diff --git a/.gitattributes b/.gitattributes index ebeb02061c4c33d9c10de13f3a63b03c5dfc0417..3bd76951d32fff6eeed948cd0a1f0c88e431f55f 100644 --- a/.gitattributes +++ b/.gitattributes @@ -252,3 +252,22 @@ shared/package-files/2d/2d1384f65f1897f0ebd3685461cdedefd4c38e9148004d66478721a5 shared/package-files/2d/2dafd96242e798bd6badf82ca2e58a75f7ae39b59e85a15a04ab6724ba6a67f1/blob filter=lfs diff=lfs merge=lfs -text shared/package-files/2d/2df214270d7c2fc2dba566a047d23e2a1ae88d8de5b64a95325511838a6e3129/blob filter=lfs diff=lfs merge=lfs -text shared/package-files/2e/2e744a910df689584b5e7f45e62723e8fcfb1951f82bbc5e5f0b385caa27a15a/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/2e/2e94bf106f33025763f512d208285c441f2344c344d4c3f3a67ba778d0589f51/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/2e/2ea4a717a746c15cfa898719b58815519482e2875a2119c5457e6f0885af589d/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/2e/2eb0e1b96a4fa1f4fcc3edbaefaf5094c583a852ee0bcf8715b1cce911477b3b/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/2f/2f1a92c18f01c13c9a89908fb86a7309ae5b89a882db9914114957bc4b6fed92/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/2f/2f1d086b642fd7ca8cde9c3c1bfbdda86f9178e42ffb035d2e285e27180f71ff/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/2f/2f2ed822742486b148167fa34eb9725a66c2686afbc4f12f2c94466d38dcb522/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/2f/2f31a0f1567cea4ce99391a914d6f783de2d33543ae3a690ca11ba51fc284327/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/2f/2f49d9e22c0ac3805fd499e23815b6310a447dad1a85541b6aadd6c7968c1ef7/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/2f/2f626635294596acca06c371a1312462b11e6cd919678eb3e244d61d4e0a2db5/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/2f/2f78bbcbca0c663f15bb1744612a35e97581a1063b99c05b6d560bc417976aa2/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/2f/2f78f2961eda0d1fbe672fd4e14692d4c36f2a6a6a570e634cb347bec89c7e35/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/2f/2f84ea0d0e55dfc231a9e4a351e6034c21fd9e9efd3f84958c10ea43fb7b1a99/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/2f/2fb9b38eba1d1b12b464d7828efc94a3c8306599909bbc7db311fab71d96d061/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/2f/2fbf3905d18dcba8e6899424c9ba60c25bce67893e84a22fbb8ea6a4a8a29b2e/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/30/30aa6a82e55c9b6882c41c9aaf9e9137c4c8c4545b627542d6b23ef5743b0acc/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/30/30e2c5853b7762551f32be245e79fd9d06e52a7cfdfd9c31bfece83405563292/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/31/3196378de7c8f842481203abc471a1e1b5f231b4c1da26fd6812cc90df38e012/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/31/31977145330b3a430a9088dcab494e4598947e5084b79e19958f694840c249e6/blob filter=lfs diff=lfs merge=lfs -text +shared/package-files/31/31b8c3d177e2f59d9cff0198d08c057aafd81f9098b9ad34eae9d7a4a7b10120/blob filter=lfs diff=lfs merge=lfs -text diff --git a/shared/package-files/2e/2e88d0c1ed7f4e4b8068130b6210fd68f61897d9fafa2f14015acb2879a18d3a/blob b/shared/package-files/2e/2e88d0c1ed7f4e4b8068130b6210fd68f61897d9fafa2f14015acb2879a18d3a/blob new file mode 100644 index 0000000000000000000000000000000000000000..61244fc51a5b06a0f955b01f8da4d29f9d2d0095 --- /dev/null +++ b/shared/package-files/2e/2e88d0c1ed7f4e4b8068130b6210fd68f61897d9fafa2f14015acb2879a18d3a/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API mkldnn_max_pool3d { + using schema = at::Tensor (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::mkldnn_max_pool3d") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "mkldnn_max_pool3d(Tensor self, int[3] kernel_size, int[3] stride=[], int[3] padding=0, int[3] dilation=1, bool ceil_mode=False) -> Tensor") + static at::Tensor call(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode); +}; + +struct TORCH_API mkldnn_max_pool3d_out { + using schema = at::Tensor & (const at::Tensor &, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, bool, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::mkldnn_max_pool3d") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "mkldnn_max_pool3d.out(Tensor self, int[3] kernel_size, int[3] stride=[], int[3] padding=0, int[3] dilation=1, bool ceil_mode=False, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef dilation, bool ceil_mode, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/2e/2e8cb9fbcd3ba9fee49adc064123d8a063d6473936ef84719fc5c5343c1352f8/blob b/shared/package-files/2e/2e8cb9fbcd3ba9fee49adc064123d8a063d6473936ef84719fc5c5343c1352f8/blob new file mode 100644 index 0000000000000000000000000000000000000000..07c9025818c34b1f1dddfbe39b6a1ed326da79e4 --- /dev/null +++ b/shared/package-files/2e/2e8cb9fbcd3ba9fee49adc064123d8a063d6473936ef84719fc5c5343c1352f8/blob @@ -0,0 +1,61 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::blackman_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor +inline at::Tensor blackman_window(int64_t window_length, at::TensorOptions options={}) { + return at::_ops::blackman_window::call(window_length, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt()); +} +// aten::blackman_window(int window_length, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor +inline at::Tensor blackman_window(int64_t window_length, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory) { + return at::_ops::blackman_window::call(window_length, dtype, layout, device, pin_memory); +} + +// aten::blackman_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor +inline at::Tensor blackman_window(int64_t window_length, bool periodic, at::TensorOptions options={}) { + return at::_ops::blackman_window_periodic::call(window_length, periodic, c10::optTypeMetaToScalarType(options.dtype_opt()), options.layout_opt(), options.device_opt(), options.pinned_memory_opt()); +} +// aten::blackman_window.periodic(int window_length, bool periodic, *, ScalarType? dtype=None, Layout? layout=None, Device? device=None, bool? pin_memory=None) -> Tensor +inline at::Tensor blackman_window(int64_t window_length, bool periodic, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory) { + return at::_ops::blackman_window_periodic::call(window_length, periodic, dtype, layout, device, pin_memory); +} + +// aten::blackman_window.out(int window_length, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & blackman_window_out(at::Tensor & out, int64_t window_length) { + return at::_ops::blackman_window_out::call(window_length, out); +} +// aten::blackman_window.out(int window_length, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & blackman_window_outf(int64_t window_length, at::Tensor & out) { + return at::_ops::blackman_window_out::call(window_length, out); +} + +// aten::blackman_window.periodic_out(int window_length, bool periodic, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & blackman_window_out(at::Tensor & out, int64_t window_length, bool periodic) { + return at::_ops::blackman_window_periodic_out::call(window_length, periodic, out); +} +// aten::blackman_window.periodic_out(int window_length, bool periodic, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & blackman_window_outf(int64_t window_length, bool periodic, at::Tensor & out) { + return at::_ops::blackman_window_periodic_out::call(window_length, periodic, out); +} + +} diff --git a/shared/package-files/2e/2e8ddec2c108827f8b40160d9e2efdc3be2ee4b4afbee5581747ba822100ad08/blob b/shared/package-files/2e/2e8ddec2c108827f8b40160d9e2efdc3be2ee4b4afbee5581747ba822100ad08/blob new file mode 100644 index 0000000000000000000000000000000000000000..01dd1f79d6582442b0932a6a252585a5d85aa0a5 --- /dev/null +++ b/shared/package-files/2e/2e8ddec2c108827f8b40160d9e2efdc3be2ee4b4afbee5581747ba822100ad08/blob @@ -0,0 +1,127 @@ +from __future__ import annotations + +from collections import deque +from functools import wraps +from typing import Any, Callable, Dict, Generic, Hashable, Tuple, TypeVar, cast + +__all__ = [ + "SimpleCache", + "FastDictCache", + "memoized", +] + +_T = TypeVar("_T", bound=Hashable) +_U = TypeVar("_U") + + +class SimpleCache(Generic[_T, _U]): + """ + Very simple cache that discards the oldest item when the cache size is + exceeded. + + :param maxsize: Maximum size of the cache. (Don't make it too big.) + """ + + def __init__(self, maxsize: int = 8) -> None: + assert maxsize > 0 + + self._data: dict[_T, _U] = {} + self._keys: deque[_T] = deque() + self.maxsize: int = maxsize + + def get(self, key: _T, getter_func: Callable[[], _U]) -> _U: + """ + Get object from the cache. + If not found, call `getter_func` to resolve it, and put that on the top + of the cache instead. + """ + # Look in cache first. + try: + return self._data[key] + except KeyError: + # Not found? Get it. + value = getter_func() + self._data[key] = value + self._keys.append(key) + + # Remove the oldest key when the size is exceeded. + if len(self._data) > self.maxsize: + key_to_remove = self._keys.popleft() + if key_to_remove in self._data: + del self._data[key_to_remove] + + return value + + def clear(self) -> None: + "Clear cache." + self._data = {} + self._keys = deque() + + +_K = TypeVar("_K", bound=Tuple[Hashable, ...]) +_V = TypeVar("_V") + + +class FastDictCache(Dict[_K, _V]): + """ + Fast, lightweight cache which keeps at most `size` items. + It will discard the oldest items in the cache first. + + The cache is a dictionary, which doesn't keep track of access counts. + It is perfect to cache little immutable objects which are not expensive to + create, but where a dictionary lookup is still much faster than an object + instantiation. + + :param get_value: Callable that's called in case of a missing key. + """ + + # NOTE: This cache is used to cache `prompt_toolkit.layout.screen.Char` and + # `prompt_toolkit.Document`. Make sure to keep this really lightweight. + # Accessing the cache should stay faster than instantiating new + # objects. + # (Dictionary lookups are really fast.) + # SimpleCache is still required for cases where the cache key is not + # the same as the arguments given to the function that creates the + # value.) + def __init__(self, get_value: Callable[..., _V], size: int = 1000000) -> None: + assert size > 0 + + self._keys: deque[_K] = deque() + self.get_value = get_value + self.size = size + + def __missing__(self, key: _K) -> _V: + # Remove the oldest key when the size is exceeded. + if len(self) > self.size: + key_to_remove = self._keys.popleft() + if key_to_remove in self: + del self[key_to_remove] + + result = self.get_value(*key) + self[key] = result + self._keys.append(key) + return result + + +_F = TypeVar("_F", bound=Callable[..., object]) + + +def memoized(maxsize: int = 1024) -> Callable[[_F], _F]: + """ + Memoization decorator for immutable classes and pure functions. + """ + + def decorator(obj: _F) -> _F: + cache: SimpleCache[Hashable, Any] = SimpleCache(maxsize=maxsize) + + @wraps(obj) + def new_callable(*a: Any, **kw: Any) -> Any: + def create_new() -> Any: + return obj(*a, **kw) + + key = (a, tuple(sorted(kw.items()))) + return cache.get(key, create_new) + + return cast(_F, new_callable) + + return decorator diff --git a/shared/package-files/2e/2e8f346967d8aefa3f5bf5314c8b264258a54402618c9e0cb5852018dad8bc68/blob b/shared/package-files/2e/2e8f346967d8aefa3f5bf5314c8b264258a54402618c9e0cb5852018dad8bc68/blob new file mode 100644 index 0000000000000000000000000000000000000000..cbbdcbd019121541d352e98b4936e0099c9dad54 --- /dev/null +++ b/shared/package-files/2e/2e8f346967d8aefa3f5bf5314c8b264258a54402618c9e0cb5852018dad8bc68/blob @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor _nested_tensor_from_mask(const at::Tensor & t, const at::Tensor & mask, bool mask_check=true); + +} // namespace cuda +} // namespace at diff --git a/shared/package-files/2e/2e93737d50bd68e6fba65dcc677e569a85d58f5a9d26ddb307756f823f6f3ad3/blob b/shared/package-files/2e/2e93737d50bd68e6fba65dcc677e569a85d58f5a9d26ddb307756f823f6f3ad3/blob new file mode 100644 index 0000000000000000000000000000000000000000..26bf9e33c217e1467ade2f0a68db013fa9f2f3eb --- /dev/null +++ b/shared/package-files/2e/2e93737d50bd68e6fba65dcc677e569a85d58f5a9d26ddb307756f823f6f3ad3/blob @@ -0,0 +1,25 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace native { +struct TORCH_API structured_hardsigmoid_out : public at::meta::structured_hardsigmoid { +void impl(const at::Tensor & self, const at::Tensor & out); +}; +TORCH_API at::Tensor hardsigmoid_quantized_cpu(const at::Tensor & self); +TORCH_API at::Tensor & hardsigmoid_out_quantized_cpu(const at::Tensor & self, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/shared/package-files/2e/2e94bf106f33025763f512d208285c441f2344c344d4c3f3a67ba778d0589f51/blob b/shared/package-files/2e/2e94bf106f33025763f512d208285c441f2344c344d4c3f3a67ba778d0589f51/blob new file mode 100644 index 0000000000000000000000000000000000000000..01a9f922df70aa77e45221c0b7d8fecb68d03967 --- /dev/null +++ b/shared/package-files/2e/2e94bf106f33025763f512d208285c441f2344c344d4c3f3a67ba778d0589f51/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2e94bf106f33025763f512d208285c441f2344c344d4c3f3a67ba778d0589f51 +size 695056 diff --git a/shared/package-files/2e/2e9b428e5ad448f442fdcea301508c046ad8062b56a8b2b560837481ecec51ce/blob b/shared/package-files/2e/2e9b428e5ad448f442fdcea301508c046ad8062b56a8b2b560837481ecec51ce/blob new file mode 100644 index 0000000000000000000000000000000000000000..735f259d33650131331c78dc7726521c5c2ae7fa --- /dev/null +++ b/shared/package-files/2e/2e9b428e5ad448f442fdcea301508c046ad8062b56a8b2b560837481ecec51ce/blob @@ -0,0 +1,11 @@ +from packaging.version import Version, parse + +try: + import matplotlib as mpl + + version = parse(mpl.__version__) + MPL_LT_310 = version < Version("3.9.99") +except ImportError: + MPL_LT_310 = False + +__all__ = ["MPL_LT_310"] diff --git a/shared/package-files/2e/2e9b54587398ac57cd835fbc70d10cc43a10cc2743b60ba286056819bd100bd3/blob b/shared/package-files/2e/2e9b54587398ac57cd835fbc70d10cc43a10cc2743b60ba286056819bd100bd3/blob new file mode 100644 index 0000000000000000000000000000000000000000..e0c4b6e2ae4ef9e5f228afa8ab7ebbfd6df8f1a7 --- /dev/null +++ b/shared/package-files/2e/2e9b54587398ac57cd835fbc70d10cc43a10cc2743b60ba286056819bd100bd3/blob @@ -0,0 +1,652 @@ +from sympy.core import ( + Basic, Rational, Symbol, S, Float, Integer, Mul, Number, Pow, + Expr, I, nan, pi, symbols, oo, zoo, N) +from sympy.core.parameters import global_parameters +from sympy.core.tests.test_evalf import NS +from sympy.core.function import expand_multinomial +from sympy.functions.elementary.miscellaneous import sqrt, cbrt +from sympy.functions.elementary.exponential import exp, log +from sympy.functions.special.error_functions import erf +from sympy.functions.elementary.trigonometric import ( + sin, cos, tan, sec, csc, atan) +from sympy.functions.elementary.hyperbolic import cosh, sinh, tanh +from sympy.polys import Poly +from sympy.series.order import O +from sympy.sets import FiniteSet +from sympy.core.power import power, integer_nthroot +from sympy.testing.pytest import warns, _both_exp_pow +from sympy.utilities.exceptions import SymPyDeprecationWarning +from sympy.abc import a, b, c, x, y + +def test_rational(): + a = Rational(1, 5) + + r = sqrt(5)/5 + assert sqrt(a) == r + assert 2*sqrt(a) == 2*r + + r = a*a**S.Half + assert a**Rational(3, 2) == r + assert 2*a**Rational(3, 2) == 2*r + + r = a**5*a**Rational(2, 3) + assert a**Rational(17, 3) == r + assert 2 * a**Rational(17, 3) == 2*r + + +def test_large_rational(): + e = (Rational(123712**12 - 1, 7) + Rational(1, 7))**Rational(1, 3) + assert e == 234232585392159195136 * (Rational(1, 7)**Rational(1, 3)) + + +def test_negative_real(): + def feq(a, b): + return abs(a - b) < 1E-10 + + assert feq(S.One / Float(-0.5), -Integer(2)) + + +def test_expand(): + assert (2**(-1 - x)).expand() == S.Half*2**(-x) + + +def test_issue_3449(): + #test if powers are simplified correctly + #see also issue 3995 + assert ((x**Rational(1, 3))**Rational(2)) == x**Rational(2, 3) + assert ( + (x**Rational(3))**Rational(2, 5)) == (x**Rational(3))**Rational(2, 5) + + a = Symbol('a', real=True) + b = Symbol('b', real=True) + assert (a**2)**b == (abs(a)**b)**2 + assert sqrt(1/a) != 1/sqrt(a) # e.g. for a = -1 + assert (a**3)**Rational(1, 3) != a + assert (x**a)**b != x**(a*b) # e.g. x = -1, a=2, b=1/2 + assert (x**.5)**b == x**(.5*b) + assert (x**.5)**.5 == x**.25 + assert (x**2.5)**.5 != x**1.25 # e.g. for x = 5*I + + k = Symbol('k', integer=True) + m = Symbol('m', integer=True) + assert (x**k)**m == x**(k*m) + assert Number(5)**Rational(2, 3) == Number(25)**Rational(1, 3) + + assert (x**.5)**2 == x**1.0 + assert (x**2)**k == (x**k)**2 == x**(2*k) + + a = Symbol('a', positive=True) + assert (a**3)**Rational(2, 5) == a**Rational(6, 5) + assert (a**2)**b == (a**b)**2 + assert (a**Rational(2, 3))**x == a**(x*Rational(2, 3)) != (a**x)**Rational(2, 3) + + +def test_issue_3866(): + assert --sqrt(sqrt(5) - 1) == sqrt(sqrt(5) - 1) + + +def test_negative_one(): + x = Symbol('x', complex=True) + y = Symbol('y', complex=True) + assert 1/x**y == x**(-y) + + +def test_issue_4362(): + neg = Symbol('neg', negative=True) + nonneg = Symbol('nonneg', nonnegative=True) + any = Symbol('any') + num, den = sqrt(1/neg).as_numer_denom() + assert num == sqrt(-1) + assert den == sqrt(-neg) + num, den = sqrt(1/nonneg).as_numer_denom() + assert num == 1 + assert den == sqrt(nonneg) + num, den = sqrt(1/any).as_numer_denom() + assert num == sqrt(1/any) + assert den == 1 + + def eqn(num, den, pow): + return (num/den)**pow + npos = 1 + nneg = -1 + dpos = 2 - sqrt(3) + dneg = 1 - sqrt(3) + assert dpos > 0 and dneg < 0 and npos > 0 and nneg < 0 + # pos or neg integer + eq = eqn(npos, dpos, 2) + assert eq.is_Pow and eq.as_numer_denom() == (1, dpos**2) + eq = eqn(npos, dneg, 2) + assert eq.is_Pow and eq.as_numer_denom() == (1, dneg**2) + eq = eqn(nneg, dpos, 2) + assert eq.is_Pow and eq.as_numer_denom() == (1, dpos**2) + eq = eqn(nneg, dneg, 2) + assert eq.is_Pow and eq.as_numer_denom() == (1, dneg**2) + eq = eqn(npos, dpos, -2) + assert eq.is_Pow and eq.as_numer_denom() == (dpos**2, 1) + eq = eqn(npos, dneg, -2) + assert eq.is_Pow and eq.as_numer_denom() == (dneg**2, 1) + eq = eqn(nneg, dpos, -2) + assert eq.is_Pow and eq.as_numer_denom() == (dpos**2, 1) + eq = eqn(nneg, dneg, -2) + assert eq.is_Pow and eq.as_numer_denom() == (dneg**2, 1) + # pos or neg rational + pow = S.Half + eq = eqn(npos, dpos, pow) + assert eq.is_Pow and eq.as_numer_denom() == (npos**pow, dpos**pow) + eq = eqn(npos, dneg, pow) + assert eq.is_Pow is False and eq.as_numer_denom() == ((-npos)**pow, (-dneg)**pow) + eq = eqn(nneg, dpos, pow) + assert not eq.is_Pow or eq.as_numer_denom() == (nneg**pow, dpos**pow) + eq = eqn(nneg, dneg, pow) + assert eq.is_Pow and eq.as_numer_denom() == ((-nneg)**pow, (-dneg)**pow) + eq = eqn(npos, dpos, -pow) + assert eq.is_Pow and eq.as_numer_denom() == (dpos**pow, npos**pow) + eq = eqn(npos, dneg, -pow) + assert eq.is_Pow is False and eq.as_numer_denom() == (-(-npos)**pow*(-dneg)**pow, npos) + eq = eqn(nneg, dpos, -pow) + assert not eq.is_Pow or eq.as_numer_denom() == (dpos**pow, nneg**pow) + eq = eqn(nneg, dneg, -pow) + assert eq.is_Pow and eq.as_numer_denom() == ((-dneg)**pow, (-nneg)**pow) + # unknown exponent + pow = 2*any + eq = eqn(npos, dpos, pow) + assert eq.is_Pow and eq.as_numer_denom() == (npos**pow, dpos**pow) + eq = eqn(npos, dneg, pow) + assert eq.is_Pow and eq.as_numer_denom() == ((-npos)**pow, (-dneg)**pow) + eq = eqn(nneg, dpos, pow) + assert eq.is_Pow and eq.as_numer_denom() == (nneg**pow, dpos**pow) + eq = eqn(nneg, dneg, pow) + assert eq.is_Pow and eq.as_numer_denom() == ((-nneg)**pow, (-dneg)**pow) + eq = eqn(npos, dpos, -pow) + assert eq.as_numer_denom() == (dpos**pow, npos**pow) + eq = eqn(npos, dneg, -pow) + assert eq.is_Pow and eq.as_numer_denom() == ((-dneg)**pow, (-npos)**pow) + eq = eqn(nneg, dpos, -pow) + assert eq.is_Pow and eq.as_numer_denom() == (dpos**pow, nneg**pow) + eq = eqn(nneg, dneg, -pow) + assert eq.is_Pow and eq.as_numer_denom() == ((-dneg)**pow, (-nneg)**pow) + + assert ((1/(1 + x/3))**(-S.One)).as_numer_denom() == (3 + x, 3) + notp = Symbol('notp', positive=False) # not positive does not imply real + b = ((1 + x/notp)**-2) + assert (b**(-y)).as_numer_denom() == (1, b**y) + assert (b**(-S.One)).as_numer_denom() == ((notp + x)**2, notp**2) + nonp = Symbol('nonp', nonpositive=True) + assert (((1 + x/nonp)**-2)**(-S.One)).as_numer_denom() == ((-nonp - + x)**2, nonp**2) + + n = Symbol('n', negative=True) + assert (x**n).as_numer_denom() == (1, x**-n) + assert sqrt(1/n).as_numer_denom() == (S.ImaginaryUnit, sqrt(-n)) + n = Symbol('0 or neg', nonpositive=True) + # if x and n are split up without negating each term and n is negative + # then the answer might be wrong; if n is 0 it won't matter since + # 1/oo and 1/zoo are both zero as is sqrt(0)/sqrt(-x) unless x is also + # zero (in which case the negative sign doesn't matter): + # 1/sqrt(1/-1) = -I but sqrt(-1)/sqrt(1) = I + assert (1/sqrt(x/n)).as_numer_denom() == (sqrt(-n), sqrt(-x)) + c = Symbol('c', complex=True) + e = sqrt(1/c) + assert e.as_numer_denom() == (e, 1) + i = Symbol('i', integer=True) + assert ((1 + x/y)**i).as_numer_denom() == ((x + y)**i, y**i) + + +def test_Pow_Expr_args(): + bases = [Basic(), Poly(x, x), FiniteSet(x)] + for base in bases: + # The cache can mess with the stacklevel test + with warns(SymPyDeprecationWarning, test_stacklevel=False): + Pow(base, S.One) + + +def test_Pow_signs(): + """Cf. issues 4595 and 5250""" + n = Symbol('n', even=True) + assert (3 - y)**2 != (y - 3)**2 + assert (3 - y)**n != (y - 3)**n + assert (-3 + y - x)**2 != (3 - y + x)**2 + assert (y - 3)**3 != -(3 - y)**3 + + +def test_power_with_noncommutative_mul_as_base(): + x = Symbol('x', commutative=False) + y = Symbol('y', commutative=False) + assert not (x*y)**3 == x**3*y**3 + assert (2*x*y)**3 == 8*(x*y)**3 + + +@_both_exp_pow +def test_power_rewrite_exp(): + assert (I**I).rewrite(exp) == exp(-pi/2) + + expr = (2 + 3*I)**(4 + 5*I) + assert expr.rewrite(exp) == exp((4 + 5*I)*(log(sqrt(13)) + I*atan(Rational(3, 2)))) + assert expr.rewrite(exp).expand() == \ + 169*exp(5*I*log(13)/2)*exp(4*I*atan(Rational(3, 2)))*exp(-5*atan(Rational(3, 2))) + + assert ((6 + 7*I)**5).rewrite(exp) == 7225*sqrt(85)*exp(5*I*atan(Rational(7, 6))) + + expr = 5**(6 + 7*I) + assert expr.rewrite(exp) == exp((6 + 7*I)*log(5)) + assert expr.rewrite(exp).expand() == 15625*exp(7*I*log(5)) + + assert Pow(123, 789, evaluate=False).rewrite(exp) == 123**789 + assert (1**I).rewrite(exp) == 1**I + assert (0**I).rewrite(exp) == 0**I + + expr = (-2)**(2 + 5*I) + assert expr.rewrite(exp) == exp((2 + 5*I)*(log(2) + I*pi)) + assert expr.rewrite(exp).expand() == 4*exp(-5*pi)*exp(5*I*log(2)) + + assert ((-2)**S(-5)).rewrite(exp) == (-2)**S(-5) + + x, y = symbols('x y') + assert (x**y).rewrite(exp) == exp(y*log(x)) + if global_parameters.exp_is_pow: + assert (7**x).rewrite(exp) == Pow(S.Exp1, x*log(7), evaluate=False) + else: + assert (7**x).rewrite(exp) == exp(x*log(7), evaluate=False) + assert ((2 + 3*I)**x).rewrite(exp) == exp(x*(log(sqrt(13)) + I*atan(Rational(3, 2)))) + assert (y**(5 + 6*I)).rewrite(exp) == exp(log(y)*(5 + 6*I)) + + assert all((1/func(x)).rewrite(exp) == 1/(func(x).rewrite(exp)) for func in + (sin, cos, tan, sec, csc, sinh, cosh, tanh)) + + +def test_zero(): + assert 0**x != 0 + assert 0**(2*x) == 0**x + assert 0**(1.0*x) == 0**x + assert 0**(2.0*x) == 0**x + assert (0**(2 - x)).as_base_exp() == (0, 2 - x) + assert 0**(x - 2) != S.Infinity**(2 - x) + assert 0**(2*x*y) == 0**(x*y) + assert 0**(-2*x*y) == S.ComplexInfinity**(x*y) + assert Float(0)**2 is not S.Zero + assert Float(0)**2 == 0.0 + assert Float(0)**-2 is zoo + assert Float(0)**oo is S.Zero + + #Test issue 19572 + assert 0 ** -oo is zoo + assert power(0, -oo) is zoo + assert Float(0)**-oo is zoo + +def test_pow_as_base_exp(): + assert (S.Infinity**(2 - x)).as_base_exp() == (S.Infinity, 2 - x) + assert (S.Infinity**(x - 2)).as_base_exp() == (S.Infinity, x - 2) + p = S.Half**x + assert p.base, p.exp == p.as_base_exp() == (S(2), -x) + p = (S(3)/2)**x + assert p.base, p.exp == p.as_base_exp() == (3*S.Half, x) + p = (S(2)/3)**x + assert p.as_base_exp() == (S(3)/2, -x) + assert p.base, p.exp == (S(2)/3, x) + # issue 8344: + assert Pow(1, 2, evaluate=False).as_base_exp() == (S.One, S(2)) + + +def test_nseries(): + assert sqrt(I*x - 1)._eval_nseries(x, 4, None, 1) == I + x/2 + I*x**2/8 - x**3/16 + O(x**4) + assert sqrt(I*x - 1)._eval_nseries(x, 4, None, -1) == -I - x/2 - I*x**2/8 + x**3/16 + O(x**4) + assert cbrt(I*x - 1)._eval_nseries(x, 4, None, 1) == (-1)**(S(1)/3) - (-1)**(S(5)/6)*x/3 + \ + (-1)**(S(1)/3)*x**2/9 + 5*(-1)**(S(5)/6)*x**3/81 + O(x**4) + assert cbrt(I*x - 1)._eval_nseries(x, 4, None, -1) == -(-1)**(S(2)/3) - (-1)**(S(1)/6)*x/3 - \ + (-1)**(S(2)/3)*x**2/9 + 5*(-1)**(S(1)/6)*x**3/81 + O(x**4) + assert (1 / (exp(-1/x) + 1/x))._eval_nseries(x, 2, None) == x + O(x**2) + # test issue 23752 + assert sqrt(-I*x**2 + x - 3)._eval_nseries(x, 4, None, 1) == -sqrt(3)*I + sqrt(3)*I*x/6 - \ + sqrt(3)*I*x**2*(-S(1)/72 + I/6) - sqrt(3)*I*x**3*(-S(1)/432 + I/36) + O(x**4) + assert sqrt(-I*x**2 + x - 3)._eval_nseries(x, 4, None, -1) == -sqrt(3)*I + sqrt(3)*I*x/6 - \ + sqrt(3)*I*x**2*(-S(1)/72 + I/6) - sqrt(3)*I*x**3*(-S(1)/432 + I/36) + O(x**4) + assert cbrt(-I*x**2 + x - 3)._eval_nseries(x, 4, None, 1) == -(-1)**(S(2)/3)*3**(S(1)/3) + \ + (-1)**(S(2)/3)*3**(S(1)/3)*x/9 - (-1)**(S(2)/3)*3**(S(1)/3)*x**2*(-S(1)/81 + I/9) - \ + (-1)**(S(2)/3)*3**(S(1)/3)*x**3*(-S(5)/2187 + 2*I/81) + O(x**4) + assert cbrt(-I*x**2 + x - 3)._eval_nseries(x, 4, None, -1) == -(-1)**(S(2)/3)*3**(S(1)/3) + \ + (-1)**(S(2)/3)*3**(S(1)/3)*x/9 - (-1)**(S(2)/3)*3**(S(1)/3)*x**2*(-S(1)/81 + I/9) - \ + (-1)**(S(2)/3)*3**(S(1)/3)*x**3*(-S(5)/2187 + 2*I/81) + O(x**4) + + +def test_issue_6100_12942_4473(): + assert x**1.0 != x + assert x != x**1.0 + assert True != x**1.0 + assert x**1.0 is not True + assert x is not True + assert x*y != (x*y)**1.0 + # Pow != Symbol + assert (x**1.0)**1.0 != x + assert (x**1.0)**2.0 != x**2 + b = Expr() + assert Pow(b, 1.0, evaluate=False) != b + # if the following gets distributed as a Mul (x**1.0*y**1.0 then + # __eq__ methods could be added to Symbol and Pow to detect the + # power-of-1.0 case. + assert ((x*y)**1.0).func is Pow + + +def test_issue_6208(): + from sympy.functions.elementary.miscellaneous import root + assert sqrt(33**(I*9/10)) == -33**(I*9/20) + assert root((6*I)**(2*I), 3).as_base_exp()[1] == Rational(1, 3) # != 2*I/3 + assert root((6*I)**(I/3), 3).as_base_exp()[1] == I/9 + assert sqrt(exp(3*I)) == exp(3*I/2) + assert sqrt(-sqrt(3)*(1 + 2*I)) == sqrt(sqrt(3))*sqrt(-1 - 2*I) + assert sqrt(exp(5*I)) == -exp(5*I/2) + assert root(exp(5*I), 3).exp == Rational(1, 3) + + +def test_issue_6990(): + assert (sqrt(a + b*x + x**2)).series(x, 0, 3).removeO() == \ + sqrt(a)*x**2*(1/(2*a) - b**2/(8*a**2)) + sqrt(a) + b*x/(2*sqrt(a)) + + +def test_issue_6068(): + assert sqrt(sin(x)).series(x, 0, 7) == \ + sqrt(x) - x**Rational(5, 2)/12 + x**Rational(9, 2)/1440 - \ + x**Rational(13, 2)/24192 + O(x**7) + assert sqrt(sin(x)).series(x, 0, 9) == \ + sqrt(x) - x**Rational(5, 2)/12 + x**Rational(9, 2)/1440 - \ + x**Rational(13, 2)/24192 - 67*x**Rational(17, 2)/29030400 + O(x**9) + assert sqrt(sin(x**3)).series(x, 0, 19) == \ + x**Rational(3, 2) - x**Rational(15, 2)/12 + x**Rational(27, 2)/1440 + O(x**19) + assert sqrt(sin(x**3)).series(x, 0, 20) == \ + x**Rational(3, 2) - x**Rational(15, 2)/12 + x**Rational(27, 2)/1440 - \ + x**Rational(39, 2)/24192 + O(x**20) + + +def test_issue_6782(): + assert sqrt(sin(x**3)).series(x, 0, 7) == x**Rational(3, 2) + O(x**7) + assert sqrt(sin(x**4)).series(x, 0, 3) == x**2 + O(x**3) + + +def test_issue_6653(): + assert (1 / sqrt(1 + sin(x**2))).series(x, 0, 3) == 1 - x**2/2 + O(x**3) + + +def test_issue_6429(): + f = (c**2 + x)**(0.5) + assert f.series(x, x0=0, n=1) == (c**2)**0.5 + O(x) + assert f.taylor_term(0, x) == (c**2)**0.5 + assert f.taylor_term(1, x) == 0.5*x*(c**2)**(-0.5) + assert f.taylor_term(2, x) == -0.125*x**2*(c**2)**(-1.5) + + +def test_issue_7638(): + f = pi/log(sqrt(2)) + assert ((1 + I)**(I*f/2))**0.3 == (1 + I)**(0.15*I*f) + # if 1/3 -> 1.0/3 this should fail since it cannot be shown that the + # sign will be +/-1; for the previous "small arg" case, it didn't matter + # that this could not be proved + assert (1 + I)**(4*I*f) == ((1 + I)**(12*I*f))**Rational(1, 3) + + assert (((1 + I)**(I*(1 + 7*f)))**Rational(1, 3)).exp == Rational(1, 3) + r = symbols('r', real=True) + assert sqrt(r**2) == abs(r) + assert cbrt(r**3) != r + assert sqrt(Pow(2*I, 5*S.Half)) != (2*I)**Rational(5, 4) + p = symbols('p', positive=True) + assert cbrt(p**2) == p**Rational(2, 3) + assert NS(((0.2 + 0.7*I)**(0.7 + 1.0*I))**(0.5 - 0.1*I), 1) == '0.4 + 0.2*I' + assert sqrt(1/(1 + I)) == sqrt(1 - I)/sqrt(2) # or 1/sqrt(1 + I) + e = 1/(1 - sqrt(2)) + assert sqrt(e) == I/sqrt(-1 + sqrt(2)) + assert e**Rational(-1, 2) == -I*sqrt(-1 + sqrt(2)) + assert sqrt((cos(1)**2 + sin(1)**2 - 1)**(3 + I)).exp in [S.Half, + Rational(3, 2) + I/2] + assert sqrt(r**Rational(4, 3)) != r**Rational(2, 3) + assert sqrt((p + I)**Rational(4, 3)) == (p + I)**Rational(2, 3) + + for q in 1+I, 1-I: + assert sqrt(q**2) == q + for q in -1+I, -1-I: + assert sqrt(q**2) == -q + + assert sqrt((p + r*I)**2) != p + r*I + e = (1 + I/5) + assert sqrt(e**5) == e**(5*S.Half) + assert sqrt(e**6) == e**3 + assert sqrt((1 + I*r)**6) != (1 + I*r)**3 + + +def test_issue_8582(): + assert 1**oo is nan + assert 1**(-oo) is nan + assert 1**zoo is nan + assert 1**(oo + I) is nan + assert 1**(1 + I*oo) is nan + assert 1**(oo + I*oo) is nan + + +def test_issue_8650(): + n = Symbol('n', integer=True, nonnegative=True) + assert (n**n).is_positive is True + x = 5*n + 5 + assert (x**(5*(n + 1))).is_positive is True + + +def test_issue_13914(): + b = Symbol('b') + assert (-1)**zoo is nan + assert 2**zoo is nan + assert (S.Half)**(1 + zoo) is nan + assert I**(zoo + I) is nan + assert b**(I + zoo) is nan + + +def test_better_sqrt(): + n = Symbol('n', integer=True, nonnegative=True) + assert sqrt(3 + 4*I) == 2 + I + assert sqrt(3 - 4*I) == 2 - I + assert sqrt(-3 - 4*I) == 1 - 2*I + assert sqrt(-3 + 4*I) == 1 + 2*I + assert sqrt(32 + 24*I) == 6 + 2*I + assert sqrt(32 - 24*I) == 6 - 2*I + assert sqrt(-32 - 24*I) == 2 - 6*I + assert sqrt(-32 + 24*I) == 2 + 6*I + + # triple (3, 4, 5): + # parity of 3 matches parity of 5 and + # den, 4, is a square + assert sqrt((3 + 4*I)/4) == 1 + I/2 + # triple (8, 15, 17) + # parity of 8 doesn't match parity of 17 but + # den/2, 8/2, is a square + assert sqrt((8 + 15*I)/8) == (5 + 3*I)/4 + # handle the denominator + assert sqrt((3 - 4*I)/25) == (2 - I)/5 + assert sqrt((3 - 4*I)/26) == (2 - I)/sqrt(26) + # mul + # issue #12739 + assert sqrt((3 + 4*I)/(3 - 4*I)) == (3 + 4*I)/5 + assert sqrt(2/(3 + 4*I)) == sqrt(2)/5*(2 - I) + assert sqrt(n/(3 + 4*I)).subs(n, 2) == sqrt(2)/5*(2 - I) + assert sqrt(-2/(3 + 4*I)) == sqrt(2)/5*(1 + 2*I) + assert sqrt(-n/(3 + 4*I)).subs(n, 2) == sqrt(2)/5*(1 + 2*I) + # power + assert sqrt(1/(3 + I*4)) == (2 - I)/5 + assert sqrt(1/(3 - I)) == sqrt(10)*sqrt(3 + I)/10 + # symbolic + i = symbols('i', imaginary=True) + assert sqrt(3/i) == Mul(sqrt(3), 1/sqrt(i), evaluate=False) + # multiples of 1/2; don't make this too automatic + assert sqrt(3 + 4*I)**3 == (2 + I)**3 + assert Pow(3 + 4*I, Rational(3, 2)) == 2 + 11*I + assert Pow(6 + 8*I, Rational(3, 2)) == 2*sqrt(2)*(2 + 11*I) + n, d = (3 + 4*I), (3 - 4*I)**3 + a = n/d + assert a.args == (1/d, n) + eq = sqrt(a) + assert eq.args == (a, S.Half) + assert expand_multinomial(eq) == sqrt((-117 + 44*I)*(3 + 4*I))/125 + assert eq.expand() == (7 - 24*I)/125 + + # issue 12775 + # pos im part + assert sqrt(2*I) == (1 + I) + assert sqrt(2*9*I) == Mul(3, 1 + I, evaluate=False) + assert Pow(2*I, 3*S.Half) == (1 + I)**3 + # neg im part + assert sqrt(-I/2) == Mul(S.Half, 1 - I, evaluate=False) + # fractional im part + assert Pow(Rational(-9, 2)*I, Rational(3, 2)) == 27*(1 - I)**3/8 + + +def test_issue_2993(): + assert str((2.3*x - 4)**0.3) == '1.5157165665104*(0.575*x - 1)**0.3' + assert str((2.3*x + 4)**0.3) == '1.5157165665104*(0.575*x + 1)**0.3' + assert str((-2.3*x + 4)**0.3) == '1.5157165665104*(1 - 0.575*x)**0.3' + assert str((-2.3*x - 4)**0.3) == '1.5157165665104*(-0.575*x - 1)**0.3' + assert str((2.3*x - 2)**0.3) == '1.28386201800527*(x - 0.869565217391304)**0.3' + assert str((-2.3*x - 2)**0.3) == '1.28386201800527*(-x - 0.869565217391304)**0.3' + assert str((-2.3*x + 2)**0.3) == '1.28386201800527*(0.869565217391304 - x)**0.3' + assert str((2.3*x + 2)**0.3) == '1.28386201800527*(x + 0.869565217391304)**0.3' + assert str((2.3*x - 4)**Rational(1, 3)) == '2**(2/3)*(0.575*x - 1)**(1/3)' + eq = (2.3*x + 4) + assert eq**2 == 16*(0.575*x + 1)**2 + assert (1/eq).args == (eq, -1) # don't change trivial power + # issue 17735 + q=.5*exp(x) - .5*exp(-x) + 0.1 + assert int((q**2).subs(x, 1)) == 1 + # issue 17756 + y = Symbol('y') + assert len(sqrt(x/(x + y)**2 + Float('0.008', 30)).subs(y, pi.n(25)).atoms(Float)) == 2 + # issue 17756 + a, b, c, d, e, f, g = symbols('a:g') + expr = sqrt(1 + a*(c**4 + g*d - 2*g*e - f*(-g + d))**2/ + (c**3*b**2*(d - 3*e + 2*f)**2))/2 + r = [ + (a, N('0.0170992456333788667034850458615', 30)), + (b, N('0.0966594956075474769169134801223', 30)), + (c, N('0.390911862903463913632151616184', 30)), + (d, N('0.152812084558656566271750185933', 30)), + (e, N('0.137562344465103337106561623432', 30)), + (f, N('0.174259178881496659302933610355', 30)), + (g, N('0.220745448491223779615401870086', 30))] + tru = expr.n(30, subs=dict(r)) + seq = expr.subs(r) + # although `tru` is the right way to evaluate + # expr with numerical values, `seq` will have + # significant loss of precision if extraction of + # the largest coefficient of a power's base's terms + # is done improperly + assert seq == tru + +def test_issue_17450(): + assert (erf(cosh(1)**7)**I).is_real is None + assert (erf(cosh(1)**7)**I).is_imaginary is False + assert (Pow(exp(1+sqrt(2)), ((1-sqrt(2))*I*pi), evaluate=False)).is_real is None + assert ((-10)**(10*I*pi/3)).is_real is False + assert ((-5)**(4*I*pi)).is_real is False + + +def test_issue_18190(): + assert sqrt(1 / tan(1 + I)) == 1 / sqrt(tan(1 + I)) + + +def test_issue_14815(): + x = Symbol('x', real=True) + assert sqrt(x).is_extended_negative is False + x = Symbol('x', real=False) + assert sqrt(x).is_extended_negative is None + x = Symbol('x', complex=True) + assert sqrt(x).is_extended_negative is False + x = Symbol('x', extended_real=True) + assert sqrt(x).is_extended_negative is False + assert sqrt(zoo, evaluate=False).is_extended_negative is None + assert sqrt(nan, evaluate=False).is_extended_negative is None + + +def test_issue_18509(): + x = Symbol('x', prime=True) + assert x**oo is oo + assert (1/x)**oo is S.Zero + assert (-1/x)**oo is S.Zero + assert (-x)**oo is zoo + assert (-oo)**(-1 + I) is S.Zero + assert (-oo)**(1 + I) is zoo + assert (oo)**(-1 + I) is S.Zero + assert (oo)**(1 + I) is zoo + + +def test_issue_18762(): + e, p = symbols('e p') + g0 = sqrt(1 + e**2 - 2*e*cos(p)) + assert len(g0.series(e, 1, 3).args) == 4 + + +def test_issue_21860(): + e = 3*2**Rational(66666666667,200000000000)*3**Rational(16666666667,50000000000)*x**Rational(66666666667, 200000000000) + ans = Mul(Rational(3, 2), + Pow(Integer(2), Rational(33333333333, 100000000000)), + Pow(Integer(3), Rational(26666666667, 40000000000))) + assert e.xreplace({x: Rational(3,8)}) == ans + + +def test_issue_21647(): + e = log((Integer(567)/500)**(811*(Integer(567)/500)**x/100)) + ans = log(Mul(Rational(64701150190720499096094005280169087619821081527, + 76293945312500000000000000000000000000000000000), + Pow(Integer(2), Rational(396204892125479941, 781250000000000000)), + Pow(Integer(3), Rational(385045107874520059, 390625000000000000)), + Pow(Integer(5), Rational(407364676376439823, 1562500000000000000)), + Pow(Integer(7), Rational(385045107874520059, 1562500000000000000)))) + assert e.xreplace({x: 6}) == ans + + +def test_issue_21762(): + e = (x**2 + 6)**(Integer(33333333333333333)/50000000000000000) + ans = Mul(Rational(5, 4), + Pow(Integer(2), Rational(16666666666666667, 25000000000000000)), + Pow(Integer(5), Rational(8333333333333333, 25000000000000000))) + assert e.xreplace({x: S.Half}) == ans + + +def test_issue_14704(): + a = 144**144 + x, xexact = integer_nthroot(a,a) + assert x == 1 and xexact is False + + +def test_rational_powers_larger_than_one(): + assert Rational(2, 3)**Rational(3, 2) == 2*sqrt(6)/9 + assert Rational(1, 6)**Rational(9, 4) == 6**Rational(3, 4)/216 + assert Rational(3, 7)**Rational(7, 3) == 9*3**Rational(1, 3)*7**Rational(2, 3)/343 + + +def test_power_dispatcher(): + + class NewBase(Expr): + pass + class NewPow(NewBase, Pow): + pass + a, b = Symbol('a'), NewBase() + + @power.register(Expr, NewBase) + @power.register(NewBase, Expr) + @power.register(NewBase, NewBase) + def _(a, b): + return NewPow(a, b) + + # Pow called as fallback + assert power(2, 3) == 8*S.One + assert power(a, 2) == Pow(a, 2) + assert power(a, a) == Pow(a, a) + + # NewPow called by dispatch + assert power(a, b) == NewPow(a, b) + assert power(b, a) == NewPow(b, a) + assert power(b, b) == NewPow(b, b) + + +def test_powers_of_I(): + assert [sqrt(I)**i for i in range(13)] == [ + 1, sqrt(I), I, sqrt(I)**3, -1, -sqrt(I), -I, -sqrt(I)**3, + 1, sqrt(I), I, sqrt(I)**3, -1] + assert sqrt(I)**(S(9)/2) == -I**(S(1)/4) + + +def test_issue_23918(): + b = S(2)/3 + assert (b**x).as_base_exp() == (1/b, -x) diff --git a/shared/package-files/2e/2e9d04897257e83b6fec7fe1c0a06913709a4df371b9c90ebfa3c75c9f749ed2/blob b/shared/package-files/2e/2e9d04897257e83b6fec7fe1c0a06913709a4df371b9c90ebfa3c75c9f749ed2/blob new file mode 100644 index 0000000000000000000000000000000000000000..84e1c0d17647de5fd4d7817f686ea25f66e1424a --- /dev/null +++ b/shared/package-files/2e/2e9d04897257e83b6fec7fe1c0a06913709a4df371b9c90ebfa3c75c9f749ed2/blob @@ -0,0 +1,61 @@ +x,weights,x_gau_wd,x_epa_wd,x_epan2_wd,x_bi_wd,x_par_wd,x_tri_wd,x_cos_wd,x_rec_wd +.50370319,.60467487,.27195577,.27358917,.28859682,.30192719,.31283399,.29793749,.31904846,.25210428 +.41308592,.60446553,.28380106,.28108376,.3181792,.32885763,.34548845,.32667957,.3553171,.3010559 +-1.13905,.84897398,.26095184,.24941442,.32307763,.34872245,.38725314,.34866867,.42649716,.30003257 +.66034203,.89616498,.2498343,.25886883,.24541009,.23760925,.23485521,.24529473,.23002624,.2627293 +.46479403,.58916777,.27716742,.27709199,.30071519,.31461812,.3288969,.31115181,.33274659,.27792568 +-.30933686,.92004553,.314696,.31804133,.34663542,.35808323,.38279667,.36339898,.44094594,.31994675 +-.64959307,.73271562,.29736955,.31088207,.25708713,.24806417,.2539103,.26299651,.28856418,.30887871 +.68375801,.31006212,.24646059,.25568508,.23632094,.22824775,.22264335,.23446073,.21686179,.2512418 +-.64383424,.93079,.2977045,.3114788,.25702669,.2509086,.25709325,.26391628,.29057321,.30887871 +.42128692,.31271088,.28277417,.28032663,.315695,.3267261,.34319264,.32450914,.35120708,.3010559 +1.0328139,.6187646,.19865928,.20562102,.1561914,.14491215,.14684135,.15591422,.16079396,.19385198 +-1.2904935,.95351446,.24177169,.22953008,.32501344,.38069438,.4611249,.36532316,.54515641,.23436556 +.78787175,.32106611,.23156764,.24078401,.20218871,.19425712,.17622449,.19531208,.16070512,.21671793 +1.5157072,.66341627,.13665126,.12703345,.17581124,.20039954,.25847706,.20674992,.35899704,.15119583 +-.27648715,.39563784,.3158193,.31586931,.3481959,.35810566,.38200715,.36407338,.42546061,.31994675 +-.22376217,.52433377,.31726241,.31194313,.35102832,.35601176,.37307496,.35644025,.38768768,.37555419 +1.3974312,.51672953,.15280551,.1444295,.19194916,.21056571,.22903207,.20154176,.23748733,.15119583 +1.5038735,.89413116,.13831766,.12874814,.17849067,.20256748,.25945018,.20968897,.3582845,.15119583 +-.47890497,.97143796,.30692589,.32055942,.30950537,.32610177,.33693342,.31654009,.30584078,.27657124 +-.1359496,.14135297,.31850248,.30708612,.35335067,.356503,.35032857,.34820511,.32358697,.36376222 +-.73032662,.52783029,.29259949,.30296315,.24788827,.21783998,.2070478,.23766242,.22559505,.30464283 +-.03327709,.86167095,.31776682,.30409739,.35990479,.35322891,.33260293,.35696834,.31130253,.35590704 +.28115083,.95467052,.2986962,.29242144,.33561626,.34984221,.36523791,.34821892,.38413714,.30800325 +-1.2989147,.80130654,.24054457,.228406,.3242507,.37937907,.45917069,.36459455,.5425096,.23436556 +-2.8194873,.29377041,.03423861,.03397935,.01992567,.01845811,.02368624,.02238546,.03521327,.02886914 +-.85198542,.07745348,.28499181,.28840952,.24395463,.21358347,.16033312,.21929099,.08660478,.27849863 +-1.1069518,.49668391,.26433879,.25400233,.32229855,.33312293,.35156483,.33496984,.37965384,.30003257 +-.93773148,.19808942,.27902143,.27775656,.27754821,.24108994,.1807995,.24935348,.0900434,.32253643 +-1.5377704,.325444,.19963066,.19249631,.23509243,.22351351,.20130053,.22380662,.15481808,.23739545 +.5557587,.24841208,.2647569,.26995034,.27512558,.28157636,.28811611,.27768035,.30157454,.27132668 +-2.277282,.75179027,.07828852,.07873796,.07875061,.09204377,.11446709,.0922851,.15025998,.05700553 +-.39020054,.13177808,.31133267,.32104843,.33517543,.35027672,.36907311,.34495022,.40165181,.29228903 +1.2071225,.36595759,.17694573,.17676473,.18418833,.17480444,.15023094,.17594001,.12570809,.17381817 +.17869009,.61706068,.30769076,.29939275,.34442456,.347134,.35602386,.34847054,.36011693,.36522916 +-1.0041675,.1042514,.27381383,.26920255,.29856445,.27641696,.23392586,.27843723,.19447102,.29342568 +-1.3776266,.92715643,.22828438,.21635169,.30823856,.35053859,.40838262,.34325694,.47623359,.23204453 +.49928077,.16346328,.2725563,.27403682,.28985754,.30351024,.31480322,.2993623,.32039228,.25210428 +-1.4052563,.96126524,.22366107,.21181391,.29911819,.33392962,.37877909,.32774722,.43913813,.23204453 +.16256489,.38334264,.30887154,.30012656,.34572104,.34707247,.35358542,.34768253,.3560065,.35593763 +-.06778502,.77186504,.31829891,.30559493,.35826195,.3554906,.33637638,.35551408,.305725,.34139722 +-1.2600064,.12778838,.24607265,.2333853,.32622041,.38243622,.46216935,.3612336,.54549954,.23436556 +-1.1328956,.49085611,.26161854,.25023928,.3231961,.34583442,.38073288,.34660716,.41805519,.30003257 +-2.0064812,.48090321,.11322783,.12879922,.0646241,.06034824,.05482294,.06467009,.05764425,.066758 +.30101641,.13432719,.29667228,.29063393,.33480316,.34885982,.36454689,.34424398,.38577022,.29229072 +.05911705,.72259881,.31483242,.30162583,.360174,.34909635,.33698463,.35400964,.32926111,.3572589 +1.1384692,.43570061,.18542783,.18785159,.17569715,.15617806,.14519084,.16879885,.15817458,.20996476 +-2.4006338,.0702726,.0661328,.05973222,.07546614,.08153031,.09764932,.08181684,.12409822,.06580884 +-.28085336,.91503527,.31567929,.31617356,.34821096,.35820009,.38234837,.36478543,.42807283,.31994675 +.02565318,.21581449,.31615397,.3015383,.36059293,.34980376,.33308907,.35373627,.32250968,.37892557 +-1.3860712,.52139452,.22688798,.21494935,.30566124,.34579032,.39987794,.33922414,.46560575,.23204453 +.86393679,.4338506,.22096543,.22892366,.1834737,.1740142,.15644199,.17635877,.12724629,.18408431 +.25246163,.90097287,.30146488,.29459784,.33628211,.35007398,.36442492,.34886654,.38021707,.29838197 +1.5005706,.52615659,.13878075,.12921959,.17919626,.20313531,.25952209,.20982585,.35751304,.15119583 +1.0532023,.23850945,.19607429,.20225294,.1596919,.1452661,.14646528,.15783051,.16537447,.19385198 +-2.3385949,.03208453,.07201598,.06861114,.07788137,.08815269,.11183084,.08955035,.15620679,.06580884 +-.37427851,.80847815,.31205326,.32060023,.33786515,.35297134,.37326996,.3501085,.41938363,.29228903 +-2.3599583,.56724767,.06994132,.06564237,.07736941,.08614625,.10817961,.08872598,.14898803,.06580884 +-1.1578862,.98669892,.25885895,.24676433,.32192541,.35726098,.40592428,.35127741,.45134312,.30003257 +-.55186497,.1049692,.30295427,.31836946,.28119002,.29690047,.30298875,.28439032,.29007716,.24740666 +1.5926728,.78610254,.12554701,.11550205,.15819727,.18163449,.22681772,.17941142,.29077747,.12550619 diff --git a/shared/package-files/2e/2ea3f8a48d2e0c35ef80b157a53c54c67b81d74add11c5faea827e4cb5d9562d/blob b/shared/package-files/2e/2ea3f8a48d2e0c35ef80b157a53c54c67b81d74add11c5faea827e4cb5d9562d/blob new file mode 100644 index 0000000000000000000000000000000000000000..8a88ba482034b6ed511f4805c3a45a466cdede1a Binary files /dev/null and b/shared/package-files/2e/2ea3f8a48d2e0c35ef80b157a53c54c67b81d74add11c5faea827e4cb5d9562d/blob differ diff --git a/shared/package-files/2e/2ea490b3d369e66dd002ea0133404c4a452900f17d7bf3bd6fb0661f2058055f/blob b/shared/package-files/2e/2ea490b3d369e66dd002ea0133404c4a452900f17d7bf3bd6fb0661f2058055f/blob new file mode 100644 index 0000000000000000000000000000000000000000..78c210698520ab0106ca4a64da2c80722e568e3b --- /dev/null +++ b/shared/package-files/2e/2ea490b3d369e66dd002ea0133404c4a452900f17d7bf3bd6fb0661f2058055f/blob @@ -0,0 +1,318 @@ +6b27a881f2d07a8453c008e7092aac0cfe08fb8d80bc8a4f7e28516b3ece1bb2 FINALIZATION.json +ccc350f3f818fddd8e66ecaa11850b2d16fd5fd62e3c3a84117f069f7d4eab97 README.md +09f52a522875fdb94cbc620011af68e38234549b2fcecfc91fbc9bea7bafd7da STATIC_CHECKS.json +8b044597670ed62d4f353707cf5dfa7da2a159a8545e0ba3969f5cb59be8a27c additional-elastic-tensor-diagnostic.json +d930f63632374b852701f536bfcef561b960ba3e0e952577b38327d641896a09 additional-elasticity-predictions.jsonl +e666556933fa11976a51462a9953238ceff6086cd8e94517d4b5ef947a232e9d additional-elasticity-run.json +2873596540f394f1df1390d8ab3ad5cbd0775342b0916d5ec951c403e5204503 additional-elasticity-score.json +54e3278959c0c72e3a9a11a1c2cb9349449e9fb4a995d2c7c2b08d205c6cf9e4 additional-kappa-audit/README.md +9b6442a20759a648111c0d70f976de018596435d334c070add045419a1ef2040 additional-kappa-audit/identity.json +ed568b6438416cf1b4be8f0e1a2635a4bb945220a6224c5b228f08b71a41c93b additional-kappa-audit/items/mp-12779.json +cdba13c9ae13084197ef7982b9a66ffefd1d3219c58737bb5f34b2c3701a3e80 additional-kappa-audit/items/mp-22905.json +784c5791ca8b8df0f07bb91061a78a2a585ca33319ba658584041fcc53728de0 additional-kappa-audit/items/mp-569346.json +97cceaf3fe8ff0e0f4d6132284d3952628a770bea5cfd3cbecd39590121b88cb additional-kappa-audit/items/mp-580941.json +314b8675f76be9d5417341868c5db7fa89e4f34c08fdcecf13df09acfe7cfbec additional-kappa-audit/run.json +66c2524548199ce3040c7f3e076923c76dc4ec47f34d8f85d4f13c50a9a96ec8 additional-kappa-audit/score.json +3fd700ea23e69b999ffdb5165823f37921c964a5a08e8309bd548bdf0a9d4991 additional-kappa-audit/transport-selection.json +59194f1656bc310581cb3e1194e066c95c0f3c4bc2a1ab8c95e6019f36297f75 additional-neb-audit/README.md +6621841b5dfe9e02071611de60df450a59687bc2110ffcb4a7cc47bc3d76cde5 additional-neb-audit/identity.json +cbed98d6264e5cec710757044fa9c5bb533a77736c0c3234d0a6ca30924a5cbe additional-neb-audit/items/mp-556902_3_6_1_1_0.json +27602c68f2fadd3a22e26919f0c5b05dfe34d5840dc8bc7bfcd002c04e40edf8 additional-neb-audit/items/mp-569085_5_9_1_1_0.json +d9927abb0bd1e501e2d7aa3b776b448ce572661dbfb98cc5a4e00df41b5ffec0 additional-neb-audit/items/mp-778397_1_3_0_0_0.json +697a58fb95ec8e6bbefe1b000fcb098cbab1b37f662d6290e7f04b36e4096a98 additional-neb-audit/items/mp-778397_2_6_0_0_0.json +2f5d9382231ba56dfc8afb5f42de9c071218001217e3f85ddb6fc7b7b68e6298 additional-neb-audit/run.json +139e6850591f3d36be416f8473e431d0e8ad0dffd3abd81111e062e25703eb9b additional-neb-audit/score.json +3fd700ea23e69b999ffdb5165823f37921c964a5a08e8309bd548bdf0a9d4991 additional-neb-audit/transport-selection.json +adeca46ec93eca52e2cb119b0d2b0867528d23e65c571b5c9a453020df18182c additional-neb57-cuda-diagnostic/README.md +a4de75de449322fbacc0c701da959624251bf8b9f0898172c0b2d19d5aa1dd45 additional-neb57-cuda-diagnostic/all57/references.json +b74d217c7f61ee9310be711ef597bac0b0385bbcb6480090a20621e15586baab additional-neb57-cuda-diagnostic/barriers.pdf +f70ec31af394751e7a2fdcadceeb7a048836b9caed1402f89e76d43db5f39610 additional-neb57-cuda-diagnostic/barriers.png +9fd85a3b9d8a7d35d4e1af0a902effc42837d4fd0a09038dce6ec06dfb697159 additional-neb57-cuda-diagnostic/gap1/references.json +7663623b7a44355d5b5e6969af9c6e89b63dd311c0f4403e8af8070f9fc2977a additional-neb57-cuda-diagnostic/gap2/references.json +f7a5641bfa3af2fd4436d00869da01feb13b25e0137df480c99fc78b671c2306 additional-neb57-cuda-diagnostic/gap3/references.json +5a84371b007dc9a923dbc27c270958eebec6bea17b8e8f86d064d3a513d77e90 additional-neb57-cuda-diagnostic/gap4/references.json +eadd306e0c03358578123de88a4bdce0be11631c2f9fbc3f5e8e2ce89f716691 additional-neb57-cuda-diagnostic/plan.json +9ae1ef774cde90d60a22dcc1436a764e1de070f08f0987bdbe4a473a61851d9a additional-neb57-cuda-diagnostic/report.json +3076fc3787acc4c4bc35a9405c151d808c6d03753e735a71a01e8524bbe5074a additional-neb57-cuda-diagnostic/review_cached_neb57_v1.py +cfa0ec5dd3f9b3efbe044e53ed14f1911a34b391f384e41821d71e3e18cf6c5c additional-neb57-cuda-diagnostic/source-caches/gap1/items/mp-556902_7_6_0_0_1.json +e893abf0b04210f2d928be923aa28a3b99bb50405679cd9115b17b04e68e4991 additional-neb57-cuda-diagnostic/source-caches/gap1/items/mp-778397_0_2_0_0_0.json +586ec9e003fbf0c13fbaca46db872276c062468f94d2dd726df114e99ef42d7f additional-neb57-cuda-diagnostic/source-caches/gap1/items/mp-778397_0_3_0_0_0.json +c6473e5dfccd7d3ed139559e82ca4247f8dc0b1c2856074c089a00343555ff65 additional-neb57-cuda-diagnostic/source-caches/gap1/plan.json +a6ff900f910d2bf59c6e3b7c3cbddb229546ef0ae44738459cc254d4c448e133 additional-neb57-cuda-diagnostic/source-caches/gap1/report.json +d296835ebc563495b7dfea0e8aa816e5177d48fe7ec007014318fcbf35aed45c additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1020030_0_1_0_0_0.json +ed96c414931cd2a3227c9a0427135481caae3ce9b84a010bc72de8e79585cc38 additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1199122_0_18_0_0_0.json +dbbc61dd1b220b280ee091e68e189def77ae226132284ced3d055a4b2f57f991 additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1199122_0_5_0_0_1.json +2b8f952d305ff6bc9bd6f449c974a6a3f38d7122edaacf68bba79590af77c307 additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1222482_0_1_0_0_0.json +2258584bdf17b6fe17b64cf2bd278791229a99639c2dde9700a9efed54d9bf09 additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1222482_0_2_0_0_0.json +7b54c5b4a8a2f5555b3ec54e49e7517ca993291b8c888492ade80379bd7370e5 additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1222482_0_5_0_0_0.json +ab21ac708fd26de1c35e23ffa55454a3343a5d75b8e3bf3249baa9d5694c2c3d additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1222482_2_3_0_0_0.json +ff7ec30542800c422524ceba1b6591e90143e76c493334922d2bfef1e0e356ae additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1222482_3_4_0_0_0.json +f3b291dc7802f513e9e4eb1fed3dc13dbe46cd726b80897a195b8c70e1c60180 additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1222482_3_5_0_0_0.json +70944aecb8547cd55d11114af0878c1bdfad781d9ce4aa44794d9e9656f3e9e9 additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1222575_0_2_0_0_0.json +c1d7bd56f8146120e0216919937ecdaef335914e3e5f9273845c9efa683d8bcb additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-1222575_1_2_0_0_0.json +f75736b162b085a80ea84b0f594cc280bce694392299053d130307c632ec6171 additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-29040_1_3_0_0_0.json +8dd56454180f74f0b98054f8a1c9a56faa9c6b180ba7fc644d036652b71ec8e5 additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-29040_4_3_0_1_1.json +7f1f042436e2283cf1cbe7a98516b0dcd6587490f887cb9d7aa1438ef0f5ceb6 additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-561294_1_2_0_0_0.json +a75cc45d8cc057c2f3aab44e237f68f2b0572967dd0ecec0d8bbb8929752870b additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-755352_0_1_0_0_0.json +24b3aae70f0b9d382a6c25f75a51afae02e3273fa36515837b7fc8dbaca0f7c7 additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-756639_0_4_0_0_0.json +97869cdfe3a348633a41e07d1d97992ca472fd85dc5f7beef0dd70e1c310a4aa additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-756639_1_3_1_0_0.json +d6a2e7ae857d55aa485ed402b3cae42c22438b7880398dfa3914e9c621115827 additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-760791_1_3_1_1_0.json +3253cdfd8014d4e540cc3c85e5a5f6279d92efe60c590eb391c19094c9986e44 additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-760791_1_4_0_0_0.json +efd003c93738c7d217b12b2d3e5c165c259181bb0ac0dca2bf8d92410014f048 additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-760791_1_6_0_1_0.json +4ef342095c8e89823c3d2c969622ef83f9bca3527ef63d0e71e3f6adeb745988 additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-761849_5_7_0_0_1.json +ad502250b1b332beb24437bcc6385159d24f9b031c23ccb69fe59994e2698e7f additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-761849_6_5_1_0_0.json +9a6d73f9d03fe5dac069e059dca91e6da8c7f4950828131a6d620c13647fd8d7 additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-762240_8_13_0_0_0.json +f140ec6ad27ef06c59e6ed245127a62e1a8f0d3aba9347f73805fdf9f182249b additional-neb57-cuda-diagnostic/source-caches/gap2/items/mp-772260_4_15_0_1_-1.json +f5d5688e38960598c457024f8bdfd34321324118e119a9c7e4e2268c43997100 additional-neb57-cuda-diagnostic/source-caches/gap2/plan.json +74d141f8546500159b5fadfb2acc1b59d15a589ed2833f744924e831d8fc090e additional-neb57-cuda-diagnostic/source-caches/gap2/report.json +9ece10cdaa075e2a106763e52e9d283ffd6af6f12ecf9269bcd7171db6ee0be2 additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-1176566_0_2_0_0_0.json +8dbc36df07c319abf6bd68a0c6606b834bfd85228581005f2dc554ebc253051d additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-1222512_0_3_0_0_1.json +eada026ecb2ad17c832916e88d4f9e51e3bb2eeae6c6aea009eccb2db1f6ba7b additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-23384_0_6_1_0_0.json +ba0b30d8b36d6a655e0cbd5053f32d4a3a73931bd82d696d48897dc16664923f additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-27417_0_1_0_0_0.json +3b5e1911558c2102d5d55878e8896c8831c54eda9c81086f8b8a7e853169fead additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-27417_0_2_0_1_0.json +8393555260eeba07c0f0e0e39ff7de3692c76c1effb2db97219e309d79ebc912 additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-27417_0_6_0_1_1.json +af33e858aba6562b08da5d3501e41f31105b884c82cab2dd4f01f2a9df65e073 additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-27417_0_8_0_0_1.json +c285a32cc70771c63bd023570b105d65d54ba3204d62656fbba15692e03a81c5 additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-27417_0_8_0_1_1.json +fe53db2bf23f3f7cff31bff4de19740c16b2083a2f3d08d1a86057cd3e9a9244 additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-28548_0_8_0_0_0.json +c5d5bb3394eb4e8da3ed3693bd08ecd59ac424fcbc6b20609fbcf1f475afb0e2 additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-5418_2_8_1_-1_0.json +5f4ca375697503a1f05aa8f3b91672a717d295ee25b38c3dab1564cabea64013 additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-560189_10_13_0_0_0.json +1d629b8e7f58c61952f872e29ccd7d4e6178182dc19655ec65a5403e73e1a6c2 additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-560189_14_22_0_0_0.json +c29337b1f5a9cf413752c5148e8b19f10aaa974048457f7e537e7b9e4ce21582 additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-560189_9_11_0_0_0.json +1354537ddff339f74921e5316ea260779c101a2b27ba32a0812256fb4fffd782 additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-6326_0_11_1_0_0.json +a37d8965b1f3010a67e42d45e134186da5a659509b2c6e56c527ef561ed71a44 additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-6327_0_0_0_1_0.json +0d75c9d9747181c7b4bea23b4f15bde04e1b63d93ce8c0c8ba3c589396856ee5 additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-753520_2_6_0_0_0.json +69333ca3487096cd20306e8c1a5602f33ed3f48edbfaf6663fba2f0be20256e1 additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-755559_0_0_0_0_1.json +83d2f8f69964c1bd387ac831e28762a1def0b1235f852f841db2f10f763da7e5 additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-757905_0_2_0_1_1.json +a53311b74e3b09333665342eed5a73333837cc37fd610140814acdde545b89c9 additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-760701_0_1_0_0_0.json +a0542e0adb7ee0f6b9062e2cb1d81d643a20ca1718f323243aeb1f5b32b3f7fb additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-768982_2_6_0_0_0.json +cb828c1327f6dbb4e9032fa44d52c5350388cd5ff140faabb4e829215fd55726 additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-780226_0_6_0_0_0.json +e464fba7666174863322d66001f892f039e5e501b1273747b216eebf547fbf5a additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-780226_1_2_1_0_0.json +d5ab368d8f8f227d3ac54d87815a5fdff89e973f62409f4182a529dae3586653 additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-780226_4_11_0_1_0.json +1cfae77d0015b526627d89a71422e3eed9749645f864cdad46a35def923f01cf additional-neb57-cuda-diagnostic/source-caches/gap3/items/mp-780226_5_0_1_1_0.json +a396e1fa123a6cdeff95fe61ce612387e5075aca4ac30cbd8f619768f2df42f4 additional-neb57-cuda-diagnostic/source-caches/gap3/plan.json +77298a731088934bfeb4893a361bbd45ccec6f72bf93e0e5f4d429e544c179bf additional-neb57-cuda-diagnostic/source-caches/gap3/report.json +054d8a855bcc77e3487d106b791358dbe7091c403e2899b145a1abeade5b7081 additional-neb57-cuda-diagnostic/source-caches/gap4/items/mp-1147685_5_17_0_0_0.json +9642c47a3c2f71bbb5e2a7db093489043ac66981a6202723deec8ec80e73cf82 additional-neb57-cuda-diagnostic/source-caches/gap4/items/mp-5418_3_9_1_-1_1.json +0bb24f4a7373448e725f7c42d86847ffd0e57c4aa5dce8b08840804615c9ce04 additional-neb57-cuda-diagnostic/source-caches/gap4/items/mp-5418_7_5_1_0_0.json +559da223167a74586193fa8c654c89c76be15c850f5e7586c9f9bbb31fbcc255 additional-neb57-cuda-diagnostic/source-caches/gap4/items/mp-755225_0_3_0_0_0.json +fff1ee5ef54a55e39a6b4670b84d5fe1b818970919350f64c06ce0f010d3f5d2 additional-neb57-cuda-diagnostic/source-caches/gap4/items/mp-772185_0_2_0_0_0.json +1dd71e20e63f3dd36445f8e62f5b25d5f0eefb0a453049b48e529b894d02027a additional-neb57-cuda-diagnostic/source-caches/gap4/items/mp-772185_3_2_1_-1_0.json +3d22ae7d5a0f1abf01dbd6adfe938f04282757fcbf6b19d68c990510f814b089 additional-neb57-cuda-diagnostic/source-caches/gap4/plan.json +cea3f30ebdb81402ec197d9ba405b073365e626a6bd8c85926e0947a308573dd additional-neb57-cuda-diagnostic/source-caches/gap4/report.json +e8981584d852f6608e8dc915a9825b3c7d24569c16458b3d0de90ae65d1f1f02 additional-phonons-predictions.jsonl +3f02f845eb7778f1cd0d6cfccc59a559d9fd037b7d16ab803a35ab8ebb97790b additional-phonons-run.json +828b6345710c407b652a9356a5121a8dba67ffabd9e64ee19b7e39e15081cb2c additional-phonons-score.json +f4c2bf293c514e6085e4ee0e7a21d2a2e57cffe6fb4f394520bfb5ee083e71d9 amorphous-energy-decomposition.json +f7ce67284512c19666bd64a0ab93c5f7f281aff022b7cb3025cdf9f2ba6ae950 audit_continuation.py +e8020b08c19ac43607476db20f2dde9a83458339184b808c1672d00f4a7d99ae background-suspension.json +93a7e0bbdb816bb86bb1b27dc451d42025a637b227b33dd58077af69c1381b5a broader-OMat-comparison.json +7b08c354083cb24910b058e8580466488c5f1aebaa39ba39ba6e050e1e4c37c8 broader-elasticity-comparison.json +6517f1839ba5c2a8aa200330e035869aca8884ee27bae42eff0ce4ac20a80137 broader-labeled-diagnostic-summary.json +9ff832696f76d3fce9a0b0524b33030404a6417dd165c6aa8eab6881a1c92fe3 broader-labeled-diagnostic.json +4e86bca6127f03a81984a08c6f86a8d20bac0d07b102d41a305dffa8ad9d36b8 broader-metadata-update.json +78aae19ada53b2fbcd7d6fccd34e2f568a672daaed2ca3802dea94376f7372b1 broader-phonon-comparison.json +02aaeeda3d67f6f0b4750125b254f8eb38ac3443af8ace4bf6f60ed74a54681c calculator.py +b5c16b0631fc8bd04237d41af809b681a3881d5fe63dee11c5effabbafaca311 check_package.py +79fb4236ae6620e1e858d5a0d8c4021dbf4ade013e569354b040c58a208abe2c completed-full-suite-comparison/README.md +7b4571e223254461bf99f341612c1d9356f25936483102688f14d063c615ecfc completed-full-suite-comparison/compare_completed100k_suites_v2.py +c27ea455bc1f1ae8ed4692c21deca2d9897d7b0b9583946e1433b8114763996e completed-full-suite-comparison/comparison.pdf +cf29c06f38f49698a3ddb99efb84350a83295fec6af06a0dc8dfffba01771a54 completed-full-suite-comparison/comparison.png +2e1d293de166306f5e245c7049cf0dd212bdd8eefce9ee25ee3603537bed96ce completed-full-suite-comparison/report.json +489e815b900ef7790e67012fc43b5d26c624a90af416bc759146174379fb60cc completed-six-suite-comparison/README.md +d160442b44aa9756b12dc575c427b09fa39bf838522e6ee6aa0f8acfc9e04b30 completed-six-suite-comparison/compare_completed100k_suites_v3.py +127fa452f5b72883f53c9998494d143d7c05366a03b34e1c0fb5309a369de5e9 completed-six-suite-comparison/comparison.pdf +326f7950937ae1bdd50169bf8a604bde6c2e1a758b32d015a4dc5996eac1e9e2 completed-six-suite-comparison/comparison.png +b7b64174d1dd8dffc44c4558a6adf77ae2ca10530ea12a361c91a9b4f503d211 completed-six-suite-comparison/report.json +bf511bcc8a5de55dc406bd75df67e2d35f586f5865b10ae98838641a078a7d78 consistency.json +c66fc6463d9ab433aee2fbb20f0b87ebe4e458bbd57981f589924827b3682dcd continuation_stage.py +3b91b17e20ca5d25a237de5d3412d5a12f2046929dc248f2ce01787c4f7b2cf2 curate_environments.py +79ef38898294ea1db1a288316f5ae48eb008c9f13d6ef41428c36c02cc761221 curate_hydrogen.py +ed7036a6069bca1b06a7f9e09a9a80d65727d7132ad465eadff387963552ad17 development-registry.json +86bf2dfb859aa4621964206cf3662e431c37bdf02f32abd6f0b7c0d5afb1a0c4 discovery-metadata-update.json +f9f35cfa199dd23096a446ca0d8dd34020f5a788d311141288562b12b92f3a13 effective-config.yaml +165e29f52cc761278bc9e3b979bdbfb0a0da196282e1f21d54deff5c63ef389a elastic-tensor-diagnostic.json +245f0b63d23b93a741ffe2e7a603709b0eb16df3743e177a02498e554d15e885 experiment.json +16d011ab077d9b8ef75c33c5b5eadac8c664c08897148e838a96d0f14fb344f5 export.json +64abf01febead6a296358011fa24e13e21e330b86d975975a553ef3df6ce1531 finalization-records/README-before-finalization.md +9c43ced1908d435650ce5a94b437e74dfd1af35f9b563549143d5a44fab7faaf finalization-records/auxiliary-energy-floor150k-v1-decision.json +dbe108ce91809d357ddd84b8c9535b1ad98b5b6bc28ee67c3a3478ecf115c9b7 finalization-records/cell-stress-replay-v1-decision.json +fbce46942b540402d81aad75cea5d3edc2e36f42e622f4e2451bd16725ee6675 finalization-records/contract.md +6853ac53076a7768659f43596e1ba2f3a6201d9b32649006581021354da51224 finalization-records/duration150k-floor-v1-decision.json +b5b98fdd12b17b20fa1ccd5384d05a4e4f27cad28731a936e1250018e740676f finalization-records/duration150k-segment-v1-decision.json +27b7ad61c92703dbd8afd9c27e784951a5ba877bb90c9a522d654fdab3991d26 finalization-records/finite-cell-force-floor150k-v1-decision.json +3c175c11e93402407cfcc0f5e6cb1ea0a7008359bdb24991effc06b57fd388bb finalization-records/force-increment-floor150k-v1-decision.json +cb28aae4485dbd81a75310601874948aef32d647433ae5d080b39c38a26bd645 finalization-records/prior-strain-components-v1-decision.json +417262466780cf3fc465e91f02c578d049d7ff1b5e7b016533f2dcfc66db9834 finalization-records/rattled6000-floor150k-v1-decision.json +661d9a8633f5c178f3e6c9b449f4ff79192b588302e2c2fcd9cd3ca4dfcf0643 finalization-records/rattled6000-segment150k-v1-decision.json +90fc0f0a2d45fd5da4240a63494d0d9dff4119d4c6754173e659a13e37b23fb7 finalization-records/source-context-v1-decision.json +81cd7d01fdfa145aef89d25b1f9c072c0b4e047c4591ca4e99ec48442665e123 finalize_coverage_v2.py +d81879fd1f40120fe8eca865c2db60e7e1c54b4d6ba8ddf415fdea18628112d0 finalize_curation.py +9b28a4c7fadd009a90eebf95b5e76427ebf23a9e7085d8a20d6341e3207baabe full-amorphous-comparison.json +87ea0c734166173ad64ba09bc29f82da4bb3c1c147e8d08fe06cc436b389f7b4 full-amorphous-diagnostic.json +080af7e77c4f682523b4e33965301aa41df1c55e2793116807a9a5abeef7398e full-amorphous-identity.json +17e71dc7d0b87b19a58e6bf8796b5ac1b75bc26a37ac70d607fa1095d304fb84 full-amorphous-metadata-update.json +1868b5265dceead98b11653e7f1fe81a40fe8239995b32a2361fdc9f6d7e2539 full-amorphous-predictions.json.gz +52184d9d257c77b9d3d56724abc1259ddbc4364ea5da43b1dc3d21e8ca3a2ae4 full-amorphous-run.json +8ed595af11fc06c4c1200744976b736404bf4ba6ade39f18ea02d19d96a6a306 full-amorphous-score.json +adff399c6628ae18949358f9c2e993df6dbabdcc2f10cf820a0559c8b7005736 full-carbon-duration-comparison.json +37c06477d596bb3502af98965e14b87748028f23dc1597e37822de3e9514706e full-carbon-duration-comparison.pdf +661dc6977b108085c076cd167a13931a7c76c051edabbb974a82a8620f85693b full-discovery-cpu-published-panel-overlap.json +657ca37ee7ee41e64fd359eff4501af044831f0c6a7945d606623b0ef1b532d1 full-discovery-duration-comparison.json +c91473f9d283909f17e339f39f81bdb6d3e74c392afdd1558f6c65d8d4d31066 full-discovery-duration-comparison.pdf +fa7685839d95ab727e8ff0558ff592899c7960100455be7ce8fbaffa1662b58d full-discovery-duration-comparison.png +b05c67a1ceb3ca6f5caec89575ecad39725261fcd722f304fce8cdd2fa278999 full-discovery-predictions.jsonl.gz +3249018347c2b00ed3c2d72f9775efd3bf25b75bc03d17d7df3ccf2c90511ffc full-discovery-run.json +ea2ec565aa31c64311e0a87d0cc7c234a9b6981f93dda948399f422c18dd7e87 full-discovery-score.json +dc98283ac0fe23c366ea4558a92eac8b808c82fff97491c057a062b51fa870a0 full-discovery-selection.json +464f1bd0ef29b4fa39e4297dc5ac7ccb718725cbbc5d349442238a9d12c1385b full-elasticity-metadata-update.json +aa2d98fc1151125adbb33c615ec4ebc1b5f080876a7e7d75502c831e7b3ac713 full-elasticity-summary-metadata-update.json +f314b1723dbaeeb9620b3489e86442f4c37140125d6f99683678f33a22da7121 full-elasticity-validation/README.md +29d44ca50d6d6345fde901deec3bf3749f24b7aa5be950d9130ded832e688c17 full-elasticity-validation/diagnostic.json +ce0cbed7638706df3d5a9e3d944523b9f8a7aa41746abd4a249fb6b390b989fe full-elasticity-validation/identity.json +38e57e50a717a1d907fbfb1f2b2652dc0cf7df089fa534094869703189d89c9c full-elasticity-validation/predictions.jsonl +6e9638cb94dd5063fcadcb1b18f00f677399ae0d860081f10554674bce4b58e2 full-elasticity-validation/priority-plan.json +e800d22eed47fcf5be3287486a33de7f3bc10f162dc0fa18c9fca7487b137112 full-elasticity-validation/run.json +f04f8a920d242247206fe496c8cfc235b15f7ce725d4298f15f6f01f55ef6146 full-elasticity-validation/score.json +a22ca38a96d93b219a1f9fecfb0ed08ba214db4203ed391a9c318647d0937ecb full-elasticity-validation/selection.json +7eb2e44b5af79420055af8c58b70e8365338c59249964df0d5b0c8b22e7885a3 full-kappa-metadata-update.json +fe1b03c0221b4622619debf557b697793b27efd548f20b2d6ffb024ebbf8f81f full-kappa-validation/README.md +5ffed54198e9d639d852744e0162074cfbbc35fe51ae82c7ee1abb255989d8ce full-kappa-validation/documentation-plan.json +9292416602ba7296c164ae6519a1b9dd5337628c5955df25aced7536691a3e5b full-kappa-validation/identity.json +b6248623cdc7308a8fdec1a93f678b31d263f75e4eaeb6088435b9711730359d full-kappa-validation/items/mp-1039.json +587cd4a0e4855d2788bf94e55c6b3c1c915f5d40f508b35c9e2289b2605d951c full-kappa-validation/items/mp-1132.json +654e6ac81515afd67c3fe43232039ec229963bc1f49458af1dd18838f724aa09 full-kappa-validation/items/mp-1253.json +ed568b6438416cf1b4be8f0e1a2635a4bb945220a6224c5b228f08b71a41c93b full-kappa-validation/items/mp-12779.json +d64f0a27f9d38ff533132d30040d1d50a88e3a02e3eb9e17ee9641e34957ef44 full-kappa-validation/items/mp-1342.json +0e36aa1aae925715fcb08c99c0fcebeeb125fae439f55be423608a4f903e2fe4 full-kappa-validation/items/mp-1415.json +b9790be2b82f0c9865a030012ab8687bb4dd6445ac451b1cd84764a68f597d9e full-kappa-validation/items/mp-1479.json +59feb2678256f631b6049cd5dc66eae6df591f7950fbe6482b545d2c8b7f2649 full-kappa-validation/items/mp-1541.json +90297f221976c2499906a9d420280f5c0a6e7fe3afb95e67de5e1410b7bf9d89 full-kappa-validation/items/mp-1672.json +bc9d722e3d4a5e88871e8123cde6e8c7964e8557832a852fccb74f570009790b full-kappa-validation/items/mp-20012.json +12060875b2e64cb0f1d6e14acbda917a7abde68e673126048c47d1a660363c85 full-kappa-validation/items/mp-20305.json +bfe0c4ae5ea8f06483c09eff7fc15d5dbf7b41f9e0bfdcd4ae5657433ca30967 full-kappa-validation/items/mp-20411.json +0f38ad5e40cbb07a83f699650e6ac0c01837e2b74719bd45e82c28d7499533a6 full-kappa-validation/items/mp-2133.json +a19545470eee3db16b60645fed8d26b3958d41e683e6e80290078562a70652cc full-kappa-validation/items/mp-2176.json +1c96b79dcf321bb94c2266b7f24d96f0136d9cfeb53eea36b22bd2dc16edc8b6 full-kappa-validation/items/mp-2201.json +6b8d6917ff6102e3549959d183085e7e180a35e91b22cbbfbf99703b3c207dc7 full-kappa-validation/items/mp-22205.json +f22109858d8098bd740a88437975a1f879c93c02ebef926d532acc1b4b5d1904 full-kappa-validation/items/mp-22903.json +cdba13c9ae13084197ef7982b9a66ffefd1d3219c58737bb5f34b2c3701a3e80 full-kappa-validation/items/mp-22905.json +2244c45767fd28551f7e523bda118e0656d8c779c80f20a28c8563c9423a1018 full-kappa-validation/items/mp-22914.json +6672f9de900601bf34b4d4969bfc883c6dd824e39790341f50e893d42f8ed5a9 full-kappa-validation/items/mp-22916.json +5cfe8819530e434da26959eace2aaef8cfa5372610a1b39515b9cfd8cc3e37ed full-kappa-validation/items/mp-23193.json +64a9e0d8417376a33b5c25e26227fbea0ae11d7d3464db2529b730285ccc9160 full-kappa-validation/items/mp-23251.json +f3a5408a35c9734e2262b516fb3a7098e43e4f5725dad7b3e61ac8aaad1b66ab full-kappa-validation/items/mp-23259.json +0a991e4254df35f40ce3410803a771f37e8750d24080e54c3333bce4aaaa0322 full-kappa-validation/items/mp-23703.json +56f5b44573c5af68cb93ffb4e9ec228c61dbccfa0a1408daf106915f8d5c6eba full-kappa-validation/items/mp-24093.json +1b2541d6fd5f3fd1bcdeeeba0192b11a4c29f66f70848943d8886557aa19836f full-kappa-validation/items/mp-2490.json +9cde80d5ed95c86ba5efc90024f107e1a2f3e96e6105c3c2fa929628ed6a1be1 full-kappa-validation/items/mp-2534.json +845df40827e3df5d8f108bf88bcf8f0ee6f4493b4d990a6f93178edfa308927c full-kappa-validation/items/mp-2624.json +3a75a9e46e1ae27403267a96e92b881093c0ab1095c95d2ba79da1a46f5db2f5 full-kappa-validation/items/mp-2653.json +f03c572107ded4e61112aceb49a7ca635efd53ed67a00f8e531376eb792649b9 full-kappa-validation/items/mp-2691.json +2f0e038b5e4239676e47f373c0f7b6807e9dfd173edd15308fb9bd01f27cf49a full-kappa-validation/items/mp-422.json +1ca0d6e74ce4e8c76cf0c981cae130812bb5048e0a2c61abd3770bc461f991ff full-kappa-validation/items/mp-463.json +784c5791ca8b8df0f07bb91061a78a2a585ca33319ba658584041fcc53728de0 full-kappa-validation/items/mp-569346.json +97cceaf3fe8ff0e0f4d6132284d3952628a770bea5cfd3cbecd39590121b88cb full-kappa-validation/items/mp-580941.json +3070df21e12e434caf9dbd1c7b5f3fe1076f9792eb256f7694691ffc85585acc full-kappa-validation/items/mp-672.json +652a090b10880132f5fffc2ca61a6e5d8821133695102bdb3195043155244f59 full-kappa-validation/items/mp-830.json +b5c43c83ddad8d869a12cb025bcebfc4b7ff5145ed8f5d4eec87eb12d82c9a13 full-kappa-validation/items/mp-8880.json +0c50c93ddc4de3a5acd35a95b6ad9c5d6696c84c97a91a318ec8aa478f58f77b full-kappa-validation/items/mp-8881.json +bbcaa0ff45e4a001dc16a2a87f48efe1135c8f373627545a248bd9c531911ba6 full-kappa-validation/items/mp-8882.json +70483edbf3253e914fb4452649fecb0833d9452fc308b1ec042be667a31690f7 full-kappa-validation/items/no-mp-3.json +0f2c2f924844805b9e5addbd9807ccf4c585cf1eabdad31ade0c44f9da49cb7f full-kappa-validation/recovery-1-before.json +d7565fede082a971d7815d6096215d93c7818887609e2003520c41fe91ce6ba9 full-kappa-validation/recovery-1-plan.json +b8baac30b4a872b74033d922364d0927e12a503cabf095520761c7b6849d96c3 full-kappa-validation/recovery-1-progress.json +30a38c479af08dbe98fcc17295597537c7dac481a971b4ff9f791960517d5b12 full-kappa-validation/recovery-1-stage-before.json +eba16ad8724753a45e9ad949ecc66d0f98d04d7f171afa0b4300f52e40e6561e full-kappa-validation/recovery-2-before.json +c0a5191007d013ddd07c9185bbfbfb26a0d02e93e352e38943af29318305c751 full-kappa-validation/recovery-2-plan.json +4de738b9d1da9856a8c2a148cf4327555bbb2667d4d181b71062bcf0b2e4ea6e full-kappa-validation/recovery-2-progress.json +14632891a7d5b5fccbf3a7398671ae88783ac3fb1cdc46940c69eb67f100073c full-kappa-validation/recovery-2-stage-before.json +5eaee11bcbdeda01f8006bca1383d31a5e22ba1887c44433c8d82cf0638249c1 full-kappa-validation/recovery-summary.json +6fdb895646fc84955fc8deb1480ab1411b6babc8957813e6b0d94e11cbd7f92f full-kappa-validation/run.json +bae1968d6b64254c9917ae3e69b012d1185c953c93698e4eb49f0579852c9996 full-kappa-validation/score.json +d33b2ba9637886ff83385c8a1ba9dd2f539b6a5197a95af662add0633d51e5c7 full-kappa-validation/transport-plan.json +ba04ed6a17745e6c87e2b2a8af30a24ef11de1993a13a75f195b23ce917b2159 full-phonons-metadata-update.json +b01b79e50321a623e07a7ebcf287b71e4e784775854731026826aa7e2c26dbc2 full-phonons-validation/README.md +e78164868927192432ba2c060738cbeeeae0abf399a21b1107467649eccec997 full-phonons-validation/diagnostic.json +ccb55839ad98f578ade8e6af02bc07e44af273c1086bd288543780a1a9126503 full-phonons-validation/identity.json +7fa53ebe1395bf03e86d0f727fd388c19ff56d270e26499f8c796846169933a6 full-phonons-validation/predictions.jsonl +6e9638cb94dd5063fcadcb1b18f00f677399ae0d860081f10554674bce4b58e2 full-phonons-validation/priority-plan.json +32c8ccd94dbdb544c346ded3a16dd9800e40c74745753bedf2aff640a2733265 full-phonons-validation/recovery-1-before.json +d7565fede082a971d7815d6096215d93c7818887609e2003520c41fe91ce6ba9 full-phonons-validation/recovery-1-plan.json +5847ea1bf79f0e496ed7f34c7e2b8d18a2a70e90416f0222d7660d965a987487 full-phonons-validation/recovery-1-progress.json +2d94967ef8222fb2e3d8228806194878815398329615573c787400b2d23a7223 full-phonons-validation/recovery-1-stage-before.json +d472d01ddc8b87bff79624a0ff533b0ea1d38c236ca6054f046d14502590a8bd full-phonons-validation/recovery-2-before.json +7530e549d548ca9827ad3f86ff5347bdcd5381ced80a6d86265cf8910222a52d full-phonons-validation/recovery-2-completion.json +c0a5191007d013ddd07c9185bbfbfb26a0d02e93e352e38943af29318305c751 full-phonons-validation/recovery-2-plan.json +f404e7449f848c9b934a67f92ff57a91ac14598082a7a2f067f37679ae8f3e63 full-phonons-validation/recovery-2-progress.json +635be0206f79d608becfe048c46939d34d7be405c1b5c3c6e52ec86128e34ad4 full-phonons-validation/recovery-2-stage-before.json +41632525baa5120c0eeedb5e4bb94cf6a602b97c7da3834100c87486652f5902 full-phonons-validation/recovery-documentation-plan.json +dd2c4c98d32fd6ce62596b63ae88ef51f2f2ff3d35aab8ca4fd3d20b8bb692a9 full-phonons-validation/recovery-documentation.json +0a1270110ebdc5aeccbb2ab71ef3830bc9c0d2d8e16a2ad92597ced9098a0ab0 full-phonons-validation/run.json +cf650c679d1d0f48e10d80d5f6a67aac61146b6ae84d694a8d403ea89f599c22 full-phonons-validation/score.json +0617df92f372a781d8eabb7e4bafe2ed8c1a55b16e4eaed29b3507248de7ad9c full-phonons-validation/selection.json +b510cab6383afcf3fdfd30aa437d9a33d329693493ffd26009c3e2508a178375 full-surface-duration-comparison.json +cd490e2ceab3ff1c6ed85b17f0cea54aefd797d7e768b1c6940656affdabf90f full-surface-duration-comparison.pdf +02327be235c219a32e65e8a13426d8cadf6f82bc19a11c27df8085d3a89da490 full-surfaces-identity.json +cf6d241b27a1ba3fe3bf38a927549d904a2baa63bc18a9963b0f3c427d664ad2 full-surfaces-predictions.jsonl.gz +c4840d7bdaf56af150b65106c31c2cdf5ab6644071ca02cfdb7f5d20506a300f full-surfaces-progress.json +1de4933f1718fcdf8cb44ceff1b3ed0c7cfc5612c111879732af2879b9e08d80 full-surfaces-score.json +3e0cef6620a19f5415ec4a947bd2dde42ee75509bf02697336db20e84aed97e7 kappa-audit-metadata-update.json +b61eb6401edfdefd979d36017e4209bb3a7b907010e1a9985a6af9e507815969 loader-audit.json +aed46a96a909a2c5ed20f94c26252dc290e94d5551a4a8d9800a971328a32f83 matched-runtime-control-validation.json +81b3a176ec847c1c1be0bf8ed80058c0b8bcaffdfa3c873f1ad97d6e8b566f79 matched-runtime-publication-review.json +ff109bae525fad5a87d10ad1bc55a9be3450a427c42dc0b8da82056be8dfd902 matched_controls.py +de8d12af689868c9baebb2054e64cfb38d583c224078aa8e95b829b57524f848 metadata-update.json +e9114f3f1647fc56a61162ce30b78ce12d0657143166dc1d51dc8213a3400cec model.pt +6378e5c54ab2c826195cbdfeecdd9057b3a2090a38e30cc0ac36319bd9e5bac3 mof-backend-sensitivity/README.md +520d2bf8a0e8406442eac52bd90030f775509d994869d8a8e87febda49148189 mof-backend-sensitivity/duration100k-runtime12-step100000-case.json +5d82738956186ea0ae6c30a6cc57f232b2f2b4e592cdb48dc191c64bf52ef1b3 mof-backend-sensitivity/duration100k-step100000-case.json +bb2c46b082f325e3a12d996e45bccdf65638f21005a91c89559bef5591ce11a9 mof-backend-sensitivity/duration100k-step100000-cpu-case.json +77d278cad12e9a4c528a555de7f2d7e7ea9ea1138387b5c52f4b21b0380cd4e9 mof-backend-sensitivity/report.json +aabdd288d22ddbc3b0e9cdb0ba3ac71f24c148daabede11e8af4544a33324f66 mof-backend-sensitivity/review_mof100k_backend_scans.py +7e2e2733e66a123ecfa0ef9cabf5354487cf4fda6aa44ff9ffea367409250172 mof-backend-sensitivity/scans.pdf +01e0d376352c8f8de9e5e13cf97756480f3a3a3244ea4d681b96c966af352e17 mof-backend-sensitivity/scans.png +1240d2eb13064b5c1615b73b5820587faaa9979fa29f7c55bd3b19a0b3582508 mof-scan-diagnostic.json +07b4355232fe7d67669c674e0bff0162bea2169226c1ac679caf9806d737941c mof-sensitivity-metadata-update.json +5fc18c2a57f3d1b7664fa52f566812a0a558c3a0d7a078e0817bb16d319be749 neb-audit-metadata-update.json +aa808c28a59b033e65dcdfbf0b24acd46053426534620cef5de39632decc0ffc neb57-diagnostic-metadata-update.json +be353f6ff845951df65bdf1bb84cc34b21b84891d82cb51686572f3854522f61 neighbor-coverage-metadata-update.json +8f228561566c04d3ef44d566658c158890bf9280a3b025246ddc328fed2d871c parent-training-and-validation.md +3b48a7431c65fb73188e1019a0e8977caf04dbbe9c69cd389d43b1d894724e45 pause_background_workers.py +dc7eb169056d4cecf365acc075da76cb52b0e523a10048fed8bd2f7747d12439 pipeline-orchestration-update.json +b870c0492a2f9e1bfbbcd292717928459fcf2b10891678f61e9098831497477e pool-stress-path-audit.json +7ee370190036a302d8c27f9e396f9bd1c8669c2689cc57d44f27fc6bf58b9377 predecessor-control-repeatability.json +534403ed3f7c41a4e8ece63d62619ac156162622982fe3ef301f7af4c4823f5a preparation.json +f24557a332118ef8a9063881564c3f05a00e5ca2d62c7df330888022728c20b9 prepare_continuation.py +28929714f5aed5a870a5e3d1e7062e49965c460089b893b8e9a9237b0203bcb6 prepare_coverage_config.py +637675084e7d9a09a9a6d035fb2357803df5e4eaed2fc2e4a65d99a0f52d766c prepare_coverage_h_config.py +a12b1aa4774852346113bc350cfe6ffe97c0aa93293e5ce2cf1b766d79fb3d59 prepare_omat_dev_diagnostic.py +a69395bca75158076ef549d82205e3f41083a871e5c1da747d1ed6446df101f7 prepare_training.py +a69395bca75158076ef549d82205e3f41083a871e5c1da747d1ed6446df101f7 prepare_v1.py +50473f06807de0241fc959d558c1b61199b41116d7b5e9e259ffcfbe3ba9f277 publication-review.json +335127beca52f68b64c720624349feec4312e0b78c763b634e50bc02a831753b relative_energy.py +683c1a88378806bb1374caa48a8fdfc4b8efbcbc9faf1c78e807cc7acb28cb19 relative_training.py +a0f7033adebd46911a57c8df2487a13108c1c58774040d5fe9dc8ff83cb96b97 resource-scientific-review.json +7aa5409c3556eec576e7a0fcdcef25a4fe764f9932f21efa8a3ffaad4f56f6c0 run_mof_logged.py +e3472bbbf7b64b283d2162bce39c8a964dfef38911454fd6e2963d22b9b1cb99 run_panel.py +e052d936ae5cee824602d876fb0f989d114c993180d37970550114a42137501e runtime-experiment-plan.json +5a7aaf419ad9bb6719f47c4af93e1f41c879491638efabfb362bca8f5069de81 runtime-profile-provenance.json +f42d4de3a0703aae19562afaf92cdf7ab953c038413d8e5f5ed5f74eb6f37834 runtime-thread-observation.json +5f992fea43279081319d94509ba9b9484dea3d49620c3a7b02060ffff5b8506e runtime12_stage.py +e81e3f0f8da139ef4755193317882c8aa6a958df67123909e8baac1392838ce1 selection-plan.json +ca2bb6e294cd73be4b60f7f28aa3e04d4b4358a19a54fca84ab54b1baddd81b9 selection.jsonl.gz +6ceadefcebfb794d378cabc249da571e0b52aa8913e74ef6d5a972cec9fd619a six-suite-status-metadata-update.json +f24e92ffc7963d6b022a26ed7c2d8cbeeaabc12395556dbd3db79fe495fe7b5f smoke.yaml +ce7e36ec4e9ec838dc0b0988aeba284e2d31ad4de94cfb9f58a577c227b4f03d source-stress-decomposition.json +37cb7efbe6e795b21c80c8e5bcd08afe2d0fbf59d097f76b6b565fa85dc8c5c8 split-audit.json +4fe23321a1e15186bac0fd3d9e84c3f14df65115d72801b711aea3339cf65014 surfaces-metadata-update.json +d082e67d20666f85927512a44ca7657b2cfd869e9f579cd4976046aa7233fc20 train_single.py +4edb51c2f8006cd3a32378914f49231bfdc59db44c68a4e519eafeb942680b7e training-neighbor-coverage/README.md +9533fd3a50134f522350c75340b8371ae011965a33bc3e04fa667f75de4dcaac training-neighbor-coverage/confirmed-empty-graph-failure.json +214158d1dfe5fce49ec24b7047eafaab9259e4c3557ed0e80e3262ae63ea2629 training-neighbor-coverage/isolated-atom-review/README.md +d5be3401bc5f8f77f87da9f66de6f1d4516392bc1bc27a17a2caa5e4610c9569 training-neighbor-coverage/isolated-atom-review/plan.json +7c68ebc11e20ad8e5aa918b3a99dd175016e5d47ac350f4490a6d3b619fde6e4 training-neighbor-coverage/isolated-atom-review/report.json +bb84e1ee0567694c139577c3e3aa55395a350361ab0f0e9ddf1834d49033fef6 training-neighbor-coverage/plan.json +8463b5b2bab690e8d445398db1b8bb213ead18b52ef2858948ddffbe8170c7e9 training-neighbor-coverage/report.json +68c99d90fa22cc28dc5208eb13fe341289d5523e4e3871cd82f8efafb53456be training-summary.json +5de3a59493b8f6166833006612b06c82f3e7c060515da59b0445b6a6303f1eb1 validation-panel.json +6297922ca40f5361d89397dd70813bf90aea55ec478770af4a7b2a26bd7582b2 validation.json diff --git a/shared/package-files/2e/2ea4a717a746c15cfa898719b58815519482e2875a2119c5457e6f0885af589d/blob b/shared/package-files/2e/2ea4a717a746c15cfa898719b58815519482e2875a2119c5457e6f0885af589d/blob new file mode 100644 index 0000000000000000000000000000000000000000..c079aff696b86c62a8e80da26adac7584f549a8d --- /dev/null +++ b/shared/package-files/2e/2ea4a717a746c15cfa898719b58815519482e2875a2119c5457e6f0885af589d/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2ea4a717a746c15cfa898719b58815519482e2875a2119c5457e6f0885af589d +size 353320 diff --git a/shared/package-files/2e/2eab602cade8e09484ac61e8c813333e531828c91cfe2e4ffdef8f2908dcb7f7/blob b/shared/package-files/2e/2eab602cade8e09484ac61e8c813333e531828c91cfe2e4ffdef8f2908dcb7f7/blob new file mode 100644 index 0000000000000000000000000000000000000000..636b6b28f33123df81e7ee30559c2c4ea03ad999 --- /dev/null +++ b/shared/package-files/2e/2eab602cade8e09484ac61e8c813333e531828c91cfe2e4ffdef8f2908dcb7f7/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API convolution_overrideable { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, c10::SymIntArrayRef, c10::SymIntArrayRef, c10::SymIntArrayRef, bool, c10::SymIntArrayRef, c10::SymInt); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::convolution_overrideable") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "convolution_overrideable(Tensor input, Tensor weight, Tensor? bias, SymInt[] stride, SymInt[] padding, SymInt[] dilation, bool transposed, SymInt[] output_padding, SymInt groups) -> Tensor") + static at::Tensor call(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups); +}; + +struct TORCH_API convolution_overrideable_out { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, const c10::optional &, c10::SymIntArrayRef, c10::SymIntArrayRef, c10::SymIntArrayRef, bool, c10::SymIntArrayRef, c10::SymInt, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::convolution_overrideable") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "convolution_overrideable.out(Tensor input, Tensor weight, Tensor? bias, SymInt[] stride, SymInt[] padding, SymInt[] dilation, bool transposed, SymInt[] output_padding, SymInt groups, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef dilation, bool transposed, c10::SymIntArrayRef output_padding, c10::SymInt groups, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/2e/2eabb41cdb7633a98cb0d49f3d7938f87853397075d0d4c49227a3abde1d063f/blob b/shared/package-files/2e/2eabb41cdb7633a98cb0d49f3d7938f87853397075d0d4c49227a3abde1d063f/blob new file mode 100644 index 0000000000000000000000000000000000000000..a8a0753f44fac5815a1c33b34a2eb243737ebede --- /dev/null +++ b/shared/package-files/2e/2eabb41cdb7633a98cb0d49f3d7938f87853397075d0d4c49227a3abde1d063f/blob @@ -0,0 +1,21 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor avg_pool1d(const at::Tensor & self, at::IntArrayRef kernel_size, at::IntArrayRef stride={}, at::IntArrayRef padding=0, bool ceil_mode=false, bool count_include_pad=true); +} // namespace native +} // namespace at diff --git a/shared/package-files/2e/2eabb4ac0bbc238804fe01626bb3b94c9711d1653350382481b886a819cb3640/blob b/shared/package-files/2e/2eabb4ac0bbc238804fe01626bb3b94c9711d1653350382481b886a819cb3640/blob new file mode 100644 index 0000000000000000000000000000000000000000..7f877ae458e6b21e96535244ad27d100f6d93cc9 --- /dev/null +++ b/shared/package-files/2e/2eabb4ac0bbc238804fe01626bb3b94c9711d1653350382481b886a819cb3640/blob @@ -0,0 +1,22 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor detach(const at::Tensor & self); +TORCH_API at::Tensor & detach_(at::Tensor & self); +} // namespace native +} // namespace at diff --git a/shared/package-files/2e/2ead4cdad023d0c362f960157422c50f36596e151be4090d0e1d3ccb83aefe15/blob b/shared/package-files/2e/2ead4cdad023d0c362f960157422c50f36596e151be4090d0e1d3ccb83aefe15/blob new file mode 100644 index 0000000000000000000000000000000000000000..00a3c03378d6e5c451026005c857bda8422fc4a7 --- /dev/null +++ b/shared/package-files/2e/2ead4cdad023d0c362f960157422c50f36596e151be4090d0e1d3ccb83aefe15/blob @@ -0,0 +1,91 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::mps_convolution_backward(Tensor self, Tensor grad_output, Tensor weight, SymInt[] padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool[3] output_mask) -> (Tensor, Tensor, Tensor) +inline ::std::tuple mps_convolution_backward(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, ::std::array output_mask) { + return at::_ops::mps_convolution_backward::call(self, grad_output, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, output_mask); +} +namespace symint { + template ::value>> + ::std::tuple mps_convolution_backward(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, ::std::array output_mask) { + return at::_ops::mps_convolution_backward::call(self, grad_output, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, output_mask); + } +} + +// aten::mps_convolution_backward(Tensor self, Tensor grad_output, Tensor weight, SymInt[] padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool[3] output_mask) -> (Tensor, Tensor, Tensor) +inline ::std::tuple mps_convolution_backward_symint(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array output_mask) { + return at::_ops::mps_convolution_backward::call(self, grad_output, weight, padding, stride, dilation, groups, output_mask); +} +namespace symint { + template ::value>> + ::std::tuple mps_convolution_backward(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array output_mask) { + return at::_ops::mps_convolution_backward::call(self, grad_output, weight, padding, stride, dilation, groups, output_mask); + } +} + +// aten::mps_convolution_backward.out(Tensor self, Tensor grad_output, Tensor weight, SymInt[] padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) +inline ::std::tuple mps_convolution_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, ::std::array output_mask) { + return at::_ops::mps_convolution_backward_out::call(self, grad_output, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, output_mask, out0, out1, out2); +} +namespace symint { + template ::value>> + ::std::tuple mps_convolution_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, ::std::array output_mask) { + return at::_ops::mps_convolution_backward_out::call(self, grad_output, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, output_mask, out0, out1, out2); + } +} + +// aten::mps_convolution_backward.out(Tensor self, Tensor grad_output, Tensor weight, SymInt[] padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) +inline ::std::tuple mps_convolution_backward_outf(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, ::std::array output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) { + return at::_ops::mps_convolution_backward_out::call(self, grad_output, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, output_mask, out0, out1, out2); +} +namespace symint { + template ::value>> + ::std::tuple mps_convolution_backward_outf(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, at::IntArrayRef padding, at::IntArrayRef stride, at::IntArrayRef dilation, int64_t groups, ::std::array output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) { + return at::_ops::mps_convolution_backward_out::call(self, grad_output, weight, c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(dilation), groups, output_mask, out0, out1, out2); + } +} + +// aten::mps_convolution_backward.out(Tensor self, Tensor grad_output, Tensor weight, SymInt[] padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) +inline ::std::tuple mps_convolution_backward_symint_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array output_mask) { + return at::_ops::mps_convolution_backward_out::call(self, grad_output, weight, padding, stride, dilation, groups, output_mask, out0, out1, out2); +} +namespace symint { + template ::value>> + ::std::tuple mps_convolution_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array output_mask) { + return at::_ops::mps_convolution_backward_out::call(self, grad_output, weight, padding, stride, dilation, groups, output_mask, out0, out1, out2); + } +} + +// aten::mps_convolution_backward.out(Tensor self, Tensor grad_output, Tensor weight, SymInt[] padding, SymInt[] stride, SymInt[] dilation, SymInt groups, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!)) +inline ::std::tuple mps_convolution_backward_symint_outf(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) { + return at::_ops::mps_convolution_backward_out::call(self, grad_output, weight, padding, stride, dilation, groups, output_mask, out0, out1, out2); +} +namespace symint { + template ::value>> + ::std::tuple mps_convolution_backward_outf(const at::Tensor & self, const at::Tensor & grad_output, const at::Tensor & weight, c10::SymIntArrayRef padding, c10::SymIntArrayRef stride, c10::SymIntArrayRef dilation, c10::SymInt groups, ::std::array output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) { + return at::_ops::mps_convolution_backward_out::call(self, grad_output, weight, padding, stride, dilation, groups, output_mask, out0, out1, out2); + } +} + +} diff --git a/shared/package-files/2e/2eb0e1b96a4fa1f4fcc3edbaefaf5094c583a852ee0bcf8715b1cce911477b3b/blob b/shared/package-files/2e/2eb0e1b96a4fa1f4fcc3edbaefaf5094c583a852ee0bcf8715b1cce911477b3b/blob new file mode 100644 index 0000000000000000000000000000000000000000..a9d301ad757837927fb00168644fc7a06dd1a44c --- /dev/null +++ b/shared/package-files/2e/2eb0e1b96a4fa1f4fcc3edbaefaf5094c583a852ee0bcf8715b1cce911477b3b/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2eb0e1b96a4fa1f4fcc3edbaefaf5094c583a852ee0bcf8715b1cce911477b3b +size 5916984 diff --git a/shared/package-files/2e/2eb40044553fffc467aaf31fad117e24949cfd62b4dfd2a2d94dbad5e0f2151d/blob b/shared/package-files/2e/2eb40044553fffc467aaf31fad117e24949cfd62b4dfd2a2d94dbad5e0f2151d/blob new file mode 100644 index 0000000000000000000000000000000000000000..ca57511cb42bc27bd05e434a80937e49584a362c --- /dev/null +++ b/shared/package-files/2e/2eb40044553fffc467aaf31fad117e24949cfd62b4dfd2a2d94dbad5e0f2151d/blob @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeimplicitautograd { + +TORCH_API at::Tensor view_as(const at::Tensor & self, const at::Tensor & other); + +} // namespace compositeimplicitautograd +} // namespace at diff --git a/shared/package-files/2e/2eb44462c9e559c11b14a7bc2c1d088a551566f12f76d73d3b9672326a8cd5c8/blob b/shared/package-files/2e/2eb44462c9e559c11b14a7bc2c1d088a551566f12f76d73d3b9672326a8cd5c8/blob new file mode 100644 index 0000000000000000000000000000000000000000..3794f7f0e77834bf5da0d21be8a2d00285eb07ed --- /dev/null +++ b/shared/package-files/2e/2eb44462c9e559c11b14a7bc2c1d088a551566f12f76d73d3b9672326a8cd5c8/blob @@ -0,0 +1,51 @@ +import copy +import warnings +from torch.utils.data.datapipes.datapipe import IterDataPipe + +__all__ = ["IterableWrapperIterDataPipe", ] + + +class IterableWrapperIterDataPipe(IterDataPipe): + r""" + Wraps an iterable object to create an IterDataPipe. + + Args: + iterable: Iterable object to be wrapped into an IterDataPipe + deepcopy: Option to deepcopy input iterable object for each + iterator. The copy is made when the first element is read in ``iter()``. + + .. note:: + If ``deepcopy`` is explicitly set to ``False``, users should ensure + that the data pipeline doesn't contain any in-place operations over + the iterable instance to prevent data inconsistency across iterations. + + Example: + >>> # xdoctest: +SKIP + >>> from torchdata.datapipes.iter import IterableWrapper + >>> dp = IterableWrapper(range(10)) + >>> list(dp) + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + """ + + def __init__(self, iterable, deepcopy=True): + self.iterable = iterable + self.deepcopy = deepcopy + + def __iter__(self): + source_data = self.iterable + if self.deepcopy: + try: + source_data = copy.deepcopy(self.iterable) + # For the case that data cannot be deep-copied, + # all in-place operations will affect iterable variable. + # When this DataPipe is iterated second time, it will + # yield modified items. + except TypeError: + warnings.warn( + "The input iterable can not be deepcopied, " + "please be aware of in-place modification would affect source data." + ) + yield from source_data + + def __len__(self): + return len(self.iterable) diff --git a/shared/package-files/2e/2eb6246b0764da26e8e0c408cdab10aff3cf03be070dbd5ad8c7dd2e79c470d2/blob b/shared/package-files/2e/2eb6246b0764da26e8e0c408cdab10aff3cf03be070dbd5ad8c7dd2e79c470d2/blob new file mode 100644 index 0000000000000000000000000000000000000000..74572a09ade1b8aa7e97313d3e8280808622afb5 --- /dev/null +++ b/shared/package-files/2e/2eb6246b0764da26e8e0c408cdab10aff3cf03be070dbd5ad8c7dd2e79c470d2/blob @@ -0,0 +1,555 @@ +#!/usr/bin/env python3 + +# Copyright (c) Facebook, Inc. and its affiliates. +# All rights reserved. +# +# This source code is licensed under the BSD-style license found in the +# LICENSE file in the root directory of this source tree. + +import abc +import logging +import os +import re +import signal +import subprocess +import sys +import time +from contextlib import nullcontext +from dataclasses import dataclass, field +from enum import IntFlag +from typing import Any, Callable, Dict, Optional, Set, Tuple, Union + +import torch.multiprocessing as mp +from torchelastic.multiprocessing.errors import ProcessFailure, record +from torchelastic.multiprocessing.redirects import redirect_stderr, redirect_stdout +from torchelastic.multiprocessing.tail_log import TailLog + +log = logging.getLogger(__name__) + + +def _validate_full_rank(d: Dict[int, Any], nprocs: int, what: str): + actual_keys = set(d.keys()) + expected_keys = set(range(nprocs)) + + if actual_keys != expected_keys: + raise RuntimeError( + f"{what}, local rank mapping mismatch," + f" expected: {expected_keys}, actual: {actual_keys}" + ) + + +_MAPPING_REGEX = r"^(\d:[0123],)*(\d:[0123])$" +_VALUE_REGEX = r"^[0123]$" + + +class Std(IntFlag): + NONE = 0 + OUT = 1 + ERR = 2 + ALL = OUT | ERR + + @classmethod + def from_str(cls, vm: str) -> Union["Std", Dict[int, "Std"]]: + """ + Example: + + :: + + from_str("0") -> Std.NONE + from_str("1") -> Std.OUT + from_str("0:3,1:0,2:1,3:2") -> {0: Std.ALL, 1: Std.NONE, 2: Std.OUT, 3: Std.ERR} + + Any other input raises an exception + """ + + def to_std(v): + v = int(v) + for s in Std: + if s == v: + return s + # return None -> should NEVER reach here since we regex check input + + if re.match(_VALUE_REGEX, vm): # vm is a number (e.g. 0) + return to_std(vm) + elif re.match(_MAPPING_REGEX, vm): # vm is a mapping (e.g. 0:1,1:2) + d: Dict[int, Std] = {} + for m in vm.split(","): + i, v = m.split(":") + d[int(i)] = to_std(v) + return d + else: + raise ValueError( + f"{vm} does not match: <{_VALUE_REGEX}> or <{_MAPPING_REGEX}>" + ) + + +def to_map( + val_or_map: Union[Std, Dict[int, Std]], local_world_size: int +) -> Dict[int, Std]: + """ + Certain APIs take redirect settings either as a single value (e.g. apply to all + local ranks) or as an explicit user-provided mapping. This method is a convenience + method that converts a value or mapping into a mapping. + + Example: + + :: + + to_map(Std.OUT, local_world_size=2) # returns: {0: Std.OUT, 1: Std.OUT} + to_map({1: Std.OUT}, local_world_size=2) # returns: {0: Std.NONE, 1: Std.OUT} + to_map({0: Std.OUT, 1: Std.OUT}, local_world_size=2) # returns: {0: Std.OUT, 1: Std.OUT} + """ + if isinstance(val_or_map, Std): + return {i: val_or_map for i in range(local_world_size)} + else: + map = {} + for i in range(local_world_size): + map[i] = val_or_map.get(i, Std.NONE) + return map + + +@dataclass +class RunProcsResult: + """ + Results of a completed run of processes started with ``start_processes()``. + Returned by ``PContext``. + + Note the following: + + 1. All fields are mapped by local rank + 2. ``return_values`` - only populated for functions (not the binaries). + 3. ``stdouts`` - path to stdout.log (empty string if no redirect) + 4. ``stderrs`` - path to stderr.log (empty string if no redirect) + + """ + + return_values: Dict[int, Any] = field(default_factory=dict) + failures: Dict[int, ProcessFailure] = field(default_factory=dict) + stdouts: Dict[int, str] = field(default_factory=dict) + stderrs: Dict[int, str] = field(default_factory=dict) + + def is_failed(self) -> bool: + return len(self.failures) > 0 + + +class PContext(abc.ABC): + """ + The base class that standardizes operations over a set of processes + that are launched via different mechanisms. The name ``PContext`` + is intentional to disambiguate with ``torch.multiprocessing.ProcessContext``. + + .. warning:: stdouts and stderrs should ALWAYS be a superset of + tee_stdouts and tee_stderrs (respectively) this is b/c + tee is implemented as a redirect + tail -f + """ + + def __init__( + self, + name: str, + entrypoint: Union[Callable, str], + args: Dict[int, Tuple], + envs: Dict[int, Dict[str, str]], + stdouts: Dict[int, str], + stderrs: Dict[int, str], + tee_stdouts: Dict[int, str], + tee_stderrs: Dict[int, str], + error_files: Dict[int, str], + ): + self.name = name + # validate that all mappings have the same number of keys and + # all local ranks are accounted for + nprocs = len(args) + _validate_full_rank(stdouts, nprocs, "stdouts") + _validate_full_rank(stderrs, nprocs, "stderrs") + + self.entrypoint = entrypoint + self.args = args + self.envs = envs + self.stdouts = stdouts + self.stderrs = stderrs + self.error_files = error_files + self.nprocs = nprocs + + self._stdout_tail = TailLog(name, tee_stdouts, sys.stdout) + self._stderr_tail = TailLog(name, tee_stderrs, sys.stderr) + + def start(self) -> None: + """ + Start processes using parameters defined in the constructor. + """ + self._start() + self._stdout_tail.start() + self._stderr_tail.start() + + @abc.abstractmethod + def _start(self) -> None: + """ + Start processes using strategy defined in a particular context. + """ + raise NotImplementedError() + + @abc.abstractmethod + def _poll(self) -> Optional[RunProcsResult]: + """ + Polls the run status of the processes running under this context. + This method follows an "all-or-nothing" policy and returns + a ``RunProcessResults`` object if either all processes complete + successfully or any process fails. Returns ``None`` if + all processes are still running. + """ + raise NotImplementedError() + + def wait(self, timeout: float = -1, period: float = 1) -> Optional[RunProcsResult]: + """ + Waits for the specified ``timeout`` seconds, polling every ``period`` seconds + for the processes to be done. Returns ``None`` if the processes are still running + on timeout expiry. Negative timeout values are interpreted as "wait-forever". + A timeout value of zero simply queries the status of the processes (e.g. equivalent + to a poll). + """ + + if timeout == 0: + return self._poll() + + if timeout < 0: + timeout = sys.maxsize + + expiry = time.time() + timeout + while time.time() < expiry: + pr = self._poll() + if pr: + return pr + time.sleep(period) + + return None + + @abc.abstractmethod + def pids(self) -> Dict[int, int]: + """ + Returns pids of processes mapped by their respective local_ranks + """ + raise NotImplementedError() + + @abc.abstractmethod + def _close(self) -> None: + r""" + Terminates all processes managed by this context and cleans up any + meta resources (e.g. redirect, error_file files). + """ + raise NotImplementedError() + + def close(self) -> None: + self._close() + if self._stdout_tail: + self._stdout_tail.stop() + if self._stderr_tail: + self._stderr_tail.stop() + + +def _wrap( + local_rank: int, + fn: Callable, + args: Dict[int, Tuple], + envs: Dict[int, Dict[str, str]], + stdout_redirects: Dict[int, str], # redirect file for stdout (to console if None) + stderr_redirects: Dict[int, str], # redirect file for stderr (to console if None) + ret_vals: Dict[int, mp.SimpleQueue], +) -> None: + # get the per-rank params up front so we fail fast if no mapping is found + args_ = args[local_rank] + env_ = envs[local_rank] + ret_val_ = ret_vals[local_rank] + + stdout_rd = stdout_redirects[local_rank] + stderr_rd = stderr_redirects[local_rank] + + stdout_cm = redirect_stdout(stdout_rd) if stdout_rd else nullcontext() + stderr_cm = redirect_stderr(stderr_rd) if stderr_rd else nullcontext() + + for k, v in env_.items(): + os.environ[k] = v + + with stdout_cm, stderr_cm: + ret = record(fn)(*args_) + ret_val_.put(ret) + + +class MultiprocessContext(PContext): + """ + ``PContext`` holding worker processes invoked as a function. + """ + + def __init__( + self, + name: str, + entrypoint: Callable, + args: Dict[int, Tuple], + envs: Dict[int, Dict[str, str]], + stdouts: Dict[int, str], + stderrs: Dict[int, str], + tee_stdouts: Dict[int, str], + tee_stderrs: Dict[int, str], + error_files: Dict[int, str], + start_method: str, + ): + super().__init__( + name, + entrypoint, + args, + envs, + stdouts, + stderrs, + tee_stdouts, + tee_stderrs, + error_files, + ) + + self.start_method = start_method + # each ret_val queue will always contain a single element. + self._ret_vals = { + local_rank: mp.get_context(self.start_method).SimpleQueue() + for local_rank in range(self.nprocs) + } + + # see comments in ``join()`` for what this is + self._return_values: Dict[int, Any] = {} + # pyre-fixme[8]: The attribute is defined in _start method + self._pc: mp.ProcessContext = None + + def _start(self): + if self._pc: + raise ValueError( + "The process context already initialized. Most likely the start method got called twice." + ) + self._pc: mp.ProcessContext = mp.start_processes( + fn=_wrap, + args=( + self.entrypoint, + self.args, + self.envs, + self.stdouts, + self.stderrs, + self._ret_vals, + ), + nprocs=self.nprocs, + join=False, + daemon=False, + start_method=self.start_method, + ) + + def _poll(self) -> Optional[RunProcsResult]: + try: + # torch.mp.ProcessContext returns True if all the workers have + # successfully finished, False if some/all are still running + # and throws an Exception if some/all of them failed + # timeout < 0 checks worker status and return immediately + done = self._pc.join(-1) + + # IMPORTANT: we use multiprocessing.Queue to carry worker return values + # back to the parent, the worker process will wait before terminating + # until all the buffered items are fed by the feeder thread to the underlying + # pipe. Hence to prevent deadlocks on large return values, + # we opportunistically try queue.get on each join call + # See: https://docs.python.org/2/library/multiprocessing.html#all-platforms + for local_rank in range(0, self.nprocs): + return_queue = self._ret_vals[local_rank] + if not return_queue.empty(): + # save the return values temporarily into a member var + self._return_values[local_rank] = return_queue.get() + + if done: + # we should ALWAYS have ALL the return values when all the processes are done + _validate_full_rank( + self._return_values, self.nprocs, "return_value queue" + ) + self.close() + return RunProcsResult( + return_values=self._return_values, + stdouts=self.stdouts, + stderrs=self.stderrs, + ) + else: + return None + except (mp.ProcessRaisedException, mp.ProcessExitedException) as e: + failed_local_rank = e.error_index + # pyre-ignore entrypoint fn has a __qualname__. + fn_name = self.entrypoint.__qualname__ + failed_proc = self._pc.processes[failed_local_rank] + error_filepath = self.error_files[failed_local_rank] + + log.error( + f"failed (exitcode: {failed_proc.exitcode})" + f" local_rank: {failed_local_rank} (pid: {e.pid})" + f" of fn: {fn_name} (start_method: {self.start_method})", + exc_info=True, + ) + + self.close() + return RunProcsResult( + failures={ + failed_local_rank: ProcessFailure( + local_rank=failed_local_rank, + pid=e.pid, + exitcode=failed_proc.exitcode, + error_file=error_filepath, + ) + }, + stdouts=self.stdouts, + stderrs=self.stderrs, + ) + + def pids(self) -> Dict[int, int]: + return {local_rank: pid for local_rank, pid in enumerate(self._pc.pids())} + + def _close(self) -> None: + if self._pc: + for proc in self._pc.processes: + proc.terminate() + proc.join() + + +class SubprocessHandler: + """ + Convenience wrapper around python's ``subprocess.Popen``. Keeps track of + meta-objects associated to the process (e.g. stdout and stderr redirect fds). + """ + + def __init__( + self, + entrypoint: str, + args: Tuple, + env: Dict[str, str], + preexec_fn: Callable, + stdout: str, + stderr: str, + ): + self._stdout = open(stdout, "w") if stdout else None + self._stderr = open(stderr, "w") if stderr else None + args_str = [str(e) for e in args] + + # inherit parent environment vars + env_vars = os.environ.copy() + env_vars.update(env) + + self.proc: subprocess.Popen = subprocess.Popen( + args=(entrypoint, *args_str), + env=env_vars, + preexec_fn=preexec_fn, + stdout=self._stdout, + stderr=self._stderr, + ) + + def close(self): + self.proc.terminate() + self.proc.wait() + if self._stdout: + self._stdout.close() + if self._stderr: + self._stderr.close() + + +class SubprocessContext(PContext): + """ + ``PContext`` holding worker processes invoked as a binary. + """ + + def __init__( + self, + name: str, + entrypoint: str, + args: Dict[int, Tuple], + envs: Dict[int, Dict[str, str]], + stdouts: Dict[int, str], + stderrs: Dict[int, str], + tee_stdouts: Dict[int, str], + tee_stderrs: Dict[int, str], + error_files: Dict[int, str], + ): + super().__init__( + name, + entrypoint, + args, + envs, + stdouts, + stderrs, + tee_stdouts, + tee_stderrs, + error_files, + ) + + # state vector; _vdone[local_rank] -> is local_rank finished or not + self._running_local_ranks: Set[int] = set(range(self.nprocs)) + self._failures: Dict[int, ProcessFailure] = {} + # pyre-fixme[8]: The attribute is defined in _start method + self.subprocess_handlers: Dict[int, SubprocessHandler] = None + + def _start(self): + if self.subprocess_handlers: + raise ValueError( + "The subprocess handlers already initialized. Most likely the start method got called twice." + ) + self.subprocess_handlers: Dict[int, SubprocessHandler] = { + local_rank: SubprocessHandler( + entrypoint=self.entrypoint, + args=self.args[local_rank], + env=self.envs[local_rank], + preexec_fn=mp._prctl_pr_set_pdeathsig(signal.SIGTERM), + stdout=self.stdouts[local_rank], + stderr=self.stderrs[local_rank], + ) + for local_rank in range(self.nprocs) + } + + def _poll(self) -> Optional[RunProcsResult]: + done_local_ranks = set() + for local_rank in self._running_local_ranks: + handler = self.subprocess_handlers[local_rank] + exitcode = handler.proc.poll() + if exitcode is not None: + done_local_ranks.add(local_rank) + if exitcode != 0: # failed or signaled + self._failures[local_rank] = ProcessFailure( + local_rank=local_rank, + pid=handler.proc.pid, + exitcode=exitcode, + error_file=self.error_files[local_rank], + ) + # else: --> succeeded; nothing to do + + self._running_local_ranks.difference_update(done_local_ranks) + + # if ALL procs are finished or ANY have failed + if not self._running_local_ranks or self._failures: + self.close() # terminate all running procs + result = RunProcsResult( + failures=self._failures, + stdouts=self.stdouts, + stderrs=self.stderrs, + ) + if result.is_failed(): + first_failure = min(result.failures.values(), key=lambda f: f.timestamp) + log.error( + f"failed (exitcode: {first_failure.exitcode})" + f" local_rank: {first_failure.local_rank} (pid: {first_failure.pid})" + f" of binary: {self.entrypoint}" + ) + else: + # Populate return with dummy values. This provides consistency with MultiprocessingHandler + result.return_values = { + local_rank: None for local_rank in range(self.nprocs) + } + + return result + else: # there are no failures and procs still running + return None + + def pids(self) -> Dict[int, int]: + return { + local_rank: sh.proc.pid + for local_rank, sh in self.subprocess_handlers.items() + } + + def _close(self) -> None: + if self.subprocess_handlers: + for handler in self.subprocess_handlers.values(): + handler.close() diff --git a/shared/package-files/2e/2eb9c84a7741917b5dba0bce59e464f59198425ced148e72ab2b6869988a3909/blob b/shared/package-files/2e/2eb9c84a7741917b5dba0bce59e464f59198425ced148e72ab2b6869988a3909/blob new file mode 100644 index 0000000000000000000000000000000000000000..6b363a508907cc064e41794720657541fc28c301 --- /dev/null +++ b/shared/package-files/2e/2eb9c84a7741917b5dba0bce59e464f59198425ced148e72ab2b6869988a3909/blob @@ -0,0 +1,19 @@ +#define TORCH_ASSERT_NO_OPERATORS + +#include +#include +#include + +namespace at { + +// NB: this is explicitly copied here (via codegen) rather than +// included via NativeFunctions.h to avoid recompiling this file when +// NativeFunctions.h changes +namespace meta { +${meta_declaration} +} + +namespace native { +${native_declaration} +${native_definitions} +}} // namespace at::native diff --git a/shared/package-files/2e/2ebd6a872ab2c28a1b3648fdb007dda2fa05cbdbc17e4cf678775309ceec651b/blob b/shared/package-files/2e/2ebd6a872ab2c28a1b3648fdb007dda2fa05cbdbc17e4cf678775309ceec651b/blob new file mode 100644 index 0000000000000000000000000000000000000000..f0fb0d50d33b872bb1ca9a113905135fe9941e08 --- /dev/null +++ b/shared/package-files/2e/2ebd6a872ab2c28a1b3648fdb007dda2fa05cbdbc17e4cf678775309ceec651b/blob @@ -0,0 +1,307 @@ +# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license + +# Copyright (C) 2003-2017 Nominum, Inc. +# +# Permission to use, copy, modify, and distribute this software and its +# documentation for any purpose with or without fee is hereby granted, +# provided that the above copyright notice and this permission notice +# appear in all copies. +# +# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES +# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR +# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +import itertools + + +class Set: + """A simple set class. + + This class was originally used to deal with sets being missing in + ancient versions of python, but dnspython will continue to use it + as these sets are based on lists and are thus indexable, and this + ability is widely used in dnspython applications. + """ + + __slots__ = ["items"] + + def __init__(self, items=None): + """Initialize the set. + + *items*, an iterable or ``None``, the initial set of items. + """ + + self.items = dict() + if items is not None: + for item in items: + # This is safe for how we use set, but if other code + # subclasses it could be a legitimate issue. + self.add(item) # lgtm[py/init-calls-subclass] + + def __repr__(self): + return "dns.set.Set(%s)" % repr(list(self.items.keys())) + + def add(self, item): + """Add an item to the set.""" + + if item not in self.items: + self.items[item] = None + + def remove(self, item): + """Remove an item from the set.""" + + try: + del self.items[item] + except KeyError: + raise ValueError + + def discard(self, item): + """Remove an item from the set if present.""" + + self.items.pop(item, None) + + def pop(self): + """Remove an arbitrary item from the set.""" + (k, _) = self.items.popitem() + return k + + def _clone(self) -> "Set": + """Make a (shallow) copy of the set. + + There is a 'clone protocol' that subclasses of this class + should use. To make a copy, first call your super's _clone() + method, and use the object returned as the new instance. Then + make shallow copies of the attributes defined in the subclass. + + This protocol allows us to write the set algorithms that + return new instances (e.g. union) once, and keep using them in + subclasses. + """ + + if hasattr(self, "_clone_class"): + cls = self._clone_class # type: ignore + else: + cls = self.__class__ + obj = cls.__new__(cls) + obj.items = dict() + obj.items.update(self.items) + return obj + + def __copy__(self): + """Make a (shallow) copy of the set.""" + + return self._clone() + + def copy(self): + """Make a (shallow) copy of the set.""" + + return self._clone() + + def union_update(self, other): + """Update the set, adding any elements from other which are not + already in the set. + """ + + if not isinstance(other, Set): + raise ValueError("other must be a Set instance") + if self is other: # lgtm[py/comparison-using-is] + return + for item in other.items: + self.add(item) + + def intersection_update(self, other): + """Update the set, removing any elements from other which are not + in both sets. + """ + + if not isinstance(other, Set): + raise ValueError("other must be a Set instance") + if self is other: # lgtm[py/comparison-using-is] + return + # we make a copy of the list so that we can remove items from + # the list without breaking the iterator. + for item in list(self.items): + if item not in other.items: + del self.items[item] + + def difference_update(self, other): + """Update the set, removing any elements from other which are in + the set. + """ + + if not isinstance(other, Set): + raise ValueError("other must be a Set instance") + if self is other: # lgtm[py/comparison-using-is] + self.items.clear() + else: + for item in other.items: + self.discard(item) + + def symmetric_difference_update(self, other): + """Update the set, retaining only elements unique to both sets.""" + + if not isinstance(other, Set): + raise ValueError("other must be a Set instance") + if self is other: # lgtm[py/comparison-using-is] + self.items.clear() + else: + overlap = self.intersection(other) + self.union_update(other) + self.difference_update(overlap) + + def union(self, other): + """Return a new set which is the union of ``self`` and ``other``. + + Returns the same Set type as this set. + """ + + obj = self._clone() + obj.union_update(other) + return obj + + def intersection(self, other): + """Return a new set which is the intersection of ``self`` and + ``other``. + + Returns the same Set type as this set. + """ + + obj = self._clone() + obj.intersection_update(other) + return obj + + def difference(self, other): + """Return a new set which ``self`` - ``other``, i.e. the items + in ``self`` which are not also in ``other``. + + Returns the same Set type as this set. + """ + + obj = self._clone() + obj.difference_update(other) + return obj + + def symmetric_difference(self, other): + """Return a new set which (``self`` - ``other``) | (``other`` + - ``self), ie: the items in either ``self`` or ``other`` which + are not contained in their intersection. + + Returns the same Set type as this set. + """ + + obj = self._clone() + obj.symmetric_difference_update(other) + return obj + + def __or__(self, other): + return self.union(other) + + def __and__(self, other): + return self.intersection(other) + + def __add__(self, other): + return self.union(other) + + def __sub__(self, other): + return self.difference(other) + + def __xor__(self, other): + return self.symmetric_difference(other) + + def __ior__(self, other): + self.union_update(other) + return self + + def __iand__(self, other): + self.intersection_update(other) + return self + + def __iadd__(self, other): + self.union_update(other) + return self + + def __isub__(self, other): + self.difference_update(other) + return self + + def __ixor__(self, other): + self.symmetric_difference_update(other) + return self + + def update(self, other): + """Update the set, adding any elements from other which are not + already in the set. + + *other*, the collection of items with which to update the set, which + may be any iterable type. + """ + + for item in other: + self.add(item) + + def clear(self): + """Make the set empty.""" + self.items.clear() + + def __eq__(self, other): + return self.items == other.items + + def __ne__(self, other): + return not self.__eq__(other) + + def __len__(self): + return len(self.items) + + def __iter__(self): + return iter(self.items) + + def __getitem__(self, i): + if isinstance(i, slice): + return list(itertools.islice(self.items, i.start, i.stop, i.step)) + else: + return next(itertools.islice(self.items, i, i + 1)) + + def __delitem__(self, i): + if isinstance(i, slice): + for elt in list(self[i]): + del self.items[elt] + else: + del self.items[self[i]] + + def issubset(self, other): + """Is this set a subset of *other*? + + Returns a ``bool``. + """ + + if not isinstance(other, Set): + raise ValueError("other must be a Set instance") + for item in self.items: + if item not in other.items: + return False + return True + + def issuperset(self, other): + """Is this set a superset of *other*? + + Returns a ``bool``. + """ + + if not isinstance(other, Set): + raise ValueError("other must be a Set instance") + for item in other.items: + if item not in self.items: + return False + return True + + def isdisjoint(self, other): + if not isinstance(other, Set): + raise ValueError("other must be a Set instance") + for item in other.items: + if item in self.items: + return False + return True diff --git a/shared/package-files/2e/2ebdb2ff589719bc9cd931b5d7f2dec8183b217151fbed270d48fbd8a30d69a5/blob b/shared/package-files/2e/2ebdb2ff589719bc9cd931b5d7f2dec8183b217151fbed270d48fbd8a30d69a5/blob new file mode 100644 index 0000000000000000000000000000000000000000..42d5b7a87c5601d9323c31c7ac19a74103afd249 --- /dev/null +++ b/shared/package-files/2e/2ebdb2ff589719bc9cd931b5d7f2dec8183b217151fbed270d48fbd8a30d69a5/blob @@ -0,0 +1,540 @@ +# -*- coding: utf-8 -*- +""" +Defines a variety of Pygments lexers for highlighting IPython code. + +This includes: + + IPythonLexer, IPython3Lexer + Lexers for pure IPython (python + magic/shell commands) + + IPythonPartialTracebackLexer, IPythonTracebackLexer + Supports 2.x and 3.x via keyword `python3`. The partial traceback + lexer reads everything but the Python code appearing in a traceback. + The full lexer combines the partial lexer with an IPython lexer. + + IPythonConsoleLexer + A lexer for IPython console sessions, with support for tracebacks. + + IPyLexer + A friendly lexer which examines the first line of text and from it, + decides whether to use an IPython lexer or an IPython console lexer. + This is probably the only lexer that needs to be explicitly added + to Pygments. + +""" +#----------------------------------------------------------------------------- +# Copyright (c) 2013, the IPython Development Team. +# +# Distributed under the terms of the Modified BSD License. +# +# The full license is in the file COPYING.txt, distributed with this software. +#----------------------------------------------------------------------------- + +# Standard library +import re + +# Third party +from pygments.lexers import ( + BashLexer, HtmlLexer, JavascriptLexer, RubyLexer, PerlLexer, PythonLexer, + Python3Lexer, TexLexer) +from pygments.lexer import ( + Lexer, DelegatingLexer, RegexLexer, do_insertions, bygroups, using, +) +from pygments.token import ( + Generic, Keyword, Literal, Name, Operator, Other, Text, Error, +) +from pygments.util import get_bool_opt + +# Local + +line_re = re.compile('.*?\n') + +__all__ = ['build_ipy_lexer', 'IPython3Lexer', 'IPythonLexer', + 'IPythonPartialTracebackLexer', 'IPythonTracebackLexer', + 'IPythonConsoleLexer', 'IPyLexer'] + + +def build_ipy_lexer(python3): + """Builds IPython lexers depending on the value of `python3`. + + The lexer inherits from an appropriate Python lexer and then adds + information about IPython specific keywords (i.e. magic commands, + shell commands, etc.) + + Parameters + ---------- + python3 : bool + If `True`, then build an IPython lexer from a Python 3 lexer. + + """ + # It would be nice to have a single IPython lexer class which takes + # a boolean `python3`. But since there are two Python lexer classes, + # we will also have two IPython lexer classes. + if python3: + PyLexer = Python3Lexer + name = 'IPython3' + aliases = ['ipython3'] + doc = """IPython3 Lexer""" + else: + PyLexer = PythonLexer + name = 'IPython' + aliases = ['ipython2', 'ipython'] + doc = """IPython Lexer""" + + ipython_tokens = [ + (r'(?s)(\s*)(%%capture)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))), + (r'(?s)(\s*)(%%debug)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))), + (r'(?is)(\s*)(%%html)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(HtmlLexer))), + (r'(?s)(\s*)(%%javascript)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(JavascriptLexer))), + (r'(?s)(\s*)(%%js)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(JavascriptLexer))), + (r'(?s)(\s*)(%%latex)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(TexLexer))), + (r'(?s)(\s*)(%%perl)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PerlLexer))), + (r'(?s)(\s*)(%%prun)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))), + (r'(?s)(\s*)(%%pypy)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))), + (r'(?s)(\s*)(%%python)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))), + (r'(?s)(\s*)(%%python2)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PythonLexer))), + (r'(?s)(\s*)(%%python3)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(Python3Lexer))), + (r'(?s)(\s*)(%%ruby)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(RubyLexer))), + (r'(?s)(\s*)(%%time)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))), + (r'(?s)(\s*)(%%timeit)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))), + (r'(?s)(\s*)(%%writefile)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))), + (r'(?s)(\s*)(%%file)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(PyLexer))), + (r"(?s)(\s*)(%%)(\w+)(.*)", bygroups(Text, Operator, Keyword, Text)), + (r'(?s)(^\s*)(%%!)([^\n]*\n)(.*)', bygroups(Text, Operator, Text, using(BashLexer))), + (r"(%%?)(\w+)(\?\??)$", bygroups(Operator, Keyword, Operator)), + (r"\b(\?\??)(\s*)$", bygroups(Operator, Text)), + (r'(%)(sx|sc|system)(.*)(\n)', bygroups(Operator, Keyword, + using(BashLexer), Text)), + (r'(%)(\w+)(.*\n)', bygroups(Operator, Keyword, Text)), + (r'^(!!)(.+)(\n)', bygroups(Operator, using(BashLexer), Text)), + (r'(!)(?!=)(.+)(\n)', bygroups(Operator, using(BashLexer), Text)), + (r'^(\s*)(\?\??)(\s*%{0,2}[\w\.\*]*)', bygroups(Text, Operator, Text)), + (r'(\s*%{0,2}[\w\.\*]*)(\?\??)(\s*)$', bygroups(Text, Operator, Text)), + ] + + tokens = PyLexer.tokens.copy() + tokens['root'] = ipython_tokens + tokens['root'] + + attrs = {'name': name, 'aliases': aliases, 'filenames': [], + '__doc__': doc, 'tokens': tokens} + + return type(name, (PyLexer,), attrs) + + +IPython3Lexer = build_ipy_lexer(python3=True) +IPythonLexer = build_ipy_lexer(python3=False) + + +class IPythonPartialTracebackLexer(RegexLexer): + """ + Partial lexer for IPython tracebacks. + + Handles all the non-python output. + + """ + name = 'IPython Partial Traceback' + + tokens = { + 'root': [ + # Tracebacks for syntax errors have a different style. + # For both types of tracebacks, we mark the first line with + # Generic.Traceback. For syntax errors, we mark the filename + # as we mark the filenames for non-syntax tracebacks. + # + # These two regexps define how IPythonConsoleLexer finds a + # traceback. + # + ## Non-syntax traceback + (r'^(\^C)?(-+\n)', bygroups(Error, Generic.Traceback)), + ## Syntax traceback + (r'^( File)(.*)(, line )(\d+\n)', + bygroups(Generic.Traceback, Name.Namespace, + Generic.Traceback, Literal.Number.Integer)), + + # (Exception Identifier)(Whitespace)(Traceback Message) + (r'(?u)(^[^\d\W]\w*)(\s*)(Traceback.*?\n)', + bygroups(Name.Exception, Generic.Whitespace, Text)), + # (Module/Filename)(Text)(Callee)(Function Signature) + # Better options for callee and function signature? + (r'(.*)( in )(.*)(\(.*\)\n)', + bygroups(Name.Namespace, Text, Name.Entity, Name.Tag)), + # Regular line: (Whitespace)(Line Number)(Python Code) + (r'(\s*?)(\d+)(.*?\n)', + bygroups(Generic.Whitespace, Literal.Number.Integer, Other)), + # Emphasized line: (Arrow)(Line Number)(Python Code) + # Using Exception token so arrow color matches the Exception. + (r'(-*>?\s?)(\d+)(.*?\n)', + bygroups(Name.Exception, Literal.Number.Integer, Other)), + # (Exception Identifier)(Message) + (r'(?u)(^[^\d\W]\w*)(:.*?\n)', + bygroups(Name.Exception, Text)), + # Tag everything else as Other, will be handled later. + (r'.*\n', Other), + ], + } + + +class IPythonTracebackLexer(DelegatingLexer): + """ + IPython traceback lexer. + + For doctests, the tracebacks can be snipped as much as desired with the + exception to the lines that designate a traceback. For non-syntax error + tracebacks, this is the line of hyphens. For syntax error tracebacks, + this is the line which lists the File and line number. + + """ + # The lexer inherits from DelegatingLexer. The "root" lexer is an + # appropriate IPython lexer, which depends on the value of the boolean + # `python3`. First, we parse with the partial IPython traceback lexer. + # Then, any code marked with the "Other" token is delegated to the root + # lexer. + # + name = 'IPython Traceback' + aliases = ['ipythontb'] + + def __init__(self, **options): + """ + A subclass of `DelegatingLexer` which delegates to the appropriate to either IPyLexer, + IPythonPartialTracebackLexer. + """ + # note we need a __init__ doc, as otherwise it inherits the doc from the super class + # which will fail the documentation build as it references section of the pygments docs that + # do not exists when building IPython's docs. + self.python3 = get_bool_opt(options, 'python3', False) + if self.python3: + self.aliases = ['ipython3tb'] + else: + self.aliases = ['ipython2tb', 'ipythontb'] + + if self.python3: + IPyLexer = IPython3Lexer + else: + IPyLexer = IPythonLexer + + DelegatingLexer.__init__(self, IPyLexer, + IPythonPartialTracebackLexer, **options) + +class IPythonConsoleLexer(Lexer): + """ + An IPython console lexer for IPython code-blocks and doctests, such as: + + .. code-block:: rst + + .. code-block:: ipythonconsole + + In [1]: a = 'foo' + + In [2]: a + Out[2]: 'foo' + + In [3]: print(a) + foo + + + Support is also provided for IPython exceptions: + + .. code-block:: rst + + .. code-block:: ipythonconsole + + In [1]: raise Exception + Traceback (most recent call last): + ... + Exception + + """ + name = 'IPython console session' + aliases = ['ipythonconsole'] + mimetypes = ['text/x-ipython-console'] + + # The regexps used to determine what is input and what is output. + # The default prompts for IPython are: + # + # in = 'In [#]: ' + # continuation = ' .D.: ' + # template = 'Out[#]: ' + # + # Where '#' is the 'prompt number' or 'execution count' and 'D' + # D is a number of dots matching the width of the execution count + # + in1_regex = r'In \[[0-9]+\]: ' + in2_regex = r' \.\.+\.: ' + out_regex = r'Out\[[0-9]+\]: ' + + #: The regex to determine when a traceback starts. + ipytb_start = re.compile(r'^(\^C)?(-+\n)|^( File)(.*)(, line )(\d+\n)') + + def __init__(self, **options): + """Initialize the IPython console lexer. + + Parameters + ---------- + python3 : bool + If `True`, then the console inputs are parsed using a Python 3 + lexer. Otherwise, they are parsed using a Python 2 lexer. + in1_regex : RegexObject + The compiled regular expression used to detect the start + of inputs. Although the IPython configuration setting may have a + trailing whitespace, do not include it in the regex. If `None`, + then the default input prompt is assumed. + in2_regex : RegexObject + The compiled regular expression used to detect the continuation + of inputs. Although the IPython configuration setting may have a + trailing whitespace, do not include it in the regex. If `None`, + then the default input prompt is assumed. + out_regex : RegexObject + The compiled regular expression used to detect outputs. If `None`, + then the default output prompt is assumed. + + """ + self.python3 = get_bool_opt(options, 'python3', False) + if self.python3: + self.aliases = ['ipython3console'] + else: + self.aliases = ['ipython2console', 'ipythonconsole'] + + in1_regex = options.get('in1_regex', self.in1_regex) + in2_regex = options.get('in2_regex', self.in2_regex) + out_regex = options.get('out_regex', self.out_regex) + + # So that we can work with input and output prompts which have been + # rstrip'd (possibly by editors) we also need rstrip'd variants. If + # we do not do this, then such prompts will be tagged as 'output'. + # The reason can't just use the rstrip'd variants instead is because + # we want any whitespace associated with the prompt to be inserted + # with the token. This allows formatted code to be modified so as hide + # the appearance of prompts, with the whitespace included. One example + # use of this is in copybutton.js from the standard lib Python docs. + in1_regex_rstrip = in1_regex.rstrip() + '\n' + in2_regex_rstrip = in2_regex.rstrip() + '\n' + out_regex_rstrip = out_regex.rstrip() + '\n' + + # Compile and save them all. + attrs = ['in1_regex', 'in2_regex', 'out_regex', + 'in1_regex_rstrip', 'in2_regex_rstrip', 'out_regex_rstrip'] + for attr in attrs: + self.__setattr__(attr, re.compile(locals()[attr])) + + Lexer.__init__(self, **options) + + if self.python3: + pylexer = IPython3Lexer + tblexer = IPythonTracebackLexer + else: + pylexer = IPythonLexer + tblexer = IPythonTracebackLexer + + self.pylexer = pylexer(**options) + self.tblexer = tblexer(**options) + + self.reset() + + def reset(self): + self.mode = 'output' + self.index = 0 + self.buffer = u'' + self.insertions = [] + + def buffered_tokens(self): + """ + Generator of unprocessed tokens after doing insertions and before + changing to a new state. + + """ + if self.mode == 'output': + tokens = [(0, Generic.Output, self.buffer)] + elif self.mode == 'input': + tokens = self.pylexer.get_tokens_unprocessed(self.buffer) + else: # traceback + tokens = self.tblexer.get_tokens_unprocessed(self.buffer) + + for i, t, v in do_insertions(self.insertions, tokens): + # All token indexes are relative to the buffer. + yield self.index + i, t, v + + # Clear it all + self.index += len(self.buffer) + self.buffer = u'' + self.insertions = [] + + def get_mci(self, line): + """ + Parses the line and returns a 3-tuple: (mode, code, insertion). + + `mode` is the next mode (or state) of the lexer, and is always equal + to 'input', 'output', or 'tb'. + + `code` is a portion of the line that should be added to the buffer + corresponding to the next mode and eventually lexed by another lexer. + For example, `code` could be Python code if `mode` were 'input'. + + `insertion` is a 3-tuple (index, token, text) representing an + unprocessed "token" that will be inserted into the stream of tokens + that are created from the buffer once we change modes. This is usually + the input or output prompt. + + In general, the next mode depends on current mode and on the contents + of `line`. + + """ + # To reduce the number of regex match checks, we have multiple + # 'if' blocks instead of 'if-elif' blocks. + + # Check for possible end of input + in2_match = self.in2_regex.match(line) + in2_match_rstrip = self.in2_regex_rstrip.match(line) + if (in2_match and in2_match.group().rstrip() == line.rstrip()) or \ + in2_match_rstrip: + end_input = True + else: + end_input = False + if end_input and self.mode != 'tb': + # Only look for an end of input when not in tb mode. + # An ellipsis could appear within the traceback. + mode = 'output' + code = u'' + insertion = (0, Generic.Prompt, line) + return mode, code, insertion + + # Check for output prompt + out_match = self.out_regex.match(line) + out_match_rstrip = self.out_regex_rstrip.match(line) + if out_match or out_match_rstrip: + mode = 'output' + if out_match: + idx = out_match.end() + else: + idx = out_match_rstrip.end() + code = line[idx:] + # Use the 'heading' token for output. We cannot use Generic.Error + # since it would conflict with exceptions. + insertion = (0, Generic.Heading, line[:idx]) + return mode, code, insertion + + + # Check for input or continuation prompt (non stripped version) + in1_match = self.in1_regex.match(line) + if in1_match or (in2_match and self.mode != 'tb'): + # New input or when not in tb, continued input. + # We do not check for continued input when in tb since it is + # allowable to replace a long stack with an ellipsis. + mode = 'input' + if in1_match: + idx = in1_match.end() + else: # in2_match + idx = in2_match.end() + code = line[idx:] + insertion = (0, Generic.Prompt, line[:idx]) + return mode, code, insertion + + # Check for input or continuation prompt (stripped version) + in1_match_rstrip = self.in1_regex_rstrip.match(line) + if in1_match_rstrip or (in2_match_rstrip and self.mode != 'tb'): + # New input or when not in tb, continued input. + # We do not check for continued input when in tb since it is + # allowable to replace a long stack with an ellipsis. + mode = 'input' + if in1_match_rstrip: + idx = in1_match_rstrip.end() + else: # in2_match + idx = in2_match_rstrip.end() + code = line[idx:] + insertion = (0, Generic.Prompt, line[:idx]) + return mode, code, insertion + + # Check for traceback + if self.ipytb_start.match(line): + mode = 'tb' + code = line + insertion = None + return mode, code, insertion + + # All other stuff... + if self.mode in ('input', 'output'): + # We assume all other text is output. Multiline input that + # does not use the continuation marker cannot be detected. + # For example, the 3 in the following is clearly output: + # + # In [1]: print 3 + # 3 + # + # But the following second line is part of the input: + # + # In [2]: while True: + # print True + # + # In both cases, the 2nd line will be 'output'. + # + mode = 'output' + else: + mode = 'tb' + + code = line + insertion = None + + return mode, code, insertion + + def get_tokens_unprocessed(self, text): + self.reset() + for match in line_re.finditer(text): + line = match.group() + mode, code, insertion = self.get_mci(line) + + if mode != self.mode: + # Yield buffered tokens before transitioning to new mode. + for token in self.buffered_tokens(): + yield token + self.mode = mode + + if insertion: + self.insertions.append((len(self.buffer), [insertion])) + self.buffer += code + + for token in self.buffered_tokens(): + yield token + +class IPyLexer(Lexer): + r""" + Primary lexer for all IPython-like code. + + This is a simple helper lexer. If the first line of the text begins with + "In \[[0-9]+\]:", then the entire text is parsed with an IPython console + lexer. If not, then the entire text is parsed with an IPython lexer. + + The goal is to reduce the number of lexers that are registered + with Pygments. + + """ + name = 'IPy session' + aliases = ['ipy'] + + def __init__(self, **options): + """ + Create a new IPyLexer instance which dispatch to either an + IPythonCOnsoleLexer (if In prompts are present) or and IPythonLexer (if + In prompts are not present). + """ + # init docstring is necessary for docs not to fail to build do to parent + # docs referenceing a section in pygments docs. + self.python3 = get_bool_opt(options, 'python3', False) + if self.python3: + self.aliases = ['ipy3'] + else: + self.aliases = ['ipy2', 'ipy'] + + Lexer.__init__(self, **options) + + self.IPythonLexer = IPythonLexer(**options) + self.IPythonConsoleLexer = IPythonConsoleLexer(**options) + + def get_tokens_unprocessed(self, text): + # Search for the input prompt anywhere...this allows code blocks to + # begin with comments as well. + if re.match(r'.*(In \[[0-9]+\]:)', text.strip(), re.DOTALL): + lex = self.IPythonConsoleLexer + else: + lex = self.IPythonLexer + for token in lex.get_tokens_unprocessed(text): + yield token + diff --git a/shared/package-files/2e/2ec42712829628685d7aa1a131cebc02ac33e0cad39c4b36d0a0186c58941f3a/blob b/shared/package-files/2e/2ec42712829628685d7aa1a131cebc02ac33e0cad39c4b36d0a0186c58941f3a/blob new file mode 100644 index 0000000000000000000000000000000000000000..da0abc1e7fa18363e6342a3b67410f1429e6fa10 --- /dev/null +++ b/shared/package-files/2e/2ec42712829628685d7aa1a131cebc02ac33e0cad39c4b36d0a0186c58941f3a/blob @@ -0,0 +1,28 @@ +############################################################################### +# Modification of concurrent.futures.Future +# +# author: Thomas Moreau and Olivier Grisel +# +# adapted from concurrent/futures/_base.py (17/02/2017) +# * Do not use yield from +# * Use old super syntax +# +# Copyright 2009 Brian Quinlan. All Rights Reserved. +# Licensed to PSF under a Contributor Agreement. + +from concurrent.futures import Future as _BaseFuture +from concurrent.futures._base import LOGGER + + +# To make loky._base.Future instances awaitable by concurrent.futures.wait, +# derive our custom Future class from _BaseFuture. _invoke_callback is the only +# modification made to this class in loky. +# TODO investigate why using `concurrent.futures.Future` directly does not +# always work in our test suite. +class Future(_BaseFuture): + def _invoke_callbacks(self): + for callback in self._done_callbacks: + try: + callback(self) + except BaseException: + LOGGER.exception(f"exception calling callback for {self!r}") diff --git a/shared/package-files/2e/2ec7d9373df55b89d3f35d5c1ebb6f82a85598f4e0f6b062a189c1781010379b/blob b/shared/package-files/2e/2ec7d9373df55b89d3f35d5c1ebb6f82a85598f4e0f6b062a189c1781010379b/blob new file mode 100644 index 0000000000000000000000000000000000000000..65f7b7e14957fc787063b952d4de2031790ce188 --- /dev/null +++ b/shared/package-files/2e/2ec7d9373df55b89d3f35d5c1ebb6f82a85598f4e0f6b062a189c1781010379b/blob @@ -0,0 +1,264 @@ +""" +Tests for numba.core.codegen. +""" + + +import warnings +import base64 +import ctypes +import pickle +import re +import subprocess +import sys +import weakref + +import llvmlite.binding as ll + +import unittest +from numba import njit +from numba.core.codegen import JITCPUCodegen +from numba.core.compiler_lock import global_compiler_lock +from numba.tests.support import TestCase + + +asm_sum = r""" + define i32 @sum(i32 %.1, i32 %.2) { + %.3 = add i32 %.1, %.2 + ret i32 %.3 + } + """ + +# Note we're using a rather mangled function name to check that it +# is compatible with object serialization. + +asm_sum_inner = """ + define i32 @"__main__.ising_element_update$1.array(int8,_2d,_C).int64.int64"(i32 %.1, i32 %.2) { + %.3 = add i32 %.1, %.2 + ret i32 %.3 + } +""" # noqa: E501 + +asm_sum_outer = """ + declare i32 @"__main__.ising_element_update$1.array(int8,_2d,_C).int64.int64"(i32 %.1, i32 %.2) + + define i32 @sum(i32 %.1, i32 %.2) { + %.3 = call i32 @"__main__.ising_element_update$1.array(int8,_2d,_C).int64.int64"(i32 %.1, i32 %.2) + ret i32 %.3 + } +""" # noqa: E501 + + +ctypes_sum_ty = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_int, ctypes.c_int) + + +class JITCPUCodegenTestCase(TestCase): + """ + Test the JIT code generation. + """ + + def setUp(self): + global_compiler_lock.acquire() + self.codegen = JITCPUCodegen('test_codegen') + + def tearDown(self): + del self.codegen + global_compiler_lock.release() + + def compile_module(self, asm, linking_asm=None): + library = self.codegen.create_library('compiled_module') + ll_module = ll.parse_assembly(asm) + ll_module.verify() + library.add_llvm_module(ll_module) + if linking_asm: + linking_library = self.codegen.create_library('linking_module') + ll_module = ll.parse_assembly(linking_asm) + ll_module.verify() + linking_library.add_llvm_module(ll_module) + library.add_linking_library(linking_library) + return library + + @classmethod + def _check_unserialize_sum(cls, state): + codegen = JITCPUCodegen('other_codegen') + library = codegen.unserialize_library(state) + ptr = library.get_pointer_to_function("sum") + assert ptr, ptr + cfunc = ctypes_sum_ty(ptr) + res = cfunc(2, 3) + assert res == 5, res + + def test_get_pointer_to_function(self): + library = self.compile_module(asm_sum) + ptr = library.get_pointer_to_function("sum") + self.assertIsInstance(ptr, int) + cfunc = ctypes_sum_ty(ptr) + self.assertEqual(cfunc(2, 3), 5) + # Note: With llvm3.9.1, deleting `library` will cause memory error in + # the following code during running of optimization passes in + # LLVM. The reason of the error is unclear. The error is known to + # replicate on osx64 and linux64. + + # Same, but with dependency on another library + library2 = self.compile_module(asm_sum_outer, asm_sum_inner) + ptr = library2.get_pointer_to_function("sum") + self.assertIsInstance(ptr, int) + cfunc = ctypes_sum_ty(ptr) + self.assertEqual(cfunc(2, 3), 5) + + def test_magic_tuple(self): + tup = self.codegen.magic_tuple() + pickle.dumps(tup) + cg2 = JITCPUCodegen('xxx') + self.assertEqual(cg2.magic_tuple(), tup) + + # Serialization tests. + + def _check_serialize_unserialize(self, state): + self._check_unserialize_sum(state) + + def _check_unserialize_other_process(self, state): + arg = base64.b64encode(pickle.dumps(state, -1)) + code = """if 1: + import base64 + import pickle + import sys + from numba.tests.test_codegen import %(test_class)s + + state = pickle.loads(base64.b64decode(sys.argv[1])) + %(test_class)s._check_unserialize_sum(state) + """ % dict(test_class=self.__class__.__name__) + subprocess.check_call([sys.executable, '-c', code, arg.decode()]) + + def test_serialize_unserialize_bitcode(self): + library = self.compile_module(asm_sum_outer, asm_sum_inner) + state = library.serialize_using_bitcode() + self._check_serialize_unserialize(state) + + def test_unserialize_other_process_bitcode(self): + library = self.compile_module(asm_sum_outer, asm_sum_inner) + state = library.serialize_using_bitcode() + self._check_unserialize_other_process(state) + + def test_serialize_unserialize_object_code(self): + library = self.compile_module(asm_sum_outer, asm_sum_inner) + library.enable_object_caching() + state = library.serialize_using_object_code() + self._check_serialize_unserialize(state) + + def test_unserialize_other_process_object_code(self): + library = self.compile_module(asm_sum_outer, asm_sum_inner) + library.enable_object_caching() + state = library.serialize_using_object_code() + self._check_unserialize_other_process(state) + + def test_cache_disabled_inspection(self): + """ + """ + library = self.compile_module(asm_sum_outer, asm_sum_inner) + library.enable_object_caching() + state = library.serialize_using_object_code() + + # exercise the valid behavior + with warnings.catch_warnings(record=True) as w: + old_llvm = library.get_llvm_str() + old_asm = library.get_asm_str() + library.get_function_cfg('sum') + self.assertEqual(len(w), 0) + + # unserialize + codegen = JITCPUCodegen('other_codegen') + library = codegen.unserialize_library(state) + + # the inspection methods would warn and give incorrect result + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always") + self.assertNotEqual(old_llvm, library.get_llvm_str()) + self.assertEqual(len(w), 1) + self.assertIn("Inspection disabled", str(w[0].message)) + + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always") + self.assertNotEqual(library.get_asm_str(), old_asm) + self.assertEqual(len(w), 1) + self.assertIn("Inspection disabled", str(w[0].message)) + + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always") + with self.assertRaises(NameError) as raises: + library.get_function_cfg('sum') + self.assertEqual(len(w), 1) + self.assertIn("Inspection disabled", str(w[0].message)) + self.assertIn("sum", str(raises.exception)) + + # Lifetime tests + + @unittest.expectedFailure # MCJIT removeModule leaks and it is disabled + def test_library_lifetime(self): + library = self.compile_module(asm_sum_outer, asm_sum_inner) + # Exercise code generation + library.enable_object_caching() + library.serialize_using_bitcode() + library.serialize_using_object_code() + u = weakref.ref(library) + v = weakref.ref(library._final_module) + del library + # Both the library and its backing LLVM module are collected + self.assertIs(u(), None) + self.assertIs(v(), None) + + +class TestWrappers(TestCase): + + def test_noinline_on_main_call(self): + # Checks that the cpython and cfunc wrapper produces a call with the + # "noinline" attr present for the decorated function. + + # Creating a refcounted object induces a side-effect that prevents IPO + # from eliding the call to the function with LLVM 15. See Issue #9658: + # https://github.com/numba/numba/issues/9658 + @njit + def foo(): + return list([1]) + + foo() + sig = foo.signatures[0] + + ol = foo.overloads[sig] + name = ol.fndesc.mangled_name.replace("$", r"\$") + p1 = r".*call.*{}".format(name) + p2 = r".*(#[0-9]+).*" + call_site = re.compile(p1 + p2) + + lines = foo.inspect_llvm(sig).splitlines() + meta_data_idx = [] + for l in lines: + matched = call_site.match(l) + if matched: + meta_data_idx.append(matched.groups()[0]) + + # should be 2 calls, one from cpython wrapper one from cfunc wrapper + self.assertEqual(len(meta_data_idx), 2) + # both calls should refer to the same metadata item + self.assertEqual(meta_data_idx[0], meta_data_idx[1]) + + p1 = r"^attributes\s+{}".format(meta_data_idx[0]) + p2 = r"\s+=\s+{(.*)}.*$" + attr_site = re.compile(p1 + p2) + + for l in reversed(lines): + matched = attr_site.match(l) + if matched: + meta_data = matched.groups()[0] + lmeta = meta_data.strip().split(' ') + for x in lmeta: + if 'noinline' in x: + break + else: + continue + break + else: + return self.fail("Metadata did not match 'noinline'") + + +if __name__ == '__main__': + unittest.main() diff --git a/shared/package-files/2e/2ecb5434dae88d16cfebb2396f2566564d98a62b0ebc1a9a8ca3a181f26d132c/property_features.py b/shared/package-files/2e/2ecb5434dae88d16cfebb2396f2566564d98a62b0ebc1a9a8ca3a181f26d132c/property_features.py new file mode 100644 index 0000000000000000000000000000000000000000..40788aaf7b90da88cf27da2c697b7c909b5a0004 --- /dev/null +++ b/shared/package-files/2e/2ecb5434dae88d16cfebb2396f2566564d98a62b0ebc1a9a8ca3a181f26d132c/property_features.py @@ -0,0 +1,23 @@ +"""Shared fixed public-spectrum and candidate-property definitions.""" +import numpy as np +from spectrum_features import spectrum_features +from prior_features import descriptors,transformed,FEATURE_NAMES +TARGET_NAMES=['MolLogP','TPSA','HDonors','HAcceptors','RotatableBonds','FractionCSP3','AromaticRings','AliphaticRings','Heterocycles'] +TARGET_INDICES=[FEATURE_NAMES.index(n) for n in TARGET_NAMES] +def broad_public_features(q): + x,names=spectrum_features(q);ce=q.get('collision_energy');known=ce is not None + # Contract allows finite numeric energies; signed log remains defined for unusual inputs. + value=float(ce) if known else 0. + return np.concatenate([x,np.asarray([float(known),np.sign(value)*np.log1p(abs(value))],np.float32)]),names+['energy_known','signed_log_energy'] +def candidate_targets(smiles): + values,valid=descriptors(smiles);return transformed(values[TARGET_INDICES]),valid + +from neutral_loss_features import neutral_losses,NAMES +def neutral_public_features(q): + x,names=broad_public_features(q) + return np.concatenate([x,neutral_losses(q)]),names+NAMES + +from fragment_pair_features import fragment_pairs,NAMES as PAIR_NAMES +def public_features(q): + x,names=neutral_public_features(q) + return np.concatenate([x,fragment_pairs(q)]),names+PAIR_NAMES diff --git a/shared/package-files/2e/2ecc26b4441f97c8a50f772ad29f9b8e47afdf44fa9a0da2162d1208e56e830d/blob b/shared/package-files/2e/2ecc26b4441f97c8a50f772ad29f9b8e47afdf44fa9a0da2162d1208e56e830d/blob new file mode 100644 index 0000000000000000000000000000000000000000..1e4ae606b28e3053eda5e549dbf291d68c2174ca --- /dev/null +++ b/shared/package-files/2e/2ecc26b4441f97c8a50f772ad29f9b8e47afdf44fa9a0da2162d1208e56e830d/blob @@ -0,0 +1,28 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API gather_backward { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, const at::Tensor &, bool); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::gather_backward") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "gather_backward(Tensor grad, Tensor self, int dim, Tensor index, bool sparse_grad) -> Tensor") + static at::Tensor call(const at::Tensor & grad, const at::Tensor & self, int64_t dim, const at::Tensor & index, bool sparse_grad); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & grad, const at::Tensor & self, int64_t dim, const at::Tensor & index, bool sparse_grad); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/2e/2ecea44b99a5e2e19f8c2f0afc0dfca30e880a4ee73535900ab9e10f4dc32449/blob b/shared/package-files/2e/2ecea44b99a5e2e19f8c2f0afc0dfca30e880a4ee73535900ab9e10f4dc32449/blob new file mode 100644 index 0000000000000000000000000000000000000000..f36e9ebf0618798a82c86059df9eb3480babf4fe --- /dev/null +++ b/shared/package-files/2e/2ecea44b99a5e2e19f8c2f0afc0dfca30e880a4ee73535900ab9e10f4dc32449/blob @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor sparse_resize_and_clear(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim); +TORCH_API const at::Tensor & sparse_resize_and_clear_out(const at::Tensor & out, const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim); +TORCH_API const at::Tensor & sparse_resize_and_clear_outf(const at::Tensor & self, at::IntArrayRef size, int64_t sparse_dim, int64_t dense_dim, const at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/shared/package-files/2e/2ed0833b84de3212d60224c6889113dd83fc44ee93dce42a99da49f091f7f758/blob b/shared/package-files/2e/2ed0833b84de3212d60224c6889113dd83fc44ee93dce42a99da49f091f7f758/blob new file mode 100644 index 0000000000000000000000000000000000000000..2af76f69a4300ac744a5e6f1f7dab185e19767ca --- /dev/null +++ b/shared/package-files/2e/2ed0833b84de3212d60224c6889113dd83fc44ee93dce42a99da49f091f7f758/blob @@ -0,0 +1,40 @@ +""" common utilities """ +from __future__ import annotations + +from typing import ( + Any, + Literal, +) + + +def _mklbl(prefix: str, n: int): + return [f"{prefix}{i}" for i in range(n)] + + +def check_indexing_smoketest_or_raises( + obj, + method: Literal["iloc", "loc"], + key: Any, + axes: Literal[0, 1] | None = None, + fails=None, +) -> None: + if axes is None: + axes_list = [0, 1] + else: + assert axes in [0, 1] + axes_list = [axes] + + for ax in axes_list: + if ax < obj.ndim: + # create a tuple accessor + new_axes = [slice(None)] * obj.ndim + new_axes[ax] = key + axified = tuple(new_axes) + try: + getattr(obj, method).__getitem__(axified) + except (IndexError, TypeError, KeyError) as detail: + # if we are in fails, the ok, otherwise raise it + if fails is not None: + if isinstance(detail, fails): + return + raise diff --git a/shared/package-files/2e/2ed0f84625acfeb439f191192e9fbfd4171ed41d79b78192d56a62c475bcf758/blob b/shared/package-files/2e/2ed0f84625acfeb439f191192e9fbfd4171ed41d79b78192d56a62c475bcf758/blob new file mode 100644 index 0000000000000000000000000000000000000000..b149f21e69570c2538860009dd742c18cd3b7754 --- /dev/null +++ b/shared/package-files/2e/2ed0f84625acfeb439f191192e9fbfd4171ed41d79b78192d56a62c475bcf758/blob @@ -0,0 +1,61 @@ +from jedi.inference.base_value import ValueSet, NO_VALUES +from jedi.common import monkeypatch + + +class AbstractLazyValue: + def __init__(self, data, min=1, max=1): + self.data = data + self.min = min + self.max = max + + def __repr__(self): + return '<%s: %s>' % (self.__class__.__name__, self.data) + + def infer(self): + raise NotImplementedError + + +class LazyKnownValue(AbstractLazyValue): + """data is a Value.""" + def infer(self): + return ValueSet([self.data]) + + +class LazyKnownValues(AbstractLazyValue): + """data is a ValueSet.""" + def infer(self): + return self.data + + +class LazyUnknownValue(AbstractLazyValue): + def __init__(self, min=1, max=1): + super().__init__(None, min, max) + + def infer(self): + return NO_VALUES + + +class LazyTreeValue(AbstractLazyValue): + def __init__(self, context, node, min=1, max=1): + super().__init__(node, min, max) + self.context = context + # We need to save the predefined names. It's an unfortunate side effect + # that needs to be tracked otherwise results will be wrong. + self._predefined_names = dict(context.predefined_names) + + def infer(self): + with monkeypatch(self.context, 'predefined_names', self._predefined_names): + return self.context.infer_node(self.data) + + +def get_merged_lazy_value(lazy_values): + if len(lazy_values) > 1: + return MergedLazyValues(lazy_values) + else: + return lazy_values[0] + + +class MergedLazyValues(AbstractLazyValue): + """data is a list of lazy values.""" + def infer(self): + return ValueSet.from_sets(l.infer() for l in self.data) diff --git a/shared/package-files/2e/2ed374ea5c33373f68633f4045e4128b3a72f5bedcd7c4caa52a8039c64c89b0/blob b/shared/package-files/2e/2ed374ea5c33373f68633f4045e4128b3a72f5bedcd7c4caa52a8039c64c89b0/blob new file mode 100644 index 0000000000000000000000000000000000000000..1dbf39f8a4565bc4fa43caace5661a3631f34614 --- /dev/null +++ b/shared/package-files/2e/2ed374ea5c33373f68633f4045e4128b3a72f5bedcd7c4caa52a8039c64c89b0/blob @@ -0,0 +1,23 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace native { +struct TORCH_API structured_acos_out : public at::meta::structured_acos { +void impl(const at::Tensor & self, const at::Tensor & out); +}; +} // namespace native +} // namespace at diff --git a/shared/package-files/2e/2ed5ed8d31bfe29f23cd375465f0d0154512f2355c509d543080b375b028dd55/blob b/shared/package-files/2e/2ed5ed8d31bfe29f23cd375465f0d0154512f2355c509d543080b375b028dd55/blob new file mode 100644 index 0000000000000000000000000000000000000000..ef30d961b85fb5238666cd02720d66d0c4fa5938 --- /dev/null +++ b/shared/package-files/2e/2ed5ed8d31bfe29f23cd375465f0d0154512f2355c509d543080b375b028dd55/blob @@ -0,0 +1,273 @@ +""" +Tests corresponding to sandbox.distributions.mv_normal +""" +from statsmodels.compat.scipy import SP_LT_116 + +import numpy as np +from numpy.testing import assert_allclose, assert_array_almost_equal +import pytest +from scipy import stats + +from statsmodels.sandbox.distributions.mv_normal import ( + MVT, + BivariateNormal, + MVNormal, + MVNormal0, + bivariate_normal, + expect_mc, +) + +MEAN3 = np.array([-1, 0.0, 2.0]) +COV3 = np.array([[1.0, 0.5, 0.75], [0.5, 1.5, 0.6], [0.75, 0.6, 2.0]]) + + +def test_bivariate_normal_function_matches_scipy(): + x = np.array([[0.0, 0.0], [1.0, 1.0], [-1.0, 2.0]]) + mu = [0.0, 0.0] + cov = np.array([[1.0, 0.3], [0.3, 1.0]]) + result = bivariate_normal(x, mu, cov) + expected = stats.multivariate_normal.pdf(x, mean=mu, cov=cov) + assert_allclose(result, expected, rtol=1e-10) + + +def test_bivariate_normal_class_construction(): + BivariateNormal([0.0, 0.0], np.eye(2)) + + +class TestMVNormal: + def setup_method(self): + self.mvn = MVNormal(MEAN3, COV3) + + def test_logpdf_matches_scipy(self): + pt = np.array([0.0, 1.0, 1.5]) + result = self.mvn.logpdf(pt) + expected = stats.multivariate_normal.logpdf(pt, mean=MEAN3, cov=COV3) + assert_allclose(result, expected, rtol=1e-10) + + def test_logpdf_2d_input_matches_scipy_rowwise(self): + pts = np.array([[0.0, 1.0, 1.5], [-1.0, 0.0, 2.0], [1.0, 1.0, 1.0]]) + result = self.mvn.logpdf(pts) + expected = stats.multivariate_normal.logpdf(pts, mean=MEAN3, cov=COV3) + assert_allclose(result, expected, rtol=1e-10) + + def test_pdf_is_exp_logpdf(self): + pt = np.array([0.0, 1.0, 1.5]) + assert_allclose(self.mvn.pdf(pt), np.exp(self.mvn.logpdf(pt))) + + def test_cov_property_equals_sigma(self): + assert_array_almost_equal(self.mvn.cov, COV3) + + def test_std_and_corr_consistent_with_cov(self): + std = self.mvn.std + corr = self.mvn.corr + assert_array_almost_equal(std, np.sqrt(np.diag(COV3))) + reconstructed = corr * np.outer(std, std) + assert_array_almost_equal(reconstructed, COV3) + + def test_rvs_moments_match_by_monte_carlo(self): + rvs = self.mvn.rvs(size=200000) + assert_allclose(rvs.mean(0), MEAN3, atol=0.02) + assert_allclose(np.cov(rvs, rowvar=False), COV3, atol=0.05) + + @pytest.mark.skipif( + not SP_LT_116, + reason=( + "MVNormal.cdf() delegates to sandbox.distributions.extras." + "mvnormcdf -> mvstdnormcdf -> mvndst, a compiled scipy.stats " + "Fortran routine that was removed in SciPy >= 1.16.0 (see " + "sandbox.distributions.tests.test_multivariate for the same " + "issue against mvstdtprob/mvstdnormcdf directly)." + ), + ) + def test_cdf_matches_scipy(self): + pt = np.array([0.0, 1.0, 1.5]) + result = self.mvn.cdf(pt) + expected = stats.multivariate_normal.cdf(pt, mean=MEAN3, cov=COV3) + assert_allclose(result, expected, atol=1e-4) + + def test_whiten_standardize_relationship(self): + x = np.array([0.5, 1.0, 2.5]) + assert_array_almost_equal( + self.mvn.standardize(x), self.mvn.whiten(x - MEAN3) + ) + + def test_normalized_has_correlation_as_sigma_and_zero_mean(self): + normalized = self.mvn.normalized() + assert_array_almost_equal(normalized.sigma, self.mvn.corr) + assert_array_almost_equal(normalized.mean, np.zeros(3)) + + def test_normalized_not_demeaned(self): + normalized = self.mvn.normalized(demeaned=False) + assert_array_almost_equal(normalized.mean, MEAN3 / self.mvn.std_sigma) + + def test_normalized2_sigma_matches_normalized(self): + assert_array_almost_equal( + self.mvn.normalized().sigma, self.mvn.normalized2().sigma + ) + + @pytest.mark.xfail( + reason=( + "BUG: normalized2(demeaned=True) computes shift=-self.mean and " + "passes it to affine_transformed(shift, scale), which computes " + "mean_new = scale @ mean + shift. That only cancels to zero " + "when scale is the identity; here scale=diag(1/std_sigma), so " + "the result is mean/std_sigma - mean, not zero. normalized() " + "(a separate, non-affine implementation) gets this right by " + "directly setting mean_new = zeros. The same shift-vs-scale " + "bug affects .standardized(), see " + "test_standardized_mean_is_zero below." + ), + raises=AssertionError, + strict=True, + ) + def test_normalized2_mean_matches_normalized(self): + assert_array_almost_equal( + self.mvn.normalized().mean, self.mvn.normalized2().mean + ) + + def test_marginal(self): + marg = self.mvn.marginal(np.array([0, 2])) + assert_array_almost_equal(marg.mean, MEAN3[[0, 2]]) + assert_array_almost_equal(marg.sigma, COV3[np.ix_([0, 2], [0, 2])]) + + def test_conditional_matches_textbook_formula(self): + keep = np.array([0]) + given = np.array([1, 2]) + values = np.array([1.0, 1.5]) + cond = self.mvn.conditional(keep, values) + + sigmakk = COV3[np.ix_(keep, keep)] + sigmagg = COV3[np.ix_(given, given)] + sigmakg = COV3[np.ix_(keep, given)] + expected_mean = MEAN3[keep] + sigmakg @ np.linalg.solve( + sigmagg, values - MEAN3[given] + ) + expected_sigma = sigmakk - sigmakg @ np.linalg.solve(sigmagg, sigmakg.T) + assert_array_almost_equal(cond.mean, expected_mean) + assert_array_almost_equal(cond.sigma, expected_sigma) + + def test_affine_transformed(self): + shift = np.array([1.0, 1.0, 1.0]) + scale = np.eye(3) * 2 + transformed = self.mvn.affine_transformed(shift, scale) + assert_array_almost_equal(transformed.mean, shift + scale @ MEAN3) + assert_array_almost_equal(transformed.sigma, scale @ COV3 @ scale.T) + + def test_standardized_has_identity_sigma(self): + standardized = self.mvn.standardized() + assert_array_almost_equal(standardized.sigma, np.eye(3), decimal=8) + + @pytest.mark.xfail( + reason=( + "BUG: standardized() calls " + "affine_transformed(-self.mean, self.cholsigmainv), but " + "affine_transformed computes mean_new = B @ mean + shift. " + "With B=cholsigmainv and shift=-mean (unscaled), the result is " + "cholsigmainv @ mean - mean, not zero. The instance *method* " + ".standardize(x) is implemented correctly (it does whiten(x - " + "mean), see test_whiten_standardize_relationship and " + "test_manual_standardize_of_samples_has_zero_mean); only the " + "*factory* .standardized(), which builds a new zero-mean " + "MVNormal via the generic affine-transform path, has the bug. " + "The correct shift would be -B @ self.mean." + ), + raises=AssertionError, + strict=True, + ) + def test_standardized_mean_is_zero(self): + standardized = self.mvn.standardized() + assert_array_almost_equal(standardized.mean, np.zeros(3)) + + def test_manual_standardize_of_samples_has_zero_mean(self): + # the .standardize(x) instance method (as opposed to the buggy + # .standardized() factory above) correctly produces zero-mean + # output when applied to samples from the distribution + rng = np.random.default_rng(0) + rvs = rng.multivariate_normal(MEAN3, COV3, size=200000) + whitened = self.mvn.standardize(rvs) + assert_allclose(whitened.mean(0), np.zeros(3), atol=0.02) + assert_allclose(np.cov(whitened, rowvar=False), np.eye(3), atol=0.05) + + +class TestMVNormalConstruction: + def test_scalar_sigma_is_iid(self): + mvn = MVNormal([0.0, 0.0], 2.0) + assert_array_almost_equal(mvn.cov, 2.0 * np.eye(2)) + + def test_1d_sigma_is_diagonal(self): + mvn = MVNormal([0.0, 0.0, 0.0], np.array([1.0, 2.0, 3.0])) + assert_array_almost_equal(mvn.cov, np.diag([1.0, 2.0, 3.0])) + + def test_invalid_sigma_shape_raises(self): + with pytest.raises(ValueError, match="sigma has invalid shape"): + MVNormal([0.0, 0.0], np.ones((3, 2))) + + +class TestMVT: + def setup_method(self): + self.df = 5 + self.mvt = MVT(MEAN3, COV3, self.df) + + def test_logpdf_matches_scipy_multivariate_t(self): + pt = np.array([0.0, 1.0, 1.5]) + result = self.mvt.logpdf(pt) + expected = stats.multivariate_t.logpdf( + pt, loc=MEAN3, shape=COV3, df=self.df + ) + assert_allclose(result, expected, rtol=1e-10) + + def test_cov_formula_for_df_greater_than_2(self): + expected = self.df / (self.df - 2.0) * COV3 + assert_array_almost_equal(self.mvt.cov, expected) + + def test_cov_is_nan_for_df_leq_2(self): + mvt2 = MVT(MEAN3, COV3, df=2) + assert np.all(np.isnan(mvt2.cov)) + mvt1 = MVT(MEAN3, COV3, df=1) + assert np.all(np.isnan(mvt1.cov)) + + def test_rvs_covariance_matches_by_monte_carlo(self): + rvs = self.mvt.rvs(size=200000) + assert_allclose(np.cov(rvs, rowvar=False), self.mvt.cov, atol=0.1) + + def test_affine_transformed(self): + shift = np.array([1.0, 1.0, 1.0]) + scale = np.eye(3) * 2 + transformed = self.mvt.affine_transformed(shift, scale) + assert_array_almost_equal(transformed.mean, shift + scale @ MEAN3) + assert_array_almost_equal(transformed.sigma, scale @ COV3 @ scale.T) + assert transformed.df == self.df + + def test_marginal_preserves_df(self): + marg = self.mvt.marginal(np.array([0, 2])) + assert marg.df == self.df + assert_array_almost_equal(marg.mean, MEAN3[[0, 2]]) + + +class TestMVNormal0: + # legacy reference implementation kept alongside MVNormal/MVElliptical + def test_logpdf_matches_mvnormal(self): + legacy = MVNormal0(MEAN3, COV3) + current = MVNormal(MEAN3, COV3) + pt = np.array([0.0, 1.0, 1.5]) + assert_allclose(legacy.logpdf(pt), current.logpdf(pt), rtol=1e-10) + + @pytest.mark.singleton_randomstate + def test_rvs_shape(self): + # MVNormal0.rvs() calls np.random.multivariate_normal directly + # (the legacy singleton RandomState API, unlike MVNormal.rvs() + # which threads an explicit rng/Generator), so this legitimately + # mutates global numpy random state. + legacy = MVNormal0(MEAN3, COV3) + rvs = legacy.rvs(size=5) + assert rvs.shape == (5, 3) + + +def test_expect_mc_estimates_normal_orthant_probability(): + # expected value of an indicator function via Monte Carlo should be + # close to the true probability computed from the cdf + mvn = MVNormal([0.0, 0.0], np.eye(2)) + a = np.array([0.0, 0.0]) + result = expect_mc(mvn, lambda x: (x < a).all(-1), size=200000) + expected = stats.multivariate_normal.cdf(a, mean=[0.0, 0.0], cov=np.eye(2)) + assert_allclose(result, expected, atol=0.01) diff --git a/shared/package-files/2e/2ed7720a8f3906b5d0b3aae51fad589bef0aa961c7e8fc003a30f44318487733/blob b/shared/package-files/2e/2ed7720a8f3906b5d0b3aae51fad589bef0aa961c7e8fc003a30f44318487733/blob new file mode 100644 index 0000000000000000000000000000000000000000..576f16bb2b21a7e0871a7222241ad65e533bb93a Binary files /dev/null and b/shared/package-files/2e/2ed7720a8f3906b5d0b3aae51fad589bef0aa961c7e8fc003a30f44318487733/blob differ diff --git a/shared/package-files/2e/2edaf7151e34a33e0bace52ba5949e4770a644cb53d4792fb8e4ed6404538ae5/blob b/shared/package-files/2e/2edaf7151e34a33e0bace52ba5949e4770a644cb53d4792fb8e4ed6404538ae5/blob new file mode 100644 index 0000000000000000000000000000000000000000..9b2d2dedba6ab935cfa2a896b14ab9dd914f4002 --- /dev/null +++ b/shared/package-files/2e/2edaf7151e34a33e0bace52ba5949e4770a644cb53d4792fb8e4ed6404538ae5/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::special_gammaln(Tensor self) -> Tensor +inline at::Tensor special_gammaln(const at::Tensor & self) { + return at::_ops::special_gammaln::call(self); +} + +// aten::special_gammaln.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & special_gammaln_out(at::Tensor & out, const at::Tensor & self) { + return at::_ops::special_gammaln_out::call(self, out); +} +// aten::special_gammaln.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & special_gammaln_outf(const at::Tensor & self, at::Tensor & out) { + return at::_ops::special_gammaln_out::call(self, out); +} + +} diff --git a/shared/package-files/2e/2edb767a89d7bc06e14532908fbe151f6f7d3412bd982c785d809dc945cb4385/blob b/shared/package-files/2e/2edb767a89d7bc06e14532908fbe151f6f7d3412bd982c785d809dc945cb4385/blob new file mode 100644 index 0000000000000000000000000000000000000000..a2fffff86812d1a7ca547a71a19078b6d5f59716 --- /dev/null +++ b/shared/package-files/2e/2edb767a89d7bc06e14532908fbe151f6f7d3412bd982c785d809dc945cb4385/blob @@ -0,0 +1,155 @@ +from . cimport sf_error +cdef void _set_action(sf_error.sf_error_t, sf_error.sf_action_t) noexcept nogil +cdef void *_export_beta_pdf_float +cdef void *_export_beta_pdf_double +cdef void *_export_beta_ppf_float +cdef void *_export_beta_ppf_double +cdef void *_export_binom_cdf_float +cdef void *_export_binom_cdf_double +cdef void *_export_binom_isf_float +cdef void *_export_binom_isf_double +cdef void *_export_binom_pmf_float +cdef void *_export_binom_pmf_double +cdef void *_export_binom_ppf_float +cdef void *_export_binom_ppf_double +cdef void *_export_binom_sf_float +cdef void *_export_binom_sf_double +cdef void *_export_cauchy_isf_float +cdef void *_export_cauchy_isf_double +cdef void *_export_cauchy_ppf_float +cdef void *_export_cauchy_ppf_double +cdef void *_export_hypergeom_cdf_float +cdef void *_export_hypergeom_cdf_double +cdef void *_export_hypergeom_mean_float +cdef void *_export_hypergeom_mean_double +cdef void *_export_hypergeom_pmf_float +cdef void *_export_hypergeom_pmf_double +cdef void *_export_hypergeom_sf_float +cdef void *_export_hypergeom_sf_double +cdef void *_export_hypergeom_skewness_float +cdef void *_export_hypergeom_skewness_double +cdef void *_export_hypergeom_variance_float +cdef void *_export_hypergeom_variance_double +cdef void *_export_invgauss_isf_float +cdef void *_export_invgauss_isf_double +cdef void *_export_invgauss_ppf_float +cdef void *_export_invgauss_ppf_double +cdef void *_export_landau_cdf_float +cdef void *_export_landau_cdf_double +cdef void *_export_landau_isf_float +cdef void *_export_landau_isf_double +cdef void *_export_landau_pdf_float +cdef void *_export_landau_pdf_double +cdef void *_export_landau_ppf_float +cdef void *_export_landau_ppf_double +cdef void *_export_landau_sf_float +cdef void *_export_landau_sf_double +cdef void *_export_nbinom_cdf_float +cdef void *_export_nbinom_cdf_double +cdef void *_export_nbinom_isf_float +cdef void *_export_nbinom_isf_double +cdef void *_export_nbinom_kurtosis_excess_float +cdef void *_export_nbinom_kurtosis_excess_double +cdef void *_export_nbinom_mean_float +cdef void *_export_nbinom_mean_double +cdef void *_export_nbinom_pmf_float +cdef void *_export_nbinom_pmf_double +cdef void *_export_nbinom_ppf_float +cdef void *_export_nbinom_ppf_double +cdef void *_export_nbinom_sf_float +cdef void *_export_nbinom_sf_double +cdef void *_export_nbinom_skewness_float +cdef void *_export_nbinom_skewness_double +cdef void *_export_nbinom_variance_float +cdef void *_export_nbinom_variance_double +cdef void *_export_ncf_isf_float +cdef void *_export_ncf_isf_double +cdef void *_export_ncf_kurtosis_excess_float +cdef void *_export_ncf_kurtosis_excess_double +cdef void *_export_ncf_mean_float +cdef void *_export_ncf_mean_double +cdef void *_export_ncf_pdf_float +cdef void *_export_ncf_pdf_double +cdef void *_export_ncf_sf_float +cdef void *_export_ncf_sf_double +cdef void *_export_ncf_skewness_float +cdef void *_export_ncf_skewness_double +cdef void *_export_ncf_variance_float +cdef void *_export_ncf_variance_double +cdef void *_export_nct_isf_float +cdef void *_export_nct_isf_double +cdef void *_export_nct_kurtosis_excess_float +cdef void *_export_nct_kurtosis_excess_double +cdef void *_export_nct_mean_float +cdef void *_export_nct_mean_double +cdef void *_export_nct_pdf_float +cdef void *_export_nct_pdf_double +cdef void *_export_nct_ppf_float +cdef void *_export_nct_ppf_double +cdef void *_export_nct_sf_float +cdef void *_export_nct_sf_double +cdef void *_export_nct_skewness_float +cdef void *_export_nct_skewness_double +cdef void *_export_nct_variance_float +cdef void *_export_nct_variance_double +cdef void *_export_ncx2_cdf_float +cdef void *_export_ncx2_cdf_double +cdef void *_export_ncx2_isf_float +cdef void *_export_ncx2_isf_double +cdef void *_export_ncx2_pdf_float +cdef void *_export_ncx2_pdf_double +cdef void *_export_ncx2_ppf_float +cdef void *_export_ncx2_ppf_double +cdef void *_export_ncx2_sf_float +cdef void *_export_ncx2_sf_double +cdef void *_export_skewnorm_cdf_float +cdef void *_export_skewnorm_cdf_double +cdef void *_export_skewnorm_isf_float +cdef void *_export_skewnorm_isf_double +cdef void *_export_skewnorm_ppf_float +cdef void *_export_skewnorm_ppf_double +cdef void *_export__stirling2_inexact +cdef void *_export_ibeta_float +cdef void *_export_ibeta_double +cdef void *_export_ibetac_float +cdef void *_export_ibetac_double +cdef void *_export_ibetac_inv_float +cdef void *_export_ibetac_inv_double +cdef void *_export_ibeta_inv_float +cdef void *_export_ibeta_inv_double +cdef void *_export_faddeeva_dawsn +cdef void *_export_faddeeva_dawsn_complex +cdef void *_export_fellint_RC +cdef void *_export_cellint_RC +cdef void *_export_fellint_RD +cdef void *_export_cellint_RD +cdef void *_export_fellint_RF +cdef void *_export_cellint_RF +cdef void *_export_fellint_RG +cdef void *_export_cellint_RG +cdef void *_export_fellint_RJ +cdef void *_export_cellint_RJ +cdef void *_export_faddeeva_erf +cdef void *_export_faddeeva_erfc_complex +cdef void *_export_faddeeva_erfcx +cdef void *_export_faddeeva_erfcx_complex +cdef void *_export_faddeeva_erfi +cdef void *_export_faddeeva_erfi_complex +cdef void *_export_erfinv_float +cdef void *_export_erfinv_double +cdef void *_export_hyp1f1_double +cdef void *_export_faddeeva_log_ndtr +cdef void *_export_faddeeva_log_ndtr_complex +cdef void *_export_ncf_cdf_float +cdef void *_export_ncf_cdf_double +cdef void *_export_ncf_ppf_float +cdef void *_export_ncf_ppf_double +cdef void *_export_nct_cdf_float +cdef void *_export_nct_cdf_double +cdef void *_export_faddeeva_ndtr +cdef void *_export_powm1_float +cdef void *_export_powm1_double +cdef void *_export_faddeeva_voigt_profile +cdef void *_export_faddeeva_w +cdef void *_export_wrightomega +cdef void *_export_wrightomega_real \ No newline at end of file diff --git a/shared/package-files/2e/2edea89ce24ba152444e003c144de0693cc49f1990857c8b4417ba4f4f91dfee/blob b/shared/package-files/2e/2edea89ce24ba152444e003c144de0693cc49f1990857c8b4417ba4f4f91dfee/blob new file mode 100644 index 0000000000000000000000000000000000000000..423982501d83b6d63312fb8f44043622630cf85b Binary files /dev/null and b/shared/package-files/2e/2edea89ce24ba152444e003c144de0693cc49f1990857c8b4417ba4f4f91dfee/blob differ diff --git a/shared/package-files/2e/2ee1a46e823643a77ad24420c0c0ee772fb97846e2c5a68218fefc0b01e58ba7/blob b/shared/package-files/2e/2ee1a46e823643a77ad24420c0c0ee772fb97846e2c5a68218fefc0b01e58ba7/blob new file mode 100644 index 0000000000000000000000000000000000000000..77d008c650264889550ec70331a1b98064242d26 --- /dev/null +++ b/shared/package-files/2e/2ee1a46e823643a77ad24420c0c0ee772fb97846e2c5a68218fefc0b01e58ba7/blob @@ -0,0 +1,724 @@ +from datetime import datetime +import re + +import numpy as np +import pytest + +from pandas.core.dtypes.dtypes import ArrowDtype + +from pandas import ( + DataFrame, + Index, + MultiIndex, + Series, + _testing as tm, +) + + +def test_extract_expand_kwarg_wrong_type_raises(any_string_dtype): + # TODO: should this raise TypeError + values = Series(["fooBAD__barBAD", np.nan, "foo"], dtype=any_string_dtype) + with pytest.raises(ValueError, match="expand must be True or False"): + values.str.extract(".*(BAD[_]+).*(BAD)", expand=None) + + +def test_extract_expand_kwarg(any_string_dtype): + s = Series(["fooBAD__barBAD", np.nan, "foo"], dtype=any_string_dtype) + expected = DataFrame(["BAD__", np.nan, np.nan], dtype=any_string_dtype) + + result = s.str.extract(".*(BAD[_]+).*") + tm.assert_frame_equal(result, expected) + + result = s.str.extract(".*(BAD[_]+).*", expand=True) + tm.assert_frame_equal(result, expected) + + expected = DataFrame( + [["BAD__", "BAD"], [np.nan, np.nan], [np.nan, np.nan]], dtype=any_string_dtype + ) + result = s.str.extract(".*(BAD[_]+).*(BAD)", expand=False) + tm.assert_frame_equal(result, expected) + + +def test_extract_expand_False_mixed_object(): + ser = Series( + ["aBAD_BAD", np.nan, "BAD_b_BAD", True, datetime.today(), "foo", None, 1, 2.0] + ) + + # two groups + result = ser.str.extract(".*(BAD[_]+).*(BAD)", expand=False) + er = [np.nan, np.nan] # empty row + expected = DataFrame( + [["BAD_", "BAD"], er, ["BAD_", "BAD"], er, er, er, er, er, er], dtype=object + ) + tm.assert_frame_equal(result, expected) + + # single group + result = ser.str.extract(".*(BAD[_]+).*BAD", expand=False) + expected = Series( + ["BAD_", np.nan, "BAD_", np.nan, np.nan, np.nan, None, np.nan, np.nan], + dtype=object, + ) + tm.assert_series_equal(result, expected) + + +def test_extract_expand_index_raises(): + # GH9980 + # Index only works with one regex group since + # multi-group would expand to a frame + idx = Index(["A1", "A2", "A3", "A4", "B5"]) + msg = "only one regex group is supported with Index" + with pytest.raises(ValueError, match=msg): + idx.str.extract("([AB])([123])", expand=False) + + +def test_extract_expand_no_capture_groups_raises(index_or_series, any_string_dtype): + s_or_idx = index_or_series(["A1", "B2", "C3"], dtype=any_string_dtype) + msg = "pattern contains no capture groups" + + # no groups + with pytest.raises(ValueError, match=msg): + s_or_idx.str.extract("[ABC][123]", expand=False) + + # only non-capturing groups + with pytest.raises(ValueError, match=msg): + s_or_idx.str.extract("(?:[AB]).*", expand=False) + + +def test_extract_expand_single_capture_group(index_or_series, any_string_dtype): + # single group renames series/index properly + s_or_idx = index_or_series(["A1", "A2"], dtype=any_string_dtype) + result = s_or_idx.str.extract(r"(?PA)\d", expand=False) + + expected = index_or_series(["A", "A"], name="uno", dtype=any_string_dtype) + if index_or_series == Series: + tm.assert_series_equal(result, expected) + else: + tm.assert_index_equal(result, expected) + + +def test_extract_expand_capture_groups(any_string_dtype): + s = Series(["A1", "B2", "C3"], dtype=any_string_dtype) + # one group, no matches + result = s.str.extract("(_)", expand=False) + expected = Series([np.nan, np.nan, np.nan], dtype=any_string_dtype) + tm.assert_series_equal(result, expected) + + # two groups, no matches + result = s.str.extract("(_)(_)", expand=False) + expected = DataFrame( + [[np.nan, np.nan], [np.nan, np.nan], [np.nan, np.nan]], dtype=any_string_dtype + ) + tm.assert_frame_equal(result, expected) + + # one group, some matches + result = s.str.extract("([AB])[123]", expand=False) + expected = Series(["A", "B", np.nan], dtype=any_string_dtype) + tm.assert_series_equal(result, expected) + + # two groups, some matches + result = s.str.extract("([AB])([123])", expand=False) + expected = DataFrame( + [["A", "1"], ["B", "2"], [np.nan, np.nan]], dtype=any_string_dtype + ) + tm.assert_frame_equal(result, expected) + + # one named group + result = s.str.extract("(?P[AB])", expand=False) + expected = Series(["A", "B", np.nan], name="letter", dtype=any_string_dtype) + tm.assert_series_equal(result, expected) + + # two named groups + result = s.str.extract("(?P[AB])(?P[123])", expand=False) + expected = DataFrame( + [["A", "1"], ["B", "2"], [np.nan, np.nan]], + columns=["letter", "number"], + dtype=any_string_dtype, + ) + tm.assert_frame_equal(result, expected) + + # mix named and unnamed groups + result = s.str.extract("([AB])(?P[123])", expand=False) + expected = DataFrame( + [["A", "1"], ["B", "2"], [np.nan, np.nan]], + columns=[0, "number"], + dtype=any_string_dtype, + ) + tm.assert_frame_equal(result, expected) + + # one normal group, one non-capturing group + result = s.str.extract("([AB])(?:[123])", expand=False) + expected = Series(["A", "B", np.nan], dtype=any_string_dtype) + tm.assert_series_equal(result, expected) + + # two normal groups, one non-capturing group + s = Series(["A11", "B22", "C33"], dtype=any_string_dtype) + result = s.str.extract("([AB])([123])(?:[123])", expand=False) + expected = DataFrame( + [["A", "1"], ["B", "2"], [np.nan, np.nan]], dtype=any_string_dtype + ) + tm.assert_frame_equal(result, expected) + + # one optional group followed by one normal group + s = Series(["A1", "B2", "3"], dtype=any_string_dtype) + result = s.str.extract("(?P[AB])?(?P[123])", expand=False) + expected = DataFrame( + [["A", "1"], ["B", "2"], [np.nan, "3"]], + columns=["letter", "number"], + dtype=any_string_dtype, + ) + tm.assert_frame_equal(result, expected) + + # one normal group followed by one optional group + s = Series(["A1", "B2", "C"], dtype=any_string_dtype) + result = s.str.extract("(?P[ABC])(?P[123])?", expand=False) + expected = DataFrame( + [["A", "1"], ["B", "2"], ["C", np.nan]], + columns=["letter", "number"], + dtype=any_string_dtype, + ) + tm.assert_frame_equal(result, expected) + + +def test_extract_expand_capture_groups_index(index, any_string_dtype): + # https://github.com/pandas-dev/pandas/issues/6348 + # not passing index to the extractor + data = ["A1", "B2", "C"] + + if len(index) == 0: + pytest.skip("Test requires len(index) > 0") + while len(index) < len(data): + index = index.repeat(2) + + index = index[: len(data)] + ser = Series(data, index=index, dtype=any_string_dtype) + + result = ser.str.extract(r"(\d)", expand=False) + expected = Series(["1", "2", np.nan], index=index, dtype=any_string_dtype) + tm.assert_series_equal(result, expected) + + result = ser.str.extract(r"(?P\D)(?P\d)?", expand=False) + expected = DataFrame( + [["A", "1"], ["B", "2"], ["C", np.nan]], + columns=["letter", "number"], + index=index, + dtype=any_string_dtype, + ) + tm.assert_frame_equal(result, expected) + + +def test_extract_single_series_name_is_preserved(any_string_dtype): + s = Series(["a3", "b3", "c2"], name="bob", dtype=any_string_dtype) + result = s.str.extract(r"(?P[a-z])", expand=False) + expected = Series(["a", "b", "c"], name="sue", dtype=any_string_dtype) + tm.assert_series_equal(result, expected) + + +def test_extract_expand_True(any_string_dtype): + # Contains tests like those in test_match and some others. + s = Series(["fooBAD__barBAD", np.nan, "foo"], dtype=any_string_dtype) + + result = s.str.extract(".*(BAD[_]+).*(BAD)", expand=True) + expected = DataFrame( + [["BAD__", "BAD"], [np.nan, np.nan], [np.nan, np.nan]], dtype=any_string_dtype + ) + tm.assert_frame_equal(result, expected) + + +def test_extract_expand_True_mixed_object(): + er = [np.nan, np.nan] # empty row + mixed = Series( + [ + "aBAD_BAD", + np.nan, + "BAD_b_BAD", + True, + datetime.today(), + "foo", + None, + 1, + 2.0, + ] + ) + + result = mixed.str.extract(".*(BAD[_]+).*(BAD)", expand=True) + expected = DataFrame( + [["BAD_", "BAD"], er, ["BAD_", "BAD"], er, er, er, er, er, er], dtype=object + ) + tm.assert_frame_equal(result, expected) + + +def test_extract_expand_True_single_capture_group_raises( + index_or_series, any_string_dtype +): + # these should work for both Series and Index + # no groups + s_or_idx = index_or_series(["A1", "B2", "C3"], dtype=any_string_dtype) + msg = "pattern contains no capture groups" + with pytest.raises(ValueError, match=msg): + s_or_idx.str.extract("[ABC][123]", expand=True) + + # only non-capturing groups + with pytest.raises(ValueError, match=msg): + s_or_idx.str.extract("(?:[AB]).*", expand=True) + + +def test_extract_expand_True_single_capture_group(index_or_series, any_string_dtype): + # single group renames series/index properly + s_or_idx = index_or_series(["A1", "A2"], dtype=any_string_dtype) + result = s_or_idx.str.extract(r"(?PA)\d", expand=True) + expected = DataFrame({"uno": ["A", "A"]}, dtype=any_string_dtype) + tm.assert_frame_equal(result, expected) + + +@pytest.mark.parametrize("name", [None, "series_name"]) +def test_extract_series(name, any_string_dtype): + # extract should give the same result whether or not the series has a name. + s = Series(["A1", "B2", "C3"], name=name, dtype=any_string_dtype) + + # one group, no matches + result = s.str.extract("(_)", expand=True) + expected = DataFrame([np.nan, np.nan, np.nan], dtype=any_string_dtype) + tm.assert_frame_equal(result, expected) + + # two groups, no matches + result = s.str.extract("(_)(_)", expand=True) + expected = DataFrame( + [[np.nan, np.nan], [np.nan, np.nan], [np.nan, np.nan]], dtype=any_string_dtype + ) + tm.assert_frame_equal(result, expected) + + # one group, some matches + result = s.str.extract("([AB])[123]", expand=True) + expected = DataFrame(["A", "B", np.nan], dtype=any_string_dtype) + tm.assert_frame_equal(result, expected) + + # two groups, some matches + result = s.str.extract("([AB])([123])", expand=True) + expected = DataFrame( + [["A", "1"], ["B", "2"], [np.nan, np.nan]], dtype=any_string_dtype + ) + tm.assert_frame_equal(result, expected) + + # one named group + result = s.str.extract("(?P[AB])", expand=True) + expected = DataFrame({"letter": ["A", "B", np.nan]}, dtype=any_string_dtype) + tm.assert_frame_equal(result, expected) + + # two named groups + result = s.str.extract("(?P[AB])(?P[123])", expand=True) + expected = DataFrame( + [["A", "1"], ["B", "2"], [np.nan, np.nan]], + columns=["letter", "number"], + dtype=any_string_dtype, + ) + tm.assert_frame_equal(result, expected) + + # mix named and unnamed groups + result = s.str.extract("([AB])(?P[123])", expand=True) + expected = DataFrame( + [["A", "1"], ["B", "2"], [np.nan, np.nan]], + columns=[0, "number"], + dtype=any_string_dtype, + ) + tm.assert_frame_equal(result, expected) + + # one normal group, one non-capturing group + result = s.str.extract("([AB])(?:[123])", expand=True) + expected = DataFrame(["A", "B", np.nan], dtype=any_string_dtype) + tm.assert_frame_equal(result, expected) + + +def test_extract_optional_groups(any_string_dtype): + # two normal groups, one non-capturing group + s = Series(["A11", "B22", "C33"], dtype=any_string_dtype) + result = s.str.extract("([AB])([123])(?:[123])", expand=True) + expected = DataFrame( + [["A", "1"], ["B", "2"], [np.nan, np.nan]], dtype=any_string_dtype + ) + tm.assert_frame_equal(result, expected) + + # one optional group followed by one normal group + s = Series(["A1", "B2", "3"], dtype=any_string_dtype) + result = s.str.extract("(?P[AB])?(?P[123])", expand=True) + expected = DataFrame( + [["A", "1"], ["B", "2"], [np.nan, "3"]], + columns=["letter", "number"], + dtype=any_string_dtype, + ) + tm.assert_frame_equal(result, expected) + + # one normal group followed by one optional group + s = Series(["A1", "B2", "C"], dtype=any_string_dtype) + result = s.str.extract("(?P[ABC])(?P[123])?", expand=True) + expected = DataFrame( + [["A", "1"], ["B", "2"], ["C", np.nan]], + columns=["letter", "number"], + dtype=any_string_dtype, + ) + tm.assert_frame_equal(result, expected) + + +def test_extract_dataframe_capture_groups_index(index, any_string_dtype): + # GH6348 + # not passing index to the extractor + + data = ["A1", "B2", "C"] + + if len(index) < len(data): + pytest.skip(f"Index needs more than {len(data)} values") + + index = index[: len(data)] + s = Series(data, index=index, dtype=any_string_dtype) + + result = s.str.extract(r"(\d)", expand=True) + expected = DataFrame(["1", "2", np.nan], index=index, dtype=any_string_dtype) + tm.assert_frame_equal(result, expected) + + result = s.str.extract(r"(?P\D)(?P\d)?", expand=True) + expected = DataFrame( + [["A", "1"], ["B", "2"], ["C", np.nan]], + columns=["letter", "number"], + index=index, + dtype=any_string_dtype, + ) + tm.assert_frame_equal(result, expected) + + +def test_extract_single_group_returns_frame(any_string_dtype): + # GH11386 extract should always return DataFrame, even when + # there is only one group. Prior to v0.18.0, extract returned + # Series when there was only one group in the regex. + s = Series(["a3", "b3", "c2"], name="series_name", dtype=any_string_dtype) + result = s.str.extract(r"(?P[a-z])", expand=True) + expected = DataFrame({"letter": ["a", "b", "c"]}, dtype=any_string_dtype) + tm.assert_frame_equal(result, expected) + + +def test_extractall(any_string_dtype): + data = [ + "dave@google.com", + "tdhock5@gmail.com", + "maudelaperriere@gmail.com", + "rob@gmail.com some text steve@gmail.com", + "a@b.com some text c@d.com and e@f.com", + np.nan, + "", + ] + expected_tuples = [ + ("dave", "google", "com"), + ("tdhock5", "gmail", "com"), + ("maudelaperriere", "gmail", "com"), + ("rob", "gmail", "com"), + ("steve", "gmail", "com"), + ("a", "b", "com"), + ("c", "d", "com"), + ("e", "f", "com"), + ] + pat = r""" + (?P[a-z0-9]+) + @ + (?P[a-z]+) + \. + (?P[a-z]{2,4}) + """ + expected_columns = ["user", "domain", "tld"] + s = Series(data, dtype=any_string_dtype) + # extractall should return a DataFrame with one row for each match, indexed by the + # subject from which the match came. + expected_index = MultiIndex.from_tuples( + [(0, 0), (1, 0), (2, 0), (3, 0), (3, 1), (4, 0), (4, 1), (4, 2)], + names=(None, "match"), + ) + expected = DataFrame( + expected_tuples, expected_index, expected_columns, dtype=any_string_dtype + ) + result = s.str.extractall(pat, flags=re.VERBOSE) + tm.assert_frame_equal(result, expected) + + # The index of the input Series should be used to construct the index of the output + # DataFrame: + mi = MultiIndex.from_tuples( + [ + ("single", "Dave"), + ("single", "Toby"), + ("single", "Maude"), + ("multiple", "robAndSteve"), + ("multiple", "abcdef"), + ("none", "missing"), + ("none", "empty"), + ] + ) + s = Series(data, index=mi, dtype=any_string_dtype) + expected_index = MultiIndex.from_tuples( + [ + ("single", "Dave", 0), + ("single", "Toby", 0), + ("single", "Maude", 0), + ("multiple", "robAndSteve", 0), + ("multiple", "robAndSteve", 1), + ("multiple", "abcdef", 0), + ("multiple", "abcdef", 1), + ("multiple", "abcdef", 2), + ], + names=(None, None, "match"), + ) + expected = DataFrame( + expected_tuples, expected_index, expected_columns, dtype=any_string_dtype + ) + result = s.str.extractall(pat, flags=re.VERBOSE) + tm.assert_frame_equal(result, expected) + + # MultiIndexed subject with names. + s = Series(data, index=mi, dtype=any_string_dtype) + s.index.names = ("matches", "description") + expected_index.names = ("matches", "description", "match") + expected = DataFrame( + expected_tuples, expected_index, expected_columns, dtype=any_string_dtype + ) + result = s.str.extractall(pat, flags=re.VERBOSE) + tm.assert_frame_equal(result, expected) + + +@pytest.mark.parametrize( + "pat,expected_names", + [ + # optional groups. + ("(?P[AB])?(?P[123])", ["letter", "number"]), + # only one of two groups has a name. + ("([AB])?(?P[123])", [0, "number"]), + ], +) +def test_extractall_column_names(pat, expected_names, any_string_dtype): + s = Series(["", "A1", "32"], dtype=any_string_dtype) + + result = s.str.extractall(pat) + expected = DataFrame( + [("A", "1"), (np.nan, "3"), (np.nan, "2")], + index=MultiIndex.from_tuples([(1, 0), (2, 0), (2, 1)], names=(None, "match")), + columns=expected_names, + dtype=any_string_dtype, + ) + tm.assert_frame_equal(result, expected) + + +def test_extractall_single_group(any_string_dtype): + s = Series(["a3", "b3", "d4c2"], name="series_name", dtype=any_string_dtype) + expected_index = MultiIndex.from_tuples( + [(0, 0), (1, 0), (2, 0), (2, 1)], names=(None, "match") + ) + + # extractall(one named group) returns DataFrame with one named column. + result = s.str.extractall(r"(?P[a-z])") + expected = DataFrame( + {"letter": ["a", "b", "d", "c"]}, index=expected_index, dtype=any_string_dtype + ) + tm.assert_frame_equal(result, expected) + + # extractall(one un-named group) returns DataFrame with one un-named column. + result = s.str.extractall(r"([a-z])") + expected = DataFrame( + ["a", "b", "d", "c"], index=expected_index, dtype=any_string_dtype + ) + tm.assert_frame_equal(result, expected) + + +def test_extractall_single_group_with_quantifier(any_string_dtype): + # GH#13382 + # extractall(one un-named group with quantifier) returns DataFrame with one un-named + # column. + s = Series(["ab3", "abc3", "d4cd2"], name="series_name", dtype=any_string_dtype) + result = s.str.extractall(r"([a-z]+)") + expected = DataFrame( + ["ab", "abc", "d", "cd"], + index=MultiIndex.from_tuples( + [(0, 0), (1, 0), (2, 0), (2, 1)], names=(None, "match") + ), + dtype=any_string_dtype, + ) + tm.assert_frame_equal(result, expected) + + +@pytest.mark.parametrize( + "data, names", + [ + ([], (None,)), + ([], ("i1",)), + ([], (None, "i2")), + ([], ("i1", "i2")), + (["a3", "b3", "d4c2"], (None,)), + (["a3", "b3", "d4c2"], ("i1", "i2")), + (["a3", "b3", "d4c2"], (None, "i2")), + (["a3", "b3", "d4c2"], ("i1", "i2")), + ], +) +def test_extractall_no_matches(data, names, any_string_dtype): + # GH19075 extractall with no matches should return a valid MultiIndex + n = len(data) + if len(names) == 1: + index = Index(range(n), name=names[0]) + else: + tuples = (tuple([i] * (n - 1)) for i in range(n)) + index = MultiIndex.from_tuples(tuples, names=names) + s = Series(data, name="series_name", index=index, dtype=any_string_dtype) + expected_index = MultiIndex.from_tuples([], names=(names + ("match",))) + + # one un-named group. + result = s.str.extractall("(z)") + expected = DataFrame(columns=[0], index=expected_index, dtype=any_string_dtype) + tm.assert_frame_equal(result, expected) + + # two un-named groups. + result = s.str.extractall("(z)(z)") + expected = DataFrame(columns=[0, 1], index=expected_index, dtype=any_string_dtype) + tm.assert_frame_equal(result, expected) + + # one named group. + result = s.str.extractall("(?Pz)") + expected = DataFrame( + columns=["first"], index=expected_index, dtype=any_string_dtype + ) + tm.assert_frame_equal(result, expected) + + # two named groups. + result = s.str.extractall("(?Pz)(?Pz)") + expected = DataFrame( + columns=["first", "second"], index=expected_index, dtype=any_string_dtype + ) + tm.assert_frame_equal(result, expected) + + # one named, one un-named. + result = s.str.extractall("(z)(?Pz)") + expected = DataFrame( + columns=[0, "second"], index=expected_index, dtype=any_string_dtype + ) + tm.assert_frame_equal(result, expected) + + +def test_extractall_stringindex(any_string_dtype): + s = Series(["a1a2", "b1", "c1"], name="xxx", dtype=any_string_dtype) + result = s.str.extractall(r"[ab](?P\d)") + expected = DataFrame( + {"digit": ["1", "2", "1"]}, + index=MultiIndex.from_tuples([(0, 0), (0, 1), (1, 0)], names=[None, "match"]), + dtype=any_string_dtype, + ) + tm.assert_frame_equal(result, expected) + + # index should return the same result as the default index without name thus + # index.name doesn't affect to the result + if any_string_dtype == "object": + for idx in [ + Index(["a1a2", "b1", "c1"], dtype=object), + Index(["a1a2", "b1", "c1"], name="xxx", dtype=object), + ]: + result = idx.str.extractall(r"[ab](?P\d)") + tm.assert_frame_equal(result, expected) + + s = Series( + ["a1a2", "b1", "c1"], + name="s_name", + index=Index(["XX", "yy", "zz"], name="idx_name"), + dtype=any_string_dtype, + ) + result = s.str.extractall(r"[ab](?P\d)") + expected = DataFrame( + {"digit": ["1", "2", "1"]}, + index=MultiIndex.from_tuples( + [("XX", 0), ("XX", 1), ("yy", 0)], names=["idx_name", "match"] + ), + dtype=any_string_dtype, + ) + tm.assert_frame_equal(result, expected) + + +def test_extractall_no_capture_groups_raises(any_string_dtype): + # Does not make sense to use extractall with a regex that has no capture groups. + # (it returns DataFrame with one column for each capture group) + s = Series(["a3", "b3", "d4c2"], name="series_name", dtype=any_string_dtype) + with pytest.raises(ValueError, match="no capture groups"): + s.str.extractall(r"[a-z]") + + +def test_extract_index_one_two_groups(): + s = Series(["a3", "b3", "d4c2"], index=["A3", "B3", "D4"], name="series_name") + r = s.index.str.extract(r"([A-Z])", expand=True) + e = DataFrame(["A", "B", "D"]) + tm.assert_frame_equal(r, e) + + # Prior to v0.18.0, index.str.extract(regex with one group) + # returned Index. With more than one group, extract raised an + # error (GH9980). Now extract always returns DataFrame. + r = s.index.str.extract(r"(?P[A-Z])(?P[0-9])", expand=True) + e_list = [("A", "3"), ("B", "3"), ("D", "4")] + e = DataFrame(e_list, columns=["letter", "digit"]) + tm.assert_frame_equal(r, e) + + +def test_extractall_same_as_extract(any_string_dtype): + s = Series(["a3", "b3", "c2"], name="series_name", dtype=any_string_dtype) + + pattern_two_noname = r"([a-z])([0-9])" + extract_two_noname = s.str.extract(pattern_two_noname, expand=True) + has_multi_index = s.str.extractall(pattern_two_noname) + no_multi_index = has_multi_index.xs(0, level="match") + tm.assert_frame_equal(extract_two_noname, no_multi_index) + + pattern_two_named = r"(?P[a-z])(?P[0-9])" + extract_two_named = s.str.extract(pattern_two_named, expand=True) + has_multi_index = s.str.extractall(pattern_two_named) + no_multi_index = has_multi_index.xs(0, level="match") + tm.assert_frame_equal(extract_two_named, no_multi_index) + + pattern_one_named = r"(?P[a-z])" + extract_one_named = s.str.extract(pattern_one_named, expand=True) + has_multi_index = s.str.extractall(pattern_one_named) + no_multi_index = has_multi_index.xs(0, level="match") + tm.assert_frame_equal(extract_one_named, no_multi_index) + + pattern_one_noname = r"([a-z])" + extract_one_noname = s.str.extract(pattern_one_noname, expand=True) + has_multi_index = s.str.extractall(pattern_one_noname) + no_multi_index = has_multi_index.xs(0, level="match") + tm.assert_frame_equal(extract_one_noname, no_multi_index) + + +def test_extractall_same_as_extract_subject_index(any_string_dtype): + # same as above tests, but s has an MultiIndex. + mi = MultiIndex.from_tuples( + [("A", "first"), ("B", "second"), ("C", "third")], + names=("capital", "ordinal"), + ) + s = Series(["a3", "b3", "c2"], index=mi, name="series_name", dtype=any_string_dtype) + + pattern_two_noname = r"([a-z])([0-9])" + extract_two_noname = s.str.extract(pattern_two_noname, expand=True) + has_match_index = s.str.extractall(pattern_two_noname) + no_match_index = has_match_index.xs(0, level="match") + tm.assert_frame_equal(extract_two_noname, no_match_index) + + pattern_two_named = r"(?P[a-z])(?P[0-9])" + extract_two_named = s.str.extract(pattern_two_named, expand=True) + has_match_index = s.str.extractall(pattern_two_named) + no_match_index = has_match_index.xs(0, level="match") + tm.assert_frame_equal(extract_two_named, no_match_index) + + pattern_one_named = r"(?P[a-z])" + extract_one_named = s.str.extract(pattern_one_named, expand=True) + has_match_index = s.str.extractall(pattern_one_named) + no_match_index = has_match_index.xs(0, level="match") + tm.assert_frame_equal(extract_one_named, no_match_index) + + pattern_one_noname = r"([a-z])" + extract_one_noname = s.str.extract(pattern_one_noname, expand=True) + has_match_index = s.str.extractall(pattern_one_noname) + no_match_index = has_match_index.xs(0, level="match") + tm.assert_frame_equal(extract_one_noname, no_match_index) + + +def test_extractall_preserves_dtype(): + # Ensure that when extractall is called on a series with specific dtypes set, that + # the dtype is preserved in the resulting DataFrame's column. + pa = pytest.importorskip("pyarrow") + + result = Series(["abc", "ab"], dtype=ArrowDtype(pa.string())).str.extractall("(ab)") + assert result.dtypes[0] == "string[pyarrow]" diff --git a/shared/package-files/2e/2ee356ffa2491a5a60bdf7d7febfac426824904738615a0c1d07aef6bda3b76f/blob b/shared/package-files/2e/2ee356ffa2491a5a60bdf7d7febfac426824904738615a0c1d07aef6bda3b76f/blob new file mode 100644 index 0000000000000000000000000000000000000000..b36ed36873ded884391fdad351fbe941521b668b --- /dev/null +++ b/shared/package-files/2e/2ee356ffa2491a5a60bdf7d7febfac426824904738615a0c1d07aef6bda3b76f/blob @@ -0,0 +1,6 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset it_CH DATE_FORMAT "%e. %B %Y" + ::msgcat::mcset it_CH TIME_FORMAT "%H:%M:%S" + ::msgcat::mcset it_CH DATE_TIME_FORMAT "%e. %B %Y %H:%M:%S %z" +} diff --git a/shared/package-files/2e/2ee441783df4613b7b64a908cb440f239714a0274391c154a613c5dcfe951e65/blob b/shared/package-files/2e/2ee441783df4613b7b64a908cb440f239714a0274391c154a613c5dcfe951e65/blob new file mode 100644 index 0000000000000000000000000000000000000000..212f15decffa872abed19c99fc4c8aec31daa6d2 --- /dev/null +++ b/shared/package-files/2e/2ee441783df4613b7b64a908cb440f239714a0274391c154a613c5dcfe951e65/blob @@ -0,0 +1,11 @@ +from typing import Dict, List, Optional, Union + +from django.db.backends.base.client import BaseDatabaseClient + +class DatabaseClient(BaseDatabaseClient): + executable_name: str = ... + @classmethod + def settings_to_cmd_args( + cls, settings_dict: Dict[str, Optional[Union[Dict[str, Dict[str, str]], int, str]]] + ) -> List[str]: ... + def runshell(self) -> None: ... diff --git a/shared/package-files/2e/2ee4f4c3ffc032d6b09ec04ca1b844316f60a76ca4d26039651cf0178e5cd142/blob b/shared/package-files/2e/2ee4f4c3ffc032d6b09ec04ca1b844316f60a76ca4d26039651cf0178e5cd142/blob new file mode 100644 index 0000000000000000000000000000000000000000..4b6b06871a91d9401bcf9fbd99aeb3c30ca0705f --- /dev/null +++ b/shared/package-files/2e/2ee4f4c3ffc032d6b09ec04ca1b844316f60a76ca4d26039651cf0178e5cd142/blob @@ -0,0 +1,14 @@ +from . import asciiTable + + +class table_T_T_F_A_(asciiTable.asciiTable): + """ttfautohint parameters table + + The ``TTFA`` table is used by the free-software `ttfautohint` program + to record the parameters that `ttfautohint` was called with when it + was used to auto-hint the font. + + See also http://freetype.org/ttfautohint/doc/ttfautohint.html#miscellaneous-1 + """ + + pass diff --git a/shared/package-files/2e/2ee656f28f77559662edc6043f7d1dbca5939bb330d532e60ade546970f10898/blob b/shared/package-files/2e/2ee656f28f77559662edc6043f7d1dbca5939bb330d532e60ade546970f10898/blob new file mode 100644 index 0000000000000000000000000000000000000000..26ae18466740b230f9b964ebb4c72c54f13c73ee --- /dev/null +++ b/shared/package-files/2e/2ee656f28f77559662edc6043f7d1dbca5939bb330d532e60ade546970f10898/blob @@ -0,0 +1,20 @@ +#if defined(DETECT_FEATURES) && defined(__INTEL_COMPILER) + /* + * Unlike GCC and CLANG, Intel Compiler exposes all supported intrinsics, + * whether or not the build options for those features are specified. + * Therefore, we must test #definitions of CPU features when option native/host + * is enabled via `--cpu-baseline` or through env var `CFLAGS` otherwise + * the test will be broken and leads to enable all possible features. + */ + #ifndef __AVX__ + #error "HOST/ARCH doesn't support AVX" + #endif +#endif + +#include + +int main(int argc, char **argv) +{ + __m256 a = _mm256_add_ps(_mm256_loadu_ps((const float*)argv[argc-1]), _mm256_loadu_ps((const float*)argv[1])); + return (int)_mm_cvtss_f32(_mm256_castps256_ps128(a)); +} diff --git a/shared/package-files/2e/2ee70fb03381b96701b9b9e0a686dac6d4f43e356d81170f06725fed88f01d2c/blob b/shared/package-files/2e/2ee70fb03381b96701b9b9e0a686dac6d4f43e356d81170f06725fed88f01d2c/blob new file mode 100644 index 0000000000000000000000000000000000000000..df6e627af6b30f57eb51cd28f31f5496d0519381 Binary files /dev/null and b/shared/package-files/2e/2ee70fb03381b96701b9b9e0a686dac6d4f43e356d81170f06725fed88f01d2c/blob differ diff --git a/shared/package-files/2e/2ee7953a85601960c1c106fc385c1791529f567df708cd4b9307f5f80f3ab514/blob b/shared/package-files/2e/2ee7953a85601960c1c106fc385c1791529f567df708cd4b9307f5f80f3ab514/blob new file mode 100644 index 0000000000000000000000000000000000000000..a753e2a3aa24383ec6ac8fd125a0120c1d6f9029 --- /dev/null +++ b/shared/package-files/2e/2ee7953a85601960c1c106fc385c1791529f567df708cd4b9307f5f80f3ab514/blob @@ -0,0 +1,91 @@ +"""macOS.""" +from __future__ import annotations + +import os.path + +from .api import PlatformDirsABC + + +class MacOS(PlatformDirsABC): + """ + Platform directories for the macOS operating system. Follows the guidance from `Apple documentation + `_. + Makes use of the `appname `, + `version `, + `ensure_exists `. + """ + + @property + def user_data_dir(self) -> str: + """:return: data directory tied to the user, e.g. ``~/Library/Application Support/$appname/$version``""" + return self._append_app_name_and_version(os.path.expanduser("~/Library/Application Support")) # noqa: PTH111 + + @property + def site_data_dir(self) -> str: + """:return: data directory shared by users, e.g. ``/Library/Application Support/$appname/$version``""" + return self._append_app_name_and_version("/Library/Application Support") + + @property + def user_config_dir(self) -> str: + """:return: config directory tied to the user, same as `user_data_dir`""" + return self.user_data_dir + + @property + def site_config_dir(self) -> str: + """:return: config directory shared by the users, same as `site_data_dir`""" + return self.site_data_dir + + @property + def user_cache_dir(self) -> str: + """:return: cache directory tied to the user, e.g. ``~/Library/Caches/$appname/$version``""" + return self._append_app_name_and_version(os.path.expanduser("~/Library/Caches")) # noqa: PTH111 + + @property + def site_cache_dir(self) -> str: + """:return: cache directory shared by users, e.g. ``/Library/Caches/$appname/$version``""" + return self._append_app_name_and_version("/Library/Caches") + + @property + def user_state_dir(self) -> str: + """:return: state directory tied to the user, same as `user_data_dir`""" + return self.user_data_dir + + @property + def user_log_dir(self) -> str: + """:return: log directory tied to the user, e.g. ``~/Library/Logs/$appname/$version``""" + return self._append_app_name_and_version(os.path.expanduser("~/Library/Logs")) # noqa: PTH111 + + @property + def user_documents_dir(self) -> str: + """:return: documents directory tied to the user, e.g. ``~/Documents``""" + return os.path.expanduser("~/Documents") # noqa: PTH111 + + @property + def user_downloads_dir(self) -> str: + """:return: downloads directory tied to the user, e.g. ``~/Downloads``""" + return os.path.expanduser("~/Downloads") # noqa: PTH111 + + @property + def user_pictures_dir(self) -> str: + """:return: pictures directory tied to the user, e.g. ``~/Pictures``""" + return os.path.expanduser("~/Pictures") # noqa: PTH111 + + @property + def user_videos_dir(self) -> str: + """:return: videos directory tied to the user, e.g. ``~/Movies``""" + return os.path.expanduser("~/Movies") # noqa: PTH111 + + @property + def user_music_dir(self) -> str: + """:return: music directory tied to the user, e.g. ``~/Music``""" + return os.path.expanduser("~/Music") # noqa: PTH111 + + @property + def user_runtime_dir(self) -> str: + """:return: runtime directory tied to the user, e.g. ``~/Library/Caches/TemporaryItems/$appname/$version``""" + return self._append_app_name_and_version(os.path.expanduser("~/Library/Caches/TemporaryItems")) # noqa: PTH111 + + +__all__ = [ + "MacOS", +] diff --git a/shared/package-files/2e/2ee8cbfb3974ecd0a735b3057ed88de45ab044b3125f2ae4c219f206df1c3ccb/blob b/shared/package-files/2e/2ee8cbfb3974ecd0a735b3057ed88de45ab044b3125f2ae4c219f206df1c3ccb/blob new file mode 100644 index 0000000000000000000000000000000000000000..1b1d2310a47ed5d3fedacc15a24e772f0c8835d3 --- /dev/null +++ b/shared/package-files/2e/2ee8cbfb3974ecd0a735b3057ed88de45ab044b3125f2ae4c219f206df1c3ccb/blob @@ -0,0 +1,28 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API row_indices { + using schema = at::Tensor (const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::row_indices") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "row_indices(Tensor(a) self) -> Tensor(a)") + static at::Tensor call(const at::Tensor & self); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/2e/2eed6198a6a99a5937fe377515c20f6eb9f3f3d595953342c18e3a0f84c56df1/blob b/shared/package-files/2e/2eed6198a6a99a5937fe377515c20f6eb9f3f3d595953342c18e3a0f84c56df1/blob new file mode 100644 index 0000000000000000000000000000000000000000..112b38d83a394ddbfd4bc7182f842e7c8bbeabc8 --- /dev/null +++ b/shared/package-files/2e/2eed6198a6a99a5937fe377515c20f6eb9f3f3d595953342c18e3a0f84c56df1/blob @@ -0,0 +1,38 @@ +from typing import AnyStr, Generic, Iterable, List, Optional, Tuple, Union + +from paramiko.util import ClosingContextManager + +class BufferedFile(ClosingContextManager, Generic[AnyStr]): + SEEK_SET: int + SEEK_CUR: int + SEEK_END: int + + FLAG_READ: int + FLAG_WRITE: int + FLAG_APPEND: int + FLAG_BINARY: int + FLAG_BUFFERED: int + FLAG_LINE_BUFFERED: int + FLAG_UNIVERSAL_NEWLINE: int + + newlines: Union[None, AnyStr, Tuple[AnyStr, ...]] + def __init__(self) -> None: ... + def __del__(self) -> None: ... + def __iter__(self) -> BufferedFile: ... + def close(self) -> None: ... + def flush(self) -> None: ... + def __next__(self) -> AnyStr: ... + def readable(self) -> bool: ... + def writable(self) -> bool: ... + def seekable(self) -> bool: ... + def readinto(self, buff: bytearray) -> int: ... + def read(self, size: Optional[int] = ...) -> AnyStr: ... + def readline(self, size: Optional[int] = ...) -> AnyStr: ... + def readlines(self, sizehint: Optional[int] = ...) -> List[AnyStr]: ... + def seek(self, offset: int, whence: int = ...) -> None: ... + def tell(self) -> int: ... + def write(self, data: AnyStr) -> None: ... + def writelines(self, sequence: Iterable[AnyStr]) -> None: ... + def xreadlines(self) -> BufferedFile: ... + @property + def closed(self) -> bool: ... diff --git a/shared/package-files/2e/2eed95d9d64b0c4dcd8a7ebf8476d10ba5762f6eefeaf35c3f44abc9f45f8fb6/blob b/shared/package-files/2e/2eed95d9d64b0c4dcd8a7ebf8476d10ba5762f6eefeaf35c3f44abc9f45f8fb6/blob new file mode 100644 index 0000000000000000000000000000000000000000..70f3f4bf7bf03f04379b781467db8d429a11abcc --- /dev/null +++ b/shared/package-files/2e/2eed95d9d64b0c4dcd8a7ebf8476d10ba5762f6eefeaf35c3f44abc9f45f8fb6/blob @@ -0,0 +1,24 @@ +#pragma once + +#include + +namespace torch { +namespace jit { +namespace tensorexpr { + +Tensor computeMatmul( + const std::vector& inputs, + const std::vector& outputShape, + const std::vector& outputStrides, + const c10::optional& outputType, + at::Device device); +Tensor computeAddMM( + const std::vector& inputs, + const std::vector& outputShape, + const std::vector& outputStrides, + const c10::optional& outputType, + at::Device device); + +} // namespace tensorexpr +} // namespace jit +} // namespace torch diff --git a/shared/package-files/2e/2eee023a23bca6fcc91e7cbd517a975efeaff648fa41ce8fbc2b0976dba35c7a/blob b/shared/package-files/2e/2eee023a23bca6fcc91e7cbd517a975efeaff648fa41ce8fbc2b0976dba35c7a/blob new file mode 100644 index 0000000000000000000000000000000000000000..7682b4f8ae426b4aa0537505e55c9c98efd47b94 --- /dev/null +++ b/shared/package-files/2e/2eee023a23bca6fcc91e7cbd517a975efeaff648fa41ce8fbc2b0976dba35c7a/blob @@ -0,0 +1,7 @@ +from torch.ao.nn.intrinsic.quantized import BNReLU2d +from torch.ao.nn.intrinsic.quantized import BNReLU3d + +__all__ = [ + 'BNReLU2d', + 'BNReLU3d', +] diff --git a/shared/package-files/2e/2ef4c53f7fe3a7267b835cffebe135d5227ca23ad5243f61cf4a4427b55500dc/blob b/shared/package-files/2e/2ef4c53f7fe3a7267b835cffebe135d5227ca23ad5243f61cf4a4427b55500dc/blob new file mode 100644 index 0000000000000000000000000000000000000000..9cf664031dd5bb6afa3cbdd2bce766cf2e2b847f Binary files /dev/null and b/shared/package-files/2e/2ef4c53f7fe3a7267b835cffebe135d5227ca23ad5243f61cf4a4427b55500dc/blob differ diff --git a/shared/package-files/2e/2ef68fc1f8ccdabef7c89c1330dbb54a20cacd65aace12418cdfe48af9d8b32a/blob b/shared/package-files/2e/2ef68fc1f8ccdabef7c89c1330dbb54a20cacd65aace12418cdfe48af9d8b32a/blob new file mode 100644 index 0000000000000000000000000000000000000000..4b7dc1ad409eda9f71944a45f2d284b3fea8785e --- /dev/null +++ b/shared/package-files/2e/2ef68fc1f8ccdabef7c89c1330dbb54a20cacd65aace12418cdfe48af9d8b32a/blob @@ -0,0 +1,75 @@ +""" + pygments.lexers._cocoa_builtins + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + This file defines a set of types used across Cocoa frameworks from Apple. + There is a list of @interfaces, @protocols and some other (structs, unions) + + File may be also used as standalone generator for above. + + :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS. + :license: BSD, see LICENSE for details. +""" + +COCOA_INTERFACES = {'AAAttribution', 'ABNewPersonViewController', 'ABPeoplePickerNavigationController', 'ABPersonViewController', 'ABUnknownPersonViewController', 'ACAccount', 'ACAccountCredential', 'ACAccountStore', 'ACAccountType', 'ADBannerView', 'ADClient', 'ADInterstitialAd', 'ADInterstitialAdPresentationViewController', 'AEAssessmentConfiguration', 'AEAssessmentSession', 'ALAsset', 'ALAssetRepresentation', 'ALAssetsFilter', 'ALAssetsGroup', 'ALAssetsLibrary', 'APActivationPayload', 'ARAnchor', 'ARAppClipCodeAnchor', 'ARBody2D', 'ARBodyAnchor', 'ARBodyTrackingConfiguration', 'ARCamera', 'ARCoachingOverlayView', 'ARCollaborationData', 'ARConfiguration', 'ARDepthData', 'ARDirectionalLightEstimate', 'AREnvironmentProbeAnchor', 'ARFaceAnchor', 'ARFaceGeometry', 'ARFaceTrackingConfiguration', 'ARFrame', 'ARGeoAnchor', 'ARGeoTrackingConfiguration', 'ARGeoTrackingStatus', 'ARGeometryElement', 'ARGeometrySource', 'ARHitTestResult', 'ARImageAnchor', 'ARImageTrackingConfiguration', 'ARLightEstimate', 'ARMatteGenerator', 'ARMeshAnchor', 'ARMeshGeometry', 'ARObjectAnchor', 'ARObjectScanningConfiguration', 'AROrientationTrackingConfiguration', 'ARParticipantAnchor', 'ARPlaneAnchor', 'ARPlaneGeometry', 'ARPointCloud', 'ARPositionalTrackingConfiguration', 'ARQuickLookPreviewItem', 'ARRaycastQuery', 'ARRaycastResult', 'ARReferenceImage', 'ARReferenceObject', 'ARSCNFaceGeometry', 'ARSCNPlaneGeometry', 'ARSCNView', 'ARSKView', 'ARSession', 'ARSkeleton', 'ARSkeleton2D', 'ARSkeleton3D', 'ARSkeletonDefinition', 'ARTrackedRaycast', 'ARVideoFormat', 'ARView', 'ARWorldMap', 'ARWorldTrackingConfiguration', 'ASAccountAuthenticationModificationController', 'ASAccountAuthenticationModificationExtensionContext', 'ASAccountAuthenticationModificationReplacePasswordWithSignInWithAppleRequest', 'ASAccountAuthenticationModificationRequest', 'ASAccountAuthenticationModificationUpgradePasswordToStrongPasswordRequest', 'ASAccountAuthenticationModificationViewController', 'ASAuthorization', 'ASAuthorizationAppleIDButton', 'ASAuthorizationAppleIDCredential', 'ASAuthorizationAppleIDProvider', 'ASAuthorizationAppleIDRequest', 'ASAuthorizationController', 'ASAuthorizationOpenIDRequest', 'ASAuthorizationPasswordProvider', 'ASAuthorizationPasswordRequest', 'ASAuthorizationProviderExtensionAuthorizationRequest', 'ASAuthorizationRequest', 'ASAuthorizationSingleSignOnCredential', 'ASAuthorizationSingleSignOnProvider', 'ASAuthorizationSingleSignOnRequest', 'ASCredentialIdentityStore', 'ASCredentialIdentityStoreState', 'ASCredentialProviderExtensionContext', 'ASCredentialProviderViewController', 'ASCredentialServiceIdentifier', 'ASIdentifierManager', 'ASPasswordCredential', 'ASPasswordCredentialIdentity', 'ASWebAuthenticationSession', 'ASWebAuthenticationSessionRequest', 'ASWebAuthenticationSessionWebBrowserSessionManager', 'ATTrackingManager', 'AUAudioUnit', 'AUAudioUnitBus', 'AUAudioUnitBusArray', 'AUAudioUnitPreset', 'AUAudioUnitV2Bridge', 'AUAudioUnitViewConfiguration', 'AUParameter', 'AUParameterGroup', 'AUParameterNode', 'AUParameterTree', 'AUViewController', 'AVAggregateAssetDownloadTask', 'AVAsset', 'AVAssetCache', 'AVAssetDownloadStorageManagementPolicy', 'AVAssetDownloadStorageManager', 'AVAssetDownloadTask', 'AVAssetDownloadURLSession', 'AVAssetExportSession', 'AVAssetImageGenerator', 'AVAssetReader', 'AVAssetReaderAudioMixOutput', 'AVAssetReaderOutput', 'AVAssetReaderOutputMetadataAdaptor', 'AVAssetReaderSampleReferenceOutput', 'AVAssetReaderTrackOutput', 'AVAssetReaderVideoCompositionOutput', 'AVAssetResourceLoader', 'AVAssetResourceLoadingContentInformationRequest', 'AVAssetResourceLoadingDataRequest', 'AVAssetResourceLoadingRequest', 'AVAssetResourceLoadingRequestor', 'AVAssetResourceRenewalRequest', 'AVAssetSegmentReport', 'AVAssetSegmentReportSampleInformation', 'AVAssetSegmentTrackReport', 'AVAssetTrack', 'AVAssetTrackGroup', 'AVAssetTrackSegment', 'AVAssetWriter', 'AVAssetWriterInput', 'AVAssetWriterInputGroup', 'AVAssetWriterInputMetadataAdaptor', 'AVAssetWriterInputPassDescription', 'AVAssetWriterInputPixelBufferAdaptor', 'AVAsynchronousCIImageFilteringRequest', 'AVAsynchronousVideoCompositionRequest', 'AVAudioMix', 'AVAudioMixInputParameters', 'AVAudioSession', 'AVCameraCalibrationData', 'AVCaptureAudioChannel', 'AVCaptureAudioDataOutput', 'AVCaptureAudioFileOutput', 'AVCaptureAudioPreviewOutput', 'AVCaptureAutoExposureBracketedStillImageSettings', 'AVCaptureBracketedStillImageSettings', 'AVCaptureConnection', 'AVCaptureDataOutputSynchronizer', 'AVCaptureDepthDataOutput', 'AVCaptureDevice', 'AVCaptureDeviceDiscoverySession', 'AVCaptureDeviceFormat', 'AVCaptureDeviceInput', 'AVCaptureDeviceInputSource', 'AVCaptureFileOutput', 'AVCaptureInput', 'AVCaptureInputPort', 'AVCaptureManualExposureBracketedStillImageSettings', 'AVCaptureMetadataInput', 'AVCaptureMetadataOutput', 'AVCaptureMovieFileOutput', 'AVCaptureMultiCamSession', 'AVCaptureOutput', 'AVCapturePhoto', 'AVCapturePhotoBracketSettings', 'AVCapturePhotoOutput', 'AVCapturePhotoSettings', 'AVCaptureResolvedPhotoSettings', 'AVCaptureScreenInput', 'AVCaptureSession', 'AVCaptureStillImageOutput', 'AVCaptureSynchronizedData', 'AVCaptureSynchronizedDataCollection', 'AVCaptureSynchronizedDepthData', 'AVCaptureSynchronizedMetadataObjectData', 'AVCaptureSynchronizedSampleBufferData', 'AVCaptureSystemPressureState', 'AVCaptureVideoDataOutput', 'AVCaptureVideoPreviewLayer', 'AVComposition', 'AVCompositionTrack', 'AVCompositionTrackFormatDescriptionReplacement', 'AVCompositionTrackSegment', 'AVContentKeyRequest', 'AVContentKeyResponse', 'AVContentKeySession', 'AVDateRangeMetadataGroup', 'AVDepthData', 'AVDisplayCriteria', 'AVFragmentedAsset', 'AVFragmentedAssetMinder', 'AVFragmentedAssetTrack', 'AVFragmentedMovie', 'AVFragmentedMovieMinder', 'AVFragmentedMovieTrack', 'AVFrameRateRange', 'AVMediaDataStorage', 'AVMediaSelection', 'AVMediaSelectionGroup', 'AVMediaSelectionOption', 'AVMetadataBodyObject', 'AVMetadataCatBodyObject', 'AVMetadataDogBodyObject', 'AVMetadataFaceObject', 'AVMetadataGroup', 'AVMetadataHumanBodyObject', 'AVMetadataItem', 'AVMetadataItemFilter', 'AVMetadataItemValueRequest', 'AVMetadataMachineReadableCodeObject', 'AVMetadataObject', 'AVMetadataSalientObject', 'AVMovie', 'AVMovieTrack', 'AVMutableAssetDownloadStorageManagementPolicy', 'AVMutableAudioMix', 'AVMutableAudioMixInputParameters', 'AVMutableComposition', 'AVMutableCompositionTrack', 'AVMutableDateRangeMetadataGroup', 'AVMutableMediaSelection', 'AVMutableMetadataItem', 'AVMutableMovie', 'AVMutableMovieTrack', 'AVMutableTimedMetadataGroup', 'AVMutableVideoComposition', 'AVMutableVideoCompositionInstruction', 'AVMutableVideoCompositionLayerInstruction', 'AVOutputSettingsAssistant', 'AVPersistableContentKeyRequest', 'AVPictureInPictureController', 'AVPlayer', 'AVPlayerItem', 'AVPlayerItemAccessLog', 'AVPlayerItemAccessLogEvent', 'AVPlayerItemErrorLog', 'AVPlayerItemErrorLogEvent', 'AVPlayerItemLegibleOutput', 'AVPlayerItemMediaDataCollector', 'AVPlayerItemMetadataCollector', 'AVPlayerItemMetadataOutput', 'AVPlayerItemOutput', 'AVPlayerItemTrack', 'AVPlayerItemVideoOutput', 'AVPlayerLayer', 'AVPlayerLooper', 'AVPlayerMediaSelectionCriteria', 'AVPlayerViewController', 'AVPortraitEffectsMatte', 'AVQueuePlayer', 'AVRouteDetector', 'AVRoutePickerView', 'AVSampleBufferAudioRenderer', 'AVSampleBufferDisplayLayer', 'AVSampleBufferRenderSynchronizer', 'AVSemanticSegmentationMatte', 'AVSynchronizedLayer', 'AVTextStyleRule', 'AVTimedMetadataGroup', 'AVURLAsset', 'AVVideoComposition', 'AVVideoCompositionCoreAnimationTool', 'AVVideoCompositionInstruction', 'AVVideoCompositionLayerInstruction', 'AVVideoCompositionRenderContext', 'AVVideoCompositionRenderHint', 'AXCustomContent', 'BCChatAction', 'BCChatButton', 'BGAppRefreshTask', 'BGAppRefreshTaskRequest', 'BGProcessingTask', 'BGProcessingTaskRequest', 'BGTask', 'BGTaskRequest', 'BGTaskScheduler', 'CAAnimation', 'CAAnimationGroup', 'CABTMIDICentralViewController', 'CABTMIDILocalPeripheralViewController', 'CABasicAnimation', 'CADisplayLink', 'CAEAGLLayer', 'CAEmitterCell', 'CAEmitterLayer', 'CAGradientLayer', 'CAInterAppAudioSwitcherView', 'CAInterAppAudioTransportView', 'CAKeyframeAnimation', 'CALayer', 'CAMediaTimingFunction', 'CAMetalLayer', 'CAPropertyAnimation', 'CAReplicatorLayer', 'CAScrollLayer', 'CAShapeLayer', 'CASpringAnimation', 'CATextLayer', 'CATiledLayer', 'CATransaction', 'CATransformLayer', 'CATransition', 'CAValueFunction', 'CBATTRequest', 'CBAttribute', 'CBCentral', 'CBCentralManager', 'CBCharacteristic', 'CBDescriptor', 'CBL2CAPChannel', 'CBManager', 'CBMutableCharacteristic', 'CBMutableDescriptor', 'CBMutableService', 'CBPeer', 'CBPeripheral', 'CBPeripheralManager', 'CBService', 'CBUUID', 'CHHapticDynamicParameter', 'CHHapticEngine', 'CHHapticEvent', 'CHHapticEventParameter', 'CHHapticParameterCurve', 'CHHapticParameterCurveControlPoint', 'CHHapticPattern', 'CIAztecCodeDescriptor', 'CIBarcodeDescriptor', 'CIBlendKernel', 'CIColor', 'CIColorKernel', 'CIContext', 'CIDataMatrixCodeDescriptor', 'CIDetector', 'CIFaceFeature', 'CIFeature', 'CIFilter', 'CIFilterGenerator', 'CIFilterShape', 'CIImage', 'CIImageAccumulator', 'CIImageProcessorKernel', 'CIKernel', 'CIPDF417CodeDescriptor', 'CIPlugIn', 'CIQRCodeDescriptor', 'CIQRCodeFeature', 'CIRectangleFeature', 'CIRenderDestination', 'CIRenderInfo', 'CIRenderTask', 'CISampler', 'CITextFeature', 'CIVector', 'CIWarpKernel', 'CKAcceptSharesOperation', 'CKAsset', 'CKContainer', 'CKDatabase', 'CKDatabaseNotification', 'CKDatabaseOperation', 'CKDatabaseSubscription', 'CKDiscoverAllUserIdentitiesOperation', 'CKDiscoverUserIdentitiesOperation', 'CKFetchDatabaseChangesOperation', 'CKFetchNotificationChangesOperation', 'CKFetchRecordChangesOperation', 'CKFetchRecordZoneChangesConfiguration', 'CKFetchRecordZoneChangesOperation', 'CKFetchRecordZoneChangesOptions', 'CKFetchRecordZonesOperation', 'CKFetchRecordsOperation', 'CKFetchShareMetadataOperation', 'CKFetchShareParticipantsOperation', 'CKFetchSubscriptionsOperation', 'CKFetchWebAuthTokenOperation', 'CKLocationSortDescriptor', 'CKMarkNotificationsReadOperation', 'CKModifyBadgeOperation', 'CKModifyRecordZonesOperation', 'CKModifyRecordsOperation', 'CKModifySubscriptionsOperation', 'CKNotification', 'CKNotificationID', 'CKNotificationInfo', 'CKOperation', 'CKOperationConfiguration', 'CKOperationGroup', 'CKQuery', 'CKQueryCursor', 'CKQueryNotification', 'CKQueryOperation', 'CKQuerySubscription', 'CKRecord', 'CKRecordID', 'CKRecordZone', 'CKRecordZoneID', 'CKRecordZoneNotification', 'CKRecordZoneSubscription', 'CKReference', 'CKServerChangeToken', 'CKShare', 'CKShareMetadata', 'CKShareParticipant', 'CKSubscription', 'CKUserIdentity', 'CKUserIdentityLookupInfo', 'CLBeacon', 'CLBeaconIdentityConstraint', 'CLBeaconRegion', 'CLCircularRegion', 'CLFloor', 'CLGeocoder', 'CLHeading', 'CLKComplication', 'CLKComplicationDescriptor', 'CLKComplicationServer', 'CLKComplicationTemplate', 'CLKComplicationTemplateCircularSmallRingImage', 'CLKComplicationTemplateCircularSmallRingText', 'CLKComplicationTemplateCircularSmallSimpleImage', 'CLKComplicationTemplateCircularSmallSimpleText', 'CLKComplicationTemplateCircularSmallStackImage', 'CLKComplicationTemplateCircularSmallStackText', 'CLKComplicationTemplateExtraLargeColumnsText', 'CLKComplicationTemplateExtraLargeRingImage', 'CLKComplicationTemplateExtraLargeRingText', 'CLKComplicationTemplateExtraLargeSimpleImage', 'CLKComplicationTemplateExtraLargeSimpleText', 'CLKComplicationTemplateExtraLargeStackImage', 'CLKComplicationTemplateExtraLargeStackText', 'CLKComplicationTemplateGraphicBezelCircularText', 'CLKComplicationTemplateGraphicCircular', 'CLKComplicationTemplateGraphicCircularClosedGaugeImage', 'CLKComplicationTemplateGraphicCircularClosedGaugeText', 'CLKComplicationTemplateGraphicCircularImage', 'CLKComplicationTemplateGraphicCircularOpenGaugeImage', 'CLKComplicationTemplateGraphicCircularOpenGaugeRangeText', 'CLKComplicationTemplateGraphicCircularOpenGaugeSimpleText', 'CLKComplicationTemplateGraphicCircularStackImage', 'CLKComplicationTemplateGraphicCircularStackText', 'CLKComplicationTemplateGraphicCornerCircularImage', 'CLKComplicationTemplateGraphicCornerGaugeImage', 'CLKComplicationTemplateGraphicCornerGaugeText', 'CLKComplicationTemplateGraphicCornerStackText', 'CLKComplicationTemplateGraphicCornerTextImage', 'CLKComplicationTemplateGraphicExtraLargeCircular', 'CLKComplicationTemplateGraphicExtraLargeCircularClosedGaugeImage', 'CLKComplicationTemplateGraphicExtraLargeCircularClosedGaugeText', 'CLKComplicationTemplateGraphicExtraLargeCircularImage', 'CLKComplicationTemplateGraphicExtraLargeCircularOpenGaugeImage', 'CLKComplicationTemplateGraphicExtraLargeCircularOpenGaugeRangeText', 'CLKComplicationTemplateGraphicExtraLargeCircularOpenGaugeSimpleText', 'CLKComplicationTemplateGraphicExtraLargeCircularStackImage', 'CLKComplicationTemplateGraphicExtraLargeCircularStackText', 'CLKComplicationTemplateGraphicRectangularFullImage', 'CLKComplicationTemplateGraphicRectangularLargeImage', 'CLKComplicationTemplateGraphicRectangularStandardBody', 'CLKComplicationTemplateGraphicRectangularTextGauge', 'CLKComplicationTemplateModularLargeColumns', 'CLKComplicationTemplateModularLargeStandardBody', 'CLKComplicationTemplateModularLargeTable', 'CLKComplicationTemplateModularLargeTallBody', 'CLKComplicationTemplateModularSmallColumnsText', 'CLKComplicationTemplateModularSmallRingImage', 'CLKComplicationTemplateModularSmallRingText', 'CLKComplicationTemplateModularSmallSimpleImage', 'CLKComplicationTemplateModularSmallSimpleText', 'CLKComplicationTemplateModularSmallStackImage', 'CLKComplicationTemplateModularSmallStackText', 'CLKComplicationTemplateUtilitarianLargeFlat', 'CLKComplicationTemplateUtilitarianSmallFlat', 'CLKComplicationTemplateUtilitarianSmallRingImage', 'CLKComplicationTemplateUtilitarianSmallRingText', 'CLKComplicationTemplateUtilitarianSmallSquare', 'CLKComplicationTimelineEntry', 'CLKDateTextProvider', 'CLKFullColorImageProvider', 'CLKGaugeProvider', 'CLKImageProvider', 'CLKRelativeDateTextProvider', 'CLKSimpleGaugeProvider', 'CLKSimpleTextProvider', 'CLKTextProvider', 'CLKTimeIntervalGaugeProvider', 'CLKTimeIntervalTextProvider', 'CLKTimeTextProvider', 'CLKWatchFaceLibrary', 'CLLocation', 'CLLocationManager', 'CLPlacemark', 'CLRegion', 'CLSActivity', 'CLSActivityItem', 'CLSBinaryItem', 'CLSContext', 'CLSDataStore', 'CLSObject', 'CLSProgressReportingCapability', 'CLSQuantityItem', 'CLSScoreItem', 'CLVisit', 'CMAccelerometerData', 'CMAltimeter', 'CMAltitudeData', 'CMAttitude', 'CMDeviceMotion', 'CMDyskineticSymptomResult', 'CMFallDetectionEvent', 'CMFallDetectionManager', 'CMGyroData', 'CMHeadphoneMotionManager', 'CMLogItem', 'CMMagnetometerData', 'CMMotionActivity', 'CMMotionActivityManager', 'CMMotionManager', 'CMMovementDisorderManager', 'CMPedometer', 'CMPedometerData', 'CMPedometerEvent', 'CMRecordedAccelerometerData', 'CMRecordedRotationRateData', 'CMRotationRateData', 'CMSensorDataList', 'CMSensorRecorder', 'CMStepCounter', 'CMTremorResult', 'CNChangeHistoryAddContactEvent', 'CNChangeHistoryAddGroupEvent', 'CNChangeHistoryAddMemberToGroupEvent', 'CNChangeHistoryAddSubgroupToGroupEvent', 'CNChangeHistoryDeleteContactEvent', 'CNChangeHistoryDeleteGroupEvent', 'CNChangeHistoryDropEverythingEvent', 'CNChangeHistoryEvent', 'CNChangeHistoryFetchRequest', 'CNChangeHistoryRemoveMemberFromGroupEvent', 'CNChangeHistoryRemoveSubgroupFromGroupEvent', 'CNChangeHistoryUpdateContactEvent', 'CNChangeHistoryUpdateGroupEvent', 'CNContact', 'CNContactFetchRequest', 'CNContactFormatter', 'CNContactPickerViewController', 'CNContactProperty', 'CNContactRelation', 'CNContactStore', 'CNContactVCardSerialization', 'CNContactViewController', 'CNContactsUserDefaults', 'CNContainer', 'CNFetchRequest', 'CNFetchResult', 'CNGroup', 'CNInstantMessageAddress', 'CNLabeledValue', 'CNMutableContact', 'CNMutableGroup', 'CNMutablePostalAddress', 'CNPhoneNumber', 'CNPostalAddress', 'CNPostalAddressFormatter', 'CNSaveRequest', 'CNSocialProfile', 'CPActionSheetTemplate', 'CPAlertAction', 'CPAlertTemplate', 'CPBarButton', 'CPButton', 'CPContact', 'CPContactCallButton', 'CPContactDirectionsButton', 'CPContactMessageButton', 'CPContactTemplate', 'CPDashboardButton', 'CPDashboardController', 'CPGridButton', 'CPGridTemplate', 'CPImageSet', 'CPInformationItem', 'CPInformationRatingItem', 'CPInformationTemplate', 'CPInterfaceController', 'CPListImageRowItem', 'CPListItem', 'CPListSection', 'CPListTemplate', 'CPManeuver', 'CPMapButton', 'CPMapTemplate', 'CPMessageComposeBarButton', 'CPMessageListItem', 'CPMessageListItemLeadingConfiguration', 'CPMessageListItemTrailingConfiguration', 'CPNavigationAlert', 'CPNavigationSession', 'CPNowPlayingAddToLibraryButton', 'CPNowPlayingButton', 'CPNowPlayingImageButton', 'CPNowPlayingMoreButton', 'CPNowPlayingPlaybackRateButton', 'CPNowPlayingRepeatButton', 'CPNowPlayingShuffleButton', 'CPNowPlayingTemplate', 'CPPointOfInterest', 'CPPointOfInterestTemplate', 'CPRouteChoice', 'CPSearchTemplate', 'CPSessionConfiguration', 'CPTabBarTemplate', 'CPTemplate', 'CPTemplateApplicationDashboardScene', 'CPTemplateApplicationScene', 'CPTextButton', 'CPTravelEstimates', 'CPTrip', 'CPTripPreviewTextConfiguration', 'CPVoiceControlState', 'CPVoiceControlTemplate', 'CPWindow', 'CSCustomAttributeKey', 'CSIndexExtensionRequestHandler', 'CSLocalizedString', 'CSPerson', 'CSSearchQuery', 'CSSearchableIndex', 'CSSearchableItem', 'CSSearchableItemAttributeSet', 'CTCall', 'CTCallCenter', 'CTCarrier', 'CTCellularData', 'CTCellularPlanProvisioning', 'CTCellularPlanProvisioningRequest', 'CTSubscriber', 'CTSubscriberInfo', 'CTTelephonyNetworkInfo', 'CXAction', 'CXAnswerCallAction', 'CXCall', 'CXCallAction', 'CXCallController', 'CXCallDirectoryExtensionContext', 'CXCallDirectoryManager', 'CXCallDirectoryProvider', 'CXCallObserver', 'CXCallUpdate', 'CXEndCallAction', 'CXHandle', 'CXPlayDTMFCallAction', 'CXProvider', 'CXProviderConfiguration', 'CXSetGroupCallAction', 'CXSetHeldCallAction', 'CXSetMutedCallAction', 'CXStartCallAction', 'CXTransaction', 'DCAppAttestService', 'DCDevice', 'EAAccessory', 'EAAccessoryManager', 'EAGLContext', 'EAGLSharegroup', 'EASession', 'EAWiFiUnconfiguredAccessory', 'EAWiFiUnconfiguredAccessoryBrowser', 'EKAlarm', 'EKCalendar', 'EKCalendarChooser', 'EKCalendarItem', 'EKEvent', 'EKEventEditViewController', 'EKEventStore', 'EKEventViewController', 'EKObject', 'EKParticipant', 'EKRecurrenceDayOfWeek', 'EKRecurrenceEnd', 'EKRecurrenceRule', 'EKReminder', 'EKSource', 'EKStructuredLocation', 'ENExposureConfiguration', 'ENExposureDaySummary', 'ENExposureDetectionSummary', 'ENExposureInfo', 'ENExposureSummaryItem', 'ENExposureWindow', 'ENManager', 'ENScanInstance', 'ENTemporaryExposureKey', 'EntityRotationGestureRecognizer', 'EntityScaleGestureRecognizer', 'EntityTranslationGestureRecognizer', 'FPUIActionExtensionContext', 'FPUIActionExtensionViewController', 'GCColor', 'GCController', 'GCControllerAxisInput', 'GCControllerButtonInput', 'GCControllerDirectionPad', 'GCControllerElement', 'GCControllerTouchpad', 'GCDeviceBattery', 'GCDeviceCursor', 'GCDeviceHaptics', 'GCDeviceLight', 'GCDirectionalGamepad', 'GCDualShockGamepad', 'GCEventViewController', 'GCExtendedGamepad', 'GCExtendedGamepadSnapshot', 'GCGamepad', 'GCGamepadSnapshot', 'GCKeyboard', 'GCKeyboardInput', 'GCMicroGamepad', 'GCMicroGamepadSnapshot', 'GCMotion', 'GCMouse', 'GCMouseInput', 'GCPhysicalInputProfile', 'GCXboxGamepad', 'GKARC4RandomSource', 'GKAccessPoint', 'GKAchievement', 'GKAchievementChallenge', 'GKAchievementDescription', 'GKAchievementViewController', 'GKAgent', 'GKAgent2D', 'GKAgent3D', 'GKBasePlayer', 'GKBehavior', 'GKBillowNoiseSource', 'GKChallenge', 'GKChallengeEventHandler', 'GKCheckerboardNoiseSource', 'GKCircleObstacle', 'GKCloudPlayer', 'GKCoherentNoiseSource', 'GKComponent', 'GKComponentSystem', 'GKCompositeBehavior', 'GKConstantNoiseSource', 'GKCylindersNoiseSource', 'GKDecisionNode', 'GKDecisionTree', 'GKEntity', 'GKFriendRequestComposeViewController', 'GKGameCenterViewController', 'GKGameSession', 'GKGameSessionSharingViewController', 'GKGaussianDistribution', 'GKGoal', 'GKGraph', 'GKGraphNode', 'GKGraphNode2D', 'GKGraphNode3D', 'GKGridGraph', 'GKGridGraphNode', 'GKInvite', 'GKLeaderboard', 'GKLeaderboardEntry', 'GKLeaderboardScore', 'GKLeaderboardSet', 'GKLeaderboardViewController', 'GKLinearCongruentialRandomSource', 'GKLocalPlayer', 'GKMatch', 'GKMatchRequest', 'GKMatchmaker', 'GKMatchmakerViewController', 'GKMersenneTwisterRandomSource', 'GKMeshGraph', 'GKMinmaxStrategist', 'GKMonteCarloStrategist', 'GKNSPredicateRule', 'GKNoise', 'GKNoiseMap', 'GKNoiseSource', 'GKNotificationBanner', 'GKObstacle', 'GKObstacleGraph', 'GKOctree', 'GKOctreeNode', 'GKPath', 'GKPeerPickerController', 'GKPerlinNoiseSource', 'GKPlayer', 'GKPolygonObstacle', 'GKQuadtree', 'GKQuadtreeNode', 'GKRTree', 'GKRandomDistribution', 'GKRandomSource', 'GKRidgedNoiseSource', 'GKRule', 'GKRuleSystem', 'GKSCNNodeComponent', 'GKSKNodeComponent', 'GKSavedGame', 'GKScene', 'GKScore', 'GKScoreChallenge', 'GKSession', 'GKShuffledDistribution', 'GKSphereObstacle', 'GKSpheresNoiseSource', 'GKState', 'GKStateMachine', 'GKTurnBasedEventHandler', 'GKTurnBasedExchangeReply', 'GKTurnBasedMatch', 'GKTurnBasedMatchmakerViewController', 'GKTurnBasedParticipant', 'GKVoiceChat', 'GKVoiceChatService', 'GKVoronoiNoiseSource', 'GLKBaseEffect', 'GLKEffectProperty', 'GLKEffectPropertyFog', 'GLKEffectPropertyLight', 'GLKEffectPropertyMaterial', 'GLKEffectPropertyTexture', 'GLKEffectPropertyTransform', 'GLKMesh', 'GLKMeshBuffer', 'GLKMeshBufferAllocator', 'GLKReflectionMapEffect', 'GLKSkyboxEffect', 'GLKSubmesh', 'GLKTextureInfo', 'GLKTextureLoader', 'GLKView', 'GLKViewController', 'HKActivityMoveModeObject', 'HKActivityRingView', 'HKActivitySummary', 'HKActivitySummaryQuery', 'HKActivitySummaryType', 'HKAnchoredObjectQuery', 'HKAudiogramSample', 'HKAudiogramSampleType', 'HKAudiogramSensitivityPoint', 'HKBiologicalSexObject', 'HKBloodTypeObject', 'HKCDADocument', 'HKCDADocumentSample', 'HKCategorySample', 'HKCategoryType', 'HKCharacteristicType', 'HKClinicalRecord', 'HKClinicalType', 'HKCorrelation', 'HKCorrelationQuery', 'HKCorrelationType', 'HKCumulativeQuantitySample', 'HKCumulativeQuantitySeriesSample', 'HKDeletedObject', 'HKDevice', 'HKDiscreteQuantitySample', 'HKDocumentQuery', 'HKDocumentSample', 'HKDocumentType', 'HKElectrocardiogram', 'HKElectrocardiogramQuery', 'HKElectrocardiogramType', 'HKElectrocardiogramVoltageMeasurement', 'HKFHIRResource', 'HKFHIRVersion', 'HKFitzpatrickSkinTypeObject', 'HKHealthStore', 'HKHeartbeatSeriesBuilder', 'HKHeartbeatSeriesQuery', 'HKHeartbeatSeriesSample', 'HKLiveWorkoutBuilder', 'HKLiveWorkoutDataSource', 'HKObject', 'HKObjectType', 'HKObserverQuery', 'HKQuantity', 'HKQuantitySample', 'HKQuantitySeriesSampleBuilder', 'HKQuantitySeriesSampleQuery', 'HKQuantityType', 'HKQuery', 'HKQueryAnchor', 'HKSample', 'HKSampleQuery', 'HKSampleType', 'HKSeriesBuilder', 'HKSeriesSample', 'HKSeriesType', 'HKSource', 'HKSourceQuery', 'HKSourceRevision', 'HKStatistics', 'HKStatisticsCollection', 'HKStatisticsCollectionQuery', 'HKStatisticsQuery', 'HKUnit', 'HKWheelchairUseObject', 'HKWorkout', 'HKWorkoutBuilder', 'HKWorkoutConfiguration', 'HKWorkoutEvent', 'HKWorkoutRoute', 'HKWorkoutRouteBuilder', 'HKWorkoutRouteQuery', 'HKWorkoutSession', 'HKWorkoutType', 'HMAccessControl', 'HMAccessory', 'HMAccessoryBrowser', 'HMAccessoryCategory', 'HMAccessoryOwnershipToken', 'HMAccessoryProfile', 'HMAccessorySetupPayload', 'HMAction', 'HMActionSet', 'HMAddAccessoryRequest', 'HMCalendarEvent', 'HMCameraAudioControl', 'HMCameraControl', 'HMCameraProfile', 'HMCameraSettingsControl', 'HMCameraSnapshot', 'HMCameraSnapshotControl', 'HMCameraSource', 'HMCameraStream', 'HMCameraStreamControl', 'HMCameraView', 'HMCharacteristic', 'HMCharacteristicEvent', 'HMCharacteristicMetadata', 'HMCharacteristicThresholdRangeEvent', 'HMCharacteristicWriteAction', 'HMDurationEvent', 'HMEvent', 'HMEventTrigger', 'HMHome', 'HMHomeAccessControl', 'HMHomeManager', 'HMLocationEvent', 'HMMutableCalendarEvent', 'HMMutableCharacteristicEvent', 'HMMutableCharacteristicThresholdRangeEvent', 'HMMutableDurationEvent', 'HMMutableLocationEvent', 'HMMutablePresenceEvent', 'HMMutableSignificantTimeEvent', 'HMNetworkConfigurationProfile', 'HMNumberRange', 'HMPresenceEvent', 'HMRoom', 'HMService', 'HMServiceGroup', 'HMSignificantTimeEvent', 'HMTimeEvent', 'HMTimerTrigger', 'HMTrigger', 'HMUser', 'HMZone', 'ICCameraDevice', 'ICCameraFile', 'ICCameraFolder', 'ICCameraItem', 'ICDevice', 'ICDeviceBrowser', 'ICScannerBandData', 'ICScannerDevice', 'ICScannerFeature', 'ICScannerFeatureBoolean', 'ICScannerFeatureEnumeration', 'ICScannerFeatureRange', 'ICScannerFeatureTemplate', 'ICScannerFunctionalUnit', 'ICScannerFunctionalUnitDocumentFeeder', 'ICScannerFunctionalUnitFlatbed', 'ICScannerFunctionalUnitNegativeTransparency', 'ICScannerFunctionalUnitPositiveTransparency', 'ILCallClassificationRequest', 'ILCallCommunication', 'ILClassificationRequest', 'ILClassificationResponse', 'ILClassificationUIExtensionContext', 'ILClassificationUIExtensionViewController', 'ILCommunication', 'ILMessageClassificationRequest', 'ILMessageCommunication', 'ILMessageFilterExtension', 'ILMessageFilterExtensionContext', 'ILMessageFilterQueryRequest', 'ILMessageFilterQueryResponse', 'ILNetworkResponse', 'INAccountTypeResolutionResult', 'INActivateCarSignalIntent', 'INActivateCarSignalIntentResponse', 'INAddMediaIntent', 'INAddMediaIntentResponse', 'INAddMediaMediaDestinationResolutionResult', 'INAddMediaMediaItemResolutionResult', 'INAddTasksIntent', 'INAddTasksIntentResponse', 'INAddTasksTargetTaskListResolutionResult', 'INAddTasksTemporalEventTriggerResolutionResult', 'INAirline', 'INAirport', 'INAirportGate', 'INAppendToNoteIntent', 'INAppendToNoteIntentResponse', 'INBalanceAmount', 'INBalanceTypeResolutionResult', 'INBillDetails', 'INBillPayee', 'INBillPayeeResolutionResult', 'INBillTypeResolutionResult', 'INBoatReservation', 'INBoatTrip', 'INBookRestaurantReservationIntent', 'INBookRestaurantReservationIntentResponse', 'INBooleanResolutionResult', 'INBusReservation', 'INBusTrip', 'INCallCapabilityResolutionResult', 'INCallDestinationTypeResolutionResult', 'INCallRecord', 'INCallRecordFilter', 'INCallRecordResolutionResult', 'INCallRecordTypeOptionsResolutionResult', 'INCallRecordTypeResolutionResult', 'INCancelRideIntent', 'INCancelRideIntentResponse', 'INCancelWorkoutIntent', 'INCancelWorkoutIntentResponse', 'INCar', 'INCarAirCirculationModeResolutionResult', 'INCarAudioSourceResolutionResult', 'INCarDefrosterResolutionResult', 'INCarHeadUnit', 'INCarSeatResolutionResult', 'INCarSignalOptionsResolutionResult', 'INCreateNoteIntent', 'INCreateNoteIntentResponse', 'INCreateTaskListIntent', 'INCreateTaskListIntentResponse', 'INCurrencyAmount', 'INCurrencyAmountResolutionResult', 'INDailyRoutineRelevanceProvider', 'INDateComponentsRange', 'INDateComponentsRangeResolutionResult', 'INDateComponentsResolutionResult', 'INDateRelevanceProvider', 'INDateSearchTypeResolutionResult', 'INDefaultCardTemplate', 'INDeleteTasksIntent', 'INDeleteTasksIntentResponse', 'INDeleteTasksTaskListResolutionResult', 'INDeleteTasksTaskResolutionResult', 'INDoubleResolutionResult', 'INEndWorkoutIntent', 'INEndWorkoutIntentResponse', 'INEnergyResolutionResult', 'INEnumResolutionResult', 'INExtension', 'INFile', 'INFileResolutionResult', 'INFlight', 'INFlightReservation', 'INGetAvailableRestaurantReservationBookingDefaultsIntent', 'INGetAvailableRestaurantReservationBookingDefaultsIntentResponse', 'INGetAvailableRestaurantReservationBookingsIntent', 'INGetAvailableRestaurantReservationBookingsIntentResponse', 'INGetCarLockStatusIntent', 'INGetCarLockStatusIntentResponse', 'INGetCarPowerLevelStatusIntent', 'INGetCarPowerLevelStatusIntentResponse', 'INGetReservationDetailsIntent', 'INGetReservationDetailsIntentResponse', 'INGetRestaurantGuestIntent', 'INGetRestaurantGuestIntentResponse', 'INGetRideStatusIntent', 'INGetRideStatusIntentResponse', 'INGetUserCurrentRestaurantReservationBookingsIntent', 'INGetUserCurrentRestaurantReservationBookingsIntentResponse', 'INGetVisualCodeIntent', 'INGetVisualCodeIntentResponse', 'INImage', 'INImageNoteContent', 'INIntegerResolutionResult', 'INIntent', 'INIntentResolutionResult', 'INIntentResponse', 'INInteraction', 'INLengthResolutionResult', 'INListCarsIntent', 'INListCarsIntentResponse', 'INListRideOptionsIntent', 'INListRideOptionsIntentResponse', 'INLocationRelevanceProvider', 'INLocationSearchTypeResolutionResult', 'INLodgingReservation', 'INMassResolutionResult', 'INMediaAffinityTypeResolutionResult', 'INMediaDestination', 'INMediaDestinationResolutionResult', 'INMediaItem', 'INMediaItemResolutionResult', 'INMediaSearch', 'INMediaUserContext', 'INMessage', 'INMessageAttributeOptionsResolutionResult', 'INMessageAttributeResolutionResult', 'INNote', 'INNoteContent', 'INNoteContentResolutionResult', 'INNoteContentTypeResolutionResult', 'INNoteResolutionResult', 'INNotebookItemTypeResolutionResult', 'INObject', 'INObjectCollection', 'INObjectResolutionResult', 'INObjectSection', 'INOutgoingMessageTypeResolutionResult', 'INParameter', 'INPauseWorkoutIntent', 'INPauseWorkoutIntentResponse', 'INPayBillIntent', 'INPayBillIntentResponse', 'INPaymentAccount', 'INPaymentAccountResolutionResult', 'INPaymentAmount', 'INPaymentAmountResolutionResult', 'INPaymentMethod', 'INPaymentMethodResolutionResult', 'INPaymentRecord', 'INPaymentStatusResolutionResult', 'INPerson', 'INPersonHandle', 'INPersonResolutionResult', 'INPlacemarkResolutionResult', 'INPlayMediaIntent', 'INPlayMediaIntentResponse', 'INPlayMediaMediaItemResolutionResult', 'INPlayMediaPlaybackSpeedResolutionResult', 'INPlaybackQueueLocationResolutionResult', 'INPlaybackRepeatModeResolutionResult', 'INPreferences', 'INPriceRange', 'INRadioTypeResolutionResult', 'INRecurrenceRule', 'INRelativeReferenceResolutionResult', 'INRelativeSettingResolutionResult', 'INRelevanceProvider', 'INRelevantShortcut', 'INRelevantShortcutStore', 'INRentalCar', 'INRentalCarReservation', 'INRequestPaymentCurrencyAmountResolutionResult', 'INRequestPaymentIntent', 'INRequestPaymentIntentResponse', 'INRequestPaymentPayerResolutionResult', 'INRequestRideIntent', 'INRequestRideIntentResponse', 'INReservation', 'INReservationAction', 'INRestaurant', 'INRestaurantGuest', 'INRestaurantGuestDisplayPreferences', 'INRestaurantGuestResolutionResult', 'INRestaurantOffer', 'INRestaurantReservation', 'INRestaurantReservationBooking', 'INRestaurantReservationUserBooking', 'INRestaurantResolutionResult', 'INResumeWorkoutIntent', 'INResumeWorkoutIntentResponse', 'INRideCompletionStatus', 'INRideDriver', 'INRideFareLineItem', 'INRideOption', 'INRidePartySizeOption', 'INRideStatus', 'INRideVehicle', 'INSaveProfileInCarIntent', 'INSaveProfileInCarIntentResponse', 'INSearchCallHistoryIntent', 'INSearchCallHistoryIntentResponse', 'INSearchForAccountsIntent', 'INSearchForAccountsIntentResponse', 'INSearchForBillsIntent', 'INSearchForBillsIntentResponse', 'INSearchForMediaIntent', 'INSearchForMediaIntentResponse', 'INSearchForMediaMediaItemResolutionResult', 'INSearchForMessagesIntent', 'INSearchForMessagesIntentResponse', 'INSearchForNotebookItemsIntent', 'INSearchForNotebookItemsIntentResponse', 'INSearchForPhotosIntent', 'INSearchForPhotosIntentResponse', 'INSeat', 'INSendMessageAttachment', 'INSendMessageIntent', 'INSendMessageIntentResponse', 'INSendMessageRecipientResolutionResult', 'INSendPaymentCurrencyAmountResolutionResult', 'INSendPaymentIntent', 'INSendPaymentIntentResponse', 'INSendPaymentPayeeResolutionResult', 'INSendRideFeedbackIntent', 'INSendRideFeedbackIntentResponse', 'INSetAudioSourceInCarIntent', 'INSetAudioSourceInCarIntentResponse', 'INSetCarLockStatusIntent', 'INSetCarLockStatusIntentResponse', 'INSetClimateSettingsInCarIntent', 'INSetClimateSettingsInCarIntentResponse', 'INSetDefrosterSettingsInCarIntent', 'INSetDefrosterSettingsInCarIntentResponse', 'INSetMessageAttributeIntent', 'INSetMessageAttributeIntentResponse', 'INSetProfileInCarIntent', 'INSetProfileInCarIntentResponse', 'INSetRadioStationIntent', 'INSetRadioStationIntentResponse', 'INSetSeatSettingsInCarIntent', 'INSetSeatSettingsInCarIntentResponse', 'INSetTaskAttributeIntent', 'INSetTaskAttributeIntentResponse', 'INSetTaskAttributeTemporalEventTriggerResolutionResult', 'INShortcut', 'INSnoozeTasksIntent', 'INSnoozeTasksIntentResponse', 'INSnoozeTasksTaskResolutionResult', 'INSpatialEventTrigger', 'INSpatialEventTriggerResolutionResult', 'INSpeakableString', 'INSpeakableStringResolutionResult', 'INSpeedResolutionResult', 'INStartAudioCallIntent', 'INStartAudioCallIntentResponse', 'INStartCallCallCapabilityResolutionResult', 'INStartCallCallRecordToCallBackResolutionResult', 'INStartCallContactResolutionResult', 'INStartCallIntent', 'INStartCallIntentResponse', 'INStartPhotoPlaybackIntent', 'INStartPhotoPlaybackIntentResponse', 'INStartVideoCallIntent', 'INStartVideoCallIntentResponse', 'INStartWorkoutIntent', 'INStartWorkoutIntentResponse', 'INStringResolutionResult', 'INTask', 'INTaskList', 'INTaskListResolutionResult', 'INTaskPriorityResolutionResult', 'INTaskResolutionResult', 'INTaskStatusResolutionResult', 'INTemperatureResolutionResult', 'INTemporalEventTrigger', 'INTemporalEventTriggerResolutionResult', 'INTemporalEventTriggerTypeOptionsResolutionResult', 'INTermsAndConditions', 'INTextNoteContent', 'INTicketedEvent', 'INTicketedEventReservation', 'INTimeIntervalResolutionResult', 'INTrainReservation', 'INTrainTrip', 'INTransferMoneyIntent', 'INTransferMoneyIntentResponse', 'INUIAddVoiceShortcutButton', 'INUIAddVoiceShortcutViewController', 'INUIEditVoiceShortcutViewController', 'INURLResolutionResult', 'INUpcomingMediaManager', 'INUpdateMediaAffinityIntent', 'INUpdateMediaAffinityIntentResponse', 'INUpdateMediaAffinityMediaItemResolutionResult', 'INUserContext', 'INVisualCodeTypeResolutionResult', 'INVocabulary', 'INVoiceShortcut', 'INVoiceShortcutCenter', 'INVolumeResolutionResult', 'INWorkoutGoalUnitTypeResolutionResult', 'INWorkoutLocationTypeResolutionResult', 'IOSurface', 'JSContext', 'JSManagedValue', 'JSValue', 'JSVirtualMachine', 'LAContext', 'LPLinkMetadata', 'LPLinkView', 'LPMetadataProvider', 'MCAdvertiserAssistant', 'MCBrowserViewController', 'MCNearbyServiceAdvertiser', 'MCNearbyServiceBrowser', 'MCPeerID', 'MCSession', 'MDLAnimatedMatrix4x4', 'MDLAnimatedQuaternion', 'MDLAnimatedQuaternionArray', 'MDLAnimatedScalar', 'MDLAnimatedScalarArray', 'MDLAnimatedValue', 'MDLAnimatedVector2', 'MDLAnimatedVector3', 'MDLAnimatedVector3Array', 'MDLAnimatedVector4', 'MDLAnimationBindComponent', 'MDLAreaLight', 'MDLAsset', 'MDLBundleAssetResolver', 'MDLCamera', 'MDLCheckerboardTexture', 'MDLColorSwatchTexture', 'MDLLight', 'MDLLightProbe', 'MDLMaterial', 'MDLMaterialProperty', 'MDLMaterialPropertyConnection', 'MDLMaterialPropertyGraph', 'MDLMaterialPropertyNode', 'MDLMatrix4x4Array', 'MDLMesh', 'MDLMeshBufferData', 'MDLMeshBufferDataAllocator', 'MDLMeshBufferMap', 'MDLMeshBufferZoneDefault', 'MDLNoiseTexture', 'MDLNormalMapTexture', 'MDLObject', 'MDLObjectContainer', 'MDLPackedJointAnimation', 'MDLPathAssetResolver', 'MDLPhotometricLight', 'MDLPhysicallyPlausibleLight', 'MDLPhysicallyPlausibleScatteringFunction', 'MDLRelativeAssetResolver', 'MDLScatteringFunction', 'MDLSkeleton', 'MDLSkyCubeTexture', 'MDLStereoscopicCamera', 'MDLSubmesh', 'MDLSubmeshTopology', 'MDLTexture', 'MDLTextureFilter', 'MDLTextureSampler', 'MDLTransform', 'MDLTransformMatrixOp', 'MDLTransformOrientOp', 'MDLTransformRotateOp', 'MDLTransformRotateXOp', 'MDLTransformRotateYOp', 'MDLTransformRotateZOp', 'MDLTransformScaleOp', 'MDLTransformStack', 'MDLTransformTranslateOp', 'MDLURLTexture', 'MDLVertexAttribute', 'MDLVertexAttributeData', 'MDLVertexBufferLayout', 'MDLVertexDescriptor', 'MDLVoxelArray', 'MFMailComposeViewController', 'MFMessageComposeViewController', 'MIDICIDeviceInfo', 'MIDICIDiscoveredNode', 'MIDICIDiscoveryManager', 'MIDICIProfile', 'MIDICIProfileState', 'MIDICIResponder', 'MIDICISession', 'MIDINetworkConnection', 'MIDINetworkHost', 'MIDINetworkSession', 'MKAnnotationView', 'MKCircle', 'MKCircleRenderer', 'MKCircleView', 'MKClusterAnnotation', 'MKCompassButton', 'MKDirections', 'MKDirectionsRequest', 'MKDirectionsResponse', 'MKDistanceFormatter', 'MKETAResponse', 'MKGeoJSONDecoder', 'MKGeoJSONFeature', 'MKGeodesicPolyline', 'MKGradientPolylineRenderer', 'MKLocalPointsOfInterestRequest', 'MKLocalSearch', 'MKLocalSearchCompleter', 'MKLocalSearchCompletion', 'MKLocalSearchRequest', 'MKLocalSearchResponse', 'MKMapCamera', 'MKMapCameraBoundary', 'MKMapCameraZoomRange', 'MKMapItem', 'MKMapSnapshot', 'MKMapSnapshotOptions', 'MKMapSnapshotter', 'MKMapView', 'MKMarkerAnnotationView', 'MKMultiPoint', 'MKMultiPolygon', 'MKMultiPolygonRenderer', 'MKMultiPolyline', 'MKMultiPolylineRenderer', 'MKOverlayPathRenderer', 'MKOverlayPathView', 'MKOverlayRenderer', 'MKOverlayView', 'MKPinAnnotationView', 'MKPitchControl', 'MKPlacemark', 'MKPointAnnotation', 'MKPointOfInterestFilter', 'MKPolygon', 'MKPolygonRenderer', 'MKPolygonView', 'MKPolyline', 'MKPolylineRenderer', 'MKPolylineView', 'MKReverseGeocoder', 'MKRoute', 'MKRouteStep', 'MKScaleView', 'MKShape', 'MKTileOverlay', 'MKTileOverlayRenderer', 'MKUserLocation', 'MKUserLocationView', 'MKUserTrackingBarButtonItem', 'MKUserTrackingButton', 'MKZoomControl', 'MLArrayBatchProvider', 'MLCActivationDescriptor', 'MLCActivationLayer', 'MLCArithmeticLayer', 'MLCBatchNormalizationLayer', 'MLCConcatenationLayer', 'MLCConvolutionDescriptor', 'MLCConvolutionLayer', 'MLCDevice', 'MLCDropoutLayer', 'MLCEmbeddingDescriptor', 'MLCEmbeddingLayer', 'MLCFullyConnectedLayer', 'MLCGramMatrixLayer', 'MLCGraph', 'MLCGroupNormalizationLayer', 'MLCInferenceGraph', 'MLCInstanceNormalizationLayer', 'MLCLSTMDescriptor', 'MLCLSTMLayer', 'MLCLayer', 'MLCLayerNormalizationLayer', 'MLCLossDescriptor', 'MLCLossLayer', 'MLCMatMulDescriptor', 'MLCMatMulLayer', 'MLCMultiheadAttentionDescriptor', 'MLCMultiheadAttentionLayer', 'MLCPaddingLayer', 'MLCPoolingDescriptor', 'MLCPoolingLayer', 'MLCReductionLayer', 'MLCReshapeLayer', 'MLCSliceLayer', 'MLCSoftmaxLayer', 'MLCSplitLayer', 'MLCTensor', 'MLCTensorData', 'MLCTensorDescriptor', 'MLCTensorOptimizerDeviceData', 'MLCTensorParameter', 'MLCTrainingGraph', 'MLCTransposeLayer', 'MLCUpsampleLayer', 'MLCYOLOLossDescriptor', 'MLCYOLOLossLayer', 'MLDictionaryConstraint', 'MLDictionaryFeatureProvider', 'MLFeatureDescription', 'MLFeatureValue', 'MLImageConstraint', 'MLImageSize', 'MLImageSizeConstraint', 'MLKey', 'MLMetricKey', 'MLModel', 'MLModelCollection', 'MLModelCollectionEntry', 'MLModelConfiguration', 'MLModelDescription', 'MLMultiArray', 'MLMultiArrayConstraint', 'MLMultiArrayShapeConstraint', 'MLNumericConstraint', 'MLParameterDescription', 'MLParameterKey', 'MLPredictionOptions', 'MLSequence', 'MLSequenceConstraint', 'MLTask', 'MLUpdateContext', 'MLUpdateProgressHandlers', 'MLUpdateTask', 'MPChangeLanguageOptionCommandEvent', 'MPChangePlaybackPositionCommand', 'MPChangePlaybackPositionCommandEvent', 'MPChangePlaybackRateCommand', 'MPChangePlaybackRateCommandEvent', 'MPChangeRepeatModeCommand', 'MPChangeRepeatModeCommandEvent', 'MPChangeShuffleModeCommand', 'MPChangeShuffleModeCommandEvent', 'MPContentItem', 'MPFeedbackCommand', 'MPFeedbackCommandEvent', 'MPMediaEntity', 'MPMediaItem', 'MPMediaItemArtwork', 'MPMediaItemCollection', 'MPMediaLibrary', 'MPMediaPickerController', 'MPMediaPlaylist', 'MPMediaPlaylistCreationMetadata', 'MPMediaPredicate', 'MPMediaPropertyPredicate', 'MPMediaQuery', 'MPMediaQuerySection', 'MPMovieAccessLog', 'MPMovieAccessLogEvent', 'MPMovieErrorLog', 'MPMovieErrorLogEvent', 'MPMoviePlayerController', 'MPMoviePlayerViewController', 'MPMusicPlayerApplicationController', 'MPMusicPlayerController', 'MPMusicPlayerControllerMutableQueue', 'MPMusicPlayerControllerQueue', 'MPMusicPlayerMediaItemQueueDescriptor', 'MPMusicPlayerPlayParameters', 'MPMusicPlayerPlayParametersQueueDescriptor', 'MPMusicPlayerQueueDescriptor', 'MPMusicPlayerStoreQueueDescriptor', 'MPNowPlayingInfoCenter', 'MPNowPlayingInfoLanguageOption', 'MPNowPlayingInfoLanguageOptionGroup', 'MPNowPlayingSession', 'MPPlayableContentManager', 'MPPlayableContentManagerContext', 'MPRatingCommand', 'MPRatingCommandEvent', 'MPRemoteCommand', 'MPRemoteCommandCenter', 'MPRemoteCommandEvent', 'MPSGraph', 'MPSGraphConvolution2DOpDescriptor', 'MPSGraphDepthwiseConvolution2DOpDescriptor', 'MPSGraphDevice', 'MPSGraphExecutionDescriptor', 'MPSGraphOperation', 'MPSGraphPooling2DOpDescriptor', 'MPSGraphShapedType', 'MPSGraphTensor', 'MPSGraphTensorData', 'MPSGraphVariableOp', 'MPSeekCommandEvent', 'MPSkipIntervalCommand', 'MPSkipIntervalCommandEvent', 'MPTimedMetadata', 'MPVolumeView', 'MSConversation', 'MSMessage', 'MSMessageLayout', 'MSMessageLiveLayout', 'MSMessageTemplateLayout', 'MSMessagesAppViewController', 'MSServiceAccount', 'MSSession', 'MSSetupSession', 'MSSticker', 'MSStickerBrowserView', 'MSStickerBrowserViewController', 'MSStickerView', 'MTKMesh', 'MTKMeshBuffer', 'MTKMeshBufferAllocator', 'MTKSubmesh', 'MTKTextureLoader', 'MTKView', 'MTLAccelerationStructureBoundingBoxGeometryDescriptor', 'MTLAccelerationStructureDescriptor', 'MTLAccelerationStructureGeometryDescriptor', 'MTLAccelerationStructureTriangleGeometryDescriptor', 'MTLArgument', 'MTLArgumentDescriptor', 'MTLArrayType', 'MTLAttribute', 'MTLAttributeDescriptor', 'MTLAttributeDescriptorArray', 'MTLBinaryArchiveDescriptor', 'MTLBlitPassDescriptor', 'MTLBlitPassSampleBufferAttachmentDescriptor', 'MTLBlitPassSampleBufferAttachmentDescriptorArray', 'MTLBufferLayoutDescriptor', 'MTLBufferLayoutDescriptorArray', 'MTLCaptureDescriptor', 'MTLCaptureManager', 'MTLCommandBufferDescriptor', 'MTLCompileOptions', 'MTLComputePassDescriptor', 'MTLComputePassSampleBufferAttachmentDescriptor', 'MTLComputePassSampleBufferAttachmentDescriptorArray', 'MTLComputePipelineDescriptor', 'MTLComputePipelineReflection', 'MTLCounterSampleBufferDescriptor', 'MTLDepthStencilDescriptor', 'MTLFunctionConstant', 'MTLFunctionConstantValues', 'MTLFunctionDescriptor', 'MTLHeapDescriptor', 'MTLIndirectCommandBufferDescriptor', 'MTLInstanceAccelerationStructureDescriptor', 'MTLIntersectionFunctionDescriptor', 'MTLIntersectionFunctionTableDescriptor', 'MTLLinkedFunctions', 'MTLPipelineBufferDescriptor', 'MTLPipelineBufferDescriptorArray', 'MTLPointerType', 'MTLPrimitiveAccelerationStructureDescriptor', 'MTLRasterizationRateLayerArray', 'MTLRasterizationRateLayerDescriptor', 'MTLRasterizationRateMapDescriptor', 'MTLRasterizationRateSampleArray', 'MTLRenderPassAttachmentDescriptor', 'MTLRenderPassColorAttachmentDescriptor', 'MTLRenderPassColorAttachmentDescriptorArray', 'MTLRenderPassDepthAttachmentDescriptor', 'MTLRenderPassDescriptor', 'MTLRenderPassSampleBufferAttachmentDescriptor', 'MTLRenderPassSampleBufferAttachmentDescriptorArray', 'MTLRenderPassStencilAttachmentDescriptor', 'MTLRenderPipelineColorAttachmentDescriptor', 'MTLRenderPipelineColorAttachmentDescriptorArray', 'MTLRenderPipelineDescriptor', 'MTLRenderPipelineReflection', 'MTLResourceStatePassDescriptor', 'MTLResourceStatePassSampleBufferAttachmentDescriptor', 'MTLResourceStatePassSampleBufferAttachmentDescriptorArray', 'MTLSamplerDescriptor', 'MTLSharedEventHandle', 'MTLSharedEventListener', 'MTLSharedTextureHandle', 'MTLStageInputOutputDescriptor', 'MTLStencilDescriptor', 'MTLStructMember', 'MTLStructType', 'MTLTextureDescriptor', 'MTLTextureReferenceType', 'MTLTileRenderPipelineColorAttachmentDescriptor', 'MTLTileRenderPipelineColorAttachmentDescriptorArray', 'MTLTileRenderPipelineDescriptor', 'MTLType', 'MTLVertexAttribute', 'MTLVertexAttributeDescriptor', 'MTLVertexAttributeDescriptorArray', 'MTLVertexBufferLayoutDescriptor', 'MTLVertexBufferLayoutDescriptorArray', 'MTLVertexDescriptor', 'MTLVisibleFunctionTableDescriptor', 'MXAnimationMetric', 'MXAppExitMetric', 'MXAppLaunchMetric', 'MXAppResponsivenessMetric', 'MXAppRunTimeMetric', 'MXAverage', 'MXBackgroundExitData', 'MXCPUExceptionDiagnostic', 'MXCPUMetric', 'MXCallStackTree', 'MXCellularConditionMetric', 'MXCrashDiagnostic', 'MXDiagnostic', 'MXDiagnosticPayload', 'MXDiskIOMetric', 'MXDiskWriteExceptionDiagnostic', 'MXDisplayMetric', 'MXForegroundExitData', 'MXGPUMetric', 'MXHangDiagnostic', 'MXHistogram', 'MXHistogramBucket', 'MXLocationActivityMetric', 'MXMemoryMetric', 'MXMetaData', 'MXMetric', 'MXMetricManager', 'MXMetricPayload', 'MXNetworkTransferMetric', 'MXSignpostIntervalData', 'MXSignpostMetric', 'MXUnitAveragePixelLuminance', 'MXUnitSignalBars', 'MyClass', 'NCWidgetController', 'NEAppProxyFlow', 'NEAppProxyProvider', 'NEAppProxyProviderManager', 'NEAppProxyTCPFlow', 'NEAppProxyUDPFlow', 'NEAppPushManager', 'NEAppPushProvider', 'NEAppRule', 'NEDNSOverHTTPSSettings', 'NEDNSOverTLSSettings', 'NEDNSProxyManager', 'NEDNSProxyProvider', 'NEDNSProxyProviderProtocol', 'NEDNSSettings', 'NEDNSSettingsManager', 'NEEvaluateConnectionRule', 'NEFilterBrowserFlow', 'NEFilterControlProvider', 'NEFilterControlVerdict', 'NEFilterDataProvider', 'NEFilterDataVerdict', 'NEFilterFlow', 'NEFilterManager', 'NEFilterNewFlowVerdict', 'NEFilterPacketContext', 'NEFilterPacketProvider', 'NEFilterProvider', 'NEFilterProviderConfiguration', 'NEFilterRemediationVerdict', 'NEFilterReport', 'NEFilterRule', 'NEFilterSettings', 'NEFilterSocketFlow', 'NEFilterVerdict', 'NEFlowMetaData', 'NEHotspotConfiguration', 'NEHotspotConfigurationManager', 'NEHotspotEAPSettings', 'NEHotspotHS20Settings', 'NEHotspotHelper', 'NEHotspotHelperCommand', 'NEHotspotHelperResponse', 'NEHotspotNetwork', 'NEIPv4Route', 'NEIPv4Settings', 'NEIPv6Route', 'NEIPv6Settings', 'NENetworkRule', 'NEOnDemandRule', 'NEOnDemandRuleConnect', 'NEOnDemandRuleDisconnect', 'NEOnDemandRuleEvaluateConnection', 'NEOnDemandRuleIgnore', 'NEPacket', 'NEPacketTunnelFlow', 'NEPacketTunnelNetworkSettings', 'NEPacketTunnelProvider', 'NEProvider', 'NEProxyServer', 'NEProxySettings', 'NETransparentProxyManager', 'NETransparentProxyNetworkSettings', 'NETransparentProxyProvider', 'NETunnelNetworkSettings', 'NETunnelProvider', 'NETunnelProviderManager', 'NETunnelProviderProtocol', 'NETunnelProviderSession', 'NEVPNConnection', 'NEVPNIKEv2SecurityAssociationParameters', 'NEVPNManager', 'NEVPNProtocol', 'NEVPNProtocolIKEv2', 'NEVPNProtocolIPSec', 'NFCISO15693CustomCommandConfiguration', 'NFCISO15693ReadMultipleBlocksConfiguration', 'NFCISO15693ReaderSession', 'NFCISO7816APDU', 'NFCNDEFMessage', 'NFCNDEFPayload', 'NFCNDEFReaderSession', 'NFCReaderSession', 'NFCTagCommandConfiguration', 'NFCTagReaderSession', 'NFCVASCommandConfiguration', 'NFCVASReaderSession', 'NFCVASResponse', 'NIConfiguration', 'NIDiscoveryToken', 'NINearbyObject', 'NINearbyPeerConfiguration', 'NISession', 'NKAssetDownload', 'NKIssue', 'NKLibrary', 'NLEmbedding', 'NLGazetteer', 'NLLanguageRecognizer', 'NLModel', 'NLModelConfiguration', 'NLTagger', 'NLTokenizer', 'NSArray', 'NSAssertionHandler', 'NSAsynchronousFetchRequest', 'NSAsynchronousFetchResult', 'NSAtomicStore', 'NSAtomicStoreCacheNode', 'NSAttributeDescription', 'NSAttributedString', 'NSAutoreleasePool', 'NSBatchDeleteRequest', 'NSBatchDeleteResult', 'NSBatchInsertRequest', 'NSBatchInsertResult', 'NSBatchUpdateRequest', 'NSBatchUpdateResult', 'NSBlockOperation', 'NSBundle', 'NSBundleResourceRequest', 'NSByteCountFormatter', 'NSCache', 'NSCachedURLResponse', 'NSCalendar', 'NSCharacterSet', 'NSCoder', 'NSCollectionLayoutAnchor', 'NSCollectionLayoutBoundarySupplementaryItem', 'NSCollectionLayoutDecorationItem', 'NSCollectionLayoutDimension', 'NSCollectionLayoutEdgeSpacing', 'NSCollectionLayoutGroup', 'NSCollectionLayoutGroupCustomItem', 'NSCollectionLayoutItem', 'NSCollectionLayoutSection', 'NSCollectionLayoutSize', 'NSCollectionLayoutSpacing', 'NSCollectionLayoutSupplementaryItem', 'NSComparisonPredicate', 'NSCompoundPredicate', 'NSCondition', 'NSConditionLock', 'NSConstantString', 'NSConstraintConflict', 'NSCoreDataCoreSpotlightDelegate', 'NSCountedSet', 'NSData', 'NSDataAsset', 'NSDataDetector', 'NSDate', 'NSDateComponents', 'NSDateComponentsFormatter', 'NSDateFormatter', 'NSDateInterval', 'NSDateIntervalFormatter', 'NSDecimalNumber', 'NSDecimalNumberHandler', 'NSDerivedAttributeDescription', 'NSDictionary', 'NSDiffableDataSourceSectionSnapshot', 'NSDiffableDataSourceSectionTransaction', 'NSDiffableDataSourceSnapshot', 'NSDiffableDataSourceTransaction', 'NSDimension', 'NSDirectoryEnumerator', 'NSEnergyFormatter', 'NSEntityDescription', 'NSEntityMapping', 'NSEntityMigrationPolicy', 'NSEnumerator', 'NSError', 'NSEvent', 'NSException', 'NSExpression', 'NSExpressionDescription', 'NSExtensionContext', 'NSExtensionItem', 'NSFetchIndexDescription', 'NSFetchIndexElementDescription', 'NSFetchRequest', 'NSFetchRequestExpression', 'NSFetchedPropertyDescription', 'NSFetchedResultsController', 'NSFileAccessIntent', 'NSFileCoordinator', 'NSFileHandle', 'NSFileManager', 'NSFileProviderDomain', 'NSFileProviderExtension', 'NSFileProviderManager', 'NSFileProviderService', 'NSFileSecurity', 'NSFileVersion', 'NSFileWrapper', 'NSFormatter', 'NSHTTPCookie', 'NSHTTPCookieStorage', 'NSHTTPURLResponse', 'NSHashTable', 'NSISO8601DateFormatter', 'NSIncrementalStore', 'NSIncrementalStoreNode', 'NSIndexPath', 'NSIndexSet', 'NSInputStream', 'NSInvocation', 'NSInvocationOperation', 'NSItemProvider', 'NSJSONSerialization', 'NSKeyedArchiver', 'NSKeyedUnarchiver', 'NSLayoutAnchor', 'NSLayoutConstraint', 'NSLayoutDimension', 'NSLayoutManager', 'NSLayoutXAxisAnchor', 'NSLayoutYAxisAnchor', 'NSLengthFormatter', 'NSLinguisticTagger', 'NSListFormatter', 'NSLocale', 'NSLock', 'NSMachPort', 'NSManagedObject', 'NSManagedObjectContext', 'NSManagedObjectID', 'NSManagedObjectModel', 'NSMapTable', 'NSMappingModel', 'NSMassFormatter', 'NSMeasurement', 'NSMeasurementFormatter', 'NSMenuToolbarItem', 'NSMergeConflict', 'NSMergePolicy', 'NSMessagePort', 'NSMetadataItem', 'NSMetadataQuery', 'NSMetadataQueryAttributeValueTuple', 'NSMetadataQueryResultGroup', 'NSMethodSignature', 'NSMigrationManager', 'NSMutableArray', 'NSMutableAttributedString', 'NSMutableCharacterSet', 'NSMutableData', 'NSMutableDictionary', 'NSMutableIndexSet', 'NSMutableOrderedSet', 'NSMutableParagraphStyle', 'NSMutableSet', 'NSMutableString', 'NSMutableURLRequest', 'NSNetService', 'NSNetServiceBrowser', 'NSNotification', 'NSNotificationCenter', 'NSNotificationQueue', 'NSNull', 'NSNumber', 'NSNumberFormatter', 'NSObject', 'NSOperation', 'NSOperationQueue', 'NSOrderedCollectionChange', 'NSOrderedCollectionDifference', 'NSOrderedSet', 'NSOrthography', 'NSOutputStream', 'NSParagraphStyle', 'NSPersistentCloudKitContainer', 'NSPersistentCloudKitContainerEvent', 'NSPersistentCloudKitContainerEventRequest', 'NSPersistentCloudKitContainerEventResult', 'NSPersistentCloudKitContainerOptions', 'NSPersistentContainer', 'NSPersistentHistoryChange', 'NSPersistentHistoryChangeRequest', 'NSPersistentHistoryResult', 'NSPersistentHistoryToken', 'NSPersistentHistoryTransaction', 'NSPersistentStore', 'NSPersistentStoreAsynchronousResult', 'NSPersistentStoreCoordinator', 'NSPersistentStoreDescription', 'NSPersistentStoreRequest', 'NSPersistentStoreResult', 'NSPersonNameComponents', 'NSPersonNameComponentsFormatter', 'NSPipe', 'NSPointerArray', 'NSPointerFunctions', 'NSPort', 'NSPredicate', 'NSProcessInfo', 'NSProgress', 'NSPropertyDescription', 'NSPropertyListSerialization', 'NSPropertyMapping', 'NSProxy', 'NSPurgeableData', 'NSQueryGenerationToken', 'NSRecursiveLock', 'NSRegularExpression', 'NSRelationshipDescription', 'NSRelativeDateTimeFormatter', 'NSRunLoop', 'NSSaveChangesRequest', 'NSScanner', 'NSSecureUnarchiveFromDataTransformer', 'NSSet', 'NSShadow', 'NSSharingServicePickerToolbarItem', 'NSSharingServicePickerTouchBarItem', 'NSSimpleCString', 'NSSocketPort', 'NSSortDescriptor', 'NSStream', 'NSString', 'NSStringDrawingContext', 'NSTextAttachment', 'NSTextCheckingResult', 'NSTextContainer', 'NSTextStorage', 'NSTextTab', 'NSThread', 'NSTimeZone', 'NSTimer', 'NSToolbarItem', 'NSURL', 'NSURLAuthenticationChallenge', 'NSURLCache', 'NSURLComponents', 'NSURLConnection', 'NSURLCredential', 'NSURLCredentialStorage', 'NSURLProtectionSpace', 'NSURLProtocol', 'NSURLQueryItem', 'NSURLRequest', 'NSURLResponse', 'NSURLSession', 'NSURLSessionConfiguration', 'NSURLSessionDataTask', 'NSURLSessionDownloadTask', 'NSURLSessionStreamTask', 'NSURLSessionTask', 'NSURLSessionTaskMetrics', 'NSURLSessionTaskTransactionMetrics', 'NSURLSessionUploadTask', 'NSURLSessionWebSocketMessage', 'NSURLSessionWebSocketTask', 'NSUUID', 'NSUbiquitousKeyValueStore', 'NSUndoManager', 'NSUnit', 'NSUnitAcceleration', 'NSUnitAngle', 'NSUnitArea', 'NSUnitConcentrationMass', 'NSUnitConverter', 'NSUnitConverterLinear', 'NSUnitDispersion', 'NSUnitDuration', 'NSUnitElectricCharge', 'NSUnitElectricCurrent', 'NSUnitElectricPotentialDifference', 'NSUnitElectricResistance', 'NSUnitEnergy', 'NSUnitFrequency', 'NSUnitFuelEfficiency', 'NSUnitIlluminance', 'NSUnitInformationStorage', 'NSUnitLength', 'NSUnitMass', 'NSUnitPower', 'NSUnitPressure', 'NSUnitSpeed', 'NSUnitTemperature', 'NSUnitVolume', 'NSUserActivity', 'NSUserDefaults', 'NSValue', 'NSValueTransformer', 'NSXMLParser', 'NSXPCCoder', 'NSXPCConnection', 'NSXPCInterface', 'NSXPCListener', 'NSXPCListenerEndpoint', 'NWBonjourServiceEndpoint', 'NWEndpoint', 'NWHostEndpoint', 'NWPath', 'NWTCPConnection', 'NWTLSParameters', 'NWUDPSession', 'OSLogEntry', 'OSLogEntryActivity', 'OSLogEntryBoundary', 'OSLogEntryLog', 'OSLogEntrySignpost', 'OSLogEnumerator', 'OSLogMessageComponent', 'OSLogPosition', 'OSLogStore', 'PDFAction', 'PDFActionGoTo', 'PDFActionNamed', 'PDFActionRemoteGoTo', 'PDFActionResetForm', 'PDFActionURL', 'PDFAnnotation', 'PDFAppearanceCharacteristics', 'PDFBorder', 'PDFDestination', 'PDFDocument', 'PDFOutline', 'PDFPage', 'PDFSelection', 'PDFThumbnailView', 'PDFView', 'PHAdjustmentData', 'PHAsset', 'PHAssetChangeRequest', 'PHAssetCollection', 'PHAssetCollectionChangeRequest', 'PHAssetCreationRequest', 'PHAssetResource', 'PHAssetResourceCreationOptions', 'PHAssetResourceManager', 'PHAssetResourceRequestOptions', 'PHCachingImageManager', 'PHChange', 'PHChangeRequest', 'PHCloudIdentifier', 'PHCollection', 'PHCollectionList', 'PHCollectionListChangeRequest', 'PHContentEditingInput', 'PHContentEditingInputRequestOptions', 'PHContentEditingOutput', 'PHEditingExtensionContext', 'PHFetchOptions', 'PHFetchResult', 'PHFetchResultChangeDetails', 'PHImageManager', 'PHImageRequestOptions', 'PHLivePhoto', 'PHLivePhotoEditingContext', 'PHLivePhotoRequestOptions', 'PHLivePhotoView', 'PHObject', 'PHObjectChangeDetails', 'PHObjectPlaceholder', 'PHPhotoLibrary', 'PHPickerConfiguration', 'PHPickerFilter', 'PHPickerResult', 'PHPickerViewController', 'PHProject', 'PHProjectChangeRequest', 'PHVideoRequestOptions', 'PKAddCarKeyPassConfiguration', 'PKAddPassButton', 'PKAddPassesViewController', 'PKAddPaymentPassRequest', 'PKAddPaymentPassRequestConfiguration', 'PKAddPaymentPassViewController', 'PKAddSecureElementPassConfiguration', 'PKAddSecureElementPassViewController', 'PKAddShareablePassConfiguration', 'PKBarcodeEventConfigurationRequest', 'PKBarcodeEventMetadataRequest', 'PKBarcodeEventMetadataResponse', 'PKBarcodeEventSignatureRequest', 'PKBarcodeEventSignatureResponse', 'PKCanvasView', 'PKContact', 'PKDisbursementAuthorizationController', 'PKDisbursementRequest', 'PKDisbursementVoucher', 'PKDrawing', 'PKEraserTool', 'PKFloatRange', 'PKInk', 'PKInkingTool', 'PKIssuerProvisioningExtensionHandler', 'PKIssuerProvisioningExtensionPassEntry', 'PKIssuerProvisioningExtensionPaymentPassEntry', 'PKIssuerProvisioningExtensionStatus', 'PKLabeledValue', 'PKLassoTool', 'PKObject', 'PKPass', 'PKPassLibrary', 'PKPayment', 'PKPaymentAuthorizationController', 'PKPaymentAuthorizationResult', 'PKPaymentAuthorizationViewController', 'PKPaymentButton', 'PKPaymentInformationEventExtension', 'PKPaymentMerchantSession', 'PKPaymentMethod', 'PKPaymentPass', 'PKPaymentRequest', 'PKPaymentRequestMerchantSessionUpdate', 'PKPaymentRequestPaymentMethodUpdate', 'PKPaymentRequestShippingContactUpdate', 'PKPaymentRequestShippingMethodUpdate', 'PKPaymentRequestUpdate', 'PKPaymentSummaryItem', 'PKPaymentToken', 'PKPushCredentials', 'PKPushPayload', 'PKPushRegistry', 'PKSecureElementPass', 'PKShareablePassMetadata', 'PKShippingMethod', 'PKStroke', 'PKStrokePath', 'PKStrokePoint', 'PKSuicaPassProperties', 'PKTool', 'PKToolPicker', 'PKTransitPassProperties', 'QLFileThumbnailRequest', 'QLPreviewController', 'QLThumbnailGenerationRequest', 'QLThumbnailGenerator', 'QLThumbnailProvider', 'QLThumbnailReply', 'QLThumbnailRepresentation', 'RPBroadcastActivityController', 'RPBroadcastActivityViewController', 'RPBroadcastConfiguration', 'RPBroadcastController', 'RPBroadcastHandler', 'RPBroadcastMP4ClipHandler', 'RPBroadcastSampleHandler', 'RPPreviewViewController', 'RPScreenRecorder', 'RPSystemBroadcastPickerView', 'SCNAccelerationConstraint', 'SCNAction', 'SCNAnimation', 'SCNAnimationEvent', 'SCNAnimationPlayer', 'SCNAudioPlayer', 'SCNAudioSource', 'SCNAvoidOccluderConstraint', 'SCNBillboardConstraint', 'SCNBox', 'SCNCamera', 'SCNCameraController', 'SCNCapsule', 'SCNCone', 'SCNConstraint', 'SCNCylinder', 'SCNDistanceConstraint', 'SCNFloor', 'SCNGeometry', 'SCNGeometryElement', 'SCNGeometrySource', 'SCNGeometryTessellator', 'SCNHitTestResult', 'SCNIKConstraint', 'SCNLevelOfDetail', 'SCNLight', 'SCNLookAtConstraint', 'SCNMaterial', 'SCNMaterialProperty', 'SCNMorpher', 'SCNNode', 'SCNParticlePropertyController', 'SCNParticleSystem', 'SCNPhysicsBallSocketJoint', 'SCNPhysicsBehavior', 'SCNPhysicsBody', 'SCNPhysicsConeTwistJoint', 'SCNPhysicsContact', 'SCNPhysicsField', 'SCNPhysicsHingeJoint', 'SCNPhysicsShape', 'SCNPhysicsSliderJoint', 'SCNPhysicsVehicle', 'SCNPhysicsVehicleWheel', 'SCNPhysicsWorld', 'SCNPlane', 'SCNProgram', 'SCNPyramid', 'SCNReferenceNode', 'SCNRenderer', 'SCNReplicatorConstraint', 'SCNScene', 'SCNSceneSource', 'SCNShape', 'SCNSkinner', 'SCNSliderConstraint', 'SCNSphere', 'SCNTechnique', 'SCNText', 'SCNTimingFunction', 'SCNTorus', 'SCNTransaction', 'SCNTransformConstraint', 'SCNTube', 'SCNView', 'SFAcousticFeature', 'SFAuthenticationSession', 'SFContentBlockerManager', 'SFContentBlockerState', 'SFSafariViewController', 'SFSafariViewControllerConfiguration', 'SFSpeechAudioBufferRecognitionRequest', 'SFSpeechRecognitionRequest', 'SFSpeechRecognitionResult', 'SFSpeechRecognitionTask', 'SFSpeechRecognizer', 'SFSpeechURLRecognitionRequest', 'SFTranscription', 'SFTranscriptionSegment', 'SFVoiceAnalytics', 'SK3DNode', 'SKAction', 'SKAdNetwork', 'SKArcadeService', 'SKAttribute', 'SKAttributeValue', 'SKAudioNode', 'SKCameraNode', 'SKCloudServiceController', 'SKCloudServiceSetupViewController', 'SKConstraint', 'SKCropNode', 'SKDownload', 'SKEffectNode', 'SKEmitterNode', 'SKFieldNode', 'SKKeyframeSequence', 'SKLabelNode', 'SKLightNode', 'SKMutablePayment', 'SKMutableTexture', 'SKNode', 'SKOverlay', 'SKOverlayAppClipConfiguration', 'SKOverlayAppConfiguration', 'SKOverlayConfiguration', 'SKOverlayTransitionContext', 'SKPayment', 'SKPaymentDiscount', 'SKPaymentQueue', 'SKPaymentTransaction', 'SKPhysicsBody', 'SKPhysicsContact', 'SKPhysicsJoint', 'SKPhysicsJointFixed', 'SKPhysicsJointLimit', 'SKPhysicsJointPin', 'SKPhysicsJointSliding', 'SKPhysicsJointSpring', 'SKPhysicsWorld', 'SKProduct', 'SKProductDiscount', 'SKProductStorePromotionController', 'SKProductSubscriptionPeriod', 'SKProductsRequest', 'SKProductsResponse', 'SKRange', 'SKReachConstraints', 'SKReceiptRefreshRequest', 'SKReferenceNode', 'SKRegion', 'SKRenderer', 'SKRequest', 'SKScene', 'SKShader', 'SKShapeNode', 'SKSpriteNode', 'SKStoreProductViewController', 'SKStoreReviewController', 'SKStorefront', 'SKTexture', 'SKTextureAtlas', 'SKTileDefinition', 'SKTileGroup', 'SKTileGroupRule', 'SKTileMapNode', 'SKTileSet', 'SKTransformNode', 'SKTransition', 'SKUniform', 'SKVideoNode', 'SKView', 'SKWarpGeometry', 'SKWarpGeometryGrid', 'SLComposeServiceViewController', 'SLComposeSheetConfigurationItem', 'SLComposeViewController', 'SLRequest', 'SNAudioFileAnalyzer', 'SNAudioStreamAnalyzer', 'SNClassification', 'SNClassificationResult', 'SNClassifySoundRequest', 'SRAmbientLightSample', 'SRApplicationUsage', 'SRDeletionRecord', 'SRDevice', 'SRDeviceUsageReport', 'SRFetchRequest', 'SRFetchResult', 'SRKeyboardMetrics', 'SRKeyboardProbabilityMetric', 'SRMessagesUsageReport', 'SRNotificationUsage', 'SRPhoneUsageReport', 'SRSensorReader', 'SRVisit', 'SRWebUsage', 'SRWristDetection', 'SSReadingList', 'STScreenTimeConfiguration', 'STScreenTimeConfigurationObserver', 'STWebHistory', 'STWebpageController', 'TKBERTLVRecord', 'TKCompactTLVRecord', 'TKSimpleTLVRecord', 'TKSmartCard', 'TKSmartCardATR', 'TKSmartCardATRInterfaceGroup', 'TKSmartCardPINFormat', 'TKSmartCardSlot', 'TKSmartCardSlotManager', 'TKSmartCardToken', 'TKSmartCardTokenDriver', 'TKSmartCardTokenSession', 'TKSmartCardUserInteraction', 'TKSmartCardUserInteractionForPINOperation', 'TKSmartCardUserInteractionForSecurePINChange', 'TKSmartCardUserInteractionForSecurePINVerification', 'TKTLVRecord', 'TKToken', 'TKTokenAuthOperation', 'TKTokenConfiguration', 'TKTokenDriver', 'TKTokenDriverConfiguration', 'TKTokenKeyAlgorithm', 'TKTokenKeyExchangeParameters', 'TKTokenKeychainCertificate', 'TKTokenKeychainContents', 'TKTokenKeychainItem', 'TKTokenKeychainKey', 'TKTokenPasswordAuthOperation', 'TKTokenSession', 'TKTokenSmartCardPINAuthOperation', 'TKTokenWatcher', 'TWRequest', 'TWTweetComposeViewController', 'UIAcceleration', 'UIAccelerometer', 'UIAccessibilityCustomAction', 'UIAccessibilityCustomRotor', 'UIAccessibilityCustomRotorItemResult', 'UIAccessibilityCustomRotorSearchPredicate', 'UIAccessibilityElement', 'UIAccessibilityLocationDescriptor', 'UIAction', 'UIActionSheet', 'UIActivity', 'UIActivityIndicatorView', 'UIActivityItemProvider', 'UIActivityItemsConfiguration', 'UIActivityViewController', 'UIAlertAction', 'UIAlertController', 'UIAlertView', 'UIApplication', 'UIApplicationShortcutIcon', 'UIApplicationShortcutItem', 'UIAttachmentBehavior', 'UIBackgroundConfiguration', 'UIBarAppearance', 'UIBarButtonItem', 'UIBarButtonItemAppearance', 'UIBarButtonItemGroup', 'UIBarButtonItemStateAppearance', 'UIBarItem', 'UIBezierPath', 'UIBlurEffect', 'UIButton', 'UICellAccessory', 'UICellAccessoryCheckmark', 'UICellAccessoryCustomView', 'UICellAccessoryDelete', 'UICellAccessoryDisclosureIndicator', 'UICellAccessoryInsert', 'UICellAccessoryLabel', 'UICellAccessoryMultiselect', 'UICellAccessoryOutlineDisclosure', 'UICellAccessoryReorder', 'UICellConfigurationState', 'UICloudSharingController', 'UICollectionLayoutListConfiguration', 'UICollectionReusableView', 'UICollectionView', 'UICollectionViewCell', 'UICollectionViewCellRegistration', 'UICollectionViewCompositionalLayout', 'UICollectionViewCompositionalLayoutConfiguration', 'UICollectionViewController', 'UICollectionViewDiffableDataSource', 'UICollectionViewDiffableDataSourceReorderingHandlers', 'UICollectionViewDiffableDataSourceSectionSnapshotHandlers', 'UICollectionViewDropPlaceholder', 'UICollectionViewDropProposal', 'UICollectionViewFlowLayout', 'UICollectionViewFlowLayoutInvalidationContext', 'UICollectionViewFocusUpdateContext', 'UICollectionViewLayout', 'UICollectionViewLayoutAttributes', 'UICollectionViewLayoutInvalidationContext', 'UICollectionViewListCell', 'UICollectionViewPlaceholder', 'UICollectionViewSupplementaryRegistration', 'UICollectionViewTransitionLayout', 'UICollectionViewUpdateItem', 'UICollisionBehavior', 'UIColor', 'UIColorPickerViewController', 'UIColorWell', 'UICommand', 'UICommandAlternate', 'UIContextMenuConfiguration', 'UIContextMenuInteraction', 'UIContextualAction', 'UIControl', 'UICubicTimingParameters', 'UIDatePicker', 'UIDeferredMenuElement', 'UIDevice', 'UIDictationPhrase', 'UIDocument', 'UIDocumentBrowserAction', 'UIDocumentBrowserTransitionController', 'UIDocumentBrowserViewController', 'UIDocumentInteractionController', 'UIDocumentMenuViewController', 'UIDocumentPickerExtensionViewController', 'UIDocumentPickerViewController', 'UIDragInteraction', 'UIDragItem', 'UIDragPreview', 'UIDragPreviewParameters', 'UIDragPreviewTarget', 'UIDropInteraction', 'UIDropProposal', 'UIDynamicAnimator', 'UIDynamicBehavior', 'UIDynamicItemBehavior', 'UIDynamicItemGroup', 'UIEvent', 'UIFeedbackGenerator', 'UIFieldBehavior', 'UIFocusAnimationCoordinator', 'UIFocusDebugger', 'UIFocusGuide', 'UIFocusMovementHint', 'UIFocusSystem', 'UIFocusUpdateContext', 'UIFont', 'UIFontDescriptor', 'UIFontMetrics', 'UIFontPickerViewController', 'UIFontPickerViewControllerConfiguration', 'UIGestureRecognizer', 'UIGraphicsImageRenderer', 'UIGraphicsImageRendererContext', 'UIGraphicsImageRendererFormat', 'UIGraphicsPDFRenderer', 'UIGraphicsPDFRendererContext', 'UIGraphicsPDFRendererFormat', 'UIGraphicsRenderer', 'UIGraphicsRendererContext', 'UIGraphicsRendererFormat', 'UIGravityBehavior', 'UIHoverGestureRecognizer', 'UIImage', 'UIImageAsset', 'UIImageConfiguration', 'UIImagePickerController', 'UIImageSymbolConfiguration', 'UIImageView', 'UIImpactFeedbackGenerator', 'UIIndirectScribbleInteraction', 'UIInputView', 'UIInputViewController', 'UIInterpolatingMotionEffect', 'UIKey', 'UIKeyCommand', 'UILabel', 'UILargeContentViewerInteraction', 'UILayoutGuide', 'UILexicon', 'UILexiconEntry', 'UIListContentConfiguration', 'UIListContentImageProperties', 'UIListContentTextProperties', 'UIListContentView', 'UILocalNotification', 'UILocalizedIndexedCollation', 'UILongPressGestureRecognizer', 'UIManagedDocument', 'UIMarkupTextPrintFormatter', 'UIMenu', 'UIMenuController', 'UIMenuElement', 'UIMenuItem', 'UIMenuSystem', 'UIMotionEffect', 'UIMotionEffectGroup', 'UIMutableApplicationShortcutItem', 'UIMutableUserNotificationAction', 'UIMutableUserNotificationCategory', 'UINavigationBar', 'UINavigationBarAppearance', 'UINavigationController', 'UINavigationItem', 'UINib', 'UINotificationFeedbackGenerator', 'UIOpenURLContext', 'UIPageControl', 'UIPageViewController', 'UIPanGestureRecognizer', 'UIPasteConfiguration', 'UIPasteboard', 'UIPencilInteraction', 'UIPercentDrivenInteractiveTransition', 'UIPickerView', 'UIPinchGestureRecognizer', 'UIPointerEffect', 'UIPointerHighlightEffect', 'UIPointerHoverEffect', 'UIPointerInteraction', 'UIPointerLiftEffect', 'UIPointerLockState', 'UIPointerRegion', 'UIPointerRegionRequest', 'UIPointerShape', 'UIPointerStyle', 'UIPopoverBackgroundView', 'UIPopoverController', 'UIPopoverPresentationController', 'UIPresentationController', 'UIPress', 'UIPressesEvent', 'UIPreviewAction', 'UIPreviewActionGroup', 'UIPreviewInteraction', 'UIPreviewParameters', 'UIPreviewTarget', 'UIPrintFormatter', 'UIPrintInfo', 'UIPrintInteractionController', 'UIPrintPageRenderer', 'UIPrintPaper', 'UIPrinter', 'UIPrinterPickerController', 'UIProgressView', 'UIPushBehavior', 'UIReferenceLibraryViewController', 'UIRefreshControl', 'UIRegion', 'UIResponder', 'UIRotationGestureRecognizer', 'UIScene', 'UISceneActivationConditions', 'UISceneActivationRequestOptions', 'UISceneConfiguration', 'UISceneConnectionOptions', 'UISceneDestructionRequestOptions', 'UISceneOpenExternalURLOptions', 'UISceneOpenURLOptions', 'UISceneSession', 'UISceneSizeRestrictions', 'UIScreen', 'UIScreenEdgePanGestureRecognizer', 'UIScreenMode', 'UIScreenshotService', 'UIScribbleInteraction', 'UIScrollView', 'UISearchBar', 'UISearchContainerViewController', 'UISearchController', 'UISearchDisplayController', 'UISearchSuggestionItem', 'UISearchTextField', 'UISearchToken', 'UISegmentedControl', 'UISelectionFeedbackGenerator', 'UISimpleTextPrintFormatter', 'UISlider', 'UISnapBehavior', 'UISplitViewController', 'UISpringLoadedInteraction', 'UISpringTimingParameters', 'UIStackView', 'UIStatusBarManager', 'UIStepper', 'UIStoryboard', 'UIStoryboardPopoverSegue', 'UIStoryboardSegue', 'UIStoryboardUnwindSegueSource', 'UISwipeActionsConfiguration', 'UISwipeGestureRecognizer', 'UISwitch', 'UITabBar', 'UITabBarAppearance', 'UITabBarController', 'UITabBarItem', 'UITabBarItemAppearance', 'UITabBarItemStateAppearance', 'UITableView', 'UITableViewCell', 'UITableViewController', 'UITableViewDiffableDataSource', 'UITableViewDropPlaceholder', 'UITableViewDropProposal', 'UITableViewFocusUpdateContext', 'UITableViewHeaderFooterView', 'UITableViewPlaceholder', 'UITableViewRowAction', 'UITapGestureRecognizer', 'UITargetedDragPreview', 'UITargetedPreview', 'UITextChecker', 'UITextDragPreviewRenderer', 'UITextDropProposal', 'UITextField', 'UITextFormattingCoordinator', 'UITextInputAssistantItem', 'UITextInputMode', 'UITextInputPasswordRules', 'UITextInputStringTokenizer', 'UITextInteraction', 'UITextPlaceholder', 'UITextPosition', 'UITextRange', 'UITextSelectionRect', 'UITextView', 'UITitlebar', 'UIToolbar', 'UIToolbarAppearance', 'UITouch', 'UITraitCollection', 'UIUserNotificationAction', 'UIUserNotificationCategory', 'UIUserNotificationSettings', 'UIVibrancyEffect', 'UIVideoEditorController', 'UIView', 'UIViewConfigurationState', 'UIViewController', 'UIViewPrintFormatter', 'UIViewPropertyAnimator', 'UIVisualEffect', 'UIVisualEffectView', 'UIWebView', 'UIWindow', 'UIWindowScene', 'UIWindowSceneDestructionRequestOptions', 'UNCalendarNotificationTrigger', 'UNLocationNotificationTrigger', 'UNMutableNotificationContent', 'UNNotification', 'UNNotificationAction', 'UNNotificationAttachment', 'UNNotificationCategory', 'UNNotificationContent', 'UNNotificationRequest', 'UNNotificationResponse', 'UNNotificationServiceExtension', 'UNNotificationSettings', 'UNNotificationSound', 'UNNotificationTrigger', 'UNPushNotificationTrigger', 'UNTextInputNotificationAction', 'UNTextInputNotificationResponse', 'UNTimeIntervalNotificationTrigger', 'UNUserNotificationCenter', 'UTType', 'VNBarcodeObservation', 'VNCircle', 'VNClassificationObservation', 'VNClassifyImageRequest', 'VNContour', 'VNContoursObservation', 'VNCoreMLFeatureValueObservation', 'VNCoreMLModel', 'VNCoreMLRequest', 'VNDetectBarcodesRequest', 'VNDetectContoursRequest', 'VNDetectFaceCaptureQualityRequest', 'VNDetectFaceLandmarksRequest', 'VNDetectFaceRectanglesRequest', 'VNDetectHorizonRequest', 'VNDetectHumanBodyPoseRequest', 'VNDetectHumanHandPoseRequest', 'VNDetectHumanRectanglesRequest', 'VNDetectRectanglesRequest', 'VNDetectTextRectanglesRequest', 'VNDetectTrajectoriesRequest', 'VNDetectedObjectObservation', 'VNDetectedPoint', 'VNDocumentCameraScan', 'VNDocumentCameraViewController', 'VNFaceLandmarkRegion', 'VNFaceLandmarkRegion2D', 'VNFaceLandmarks', 'VNFaceLandmarks2D', 'VNFaceObservation', 'VNFeaturePrintObservation', 'VNGenerateAttentionBasedSaliencyImageRequest', 'VNGenerateImageFeaturePrintRequest', 'VNGenerateObjectnessBasedSaliencyImageRequest', 'VNGenerateOpticalFlowRequest', 'VNGeometryUtils', 'VNHomographicImageRegistrationRequest', 'VNHorizonObservation', 'VNHumanBodyPoseObservation', 'VNHumanHandPoseObservation', 'VNImageAlignmentObservation', 'VNImageBasedRequest', 'VNImageHomographicAlignmentObservation', 'VNImageRegistrationRequest', 'VNImageRequestHandler', 'VNImageTranslationAlignmentObservation', 'VNObservation', 'VNPixelBufferObservation', 'VNPoint', 'VNRecognizeAnimalsRequest', 'VNRecognizeTextRequest', 'VNRecognizedObjectObservation', 'VNRecognizedPoint', 'VNRecognizedPointsObservation', 'VNRecognizedText', 'VNRecognizedTextObservation', 'VNRectangleObservation', 'VNRequest', 'VNSaliencyImageObservation', 'VNSequenceRequestHandler', 'VNStatefulRequest', 'VNTargetedImageRequest', 'VNTextObservation', 'VNTrackObjectRequest', 'VNTrackRectangleRequest', 'VNTrackingRequest', 'VNTrajectoryObservation', 'VNTranslationalImageRegistrationRequest', 'VNVector', 'VNVideoProcessor', 'VNVideoProcessorCadence', 'VNVideoProcessorFrameRateCadence', 'VNVideoProcessorRequestProcessingOptions', 'VNVideoProcessorTimeIntervalCadence', 'VSAccountApplicationProvider', 'VSAccountManager', 'VSAccountManagerResult', 'VSAccountMetadata', 'VSAccountMetadataRequest', 'VSAccountProviderResponse', 'VSSubscription', 'VSSubscriptionRegistrationCenter', 'WCSession', 'WCSessionFile', 'WCSessionFileTransfer', 'WCSessionUserInfoTransfer', 'WKBackForwardList', 'WKBackForwardListItem', 'WKContentRuleList', 'WKContentRuleListStore', 'WKContentWorld', 'WKContextMenuElementInfo', 'WKFindConfiguration', 'WKFindResult', 'WKFrameInfo', 'WKHTTPCookieStore', 'WKNavigation', 'WKNavigationAction', 'WKNavigationResponse', 'WKOpenPanelParameters', 'WKPDFConfiguration', 'WKPreferences', 'WKPreviewElementInfo', 'WKProcessPool', 'WKScriptMessage', 'WKSecurityOrigin', 'WKSnapshotConfiguration', 'WKUserContentController', 'WKUserScript', 'WKWebView', 'WKWebViewConfiguration', 'WKWebpagePreferences', 'WKWebsiteDataRecord', 'WKWebsiteDataStore', 'WKWindowFeatures', '__EntityAccessibilityWrapper'} +COCOA_PROTOCOLS = {'ABNewPersonViewControllerDelegate', 'ABPeoplePickerNavigationControllerDelegate', 'ABPersonViewControllerDelegate', 'ABUnknownPersonViewControllerDelegate', 'ADActionViewControllerChildInterface', 'ADActionViewControllerInterface', 'ADBannerViewDelegate', 'ADInterstitialAdDelegate', 'AEAssessmentSessionDelegate', 'ARAnchorCopying', 'ARCoachingOverlayViewDelegate', 'ARSCNViewDelegate', 'ARSKViewDelegate', 'ARSessionDelegate', 'ARSessionObserver', 'ARSessionProviding', 'ARTrackable', 'ASAccountAuthenticationModificationControllerDelegate', 'ASAccountAuthenticationModificationControllerPresentationContextProviding', 'ASAuthorizationControllerDelegate', 'ASAuthorizationControllerPresentationContextProviding', 'ASAuthorizationCredential', 'ASAuthorizationProvider', 'ASAuthorizationProviderExtensionAuthorizationRequestHandler', 'ASWebAuthenticationPresentationContextProviding', 'ASWebAuthenticationSessionRequestDelegate', 'ASWebAuthenticationSessionWebBrowserSessionHandling', 'AUAudioUnitFactory', 'AVAssetDownloadDelegate', 'AVAssetResourceLoaderDelegate', 'AVAssetWriterDelegate', 'AVAsynchronousKeyValueLoading', 'AVCaptureAudioDataOutputSampleBufferDelegate', 'AVCaptureDataOutputSynchronizerDelegate', 'AVCaptureDepthDataOutputDelegate', 'AVCaptureFileOutputDelegate', 'AVCaptureFileOutputRecordingDelegate', 'AVCaptureMetadataOutputObjectsDelegate', 'AVCapturePhotoCaptureDelegate', 'AVCapturePhotoFileDataRepresentationCustomizer', 'AVCaptureVideoDataOutputSampleBufferDelegate', 'AVContentKeyRecipient', 'AVContentKeySessionDelegate', 'AVFragmentMinding', 'AVPictureInPictureControllerDelegate', 'AVPlayerItemLegibleOutputPushDelegate', 'AVPlayerItemMetadataCollectorPushDelegate', 'AVPlayerItemMetadataOutputPushDelegate', 'AVPlayerItemOutputPullDelegate', 'AVPlayerItemOutputPushDelegate', 'AVPlayerViewControllerDelegate', 'AVQueuedSampleBufferRendering', 'AVRoutePickerViewDelegate', 'AVVideoCompositing', 'AVVideoCompositionInstruction', 'AVVideoCompositionValidationHandling', 'AXCustomContentProvider', 'CAAction', 'CAAnimationDelegate', 'CALayerDelegate', 'CAMediaTiming', 'CAMetalDrawable', 'CBCentralManagerDelegate', 'CBPeripheralDelegate', 'CBPeripheralManagerDelegate', 'CHHapticAdvancedPatternPlayer', 'CHHapticDeviceCapability', 'CHHapticParameterAttributes', 'CHHapticPatternPlayer', 'CIAccordionFoldTransition', 'CIAffineClamp', 'CIAffineTile', 'CIAreaAverage', 'CIAreaHistogram', 'CIAreaMaximum', 'CIAreaMaximumAlpha', 'CIAreaMinMax', 'CIAreaMinMaxRed', 'CIAreaMinimum', 'CIAreaMinimumAlpha', 'CIAreaReductionFilter', 'CIAttributedTextImageGenerator', 'CIAztecCodeGenerator', 'CIBarcodeGenerator', 'CIBarsSwipeTransition', 'CIBicubicScaleTransform', 'CIBlendWithMask', 'CIBloom', 'CIBokehBlur', 'CIBoxBlur', 'CIBumpDistortion', 'CIBumpDistortionLinear', 'CICMYKHalftone', 'CICheckerboardGenerator', 'CICircleSplashDistortion', 'CICircularScreen', 'CICircularWrap', 'CICode128BarcodeGenerator', 'CIColorAbsoluteDifference', 'CIColorClamp', 'CIColorControls', 'CIColorCrossPolynomial', 'CIColorCube', 'CIColorCubeWithColorSpace', 'CIColorCubesMixedWithMask', 'CIColorCurves', 'CIColorInvert', 'CIColorMap', 'CIColorMatrix', 'CIColorMonochrome', 'CIColorPolynomial', 'CIColorPosterize', 'CIColorThreshold', 'CIColorThresholdOtsu', 'CIColumnAverage', 'CIComicEffect', 'CICompositeOperation', 'CIConvolution', 'CICopyMachineTransition', 'CICoreMLModel', 'CICrystallize', 'CIDepthOfField', 'CIDepthToDisparity', 'CIDiscBlur', 'CIDisintegrateWithMaskTransition', 'CIDisparityToDepth', 'CIDisplacementDistortion', 'CIDissolveTransition', 'CIDither', 'CIDocumentEnhancer', 'CIDotScreen', 'CIDroste', 'CIEdgePreserveUpsample', 'CIEdgeWork', 'CIEdges', 'CIEightfoldReflectedTile', 'CIExposureAdjust', 'CIFalseColor', 'CIFilter', 'CIFilterConstructor', 'CIFlashTransition', 'CIFourCoordinateGeometryFilter', 'CIFourfoldReflectedTile', 'CIFourfoldRotatedTile', 'CIFourfoldTranslatedTile', 'CIGaborGradients', 'CIGammaAdjust', 'CIGaussianBlur', 'CIGaussianGradient', 'CIGlassDistortion', 'CIGlassLozenge', 'CIGlideReflectedTile', 'CIGloom', 'CIHatchedScreen', 'CIHeightFieldFromMask', 'CIHexagonalPixellate', 'CIHighlightShadowAdjust', 'CIHistogramDisplay', 'CIHoleDistortion', 'CIHueAdjust', 'CIHueSaturationValueGradient', 'CIImageProcessorInput', 'CIImageProcessorOutput', 'CIKMeans', 'CIKaleidoscope', 'CIKeystoneCorrectionCombined', 'CIKeystoneCorrectionHorizontal', 'CIKeystoneCorrectionVertical', 'CILabDeltaE', 'CILanczosScaleTransform', 'CILenticularHaloGenerator', 'CILightTunnel', 'CILineOverlay', 'CILineScreen', 'CILinearGradient', 'CILinearToSRGBToneCurve', 'CIMaskToAlpha', 'CIMaskedVariableBlur', 'CIMaximumComponent', 'CIMedian', 'CIMeshGenerator', 'CIMinimumComponent', 'CIMix', 'CIModTransition', 'CIMorphologyGradient', 'CIMorphologyMaximum', 'CIMorphologyMinimum', 'CIMorphologyRectangleMaximum', 'CIMorphologyRectangleMinimum', 'CIMotionBlur', 'CINinePartStretched', 'CINinePartTiled', 'CINoiseReduction', 'CIOpTile', 'CIPDF417BarcodeGenerator', 'CIPageCurlTransition', 'CIPageCurlWithShadowTransition', 'CIPaletteCentroid', 'CIPalettize', 'CIParallelogramTile', 'CIPerspectiveCorrection', 'CIPerspectiveRotate', 'CIPerspectiveTile', 'CIPerspectiveTransform', 'CIPerspectiveTransformWithExtent', 'CIPhotoEffect', 'CIPinchDistortion', 'CIPixellate', 'CIPlugInRegistration', 'CIPointillize', 'CIQRCodeGenerator', 'CIRadialGradient', 'CIRandomGenerator', 'CIRippleTransition', 'CIRoundedRectangleGenerator', 'CIRowAverage', 'CISRGBToneCurveToLinear', 'CISaliencyMap', 'CISepiaTone', 'CIShadedMaterial', 'CISharpenLuminance', 'CISixfoldReflectedTile', 'CISixfoldRotatedTile', 'CISmoothLinearGradient', 'CISpotColor', 'CISpotLight', 'CIStarShineGenerator', 'CIStraighten', 'CIStretchCrop', 'CIStripesGenerator', 'CISunbeamsGenerator', 'CISwipeTransition', 'CITemperatureAndTint', 'CITextImageGenerator', 'CIThermal', 'CIToneCurve', 'CITorusLensDistortion', 'CITransitionFilter', 'CITriangleKaleidoscope', 'CITriangleTile', 'CITwelvefoldReflectedTile', 'CITwirlDistortion', 'CIUnsharpMask', 'CIVibrance', 'CIVignette', 'CIVignetteEffect', 'CIVortexDistortion', 'CIWhitePointAdjust', 'CIXRay', 'CIZoomBlur', 'CKRecordKeyValueSetting', 'CKRecordValue', 'CLKComplicationDataSource', 'CLLocationManagerDelegate', 'CLSContextProvider', 'CLSDataStoreDelegate', 'CMFallDetectionDelegate', 'CMHeadphoneMotionManagerDelegate', 'CNChangeHistoryEventVisitor', 'CNContactPickerDelegate', 'CNContactViewControllerDelegate', 'CNKeyDescriptor', 'CPApplicationDelegate', 'CPBarButtonProviding', 'CPInterfaceControllerDelegate', 'CPListTemplateDelegate', 'CPListTemplateItem', 'CPMapTemplateDelegate', 'CPNowPlayingTemplateObserver', 'CPPointOfInterestTemplateDelegate', 'CPSearchTemplateDelegate', 'CPSelectableListItem', 'CPSessionConfigurationDelegate', 'CPTabBarTemplateDelegate', 'CPTemplateApplicationDashboardSceneDelegate', 'CPTemplateApplicationSceneDelegate', 'CSSearchableIndexDelegate', 'CTSubscriberDelegate', 'CTTelephonyNetworkInfoDelegate', 'CXCallDirectoryExtensionContextDelegate', 'CXCallObserverDelegate', 'CXProviderDelegate', 'EAAccessoryDelegate', 'EAGLDrawable', 'EAWiFiUnconfiguredAccessoryBrowserDelegate', 'EKCalendarChooserDelegate', 'EKEventEditViewDelegate', 'EKEventViewDelegate', 'GCDevice', 'GKAchievementViewControllerDelegate', 'GKAgentDelegate', 'GKChallengeEventHandlerDelegate', 'GKChallengeListener', 'GKFriendRequestComposeViewControllerDelegate', 'GKGameCenterControllerDelegate', 'GKGameModel', 'GKGameModelPlayer', 'GKGameModelUpdate', 'GKGameSessionEventListener', 'GKGameSessionSharingViewControllerDelegate', 'GKInviteEventListener', 'GKLeaderboardViewControllerDelegate', 'GKLocalPlayerListener', 'GKMatchDelegate', 'GKMatchmakerViewControllerDelegate', 'GKPeerPickerControllerDelegate', 'GKRandom', 'GKSavedGameListener', 'GKSceneRootNodeType', 'GKSessionDelegate', 'GKStrategist', 'GKTurnBasedEventListener', 'GKTurnBasedMatchmakerViewControllerDelegate', 'GKVoiceChatClient', 'GLKNamedEffect', 'GLKViewControllerDelegate', 'GLKViewDelegate', 'HKLiveWorkoutBuilderDelegate', 'HKWorkoutSessionDelegate', 'HMAccessoryBrowserDelegate', 'HMAccessoryDelegate', 'HMCameraSnapshotControlDelegate', 'HMCameraStreamControlDelegate', 'HMHomeDelegate', 'HMHomeManagerDelegate', 'HMNetworkConfigurationProfileDelegate', 'ICCameraDeviceDelegate', 'ICCameraDeviceDownloadDelegate', 'ICDeviceBrowserDelegate', 'ICDeviceDelegate', 'ICScannerDeviceDelegate', 'ILMessageFilterQueryHandling', 'INActivateCarSignalIntentHandling', 'INAddMediaIntentHandling', 'INAddTasksIntentHandling', 'INAppendToNoteIntentHandling', 'INBookRestaurantReservationIntentHandling', 'INCallsDomainHandling', 'INCancelRideIntentHandling', 'INCancelWorkoutIntentHandling', 'INCarCommandsDomainHandling', 'INCarPlayDomainHandling', 'INCreateNoteIntentHandling', 'INCreateTaskListIntentHandling', 'INDeleteTasksIntentHandling', 'INEndWorkoutIntentHandling', 'INGetAvailableRestaurantReservationBookingDefaultsIntentHandling', 'INGetAvailableRestaurantReservationBookingsIntentHandling', 'INGetCarLockStatusIntentHandling', 'INGetCarPowerLevelStatusIntentHandling', 'INGetCarPowerLevelStatusIntentResponseObserver', 'INGetRestaurantGuestIntentHandling', 'INGetRideStatusIntentHandling', 'INGetRideStatusIntentResponseObserver', 'INGetUserCurrentRestaurantReservationBookingsIntentHandling', 'INGetVisualCodeIntentHandling', 'INIntentHandlerProviding', 'INListCarsIntentHandling', 'INListRideOptionsIntentHandling', 'INMessagesDomainHandling', 'INNotebookDomainHandling', 'INPauseWorkoutIntentHandling', 'INPayBillIntentHandling', 'INPaymentsDomainHandling', 'INPhotosDomainHandling', 'INPlayMediaIntentHandling', 'INRadioDomainHandling', 'INRequestPaymentIntentHandling', 'INRequestRideIntentHandling', 'INResumeWorkoutIntentHandling', 'INRidesharingDomainHandling', 'INSaveProfileInCarIntentHandling', 'INSearchCallHistoryIntentHandling', 'INSearchForAccountsIntentHandling', 'INSearchForBillsIntentHandling', 'INSearchForMediaIntentHandling', 'INSearchForMessagesIntentHandling', 'INSearchForNotebookItemsIntentHandling', 'INSearchForPhotosIntentHandling', 'INSendMessageIntentHandling', 'INSendPaymentIntentHandling', 'INSendRideFeedbackIntentHandling', 'INSetAudioSourceInCarIntentHandling', 'INSetCarLockStatusIntentHandling', 'INSetClimateSettingsInCarIntentHandling', 'INSetDefrosterSettingsInCarIntentHandling', 'INSetMessageAttributeIntentHandling', 'INSetProfileInCarIntentHandling', 'INSetRadioStationIntentHandling', 'INSetSeatSettingsInCarIntentHandling', 'INSetTaskAttributeIntentHandling', 'INSnoozeTasksIntentHandling', 'INSpeakable', 'INStartAudioCallIntentHandling', 'INStartCallIntentHandling', 'INStartPhotoPlaybackIntentHandling', 'INStartVideoCallIntentHandling', 'INStartWorkoutIntentHandling', 'INTransferMoneyIntentHandling', 'INUIAddVoiceShortcutButtonDelegate', 'INUIAddVoiceShortcutViewControllerDelegate', 'INUIEditVoiceShortcutViewControllerDelegate', 'INUIHostedViewControlling', 'INUIHostedViewSiriProviding', 'INUpdateMediaAffinityIntentHandling', 'INVisualCodeDomainHandling', 'INWorkoutsDomainHandling', 'JSExport', 'MCAdvertiserAssistantDelegate', 'MCBrowserViewControllerDelegate', 'MCNearbyServiceAdvertiserDelegate', 'MCNearbyServiceBrowserDelegate', 'MCSessionDelegate', 'MDLAssetResolver', 'MDLComponent', 'MDLJointAnimation', 'MDLLightProbeIrradianceDataSource', 'MDLMeshBuffer', 'MDLMeshBufferAllocator', 'MDLMeshBufferZone', 'MDLNamed', 'MDLObjectContainerComponent', 'MDLTransformComponent', 'MDLTransformOp', 'MFMailComposeViewControllerDelegate', 'MFMessageComposeViewControllerDelegate', 'MIDICIProfileResponderDelegate', 'MKAnnotation', 'MKGeoJSONObject', 'MKLocalSearchCompleterDelegate', 'MKMapViewDelegate', 'MKOverlay', 'MKReverseGeocoderDelegate', 'MLBatchProvider', 'MLCustomLayer', 'MLCustomModel', 'MLFeatureProvider', 'MLWritable', 'MPMediaPickerControllerDelegate', 'MPMediaPlayback', 'MPNowPlayingSessionDelegate', 'MPPlayableContentDataSource', 'MPPlayableContentDelegate', 'MPSystemMusicPlayerController', 'MSAuthenticationPresentationContext', 'MSMessagesAppTranscriptPresentation', 'MSStickerBrowserViewDataSource', 'MTKViewDelegate', 'MTLAccelerationStructure', 'MTLAccelerationStructureCommandEncoder', 'MTLArgumentEncoder', 'MTLBinaryArchive', 'MTLBlitCommandEncoder', 'MTLBuffer', 'MTLCaptureScope', 'MTLCommandBuffer', 'MTLCommandBufferEncoderInfo', 'MTLCommandEncoder', 'MTLCommandQueue', 'MTLComputeCommandEncoder', 'MTLComputePipelineState', 'MTLCounter', 'MTLCounterSampleBuffer', 'MTLCounterSet', 'MTLDepthStencilState', 'MTLDevice', 'MTLDrawable', 'MTLDynamicLibrary', 'MTLEvent', 'MTLFence', 'MTLFunction', 'MTLFunctionHandle', 'MTLFunctionLog', 'MTLFunctionLogDebugLocation', 'MTLHeap', 'MTLIndirectCommandBuffer', 'MTLIndirectComputeCommand', 'MTLIndirectComputeCommandEncoder', 'MTLIndirectRenderCommand', 'MTLIndirectRenderCommandEncoder', 'MTLIntersectionFunctionTable', 'MTLLibrary', 'MTLLogContainer', 'MTLParallelRenderCommandEncoder', 'MTLRasterizationRateMap', 'MTLRenderCommandEncoder', 'MTLRenderPipelineState', 'MTLResource', 'MTLResourceStateCommandEncoder', 'MTLSamplerState', 'MTLSharedEvent', 'MTLTexture', 'MTLVisibleFunctionTable', 'MXMetricManagerSubscriber', 'MyClassJavaScriptMethods', 'NCWidgetProviding', 'NEAppPushDelegate', 'NFCFeliCaTag', 'NFCISO15693Tag', 'NFCISO7816Tag', 'NFCMiFareTag', 'NFCNDEFReaderSessionDelegate', 'NFCNDEFTag', 'NFCReaderSession', 'NFCReaderSessionDelegate', 'NFCTag', 'NFCTagReaderSessionDelegate', 'NFCVASReaderSessionDelegate', 'NISessionDelegate', 'NSCacheDelegate', 'NSCoding', 'NSCollectionLayoutContainer', 'NSCollectionLayoutEnvironment', 'NSCollectionLayoutVisibleItem', 'NSCopying', 'NSDecimalNumberBehaviors', 'NSDiscardableContent', 'NSExtensionRequestHandling', 'NSFastEnumeration', 'NSFetchRequestResult', 'NSFetchedResultsControllerDelegate', 'NSFetchedResultsSectionInfo', 'NSFileManagerDelegate', 'NSFilePresenter', 'NSFileProviderChangeObserver', 'NSFileProviderEnumerationObserver', 'NSFileProviderEnumerator', 'NSFileProviderItem', 'NSFileProviderServiceSource', 'NSItemProviderReading', 'NSItemProviderWriting', 'NSKeyedArchiverDelegate', 'NSKeyedUnarchiverDelegate', 'NSLayoutManagerDelegate', 'NSLocking', 'NSMachPortDelegate', 'NSMetadataQueryDelegate', 'NSMutableCopying', 'NSNetServiceBrowserDelegate', 'NSNetServiceDelegate', 'NSPortDelegate', 'NSProgressReporting', 'NSSecureCoding', 'NSStreamDelegate', 'NSTextAttachmentContainer', 'NSTextLayoutOrientationProvider', 'NSTextStorageDelegate', 'NSURLAuthenticationChallengeSender', 'NSURLConnectionDataDelegate', 'NSURLConnectionDelegate', 'NSURLConnectionDownloadDelegate', 'NSURLProtocolClient', 'NSURLSessionDataDelegate', 'NSURLSessionDelegate', 'NSURLSessionDownloadDelegate', 'NSURLSessionStreamDelegate', 'NSURLSessionTaskDelegate', 'NSURLSessionWebSocketDelegate', 'NSUserActivityDelegate', 'NSXMLParserDelegate', 'NSXPCListenerDelegate', 'NSXPCProxyCreating', 'NWTCPConnectionAuthenticationDelegate', 'OSLogEntryFromProcess', 'OSLogEntryWithPayload', 'PDFDocumentDelegate', 'PDFViewDelegate', 'PHContentEditingController', 'PHLivePhotoFrame', 'PHLivePhotoViewDelegate', 'PHPhotoLibraryAvailabilityObserver', 'PHPhotoLibraryChangeObserver', 'PHPickerViewControllerDelegate', 'PKAddPassesViewControllerDelegate', 'PKAddPaymentPassViewControllerDelegate', 'PKAddSecureElementPassViewControllerDelegate', 'PKCanvasViewDelegate', 'PKDisbursementAuthorizationControllerDelegate', 'PKIssuerProvisioningExtensionAuthorizationProviding', 'PKPaymentAuthorizationControllerDelegate', 'PKPaymentAuthorizationViewControllerDelegate', 'PKPaymentInformationRequestHandling', 'PKPushRegistryDelegate', 'PKToolPickerObserver', 'PreviewDisplaying', 'QLPreviewControllerDataSource', 'QLPreviewControllerDelegate', 'QLPreviewItem', 'QLPreviewingController', 'RPBroadcastActivityControllerDelegate', 'RPBroadcastActivityViewControllerDelegate', 'RPBroadcastControllerDelegate', 'RPPreviewViewControllerDelegate', 'RPScreenRecorderDelegate', 'SCNActionable', 'SCNAnimatable', 'SCNAnimation', 'SCNAvoidOccluderConstraintDelegate', 'SCNBoundingVolume', 'SCNBufferStream', 'SCNCameraControlConfiguration', 'SCNCameraControllerDelegate', 'SCNNodeRendererDelegate', 'SCNPhysicsContactDelegate', 'SCNProgramDelegate', 'SCNSceneExportDelegate', 'SCNSceneRenderer', 'SCNSceneRendererDelegate', 'SCNShadable', 'SCNTechniqueSupport', 'SFSafariViewControllerDelegate', 'SFSpeechRecognitionTaskDelegate', 'SFSpeechRecognizerDelegate', 'SKCloudServiceSetupViewControllerDelegate', 'SKOverlayDelegate', 'SKPaymentQueueDelegate', 'SKPaymentTransactionObserver', 'SKPhysicsContactDelegate', 'SKProductsRequestDelegate', 'SKRequestDelegate', 'SKSceneDelegate', 'SKStoreProductViewControllerDelegate', 'SKViewDelegate', 'SKWarpable', 'SNRequest', 'SNResult', 'SNResultsObserving', 'SRSensorReaderDelegate', 'TKSmartCardTokenDriverDelegate', 'TKSmartCardUserInteractionDelegate', 'TKTokenDelegate', 'TKTokenDriverDelegate', 'TKTokenSessionDelegate', 'UIAccelerometerDelegate', 'UIAccessibilityContainerDataTable', 'UIAccessibilityContainerDataTableCell', 'UIAccessibilityContentSizeCategoryImageAdjusting', 'UIAccessibilityIdentification', 'UIAccessibilityReadingContent', 'UIActionSheetDelegate', 'UIActivityItemSource', 'UIActivityItemsConfigurationReading', 'UIAdaptivePresentationControllerDelegate', 'UIAlertViewDelegate', 'UIAppearance', 'UIAppearanceContainer', 'UIApplicationDelegate', 'UIBarPositioning', 'UIBarPositioningDelegate', 'UICloudSharingControllerDelegate', 'UICollectionViewDataSource', 'UICollectionViewDataSourcePrefetching', 'UICollectionViewDelegate', 'UICollectionViewDelegateFlowLayout', 'UICollectionViewDragDelegate', 'UICollectionViewDropCoordinator', 'UICollectionViewDropDelegate', 'UICollectionViewDropItem', 'UICollectionViewDropPlaceholderContext', 'UICollisionBehaviorDelegate', 'UIColorPickerViewControllerDelegate', 'UIConfigurationState', 'UIContentConfiguration', 'UIContentContainer', 'UIContentSizeCategoryAdjusting', 'UIContentView', 'UIContextMenuInteractionAnimating', 'UIContextMenuInteractionCommitAnimating', 'UIContextMenuInteractionDelegate', 'UICoordinateSpace', 'UIDataSourceModelAssociation', 'UIDataSourceTranslating', 'UIDocumentBrowserViewControllerDelegate', 'UIDocumentInteractionControllerDelegate', 'UIDocumentMenuDelegate', 'UIDocumentPickerDelegate', 'UIDragAnimating', 'UIDragDropSession', 'UIDragInteractionDelegate', 'UIDragSession', 'UIDropInteractionDelegate', 'UIDropSession', 'UIDynamicAnimatorDelegate', 'UIDynamicItem', 'UIFocusAnimationContext', 'UIFocusDebuggerOutput', 'UIFocusEnvironment', 'UIFocusItem', 'UIFocusItemContainer', 'UIFocusItemScrollableContainer', 'UIFontPickerViewControllerDelegate', 'UIGestureRecognizerDelegate', 'UIGuidedAccessRestrictionDelegate', 'UIImageConfiguration', 'UIImagePickerControllerDelegate', 'UIIndirectScribbleInteractionDelegate', 'UIInputViewAudioFeedback', 'UIInteraction', 'UIItemProviderPresentationSizeProviding', 'UIKeyInput', 'UILargeContentViewerInteractionDelegate', 'UILargeContentViewerItem', 'UILayoutSupport', 'UIMenuBuilder', 'UINavigationBarDelegate', 'UINavigationControllerDelegate', 'UIObjectRestoration', 'UIPageViewControllerDataSource', 'UIPageViewControllerDelegate', 'UIPasteConfigurationSupporting', 'UIPencilInteractionDelegate', 'UIPickerViewAccessibilityDelegate', 'UIPickerViewDataSource', 'UIPickerViewDelegate', 'UIPointerInteractionAnimating', 'UIPointerInteractionDelegate', 'UIPopoverBackgroundViewMethods', 'UIPopoverControllerDelegate', 'UIPopoverPresentationControllerDelegate', 'UIPreviewActionItem', 'UIPreviewInteractionDelegate', 'UIPrintInteractionControllerDelegate', 'UIPrinterPickerControllerDelegate', 'UIResponderStandardEditActions', 'UISceneDelegate', 'UIScreenshotServiceDelegate', 'UIScribbleInteractionDelegate', 'UIScrollViewAccessibilityDelegate', 'UIScrollViewDelegate', 'UISearchBarDelegate', 'UISearchControllerDelegate', 'UISearchDisplayDelegate', 'UISearchResultsUpdating', 'UISearchSuggestion', 'UISearchTextFieldDelegate', 'UISearchTextFieldPasteItem', 'UISplitViewControllerDelegate', 'UISpringLoadedInteractionBehavior', 'UISpringLoadedInteractionContext', 'UISpringLoadedInteractionEffect', 'UISpringLoadedInteractionSupporting', 'UIStateRestoring', 'UITabBarControllerDelegate', 'UITabBarDelegate', 'UITableViewDataSource', 'UITableViewDataSourcePrefetching', 'UITableViewDelegate', 'UITableViewDragDelegate', 'UITableViewDropCoordinator', 'UITableViewDropDelegate', 'UITableViewDropItem', 'UITableViewDropPlaceholderContext', 'UITextDocumentProxy', 'UITextDragDelegate', 'UITextDragRequest', 'UITextDraggable', 'UITextDropDelegate', 'UITextDropRequest', 'UITextDroppable', 'UITextFieldDelegate', 'UITextFormattingCoordinatorDelegate', 'UITextInput', 'UITextInputDelegate', 'UITextInputTokenizer', 'UITextInputTraits', 'UITextInteractionDelegate', 'UITextPasteConfigurationSupporting', 'UITextPasteDelegate', 'UITextPasteItem', 'UITextSelecting', 'UITextViewDelegate', 'UITimingCurveProvider', 'UIToolbarDelegate', 'UITraitEnvironment', 'UIUserActivityRestoring', 'UIVideoEditorControllerDelegate', 'UIViewAnimating', 'UIViewControllerAnimatedTransitioning', 'UIViewControllerContextTransitioning', 'UIViewControllerInteractiveTransitioning', 'UIViewControllerPreviewing', 'UIViewControllerPreviewingDelegate', 'UIViewControllerRestoration', 'UIViewControllerTransitionCoordinator', 'UIViewControllerTransitionCoordinatorContext', 'UIViewControllerTransitioningDelegate', 'UIViewImplicitlyAnimating', 'UIWebViewDelegate', 'UIWindowSceneDelegate', 'UNNotificationContentExtension', 'UNUserNotificationCenterDelegate', 'VNDocumentCameraViewControllerDelegate', 'VNFaceObservationAccepting', 'VNRequestProgressProviding', 'VNRequestRevisionProviding', 'VSAccountManagerDelegate', 'WCSessionDelegate', 'WKHTTPCookieStoreObserver', 'WKNavigationDelegate', 'WKPreviewActionItem', 'WKScriptMessageHandler', 'WKScriptMessageHandlerWithReply', 'WKUIDelegate', 'WKURLSchemeHandler', 'WKURLSchemeTask'} +COCOA_PRIMITIVES = {'ACErrorCode', 'ALCcontext_struct', 'ALCdevice_struct', 'ALMXGlyphEntry', 'ALMXHeader', 'API_UNAVAILABLE', 'AUChannelInfo', 'AUDependentParameter', 'AUDistanceAttenuationData', 'AUHostIdentifier', 'AUHostVersionIdentifier', 'AUInputSamplesInOutputCallbackStruct', 'AUMIDIEvent', 'AUMIDIOutputCallbackStruct', 'AUNodeInteraction', 'AUNodeRenderCallback', 'AUNumVersion', 'AUParameterAutomationEvent', 'AUParameterEvent', 'AUParameterMIDIMapping', 'AUPreset', 'AUPresetEvent', 'AURecordedParameterEvent', 'AURenderCallbackStruct', 'AURenderEventHeader', 'AUSamplerBankPresetData', 'AUSamplerInstrumentData', 'AnchorPoint', 'AnchorPointTable', 'AnkrTable', 'AudioBalanceFade', 'AudioBuffer', 'AudioBufferList', 'AudioBytePacketTranslation', 'AudioChannelDescription', 'AudioChannelLayout', 'AudioClassDescription', 'AudioCodecMagicCookieInfo', 'AudioCodecPrimeInfo', 'AudioComponentDescription', 'AudioComponentPlugInInterface', 'AudioConverterPrimeInfo', 'AudioFileMarker', 'AudioFileMarkerList', 'AudioFilePacketTableInfo', 'AudioFileRegion', 'AudioFileRegionList', 'AudioFileTypeAndFormatID', 'AudioFile_SMPTE_Time', 'AudioFormatInfo', 'AudioFormatListItem', 'AudioFramePacketTranslation', 'AudioIndependentPacketTranslation', 'AudioOutputUnitMIDICallbacks', 'AudioOutputUnitStartAtTimeParams', 'AudioPacketDependencyInfoTranslation', 'AudioPacketRangeByteCountTranslation', 'AudioPacketRollDistanceTranslation', 'AudioPanningInfo', 'AudioQueueBuffer', 'AudioQueueChannelAssignment', 'AudioQueueLevelMeterState', 'AudioQueueParameterEvent', 'AudioStreamBasicDescription', 'AudioStreamPacketDescription', 'AudioTimeStamp', 'AudioUnitCocoaViewInfo', 'AudioUnitConnection', 'AudioUnitExternalBuffer', 'AudioUnitFrequencyResponseBin', 'AudioUnitMIDIControlMapping', 'AudioUnitMeterClipping', 'AudioUnitNodeConnection', 'AudioUnitOtherPluginDesc', 'AudioUnitParameter', 'AudioUnitParameterEvent', 'AudioUnitParameterHistoryInfo', 'AudioUnitParameterInfo', 'AudioUnitParameterNameInfo', 'AudioUnitParameterStringFromValue', 'AudioUnitParameterValueFromString', 'AudioUnitParameterValueName', 'AudioUnitParameterValueTranslation', 'AudioUnitPresetMAS_SettingData', 'AudioUnitPresetMAS_Settings', 'AudioUnitProperty', 'AudioUnitRenderContext', 'AudioValueRange', 'AudioValueTranslation', 'AuthorizationOpaqueRef', 'BslnFormat0Part', 'BslnFormat1Part', 'BslnFormat2Part', 'BslnFormat3Part', 'BslnTable', 'CABarBeatTime', 'CAFAudioDescription', 'CAFChunkHeader', 'CAFDataChunk', 'CAFFileHeader', 'CAFInfoStrings', 'CAFInstrumentChunk', 'CAFMarker', 'CAFMarkerChunk', 'CAFOverviewChunk', 'CAFOverviewSample', 'CAFPacketTableHeader', 'CAFPeakChunk', 'CAFPositionPeak', 'CAFRegion', 'CAFRegionChunk', 'CAFStringID', 'CAFStrings', 'CAFUMIDChunk', 'CAF_SMPTE_Time', 'CAF_UUID_ChunkHeader', 'CA_BOXABLE', 'CFHostClientContext', 'CFNetServiceClientContext', 'CF_BRIDGED_MUTABLE_TYPE', 'CF_BRIDGED_TYPE', 'CF_RELATED_TYPE', 'CGAffineTransform', 'CGDataConsumerCallbacks', 'CGDataProviderDirectCallbacks', 'CGDataProviderSequentialCallbacks', 'CGFunctionCallbacks', 'CGPDFArray', 'CGPDFContentStream', 'CGPDFDictionary', 'CGPDFObject', 'CGPDFOperatorTable', 'CGPDFScanner', 'CGPDFStream', 'CGPDFString', 'CGPathElement', 'CGPatternCallbacks', 'CGVector', 'CG_BOXABLE', 'CLLocationCoordinate2D', 'CM_BRIDGED_TYPE', 'CTParagraphStyleSetting', 'CVPlanarComponentInfo', 'CVPlanarPixelBufferInfo', 'CVPlanarPixelBufferInfo_YCbCrBiPlanar', 'CVPlanarPixelBufferInfo_YCbCrPlanar', 'CVSMPTETime', 'CV_BRIDGED_TYPE', 'ComponentInstanceRecord', 'ExtendedAudioFormatInfo', 'ExtendedControlEvent', 'ExtendedNoteOnEvent', 'ExtendedTempoEvent', 'FontVariation', 'GCQuaternion', 'GKBox', 'GKQuad', 'GKTriangle', 'GLKEffectPropertyPrv', 'HostCallbackInfo', 'IIO_BRIDGED_TYPE', 'IUnknownVTbl', 'JustDirectionTable', 'JustPCAction', 'JustPCActionSubrecord', 'JustPCConditionalAddAction', 'JustPCDecompositionAction', 'JustPCDuctilityAction', 'JustPCGlyphRepeatAddAction', 'JustPostcompTable', 'JustTable', 'JustWidthDeltaEntry', 'JustWidthDeltaGroup', 'KernIndexArrayHeader', 'KernKerningPair', 'KernOffsetTable', 'KernOrderedListEntry', 'KernOrderedListHeader', 'KernSimpleArrayHeader', 'KernStateEntry', 'KernStateHeader', 'KernSubtableHeader', 'KernTableHeader', 'KernVersion0Header', 'KernVersion0SubtableHeader', 'KerxAnchorPointAction', 'KerxControlPointAction', 'KerxControlPointEntry', 'KerxControlPointHeader', 'KerxCoordinateAction', 'KerxIndexArrayHeader', 'KerxKerningPair', 'KerxOrderedListEntry', 'KerxOrderedListHeader', 'KerxSimpleArrayHeader', 'KerxStateEntry', 'KerxStateHeader', 'KerxSubtableHeader', 'KerxTableHeader', 'LcarCaretClassEntry', 'LcarCaretTable', 'LtagStringRange', 'LtagTable', 'MDL_CLASS_EXPORT', 'MIDICIDeviceIdentification', 'MIDIChannelMessage', 'MIDIControlTransform', 'MIDIDriverInterface', 'MIDIEventList', 'MIDIEventPacket', 'MIDIIOErrorNotification', 'MIDIMessage_128', 'MIDIMessage_64', 'MIDIMessage_96', 'MIDIMetaEvent', 'MIDINoteMessage', 'MIDINotification', 'MIDIObjectAddRemoveNotification', 'MIDIObjectPropertyChangeNotification', 'MIDIPacket', 'MIDIPacketList', 'MIDIRawData', 'MIDISysexSendRequest', 'MIDIThruConnectionEndpoint', 'MIDIThruConnectionParams', 'MIDITransform', 'MIDIValueMap', 'MPSDeviceOptions', 'MixerDistanceParams', 'MortChain', 'MortContextualSubtable', 'MortFeatureEntry', 'MortInsertionSubtable', 'MortLigatureSubtable', 'MortRearrangementSubtable', 'MortSubtable', 'MortSwashSubtable', 'MortTable', 'MorxChain', 'MorxContextualSubtable', 'MorxInsertionSubtable', 'MorxLigatureSubtable', 'MorxRearrangementSubtable', 'MorxSubtable', 'MorxTable', 'MusicDeviceNoteParams', 'MusicDeviceStdNoteParams', 'MusicEventUserData', 'MusicTrackLoopInfo', 'NoteParamsControlValue', 'OpaqueAudioComponent', 'OpaqueAudioComponentInstance', 'OpaqueAudioConverter', 'OpaqueAudioQueue', 'OpaqueAudioQueueProcessingTap', 'OpaqueAudioQueueTimeline', 'OpaqueExtAudioFile', 'OpaqueJSClass', 'OpaqueJSContext', 'OpaqueJSContextGroup', 'OpaqueJSPropertyNameAccumulator', 'OpaqueJSPropertyNameArray', 'OpaqueJSString', 'OpaqueJSValue', 'OpaqueMusicEventIterator', 'OpaqueMusicPlayer', 'OpaqueMusicSequence', 'OpaqueMusicTrack', 'OpbdSideValues', 'OpbdTable', 'ParameterEvent', 'PropLookupSegment', 'PropLookupSingle', 'PropTable', 'ROTAGlyphEntry', 'ROTAHeader', 'SCNMatrix4', 'SCNVector3', 'SCNVector4', 'SFNTLookupArrayHeader', 'SFNTLookupBinarySearchHeader', 'SFNTLookupSegment', 'SFNTLookupSegmentHeader', 'SFNTLookupSingle', 'SFNTLookupSingleHeader', 'SFNTLookupTable', 'SFNTLookupTrimmedArrayHeader', 'SFNTLookupVectorHeader', 'SMPTETime', 'STClassTable', 'STEntryOne', 'STEntryTwo', 'STEntryZero', 'STHeader', 'STXEntryOne', 'STXEntryTwo', 'STXEntryZero', 'STXHeader', 'ScheduledAudioFileRegion', 'ScheduledAudioSlice', 'SecKeychainAttribute', 'SecKeychainAttributeInfo', 'SecKeychainAttributeList', 'TrakTable', 'TrakTableData', 'TrakTableEntry', 'UIAccessibility', 'VTDecompressionOutputCallbackRecord', 'VTInt32Point', 'VTInt32Size', '_CFHTTPAuthentication', '_GLKMatrix2', '_GLKMatrix3', '_GLKMatrix4', '_GLKQuaternion', '_GLKVector2', '_GLKVector3', '_GLKVector4', '_GLKVertexAttributeParameters', '_MTLAxisAlignedBoundingBox', '_MTLPackedFloat3', '_MTLPackedFloat4x3', '_NSRange', '_NSZone', '__CFHTTPMessage', '__CFHost', '__CFNetDiagnostic', '__CFNetService', '__CFNetServiceBrowser', '__CFNetServiceMonitor', '__CFXMLNode', '__CFXMLParser', '__GLsync', '__SecAccess', '__SecCertificate', '__SecIdentity', '__SecKey', '__SecRandom', '__attribute__', 'gss_OID_desc_struct', 'gss_OID_set_desc_struct', 'gss_auth_identity', 'gss_buffer_desc_struct', 'gss_buffer_set_desc_struct', 'gss_channel_bindings_struct', 'gss_cred_id_t_desc_struct', 'gss_ctx_id_t_desc_struct', 'gss_iov_buffer_desc_struct', 'gss_krb5_cfx_keydata', 'gss_krb5_lucid_context_v1', 'gss_krb5_lucid_context_version', 'gss_krb5_lucid_key', 'gss_krb5_rfc1964_keydata', 'gss_name_t_desc_struct', 'opaqueCMBufferQueueTriggerToken', 'sfntCMapEncoding', 'sfntCMapExtendedSubHeader', 'sfntCMapHeader', 'sfntCMapSubHeader', 'sfntDescriptorHeader', 'sfntDirectory', 'sfntDirectoryEntry', 'sfntFeatureHeader', 'sfntFeatureName', 'sfntFontDescriptor', 'sfntFontFeatureSetting', 'sfntFontRunFeature', 'sfntInstance', 'sfntNameHeader', 'sfntNameRecord', 'sfntVariationAxis', 'sfntVariationHeader'} + +if __name__ == '__main__': # pragma: no cover + import os + import re + + FRAMEWORKS_PATH = '/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/System/Library/Frameworks/' + frameworks = os.listdir(FRAMEWORKS_PATH) + + all_interfaces = set() + all_protocols = set() + all_primitives = set() + for framework in frameworks: + frameworkHeadersDir = FRAMEWORKS_PATH + framework + '/Headers/' + if not os.path.exists(frameworkHeadersDir): + continue + + headerFilenames = os.listdir(frameworkHeadersDir) + + for f in headerFilenames: + if not f.endswith('.h'): + continue + headerFilePath = frameworkHeadersDir + f + + try: + with open(headerFilePath, encoding='utf-8') as f: + content = f.read() + except UnicodeDecodeError: + print("Decoding error for file: {0}".format(headerFilePath)) + continue + + res = re.findall(r'(?<=@interface )\w+', content) + for r in res: + all_interfaces.add(r) + + res = re.findall(r'(?<=@protocol )\w+', content) + for r in res: + all_protocols.add(r) + + res = re.findall(r'(?<=typedef enum )\w+', content) + for r in res: + all_primitives.add(r) + + res = re.findall(r'(?<=typedef struct )\w+', content) + for r in res: + all_primitives.add(r) + + res = re.findall(r'(?<=typedef const struct )\w+', content) + for r in res: + all_primitives.add(r) + + + print("ALL interfaces: \n") + print(sorted(list(all_interfaces))) + + print("\nALL protocols: \n") + print(sorted(list(all_protocols))) + + print("\nALL primitives: \n") + print(sorted(list(all_primitives))) diff --git a/shared/package-files/2e/2ef98a863233f261da297b610b632fe72919d5df76be8c9fde826977e56e0228/blob b/shared/package-files/2e/2ef98a863233f261da297b610b632fe72919d5df76be8c9fde826977e56e0228/blob new file mode 100644 index 0000000000000000000000000000000000000000..300a16c5741d9ccb751185407694fe49e8da6bc5 --- /dev/null +++ b/shared/package-files/2e/2ef98a863233f261da297b610b632fe72919d5df76be8c9fde826977e56e0228/blob @@ -0,0 +1,180 @@ +# __ +# /__) _ _ _ _ _/ _ +# / ( (- (/ (/ (- _) / _) +# / + +""" +Requests HTTP Library +~~~~~~~~~~~~~~~~~~~~~ + +Requests is an HTTP library, written in Python, for human beings. +Basic GET usage: + + >>> import requests + >>> r = requests.get('https://www.python.org') + >>> r.status_code + 200 + >>> b'Python is a programming language' in r.content + True + +... or POST: + + >>> payload = dict(key1='value1', key2='value2') + >>> r = requests.post('https://httpbin.org/post', data=payload) + >>> print(r.text) + { + ... + "form": { + "key1": "value1", + "key2": "value2" + }, + ... + } + +The other HTTP methods are supported - see `requests.api`. Full documentation +is at . + +:copyright: (c) 2017 by Kenneth Reitz. +:license: Apache 2.0, see LICENSE for more details. +""" + +import warnings + +import urllib3 + +from .exceptions import RequestsDependencyWarning + +try: + from charset_normalizer import __version__ as charset_normalizer_version +except ImportError: + charset_normalizer_version = None + +try: + from chardet import __version__ as chardet_version +except ImportError: + chardet_version = None + + +def check_compatibility(urllib3_version, chardet_version, charset_normalizer_version): + urllib3_version = urllib3_version.split(".") + assert urllib3_version != ["dev"] # Verify urllib3 isn't installed from git. + + # Sometimes, urllib3 only reports its version as 16.1. + if len(urllib3_version) == 2: + urllib3_version.append("0") + + # Check urllib3 for compatibility. + major, minor, patch = urllib3_version # noqa: F811 + major, minor, patch = int(major), int(minor), int(patch) + # urllib3 >= 1.21.1 + assert major >= 1 + if major == 1: + assert minor >= 21 + + # Check charset_normalizer for compatibility. + if chardet_version: + major, minor, patch = chardet_version.split(".")[:3] + major, minor, patch = int(major), int(minor), int(patch) + # chardet_version >= 3.0.2, < 6.0.0 + assert (3, 0, 2) <= (major, minor, patch) < (6, 0, 0) + elif charset_normalizer_version: + major, minor, patch = charset_normalizer_version.split(".")[:3] + major, minor, patch = int(major), int(minor), int(patch) + # charset_normalizer >= 2.0.0 < 4.0.0 + assert (2, 0, 0) <= (major, minor, patch) < (4, 0, 0) + else: + raise Exception("You need either charset_normalizer or chardet installed") + + +def _check_cryptography(cryptography_version): + # cryptography < 1.3.4 + try: + cryptography_version = list(map(int, cryptography_version.split("."))) + except ValueError: + return + + if cryptography_version < [1, 3, 4]: + warning = "Old version of cryptography ({}) may cause slowdown.".format( + cryptography_version + ) + warnings.warn(warning, RequestsDependencyWarning) + + +# Check imported dependencies for compatibility. +try: + check_compatibility( + urllib3.__version__, chardet_version, charset_normalizer_version + ) +except (AssertionError, ValueError): + warnings.warn( + "urllib3 ({}) or chardet ({})/charset_normalizer ({}) doesn't match a supported " + "version!".format( + urllib3.__version__, chardet_version, charset_normalizer_version + ), + RequestsDependencyWarning, + ) + +# Attempt to enable urllib3's fallback for SNI support +# if the standard library doesn't support SNI or the +# 'ssl' library isn't available. +try: + try: + import ssl + except ImportError: + ssl = None + + if not getattr(ssl, "HAS_SNI", False): + from urllib3.contrib import pyopenssl + + pyopenssl.inject_into_urllib3() + + # Check cryptography version + from cryptography import __version__ as cryptography_version + + _check_cryptography(cryptography_version) +except ImportError: + pass + +# urllib3's DependencyWarnings should be silenced. +from urllib3.exceptions import DependencyWarning + +warnings.simplefilter("ignore", DependencyWarning) + +# Set default logging handler to avoid "No handler found" warnings. +import logging +from logging import NullHandler + +from . import packages, utils +from .__version__ import ( + __author__, + __author_email__, + __build__, + __cake__, + __copyright__, + __description__, + __license__, + __title__, + __url__, + __version__, +) +from .api import delete, get, head, options, patch, post, put, request +from .exceptions import ( + ConnectionError, + ConnectTimeout, + FileModeWarning, + HTTPError, + JSONDecodeError, + ReadTimeout, + RequestException, + Timeout, + TooManyRedirects, + URLRequired, +) +from .models import PreparedRequest, Request, Response +from .sessions import Session, session +from .status_codes import codes + +logging.getLogger(__name__).addHandler(NullHandler()) + +# FileModeWarnings go off per the default. +warnings.simplefilter("default", FileModeWarning, append=True) diff --git a/shared/package-files/2e/2efa7f1c597ee5a6810c3a6ef3f438f076cb88da2b025e7b9f787222e7097413/blob b/shared/package-files/2e/2efa7f1c597ee5a6810c3a6ef3f438f076cb88da2b025e7b9f787222e7097413/blob new file mode 100644 index 0000000000000000000000000000000000000000..bb513a906e425c11fa2c2bbf3d91a1e96f81552f --- /dev/null +++ b/shared/package-files/2e/2efa7f1c597ee5a6810c3a6ef3f438f076cb88da2b025e7b9f787222e7097413/blob @@ -0,0 +1,20 @@ +__all__ = [ + "CycleTrendResult", + "bkfilter", + "cffilter", + "convolution_filter", + "hamilton_filter", + "hpfilter", + "miso_lfilter", + "recursive_filter", +] +from .bk_filter import bkfilter +from .cf_filter import cffilter +from .filtertools import ( + CycleTrendResult, + convolution_filter, + miso_lfilter, + recursive_filter, +) +from .hamilton_filter import hamilton_filter +from .hp_filter import hpfilter diff --git a/shared/package-files/2e/2efadd6fed3a22616914cb1260d88427489686cbbe85263b4a25d597ade82981/blob b/shared/package-files/2e/2efadd6fed3a22616914cb1260d88427489686cbbe85263b4a25d597ade82981/blob new file mode 100644 index 0000000000000000000000000000000000000000..72d6eecb15607f83e5c63eae5f689ab7cca9f3ed --- /dev/null +++ b/shared/package-files/2e/2efadd6fed3a22616914cb1260d88427489686cbbe85263b4a25d597ade82981/blob @@ -0,0 +1,198 @@ +# Copyright (C) 2012 Anaconda, Inc +# SPDX-License-Identifier: BSD-3-Clause +# Much of this forked from https://github.com/gforsyth/xonda +# Copyright (c) 2016, Gil Forsyth, All rights reserved. +# Original code licensed under BSD-3-Clause. +from xonsh.lazyasd import lazyobject + +if 'CONDA_EXE' not in ${...}: + ![python -m conda init --dev out> conda-dev-init.sh] + source-bash conda-dev-init.sh + import os + os.remove("conda-dev-init.sh") + +_REACTIVATE_COMMANDS = ('install', 'update', 'upgrade', 'remove', 'uninstall') + + +@lazyobject +def Env(): + from collections import namedtuple + return namedtuple('Env', ['name', 'path', 'bin_dir', 'envs_dir']) + + +def _parse_args(args=None): + from argparse import ArgumentParser + p = ArgumentParser(add_help=False) + p.add_argument('command', nargs='?') + p.add_argument('-h', '--help', dest='help', action='store_true', default=False) + p.add_argument('-v', '--version', dest='version', action='store_true', default=False) + ns, _ = p.parse_known_args(args) + if ns.command == 'activate': + p.add_argument('env_name_or_prefix', default='base') + elif ns.command in _REACTIVATE_COMMANDS: + p.add_argument('-n', '--name') + p.add_argument('-p', '--prefix') + parsed_args, _ = p.parse_known_args(args) + return parsed_args + + +def _raise_pipeline_error(pipeline): + stdout = pipeline.out + stderr = pipeline.err + if pipeline.returncode != 0: + message = ("exited with %s\nstdout: %s\nstderr: %s\n" + "" % (pipeline.returncode, stdout, stderr)) + raise RuntimeError(message) + return stdout.strip() + + +def _conda_activate_handler(env_name_or_prefix): + import os + + __xonsh__.execer.exec($($CONDA_EXE shell.xonsh activate @(env_name_or_prefix)), + glbs=__xonsh__.ctx, + filename="$(conda shell.xonsh activate " + env_name_or_prefix + ")") + if $CONDA_DEFAULT_ENV != os.path.split(env_name_or_prefix)[1]: + import sys as _sys + + print("WARNING: conda environment not activated properly. " + "This is likely because you have a conda init inside of your " + "~/.bashrc (unix) or *.bat activation file (windows). This is " + "causing conda to activate twice in xonsh. Please remove the conda " + "init block from your other shell.", file=_sys.stderr) + + +def _conda_deactivate_handler(): + __xonsh__.execer.exec($($CONDA_EXE shell.xonsh deactivate), + glbs=__xonsh__.ctx, + filename="$(conda shell.xonsh deactivate)") + + +def _conda_passthrough_handler(args): + pipeline = ![$CONDA_EXE @(args)] + _raise_pipeline_error(pipeline) + + +def _conda_reactivate_handler(args, name_or_prefix_given): + pipeline = ![$CONDA_EXE @(args)] + _raise_pipeline_error(pipeline) + if not name_or_prefix_given: + __xonsh__.execer.exec($($CONDA_EXE shell.xonsh reactivate), + glbs=__xonsh__.ctx, + filename="$(conda shell.xonsh reactivate)") + + +def _conda_main(args=None): + parsed_args = _parse_args(args) + if parsed_args.command == 'activate': + _conda_activate_handler(parsed_args.env_name_or_prefix) + elif parsed_args.command == 'deactivate': + _conda_deactivate_handler() + elif parsed_args.command in _REACTIVATE_COMMANDS: + name_or_prefix_given = bool(parsed_args.name or parsed_args.prefix) + _conda_reactivate_handler(args, name_or_prefix_given) + else: + _conda_passthrough_handler(args) + + +if 'CONDA_SHLVL' not in ${...}: + $CONDA_SHLVL = '0' + import os as _os + import sys as _sys + _sys.path.insert(0, _os.path.join(_os.path.dirname(_os.path.dirname($CONDA_EXE)), "condabin")) + del _os, _sys + +aliases['conda'] = _conda_main + + +def _list_dirs(path): + """Generator that lists the directories in a given path.""" + import os + for entry in os.scandir(path): + if not entry.name.startswith('.') and entry.is_dir(): + yield entry.name + + +def _get_envs_unfiltered(): + """Grab a list of all conda env dirs from conda, allowing all warnings.""" + import os + import importlib + + try: + # breaking changes introduced in Anaconda 4.4.7 + # try to import newer library structure first + context = importlib.import_module('conda.base.context') + config = context.context + except ModuleNotFoundError: + config = importlib.import_module('conda.config') + + # create the list of environments + env_list = [] + for envs_dir in config.envs_dirs: + # skip non-existing environments directories + if not os.path.exists(envs_dir): + continue + # for each environment in the environments directory + for env_name in _list_dirs(envs_dir): + # check for duplicates names + if env_name in [env.name for env in env_list]: + raise ValueError('Multiple environments with the same name ' + "in the system is not supported by conda's xonsh tools.") + # add the environment to the list + env_list.append(Env(name=env_name, + path=os.path.join(envs_dir, env_name), + bin_dir=os.path.join(envs_dir, env_name, 'bin'), + envs_dir=envs_dir, + )) + return env_list + + +def _get_envs(): + """Grab a list of all conda env dirs from conda, ignoring all warnings.""" + import warnings + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + return _get_envs_unfiltered() + + +def _conda_completer(prefix, line, start, end, ctx): + """Completion for conda.""" + args = line.split(' ') + possible = set() + if len(args) == 0 or args[0] not in ['xonda', 'conda']: + return None + curix = args.index(prefix) + if curix == 1: + possible = {'activate', 'deactivate', 'install', 'remove', 'info', + 'help', 'list', 'search', 'update', 'upgrade', 'uninstall', + 'config', 'init', 'clean', 'package', 'bundle', 'env', + 'select', 'create', '-h', '--help', '-V', '--version'} + + elif curix == 2: + if args[1] in ['activate', 'select']: + possible = set([env.name for env in _get_envs()]) + elif args[1] == 'create': + possible = {'-p', '-n'} + elif args[1] == 'env': + possible = {'attach', 'create', 'export', 'list', 'remove', + 'upload', 'update'} + + elif curix == 3: + if args[2] == 'export': + possible = {'-n', '--name'} + elif args[2] == 'create': + possible = {'-h', '--help', '-f', '--file', '-n', '--name', '-p', + '--prefix', '-q', '--quiet', '--force', '--json', + '--debug', '-v', '--verbose'} + + elif curix == 4: + if args[2] == 'export' and args[3] in ['-n','--name']: + possible = set([env.name for env in _get_envs()]) + + return {i for i in possible if i.startswith(prefix)} + + +# add _xonda_completer to list of completers +__xonsh__.completers['conda'] = _conda_completer +# bump to top of list +__xonsh__.completers.move_to_end('conda', last=False) diff --git a/shared/package-files/2f/2f013b643d62f08ddaaa1dea39ff80d6607569c9e1acc19406377b64d75ccf53/blob b/shared/package-files/2f/2f013b643d62f08ddaaa1dea39ff80d6607569c9e1acc19406377b64d75ccf53/blob new file mode 100644 index 0000000000000000000000000000000000000000..9b13607710a078ed34458ad8179f1d80c2a2d9c5 --- /dev/null +++ b/shared/package-files/2f/2f013b643d62f08ddaaa1dea39ff80d6607569c9e1acc19406377b64d75ccf53/blob @@ -0,0 +1,782 @@ +# button.tcl -- +# +# This file defines the default bindings for Tk label, button, +# checkbutton, and radiobutton widgets and provides procedures +# that help in implementing those bindings. +# +# Copyright (c) 1992-1994 The Regents of the University of California. +# Copyright (c) 1994-1996 Sun Microsystems, Inc. +# Copyright (c) 2002 ActiveState Corporation. +# +# See the file "license.terms" for information on usage and redistribution +# of this file, and for a DISCLAIMER OF ALL WARRANTIES. +# + +#------------------------------------------------------------------------- +# The code below creates the default class bindings for buttons. +#------------------------------------------------------------------------- + +if {[tk windowingsystem] eq "aqua"} { + + bind Radiobutton { + tk::ButtonEnter %W + } + bind Radiobutton <1> { + tk::ButtonDown %W + } + bind Radiobutton { + tk::ButtonUp %W + } + bind Checkbutton { + tk::ButtonEnter %W + } + bind Checkbutton <1> { + tk::ButtonDown %W + } + bind Checkbutton { + tk::ButtonUp %W + } + bind Checkbutton { + tk::ButtonLeave %W + } +} +if {"win32" eq [tk windowingsystem]} { + bind Checkbutton { + tk::CheckRadioInvoke %W select + } + bind Checkbutton { + tk::CheckRadioInvoke %W select + } + bind Checkbutton { + tk::CheckRadioInvoke %W deselect + } + bind Checkbutton <1> { + tk::CheckRadioDown %W + } + bind Checkbutton { + tk::ButtonUp %W + } + bind Checkbutton { + tk::CheckRadioEnter %W + } + bind Checkbutton { + tk::ButtonLeave %W + } + + bind Radiobutton <1> { + tk::CheckRadioDown %W + } + bind Radiobutton { + tk::ButtonUp %W + } + bind Radiobutton { + tk::CheckRadioEnter %W + } +} +if {"x11" eq [tk windowingsystem]} { + bind Checkbutton { + if {!$tk_strictMotif} { + tk::CheckInvoke %W + } + } + bind Radiobutton { + if {!$tk_strictMotif} { + tk::CheckRadioInvoke %W + } + } + bind Checkbutton <1> { + tk::CheckInvoke %W + } + bind Radiobutton <1> { + tk::CheckRadioInvoke %W + } + bind Checkbutton { + tk::CheckEnter %W + } + bind Radiobutton { + tk::ButtonEnter %W + } + bind Checkbutton { + tk::CheckLeave %W + } +} + +bind Button { + tk::ButtonInvoke %W +} +bind Checkbutton { + tk::CheckRadioInvoke %W +} +bind Radiobutton { + tk::CheckRadioInvoke %W +} +bind Button <> { + tk::ButtonInvoke %W +} +bind Checkbutton <> { + tk::CheckRadioInvoke %W +} +bind Radiobutton <> { + tk::CheckRadioInvoke %W +} + +bind Button {} +bind Button { + tk::ButtonEnter %W +} +bind Button { + tk::ButtonLeave %W +} +bind Button <1> { + tk::ButtonDown %W +} +bind Button { + tk::ButtonUp %W +} + +bind Checkbutton {} + +bind Radiobutton {} +bind Radiobutton { + tk::ButtonLeave %W +} + +if {"win32" eq [tk windowingsystem]} { + +######################### +# Windows implementation +######################### + +# ::tk::ButtonEnter -- +# The procedure below is invoked when the mouse pointer enters a +# button widget. It records the button we're in and changes the +# state of the button to active unless the button is disabled. +# +# Arguments: +# w - The name of the widget. + +proc ::tk::ButtonEnter w { + variable ::tk::Priv + if {[$w cget -state] ne "disabled"} { + + # If the mouse button is down, set the relief to sunken on entry. + # Overwise, if there's an -overrelief value, set the relief to that. + + set Priv($w,relief) [$w cget -relief] + if {$Priv(buttonWindow) eq $w} { + $w configure -relief sunken -state active + set Priv($w,prelief) sunken + } elseif {[set over [$w cget -overrelief]] ne ""} { + $w configure -relief $over + set Priv($w,prelief) $over + } + } + set Priv(window) $w +} + +# ::tk::ButtonLeave -- +# The procedure below is invoked when the mouse pointer leaves a +# button widget. It changes the state of the button back to inactive. +# Restore any modified relief too. +# +# Arguments: +# w - The name of the widget. + +proc ::tk::ButtonLeave w { + variable ::tk::Priv + if {[$w cget -state] ne "disabled"} { + $w configure -state normal + } + + # Restore the original button relief if it was changed by Tk. + # That is signaled by the existence of Priv($w,prelief). + + if {[info exists Priv($w,relief)]} { + if {[info exists Priv($w,prelief)] && \ + $Priv($w,prelief) eq [$w cget -relief]} { + $w configure -relief $Priv($w,relief) + } + unset -nocomplain Priv($w,relief) Priv($w,prelief) + } + + set Priv(window) "" +} + +# ::tk::ButtonDown -- +# The procedure below is invoked when the mouse button is pressed in +# a button widget. It records the fact that the mouse is in the button, +# saves the button's relief so it can be restored later, and changes +# the relief to sunken. +# +# Arguments: +# w - The name of the widget. + +proc ::tk::ButtonDown w { + variable ::tk::Priv + + # Only save the button's relief if it does not yet exist. If there + # is an overrelief setting, Priv($w,relief) will already have been set, + # and the current value of the -relief option will be incorrect. + + if {![info exists Priv($w,relief)]} { + set Priv($w,relief) [$w cget -relief] + } + + if {[$w cget -state] ne "disabled"} { + set Priv(buttonWindow) $w + $w configure -relief sunken -state active + set Priv($w,prelief) sunken + + # If this button has a repeatdelay set up, get it going with an after + after cancel $Priv(afterId) + set delay [$w cget -repeatdelay] + set Priv(repeated) 0 + if {$delay > 0} { + set Priv(afterId) [after $delay [list tk::ButtonAutoInvoke $w]] + } + } +} + +# ::tk::ButtonUp -- +# The procedure below is invoked when the mouse button is released +# in a button widget. It restores the button's relief and invokes +# the command as long as the mouse hasn't left the button. +# +# Arguments: +# w - The name of the widget. + +proc ::tk::ButtonUp w { + variable ::tk::Priv + if {$Priv(buttonWindow) eq $w} { + set Priv(buttonWindow) "" + + # Restore the button's relief if it was cached. + + if {[info exists Priv($w,relief)]} { + if {[info exists Priv($w,prelief)] && \ + $Priv($w,prelief) eq [$w cget -relief]} { + $w configure -relief $Priv($w,relief) + } + unset -nocomplain Priv($w,relief) Priv($w,prelief) + } + + # Clean up the after event from the auto-repeater + after cancel $Priv(afterId) + + if {$Priv(window) eq $w && [$w cget -state] ne "disabled"} { + $w configure -state normal + + # Only invoke the command if it wasn't already invoked by the + # auto-repeater functionality + if { $Priv(repeated) == 0 } { + uplevel #0 [list $w invoke] + } + } + } +} + +# ::tk::CheckRadioEnter -- +# The procedure below is invoked when the mouse pointer enters a +# checkbutton or radiobutton widget. It records the button we're in +# and changes the state of the button to active unless the button is +# disabled. +# +# Arguments: +# w - The name of the widget. + +proc ::tk::CheckRadioEnter w { + variable ::tk::Priv + if {[$w cget -state] ne "disabled"} { + if {$Priv(buttonWindow) eq $w} { + $w configure -state active + } + if {[set over [$w cget -overrelief]] ne ""} { + set Priv($w,relief) [$w cget -relief] + set Priv($w,prelief) $over + $w configure -relief $over + } + } + set Priv(window) $w +} + +# ::tk::CheckRadioDown -- +# The procedure below is invoked when the mouse button is pressed in +# a button widget. It records the fact that the mouse is in the button, +# saves the button's relief so it can be restored later, and changes +# the relief to sunken. +# +# Arguments: +# w - The name of the widget. + +proc ::tk::CheckRadioDown w { + variable ::tk::Priv + if {![info exists Priv($w,relief)]} { + set Priv($w,relief) [$w cget -relief] + } + if {[$w cget -state] ne "disabled"} { + set Priv(buttonWindow) $w + set Priv(repeated) 0 + $w configure -state active + } +} + +} + +if {"x11" eq [tk windowingsystem]} { + +##################### +# Unix implementation +##################### + +# ::tk::ButtonEnter -- +# The procedure below is invoked when the mouse pointer enters a +# button widget. It records the button we're in and changes the +# state of the button to active unless the button is disabled. +# +# Arguments: +# w - The name of the widget. + +proc ::tk::ButtonEnter {w} { + variable ::tk::Priv + if {[$w cget -state] ne "disabled"} { + # On unix the state is active just with mouse-over + $w configure -state active + + # If the mouse button is down, set the relief to sunken on entry. + # Overwise, if there's an -overrelief value, set the relief to that. + + set Priv($w,relief) [$w cget -relief] + if {$Priv(buttonWindow) eq $w} { + $w configure -relief sunken + set Priv($w,prelief) sunken + } elseif {[set over [$w cget -overrelief]] ne ""} { + $w configure -relief $over + set Priv($w,prelief) $over + } + } + set Priv(window) $w +} + +# ::tk::ButtonLeave -- +# The procedure below is invoked when the mouse pointer leaves a +# button widget. It changes the state of the button back to inactive. +# Restore any modified relief too. +# +# Arguments: +# w - The name of the widget. + +proc ::tk::ButtonLeave w { + variable ::tk::Priv + if {[$w cget -state] ne "disabled"} { + $w configure -state normal + } + + # Restore the original button relief if it was changed by Tk. + # That is signaled by the existence of Priv($w,prelief). + + if {[info exists Priv($w,relief)]} { + if {[info exists Priv($w,prelief)] && \ + $Priv($w,prelief) eq [$w cget -relief]} { + $w configure -relief $Priv($w,relief) + } + unset -nocomplain Priv($w,relief) Priv($w,prelief) + } + + set Priv(window) "" +} + +# ::tk::ButtonDown -- +# The procedure below is invoked when the mouse button is pressed in +# a button widget. It records the fact that the mouse is in the button, +# saves the button's relief so it can be restored later, and changes +# the relief to sunken. +# +# Arguments: +# w - The name of the widget. + +proc ::tk::ButtonDown w { + variable ::tk::Priv + + # Only save the button's relief if it does not yet exist. If there + # is an overrelief setting, Priv($w,relief) will already have been set, + # and the current value of the -relief option will be incorrect. + + if {![info exists Priv($w,relief)]} { + set Priv($w,relief) [$w cget -relief] + } + + if {[$w cget -state] ne "disabled"} { + set Priv(buttonWindow) $w + $w configure -relief sunken + set Priv($w,prelief) sunken + + # If this button has a repeatdelay set up, get it going with an after + after cancel $Priv(afterId) + set delay [$w cget -repeatdelay] + set Priv(repeated) 0 + if {$delay > 0} { + set Priv(afterId) [after $delay [list tk::ButtonAutoInvoke $w]] + } + } +} + +# ::tk::ButtonUp -- +# The procedure below is invoked when the mouse button is released +# in a button widget. It restores the button's relief and invokes +# the command as long as the mouse hasn't left the button. +# +# Arguments: +# w - The name of the widget. + +proc ::tk::ButtonUp w { + variable ::tk::Priv + if {$w eq $Priv(buttonWindow)} { + set Priv(buttonWindow) "" + + # Restore the button's relief if it was cached. + + if {[info exists Priv($w,relief)]} { + if {[info exists Priv($w,prelief)] && \ + $Priv($w,prelief) eq [$w cget -relief]} { + $w configure -relief $Priv($w,relief) + } + unset -nocomplain Priv($w,relief) Priv($w,prelief) + } + + # Clean up the after event from the auto-repeater + after cancel $Priv(afterId) + + if {$Priv(window) eq $w && [$w cget -state] ne "disabled"} { + # Only invoke the command if it wasn't already invoked by the + # auto-repeater functionality + if { $Priv(repeated) == 0 } { + uplevel #0 [list $w invoke] + } + } + } +} + +} + +if {[tk windowingsystem] eq "aqua"} { + +#################### +# Mac implementation +#################### + +# ::tk::ButtonEnter -- +# The procedure below is invoked when the mouse pointer enters a +# button widget. It records the button we're in and changes the +# state of the button to active unless the button is disabled. +# +# Arguments: +# w - The name of the widget. + +proc ::tk::ButtonEnter {w} { + variable ::tk::Priv + if {[$w cget -state] ne "disabled"} { + + # If there's an -overrelief value, set the relief to that. + + if {$Priv(buttonWindow) eq $w} { + $w configure -state active + } elseif {[set over [$w cget -overrelief]] ne ""} { + set Priv($w,relief) [$w cget -relief] + set Priv($w,prelief) $over + $w configure -relief $over + } + } + set Priv(window) $w +} + +# ::tk::ButtonLeave -- +# The procedure below is invoked when the mouse pointer leaves a +# button widget. It changes the state of the button back to +# inactive. If we're leaving the button window with a mouse button +# pressed (Priv(buttonWindow) == $w), restore the relief of the +# button too. +# +# Arguments: +# w - The name of the widget. + +proc ::tk::ButtonLeave w { + variable ::tk::Priv + if {$w eq $Priv(buttonWindow)} { + $w configure -state normal + } + + # Restore the original button relief if it was changed by Tk. + # That is signaled by the existence of Priv($w,prelief). + + if {[info exists Priv($w,relief)]} { + if {[info exists Priv($w,prelief)] && \ + $Priv($w,prelief) eq [$w cget -relief]} { + $w configure -relief $Priv($w,relief) + } + unset -nocomplain Priv($w,relief) Priv($w,prelief) + } + + set Priv(window) "" +} + +# ::tk::ButtonDown -- +# The procedure below is invoked when the mouse button is pressed in +# a button widget. It records the fact that the mouse is in the button, +# saves the button's relief so it can be restored later, and changes +# the relief to sunken. +# +# Arguments: +# w - The name of the widget. + +proc ::tk::ButtonDown w { + variable ::tk::Priv + + if {[$w cget -state] ne "disabled"} { + set Priv(buttonWindow) $w + $w configure -state active + + # If this button has a repeatdelay set up, get it going with an after + after cancel $Priv(afterId) + set Priv(repeated) 0 + if { ![catch {$w cget -repeatdelay} delay] } { + if {$delay > 0} { + set Priv(afterId) [after $delay [list tk::ButtonAutoInvoke $w]] + } + } + } +} + +# ::tk::ButtonUp -- +# The procedure below is invoked when the mouse button is released +# in a button widget. It restores the button's relief and invokes +# the command as long as the mouse hasn't left the button. +# +# Arguments: +# w - The name of the widget. + +proc ::tk::ButtonUp w { + variable ::tk::Priv + if {$Priv(buttonWindow) eq $w} { + set Priv(buttonWindow) "" + $w configure -state normal + + # Restore the button's relief if it was cached. + + if {[info exists Priv($w,relief)]} { + if {[info exists Priv($w,prelief)] && \ + $Priv($w,prelief) eq [$w cget -relief]} { + $w configure -relief $Priv($w,relief) + } + unset -nocomplain Priv($w,relief) Priv($w,prelief) + } + + # Clean up the after event from the auto-repeater + after cancel $Priv(afterId) + + if {$Priv(window) eq $w && [$w cget -state] ne "disabled"} { + # Only invoke the command if it wasn't already invoked by the + # auto-repeater functionality + if { $Priv(repeated) == 0 } { + uplevel #0 [list $w invoke] + } + } + } +} + +} + +################## +# Shared routines +################## + +# ::tk::ButtonInvoke -- +# The procedure below is called when a button is invoked through +# the keyboard. It simulate a press of the button via the mouse. +# +# Arguments: +# w - The name of the widget. + +proc ::tk::ButtonInvoke w { + if {[winfo exists $w] && [$w cget -state] ne "disabled"} { + set oldRelief [$w cget -relief] + set oldState [$w cget -state] + $w configure -state active -relief sunken + after 100 [list ::tk::ButtonInvokeEnd $w $oldState $oldRelief] + } +} + +# ::tk::ButtonInvokeEnd -- +# The procedure below is called after a button is invoked through +# the keyboard. It simulate a release of the button via the mouse. +# +# Arguments: +# w - The name of the widget. +# oldState - Old state to be set back. +# oldRelief - Old relief to be set back. + +proc ::tk::ButtonInvokeEnd {w oldState oldRelief} { + if {[winfo exists $w]} { + $w configure -state $oldState -relief $oldRelief + uplevel #0 [list $w invoke] + } +} + +# ::tk::ButtonAutoInvoke -- +# +# Invoke an auto-repeating button, and set it up to continue to repeat. +# +# Arguments: +# w button to invoke. +# +# Results: +# None. +# +# Side effects: +# May create an after event to call ::tk::ButtonAutoInvoke. + +proc ::tk::ButtonAutoInvoke {w} { + variable ::tk::Priv + after cancel $Priv(afterId) + set delay [$w cget -repeatinterval] + if {$Priv(window) eq $w} { + incr Priv(repeated) + uplevel #0 [list $w invoke] + } + if {$delay > 0} { + set Priv(afterId) [after $delay [list tk::ButtonAutoInvoke $w]] + } +} + +# ::tk::CheckRadioInvoke -- +# The procedure below is invoked when the mouse button is pressed in +# a checkbutton or radiobutton widget, or when the widget is invoked +# through the keyboard. It invokes the widget if it +# isn't disabled. +# +# Arguments: +# w - The name of the widget. +# cmd - The subcommand to invoke (one of invoke, select, or deselect). + +proc ::tk::CheckRadioInvoke {w {cmd invoke}} { + if {[$w cget -state] ne "disabled"} { + uplevel #0 [list $w $cmd] + } +} + +# Special versions of the handlers for checkbuttons on Unix that do the magic +# to make things work right when the checkbutton indicator is hidden; +# radiobuttons don't need this complexity. + +# ::tk::CheckInvoke -- +# The procedure below invokes the checkbutton, like ButtonInvoke, but handles +# what to do when the checkbutton indicator is missing. Only used on Unix. +# +# Arguments: +# w - The name of the widget. + +proc ::tk::CheckInvoke {w} { + variable ::tk::Priv + if {[$w cget -state] ne "disabled"} { + # Additional logic to switch the "selected" colors around if necessary + # (when we're indicator-less). + + if {![$w cget -indicatoron] && [info exist Priv($w,selectcolor)]} { + if {[$w cget -selectcolor] eq $Priv($w,aselectcolor)} { + $w configure -selectcolor $Priv($w,selectcolor) + } else { + $w configure -selectcolor $Priv($w,aselectcolor) + } + } + uplevel #0 [list $w invoke] + } +} + +# ::tk::CheckEnter -- +# The procedure below enters the checkbutton, like ButtonEnter, but handles +# what to do when the checkbutton indicator is missing. Only used on Unix. +# +# Arguments: +# w - The name of the widget. + +proc ::tk::CheckEnter {w} { + variable ::tk::Priv + if {[$w cget -state] ne "disabled"} { + # On unix the state is active just with mouse-over + $w configure -state active + + # If the mouse button is down, set the relief to sunken on entry. + # Overwise, if there's an -overrelief value, set the relief to that. + + set Priv($w,relief) [$w cget -relief] + if {$Priv(buttonWindow) eq $w} { + $w configure -relief sunken + set Priv($w,prelief) sunken + } elseif {[set over [$w cget -overrelief]] ne ""} { + $w configure -relief $over + set Priv($w,prelief) $over + } + + # Compute what the "selected and active" color should be. + + if {![$w cget -indicatoron] && [$w cget -selectcolor] ne ""} { + set Priv($w,selectcolor) [$w cget -selectcolor] + lassign [winfo rgb $w [$w cget -selectcolor]] r1 g1 b1 + lassign [winfo rgb $w [$w cget -activebackground]] r2 g2 b2 + set Priv($w,aselectcolor) \ + [format "#%04x%04x%04x" [expr {($r1+$r2)/2}] \ + [expr {($g1+$g2)/2}] [expr {($b1+$b2)/2}]] + # use uplevel to work with other var resolvers + if {[uplevel #0 [list set [$w cget -variable]]] + eq [$w cget -onvalue]} { + $w configure -selectcolor $Priv($w,aselectcolor) + } + } + } + set Priv(window) $w +} + +# ::tk::CheckLeave -- +# The procedure below leaves the checkbutton, like ButtonLeave, but handles +# what to do when the checkbutton indicator is missing. Only used on Unix. +# +# Arguments: +# w - The name of the widget. + +proc ::tk::CheckLeave {w} { + variable ::tk::Priv + if {[$w cget -state] ne "disabled"} { + $w configure -state normal + } + + # Restore the original button "selected" color; but only if the user + # has not changed it in the meantime. + + if {![$w cget -indicatoron] && [info exist Priv($w,selectcolor)]} { + if {[$w cget -selectcolor] eq $Priv($w,selectcolor) + || ([info exist Priv($w,aselectcolor)] && + [$w cget -selectcolor] eq $Priv($w,aselectcolor))} { + $w configure -selectcolor $Priv($w,selectcolor) + } + } + unset -nocomplain Priv($w,selectcolor) Priv($w,aselectcolor) + + # Restore the original button relief if it was changed by Tk. That is + # signaled by the existence of Priv($w,prelief). + + if {[info exists Priv($w,relief)]} { + if {[info exists Priv($w,prelief)] && \ + $Priv($w,prelief) eq [$w cget -relief]} { + $w configure -relief $Priv($w,relief) + } + unset -nocomplain Priv($w,relief) Priv($w,prelief) + } + + set Priv(window) "" +} + +return + +# Local Variables: +# mode: tcl +# fill-column: 78 +# End: diff --git a/shared/package-files/2f/2f05996827309ef6147f8b888352a1b9911678e70dc9046bd5363dab7733a329/blob b/shared/package-files/2f/2f05996827309ef6147f8b888352a1b9911678e70dc9046bd5363dab7733a329/blob new file mode 100644 index 0000000000000000000000000000000000000000..0f835a9cc1d010b29fbb4f21f1d107a90bf6b6f7 --- /dev/null +++ b/shared/package-files/2f/2f05996827309ef6147f8b888352a1b9911678e70dc9046bd5363dab7733a329/blob @@ -0,0 +1,502 @@ +""" +An auto-completion window for IDLE, used by the autocomplete extension +""" +import platform + +from tkinter import * +from tkinter.ttk import Scrollbar + +from idlelib.autocomplete import FILES, ATTRS +from idlelib.multicall import MC_SHIFT + +HIDE_VIRTUAL_EVENT_NAME = "<>" +HIDE_FOCUS_OUT_SEQUENCE = "" +HIDE_SEQUENCES = (HIDE_FOCUS_OUT_SEQUENCE, "") +KEYPRESS_VIRTUAL_EVENT_NAME = "<>" +# We need to bind event beyond so that the function will be called +# before the default specific IDLE function +KEYPRESS_SEQUENCES = ("", "", "", "", + "", "", "", "", + "", "", "") +KEYRELEASE_VIRTUAL_EVENT_NAME = "<>" +KEYRELEASE_SEQUENCE = "" +LISTUPDATE_SEQUENCE = "" +WINCONFIG_SEQUENCE = "" +DOUBLECLICK_SEQUENCE = "" + +class AutoCompleteWindow: + + def __init__(self, widget, tags): + # The widget (Text) on which we place the AutoCompleteWindow + self.widget = widget + # Tags to mark inserted text with + self.tags = tags + # The widgets we create + self.autocompletewindow = self.listbox = self.scrollbar = None + # The default foreground and background of a selection. Saved because + # they are changed to the regular colors of list items when the + # completion start is not a prefix of the selected completion + self.origselforeground = self.origselbackground = None + # The list of completions + self.completions = None + # A list with more completions, or None + self.morecompletions = None + # The completion mode, either autocomplete.ATTRS or .FILES. + self.mode = None + # The current completion start, on the text box (a string) + self.start = None + # The index of the start of the completion + self.startindex = None + # The last typed start, used so that when the selection changes, + # the new start will be as close as possible to the last typed one. + self.lasttypedstart = None + # Do we have an indication that the user wants the completion window + # (for example, he clicked the list) + self.userwantswindow = None + # event ids + self.hideid = self.keypressid = self.listupdateid = \ + self.winconfigid = self.keyreleaseid = self.doubleclickid = None + # Flag set if last keypress was a tab + self.lastkey_was_tab = False + # Flag set to avoid recursive callback invocations. + self.is_configuring = False + + def _change_start(self, newstart): + min_len = min(len(self.start), len(newstart)) + i = 0 + while i < min_len and self.start[i] == newstart[i]: + i += 1 + if i < len(self.start): + self.widget.delete("%s+%dc" % (self.startindex, i), + "%s+%dc" % (self.startindex, len(self.start))) + if i < len(newstart): + self.widget.insert("%s+%dc" % (self.startindex, i), + newstart[i:], + self.tags) + self.start = newstart + + def _binary_search(self, s): + """Find the first index in self.completions where completions[i] is + greater or equal to s, or the last index if there is no such. + """ + i = 0; j = len(self.completions) + while j > i: + m = (i + j) // 2 + if self.completions[m] >= s: + j = m + else: + i = m + 1 + return min(i, len(self.completions)-1) + + def _complete_string(self, s): + """Assuming that s is the prefix of a string in self.completions, + return the longest string which is a prefix of all the strings which + s is a prefix of them. If s is not a prefix of a string, return s. + """ + first = self._binary_search(s) + if self.completions[first][:len(s)] != s: + # There is not even one completion which s is a prefix of. + return s + # Find the end of the range of completions where s is a prefix of. + i = first + 1 + j = len(self.completions) + while j > i: + m = (i + j) // 2 + if self.completions[m][:len(s)] != s: + j = m + else: + i = m + 1 + last = i-1 + + if first == last: # only one possible completion + return self.completions[first] + + # We should return the maximum prefix of first and last + first_comp = self.completions[first] + last_comp = self.completions[last] + min_len = min(len(first_comp), len(last_comp)) + i = len(s) + while i < min_len and first_comp[i] == last_comp[i]: + i += 1 + return first_comp[:i] + + def _selection_changed(self): + """Call when the selection of the Listbox has changed. + + Updates the Listbox display and calls _change_start. + """ + cursel = int(self.listbox.curselection()[0]) + + self.listbox.see(cursel) + + lts = self.lasttypedstart + selstart = self.completions[cursel] + if self._binary_search(lts) == cursel: + newstart = lts + else: + min_len = min(len(lts), len(selstart)) + i = 0 + while i < min_len and lts[i] == selstart[i]: + i += 1 + newstart = selstart[:i] + self._change_start(newstart) + + if self.completions[cursel][:len(self.start)] == self.start: + # start is a prefix of the selected completion + self.listbox.configure(selectbackground=self.origselbackground, + selectforeground=self.origselforeground) + else: + self.listbox.configure(selectbackground=self.listbox.cget("bg"), + selectforeground=self.listbox.cget("fg")) + # If there are more completions, show them, and call me again. + if self.morecompletions: + self.completions = self.morecompletions + self.morecompletions = None + self.listbox.delete(0, END) + for item in self.completions: + self.listbox.insert(END, item) + self.listbox.select_set(self._binary_search(self.start)) + self._selection_changed() + + def show_window(self, comp_lists, index, complete, mode, userWantsWin): + """Show the autocomplete list, bind events. + + If complete is True, complete the text, and if there is exactly + one matching completion, don't open a list. + """ + # Handle the start we already have + self.completions, self.morecompletions = comp_lists + self.mode = mode + self.startindex = self.widget.index(index) + self.start = self.widget.get(self.startindex, "insert") + if complete: + completed = self._complete_string(self.start) + start = self.start + self._change_start(completed) + i = self._binary_search(completed) + if self.completions[i] == completed and \ + (i == len(self.completions)-1 or + self.completions[i+1][:len(completed)] != completed): + # There is exactly one matching completion + return completed == start + self.userwantswindow = userWantsWin + self.lasttypedstart = self.start + + # Put widgets in place + self.autocompletewindow = acw = Toplevel(self.widget) + # Put it in a position so that it is not seen. + acw.wm_geometry("+10000+10000") + # Make it float + acw.wm_overrideredirect(1) + try: + # This command is only needed and available on Tk >= 8.4.0 for OSX + # Without it, call tips intrude on the typing process by grabbing + # the focus. + acw.tk.call("::tk::unsupported::MacWindowStyle", "style", acw._w, + "help", "noActivates") + except TclError: + pass + self.scrollbar = scrollbar = Scrollbar(acw, orient=VERTICAL) + self.listbox = listbox = Listbox(acw, yscrollcommand=scrollbar.set, + exportselection=False) + for item in self.completions: + listbox.insert(END, item) + self.origselforeground = listbox.cget("selectforeground") + self.origselbackground = listbox.cget("selectbackground") + scrollbar.config(command=listbox.yview) + scrollbar.pack(side=RIGHT, fill=Y) + listbox.pack(side=LEFT, fill=BOTH, expand=True) + #acw.update_idletasks() # Need for tk8.6.8 on macOS: #40128. + acw.lift() # work around bug in Tk 8.5.18+ (issue #24570) + + # Initialize the listbox selection + self.listbox.select_set(self._binary_search(self.start)) + self._selection_changed() + + # bind events + self.hideaid = acw.bind(HIDE_VIRTUAL_EVENT_NAME, self.hide_event) + self.hidewid = self.widget.bind(HIDE_VIRTUAL_EVENT_NAME, self.hide_event) + acw.event_add(HIDE_VIRTUAL_EVENT_NAME, HIDE_FOCUS_OUT_SEQUENCE) + for seq in HIDE_SEQUENCES: + self.widget.event_add(HIDE_VIRTUAL_EVENT_NAME, seq) + + self.keypressid = self.widget.bind(KEYPRESS_VIRTUAL_EVENT_NAME, + self.keypress_event) + for seq in KEYPRESS_SEQUENCES: + self.widget.event_add(KEYPRESS_VIRTUAL_EVENT_NAME, seq) + self.keyreleaseid = self.widget.bind(KEYRELEASE_VIRTUAL_EVENT_NAME, + self.keyrelease_event) + self.widget.event_add(KEYRELEASE_VIRTUAL_EVENT_NAME,KEYRELEASE_SEQUENCE) + self.listupdateid = listbox.bind(LISTUPDATE_SEQUENCE, + self.listselect_event) + self.is_configuring = False + self.winconfigid = acw.bind(WINCONFIG_SEQUENCE, self.winconfig_event) + self.doubleclickid = listbox.bind(DOUBLECLICK_SEQUENCE, + self.doubleclick_event) + return None + + def winconfig_event(self, event): + if self.is_configuring: + # Avoid running on recursive callback invocations. + return + + self.is_configuring = True + if not self.is_active(): + return + + # Since the event may occur after the completion window is gone, + # catch potential TclError exceptions when accessing acw. See: bpo-41611. + try: + # Position the completion list window + text = self.widget + text.see(self.startindex) + x, y, cx, cy = text.bbox(self.startindex) + acw = self.autocompletewindow + if platform.system().startswith('Windows'): + # On Windows an update() call is needed for the completion + # list window to be created, so that we can fetch its width + # and height. However, this is not needed on other platforms + # (tested on Ubuntu and macOS) but at one point began + # causing freezes on macOS. See issues 37849 and 41611. + acw.update() + acw_width, acw_height = acw.winfo_width(), acw.winfo_height() + text_width, text_height = text.winfo_width(), text.winfo_height() + new_x = text.winfo_rootx() + min(x, max(0, text_width - acw_width)) + new_y = text.winfo_rooty() + y + if (text_height - (y + cy) >= acw_height # enough height below + or y < acw_height): # not enough height above + # place acw below current line + new_y += cy + else: + # place acw above current line + new_y -= acw_height + acw.wm_geometry("+%d+%d" % (new_x, new_y)) + acw.update_idletasks() + except TclError: + pass + + if platform.system().startswith('Windows'): + # See issue 15786. When on Windows platform, Tk will misbehave + # to call winconfig_event multiple times, we need to prevent this, + # otherwise mouse button double click will not be able to used. + try: + acw.unbind(WINCONFIG_SEQUENCE, self.winconfigid) + except TclError: + pass + self.winconfigid = None + + self.is_configuring = False + + def _hide_event_check(self): + if not self.autocompletewindow: + return + + try: + if not self.autocompletewindow.focus_get(): + self.hide_window() + except KeyError: + # See issue 734176, when user click on menu, acw.focus_get() + # will get KeyError. + self.hide_window() + + def hide_event(self, event): + # Hide autocomplete list if it exists and does not have focus or + # mouse click on widget / text area. + if self.is_active(): + if event.type == EventType.FocusOut: + # On Windows platform, it will need to delay the check for + # acw.focus_get() when click on acw, otherwise it will return + # None and close the window + self.widget.after(1, self._hide_event_check) + elif event.type == EventType.ButtonPress: + # ButtonPress event only bind to self.widget + self.hide_window() + + def listselect_event(self, event): + if self.is_active(): + self.userwantswindow = True + cursel = int(self.listbox.curselection()[0]) + self._change_start(self.completions[cursel]) + + def doubleclick_event(self, event): + # Put the selected completion in the text, and close the list + cursel = int(self.listbox.curselection()[0]) + self._change_start(self.completions[cursel]) + self.hide_window() + + def keypress_event(self, event): + if not self.is_active(): + return None + keysym = event.keysym + if hasattr(event, "mc_state"): + state = event.mc_state + else: + state = 0 + if keysym != "Tab": + self.lastkey_was_tab = False + if (len(keysym) == 1 or keysym in ("underscore", "BackSpace") + or (self.mode == FILES and keysym in + ("period", "minus"))) \ + and not (state & ~MC_SHIFT): + # Normal editing of text + if len(keysym) == 1: + self._change_start(self.start + keysym) + elif keysym == "underscore": + self._change_start(self.start + '_') + elif keysym == "period": + self._change_start(self.start + '.') + elif keysym == "minus": + self._change_start(self.start + '-') + else: + # keysym == "BackSpace" + if len(self.start) == 0: + self.hide_window() + return None + self._change_start(self.start[:-1]) + self.lasttypedstart = self.start + self.listbox.select_clear(0, int(self.listbox.curselection()[0])) + self.listbox.select_set(self._binary_search(self.start)) + self._selection_changed() + return "break" + + elif keysym == "Return": + self.complete() + self.hide_window() + return 'break' + + elif (self.mode == ATTRS and keysym in + ("period", "space", "parenleft", "parenright", "bracketleft", + "bracketright")) or \ + (self.mode == FILES and keysym in + ("slash", "backslash", "quotedbl", "apostrophe")) \ + and not (state & ~MC_SHIFT): + # If start is a prefix of the selection, but is not '' when + # completing file names, put the whole + # selected completion. Anyway, close the list. + cursel = int(self.listbox.curselection()[0]) + if self.completions[cursel][:len(self.start)] == self.start \ + and (self.mode == ATTRS or self.start): + self._change_start(self.completions[cursel]) + self.hide_window() + return None + + elif keysym in ("Home", "End", "Prior", "Next", "Up", "Down") and \ + not state: + # Move the selection in the listbox + self.userwantswindow = True + cursel = int(self.listbox.curselection()[0]) + if keysym == "Home": + newsel = 0 + elif keysym == "End": + newsel = len(self.completions)-1 + elif keysym in ("Prior", "Next"): + jump = self.listbox.nearest(self.listbox.winfo_height()) - \ + self.listbox.nearest(0) + if keysym == "Prior": + newsel = max(0, cursel-jump) + else: + assert keysym == "Next" + newsel = min(len(self.completions)-1, cursel+jump) + elif keysym == "Up": + newsel = max(0, cursel-1) + else: + assert keysym == "Down" + newsel = min(len(self.completions)-1, cursel+1) + self.listbox.select_clear(cursel) + self.listbox.select_set(newsel) + self._selection_changed() + self._change_start(self.completions[newsel]) + return "break" + + elif (keysym == "Tab" and not state): + if self.lastkey_was_tab: + # two tabs in a row; insert current selection and close acw + cursel = int(self.listbox.curselection()[0]) + self._change_start(self.completions[cursel]) + self.hide_window() + return "break" + else: + # first tab; let AutoComplete handle the completion + self.userwantswindow = True + self.lastkey_was_tab = True + return None + + elif any(s in keysym for s in ("Shift", "Control", "Alt", + "Meta", "Command", "Option")): + # A modifier key, so ignore + return None + + elif event.char and event.char >= ' ': + # Regular character with a non-length-1 keycode + self._change_start(self.start + event.char) + self.lasttypedstart = self.start + self.listbox.select_clear(0, int(self.listbox.curselection()[0])) + self.listbox.select_set(self._binary_search(self.start)) + self._selection_changed() + return "break" + + else: + # Unknown event, close the window and let it through. + self.hide_window() + return None + + def keyrelease_event(self, event): + if not self.is_active(): + return + if self.widget.index("insert") != \ + self.widget.index("%s+%dc" % (self.startindex, len(self.start))): + # If we didn't catch an event which moved the insert, close window + self.hide_window() + + def is_active(self): + return self.autocompletewindow is not None + + def complete(self): + self._change_start(self._complete_string(self.start)) + # The selection doesn't change. + + def hide_window(self): + if not self.is_active(): + return + + # unbind events + self.autocompletewindow.event_delete(HIDE_VIRTUAL_EVENT_NAME, + HIDE_FOCUS_OUT_SEQUENCE) + for seq in HIDE_SEQUENCES: + self.widget.event_delete(HIDE_VIRTUAL_EVENT_NAME, seq) + + self.autocompletewindow.unbind(HIDE_VIRTUAL_EVENT_NAME, self.hideaid) + self.widget.unbind(HIDE_VIRTUAL_EVENT_NAME, self.hidewid) + self.hideaid = None + self.hidewid = None + for seq in KEYPRESS_SEQUENCES: + self.widget.event_delete(KEYPRESS_VIRTUAL_EVENT_NAME, seq) + self.widget.unbind(KEYPRESS_VIRTUAL_EVENT_NAME, self.keypressid) + self.keypressid = None + self.widget.event_delete(KEYRELEASE_VIRTUAL_EVENT_NAME, + KEYRELEASE_SEQUENCE) + self.widget.unbind(KEYRELEASE_VIRTUAL_EVENT_NAME, self.keyreleaseid) + self.keyreleaseid = None + self.listbox.unbind(LISTUPDATE_SEQUENCE, self.listupdateid) + self.listupdateid = None + if self.winconfigid: + self.autocompletewindow.unbind(WINCONFIG_SEQUENCE, self.winconfigid) + self.winconfigid = None + + # Re-focusOn frame.text (See issue #15786) + self.widget.focus_set() + + # destroy widgets + self.scrollbar.destroy() + self.scrollbar = None + self.listbox.destroy() + self.listbox = None + self.autocompletewindow.destroy() + self.autocompletewindow = None + + +if __name__ == '__main__': + from unittest import main + main('idlelib.idle_test.test_autocomplete_w', verbosity=2, exit=False) + +# TODO: autocomplete/w htest here diff --git a/shared/package-files/2f/2f06cf92c73403524c6e2e979ee3dd301527f375fb04fb85356a8f184288ebdf/blob b/shared/package-files/2f/2f06cf92c73403524c6e2e979ee3dd301527f375fb04fb85356a8f184288ebdf/blob new file mode 100644 index 0000000000000000000000000000000000000000..fef52aa103ea369c96567b9af2a5a0ba14db5cb9 --- /dev/null +++ b/shared/package-files/2f/2f06cf92c73403524c6e2e979ee3dd301527f375fb04fb85356a8f184288ebdf/blob @@ -0,0 +1,358 @@ +# -*- coding: utf-8 -*- +# +# Copyright (C) 2013-2017 Vinay Sajip. +# Licensed to the Python Software Foundation under a contributor agreement. +# See LICENSE.txt and CONTRIBUTORS.txt. +# +from __future__ import unicode_literals + +import bisect +import io +import logging +import os +import pkgutil +import sys +import types +import zipimport + +from . import DistlibException +from .util import cached_property, get_cache_base, Cache + +logger = logging.getLogger(__name__) + + +cache = None # created when needed + + +class ResourceCache(Cache): + def __init__(self, base=None): + if base is None: + # Use native string to avoid issues on 2.x: see Python #20140. + base = os.path.join(get_cache_base(), str('resource-cache')) + super(ResourceCache, self).__init__(base) + + def is_stale(self, resource, path): + """ + Is the cache stale for the given resource? + + :param resource: The :class:`Resource` being cached. + :param path: The path of the resource in the cache. + :return: True if the cache is stale. + """ + # Cache invalidation is a hard problem :-) + return True + + def get(self, resource): + """ + Get a resource into the cache, + + :param resource: A :class:`Resource` instance. + :return: The pathname of the resource in the cache. + """ + prefix, path = resource.finder.get_cache_info(resource) + if prefix is None: + result = path + else: + result = os.path.join(self.base, self.prefix_to_dir(prefix), path) + dirname = os.path.dirname(result) + if not os.path.isdir(dirname): + os.makedirs(dirname) + if not os.path.exists(result): + stale = True + else: + stale = self.is_stale(resource, path) + if stale: + # write the bytes of the resource to the cache location + with open(result, 'wb') as f: + f.write(resource.bytes) + return result + + +class ResourceBase(object): + def __init__(self, finder, name): + self.finder = finder + self.name = name + + +class Resource(ResourceBase): + """ + A class representing an in-package resource, such as a data file. This is + not normally instantiated by user code, but rather by a + :class:`ResourceFinder` which manages the resource. + """ + is_container = False # Backwards compatibility + + def as_stream(self): + """ + Get the resource as a stream. + + This is not a property to make it obvious that it returns a new stream + each time. + """ + return self.finder.get_stream(self) + + @cached_property + def file_path(self): + global cache + if cache is None: + cache = ResourceCache() + return cache.get(self) + + @cached_property + def bytes(self): + return self.finder.get_bytes(self) + + @cached_property + def size(self): + return self.finder.get_size(self) + + +class ResourceContainer(ResourceBase): + is_container = True # Backwards compatibility + + @cached_property + def resources(self): + return self.finder.get_resources(self) + + +class ResourceFinder(object): + """ + Resource finder for file system resources. + """ + + if sys.platform.startswith('java'): + skipped_extensions = ('.pyc', '.pyo', '.class') + else: + skipped_extensions = ('.pyc', '.pyo') + + def __init__(self, module): + self.module = module + self.loader = getattr(module, '__loader__', None) + self.base = os.path.dirname(getattr(module, '__file__', '')) + + def _adjust_path(self, path): + return os.path.realpath(path) + + def _make_path(self, resource_name): + # Issue #50: need to preserve type of path on Python 2.x + # like os.path._get_sep + if isinstance(resource_name, bytes): # should only happen on 2.x + sep = b'/' + else: + sep = '/' + parts = resource_name.split(sep) + parts.insert(0, self.base) + result = os.path.join(*parts) + return self._adjust_path(result) + + def _find(self, path): + return os.path.exists(path) + + def get_cache_info(self, resource): + return None, resource.path + + def find(self, resource_name): + path = self._make_path(resource_name) + if not self._find(path): + result = None + else: + if self._is_directory(path): + result = ResourceContainer(self, resource_name) + else: + result = Resource(self, resource_name) + result.path = path + return result + + def get_stream(self, resource): + return open(resource.path, 'rb') + + def get_bytes(self, resource): + with open(resource.path, 'rb') as f: + return f.read() + + def get_size(self, resource): + return os.path.getsize(resource.path) + + def get_resources(self, resource): + def allowed(f): + return (f != '__pycache__' and not + f.endswith(self.skipped_extensions)) + return set([f for f in os.listdir(resource.path) if allowed(f)]) + + def is_container(self, resource): + return self._is_directory(resource.path) + + _is_directory = staticmethod(os.path.isdir) + + def iterator(self, resource_name): + resource = self.find(resource_name) + if resource is not None: + todo = [resource] + while todo: + resource = todo.pop(0) + yield resource + if resource.is_container: + rname = resource.name + for name in resource.resources: + if not rname: + new_name = name + else: + new_name = '/'.join([rname, name]) + child = self.find(new_name) + if child.is_container: + todo.append(child) + else: + yield child + + +class ZipResourceFinder(ResourceFinder): + """ + Resource finder for resources in .zip files. + """ + def __init__(self, module): + super(ZipResourceFinder, self).__init__(module) + archive = self.loader.archive + self.prefix_len = 1 + len(archive) + # PyPy doesn't have a _files attr on zipimporter, and you can't set one + if hasattr(self.loader, '_files'): + self._files = self.loader._files + else: + self._files = zipimport._zip_directory_cache[archive] + self.index = sorted(self._files) + + def _adjust_path(self, path): + return path + + def _find(self, path): + path = path[self.prefix_len:] + if path in self._files: + result = True + else: + if path and path[-1] != os.sep: + path = path + os.sep + i = bisect.bisect(self.index, path) + try: + result = self.index[i].startswith(path) + except IndexError: + result = False + if not result: + logger.debug('_find failed: %r %r', path, self.loader.prefix) + else: + logger.debug('_find worked: %r %r', path, self.loader.prefix) + return result + + def get_cache_info(self, resource): + prefix = self.loader.archive + path = resource.path[1 + len(prefix):] + return prefix, path + + def get_bytes(self, resource): + return self.loader.get_data(resource.path) + + def get_stream(self, resource): + return io.BytesIO(self.get_bytes(resource)) + + def get_size(self, resource): + path = resource.path[self.prefix_len:] + return self._files[path][3] + + def get_resources(self, resource): + path = resource.path[self.prefix_len:] + if path and path[-1] != os.sep: + path += os.sep + plen = len(path) + result = set() + i = bisect.bisect(self.index, path) + while i < len(self.index): + if not self.index[i].startswith(path): + break + s = self.index[i][plen:] + result.add(s.split(os.sep, 1)[0]) # only immediate children + i += 1 + return result + + def _is_directory(self, path): + path = path[self.prefix_len:] + if path and path[-1] != os.sep: + path += os.sep + i = bisect.bisect(self.index, path) + try: + result = self.index[i].startswith(path) + except IndexError: + result = False + return result + + +_finder_registry = { + type(None): ResourceFinder, + zipimport.zipimporter: ZipResourceFinder +} + +try: + # In Python 3.6, _frozen_importlib -> _frozen_importlib_external + try: + import _frozen_importlib_external as _fi + except ImportError: + import _frozen_importlib as _fi + _finder_registry[_fi.SourceFileLoader] = ResourceFinder + _finder_registry[_fi.FileFinder] = ResourceFinder + # See issue #146 + _finder_registry[_fi.SourcelessFileLoader] = ResourceFinder + del _fi +except (ImportError, AttributeError): + pass + + +def register_finder(loader, finder_maker): + _finder_registry[type(loader)] = finder_maker + + +_finder_cache = {} + + +def finder(package): + """ + Return a resource finder for a package. + :param package: The name of the package. + :return: A :class:`ResourceFinder` instance for the package. + """ + if package in _finder_cache: + result = _finder_cache[package] + else: + if package not in sys.modules: + __import__(package) + module = sys.modules[package] + path = getattr(module, '__path__', None) + if path is None: + raise DistlibException('You cannot get a finder for a module, ' + 'only for a package') + loader = getattr(module, '__loader__', None) + finder_maker = _finder_registry.get(type(loader)) + if finder_maker is None: + raise DistlibException('Unable to locate finder for %r' % package) + result = finder_maker(module) + _finder_cache[package] = result + return result + + +_dummy_module = types.ModuleType(str('__dummy__')) + + +def finder_for_path(path): + """ + Return a resource finder for a path, which should represent a container. + + :param path: The path. + :return: A :class:`ResourceFinder` instance for the path. + """ + result = None + # calls any path hooks, gets importer into cache + pkgutil.get_importer(path) + loader = sys.path_importer_cache.get(path) + finder = _finder_registry.get(type(loader)) + if finder: + module = _dummy_module + module.__file__ = os.path.join(path, '') + module.__loader__ = loader + result = finder(module) + return result diff --git a/shared/package-files/2f/2f0736cde1927dcdc89f9d51386930184edfc8b799a08c1fcfdff5bdbe720bd6/blob b/shared/package-files/2f/2f0736cde1927dcdc89f9d51386930184edfc8b799a08c1fcfdff5bdbe720bd6/blob new file mode 100644 index 0000000000000000000000000000000000000000..e9101e2f2b541b55a91a24d62031f29bcf114af0 --- /dev/null +++ b/shared/package-files/2f/2f0736cde1927dcdc89f9d51386930184edfc8b799a08c1fcfdff5bdbe720bd6/blob @@ -0,0 +1,24 @@ +# See issue: https://github.com/numba/numba/issues/4348 +# this file must be run in isolation to replicate, test: +# numba.tests.test_parallel_backend.TestInitSafetyIssues.test_orphaned_semaphore +# does this to check semaphores are not leaking. + +import multiprocessing as mp + +import numba # noqa, deliberately unused, here to test import is safe + + +def w(): + pass + + +def main(): + ps = [mp.Process(target=w) for _ in range(4)] + [p.start() for p in ps] + [p.join() for p in ps] + + +if __name__ == '__main__': + p = mp.get_context('spawn').Process(target=main) + p.start() + p.join() diff --git a/shared/package-files/2f/2f0ce74a6651250b7fb037aafe5717b145e54b2adc13c27e73082f8bdb1a5038/blob b/shared/package-files/2f/2f0ce74a6651250b7fb037aafe5717b145e54b2adc13c27e73082f8bdb1a5038/blob new file mode 100644 index 0000000000000000000000000000000000000000..6402743a0855c367e082f770c1b4b1c55d841e10 --- /dev/null +++ b/shared/package-files/2f/2f0ce74a6651250b7fb037aafe5717b145e54b2adc13c27e73082f8bdb1a5038/blob @@ -0,0 +1,155 @@ +from functools import reduce +import operator + +from sympy.core import Basic, sympify +from sympy.core.add import add, Add, _could_extract_minus_sign +from sympy.core.sorting import default_sort_key +from sympy.functions import adjoint +from sympy.matrices.matrices import MatrixBase +from sympy.matrices.expressions.transpose import transpose +from sympy.strategies import (rm_id, unpack, flatten, sort, condition, + exhaust, do_one, glom) +from sympy.matrices.expressions.matexpr import MatrixExpr +from sympy.matrices.expressions.special import ZeroMatrix, GenericZeroMatrix +from sympy.matrices.expressions._shape import validate_matadd_integer as validate +from sympy.utilities.iterables import sift +from sympy.utilities.exceptions import sympy_deprecation_warning + +# XXX: MatAdd should perhaps not subclass directly from Add +class MatAdd(MatrixExpr, Add): + """A Sum of Matrix Expressions + + MatAdd inherits from and operates like SymPy Add + + Examples + ======== + + >>> from sympy import MatAdd, MatrixSymbol + >>> A = MatrixSymbol('A', 5, 5) + >>> B = MatrixSymbol('B', 5, 5) + >>> C = MatrixSymbol('C', 5, 5) + >>> MatAdd(A, B, C) + A + B + C + """ + is_MatAdd = True + + identity = GenericZeroMatrix() + + def __new__(cls, *args, evaluate=False, check=None, _sympify=True): + if not args: + return cls.identity + + # This must be removed aggressively in the constructor to avoid + # TypeErrors from GenericZeroMatrix().shape + args = list(filter(lambda i: cls.identity != i, args)) + if _sympify: + args = list(map(sympify, args)) + + if not all(isinstance(arg, MatrixExpr) for arg in args): + raise TypeError("Mix of Matrix and Scalar symbols") + + obj = Basic.__new__(cls, *args) + + if check is not None: + sympy_deprecation_warning( + "Passing check to MatAdd is deprecated and the check argument will be removed in a future version.", + deprecated_since_version="1.11", + active_deprecations_target='remove-check-argument-from-matrix-operations') + + if check is not False: + validate(*args) + + if evaluate: + obj = cls._evaluate(obj) + + return obj + + @classmethod + def _evaluate(cls, expr): + return canonicalize(expr) + + @property + def shape(self): + return self.args[0].shape + + def could_extract_minus_sign(self): + return _could_extract_minus_sign(self) + + def expand(self, **kwargs): + expanded = super(MatAdd, self).expand(**kwargs) + return self._evaluate(expanded) + + def _entry(self, i, j, **kwargs): + return Add(*[arg._entry(i, j, **kwargs) for arg in self.args]) + + def _eval_transpose(self): + return MatAdd(*[transpose(arg) for arg in self.args]).doit() + + def _eval_adjoint(self): + return MatAdd(*[adjoint(arg) for arg in self.args]).doit() + + def _eval_trace(self): + from .trace import trace + return Add(*[trace(arg) for arg in self.args]).doit() + + def doit(self, **hints): + deep = hints.get('deep', True) + if deep: + args = [arg.doit(**hints) for arg in self.args] + else: + args = self.args + return canonicalize(MatAdd(*args)) + + def _eval_derivative_matrix_lines(self, x): + add_lines = [arg._eval_derivative_matrix_lines(x) for arg in self.args] + return [j for i in add_lines for j in i] + +add.register_handlerclass((Add, MatAdd), MatAdd) + + +factor_of = lambda arg: arg.as_coeff_mmul()[0] +matrix_of = lambda arg: unpack(arg.as_coeff_mmul()[1]) +def combine(cnt, mat): + if cnt == 1: + return mat + else: + return cnt * mat + + +def merge_explicit(matadd): + """ Merge explicit MatrixBase arguments + + Examples + ======== + + >>> from sympy import MatrixSymbol, eye, Matrix, MatAdd, pprint + >>> from sympy.matrices.expressions.matadd import merge_explicit + >>> A = MatrixSymbol('A', 2, 2) + >>> B = eye(2) + >>> C = Matrix([[1, 2], [3, 4]]) + >>> X = MatAdd(A, B, C) + >>> pprint(X) + [1 0] [1 2] + A + [ ] + [ ] + [0 1] [3 4] + >>> pprint(merge_explicit(X)) + [2 2] + A + [ ] + [3 5] + """ + groups = sift(matadd.args, lambda arg: isinstance(arg, MatrixBase)) + if len(groups[True]) > 1: + return MatAdd(*(groups[False] + [reduce(operator.add, groups[True])])) + else: + return matadd + + +rules = (rm_id(lambda x: x == 0 or isinstance(x, ZeroMatrix)), + unpack, + flatten, + glom(matrix_of, factor_of, combine), + merge_explicit, + sort(default_sort_key)) + +canonicalize = exhaust(condition(lambda x: isinstance(x, MatAdd), + do_one(*rules))) diff --git a/shared/package-files/2f/2f10f360c7d258592ff45545e1eeb2d6d9fb8782e927ad1ad8a305c620b051d9/blob b/shared/package-files/2f/2f10f360c7d258592ff45545e1eeb2d6d9fb8782e927ad1ad8a305c620b051d9/blob new file mode 100644 index 0000000000000000000000000000000000000000..8c4d8f91146198cccd658af25b8f644742c82a5a --- /dev/null +++ b/shared/package-files/2f/2f10f360c7d258592ff45545e1eeb2d6d9fb8782e927ad1ad8a305c620b051d9/blob @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API ::std::tuple kthvalue_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, int64_t k, int64_t dim=-1, bool keepdim=false); +TORCH_API ::std::tuple kthvalue_outf(const at::Tensor & self, int64_t k, int64_t dim, bool keepdim, at::Tensor & values, at::Tensor & indices); + +} // namespace cuda +} // namespace at diff --git a/shared/package-files/2f/2f14ca60b34aa1fe4eb74472bef0c67f6ebb3ca0f330422ba3b56604112c8eb7/blob b/shared/package-files/2f/2f14ca60b34aa1fe4eb74472bef0c67f6ebb3ca0f330422ba3b56604112c8eb7/blob new file mode 100644 index 0000000000000000000000000000000000000000..3a199140045dea9eec651952a05003f4f2af60e2 --- /dev/null +++ b/shared/package-files/2f/2f14ca60b34aa1fe4eb74472bef0c67f6ebb3ca0f330422ba3b56604112c8eb7/blob @@ -0,0 +1,28 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API _neg_view { + using schema = at::Tensor (const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_neg_view") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_neg_view(Tensor(a) self) -> Tensor(a)") + static at::Tensor call(const at::Tensor & self); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/2f/2f1680df52493e6fe2c45e93c3bf54c862083c6f61fe121d12b136c1e25455af/blob b/shared/package-files/2f/2f1680df52493e6fe2c45e93c3bf54c862083c6f61fe121d12b136c1e25455af/blob new file mode 100644 index 0000000000000000000000000000000000000000..ec852764e1b940f141eee456d0bfc73133987ffa --- /dev/null +++ b/shared/package-files/2f/2f1680df52493e6fe2c45e93c3bf54c862083c6f61fe121d12b136c1e25455af/blob @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor _log_softmax(const at::Tensor & self, int64_t dim, bool half_to_float); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/shared/package-files/2f/2f187cba1a96733fece94ea773fead777d3897ae5d6a0d53657d77ea818e5d0a/blob b/shared/package-files/2f/2f187cba1a96733fece94ea773fead777d3897ae5d6a0d53657d77ea818e5d0a/blob new file mode 100644 index 0000000000000000000000000000000000000000..cc3ccb557a36c70125efef1f069968702a39adc9 Binary files /dev/null and b/shared/package-files/2f/2f187cba1a96733fece94ea773fead777d3897ae5d6a0d53657d77ea818e5d0a/blob differ diff --git a/shared/package-files/2f/2f18f5678a355ad613e625431baf9bdb856b57a580e75f8d67704a48f2da9216/blob b/shared/package-files/2f/2f18f5678a355ad613e625431baf9bdb856b57a580e75f8d67704a48f2da9216/blob new file mode 100644 index 0000000000000000000000000000000000000000..02645788b0b8eebe115c6b41a78f7553b4ad7e7c --- /dev/null +++ b/shared/package-files/2f/2f18f5678a355ad613e625431baf9bdb856b57a580e75f8d67704a48f2da9216/blob @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor nextafter(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & nextafter_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & nextafter_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); +TORCH_API at::Tensor & nextafter_(at::Tensor & self, const at::Tensor & other); + +} // namespace cuda +} // namespace at diff --git a/shared/package-files/2f/2f1a92c18f01c13c9a89908fb86a7309ae5b89a882db9914114957bc4b6fed92/blob b/shared/package-files/2f/2f1a92c18f01c13c9a89908fb86a7309ae5b89a882db9914114957bc4b6fed92/blob new file mode 100644 index 0000000000000000000000000000000000000000..0ac3eb4db4afc304563eb9424ebd8f5d8e2a38e0 --- /dev/null +++ b/shared/package-files/2f/2f1a92c18f01c13c9a89908fb86a7309ae5b89a882db9914114957bc4b6fed92/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2f1a92c18f01c13c9a89908fb86a7309ae5b89a882db9914114957bc4b6fed92 +size 143648 diff --git a/shared/package-files/2f/2f1ab65c656a235e4c98392bb5fd5cdb618f8fe3a67f679aa493f19a434db280/blob b/shared/package-files/2f/2f1ab65c656a235e4c98392bb5fd5cdb618f8fe3a67f679aa493f19a434db280/blob new file mode 100644 index 0000000000000000000000000000000000000000..7278d4c587d1663b1b9e2d4fb7387158206b3489 --- /dev/null +++ b/shared/package-files/2f/2f1ab65c656a235e4c98392bb5fd5cdb618f8fe3a67f679aa493f19a434db280/blob @@ -0,0 +1,1826 @@ +from collections import defaultdict, namedtuple +from contextlib import contextmanager +from copy import deepcopy, copy +import warnings + +from numba.core.compiler_machinery import (FunctionPass, AnalysisPass, + SSACompliantMixin, register_pass) +from numba.core import (errors, types, ir, bytecode, postproc, rewrites, config, + transforms, consts) +from numba.misc.special import literal_unroll +from numba.core.analysis import (dead_branch_prune, rewrite_semantic_constants, + find_literally_calls, compute_cfg_from_blocks, + compute_use_defs) +from numba.core.ir_utils import (guard, resolve_func_from_module, simplify_CFG, + GuardException, convert_code_obj_to_function, + build_definitions, + replace_var_names, get_name_var_table, + compile_to_numba_ir, get_definition, + find_max_label, rename_labels, + transfer_scope, fixup_var_define_in_scope, + ) +from numba.core.ssa import reconstruct_ssa +from numba.core import interpreter + + +@contextmanager +def fallback_context(state, msg): + """ + Wraps code that would signal a fallback to object mode + """ + try: + yield + except Exception as e: + if not state.status.can_fallback: + raise + else: + # Clear all references attached to the traceback + e = e.with_traceback(None) + # this emits a warning containing the error message body in the + # case of fallback from npm to objmode + loop_lift = '' if state.flags.enable_looplift else 'OUT' + msg_rewrite = ("\nCompilation is falling back to object mode " + "WITH%s looplifting enabled because %s" + % (loop_lift, msg)) + warnings.warn_explicit('%s due to: %s' % (msg_rewrite, e), + errors.NumbaWarning, + state.func_id.filename, + state.func_id.firstlineno) + raise + + +@register_pass(mutates_CFG=True, analysis_only=False) +class ExtractByteCode(FunctionPass): + _name = "extract_bytecode" + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + """ + Extract bytecode from function + """ + func_id = state['func_id'] + bc = bytecode.ByteCode(func_id) + if config.DUMP_BYTECODE: + print(bc.dump()) + + state['bc'] = bc + return True + + +@register_pass(mutates_CFG=True, analysis_only=False) +class TranslateByteCode(FunctionPass): + _name = "translate_bytecode" + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + """ + Analyze bytecode and translating to Numba IR + """ + func_id = state['func_id'] + bc = state['bc'] + interp = interpreter.Interpreter(func_id) + func_ir = interp.interpret(bc) + state["func_ir"] = func_ir + return True + + +@register_pass(mutates_CFG=True, analysis_only=False) +class FixupArgs(FunctionPass): + _name = "fixup_args" + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + state['nargs'] = state['func_ir'].arg_count + if not state['args'] and state['flags'].force_pyobject: + # Allow an empty argument types specification when object mode + # is explicitly requested. + state['args'] = (types.pyobject,) * state['nargs'] + elif len(state['args']) != state['nargs']: + raise TypeError("Signature mismatch: %d argument types given, " + "but function takes %d arguments" + % (len(state['args']), state['nargs'])) + return True + + +@register_pass(mutates_CFG=True, analysis_only=False) +class IRProcessing(FunctionPass): + _name = "ir_processing" + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + func_ir = state['func_ir'] + post_proc = postproc.PostProcessor(func_ir) + post_proc.run() + + if config.DEBUG or config.DUMP_IR: + name = func_ir.func_id.func_qualname + print(("IR DUMP: %s" % name).center(80, "-")) + func_ir.dump() + if func_ir.is_generator: + print(("GENERATOR INFO: %s" % name).center(80, "-")) + func_ir.dump_generator_info() + return True + + +@register_pass(mutates_CFG=True, analysis_only=False) +class RewriteSemanticConstants(FunctionPass): + _name = "rewrite_semantic_constants" + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + """ + This prunes dead branches, a dead branch is one which is derivable as + not taken at compile time purely based on const/literal evaluation. + """ + assert state.func_ir + msg = ('Internal error in pre-inference dead branch pruning ' + 'pass encountered during compilation of ' + 'function "%s"' % (state.func_id.func_name,)) + with fallback_context(state, msg): + rewrite_semantic_constants(state.func_ir, state.args) + + return True + + +@register_pass(mutates_CFG=True, analysis_only=False) +class DeadBranchPrune(SSACompliantMixin, FunctionPass): + _name = "dead_branch_prune" + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + """ + This prunes dead branches, a dead branch is one which is derivable as + not taken at compile time purely based on const/literal evaluation. + """ + + # purely for demonstration purposes, obtain the analysis from a pass + # declare as a required dependent + semantic_const_analysis = self.get_analysis(type(self)) # noqa + + assert state.func_ir + msg = ('Internal error in pre-inference dead branch pruning ' + 'pass encountered during compilation of ' + 'function "%s"' % (state.func_id.func_name,)) + with fallback_context(state, msg): + dead_branch_prune(state.func_ir, state.args) + + return True + + def get_analysis_usage(self, AU): + AU.add_required(RewriteSemanticConstants) + + +@register_pass(mutates_CFG=True, analysis_only=False) +class InlineClosureLikes(FunctionPass): + _name = "inline_closure_likes" + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + # Ensure we have an IR and type information. + assert state.func_ir + + # if the return type is a pyobject, there's no type info available and + # no ability to resolve certain typed function calls in the array + # inlining code, use this variable to indicate + typed_pass = not isinstance(state.return_type, types.misc.PyObject) + from numba.core.inline_closurecall import InlineClosureCallPass + inline_pass = InlineClosureCallPass( + state.func_ir, + state.flags.auto_parallel, + state.parfor_diagnostics.replaced_fns, + typed_pass) + inline_pass.run() + + # Remove all Dels, and re-run postproc + post_proc = postproc.PostProcessor(state.func_ir) + post_proc.run() + + fixup_var_define_in_scope(state.func_ir.blocks) + + return True + + +@register_pass(mutates_CFG=True, analysis_only=False) +class GenericRewrites(FunctionPass): + _name = "generic_rewrites" + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + """ + Perform any intermediate representation rewrites before type + inference. + """ + assert state.func_ir + msg = ('Internal error in pre-inference rewriting ' + 'pass encountered during compilation of ' + 'function "%s"' % (state.func_id.func_name,)) + with fallback_context(state, msg): + rewrites.rewrite_registry.apply('before-inference', state) + return True + + +@register_pass(mutates_CFG=True, analysis_only=False) +class WithLifting(FunctionPass): + _name = "with_lifting" + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + """ + Extract with-contexts + """ + main, withs = transforms.with_lifting( + func_ir=state.func_ir, + typingctx=state.typingctx, + targetctx=state.targetctx, + flags=state.flags, + locals=state.locals, + ) + if withs: + from numba.core.compiler import compile_ir, _EarlyPipelineCompletion + cres = compile_ir(state.typingctx, state.targetctx, main, + state.args, state.return_type, + state.flags, state.locals, + lifted=tuple(withs), lifted_from=None, + pipeline_class=type(state.pipeline)) + raise _EarlyPipelineCompletion(cres) + return True + + +@register_pass(mutates_CFG=True, analysis_only=False) +class InlineInlinables(FunctionPass): + """ + This pass will inline a function wrapped by the numba.jit decorator directly + into the site of its call depending on the value set in the 'inline' kwarg + to the decorator. + + This is an untyped pass. CFG simplification is performed at the end of the + pass but no block level clean up is performed on the mutated IR (typing + information is not available to do so). + """ + _name = "inline_inlinables" + _DEBUG = False + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + """Run inlining of inlinables + """ + if self._DEBUG: + print('before inline'.center(80, '-')) + print(state.func_ir.dump()) + print(''.center(80, '-')) + + from numba.core.inline_closurecall import (InlineWorker, + callee_ir_validator) + inline_worker = InlineWorker(state.typingctx, + state.targetctx, + state.locals, + state.pipeline, + state.flags, + validator=callee_ir_validator) + + modified = False + # use a work list, look for call sites via `ir.Expr.op == call` and + # then pass these to `self._do_work` to make decisions about inlining. + work_list = list(state.func_ir.blocks.items()) + while work_list: + label, block = work_list.pop() + for i, instr in enumerate(block.body): + if isinstance(instr, ir.Assign): + expr = instr.value + if isinstance(expr, ir.Expr) and expr.op == 'call': + if guard(self._do_work, state, work_list, block, i, + expr, inline_worker): + modified = True + break # because block structure changed + + if modified: + # clean up unconditional branches that appear due to inlined + # functions introducing blocks + cfg = compute_cfg_from_blocks(state.func_ir.blocks) + for dead in cfg.dead_nodes(): + del state.func_ir.blocks[dead] + post_proc = postproc.PostProcessor(state.func_ir) + post_proc.run() + state.func_ir.blocks = simplify_CFG(state.func_ir.blocks) + + if self._DEBUG: + print('after inline'.center(80, '-')) + print(state.func_ir.dump()) + print(''.center(80, '-')) + return True + + def _do_work(self, state, work_list, block, i, expr, inline_worker): + from numba.core.compiler import run_frontend + from numba.core.cpu import InlineOptions + + # try and get a definition for the call, this isn't always possible as + # it might be a eval(str)/part generated awaiting update etc. (parfors) + to_inline = None + try: + to_inline = state.func_ir.get_definition(expr.func) + except Exception: + if self._DEBUG: + print("Cannot find definition for %s" % expr.func) + return False + # do not handle closure inlining here, another pass deals with that. + if getattr(to_inline, 'op', False) == 'make_function': + return False + + # see if the definition is a "getattr", in which case walk the IR to + # try and find the python function via the module from which it's + # imported, this should all be encoded in the IR. + if getattr(to_inline, 'op', False) == 'getattr': + val = resolve_func_from_module(state.func_ir, to_inline) + else: + # This is likely a freevar or global + # + # NOTE: getattr 'value' on a call may fail if it's an ir.Expr as + # getattr is overloaded to look in _kws. + try: + val = getattr(to_inline, 'value', False) + except Exception: + raise GuardException + + # if something was found... + if val: + # check it's dispatcher-like, the targetoptions attr holds the + # kwargs supplied in the jit decorator and is where 'inline' will + # be if it is present. + topt = getattr(val, 'targetoptions', False) + if topt: + inline_type = topt.get('inline', None) + # has 'inline' been specified? + if inline_type is not None: + inline_opt = InlineOptions(inline_type) + # Could this be inlinable? + if not inline_opt.is_never_inline: + # yes, it could be inlinable + do_inline = True + pyfunc = val.py_func + # Has it got an associated cost model? + if inline_opt.has_cost_model: + # yes, it has a cost model, use it to determine + # whether to do the inline + py_func_ir = run_frontend(pyfunc) + do_inline = inline_type(expr, state.func_ir, + py_func_ir) + # if do_inline is True then inline! + if do_inline: + _, _, _, new_blocks = \ + inline_worker.inline_function(state.func_ir, + block, i, pyfunc,) + if work_list is not None: + for blk in new_blocks: + work_list.append(blk) + return True + return False + + +@register_pass(mutates_CFG=False, analysis_only=False) +class PreserveIR(AnalysisPass): + """ + Preserves the IR in the metadata + """ + + _name = "preserve_ir" + + def __init__(self): + AnalysisPass.__init__(self) + + def run_pass(self, state): + state.metadata['preserved_ir'] = state.func_ir.copy() + return False + + +@register_pass(mutates_CFG=False, analysis_only=True) +class FindLiterallyCalls(FunctionPass): + """Find calls to `numba.literally()` and signal if its requirement is not + satisfied. + """ + _name = "find_literally" + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + find_literally_calls(state.func_ir, state.args) + return False + + +@register_pass(mutates_CFG=True, analysis_only=False) +class CanonicalizeLoopExit(FunctionPass): + """A pass to canonicalize loop exit by splitting it from function exit. + """ + _name = "canonicalize_loop_exit" + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + fir = state.func_ir + cfg = compute_cfg_from_blocks(fir.blocks) + status = False + for loop in cfg.loops().values(): + for exit_label in loop.exits: + if exit_label in cfg.exit_points(): + self._split_exit_block(fir, cfg, exit_label) + status = True + + fir._reset_analysis_variables() + + vlt = postproc.VariableLifetime(fir.blocks) + fir.variable_lifetime = vlt + return status + + def _split_exit_block(self, fir, cfg, exit_label): + curblock = fir.blocks[exit_label] + newlabel = exit_label + 1 + newlabel = find_max_label(fir.blocks) + 1 + fir.blocks[newlabel] = curblock + newblock = ir.Block(scope=curblock.scope, loc=curblock.loc) + newblock.append(ir.Jump(newlabel, loc=curblock.loc)) + fir.blocks[exit_label] = newblock + # Rename all labels + fir.blocks = rename_labels(fir.blocks) + + +@register_pass(mutates_CFG=True, analysis_only=False) +class CanonicalizeLoopEntry(FunctionPass): + """A pass to canonicalize loop header by splitting it from function entry. + + This is needed for loop-lifting; esp in py3.8 + """ + _name = "canonicalize_loop_entry" + _supported_globals = {range, enumerate, zip} + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + fir = state.func_ir + cfg = compute_cfg_from_blocks(fir.blocks) + status = False + for loop in cfg.loops().values(): + if len(loop.entries) == 1: + [entry_label] = loop.entries + if entry_label == cfg.entry_point(): + self._split_entry_block(fir, cfg, loop, entry_label) + status = True + fir._reset_analysis_variables() + + vlt = postproc.VariableLifetime(fir.blocks) + fir.variable_lifetime = vlt + return status + + def _split_entry_block(self, fir, cfg, loop, entry_label): + # Find iterator inputs into the for-loop header + header_block = fir.blocks[loop.header] + deps = set() + for expr in header_block.find_exprs(op="iternext"): + deps.add(expr.value) + # Find the getiter for each iterator + entry_block = fir.blocks[entry_label] + + # Find the start of loop entry statement that needs to be included. + startpt = None + list_of_insts = list(entry_block.find_insts(ir.Assign)) + for assign in reversed(list_of_insts): + if assign.target in deps: + rhs = assign.value + if isinstance(rhs, ir.Var): + if rhs.is_temp: + deps.add(rhs) + elif isinstance(rhs, ir.Expr): + expr = rhs + if expr.op == 'getiter': + startpt = assign + if expr.value.is_temp: + deps.add(expr.value) + elif expr.op == 'call': + defn = guard(get_definition, fir, expr.func) + if isinstance(defn, ir.Global): + if expr.func.is_temp: + deps.add(expr.func) + elif (isinstance(rhs, ir.Global) + and rhs.value in self._supported_globals): + startpt = assign + + if startpt is None: + return + + splitpt = entry_block.body.index(startpt) + new_block = entry_block.copy() + new_block.body = new_block.body[splitpt:] + new_block.loc = new_block.body[0].loc + new_label = find_max_label(fir.blocks) + 1 + entry_block.body = entry_block.body[:splitpt] + entry_block.append(ir.Jump(new_label, loc=new_block.loc)) + + fir.blocks[new_label] = new_block + # Rename all labels + fir.blocks = rename_labels(fir.blocks) + + +@register_pass(mutates_CFG=False, analysis_only=True) +class PrintIRCFG(FunctionPass): + _name = "print_ir_cfg" + + def __init__(self): + FunctionPass.__init__(self) + self._ver = 0 + + def run_pass(self, state): + fir = state.func_ir + self._ver += 1 + fir.render_dot(filename_prefix='v{}'.format(self._ver)).render() + return False + + +@register_pass(mutates_CFG=True, analysis_only=False) +class MakeFunctionToJitFunction(FunctionPass): + """ + This swaps an ir.Expr.op == "make_function" i.e. a closure, for a compiled + function containing the closure body and puts it in ir.Global. It's a 1:1 + statement value swap. `make_function` is already untyped + """ + _name = "make_function_op_code_to_jit_function" + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + from numba import njit + func_ir = state.func_ir + mutated = False + for idx, blk in func_ir.blocks.items(): + for stmt in blk.body: + if isinstance(stmt, ir.Assign): + if isinstance(stmt.value, ir.Expr): + if stmt.value.op == "make_function": + node = stmt.value + getdef = func_ir.get_definition + kw_default = getdef(node.defaults) + ok = False + if (kw_default is None or + isinstance(kw_default, ir.Const)): + ok = True + elif isinstance(kw_default, tuple): + ok = all([isinstance(getdef(x), ir.Const) + for x in kw_default]) + elif isinstance(kw_default, ir.Expr): + if kw_default.op != "build_tuple": + continue + ok = all([isinstance(getdef(x), ir.Const) + for x in kw_default.items]) + if not ok: + continue + + pyfunc = convert_code_obj_to_function(node, func_ir) + func = njit()(pyfunc) + new_node = ir.Global(node.code.co_name, func, + stmt.loc) + stmt.value = new_node + mutated |= True + + # if a change was made the del ordering is probably wrong, patch up + if mutated: + post_proc = postproc.PostProcessor(func_ir) + post_proc.run() + + return mutated + + +@register_pass(mutates_CFG=True, analysis_only=False) +class TransformLiteralUnrollConstListToTuple(FunctionPass): + """ This pass spots a `literal_unroll([])` and rewrites it + as a `literal_unroll(tuple())`. + """ + _name = "transform_literal_unroll_const_list_to_tuple" + + _accepted_types = (types.BaseTuple, types.LiteralList) + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + mutated = False + func_ir = state.func_ir + for label, blk in func_ir.blocks.items(): + calls = [_ for _ in blk.find_exprs('call')] + for call in calls: + glbl = guard(get_definition, func_ir, call.func) + if glbl and isinstance(glbl, (ir.Global, ir.FreeVar)): + # find a literal_unroll + if glbl.value is literal_unroll: + if len(call.args) > 1: + msg = "literal_unroll takes one argument, found %s" + raise errors.UnsupportedError(msg % len(call.args), + call.loc) + # get the arg, make sure its a build_list + unroll_var = call.args[0] + to_unroll = guard(get_definition, func_ir, unroll_var) + if (isinstance(to_unroll, ir.Expr) and + to_unroll.op == "build_list"): + # make sure they are all const items in the list + for i, item in enumerate(to_unroll.items): + val = guard(get_definition, func_ir, item) + if not val: + msg = ("multiple definitions for variable " + "%s, cannot resolve constant") + raise errors.UnsupportedError(msg % item, + to_unroll.loc) + if not isinstance(val, ir.Const): + msg = ("Found non-constant value at " + "position %s in a list argument to " + "literal_unroll" % i) + raise errors.UnsupportedError(msg, + to_unroll.loc) + # The above appears ok, now swap the build_list for + # a built tuple. + + # find the assignment for the unroll target + to_unroll_lhs = guard(get_definition, func_ir, + unroll_var, lhs_only=True) + + if to_unroll_lhs is None: + msg = ("multiple definitions for variable " + "%s, cannot resolve constant") + raise errors.UnsupportedError(msg % unroll_var, + to_unroll.loc) + # scan all blocks looking for the LHS + for b in func_ir.blocks.values(): + asgn = b.find_variable_assignment( + to_unroll_lhs.name) + if asgn is not None: + break + else: + msg = ("Cannot find assignment for known " + "variable %s") % to_unroll_lhs.name + raise errors.CompilerError(msg, to_unroll.loc) + + # Create a tuple with the list items as contents + tup = ir.Expr.build_tuple(to_unroll.items, + to_unroll.loc) + + # swap the list for the tuple + asgn.value = tup + mutated = True + elif (isinstance(to_unroll, ir.Expr) and + to_unroll.op == "build_tuple"): + # this is fine, do nothing + pass + elif (isinstance(to_unroll, (ir.Global, ir.FreeVar)) and + isinstance(to_unroll.value, tuple)): + # this is fine, do nothing + pass + elif isinstance(to_unroll, ir.Arg): + # this is only fine if the arg is a tuple + ty = state.typemap[to_unroll.name] + if not isinstance(ty, self._accepted_types): + msg = ("Invalid use of literal_unroll with a " + "function argument, only tuples are " + "supported as function arguments, found " + "%s") % ty + raise errors.UnsupportedError(msg, + to_unroll.loc) + else: + extra = None + if isinstance(to_unroll, ir.Expr): + # probably a slice + if to_unroll.op == "getitem": + ty = state.typemap[to_unroll.value.name] + # check if this is a tuple slice + if not isinstance(ty, self._accepted_types): + extra = "operation %s" % to_unroll.op + loc = to_unroll.loc + elif isinstance(to_unroll, ir.Arg): + extra = "non-const argument %s" % to_unroll.name + loc = to_unroll.loc + else: + if to_unroll is None: + extra = ('multiple definitions of ' + 'variable "%s".' % unroll_var.name) + loc = unroll_var.loc + else: + loc = to_unroll.loc + extra = "unknown problem" + + if extra: + msg = ("Invalid use of literal_unroll, " + "argument should be a tuple or a list " + "of constant values. Failure reason: " + "found %s" % extra) + raise errors.UnsupportedError(msg, loc) + return mutated + + +@register_pass(mutates_CFG=True, analysis_only=False) +class MixedContainerUnroller(FunctionPass): + _name = "mixed_container_unroller" + + _DEBUG = False + + _accepted_types = (types.BaseTuple, types.LiteralList) + + def __init__(self): + FunctionPass.__init__(self) + + def analyse_tuple(self, tup): + """ + Returns a map of type->list(indexes) for a typed tuple + """ + d = defaultdict(list) + for i, ty in enumerate(tup): + d[ty].append(i) + return d + + def add_offset_to_labels_w_ignore(self, blocks, offset, ignore=None): + """add an offset to all block labels and jump/branch targets + don't add an offset to anything in the ignore list + """ + if ignore is None: + ignore = set() + + new_blocks = {} + for l, b in blocks.items(): + # some parfor last blocks might be empty + term = None + if b.body: + term = b.body[-1] + if isinstance(term, ir.Jump): + if term.target not in ignore: + b.body[-1] = ir.Jump(term.target + offset, term.loc) + if isinstance(term, ir.Branch): + if term.truebr not in ignore: + new_true = term.truebr + offset + else: + new_true = term.truebr + + if term.falsebr not in ignore: + new_false = term.falsebr + offset + else: + new_false = term.falsebr + b.body[-1] = ir.Branch(term.cond, new_true, new_false, term.loc) + new_blocks[l + offset] = b + return new_blocks + + def inject_loop_body(self, switch_ir, loop_ir, caller_max_label, + dont_replace, switch_data): + """ + Injects the "loop body" held in `loop_ir` into `switch_ir` where ever + there is a statement of the form `SENTINEL. = RHS`. It also: + * Finds and then deliberately does not relabel non-local jumps so as to + make the switch table suitable for injection into the IR from which + the loop body was derived. + * Looks for `typed_getitem` and wires them up to loop body version + specific variables or, if possible, directly writes in their constant + value at their use site. + + Args: + - switch_ir, the switch table with SENTINELS as generated by + self.gen_switch + - loop_ir, the IR of the loop blocks (derived from the original func_ir) + - caller_max_label, the maximum label in the func_ir caller + - dont_replace, variables that should not be renamed (to handle + references to variables that are incoming at the loop head/escaping at + the loop exit. + - switch_data, the switch table data used to generated the switch_ir, + can be generated by self.analyse_tuple. + + Returns: + - A type specific switch table with each case containing a versioned + loop body suitable for injection as a replacement for the loop_ir. + """ + + # Switch IR came from code gen, immediately relabel to prevent + # collisions with IR derived from the user code (caller) + switch_ir.blocks = self.add_offset_to_labels_w_ignore( + switch_ir.blocks, caller_max_label + 1) + + # Find the sentinels and validate the form + sentinel_exits = set() + sentinel_blocks = [] + for lbl, blk in switch_ir.blocks.items(): + for i, stmt in enumerate(blk.body): + if isinstance(stmt, ir.Assign): + if "SENTINEL" in stmt.target.name: + sentinel_blocks.append(lbl) + sentinel_exits.add(blk.body[-1].target) + break + + assert len(sentinel_exits) == 1 # should only be 1 exit + switch_ir.blocks.pop(sentinel_exits.pop()) # kill the exit, it's dead + + # find jumps that are non-local, we won't relabel these + ignore_set = set() + local_lbl = [x for x in loop_ir.blocks.keys()] + for lbl, blk in loop_ir.blocks.items(): + for i, stmt in enumerate(blk.body): + if isinstance(stmt, ir.Jump): + if stmt.target not in local_lbl: + ignore_set.add(stmt.target) + if isinstance(stmt, ir.Branch): + if stmt.truebr not in local_lbl: + ignore_set.add(stmt.truebr) + if stmt.falsebr not in local_lbl: + ignore_set.add(stmt.falsebr) + + # make sure the generated switch table matches the switch data + assert len(sentinel_blocks) == len(switch_data) + + # replace the sentinel_blocks with the loop body + for lbl, branch_ty in zip(sentinel_blocks, switch_data.keys()): + loop_blocks = deepcopy(loop_ir.blocks) + # relabel blocks WRT switch table, each block replacement will shift + # the maximum label + max_label = max(switch_ir.blocks.keys()) + loop_blocks = self.add_offset_to_labels_w_ignore( + loop_blocks, max_label + 1, ignore_set) + + # start label + loop_start_lbl = min(loop_blocks.keys()) + + # fix the typed_getitem locations in the loop blocks + for blk in loop_blocks.values(): + new_body = [] + for stmt in blk.body: + if isinstance(stmt, ir.Assign): + if (isinstance(stmt.value, ir.Expr) and + stmt.value.op == "typed_getitem"): + if isinstance(branch_ty, types.Literal): + scope = switch_ir.blocks[lbl].scope + new_const_name = scope.redefine( + "branch_const", stmt.loc).name + new_const_var = ir.Var( + blk.scope, new_const_name, stmt.loc) + new_const_val = ir.Const( + branch_ty.literal_value, stmt.loc) + const_assign = ir.Assign( + new_const_val, new_const_var, stmt.loc) + new_assign = ir.Assign( + new_const_var, stmt.target, stmt.loc) + new_body.append(const_assign) + new_body.append(new_assign) + dont_replace.append(new_const_name) + else: + orig = stmt.value + new_typed_getitem = ir.Expr.typed_getitem( + value=orig.value, dtype=branch_ty, + index=orig.index, loc=orig.loc) + new_assign = ir.Assign( + new_typed_getitem, stmt.target, stmt.loc) + new_body.append(new_assign) + else: + new_body.append(stmt) + else: + new_body.append(stmt) + blk.body = new_body + + # rename + var_table = get_name_var_table(loop_blocks) + drop_keys = [] + for k, v in var_table.items(): + if v.name in dont_replace: + drop_keys.append(k) + for k in drop_keys: + var_table.pop(k) + + new_var_dict = {} + for name, var in var_table.items(): + scope = switch_ir.blocks[lbl].scope + try: + scope.get_exact(name) + except errors.NotDefinedError: + # In case the scope doesn't have the variable, we need to + # define it prior creating new copies of it! This is + # because the scope of the function and the scope of the + # loop are different and the variable needs to be redefined + # within the scope of the loop. + scope.define(name, var.loc) + new_var_dict[name] = scope.redefine(name, var.loc).name + replace_var_names(loop_blocks, new_var_dict) + + # clobber the sentinel body and then stuff in the rest + switch_ir.blocks[lbl] = deepcopy(loop_blocks[loop_start_lbl]) + remaining_keys = [y for y in loop_blocks.keys()] + remaining_keys.remove(loop_start_lbl) + for k in remaining_keys: + switch_ir.blocks[k] = deepcopy(loop_blocks[k]) + + if self._DEBUG: + print("-" * 80 + "EXIT STUFFER") + switch_ir.dump() + print("-" * 80) + + return switch_ir + + def gen_switch(self, data, index): + """ + Generates a function with a switch table like + def foo(): + if PLACEHOLDER_INDEX in (): + SENTINEL = None + elif PLACEHOLDER_INDEX in (): + SENTINEL = None + ... + else: + raise RuntimeError + + The data is a map of (type : indexes) for example: + (int64, int64, float64) + might give: + {int64: [0, 1], float64: [2]} + + The index is the index variable for the driving range loop over the + mixed tuple. + """ + elif_tplt = "\n\telif PLACEHOLDER_INDEX in (%s,):\n\t\tSENTINEL = None" + + # Note regarding the insertion of the garbage/defeat variables below: + # These values have been designed and inserted to defeat a specific + # behaviour of the cpython optimizer. The optimization was introduced + # in Python 3.10. + + # The URL for the BPO is: + # https://bugs.python.org/issue44626 + # The code for the optimization can be found at: + # https://github.com/python/cpython/blob/d41abe8/Python/compile.c#L7533-L7557 + + # Essentially the CPython optimizer will inline the exit block under + # certain circumstances and thus replace the jump with a return if the + # exit block is small enough. This is an issue for unroller, as it + # looks for a jump, not a return, when it inserts the generated switch + # table. + + # Part of the condition for this optimization to be applied is that the + # exit block not exceed a certain (4 at the time of writing) number of + # bytecode instructions. We defeat the optimizer by inserting a + # sufficient number of instructions so that the exit block is big + # enough. We don't care about this garbage, because the generated exit + # block is discarded anyway when we smash the switch table into the + # original function and so all the inserted garbage is dropped again. + + # The final lines of the stacktrace w/o this will look like: + # + # File "/numba/numba/core/untyped_passes.py", line 830, \ + # in inject_loop_body + # sentinel_exits.add(blk.body[-1].target) + # AttributeError: Failed in nopython mode pipeline \ + # (step: handles literal_unroll) + # Failed in literal_unroll_subpipeline mode pipeline \ + # (step: performs mixed container unroll) + # 'Return' object has no attribute 'target' + # + # Which indicates that a Return has been found instead of a Jump + + b = ('def foo():\n\tif PLACEHOLDER_INDEX in (%s,):\n\t\t' + 'SENTINEL = None\n%s\n\telse:\n\t\t' + 'raise RuntimeError("Unreachable")\n\t' + 'py310_defeat1 = 1\n\t' + 'py310_defeat2 = 2\n\t' + 'py310_defeat3 = 3\n\t' + 'py310_defeat4 = 4\n\t' + ) + keys = [k for k in data.keys()] + + elifs = [] + for i in range(1, len(keys)): + elifs.append(elif_tplt % ','.join(map(str, data[keys[i]]))) + src = b % (','.join(map(str, data[keys[0]])), ''.join(elifs)) + wstr = src + l = {} + exec(wstr, {}, l) + bfunc = l['foo'] + branches = compile_to_numba_ir(bfunc, {}) + for lbl, blk in branches.blocks.items(): + for stmt in blk.body: + if isinstance(stmt, ir.Assign): + if isinstance(stmt.value, ir.Global): + if stmt.value.name == "PLACEHOLDER_INDEX": + stmt.value = index + return branches + + def apply_transform(self, state): + # compute new CFG + func_ir = state.func_ir + cfg = compute_cfg_from_blocks(func_ir.blocks) + # find loops + loops = cfg.loops() + + # 0. Find the loops containing literal_unroll and store this + # information + unroll_info = namedtuple( + "unroll_info", [ + "loop", "call", "arg", "getitem"]) + + def get_call_args(init_arg, want): + # Chases the assignment of a called value back through a specific + # call to a global function "want" and returns the arguments + # supplied to that function's call + some_call = get_definition(func_ir, init_arg) + if not isinstance(some_call, ir.Expr): + raise GuardException + if not some_call.op == "call": + raise GuardException + the_global = get_definition(func_ir, some_call.func) + if not isinstance(the_global, ir.Global): + raise GuardException + if the_global.value is not want: + raise GuardException + return some_call + + def find_unroll_loops(loops): + """This finds loops which are compliant with the form: + for i in range(len(literal_unroll(>)))""" + unroll_loops = {} + for header_lbl, loop in loops.items(): + # TODO: check the loop head has literal_unroll, if it does but + # does not conform to the following then raise + + # scan loop header + iternexts = [_ for _ in + func_ir.blocks[loop.header].find_exprs('iternext')] + # needs to be an single iternext driven loop + if len(iternexts) != 1: + continue + for iternext in iternexts: + # Walk the canonicalised loop structure and check it + # Check loop form range(literal_unroll(container))) + phi = guard(get_definition, func_ir, iternext.value) + if phi is None: + continue + + # check call global "range" + range_call = guard(get_call_args, phi.value, range) + if range_call is None: + continue + range_arg = range_call.args[0] + + # check call global "len" + len_call = guard(get_call_args, range_arg, len) + if len_call is None: + continue + len_arg = len_call.args[0] + + # check literal_unroll + literal_unroll_call = guard(get_definition, func_ir, + len_arg) + if literal_unroll_call is None: + continue + if not isinstance(literal_unroll_call, ir.Expr): + continue + if literal_unroll_call.op != "call": + continue + literal_func = getattr(literal_unroll_call, 'func', None) + if not literal_func: + continue + call_func = guard(get_definition, func_ir, + literal_unroll_call.func) + if call_func is None: + continue + call_func_value = call_func.value + + if call_func_value is literal_unroll: + assert len(literal_unroll_call.args) == 1 + unroll_loops[loop] = literal_unroll_call + return unroll_loops + + def ensure_no_nested_unroll(unroll_loops): + # Validate loop nests, nested literal_unroll loops are unsupported. + # This doesn't check that there's a getitem or anything else + # required for the transform to work, simply just that there's no + # nesting. + for test_loop in unroll_loops: + for ref_loop in unroll_loops: + if test_loop == ref_loop: # comparing to self! skip + continue + if test_loop.header in ref_loop.body: + msg = ("Nesting of literal_unroll is unsupported") + loc = func_ir.blocks[test_loop.header].loc + raise errors.UnsupportedError(msg, loc) + + def collect_literal_unroll_info(literal_unroll_loops): + """Finds the loops induced by `literal_unroll`, returns a list of + unroll_info namedtuples for use in the transform pass. + """ + + literal_unroll_info = [] + for loop, literal_unroll_call in literal_unroll_loops.items(): + arg = literal_unroll_call.args[0] + typemap = state.typemap + resolved_arg = guard(get_definition, func_ir, arg, + lhs_only=True) + ty = typemap[resolved_arg.name] + assert isinstance(ty, self._accepted_types) + # loop header is spelled ok, now make sure the body + # actually contains a getitem + + # find a "getitem"... only looks in the blocks that belong + # _solely_ to this literal_unroll (there should not be nested + # literal_unroll loops, this is unsupported). + tuple_getitem = None + for lbli in loop.body: + blk = func_ir.blocks[lbli] + for stmt in blk.body: + if isinstance(stmt, ir.Assign): + if (isinstance(stmt.value, ir.Expr) and + stmt.value.op == "getitem"): + # check for something like a[i] + if stmt.value.value != arg: + # that failed, so check for the + # definition + dfn = guard(get_definition, func_ir, + stmt.value.value) + if dfn is None: + continue + try: + args = getattr(dfn, 'args', False) + except KeyError: + continue + if not args: + continue + if not args[0] == arg: + continue + target_ty = state.typemap[arg.name] + if not isinstance(target_ty, + self._accepted_types): + continue + tuple_getitem = stmt + break + if tuple_getitem: + break + else: + continue # no getitem in this loop + + ui = unroll_info(loop, literal_unroll_call, arg, + tuple_getitem) + literal_unroll_info.append(ui) + return literal_unroll_info + + # 1. Collect info about the literal_unroll loops, ensure they are legal + literal_unroll_loops = find_unroll_loops(loops) + # validate + ensure_no_nested_unroll(literal_unroll_loops) + # assemble info + literal_unroll_info = collect_literal_unroll_info(literal_unroll_loops) + if not literal_unroll_info: + return False + + # 2. Do the unroll, get a loop and process it! + info = literal_unroll_info[0] + self.unroll_loop(state, info) + + # 3. Rebuild the state, the IR has taken a hammering + func_ir.blocks = simplify_CFG(func_ir.blocks) + post_proc = postproc.PostProcessor(func_ir) + post_proc.run() + if self._DEBUG: + print('-' * 80 + "END OF PASS, SIMPLIFY DONE") + func_ir.dump() + func_ir._definitions = build_definitions(func_ir.blocks) + return True + + def unroll_loop(self, state, loop_info): + # The general idea here is to: + # 1. Find *a* getitem that conforms to the literal_unroll semantic, + # i.e. one that is targeting a tuple with a loop induced index + # 2. Compute a structure from the tuple that describes which + # iterations of a loop will have which type + # 3. Generate a switch table in IR form for the structure in 2 + # 4. Switch out getitems for the tuple for a `typed_getitem` + # 5. Inject switch table as replacement loop body + # 6. Patch up + func_ir = state.func_ir + getitem_target = loop_info.arg + target_ty = state.typemap[getitem_target.name] + assert isinstance(target_ty, self._accepted_types) + + # 1. find a "getitem" that conforms + tuple_getitem = [] + for lbl in loop_info.loop.body: + blk = func_ir.blocks[lbl] + for stmt in blk.body: + if isinstance(stmt, ir.Assign): + if isinstance(stmt.value, + ir.Expr) and stmt.value.op == "getitem": + # try a couple of spellings... a[i] and ref(a)[i] + if stmt.value.value != getitem_target: + try: + dfn = func_ir.get_definition(stmt.value.value) + except KeyError: + # more than one definition reaches this + # getitem, so it cannot be resolved against + # the unroll target + msg = ("Invalid use of literal_unroll, " + "found multiple definitions of " + 'variable "%s".') + name = stmt.value.value.unversioned_name + raise errors.UnsupportedError( + msg % name, stmt.loc) from None + try: + args = getattr(dfn, 'args', False) + except KeyError: + continue + if not args: + continue + if not args[0] == getitem_target: + continue + target_ty = state.typemap[getitem_target.name] + if not isinstance(target_ty, self._accepted_types): + continue + tuple_getitem.append(stmt) + + if not tuple_getitem: + msg = ("Loop unrolling analysis has failed, there's no getitem " + "in loop body that conforms to literal_unroll " + "requirements.") + LOC = func_ir.blocks[loop_info.loop.header].loc + raise errors.CompilerError(msg, LOC) + + # 2. get switch data + switch_data = self.analyse_tuple(target_ty) + + # 3. generate switch IR + index = func_ir._definitions[tuple_getitem[0].value.index.name][0] + branches = self.gen_switch(switch_data, index) + + # 4. swap getitems for a typed_getitem, these are actually just + # placeholders at this point. When the loop is duplicated they can + # be swapped for a typed_getitem of the correct type or if the item + # is literal it can be shoved straight into the duplicated loop body + for item in tuple_getitem: + old = item.value + new = ir.Expr.typed_getitem( + old.value, types.void, old.index, old.loc) + item.value = new + + # 5. Inject switch table + + # Find the actual loop without the header (that won't get replaced) + # and derive some new IR for this set of blocks + this_loop = loop_info.loop + this_loop_body = this_loop.body - \ + set([this_loop.header]) + loop_blocks = { + x: func_ir.blocks[x] for x in this_loop_body} + new_ir = func_ir.derive(loop_blocks) + + # Work out what is live on entry and exit so as to prevent + # replacement (defined vars can escape, used vars live at the header + # need to remain as-is so their references are correct, they can + # also escape). + + usedefs = compute_use_defs(func_ir.blocks) + idx = this_loop.header + keep = set() + keep |= usedefs.usemap[idx] | usedefs.defmap[idx] + keep |= func_ir.variable_lifetime.livemap[idx] + dont_replace = [x for x in (keep)] + + # compute the unrolled body + unrolled_body = self.inject_loop_body( + branches, new_ir, max(func_ir.blocks.keys()) + 1, + dont_replace, switch_data) + + # 6. Patch in the unrolled body and fix up + blks = state.func_ir.blocks + the_scope = next(iter(blks.values())).scope + orig_lbl = tuple(this_loop_body) + + replace, *delete = orig_lbl + unroll, header_block = unrolled_body, this_loop.header + unroll_lbl = [x for x in sorted(unroll.blocks.keys())] + blks[replace] = transfer_scope(unroll.blocks[unroll_lbl[0]], the_scope) + [blks.pop(d) for d in delete] + for k in unroll_lbl[1:]: + blks[k] = transfer_scope(unroll.blocks[k], the_scope) + # stitch up the loop predicate true -> new loop body jump + blks[header_block].body[-1].truebr = replace + + def run_pass(self, state): + mutated = False + func_ir = state.func_ir + # first limit the work by squashing the CFG if possible + func_ir.blocks = simplify_CFG(func_ir.blocks) + + if self._DEBUG: + print("-" * 80 + "PASS ENTRY") + func_ir.dump() + print("-" * 80) + + # limitations: + # 1. No nested unrolls + # 2. Opt in via `numba.literal_unroll` + # 3. No multiple mix-tuple use + + # keep running the transform loop until it reports no more changes + while (True): + stat = self.apply_transform(state) + mutated |= stat + if not stat: + break + + # reset type inference now we are done with the partial results + state.typemap = {} + state.calltypes = None + + return mutated + + +@register_pass(mutates_CFG=True, analysis_only=False) +class IterLoopCanonicalization(FunctionPass): + """ Transforms loops that are induced by `getiter` into range() driven loops + If the typemap is available this will only impact Tuple and UniTuple, if it + is not available it will impact all matching loops. + """ + _name = "iter_loop_canonicalisation" + + _DEBUG = False + + # if partial typing info is available it will only look at these types + _accepted_types = (types.BaseTuple, types.LiteralList) + _accepted_calls = (literal_unroll,) + + def __init__(self): + FunctionPass.__init__(self) + + def assess_loop(self, loop, func_ir, partial_typemap=None): + # it's a iter loop if: + # - loop header is driven by an iternext + # - the iternext value is a phi derived from getiter() + + # check header + iternexts = [_ for _ in + func_ir.blocks[loop.header].find_exprs('iternext')] + if len(iternexts) != 1: + return False + for iternext in iternexts: + phi = guard(get_definition, func_ir, iternext.value) + if phi is None: + return False + if getattr(phi, 'op', False) == 'getiter': + if partial_typemap: + # check that the call site is accepted, until we're + # confident that tuple unrolling is behaving require opt-in + # guard of `literal_unroll`, remove this later! + phi_val_defn = guard(get_definition, func_ir, phi.value) + if not isinstance(phi_val_defn, ir.Expr): + return False + if not phi_val_defn.op == "call": + return False + call = guard(get_definition, func_ir, phi_val_defn) + if call is None or len(call.args) != 1: + return False + func_var = guard(get_definition, func_ir, call.func) + func = guard(get_definition, func_ir, func_var) + if func is None or not isinstance(func, + (ir.Global, ir.FreeVar)): + return False + if (func.value is None or + func.value not in self._accepted_calls): + return False + + # now check the type is supported + ty = partial_typemap.get(call.args[0].name, None) + if ty and isinstance(ty, self._accepted_types): + return len(loop.entries) == 1 + else: + return len(loop.entries) == 1 + + def transform(self, loop, func_ir, cfg): + def get_range(a): + return range(len(a)) + + iternext = [_ for _ in + func_ir.blocks[loop.header].find_exprs('iternext')][0] + LOC = func_ir.blocks[loop.header].loc + scope = func_ir.blocks[loop.header].scope + get_range_var = scope.redefine("CANONICALISER_get_range_gbl", LOC) + get_range_global = ir.Global('get_range', get_range, LOC) + assgn = ir.Assign(get_range_global, get_range_var, LOC) + + loop_entry = tuple(loop.entries)[0] + entry_block = func_ir.blocks[loop_entry] + entry_block.body.insert(0, assgn) + + iterarg = guard(get_definition, func_ir, iternext.value) + if iterarg is not None: + iterarg = iterarg.value + + # look for iternext + idx = 0 + for stmt in entry_block.body: + if isinstance(stmt, ir.Assign): + if isinstance(stmt.value, + ir.Expr) and stmt.value.op == 'getiter': + break + idx += 1 + else: + raise ValueError("problem") + + # create a range(len(tup)) and inject it + call_get_range_var = scope.redefine('CANONICALISER_call_get_range', LOC) + make_call = ir.Expr.call(get_range_var, (stmt.value.value,), (), LOC) + assgn_call = ir.Assign(make_call, call_get_range_var, LOC) + entry_block.body.insert(idx, assgn_call) + entry_block.body[idx + 1].value.value = call_get_range_var + + glbls = copy(func_ir.func_id.func.__globals__) + from numba.core.inline_closurecall import inline_closure_call + inline_closure_call(func_ir, glbls, entry_block, idx, get_range,) + kill = entry_block.body.index(assgn) + entry_block.body.pop(kill) + + # find the induction variable + references in the loop header + # fixed point iter to do this, it's a bit clunky + induction_vars = set() + header_block = func_ir.blocks[loop.header] + + # find induction var + ind = [x for x in header_block.find_exprs('pair_first')] + for x in ind: + induction_vars.add(func_ir.get_assignee(x, loop.header)) + # find aliases of the induction var + tmp = set() + for x in induction_vars: + try: # there's not always an alias, e.g. loop from inlined closure + tmp.add(func_ir.get_assignee(x, loop.header)) + except ValueError: + pass + induction_vars |= tmp + induction_var_names = set([x.name for x in induction_vars]) + + # Find the downstream blocks that might reference the induction var + succ = set() + for lbl in loop.exits: + succ |= set([x[0] for x in cfg.successors(lbl)]) + check_blocks = (loop.body | loop.exits | succ) ^ {loop.header} + + # replace RHS use of induction var with getitem + for lbl in check_blocks: + for stmt in func_ir.blocks[lbl].body: + if isinstance(stmt, ir.Assign): + # check for aliases + try: + lookup = getattr(stmt.value, 'name', None) + except KeyError: + continue + if lookup and lookup in induction_var_names: + stmt.value = ir.Expr.getitem( + iterarg, stmt.value, stmt.loc) + + post_proc = postproc.PostProcessor(func_ir) + post_proc.run() + + def run_pass(self, state): + func_ir = state.func_ir + cfg = compute_cfg_from_blocks(func_ir.blocks) + loops = cfg.loops() + + mutated = False + for header, loop in loops.items(): + stat = self.assess_loop(loop, func_ir, state.typemap) + if stat: + if self._DEBUG: + print("Canonicalising loop", loop) + self.transform(loop, func_ir, cfg) + mutated = True + else: + if self._DEBUG: + print("NOT Canonicalising loop", loop) + + func_ir.blocks = simplify_CFG(func_ir.blocks) + return mutated + + +@register_pass(mutates_CFG=False, analysis_only=False) +class PropagateLiterals(FunctionPass): + """Implement literal propagation based on partial type inference""" + _name = "PropagateLiterals" + + def __init__(self): + FunctionPass.__init__(self) + + def get_analysis_usage(self, AU): + AU.add_required(ReconstructSSA) + + def run_pass(self, state): + func_ir = state.func_ir + typemap = state.typemap + flags = state.flags + + accepted_functions = ('isinstance', 'hasattr') + + if not hasattr(func_ir, '_definitions') \ + and not flags.enable_ssa: + func_ir._definitions = build_definitions(func_ir.blocks) + + changed = False + + for block in func_ir.blocks.values(): + for assign in block.find_insts(ir.Assign): + value = assign.value + if isinstance(value, (ir.Arg, ir.Const, ir.FreeVar, ir.Global)): + continue + + # 1) Don't change return stmt in the form + # $return_xyz = cast(value=ABC) + # 2) Don't propagate literal values that are not primitives + if isinstance(value, ir.Expr) and \ + value.op in ('cast', 'build_map', 'build_list', + 'build_tuple', 'build_set'): + continue + + target = assign.target + if not flags.enable_ssa: + # SSA is disabled when doing inlining + if guard(get_definition, func_ir, target.name) is None: # noqa: E501 + continue + + # Numba cannot safely determine if an isinstance call + # with a PHI node is True/False. For instance, in + # the case below, the partial type inference step can coerce + # '$z' to float, so any call to 'isinstance(z, int)' would fail. + # + # def fn(x): + # if x > 4: + # z = 1 + # else: + # z = 3.14 + # if isinstance(z, int): + # print('int') + # else: + # print('float') + # + # At the moment, one avoid propagating the literal + # value if the argument is a PHI node + + if isinstance(value, ir.Expr) and value.op == 'call': + + fn = guard(get_definition, func_ir, value.func.name) + if fn is None: + continue + + if not (isinstance(fn, ir.Global) and fn.name in + accepted_functions): + continue + + for arg in value.args: + # check if any of the args to isinstance is a PHI node + iv = func_ir._definitions[arg.name] + assert len(iv) == 1 # SSA! + if isinstance(iv[0], ir.Expr) and iv[0].op == 'phi': + msg = (f'{fn.name}() cannot determine the ' + f'type of variable "{arg.unversioned_name}" ' + 'due to a branch.') + raise errors.NumbaTypeError(msg, loc=assign.loc) + + # Only propagate a PHI node if all arguments are the same + # constant + if isinstance(value, ir.Expr) and value.op == 'phi': + # typemap will return None in case `inc.name` not in typemap + v = [typemap.get(inc.name) for inc in value.incoming_values] + # stop if the elements in `v` do not hold the same value + if v[0] is not None and any([v[0] != vi for vi in v]): + continue + + lit = typemap.get(target.name, None) + if lit and isinstance(lit, types.Literal): + # replace assign instruction by ir.Const(lit) iff + # lit is a literal value + rhs = ir.Const(lit.literal_value, assign.loc) + new_assign = ir.Assign(rhs, target, assign.loc) + + # replace instruction + block.insert_after(new_assign, assign) + block.remove(assign) + + changed = True + + # reset type inference now we are done with the partial results + state.typemap = None + state.calltypes = None + + if changed: + # Rebuild definitions + func_ir._definitions = build_definitions(func_ir.blocks) + + return changed + + +@register_pass(mutates_CFG=True, analysis_only=False) +class LiteralPropagationSubPipelinePass(FunctionPass): + """Implement literal propagation based on partial type inference""" + _name = "LiteralPropagation" + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + # Determine whether to even attempt this pass... if there's no + # `isinstance` as a global or as a freevar then just skip. + + found = False + func_ir = state.func_ir + for blk in func_ir.blocks.values(): + for asgn in blk.find_insts(ir.Assign): + if isinstance(asgn.value, (ir.Global, ir.FreeVar)): + value = asgn.value.value + if value is isinstance or value is hasattr: + found = True + break + if found: + break + if not found: + return False + + # run as subpipeline + from numba.core.compiler_machinery import PassManager + from numba.core.typed_passes import PartialTypeInference + pm = PassManager("literal_propagation_subpipeline") + + pm.add_pass(PartialTypeInference, "performs partial type inference") + pm.add_pass(PropagateLiterals, "performs propagation of literal values") + + # rewrite consts / dead branch pruning + pm.add_pass(RewriteSemanticConstants, "rewrite semantic constants") + pm.add_pass(DeadBranchPrune, "dead branch pruning") + + pm.finalize() + pm.run(state) + return True + + def get_analysis_usage(self, AU): + AU.add_required(ReconstructSSA) + + +@register_pass(mutates_CFG=True, analysis_only=False) +class LiteralUnroll(FunctionPass): + """Implement the literal_unroll semantics""" + _name = "literal_unroll" + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + # Determine whether to even attempt this pass... if there's no + # `literal_unroll` as a global or as a freevar then just skip. + found = False + func_ir = state.func_ir + for blk in func_ir.blocks.values(): + for asgn in blk.find_insts(ir.Assign): + if isinstance(asgn.value, (ir.Global, ir.FreeVar)): + if asgn.value.value is literal_unroll: + found = True + break + if found: + break + if not found: + return False + + # run as subpipeline + from numba.core.compiler_machinery import PassManager + from numba.core.typed_passes import PartialTypeInference + pm = PassManager("literal_unroll_subpipeline") + # get types where possible to help with list->tuple change + pm.add_pass(PartialTypeInference, "performs partial type inference") + # make const lists tuples + pm.add_pass(TransformLiteralUnrollConstListToTuple, + "switch const list for tuples") + # recompute partial typemap following IR change + pm.add_pass(PartialTypeInference, "performs partial type inference") + # canonicalise loops + pm.add_pass(IterLoopCanonicalization, + "switch iter loops for range driven loops") + # rewrite consts + pm.add_pass(RewriteSemanticConstants, "rewrite semantic constants") + # do the unroll + pm.add_pass(MixedContainerUnroller, "performs mixed container unroll") + # rewrite dynamic getitem to static getitem as it's possible some more + # getitems will now be statically resolvable + pm.add_pass(GenericRewrites, "Generic Rewrites") + pm.add_pass(RewriteSemanticConstants, "rewrite semantic constants") + pm.finalize() + pm.run(state) + return True + + +@register_pass(mutates_CFG=True, analysis_only=False) +class SimplifyCFG(FunctionPass): + """Perform CFG simplification""" + _name = "simplify_cfg" + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + blks = state.func_ir.blocks + new_blks = simplify_CFG(blks) + state.func_ir.blocks = new_blks + mutated = blks != new_blks + return mutated + + +@register_pass(mutates_CFG=False, analysis_only=False) +class ReconstructSSA(FunctionPass): + """Perform SSA-reconstruction + + Produces minimal SSA. + """ + _name = "reconstruct_ssa" + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + state.func_ir = reconstruct_ssa(state.func_ir) + self._patch_locals(state) + + # Rebuild definitions + state.func_ir._definitions = build_definitions(state.func_ir.blocks) + + # Rerun postprocessor to update metadata + # example generator_info + post_proc = postproc.PostProcessor(state.func_ir) + post_proc.run(emit_dels=False) + + if config.DEBUG or config.DUMP_SSA: + name = state.func_ir.func_id.func_qualname + print(f"SSA IR DUMP: {name}".center(80, "-")) + state.func_ir.dump() + + return True # XXX detect if it actually got changed + + def _patch_locals(self, state): + # Fix dispatcher locals dictionary type annotation + locals_dict = state.get('locals') + if locals_dict is None: + return + + first_blk, *_ = state.func_ir.blocks.values() + scope = first_blk.scope + for parent, redefs in scope.var_redefinitions.items(): + if parent in locals_dict: + typ = locals_dict[parent] + for derived in redefs: + locals_dict[derived] = typ + + +@register_pass(mutates_CFG=False, analysis_only=False) +class RewriteDynamicRaises(FunctionPass): + """Replace existing raise statements by dynamic raises in Numba IR. + """ + _name = "Rewrite dynamic raises" + + def __init__(self): + FunctionPass.__init__(self) + + def run_pass(self, state): + func_ir = state.func_ir + changed = False + + for block in func_ir.blocks.values(): + for raise_ in block.find_insts((ir.Raise, ir.TryRaise)): + call_inst = guard(get_definition, func_ir, raise_.exception) + if call_inst is None: + continue + exc_type = func_ir.infer_constant(call_inst.func.name) + exc_args = [] + for exc_arg in call_inst.args: + try: + const = func_ir.infer_constant(exc_arg) + exc_args.append(const) + except consts.ConstantInferenceError: + exc_args.append(exc_arg) + loc = raise_.loc + + cls = { + ir.TryRaise: ir.DynamicTryRaise, + ir.Raise: ir.DynamicRaise, + }[type(raise_)] + + dyn_raise = cls(exc_type, tuple(exc_args), loc) + block.insert_after(dyn_raise, raise_) + block.remove(raise_) + changed = True + return changed diff --git a/shared/package-files/2f/2f1d036b8742a8572d08c0a0cc99887d1f591e9da522ab431aeace2b44c96c69/blob b/shared/package-files/2f/2f1d036b8742a8572d08c0a0cc99887d1f591e9da522ab431aeace2b44c96c69/blob new file mode 100644 index 0000000000000000000000000000000000000000..a1b6531b158061dc2226783edbdacd5647a149bf --- /dev/null +++ b/shared/package-files/2f/2f1d036b8742a8572d08c0a0cc99887d1f591e9da522ab431aeace2b44c96c69/blob @@ -0,0 +1,2454 @@ +# mypy: ignore-errors + +import itertools +import random +import unittest +from functools import partial +from itertools import chain, product +from typing import Iterable, List, Tuple + +import numpy as np +from numpy import inf + +import torch + +from torch.testing import make_tensor +from torch.testing._internal.common_cuda import ( + _get_magma_version, + _get_torch_cuda_version, + with_tf32_off, +) +from torch.testing._internal.common_device_type import ( + has_cusolver, + skipCPUIfNoLapack, + skipCUDAIf, + skipCUDAIfNoCusolver, + skipCUDAIfNoMagma, + skipCUDAIfNoMagmaAndNoCusolver, + skipCUDAIfNoMagmaAndNoLinalgsolver, + skipCUDAIfRocm, + tol, + toleranceOverride, +) +from torch.testing._internal.common_dtype import ( + all_types_and_complex, + all_types_and_complex_and, + floating_and_complex_types, + floating_and_complex_types_and, + get_all_complex_dtypes, +) +from torch.testing._internal.common_utils import ( + GRADCHECK_NONDET_TOL, + IS_MACOS, + make_fullrank_matrices_with_distinct_singular_values, + skipIfSlowGradcheckEnv, + slowTest, + TEST_WITH_ROCM, +) +from torch.testing._internal.opinfo.core import ( + clone_sample, + DecorateInfo, + ErrorInput, + gradcheck_wrapper_hermitian_input, + L, + M, + OpInfo, + ReductionOpInfo, + S, + SampleInput, +) +from torch.testing._internal.opinfo.refs import PythonRefInfo, ReductionPythonRefInfo + + +def sample_kwargs_vector_norm(t, **kwargs): + # orders with / without identity + def ords(): + has_id = (6, 4, 2, 1, 0, 0.9) + no_id = (inf, -2.1, -inf) + if t.numel() == 0: + dim = kwargs.get("dim") + if dim is None: + return has_id + if not isinstance(dim, Iterable): + dim = (dim,) + for d in dim: + if t.size(d) == 0: + return has_id + return has_id + no_id + + return (((), dict(ord=o)) for o in ords()) + + +def sample_inputs_svd(op_info, device, dtype, requires_grad=False, **kwargs): + make_fullrank = make_fullrank_matrices_with_distinct_singular_values + make_arg = partial( + make_fullrank, dtype=dtype, device=device, requires_grad=requires_grad + ) + + is_linalg_svd = "linalg.svd" in op_info.name + batches = [(), (0,), (3,)] + ns = [0, 3, 5] + + def uniformize(usv): + S = usv[1] + k = S.shape[-1] + U = usv[0][..., :k] + Vh = usv[2] if is_linalg_svd else usv[2].mH + Vh = Vh[..., :k, :] + return U, S, Vh + + def fn_U(usv): + U, _, _ = uniformize(usv) + return U.abs() + + def fn_S(usv): + return uniformize(usv)[1] + + def fn_Vh(usv): + # We also return S to test + _, S, Vh = uniformize(usv) + return S, Vh.abs() + + def fn_UVh(usv): + U, S, Vh = uniformize(usv) + return U @ Vh, S + + fns = (fn_U, fn_S, fn_Vh, fn_UVh) + + fullmat = "full_matrices" if is_linalg_svd else "some" + + for batch, n, k, fullmat_val, fn in product(batches, ns, ns, (True, False), fns): + shape = batch + (n, k) + yield SampleInput( + make_arg(*shape), kwargs={fullmat: fullmat_val}, output_process_fn_grad=fn + ) + + +def sample_inputs_cross(op_info, device, dtype, requires_grad, **kwargs): + make_arg = partial( + make_tensor, dtype=dtype, device=device, requires_grad=requires_grad + ) + yield SampleInput(make_arg((S, 3)), args=(make_arg((S, 3)),)) + yield SampleInput( + make_arg((S, 3, S)), args=(make_arg((S, 3, S)),), kwargs=dict(dim=1) + ) + yield SampleInput(make_arg((1, 3)), args=(make_arg((S, 3)),), kwargs=dict(dim=-1)) + + +def error_inputs_cross(op_info, device, **kwargs): + make_arg = partial(make_tensor, device=device, dtype=torch.float32) + + sample = SampleInput(input=make_arg((S, 3)), args=(make_arg((S, 1)),)) + err = "inputs dimension -1 must have length 3" + yield ErrorInput(sample, error_regex=err, error_type=RuntimeError) + + sample = SampleInput(input=make_arg((5, S, 3)), args=(make_arg((S, 3)),)) + err = "inputs must have the same number of dimensions" + yield ErrorInput(sample, error_regex=err, error_type=RuntimeError) + + sample = SampleInput(input=make_arg((S, 2)), args=(make_arg((S, 2)),)) + err = "must have length 3" + yield ErrorInput(sample, error_regex=err, error_type=RuntimeError) + + sample = SampleInput( + input=make_arg((S, 2)), args=(make_arg((S, 2)),), kwargs=dict(dim=2) + ) + err = "Dimension out of range" + yield ErrorInput(sample, error_regex=err, error_type=IndexError) + + +def sample_inputs_householder_product(op_info, device, dtype, requires_grad, **kwargs): + """ + This function generates input for torch.linalg.householder_product (torch.orgqr). + The first argument should be a square matrix or batch of square matrices, the second argument is a vector or batch of vectors. + Empty, square, rectangular, batched square and batched rectangular input is generated. + """ + make_arg = partial( + make_tensor, + device=device, + dtype=dtype, + requires_grad=requires_grad, + low=-2, + high=2, + ) + # Each column of the matrix is getting multiplied many times leading to very large values for + # the Jacobian matrix entries and making the finite-difference result of grad check less accurate. + # That's why gradcheck with the default range [-9, 9] fails and [-2, 2] is used here. + yield SampleInput(make_arg((S, S)), make_arg((S,))) + yield SampleInput(make_arg((S + 1, S)), make_arg((S,))) + yield SampleInput(make_arg((2, 1, S, S)), make_arg((2, 1, S))) + yield SampleInput(make_arg((2, 1, S + 1, S)), make_arg((2, 1, S))) + yield SampleInput( + make_arg((0, 0), low=None, high=None), + make_arg((0,), low=None, high=None), + ) + yield SampleInput(make_arg((S, S)), make_arg((0,), low=None, high=None)) + # m = n = S, k = S - 2 + yield SampleInput(make_arg((S, S)), make_arg((S - 2,), low=None, high=None)) + # m = S, n = S -1, k = S - 2 + yield SampleInput(make_arg((S, S - 1)), make_arg((S - 2,), low=None, high=None)) + + +def sample_inputs_linalg_det_singular(op_info, device, dtype, requires_grad, **kwargs): + make_arg = partial(make_tensor, device=device, dtype=dtype) + + def make_singular_matrix_batch_base(size, rank): + assert size[-1] == size[-2] + assert rank > 0 and rank < size[-1] + + n = size[-1] + a = make_arg(size[:-2] + (n, rank)) / 10 + b = make_arg(size[:-2] + (rank, n)) / 10 + x = a @ b + lu, pivs, _ = torch.linalg.lu_factor_ex(x) + p, l, u = torch.lu_unpack(lu, pivs) + u_diag_abs = u.diagonal(0, -2, -1).abs() + u_diag_abs_largest = u_diag_abs.max(dim=-1, keepdim=True).values + u_diag_abs_smallest_idxs = torch.topk( + u_diag_abs, k=(n - rank), largest=False + ).indices + u.diagonal(0, -2, -1).div_(u_diag_abs_largest) + u.diagonal(0, -2, -1)[..., u_diag_abs_smallest_idxs] = torch.finfo(dtype).eps + matrix = p @ l @ u + + matrix.requires_grad_(requires_grad) + return matrix + + for batch, size in product(((), (2,), (2, 2)), range(6)): + shape = batch + (size, size) + for rank in range(1, size): + yield SampleInput(make_singular_matrix_batch_base(shape, rank)) + + +def sample_inputs_linalg_matrix_power(op_info, device, dtype, requires_grad, **kwargs): + make_fullrank = make_fullrank_matrices_with_distinct_singular_values + make_arg = partial( + make_tensor, dtype=dtype, device=device, requires_grad=requires_grad + ) + make_arg_fullrank = partial( + make_fullrank, dtype=dtype, device=device, requires_grad=requires_grad + ) + # (, ()) + test_sizes = [ + (1, ()), + (2, (0,)), + (2, (2,)), + ] + + for matrix_size, batch_sizes in test_sizes: + size = batch_sizes + (matrix_size, matrix_size) + for n in (0, 3, 5): + yield SampleInput(make_arg(size), args=(n,)) + for n in [-4, -2, -1]: + yield SampleInput(make_arg_fullrank(*size), args=(n,)) + + +def sample_inputs_linalg_det_logdet_slogdet( + op_info, device, dtype, requires_grad, **kwargs +): + make_fullrank = make_fullrank_matrices_with_distinct_singular_values + make_arg = partial( + make_fullrank, dtype=dtype, device=device, requires_grad=requires_grad + ) + batches = [(), (0,), (3,)] + ns = [0, 1, 5] + + is_logdet = op_info.name == "logdet" + + for ( + batch, + n, + ) in product(batches, ns): + shape = batch + (n, n) + A = make_arg(*shape) + # Need to make the matrices in A have positive determinant for autograd + # To do so, we multiply A by its determinant to flip the sign of its determinant + if is_logdet and not A.is_complex() and A.numel() > 0: + s = torch.linalg.slogdet(A).sign + A = A * s.unsqueeze(-1).unsqueeze(-1) + A.requires_grad_(requires_grad) + yield SampleInput(A) + + +def sample_inputs_lu_solve(op_info, device, dtype, requires_grad=False, **kwargs): + """Samples the inputs for both linalg.lu_solve and lu_solve""" + make_fn = make_fullrank_matrices_with_distinct_singular_values + make_a = partial(make_fn, dtype=dtype, device=device) + make_b = partial(make_tensor, dtype=dtype, device=device) + + def clone(X, requires_grad): + Y = X.clone() + Y.requires_grad_(requires_grad) + return Y + + is_linalg_lu_solve = op_info.name == "linalg.lu_solve" + + batches = ((), (0,), (2,)) + ns = (3, 1, 0) + nrhs = (4, 1, 0) + + for n, batch, rhs in product(ns, batches, nrhs): + A = make_a(*(batch + (n, n))) + LU, pivots = torch.linalg.lu_factor(A) + + B = make_b(batch + (n, rhs)) + + grads = (False,) if not requires_grad else (True, False) + # we try all possible combinations of requires_grad for each input + for LU_grad, B_grad in product(grads, grads): + # when requires_grad == True, at least one input has to have requires_grad enabled + if requires_grad and not LU_grad and not B_grad: + continue + + if is_linalg_lu_solve: + for adjoint, left in product((True, False), repeat=2): + yield SampleInput( + clone(LU, LU_grad), + args=(pivots, clone(B if left else B.mT, B_grad)), + kwargs=dict(adjoint=adjoint, left=left), + ) + else: + yield SampleInput(clone(B, B_grad), args=(clone(LU, LU_grad), pivots)) + + +def sample_inputs_linalg_multi_dot(op_info, device, dtype, requires_grad, **kwargs): + # Each test case consists of the sizes in the chain of multiplications + # e.g. [2, 3, 4, 5] generates matrices (2, 3) @ (3, 4) @ (4, 5) + test_cases = [ + [1, 2, 1], + [2, 0, 2], + [0, 2, 2], + [2, 2, 2, 2], + [2, 3, 4, 5], + [5, 4, 0, 2], + [2, 4, 3, 5, 3, 2], + ] + + for sizes in test_cases: + tensors = [] + for size in zip(sizes[:-1], sizes[1:]): + t = make_tensor( + size, dtype=dtype, device=device, requires_grad=requires_grad + ) + tensors.append(t) + yield SampleInput(tensors) + + +def sample_inputs_linalg_matrix_norm(op_info, device, dtype, requires_grad, **kwargs): + low_precision_dtypes = (torch.float16, torch.bfloat16, torch.complex32) + make_arg = partial( + make_tensor, device=device, dtype=dtype, requires_grad=requires_grad + ) + + sizes = ((2, 2), (2, 3, 2)) + if dtype in low_precision_dtypes: + # svdvals not supported for low precision dtypes + ords = ("fro", inf, -inf, 1, -1) + else: + ords = ("fro", "nuc", inf, -inf, 1, -1, 2, -2) + dims = ((-2, -1), (-1, 0)) + + for size, ord, dim, keepdim in product(sizes, ords, dims, [True, False]): + yield SampleInput(make_arg(size), args=(ord, dim, keepdim)) + + +def sample_inputs_linalg_norm( + op_info, device, dtype, requires_grad, *, variant=None, **kwargs +): + if variant is not None and variant not in ("subgradient_at_zero",): + raise ValueError( + f"Unsupported variant, expected variant to be 'subgradient_at_zero' but got: {variant}" + ) + + test_sizes = [ + (S,), + (0,), + (S, S), + (0, 0), + (S, 0), + (0, S), + (S, S, S), + (0, S, S), + (S, 0, S), + (0, 0, 0), + ] + + vector_ords = (None, 0, 0.5, 1, 2, 3.5, inf, -0.5, -1, -2, -3.5, -inf) + if dtype in {torch.float16, torch.bfloat16, torch.complex32}: + # svdvals not supported for low precision dtypes + matrix_ords = ("fro", inf, -inf, 1, -1) + else: + matrix_ords = (None, "fro", "nuc", inf, -inf, 1, -1, 2, -2) + + make_arg = partial( + make_tensor, + dtype=dtype, + device=device, + requires_grad=requires_grad, + low=None, + high=None, + ) + + for test_size in test_sizes: + is_vector_norm = len(test_size) == 1 + is_matrix_norm = len(test_size) == 2 + + # IndexError: amax(): Expected reduction dim 0 to have non-zero size. + is_valid_for_p2 = is_vector_norm or (test_size[-1] != 0 and test_size[-2] != 0) + + for keepdim in [False, True]: + if variant != "subgradient_at_zero" and is_valid_for_p2: + yield SampleInput(make_arg(test_size), keepdim=keepdim) + + if not (is_vector_norm or is_matrix_norm): + continue + + ords = vector_ords if is_vector_norm else matrix_ords + + for ord in ords: + if is_vector_norm and test_size[-1] == 0: + if ord == np.inf or (ord is not None and ord < 0): + # RuntimeError: linalg.vector_norm cannot compute the + # {ord} norm on an empty tensor because the operation + # does not have an identity + continue + elif is_matrix_norm: + dims_to_check = { + None: (0,), + np.inf: (0,), + 2: (0, 1), + 1: (1,), + -1: (1,), + -2: (0, 1), + -np.inf: (0,), + }.get(ord, ()) + + if any(test_size[d] == 0 for d in dims_to_check): + # IndexError: amax(): Expected reduction dim {dim} to + # have non-zero size. + continue + + if variant == "subgradient_at_zero": + yield SampleInput( + torch.zeros( + test_size, + dtype=dtype, + device=device, + requires_grad=requires_grad, + ), + ord, + keepdim=keepdim, + ) + else: + yield SampleInput(make_arg(test_size), ord, keepdim=keepdim) + + if ord in ["nuc", "fro"]: + yield SampleInput( + make_arg(test_size), ord=ord, keepdim=keepdim, dim=(0, 1) + ) + + +def sample_inputs_linalg_vecdot(op_info, device, dtype, requires_grad, **kwargs): + make_arg = partial( + make_tensor, device=device, dtype=dtype, requires_grad=requires_grad + ) + batches = ((), (0,), (1,), (5,)) + ns = (0, 1, 3, 5) + for b, n in product(batches, ns): + shape = b + (n,) + yield SampleInput(make_arg(shape), args=(make_arg(shape),)) + for i in range(len(shape)): + yield SampleInput( + make_arg(shape), args=(make_arg(shape),), kwargs=dict(dim=i) + ) + + +def sample_inputs_linalg_invertible( + op_info, device, dtype, requires_grad=False, **kwargs +): + """ + This function generates invertible inputs for linear algebra ops + The input is generated as the itertools.product of 'batches' and 'ns'. + In total this function generates 8 SampleInputs + 'batches' cases include: + () - single input, + (0,) - zero batched dimension, + (2,) - batch of two matrices, + (1, 1) - 1x1 batch of matrices + 'ns' gives 0x0 and 5x5 matrices. + Zeros in dimensions are edge cases in the implementation and important to test for in order to avoid unexpected crashes. + """ + make_fn = make_fullrank_matrices_with_distinct_singular_values + make_arg = partial(make_fn, dtype=dtype, device=device, requires_grad=requires_grad) + + batches = [(), (0,), (2,), (1, 1)] + ns = [5, 0] + + for batch, n in product(batches, ns): + yield SampleInput(make_arg(*batch, n, n)) + + +def sample_inputs_matrix_rank(op_info, device, dtype, requires_grad=False, **kwargs): + """ + This function produces inputs for matrix rank that test + all possible combinations for atol and rtol + """ + + def make_tol_arg(kwarg_type, inp): + if kwarg_type == "none": + return None + if kwarg_type == "float": + return 1.0 + assert kwarg_type == "tensor" + return torch.ones(inp.shape[:-2], device=device) + + for tol_type in ["float", "tensor"]: + for atol_type, rtol_type in product(["none", tol_type], repeat=2): + if ( + not atol_type and not rtol_type + ): # default behavior, so skipped here so it's not tested 2 extra times + continue + for sample in sample_inputs_linalg_invertible( + op_info, device, dtype, requires_grad + ): + assert sample.kwargs == {} + sample.kwargs = { + "atol": make_tol_arg(atol_type, sample.input), + "rtol": make_tol_arg(rtol_type, sample.input), + } + yield sample + + # default kwargs + yield from sample_inputs_linalg_invertible(op_info, device, dtype, requires_grad) + + +def sample_inputs_linalg_pinv_singular( + op_info, device, dtype, requires_grad=False, **kwargs +): + """ + This function produces factors `a` and `b` to generate inputs of the form `a @ b.t()` to + test the backward method of `linalg_pinv`. That way we always preserve the rank of the + input no matter the perturbations applied to it by the gradcheck. + Note that `pinv` is Frechet-differentiable in a rank-preserving neighborhood. + """ + batches = [(), (0,), (2,), (1, 1)] + # the size of at least 30 is required to cause failures for the previous implicit implementation + # of the pinv's backward method, albeit it is slow. + size = [0, 3, 50] + + for batch, m, n in product(batches, size, size): + for k in range(min(3, m, n)): + # Note that by making the columns of `a` and `b` orthonormal we make sure that + # the product matrix `a @ b.t()` has condition number 1 when restricted to its image + a = ( + torch.rand(*batch, m, k, device=device, dtype=dtype) + .qr() + .Q.requires_grad_(requires_grad) + ) + b = ( + torch.rand(*batch, n, k, device=device, dtype=dtype) + .qr() + .Q.requires_grad_(requires_grad) + ) + yield SampleInput(a, args=(b,)) + + +def sample_inputs_linalg_cond(op_info, device, dtype, requires_grad=False, **kwargs): + make_arg = partial( + make_tensor, dtype=dtype, device=device, requires_grad=requires_grad + ) + + # autograd is not supported for inputs with zero number of elements + shapes = ( + (S, S), + (2, S, S), + (2, 1, S, S), + ) + + for shape in shapes: + yield SampleInput(make_arg(shape)) + + +def sample_inputs_linalg_vander(op_info, device, dtype, requires_grad=False, **kwargs): + make_arg = partial( + make_tensor, dtype=dtype, device=device, requires_grad=requires_grad + ) + + shapes = ( + (), + (1,), + (S,), + (2, S), + ) + + for shape in shapes: + if len(shape) > 0 and shape[-1] > 1: + yield SampleInput(make_arg(shape)) + n = shape[-1] if len(shape) > 0 else 1 + for i in range(3): + # n-1, n, n+1 + N = n + i - 1 + if N < 2: + continue + yield SampleInput(make_arg(shape), kwargs=dict(N=N)) + + +def np_vander_batched(x, N=None): + # Wrapper around np.vander that supports batches of 1 dimension (enough for the tests) + if x.ndim == 0: + x = x[np.newaxis] + if x.ndim == 1: + y = np.vander(x, N=N, increasing=True) + return y + else: + if N is None: + N = x.shape[-1] + y = np.vander(x.ravel(), N=N, increasing=True).reshape((*x.shape, N)) + return y + + +def sample_inputs_linalg_cholesky_inverse( + op_info, device, dtype, requires_grad=False, **kwargs +): + from torch.testing._internal.common_utils import random_well_conditioned_matrix + + # Cholesky factorization is for positive-definite matrices + single_well_conditioned_matrix = random_well_conditioned_matrix( + S, S, dtype=dtype, device=device + ) + batch_well_conditioned_matrices = random_well_conditioned_matrix( + 2, S, S, dtype=dtype, device=device + ) + single_pd = single_well_conditioned_matrix @ single_well_conditioned_matrix.mH + batch_pd = batch_well_conditioned_matrices @ batch_well_conditioned_matrices.mH + + inputs = ( + torch.zeros(0, 0, dtype=dtype, device=device), # 0x0 matrix + torch.zeros(0, 2, 2, dtype=dtype, device=device), # zero batch of matrices + single_pd, + batch_pd, + ) + test_cases = (torch.linalg.cholesky(a, upper=False) for a in inputs) + for l in test_cases: + # generated lower-triangular samples + l.requires_grad = requires_grad + yield SampleInput(l) # upper=False by default + yield SampleInput( + l.detach().clone().requires_grad_(requires_grad), kwargs=dict(upper=False) + ) + + # generate upper-triangular inputs + u = l.detach().clone().mT.contiguous().requires_grad_(requires_grad) + yield SampleInput(u, kwargs=dict(upper=True)) + + +def sample_inputs_linalg_ldl_factor( + op_info, device, dtype, requires_grad=False, **kwargs +): + from torch.testing._internal.common_utils import ( + random_hermitian_pd_matrix, + random_symmetric_pd_matrix, + ) + + device = torch.device(device) + + # Symmetric inputs + yield SampleInput( + random_symmetric_pd_matrix(S, dtype=dtype, device=device), + kwargs=dict(hermitian=False), + ) # single matrix + yield SampleInput( + random_symmetric_pd_matrix(S, 2, dtype=dtype, device=device), + kwargs=dict(hermitian=False), + ) # batch of matrices + yield SampleInput( + torch.zeros(0, 0, dtype=dtype, device=device), kwargs=dict(hermitian=False) + ) # 0x0 matrix + yield SampleInput( + torch.zeros(0, 2, 2, dtype=dtype, device=device), kwargs=dict(hermitian=False) + ) # zero batch of matrices + + # Hermitian inputs + # hermitian=True for complex inputs on CUDA is supported only with MAGMA 2.5.4+ + magma_254_available = device.type == "cuda" and _get_magma_version() >= (2, 5, 4) + if dtype.is_complex and (device.type == "cpu" or magma_254_available): + yield SampleInput( + random_hermitian_pd_matrix(S, dtype=dtype, device=device), + kwargs=dict(hermitian=True), + ) # single matrix + yield SampleInput( + random_hermitian_pd_matrix(S, 2, dtype=dtype, device=device), + kwargs=dict(hermitian=True), + ) # batch of matrices + + +def sample_inputs_linalg_ldl_solve( + op_info, device, dtype, requires_grad=False, **kwargs +): + # Generate LDL factors of symmetric (and Hermitian on CPU) matrices + from torch.testing._internal.common_utils import ( + random_hermitian_pd_matrix, + random_symmetric_pd_matrix, + ) + + device = torch.device(device) + symmetric_inputs = ( + random_symmetric_pd_matrix(S, dtype=dtype, device=device), # single matrix + random_symmetric_pd_matrix( + S, 2, dtype=dtype, device=device + ), # batch of matrices + torch.zeros(0, 0, dtype=dtype, device=device), # 0x0 matrix + torch.zeros(0, 2, 2, dtype=dtype, device=device), # zero batch of matrices + ) + hermitian_inputs = ( + ( + random_hermitian_pd_matrix(S, dtype=dtype, device=device), + random_hermitian_pd_matrix(S, 2, dtype=dtype, device=device), + ) + if device.type == "cpu" and dtype.is_complex + else () + ) + test_cases1 = ( + torch.linalg.ldl_factor_ex(a, hermitian=False) for a in symmetric_inputs + ) + test_cases2 = ( + torch.linalg.ldl_factor_ex(a, hermitian=True) for a in hermitian_inputs + ) + + # Symmetric case + make_arg = partial( + make_tensor, device=device, dtype=dtype, requires_grad=requires_grad + ) + for test_case in test_cases1: + factors, pivots, _ = test_case + factors.requires_grad = requires_grad + for B_batch_shape in ((), factors.shape[:-2]): + B = make_arg((*B_batch_shape, factors.shape[-1], S)) + yield SampleInput(factors, args=(pivots, B), kwargs=dict(hermitian=False)) + clone_factors = factors.detach().clone().requires_grad_(requires_grad) + yield SampleInput( + clone_factors, args=(pivots, B), kwargs=dict(hermitian=False) + ) + + # Hermitian case + for test_case in test_cases2: + factors, pivots, _ = test_case + factors.requires_grad = requires_grad + for B_batch_shape in ((), factors.shape[:-2]): + B = make_arg((*B_batch_shape, factors.shape[-1], S)) + yield SampleInput(factors, args=(pivots, B), kwargs=dict(hermitian=True)) + clone_factors = factors.detach().clone().requires_grad_(requires_grad) + yield SampleInput( + clone_factors, args=(pivots, B), kwargs=dict(hermitian=True) + ) + + +def sample_inputs_linalg_lstsq(op_info, device, dtype, requires_grad=False, **kwargs): + from torch.testing._internal.common_utils import random_well_conditioned_matrix + + device = torch.device(device) + + drivers: Tuple[str, ...] + if device.type == "cuda": + drivers = ("gels",) + else: + drivers = ("gels", "gelsy", "gelss", "gelsd") + + # we generate matrices of shape (..., n + delta, n) + deltas: Tuple[int, ...] + if device.type == "cpu" or has_cusolver(): + deltas = (-1, 0, +1) + # only square systems if Cusolver is not available + # becase we solve a lstsq problem with a transposed matrix in the backward + else: + deltas = (0,) + + for batch, driver, delta in product(((), (3,), (3, 3)), drivers, deltas): + shape = batch + (3 + delta, 3) + a = random_well_conditioned_matrix(*shape, dtype=dtype, device=device) + a.requires_grad_(requires_grad) + b = make_tensor( + shape, + dtype=dtype, + device=device, + low=None, + high=None, + requires_grad=requires_grad, + ) + yield SampleInput(a, b, driver=driver) + + +def error_inputs_lstsq(op_info, device, **kwargs): + zero_d = torch.randn((), device=device) + yield ErrorInput( + SampleInput(zero_d, args=(zero_d,)), + error_type=RuntimeError, + error_regex="at least 2 dimensions", + ) + + +def error_inputs_lstsq_grad_oriented(op_info, device, **kwargs): + zero_d = torch.randn((), device=device) + yield ErrorInput( + SampleInput(zero_d, args=(zero_d, None)), + error_type=RuntimeError, + error_regex="at least 2 dimensions", + ) + + +def sample_inputs_diagonal_diag_embed(op_info, device, dtype, requires_grad, **kwargs): + make_arg = partial( + make_tensor, dtype=dtype, device=device, requires_grad=requires_grad + ) + + # Shapes for 2D Tensors + shapes_2d = ((S, S), (3, 5), (5, 3)) + + # Shapes for 3D Tensors + shapes_3d = ((S, S, S),) + + kwargs_2d = (dict(), dict(offset=2), dict(offset=2), dict(offset=1)) + kwargs_3d = ( + dict(offset=1, dim1=1, dim2=2), + dict(offset=2, dim1=0, dim2=1), + dict(offset=-2, dim1=0, dim2=1), + ) + + for shape, kwarg in chain( + product(shapes_2d, kwargs_2d), product(shapes_3d, kwargs_3d) + ): + yield SampleInput(make_arg(shape), kwargs=kwarg) + + +def error_inputs_diagonal_diag_embed(op_info, device, **kwargs): + make_arg = partial(make_tensor, device=device, dtype=torch.float32) + + shapes1d = (0, 1, (0,), (1,)) + shapes2d = ((M, L),) + shapes3d = ((M, S, L),) + + kwargs1d = {} + + kwargs2d = ( + # dim1 == dim2 is not allowed + dict(dim1=1, dim2=1), + # out of bounds dims are not allowed + dict(dim1=10000), + dict(dim2=10000), + ) + + kwargs3d = kwargs2d + + samples1d = product(shapes1d, kwargs1d) + samples2d = product(shapes2d, kwargs2d) + samples3d = product(shapes3d, kwargs3d) + + for shape, kwargs in chain(samples1d, samples2d, samples3d): + arg = make_arg(shape) + sample = SampleInput(input=arg, kwargs=kwargs) + + dim1 = kwargs.get("dim1") + dim2 = kwargs.get("dim2") + + if "diagonal" in op_info.name: + num_dim = arg.dim() + elif op_info.name in ("diag_embed", "_refs.diag_embed"): + # these are valid inputs for diag_embed + if shape in ((0,), (1,)): + continue + num_dim = arg.dim() + 1 + else: + raise RuntimeError("should be unreachable") + + bound1 = -num_dim + bound2 = num_dim - 1 + dim_range = range(bound1, bound2 + 1) + dim1_cond = dim1 and dim1 not in dim_range + dim2_cond = dim2 and dim2 not in dim_range + + if dim1 == dim2: + err = f"diagonal dimensions cannot be identical {dim1}, {dim2}" + yield ErrorInput(sample, error_regex=err, error_type=RuntimeError) + elif dim1_cond or dim2_cond: + err_dim = dim1 if dim1_cond else dim2 + err = ( + r"Dimension out of range \(expected to be in range of " + rf"\[{bound1}, {bound2}\], but got {err_dim}\)" + ) + yield ErrorInput(sample, error_regex=err, error_type=IndexError) + else: + raise RuntimeError("should be unreachable") + + +def sample_inputs_linalg_cholesky( + op_info, device, dtype, requires_grad=False, **kwargs +): + """ + This function generates always positive-definite input for torch.linalg.cholesky using + random_hermitian_pd_matrix. + The input is generated as the itertools.product of 'batches' and 'ns'. + In total this function generates 8 SampleInputs + 'batches' cases include: + () - single input, + (0,) - zero batched dimension, + (2,) - batch of two matrices, + (1, 1) - 1x1 batch of matrices + 'ns' gives 0x0 and 5x5 matrices. + Zeros in dimensions are edge cases in the implementation and important to test for in order to avoid unexpected crashes. + """ + from torch.testing._internal.common_utils import random_hermitian_pd_matrix + + batches = [(), (0,), (2,), (1, 1)] + ns = [5, 0] + for batch, n, upper in product(batches, ns, [True, False]): + a = random_hermitian_pd_matrix(n, *batch, dtype=dtype, device=device) + a.requires_grad = requires_grad + yield SampleInput(a, upper=upper) + + +def sample_inputs_linalg_eig(op_info, device, dtype, requires_grad=False, **kwargs): + """ + This function generates input for torch.linalg.eig + """ + + def out_fn(output): + return output[0], abs(output[1]) + + samples = sample_inputs_linalg_invertible(op_info, device, dtype, requires_grad) + for sample in samples: + sample.output_process_fn_grad = out_fn + yield sample + + +def sample_inputs_linalg_eigh(op_info, device, dtype, requires_grad=False, **kwargs): + """ + This function generates input for torch.linalg.eigh/eigvalsh with UPLO="U" or "L" keyword argument. + """ + + def out_fn(output): + if isinstance(output, tuple): + # eigh function + return output[0], abs(output[1]) + else: + # eigvalsh function + return output + + # Samples do not need to be Hermitian, as we're using gradcheck_wrapper_hermitian_input + samples = sample_inputs_linalg_invertible(op_info, device, dtype, requires_grad) + for sample in samples: + # Note: we cannot use np.random.choice here as TorchDynamo + # does not support tensors of strings. + sample.kwargs = {"UPLO": random.choice(["L", "U"])} + sample.output_process_fn_grad = out_fn + yield sample + + +def sample_inputs_linalg_pinv(op_info, device, dtype, requires_grad=False, **kwargs): + """ + This function generates input for torch.linalg.pinv with hermitian=False keyword argument. + """ + for o in sample_inputs_linalg_invertible( + op_info, device, dtype, requires_grad, **kwargs + ): + real_dtype = o.input.real.dtype if dtype.is_complex else dtype + # requires_grad path for rtol tensor is not implemented + for rtol in (None, 1.0, torch.tensor(1.0, dtype=real_dtype, device=device)): + o = clone_sample(o) + o.kwargs = {"rtol": rtol} + yield o + + +def sample_inputs_linalg_pinv_hermitian( + op_info, device, dtype, requires_grad=False, **kwargs +): + """ + This function generates input for torch.linalg.pinv with hermitian=True keyword argument. + """ + for o in sample_inputs_linalg_invertible( + op_info, device, dtype, requires_grad, **kwargs + ): + o.kwargs = {"hermitian": True} + yield o + + +def sample_inputs_linalg_solve( + op_info, device, dtype, requires_grad=False, vector_rhs_allowed=True, **kwargs +): + """ + This function generates always solvable input for torch.linalg.solve + We sample a fullrank square matrix (i.e. invertible) A + The first input to torch.linalg.solve is generated as the itertools.product of 'batches' and 'ns'. + The second input is generated as the product of 'batches', 'ns' and 'nrhs'. + In total this function generates 18 SampleInputs + 'batches' cases include: + () - single input, + (0,) - zero batched dimension, + (2,) - batch of two matrices. + 'ns' gives 0x0 and 5x5 matrices. + and 'nrhs' controls the number of vectors to solve for: + () - using 1 as the number of vectors implicitly + (1,) - same as () but explicit + (3,) - solve for 3 vectors. + Zeros in dimensions are edge cases in the implementation and important to test for in order to avoid unexpected crashes. + 'vector_rhs_allowed' controls whether to include nrhs = () to the list of SampleInputs. + torch.solve / triangular_solve / cholesky_solve (opposed to torch.linalg.solve) do not allow + 1D tensors (vectors) as the right-hand-side. + Once torch.solve / triangular_solve / cholesky_solve and its testing are removed, + 'vector_rhs_allowed' may be removed here as well. + """ + make_fullrank = make_fullrank_matrices_with_distinct_singular_values + make_a = partial( + make_fullrank, dtype=dtype, device=device, requires_grad=requires_grad + ) + make_b = partial( + make_tensor, dtype=dtype, device=device, requires_grad=requires_grad + ) + + batches = [(), (0,), (2,)] + ns = [5, 0] + if vector_rhs_allowed: + nrhs = [(), (1,), (3,)] + else: + nrhs = [(1,), (3,)] + + for n, batch, rhs in product(ns, batches, nrhs): + yield SampleInput(make_a(*batch, n, n), args=(make_b(batch + (n,) + rhs),)) + + +def sample_inputs_linalg_solve_triangular( + op_info, device, dtype, requires_grad=False, **kwargs +): + make_arg = partial(make_tensor, dtype=dtype, device=device) + bs = (1, 2, 0) + ns = (3, 0) + ks = (1, 3, 0) + + for b, n, k, (left, upper, uni) in product( + bs, ns, ks, product((True, False), repeat=3) + ): + if b == 1: + A = make_arg((n, n)) if left else make_arg((k, k)) + B = make_arg((n, k)) + else: + A = make_arg((b, n, n)) if left else make_arg((b, k, k)) + B = make_arg((b, n, k)) + if uni: + # Not really necessary, but writing it for consistency + A.diagonal(0, -2, -1).fill_(1.0) + else: + d = A.diagonal(0, -2, -1) + d[d.abs() < 1e-6] = 1.0 + if upper: + A.triu_() + else: + A.tril_() + kwargs = {"upper": upper, "left": left, "unitriangular": uni} + if requires_grad: + for grad_A, grad_B in product((True, False), repeat=2): + # Either A or B needs to have a gradient + if not grad_A and not grad_B: + continue + yield SampleInput( + A.clone().requires_grad_(grad_A), + args=(B.clone().requires_grad_(grad_B),), + kwargs=kwargs, + ) + else: + yield SampleInput(A, args=(B,), kwargs=kwargs) + + +def sample_inputs_legacy_solve(op_info, device, dtype, requires_grad=False, **kwargs): + """ + This function generates always solvable input for legacy solve functions + (the ones that are not in torch.linalg module). + The difference from sample_inputs_linalg_solve is that here the right-hand-side of A x = b equation + should have b.ndim >= 2, vectors are not allowed. + Also the arguments order is swapped. + """ + out = sample_inputs_linalg_solve( + op_info, device, dtype, requires_grad=requires_grad, vector_rhs_allowed=False + ) + + def out_fn(output): + return output[0] + + # Reverses tensor order + for sample in out: + sample.input, sample.args = sample.args[0], (sample.input,) + if op_info.name == "solve": + sample.output_process_fn_grad = out_fn + yield sample + + +def sample_inputs_linalg_lu(op_info, device, dtype, requires_grad=False, **kwargs): + full_rank = op_info.name == "linalg.lu_factor" + make_fn = ( + make_tensor + if not full_rank + else make_fullrank_matrices_with_distinct_singular_values + ) + make_arg = partial(make_fn, dtype=dtype, device=device, requires_grad=requires_grad) + + def out_fn(output): + if op_info.name == "linalg.lu": + return output[1], output[2] + else: + return output + + batch_shapes = ((), (3,), (3, 3)) + # pivot=False only supported in CUDA + pivots = (True, False) if torch.device(device).type == "cuda" else (True,) + deltas = (-2, -1, 0, +1, +2) + for batch_shape, pivot, delta in product(batch_shapes, pivots, deltas): + shape = batch_shape + (S + delta, S) + # Insanely annoying that make_fullrank_blablabla accepts a *shape and not a tuple! + A = make_arg(shape) if not full_rank else make_arg(*shape) + yield SampleInput(A, kwargs={"pivot": pivot}, output_process_fn_grad=out_fn) + + +def sample_inputs_linalg_svdvals(op_info, device, dtype, requires_grad=False, **kwargs): + make_arg = partial( + make_tensor, dtype=dtype, device=device, requires_grad=requires_grad + ) + + batches = [(), (0,), (2,), (1, 1)] + ns = [5, 2, 0] + + for batch, m, n in product(batches, ns, ns): + yield SampleInput(make_arg(batch + (m, n))) + + +def sample_inputs_linalg_qr_geqrf( + op_info, device, dtype, requires_grad=False, **kwargs +): + # QR is just well defined when the matrix is full rank + make_fullrank = make_fullrank_matrices_with_distinct_singular_values + make_arg = partial( + make_fullrank, dtype=dtype, device=device, requires_grad=requires_grad + ) + + batches = [(), (0,), (2,), (1, 1)] + ns = [5, 2, 0] + + for batch, (m, n) in product(batches, product(ns, ns)): + shape = batch + (m, n) + yield SampleInput(make_arg(*shape)) + + +def sample_inputs_tensorsolve(op_info, device, dtype, requires_grad, **kwargs): + a_shapes = [(2, 3, 6), (3, 4, 4, 3)] + # Zero-dim tensors are not supported in NumPy, so we skip them for now. + # NumPy is used in reference check tests. + # See https://github.com/numpy/numpy/pull/20482 for tracking NumPy bugfix. + # a_shapes += [(0, 0, 1, 2, 3, 0)] + dimss = [None, (0, 2)] + + make_arg = partial( + make_tensor, dtype=dtype, device=device, requires_grad=requires_grad + ) + for a_shape, dims in itertools.product(a_shapes, dimss): + a = make_arg(a_shape) + b = make_arg(a_shape[:2]) + yield SampleInput(a, b, dims=dims) + + +def sample_inputs_tensorinv(op_info, device, dtype, requires_grad, **kwargs): + make_arg = make_fullrank_matrices_with_distinct_singular_values + + def make_input(): + return make_arg(12, 12, device=device, dtype=dtype, requires_grad=requires_grad) + + # lhs / rhs shape can have any number of dimensions as long as their product equals 12 + shapes = [ + ((2, 2, 3), (12, 1)), + ((4, 3), (6, 1, 2)), + ] + + for shape_lhs, shape_rhs in shapes: + inp = make_input().reshape(*shape_lhs, *shape_rhs).detach() + inp.requires_grad_(requires_grad) + yield SampleInput(inp, ind=len(shape_lhs)) + + +op_db: List[OpInfo] = [ + OpInfo( + "linalg.cross", + ref=lambda x, y, dim=-1: np.cross(x, y, axis=dim), + op=torch.linalg.cross, + dtypes=all_types_and_complex_and(torch.half, torch.bfloat16), + aten_name="linalg_cross", + sample_inputs_func=sample_inputs_cross, + error_inputs_func=error_inputs_cross, + supports_out=True, + supports_fwgrad_bwgrad=True, + supports_forward_ad=True, + skips=( + DecorateInfo( + unittest.skip("Unsupported on MPS for now"), + "TestCommon", + "test_numpy_ref_mps", + ), + ), + ), + OpInfo( + "linalg.det", + aten_name="linalg_det", + op=torch.linalg.det, + aliases=("det",), + dtypes=floating_and_complex_types(), + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + sample_inputs_func=sample_inputs_linalg_det_logdet_slogdet, + decorators=[skipCPUIfNoLapack, skipCUDAIfNoMagmaAndNoCusolver], + check_batched_gradgrad=False, + ), + OpInfo( + "linalg.det", + aten_name="linalg_det", + op=torch.linalg.det, + variant_test_name="singular", + aliases=("det",), + dtypes=floating_and_complex_types(), + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + check_batched_gradgrad=False, + sample_inputs_func=sample_inputs_linalg_det_singular, + decorators=[skipCPUIfNoLapack, skipCUDAIfNoMagmaAndNoCusolver], + skips=( + DecorateInfo( + unittest.skip("The backward may give different results"), + "TestCommon", + "test_noncontiguous_samples", + ), + DecorateInfo( + unittest.skip("Gradients are incorrect on macos"), + "TestBwdGradients", + "test_fn_grad", + device_type="cpu", + dtypes=(torch.float64,), + active_if=IS_MACOS, + ), + DecorateInfo( + unittest.skip("Gradients are incorrect on macos"), + "TestFwdGradients", + "test_forward_mode_AD", + device_type="cpu", + dtypes=(torch.float64,), + active_if=IS_MACOS, + ), + # Both Hessians are incorrect on complex inputs?? + DecorateInfo( + unittest.expectedFailure, + "TestBwdGradients", + "test_fn_gradgrad", + dtypes=(torch.complex128,), + ), + DecorateInfo( + unittest.expectedFailure, + "TestFwdGradients", + "test_fn_fwgrad_bwgrad", + dtypes=(torch.complex128,), + ), + DecorateInfo( + unittest.skip("Skipped, see https://github.com//issues/84192"), + "TestBwdGradients", + "test_fn_gradgrad", + device_type="cuda", + ), + DecorateInfo( + unittest.skip("Skipped, see https://github.com//issues/84192"), + "TestFwdGradients", + "test_fn_fwgrad_bwgrad", + device_type="cuda", + ), + DecorateInfo( + unittest.skip( + "Flaky on ROCm https://github.com/pytorch/pytorch/issues/93044" + ), + "TestBwdGradients", + "test_fn_grad", + device_type="cuda", + dtypes=get_all_complex_dtypes(), + active_if=TEST_WITH_ROCM, + ), + DecorateInfo( + unittest.skip( + "Flaky on ROCm https://github.com/pytorch/pytorch/issues/93045" + ), + "TestFwdGradients", + "test_forward_mode_AD", + device_type="cuda", + dtypes=get_all_complex_dtypes(), + active_if=TEST_WITH_ROCM, + ), + ), + ), + OpInfo( + "linalg.diagonal", + aten_name="linalg_diagonal", + aten_backward_name="diagonal_backward", + dtypes=all_types_and_complex_and( + torch.bool, torch.bfloat16, torch.float16, torch.chalf + ), + supports_out=False, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + sample_inputs_func=sample_inputs_diagonal_diag_embed, + error_inputs_func=error_inputs_diagonal_diag_embed, + ), + OpInfo( + "linalg.cholesky", + aten_name="linalg_cholesky", + dtypes=floating_and_complex_types(), + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + # See https://github.com/pytorch/pytorch/pull/78358 + check_batched_forward_grad=False, + sample_inputs_func=sample_inputs_linalg_cholesky, + gradcheck_wrapper=gradcheck_wrapper_hermitian_input, + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack], + ), + OpInfo( + "linalg.cholesky_ex", + aten_name="linalg_cholesky_ex", + dtypes=floating_and_complex_types(), + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + # See https://github.com/pytorch/pytorch/pull/78358 + check_batched_forward_grad=False, + sample_inputs_func=sample_inputs_linalg_cholesky, + gradcheck_wrapper=gradcheck_wrapper_hermitian_input, + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack], + ), + OpInfo( + "linalg.vecdot", + aten_name="linalg_vecdot", + ref=lambda x, y, *, dim=-1: (x.conj() * y).sum(dim), + dtypes=floating_and_complex_types_and(torch.half, torch.bfloat16), + sample_inputs_func=sample_inputs_linalg_vecdot, + check_batched_forward_grad=False, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + skips=( + # Issue with conj and torch dispatch, see https://github.com/pytorch/pytorch/issues/82479 + DecorateInfo( + unittest.skip("Skipped!"), + "TestSchemaCheckModeOpInfo", + "test_schema_correctness", + dtypes=(torch.complex64, torch.complex128), + ), + DecorateInfo( + unittest.skip("Unsupported on MPS for now"), + "TestCommon", + "test_numpy_ref_mps", + ), + ), + ), + OpInfo( + "linalg.cond", + aten_name="linalg_cond", + dtypes=floating_and_complex_types(), + sample_inputs_func=sample_inputs_linalg_cond, + check_batched_gradgrad=False, + check_batched_forward_grad=False, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + gradcheck_nondet_tol=GRADCHECK_NONDET_TOL, + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack, with_tf32_off], + skips=( + DecorateInfo( + unittest.skip("Skipped!"), + "TestFakeTensor", + "test_fake_crossref_backward_amp", + device_type="cuda", + dtypes=[torch.float32], + active_if=TEST_WITH_ROCM, + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestFakeTensor", + "test_fake_crossref_backward_no_amp", + device_type="cuda", + dtypes=[torch.float32], + active_if=TEST_WITH_ROCM, + ), + ), + ), + OpInfo( + "linalg.eig", + aten_name="linalg_eig", + op=torch.linalg.eig, + dtypes=floating_and_complex_types(), + sample_inputs_func=sample_inputs_linalg_eig, + check_batched_forward_grad=False, + check_batched_grad=False, + check_batched_gradgrad=False, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + skips=( + # AssertionError: Scalars are not equal! + DecorateInfo( + unittest.expectedFailure, "TestCommon", "test_out", device_type="cpu" + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_out", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_variant_consistency_eager", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestJit", + "test_variant_consistency_jit", + device_type="mps", + dtypes=[torch.float32], + ), + ), + decorators=[skipCUDAIfNoMagma, skipCPUIfNoLapack, with_tf32_off], + ), + OpInfo( + "linalg.eigvals", + aten_name="linalg_eigvals", + op=torch.linalg.eigvals, + dtypes=floating_and_complex_types(), + sample_inputs_func=sample_inputs_linalg_invertible, + check_batched_forward_grad=False, + check_batched_grad=False, + check_batched_gradgrad=False, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + decorators=[skipCUDAIfNoMagma, skipCPUIfNoLapack], + skips=( + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_out", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_variant_consistency_eager", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestJit", + "test_variant_consistency_jit", + device_type="mps", + dtypes=[torch.float32], + ), + ), + ), + OpInfo( + "linalg.eigh", + aten_name="linalg_eigh", + dtypes=floating_and_complex_types(), + sample_inputs_func=sample_inputs_linalg_eigh, + gradcheck_wrapper=gradcheck_wrapper_hermitian_input, + check_batched_forward_grad=False, + check_batched_grad=False, + check_batched_gradgrad=False, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + decorators=[skipCUDAIfNoMagma, skipCPUIfNoLapack, with_tf32_off], + skips=( + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_out", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_variant_consistency_eager", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestJit", + "test_variant_consistency_jit", + device_type="mps", + dtypes=[torch.float32], + ), + ), + ), + OpInfo( + "linalg.eigvalsh", + aten_name="linalg_eigvalsh", + dtypes=floating_and_complex_types(), + sample_inputs_func=sample_inputs_linalg_eigh, + gradcheck_wrapper=gradcheck_wrapper_hermitian_input, + check_batched_forward_grad=False, + check_batched_grad=False, + check_batched_gradgrad=False, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + decorators=[skipCUDAIfNoMagma, skipCPUIfNoLapack], + skips=( + # Pre-existing condition; Needs to be fixed + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_out", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_variant_consistency_eager", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestJit", + "test_variant_consistency_jit", + device_type="mps", + dtypes=[torch.float32], + ), + ), + ), + OpInfo( + "linalg.householder_product", + aten_name="linalg_householder_product", + op=torch.linalg.householder_product, + aliases=("orgqr",), + dtypes=floating_and_complex_types(), + # https://github.com/pytorch/pytorch/issues/80411 + gradcheck_fast_mode=True, + # TODO: backward uses in-place operations that vmap doesn't like + check_batched_grad=False, + check_batched_gradgrad=False, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + check_batched_forward_grad=False, + sample_inputs_func=sample_inputs_householder_product, + decorators=[ + skipCUDAIfNoCusolver, + skipCPUIfNoLapack, + DecorateInfo( + toleranceOverride({torch.complex64: tol(atol=1e-3, rtol=1e-3)}) + ), + DecorateInfo( + unittest.skip("Skipped! Flaky"), + "TestFwdGradients", + "test_fn_fwgrad_bwgrad", + device_type="cpu", + dtypes=(torch.complex128,), + ), + ], + ), + OpInfo( + "linalg.ldl_factor", + aten_name="linalg_ldl_factor", + dtypes=floating_and_complex_types(), + supports_autograd=False, + sample_inputs_func=sample_inputs_linalg_ldl_factor, + decorators=[skipCUDAIfNoMagmaAndNoLinalgsolver, skipCPUIfNoLapack], + ), + OpInfo( + "linalg.ldl_factor_ex", + aten_name="linalg_ldl_factor_ex", + dtypes=floating_and_complex_types(), + supports_autograd=False, + sample_inputs_func=sample_inputs_linalg_ldl_factor, + decorators=[skipCUDAIfNoMagmaAndNoLinalgsolver, skipCPUIfNoLapack], + ), + OpInfo( + "linalg.ldl_solve", + aten_name="linalg_ldl_solve", + dtypes=floating_and_complex_types(), + supports_autograd=False, + sample_inputs_func=sample_inputs_linalg_ldl_solve, + decorators=[ + skipCUDAIf( + _get_torch_cuda_version() < (11, 4), "not available before CUDA 11.3.1" + ), + skipCUDAIfNoCusolver, + skipCUDAIfRocm, + skipCPUIfNoLapack, + ], + ), + OpInfo( + "linalg.lstsq", + aten_name="linalg_lstsq", + dtypes=floating_and_complex_types(), + supports_out=True, + sample_inputs_func=sample_inputs_linalg_lstsq, + error_inputs_func=error_inputs_lstsq, + decorators=[skipCUDAIfNoMagma, skipCPUIfNoLapack], + skips=( + # we skip gradient checks for this suite as they are tested in + # variant_test_name='grad_oriented' + DecorateInfo(unittest.skip("Skipped!"), "TestFwdGradients"), + DecorateInfo(unittest.skip("Skipped!"), "TestBwdGradients"), + # The values for attribute 'shape' do not match + DecorateInfo(unittest.skip("Skipped!"), "TestCommon", "test_out"), + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_out", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_variant_consistency_eager", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestJit", + "test_variant_consistency_jit", + device_type="mps", + dtypes=[torch.float32], + ), + ), + ), + OpInfo( + "linalg.lstsq", + aten_name="linalg_lstsq", + variant_test_name="grad_oriented", + # gradchecks for forward AD fails with multi-Tensor outputs + op=lambda a, b, driver: torch.linalg.lstsq(a, b, driver=driver)[0], + supports_out=False, + dtypes=floating_and_complex_types(), + sample_inputs_func=sample_inputs_linalg_lstsq, + error_inputs_func=error_inputs_lstsq_grad_oriented, + # Runs very slowly on slow gradcheck - alternatively reduce input sizes + gradcheck_fast_mode=True, + supports_autograd=True, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + decorators=[skipCUDAIfNoMagma, skipCPUIfNoLapack], + skips=( + # tests do not work with passing lambda for op + DecorateInfo( + unittest.expectedFailure, "TestJit", "test_variant_consistency_jit" + ), + DecorateInfo( + unittest.expectedFailure, + "TestOperatorSignatures", + "test_get_torch_func_signature_exhaustive", + ), + ), + ), + OpInfo( + "linalg.matrix_power", + aliases=("matrix_power",), + aten_name="linalg_matrix_power", + dtypes=floating_and_complex_types(), + # https://github.com/pytorch/pytorch/issues/80411 + gradcheck_fast_mode=True, + supports_inplace_autograd=False, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + check_batched_grad=False, + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack, with_tf32_off], + sample_inputs_func=sample_inputs_linalg_matrix_power, + ), + OpInfo( + "linalg.multi_dot", + # Need this lambda because gradcheck does not work with TensorList inputs + aten_name="linalg_multi_dot", + dtypes=all_types_and_complex_and(torch.half, torch.bfloat16), + dtypesIfCUDA=floating_and_complex_types_and(torch.half, torch.bfloat16), + supports_inplace_autograd=False, + # Batched grad checks fail for empty input tensors (see https://github.com/pytorch/pytorch/issues/53407) + check_batched_grad=False, + check_batched_gradgrad=False, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + # https://github.com/pytorch/pytorch/issues/66357 + check_batched_forward_grad=False, + sample_inputs_func=sample_inputs_linalg_multi_dot, + gradcheck_nondet_tol=GRADCHECK_NONDET_TOL, + skips=( + # https://github.com/pytorch/pytorch/issues/67470 + DecorateInfo( + unittest.skip("67470!"), "TestCommon", "test_noncontiguous_samples" + ), + # Fails on XLA. + # AssertionError: False is not true : Tensors failed to compare as equal! + DecorateInfo( + unittest.skip("Skipped!"), + "TestOpInfo", + device_type="xla", + dtypes=(torch.long,), + ), + # https://github.com/pytorch/pytorch/issues/71774 + DecorateInfo( + unittest.skip("Skipped!"), + "TestNNCOpInfo", + "test_nnc_correctness", + device_type="cpu", + dtypes=(torch.long,), + ), + ), + ), + # NB: linalg.norm has two variants so that different skips can be used for different sample inputs + OpInfo( + "linalg.norm", + aten_name="linalg_norm", + op=torch.linalg.norm, + dtypes=floating_and_complex_types_and(torch.float16, torch.bfloat16), + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack, with_tf32_off], + sample_inputs_func=sample_inputs_linalg_norm, + supports_forward_ad=True, + check_batched_forward_grad=False, + supports_fwgrad_bwgrad=True, + skips=( + DecorateInfo( + unittest.expectedFailure, "TestBwdGradients", "test_fn_gradgrad" + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestFakeTensor", + "test_fake_crossref_backward_amp", + device_type="cuda", + dtypes=[torch.float32], + active_if=TEST_WITH_ROCM, + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestFakeTensor", + "test_fake_crossref_backward_no_amp", + device_type="cuda", + dtypes=[torch.float32], + active_if=TEST_WITH_ROCM, + ), + ), + ), + OpInfo( + "linalg.norm", + op=torch.linalg.norm, + variant_test_name="subgradients_at_zero", + dtypes=floating_and_complex_types_and(torch.float16, torch.bfloat16), + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack, with_tf32_off], + sample_inputs_func=partial( + sample_inputs_linalg_norm, variant="subgradient_at_zero" + ), + aten_name="linalg_norm", + supports_forward_ad=True, + # torch.autograd.gradcheck.GradcheckError: While computing batched gradients, got: + # Could not allocate memory to change Tensor SizesAndStrides! + check_batched_forward_grad=False, + supports_fwgrad_bwgrad=True, + skips=( + # [NEW] Skips specifically for sample inputs at zero + # norm's vjp/jvp are not well-conditioned near zero + DecorateInfo( + unittest.expectedFailure, "TestBwdGradients", "test_fn_gradgrad" + ), + DecorateInfo( + unittest.expectedFailure, "TestFwdGradients", "test_fn_fwgrad_bwgrad" + ), + DecorateInfo( + unittest.expectedFailure, "TestFwdGradients", "test_forward_mode_AD" + ), + DecorateInfo(unittest.expectedFailure, "TestBwdGradients", "test_fn_grad"), + ), + ), + OpInfo( + "linalg.matrix_norm", + aten_name="linalg_matrix_norm", + dtypes=floating_and_complex_types_and(torch.float16, torch.bfloat16), + supports_forward_ad=True, + check_batched_forward_grad=False, + check_batched_gradgrad=False, + supports_fwgrad_bwgrad=True, + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack, with_tf32_off], + sample_inputs_func=sample_inputs_linalg_matrix_norm, + skips=( + DecorateInfo( + unittest.skip("Skipped!"), + "TestFakeTensor", + "test_fake_crossref_backward_amp", + device_type="cuda", + dtypes=[torch.float32], + active_if=TEST_WITH_ROCM, + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestFakeTensor", + "test_fake_crossref_backward_no_amp", + device_type="cuda", + dtypes=[torch.float32], + active_if=TEST_WITH_ROCM, + ), + ), + ), + OpInfo( + "linalg.qr", + aten_name="linalg_qr", + op=torch.linalg.qr, + dtypes=floating_and_complex_types(), + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + # In-place ops + check_batched_gradgrad=False, + sample_inputs_func=sample_inputs_linalg_qr_geqrf, + decorators=[skipCUDAIfNoCusolver, skipCPUIfNoLapack], + ), + OpInfo( + "linalg.slogdet", + aten_name="linalg_slogdet", + op=torch.linalg.slogdet, + dtypes=floating_and_complex_types(), + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + sample_inputs_func=sample_inputs_linalg_det_logdet_slogdet, + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack], + ), + OpInfo( + "linalg.vander", + aten_name="linalg_vander", + ref=np_vander_batched, + op=torch.linalg.vander, + dtypes=all_types_and_complex(), + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + supports_out=False, + sample_inputs_func=sample_inputs_linalg_vander, + skips=( + DecorateInfo( + unittest.skip("Unsupported on MPS for now"), + "TestCommon", + "test_numpy_ref_mps", + ), + ), + ), + ReductionOpInfo( + "linalg.vector_norm", + op=torch.linalg.vector_norm, + identity=0, + nan_policy="propagate", + supports_multiple_dims=True, + complex_to_real=True, + supports_forward_ad=True, + # torch.autograd.gradcheck.GradcheckError: While computing batched gradients + # got: Could not allocate memory to change Tensor SizesAndStrides! + check_batched_forward_grad=False, + supports_fwgrad_bwgrad=True, + dtypes=floating_and_complex_types_and(torch.float16, torch.bfloat16), + generate_args_kwargs=sample_kwargs_vector_norm, + aten_name="linalg_vector_norm", + skips=( + # FIXME: sum reduces all dimensions when dim=[] + DecorateInfo(unittest.expectedFailure, "TestReductions", "test_dim_empty"), + DecorateInfo( + unittest.expectedFailure, "TestReductions", "test_dim_empty_keepdim" + ), + ), + ), + OpInfo( + "linalg.lu_factor", + aten_name="linalg_lu_factor", + op=torch.linalg.lu_factor, + dtypes=floating_and_complex_types(), + # Runs very slowly on slow gradcheck - alternatively reduce input sizes + # https://github.com/pytorch/pytorch/issues/80411 + gradcheck_fast_mode=True, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + sample_inputs_func=sample_inputs_linalg_lu, + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack], + skips=( + # linalg.lu_factor: LU without pivoting is not implemented on the CPU + DecorateInfo(unittest.expectedFailure, "TestCommon", "test_compare_cpu"), + ), + ), + OpInfo( + "linalg.lu_factor_ex", + aten_name="linalg_lu_factor_ex", + op=torch.linalg.lu_factor_ex, + dtypes=floating_and_complex_types(), + # https://github.com/pytorch/pytorch/issues/80411 + gradcheck_fast_mode=True, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + sample_inputs_func=sample_inputs_linalg_lu, + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack], + skips=( + # linalg.lu_factor: LU without pivoting is not implemented on the CPU + DecorateInfo(unittest.expectedFailure, "TestCommon", "test_compare_cpu"), + ), + ), + OpInfo( + "linalg.lu", + aten_name="linalg_lu", + op=torch.linalg.lu, + dtypes=floating_and_complex_types(), + # https://github.com/pytorch/pytorch/issues/80411 + # Runs very slowly on slow-gradcheck - alternatively reduce input sizes + gradcheck_fast_mode=True, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + sample_inputs_func=sample_inputs_linalg_lu, + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack], + skips=( + # linalg.lu_factor: LU without pivoting is not implemented on the CPU + DecorateInfo(unittest.expectedFailure, "TestCommon", "test_compare_cpu"), + ), + ), + OpInfo( + "linalg.lu_solve", + op=torch.linalg.lu_solve, + aten_name="linalg_lu_solve", + dtypes=floating_and_complex_types(), + # Runs very slowly on slow gradcheck - alternatively reduce input sizes + gradcheck_fast_mode=True, + supports_forward_ad=True, + check_batched_forward_grad=False, + supports_fwgrad_bwgrad=True, + sample_inputs_func=sample_inputs_lu_solve, + skips=( + DecorateInfo( + unittest.skip("Tests different backward paths"), + "TestCommon", + "test_floating_inputs_are_differentiable", + ), + ), + decorators=[skipCPUIfNoLapack, skipCUDAIfNoMagmaAndNoCusolver], + ), + OpInfo( + "linalg.inv", + aten_name="linalg_inv", + op=torch.linalg.inv, + aliases=("inverse",), + dtypes=floating_and_complex_types(), + sample_inputs_func=sample_inputs_linalg_invertible, + check_batched_gradgrad=False, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack], + skips=( + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_out", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_variant_consistency_eager", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestJit", + "test_variant_consistency_jit", + device_type="mps", + dtypes=[torch.float32], + ), + ), + ), + OpInfo( + "linalg.inv_ex", + aten_name="linalg_inv_ex", + op=torch.linalg.inv_ex, + dtypes=floating_and_complex_types(), + sample_inputs_func=sample_inputs_linalg_invertible, + check_batched_gradgrad=False, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack], + skips=( + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_out", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_variant_consistency_eager", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestJit", + "test_variant_consistency_jit", + device_type="mps", + dtypes=[torch.float32], + ), + ), + ), + OpInfo( + "linalg.solve", + aten_name="linalg_solve", + op=torch.linalg.solve, + dtypes=floating_and_complex_types(), + sample_inputs_func=sample_inputs_linalg_solve, + # Runs very slowly on slow gradcheck - alternatively reduce input sizes + gradcheck_fast_mode=True, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack], + skips=( + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_out", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_variant_consistency_eager", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestJit", + "test_variant_consistency_jit", + device_type="mps", + dtypes=[torch.float32], + ), + ), + ), + OpInfo( + "linalg.solve_ex", + aten_name="linalg_solve_ex", + op=torch.linalg.solve_ex, + dtypes=floating_and_complex_types(), + sample_inputs_func=sample_inputs_linalg_solve, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack], + skips=( + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_out", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_variant_consistency_eager", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestJit", + "test_variant_consistency_jit", + device_type="mps", + dtypes=[torch.float32], + ), + ), + ), + OpInfo( + "linalg.solve_triangular", + aten_name="linalg_solve_triangular", + op=torch.linalg.solve_triangular, + dtypes=floating_and_complex_types(), + sample_inputs_func=sample_inputs_linalg_solve_triangular, + supports_fwgrad_bwgrad=True, + skips=(skipCPUIfNoLapack,), + # linalg.solve_triangular cannot be batched over because of a call to out.copy_(result); + supports_forward_ad=True, + ), + OpInfo( + "linalg.matrix_rank", + aten_name="linalg_matrix_rank", + dtypes=floating_and_complex_types(), + supports_autograd=False, + sample_inputs_func=sample_inputs_matrix_rank, + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack], + skips=( + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_out", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_variant_consistency_eager", + device_type="mps", + dtypes=[torch.float32], + ), + # jit doesn't accept tensor inputs for matrix rank + DecorateInfo( + unittest.skip("Skipped!"), + "TestJit", + "test_variant_consistency_jit", + dtypes=[torch.complex64, torch.float32], + ), + ), + ), + OpInfo( + "linalg.matrix_rank", + aten_name="linalg_matrix_rank", + variant_test_name="hermitian", + dtypes=floating_and_complex_types(), + supports_autograd=False, + sample_inputs_func=sample_inputs_linalg_pinv_hermitian, + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack], + skips=( + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_out", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestJit", + "test_variant_consistency_jit", + device_type="mps", + dtypes=[torch.float32], + ), + ), + ), + OpInfo( + "linalg.pinv", + aten_name="linalg_pinv", + op=torch.linalg.pinv, + dtypes=floating_and_complex_types(), + # Runs very slowly on slow gradcheck - alternatively reduce input sizes + gradcheck_fast_mode=True, + check_batched_grad=False, + check_batched_gradgrad=False, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + sample_inputs_func=sample_inputs_linalg_pinv, + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack], + skips=( + # errors with "leaked XXXX bytes CUDA memory on device 0" + DecorateInfo( + unittest.skip("Skipped!"), + "TestJit", + "test_variant_consistency_jit", + device_type="cuda", + ), + ), + ), + OpInfo( + "linalg.pinv", + aten_name="linalg_pinv", + variant_test_name="singular", + # pinv is Frechet-differentiable in a rank-preserving neighborhood, + # so we feed inputs that are the products of two full-rank factors, + # to avoid any rank changes caused by the perturbations in the gradcheck + op=lambda a, b: torch.linalg.pinv(a @ b.mT), + dtypes=floating_and_complex_types(), + supports_out=False, + check_batched_grad=False, + check_batched_gradgrad=False, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + sample_inputs_func=sample_inputs_linalg_pinv_singular, + # Only large tensors show issues with implicit backward used prior to + # explicit backward implementation. + decorators=[slowTest, skipCUDAIfNoCusolver, skipCPUIfNoLapack], + skips=( + DecorateInfo( + unittest.expectedFailure, "TestJit", "test_variant_consistency_jit" + ), + # CUDA runs out of memory + DecorateInfo( + unittest.skip("Skipped!"), + "TestFwdGradients", + "test_fn_fwgrad_bwgrad", + device_type="cuda", + dtypes=[torch.cdouble], + ), + # This test takes almost 2 hours to run! + DecorateInfo( + unittest.skip("Skipped!"), + "TestBwdGradients", + "test_fn_gradgrad", + device_type="cuda", + dtypes=[torch.cdouble], + ), + ), + ), + OpInfo( + "linalg.pinv", + aten_name="linalg_pinv", + variant_test_name="hermitian", + dtypes=floating_and_complex_types(), + check_batched_grad=False, + check_batched_gradgrad=False, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + # See https://github.com/pytorch/pytorch/pull/78358 + check_batched_forward_grad=False, + sample_inputs_func=sample_inputs_linalg_pinv_hermitian, + gradcheck_wrapper=gradcheck_wrapper_hermitian_input, + decorators=[skipCUDAIfNoMagma, skipCPUIfNoLapack], + skips=( + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_out", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_variant_consistency_eager", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestJit", + "test_variant_consistency_jit", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + toleranceOverride({torch.float32: tol(atol=1e-5, rtol=1e-5)}), + "TestCommon", + "test_noncontiguous_samples", + device_type="cuda", + ), + # This test is flaky under slow gradcheck, likely due to rounding issues + DecorateInfo( + skipIfSlowGradcheckEnv, + "TestFwdGradients", + "test_fn_fwgrad_bwgrad", + device_type="cuda", + ), + ), + ), + OpInfo( + "linalg.svd", + op=torch.linalg.svd, + aten_name="linalg_svd", + decomp_aten_name="_linalg_svd", + dtypes=floating_and_complex_types(), + # Runs very slowly on slow-gradcheck - alternatively reduce input sizes + gradcheck_fast_mode=True, + supports_fwgrad_bwgrad=True, + supports_forward_ad=True, + check_batched_forward_grad=False, + # We're using at::allclose, which does not have a batching rule + check_batched_grad=False, + check_batched_gradgrad=False, + sample_inputs_func=sample_inputs_svd, + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack, with_tf32_off], + skips=( + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_out", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestCommon", + "test_variant_consistency_eager", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestJit", + "test_variant_consistency_jit", + device_type="mps", + dtypes=[torch.float32], + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestFakeTensor", + "test_fake_crossref_backward_amp", + device_type="cuda", + dtypes=[torch.float32], + active_if=TEST_WITH_ROCM, + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestFakeTensor", + "test_fake_crossref_backward_no_amp", + device_type="cuda", + dtypes=[torch.float32], + active_if=TEST_WITH_ROCM, + ), + ), + ), + OpInfo( + "linalg.svdvals", + op=torch.linalg.svdvals, + aten_name="linalg_svdvals", + decomp_aten_name="_linalg_svd", + dtypes=floating_and_complex_types(), + check_batched_forward_grad=False, + supports_fwgrad_bwgrad=True, + supports_forward_ad=True, + # We're using at::allclose, which does not have a batching rule + check_batched_gradgrad=False, + sample_inputs_func=sample_inputs_linalg_svdvals, + decorators=[skipCUDAIfNoMagmaAndNoCusolver, skipCPUIfNoLapack, with_tf32_off], + skips=( + DecorateInfo( + unittest.skip("Skipped!"), + "TestFakeTensor", + "test_fake_crossref_backward_amp", + device_type="cuda", + dtypes=[torch.float32], + active_if=TEST_WITH_ROCM, + ), + DecorateInfo( + unittest.skip("Skipped!"), + "TestFakeTensor", + "test_fake_crossref_backward_no_amp", + device_type="cuda", + dtypes=[torch.float32], + active_if=TEST_WITH_ROCM, + ), + ), + ), + OpInfo( + "linalg.tensorinv", + ref=np.linalg.tensorinv, + dtypes=floating_and_complex_types(), + sample_inputs_func=sample_inputs_tensorinv, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + # See https://github.com/pytorch/pytorch/pull/78358 + check_batched_forward_grad=False, + decorators=[skipCPUIfNoLapack, skipCUDAIfNoMagmaAndNoCusolver], + skips=( + DecorateInfo( + unittest.skip("Unsupported on MPS for now"), + "TestCommon", + "test_numpy_ref_mps", + ), + ), + ), + OpInfo( + "linalg.tensorsolve", + ref=lambda a, b, dims=None: np.linalg.tensorsolve(a, b, axes=dims), + dtypes=floating_and_complex_types(), + sample_inputs_func=sample_inputs_tensorsolve, + supports_forward_ad=True, + supports_fwgrad_bwgrad=True, + decorators=[ + skipCUDAIfNoMagmaAndNoCusolver, + skipCPUIfNoLapack, + DecorateInfo( + toleranceOverride({torch.float32: tol(atol=1e-03, rtol=1e-03)}), + "TestCommon", + "test_noncontiguous_samples", + device_type="cuda", + ), + ], + skips=( + DecorateInfo( + unittest.skip("Unsupported on MPS for now"), + "TestCommon", + "test_numpy_ref_mps", + ), + ), + ), +] + +python_ref_db: List[OpInfo] = [ + # + # torch.linalg + # + PythonRefInfo( + "_refs.linalg.cross", + torch_opinfo_name="linalg.cross", + supports_out=True, + op_db=op_db, + skips=( + # no _refs support for Tensor.__getitem__ + DecorateInfo(unittest.expectedFailure, "TestCommon", "test_python_ref"), + # TODO: is this really needed? + DecorateInfo( + unittest.expectedFailure, "TestCommon", "test_python_ref_errors" + ), + ), + ), + PythonRefInfo( + "_refs.linalg.diagonal", + torch_opinfo_name="linalg.diagonal", + supports_out=False, + op_db=op_db, + ), + PythonRefInfo( + "_refs.linalg.vecdot", + torch_opinfo_name="linalg.vecdot", + op_db=op_db, + ), + ReductionPythonRefInfo( + "_refs.linalg.vector_norm", + torch_opinfo_name="linalg.vector_norm", + supports_out=True, + op_db=op_db, + skips=( + # FIXME: sum reduces all dimensions when dim=[] + DecorateInfo(unittest.expectedFailure, "TestReductions", "test_dim_empty"), + DecorateInfo( + unittest.expectedFailure, "TestReductions", "test_dim_empty_keepdim" + ), + ), + ), + PythonRefInfo( + "_refs.linalg.matrix_norm", + torch_opinfo_name="linalg.matrix_norm", + supports_out=True, + # Uses vector_norm inside and vector_norm is affected by + # https://github.com/pytorch/pytorch/issues/77216 + validate_view_consistency=False, + op_db=op_db, + ), + PythonRefInfo( + "_refs.linalg.norm", + torch_opinfo_name="linalg.norm", + supports_out=True, + # Uses vector_norm inside and vector_norm is affected by + # https://github.com/pytorch/pytorch/issues/77216 + validate_view_consistency=False, + op_db=op_db, + ), + PythonRefInfo( + "_refs.linalg.svd", + torch_opinfo_name="linalg.svd", + supports_out=True, + op_db=op_db, + ), + PythonRefInfo( + "_refs.linalg.svdvals", + torch_opinfo_name="linalg.svdvals", + supports_out=True, + op_db=op_db, + ), +] diff --git a/shared/package-files/2f/2f1d086b642fd7ca8cde9c3c1bfbdda86f9178e42ffb035d2e285e27180f71ff/blob b/shared/package-files/2f/2f1d086b642fd7ca8cde9c3c1bfbdda86f9178e42ffb035d2e285e27180f71ff/blob new file mode 100644 index 0000000000000000000000000000000000000000..44214b1eea1c46ba6a1df1f0eaf50ee0b774112a --- /dev/null +++ b/shared/package-files/2f/2f1d086b642fd7ca8cde9c3c1bfbdda86f9178e42ffb035d2e285e27180f71ff/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2f1d086b642fd7ca8cde9c3c1bfbdda86f9178e42ffb035d2e285e27180f71ff +size 1035738 diff --git a/shared/package-files/2f/2f229d022d281d16f4f5e3ebd4df7c7a27783f02131f1c4ec14728818057fba7/blob b/shared/package-files/2f/2f229d022d281d16f4f5e3ebd4df7c7a27783f02131f1c4ec14728818057fba7/blob new file mode 100644 index 0000000000000000000000000000000000000000..31a2ab65131c1c575591a5453773fe17b3200b82 --- /dev/null +++ b/shared/package-files/2f/2f229d022d281d16f4f5e3ebd4df7c7a27783f02131f1c4ec14728818057fba7/blob @@ -0,0 +1,516 @@ +#pragma once + +#include +#include +#include +#include +#include +#include + +namespace torch { +/// An ordered dictionary implementation, akin to Python's `OrderedDict`. +template +class OrderedDict { + public: + /// A (key, value) pair. + class Item; + + // The lifetime of an iterator is bound to the lifetime of the `OrderedDict`. + // Further, any `insert()` operation may invalidate all iterators + // pointing into the vector. + using Iterator = typename std::vector::iterator; + using ConstIterator = typename std::vector::const_iterator; + + /// Constructs the `OrderedDict` with a short description of the kinds of keys + /// stored in the `OrderedDict`. This description is used in error messages + /// thrown by the `OrderedDict`. + explicit OrderedDict(std::string key_description = "Key"); + + /// Copy constructs this `OrderedDict` from `other`. + OrderedDict(const OrderedDict& other); + + /// Assigns items from `other` to this `OrderedDict`. + OrderedDict& operator=(const OrderedDict& other); + + // NB: Move works by default, because you can move-construct vectors of const + // values. I tried to make this noexcept (conditional on the move constructors + // of index_ and items_ being noexcept) but the obvious spelling didn't + // compile on Windows. + OrderedDict(OrderedDict&& other) noexcept = default; + OrderedDict& operator=(OrderedDict&& other) noexcept = default; + + ~OrderedDict() = default; + + /// Constructs a new `OrderedDict` and pre-populates it with the given + /// `Item`s. + /*implicit */ OrderedDict(std::initializer_list initializer_list); + + /// Returns the key description string the `OrderedDict` was constructed with. + const std::string& key_description() const noexcept; + + // Element Access + + /// Returns the very first item in the `OrderedDict` and throws an exception + /// if it is empty. + Item& front(); + + /// Returns the very first item in the `OrderedDict` and throws an exception + /// if it is empty. + const Item& front() const; + + /// Returns the very last item in the `OrderedDict` and throws an exception + /// if it is empty. + Item& back(); + + /// Returns the very last item in the `OrderedDict` and throws an exception + /// if it is empty. + const Item& back() const; + + /// Returns the item at the `index`-th position in the `OrderedDict`. Throws + /// an exception if the index is out of bounds. + Item& operator[](size_t index); + + /// Returns the item at the `index`-th position in the `OrderedDict`. Throws + /// an exception if the index is out of bounds. + const Item& operator[](size_t index) const; + + /// Returns the value associated with the given `key`. Throws an exception if + /// no such key is stored in the `OrderedDict`. Use `find()` for a + /// non-throwing way of accessing a value if it is present. + Value& operator[](const Key& key); + + /// Returns the value associated with the given `key`. Throws an exception if + /// no such key is stored in the `OrderedDict`. Use `find()` for a + /// non-throwing way of accessing a value if it is present. + const Value& operator[](const Key& key) const; + + // Lookup + + /// Returns a pointer to the value associated with the given key, or a + /// `nullptr` if no such key is stored in the `OrderedDict`. + Value* find(const Key& key) noexcept; + + /// Returns a pointer to the value associated with the given key, or a + /// `nullptr` if no such key is stored in the `OrderedDict`. + const Value* find(const Key& key) const noexcept; + + /// Returns true if the key is present in the `OrderedDict`. + bool contains(const Key& key) const noexcept; + + // Iterators + + /// Returns an iterator to the first item in the `OrderedDict`. Iteration is + /// ordered. + Iterator begin(); + + /// Returns an iterator to the first item in the `OrderedDict`. Iteration is + /// ordered. + ConstIterator begin() const; + + /// Returns an iterator one past the last item in the `OrderedDict`. + Iterator end(); + + /// Returns an iterator one past the last item in the `OrderedDict`. + ConstIterator end() const; + + // Capacity + + /// Returns the number of items currently stored in the `OrderedDict`. + size_t size() const noexcept; + + /// Returns true if the `OrderedDict` contains no elements. + bool is_empty() const noexcept; + + /// Resizes internal storage to fit at least `requested_capacity` items + /// without requiring reallocation. + void reserve(size_t requested_capacity); + + // Modifiers + + /// Inserts a new `(key, value)` pair into the `OrderedDict`. Throws an + /// exception if the key is already present. If insertion is successful, + /// immediately returns a reference to the inserted value. + template + Value& insert(K&& key, V&& value); + + /// Inserts a new `(key, value)` pair into the `OrderedDict`. Throws an + /// exception if the key is already present. If insertion is successful, + /// immediately returns a reference to the inserted value. + Value& insert(Key key, Value&& value); + + /// Inserts all items from `other` into this `OrderedDict`. If any key from + /// `other` is already present in this `OrderedDict`, an exception is thrown. + void update(OrderedDict&& other); + + /// Inserts all items from `other` into this `OrderedDict`. If any key from + /// `other` is already present in this `OrderedDict`, an exception is thrown. + void update(const OrderedDict& other); + + /// Removes the item that has `key` from this `OrderedDict` if exists and if + /// it doesn't an exception is thrown. + void erase(const Key& key); + + /// Removes all items from this `OrderedDict`. + void clear(); + + // Observers + + /// Returns the items stored in the `OrderedDict`. + const std::vector& items() const noexcept; + + /// Returns a newly allocated vector and copies all keys from this + /// `OrderedDict` into the vector. + ::std::vector keys() const; + + /// Returns a newly allocated vector and copies all values from this + /// `OrderedDict` into the vector. + ::std::vector values() const; + + /// Returns a newly allocated vector and copies all keys and values from this + /// `OrderedDict` into a vector of `std::pair`. + ::std::vector> pairs() const; + + /// Returns true if both dicts contain the same keys and values, in the same + /// order. + template + friend bool operator==( + const OrderedDict& a, + const OrderedDict& b); + + private: + /// A mapping from a key to an index into the `items_` vector. + ::std::unordered_map index_; + + /// The items stored in the `OrderedDict`. + ::std::vector items_; + + /// A description of the keys stored in the `OrderedDict`. + ::std::string key_description_{"Key"}; +}; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ OrderedDict::Item ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +template +class OrderedDict::Item { + public: + /// Constructs a new item. + Item(Key key, Value value) : pair_(std::move(key), std::move(value)) {} + + /// Returns a reference to the value. + Value& operator*() { + return value(); + } + + /// Returns a reference to the value. + const Value& operator*() const { + return value(); + } + + /// Allows access to the value using the arrow operator. + Value* operator->() { + return &value(); + } + + /// Allows access to the value using the arrow operator. + const Value* operator->() const { + return &value(); + } + + /// Returns a reference to the key. + const Key& key() const noexcept { + return pair_.first; + } + + /// Returns a reference to the value. + Value& value() noexcept { + return pair_.second; + } + + /// Returns a reference to the value. + const Value& value() const noexcept { + return pair_.second; + } + + /// Returns a `(key, value)` pair. + const std::pair& pair() const noexcept { + return pair_; + } + + private: + /// This is stored as an std::pair because it will make Python binding a lot, + /// lot easier. + ::std::pair pair_; +}; + +// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ OrderedDict ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +template +OrderedDict::OrderedDict(std::string key_description) + : key_description_(std::move(key_description)) {} + +template +OrderedDict::OrderedDict(const OrderedDict& other) + : index_(other.index_), key_description_(other.key_description_) { + // Copy we have to do ourselves, because items' keys are const, so we have to + // re-insert the items. + for (const auto& item : other.items_) { + items_.push_back(item); + } +} + +template +OrderedDict& OrderedDict::operator=( + const OrderedDict& other) { + index_ = other.index_; + items_.clear(); + for (auto& item : other.items_) { + items_.push_back(item); + } + key_description_ = other.key_description_; + return *this; +} + +template +OrderedDict::OrderedDict( + std::initializer_list initializer_list) + : OrderedDict("Key") { + items_.reserve(initializer_list.size()); + for (auto& item : initializer_list) { + // Copy the key here and move it into the index. + items_.emplace_back(item.key(), std::move(item.value())); + index_.emplace(std::move(item.key()), size() - 1); + } +} + +template +typename OrderedDict::Iterator OrderedDict::begin() { + return items_.begin(); +} + +template +typename OrderedDict::ConstIterator OrderedDict::begin() + const { + return items_.begin(); +} + +template +typename OrderedDict::Iterator OrderedDict::end() { + return items_.end(); +} + +template +typename OrderedDict::ConstIterator OrderedDict::end() + const { + return items_.end(); +} + +template +typename OrderedDict::Item& OrderedDict::front() { + TORCH_CHECK(!items_.empty(), "Called front() on an empty OrderedDict"); + return items_.front(); +} + +template +const typename OrderedDict::Item& OrderedDict::front() + const { + TORCH_CHECK(!items_.empty(), "Called front() on an empty OrderedDict"); + return items_.front(); +} + +template +typename OrderedDict::Item& OrderedDict::back() { + TORCH_CHECK(!items_.empty(), "Called back() on an empty OrderedDict"); + return items_.back(); +} + +template +const typename OrderedDict::Item& OrderedDict::back() + const { + TORCH_CHECK(!items_.empty(), "Called back() on an empty OrderedDict"); + return items_.back(); +} + +template +typename OrderedDict::Item& OrderedDict::operator[]( + size_t index) { + TORCH_CHECK(index < items_.size(), "Index ", index, " is out of bounds"); + return items_[index]; +} + +template +const typename OrderedDict::Item& OrderedDict:: +operator[](size_t index) const { + TORCH_CHECK(index < items_.size(), "Index ", index, " is out of bounds"); + return items_[index]; +} + +template +Value& OrderedDict::operator[](const Key& key) { + if (auto* value = find(key)) { + return *value; + } + AT_ERROR(key_description_, " '", key, "' is not defined"); +} + +template +const Value& OrderedDict::operator[](const Key& key) const { + if (auto* value = find(key)) { + return *value; + } + AT_ERROR(key_description_, " '", key, "' is not defined"); +} + +template +template +Value& OrderedDict::insert(K&& key, V&& value) { + TORCH_CHECK( + index_.count(key) == 0, key_description_, " '", key, "' already defined"); + // Copy `key` here and move it into the index. + items_.emplace_back(key, std::forward(value)); + index_.emplace(std::forward(key), size() - 1); + return items_.back().value(); +} + +template +Value& OrderedDict::insert(Key key, Value&& value) { + return insert(std::move(key), std::move(value)); +} + +template +void OrderedDict::update(OrderedDict&& other) { + reserve(size() + other.size()); + for (auto& item : other) { + // We want to call `insert()` to prevent duplicate keys. + insert(std::move(item.key()), std::move(item.value())); + } +} + +template +void OrderedDict::update(const OrderedDict& other) { + reserve(size() + other.size()); + for (auto& item : other) { + // We want to call `insert()` to prevent duplicate keys. + insert(item.key(), item.value()); + } +} + +template +Value* OrderedDict::find(const Key& key) noexcept { + auto iterator = index_.find(key); + if (iterator == index_.end()) { + return nullptr; + } + return &items_[iterator->second].value(); +} + +template +const Value* OrderedDict::find(const Key& key) const noexcept { + auto iterator = index_.find(key); + if (iterator == index_.end()) { + return nullptr; + } + return &items_[iterator->second].value(); +} + +template +void OrderedDict::erase(const Key& key) { + auto it = index_.find(key); + TORCH_CHECK(it != index_.end(), "Key '", key, "' doesn't exist"); + + auto index = it->second; + index_.erase(it); + items_.erase(items_.begin() + index); + + for (auto& pair : index_) + if (pair.second > index) + --pair.second; +} + +template +bool OrderedDict::contains(const Key& key) const noexcept { + return find(key) != nullptr; +} + +template +void OrderedDict::clear() { + index_.clear(); + items_.clear(); +} + +template +size_t OrderedDict::size() const noexcept { + return items_.size(); +} + +template +bool OrderedDict::is_empty() const noexcept { + return items_.empty(); +} + +template +const std::string& OrderedDict::key_description() const noexcept { + return key_description_; +} + +template +const std::vector::Item>& OrderedDict< + Key, + Value>::items() const noexcept { + return items_; +} + +template +::std::vector OrderedDict::keys() const { + std::vector keys; + keys.reserve(size()); + for (const auto& item : items_) { + keys.push_back(item.key()); + } + return keys; +} + +template +::std::vector OrderedDict::values() const { + std::vector values; + values.reserve(size()); + for (const auto& item : items_) { + values.push_back(item.value()); + } + return values; +} + +template +::std::vector> OrderedDict::pairs() const { + std::vector> values; + values.reserve(size()); + for (const auto& item : items_) { + values.push_back(item.pair()); + } + return values; +} + +template +void OrderedDict::reserve(size_t requested_capacity) { + index_.reserve(requested_capacity); + items_.reserve(requested_capacity); +} + +template +bool operator==( + const torch::OrderedDict& a, + const torch::OrderedDict& b) { + using Item = typename torch::OrderedDict::Item; + if (a.index_ != b.index_) + return false; + if (a.items_.size() != b.items_.size()) + return false; + // NOTE: There's no point in comparing keys for items_, as we already know + // that index is equal. + return std::equal( + a.items_.begin(), + a.items_.end(), + b.items_.begin(), + [](const Item& a, const Item& b) { return a.value() == b.value(); }); +} + +} // namespace torch diff --git a/shared/package-files/2f/2f24746181c90c7e6fa694331b31a224af9a688575eff26695af1d31ff77a258/blob b/shared/package-files/2f/2f24746181c90c7e6fa694331b31a224af9a688575eff26695af1d31ff77a258/blob new file mode 100644 index 0000000000000000000000000000000000000000..d29b306d2b13c2457905c41218e5c60793b309ba --- /dev/null +++ b/shared/package-files/2f/2f24746181c90c7e6fa694331b31a224af9a688575eff26695af1d31ff77a258/blob @@ -0,0 +1,26 @@ +"""Unit tests for the :mod:`networkx.algorithms.isolates` module.""" + +import networkx as nx + + +def test_is_isolate(): + G = nx.Graph() + G.add_edge(0, 1) + G.add_node(2) + assert not nx.is_isolate(G, 0) + assert not nx.is_isolate(G, 1) + assert nx.is_isolate(G, 2) + + +def test_isolates(): + G = nx.Graph() + G.add_edge(0, 1) + G.add_nodes_from([2, 3]) + assert sorted(nx.isolates(G)) == [2, 3] + + +def test_number_of_isolates(): + G = nx.Graph() + G.add_edge(0, 1) + G.add_nodes_from([2, 3]) + assert nx.number_of_isolates(G) == 2 diff --git a/shared/package-files/2f/2f24d5636740371fa2fd3124e58afd61cc14b62cb41ce10508042ad45ff8e9ca/blob b/shared/package-files/2f/2f24d5636740371fa2fd3124e58afd61cc14b62cb41ce10508042ad45ff8e9ca/blob new file mode 100644 index 0000000000000000000000000000000000000000..d95fe44b34a936dc178c89d98ee9ef093cb0fccb --- /dev/null +++ b/shared/package-files/2f/2f24d5636740371fa2fd3124e58afd61cc14b62cb41ce10508042ad45ff8e9ca/blob @@ -0,0 +1,733 @@ +"""Exceptions used throughout package. + +This module MUST NOT try to import from anything within `pip._internal` to +operate. This is expected to be importable from any/all files within the +subpackage and, thus, should not depend on them. +""" + +import configparser +import contextlib +import locale +import logging +import pathlib +import re +import sys +from itertools import chain, groupby, repeat +from typing import TYPE_CHECKING, Dict, Iterator, List, Optional, Union + +from pip._vendor.requests.models import Request, Response +from pip._vendor.rich.console import Console, ConsoleOptions, RenderResult +from pip._vendor.rich.markup import escape +from pip._vendor.rich.text import Text + +if TYPE_CHECKING: + from hashlib import _Hash + from typing import Literal + + from pip._internal.metadata import BaseDistribution + from pip._internal.req.req_install import InstallRequirement + +logger = logging.getLogger(__name__) + + +# +# Scaffolding +# +def _is_kebab_case(s: str) -> bool: + return re.match(r"^[a-z]+(-[a-z]+)*$", s) is not None + + +def _prefix_with_indent( + s: Union[Text, str], + console: Console, + *, + prefix: str, + indent: str, +) -> Text: + if isinstance(s, Text): + text = s + else: + text = console.render_str(s) + + return console.render_str(prefix, overflow="ignore") + console.render_str( + f"\n{indent}", overflow="ignore" + ).join(text.split(allow_blank=True)) + + +class PipError(Exception): + """The base pip error.""" + + +class DiagnosticPipError(PipError): + """An error, that presents diagnostic information to the user. + + This contains a bunch of logic, to enable pretty presentation of our error + messages. Each error gets a unique reference. Each error can also include + additional context, a hint and/or a note -- which are presented with the + main error message in a consistent style. + + This is adapted from the error output styling in `sphinx-theme-builder`. + """ + + reference: str + + def __init__( + self, + *, + kind: 'Literal["error", "warning"]' = "error", + reference: Optional[str] = None, + message: Union[str, Text], + context: Optional[Union[str, Text]], + hint_stmt: Optional[Union[str, Text]], + note_stmt: Optional[Union[str, Text]] = None, + link: Optional[str] = None, + ) -> None: + # Ensure a proper reference is provided. + if reference is None: + assert hasattr(self, "reference"), "error reference not provided!" + reference = self.reference + assert _is_kebab_case(reference), "error reference must be kebab-case!" + + self.kind = kind + self.reference = reference + + self.message = message + self.context = context + + self.note_stmt = note_stmt + self.hint_stmt = hint_stmt + + self.link = link + + super().__init__(f"<{self.__class__.__name__}: {self.reference}>") + + def __repr__(self) -> str: + return ( + f"<{self.__class__.__name__}(" + f"reference={self.reference!r}, " + f"message={self.message!r}, " + f"context={self.context!r}, " + f"note_stmt={self.note_stmt!r}, " + f"hint_stmt={self.hint_stmt!r}" + ")>" + ) + + def __rich_console__( + self, + console: Console, + options: ConsoleOptions, + ) -> RenderResult: + colour = "red" if self.kind == "error" else "yellow" + + yield f"[{colour} bold]{self.kind}[/]: [bold]{self.reference}[/]" + yield "" + + if not options.ascii_only: + # Present the main message, with relevant context indented. + if self.context is not None: + yield _prefix_with_indent( + self.message, + console, + prefix=f"[{colour}]×[/] ", + indent=f"[{colour}]│[/] ", + ) + yield _prefix_with_indent( + self.context, + console, + prefix=f"[{colour}]╰─>[/] ", + indent=f"[{colour}] [/] ", + ) + else: + yield _prefix_with_indent( + self.message, + console, + prefix="[red]×[/] ", + indent=" ", + ) + else: + yield self.message + if self.context is not None: + yield "" + yield self.context + + if self.note_stmt is not None or self.hint_stmt is not None: + yield "" + + if self.note_stmt is not None: + yield _prefix_with_indent( + self.note_stmt, + console, + prefix="[magenta bold]note[/]: ", + indent=" ", + ) + if self.hint_stmt is not None: + yield _prefix_with_indent( + self.hint_stmt, + console, + prefix="[cyan bold]hint[/]: ", + indent=" ", + ) + + if self.link is not None: + yield "" + yield f"Link: {self.link}" + + +# +# Actual Errors +# +class ConfigurationError(PipError): + """General exception in configuration""" + + +class InstallationError(PipError): + """General exception during installation""" + + +class UninstallationError(PipError): + """General exception during uninstallation""" + + +class MissingPyProjectBuildRequires(DiagnosticPipError): + """Raised when pyproject.toml has `build-system`, but no `build-system.requires`.""" + + reference = "missing-pyproject-build-system-requires" + + def __init__(self, *, package: str) -> None: + super().__init__( + message=f"Can not process {escape(package)}", + context=Text( + "This package has an invalid pyproject.toml file.\n" + "The [build-system] table is missing the mandatory `requires` key." + ), + note_stmt="This is an issue with the package mentioned above, not pip.", + hint_stmt=Text("See PEP 518 for the detailed specification."), + ) + + +class InvalidPyProjectBuildRequires(DiagnosticPipError): + """Raised when pyproject.toml an invalid `build-system.requires`.""" + + reference = "invalid-pyproject-build-system-requires" + + def __init__(self, *, package: str, reason: str) -> None: + super().__init__( + message=f"Can not process {escape(package)}", + context=Text( + "This package has an invalid `build-system.requires` key in " + f"pyproject.toml.\n{reason}" + ), + note_stmt="This is an issue with the package mentioned above, not pip.", + hint_stmt=Text("See PEP 518 for the detailed specification."), + ) + + +class NoneMetadataError(PipError): + """Raised when accessing a Distribution's "METADATA" or "PKG-INFO". + + This signifies an inconsistency, when the Distribution claims to have + the metadata file (if not, raise ``FileNotFoundError`` instead), but is + not actually able to produce its content. This may be due to permission + errors. + """ + + def __init__( + self, + dist: "BaseDistribution", + metadata_name: str, + ) -> None: + """ + :param dist: A Distribution object. + :param metadata_name: The name of the metadata being accessed + (can be "METADATA" or "PKG-INFO"). + """ + self.dist = dist + self.metadata_name = metadata_name + + def __str__(self) -> str: + # Use `dist` in the error message because its stringification + # includes more information, like the version and location. + return "None {} metadata found for distribution: {}".format( + self.metadata_name, + self.dist, + ) + + +class UserInstallationInvalid(InstallationError): + """A --user install is requested on an environment without user site.""" + + def __str__(self) -> str: + return "User base directory is not specified" + + +class InvalidSchemeCombination(InstallationError): + def __str__(self) -> str: + before = ", ".join(str(a) for a in self.args[:-1]) + return f"Cannot set {before} and {self.args[-1]} together" + + +class DistributionNotFound(InstallationError): + """Raised when a distribution cannot be found to satisfy a requirement""" + + +class RequirementsFileParseError(InstallationError): + """Raised when a general error occurs parsing a requirements file line.""" + + +class BestVersionAlreadyInstalled(PipError): + """Raised when the most up-to-date version of a package is already + installed.""" + + +class BadCommand(PipError): + """Raised when virtualenv or a command is not found""" + + +class CommandError(PipError): + """Raised when there is an error in command-line arguments""" + + +class PreviousBuildDirError(PipError): + """Raised when there's a previous conflicting build directory""" + + +class NetworkConnectionError(PipError): + """HTTP connection error""" + + def __init__( + self, + error_msg: str, + response: Optional[Response] = None, + request: Optional[Request] = None, + ) -> None: + """ + Initialize NetworkConnectionError with `request` and `response` + objects. + """ + self.response = response + self.request = request + self.error_msg = error_msg + if ( + self.response is not None + and not self.request + and hasattr(response, "request") + ): + self.request = self.response.request + super().__init__(error_msg, response, request) + + def __str__(self) -> str: + return str(self.error_msg) + + +class InvalidWheelFilename(InstallationError): + """Invalid wheel filename.""" + + +class UnsupportedWheel(InstallationError): + """Unsupported wheel.""" + + +class InvalidWheel(InstallationError): + """Invalid (e.g. corrupt) wheel.""" + + def __init__(self, location: str, name: str): + self.location = location + self.name = name + + def __str__(self) -> str: + return f"Wheel '{self.name}' located at {self.location} is invalid." + + +class MetadataInconsistent(InstallationError): + """Built metadata contains inconsistent information. + + This is raised when the metadata contains values (e.g. name and version) + that do not match the information previously obtained from sdist filename, + user-supplied ``#egg=`` value, or an install requirement name. + """ + + def __init__( + self, ireq: "InstallRequirement", field: str, f_val: str, m_val: str + ) -> None: + self.ireq = ireq + self.field = field + self.f_val = f_val + self.m_val = m_val + + def __str__(self) -> str: + return ( + f"Requested {self.ireq} has inconsistent {self.field}: " + f"expected {self.f_val!r}, but metadata has {self.m_val!r}" + ) + + +class InstallationSubprocessError(DiagnosticPipError, InstallationError): + """A subprocess call failed.""" + + reference = "subprocess-exited-with-error" + + def __init__( + self, + *, + command_description: str, + exit_code: int, + output_lines: Optional[List[str]], + ) -> None: + if output_lines is None: + output_prompt = Text("See above for output.") + else: + output_prompt = ( + Text.from_markup(f"[red][{len(output_lines)} lines of output][/]\n") + + Text("".join(output_lines)) + + Text.from_markup(R"[red]\[end of output][/]") + ) + + super().__init__( + message=( + f"[green]{escape(command_description)}[/] did not run successfully.\n" + f"exit code: {exit_code}" + ), + context=output_prompt, + hint_stmt=None, + note_stmt=( + "This error originates from a subprocess, and is likely not a " + "problem with pip." + ), + ) + + self.command_description = command_description + self.exit_code = exit_code + + def __str__(self) -> str: + return f"{self.command_description} exited with {self.exit_code}" + + +class MetadataGenerationFailed(InstallationSubprocessError, InstallationError): + reference = "metadata-generation-failed" + + def __init__( + self, + *, + package_details: str, + ) -> None: + super(InstallationSubprocessError, self).__init__( + message="Encountered error while generating package metadata.", + context=escape(package_details), + hint_stmt="See above for details.", + note_stmt="This is an issue with the package mentioned above, not pip.", + ) + + def __str__(self) -> str: + return "metadata generation failed" + + +class HashErrors(InstallationError): + """Multiple HashError instances rolled into one for reporting""" + + def __init__(self) -> None: + self.errors: List["HashError"] = [] + + def append(self, error: "HashError") -> None: + self.errors.append(error) + + def __str__(self) -> str: + lines = [] + self.errors.sort(key=lambda e: e.order) + for cls, errors_of_cls in groupby(self.errors, lambda e: e.__class__): + lines.append(cls.head) + lines.extend(e.body() for e in errors_of_cls) + if lines: + return "\n".join(lines) + return "" + + def __bool__(self) -> bool: + return bool(self.errors) + + +class HashError(InstallationError): + """ + A failure to verify a package against known-good hashes + + :cvar order: An int sorting hash exception classes by difficulty of + recovery (lower being harder), so the user doesn't bother fretting + about unpinned packages when he has deeper issues, like VCS + dependencies, to deal with. Also keeps error reports in a + deterministic order. + :cvar head: A section heading for display above potentially many + exceptions of this kind + :ivar req: The InstallRequirement that triggered this error. This is + pasted on after the exception is instantiated, because it's not + typically available earlier. + + """ + + req: Optional["InstallRequirement"] = None + head = "" + order: int = -1 + + def body(self) -> str: + """Return a summary of me for display under the heading. + + This default implementation simply prints a description of the + triggering requirement. + + :param req: The InstallRequirement that provoked this error, with + its link already populated by the resolver's _populate_link(). + + """ + return f" {self._requirement_name()}" + + def __str__(self) -> str: + return f"{self.head}\n{self.body()}" + + def _requirement_name(self) -> str: + """Return a description of the requirement that triggered me. + + This default implementation returns long description of the req, with + line numbers + + """ + return str(self.req) if self.req else "unknown package" + + +class VcsHashUnsupported(HashError): + """A hash was provided for a version-control-system-based requirement, but + we don't have a method for hashing those.""" + + order = 0 + head = ( + "Can't verify hashes for these requirements because we don't " + "have a way to hash version control repositories:" + ) + + +class DirectoryUrlHashUnsupported(HashError): + """A hash was provided for a version-control-system-based requirement, but + we don't have a method for hashing those.""" + + order = 1 + head = ( + "Can't verify hashes for these file:// requirements because they " + "point to directories:" + ) + + +class HashMissing(HashError): + """A hash was needed for a requirement but is absent.""" + + order = 2 + head = ( + "Hashes are required in --require-hashes mode, but they are " + "missing from some requirements. Here is a list of those " + "requirements along with the hashes their downloaded archives " + "actually had. Add lines like these to your requirements files to " + "prevent tampering. (If you did not enable --require-hashes " + "manually, note that it turns on automatically when any package " + "has a hash.)" + ) + + def __init__(self, gotten_hash: str) -> None: + """ + :param gotten_hash: The hash of the (possibly malicious) archive we + just downloaded + """ + self.gotten_hash = gotten_hash + + def body(self) -> str: + # Dodge circular import. + from pip._internal.utils.hashes import FAVORITE_HASH + + package = None + if self.req: + # In the case of URL-based requirements, display the original URL + # seen in the requirements file rather than the package name, + # so the output can be directly copied into the requirements file. + package = ( + self.req.original_link + if self.req.is_direct + # In case someone feeds something downright stupid + # to InstallRequirement's constructor. + else getattr(self.req, "req", None) + ) + return " {} --hash={}:{}".format( + package or "unknown package", FAVORITE_HASH, self.gotten_hash + ) + + +class HashUnpinned(HashError): + """A requirement had a hash specified but was not pinned to a specific + version.""" + + order = 3 + head = ( + "In --require-hashes mode, all requirements must have their " + "versions pinned with ==. These do not:" + ) + + +class HashMismatch(HashError): + """ + Distribution file hash values don't match. + + :ivar package_name: The name of the package that triggered the hash + mismatch. Feel free to write to this after the exception is raise to + improve its error message. + + """ + + order = 4 + head = ( + "THESE PACKAGES DO NOT MATCH THE HASHES FROM THE REQUIREMENTS " + "FILE. If you have updated the package versions, please update " + "the hashes. Otherwise, examine the package contents carefully; " + "someone may have tampered with them." + ) + + def __init__(self, allowed: Dict[str, List[str]], gots: Dict[str, "_Hash"]) -> None: + """ + :param allowed: A dict of algorithm names pointing to lists of allowed + hex digests + :param gots: A dict of algorithm names pointing to hashes we + actually got from the files under suspicion + """ + self.allowed = allowed + self.gots = gots + + def body(self) -> str: + return " {}:\n{}".format(self._requirement_name(), self._hash_comparison()) + + def _hash_comparison(self) -> str: + """ + Return a comparison of actual and expected hash values. + + Example:: + + Expected sha256 abcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde + or 123451234512345123451234512345123451234512345 + Got bcdefbcdefbcdefbcdefbcdefbcdefbcdefbcdefbcdef + + """ + + def hash_then_or(hash_name: str) -> "chain[str]": + # For now, all the decent hashes have 6-char names, so we can get + # away with hard-coding space literals. + return chain([hash_name], repeat(" or")) + + lines: List[str] = [] + for hash_name, expecteds in self.allowed.items(): + prefix = hash_then_or(hash_name) + lines.extend( + (" Expected {} {}".format(next(prefix), e)) for e in expecteds + ) + lines.append( + " Got {}\n".format(self.gots[hash_name].hexdigest()) + ) + return "\n".join(lines) + + +class UnsupportedPythonVersion(InstallationError): + """Unsupported python version according to Requires-Python package + metadata.""" + + +class ConfigurationFileCouldNotBeLoaded(ConfigurationError): + """When there are errors while loading a configuration file""" + + def __init__( + self, + reason: str = "could not be loaded", + fname: Optional[str] = None, + error: Optional[configparser.Error] = None, + ) -> None: + super().__init__(error) + self.reason = reason + self.fname = fname + self.error = error + + def __str__(self) -> str: + if self.fname is not None: + message_part = f" in {self.fname}." + else: + assert self.error is not None + message_part = f".\n{self.error}\n" + return f"Configuration file {self.reason}{message_part}" + + +_DEFAULT_EXTERNALLY_MANAGED_ERROR = f"""\ +The Python environment under {sys.prefix} is managed externally, and may not be +manipulated by the user. Please use specific tooling from the distributor of +the Python installation to interact with this environment instead. +""" + + +class ExternallyManagedEnvironment(DiagnosticPipError): + """The current environment is externally managed. + + This is raised when the current environment is externally managed, as + defined by `PEP 668`_. The ``EXTERNALLY-MANAGED`` configuration is checked + and displayed when the error is bubbled up to the user. + + :param error: The error message read from ``EXTERNALLY-MANAGED``. + """ + + reference = "externally-managed-environment" + + def __init__(self, error: Optional[str]) -> None: + if error is None: + context = Text(_DEFAULT_EXTERNALLY_MANAGED_ERROR) + else: + context = Text(error) + super().__init__( + message="This environment is externally managed", + context=context, + note_stmt=( + "If you believe this is a mistake, please contact your " + "Python installation or OS distribution provider. " + "You can override this, at the risk of breaking your Python " + "installation or OS, by passing --break-system-packages." + ), + hint_stmt=Text("See PEP 668 for the detailed specification."), + ) + + @staticmethod + def _iter_externally_managed_error_keys() -> Iterator[str]: + # LC_MESSAGES is in POSIX, but not the C standard. The most common + # platform that does not implement this category is Windows, where + # using other categories for console message localization is equally + # unreliable, so we fall back to the locale-less vendor message. This + # can always be re-evaluated when a vendor proposes a new alternative. + try: + category = locale.LC_MESSAGES + except AttributeError: + lang: Optional[str] = None + else: + lang, _ = locale.getlocale(category) + if lang is not None: + yield f"Error-{lang}" + for sep in ("-", "_"): + before, found, _ = lang.partition(sep) + if not found: + continue + yield f"Error-{before}" + yield "Error" + + @classmethod + def from_config( + cls, + config: Union[pathlib.Path, str], + ) -> "ExternallyManagedEnvironment": + parser = configparser.ConfigParser(interpolation=None) + try: + parser.read(config, encoding="utf-8") + section = parser["externally-managed"] + for key in cls._iter_externally_managed_error_keys(): + with contextlib.suppress(KeyError): + return cls(section[key]) + except KeyError: + pass + except (OSError, UnicodeDecodeError, configparser.ParsingError): + from pip._internal.utils._log import VERBOSE + + exc_info = logger.isEnabledFor(VERBOSE) + logger.warning("Failed to read %s", config, exc_info=exc_info) + return cls(None) diff --git a/shared/package-files/2f/2f2587c0cadbe69817ebdb786fda2e1df9572a9e2005769d4c291a65293f1c1e/blob b/shared/package-files/2f/2f2587c0cadbe69817ebdb786fda2e1df9572a9e2005769d4c291a65293f1c1e/blob new file mode 100644 index 0000000000000000000000000000000000000000..31386e4e342ae3676a5468cfff5035686821fd52 --- /dev/null +++ b/shared/package-files/2f/2f2587c0cadbe69817ebdb786fda2e1df9572a9e2005769d4c291a65293f1c1e/blob @@ -0,0 +1,53 @@ +import numpy as np + +from pandas import ( + DataFrame, + Index, + MultiIndex, + Series, + _testing as tm, +) + + +def test_get_dummies(any_string_dtype): + s = Series(["a|b", "a|c", np.nan], dtype=any_string_dtype) + result = s.str.get_dummies("|") + expected = DataFrame([[1, 1, 0], [1, 0, 1], [0, 0, 0]], columns=list("abc")) + tm.assert_frame_equal(result, expected) + + s = Series(["a;b", "a", 7], dtype=any_string_dtype) + result = s.str.get_dummies(";") + expected = DataFrame([[0, 1, 1], [0, 1, 0], [1, 0, 0]], columns=list("7ab")) + tm.assert_frame_equal(result, expected) + + +def test_get_dummies_index(): + # GH9980, GH8028 + idx = Index(["a|b", "a|c", "b|c"]) + result = idx.str.get_dummies("|") + + expected = MultiIndex.from_tuples( + [(1, 1, 0), (1, 0, 1), (0, 1, 1)], names=("a", "b", "c") + ) + tm.assert_index_equal(result, expected) + + +def test_get_dummies_with_name_dummy(any_string_dtype): + # GH 12180 + # Dummies named 'name' should work as expected + s = Series(["a", "b,name", "b"], dtype=any_string_dtype) + result = s.str.get_dummies(",") + expected = DataFrame([[1, 0, 0], [0, 1, 1], [0, 1, 0]], columns=["a", "b", "name"]) + tm.assert_frame_equal(result, expected) + + +def test_get_dummies_with_name_dummy_index(): + # GH 12180 + # Dummies named 'name' should work as expected + idx = Index(["a|b", "name|c", "b|name"]) + result = idx.str.get_dummies("|") + + expected = MultiIndex.from_tuples( + [(1, 1, 0, 0), (0, 0, 1, 1), (0, 1, 0, 1)], names=("a", "b", "c", "name") + ) + tm.assert_index_equal(result, expected) diff --git a/shared/package-files/2f/2f29d7f1d2ceca07f10df172c0e826ef08163a14b12c6ef3fa80ec53a5fcdc3c/blob b/shared/package-files/2f/2f29d7f1d2ceca07f10df172c0e826ef08163a14b12c6ef3fa80ec53a5fcdc3c/blob new file mode 100644 index 0000000000000000000000000000000000000000..8d8ef8ca531f69de09080dbcaa57bae1ed2ca6ed Binary files /dev/null and b/shared/package-files/2f/2f29d7f1d2ceca07f10df172c0e826ef08163a14b12c6ef3fa80ec53a5fcdc3c/blob differ diff --git a/shared/package-files/2f/2f2d25d3092ef3408c762cefd5408a131d928a9f52ff405dd0f4c27d03d81cb7/blob b/shared/package-files/2f/2f2d25d3092ef3408c762cefd5408a131d928a9f52ff405dd0f4c27d03d81cb7/blob new file mode 100644 index 0000000000000000000000000000000000000000..7e1a89b631b51a03e4eeb94783abc422e5af64f5 --- /dev/null +++ b/shared/package-files/2f/2f2d25d3092ef3408c762cefd5408a131d928a9f52ff405dd0f4c27d03d81cb7/blob @@ -0,0 +1,4 @@ +processor : 0 +cpu : POWER9, altivec supported +clock : 3666.000000MHz +revision : 2.2 (pvr 004e 1202) diff --git a/shared/package-files/2f/2f2d76a0f63225536b74e0c133e17d7553b51332b7862888b4c81acb48434001/blob b/shared/package-files/2f/2f2d76a0f63225536b74e0c133e17d7553b51332b7862888b4c81acb48434001/blob new file mode 100644 index 0000000000000000000000000000000000000000..64890a19a5f683994686238524888fa7afb5d0de --- /dev/null +++ b/shared/package-files/2f/2f2d76a0f63225536b74e0c133e17d7553b51332b7862888b4c81acb48434001/blob @@ -0,0 +1,97 @@ +from typing import Any + +from yaml.error import MarkedYAMLError + +class ScannerError(MarkedYAMLError): ... + +class SimpleKey: + token_number: Any + required: Any + index: Any + line: Any + column: Any + mark: Any + def __init__(self, token_number, required, index, line, column, mark) -> None: ... + +class Scanner: + done: Any + flow_level: Any + tokens: Any + tokens_taken: Any + indent: Any + indents: Any + allow_simple_key: Any + possible_simple_keys: Any + def __init__(self) -> None: ... + def check_token(self, *choices): ... + def peek_token(self): ... + def get_token(self): ... + def need_more_tokens(self): ... + def fetch_more_tokens(self): ... + def next_possible_simple_key(self): ... + def stale_possible_simple_keys(self): ... + def save_possible_simple_key(self): ... + def remove_possible_simple_key(self): ... + def unwind_indent(self, column): ... + def add_indent(self, column): ... + def fetch_stream_start(self): ... + def fetch_stream_end(self): ... + def fetch_directive(self): ... + def fetch_document_start(self): ... + def fetch_document_end(self): ... + def fetch_document_indicator(self, TokenClass): ... + def fetch_flow_sequence_start(self): ... + def fetch_flow_mapping_start(self): ... + def fetch_flow_collection_start(self, TokenClass): ... + def fetch_flow_sequence_end(self): ... + def fetch_flow_mapping_end(self): ... + def fetch_flow_collection_end(self, TokenClass): ... + def fetch_flow_entry(self): ... + def fetch_block_entry(self): ... + def fetch_key(self): ... + def fetch_value(self): ... + def fetch_alias(self): ... + def fetch_anchor(self): ... + def fetch_tag(self): ... + def fetch_literal(self): ... + def fetch_folded(self): ... + def fetch_block_scalar(self, style): ... + def fetch_single(self): ... + def fetch_double(self): ... + def fetch_flow_scalar(self, style): ... + def fetch_plain(self): ... + def check_directive(self): ... + def check_document_start(self): ... + def check_document_end(self): ... + def check_block_entry(self): ... + def check_key(self): ... + def check_value(self): ... + def check_plain(self): ... + def scan_to_next_token(self): ... + def scan_directive(self): ... + def scan_directive_name(self, start_mark): ... + def scan_yaml_directive_value(self, start_mark): ... + def scan_yaml_directive_number(self, start_mark): ... + def scan_tag_directive_value(self, start_mark): ... + def scan_tag_directive_handle(self, start_mark): ... + def scan_tag_directive_prefix(self, start_mark): ... + def scan_directive_ignored_line(self, start_mark): ... + def scan_anchor(self, TokenClass): ... + def scan_tag(self): ... + def scan_block_scalar(self, style): ... + def scan_block_scalar_indicators(self, start_mark): ... + def scan_block_scalar_ignored_line(self, start_mark): ... + def scan_block_scalar_indentation(self): ... + def scan_block_scalar_breaks(self, indent): ... + def scan_flow_scalar(self, style): ... + ESCAPE_REPLACEMENTS: Any + ESCAPE_CODES: Any + def scan_flow_scalar_non_spaces(self, double, start_mark): ... + def scan_flow_scalar_spaces(self, double, start_mark): ... + def scan_flow_scalar_breaks(self, double, start_mark): ... + def scan_plain(self): ... + def scan_plain_spaces(self, indent, start_mark): ... + def scan_tag_handle(self, name, start_mark): ... + def scan_tag_uri(self, name, start_mark): ... + def scan_uri_escapes(self, name, start_mark): ... + def scan_line_break(self): ... diff --git a/shared/package-files/2f/2f2db7ff3411781ea7c5a665009b54a979652b7f461cdfbc019ec14cfe48c59b/blob b/shared/package-files/2f/2f2db7ff3411781ea7c5a665009b54a979652b7f461cdfbc019ec14cfe48c59b/blob new file mode 100644 index 0000000000000000000000000000000000000000..bba38946c506cebd0fd9413670976413d61f82a7 --- /dev/null +++ b/shared/package-files/2f/2f2db7ff3411781ea7c5a665009b54a979652b7f461cdfbc019ec14cfe48c59b/blob @@ -0,0 +1,44 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::threshold(Tensor self, Scalar threshold, Scalar value) -> Tensor +inline at::Tensor threshold(const at::Tensor & self, const at::Scalar & threshold, const at::Scalar & value) { + return at::_ops::threshold::call(self, threshold, value); +} + +// aten::threshold_(Tensor(a!) self, Scalar threshold, Scalar value) -> Tensor(a!) +inline at::Tensor & threshold_(at::Tensor & self, const at::Scalar & threshold, const at::Scalar & value) { + return at::_ops::threshold_::call(self, threshold, value); +} + +// aten::threshold.out(Tensor self, Scalar threshold, Scalar value, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & threshold_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & threshold, const at::Scalar & value) { + return at::_ops::threshold_out::call(self, threshold, value, out); +} +// aten::threshold.out(Tensor self, Scalar threshold, Scalar value, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & threshold_outf(const at::Tensor & self, const at::Scalar & threshold, const at::Scalar & value, at::Tensor & out) { + return at::_ops::threshold_out::call(self, threshold, value, out); +} + +} diff --git a/shared/package-files/2f/2f2e1cb6dd8b3a96cff6de5878a53dc30a2fee2375b85a9e02d06327e3b51ed5/blob b/shared/package-files/2f/2f2e1cb6dd8b3a96cff6de5878a53dc30a2fee2375b85a9e02d06327e3b51ed5/blob new file mode 100644 index 0000000000000000000000000000000000000000..0382fc2854e8b7950c071a1d9ac4c1b89894d82e --- /dev/null +++ b/shared/package-files/2f/2f2e1cb6dd8b3a96cff6de5878a53dc30a2fee2375b85a9e02d06327e3b51ed5/blob @@ -0,0 +1,23 @@ +import sys +from typing import IO, Any, Callable, Optional + +from .types import WSGIEnvironment + +class FileWrapper: + filelike: IO[bytes] + blksize: int + close: Callable[[], None] # only exists if filelike.close exists + def __init__(self, filelike: IO[bytes], blksize: int = ...) -> None: ... + def __getitem__(self, key: Any) -> bytes: ... + def __iter__(self) -> FileWrapper: ... + if sys.version_info < (3,): + def next(self) -> bytes: ... + else: + def __next__(self) -> bytes: ... + +def guess_scheme(environ: WSGIEnvironment) -> str: ... +def application_uri(environ: WSGIEnvironment) -> str: ... +def request_uri(environ: WSGIEnvironment, include_query: bool = ...) -> str: ... +def shift_path_info(environ: WSGIEnvironment) -> Optional[str]: ... +def setup_testing_defaults(environ: WSGIEnvironment) -> None: ... +def is_hop_by_hop(header_name: str) -> bool: ... diff --git a/shared/package-files/2f/2f2ed822742486b148167fa34eb9725a66c2686afbc4f12f2c94466d38dcb522/blob b/shared/package-files/2f/2f2ed822742486b148167fa34eb9725a66c2686afbc4f12f2c94466d38dcb522/blob new file mode 100644 index 0000000000000000000000000000000000000000..07471bfab223e3a0bd2f56d309e5becbd506a1b8 --- /dev/null +++ b/shared/package-files/2f/2f2ed822742486b148167fa34eb9725a66c2686afbc4f12f2c94466d38dcb522/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2f2ed822742486b148167fa34eb9725a66c2686afbc4f12f2c94466d38dcb522 +size 5845790 diff --git a/shared/package-files/2f/2f2ffabc17c79f6e0a575b4a7d73652fd6971738e5ca80903cde180347aaa60c/blob b/shared/package-files/2f/2f2ffabc17c79f6e0a575b4a7d73652fd6971738e5ca80903cde180347aaa60c/blob new file mode 100644 index 0000000000000000000000000000000000000000..42e6a8e7808433970e7bcc3792ac62a19de20ea2 --- /dev/null +++ b/shared/package-files/2f/2f2ffabc17c79f6e0a575b4a7d73652fd6971738e5ca80903cde180347aaa60c/blob @@ -0,0 +1,202 @@ +"""Bridge-finding algorithms.""" +from itertools import chain + +import networkx as nx +from networkx.utils import not_implemented_for + +__all__ = ["bridges", "has_bridges", "local_bridges"] + + +@not_implemented_for("directed") +def bridges(G, root=None): + """Generate all bridges in a graph. + + A *bridge* in a graph is an edge whose removal causes the number of + connected components of the graph to increase. Equivalently, a bridge is an + edge that does not belong to any cycle. Bridges are also known as cut-edges, + isthmuses, or cut arcs. + + Parameters + ---------- + G : undirected graph + + root : node (optional) + A node in the graph `G`. If specified, only the bridges in the + connected component containing this node will be returned. + + Yields + ------ + e : edge + An edge in the graph whose removal disconnects the graph (or + causes the number of connected components to increase). + + Raises + ------ + NodeNotFound + If `root` is not in the graph `G`. + + NetworkXNotImplemented + If `G` is a directed graph. + + Examples + -------- + The barbell graph with parameter zero has a single bridge: + + >>> G = nx.barbell_graph(10, 0) + >>> list(nx.bridges(G)) + [(9, 10)] + + Notes + ----- + This is an implementation of the algorithm described in [1]_. An edge is a + bridge if and only if it is not contained in any chain. Chains are found + using the :func:`networkx.chain_decomposition` function. + + The algorithm described in [1]_ requires a simple graph. If the provided + graph is a multigraph, we convert it to a simple graph and verify that any + bridges discovered by the chain decomposition algorithm are not multi-edges. + + Ignoring polylogarithmic factors, the worst-case time complexity is the + same as the :func:`networkx.chain_decomposition` function, + $O(m + n)$, where $n$ is the number of nodes in the graph and $m$ is + the number of edges. + + References + ---------- + .. [1] https://en.wikipedia.org/wiki/Bridge_%28graph_theory%29#Bridge-Finding_with_Chain_Decompositions + """ + multigraph = G.is_multigraph() + H = nx.Graph(G) if multigraph else G + chains = nx.chain_decomposition(H, root=root) + chain_edges = set(chain.from_iterable(chains)) + H_copy = H.copy() + if root is not None: + H = H.subgraph(nx.node_connected_component(H, root)).copy() + for u, v in H.edges(): + if (u, v) not in chain_edges and (v, u) not in chain_edges: + if multigraph and len(G[u][v]) > 1: + continue + yield u, v + + +@not_implemented_for("directed") +def has_bridges(G, root=None): + """Decide whether a graph has any bridges. + + A *bridge* in a graph is an edge whose removal causes the number of + connected components of the graph to increase. + + Parameters + ---------- + G : undirected graph + + root : node (optional) + A node in the graph `G`. If specified, only the bridges in the + connected component containing this node will be considered. + + Returns + ------- + bool + Whether the graph (or the connected component containing `root`) + has any bridges. + + Raises + ------ + NodeNotFound + If `root` is not in the graph `G`. + + NetworkXNotImplemented + If `G` is a directed graph. + + Examples + -------- + The barbell graph with parameter zero has a single bridge:: + + >>> G = nx.barbell_graph(10, 0) + >>> nx.has_bridges(G) + True + + On the other hand, the cycle graph has no bridges:: + + >>> G = nx.cycle_graph(5) + >>> nx.has_bridges(G) + False + + Notes + ----- + This implementation uses the :func:`networkx.bridges` function, so + it shares its worst-case time complexity, $O(m + n)$, ignoring + polylogarithmic factors, where $n$ is the number of nodes in the + graph and $m$ is the number of edges. + + """ + try: + next(bridges(G, root=root)) + except StopIteration: + return False + else: + return True + + +@not_implemented_for("multigraph") +@not_implemented_for("directed") +def local_bridges(G, with_span=True, weight=None): + """Iterate over local bridges of `G` optionally computing the span + + A *local bridge* is an edge whose endpoints have no common neighbors. + That is, the edge is not part of a triangle in the graph. + + The *span* of a *local bridge* is the shortest path length between + the endpoints if the local bridge is removed. + + Parameters + ---------- + G : undirected graph + + with_span : bool + If True, yield a 3-tuple `(u, v, span)` + + weight : function, string or None (default: None) + If function, used to compute edge weights for the span. + If string, the edge data attribute used in calculating span. + If None, all edges have weight 1. + + Yields + ------ + e : edge + The local bridges as an edge 2-tuple of nodes `(u, v)` or + as a 3-tuple `(u, v, span)` when `with_span is True`. + + Raises + ------ + NetworkXNotImplemented + If `G` is a directed graph or multigraph. + + Examples + -------- + A cycle graph has every edge a local bridge with span N-1. + + >>> G = nx.cycle_graph(9) + >>> (0, 8, 8) in set(nx.local_bridges(G)) + True + """ + if with_span is not True: + for u, v in G.edges: + if not (set(G[u]) & set(G[v])): + yield u, v + else: + wt = nx.weighted._weight_function(G, weight) + for u, v in G.edges: + if not (set(G[u]) & set(G[v])): + enodes = {u, v} + + def hide_edge(n, nbr, d): + if n not in enodes or nbr not in enodes: + return wt(n, nbr, d) + return None + + try: + span = nx.shortest_path_length(G, u, v, weight=hide_edge) + yield u, v, span + except nx.NetworkXNoPath: + yield u, v, float("inf") diff --git a/shared/package-files/2f/2f31a0f1567cea4ce99391a914d6f783de2d33543ae3a690ca11ba51fc284327/blob b/shared/package-files/2f/2f31a0f1567cea4ce99391a914d6f783de2d33543ae3a690ca11ba51fc284327/blob new file mode 100644 index 0000000000000000000000000000000000000000..bc37b1e7f9d94d077e93991b981ab4b2e5be0890 --- /dev/null +++ b/shared/package-files/2f/2f31a0f1567cea4ce99391a914d6f783de2d33543ae3a690ca11ba51fc284327/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2f31a0f1567cea4ce99391a914d6f783de2d33543ae3a690ca11ba51fc284327 +size 386288 diff --git a/shared/package-files/2f/2f3286032100c38971718f404379df5ae819630eb2dfc8fb6791f98689241104/blob b/shared/package-files/2f/2f3286032100c38971718f404379df5ae819630eb2dfc8fb6791f98689241104/blob new file mode 100644 index 0000000000000000000000000000000000000000..66ac0593999630513b7f9d9feebb85f1a8a350bf --- /dev/null +++ b/shared/package-files/2f/2f3286032100c38971718f404379df5ae819630eb2dfc8fb6791f98689241104/blob @@ -0,0 +1,5 @@ +Nominal data. +99 runs converged successfully. +Checking dependence parameters: +Odds ratio estimate: 1.0028 +Odds ratio truth: 1.0000 diff --git a/shared/package-files/2f/2f32f98dd9999314641dd0375e4a2a24f1bf2269659d24616182d0a4c7ff4d8f/blob b/shared/package-files/2f/2f32f98dd9999314641dd0375e4a2a24f1bf2269659d24616182d0a4c7ff4d8f/blob new file mode 100644 index 0000000000000000000000000000000000000000..f38dc56bf20d9db68515ea7602c9edb39fabae8d Binary files /dev/null and b/shared/package-files/2f/2f32f98dd9999314641dd0375e4a2a24f1bf2269659d24616182d0a4c7ff4d8f/blob differ diff --git a/shared/package-files/2f/2f3a0ad1a3dc7053bf41c11235b30dd8ea4c341476a107092cb56b896c485abc/blob b/shared/package-files/2f/2f3a0ad1a3dc7053bf41c11235b30dd8ea4c341476a107092cb56b896c485abc/blob new file mode 100644 index 0000000000000000000000000000000000000000..a31953ca6e7917755f12af07784777c81438fdb6 --- /dev/null +++ b/shared/package-files/2f/2f3a0ad1a3dc7053bf41c11235b30dd8ea4c341476a107092cb56b896c485abc/blob @@ -0,0 +1,73 @@ +from typing import Optional + +import torch.fx +from torch.fx import Node +from torch.fx._compatibility import compatibility +from torch._subclasses.fake_tensor import FakeTensorMode, FakeTensor +from torch.fx.experimental.proxy_tensor import py_sym_types, snapshot_fake +from torch.fx.node import map_aggregate + +__all__ = ['FakeTensorProp'] + +@compatibility(is_backward_compatible=False) +class FakeTensorProp(torch.fx.Interpreter): + """ + Execute an FX graph Node-by-Node and record a fake tensor representing + the metadata for the node. Unlike ShapeProp, (1) this propagation + is cheap--it does the propagation with meta tensors which do not actually + store data, and (2) the fake tensors have much more fine grained information, + e.g., they have accurate alias information that can be consulted by looking + at the storages. + + Args: + module (GraphModule): The module to be executed + mode (Optional[FakeTensorMode]): The dispatch mode used to execute computation indicated by each FX Node. + """ + def __init__(self, module: torch.fx.GraphModule, mode: Optional[FakeTensorMode] = None): + super().__init__(module) + if mode is None: + mode = FakeTensorMode() + self._mode = mode + + def run_node(self, n: Node): + import sympy + from torch.fx.experimental.symbolic_shapes import free_unbacked_symbols + + result = super().run_node(n) + sym = None + if ( + 'val' in n.meta and + isinstance(v := n.meta['val'], torch.SymInt) and + isinstance(v.node.expr, sympy.Symbol) and free_unbacked_symbols(v) + ): + sym = v + + def extract_val(obj): + if isinstance(obj, FakeTensor): + return snapshot_fake(obj) + elif isinstance(obj, torch.Tensor): + # TODO: How is it possible that we get a non fake tensor? We + # should be running under the mode... + return snapshot_fake(self._mode.from_tensor(obj, static_shapes=True)) + elif isinstance(obj, py_sym_types): + return obj + else: + return None + + meta = map_aggregate(result, extract_val) + if meta is not None: + n.meta['val'] = meta + if sym is not None: + torch._check(meta == v) + return result + + def propagate(self, *args): + fake_args = [ + self._mode.from_tensor(a) if isinstance(a, torch.Tensor) else a + for a in args + ] + return self.propagate_dont_convert_inputs(*fake_args) + + def propagate_dont_convert_inputs(self, *args): + with self._mode: + return super().run(*args) diff --git a/shared/package-files/2f/2f3eed08fad2a6ff46aca3cc4be7aed4b7a1b024f0cfb29d51d09827cb45f1d1/blob b/shared/package-files/2f/2f3eed08fad2a6ff46aca3cc4be7aed4b7a1b024f0cfb29d51d09827cb45f1d1/blob new file mode 100644 index 0000000000000000000000000000000000000000..2345855a3321b6af48acfc0fcba0732e4af2c92c --- /dev/null +++ b/shared/package-files/2f/2f3eed08fad2a6ff46aca3cc4be7aed4b7a1b024f0cfb29d51d09827cb45f1d1/blob @@ -0,0 +1,109 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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 pytest + +import pyarrow as pa + +try: + import pyarrow.parquet as pq + from pyarrow.tests.parquet.common import (_read_table, + _check_roundtrip) +except ImportError: + pq = None + +try: + import pandas as pd + import pandas.testing as tm + + from pyarrow.tests.parquet.common import _roundtrip_pandas_dataframe +except ImportError: + pd = tm = None + + +# Marks all of the tests in this module +# Ignore these with pytest ... -m 'not parquet' +pytestmark = pytest.mark.parquet + + +# Tests for ARROW-11497 +_test_data_simple = [ + {'items': [1, 2]}, + {'items': [0]}, +] + +_test_data_complex = [ + {'items': [{'name': 'elem1', 'value': '1'}, + {'name': 'elem2', 'value': '2'}]}, + {'items': [{'name': 'elem1', 'value': '0'}]}, +] + +parametrize_test_data = pytest.mark.parametrize( + "test_data", [_test_data_simple, _test_data_complex]) + + +@pytest.mark.pandas +@parametrize_test_data +def test_write_compliant_nested_type_enable(tempdir, test_data): + # prepare dataframe for testing + df = pd.DataFrame(data=test_data) + # verify that we can read/write pandas df with new flag (default behaviour) + _roundtrip_pandas_dataframe(df, + write_kwargs={}) + + # Write to a parquet file with compliant nested type + table = pa.Table.from_pandas(df, preserve_index=False) + path = str(tempdir / 'data.parquet') + with pq.ParquetWriter(path, table.schema, + version='2.6') as writer: + writer.write_table(table) + # Read back as a table + new_table = _read_table(path) + # Validate that "items" columns compliant to Parquet nested format + # Should be like this: list> + assert isinstance(new_table.schema.types[0], pa.ListType) + assert new_table.schema.types[0].value_field.name == 'element' + + # Verify that the new table can be read/written correctly + _check_roundtrip(new_table) + + +@pytest.mark.pandas +@parametrize_test_data +def test_write_compliant_nested_type_disable(tempdir, test_data): + # prepare dataframe for testing + df = pd.DataFrame(data=test_data) + # verify that we can read/write with new flag disabled + _roundtrip_pandas_dataframe(df, write_kwargs={ + 'use_compliant_nested_type': False}) + + # Write to a parquet file while disabling compliant nested type + table = pa.Table.from_pandas(df, preserve_index=False) + path = str(tempdir / 'data.parquet') + with pq.ParquetWriter(path, table.schema, version='2.6', + use_compliant_nested_type=False) as writer: + writer.write_table(table) + new_table = _read_table(path) + + # Validate that "items" columns is not compliant to Parquet nested format + # Should be like this: list> + assert isinstance(new_table.schema.types[0], pa.ListType) + assert new_table.schema.types[0].value_field.name == 'item' + + # Verify that the new table can be read/written correctly + _check_roundtrip(new_table, + use_compliant_nested_type=False) diff --git a/shared/package-files/2f/2f400f8a11fdcf939fe8cd70846b735c14186dddee2c02cbfd957bda3ec85c3d/blob b/shared/package-files/2f/2f400f8a11fdcf939fe8cd70846b735c14186dddee2c02cbfd957bda3ec85c3d/blob new file mode 100644 index 0000000000000000000000000000000000000000..fc0ad81b2021ff0daf7428184d48afedad4e6f2c --- /dev/null +++ b/shared/package-files/2f/2f400f8a11fdcf939fe8cd70846b735c14186dddee2c02cbfd957bda3ec85c3d/blob @@ -0,0 +1,14 @@ +from .enums import ClusterBy, NAAction +from .evaluated_factor import EvaluatedFactor +from .factor_values import FactorValues +from .scoped_factor import ScopedFactor +from .scoped_term import ScopedTerm + +__all__ = [ + "EvaluatedFactor", + "FactorValues", + "ClusterBy", + "NAAction", + "ScopedFactor", + "ScopedTerm", +] diff --git a/shared/package-files/2f/2f4183f6ab539b751ed64877db311977483ff95f54cf0731aa9a18db0f6e305b/blob b/shared/package-files/2f/2f4183f6ab539b751ed64877db311977483ff95f54cf0731aa9a18db0f6e305b/blob new file mode 100644 index 0000000000000000000000000000000000000000..6c8f9d4c0873e65a3c3b8ac2dbab32acbb366fdf --- /dev/null +++ b/shared/package-files/2f/2f4183f6ab539b751ed64877db311977483ff95f54cf0731aa9a18db0f6e305b/blob @@ -0,0 +1,51 @@ +"""Calculate the area of a glyph.""" + +from fontTools.pens.basePen import BasePen + +__all__ = ["AreaPen"] + + +class AreaPen(BasePen): + def __init__(self, glyphset=None): + BasePen.__init__(self, glyphset) + self.value = 0 + + def _moveTo(self, p0): + self._p0 = self._startPoint = p0 + + def _lineTo(self, p1): + x0, y0 = self._p0 + x1, y1 = p1 + self.value -= (x1 - x0) * (y1 + y0) * 0.5 + self._p0 = p1 + + def _qCurveToOne(self, p1, p2): + # https://github.com/Pomax/bezierinfo/issues/44 + p0 = self._p0 + x0, y0 = p0[0], p0[1] + x1, y1 = p1[0] - x0, p1[1] - y0 + x2, y2 = p2[0] - x0, p2[1] - y0 + self.value -= (x2 * y1 - x1 * y2) / 3 + self._lineTo(p2) + self._p0 = p2 + + def _curveToOne(self, p1, p2, p3): + # https://github.com/Pomax/bezierinfo/issues/44 + p0 = self._p0 + x0, y0 = p0[0], p0[1] + x1, y1 = p1[0] - x0, p1[1] - y0 + x2, y2 = p2[0] - x0, p2[1] - y0 + x3, y3 = p3[0] - x0, p3[1] - y0 + self.value -= (x1 * (-y2 - y3) + x2 * (y1 - 2 * y3) + x3 * (y1 + 2 * y2)) * 0.15 + self._lineTo(p3) + self._p0 = p3 + + def _closePath(self): + self._lineTo(self._startPoint) + del self._p0, self._startPoint + + def _endPath(self): + if self._p0 != self._startPoint: + # Area is not defined for open contours. + raise NotImplementedError + del self._p0, self._startPoint diff --git a/shared/package-files/2f/2f42b948a211b0a74bfd6248cfbdf96206923efc415ed54f1d663476fc6e999e/blob b/shared/package-files/2f/2f42b948a211b0a74bfd6248cfbdf96206923efc415ed54f1d663476fc6e999e/blob new file mode 100644 index 0000000000000000000000000000000000000000..0136f3456c58660ea726758afd1d4ea9f8c74764 --- /dev/null +++ b/shared/package-files/2f/2f42b948a211b0a74bfd6248cfbdf96206923efc415ed54f1d663476fc6e999e/blob @@ -0,0 +1,130 @@ +from types import ClassType, FrameType, ModuleType, TracebackType +from typing import IO, Any, BinaryIO, Callable, Dict, List, NoReturn, Optional, Sequence, Text, Tuple, Type, Union, overload + +# The following type alias are stub-only and do not exist during runtime +_ExcInfo = Tuple[Type[BaseException], BaseException, TracebackType] +_OptExcInfo = Union[_ExcInfo, Tuple[None, None, None]] + +class _flags: + bytes_warning: int + debug: int + division_new: int + division_warning: int + dont_write_bytecode: int + hash_randomization: int + ignore_environment: int + inspect: int + interactive: int + no_site: int + no_user_site: int + optimize: int + py3k_warning: int + tabcheck: int + unicode: int + verbose: int + +class _float_info: + max: float + max_exp: int + max_10_exp: int + min: float + min_exp: int + min_10_exp: int + dig: int + mant_dig: int + epsilon: float + radix: int + rounds: int + +class _version_info(Tuple[int, int, int, str, int]): + major: int + minor: int + micro: int + releaselevel: str + serial: int + +_mercurial: Tuple[str, str, str] +api_version: int +argv: List[str] +builtin_module_names: Tuple[str, ...] +byteorder: str +copyright: str +dont_write_bytecode: bool +exec_prefix: str +executable: str +flags: _flags +float_repr_style: str +hexversion: int +long_info: object +maxint: int +maxsize: int +maxunicode: int +modules: Dict[str, Any] +path: List[str] +platform: str +prefix: str +py3kwarning: bool +__stderr__: IO[str] +__stdin__: IO[str] +__stdout__: IO[str] +stderr: IO[str] +stdin: IO[str] +stdout: IO[str] +subversion: Tuple[str, str, str] +version: str +warnoptions: object +float_info: _float_info +version_info: _version_info +ps1: str +ps2: str +last_type: type +last_value: BaseException +last_traceback: TracebackType +# TODO precise types +meta_path: List[Any] +path_hooks: List[Any] +path_importer_cache: Dict[str, Any] +displayhook: Callable[[object], Any] +excepthook: Callable[[Type[BaseException], BaseException, TracebackType], Any] +exc_type: Optional[type] +exc_value: Union[BaseException, ClassType] +exc_traceback: TracebackType + +class _WindowsVersionType: + major: Any + minor: Any + build: Any + platform: Any + service_pack: Any + service_pack_major: Any + service_pack_minor: Any + suite_mask: Any + product_type: Any + +def getwindowsversion() -> _WindowsVersionType: ... +def _clear_type_cache() -> None: ... +def _current_frames() -> Dict[int, FrameType]: ... +def _getframe(depth: int = ...) -> FrameType: ... +def call_tracing(fn: Any, args: Any) -> Any: ... +def __displayhook__(value: object) -> None: ... +def __excepthook__(type_: type, value: BaseException, traceback: TracebackType) -> None: ... +def exc_clear() -> None: ... +def exc_info() -> _OptExcInfo: ... + +# sys.exit() accepts an optional argument of anything printable +def exit(arg: Any = ...) -> NoReturn: ... +def getcheckinterval() -> int: ... # deprecated +def getdefaultencoding() -> str: ... +def getdlopenflags() -> int: ... +def getfilesystemencoding() -> str: ... # In practice, never returns None +def getrefcount(arg: Any) -> int: ... +def getrecursionlimit() -> int: ... +def getsizeof(obj: object, default: int = ...) -> int: ... +def getprofile() -> Optional[Any]: ... +def gettrace() -> Optional[Any]: ... +def setcheckinterval(interval: int) -> None: ... # deprecated +def setdlopenflags(n: int) -> None: ... +def setdefaultencoding(encoding: Text) -> None: ... # only exists after reload(sys) +def setprofile(profilefunc: Any) -> None: ... # TODO type +def setrecursionlimit(limit: int) -> None: ... +def settrace(tracefunc: Any) -> None: ... # TODO type diff --git a/shared/package-files/2f/2f47188175984ff0eab25f95c8bfff3eae88f69b7aed93c0140d23ac91eb6b16/blob b/shared/package-files/2f/2f47188175984ff0eab25f95c8bfff3eae88f69b7aed93c0140d23ac91eb6b16/blob new file mode 100644 index 0000000000000000000000000000000000000000..0cbd5eeeda1c426ab17da1833e0eaa768604858a --- /dev/null +++ b/shared/package-files/2f/2f47188175984ff0eab25f95c8bfff3eae88f69b7aed93c0140d23ac91eb6b16/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API linalg_lu_solve { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, bool); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::linalg_lu_solve") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "linalg_lu_solve(Tensor LU, Tensor pivots, Tensor B, *, bool left=True, bool adjoint=False) -> Tensor") + static at::Tensor call(const at::Tensor & LU, const at::Tensor & pivots, const at::Tensor & B, bool left, bool adjoint); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & LU, const at::Tensor & pivots, const at::Tensor & B, bool left, bool adjoint); +}; + +struct TORCH_API linalg_lu_solve_out { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, const at::Tensor &, bool, bool, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::linalg_lu_solve") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "linalg_lu_solve.out(Tensor LU, Tensor pivots, Tensor B, *, bool left=True, bool adjoint=False, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & LU, const at::Tensor & pivots, const at::Tensor & B, bool left, bool adjoint, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & LU, const at::Tensor & pivots, const at::Tensor & B, bool left, bool adjoint, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/2f/2f49d9e22c0ac3805fd499e23815b6310a447dad1a85541b6aadd6c7968c1ef7/blob b/shared/package-files/2f/2f49d9e22c0ac3805fd499e23815b6310a447dad1a85541b6aadd6c7968c1ef7/blob new file mode 100644 index 0000000000000000000000000000000000000000..de9484c0ab9a1b682226830cb8a96baa228eaaa1 --- /dev/null +++ b/shared/package-files/2f/2f49d9e22c0ac3805fd499e23815b6310a447dad1a85541b6aadd6c7968c1ef7/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2f49d9e22c0ac3805fd499e23815b6310a447dad1a85541b6aadd6c7968c1ef7 +size 320858 diff --git a/shared/package-files/2f/2f4afdc8010c6df330610cadcd8b12e3908ea9a564fa8fe18bacd1637c8888ee/blob b/shared/package-files/2f/2f4afdc8010c6df330610cadcd8b12e3908ea9a564fa8fe18bacd1637c8888ee/blob new file mode 100644 index 0000000000000000000000000000000000000000..0bd683096f18eadceb7168f811c75bf072baecfe Binary files /dev/null and b/shared/package-files/2f/2f4afdc8010c6df330610cadcd8b12e3908ea9a564fa8fe18bacd1637c8888ee/blob differ diff --git a/shared/package-files/2f/2f524e40e4e9e52a22663cd92937333ad1aec62961ff46c096e0a4f10f583376/blob b/shared/package-files/2f/2f524e40e4e9e52a22663cd92937333ad1aec62961ff46c096e0a4f10f583376/blob new file mode 100644 index 0000000000000000000000000000000000000000..3dfb0421f0c190b293ce4121fc21cc68bc54f79c --- /dev/null +++ b/shared/package-files/2f/2f524e40e4e9e52a22663cd92937333ad1aec62961ff46c096e0a4f10f583376/blob @@ -0,0 +1,116 @@ +# Authors: The scikit-learn developers +# SPDX-License-Identifier: BSD-3-Clause + +# Uses the pool adjacent violators algorithm (PAVA), with the +# enhancement of searching for the longest decreasing subsequence to +# pool at each step. + +import numpy as np +from cython cimport floating + + +def _inplace_contiguous_isotonic_regression(floating[::1] y, floating[::1] w): + cdef: + Py_ssize_t n = y.shape[0], i, k + floating prev_y, sum_wy, sum_w + Py_ssize_t[::1] target = np.arange(n, dtype=np.intp) + + # target describes a list of blocks. At any time, if [i..j] (inclusive) is + # an active block, then target[i] := j and target[j] := i. + + # For "active" indices (block starts): + # w[i] := sum{w_orig[j], j=[i..target[i]]} + # y[i] := sum{y_orig[j]*w_orig[j], j=[i..target[i]]} / w[i] + + with nogil: + i = 0 + while i < n: + k = target[i] + 1 + if k == n: + break + if y[i] < y[k]: + i = k + continue + sum_wy = w[i] * y[i] + sum_w = w[i] + while True: + # We are within a decreasing subsequence. + prev_y = y[k] + sum_wy += w[k] * y[k] + sum_w += w[k] + k = target[k] + 1 + if k == n or prev_y < y[k]: + # Non-singleton decreasing subsequence is finished, + # update first entry. + y[i] = sum_wy / sum_w + w[i] = sum_w + target[i] = k - 1 + target[k - 1] = i + if i > 0: + # Backtrack if we can. This makes the algorithm + # single-pass and ensures O(n) complexity. + i = target[i - 1] + # Otherwise, restart from the same point. + break + # Reconstruct the solution. + i = 0 + while i < n: + k = target[i] + 1 + y[i + 1 : k] = y[i] + i = k + + +def _make_unique(const floating[::1] X, + const floating[::1] y, + const floating[::1] sample_weights): + """Average targets for duplicate X, drop duplicates. + + Aggregates duplicate X values into a single X value where + the target y is a (sample_weighted) average of the individual + targets. + + Assumes that X is ordered, so that all duplicates follow each other. + """ + unique_values = len(np.unique(X)) + + if floating is float: + dtype = np.float32 + else: + dtype = np.float64 + + cdef floating[::1] y_out = np.empty(unique_values, dtype=dtype) + cdef floating[::1] x_out = np.empty_like(y_out) + cdef floating[::1] weights_out = np.empty_like(y_out) + + cdef floating current_x = X[0] + cdef floating current_y = 0 + cdef floating current_weight = 0 + cdef int i = 0 + cdef int j + cdef floating x + cdef int n_samples = len(X) + cdef floating eps = np.finfo(dtype).resolution + + for j in range(n_samples): + x = X[j] + if x - current_x >= eps: + # next unique value + x_out[i] = current_x + weights_out[i] = current_weight + y_out[i] = current_y / current_weight + i += 1 + current_x = x + current_weight = sample_weights[j] + current_y = y[j] * sample_weights[j] + else: + current_weight += sample_weights[j] + current_y += y[j] * sample_weights[j] + + x_out[i] = current_x + weights_out[i] = current_weight + y_out[i] = current_y / current_weight + return( + np.asarray(x_out[:i+1]), + np.asarray(y_out[:i+1]), + np.asarray(weights_out[:i+1]), + ) diff --git a/shared/package-files/2f/2f54ade328874c0deff752639e77587d4add29f4f56d6c5c9309e7aec7046577/blob b/shared/package-files/2f/2f54ade328874c0deff752639e77587d4add29f4f56d6c5c9309e7aec7046577/blob new file mode 100644 index 0000000000000000000000000000000000000000..49c0ec1d18d9f08111fe2d2a269ed407da71b158 Binary files /dev/null and b/shared/package-files/2f/2f54ade328874c0deff752639e77587d4add29f4f56d6c5c9309e7aec7046577/blob differ diff --git a/shared/package-files/2f/2f55a0ddb95baba0f3427ff465bec86e16c6afa7160bc04271934d0e7a72d090/rank_binned.py b/shared/package-files/2f/2f55a0ddb95baba0f3427ff465bec86e16c6afa7160bc04271934d0e7a72d090/rank_binned.py new file mode 100644 index 0000000000000000000000000000000000000000..b13f282eb64fdbe0a67307ba11551b772fb69c15 --- /dev/null +++ b/shared/package-files/2f/2f55a0ddb95baba0f3427ff465bec86e16c6afa7160bc04271934d0e7a72d090/rank_binned.py @@ -0,0 +1,152 @@ +import numpy as np +from pathlib import Path +import pickle +import argparse +import pandas as pd +from functools import partial +from tqdm import tqdm + +from ms_pred.retrieval.retrieval_benchmark import cos_dist +from ms_pred import common + + +def get_args(): + """get_args.""" + parser = argparse.ArgumentParser() + parser.add_argument( + "--spec-folder", + default="data/elucidation/broad_distress/spec_files" + ) + parser.add_argument( + "--binned-pred-file", + default="results/iceberg_nist20/split_1_rnd1/elucidation_broad_distress/binned_preds.p", + ) + parser.add_argument("--outfile", default=None) + parser.add_argument("--dist-fn", default="cos") + return parser.parse_args() + + +def process_spec_file(spec_name: str, num_bins: int, upper_limit: int, spec_dir: Path): + """process_spec_file.""" + if spec_dir.suffix == '.hdf5': # is h5file + spec_h5 = common.HDF5Dataset(spec_dir) + spec_file = spec_h5.read_str(spec_name).split('\n') + else: # is directory + spec_files = list(spec_dir.glob(f'{spec_name}.[mM][sS]')) + if len(spec_files) == 0: + raise FileNotFoundError(f'{spec_dir / spec_name}.ms does not exist') + spec_file = spec_files[0] + meta, all_spec = common.parse_spectra(spec_file) + all_spec = common.process_spec_file(meta, all_spec, merge_specs=False) + + return_dict = {} + for colli_eng, spec in all_spec.items(): + colli_eng = common.get_collision_energy(colli_eng) + binned = common.bin_spectra([spec], num_bins, upper_limit) + avged = binned[0] + return_dict[colli_eng] = avged + return return_dict + + +def rank_unknown_entry( + cand_smiles, + cand_preds, + true_spec, + spec_name, + dist_fn="cos", +): + if dist_fn == "cos": + dist = cos_dist(cand_preds_dict=cand_preds, true_spec_dict=true_spec) + elif dist_fn == "random": + dist = np.random.randn(cand_preds.shape[0]) + else: + raise NotImplementedError() + + resorted = np.argsort(dist) + resorted_smiles = cand_smiles[resorted] + resorted_dist = dist[resorted] + + return { + "ranked_smiles": resorted_smiles, + "ranked_dist": resorted_dist, + "spec_name": str(spec_name), + } + + +def main(args): + """main.""" + dist_fn = args.dist_fn + spec_folder = Path(args.spec_folder) + binned_pred_file = Path(args.binned_pred_file) + outfile = args.outfile + if outfile is None: + outfile = binned_pred_file.parent / 'ranked_smiles.tsv' + else: + outfile = Path(outfile) + + pred_specs = pickle.load(open(binned_pred_file, "rb")) + pred_spec_ars = pred_specs["preds"] + pred_smiles = np.array(pred_specs['smiles']) + pred_spec_names = np.array(pred_specs["spec_names"]) + pred_spec_names_unique = np.unique(pred_spec_names) + upper_limit = pred_specs["upper_limit"] + num_bins = pred_specs["num_bins"] + use_sparse = pred_specs["sparse_out"] + + # Only use sparse valid for now + assert use_sparse + + read_spec = partial( + process_spec_file, + num_bins=num_bins, + upper_limit=upper_limit, + spec_dir=spec_folder, + ) + true_specs = common.chunked_parallel( + pred_spec_names_unique, + read_spec, + chunks=1000, + max_cpu=16, + ) + name_to_spec = dict(zip(pred_spec_names_unique, true_specs)) + + # Create a list of dicts, bucket by mass, etc. + all_entries = [] + for spec_name in tqdm(pred_spec_names_unique): + + # Get candidates + bool_sel = pred_spec_names == spec_name + cand_smiles = pred_smiles[bool_sel] + cand_preds = np.array(pred_spec_ars)[bool_sel] + true_spec = name_to_spec[spec_name] + new_entry = { + "cand_smiles": cand_smiles, + "cand_preds": cand_preds, + "true_spec": true_spec, + "spec_name": spec_name, + } + + if true_spec is None: + continue + all_entries.append(new_entry) + + rank_unknown_entry_ = partial(rank_unknown_entry, dist_fn=dist_fn) + all_out = [rank_unknown_entry_(**test_entry) for test_entry in all_entries] + + # Output a sheet of structural elucidations + out_entries = [] + for out_info in all_out: + spec_name = out_info["spec_name"] + for smi, dist in zip(out_info['ranked_smiles'], out_info['ranked_dist']): + out_entries.append({ + "spec_name": spec_name, + "predict_smiles": smi, + "cosine_distance": dist, + }) + df = pd.DataFrame(out_entries) + df.to_csv(outfile, sep='\t') + + +if __name__ == "__main__": + args = get_args() + main(args) diff --git a/shared/package-files/2f/2f57c60eccb676666a7ffcb76d7568f6650caf526c962f4175270284e110927b/blob b/shared/package-files/2f/2f57c60eccb676666a7ffcb76d7568f6650caf526c962f4175270284e110927b/blob new file mode 100644 index 0000000000000000000000000000000000000000..5b9832093fded0f48c523bdbc363d043a871eb60 --- /dev/null +++ b/shared/package-files/2f/2f57c60eccb676666a7ffcb76d7568f6650caf526c962f4175270284e110927b/blob @@ -0,0 +1,30 @@ +import pytest + +from pandas import ( + Series, + Timedelta, + TimedeltaIndex, + timedelta_range, +) +import pandas._testing as tm + +pytestmark = pytest.mark.filterwarnings( + "ignore:Setting a value on a view:FutureWarning" +) + + +@pytest.mark.parametrize( + "cons", + [ + lambda x: TimedeltaIndex(x), + lambda x: TimedeltaIndex(TimedeltaIndex(x)), + ], +) +def test_timedeltaindex(using_copy_on_write, cons): + dt = timedelta_range("1 day", periods=3) + ser = Series(dt) + idx = cons(ser) + expected = idx.copy(deep=True) + ser.iloc[0] = Timedelta("5 days") + if using_copy_on_write: + tm.assert_index_equal(idx, expected) diff --git a/shared/package-files/2f/2f58003236183c1e9e6264a9a577dbc0f54a6b71c23687ea3d5519de0c4b95d0/blob b/shared/package-files/2f/2f58003236183c1e9e6264a9a577dbc0f54a6b71c23687ea3d5519de0c4b95d0/blob new file mode 100644 index 0000000000000000000000000000000000000000..e1302d4b73f2b9c8e74b06c70ec29a92c1e48723 --- /dev/null +++ b/shared/package-files/2f/2f58003236183c1e9e6264a9a577dbc0f54a6b71c23687ea3d5519de0c4b95d0/blob @@ -0,0 +1,36 @@ +import pytest + +from pandas import ( + DataFrame, + Index, + MultiIndex, +) +import pandas._testing as tm + + +class TestDropLevel: + def test_droplevel(self, frame_or_series): + # GH#20342 + cols = MultiIndex.from_tuples( + [("c", "e"), ("d", "f")], names=["level_1", "level_2"] + ) + mi = MultiIndex.from_tuples([(1, 2), (5, 6), (9, 10)], names=["a", "b"]) + df = DataFrame([[3, 4], [7, 8], [11, 12]], index=mi, columns=cols) + if frame_or_series is not DataFrame: + df = df.iloc[:, 0] + + # test that dropping of a level in index works + expected = df.reset_index("a", drop=True) + result = df.droplevel("a", axis="index") + tm.assert_equal(result, expected) + + if frame_or_series is DataFrame: + # test that dropping of a level in columns works + expected = df.copy() + expected.columns = Index(["c", "d"], name="level_1") + result = df.droplevel("level_2", axis="columns") + tm.assert_equal(result, expected) + else: + # test that droplevel raises ValueError on axis != 0 + with pytest.raises(ValueError, match="No axis named columns"): + df.droplevel(1, axis="columns") diff --git a/shared/package-files/2f/2f5ba5e8e9a52d2586643b3e08b7776bf08d4bdf29dc1841d4d1a56e741c5ab9/blob b/shared/package-files/2f/2f5ba5e8e9a52d2586643b3e08b7776bf08d4bdf29dc1841d4d1a56e741c5ab9/blob new file mode 100644 index 0000000000000000000000000000000000000000..5b5b6ccf6387b63ee4b8e539265e00fde664dd64 --- /dev/null +++ b/shared/package-files/2f/2f5ba5e8e9a52d2586643b3e08b7776bf08d4bdf29dc1841d4d1a56e741c5ab9/blob @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API ::std::vector _foreach_zero(at::TensorList self); +TORCH_API void _foreach_zero_out(at::TensorList out, at::TensorList self); +TORCH_API void _foreach_zero_outf(at::TensorList self, at::TensorList out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/shared/package-files/2f/2f5e6b7cdf03c0e450967f905b78a105a55d09f57b21b6be97095ccb0d5ffd59/blob b/shared/package-files/2f/2f5e6b7cdf03c0e450967f905b78a105a55d09f57b21b6be97095ccb0d5ffd59/blob new file mode 100644 index 0000000000000000000000000000000000000000..5dc91bf4950721bfeacacd8bf7acff1fdf629606 --- /dev/null +++ b/shared/package-files/2f/2f5e6b7cdf03c0e450967f905b78a105a55d09f57b21b6be97095ccb0d5ffd59/blob @@ -0,0 +1,203 @@ +import importlib.resources +import locale +import logging +import os +import sys +from optparse import Values +from types import ModuleType +from typing import Any, Dict, List, Optional + +import pip._vendor +from pip._vendor.certifi import where +from pip._vendor.packaging.version import parse as parse_version + +from pip._internal.cli import cmdoptions +from pip._internal.cli.base_command import Command +from pip._internal.cli.cmdoptions import make_target_python +from pip._internal.cli.status_codes import SUCCESS +from pip._internal.configuration import Configuration +from pip._internal.metadata import get_environment +from pip._internal.utils.logging import indent_log +from pip._internal.utils.misc import get_pip_version + +logger = logging.getLogger(__name__) + + +def show_value(name: str, value: Any) -> None: + logger.info("%s: %s", name, value) + + +def show_sys_implementation() -> None: + logger.info("sys.implementation:") + implementation_name = sys.implementation.name + with indent_log(): + show_value("name", implementation_name) + + +def create_vendor_txt_map() -> Dict[str, str]: + with importlib.resources.open_text("pip._vendor", "vendor.txt") as f: + # Purge non version specifying lines. + # Also, remove any space prefix or suffixes (including comments). + lines = [ + line.strip().split(" ", 1)[0] for line in f.readlines() if "==" in line + ] + + # Transform into "module" -> version dict. + return dict(line.split("==", 1) for line in lines) + + +def get_module_from_module_name(module_name: str) -> Optional[ModuleType]: + # Module name can be uppercase in vendor.txt for some reason... + module_name = module_name.lower().replace("-", "_") + # PATCH: setuptools is actually only pkg_resources. + if module_name == "setuptools": + module_name = "pkg_resources" + + try: + __import__(f"pip._vendor.{module_name}", globals(), locals(), level=0) + return getattr(pip._vendor, module_name) + except ImportError: + # We allow 'truststore' to fail to import due + # to being unavailable on Python 3.9 and earlier. + if module_name == "truststore" and sys.version_info < (3, 10): + return None + raise + + +def get_vendor_version_from_module(module_name: str) -> Optional[str]: + module = get_module_from_module_name(module_name) + version = getattr(module, "__version__", None) + + if module and not version: + # Try to find version in debundled module info. + assert module.__file__ is not None + env = get_environment([os.path.dirname(module.__file__)]) + dist = env.get_distribution(module_name) + if dist: + version = str(dist.version) + + return version + + +def show_actual_vendor_versions(vendor_txt_versions: Dict[str, str]) -> None: + """Log the actual version and print extra info if there is + a conflict or if the actual version could not be imported. + """ + for module_name, expected_version in vendor_txt_versions.items(): + extra_message = "" + actual_version = get_vendor_version_from_module(module_name) + if not actual_version: + extra_message = ( + " (Unable to locate actual module version, using" + " vendor.txt specified version)" + ) + actual_version = expected_version + elif parse_version(actual_version) != parse_version(expected_version): + extra_message = ( + " (CONFLICT: vendor.txt suggests version should" + " be {})".format(expected_version) + ) + logger.info("%s==%s%s", module_name, actual_version, extra_message) + + +def show_vendor_versions() -> None: + logger.info("vendored library versions:") + + vendor_txt_versions = create_vendor_txt_map() + with indent_log(): + show_actual_vendor_versions(vendor_txt_versions) + + +def show_tags(options: Values) -> None: + tag_limit = 10 + + target_python = make_target_python(options) + tags = target_python.get_sorted_tags() + + # Display the target options that were explicitly provided. + formatted_target = target_python.format_given() + suffix = "" + if formatted_target: + suffix = f" (target: {formatted_target})" + + msg = "Compatible tags: {}{}".format(len(tags), suffix) + logger.info(msg) + + if options.verbose < 1 and len(tags) > tag_limit: + tags_limited = True + tags = tags[:tag_limit] + else: + tags_limited = False + + with indent_log(): + for tag in tags: + logger.info(str(tag)) + + if tags_limited: + msg = ( + "...\n[First {tag_limit} tags shown. Pass --verbose to show all.]" + ).format(tag_limit=tag_limit) + logger.info(msg) + + +def ca_bundle_info(config: Configuration) -> str: + levels = {key.split(".", 1)[0] for key, _ in config.items()} + if not levels: + return "Not specified" + + levels_that_override_global = ["install", "wheel", "download"] + global_overriding_level = [ + level for level in levels if level in levels_that_override_global + ] + if not global_overriding_level: + return "global" + + if "global" in levels: + levels.remove("global") + return ", ".join(levels) + + +class DebugCommand(Command): + """ + Display debug information. + """ + + usage = """ + %prog """ + ignore_require_venv = True + + def add_options(self) -> None: + cmdoptions.add_target_python_options(self.cmd_opts) + self.parser.insert_option_group(0, self.cmd_opts) + self.parser.config.load() + + def run(self, options: Values, args: List[str]) -> int: + logger.warning( + "This command is only meant for debugging. " + "Do not use this with automation for parsing and getting these " + "details, since the output and options of this command may " + "change without notice." + ) + show_value("pip version", get_pip_version()) + show_value("sys.version", sys.version) + show_value("sys.executable", sys.executable) + show_value("sys.getdefaultencoding", sys.getdefaultencoding()) + show_value("sys.getfilesystemencoding", sys.getfilesystemencoding()) + show_value( + "locale.getpreferredencoding", + locale.getpreferredencoding(), + ) + show_value("sys.platform", sys.platform) + show_sys_implementation() + + show_value("'cert' config value", ca_bundle_info(self.parser.config)) + show_value("REQUESTS_CA_BUNDLE", os.environ.get("REQUESTS_CA_BUNDLE")) + show_value("CURL_CA_BUNDLE", os.environ.get("CURL_CA_BUNDLE")) + show_value("pip._vendor.certifi.where()", where()) + show_value("pip._vendor.DEBUNDLED", pip._vendor.DEBUNDLED) + + show_vendor_versions() + + show_tags(options) + + return SUCCESS diff --git a/shared/package-files/2f/2f5f954b4c8132b09365386dae87c887b398977f45795fdf9134411d117c9aed/blob b/shared/package-files/2f/2f5f954b4c8132b09365386dae87c887b398977f45795fdf9134411d117c9aed/blob new file mode 100644 index 0000000000000000000000000000000000000000..b31cf7d0ed110f9532c2ef00d857f79075a06d2b --- /dev/null +++ b/shared/package-files/2f/2f5f954b4c8132b09365386dae87c887b398977f45795fdf9134411d117c9aed/blob @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor & smooth_l1_loss_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, int64_t reduction, double beta); +TORCH_API at::Tensor & smooth_l1_loss_backward_outf(const at::Tensor & grad_output, const at::Tensor & self, const at::Tensor & target, int64_t reduction, double beta, at::Tensor & grad_input); + +} // namespace cpu +} // namespace at diff --git a/shared/package-files/2f/2f626635294596acca06c371a1312462b11e6cd919678eb3e244d61d4e0a2db5/blob b/shared/package-files/2f/2f626635294596acca06c371a1312462b11e6cd919678eb3e244d61d4e0a2db5/blob new file mode 100644 index 0000000000000000000000000000000000000000..96ece2bfe204cc740c94ea2c7e3006e3a9f23200 --- /dev/null +++ b/shared/package-files/2f/2f626635294596acca06c371a1312462b11e6cd919678eb3e244d61d4e0a2db5/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2f626635294596acca06c371a1312462b11e6cd919678eb3e244d61d4e0a2db5 +size 280968 diff --git a/shared/package-files/2f/2f62c4959f7b68e42b1a57a99d65f20346587e3301db5587d17c3c13ce1de93e/blob b/shared/package-files/2f/2f62c4959f7b68e42b1a57a99d65f20346587e3301db5587d17c3c13ce1de93e/blob new file mode 100644 index 0000000000000000000000000000000000000000..27f7af785d56e7730022a61f54ae8524f180e1b2 --- /dev/null +++ b/shared/package-files/2f/2f62c4959f7b68e42b1a57a99d65f20346587e3301db5587d17c3c13ce1de93e/blob @@ -0,0 +1,168 @@ +function [X,Time,Z] = load_data(datafile,Spec,sample,loadExcel) +%loadData Load vintage of data from file and format as structure +% +% Description: +% +% Load data from file +% +% Input Arguments: +% +% datafile - filename of Microsoft Excel workbook file +% +% Output Arguments: +% +% Data - structure with the following fields: +% . X : T x N numeric array, transformed dataset +% . Time : T x 1 numeric array, date number with observation dates +% . Z : T x N numeric array, raw (untransformed) dataset + +fprintf('Loading data... \n'); + +if nargin < 4 + loadExcel = 0; +end + +ext = datafile(find(datafile=='.',1,'last'):end); % file extension + +idx = strfind(datafile,filesep); idx = idx(2); +datafile_mat = fullfile(datafile(1:idx),'mat',[strtok(datafile(idx+1:end),'.') '.mat']); +if exist(datafile_mat,'file')==2 && ~loadExcel + % Load raw data from MATLAB formatted binary (.mat) file + d = load(datafile_mat); + Z = d.Z; + Time = d.Time; + Mnem = d.Mnem; +elseif any(strcmpi(ext,{'.xlsx','.xls'})) + % Read raw data from Excel file + [Z,Time,Mnem] = readData(datafile); + save(datafile_mat,'Z','Time','Mnem'); + % Z : raw (untransformed) observed data + % Time : observation periods for the time series data + % Mnem : series ID for each variable +else + error('Only Microsoft Excel workbook files supported.'); +end + +% Sort data based on model specification +Z = sortData(Z,Mnem,Spec); +clear Mnem; % since now Mnem == Spec.SeriesID + +% Transform data based on model specification +[X,Time,Z] = transformData(Z,Time,Spec); + +% Drop data not in estimation sample +if nargin == 3 + [X,Time,Z] = dropData(X,Time,Z,sample); +end + +end + + +function [Z,Time,Mnem] = readData(datafile) +%readData Read data from Microsoft Excel workbook file + +[DATA,TEXT] = xlsread(datafile,'data'); +Mnem = TEXT(1,2:end); +if ispc + Time = datenum(TEXT(2:end,1),'mm/dd/yyyy'); + Z = DATA; +else + Time = DATA(:,1) + datenum(1899,12,31) - 1; + Z = DATA(:,2:end); +end + +end + +function [Z,Mnem] = sortData(Z,Mnem,Spec) +%sortData Sort series by order of model specification + +% Drop series not in Spec +inSpec = ismember(Mnem,Spec.SeriesID); +Mnem(~inSpec) = []; +Z(:,~inSpec) = []; + +% Sort series by ordering of Spec +N = length(Spec.SeriesID); +permutation = NaN(1,N); +for i = 1:N + idxSeriesSpec = find(strcmp(Spec.SeriesID{i},Mnem)); + permutation(i) = idxSeriesSpec; +end + +Mnem = Mnem(permutation); +Z = Z(:,permutation); + + +end + + +function [X,Time,Z] = transformData(Z,Time,Spec) +%transformData Transforms each data series based on Spec.Transformation +% +% Input Arguments: +% +% Z : T x N numeric array, raw (untransformed) observed data +% Spec : structure , model specification +% +% Output Arguments: +% +% X : T x N numeric array, transformed data (stationary to enter DFM) + +T = size(Z,1); +N = size(Z,2); + +X = NaN(T,N); +for i = 1:N + formula = Spec.Transformation{i}; + freq = Spec.Frequency{i}; + switch freq % time step for different frequencies based on monthly time + case 'm' % Monthly + step = 1; + case 'q' % Quarterly + step = 3; + end + t1 = step; % assume monthly observations start at beginning of quarter + n = step/12; % number of years, needed to compute annual % changes + series = Spec.SeriesName{i}; + switch formula + case 'lin' % Levels (No Transformation) + X(:,i) = Z(:,i); + case 'chg' % Change (Difference) + X(t1:step:T,i) = [NaN; Z(t1+step:step:T,i) - Z(t1:step:T-t1,i)]; + case 'ch1' % Year over Year Change (Difference) + X(12+t1:step:T,i) = Z(12+t1:step:T,i) - Z(t1:step:T-12,i); + case 'pch' % Percent Change + X(t1:step:T,i) = 100*[NaN; Z(t1+step:step:T,i) ./ Z(t1:step:T-t1,i) - 1]; + case 'pc1' % Year over Year Percent Change + X(12+t1:step:T,i) = 100*(Z(12+t1:step:T,i) ./ Z(t1:step:T-12,i) - 1); + case 'pca' % Percent Change (Annual Rate) + X(t1:step:T,i) = 100*[NaN; (Z(t1+step:step:T,i) ./ Z(t1:step:T-step,i)).^(1/n) - 1]; + case 'log' % Natural Log + X(:,i) = log(Z(:,i)); + otherwise + warning(['Transformation ''' formula ''' not found for ' series '. ' 'Using untransformed data.']); + X(:,i) = Z(:,i); + end +end + + +% Drop first quarter of observations +% since transformations cause missing values +Time = Time(4:end); +Z = Z(4:end,:); +X = X(4:end,:); + +end + + +function [X,Time,Z] = dropData(X,Time,Z,sample) +%dropData Remove data not in estimation sample + +idxDrop = Time < sample; + +Time(idxDrop) = []; +X(idxDrop,:) = []; +Z(idxDrop,:) = []; + +end + diff --git a/shared/package-files/2f/2f66990422ae7bfa7bb4728d65aa550e9fe73e4c24207d52b97d189c6b05db14/blob b/shared/package-files/2f/2f66990422ae7bfa7bb4728d65aa550e9fe73e4c24207d52b97d189c6b05db14/blob new file mode 100644 index 0000000000000000000000000000000000000000..64bfae3f9fdc7994a56d3c5a0841c861e4a595d6 --- /dev/null +++ b/shared/package-files/2f/2f66990422ae7bfa7bb4728d65aa550e9fe73e4c24207d52b97d189c6b05db14/blob @@ -0,0 +1,513 @@ +/* + * include/omp.h.var + */ + + +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + + +#ifndef __OMP_H +# define __OMP_H + +# include +# include + +# define KMP_VERSION_MAJOR 5 +# define KMP_VERSION_MINOR 0 +# define KMP_VERSION_BUILD 20140926 +# define KMP_BUILD_DATE "No_Timestamp" + +# ifdef __cplusplus + extern "C" { +# endif + +# define omp_set_affinity_format ompc_set_affinity_format +# define omp_get_affinity_format ompc_get_affinity_format +# define omp_display_affinity ompc_display_affinity +# define omp_capture_affinity ompc_capture_affinity + +# if defined(_WIN32) +# define __KAI_KMPC_CONVENTION __cdecl +# ifndef __KMP_IMP +# define __KMP_IMP __declspec(dllimport) +# endif +# else +# define __KAI_KMPC_CONVENTION +# ifndef __KMP_IMP +# define __KMP_IMP +# endif +# endif + + /* schedule kind constants */ + typedef enum omp_sched_t { + omp_sched_static = 1, + omp_sched_dynamic = 2, + omp_sched_guided = 3, + omp_sched_auto = 4, + omp_sched_monotonic = 0x80000000 + } omp_sched_t; + + /* set API functions */ + extern void __KAI_KMPC_CONVENTION omp_set_num_threads (int); + extern void __KAI_KMPC_CONVENTION omp_set_dynamic (int); + extern void __KAI_KMPC_CONVENTION omp_set_nested (int); + extern void __KAI_KMPC_CONVENTION omp_set_max_active_levels (int); + extern void __KAI_KMPC_CONVENTION omp_set_schedule (omp_sched_t, int); + + /* query API functions */ + extern int __KAI_KMPC_CONVENTION omp_get_num_threads (void); + extern int __KAI_KMPC_CONVENTION omp_get_dynamic (void); + extern int __KAI_KMPC_CONVENTION omp_get_nested (void); + extern int __KAI_KMPC_CONVENTION omp_get_max_threads (void); + extern int __KAI_KMPC_CONVENTION omp_get_thread_num (void); + extern int __KAI_KMPC_CONVENTION omp_get_num_procs (void); + extern int __KAI_KMPC_CONVENTION omp_in_parallel (void); + extern int __KAI_KMPC_CONVENTION omp_in_final (void); + extern int __KAI_KMPC_CONVENTION omp_get_active_level (void); + extern int __KAI_KMPC_CONVENTION omp_get_level (void); + extern int __KAI_KMPC_CONVENTION omp_get_ancestor_thread_num (int); + extern int __KAI_KMPC_CONVENTION omp_get_team_size (int); + extern int __KAI_KMPC_CONVENTION omp_get_thread_limit (void); + extern int __KAI_KMPC_CONVENTION omp_get_max_active_levels (void); + extern void __KAI_KMPC_CONVENTION omp_get_schedule (omp_sched_t *, int *); + extern int __KAI_KMPC_CONVENTION omp_get_max_task_priority (void); + + /* lock API functions */ + typedef struct omp_lock_t { + void * _lk; + } omp_lock_t; + + extern void __KAI_KMPC_CONVENTION omp_init_lock (omp_lock_t *); + extern void __KAI_KMPC_CONVENTION omp_set_lock (omp_lock_t *); + extern void __KAI_KMPC_CONVENTION omp_unset_lock (omp_lock_t *); + extern void __KAI_KMPC_CONVENTION omp_destroy_lock (omp_lock_t *); + extern int __KAI_KMPC_CONVENTION omp_test_lock (omp_lock_t *); + + /* nested lock API functions */ + typedef struct omp_nest_lock_t { + void * _lk; + } omp_nest_lock_t; + + extern void __KAI_KMPC_CONVENTION omp_init_nest_lock (omp_nest_lock_t *); + extern void __KAI_KMPC_CONVENTION omp_set_nest_lock (omp_nest_lock_t *); + extern void __KAI_KMPC_CONVENTION omp_unset_nest_lock (omp_nest_lock_t *); + extern void __KAI_KMPC_CONVENTION omp_destroy_nest_lock (omp_nest_lock_t *); + extern int __KAI_KMPC_CONVENTION omp_test_nest_lock (omp_nest_lock_t *); + + /* OpenMP 5.0 Synchronization hints*/ + typedef enum omp_sync_hint_t { + omp_sync_hint_none = 0, + omp_lock_hint_none = omp_sync_hint_none, + omp_sync_hint_uncontended = 1, + omp_lock_hint_uncontended = omp_sync_hint_uncontended, + omp_sync_hint_contended = (1<<1), + omp_lock_hint_contended = omp_sync_hint_contended, + omp_sync_hint_nonspeculative = (1<<2), + omp_lock_hint_nonspeculative = omp_sync_hint_nonspeculative, + omp_sync_hint_speculative = (1<<3), + omp_lock_hint_speculative = omp_sync_hint_speculative, + kmp_lock_hint_hle = (1<<16), + kmp_lock_hint_rtm = (1<<17), + kmp_lock_hint_adaptive = (1<<18) + } omp_sync_hint_t; + + /* lock hint type for dynamic user lock */ + typedef omp_sync_hint_t omp_lock_hint_t; + + /* hinted lock initializers */ + extern void __KAI_KMPC_CONVENTION omp_init_lock_with_hint(omp_lock_t *, omp_lock_hint_t); + extern void __KAI_KMPC_CONVENTION omp_init_nest_lock_with_hint(omp_nest_lock_t *, omp_lock_hint_t); + + /* time API functions */ + extern double __KAI_KMPC_CONVENTION omp_get_wtime (void); + extern double __KAI_KMPC_CONVENTION omp_get_wtick (void); + + /* OpenMP 4.0 */ + extern int __KAI_KMPC_CONVENTION omp_get_default_device (void); + extern void __KAI_KMPC_CONVENTION omp_set_default_device (int); + extern int __KAI_KMPC_CONVENTION omp_is_initial_device (void); + extern int __KAI_KMPC_CONVENTION omp_get_num_devices (void); + extern int __KAI_KMPC_CONVENTION omp_get_num_teams (void); + extern int __KAI_KMPC_CONVENTION omp_get_team_num (void); + extern int __KAI_KMPC_CONVENTION omp_get_cancellation (void); + + /* OpenMP 4.5 */ + extern int __KAI_KMPC_CONVENTION omp_get_initial_device (void); + extern void* __KAI_KMPC_CONVENTION omp_target_alloc(size_t, int); + extern void __KAI_KMPC_CONVENTION omp_target_free(void *, int); + extern int __KAI_KMPC_CONVENTION omp_target_is_present(const void *, int); + extern int __KAI_KMPC_CONVENTION omp_target_memcpy(void *, const void *, size_t, size_t, size_t, int, int); + extern int __KAI_KMPC_CONVENTION omp_target_memcpy_rect(void *, const void *, size_t, int, const size_t *, + const size_t *, const size_t *, const size_t *, const size_t *, int, int); + extern int __KAI_KMPC_CONVENTION omp_target_associate_ptr(const void *, const void *, size_t, size_t, int); + extern int __KAI_KMPC_CONVENTION omp_target_disassociate_ptr(const void *, int); + + /* OpenMP 5.0 */ + extern int __KAI_KMPC_CONVENTION omp_get_device_num (void); + typedef void * omp_depend_t; + + /* OpenMP 5.1 interop */ + typedef intptr_t omp_intptr_t; + + /* 0..omp_get_num_interop_properties()-1 are reserved for implementation-defined properties */ + typedef enum omp_interop_property { + omp_ipr_fr_id = -1, + omp_ipr_fr_name = -2, + omp_ipr_vendor = -3, + omp_ipr_vendor_name = -4, + omp_ipr_device_num = -5, + omp_ipr_platform = -6, + omp_ipr_device = -7, + omp_ipr_device_context = -8, + omp_ipr_targetsync = -9, + omp_ipr_first = -9 + } omp_interop_property_t; + + #define omp_interop_none 0 + + typedef enum omp_interop_rc { + omp_irc_no_value = 1, + omp_irc_success = 0, + omp_irc_empty = -1, + omp_irc_out_of_range = -2, + omp_irc_type_int = -3, + omp_irc_type_ptr = -4, + omp_irc_type_str = -5, + omp_irc_other = -6 + } omp_interop_rc_t; + + typedef enum omp_interop_fr { + omp_ifr_cuda = 1, + omp_ifr_cuda_driver = 2, + omp_ifr_opencl = 3, + omp_ifr_sycl = 4, + omp_ifr_hip = 5, + omp_ifr_level_zero = 6, + omp_ifr_last = 7 + } omp_interop_fr_t; + + typedef void * omp_interop_t; + + /*! + * The `omp_get_num_interop_properties` routine retrieves the number of implementation-defined properties available for an `omp_interop_t` object. + */ + extern int __KAI_KMPC_CONVENTION omp_get_num_interop_properties(const omp_interop_t); + /*! + * The `omp_get_interop_int` routine retrieves an integer property from an `omp_interop_t` object. + */ + extern omp_intptr_t __KAI_KMPC_CONVENTION omp_get_interop_int(const omp_interop_t, omp_interop_property_t, int *); + /*! + * The `omp_get_interop_ptr` routine retrieves a pointer property from an `omp_interop_t` object. + */ + extern void * __KAI_KMPC_CONVENTION omp_get_interop_ptr(const omp_interop_t, omp_interop_property_t, int *); + /*! + * The `omp_get_interop_str` routine retrieves a string property from an `omp_interop_t` object. + */ + extern const char * __KAI_KMPC_CONVENTION omp_get_interop_str(const omp_interop_t, omp_interop_property_t, int *); + /*! + * The `omp_get_interop_name` routine retrieves a property name from an `omp_interop_t` object. + */ + extern const char * __KAI_KMPC_CONVENTION omp_get_interop_name(const omp_interop_t, omp_interop_property_t); + /*! + * The `omp_get_interop_type_desc` routine retrieves a description of the type of a property associated with an `omp_interop_t` object. + */ + extern const char * __KAI_KMPC_CONVENTION omp_get_interop_type_desc(const omp_interop_t, omp_interop_property_t); + /*! + * The `omp_get_interop_rc_desc` routine retrieves a description of the return code associated with an `omp_interop_t` object. + */ + extern const char * __KAI_KMPC_CONVENTION omp_get_interop_rc_desc(const omp_interop_t, omp_interop_rc_t); + + /* OpenMP 5.1 device memory routines */ + + /*! + * The `omp_target_memcpy_async` routine asynchronously performs a copy between any combination of host and device pointers. + */ + extern int __KAI_KMPC_CONVENTION omp_target_memcpy_async(void *, const void *, size_t, size_t, size_t, int, + int, int, omp_depend_t *); + /*! + * The `omp_target_memcpy_rect_async` routine asynchronously performs a copy between any combination of host and device pointers. + */ + extern int __KAI_KMPC_CONVENTION omp_target_memcpy_rect_async(void *, const void *, size_t, int, const size_t *, + const size_t *, const size_t *, const size_t *, const size_t *, int, int, + int, omp_depend_t *); + /*! + * The `omp_get_mapped_ptr` routine returns the device pointer that is associated with a host pointer for a given device. + */ + extern void * __KAI_KMPC_CONVENTION omp_get_mapped_ptr(const void *, int); + extern int __KAI_KMPC_CONVENTION omp_target_is_accessible(const void *, size_t, int); + + /* kmp API functions */ + extern int __KAI_KMPC_CONVENTION kmp_get_stacksize (void); + extern void __KAI_KMPC_CONVENTION kmp_set_stacksize (int); + extern size_t __KAI_KMPC_CONVENTION kmp_get_stacksize_s (void); + extern void __KAI_KMPC_CONVENTION kmp_set_stacksize_s (size_t); + extern int __KAI_KMPC_CONVENTION kmp_get_blocktime (void); + extern int __KAI_KMPC_CONVENTION kmp_get_library (void); + extern void __KAI_KMPC_CONVENTION kmp_set_blocktime (int); + extern void __KAI_KMPC_CONVENTION kmp_set_library (int); + extern void __KAI_KMPC_CONVENTION kmp_set_library_serial (void); + extern void __KAI_KMPC_CONVENTION kmp_set_library_turnaround (void); + extern void __KAI_KMPC_CONVENTION kmp_set_library_throughput (void); + extern void __KAI_KMPC_CONVENTION kmp_set_defaults (char const *); + extern void __KAI_KMPC_CONVENTION kmp_set_disp_num_buffers (int); + + /* Intel affinity API */ + typedef void * kmp_affinity_mask_t; + + extern int __KAI_KMPC_CONVENTION kmp_set_affinity (kmp_affinity_mask_t *); + extern int __KAI_KMPC_CONVENTION kmp_get_affinity (kmp_affinity_mask_t *); + extern int __KAI_KMPC_CONVENTION kmp_get_affinity_max_proc (void); + extern void __KAI_KMPC_CONVENTION kmp_create_affinity_mask (kmp_affinity_mask_t *); + extern void __KAI_KMPC_CONVENTION kmp_destroy_affinity_mask (kmp_affinity_mask_t *); + extern int __KAI_KMPC_CONVENTION kmp_set_affinity_mask_proc (int, kmp_affinity_mask_t *); + extern int __KAI_KMPC_CONVENTION kmp_unset_affinity_mask_proc (int, kmp_affinity_mask_t *); + extern int __KAI_KMPC_CONVENTION kmp_get_affinity_mask_proc (int, kmp_affinity_mask_t *); + + /* OpenMP 4.0 affinity API */ + typedef enum omp_proc_bind_t { + omp_proc_bind_false = 0, + omp_proc_bind_true = 1, + omp_proc_bind_master = 2, + omp_proc_bind_close = 3, + omp_proc_bind_spread = 4 + } omp_proc_bind_t; + + extern omp_proc_bind_t __KAI_KMPC_CONVENTION omp_get_proc_bind (void); + + /* OpenMP 4.5 affinity API */ + extern int __KAI_KMPC_CONVENTION omp_get_num_places (void); + extern int __KAI_KMPC_CONVENTION omp_get_place_num_procs (int); + extern void __KAI_KMPC_CONVENTION omp_get_place_proc_ids (int, int *); + extern int __KAI_KMPC_CONVENTION omp_get_place_num (void); + extern int __KAI_KMPC_CONVENTION omp_get_partition_num_places (void); + extern void __KAI_KMPC_CONVENTION omp_get_partition_place_nums (int *); + + extern void * __KAI_KMPC_CONVENTION kmp_malloc (size_t); + extern void * __KAI_KMPC_CONVENTION kmp_aligned_malloc (size_t, size_t); + extern void * __KAI_KMPC_CONVENTION kmp_calloc (size_t, size_t); + extern void * __KAI_KMPC_CONVENTION kmp_realloc (void *, size_t); + extern void __KAI_KMPC_CONVENTION kmp_free (void *); + + extern void __KAI_KMPC_CONVENTION kmp_set_warnings_on(void); + extern void __KAI_KMPC_CONVENTION kmp_set_warnings_off(void); + + /* OpenMP 5.0 Tool Control */ + typedef enum omp_control_tool_result_t { + omp_control_tool_notool = -2, + omp_control_tool_nocallback = -1, + omp_control_tool_success = 0, + omp_control_tool_ignored = 1 + } omp_control_tool_result_t; + + typedef enum omp_control_tool_t { + omp_control_tool_start = 1, + omp_control_tool_pause = 2, + omp_control_tool_flush = 3, + omp_control_tool_end = 4 + } omp_control_tool_t; + + extern int __KAI_KMPC_CONVENTION omp_control_tool(int, int, void*); + + /* OpenMP 5.0 Memory Management */ + typedef uintptr_t omp_uintptr_t; + + typedef enum { + omp_atk_sync_hint = 1, + omp_atk_alignment = 2, + omp_atk_access = 3, + omp_atk_pool_size = 4, + omp_atk_fallback = 5, + omp_atk_fb_data = 6, + omp_atk_pinned = 7, + omp_atk_partition = 8 + } omp_alloctrait_key_t; + + typedef enum { + omp_atv_false = 0, + omp_atv_true = 1, + omp_atv_contended = 3, + omp_atv_uncontended = 4, + omp_atv_serialized = 5, + omp_atv_sequential = omp_atv_serialized, // (deprecated) + omp_atv_private = 6, + omp_atv_all = 7, + omp_atv_thread = 8, + omp_atv_pteam = 9, + omp_atv_cgroup = 10, + omp_atv_default_mem_fb = 11, + omp_atv_null_fb = 12, + omp_atv_abort_fb = 13, + omp_atv_allocator_fb = 14, + omp_atv_environment = 15, + omp_atv_nearest = 16, + omp_atv_blocked = 17, + omp_atv_interleaved = 18 + } omp_alloctrait_value_t; + #define omp_atv_default ((omp_uintptr_t)-1) + + typedef struct { + omp_alloctrait_key_t key; + omp_uintptr_t value; + } omp_alloctrait_t; + +# if defined(_WIN32) + // On Windows cl and icl do not support 64-bit enum, let's use integer then. + typedef omp_uintptr_t omp_allocator_handle_t; + extern __KMP_IMP omp_allocator_handle_t const omp_null_allocator; + extern __KMP_IMP omp_allocator_handle_t const omp_default_mem_alloc; + extern __KMP_IMP omp_allocator_handle_t const omp_large_cap_mem_alloc; + extern __KMP_IMP omp_allocator_handle_t const omp_const_mem_alloc; + extern __KMP_IMP omp_allocator_handle_t const omp_high_bw_mem_alloc; + extern __KMP_IMP omp_allocator_handle_t const omp_low_lat_mem_alloc; + extern __KMP_IMP omp_allocator_handle_t const omp_cgroup_mem_alloc; + extern __KMP_IMP omp_allocator_handle_t const omp_pteam_mem_alloc; + extern __KMP_IMP omp_allocator_handle_t const omp_thread_mem_alloc; + /* Preview of target memory support */ + extern __KMP_IMP omp_allocator_handle_t const llvm_omp_target_host_mem_alloc; + extern __KMP_IMP omp_allocator_handle_t const llvm_omp_target_shared_mem_alloc; + extern __KMP_IMP omp_allocator_handle_t const llvm_omp_target_device_mem_alloc; + + typedef omp_uintptr_t omp_memspace_handle_t; + extern __KMP_IMP omp_memspace_handle_t const omp_default_mem_space; + extern __KMP_IMP omp_memspace_handle_t const omp_large_cap_mem_space; + extern __KMP_IMP omp_memspace_handle_t const omp_const_mem_space; + extern __KMP_IMP omp_memspace_handle_t const omp_high_bw_mem_space; + extern __KMP_IMP omp_memspace_handle_t const omp_low_lat_mem_space; + /* Preview of target memory support */ + extern __KMP_IMP omp_memspace_handle_t const llvm_omp_target_host_mem_space; + extern __KMP_IMP omp_memspace_handle_t const llvm_omp_target_shared_mem_space; + extern __KMP_IMP omp_memspace_handle_t const llvm_omp_target_device_mem_space; +# else +# if __cplusplus >= 201103 + typedef enum omp_allocator_handle_t : omp_uintptr_t +# else + typedef enum omp_allocator_handle_t +# endif + { + omp_null_allocator = 0, + omp_default_mem_alloc = 1, + omp_large_cap_mem_alloc = 2, + omp_const_mem_alloc = 3, + omp_high_bw_mem_alloc = 4, + omp_low_lat_mem_alloc = 5, + omp_cgroup_mem_alloc = 6, + omp_pteam_mem_alloc = 7, + omp_thread_mem_alloc = 8, + /* Preview of target memory support */ + llvm_omp_target_host_mem_alloc = 100, + llvm_omp_target_shared_mem_alloc = 101, + llvm_omp_target_device_mem_alloc = 102, + KMP_ALLOCATOR_MAX_HANDLE = UINTPTR_MAX + } omp_allocator_handle_t; +# if __cplusplus >= 201103 + typedef enum omp_memspace_handle_t : omp_uintptr_t +# else + typedef enum omp_memspace_handle_t +# endif + { + omp_default_mem_space = 0, + omp_large_cap_mem_space = 1, + omp_const_mem_space = 2, + omp_high_bw_mem_space = 3, + omp_low_lat_mem_space = 4, + /* Preview of target memory support */ + llvm_omp_target_host_mem_space = 100, + llvm_omp_target_shared_mem_space = 101, + llvm_omp_target_device_mem_space = 102, + KMP_MEMSPACE_MAX_HANDLE = UINTPTR_MAX + } omp_memspace_handle_t; +# endif + extern omp_allocator_handle_t __KAI_KMPC_CONVENTION omp_init_allocator(omp_memspace_handle_t m, + int ntraits, omp_alloctrait_t traits[]); + extern void __KAI_KMPC_CONVENTION omp_destroy_allocator(omp_allocator_handle_t allocator); + + extern void __KAI_KMPC_CONVENTION omp_set_default_allocator(omp_allocator_handle_t a); + extern omp_allocator_handle_t __KAI_KMPC_CONVENTION omp_get_default_allocator(void); +# ifdef __cplusplus + extern void *__KAI_KMPC_CONVENTION omp_alloc(size_t size, omp_allocator_handle_t a = omp_null_allocator); + extern void *__KAI_KMPC_CONVENTION omp_aligned_alloc(size_t align, size_t size, + omp_allocator_handle_t a = omp_null_allocator); + extern void *__KAI_KMPC_CONVENTION omp_calloc(size_t nmemb, size_t size, + omp_allocator_handle_t a = omp_null_allocator); + extern void *__KAI_KMPC_CONVENTION omp_aligned_calloc(size_t align, size_t nmemb, size_t size, + omp_allocator_handle_t a = omp_null_allocator); + extern void *__KAI_KMPC_CONVENTION omp_realloc(void *ptr, size_t size, + omp_allocator_handle_t allocator = omp_null_allocator, + omp_allocator_handle_t free_allocator = omp_null_allocator); + extern void __KAI_KMPC_CONVENTION omp_free(void * ptr, omp_allocator_handle_t a = omp_null_allocator); +# else + extern void *__KAI_KMPC_CONVENTION omp_alloc(size_t size, omp_allocator_handle_t a); + extern void *__KAI_KMPC_CONVENTION omp_aligned_alloc(size_t align, size_t size, + omp_allocator_handle_t a); + extern void *__KAI_KMPC_CONVENTION omp_calloc(size_t nmemb, size_t size, omp_allocator_handle_t a); + extern void *__KAI_KMPC_CONVENTION omp_aligned_calloc(size_t align, size_t nmemb, size_t size, + omp_allocator_handle_t a); + extern void *__KAI_KMPC_CONVENTION omp_realloc(void *ptr, size_t size, omp_allocator_handle_t allocator, + omp_allocator_handle_t free_allocator); + extern void __KAI_KMPC_CONVENTION omp_free(void *ptr, omp_allocator_handle_t a); +# endif + + /* OpenMP 5.0 Affinity Format */ + extern void __KAI_KMPC_CONVENTION omp_set_affinity_format(char const *); + extern size_t __KAI_KMPC_CONVENTION omp_get_affinity_format(char *, size_t); + extern void __KAI_KMPC_CONVENTION omp_display_affinity(char const *); + extern size_t __KAI_KMPC_CONVENTION omp_capture_affinity(char *, size_t, char const *); + + /* OpenMP 5.0 events */ +# if defined(_WIN32) + // On Windows cl and icl do not support 64-bit enum, let's use integer then. + typedef omp_uintptr_t omp_event_handle_t; +# else + typedef enum omp_event_handle_t { KMP_EVENT_MAX_HANDLE = UINTPTR_MAX } omp_event_handle_t; +# endif + extern void __KAI_KMPC_CONVENTION omp_fulfill_event ( omp_event_handle_t event ); + + /* OpenMP 5.0 Pause Resources */ + typedef enum omp_pause_resource_t { + omp_pause_resume = 0, + omp_pause_soft = 1, + omp_pause_hard = 2 + } omp_pause_resource_t; + extern int __KAI_KMPC_CONVENTION omp_pause_resource(omp_pause_resource_t, int); + extern int __KAI_KMPC_CONVENTION omp_pause_resource_all(omp_pause_resource_t); + + extern int __KAI_KMPC_CONVENTION omp_get_supported_active_levels(void); + + /* OpenMP 5.1 */ + extern void __KAI_KMPC_CONVENTION omp_set_num_teams(int num_teams); + extern int __KAI_KMPC_CONVENTION omp_get_max_teams(void); + extern void __KAI_KMPC_CONVENTION omp_set_teams_thread_limit(int limit); + extern int __KAI_KMPC_CONVENTION omp_get_teams_thread_limit(void); + + /* OpenMP 5.1 Display Environment */ + extern void omp_display_env(int verbose); + +# if defined(_OPENMP) && _OPENMP >= 201811 + #pragma omp begin declare variant match(device={kind(host)}) + static inline int omp_is_initial_device(void) { return 1; } + #pragma omp end declare variant + #pragma omp begin declare variant match(device={kind(nohost)}) + static inline int omp_is_initial_device(void) { return 0; } + #pragma omp end declare variant +# endif + +# undef __KAI_KMPC_CONVENTION +# undef __KMP_IMP + + /* Warning: + The following typedefs are not standard, deprecated and will be removed in a future release. + */ + typedef int omp_int_t; + typedef double omp_wtime_t; + +# ifdef __cplusplus + } +# endif + +#endif /* __OMP_H */ diff --git a/shared/package-files/2f/2f6714f87ed4535337ebfec353ba7af52bc61055995e9329509f0d652db23932/blob b/shared/package-files/2f/2f6714f87ed4535337ebfec353ba7af52bc61055995e9329509f0d652db23932/blob new file mode 100644 index 0000000000000000000000000000000000000000..4e569dc40005d5883870b82f46859d5bc36578f9 --- /dev/null +++ b/shared/package-files/2f/2f6714f87ed4535337ebfec353ba7af52bc61055995e9329509f0d652db23932/blob @@ -0,0 +1,103 @@ +from collections.abc import Generator +import contextlib + +import pytest + +import pandas as pd +import pandas._testing as tm +from pandas.core import accessor + + +def test_dirname_mixin() -> None: + # GH37173 + + class X(accessor.DirNamesMixin): + x = 1 + y: int + + def __init__(self) -> None: + self.z = 3 + + result = [attr_name for attr_name in dir(X()) if not attr_name.startswith("_")] + + assert result == ["x", "z"] + + +@contextlib.contextmanager +def ensure_removed(obj, attr) -> Generator[None, None, None]: + """Ensure that an attribute added to 'obj' during the test is + removed when we're done + """ + try: + yield + finally: + try: + delattr(obj, attr) + except AttributeError: + pass + obj._accessors.discard(attr) + + +class MyAccessor: + def __init__(self, obj) -> None: + self.obj = obj + self.item = "item" + + @property + def prop(self): + return self.item + + def method(self): + return self.item + + +@pytest.mark.parametrize( + "obj, registrar", + [ + (pd.Series, pd.api.extensions.register_series_accessor), + (pd.DataFrame, pd.api.extensions.register_dataframe_accessor), + (pd.Index, pd.api.extensions.register_index_accessor), + ], +) +def test_register(obj, registrar): + with ensure_removed(obj, "mine"): + before = set(dir(obj)) + registrar("mine")(MyAccessor) + o = obj([]) if obj is not pd.Series else obj([], dtype=object) + assert o.mine.prop == "item" + after = set(dir(obj)) + assert (before ^ after) == {"mine"} + assert "mine" in obj._accessors + + +def test_accessor_works(): + with ensure_removed(pd.Series, "mine"): + pd.api.extensions.register_series_accessor("mine")(MyAccessor) + + s = pd.Series([1, 2]) + assert s.mine.obj is s + + assert s.mine.prop == "item" + assert s.mine.method() == "item" + + +def test_overwrite_warns(): + match = r".*MyAccessor.*fake.*Series.*" + with tm.assert_produces_warning(UserWarning, match=match): + with ensure_removed(pd.Series, "fake"): + setattr(pd.Series, "fake", 123) + pd.api.extensions.register_series_accessor("fake")(MyAccessor) + s = pd.Series([1, 2]) + assert s.fake.prop == "item" + + +def test_raises_attribute_error(): + with ensure_removed(pd.Series, "bad"): + + @pd.api.extensions.register_series_accessor("bad") + class Bad: + def __init__(self, data) -> None: + raise AttributeError("whoops") + + with pytest.raises(AttributeError, match="whoops"): + pd.Series([], dtype=object).bad diff --git a/shared/package-files/2f/2f695b462c79cb2bb167aa6f2793f6c0c68cd11bec448b5b248579229add5915/blob b/shared/package-files/2f/2f695b462c79cb2bb167aa6f2793f6c0c68cd11bec448b5b248579229add5915/blob new file mode 100644 index 0000000000000000000000000000000000000000..fb448197a1e4f7b48b25e229e8da1a10cf8f409d --- /dev/null +++ b/shared/package-files/2f/2f695b462c79cb2bb167aa6f2793f6c0c68cd11bec448b5b248579229add5915/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API select_scatter { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, int64_t, c10::SymInt); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::select_scatter") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "select_scatter(Tensor self, Tensor src, int dim, SymInt index) -> Tensor") + static at::Tensor call(const at::Tensor & self, const at::Tensor & src, int64_t dim, c10::SymInt index); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & src, int64_t dim, c10::SymInt index); +}; + +struct TORCH_API select_scatter_out { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, c10::SymInt, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::select_scatter") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "select_scatter.out(Tensor self, Tensor src, int dim, SymInt index, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, const at::Tensor & src, int64_t dim, c10::SymInt index, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & src, int64_t dim, c10::SymInt index, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/2f/2f69a1105973212c624ee049d125a64093c82d029956be9d35d23aa91b698b31/blob b/shared/package-files/2f/2f69a1105973212c624ee049d125a64093c82d029956be9d35d23aa91b698b31/blob new file mode 100644 index 0000000000000000000000000000000000000000..f504fdce71c054739992094ed42553032eb9b826 Binary files /dev/null and b/shared/package-files/2f/2f69a1105973212c624ee049d125a64093c82d029956be9d35d23aa91b698b31/blob differ diff --git a/shared/package-files/2f/2f69d2e202cd16fba8f3da7762d07e9520d8636dbce12aa4187f6941023cbb07/blob b/shared/package-files/2f/2f69d2e202cd16fba8f3da7762d07e9520d8636dbce12aa4187f6941023cbb07/blob new file mode 100644 index 0000000000000000000000000000000000000000..56a4dd2a19fac5cc1bb1951dedf3ae93e0b9e321 Binary files /dev/null and b/shared/package-files/2f/2f69d2e202cd16fba8f3da7762d07e9520d8636dbce12aa4187f6941023cbb07/blob differ diff --git a/shared/package-files/2f/2f6b08439eb36ad1c53e0c150e554cd1c03e2b3048e0cebe4efdccf06e561d23/blob b/shared/package-files/2f/2f6b08439eb36ad1c53e0c150e554cd1c03e2b3048e0cebe4efdccf06e561d23/blob new file mode 100644 index 0000000000000000000000000000000000000000..4cab3be078e439ca16525eee6fde85b741af579a --- /dev/null +++ b/shared/package-files/2f/2f6b08439eb36ad1c53e0c150e554cd1c03e2b3048e0cebe4efdccf06e561d23/blob @@ -0,0 +1,73 @@ +//===- llvm/ADT/STLExtras.h - Useful STL related functions ------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file contains some templates that are useful if you are working with the +// STL at all. +// +// No library is required when using these functions. +// +//===----------------------------------------------------------------------===// + +// c10: modified from llvm::function_ref +// c10: added more SFINAE to enable use in overloaded functions + +#pragma once + +#include +#include +#include + +namespace c10 { + +/// An efficient, type-erasing, non-owning reference to a callable. This is +/// intended for use as the type of a function parameter that is not used +/// after the function in question returns. +/// +/// This class does not own the callable, so it is not in general safe to store +/// a function_ref. +template +class function_ref; + +template +class function_ref { + Ret (*callback)(intptr_t callable, Params... params) = nullptr; + intptr_t callable{}; + + template + static Ret callback_fn(intptr_t callable, Params... params) { + return (*reinterpret_cast(callable))( + std::forward(params)...); + } + + public: + function_ref() = default; + function_ref(std::nullptr_t) {} + + template + function_ref( + // NOLINTNEXTLINE(cppcoreguidelines-missing-std-forward) + Callable&& callable, + std::enable_if_t< + !std::is_same_v, function_ref>>* = + nullptr, + std::enable_if_t, + Ret>>* = nullptr) + : callback(callback_fn>), + callable(reinterpret_cast(&callable)) {} + + Ret operator()(Params... params) const { + return callback(callable, std::forward(params)...); + } + + operator bool() const { + return callback; + } +}; + +} // namespace c10 diff --git a/shared/package-files/2f/2f6e0d3fc750b9c1a62b32bd7c5ca28925f2edd106f3b19acfcecde2fff1b9c1/blob b/shared/package-files/2f/2f6e0d3fc750b9c1a62b32bd7c5ca28925f2edd106f3b19acfcecde2fff1b9c1/blob new file mode 100644 index 0000000000000000000000000000000000000000..ae6b9f994a1355ad3e3989e4d2427235ed8fb665 --- /dev/null +++ b/shared/package-files/2f/2f6e0d3fc750b9c1a62b32bd7c5ca28925f2edd106f3b19acfcecde2fff1b9c1/blob @@ -0,0 +1,53 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::floor_divide(Tensor self, Tensor other) -> Tensor +inline at::Tensor floor_divide(const at::Tensor & self, const at::Tensor & other) { + return at::_ops::floor_divide::call(self, other); +} + +// aten::floor_divide.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & floor_divide_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { + return at::_ops::floor_divide_out::call(self, other, out); +} +// aten::floor_divide.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & floor_divide_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { + return at::_ops::floor_divide_out::call(self, other, out); +} + +// aten::floor_divide.Scalar(Tensor self, Scalar other) -> Tensor +inline at::Tensor floor_divide(const at::Tensor & self, const at::Scalar & other) { + return at::_ops::floor_divide_Scalar::call(self, other); +} + +// aten::floor_divide.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & floor_divide_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other) { + return at::_ops::floor_divide_Scalar_out::call(self, other, out); +} +// aten::floor_divide.Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & floor_divide_outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out) { + return at::_ops::floor_divide_Scalar_out::call(self, other, out); +} + +} diff --git a/shared/package-files/2f/2f6e422ab3ebe9b400f4d4d0a396c31dfb6d9f9592004c25932f72def208360a/blob b/shared/package-files/2f/2f6e422ab3ebe9b400f4d4d0a396c31dfb6d9f9592004c25932f72def208360a/blob new file mode 100644 index 0000000000000000000000000000000000000000..cfc469455a0dba0ede751f8b93c43bcc98a43a8b --- /dev/null +++ b/shared/package-files/2f/2f6e422ab3ebe9b400f4d4d0a396c31dfb6d9f9592004c25932f72def208360a/blob @@ -0,0 +1,63 @@ +import logging +import unittest +from typing import Any, Callable, Generator, Optional, overload + +AsyncHTTPClient: Any +gen: Any +HTTPServer: Any +IOLoop: Any +netutil: Any +SimpleAsyncHTTPClient: Any + +def get_unused_port(): ... +def bind_unused_port(): ... + +class AsyncTestCase(unittest.TestCase): + def __init__(self, *args, **kwargs): ... + io_loop: Any + def setUp(self): ... + def tearDown(self): ... + def get_new_ioloop(self): ... + def run(self, result: Optional[Any] = ...): ... + def stop(self, _arg: Optional[Any] = ..., **kwargs): ... + def wait(self, condition: Optional[Any] = ..., timeout: float = ...): ... + +class AsyncHTTPTestCase(AsyncTestCase): + http_client: Any + http_server: Any + def setUp(self): ... + def get_http_client(self): ... + def get_http_server(self): ... + def get_app(self): ... + def fetch(self, path, **kwargs): ... + def get_httpserver_options(self): ... + def get_http_port(self): ... + def get_protocol(self): ... + def get_url(self, path): ... + def tearDown(self): ... + +class AsyncHTTPSTestCase(AsyncHTTPTestCase): + def get_http_client(self): ... + def get_httpserver_options(self): ... + def get_ssl_options(self): ... + def get_protocol(self): ... + +@overload +def gen_test(*, timeout: Optional[float] = ...) -> Callable[[Callable[..., Generator[Any, Any, Any]]], Callable[..., None]]: ... +@overload +def gen_test(func: Callable[..., Generator[Any, Any, Any]]) -> Callable[..., None]: ... + +class LogTrapTestCase(unittest.TestCase): + def run(self, result: Optional[Any] = ...): ... + +class ExpectLog(logging.Filter): + logger: Any + regex: Any + required: Any + matched: Any + def __init__(self, logger, regex, required: bool = ...): ... + def filter(self, record): ... + def __enter__(self): ... + def __exit__(self, typ, value, tb): ... + +def main(**kwargs): ... diff --git a/shared/package-files/2f/2f6f65a5dcb1f353496326ae1d86f30bfb0d906a82fb50ac97d7c952841bcc01/blob b/shared/package-files/2f/2f6f65a5dcb1f353496326ae1d86f30bfb0d906a82fb50ac97d7c952841bcc01/blob new file mode 100644 index 0000000000000000000000000000000000000000..a04cbedd321675434cf7530ae7b6bb88ec13ad68 --- /dev/null +++ b/shared/package-files/2f/2f6f65a5dcb1f353496326ae1d86f30bfb0d906a82fb50ac97d7c952841bcc01/blob @@ -0,0 +1,91 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::slow_conv_transpose2d.out(Tensor self, Tensor weight, SymInt[2] kernel_size, Tensor? bias=None, SymInt[2] stride=1, SymInt[2] padding=0, SymInt[2] output_padding=0, SymInt[2] dilation=1, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & slow_conv_transpose2d_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0, at::IntArrayRef output_padding=0, at::IntArrayRef dilation=1) { + return at::_ops::slow_conv_transpose2d_out::call(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(dilation), out); +} +namespace symint { + template ::value>> + at::Tensor & slow_conv_transpose2d_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0, at::IntArrayRef output_padding=0, at::IntArrayRef dilation=1) { + return at::_ops::slow_conv_transpose2d_out::call(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(dilation), out); + } +} + +// aten::slow_conv_transpose2d.out(Tensor self, Tensor weight, SymInt[2] kernel_size, Tensor? bias=None, SymInt[2] stride=1, SymInt[2] padding=0, SymInt[2] output_padding=0, SymInt[2] dilation=1, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & slow_conv_transpose2d_outf(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef dilation, at::Tensor & out) { + return at::_ops::slow_conv_transpose2d_out::call(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(dilation), out); +} +namespace symint { + template ::value>> + at::Tensor & slow_conv_transpose2d_outf(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional & bias, at::IntArrayRef stride, at::IntArrayRef padding, at::IntArrayRef output_padding, at::IntArrayRef dilation, at::Tensor & out) { + return at::_ops::slow_conv_transpose2d_out::call(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(dilation), out); + } +} + +// aten::slow_conv_transpose2d.out(Tensor self, Tensor weight, SymInt[2] kernel_size, Tensor? bias=None, SymInt[2] stride=1, SymInt[2] padding=0, SymInt[2] output_padding=0, SymInt[2] dilation=1, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & slow_conv_transpose2d_symint_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional & bias={}, c10::SymIntArrayRef stride=c10::SymInt(1), c10::SymIntArrayRef padding=c10::SymInt(0), c10::SymIntArrayRef output_padding=c10::SymInt(0), c10::SymIntArrayRef dilation=c10::SymInt(1)) { + return at::_ops::slow_conv_transpose2d_out::call(self, weight, kernel_size, bias, stride, padding, output_padding, dilation, out); +} +namespace symint { + template ::value>> + at::Tensor & slow_conv_transpose2d_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional & bias={}, c10::SymIntArrayRef stride=c10::SymInt(1), c10::SymIntArrayRef padding=c10::SymInt(0), c10::SymIntArrayRef output_padding=c10::SymInt(0), c10::SymIntArrayRef dilation=c10::SymInt(1)) { + return at::_ops::slow_conv_transpose2d_out::call(self, weight, kernel_size, bias, stride, padding, output_padding, dilation, out); + } +} + +// aten::slow_conv_transpose2d.out(Tensor self, Tensor weight, SymInt[2] kernel_size, Tensor? bias=None, SymInt[2] stride=1, SymInt[2] padding=0, SymInt[2] output_padding=0, SymInt[2] dilation=1, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & slow_conv_transpose2d_symint_outf(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef dilation, at::Tensor & out) { + return at::_ops::slow_conv_transpose2d_out::call(self, weight, kernel_size, bias, stride, padding, output_padding, dilation, out); +} +namespace symint { + template ::value>> + at::Tensor & slow_conv_transpose2d_outf(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional & bias, c10::SymIntArrayRef stride, c10::SymIntArrayRef padding, c10::SymIntArrayRef output_padding, c10::SymIntArrayRef dilation, at::Tensor & out) { + return at::_ops::slow_conv_transpose2d_out::call(self, weight, kernel_size, bias, stride, padding, output_padding, dilation, out); + } +} + +// aten::slow_conv_transpose2d(Tensor self, Tensor weight, SymInt[2] kernel_size, Tensor? bias=None, SymInt[2] stride=1, SymInt[2] padding=0, SymInt[2] output_padding=0, SymInt[2] dilation=1) -> Tensor +inline at::Tensor slow_conv_transpose2d(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0, at::IntArrayRef output_padding=0, at::IntArrayRef dilation=1) { + return at::_ops::slow_conv_transpose2d::call(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(dilation)); +} +namespace symint { + template ::value>> + at::Tensor slow_conv_transpose2d(const at::Tensor & self, const at::Tensor & weight, at::IntArrayRef kernel_size, const c10::optional & bias={}, at::IntArrayRef stride=1, at::IntArrayRef padding=0, at::IntArrayRef output_padding=0, at::IntArrayRef dilation=1) { + return at::_ops::slow_conv_transpose2d::call(self, weight, c10::fromIntArrayRefSlow(kernel_size), bias, c10::fromIntArrayRefSlow(stride), c10::fromIntArrayRefSlow(padding), c10::fromIntArrayRefSlow(output_padding), c10::fromIntArrayRefSlow(dilation)); + } +} + +// aten::slow_conv_transpose2d(Tensor self, Tensor weight, SymInt[2] kernel_size, Tensor? bias=None, SymInt[2] stride=1, SymInt[2] padding=0, SymInt[2] output_padding=0, SymInt[2] dilation=1) -> Tensor +inline at::Tensor slow_conv_transpose2d_symint(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional & bias={}, c10::SymIntArrayRef stride=c10::SymInt(1), c10::SymIntArrayRef padding=c10::SymInt(0), c10::SymIntArrayRef output_padding=c10::SymInt(0), c10::SymIntArrayRef dilation=c10::SymInt(1)) { + return at::_ops::slow_conv_transpose2d::call(self, weight, kernel_size, bias, stride, padding, output_padding, dilation); +} +namespace symint { + template ::value>> + at::Tensor slow_conv_transpose2d(const at::Tensor & self, const at::Tensor & weight, c10::SymIntArrayRef kernel_size, const c10::optional & bias={}, c10::SymIntArrayRef stride=c10::SymInt(1), c10::SymIntArrayRef padding=c10::SymInt(0), c10::SymIntArrayRef output_padding=c10::SymInt(0), c10::SymIntArrayRef dilation=c10::SymInt(1)) { + return at::_ops::slow_conv_transpose2d::call(self, weight, kernel_size, bias, stride, padding, output_padding, dilation); + } +} + +} diff --git a/shared/package-files/2f/2f73901e3c793013570b8cbecc8956b9136f3c879d82659a2a8b7d9c1996f3b7/blob b/shared/package-files/2f/2f73901e3c793013570b8cbecc8956b9136f3c879d82659a2a8b7d9c1996f3b7/blob new file mode 100644 index 0000000000000000000000000000000000000000..a04219120e2375a087dc2e0aaf8691b252cecf46 --- /dev/null +++ b/shared/package-files/2f/2f73901e3c793013570b8cbecc8956b9136f3c879d82659a2a8b7d9c1996f3b7/blob @@ -0,0 +1,355 @@ +""" +Tests for the as_numba_type() machinery. +""" +import typing as py_typing + + +import unittest + +from contextlib import ExitStack +from llvmlite import ir + +from numba import jit +from numba.core import cgutils, types +from numba.core.datamodel.models import PrimitiveModel +from numba.core.errors import TypingError +from numba.core.extending import (register_model, type_callable, unbox, + NativeValue) +from numba.core.types import Number +from numba.core.typing.typeof import typeof, typeof_impl +from numba.core.typing.asnumbatype import as_numba_type, AsNumbaTypeRegistry +from numba.core.utils import PYVERSION +from numba.experimental.jitclass import jitclass +from numba.tests.support import TestCase + + +class TestAsNumbaType(TestCase): + + int_nb_type = typeof(0) + float_nb_type = typeof(0.0) + complex_nb_type = typeof(complex(0)) + str_nb_type = typeof("numba") + bool_nb_type = typeof(True) + none_nb_type = typeof(None) + + def test_simple_types(self): + self.assertEqual(as_numba_type(int), self.int_nb_type) + self.assertEqual(as_numba_type(float), self.float_nb_type) + self.assertEqual(as_numba_type(complex), self.complex_nb_type) + self.assertEqual(as_numba_type(str), self.str_nb_type) + self.assertEqual(as_numba_type(bool), self.bool_nb_type) + self.assertEqual(as_numba_type(type(None)), self.none_nb_type) + + def test_numba_types(self): + numba_types = [ + types.intp, + types.boolean, + types.ListType(types.float64), + types.DictType( + types.intp, types.Tuple([types.float32, types.float32]) + ), + ] + + for ty in numba_types: + self.assertEqual(as_numba_type(ty), ty) + + def test_single_containers(self): + # Native container types + self.assertEqual( + as_numba_type(list[float]), + types.ListType(self.float_nb_type), + ) + self.assertEqual( + as_numba_type(dict[float, str]), + types.DictType(self.float_nb_type, self.str_nb_type), + ) + self.assertEqual( + as_numba_type(set[complex]), + types.SetType(self.complex_nb_type), + ) + self.assertEqual( + as_numba_type(tuple[float, float]), + types.Tuple([self.float_nb_type, self.float_nb_type]), + ) + self.assertEqual( + as_numba_type(tuple[float, complex]), + types.Tuple([self.float_nb_type, self.complex_nb_type]), + ) + + # Corresponding deprecated aliases + self.assertEqual( + as_numba_type(py_typing.List[float]), + types.ListType(self.float_nb_type), + ) + self.assertEqual( + as_numba_type(py_typing.Dict[float, str]), + types.DictType(self.float_nb_type, self.str_nb_type), + ) + self.assertEqual( + as_numba_type(py_typing.Set[complex]), + types.SetType(self.complex_nb_type), + ) + self.assertEqual( + as_numba_type(py_typing.Tuple[float, float]), + types.Tuple([self.float_nb_type, self.float_nb_type]), + ) + self.assertEqual( + as_numba_type(py_typing.Tuple[float, complex]), + types.Tuple([self.float_nb_type, self.complex_nb_type]), + ) + + def test_optional(self): + self.assertEqual( + as_numba_type(py_typing.Optional[float]), + types.Optional(self.float_nb_type), + ) + self.assertEqual( + as_numba_type(py_typing.Union[str, None]), + types.Optional(self.str_nb_type), + ) + self.assertEqual( + as_numba_type(py_typing.Union[None, bool]), + types.Optional(self.bool_nb_type), + ) + + # Optional[x] is a special case of Union[x, None]. We raise a + # TypingError if the right type is not NoneType. + with self.assertRaises(TypingError) as raises: + as_numba_type(py_typing.Union[int, float]) + self.assertIn("Cannot type Union that is not an Optional", + str(raises.exception)) + + @unittest.skipUnless(PYVERSION >= (3, 14), + "Syntax only supported from 3.14 onwards") + def test_optional_syntax_OR(self): + self.assertEqual(as_numba_type(int | None), + types.Optional(self.int_nb_type)) + + def test_nested_containers(self): + self.assertEqual( + as_numba_type(list[list[int]]), + types.ListType(types.ListType(self.int_nb_type)), + ) + self.assertEqual( + as_numba_type(list[py_typing.List[int]]), + types.ListType(types.ListType(self.int_nb_type)), + ) + self.assertEqual( + as_numba_type(py_typing.List[list[int]]), + types.ListType(types.ListType(self.int_nb_type)), + ) + self.assertEqual( + as_numba_type(py_typing.List[py_typing.List[int]]), + types.ListType(types.ListType(self.int_nb_type)), + ) + self.assertEqual( + as_numba_type(list[dict[float, bool]]), + types.ListType( + types.DictType(self.float_nb_type, self.bool_nb_type) + ), + ) + self.assertEqual( + as_numba_type(py_typing.List[py_typing.Dict[float, bool]]), + types.ListType( + types.DictType(self.float_nb_type, self.bool_nb_type) + ), + ) + self.assertEqual( + as_numba_type( + py_typing.Set[py_typing.Tuple[py_typing.Optional[int], float]]), + types.SetType(types.Tuple( + [types.Optional(self.int_nb_type), self.float_nb_type])), + ) + + def test_jitclass_registers(self): + + @jitclass + class MyInt: + x: int + + def __init__(self, value): + self.x = value + + self.assertEqual(as_numba_type(MyInt), MyInt.class_type.instance_type) + + def test_type_alias(self): + Pair = py_typing.Tuple[int, int] + ListOfPairs = py_typing.List[Pair] + + pair_nb_type = types.Tuple((self.int_nb_type, self.int_nb_type)) + self.assertEqual(as_numba_type(Pair), pair_nb_type) + self.assertEqual( + as_numba_type(ListOfPairs), types.ListType(pair_nb_type) + ) + + def test_overwrite_type(self): + as_numba_type = AsNumbaTypeRegistry() + self.assertEqual(as_numba_type(float), self.float_nb_type) + as_numba_type.register(float, types.float32) + self.assertEqual(as_numba_type(float), types.float32) + self.assertNotEqual(as_numba_type(float), self.float_nb_type) + + def test_any_throws(self): + Any = py_typing.Any + + any_types = [ + py_typing.Optional[Any], + py_typing.List[Any], + py_typing.Set[Any], + py_typing.Dict[float, Any], + py_typing.Dict[Any, float], + py_typing.Tuple[int, Any], + ] + + for bad_py_type in any_types: + with self.assertRaises(TypingError) as raises: + as_numba_type(bad_py_type) + self.assertIn( + "Cannot infer Numba type of Python type", + str(raises.exception), + ) + + def test_non_homogenous_type_throws(self): + # Non-generic types of native container are not strictly homogeneous, + # therefore not supported. Also, tuples with inhomogeneous types are + # excluded. + native_no_args_types = [ + list, + set, + dict, + tuple, + tuple[int, list], + ] + + for bad_py_type in native_no_args_types: + with self.assertRaises(TypingError) as raises: + as_numba_type(bad_py_type) + self.assertIn( + "Cannot infer Numba type of Python type", + str(raises.exception), + ) + + def test_bad_union_throws(self): + bad_unions = [ + py_typing.Union[str, int], + py_typing.Union[int, type(None), py_typing.Tuple[bool, bool]], + ] + + for bad_py_type in bad_unions: + with self.assertRaises(TypingError) as raises: + as_numba_type(bad_py_type) + self.assertIn("Cannot type Union", str(raises.exception)) + + def test_instance_check_usecase(self): + # Demonstrates that registering the type class with as_numba_type + # supports instance checks, at least for those subclasses supported by + # the instance check (e.g. types.Number, etc.). + # + # To set up the test we need quite a lot of extension code to support + # a new type independent of the existing types. + + # The Python class + class bfloat16: + def __init__(self, value): + self._value = value + + # The Numba type class - we use a Number subclass both because it makes + # sense for a new numeric type, and it's one of the types supported by + # instance checks in Numba + class _type_class_bfloat16(Number): + def __init__(self): + self.bitwidth = 16 + super().__init__(name="bfloat16") + + # The Numba type instance + bfloat16_type = _type_class_bfloat16() + + # Register typing of the Python class for use as arguments and + # constants + @typeof_impl.register(bfloat16) + def typeof_bfloat16(val, c): + return bfloat16_type + + # A data model for the bfloat16 class. We don't need much actual + # implementation so it doesn't matter too much what this is; a 16-bit + # integer representation is sufficient. + @register_model(_type_class_bfloat16) + class _model_bfloat16(PrimitiveModel): + def __init__(self, dmm, fe_type): + be_type = ir.IntType(fe_type.bitwidth) + super(_model_bfloat16, self).__init__(dmm, fe_type, be_type) + + # Ideally we pass in a value so we ensure that the instance check is + # working with values dynamically passed in (preventing the whole check + # being potentially optimized into a simple True or False). For this we + # need an unboxing. + @unbox(_type_class_bfloat16) + def unbox_bfloat16(ty, obj, c): + ll_type = c.context.get_argument_type(ty) + val = cgutils.alloca_once(c.builder, ll_type) + is_error_ptr = cgutils.alloca_once_value(c.builder, + cgutils.false_bit) + + with ExitStack() as stack: + value_obj = c.pyapi.object_getattr_string(obj, "_value") + + with cgutils.early_exit_if_null(c.builder, stack, value_obj): + c.builder.store(cgutils.true_bit, is_error_ptr) + + value_native = c.unbox(types.uint16, value_obj) + c.pyapi.decref(value_obj) + + with cgutils.early_exit_if(c.builder, stack, + value_native.is_error): + c.builder.store(cgutils.true_bit, is_error_ptr) + + c.builder.store(value_native.value, val) + + return NativeValue(c.builder.load(val), + is_error=c.builder.load(is_error_ptr)) + + # We never call bfloat16 to construct one inside a jitted function, but + # we need this typing so that the type of the bfloat16 class can be + # determined (it's the argument to the instance check). + @type_callable(bfloat16) + def type_bfloat16_ctor(context): + # Note that the typer is never called in this test, because we + # don't call bfloat16 - only the typing of it as a callable is + # used. + + def typer(value): + if isinstance(value, types.Integer): + return bfloat16_type + + # First we try the instance check without an as_numba_type + # registration, to prove that it is necessary for instance checks to + # work. + @jit + def instancecheck_no_ant_reg(x): + return isinstance(x, bfloat16) + + # A "random" value to test with + x_bf16 = bfloat16(0x4049) # bfloat16(3.14) + + # Ensure the typing fails without the registration + expected_message = r"Cannot infer Numba type of Python type.*bfloat16" + with self.assertRaisesRegex(TypingError, expected_message): + instancecheck_no_ant_reg(x_bf16) + + # Register the typing with as_numba_type so that we can expect instance + # checks to work + as_numba_type.register(bfloat16, bfloat16_type) + + # We define a new function to ensure all registrations are as-required + @jit + def instancecheck(x): + return isinstance(x, bfloat16) + + # The instance check should be True for bfloat16 instances and False + # otherwise. + self.assertTrue(instancecheck(x_bf16)) + self.assertFalse(instancecheck(1)) + + +if __name__ == '__main__': + unittest.main() diff --git a/shared/package-files/2f/2f7427f8348b8d142860fb4323391772a3b49a71488ce974a7afa0033614639e/blob b/shared/package-files/2f/2f7427f8348b8d142860fb4323391772a3b49a71488ce974a7afa0033614639e/blob new file mode 100644 index 0000000000000000000000000000000000000000..7b28cb4881a9af9a9490908733ad9220488ac3de --- /dev/null +++ b/shared/package-files/2f/2f7427f8348b8d142860fb4323391772a3b49a71488ce974a7afa0033614639e/blob @@ -0,0 +1,38 @@ +from charset_normalizer.api import from_bytes +from charset_normalizer.constant import CHARDET_CORRESPONDENCE +from typing import Dict, Optional, Union + + +def detect(byte_str: bytes) -> Dict[str, Optional[Union[str, float]]]: + """ + chardet legacy method + Detect the encoding of the given byte string. It should be mostly backward-compatible. + Encoding name will match Chardet own writing whenever possible. (Not on encoding name unsupported by it) + This function is deprecated and should be used to migrate your project easily, consult the documentation for + further information. Not planned for removal. + + :param byte_str: The byte sequence to examine. + """ + if not isinstance(byte_str, (bytearray, bytes)): + raise TypeError('Expected object of type bytes or bytearray, got: ' + '{0}'.format(type(byte_str))) + + if isinstance(byte_str, bytearray): + byte_str = bytes(byte_str) + + r = from_bytes(byte_str).best() + + encoding = r.encoding if r is not None else None + language = r.language if r is not None and r.language != 'Unknown' else '' + confidence = 1. - r.chaos if r is not None else None + + # Note: CharsetNormalizer does not return 'UTF-8-SIG' as the sig get stripped in the detection/normalization process + # but chardet does return 'utf-8-sig' and it is a valid codec name. + if r is not None and encoding == 'utf_8' and r.bom: + encoding += '_sig' + + return { + 'encoding': encoding if encoding not in CHARDET_CORRESPONDENCE else CHARDET_CORRESPONDENCE[encoding], + 'language': language, + 'confidence': confidence + } diff --git a/shared/package-files/2f/2f77c48c04cfb00cb76baceb75025a5d7690ec5bd1d8b39e88f24c8c6364c0a4/blob b/shared/package-files/2f/2f77c48c04cfb00cb76baceb75025a5d7690ec5bd1d8b39e88f24c8c6364c0a4/blob new file mode 100644 index 0000000000000000000000000000000000000000..4dd3eda8c995ce022e9d46b907323e79bcd679f8 --- /dev/null +++ b/shared/package-files/2f/2f77c48c04cfb00cb76baceb75025a5d7690ec5bd1d8b39e88f24c8c6364c0a4/blob @@ -0,0 +1,18 @@ +from pandas import Index +import pandas._testing as tm +from pandas.core.construction import extract_array + + +def test_extract_array_rangeindex(): + ri = Index(range(5)) + + expected = ri._values + res = extract_array(ri, extract_numpy=True, extract_range=True) + tm.assert_numpy_array_equal(res, expected) + res = extract_array(ri, extract_numpy=False, extract_range=True) + tm.assert_numpy_array_equal(res, expected) + + res = extract_array(ri, extract_numpy=True, extract_range=False) + tm.assert_index_equal(res, ri) + res = extract_array(ri, extract_numpy=False, extract_range=False) + tm.assert_index_equal(res, ri) diff --git a/shared/package-files/2f/2f78bbcbca0c663f15bb1744612a35e97581a1063b99c05b6d560bc417976aa2/blob b/shared/package-files/2f/2f78bbcbca0c663f15bb1744612a35e97581a1063b99c05b6d560bc417976aa2/blob new file mode 100644 index 0000000000000000000000000000000000000000..75def00259baffd04c6ba9a6cf97c78031c0300f --- /dev/null +++ b/shared/package-files/2f/2f78bbcbca0c663f15bb1744612a35e97581a1063b99c05b6d560bc417976aa2/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2f78bbcbca0c663f15bb1744612a35e97581a1063b99c05b6d560bc417976aa2 +size 233417 diff --git a/shared/package-files/2f/2f78f2961eda0d1fbe672fd4e14692d4c36f2a6a6a570e634cb347bec89c7e35/blob b/shared/package-files/2f/2f78f2961eda0d1fbe672fd4e14692d4c36f2a6a6a570e634cb347bec89c7e35/blob new file mode 100644 index 0000000000000000000000000000000000000000..dedd833ed1e4d9fb3fc179917191587be4cfbfd1 --- /dev/null +++ b/shared/package-files/2f/2f78f2961eda0d1fbe672fd4e14692d4c36f2a6a6a570e634cb347bec89c7e35/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2f78f2961eda0d1fbe672fd4e14692d4c36f2a6a6a570e634cb347bec89c7e35 +size 440800 diff --git a/shared/package-files/2f/2f79829d83d3a7302035f79d56eabd83bc4f59b7347353e8b7de24f6367d3692/blob b/shared/package-files/2f/2f79829d83d3a7302035f79d56eabd83bc4f59b7347353e8b7de24f6367d3692/blob new file mode 100644 index 0000000000000000000000000000000000000000..e44bda3d58ab92e614905f6f20f102242d6d6b0c --- /dev/null +++ b/shared/package-files/2f/2f79829d83d3a7302035f79d56eabd83bc4f59b7347353e8b7de24f6367d3692/blob @@ -0,0 +1,9 @@ + +import collections +import numpy as np + + +def test_no_duplicates_in_np__all__(): + # Regression test for gh-10198. + dups = {k: v for k, v in collections.Counter(np.__all__).items() if v > 1} + assert len(dups) == 0 diff --git a/shared/package-files/2f/2f7b7cff020ea2ff1e9bebd958e71b91db2bc1ee3737afe0a8d879a47ed63dde/blob b/shared/package-files/2f/2f7b7cff020ea2ff1e9bebd958e71b91db2bc1ee3737afe0a8d879a47ed63dde/blob new file mode 100644 index 0000000000000000000000000000000000000000..a103ca11356606402c03b320a4fcdb8635051623 --- /dev/null +++ b/shared/package-files/2f/2f7b7cff020ea2ff1e9bebd958e71b91db2bc1ee3737afe0a8d879a47ed63dde/blob @@ -0,0 +1,147 @@ +######################## BEGIN LICENSE BLOCK ######################## +# The Original Code is Mozilla Universal charset detector code. +# +# The Initial Developer of the Original Code is +# Netscape Communications Corporation. +# Portions created by the Initial Developer are Copyright (C) 2001 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# Mark Pilgrim - port to Python +# Shy Shalom - original C code +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA +# 02110-1301 USA +######################### END LICENSE BLOCK ######################### + +import logging +import re +from typing import Optional, Union + +from .enums import LanguageFilter, ProbingState + +INTERNATIONAL_WORDS_PATTERN = re.compile( + b"[a-zA-Z]*[\x80-\xFF]+[a-zA-Z]*[^a-zA-Z\x80-\xFF]?" +) + + +class CharSetProber: + + SHORTCUT_THRESHOLD = 0.95 + + def __init__(self, lang_filter: LanguageFilter = LanguageFilter.NONE) -> None: + self._state = ProbingState.DETECTING + self.active = True + self.lang_filter = lang_filter + self.logger = logging.getLogger(__name__) + + def reset(self) -> None: + self._state = ProbingState.DETECTING + + @property + def charset_name(self) -> Optional[str]: + return None + + @property + def language(self) -> Optional[str]: + raise NotImplementedError + + def feed(self, byte_str: Union[bytes, bytearray]) -> ProbingState: + raise NotImplementedError + + @property + def state(self) -> ProbingState: + return self._state + + def get_confidence(self) -> float: + return 0.0 + + @staticmethod + def filter_high_byte_only(buf: Union[bytes, bytearray]) -> bytes: + buf = re.sub(b"([\x00-\x7F])+", b" ", buf) + return buf + + @staticmethod + def filter_international_words(buf: Union[bytes, bytearray]) -> bytearray: + """ + We define three types of bytes: + alphabet: english alphabets [a-zA-Z] + international: international characters [\x80-\xFF] + marker: everything else [^a-zA-Z\x80-\xFF] + The input buffer can be thought to contain a series of words delimited + by markers. This function works to filter all words that contain at + least one international character. All contiguous sequences of markers + are replaced by a single space ascii character. + This filter applies to all scripts which do not use English characters. + """ + filtered = bytearray() + + # This regex expression filters out only words that have at-least one + # international character. The word may include one marker character at + # the end. + words = INTERNATIONAL_WORDS_PATTERN.findall(buf) + + for word in words: + filtered.extend(word[:-1]) + + # If the last character in the word is a marker, replace it with a + # space as markers shouldn't affect our analysis (they are used + # similarly across all languages and may thus have similar + # frequencies). + last_char = word[-1:] + if not last_char.isalpha() and last_char < b"\x80": + last_char = b" " + filtered.extend(last_char) + + return filtered + + @staticmethod + def remove_xml_tags(buf: Union[bytes, bytearray]) -> bytes: + """ + Returns a copy of ``buf`` that retains only the sequences of English + alphabet and high byte characters that are not between <> characters. + This filter can be applied to all scripts which contain both English + characters and extended ASCII characters, but is currently only used by + ``Latin1Prober``. + """ + filtered = bytearray() + in_tag = False + prev = 0 + buf = memoryview(buf).cast("c") + + for curr, buf_char in enumerate(buf): + # Check if we're coming out of or entering an XML tag + + # https://github.com/python/typeshed/issues/8182 + if buf_char == b">": # type: ignore[comparison-overlap] + prev = curr + 1 + in_tag = False + # https://github.com/python/typeshed/issues/8182 + elif buf_char == b"<": # type: ignore[comparison-overlap] + if curr > prev and not in_tag: + # Keep everything after last non-extended-ASCII, + # non-alphabetic character + filtered.extend(buf[prev:curr]) + # Output a space to delimit stretch we kept + filtered.extend(b" ") + in_tag = True + + # If we're not in a tag... + if not in_tag: + # Keep everything after last non-extended-ASCII, non-alphabetic + # character + filtered.extend(buf[prev:]) + + return filtered diff --git a/shared/package-files/2f/2f7c604bfe005884efadf2d425d719c569998a88ab2fb09089bb3db6f6386bbf/blob b/shared/package-files/2f/2f7c604bfe005884efadf2d425d719c569998a88ab2fb09089bb3db6f6386bbf/blob new file mode 100644 index 0000000000000000000000000000000000000000..4465aa774fce171038b5677c963def97ae61a5bf --- /dev/null +++ b/shared/package-files/2f/2f7c604bfe005884efadf2d425d719c569998a88ab2fb09089bb3db6f6386bbf/blob @@ -0,0 +1,28 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor replication_pad2d(const at::Tensor & self, at::IntArrayRef padding); +TORCH_API at::Tensor replication_pad2d_symint(const at::Tensor & self, c10::SymIntArrayRef padding); +TORCH_API at::Tensor & replication_pad2d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef padding); +TORCH_API at::Tensor & replication_pad2d_outf(const at::Tensor & self, at::IntArrayRef padding, at::Tensor & out); +TORCH_API at::Tensor & replication_pad2d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef padding); +TORCH_API at::Tensor & replication_pad2d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef padding, at::Tensor & out); + +} // namespace cuda +} // namespace at diff --git a/shared/package-files/2f/2f7dadc0f0d23cd11bf4829de3df119a7d995e27787563b0867a31732d793640/blob b/shared/package-files/2f/2f7dadc0f0d23cd11bf4829de3df119a7d995e27787563b0867a31732d793640/blob new file mode 100644 index 0000000000000000000000000000000000000000..94607915951891f245c7c6e0d26051fa42b44833 Binary files /dev/null and b/shared/package-files/2f/2f7dadc0f0d23cd11bf4829de3df119a7d995e27787563b0867a31732d793640/blob differ diff --git a/shared/package-files/2f/2f7eda26b57b6fe18f50bc498f69cdc760337dec5c39b44cb6e6078a56799ebb/blob b/shared/package-files/2f/2f7eda26b57b6fe18f50bc498f69cdc760337dec5c39b44cb6e6078a56799ebb/blob new file mode 100644 index 0000000000000000000000000000000000000000..b9e09702e2df01f182eb44c9473fa14d879ad422 --- /dev/null +++ b/shared/package-files/2f/2f7eda26b57b6fe18f50bc498f69cdc760337dec5c39b44cb6e6078a56799ebb/blob @@ -0,0 +1,11 @@ +prefix=/opt/conda +exec_prefix=${prefix} +libdir=${exec_prefix}/lib +includedir=${prefix}/include + +Name: kadm-server +Description: Kerberos administration server library +Version: 1.20.1 +Requires.private: kdb mit-krb5-gssapi +Cflags: -I${includedir} +Libs: -L${libdir} -lkadm5srv_mit diff --git a/shared/package-files/2f/2f7f532dd1178fcd1a8c47d94310d342e06f3280c6e0f627479f8e58541fcdd1/blob b/shared/package-files/2f/2f7f532dd1178fcd1a8c47d94310d342e06f3280c6e0f627479f8e58541fcdd1/blob new file mode 100644 index 0000000000000000000000000000000000000000..56abdbe006e347e85dcef7a28420eb67eb887200 --- /dev/null +++ b/shared/package-files/2f/2f7f532dd1178fcd1a8c47d94310d342e06f3280c6e0f627479f8e58541fcdd1/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::linalg_matmul(Tensor self, Tensor other) -> Tensor +inline at::Tensor linalg_matmul(const at::Tensor & self, const at::Tensor & other) { + return at::_ops::linalg_matmul::call(self, other); +} + +// aten::linalg_matmul.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & linalg_matmul_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other) { + return at::_ops::linalg_matmul_out::call(self, other, out); +} +// aten::linalg_matmul.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & linalg_matmul_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out) { + return at::_ops::linalg_matmul_out::call(self, other, out); +} + +} diff --git a/shared/package-files/2f/2f80d873a07240c0f0246173242dd885f4ab564e5ab96ee97f8418a49e7163bc/blob b/shared/package-files/2f/2f80d873a07240c0f0246173242dd885f4ab564e5ab96ee97f8418a49e7163bc/blob new file mode 100644 index 0000000000000000000000000000000000000000..973ca329586f3e904f9377c44022c266f81c805c --- /dev/null +++ b/shared/package-files/2f/2f80d873a07240c0f0246173242dd885f4ab564e5ab96ee97f8418a49e7163bc/blob @@ -0,0 +1,67 @@ +from sympy.sets.ordinals import Ordinal, OmegaPower, ord0, omega +from sympy.testing.pytest import raises + +def test_string_ordinals(): + assert str(omega) == 'w' + assert str(Ordinal(OmegaPower(5, 3), OmegaPower(3, 2))) == 'w**5*3 + w**3*2' + assert str(Ordinal(OmegaPower(5, 3), OmegaPower(0, 5))) == 'w**5*3 + 5' + assert str(Ordinal(OmegaPower(1, 3), OmegaPower(0, 5))) == 'w*3 + 5' + assert str(Ordinal(OmegaPower(omega + 1, 1), OmegaPower(3, 2))) == 'w**(w + 1) + w**3*2' + +def test_addition_with_integers(): + assert 3 + Ordinal(OmegaPower(5, 3)) == Ordinal(OmegaPower(5, 3)) + assert Ordinal(OmegaPower(5, 3))+3 == Ordinal(OmegaPower(5, 3), OmegaPower(0, 3)) + assert Ordinal(OmegaPower(5, 3), OmegaPower(0, 2))+3 == \ + Ordinal(OmegaPower(5, 3), OmegaPower(0, 5)) + + +def test_addition_with_ordinals(): + assert Ordinal(OmegaPower(5, 3), OmegaPower(3, 2)) + Ordinal(OmegaPower(3, 3)) == \ + Ordinal(OmegaPower(5, 3), OmegaPower(3, 5)) + assert Ordinal(OmegaPower(5, 3), OmegaPower(3, 2)) + Ordinal(OmegaPower(4, 2)) == \ + Ordinal(OmegaPower(5, 3), OmegaPower(4, 2)) + assert Ordinal(OmegaPower(omega, 2), OmegaPower(3, 2)) + Ordinal(OmegaPower(4, 2)) == \ + Ordinal(OmegaPower(omega, 2), OmegaPower(4, 2)) + +def test_comparison(): + assert Ordinal(OmegaPower(5, 3)) > Ordinal(OmegaPower(4, 3), OmegaPower(2, 1)) + assert Ordinal(OmegaPower(5, 3), OmegaPower(3, 2)) < Ordinal(OmegaPower(5, 4)) + assert Ordinal(OmegaPower(5, 4)) < Ordinal(OmegaPower(5, 5), OmegaPower(4, 1)) + + assert Ordinal(OmegaPower(5, 3), OmegaPower(3, 2)) == \ + Ordinal(OmegaPower(5, 3), OmegaPower(3, 2)) + assert not Ordinal(OmegaPower(5, 3), OmegaPower(3, 2)) == Ordinal(OmegaPower(5, 3)) + assert Ordinal(OmegaPower(omega, 3)) > Ordinal(OmegaPower(5, 3)) + +def test_multiplication_with_integers(): + w = omega + assert 3*w == w + assert w*9 == Ordinal(OmegaPower(1, 9)) + +def test_multiplication(): + w = omega + assert w*(w + 1) == w*w + w + assert (w + 1)*(w + 1) == w*w + w + 1 + assert w*1 == w + assert 1*w == w + assert w*ord0 == ord0 + assert ord0*w == ord0 + assert w**w == w * w**w + assert (w**w)*w*w == w**(w + 2) + +def test_exponentiation(): + w = omega + assert w**2 == w*w + assert w**3 == w*w*w + assert w**(w + 1) == Ordinal(OmegaPower(omega + 1, 1)) + assert (w**w)*(w**w) == w**(w*2) + +def test_comapre_not_instance(): + w = OmegaPower(omega + 1, 1) + assert(not (w == None)) + assert(not (w < 5)) + raises(TypeError, lambda: w < 6.66) + +def test_is_successort(): + w = Ordinal(OmegaPower(5, 1)) + assert not w.is_successor_ordinal diff --git a/shared/package-files/2f/2f812a0550716b88930174a8ca245698427cd286680c0968558ae269ab52440d/blob b/shared/package-files/2f/2f812a0550716b88930174a8ca245698427cd286680c0968558ae269ab52440d/blob new file mode 100644 index 0000000000000000000000000000000000000000..6eb96910188fb832b5ed5d668f3ba4fad9aff92d --- /dev/null +++ b/shared/package-files/2f/2f812a0550716b88930174a8ca245698427cd286680c0968558ae269ab52440d/blob @@ -0,0 +1,241 @@ + +# -*- tcl -*- +# ### ### ### ######### ######### ######### +## Overview + +# Higher-level commands which invoke the functionality of this package +# for an arbitrary tcl shell (tclsh, wish, ...). This is required by a +# repository as while the tcl shell executing packages uses the same +# platform in general as a repository application there can be +# differences in detail (i.e. 32/64 bit builds). + +# ### ### ### ######### ######### ######### +## Requirements + +package require platform +namespace eval ::platform::shell {} + +# ### ### ### ######### ######### ######### +## Implementation + +# -- platform::shell::generic + +proc ::platform::shell::generic {shell} { + # Argument is the path to a tcl shell. + + CHECK $shell + LOCATE base out + + set code {} + # Forget any pre-existing platform package, it might be in + # conflict with this one. + lappend code {package forget platform} + # Inject our platform package + lappend code [list source $base] + # Query and print the architecture + lappend code {puts [platform::generic]} + # And done + lappend code {exit 0} + + set arch [RUN $shell [join $code \n]] + + if {$out} {file delete -force $base} + return $arch +} + +# -- platform::shell::identify + +proc ::platform::shell::identify {shell} { + # Argument is the path to a tcl shell. + + CHECK $shell + LOCATE base out + + set code {} + # Forget any pre-existing platform package, it might be in + # conflict with this one. + lappend code {package forget platform} + # Inject our platform package + lappend code [list source $base] + # Query and print the architecture + lappend code {puts [platform::identify]} + # And done + lappend code {exit 0} + + set arch [RUN $shell [join $code \n]] + + if {$out} {file delete -force $base} + return $arch +} + +# -- platform::shell::platform + +proc ::platform::shell::platform {shell} { + # Argument is the path to a tcl shell. + + CHECK $shell + + set code {} + lappend code {puts $tcl_platform(platform)} + lappend code {exit 0} + + return [RUN $shell [join $code \n]] +} + +# ### ### ### ######### ######### ######### +## Internal helper commands. + +proc ::platform::shell::CHECK {shell} { + if {![file exists $shell]} { + return -code error "Shell \"$shell\" does not exist" + } + if {![file executable $shell]} { + return -code error "Shell \"$shell\" is not executable (permissions)" + } + return +} + +proc ::platform::shell::LOCATE {bv ov} { + upvar 1 $bv base $ov out + + # Locate the platform package for injection into the specified + # shell. We are using package management to find it, whereever it + # is, instead of using hardwired relative paths. This allows us to + # install the two packages as TMs without breaking the code + # here. If the found package is wrapped we copy the code somewhere + # where the spawned shell will be able to read it. + + # This code is brittle, it needs has to adapt to whatever changes + # are made to the TM code, i.e. the provide statement generated by + # tm.tcl + + set pl [package ifneeded platform [package require platform]] + set base [lindex $pl end] + + set out 0 + if {[lindex [file system $base]] ne "native"} { + set temp [TEMP] + file copy -force $base $temp + set base $temp + set out 1 + } + return +} + +proc ::platform::shell::RUN {shell code} { + set c [TEMP] + set cc [open $c w] + puts $cc $code + close $cc + + set e [TEMP] + + set code [catch { + exec $shell $c 2> $e + } res] + + file delete $c + + if {$code} { + append res \n[read [set chan [open $e r]]][close $chan] + file delete $e + return -code error "Shell \"$shell\" is not executable ($res)" + } + + file delete $e + return $res +} + +proc ::platform::shell::TEMP {} { + set prefix platform + + # This code is copied out of Tcllib's fileutil package. + # (TempFile/tempfile) + + set tmpdir [DIR] + + set chars "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" + set nrand_chars 10 + set maxtries 10 + set access [list RDWR CREAT EXCL TRUNC] + set permission 0600 + set channel "" + set checked_dir_writable 0 + set mypid [pid] + for {set i 0} {$i < $maxtries} {incr i} { + set newname $prefix + for {set j 0} {$j < $nrand_chars} {incr j} { + append newname [string index $chars \ + [expr {int(rand()*62)}]] + } + set newname [file join $tmpdir $newname] + if {[file exists $newname]} { + after 1 + } else { + if {[catch {open $newname $access $permission} channel]} { + if {!$checked_dir_writable} { + set dirname [file dirname $newname] + if {![file writable $dirname]} { + return -code error "Directory $dirname is not writable" + } + set checked_dir_writable 1 + } + } else { + # Success + close $channel + return [file normalize $newname] + } + } + } + if {$channel ne ""} { + return -code error "Failed to open a temporary file: $channel" + } else { + return -code error "Failed to find an unused temporary file name" + } +} + +proc ::platform::shell::DIR {} { + # This code is copied out of Tcllib's fileutil package. + # (TempDir/tempdir) + + global tcl_platform env + + set attempdirs [list] + + foreach tmp {TMPDIR TEMP TMP} { + if { [info exists env($tmp)] } { + lappend attempdirs $env($tmp) + } + } + + switch $tcl_platform(platform) { + windows { + lappend attempdirs "C:\\TEMP" "C:\\TMP" "\\TEMP" "\\TMP" + } + macintosh { + set tmpdir $env(TRASH_FOLDER) ;# a better place? + } + default { + lappend attempdirs \ + [file join / tmp] \ + [file join / var tmp] \ + [file join / usr tmp] + } + } + + lappend attempdirs [pwd] + + foreach tmp $attempdirs { + if { [file isdirectory $tmp] && [file writable $tmp] } { + return [file normalize $tmp] + } + } + + # Fail if nothing worked. + return -code error "Unable to determine a proper directory for temporary files" +} + +# ### ### ### ######### ######### ######### +## Ready + +package provide platform::shell 1.1.4 diff --git a/shared/package-files/2f/2f84ea0d0e55dfc231a9e4a351e6034c21fd9e9efd3f84958c10ea43fb7b1a99/blob b/shared/package-files/2f/2f84ea0d0e55dfc231a9e4a351e6034c21fd9e9efd3f84958c10ea43fb7b1a99/blob new file mode 100644 index 0000000000000000000000000000000000000000..e6c931930da0a72bfc2f640e5727d33d51fd7158 --- /dev/null +++ b/shared/package-files/2f/2f84ea0d0e55dfc231a9e4a351e6034c21fd9e9efd3f84958c10ea43fb7b1a99/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2f84ea0d0e55dfc231a9e4a351e6034c21fd9e9efd3f84958c10ea43fb7b1a99 +size 454170 diff --git a/shared/package-files/2f/2f8668e06588315cc7a4e437434f7e187ff4231b607b901347a90880c6188e87/blob b/shared/package-files/2f/2f8668e06588315cc7a4e437434f7e187ff4231b607b901347a90880c6188e87/blob new file mode 100644 index 0000000000000000000000000000000000000000..63f9b2176dddde899a2b199eec53abefd7c9621c --- /dev/null +++ b/shared/package-files/2f/2f8668e06588315cc7a4e437434f7e187ff4231b607b901347a90880c6188e87/blob @@ -0,0 +1,918 @@ +from itertools import permutations +import re + +import numpy as np +import pytest + +import pandas as pd +from pandas import ( + Index, + Interval, + IntervalIndex, + Timedelta, + Timestamp, + date_range, + interval_range, + isna, + notna, + timedelta_range, +) +import pandas._testing as tm +import pandas.core.common as com + + +@pytest.fixture(params=[None, "foo"]) +def name(request): + return request.param + + +class TestIntervalIndex: + index = IntervalIndex.from_arrays([0, 1], [1, 2]) + + def create_index(self, closed="right"): + return IntervalIndex.from_breaks(range(11), closed=closed) + + def create_index_with_nan(self, closed="right"): + mask = [True, False] + [True] * 8 + return IntervalIndex.from_arrays( + np.where(mask, np.arange(10), np.nan), + np.where(mask, np.arange(1, 11), np.nan), + closed=closed, + ) + + def test_properties(self, closed): + index = self.create_index(closed=closed) + assert len(index) == 10 + assert index.size == 10 + assert index.shape == (10,) + + tm.assert_index_equal(index.left, Index(np.arange(10, dtype=np.int64))) + tm.assert_index_equal(index.right, Index(np.arange(1, 11, dtype=np.int64))) + tm.assert_index_equal(index.mid, Index(np.arange(0.5, 10.5, dtype=np.float64))) + + assert index.closed == closed + + ivs = [ + Interval(left, right, closed) + for left, right in zip(range(10), range(1, 11)) + ] + expected = np.array(ivs, dtype=object) + tm.assert_numpy_array_equal(np.asarray(index), expected) + + # with nans + index = self.create_index_with_nan(closed=closed) + assert len(index) == 10 + assert index.size == 10 + assert index.shape == (10,) + + expected_left = Index([0, np.nan, 2, 3, 4, 5, 6, 7, 8, 9]) + expected_right = expected_left + 1 + expected_mid = expected_left + 0.5 + tm.assert_index_equal(index.left, expected_left) + tm.assert_index_equal(index.right, expected_right) + tm.assert_index_equal(index.mid, expected_mid) + + assert index.closed == closed + + ivs = [ + Interval(left, right, closed) if notna(left) else np.nan + for left, right in zip(expected_left, expected_right) + ] + expected = np.array(ivs, dtype=object) + tm.assert_numpy_array_equal(np.asarray(index), expected) + + @pytest.mark.parametrize( + "breaks", + [ + [1, 1, 2, 5, 15, 53, 217, 1014, 5335, 31240, 201608], + [-np.inf, -100, -10, 0.5, 1, 1.5, 3.8, 101, 202, np.inf], + date_range("2017-01-01", "2017-01-04"), + pytest.param( + date_range("2017-01-01", "2017-01-04", unit="s"), + marks=pytest.mark.xfail(reason="mismatched result unit"), + ), + pd.to_timedelta(["1ns", "2ms", "3s", "4min", "5h", "6D"]), + ], + ) + def test_length(self, closed, breaks): + # GH 18789 + index = IntervalIndex.from_breaks(breaks, closed=closed) + result = index.length + expected = Index(iv.length for iv in index) + tm.assert_index_equal(result, expected) + + # with NA + index = index.insert(1, np.nan) + result = index.length + expected = Index(iv.length if notna(iv) else iv for iv in index) + tm.assert_index_equal(result, expected) + + def test_with_nans(self, closed): + index = self.create_index(closed=closed) + assert index.hasnans is False + + result = index.isna() + expected = np.zeros(len(index), dtype=bool) + tm.assert_numpy_array_equal(result, expected) + + result = index.notna() + expected = np.ones(len(index), dtype=bool) + tm.assert_numpy_array_equal(result, expected) + + index = self.create_index_with_nan(closed=closed) + assert index.hasnans is True + + result = index.isna() + expected = np.array([False, True] + [False] * (len(index) - 2)) + tm.assert_numpy_array_equal(result, expected) + + result = index.notna() + expected = np.array([True, False] + [True] * (len(index) - 2)) + tm.assert_numpy_array_equal(result, expected) + + def test_copy(self, closed): + expected = self.create_index(closed=closed) + + result = expected.copy() + assert result.equals(expected) + + result = expected.copy(deep=True) + assert result.equals(expected) + assert result.left is not expected.left + + def test_ensure_copied_data(self, closed): + # exercise the copy flag in the constructor + + # not copying + index = self.create_index(closed=closed) + result = IntervalIndex(index, copy=False) + tm.assert_numpy_array_equal( + index.left.values, result.left.values, check_same="same" + ) + tm.assert_numpy_array_equal( + index.right.values, result.right.values, check_same="same" + ) + + # by-definition make a copy + result = IntervalIndex(np.array(index), copy=False) + tm.assert_numpy_array_equal( + index.left.values, result.left.values, check_same="copy" + ) + tm.assert_numpy_array_equal( + index.right.values, result.right.values, check_same="copy" + ) + + def test_delete(self, closed): + breaks = np.arange(1, 11, dtype=np.int64) + expected = IntervalIndex.from_breaks(breaks, closed=closed) + result = self.create_index(closed=closed).delete(0) + tm.assert_index_equal(result, expected) + + @pytest.mark.parametrize( + "data", + [ + interval_range(0, periods=10, closed="neither"), + interval_range(1.7, periods=8, freq=2.5, closed="both"), + interval_range(Timestamp("20170101"), periods=12, closed="left"), + interval_range(Timedelta("1 day"), periods=6, closed="right"), + ], + ) + def test_insert(self, data): + item = data[0] + idx_item = IntervalIndex([item]) + + # start + expected = idx_item.append(data) + result = data.insert(0, item) + tm.assert_index_equal(result, expected) + + # end + expected = data.append(idx_item) + result = data.insert(len(data), item) + tm.assert_index_equal(result, expected) + + # mid + expected = data[:3].append(idx_item).append(data[3:]) + result = data.insert(3, item) + tm.assert_index_equal(result, expected) + + # invalid type + res = data.insert(1, "foo") + expected = data.astype(object).insert(1, "foo") + tm.assert_index_equal(res, expected) + + msg = "can only insert Interval objects and NA into an IntervalArray" + with pytest.raises(TypeError, match=msg): + data._data.insert(1, "foo") + + # invalid closed + msg = "'value.closed' is 'left', expected 'right'." + for closed in {"left", "right", "both", "neither"} - {item.closed}: + msg = f"'value.closed' is '{closed}', expected '{item.closed}'." + bad_item = Interval(item.left, item.right, closed=closed) + res = data.insert(1, bad_item) + expected = data.astype(object).insert(1, bad_item) + tm.assert_index_equal(res, expected) + with pytest.raises(ValueError, match=msg): + data._data.insert(1, bad_item) + + # GH 18295 (test missing) + na_idx = IntervalIndex([np.nan], closed=data.closed) + for na in [np.nan, None, pd.NA]: + expected = data[:1].append(na_idx).append(data[1:]) + result = data.insert(1, na) + tm.assert_index_equal(result, expected) + + if data.left.dtype.kind not in ["m", "M"]: + # trying to insert pd.NaT into a numeric-dtyped Index should cast + expected = data.astype(object).insert(1, pd.NaT) + + msg = "can only insert Interval objects and NA into an IntervalArray" + with pytest.raises(TypeError, match=msg): + data._data.insert(1, pd.NaT) + + result = data.insert(1, pd.NaT) + tm.assert_index_equal(result, expected) + + def test_is_unique_interval(self, closed): + """ + Interval specific tests for is_unique in addition to base class tests + """ + # unique overlapping - distinct endpoints + idx = IntervalIndex.from_tuples([(0, 1), (0.5, 1.5)], closed=closed) + assert idx.is_unique is True + + # unique overlapping - shared endpoints + idx = IntervalIndex.from_tuples([(1, 2), (1, 3), (2, 3)], closed=closed) + assert idx.is_unique is True + + # unique nested + idx = IntervalIndex.from_tuples([(-1, 1), (-2, 2)], closed=closed) + assert idx.is_unique is True + + # unique NaN + idx = IntervalIndex.from_tuples([(np.nan, np.nan)], closed=closed) + assert idx.is_unique is True + + # non-unique NaN + idx = IntervalIndex.from_tuples( + [(np.nan, np.nan), (np.nan, np.nan)], closed=closed + ) + assert idx.is_unique is False + + def test_monotonic(self, closed): + # increasing non-overlapping + idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (4, 5)], closed=closed) + assert idx.is_monotonic_increasing is True + assert idx._is_strictly_monotonic_increasing is True + assert idx.is_monotonic_decreasing is False + assert idx._is_strictly_monotonic_decreasing is False + + # decreasing non-overlapping + idx = IntervalIndex.from_tuples([(4, 5), (2, 3), (1, 2)], closed=closed) + assert idx.is_monotonic_increasing is False + assert idx._is_strictly_monotonic_increasing is False + assert idx.is_monotonic_decreasing is True + assert idx._is_strictly_monotonic_decreasing is True + + # unordered non-overlapping + idx = IntervalIndex.from_tuples([(0, 1), (4, 5), (2, 3)], closed=closed) + assert idx.is_monotonic_increasing is False + assert idx._is_strictly_monotonic_increasing is False + assert idx.is_monotonic_decreasing is False + assert idx._is_strictly_monotonic_decreasing is False + + # increasing overlapping + idx = IntervalIndex.from_tuples([(0, 2), (0.5, 2.5), (1, 3)], closed=closed) + assert idx.is_monotonic_increasing is True + assert idx._is_strictly_monotonic_increasing is True + assert idx.is_monotonic_decreasing is False + assert idx._is_strictly_monotonic_decreasing is False + + # decreasing overlapping + idx = IntervalIndex.from_tuples([(1, 3), (0.5, 2.5), (0, 2)], closed=closed) + assert idx.is_monotonic_increasing is False + assert idx._is_strictly_monotonic_increasing is False + assert idx.is_monotonic_decreasing is True + assert idx._is_strictly_monotonic_decreasing is True + + # unordered overlapping + idx = IntervalIndex.from_tuples([(0.5, 2.5), (0, 2), (1, 3)], closed=closed) + assert idx.is_monotonic_increasing is False + assert idx._is_strictly_monotonic_increasing is False + assert idx.is_monotonic_decreasing is False + assert idx._is_strictly_monotonic_decreasing is False + + # increasing overlapping shared endpoints + idx = IntervalIndex.from_tuples([(1, 2), (1, 3), (2, 3)], closed=closed) + assert idx.is_monotonic_increasing is True + assert idx._is_strictly_monotonic_increasing is True + assert idx.is_monotonic_decreasing is False + assert idx._is_strictly_monotonic_decreasing is False + + # decreasing overlapping shared endpoints + idx = IntervalIndex.from_tuples([(2, 3), (1, 3), (1, 2)], closed=closed) + assert idx.is_monotonic_increasing is False + assert idx._is_strictly_monotonic_increasing is False + assert idx.is_monotonic_decreasing is True + assert idx._is_strictly_monotonic_decreasing is True + + # stationary + idx = IntervalIndex.from_tuples([(0, 1), (0, 1)], closed=closed) + assert idx.is_monotonic_increasing is True + assert idx._is_strictly_monotonic_increasing is False + assert idx.is_monotonic_decreasing is True + assert idx._is_strictly_monotonic_decreasing is False + + # empty + idx = IntervalIndex([], closed=closed) + assert idx.is_monotonic_increasing is True + assert idx._is_strictly_monotonic_increasing is True + assert idx.is_monotonic_decreasing is True + assert idx._is_strictly_monotonic_decreasing is True + + def test_is_monotonic_with_nans(self): + # GH#41831 + index = IntervalIndex([np.nan, np.nan]) + + assert not index.is_monotonic_increasing + assert not index._is_strictly_monotonic_increasing + assert not index.is_monotonic_increasing + assert not index._is_strictly_monotonic_decreasing + assert not index.is_monotonic_decreasing + + @pytest.mark.parametrize( + "breaks", + [ + date_range("20180101", periods=4), + date_range("20180101", periods=4, tz="US/Eastern"), + timedelta_range("0 days", periods=4), + ], + ids=lambda x: str(x.dtype), + ) + def test_maybe_convert_i8(self, breaks): + # GH 20636 + index = IntervalIndex.from_breaks(breaks) + + # intervalindex + result = index._maybe_convert_i8(index) + expected = IntervalIndex.from_breaks(breaks.asi8) + tm.assert_index_equal(result, expected) + + # interval + interval = Interval(breaks[0], breaks[1]) + result = index._maybe_convert_i8(interval) + expected = Interval(breaks[0]._value, breaks[1]._value) + assert result == expected + + # datetimelike index + result = index._maybe_convert_i8(breaks) + expected = Index(breaks.asi8) + tm.assert_index_equal(result, expected) + + # datetimelike scalar + result = index._maybe_convert_i8(breaks[0]) + expected = breaks[0]._value + assert result == expected + + # list-like of datetimelike scalars + result = index._maybe_convert_i8(list(breaks)) + expected = Index(breaks.asi8) + tm.assert_index_equal(result, expected) + + @pytest.mark.parametrize( + "breaks", + [date_range("2018-01-01", periods=5), timedelta_range("0 days", periods=5)], + ) + def test_maybe_convert_i8_nat(self, breaks): + # GH 20636 + index = IntervalIndex.from_breaks(breaks) + + to_convert = breaks._constructor([pd.NaT] * 3).as_unit("ns") + expected = Index([np.nan] * 3, dtype=np.float64) + result = index._maybe_convert_i8(to_convert) + tm.assert_index_equal(result, expected) + + to_convert = to_convert.insert(0, breaks[0]) + expected = expected.insert(0, float(breaks[0]._value)) + result = index._maybe_convert_i8(to_convert) + tm.assert_index_equal(result, expected) + + @pytest.mark.parametrize( + "make_key", + [lambda breaks: breaks, list], + ids=["lambda", "list"], + ) + def test_maybe_convert_i8_numeric(self, make_key, any_real_numpy_dtype): + # GH 20636 + breaks = np.arange(5, dtype=any_real_numpy_dtype) + index = IntervalIndex.from_breaks(breaks) + key = make_key(breaks) + + result = index._maybe_convert_i8(key) + kind = breaks.dtype.kind + expected_dtype = {"i": np.int64, "u": np.uint64, "f": np.float64}[kind] + expected = Index(key, dtype=expected_dtype) + tm.assert_index_equal(result, expected) + + @pytest.mark.parametrize( + "make_key", + [ + IntervalIndex.from_breaks, + lambda breaks: Interval(breaks[0], breaks[1]), + lambda breaks: breaks[0], + ], + ids=["IntervalIndex", "Interval", "scalar"], + ) + def test_maybe_convert_i8_numeric_identical(self, make_key, any_real_numpy_dtype): + # GH 20636 + breaks = np.arange(5, dtype=any_real_numpy_dtype) + index = IntervalIndex.from_breaks(breaks) + key = make_key(breaks) + + # test if _maybe_convert_i8 won't change key if an Interval or IntervalIndex + result = index._maybe_convert_i8(key) + assert result is key + + @pytest.mark.parametrize( + "breaks1, breaks2", + permutations( + [ + date_range("20180101", periods=4), + date_range("20180101", periods=4, tz="US/Eastern"), + timedelta_range("0 days", periods=4), + ], + 2, + ), + ids=lambda x: str(x.dtype), + ) + @pytest.mark.parametrize( + "make_key", + [ + IntervalIndex.from_breaks, + lambda breaks: Interval(breaks[0], breaks[1]), + lambda breaks: breaks, + lambda breaks: breaks[0], + list, + ], + ids=["IntervalIndex", "Interval", "Index", "scalar", "list"], + ) + def test_maybe_convert_i8_errors(self, breaks1, breaks2, make_key): + # GH 20636 + index = IntervalIndex.from_breaks(breaks1) + key = make_key(breaks2) + + msg = ( + f"Cannot index an IntervalIndex of subtype {breaks1.dtype} with " + f"values of dtype {breaks2.dtype}" + ) + msg = re.escape(msg) + with pytest.raises(ValueError, match=msg): + index._maybe_convert_i8(key) + + def test_contains_method(self): + # can select values that are IN the range of a value + i = IntervalIndex.from_arrays([0, 1], [1, 2]) + + expected = np.array([False, False], dtype="bool") + actual = i.contains(0) + tm.assert_numpy_array_equal(actual, expected) + actual = i.contains(3) + tm.assert_numpy_array_equal(actual, expected) + + expected = np.array([True, False], dtype="bool") + actual = i.contains(0.5) + tm.assert_numpy_array_equal(actual, expected) + actual = i.contains(1) + tm.assert_numpy_array_equal(actual, expected) + + # __contains__ not implemented for "interval in interval", follow + # that for the contains method for now + with pytest.raises( + NotImplementedError, match="contains not implemented for two" + ): + i.contains(Interval(0, 1)) + + def test_dropna(self, closed): + expected = IntervalIndex.from_tuples([(0.0, 1.0), (1.0, 2.0)], closed=closed) + + ii = IntervalIndex.from_tuples([(0, 1), (1, 2), np.nan], closed=closed) + result = ii.dropna() + tm.assert_index_equal(result, expected) + + ii = IntervalIndex.from_arrays([0, 1, np.nan], [1, 2, np.nan], closed=closed) + result = ii.dropna() + tm.assert_index_equal(result, expected) + + def test_non_contiguous(self, closed): + index = IntervalIndex.from_tuples([(0, 1), (2, 3)], closed=closed) + target = [0.5, 1.5, 2.5] + actual = index.get_indexer(target) + expected = np.array([0, -1, 1], dtype="intp") + tm.assert_numpy_array_equal(actual, expected) + + assert 1.5 not in index + + def test_isin(self, closed): + index = self.create_index(closed=closed) + + expected = np.array([True] + [False] * (len(index) - 1)) + result = index.isin(index[:1]) + tm.assert_numpy_array_equal(result, expected) + + result = index.isin([index[0]]) + tm.assert_numpy_array_equal(result, expected) + + other = IntervalIndex.from_breaks(np.arange(-2, 10), closed=closed) + expected = np.array([True] * (len(index) - 1) + [False]) + result = index.isin(other) + tm.assert_numpy_array_equal(result, expected) + + result = index.isin(other.tolist()) + tm.assert_numpy_array_equal(result, expected) + + for other_closed in ["right", "left", "both", "neither"]: + other = self.create_index(closed=other_closed) + expected = np.repeat(closed == other_closed, len(index)) + result = index.isin(other) + tm.assert_numpy_array_equal(result, expected) + + result = index.isin(other.tolist()) + tm.assert_numpy_array_equal(result, expected) + + def test_comparison(self): + actual = Interval(0, 1) < self.index + expected = np.array([False, True]) + tm.assert_numpy_array_equal(actual, expected) + + actual = Interval(0.5, 1.5) < self.index + expected = np.array([False, True]) + tm.assert_numpy_array_equal(actual, expected) + actual = self.index > Interval(0.5, 1.5) + tm.assert_numpy_array_equal(actual, expected) + + actual = self.index == self.index + expected = np.array([True, True]) + tm.assert_numpy_array_equal(actual, expected) + actual = self.index <= self.index + tm.assert_numpy_array_equal(actual, expected) + actual = self.index >= self.index + tm.assert_numpy_array_equal(actual, expected) + + actual = self.index < self.index + expected = np.array([False, False]) + tm.assert_numpy_array_equal(actual, expected) + actual = self.index > self.index + tm.assert_numpy_array_equal(actual, expected) + + actual = self.index == IntervalIndex.from_breaks([0, 1, 2], "left") + tm.assert_numpy_array_equal(actual, expected) + + actual = self.index == self.index.values + tm.assert_numpy_array_equal(actual, np.array([True, True])) + actual = self.index.values == self.index + tm.assert_numpy_array_equal(actual, np.array([True, True])) + actual = self.index <= self.index.values + tm.assert_numpy_array_equal(actual, np.array([True, True])) + actual = self.index != self.index.values + tm.assert_numpy_array_equal(actual, np.array([False, False])) + actual = self.index > self.index.values + tm.assert_numpy_array_equal(actual, np.array([False, False])) + actual = self.index.values > self.index + tm.assert_numpy_array_equal(actual, np.array([False, False])) + + # invalid comparisons + actual = self.index == 0 + tm.assert_numpy_array_equal(actual, np.array([False, False])) + actual = self.index == self.index.left + tm.assert_numpy_array_equal(actual, np.array([False, False])) + + msg = "|".join( + [ + "not supported between instances of 'int' and '.*.Interval'", + r"Invalid comparison between dtype=interval\[int64, right\] and ", + ] + ) + with pytest.raises(TypeError, match=msg): + self.index > 0 + with pytest.raises(TypeError, match=msg): + self.index <= 0 + with pytest.raises(TypeError, match=msg): + self.index > np.arange(2) + + msg = "Lengths must match to compare" + with pytest.raises(ValueError, match=msg): + self.index > np.arange(3) + + def test_missing_values(self, closed): + idx = Index( + [np.nan, Interval(0, 1, closed=closed), Interval(1, 2, closed=closed)] + ) + idx2 = IntervalIndex.from_arrays([np.nan, 0, 1], [np.nan, 1, 2], closed=closed) + assert idx.equals(idx2) + + msg = ( + "missing values must be missing in the same location both left " + "and right sides" + ) + with pytest.raises(ValueError, match=msg): + IntervalIndex.from_arrays( + [np.nan, 0, 1], np.array([0, 1, 2]), closed=closed + ) + + tm.assert_numpy_array_equal(isna(idx), np.array([True, False, False])) + + def test_sort_values(self, closed): + index = self.create_index(closed=closed) + + result = index.sort_values() + tm.assert_index_equal(result, index) + + result = index.sort_values(ascending=False) + tm.assert_index_equal(result, index[::-1]) + + # with nan + index = IntervalIndex([Interval(1, 2), np.nan, Interval(0, 1)]) + + result = index.sort_values() + expected = IntervalIndex([Interval(0, 1), Interval(1, 2), np.nan]) + tm.assert_index_equal(result, expected) + + result = index.sort_values(ascending=False, na_position="first") + expected = IntervalIndex([np.nan, Interval(1, 2), Interval(0, 1)]) + tm.assert_index_equal(result, expected) + + @pytest.mark.parametrize("tz", [None, "US/Eastern"]) + def test_datetime(self, tz): + start = Timestamp("2000-01-01", tz=tz) + dates = date_range(start=start, periods=10) + index = IntervalIndex.from_breaks(dates) + + # test mid + start = Timestamp("2000-01-01T12:00", tz=tz) + expected = date_range(start=start, periods=9) + tm.assert_index_equal(index.mid, expected) + + # __contains__ doesn't check individual points + assert Timestamp("2000-01-01", tz=tz) not in index + assert Timestamp("2000-01-01T12", tz=tz) not in index + assert Timestamp("2000-01-02", tz=tz) not in index + iv_true = Interval( + Timestamp("2000-01-02", tz=tz), Timestamp("2000-01-03", tz=tz) + ) + iv_false = Interval( + Timestamp("1999-12-31", tz=tz), Timestamp("2000-01-01", tz=tz) + ) + assert iv_true in index + assert iv_false not in index + + # .contains does check individual points + assert not index.contains(Timestamp("2000-01-01", tz=tz)).any() + assert index.contains(Timestamp("2000-01-01T12", tz=tz)).any() + assert index.contains(Timestamp("2000-01-02", tz=tz)).any() + + # test get_indexer + start = Timestamp("1999-12-31T12:00", tz=tz) + target = date_range(start=start, periods=7, freq="12h") + actual = index.get_indexer(target) + expected = np.array([-1, -1, 0, 0, 1, 1, 2], dtype="intp") + tm.assert_numpy_array_equal(actual, expected) + + start = Timestamp("2000-01-08T18:00", tz=tz) + target = date_range(start=start, periods=7, freq="6h") + actual = index.get_indexer(target) + expected = np.array([7, 7, 8, 8, 8, 8, -1], dtype="intp") + tm.assert_numpy_array_equal(actual, expected) + + def test_append(self, closed): + index1 = IntervalIndex.from_arrays([0, 1], [1, 2], closed=closed) + index2 = IntervalIndex.from_arrays([1, 2], [2, 3], closed=closed) + + result = index1.append(index2) + expected = IntervalIndex.from_arrays([0, 1, 1, 2], [1, 2, 2, 3], closed=closed) + tm.assert_index_equal(result, expected) + + result = index1.append([index1, index2]) + expected = IntervalIndex.from_arrays( + [0, 1, 0, 1, 1, 2], [1, 2, 1, 2, 2, 3], closed=closed + ) + tm.assert_index_equal(result, expected) + + for other_closed in {"left", "right", "both", "neither"} - {closed}: + index_other_closed = IntervalIndex.from_arrays( + [0, 1], [1, 2], closed=other_closed + ) + result = index1.append(index_other_closed) + expected = index1.astype(object).append(index_other_closed.astype(object)) + tm.assert_index_equal(result, expected) + + def test_is_non_overlapping_monotonic(self, closed): + # Should be True in all cases + tpls = [(0, 1), (2, 3), (4, 5), (6, 7)] + idx = IntervalIndex.from_tuples(tpls, closed=closed) + assert idx.is_non_overlapping_monotonic is True + + idx = IntervalIndex.from_tuples(tpls[::-1], closed=closed) + assert idx.is_non_overlapping_monotonic is True + + # Should be False in all cases (overlapping) + tpls = [(0, 2), (1, 3), (4, 5), (6, 7)] + idx = IntervalIndex.from_tuples(tpls, closed=closed) + assert idx.is_non_overlapping_monotonic is False + + idx = IntervalIndex.from_tuples(tpls[::-1], closed=closed) + assert idx.is_non_overlapping_monotonic is False + + # Should be False in all cases (non-monotonic) + tpls = [(0, 1), (2, 3), (6, 7), (4, 5)] + idx = IntervalIndex.from_tuples(tpls, closed=closed) + assert idx.is_non_overlapping_monotonic is False + + idx = IntervalIndex.from_tuples(tpls[::-1], closed=closed) + assert idx.is_non_overlapping_monotonic is False + + # Should be False for closed='both', otherwise True (GH16560) + if closed == "both": + idx = IntervalIndex.from_breaks(range(4), closed=closed) + assert idx.is_non_overlapping_monotonic is False + else: + idx = IntervalIndex.from_breaks(range(4), closed=closed) + assert idx.is_non_overlapping_monotonic is True + + @pytest.mark.parametrize( + "start, shift, na_value", + [ + (0, 1, np.nan), + (Timestamp("2018-01-01"), Timedelta("1 day"), pd.NaT), + (Timedelta("0 days"), Timedelta("1 day"), pd.NaT), + ], + ) + def test_is_overlapping(self, start, shift, na_value, closed): + # GH 23309 + # see test_interval_tree.py for extensive tests; interface tests here + + # non-overlapping + tuples = [(start + n * shift, start + (n + 1) * shift) for n in (0, 2, 4)] + index = IntervalIndex.from_tuples(tuples, closed=closed) + assert index.is_overlapping is False + + # non-overlapping with NA + tuples = [(na_value, na_value)] + tuples + [(na_value, na_value)] + index = IntervalIndex.from_tuples(tuples, closed=closed) + assert index.is_overlapping is False + + # overlapping + tuples = [(start + n * shift, start + (n + 2) * shift) for n in range(3)] + index = IntervalIndex.from_tuples(tuples, closed=closed) + assert index.is_overlapping is True + + # overlapping with NA + tuples = [(na_value, na_value)] + tuples + [(na_value, na_value)] + index = IntervalIndex.from_tuples(tuples, closed=closed) + assert index.is_overlapping is True + + # common endpoints + tuples = [(start + n * shift, start + (n + 1) * shift) for n in range(3)] + index = IntervalIndex.from_tuples(tuples, closed=closed) + result = index.is_overlapping + expected = closed == "both" + assert result is expected + + # common endpoints with NA + tuples = [(na_value, na_value)] + tuples + [(na_value, na_value)] + index = IntervalIndex.from_tuples(tuples, closed=closed) + result = index.is_overlapping + assert result is expected + + # intervals with duplicate left values + a = [10, 15, 20, 25, 30, 35, 40, 45, 45, 50, 55, 60, 65, 70, 75, 80, 85] + b = [15, 20, 25, 30, 35, 40, 45, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90] + index = IntervalIndex.from_arrays(a, b, closed="right") + result = index.is_overlapping + assert result is False + + @pytest.mark.parametrize( + "tuples", + [ + list(zip(range(10), range(1, 11))), + list( + zip( + date_range("20170101", periods=10), + date_range("20170101", periods=10), + ) + ), + list( + zip( + timedelta_range("0 days", periods=10), + timedelta_range("1 day", periods=10), + ) + ), + ], + ) + def test_to_tuples(self, tuples): + # GH 18756 + idx = IntervalIndex.from_tuples(tuples) + result = idx.to_tuples() + expected = Index(com.asarray_tuplesafe(tuples)) + tm.assert_index_equal(result, expected) + + @pytest.mark.parametrize( + "tuples", + [ + list(zip(range(10), range(1, 11))) + [np.nan], + list( + zip( + date_range("20170101", periods=10), + date_range("20170101", periods=10), + ) + ) + + [np.nan], + list( + zip( + timedelta_range("0 days", periods=10), + timedelta_range("1 day", periods=10), + ) + ) + + [np.nan], + ], + ) + @pytest.mark.parametrize("na_tuple", [True, False]) + def test_to_tuples_na(self, tuples, na_tuple): + # GH 18756 + idx = IntervalIndex.from_tuples(tuples) + result = idx.to_tuples(na_tuple=na_tuple) + + # check the non-NA portion + expected_notna = Index(com.asarray_tuplesafe(tuples[:-1])) + result_notna = result[:-1] + tm.assert_index_equal(result_notna, expected_notna) + + # check the NA portion + result_na = result[-1] + if na_tuple: + assert isinstance(result_na, tuple) + assert len(result_na) == 2 + assert all(isna(x) for x in result_na) + else: + assert isna(result_na) + + def test_nbytes(self): + # GH 19209 + left = np.arange(0, 4, dtype="i8") + right = np.arange(1, 5, dtype="i8") + + result = IntervalIndex.from_arrays(left, right).nbytes + expected = 64 # 4 * 8 * 2 + assert result == expected + + @pytest.mark.parametrize("new_closed", ["left", "right", "both", "neither"]) + def test_set_closed(self, name, closed, new_closed): + # GH 21670 + index = interval_range(0, 5, closed=closed, name=name) + result = index.set_closed(new_closed) + expected = interval_range(0, 5, closed=new_closed, name=name) + tm.assert_index_equal(result, expected) + + @pytest.mark.parametrize("bad_closed", ["foo", 10, "LEFT", True, False]) + def test_set_closed_errors(self, bad_closed): + # GH 21670 + index = interval_range(0, 5) + msg = f"invalid option for 'closed': {bad_closed}" + with pytest.raises(ValueError, match=msg): + index.set_closed(bad_closed) + + def test_is_all_dates(self): + # GH 23576 + year_2017 = Interval( + Timestamp("2017-01-01 00:00:00"), Timestamp("2018-01-01 00:00:00") + ) + year_2017_index = IntervalIndex([year_2017]) + assert not year_2017_index._is_all_dates + + +def test_dir(): + # GH#27571 dir(interval_index) should not raise + index = IntervalIndex.from_arrays([0, 1], [1, 2]) + result = dir(index) + assert "str" not in result + + +def test_searchsorted_different_argument_classes(listlike_box): + # https://github.com/pandas-dev/pandas/issues/32762 + values = IntervalIndex([Interval(0, 1), Interval(1, 2)]) + result = values.searchsorted(listlike_box(values)) + expected = np.array([0, 1], dtype=result.dtype) + tm.assert_numpy_array_equal(result, expected) + + result = values._data.searchsorted(listlike_box(values)) + tm.assert_numpy_array_equal(result, expected) + + +@pytest.mark.parametrize( + "arg", [[1, 2], ["a", "b"], [Timestamp("2020-01-01", tz="Europe/London")] * 2] +) +def test_searchsorted_invalid_argument(arg): + values = IntervalIndex([Interval(0, 1), Interval(1, 2)]) + msg = "'<' not supported between instances of 'pandas._libs.interval.Interval' and " + with pytest.raises(TypeError, match=msg): + values.searchsorted(arg) diff --git a/shared/package-files/2f/2f86b22c718b9f0a63b6e0642b4c222523d3a78c890a0b7f5e5a7ee589c145d5/blob b/shared/package-files/2f/2f86b22c718b9f0a63b6e0642b4c222523d3a78c890a0b7f5e5a7ee589c145d5/blob new file mode 100644 index 0000000000000000000000000000000000000000..686205119b036191164f90d935e579defc197575 Binary files /dev/null and b/shared/package-files/2f/2f86b22c718b9f0a63b6e0642b4c222523d3a78c890a0b7f5e5a7ee589c145d5/blob differ diff --git a/shared/package-files/2f/2f8827c762961bcc98728bb3e5bf5ba0922490536d38957a423727182adb9d16/blob b/shared/package-files/2f/2f8827c762961bcc98728bb3e5bf5ba0922490536d38957a423727182adb9d16/blob new file mode 100644 index 0000000000000000000000000000000000000000..883e817d9a6c7927a8b1e722d2b0ca074fd37c19 --- /dev/null +++ b/shared/package-files/2f/2f8827c762961bcc98728bb3e5bf5ba0922490536d38957a423727182adb9d16/blob @@ -0,0 +1,167 @@ +from __future__ import annotations + +import sys +from collections.abc import Collection, Callable, Sequence +from typing import Any, Protocol, Union, TypeVar, runtime_checkable + +from numpy import ( + ndarray, + dtype, + generic, + bool_, + unsignedinteger, + integer, + floating, + complexfloating, + number, + timedelta64, + datetime64, + object_, + void, + str_, + bytes_, +) +from ._nested_sequence import _NestedSequence + +_T = TypeVar("_T") +_ScalarType = TypeVar("_ScalarType", bound=generic) +_ScalarType_co = TypeVar("_ScalarType_co", bound=generic, covariant=True) +_DType = TypeVar("_DType", bound=dtype[Any]) +_DType_co = TypeVar("_DType_co", covariant=True, bound=dtype[Any]) + +NDArray = ndarray[Any, dtype[_ScalarType_co]] + +# The `_SupportsArray` protocol only cares about the default dtype +# (i.e. `dtype=None` or no `dtype` parameter at all) of the to-be returned +# array. +# Concrete implementations of the protocol are responsible for adding +# any and all remaining overloads +@runtime_checkable +class _SupportsArray(Protocol[_DType_co]): + def __array__(self) -> ndarray[Any, _DType_co]: ... + + +@runtime_checkable +class _SupportsArrayFunc(Protocol): + """A protocol class representing `~class.__array_function__`.""" + def __array_function__( + self, + func: Callable[..., Any], + types: Collection[type[Any]], + args: tuple[Any, ...], + kwargs: dict[str, Any], + ) -> object: ... + + +# TODO: Wait until mypy supports recursive objects in combination with typevars +_FiniteNestedSequence = Union[ + _T, + Sequence[_T], + Sequence[Sequence[_T]], + Sequence[Sequence[Sequence[_T]]], + Sequence[Sequence[Sequence[Sequence[_T]]]], +] + +# A subset of `npt.ArrayLike` that can be parametrized w.r.t. `np.generic` +_ArrayLike = Union[ + _SupportsArray[dtype[_ScalarType]], + _NestedSequence[_SupportsArray[dtype[_ScalarType]]], +] + +# A union representing array-like objects; consists of two typevars: +# One representing types that can be parametrized w.r.t. `np.dtype` +# and another one for the rest +_DualArrayLike = Union[ + _SupportsArray[_DType], + _NestedSequence[_SupportsArray[_DType]], + _T, + _NestedSequence[_T], +] + +if sys.version_info >= (3, 12): + from collections.abc import Buffer + + ArrayLike = Buffer | _DualArrayLike[ + dtype[Any], + Union[bool, int, float, complex, str, bytes], + ] +else: + ArrayLike = _DualArrayLike[ + dtype[Any], + Union[bool, int, float, complex, str, bytes], + ] + +# `ArrayLike_co`: array-like objects that can be coerced into `X` +# given the casting rules `same_kind` +_ArrayLikeBool_co = _DualArrayLike[ + dtype[bool_], + bool, +] +_ArrayLikeUInt_co = _DualArrayLike[ + dtype[Union[bool_, unsignedinteger[Any]]], + bool, +] +_ArrayLikeInt_co = _DualArrayLike[ + dtype[Union[bool_, integer[Any]]], + Union[bool, int], +] +_ArrayLikeFloat_co = _DualArrayLike[ + dtype[Union[bool_, integer[Any], floating[Any]]], + Union[bool, int, float], +] +_ArrayLikeComplex_co = _DualArrayLike[ + dtype[Union[ + bool_, + integer[Any], + floating[Any], + complexfloating[Any, Any], + ]], + Union[bool, int, float, complex], +] +_ArrayLikeNumber_co = _DualArrayLike[ + dtype[Union[bool_, number[Any]]], + Union[bool, int, float, complex], +] +_ArrayLikeTD64_co = _DualArrayLike[ + dtype[Union[bool_, integer[Any], timedelta64]], + Union[bool, int], +] +_ArrayLikeDT64_co = Union[ + _SupportsArray[dtype[datetime64]], + _NestedSequence[_SupportsArray[dtype[datetime64]]], +] +_ArrayLikeObject_co = Union[ + _SupportsArray[dtype[object_]], + _NestedSequence[_SupportsArray[dtype[object_]]], +] + +_ArrayLikeVoid_co = Union[ + _SupportsArray[dtype[void]], + _NestedSequence[_SupportsArray[dtype[void]]], +] +_ArrayLikeStr_co = _DualArrayLike[ + dtype[str_], + str, +] +_ArrayLikeBytes_co = _DualArrayLike[ + dtype[bytes_], + bytes, +] + +_ArrayLikeInt = _DualArrayLike[ + dtype[integer[Any]], + int, +] + +# Extra ArrayLike type so that pyright can deal with NDArray[Any] +# Used as the first overload, should only match NDArray[Any], +# not any actual types. +# https://github.com/numpy/numpy/pull/22193 +class _UnknownType: + ... + + +_ArrayLikeUnknown = _DualArrayLike[ + dtype[_UnknownType], + _UnknownType, +] diff --git a/shared/package-files/2f/2f8b2ad3c07411dc3b266da66befe74ee4150f08fa39842844f4050b8ad7008e/blob b/shared/package-files/2f/2f8b2ad3c07411dc3b266da66befe74ee4150f08fa39842844f4050b8ad7008e/blob new file mode 100644 index 0000000000000000000000000000000000000000..886809a0b8a78b100ac698ceb6ecaa9fa7f7b046 --- /dev/null +++ b/shared/package-files/2f/2f8b2ad3c07411dc3b266da66befe74ee4150f08fa39842844f4050b8ad7008e/blob @@ -0,0 +1,636 @@ +#pragma once + +// DO NOT DEFINE STATIC DATA IN THIS HEADER! +// See Note [Do not compile initializers with AVX] + +#include +#include +#include +#if defined(CPU_CAPABILITY_AVX2) && !defined(_MSC_VER) +#include +#endif + +namespace at::vec { +// See Note [CPU_CAPABILITY namespace] +inline namespace CPU_CAPABILITY { + +#if defined(CPU_CAPABILITY_AVX2) && !defined(_MSC_VER) + +template <> class Vectorized { +private: + __m256 values; +public: + using value_type = float; + using size_type = int; + static constexpr size_type size() { + return 8; + } + Vectorized() {} + Vectorized(__m256 v) : values(v) {} + Vectorized(float val) { + values = _mm256_set1_ps(val); + } + Vectorized(float val1, float val2, float val3, float val4, + float val5, float val6, float val7, float val8) { + values = _mm256_setr_ps(val1, val2, val3, val4, val5, val6, val7, val8); + } + operator __m256() const { + return values; + } + template + static Vectorized blend(const Vectorized& a, const Vectorized& b) { + return _mm256_blend_ps(a.values, b.values, mask); + } + static Vectorized blendv(const Vectorized& a, const Vectorized& b, + const Vectorized& mask) { + return _mm256_blendv_ps(a.values, b.values, mask.values); + } + template + static Vectorized arange(float base = 0.f, step_t step = static_cast(1)) { + return Vectorized( + base, base + step, base + 2 * step, base + 3 * step, + base + 4 * step, base + 5 * step, base + 6 * step, base + 7 * step); + } + static Vectorized set(const Vectorized& a, const Vectorized& b, + int64_t count = size()) { + switch (count) { + case 0: + return a; + case 1: + return blend<1>(a, b); + case 2: + return blend<3>(a, b); + case 3: + return blend<7>(a, b); + case 4: + return blend<15>(a, b); + case 5: + return blend<31>(a, b); + case 6: + return blend<63>(a, b); + case 7: + return blend<127>(a, b); + } + return b; + } + static Vectorized loadu(const void* ptr, int64_t count = size()) { + if (count == size()) + return _mm256_loadu_ps(reinterpret_cast(ptr)); + __at_align__ float tmp_values[size()]; + // Ensure uninitialized memory does not change the output value See https://github.com/pytorch/pytorch/issues/32502 + // for more details. We do not initialize arrays to zero using "={0}" because gcc would compile it to two + // instructions while a loop would be compiled to one instruction. + for (const auto i : c10::irange(size())) { + tmp_values[i] = 0.0; + } + std::memcpy( + tmp_values, reinterpret_cast(ptr), count * sizeof(float)); + return _mm256_loadu_ps(tmp_values); + } + void store(void* ptr, int64_t count = size()) const { + if (count == size()) { + _mm256_storeu_ps(reinterpret_cast(ptr), values); + } else if (count > 0) { + float tmp_values[size()]; + _mm256_storeu_ps(reinterpret_cast(tmp_values), values); + std::memcpy(ptr, tmp_values, count * sizeof(float)); + } + } + const float& operator[](int idx) const = delete; + float& operator[](int idx) = delete; + int zero_mask() const { + // returns an integer mask where all zero elements are translated to 1-bit and others are translated to 0-bit + __m256 cmp = _mm256_cmp_ps(values, _mm256_set1_ps(0.0f), _CMP_EQ_OQ); + return _mm256_movemask_ps(cmp); + } + Vectorized isnan() const { + return _mm256_cmp_ps(values, _mm256_set1_ps(0.0f), _CMP_UNORD_Q); + } + + bool has_inf_nan() const { + __m256 self_sub = _mm256_sub_ps(values, values); + return (_mm256_movemask_epi8(_mm256_castps_si256(self_sub)) & 0x77777777) != 0; + } + + Vectorized map(float (*const f)(float)) const { + __at_align__ float tmp[size()]; + store(tmp); + for (const auto i : c10::irange(size())) { + tmp[i] = f(tmp[i]); + } + return loadu(tmp); + } + Vectorized abs() const { + auto mask = _mm256_set1_ps(-0.f); + return _mm256_andnot_ps(mask, values); + } + Vectorized angle() const { + const auto zero_vec = _mm256_set1_ps(0.f); + const auto nan_vec = _mm256_set1_ps(NAN); + const auto not_nan_mask = _mm256_cmp_ps(values, values, _CMP_EQ_OQ); + const auto nan_mask = _mm256_cmp_ps(not_nan_mask, zero_vec, _CMP_EQ_OQ); + const auto pi = _mm256_set1_ps(c10::pi); + + const auto neg_mask = _mm256_cmp_ps(values, zero_vec, _CMP_LT_OQ); + auto angle = _mm256_blendv_ps(zero_vec, pi, neg_mask); + angle = _mm256_blendv_ps(angle, nan_vec, nan_mask); + return angle; + } + Vectorized real() const { + return *this; + } + Vectorized imag() const { + return _mm256_set1_ps(0); + } + Vectorized conj() const { + return *this; + } + Vectorized acos() const { + return Vectorized(Sleef_acosf8_u10(values)); + } + Vectorized acosh() const { + return Vectorized(Sleef_acoshf8_u10(values)); + } + Vectorized asin() const { + return Vectorized(Sleef_asinf8_u10(values)); + } + Vectorized atan() const { + return Vectorized(Sleef_atanf8_u10(values)); + } + Vectorized atanh() const { + return Vectorized(Sleef_atanhf8_u10(values)); + } + Vectorized atan2(const Vectorized &b) const { + return Vectorized(Sleef_atan2f8_u10(values, b)); + } + Vectorized copysign(const Vectorized &sign) const { + return Vectorized(Sleef_copysignf8(values, sign)); + } + Vectorized erf() const { + // constants + const auto neg_zero_vec = _mm256_set1_ps(-0.f); + const auto one_vec = _mm256_set1_ps(1.0f); + const auto p = _mm256_set1_ps(0.3275911f); + const auto p1 = _mm256_set1_ps(0.254829592f); + const auto p2 = _mm256_set1_ps(-0.284496736f); + const auto p3 = _mm256_set1_ps(1.421413741f); + const auto p4 = _mm256_set1_ps(-1.453152027f); + const auto p5 = _mm256_set1_ps(1.061405429f); + // sign(x) + auto sign_mask = _mm256_and_ps(neg_zero_vec, values); + auto abs_vec = _mm256_xor_ps(sign_mask, values); + // t = 1 / (p * abs(x) + 1) + auto tmp0 = _mm256_fmadd_ps(p, abs_vec, one_vec); + auto t = _mm256_div_ps(one_vec, tmp0); + // r = p5 * t ^ 4 + p4 * t ^ 3 + p3 * t ^ 2 + p2 * t + p1 + auto tmp1 = _mm256_fmadd_ps(p5, t, p4); + auto tmp2 = _mm256_fmadd_ps(tmp1, t, p3); + auto tmp3 = _mm256_fmadd_ps(tmp2, t, p2); + auto r = _mm256_fmadd_ps(tmp3, t, p1); + // - exp(- x * x) + auto pow_2 = _mm256_mul_ps(values, values); + auto neg_pow_2 = _mm256_xor_ps(neg_zero_vec, pow_2); + // auto tmp4 = exp(neg_pow_2); + auto tmp4 = Vectorized(Sleef_expf8_u10(neg_pow_2)); + auto tmp5 = _mm256_xor_ps(neg_zero_vec, tmp4); + // erf(x) = sign(x) * (1 - r * t * exp(- x * x)) + auto tmp6 = _mm256_mul_ps(tmp5, t); + auto tmp7 = _mm256_fmadd_ps(tmp6, r, one_vec); + return _mm256_xor_ps(sign_mask, tmp7); + } + Vectorized erfc() const { + return Vectorized(Sleef_erfcf8_u15(values)); + } + Vectorized erfinv() const { + return map(calc_erfinv); + } + Vectorized exp() const { + return Vectorized(Sleef_expf8_u10(values)); + } + Vectorized exp2() const { + return Vectorized(Sleef_exp2f8_u10(values)); + } + Vectorized expm1() const { + return Vectorized(Sleef_expm1f8_u10(values)); + } + Vectorized exp_u20() const { + // A faster version of exp with ULP=20 + static __m256 vec_factorial_1 = + _mm256_set1_ps(0.999999701f); // 1/factorial(1) + static __m256 vec_factorial_2 = + _mm256_set1_ps(0.499991506f); // 1/factorial(2) + static __m256 vec_factorial_3 = + _mm256_set1_ps(0.166676521f); // 1/factorial(3) + static __m256 vec_factorial_4 = + _mm256_set1_ps(0.0418978221f); // 1/factorial(4) + static __m256 vec_factorial_5 = + _mm256_set1_ps(0.00828929059f); // 1/factorial(5) + static __m256 vec_exp_log2ef = + (__m256)_mm256_set1_epi32(0x3fb8aa3b); // log2(e) + static __m256 vec_half = _mm256_set1_ps(0.5f); + static __m256 vec_one = _mm256_set1_ps(1.f); + static __m256 vec_zero = _mm256_set1_ps(0.f); + static __m256 vec_two = _mm256_set1_ps(2.f); + static __m256 vec_ln2f = (__m256)_mm256_set1_epi32(0x3f317218); // ln(2) + static __m256 vec_ln_flt_min = (__m256)_mm256_set1_epi32(0xc2aeac50); + static __m256 vec_ln_flt_max = (__m256)_mm256_set1_epi32(0x42b17218); + static __m256i vec_127 = _mm256_set1_epi32(0x0000007f); + static int n_mantissa_bits = 23; + + // exp(x) = + // = exp(n * ln(2) + r) // divide x by ln(2) and get quot and rem + // = 2^n * exp(r) // simplify the exp(n*ln(2)) expression + + auto less_ln_flt_min_mask = + _mm256_cmp_ps(values, vec_ln_flt_min, 1 /*_CMP_LT_OS*/); + auto vec_src = _mm256_min_ps(values, vec_ln_flt_max); + vec_src = _mm256_max_ps(vec_src, vec_ln_flt_min); + + // fx = floorf(x * log2ef + 0.5) + auto vec_fx = _mm256_fmadd_ps(vec_src, vec_exp_log2ef, vec_half); + vec_fx = _mm256_floor_ps(vec_fx); + + // x = x - fx * ln2 + auto vec_exp_poly = _mm256_fnmadd_ps(vec_fx, vec_ln2f, vec_src); + + // compute polynomial + auto vec_res = + _mm256_fmadd_ps(vec_exp_poly, vec_factorial_5, vec_factorial_4); + vec_res = _mm256_fmadd_ps(vec_exp_poly, vec_res, vec_factorial_3); + vec_res = _mm256_fmadd_ps(vec_exp_poly, vec_res, vec_factorial_2); + vec_res = _mm256_fmadd_ps(vec_exp_poly, vec_res, vec_factorial_1); + vec_res = _mm256_fmadd_ps(vec_exp_poly, vec_res, vec_one); + + // compute 2^(n-1) + auto vec_exp_number = _mm256_sub_ps(vec_fx, vec_one); + auto vec_exp_number_i = _mm256_cvtps_epi32(vec_exp_number); + auto vec_two_pow_n_i = _mm256_add_epi32(vec_exp_number_i, vec_127); + vec_two_pow_n_i = _mm256_slli_epi32(vec_two_pow_n_i, n_mantissa_bits); + auto vec_two_pow_n = (__m256)vec_two_pow_n_i; + vec_two_pow_n = + _mm256_blendv_ps(vec_two_pow_n, vec_zero, less_ln_flt_min_mask); + + // y = y * 2^n + vec_res = _mm256_mul_ps(vec_res, vec_two_pow_n); + vec_res = _mm256_mul_ps(vec_res, vec_two); + return vec_res; + } + Vectorized fmod(const Vectorized& q) const { + return Vectorized(Sleef_fmodf8(values, q)); + } + Vectorized log() const { + return Vectorized(Sleef_logf8_u10(values)); + } + Vectorized log2() const { + return Vectorized(Sleef_log2f8_u10(values)); + } + Vectorized log10() const { + return Vectorized(Sleef_log10f8_u10(values)); + } + Vectorized log1p() const { + return Vectorized(Sleef_log1pf8_u10(values)); + } + Vectorized frac() const; + Vectorized sin() const { + return Vectorized(Sleef_sinf8_u35(values)); + } + Vectorized sinh() const { + return Vectorized(Sleef_sinhf8_u10(values)); + } + Vectorized cos() const { + return Vectorized(Sleef_cosf8_u35(values)); + } + Vectorized cosh() const { + return Vectorized(Sleef_coshf8_u10(values)); + } + Vectorized ceil() const { + return _mm256_ceil_ps(values); + } + Vectorized floor() const { + return _mm256_floor_ps(values); + } + Vectorized hypot(const Vectorized &b) const { + return Vectorized(Sleef_hypotf8_u05(values, b)); + } + Vectorized i0() const { + return map(calc_i0); + } + Vectorized i0e() const { + return map(calc_i0e); + } + Vectorized digamma() const { + return map(calc_digamma); + } + Vectorized igamma(const Vectorized &x) const { + __at_align__ float tmp[size()]; + __at_align__ float tmp_x[size()]; + store(tmp); + x.store(tmp_x); + for (const auto i : c10::irange(size())) { + tmp[i] = calc_igamma(tmp[i], tmp_x[i]); + } + return loadu(tmp); + } + Vectorized igammac(const Vectorized &x) const { + __at_align__ float tmp[size()]; + __at_align__ float tmp_x[size()]; + store(tmp); + x.store(tmp_x); + for (const auto i : c10::irange(size())) { + tmp[i] = calc_igammac(tmp[i], tmp_x[i]); + } + return loadu(tmp); + } + Vectorized neg() const { + return _mm256_xor_ps(_mm256_set1_ps(-0.f), values); + } + Vectorized nextafter(const Vectorized &b) const { + return Vectorized(Sleef_nextafterf8(values, b)); + } + Vectorized round() const { + return _mm256_round_ps(values, (_MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC)); + } + Vectorized tan() const { + return Vectorized(Sleef_tanf8_u10(values)); + } + Vectorized tanh() const { + return Vectorized(Sleef_tanhf8_u10(values)); + } + Vectorized trunc() const { + return _mm256_round_ps(values, (_MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC)); + } + Vectorized lgamma() const { + return Vectorized(Sleef_lgammaf8_u10(values)); + } + Vectorized sqrt() const { + return _mm256_sqrt_ps(values); + } + Vectorized reciprocal() const { + return _mm256_div_ps(_mm256_set1_ps(1), values); + } + Vectorized rsqrt() const { + return _mm256_div_ps(_mm256_set1_ps(1), _mm256_sqrt_ps(values)); + } + Vectorized pow(const Vectorized &b) const { + return Vectorized(Sleef_powf8_u10(values, b)); + } + // Comparison using the _CMP_**_OQ predicate. + // `O`: get false if an operand is NaN + // `Q`: do not raise if an operand is NaN + Vectorized operator==(const Vectorized& other) const { + return _mm256_cmp_ps(values, other.values, _CMP_EQ_OQ); + } + + Vectorized operator!=(const Vectorized& other) const { + return _mm256_cmp_ps(values, other.values, _CMP_NEQ_UQ); + } + + Vectorized operator<(const Vectorized& other) const { + return _mm256_cmp_ps(values, other.values, _CMP_LT_OQ); + } + + Vectorized operator<=(const Vectorized& other) const { + return _mm256_cmp_ps(values, other.values, _CMP_LE_OQ); + } + + Vectorized operator>(const Vectorized& other) const { + return _mm256_cmp_ps(values, other.values, _CMP_GT_OQ); + } + + Vectorized operator>=(const Vectorized& other) const { + return _mm256_cmp_ps(values, other.values, _CMP_GE_OQ); + } + + Vectorized eq(const Vectorized& other) const; + Vectorized ne(const Vectorized& other) const; + Vectorized gt(const Vectorized& other) const; + Vectorized ge(const Vectorized& other) const; + Vectorized lt(const Vectorized& other) const; + Vectorized le(const Vectorized& other) const; +}; + +template <> +Vectorized inline operator+(const Vectorized& a, const Vectorized& b) { + return _mm256_add_ps(a, b); +} + +template <> +Vectorized inline operator-(const Vectorized& a, const Vectorized& b) { + return _mm256_sub_ps(a, b); +} + +template <> +Vectorized inline operator*(const Vectorized& a, const Vectorized& b) { + return _mm256_mul_ps(a, b); +} + +template <> +Vectorized inline operator/(const Vectorized& a, const Vectorized& b) { + return _mm256_div_ps(a, b); +} + +// frac. Implement this here so we can use subtraction +inline Vectorized Vectorized::frac() const { + return *this - this->trunc(); +} + +// Implements the IEEE 754 201X `maximum` operation, which propagates NaN if +// either input is a NaN. +template <> +Vectorized inline maximum(const Vectorized& a, const Vectorized& b) { + Vectorized max = _mm256_max_ps(a, b); + Vectorized isnan = _mm256_cmp_ps(a, b, _CMP_UNORD_Q); + // Exploit the fact that all-ones is a NaN. + return _mm256_or_ps(max, isnan); +} + +// Implements the IEEE 754 201X `minimum` operation, which propagates NaN if +// either input is a NaN. +template <> +Vectorized inline minimum(const Vectorized& a, const Vectorized& b) { + Vectorized min = _mm256_min_ps(a, b); + Vectorized isnan = _mm256_cmp_ps(a, b, _CMP_UNORD_Q); + // Exploit the fact that all-ones is a NaN. + return _mm256_or_ps(min, isnan); +} + +template <> +Vectorized inline clamp(const Vectorized& a, const Vectorized& min, const Vectorized& max) { + return _mm256_min_ps(max, _mm256_max_ps(min, a)); +} + +template <> +Vectorized inline clamp_max(const Vectorized& a, const Vectorized& max) { + return _mm256_min_ps(max, a); +} + +template <> +Vectorized inline clamp_min(const Vectorized& a, const Vectorized& min) { + return _mm256_max_ps(min, a); +} + +template <> +Vectorized inline operator&(const Vectorized& a, const Vectorized& b) { + return _mm256_and_ps(a, b); +} + +template <> +Vectorized inline operator|(const Vectorized& a, const Vectorized& b) { + return _mm256_or_ps(a, b); +} + +template <> +Vectorized inline operator^(const Vectorized& a, const Vectorized& b) { + return _mm256_xor_ps(a, b); +} + +inline Vectorized Vectorized::eq(const Vectorized& other) const { + return (*this == other) & Vectorized(1.0f); +} + +inline Vectorized Vectorized::ne(const Vectorized& other) const { + return (*this != other) & Vectorized(1.0f); +} + +inline Vectorized Vectorized::gt(const Vectorized& other) const { + return (*this > other) & Vectorized(1.0f); +} + +inline Vectorized Vectorized::ge(const Vectorized& other) const { + return (*this >= other) & Vectorized(1.0f); +} + +inline Vectorized Vectorized::lt(const Vectorized& other) const { + return (*this < other) & Vectorized(1.0f); +} + +inline Vectorized Vectorized::le(const Vectorized& other) const { + return (*this <= other) & Vectorized(1.0f); +} + +template <> +inline void convert(const float* src, float* dst, int64_t n) { + int64_t i; +#pragma unroll + for (i = 0; i <= (n - Vectorized::size()); i += Vectorized::size()) { + _mm256_storeu_ps(dst + i, _mm256_loadu_ps(src + i)); + } +#pragma unroll + for (; i < n; i++) { + dst[i] = src[i]; + } +} + + +template <> +Vectorized inline fmadd(const Vectorized& a, const Vectorized& b, const Vectorized& c) { + return _mm256_fmadd_ps(a, b, c); +} + +template <> +Vectorized inline fmsub(const Vectorized& a, const Vectorized& b, const Vectorized& c) { + return _mm256_fmsub_ps(a, b, c); +} + +// Used by Inductor CPP codegen +template<> +inline void transpose_mxn( + const float* src, + int64_t ld_src, + float* dst, + int64_t ld_dst) { + // load from src to registers + // a: a0 a1 a2 a3 a4 a5 a6 a7 + // b: b0 b1 b2 b3 b4 b5 b6 b7 + // c: c0 c1 c2 c3 c4 c5 c6 c7 + // d: d0 d1 d2 d3 d4 d5 d6 d7 + // e: e0 e1 e2 e3 e4 e5 e6 e7 + // f: f0 f1 f2 f3 f4 f5 f6 f7 + // g: g0 g1 g2 g3 g4 g5 g6 g7 + // h: h0 h1 h2 h3 h4 h5 h6 h7 + __m256 a = _mm256_loadu_ps(&src[0 * ld_src]); + __m256 b = _mm256_loadu_ps(&src[1 * ld_src]); + __m256 c = _mm256_loadu_ps(&src[2 * ld_src]); + __m256 d = _mm256_loadu_ps(&src[3 * ld_src]); + __m256 e = _mm256_loadu_ps(&src[4 * ld_src]); + __m256 f = _mm256_loadu_ps(&src[5 * ld_src]); + __m256 g = _mm256_loadu_ps(&src[6 * ld_src]); + __m256 h = _mm256_loadu_ps(&src[7 * ld_src]); + + __m256 ta, tb, tc, td, te, tf, tg, th; + // unpacking and interleaving 32-bit elements + // a0 b0 a1 b1 a4 b4 a5 b5 + // a2 b2 a3 b3 a6 b6 a7 b7 + // c0 d0 c1 d1 ... + // c2 d2 c3 d3 ... + // e0 f0 e1 f1 ... + // e2 f2 e3 f3 ... + // g0 h0 g1 h1 ... + // g2 h2 g3 h3 ... + ta = _mm256_unpacklo_ps(a, b); + tb = _mm256_unpackhi_ps(a, b); + tc = _mm256_unpacklo_ps(c, d); + td = _mm256_unpackhi_ps(c, d); + te = _mm256_unpacklo_ps(e, f); + tf = _mm256_unpackhi_ps(e, f); + tg = _mm256_unpacklo_ps(g, h); + th = _mm256_unpackhi_ps(g, h); + + // unpacking and interleaving 64-bit elements + // a0 b0 c0 d0 a4 b4 c4 d4 + // a1 b1 c1 d1 ... + // a2 b2 c2 d2 ... + // a3 b3 c3 d3 ... + // e0 f0 g0 h0 e4 f4 g4 h4 + // e1 f1 g1 h1 ... + // e2 f2 g2 h2 ... + // e3 f3 g3 h3 ... + a = _mm256_castpd_ps( + _mm256_unpacklo_pd(_mm256_castps_pd(ta), _mm256_castps_pd(tc))); + b = _mm256_castpd_ps( + _mm256_unpackhi_pd(_mm256_castps_pd(ta), _mm256_castps_pd(tc))); + c = _mm256_castpd_ps( + _mm256_unpacklo_pd(_mm256_castps_pd(tb), _mm256_castps_pd(td))); + d = _mm256_castpd_ps( + _mm256_unpackhi_pd(_mm256_castps_pd(tb), _mm256_castps_pd(td))); + e = _mm256_castpd_ps( + _mm256_unpacklo_pd(_mm256_castps_pd(te), _mm256_castps_pd(tg))); + f = _mm256_castpd_ps( + _mm256_unpackhi_pd(_mm256_castps_pd(te), _mm256_castps_pd(tg))); + g = _mm256_castpd_ps( + _mm256_unpacklo_pd(_mm256_castps_pd(tf), _mm256_castps_pd(th))); + h = _mm256_castpd_ps( + _mm256_unpackhi_pd(_mm256_castps_pd(tf), _mm256_castps_pd(th))); + + // shuffle 128-bits (composed of 4 32-bit elements) + // a0 b0 c0 d0 e0 f0 g0 h0 + // a1 b1 c1 d1 ... + // a2 b2 c2 d2 ... + // a3 b3 c3 d3 ... + // a4 b4 c4 d4 ... + // a5 b5 c5 d5 ... + // a6 b6 c6 d6 ... + // a7 b7 c7 d7 ... + ta = _mm256_permute2f128_ps(a, e, 0x20); + tb = _mm256_permute2f128_ps(b, f, 0x20); + tc = _mm256_permute2f128_ps(c, g, 0x20); + td = _mm256_permute2f128_ps(d, h, 0x20); + te = _mm256_permute2f128_ps(a, e, 0x31); + tf = _mm256_permute2f128_ps(b, f, 0x31); + tg = _mm256_permute2f128_ps(c, g, 0x31); + th = _mm256_permute2f128_ps(d, h, 0x31); + + // store from registers to dst + _mm256_storeu_ps(&dst[0 * ld_dst], ta); + _mm256_storeu_ps(&dst[1 * ld_dst], tb); + _mm256_storeu_ps(&dst[2 * ld_dst], tc); + _mm256_storeu_ps(&dst[3 * ld_dst], td); + _mm256_storeu_ps(&dst[4 * ld_dst], te); + _mm256_storeu_ps(&dst[5 * ld_dst], tf); + _mm256_storeu_ps(&dst[6 * ld_dst], tg); + _mm256_storeu_ps(&dst[7 * ld_dst], th); +} + +#endif + +}} // namespace at::vec::CPU_CAPABILITY diff --git a/shared/package-files/2f/2f8e8b2b50c8e528c70e2fa63f20f20bc8700d2c84b96bf92828f8cd6db8e6b8/blob b/shared/package-files/2f/2f8e8b2b50c8e528c70e2fa63f20f20bc8700d2c84b96bf92828f8cd6db8e6b8/blob new file mode 100644 index 0000000000000000000000000000000000000000..3a43719c0030f51ef34bf3e9bf72e7800cb2179c Binary files /dev/null and b/shared/package-files/2f/2f8e8b2b50c8e528c70e2fa63f20f20bc8700d2c84b96bf92828f8cd6db8e6b8/blob differ diff --git a/shared/package-files/2f/2f8eabb1727746800ba9b253a27e1f1e1d55d910fa429089907aedf89c59dfdf/blob b/shared/package-files/2f/2f8eabb1727746800ba9b253a27e1f1e1d55d910fa429089907aedf89c59dfdf/blob new file mode 100644 index 0000000000000000000000000000000000000000..a795c3b77646875e97775ba197adafa8388f56e3 --- /dev/null +++ b/shared/package-files/2f/2f8eabb1727746800ba9b253a27e1f1e1d55d910fa429089907aedf89c59dfdf/blob @@ -0,0 +1,28 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API _convolution_mode { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const c10::optional &, c10::SymIntArrayRef, c10::string_view, c10::SymIntArrayRef, c10::SymInt); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_convolution_mode") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_convolution_mode(Tensor input, Tensor weight, Tensor? bias, SymInt[] stride, str padding, SymInt[] dilation, SymInt groups) -> Tensor") + static at::Tensor call(const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, c10::SymIntArrayRef stride, c10::string_view padding, c10::SymIntArrayRef dilation, c10::SymInt groups); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const at::Tensor & weight, const c10::optional & bias, c10::SymIntArrayRef stride, c10::string_view padding, c10::SymIntArrayRef dilation, c10::SymInt groups); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/2f/2f9117efda960636ae5d7ab1c5b69cce80dbb3b38d1a70f57861cb1fea4cd482/blob b/shared/package-files/2f/2f9117efda960636ae5d7ab1c5b69cce80dbb3b38d1a70f57861cb1fea4cd482/blob new file mode 100644 index 0000000000000000000000000000000000000000..20a056655917c2b6d5b902c9d1d7d6ad1a60979c Binary files /dev/null and b/shared/package-files/2f/2f9117efda960636ae5d7ab1c5b69cce80dbb3b38d1a70f57861cb1fea4cd482/blob differ diff --git a/shared/package-files/2f/2f94490bade801df50a3a57cd586e25891762f27870df9e5cffcd1df17689e59/blob b/shared/package-files/2f/2f94490bade801df50a3a57cd586e25891762f27870df9e5cffcd1df17689e59/blob new file mode 100644 index 0000000000000000000000000000000000000000..f64c6ff2844685285187c0904ae29ee5e5774fdc --- /dev/null +++ b/shared/package-files/2f/2f94490bade801df50a3a57cd586e25891762f27870df9e5cffcd1df17689e59/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::_weight_norm_interface(Tensor v, Tensor g, int dim=0) -> (Tensor, Tensor) +inline ::std::tuple _weight_norm_interface(const at::Tensor & v, const at::Tensor & g, int64_t dim=0) { + return at::_ops::_weight_norm_interface::call(v, g, dim); +} + +// aten::_weight_norm_interface.out(Tensor v, Tensor g, int dim=0, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) +inline ::std::tuple _weight_norm_interface_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & v, const at::Tensor & g, int64_t dim=0) { + return at::_ops::_weight_norm_interface_out::call(v, g, dim, out0, out1); +} +// aten::_weight_norm_interface.out(Tensor v, Tensor g, int dim=0, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!)) +inline ::std::tuple _weight_norm_interface_outf(const at::Tensor & v, const at::Tensor & g, int64_t dim, at::Tensor & out0, at::Tensor & out1) { + return at::_ops::_weight_norm_interface_out::call(v, g, dim, out0, out1); +} + +} diff --git a/shared/package-files/2f/2f977ddc56c7958d2a616b072f71c5e191e0dd77cdd4667e0f5a644bd3b4f96c/blob b/shared/package-files/2f/2f977ddc56c7958d2a616b072f71c5e191e0dd77cdd4667e0f5a644bd3b4f96c/blob new file mode 100644 index 0000000000000000000000000000000000000000..087ea95916e54ee925b50a6466693a735a8717d9 --- /dev/null +++ b/shared/package-files/2f/2f977ddc56c7958d2a616b072f71c5e191e0dd77cdd4667e0f5a644bd3b4f96c/blob @@ -0,0 +1,192 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates + +import torch + +from .core import _map_mt_args_kwargs, _masks_match, _tensors_match, _wrap_result, is_masked_tensor + +__all__ = [] # type: ignore[var-annotated] + +BINARY_NAMES = [ + "add", + "atan2", + "arctan2", + "bitwise_and", + "bitwise_or", + "bitwise_xor", + "bitwise_left_shift", + "bitwise_right_shift", + "div", + "divide", + "floor_divide", + "fmod", + "logaddexp", + "logaddexp2", + "mul", + "multiply", + "nextafter", + "remainder", + "sub", + "subtract", + "true_divide", + "eq", + "ne", + "le", + "ge", + "greater", + "greater_equal", + "gt", + "less_equal", + "lt", + "less", + "maximum", + "minimum", + "fmax", + "fmin", + "not_equal", +] + +INPLACE_BINARY_NAMES = [ + n + "_" + for n in ( + list( + set(BINARY_NAMES) + - { + "logaddexp", + "logaddexp2", + "equal", + "fmin", + "minimum", + "maximum", + "fmax", + } + ) + ) +] + + +def _get_at_least_one_mask(a, b): + if not is_masked_tensor(a) and not is_masked_tensor(b): + raise TypeError("At least one of `a` and `b` must be a MaskedTensor") + if not _masks_match(a, b): + raise ValueError("a and b must have matching masks") + if is_masked_tensor(a): + return a.get_mask() + return b.get_mask() + + +def _binary_helper(fn, args, kwargs, inplace): + if len(kwargs) != 0: + raise ValueError("len(kwargs) must equal 0") + for a in args[2:]: + if torch.is_tensor(a): + raise TypeError("MaskedTensor binary ops do not support Tensor arguments aside from the lhs and rhs") + + if not _masks_match(*args[:2]): + raise ValueError( + "Input masks must match. If you need support for this, please open an issue on Github." + ) + + data_args, data_kwargs = _map_mt_args_kwargs( + args, kwargs, lambda x: x.get_data() + ) + mask_args, mask_kwargs = _map_mt_args_kwargs( + args, kwargs, lambda x: x.get_mask() + ) + + args0_layout = data_args[0].layout + same_layout = ( + (torch.is_tensor(data_args[1]) or is_masked_tensor(data_args[1])) and + (args0_layout == data_args[1].layout) + ) + + if args0_layout == torch.sparse_coo: + if same_layout: + if not _tensors_match(data_args[0].indices(), data_args[1].indices()): + raise ValueError( + "sparse_coo indices must match. If you need support for this, please open an issue on Github." + ) + if data_args[0].size() != data_args[1].size(): + raise ValueError("input1 and input2 must have the same size for binary functions.") + + data_args[1] = data_args[1].values() + + i = data_args[0].indices() + size = data_args[0].size() + data_args[0] = data_args[0].values() + v = fn(*data_args) + result_data = torch.sparse_coo_tensor(i, v, size) + + elif args0_layout == torch.sparse_csr: + if same_layout: + if not ( + _tensors_match(data_args[0].crow_indices(), data_args[1].crow_indices()) + and _tensors_match( + data_args[0].col_indices(), data_args[1].col_indices() + ) + ): + raise ValueError( + "sparse_csr indices must match. If you need support for this, please open an issue on Github." + ) + + data_args[1] = data_args[1].values() + + crow = data_args[0].crow_indices() + col = data_args[0].col_indices() + data_args[0] = data_args[0].values() + v = fn(*data_args) + result_data = torch.sparse_csr_tensor(crow, col, v) + + else: + result_data = fn(*data_args) + + if inplace: + args[0]._set_data_mask(result_data, mask_args[0]) + return args[0] + else: + result_mask = _get_at_least_one_mask(*args[:2]) + # sparse tensors don't have strides so we can only expand if the layout is strided + if args0_layout == torch.strided: + result_mask = result_mask.expand_as(result_data) + return _wrap_result(result_data, result_mask) + + +def _torch_binary(fn_name): + fn = getattr(torch.ops.aten, fn_name) + + def binary_fn(*args, **kwargs): + return _binary_helper(fn, args, kwargs, inplace=False) + + return binary_fn + + +def _torch_inplace_binary(fn_name): + fn = getattr(torch.ops.aten, fn_name) + + def binary_fn(*args, **kwargs): + return _binary_helper(fn, args, kwargs, inplace=True) + + return binary_fn + + +NATIVE_BINARY_MAP = { + getattr(torch.ops.aten, name): _torch_binary(name) for name in BINARY_NAMES +} +NATIVE_INPLACE_BINARY_MAP = { + getattr(torch.ops.aten, name): _torch_inplace_binary(name) + for name in INPLACE_BINARY_NAMES +} + +NATIVE_BINARY_FNS = list(NATIVE_BINARY_MAP.keys()) +NATIVE_INPLACE_BINARY_FNS = list(NATIVE_INPLACE_BINARY_MAP.keys()) + + +def _is_native_binary(fn): + return fn in NATIVE_BINARY_FNS or fn in NATIVE_INPLACE_BINARY_FNS + + +def _apply_native_binary(fn, *args, **kwargs): + if fn in NATIVE_BINARY_FNS: + return NATIVE_BINARY_MAP[fn](*args, **kwargs) + if fn in NATIVE_INPLACE_BINARY_FNS: + return NATIVE_INPLACE_BINARY_MAP[fn](*args, **kwargs) + return NotImplemented diff --git a/shared/package-files/2f/2f97b677bc9be78735ef524653c83fafa1b8a880f1e00bf6f01635da28b04fac/blob b/shared/package-files/2f/2f97b677bc9be78735ef524653c83fafa1b8a880f1e00bf6f01635da28b04fac/blob new file mode 100644 index 0000000000000000000000000000000000000000..334cb3d0afa7c50ab89a22e83dd9c1e8470feed0 --- /dev/null +++ b/shared/package-files/2f/2f97b677bc9be78735ef524653c83fafa1b8a880f1e00bf6f01635da28b04fac/blob @@ -0,0 +1,8 @@ +from typing import Any + +from ._compat import to_unicode as to_unicode +from .filesystem import get_filesystem_encoding as get_filesystem_encoding + +can_rename_open_file: Any + +def rename(src, dst): ... diff --git a/shared/package-files/2f/2f992c244d0cfce472d075184b418be2fe788da8509948a6604f2a035016ae58/blob b/shared/package-files/2f/2f992c244d0cfce472d075184b418be2fe788da8509948a6604f2a035016ae58/blob new file mode 100644 index 0000000000000000000000000000000000000000..0a02b670982b6157a6989e1b8252c7c2cdc59087 --- /dev/null +++ b/shared/package-files/2f/2f992c244d0cfce472d075184b418be2fe788da8509948a6604f2a035016ae58/blob @@ -0,0 +1,277 @@ +"""This file implements the IndexPropagation ops handler, which wraps an +underlying handler to add a limited form of constant propagation, as well as +propagation of sympy expressions downstream of ops.index_expr calls. + +For example, say we have the IR: + + tmp0 = ops.index_expr(x, torch.int32) + tmp1 = ops.constant(2, torch.int32) + tmp2 = ops.mul(tmp0, tmp1) + tmp3 = ops.indirect_indexing(tmp2, x_size) + tmp4 = ops.load("buf0", tmp3) + +The underlying handler would just see: + + ops.load("buf0", x * 2) + +This is limited by the set of operators handled in the sympy expression +printers. So simple operations like minimum and maximum cannot be translated to +SymPy expressions yet, despite sympy.Min and sympy.Max existing. + +""" +import itertools +from dataclasses import dataclass +from typing import Any, Callable, Dict, Literal, Optional, overload, Tuple, Union + +import sympy + +from typing_extensions import TypeAlias + +import torch +from torch._prims_common import is_boolean_dtype, is_integer_dtype +from torch.utils._sympy.functions import FloorDiv, ModularIndexing, Where + + +@dataclass +class TypedExpr: + """A SymPy expression with associated type""" + + expr: sympy.Expr + dtype: torch.dtype + + +class SymPyOps: + """An ops handler where all IR values are SymPy expressions + + When a value cannot be represented as a SymPy expression, the method is + either not defined, or returns NotImplemented + + """ + + @staticmethod + def identity(value: Any) -> Any: + return value + + @staticmethod + def constant(value: Union[int, float, bool], dtype: torch.dtype) -> TypedExpr: + if is_boolean_dtype(dtype): + expr = sympy.Integer(bool(value)) + elif is_integer_dtype(dtype): + expr = sympy.Integer(int(value)) + else: + expr = sympy.Float(float(value)) + return TypedExpr(expr, dtype) + + @staticmethod + def index_expr(value: sympy.Expr, dtype: torch.dtype) -> Union[int, TypedExpr]: + if isinstance(value, int): + value = sympy.Integer(value) + return TypedExpr(value, dtype) + + @staticmethod + def to_dtype( + value: Any, dtype: torch.dtype, src_dtype: Optional[torch.dtype] = None + ) -> Union[int, TypedExpr]: + if isinstance(value.expr, (sympy.Integer, sympy.Float)): + return SymPyOps.constant(value.expr, dtype) + elif is_integer_dtype(dtype) and is_integer_dtype(value.dtype): + return SymPyOps.index_expr(value.expr, dtype) + else: + # TODO: Inductor doesn't handle floating point in sympy expressions well at the moment + return NotImplemented + + @staticmethod + def square(x: TypedExpr) -> TypedExpr: + return TypedExpr(x.expr * x.expr, x.dtype) + + @staticmethod + def add(x: TypedExpr, y: TypedExpr) -> TypedExpr: + result_type = torch.promote_types(x.dtype, y.dtype) + return TypedExpr(x.expr + y.expr, result_type) + + @staticmethod + def sub(x: TypedExpr, y: TypedExpr) -> TypedExpr: + result_type = torch.promote_types(x.dtype, y.dtype) + return TypedExpr(x.expr - y.expr, result_type) + + @staticmethod + def mul(x: TypedExpr, y: TypedExpr) -> TypedExpr: + result_type = torch.promote_types(x.dtype, y.dtype) + return TypedExpr(x.expr * y.expr, result_type) + + @staticmethod + def neg(x: TypedExpr) -> TypedExpr: + return TypedExpr(-x.expr, x.dtype) + + @staticmethod + def floordiv(x: TypedExpr, y: TypedExpr) -> TypedExpr: + result_type = torch.promote_types(x.dtype, y.dtype) + if not is_integer_dtype(result_type): + return NotImplemented + + return TypedExpr(FloorDiv(x.expr, y.expr), result_type) + + @staticmethod + def mod(x: TypedExpr, y: TypedExpr) -> Optional[TypedExpr]: + result_type = torch.promote_types(x.dtype, y.dtype) + if not is_integer_dtype(result_type): + return NotImplemented + + result_expr = ModularIndexing(x.expr, sympy.Integer(1), y.expr) + return TypedExpr(result_expr, result_type) + + @staticmethod + def remainder(x: TypedExpr, y: TypedExpr) -> Optional[TypedExpr]: + result_type = torch.promote_types(x.dtype, y.dtype) + if not is_integer_dtype(result_type): + return NotImplemented + # In these cases, remainder in Python == remainder in C++, so this transformation + # is sound + if ( + x.expr.is_nonnegative is not None + and x.expr.is_nonnegative == y.expr.is_positive + ): + result_expr = ModularIndexing(x.expr, sympy.Integer(1), y.expr) + return TypedExpr(result_expr, result_type) + return NotImplemented + + @staticmethod + def minimum(x: TypedExpr, y: TypedExpr) -> TypedExpr: + result_type = torch.promote_types(x.dtype, y.dtype) + return TypedExpr(sympy.Min(x.expr, y.expr), result_type) + + @staticmethod + def maximum(x: TypedExpr, y: TypedExpr) -> TypedExpr: + result_type = torch.promote_types(x.dtype, y.dtype) + return TypedExpr(sympy.Max(x.expr, y.expr), result_type) + + +@dataclass +class IndexPropVar: + value: Any # Either an IR value, or TypedExpr if is_symbolic is true + is_symbolic: bool = False + + @staticmethod + def new_symbolic(expr: TypedExpr) -> "IndexPropVar": + return IndexPropVar(expr, is_symbolic=True) + + def __post_init__(self): + assert not self.is_symbolic or isinstance( + self.value, TypedExpr + ), "Symbolic IndexPropVar must contain a TypedExpr" + + +IndexPropResult: TypeAlias = Union[IndexPropVar, Tuple["IndexPropResult", ...]] + + +class IndexPropagation: + """Ops wrapper that tries to propagate constant and index_expr values through the computation. + + This aims to maximize the compile time simplification possible, and convert + indirect indexing from arange into normal static indexing. + + """ + + def __init__(self, inner: Any): + self._inner = inner + + def materialize_expr(self, expr: sympy.Expr, dtype: torch.dtype) -> Any: + # Construct a new constant/index_expr from the SymPy expression + if isinstance(expr, sympy.Integer): + return self._inner.constant(int(expr), dtype) + elif expr.is_number: + return self._inner.constant(float(expr), dtype) + return self._inner.index_expr(expr, dtype) + + def unwrap(self, a: Union[Any, IndexPropVar]) -> Any: + if isinstance(a, (list, tuple)): + return tuple(self.unwrap(v) for v in a) + + if not isinstance(a, IndexPropVar): + return a + + # Prefer the sympy representation if possible + if a.is_symbolic: + return self.materialize_expr(a.value.expr, a.value.dtype) + + return a.value + + def wrap(self, a) -> IndexPropResult: + if isinstance(a, (list, tuple)): + return tuple(self.wrap(v) for v in a) + return IndexPropVar(a) + + @overload + def fallback( + self, + name: Literal["indirect_indexing"], + args: Tuple[Any, ...], + kwargs: Dict[str, Any], + ) -> IndexPropVar: + ... + + @overload + def fallback( + self, name: str, args: Tuple[Any, ...], kwargs: Dict[str, Any] + ) -> IndexPropResult: + ... + + def fallback( + self, name: str, args: Tuple[Any, ...], kwargs: Dict[str, Any] + ) -> IndexPropResult: + # Fallback to the wrapped handler + new_args = [self.unwrap(a) for a in args] + new_kwargs = {k: self.unwrap(v) for k, v in kwargs.items()} + return self.wrap(getattr(self._inner, name)(*new_args, **new_kwargs)) + + def propagate_sympy( + self, name: str, args: Tuple[Any, ...], kwargs: Dict[str, Any] + ) -> IndexPropResult: + # Build a new SymPy expression from this ops call + def unwrap(a: Union[Any, IndexPropVar]) -> Any: + if not isinstance(a, IndexPropVar): + return a + return a.value + + new_args = [unwrap(a) for a in args] + new_kwargs = {k: unwrap(v) for k, v in kwargs.items()} + new_expr = getattr(SymPyOps, name)(*new_args, **new_kwargs) + is_valid_expr = new_expr is not NotImplemented and ( + # Inductor doesn't expect floating point in sympy expressions, but + # allow floating point constants to be propagated + isinstance(new_expr.expr, sympy.Number) + or new_expr.expr.is_integer + ) + if not is_valid_expr: + return self.fallback(name, args, kwargs) + return IndexPropVar.new_symbolic(new_expr) + + def __getattr__(self, name: str) -> Callable[..., IndexPropResult]: + def inner(*args: Any, **kwargs: Any) -> IndexPropResult: + if not hasattr(SymPyOps, name): + return self.fallback(name, args, kwargs) + + var_arguments = [ + a + for a in itertools.chain(args, kwargs.values()) + if isinstance(a, IndexPropVar) + ] + if not all(v.is_symbolic for v in var_arguments): + return self.fallback(name, args, kwargs) + + return self.propagate_sympy(name, args, kwargs) + + return inner + + def indirect_indexing( + self, index: Union[Any, IndexPropVar], size: Any, check: bool = True + ) -> Any: + # nb. We do index + Where(...) rather than Where(idx >= 0, idx, idx + sz) because we don't have CSE + # for SymPy expressions, so we don't want to repeat idx too much + + # indirect_indexing returns a sympy value, so no need to wrap in IndexPropVar here + if isinstance(index, IndexPropVar) and index.is_symbolic: + # If we are turning a indirect indexing into direct, we need to wrap it. + index = index.value.expr + return index + Where(index >= 0, 0, size) + return self.fallback("indirect_indexing", (index, size, check), {}).value diff --git a/shared/package-files/2f/2f9f003b8a6119007419d6485fadfbc59b2d235bb230d35f66986f5a16fa9ba6/blob b/shared/package-files/2f/2f9f003b8a6119007419d6485fadfbc59b2d235bb230d35f66986f5a16fa9ba6/blob new file mode 100644 index 0000000000000000000000000000000000000000..07b1264dfbb80b0bebd9b602a21700f21079aae9 --- /dev/null +++ b/shared/package-files/2f/2f9f003b8a6119007419d6485fadfbc59b2d235bb230d35f66986f5a16fa9ba6/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API replication_pad3d_out { + using schema = at::Tensor & (const at::Tensor &, c10::SymIntArrayRef, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::replication_pad3d") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "replication_pad3d.out(Tensor self, SymInt[6] padding, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, c10::SymIntArrayRef padding, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, c10::SymIntArrayRef padding, at::Tensor & out); +}; + +struct TORCH_API replication_pad3d { + using schema = at::Tensor (const at::Tensor &, c10::SymIntArrayRef); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::replication_pad3d") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "replication_pad3d(Tensor self, SymInt[6] padding) -> Tensor") + static at::Tensor call(const at::Tensor & self, c10::SymIntArrayRef padding); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, c10::SymIntArrayRef padding); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/2f/2f9f107be7aa4081451fa61086d4815790050d2fb8d1d75f45a06e5d1394a4e5/blob b/shared/package-files/2f/2f9f107be7aa4081451fa61086d4815790050d2fb8d1d75f45a06e5d1394a4e5/blob new file mode 100644 index 0000000000000000000000000000000000000000..22a1209a52adf3814701f3f60b22ace6de2fb8cc --- /dev/null +++ b/shared/package-files/2f/2f9f107be7aa4081451fa61086d4815790050d2fb8d1d75f45a06e5d1394a4e5/blob @@ -0,0 +1,27 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeMetaFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace meta { + +struct TORCH_API structured_tanh_backward : public TensorIteratorBase { + + + void meta(const at::Tensor & grad_output, const at::Tensor & output); +}; + +} // namespace native +} // namespace at diff --git a/shared/package-files/2f/2f9f65643072e7c5dfeb11e6af96b27a7589e0771bece0f0d7f1b3a797d9c018/blob b/shared/package-files/2f/2f9f65643072e7c5dfeb11e6af96b27a7589e0771bece0f0d7f1b3a797d9c018/blob new file mode 100644 index 0000000000000000000000000000000000000000..a8bfb331b6bb855a076c85a9caeb421f2785ed66 --- /dev/null +++ b/shared/package-files/2f/2f9f65643072e7c5dfeb11e6af96b27a7589e0771bece0f0d7f1b3a797d9c018/blob @@ -0,0 +1,146 @@ +#pragma once + +#include + +#ifdef __cplusplus + +#include +#include +#include + +namespace py = pybind11; + +extern "C" { + +#endif + +// Flag to just run a frame normally +#define SKIP_CODE ((void*)0x1) + +// Points to the extra scratch space on the code object +extern Py_ssize_t extra_index; + +// function to call when cache lookup errors +extern PyObject* guard_error_hook; + +typedef PyObject FrameState; +typedef struct CacheEntry CacheEntry; + +// ExtraState encasulates CacheEntry and FrameState. ExtraState is the highest +// level of abstraction of what is stored on the extra code object. Previously, +// we saved different parts on different extra indexes. We prefer this way +// because of cleaner abstraction and faster SetExtra access. + +#ifdef __cplusplus + +typedef struct VISIBILITY_HIDDEN ExtraState { + // List of cache entries for compiled code objects + std::list cache_entry_list; + // Frame state to detect dynamic shape dims + py::dict frame_state; + + CacheEntry* get_first_entry(); + void move_to_front(CacheEntry* cache_entry); + void invalidate(CacheEntry* cache_entry); +} ExtraState; + +#else + +typedef struct ExtraState ExtraState; + +#endif + +// Helper to extra the cache_entry from the extra state. +// Ownership contract +// args +// - extra_state: Borrowed +// return +// - CacheEntry: Borrowed. +CacheEntry* extract_cache_entry(ExtraState* extra_state); + +// Returns either the previously stored frame state or an empty dict. +// Ownership contract +// args +// - extra_state: Borrowed +// return +// - extra_state->frame_state: Borrowed. +FrameState* extract_frame_state(ExtraState* extra_state); + +// Ownership contract +// args +// - code: Borrowed +// return +// - extra_state: Borrowed. +ExtraState* get_extra_state(PyCodeObject* code); + +// This is passed as freefunc to _PyEval_RequestCodeExtraIndex. This acts as a +// deleter for the object on extra scratch space. This function is called +// internally in _PyCode_SetExtra and also during the code deallocation. + +// Destroys the extra state by deleting cache_entry, frame state and finally +// freeing the constructed extra state. + +// Developer note - You should not call this function directly. This is called +// directly inside set_extra_state. If you are in a situation trying to call +// this function, consider if set_extra_state should be called. +void destroy_extra_state(void* obj); + +// Clears the existing object sitting on the extra scratch spance and sets it +// up with the new state. Note that _PyCode_SetExtra calls the +// destroy_extra_state deleter internally, and therefore we don't call it +// explicity here. + +// Ownership contract +// args +// - extra_state: Stolen +// return +// - there is no return, but the extra_state is stolen, so it becomes +// set_extra_state responsibility to clean it up. It will be deleted during +// the reset_code/skip, when the set_extra_state is called with +// NULL/SKIP_CODE. + +// Invariant - Dont set the extra state for the extra state that is already on +// the code object. Otherwise, we will first free up the old extra state +// (which is also the new extra state) and write something invalid on the +// scratch space. +void set_extra_state(PyCodeObject* code, ExtraState* extra_state); + +// Creates a new extra state and put it on the extra scrach space of the code +// object. + +// Ownership contract +// args +// - code: Borrowed +// return: +// - extra_state: New reference. +// These references are then further passed to set_extra_state which becomes +// the final owner of these references. +ExtraState* init_and_set_extra_state(PyCodeObject* code); + +// Lookup the cache held by extra_state. +// Ownership contract +// args +// - extra_state: Borrowed +// - f_locals: Borrowed +// return: +// - Py_None or PyCodeObject: Borrowed reference. +PyObject* lookup(ExtraState* extra_state, PyObject* f_locals); + +// Create a new cache entry at extra_state holding on to guarded_code. +// Ownership contract +// args +// - extra_state: Borrowed +// - guarded_code: Borrowed +// return: +// - cache_entry: Borrowed reference +CacheEntry* create_cache_entry(ExtraState* extra_state, PyObject* guraded_code); + +#ifdef __cplusplus + +} // extern "C" + +// Returns the list of CacheEntry corresponding to code_obj. +// Warning: returns references whose lifetimes are controlled by C++ +py::list _debug_get_cache_entry_list(const py::handle& code_obj); + +#endif diff --git a/shared/package-files/2f/2fa49b807e2e967a93295bc052d68a0804d7e1760b34afabb365008157bed51c/blob b/shared/package-files/2f/2fa49b807e2e967a93295bc052d68a0804d7e1760b34afabb365008157bed51c/blob new file mode 100644 index 0000000000000000000000000000000000000000..77eaf85a901df4bea09b19ae639e80f3fddcb2ed --- /dev/null +++ b/shared/package-files/2f/2fa49b807e2e967a93295bc052d68a0804d7e1760b34afabb365008157bed51c/blob @@ -0,0 +1,750 @@ +""" +Python code printers + +This module contains Python code printers for plain Python as well as NumPy & SciPy enabled code. +""" +from collections import defaultdict +from itertools import chain +from sympy.core import S +from sympy.core.mod import Mod +from .precedence import precedence +from .codeprinter import CodePrinter + +_kw = { + 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', + 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', + 'is', 'lambda', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', + 'with', 'yield', 'None', 'False', 'nonlocal', 'True' +} + +_known_functions = { + 'Abs': 'abs', + 'Min': 'min', + 'Max': 'max', +} +_known_functions_math = { + 'acos': 'acos', + 'acosh': 'acosh', + 'asin': 'asin', + 'asinh': 'asinh', + 'atan': 'atan', + 'atan2': 'atan2', + 'atanh': 'atanh', + 'ceiling': 'ceil', + 'cos': 'cos', + 'cosh': 'cosh', + 'erf': 'erf', + 'erfc': 'erfc', + 'exp': 'exp', + 'expm1': 'expm1', + 'factorial': 'factorial', + 'floor': 'floor', + 'gamma': 'gamma', + 'hypot': 'hypot', + 'loggamma': 'lgamma', + 'log': 'log', + 'ln': 'log', + 'log10': 'log10', + 'log1p': 'log1p', + 'log2': 'log2', + 'sin': 'sin', + 'sinh': 'sinh', + 'Sqrt': 'sqrt', + 'tan': 'tan', + 'tanh': 'tanh' +} # Not used from ``math``: [copysign isclose isfinite isinf isnan ldexp frexp pow modf +# radians trunc fmod fsum gcd degrees fabs] +_known_constants_math = { + 'Exp1': 'e', + 'Pi': 'pi', + 'E': 'e', + 'Infinity': 'inf', + 'NaN': 'nan', + 'ComplexInfinity': 'nan' +} + +def _print_known_func(self, expr): + known = self.known_functions[expr.__class__.__name__] + return '{name}({args})'.format(name=self._module_format(known), + args=', '.join((self._print(arg) for arg in expr.args))) + + +def _print_known_const(self, expr): + known = self.known_constants[expr.__class__.__name__] + return self._module_format(known) + + +class AbstractPythonCodePrinter(CodePrinter): + printmethod = "_pythoncode" + language = "Python" + reserved_words = _kw + modules = None # initialized to a set in __init__ + tab = ' ' + _kf = dict(chain( + _known_functions.items(), + [(k, 'math.' + v) for k, v in _known_functions_math.items()] + )) + _kc = {k: 'math.'+v for k, v in _known_constants_math.items()} + _operators = {'and': 'and', 'or': 'or', 'not': 'not'} + _default_settings = dict( + CodePrinter._default_settings, + user_functions={}, + precision=17, + inline=True, + fully_qualified_modules=True, + contract=False, + standard='python3', + ) + + def __init__(self, settings=None): + super().__init__(settings) + + # Python standard handler + std = self._settings['standard'] + if std is None: + import sys + std = 'python{}'.format(sys.version_info.major) + if std != 'python3': + raise ValueError('Only Python 3 is supported.') + self.standard = std + + self.module_imports = defaultdict(set) + + # Known functions and constants handler + self.known_functions = dict(self._kf, **(settings or {}).get( + 'user_functions', {})) + self.known_constants = dict(self._kc, **(settings or {}).get( + 'user_constants', {})) + + def _declare_number_const(self, name, value): + return "%s = %s" % (name, value) + + def _module_format(self, fqn, register=True): + parts = fqn.split('.') + if register and len(parts) > 1: + self.module_imports['.'.join(parts[:-1])].add(parts[-1]) + + if self._settings['fully_qualified_modules']: + return fqn + else: + return fqn.split('(')[0].split('[')[0].split('.')[-1] + + def _format_code(self, lines): + return lines + + def _get_statement(self, codestring): + return "{}".format(codestring) + + def _get_comment(self, text): + return " # {}".format(text) + + def _expand_fold_binary_op(self, op, args): + """ + This method expands a fold on binary operations. + + ``functools.reduce`` is an example of a folded operation. + + For example, the expression + + `A + B + C + D` + + is folded into + + `((A + B) + C) + D` + """ + if len(args) == 1: + return self._print(args[0]) + else: + return "%s(%s, %s)" % ( + self._module_format(op), + self._expand_fold_binary_op(op, args[:-1]), + self._print(args[-1]), + ) + + def _expand_reduce_binary_op(self, op, args): + """ + This method expands a reductin on binary operations. + + Notice: this is NOT the same as ``functools.reduce``. + + For example, the expression + + `A + B + C + D` + + is reduced into: + + `(A + B) + (C + D)` + """ + if len(args) == 1: + return self._print(args[0]) + else: + N = len(args) + Nhalf = N // 2 + return "%s(%s, %s)" % ( + self._module_format(op), + self._expand_reduce_binary_op(args[:Nhalf]), + self._expand_reduce_binary_op(args[Nhalf:]), + ) + + def _print_NaN(self, expr): + return "float('nan')" + + def _print_Infinity(self, expr): + return "float('inf')" + + def _print_NegativeInfinity(self, expr): + return "float('-inf')" + + def _print_ComplexInfinity(self, expr): + return self._print_NaN(expr) + + def _print_Mod(self, expr): + PREC = precedence(expr) + return ('{} % {}'.format(*(self.parenthesize(x, PREC) for x in expr.args))) + + def _print_Piecewise(self, expr): + result = [] + i = 0 + for arg in expr.args: + e = arg.expr + c = arg.cond + if i == 0: + result.append('(') + result.append('(') + result.append(self._print(e)) + result.append(')') + result.append(' if ') + result.append(self._print(c)) + result.append(' else ') + i += 1 + result = result[:-1] + if result[-1] == 'True': + result = result[:-2] + result.append(')') + else: + result.append(' else None)') + return ''.join(result) + + def _print_Relational(self, expr): + "Relational printer for Equality and Unequality" + op = { + '==' :'equal', + '!=' :'not_equal', + '<' :'less', + '<=' :'less_equal', + '>' :'greater', + '>=' :'greater_equal', + } + if expr.rel_op in op: + lhs = self._print(expr.lhs) + rhs = self._print(expr.rhs) + return '({lhs} {op} {rhs})'.format(op=expr.rel_op, lhs=lhs, rhs=rhs) + return super()._print_Relational(expr) + + def _print_ITE(self, expr): + from sympy.functions.elementary.piecewise import Piecewise + return self._print(expr.rewrite(Piecewise)) + + def _print_Sum(self, expr): + loops = ( + 'for {i} in range({a}, {b}+1)'.format( + i=self._print(i), + a=self._print(a), + b=self._print(b)) + for i, a, b in expr.limits) + return '(builtins.sum({function} {loops}))'.format( + function=self._print(expr.function), + loops=' '.join(loops)) + + def _print_ImaginaryUnit(self, expr): + return '1j' + + def _print_KroneckerDelta(self, expr): + a, b = expr.args + + return '(1 if {a} == {b} else 0)'.format( + a = self._print(a), + b = self._print(b) + ) + + def _print_MatrixBase(self, expr): + name = expr.__class__.__name__ + func = self.known_functions.get(name, name) + return "%s(%s)" % (func, self._print(expr.tolist())) + + _print_SparseRepMatrix = \ + _print_MutableSparseMatrix = \ + _print_ImmutableSparseMatrix = \ + _print_Matrix = \ + _print_DenseMatrix = \ + _print_MutableDenseMatrix = \ + _print_ImmutableMatrix = \ + _print_ImmutableDenseMatrix = \ + lambda self, expr: self._print_MatrixBase(expr) + + def _indent_codestring(self, codestring): + return '\n'.join([self.tab + line for line in codestring.split('\n')]) + + def _print_FunctionDefinition(self, fd): + body = '\n'.join((self._print(arg) for arg in fd.body)) + return "def {name}({parameters}):\n{body}".format( + name=self._print(fd.name), + parameters=', '.join([self._print(var.symbol) for var in fd.parameters]), + body=self._indent_codestring(body) + ) + + def _print_While(self, whl): + body = '\n'.join((self._print(arg) for arg in whl.body)) + return "while {cond}:\n{body}".format( + cond=self._print(whl.condition), + body=self._indent_codestring(body) + ) + + def _print_Declaration(self, decl): + return '%s = %s' % ( + self._print(decl.variable.symbol), + self._print(decl.variable.value) + ) + + def _print_Return(self, ret): + arg, = ret.args + return 'return %s' % self._print(arg) + + def _print_Print(self, prnt): + print_args = ', '.join((self._print(arg) for arg in prnt.print_args)) + if prnt.format_string != None: # Must be '!= None', cannot be 'is not None' + print_args = '{} % ({})'.format( + self._print(prnt.format_string), print_args) + if prnt.file != None: # Must be '!= None', cannot be 'is not None' + print_args += ', file=%s' % self._print(prnt.file) + + return 'print(%s)' % print_args + + def _print_Stream(self, strm): + if str(strm.name) == 'stdout': + return self._module_format('sys.stdout') + elif str(strm.name) == 'stderr': + return self._module_format('sys.stderr') + else: + return self._print(strm.name) + + def _print_NoneToken(self, arg): + return 'None' + + def _hprint_Pow(self, expr, rational=False, sqrt='math.sqrt'): + """Printing helper function for ``Pow`` + + Notes + ===== + + This preprocesses the ``sqrt`` as math formatter and prints division + + Examples + ======== + + >>> from sympy import sqrt + >>> from sympy.printing.pycode import PythonCodePrinter + >>> from sympy.abc import x + + Python code printer automatically looks up ``math.sqrt``. + + >>> printer = PythonCodePrinter() + >>> printer._hprint_Pow(sqrt(x), rational=True) + 'x**(1/2)' + >>> printer._hprint_Pow(sqrt(x), rational=False) + 'math.sqrt(x)' + >>> printer._hprint_Pow(1/sqrt(x), rational=True) + 'x**(-1/2)' + >>> printer._hprint_Pow(1/sqrt(x), rational=False) + '1/math.sqrt(x)' + >>> printer._hprint_Pow(1/x, rational=False) + '1/x' + >>> printer._hprint_Pow(1/x, rational=True) + 'x**(-1)' + + Using sqrt from numpy or mpmath + + >>> printer._hprint_Pow(sqrt(x), sqrt='numpy.sqrt') + 'numpy.sqrt(x)' + >>> printer._hprint_Pow(sqrt(x), sqrt='mpmath.sqrt') + 'mpmath.sqrt(x)' + + See Also + ======== + + sympy.printing.str.StrPrinter._print_Pow + """ + PREC = precedence(expr) + + if expr.exp == S.Half and not rational: + func = self._module_format(sqrt) + arg = self._print(expr.base) + return '{func}({arg})'.format(func=func, arg=arg) + + if expr.is_commutative and not rational: + if -expr.exp is S.Half: + func = self._module_format(sqrt) + num = self._print(S.One) + arg = self._print(expr.base) + return f"{num}/{func}({arg})" + if expr.exp is S.NegativeOne: + num = self._print(S.One) + arg = self.parenthesize(expr.base, PREC, strict=False) + return f"{num}/{arg}" + + + base_str = self.parenthesize(expr.base, PREC, strict=False) + exp_str = self.parenthesize(expr.exp, PREC, strict=False) + return "{}**{}".format(base_str, exp_str) + + +class ArrayPrinter: + + def _arrayify(self, indexed): + from sympy.tensor.array.expressions.from_indexed_to_array import convert_indexed_to_array + try: + return convert_indexed_to_array(indexed) + except Exception: + return indexed + + def _get_einsum_string(self, subranks, contraction_indices): + letters = self._get_letter_generator_for_einsum() + contraction_string = "" + counter = 0 + d = {j: min(i) for i in contraction_indices for j in i} + indices = [] + for rank_arg in subranks: + lindices = [] + for i in range(rank_arg): + if counter in d: + lindices.append(d[counter]) + else: + lindices.append(counter) + counter += 1 + indices.append(lindices) + mapping = {} + letters_free = [] + letters_dum = [] + for i in indices: + for j in i: + if j not in mapping: + l = next(letters) + mapping[j] = l + else: + l = mapping[j] + contraction_string += l + if j in d: + if l not in letters_dum: + letters_dum.append(l) + else: + letters_free.append(l) + contraction_string += "," + contraction_string = contraction_string[:-1] + return contraction_string, letters_free, letters_dum + + def _get_letter_generator_for_einsum(self): + for i in range(97, 123): + yield chr(i) + for i in range(65, 91): + yield chr(i) + raise ValueError("out of letters") + + def _print_ArrayTensorProduct(self, expr): + letters = self._get_letter_generator_for_einsum() + contraction_string = ",".join(["".join([next(letters) for j in range(i)]) for i in expr.subranks]) + return '%s("%s", %s)' % ( + self._module_format(self._module + "." + self._einsum), + contraction_string, + ", ".join([self._print(arg) for arg in expr.args]) + ) + + def _print_ArrayContraction(self, expr): + from sympy.tensor.array.expressions.array_expressions import ArrayTensorProduct + base = expr.expr + contraction_indices = expr.contraction_indices + + if isinstance(base, ArrayTensorProduct): + elems = ",".join(["%s" % (self._print(arg)) for arg in base.args]) + ranks = base.subranks + else: + elems = self._print(base) + ranks = [len(base.shape)] + + contraction_string, letters_free, letters_dum = self._get_einsum_string(ranks, contraction_indices) + + if not contraction_indices: + return self._print(base) + if isinstance(base, ArrayTensorProduct): + elems = ",".join(["%s" % (self._print(arg)) for arg in base.args]) + else: + elems = self._print(base) + return "%s(\"%s\", %s)" % ( + self._module_format(self._module + "." + self._einsum), + "{}->{}".format(contraction_string, "".join(sorted(letters_free))), + elems, + ) + + def _print_ArrayDiagonal(self, expr): + from sympy.tensor.array.expressions.array_expressions import ArrayTensorProduct + diagonal_indices = list(expr.diagonal_indices) + if isinstance(expr.expr, ArrayTensorProduct): + subranks = expr.expr.subranks + elems = expr.expr.args + else: + subranks = expr.subranks + elems = [expr.expr] + diagonal_string, letters_free, letters_dum = self._get_einsum_string(subranks, diagonal_indices) + elems = [self._print(i) for i in elems] + return '%s("%s", %s)' % ( + self._module_format(self._module + "." + self._einsum), + "{}->{}".format(diagonal_string, "".join(letters_free+letters_dum)), + ", ".join(elems) + ) + + def _print_PermuteDims(self, expr): + return "%s(%s, %s)" % ( + self._module_format(self._module + "." + self._transpose), + self._print(expr.expr), + self._print(expr.permutation.array_form), + ) + + def _print_ArrayAdd(self, expr): + return self._expand_fold_binary_op(self._module + "." + self._add, expr.args) + + def _print_OneArray(self, expr): + return "%s((%s,))" % ( + self._module_format(self._module+ "." + self._ones), + ','.join(map(self._print,expr.args)) + ) + + def _print_ZeroArray(self, expr): + return "%s((%s,))" % ( + self._module_format(self._module+ "." + self._zeros), + ','.join(map(self._print,expr.args)) + ) + + def _print_Assignment(self, expr): + #XXX: maybe this needs to happen at a higher level e.g. at _print or + #doprint? + lhs = self._print(self._arrayify(expr.lhs)) + rhs = self._print(self._arrayify(expr.rhs)) + return "%s = %s" % ( lhs, rhs ) + + def _print_IndexedBase(self, expr): + return self._print_ArraySymbol(expr) + + +class PythonCodePrinter(AbstractPythonCodePrinter): + + def _print_sign(self, e): + return '(0.0 if {e} == 0 else {f}(1, {e}))'.format( + f=self._module_format('math.copysign'), e=self._print(e.args[0])) + + def _print_Not(self, expr): + PREC = precedence(expr) + return self._operators['not'] + self.parenthesize(expr.args[0], PREC) + + def _print_Indexed(self, expr): + base = expr.args[0] + index = expr.args[1:] + return "{}[{}]".format(str(base), ", ".join([self._print(ind) for ind in index])) + + def _print_Pow(self, expr, rational=False): + return self._hprint_Pow(expr, rational=rational) + + def _print_Rational(self, expr): + return '{}/{}'.format(expr.p, expr.q) + + def _print_Half(self, expr): + return self._print_Rational(expr) + + def _print_frac(self, expr): + return self._print_Mod(Mod(expr.args[0], 1)) + + def _print_Symbol(self, expr): + + name = super()._print_Symbol(expr) + + if name in self.reserved_words: + if self._settings['error_on_reserved']: + msg = ('This expression includes the symbol "{}" which is a ' + 'reserved keyword in this language.') + raise ValueError(msg.format(name)) + return name + self._settings['reserved_word_suffix'] + elif '{' in name: # Remove curly braces from subscripted variables + return name.replace('{', '').replace('}', '') + else: + return name + + _print_lowergamma = CodePrinter._print_not_supported + _print_uppergamma = CodePrinter._print_not_supported + _print_fresnelc = CodePrinter._print_not_supported + _print_fresnels = CodePrinter._print_not_supported + + +for k in PythonCodePrinter._kf: + setattr(PythonCodePrinter, '_print_%s' % k, _print_known_func) + +for k in _known_constants_math: + setattr(PythonCodePrinter, '_print_%s' % k, _print_known_const) + + +def pycode(expr, **settings): + """ Converts an expr to a string of Python code + + Parameters + ========== + + expr : Expr + A SymPy expression. + fully_qualified_modules : bool + Whether or not to write out full module names of functions + (``math.sin`` vs. ``sin``). default: ``True``. + standard : str or None, optional + Only 'python3' (default) is supported. + This parameter may be removed in the future. + + Examples + ======== + + >>> from sympy import pycode, tan, Symbol + >>> pycode(tan(Symbol('x')) + 1) + 'math.tan(x) + 1' + + """ + return PythonCodePrinter(settings).doprint(expr) + + +_not_in_mpmath = 'log1p log2'.split() +_in_mpmath = [(k, v) for k, v in _known_functions_math.items() if k not in _not_in_mpmath] +_known_functions_mpmath = dict(_in_mpmath, **{ + 'beta': 'beta', + 'frac': 'frac', + 'fresnelc': 'fresnelc', + 'fresnels': 'fresnels', + 'sign': 'sign', + 'loggamma': 'loggamma', + 'hyper': 'hyper', + 'meijerg': 'meijerg', + 'besselj': 'besselj', + 'bessely': 'bessely', + 'besseli': 'besseli', + 'besselk': 'besselk', +}) +_known_constants_mpmath = { + 'Exp1': 'e', + 'Pi': 'pi', + 'GoldenRatio': 'phi', + 'EulerGamma': 'euler', + 'Catalan': 'catalan', + 'NaN': 'nan', + 'Infinity': 'inf', + 'NegativeInfinity': 'ninf' +} + + +def _unpack_integral_limits(integral_expr): + """ helper function for _print_Integral that + - accepts an Integral expression + - returns a tuple of + - a list variables of integration + - a list of tuples of the upper and lower limits of integration + """ + integration_vars = [] + limits = [] + for integration_range in integral_expr.limits: + if len(integration_range) == 3: + integration_var, lower_limit, upper_limit = integration_range + else: + raise NotImplementedError("Only definite integrals are supported") + integration_vars.append(integration_var) + limits.append((lower_limit, upper_limit)) + return integration_vars, limits + + +class MpmathPrinter(PythonCodePrinter): + """ + Lambda printer for mpmath which maintains precision for floats + """ + printmethod = "_mpmathcode" + + language = "Python with mpmath" + + _kf = dict(chain( + _known_functions.items(), + [(k, 'mpmath.' + v) for k, v in _known_functions_mpmath.items()] + )) + _kc = {k: 'mpmath.'+v for k, v in _known_constants_mpmath.items()} + + def _print_Float(self, e): + # XXX: This does not handle setting mpmath.mp.dps. It is assumed that + # the caller of the lambdified function will have set it to sufficient + # precision to match the Floats in the expression. + + # Remove 'mpz' if gmpy is installed. + args = str(tuple(map(int, e._mpf_))) + return '{func}({args})'.format(func=self._module_format('mpmath.mpf'), args=args) + + + def _print_Rational(self, e): + return "{func}({p})/{func}({q})".format( + func=self._module_format('mpmath.mpf'), + q=self._print(e.q), + p=self._print(e.p) + ) + + def _print_Half(self, e): + return self._print_Rational(e) + + def _print_uppergamma(self, e): + return "{}({}, {}, {})".format( + self._module_format('mpmath.gammainc'), + self._print(e.args[0]), + self._print(e.args[1]), + self._module_format('mpmath.inf')) + + def _print_lowergamma(self, e): + return "{}({}, 0, {})".format( + self._module_format('mpmath.gammainc'), + self._print(e.args[0]), + self._print(e.args[1])) + + def _print_log2(self, e): + return '{0}({1})/{0}(2)'.format( + self._module_format('mpmath.log'), self._print(e.args[0])) + + def _print_log1p(self, e): + return '{}({})'.format( + self._module_format('mpmath.log1p'), self._print(e.args[0])) + + def _print_Pow(self, expr, rational=False): + return self._hprint_Pow(expr, rational=rational, sqrt='mpmath.sqrt') + + def _print_Integral(self, e): + integration_vars, limits = _unpack_integral_limits(e) + + return "{}(lambda {}: {}, {})".format( + self._module_format("mpmath.quad"), + ", ".join(map(self._print, integration_vars)), + self._print(e.args[0]), + ", ".join("(%s, %s)" % tuple(map(self._print, l)) for l in limits)) + + +for k in MpmathPrinter._kf: + setattr(MpmathPrinter, '_print_%s' % k, _print_known_func) + +for k in _known_constants_mpmath: + setattr(MpmathPrinter, '_print_%s' % k, _print_known_const) + + +class SymPyPrinter(AbstractPythonCodePrinter): + + language = "Python with SymPy" + + def _print_Function(self, expr): + mod = expr.func.__module__ or '' + return '%s(%s)' % (self._module_format(mod + ('.' if mod else '') + expr.func.__name__), + ', '.join((self._print(arg) for arg in expr.args))) + + def _print_Pow(self, expr, rational=False): + return self._hprint_Pow(expr, rational=rational, sqrt='sympy.sqrt') diff --git a/shared/package-files/2f/2fa534fa68c43127054659e59fc22696cbc09f38d8b11c1c57ca6983e417aee2/blob b/shared/package-files/2f/2fa534fa68c43127054659e59fc22696cbc09f38d8b11c1c57ca6983e417aee2/blob new file mode 100644 index 0000000000000000000000000000000000000000..2bf9ecce0247e9a195d134c82f3b3cf5d1c34759 --- /dev/null +++ b/shared/package-files/2f/2fa534fa68c43127054659e59fc22696cbc09f38d8b11c1c57ca6983e417aee2/blob @@ -0,0 +1,70 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version, +# but only if the requested major version is the same as the current one. +# The variable CVF_VERSION must be set before calling configure_file(). + + +set(PACKAGE_VERSION "1.5.5") + +if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) +else() + + if("1.5.5" MATCHES "^([0-9]+)\\.") + set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}") + if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0) + string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}") + endif() + else() + set(CVF_VERSION_MAJOR "1.5.5") + endif() + + if(PACKAGE_FIND_VERSION_RANGE) + # both endpoints of the range must have the expected major version + math (EXPR CVF_VERSION_MAJOR_NEXT "${CVF_VERSION_MAJOR} + 1") + if (NOT PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX_MAJOR STREQUAL CVF_VERSION_MAJOR) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX VERSION_LESS_EQUAL CVF_VERSION_MAJOR_NEXT))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + elseif(PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR + AND ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS_EQUAL PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE TRUE) + else() + set(PACKAGE_VERSION_COMPATIBLE FALSE) + endif() + else() + if(PACKAGE_FIND_VERSION_MAJOR STREQUAL CVF_VERSION_MAJOR) + set(PACKAGE_VERSION_COMPATIBLE TRUE) + else() + set(PACKAGE_VERSION_COMPATIBLE FALSE) + endif() + + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed project requested no architecture check, don't perform the check +if("FALSE") + return() +endif() + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/shared/package-files/2f/2fa6e23d9120ece2847b7e3cd0a0de7f3d9063797d59c51ed52217bb01b47a7e/blob b/shared/package-files/2f/2fa6e23d9120ece2847b7e3cd0a0de7f3d9063797d59c51ed52217bb01b47a7e/blob new file mode 100644 index 0000000000000000000000000000000000000000..2b40e647bb0e21a2d56a120d10b8427dfc2100a4 --- /dev/null +++ b/shared/package-files/2f/2fa6e23d9120ece2847b7e3cd0a0de7f3d9063797d59c51ed52217bb01b47a7e/blob @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor replication_pad1d_backward(const at::Tensor & grad_output, const at::Tensor & self, at::IntArrayRef padding); +TORCH_API at::Tensor replication_pad1d_backward_symint(const at::Tensor & grad_output, const at::Tensor & self, c10::SymIntArrayRef padding); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/shared/package-files/2f/2fa854123448867d8387ae410d789f0eb8171eebc1a004d3f3dfba758647ce0a/blob b/shared/package-files/2f/2fa854123448867d8387ae410d789f0eb8171eebc1a004d3f3dfba758647ce0a/blob new file mode 100644 index 0000000000000000000000000000000000000000..b51e0eef553acdf95bbc16c2a614968153361c73 --- /dev/null +++ b/shared/package-files/2f/2fa854123448867d8387ae410d789f0eb8171eebc1a004d3f3dfba758647ce0a/blob @@ -0,0 +1,1340 @@ +from sympy.assumptions.ask import Q +from sympy.assumptions.refine import refine +from sympy.core.numbers import oo +from sympy.core.relational import Equality, Eq, Ne +from sympy.core.singleton import S +from sympy.core.symbol import (Dummy, symbols) +from sympy.functions import Piecewise +from sympy.functions.elementary.trigonometric import cos, sin +from sympy.sets.sets import (Interval, Union) +from sympy.simplify.simplify import simplify +from sympy.logic.boolalg import ( + And, Boolean, Equivalent, ITE, Implies, Nand, Nor, Not, Or, + POSform, SOPform, Xor, Xnor, conjuncts, disjuncts, + distribute_or_over_and, distribute_and_over_or, + eliminate_implications, is_nnf, is_cnf, is_dnf, simplify_logic, + to_nnf, to_cnf, to_dnf, to_int_repr, bool_map, true, false, + BooleanAtom, is_literal, term_to_integer, + truth_table, as_Boolean, to_anf, is_anf, distribute_xor_over_and, + anf_coeffs, ANFform, bool_minterm, bool_maxterm, bool_monomial, + _check_pair, _convert_to_varsSOP, _convert_to_varsPOS, Exclusive, + gateinputcount) +from sympy.assumptions.cnf import CNF + +from sympy.testing.pytest import raises, XFAIL, slow + +from itertools import combinations, permutations, product + +A, B, C, D = symbols('A:D') +a, b, c, d, e, w, x, y, z = symbols('a:e w:z') + + +def test_overloading(): + """Test that |, & are overloaded as expected""" + + assert A & B == And(A, B) + assert A | B == Or(A, B) + assert (A & B) | C == Or(And(A, B), C) + assert A >> B == Implies(A, B) + assert A << B == Implies(B, A) + assert ~A == Not(A) + assert A ^ B == Xor(A, B) + + +def test_And(): + assert And() is true + assert And(A) == A + assert And(True) is true + assert And(False) is false + assert And(True, True) is true + assert And(True, False) is false + assert And(False, False) is false + assert And(True, A) == A + assert And(False, A) is false + assert And(True, True, True) is true + assert And(True, True, A) == A + assert And(True, False, A) is false + assert And(1, A) == A + raises(TypeError, lambda: And(2, A)) + raises(TypeError, lambda: And(A < 2, A)) + assert And(A < 1, A >= 1) is false + e = A > 1 + assert And(e, e.canonical) == e.canonical + g, l, ge, le = A > B, B < A, A >= B, B <= A + assert And(g, l, ge, le) == And(ge, g) + assert {And(*i) for i in permutations((l,g,le,ge))} == {And(ge, g)} + assert And(And(Eq(a, 0), Eq(b, 0)), And(Ne(a, 0), Eq(c, 0))) is false + + +def test_Or(): + assert Or() is false + assert Or(A) == A + assert Or(True) is true + assert Or(False) is false + assert Or(True, True) is true + assert Or(True, False) is true + assert Or(False, False) is false + assert Or(True, A) is true + assert Or(False, A) == A + assert Or(True, False, False) is true + assert Or(True, False, A) is true + assert Or(False, False, A) == A + assert Or(1, A) is true + raises(TypeError, lambda: Or(2, A)) + raises(TypeError, lambda: Or(A < 2, A)) + assert Or(A < 1, A >= 1) is true + e = A > 1 + assert Or(e, e.canonical) == e + g, l, ge, le = A > B, B < A, A >= B, B <= A + assert Or(g, l, ge, le) == Or(g, ge) + + +def test_Xor(): + assert Xor() is false + assert Xor(A) == A + assert Xor(A, A) is false + assert Xor(True, A, A) is true + assert Xor(A, A, A, A, A) == A + assert Xor(True, False, False, A, B) == ~Xor(A, B) + assert Xor(True) is true + assert Xor(False) is false + assert Xor(True, True) is false + assert Xor(True, False) is true + assert Xor(False, False) is false + assert Xor(True, A) == ~A + assert Xor(False, A) == A + assert Xor(True, False, False) is true + assert Xor(True, False, A) == ~A + assert Xor(False, False, A) == A + assert isinstance(Xor(A, B), Xor) + assert Xor(A, B, Xor(C, D)) == Xor(A, B, C, D) + assert Xor(A, B, Xor(B, C)) == Xor(A, C) + assert Xor(A < 1, A >= 1, B) == Xor(0, 1, B) == Xor(1, 0, B) + e = A > 1 + assert Xor(e, e.canonical) == Xor(0, 0) == Xor(1, 1) + + +def test_rewrite_as_And(): + expr = x ^ y + assert expr.rewrite(And) == (x | y) & (~x | ~y) + + +def test_rewrite_as_Or(): + expr = x ^ y + assert expr.rewrite(Or) == (x & ~y) | (y & ~x) + + +def test_rewrite_as_Nand(): + expr = (y & z) | (z & ~w) + assert expr.rewrite(Nand) == ~(~(y & z) & ~(z & ~w)) + + +def test_rewrite_as_Nor(): + expr = z & (y | ~w) + assert expr.rewrite(Nor) == ~(~z | ~(y | ~w)) + + +def test_Not(): + raises(TypeError, lambda: Not(True, False)) + assert Not(True) is false + assert Not(False) is true + assert Not(0) is true + assert Not(1) is false + assert Not(2) is false + + +def test_Nand(): + assert Nand() is false + assert Nand(A) == ~A + assert Nand(True) is false + assert Nand(False) is true + assert Nand(True, True) is false + assert Nand(True, False) is true + assert Nand(False, False) is true + assert Nand(True, A) == ~A + assert Nand(False, A) is true + assert Nand(True, True, True) is false + assert Nand(True, True, A) == ~A + assert Nand(True, False, A) is true + + +def test_Nor(): + assert Nor() is true + assert Nor(A) == ~A + assert Nor(True) is false + assert Nor(False) is true + assert Nor(True, True) is false + assert Nor(True, False) is false + assert Nor(False, False) is true + assert Nor(True, A) is false + assert Nor(False, A) == ~A + assert Nor(True, True, True) is false + assert Nor(True, True, A) is false + assert Nor(True, False, A) is false + + +def test_Xnor(): + assert Xnor() is true + assert Xnor(A) == ~A + assert Xnor(A, A) is true + assert Xnor(True, A, A) is false + assert Xnor(A, A, A, A, A) == ~A + assert Xnor(True) is false + assert Xnor(False) is true + assert Xnor(True, True) is true + assert Xnor(True, False) is false + assert Xnor(False, False) is true + assert Xnor(True, A) == A + assert Xnor(False, A) == ~A + assert Xnor(True, False, False) is false + assert Xnor(True, False, A) == A + assert Xnor(False, False, A) == ~A + + +def test_Implies(): + raises(ValueError, lambda: Implies(A, B, C)) + assert Implies(True, True) is true + assert Implies(True, False) is false + assert Implies(False, True) is true + assert Implies(False, False) is true + assert Implies(0, A) is true + assert Implies(1, 1) is true + assert Implies(1, 0) is false + assert A >> B == B << A + assert (A < 1) >> (A >= 1) == (A >= 1) + assert (A < 1) >> (S.One > A) is true + assert A >> A is true + + +def test_Equivalent(): + assert Equivalent(A, B) == Equivalent(B, A) == Equivalent(A, B, A) + assert Equivalent() is true + assert Equivalent(A, A) == Equivalent(A) is true + assert Equivalent(True, True) == Equivalent(False, False) is true + assert Equivalent(True, False) == Equivalent(False, True) is false + assert Equivalent(A, True) == A + assert Equivalent(A, False) == Not(A) + assert Equivalent(A, B, True) == A & B + assert Equivalent(A, B, False) == ~A & ~B + assert Equivalent(1, A) == A + assert Equivalent(0, A) == Not(A) + assert Equivalent(A, Equivalent(B, C)) != Equivalent(Equivalent(A, B), C) + assert Equivalent(A < 1, A >= 1) is false + assert Equivalent(A < 1, A >= 1, 0) is false + assert Equivalent(A < 1, A >= 1, 1) is false + assert Equivalent(A < 1, S.One > A) == Equivalent(1, 1) == Equivalent(0, 0) + assert Equivalent(Equality(A, B), Equality(B, A)) is true + + +def test_Exclusive(): + assert Exclusive(False, False, False) is true + assert Exclusive(True, False, False) is true + assert Exclusive(True, True, False) is false + assert Exclusive(True, True, True) is false + + +def test_equals(): + assert Not(Or(A, B)).equals(And(Not(A), Not(B))) is True + assert Equivalent(A, B).equals((A >> B) & (B >> A)) is True + assert ((A | ~B) & (~A | B)).equals((~A & ~B) | (A & B)) is True + assert (A >> B).equals(~A >> ~B) is False + assert (A >> (B >> A)).equals(A >> (C >> A)) is False + raises(NotImplementedError, lambda: (A & B).equals(A > B)) + + +def test_simplification_boolalg(): + """ + Test working of simplification methods. + """ + set1 = [[0, 0, 1], [0, 1, 1], [1, 0, 0], [1, 1, 0]] + set2 = [[0, 0, 0], [0, 1, 0], [1, 0, 1], [1, 1, 1]] + assert SOPform([x, y, z], set1) == Or(And(Not(x), z), And(Not(z), x)) + assert Not(SOPform([x, y, z], set2)) == \ + Not(Or(And(Not(x), Not(z)), And(x, z))) + assert POSform([x, y, z], set1 + set2) is true + assert SOPform([x, y, z], set1 + set2) is true + assert SOPform([Dummy(), Dummy(), Dummy()], set1 + set2) is true + + minterms = [[0, 0, 0, 1], [0, 0, 1, 1], [0, 1, 1, 1], [1, 0, 1, 1], + [1, 1, 1, 1]] + dontcares = [[0, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 1]] + assert ( + SOPform([w, x, y, z], minterms, dontcares) == + Or(And(y, z), And(Not(w), Not(x)))) + assert POSform([w, x, y, z], minterms, dontcares) == And(Or(Not(w), y), z) + + minterms = [1, 3, 7, 11, 15] + dontcares = [0, 2, 5] + assert ( + SOPform([w, x, y, z], minterms, dontcares) == + Or(And(y, z), And(Not(w), Not(x)))) + assert POSform([w, x, y, z], minterms, dontcares) == And(Or(Not(w), y), z) + + minterms = [1, [0, 0, 1, 1], 7, [1, 0, 1, 1], + [1, 1, 1, 1]] + dontcares = [0, [0, 0, 1, 0], 5] + assert ( + SOPform([w, x, y, z], minterms, dontcares) == + Or(And(y, z), And(Not(w), Not(x)))) + assert POSform([w, x, y, z], minterms, dontcares) == And(Or(Not(w), y), z) + + minterms = [1, {y: 1, z: 1}] + dontcares = [0, [0, 0, 1, 0], 5] + assert ( + SOPform([w, x, y, z], minterms, dontcares) == + Or(And(y, z), And(Not(w), Not(x)))) + assert POSform([w, x, y, z], minterms, dontcares) == And(Or(Not(w), y), z) + + + minterms = [{y: 1, z: 1}, 1] + dontcares = [[0, 0, 0, 0]] + + minterms = [[0, 0, 0]] + raises(ValueError, lambda: SOPform([w, x, y, z], minterms)) + raises(ValueError, lambda: POSform([w, x, y, z], minterms)) + + raises(TypeError, lambda: POSform([w, x, y, z], ["abcdefg"])) + + # test simplification + ans = And(A, Or(B, C)) + assert simplify_logic(A & (B | C)) == ans + assert simplify_logic((A & B) | (A & C)) == ans + assert simplify_logic(Implies(A, B)) == Or(Not(A), B) + assert simplify_logic(Equivalent(A, B)) == \ + Or(And(A, B), And(Not(A), Not(B))) + assert simplify_logic(And(Equality(A, 2), C)) == And(Equality(A, 2), C) + assert simplify_logic(And(Equality(A, 2), A)) is S.false + assert simplify_logic(And(Equality(A, 2), A)) == And(Equality(A, 2), A) + assert simplify_logic(And(Equality(A, B), C)) == And(Equality(A, B), C) + assert simplify_logic(Or(And(Equality(A, 3), B), And(Equality(A, 3), C))) \ + == And(Equality(A, 3), Or(B, C)) + b = (~x & ~y & ~z) | (~x & ~y & z) + e = And(A, b) + assert simplify_logic(e) == A & ~x & ~y + raises(ValueError, lambda: simplify_logic(A & (B | C), form='blabla')) + assert simplify(Or(x <= y, And(x < y, z))) == (x <= y) + assert simplify(Or(x <= y, And(y > x, z))) == (x <= y) + assert simplify(Or(x >= y, And(y < x, z))) == (x >= y) + + # Check that expressions with nine variables or more are not simplified + # (without the force-flag) + a, b, c, d, e, f, g, h, j = symbols('a b c d e f g h j') + expr = a & b & c & d & e & f & g & h & j | \ + a & b & c & d & e & f & g & h & ~j + # This expression can be simplified to get rid of the j variables + assert simplify_logic(expr) == expr + + # Test dontcare + assert simplify_logic((a & b) | c | d, dontcare=(a & b)) == c | d + + # check input + ans = SOPform([x, y], [[1, 0]]) + assert SOPform([x, y], [[1, 0]]) == ans + assert POSform([x, y], [[1, 0]]) == ans + + raises(ValueError, lambda: SOPform([x], [[1]], [[1]])) + assert SOPform([x], [[1]], [[0]]) is true + assert SOPform([x], [[0]], [[1]]) is true + assert SOPform([x], [], []) is false + + raises(ValueError, lambda: POSform([x], [[1]], [[1]])) + assert POSform([x], [[1]], [[0]]) is true + assert POSform([x], [[0]], [[1]]) is true + assert POSform([x], [], []) is false + + # check working of simplify + assert simplify((A & B) | (A & C)) == And(A, Or(B, C)) + assert simplify(And(x, Not(x))) == False + assert simplify(Or(x, Not(x))) == True + assert simplify(And(Eq(x, 0), Eq(x, y))) == And(Eq(x, 0), Eq(y, 0)) + assert And(Eq(x - 1, 0), Eq(x, y)).simplify() == And(Eq(x, 1), Eq(y, 1)) + assert And(Ne(x - 1, 0), Ne(x, y)).simplify() == And(Ne(x, 1), Ne(x, y)) + assert And(Eq(x - 1, 0), Ne(x, y)).simplify() == And(Eq(x, 1), Ne(y, 1)) + assert And(Eq(x - 1, 0), Eq(x, z + y), Eq(y + x, 0)).simplify( + ) == And(Eq(x, 1), Eq(y, -1), Eq(z, 2)) + assert And(Eq(x - 1, 0), Eq(x + 2, 3)).simplify() == Eq(x, 1) + assert And(Ne(x - 1, 0), Ne(x + 2, 3)).simplify() == Ne(x, 1) + assert And(Eq(x - 1, 0), Eq(x + 2, 2)).simplify() == False + assert And(Ne(x - 1, 0), Ne(x + 2, 2)).simplify( + ) == And(Ne(x, 1), Ne(x, 0)) + + +def test_bool_map(): + """ + Test working of bool_map function. + """ + + minterms = [[0, 0, 0, 1], [0, 0, 1, 1], [0, 1, 1, 1], [1, 0, 1, 1], + [1, 1, 1, 1]] + assert bool_map(Not(Not(a)), a) == (a, {a: a}) + assert bool_map(SOPform([w, x, y, z], minterms), + POSform([w, x, y, z], minterms)) == \ + (And(Or(Not(w), y), Or(Not(x), y), z), {x: x, w: w, z: z, y: y}) + assert bool_map(SOPform([x, z, y], [[1, 0, 1]]), + SOPform([a, b, c], [[1, 0, 1]])) != False + function1 = SOPform([x, z, y], [[1, 0, 1], [0, 0, 1]]) + function2 = SOPform([a, b, c], [[1, 0, 1], [1, 0, 0]]) + assert bool_map(function1, function2) == \ + (function1, {y: a, z: b}) + assert bool_map(Xor(x, y), ~Xor(x, y)) == False + assert bool_map(And(x, y), Or(x, y)) is None + assert bool_map(And(x, y), And(x, y, z)) is None + # issue 16179 + assert bool_map(Xor(x, y, z), ~Xor(x, y, z)) == False + assert bool_map(Xor(a, x, y, z), ~Xor(a, x, y, z)) == False + + +def test_bool_symbol(): + """Test that mixing symbols with boolean values + works as expected""" + + assert And(A, True) == A + assert And(A, True, True) == A + assert And(A, False) is false + assert And(A, True, False) is false + assert Or(A, True) is true + assert Or(A, False) == A + + +def test_is_boolean(): + assert isinstance(True, Boolean) is False + assert isinstance(true, Boolean) is True + assert 1 == True + assert 1 != true + assert (1 == true) is False + assert 0 == False + assert 0 != false + assert (0 == false) is False + assert true.is_Boolean is True + assert (A & B).is_Boolean + assert (A | B).is_Boolean + assert (~A).is_Boolean + assert (A ^ B).is_Boolean + assert A.is_Boolean != isinstance(A, Boolean) + assert isinstance(A, Boolean) + + +def test_subs(): + assert (A & B).subs(A, True) == B + assert (A & B).subs(A, False) is false + assert (A & B).subs(B, True) == A + assert (A & B).subs(B, False) is false + assert (A & B).subs({A: True, B: True}) is true + assert (A | B).subs(A, True) is true + assert (A | B).subs(A, False) == B + assert (A | B).subs(B, True) is true + assert (A | B).subs(B, False) == A + assert (A | B).subs({A: True, B: True}) is true + + +""" +we test for axioms of boolean algebra +see https://en.wikipedia.org/wiki/Boolean_algebra_(structure) +""" + + +def test_commutative(): + """Test for commutativity of And and Or""" + A, B = map(Boolean, symbols('A,B')) + + assert A & B == B & A + assert A | B == B | A + + +def test_and_associativity(): + """Test for associativity of And""" + + assert (A & B) & C == A & (B & C) + + +def test_or_assicativity(): + assert ((A | B) | C) == (A | (B | C)) + + +def test_double_negation(): + a = Boolean() + assert ~(~a) == a + + +# test methods + +def test_eliminate_implications(): + assert eliminate_implications(Implies(A, B, evaluate=False)) == (~A) | B + assert eliminate_implications( + A >> (C >> Not(B))) == Or(Or(Not(B), Not(C)), Not(A)) + assert eliminate_implications(Equivalent(A, B, C, D)) == \ + (~A | B) & (~B | C) & (~C | D) & (~D | A) + + +def test_conjuncts(): + assert conjuncts(A & B & C) == {A, B, C} + assert conjuncts((A | B) & C) == {A | B, C} + assert conjuncts(A) == {A} + assert conjuncts(True) == {True} + assert conjuncts(False) == {False} + + +def test_disjuncts(): + assert disjuncts(A | B | C) == {A, B, C} + assert disjuncts((A | B) & C) == {(A | B) & C} + assert disjuncts(A) == {A} + assert disjuncts(True) == {True} + assert disjuncts(False) == {False} + + +def test_distribute(): + assert distribute_and_over_or(Or(And(A, B), C)) == And(Or(A, C), Or(B, C)) + assert distribute_or_over_and(And(A, Or(B, C))) == Or(And(A, B), And(A, C)) + assert distribute_xor_over_and(And(A, Xor(B, C))) == Xor(And(A, B), And(A, C)) + + +def test_to_anf(): + x, y, z = symbols('x,y,z') + assert to_anf(And(x, y)) == And(x, y) + assert to_anf(Or(x, y)) == Xor(x, y, And(x, y)) + assert to_anf(Or(Implies(x, y), And(x, y), y)) == \ + Xor(x, True, x & y, remove_true=False) + assert to_anf(Or(Nand(x, y), Nor(x, y), Xnor(x, y), Implies(x, y))) == True + assert to_anf(Or(x, Not(y), Nor(x,z), And(x, y), Nand(y, z))) == \ + Xor(True, And(y, z), And(x, y, z), remove_true=False) + assert to_anf(Xor(x, y)) == Xor(x, y) + assert to_anf(Not(x)) == Xor(x, True, remove_true=False) + assert to_anf(Nand(x, y)) == Xor(True, And(x, y), remove_true=False) + assert to_anf(Nor(x, y)) == Xor(x, y, True, And(x, y), remove_true=False) + assert to_anf(Implies(x, y)) == Xor(x, True, And(x, y), remove_true=False) + assert to_anf(Equivalent(x, y)) == Xor(x, y, True, remove_true=False) + assert to_anf(Nand(x | y, x >> y), deep=False) == \ + Xor(True, And(Or(x, y), Implies(x, y)), remove_true=False) + assert to_anf(Nor(x ^ y, x & y), deep=False) == \ + Xor(True, Or(Xor(x, y), And(x, y)), remove_true=False) + + +def test_to_nnf(): + assert to_nnf(true) is true + assert to_nnf(false) is false + assert to_nnf(A) == A + assert to_nnf(A | ~A | B) is true + assert to_nnf(A & ~A & B) is false + assert to_nnf(A >> B) == ~A | B + assert to_nnf(Equivalent(A, B, C)) == (~A | B) & (~B | C) & (~C | A) + assert to_nnf(A ^ B ^ C) == \ + (A | B | C) & (~A | ~B | C) & (A | ~B | ~C) & (~A | B | ~C) + assert to_nnf(ITE(A, B, C)) == (~A | B) & (A | C) + assert to_nnf(Not(A | B | C)) == ~A & ~B & ~C + assert to_nnf(Not(A & B & C)) == ~A | ~B | ~C + assert to_nnf(Not(A >> B)) == A & ~B + assert to_nnf(Not(Equivalent(A, B, C))) == And(Or(A, B, C), Or(~A, ~B, ~C)) + assert to_nnf(Not(A ^ B ^ C)) == \ + (~A | B | C) & (A | ~B | C) & (A | B | ~C) & (~A | ~B | ~C) + assert to_nnf(Not(ITE(A, B, C))) == (~A | ~B) & (A | ~C) + assert to_nnf((A >> B) ^ (B >> A)) == (A & ~B) | (~A & B) + assert to_nnf((A >> B) ^ (B >> A), False) == \ + (~A | ~B | A | B) & ((A & ~B) | (~A & B)) + assert ITE(A, 1, 0).to_nnf() == A + assert ITE(A, 0, 1).to_nnf() == ~A + # although ITE can hold non-Boolean, it will complain if + # an attempt is made to convert the ITE to Boolean nnf + raises(TypeError, lambda: ITE(A < 1, [1], B).to_nnf()) + + +def test_to_cnf(): + assert to_cnf(~(B | C)) == And(Not(B), Not(C)) + assert to_cnf((A & B) | C) == And(Or(A, C), Or(B, C)) + assert to_cnf(A >> B) == (~A) | B + assert to_cnf(A >> (B & C)) == (~A | B) & (~A | C) + assert to_cnf(A & (B | C) | ~A & (B | C), True) == B | C + assert to_cnf(A & B) == And(A, B) + + assert to_cnf(Equivalent(A, B)) == And(Or(A, Not(B)), Or(B, Not(A))) + assert to_cnf(Equivalent(A, B & C)) == \ + (~A | B) & (~A | C) & (~B | ~C | A) + assert to_cnf(Equivalent(A, B | C), True) == \ + And(Or(Not(B), A), Or(Not(C), A), Or(B, C, Not(A))) + assert to_cnf(A + 1) == A + 1 + + +def test_issue_18904(): + x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15 = symbols('x1:16') + eq = (( x1 & x2 & x3 & x4 & x5 & x6 & x7 & x8 & x9 ) | + ( x1 & x2 & x3 & x4 & x5 & x6 & x7 & x10 & x9 ) | + ( x1 & x11 & x3 & x12 & x5 & x13 & x14 & x15 & x9 )) + assert is_cnf(to_cnf(eq)) + raises(ValueError, lambda: to_cnf(eq, simplify=True)) + for f, t in zip((And, Or), (to_cnf, to_dnf)): + eq = f(x1, x2, x3, x4, x5, x6, x7, x8, x9) + raises(ValueError, lambda: to_cnf(eq, simplify=True)) + assert t(eq, simplify=True, force=True) == eq + + +def test_issue_9949(): + assert is_cnf(to_cnf((b > -5) | (a > 2) & (a < 4))) + + +def test_to_CNF(): + assert CNF.CNF_to_cnf(CNF.to_CNF(~(B | C))) == to_cnf(~(B | C)) + assert CNF.CNF_to_cnf(CNF.to_CNF((A & B) | C)) == to_cnf((A & B) | C) + assert CNF.CNF_to_cnf(CNF.to_CNF(A >> B)) == to_cnf(A >> B) + assert CNF.CNF_to_cnf(CNF.to_CNF(A >> (B & C))) == to_cnf(A >> (B & C)) + assert CNF.CNF_to_cnf(CNF.to_CNF(A & (B | C) | ~A & (B | C))) == to_cnf(A & (B | C) | ~A & (B | C)) + assert CNF.CNF_to_cnf(CNF.to_CNF(A & B)) == to_cnf(A & B) + + +def test_to_dnf(): + assert to_dnf(~(B | C)) == And(Not(B), Not(C)) + assert to_dnf(A & (B | C)) == Or(And(A, B), And(A, C)) + assert to_dnf(A >> B) == (~A) | B + assert to_dnf(A >> (B & C)) == (~A) | (B & C) + assert to_dnf(A | B) == A | B + + assert to_dnf(Equivalent(A, B), True) == \ + Or(And(A, B), And(Not(A), Not(B))) + assert to_dnf(Equivalent(A, B & C), True) == \ + Or(And(A, B, C), And(Not(A), Not(B)), And(Not(A), Not(C))) + assert to_dnf(A + 1) == A + 1 + + +def test_to_int_repr(): + x, y, z = map(Boolean, symbols('x,y,z')) + + def sorted_recursive(arg): + try: + return sorted(sorted_recursive(x) for x in arg) + except TypeError: # arg is not a sequence + return arg + + assert sorted_recursive(to_int_repr([x | y, z | x], [x, y, z])) == \ + sorted_recursive([[1, 2], [1, 3]]) + assert sorted_recursive(to_int_repr([x | y, z | ~x], [x, y, z])) == \ + sorted_recursive([[1, 2], [3, -1]]) + + +def test_is_anf(): + x, y = symbols('x,y') + assert is_anf(true) is True + assert is_anf(false) is True + assert is_anf(x) is True + assert is_anf(And(x, y)) is True + assert is_anf(Xor(x, y, And(x, y))) is True + assert is_anf(Xor(x, y, Or(x, y))) is False + assert is_anf(Xor(Not(x), y)) is False + + +def test_is_nnf(): + assert is_nnf(true) is True + assert is_nnf(A) is True + assert is_nnf(~A) is True + assert is_nnf(A & B) is True + assert is_nnf((A & B) | (~A & A) | (~B & B) | (~A & ~B), False) is True + assert is_nnf((A | B) & (~A | ~B)) is True + assert is_nnf(Not(Or(A, B))) is False + assert is_nnf(A ^ B) is False + assert is_nnf((A & B) | (~A & A) | (~B & B) | (~A & ~B), True) is False + + +def test_is_cnf(): + assert is_cnf(x) is True + assert is_cnf(x | y | z) is True + assert is_cnf(x & y & z) is True + assert is_cnf((x | y) & z) is True + assert is_cnf((x & y) | z) is False + assert is_cnf(~(x & y) | z) is False + + +def test_is_dnf(): + assert is_dnf(x) is True + assert is_dnf(x | y | z) is True + assert is_dnf(x & y & z) is True + assert is_dnf((x & y) | z) is True + assert is_dnf((x | y) & z) is False + assert is_dnf(~(x | y) & z) is False + + +def test_ITE(): + A, B, C = symbols('A:C') + assert ITE(True, False, True) is false + assert ITE(True, True, False) is true + assert ITE(False, True, False) is false + assert ITE(False, False, True) is true + assert isinstance(ITE(A, B, C), ITE) + + A = True + assert ITE(A, B, C) == B + A = False + assert ITE(A, B, C) == C + B = True + assert ITE(And(A, B), B, C) == C + assert ITE(Or(A, False), And(B, True), False) is false + assert ITE(x, A, B) == Not(x) + assert ITE(x, B, A) == x + assert ITE(1, x, y) == x + assert ITE(0, x, y) == y + raises(TypeError, lambda: ITE(2, x, y)) + raises(TypeError, lambda: ITE(1, [], y)) + raises(TypeError, lambda: ITE(1, (), y)) + raises(TypeError, lambda: ITE(1, y, [])) + assert ITE(1, 1, 1) is S.true + assert isinstance(ITE(1, 1, 1, evaluate=False), ITE) + + raises(TypeError, lambda: ITE(x > 1, y, x)) + assert ITE(Eq(x, True), y, x) == ITE(x, y, x) + assert ITE(Eq(x, False), y, x) == ITE(~x, y, x) + assert ITE(Ne(x, True), y, x) == ITE(~x, y, x) + assert ITE(Ne(x, False), y, x) == ITE(x, y, x) + assert ITE(Eq(S. true, x), y, x) == ITE(x, y, x) + assert ITE(Eq(S.false, x), y, x) == ITE(~x, y, x) + assert ITE(Ne(S.true, x), y, x) == ITE(~x, y, x) + assert ITE(Ne(S.false, x), y, x) == ITE(x, y, x) + # 0 and 1 in the context are not treated as True/False + # so the equality must always be False since dissimilar + # objects cannot be equal + assert ITE(Eq(x, 0), y, x) == x + assert ITE(Eq(x, 1), y, x) == x + assert ITE(Ne(x, 0), y, x) == y + assert ITE(Ne(x, 1), y, x) == y + assert ITE(Eq(x, 0), y, z).subs(x, 0) == y + assert ITE(Eq(x, 0), y, z).subs(x, 1) == z + raises(ValueError, lambda: ITE(x > 1, y, x, z)) + + +def test_is_literal(): + assert is_literal(True) is True + assert is_literal(False) is True + assert is_literal(A) is True + assert is_literal(~A) is True + assert is_literal(Or(A, B)) is False + assert is_literal(Q.zero(A)) is True + assert is_literal(Not(Q.zero(A))) is True + assert is_literal(Or(A, B)) is False + assert is_literal(And(Q.zero(A), Q.zero(B))) is False + assert is_literal(x < 3) + assert not is_literal(x + y < 3) + + +def test_operators(): + # Mostly test __and__, __rand__, and so on + assert True & A == A & True == A + assert False & A == A & False == False + assert A & B == And(A, B) + assert True | A == A | True == True + assert False | A == A | False == A + assert A | B == Or(A, B) + assert ~A == Not(A) + assert True >> A == A << True == A + assert False >> A == A << False == True + assert A >> True == True << A == True + assert A >> False == False << A == ~A + assert A >> B == B << A == Implies(A, B) + assert True ^ A == A ^ True == ~A + assert False ^ A == A ^ False == A + assert A ^ B == Xor(A, B) + + +def test_true_false(): + assert true is S.true + assert false is S.false + assert true is not True + assert false is not False + assert true + assert not false + assert true == True + assert false == False + assert not (true == False) + assert not (false == True) + assert not (true == false) + + assert hash(true) == hash(True) + assert hash(false) == hash(False) + assert len({true, True}) == len({false, False}) == 1 + + assert isinstance(true, BooleanAtom) + assert isinstance(false, BooleanAtom) + # We don't want to subclass from bool, because bool subclasses from + # int. But operators like &, |, ^, <<, >>, and ~ act differently on 0 and + # 1 then we want them to on true and false. See the docstrings of the + # various And, Or, etc. functions for examples. + assert not isinstance(true, bool) + assert not isinstance(false, bool) + + # Note: using 'is' comparison is important here. We want these to return + # true and false, not True and False + + assert Not(true) is false + assert Not(True) is false + assert Not(false) is true + assert Not(False) is true + assert ~true is false + assert ~false is true + + for T, F in product((True, true), (False, false)): + assert And(T, F) is false + assert And(F, T) is false + assert And(F, F) is false + assert And(T, T) is true + assert And(T, x) == x + assert And(F, x) is false + if not (T is True and F is False): + assert T & F is false + assert F & T is false + if F is not False: + assert F & F is false + if T is not True: + assert T & T is true + + assert Or(T, F) is true + assert Or(F, T) is true + assert Or(F, F) is false + assert Or(T, T) is true + assert Or(T, x) is true + assert Or(F, x) == x + if not (T is True and F is False): + assert T | F is true + assert F | T is true + if F is not False: + assert F | F is false + if T is not True: + assert T | T is true + + assert Xor(T, F) is true + assert Xor(F, T) is true + assert Xor(F, F) is false + assert Xor(T, T) is false + assert Xor(T, x) == ~x + assert Xor(F, x) == x + if not (T is True and F is False): + assert T ^ F is true + assert F ^ T is true + if F is not False: + assert F ^ F is false + if T is not True: + assert T ^ T is false + + assert Nand(T, F) is true + assert Nand(F, T) is true + assert Nand(F, F) is true + assert Nand(T, T) is false + assert Nand(T, x) == ~x + assert Nand(F, x) is true + + assert Nor(T, F) is false + assert Nor(F, T) is false + assert Nor(F, F) is true + assert Nor(T, T) is false + assert Nor(T, x) is false + assert Nor(F, x) == ~x + + assert Implies(T, F) is false + assert Implies(F, T) is true + assert Implies(F, F) is true + assert Implies(T, T) is true + assert Implies(T, x) == x + assert Implies(F, x) is true + assert Implies(x, T) is true + assert Implies(x, F) == ~x + if not (T is True and F is False): + assert T >> F is false + assert F << T is false + assert F >> T is true + assert T << F is true + if F is not False: + assert F >> F is true + assert F << F is true + if T is not True: + assert T >> T is true + assert T << T is true + + assert Equivalent(T, F) is false + assert Equivalent(F, T) is false + assert Equivalent(F, F) is true + assert Equivalent(T, T) is true + assert Equivalent(T, x) == x + assert Equivalent(F, x) == ~x + assert Equivalent(x, T) == x + assert Equivalent(x, F) == ~x + + assert ITE(T, T, T) is true + assert ITE(T, T, F) is true + assert ITE(T, F, T) is false + assert ITE(T, F, F) is false + assert ITE(F, T, T) is true + assert ITE(F, T, F) is false + assert ITE(F, F, T) is true + assert ITE(F, F, F) is false + + assert all(i.simplify(1, 2) is i for i in (S.true, S.false)) + + +def test_bool_as_set(): + assert ITE(y <= 0, False, y >= 1).as_set() == Interval(1, oo) + assert And(x <= 2, x >= -2).as_set() == Interval(-2, 2) + assert Or(x >= 2, x <= -2).as_set() == Interval(-oo, -2) + Interval(2, oo) + assert Not(x > 2).as_set() == Interval(-oo, 2) + # issue 10240 + assert Not(And(x > 2, x < 3)).as_set() == \ + Union(Interval(-oo, 2), Interval(3, oo)) + assert true.as_set() == S.UniversalSet + assert false.as_set() is S.EmptySet + assert x.as_set() == S.UniversalSet + assert And(Or(x < 1, x > 3), x < 2).as_set() == Interval.open(-oo, 1) + assert And(x < 1, sin(x) < 3).as_set() == (x < 1).as_set() + raises(NotImplementedError, lambda: (sin(x) < 1).as_set()) + # watch for object morph in as_set + assert Eq(-1, cos(2*x)**2/sin(2*x)**2).as_set() is S.EmptySet + + +@XFAIL +def test_multivariate_bool_as_set(): + x, y = symbols('x,y') + + assert And(x >= 0, y >= 0).as_set() == Interval(0, oo)*Interval(0, oo) + assert Or(x >= 0, y >= 0).as_set() == S.Reals*S.Reals - \ + Interval(-oo, 0, True, True)*Interval(-oo, 0, True, True) + + +def test_all_or_nothing(): + x = symbols('x', extended_real=True) + args = x >= -oo, x <= oo + v = And(*args) + if v.func is And: + assert len(v.args) == len(args) - args.count(S.true) + else: + assert v == True + v = Or(*args) + if v.func is Or: + assert len(v.args) == 2 + else: + assert v == True + + +def test_canonical_atoms(): + assert true.canonical == true + assert false.canonical == false + + +def test_negated_atoms(): + assert true.negated == false + assert false.negated == true + + +def test_issue_8777(): + assert And(x > 2, x < oo).as_set() == Interval(2, oo, left_open=True) + assert And(x >= 1, x < oo).as_set() == Interval(1, oo) + assert (x < oo).as_set() == Interval(-oo, oo) + assert (x > -oo).as_set() == Interval(-oo, oo) + + +def test_issue_8975(): + assert Or(And(-oo < x, x <= -2), And(2 <= x, x < oo)).as_set() == \ + Interval(-oo, -2) + Interval(2, oo) + + +def test_term_to_integer(): + assert term_to_integer([1, 0, 1, 0, 0, 1, 0]) == 82 + assert term_to_integer('0010101000111001') == 10809 + + +def test_issue_21971(): + a, b, c, d = symbols('a b c d') + f = a & b & c | a & c + assert f.subs(a & c, d) == b & d | d + assert f.subs(a & b & c, d) == a & c | d + + f = (a | b | c) & (a | c) + assert f.subs(a | c, d) == (b | d) & d + assert f.subs(a | b | c, d) == (a | c) & d + + f = (a ^ b ^ c) & (a ^ c) + assert f.subs(a ^ c, d) == (b ^ d) & d + assert f.subs(a ^ b ^ c, d) == (a ^ c) & d + + +def test_truth_table(): + assert list(truth_table(And(x, y), [x, y], input=False)) == \ + [False, False, False, True] + assert list(truth_table(x | y, [x, y], input=False)) == \ + [False, True, True, True] + assert list(truth_table(x >> y, [x, y], input=False)) == \ + [True, True, False, True] + assert list(truth_table(And(x, y), [x, y])) == \ + [([0, 0], False), ([0, 1], False), ([1, 0], False), ([1, 1], True)] + + +def test_issue_8571(): + for t in (S.true, S.false): + raises(TypeError, lambda: +t) + raises(TypeError, lambda: -t) + raises(TypeError, lambda: abs(t)) + # use int(bool(t)) to get 0 or 1 + raises(TypeError, lambda: int(t)) + + for o in [S.Zero, S.One, x]: + for _ in range(2): + raises(TypeError, lambda: o + t) + raises(TypeError, lambda: o - t) + raises(TypeError, lambda: o % t) + raises(TypeError, lambda: o*t) + raises(TypeError, lambda: o/t) + raises(TypeError, lambda: o**t) + o, t = t, o # do again in reversed order + + +def test_expand_relational(): + n = symbols('n', negative=True) + p, q = symbols('p q', positive=True) + r = ((n + q*(-n/q + 1))/(q*(-n/q + 1)) < 0) + assert r is not S.false + assert r.expand() is S.false + assert (q > 0).expand() is S.true + + +def test_issue_12717(): + assert S.true.is_Atom == True + assert S.false.is_Atom == True + + +def test_as_Boolean(): + nz = symbols('nz', nonzero=True) + assert all(as_Boolean(i) is S.true for i in (True, S.true, 1, nz)) + z = symbols('z', zero=True) + assert all(as_Boolean(i) is S.false for i in (False, S.false, 0, z)) + assert all(as_Boolean(i) == i for i in (x, x < 0)) + for i in (2, S(2), x + 1, []): + raises(TypeError, lambda: as_Boolean(i)) + + +def test_binary_symbols(): + assert ITE(x < 1, y, z).binary_symbols == {y, z} + for f in (Eq, Ne): + assert f(x, 1).binary_symbols == set() + assert f(x, True).binary_symbols == {x} + assert f(x, False).binary_symbols == {x} + assert S.true.binary_symbols == set() + assert S.false.binary_symbols == set() + assert x.binary_symbols == {x} + assert And(x, Eq(y, False), Eq(z, 1)).binary_symbols == {x, y} + assert Q.prime(x).binary_symbols == set() + assert Q.lt(x, 1).binary_symbols == set() + assert Q.is_true(x).binary_symbols == {x} + assert Q.eq(x, True).binary_symbols == {x} + assert Q.prime(x).binary_symbols == set() + + +def test_BooleanFunction_diff(): + assert And(x, y).diff(x) == Piecewise((0, Eq(y, False)), (1, True)) + + +def test_issue_14700(): + A, B, C, D, E, F, G, H = symbols('A B C D E F G H') + q = ((B & D & H & ~F) | (B & H & ~C & ~D) | (B & H & ~C & ~F) | + (B & H & ~D & ~G) | (B & H & ~F & ~G) | (C & G & ~B & ~D) | + (C & G & ~D & ~H) | (C & G & ~F & ~H) | (D & F & H & ~B) | + (D & F & ~G & ~H) | (B & D & F & ~C & ~H) | (D & E & F & ~B & ~C) | + (D & F & ~A & ~B & ~C) | (D & F & ~A & ~C & ~H) | + (A & B & D & F & ~E & ~H)) + soldnf = ((B & D & H & ~F) | (D & F & H & ~B) | (B & H & ~C & ~D) | + (B & H & ~D & ~G) | (C & G & ~B & ~D) | (C & G & ~D & ~H) | + (C & G & ~F & ~H) | (D & F & ~G & ~H) | (D & E & F & ~C & ~H) | + (D & F & ~A & ~C & ~H) | (A & B & D & F & ~E & ~H)) + solcnf = ((B | C | D) & (B | D | G) & (C | D | H) & (C | F | H) & + (D | G | H) & (F | G | H) & (B | F | ~D | ~H) & + (~B | ~D | ~F | ~H) & (D | ~B | ~C | ~G | ~H) & + (A | H | ~C | ~D | ~F | ~G) & (H | ~C | ~D | ~E | ~F | ~G) & + (B | E | H | ~A | ~D | ~F | ~G)) + assert simplify_logic(q, "dnf") == soldnf + assert simplify_logic(q, "cnf") == solcnf + + minterms = [[0, 1, 0, 0], [0, 1, 0, 1], [0, 1, 1, 0], [0, 1, 1, 1], + [0, 0, 1, 1], [1, 0, 1, 1]] + dontcares = [[1, 0, 0, 0], [1, 0, 0, 1], [1, 1, 0, 0], [1, 1, 0, 1]] + assert SOPform([w, x, y, z], minterms) == (x & ~w) | (y & z & ~x) + # Should not be more complicated with don't cares + assert SOPform([w, x, y, z], minterms, dontcares) == \ + (x & ~w) | (y & z & ~x) + + +def test_relational_simplification(): + w, x, y, z = symbols('w x y z', real=True) + d, e = symbols('d e', real=False) + # Test all combinations or sign and order + assert Or(x >= y, x < y).simplify() == S.true + assert Or(x >= y, y > x).simplify() == S.true + assert Or(x >= y, -x > -y).simplify() == S.true + assert Or(x >= y, -y < -x).simplify() == S.true + assert Or(-x <= -y, x < y).simplify() == S.true + assert Or(-x <= -y, -x > -y).simplify() == S.true + assert Or(-x <= -y, y > x).simplify() == S.true + assert Or(-x <= -y, -y < -x).simplify() == S.true + assert Or(y <= x, x < y).simplify() == S.true + assert Or(y <= x, y > x).simplify() == S.true + assert Or(y <= x, -x > -y).simplify() == S.true + assert Or(y <= x, -y < -x).simplify() == S.true + assert Or(-y >= -x, x < y).simplify() == S.true + assert Or(-y >= -x, y > x).simplify() == S.true + assert Or(-y >= -x, -x > -y).simplify() == S.true + assert Or(-y >= -x, -y < -x).simplify() == S.true + + assert Or(x < y, x >= y).simplify() == S.true + assert Or(y > x, x >= y).simplify() == S.true + assert Or(-x > -y, x >= y).simplify() == S.true + assert Or(-y < -x, x >= y).simplify() == S.true + assert Or(x < y, -x <= -y).simplify() == S.true + assert Or(-x > -y, -x <= -y).simplify() == S.true + assert Or(y > x, -x <= -y).simplify() == S.true + assert Or(-y < -x, -x <= -y).simplify() == S.true + assert Or(x < y, y <= x).simplify() == S.true + assert Or(y > x, y <= x).simplify() == S.true + assert Or(-x > -y, y <= x).simplify() == S.true + assert Or(-y < -x, y <= x).simplify() == S.true + assert Or(x < y, -y >= -x).simplify() == S.true + assert Or(y > x, -y >= -x).simplify() == S.true + assert Or(-x > -y, -y >= -x).simplify() == S.true + assert Or(-y < -x, -y >= -x).simplify() == S.true + + # Some other tests + assert Or(x >= y, w < z, x <= y).simplify() == S.true + assert And(x >= y, x < y).simplify() == S.false + assert Or(x >= y, Eq(y, x)).simplify() == (x >= y) + assert And(x >= y, Eq(y, x)).simplify() == Eq(x, y) + assert And(Eq(x, y), x >= 1, 2 < y, y >= 5, z < y).simplify() == \ + (Eq(x, y) & (x >= 1) & (y >= 5) & (y > z)) + assert Or(Eq(x, y), x >= y, w < y, z < y).simplify() == \ + (x >= y) | (y > z) | (w < y) + assert And(Eq(x, y), x >= y, w < y, y >= z, z < y).simplify() == \ + Eq(x, y) & (y > z) & (w < y) + # assert And(Eq(x, y), x >= y, w < y, y >= z, z < y).simplify(relational_minmax=True) == \ + # And(Eq(x, y), y > Max(w, z)) + # assert Or(Eq(x, y), x >= 1, 2 < y, y >= 5, z < y).simplify(relational_minmax=True) == \ + # (Eq(x, y) | (x >= 1) | (y > Min(2, z))) + assert And(Eq(x, y), x >= 1, 2 < y, y >= 5, z < y).simplify() == \ + (Eq(x, y) & (x >= 1) & (y >= 5) & (y > z)) + assert (Eq(x, y) & Eq(d, e) & (x >= y) & (d >= e)).simplify() == \ + (Eq(x, y) & Eq(d, e) & (d >= e)) + assert And(Eq(x, y), Eq(x, -y)).simplify() == And(Eq(x, 0), Eq(y, 0)) + assert Xor(x >= y, x <= y).simplify() == Ne(x, y) + assert And(x > 1, x < -1, Eq(x, y)).simplify() == S.false + # From #16690 + assert And(x >= y, Eq(y, 0)).simplify() == And(x >= 0, Eq(y, 0)) + assert Or(Ne(x, 1), Ne(x, 2)).simplify() == S.true + assert And(Eq(x, 1), Ne(2, x)).simplify() == Eq(x, 1) + assert Or(Eq(x, 1), Ne(2, x)).simplify() == Ne(x, 2) + +def test_issue_8373(): + x = symbols('x', real=True) + assert Or(x < 1, x > -1).simplify() == S.true + assert Or(x < 1, x >= 1).simplify() == S.true + assert And(x < 1, x >= 1).simplify() == S.false + assert Or(x <= 1, x >= 1).simplify() == S.true + + +def test_issue_7950(): + x = symbols('x', real=True) + assert And(Eq(x, 1), Eq(x, 2)).simplify() == S.false + + +@slow +def test_relational_simplification_numerically(): + def test_simplification_numerically_function(original, simplified): + symb = original.free_symbols + n = len(symb) + valuelist = list(set(combinations(list(range(-(n-1), n))*n, n))) + for values in valuelist: + sublist = dict(zip(symb, values)) + originalvalue = original.subs(sublist) + simplifiedvalue = simplified.subs(sublist) + assert originalvalue == simplifiedvalue, "Original: {}\nand"\ + " simplified: {}\ndo not evaluate to the same value for {}"\ + "".format(original, simplified, sublist) + + w, x, y, z = symbols('w x y z', real=True) + d, e = symbols('d e', real=False) + + expressions = (And(Eq(x, y), x >= y, w < y, y >= z, z < y), + And(Eq(x, y), x >= 1, 2 < y, y >= 5, z < y), + Or(Eq(x, y), x >= 1, 2 < y, y >= 5, z < y), + And(x >= y, Eq(y, x)), + Or(And(Eq(x, y), x >= y, w < y, Or(y >= z, z < y)), + And(Eq(x, y), x >= 1, 2 < y, y >= -1, z < y)), + (Eq(x, y) & Eq(d, e) & (x >= y) & (d >= e)), + ) + + for expression in expressions: + test_simplification_numerically_function(expression, + expression.simplify()) + + +def test_relational_simplification_patterns_numerically(): + from sympy.core import Wild + from sympy.logic.boolalg import _simplify_patterns_and, \ + _simplify_patterns_or, _simplify_patterns_xor + a = Wild('a') + b = Wild('b') + c = Wild('c') + symb = [a, b, c] + patternlists = [[And, _simplify_patterns_and()], + [Or, _simplify_patterns_or()], + [Xor, _simplify_patterns_xor()]] + valuelist = list(set(combinations(list(range(-2, 3))*3, 3))) + # Skip combinations of +/-2 and 0, except for all 0 + valuelist = [v for v in valuelist if any([w % 2 for w in v]) or not any(v)] + for func, patternlist in patternlists: + for pattern in patternlist: + original = func(*pattern[0].args) + simplified = pattern[1] + for values in valuelist: + sublist = dict(zip(symb, values)) + originalvalue = original.xreplace(sublist) + simplifiedvalue = simplified.xreplace(sublist) + assert originalvalue == simplifiedvalue, "Original: {}\nand"\ + " simplified: {}\ndo not evaluate to the same value for"\ + "{}".format(pattern[0], simplified, sublist) + + +def test_issue_16803(): + n = symbols('n') + # No simplification done, but should not raise an exception + assert ((n > 3) | (n < 0) | ((n > 0) & (n < 3))).simplify() == \ + (n > 3) | (n < 0) | ((n > 0) & (n < 3)) + + +def test_issue_17530(): + r = {x: oo, y: oo} + assert Or(x + y > 0, x - y < 0).subs(r) + assert not And(x + y < 0, x - y < 0).subs(r) + raises(TypeError, lambda: Or(x + y < 0, x - y < 0).subs(r)) + raises(TypeError, lambda: And(x + y > 0, x - y < 0).subs(r)) + raises(TypeError, lambda: And(x + y > 0, x - y < 0).subs(r)) + + +def test_anf_coeffs(): + assert anf_coeffs([1, 0]) == [1, 1] + assert anf_coeffs([0, 0, 0, 1]) == [0, 0, 0, 1] + assert anf_coeffs([0, 1, 1, 1]) == [0, 1, 1, 1] + assert anf_coeffs([1, 1, 1, 0]) == [1, 0, 0, 1] + assert anf_coeffs([1, 0, 0, 0]) == [1, 1, 1, 1] + assert anf_coeffs([1, 0, 0, 1]) == [1, 1, 1, 0] + assert anf_coeffs([1, 1, 0, 1]) == [1, 0, 1, 1] + + +def test_ANFform(): + x, y = symbols('x,y') + assert ANFform([x], [1, 1]) == True + assert ANFform([x], [0, 0]) == False + assert ANFform([x], [1, 0]) == Xor(x, True, remove_true=False) + assert ANFform([x, y], [1, 1, 1, 0]) == \ + Xor(True, And(x, y), remove_true=False) + + +def test_bool_minterm(): + x, y = symbols('x,y') + assert bool_minterm(3, [x, y]) == And(x, y) + assert bool_minterm([1, 0], [x, y]) == And(Not(y), x) + + +def test_bool_maxterm(): + x, y = symbols('x,y') + assert bool_maxterm(2, [x, y]) == Or(Not(x), y) + assert bool_maxterm([0, 1], [x, y]) == Or(Not(y), x) + + +def test_bool_monomial(): + x, y = symbols('x,y') + assert bool_monomial(1, [x, y]) == y + assert bool_monomial([1, 1], [x, y]) == And(x, y) + + +def test_check_pair(): + assert _check_pair([0, 1, 0], [0, 1, 1]) == 2 + assert _check_pair([0, 1, 0], [1, 1, 1]) == -1 + + +def test_issue_19114(): + expr = (B & C) | (A & ~C) | (~A & ~B) + # Expression is minimal, but there are multiple minimal forms possible + res1 = (A & B) | (C & ~A) | (~B & ~C) + result = to_dnf(expr, simplify=True) + assert result in (expr, res1) + + +def test_issue_20870(): + result = SOPform([a, b, c, d], [1, 2, 3, 4, 5, 6, 8, 9, 11, 12, 14, 15]) + expected = ((d & ~b) | (a & b & c) | (a & ~c & ~d) | + (b & ~a & ~c) | (c & ~a & ~d)) + assert result == expected + + +def test_convert_to_varsSOP(): + assert _convert_to_varsSOP([0, 1, 0], [x, y, z]) == And(Not(x), y, Not(z)) + assert _convert_to_varsSOP([3, 1, 0], [x, y, z]) == And(y, Not(z)) + + +def test_convert_to_varsPOS(): + assert _convert_to_varsPOS([0, 1, 0], [x, y, z]) == Or(x, Not(y), z) + assert _convert_to_varsPOS([3, 1, 0], [x, y, z]) == Or(Not(y), z) + + +def test_gateinputcount(): + a, b, c, d, e = symbols('a:e') + assert gateinputcount(And(a, b)) == 2 + assert gateinputcount(a | b & c & d ^ (e | a)) == 9 + assert gateinputcount(And(a, True)) == 0 + raises(TypeError, lambda: gateinputcount(a*b)) + + +def test_refine(): + # relational + assert not refine(x < 0, ~(x < 0)) + assert refine(x < 0, (x < 0)) + assert refine(x < 0, (0 > x)) is S.true + assert refine(x < 0, (y < 0)) == (x < 0) + assert not refine(x <= 0, ~(x <= 0)) + assert refine(x <= 0, (x <= 0)) + assert refine(x <= 0, (0 >= x)) is S.true + assert refine(x <= 0, (y <= 0)) == (x <= 0) + assert not refine(x > 0, ~(x > 0)) + assert refine(x > 0, (x > 0)) + assert refine(x > 0, (0 < x)) is S.true + assert refine(x > 0, (y > 0)) == (x > 0) + assert not refine(x >= 0, ~(x >= 0)) + assert refine(x >= 0, (x >= 0)) + assert refine(x >= 0, (0 <= x)) is S.true + assert refine(x >= 0, (y >= 0)) == (x >= 0) + assert not refine(Eq(x, 0), ~(Eq(x, 0))) + assert refine(Eq(x, 0), (Eq(x, 0))) + assert refine(Eq(x, 0), (Eq(0, x))) is S.true + assert refine(Eq(x, 0), (Eq(y, 0))) == Eq(x, 0) + assert not refine(Ne(x, 0), ~(Ne(x, 0))) + assert refine(Ne(x, 0), (Ne(0, x))) is S.true + assert refine(Ne(x, 0), (Ne(x, 0))) + assert refine(Ne(x, 0), (Ne(y, 0))) == (Ne(x, 0)) + + # boolean functions + assert refine(And(x > 0, y > 0), (x > 0)) == (y > 0) + assert refine(And(x > 0, y > 0), (x > 0) & (y > 0)) is S.true + + # predicates + assert refine(Q.positive(x), Q.positive(x)) is S.true + assert refine(Q.positive(x), Q.negative(x)) is S.false + assert refine(Q.positive(x), Q.real(x)) == Q.positive(x) + + +def test_relational_threeterm_simplification_patterns_numerically(): + from sympy.core import Wild + from sympy.logic.boolalg import _simplify_patterns_and3 + a = Wild('a') + b = Wild('b') + c = Wild('c') + symb = [a, b, c] + patternlists = [[And, _simplify_patterns_and3()]] + valuelist = list(set(combinations(list(range(-2, 3))*3, 3))) + # Skip combinations of +/-2 and 0, except for all 0 + valuelist = [v for v in valuelist if any([w % 2 for w in v]) or not any(v)] + for func, patternlist in patternlists: + for pattern in patternlist: + original = func(*pattern[0].args) + simplified = pattern[1] + for values in valuelist: + sublist = dict(zip(symb, values)) + originalvalue = original.xreplace(sublist) + simplifiedvalue = simplified.xreplace(sublist) + assert originalvalue == simplifiedvalue, "Original: {}\nand"\ + " simplified: {}\ndo not evaluate to the same value for"\ + "{}".format(pattern[0], simplified, sublist) diff --git a/shared/package-files/2f/2fa88761b03552cd6996396514b1080075b865a66114aa06d99afc4d3e5a637f/blob b/shared/package-files/2f/2fa88761b03552cd6996396514b1080075b865a66114aa06d99afc4d3e5a637f/blob new file mode 100644 index 0000000000000000000000000000000000000000..ae4a8a754617b8b918daffb6a45a067df2fd2fe6 Binary files /dev/null and b/shared/package-files/2f/2fa88761b03552cd6996396514b1080075b865a66114aa06d99afc4d3e5a637f/blob differ diff --git a/shared/package-files/2f/2fa9182f0a8b1b757ea3dd1bba1cc914f87b788fddcd012a3e3fa6d00f7a6a5c/blob b/shared/package-files/2f/2fa9182f0a8b1b757ea3dd1bba1cc914f87b788fddcd012a3e3fa6d00f7a6a5c/blob new file mode 100644 index 0000000000000000000000000000000000000000..9344a2e480b24bd77b8c108b8ef1adb1404af616 --- /dev/null +++ b/shared/package-files/2f/2fa9182f0a8b1b757ea3dd1bba1cc914f87b788fddcd012a3e3fa6d00f7a6a5c/blob @@ -0,0 +1,78 @@ +/* + * Copyright (c) Meta Platforms, Inc. and affiliates. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. + */ + +#pragma once + +#include +#include + +namespace tensorpipe { +namespace transport { + +class Connection; +class Listener; + +class Context { + public: + virtual std::shared_ptr connect(std::string addr) = 0; + + virtual std::shared_ptr listen(std::string addr) = 0; + + // Return whether the context is able to operate correctly. + // + // Some transport types may be unable to perform as intended under + // some circumstances (e.g., specialized hardware unavailable, lack + // of permissions). They can report it through this method in order + // for the core context to avoid registering them in the first place. + // + virtual bool isViable() const = 0; + + // Return string to describe the domain for this context. + // + // Two processes with a context of the same type can connect to each + // other if one side's domain descriptor is "accepted" by the other + // one, using the canCommunicateWithRemote method below. That method + // must be symmetric, and unless overridden defaults to string + // comparison. + // + // For example, for a transport that leverages TCP/IP, this may be + // as simple as the address family (assuming we can route between + // any two processes). For a transport that leverages shared memory, + // this descriptor must uniquely identify the machine, such that + // only co-located processes generate the same domain descriptor. + // + virtual const std::string& domainDescriptor() const = 0; + + // Compare local and remote domain descriptor for compatibility. + // + // Determine whether a connection can be opened between this context + // and a remote one that has the given domain descriptor. This + // function needs to be symmetric: if we called this method on the + // remote context with the local descriptor we should get the same + // answer. Unless overridden it defaults to string comparison. + // + virtual bool canCommunicateWithRemote( + const std::string& remoteDomainDescriptor) const { + return domainDescriptor() == remoteDomainDescriptor; + } + + // Tell the context what its identifier is. + // + // This is only supposed to be called from the high-level context or from + // channel contexts. It will only used for logging and debugging purposes. + virtual void setId(std::string id) = 0; + + virtual void close() = 0; + + virtual void join() = 0; + + virtual ~Context() = default; +}; + +} // namespace transport +} // namespace tensorpipe diff --git a/shared/package-files/2f/2faacdddf2a2afca224926fc1f160d1f298ceb7e522cf6a569810c1abdd8b5c8/blob b/shared/package-files/2f/2faacdddf2a2afca224926fc1f160d1f298ceb7e522cf6a569810c1abdd8b5c8/blob new file mode 100644 index 0000000000000000000000000000000000000000..25953fde5fb582d501479e736e93c3c290db3338 --- /dev/null +++ b/shared/package-files/2f/2faacdddf2a2afca224926fc1f160d1f298ceb7e522cf6a569810c1abdd8b5c8/blob @@ -0,0 +1,35 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::selu(Tensor self) -> Tensor +inline at::Tensor selu(const at::Tensor & self) { + return at::_ops::selu::call(self); +} + +// aten::selu_(Tensor(a!) self) -> Tensor(a!) +inline at::Tensor & selu_(at::Tensor & self) { + return at::_ops::selu_::call(self); +} + +} diff --git a/shared/package-files/2f/2faad44553bd6a7adabb62d6023c29d5916dba8cf5593baa3f70bd367d33e8be/blob b/shared/package-files/2f/2faad44553bd6a7adabb62d6023c29d5916dba8cf5593baa3f70bd367d33e8be/blob new file mode 100644 index 0000000000000000000000000000000000000000..6694c8cfd7f987271d1f6775e7b21431e1ce5879 --- /dev/null +++ b/shared/package-files/2f/2faad44553bd6a7adabb62d6023c29d5916dba8cf5593baa3f70bd367d33e8be/blob @@ -0,0 +1,21 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor to_sparse_csc(const at::Tensor & self, c10::optional dense_dim=c10::nullopt); +} // namespace native +} // namespace at diff --git a/shared/package-files/2f/2fab95ce4d865e3147fd4f4b0dd33e78fee7e90d34e569136c0f5a1d64c7b166/blob b/shared/package-files/2f/2fab95ce4d865e3147fd4f4b0dd33e78fee7e90d34e569136c0f5a1d64c7b166/blob new file mode 100644 index 0000000000000000000000000000000000000000..c8f24bef1b51d2b978eb1083ad405832057c2107 --- /dev/null +++ b/shared/package-files/2f/2fab95ce4d865e3147fd4f4b0dd33e78fee7e90d34e569136c0f5a1d64c7b166/blob @@ -0,0 +1,306 @@ +# Unpickler restricted to loading only state dicts +# Restrict constructing types to a list defined in _get_allowed_globals() +# Restrict BUILD operation to `Tensor`, `Parameter` and `OrderedDict` types only +# Restrict APPEND/APPENDS to `list` +# In `GLOBALS` operation do not do class lookup by name, but rather rely on dictionary +# defined by `_get_allowed_globals()` method, that contains: +# - torch types (Storage, dtypes, Tensor, `torch.Size`), +# - `torch._utils._rebuild` functions. +# - `torch.nn.Parameter` +# - `collections.OrderedDict` + +# Based of https://github.com/python/cpython/blob/main/Lib/pickle.py +# Expected to be useful for loading PyTorch model weights +# For example: +# data = urllib.request.urlopen('https://download.pytorch.org/models/resnet50-0676ba61.pth').read() +# buf = io.BytesIO(data) +# weights = torch.load(buf, weights_only = True) + +import functools as _functools +from collections import OrderedDict +from pickle import ( + APPEND, + APPENDS, + BINFLOAT, + BINGET, + BININT, + BININT1, + BININT2, + BINPERSID, + BINPUT, + BINUNICODE, + BUILD, + bytes_types, + decode_long, + EMPTY_DICT, + EMPTY_LIST, + EMPTY_SET, + EMPTY_TUPLE, + GLOBAL, + LONG1, + LONG_BINGET, + LONG_BINPUT, + MARK, + NEWFALSE, + NEWOBJ, + NEWTRUE, + NONE, + PROTO, + REDUCE, + SETITEM, + SETITEMS, + SHORT_BINSTRING, + STOP, + TUPLE, + TUPLE1, + TUPLE2, + TUPLE3, + UnpicklingError, +) +from struct import unpack +from sys import maxsize +from typing import Any, Dict, List + +import torch + + +# Unpickling machinery +@_functools.lru_cache(maxsize=1) +def _get_allowed_globals(): + rc: Dict[str, Any] = { + "collections.OrderedDict": OrderedDict, + "torch.nn.parameter.Parameter": torch.nn.Parameter, + "torch.serialization._get_layout": torch.serialization._get_layout, + "torch.Size": torch.Size, + "torch.Tensor": torch.Tensor, + } + # dtype + for t in [ + torch.complex32, + torch.complex64, + torch.complex128, + torch.float8_e5m2, + torch.float8_e4m3fn, + torch.float8_e5m2fnuz, + torch.float8_e4m3fnuz, + torch.float16, + torch.float32, + torch.float64, + torch.int8, + torch.int16, + torch.int32, + torch.int64, + ]: + rc[str(t)] = t + # Tensor classes + for tt in torch._tensor_classes: + rc[f"{tt.__module__}.{tt.__name__}"] = tt + # Storage classes + for ts in torch._storage_classes: + if ts not in (torch.storage.TypedStorage, torch.storage.UntypedStorage): + # Wrap legacy storage types in a dummy class + rc[f"{ts.__module__}.{ts.__name__}"] = torch.serialization.StorageType( + ts.__name__ + ) + else: + rc[f"{ts.__module__}.{ts.__name__}"] = ts + # Rebuild functions + for f in [ + torch._utils._rebuild_parameter, + torch._utils._rebuild_tensor, + torch._utils._rebuild_tensor_v2, + torch._utils._rebuild_tensor_v3, + torch._utils._rebuild_sparse_tensor, + torch._utils._rebuild_meta_tensor_no_storage, + torch._utils._rebuild_nested_tensor, + ]: + rc[f"torch._utils.{f.__name__}"] = f + + # Handles Tensor Subclasses, Tensor's with attributes. + # NOTE: It calls into above rebuild functions for regular Tensor types. + rc["torch._tensor._rebuild_from_type_v2"] = torch._tensor._rebuild_from_type_v2 + return rc + + +class Unpickler: + def __init__(self, file, *, encoding: str = "bytes"): + self.encoding = encoding + self.readline = file.readline + self.read = file.read + self.memo: Dict[int, Any] = {} + + def load(self): + """Read a pickled object representation from the open file. + + Return the reconstituted object hierarchy specified in the file. + """ + self.metastack = [] + self.stack: List[Any] = [] + self.append = self.stack.append + read = self.read + readline = self.readline + while True: + key = read(1) + if not key: + raise EOFError + assert isinstance(key, bytes_types) + # Risky operators + if key[0] == GLOBAL[0]: + module = readline()[:-1].decode("utf-8") + name = readline()[:-1].decode("utf-8") + full_path = f"{module}.{name}" + if full_path in _get_allowed_globals(): + self.append(_get_allowed_globals()[full_path]) + else: + raise RuntimeError(f"Unsupported class {full_path}") + elif key[0] == NEWOBJ[0]: + args = self.stack.pop() + cls = self.stack.pop() + if cls is not torch.nn.Parameter: + raise RuntimeError(f"Trying to instantiate unsupported class {cls}") + self.append(torch.nn.Parameter(*args)) + elif key[0] == REDUCE[0]: + args = self.stack.pop() + func = self.stack[-1] + if func not in _get_allowed_globals().values(): + raise RuntimeError( + f"Trying to call reduce for unrecognized function {func}" + ) + self.stack[-1] = func(*args) + elif key[0] == BUILD[0]: + state = self.stack.pop() + inst = self.stack[-1] + if type(inst) is torch.Tensor: + # Legacy unpickling + inst.set_(*state) + elif type(inst) is torch.nn.Parameter: + inst.__setstate__(state) + elif type(inst) is OrderedDict: + inst.__dict__.update(state) + else: + raise RuntimeError( + f"Can only build Tensor, parameter or dict objects, but got {type(inst)}" + ) + # Stack manipulation + elif key[0] == APPEND[0]: + item = self.stack.pop() + list_obj = self.stack[-1] + if type(list_obj) is not list: + raise RuntimeError( + f"Can only append to lists, but got {type(list_obj)}" + ) + list_obj.append(item) + elif key[0] == APPENDS[0]: + items = self.pop_mark() + list_obj = self.stack[-1] + if type(list_obj) is not list: + raise RuntimeError( + f"Can only extend lists, but got {type(list_obj)}" + ) + list_obj.extend(items) + elif key[0] == SETITEM[0]: + (v, k) = (self.stack.pop(), self.stack.pop()) + self.stack[-1][k] = v + elif key[0] == SETITEMS[0]: + items = self.pop_mark() + for i in range(0, len(items), 2): + self.stack[-1][items[i]] = items[i + 1] + elif key[0] == MARK[0]: + self.metastack.append(self.stack) + self.stack = [] + self.append = self.stack.append + elif key[0] == TUPLE[0]: + items = self.pop_mark() + self.append(tuple(items)) + elif key[0] == TUPLE1[0]: + self.stack[-1] = (self.stack[-1],) + elif key[0] == TUPLE2[0]: + self.stack[-2:] = [(self.stack[-2], self.stack[-1])] + elif key[0] == TUPLE3[0]: + self.stack[-3:] = [(self.stack[-3], self.stack[-2], self.stack[-1])] + # Basic types construction + elif key[0] == NONE[0]: + self.append(None) + elif key[0] == NEWFALSE[0]: + self.append(False) + elif key[0] == NEWTRUE[0]: + self.append(True) + elif key[0] == EMPTY_TUPLE[0]: + self.append(()) + elif key[0] == EMPTY_LIST[0]: + self.append([]) + elif key[0] == EMPTY_DICT[0]: + self.append({}) + elif key[0] == EMPTY_SET[0]: + self.append(set()) + elif key[0] == BININT[0]: + self.append(unpack("d", self.read(8))[0]) + elif key[0] == BINUNICODE[0]: + strlen = unpack(" maxsize: + raise RuntimeError("String is too long") + strval = str(read(strlen), "utf-8", "surrogatepass") + self.append(strval) + elif key[0] == SHORT_BINSTRING[0]: + strlen = read(1)[0] + strdata = read(strlen) + if self.encoding != "bytes": + strdata = strdata.decode(self.encoding, "strict") + self.append(strdata) + elif key[0] == BINPERSID[0]: + pid = self.stack.pop() + # Only allow persistent load of storage + if type(pid) is not tuple and not type(pid) is not int: + raise RuntimeError( + f"persistent_load id must be tuple or int, but got {type(pid)}" + ) + if ( + type(pid) is tuple + and len(pid) > 0 + and torch.serialization._maybe_decode_ascii(pid[0]) != "storage" + ): + raise RuntimeError( + f"Only persistent_load of storage is allowed, but got {pid[0]}" + ) + self.append(self.persistent_load(pid)) + elif key[0] in [BINGET[0], LONG_BINGET[0]]: + idx = (read(1) if key[0] == BINGET[0] else unpack(" _T: ... + +next = advance_iterator + +def callable(obj: object) -> bool: ... +def get_unbound_function(unbound: types.MethodType) -> types.FunctionType: ... +def create_bound_method(func: types.FunctionType, obj: object) -> types.MethodType: ... +def create_unbound_method(func: types.FunctionType, cls: Union[type, types.ClassType]) -> types.MethodType: ... + +class Iterator: + def next(self) -> Any: ... + +def get_method_function(meth: types.MethodType) -> types.FunctionType: ... +def get_method_self(meth: types.MethodType) -> Optional[object]: ... +def get_function_closure(fun: types.FunctionType) -> Optional[Tuple[types._Cell, ...]]: ... +def get_function_code(fun: types.FunctionType) -> types.CodeType: ... +def get_function_defaults(fun: types.FunctionType) -> Optional[Tuple[Any, ...]]: ... +def get_function_globals(fun: types.FunctionType) -> Dict[str, Any]: ... +def iterkeys(d: Mapping[_K, _V]) -> typing.Iterator[_K]: ... +def itervalues(d: Mapping[_K, _V]) -> typing.Iterator[_V]: ... +def iteritems(d: Mapping[_K, _V]) -> typing.Iterator[Tuple[_K, _V]]: ... + +# def iterlists + +def viewkeys(d: Mapping[_K, _V]) -> KeysView[_K]: ... +def viewvalues(d: Mapping[_K, _V]) -> ValuesView[_V]: ... +def viewitems(d: Mapping[_K, _V]) -> ItemsView[_K, _V]: ... +def b(s: str) -> binary_type: ... +def u(s: str) -> text_type: ... + +int2byte = chr + +def byte2int(bs: binary_type) -> int: ... +def indexbytes(buf: binary_type, i: int) -> int: ... +def iterbytes(buf: binary_type) -> typing.Iterator[int]: ... +def assertCountEqual(self: unittest.TestCase, first: Iterable[_T], second: Iterable[_T], msg: str = ...) -> None: ... +@overload +def assertRaisesRegex(self: unittest.TestCase, msg: str = ...) -> Any: ... +@overload +def assertRaisesRegex(self: unittest.TestCase, callable_obj: Callable[..., Any], *args: Any, **kwargs: Any) -> Any: ... +def assertRegex( + self: unittest.TestCase, text: AnyStr, expected_regex: Union[AnyStr, Pattern[AnyStr]], msg: str = ... +) -> None: ... +def reraise( + tp: Optional[Type[BaseException]], value: Optional[BaseException], tb: Optional[types.TracebackType] = ... +) -> NoReturn: ... +def exec_(_code_: Union[unicode, types.CodeType], _globs_: Dict[str, Any] = ..., _locs_: Dict[str, Any] = ...): ... +def raise_from(value: Union[BaseException, Type[BaseException]], from_value: Optional[BaseException]) -> NoReturn: ... + +print_ = print + +def with_metaclass(meta: type, *bases: type) -> type: ... +def add_metaclass(metaclass: type) -> Callable[[_T], _T]: ... +def ensure_binary(s: Union[bytes, Text], encoding: str = ..., errors: str = ...) -> bytes: ... +def ensure_str(s: Union[bytes, Text], encoding: str = ..., errors: str = ...) -> str: ... +def ensure_text(s: Union[bytes, Text], encoding: str = ..., errors: str = ...) -> Text: ... +def python_2_unicode_compatible(klass: _T) -> _T: ... + +class _LazyDescriptor: + name: str + def __init__(self, name: str) -> None: ... + def __get__(self, obj: Optional[object], type: Optional[type] = ...) -> Any: ... + +class MovedModule(_LazyDescriptor): + mod: str + def __init__(self, name: str, old: str, new: Optional[str] = ...) -> None: ... + def __getattr__(self, attr: str) -> Any: ... + +class MovedAttribute(_LazyDescriptor): + mod: str + attr: str + def __init__( + self, name: str, old_mod: str, new_mod: str, old_attr: Optional[str] = ..., new_attr: Optional[str] = ... + ) -> None: ... + +def add_move(move: Union[MovedModule, MovedAttribute]) -> None: ... +def remove_move(name: str) -> None: ... diff --git a/shared/package-files/2f/2fb0a7b2f6d00be53b8a36d265dbbb0c4af4de9f3c38b8f820fbc527fde4083a/blob b/shared/package-files/2f/2fb0a7b2f6d00be53b8a36d265dbbb0c4af4de9f3c38b8f820fbc527fde4083a/blob new file mode 100644 index 0000000000000000000000000000000000000000..4a8fd5fb50c3178f5a5cdab1e80423df8b52f525 --- /dev/null +++ b/shared/package-files/2f/2fb0a7b2f6d00be53b8a36d265dbbb0c4af4de9f3c38b8f820fbc527fde4083a/blob @@ -0,0 +1,5 @@ +from sympy.physics.mechanics.method import _Methods +from sympy.testing.pytest import raises + +def test_method(): + raises(TypeError, lambda: _Methods()) diff --git a/shared/package-files/2f/2fb0dd5c96705dc26be4ba7eb5d7a579b302577b4fdb45d7c739362ac04117f5/blob b/shared/package-files/2f/2fb0dd5c96705dc26be4ba7eb5d7a579b302577b4fdb45d7c739362ac04117f5/blob new file mode 100644 index 0000000000000000000000000000000000000000..7f04a5a0bd3761027266abf63fda91baf3346f47 Binary files /dev/null and b/shared/package-files/2f/2fb0dd5c96705dc26be4ba7eb5d7a579b302577b4fdb45d7c739362ac04117f5/blob differ diff --git a/shared/package-files/2f/2fb19c6638c85db0f0a9fe88a787a3b63a30da229392f8b7285012d71e8667a6/blob b/shared/package-files/2f/2fb19c6638c85db0f0a9fe88a787a3b63a30da229392f8b7285012d71e8667a6/blob new file mode 100644 index 0000000000000000000000000000000000000000..65d3b6312f1b39772fdd268558fa02f103a2720f --- /dev/null +++ b/shared/package-files/2f/2fb19c6638c85db0f0a9fe88a787a3b63a30da229392f8b7285012d71e8667a6/blob @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor _to_sparse(const at::Tensor & self, int64_t sparse_dim); +TORCH_API at::Tensor _to_sparse(const at::Tensor & self, c10::optional layout=c10::nullopt, at::OptionalIntArrayRef blocksize=c10::nullopt, c10::optional dense_dim=c10::nullopt); + +} // namespace cuda +} // namespace at diff --git a/shared/package-files/2f/2fb38b4117fafc605d1a70bc197fab52e2044d8a48e90f42ce4709c9a488f330/blob b/shared/package-files/2f/2fb38b4117fafc605d1a70bc197fab52e2044d8a48e90f42ce4709c9a488f330/blob new file mode 100644 index 0000000000000000000000000000000000000000..b94c4d46dba26adccf67224f3f82de0b9387b284 --- /dev/null +++ b/shared/package-files/2f/2fb38b4117fafc605d1a70bc197fab52e2044d8a48e90f42ce4709c9a488f330/blob @@ -0,0 +1,22 @@ +#pragma once + +// Test these using #if AT_MKL_ENABLED(), not #ifdef, so that it's +// obvious if you forgot to include Config.h +// c.f. https://stackoverflow.com/questions/33759787/generating-an-error-if-checked-boolean-macro-is-not-defined +// +// DO NOT put the macros for CUDA libraries in this file; they belong in cuda/CUDAConfig.h + +#define AT_MKLDNN_ENABLED() 1 +#define AT_MKLDNN_ACL_ENABLED() 0 +#define AT_MKL_ENABLED() 1 +#define AT_MKL_SEQUENTIAL() 0 +#define AT_POCKETFFT_ENABLED() 0 +#define AT_NNPACK_ENABLED() 1 +#define CAFFE2_STATIC_LINK_CUDA() 0 +#define AT_BUILD_WITH_BLAS() 1 +#define AT_BUILD_WITH_LAPACK() 1 +#define AT_PARALLEL_OPENMP 1 +#define AT_PARALLEL_NATIVE 0 +#define AT_PARALLEL_NATIVE_TBB 0 +#define AT_BLAS_F2C() 0 +#define AT_BLAS_USE_CBLAS_DOT() 0 diff --git a/shared/package-files/2f/2fb4934e69515fecfe62f92c9a203111ed54a139839d0fe59c08d91f9dd2ce9d/blob b/shared/package-files/2f/2fb4934e69515fecfe62f92c9a203111ed54a139839d0fe59c08d91f9dd2ce9d/blob new file mode 100644 index 0000000000000000000000000000000000000000..da698cf511e6983e1db1bbed6e2974f3480a6903 --- /dev/null +++ b/shared/package-files/2f/2fb4934e69515fecfe62f92c9a203111ed54a139839d0fe59c08d91f9dd2ce9d/blob @@ -0,0 +1 @@ +0.0211635609063 0.00455072769716 0.0230610904531 0.0076674324982 0.037571216894 0.029561354778 0.0115281186735 0.0225809070507 0.0346801442638 0.00321049176948 0.0232839774828 0.0321124517082 0.0244179197971 0.0331466156799 0.0373949302575 0.0411984503375 0.0218945865519 0.0198268474453 0.02395616278 0.0254898420418 0.0394901943037 0.0396613298853 0.0621120626322 0.0458316817045 0.0334832834948 0.0445794256135 0.00775602650151 0.00770188279153 0.0277044809709 0.0292851269343 0.0408206135002 0.0384837880405 0.0229145225178 0.0346801442638 0.017155900548 0.0186865079856 0.0346801442638 0.011778601551 0.0109570078484 0.0244803928224 0.0609237090857 0.0125274661674 0.0713079215249 0.05072181848 0.0329702193648 0.018118079192 0.0129441131729 0.00461235131171 0.0077204189151 0.190781073622 0.196235539354 0.202381067744 0.215567934651 0.208951210729 0.208395222197 0.202977772245 0.185995150024 0.197488445796 0.207754344906 0.207231776416 0.200895721783 0.202370257926 0.208839694602 0.184151316466 0.18979501874 0.211864590783 0.187854399445 0.231134943838 0.195836809821 0.220082308081 0.191451897661 0.227329222402 0.204586412278 0.192443163994 0.193684928543 0.206841791869 0.21612354251 0.209268704489 0.175345617131 0.197941218478 0.190625337098 0.191065854858 0.2317867516 0.214902945463 0.200203629275 0.200116177839 0.216845735492 0.194043462589 0.208271280018 0.210985756639 0.203659220099 0.197020978632 0.188475437149 0.205376756706 0.190989482965 0.1980172695 0.194499957306 0.176357663314 0.198492265793 0.255232551639 0.244270007892 0.240469208946 0.23837051036 0.248414598574 0.246817944636 0.244919131711 0.239985639856 0.249741998486 0.238825041235 0.224881988223 0.240479022193 0.236919216915 0.253134884385 0.257281336145 0.239143010746 0.231252341207 0.230464321684 0.26688757037 0.243702807017 0.239741931201 0.243722504108 0.250777226737 0.230838149152 0.233779458319 0.227365052742 0.226996712309 0.224529623997 0.248876761269 0.223504306637 0.241222705588 0.218359591571 0.251783757155 0.22178058433 0.237922879169 0.243259140467 0.243757719218 0.229784431814 0.223834512884 0.231417699032 0.245855002542 0.23260880661 0.244270007892 0.24412721812 0.245364556958 0.239069534798 0.242476824971 0.231950344971 0.238821966724 0.23119389821 0.0191037071088 0.0192689125135 0.0279599225292 0.0400056720024 0.0369973592153 0.0168401225107 0.0156647141811 0.0317569365649 0.0209196472407 0.0261095572505 0.0295911292198 0.0387034711929 0.047943015361 0.0502801086558 0.0505076233319 0.0276985510653 0.0178344200842 0.0354647529806 0.0132311775272 0.0439058315568 0.0587698655317 0.0548749800113 0.0420211683289 0.0158475875817 0.0410205075223 0.0159821398213 0.0151652303532 0.0238719428054 0.0190485214781 0.0351129659726 0.0545720530766 0.0439213935019 0.0317569365649 0.0241815879409 0.0259117209292 0.0317569365649 0.0173211662353 0.0138864344566 0.0338981856531 0.0429537854169 0.027658485714 0.0691172321094 0.0500059403041 0.0236011037029 0.0316644090037 0.0201837094834 0.0228863104939 0.0134861623597 0.176517909274 0.183281450302 0.188265462996 0.20119658342 0.194697326208 0.195209942657 0.190674274015 0.172425697578 0.182894065786 0.195529592383 0.192026007893 0.188346396823 0.186051479032 0.19538200246 0.171605310091 0.175766658214 0.199864266754 0.173408334646 0.215875435175 0.181358449055 0.208526316653 0.177419239992 0.212710197663 0.190468934035 0.178153770213 0.179556589614 0.19192211318 0.202468559318 0.196181327665 0.160572766746 0.183327527516 0.175701303909 0.177066663037 0.218355819513 0.203310616701 0.188843124957 0.186323930321 0.201194011774 0.18173319992 0.194510318604 0.197386404553 0.190483994401 0.182718294182 0.174255518011 0.19205782762 0.178239088983 0.18513760318 0.180597338326 0.163063102971 0.185284857996 0.243887274146 0.231624187925 0.22689829944 0.225289762668 0.235796354542 0.23269059518 0.23306609907 0.225602345189 0.235244584021 0.226892475392 0.212543999067 0.226908361887 0.223757309255 0.240296170501 0.245569279789 0.227339668618 0.2180947426 0.217889650333 0.252259964829 0.228879839341 0.227150610245 0.231836962279 0.236076260811 0.217244760533 0.221438124324 0.213671912157 0.213819376581 0.212040793299 0.235827974309 0.209053467969 0.226615210725 0.205271111175 0.238869689413 0.207939309627 0.223898822147 0.229226063436 0.232630777303 0.217026651272 0.211532427176 0.218347693285 0.233460132247 0.219891922362 0.231624187925 0.231652249658 0.233525349836 0.226377769419 0.228579062405 0.219098380821 0.227789794229 0.219023772057 0.0212386043587 0.00993825296406 0.0336976816686 0.0262325070397 0.0107568964379 0.0200399473123 0.0369530877134 0.00706121377315 0.0225180018442 0.0345620434634 0.0288649599558 0.0352792061476 0.0352526366714 0.0385518621347 0.0178346265809 0.0156087458393 0.0212893461987 0.0244762891905 0.0356848493955 0.0412118431681 0.0577499958146 0.0449060313177 0.0316682156452 0.0402876009485 0.00791017688182 0.00777689270989 0.0262859463939 0.0275691765497 0.0363841779992 0.0426229028778 0.0258430808451 0.0369530877134 0.0171494695134 0.0197038085728 0.0369530877134 0.00856221073911 0.010146504576 0.0213442662268 0.0572142712511 0.0116574543859 0.0671597340405 0.047388301579 0.0285557929122 0.0192111185981 0.0112749020632 0.00781127840012 0.00637566729419 0.187210918471 0.192623672543 0.198833727144 0.212008654042 0.205367416257 0.204958566039 0.199402528264 0.182409867249 0.193987091024 0.204155295526 0.20374075502 0.197257634781 0.198980554413 0.205364330922 0.180426094029 0.186163209648 0.208359044162 0.184479344493 0.227592539467 0.192334488284 0.216529219774 0.187806950452 0.223855994439 0.201226354807 0.188864300604 0.190066520684 0.203335651256 0.212548662023 0.205705049083 0.171742464799 0.194417377469 0.187136601809 0.187472552212 0.228344421279 0.211429948522 0.196622478767 0.196530972542 0.21335054643 0.190497911091 0.204702393397 0.207598118603 0.200155023454 0.193467129006 0.184880183147 0.201857382862 0.187517863683 0.194486736804 0.1909406597 0.172553592377 0.194927231832 0.251743344729 0.240762357546 0.236947962879 0.234942968898 0.244909063494 0.243388177909 0.24143957892 0.236617606758 0.24633077256 0.235257992461 0.221275459366 0.23695229759 0.23334624948 0.249598367646 0.253700089415 0.235542233543 0.227782636512 0.227013807453 0.263469639225 0.240293112196 0.236160757703 0.240179126335 0.247395319298 0.227257451928 0.23025606552 0.223937789122 0.223399862869 0.220967129276 0.245363860699 0.220116506797 0.237779687596 0.214888164759 0.248252329967 0.218347705592 0.234681014401 0.239690494574 0.240217402996 0.22632629355 0.220260809644 0.227813787503 0.242262375922 0.228918020841 0.240762357546 0.240592325032 0.241778783496 0.235418026861 0.23890352284 0.228365058816 0.235271978928 0.227703766766 0.0251699105319 0.0326109277538 0.029278801732 0.0117605763436 0.00495713045566 0.032971458625 0.022273270218 0.00845866705418 0.0338325850006 0.0418060793613 0.0560571569439 0.0475989809058 0.0526432986362 0.0287512950603 0.0156470261333 0.0286833299321 0.0125318521449 0.039628171731 0.0605879245284 0.051592881751 0.0247889558 0.0185457610439 0.0360813596602 0.0162897964903 0.0233731835598 0.00555113851114 0.00851608036789 0.039350861172 0.0494281040416 0.0428445793936 0.032971458625 0.0361084743768 0.0382083791018 0.032971458625 0.0135564720949 0.0133460812565 0.0359059029584 0.0525998249753 0.020448013216 0.0653401649712 0.0366222774812 0.0276779812669 0.0199994530533 0.0115734561992 0.0214333278479 0.0186461579961 0.171344593808 0.177166238774 0.182950771401 0.19643196185 0.18986301898 0.188443393542 0.18388535541 0.166562175459 0.177783941311 0.188923487579 0.187724110496 0.182156573883 0.18272910062 0.189078094755 0.165787292858 0.170722554665 0.192539814536 0.167433166664 0.21234151671 0.17610118578 0.201339136255 0.172496446246 0.207869320447 0.184234771078 0.173084677744 0.174586008872 0.187343267555 0.197067369338 0.190065322687 0.155992913972 0.178370192697 0.170834599332 0.171756811444 0.21215391799 0.195543956872 0.181382419503 0.180878423055 0.197648250997 0.174630568935 0.189049602981 0.190809942592 0.184007315234 0.177572802284 0.169158986096 0.1858235382 0.171054750208 0.178472858167 0.175024341592 0.15843173338 0.179125844986 0.236753289776 0.225336913605 0.221457751336 0.21877528886 0.229546376269 0.227338714151 0.226000082599 0.220106179064 0.230241030133 0.220420771483 0.206398010187 0.221506177578 0.218254053746 0.234550382603 0.23950257292 0.221077875617 0.211789394262 0.210958467875 0.247726054061 0.224160699687 0.221293898641 0.225242596712 0.231164838975 0.212084684776 0.21483758197 0.207582855086 0.208324546741 0.205668770285 0.22999948579 0.203519866038 0.221791807814 0.198729512666 0.233119883684 0.201955632148 0.21744774227 0.224658382044 0.22554531899 0.210282327898 0.205086194314 0.212901784527 0.227685054369 0.214992030153 0.225336913605 0.225426421062 0.227294020009 0.22122180599 0.223891772502 0.213328572484 0.220627825622 0.212027719306 0.036692370716 0.0274221847228 0.014614486903 0.0257905543192 0.038185072385 0.00854173398239 0.0228846598272 0.0362880440778 0.0247966202157 0.0338575762449 0.0341810302892 0.0403839419732 0.023192138006 0.0228332335778 0.0207802721216 0.030246984472 0.0385095591836 0.036116458124 0.063670015249 0.0456331337141 0.0387265099713 0.0454622939774 0.0128829753328 0.0153687384621 0.0290580106985 0.032571197138 0.0439484983687 0.0345946330706 0.0178789804494 0.038185072385 0.0229066226947 0.0243703411158 0.038185072385 0.0145921399018 0.0157758022112 0.0246899780508 0.0667942861058 0.00859371091119 0.0713780561444 0.0493343894065 0.0370078971529 0.0136450272229 0.0138896306008 0.00617904291603 0.0146027872105 0.19304474601 0.19797909852 0.204564547012 0.217893788171 0.211240589753 0.210085035577 0.204424468033 0.187966151726 0.199846283114 0.209201380502 0.209876418912 0.202509063074 0.205495616388 0.210676243708 0.185852822947 0.192014733821 0.213129345848 0.190059083655 0.233894763867 0.198141527364 0.221234996275 0.193689434624 0.229701750232 0.206631480423 0.194727732257 0.195938025333 0.209362001884 0.218147207364 0.211029564766 0.177869147322 0.200327033561 0.193124484677 0.193233901741 0.233604044389 0.215980508747 0.201289146742 0.20219168761 0.219726845187 0.195458087393 0.2103246028 0.212820091698 0.205396680761 0.199290845186 0.190742394929 0.207189399227 0.192521418757 0.199651552643 0.196594932336 0.178468769167 0.200295584792 0.256297768876 0.245841451519 0.242438509968 0.240033073248 0.249980802879 0.248953385462 0.246144223104 0.242178797272 0.252036489845 0.240176361939 0.226412773569 0.242454491215 0.238768549206 0.254841315698 0.258625650226 0.240494667361 0.232976534038 0.231927166971 0.269283834821 0.246140263748 0.241374087503 0.245035624054 0.253144665918 0.232868387014 0.235226383286 0.229279397026 0.228861516729 0.226064745168 0.250630665997 0.225726655668 0.243583203961 0.220042394187 0.253511231548 0.2237596548 0.239872842457 0.245497904196 0.24478307529 0.231328796826 0.225307213023 0.233256809435 0.247442229489 0.234444929147 0.245841451519 0.245661961251 0.246724980668 0.240848644418 0.244659004118 0.233675626419 0.239814102397 0.232532592403 0.010524058973 0.0347497758249 0.0310026365608 0.0636683508445 0.039628310023 0.0339732471818 0.0632599742009 0.0607622080336 0.0610552648732 0.0274939888458 0.0321794296029 0.0203038890155 0.0225566538528 0.0181521200419 0.0426282898435 0.00971744861179 0.0573638408809 0.0304112802741 0.0463628234513 0.044509344874 0.0125060810098 0.0372012029006 0.0399195029174 0.0351572922113 0.0381714857339 0.0236066809352 0.0675880085279 0.0489234884353 0.0636683508445 0.0451372647506 0.0495218266562 0.0636683508445 0.028718795999 0.0363358460459 0.0247409309981 0.0536494939568 0.0291783067693 0.0362475310016 0.0206193569389 0.0238060051702 0.0365127412376 0.0303247636874 0.0382706081182 0.036679138207 0.165252454208 0.168745392776 0.176697416201 0.190075579294 0.183193768644 0.182210296577 0.174895117306 0.159516185843 0.172780618769 0.179424300801 0.183362052205 0.17275366841 0.180884475296 0.18272692365 0.155645508044 0.163596126812 0.183814684533 0.163944686708 0.206939183794 0.170981324059 0.191238016882 0.165171506195 0.202635613449 0.180157192696 0.16688029242 0.167662828735 0.182473473654 0.189606814944 0.182144568907 0.150494922446 0.17311022882 0.166528964674 0.165043072843 0.205731384902 0.18659197245 0.17105591364 0.173799739615 0.193545885155 0.166211621507 0.181959703917 0.185636136233 0.177047042786 0.171588556623 0.162758165885 0.178831153511 0.164197394115 0.170920859204 0.168528635782 0.148460744764 0.171573948268 0.226522867074 0.216861787556 0.214094925757 0.211961277469 0.220987866614 0.22168305754 0.216782699249 0.215609692292 0.225208444508 0.210312198283 0.19661028383 0.214074476024 0.209773195915 0.225810880474 0.228551359916 0.210341321513 0.204691741777 0.203336697222 0.242485382573 0.21963599647 0.211892193047 0.215282949931 0.226705435666 0.20418234927 0.205942096193 0.201754356567 0.199749686219 0.196656401255 0.221913123953 0.199165134473 0.216656797893 0.191759529503 0.224569670715 0.196349964299 0.213992874847 0.217230566883 0.214548114667 0.2028246956 0.195690210734 0.20400781198 0.217750478797 0.204445613083 0.216861787556 0.216379424168 0.21668692278 0.211041069144 0.216249554038 0.204373397921 0.209459569208 0.203359671893 0.0284940982012 0.0283835072119 0.0582564069663 0.0317209110303 0.0290062929149 0.0575581968066 0.0518675712793 0.0525497818792 0.0214648817816 0.0289820919427 0.0151981567712 0.0194868108708 0.00772151270155 0.0396885548083 0.0133170749495 0.0480498930165 0.0406834920646 0.0454173876936 0.04374952779 0.0223043370554 0.0304932603619 0.0333669476098 0.0323541790178 0.036462611527 0.0283937271683 0.0581656862224 0.0386849486073 0.0582564069663 0.0386824403573 0.0427767064205 0.0582564069663 0.0225670168648 0.0303996112373 0.0186317385432 0.0589532282724 0.020129496567 0.0456219811369 0.0271705146906 0.0266114081755 0.0281840659315 0.0237276312035 0.0300017258072 0.0304084467621 0.174689674341 0.17830904459 0.186122916272 0.199541551099 0.192698821274 0.191439303409 0.184399484383 0.168993025372 0.182083678728 0.188980455315 0.192641208359 0.182376656778 0.189869605957 0.192034662906 0.165406381187 0.173160863593 0.193190156667 0.172952807322 0.216356837462 0.18028635421 0.200707489616 0.174765006311 0.211946253402 0.189197004074 0.176338357547 0.17720731475 0.191796191467 0.199121585044 0.191634817003 0.159923924784 0.182459504488 0.175769947329 0.174536678956 0.215011640541 0.195898920801 0.180555890973 0.183304141459 0.202828623711 0.175640593326 0.191448592698 0.194762075203 0.186406863824 0.181008054094 0.172240816201 0.188223844291 0.17346231425 0.180325575914 0.177965844821 0.158332658267 0.181046361448 0.235882031296 0.226280867303 0.2235366831 0.221221709251 0.230404936567 0.23094802366 0.226136073658 0.224736021115 0.234431734165 0.219824894986 0.20619515856 0.223526372128 0.219308937798 0.235287233784 0.23807753807 0.219908336162 0.214027462834 0.212631745032 0.251732773763 0.228838671706 0.221440978506 0.224753704594 0.235866097652 0.213724598783 0.215380278296 0.210994508636 0.209321687173 0.206162323946 0.231346876087 0.208300913946 0.225928825898 0.201080283138 0.234037288778 0.20558958438 0.222856381147 0.226751911512 0.223989137906 0.212135251626 0.205214537461 0.213595258296 0.2273163389 0.21417146415 0.226280867303 0.225846388312 0.226229092302 0.220705781832 0.225781259333 0.213928177909 0.218913775078 0.212729498479 0.0122225873329 0.0303322491715 0.0105162282326 0.0130161869455 0.0294681125528 0.031169289575 0.0445674903412 0.0424428041907 0.0471592401326 0.0242919299586 0.0151911030837 0.0250458377851 0.0159588466859 0.0393890228389 0.0501712969027 0.0573610210315 0.0347635318983 0.0244162409612 0.040396894165 0.00489128055225 0.0130158047868 0.0162739668734 0.0181749821427 0.0399100872217 0.0416234365466 0.032217222914 0.0303322491715 0.0260818708259 0.0277812891175 0.0303322491715 0.0068887146948 0.00350057866506 0.0298024545939 0.056647752597 0.0131029257559 0.0689399130874 0.0438694576111 0.0295733202179 0.0148293487362 0.005187559828 0.00994170320116 0.00857601759458 0.181761248694 0.187453410696 0.193365623784 0.206702523841 0.20011934013 0.199105672278 0.194191029325 0.176999836949 0.188302627791 0.199111466491 0.198126208998 0.192301121465 0.193121251528 0.199652739338 0.175765384319 0.180985589904 0.202947496477 0.178262931918 0.22241465847 0.18663850283 0.211489015658 0.182706386145 0.218266373994 0.195039865626 0.18346554188 0.184856636434 0.197755074291 0.207324505424 0.200404409787 0.166355990223 0.188830148216 0.181378679541 0.182125858248 0.222660838403 0.205968099039 0.191576935017 0.19121911341 0.207887116649 0.185081160877 0.199380829938 0.201554837448 0.194543615891 0.187991163757 0.179524780118 0.19631300534 0.181726234556 0.188970696545 0.185468734774 0.168191837054 0.18953883133 0.246767069406 0.235545780286 0.231684267956 0.229269594484 0.239724337717 0.237749571543 0.236212316891 0.230682790909 0.240645700931 0.230405224861 0.216420479968 0.231715542723 0.228337424754 0.244594612682 0.249193956399 0.230909382279 0.222229420235 0.221427946934 0.257965809127 0.234573740528 0.231288571496 0.235259005866 0.241607850531 0.22220070955 0.225060949621 0.218149643482 0.218415896436 0.21585883122 0.24017332069 0.214149237729 0.232167950695 0.20925074028 0.243199182069 0.21253980165 0.228281003551 0.23468620257 0.235446691383 0.22074773222 0.215228869367 0.222922571895 0.237553097068 0.224606387466 0.235545780286 0.235534393045 0.23712429287 0.230940484692 0.233917063813 0.223401305554 0.230524046304 0.222353817706 0.0346270873711 0.0222428303765 0.0130402644662 0.0348466257078 0.042829178942 0.0549568638218 0.0464424131108 0.050271964255 0.0260503884653 0.0122224116333 0.0282180922789 0.011864843965 0.0376053109772 0.060340947297 0.0487164281844 0.0285013587126 0.0163929694658 0.0334500762426 0.015996373074 0.0216948948211 0.00981357617646 0.00897169179454 0.0351677992971 0.0524329239391 0.0436506734112 0.0346270873711 0.0336931600411 0.03612022228 0.0346270873711 0.0123155461924 0.0128144174355 0.033561339537 0.0480641708164 0.0212422700005 0.0628734973132 0.0366806543871 0.0231396795589 0.0230741684915 0.0123098386274 0.0219470818919 0.0170687771133 0.170097980345 0.176050748737 0.181762587161 0.195138740624 0.188553715994 0.187634353283 0.182931238354 0.165421712546 0.176600578903 0.187912731345 0.186408453678 0.181027641681 0.181322068987 0.188146844457 0.16448627936 0.169388121003 0.191757508168 0.166524283083 0.21084441712 0.17494262847 0.200480456222 0.171127562134 0.206682857942 0.183402734812 0.171811556423 0.173255302855 0.186064001811 0.195873759085 0.189008503285 0.154586199139 0.177136590503 0.16961214015 0.170511848112 0.211247624618 0.194873193684 0.18053463387 0.179673493778 0.196193226513 0.173758955601 0.187869379999 0.19001738823 0.183074417621 0.176342969787 0.167870586049 0.184832516957 0.170273119593 0.177542554096 0.173865162824 0.156824879402 0.178069468543 0.235952767235 0.224377142544 0.220334312937 0.217941307072 0.228582134377 0.226295522057 0.225204079848 0.219149120214 0.229153457047 0.219423743811 0.20530168342 0.220370010221 0.217084867796 0.233463162138 0.238411309618 0.220004052761 0.210872881275 0.210171938201 0.24654768975 0.223020715486 0.220176358035 0.224293060856 0.230089603615 0.210845620347 0.213914309618 0.206670271948 0.207126565579 0.204661896322 0.228953899388 0.202543633745 0.220637247329 0.197849243585 0.232039444595 0.201016080923 0.216786754649 0.223327252818 0.224678101179 0.209454984614 0.204079198003 0.211687536154 0.226538202286 0.213579234366 0.224377142544 0.224425108032 0.226231350025 0.219899730556 0.222577135927 0.212192019374 0.21976273048 0.211209202307 0.0316629149872 0.033505533415 0.00599304401229 0.03147088677 0.0569379974042 0.0709823822809 0.0748230813085 0.0531369685873 0.043263968218 0.0546416139704 0.0249055105449 0.0688386171987 0.0687094353901 0.0814189949505 0.0424145094995 0.0312264925083 0.0671690041442 0.0297074253675 0.0326159908833 0.0331671559449 0.0312681130066 0.0653641254742 0.040141041955 0.0490986378456 0.0 0.0426893927085 0.0408370899258 0.0 0.0368318621027 0.029200211213 0.0578784327643 0.069522041979 0.0411420259607 0.0955605905857 0.0684916485028 0.0536985636371 0.0361283833003 0.0349236407736 0.0326544016244 0.0320790517512 0.190734279342 0.198011093099 0.202165335147 0.215193803756 0.208989236133 0.207943677959 0.205067684162 0.186855165408 0.196324830352 0.210203923195 0.205342231011 0.203427359944 0.198526873832 0.208498767129 0.187766259392 0.1906844311 0.213518747065 0.185598548292 0.229746939288 0.194805777978 0.222821572969 0.192481412892 0.225723793976 0.202375384198 0.192457483521 0.194300696695 0.205376522136 0.216660688755 0.21030774241 0.175307222553 0.197000980201 0.189066511629 0.191539232379 0.231058906578 0.21669613367 0.203523564636 0.200666530244 0.214595210264 0.195827171333 0.208641958794 0.209561099462 0.203960485003 0.196717491572 0.188766309975 0.205678014795 0.191492051166 0.198961164508 0.194672996958 0.180152450124 0.19944864987 0.257583228235 0.245178524187 0.240481186058 0.23786630337 0.249341975217 0.245210894146 0.246468005973 0.237456371003 0.247563146561 0.241300303041 0.22729752986 0.240555698528 0.237993038095 0.254193700204 0.26033321069 0.24220764546 0.231128442611 0.230799434891 0.264694157473 0.241194058993 0.241588310222 0.245985985156 0.248083056968 0.231516408669 0.235215479132 0.226198260689 0.228320459149 0.22623565919 0.249391170367 0.221152204365 0.239284874476 0.218351963925 0.252686589685 0.220530747351 0.234477098822 0.243363395844 0.246969168578 0.229990071021 0.225895881072 0.232959826282 0.248113114083 0.23570223574 0.245178524187 0.245562733947 0.248226439579 0.241702239505 0.242775171886 0.233515238499 0.242256602421 0.232453320509 0.0221776604768 0.0292076409984 0.0225953199419 0.0344078822964 0.0402556862186 0.0443490345462 0.0247422055695 0.0212582761966 0.0262237412261 0.0239779350196 0.0420497572884 0.0414593565817 0.0638943455501 0.0444256278823 0.0324613404347 0.0464717210574 0.0064847144584 0.00810593532016 0.026613709743 0.0281809240896 0.0431707040779 0.0364933096346 0.0236549105265 0.0316629149872 0.0188389154871 0.0197111271958 0.0316629149872 0.0126413659503 0.00989228745945 0.0276229976961 0.0619054176788 0.0136582341261 0.0735855911944 0.0517713161376 0.0346942423053 0.0171636471405 0.0128780143687 0.00330427938484 0.00787705209324 0.191124461218 0.196709270957 0.202716444922 0.215924187936 0.209335641351 0.208652638742 0.203456445375 0.186385899088 0.197740844714 0.208277146555 0.207460837635 0.201437849638 0.202451222155 0.209128071387 0.184787202976 0.190226937612 0.212288039878 0.187958804478 0.231460569504 0.196093364986 0.220613648389 0.191903262961 0.227580912528 0.204703238288 0.192798319471 0.194099784682 0.207098250381 0.21653588119 0.209689452484 0.175692486622 0.198220686642 0.190843207535 0.19145100341 0.232063526554 0.215320322312 0.200757345911 0.200512766736 0.217080327154 0.194471953875 0.2086592247 0.211165769014 0.203992872465 0.197349559187 0.188849659131 0.205722712353 0.191296031353 0.198394567468 0.194851113014 0.177048060287 0.198893335106 0.255751598489 0.244696550693 0.240850735029 0.238657915403 0.248846650839 0.247061872969 0.245367004129 0.240135191988 0.249950401792 0.239377278919 0.225435027987 0.240867925442 0.23738991955 0.253602763959 0.257909304325 0.239755581779 0.231578379023 0.230802663983 0.267123052444 0.243889033036 0.240266927764 0.244253437447 0.250943098487 0.231284290644 0.234232349856 0.227603903464 0.227483301065 0.225010355342 0.249291083828 0.223656027478 0.241455021635 0.21867583866 0.252237135554 0.222012069338 0.237944922778 0.2436864771 0.244348021388 0.230119265967 0.224342678419 0.231928535106 0.246422479994 0.233277995952 0.244696550693 0.244602643666 0.245964063641 0.239692017082 0.242916090829 0.232449793011 0.23942553099 0.231611684555 0.0349328180738 0.0397488289561 0.055917859907 0.0466657680267 0.0537525131124 0.0312322620487 0.0204661899168 0.0273925121636 0.0188335643607 0.0409848131484 0.0582072876054 0.056071962696 0.0229170555223 0.0261517042618 0.0397135231185 0.0177392332242 0.0260266328079 0.00803879586998 0.0153514357558 0.0448019039458 0.0436873202641 0.0393784019825 0.033505533415 0.038918396453 0.040710313775 0.033505533415 0.0158373818638 0.0159973219202 0.0374102115892 0.0608056403948 0.0178404535904 0.0681680501025 0.0368277650919 0.0342153028534 0.0136005609896 0.0114725513671 0.0202654226306 0.0215111320227 0.175502940168 0.180846739943 0.186993890383 0.200622200655 0.194047326964 0.191871659177 0.187230724864 0.170446969951 0.181958118895 0.192296146604 0.192168805538 0.185737701873 0.187567790504 0.1926934047 0.169562979332 0.174903941965 0.195627236518 0.171332536122 0.216941277953 0.180224282629 0.204375817171 0.176708588212 0.212007481629 0.187940100384 0.177271729963 0.178782860675 0.191678059195 0.200974345147 0.193702992688 0.160469688943 0.182595805427 0.175146841545 0.17584337797 0.215706304999 0.198413689274 0.184386485081 0.184856323095 0.20232915317 0.177913816132 0.192982627694 0.194328346433 0.187558388958 0.181714052911 0.173349805963 0.189464804214 0.174374123803 0.181953747446 0.178997842818 0.162709307879 0.18281187754 0.239644460978 0.228724428122 0.225246554022 0.222159074766 0.232927392687 0.231188577573 0.229024014707 0.22394884582 0.234228075319 0.223668927512 0.209861178703 0.225307285274 0.221985913786 0.238104571085 0.242774657148 0.224369518131 0.215280858443 0.214174032708 0.25182022511 0.228290074367 0.224826938646 0.228427350702 0.235193041024 0.216001866886 0.218122104545 0.211215702011 0.212099059638 0.209083204086 0.233569980649 0.207419375116 0.225880589953 0.202184861075 0.236687676647 0.205660738951 0.22091809464 0.228766193737 0.228457617824 0.2135856342 0.208453819381 0.216659972673 0.231192094033 0.218856194539 0.228724428122 0.228811270004 0.230578167797 0.224983578773 0.22794936407 0.216954366886 0.223518672063 0.215168993038 0.0278789967436 0.0521696459286 0.0689795584164 0.0720246274977 0.0510464689946 0.0421745394626 0.053582971262 0.0252834975098 0.0677158937278 0.0652657188093 0.081318384881 0.0463957610979 0.0317140261778 0.0668416555065 0.0279143378417 0.0293650428541 0.0349789935753 0.032697569141 0.0634994948437 0.0398508689254 0.0464805914619 0.00599304401229 0.0382168939676 0.0359888514026 0.00599304401229 0.0356302780251 0.0278103138868 0.0553135387293 0.0681148770417 0.0401494228711 0.0950529579724 0.0698373790182 0.0522664102967 0.0364245082526 0.034367526255 0.0307005764611 0.0296340954647 0.193320448722 0.200616479264 0.204805927895 0.217738543992 0.211505662739 0.210916031972 0.207785188245 0.189492055249 0.199011305592 0.212849559963 0.207930120156 0.205973985295 0.201080290256 0.211364107387 0.190111543422 0.193149888648 0.216396870129 0.188564248953 0.232124397575 0.197509520178 0.225563508571 0.194908404083 0.228408782968 0.205404773753 0.195016829794 0.196780548006 0.207983584103 0.219251719916 0.21299620972 0.177753842585 0.19963357851 0.19173429638 0.194103048534 0.233951642516 0.219652294406 0.206249008964 0.203257559758 0.217055047586 0.19863330849 0.211258733702 0.212590735452 0.206794766477 0.199327419787 0.191301214309 0.208462930841 0.194441169877 0.201765843334 0.197324504463 0.182225897174 0.202147597456 0.260363424846 0.247928312505 0.243139798114 0.240805098305 0.252082485905 0.248010938223 0.249316339351 0.240374954583 0.250342905364 0.243926059402 0.229857687769 0.243199557315 0.240557269117 0.256813113392 0.262812568913 0.244726906585 0.233983032632 0.233739246967 0.267372287242 0.243942332388 0.244149194945 0.248660562989 0.250891907974 0.234045856002 0.23797517084 0.229108542601 0.230855414047 0.228916694642 0.252083674667 0.224056856634 0.242001030284 0.221239323161 0.255322806495 0.223424493307 0.237685672547 0.245823282675 0.249646734812 0.232903558602 0.228555612396 0.235462898266 0.250614129287 0.237926457957 0.247928312505 0.248245352669 0.250761236826 0.244030479155 0.2452417146 0.236085335476 0.244925556651 0.235313123462 0.0296919493074 0.0549103775111 0.0590022859872 0.0450958795243 0.0436647014416 0.0451669494409 0.0401697758406 0.0620690815544 0.0404063812339 0.0856236153109 0.0591687282212 0.0490473517415 0.0683619493373 0.0275851844543 0.0264002504943 0.0446945676427 0.0461763497794 0.0638640733472 0.0232220049486 0.0233353107646 0.03147088677 0.029201781247 0.02614478673 0.03147088677 0.0350355717384 0.030428654072 0.0452764113597 0.0802967236314 0.0328354116031 0.0941098407344 0.0724718577687 0.0562014612922 0.0313029110017 0.0340889421853 0.0234757814211 0.028925036543 0.210407140423 0.216202187825 0.221880775368 0.234954371989 0.228487320903 0.227668142527 0.22288748901 0.205844703323 0.216768667446 0.227711464843 0.226263348504 0.220970493431 0.220784685064 0.228189601628 0.204608420295 0.209669658318 0.231537789973 0.206793805641 0.250139733355 0.215157813925 0.239903556316 0.211352210266 0.246303099122 0.223431243026 0.212079033799 0.213468334673 0.225996065584 0.235701634712 0.228967589943 0.195079844754 0.217288259849 0.209835756349 0.210818201018 0.25087781482 0.234509225035 0.220284749566 0.219817558162 0.235704379779 0.213924917847 0.22786813663 0.229992970272 0.223192642095 0.216540668547 0.208207378637 0.224921456698 0.210576921517 0.217728441709 0.214138769918 0.196963968339 0.21825274764 0.274633184392 0.263620373951 0.259724001387 0.257434131046 0.267733388911 0.265627371082 0.264299751314 0.258574475793 0.268388644672 0.258492710734 0.244710620006 0.259750243754 0.256426981572 0.272472244255 0.27686351493 0.258914849135 0.250487159092 0.249742739323 0.285410306304 0.262307563551 0.259345413586 0.26329314732 0.269271128247 0.250334873532 0.253300294048 0.246383898221 0.246645581278 0.244211963707 0.268141898451 0.242252606427 0.260005586654 0.237699783889 0.271104326635 0.240825446457 0.256147548483 0.26253800174 0.263413026859 0.249061635853 0.243583443282 0.251070491042 0.265469741093 0.25252673858 0.263620373951 0.263585528386 0.265041995624 0.258842865142 0.261802853748 0.251583944502 0.25855292944 0.250657339544 0.0450102465608 0.0439198537957 0.0420878714528 0.0489743500788 0.0458798154287 0.0561577170329 0.0578224624858 0.0224176386409 0.0849412968827 0.0784422731853 0.0630254855321 0.0686145922194 0.0402128784166 0.0342259139129 0.0607491308771 0.0616063147121 0.059057582132 0.0469260494382 0.0248556117621 0.0569379974042 0.0246670677105 0.0228986845775 0.0569379974042 0.0437638412118 0.0433305015411 0.0375189879884 0.0808012493057 0.0411311531308 0.089015155435 0.0787045494767 0.0568803303557 0.0468151856286 0.0457099341419 0.0358166687321 0.0382966404493 0.218181156993 0.223322073096 0.229705702275 0.242392790988 0.23577882008 0.236467641295 0.230139466345 0.213525276303 0.225126391191 0.234563959305 0.23447409507 0.227593305984 0.22968375989 0.236629811874 0.210530415308 0.216784944512 0.23930372472 0.216469414915 0.257297585894 0.22354090813 0.246798396633 0.218282233397 0.254457430072 0.233053108231 0.219729861221 0.220661425884 0.234112165808 0.242944509178 0.236406584132 0.202708452811 0.225406734885 0.218378296681 0.218342011887 0.259279663879 0.242430236301 0.227193609953 0.227261836804 0.24357213448 0.22167035443 0.235341335514 0.239265397892 0.231386700827 0.224381906232 0.215751708357 0.232947742221 0.219218926008 0.225693206986 0.221969156729 0.202171293512 0.225894654473 0.281426284779 0.270908280604 0.267090828143 0.26583132699 0.274949583689 0.273930107263 0.271660675229 0.267616788632 0.276815360824 0.264923167376 0.251110814116 0.267050687079 0.263175899022 0.279239724537 0.282486166675 0.264820551157 0.258570659963 0.257930961428 0.293412787858 0.270816835713 0.265787467516 0.269896000193 0.277962792777 0.257183140616 0.260538043514 0.255036127386 0.253324298915 0.251219664681 0.275354649609 0.251349757403 0.268235077166 0.245978035775 0.277988121804 0.249516964722 0.266387651101 0.269264891567 0.269706692396 0.257221982881 0.25041421232 0.257531332229 0.271532129624 0.257608408712 0.270908280604 0.270491687514 0.271003440471 0.264326332823 0.268486578685 0.258229704408 0.264793848318 0.258283260113 0.0140423845301 0.0233496953457 0.0357817640834 0.0194594148752 0.0561842963236 0.0207161808072 0.0344686045315 0.0532665757163 0.0656105748711 0.0611304155975 0.0376479555399 0.0422417749013 0.0418045042693 0.0514369987371 0.0551924216967 0.0370785412495 0.0618826263881 0.03552992519 0.0709823822809 0.0406476055096 0.0445130802003 0.0709823822809 0.0367370595656 0.0436433053629 0.0176515558758 0.0714383400943 0.0313405988749 0.050902359898 0.0456873150128 0.0406736463161 0.0404939048403 0.0386201712918 0.0390017962403 0.0411563720519 0.190383467974 0.193150151335 0.201647820189 0.214732592431 0.207848794505 0.207203203998 0.199017728171 0.184517441065 0.198117570692 0.203251095462 0.208611510757 0.196706601418 0.206520396425 0.207659337014 0.179547279859 0.188402996857 0.207901541524 0.18984126915 0.231436366396 0.196328732424 0.214604717337 0.189868309751 0.227504737805 0.2057488472 0.191940214233 0.192467873609 0.207646738607 0.21397919575 0.206530920079 0.175883310987 0.198349858418 0.192082967323 0.190004696209 0.230325216181 0.21052421867 0.194679583814 0.198537353627 0.218586319181 0.19070413186 0.206580728089 0.210890308648 0.201869808993 0.196665077614 0.187817228574 0.203604184545 0.189253631177 0.195640755776 0.193545341254 0.172360847921 0.196255157011 0.249220192749 0.240515221189 0.238164043403 0.236348677214 0.244540315717 0.246252369823 0.240132469075 0.240621741867 0.249888930273 0.233326376677 0.219986372028 0.238112203328 0.233455949013 0.249164983161 0.25077275089 0.233019708703 0.229068571188 0.227556818352 0.266813634827 0.244493984417 0.235169888951 0.238293435462 0.251527743788 0.228140449415 0.22959779378 0.226587756924 0.223543468869 0.220396683922 0.245620426642 0.22441324809 0.241383050303 0.216373265669 0.24802824928 0.221314439433 0.239346728325 0.241091845042 0.237050180919 0.227111645095 0.219282181885 0.227591404442 0.240665010845 0.227138628142 0.240515221189 0.239782829874 0.239319392462 0.23385508337 0.24006053231 0.227964392353 0.231962468731 0.227162089828 0.0243523838323 0.0383436294161 0.0281380877138 0.0591143980174 0.023507742642 0.0377968944731 0.0517794728194 0.0731209286425 0.0626942772583 0.0386453724111 0.0461236944312 0.0433886463071 0.057222198299 0.0591551673076 0.0319956615202 0.0701506857494 0.0422353525103 0.0748230813085 0.0387325777977 0.0428806382505 0.0748230813085 0.0409657262208 0.047385502674 0.0175421295668 0.0657295550805 0.0386908764688 0.0489968109439 0.0522686619491 0.0387311691946 0.0491554938498 0.0442532671202 0.0441014308007 0.0436449779054 0.189947462454 0.193087358051 0.201270443197 0.213957860003 0.207091706444 0.207812220084 0.199357780455 0.184445706942 0.197758177741 0.203406879958 0.207785745488 0.196588475912 0.205402521621 0.207935882191 0.179126107639 0.187763747972 0.208638518258 0.190249811145 0.22994679767 0.196055336563 0.215105618909 0.189122223025 0.226906503622 0.206245399814 0.191418910324 0.191795589288 0.206939834769 0.213506326546 0.206505332082 0.175157210084 0.197857598212 0.191658112797 0.189588115864 0.230508642351 0.211553886467 0.195374420383 0.198156887541 0.217288762795 0.191332101287 0.206198782834 0.211486527696 0.202202827305 0.19621322526 0.187298385594 0.203764973183 0.190101114406 0.196046751208 0.193325009164 0.171164264517 0.19631141813 0.249660253112 0.240527632421 0.23771162293 0.236702658605 0.244516745342 0.245937622906 0.240621381598 0.240549902948 0.249413960629 0.233305723303 0.219774348622 0.237625603888 0.232924324305 0.248768260048 0.250380844287 0.232789805762 0.22924781342 0.228117670835 0.26599273559 0.24389404773 0.234785533178 0.238373023947 0.251062908639 0.227440481837 0.229791016779 0.226764157548 0.223002288166 0.220422035353 0.245352612988 0.224391473735 0.240777024278 0.216738025139 0.247654798968 0.221447853711 0.240056634641 0.240035093698 0.237386138185 0.227558813593 0.219321439562 0.226978987712 0.240167124817 0.22597544824 0.240527632421 0.2396924683 0.239078218682 0.232902821621 0.239060496039 0.227569835839 0.232339810664 0.227659905228 0.0141262101806 0.0139426926457 0.0350538423884 0.0193552608508 0.0431621025158 0.0440916637552 0.050896637678 0.0388189182549 0.0267566278127 0.024110231253 0.0232035130335 0.0336464874245 0.0349533341335 0.0219308383764 0.0572621322316 0.0349099564127 0.0531369685873 0.0252590392656 0.0298245046475 0.0531369685873 0.0175869571119 0.0244711956848 0.00818635303924 0.0514811245358 0.0194723442375 0.0509148981601 0.038941584783 0.0196470806889 0.0301479553419 0.021545096414 0.0245644202822 0.0217515624084 0.179463055971 0.184039565703 0.191058390156 0.204133065196 0.197353411589 0.197439799103 0.1907070948 0.174350095292 0.18671934138 0.195225461177 0.19666314681 0.188285080293 0.192912863971 0.197716084636 0.17106321505 0.177948538218 0.199885832792 0.178001143095 0.220003811923 0.185034059424 0.207478284578 0.179492397587 0.21650741229 0.194560853934 0.181055185718 0.181934852801 0.196069170377 0.204292703623 0.197354097622 0.164139489747 0.187014857055 0.180129327357 0.179477085752 0.220692949894 0.202951258529 0.187497059139 0.188415486818 0.206311756974 0.182082560815 0.196599300923 0.200515380101 0.192263706104 0.185773424375 0.176983033355 0.193914579783 0.179773695055 0.186365398569 0.183085748173 0.163066216827 0.18672092116 0.242702110891 0.232274391832 0.228788679171 0.227187602483 0.236388804345 0.235969651611 0.232778101812 0.229721372697 0.23914299349 0.226115326683 0.212181006801 0.228757804803 0.224715842477 0.240932159296 0.244193462731 0.226111600887 0.219855639469 0.218968698082 0.256162056313 0.233278273993 0.227208648321 0.231128251362 0.240452766308 0.218806638317 0.221623839858 0.216518120679 0.214708469871 0.212229381986 0.23697508889 0.213254322456 0.230501952576 0.207030794754 0.239662752997 0.210997516317 0.22840539478 0.231383198724 0.230834439598 0.218316993527 0.211375460714 0.218990694003 0.233092437868 0.219339375552 0.232274391832 0.231855607362 0.232408829329 0.226038981221 0.230519762371 0.219567778072 0.225824086027 0.219230412501 0.0195919993919 0.0221059172753 0.0271326704392 0.0528905379198 0.0431586822848 0.0385447030867 0.0255010287112 0.0262337606525 0.0170321830128 0.0195302099147 0.0206521036595 0.0209833716129 0.0252645250533 0.0550811186683 0.0394746523074 0.043263968218 0.0280088992059 0.0316978756724 0.043263968218 0.00932281475944 0.0154549635915 0.0220221996956 0.04619442006 0.0176558634743 0.0549187053198 0.0347531723104 0.0154010655624 0.0249961358537 0.0130624709681 0.021086975526 0.0157582275316 0.172494143831 0.17784850126 0.184169405165 0.197413015598 0.190717679771 0.190383314088 0.184688114733 0.167622718241 0.179385018024 0.189454833136 0.189254205537 0.182497405034 0.184783379021 0.190756581821 0.165553322788 0.171383967321 0.193742345805 0.169993474917 0.213189630746 0.17771520654 0.201947261672 0.173029090008 0.209395719039 0.186777092552 0.174149245532 0.175318744446 0.188797436083 0.197902799323 0.191019058185 0.156992121883 0.179797341784 0.172560525004 0.172720884671 0.213854773981 0.196871318612 0.181938976962 0.181811193063 0.198969640765 0.17576606357 0.19002752539 0.193102069722 0.185493626505 0.178790364297 0.170132074883 0.187191891105 0.172843021691 0.179777298661 0.176222723299 0.157641466463 0.180195116525 0.237394679003 0.226280310947 0.222447934209 0.220486140395 0.230450693082 0.229006895923 0.227001818993 0.222289337207 0.232008422548 0.22075701885 0.20666547313 0.222449960987 0.218801277251 0.235156691974 0.239347508119 0.221054539901 0.213261323555 0.212504634094 0.249237472588 0.225979854618 0.221636903122 0.225713392695 0.233125083698 0.212685206963 0.215719410439 0.209455227207 0.208792490533 0.206361366722 0.230902205737 0.20571314342 0.223403407555 0.200311655198 0.233802587518 0.20384593219 0.22048704521 0.225216247618 0.225812871456 0.211806271505 0.205652934938 0.213231447371 0.227786843309 0.214377387143 0.226280310947 0.226104307704 0.22732908173 0.220904746241 0.224415757753 0.21378854989 0.220845147853 0.213178189936 0.0385029210536 0.0191331286834 0.0412210559221 0.0479132957057 0.0465498029846 0.0439952648454 0.0294155998226 0.0263022819525 0.0288814535105 0.0321813612841 0.0366154046916 0.0324760763417 0.0515944791638 0.0310049526439 0.0546416139704 0.0338597056505 0.0376153728239 0.0546416139704 0.019563854062 0.0269885058553 0.0157505744896 0.0625368339241 0.0143844790412 0.0526157254036 0.0338348827289 0.0297234721938 0.0233631827985 0.0204547357021 0.0243203298193 0.026443786847 0.18161798851 0.18540629351 0.193056292253 0.206460086953 0.199649422865 0.198358533748 0.191516052491 0.176005251549 0.188914967022 0.196119500233 0.199392563722 0.189524653623 0.196344377596 0.19896940691 0.172616127427 0.180167039066 0.200264745011 0.179650753185 0.223145799502 0.187130729579 0.207841346365 0.181781654149 0.218763807382 0.195938920487 0.183272877978 0.184194077304 0.198599402775 0.206127033545 0.198682577368 0.166796826532 0.189310437328 0.182538488189 0.181515358431 0.221921151125 0.202966250725 0.187732725258 0.190303161279 0.209524247949 0.182729260129 0.198439370358 0.201593038612 0.193392410161 0.187922687561 0.179193994752 0.195211914017 0.180441261226 0.187358375156 0.184927566912 0.165517695891 0.188083050798 0.242939707589 0.233299699182 0.23049760933 0.228144979761 0.237419943564 0.237777043946 0.233178399857 0.23147925362 0.241203272786 0.226929567318 0.213318762235 0.230491320835 0.22634238089 0.242302330141 0.245163744774 0.227035678455 0.220985219764 0.21961554026 0.258484704802 0.235572463293 0.228516087928 0.231839786454 0.242586485114 0.220732170317 0.222439032331 0.217865646283 0.216378419732 0.213247698263 0.238336887242 0.215052759841 0.232719204269 0.208046041848 0.241045913549 0.212450914632 0.229495311164 0.23369764439 0.231101958719 0.219113353825 0.212320151032 0.220660185426 0.234399345217 0.221293359798 0.233299699182 0.23289508713 0.233336932661 0.227805970609 0.232744111879 0.220997609023 0.226042688917 0.219773770977 0.0487507947542 0.0650775470184 0.057802762893 0.0304021403296 0.00977564963899 0.0440829229362 0.0178656109143 0.0223657443481 0.0145412613726 0.00880579384939 0.0433599813023 0.0513293545711 0.0472054655688 0.0249055105449 0.0346274013058 0.0356855998153 0.0249055105449 0.0197624673252 0.0147740519949 0.0419438715965 0.0491548979957 0.0286642180871 0.0731736765881 0.0474587573553 0.0307413987988 0.0281173399333 0.0193986394444 0.0247050709585 0.0190246608336 0.173083486457 0.179910481276 0.184747521108 0.19795391577 0.191518465927 0.190900207622 0.18706914222 0.168885152715 0.179192090216 0.192134059909 0.188561922702 0.185169221179 0.182516578227 0.191341288573 0.168884190059 0.172666616329 0.195883736852 0.16891577804 0.213018522015 0.177613800133 0.204946600226 0.174427531668 0.209108112252 0.18591519295 0.174796071764 0.17642769541 0.188436163643 0.199161967465 0.19263437332 0.157387090389 0.179769711315 0.171986018804 0.173714059835 0.214316704261 0.199152104404 0.185242989169 0.182953007753 0.198045578814 0.177854485907 0.191103831493 0.192902410163 0.18652468984 0.179244739552 0.170950373519 0.188227253613 0.173938849831 0.181251003885 0.177034455953 0.160977434421 0.181661357468 0.240293898195 0.228034626835 0.223480275138 0.221169492968 0.232239647508 0.228872448909 0.229260803782 0.221433214134 0.231450162781 0.223643381382 0.209415344527 0.223528489107 0.220601809879 0.237045012584 0.242726403737 0.224366911478 0.21417342735 0.213777217999 0.24873924373 0.225124576112 0.224039797111 0.228474279829 0.232185938187 0.214138987375 0.217816173262 0.209554716543 0.210717178803 0.208592377005 0.232371287988 0.204873194809 0.222962175481 0.201230387345 0.23556954796 0.203837920113 0.218977104053 0.226289614933 0.229286064361 0.212971252918 0.208146125074 0.215343203422 0.230520772996 0.217614435398 0.228034626835 0.228243837858 0.230522424537 0.223850190554 0.225634530741 0.215935214332 0.224460188266 0.215143400901 0.0529022439667 0.0328752197893 0.0555054115849 0.0509289255649 0.0173017354019 0.040824127775 0.0418711547682 0.0429127577978 0.0455543968368 0.0222834470095 0.0700549868865 0.0480571802481 0.0688386171987 0.0442386440219 0.048830469586 0.0688386171987 0.0328274300443 0.0405886029945 0.0207406620607 0.0561033512724 0.0322786585229 0.0341942563123 0.0291137581017 0.0267606033099 0.0411628160219 0.0351933008888 0.0409598634365 0.0395653722748 0.170381496838 0.173513369262 0.181763628401 0.194913312213 0.188005094963 0.187597093173 0.17963993246 0.164619720579 0.178109956535 0.183964962678 0.188586214824 0.177259498897 0.186421186364 0.18797705999 0.159970598511 0.168451386355 0.188698976448 0.169860506279 0.211615177079 0.176329007245 0.195682012245 0.169937526308 0.20770892717 0.185927394166 0.171947667368 0.172526710735 0.187654893417 0.194331077481 0.186965121806 0.155693053512 0.178340485408 0.171986662107 0.170058435784 0.210831670623 0.191498228781 0.175622787806 0.178712133706 0.198589692402 0.171227708945 0.186830515333 0.191211132234 0.182219297429 0.176703062328 0.167807776518 0.183929379926 0.16962686739 0.17602523241 0.173642929989 0.152568053554 0.176555503125 0.230732284086 0.221405569072 0.21873883425 0.217008773205 0.22548132942 0.226701619289 0.221306518291 0.22096326048 0.23027897199 0.21448417882 0.200865540743 0.218691208961 0.214158679542 0.230111756153 0.232289297369 0.214283536851 0.209653108975 0.208315017711 0.24732302577 0.224778673487 0.216104443077 0.219500448511 0.231884032027 0.208661452368 0.210499772687 0.206990362059 0.20415679031 0.201176497026 0.226427503413 0.204626996142 0.221691815993 0.19686908479 0.228928610762 0.20163871009 0.219806895143 0.22162291443 0.218587303851 0.207804967644 0.200129766869 0.208295752101 0.221764477978 0.208127749312 0.221405569072 0.220756657587 0.220625985458 0.214861357139 0.220620889076 0.208723632287 0.213494112425 0.208081504586 0.0844496882978 0.080315980567 0.0726849367116 0.0675030089859 0.0473153931529 0.0443066374773 0.0646752376508 0.0680246382237 0.0621370759065 0.0478849585017 0.0214355468841 0.0687094353901 0.0384979333887 0.0389190825118 0.0687094353901 0.0480894783324 0.0504544201599 0.0366660205236 0.0908834253131 0.0410486802894 0.0843383154277 0.0744888741312 0.0620377042787 0.0466247584157 0.0490662247741 0.0410809318858 0.0466044522535 0.220241217585 0.22387872958 0.231567441105 0.244549509651 0.237801597966 0.237271702597 0.229957304486 0.214803305719 0.2275731622 0.234289966045 0.237659204867 0.227701989162 0.234344570768 0.237727323575 0.210730852647 0.218580436475 0.238765139748 0.218842181584 0.260585713889 0.225852980679 0.24576980875 0.220083510611 0.25691340974 0.234991633089 0.221816502308 0.222561867727 0.236939418607 0.244255467135 0.237073335368 0.205416544089 0.227870869354 0.221241762596 0.220094090971 0.260317043933 0.241447551617 0.226019474356 0.228752673734 0.247333244315 0.221529692284 0.236780633698 0.24056209021 0.232170242771 0.226474325634 0.217767662464 0.233885787279 0.219595234935 0.226160651319 0.223600212873 0.203287025744 0.22672247966 0.280139937217 0.271046573965 0.268296536378 0.26646171863 0.275059767728 0.275799812567 0.270911764394 0.269815722172 0.27914751079 0.264301608642 0.250949666543 0.26825814336 0.263926860434 0.279625941989 0.2816892989 0.264092216423 0.259287884013 0.257990452056 0.295945646215 0.273550874886 0.265902495939 0.269211685027 0.28055869892 0.258431707188 0.260338655828 0.256388822593 0.254096852299 0.25120005211 0.275959599762 0.25362897924 0.27069009133 0.246633770083 0.278453866291 0.251048870754 0.268244717954 0.271056483898 0.268212813274 0.257487053623 0.250194192056 0.258191856723 0.27145388403 0.257986657626 0.271046573965 0.2704506544 0.270310564507 0.264635332559 0.270115829289 0.258629632749 0.263204545545 0.257890609764 0.0600044713459 0.054351041098 0.0187381084361 0.0598557442646 0.0614469307754 0.0531453686192 0.0525559397425 0.0279315026787 0.094761292833 0.0773971393828 0.0814189949505 0.0655620569523 0.0700255275487 0.0814189949505 0.0520201647503 0.0579117136152 0.0488956649362 0.0419109171187 0.0567137285928 0.0208614229037 0.0306610868801 0.0327090237565 0.063272034339 0.0543984191577 0.0634480421324 0.0583685669148 0.139330779418 0.142986837848 0.150850053523 0.163810831232 0.156868051014 0.157669598862 0.149679456655 0.133871337528 0.147188409072 0.153968295801 0.157417010427 0.14689076955 0.155379198936 0.157713790383 0.129254210759 0.137253284329 0.159227064857 0.139693977567 0.180206197156 0.145463442392 0.166351059616 0.138682374547 0.176816693259 0.155870230339 0.140840856643 0.141328264666 0.156536274226 0.163539791349 0.156545980147 0.124345584519 0.147307265103 0.141019689746 0.139034333305 0.180682036747 0.1624502749 0.146314826392 0.147811298228 0.167221256708 0.141400345074 0.156004354912 0.161263479124 0.152006654871 0.145684418167 0.136675034398 0.153561404536 0.139874017863 0.145889334783 0.142806737922 0.121109447078 0.146069682444 0.201853472765 0.191504661606 0.188213817168 0.18712354961 0.1956147304 0.196211110416 0.19205227926 0.19059963575 0.199675257584 0.184878502918 0.170804202645 0.188147863911 0.18370042204 0.200019806255 0.20290821197 0.184684396544 0.179556147674 0.178663646288 0.216648538359 0.194032671841 0.185998827234 0.190015746161 0.201299319844 0.177907547001 0.180731098286 0.176760615884 0.17358596254 0.171156072474 0.196260390732 0.174185108777 0.190914661822 0.166819613367 0.198798087344 0.171315193398 0.190200635461 0.190703604042 0.189694426068 0.178004531696 0.170196606131 0.177783458136 0.19179082566 0.177644952 0.191504661606 0.190881968726 0.191068709685 0.184514101166 0.189756786146 0.178407147108 0.184631515769 0.178548671216 0.0324892056253 0.0484887435869 0.0393579503362 0.0472627188893 0.0192847169709 0.0232472318507 0.0583393494412 0.0585791036352 0.0611786752117 0.0424145094995 0.0604358052165 0.0620651155443 0.0424145094995 0.037432002363 0.036885144463 0.057932237922 0.0663347563067 0.0402054510934 0.0745837939532 0.0379481013657 0.0474009418109 0.0343119409392 0.0339409730754 0.0428079642087 0.0427340086613 0.16139435599 0.167055199688 0.172679145019 0.186588672878 0.18018023169 0.176484226078 0.173177363378 0.15635152751 0.167324305619 0.178559723881 0.177731707828 0.172313382954 0.172981201837 0.177656055027 0.157022451257 0.161367937512 0.181005231952 0.155624650937 0.203264920982 0.165557822324 0.190457367134 0.163325089652 0.197312648791 0.172046353812 0.163261037864 0.165144860989 0.177247951111 0.186978615056 0.179504291425 0.146841839918 0.168174392768 0.160512412099 0.161906209121 0.200546381048 0.18360708151 0.170619997941 0.170849280459 0.188248015891 0.163499893332 0.178863271671 0.178580924982 0.172741578769 0.16748001244 0.159472149167 0.174802823761 0.159227769495 0.167358477359 0.164720514491 0.151099028747 0.168548224145 0.225620984689 0.214383995774 0.210968404368 0.206923044041 0.218629792329 0.216162853062 0.214556733684 0.208383921822 0.219163632298 0.210075568948 0.196412311391 0.211088115641 0.208225582965 0.224211015109 0.229824216763 0.21125046128 0.200361910494 0.199102744226 0.237092122358 0.213257676298 0.21126821314 0.214648561609 0.219950980033 0.202248505777 0.203853239286 0.195906673599 0.198467217831 0.195092454721 0.219319110187 0.191906900165 0.211043854216 0.187166023617 0.222703227226 0.190377176965 0.20432458647 0.215124925944 0.214931156714 0.198560742198 0.194613360236 0.203185148475 0.217932610212 0.206623397839 0.214383995774 0.214797954846 0.217376030313 0.212326968407 0.214327312553 0.203281369316 0.21006441216 0.200554878155 0.0431984510448 0.0262542814372 0.0292765976694 0.0197548242369 0.011556553192 0.0420248516295 0.0609848282508 0.0559281666693 0.0312264925083 0.0398958448421 0.0413044920489 0.0312264925083 0.0264369738429 0.0230439739916 0.0462734733613 0.0414691510708 0.0363662025945 0.071550533242 0.0478849716213 0.0291862789915 0.0369373377392 0.0270714127462 0.0334218260536 0.0262390277171 0.165544038214 0.172891912863 0.17727312869 0.190354892388 0.183958646909 0.183879480011 0.180336742003 0.161635841791 0.171548979047 0.185413091762 0.180663093483 0.178298498301 0.174219977581 0.184181187608 0.161990271375 0.165191063063 0.189309277337 0.161423020955 0.205054842396 0.170020243784 0.198514733988 0.166940816324 0.201451973118 0.178556962169 0.167238778058 0.168913749918 0.180647428918 0.191850429195 0.185573186785 0.149626920851 0.172104358108 0.164216849771 0.166272040954 0.207167511585 0.192763981398 0.178906141081 0.175593499508 0.189955336349 0.171151190119 0.183759195847 0.185737635433 0.179470325207 0.171692649892 0.163416602952 0.18110112813 0.167100843514 0.174311352225 0.169649991905 0.153736698586 0.174561747041 0.233945473753 0.221154951746 0.216216020369 0.214168470951 0.225368727897 0.22143399553 0.222723035108 0.213934293134 0.223870685298 0.217024022208 0.202620827758 0.216260896263 0.213476245827 0.230060267172 0.236168299839 0.217779153489 0.207119858677 0.206977473585 0.241093686538 0.217416199365 0.217140656671 0.221883614074 0.224541883596 0.206836488872 0.211062122527 0.202310625247 0.203579796415 0.201763166599 0.225319290313 0.197343747333 0.215321920645 0.194216980733 0.228558415828 0.196533366942 0.211711953148 0.218804815465 0.22300715182 0.206091661798 0.201387938181 0.208241563837 0.223688965104 0.210605474313 0.221154951746 0.221416959944 0.223922313478 0.216868041009 0.218202757079 0.208934179216 0.218220121204 0.208484033719 0.0428988991781 0.0449811252912 0.038369173012 0.0392012066073 0.0184411809504 0.0770158611592 0.0591685049971 0.0671690041442 0.0499388239897 0.0544215157144 0.0671690041442 0.0346140690794 0.0413101969584 0.0321994698404 0.0440967531043 0.0383047062906 0.0298070621094 0.0211708137004 0.0201129458309 0.0453565917011 0.0368886973605 0.0457257341 0.0417220412167 0.154888546678 0.158813196403 0.166441835812 0.179672088583 0.172784191158 0.17260621351 0.165322327284 0.149403283235 0.162445964052 0.169819706795 0.172790429714 0.162919256631 0.17010598628 0.17291506116 0.145591206314 0.153172124666 0.174534430185 0.15398983773 0.196191934512 0.160693736573 0.182015889553 0.154710886954 0.192325902157 0.170351903358 0.156482289316 0.157229639215 0.171983255038 0.179460677481 0.172268582678 0.139849276668 0.162711676043 0.156097286205 0.154728919391 0.195984213978 0.177559464338 0.161865850494 0.163584898864 0.182768842876 0.156718657607 0.171791912863 0.175973376944 0.167287390852 0.161244255475 0.152349968293 0.168972557751 0.154707872737 0.161224201041 0.158337859598 0.137882544324 0.161653779265 0.217498297387 0.207268525118 0.204089016051 0.202387117484 0.211405750921 0.211656794766 0.207586435206 0.20562940887 0.215067539532 0.200874708618 0.186922162094 0.204055283767 0.199813802793 0.216054855672 0.219141272905 0.20087129472 0.194993585948 0.193928687775 0.232251037143 0.209370889696 0.202145172225 0.205917531589 0.216546254935 0.194031863501 0.196450064794 0.191939021682 0.189735506736 0.187016932169 0.212133736422 0.189132050882 0.20640648386 0.182100826622 0.214796842045 0.186466235268 0.20445164291 0.206912827034 0.205504201388 0.193322781156 0.186101115818 0.194015369065 0.208047565025 0.194373832921 0.207268525118 0.20679029341 0.207231461284 0.201073842632 0.205977385627 0.194517602543 0.200437951551 0.194023674059 0.00847168263945 0.0208969725179 0.0218078109788 0.0404437599311 0.0404194345362 0.0297098891496 0.0297074253675 0.0216763215811 0.0230614305273 0.0297074253675 0.00860159575866 0.00340785264521 0.0287758992091 0.0571909561512 0.0141236699669 0.0709946391549 0.0479055513747 0.0306293087394 0.0170492128659 0.00888265836541 0.00729150357409 0.00480661141663 0.185289458233 0.191085055337 0.196910034804 0.210145347321 0.203571296435 0.202882056675 0.197912476038 0.180625340213 0.191835734795 0.202787038295 0.201526915714 0.195916323017 0.19637797116 0.203353873438 0.179306027922 0.184472082084 0.206754233077 0.181958697279 0.225649748274 0.19019500565 0.21522963857 0.186167360837 0.221735787446 0.198765098442 0.186973637291 0.18833349586 0.201196357535 0.21085114286 0.204041973491 0.169797982896 0.192333522046 0.184882922721 0.185665053896 0.226331622925 0.209833971543 0.195365654989 0.194769866304 0.211153682947 0.188870228152 0.202929999244 0.20531727443 0.198262875463 0.19151438955 0.183035158868 0.19999216658 0.185562442931 0.19270971507 0.189054601453 0.171539131405 0.193197031986 0.250465285504 0.239173402368 0.23520366736 0.232978158323 0.24334022521 0.241285239552 0.239942028126 0.234265108703 0.244131225098 0.234017030201 0.220001112132 0.235226825533 0.231841004595 0.248118070359 0.252690451382 0.234464488853 0.225903274535 0.225189555796 0.261354129729 0.238022768459 0.234821661628 0.238891339667 0.245085625014 0.225666229038 0.228735290931 0.22181584168 0.221922833386 0.219499858076 0.243732621444 0.217749348385 0.235627115362 0.212972717548 0.246730042299 0.216195919385 0.232029501648 0.238052252824 0.239120375862 0.224484292562 0.218871170879 0.226408868705 0.241049615623 0.227943328268 0.239173402368 0.239135618661 0.240673256099 0.234329166611 0.237299131316 0.226939754937 0.234208016817 0.226098822397 0.028402190164 0.0277439229346 0.038946334352 0.0434213038922 0.0291676419928 0.0326159908833 0.0134911389606 0.0149220924049 0.0326159908833 0.0134816006656 0.0104081517294 0.0265932070523 0.0554420028459 0.0189257472352 0.0720390188254 0.0531694571518 0.0303305078503 0.0242591305562 0.0161087615284 0.011068875208 0.00482735633945 0.188743108882 0.194722342773 0.200407653053 0.213430694909 0.206860229667 0.206917746824 0.201757002065 0.18426566592 0.195342886433 0.206526515083 0.204777293747 0.199508643938 0.199425600774 0.207211939812 0.182702196026 0.187804249003 0.210815779569 0.185880854144 0.228533589019 0.193748347964 0.21913688541 0.189440254064 0.225129338462 0.202750726696 0.19038113591 0.191653574921 0.204515978518 0.214295374936 0.207718295645 0.173066791358 0.195766348142 0.188344856347 0.189125824359 0.230149564934 0.214039936134 0.199354571186 0.198257058594 0.214135463178 0.192868986061 0.206423136152 0.209356843732 0.20214026995 0.194966833942 0.186438002469 0.20377859508 0.189699928978 0.196612341236 0.192629244536 0.174503529883 0.196914127595 0.254336052592 0.242870282486 0.238667846113 0.23688365824 0.247015930548 0.244839615824 0.243870689439 0.237954961473 0.247598002179 0.237655720218 0.223546452001 0.238671394435 0.23524462783 0.251589019272 0.256100611398 0.237973407633 0.229710932979 0.229189966161 0.264623863258 0.241418386796 0.238285878732 0.24258651618 0.248557401899 0.228985563027 0.232518055884 0.22563381547 0.2253177885 0.223189662674 0.247286475663 0.221462369267 0.239019854286 0.21687609732 0.250217711381 0.219989961903 0.23614243802 0.241179806044 0.242913875985 0.228427928816 0.222559090866 0.229759973658 0.244438457877 0.230953863516 0.242870282486 0.24276526561 0.244179265793 0.237465205634 0.24045622955 0.230407994296 0.238017253402 0.230045288889 0.0082487413397 0.0434871339043 0.050183840328 0.0462946366306 0.0331671559449 0.0413860283481 0.0432754400997 0.0331671559449 0.018728526127 0.0181135727037 0.0407852007406 0.0552412031248 0.0241124765906 0.0672915663182 0.036051090003 0.0318240646756 0.0214815502931 0.0159437959725 0.0254901889174 0.0237539942631 0.169264556488 0.175091115152 0.180818741393 0.194404360875 0.187867354301 0.185963216048 0.181699481724 0.164435072081 0.175589139186 0.186821392192 0.185627969522 0.180155862933 0.18064011609 0.186712516664 0.164002900607 0.168780956251 0.190185205445 0.164923288811 0.210475012613 0.173888729012 0.199146471591 0.170598213889 0.205685349652 0.18167215365 0.171034804287 0.172628140609 0.185232711805 0.19500403819 0.187902476327 0.154050585176 0.176234935944 0.168650273349 0.169706859713 0.209769138775 0.193110247226 0.179199013537 0.178806517751 0.195681872133 0.172338947581 0.186953230165 0.188260629529 0.181677967227 0.175468629894 0.167135725316 0.183547713996 0.168593151982 0.176177479228 0.172880341359 0.156935998004 0.176943539051 0.234533528357 0.223126396017 0.219327759561 0.216348929156 0.227347260416 0.225044163552 0.22369577874 0.21767535265 0.227960059154 0.218355967949 0.204394726122 0.219392188471 0.216234012192 0.232478694207 0.237601395838 0.219130755018 0.209451421522 0.208536786671 0.245551542374 0.221905162641 0.219288471778 0.22312655653 0.228847315313 0.210092965448 0.212618708514 0.205172062073 0.20633435877 0.203530506813 0.227844403478 0.201098042061 0.219576265526 0.196351165226 0.231028528894 0.199557870197 0.214705957114 0.222733230705 0.223437599857 0.207886214359 0.202974139337 0.210949037245 0.225748458168 0.213347187038 0.223126396017 0.223291835541 0.22533034675 0.219465519892 0.221962474599 0.211307137623 0.21852957733 0.209700938041 0.0419192621384 0.0545713872547 0.0501857282151 0.0312681130066 0.0402402021553 0.0420008929211 0.0312681130066 0.0205720172252 0.0184919891428 0.0424913715031 0.0489285308529 0.0286939286865 0.0683097144827 0.0399734095489 0.0293256914093 0.0276858239832 0.0194684720042 0.0280123772406 0.0234918354003 0.166859723597 0.173331371512 0.178503598003 0.191909917223 0.185423378094 0.184241312774 0.180294315558 0.162400014304 0.173055799755 0.185412361634 0.18273757472 0.178554599617 0.177148633502 0.184812731656 0.162323255063 0.166439616176 0.188986532191 0.162572794611 0.207449709654 0.171422042516 0.198077549025 0.168235674576 0.203119984389 0.179508471538 0.16860424661 0.170241216483 0.182496759111 0.192879913246 0.186103766816 0.151333877107 0.173669495408 0.165942821486 0.167423536544 0.20787297933 0.192134128169 0.178241744028 0.176630454655 0.192503529595 0.170982423968 0.184797056786 0.186354645979 0.179907483835 0.173050611212 0.164731478826 0.181684378357 0.167089130276 0.174542724285 0.170681059367 0.154769008136 0.175102602238 0.233527638993 0.221524217045 0.217249882254 0.214634557666 0.225748190551 0.222754126699 0.222507410575 0.215313006261 0.225475910208 0.217028556203 0.202867049651 0.217307455338 0.214308520933 0.230711314018 0.236268919515 0.217806003587 0.207670960165 0.207072717123 0.242941912447 0.219250459655 0.217623775648 0.221838573376 0.226272530404 0.207953270239 0.211176611808 0.20315950921 0.204399143496 0.201993427277 0.226020220858 0.198708591851 0.217018221505 0.194631582156 0.229236199557 0.197470332905 0.212630809879 0.22033552246 0.22249437564 0.206324343096 0.201514537553 0.209042945777 0.224134795171 0.211456208554 0.221524217045 0.221736417649 0.223988271389 0.217633390228 0.219633609699 0.209536083539 0.217632171671 0.20838956304 0.0775399671204 0.0564468400456 0.0653641254742 0.0395849667657 0.0441943006701 0.0653641254742 0.03373111328 0.0393588608039 0.0260318537498 0.035188052496 0.0394930245033 0.0375459624937 0.0389958606199 0.0129896263362 0.048815943545 0.0379517413039 0.0436570210079 0.0373605585088 0.163502150984 0.168337389523 0.175155703097 0.187828039408 0.181028588214 0.182647655516 0.175454197959 0.158708602469 0.170954310136 0.179762949884 0.180496225683 0.172501221065 0.176828601599 0.182533215894 0.154901122018 0.161684635697 0.185118234991 0.163277975005 0.203127118484 0.169348081929 0.192443927773 0.163103682661 0.200509349698 0.179853786658 0.164993784705 0.165655282459 0.179962811264 0.188228038198 0.18173609183 0.147930089008 0.171080786567 0.164375611634 0.163483874158 0.205438086531 0.18853460221 0.172643498492 0.17244334411 0.189729944562 0.167174105351 0.180637454384 0.185804185303 0.177096116234 0.169809585441 0.16090449309 0.178551065139 0.165213876 0.171240797871 0.16732581913 0.146067131815 0.17119760345 0.227732558213 0.216775565291 0.212818856201 0.212113111804 0.220864451794 0.220275362854 0.217805693503 0.214378859193 0.223348154292 0.21056133718 0.196361313338 0.212749259626 0.208612136858 0.225027947273 0.228363013794 0.210350767964 0.204552905568 0.204069917831 0.240058060786 0.217392662406 0.211260278871 0.215701291359 0.224730833936 0.202526361799 0.206282759299 0.201292044309 0.198558189974 0.196671901675 0.221200953228 0.197951565037 0.214539723027 0.191917757906 0.223779418483 0.195733699704 0.214045901526 0.214810423689 0.215727246675 0.203293848315 0.195827563807 0.20277537878 0.217057373264 0.202583470922 0.216775565291 0.216238379997 0.216660429864 0.209514540125 0.213990052328 0.203581443905 0.210749726957 0.20422943306 0.0299803388219 0.040141041955 0.0494042382248 0.0475047073328 0.040141041955 0.0460070623429 0.0427394298505 0.0575631845334 0.0966299998606 0.0399614977189 0.101837465377 0.0750240618009 0.0697188576907 0.0332240827502 0.042809511279 0.0352142478257 0.0438103448171 0.215592317841 0.220449330264 0.226776190885 0.240218246846 0.233773884944 0.231038348034 0.2263684672 0.210465175429 0.221881119192 0.231308080404 0.231995396207 0.22508238649 0.227350588366 0.232024663305 0.209334152567 0.215020396004 0.234337406165 0.211132081266 0.256379513335 0.220156177626 0.242726282533 0.216799299323 0.251315628789 0.227298889535 0.217343977664 0.218830240402 0.231491464759 0.240364579333 0.233021642066 0.20102218505 0.222551706707 0.215242680103 0.215887525017 0.254517907032 0.236803444285 0.223122921939 0.224639449766 0.242029857582 0.217221787473 0.232566133597 0.233478733428 0.226945320336 0.221662735537 0.213507733767 0.228892766884 0.213808892567 0.221389781107 0.218899946715 0.202924474402 0.222409930936 0.277044937084 0.267058523642 0.264053120566 0.260683081125 0.271161003688 0.269928478944 0.266921380471 0.262757571495 0.272983826376 0.261803183737 0.248535164351 0.264118904646 0.260747941814 0.276361888176 0.280348586054 0.262426412526 0.254046125774 0.252677731845 0.290308221249 0.267228122274 0.26327783075 0.266417210913 0.273921992864 0.255063180539 0.256547903477 0.250174111671 0.251094888905 0.247813627121 0.2719924919 0.246585755223 0.264876118769 0.241182097008 0.275004799417 0.244784301617 0.259319666846 0.267703173929 0.266005774781 0.252196034878 0.247119094967 0.255516011217 0.269407340011 0.257485027934 0.267058523642 0.267089999571 0.268509786469 0.263477813268 0.266862086523 0.25569939087 0.261126117571 0.253527997613 0.0490986378456 0.0295882981502 0.0295703235206 0.0490986378456 0.0321772405698 0.0329624694956 0.0320791928311 0.0819581869701 0.0243777845713 0.0815880274595 0.0630031242432 0.0521832400773 0.0270041961787 0.0316626367995 0.0225970983534 0.0306135777155 0.209138400452 0.213486068388 0.2205444529 0.233810061497 0.227135531522 0.225853564299 0.21966357841 0.203852341272 0.216088869802 0.224306040557 0.226217923772 0.217746213648 0.22224285579 0.226486749722 0.201086071725 0.207931744175 0.228270944293 0.206490835508 0.249940445551 0.214362660634 0.235990805565 0.209564571075 0.245741550277 0.222850058752 0.210799114332 0.211874421056 0.225608964554 0.23378761328 0.226547651045 0.194192088088 0.216536885951 0.209533041634 0.209201443093 0.249253656365 0.230961033564 0.21611849601 0.218017866257 0.236081990375 0.21084689547 0.226091432124 0.228781524913 0.221104911259 0.215367366824 0.206800674523 0.222911320613 0.208230596605 0.21525709201 0.2125575014 0.193883560936 0.215963986139 0.270701972881 0.26093677072 0.257916700448 0.255512820108 0.265026258573 0.264740784654 0.260931231555 0.258198696768 0.267948592812 0.254868213876 0.241356571396 0.257920982238 0.254009770883 0.269860597717 0.272941762013 0.255029971614 0.248480879151 0.247232962401 0.285073136127 0.262202525959 0.256323297606 0.259707446043 0.269155247223 0.248322830219 0.250262594392 0.245086205405 0.244160084795 0.241180503071 0.265837705385 0.241871800867 0.259549733542 0.235634358004 0.268589453275 0.239657575868 0.255932774798 0.261005427367 0.2590787222 0.246704864465 0.240323606031 0.248446059436 0.262200385961 0.249216212931 0.26093677072 0.260623330072 0.261243034875 0.255650557301 0.260116706756 0.248814449864 0.254094104786 0.247584466928 0.0426893927085 0.0408370899258 0.0 0.0368318621027 0.029200211213 0.0578784327643 0.069522041979 0.0411420259607 0.0955605905857 0.0684916485028 0.0536985636371 0.0361283833003 0.0349236407736 0.0326544016244 0.0320790517512 0.190734279342 0.198011093099 0.202165335147 0.215193803756 0.208989236133 0.207943677959 0.205067684162 0.186855165408 0.196324830352 0.210203923195 0.205342231011 0.203427359944 0.198526873832 0.208498767129 0.187766259392 0.1906844311 0.213518747065 0.185598548292 0.229746939288 0.194805777978 0.222821572969 0.192481412892 0.225723793976 0.202375384198 0.192457483521 0.194300696695 0.205376522136 0.216660688755 0.21030774241 0.175307222553 0.197000980201 0.189066511629 0.191539232379 0.231058906578 0.21669613367 0.203523564636 0.200666530244 0.214595210264 0.195827171333 0.208641958794 0.209561099462 0.203960485003 0.196717491572 0.188766309975 0.205678014795 0.191492051166 0.198961164508 0.194672996958 0.180152450124 0.19944864987 0.257583228235 0.245178524187 0.240481186058 0.23786630337 0.249341975217 0.245210894146 0.246468005973 0.237456371003 0.247563146561 0.241300303041 0.22729752986 0.240555698528 0.237993038095 0.254193700204 0.26033321069 0.24220764546 0.231128442611 0.230799434891 0.264694157473 0.241194058993 0.241588310222 0.245985985156 0.248083056968 0.231516408669 0.235215479132 0.226198260689 0.228320459149 0.22623565919 0.249391170367 0.221152204365 0.239284874476 0.218351963925 0.252686589685 0.220530747351 0.234477098822 0.243363395844 0.246969168578 0.229990071021 0.225895881072 0.232959826282 0.248113114083 0.23570223574 0.245178524187 0.245562733947 0.248226439579 0.241702239505 0.242775171886 0.233515238499 0.242256602421 0.232453320509 0.00485178735022 0.0426893927085 0.0245520805084 0.0237321483943 0.0251494297711 0.057422445578 0.0278324002426 0.0740340192529 0.0616449531864 0.0345266403523 0.0352178925007 0.0280808122885 0.0215364121522 0.0177797202497 0.195939824645 0.201850357058 0.207610278022 0.22033675889 0.213750209485 0.214735564684 0.209038553623 0.191585516698 0.202707820911 0.213610139259 0.211883129405 0.206450810174 0.206559465565 0.214810867748 0.189369070647 0.194741318593 0.218356798216 0.193913039155 0.235021949805 0.201158850164 0.226304640977 0.196279111135 0.23226696484 0.210758787397 0.197506357802 0.198589557713 0.211650666116 0.221261000242 0.214919567324 0.180148757389 0.203013849771 0.195747568982 0.196259855385 0.237643665501 0.221708411792 0.206639148011 0.205357745264 0.220920753341 0.200419916968 0.213509698507 0.217293606067 0.209702604063 0.202159105945 0.193545439121 0.211227865592 0.19759997516 0.20414742205 0.199914048013 0.180698578828 0.204233409175 0.261355583351 0.249944219156 0.245612323364 0.244419283687 0.254044690674 0.252080319195 0.251117898529 0.245501499007 0.254799073865 0.244461494615 0.230320341653 0.245583982907 0.241986600586 0.258340089378 0.262471019952 0.244539880639 0.237114058797 0.236754636273 0.271527597514 0.248603215251 0.244975611097 0.24946627049 0.255826675762 0.23571262824 0.239663820665 0.233206292475 0.232061847402 0.230234276049 0.254229520181 0.229085095534 0.246138012907 0.224434087127 0.257016267918 0.227571722833 0.244299258458 0.247702557023 0.249766808341 0.235948695396 0.229554249737 0.236400217176 0.250952182681 0.236961759284 0.249944219156 0.249686907558 0.250743450736 0.243657848264 0.246990711027 0.237179418187 0.244877764453 0.237415960787 0.0408370899258 0.0273499265107 0.025297636378 0.0296282714156 0.0603715739764 0.030303105355 0.0787085816014 0.0655434565706 0.0387042108075 0.0365503327535 0.0303622028421 0.0226096284705 0.0196557817863 0.19925839426 0.205348957591 0.210921560248 0.223617852816 0.217069506306 0.218059817218 0.212575335145 0.194999027921 0.205926088655 0.217171129009 0.215009852018 0.21001079042 0.209452929226 0.218136520475 0.193003747556 0.198137341753 0.221866239829 0.197043564846 0.238162085485 0.204392911714 0.229893095054 0.199683809546 0.235440202166 0.213909407049 0.200827966888 0.201961005661 0.214826820158 0.224639586072 0.218358620882 0.183440825957 0.206248208954 0.198918059014 0.19962810203 0.240932955881 0.225232933618 0.210279009964 0.208738673233 0.223984027141 0.203935797463 0.216876482587 0.220527121607 0.21308659534 0.205456328664 0.196890655988 0.214607347176 0.201007750183 0.207588221909 0.203264328774 0.184313736826 0.207665740899 0.26489357675 0.253366014308 0.248941435732 0.247733075772 0.257464720601 0.255265649267 0.254603866324 0.248608337617 0.25792057227 0.248007634376 0.233863042555 0.24891723403 0.245404277418 0.261753780229 0.266030956859 0.248122124098 0.240457509587 0.240148573616 0.27462290691 0.251686093628 0.248460344614 0.252996524531 0.258897040073 0.239091218679 0.243138472416 0.236454818573 0.235503469176 0.233728803563 0.257606144443 0.232210377675 0.249277823428 0.227793973728 0.260419107201 0.230810446264 0.247340816609 0.251008018719 0.253372216044 0.239328849004 0.233077723245 0.239855175697 0.254460096493 0.240510971982 0.253366014308 0.253147704183 0.254305992093 0.247178452498 0.250316773817 0.240645130337 0.248503359474 0.240885126472 0.0368318621027 0.029200211213 0.0578784327643 0.069522041979 0.0411420259607 0.0955605905857 0.0684916485028 0.0536985636371 0.0361283833003 0.0349236407736 0.0326544016244 0.0320790517512 0.190734279342 0.198011093099 0.202165335147 0.215193803756 0.208989236133 0.207943677959 0.205067684162 0.186855165408 0.196324830352 0.210203923195 0.205342231011 0.203427359944 0.198526873832 0.208498767129 0.187766259392 0.1906844311 0.213518747065 0.185598548292 0.229746939288 0.194805777978 0.222821572969 0.192481412892 0.225723793976 0.202375384198 0.192457483521 0.194300696695 0.205376522136 0.216660688755 0.21030774241 0.175307222553 0.197000980201 0.189066511629 0.191539232379 0.231058906578 0.21669613367 0.203523564636 0.200666530244 0.214595210264 0.195827171333 0.208641958794 0.209561099462 0.203960485003 0.196717491572 0.188766309975 0.205678014795 0.191492051166 0.198961164508 0.194672996958 0.180152450124 0.19944864987 0.257583228235 0.245178524187 0.240481186058 0.23786630337 0.249341975217 0.245210894146 0.246468005973 0.237456371003 0.247563146561 0.241300303041 0.22729752986 0.240555698528 0.237993038095 0.254193700204 0.26033321069 0.24220764546 0.231128442611 0.230799434891 0.264694157473 0.241194058993 0.241588310222 0.245985985156 0.248083056968 0.231516408669 0.235215479132 0.226198260689 0.228320459149 0.22623565919 0.249391170367 0.221152204365 0.239284874476 0.218351963925 0.252686589685 0.220530747351 0.234477098822 0.243363395844 0.246969168578 0.229990071021 0.225895881072 0.232959826282 0.248113114083 0.23570223574 0.245178524187 0.245562733947 0.248226439579 0.241702239505 0.242775171886 0.233515238499 0.242256602421 0.232453320509 0.00792313459309 0.0236297776546 0.0536541076705 0.0108412074571 0.0628560371629 0.0400426717019 0.0242916508179 0.0172043768705 0.0050674059167 0.0120480352419 0.00909567999576 0.179733982337 0.185130641595 0.191359647755 0.204666509458 0.198016972069 0.197255576955 0.19185518721 0.174855164332 0.186481505005 0.196685913747 0.196375987191 0.189833405887 0.19172374648 0.197739787295 0.173088361774 0.178764981726 0.200732295255 0.17675687262 0.220477540317 0.184804954654 0.209049846749 0.180446207623 0.21646451476 0.193507677512 0.181414841832 0.18267689502 0.195938395299 0.20515640915 0.198204629073 0.164323672477 0.186951627799 0.179636188812 0.180004434454 0.220785829324 0.203765417111 0.189073881786 0.189075562692 0.206144383335 0.182845346787 0.197260508087 0.199879524686 0.192526504243 0.186000212457 0.177429453542 0.194272636643 0.179755047797 0.186852872988 0.183420017951 0.165408476828 0.187374971211 0.244379342624 0.233352874625 0.229596132577 0.227371143644 0.2375226222 0.23596534417 0.233967797192 0.229101525181 0.238946455726 0.22794079194 0.213947298319 0.229612039594 0.226054866131 0.242325328031 0.24658946328 0.228320886035 0.220245475488 0.219410638455 0.256223296024 0.232925784221 0.228888220536 0.232841814871 0.240004491346 0.219971839687 0.222802209556 0.216357175156 0.216093165101 0.213536808192 0.238014479196 0.212556057937 0.230415334062 0.207278762186 0.240959781593 0.210762423837 0.226970181506 0.23251461018 0.23290234378 0.218739342276 0.212847200349 0.220551656017 0.235068599786 0.221910374672 0.233352874625 0.233237981586 0.234568034713 0.228343429058 0.231717374059 0.221050886534 0.227947933137 0.220165226053 0.0299322879907 0.05484354778 0.015508827535 0.0698377856312 0.0461226756997 0.0288439268589 0.0179749812614 0.00820193608475 0.0104514607363 0.00601471721254 0.182232775094 0.188144985482 0.193867682363 0.20711590793 0.200550766912 0.199860135361 0.195016228938 0.177611309591 0.188739284934 0.199919451707 0.198412537874 0.193032154463 0.193186123937 0.200329430243 0.176446801251 0.181459762374 0.203862717343 0.178811701467 0.222599641879 0.187102653143 0.212418919228 0.183165138771 0.218668582765 0.195650642874 0.183922319896 0.18531418569 0.198099986213 0.207874048966 0.201087073424 0.166709980365 0.189246782627 0.18175655241 0.182635613511 0.223327464443 0.206968516624 0.19255440527 0.191763016548 0.208041469681 0.185943960269 0.199929552497 0.20225187193 0.195263692383 0.188456709089 0.17999008547 0.196992188976 0.182563902533 0.189736470349 0.186019084029 0.168664903455 0.190216873808 0.247702840069 0.236282170601 0.232244216334 0.230002139075 0.240457584895 0.238254033101 0.237105182737 0.231183514354 0.241076068443 0.231215767875 0.217161214732 0.232270602033 0.228935795245 0.245246208475 0.249963377759 0.231700745278 0.222930449716 0.222251471523 0.258324331925 0.234942120984 0.231973156153 0.236088516952 0.242009296663 0.222723564262 0.225860019318 0.218781249758 0.219012595092 0.216618271437 0.240821050718 0.214649402949 0.232567858569 0.209986385677 0.243846113816 0.213146433073 0.228924161819 0.235098611969 0.236391467186 0.22153411273 0.216011138881 0.223520339681 0.238239770023 0.225155295827 0.236282170601 0.236275025927 0.237908750738 0.231525069379 0.234355153325 0.224056763193 0.231485450395 0.223215654925 0.0572284762647 0.0227453897084 0.0528238726337 0.0444991634471 0.0266973769114 0.0336948312224 0.0272062333147 0.0274688740262 0.0263328670099 0.185716682176 0.189934662812 0.1972487923 0.210230033124 0.203429572326 0.203652674494 0.196491149306 0.180504651022 0.193104816748 0.200892549998 0.203064104164 0.193989394378 0.199601579765 0.203900303764 0.17670118478 0.184039790634 0.205684310622 0.1846555251 0.226113704537 0.191415178407 0.212986837934 0.185538541574 0.222740004307 0.201086740863 0.187280443615 0.188038576609 0.202414184433 0.210238732317 0.203278048935 0.170511460418 0.193354539773 0.186626010428 0.185640639557 0.226777734968 0.208697723096 0.193060716385 0.194490643156 0.212667601723 0.188009393157 0.2026405567 0.206872630148 0.198376957217 0.192017886181 0.18319542151 0.200010008529 0.185964041385 0.192410951726 0.189280207199 0.168712331151 0.192752182621 0.248024768226 0.23796255467 0.234657432476 0.23319215601 0.242043627351 0.242092609424 0.238343194449 0.236048752979 0.245336704526 0.231521041315 0.21770196943 0.234612870361 0.230403022013 0.246515101463 0.249324779094 0.231381623939 0.225835327084 0.224876205525 0.262239370649 0.239554652873 0.232726560614 0.236544998844 0.246724791051 0.22460575232 0.227286958934 0.222708966341 0.220419587826 0.21790450046 0.242699459353 0.219658545965 0.236700307439 0.213086341068 0.245286981729 0.217239309033 0.234909245332 0.237182720463 0.236050820735 0.224251890124 0.21698485009 0.224622112179 0.238475066919 0.224611061526 0.23796255467 0.237436165661 0.237675287343 0.231370754771 0.236291823604 0.225200181658 0.231029643716 0.224953381888 0.0635710838178 0.0592624543316 0.0596058092469 0.0328544820604 0.0698260168465 0.0573261822931 0.0634460229613 0.0541080958794 0.147303482686 0.155161448288 0.159136079545 0.171063643845 0.16463221595 0.168584971583 0.163624194761 0.144235266953 0.153827968777 0.168063795028 0.16179307599 0.160206770568 0.155398151635 0.167887347752 0.142965424509 0.146100735749 0.17375554158 0.146517107633 0.184102282814 0.152518687773 0.182006446517 0.147493939017 0.182975421708 0.163616999091 0.148716120222 0.149770660992 0.161958247648 0.173135111896 0.168022513735 0.130738265008 0.153920373487 0.146537313722 0.147925357539 0.190546691654 0.177990062346 0.162980599048 0.157241520972 0.169863812022 0.155438284157 0.165389918434 0.170707644688 0.163197102596 0.153422018191 0.144858486622 0.164315178145 0.152440808389 0.158128021971 0.151920639439 0.132537826475 0.157359920068 0.217237278816 0.203578319465 0.19760287759 0.197919551969 0.207681519923 0.203644803794 0.206313583309 0.1971606419 0.205828867849 0.199064489236 0.184178187026 0.197538822775 0.194404518771 0.211337912042 0.217143803133 0.199166671372 0.190313841849 0.191119829867 0.222105237734 0.199176357415 0.198307304 0.204224647581 0.206706114847 0.187412194782 0.19389709622 0.185837912363 0.184448440446 0.184112718669 0.207064291919 0.180760878547 0.196874753064 0.177987251583 0.20993106085 0.180009687643 0.197504007472 0.198552660709 0.205899002329 0.189953313758 0.183706289376 0.188863124638 0.204480568311 0.189510910124 0.203578319465 0.203449868624 0.205307715981 0.196398052452 0.198053210544 0.190139115088 0.201200460168 0.192215464603 0.0646648846724 0.0408252785942 0.0324283536149 0.0110096321254 0.0094227049932 0.0109851717283 0.0161323040352 0.185995265043 0.190666336997 0.197500031875 0.21094278484 0.204249573992 0.202798103731 0.196994111724 0.180742040387 0.192881751338 0.201790619427 0.203110749465 0.195155158145 0.19908437034 0.203454592708 0.178505994536 0.184932353957 0.205646229373 0.183039730424 0.227253690432 0.191142107437 0.213742423108 0.186621634482 0.222820224457 0.199555206103 0.187692696694 0.188884746385 0.202513734055 0.21103182776 0.203761324581 0.170936996707 0.193374027451 0.18623653615 0.18612791719 0.226436319176 0.208431967216 0.193707164322 0.195058461584 0.2131353075 0.187987297837 0.203202157658 0.20562939159 0.19810682266 0.192261721083 0.183685994256 0.199939039445 0.185109577754 0.192293556305 0.189460942551 0.171326016098 0.193018202765 0.248893705524 0.238594153414 0.235368547023 0.232809197602 0.242745772985 0.241996085058 0.238752248121 0.235253956997 0.245180784501 0.232837883436 0.219103668122 0.235388183401 0.231636120508 0.247694764978 0.251385734184 0.233178069062 0.225757404345 0.224585782777 0.262534762143 0.239353867417 0.234157942476 0.23769286224 0.246342255252 0.225805082888 0.227891511242 0.222153883963 0.221706146684 0.218742321816 0.243483255972 0.218775046696 0.236736505477 0.212768083313 0.246367071263 0.216653745648 0.232866084107 0.238586937872 0.237342638049 0.224021718097 0.217958679267 0.226108360277 0.24024082191 0.227355271774 0.238594153414 0.238405022146 0.239431466759 0.233734880392 0.237715653864 0.226470518154 0.232346541994 0.225139690924 0.0393671458325 0.0464638919444 0.0721210062546 0.0652058473437 0.0727980489441 0.069475743339 0.146377403101 0.147841270546 0.157364583964 0.169967544666 0.162961576643 0.163688135507 0.153695971045 0.140223917866 0.154815274304 0.157460458795 0.165356253736 0.150768971529 0.165320051187 0.163744020488 0.133177827162 0.143578449734 0.163063976092 0.148488500757 0.186880468442 0.153029883361 0.168852310214 0.144817839236 0.183493098196 0.16367577587 0.147767272784 0.147687188567 0.164075138054 0.168705452589 0.161392920433 0.132534765042 0.154766041608 0.149414499828 0.145576557217 0.186084208163 0.165901662347 0.149128920765 0.153742006284 0.175201329509 0.146090630422 0.161672202019 0.168031911823 0.15768748388 0.152605178523 0.14358929792 0.159222856143 0.14586039418 0.151244472229 0.149339889326 0.125727972716 0.151529925609 0.203450036676 0.194986217471 0.192843589773 0.192004248179 0.198946853705 0.202034655336 0.194735870429 0.197390062155 0.205967080811 0.187074482741 0.173679535364 0.192730113791 0.187498820793 0.203203985607 0.204052975425 0.186370806955 0.184428712838 0.182999565721 0.222535792393 0.200873648 0.188899014225 0.192203777807 0.208005111614 0.182384645276 0.184037705225 0.182740791406 0.177549631149 0.174643342307 0.20005255491 0.181451046073 0.197344936488 0.172060390986 0.202165775813 0.177622921879 0.197550181919 0.195373313831 0.190875275066 0.18253037262 0.173366080571 0.181382900577 0.194116360457 0.17989694523 0.194986217471 0.19390780748 0.192735187036 0.186889353803 0.194252690611 0.181881177771 0.185754237755 0.182012475847 0.0362542669235 0.0433946419111 0.0395938166279 0.0499100911085 0.0488639489089 0.15152574063 0.154669324023 0.162831337388 0.176665753207 0.169806006203 0.167122046596 0.160378494232 0.145396880889 0.158882941041 0.165181343889 0.170013544811 0.158841213295 0.168049497633 0.168033584387 0.142281111905 0.150191536414 0.168801703096 0.149137142763 0.194382185315 0.156984666205 0.176687245859 0.151908690894 0.188914920448 0.165149458367 0.153257832095 0.154263633953 0.168972071115 0.175883337588 0.16793063653 0.137286345822 0.159386690667 0.152763325671 0.151315442368 0.191108253021 0.171290308569 0.156330262179 0.159994057675 0.180780718652 0.151317533557 0.168120728135 0.170508979962 0.162341150711 0.157837504705 0.149168793021 0.164327797527 0.148926027403 0.156192253462 0.154516403486 0.136169004568 0.157264478091 0.212122717934 0.202635989676 0.200296956824 0.197168424809 0.206818081536 0.207593997357 0.202129844535 0.201194661862 0.211287068634 0.196367072918 0.182828097116 0.200324517328 0.196191886272 0.212106652571 0.215234691898 0.196754062665 0.19012565359 0.188386972878 0.22899541165 0.20586463613 0.198258080181 0.201204812212 0.21275581912 0.190751178898 0.191559171703 0.187109767024 0.186199376174 0.182482910799 0.207969239625 0.184720534783 0.20291190811 0.176982703379 0.210810911009 0.181756418439 0.198660937707 0.204191111601 0.200384835859 0.187985877445 0.181554202617 0.190580156178 0.204342491841 0.191957847677 0.202635989676 0.20235052312 0.203098119616 0.198224746232 0.20315819974 0.190687755597 0.195275148422 0.188602851388 0.0403137962831 0.0283224608052 0.0352856337592 0.0279159520938 0.163417587591 0.169024399252 0.175174902733 0.188097949492 0.181377843525 0.182339093803 0.176249889638 0.158817342465 0.170474967966 0.180845899763 0.180001842158 0.173609983768 0.175496658011 0.182387588854 0.15630806646 0.162058645803 0.185720747493 0.161911269413 0.203372519665 0.168871283524 0.193698104443 0.163602773962 0.200347540332 0.178768462478 0.164992621499 0.165987648079 0.179610648238 0.188805808549 0.182291142535 0.147635227715 0.17074779736 0.163623388142 0.163626611748 0.205461058801 0.189137857415 0.173807850394 0.172761367844 0.189359771077 0.167597338583 0.181003226921 0.18512092453 0.177130623568 0.169726367846 0.160952549622 0.178668367454 0.164953979441 0.171439694143 0.167334380068 0.147661742228 0.171525073941 0.229212799489 0.217687295638 0.213458314816 0.212251579761 0.221837277994 0.220248120289 0.218836902814 0.21380890761 0.22315649106 0.21209021333 0.197773787684 0.213427195478 0.209691510886 0.226221325989 0.230427027381 0.212200169545 0.204828617154 0.204406576244 0.240127225685 0.217034360511 0.212651201199 0.2171572787 0.224326708779 0.203421180278 0.207247009432 0.201076078606 0.199634752126 0.197699005741 0.222082174457 0.197241869749 0.214400679015 0.192020712279 0.224886788727 0.195424460906 0.212817607264 0.215705919361 0.217495203752 0.20360497892 0.196993475509 0.204019508797 0.218720046506 0.204677118987 0.217687295638 0.217405004007 0.218489214457 0.2114130463 0.214943199157 0.204771656731 0.212548494217 0.204988233676 0.0127227257693 0.0140144534262 0.021205315625 0.187358882688 0.192125766059 0.198772205734 0.212374766999 0.205757524042 0.203466313878 0.198269360384 0.182075536022 0.193992765379 0.203217006858 0.204331991647 0.196763084721 0.20014614007 0.2043270841 0.180514052654 0.186571402116 0.206603961592 0.183553088594 0.228871000555 0.192232411854 0.214999691886 0.188338267885 0.22392031363 0.199986970587 0.189109313009 0.19048409561 0.20374267521 0.212452607057 0.205039311477 0.17250608603 0.194596025922 0.187333202847 0.187569910566 0.227244357321 0.209244321292 0.19501056691 0.196469921009 0.214533216851 0.189073691369 0.204563213894 0.206128514596 0.199072106837 0.193573357583 0.185159768848 0.200995780718 0.185854759801 0.193344854477 0.190733738309 0.173803583444 0.194263918799 0.250041858008 0.239752334137 0.236636793113 0.233547933384 0.243918830588 0.242901503454 0.239756635176 0.235879076786 0.246072511959 0.234292093183 0.220682667006 0.236686092505 0.233134556981 0.249085035733 0.25310029637 0.234845006722 0.226672837999 0.225370202913 0.263585873652 0.240269679341 0.235701118126 0.239046163418 0.247138992266 0.227341018945 0.229062028698 0.222899030248 0.223273394137 0.220071420598 0.244719204688 0.219434280561 0.237757183282 0.213627898609 0.247720909818 0.217420020786 0.232895251914 0.240194731922 0.23871780496 0.22484832656 0.219342733041 0.227741527766 0.241902288188 0.229541957119 0.239752334137 0.239709455557 0.241056941465 0.235717844261 0.239326740269 0.227988125157 0.23374803561 0.226117504317 0.0112944223112 0.0116717916683 0.180315550232 0.185624806253 0.191893759643 0.205310880338 0.198677901623 0.19742928403 0.192207723586 0.175346071899 0.186991091141 0.197103740487 0.197010559796 0.19035952375 0.192415460068 0.198031907427 0.173783350974 0.179445795208 0.200920544981 0.176980189616 0.221316628359 0.185291341794 0.209338461592 0.181164395028 0.216995536327 0.193672787851 0.182024521085 0.183353435463 0.196543976916 0.205721030365 0.198641096205 0.165041173069 0.187513275437 0.180170480519 0.180593580969 0.221064954649 0.203852710847 0.189347093282 0.189636739108 0.206917162302 0.183105626465 0.197802407018 0.200023916345 0.192826802002 0.18656768388 0.178054301819 0.194629767109 0.179904508376 0.187157083025 0.183925453374 0.166391248738 0.187799823192 0.244629672801 0.233720966397 0.230103074977 0.227589285523 0.237898238239 0.236372028201 0.234191133105 0.229406521443 0.239389014631 0.228371263352 0.214461216321 0.2301324354 0.226622699222 0.242825477857 0.247136546528 0.228837795311 0.220544275821 0.219592617307 0.256764787312 0.233410014962 0.229423132068 0.233225877209 0.240428033421 0.220595144087 0.223137647662 0.216631996383 0.216685610877 0.213950565713 0.238461242313 0.212870718316 0.230920602382 0.207535413146 0.241449474994 0.211057657029 0.226977435726 0.233226691247 0.233226664174 0.218957536154 0.213267398065 0.221167604245 0.235644719391 0.222751284499 0.233720966397 0.233655964463 0.235074683268 0.229091941731 0.232416283617 0.221592631388 0.228271321964 0.220395124759 0.00983853465038 0.190743576675 0.196127634014 0.202306832097 0.215593264431 0.208988714901 0.208014681254 0.202752493595 0.185879141861 0.197391448173 0.207587390017 0.207246286244 0.200818808941 0.202436920976 0.208560198594 0.184214467342 0.189842910423 0.211501430369 0.187510793393 0.23133568248 0.195719341744 0.219810583637 0.19153274103 0.227260064133 0.204197085901 0.192430421495 0.193730481177 0.206830708645 0.216081015857 0.209114627207 0.175418662775 0.197889059256 0.19054759391 0.191035254803 0.231501988345 0.214455580052 0.199914298524 0.200065006525 0.216984298716 0.193736240961 0.208206242937 0.210580217034 0.203385972256 0.196973524191 0.188474338185 0.205152454389 0.190585220715 0.197746685322 0.194398694242 0.176663593729 0.198324488838 0.254937931723 0.244068220209 0.240384243666 0.238035456407 0.248220627185 0.246646653405 0.244595211757 0.23972473422 0.249602645305 0.238680104062 0.224803483418 0.240405804306 0.236887764418 0.253050369586 0.257246240499 0.239074958955 0.230985078994 0.230097737916 0.266839316033 0.24359819756 0.239685124735 0.243538571704 0.250621888643 0.230851769093 0.233547789712 0.227075078845 0.226983547477 0.224362834405 0.248743336169 0.223247552937 0.241135379781 0.21805286342 0.251689329115 0.22150661959 0.237406179341 0.243353541542 0.243526559835 0.229448331316 0.22367406721 0.231427017129 0.245837459247 0.232818717405 0.244068220209 0.243969807123 0.245289155672 0.239200193755 0.242559723366 0.231895813526 0.238589343178 0.230870674099 0.185074856292 0.190966638679 0.196734232482 0.209858428647 0.203274864625 0.203041999473 0.197926990268 0.180506604609 0.191676192961 0.202741147438 0.201237653931 0.195771907735 0.19601488206 0.203403274574 0.179018659177 0.184172394714 0.206916175569 0.182062920029 0.225161143908 0.190059350101 0.215302655172 0.18583273214 0.22154130677 0.198918819466 0.186732254392 0.188033674574 0.200939126942 0.210648020541 0.203966819203 0.169461460201 0.19212652304 0.184698761261 0.185447917615 0.226382707341 0.210090272929 0.195464472523 0.194576182922 0.210724866996 0.188972223666 0.202749851185 0.205495551665 0.198311837225 0.191308228071 0.1827836447 0.199987032182 0.185758986102 0.192762378199 0.188912535548 0.170985151469 0.193136210612 0.250560354729 0.239150130043 0.235042618318 0.233086785485 0.243308731763 0.241203268173 0.2400598963 0.234273096316 0.244008938502 0.233948328457 0.219858019146 0.235053540533 0.231632132621 0.247968147104 0.252509320758 0.234318201257 0.225941055535 0.225341346975 0.261132458323 0.237859251815 0.23464919225 0.238863315744 0.244976238699 0.225403382703 0.228750181247 0.221868483944 0.221696049716 0.219446034661 0.243630311449 0.217754591911 0.235449762585 0.213055210612 0.246589228494 0.216230229788 0.232311179578 0.237695560547 0.239155145074 0.22460119101 0.218814227997 0.226159982187 0.240839111604 0.227492031494 0.239150130043 0.239069291581 0.240533107829 0.233959974366 0.236956995194 0.226761267667 0.234246750663 0.226212511867 0.0174000566092 0.0121264323023 0.0260599074483 0.0195345881682 0.024716388707 0.0269505563041 0.00951579401108 0.00952789620934 0.0312682326376 0.021380704298 0.0249359987416 0.0321633377276 0.0221499569656 0.0250465767598 0.00649156808823 0.035247677191 0.0178478945632 0.0452164673822 0.00796037757126 0.0457327534983 0.00806434689496 0.0382898633561 0.0225581753549 0.00212523780258 0.00635071079008 0.0188691425113 0.0279463141708 0.0242753243704 0.0170805625395 0.00904309726647 0.0106287996797 0.00382969063087 0.0441552932431 0.0411601284763 0.0356126616505 0.0116846154421 0.0333280322148 0.0231237862627 0.0194233884188 0.0266405905658 0.0193741592831 0.00647009737397 0.00313195595137 0.0192809490983 0.0198825976901 0.0184223649953 0.00589033700008 0.0274923472821 0.0151107135826 0.0780209291989 0.0597893086125 0.0526478480904 0.0519801851129 0.0640907142958 0.0582643284706 0.0646025548306 0.0523589334483 0.0615531482061 0.0598796956679 0.0449628875056 0.0527423072945 0.051324556652 0.0686409960047 0.0805660524071 0.0623345264313 0.0443847427682 0.0466830846559 0.0795542446923 0.0559362746494 0.057180756356 0.0643259703348 0.063211257271 0.0437185245372 0.0513548290636 0.0393714351609 0.0417127661704 0.0422926634719 0.0628873923745 0.0360959787877 0.0527047257983 0.0325588237609 0.0667976247829 0.0335624409497 0.0547114607912 0.0561052885987 0.069799650238 0.0449738444715 0.0432370258673 0.0470356297838 0.065014861143 0.055075271212 0.0597893086125 0.0609892947965 0.0676680770887 0.0593149961508 0.0554983088895 0.0479751568133 0.0662596895747 0.0497728280187 0.01649842894 0.0270940163297 0.0209738779605 0.0204474607028 0.0105739124512 0.0137437284214 0.0226997190651 0.0150100972387 0.0323011347894 0.008153166122 0.0475382748664 0.0187641297777 0.0164404692163 0.0144508320868 0.0210394349685 0.0305556358824 0.0486242638836 0.0214513889049 0.030175982789 0.0140964441541 0.0400575333251 0.0288561044949 0.0169609734513 0.0143755139823 0.0284025548343 0.0224203703593 0.013792641556 0.0304826758057 0.0219984307058 0.027438003111 0.0138498079587 0.0391014082904 0.0268826742795 0.0187520448645 0.0110691342578 0.0424853466078 0.0102534616754 0.0160596134656 0.0266767705353 0.0127998581546 0.0173245890268 0.0173211449901 0.0131739480428 0.0158792885006 0.00835247262611 0.012879803971 0.0267489620569 0.00596710410688 0.0651865992814 0.0501303259948 0.0467631748034 0.0452702235248 0.0544981935174 0.0559804285713 0.0526556031199 0.0527154428326 0.0609295585885 0.0469864956417 0.0318305696362 0.0467870360621 0.0428839020559 0.0596952123639 0.0682904935263 0.0490145651142 0.0373470202066 0.0372051258398 0.0783094346225 0.0573164765228 0.0464381891239 0.0518006344835 0.0637213875725 0.037328539174 0.0398159521041 0.0364375689163 0.0327311081772 0.0300536558581 0.0548465086523 0.039011355091 0.052932116237 0.0253006236285 0.0581288867478 0.0321437027692 0.0554616174667 0.0518535767409 0.0554912699649 0.0361633495108 0.0300500951908 0.0376868875379 0.053920841562 0.0443787428504 0.0501303259948 0.0504194914628 0.0549441033997 0.0487769599128 0.0505784847321 0.0377653392745 0.0513716565226 0.0379306609676 0.0148794236891 0.00906915259144 0.016817766784 0.022666965263 0.0181414830259 0.00943690730089 0.0254552863313 0.0160108606893 0.0217205062473 0.032481574081 0.0125336713193 0.0301048876528 0.0144114156753 0.0283145714635 0.0236499286545 0.0356994826174 0.00980454037789 0.0380382046842 0.0138535372004 0.0270349861178 0.0179310476065 0.0105970849446 0.0106446588122 0.0120133548138 0.0166102052911 0.0152998463146 0.0290596443937 0.00834773888805 0.0173051001714 0.012006228531 0.0322817993752 0.0342847484172 0.0334965405575 0.00578703582339 0.0267498608594 0.0233284219943 0.00836772170811 0.018341518653 0.0127097608473 0.00603575216863 0.0145919151911 0.0109073587446 0.0221533308504 0.0160929276419 0.00858765501382 0.0355326614102 0.0120318414802 0.067539995406 0.0482957753815 0.0406895564252 0.0402187129364 0.0525505335689 0.046337446086 0.0538706159523 0.0410532995186 0.049945680623 0.0498002070389 0.0356573113194 0.0408170339224 0.03998131445 0.0570983300794 0.0703114871106 0.0527515586 0.0326360388464 0.0357703215059 0.068007735392 0.0448145788863 0.0463929144792 0.0539072356938 0.0519007533329 0.0322898342044 0.0406511091494 0.027662402635 0.0308780067072 0.0322628111538 0.0510866561777 0.025649802677 0.0412344607513 0.0218269690426 0.0551778627391 0.0220763570226 0.0446670171533 0.0446820028935 0.060359178521 0.0338187065026 0.0337343667693 0.0362783001067 0.0544202026485 0.046225200341 0.0482957753815 0.049817335882 0.0576169439653 0.0494636606912 0.0440581542748 0.0371733017103 0.0573289834367 0.0394045266195 0.00716257307188 0.0232372547893 0.0296783885761 0.0325204811189 0.0212497773179 0.0292620976856 0.016439517739 0.0284506794787 0.0345599570635 0.018188478274 0.0407426749726 0.0271225123173 0.0318719827355 0.0364884226289 0.021914442716 0.0227786086069 0.0376078412936 0.0256329664506 0.0146652900265 0.0257412263731 0.0241649286356 0.0229439407062 0.0136364254073 0.0100256292567 0.0184950349026 0.0419365600148 0.0198805169881 0.0290470401931 0.0259349477967 0.0239003990661 0.037192775807 0.0407761513521 0.0178664543062 0.0194803036782 0.0346542430628 0.0113663417752 0.0228609184952 0.0221099611853 0.0198250112005 0.0281996969801 0.0190943935979 0.0354944682629 0.027502181016 0.0232700909093 0.0459502516894 0.0236639254111 0.0598327139142 0.0386582188727 0.0283018389706 0.0317793366202 0.0424462733589 0.0338166029949 0.0467225177273 0.0306128740578 0.0370882424143 0.0426365040044 0.0306518342203 0.028353389025 0.0289452185335 0.045605512774 0.0609187137277 0.0456096520871 0.0247062397964 0.0307047013286 0.0541889879817 0.0321986089116 0.0369056583991 0.0461635888574 0.0394191509814 0.0202672234717 0.0339543216254 0.0203331670034 0.0216962768111 0.0275014797571 0.0396207876643 0.019383687668 0.028134515225 0.0203542968498 0.0436399460151 0.0166979961449 0.0388212853573 0.0305366541923 0.0544557347145 0.0282093601187 0.0297076171269 0.0264388860156 0.0445799816631 0.0375526043804 0.0386582188727 0.0404030430489 0.0493940445937 0.0396161416365 0.0302144214958 0.0282464575757 0.0525063270042 0.0345543356833 0.0213910735206 0.0254312508458 0.0257342205184 0.0165221855109 0.0259539784544 0.0158835031429 0.0233831935041 0.0339323139257 0.0162106434865 0.03399674531 0.0200386549433 0.0299171917849 0.0320747556874 0.028046974659 0.0176794481153 0.0368388291758 0.0185008751091 0.0214981879903 0.0241691252685 0.0175651807134 0.0158907875652 0.0122369735355 0.0109776452166 0.015527622801 0.0354957768624 0.014819189185 0.0241388300803 0.019062303667 0.0287269405771 0.0357916006232 0.0364633531028 0.011219279972 0.0225748368915 0.0292557862917 0.00702356235419 0.0224830610185 0.0181511844266 0.0136555064616 0.0214280218685 0.0152776051594 0.0301845131917 0.0223495731118 0.0167956602264 0.0389756608983 0.0178914144765 0.0630604023291 0.0430080788574 0.0341031378994 0.0365519407683 0.0470199755056 0.0406269394348 0.0499352678431 0.0370580183618 0.0441324571638 0.0450148609009 0.0313792244576 0.0341228348643 0.0333031398497 0.0505703458181 0.0642434790604 0.0476293944045 0.0288843329998 0.0334940865056 0.0612862785232 0.0392274534904 0.040346557275 0.0490663667656 0.0464449738085 0.0249899515531 0.0366261362911 0.0249803957153 0.0245501998624 0.0286632518672 0.0448796558538 0.024023128213 0.0352285170514 0.0213779538928 0.0486983458625 0.0204530056806 0.043719713027 0.0366461987398 0.0563678077617 0.0312461294161 0.0303695774583 0.0296679302141 0.0480887950749 0.0392929320337 0.0430080788574 0.0443169978812 0.0521158245642 0.0424602914349 0.0361040078467 0.0312787145737 0.0538034695951 0.0366723303295 0.0189709615579 0.0257111384326 0.0217335533305 0.0223113040739 0.027967478664 0.0234852927562 0.0436322798908 0.00521461133699 0.0364760096592 0.0272343470762 0.018116669378 0.0277674536165 0.043201573857 0.0213285903305 0.0304538340544 0.0273512817022 0.0293661558134 0.0151289313008 0.0243064809516 0.0249356313294 0.024322988602 0.0196946095768 0.0139855052687 0.0405716245072 0.0223909261135 0.0287463352875 0.0239629151594 0.02510185342 0.0224608355139 0.0285849443101 0.0178309380123 0.0374526670612 0.0202528662781 0.0157931802813 0.00761690092841 0.00770880409418 0.0208073209186 0.0270724449013 0.00859765119326 0.0186885305588 0.0137210864523 0.0193875507074 0.0459800217652 0.015147695259 0.0594631949225 0.0420406539118 0.0381002519704 0.0316288068581 0.0464453358384 0.0430647918893 0.0450678160713 0.0372936406921 0.0478953066773 0.0442824164473 0.0325191406563 0.038458833697 0.0379877190085 0.0530105166244 0.0661049064219 0.0485790002934 0.0252530768184 0.0252616659632 0.0666194586026 0.0445179442461 0.0429682351205 0.0475934680999 0.0500384221554 0.032835448251 0.0334890161181 0.0210425012042 0.0304165560005 0.0269992218058 0.0464858418191 0.0236376116141 0.0409389296383 0.0119097107153 0.0510342004912 0.0165862044563 0.0364051705359 0.0459765436849 0.0532158463913 0.0240697227805 0.0285944307415 0.0355069812685 0.0512442268801 0.0481793211849 0.0420406539118 0.0442662890139 0.05312949223 0.0494910921385 0.04499219501 0.0346009573898 0.0502278687979 0.0300299308142 0.0232712606741 0.0301762988443 0.00654363258115 0.0383536762695 0.0073760670349 0.0549696818035 0.0187358469678 0.0230006125585 0.0248620926321 0.0112006081505 0.0374302122761 0.0507791829944 0.0291552453818 0.0203658790931 0.0243768337268 0.0405838171216 0.0318523232399 0.0264398107213 0.0241549255092 0.0342108755533 0.021966370396 0.0115756992435 0.0406700397742 0.029726336077 0.0360763557135 0.0237708872008 0.0347952708329 0.0167090325333 0.0113314779127 0.0183460384347 0.0474972085699 0.0106130759732 0.0188803713912 0.0264255690706 0.0134988723184 0.025504997589 0.027405254367 0.0141844800377 0.0190580694839 0.0107985492476 0.0215712414492 0.0353201768965 0.0121413245456 0.0563908913649 0.043304104353 0.0426898087169 0.0394771848203 0.0476531796683 0.0529352282385 0.044079995111 0.0508430194559 0.0587105683651 0.0390993709526 0.0249779507582 0.042747127932 0.0380731496814 0.053623295371 0.0609715530482 0.0414798961609 0.0320700568798 0.0299307088952 0.0756552859532 0.0564187262812 0.0401315540974 0.0437426630802 0.0619393205223 0.0343990170803 0.0321000148697 0.0335451545545 0.0286757976711 0.0228629245983 0.0490706959168 0.039335399235 0.0517108395757 0.0207931533413 0.0521719534959 0.0306385429933 0.0529657791748 0.0494073245643 0.0465244230409 0.0294935309982 0.022387741137 0.033135656028 0.0474637239198 0.0404408008061 0.043304104353 0.0434045699957 0.0474449484031 0.0438694244062 0.0478136370998 0.032205230585 0.0422362620829 0.0295056722481 0.0179188644218 0.028584000913 0.0304649482776 0.0216593575612 0.0411663680687 0.024518088592 0.0182283990095 0.00873472135302 0.0327024039756 0.0205661418233 0.0530659348987 0.0158790060301 0.0434559310925 0.0108179884547 0.0451149656888 0.0268976993783 0.0108384529361 0.0115766662184 0.0275567255166 0.0316971869351 0.0249562865626 0.0177154908046 0.0178955252093 0.0182906823384 0.00749636648732 0.0477714342488 0.038203551745 0.0295629098692 0.0151014852938 0.0424264199032 0.016651504005 0.0233361298106 0.0296064297332 0.0193940010564 0.0143559792056 0.00822362335298 0.0204472045407 0.0141062231631 0.0150969431722 0.00961358010122 0.0230069897016 0.0136344497691 0.0781873312389 0.061922358127 0.0567947708263 0.0549074799203 0.0663268940474 0.0637272258979 0.0651276548535 0.0583171690756 0.0677292446726 0.060191106251 0.0450946120505 0.0568830058441 0.0543288790766 0.0714589426004 0.081454303397 0.0624243269582 0.0472314410611 0.0479124253475 0.0858307227677 0.0627914211132 0.0589518720089 0.0648453559762 0.0697319385158 0.0476614784634 0.0522209851297 0.0435983831723 0.0443141443319 0.0427834724857 0.0660408790701 0.0423473900154 0.0592034189384 0.034371623803 0.0697342027164 0.0381294864628 0.0595840773258 0.0612390496755 0.0689539919437 0.0466415215244 0.0431628346368 0.0495434525796 0.0666477691564 0.0566659496435 0.061922358127 0.062735676927 0.0682003243846 0.0612178236271 0.0603270178223 0.0499653486319 0.0649071391116 0.0500436367076 0.0339571590708 0.013301666182 0.0294613107742 0.0254168369791 0.0187830848109 0.0337456927151 0.0151760493477 0.0360233288761 0.0161149469416 0.039042024755 0.00229536147376 0.0468249873675 0.0157583667263 0.0310761119725 0.0155497505138 0.0090301180649 0.0126416375855 0.0110159110748 0.0254616235228 0.0242814349621 0.0236690592627 0.00236651040215 0.00842631126501 0.0122777482071 0.0387720000407 0.041740632348 0.0402615455592 0.013434165421 0.0259957062278 0.0279382933191 0.0176919201528 0.0210030594474 0.0190515742522 0.00605687883869 0.0125440326934 0.0183812478057 0.0234838433483 0.0213287295776 0.0102611349583 0.0367608397052 0.018305882063 0.0762459812633 0.0565232340764 0.0480647092458 0.0470080033305 0.0607210126742 0.0515562009886 0.0623134210102 0.0445281266442 0.0542656274802 0.0589172543408 0.0450145677229 0.0482495838943 0.0484339717661 0.0652417317109 0.0793204584838 0.0620264746962 0.0400173133601 0.0433798691859 0.0725797896424 0.0481813389954 0.055284998644 0.0628522019597 0.0554630904838 0.0404443368976 0.0493602212467 0.0332419109523 0.0398075629785 0.0413677301877 0.0589057964055 0.0278286603835 0.0454781228443 0.029186418008 0.0632373035893 0.027173160002 0.0466041993476 0.0516248397682 0.0694549695494 0.0414073101396 0.0429302830553 0.0451579600752 0.0633364240737 0.0552241510377 0.0565232340764 0.0584051969715 0.0667610558404 0.0584355181495 0.0512925402879 0.046128531904 0.0664605075068 0.0478081299752 0.0403784266437 0.00849189377523 0.0578244327435 0.0213782060591 0.0260735654855 0.0286868543518 0.0107633182991 0.0429130184438 0.049112317265 0.0332704837119 0.015321761445 0.0277153223765 0.0397499694056 0.0358925712782 0.0304111104426 0.027505083584 0.0362377250231 0.020296537393 0.0117771620381 0.0454349567531 0.033203078919 0.0404550655622 0.028050968973 0.0329121522515 0.0157822820327 0.0128529655968 0.0212960295437 0.0481179953609 0.0170390332384 0.0197624290813 0.029414246654 0.0176689832365 0.0290804953813 0.0317312604538 0.0173770193477 0.0255273516204 0.0167054579942 0.0259572392414 0.0381174742782 0.0168503391466 0.0510138836142 0.0385473731826 0.0388016187658 0.0368178557203 0.04276997017 0.0503778656709 0.0392641023806 0.0497809957465 0.0564266766196 0.0332095636962 0.0188695135337 0.0387787813789 0.0331502464834 0.0483979502244 0.0548055143427 0.035228159998 0.0294466884888 0.0272290139414 0.0724784935896 0.0548011964122 0.0344489111929 0.0380672364964 0.060026483594 0.0303284751736 0.0272545178904 0.0327801045139 0.0239410636139 0.0177611799925 0.0444007657806 0.0400513163792 0.0497786040376 0.0204852863736 0.0470867569115 0.0308376722615 0.0532970554221 0.0452748414675 0.0407821021663 0.0268849282918 0.0168086928609 0.0279020988959 0.0414910752652 0.0343097482389 0.0385473731826 0.0381367753126 0.0413101510581 0.0377465227401 0.0435171810289 0.0268955341281 0.0365057689544 0.0254190380854 0.0372013435687 0.018490846954 0.023945912793 0.0440067159299 0.0253810829497 0.0423576975539 0.0266775910883 0.0276067076791 0.0155964706338 0.0512008225103 0.0249293141549 0.0224091031216 0.0208182862063 0.0201027144741 0.0218258381078 0.00416795120123 0.0250523436876 0.0291897433081 0.0336104473732 0.0126474260294 0.0179897427224 0.0236687976248 0.0357767564718 0.0479080621505 0.0493839683144 0.0213027411218 0.0127962715487 0.0389577422313 0.0207982711984 0.0248766740175 0.0272195414617 0.0164396805465 0.0239043019084 0.0253433507519 0.0357454256498 0.0316012688091 0.0218891275488 0.046006369731 0.0279699723289 0.0753592714385 0.0538300830176 0.0427234551893 0.0442120918411 0.0575724115573 0.0438794711912 0.0617203772126 0.0368175055007 0.0452394206226 0.0586608041232 0.0462735571883 0.0428932945735 0.0449361857949 0.0608531076963 0.0771129194067 0.0618336393757 0.0380658785095 0.0436894906412 0.0627047512052 0.0382553066725 0.0531191059331 0.0620656917263 0.0459127944105 0.0362899248016 0.0492167826913 0.0301637294202 0.0380460619309 0.0426550687382 0.0544072702012 0.0218332584664 0.0362322493618 0.031226533309 0.0587827461321 0.024852970378 0.0417700516252 0.0442659791406 0.0702283886386 0.0412678777108 0.0447863140602 0.0428258891548 0.0608093994885 0.0534400200237 0.0538300830176 0.0561072465285 0.0656581075266 0.0558523559264 0.0444818994194 0.044500683531 0.0680831562837 0.0488303143353 0.0536500814259 0.0217777943298 0.0182308184172 0.0213271967089 0.017640751735 0.0384313065823 0.0491331799987 0.0285490579199 0.0236508921207 0.0203518801552 0.0410544418794 0.0345949638149 0.024163451076 0.0208164937907 0.0331698057229 0.0214370208347 0.0129093004816 0.0378630437774 0.0285080143021 0.0349561724295 0.0213643314537 0.0378207671811 0.023156173716 0.0144257922467 0.0164328495191 0.0458898771597 0.0137078716838 0.0180512548912 0.0303444429836 0.0166949845236 0.0239375979831 0.0248141920509 0.0164642247089 0.0221495310709 0.0136759772653 0.0203492925476 0.0297801495496 0.012327304817 0.0589145352863 0.0454329273476 0.0436909431618 0.0429329583507 0.0496681092117 0.0546717056664 0.0472190839202 0.0531335572006 0.0601545762173 0.0404993410456 0.025351107679 0.0436326686228 0.0384109589864 0.0546942484238 0.0614849395874 0.0420121432296 0.0350678306139 0.034181943564 0.076607832627 0.0574938051354 0.0407284888751 0.0455392391661 0.0634559846389 0.0340449392101 0.0346886110004 0.0365094436091 0.0283668149646 0.0247441178114 0.0505723350307 0.0414268809452 0.0526572068528 0.0247442404176 0.0533283030157 0.0333480302269 0.0569330422551 0.0488445949836 0.0485166318417 0.0334202567015 0.0241088713298 0.0327605074387 0.0477602460683 0.037977730422 0.0454329273476 0.0450703466816 0.0481686005759 0.0425586735361 0.0473020173719 0.0326189496433 0.0442268465034 0.033265894657 0.0406164099076 0.0563656658624 0.0369501005762 0.0596090654503 0.0304778147307 0.0384204581231 0.0270915625525 0.0693260105947 0.0372136698768 0.037023479673 0.0317062741776 0.0317712182279 0.034804368211 0.0223060266021 0.0435100417127 0.047004084469 0.0362329082931 0.0256397756303 0.0233719185841 0.035627421568 0.0521858971919 0.0650552610656 0.0654396577163 0.0372909018916 0.0208395075735 0.0532980934411 0.0387978654626 0.0393043110859 0.0433091405548 0.0302415541747 0.0340064333643 0.0421117035102 0.0478257550421 0.0466283489206 0.035247716101 0.054937797688 0.0434605477125 0.0930034854114 0.0710598303107 0.0590352084097 0.0604460830393 0.0745555173324 0.0571183440581 0.0793617023165 0.0484952151811 0.0566053521726 0.0768259736839 0.0646780127707 0.0592344115045 0.0623544010763 0.0773513341111 0.0945306112415 0.0799933849368 0.0552426925494 0.0610368934489 0.0726391747026 0.0486086004123 0.0708765879781 0.0800292786375 0.0558578611463 0.0537011940437 0.0672777153371 0.0461852109805 0.0561622363977 0.0610513630375 0.0708198771797 0.0350965268909 0.0484124521051 0.0486964562823 0.075256407672 0.04111323881 0.0515712020719 0.0592740141065 0.0884497661149 0.0586350703024 0.0632023881374 0.0606979638812 0.078320587954 0.0707259147977 0.0710598303107 0.0736338137855 0.0835800603427 0.0732101393079 0.0599496433571 0.0625510181289 0.0864139348042 0.0667637091982 0.0350728110176 0.0244007367668 0.0194418255357 0.0278046770383 0.0387260088041 0.0187288873365 0.0305873095592 0.0241694671072 0.0257451620145 0.0153815378858 0.021353060898 0.0215496497445 0.0200984831417 0.0151985245998 0.0110228413253 0.0387908454863 0.0190085239065 0.026530841158 0.0213969993651 0.0238500818663 0.0245406806879 0.0294364678495 0.0140120927131 0.0331219747793 0.0211978333105 0.0108265764026 0.00897607251111 0.00677241917437 0.0173770286262 0.0245814114194 0.00563326172159 0.0204952689406 0.0138047466575 0.0168569359655 0.0438273371107 0.0133334601758 0.0592456323654 0.0408071286879 0.0355509485261 0.031081872872 0.0452073820968 0.0410054777303 0.04495248578 0.0356498623047 0.0456510923283 0.0431383529174 0.0306345228853 0.0358468154266 0.0353265194622 0.0511623196634 0.0646276367384 0.0471382277373 0.0240229200194 0.0254553208119 0.0642596486532 0.0418982548195 0.0409421092482 0.0466753277343 0.0478887558589 0.0293373407147 0.0326161841904 0.0195735225778 0.0272641873276 0.0254981680323 0.0447040552558 0.0215611560931 0.0381253844376 0.0111199895155 0.0491745036263 0.0145691145727 0.0368088577033 0.0425091408325 0.0528722213324 0.0238501784613 0.0272505069941 0.0325614342759 0.0492627638247 0.0449950723976 0.0408071286879 0.042880253884 0.0517160325388 0.0466599102029 0.0415966376912 0.0321745745193 0.0499813496989 0.030016506883 0.0195067443548 0.034042657808 0.0387050626348 0.0607833234632 0.0322025711177 0.0402462250605 0.019510297358 0.0548235012014 0.0429595771314 0.0252279466187 0.0223273919125 0.0407231129516 0.0368354815518 0.0293953937656 0.0290463736365 0.0328461116776 0.035143771121 0.0215923461726 0.0549385181088 0.0388660143681 0.023623079783 0.0246479181765 0.0539903453268 0.0196033552608 0.0309786977565 0.0425462811063 0.0289476729073 0.0283702078661 0.0228452205014 0.0295421719187 0.0252210967901 0.0230772437036 0.0240590413191 0.0135013916275 0.0218148808282 0.0760114892469 0.0634029220478 0.0607879784498 0.0607163777171 0.0675569624906 0.0711706523576 0.0650651993965 0.0685468614076 0.0760185520266 0.0575507664821 0.0425210776149 0.0606855343213 0.0555229333703 0.0720565340813 0.0774071503121 0.0581416488422 0.0527363337967 0.0521637490438 0.0926239124524 0.0722776295267 0.0578783465588 0.0627903946651 0.0789206671037 0.0503951188312 0.0527646858335 0.0526096570134 0.04527903594 0.0427992547678 0.0682205850017 0.0547141937568 0.067807383273 0.0414244261778 0.0707718291801 0.0483573376556 0.0717861683592 0.0644987372167 0.0647006499463 0.0513517515126 0.0419564687506 0.0495341433982 0.064364362053 0.0518587226049 0.0634029220478 0.0627776825589 0.0645131806296 0.0578143875392 0.0631581345522 0.0499505499876 0.0600491597535 0.0513712453732 0.034450057717 0.0238219725869 0.0465207238958 0.0139550218762 0.0437148052069 0.00245848843359 0.0406705408218 0.027996084796 0.00617634742576 0.0042140797155 0.0226171443798 0.0276920922451 0.023535776763 0.0178395839466 0.0140356715542 0.0166022608919 0.00395476408572 0.0457707350729 0.0404789526881 0.0327219703849 0.0114454148489 0.0362680793242 0.0217463268752 0.0196365744138 0.030477863462 0.0206103562172 0.0102714385383 0.00460445870022 0.0203218526125 0.0212018784388 0.0183586998171 0.00829854248447 0.0218572079865 0.0144443422105 0.0767877803745 0.0594466868469 0.0529468255635 0.0532520366965 0.0637146030163 0.0600960587419 0.0639510014921 0.0553587219012 0.0637257572972 0.0581054381403 0.0427611569751 0.0529559974475 0.050488809742 0.0679805704334 0.0784814462329 0.0599903091584 0.0453120703317 0.0472956572051 0.081207762841 0.0585100350392 0.0557351056658 0.0628545029747 0.0657746195642 0.0431635890019 0.0505766161122 0.0416755044323 0.0404647152471 0.0409948112567 0.0627553433594 0.0398795409571 0.0548556307871 0.0337749376373 0.0662751646447 0.0362650420971 0.058753352182 0.0559719307576 0.0677796526261 0.0456851568449 0.0415580901724 0.0455930571155 0.0632638085815 0.0519953365762 0.0594466868469 0.0601182129397 0.0655928087235 0.0568949371894 0.0552051980285 0.0466604473635 0.0640269526764 0.0493532376221 0.0428114080859 0.0513187599237 0.0353300715155 0.0136841990953 0.0339659047401 0.0392151216672 0.0331598693815 0.0346578423583 0.0330024342773 0.038276947888 0.0230224626975 0.0145213724276 0.0501490398304 0.0358866478447 0.0428680377048 0.0326728263648 0.0285835471973 0.0062386073831 0.0158573158736 0.0257280664001 0.0503050577684 0.0188536314021 0.0230369129683 0.0250256284162 0.0171680840121 0.0324912467925 0.0363869094834 0.0177612063031 0.0250245943265 0.0179627656197 0.0294197347692 0.0465091219099 0.0203095862842 0.0478795030574 0.0357982238192 0.0376241763265 0.0315623347361 0.0401002610089 0.0474897864671 0.0350582543035 0.0460362585126 0.0538318698513 0.0325365856585 0.0213227378076 0.0377990397126 0.0335693240845 0.0471274543161 0.054885621667 0.0360897261843 0.0253548565171 0.0209548211511 0.0704293001167 0.0527939534511 0.0346935966786 0.0364130601336 0.0572327947958 0.0318390512051 0.0244040617426 0.0286768378156 0.0261566126157 0.0173773142125 0.0423900706098 0.037171182215 0.0481110975007 0.0159454061909 0.0456669379702 0.0274665151098 0.0469607798152 0.0462908705234 0.039158298024 0.0212460794033 0.0171141394847 0.0299475002492 0.0420369583583 0.0395076063195 0.0357982238192 0.0363456286371 0.0414629362584 0.0409765644808 0.0445581081298 0.027819794971 0.035217696192 0.0204081888775 0.0536229831874 0.0147412411033 0.0555896434003 0.0257773616784 0.0440411962897 0.0177255540439 0.0193829905731 0.0239978426404 0.0256940264499 0.0393410530504 0.0352411367288 0.0221731284836 0.0182277280594 0.0123391761488 0.020654487001 0.0493059373458 0.0475681206642 0.0451873269558 0.025880190654 0.0390288508413 0.0309214453223 0.0313196281309 0.0264802426158 0.0266703711652 0.0198006836859 0.019520741807 0.0278514155812 0.0221034761072 0.026690732588 0.0196134707881 0.0412756734602 0.0265178671443 0.0867397306197 0.0682110021203 0.0611304199736 0.0570363597121 0.0725160802101 0.0632079822129 0.072465417084 0.0544582268199 0.0658094706322 0.0704919404627 0.0569226677141 0.0614294730407 0.0618668588016 0.0780403185985 0.0918397178914 0.0740264863472 0.0508436174709 0.0525989509117 0.0847012354501 0.0597190404435 0.0681089165817 0.0742388101657 0.0664380426823 0.0545769816583 0.0603124830305 0.0434291774759 0.0533790593767 0.0526730162139 0.07136820435 0.037381607524 0.0577096830472 0.0386410478706 0.0759869972218 0.0373998132392 0.052181569916 0.0660810261842 0.0798969360666 0.0510826914494 0.0540234946407 0.0588039304452 0.0763291167757 0.0694007087698 0.0682110021203 0.0704124305268 0.0789271737863 0.0724038719993 0.0657040131714 0.0590995697111 0.0765722724394 0.0574793382897 0.0411299322154 0.0539204969946 0.0448971315706 0.0161163886115 0.0424587591617 0.0433134103038 0.0424269061508 0.0282464178608 0.029088245744 0.0394507490162 0.0585960215177 0.0377541724349 0.0451043153526 0.0458829699472 0.0321616028135 0.0557124503126 0.0614547711288 0.0392057260171 0.0177559051904 0.0564954090624 0.0332181102648 0.0405454141429 0.0436595776199 0.0393478274847 0.0472383546112 0.0407140770645 0.0569892712332 0.049354627832 0.0439022116296 0.0637553975882 0.0455099918129 0.0646100490562 0.0426539647843 0.028431151743 0.0378227253234 0.0447657124399 0.0278050988657 0.0537117960824 0.0274550112394 0.027109787916 0.0505464931112 0.0435971104256 0.0283504838988 0.0329648689469 0.0443909167392 0.0625701957077 0.0530229796398 0.0343871989004 0.0426240079793 0.0396498771349 0.0213457948378 0.0419360502864 0.0525916757896 0.0283713421426 0.0258314536376 0.0439902997437 0.0303827915475 0.0319578433558 0.0415135400801 0.039276736137 0.0267873256159 0.0192565547583 0.03784586336 0.0425882783228 0.0300770949457 0.0411024644378 0.0235206108502 0.0627241786637 0.0400442811976 0.0439864971889 0.0336917004451 0.0474026229045 0.0427127785344 0.0426539647843 0.0447428873557 0.0545498150062 0.042821329639 0.024917555179 0.03656154349 0.0624685036836 0.0466134489709 0.0464211898017 0.0148261628982 0.0328892390973 0.0156382282878 0.00785541359441 0.0118772597644 0.013233811524 0.0262299374219 0.024092235964 0.0223052815816 0.00384479195153 0.00794260597132 0.0107672255318 0.0397240757159 0.0410257993957 0.038935751255 0.0130110302225 0.0282819504394 0.0262547979726 0.0181226466418 0.0211289335782 0.0182692961983 0.00567846812613 0.0110316054291 0.0179271098732 0.0214946645806 0.0199268176637 0.00875561948865 0.0354271933282 0.0171443662393 0.0766374045646 0.0572939392451 0.0492966948245 0.0478544225205 0.061544844174 0.0531089657897 0.0627070970919 0.0461191081801 0.0559975469422 0.0592703107177 0.045198111152 0.0494826907565 0.0493817865713 0.0662451441692 0.0799247658409 0.0623534855885 0.040791427856 0.0437433118438 0.0743922416686 0.0500539193261 0.0559768175635 0.0632764008918 0.057263588801 0.0415573436738 0.0497522962913 0.0342757495228 0.040553840562 0.0415809282216 0.0599519771943 0.0293556022635 0.0472716928172 0.029440558171 0.0642586667075 0.0282006776448 0.047766217977 0.0531327322745 0.069584244341 0.041867047458 0.0430265316703 0.045945636772 0.0640480645613 0.0558532996544 0.0572939392451 0.0591020248311 0.0672221887664 0.0591786574244 0.0527229760336 0.0467939943149 0.066452337221 0.048010057481 0.0426662887331 0.0439949614302 0.0453715955589 0.0447907897725 0.0421151539334 0.0471958607455 0.0276193449237 0.02275846799 0.0605343055308 0.046215555164 0.0540603153716 0.0428037480825 0.0313795261955 0.0125172459763 0.0208290281635 0.0350621941996 0.0569552641601 0.0299458792012 0.0309610087229 0.0366049420462 0.0292005950568 0.0426658539169 0.046550389751 0.0288402250941 0.037809939324 0.0299619998536 0.0401350153602 0.0525912191682 0.0310232912468 0.0370292782789 0.029362531619 0.0351405044644 0.0315813022426 0.0330583005053 0.0477931213785 0.0264557013575 0.0497838425895 0.0546676669155 0.0214340498054 0.0132666230167 0.0351245595911 0.0284887636401 0.0394555006358 0.0430107543153 0.024001610215 0.0265746605534 0.0212961513987 0.0686985381679 0.055308045978 0.0261438582005 0.0256904480148 0.0588231449389 0.030013743601 0.0177237336601 0.0340579413817 0.023239083403 0.0129096702298 0.0366510262704 0.0448114548715 0.0501265325324 0.0238298010541 0.0385248366721 0.0348349791307 0.0531258509004 0.0432244806886 0.0265717263897 0.0222990802833 0.0105547424712 0.0247433535936 0.0319856839059 0.0308056274733 0.029362531619 0.0282110860995 0.0297242114734 0.0317000113527 0.0411003820059 0.0219347750579 0.022168792283 0.0155469808263 0.0395024062804 0.0287670845389 0.00713435108734 0.00340555052012 0.0220748170877 0.0261325674803 0.0225086838709 0.0197301659136 0.0143163055062 0.0179547860371 0.00552830002832 0.044759241534 0.0400746442935 0.0324889323762 0.0105741309237 0.0352991764051 0.0223168808509 0.0183878728912 0.0306904112299 0.0206021475442 0.0104104939928 0.00670538845305 0.0199820984844 0.0226302237702 0.0187233601872 0.00907856174289 0.0219615297998 0.0143637742128 0.0753337380263 0.0579434032885 0.0513377916805 0.0521965044751 0.0621695045027 0.0588078748161 0.0626419440897 0.0544695113035 0.0624620281749 0.0565017669041 0.0411290585403 0.0513195597187 0.0487054775012 0.0662358469866 0.0766400648909 0.0582604755345 0.0441853596565 0.0463597810918 0.0797172873623 0.0573362873289 0.0539615186802 0.0612879452506 0.064613107429 0.0413483548752 0.0492060616579 0.0408536005927 0.0386658835072 0.0395835329499 0.0611338973657 0.0393645393569 0.053572584104 0.0330686361703 0.0645571164168 0.0355933171917 0.0584689678276 0.0540828717859 0.066313152361 0.0447064134304 0.0401381607957 0.0437269026711 0.0614075519202 0.0498319714223 0.0579434032885 0.0585128670581 0.0638402708268 0.0548281142484 0.0533071471302 0.0449195692472 0.0626153729552 0.0482343239424 0.0295703841711 0.0366619395227 0.036500768924 0.0216100790796 0.0202086133386 0.0291081498137 0.0538445159183 0.0304641791012 0.0384602037434 0.0388505887816 0.0184939827468 0.0431509831641 0.0514497599393 0.0311190761962 0.0193480902941 0.0458820296239 0.0240997287473 0.0258856149523 0.0318135695083 0.0318488388141 0.0408906139312 0.0292269134036 0.0455476970026 0.0384416242221 0.0355459730354 0.0604270677753 0.0357756191383 0.0579552498509 0.0353240752803 0.0225716123758 0.0257247517645 0.0383804782921 0.0215488097029 0.044948702922 0.0168022708851 0.0235401078242 0.0440963094143 0.0364932029322 0.0228797040221 0.0280879909327 0.0410984380147 0.0600604954457 0.0480533666552 0.0218775898923 0.029791578282 0.04158778439 0.0178882014032 0.0370867411707 0.0460836281119 0.0252155578724 0.0208740877353 0.0346851323104 0.0150019768994 0.0257835645737 0.0322493089661 0.0342156649906 0.0116183721538 0.0144931943243 0.0240188836176 0.0389068297986 0.0144502424291 0.0276541092905 0.0250061652639 0.0558771163058 0.0271661677907 0.0351271284352 0.0289684152137 0.0442230773604 0.0424650907505 0.0353240752803 0.0384614305736 0.0501641618566 0.0418657156844 0.0254781137454 0.0303709238998 0.055175185082 0.0355533707256 0.0226236551837 0.0257243733887 0.0188708962976 0.0280458447088 0.0259495603965 0.0358126700891 0.0173972925493 0.0203550537734 0.0241984077655 0.0326658712857 0.0374251933899 0.0415458358848 0.0220997016335 0.0314739029711 0.0297599572502 0.0224642058136 0.0101652715813 0.0184552115135 0.0190795074292 0.0255522841638 0.0188568594492 0.0233889500734 0.0229626929389 0.0201746110209 0.0490887418108 0.0229752614583 0.0721999639917 0.0528489482775 0.0457665690796 0.0402580156331 0.0570067559398 0.0466251225309 0.0575932728503 0.0376765605581 0.0495760090258 0.0573857799099 0.0457294834507 0.0461836275015 0.0478961825174 0.0628300939828 0.0782978077723 0.0617431168606 0.0349090738753 0.0372003973766 0.0687801137491 0.0442160827041 0.0545072221083 0.0604041835816 0.0503536267186 0.0412302683921 0.0462335606677 0.0265634879228 0.0409252862943 0.0403112510912 0.055713517152 0.0210444978159 0.042126696634 0.0241765196843 0.060672423249 0.020816933598 0.0350778856202 0.052005350197 0.067095717986 0.0355534496705 0.0422916670752 0.0461036815572 0.0628103650139 0.0591144676161 0.0528489482775 0.055715116829 0.0658580956838 0.0605104799512 0.0516473901424 0.0459913703308 0.0644951804376 0.0433395766961 0.00476396676703 0.0174479971383 0.0262117873028 0.0230803954362 0.0185627883328 0.00806620839217 0.0113814933623 0.00390319674762 0.0428177321428 0.0406615445683 0.0354624532828 0.0102263088249 0.0317971018832 0.0234656694869 0.0177926588758 0.0262276626577 0.0188776295133 0.00499606040594 0.00424685036617 0.0184558479833 0.02090066744 0.0184013332257 0.00554993882929 0.0277916235291 0.0146255258466 0.0766584518429 0.0582536091399 0.0509151171955 0.0506702158494 0.0625265075224 0.0566765790267 0.063296553303 0.0510181236531 0.0599592936046 0.0584198089247 0.0435074153396 0.0509940717271 0.0495661398107 0.0669266401341 0.0789376730305 0.0608280979649 0.0430167703447 0.0455496571569 0.0778333721022 0.054368608181 0.0555188693765 0.0628704456678 0.0616793859568 0.0418722056261 0.0499801315934 0.0381178178645 0.0399704213931 0.0409195428074 0.0612188756554 0.0349680364553 0.0510653686933 0.0315069690942 0.065089713199 0.0323745393338 0.0538917621299 0.0541667478451 0.0685063182149 0.0437802642661 0.0419063387522 0.0452698567868 0.063322234724 0.0532615551019 0.0582536091399 0.0594215850469 0.0661130238288 0.0575059193505 0.0535703049783 0.046311202915 0.0650382074097 0.0485914933238 0.018842155525 0.0240370427448 0.0209528738511 0.0208089534878 0.0111203801188 0.015917150662 0.00453488271341 0.0421322819802 0.0391458330884 0.0331083714381 0.00824403626512 0.0325132311882 0.0224847085725 0.015999516676 0.0277730715816 0.0186363801442 0.00708833477439 0.00642676690132 0.0178233234532 0.0220593051536 0.0178006297585 0.00678573265748 0.0253531080362 0.0132629896024 0.0741187095157 0.0561450172019 0.0491350925935 0.0497514221438 0.060382347286 0.0560370322524 0.0611402268324 0.051356658754 0.059586423134 0.0554899035837 0.04031824984 0.0491508161478 0.0470289167752 0.0645318276086 0.0757421493114 0.057544117742 0.0418388253062 0.0443100927117 0.0770487593095 0.0543425693403 0.0526585588221 0.0601234502371 0.0616298008584 0.039475560154 0.0476974484773 0.0379820027229 0.0371681460661 0.0383173623723 0.0591794106435 0.0360653613059 0.0506856040282 0.0307481929538 0.0627839311984 0.0325910275487 0.055237903563 0.0520576344331 0.0655568890209 0.042566036842 0.0391094232808 0.0423459347432 0.0602723002528 0.0493981873195 0.0561450172019 0.0569656980973 0.0629553672806 0.0540102942581 0.0513493159685 0.0435185067862 0.0620208318713 0.0466647868495 0.0214518595921 0.0250574648372 0.0327035392179 0.0101396500324 0.0173409936704 0.0207342919251 0.0332931627481 0.0438902497615 0.0452760516117 0.0173962021214 0.0155474932413 0.035097178823 0.0167075078514 0.0219356609327 0.0232161362242 0.0132718217012 0.0215035441799 0.0212520758854 0.0323731403418 0.0276797560909 0.0185474301296 0.0436301136913 0.0240030156204 0.0722858985812 0.0511085237891 0.0406650357841 0.0417405611462 0.0549851372416 0.0429543701734 0.0585838550979 0.0363293620395 0.0449605458738 0.0553495140321 0.0426335340052 0.0408304262584 0.0422933209142 0.0585800490211 0.0742997883793 0.058525226517 0.035206446299 0.0404435198283 0.0627381786217 0.038449263747 0.0501920171677 0.058888502058 0.0460241869732 0.0337463818569 0.0458812434451 0.0278046680998 0.0349131438742 0.0389869853015 0.0521722266345 0.0209043609517 0.0359181281747 0.0276204608178 0.056526179998 0.0222941226577 0.041152359144 0.0428797366789 0.0667722352073 0.0380782189511 0.0410414680557 0.0398735425148 0.0580112990116 0.0505852294836 0.0511085237891 0.0532571789631 0.0625496034306 0.0531021220011 0.042888351609 0.0413906647006 0.0644729984699 0.0453457651066 0.0107504885543 0.0445819304752 0.0242663168605 0.0336280858548 0.0265479358211 0.0206001571473 0.0282052030653 0.0325495864256 0.0168933846577 0.0294835383052 0.0291726320507 0.0086711740192 0.0221542204142 0.0179304565478 0.022368606911 0.0297212987281 0.0149126627655 0.0323363820236 0.0229519593576 0.0235384954017 0.0445361789109 0.0198724736323 0.0521573964273 0.0325036248406 0.025391360945 0.0274230805005 0.0366454630316 0.0344942582431 0.0390192491133 0.0331598239249 0.0393605141281 0.0342759827638 0.021260474927 0.0254073365966 0.0234580906639 0.0407813070352 0.054069225305 0.037293221414 0.0193616327469 0.0235535155332 0.0561408138747 0.0363119747552 0.0299684113953 0.0382284111131 0.0425406057591 0.0161350959097 0.0256650379468 0.0189027762255 0.0143744986934 0.0179840539103 0.0351859317755 0.0236434364907 0.0314452790447 0.0139598707264 0.0389431870684 0.016485382228 0.040355084472 0.0299825744277 0.0456481354326 0.0213868007101 0.0199817088813 0.0197684998025 0.0379808456048 0.0313521152981 0.0325036248406 0.0336827412775 0.0416843797906 0.0334784161986 0.0289224474022 0.0207816321212 0.0432746333929 0.0259935830061 0.0406061367838 0.0235468720047 0.0318323205013 0.0219961670771 0.0255808203638 0.0205571609912 0.0226267329863 0.013012280745 0.0369778751619 0.0187789289183 0.00874641080149 0.0197571101094 0.00977736627462 0.0202312308031 0.0257037864622 0.00771970434192 0.0231557657352 0.0133099999073 0.0187324692629 0.0392432332024 0.0115155558073 0.0539655210169 0.0370438046358 0.0333786958054 0.0316409822149 0.0414621149977 0.0426991016561 0.0406517401284 0.0403678402162 0.0480644681966 0.0361424947464 0.0218113942904 0.0334641673727 0.0302365918541 0.0468956611505 0.0577004528593 0.0391757625612 0.0236163775334 0.0242576354959 0.0653230280715 0.0452817250312 0.0345762397733 0.0404850805623 0.0511603238121 0.024886725311 0.0274569982987 0.0236904007661 0.0206352481789 0.0182697542476 0.041544522984 0.0289437440201 0.0406091261712 0.0126309522282 0.0451825068417 0.020490830418 0.0442568377481 0.0395946754396 0.0458654268305 0.0228937718071 0.0192636370802 0.0258703030154 0.0425840964507 0.0360074541747 0.0370438046358 0.0378930233244 0.0444471390747 0.0387351356827 0.0382610925586 0.0256300024801 0.0425154846229 0.0258478343265 0.0236633695184 0.0174990292841 0.0186530571476 0.0611247172591 0.0557656094279 0.0466088592976 0.0282320418304 0.0445464770565 0.0341524834412 0.0362512556468 0.0421364706395 0.0353354631726 0.0231187500774 0.0150626098763 0.0358189243099 0.0298015850374 0.0324439491366 0.0223980477721 0.0244141427415 0.0302418773665 0.0942328467355 0.076594072426 0.0693014297828 0.0689934026371 0.0808708035071 0.0745545238332 0.0811424703773 0.0680895982601 0.0772898278285 0.0757784502044 0.0604959493699 0.069358828284 0.0677179794145 0.0851546659241 0.0961465377952 0.0777040409423 0.0614342341624 0.0635105029946 0.0949910709403 0.0710640834394 0.0733442971825 0.0804630717269 0.0785569975811 0.0599979412685 0.0679000809486 0.0561320615274 0.0579270123928 0.0585056430456 0.0796324819571 0.0514612322157 0.068283919556 0.0494122791964 0.083373938553 0.0501855689957 0.06973964597 0.0718399524308 0.0852557355766 0.0618964253913 0.0591154896454 0.0630863991576 0.0809010142666 0.069276699042 0.076594072426 0.0775503896407 0.0833112406891 0.0743754315619 0.0713482849075 0.0642332894623 0.0813844341388 0.0662752735857 0.00943572253542 0.0115403490897 0.0385513754293 0.041736873589 0.0399182937318 0.0122452242861 0.025058464158 0.0280391379811 0.0165428935252 0.0220426648475 0.0191966494038 0.00476868066193 0.0119136882752 0.0182274158907 0.024378991238 0.0214350053307 0.00987681971674 0.0356319079498 0.0179231346829 0.0755450486118 0.0557883449648 0.0471764532756 0.0467952668235 0.0599617395979 0.0511011457957 0.0617632501287 0.0445144536833 0.0538325742859 0.0579584947727 0.0439095831377 0.0473266714409 0.047305404175 0.0642647315012 0.0781620294368 0.0608980895696 0.0396397814207 0.0431908772896 0.0719383279912 0.0477762451878 0.0541744509705 0.0619776318533 0.0551486398926 0.0392023772277 0.0486708484659 0.0332061436773 0.0385651962783 0.0405238673503 0.0580675371179 0.0281169946403 0.0449308552075 0.0290979509914 0.0622896414172 0.0272386507233 0.0473564201885 0.0503681043652 0.0686223309305 0.0411717919112 0.0420509879955 0.0438795889294 0.0621492769732 0.0535535915584 0.0557883449648 0.0575324110618 0.0656578520536 0.0569417414102 0.0500298962763 0.0450037013757 0.0656341911967 0.0473715492692 0.0144468889514 0.0470085725986 0.0485138320241 0.0451352115307 0.0199583230651 0.0301372822106 0.0318368515531 0.0256571286264 0.0278614622113 0.0258405224944 0.0121251490044 0.0124421067497 0.0257425497103 0.0259848999587 0.0265128839547 0.0147071440313 0.0356921243154 0.0239599037157 0.0844599977072 0.0649098127865 0.0563152793656 0.0552526867175 0.0691043038035 0.0592804769565 0.0705635348052 0.0516880380121 0.0615515055365 0.0669939251635 0.0527850317966 0.0564919445965 0.0566781222463 0.0735436571696 0.0873943668972 0.0699246931044 0.0483722118201 0.0515510652048 0.079719756552 0.0550353446586 0.0634817595673 0.0710367571435 0.0623974106591 0.0485852577555 0.0576004808055 0.0413084590066 0.0479219849808 0.0493882028299 0.0672450344951 0.0348287223508 0.0527462211198 0.037276801135 0.071549415301 0.0351894067592 0.0529630080357 0.0594111357934 0.0773657257414 0.0496448829109 0.0507905960575 0.0532464315334 0.0714643731585 0.0625646663061 0.0649098127865 0.0667401518449 0.0748051995393 0.0661923309263 0.0591726016457 0.0543093310288 0.074196762744 0.0559244370052 0.043526425057 0.0386335179446 0.0321768451862 0.00974615024856 0.0352347635745 0.0201959159339 0.0180776754132 0.0269400303578 0.0177526168011 0.0076128290146 0.00378003726334 0.0176983136317 0.0184021944475 0.015957334363 0.00467338620778 0.0252008449064 0.0123712673884 0.075769333126 0.0581585948517 0.051685391535 0.0510927438975 0.0624824329901 0.058237684953 0.0625760535583 0.0529652916573 0.0618856654756 0.0574514448673 0.0423317456956 0.0517508019275 0.0497149058646 0.0670867680773 0.0782168275888 0.0597219475669 0.0433096265158 0.0451925797267 0.0797528207091 0.0566461202307 0.0551309318768 0.0620350591031 0.0638200944876 0.0424059873805 0.0493045876457 0.0391604065434 0.0398454975082 0.039967724192 0.0615633801452 0.0371201263022 0.0531118088353 0.0313373664803 0.0653089870936 0.0335830893361 0.0556009421638 0.055317918307 0.0671296861942 0.0435900410315 0.0407047621897 0.0451219309698 0.062876852421 0.0526327547566 0.0581585948517 0.0591116735406 0.0652217833265 0.0570769673892 0.0545681643866 0.0459758175248 0.0634453480612 0.0477419996054 0.0302678050916 0.043643410877 0.0344015081898 0.0370220423378 0.041870658286 0.0264826423168 0.0239447061259 0.0294219290852 0.0381639993795 0.046622906961 0.0276160450358 0.0433656713185 0.0358877725536 0.0394027280044 0.0640596529703 0.0352660320463 0.0428200645336 0.0215929365207 0.0157178006612 0.00848045847957 0.0252717757761 0.0193974269851 0.0287059984697 0.018482386953 0.0255997786212 0.0310533244304 0.0267766622161 0.0163561213819 0.0202134806234 0.03120585866 0.04895305148 0.036414957876 0.00526673250197 0.012342309222 0.0430330254803 0.0254800237585 0.0266262246906 0.032239986602 0.0289090953163 0.0180202124552 0.0199181330431 0.00657470209208 0.019948180111 0.0209059906389 0.0237059104211 0.0188029876251 0.0211536929916 0.0148162018356 0.0289733910382 0.0123381921604 0.0242362829274 0.0258181102869 0.0413288399769 0.0100525363381 0.0238857865216 0.0223322555234 0.0341921837249 0.0380927560603 0.0215929365207 0.0255329039423 0.0383043472154 0.0356000313746 0.0249953874006 0.0211460552822 0.0407734262534 0.0193178864072 0.0180029141367 0.0318989553395 0.055546862882 0.0233316606029 0.0289827460324 0.0288090712213 0.0227692137274 0.0384790428766 0.0423072029606 0.0235668927239 0.02923399269 0.0234314824709 0.0353361736228 0.0517306479462 0.0262806947106 0.0449202216804 0.0352666691701 0.0392752718621 0.0317034826189 0.0393329164331 0.0490036652351 0.0325915526781 0.0480657848217 0.0556144972514 0.0314856186317 0.0229568301755 0.0394863344353 0.0351981784458 0.0468732286627 0.0534614036052 0.0352961935447 0.0267660200432 0.0206247795688 0.0716485928619 0.0553558677376 0.0350658679333 0.0348297205048 0.0591015265332 0.0349050611526 0.0239450314084 0.0312292238968 0.0291976883203 0.0191245738332 0.0424715605102 0.0407160306554 0.0507428891398 0.0195019979736 0.0455419926359 0.03094049167 0.0480027022309 0.0486981223658 0.0364405293098 0.0216724201002 0.0185311393183 0.0322264249099 0.0418711782883 0.0415641388928 0.0352666691701 0.0357541599092 0.040359691621 0.0422344237589 0.0468672273606 0.0294846892119 0.0324923805449 0.019122055634 0.028756827183 0.0587035417373 0.0144079071022 0.0301136242831 0.0361947314748 0.0239369814187 0.0355016994114 0.0354103580658 0.0251937444079 0.0240593800606 0.0195703439645 0.0308533101673 0.0370972551577 0.0220259748313 0.0576270076145 0.0487199724465 0.0508215730415 0.0469075647824 0.0527931212734 0.0620087731623 0.046977227863 0.0607033064427 0.0681905343994 0.0417090362137 0.0294084394516 0.0508408090071 0.0450400867986 0.0589677823649 0.0627613332544 0.0433082894199 0.0402642195426 0.0363046359117 0.084449006206 0.0666097386489 0.0449981598795 0.0463289168121 0.0716590868723 0.0429897098207 0.0369198960753 0.0432687121664 0.0364322199569 0.0287560795721 0.0553568599314 0.0500592177291 0.0617693212505 0.0302484927047 0.057817398636 0.0410079662048 0.0620054930234 0.0578523465697 0.0464641684152 0.0365865801942 0.0272374209649 0.0399576916682 0.0513227964118 0.0446516670985 0.0487199724465 0.0480806958126 0.0495453699635 0.0482845333883 0.0560302897599 0.0385013240981 0.0415333749992 0.0339802993211 0.0315416974034 0.0191639032899 0.00845591360235 0.0214341775937 0.0115218935447 0.00798589270321 0.013178045677 0.0100207917484 0.0199483776485 0.012776598265 0.00707708079363 0.0310463483447 0.00779811122226 0.0665120827305 0.0484731432285 0.0421114253952 0.0418216626354 0.0527853739739 0.0493966141428 0.0532439640509 0.0450980317427 0.0534929652418 0.0482563107324 0.0334028573772 0.0421738253769 0.0400650763191 0.0574010770653 0.0690115183659 0.0507807835016 0.033887277172 0.0360916940356 0.0712074753299 0.0488889567075 0.0456112729946 0.052712754383 0.0558191941722 0.0328832629679 0.0398769847778 0.0305626616722 0.03027845702 0.0307126203306 0.051853149134 0.0304315085387 0.0449208583046 0.0225669791691 0.0556104755493 0.0254498384131 0.0488668504899 0.0462046921677 0.0583599392562 0.0343786096194 0.0317076229625 0.0356254179774 0.0534761774586 0.0442401179536 0.0484731432285 0.0494784680372 0.0560638562362 0.0481022882275 0.0453399462887 0.0364100969213 0.0549637988767 0.0386182470618 0.0499647144567 0.0286991839096 0.0337581082348 0.0374427591873 0.0282526339036 0.0355267981937 0.0350362485208 0.0478325170984 0.0425063748067 0.0336958297594 0.0552821351039 0.0385952701325 0.0756759815417 0.0533281139759 0.0401812481707 0.0447968354881 0.0564105044414 0.0391525826608 0.0629279047421 0.0332827070938 0.0388499692511 0.059944716429 0.0494848197832 0.0402828974015 0.0438747097228 0.0580998054312 0.0757410641548 0.0628856838636 0.039846534973 0.047063496141 0.0543336344875 0.0312551117596 0.052807685198 0.0627916823231 0.0390112066642 0.0353058185357 0.0513654740192 0.0323261929775 0.0392211101217 0.0463708307148 0.0519963158873 0.0234224809867 0.0301000678074 0.0372829629985 0.056085164213 0.0288004220361 0.0417416575715 0.0389119081863 0.0720657500645 0.0444323135884 0.0487706488559 0.0429521653792 0.0596874437499 0.052997284605 0.0533281139759 0.055723410021 0.0657462146584 0.0546473494099 0.0397492903292 0.0452841873006 0.0707319601823 0.0522103619845 0.0233361726138 0.027152976334 0.0145101369991 0.0239084572879 0.0231796409398 0.016731423623 0.010101659051 0.00781108168527 0.0186261838058 0.0315054768721 0.011535154356 0.0661583467836 0.0529737197777 0.0515726376237 0.0472342284059 0.0573866872941 0.0602508051558 0.0535888133028 0.0563499220883 0.0655740867856 0.0494619373879 0.0355566546043 0.0516986354459 0.0478914383755 0.0636133913461 0.0714227137745 0.0519652065027 0.040040966538 0.0379888138015 0.0833863881089 0.0624232672218 0.0504889561622 0.0539483262888 0.0682863371673 0.0434492287718 0.0419221148541 0.0393420375143 0.0383919560321 0.0330409365388 0.0586345177546 0.0426935993753 0.0582011555148 0.0271038932712 0.0620596992058 0.0353264927481 0.0565229896235 0.0582751327845 0.0564224406826 0.0375222198637 0.032781658946 0.0431629716317 0.0579468986629 0.0506284295544 0.0529737197777 0.0534601982596 0.057907553496 0.0543043024926 0.0568716124285 0.0423649825393 0.0520169525452 0.0387128090446 0.0188041113809 0.0118952838684 0.0140246174547 0.0212962400935 0.00885470160798 0.025142494638 0.0164130694781 0.0148836892075 0.0382106616301 0.012548123562 0.0595024177002 0.0405144987261 0.0336829979036 0.0339109092342 0.0447786612887 0.0412528753098 0.0460796810618 0.0378073897699 0.0456289595962 0.0415318567716 0.0274434917532 0.0337586538145 0.0320559171837 0.0493065770936 0.0620181140557 0.044443934423 0.0259210454652 0.0290199212383 0.0631931226882 0.0415500215307 0.0381432011516 0.0457001329437 0.0482419653282 0.0247624956339 0.0326912275918 0.0231122641396 0.0226732232029 0.0241582823353 0.0435758556102 0.024717419625 0.037259551901 0.0161507334564 0.0474557435456 0.0186437176733 0.0428749718429 0.0381563349544 0.0522572394535 0.0270598018866 0.0256825354187 0.028101885414 0.0461630275758 0.0383904744963 0.0405144987261 0.041758354552 0.0492909187408 0.0413606774947 0.0372601462253 0.0289047461458 0.049343864353 0.0319066136889 0.0140884736377 0.0220949123029 0.0294588701998 0.0141915109934 0.0236402055251 0.0202701530019 0.0222961106051 0.0508328337578 0.0209048958304 0.0623063919994 0.0435137888223 0.0379179155361 0.0310595169631 0.0477275300573 0.0401401417297 0.0476510837343 0.0326069267264 0.0442002914704 0.048031576146 0.0373260310255 0.0383688546713 0.0396828967833 0.0540671732006 0.0691161945626 0.052697233895 0.0256698443155 0.0271866198766 0.063343063446 0.0401717345523 0.0456835007162 0.0508390224232 0.0457136947621 0.0340506342939 0.0366331778515 0.0185292352758 0.0332180639746 0.031402826069 0.0470047522912 0.0178796862446 0.0373117201537 0.0146755143259 0.0519441438124 0.0134308953908 0.0305516636587 0.0455547559496 0.0574314455133 0.025677142017 0.0334820400224 0.038185075996 0.053981408775 0.0519396327628 0.0435137888223 0.0464090712113 0.0566586435278 0.0526391071675 0.0449104072539 0.0375180555166 0.0549667946861 0.0334290223836 0.0161979126548 0.0212360948185 0.00313302296585 0.0148689509772 0.00704616989296 0.0135603719097 0.0384674432624 0.00748847746612 0.0612097252086 0.0442840466006 0.040253243803 0.0360606427738 0.0487530949526 0.0470778914902 0.0473392259982 0.0422963534873 0.051949068182 0.0444929580638 0.0309270188278 0.040473799777 0.0386243677637 0.0547837147046 0.066413370926 0.0479885282668 0.0287291459439 0.0288822795748 0.0702829288423 0.0483322868723 0.0432975336344 0.0484818516534 0.0543652596123 0.0329738645592 0.0348525988976 0.0258401695463 0.029652318833 0.0266204166929 0.0488217477328 0.0282325775461 0.0443695558327 0.0152728890442 0.0529346931915 0.0211960241124 0.0432358961175 0.0470042201915 0.0535566647123 0.027654993588 0.0276975587847 0.0349524016669 0.051450438001 0.0457471816551 0.0442840466006 0.0457673454519 0.0531390087147 0.0482613634351 0.0459084957324 0.0344895940573 0.0501063288839 0.0320407745768 0.00918896575074 0.0152928703979 0.0213827580606 0.0175694634428 0.00562421953864 0.0321021314886 0.0136468651148 0.0732793088732 0.0542749513511 0.0465599433205 0.0461499050441 0.0585282720374 0.0518386762248 0.0596896497046 0.0460357977086 0.0551020502351 0.055347044484 0.0408456006547 0.0466734650365 0.0457685420886 0.0629790052567 0.0758414718388 0.0580725583953 0.0386295601195 0.0415657641172 0.0731303485703 0.0495368191967 0.0520897347287 0.0595893389246 0.0567976430466 0.0379647331116 0.046441942626 0.0333063038869 0.036500108881 0.0377849182347 0.0570420811998 0.030012797008 0.0462545479693 0.027461418846 0.0610786707463 0.0275181743774 0.0490679602747 0.0500650525841 0.0657243645716 0.0396831631678 0.0390548397455 0.0418579268325 0.0600259300869 0.0509169565607 0.0542749513511 0.0557017357111 0.0631094362549 0.0546387182457 0.049518990394 0.0428637051261 0.0625010516077 0.0450876329039 0.0212339329669 0.0205215987455 0.0193863377449 0.00780222226267 0.0244911121423 0.0160871853235 0.0794295187203 0.0616053956912 0.0547043851777 0.0543405312398 0.065903416382 0.0608093966938 0.066232208671 0.0551996275352 0.0641635601661 0.0610614868167 0.0459223913813 0.0547672174246 0.0529488520021 0.0703578675954 0.081658744309 0.063265127216 0.046621662518 0.0487339053303 0.0819943915105 0.0586031447424 0.058550915637 0.0656481691263 0.065908662167 0.0454276311919 0.0529363521846 0.0420305180364 0.0431442291715 0.0436296366503 0.0648039964872 0.0390809908814 0.0552779379516 0.0347675148936 0.0685677387884 0.0363124697872 0.0577513229251 0.0579440183076 0.0708163109663 0.0470812852612 0.0443909494169 0.0483964045026 0.0662606542355 0.055662814312 0.0616053956912 0.0625961650479 0.0687432253304 0.0602433308395 0.0572909174214 0.0493875071422 0.0671416550914 0.051430941132 0.0176886906331 0.00927892520724 0.0135248076976 0.0386449359276 0.00800171044068 0.0600153322548 0.0424684845259 0.0378068586886 0.0345103555887 0.0469162632965 0.044830307306 0.0461600332306 0.040366688607 0.0496446456688 0.0429723253644 0.0292480429291 0.0380026884561 0.0362133523808 0.0526530252718 0.0646507321938 0.046401756397 0.0269368048123 0.0278152961494 0.0678508831968 0.0459682894465 0.0412431425852 0.0469952418705 0.0521326959742 0.0302237793371 0.0333696851677 0.0240543524356 0.0271406206916 0.0250182744726 0.0466959485275 0.0265020349694 0.0419000008026 0.0139599809083 0.0507909794153 0.0193885955935 0.0423195771966 0.0441873849773 0.0525088605043 0.0263754966172 0.0262639235251 0.0325133748369 0.0494223408625 0.0434143928247 0.0424684845259 0.0439360734198 0.0514706200386 0.0459476778298 0.0431249041549 0.0322850478478 0.0492075262735 0.0310084454102 0.0100495790147 0.0163467110294 0.0344303173981 0.0138069903297 0.0725561849391 0.0577945355153 0.0549392051976 0.0494983401957 0.0622636335656 0.0613281176125 0.0591564733558 0.055493289997 0.0660163516694 0.0564238014063 0.0428263617367 0.0551692935595 0.0528843814502 0.0687090576791 0.0786138592889 0.0595588928727 0.0427108568825 0.041401774003 0.084635719422 0.0620469795992 0.0566375025559 0.0605458826833 0.0680826326606 0.0475957607451 0.0475121922821 0.0395532575369 0.0436869591597 0.0392259763169 0.0629613789201 0.0403138291944 0.0584854937624 0.0290090498587 0.0669476358426 0.0346983343078 0.0538333844175 0.0617823249939 0.0639146571596 0.0406990904981 0.0395983575205 0.0488304003282 0.0645174644364 0.0580105192199 0.0577945355153 0.0590354282227 0.0651460923012 0.0612394393036 0.0606595939265 0.0481508588685 0.059835663962 0.0439114917806 0.0129734005291 0.03341718436 0.00522839839082 0.0644629130549 0.0490781090479 0.0460393397147 0.042060104717 0.0535473784021 0.0537667869164 0.051142158888 0.0493088817338 0.0587609555936 0.047452874403 0.0333145084294 0.0462018313471 0.0433659094036 0.0595851004773 0.0694769331379 0.0504124171924 0.034671039268 0.0338977868767 0.0768809318577 0.0551957563061 0.0471765984426 0.0517762151648 0.0612752535588 0.0380650031758 0.0388085089346 0.0327052071067 0.0338902731124 0.0299610722521 0.054082097785 0.0351427472718 0.0511360689963 0.0213341577068 0.0578680354373 0.0282202368919 0.0499673113862 0.0525352197686 0.0557073834724 0.0329893658613 0.0303826410135 0.0390336792828 0.055051644837 0.0480885204528 0.0490781090479 0.0500556489468 0.0560168186449 0.0513666437929 0.0513150683738 0.038531174408 0.0517653307967 0.0358776775011 0.0293027668161 0.00949293329263 0.0725916210374 0.0547194436592 0.0483620571735 0.0469816749901 0.0590799074957 0.0545464429945 0.0590974756513 0.0490311503881 0.0583273766433 0.0546626805606 0.0398779297173 0.0484777367952 0.0468025950712 0.0639880374892 0.0757199402524 0.0573199482995 0.0393352512936 0.0411552751652 0.0764775433632 0.0532445829203 0.052349146311 0.0590579753428 0.0602574471507 0.039602885829 0.0459481099263 0.0349175810863 0.037150941259 0.03692168916 0.0582151479375 0.0331340211018 0.0497159727507 0.0271028830882 0.0621502493207 0.0292960379946 0.0512053897158 0.0526539904442 0.0643939446385 0.0395489605444 0.0378591872997 0.0425337328718 0.0602822057384 0.0511975943751 0.0547194436592 0.0559279154126 0.0626694858218 0.0551041885347 0.0518894661445 0.0431638732605 0.0608387750183 0.0441361499894 0.0310183369902 0.0871660444405 0.0733823196322 0.0689340787316 0.0705597518969 0.0774366556509 0.07861295118 0.076322371958 0.075585060054 0.0826717778434 0.0681219966699 0.0528565530205 0.0687776982924 0.0640973745197 0.0810751053908 0.0869333145725 0.0682988428223 0.0623918658396 0.0630905228705 0.0989058396189 0.0780506774957 0.0672923155095 0.0734447484338 0.0852286487915 0.0580045491026 0.0635565107431 0.0611199283903 0.0538632888957 0.0534691027903 0.0772908944799 0.0610905623861 0.073927736475 0.0514266311669 0.0797776498939 0.0563654161709 0.0797411714169 0.0709112220147 0.075991910188 0.061929266059 0.0528794637266 0.0580761513446 0.0735774043698 0.0591743277341 0.0733823196322 0.0727567267189 0.0745131906994 0.065799040936 0.0698581828462 0.0592195179672 0.0715468662712 0.0627789092372 0.0648080233561 0.0484745494015 0.0442686485072 0.0419227062634 0.0529072690322 0.05220865754 0.0515658331236 0.0480206916873 0.056947174509 0.0470499747083 0.0323100366631 0.0443750009709 0.0415450201967 0.0583606796016 0.0686531977281 0.0497286282257 0.0341488382347 0.0345013563823 0.0748626932863 0.0530450676854 0.0459172064129 0.0515384326883 0.0594738121093 0.0355453778886 0.038659716641 0.0319368788596 0.0317165879728 0.0293867131129 0.0529269518286 0.0336846365247 0.0489212862277 0.021422361173 0.0566364033836 0.0272163294484 0.0501093106191 0.0498104699827 0.056059086848 0.0332712049783 0.0299486671345 0.0369730112559 0.0537844555125 0.0455932312627 0.0484745494015 0.0493458255088 0.0553162838774 0.0492693292197 0.0486803630647 0.0369835817896 0.0522579331221 0.0364683447074 0.022730708667 0.036743783492 0.0359076620395 0.0204805867516 0.0463990865864 0.0147686048767 0.0549817963395 0.0525592871928 0.0196223614467 0.0349129145261 0.0366443799136 0.0327544499352 0.0228629827418 0.017026958725 0.0209966358066 0.0388626349727 0.035298115438 0.0567980979705 0.0582058906835 0.0248891314561 0.0145753449597 0.0570907866116 0.0413833987479 0.0269969183741 0.0492024913366 0.039440986454 0.0359176091053 0.0265520996515 0.0615044403055 0.0540461620767 0.0485288037826 0.0239710979892 0.0540724881457 0.0603640513646 0.0428978851084 0.0134027017241 0.0368991356344 0.0354211161184 0.0355257446359 0.0210753154172 0.0377446845484 0.022730708667 0.0201673641607 0.0164841811953 0.0313109932769 0.041027522952 0.0326196770584 0.0184701671719 0.0295244972329 0.0144112105736 0.0158826147242 0.00448936000965 0.0256749628733 0.0117360219999 0.0336843126425 0.0324372887253 0.0146677582401 0.0224513170291 0.0144322007261 0.0126899376427 0.0122323800999 0.0277700509569 0.0197834641463 0.0180901487399 0.0184584697146 0.0418096588931 0.0367452397055 0.0108947935426 0.0131136689852 0.0371795334759 0.0204476192567 0.0118634455346 0.0280193213775 0.0206906520081 0.0208413846069 0.00805992628737 0.0397245591306 0.032104964073 0.0301985227624 0.0107001908888 0.0330988349255 0.0415195660786 0.0230606485279 0.0236410923325 0.0187109927435 0.0222023475244 0.0175662614613 0.0151089228932 0.0279798538754 0.0 0.00504787707871 0.0188703006517 0.0219245561497 0.0212095981034 0.0149942492526 0.0252687339312 0.016225955903 0.014982874816 0.0165713440517 0.0153992347708 0.0258128425881 0.0233194300829 0.0216404069707 0.0254243329386 0.0254506863873 0.000788850240312 0.00972288497974 0.0186083951584 0.0381473811219 0.0294157845108 0.0147578085456 0.0211609731312 0.0342335739858 0.0241609615185 0.0173732430671 0.0259324451415 0.0264222187829 0.0114741578552 0.0193298399608 0.0206022299244 0.0166568971164 0.0229188388297 0.0118905814083 0.0295550989457 0.0189848877848 0.0268759492012 0.0164070102936 0.0252554335694 0.0350869023834 0.0115237799469 0.0366507700029 0.0195520445986 0.0253794363549 0.0152320827299 0.0231766024476 0.028592244401 0.0144112105736 0.0173074040909 0.0296651493536 0.0243710502336 0.0103105434217 0.0155263675354 0.0374184940592 0.0231136537684 0.0190194510466 0.0188364876977 0.0221985054079 0.0214172478398 0.0257446692843 0.0273354856863 0.0275203255805 0.0156705691302 0.0195445751869 0.0258686776409 0.0435616108671 0.0331590462603 0.00822908256455 0.0111578554098 0.0408350390305 0.0282065307084 0.0237933699021 0.0272090918986 0.029489839001 0.0211107451245 0.0171676820259 0.0146997004559 0.0226821224304 0.022183640748 0.0185118691459 0.0264356522916 0.0241910879615 0.0208215741795 0.0237366538469 0.0205889692169 0.0263075431581 0.0263185412116 0.036342074994 0.0103523538982 0.0247947799759 0.0232770954007 0.0303205821473 0.0382875192266 0.0158826147242 0.0205185838207 0.033936913628 0.0342591359421 0.0252819239657 0.0211775313941 0.0366164619483 0.0168683582115 0.0265527528137 0.0122930639405 0.0356399190513 0.0329283261088 0.0161748547301 0.0260907486468 0.0165355786656 0.0155013603686 0.00871939649167 0.0250375042482 0.0205784254424 0.0221880849182 0.0226228234946 0.0402265547715 0.0380348851944 0.0126404460089 0.0132955588731 0.037673161045 0.023685130291 0.0159536871846 0.0317445670434 0.0244407629294 0.0250650773838 0.00665080674841 0.0431354773139 0.0336884150562 0.0346100496205 0.00755310734613 0.037025240188 0.043753914844 0.0237910793513 0.023601769275 0.0229675330633 0.0262374537149 0.0207694947791 0.0142462256068 0.0294419901123 0.00448936000965 0.00600179744469 0.0181950411243 0.0225874743282 0.0220819669003 0.0185630904749 0.0261141108628 0.0202600233978 0.0359510556228 0.0122181959079 0.00715556619596 0.0393252590156 0.0398773260728 0.015944130912 0.025117898688 0.0279596047113 0.0495072405762 0.0438343802676 0.0223301740975 0.0291958566192 0.0238057945893 0.0121408308676 0.0320439133203 0.0386704894061 0.0116681269474 0.0246115626131 0.0320654848123 0.02212022544 0.0306066666749 0.0360151785428 0.0212925403107 0.0265520435189 0.0096564754612 0.0336990775918 0.0258669646258 0.0271355620099 0.0255831511409 0.0192288539502 0.0492946436623 0.0275425360484 0.0388140188539 0.0303333899385 0.0366778253264 0.0435686919256 0.0256749628733 0.0298872725089 0.043124071299 0.0391147976424 0.020010154166 0.0305524053833 0.0506217525372 0.0340993001213 0.0427032875962 0.0428000340065 0.0127191401929 0.0244302586973 0.0258873530415 0.0224665589838 0.0196473040025 0.0259734946343 0.0180766430627 0.0245847379502 0.0205530555257 0.0515531804399 0.047284161103 0.0168752313645 0.0093274994833 0.0472940785154 0.0299859804517 0.013568861355 0.0349261393238 0.0278394065303 0.0233159306106 0.018729490125 0.0474594716238 0.0428441003445 0.0340535271365 0.0192623858156 0.0396592952666 0.0474504224755 0.0346317498496 0.0155232846365 0.0221965807346 0.023519540409 0.0251795457747 0.0186807942123 0.0328466600284 0.0117360219999 0.0111390258469 0.0171063233969 0.027248122956 0.0326787410905 0.0216187767654 0.0174724607588 0.0153838329478 0.013043913361 0.0463610530412 0.0437380208469 0.0239671160531 0.0322222363953 0.0387763357271 0.0597848214293 0.0513617728094 0.0233595904168 0.0301944308891 0.0320013483014 0.010613155035 0.0399275999718 0.0464560281456 0.0134988892532 0.0290788786594 0.0367911394695 0.0175534572334 0.0343523037935 0.0386269072909 0.0314326304477 0.0171757591643 0.0105270444576 0.0306360966619 0.0365489530298 0.0211256372062 0.0155275027866 0.0282406353658 0.0565789653078 0.0282583663219 0.0416523037157 0.0359394330813 0.0459783038684 0.0506220203623 0.0336843126425 0.0381881672141 0.0517807652888 0.0474506190651 0.0289707556044 0.0360504295798 0.0570578425896 0.0371145976129 0.0460576692202 0.0464080290911 0.0220712004031 0.0312574889523 0.0332251791601 0.054841891687 0.0503036463483 0.028999517533 0.0360798173432 0.0193249539307 0.00826557354917 0.0383933246971 0.0453200679143 0.00495350657916 0.0300295268949 0.0391229254289 0.0271682846269 0.036533385441 0.0426841669003 0.0272844902637 0.0287077471132 0.00927183865749 0.0394174170837 0.0313084618098 0.0314758507766 0.0267668687054 0.022518491913 0.05600898249 0.0343402195218 0.045509854552 0.0363226467926 0.0425348706975 0.0488168350062 0.0324372887253 0.0364696219213 0.0493441352532 0.0445105561012 0.0238995483109 0.0369592605884 0.0574925847452 0.0411978099793 0.0155890245102 0.0251635522565 0.0177733966699 0.020295344741 0.0224627747939 0.00622985531203 0.0261058920982 0.0236064364637 0.0550881017687 0.0493624804622 0.00949195374034 0.00547982782741 0.0508785947136 0.0251610996387 0.0119430843146 0.0365988456521 0.0213251727582 0.0179868212343 0.0207990673061 0.0485594746656 0.044214664825 0.0334335462828 0.0201922684831 0.0401754502972 0.0535325351547 0.0317074448278 0.0123261383208 0.0244676333996 0.0171629247157 0.0177983318365 0.0115555789303 0.021116940732 0.0146677582401 0.0105358367361 0.00915254671069 0.0167177891777 0.0294167459865 0.0147897849251 0.0123457776793 0.0164773765795 0.0252103273152 0.0171988861049 0.0305685435552 0.0365843208441 0.0175183238357 0.0218496748957 0.0205878945245 0.0593121863314 0.0470793832619 0.0159816216856 0.020744505382 0.0508661739809 0.018760262956 0.0128710885205 0.0300992820345 0.0117566522917 0.00679248320348 0.0280357325772 0.040552704264 0.0415859654681 0.0232256372519 0.0295874345059 0.0314690999231 0.0507965688951 0.0314591977122 0.0256867489287 0.0204093797109 0.00501434925534 0.0122277574576 0.0226603353781 0.0187158051887 0.0224513170291 0.020695499337 0.0231928239165 0.0198154038419 0.0292814261752 0.0103125125409 0.0227651885673 0.0153489133169 0.00921470910295 0.0183064776985 0.0377227049932 0.0290274791546 0.0152667053733 0.0215933253328 0.0343731361054 0.0245700487863 0.0169471424987 0.0257260078813 0.0268671065769 0.0111334970897 0.0193681705086 0.0211865368155 0.0163734248392 0.0228777878657 0.0117963493804 0.030068869871 0.0193762721713 0.027229886316 0.0161367068103 0.025740037188 0.0358416431275 0.0109673463454 0.0364509080414 0.0199965660095 0.0252914478428 0.014773865842 0.0226846344514 0.0279231861054 0.0144322007261 0.0171240275822 0.0292730788831 0.0236979129564 0.00966001570023 0.0151974508598 0.0372251985508 0.023311727536 0.0176051360114 0.032564167101 0.0208965631668 0.0168197313548 0.0207764664023 0.0423976172234 0.033280884693 0.00922898632458 0.0197200489933 0.0360385863631 0.00893473638299 0.014132357355 0.0250685285695 0.0103719683171 0.0167517993882 0.0135716425012 0.0350532380107 0.027879799306 0.0265658749664 0.015993421345 0.0286771298489 0.0428550440411 0.0151980773887 0.0298292088786 0.0196261415194 0.0184891599574 0.00655621912452 0.016322105066 0.0195353045374 0.0126899376427 0.0127701290018 0.0223217848231 0.0157154460048 0.0129568955631 0.00690277207156 0.0299954575682 0.0193817024498 0.0216771607077 0.0225658582257 0.0286138040807 0.0305011727447 0.0368382394098 0.0388439321615 0.0148355509953 0.0174423915339 0.0380129595202 0.0258082909988 0.0229842208153 0.0373470514825 0.0277476701907 0.0308564780706 0.00775830938446 0.0476084837369 0.0347450599297 0.0411478727988 0.00231111578025 0.0424821924039 0.0488975441679 0.0213563138315 0.0271270574956 0.0304501786922 0.0318897260431 0.0231190177025 0.0126379860304 0.0283589858381 0.0122323800999 0.0114136835682 0.0186791916183 0.0206672138954 0.0199079464104 0.0222007080182 0.0303110417953 0.0280827256688 0.0197052367937 0.0449418080277 0.0438182248518 0.0562345701188 0.0602081091792 0.0243728506009 0.019370550695 0.0596171194363 0.0411146925258 0.0330451422406 0.0550957050319 0.039836592047 0.0399228025142 0.0284759591968 0.0663825437409 0.0558252777705 0.0548034680532 0.0236830779253 0.0595333433641 0.0686676458986 0.0397842689041 0.0197958382609 0.0446061287137 0.0392287195509 0.0347118369491 0.0164026290561 0.0305214779366 0.0277700509569 0.0235155079857 0.0135888018548 0.0240589544851 0.0380160024194 0.0333951182547 0.0242014401746 0.0377621051763 0.0314790157987 0.029423203836 0.0582327389784 0.0535477924002 0.0121411421616 0.00926081168701 0.0551978876015 0.028043323191 0.0176337854836 0.041735927557 0.023998617859 0.0217227463265 0.0246395690903 0.0532994548372 0.0483234850835 0.0380931811444 0.0229416680066 0.0449797181572 0.059280772983 0.0338814552602 0.0120128740103 0.0301325195322 0.0203844916972 0.0200232099081 0.0110576598728 0.0182627991321 0.0197834641463 0.0150522414851 0.006556855609 0.0144048387324 0.0315801243453 0.0179150623078 0.0119668288225 0.022167313587 0.00841936493113 0.0453128226707 0.029523676844 0.0223084484022 0.0276272783534 0.0327625901905 0.0158536182647 0.0147737513682 0.0106741877313 0.0162753926733 0.0159900539559 0.0215767754577 0.023165172617 0.0247814128516 0.0137331692872 0.0264980088885 0.0153005942866 0.0291348842471 0.0254286093168 0.0364522562324 0.00599431682769 0.0189173783639 0.0184393411187 0.0301213577678 0.0340540018144 0.0180901487399 0.0215314467503 0.0337154513722 0.0315978293722 0.024169684578 0.0166816873996 0.0356875981931 0.0143747226708 0.0514837021891 0.0372994668391 0.0230531280792 0.0250236859971 0.0398047566678 0.021934356719 0.0118568359564 0.016712157857 0.0198275637831 0.0143476538676 0.0244078681037 0.0292462046489 0.0328036706334 0.014376575397 0.0286902071785 0.0204063466033 0.0328369650405 0.0322219054124 0.0320787692664 0.00266433410273 0.0165423262191 0.0215926529236 0.03047036768 0.0358252300263 0.0184584697146 0.0213100670766 0.032046547675 0.0333108429689 0.0306570115485 0.018573514939 0.030845411182 0.00824349209933 0.0254197321026 0.047324533609 0.0530498030585 0.0193482837408 0.0436475526218 0.0516271254066 0.0457976820229 0.0502335440929 0.0569904536613 0.0344485460271 0.0478896186827 0.0272539439051 0.0572698534085 0.0358919394369 0.050424643016 0.0434868500285 0.0309009333379 0.0632686594285 0.0501928388473 0.0594250482186 0.0482632028717 0.0482478127894 0.0570074387196 0.0418096588931 0.0448198518438 0.0553205633247 0.0514202209421 0.0325934353049 0.0491031454545 0.0660730408504 0.0548573842682 0.041501827818 0.0494594306994 0.00785967991178 0.0297803384368 0.0414124759052 0.0250716250932 0.0363814861914 0.0430927179021 0.0324719682551 0.0232534554573 0.00557282966442 0.0375065288364 0.0368003051347 0.0279998159154 0.0252506405295 0.0244125277036 0.0601405054627 0.0351799654171 0.0460355764213 0.0372310571496 0.0466115069454 0.0500875517655 0.0367452397055 0.0406580228721 0.0534802351733 0.0469702184582 0.0259083864948 0.0383091416944 0.0609916135179 0.0430915691708 0.0113258711014 0.0432937210726 0.0175511998728 0.0124157338497 0.03212454916 0.0158561794962 0.0176896387613 0.0143093876737 0.043181186929 0.0362893217044 0.0315177649353 0.0141883840024 0.0359022033885 0.0492746305333 0.0223018781484 0.0211045193185 0.0229404408443 0.0181288833884 0.0110415500412 0.00837364985146 0.0172572597582 0.0108947935426 0.00733209366776 0.0131427681285 0.0115359384743 0.0199994152339 0.0092535804352 0.0217603350968 0.0184515208125 0.0501255669434 0.0279388443296 0.0142651752221 0.0382528821443 0.0251771073359 0.0222405400165 0.018907996804 0.050407441851 0.0445874581383 0.03644061978 0.0176520694999 0.0424414179548 0.05338489352 0.0323923780445 0.0108812710336 0.0260958051981 0.0217902651406 0.0213471493056 0.0109405604951 0.0249968133743 0.0131136689852 0.00893536297262 0.00802513881767 0.0192978256402 0.0302167707341 0.018365059649 0.0130926236805 0.0184689475202 0.0343186729394 0.0436186327673 0.0296745080858 0.0408423177906 0.0469164023153 0.0321355072481 0.0293927572919 0.0115197032526 0.0423686398976 0.036129628995 0.0335484782832 0.0259949361948 0.0269704035297 0.0607621523939 0.0380404513983 0.049798653181 0.0409231346593 0.0474755392541 0.0535032395417 0.0371795334759 0.0413092694389 0.054257484038 0.0493594143559 0.0284802931744 0.0415978746211 0.0622229836323 0.0453773607077 0.0190484002067 0.0207749590973 0.00729318592678 0.0172314224853 0.0208211767145 0.0287420582694 0.0242194382748 0.0225231335589 0.0240241380028 0.0229680498334 0.0402905798782 0.0150429891355 0.0374592753112 0.0199314954492 0.0195088829088 0.00836639606005 0.0247669201274 0.0222507048525 0.0204476192567 0.021382719754 0.0305241597933 0.0212891172726 0.0134776031268 0.0107610654817 0.0367912026131 0.0227467739819 0.0252412358335 0.0153803531506 0.0101093922522 0.0191555088988 0.0375470144869 0.0363071087647 0.0222024666973 0.021689493319 0.0288400411309 0.0426974513075 0.0286740878663 0.0220177373135 0.0125507954062 0.0111145943691 0.0144555489867 0.0195277194831 0.0258649050915 0.0118634455346 0.0120062047089 0.0205457113931 0.0226933950128 0.0265812358015 0.010518368073 0.0210005232169 0.00605049088221 0.0227443548737 0.0240543202468 0.0298445720969 0.0127076622649 0.0212764877573 0.0130936058244 0.0350960563748 0.00616350137707 0.0220053566886 0.029182207808 0.0470447673611 0.0143549158293 0.0270200109504 0.0261798064669 0.0399469917707 0.0417589617676 0.0280193213775 0.0317524179632 0.0441157592928 0.0402109444472 0.0286518076954 0.0255338040061 0.0460635600013 0.0240522825965 0.0109052701432 0.0235077295524 0.0318665250498 0.0308330797717 0.0201941994246 0.026209699134 0.024272445381 0.0437154276666 0.0215651164399 0.0334110813047 0.0182660118628 0.0127706309369 0.00547043300996 0.0236736081076 0.0193715054877 0.0206906520081 0.0206326054685 0.0278093020752 0.0196854448654 0.0196839348285 0.00687772387853 0.0318861086105 0.0187829482374 0.026787715043 0.0349795665731 0.0377560197701 0.0169430774361 0.0294826475268 0.02554791035 0.044564230482 0.0307872765104 0.0282156909894 0.0140157312571 0.00304825224888 0.013131876158 0.0254598849649 0.0242359050423 0.0208413846069 0.0206178921833 0.0265921223132 0.024263714379 0.0287692622655 0.0105411880456 0.0255889461915 0.0107722057824 0.040112260752 0.0281920691871 0.0346799127455 0.00547299312148 0.0351698801996 0.0413927767406 0.0178561632488 0.0295704831304 0.0240442618733 0.028433519767 0.0198981190422 0.0164655446546 0.0293872770207 0.00805992628737 0.0103936152637 0.0224915115769 0.0226675446032 0.0164308167554 0.0187959028502 0.0318543120786 0.0236941138036 0.0214366809685 0.02158460699 0.0453234846239 0.0100348820296 0.0205571695519 0.0349449705288 0.0594353543617 0.0269232145172 0.0378563722335 0.0357646095878 0.0508614713562 0.0504482642845 0.0397245591306 0.0434432071263 0.055747628056 0.0497669350857 0.035138779746 0.0361053959246 0.0583555321158 0.0365217793435 0.0331608473129 0.0326376645366 0.0244797200401 0.0260351758605 0.0198255233977 0.055257342683 0.030607412773 0.0406724640229 0.0316826493706 0.0417015250124 0.044714144963 0.032104964073 0.0358439539437 0.0485265392209 0.0417397589401 0.0211023329973 0.0328093106913 0.055937896155 0.0382216948189 0.039178382683 0.0116462448464 0.0328449320294 0.0356452166019 0.0431040247851 0.0127555033307 0.0192172916283 0.0248029464024 0.0398126039657 0.0387676066679 0.0301985227624 0.0325088097853 0.0421224110282 0.0389248491362 0.0344395222458 0.0235149407659 0.0407276725105 0.0194230824244 0.0402634745964 0.0467109968717 0.0198309327046 0.0277799641062 0.0285372209353 0.0306922978338 0.0217975015009 0.0133715864954 0.0282760151712 0.0107001908888 0.0106288988311 0.0196086000788 0.0208164998238 0.0183683750797 0.0208677693371 0.0306825719595 0.0267116346537 0.0244223076771 0.0326854873354 0.0507787766717 0.0180800830921 0.0283453513368 0.0285692206738 0.0439964220236 0.0435330479692 0.0330988349255 0.0364104267178 0.047999984958 0.0430530022579 0.0322085934623 0.0282999450485 0.049271623839 0.0273166054796 0.0425206430225 0.0621747559979 0.0316259435967 0.0474306721161 0.0460270405303 0.055722110458 0.0616108763567 0.0415195660786 0.0463779068274 0.0600405303926 0.058487923658 0.0428330727641 0.0451145046508 0.0622811849491 0.040848815271 0.0429266615699 0.0304603009077 0.0328680598837 0.0193092495687 0.0257358921646 0.0276472175985 0.0230606485279 0.0242829569209 0.0335562675322 0.0240112096757 0.0023427193432 0.0215758461563 0.0440130376785 0.0333268924093 0.0336594835101 0.0267459293135 0.0300685155468 0.0190916149163 0.0302108808069 0.0236410923325 0.0197983357166 0.0116623663768 0.025981149508 0.0407083432987 0.0270506742353 0.00533601555818 0.0243947872794 0.0165388277645 0.0203993556991 0.0306449706863 0.0351570407904 0.0187109927435 0.0216936002715 0.0328125704384 0.0328483395342 0.0289711567156 0.0177290185247 0.0324417191457 0.00990245486371 0.0144435719572 0.0253854499058 0.0235470613048 0.0222023475244 0.0213735089495 0.0257216217897 0.0239916366178 0.0307770932602 0.0118559544137 0.0237036848381 0.0117425310805 0.0184555467145 0.0157796168272 0.0175662614613 0.0166625646078 0.0231975140243 0.0146299258577 0.0171445810537 0.00397360286698 0.029169512627 0.0192796522734 0.0184254094366 0.0151089228932 0.0104342480435 0.00810789324855 0.0108902089943 0.0236280097789 0.017384613998 0.0213096795304 0.0252727380791 0.0279798538754 0.0244605767611 0.021500625639 0.00796997392989 0.0256665045822 0.0176058458155 0.0292950203769 0.0310442784549 0.00504787707871 0.0188703006517 0.0219245561497 0.0212095981034 0.0149942492526 0.0252687339312 0.016225955903 0.0138989004364 0.0180767927652 0.0222193332382 0.0141002986592 0.0215877207325 0.0172352062998 0.0156454524782 0.031383424491 0.0212505739868 0.0142951058056 0.0253431933269 0.0219030212003 0.0156518397703 0.0263438271284 0.0285058962486 0.0193626993311 0.0417261059969 0.0313743437253 0.0260801912789 0.0155074292908 0.0227467684355 diff --git a/shared/package-files/2f/2fb7e2df5f73d447856a0ea91fc9b2a83418437d87d7ddd02ca31daa5c400ac6/blob b/shared/package-files/2f/2fb7e2df5f73d447856a0ea91fc9b2a83418437d87d7ddd02ca31daa5c400ac6/blob new file mode 100644 index 0000000000000000000000000000000000000000..b550db1606866fb76442980ea2139aaf61219525 --- /dev/null +++ b/shared/package-files/2f/2fb7e2df5f73d447856a0ea91fc9b2a83418437d87d7ddd02ca31daa5c400ac6/blob @@ -0,0 +1,493 @@ +"""Tests for tools for manipulating of large commutative expressions. """ + +from sympy.concrete.summations import Sum +from sympy.core.add import Add +from sympy.core.basic import Basic +from sympy.core.containers import (Dict, Tuple) +from sympy.core.function import Function +from sympy.core.mul import Mul +from sympy.core.numbers import (I, Rational, oo) +from sympy.core.singleton import S +from sympy.core.symbol import (Dummy, Symbol, symbols) +from sympy.functions.elementary.exponential import (exp, log) +from sympy.functions.elementary.miscellaneous import (root, sqrt) +from sympy.functions.elementary.trigonometric import (cos, sin) +from sympy.integrals.integrals import Integral +from sympy.series.order import O +from sympy.sets.sets import Interval +from sympy.simplify.radsimp import collect +from sympy.simplify.simplify import simplify +from sympy.core.exprtools import (decompose_power, Factors, Term, _gcd_terms, + gcd_terms, factor_terms, factor_nc, _mask_nc, + _monotonic_sign) +from sympy.core.mul import _keep_coeff as _keep_coeff +from sympy.simplify.cse_opts import sub_pre +from sympy.testing.pytest import raises + +from sympy.abc import a, b, t, x, y, z + + +def test_decompose_power(): + assert decompose_power(x) == (x, 1) + assert decompose_power(x**2) == (x, 2) + assert decompose_power(x**(2*y)) == (x**y, 2) + assert decompose_power(x**(2*y/3)) == (x**(y/3), 2) + assert decompose_power(x**(y*Rational(2, 3))) == (x**(y/3), 2) + + +def test_Factors(): + assert Factors() == Factors({}) == Factors(S.One) + assert Factors().as_expr() is S.One + assert Factors({x: 2, y: 3, sin(x): 4}).as_expr() == x**2*y**3*sin(x)**4 + assert Factors(S.Infinity) == Factors({oo: 1}) + assert Factors(S.NegativeInfinity) == Factors({oo: 1, -1: 1}) + # issue #18059: + assert Factors((x**2)**S.Half).as_expr() == (x**2)**S.Half + + a = Factors({x: 5, y: 3, z: 7}) + b = Factors({ y: 4, z: 3, t: 10}) + + assert a.mul(b) == a*b == Factors({x: 5, y: 7, z: 10, t: 10}) + + assert a.div(b) == divmod(a, b) == \ + (Factors({x: 5, z: 4}), Factors({y: 1, t: 10})) + assert a.quo(b) == a/b == Factors({x: 5, z: 4}) + assert a.rem(b) == a % b == Factors({y: 1, t: 10}) + + assert a.pow(3) == a**3 == Factors({x: 15, y: 9, z: 21}) + assert b.pow(3) == b**3 == Factors({y: 12, z: 9, t: 30}) + + assert a.gcd(b) == Factors({y: 3, z: 3}) + assert a.lcm(b) == Factors({x: 5, y: 4, z: 7, t: 10}) + + a = Factors({x: 4, y: 7, t: 7}) + b = Factors({z: 1, t: 3}) + + assert a.normal(b) == (Factors({x: 4, y: 7, t: 4}), Factors({z: 1})) + + assert Factors(sqrt(2)*x).as_expr() == sqrt(2)*x + + assert Factors(-I)*I == Factors() + assert Factors({S.NegativeOne: S(3)})*Factors({S.NegativeOne: S.One, I: S(5)}) == \ + Factors(I) + assert Factors(sqrt(I)*I) == Factors(I**(S(3)/2)) == Factors({I: S(3)/2}) + assert Factors({I: S(3)/2}).as_expr() == I**(S(3)/2) + + assert Factors(S(2)**x).div(S(3)**x) == \ + (Factors({S(2): x}), Factors({S(3): x})) + assert Factors(2**(2*x + 2)).div(S(8)) == \ + (Factors({S(2): 2*x + 2}), Factors({S(8): S.One})) + + # coverage + # /!\ things break if this is not True + assert Factors({S.NegativeOne: Rational(3, 2)}) == Factors({I: S.One, S.NegativeOne: S.One}) + assert Factors({I: S.One, S.NegativeOne: Rational(1, 3)}).as_expr() == I*(-1)**Rational(1, 3) + + assert Factors(-1.) == Factors({S.NegativeOne: S.One, S(1.): 1}) + assert Factors(-2.) == Factors({S.NegativeOne: S.One, S(2.): 1}) + assert Factors((-2.)**x) == Factors({S(-2.): x}) + assert Factors(S(-2)) == Factors({S.NegativeOne: S.One, S(2): 1}) + assert Factors(S.Half) == Factors({S(2): -S.One}) + assert Factors(Rational(3, 2)) == Factors({S(3): S.One, S(2): S.NegativeOne}) + assert Factors({I: S.One}) == Factors(I) + assert Factors({-1.0: 2, I: 1}) == Factors({S(1.0): 1, I: 1}) + assert Factors({S.NegativeOne: Rational(-3, 2)}).as_expr() == I + A = symbols('A', commutative=False) + assert Factors(2*A**2) == Factors({S(2): 1, A**2: 1}) + assert Factors(I) == Factors({I: S.One}) + assert Factors(x).normal(S(2)) == (Factors(x), Factors(S(2))) + assert Factors(x).normal(S.Zero) == (Factors(), Factors(S.Zero)) + raises(ZeroDivisionError, lambda: Factors(x).div(S.Zero)) + assert Factors(x).mul(S(2)) == Factors(2*x) + assert Factors(x).mul(S.Zero).is_zero + assert Factors(x).mul(1/x).is_one + assert Factors(x**sqrt(2)**3).as_expr() == x**(2*sqrt(2)) + assert Factors(x)**Factors(S(2)) == Factors(x**2) + assert Factors(x).gcd(S.Zero) == Factors(x) + assert Factors(x).lcm(S.Zero).is_zero + assert Factors(S.Zero).div(x) == (Factors(S.Zero), Factors()) + assert Factors(x).div(x) == (Factors(), Factors()) + assert Factors({x: .2})/Factors({x: .2}) == Factors() + assert Factors(x) != Factors() + assert Factors(S.Zero).normal(x) == (Factors(S.Zero), Factors()) + n, d = x**(2 + y), x**2 + f = Factors(n) + assert f.div(d) == f.normal(d) == (Factors(x**y), Factors()) + assert f.gcd(d) == Factors() + d = x**y + assert f.div(d) == f.normal(d) == (Factors(x**2), Factors()) + assert f.gcd(d) == Factors(d) + n = d = 2**x + f = Factors(n) + assert f.div(d) == f.normal(d) == (Factors(), Factors()) + assert f.gcd(d) == Factors(d) + n, d = 2**x, 2**y + f = Factors(n) + assert f.div(d) == f.normal(d) == (Factors({S(2): x}), Factors({S(2): y})) + assert f.gcd(d) == Factors() + + # extraction of constant only + n = x**(x + 3) + assert Factors(n).normal(x**-3) == (Factors({x: x + 6}), Factors({})) + assert Factors(n).normal(x**3) == (Factors({x: x}), Factors({})) + assert Factors(n).normal(x**4) == (Factors({x: x}), Factors({x: 1})) + assert Factors(n).normal(x**(y - 3)) == \ + (Factors({x: x + 6}), Factors({x: y})) + assert Factors(n).normal(x**(y + 3)) == (Factors({x: x}), Factors({x: y})) + assert Factors(n).normal(x**(y + 4)) == \ + (Factors({x: x}), Factors({x: y + 1})) + + assert Factors(n).div(x**-3) == (Factors({x: x + 6}), Factors({})) + assert Factors(n).div(x**3) == (Factors({x: x}), Factors({})) + assert Factors(n).div(x**4) == (Factors({x: x}), Factors({x: 1})) + assert Factors(n).div(x**(y - 3)) == \ + (Factors({x: x + 6}), Factors({x: y})) + assert Factors(n).div(x**(y + 3)) == (Factors({x: x}), Factors({x: y})) + assert Factors(n).div(x**(y + 4)) == \ + (Factors({x: x}), Factors({x: y + 1})) + + assert Factors(3 * x / 2) == Factors({3: 1, 2: -1, x: 1}) + assert Factors(x * x / y) == Factors({x: 2, y: -1}) + assert Factors(27 * x / y**9) == Factors({27: 1, x: 1, y: -9}) + + +def test_Term(): + a = Term(4*x*y**2/z/t**3) + b = Term(2*x**3*y**5/t**3) + + assert a == Term(4, Factors({x: 1, y: 2}), Factors({z: 1, t: 3})) + assert b == Term(2, Factors({x: 3, y: 5}), Factors({t: 3})) + + assert a.as_expr() == 4*x*y**2/z/t**3 + assert b.as_expr() == 2*x**3*y**5/t**3 + + assert a.inv() == \ + Term(S.One/4, Factors({z: 1, t: 3}), Factors({x: 1, y: 2})) + assert b.inv() == Term(S.Half, Factors({t: 3}), Factors({x: 3, y: 5})) + + assert a.mul(b) == a*b == \ + Term(8, Factors({x: 4, y: 7}), Factors({z: 1, t: 6})) + assert a.quo(b) == a/b == Term(2, Factors({}), Factors({x: 2, y: 3, z: 1})) + + assert a.pow(3) == a**3 == \ + Term(64, Factors({x: 3, y: 6}), Factors({z: 3, t: 9})) + assert b.pow(3) == b**3 == Term(8, Factors({x: 9, y: 15}), Factors({t: 9})) + + assert a.pow(-3) == a**(-3) == \ + Term(S.One/64, Factors({z: 3, t: 9}), Factors({x: 3, y: 6})) + assert b.pow(-3) == b**(-3) == \ + Term(S.One/8, Factors({t: 9}), Factors({x: 9, y: 15})) + + assert a.gcd(b) == Term(2, Factors({x: 1, y: 2}), Factors({t: 3})) + assert a.lcm(b) == Term(4, Factors({x: 3, y: 5}), Factors({z: 1, t: 3})) + + a = Term(4*x*y**2/z/t**3) + b = Term(2*x**3*y**5*t**7) + + assert a.mul(b) == Term(8, Factors({x: 4, y: 7, t: 4}), Factors({z: 1})) + + assert Term((2*x + 2)**3) == Term(8, Factors({x + 1: 3}), Factors({})) + assert Term((2*x + 2)*(3*x + 6)**2) == \ + Term(18, Factors({x + 1: 1, x + 2: 2}), Factors({})) + + +def test_gcd_terms(): + f = 2*(x + 1)*(x + 4)/(5*x**2 + 5) + (2*x + 2)*(x + 5)/(x**2 + 1)/5 + \ + (2*x + 2)*(x + 6)/(5*x**2 + 5) + + assert _gcd_terms(f) == ((Rational(6, 5))*((1 + x)/(1 + x**2)), 5 + x, 1) + assert _gcd_terms(Add.make_args(f)) == \ + ((Rational(6, 5))*((1 + x)/(1 + x**2)), 5 + x, 1) + + newf = (Rational(6, 5))*((1 + x)*(5 + x)/(1 + x**2)) + assert gcd_terms(f) == newf + args = Add.make_args(f) + # non-Basic sequences of terms treated as terms of Add + assert gcd_terms(list(args)) == newf + assert gcd_terms(tuple(args)) == newf + assert gcd_terms(set(args)) == newf + # but a Basic sequence is treated as a container + assert gcd_terms(Tuple(*args)) != newf + assert gcd_terms(Basic(Tuple(S(1), 3*y + 3*x*y), Tuple(S(1), S(3)))) == \ + Basic(Tuple(S(1), 3*y*(x + 1)), Tuple(S(1), S(3))) + # but we shouldn't change keys of a dictionary or some may be lost + assert gcd_terms(Dict((x*(1 + y), S(2)), (x + x*y, y + x*y))) == \ + Dict({x*(y + 1): S(2), x + x*y: y*(1 + x)}) + + assert gcd_terms((2*x + 2)**3 + (2*x + 2)**2) == 4*(x + 1)**2*(2*x + 3) + + assert gcd_terms(0) == 0 + assert gcd_terms(1) == 1 + assert gcd_terms(x) == x + assert gcd_terms(2 + 2*x) == Mul(2, 1 + x, evaluate=False) + arg = x*(2*x + 4*y) + garg = 2*x*(x + 2*y) + assert gcd_terms(arg) == garg + assert gcd_terms(sin(arg)) == sin(garg) + + # issue 6139-like + alpha, alpha1, alpha2, alpha3 = symbols('alpha:4') + a = alpha**2 - alpha*x**2 + alpha + x**3 - x*(alpha + 1) + rep = (alpha, (1 + sqrt(5))/2 + alpha1*x + alpha2*x**2 + alpha3*x**3) + s = (a/(x - alpha)).subs(*rep).series(x, 0, 1) + assert simplify(collect(s, x)) == -sqrt(5)/2 - Rational(3, 2) + O(x) + + # issue 5917 + assert _gcd_terms([S.Zero, S.Zero]) == (0, 0, 1) + assert _gcd_terms([2*x + 4]) == (2, x + 2, 1) + + eq = x/(x + 1/x) + assert gcd_terms(eq, fraction=False) == eq + eq = x/2/y + 1/x/y + assert gcd_terms(eq, fraction=True, clear=True) == \ + (x**2 + 2)/(2*x*y) + assert gcd_terms(eq, fraction=True, clear=False) == \ + (x**2/2 + 1)/(x*y) + assert gcd_terms(eq, fraction=False, clear=True) == \ + (x + 2/x)/(2*y) + assert gcd_terms(eq, fraction=False, clear=False) == \ + (x/2 + 1/x)/y + + +def test_factor_terms(): + A = Symbol('A', commutative=False) + assert factor_terms(9*(x + x*y + 1) + (3*x + 3)**(2 + 2*x)) == \ + 9*x*y + 9*x + _keep_coeff(S(3), x + 1)**_keep_coeff(S(2), x + 1) + 9 + assert factor_terms(9*(x + x*y + 1) + (3)**(2 + 2*x)) == \ + _keep_coeff(S(9), 3**(2*x) + x*y + x + 1) + assert factor_terms(3**(2 + 2*x) + a*3**(2 + 2*x)) == \ + 9*3**(2*x)*(a + 1) + assert factor_terms(x + x*A) == \ + x*(1 + A) + assert factor_terms(sin(x + x*A)) == \ + sin(x*(1 + A)) + assert factor_terms((3*x + 3)**((2 + 2*x)/3)) == \ + _keep_coeff(S(3), x + 1)**_keep_coeff(Rational(2, 3), x + 1) + assert factor_terms(x + (x*y + x)**(3*x + 3)) == \ + x + (x*(y + 1))**_keep_coeff(S(3), x + 1) + assert factor_terms(a*(x + x*y) + b*(x*2 + y*x*2)) == \ + x*(a + 2*b)*(y + 1) + i = Integral(x, (x, 0, oo)) + assert factor_terms(i) == i + + assert factor_terms(x/2 + y) == x/2 + y + # fraction doesn't apply to integer denominators + assert factor_terms(x/2 + y, fraction=True) == x/2 + y + # clear *does* apply to the integer denominators + assert factor_terms(x/2 + y, clear=True) == Mul(S.Half, x + 2*y, evaluate=False) + + # check radical extraction + eq = sqrt(2) + sqrt(10) + assert factor_terms(eq) == eq + assert factor_terms(eq, radical=True) == sqrt(2)*(1 + sqrt(5)) + eq = root(-6, 3) + root(6, 3) + assert factor_terms(eq, radical=True) == 6**(S.One/3)*(1 + (-1)**(S.One/3)) + + eq = [x + x*y] + ans = [x*(y + 1)] + for c in [list, tuple, set]: + assert factor_terms(c(eq)) == c(ans) + assert factor_terms(Tuple(x + x*y)) == Tuple(x*(y + 1)) + assert factor_terms(Interval(0, 1)) == Interval(0, 1) + e = 1/sqrt(a/2 + 1) + assert factor_terms(e, clear=False) == 1/sqrt(a/2 + 1) + assert factor_terms(e, clear=True) == sqrt(2)/sqrt(a + 2) + + eq = x/(x + 1/x) + 1/(x**2 + 1) + assert factor_terms(eq, fraction=False) == eq + assert factor_terms(eq, fraction=True) == 1 + + assert factor_terms((1/(x**3 + x**2) + 2/x**2)*y) == \ + y*(2 + 1/(x + 1))/x**2 + + # if not True, then processesing for this in factor_terms is not necessary + assert gcd_terms(-x - y) == -x - y + assert factor_terms(-x - y) == Mul(-1, x + y, evaluate=False) + + # if not True, then "special" processesing in factor_terms is not necessary + assert gcd_terms(exp(Mul(-1, x + 1))) == exp(-x - 1) + e = exp(-x - 2) + x + assert factor_terms(e) == exp(Mul(-1, x + 2, evaluate=False)) + x + assert factor_terms(e, sign=False) == e + assert factor_terms(exp(-4*x - 2) - x) == -x + exp(Mul(-2, 2*x + 1, evaluate=False)) + + # sum/integral tests + for F in (Sum, Integral): + assert factor_terms(F(x, (y, 1, 10))) == x * F(1, (y, 1, 10)) + assert factor_terms(F(x, (y, 1, 10)) + x) == x * (1 + F(1, (y, 1, 10))) + assert factor_terms(F(x*y + x*y**2, (y, 1, 10))) == x*F(y*(y + 1), (y, 1, 10)) + + # expressions involving Pow terms with base 0 + assert factor_terms(0**(x - 2) - 1) == 0**(x - 2) - 1 + assert factor_terms(0**(x + 2) - 1) == 0**(x + 2) - 1 + assert factor_terms((0**(x + 2) - 1).subs(x,-2)) == 0 + + +def test_xreplace(): + e = Mul(2, 1 + x, evaluate=False) + assert e.xreplace({}) == e + assert e.xreplace({y: x}) == e + + +def test_factor_nc(): + x, y = symbols('x,y') + k = symbols('k', integer=True) + n, m, o = symbols('n,m,o', commutative=False) + + # mul and multinomial expansion is needed + from sympy.core.function import _mexpand + e = x*(1 + y)**2 + assert _mexpand(e) == x + x*2*y + x*y**2 + + def factor_nc_test(e): + ex = _mexpand(e) + assert ex.is_Add + f = factor_nc(ex) + assert not f.is_Add and _mexpand(f) == ex + + factor_nc_test(x*(1 + y)) + factor_nc_test(n*(x + 1)) + factor_nc_test(n*(x + m)) + factor_nc_test((x + m)*n) + factor_nc_test(n*m*(x*o + n*o*m)*n) + s = Sum(x, (x, 1, 2)) + factor_nc_test(x*(1 + s)) + factor_nc_test(x*(1 + s)*s) + factor_nc_test(x*(1 + sin(s))) + factor_nc_test((1 + n)**2) + + factor_nc_test((x + n)*(x + m)*(x + y)) + factor_nc_test(x*(n*m + 1)) + factor_nc_test(x*(n*m + x)) + factor_nc_test(x*(x*n*m + 1)) + factor_nc_test(n*(m/x + o)) + factor_nc_test(m*(n + o/2)) + factor_nc_test(x*n*(x*m + 1)) + factor_nc_test(x*(m*n + x*n*m)) + factor_nc_test(n*(1 - m)*n**2) + + factor_nc_test((n + m)**2) + factor_nc_test((n - m)*(n + m)**2) + factor_nc_test((n + m)**2*(n - m)) + factor_nc_test((m - n)*(n + m)**2*(n - m)) + + assert factor_nc(n*(n + n*m)) == n**2*(1 + m) + assert factor_nc(m*(m*n + n*m*n**2)) == m*(m + n*m*n)*n + eq = m*sin(n) - sin(n)*m + assert factor_nc(eq) == eq + + # for coverage: + from sympy.physics.secondquant import Commutator + from sympy.polys.polytools import factor + eq = 1 + x*Commutator(m, n) + assert factor_nc(eq) == eq + eq = x*Commutator(m, n) + x*Commutator(m, o)*Commutator(m, n) + assert factor(eq) == x*(1 + Commutator(m, o))*Commutator(m, n) + + # issue 6534 + assert (2*n + 2*m).factor() == 2*(n + m) + + # issue 6701 + _n = symbols('nz', zero=False, commutative=False) + assert factor_nc(_n**k + _n**(k + 1)) == _n**k*(1 + _n) + assert factor_nc((m*n)**k + (m*n)**(k + 1)) == (1 + m*n)*(m*n)**k + + # issue 6918 + assert factor_nc(-n*(2*x**2 + 2*x)) == -2*n*x*(x + 1) + + +def test_issue_6360(): + a, b = symbols("a b") + apb = a + b + eq = apb + apb**2*(-2*a - 2*b) + assert factor_terms(sub_pre(eq)) == a + b - 2*(a + b)**3 + + +def test_issue_7903(): + a = symbols(r'a', real=True) + t = exp(I*cos(a)) + exp(-I*sin(a)) + assert t.simplify() + +def test_issue_8263(): + F, G = symbols('F, G', commutative=False, cls=Function) + x, y = symbols('x, y') + expr, dummies, _ = _mask_nc(F(x)*G(y) - G(y)*F(x)) + for v in dummies.values(): + assert not v.is_commutative + assert not expr.is_zero + +def test_monotonic_sign(): + F = _monotonic_sign + x = symbols('x') + assert F(x) is None + assert F(-x) is None + assert F(Dummy(prime=True)) == 2 + assert F(Dummy(prime=True, odd=True)) == 3 + assert F(Dummy(composite=True)) == 4 + assert F(Dummy(composite=True, odd=True)) == 9 + assert F(Dummy(positive=True, integer=True)) == 1 + assert F(Dummy(positive=True, even=True)) == 2 + assert F(Dummy(positive=True, even=True, prime=False)) == 4 + assert F(Dummy(negative=True, integer=True)) == -1 + assert F(Dummy(negative=True, even=True)) == -2 + assert F(Dummy(zero=True)) == 0 + assert F(Dummy(nonnegative=True)) == 0 + assert F(Dummy(nonpositive=True)) == 0 + + assert F(Dummy(positive=True) + 1).is_positive + assert F(Dummy(positive=True, integer=True) - 1).is_nonnegative + assert F(Dummy(positive=True) - 1) is None + assert F(Dummy(negative=True) + 1) is None + assert F(Dummy(negative=True, integer=True) - 1).is_nonpositive + assert F(Dummy(negative=True) - 1).is_negative + assert F(-Dummy(positive=True) + 1) is None + assert F(-Dummy(positive=True, integer=True) - 1).is_negative + assert F(-Dummy(positive=True) - 1).is_negative + assert F(-Dummy(negative=True) + 1).is_positive + assert F(-Dummy(negative=True, integer=True) - 1).is_nonnegative + assert F(-Dummy(negative=True) - 1) is None + x = Dummy(negative=True) + assert F(x**3).is_nonpositive + assert F(x**3 + log(2)*x - 1).is_negative + x = Dummy(positive=True) + assert F(-x**3).is_nonpositive + + p = Dummy(positive=True) + assert F(1/p).is_positive + assert F(p/(p + 1)).is_positive + p = Dummy(nonnegative=True) + assert F(p/(p + 1)).is_nonnegative + p = Dummy(positive=True) + assert F(-1/p).is_negative + p = Dummy(nonpositive=True) + assert F(p/(-p + 1)).is_nonpositive + + p = Dummy(positive=True, integer=True) + q = Dummy(positive=True, integer=True) + assert F(-2/p/q).is_negative + assert F(-2/(p - 1)/q) is None + + assert F((p - 1)*q + 1).is_positive + assert F(-(p - 1)*q - 1).is_negative + +def test_issue_17256(): + from sympy.sets.fancysets import Range + x = Symbol('x') + s1 = Sum(x + 1, (x, 1, 9)) + s2 = Sum(x + 1, (x, Range(1, 10))) + a = Symbol('a') + r1 = s1.xreplace({x:a}) + r2 = s2.xreplace({x:a}) + + assert r1.doit() == r2.doit() + s1 = Sum(x + 1, (x, 0, 9)) + s2 = Sum(x + 1, (x, Range(10))) + a = Symbol('a') + r1 = s1.xreplace({x:a}) + r2 = s2.xreplace({x:a}) + assert r1 == r2 + +def test_issue_21623(): + from sympy.matrices.expressions.matexpr import MatrixSymbol + M = MatrixSymbol('X', 2, 2) + assert gcd_terms(M[0,0], 1) == M[0,0] diff --git a/shared/package-files/2f/2fb9b38eba1d1b12b464d7828efc94a3c8306599909bbc7db311fab71d96d061/blob b/shared/package-files/2f/2fb9b38eba1d1b12b464d7828efc94a3c8306599909bbc7db311fab71d96d061/blob new file mode 100644 index 0000000000000000000000000000000000000000..484d093d1d76d6da9c0f3daccaf708d2b7ff08d4 --- /dev/null +++ b/shared/package-files/2f/2fb9b38eba1d1b12b464d7828efc94a3c8306599909bbc7db311fab71d96d061/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2fb9b38eba1d1b12b464d7828efc94a3c8306599909bbc7db311fab71d96d061 +size 182352 diff --git a/shared/package-files/2f/2fbc0738b7c3a0cd2168ef72890eb0b1f236d6464d5c2cebfcdb810382893891/blob b/shared/package-files/2f/2fbc0738b7c3a0cd2168ef72890eb0b1f236d6464d5c2cebfcdb810382893891/blob new file mode 100644 index 0000000000000000000000000000000000000000..a83244d6771e237ae3272c0b9e7e6053d032dfdd --- /dev/null +++ b/shared/package-files/2f/2fbc0738b7c3a0cd2168ef72890eb0b1f236d6464d5c2cebfcdb810382893891/blob @@ -0,0 +1,1220 @@ +"""Correlation plot functions""" + +import calendar +from typing import TYPE_CHECKING + +import numpy as np +import pandas as pd + +from statsmodels.graphics import utils +from statsmodels.tools.validation import array_like +from statsmodels.tsa.stattools import acf, ccf, pacf, pccf + +if TYPE_CHECKING: + from statsmodels.tsa.base.prediction import PredictionResults + + +def _prepare_data_corr_plot(x, lags, zero): + """ + Compute the lags to plot and whether they are regularly spaced + + Parameters + ---------- + x : array_like + Array of time-series values. + lags : int, array_like, or None + An int or array of lag values, or None to use a sensible default + based on the number of observations in `x`. + zero : bool + Flag indicating whether to include the 0-lag value. + + Returns + ------- + lags : ndarray + The array of lag values to plot. + nlags : int + The maximum lag value. + irregular : bool + True if `lags` was given as an explicit, possibly non-contiguous, + array of lag values. + """ + zero = bool(zero) + irregular = False if zero else True + if lags is None: + # GH 4663 - use a sensible default value + nobs = x.shape[0] + lim = min(int(np.ceil(10 * np.log10(nobs))), nobs // 2) + lags = np.arange(not zero, lim + 1) + elif np.isscalar(lags): + lags = np.arange(not zero, int(lags) + 1) # +1 for zero lag + else: + irregular = True + lags = np.asanyarray(lags).astype(int) + nlags = lags.max(0) + + return lags, nlags, irregular + + +def _plot_corr( + ax, + title, + acf_x, + confint, + lags, + irregular, + use_vlines, + vlines_kwargs, + auto_ylims=False, + skip_lag0_confint=True, + **kwargs, +): + """ + Plot the values in `acf_x`, optionally with vertical lines and a + confidence band + + Parameters + ---------- + ax : AxesSubplot + The subplot to plot in. + title : str + Title to place on plot. + acf_x : ndarray + The correlation values to plot, one per lag. + confint : ndarray, optional + The confidence interval bounds for each lag in `acf_x`, or None + if no confidence band should be drawn. + lags : ndarray + The lag values to use on the horizontal axis. + irregular : bool + If True, `acf_x` and `confint` are indexed with `lags` before + plotting (they contain values for a superset of the requested + lags). + use_vlines : bool + If True, vertical lines and markers are plotted. If False, only + markers are plotted. + vlines_kwargs : dict + Keyword arguments passed to ``ax.vlines``. + auto_ylims : bool, optional + If True, adjusts automatically the y-axis limits to the values + in `acf_x` and `confint`. + skip_lag0_confint : bool, optional + If True, the confidence interval is not drawn for the 0 lag. + **kwargs + Additional keyword arguments passed to ``ax.plot`` and + ``ax.axhline``. + """ + if irregular: + acf_x = acf_x[lags] + if confint is not None: + confint = confint[lags] + + if use_vlines: + ax.vlines(lags, [0], acf_x, **vlines_kwargs) + ax.axhline(**kwargs) + + kwargs.setdefault("marker", "o") + kwargs.setdefault("markersize", 5) + if "ls" not in kwargs: + # gh-2369 + kwargs.setdefault("linestyle", "None") + ax.margins(0.05) + ax.plot(lags, acf_x, **kwargs) + ax.set_title(title) + + ax.set_ylim(-1, 1) + if auto_ylims: + lower = np.minimum(0, min(acf_x)) + upper = np.maximum(0, max(acf_x)) + if confint is not None: + lower = np.minimum(lower, min(confint[:, 0] - acf_x)) + upper = np.maximum(upper, max(confint[:, 1] - acf_x)) + if lower == upper: + lower, upper = -1, 1 + ax.set_ylim( + 1.25 * lower, + 1.25 * upper, + ) + + if confint is not None: + if skip_lag0_confint and lags[0] == 0: + lags = lags[1:] + confint = confint[1:] + acf_x = acf_x[1:] + lags = lags.astype(float) + lags[np.argmin(lags)] -= 0.5 + lags[np.argmax(lags)] += 0.5 + ax.fill_between(lags, confint[:, 0] - acf_x, confint[:, 1] - acf_x, alpha=0.25) + + +def plot_acf( + x, + ax=None, + lags=None, + *, + alpha=0.05, + use_vlines=True, + adjusted=False, + fft=False, + missing="none", + title="Autocorrelation", + zero=True, + auto_ylims=False, + bartlett_confint=True, + vlines_kwargs=None, + **kwargs, +): + """ + Plot the autocorrelation function + + Plots lags on the horizontal and the correlations on vertical axis. + + Parameters + ---------- + x : array_like + Array of time-series values + ax : AxesSubplot, optional + If given, this subplot is used to plot in instead of a new figure being + created. + lags : int or array_like, optional + An int or array of lag values, used on horizontal axis. Uses + np.arange(lags) when lags is an int. If not provided, + ``lags=np.arange(len(corr))`` is used. + alpha : float or None, optional + If a number is given, the confidence intervals for the given level are + returned. For instance if alpha=.05, 95 % confidence intervals are + returned where the standard deviation is computed according to + Bartlett's formula. The confidence intervals centered at 0 to simplify + detecting which estimated autocorrelations are significantly + different from 0. If None, no confidence intervals are plotted. + use_vlines : bool, optional + If True, vertical lines and markers are plotted. + If False, only markers are plotted. The default marker is 'o'; it can + be overridden with a ``marker`` kwarg. + adjusted : bool, optional + If True, then denominators for autocovariance are n-k, otherwise n + fft : bool, optional + If True, computes the ACF via FFT. + missing : str, optional + A string in ['none', 'raise', 'conservative', 'drop'] specifying how + the NaNs are to be treated. + title : str, optional + Title to place on plot. Default is 'Autocorrelation' + zero : bool, optional + Flag indicating whether to include the 0-lag autocorrelation. + Default is True. + auto_ylims : bool, optional + If True, adjusts automatically the y-axis limits to ACF values. + bartlett_confint : bool, optional + Confidence intervals for ACF values are generally placed at 2 + standard errors around r_k. The formula used for standard error + depends upon the situation. If the autocorrelations are being used + to test for randomness of residuals as part of the ARIMA routine, + the standard errors are determined assuming the residuals are white + noise. The approximate formula for any lag is that standard error + of each r_k = 1/sqrt(N). See section 9.4 of [1]_ for more details on + the 1/sqrt(N) result. For more elementary discussion, see section + 5.3.2 in [2]_. + For the ACF of raw data, the standard error at a lag k is + found as if the right model was an MA(k-1). This allows the + possible interpretation that if all autocorrelations past a + certain lag are within the limits, the model might be an MA of + order defined by the last significant autocorrelation. In this + case, a moving average model is assumed for the data and the + standard errors for the confidence intervals should be + generated using Bartlett's formula. For more details on + Bartlett formula result, see section 7.2 in [1]_. + vlines_kwargs : dict, optional + Optional dictionary of keyword arguments that are passed to vlines. + **kwargs + Optional keyword arguments that are directly passed on to the + Matplotlib ``plot`` and ``axhline`` functions. + + Returns + ------- + Figure + If `ax` is None, the created figure. Otherwise the figure to which + `ax` is connected. + + See Also + -------- + statsmodels.tsa.stattools.acf + matplotlib.pyplot.xcorr + matplotlib.pyplot.acorr + + Notes + ----- + Adapted from matplotlib's `xcorr`. + + Data are plotted as ``plot(lags, corr, **kwargs)`` + + kwargs is used to pass matplotlib optional arguments to both the line + tracing the autocorrelations and for the horizontal line at 0. These + options must be valid for a Line2D object. + + vlines_kwargs is used to pass additional optional arguments to the + vertical lines connecting each autocorrelation to the axis. These options + must be valid for a LineCollection object. + + References + ---------- + .. [1] Brockwell and Davis, 1987. Time Series Theory and Methods + .. [2] Brockwell and Davis, 2010. Introduction to Time Series and + Forecasting, 2nd edition. + + Examples + -------- + >>> import pandas as pd + >>> import matplotlib.pyplot as plt + >>> import statsmodels.api as sm + + >>> dta = sm.datasets.sunspots.load_pandas().data + >>> dta.index = pd.Index(sm.tsa.datetools.dates_from_range('1700', '2008')) + >>> del dta["YEAR"] + >>> sm.graphics.tsa.plot_acf(dta.values.squeeze(), lags=40) + >>> plt.show() + + .. plot:: plots/graphics_tsa_plot_acf.py + """ + fig, ax = utils.create_mpl_ax(ax) + + lags, nlags, irregular = _prepare_data_corr_plot(x, lags, zero) + vlines_kwargs = {} if vlines_kwargs is None else vlines_kwargs + + acf_res = acf( + x, + nlags=nlags, + alpha=alpha, + fft=fft, + bartlett_confint=bartlett_confint, + adjusted=adjusted, + missing=missing, + result_object=True, + ) + # result_object=True always yields an AcfResult; confint is None when + # alpha is None. + acf_x, confint = acf_res.acf, acf_res.confint + + _plot_corr( + ax, + title, + acf_x, + confint, + lags, + irregular, + use_vlines, + vlines_kwargs, + auto_ylims=auto_ylims, + **kwargs, + ) + + return fig + + +def plot_pacf( + x, + ax=None, + lags=None, + alpha=0.05, + method="ywm", + use_vlines=True, + title="Partial Autocorrelation", + zero=True, + vlines_kwargs=None, + **kwargs, +): + """ + Plot the partial autocorrelation function + + Parameters + ---------- + x : array_like + Array of time-series values + ax : AxesSubplot, optional + If given, this subplot is used to plot in instead of a new figure being + created. + lags : int or array_like, optional + An int or array of lag values, used on horizontal axis. Uses + np.arange(lags) when lags is an int. If not provided, + ``lags=np.arange(len(corr))`` is used. + alpha : float or None, optional + If a number is given, the confidence intervals for the given level are + returned. For instance if alpha=.05, 95 % confidence intervals are + returned where the standard deviation is computed according to + 1/sqrt(len(x)). If None, no confidence intervals are plotted. + method : str, optional + Specifies which method for the calculations to use: + + - "ywm" or "ywmle" : Yule-Walker without adjustment. Default. + - "yw" or "ywadjusted" : Yule-Walker with sample-size adjustment in + denominator for acovf. + - "ols" : regression of time series on lags of it and on constant. + - "ols-inefficient" : regression of time series on lags using a single + common sample to estimate all pacf coefficients. + - "ols-adjusted" : regression of time series on lags with a bias + adjustment. + - "ld" or "ldadjusted" : Levinson-Durbin recursion with bias + correction. + - "ldb" or "ldbiased" : Levinson-Durbin recursion without bias + correction. + - "burg" : Burg's partial autocorrelation estimator. + + use_vlines : bool, optional + If True, vertical lines and markers are plotted. + If False, only markers are plotted. The default marker is 'o'; it can + be overridden with a ``marker`` kwarg. + title : str, optional + Title to place on plot. Default is 'Partial Autocorrelation' + zero : bool, optional + Flag indicating whether to include the 0-lag autocorrelation. + Default is True. + vlines_kwargs : dict, optional + Optional dictionary of keyword arguments that are passed to vlines. + **kwargs + Optional keyword arguments that are directly passed on to the + Matplotlib ``plot`` and ``axhline`` functions. + + Returns + ------- + Figure + If `ax` is None, the created figure. Otherwise the figure to which + `ax` is connected. + + See Also + -------- + statsmodels.tsa.stattools.pacf + matplotlib.pyplot.xcorr + matplotlib.pyplot.acorr + + Notes + ----- + Plots lags on the horizontal and the correlations on vertical axis. + Adapted from matplotlib's `xcorr`. + + Data are plotted as ``plot(lags, corr, **kwargs)`` + + kwargs is used to pass matplotlib optional arguments to both the line + tracing the autocorrelations and for the horizontal line at 0. These + options must be valid for a Line2D object. + + vlines_kwargs is used to pass additional optional arguments to the + vertical lines connecting each autocorrelation to the axis. These options + must be valid for a LineCollection object. + + Examples + -------- + >>> import pandas as pd + >>> import matplotlib.pyplot as plt + >>> import statsmodels.api as sm + + >>> dta = sm.datasets.sunspots.load_pandas().data + >>> dta.index = pd.Index(sm.tsa.datetools.dates_from_range('1700', '2008')) + >>> del dta["YEAR"] + >>> sm.graphics.tsa.plot_pacf(dta.values.squeeze(), lags=40, method="ywm") + >>> plt.show() + + .. plot:: plots/graphics_tsa_plot_pacf.py + """ + fig, ax = utils.create_mpl_ax(ax) + vlines_kwargs = {} if vlines_kwargs is None else vlines_kwargs + lags, nlags, irregular = _prepare_data_corr_plot(x, lags, zero) + + result = pacf( + x, nlags=nlags, alpha=alpha, method=method, result_object=True + ) + # result_object=True always yields a PacfResult; confint is None when + # alpha is None. + acf_x, confint = result.pacf, result.confint + + _plot_corr( + ax, + title, + acf_x, + confint, + lags, + irregular, + use_vlines, + vlines_kwargs, + **kwargs, + ) + + return fig + + +def plot_ccf( + x, + y, + *, + ax=None, + lags=None, + negative_lags=False, + alpha=0.05, + use_vlines=True, + adjusted=False, + fft=False, + title="Cross-correlation", + auto_ylims=False, + vlines_kwargs=None, + **kwargs, +): + """ + Plot the cross-correlation function + + Correlations between ``x`` and the lags of ``y`` are calculated. + + The lags are shown on the horizontal axis and the correlations + on the vertical axis. + + Parameters + ---------- + x, y : array_like + Arrays of time-series values. + ax : AxesSubplot, optional + If given, this subplot is used to plot in, otherwise a new figure with + one subplot is created. + lags : int or array_like, optional + An int or array of lag values, used on the horizontal axis. Uses + ``np.arange(lags)`` when lags is an int. If not provided, + ``lags=np.arange(len(corr))`` is used. + negative_lags : bool, optional + If True, negative lags are shown on the horizontal axis. + alpha : float or None, optional + If a number is given, the confidence intervals for the given level are + plotted, e.g., if alpha=.05, 95 % confidence intervals are shown. + If None, confidence intervals are not shown on the plot. + use_vlines : bool, optional + If True, shows vertical lines and markers for the correlation values. + If False, only shows markers. The default marker is 'o'; it can + be overridden with a ``marker`` kwarg. + adjusted : bool, optional + If True, then denominators for cross-correlations are n-k, otherwise n. + fft : bool, optional + If True, computes the CCF via FFT. + title : str, optional + Title to place on plot. Default is 'Cross-correlation'. + auto_ylims : bool, optional + If True, adjusts automatically the vertical axis limits to CCF values. + vlines_kwargs : dict, optional + Optional dictionary of keyword arguments that are passed to vlines. + **kwargs + Optional keyword arguments that are directly passed on to the + Matplotlib ``plot`` and ``axhline`` functions. + + Returns + ------- + Figure + The figure where the plot is drawn. This is either an existing figure + if the `ax` argument is provided, or a newly created figure + if `ax` is None. + + See Also + -------- + statsmodels.graphics.tsaplots.plot_acf + + Examples + -------- + >>> import pandas as pd + >>> import matplotlib.pyplot as plt + >>> import statsmodels.api as sm + + >>> dta = sm.datasets.macrodata.load_pandas().data + >>> diffed = dta.diff().dropna() + >>> sm.graphics.tsa.plot_ccf(diffed["unemp"], diffed["infl"]) + >>> plt.show() + """ + fig, ax = utils.create_mpl_ax(ax) + + lags, nlags, irregular = _prepare_data_corr_plot(x, lags, True) + vlines_kwargs = {} if vlines_kwargs is None else vlines_kwargs + + if negative_lags: + lags = -lags + + ccf_res = ccf( + x, + y, + adjusted=adjusted, + fft=fft, + alpha=alpha, + nlags=nlags + 1, + result_object=True, + ) + # result_object=True always yields a CcfResult; confint is None when + # alpha is None. + ccf_xy, confint = ccf_res.ccf, ccf_res.confint + + _plot_corr( + ax, + title, + ccf_xy, + confint, + lags, + irregular, + use_vlines, + vlines_kwargs, + auto_ylims=auto_ylims, + skip_lag0_confint=False, + **kwargs, + ) + + return fig + + +def plot_pccf( + x, + y, + *, + ax=None, + lags=None, + method="ywm", + alpha=0.05, + use_vlines=True, + title="Partial Cross-correlation", + auto_ylims=False, + vlines_kwargs=None, + **kwargs, +): + """ + Plot the partial cross-correlation function + + Partial cross-correlations between ``x`` and the lags of ``y`` + are calculated. + + The lags are shown on the horizontal axis and the partial + cross-correlations on the vertical axis. + + Parameters + ---------- + x, y : array_like + Arrays of time-series values. + ax : AxesSubplot, optional + If given, this subplot is used to plot in, otherwise a new + figure with one subplot is created. + lags : int or array_like, optional + An int or array of lag values, used on the horizontal axis. + Uses ``np.arange(lags)`` when lags is an int. If not + provided, ``lags=np.arange(len(corr))`` is used. + method : str, optional + Specifies which method for the calculations to use. + + - "ywm", "ywmle" or "yw_mle" : Yule-Walker via the + multivariate Levinson-Durbin recursion without sample-size + adjustment in the autocovariance denominator. Default. + - "yw", "ywa", "ywadjusted" or "yw_adjusted" : Yule-Walker + via the multivariate Levinson-Durbin recursion with + sample-size adjustment in the autocovariance denominator. + - "ols" : OLS regression of x_t and y_{t+h} on all + intervening observations. + alpha : float or None, optional + If a number is given, the confidence intervals for the + given level are plotted, e.g., if alpha=.05, 95 % + confidence intervals are shown. + If None, confidence intervals are not shown on the plot. + use_vlines : bool, optional + If True, shows vertical lines and markers for the + correlation values. If False, only shows markers. The + default marker is 'o'; it can be overridden with a + ``marker`` kwarg. + title : str, optional + Title to place on plot. Default is + 'Partial Cross-correlation'. + auto_ylims : bool, optional + If True, adjusts automatically the vertical axis limits + to PCCF values. + vlines_kwargs : dict, optional + Optional dictionary of keyword arguments that are passed + to vlines. + **kwargs + Optional keyword arguments that are directly passed on to + the Matplotlib ``plot`` and ``axhline`` functions. + + Returns + ------- + Figure + The figure where the plot is drawn. This is either an + existing figure if the `ax` argument is provided, or a + newly created figure if `ax` is None. + + See Also + -------- + statsmodels.graphics.tsaplots.plot_ccf + statsmodels.graphics.tsaplots.plot_pacf + statsmodels.graphics.tsaplots.plot_acf + + Examples + -------- + >>> import pandas as pd + >>> import matplotlib.pyplot as plt + >>> import statsmodels.api as sm + + >>> dta = sm.datasets.macrodata.load_pandas().data + >>> diffed = dta.diff().dropna() + >>> sm.graphics.tsa.plot_pccf( + ... diffed["unemp"], diffed["infl"] + ... ) + >>> plt.show() + """ + fig, ax = utils.create_mpl_ax(ax) + + lags, nlags, irregular = _prepare_data_corr_plot(x, lags, True) + vlines_kwargs = {} if vlines_kwargs is None else vlines_kwargs + + pccf_res = pccf( + x, y, alpha=alpha, nlags=nlags, method=method, result_object=True + ) + # result_object=True always yields a PccfResult; confint is None when + # alpha is None. + pccf_xy, confint = pccf_res.pccf, pccf_res.confint + + if irregular: + lags = lags[lags > 0] + pccf_xy = pccf_xy[lags - 1] + if confint is not None: + confint = confint[lags - 1] + irregular = False + else: + lags = lags[1 : nlags + 1] + + _plot_corr( + ax, + title, + pccf_xy, + confint, + lags, + irregular, + use_vlines, + vlines_kwargs, + auto_ylims=auto_ylims, + skip_lag0_confint=False, + **kwargs, + ) + + return fig + + +def plot_accf_grid( + x, + *, + varnames=None, + fig=None, + lags=None, + negative_lags=True, + alpha=0.05, + use_vlines=True, + adjusted=False, + fft=False, + missing="none", + zero=True, + auto_ylims=False, + bartlett_confint=False, + vlines_kwargs=None, + **kwargs, +): + """ + Plot auto/cross-correlation grid + + Plots lags on the horizontal axis and the correlations + on the vertical axis of each graph. + + Parameters + ---------- + x : array_like + 2D array of time-series values: rows are observations, + columns are variables. + varnames : sequence of str, optional + Variable names to use in plot titles. If ``x`` is a pandas dataframe + and ``varnames`` is provided, it overrides the column names + of the dataframe. If ``varnames`` is not provided and ``x`` is not + a dataframe, variable names ``x[0]``, ``x[1]``, etc. are generated. + fig : Figure, optional + If given, this figure is used to plot in, otherwise a new figure + is created. + lags : int or array_like, optional + An int or array of lag values, used on horizontal axes. Uses + ``np.arange(lags)`` when lags is an int. If not provided, + ``lags=np.arange(len(corr))`` is used. + negative_lags : bool, optional + If True, negative lags are shown on the horizontal axes of plots + below the main diagonal. + alpha : float or None, optional + If a number is given, the confidence intervals for the given level are + plotted, e.g., if alpha=.05, 95 % confidence intervals are shown. + If None, confidence intervals are not shown on the plot. + use_vlines : bool, optional + If True, shows vertical lines and markers for the correlation values. + If False, only shows markers. The default marker is 'o'; it can + be overridden with a ``marker`` kwarg. + adjusted : bool, optional + If True, then denominators for correlations are n-k, otherwise n. + fft : bool, optional + If True, computes the ACF via FFT. + missing : str, optional + A string in ['none', 'raise', 'conservative', 'drop'] specifying how + NaNs are to be treated. + zero : bool, optional + Flag indicating whether to include the 0-lag autocorrelations + (which are always equal to 1). Default is True. + auto_ylims : bool, optional + If True, adjusts automatically the vertical axis limits + to correlation values. + bartlett_confint : bool, optional + If True, use Bartlett's formula to calculate confidence intervals + in auto-correlation plots. See the description of ``plot_acf`` for + details. This argument does not affect cross-correlation plots. + vlines_kwargs : dict, optional + Optional dictionary of keyword arguments that are passed to vlines. + **kwargs + Optional keyword arguments that are directly passed on to the + Matplotlib ``plot`` and ``axhline`` functions. + + Returns + ------- + Figure + If `fig` is None, the created figure. Otherwise, `fig` is returned. + Plots on the grid show the cross-correlation of the row variable + with the lags of the column variable. + + See Also + -------- + statsmodels.graphics.tsaplots.plot_acf + statsmodels.graphics.tsaplots.plot_ccf + + Examples + -------- + >>> import pandas as pd + >>> import matplotlib.pyplot as plt + >>> import statsmodels.api as sm + + >>> dta = sm.datasets.macrodata.load_pandas().data + >>> diffed = dta.diff().dropna() + >>> sm.graphics.tsa.plot_accf_grid(diffed[["unemp", "infl"]]) + >>> plt.show() + """ + from statsmodels.tools.data import _is_using_pandas + + array_like(x, "x", ndim=2) + m = x.shape[1] + + fig = utils.create_mpl_fig(fig) + gs = fig.add_gridspec(m, m) + + if _is_using_pandas(x, None): + varnames = varnames or list(x.columns) + + def get_var(i): + return x.iloc[:, i] + + else: + varnames = varnames or [f"x[{i}]" for i in range(m)] + + x = np.asarray(x) + + def get_var(i): + return x[:, i] + + for i in range(m): + for j in range(m): + ax = fig.add_subplot(gs[i, j]) + if i == j: + plot_acf( + get_var(i), + ax=ax, + title=f"ACF({varnames[i]})", + lags=lags, + alpha=alpha, + use_vlines=use_vlines, + adjusted=adjusted, + fft=fft, + missing=missing, + zero=zero, + auto_ylims=auto_ylims, + bartlett_confint=bartlett_confint, + vlines_kwargs=vlines_kwargs, + **kwargs, + ) + else: + plot_ccf( + get_var(i), + get_var(j), + ax=ax, + title=f"CCF({varnames[i]}, {varnames[j]})", + lags=lags, + negative_lags=negative_lags and i > j, + alpha=alpha, + use_vlines=use_vlines, + adjusted=adjusted, + fft=fft, + auto_ylims=auto_ylims, + vlines_kwargs=vlines_kwargs, + **kwargs, + ) + + return fig + + +def seasonal_plot(grouped_x, xticklabels, ylabel=None, ax=None): + """ + Consider using one of month_plot or quarter_plot unless you need + irregular plotting + + Parameters + ---------- + grouped_x : iterable of DataFrames + Should be a GroupBy object (or similar pair of group_names and groups + as DataFrames) with a DatetimeIndex or PeriodIndex + xticklabels : list of str + List of season labels, one for each group. + ylabel : str, optional + Label for y axis + ax : AxesSubplot, optional + If given, this subplot is used to plot in instead of a new figure being + created. + + Returns + ------- + Figure + If `ax` is None, the created figure. Otherwise the figure to which + `ax` is connected. + """ + fig, ax = utils.create_mpl_ax(ax) + start = 0 + ticks = [] + for _, df in grouped_x: + df = df.copy() # or sort balks for series. may be better way + df.sort_index() + nobs = len(df) + x_plot = np.arange(start, start + nobs) + ticks.append(x_plot.mean()) + ax.plot(x_plot, df.values, "k") + ax.hlines(df.values.mean(), x_plot[0], x_plot[-1], colors="r", linewidth=3) + start += nobs + + ax.set_xticks(ticks) + ax.set_xticklabels(xticklabels) + ax.set_ylabel(ylabel) + ax.margins(0.1, 0.05) + return fig + + +def month_plot(x, dates=None, ylabel=None, ax=None): + """ + Seasonal plot of monthly data + + Parameters + ---------- + x : array_like + Seasonal data to plot. If dates is None, x must be a pandas object + with a PeriodIndex or DatetimeIndex with a monthly frequency. + dates : array_like, optional + If `x` is not a pandas object, then dates must be supplied. + ylabel : str, optional + The label for the y-axis. Will attempt to use the `name` attribute + of the Series. + ax : Axes, optional + Existing axes instance. + + Returns + ------- + Figure + If `ax` is provided, the Figure instance attached to `ax`. Otherwise + a new Figure instance. + + Examples + -------- + >>> import statsmodels.api as sm + >>> import pandas as pd + + >>> dta = sm.datasets.elnino.load_pandas().data + >>> dta['YEAR'] = dta.YEAR.astype(int).astype(str) + >>> dta = dta.set_index('YEAR').T.unstack() + >>> dates = pd.to_datetime(list(map(lambda x: '-'.join(x) + '-1', + ... dta.index.values))) + >>> dta.index = pd.DatetimeIndex(dates, freq='MS') + >>> fig = sm.graphics.tsa.month_plot(dta) + + .. plot:: plots/graphics_tsa_month_plot.py + """ + + if dates is None: + from statsmodels.tools.data import _check_period_index + + _check_period_index(x, freq="M") + else: + x = pd.Series(x, index=pd.PeriodIndex(dates, freq="M")) + + # there's no zero month + xticklabels = list(calendar.month_abbr)[1:] + return seasonal_plot( + x.groupby(lambda y: y.month), xticklabels, ylabel=ylabel, ax=ax + ) + + +def quarter_plot(x, dates=None, ylabel=None, ax=None): + """ + Seasonal plot of quarterly data + + Parameters + ---------- + x : array_like + Seasonal data to plot. If dates is None, x must be a pandas object + with a PeriodIndex or DatetimeIndex with a monthly frequency. + dates : array_like, optional + If `x` is not a pandas object, then dates must be supplied. + ylabel : str, optional + The label for the y-axis. Will attempt to use the `name` attribute + of the Series. + ax : Axes, optional + Existing axes instance. + + Returns + ------- + Figure + If `ax` is provided, the Figure instance attached to `ax`. Otherwise + a new Figure instance. + + Examples + -------- + >>> import statsmodels.api as sm + >>> import pandas as pd + + >>> dta = sm.datasets.elnino.load_pandas().data + >>> dta['YEAR'] = dta.YEAR.astype(int).astype(str) + >>> dta = dta.set_index('YEAR').T.unstack() + >>> dates = pd.to_datetime(list(map(lambda x: '-'.join(x) + '-1', + ... dta.index.values))) + >>> dta.index = dates.to_period('Q') + >>> fig = sm.graphics.tsa.quarter_plot(dta) + + .. plot:: plots/graphics_tsa_quarter_plot.py + """ + + if dates is None: + from statsmodels.tools.data import _check_period_index + + _check_period_index(x, freq="Q") + else: + x = pd.Series(x, index=pd.PeriodIndex(dates, freq="Q")) + + xticklabels = ["q1", "q2", "q3", "q4"] + return seasonal_plot( + x.groupby(lambda y: y.quarter), xticklabels, ylabel=ylabel, ax=ax + ) + + +def plot_predict( + result, + start=None, + end=None, + dynamic=False, + alpha=0.05, + ax=None, + **predict_kwargs, +): + """ + Plot forecasts + + Parameters + ---------- + result : Result + Any model result supporting ``get_prediction``. + start : int, str, or datetime, optional + Zero-indexed observation number at which to start forecasting, + i.e., the first forecast is start. Can also be a date string to + parse or a datetime type. Default is the zeroth observation. + end : int, str, or datetime, optional + Zero-indexed observation number at which to end forecasting, i.e., + the last forecast is end. Can also be a date string to + parse or a datetime type. However, if the dates index does not + have a fixed frequency, end must be an integer index if you + want out of sample prediction. Default is the last observation in + the sample. + dynamic : bool, int, str, or datetime, optional + Integer offset relative to `start` at which to begin dynamic + prediction. Can also be an absolute date string to parse or a + datetime type (these are not interpreted as offsets). + Prior to this observation, true endogenous values will be used for + prediction; starting with this observation and continuing through + the end of prediction, forecasted endogenous values will be used + instead. + alpha : float or None, optional + The tail probability not covered by the confidence interval. Must + be in (0, 1). Confidence interval is constructed assuming normally + distributed shocks. If None, figure will not show the confidence + interval. + ax : AxesSubplot, optional + matplotlib Axes instance to use + **predict_kwargs + Any additional keyword arguments to pass to ``result.get_prediction``. + + Returns + ------- + Figure + matplotlib Figure containing the prediction plot + """ + from statsmodels.graphics.utils import _import_mpl, create_mpl_ax + + _ = _import_mpl() + fig, ax = create_mpl_ax(ax) + + # use predict so you set dates + pred: PredictionResults = result.get_prediction( + start=start, end=end, dynamic=dynamic, **predict_kwargs + ) + mean = pred.predicted_mean + if isinstance(mean, (pd.Series, pd.DataFrame)): + x = mean.index + mean.plot(ax=ax, label="forecast") + else: + x = np.arange(mean.shape[0]) + ax.plot(x, mean, label="forecast") + + if alpha is not None: + label = f"{1 - alpha:.0%} confidence interval" + ci = pred.conf_int(alpha=alpha) + conf_int = np.asarray(ci) + + ax.fill_between( + x, + conf_int[:, 0], + conf_int[:, 1], + color="gray", + alpha=0.5, + label=label, + ) + + ax.legend(loc="best") + + return fig + + +def seasonal_diagnostic_plot(x, period, subplots=None, labels=None, nrows=1, **kwargs): + """ + Seasonal-Diagnostic Plot, as described by [1]_ + + Parameters + ---------- + x : DecomposeResult + The result of your seasonal decomposition. + period : int + The length of the period. Should match the `period` parameter used to + decompose the series. + subplots : int, list of int, or ndarray of int, optional + If `period` is large, `subplots` can be used to specify how many should + be plotted. If `subplots` is an `int`, the periods are selected evenly + from `range(period)`. If `subplots` is a list or ndarray of `int`, the + periods with those indices will be selected for the subplots. By + default, `subplots=period`. + labels : sequence of str, optional + Labels for the displayed period subplots. + nrows : int, optional + The number of rows on which to display the plots. + **kwargs + Additional keyword arguments passed to ``plt.subplots``, such as + ``figsize`` or ``ncols``. + + Returns + ------- + fig : Figure + Returns a matplotlib object of type Figure with the + Seasonal-Diagnostic Plot. + + Examples + -------- + >>> from statsmodels.datasets import co2 + >>> from statsmodels.tsa.seasonal import STL + >>> from statsmodels.graphics.tsaplots import seasonal_diagnostic_plot + + >>> data = (co2.load().data + ... .loc[lambda df: df.index.isocalendar().week<53] + ... .loc['1986-01-01':] + ... ) + + >>> res = STL(data, period=52, seasonal=21).fit() + >>> _ = seasonal_diagnostic_plot(res, period=52, subplots=6, nrows=2) + + .. plot:: plots/graphics_tsa_plot_sdp1.py + + >>> from statsmodels.datasets import elnino + >>> from statsmodels.tsa.seasonal import STL + >>> from statsmodels.graphics.tsaplots import seasonal_diagnostic_plot + >>> import pandas as pd + + >>> month_dict = {'JAN':1, 'FEB':2, 'MAR':3, 'APR':4, 'MAY':5, 'JUN':6, + ... 'JUL':7, 'AUG':8, 'SEP':9, 'OCT':10, 'NOV':11, 'DEC':12} + >>> data = (elnino.load().data + ... .rename(columns=month_dict) + ... .melt(id_vars=['YEAR'], var_name='month') + ... .assign(day=1, + ... date = lambda df: pd.to_datetime( + ... df[['YEAR', 'month', 'day']])) + ... .drop(columns=['YEAR', 'month', 'day']) + ... .set_index('date') + ... .sort_index() + ... ) + + >>> res = STL(data, period=12, seasonal=53).fit() + >>> labels=['January', 'February', 'March', 'November'] + >>> _ = seasonal_diagnostic_plot(res, period=12, subplots=[0,1,2,10], + ... labels=labels, nrows=2) + + .. plot:: plots/graphics_tsa_plot_sdp2.py + + References + ---------- + .. [1] Cleveland, Robert B., William S. Cleveland, Jean E. McRae, Irma + Terpenning (1990) "STL: A Seasonal-Trend Decomposition Procedure + Based on Loess". Journal of Official Statistics, 6 (1), 3-33. + """ + plt = utils._import_mpl() + + def seasonplot(x, period, period_length, ax=None): + + where = [ + period_length * i + period for i in range(x.seasonal.size // period_length) + ] + seasonal_k = x.seasonal.iloc[where] + residual_k = x.resid.iloc[where] + mean = seasonal_k.mean() + + ax.plot(seasonal_k.index, seasonal_k + residual_k - mean, ".") + ax.plot(seasonal_k.index, seasonal_k - mean) + return ax + + if subplots is None: + subplots = period + + if isinstance(subplots, int): + if subplots > period: + raise ValueError("subplots cannot be larger than period.") + p_to_plot = np.floor(np.arange(subplots) * period / subplots).astype(int) + elif isinstance(subplots, (list, np.ndarray)) and all( + isinstance(i, int) for i in subplots + ): + p_to_plot = subplots + subplots = len(p_to_plot) + else: + raise TypeError("subplots must be either an int or a list of ints.") + + if labels is None: + labels = [f"Cycle-subseries {int(i + 1)}" for i in p_to_plot] + elif len(labels) != subplots: + raise ValueError( + "The number of labels does not match the number of periods to plot." + ) + + kwargs.setdefault("ncols", np.ceil(subplots / nrows).astype(int)) + kwargs.setdefault("figsize", (kwargs["ncols"] * 2, nrows * 2 + 0.5)) + fig, axs = plt.subplots( + sharex=True, sharey=True, squeeze=False, nrows=nrows, **kwargs + ) + + for i, ax in enumerate(fig.get_axes()): + if i < subplots: + ax = seasonplot(x, p_to_plot[i], period, ax=ax) + ax.set_title(str(labels[i])) + ax.set(xlabel="", ylabel="") + else: + fig.delaxes(ax) + continue + + fig.tight_layout(w_pad=0.1) + return fig diff --git a/shared/package-files/2f/2fbf3905d18dcba8e6899424c9ba60c25bce67893e84a22fbb8ea6a4a8a29b2e/blob b/shared/package-files/2f/2fbf3905d18dcba8e6899424c9ba60c25bce67893e84a22fbb8ea6a4a8a29b2e/blob new file mode 100644 index 0000000000000000000000000000000000000000..e9570ec321f91b392cadae357a917ea9893a18a0 --- /dev/null +++ b/shared/package-files/2f/2fbf3905d18dcba8e6899424c9ba60c25bce67893e84a22fbb8ea6a4a8a29b2e/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2fbf3905d18dcba8e6899424c9ba60c25bce67893e84a22fbb8ea6a4a8a29b2e +size 39811936 diff --git a/shared/package-files/2f/2fc0872961f5b8c136ef7fecf82a17fa4e604a2f446b108dc741c0409d6c8e76/blob b/shared/package-files/2f/2fc0872961f5b8c136ef7fecf82a17fa4e604a2f446b108dc741c0409d6c8e76/blob new file mode 100644 index 0000000000000000000000000000000000000000..65f3dd61bbd7f0ba594fd2270f52afad6108ad42 --- /dev/null +++ b/shared/package-files/2f/2fc0872961f5b8c136ef7fecf82a17fa4e604a2f446b108dc741c0409d6c8e76/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::_embedding_bag(Tensor weight, Tensor indices, Tensor offsets, bool scale_grad_by_freq=False, int mode=0, bool sparse=False, Tensor? per_sample_weights=None, bool include_last_offset=False, int padding_idx=-1) -> (Tensor, Tensor, Tensor, Tensor) +inline ::std::tuple _embedding_bag(const at::Tensor & weight, const at::Tensor & indices, const at::Tensor & offsets, bool scale_grad_by_freq=false, int64_t mode=0, bool sparse=false, const c10::optional & per_sample_weights={}, bool include_last_offset=false, int64_t padding_idx=-1) { + return at::_ops::_embedding_bag::call(weight, indices, offsets, scale_grad_by_freq, mode, sparse, per_sample_weights, include_last_offset, padding_idx); +} + +// aten::_embedding_bag.out(Tensor weight, Tensor indices, Tensor offsets, bool scale_grad_by_freq=False, int mode=0, bool sparse=False, Tensor? per_sample_weights=None, bool include_last_offset=False, int padding_idx=-1, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!) out3) -> (Tensor(a!), Tensor(b!), Tensor(c!), Tensor(d!)) +inline ::std::tuple _embedding_bag_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, const at::Tensor & weight, const at::Tensor & indices, const at::Tensor & offsets, bool scale_grad_by_freq=false, int64_t mode=0, bool sparse=false, const c10::optional & per_sample_weights={}, bool include_last_offset=false, int64_t padding_idx=-1) { + return at::_ops::_embedding_bag_out::call(weight, indices, offsets, scale_grad_by_freq, mode, sparse, per_sample_weights, include_last_offset, padding_idx, out0, out1, out2, out3); +} +// aten::_embedding_bag.out(Tensor weight, Tensor indices, Tensor offsets, bool scale_grad_by_freq=False, int mode=0, bool sparse=False, Tensor? per_sample_weights=None, bool include_last_offset=False, int padding_idx=-1, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2, Tensor(d!) out3) -> (Tensor(a!), Tensor(b!), Tensor(c!), Tensor(d!)) +inline ::std::tuple _embedding_bag_outf(const at::Tensor & weight, const at::Tensor & indices, const at::Tensor & offsets, bool scale_grad_by_freq, int64_t mode, bool sparse, const c10::optional & per_sample_weights, bool include_last_offset, int64_t padding_idx, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3) { + return at::_ops::_embedding_bag_out::call(weight, indices, offsets, scale_grad_by_freq, mode, sparse, per_sample_weights, include_last_offset, padding_idx, out0, out1, out2, out3); +} + +} diff --git a/shared/package-files/2f/2fc1d35b2002fcc20abb1599bb0d33bd3ab9aa6500d2db6bbcaf78d4ecc3294f/blob b/shared/package-files/2f/2fc1d35b2002fcc20abb1599bb0d33bd3ab9aa6500d2db6bbcaf78d4ecc3294f/blob new file mode 100644 index 0000000000000000000000000000000000000000..8b5b1d280f3c7b45cee54338f60d5271a7510c2e --- /dev/null +++ b/shared/package-files/2f/2fc1d35b2002fcc20abb1599bb0d33bd3ab9aa6500d2db6bbcaf78d4ecc3294f/blob @@ -0,0 +1,108 @@ +# flake8: noqa + +import abc +import os +import sys +import pathlib +from contextlib import suppress +from typing import Union + + +if sys.version_info >= (3, 10): + from zipfile import Path as ZipPath # type: ignore +else: + from ..zipp import Path as ZipPath # type: ignore + + +try: + from typing import runtime_checkable # type: ignore +except ImportError: + + def runtime_checkable(cls): # type: ignore + return cls + + +try: + from typing import Protocol # type: ignore +except ImportError: + Protocol = abc.ABC # type: ignore + + +class TraversableResourcesLoader: + """ + Adapt loaders to provide TraversableResources and other + compatibility. + + Used primarily for Python 3.9 and earlier where the native + loaders do not yet implement TraversableResources. + """ + + def __init__(self, spec): + self.spec = spec + + @property + def path(self): + return self.spec.origin + + def get_resource_reader(self, name): + from . import readers, _adapters + + def _zip_reader(spec): + with suppress(AttributeError): + return readers.ZipReader(spec.loader, spec.name) + + def _namespace_reader(spec): + with suppress(AttributeError, ValueError): + return readers.NamespaceReader(spec.submodule_search_locations) + + def _available_reader(spec): + with suppress(AttributeError): + return spec.loader.get_resource_reader(spec.name) + + def _native_reader(spec): + reader = _available_reader(spec) + return reader if hasattr(reader, 'files') else None + + def _file_reader(spec): + try: + path = pathlib.Path(self.path) + except TypeError: + return None + if path.exists(): + return readers.FileReader(self) + + return ( + # native reader if it supplies 'files' + _native_reader(self.spec) + or + # local ZipReader if a zip module + _zip_reader(self.spec) + or + # local NamespaceReader if a namespace module + _namespace_reader(self.spec) + or + # local FileReader + _file_reader(self.spec) + # fallback - adapt the spec ResourceReader to TraversableReader + or _adapters.CompatibilityFiles(self.spec) + ) + + +def wrap_spec(package): + """ + Construct a package spec with traversable compatibility + on the spec/loader/reader. + + Supersedes _adapters.wrap_spec to use TraversableResourcesLoader + from above for older Python compatibility (<3.10). + """ + from . import _adapters + + return _adapters.SpecLoaderAdapter(package.__spec__, TraversableResourcesLoader) + + +if sys.version_info >= (3, 9): + StrPath = Union[str, os.PathLike[str]] +else: + # PathLike is only subscriptable at runtime in 3.9+ + StrPath = Union[str, "os.PathLike[str]"] diff --git a/shared/package-files/2f/2fc71a7d5d9e1e23728bd9bd11a154cf36f4acbcbf47ae4db848c0a2f16e13f2/blob b/shared/package-files/2f/2fc71a7d5d9e1e23728bd9bd11a154cf36f4acbcbf47ae4db848c0a2f16e13f2/blob new file mode 100644 index 0000000000000000000000000000000000000000..dd5ca867398031a31c74927cfa3b4491a50423aa --- /dev/null +++ b/shared/package-files/2f/2fc71a7d5d9e1e23728bd9bd11a154cf36f4acbcbf47ae4db848c0a2f16e13f2/blob @@ -0,0 +1,229 @@ +# -*- coding: utf-8 -*- +""" +Support for CFFI. Allows checking whether objects are CFFI functions and +obtaining the pointer and numba signature. +""" + +from types import BuiltinFunctionType +import ctypes +from functools import partial +import numpy as np + +from numba.core import types +from numba.core.errors import TypingError +from numba.core.typing import templates +from numba.np import numpy_support + +try: + import cffi + ffi = cffi.FFI() +except ImportError: + ffi = None + +SUPPORTED = ffi is not None +_ool_func_types = {} +_ool_func_ptr = {} +_ffi_instances = set() + + +def is_ffi_instance(obj): + # Compiled FFI modules have a member, ffi, which is an instance of + # CompiledFFI, which behaves similarly to an instance of cffi.FFI. In + # order to simplify handling a CompiledFFI object, we treat them as + # if they're cffi.FFI instances for typing and lowering purposes. + try: + return obj in _ffi_instances or isinstance(obj, cffi.FFI) + except TypeError: # Unhashable type possible + return False + +def is_cffi_func(obj): + """Check whether the obj is a CFFI function""" + try: + return ffi.typeof(obj).kind == 'function' + except TypeError: + try: + return obj in _ool_func_types + except Exception: + return False + +def get_pointer(cffi_func): + """ + Get a pointer to the underlying function for a CFFI function as an + integer. + """ + if cffi_func in _ool_func_ptr: + return _ool_func_ptr[cffi_func] + return int(ffi.cast("uintptr_t", cffi_func)) + + +_cached_type_map = None + +def _type_map(): + """ + Lazily compute type map, as calling ffi.typeof() involves costly + parsing of C code... + """ + global _cached_type_map + if _cached_type_map is None: + _cached_type_map = { + ffi.typeof('bool') : types.boolean, + ffi.typeof('char') : types.char, + ffi.typeof('short') : types.short, + ffi.typeof('int') : types.intc, + ffi.typeof('long') : types.long_, + ffi.typeof('long long') : types.longlong, + ffi.typeof('unsigned char') : types.uchar, + ffi.typeof('unsigned short') : types.ushort, + ffi.typeof('unsigned int') : types.uintc, + ffi.typeof('unsigned long') : types.ulong, + ffi.typeof('unsigned long long') : types.ulonglong, + ffi.typeof('int8_t') : types.char, + ffi.typeof('uint8_t') : types.uchar, + ffi.typeof('int16_t') : types.short, + ffi.typeof('uint16_t') : types.ushort, + ffi.typeof('int32_t') : types.intc, + ffi.typeof('uint32_t') : types.uintc, + ffi.typeof('int64_t') : types.longlong, + ffi.typeof('uint64_t') : types.ulonglong, + ffi.typeof('float') : types.float32, + ffi.typeof('double') : types.double, + ffi.typeof('ssize_t') : types.intp, + ffi.typeof('size_t') : types.uintp, + ffi.typeof('void') : types.void, + } + return _cached_type_map + + +def map_type(cffi_type, use_record_dtype=False): + """ + Map CFFI type to numba type. + + Parameters + ---------- + cffi_type: + The CFFI type to be converted. + use_record_dtype: bool (default: False) + When True, struct types are mapped to a NumPy Record dtype. + + """ + primed_map_type = partial(map_type, use_record_dtype=use_record_dtype) + kind = getattr(cffi_type, 'kind', '') + if kind == 'union': + raise TypeError("No support for CFFI union") + elif kind == 'function': + if cffi_type.ellipsis: + raise TypeError("vararg function is not supported") + restype = primed_map_type(cffi_type.result) + argtypes = [primed_map_type(arg) for arg in cffi_type.args] + return templates.signature(restype, *argtypes) + elif kind == 'pointer': + pointee = cffi_type.item + if pointee.kind == 'void': + return types.voidptr + else: + return types.CPointer(primed_map_type(pointee)) + elif kind == 'array': + dtype = primed_map_type(cffi_type.item) + nelem = cffi_type.length + return types.NestedArray(dtype=dtype, shape=(nelem,)) + elif kind == 'struct' and use_record_dtype: + return map_struct_to_record_dtype(cffi_type) + else: + result = _type_map().get(cffi_type) + if result is None: + raise TypeError(cffi_type) + return result + + +def map_struct_to_record_dtype(cffi_type): + """Convert a cffi type into a NumPy Record dtype + """ + fields = { + 'names': [], + 'formats': [], + 'offsets': [], + 'itemsize': ffi.sizeof(cffi_type), + } + is_aligned = True + for k, v in cffi_type.fields: + # guard unsupported values + if v.bitshift != -1: + msg = "field {!r} has bitshift, this is not supported" + raise ValueError(msg.format(k)) + if v.flags != 0: + msg = "field {!r} has flags, this is not supported" + raise ValueError(msg.format(k)) + if v.bitsize != -1: + msg = "field {!r} has bitsize, this is not supported" + raise ValueError(msg.format(k)) + dtype = numpy_support.as_dtype( + map_type(v.type, use_record_dtype=True), + ) + fields['names'].append(k) + fields['formats'].append(dtype) + fields['offsets'].append(v.offset) + # Check alignment + is_aligned &= (v.offset % dtype.alignment == 0) + + return numpy_support.from_dtype(np.dtype(fields, align=is_aligned)) + + +def make_function_type(cffi_func, use_record_dtype=False): + """ + Return a Numba type for the given CFFI function pointer. + """ + cffi_type = _ool_func_types.get(cffi_func) or ffi.typeof(cffi_func) + if getattr(cffi_type, 'kind', '') == 'struct': + raise TypeError('No support for CFFI struct values') + sig = map_type(cffi_type, use_record_dtype=use_record_dtype) + return types.ExternalFunctionPointer(sig, get_pointer=get_pointer) + + +registry = templates.Registry() + +@registry.register +class FFI_from_buffer(templates.AbstractTemplate): + key = 'ffi.from_buffer' + + def generic(self, args, kws): + if kws or len(args) != 1: + return + [ary] = args + if not isinstance(ary, types.Buffer): + raise TypingError("from_buffer() expected a buffer object, got %s" + % (ary,)) + if ary.layout not in ('C', 'F'): + raise TypingError("from_buffer() unsupported on non-contiguous buffers (got %s)" + % (ary,)) + if ary.layout != 'C' and ary.ndim > 1: + raise TypingError("from_buffer() only supports multidimensional arrays with C layout (got %s)" + % (ary,)) + ptr = types.CPointer(ary.dtype) + return templates.signature(ptr, ary) + +@registry.register_attr +class FFIAttribute(templates.AttributeTemplate): + key = types.ffi + + def resolve_from_buffer(self, ffi): + return types.BoundFunction(FFI_from_buffer, types.ffi) + + +def register_module(mod): + """ + Add typing for all functions in an out-of-line CFFI module to the typemap + """ + for f in dir(mod.lib): + f = getattr(mod.lib, f) + if isinstance(f, BuiltinFunctionType): + _ool_func_types[f] = mod.ffi.typeof(f) + addr = mod.ffi.addressof(mod.lib, f.__name__) + _ool_func_ptr[f] = int(mod.ffi.cast("uintptr_t", addr)) + _ffi_instances.add(mod.ffi) + +def register_type(cffi_type, numba_type): + """ + Add typing for a given CFFI type to the typemap + """ + tm = _type_map() + tm[cffi_type] = numba_type diff --git a/shared/package-files/2f/2fcd1e68b71bf72989399c852e84210f2914f5dc22a2e4454530fefc8aca16c2/blob b/shared/package-files/2f/2fcd1e68b71bf72989399c852e84210f2914f5dc22a2e4454530fefc8aca16c2/blob new file mode 100644 index 0000000000000000000000000000000000000000..a74905681468d56fa69cdc80994cc1b2d9b9df05 --- /dev/null +++ b/shared/package-files/2f/2fcd1e68b71bf72989399c852e84210f2914f5dc22a2e4454530fefc8aca16c2/blob @@ -0,0 +1,40 @@ +.. _species_distribution_dataset: + +Species distribution dataset +---------------------------- + +This dataset represents the geographic distribution of two species in Central and +South America. The two species are: + +- `"Bradypus variegatus" `_ , + the Brown-throated Sloth. + +- `"Microryzomys minutus" `_ , + also known as the Forest Small Rice Rat, a rodent that lives in Peru, + Colombia, Ecuador, Peru, and Venezuela. + +The dataset is not a typical dataset since a :class:`~sklearn.datasets.base.Bunch` +containing the attributes `data` and `target` is not returned. Instead, we have +information allowing to create a "density" map of the different species. + +The grid for the map can be built using the attributes `x_left_lower_corner`, +`y_left_lower_corner`, `Nx`, `Ny` and `grid_size`, which respectively correspond +to the x and y coordinates of the lower left corner of the grid, the number of +points along the x- and y-axis and the size of the step on the grid. + +The density at each location of the grid is contained in the `coverage` attribute. + +Finally, the `train` and `test` attributes contain information regarding the location +of a species at a specific location. + +The dataset is provided by Phillips et. al. (2006). + +.. rubric:: References + +* `"Maximum entropy modeling of species geographic distributions" + `_ S. J. Phillips, + R. P. Anderson, R. E. Schapire - Ecological Modelling, 190:231-259, 2006. + +.. rubric:: Examples + +* :ref:`sphx_glr_auto_examples_applications_plot_species_distribution_modeling.py` diff --git a/shared/package-files/2f/2fd0becb8e885fdbb4438f2ae3e7041520d12b5c1e5081330102dcc2d525abe8/blob b/shared/package-files/2f/2fd0becb8e885fdbb4438f2ae3e7041520d12b5c1e5081330102dcc2d525abe8/blob new file mode 100644 index 0000000000000000000000000000000000000000..a854d30c895ce7f537727adec3caf3b617d03af0 --- /dev/null +++ b/shared/package-files/2f/2fd0becb8e885fdbb4438f2ae3e7041520d12b5c1e5081330102dcc2d525abe8/blob @@ -0,0 +1,17 @@ +#ifndef THP_AUTOGRAD_H +#define THP_AUTOGRAD_H + +PyObject* THPAutograd_initExtension(PyObject* _unused, PyObject* unused); +void THPAutograd_initFunctions(); + +namespace torch::autograd { + +PyMethodDef* python_functions(); + +} + +#include +#include +#include + +#endif diff --git a/shared/package-files/2f/2fd10dbb5fabd45d6a8afc71203563659a8fd790ac1f2027efd7bd71520fc9e4/blob b/shared/package-files/2f/2fd10dbb5fabd45d6a8afc71203563659a8fd790ac1f2027efd7bd71520fc9e4/blob new file mode 100644 index 0000000000000000000000000000000000000000..bb5d5cf7b8faa2a4b774889c68ea88fb0e3c248c --- /dev/null +++ b/shared/package-files/2f/2fd10dbb5fabd45d6a8afc71203563659a8fd790ac1f2027efd7bd71520fc9e4/blob @@ -0,0 +1,110 @@ +import numpy as np + +from statsmodels.tools.validation import PandasWrapper, array_like +from statsmodels.tsa.filters.filtertools import CycleTrendResult + +# the data is sampled quarterly, so cut-off frequency of 18 + +# Wn is normalized cut-off freq +# Cutoff frequency is that frequency where the magnitude response of the filter +# is sqrt(1/2.). For butter, the normalized cutoff frequency Wn must be a +# number between 0 and 1, where 1 corresponds to the Nyquist frequency, p +# radians per sample. + + +# NOTE: uses a loop, could probably be sped-up for very large datasets +def cffilter(x, low=6, high=32, drift=True): + """ + Christiano Fitzgerald asymmetric, random walk filter + + Parameters + ---------- + x : array_like + The 1 or 2d array to filter. If 2d, variables are assumed to be in + columns. + low : float, optional + Minimum period of oscillations. Features below low periodicity are + filtered out. Default is 6 for quarterly data, giving a 1.5 year + periodicity. + high : float, optional + Maximum period of oscillations. Features above high periodicity are + filtered out. Default is 32 for quarterly data, giving an 8 year + periodicity. + drift : bool, optional + Whether or not to remove a trend from the data. The trend is estimated + as np.arange(nobs)*(x[-1] - x[0])/(len(x)-1). + + Returns + ------- + CycleTrendResult + A result object with fields: + + cycle : ndarray, Series, or DataFrame + The features of x between the periodicities low and high. + trend : ndarray, Series, or DataFrame + The trend in the data with the cycles removed. + + See Also + -------- + statsmodels.tsa.filters.bk_filter.bkfilter + Baxter-King filter. + statsmodels.tsa.filters.hp_filter.hpfilter + Hodrick-Prescott filter. + statsmodels.tsa.seasonal.seasonal_decompose + Decompose a time series using moving averages. + statsmodels.tsa.seasonal.STL + Season-Trend decomposition using LOESS. + + Notes + ----- + See the notebook `Time Series Filters + <../examples/notebooks/generated/tsa_filters.html>`__ for an overview. + + Examples + -------- + >>> import statsmodels.api as sm + >>> import pandas as pd + >>> dta = sm.datasets.macrodata.load_pandas().data + >>> index = pd.DatetimeIndex(start='1959Q1', end='2009Q4', freq='Q') + >>> dta.set_index(index, inplace=True) + + >>> cf_cycles, cf_trend = sm.tsa.filters.cffilter(dta[["infl", "unemp"]]) + + >>> import matplotlib.pyplot as plt + >>> fig, ax = plt.subplots() + >>> cf_cycles.plot(ax=ax, style=['r--', 'b-']) + >>> plt.show() + + .. plot:: plots/cff_plot.py + """ + # TODO: cythonize/vectorize loop?, add ability for symmetric filter, + # and estimates of theta other than random walk. + if low < 2: + raise ValueError("low must be >= 2") + pw = PandasWrapper(x) + x = array_like(x, "x", ndim=2) + nobs, nseries = x.shape + a = 2*np.pi/high + b = 2*np.pi/low + + if drift: # get drift adjusted series + x = x - np.arange(nobs)[:, None] * (x[-1] - x[0]) / (nobs - 1) + + J = np.arange(1, nobs + 1) + Bj = (np.sin(b * J) - np.sin(a * J)) / (np.pi * J) + B0 = (b - a) / np.pi + Bj = np.r_[B0, Bj][:, None] + y = np.zeros((nobs, nseries)) + + for i in range(nobs): + B = -.5 * Bj[0] - np.sum(Bj[1:-i - 2]) + A = -Bj[0] - np.sum(Bj[1:-i - 2]) - np.sum(Bj[1:i]) - B + y[i] = (Bj[0] * x[i] + np.dot(Bj[1:-i - 2].T, x[i + 1:-1]) + + B * x[-1] + np.dot(Bj[1:i].T, x[1:i][::-1]) + A * x[0]) + y = y.squeeze() + + cycle, trend = y.squeeze(), x.squeeze() - y + + return CycleTrendResult( + pw.wrap(cycle, append="cycle"), pw.wrap(trend, append="trend") + ) diff --git a/shared/package-files/2f/2fd1f4711bd059c1b8a39e2bad9556d59741463029881e9c68275818b764a4b8/blob b/shared/package-files/2f/2fd1f4711bd059c1b8a39e2bad9556d59741463029881e9c68275818b764a4b8/blob new file mode 100644 index 0000000000000000000000000000000000000000..80e34d93635d8902d779caeaccfdadad15bb32ec --- /dev/null +++ b/shared/package-files/2f/2fd1f4711bd059c1b8a39e2bad9556d59741463029881e9c68275818b764a4b8/blob @@ -0,0 +1,164 @@ +from statsmodels.compat.pandas import FUTURE_STACK + +from collections import defaultdict +import os +from pathlib import Path + +import numpy as np +import pandas as pd +from scipy import stats +from sklearn.model_selection import KFold + +if __name__ == "__main__": + from black import FileMode, TargetVersion, format_file_contents + from sklearn.linear_model import LinearRegression + from sklearn.model_selection import cross_val_score + + PATH = os.environ.get("PSS_PATH", "..") + print(f"Processing {PATH}") + + files = [str(p) for p in Path(PATH).glob("*.npz")] + groups = defaultdict(list) + for f in files: + keys = f.split("-") + key = int(keys[2]), int(keys[4]), keys[6] == "True" + if key[0] == 0: + continue + with np.load(f) as contents: + idx = (100 * contents["percentiles"]).astype(int) + s = pd.Series(contents["q"], index=idx) + groups[key].append(s) + + final = {} + quantiles = (90, 95, 99, 99.9) + crit_vals = {} + ordered_keys = sorted(groups.keys()) + for key in ordered_keys: + final[key] = pd.concat(groups[key], axis=1) + cv = [final[key].loc[int(100 * q)].mean() for q in quantiles] + crit_vals[key] = cv + df = pd.DataFrame(crit_vals).T + df.index.names = ("k", "case", "I1") + df.columns = quantiles + + for key, row in df.iterrows(): + crit_vals[key] = [round(val, 7) for val in list(row)] + + def setup_regressors(df, low_pow=3, high_pow=3, cut=70, log=False): + s = df.stack(**FUTURE_STACK).reset_index() + q = s.level_0 / 10000 + y = stats.norm.ppf(q) + cv = s[0] + if log: + cv = np.log(cv) + m = np.where(s.level_0 <= df.index[cut])[0].max() + reg = np.zeros((q.shape[0], 2 + low_pow + high_pow)) + reg[:m, 0] = 1 + for i in range(low_pow): + reg[:m, i + 1] = cv[:m] ** (i + 1) + w = 1 + low_pow + reg[m:, w] = 1 + for i in range(high_pow): + reg[m:, w + i + 1] = cv[m:] ** (i + 1) + return reg, y + + large_p = {} + small_p = {} + transform = {} + max_stat = {} + threshold = {} + + hp = 2 + for key, final_value in final.items(): + print(key) + data = final_value + score = {} + lr = LinearRegression(fit_intercept=False) + for lp in (2, 3): + for cut in range(40, data.shape[0] - 40): + for log in (True, False): + cv = KFold(shuffle=True, rng=20210903) + x, y = setup_regressors(data, lp, hp, cut, log) + k = (lp, hp, cut, log) + score[k] = cross_val_score( + lr, x, y, scoring="neg_mean_absolute_error", cv=cv + ).sum() + idx = pd.Series(score).idxmax() + lp, hp, cut, log = idx + assert log + + x, y = setup_regressors(data, lp, hp, cut, log) + lr = lr.fit(x, y) + large = lr.coef_[: 1 + lp] + if lp == 2: + large = np.array(large.tolist() + [0.0]) + large_p[key] = large.tolist() + small_p[key] = lr.coef_[1 + lp :].tolist() + transform[key] = log + max_stat[key] = np.inf + threshold[key] = data.iloc[cut].mean() + if small_p[key][2] < 0: + max_stat[key] = small_p[key][1] / (-2 * small_p[key][2]) + + for key, large_p_value in large_p.items(): + large_p[key] = [round(val, 5) for val in large_p_value] + small_p[key] = [round(val, 5) for val in small_p[key]] + + raw_code = f""" +#!/usr/bin/env python +# coding: utf-8 + +\"\"\" +Critical value polynomials and related quantities for the bounds test of + +Pesaran, M. H., Shin, Y., & Smith, R. J. (2001). Bounds testing approaches + to the analysis of level relationships. Journal of applied econometrics, + 16(3), 289-326. + +These were computed using 32,000,000 simulations for each key using the +methodology of PSS, who only used 40,000. The asymptotic P-value response +functions were computed based on the simulated value. Critical values +are the point estimates for the respective quantiles. The simulation code +is contained in pss.py. The output files from this function are then +transformed using pss-process.py. + +The format of the keys is (k, case, I1) where + +* k is the number of x variables included in the model (0 is an ADF) +* case is 1, 2, 3, 4 or 5 and corresponds to the PSS paper +* I1 is True if X contains I1 variables and False if X is stationary + +The parameters are for polynomials of order 3 (large) or 2 (small). +stat_star is the value where the switch between large and small occurs. +Stat values less than stat_star use large_p, while values above use +small_p. In all cases the stat is logged prior to computing the p-value +so that the p-value is + +1 - Phi(c[0] + c[1] * x + c[2] * x**2 + c[3] * x**3) + +where x = np.log(stat) and Phi() is the normal cdf. + +When evaluating the models, the polynomial is evaluated at the natural log +of the test statistic and then the normal CDF of this value is computed to +produce the p-value. +\"\"\" + +__all__ = ["large_p", "small_p", "crit_vals", "crit_percentiles", "stat_star"] + +large_p = {large_p} + +small_p = {small_p} + +stat_star = {threshold} + +crit_percentiles = {quantiles} + +crit_vals = {crit_vals} +""" + + targets = {TargetVersion.PY38, TargetVersion.PY39} + fm = FileMode(target_versions=targets, line_length=79) + formatted_code = format_file_contents(raw_code, fast=False, mode=fm) + + with Path("../pss_critical_values.py").open("w", newline="\n", encoding="utf-8") as out: + out.write(formatted_code) diff --git a/shared/package-files/2f/2fd2130ae225aee03f9cb4682089ecad907884e1ce21b14659547d3bf338ac81/blob b/shared/package-files/2f/2fd2130ae225aee03f9cb4682089ecad907884e1ce21b14659547d3bf338ac81/blob new file mode 100644 index 0000000000000000000000000000000000000000..3c0d15723d24586dd04a831d08cc04cbf93ed51d --- /dev/null +++ b/shared/package-files/2f/2fd2130ae225aee03f9cb4682089ecad907884e1ce21b14659547d3bf338ac81/blob @@ -0,0 +1,53 @@ +from typing import Optional +from tensorboard.compat.proto.node_def_pb2 import NodeDef +from tensorboard.compat.proto.attr_value_pb2 import AttrValue +from tensorboard.compat.proto.tensor_shape_pb2 import TensorShapeProto + + +def attr_value_proto(dtype, shape, s): + """Create a dict of objects matching a NodeDef's attr field. + + Follows https://github.com/tensorflow/tensorboard/blob/master/tensorboard/compat/proto/attr_value.proto + specifically designed for a NodeDef. The values have been reverse engineered from + standard TensorBoard logged data. + """ + attr = {} + if s is not None: + attr["attr"] = AttrValue(s=s.encode(encoding="utf_8")) + if shape is not None: + shapeproto = tensor_shape_proto(shape) + attr["_output_shapes"] = AttrValue(list=AttrValue.ListValue(shape=[shapeproto])) + return attr + + +def tensor_shape_proto(outputsize): + """Create an object matching a tensor_shape field. + + Follows https://github.com/tensorflow/tensorboard/blob/master/tensorboard/compat/proto/tensor_shape.proto . + """ + return TensorShapeProto(dim=[TensorShapeProto.Dim(size=d) for d in outputsize]) + + +def node_proto( + name, + op="UnSpecified", + input=None, + dtype=None, + shape: Optional[tuple] = None, + outputsize=None, + attributes="", +): + """Create an object matching a NodeDef. + + Follows https://github.com/tensorflow/tensorboard/blob/master/tensorboard/compat/proto/node_def.proto . + """ + if input is None: + input = [] + if not isinstance(input, list): + input = [input] + return NodeDef( + name=name.encode(encoding="utf_8"), + op=op, + input=input, + attr=attr_value_proto(dtype, outputsize, attributes), + ) diff --git a/shared/package-files/2f/2fd34164811904689c416116b7e03cdfe206e475232cd7aeee808b57dc75fd3f/blob b/shared/package-files/2f/2fd34164811904689c416116b7e03cdfe206e475232cd7aeee808b57dc75fd3f/blob new file mode 100644 index 0000000000000000000000000000000000000000..e3f0fc8a05efb25d0a1c5baa7009f874b326a827 --- /dev/null +++ b/shared/package-files/2f/2fd34164811904689c416116b7e03cdfe206e475232cd7aeee808b57dc75fd3f/blob @@ -0,0 +1,114 @@ +#pragma once + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +namespace py = pybind11; + +// Python object that backs torch.autograd.Variable +struct THPVariable { + PyObject_HEAD; + // Payload + c10::MaybeOwned cdata; + // Hooks to be run on backwards pass (corresponds to Python attr + // '_backwards_hooks', set by 'register_hook') + PyObject* backward_hooks = nullptr; + // Hooks to be run in the backwards pass after accumulate grad, + // i.e., after the .grad has been set (corresponds to Python attr + // '_post_accumulate_grad_hooks', set by 'register_post_accumulate_grad_hook') + PyObject* post_accumulate_grad_hooks = nullptr; +}; + +TORCH_PYTHON_API void registerPythonTensorClass( + const std::string& device, + PyObject* python_tensor_class); + +TORCH_PYTHON_API void activateCUDATrace(); + +TORCH_PYTHON_API extern PyObject* THPVariableClass; +TORCH_PYTHON_API extern PyObject* ParameterClass; + +bool THPVariable_initModule(PyObject* module); +TORCH_PYTHON_API PyObject* THPVariable_Wrap(at::TensorBase var); + +static inline bool THPVariable_CheckTypeExact(PyTypeObject* tp) { + // Check that a python object is a `Tensor`, but not a `Tensor` subclass. + // (A subclass could have different semantics.) The one exception is + // Parameter, which is used for Python bookkeeping but is equivalent to + // Tensor as far as C++ is concerned. + return ( + tp == (PyTypeObject*)THPVariableClass || + tp == (PyTypeObject*)ParameterClass); +} + +static inline bool THPVariable_CheckExact(PyObject* obj) { + return THPVariable_CheckTypeExact(Py_TYPE(obj)); +} + +inline bool THPVariable_Check(PyObject* obj) { + if (!THPVariableClass) + return false; + + // Fast path + if (THPVariable_CheckExact(obj)) { + return true; + } + + const auto result = PyObject_IsInstance(obj, THPVariableClass); + if (result == -1) + throw python_error(); + return result; +} + +inline const at::Tensor& THPVariable_Unpack(THPVariable* var) { + return *var->cdata; +} + +inline const at::Tensor& THPVariable_Unpack(PyObject* obj) { + return THPVariable_Unpack(reinterpret_cast(obj)); +} + +std::pair parseIValuesToPyArgsKwargs( + const c10::OperatorHandle& op, + const std::vector& arguments); + +void pushPyOutToStack( + const c10::OperatorHandle& op, + torch::jit::Stack* stack, + py::object out, + const char* msg); + +inline PyObject* THPVariable_WrapList( + const torch::autograd::variable_list& inputs) { + PyObject* pyinput = PyList_New(static_cast(inputs.size())); + for (const auto i : c10::irange(inputs.size())) { + PyList_SET_ITEM(pyinput, i, THPVariable_Wrap(inputs[i])); + } + return pyinput; +} + +inline torch::autograd::variable_list THPVariable_UnpackList( + PyObject* pyresult) { + TORCH_CHECK(PyList_CheckExact(pyresult)); + auto result_len = PyList_GET_SIZE(pyresult); + torch::autograd::variable_list result; + result.reserve(result_len); + for (const auto i : c10::irange(result_len)) { + PyObject* item = PyList_GET_ITEM(pyresult, i); + if (!Py_IsNone(item)) { + TORCH_INTERNAL_ASSERT_DEBUG_ONLY(THPVariable_Check(item)); + result.emplace_back(THPVariable_Unpack(item)); + } else { + result.emplace_back(); + } + } + return result; +} diff --git a/shared/package-files/2f/2fd47fa7a7ec8a28c6f4ae804cd811adf4f77ba7b9a62c33b79c09331e3f5aa3/blob b/shared/package-files/2f/2fd47fa7a7ec8a28c6f4ae804cd811adf4f77ba7b9a62c33b79c09331e3f5aa3/blob new file mode 100644 index 0000000000000000000000000000000000000000..62b9ef4e4035a4d1716b0d90a1bfe8d68780c5b0 --- /dev/null +++ b/shared/package-files/2f/2fd47fa7a7ec8a28c6f4ae804cd811adf4f77ba7b9a62c33b79c09331e3f5aa3/blob @@ -0,0 +1,344 @@ +import builtins +import copy +import dataclasses +import inspect +import io +import os +import sys +import typing +import warnings +from enum import auto, Enum +from typing import ( + Any, + Callable, + Dict, + Iterator, + List, + Optional, + Tuple, + Type, + TYPE_CHECKING, + Union, +) + +import torch +import torch.utils._pytree as pytree +from torch.fx._compatibility import compatibility + +from torch.fx.passes.infra.pass_base import PassResult +from torch.fx.passes.infra.pass_manager import PassManager + +from torch.utils._pytree import ( + FlattenFunc, + FromDumpableContextFn, + ToDumpableContextFn, + UnflattenFunc, +) + +if TYPE_CHECKING: + # Import the following modules during type checking to enable code intelligence features, + # Do not import unconditionally, as they import sympy and importing sympy is very slow + from torch.fx.experimental.symbolic_shapes import StrictMinMaxConstraint + + +__all__ = [ + "Constraint", + "Dim", + "ExportBackwardSignature", + "ExportGraphSignature", + "ExportedProgram", + "ModuleCallEntry", + "ModuleCallSignature", + "dims", + "dynamic_dim", + "export", + "load", + "register_dataclass", + "save", + "unflatten", + "FlatArgsAdapter", + "UnflattenedModule", +] + + +from .dynamic_shapes import Constraint, Dim, dims, dynamic_dim +from .exported_program import ExportedProgram, ModuleCallEntry, ModuleCallSignature +from .graph_signature import ExportBackwardSignature, ExportGraphSignature +from .unflatten import FlatArgsAdapter, unflatten, UnflattenedModule + + +PassType = Callable[[torch.fx.GraphModule], Optional[PassResult]] + + +def export( + mod: torch.nn.Module, + args: Tuple[Any, ...], + kwargs: Optional[Dict[str, Any]] = None, + *, + dynamic_shapes: Optional[Union[Dict[str, Any], Tuple[Any], List[Any]]] = None, + strict: bool = True, + preserve_module_call_signature: Tuple[str, ...] = (), +) -> ExportedProgram: + """ + :func:`export` takes an arbitrary Python callable (an nn.Module, a function or + a method) along with example inputs, and produces a traced graph representing + only the Tensor computation of the function in an Ahead-of-Time (AOT) fashion, + which can subsequently be executed with different inputs or serialized. The + traced graph (1) produces normalized operators in the functional ATen operator set + (as well as any user-specified custom operators), (2) has eliminated all Python control + flow and data structures (with certain exceptions), and (3) records the set of + shape constraints needed to show that this normalization and control-flow elimination + is sound for future inputs. + + **Soundness Guarantee** + + While tracing, :func:`export()` takes note of shape-related assumptions + made by the user program and the underlying PyTorch operator kernels. + The output :class:`ExportedProgram` is considered valid only when these + assumptions hold true. + + Tracing makes assumptions on the shapes (not values) of input tensors. + Such assumptions must be validated at graph capture time for :func:`export` + to succeed. Specifically: + + - Assumptions on static shapes of input tensors are automatically validated without additional effort. + - Assumptions on dynamic shape of input tensors require explicit specification + by using the :func:`Dim` API to construct dynamic dimensions and by associating + them with example inputs through the ``dynamic_shapes`` argument. + + If any assumption can not be validated, a fatal error will be raised. When that happens, + the error message will include suggested fixes to the specification that are needed + to validate the assumptions. For example :func:`export` might suggest the + following fix to the definition of a dynamic dimension ``dim0_x``, say appearing in the + shape associated with input ``x``, that was previously defined as ``Dim("dim0_x")``:: + + dim = Dim("dim0_x", max=5) + + This example means the generated code requires dimension 0 of input ``x`` to be less + than or equal to 5 to be valid. You can inspect the suggested fixes to dynamic dimension + definitions and then copy them verbatim into your code without needing to change the + ``dynamic_shapes`` argument to your :func:`export` call. + + Args: + mod: We will trace the forward method of this module. + + args: Example positional inputs. + + kwargs: Optional example keyword inputs. + + dynamic_shapes: + An optional argument where the type should either be: + 1) a dict from argument names of ``f`` to their dynamic shape specifications, + 2) a tuple that specifies dynamic shape specifications for each input in original order. + If you are specifying dynamism on keyword args, you will need to pass them in the order that + is defined in the original function signature. + + The dynamic shape of a tensor argument can be specified as either + (1) a dict from dynamic dimension indices to :func:`Dim` types, where it is + not required to include static dimension indices in this dict, but when they are, + they should be mapped to None; or (2) a tuple / list of :func:`Dim` types or None, + where the :func:`Dim` types correspond to dynamic dimensions, and static dimensions + are denoted by None. Arguments that are dicts or tuples / lists of tensors are + recursively specified by using mappings or sequences of contained specifications. + + strict: When enabled (default), the export function will trace the program through + TorchDynamo which will ensure the soundness of the resulting graph. Otherwise, the + exported program will not validate the implicit assumptions baked into the graph and + may cause behavior divergence between the original model and the exported one. This is + useful when users need to workaround bugs in the tracer, or simply want incrementally + enable safety in their models. Note that this does not affect the resulting IR spec + to be different and the model will be serialized in the same way regardless of what value + is passed here. + WARNING: This option is experimental and use this at your own risk. + + Returns: + An :class:`ExportedProgram` containing the traced callable. + + **Acceptable input/output types** + + Acceptable types of inputs (for ``args`` and ``kwargs``) and outputs include: + + - Primitive types, i.e. ``torch.Tensor``, ``int``, ``float``, ``bool`` and ``str``. + - Dataclasses, but they must be registered by calling :func:`register_dataclass` first. + - (Nested) Data structures comprising of ``dict``, ``list``, ``tuple``, ``namedtuple`` and + ``OrderedDict`` containing all above types. + + """ + from ._trace import _export + + if not isinstance(mod, torch.nn.Module): + raise ValueError( + f"Expected `mod` to be an instance of `torch.nn.Module`, got {type(mod)}." + ) + + return _export( + mod, + args, + kwargs, + dynamic_shapes, + strict=strict, + preserve_module_call_signature=preserve_module_call_signature, + ) + + +def save( + ep: ExportedProgram, + f: Union[str, os.PathLike, io.BytesIO], + *, + extra_files: Optional[Dict[str, Any]] = None, + opset_version: Optional[Dict[str, int]] = None, +) -> None: + """ + + .. warning:: + Under active development, saved files may not be usable in newer versions + of PyTorch. + + Saves an :class:`ExportedProgram` to a file-like object. It can then be + loaded using the Python API :func:`torch.export.load `. + + Args: + ep (ExportedProgram): The exported program to save. + + f (Union[str, os.PathLike, io.BytesIO): A file-like object (has to + implement write and flush) or a string containing a file name. + + extra_files (Optional[Dict[str, Any]]): Map from filename to contents + which will be stored as part of f. + + opset_version (Optional[Dict[str, int]]): A map of opset names + to the version of this opset + + + Example:: + + import torch + import io + + class MyModule(torch.nn.Module): + def forward(self, x): + return x + 10 + + ep = torch.export.export(MyModule(), (torch.randn(5),)) + + # Save to file + torch.export.save(ep, 'exported_program.pt2') + + # Save to io.BytesIO buffer + buffer = io.BytesIO() + torch.export.save(ep, buffer) + + # Save with extra files + extra_files = {'foo.txt': b'bar'.decode('utf-8')} + torch.export.save(ep, 'exported_program.pt2', extra_files=extra_files) + + """ + from torch._export import save + + if not isinstance(ep, ExportedProgram): + raise TypeError( + f"The 'ep' parameter must be an instance of 'ExportedProgram', got '{type(ep).__name__}' instead." + ) + + save(ep, f, extra_files=extra_files, opset_version=opset_version) + + +def load( + f: Union[str, os.PathLike, io.BytesIO], + *, + extra_files: Optional[Dict[str, Any]] = None, + expected_opset_version: Optional[Dict[str, int]] = None, +) -> ExportedProgram: + """ + + .. warning:: + Under active development, saved files may not be usable in newer versions + of PyTorch. + + Loads an :class:`ExportedProgram` previously saved with + :func:`torch.export.save `. + + Args: + ep (ExportedProgram): The exported program to save. + + f (Union[str, os.PathLike, io.BytesIO): A file-like object (has to + implement write and flush) or a string containing a file name. + + extra_files (Optional[Dict[str, Any]]): The extra filenames given in + this map would be loaded and their content would be stored in the + provided map. + + expected_opset_version (Optional[Dict[str, int]]): A map of opset names + to expected opset versions + + Returns: + An :class:`ExportedProgram` object + + Example:: + + import torch + import io + + # Load ExportedProgram from file + ep = torch.export.load('exported_program.pt2') + + # Load ExportedProgram from io.BytesIO object + with open('exported_program.pt2', 'rb') as f: + buffer = io.BytesIO(f.read()) + buffer.seek(0) + ep = torch.export.load(buffer) + + # Load with extra files. + extra_files = {'foo.txt': ''} # values will be replaced with data + ep = torch.export.load('exported_program.pt2', extra_files=extra_files) + print(extra_files['foo.txt']) + print(ep(torch.randn(5))) + """ + from torch._export import load + + return load( + f, extra_files=extra_files, expected_opset_version=expected_opset_version + ) + + +def register_dataclass( + cls: Type[Any], + *, + serialized_type_name: Optional[str] = None, +) -> None: + """ + Registers a dataclass as a valid input/output type for :func:`torch.export.export`. + + Args: + cls: the dataclass type to register + serialized_type_name: The serialized name for the dataclass. This is + required if you want to serialize the pytree TreeSpec containing this + dataclass. + + Example:: + + @dataclass + class InputDataClass: + feature: torch.Tensor + bias: int + + class OutputDataClass: + res: torch.Tensor + + torch.export.register_dataclass(InputDataClass) + torch.export.register_dataclass(OutputDataClass) + + def fn(o: InputDataClass) -> torch.Tensor: + res = res=o.feature + o.bias + return OutputDataClass(res=res) + + ep = torch.export.export(fn, (InputDataClass(torch.ones(2, 2), 1), )) + print(ep) + + """ + + from torch._export.utils import register_dataclass_as_pytree_node + + return register_dataclass_as_pytree_node( + cls, serialized_type_name=serialized_type_name + ) diff --git a/shared/package-files/2f/2fd5b2f2f079a13b2e60943d34163844810059705c9674ce1f723fb719086d99/blob b/shared/package-files/2f/2fd5b2f2f079a13b2e60943d34163844810059705c9674ce1f723fb719086d99/blob new file mode 100644 index 0000000000000000000000000000000000000000..95e7b6a26f93a8cd10048076bd6906190e04d2ba --- /dev/null +++ b/shared/package-files/2f/2fd5b2f2f079a13b2e60943d34163844810059705c9674ce1f723fb719086d99/blob @@ -0,0 +1,465 @@ +""" +A verbatim copy (vendored) of the spec from https://github.com/data-apis/dataframe-api +""" + +from __future__ import annotations + +from abc import ( + ABC, + abstractmethod, +) +import enum +from typing import ( + TYPE_CHECKING, + Any, + TypedDict, +) + +if TYPE_CHECKING: + from collections.abc import ( + Iterable, + Sequence, + ) + + +class DlpackDeviceType(enum.IntEnum): + """Integer enum for device type codes matching DLPack.""" + + CPU = 1 + CUDA = 2 + CPU_PINNED = 3 + OPENCL = 4 + VULKAN = 7 + METAL = 8 + VPI = 9 + ROCM = 10 + + +class DtypeKind(enum.IntEnum): + """ + Integer enum for data types. + + Attributes + ---------- + INT : int + Matches to signed integer data type. + UINT : int + Matches to unsigned integer data type. + FLOAT : int + Matches to floating point data type. + BOOL : int + Matches to boolean data type. + STRING : int + Matches to string data type (UTF-8 encoded). + DATETIME : int + Matches to datetime data type. + CATEGORICAL : int + Matches to categorical data type. + """ + + INT = 0 + UINT = 1 + FLOAT = 2 + BOOL = 20 + STRING = 21 # UTF-8 + DATETIME = 22 + CATEGORICAL = 23 + + +class ColumnNullType(enum.IntEnum): + """ + Integer enum for null type representation. + + Attributes + ---------- + NON_NULLABLE : int + Non-nullable column. + USE_NAN : int + Use explicit float NaN value. + USE_SENTINEL : int + Sentinel value besides NaN/NaT. + USE_BITMASK : int + The bit is set/unset representing a null on a certain position. + USE_BYTEMASK : int + The byte is set/unset representing a null on a certain position. + """ + + NON_NULLABLE = 0 + USE_NAN = 1 + USE_SENTINEL = 2 + USE_BITMASK = 3 + USE_BYTEMASK = 4 + + +class ColumnBuffers(TypedDict): + # first element is a buffer containing the column data; + # second element is the data buffer's associated dtype + data: tuple[Buffer, Any] + + # first element is a buffer containing mask values indicating missing data; + # second element is the mask value buffer's associated dtype. + # None if the null representation is not a bit or byte mask + validity: tuple[Buffer, Any] | None + + # first element is a buffer containing the offset values for + # variable-size binary data (e.g., variable-length strings); + # second element is the offsets buffer's associated dtype. + # None if the data buffer does not have an associated offsets buffer + offsets: tuple[Buffer, Any] | None + + +class CategoricalDescription(TypedDict): + # whether the ordering of dictionary indices is semantically meaningful + is_ordered: bool + # whether a dictionary-style mapping of categorical values to other objects exists + is_dictionary: bool + # Python-level only (e.g. ``{int: str}``). + # None if not a dictionary-style categorical. + categories: Column | None + + +class Buffer(ABC): + """ + Data in the buffer is guaranteed to be contiguous in memory. + + Note that there is no dtype attribute present, a buffer can be thought of + as simply a block of memory. However, if the column that the buffer is + attached to has a dtype that's supported by DLPack and ``__dlpack__`` is + implemented, then that dtype information will be contained in the return + value from ``__dlpack__``. + + This distinction is useful to support both data exchange via DLPack on a + buffer and (b) dtypes like variable-length strings which do not have a + fixed number of bytes per element. + """ + + @property + @abstractmethod + def bufsize(self) -> int: + """ + Buffer size in bytes. + """ + + @property + @abstractmethod + def ptr(self) -> int: + """ + Pointer to start of the buffer as an integer. + """ + + @abstractmethod + def __dlpack__(self): + """ + Produce DLPack capsule (see array API standard). + + Raises: + + - TypeError : if the buffer contains unsupported dtypes. + - NotImplementedError : if DLPack support is not implemented + + Useful to have to connect to array libraries. Support optional because + it's not completely trivial to implement for a Python-only library. + """ + raise NotImplementedError("__dlpack__") + + @abstractmethod + def __dlpack_device__(self) -> tuple[DlpackDeviceType, int | None]: + """ + Device type and device ID for where the data in the buffer resides. + Uses device type codes matching DLPack. + Note: must be implemented even if ``__dlpack__`` is not. + """ + + +class Column(ABC): + """ + A column object, with only the methods and properties required by the + interchange protocol defined. + + A column can contain one or more chunks. Each chunk can contain up to three + buffers - a data buffer, a mask buffer (depending on null representation), + and an offsets buffer (if variable-size binary; e.g., variable-length + strings). + + TBD: Arrow has a separate "null" dtype, and has no separate mask concept. + Instead, it seems to use "children" for both columns with a bit mask, + and for nested dtypes. Unclear whether this is elegant or confusing. + This design requires checking the null representation explicitly. + + The Arrow design requires checking: + 1. the ARROW_FLAG_NULLABLE (for sentinel values) + 2. if a column has two children, combined with one of those children + having a null dtype. + + Making the mask concept explicit seems useful. One null dtype would + not be enough to cover both bit and byte masks, so that would mean + even more checking if we did it the Arrow way. + + TBD: there's also the "chunk" concept here, which is implicit in Arrow as + multiple buffers per array (= column here). Semantically it may make + sense to have both: chunks were meant for example for lazy evaluation + of data which doesn't fit in memory, while multiple buffers per column + could also come from doing a selection operation on a single + contiguous buffer. + + Given these concepts, one would expect chunks to be all of the same + size (say a 10,000 row dataframe could have 10 chunks of 1,000 rows), + while multiple buffers could have data-dependent lengths. Not an issue + in pandas if one column is backed by a single NumPy array, but in + Arrow it seems possible. + Are multiple chunks *and* multiple buffers per column necessary for + the purposes of this interchange protocol, or must producers either + reuse the chunk concept for this or copy the data? + + Note: this Column object can only be produced by ``__dataframe__``, so + doesn't need its own version or ``__column__`` protocol. + """ + + @abstractmethod + def size(self) -> int: + """ + Size of the column, in elements. + + Corresponds to DataFrame.num_rows() if column is a single chunk; + equal to size of this current chunk otherwise. + """ + + @property + @abstractmethod + def offset(self) -> int: + """ + Offset of first element. + + May be > 0 if using chunks; for example for a column with N chunks of + equal size M (only the last chunk may be shorter), + ``offset = n * M``, ``n = 0 .. N-1``. + """ + + @property + @abstractmethod + def dtype(self) -> tuple[DtypeKind, int, str, str]: + """ + Dtype description as a tuple ``(kind, bit-width, format string, endianness)``. + + Bit-width : the number of bits as an integer + Format string : data type description format string in Apache Arrow C + Data Interface format. + Endianness : current only native endianness (``=``) is supported + + Notes: + - Kind specifiers are aligned with DLPack where possible (hence the + jump to 20, leave enough room for future extension) + - Masks must be specified as boolean with either bit width 1 (for bit + masks) or 8 (for byte masks). + - Dtype width in bits was preferred over bytes + - Endianness isn't too useful, but included now in case in the future + we need to support non-native endianness + - Went with Apache Arrow format strings over NumPy format strings + because they're more complete from a dataframe perspective + - Format strings are mostly useful for datetime specification, and + for categoricals. + - For categoricals, the format string describes the type of the + categorical in the data buffer. In case of a separate encoding of + the categorical (e.g. an integer to string mapping), this can + be derived from ``self.describe_categorical``. + - Data types not included: complex, Arrow-style null, binary, decimal, + and nested (list, struct, map, union) dtypes. + """ + + @property + @abstractmethod + def describe_categorical(self) -> CategoricalDescription: + """ + If the dtype is categorical, there are two options: + - There are only values in the data buffer. + - There is a separate non-categorical Column encoding for categorical values. + + Raises TypeError if the dtype is not categorical + + Returns the dictionary with description on how to interpret the data buffer: + - "is_ordered" : bool, whether the ordering of dictionary indices is + semantically meaningful. + - "is_dictionary" : bool, whether a mapping of + categorical values to other objects exists + - "categories" : Column representing the (implicit) mapping of indices to + category values (e.g. an array of cat1, cat2, ...). + None if not a dictionary-style categorical. + + TBD: are there any other in-memory representations that are needed? + """ + + @property + @abstractmethod + def describe_null(self) -> tuple[ColumnNullType, Any]: + """ + Return the missing value (or "null") representation the column dtype + uses, as a tuple ``(kind, value)``. + + Value : if kind is "sentinel value", the actual value. If kind is a bit + mask or a byte mask, the value (0 or 1) indicating a missing value. None + otherwise. + """ + + @property + @abstractmethod + def null_count(self) -> int | None: + """ + Number of null elements, if known. + + Note: Arrow uses -1 to indicate "unknown", but None seems cleaner. + """ + + @property + @abstractmethod + def metadata(self) -> dict[str, Any]: + """ + The metadata for the column. See `DataFrame.metadata` for more details. + """ + + @abstractmethod + def num_chunks(self) -> int: + """ + Return the number of chunks the column consists of. + """ + + @abstractmethod + def get_chunks(self, n_chunks: int | None = None) -> Iterable[Column]: + """ + Return an iterator yielding the chunks. + + See `DataFrame.get_chunks` for details on ``n_chunks``. + """ + + @abstractmethod + def get_buffers(self) -> ColumnBuffers: + """ + Return a dictionary containing the underlying buffers. + + The returned dictionary has the following contents: + + - "data": a two-element tuple whose first element is a buffer + containing the data and whose second element is the data + buffer's associated dtype. + - "validity": a two-element tuple whose first element is a buffer + containing mask values indicating missing data and + whose second element is the mask value buffer's + associated dtype. None if the null representation is + not a bit or byte mask. + - "offsets": a two-element tuple whose first element is a buffer + containing the offset values for variable-size binary + data (e.g., variable-length strings) and whose second + element is the offsets buffer's associated dtype. None + if the data buffer does not have an associated offsets + buffer. + """ + + +# def get_children(self) -> Iterable[Column]: +# """ +# Children columns underneath the column, each object in this iterator +# must adhere to the column specification. +# """ +# pass + + +class DataFrame(ABC): + """ + A data frame class, with only the methods required by the interchange + protocol defined. + + A "data frame" represents an ordered collection of named columns. + A column's "name" must be a unique string. + Columns may be accessed by name or by position. + + This could be a public data frame class, or an object with the methods and + attributes defined on this DataFrame class could be returned from the + ``__dataframe__`` method of a public data frame class in a library adhering + to the dataframe interchange protocol specification. + """ + + version = 0 # version of the protocol + + @abstractmethod + def __dataframe__(self, nan_as_null: bool = False, allow_copy: bool = True): + """Construct a new interchange object, potentially changing the parameters.""" + + @property + @abstractmethod + def metadata(self) -> dict[str, Any]: + """ + The metadata for the data frame, as a dictionary with string keys. The + contents of `metadata` may be anything, they are meant for a library + to store information that it needs to, e.g., roundtrip losslessly or + for two implementations to share data that is not (yet) part of the + interchange protocol specification. For avoiding collisions with other + entries, please add name the keys with the name of the library + followed by a period and the desired name, e.g, ``pandas.indexcol``. + """ + + @abstractmethod + def num_columns(self) -> int: + """ + Return the number of columns in the DataFrame. + """ + + @abstractmethod + def num_rows(self) -> int | None: + # TODO: not happy with Optional, but need to flag it may be expensive + # why include it if it may be None - what do we expect consumers + # to do here? + """ + Return the number of rows in the DataFrame, if available. + """ + + @abstractmethod + def num_chunks(self) -> int: + """ + Return the number of chunks the DataFrame consists of. + """ + + @abstractmethod + def column_names(self) -> Iterable[str]: + """ + Return an iterator yielding the column names. + """ + + @abstractmethod + def get_column(self, i: int) -> Column: + """ + Return the column at the indicated position. + """ + + @abstractmethod + def get_column_by_name(self, name: str) -> Column: + """ + Return the column whose name is the indicated name. + """ + + @abstractmethod + def get_columns(self) -> Iterable[Column]: + """ + Return an iterator yielding the columns. + """ + + @abstractmethod + def select_columns(self, indices: Sequence[int]) -> DataFrame: + """ + Create a new DataFrame by selecting a subset of columns by index. + """ + + @abstractmethod + def select_columns_by_name(self, names: Sequence[str]) -> DataFrame: + """ + Create a new DataFrame by selecting a subset of columns by name. + """ + + @abstractmethod + def get_chunks(self, n_chunks: int | None = None) -> Iterable[DataFrame]: + """ + Return an iterator yielding the chunks. + + By default (None), yields the chunks that the data is stored as by the + producer. If given, ``n_chunks`` must be a multiple of + ``self.num_chunks()``, meaning the producer must subdivide each chunk + before yielding it. + """ diff --git a/shared/package-files/2f/2fd7ebadb1e6d2dde5e8a5f3fd3fd6f5a120ee0d306a05c3c87cc99b3a0ca890/blob b/shared/package-files/2f/2fd7ebadb1e6d2dde5e8a5f3fd3fd6f5a120ee0d306a05c3c87cc99b3a0ca890/blob new file mode 100644 index 0000000000000000000000000000000000000000..b7d3d1f4d86a6b4817af36489d1846b74afe7e6d --- /dev/null +++ b/shared/package-files/2f/2fd7ebadb1e6d2dde5e8a5f3fd3fd6f5a120ee0d306a05c3c87cc99b3a0ca890/blob @@ -0,0 +1,2811 @@ +{{py: + +implementation_specific_values = [ + # Values are the following ones: + # + # name_suffix, INPUT_DTYPE_t, INPUT_DTYPE + ('64', 'float64_t', 'np.float64'), + ('32', 'float32_t', 'np.float32') +] + +}} +# By Jake Vanderplas (2013) +# written for the scikit-learn project +# SPDX-License-Identifier: BSD-3-Clause + +import numpy as np +cimport numpy as cnp + +cnp.import_array() # required in order to use C-API + +from libc.math cimport fabs, sqrt, exp, pow, cos, sin, asin + +from scipy.sparse import csr_matrix, issparse +from ..utils._typedefs cimport float64_t, float32_t, int32_t, intp_t +from ..utils import check_array +from ..utils.fixes import parse_version, sp_base_version + +cdef inline double fmax(double a, double b) noexcept nogil: + return max(a, b) + + +###################################################################### +# newObj function +# this is a helper function for pickling +def newObj(obj): + return obj.__new__(obj) + + +BOOL_METRICS = [ + "hamming", + "jaccard", + "dice", + "rogerstanimoto", + "russellrao", + "sokalsneath", +] +DEPRECATED_METRICS = [] +if sp_base_version < parse_version("1.17"): + # Deprecated in SciPy 1.15 and removed in SciPy 1.17 + BOOL_METRICS += ["sokalmichener"] +if sp_base_version >= parse_version("1.15"): + DEPRECATED_METRICS.append("sokalmichener") +if sp_base_version < parse_version("1.11"): + # Deprecated in SciPy 1.9 and removed in SciPy 1.11 + BOOL_METRICS += ["kulsinski"] +if sp_base_version >= parse_version("1.9"): + DEPRECATED_METRICS.append("kulsinski") +if sp_base_version < parse_version("1.9"): + # Deprecated in SciPy 1.0 and removed in SciPy 1.9 + BOOL_METRICS += ["matching"] +if sp_base_version >= parse_version("1.0"): + DEPRECATED_METRICS.append("matching") + +def get_valid_metric_ids(L): + """Given an iterable of metric class names or class identifiers, + return a list of metric IDs which map to those classes. + + Example: + >>> L = get_valid_metric_ids([EuclideanDistance, 'ManhattanDistance']) + >>> sorted(L) + ['cityblock', 'euclidean', 'l1', 'l2', 'manhattan'] + """ + return [key for (key, val) in METRIC_MAPPING64.items() + if (val.__name__ in L) or (val in L)] + +cdef class DistanceMetric: + """Uniform interface for fast distance metric functions. + + The `DistanceMetric` class provides a convenient way to compute pairwise distances + between samples. It supports various distance metrics, such as Euclidean distance, + Manhattan distance, and more. + + The `pairwise` method can be used to compute pairwise distances between samples in + the input arrays. It returns a distance matrix representing the distances between + all pairs of samples. + + The :meth:`get_metric` method allows you to retrieve a specific metric using its + string identifier. + + Examples + -------- + >>> from sklearn.metrics import DistanceMetric + >>> dist = DistanceMetric.get_metric('euclidean') + >>> X = [[1, 2], [3, 4], [5, 6]] + >>> Y = [[7, 8], [9, 10]] + >>> dist.pairwise(X,Y) + array([[7.81..., 10.63...] + [5.65..., 8.48...] + [1.41..., 4.24...]]) + + .. rubric:: Available Metrics + + The following lists the string metric identifiers and the associated + distance metric classes: + + **Metrics intended for real-valued vector spaces:** + + ============== ==================== ======== =============================== + identifier class name args distance function + -------------- -------------------- -------- ------------------------------- + "euclidean" EuclideanDistance - ``sqrt(sum((x - y)^2))`` + "manhattan" ManhattanDistance - ``sum(|x - y|)`` + "chebyshev" ChebyshevDistance - ``max(|x - y|)`` + "minkowski" MinkowskiDistance p, w ``sum(w * |x - y|^p)^(1/p)`` + "seuclidean" SEuclideanDistance V ``sqrt(sum((x - y)^2 / V))`` + "mahalanobis" MahalanobisDistance V or VI ``sqrt((x - y)' V^-1 (x - y))`` + ============== ==================== ======== =============================== + + **Metrics intended for two-dimensional vector spaces:** Note that the haversine + distance metric requires data in the form of [latitude, longitude] and both + inputs and outputs are in units of radians. + + ============ ================== =============================================================== + identifier class name distance function + ------------ ------------------ --------------------------------------------------------------- + "haversine" HaversineDistance ``2 arcsin(sqrt(sin^2(0.5*dx) + cos(x1)cos(x2)sin^2(0.5*dy)))`` + ============ ================== =============================================================== + + + **Metrics intended for integer-valued vector spaces:** Though intended + for integer-valued vectors, these are also valid metrics in the case of + real-valued vectors. + + ============= ==================== ======================================== + identifier class name distance function + ------------- -------------------- ---------------------------------------- + "hamming" HammingDistance ``N_unequal(x, y) / N_tot`` + "canberra" CanberraDistance ``sum(|x - y| / (|x| + |y|))`` + "braycurtis" BrayCurtisDistance ``sum(|x - y|) / (sum(|x|) + sum(|y|))`` + ============= ==================== ======================================== + + **Metrics intended for boolean-valued vector spaces:** Any nonzero entry + is evaluated to "True". In the listings below, the following + abbreviations are used: + + - N: number of dimensions + - NTT: number of dims in which both values are True + - NTF: number of dims in which the first value is True, second is False + - NFT: number of dims in which the first value is False, second is True + - NFF: number of dims in which both values are False + - NNEQ: number of non-equal dimensions, NNEQ = NTF + NFT + - NNZ: number of nonzero dimensions, NNZ = NTF + NFT + NTT + + ================= ======================= =============================== + identifier class name distance function + ----------------- ----------------------- ------------------------------- + "jaccard" JaccardDistance NNEQ / NNZ + "matching" MatchingDistance NNEQ / N + "dice" DiceDistance NNEQ / (NTT + NNZ) + "kulsinski" KulsinskiDistance (NNEQ + N - NTT) / (NNEQ + N) + "rogerstanimoto" RogersTanimotoDistance 2 * NNEQ / (N + NNEQ) + "russellrao" RussellRaoDistance (N - NTT) / N + "sokalmichener" SokalMichenerDistance 2 * NNEQ / (N + NNEQ) + "sokalsneath" SokalSneathDistance NNEQ / (NNEQ + 0.5 * NTT) + ================= ======================= =============================== + + **User-defined distance:** + + =========== =============== ======= + identifier class name args + ----------- --------------- ------- + "pyfunc" PyFuncDistance func + =========== =============== ======= + + Here ``func`` is a function which takes two one-dimensional numpy + arrays, and returns a distance. Note that in order to be used within + the BallTree, the distance must be a true metric: + i.e. it must satisfy the following properties + + 1) Non-negativity: d(x, y) >= 0 + 2) Identity: d(x, y) = 0 if and only if x == y + 3) Symmetry: d(x, y) = d(y, x) + 4) Triangle Inequality: d(x, y) + d(y, z) >= d(x, z) + + Because of the Python object overhead involved in calling the python + function, this will be fairly slow, but it will have the same + scaling as other distances. + """ + @classmethod + def get_metric(cls, metric, dtype=np.float64, **kwargs): + """Get the given distance metric from the string identifier. + + See the docstring of DistanceMetric for a list of available metrics. + + Parameters + ---------- + metric : str or class name + The string identifier or class name of the desired distance metric. + See the documentation of the `DistanceMetric` class for a list of + available metrics. + + dtype : {np.float32, np.float64}, default=np.float64 + The data type of the input on which the metric will be applied. + This affects the precision of the computed distances. + By default, it is set to `np.float64`. + + **kwargs + Additional keyword arguments that will be passed to the requested metric. + These arguments can be used to customize the behavior of the specific + metric. + + Returns + ------- + metric_obj : instance of the requested metric + An instance of the requested distance metric class. + """ + if dtype == np.float32: + specialized_class = DistanceMetric32 + elif dtype == np.float64: + specialized_class = DistanceMetric64 + else: + raise ValueError( + f"Unexpected dtype {dtype} provided. Please select a dtype from" + " {np.float32, np.float64}" + ) + + return specialized_class.get_metric(metric, **kwargs) + +{{for name_suffix, INPUT_DTYPE_t, INPUT_DTYPE in implementation_specific_values}} + +###################################################################### +# metric mappings +# These map from metric id strings to class names +METRIC_MAPPING{{name_suffix}} = { + 'euclidean': EuclideanDistance{{name_suffix}}, + 'l2': EuclideanDistance{{name_suffix}}, + 'minkowski': MinkowskiDistance{{name_suffix}}, + 'p': MinkowskiDistance{{name_suffix}}, + 'manhattan': ManhattanDistance{{name_suffix}}, + 'cityblock': ManhattanDistance{{name_suffix}}, + 'l1': ManhattanDistance{{name_suffix}}, + 'chebyshev': ChebyshevDistance{{name_suffix}}, + 'infinity': ChebyshevDistance{{name_suffix}}, + 'seuclidean': SEuclideanDistance{{name_suffix}}, + 'mahalanobis': MahalanobisDistance{{name_suffix}}, + 'hamming': HammingDistance{{name_suffix}}, + 'canberra': CanberraDistance{{name_suffix}}, + 'braycurtis': BrayCurtisDistance{{name_suffix}}, + 'matching': MatchingDistance{{name_suffix}}, + 'jaccard': JaccardDistance{{name_suffix}}, + 'dice': DiceDistance{{name_suffix}}, + 'kulsinski': KulsinskiDistance{{name_suffix}}, + 'rogerstanimoto': RogersTanimotoDistance{{name_suffix}}, + 'russellrao': RussellRaoDistance{{name_suffix}}, + 'sokalmichener': SokalMichenerDistance{{name_suffix}}, + 'sokalsneath': SokalSneathDistance{{name_suffix}}, + 'haversine': HaversineDistance{{name_suffix}}, + 'pyfunc': PyFuncDistance{{name_suffix}}, +} + +cdef inline object _buffer_to_ndarray{{name_suffix}}(const {{INPUT_DTYPE_t}}* x, intp_t n): + # Wrap a memory buffer with an ndarray. Warning: this is not robust. + # In particular, if x is deallocated before the returned array goes + # out of scope, this could cause memory errors. Since there is not + # a possibility of this for our use-case, this should be safe. + + # Note: this Segfaults unless np.import_array() is called above + # TODO: remove the explicit cast to cnp.intp_t* when cython min version >= 3.0 + return cnp.PyArray_SimpleNewFromData(1, &n, cnp.NPY_FLOAT64, x) + + +cdef {{INPUT_DTYPE_t}} INF{{name_suffix}} = np.inf + + +###################################################################### +# Distance Metric Classes +cdef class DistanceMetric{{name_suffix}}(DistanceMetric): + """DistanceMetric class + + This class provides a uniform interface to fast distance metric + functions. The various metrics can be accessed via the :meth:`get_metric` + class method and the metric string identifier (see below). + + Examples + -------- + >>> from sklearn.metrics import DistanceMetric + >>> dist = DistanceMetric.get_metric('euclidean') + >>> X = [[0, 1, 2], + [3, 4, 5]] + >>> dist.pairwise(X) + array([[ 0. , 5.19615242], + [ 5.19615242, 0. ]]) + + Available Metrics + + The following lists the string metric identifiers and the associated + distance metric classes: + + **Metrics intended for real-valued vector spaces:** + + ============== ==================== ======== =============================== + identifier class name args distance function + -------------- -------------------- -------- ------------------------------- + "euclidean" EuclideanDistance - ``sqrt(sum((x - y)^2))`` + "manhattan" ManhattanDistance - ``sum(|x - y|)`` + "chebyshev" ChebyshevDistance - ``max(|x - y|)`` + "minkowski" MinkowskiDistance p, w ``sum(w * |x - y|^p)^(1/p)`` + "seuclidean" SEuclideanDistance V ``sqrt(sum((x - y)^2 / V))`` + "mahalanobis" MahalanobisDistance V or VI ``sqrt((x - y)' V^-1 (x - y))`` + ============== ==================== ======== =============================== + + **Metrics intended for two-dimensional vector spaces:** Note that the haversine + distance metric requires data in the form of [latitude, longitude] and both + inputs and outputs are in units of radians. + + ============ ================== =============================================================== + identifier class name distance function + ------------ ------------------ --------------------------------------------------------------- + "haversine" HaversineDistance ``2 arcsin(sqrt(sin^2(0.5*dx) + cos(x1)cos(x2)sin^2(0.5*dy)))`` + ============ ================== =============================================================== + + + **Metrics intended for integer-valued vector spaces:** Though intended + for integer-valued vectors, these are also valid metrics in the case of + real-valued vectors. + + ============= ==================== ======================================== + identifier class name distance function + ------------- -------------------- ---------------------------------------- + "hamming" HammingDistance ``N_unequal(x, y) / N_tot`` + "canberra" CanberraDistance ``sum(|x - y| / (|x| + |y|))`` + "braycurtis" BrayCurtisDistance ``sum(|x - y|) / (sum(|x|) + sum(|y|))`` + ============= ==================== ======================================== + + **Metrics intended for boolean-valued vector spaces:** Any nonzero entry + is evaluated to "True". In the listings below, the following + abbreviations are used: + + - N: number of dimensions + - NTT: number of dims in which both values are True + - NTF: number of dims in which the first value is True, second is False + - NFT: number of dims in which the first value is False, second is True + - NFF: number of dims in which both values are False + - NNEQ: number of non-equal dimensions, NNEQ = NTF + NFT + - NNZ: number of nonzero dimensions, NNZ = NTF + NFT + NTT + + ================= ======================= =============================== + identifier class name distance function + ----------------- ----------------------- ------------------------------- + "jaccard" JaccardDistance NNEQ / NNZ + "matching" MatchingDistance NNEQ / N + "dice" DiceDistance NNEQ / (NTT + NNZ) + "kulsinski" KulsinskiDistance (NNEQ + N - NTT) / (NNEQ + N) + "rogerstanimoto" RogersTanimotoDistance 2 * NNEQ / (N + NNEQ) + "russellrao" RussellRaoDistance (N - NTT) / N + "sokalmichener" SokalMichenerDistance 2 * NNEQ / (N + NNEQ) + "sokalsneath" SokalSneathDistance NNEQ / (NNEQ + 0.5 * NTT) + ================= ======================= =============================== + + **User-defined distance:** + + =========== =============== ======= + identifier class name args + ----------- --------------- ------- + "pyfunc" PyFuncDistance func + =========== =============== ======= + + Here ``func`` is a function which takes two one-dimensional numpy + arrays, and returns a distance. Note that in order to be used within + the BallTree, the distance must be a true metric: + i.e. it must satisfy the following properties + + 1) Non-negativity: d(x, y) >= 0 + 2) Identity: d(x, y) = 0 if and only if x == y + 3) Symmetry: d(x, y) = d(y, x) + 4) Triangle Inequality: d(x, y) + d(y, z) >= d(x, z) + + Because of the Python object overhead involved in calling the python + function, this will be fairly slow, but it will have the same + scaling as other distances. + """ + def __cinit__(self): + self.p = 2 + self.vec = np.zeros(1, dtype=np.float64, order='C') + self.mat = np.zeros((1, 1), dtype=np.float64, order='C') + self.size = 1 + + def __reduce__(self): + """ + reduce method used for pickling + """ + return (newObj, (self.__class__,), self.__getstate__()) + + def __getstate__(self): + """ + get state for pickling + """ + if self.__class__.__name__ == "PyFuncDistance{{name_suffix}}": + return (float(self.p), np.asarray(self.vec), np.asarray(self.mat), self.func, self.kwargs) + return (float(self.p), np.asarray(self.vec), np.asarray(self.mat)) + + def __setstate__(self, state): + """ + set state for pickling + """ + self.p = state[0] + self.vec = state[1] + self.mat = state[2] + if self.__class__.__name__ == "PyFuncDistance{{name_suffix}}": + self.func = state[3] + self.kwargs = state[4] + self.size = self.vec.shape[0] + + @classmethod + def get_metric(cls, metric, **kwargs): + """Get the given distance metric from the string identifier. + + See the docstring of DistanceMetric for a list of available metrics. + + Parameters + ---------- + metric : str or class name + The distance metric to use + **kwargs + additional arguments will be passed to the requested metric + """ + if isinstance(metric, DistanceMetric{{name_suffix}}): + return metric + + if callable(metric): + return PyFuncDistance{{name_suffix}}(metric, **kwargs) + + # Map the metric string ID to the metric class + if isinstance(metric, type) and issubclass(metric, DistanceMetric{{name_suffix}}): + pass + else: + try: + metric = METRIC_MAPPING{{name_suffix}}[metric] + except: + raise ValueError("Unrecognized metric '%s'" % metric) + + # In Minkowski special cases, return more efficient methods + if metric is MinkowskiDistance{{name_suffix}}: + p = kwargs.pop('p', 2) + w = kwargs.pop('w', None) + if p == 1 and w is None: + return ManhattanDistance{{name_suffix}}(**kwargs) + elif p == 2 and w is None: + return EuclideanDistance{{name_suffix}}(**kwargs) + elif np.isinf(p) and w is None: + return ChebyshevDistance{{name_suffix}}(**kwargs) + else: + return MinkowskiDistance{{name_suffix}}(p, w, **kwargs) + else: + return metric(**kwargs) + + def __init__(self): + if self.__class__ is DistanceMetric{{name_suffix}}: + raise NotImplementedError("DistanceMetric{{name_suffix}} is an abstract class") + + def _validate_data(self, X): + """Validate the input data. + + This should be overridden in a base class if a specific input format + is required. + """ + return + + cdef {{INPUT_DTYPE_t}} dist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + """Compute the distance between vectors x1 and x2 + + This should be overridden in a base class. + """ + return -999 + + cdef {{INPUT_DTYPE_t}} rdist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + """Compute the rank-preserving surrogate distance between vectors x1 and x2. + + This can optionally be overridden in a base class. + + The rank-preserving surrogate distance is any measure that yields the same + rank as the distance, but is more efficient to compute. For example, the + rank-preserving surrogate distance of the Euclidean metric is the + squared-euclidean distance. + """ + return self.dist(x1, x2, size) + + cdef int pdist( + self, + const {{INPUT_DTYPE_t}}[:, ::1] X, + {{INPUT_DTYPE_t}}[:, ::1] D, + ) except -1: + """Compute the pairwise distances between points in X""" + cdef intp_t i1, i2 + for i1 in range(X.shape[0]): + for i2 in range(i1, X.shape[0]): + D[i1, i2] = self.dist(&X[i1, 0], &X[i2, 0], X.shape[1]) + D[i2, i1] = D[i1, i2] + return 0 + + + cdef int cdist( + self, + const {{INPUT_DTYPE_t}}[:, ::1] X, + const {{INPUT_DTYPE_t}}[:, ::1] Y, + {{INPUT_DTYPE_t}}[:, ::1] D, + ) except -1: + """Compute the cross-pairwise distances between arrays X and Y""" + cdef intp_t i1, i2 + if X.shape[1] != Y.shape[1]: + raise ValueError('X and Y must have the same second dimension') + for i1 in range(X.shape[0]): + for i2 in range(Y.shape[0]): + D[i1, i2] = self.dist(&X[i1, 0], &Y[i2, 0], X.shape[1]) + return 0 + + cdef {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + """Compute the distance between vectors x1 and x2 represented + under the CSR format. + + This must be overridden in a subclass. + + Notes + ----- + 0. The implementation of this method in subclasses must be robust to the + presence of explicit zeros in the CSR representation. + + 1. The `data` arrays are passed using pointers to be able to support an + alternative representation of the CSR data structure for supporting + fused sparse-dense datasets pairs with minimum overhead. + + See the explanations in `SparseDenseDatasetsPair.__init__`. + + 2. An alternative signature would be: + + cdef {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + ) except -1 nogil: + + Where callers would use slicing on the original CSR data and indices + memoryviews: + + x1_start = X1_csr.indices_ptr[i] + x1_end = X1_csr.indices_ptr[i+1] + x2_start = X2_csr.indices_ptr[j] + x2_end = X2_csr.indices_ptr[j+1] + + self.dist_csr( + &x1_data[x1_start], + x1_indices[x1_start:x1_end], + &x2_data[x2_start], + x2_indices[x2_start:x2_end], + ) + + Yet, slicing on memoryview slows down execution as it takes the GIL. + See: https://github.com/scikit-learn/scikit-learn/issues/17299 + + Hence, to avoid slicing the data and indices arrays of the sparse + matrices containing respectively x1 and x2 (namely x{1,2}_{data,indices}) + are passed as well as their indices pointers (namely x{1,2}_{start,end}). + + 3. For reference about the CSR format, see section 3.4 of + Saad, Y. (2003), Iterative Methods for Sparse Linear Systems, SIAM. + https://www-users.cse.umn.edu/~saad/IterMethBook_2ndEd.pdf + """ + return -999 + + cdef {{INPUT_DTYPE_t}} rdist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + """Distance between rows of CSR matrices x1 and x2. + + This can optionally be overridden in a subclass. + + The rank-preserving surrogate distance is any measure that yields the same + rank as the distance, but is more efficient to compute. For example, the + rank-preserving surrogate distance of the Euclidean metric is the + squared-euclidean distance. + + Notes + ----- + The implementation of this method in subclasses must be robust to the + presence of explicit zeros in the CSR representation. + + More information about the motives for this method signature is given + in the docstring of dist_csr. + """ + return self.dist_csr( + x1_data, + x1_indices, + x2_data, + x2_indices, + x1_start, + x1_end, + x2_start, + x2_end, + size, + ) + + cdef int pdist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t[::1] x1_indices, + const int32_t[::1] x1_indptr, + const intp_t size, + {{INPUT_DTYPE_t}}[:, ::1] D, + ) except -1 nogil: + """Pairwise distances between rows in CSR matrix X. + + Note that this implementation is twice faster than cdist_csr(X, X) + because it leverages the symmetry of the problem. + """ + cdef: + intp_t i1, i2 + intp_t n_x1 = x1_indptr.shape[0] - 1 + intp_t x1_start, x1_end, x2_start, x2_end + + for i1 in range(n_x1): + x1_start = x1_indptr[i1] + x1_end = x1_indptr[i1 + 1] + for i2 in range(i1, n_x1): + x2_start = x1_indptr[i2] + x2_end = x1_indptr[i2 + 1] + D[i1, i2] = D[i2, i1] = self.dist_csr( + x1_data, + &x1_indices[0], + x1_data, + &x1_indices[0], + x1_start, + x1_end, + x2_start, + x2_end, + size, + ) + return 0 + + cdef int cdist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t[::1] x1_indices, + const int32_t[::1] x1_indptr, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t[::1] x2_indices, + const int32_t[::1] x2_indptr, + const intp_t size, + {{INPUT_DTYPE_t}}[:, ::1] D, + ) except -1 nogil: + """Compute the cross-pairwise distances between arrays X and Y + represented in the CSR format.""" + cdef: + intp_t i1, i2 + intp_t n_x1 = x1_indptr.shape[0] - 1 + intp_t n_x2 = x2_indptr.shape[0] - 1 + intp_t x1_start, x1_end, x2_start, x2_end + + for i1 in range(n_x1): + x1_start = x1_indptr[i1] + x1_end = x1_indptr[i1 + 1] + for i2 in range(n_x2): + x2_start = x2_indptr[i2] + x2_end = x2_indptr[i2 + 1] + + D[i1, i2] = self.dist_csr( + x1_data, + &x1_indices[0], + x2_data, + &x2_indices[0], + x1_start, + x1_end, + x2_start, + x2_end, + size, + ) + return 0 + + cdef {{INPUT_DTYPE_t}} _rdist_to_dist(self, {{INPUT_DTYPE_t}} rdist) except -1 nogil: + """Convert the rank-preserving surrogate distance to the distance""" + return rdist + + cdef {{INPUT_DTYPE_t}} _dist_to_rdist(self, {{INPUT_DTYPE_t}} dist) except -1 nogil: + """Convert the distance to the rank-preserving surrogate distance""" + return dist + + def rdist_to_dist(self, rdist): + """Convert the rank-preserving surrogate distance to the distance. + + The surrogate distance is any measure that yields the same rank as the + distance, but is more efficient to compute. For example, the + rank-preserving surrogate distance of the Euclidean metric is the + squared-euclidean distance. + + Parameters + ---------- + rdist : double + Surrogate distance. + + Returns + ------- + double + True distance. + """ + return rdist + + def dist_to_rdist(self, dist): + """Convert the true distance to the rank-preserving surrogate distance. + + The surrogate distance is any measure that yields the same rank as the + distance, but is more efficient to compute. For example, the + rank-preserving surrogate distance of the Euclidean metric is the + squared-euclidean distance. + + Parameters + ---------- + dist : double + True distance. + + Returns + ------- + double + Surrogate distance. + """ + return dist + + def _pairwise_dense_dense(self, X, Y): + cdef const {{INPUT_DTYPE_t}}[:, ::1] Xarr + cdef const {{INPUT_DTYPE_t}}[:, ::1] Yarr + cdef {{INPUT_DTYPE_t}}[:, ::1] Darr + + Xarr = np.asarray(X, dtype={{INPUT_DTYPE}}, order='C') + self._validate_data(Xarr) + if X is Y: + Darr = np.empty((Xarr.shape[0], Xarr.shape[0]), dtype={{INPUT_DTYPE}}, order='C') + self.pdist(Xarr, Darr) + else: + Yarr = np.asarray(Y, dtype={{INPUT_DTYPE}}, order='C') + self._validate_data(Yarr) + Darr = np.empty((Xarr.shape[0], Yarr.shape[0]), dtype={{INPUT_DTYPE}}, order='C') + self.cdist(Xarr, Yarr, Darr) + return np.asarray(Darr) + + def _pairwise_sparse_sparse(self, X: csr_matrix , Y: csr_matrix): + cdef: + intp_t n_X, n_features + const {{INPUT_DTYPE_t}}[::1] X_data + const int32_t[::1] X_indices + const int32_t[::1] X_indptr + + intp_t n_Y + const {{INPUT_DTYPE_t}}[::1] Y_data + const int32_t[::1] Y_indices + const int32_t[::1] Y_indptr + + {{INPUT_DTYPE_t}}[:, ::1] Darr + + X_csr = X.tocsr() + n_X, n_features = X_csr.shape + X_data = np.asarray(X_csr.data, dtype={{INPUT_DTYPE}}) + X_indices = np.asarray(X_csr.indices, dtype=np.int32) + X_indptr = np.asarray(X_csr.indptr, dtype=np.int32) + if X is Y: + Darr = np.empty((n_X, n_X), dtype={{INPUT_DTYPE}}, order='C') + self.pdist_csr( + x1_data=&X_data[0], + x1_indices=X_indices, + x1_indptr=X_indptr, + size=n_features, + D=Darr, + ) + else: + Y_csr = Y.tocsr() + n_Y, _ = Y_csr.shape + Y_data = np.asarray(Y_csr.data, dtype={{INPUT_DTYPE}}) + Y_indices = np.asarray(Y_csr.indices, dtype=np.int32) + Y_indptr = np.asarray(Y_csr.indptr, dtype=np.int32) + + Darr = np.empty((n_X, n_Y), dtype={{INPUT_DTYPE}}, order='C') + self.cdist_csr( + x1_data=&X_data[0], + x1_indices=X_indices, + x1_indptr=X_indptr, + x2_data=&Y_data[0], + x2_indices=Y_indices, + x2_indptr=Y_indptr, + size=n_features, + D=Darr, + ) + return np.asarray(Darr) + + def _pairwise_sparse_dense(self, X: csr_matrix, Y): + cdef: + intp_t n_X = X.shape[0] + intp_t n_features = X.shape[1] + const {{INPUT_DTYPE_t}}[::1] X_data = np.asarray( + X.data, dtype={{INPUT_DTYPE}}, + ) + const int32_t[::1] X_indices = np.asarray( + X.indices, dtype=np.int32, + ) + const int32_t[::1] X_indptr = np.asarray( + X.indptr, dtype=np.int32, + ) + + const {{INPUT_DTYPE_t}}[:, ::1] Y_data = np.asarray( + Y, dtype={{INPUT_DTYPE}}, order="C", + ) + intp_t n_Y = Y_data.shape[0] + const int32_t[::1] Y_indices = ( + np.arange(n_features, dtype=np.int32) + ) + + {{INPUT_DTYPE_t}}[:, ::1] Darr = np.empty((n_X, n_Y), dtype={{INPUT_DTYPE}}, order='C') + + intp_t i1, i2 + intp_t x1_start, x1_end + {{INPUT_DTYPE_t}} * x2_data + + with nogil: + # Use the exact same adaptation for CSR than in SparseDenseDatasetsPair + # for supporting the sparse-dense case with minimal overhead. + # Note: at this point this method is only a convenience method + # used in the tests via the DistanceMetric.pairwise method. + # Therefore, there is no need to attempt parallelization of those + # nested for-loops. + # Efficient parallel computation of pairwise distances can be + # achieved via the PairwiseDistances class instead. The latter + # internally calls into vector-wise distance computation from + # the DistanceMetric subclass while benefiting from the generic + # Cython/OpenMP parallelization template for the generic pairwise + # distance + reduction computational pattern. + for i1 in range(n_X): + x1_start = X_indptr[i1] + x1_end = X_indptr[i1 + 1] + for i2 in range(n_Y): + x2_data = &Y_data[0, 0] + i2 * n_features + + Darr[i1, i2] = self.dist_csr( + x1_data=&X_data[0], + x1_indices=&X_indices[0], + x2_data=x2_data, + x2_indices=&Y_indices[0], + x1_start=x1_start, + x1_end=x1_end, + x2_start=0, + x2_end=n_features, + size=n_features, + ) + + return np.asarray(Darr) + + def _pairwise_dense_sparse(self, X, Y: csr_matrix): + # We could have implemented this method using _pairwise_dense_sparse by + # swapping argument and by transposing the results, but this would + # have come with an extra copy to ensure C-contiguity of the result. + cdef: + intp_t n_X = X.shape[0] + intp_t n_features = X.shape[1] + + const {{INPUT_DTYPE_t}}[:, ::1] X_data = np.asarray( + X, dtype={{INPUT_DTYPE}}, order="C", + ) + const int32_t[::1] X_indices = np.arange( + n_features, dtype=np.int32, + ) + + intp_t n_Y = Y.shape[0] + const {{INPUT_DTYPE_t}}[::1] Y_data = np.asarray( + Y.data, dtype={{INPUT_DTYPE}}, + ) + const int32_t[::1] Y_indices = np.asarray( + Y.indices, dtype=np.int32, + ) + const int32_t[::1] Y_indptr = np.asarray( + Y.indptr, dtype=np.int32, + ) + + {{INPUT_DTYPE_t}}[:, ::1] Darr = np.empty((n_X, n_Y), dtype={{INPUT_DTYPE}}, order='C') + + intp_t i1, i2 + {{INPUT_DTYPE_t}} * x1_data + + intp_t x2_start, x2_end + + with nogil: + # Use the exact same adaptation for CSR than in SparseDenseDatasetsPair + # for supporting the dense-sparse case with minimal overhead. + # Note: at this point this method is only a convenience method + # used in the tests via the DistanceMetric.pairwise method. + # Therefore, there is no need to attempt parallelization of those + # nested for-loops. + # Efficient parallel computation of pairwise distances can be + # achieved via the PairwiseDistances class instead. The latter + # internally calls into vector-wise distance computation from + # the DistanceMetric subclass while benefiting from the generic + # Cython/OpenMP parallelization template for the generic pairwise + # distance + reduction computational pattern. + for i1 in range(n_X): + x1_data = &X_data[0, 0] + i1 * n_features + for i2 in range(n_Y): + x2_start = Y_indptr[i2] + x2_end = Y_indptr[i2 + 1] + + Darr[i1, i2] = self.dist_csr( + x1_data=x1_data, + x1_indices=&X_indices[0], + x2_data=&Y_data[0], + x2_indices=&Y_indices[0], + x1_start=0, + x1_end=n_features, + x2_start=x2_start, + x2_end=x2_end, + size=n_features, + ) + + return np.asarray(Darr) + + + def pairwise(self, X, Y=None): + """Compute the pairwise distances between X and Y + + This is a convenience routine for the sake of testing. For many + metrics, the utilities in scipy.spatial.distance.cdist and + scipy.spatial.distance.pdist will be faster. + + Parameters + ---------- + X : ndarray or CSR matrix of shape (n_samples_X, n_features) + Input data. + Y : ndarray or CSR matrix of shape (n_samples_Y, n_features) + Input data. + If not specified, then Y=X. + + Returns + ------- + dist : ndarray of shape (n_samples_X, n_samples_Y) + The distance matrix of pairwise distances between points in X and Y. + """ + X = check_array(X, accept_sparse=['csr']) + + if Y is None: + Y = X + else: + Y = check_array(Y, accept_sparse=['csr']) + + X_is_sparse = issparse(X) + Y_is_sparse = issparse(Y) + + if not X_is_sparse and not Y_is_sparse: + return self._pairwise_dense_dense(X, Y) + + if X_is_sparse and Y_is_sparse: + return self._pairwise_sparse_sparse(X, Y) + + if X_is_sparse and not Y_is_sparse: + return self._pairwise_sparse_dense(X, Y) + + return self._pairwise_dense_sparse(X, Y) + +#------------------------------------------------------------ +# Euclidean Distance +# d = sqrt(sum(x_i^2 - y_i^2)) +cdef class EuclideanDistance{{name_suffix}}(DistanceMetric{{name_suffix}}): + r"""Euclidean Distance metric + + .. math:: + D(x, y) = \sqrt{ \sum_i (x_i - y_i) ^ 2 } + """ + def __init__(self): + self.p = 2 + + cdef inline {{INPUT_DTYPE_t}} dist(self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + return euclidean_dist{{name_suffix}}(x1, x2, size) + + cdef inline {{INPUT_DTYPE_t}} rdist(self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + return euclidean_rdist{{name_suffix}}(x1, x2, size) + + cdef inline {{INPUT_DTYPE_t}} _rdist_to_dist(self, {{INPUT_DTYPE_t}} rdist) except -1 nogil: + return sqrt(rdist) + + cdef inline {{INPUT_DTYPE_t}} _dist_to_rdist(self, {{INPUT_DTYPE_t}} dist) except -1 nogil: + return dist * dist + + def rdist_to_dist(self, rdist): + return np.sqrt(rdist) + + def dist_to_rdist(self, dist): + return dist ** 2 + + cdef inline {{INPUT_DTYPE_t}} rdist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + + cdef: + intp_t ix1, ix2 + intp_t i1 = x1_start + intp_t i2 = x2_start + + float64_t d = 0.0 + float64_t unsquared = 0 + + while i1 < x1_end and i2 < x2_end: + ix1 = x1_indices[i1] + ix2 = x2_indices[i2] + + if ix1 == ix2: + unsquared = x1_data[i1] - x2_data[i2] + d = d + (unsquared * unsquared) + i1 = i1 + 1 + i2 = i2 + 1 + elif ix1 < ix2: + unsquared = x1_data[i1] + d = d + (unsquared * unsquared) + i1 = i1 + 1 + else: + unsquared = x2_data[i2] + d = d + (unsquared * unsquared) + i2 = i2 + 1 + + if i1 == x1_end: + while i2 < x2_end: + unsquared = x2_data[i2] + d = d + (unsquared * unsquared) + i2 = i2 + 1 + else: + while i1 < x1_end: + unsquared = x1_data[i1] + d = d + (unsquared * unsquared) + i1 = i1 + 1 + + return d + + cdef inline {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + return sqrt( + self.rdist_csr( + x1_data, + x1_indices, + x2_data, + x2_indices, + x1_start, + x1_end, + x2_start, + x2_end, + size, + )) + +#------------------------------------------------------------ +# SEuclidean Distance +# d = sqrt(sum((x_i - y_i2)^2 / v_i)) +cdef class SEuclideanDistance{{name_suffix}}(DistanceMetric{{name_suffix}}): + r"""Standardized Euclidean Distance metric + + .. math:: + D(x, y) = \sqrt{ \sum_i \frac{ (x_i - y_i) ^ 2}{V_i} } + """ + def __init__(self, V): + self.vec = np.asarray(V, dtype=np.float64) + self.size = self.vec.shape[0] + self.p = 2 + + def _validate_data(self, X): + if X.shape[1] != self.size: + raise ValueError('SEuclidean dist: size of V does not match') + + cdef inline {{INPUT_DTYPE_t}} rdist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + cdef float64_t tmp, d=0 + cdef intp_t j + for j in range(size): + tmp = x1[j] - x2[j] + d += (tmp * tmp / self.vec[j]) + return d + + cdef inline {{INPUT_DTYPE_t}} dist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + return sqrt(self.rdist(x1, x2, size)) + + cdef inline {{INPUT_DTYPE_t}} _rdist_to_dist(self, {{INPUT_DTYPE_t}} rdist) except -1 nogil: + return sqrt(rdist) + + cdef inline {{INPUT_DTYPE_t}} _dist_to_rdist(self, {{INPUT_DTYPE_t}} dist) except -1 nogil: + return dist * dist + + def rdist_to_dist(self, rdist): + return np.sqrt(rdist) + + def dist_to_rdist(self, dist): + return dist ** 2 + + cdef inline {{INPUT_DTYPE_t}} rdist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + + cdef: + intp_t ix1, ix2 + intp_t i1 = x1_start + intp_t i2 = x2_start + + float64_t d = 0.0 + float64_t unsquared = 0 + + while i1 < x1_end and i2 < x2_end: + ix1 = x1_indices[i1] + ix2 = x2_indices[i2] + + if ix1 == ix2: + unsquared = x1_data[i1] - x2_data[i2] + d = d + (unsquared * unsquared) / self.vec[ix1] + i1 = i1 + 1 + i2 = i2 + 1 + elif ix1 < ix2: + unsquared = x1_data[i1] + d = d + (unsquared * unsquared) / self.vec[ix1] + i1 = i1 + 1 + else: + unsquared = x2_data[i2] + d = d + (unsquared * unsquared) / self.vec[ix2] + i2 = i2 + 1 + + if i1 == x1_end: + while i2 < x2_end: + ix2 = x2_indices[i2] + unsquared = x2_data[i2] + d = d + (unsquared * unsquared) / self.vec[ix2] + i2 = i2 + 1 + else: + while i1 < x1_end: + ix1 = x1_indices[i1] + unsquared = x1_data[i1] + d = d + (unsquared * unsquared) / self.vec[ix1] + i1 = i1 + 1 + return d + + cdef inline {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + return sqrt( + self.rdist_csr( + x1_data, + x1_indices, + x2_data, + x2_indices, + x1_start, + x1_end, + x2_start, + x2_end, + size, + )) + +#------------------------------------------------------------ +# Manhattan Distance +# d = sum(abs(x_i - y_i)) +cdef class ManhattanDistance{{name_suffix}}(DistanceMetric{{name_suffix}}): + r"""Manhattan/City-block Distance metric + + .. math:: + D(x, y) = \sum_i |x_i - y_i| + """ + def __init__(self): + self.p = 1 + + cdef inline {{INPUT_DTYPE_t}} dist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + cdef float64_t d = 0 + cdef intp_t j + for j in range(size): + d += fabs(x1[j] - x2[j]) + return d + + cdef inline {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + + cdef: + intp_t ix1, ix2 + intp_t i1 = x1_start + intp_t i2 = x2_start + + {{INPUT_DTYPE_t}} d = 0.0 + + while i1 < x1_end and i2 < x2_end: + ix1 = x1_indices[i1] + ix2 = x2_indices[i2] + + if ix1 == ix2: + d = d + fabs(x1_data[i1] - x2_data[i2]) + i1 = i1 + 1 + i2 = i2 + 1 + elif ix1 < ix2: + d = d + fabs(x1_data[i1]) + i1 = i1 + 1 + else: + d = d + fabs(x2_data[i2]) + i2 = i2 + 1 + + if i1 == x1_end: + while i2 < x2_end: + d = d + fabs(x2_data[i2]) + i2 = i2 + 1 + else: + while i1 < x1_end: + d = d + fabs(x1_data[i1]) + i1 = i1 + 1 + + return d + + +#------------------------------------------------------------ +# Chebyshev Distance +# d = max_i(abs(x_i - y_i)) +cdef class ChebyshevDistance{{name_suffix}}(DistanceMetric{{name_suffix}}): + """Chebyshev/Infinity Distance + + .. math:: + D(x, y) = max_i (|x_i - y_i|) + + Examples + -------- + >>> from sklearn.metrics.dist_metrics import DistanceMetric + >>> dist = DistanceMetric.get_metric('chebyshev') + >>> X = [[0, 1, 2], + ... [3, 4, 5]] + >>> Y = [[-1, 0, 1], + ... [3, 4, 5]] + >>> dist.pairwise(X, Y) + array([[1.732..., 5.196...], + [6.928..., 0.... ]]) + """ + def __init__(self): + self.p = INF{{name_suffix}} + + cdef inline {{INPUT_DTYPE_t}} dist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + cdef float64_t d = 0 + cdef intp_t j + for j in range(size): + d = fmax(d, fabs(x1[j] - x2[j])) + return d + + + cdef inline {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + + cdef: + intp_t ix1, ix2 + intp_t i1 = x1_start + intp_t i2 = x2_start + + float64_t d = 0.0 + + while i1 < x1_end and i2 < x2_end: + ix1 = x1_indices[i1] + ix2 = x2_indices[i2] + + if ix1 == ix2: + d = fmax(d, fabs(x1_data[i1] - x2_data[i2])) + i1 = i1 + 1 + i2 = i2 + 1 + elif ix1 < ix2: + d = fmax(d, fabs(x1_data[i1])) + i1 = i1 + 1 + else: + d = fmax(d, fabs(x2_data[i2])) + i2 = i2 + 1 + + if i1 == x1_end: + while i2 < x2_end: + d = fmax(d, fabs(x2_data[i2])) + i2 = i2 + 1 + else: + while i1 < x1_end: + d = fmax(d, fabs(x1_data[i1])) + i1 = i1 + 1 + + return d + + +#------------------------------------------------------------ +# Minkowski Distance +cdef class MinkowskiDistance{{name_suffix}}(DistanceMetric{{name_suffix}}): + r"""Minkowski Distance + + .. math:: + D(x, y) = {||u-v||}_p + + when w is None. + + Here is the more general expanded expression for the weighted case: + + .. math:: + D(x, y) = [\sum_i w_i *|x_i - y_i|^p] ^ (1/p) + + Parameters + ---------- + p : float + The order of the p-norm of the difference (see above). + + .. versionchanged:: 1.4.0 + Minkowski distance allows `p` to be `0 0 and finite. + When :math:`p \in (0,1)`, it isn't a true metric but is permissible when + the triangular inequality isn't necessary. + For p = infinity, use ChebyshevDistance. + Note that for p=1, ManhattanDistance is more efficient, and for + p=2, EuclideanDistance is more efficient. + + """ + def __init__(self, p, w=None): + if p <= 0: + raise ValueError("p must be greater than 0") + elif np.isinf(p): + raise ValueError("MinkowskiDistance requires finite p. " + "For p=inf, use ChebyshevDistance.") + + self.p = p + if w is not None: + w_array = check_array( + w, ensure_2d=False, dtype=np.float64, input_name="w" + ) + if (w_array < 0).any(): + raise ValueError("w cannot contain negative weights") + self.vec = w_array + self.size = self.vec.shape[0] + else: + self.vec = np.asarray([], dtype=np.float64) + self.size = 0 + + def _validate_data(self, X): + if self.size > 0 and X.shape[1] != self.size: + raise ValueError("MinkowskiDistance: the size of w must match " + f"the number of features ({X.shape[1]}). " + f"Currently len(w)={self.size}.") + + cdef inline {{INPUT_DTYPE_t}} rdist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + cdef float64_t d=0 + cdef intp_t j + cdef bint has_w = self.size > 0 + if has_w: + for j in range(size): + d += (self.vec[j] * pow(fabs(x1[j] - x2[j]), self.p)) + else: + for j in range(size): + d += (pow(fabs(x1[j] - x2[j]), self.p)) + return d + + cdef inline {{INPUT_DTYPE_t}} dist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + return pow(self.rdist(x1, x2, size), 1. / self.p) + + cdef inline {{INPUT_DTYPE_t}} _rdist_to_dist(self, {{INPUT_DTYPE_t}} rdist) except -1 nogil: + return pow(rdist, 1. / self.p) + + cdef inline {{INPUT_DTYPE_t}} _dist_to_rdist(self, {{INPUT_DTYPE_t}} dist) except -1 nogil: + return pow(dist, self.p) + + def rdist_to_dist(self, rdist): + return rdist ** (1. / self.p) + + def dist_to_rdist(self, dist): + return dist ** self.p + + cdef inline {{INPUT_DTYPE_t}} rdist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + + cdef: + intp_t ix1, ix2 + intp_t i1 = x1_start + intp_t i2 = x2_start + + float64_t d = 0.0 + bint has_w = self.size > 0 + + if has_w: + while i1 < x1_end and i2 < x2_end: + ix1 = x1_indices[i1] + ix2 = x2_indices[i2] + + if ix1 == ix2: + d = d + (self.vec[ix1] * pow(fabs( + x1_data[i1] - x2_data[i2] + ), self.p)) + i1 = i1 + 1 + i2 = i2 + 1 + elif ix1 < ix2: + d = d + (self.vec[ix1] * pow(fabs(x1_data[i1]), self.p)) + i1 = i1 + 1 + else: + d = d + (self.vec[ix2] * pow(fabs(x2_data[i2]), self.p)) + i2 = i2 + 1 + + if i1 == x1_end: + while i2 < x2_end: + ix2 = x2_indices[i2] + d = d + (self.vec[ix2] * pow(fabs(x2_data[i2]), self.p)) + i2 = i2 + 1 + else: + while i1 < x1_end: + ix1 = x1_indices[i1] + d = d + (self.vec[ix1] * pow(fabs(x1_data[i1]), self.p)) + i1 = i1 + 1 + + return d + else: + while i1 < x1_end and i2 < x2_end: + ix1 = x1_indices[i1] + ix2 = x2_indices[i2] + + if ix1 == ix2: + d = d + (pow(fabs( + x1_data[i1] - x2_data[i2] + ), self.p)) + i1 = i1 + 1 + i2 = i2 + 1 + elif ix1 < ix2: + d = d + (pow(fabs(x1_data[i1]), self.p)) + i1 = i1 + 1 + else: + d = d + (pow(fabs(x2_data[i2]), self.p)) + i2 = i2 + 1 + + if i1 == x1_end: + while i2 < x2_end: + d = d + (pow(fabs(x2_data[i2]), self.p)) + i2 = i2 + 1 + else: + while i1 < x1_end: + d = d + (pow(fabs(x1_data[i1]), self.p)) + i1 = i1 + 1 + + return d + + cdef inline {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + return pow( + self.rdist_csr( + x1_data, + x1_indices, + x2_data, + x2_indices, + x1_start, + x1_end, + x2_start, + x2_end, + size, + ), + 1 / self.p + ) + +#------------------------------------------------------------ +# Mahalanobis Distance +# d = sqrt( (x - y)^T V^-1 (x - y) ) +cdef class MahalanobisDistance{{name_suffix}}(DistanceMetric{{name_suffix}}): + """Mahalanobis Distance + + .. math:: + D(x, y) = \sqrt{ (x - y)^T V^{-1} (x - y) } + + Parameters + ---------- + V : array-like + Symmetric positive-definite covariance matrix. + The inverse of this matrix will be explicitly computed. + VI : array-like + optionally specify the inverse directly. If VI is passed, + then V is not referenced. + """ + cdef float64_t[::1] buffer + + def __init__(self, V=None, VI=None): + if VI is None: + if V is None: + raise ValueError("Must provide either V or VI " + "for Mahalanobis distance") + VI = np.linalg.inv(V) + if VI.ndim != 2 or VI.shape[0] != VI.shape[1]: + raise ValueError("V/VI must be square") + + self.mat = np.asarray(VI, dtype=np.float64, order='C') + + self.size = self.mat.shape[0] + + # We need to create a buffer to store the vectors' coordinates' differences + self.buffer = np.zeros(self.size, dtype=np.float64) + + def __setstate__(self, state): + super().__setstate__(state) + self.size = self.mat.shape[0] + self.buffer = np.zeros(self.size, dtype=np.float64) + + def _validate_data(self, X): + if X.shape[1] != self.size: + raise ValueError('Mahalanobis dist: size of V does not match') + + cdef inline {{INPUT_DTYPE_t}} rdist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + cdef float64_t tmp, d = 0 + cdef intp_t i, j + + # compute (x1 - x2).T * VI * (x1 - x2) + for i in range(size): + self.buffer[i] = x1[i] - x2[i] + + for i in range(size): + tmp = 0 + for j in range(size): + tmp += self.mat[i, j] * self.buffer[j] + d += tmp * self.buffer[i] + return d + + cdef inline {{INPUT_DTYPE_t}} dist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + return sqrt(self.rdist(x1, x2, size)) + + cdef inline {{INPUT_DTYPE_t}} _rdist_to_dist(self, {{INPUT_DTYPE_t}} rdist) except -1 nogil: + return sqrt(rdist) + + cdef inline {{INPUT_DTYPE_t}} _dist_to_rdist(self, {{INPUT_DTYPE_t}} dist) except -1 nogil: + return dist * dist + + def rdist_to_dist(self, rdist): + return np.sqrt(rdist) + + def dist_to_rdist(self, dist): + return dist ** 2 + + cdef inline {{INPUT_DTYPE_t}} rdist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + + cdef: + intp_t ix1, ix2 + intp_t i1 = x1_start + intp_t i2 = x2_start + + float64_t tmp, d = 0.0 + + while i1 < x1_end and i2 < x2_end: + ix1 = x1_indices[i1] + ix2 = x2_indices[i2] + + if ix1 == ix2: + self.buffer[ix1] = x1_data[i1] - x2_data[i2] + i1 = i1 + 1 + i2 = i2 + 1 + elif ix1 < ix2: + self.buffer[ix1] = x1_data[i1] + i1 = i1 + 1 + else: + self.buffer[ix2] = - x2_data[i2] + i2 = i2 + 1 + + if i1 == x1_end: + while i2 < x2_end: + ix2 = x2_indices[i2] + self.buffer[ix2] = - x2_data[i2] + i2 = i2 + 1 + else: + while i1 < x1_end: + ix1 = x1_indices[i1] + self.buffer[ix1] = x1_data[i1] + i1 = i1 + 1 + + for i in range(size): + tmp = 0 + for j in range(size): + tmp += self.mat[i, j] * self.buffer[j] + d += tmp * self.buffer[i] + + return d + + cdef inline {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + return sqrt( + self.rdist_csr( + x1_data, + x1_indices, + x2_data, + x2_indices, + x1_start, + x1_end, + x2_start, + x2_end, + size, + )) + +#------------------------------------------------------------ +# Hamming Distance +# d = N_unequal(x, y) / N_tot +cdef class HammingDistance{{name_suffix}}(DistanceMetric{{name_suffix}}): + r"""Hamming Distance + + Hamming distance is meant for discrete-valued vectors, though it is + a valid metric for real-valued vectors. + + .. math:: + D(x, y) = \frac{1}{N} \sum_i \delta_{x_i, y_i} + """ + cdef inline {{INPUT_DTYPE_t}} dist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + cdef int n_unequal = 0 + cdef intp_t j + for j in range(size): + if x1[j] != x2[j]: + n_unequal += 1 + return float(n_unequal) / size + + + cdef inline {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + + cdef: + intp_t ix1, ix2 + intp_t i1 = x1_start + intp_t i2 = x2_start + + float64_t d = 0.0 + + while i1 < x1_end and i2 < x2_end: + ix1 = x1_indices[i1] + ix2 = x2_indices[i2] + + if ix1 == ix2: + d += (x1_data[i1] != x2_data[i2]) + i1 = i1 + 1 + i2 = i2 + 1 + elif ix1 < ix2: + d += (x1_data[i1] != 0) + i1 = i1 + 1 + else: + d += (x2_data[i2] != 0) + i2 = i2 + 1 + + if i1 == x1_end: + while i2 < x2_end: + d += (x2_data[i2] != 0) + i2 = i2 + 1 + else: + while i1 < x1_end: + d += (x1_data[i1] != 0) + i1 = i1 + 1 + + d /= size + + return d + + +#------------------------------------------------------------ +# Canberra Distance +# D(x, y) = sum[ abs(x_i - y_i) / (abs(x_i) + abs(y_i)) ] +cdef class CanberraDistance{{name_suffix}}(DistanceMetric{{name_suffix}}): + r"""Canberra Distance + + Canberra distance is meant for discrete-valued vectors, though it is + a valid metric for real-valued vectors. + + .. math:: + D(x, y) = \sum_i \frac{|x_i - y_i|}{|x_i| + |y_i|} + """ + cdef inline {{INPUT_DTYPE_t}} dist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + cdef float64_t denom, d = 0 + cdef intp_t j + for j in range(size): + denom = fabs(x1[j]) + fabs(x2[j]) + if denom > 0: + d += fabs(x1[j] - x2[j]) / denom + return d + + cdef inline {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + + cdef: + intp_t ix1, ix2 + intp_t i1 = x1_start + intp_t i2 = x2_start + + float64_t d = 0.0 + + while i1 < x1_end and i2 < x2_end: + ix1 = x1_indices[i1] + ix2 = x2_indices[i2] + + if ix1 == ix2: + d += ( + fabs(x1_data[i1] - x2_data[i2]) / + (fabs(x1_data[i1]) + fabs(x2_data[i2])) + ) + i1 = i1 + 1 + i2 = i2 + 1 + elif ix1 < ix2: + d += 1. + i1 = i1 + 1 + else: + d += 1. + i2 = i2 + 1 + + if i1 == x1_end: + while i2 < x2_end: + d += 1. + i2 = i2 + 1 + else: + while i1 < x1_end: + d += 1. + i1 = i1 + 1 + + return d + +#------------------------------------------------------------ +# Bray-Curtis Distance +# D(x, y) = sum[abs(x_i - y_i)] / sum[abs(x_i) + abs(y_i)] +cdef class BrayCurtisDistance{{name_suffix}}(DistanceMetric{{name_suffix}}): + r"""Bray-Curtis Distance + + Bray-Curtis distance is meant for discrete-valued vectors, though it is + a valid metric for real-valued vectors. + + .. math:: + D(x, y) = \frac{\sum_i |x_i - y_i|}{\sum_i(|x_i| + |y_i|)} + """ + cdef inline {{INPUT_DTYPE_t}} dist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + cdef float64_t num = 0, denom = 0 + cdef intp_t j + for j in range(size): + num += fabs(x1[j] - x2[j]) + denom += fabs(x1[j]) + fabs(x2[j]) + if denom > 0: + return num / denom + else: + return 0.0 + + cdef inline {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + + cdef: + intp_t ix1, ix2 + intp_t i1 = x1_start + intp_t i2 = x2_start + + float64_t num = 0.0 + float64_t denom = 0.0 + + while i1 < x1_end and i2 < x2_end: + ix1 = x1_indices[i1] + ix2 = x2_indices[i2] + + if ix1 == ix2: + num += fabs(x1_data[i1] - x2_data[i2]) + denom += fabs(x1_data[i1]) + fabs(x2_data[i2]) + i1 = i1 + 1 + i2 = i2 + 1 + elif ix1 < ix2: + num += fabs(x1_data[i1]) + denom += fabs(x1_data[i1]) + i1 = i1 + 1 + else: + num += fabs(x2_data[i2]) + denom += fabs(x2_data[i2]) + i2 = i2 + 1 + + if i1 == x1_end: + while i2 < x2_end: + num += fabs(x1_data[i1]) + denom += fabs(x1_data[i1]) + i2 = i2 + 1 + else: + while i1 < x1_end: + num += fabs(x2_data[i2]) + denom += fabs(x2_data[i2]) + i1 = i1 + 1 + + return num / denom + +#------------------------------------------------------------ +# Jaccard Distance (boolean) +# D(x, y) = N_unequal(x, y) / N_nonzero(x, y) +cdef class JaccardDistance{{name_suffix}}(DistanceMetric{{name_suffix}}): + r"""Jaccard Distance + + Jaccard Distance is a dissimilarity measure for boolean-valued + vectors. All nonzero entries will be treated as True, zero entries will + be treated as False. + + D(x, y) = (N_TF + N_FT) / (N_TT + N_TF + N_FT) + """ + cdef inline {{INPUT_DTYPE_t}} dist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + cdef int tf1, tf2, n_eq = 0, nnz = 0 + cdef intp_t j + for j in range(size): + tf1 = x1[j] != 0 + tf2 = x2[j] != 0 + nnz += (tf1 or tf2) + n_eq += (tf1 and tf2) + # Based on https://github.com/scipy/scipy/pull/7373 + # When comparing two all-zero vectors, scipy>=1.2.0 jaccard metric + # was changed to return 0, instead of nan. + if nnz == 0: + return 0 + return (nnz - n_eq) * 1.0 / nnz + + cdef inline {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + + cdef: + intp_t ix1, ix2 + intp_t i1 = x1_start + intp_t i2 = x2_start + + intp_t tf1, tf2, n_tt = 0, nnz = 0 + + while i1 < x1_end and i2 < x2_end: + ix1 = x1_indices[i1] + ix2 = x2_indices[i2] + + tf1 = x1_data[i1] != 0 + tf2 = x2_data[i2] != 0 + + if ix1 == ix2: + nnz += (tf1 or tf2) + n_tt += (tf1 and tf2) + i1 = i1 + 1 + i2 = i2 + 1 + elif ix1 < ix2: + nnz += tf1 + i1 = i1 + 1 + else: + nnz += tf2 + i2 = i2 + 1 + + if i1 == x1_end: + while i2 < x2_end: + tf2 = x2_data[i2] != 0 + nnz += tf2 + i2 = i2 + 1 + else: + while i1 < x1_end: + tf1 = x1_data[i1] != 0 + nnz += tf1 + i1 = i1 + 1 + + # Based on https://github.com/scipy/scipy/pull/7373 + # When comparing two all-zero vectors, scipy>=1.2.0 jaccard metric + # was changed to return 0, instead of nan. + if nnz == 0: + return 0 + return (nnz - n_tt) * 1.0 / nnz + +#------------------------------------------------------------ +# Matching Distance (boolean) +# D(x, y) = n_neq / n +cdef class MatchingDistance{{name_suffix}}(DistanceMetric{{name_suffix}}): + r"""Matching Distance + + Matching Distance is a dissimilarity measure for boolean-valued + vectors. All nonzero entries will be treated as True, zero entries will + be treated as False. + + D(x, y) = (N_TF + N_FT) / N + """ + cdef inline {{INPUT_DTYPE_t}} dist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + cdef int tf1, tf2, n_neq = 0 + cdef intp_t j + for j in range(size): + tf1 = x1[j] != 0 + tf2 = x2[j] != 0 + n_neq += (tf1 != tf2) + return n_neq * 1. / size + + cdef inline {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + + cdef: + intp_t ix1, ix2 + intp_t i1 = x1_start + intp_t i2 = x2_start + + intp_t tf1, tf2, n_neq = 0 + + while i1 < x1_end and i2 < x2_end: + ix1 = x1_indices[i1] + ix2 = x2_indices[i2] + + if ix1 == ix2: + tf1 = x1_data[i1] != 0 + tf2 = x2_data[i2] != 0 + n_neq += (tf1 != tf2) + i1 = i1 + 1 + i2 = i2 + 1 + elif ix1 < ix2: + n_neq += (x1_data[i1] != 0) + i1 = i1 + 1 + else: + n_neq += (x2_data[i2] != 0) + i2 = i2 + 1 + + if i1 == x1_end: + while i2 < x2_end: + n_neq += (x2_data[i2] != 0) + i2 = i2 + 1 + else: + while i1 < x1_end: + n_neq += (x1_data[i1] != 0) + i1 = i1 + 1 + + return n_neq * 1.0 / size + +#------------------------------------------------------------ +# Dice Distance (boolean) +# D(x, y) = n_neq / (2 * ntt + n_neq) +cdef class DiceDistance{{name_suffix}}(DistanceMetric{{name_suffix}}): + r"""Dice Distance + + Dice Distance is a dissimilarity measure for boolean-valued + vectors. All nonzero entries will be treated as True, zero entries will + be treated as False. + + D(x, y) = (N_TF + N_FT) / (2 * N_TT + N_TF + N_FT) + + """ + cdef inline {{INPUT_DTYPE_t}} dist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + cdef int tf1, tf2, n_neq = 0, n_tt = 0 + cdef intp_t j + for j in range(size): + tf1 = x1[j] != 0 + tf2 = x2[j] != 0 + n_tt += (tf1 and tf2) + n_neq += (tf1 != tf2) + return n_neq / (2.0 * n_tt + n_neq) + + cdef inline {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + + cdef: + intp_t ix1, ix2 + intp_t i1 = x1_start + intp_t i2 = x2_start + + intp_t tf1, tf2, n_tt = 0, n_neq = 0 + + while i1 < x1_end and i2 < x2_end: + ix1 = x1_indices[i1] + ix2 = x2_indices[i2] + + tf1 = x1_data[i1] != 0 + tf2 = x2_data[i2] != 0 + + if ix1 == ix2: + n_tt += (tf1 and tf2) + n_neq += (tf1 != tf2) + i1 = i1 + 1 + i2 = i2 + 1 + elif ix1 < ix2: + n_neq += tf1 + i1 = i1 + 1 + else: + n_neq += tf2 + i2 = i2 + 1 + + if i1 == x1_end: + while i2 < x2_end: + tf2 = x2_data[i2] != 0 + n_neq += tf2 + i2 = i2 + 1 + else: + while i1 < x1_end: + tf1 = x1_data[i1] != 0 + n_neq += tf1 + i1 = i1 + 1 + + return n_neq / (2.0 * n_tt + n_neq) + + +#------------------------------------------------------------ +# Kulsinski Distance (boolean) +# D(x, y) = (ntf + nft - ntt + n) / (n_neq + n) +cdef class KulsinskiDistance{{name_suffix}}(DistanceMetric{{name_suffix}}): + r"""Kulsinski Distance + + Kulsinski Distance is a dissimilarity measure for boolean-valued + vectors. All nonzero entries will be treated as True, zero entries will + be treated as False. + + D(x, y) = 1 - N_TT / (N + N_TF + N_FT) + + """ + cdef inline {{INPUT_DTYPE_t}} dist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + cdef int tf1, tf2, n_tt = 0, n_neq = 0 + cdef intp_t j + for j in range(size): + tf1 = x1[j] != 0 + tf2 = x2[j] != 0 + n_neq += (tf1 != tf2) + n_tt += (tf1 and tf2) + return (n_neq - n_tt + size) * 1.0 / (n_neq + size) + + cdef inline {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + + cdef: + intp_t ix1, ix2 + intp_t i1 = x1_start + intp_t i2 = x2_start + + intp_t tf1, tf2, n_tt = 0, n_neq = 0 + + while i1 < x1_end and i2 < x2_end: + ix1 = x1_indices[i1] + ix2 = x2_indices[i2] + + tf1 = x1_data[i1] != 0 + tf2 = x2_data[i2] != 0 + + if ix1 == ix2: + n_tt += (tf1 and tf2) + n_neq += (tf1 != tf2) + i1 = i1 + 1 + i2 = i2 + 1 + elif ix1 < ix2: + n_neq += tf1 + i1 = i1 + 1 + else: + n_neq += tf2 + i2 = i2 + 1 + + if i1 == x1_end: + while i2 < x2_end: + tf2 = x2_data[i2] != 0 + n_neq += tf2 + i2 = i2 + 1 + else: + while i1 < x1_end: + tf1 = x1_data[i1] != 0 + n_neq += tf1 + i1 = i1 + 1 + + return (n_neq - n_tt + size) * 1.0 / (n_neq + size) + +#------------------------------------------------------------ +# Rogers-Tanimoto Distance (boolean) +# D(x, y) = 2 * n_neq / (n + n_neq) +cdef class RogersTanimotoDistance{{name_suffix}}(DistanceMetric{{name_suffix}}): + r"""Rogers-Tanimoto Distance + + Rogers-Tanimoto Distance is a dissimilarity measure for boolean-valued + vectors. All nonzero entries will be treated as True, zero entries will + be treated as False. + + D(x, y) = 2 (N_TF + N_FT) / (N + N_TF + N_FT) + """ + cdef inline {{INPUT_DTYPE_t}} dist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + cdef int tf1, tf2, n_neq = 0 + cdef intp_t j + for j in range(size): + tf1 = x1[j] != 0 + tf2 = x2[j] != 0 + n_neq += (tf1 != tf2) + return (2.0 * n_neq) / (size + n_neq) + + cdef inline {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + + cdef: + intp_t ix1, ix2 + intp_t i1 = x1_start + intp_t i2 = x2_start + + intp_t tf1, tf2, n_neq = 0 + + while i1 < x1_end and i2 < x2_end: + ix1 = x1_indices[i1] + ix2 = x2_indices[i2] + + tf1 = x1_data[i1] != 0 + tf2 = x2_data[i2] != 0 + + if ix1 == ix2: + n_neq += (tf1 != tf2) + i1 = i1 + 1 + i2 = i2 + 1 + elif ix1 < ix2: + n_neq += tf1 + i1 = i1 + 1 + else: + n_neq += tf2 + i2 = i2 + 1 + + if i1 == x1_end: + while i2 < x2_end: + tf2 = x2_data[i2] != 0 + n_neq += tf2 + i2 = i2 + 1 + else: + while i1 < x1_end: + tf1 = x1_data[i1] != 0 + n_neq += tf1 + i1 = i1 + 1 + + return (2.0 * n_neq) / (size + n_neq) + +#------------------------------------------------------------ +# Russell-Rao Distance (boolean) +# D(x, y) = (n - ntt) / n +cdef class RussellRaoDistance{{name_suffix}}(DistanceMetric{{name_suffix}}): + r"""Russell-Rao Distance + + Russell-Rao Distance is a dissimilarity measure for boolean-valued + vectors. All nonzero entries will be treated as True, zero entries will + be treated as False. + + D(x, y) = (N - N_TT) / N + """ + cdef inline {{INPUT_DTYPE_t}} dist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + cdef int tf1, tf2, n_tt = 0 + cdef intp_t j + for j in range(size): + tf1 = x1[j] != 0 + tf2 = x2[j] != 0 + n_tt += (tf1 and tf2) + return (size - n_tt) * 1. / size + + cdef inline {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + + cdef: + intp_t ix1, ix2 + intp_t i1 = x1_start + intp_t i2 = x2_start + + intp_t tf1, tf2, n_tt = 0 + + while i1 < x1_end and i2 < x2_end: + ix1 = x1_indices[i1] + ix2 = x2_indices[i2] + + tf1 = x1_data[i1] != 0 + tf2 = x2_data[i2] != 0 + + if ix1 == ix2: + n_tt += (tf1 and tf2) + i1 = i1 + 1 + i2 = i2 + 1 + elif ix1 < ix2: + i1 = i1 + 1 + else: + i2 = i2 + 1 + + # We don't need to go through all the longest + # vector because tf1 or tf2 will be false + # and thus n_tt won't be increased. + + return (size - n_tt) * 1. / size + + + +#------------------------------------------------------------ +# Sokal-Michener Distance (boolean) +# D(x, y) = 2 * n_neq / (n + n_neq) +cdef class SokalMichenerDistance{{name_suffix}}(DistanceMetric{{name_suffix}}): + r"""Sokal-Michener Distance + + Sokal-Michener Distance is a dissimilarity measure for boolean-valued + vectors. All nonzero entries will be treated as True, zero entries will + be treated as False. + + D(x, y) = 2 (N_TF + N_FT) / (N + N_TF + N_FT) + """ + cdef inline {{INPUT_DTYPE_t}} dist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + cdef int tf1, tf2, n_neq = 0 + cdef intp_t j + for j in range(size): + tf1 = x1[j] != 0 + tf2 = x2[j] != 0 + n_neq += (tf1 != tf2) + return (2.0 * n_neq) / (size + n_neq) + + cdef inline {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + + cdef: + intp_t ix1, ix2 + intp_t i1 = x1_start + intp_t i2 = x2_start + + intp_t tf1, tf2, n_neq = 0 + + while i1 < x1_end and i2 < x2_end: + ix1 = x1_indices[i1] + ix2 = x2_indices[i2] + + tf1 = x1_data[i1] != 0 + tf2 = x2_data[i2] != 0 + + if ix1 == ix2: + n_neq += (tf1 != tf2) + i1 = i1 + 1 + i2 = i2 + 1 + elif ix1 < ix2: + n_neq += tf1 + i1 = i1 + 1 + else: + n_neq += tf2 + i2 = i2 + 1 + + if i1 == x1_end: + while i2 < x2_end: + tf2 = x2_data[i2] != 0 + n_neq += tf2 + i2 = i2 + 1 + else: + while i1 < x1_end: + tf1 = x1_data[i1] != 0 + n_neq += tf1 + i1 = i1 + 1 + + return (2.0 * n_neq) / (size + n_neq) + +#------------------------------------------------------------ +# Sokal-Sneath Distance (boolean) +# D(x, y) = n_neq / (0.5 * n_tt + n_neq) +cdef class SokalSneathDistance{{name_suffix}}(DistanceMetric{{name_suffix}}): + r"""Sokal-Sneath Distance + + Sokal-Sneath Distance is a dissimilarity measure for boolean-valued + vectors. All nonzero entries will be treated as True, zero entries will + be treated as False. + + D(x, y) = (N_TF + N_FT) / (N_TT / 2 + N_FT + N_TF) + """ + cdef inline {{INPUT_DTYPE_t}} dist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + cdef int tf1, tf2, n_tt = 0, n_neq = 0 + cdef intp_t j + for j in range(size): + tf1 = x1[j] != 0 + tf2 = x2[j] != 0 + n_neq += (tf1 != tf2) + n_tt += (tf1 and tf2) + return n_neq / (0.5 * n_tt + n_neq) + + cdef inline {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + + cdef: + intp_t ix1, ix2 + intp_t i1 = x1_start + intp_t i2 = x2_start + + intp_t tf1, tf2, n_tt = 0, n_neq = 0 + + while i1 < x1_end and i2 < x2_end: + ix1 = x1_indices[i1] + ix2 = x2_indices[i2] + + tf1 = x1_data[i1] != 0 + tf2 = x2_data[i2] != 0 + + if ix1 == ix2: + n_tt += (tf1 and tf2) + n_neq += (tf1 != tf2) + i1 = i1 + 1 + i2 = i2 + 1 + elif ix1 < ix2: + n_neq += tf1 + i1 = i1 + 1 + else: + n_neq += tf2 + i2 = i2 + 1 + + if i1 == x1_end: + while i2 < x2_end: + tf2 = x2_data[i2] != 0 + n_neq += tf2 + i2 = i2 + 1 + else: + while i1 < x1_end: + tf1 = x1_data[i1] != 0 + n_neq += tf1 + i1 = i1 + 1 + + return n_neq / (0.5 * n_tt + n_neq) + + +#------------------------------------------------------------ +# Haversine Distance (2 dimensional) +# D(x, y) = 2 arcsin{sqrt[sin^2 ((x1 - y1) / 2) +# + cos(x1) cos(y1) sin^2 ((x2 - y2) / 2)]} +cdef class HaversineDistance{{name_suffix}}(DistanceMetric{{name_suffix}}): + """Haversine (Spherical) Distance + + The Haversine distance is the angular distance between two points on + the surface of a sphere. The first distance of each point is assumed + to be the latitude, the second is the longitude, given in radians. + The dimension of the points must be 2: + + D(x, y) = 2 arcsin[sqrt{sin^2((x1 - y1) / 2) + cos(x1)cos(y1)sin^2((x2 - y2) / 2)}] + + """ + + def _validate_data(self, X): + if X.shape[1] != 2: + raise ValueError("Haversine distance only valid " + "in 2 dimensions") + + cdef inline {{INPUT_DTYPE_t}} rdist(self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + cdef float64_t sin_0 = sin(0.5 * ((x1[0]) - (x2[0]))) + cdef float64_t sin_1 = sin(0.5 * ((x1[1]) - (x2[1]))) + return (sin_0 * sin_0 + cos(x1[0]) * cos(x2[0]) * sin_1 * sin_1) + + cdef inline {{INPUT_DTYPE_t}} dist(self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + return 2 * asin(sqrt(self.rdist(x1, x2, size))) + + cdef inline {{INPUT_DTYPE_t}} _rdist_to_dist(self, {{INPUT_DTYPE_t}} rdist) except -1 nogil: + return 2 * asin(sqrt(rdist)) + + cdef inline {{INPUT_DTYPE_t}} _dist_to_rdist(self, {{INPUT_DTYPE_t}} dist) except -1 nogil: + cdef float64_t tmp = sin(0.5 * dist) + return tmp * tmp + + def rdist_to_dist(self, rdist): + return 2 * np.arcsin(np.sqrt(rdist)) + + def dist_to_rdist(self, dist): + tmp = np.sin(0.5 * dist) + return tmp * tmp + + cdef inline {{INPUT_DTYPE_t}} dist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + return 2 * asin(sqrt(self.rdist_csr( + x1_data, + x1_indices, + x2_data, + x2_indices, + x1_start, + x1_end, + x2_start, + x2_end, + size, + ))) + + cdef inline {{INPUT_DTYPE_t}} rdist_csr( + self, + const {{INPUT_DTYPE_t}}* x1_data, + const int32_t* x1_indices, + const {{INPUT_DTYPE_t}}* x2_data, + const int32_t* x2_indices, + const int32_t x1_start, + const int32_t x1_end, + const int32_t x2_start, + const int32_t x2_end, + const intp_t size, + ) except -1 nogil: + + cdef: + intp_t ix1, ix2 + intp_t i1 = x1_start + intp_t i2 = x2_start + + float64_t x1_0 = 0 + float64_t x1_1 = 0 + float64_t x2_0 = 0 + float64_t x2_1 = 0 + float64_t sin_0 + float64_t sin_1 + + while i1 < x1_end and i2 < x2_end: + ix1 = x1_indices[i1] + ix2 = x2_indices[i2] + + # Find the components in the 2D vectors to work with + x1_component = ix1 if (x1_start == 0) else ix1 % x1_start + x2_component = ix2 if (x2_start == 0) else ix2 % x2_start + + if x1_component == 0: + x1_0 = x1_data[i1] + else: + x1_1 = x1_data[i1] + + if x2_component == 0: + x2_0 = x2_data[i2] + else: + x2_1 = x2_data[i2] + + i1 = i1 + 1 + i2 = i2 + 1 + + if i1 == x1_end: + while i2 < x2_end: + ix2 = x2_indices[i2] + x2_component = ix2 if (x2_start == 0) else ix2 % x2_start + if x2_component == 0: + x2_0 = x2_data[i2] + else: + x2_1 = x2_data[i2] + i2 = i2 + 1 + else: + while i1 < x1_end: + ix1 = x1_indices[i1] + x1_component = ix1 if (x1_start == 0) else ix1 % x1_start + if x1_component == 0: + x1_0 = x1_data[i1] + else: + x1_1 = x1_data[i1] + i1 = i1 + 1 + + sin_0 = sin(0.5 * (x1_0 - x2_0)) + sin_1 = sin(0.5 * (x1_1 - x2_1)) + + return (sin_0 * sin_0 + cos(x1_0) * cos(x2_0) * sin_1 * sin_1) + +#------------------------------------------------------------ +# User-defined distance +# +cdef class PyFuncDistance{{name_suffix}}(DistanceMetric{{name_suffix}}): + """PyFunc Distance + + A user-defined distance + + Parameters + ---------- + func : function + func should take two numpy arrays as input, and return a distance. + """ + def __init__(self, func, **kwargs): + self.func = func + self.kwargs = kwargs + + # in cython < 0.26, GIL was required to be acquired during definition of + # the function and inside the body of the function. This behaviour is not + # allowed in cython >= 0.26 since it is a redundant GIL acquisition. The + # only way to be back compatible is to inherit `dist` from the base class + # without GIL and called an inline `_dist` which acquire GIL. + cdef inline {{INPUT_DTYPE_t}} dist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 nogil: + return self._dist(x1, x2, size) + + cdef inline {{INPUT_DTYPE_t}} _dist( + self, + const {{INPUT_DTYPE_t}}* x1, + const {{INPUT_DTYPE_t}}* x2, + intp_t size, + ) except -1 with gil: + cdef: + object x1arr = _buffer_to_ndarray{{name_suffix}}(x1, size) + object x2arr = _buffer_to_ndarray{{name_suffix}}(x2, size) + d = self.func(x1arr, x2arr, **self.kwargs) + try: + # Cython generates code here that results in a TypeError + # if d is the wrong type. + return d + except TypeError: + raise TypeError("Custom distance function must accept two " + "vectors and return a float.") + +{{endfor}} diff --git a/shared/package-files/2f/2fdacd34f701fba781e5f3e5b44a4e12b96674c6e1dbe2b768029194be67b58e/blob b/shared/package-files/2f/2fdacd34f701fba781e5f3e5b44a4e12b96674c6e1dbe2b768029194be67b58e/blob new file mode 100644 index 0000000000000000000000000000000000000000..5c62be4ea2ba60569942e7a2fda138ef680f4063 --- /dev/null +++ b/shared/package-files/2f/2fdacd34f701fba781e5f3e5b44a4e12b96674c6e1dbe2b768029194be67b58e/blob @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor median(const at::Tensor & self); +TORCH_API ::std::tuple median_out(at::Tensor & values, at::Tensor & indices, const at::Tensor & self, int64_t dim, bool keepdim=false); +TORCH_API ::std::tuple median_outf(const at::Tensor & self, int64_t dim, bool keepdim, at::Tensor & values, at::Tensor & indices); + +} // namespace cpu +} // namespace at diff --git a/shared/package-files/2f/2fe21da6fe786793002e6a2eeab10d64ebbb17f8c0143e423e8d616f96a6176b/blob b/shared/package-files/2f/2fe21da6fe786793002e6a2eeab10d64ebbb17f8c0143e423e8d616f96a6176b/blob new file mode 100644 index 0000000000000000000000000000000000000000..b4b5ba7d14f7d72ad6636609ba44129c3406962f --- /dev/null +++ b/shared/package-files/2f/2fe21da6fe786793002e6a2eeab10d64ebbb17f8c0143e423e8d616f96a6176b/blob @@ -0,0 +1 @@ +def where() -> str: ... diff --git a/shared/package-files/2f/2fe44d0fa57cb38838d14cbae4121d406d6812d1e03960658811f86d455d5507/blob b/shared/package-files/2f/2fe44d0fa57cb38838d14cbae4121d406d6812d1e03960658811f86d455d5507/blob new file mode 100644 index 0000000000000000000000000000000000000000..0c1bd83f7ca9ea8adde76940e2f7fdd86d89ea5c --- /dev/null +++ b/shared/package-files/2f/2fe44d0fa57cb38838d14cbae4121d406d6812d1e03960658811f86d455d5507/blob @@ -0,0 +1,107 @@ +import numpy as np +import pytest + +from sklearn.impute._base import _BaseImputer +from sklearn.impute._iterative import _assign_where +from sklearn.utils._mask import _get_mask +from sklearn.utils._testing import _convert_container, assert_allclose + + +@pytest.fixture +def data(): + X = np.random.randn(10, 2) + X[::2] = np.nan + return X + + +class NoFitIndicatorImputer(_BaseImputer): + def fit(self, X, y=None): + return self + + def transform(self, X, y=None): + return self._concatenate_indicator(X, self._transform_indicator(X)) + + +class NoTransformIndicatorImputer(_BaseImputer): + def fit(self, X, y=None): + mask = _get_mask(X, value_to_mask=np.nan) + super()._fit_indicator(mask) + return self + + def transform(self, X, y=None): + return self._concatenate_indicator(X, None) + + +class NoPrecomputedMaskFit(_BaseImputer): + def fit(self, X, y=None): + self._fit_indicator(X) + return self + + def transform(self, X): + return self._concatenate_indicator(X, self._transform_indicator(X)) + + +class NoPrecomputedMaskTransform(_BaseImputer): + def fit(self, X, y=None): + mask = _get_mask(X, value_to_mask=np.nan) + self._fit_indicator(mask) + return self + + def transform(self, X): + return self._concatenate_indicator(X, self._transform_indicator(X)) + + +def test_base_imputer_not_fit(data): + imputer = NoFitIndicatorImputer(add_indicator=True) + err_msg = "Make sure to call _fit_indicator before _transform_indicator" + with pytest.raises(ValueError, match=err_msg): + imputer.fit(data).transform(data) + with pytest.raises(ValueError, match=err_msg): + imputer.fit_transform(data) + + +def test_base_imputer_not_transform(data): + imputer = NoTransformIndicatorImputer(add_indicator=True) + err_msg = ( + "Call _fit_indicator and _transform_indicator in the imputer implementation" + ) + with pytest.raises(ValueError, match=err_msg): + imputer.fit(data).transform(data) + with pytest.raises(ValueError, match=err_msg): + imputer.fit_transform(data) + + +def test_base_no_precomputed_mask_fit(data): + imputer = NoPrecomputedMaskFit(add_indicator=True) + err_msg = "precomputed is True but the input data is not a mask" + with pytest.raises(ValueError, match=err_msg): + imputer.fit(data) + with pytest.raises(ValueError, match=err_msg): + imputer.fit_transform(data) + + +def test_base_no_precomputed_mask_transform(data): + imputer = NoPrecomputedMaskTransform(add_indicator=True) + err_msg = "precomputed is True but the input data is not a mask" + imputer.fit(data) + with pytest.raises(ValueError, match=err_msg): + imputer.transform(data) + with pytest.raises(ValueError, match=err_msg): + imputer.fit_transform(data) + + +@pytest.mark.parametrize("X1_type", ["array", "dataframe"]) +def test_assign_where(X1_type): + """Check the behaviour of the private helpers `_assign_where`.""" + rng = np.random.RandomState(0) + + n_samples, n_features = 10, 5 + X1 = _convert_container(rng.randn(n_samples, n_features), constructor_name=X1_type) + X2 = rng.randn(n_samples, n_features) + mask = rng.randint(0, 2, size=(n_samples, n_features)).astype(bool) + + _assign_where(X1, X2, mask) + + if X1_type == "dataframe": + X1 = X1.to_numpy() + assert_allclose(X1[mask], X2[mask]) diff --git a/shared/package-files/2f/2fe57349b65d21a25883adeecb25e83e6ceda09440fb74b03b407737e2a00d8e/blob b/shared/package-files/2f/2fe57349b65d21a25883adeecb25e83e6ceda09440fb74b03b407737e2a00d8e/blob new file mode 100644 index 0000000000000000000000000000000000000000..ea7dcd2ffd363a03ef72d3ff758d052650527354 --- /dev/null +++ b/shared/package-files/2f/2fe57349b65d21a25883adeecb25e83e6ceda09440fb74b03b407737e2a00d8e/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API slice_copy_Tensor { + using schema = at::Tensor (const at::Tensor &, int64_t, c10::optional, c10::optional, c10::SymInt); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::slice_copy") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "slice_copy.Tensor(Tensor self, int dim=0, SymInt? start=None, SymInt? end=None, SymInt step=1) -> Tensor") + static at::Tensor call(const at::Tensor & self, int64_t dim, c10::optional start, c10::optional end, c10::SymInt step); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, int64_t dim, c10::optional start, c10::optional end, c10::SymInt step); +}; + +struct TORCH_API slice_copy_Tensor_out { + using schema = at::Tensor & (const at::Tensor &, int64_t, c10::optional, c10::optional, c10::SymInt, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::slice_copy") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor_out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "slice_copy.Tensor_out(Tensor self, int dim=0, SymInt? start=None, SymInt? end=None, SymInt step=1, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, int64_t dim, c10::optional start, c10::optional end, c10::SymInt step, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, int64_t dim, c10::optional start, c10::optional end, c10::SymInt step, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/2f/2fe68e015872c6a9e761b434ff31cdb4ba76aaa6e7a8585c85c8db48a9fbd2df/blob b/shared/package-files/2f/2fe68e015872c6a9e761b434ff31cdb4ba76aaa6e7a8585c85c8db48a9fbd2df/blob new file mode 100644 index 0000000000000000000000000000000000000000..58c6abc05abf3ff50420438e9859ae4969a06253 Binary files /dev/null and b/shared/package-files/2f/2fe68e015872c6a9e761b434ff31cdb4ba76aaa6e7a8585c85c8db48a9fbd2df/blob differ diff --git a/shared/package-files/2f/2fe72632015db2cba2bb4367055551da6fe22051b96d170c7b96fa271c46b257/blob b/shared/package-files/2f/2fe72632015db2cba2bb4367055551da6fe22051b96d170c7b96fa271c46b257/blob new file mode 100644 index 0000000000000000000000000000000000000000..c25a5a43bc49e1ce821793979b87d39fbbd05d18 --- /dev/null +++ b/shared/package-files/2f/2fe72632015db2cba2bb4367055551da6fe22051b96d170c7b96fa271c46b257/blob @@ -0,0 +1,307 @@ +""" Python Character Mapping Codec cp875 generated from 'MAPPINGS/VENDORS/MICSFT/EBCDIC/CP875.TXT' with gencodec.py. + +"""#" + +import codecs + +### Codec APIs + +class Codec(codecs.Codec): + + def encode(self,input,errors='strict'): + return codecs.charmap_encode(input,errors,encoding_table) + + def decode(self,input,errors='strict'): + return codecs.charmap_decode(input,errors,decoding_table) + +class IncrementalEncoder(codecs.IncrementalEncoder): + def encode(self, input, final=False): + return codecs.charmap_encode(input,self.errors,encoding_table)[0] + +class IncrementalDecoder(codecs.IncrementalDecoder): + def decode(self, input, final=False): + return codecs.charmap_decode(input,self.errors,decoding_table)[0] + +class StreamWriter(Codec,codecs.StreamWriter): + pass + +class StreamReader(Codec,codecs.StreamReader): + pass + +### encodings module API + +def getregentry(): + return codecs.CodecInfo( + name='cp875', + encode=Codec().encode, + decode=Codec().decode, + incrementalencoder=IncrementalEncoder, + incrementaldecoder=IncrementalDecoder, + streamreader=StreamReader, + streamwriter=StreamWriter, + ) + + +### Decoding Table + +decoding_table = ( + '\x00' # 0x00 -> NULL + '\x01' # 0x01 -> START OF HEADING + '\x02' # 0x02 -> START OF TEXT + '\x03' # 0x03 -> END OF TEXT + '\x9c' # 0x04 -> CONTROL + '\t' # 0x05 -> HORIZONTAL TABULATION + '\x86' # 0x06 -> CONTROL + '\x7f' # 0x07 -> DELETE + '\x97' # 0x08 -> CONTROL + '\x8d' # 0x09 -> CONTROL + '\x8e' # 0x0A -> CONTROL + '\x0b' # 0x0B -> VERTICAL TABULATION + '\x0c' # 0x0C -> FORM FEED + '\r' # 0x0D -> CARRIAGE RETURN + '\x0e' # 0x0E -> SHIFT OUT + '\x0f' # 0x0F -> SHIFT IN + '\x10' # 0x10 -> DATA LINK ESCAPE + '\x11' # 0x11 -> DEVICE CONTROL ONE + '\x12' # 0x12 -> DEVICE CONTROL TWO + '\x13' # 0x13 -> DEVICE CONTROL THREE + '\x9d' # 0x14 -> CONTROL + '\x85' # 0x15 -> CONTROL + '\x08' # 0x16 -> BACKSPACE + '\x87' # 0x17 -> CONTROL + '\x18' # 0x18 -> CANCEL + '\x19' # 0x19 -> END OF MEDIUM + '\x92' # 0x1A -> CONTROL + '\x8f' # 0x1B -> CONTROL + '\x1c' # 0x1C -> FILE SEPARATOR + '\x1d' # 0x1D -> GROUP SEPARATOR + '\x1e' # 0x1E -> RECORD SEPARATOR + '\x1f' # 0x1F -> UNIT SEPARATOR + '\x80' # 0x20 -> CONTROL + '\x81' # 0x21 -> CONTROL + '\x82' # 0x22 -> CONTROL + '\x83' # 0x23 -> CONTROL + '\x84' # 0x24 -> CONTROL + '\n' # 0x25 -> LINE FEED + '\x17' # 0x26 -> END OF TRANSMISSION BLOCK + '\x1b' # 0x27 -> ESCAPE + '\x88' # 0x28 -> CONTROL + '\x89' # 0x29 -> CONTROL + '\x8a' # 0x2A -> CONTROL + '\x8b' # 0x2B -> CONTROL + '\x8c' # 0x2C -> CONTROL + '\x05' # 0x2D -> ENQUIRY + '\x06' # 0x2E -> ACKNOWLEDGE + '\x07' # 0x2F -> BELL + '\x90' # 0x30 -> CONTROL + '\x91' # 0x31 -> CONTROL + '\x16' # 0x32 -> SYNCHRONOUS IDLE + '\x93' # 0x33 -> CONTROL + '\x94' # 0x34 -> CONTROL + '\x95' # 0x35 -> CONTROL + '\x96' # 0x36 -> CONTROL + '\x04' # 0x37 -> END OF TRANSMISSION + '\x98' # 0x38 -> CONTROL + '\x99' # 0x39 -> CONTROL + '\x9a' # 0x3A -> CONTROL + '\x9b' # 0x3B -> CONTROL + '\x14' # 0x3C -> DEVICE CONTROL FOUR + '\x15' # 0x3D -> NEGATIVE ACKNOWLEDGE + '\x9e' # 0x3E -> CONTROL + '\x1a' # 0x3F -> SUBSTITUTE + ' ' # 0x40 -> SPACE + '\u0391' # 0x41 -> GREEK CAPITAL LETTER ALPHA + '\u0392' # 0x42 -> GREEK CAPITAL LETTER BETA + '\u0393' # 0x43 -> GREEK CAPITAL LETTER GAMMA + '\u0394' # 0x44 -> GREEK CAPITAL LETTER DELTA + '\u0395' # 0x45 -> GREEK CAPITAL LETTER EPSILON + '\u0396' # 0x46 -> GREEK CAPITAL LETTER ZETA + '\u0397' # 0x47 -> GREEK CAPITAL LETTER ETA + '\u0398' # 0x48 -> GREEK CAPITAL LETTER THETA + '\u0399' # 0x49 -> GREEK CAPITAL LETTER IOTA + '[' # 0x4A -> LEFT SQUARE BRACKET + '.' # 0x4B -> FULL STOP + '<' # 0x4C -> LESS-THAN SIGN + '(' # 0x4D -> LEFT PARENTHESIS + '+' # 0x4E -> PLUS SIGN + '!' # 0x4F -> EXCLAMATION MARK + '&' # 0x50 -> AMPERSAND + '\u039a' # 0x51 -> GREEK CAPITAL LETTER KAPPA + '\u039b' # 0x52 -> GREEK CAPITAL LETTER LAMDA + '\u039c' # 0x53 -> GREEK CAPITAL LETTER MU + '\u039d' # 0x54 -> GREEK CAPITAL LETTER NU + '\u039e' # 0x55 -> GREEK CAPITAL LETTER XI + '\u039f' # 0x56 -> GREEK CAPITAL LETTER OMICRON + '\u03a0' # 0x57 -> GREEK CAPITAL LETTER PI + '\u03a1' # 0x58 -> GREEK CAPITAL LETTER RHO + '\u03a3' # 0x59 -> GREEK CAPITAL LETTER SIGMA + ']' # 0x5A -> RIGHT SQUARE BRACKET + '$' # 0x5B -> DOLLAR SIGN + '*' # 0x5C -> ASTERISK + ')' # 0x5D -> RIGHT PARENTHESIS + ';' # 0x5E -> SEMICOLON + '^' # 0x5F -> CIRCUMFLEX ACCENT + '-' # 0x60 -> HYPHEN-MINUS + '/' # 0x61 -> SOLIDUS + '\u03a4' # 0x62 -> GREEK CAPITAL LETTER TAU + '\u03a5' # 0x63 -> GREEK CAPITAL LETTER UPSILON + '\u03a6' # 0x64 -> GREEK CAPITAL LETTER PHI + '\u03a7' # 0x65 -> GREEK CAPITAL LETTER CHI + '\u03a8' # 0x66 -> GREEK CAPITAL LETTER PSI + '\u03a9' # 0x67 -> GREEK CAPITAL LETTER OMEGA + '\u03aa' # 0x68 -> GREEK CAPITAL LETTER IOTA WITH DIALYTIKA + '\u03ab' # 0x69 -> GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA + '|' # 0x6A -> VERTICAL LINE + ',' # 0x6B -> COMMA + '%' # 0x6C -> PERCENT SIGN + '_' # 0x6D -> LOW LINE + '>' # 0x6E -> GREATER-THAN SIGN + '?' # 0x6F -> QUESTION MARK + '\xa8' # 0x70 -> DIAERESIS + '\u0386' # 0x71 -> GREEK CAPITAL LETTER ALPHA WITH TONOS + '\u0388' # 0x72 -> GREEK CAPITAL LETTER EPSILON WITH TONOS + '\u0389' # 0x73 -> GREEK CAPITAL LETTER ETA WITH TONOS + '\xa0' # 0x74 -> NO-BREAK SPACE + '\u038a' # 0x75 -> GREEK CAPITAL LETTER IOTA WITH TONOS + '\u038c' # 0x76 -> GREEK CAPITAL LETTER OMICRON WITH TONOS + '\u038e' # 0x77 -> GREEK CAPITAL LETTER UPSILON WITH TONOS + '\u038f' # 0x78 -> GREEK CAPITAL LETTER OMEGA WITH TONOS + '`' # 0x79 -> GRAVE ACCENT + ':' # 0x7A -> COLON + '#' # 0x7B -> NUMBER SIGN + '@' # 0x7C -> COMMERCIAL AT + "'" # 0x7D -> APOSTROPHE + '=' # 0x7E -> EQUALS SIGN + '"' # 0x7F -> QUOTATION MARK + '\u0385' # 0x80 -> GREEK DIALYTIKA TONOS + 'a' # 0x81 -> LATIN SMALL LETTER A + 'b' # 0x82 -> LATIN SMALL LETTER B + 'c' # 0x83 -> LATIN SMALL LETTER C + 'd' # 0x84 -> LATIN SMALL LETTER D + 'e' # 0x85 -> LATIN SMALL LETTER E + 'f' # 0x86 -> LATIN SMALL LETTER F + 'g' # 0x87 -> LATIN SMALL LETTER G + 'h' # 0x88 -> LATIN SMALL LETTER H + 'i' # 0x89 -> LATIN SMALL LETTER I + '\u03b1' # 0x8A -> GREEK SMALL LETTER ALPHA + '\u03b2' # 0x8B -> GREEK SMALL LETTER BETA + '\u03b3' # 0x8C -> GREEK SMALL LETTER GAMMA + '\u03b4' # 0x8D -> GREEK SMALL LETTER DELTA + '\u03b5' # 0x8E -> GREEK SMALL LETTER EPSILON + '\u03b6' # 0x8F -> GREEK SMALL LETTER ZETA + '\xb0' # 0x90 -> DEGREE SIGN + 'j' # 0x91 -> LATIN SMALL LETTER J + 'k' # 0x92 -> LATIN SMALL LETTER K + 'l' # 0x93 -> LATIN SMALL LETTER L + 'm' # 0x94 -> LATIN SMALL LETTER M + 'n' # 0x95 -> LATIN SMALL LETTER N + 'o' # 0x96 -> LATIN SMALL LETTER O + 'p' # 0x97 -> LATIN SMALL LETTER P + 'q' # 0x98 -> LATIN SMALL LETTER Q + 'r' # 0x99 -> LATIN SMALL LETTER R + '\u03b7' # 0x9A -> GREEK SMALL LETTER ETA + '\u03b8' # 0x9B -> GREEK SMALL LETTER THETA + '\u03b9' # 0x9C -> GREEK SMALL LETTER IOTA + '\u03ba' # 0x9D -> GREEK SMALL LETTER KAPPA + '\u03bb' # 0x9E -> GREEK SMALL LETTER LAMDA + '\u03bc' # 0x9F -> GREEK SMALL LETTER MU + '\xb4' # 0xA0 -> ACUTE ACCENT + '~' # 0xA1 -> TILDE + 's' # 0xA2 -> LATIN SMALL LETTER S + 't' # 0xA3 -> LATIN SMALL LETTER T + 'u' # 0xA4 -> LATIN SMALL LETTER U + 'v' # 0xA5 -> LATIN SMALL LETTER V + 'w' # 0xA6 -> LATIN SMALL LETTER W + 'x' # 0xA7 -> LATIN SMALL LETTER X + 'y' # 0xA8 -> LATIN SMALL LETTER Y + 'z' # 0xA9 -> LATIN SMALL LETTER Z + '\u03bd' # 0xAA -> GREEK SMALL LETTER NU + '\u03be' # 0xAB -> GREEK SMALL LETTER XI + '\u03bf' # 0xAC -> GREEK SMALL LETTER OMICRON + '\u03c0' # 0xAD -> GREEK SMALL LETTER PI + '\u03c1' # 0xAE -> GREEK SMALL LETTER RHO + '\u03c3' # 0xAF -> GREEK SMALL LETTER SIGMA + '\xa3' # 0xB0 -> POUND SIGN + '\u03ac' # 0xB1 -> GREEK SMALL LETTER ALPHA WITH TONOS + '\u03ad' # 0xB2 -> GREEK SMALL LETTER EPSILON WITH TONOS + '\u03ae' # 0xB3 -> GREEK SMALL LETTER ETA WITH TONOS + '\u03ca' # 0xB4 -> GREEK SMALL LETTER IOTA WITH DIALYTIKA + '\u03af' # 0xB5 -> GREEK SMALL LETTER IOTA WITH TONOS + '\u03cc' # 0xB6 -> GREEK SMALL LETTER OMICRON WITH TONOS + '\u03cd' # 0xB7 -> GREEK SMALL LETTER UPSILON WITH TONOS + '\u03cb' # 0xB8 -> GREEK SMALL LETTER UPSILON WITH DIALYTIKA + '\u03ce' # 0xB9 -> GREEK SMALL LETTER OMEGA WITH TONOS + '\u03c2' # 0xBA -> GREEK SMALL LETTER FINAL SIGMA + '\u03c4' # 0xBB -> GREEK SMALL LETTER TAU + '\u03c5' # 0xBC -> GREEK SMALL LETTER UPSILON + '\u03c6' # 0xBD -> GREEK SMALL LETTER PHI + '\u03c7' # 0xBE -> GREEK SMALL LETTER CHI + '\u03c8' # 0xBF -> GREEK SMALL LETTER PSI + '{' # 0xC0 -> LEFT CURLY BRACKET + 'A' # 0xC1 -> LATIN CAPITAL LETTER A + 'B' # 0xC2 -> LATIN CAPITAL LETTER B + 'C' # 0xC3 -> LATIN CAPITAL LETTER C + 'D' # 0xC4 -> LATIN CAPITAL LETTER D + 'E' # 0xC5 -> LATIN CAPITAL LETTER E + 'F' # 0xC6 -> LATIN CAPITAL LETTER F + 'G' # 0xC7 -> LATIN CAPITAL LETTER G + 'H' # 0xC8 -> LATIN CAPITAL LETTER H + 'I' # 0xC9 -> LATIN CAPITAL LETTER I + '\xad' # 0xCA -> SOFT HYPHEN + '\u03c9' # 0xCB -> GREEK SMALL LETTER OMEGA + '\u0390' # 0xCC -> GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS + '\u03b0' # 0xCD -> GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS + '\u2018' # 0xCE -> LEFT SINGLE QUOTATION MARK + '\u2015' # 0xCF -> HORIZONTAL BAR + '}' # 0xD0 -> RIGHT CURLY BRACKET + 'J' # 0xD1 -> LATIN CAPITAL LETTER J + 'K' # 0xD2 -> LATIN CAPITAL LETTER K + 'L' # 0xD3 -> LATIN CAPITAL LETTER L + 'M' # 0xD4 -> LATIN CAPITAL LETTER M + 'N' # 0xD5 -> LATIN CAPITAL LETTER N + 'O' # 0xD6 -> LATIN CAPITAL LETTER O + 'P' # 0xD7 -> LATIN CAPITAL LETTER P + 'Q' # 0xD8 -> LATIN CAPITAL LETTER Q + 'R' # 0xD9 -> LATIN CAPITAL LETTER R + '\xb1' # 0xDA -> PLUS-MINUS SIGN + '\xbd' # 0xDB -> VULGAR FRACTION ONE HALF + '\x1a' # 0xDC -> SUBSTITUTE + '\u0387' # 0xDD -> GREEK ANO TELEIA + '\u2019' # 0xDE -> RIGHT SINGLE QUOTATION MARK + '\xa6' # 0xDF -> BROKEN BAR + '\\' # 0xE0 -> REVERSE SOLIDUS + '\x1a' # 0xE1 -> SUBSTITUTE + 'S' # 0xE2 -> LATIN CAPITAL LETTER S + 'T' # 0xE3 -> LATIN CAPITAL LETTER T + 'U' # 0xE4 -> LATIN CAPITAL LETTER U + 'V' # 0xE5 -> LATIN CAPITAL LETTER V + 'W' # 0xE6 -> LATIN CAPITAL LETTER W + 'X' # 0xE7 -> LATIN CAPITAL LETTER X + 'Y' # 0xE8 -> LATIN CAPITAL LETTER Y + 'Z' # 0xE9 -> LATIN CAPITAL LETTER Z + '\xb2' # 0xEA -> SUPERSCRIPT TWO + '\xa7' # 0xEB -> SECTION SIGN + '\x1a' # 0xEC -> SUBSTITUTE + '\x1a' # 0xED -> SUBSTITUTE + '\xab' # 0xEE -> LEFT-POINTING DOUBLE ANGLE QUOTATION MARK + '\xac' # 0xEF -> NOT SIGN + '0' # 0xF0 -> DIGIT ZERO + '1' # 0xF1 -> DIGIT ONE + '2' # 0xF2 -> DIGIT TWO + '3' # 0xF3 -> DIGIT THREE + '4' # 0xF4 -> DIGIT FOUR + '5' # 0xF5 -> DIGIT FIVE + '6' # 0xF6 -> DIGIT SIX + '7' # 0xF7 -> DIGIT SEVEN + '8' # 0xF8 -> DIGIT EIGHT + '9' # 0xF9 -> DIGIT NINE + '\xb3' # 0xFA -> SUPERSCRIPT THREE + '\xa9' # 0xFB -> COPYRIGHT SIGN + '\x1a' # 0xFC -> SUBSTITUTE + '\x1a' # 0xFD -> SUBSTITUTE + '\xbb' # 0xFE -> RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK + '\x9f' # 0xFF -> CONTROL +) + +### Encoding table +encoding_table=codecs.charmap_build(decoding_table) diff --git a/shared/package-files/2f/2fe8a644de33042b455da8e3c90e3eda978c50bab2b026d5114abaf49a506e00/blob b/shared/package-files/2f/2fe8a644de33042b455da8e3c90e3eda978c50bab2b026d5114abaf49a506e00/blob new file mode 100644 index 0000000000000000000000000000000000000000..33308e2add7670f436dbcb77e3605d6c36b82145 --- /dev/null +++ b/shared/package-files/2f/2fe8a644de33042b455da8e3c90e3eda978c50bab2b026d5114abaf49a506e00/blob @@ -0,0 +1,741 @@ +from sympy.core.backend import zeros, Matrix, diff, eye +from sympy.core.sorting import default_sort_key +from sympy.physics.vector import (ReferenceFrame, dynamicsymbols, + partial_velocity) +from sympy.physics.mechanics.method import _Methods +from sympy.physics.mechanics.particle import Particle +from sympy.physics.mechanics.rigidbody import RigidBody +from sympy.physics.mechanics.functions import ( + msubs, find_dynamicsymbols, _f_list_parser, _validate_coordinates) +from sympy.physics.mechanics.linearize import Linearizer +from sympy.utilities.iterables import iterable + +__all__ = ['KanesMethod'] + + +class KanesMethod(_Methods): + r"""Kane's method object. + + Explanation + =========== + + This object is used to do the "book-keeping" as you go through and form + equations of motion in the way Kane presents in: + Kane, T., Levinson, D. Dynamics Theory and Applications. 1985 McGraw-Hill + + The attributes are for equations in the form [M] udot = forcing. + + Attributes + ========== + + q, u : Matrix + Matrices of the generalized coordinates and speeds + bodies : iterable + Iterable of Point and RigidBody objects in the system. + loads : iterable + Iterable of (Point, vector) or (ReferenceFrame, vector) tuples + describing the forces on the system. + auxiliary_eqs : Matrix + If applicable, the set of auxiliary Kane's + equations used to solve for non-contributing + forces. + mass_matrix : Matrix + The system's dynamics mass matrix: [k_d; k_dnh] + forcing : Matrix + The system's dynamics forcing vector: -[f_d; f_dnh] + mass_matrix_kin : Matrix + The "mass matrix" for kinematic differential equations: k_kqdot + forcing_kin : Matrix + The forcing vector for kinematic differential equations: -(k_ku*u + f_k) + mass_matrix_full : Matrix + The "mass matrix" for the u's and q's with dynamics and kinematics + forcing_full : Matrix + The "forcing vector" for the u's and q's with dynamics and kinematics + explicit_kinematics : bool + Boolean whether the mass matrices and forcing vectors should use the + explicit form (default) or implicit form for kinematics. + See the notes for more details. + + Notes + ===== + + The mass matrices and forcing vectors related to kinematic equations + are given in the explicit form by default. In other words, the kinematic + mass matrix is $\mathbf{k_{k\dot{q}}} = \mathbf{I}$. + In order to get the implicit form of those matrices/vectors, you can set the + ``explicit_kinematics`` attribute to ``False``. So $\mathbf{k_{k\dot{q}}}$ is not + necessarily an identity matrix. This can provide more compact equations for + non-simple kinematics (see #22626). + + Examples + ======== + + This is a simple example for a one degree of freedom translational + spring-mass-damper. + + In this example, we first need to do the kinematics. + This involves creating generalized speeds and coordinates and their + derivatives. + Then we create a point and set its velocity in a frame. + + >>> from sympy import symbols + >>> from sympy.physics.mechanics import dynamicsymbols, ReferenceFrame + >>> from sympy.physics.mechanics import Point, Particle, KanesMethod + >>> q, u = dynamicsymbols('q u') + >>> qd, ud = dynamicsymbols('q u', 1) + >>> m, c, k = symbols('m c k') + >>> N = ReferenceFrame('N') + >>> P = Point('P') + >>> P.set_vel(N, u * N.x) + + Next we need to arrange/store information in the way that KanesMethod + requires. The kinematic differential equations need to be stored in a + dict. A list of forces/torques must be constructed, where each entry in + the list is a (Point, Vector) or (ReferenceFrame, Vector) tuple, where the + Vectors represent the Force or Torque. + Next a particle needs to be created, and it needs to have a point and mass + assigned to it. + Finally, a list of all bodies and particles needs to be created. + + >>> kd = [qd - u] + >>> FL = [(P, (-k * q - c * u) * N.x)] + >>> pa = Particle('pa', P, m) + >>> BL = [pa] + + Finally we can generate the equations of motion. + First we create the KanesMethod object and supply an inertial frame, + coordinates, generalized speeds, and the kinematic differential equations. + Additional quantities such as configuration and motion constraints, + dependent coordinates and speeds, and auxiliary speeds are also supplied + here (see the online documentation). + Next we form FR* and FR to complete: Fr + Fr* = 0. + We have the equations of motion at this point. + It makes sense to rearrange them though, so we calculate the mass matrix and + the forcing terms, for E.o.M. in the form: [MM] udot = forcing, where MM is + the mass matrix, udot is a vector of the time derivatives of the + generalized speeds, and forcing is a vector representing "forcing" terms. + + >>> KM = KanesMethod(N, q_ind=[q], u_ind=[u], kd_eqs=kd) + >>> (fr, frstar) = KM.kanes_equations(BL, FL) + >>> MM = KM.mass_matrix + >>> forcing = KM.forcing + >>> rhs = MM.inv() * forcing + >>> rhs + Matrix([[(-c*u(t) - k*q(t))/m]]) + >>> KM.linearize(A_and_B=True)[0] + Matrix([ + [ 0, 1], + [-k/m, -c/m]]) + + Please look at the documentation pages for more information on how to + perform linearization and how to deal with dependent coordinates & speeds, + and how do deal with bringing non-contributing forces into evidence. + + """ + + def __init__(self, frame, q_ind, u_ind, kd_eqs=None, q_dependent=None, + configuration_constraints=None, u_dependent=None, + velocity_constraints=None, acceleration_constraints=None, + u_auxiliary=None, bodies=None, forcelist=None, explicit_kinematics=True): + + """Please read the online documentation. """ + if not q_ind: + q_ind = [dynamicsymbols('dummy_q')] + kd_eqs = [dynamicsymbols('dummy_kd')] + + if not isinstance(frame, ReferenceFrame): + raise TypeError('An inertial ReferenceFrame must be supplied') + self._inertial = frame + + self._fr = None + self._frstar = None + + self._forcelist = forcelist + self._bodylist = bodies + + self.explicit_kinematics = explicit_kinematics + + self._initialize_vectors(q_ind, q_dependent, u_ind, u_dependent, + u_auxiliary) + _validate_coordinates(self.q, self.u) + self._initialize_kindiffeq_matrices(kd_eqs) + self._initialize_constraint_matrices(configuration_constraints, + velocity_constraints, acceleration_constraints) + + def _initialize_vectors(self, q_ind, q_dep, u_ind, u_dep, u_aux): + """Initialize the coordinate and speed vectors.""" + + none_handler = lambda x: Matrix(x) if x else Matrix() + + # Initialize generalized coordinates + q_dep = none_handler(q_dep) + if not iterable(q_ind): + raise TypeError('Generalized coordinates must be an iterable.') + if not iterable(q_dep): + raise TypeError('Dependent coordinates must be an iterable.') + q_ind = Matrix(q_ind) + self._qdep = q_dep + self._q = Matrix([q_ind, q_dep]) + self._qdot = self.q.diff(dynamicsymbols._t) + + # Initialize generalized speeds + u_dep = none_handler(u_dep) + if not iterable(u_ind): + raise TypeError('Generalized speeds must be an iterable.') + if not iterable(u_dep): + raise TypeError('Dependent speeds must be an iterable.') + u_ind = Matrix(u_ind) + self._udep = u_dep + self._u = Matrix([u_ind, u_dep]) + self._udot = self.u.diff(dynamicsymbols._t) + self._uaux = none_handler(u_aux) + + def _initialize_constraint_matrices(self, config, vel, acc): + """Initializes constraint matrices.""" + + # Define vector dimensions + o = len(self.u) + m = len(self._udep) + p = o - m + none_handler = lambda x: Matrix(x) if x else Matrix() + + # Initialize configuration constraints + config = none_handler(config) + if len(self._qdep) != len(config): + raise ValueError('There must be an equal number of dependent ' + 'coordinates and configuration constraints.') + self._f_h = none_handler(config) + + # Initialize velocity and acceleration constraints + vel = none_handler(vel) + acc = none_handler(acc) + if len(vel) != m: + raise ValueError('There must be an equal number of dependent ' + 'speeds and velocity constraints.') + if acc and (len(acc) != m): + raise ValueError('There must be an equal number of dependent ' + 'speeds and acceleration constraints.') + if vel: + u_zero = {i: 0 for i in self.u} + udot_zero = {i: 0 for i in self._udot} + + # When calling kanes_equations, another class instance will be + # created if auxiliary u's are present. In this case, the + # computation of kinetic differential equation matrices will be + # skipped as this was computed during the original KanesMethod + # object, and the qd_u_map will not be available. + if self._qdot_u_map is not None: + vel = msubs(vel, self._qdot_u_map) + + self._f_nh = msubs(vel, u_zero) + self._k_nh = (vel - self._f_nh).jacobian(self.u) + # If no acceleration constraints given, calculate them. + if not acc: + _f_dnh = (self._k_nh.diff(dynamicsymbols._t) * self.u + + self._f_nh.diff(dynamicsymbols._t)) + if self._qdot_u_map is not None: + _f_dnh = msubs(_f_dnh, self._qdot_u_map) + self._f_dnh = _f_dnh + self._k_dnh = self._k_nh + else: + if self._qdot_u_map is not None: + acc = msubs(acc, self._qdot_u_map) + self._f_dnh = msubs(acc, udot_zero) + self._k_dnh = (acc - self._f_dnh).jacobian(self._udot) + + # Form of non-holonomic constraints is B*u + C = 0. + # We partition B into independent and dependent columns: + # Ars is then -B_dep.inv() * B_ind, and it relates dependent speeds + # to independent speeds as: udep = Ars*uind, neglecting the C term. + B_ind = self._k_nh[:, :p] + B_dep = self._k_nh[:, p:o] + self._Ars = -B_dep.LUsolve(B_ind) + else: + self._f_nh = Matrix() + self._k_nh = Matrix() + self._f_dnh = Matrix() + self._k_dnh = Matrix() + self._Ars = Matrix() + + def _initialize_kindiffeq_matrices(self, kdeqs): + """Initialize the kinematic differential equation matrices. + + Parameters + ========== + kdeqs : sequence of sympy expressions + Kinematic differential equations in the form of f(u,q',q,t) where + f() = 0. The equations have to be linear in the generalized + coordinates and generalized speeds. + + """ + + if kdeqs: + if len(self.q) != len(kdeqs): + raise ValueError('There must be an equal number of kinematic ' + 'differential equations and coordinates.') + + u = self.u + qdot = self._qdot + + kdeqs = Matrix(kdeqs) + + u_zero = {ui: 0 for ui in u} + uaux_zero = {uai: 0 for uai in self._uaux} + qdot_zero = {qdi: 0 for qdi in qdot} + + # Extract the linear coefficient matrices as per the following + # equation: + # + # k_ku(q,t)*u(t) + k_kqdot(q,t)*q'(t) + f_k(q,t) = 0 + # + k_ku = kdeqs.jacobian(u) + k_kqdot = kdeqs.jacobian(qdot) + f_k = kdeqs.xreplace(u_zero).xreplace(qdot_zero) + + # The kinematic differential equations should be linear in both q' + # and u, so check for u and q' in the components. + dy_syms = find_dynamicsymbols(k_ku.row_join(k_kqdot).row_join(f_k)) + nonlin_vars = [vari for vari in u[:] + qdot[:] if vari in dy_syms] + if nonlin_vars: + msg = ('The provided kinematic differential equations are ' + 'nonlinear in {}. They must be linear in the ' + 'generalized speeds and derivatives of the generalized ' + 'coordinates.') + raise ValueError(msg.format(nonlin_vars)) + + self._f_k_implicit = f_k.xreplace(uaux_zero) + self._k_ku_implicit = k_ku.xreplace(uaux_zero) + self._k_kqdot_implicit = k_kqdot + + # Solve for q'(t) such that the coefficient matrices are now in + # this form: + # + # k_kqdot^-1*k_ku*u(t) + I*q'(t) + k_kqdot^-1*f_k = 0 + # + # NOTE : Solving the kinematic differential equations here is not + # necessary and prevents the equations from being provided in fully + # implicit form. + f_k_explicit = k_kqdot.LUsolve(f_k) + k_ku_explicit = k_kqdot.LUsolve(k_ku) + self._qdot_u_map = dict(zip(qdot, -(k_ku_explicit*u + f_k_explicit))) + + self._f_k = f_k_explicit.xreplace(uaux_zero) + self._k_ku = k_ku_explicit.xreplace(uaux_zero) + self._k_kqdot = eye(len(qdot)) + + else: + self._qdot_u_map = None + self._f_k_implicit = self._f_k = Matrix() + self._k_ku_implicit = self._k_ku = Matrix() + self._k_kqdot_implicit = self._k_kqdot = Matrix() + + def _form_fr(self, fl): + """Form the generalized active force.""" + if fl is not None and (len(fl) == 0 or not iterable(fl)): + raise ValueError('Force pairs must be supplied in an ' + 'non-empty iterable or None.') + + N = self._inertial + # pull out relevant velocities for constructing partial velocities + vel_list, f_list = _f_list_parser(fl, N) + vel_list = [msubs(i, self._qdot_u_map) for i in vel_list] + f_list = [msubs(i, self._qdot_u_map) for i in f_list] + + # Fill Fr with dot product of partial velocities and forces + o = len(self.u) + b = len(f_list) + FR = zeros(o, 1) + partials = partial_velocity(vel_list, self.u, N) + for i in range(o): + FR[i] = sum(partials[j][i] & f_list[j] for j in range(b)) + + # In case there are dependent speeds + if self._udep: + p = o - len(self._udep) + FRtilde = FR[:p, 0] + FRold = FR[p:o, 0] + FRtilde += self._Ars.T * FRold + FR = FRtilde + + self._forcelist = fl + self._fr = FR + return FR + + def _form_frstar(self, bl): + """Form the generalized inertia force.""" + + if not iterable(bl): + raise TypeError('Bodies must be supplied in an iterable.') + + t = dynamicsymbols._t + N = self._inertial + # Dicts setting things to zero + udot_zero = {i: 0 for i in self._udot} + uaux_zero = {i: 0 for i in self._uaux} + uauxdot = [diff(i, t) for i in self._uaux] + uauxdot_zero = {i: 0 for i in uauxdot} + # Dictionary of q' and q'' to u and u' + q_ddot_u_map = {k.diff(t): v.diff(t) for (k, v) in + self._qdot_u_map.items()} + q_ddot_u_map.update(self._qdot_u_map) + + # Fill up the list of partials: format is a list with num elements + # equal to number of entries in body list. Each of these elements is a + # list - either of length 1 for the translational components of + # particles or of length 2 for the translational and rotational + # components of rigid bodies. The inner most list is the list of + # partial velocities. + def get_partial_velocity(body): + if isinstance(body, RigidBody): + vlist = [body.masscenter.vel(N), body.frame.ang_vel_in(N)] + elif isinstance(body, Particle): + vlist = [body.point.vel(N),] + else: + raise TypeError('The body list may only contain either ' + 'RigidBody or Particle as list elements.') + v = [msubs(vel, self._qdot_u_map) for vel in vlist] + return partial_velocity(v, self.u, N) + partials = [get_partial_velocity(body) for body in bl] + + # Compute fr_star in two components: + # fr_star = -(MM*u' + nonMM) + o = len(self.u) + MM = zeros(o, o) + nonMM = zeros(o, 1) + zero_uaux = lambda expr: msubs(expr, uaux_zero) + zero_udot_uaux = lambda expr: msubs(msubs(expr, udot_zero), uaux_zero) + for i, body in enumerate(bl): + if isinstance(body, RigidBody): + M = zero_uaux(body.mass) + I = zero_uaux(body.central_inertia) + vel = zero_uaux(body.masscenter.vel(N)) + omega = zero_uaux(body.frame.ang_vel_in(N)) + acc = zero_udot_uaux(body.masscenter.acc(N)) + inertial_force = (M.diff(t) * vel + M * acc) + inertial_torque = zero_uaux((I.dt(body.frame) & omega) + + msubs(I & body.frame.ang_acc_in(N), udot_zero) + + (omega ^ (I & omega))) + for j in range(o): + tmp_vel = zero_uaux(partials[i][0][j]) + tmp_ang = zero_uaux(I & partials[i][1][j]) + for k in range(o): + # translational + MM[j, k] += M * (tmp_vel & partials[i][0][k]) + # rotational + MM[j, k] += (tmp_ang & partials[i][1][k]) + nonMM[j] += inertial_force & partials[i][0][j] + nonMM[j] += inertial_torque & partials[i][1][j] + else: + M = zero_uaux(body.mass) + vel = zero_uaux(body.point.vel(N)) + acc = zero_udot_uaux(body.point.acc(N)) + inertial_force = (M.diff(t) * vel + M * acc) + for j in range(o): + temp = zero_uaux(partials[i][0][j]) + for k in range(o): + MM[j, k] += M * (temp & partials[i][0][k]) + nonMM[j] += inertial_force & partials[i][0][j] + # Compose fr_star out of MM and nonMM + MM = zero_uaux(msubs(MM, q_ddot_u_map)) + nonMM = msubs(msubs(nonMM, q_ddot_u_map), + udot_zero, uauxdot_zero, uaux_zero) + fr_star = -(MM * msubs(Matrix(self._udot), uauxdot_zero) + nonMM) + + # If there are dependent speeds, we need to find fr_star_tilde + if self._udep: + p = o - len(self._udep) + fr_star_ind = fr_star[:p, 0] + fr_star_dep = fr_star[p:o, 0] + fr_star = fr_star_ind + (self._Ars.T * fr_star_dep) + # Apply the same to MM + MMi = MM[:p, :] + MMd = MM[p:o, :] + MM = MMi + (self._Ars.T * MMd) + + self._bodylist = bl + self._frstar = fr_star + self._k_d = MM + self._f_d = -msubs(self._fr + self._frstar, udot_zero) + return fr_star + + def to_linearizer(self): + """Returns an instance of the Linearizer class, initiated from the + data in the KanesMethod class. This may be more desirable than using + the linearize class method, as the Linearizer object will allow more + efficient recalculation (i.e. about varying operating points).""" + + if (self._fr is None) or (self._frstar is None): + raise ValueError('Need to compute Fr, Fr* first.') + + # Get required equation components. The Kane's method class breaks + # these into pieces. Need to reassemble + f_c = self._f_h + if self._f_nh and self._k_nh: + f_v = self._f_nh + self._k_nh*Matrix(self.u) + else: + f_v = Matrix() + if self._f_dnh and self._k_dnh: + f_a = self._f_dnh + self._k_dnh*Matrix(self._udot) + else: + f_a = Matrix() + # Dicts to sub to zero, for splitting up expressions + u_zero = {i: 0 for i in self.u} + ud_zero = {i: 0 for i in self._udot} + qd_zero = {i: 0 for i in self._qdot} + qd_u_zero = {i: 0 for i in Matrix([self._qdot, self.u])} + # Break the kinematic differential eqs apart into f_0 and f_1 + f_0 = msubs(self._f_k, u_zero) + self._k_kqdot*Matrix(self._qdot) + f_1 = msubs(self._f_k, qd_zero) + self._k_ku*Matrix(self.u) + # Break the dynamic differential eqs into f_2 and f_3 + f_2 = msubs(self._frstar, qd_u_zero) + f_3 = msubs(self._frstar, ud_zero) + self._fr + f_4 = zeros(len(f_2), 1) + + # Get the required vector components + q = self.q + u = self.u + if self._qdep: + q_i = q[:-len(self._qdep)] + else: + q_i = q + q_d = self._qdep + if self._udep: + u_i = u[:-len(self._udep)] + else: + u_i = u + u_d = self._udep + + # Form dictionary to set auxiliary speeds & their derivatives to 0. + uaux = self._uaux + uauxdot = uaux.diff(dynamicsymbols._t) + uaux_zero = {i: 0 for i in Matrix([uaux, uauxdot])} + + # Checking for dynamic symbols outside the dynamic differential + # equations; throws error if there is. + sym_list = set(Matrix([q, self._qdot, u, self._udot, uaux, uauxdot])) + if any(find_dynamicsymbols(i, sym_list) for i in [self._k_kqdot, + self._k_ku, self._f_k, self._k_dnh, self._f_dnh, self._k_d]): + raise ValueError('Cannot have dynamicsymbols outside dynamic \ + forcing vector.') + + # Find all other dynamic symbols, forming the forcing vector r. + # Sort r to make it canonical. + r = list(find_dynamicsymbols(msubs(self._f_d, uaux_zero), sym_list)) + r.sort(key=default_sort_key) + + # Check for any derivatives of variables in r that are also found in r. + for i in r: + if diff(i, dynamicsymbols._t) in r: + raise ValueError('Cannot have derivatives of specified \ + quantities when linearizing forcing terms.') + return Linearizer(f_0, f_1, f_2, f_3, f_4, f_c, f_v, f_a, q, u, q_i, + q_d, u_i, u_d, r) + + # TODO : Remove `new_method` after 1.1 has been released. + def linearize(self, *, new_method=None, **kwargs): + """ Linearize the equations of motion about a symbolic operating point. + + Explanation + =========== + + If kwarg A_and_B is False (default), returns M, A, B, r for the + linearized form, M*[q', u']^T = A*[q_ind, u_ind]^T + B*r. + + If kwarg A_and_B is True, returns A, B, r for the linearized form + dx = A*x + B*r, where x = [q_ind, u_ind]^T. Note that this is + computationally intensive if there are many symbolic parameters. For + this reason, it may be more desirable to use the default A_and_B=False, + returning M, A, and B. Values may then be substituted in to these + matrices, and the state space form found as + A = P.T*M.inv()*A, B = P.T*M.inv()*B, where P = Linearizer.perm_mat. + + In both cases, r is found as all dynamicsymbols in the equations of + motion that are not part of q, u, q', or u'. They are sorted in + canonical form. + + The operating points may be also entered using the ``op_point`` kwarg. + This takes a dictionary of {symbol: value}, or a an iterable of such + dictionaries. The values may be numeric or symbolic. The more values + you can specify beforehand, the faster this computation will run. + + For more documentation, please see the ``Linearizer`` class.""" + linearizer = self.to_linearizer() + result = linearizer.linearize(**kwargs) + return result + (linearizer.r,) + + def kanes_equations(self, bodies=None, loads=None): + """ Method to form Kane's equations, Fr + Fr* = 0. + + Explanation + =========== + + Returns (Fr, Fr*). In the case where auxiliary generalized speeds are + present (say, s auxiliary speeds, o generalized speeds, and m motion + constraints) the length of the returned vectors will be o - m + s in + length. The first o - m equations will be the constrained Kane's + equations, then the s auxiliary Kane's equations. These auxiliary + equations can be accessed with the auxiliary_eqs property. + + Parameters + ========== + + bodies : iterable + An iterable of all RigidBody's and Particle's in the system. + A system must have at least one body. + loads : iterable + Takes in an iterable of (Particle, Vector) or (ReferenceFrame, Vector) + tuples which represent the force at a point or torque on a frame. + Must be either a non-empty iterable of tuples or None which corresponds + to a system with no constraints. + """ + if bodies is None: + bodies = self.bodies + if loads is None and self._forcelist is not None: + loads = self._forcelist + if loads == []: + loads = None + if not self._k_kqdot: + raise AttributeError('Create an instance of KanesMethod with ' + 'kinematic differential equations to use this method.') + fr = self._form_fr(loads) + frstar = self._form_frstar(bodies) + if self._uaux: + if not self._udep: + km = KanesMethod(self._inertial, self.q, self._uaux, + u_auxiliary=self._uaux) + else: + km = KanesMethod(self._inertial, self.q, self._uaux, + u_auxiliary=self._uaux, u_dependent=self._udep, + velocity_constraints=(self._k_nh * self.u + + self._f_nh), + acceleration_constraints=(self._k_dnh * self._udot + + self._f_dnh) + ) + km._qdot_u_map = self._qdot_u_map + self._km = km + fraux = km._form_fr(loads) + frstaraux = km._form_frstar(bodies) + self._aux_eq = fraux + frstaraux + self._fr = fr.col_join(fraux) + self._frstar = frstar.col_join(frstaraux) + return (self._fr, self._frstar) + + def _form_eoms(self): + fr, frstar = self.kanes_equations(self.bodylist, self.forcelist) + return fr + frstar + + def rhs(self, inv_method=None): + """Returns the system's equations of motion in first order form. The + output is the right hand side of:: + + x' = |q'| =: f(q, u, r, p, t) + |u'| + + The right hand side is what is needed by most numerical ODE + integrators. + + Parameters + ========== + + inv_method : str + The specific sympy inverse matrix calculation method to use. For a + list of valid methods, see + :meth:`~sympy.matrices.matrices.MatrixBase.inv` + + """ + rhs = zeros(len(self.q) + len(self.u), 1) + kdes = self.kindiffdict() + for i, q_i in enumerate(self.q): + rhs[i] = kdes[q_i.diff()] + + if inv_method is None: + rhs[len(self.q):, 0] = self.mass_matrix.LUsolve(self.forcing) + else: + rhs[len(self.q):, 0] = (self.mass_matrix.inv(inv_method, + try_block_diag=True) * + self.forcing) + + return rhs + + def kindiffdict(self): + """Returns a dictionary mapping q' to u.""" + if not self._qdot_u_map: + raise AttributeError('Create an instance of KanesMethod with ' + 'kinematic differential equations to use this method.') + return self._qdot_u_map + + @property + def auxiliary_eqs(self): + """A matrix containing the auxiliary equations.""" + if not self._fr or not self._frstar: + raise ValueError('Need to compute Fr, Fr* first.') + if not self._uaux: + raise ValueError('No auxiliary speeds have been declared.') + return self._aux_eq + + @property + def mass_matrix_kin(self): + r"""The kinematic "mass matrix" $\mathbf{k_{k\dot{q}}}$ of the system.""" + return self._k_kqdot if self.explicit_kinematics else self._k_kqdot_implicit + + @property + def forcing_kin(self): + """The kinematic "forcing vector" of the system.""" + if self.explicit_kinematics: + return -(self._k_ku * Matrix(self.u) + self._f_k) + else: + return -(self._k_ku_implicit * Matrix(self.u) + self._f_k_implicit) + + @property + def mass_matrix(self): + """The mass matrix of the system.""" + if not self._fr or not self._frstar: + raise ValueError('Need to compute Fr, Fr* first.') + return Matrix([self._k_d, self._k_dnh]) + + @property + def forcing(self): + """The forcing vector of the system.""" + if not self._fr or not self._frstar: + raise ValueError('Need to compute Fr, Fr* first.') + return -Matrix([self._f_d, self._f_dnh]) + + @property + def mass_matrix_full(self): + """The mass matrix of the system, augmented by the kinematic + differential equations in explicit or implicit form.""" + if not self._fr or not self._frstar: + raise ValueError('Need to compute Fr, Fr* first.') + o, n = len(self.u), len(self.q) + return (self.mass_matrix_kin.row_join(zeros(n, o))).col_join( + zeros(o, n).row_join(self.mass_matrix)) + + @property + def forcing_full(self): + """The forcing vector of the system, augmented by the kinematic + differential equations in explicit or implicit form.""" + return Matrix([self.forcing_kin, self.forcing]) + + @property + def q(self): + return self._q + + @property + def u(self): + return self._u + + @property + def bodylist(self): + return self._bodylist + + @property + def forcelist(self): + return self._forcelist + + @property + def bodies(self): + return self._bodylist + + @property + def loads(self): + return self._forcelist diff --git a/shared/package-files/2f/2fe8c4f0867b90ee0bddbbe583e79b79b32ffa47b0f184c773f4a832768e531d/blob b/shared/package-files/2f/2fe8c4f0867b90ee0bddbbe583e79b79b32ffa47b0f184c773f4a832768e531d/blob new file mode 100644 index 0000000000000000000000000000000000000000..1799fe278abc2de3a1ecd8e37a029cad8cd62e03 --- /dev/null +++ b/shared/package-files/2f/2fe8c4f0867b90ee0bddbbe583e79b79b32ffa47b0f184c773f4a832768e531d/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API linalg_matrix_power { + using schema = at::Tensor (const at::Tensor &, int64_t); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::linalg_matrix_power") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "linalg_matrix_power(Tensor self, int n) -> Tensor") + static at::Tensor call(const at::Tensor & self, int64_t n); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, int64_t n); +}; + +struct TORCH_API linalg_matrix_power_out { + using schema = at::Tensor & (const at::Tensor &, int64_t, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::linalg_matrix_power") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "linalg_matrix_power.out(Tensor self, int n, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, int64_t n, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, int64_t n, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/2f/2fea7bfd340ef505b328bd34623ba8cd9099cac42ee171a914837b1805dd97b2/blob b/shared/package-files/2f/2fea7bfd340ef505b328bd34623ba8cd9099cac42ee171a914837b1805dd97b2/blob new file mode 100644 index 0000000000000000000000000000000000000000..40a5a211dd714ce948228ab42a576a50e939c7b9 --- /dev/null +++ b/shared/package-files/2f/2fea7bfd340ef505b328bd34623ba8cd9099cac42ee171a914837b1805dd97b2/blob @@ -0,0 +1,24 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor nonzero_cpu(const at::Tensor & self); +TORCH_API at::Tensor & nonzero_out_cpu(const at::Tensor & self, at::Tensor & out); +TORCH_API at::Tensor nonzero_cuda(const at::Tensor & self); +TORCH_API at::Tensor & nonzero_out_cuda(const at::Tensor & self, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/shared/package-files/2f/2feb17cfc434d0f4cdd642543faef73a553dba8a916bd847309de1447dd5ab18/blob b/shared/package-files/2f/2feb17cfc434d0f4cdd642543faef73a553dba8a916bd847309de1447dd5ab18/blob new file mode 100644 index 0000000000000000000000000000000000000000..31a6179d6b776a7ef1dafcd4db0e3ba3a5232d89 --- /dev/null +++ b/shared/package-files/2f/2feb17cfc434d0f4cdd642543faef73a553dba8a916bd847309de1447dd5ab18/blob @@ -0,0 +1,28 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API q_scale { + using schema = double (const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::q_scale") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "q_scale(Tensor self) -> float") + static double call(const at::Tensor & self); + static double redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/2f/2ff15d6669a4e4df95122bc4fcefea65af7c059853d564b145f7661bcd7b6c0d/blob b/shared/package-files/2f/2ff15d6669a4e4df95122bc4fcefea65af7c059853d564b145f7661bcd7b6c0d/blob new file mode 100644 index 0000000000000000000000000000000000000000..137cfdf5c858544f0811ae666f000cfb368787a0 --- /dev/null +++ b/shared/package-files/2f/2ff15d6669a4e4df95122bc4fcefea65af7c059853d564b145f7661bcd7b6c0d/blob @@ -0,0 +1,176 @@ +""" +test_pythonmpq.py + +Test the PythonMPQ class for consistency with gmpy2's mpq type. If gmpy2 is +installed run the same tests for both. +""" +from fractions import Fraction +from decimal import Decimal +import pickle +from typing import Callable, List, Tuple, Type + +from sympy.testing.pytest import raises + +from sympy.external.pythonmpq import PythonMPQ + +# +# If gmpy2 is installed then run the tests for both mpq and PythonMPQ. +# That should ensure consistency between the implementation here and mpq. +# +rational_types: List[Tuple[Callable, Type, Callable, Type]] +rational_types = [(PythonMPQ, PythonMPQ, int, int)] +try: + from gmpy2 import mpq, mpz + rational_types.append((mpq, type(mpq(1)), mpz, type(mpz(1)))) +except ImportError: + pass + + +def test_PythonMPQ(): + # + # Test PythonMPQ and also mpq if gmpy/gmpy2 is installed. + # + for Q, TQ, Z, TZ in rational_types: + + def check_Q(q): + assert isinstance(q, TQ) + assert isinstance(q.numerator, TZ) + assert isinstance(q.denominator, TZ) + return q.numerator, q.denominator + + # Check construction from different types + assert check_Q(Q(3)) == (3, 1) + assert check_Q(Q(3, 5)) == (3, 5) + assert check_Q(Q(Q(3, 5))) == (3, 5) + assert check_Q(Q(0.5)) == (1, 2) + assert check_Q(Q('0.5')) == (1, 2) + assert check_Q(Q(Fraction(3, 5))) == (3, 5) + + # https://github.com/aleaxit/gmpy/issues/327 + if Q is PythonMPQ: + assert check_Q(Q(Decimal('0.6'))) == (3, 5) + + # Invalid types + raises(TypeError, lambda: Q([])) + raises(TypeError, lambda: Q([], [])) + + # Check normalisation of signs + assert check_Q(Q(2, 3)) == (2, 3) + assert check_Q(Q(-2, 3)) == (-2, 3) + assert check_Q(Q(2, -3)) == (-2, 3) + assert check_Q(Q(-2, -3)) == (2, 3) + + # Check gcd calculation + assert check_Q(Q(12, 8)) == (3, 2) + + # __int__/__float__ + assert int(Q(5, 3)) == 1 + assert int(Q(-5, 3)) == -1 + assert float(Q(5, 2)) == 2.5 + assert float(Q(-5, 2)) == -2.5 + + # __str__/__repr__ + assert str(Q(2, 1)) == "2" + assert str(Q(1, 2)) == "1/2" + if Q is PythonMPQ: + assert repr(Q(2, 1)) == "MPQ(2,1)" + assert repr(Q(1, 2)) == "MPQ(1,2)" + else: + assert repr(Q(2, 1)) == "mpq(2,1)" + assert repr(Q(1, 2)) == "mpq(1,2)" + + # __bool__ + assert bool(Q(1, 2)) is True + assert bool(Q(0)) is False + + # __eq__/__ne__ + assert (Q(2, 3) == Q(2, 3)) is True + assert (Q(2, 3) == Q(2, 5)) is False + assert (Q(2, 3) != Q(2, 3)) is False + assert (Q(2, 3) != Q(2, 5)) is True + + # __hash__ + assert hash(Q(3, 5)) == hash(Fraction(3, 5)) + + # __reduce__ + q = Q(2, 3) + assert pickle.loads(pickle.dumps(q)) == q + + # __ge__/__gt__/__le__/__lt__ + assert (Q(1, 3) < Q(2, 3)) is True + assert (Q(2, 3) < Q(2, 3)) is False + assert (Q(2, 3) < Q(1, 3)) is False + assert (Q(-2, 3) < Q(1, 3)) is True + assert (Q(1, 3) < Q(-2, 3)) is False + + assert (Q(1, 3) <= Q(2, 3)) is True + assert (Q(2, 3) <= Q(2, 3)) is True + assert (Q(2, 3) <= Q(1, 3)) is False + assert (Q(-2, 3) <= Q(1, 3)) is True + assert (Q(1, 3) <= Q(-2, 3)) is False + + assert (Q(1, 3) > Q(2, 3)) is False + assert (Q(2, 3) > Q(2, 3)) is False + assert (Q(2, 3) > Q(1, 3)) is True + assert (Q(-2, 3) > Q(1, 3)) is False + assert (Q(1, 3) > Q(-2, 3)) is True + + assert (Q(1, 3) >= Q(2, 3)) is False + assert (Q(2, 3) >= Q(2, 3)) is True + assert (Q(2, 3) >= Q(1, 3)) is True + assert (Q(-2, 3) >= Q(1, 3)) is False + assert (Q(1, 3) >= Q(-2, 3)) is True + + # __abs__/__pos__/__neg__ + assert abs(Q(2, 3)) == abs(Q(-2, 3)) == Q(2, 3) + assert +Q(2, 3) == Q(2, 3) + assert -Q(2, 3) == Q(-2, 3) + + # __add__/__radd__ + assert Q(2, 3) + Q(5, 7) == Q(29, 21) + assert Q(2, 3) + 1 == Q(5, 3) + assert 1 + Q(2, 3) == Q(5, 3) + raises(TypeError, lambda: [] + Q(1)) + raises(TypeError, lambda: Q(1) + []) + + # __sub__/__rsub__ + assert Q(2, 3) - Q(5, 7) == Q(-1, 21) + assert Q(2, 3) - 1 == Q(-1, 3) + assert 1 - Q(2, 3) == Q(1, 3) + raises(TypeError, lambda: [] - Q(1)) + raises(TypeError, lambda: Q(1) - []) + + # __mul__/__rmul__ + assert Q(2, 3) * Q(5, 7) == Q(10, 21) + assert Q(2, 3) * 1 == Q(2, 3) + assert 1 * Q(2, 3) == Q(2, 3) + raises(TypeError, lambda: [] * Q(1)) + raises(TypeError, lambda: Q(1) * []) + + # __pow__/__rpow__ + assert Q(2, 3) ** 2 == Q(4, 9) + assert Q(2, 3) ** 1 == Q(2, 3) + assert Q(-2, 3) ** 2 == Q(4, 9) + assert Q(-2, 3) ** -1 == Q(-3, 2) + if Q is PythonMPQ: + raises(TypeError, lambda: 1 ** Q(2, 3)) + raises(TypeError, lambda: Q(1, 4) ** Q(1, 2)) + raises(TypeError, lambda: [] ** Q(1)) + raises(TypeError, lambda: Q(1) ** []) + + # __div__/__rdiv__ + assert Q(2, 3) / Q(5, 7) == Q(14, 15) + assert Q(2, 3) / 1 == Q(2, 3) + assert 1 / Q(2, 3) == Q(3, 2) + raises(TypeError, lambda: [] / Q(1)) + raises(TypeError, lambda: Q(1) / []) + raises(ZeroDivisionError, lambda: Q(1, 2) / Q(0)) + + # __divmod__ + if Q is PythonMPQ: + raises(TypeError, lambda: Q(2, 3) // Q(1, 3)) + raises(TypeError, lambda: Q(2, 3) % Q(1, 3)) + raises(TypeError, lambda: 1 // Q(1, 3)) + raises(TypeError, lambda: 1 % Q(1, 3)) + raises(TypeError, lambda: Q(2, 3) // 1) + raises(TypeError, lambda: Q(2, 3) % 1) diff --git a/shared/package-files/2f/2ff8fe774918b80fcccc0dbfda1ada175a2f7fa293e834eab91755de9690c0e9/blob b/shared/package-files/2f/2ff8fe774918b80fcccc0dbfda1ada175a2f7fa293e834eab91755de9690c0e9/blob new file mode 100644 index 0000000000000000000000000000000000000000..8ce89cef706adc0d08fc4de5625a495e4003798e --- /dev/null +++ b/shared/package-files/2f/2ff8fe774918b80fcccc0dbfda1ada175a2f7fa293e834eab91755de9690c0e9/blob @@ -0,0 +1,4 @@ +from .core import contents, where + +__all__ = ["contents", "where"] +__version__ = "2023.07.22" diff --git a/shared/package-files/30/3000a05a8d25ec3d78f48ab381357e31ac3ffbee5af4ac76baa12016ac6ebaa7/blob b/shared/package-files/30/3000a05a8d25ec3d78f48ab381357e31ac3ffbee5af4ac76baa12016ac6ebaa7/blob new file mode 100644 index 0000000000000000000000000000000000000000..813064d4fabb927b9125b791d892d82483c53845 --- /dev/null +++ b/shared/package-files/30/3000a05a8d25ec3d78f48ab381357e31ac3ffbee5af4ac76baa12016ac6ebaa7/blob @@ -0,0 +1,12 @@ +#pragma once + +#include +#include + +namespace torch { +namespace jit { + +TORCH_API std::string prettyPrint(const ::ONNX_NAMESPACE::ModelProto& model); + +} // namespace jit +} // namespace torch diff --git a/shared/package-files/30/3008f6609e2026600f29aa8488df7d09c15539340e20c8061ca52f297ddd15ae/blob b/shared/package-files/30/3008f6609e2026600f29aa8488df7d09c15539340e20c8061ca52f297ddd15ae/blob new file mode 100644 index 0000000000000000000000000000000000000000..d615ac650ad983cc887fd5b0594a7d85673cb0eb Binary files /dev/null and b/shared/package-files/30/3008f6609e2026600f29aa8488df7d09c15539340e20c8061ca52f297ddd15ae/blob differ diff --git a/shared/package-files/30/300f627fc2199deb246ec793ef47b032de742d763a4170c8bb15e19ccbf602a5/blob b/shared/package-files/30/300f627fc2199deb246ec793ef47b032de742d763a4170c8bb15e19ccbf602a5/blob new file mode 100644 index 0000000000000000000000000000000000000000..20721fe980c784e1497ef96c7e52d11f834d9740 --- /dev/null +++ b/shared/package-files/30/300f627fc2199deb246ec793ef47b032de742d763a4170c8bb15e19ccbf602a5/blob @@ -0,0 +1,14 @@ +"""Test util, coverage 100%""" + +import unittest +from idlelib import util + + +class UtilTest(unittest.TestCase): + def test_extensions(self): + for extension in {'.pyi', '.py', '.pyw'}: + self.assertIn(extension, util.py_extensions) + + +if __name__ == '__main__': + unittest.main(verbosity=2) diff --git a/shared/package-files/30/300fd588c4d0e5d8b8960c0eb5fa0eb2d897497434903c8fff65b52717978c56/blob b/shared/package-files/30/300fd588c4d0e5d8b8960c0eb5fa0eb2d897497434903c8fff65b52717978c56/blob new file mode 100644 index 0000000000000000000000000000000000000000..e5d7c16641a0066a9c914840b11db712735b6666 --- /dev/null +++ b/shared/package-files/30/300fd588c4d0e5d8b8960c0eb5fa0eb2d897497434903c8fff65b52717978c56/blob @@ -0,0 +1,22 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor fft_fftfreq(int64_t n, double d=1.0, c10::optional dtype={}, c10::optional layout={}, c10::optional device={}, c10::optional pin_memory={}); +TORCH_API at::Tensor & fft_fftfreq_out(int64_t n, double d, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/shared/package-files/30/30115cfb20236f88bd9006f0fdeb91d47c4b8072f7d5b078edde1d59fec3f77f/model_manifest.json b/shared/package-files/30/30115cfb20236f88bd9006f0fdeb91d47c4b8072f7d5b078edde1d59fec3f77f/model_manifest.json new file mode 100644 index 0000000000000000000000000000000000000000..ef17a6c3ee6dba6768d6a6201a2a4cf7938b9c83 --- /dev/null +++ b/shared/package-files/30/30115cfb20236f88bd9006f0fdeb91d47c4b8072f7d5b078edde1d59fec3f77f/model_manifest.json @@ -0,0 +1,13 @@ +{ + "schema": "massspecgym-retrieval-model/v1", + "checkpoint": { + "path": ".versions/generation-5y79tkae/glacier.ckpt", + "sha256": "e79b4150ce92647fe99446477caf1f6c3819d343ea3867db8af1e2e7ad0ed369", + "format": "pytorch" + }, + "model_config": ".versions/generation-5y79tkae/model_config.json", + "training_provenance": { + "data": "MassSpecGym v1.5 train; validation for selection only", + "pretrained_assets": [] + } +} diff --git a/shared/package-files/30/301396b4a42c814b1a15038ddfcbcf5c8590501231747d0dc2a500b84b2fd0df/blob b/shared/package-files/30/301396b4a42c814b1a15038ddfcbcf5c8590501231747d0dc2a500b84b2fd0df/blob new file mode 100644 index 0000000000000000000000000000000000000000..190571cb65d9048cd6a0fffd0d95179c6bc2c242 Binary files /dev/null and b/shared/package-files/30/301396b4a42c814b1a15038ddfcbcf5c8590501231747d0dc2a500b84b2fd0df/blob differ diff --git a/shared/package-files/30/3013cc83552df55489ec66b33198f7e3cb24a52c8505d40d10c04d26762f8957/blob b/shared/package-files/30/3013cc83552df55489ec66b33198f7e3cb24a52c8505d40d10c04d26762f8957/blob new file mode 100644 index 0000000000000000000000000000000000000000..1289bdcdffe47bce04e3aa0a663b5d8d5c443b10 --- /dev/null +++ b/shared/package-files/30/3013cc83552df55489ec66b33198f7e3cb24a52c8505d40d10c04d26762f8957/blob @@ -0,0 +1,23 @@ +import contextlib +import threading + +# Global variable to identify which SubgraphTracer we are in. +# It is sometimes difficult to find an InstructionTranslator to use. +_current_scope_id = threading.local() + + +def current_scope_id(): + global _current_scope_id + if not hasattr(_current_scope_id, "value"): + _current_scope_id.value = 1 + return _current_scope_id.value + + +@contextlib.contextmanager +def enter_new_scope(): + global _current_scope_id + try: + _current_scope_id.value = current_scope_id() + 1 + yield + finally: + _current_scope_id.value = current_scope_id() - 1 diff --git a/shared/package-files/30/30146d9afaf3ff6fdcac62a73a6aa4e99a30ad4ee64baf77cf868db12232a0a2/blob b/shared/package-files/30/30146d9afaf3ff6fdcac62a73a6aa4e99a30ad4ee64baf77cf868db12232a0a2/blob new file mode 100644 index 0000000000000000000000000000000000000000..b8dbb2a389921d7e6fd1bb87c8f8d77ae0d66844 Binary files /dev/null and b/shared/package-files/30/30146d9afaf3ff6fdcac62a73a6aa4e99a30ad4ee64baf77cf868db12232a0a2/blob differ diff --git a/shared/package-files/30/3015cb8615477d0cb9fad55c2c4a51c2cb65399b9976b54220f78280c4a9e0b5/blob b/shared/package-files/30/3015cb8615477d0cb9fad55c2c4a51c2cb65399b9976b54220f78280c4a9e0b5/blob new file mode 100644 index 0000000000000000000000000000000000000000..ca036f761365733d175c1b8870d6152f2c5d4ecc --- /dev/null +++ b/shared/package-files/30/3015cb8615477d0cb9fad55c2c4a51c2cb65399b9976b54220f78280c4a9e0b5/blob @@ -0,0 +1,27 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace native { +TORCH_API at::Tensor upsample_nearest1d(const at::Tensor & input, at::OptionalIntArrayRef output_size, c10::optional> scale_factors); +struct TORCH_API structured_upsample_nearest1d_out_cpu : public at::meta::structured_upsample_nearest1d { +void impl(const at::Tensor & self, at::ArrayRef output_size, c10::optional scales, const at::Tensor & out); +}; +struct TORCH_API structured_upsample_nearest1d_out_cuda : public at::meta::structured_upsample_nearest1d { +void impl(const at::Tensor & self, at::ArrayRef output_size, c10::optional scales, const at::Tensor & out); +}; +} // namespace native +} // namespace at diff --git a/shared/package-files/30/3017d4cf6e2e21abecb1cb6aea1a48d7e9eef063189c82315b122cd96cc914f0/blob b/shared/package-files/30/3017d4cf6e2e21abecb1cb6aea1a48d7e9eef063189c82315b122cd96cc914f0/blob new file mode 100644 index 0000000000000000000000000000000000000000..2e83ea950c7c808dcb3c9bf1261ed74bf9eac63a --- /dev/null +++ b/shared/package-files/30/3017d4cf6e2e21abecb1cb6aea1a48d7e9eef063189c82315b122cd96cc914f0/blob @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor special_chebyshev_polynomial_u(const at::Tensor & x, const at::Tensor & n); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/shared/package-files/30/301b394ddc39c4080d32509d37c7d22e222cc10b9d6626c86c78c8f4be4111db/blob b/shared/package-files/30/301b394ddc39c4080d32509d37c7d22e222cc10b9d6626c86c78c8f4be4111db/blob new file mode 100644 index 0000000000000000000000000000000000000000..4e050a5196fc4d524a6fa2288eea7f02f0b9a922 --- /dev/null +++ b/shared/package-files/30/301b394ddc39c4080d32509d37c7d22e222cc10b9d6626c86c78c8f4be4111db/blob @@ -0,0 +1,67 @@ +""" +Number theory module (primes, etc) +""" + +from .generate import nextprime, prevprime, prime, primepi, primerange, \ + randprime, Sieve, sieve, primorial, cycle_length, composite, compositepi +from .primetest import isprime, is_gaussian_prime +from .factor_ import divisors, proper_divisors, factorint, multiplicity, \ + multiplicity_in_factorial, perfect_power, pollard_pm1, pollard_rho, \ + primefactors, totient, trailing, \ + divisor_count, proper_divisor_count, divisor_sigma, factorrat, \ + reduced_totient, primenu, primeomega, mersenne_prime_exponent, \ + is_perfect, is_mersenne_prime, is_abundant, is_deficient, is_amicable, \ + abundance, dra, drm + +from .partitions_ import npartitions +from .residue_ntheory import is_primitive_root, is_quad_residue, \ + legendre_symbol, jacobi_symbol, n_order, sqrt_mod, quadratic_residues, \ + primitive_root, nthroot_mod, is_nthpow_residue, sqrt_mod_iter, mobius, \ + discrete_log, quadratic_congruence, polynomial_congruence +from .multinomial import binomial_coefficients, binomial_coefficients_list, \ + multinomial_coefficients +from .continued_fraction import continued_fraction_periodic, \ + continued_fraction_iterator, continued_fraction_reduce, \ + continued_fraction_convergents, continued_fraction +from .digits import count_digits, digits, is_palindromic +from .egyptian_fraction import egyptian_fraction +from .ecm import ecm +from .qs import qs +__all__ = [ + 'nextprime', 'prevprime', 'prime', 'primepi', 'primerange', 'randprime', + 'Sieve', 'sieve', 'primorial', 'cycle_length', 'composite', 'compositepi', + + 'isprime', 'is_gaussian_prime', + + + 'divisors', 'proper_divisors', 'factorint', 'multiplicity', 'perfect_power', + 'pollard_pm1', 'pollard_rho', 'primefactors', 'totient', 'trailing', + 'divisor_count', 'proper_divisor_count', 'divisor_sigma', 'factorrat', + 'reduced_totient', 'primenu', 'primeomega', 'mersenne_prime_exponent', + 'is_perfect', 'is_mersenne_prime', 'is_abundant', 'is_deficient', 'is_amicable', + 'abundance', 'dra', 'drm', 'multiplicity_in_factorial', + + 'npartitions', + + 'is_primitive_root', 'is_quad_residue', 'legendre_symbol', + 'jacobi_symbol', 'n_order', 'sqrt_mod', 'quadratic_residues', + 'primitive_root', 'nthroot_mod', 'is_nthpow_residue', 'sqrt_mod_iter', + 'mobius', 'discrete_log', 'quadratic_congruence', 'polynomial_congruence', + + 'binomial_coefficients', 'binomial_coefficients_list', + 'multinomial_coefficients', + + 'continued_fraction_periodic', 'continued_fraction_iterator', + 'continued_fraction_reduce', 'continued_fraction_convergents', + 'continued_fraction', + + 'digits', + 'count_digits', + 'is_palindromic', + + 'egyptian_fraction', + + 'ecm', + + 'qs', +] diff --git a/shared/package-files/30/301c6aab09868c99c2280de1349be30b90c1022f6536a5162d3305b26174596d/blob b/shared/package-files/30/301c6aab09868c99c2280de1349be30b90c1022f6536a5162d3305b26174596d/blob new file mode 100644 index 0000000000000000000000000000000000000000..6dced6271caf885396711390b8b058c505ecc5e5 --- /dev/null +++ b/shared/package-files/30/301c6aab09868c99c2280de1349be30b90c1022f6536a5162d3305b26174596d/blob @@ -0,0 +1,22 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor & quantize_per_channel_out(const at::Tensor & self, const at::Tensor & scales, const at::Tensor & zero_points, int64_t axis, at::ScalarType dtype, at::Tensor & out); +TORCH_API at::Tensor quantize_per_channel(const at::Tensor & self, const at::Tensor & scales, const at::Tensor & zero_points, int64_t axis, at::ScalarType dtype); +} // namespace native +} // namespace at diff --git a/shared/package-files/30/301fcc96df6eb0ce30a42ab2f87e626e1fba3f57fbd372ef2261dcb8b4e14481/alignment_entropy.py b/shared/package-files/30/301fcc96df6eb0ce30a42ab2f87e626e1fba3f57fbd372ef2261dcb8b4e14481/alignment_entropy.py new file mode 100644 index 0000000000000000000000000000000000000000..f9bda176f93df44e9e2305ee826f1e45baef103f --- /dev/null +++ b/shared/package-files/30/301fcc96df6eb0ce30a42ab2f87e626e1fba3f57fbd372ef2261dcb8b4e14481/alignment_entropy.py @@ -0,0 +1,15 @@ +"""Change matching tolerance only, preserving the selected precursor rule.""" +import numpy as np +from mass_tolerant_entropy import adduct_conditioned_entropy,tolerant_entropy + +def alignment_entropy(predicted,observed,precursor_mz,adduct,scale=1.): + if scale==1.: + return adduct_conditioned_entropy(predicted,observed,precursor_mz,adduct) + def remove_precursor(peaks): + a=np.asarray(peaks,dtype=np.float64).copy() + if a.ndim==2 and len(a): + a[np.abs(a[:,0]-precursor_mz)<=max(.002,20e-6*precursor_mz),1]*=0. + return a + if adduct=='[M+Na]+': + predicted=remove_precursor(predicted);observed=remove_precursor(observed) + return tolerant_entropy(predicted,observed,ppm=20.*scale,absolute_floor=.002*scale) diff --git a/shared/package-files/30/3022059ecfe9ee1a9dfe2adea0716707d809f9ed9079612846fc0b939d0d3ab8/blob b/shared/package-files/30/3022059ecfe9ee1a9dfe2adea0716707d809f9ed9079612846fc0b939d0d3ab8/blob new file mode 100644 index 0000000000000000000000000000000000000000..d0d3fbea88f390a148b968091746b5c18ac76141 Binary files /dev/null and b/shared/package-files/30/3022059ecfe9ee1a9dfe2adea0716707d809f9ed9079612846fc0b939d0d3ab8/blob differ diff --git a/shared/package-files/30/3022648ee919b4e5426ae7381590dba2bd61f7d02f1b878c35f4195bc2f58797/blob b/shared/package-files/30/3022648ee919b4e5426ae7381590dba2bd61f7d02f1b878c35f4195bc2f58797/blob new file mode 100644 index 0000000000000000000000000000000000000000..ef72ca1ac86b9a6eb395a5a64bbfb99aef76a02a --- /dev/null +++ b/shared/package-files/30/3022648ee919b4e5426ae7381590dba2bd61f7d02f1b878c35f4195bc2f58797/blob @@ -0,0 +1,263 @@ +from datetime import datetime + +import numpy as np +import pytest + +from pandas._libs.tslibs.offsets import MonthEnd + +from pandas import ( + DataFrame, + DatetimeIndex, + Series, + date_range, + period_range, + to_datetime, +) +import pandas._testing as tm + +from pandas.tseries import offsets + + +class TestAsFreq: + @pytest.fixture(params=["s", "ms", "us", "ns"]) + def unit(self, request): + return request.param + + def test_asfreq2(self, frame_or_series): + ts = frame_or_series( + [0.0, 1.0, 2.0], + index=DatetimeIndex( + [ + datetime(2009, 10, 30), + datetime(2009, 11, 30), + datetime(2009, 12, 31), + ], + dtype="M8[ns]", + freq="BME", + ), + ) + + daily_ts = ts.asfreq("B") + monthly_ts = daily_ts.asfreq("BME") + tm.assert_equal(monthly_ts, ts) + + daily_ts = ts.asfreq("B", method="pad") + monthly_ts = daily_ts.asfreq("BME") + tm.assert_equal(monthly_ts, ts) + + daily_ts = ts.asfreq(offsets.BDay()) + monthly_ts = daily_ts.asfreq(offsets.BMonthEnd()) + tm.assert_equal(monthly_ts, ts) + + result = ts[:0].asfreq("ME") + assert len(result) == 0 + assert result is not ts + + if frame_or_series is Series: + daily_ts = ts.asfreq("D", fill_value=-1) + result = daily_ts.value_counts().sort_index() + expected = Series( + [60, 1, 1, 1], index=[-1.0, 2.0, 1.0, 0.0], name="count" + ).sort_index() + tm.assert_series_equal(result, expected) + + def test_asfreq_datetimeindex_empty(self, frame_or_series): + # GH#14320 + index = DatetimeIndex(["2016-09-29 11:00"]) + expected = frame_or_series(index=index, dtype=object).asfreq("h") + result = frame_or_series([3], index=index.copy()).asfreq("h") + tm.assert_index_equal(expected.index, result.index) + + @pytest.mark.parametrize("tz", ["US/Eastern", "dateutil/US/Eastern"]) + def test_tz_aware_asfreq_smoke(self, tz, frame_or_series): + dr = date_range("2011-12-01", "2012-07-20", freq="D", tz=tz) + + obj = frame_or_series( + np.random.default_rng(2).standard_normal(len(dr)), index=dr + ) + + # it works! + obj.asfreq("min") + + def test_asfreq_normalize(self, frame_or_series): + rng = date_range("1/1/2000 09:30", periods=20) + norm = date_range("1/1/2000", periods=20) + + vals = np.random.default_rng(2).standard_normal((20, 3)) + + obj = DataFrame(vals, index=rng) + expected = DataFrame(vals, index=norm) + if frame_or_series is Series: + obj = obj[0] + expected = expected[0] + + result = obj.asfreq("D", normalize=True) + tm.assert_equal(result, expected) + + def test_asfreq_keep_index_name(self, frame_or_series): + # GH#9854 + index_name = "bar" + index = date_range("20130101", periods=20, name=index_name) + obj = DataFrame(list(range(20)), columns=["foo"], index=index) + obj = tm.get_obj(obj, frame_or_series) + + assert index_name == obj.index.name + assert index_name == obj.asfreq("10D").index.name + + def test_asfreq_ts(self, frame_or_series): + index = period_range(freq="Y", start="1/1/2001", end="12/31/2010") + obj = DataFrame( + np.random.default_rng(2).standard_normal((len(index), 3)), index=index + ) + obj = tm.get_obj(obj, frame_or_series) + + result = obj.asfreq("D", how="end") + exp_index = index.asfreq("D", how="end") + assert len(result) == len(obj) + tm.assert_index_equal(result.index, exp_index) + + result = obj.asfreq("D", how="start") + exp_index = index.asfreq("D", how="start") + assert len(result) == len(obj) + tm.assert_index_equal(result.index, exp_index) + + def test_asfreq_resample_set_correct_freq(self, frame_or_series): + # GH#5613 + # we test if .asfreq() and .resample() set the correct value for .freq + dti = to_datetime(["2012-01-01", "2012-01-02", "2012-01-03"]) + obj = DataFrame({"col": [1, 2, 3]}, index=dti) + obj = tm.get_obj(obj, frame_or_series) + + # testing the settings before calling .asfreq() and .resample() + assert obj.index.freq is None + assert obj.index.inferred_freq == "D" + + # does .asfreq() set .freq correctly? + assert obj.asfreq("D").index.freq == "D" + + # does .resample() set .freq correctly? + assert obj.resample("D").asfreq().index.freq == "D" + + def test_asfreq_empty(self, datetime_frame): + # test does not blow up on length-0 DataFrame + zero_length = datetime_frame.reindex([]) + result = zero_length.asfreq("BME") + assert result is not zero_length + + def test_asfreq(self, datetime_frame): + offset_monthly = datetime_frame.asfreq(offsets.BMonthEnd()) + rule_monthly = datetime_frame.asfreq("BME") + + tm.assert_frame_equal(offset_monthly, rule_monthly) + + rule_monthly.asfreq("B", method="pad") + # TODO: actually check that this worked. + + # don't forget! + rule_monthly.asfreq("B", method="pad") + + def test_asfreq_datetimeindex(self): + df = DataFrame( + {"A": [1, 2, 3]}, + index=[datetime(2011, 11, 1), datetime(2011, 11, 2), datetime(2011, 11, 3)], + ) + df = df.asfreq("B") + assert isinstance(df.index, DatetimeIndex) + + ts = df["A"].asfreq("B") + assert isinstance(ts.index, DatetimeIndex) + + def test_asfreq_fillvalue(self): + # test for fill value during upsampling, related to issue 3715 + + # setup + rng = date_range("1/1/2016", periods=10, freq="2s") + # Explicit cast to 'float' to avoid implicit cast when setting None + ts = Series(np.arange(len(rng)), index=rng, dtype="float") + df = DataFrame({"one": ts}) + + # insert pre-existing missing value + df.loc["2016-01-01 00:00:08", "one"] = None + + actual_df = df.asfreq(freq="1s", fill_value=9.0) + expected_df = df.asfreq(freq="1s").fillna(9.0) + expected_df.loc["2016-01-01 00:00:08", "one"] = None + tm.assert_frame_equal(expected_df, actual_df) + + expected_series = ts.asfreq(freq="1s").fillna(9.0) + actual_series = ts.asfreq(freq="1s", fill_value=9.0) + tm.assert_series_equal(expected_series, actual_series) + + def test_asfreq_with_date_object_index(self, frame_or_series): + rng = date_range("1/1/2000", periods=20) + ts = frame_or_series(np.random.default_rng(2).standard_normal(20), index=rng) + + ts2 = ts.copy() + ts2.index = [x.date() for x in ts2.index] + + result = ts2.asfreq("4h", method="ffill") + expected = ts.asfreq("4h", method="ffill") + tm.assert_equal(result, expected) + + def test_asfreq_with_unsorted_index(self, frame_or_series): + # GH#39805 + # Test that rows are not dropped when the datetime index is out of order + index = to_datetime(["2021-01-04", "2021-01-02", "2021-01-03", "2021-01-01"]) + result = frame_or_series(range(4), index=index) + + expected = result.reindex(sorted(index)) + expected.index = expected.index._with_freq("infer") + + result = result.asfreq("D") + tm.assert_equal(result, expected) + + def test_asfreq_after_normalize(self, unit): + # https://github.com/pandas-dev/pandas/issues/50727 + result = DatetimeIndex( + date_range("2000", periods=2).as_unit(unit).normalize(), freq="D" + ) + expected = DatetimeIndex(["2000-01-01", "2000-01-02"], freq="D").as_unit(unit) + tm.assert_index_equal(result, expected) + + @pytest.mark.parametrize( + "freq, freq_half", + [ + ("2ME", "ME"), + (MonthEnd(2), MonthEnd(1)), + ], + ) + def test_asfreq_2ME(self, freq, freq_half): + index = date_range("1/1/2000", periods=6, freq=freq_half) + df = DataFrame({"s": Series([0.0, 1.0, 2.0, 3.0, 4.0, 5.0], index=index)}) + expected = df.asfreq(freq=freq) + + index = date_range("1/1/2000", periods=3, freq=freq) + result = DataFrame({"s": Series([0.0, 2.0, 4.0], index=index)}) + tm.assert_frame_equal(result, expected) + + @pytest.mark.parametrize( + "freq, freq_depr", + [ + ("2ME", "2M"), + ("2QE", "2Q"), + ("2QE-SEP", "2Q-SEP"), + ("1BQE", "1BQ"), + ("2BQE-SEP", "2BQ-SEP"), + ("1YE", "1Y"), + ("2YE-MAR", "2Y-MAR"), + ("1YE", "1A"), + ("2YE-MAR", "2A-MAR"), + ("2BYE-MAR", "2BA-MAR"), + ], + ) + def test_asfreq_frequency_M_Q_Y_A_deprecated(self, freq, freq_depr): + # GH#9586, #55978 + depr_msg = f"'{freq_depr[1:]}' is deprecated and will be removed " + f"in a future version, please use '{freq[1:]}' instead." + + index = date_range("1/1/2000", periods=4, freq=f"{freq[1:]}") + df = DataFrame({"s": Series([0.0, 1.0, 2.0, 3.0], index=index)}) + expected = df.asfreq(freq=freq) + with tm.assert_produces_warning(FutureWarning, match=depr_msg): + result = df.asfreq(freq=freq_depr) + tm.assert_frame_equal(result, expected) diff --git a/shared/package-files/30/302435b4d88542b974f8cbad33537f43a407604582bc343a71133f63b577743c/blob b/shared/package-files/30/302435b4d88542b974f8cbad33537f43a407604582bc343a71133f63b577743c/blob new file mode 100644 index 0000000000000000000000000000000000000000..6b280313966da33b7be4582568c3f08616629fe5 --- /dev/null +++ b/shared/package-files/30/302435b4d88542b974f8cbad33537f43a407604582bc343a71133f63b577743c/blob @@ -0,0 +1,301 @@ +# Test for approximation to k-components algorithm +import pytest + +import networkx as nx +from networkx.algorithms.approximation import k_components +from networkx.algorithms.approximation.kcomponents import _AntiGraph, _same + + +def build_k_number_dict(k_components): + k_num = {} + for k, comps in sorted(k_components.items()): + for comp in comps: + for node in comp: + k_num[node] = k + return k_num + + +## +# Some nice synthetic graphs +## + + +def graph_example_1(): + G = nx.convert_node_labels_to_integers( + nx.grid_graph([5, 5]), label_attribute="labels" + ) + rlabels = nx.get_node_attributes(G, "labels") + labels = {v: k for k, v in rlabels.items()} + + for nodes in [ + (labels[(0, 0)], labels[(1, 0)]), + (labels[(0, 4)], labels[(1, 4)]), + (labels[(3, 0)], labels[(4, 0)]), + (labels[(3, 4)], labels[(4, 4)]), + ]: + new_node = G.order() + 1 + # Petersen graph is triconnected + P = nx.petersen_graph() + G = nx.disjoint_union(G, P) + # Add two edges between the grid and P + G.add_edge(new_node + 1, nodes[0]) + G.add_edge(new_node, nodes[1]) + # K5 is 4-connected + K = nx.complete_graph(5) + G = nx.disjoint_union(G, K) + # Add three edges between P and K5 + G.add_edge(new_node + 2, new_node + 11) + G.add_edge(new_node + 3, new_node + 12) + G.add_edge(new_node + 4, new_node + 13) + # Add another K5 sharing a node + G = nx.disjoint_union(G, K) + nbrs = G[new_node + 10] + G.remove_node(new_node + 10) + for nbr in nbrs: + G.add_edge(new_node + 17, nbr) + G.add_edge(new_node + 16, new_node + 5) + return G + + +def torrents_and_ferraro_graph(): + G = nx.convert_node_labels_to_integers( + nx.grid_graph([5, 5]), label_attribute="labels" + ) + rlabels = nx.get_node_attributes(G, "labels") + labels = {v: k for k, v in rlabels.items()} + + for nodes in [(labels[(0, 4)], labels[(1, 4)]), (labels[(3, 4)], labels[(4, 4)])]: + new_node = G.order() + 1 + # Petersen graph is triconnected + P = nx.petersen_graph() + G = nx.disjoint_union(G, P) + # Add two edges between the grid and P + G.add_edge(new_node + 1, nodes[0]) + G.add_edge(new_node, nodes[1]) + # K5 is 4-connected + K = nx.complete_graph(5) + G = nx.disjoint_union(G, K) + # Add three edges between P and K5 + G.add_edge(new_node + 2, new_node + 11) + G.add_edge(new_node + 3, new_node + 12) + G.add_edge(new_node + 4, new_node + 13) + # Add another K5 sharing a node + G = nx.disjoint_union(G, K) + nbrs = G[new_node + 10] + G.remove_node(new_node + 10) + for nbr in nbrs: + G.add_edge(new_node + 17, nbr) + # Commenting this makes the graph not biconnected !! + # This stupid mistake make one reviewer very angry :P + G.add_edge(new_node + 16, new_node + 8) + + for nodes in [(labels[(0, 0)], labels[(1, 0)]), (labels[(3, 0)], labels[(4, 0)])]: + new_node = G.order() + 1 + # Petersen graph is triconnected + P = nx.petersen_graph() + G = nx.disjoint_union(G, P) + # Add two edges between the grid and P + G.add_edge(new_node + 1, nodes[0]) + G.add_edge(new_node, nodes[1]) + # K5 is 4-connected + K = nx.complete_graph(5) + G = nx.disjoint_union(G, K) + # Add three edges between P and K5 + G.add_edge(new_node + 2, new_node + 11) + G.add_edge(new_node + 3, new_node + 12) + G.add_edge(new_node + 4, new_node + 13) + # Add another K5 sharing two nodes + G = nx.disjoint_union(G, K) + nbrs = G[new_node + 10] + G.remove_node(new_node + 10) + for nbr in nbrs: + G.add_edge(new_node + 17, nbr) + nbrs2 = G[new_node + 9] + G.remove_node(new_node + 9) + for nbr in nbrs2: + G.add_edge(new_node + 18, nbr) + return G + + +# Helper function + + +def _check_connectivity(G): + result = k_components(G) + for k, components in result.items(): + if k < 3: + continue + for component in components: + C = G.subgraph(component) + K = nx.node_connectivity(C) + assert K >= k + + +def test_torrents_and_ferraro_graph(): + G = torrents_and_ferraro_graph() + _check_connectivity(G) + + +def test_example_1(): + G = graph_example_1() + _check_connectivity(G) + + +def test_karate_0(): + G = nx.karate_club_graph() + _check_connectivity(G) + + +def test_karate_1(): + karate_k_num = { + 0: 4, + 1: 4, + 2: 4, + 3: 4, + 4: 3, + 5: 3, + 6: 3, + 7: 4, + 8: 4, + 9: 2, + 10: 3, + 11: 1, + 12: 2, + 13: 4, + 14: 2, + 15: 2, + 16: 2, + 17: 2, + 18: 2, + 19: 3, + 20: 2, + 21: 2, + 22: 2, + 23: 3, + 24: 3, + 25: 3, + 26: 2, + 27: 3, + 28: 3, + 29: 3, + 30: 4, + 31: 3, + 32: 4, + 33: 4, + } + approx_karate_k_num = karate_k_num.copy() + approx_karate_k_num[24] = 2 + approx_karate_k_num[25] = 2 + G = nx.karate_club_graph() + k_comps = k_components(G) + k_num = build_k_number_dict(k_comps) + assert k_num in (karate_k_num, approx_karate_k_num) + + +def test_example_1_detail_3_and_4(): + G = graph_example_1() + result = k_components(G) + # In this example graph there are 8 3-components, 4 with 15 nodes + # and 4 with 5 nodes. + assert len(result[3]) == 8 + assert len([c for c in result[3] if len(c) == 15]) == 4 + assert len([c for c in result[3] if len(c) == 5]) == 4 + # There are also 8 4-components all with 5 nodes. + assert len(result[4]) == 8 + assert all(len(c) == 5 for c in result[4]) + # Finally check that the k-components detected have actually node + # connectivity >= k. + for k, components in result.items(): + if k < 3: + continue + for component in components: + K = nx.node_connectivity(G.subgraph(component)) + assert K >= k + + +def test_directed(): + with pytest.raises(nx.NetworkXNotImplemented): + G = nx.gnp_random_graph(10, 0.4, directed=True) + kc = k_components(G) + + +def test_same(): + equal = {"A": 2, "B": 2, "C": 2} + slightly_different = {"A": 2, "B": 1, "C": 2} + different = {"A": 2, "B": 8, "C": 18} + assert _same(equal) + assert not _same(slightly_different) + assert _same(slightly_different, tol=1) + assert not _same(different) + assert not _same(different, tol=4) + + +class TestAntiGraph: + @classmethod + def setup_class(cls): + cls.Gnp = nx.gnp_random_graph(20, 0.8) + cls.Anp = _AntiGraph(nx.complement(cls.Gnp)) + cls.Gd = nx.davis_southern_women_graph() + cls.Ad = _AntiGraph(nx.complement(cls.Gd)) + cls.Gk = nx.karate_club_graph() + cls.Ak = _AntiGraph(nx.complement(cls.Gk)) + cls.GA = [(cls.Gnp, cls.Anp), (cls.Gd, cls.Ad), (cls.Gk, cls.Ak)] + + def test_size(self): + for G, A in self.GA: + n = G.order() + s = len(list(G.edges())) + len(list(A.edges())) + assert s == (n * (n - 1)) / 2 + + def test_degree(self): + for G, A in self.GA: + assert sorted(G.degree()) == sorted(A.degree()) + + def test_core_number(self): + for G, A in self.GA: + assert nx.core_number(G) == nx.core_number(A) + + def test_connected_components(self): + for G, A in self.GA: + gc = [set(c) for c in nx.connected_components(G)] + ac = [set(c) for c in nx.connected_components(A)] + for comp in ac: + assert comp in gc + + def test_adj(self): + for G, A in self.GA: + for n, nbrs in G.adj.items(): + a_adj = sorted((n, sorted(ad)) for n, ad in A.adj.items()) + g_adj = sorted((n, sorted(ad)) for n, ad in G.adj.items()) + assert a_adj == g_adj + + def test_adjacency(self): + for G, A in self.GA: + a_adj = list(A.adjacency()) + for n, nbrs in G.adjacency(): + assert (n, set(nbrs)) in a_adj + + def test_neighbors(self): + for G, A in self.GA: + node = list(G.nodes())[0] + assert set(G.neighbors(node)) == set(A.neighbors(node)) + + def test_node_not_in_graph(self): + for G, A in self.GA: + node = "non_existent_node" + pytest.raises(nx.NetworkXError, A.neighbors, node) + pytest.raises(nx.NetworkXError, G.neighbors, node) + + def test_degree_thingraph(self): + for G, A in self.GA: + node = list(G.nodes())[0] + nodes = list(G.nodes())[1:4] + assert G.degree(node) == A.degree(node) + assert sum(d for n, d in G.degree()) == sum(d for n, d in A.degree()) + # AntiGraph is a ThinGraph, so all the weights are 1 + assert sum(d for n, d in A.degree()) == sum( + d for n, d in A.degree(weight="weight") + ) + assert sum(d for n, d in G.degree(nodes)) == sum( + d for n, d in A.degree(nodes) + ) diff --git a/shared/package-files/30/3024b38540fe6dc0acd4b979a4726a09d453804a6298282567795bf1bcf066ab/blob b/shared/package-files/30/3024b38540fe6dc0acd4b979a4726a09d453804a6298282567795bf1bcf066ab/blob new file mode 100644 index 0000000000000000000000000000000000000000..7553e21d61ceaa774d24c48d9d4bc2e3a8e3cc00 --- /dev/null +++ b/shared/package-files/30/3024b38540fe6dc0acd4b979a4726a09d453804a6298282567795bf1bcf066ab/blob @@ -0,0 +1,1701 @@ +import itertools + +import numpy as np +from numpy.testing import assert_, assert_allclose, assert_equal +from pytest import raises as assert_raises +from scipy import linalg +import scipy.linalg._decomp_update as _decomp_update +from scipy.linalg._decomp_update import qr_delete, qr_update, qr_insert + +def assert_unitary(a, rtol=None, atol=None, assert_sqr=True): + if rtol is None: + rtol = 10.0 ** -(np.finfo(a.dtype).precision-2) + if atol is None: + atol = 10*np.finfo(a.dtype).eps + + if assert_sqr: + assert_(a.shape[0] == a.shape[1], 'unitary matrices must be square') + aTa = np.dot(a.T.conj(), a) + assert_allclose(aTa, np.eye(a.shape[1]), rtol=rtol, atol=atol) + +def assert_upper_tri(a, rtol=None, atol=None): + if rtol is None: + rtol = 10.0 ** -(np.finfo(a.dtype).precision-2) + if atol is None: + atol = 2*np.finfo(a.dtype).eps + mask = np.tri(a.shape[0], a.shape[1], -1, np.bool_) + assert_allclose(a[mask], 0.0, rtol=rtol, atol=atol) + +def check_qr(q, r, a, rtol, atol, assert_sqr=True): + assert_unitary(q, rtol, atol, assert_sqr) + assert_upper_tri(r, rtol, atol) + assert_allclose(q.dot(r), a, rtol=rtol, atol=atol) + +def make_strided(arrs): + strides = [(3, 7), (2, 2), (3, 4), (4, 2), (5, 4), (2, 3), (2, 1), (4, 5)] + kmax = len(strides) + k = 0 + ret = [] + for a in arrs: + if a.ndim == 1: + s = strides[k % kmax] + k += 1 + base = np.zeros(s[0]*a.shape[0]+s[1], a.dtype) + view = base[s[1]::s[0]] + view[...] = a + elif a.ndim == 2: + s = strides[k % kmax] + t = strides[(k+1) % kmax] + k += 2 + base = np.zeros((s[0]*a.shape[0]+s[1], t[0]*a.shape[1]+t[1]), + a.dtype) + view = base[s[1]::s[0], t[1]::t[0]] + view[...] = a + else: + raise ValueError('make_strided only works for ndim = 1 or' + ' 2 arrays') + ret.append(view) + return ret + +def negate_strides(arrs): + ret = [] + for a in arrs: + b = np.zeros_like(a) + if b.ndim == 2: + b = b[::-1, ::-1] + elif b.ndim == 1: + b = b[::-1] + else: + raise ValueError('negate_strides only works for ndim = 1 or' + ' 2 arrays') + b[...] = a + ret.append(b) + return ret + +def nonitemsize_strides(arrs): + out = [] + for a in arrs: + a_dtype = a.dtype + b = np.zeros(a.shape, [('a', a_dtype), ('junk', 'S1')]) + c = b.getfield(a_dtype) + c[...] = a + out.append(c) + return out + + +def make_nonnative(arrs): + return [a.astype(a.dtype.newbyteorder()) for a in arrs] + + +class BaseQRdeltas: + def setup_method(self): + self.rtol = 10.0 ** -(np.finfo(self.dtype).precision-2) + self.atol = 10 * np.finfo(self.dtype).eps + + def generate(self, type, mode='full'): + np.random.seed(29382) + shape = {'sqr': (8, 8), 'tall': (12, 7), 'fat': (7, 12), + 'Mx1': (8, 1), '1xN': (1, 8), '1x1': (1, 1)}[type] + a = np.random.random(shape) + if np.iscomplexobj(self.dtype.type(1)): + b = np.random.random(shape) + a = a + 1j * b + a = a.astype(self.dtype) + q, r = linalg.qr(a, mode=mode) + return a, q, r + +class BaseQRdelete(BaseQRdeltas): + def test_sqr_1_row(self): + a, q, r = self.generate('sqr') + for row in range(r.shape[0]): + q1, r1 = qr_delete(q, r, row, overwrite_qr=False) + a1 = np.delete(a, row, 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_sqr_p_row(self): + a, q, r = self.generate('sqr') + for ndel in range(2, 6): + for row in range(a.shape[0]-ndel): + q1, r1 = qr_delete(q, r, row, ndel, overwrite_qr=False) + a1 = np.delete(a, slice(row, row+ndel), 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_sqr_1_col(self): + a, q, r = self.generate('sqr') + for col in range(r.shape[1]): + q1, r1 = qr_delete(q, r, col, which='col', overwrite_qr=False) + a1 = np.delete(a, col, 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_sqr_p_col(self): + a, q, r = self.generate('sqr') + for ndel in range(2, 6): + for col in range(r.shape[1]-ndel): + q1, r1 = qr_delete(q, r, col, ndel, which='col', + overwrite_qr=False) + a1 = np.delete(a, slice(col, col+ndel), 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_tall_1_row(self): + a, q, r = self.generate('tall') + for row in range(r.shape[0]): + q1, r1 = qr_delete(q, r, row, overwrite_qr=False) + a1 = np.delete(a, row, 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_tall_p_row(self): + a, q, r = self.generate('tall') + for ndel in range(2, 6): + for row in range(a.shape[0]-ndel): + q1, r1 = qr_delete(q, r, row, ndel, overwrite_qr=False) + a1 = np.delete(a, slice(row, row+ndel), 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_tall_1_col(self): + a, q, r = self.generate('tall') + for col in range(r.shape[1]): + q1, r1 = qr_delete(q, r, col, which='col', overwrite_qr=False) + a1 = np.delete(a, col, 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_tall_p_col(self): + a, q, r = self.generate('tall') + for ndel in range(2, 6): + for col in range(r.shape[1]-ndel): + q1, r1 = qr_delete(q, r, col, ndel, which='col', + overwrite_qr=False) + a1 = np.delete(a, slice(col, col+ndel), 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_fat_1_row(self): + a, q, r = self.generate('fat') + for row in range(r.shape[0]): + q1, r1 = qr_delete(q, r, row, overwrite_qr=False) + a1 = np.delete(a, row, 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_fat_p_row(self): + a, q, r = self.generate('fat') + for ndel in range(2, 6): + for row in range(a.shape[0]-ndel): + q1, r1 = qr_delete(q, r, row, ndel, overwrite_qr=False) + a1 = np.delete(a, slice(row, row+ndel), 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_fat_1_col(self): + a, q, r = self.generate('fat') + for col in range(r.shape[1]): + q1, r1 = qr_delete(q, r, col, which='col', overwrite_qr=False) + a1 = np.delete(a, col, 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_fat_p_col(self): + a, q, r = self.generate('fat') + for ndel in range(2, 6): + for col in range(r.shape[1]-ndel): + q1, r1 = qr_delete(q, r, col, ndel, which='col', + overwrite_qr=False) + a1 = np.delete(a, slice(col, col+ndel), 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_economic_1_row(self): + # this test always starts and ends with an economic decomp. + a, q, r = self.generate('tall', 'economic') + for row in range(r.shape[0]): + q1, r1 = qr_delete(q, r, row, overwrite_qr=False) + a1 = np.delete(a, row, 0) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + + # for economic row deletes + # eco - prow = eco + # eco - prow = sqr + # eco - prow = fat + def base_economic_p_row_xxx(self, ndel): + a, q, r = self.generate('tall', 'economic') + for row in range(a.shape[0]-ndel): + q1, r1 = qr_delete(q, r, row, ndel, overwrite_qr=False) + a1 = np.delete(a, slice(row, row+ndel), 0) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + + def test_economic_p_row_economic(self): + # (12, 7) - (3, 7) = (9,7) --> stays economic + self.base_economic_p_row_xxx(3) + + def test_economic_p_row_sqr(self): + # (12, 7) - (5, 7) = (7, 7) --> becomes square + self.base_economic_p_row_xxx(5) + + def test_economic_p_row_fat(self): + # (12, 7) - (7,7) = (5, 7) --> becomes fat + self.base_economic_p_row_xxx(7) + + def test_economic_1_col(self): + a, q, r = self.generate('tall', 'economic') + for col in range(r.shape[1]): + q1, r1 = qr_delete(q, r, col, which='col', overwrite_qr=False) + a1 = np.delete(a, col, 1) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + + def test_economic_p_col(self): + a, q, r = self.generate('tall', 'economic') + for ndel in range(2, 6): + for col in range(r.shape[1]-ndel): + q1, r1 = qr_delete(q, r, col, ndel, which='col', + overwrite_qr=False) + a1 = np.delete(a, slice(col, col+ndel), 1) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + + def test_Mx1_1_row(self): + a, q, r = self.generate('Mx1') + for row in range(r.shape[0]): + q1, r1 = qr_delete(q, r, row, overwrite_qr=False) + a1 = np.delete(a, row, 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_Mx1_p_row(self): + a, q, r = self.generate('Mx1') + for ndel in range(2, 6): + for row in range(a.shape[0]-ndel): + q1, r1 = qr_delete(q, r, row, ndel, overwrite_qr=False) + a1 = np.delete(a, slice(row, row+ndel), 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_1xN_1_col(self): + a, q, r = self.generate('1xN') + for col in range(r.shape[1]): + q1, r1 = qr_delete(q, r, col, which='col', overwrite_qr=False) + a1 = np.delete(a, col, 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_1xN_p_col(self): + a, q, r = self.generate('1xN') + for ndel in range(2, 6): + for col in range(r.shape[1]-ndel): + q1, r1 = qr_delete(q, r, col, ndel, which='col', + overwrite_qr=False) + a1 = np.delete(a, slice(col, col+ndel), 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_Mx1_economic_1_row(self): + a, q, r = self.generate('Mx1', 'economic') + for row in range(r.shape[0]): + q1, r1 = qr_delete(q, r, row, overwrite_qr=False) + a1 = np.delete(a, row, 0) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + + def test_Mx1_economic_p_row(self): + a, q, r = self.generate('Mx1', 'economic') + for ndel in range(2, 6): + for row in range(a.shape[0]-ndel): + q1, r1 = qr_delete(q, r, row, ndel, overwrite_qr=False) + a1 = np.delete(a, slice(row, row+ndel), 0) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + + def test_delete_last_1_row(self): + # full and eco are the same for 1xN + a, q, r = self.generate('1xN') + q1, r1 = qr_delete(q, r, 0, 1, 'row') + assert_equal(q1, np.ndarray(shape=(0, 0), dtype=q.dtype)) + assert_equal(r1, np.ndarray(shape=(0, r.shape[1]), dtype=r.dtype)) + + def test_delete_last_p_row(self): + a, q, r = self.generate('tall', 'full') + q1, r1 = qr_delete(q, r, 0, a.shape[0], 'row') + assert_equal(q1, np.ndarray(shape=(0, 0), dtype=q.dtype)) + assert_equal(r1, np.ndarray(shape=(0, r.shape[1]), dtype=r.dtype)) + + a, q, r = self.generate('tall', 'economic') + q1, r1 = qr_delete(q, r, 0, a.shape[0], 'row') + assert_equal(q1, np.ndarray(shape=(0, 0), dtype=q.dtype)) + assert_equal(r1, np.ndarray(shape=(0, r.shape[1]), dtype=r.dtype)) + + def test_delete_last_1_col(self): + a, q, r = self.generate('Mx1', 'economic') + q1, r1 = qr_delete(q, r, 0, 1, 'col') + assert_equal(q1, np.ndarray(shape=(q.shape[0], 0), dtype=q.dtype)) + assert_equal(r1, np.ndarray(shape=(0, 0), dtype=r.dtype)) + + a, q, r = self.generate('Mx1', 'full') + q1, r1 = qr_delete(q, r, 0, 1, 'col') + assert_unitary(q1) + assert_(q1.dtype == q.dtype) + assert_(q1.shape == q.shape) + assert_equal(r1, np.ndarray(shape=(r.shape[0], 0), dtype=r.dtype)) + + def test_delete_last_p_col(self): + a, q, r = self.generate('tall', 'full') + q1, r1 = qr_delete(q, r, 0, a.shape[1], 'col') + assert_unitary(q1) + assert_(q1.dtype == q.dtype) + assert_(q1.shape == q.shape) + assert_equal(r1, np.ndarray(shape=(r.shape[0], 0), dtype=r.dtype)) + + a, q, r = self.generate('tall', 'economic') + q1, r1 = qr_delete(q, r, 0, a.shape[1], 'col') + assert_equal(q1, np.ndarray(shape=(q.shape[0], 0), dtype=q.dtype)) + assert_equal(r1, np.ndarray(shape=(0, 0), dtype=r.dtype)) + + def test_delete_1x1_row_col(self): + a, q, r = self.generate('1x1') + q1, r1 = qr_delete(q, r, 0, 1, 'row') + assert_equal(q1, np.ndarray(shape=(0, 0), dtype=q.dtype)) + assert_equal(r1, np.ndarray(shape=(0, r.shape[1]), dtype=r.dtype)) + + a, q, r = self.generate('1x1') + q1, r1 = qr_delete(q, r, 0, 1, 'col') + assert_unitary(q1) + assert_(q1.dtype == q.dtype) + assert_(q1.shape == q.shape) + assert_equal(r1, np.ndarray(shape=(r.shape[0], 0), dtype=r.dtype)) + + # all full qr, row deletes and single column deletes should be able to + # handle any non negative strides. (only row and column vector + # operations are used.) p column delete require fortran ordered + # Q and R and will make a copy as necessary. Economic qr row deletes + # require a contiguous q. + + def base_non_simple_strides(self, adjust_strides, ks, p, which, + overwriteable): + if which == 'row': + qind = (slice(p,None), slice(p,None)) + rind = (slice(p,None), slice(None)) + else: + qind = (slice(None), slice(None)) + rind = (slice(None), slice(None,-p)) + + for type, k in itertools.product(['sqr', 'tall', 'fat'], ks): + a, q0, r0, = self.generate(type) + qs, rs = adjust_strides((q0, r0)) + if p == 1: + a1 = np.delete(a, k, 0 if which == 'row' else 1) + else: + s = slice(k,k+p) + if k < 0: + s = slice(k, k + p + + (a.shape[0] if which == 'row' else a.shape[1])) + a1 = np.delete(a, s, 0 if which == 'row' else 1) + + # for each variable, q, r we try with it strided and + # overwrite=False. Then we try with overwrite=True, and make + # sure that q and r are still overwritten. + + q = q0.copy('F') + r = r0.copy('F') + q1, r1 = qr_delete(qs, r, k, p, which, False) + check_qr(q1, r1, a1, self.rtol, self.atol) + q1o, r1o = qr_delete(qs, r, k, p, which, True) + check_qr(q1o, r1o, a1, self.rtol, self.atol) + if overwriteable: + assert_allclose(q1o, qs[qind], rtol=self.rtol, atol=self.atol) + assert_allclose(r1o, r[rind], rtol=self.rtol, atol=self.atol) + + q = q0.copy('F') + r = r0.copy('F') + q2, r2 = qr_delete(q, rs, k, p, which, False) + check_qr(q2, r2, a1, self.rtol, self.atol) + q2o, r2o = qr_delete(q, rs, k, p, which, True) + check_qr(q2o, r2o, a1, self.rtol, self.atol) + if overwriteable: + assert_allclose(q2o, q[qind], rtol=self.rtol, atol=self.atol) + assert_allclose(r2o, rs[rind], rtol=self.rtol, atol=self.atol) + + q = q0.copy('F') + r = r0.copy('F') + # since some of these were consumed above + qs, rs = adjust_strides((q, r)) + q3, r3 = qr_delete(qs, rs, k, p, which, False) + check_qr(q3, r3, a1, self.rtol, self.atol) + q3o, r3o = qr_delete(qs, rs, k, p, which, True) + check_qr(q3o, r3o, a1, self.rtol, self.atol) + if overwriteable: + assert_allclose(q2o, qs[qind], rtol=self.rtol, atol=self.atol) + assert_allclose(r3o, rs[rind], rtol=self.rtol, atol=self.atol) + + def test_non_unit_strides_1_row(self): + self.base_non_simple_strides(make_strided, [0], 1, 'row', True) + + def test_non_unit_strides_p_row(self): + self.base_non_simple_strides(make_strided, [0], 3, 'row', True) + + def test_non_unit_strides_1_col(self): + self.base_non_simple_strides(make_strided, [0], 1, 'col', True) + + def test_non_unit_strides_p_col(self): + self.base_non_simple_strides(make_strided, [0], 3, 'col', False) + + def test_neg_strides_1_row(self): + self.base_non_simple_strides(negate_strides, [0], 1, 'row', False) + + def test_neg_strides_p_row(self): + self.base_non_simple_strides(negate_strides, [0], 3, 'row', False) + + def test_neg_strides_1_col(self): + self.base_non_simple_strides(negate_strides, [0], 1, 'col', False) + + def test_neg_strides_p_col(self): + self.base_non_simple_strides(negate_strides, [0], 3, 'col', False) + + def test_non_itemize_strides_1_row(self): + self.base_non_simple_strides(nonitemsize_strides, [0], 1, 'row', False) + + def test_non_itemize_strides_p_row(self): + self.base_non_simple_strides(nonitemsize_strides, [0], 3, 'row', False) + + def test_non_itemize_strides_1_col(self): + self.base_non_simple_strides(nonitemsize_strides, [0], 1, 'col', False) + + def test_non_itemize_strides_p_col(self): + self.base_non_simple_strides(nonitemsize_strides, [0], 3, 'col', False) + + def test_non_native_byte_order_1_row(self): + self.base_non_simple_strides(make_nonnative, [0], 1, 'row', False) + + def test_non_native_byte_order_p_row(self): + self.base_non_simple_strides(make_nonnative, [0], 3, 'row', False) + + def test_non_native_byte_order_1_col(self): + self.base_non_simple_strides(make_nonnative, [0], 1, 'col', False) + + def test_non_native_byte_order_p_col(self): + self.base_non_simple_strides(make_nonnative, [0], 3, 'col', False) + + def test_neg_k(self): + a, q, r = self.generate('sqr') + for k, p, w in itertools.product([-3, -7], [1, 3], ['row', 'col']): + q1, r1 = qr_delete(q, r, k, p, w, overwrite_qr=False) + if w == 'row': + a1 = np.delete(a, slice(k+a.shape[0], k+p+a.shape[0]), 0) + else: + a1 = np.delete(a, slice(k+a.shape[0], k+p+a.shape[1]), 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def base_overwrite_qr(self, which, p, test_C, test_F, mode='full'): + assert_sqr = True if mode == 'full' else False + if which == 'row': + qind = (slice(p,None), slice(p,None)) + rind = (slice(p,None), slice(None)) + else: + qind = (slice(None), slice(None)) + rind = (slice(None), slice(None,-p)) + a, q0, r0 = self.generate('sqr', mode) + if p == 1: + a1 = np.delete(a, 3, 0 if which == 'row' else 1) + else: + a1 = np.delete(a, slice(3, 3+p), 0 if which == 'row' else 1) + + # don't overwrite + q = q0.copy('F') + r = r0.copy('F') + q1, r1 = qr_delete(q, r, 3, p, which, False) + check_qr(q1, r1, a1, self.rtol, self.atol, assert_sqr) + check_qr(q, r, a, self.rtol, self.atol, assert_sqr) + + if test_F: + q = q0.copy('F') + r = r0.copy('F') + q2, r2 = qr_delete(q, r, 3, p, which, True) + check_qr(q2, r2, a1, self.rtol, self.atol, assert_sqr) + # verify the overwriting + assert_allclose(q2, q[qind], rtol=self.rtol, atol=self.atol) + assert_allclose(r2, r[rind], rtol=self.rtol, atol=self.atol) + + if test_C: + q = q0.copy('C') + r = r0.copy('C') + q3, r3 = qr_delete(q, r, 3, p, which, True) + check_qr(q3, r3, a1, self.rtol, self.atol, assert_sqr) + assert_allclose(q3, q[qind], rtol=self.rtol, atol=self.atol) + assert_allclose(r3, r[rind], rtol=self.rtol, atol=self.atol) + + def test_overwrite_qr_1_row(self): + # any positively strided q and r. + self.base_overwrite_qr('row', 1, True, True) + + def test_overwrite_economic_qr_1_row(self): + # Any contiguous q and positively strided r. + self.base_overwrite_qr('row', 1, True, True, 'economic') + + def test_overwrite_qr_1_col(self): + # any positively strided q and r. + # full and eco share code paths + self.base_overwrite_qr('col', 1, True, True) + + def test_overwrite_qr_p_row(self): + # any positively strided q and r. + self.base_overwrite_qr('row', 3, True, True) + + def test_overwrite_economic_qr_p_row(self): + # any contiguous q and positively strided r + self.base_overwrite_qr('row', 3, True, True, 'economic') + + def test_overwrite_qr_p_col(self): + # only F ordered q and r can be overwritten for cols + # full and eco share code paths + self.base_overwrite_qr('col', 3, False, True) + + def test_bad_which(self): + a, q, r = self.generate('sqr') + assert_raises(ValueError, qr_delete, q, r, 0, which='foo') + + def test_bad_k(self): + a, q, r = self.generate('tall') + assert_raises(ValueError, qr_delete, q, r, q.shape[0], 1) + assert_raises(ValueError, qr_delete, q, r, -q.shape[0]-1, 1) + assert_raises(ValueError, qr_delete, q, r, r.shape[0], 1, 'col') + assert_raises(ValueError, qr_delete, q, r, -r.shape[0]-1, 1, 'col') + + def test_bad_p(self): + a, q, r = self.generate('tall') + # p must be positive + assert_raises(ValueError, qr_delete, q, r, 0, -1) + assert_raises(ValueError, qr_delete, q, r, 0, -1, 'col') + + # and nonzero + assert_raises(ValueError, qr_delete, q, r, 0, 0) + assert_raises(ValueError, qr_delete, q, r, 0, 0, 'col') + + # must have at least k+p rows or cols, depending. + assert_raises(ValueError, qr_delete, q, r, 3, q.shape[0]-2) + assert_raises(ValueError, qr_delete, q, r, 3, r.shape[1]-2, 'col') + + def test_empty_q(self): + a, q, r = self.generate('tall') + # same code path for 'row' and 'col' + assert_raises(ValueError, qr_delete, np.array([]), r, 0, 1) + + def test_empty_r(self): + a, q, r = self.generate('tall') + # same code path for 'row' and 'col' + assert_raises(ValueError, qr_delete, q, np.array([]), 0, 1) + + def test_mismatched_q_and_r(self): + a, q, r = self.generate('tall') + r = r[1:] + assert_raises(ValueError, qr_delete, q, r, 0, 1) + + def test_unsupported_dtypes(self): + dts = ['int8', 'int16', 'int32', 'int64', + 'uint8', 'uint16', 'uint32', 'uint64', + 'float16', 'longdouble', 'clongdouble', + 'bool'] + a, q0, r0 = self.generate('tall') + for dtype in dts: + q = q0.real.astype(dtype) + with np.errstate(invalid="ignore"): + r = r0.real.astype(dtype) + assert_raises(ValueError, qr_delete, q, r0, 0, 1, 'row') + assert_raises(ValueError, qr_delete, q, r0, 0, 2, 'row') + assert_raises(ValueError, qr_delete, q, r0, 0, 1, 'col') + assert_raises(ValueError, qr_delete, q, r0, 0, 2, 'col') + + assert_raises(ValueError, qr_delete, q0, r, 0, 1, 'row') + assert_raises(ValueError, qr_delete, q0, r, 0, 2, 'row') + assert_raises(ValueError, qr_delete, q0, r, 0, 1, 'col') + assert_raises(ValueError, qr_delete, q0, r, 0, 2, 'col') + + def test_check_finite(self): + a0, q0, r0 = self.generate('tall') + + q = q0.copy('F') + q[1,1] = np.nan + assert_raises(ValueError, qr_delete, q, r0, 0, 1, 'row') + assert_raises(ValueError, qr_delete, q, r0, 0, 3, 'row') + assert_raises(ValueError, qr_delete, q, r0, 0, 1, 'col') + assert_raises(ValueError, qr_delete, q, r0, 0, 3, 'col') + + r = r0.copy('F') + r[1,1] = np.nan + assert_raises(ValueError, qr_delete, q0, r, 0, 1, 'row') + assert_raises(ValueError, qr_delete, q0, r, 0, 3, 'row') + assert_raises(ValueError, qr_delete, q0, r, 0, 1, 'col') + assert_raises(ValueError, qr_delete, q0, r, 0, 3, 'col') + + def test_qr_scalar(self): + a, q, r = self.generate('1x1') + assert_raises(ValueError, qr_delete, q[0, 0], r, 0, 1, 'row') + assert_raises(ValueError, qr_delete, q, r[0, 0], 0, 1, 'row') + assert_raises(ValueError, qr_delete, q[0, 0], r, 0, 1, 'col') + assert_raises(ValueError, qr_delete, q, r[0, 0], 0, 1, 'col') + +class TestQRdelete_f(BaseQRdelete): + dtype = np.dtype('f') + +class TestQRdelete_F(BaseQRdelete): + dtype = np.dtype('F') + +class TestQRdelete_d(BaseQRdelete): + dtype = np.dtype('d') + +class TestQRdelete_D(BaseQRdelete): + dtype = np.dtype('D') + +class BaseQRinsert(BaseQRdeltas): + def generate(self, type, mode='full', which='row', p=1): + a, q, r = super().generate(type, mode) + + assert_(p > 0) + rng = np.random.RandomState(1234) + + # super call set the seed... + if which == 'row': + if p == 1: + u = rng.random(a.shape[1]) + else: + u = rng.random((p, a.shape[1])) + elif which == 'col': + if p == 1: + u = rng.random(a.shape[0]) + else: + u = rng.random((a.shape[0], p)) + else: + ValueError('which should be either "row" or "col"') + + if np.iscomplexobj(self.dtype.type(1)): + b = rng.random(u.shape) + u = u + 1j * b + + u = u.astype(self.dtype) + return a, q, r, u + + def test_sqr_1_row(self): + a, q, r, u = self.generate('sqr', which='row') + for row in range(r.shape[0] + 1): + q1, r1 = qr_insert(q, r, u, row) + a1 = np.insert(a, row, u, 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_sqr_p_row(self): + # sqr + rows --> fat always + a, q, r, u = self.generate('sqr', which='row', p=3) + for row in range(r.shape[0] + 1): + q1, r1 = qr_insert(q, r, u, row) + a1 = np.insert(a, np.full(3, row, np.intp), u, 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_sqr_1_col(self): + a, q, r, u = self.generate('sqr', which='col') + for col in range(r.shape[1] + 1): + q1, r1 = qr_insert(q, r, u, col, 'col', overwrite_qru=False) + a1 = np.insert(a, col, u, 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_sqr_p_col(self): + # sqr + cols --> fat always + a, q, r, u = self.generate('sqr', which='col', p=3) + for col in range(r.shape[1] + 1): + q1, r1 = qr_insert(q, r, u, col, 'col', overwrite_qru=False) + a1 = np.insert(a, np.full(3, col, np.intp), u, 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_tall_1_row(self): + a, q, r, u = self.generate('tall', which='row') + for row in range(r.shape[0] + 1): + q1, r1 = qr_insert(q, r, u, row) + a1 = np.insert(a, row, u, 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_tall_p_row(self): + # tall + rows --> tall always + a, q, r, u = self.generate('tall', which='row', p=3) + for row in range(r.shape[0] + 1): + q1, r1 = qr_insert(q, r, u, row) + a1 = np.insert(a, np.full(3, row, np.intp), u, 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_tall_1_col(self): + a, q, r, u = self.generate('tall', which='col') + for col in range(r.shape[1] + 1): + q1, r1 = qr_insert(q, r, u, col, 'col', overwrite_qru=False) + a1 = np.insert(a, col, u, 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + # for column adds to tall matrices there are three cases to test + # tall + pcol --> tall + # tall + pcol --> sqr + # tall + pcol --> fat + def base_tall_p_col_xxx(self, p): + a, q, r, u = self.generate('tall', which='col', p=p) + for col in range(r.shape[1] + 1): + q1, r1 = qr_insert(q, r, u, col, 'col', overwrite_qru=False) + a1 = np.insert(a, np.full(p, col, np.intp), u, 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_tall_p_col_tall(self): + # 12x7 + 12x3 = 12x10 --> stays tall + self.base_tall_p_col_xxx(3) + + def test_tall_p_col_sqr(self): + # 12x7 + 12x5 = 12x12 --> becomes sqr + self.base_tall_p_col_xxx(5) + + def test_tall_p_col_fat(self): + # 12x7 + 12x7 = 12x14 --> becomes fat + self.base_tall_p_col_xxx(7) + + def test_fat_1_row(self): + a, q, r, u = self.generate('fat', which='row') + for row in range(r.shape[0] + 1): + q1, r1 = qr_insert(q, r, u, row) + a1 = np.insert(a, row, u, 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + # for row adds to fat matrices there are three cases to test + # fat + prow --> fat + # fat + prow --> sqr + # fat + prow --> tall + def base_fat_p_row_xxx(self, p): + a, q, r, u = self.generate('fat', which='row', p=p) + for row in range(r.shape[0] + 1): + q1, r1 = qr_insert(q, r, u, row) + a1 = np.insert(a, np.full(p, row, np.intp), u, 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_fat_p_row_fat(self): + # 7x12 + 3x12 = 10x12 --> stays fat + self.base_fat_p_row_xxx(3) + + def test_fat_p_row_sqr(self): + # 7x12 + 5x12 = 12x12 --> becomes sqr + self.base_fat_p_row_xxx(5) + + def test_fat_p_row_tall(self): + # 7x12 + 7x12 = 14x12 --> becomes tall + self.base_fat_p_row_xxx(7) + + def test_fat_1_col(self): + a, q, r, u = self.generate('fat', which='col') + for col in range(r.shape[1] + 1): + q1, r1 = qr_insert(q, r, u, col, 'col', overwrite_qru=False) + a1 = np.insert(a, col, u, 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_fat_p_col(self): + # fat + cols --> fat always + a, q, r, u = self.generate('fat', which='col', p=3) + for col in range(r.shape[1] + 1): + q1, r1 = qr_insert(q, r, u, col, 'col', overwrite_qru=False) + a1 = np.insert(a, np.full(3, col, np.intp), u, 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_economic_1_row(self): + a, q, r, u = self.generate('tall', 'economic', 'row') + for row in range(r.shape[0] + 1): + q1, r1 = qr_insert(q, r, u, row, overwrite_qru=False) + a1 = np.insert(a, row, u, 0) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + + def test_economic_p_row(self): + # tall + rows --> tall always + a, q, r, u = self.generate('tall', 'economic', 'row', 3) + for row in range(r.shape[0] + 1): + q1, r1 = qr_insert(q, r, u, row, overwrite_qru=False) + a1 = np.insert(a, np.full(3, row, np.intp), u, 0) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + + def test_economic_1_col(self): + a, q, r, u = self.generate('tall', 'economic', which='col') + for col in range(r.shape[1] + 1): + q1, r1 = qr_insert(q, r, u.copy(), col, 'col', overwrite_qru=False) + a1 = np.insert(a, col, u, 1) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + + def test_economic_1_col_bad_update(self): + # When the column to be added lies in the span of Q, the update is + # not meaningful. This is detected, and a LinAlgError is issued. + q = np.eye(5, 3, dtype=self.dtype) + r = np.eye(3, dtype=self.dtype) + u = np.array([1, 0, 0, 0, 0], self.dtype) + assert_raises(linalg.LinAlgError, qr_insert, q, r, u, 0, 'col') + + # for column adds to economic matrices there are three cases to test + # eco + pcol --> eco + # eco + pcol --> sqr + # eco + pcol --> fat + def base_economic_p_col_xxx(self, p): + a, q, r, u = self.generate('tall', 'economic', which='col', p=p) + for col in range(r.shape[1] + 1): + q1, r1 = qr_insert(q, r, u, col, 'col', overwrite_qru=False) + a1 = np.insert(a, np.full(p, col, np.intp), u, 1) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + + def test_economic_p_col_eco(self): + # 12x7 + 12x3 = 12x10 --> stays eco + self.base_economic_p_col_xxx(3) + + def test_economic_p_col_sqr(self): + # 12x7 + 12x5 = 12x12 --> becomes sqr + self.base_economic_p_col_xxx(5) + + def test_economic_p_col_fat(self): + # 12x7 + 12x7 = 12x14 --> becomes fat + self.base_economic_p_col_xxx(7) + + def test_Mx1_1_row(self): + a, q, r, u = self.generate('Mx1', which='row') + for row in range(r.shape[0] + 1): + q1, r1 = qr_insert(q, r, u, row) + a1 = np.insert(a, row, u, 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_Mx1_p_row(self): + a, q, r, u = self.generate('Mx1', which='row', p=3) + for row in range(r.shape[0] + 1): + q1, r1 = qr_insert(q, r, u, row) + a1 = np.insert(a, np.full(3, row, np.intp), u, 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_Mx1_1_col(self): + a, q, r, u = self.generate('Mx1', which='col') + for col in range(r.shape[1] + 1): + q1, r1 = qr_insert(q, r, u, col, 'col', overwrite_qru=False) + a1 = np.insert(a, col, u, 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_Mx1_p_col(self): + a, q, r, u = self.generate('Mx1', which='col', p=3) + for col in range(r.shape[1] + 1): + q1, r1 = qr_insert(q, r, u, col, 'col', overwrite_qru=False) + a1 = np.insert(a, np.full(3, col, np.intp), u, 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_Mx1_economic_1_row(self): + a, q, r, u = self.generate('Mx1', 'economic', 'row') + for row in range(r.shape[0] + 1): + q1, r1 = qr_insert(q, r, u, row) + a1 = np.insert(a, row, u, 0) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + + def test_Mx1_economic_p_row(self): + a, q, r, u = self.generate('Mx1', 'economic', 'row', 3) + for row in range(r.shape[0] + 1): + q1, r1 = qr_insert(q, r, u, row) + a1 = np.insert(a, np.full(3, row, np.intp), u, 0) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + + def test_Mx1_economic_1_col(self): + a, q, r, u = self.generate('Mx1', 'economic', 'col') + for col in range(r.shape[1] + 1): + q1, r1 = qr_insert(q, r, u, col, 'col', overwrite_qru=False) + a1 = np.insert(a, col, u, 1) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + + def test_Mx1_economic_p_col(self): + a, q, r, u = self.generate('Mx1', 'economic', 'col', 3) + for col in range(r.shape[1] + 1): + q1, r1 = qr_insert(q, r, u, col, 'col', overwrite_qru=False) + a1 = np.insert(a, np.full(3, col, np.intp), u, 1) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + + def test_1xN_1_row(self): + a, q, r, u = self.generate('1xN', which='row') + for row in range(r.shape[0] + 1): + q1, r1 = qr_insert(q, r, u, row) + a1 = np.insert(a, row, u, 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_1xN_p_row(self): + a, q, r, u = self.generate('1xN', which='row', p=3) + for row in range(r.shape[0] + 1): + q1, r1 = qr_insert(q, r, u, row) + a1 = np.insert(a, np.full(3, row, np.intp), u, 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_1xN_1_col(self): + a, q, r, u = self.generate('1xN', which='col') + for col in range(r.shape[1] + 1): + q1, r1 = qr_insert(q, r, u, col, 'col', overwrite_qru=False) + a1 = np.insert(a, col, u, 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_1xN_p_col(self): + a, q, r, u = self.generate('1xN', which='col', p=3) + for col in range(r.shape[1] + 1): + q1, r1 = qr_insert(q, r, u, col, 'col', overwrite_qru=False) + a1 = np.insert(a, np.full(3, col, np.intp), u, 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_1x1_1_row(self): + a, q, r, u = self.generate('1x1', which='row') + for row in range(r.shape[0] + 1): + q1, r1 = qr_insert(q, r, u, row) + a1 = np.insert(a, row, u, 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_1x1_p_row(self): + a, q, r, u = self.generate('1x1', which='row', p=3) + for row in range(r.shape[0] + 1): + q1, r1 = qr_insert(q, r, u, row) + a1 = np.insert(a, np.full(3, row, np.intp), u, 0) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_1x1_1_col(self): + a, q, r, u = self.generate('1x1', which='col') + for col in range(r.shape[1] + 1): + q1, r1 = qr_insert(q, r, u, col, 'col', overwrite_qru=False) + a1 = np.insert(a, col, u, 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_1x1_p_col(self): + a, q, r, u = self.generate('1x1', which='col', p=3) + for col in range(r.shape[1] + 1): + q1, r1 = qr_insert(q, r, u, col, 'col', overwrite_qru=False) + a1 = np.insert(a, np.full(3, col, np.intp), u, 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_1x1_1_scalar(self): + a, q, r, u = self.generate('1x1', which='row') + assert_raises(ValueError, qr_insert, q[0, 0], r, u, 0, 'row') + assert_raises(ValueError, qr_insert, q, r[0, 0], u, 0, 'row') + assert_raises(ValueError, qr_insert, q, r, u[0], 0, 'row') + + assert_raises(ValueError, qr_insert, q[0, 0], r, u, 0, 'col') + assert_raises(ValueError, qr_insert, q, r[0, 0], u, 0, 'col') + assert_raises(ValueError, qr_insert, q, r, u[0], 0, 'col') + + def base_non_simple_strides(self, adjust_strides, k, p, which): + for type in ['sqr', 'tall', 'fat']: + a, q0, r0, u0 = self.generate(type, which=which, p=p) + qs, rs, us = adjust_strides((q0, r0, u0)) + if p == 1: + ai = np.insert(a, k, u0, 0 if which == 'row' else 1) + else: + ai = np.insert(a, np.full(p, k, np.intp), + u0 if which == 'row' else u0, + 0 if which == 'row' else 1) + + # for each variable, q, r, u we try with it strided and + # overwrite=False. Then we try with overwrite=True. Nothing + # is checked to see if it can be overwritten, since only + # F ordered Q can be overwritten when adding columns. + + q = q0.copy('F') + r = r0.copy('F') + u = u0.copy('F') + q1, r1 = qr_insert(qs, r, u, k, which, overwrite_qru=False) + check_qr(q1, r1, ai, self.rtol, self.atol) + q1o, r1o = qr_insert(qs, r, u, k, which, overwrite_qru=True) + check_qr(q1o, r1o, ai, self.rtol, self.atol) + + q = q0.copy('F') + r = r0.copy('F') + u = u0.copy('F') + q2, r2 = qr_insert(q, rs, u, k, which, overwrite_qru=False) + check_qr(q2, r2, ai, self.rtol, self.atol) + q2o, r2o = qr_insert(q, rs, u, k, which, overwrite_qru=True) + check_qr(q2o, r2o, ai, self.rtol, self.atol) + + q = q0.copy('F') + r = r0.copy('F') + u = u0.copy('F') + q3, r3 = qr_insert(q, r, us, k, which, overwrite_qru=False) + check_qr(q3, r3, ai, self.rtol, self.atol) + q3o, r3o = qr_insert(q, r, us, k, which, overwrite_qru=True) + check_qr(q3o, r3o, ai, self.rtol, self.atol) + + q = q0.copy('F') + r = r0.copy('F') + u = u0.copy('F') + # since some of these were consumed above + qs, rs, us = adjust_strides((q, r, u)) + q5, r5 = qr_insert(qs, rs, us, k, which, overwrite_qru=False) + check_qr(q5, r5, ai, self.rtol, self.atol) + q5o, r5o = qr_insert(qs, rs, us, k, which, overwrite_qru=True) + check_qr(q5o, r5o, ai, self.rtol, self.atol) + + def test_non_unit_strides_1_row(self): + self.base_non_simple_strides(make_strided, 0, 1, 'row') + + def test_non_unit_strides_p_row(self): + self.base_non_simple_strides(make_strided, 0, 3, 'row') + + def test_non_unit_strides_1_col(self): + self.base_non_simple_strides(make_strided, 0, 1, 'col') + + def test_non_unit_strides_p_col(self): + self.base_non_simple_strides(make_strided, 0, 3, 'col') + + def test_neg_strides_1_row(self): + self.base_non_simple_strides(negate_strides, 0, 1, 'row') + + def test_neg_strides_p_row(self): + self.base_non_simple_strides(negate_strides, 0, 3, 'row') + + def test_neg_strides_1_col(self): + self.base_non_simple_strides(negate_strides, 0, 1, 'col') + + def test_neg_strides_p_col(self): + self.base_non_simple_strides(negate_strides, 0, 3, 'col') + + def test_non_itemsize_strides_1_row(self): + self.base_non_simple_strides(nonitemsize_strides, 0, 1, 'row') + + def test_non_itemsize_strides_p_row(self): + self.base_non_simple_strides(nonitemsize_strides, 0, 3, 'row') + + def test_non_itemsize_strides_1_col(self): + self.base_non_simple_strides(nonitemsize_strides, 0, 1, 'col') + + def test_non_itemsize_strides_p_col(self): + self.base_non_simple_strides(nonitemsize_strides, 0, 3, 'col') + + def test_non_native_byte_order_1_row(self): + self.base_non_simple_strides(make_nonnative, 0, 1, 'row') + + def test_non_native_byte_order_p_row(self): + self.base_non_simple_strides(make_nonnative, 0, 3, 'row') + + def test_non_native_byte_order_1_col(self): + self.base_non_simple_strides(make_nonnative, 0, 1, 'col') + + def test_non_native_byte_order_p_col(self): + self.base_non_simple_strides(make_nonnative, 0, 3, 'col') + + def test_overwrite_qu_rank_1(self): + # when inserting rows, the size of both Q and R change, so only + # column inserts can overwrite q. Only complex column inserts + # with C ordered Q overwrite u. Any contiguous Q is overwritten + # when inserting 1 column + a, q0, r, u, = self.generate('sqr', which='col', p=1) + q = q0.copy('C') + u0 = u.copy() + # don't overwrite + q1, r1 = qr_insert(q, r, u, 0, 'col', overwrite_qru=False) + a1 = np.insert(a, 0, u0, 1) + check_qr(q1, r1, a1, self.rtol, self.atol) + check_qr(q, r, a, self.rtol, self.atol) + + # try overwriting + q2, r2 = qr_insert(q, r, u, 0, 'col', overwrite_qru=True) + check_qr(q2, r2, a1, self.rtol, self.atol) + # verify the overwriting + assert_allclose(q2, q, rtol=self.rtol, atol=self.atol) + assert_allclose(u, u0.conj(), self.rtol, self.atol) + + # now try with a fortran ordered Q + qF = q0.copy('F') + u1 = u0.copy() + q3, r3 = qr_insert(qF, r, u1, 0, 'col', overwrite_qru=False) + check_qr(q3, r3, a1, self.rtol, self.atol) + check_qr(qF, r, a, self.rtol, self.atol) + + # try overwriting + q4, r4 = qr_insert(qF, r, u1, 0, 'col', overwrite_qru=True) + check_qr(q4, r4, a1, self.rtol, self.atol) + assert_allclose(q4, qF, rtol=self.rtol, atol=self.atol) + + def test_overwrite_qu_rank_p(self): + # when inserting rows, the size of both Q and R change, so only + # column inserts can potentially overwrite Q. In practice, only + # F ordered Q are overwritten with a rank p update. + a, q0, r, u, = self.generate('sqr', which='col', p=3) + q = q0.copy('F') + a1 = np.insert(a, np.zeros(3, np.intp), u, 1) + + # don't overwrite + q1, r1 = qr_insert(q, r, u, 0, 'col', overwrite_qru=False) + check_qr(q1, r1, a1, self.rtol, self.atol) + check_qr(q, r, a, self.rtol, self.atol) + + # try overwriting + q2, r2 = qr_insert(q, r, u, 0, 'col', overwrite_qru=True) + check_qr(q2, r2, a1, self.rtol, self.atol) + assert_allclose(q2, q, rtol=self.rtol, atol=self.atol) + + def test_empty_inputs(self): + a, q, r, u = self.generate('sqr', which='row') + assert_raises(ValueError, qr_insert, np.array([]), r, u, 0, 'row') + assert_raises(ValueError, qr_insert, q, np.array([]), u, 0, 'row') + assert_raises(ValueError, qr_insert, q, r, np.array([]), 0, 'row') + assert_raises(ValueError, qr_insert, np.array([]), r, u, 0, 'col') + assert_raises(ValueError, qr_insert, q, np.array([]), u, 0, 'col') + assert_raises(ValueError, qr_insert, q, r, np.array([]), 0, 'col') + + def test_mismatched_shapes(self): + a, q, r, u = self.generate('tall', which='row') + assert_raises(ValueError, qr_insert, q, r[1:], u, 0, 'row') + assert_raises(ValueError, qr_insert, q[:-2], r, u, 0, 'row') + assert_raises(ValueError, qr_insert, q, r, u[1:], 0, 'row') + assert_raises(ValueError, qr_insert, q, r[1:], u, 0, 'col') + assert_raises(ValueError, qr_insert, q[:-2], r, u, 0, 'col') + assert_raises(ValueError, qr_insert, q, r, u[1:], 0, 'col') + + def test_unsupported_dtypes(self): + dts = ['int8', 'int16', 'int32', 'int64', + 'uint8', 'uint16', 'uint32', 'uint64', + 'float16', 'longdouble', 'clongdouble', + 'bool'] + a, q0, r0, u0 = self.generate('sqr', which='row') + for dtype in dts: + q = q0.real.astype(dtype) + with np.errstate(invalid="ignore"): + r = r0.real.astype(dtype) + u = u0.real.astype(dtype) + assert_raises(ValueError, qr_insert, q, r0, u0, 0, 'row') + assert_raises(ValueError, qr_insert, q, r0, u0, 0, 'col') + assert_raises(ValueError, qr_insert, q0, r, u0, 0, 'row') + assert_raises(ValueError, qr_insert, q0, r, u0, 0, 'col') + assert_raises(ValueError, qr_insert, q0, r0, u, 0, 'row') + assert_raises(ValueError, qr_insert, q0, r0, u, 0, 'col') + + def test_check_finite(self): + a0, q0, r0, u0 = self.generate('sqr', which='row', p=3) + + q = q0.copy('F') + q[1,1] = np.nan + assert_raises(ValueError, qr_insert, q, r0, u0[:,0], 0, 'row') + assert_raises(ValueError, qr_insert, q, r0, u0, 0, 'row') + assert_raises(ValueError, qr_insert, q, r0, u0[:,0], 0, 'col') + assert_raises(ValueError, qr_insert, q, r0, u0, 0, 'col') + + r = r0.copy('F') + r[1,1] = np.nan + assert_raises(ValueError, qr_insert, q0, r, u0[:,0], 0, 'row') + assert_raises(ValueError, qr_insert, q0, r, u0, 0, 'row') + assert_raises(ValueError, qr_insert, q0, r, u0[:,0], 0, 'col') + assert_raises(ValueError, qr_insert, q0, r, u0, 0, 'col') + + u = u0.copy('F') + u[0,0] = np.nan + assert_raises(ValueError, qr_insert, q0, r0, u[:,0], 0, 'row') + assert_raises(ValueError, qr_insert, q0, r0, u, 0, 'row') + assert_raises(ValueError, qr_insert, q0, r0, u[:,0], 0, 'col') + assert_raises(ValueError, qr_insert, q0, r0, u, 0, 'col') + +class TestQRinsert_f(BaseQRinsert): + dtype = np.dtype('f') + +class TestQRinsert_F(BaseQRinsert): + dtype = np.dtype('F') + +class TestQRinsert_d(BaseQRinsert): + dtype = np.dtype('d') + +class TestQRinsert_D(BaseQRinsert): + dtype = np.dtype('D') + +class BaseQRupdate(BaseQRdeltas): + def generate(self, type, mode='full', p=1): + a, q, r = super().generate(type, mode) + + # super call set the seed... + if p == 1: + u = np.random.random(q.shape[0]) + v = np.random.random(r.shape[1]) + else: + u = np.random.random((q.shape[0], p)) + v = np.random.random((r.shape[1], p)) + + if np.iscomplexobj(self.dtype.type(1)): + b = np.random.random(u.shape) + u = u + 1j * b + + c = np.random.random(v.shape) + v = v + 1j * c + + u = u.astype(self.dtype) + v = v.astype(self.dtype) + return a, q, r, u, v + + def test_sqr_rank_1(self): + a, q, r, u, v = self.generate('sqr') + q1, r1 = qr_update(q, r, u, v, False) + a1 = a + np.outer(u, v.conj()) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_sqr_rank_p(self): + # test ndim = 2, rank 1 updates here too + for p in [1, 2, 3, 5]: + a, q, r, u, v = self.generate('sqr', p=p) + if p == 1: + u = u.reshape(u.size, 1) + v = v.reshape(v.size, 1) + q1, r1 = qr_update(q, r, u, v, False) + a1 = a + np.dot(u, v.T.conj()) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_tall_rank_1(self): + a, q, r, u, v = self.generate('tall') + q1, r1 = qr_update(q, r, u, v, False) + a1 = a + np.outer(u, v.conj()) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_tall_rank_p(self): + for p in [1, 2, 3, 5]: + a, q, r, u, v = self.generate('tall', p=p) + if p == 1: + u = u.reshape(u.size, 1) + v = v.reshape(v.size, 1) + q1, r1 = qr_update(q, r, u, v, False) + a1 = a + np.dot(u, v.T.conj()) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_fat_rank_1(self): + a, q, r, u, v = self.generate('fat') + q1, r1 = qr_update(q, r, u, v, False) + a1 = a + np.outer(u, v.conj()) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_fat_rank_p(self): + for p in [1, 2, 3, 5]: + a, q, r, u, v = self.generate('fat', p=p) + if p == 1: + u = u.reshape(u.size, 1) + v = v.reshape(v.size, 1) + q1, r1 = qr_update(q, r, u, v, False) + a1 = a + np.dot(u, v.T.conj()) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_economic_rank_1(self): + a, q, r, u, v = self.generate('tall', 'economic') + q1, r1 = qr_update(q, r, u, v, False) + a1 = a + np.outer(u, v.conj()) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + + def test_economic_rank_p(self): + for p in [1, 2, 3, 5]: + a, q, r, u, v = self.generate('tall', 'economic', p) + if p == 1: + u = u.reshape(u.size, 1) + v = v.reshape(v.size, 1) + q1, r1 = qr_update(q, r, u, v, False) + a1 = a + np.dot(u, v.T.conj()) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + + def test_Mx1_rank_1(self): + a, q, r, u, v = self.generate('Mx1') + q1, r1 = qr_update(q, r, u, v, False) + a1 = a + np.outer(u, v.conj()) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_Mx1_rank_p(self): + # when M or N == 1, only a rank 1 update is allowed. This isn't + # fundamental limitation, but the code does not support it. + a, q, r, u, v = self.generate('Mx1', p=1) + u = u.reshape(u.size, 1) + v = v.reshape(v.size, 1) + q1, r1 = qr_update(q, r, u, v, False) + a1 = a + np.dot(u, v.T.conj()) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_Mx1_economic_rank_1(self): + a, q, r, u, v = self.generate('Mx1', 'economic') + q1, r1 = qr_update(q, r, u, v, False) + a1 = a + np.outer(u, v.conj()) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + + def test_Mx1_economic_rank_p(self): + # when M or N == 1, only a rank 1 update is allowed. This isn't + # fundamental limitation, but the code does not support it. + a, q, r, u, v = self.generate('Mx1', 'economic', p=1) + u = u.reshape(u.size, 1) + v = v.reshape(v.size, 1) + q1, r1 = qr_update(q, r, u, v, False) + a1 = a + np.dot(u, v.T.conj()) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + + def test_1xN_rank_1(self): + a, q, r, u, v = self.generate('1xN') + q1, r1 = qr_update(q, r, u, v, False) + a1 = a + np.outer(u, v.conj()) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_1xN_rank_p(self): + # when M or N == 1, only a rank 1 update is allowed. This isn't + # fundamental limitation, but the code does not support it. + a, q, r, u, v = self.generate('1xN', p=1) + u = u.reshape(u.size, 1) + v = v.reshape(v.size, 1) + q1, r1 = qr_update(q, r, u, v, False) + a1 = a + np.dot(u, v.T.conj()) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_1x1_rank_1(self): + a, q, r, u, v = self.generate('1x1') + q1, r1 = qr_update(q, r, u, v, False) + a1 = a + np.outer(u, v.conj()) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_1x1_rank_p(self): + # when M or N == 1, only a rank 1 update is allowed. This isn't + # fundamental limitation, but the code does not support it. + a, q, r, u, v = self.generate('1x1', p=1) + u = u.reshape(u.size, 1) + v = v.reshape(v.size, 1) + q1, r1 = qr_update(q, r, u, v, False) + a1 = a + np.dot(u, v.T.conj()) + check_qr(q1, r1, a1, self.rtol, self.atol) + + def test_1x1_rank_1_scalar(self): + a, q, r, u, v = self.generate('1x1') + assert_raises(ValueError, qr_update, q[0, 0], r, u, v) + assert_raises(ValueError, qr_update, q, r[0, 0], u, v) + assert_raises(ValueError, qr_update, q, r, u[0], v) + assert_raises(ValueError, qr_update, q, r, u, v[0]) + + def base_non_simple_strides(self, adjust_strides, mode, p, overwriteable): + assert_sqr = False if mode == 'economic' else True + for type in ['sqr', 'tall', 'fat']: + a, q0, r0, u0, v0 = self.generate(type, mode, p) + qs, rs, us, vs = adjust_strides((q0, r0, u0, v0)) + if p == 1: + aup = a + np.outer(u0, v0.conj()) + else: + aup = a + np.dot(u0, v0.T.conj()) + + # for each variable, q, r, u, v we try with it strided and + # overwrite=False. Then we try with overwrite=True, and make + # sure that if p == 1, r and v are still overwritten. + # a strided q and u must always be copied. + + q = q0.copy('F') + r = r0.copy('F') + u = u0.copy('F') + v = v0.copy('C') + q1, r1 = qr_update(qs, r, u, v, False) + check_qr(q1, r1, aup, self.rtol, self.atol, assert_sqr) + q1o, r1o = qr_update(qs, r, u, v, True) + check_qr(q1o, r1o, aup, self.rtol, self.atol, assert_sqr) + if overwriteable: + assert_allclose(r1o, r, rtol=self.rtol, atol=self.atol) + assert_allclose(v, v0.conj(), rtol=self.rtol, atol=self.atol) + + q = q0.copy('F') + r = r0.copy('F') + u = u0.copy('F') + v = v0.copy('C') + q2, r2 = qr_update(q, rs, u, v, False) + check_qr(q2, r2, aup, self.rtol, self.atol, assert_sqr) + q2o, r2o = qr_update(q, rs, u, v, True) + check_qr(q2o, r2o, aup, self.rtol, self.atol, assert_sqr) + if overwriteable: + assert_allclose(r2o, rs, rtol=self.rtol, atol=self.atol) + assert_allclose(v, v0.conj(), rtol=self.rtol, atol=self.atol) + + q = q0.copy('F') + r = r0.copy('F') + u = u0.copy('F') + v = v0.copy('C') + q3, r3 = qr_update(q, r, us, v, False) + check_qr(q3, r3, aup, self.rtol, self.atol, assert_sqr) + q3o, r3o = qr_update(q, r, us, v, True) + check_qr(q3o, r3o, aup, self.rtol, self.atol, assert_sqr) + if overwriteable: + assert_allclose(r3o, r, rtol=self.rtol, atol=self.atol) + assert_allclose(v, v0.conj(), rtol=self.rtol, atol=self.atol) + + q = q0.copy('F') + r = r0.copy('F') + u = u0.copy('F') + v = v0.copy('C') + q4, r4 = qr_update(q, r, u, vs, False) + check_qr(q4, r4, aup, self.rtol, self.atol, assert_sqr) + q4o, r4o = qr_update(q, r, u, vs, True) + check_qr(q4o, r4o, aup, self.rtol, self.atol, assert_sqr) + if overwriteable: + assert_allclose(r4o, r, rtol=self.rtol, atol=self.atol) + assert_allclose(vs, v0.conj(), rtol=self.rtol, atol=self.atol) + + q = q0.copy('F') + r = r0.copy('F') + u = u0.copy('F') + v = v0.copy('C') + # since some of these were consumed above + qs, rs, us, vs = adjust_strides((q, r, u, v)) + q5, r5 = qr_update(qs, rs, us, vs, False) + check_qr(q5, r5, aup, self.rtol, self.atol, assert_sqr) + q5o, r5o = qr_update(qs, rs, us, vs, True) + check_qr(q5o, r5o, aup, self.rtol, self.atol, assert_sqr) + if overwriteable: + assert_allclose(r5o, rs, rtol=self.rtol, atol=self.atol) + assert_allclose(vs, v0.conj(), rtol=self.rtol, atol=self.atol) + + def test_non_unit_strides_rank_1(self): + self.base_non_simple_strides(make_strided, 'full', 1, True) + + def test_non_unit_strides_economic_rank_1(self): + self.base_non_simple_strides(make_strided, 'economic', 1, True) + + def test_non_unit_strides_rank_p(self): + self.base_non_simple_strides(make_strided, 'full', 3, False) + + def test_non_unit_strides_economic_rank_p(self): + self.base_non_simple_strides(make_strided, 'economic', 3, False) + + def test_neg_strides_rank_1(self): + self.base_non_simple_strides(negate_strides, 'full', 1, False) + + def test_neg_strides_economic_rank_1(self): + self.base_non_simple_strides(negate_strides, 'economic', 1, False) + + def test_neg_strides_rank_p(self): + self.base_non_simple_strides(negate_strides, 'full', 3, False) + + def test_neg_strides_economic_rank_p(self): + self.base_non_simple_strides(negate_strides, 'economic', 3, False) + + def test_non_itemsize_strides_rank_1(self): + self.base_non_simple_strides(nonitemsize_strides, 'full', 1, False) + + def test_non_itemsize_strides_economic_rank_1(self): + self.base_non_simple_strides(nonitemsize_strides, 'economic', 1, False) + + def test_non_itemsize_strides_rank_p(self): + self.base_non_simple_strides(nonitemsize_strides, 'full', 3, False) + + def test_non_itemsize_strides_economic_rank_p(self): + self.base_non_simple_strides(nonitemsize_strides, 'economic', 3, False) + + def test_non_native_byte_order_rank_1(self): + self.base_non_simple_strides(make_nonnative, 'full', 1, False) + + def test_non_native_byte_order_economic_rank_1(self): + self.base_non_simple_strides(make_nonnative, 'economic', 1, False) + + def test_non_native_byte_order_rank_p(self): + self.base_non_simple_strides(make_nonnative, 'full', 3, False) + + def test_non_native_byte_order_economic_rank_p(self): + self.base_non_simple_strides(make_nonnative, 'economic', 3, False) + + def test_overwrite_qruv_rank_1(self): + # Any positive strided q, r, u, and v can be overwritten for a rank 1 + # update, only checking C and F contiguous. + a, q0, r0, u0, v0 = self.generate('sqr') + a1 = a + np.outer(u0, v0.conj()) + q = q0.copy('F') + r = r0.copy('F') + u = u0.copy('F') + v = v0.copy('F') + + # don't overwrite + q1, r1 = qr_update(q, r, u, v, False) + check_qr(q1, r1, a1, self.rtol, self.atol) + check_qr(q, r, a, self.rtol, self.atol) + + q2, r2 = qr_update(q, r, u, v, True) + check_qr(q2, r2, a1, self.rtol, self.atol) + # verify the overwriting, no good way to check u and v. + assert_allclose(q2, q, rtol=self.rtol, atol=self.atol) + assert_allclose(r2, r, rtol=self.rtol, atol=self.atol) + + q = q0.copy('C') + r = r0.copy('C') + u = u0.copy('C') + v = v0.copy('C') + q3, r3 = qr_update(q, r, u, v, True) + check_qr(q3, r3, a1, self.rtol, self.atol) + assert_allclose(q3, q, rtol=self.rtol, atol=self.atol) + assert_allclose(r3, r, rtol=self.rtol, atol=self.atol) + + def test_overwrite_qruv_rank_1_economic(self): + # updating economic decompositions can overwrite any contiguous r, + # and positively strided r and u. V is only ever read. + # only checking C and F contiguous. + a, q0, r0, u0, v0 = self.generate('tall', 'economic') + a1 = a + np.outer(u0, v0.conj()) + q = q0.copy('F') + r = r0.copy('F') + u = u0.copy('F') + v = v0.copy('F') + + # don't overwrite + q1, r1 = qr_update(q, r, u, v, False) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + check_qr(q, r, a, self.rtol, self.atol, False) + + q2, r2 = qr_update(q, r, u, v, True) + check_qr(q2, r2, a1, self.rtol, self.atol, False) + # verify the overwriting, no good way to check u and v. + assert_allclose(q2, q, rtol=self.rtol, atol=self.atol) + assert_allclose(r2, r, rtol=self.rtol, atol=self.atol) + + q = q0.copy('C') + r = r0.copy('C') + u = u0.copy('C') + v = v0.copy('C') + q3, r3 = qr_update(q, r, u, v, True) + check_qr(q3, r3, a1, self.rtol, self.atol, False) + assert_allclose(q3, q, rtol=self.rtol, atol=self.atol) + assert_allclose(r3, r, rtol=self.rtol, atol=self.atol) + + def test_overwrite_qruv_rank_p(self): + # for rank p updates, q r must be F contiguous, v must be C (v.T --> F) + # and u can be C or F, but is only overwritten if Q is C and complex + a, q0, r0, u0, v0 = self.generate('sqr', p=3) + a1 = a + np.dot(u0, v0.T.conj()) + q = q0.copy('F') + r = r0.copy('F') + u = u0.copy('F') + v = v0.copy('C') + + # don't overwrite + q1, r1 = qr_update(q, r, u, v, False) + check_qr(q1, r1, a1, self.rtol, self.atol) + check_qr(q, r, a, self.rtol, self.atol) + + q2, r2 = qr_update(q, r, u, v, True) + check_qr(q2, r2, a1, self.rtol, self.atol) + # verify the overwriting, no good way to check u and v. + assert_allclose(q2, q, rtol=self.rtol, atol=self.atol) + assert_allclose(r2, r, rtol=self.rtol, atol=self.atol) + + def test_empty_inputs(self): + a, q, r, u, v = self.generate('tall') + assert_raises(ValueError, qr_update, np.array([]), r, u, v) + assert_raises(ValueError, qr_update, q, np.array([]), u, v) + assert_raises(ValueError, qr_update, q, r, np.array([]), v) + assert_raises(ValueError, qr_update, q, r, u, np.array([])) + + def test_mismatched_shapes(self): + a, q, r, u, v = self.generate('tall') + assert_raises(ValueError, qr_update, q, r[1:], u, v) + assert_raises(ValueError, qr_update, q[:-2], r, u, v) + assert_raises(ValueError, qr_update, q, r, u[1:], v) + assert_raises(ValueError, qr_update, q, r, u, v[1:]) + + def test_unsupported_dtypes(self): + dts = ['int8', 'int16', 'int32', 'int64', + 'uint8', 'uint16', 'uint32', 'uint64', + 'float16', 'longdouble', 'clongdouble', + 'bool'] + a, q0, r0, u0, v0 = self.generate('tall') + for dtype in dts: + q = q0.real.astype(dtype) + with np.errstate(invalid="ignore"): + r = r0.real.astype(dtype) + u = u0.real.astype(dtype) + v = v0.real.astype(dtype) + assert_raises(ValueError, qr_update, q, r0, u0, v0) + assert_raises(ValueError, qr_update, q0, r, u0, v0) + assert_raises(ValueError, qr_update, q0, r0, u, v0) + assert_raises(ValueError, qr_update, q0, r0, u0, v) + + def test_integer_input(self): + q = np.arange(16).reshape(4, 4) + r = q.copy() # doesn't matter + u = q[:, 0].copy() + v = r[0, :].copy() + assert_raises(ValueError, qr_update, q, r, u, v) + + def test_check_finite(self): + a0, q0, r0, u0, v0 = self.generate('tall', p=3) + + q = q0.copy('F') + q[1,1] = np.nan + assert_raises(ValueError, qr_update, q, r0, u0[:,0], v0[:,0]) + assert_raises(ValueError, qr_update, q, r0, u0, v0) + + r = r0.copy('F') + r[1,1] = np.nan + assert_raises(ValueError, qr_update, q0, r, u0[:,0], v0[:,0]) + assert_raises(ValueError, qr_update, q0, r, u0, v0) + + u = u0.copy('F') + u[0,0] = np.nan + assert_raises(ValueError, qr_update, q0, r0, u[:,0], v0[:,0]) + assert_raises(ValueError, qr_update, q0, r0, u, v0) + + v = v0.copy('F') + v[0,0] = np.nan + assert_raises(ValueError, qr_update, q0, r0, u[:,0], v[:,0]) + assert_raises(ValueError, qr_update, q0, r0, u, v) + + def test_economic_check_finite(self): + a0, q0, r0, u0, v0 = self.generate('tall', mode='economic', p=3) + + q = q0.copy('F') + q[1,1] = np.nan + assert_raises(ValueError, qr_update, q, r0, u0[:,0], v0[:,0]) + assert_raises(ValueError, qr_update, q, r0, u0, v0) + + r = r0.copy('F') + r[1,1] = np.nan + assert_raises(ValueError, qr_update, q0, r, u0[:,0], v0[:,0]) + assert_raises(ValueError, qr_update, q0, r, u0, v0) + + u = u0.copy('F') + u[0,0] = np.nan + assert_raises(ValueError, qr_update, q0, r0, u[:,0], v0[:,0]) + assert_raises(ValueError, qr_update, q0, r0, u, v0) + + v = v0.copy('F') + v[0,0] = np.nan + assert_raises(ValueError, qr_update, q0, r0, u[:,0], v[:,0]) + assert_raises(ValueError, qr_update, q0, r0, u, v) + + def test_u_exactly_in_span_q(self): + q = np.array([[0, 0], [0, 0], [1, 0], [0, 1]], self.dtype) + r = np.array([[1, 0], [0, 1]], self.dtype) + u = np.array([0, 0, 0, -1], self.dtype) + v = np.array([1, 2], self.dtype) + q1, r1 = qr_update(q, r, u, v) + a1 = np.dot(q, r) + np.outer(u, v.conj()) + check_qr(q1, r1, a1, self.rtol, self.atol, False) + +class TestQRupdate_f(BaseQRupdate): + dtype = np.dtype('f') + +class TestQRupdate_F(BaseQRupdate): + dtype = np.dtype('F') + +class TestQRupdate_d(BaseQRupdate): + dtype = np.dtype('d') + +class TestQRupdate_D(BaseQRupdate): + dtype = np.dtype('D') + +def test_form_qTu(): + # We want to ensure that all of the code paths through this function are + # tested. Most of them should be hit with the rest of test suite, but + # explicit tests make clear precisely what is being tested. + # + # This function expects that Q is either C or F contiguous and square. + # Economic mode decompositions (Q is (M, N), M != N) do not go through this + # function. U may have any positive strides. + # + # Some of these test are duplicates, since contiguous 1d arrays are both C + # and F. + + q_order = ['F', 'C'] + q_shape = [(8, 8), ] + u_order = ['F', 'C', 'A'] # here A means is not F not C + u_shape = [1, 3] + dtype = ['f', 'd', 'F', 'D'] + + for qo, qs, uo, us, d in \ + itertools.product(q_order, q_shape, u_order, u_shape, dtype): + if us == 1: + check_form_qTu(qo, qs, uo, us, 1, d) + check_form_qTu(qo, qs, uo, us, 2, d) + else: + check_form_qTu(qo, qs, uo, us, 2, d) + +def check_form_qTu(q_order, q_shape, u_order, u_shape, u_ndim, dtype): + np.random.seed(47) + if u_shape == 1 and u_ndim == 1: + u_shape = (q_shape[0],) + else: + u_shape = (q_shape[0], u_shape) + dtype = np.dtype(dtype) + + if dtype.char in 'fd': + q = np.random.random(q_shape) + u = np.random.random(u_shape) + elif dtype.char in 'FD': + q = np.random.random(q_shape) + 1j*np.random.random(q_shape) + u = np.random.random(u_shape) + 1j*np.random.random(u_shape) + else: + ValueError("form_qTu doesn't support this dtype") + + q = np.require(q, dtype, q_order) + if u_order != 'A': + u = np.require(u, dtype, u_order) + else: + u, = make_strided((u.astype(dtype),)) + + rtol = 10.0 ** -(np.finfo(dtype).precision-2) + atol = 2*np.finfo(dtype).eps + + expected = np.dot(q.T.conj(), u) + res = _decomp_update._form_qTu(q, u) + assert_allclose(res, expected, rtol=rtol, atol=atol) diff --git a/shared/package-files/30/302506c88e706562dc3ddf5287f6879c37ee9aa4bd668098b10d96b1e2be04cf/blob b/shared/package-files/30/302506c88e706562dc3ddf5287f6879c37ee9aa4bd668098b10d96b1e2be04cf/blob new file mode 100644 index 0000000000000000000000000000000000000000..1e8b69eb702e0231c3cdb4e75da68b09b0ad81ea --- /dev/null +++ b/shared/package-files/30/302506c88e706562dc3ddf5287f6879c37ee9aa4bd668098b10d96b1e2be04cf/blob @@ -0,0 +1,30 @@ +from enum import Enum +from typing import Optional + +from cryptography.hazmat.backends.interfaces import HMACBackend +from cryptography.hazmat.primitives.hashes import HashAlgorithm +from cryptography.hazmat.primitives.kdf import KeyDerivationFunction + +class Mode(Enum): + CounterMode: str + +class CounterLocation(Enum): + BeforeFixed: str + AfterFixed: str + +class KBKDFHMAC(KeyDerivationFunction): + def __init__( + self, + algorithm: HashAlgorithm, + mode: Mode, + length: int, + rlen: int, + llen: int, + location: CounterLocation, + label: Optional[bytes], + context: Optional[bytes], + fixed: Optional[bytes], + backend: Optional[HMACBackend] = ..., + ): ... + def derive(self, key_material: bytes) -> bytes: ... + def verify(self, key_material: bytes, expected_key: bytes) -> None: ... diff --git a/shared/package-files/30/30262b10ffc8afc8dc6bc17d4205f3b2faf614883f8592d439e4587176189099/blob b/shared/package-files/30/30262b10ffc8afc8dc6bc17d4205f3b2faf614883f8592d439e4587176189099/blob new file mode 100644 index 0000000000000000000000000000000000000000..ce64320bcddacf77e9c5a4a4ea2f69f0e4a9589f --- /dev/null +++ b/shared/package-files/30/30262b10ffc8afc8dc6bc17d4205f3b2faf614883f8592d439e4587176189099/blob @@ -0,0 +1,23 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor & _make_per_tensor_quantized_tensor_out(const at::Tensor & self, double scale, int64_t zero_point, at::Tensor & out); +TORCH_API at::Tensor make_per_tensor_quantized_tensor_cpu(const at::Tensor & self, double scale, int64_t zero_point); +TORCH_API at::Tensor make_per_tensor_quantized_tensor_cuda(const at::Tensor & self, double scale, int64_t zero_point); +} // namespace native +} // namespace at diff --git a/shared/package-files/30/3029ea34173e9fdc233ad315dc6b100bd1ea71f529b1c1af97664a272fdc55f5/blob b/shared/package-files/30/3029ea34173e9fdc233ad315dc6b100bd1ea71f529b1c1af97664a272fdc55f5/blob new file mode 100644 index 0000000000000000000000000000000000000000..d112c4806aa90b4c911b360fa0ce1d0ee7c031ce --- /dev/null +++ b/shared/package-files/30/3029ea34173e9fdc233ad315dc6b100bd1ea71f529b1c1af97664a272fdc55f5/blob @@ -0,0 +1,32 @@ +This module was extracted from the `cloud` package, developed by +PiCloud, Inc. + +Copyright (c) 2015, Cloudpickle contributors. +Copyright (c) 2012, Regents of the University of California. +Copyright (c) 2009 PiCloud, Inc. http://www.picloud.com. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of the University of California, Berkeley nor the + names of its contributors may be used to endorse or promote + products derived from this software without specific prior written + permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED +TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/shared/package-files/30/302ae2df8eaaa356d8c23966df6c47472465f9b00835395f548b9b37a1c3cfaf/blob b/shared/package-files/30/302ae2df8eaaa356d8c23966df6c47472465f9b00835395f548b9b37a1c3cfaf/blob new file mode 100644 index 0000000000000000000000000000000000000000..3eb7e9af9c8ce3c5834f9e4d7283746961ea0981 --- /dev/null +++ b/shared/package-files/30/302ae2df8eaaa356d8c23966df6c47472465f9b00835395f548b9b37a1c3cfaf/blob @@ -0,0 +1,71 @@ +import sys + +from numpy.distutils.fcompiler import FCompiler, dummy_fortran_file +from sys import platform +from os.path import join, dirname, normpath + +compilers = ['ArmFlangCompiler'] + +import functools + +class ArmFlangCompiler(FCompiler): + compiler_type = 'arm' + description = 'Arm Compiler' + version_pattern = r'\s*Arm.*version (?P[\d.-]+).*' + + ar_exe = 'lib.exe' + possible_executables = ['armflang'] + + executables = { + 'version_cmd': ["", "--version"], + 'compiler_f77': ["armflang", "-fPIC"], + 'compiler_fix': ["armflang", "-fPIC", "-ffixed-form"], + 'compiler_f90': ["armflang", "-fPIC"], + 'linker_so': ["armflang", "-fPIC", "-shared"], + 'archiver': ["ar", "-cr"], + 'ranlib': None + } + + pic_flags = ["-fPIC", "-DPIC"] + c_compiler = 'arm' + module_dir_switch = '-module ' # Don't remove ending space! + + def get_libraries(self): + opt = FCompiler.get_libraries(self) + opt.extend(['flang', 'flangrti', 'ompstub']) + return opt + + @functools.lru_cache(maxsize=128) + def get_library_dirs(self): + """List of compiler library directories.""" + opt = FCompiler.get_library_dirs(self) + flang_dir = dirname(self.executables['compiler_f77'][0]) + opt.append(normpath(join(flang_dir, '..', 'lib'))) + + return opt + + def get_flags(self): + return [] + + def get_flags_free(self): + return [] + + def get_flags_debug(self): + return ['-g'] + + def get_flags_opt(self): + return ['-O3'] + + def get_flags_arch(self): + return [] + + def runtime_library_dir_option(self, dir): + return '-Wl,-rpath=%s' % dir + + +if __name__ == '__main__': + from distutils import log + log.set_verbosity(2) + from numpy.distutils import customized_fcompiler + print(customized_fcompiler(compiler='armflang').get_version()) + diff --git a/shared/package-files/30/302e961e54e5a07c467a7f642291f51e9da9d4f3f208d9a82b97f72bd7fb8d70/blob b/shared/package-files/30/302e961e54e5a07c467a7f642291f51e9da9d4f3f208d9a82b97f72bd7fb8d70/blob new file mode 100644 index 0000000000000000000000000000000000000000..dde9362d44669831843a33ed2d944c3c64ed91fa --- /dev/null +++ b/shared/package-files/30/302e961e54e5a07c467a7f642291f51e9da9d4f3f208d9a82b97f72bd7fb8d70/blob @@ -0,0 +1,2 @@ +from numba.cuda.simulator.cudadrv import (devicearray, devices, driver, drvapi, + error, nvvm) diff --git a/shared/package-files/30/302ed03d2df83c2e30c4d6cea7ba53cb9edda85f41f8be8bd4a308eabadf7b6c/blob b/shared/package-files/30/302ed03d2df83c2e30c4d6cea7ba53cb9edda85f41f8be8bd4a308eabadf7b6c/blob new file mode 100644 index 0000000000000000000000000000000000000000..8a6246c3666c8475be5b63261692e0718f2095e9 --- /dev/null +++ b/shared/package-files/30/302ed03d2df83c2e30c4d6cea7ba53cb9edda85f41f8be8bd4a308eabadf7b6c/blob @@ -0,0 +1,2133 @@ +""" +Masked arrays add-ons. + +A collection of utilities for `numpy.ma`. + +:author: Pierre Gerard-Marchant +:contact: pierregm_at_uga_dot_edu +:version: $Id: extras.py 3473 2007-10-29 15:18:13Z jarrod.millman $ + +""" +__all__ = [ + 'apply_along_axis', 'apply_over_axes', 'atleast_1d', 'atleast_2d', + 'atleast_3d', 'average', 'clump_masked', 'clump_unmasked', 'column_stack', + 'compress_cols', 'compress_nd', 'compress_rowcols', 'compress_rows', + 'count_masked', 'corrcoef', 'cov', 'diagflat', 'dot', 'dstack', 'ediff1d', + 'flatnotmasked_contiguous', 'flatnotmasked_edges', 'hsplit', 'hstack', + 'isin', 'in1d', 'intersect1d', 'mask_cols', 'mask_rowcols', 'mask_rows', + 'masked_all', 'masked_all_like', 'median', 'mr_', 'ndenumerate', + 'notmasked_contiguous', 'notmasked_edges', 'polyfit', 'row_stack', + 'setdiff1d', 'setxor1d', 'stack', 'unique', 'union1d', 'vander', 'vstack', + ] + +import itertools +import warnings + +from . import core as ma +from .core import ( + MaskedArray, MAError, add, array, asarray, concatenate, filled, count, + getmask, getmaskarray, make_mask_descr, masked, masked_array, mask_or, + nomask, ones, sort, zeros, getdata, get_masked_subclass, dot + ) + +import numpy as np +from numpy import ndarray, array as nxarray +from numpy.core.multiarray import normalize_axis_index +from numpy.core.numeric import normalize_axis_tuple +from numpy.lib.function_base import _ureduce +from numpy.lib.index_tricks import AxisConcatenator + + +def issequence(seq): + """ + Is seq a sequence (ndarray, list or tuple)? + + """ + return isinstance(seq, (ndarray, tuple, list)) + + +def count_masked(arr, axis=None): + """ + Count the number of masked elements along the given axis. + + Parameters + ---------- + arr : array_like + An array with (possibly) masked elements. + axis : int, optional + Axis along which to count. If None (default), a flattened + version of the array is used. + + Returns + ------- + count : int, ndarray + The total number of masked elements (axis=None) or the number + of masked elements along each slice of the given axis. + + See Also + -------- + MaskedArray.count : Count non-masked elements. + + Examples + -------- + >>> import numpy.ma as ma + >>> a = np.arange(9).reshape((3,3)) + >>> a = ma.array(a) + >>> a[1, 0] = ma.masked + >>> a[1, 2] = ma.masked + >>> a[2, 1] = ma.masked + >>> a + masked_array( + data=[[0, 1, 2], + [--, 4, --], + [6, --, 8]], + mask=[[False, False, False], + [ True, False, True], + [False, True, False]], + fill_value=999999) + >>> ma.count_masked(a) + 3 + + When the `axis` keyword is used an array is returned. + + >>> ma.count_masked(a, axis=0) + array([1, 1, 1]) + >>> ma.count_masked(a, axis=1) + array([0, 2, 1]) + + """ + m = getmaskarray(arr) + return m.sum(axis) + + +def masked_all(shape, dtype=float): + """ + Empty masked array with all elements masked. + + Return an empty masked array of the given shape and dtype, where all the + data are masked. + + Parameters + ---------- + shape : int or tuple of ints + Shape of the required MaskedArray, e.g., ``(2, 3)`` or ``2``. + dtype : dtype, optional + Data type of the output. + + Returns + ------- + a : MaskedArray + A masked array with all data masked. + + See Also + -------- + masked_all_like : Empty masked array modelled on an existing array. + + Examples + -------- + >>> import numpy.ma as ma + >>> ma.masked_all((3, 3)) + masked_array( + data=[[--, --, --], + [--, --, --], + [--, --, --]], + mask=[[ True, True, True], + [ True, True, True], + [ True, True, True]], + fill_value=1e+20, + dtype=float64) + + The `dtype` parameter defines the underlying data type. + + >>> a = ma.masked_all((3, 3)) + >>> a.dtype + dtype('float64') + >>> a = ma.masked_all((3, 3), dtype=np.int32) + >>> a.dtype + dtype('int32') + + """ + a = masked_array(np.empty(shape, dtype), + mask=np.ones(shape, make_mask_descr(dtype))) + return a + + +def masked_all_like(arr): + """ + Empty masked array with the properties of an existing array. + + Return an empty masked array of the same shape and dtype as + the array `arr`, where all the data are masked. + + Parameters + ---------- + arr : ndarray + An array describing the shape and dtype of the required MaskedArray. + + Returns + ------- + a : MaskedArray + A masked array with all data masked. + + Raises + ------ + AttributeError + If `arr` doesn't have a shape attribute (i.e. not an ndarray) + + See Also + -------- + masked_all : Empty masked array with all elements masked. + + Examples + -------- + >>> import numpy.ma as ma + >>> arr = np.zeros((2, 3), dtype=np.float32) + >>> arr + array([[0., 0., 0.], + [0., 0., 0.]], dtype=float32) + >>> ma.masked_all_like(arr) + masked_array( + data=[[--, --, --], + [--, --, --]], + mask=[[ True, True, True], + [ True, True, True]], + fill_value=1e+20, + dtype=float32) + + The dtype of the masked array matches the dtype of `arr`. + + >>> arr.dtype + dtype('float32') + >>> ma.masked_all_like(arr).dtype + dtype('float32') + + """ + a = np.empty_like(arr).view(MaskedArray) + a._mask = np.ones(a.shape, dtype=make_mask_descr(a.dtype)) + return a + + +#####-------------------------------------------------------------------------- +#---- --- Standard functions --- +#####-------------------------------------------------------------------------- +class _fromnxfunction: + """ + Defines a wrapper to adapt NumPy functions to masked arrays. + + + An instance of `_fromnxfunction` can be called with the same parameters + as the wrapped NumPy function. The docstring of `newfunc` is adapted from + the wrapped function as well, see `getdoc`. + + This class should not be used directly. Instead, one of its extensions that + provides support for a specific type of input should be used. + + Parameters + ---------- + funcname : str + The name of the function to be adapted. The function should be + in the NumPy namespace (i.e. ``np.funcname``). + + """ + + def __init__(self, funcname): + self.__name__ = funcname + self.__doc__ = self.getdoc() + + def getdoc(self): + """ + Retrieve the docstring and signature from the function. + + The ``__doc__`` attribute of the function is used as the docstring for + the new masked array version of the function. A note on application + of the function to the mask is appended. + + Parameters + ---------- + None + + """ + npfunc = getattr(np, self.__name__, None) + doc = getattr(npfunc, '__doc__', None) + if doc: + sig = self.__name__ + ma.get_object_signature(npfunc) + doc = ma.doc_note(doc, "The function is applied to both the _data " + "and the _mask, if any.") + return '\n\n'.join((sig, doc)) + return + + def __call__(self, *args, **params): + pass + + +class _fromnxfunction_single(_fromnxfunction): + """ + A version of `_fromnxfunction` that is called with a single array + argument followed by auxiliary args that are passed verbatim for + both the data and mask calls. + """ + def __call__(self, x, *args, **params): + func = getattr(np, self.__name__) + if isinstance(x, ndarray): + _d = func(x.__array__(), *args, **params) + _m = func(getmaskarray(x), *args, **params) + return masked_array(_d, mask=_m) + else: + _d = func(np.asarray(x), *args, **params) + _m = func(getmaskarray(x), *args, **params) + return masked_array(_d, mask=_m) + + +class _fromnxfunction_seq(_fromnxfunction): + """ + A version of `_fromnxfunction` that is called with a single sequence + of arrays followed by auxiliary args that are passed verbatim for + both the data and mask calls. + """ + def __call__(self, x, *args, **params): + func = getattr(np, self.__name__) + _d = func(tuple([np.asarray(a) for a in x]), *args, **params) + _m = func(tuple([getmaskarray(a) for a in x]), *args, **params) + return masked_array(_d, mask=_m) + + +class _fromnxfunction_args(_fromnxfunction): + """ + A version of `_fromnxfunction` that is called with multiple array + arguments. The first non-array-like input marks the beginning of the + arguments that are passed verbatim for both the data and mask calls. + Array arguments are processed independently and the results are + returned in a list. If only one array is found, the return value is + just the processed array instead of a list. + """ + def __call__(self, *args, **params): + func = getattr(np, self.__name__) + arrays = [] + args = list(args) + while len(args) > 0 and issequence(args[0]): + arrays.append(args.pop(0)) + res = [] + for x in arrays: + _d = func(np.asarray(x), *args, **params) + _m = func(getmaskarray(x), *args, **params) + res.append(masked_array(_d, mask=_m)) + if len(arrays) == 1: + return res[0] + return res + + +class _fromnxfunction_allargs(_fromnxfunction): + """ + A version of `_fromnxfunction` that is called with multiple array + arguments. Similar to `_fromnxfunction_args` except that all args + are converted to arrays even if they are not so already. This makes + it possible to process scalars as 1-D arrays. Only keyword arguments + are passed through verbatim for the data and mask calls. Arrays + arguments are processed independently and the results are returned + in a list. If only one arg is present, the return value is just the + processed array instead of a list. + """ + def __call__(self, *args, **params): + func = getattr(np, self.__name__) + res = [] + for x in args: + _d = func(np.asarray(x), **params) + _m = func(getmaskarray(x), **params) + res.append(masked_array(_d, mask=_m)) + if len(args) == 1: + return res[0] + return res + + +atleast_1d = _fromnxfunction_allargs('atleast_1d') +atleast_2d = _fromnxfunction_allargs('atleast_2d') +atleast_3d = _fromnxfunction_allargs('atleast_3d') + +vstack = row_stack = _fromnxfunction_seq('vstack') +hstack = _fromnxfunction_seq('hstack') +column_stack = _fromnxfunction_seq('column_stack') +dstack = _fromnxfunction_seq('dstack') +stack = _fromnxfunction_seq('stack') + +hsplit = _fromnxfunction_single('hsplit') + +diagflat = _fromnxfunction_single('diagflat') + + +#####-------------------------------------------------------------------------- +#---- +#####-------------------------------------------------------------------------- +def flatten_inplace(seq): + """Flatten a sequence in place.""" + k = 0 + while (k != len(seq)): + while hasattr(seq[k], '__iter__'): + seq[k:(k + 1)] = seq[k] + k += 1 + return seq + + +def apply_along_axis(func1d, axis, arr, *args, **kwargs): + """ + (This docstring should be overwritten) + """ + arr = array(arr, copy=False, subok=True) + nd = arr.ndim + axis = normalize_axis_index(axis, nd) + ind = [0] * (nd - 1) + i = np.zeros(nd, 'O') + indlist = list(range(nd)) + indlist.remove(axis) + i[axis] = slice(None, None) + outshape = np.asarray(arr.shape).take(indlist) + i.put(indlist, ind) + res = func1d(arr[tuple(i.tolist())], *args, **kwargs) + # if res is a number, then we have a smaller output array + asscalar = np.isscalar(res) + if not asscalar: + try: + len(res) + except TypeError: + asscalar = True + # Note: we shouldn't set the dtype of the output from the first result + # so we force the type to object, and build a list of dtypes. We'll + # just take the largest, to avoid some downcasting + dtypes = [] + if asscalar: + dtypes.append(np.asarray(res).dtype) + outarr = zeros(outshape, object) + outarr[tuple(ind)] = res + Ntot = np.prod(outshape) + k = 1 + while k < Ntot: + # increment the index + ind[-1] += 1 + n = -1 + while (ind[n] >= outshape[n]) and (n > (1 - nd)): + ind[n - 1] += 1 + ind[n] = 0 + n -= 1 + i.put(indlist, ind) + res = func1d(arr[tuple(i.tolist())], *args, **kwargs) + outarr[tuple(ind)] = res + dtypes.append(asarray(res).dtype) + k += 1 + else: + res = array(res, copy=False, subok=True) + j = i.copy() + j[axis] = ([slice(None, None)] * res.ndim) + j.put(indlist, ind) + Ntot = np.prod(outshape) + holdshape = outshape + outshape = list(arr.shape) + outshape[axis] = res.shape + dtypes.append(asarray(res).dtype) + outshape = flatten_inplace(outshape) + outarr = zeros(outshape, object) + outarr[tuple(flatten_inplace(j.tolist()))] = res + k = 1 + while k < Ntot: + # increment the index + ind[-1] += 1 + n = -1 + while (ind[n] >= holdshape[n]) and (n > (1 - nd)): + ind[n - 1] += 1 + ind[n] = 0 + n -= 1 + i.put(indlist, ind) + j.put(indlist, ind) + res = func1d(arr[tuple(i.tolist())], *args, **kwargs) + outarr[tuple(flatten_inplace(j.tolist()))] = res + dtypes.append(asarray(res).dtype) + k += 1 + max_dtypes = np.dtype(np.asarray(dtypes).max()) + if not hasattr(arr, '_mask'): + result = np.asarray(outarr, dtype=max_dtypes) + else: + result = asarray(outarr, dtype=max_dtypes) + result.fill_value = ma.default_fill_value(result) + return result +apply_along_axis.__doc__ = np.apply_along_axis.__doc__ + + +def apply_over_axes(func, a, axes): + """ + (This docstring will be overwritten) + """ + val = asarray(a) + N = a.ndim + if array(axes).ndim == 0: + axes = (axes,) + for axis in axes: + if axis < 0: + axis = N + axis + args = (val, axis) + res = func(*args) + if res.ndim == val.ndim: + val = res + else: + res = ma.expand_dims(res, axis) + if res.ndim == val.ndim: + val = res + else: + raise ValueError("function is not returning " + "an array of the correct shape") + return val + + +if apply_over_axes.__doc__ is not None: + apply_over_axes.__doc__ = np.apply_over_axes.__doc__[ + :np.apply_over_axes.__doc__.find('Notes')].rstrip() + \ + """ + + Examples + -------- + >>> a = np.ma.arange(24).reshape(2,3,4) + >>> a[:,0,1] = np.ma.masked + >>> a[:,1,:] = np.ma.masked + >>> a + masked_array( + data=[[[0, --, 2, 3], + [--, --, --, --], + [8, 9, 10, 11]], + [[12, --, 14, 15], + [--, --, --, --], + [20, 21, 22, 23]]], + mask=[[[False, True, False, False], + [ True, True, True, True], + [False, False, False, False]], + [[False, True, False, False], + [ True, True, True, True], + [False, False, False, False]]], + fill_value=999999) + >>> np.ma.apply_over_axes(np.ma.sum, a, [0,2]) + masked_array( + data=[[[46], + [--], + [124]]], + mask=[[[False], + [ True], + [False]]], + fill_value=999999) + + Tuple axis arguments to ufuncs are equivalent: + + >>> np.ma.sum(a, axis=(0,2)).reshape((1,-1,1)) + masked_array( + data=[[[46], + [--], + [124]]], + mask=[[[False], + [ True], + [False]]], + fill_value=999999) + """ + + +def average(a, axis=None, weights=None, returned=False, *, + keepdims=np._NoValue): + """ + Return the weighted average of array over the given axis. + + Parameters + ---------- + a : array_like + Data to be averaged. + Masked entries are not taken into account in the computation. + axis : int, optional + Axis along which to average `a`. If None, averaging is done over + the flattened array. + weights : array_like, optional + The importance that each element has in the computation of the average. + The weights array can either be 1-D (in which case its length must be + the size of `a` along the given axis) or of the same shape as `a`. + If ``weights=None``, then all data in `a` are assumed to have a + weight equal to one. The 1-D calculation is:: + + avg = sum(a * weights) / sum(weights) + + The only constraint on `weights` is that `sum(weights)` must not be 0. + returned : bool, optional + Flag indicating whether a tuple ``(result, sum of weights)`` + should be returned as output (True), or just the result (False). + Default is False. + keepdims : bool, optional + If this is set to True, the axes which are reduced are left + in the result as dimensions with size one. With this option, + the result will broadcast correctly against the original `a`. + *Note:* `keepdims` will not work with instances of `numpy.matrix` + or other classes whose methods do not support `keepdims`. + + .. versionadded:: 1.23.0 + + Returns + ------- + average, [sum_of_weights] : (tuple of) scalar or MaskedArray + The average along the specified axis. When returned is `True`, + return a tuple with the average as the first element and the sum + of the weights as the second element. The return type is `np.float64` + if `a` is of integer type and floats smaller than `float64`, or the + input data-type, otherwise. If returned, `sum_of_weights` is always + `float64`. + + Examples + -------- + >>> a = np.ma.array([1., 2., 3., 4.], mask=[False, False, True, True]) + >>> np.ma.average(a, weights=[3, 1, 0, 0]) + 1.25 + + >>> x = np.ma.arange(6.).reshape(3, 2) + >>> x + masked_array( + data=[[0., 1.], + [2., 3.], + [4., 5.]], + mask=False, + fill_value=1e+20) + >>> avg, sumweights = np.ma.average(x, axis=0, weights=[1, 2, 3], + ... returned=True) + >>> avg + masked_array(data=[2.6666666666666665, 3.6666666666666665], + mask=[False, False], + fill_value=1e+20) + + With ``keepdims=True``, the following result has shape (3, 1). + + >>> np.ma.average(x, axis=1, keepdims=True) + masked_array( + data=[[0.5], + [2.5], + [4.5]], + mask=False, + fill_value=1e+20) + """ + a = asarray(a) + m = getmask(a) + + # inspired by 'average' in numpy/lib/function_base.py + + if keepdims is np._NoValue: + # Don't pass on the keepdims argument if one wasn't given. + keepdims_kw = {} + else: + keepdims_kw = {'keepdims': keepdims} + + if weights is None: + avg = a.mean(axis, **keepdims_kw) + scl = avg.dtype.type(a.count(axis)) + else: + wgt = asarray(weights) + + if issubclass(a.dtype.type, (np.integer, np.bool_)): + result_dtype = np.result_type(a.dtype, wgt.dtype, 'f8') + else: + result_dtype = np.result_type(a.dtype, wgt.dtype) + + # Sanity checks + if a.shape != wgt.shape: + if axis is None: + raise TypeError( + "Axis must be specified when shapes of a and weights " + "differ.") + if wgt.ndim != 1: + raise TypeError( + "1D weights expected when shapes of a and weights differ.") + if wgt.shape[0] != a.shape[axis]: + raise ValueError( + "Length of weights not compatible with specified axis.") + + # setup wgt to broadcast along axis + wgt = np.broadcast_to(wgt, (a.ndim-1)*(1,) + wgt.shape, subok=True) + wgt = wgt.swapaxes(-1, axis) + + if m is not nomask: + wgt = wgt*(~a.mask) + wgt.mask |= a.mask + + scl = wgt.sum(axis=axis, dtype=result_dtype, **keepdims_kw) + avg = np.multiply(a, wgt, + dtype=result_dtype).sum(axis, **keepdims_kw) / scl + + if returned: + if scl.shape != avg.shape: + scl = np.broadcast_to(scl, avg.shape).copy() + return avg, scl + else: + return avg + + +def median(a, axis=None, out=None, overwrite_input=False, keepdims=False): + """ + Compute the median along the specified axis. + + Returns the median of the array elements. + + Parameters + ---------- + a : array_like + Input array or object that can be converted to an array. + axis : int, optional + Axis along which the medians are computed. The default (None) is + to compute the median along a flattened version of the array. + out : ndarray, optional + Alternative output array in which to place the result. It must + have the same shape and buffer length as the expected output + but the type will be cast if necessary. + overwrite_input : bool, optional + If True, then allow use of memory of input array (a) for + calculations. The input array will be modified by the call to + median. This will save memory when you do not need to preserve + the contents of the input array. Treat the input as undefined, + but it will probably be fully or partially sorted. Default is + False. Note that, if `overwrite_input` is True, and the input + is not already an `ndarray`, an error will be raised. + keepdims : bool, optional + If this is set to True, the axes which are reduced are left + in the result as dimensions with size one. With this option, + the result will broadcast correctly against the input array. + + .. versionadded:: 1.10.0 + + Returns + ------- + median : ndarray + A new array holding the result is returned unless out is + specified, in which case a reference to out is returned. + Return data-type is `float64` for integers and floats smaller than + `float64`, or the input data-type, otherwise. + + See Also + -------- + mean + + Notes + ----- + Given a vector ``V`` with ``N`` non masked values, the median of ``V`` + is the middle value of a sorted copy of ``V`` (``Vs``) - i.e. + ``Vs[(N-1)/2]``, when ``N`` is odd, or ``{Vs[N/2 - 1] + Vs[N/2]}/2`` + when ``N`` is even. + + Examples + -------- + >>> x = np.ma.array(np.arange(8), mask=[0]*4 + [1]*4) + >>> np.ma.median(x) + 1.5 + + >>> x = np.ma.array(np.arange(10).reshape(2, 5), mask=[0]*6 + [1]*4) + >>> np.ma.median(x) + 2.5 + >>> np.ma.median(x, axis=-1, overwrite_input=True) + masked_array(data=[2.0, 5.0], + mask=[False, False], + fill_value=1e+20) + + """ + if not hasattr(a, 'mask'): + m = np.median(getdata(a, subok=True), axis=axis, + out=out, overwrite_input=overwrite_input, + keepdims=keepdims) + if isinstance(m, np.ndarray) and 1 <= m.ndim: + return masked_array(m, copy=False) + else: + return m + + return _ureduce(a, func=_median, keepdims=keepdims, axis=axis, out=out, + overwrite_input=overwrite_input) + + +def _median(a, axis=None, out=None, overwrite_input=False): + # when an unmasked NaN is present return it, so we need to sort the NaN + # values behind the mask + if np.issubdtype(a.dtype, np.inexact): + fill_value = np.inf + else: + fill_value = None + if overwrite_input: + if axis is None: + asorted = a.ravel() + asorted.sort(fill_value=fill_value) + else: + a.sort(axis=axis, fill_value=fill_value) + asorted = a + else: + asorted = sort(a, axis=axis, fill_value=fill_value) + + if axis is None: + axis = 0 + else: + axis = normalize_axis_index(axis, asorted.ndim) + + if asorted.shape[axis] == 0: + # for empty axis integer indices fail so use slicing to get same result + # as median (which is mean of empty slice = nan) + indexer = [slice(None)] * asorted.ndim + indexer[axis] = slice(0, 0) + indexer = tuple(indexer) + return np.ma.mean(asorted[indexer], axis=axis, out=out) + + if asorted.ndim == 1: + idx, odd = divmod(count(asorted), 2) + mid = asorted[idx + odd - 1:idx + 1] + if np.issubdtype(asorted.dtype, np.inexact) and asorted.size > 0: + # avoid inf / x = masked + s = mid.sum(out=out) + if not odd: + s = np.true_divide(s, 2., casting='safe', out=out) + s = np.lib.utils._median_nancheck(asorted, s, axis) + else: + s = mid.mean(out=out) + + # if result is masked either the input contained enough + # minimum_fill_value so that it would be the median or all values + # masked + if np.ma.is_masked(s) and not np.all(asorted.mask): + return np.ma.minimum_fill_value(asorted) + return s + + counts = count(asorted, axis=axis, keepdims=True) + h = counts // 2 + + # duplicate high if odd number of elements so mean does nothing + odd = counts % 2 == 1 + l = np.where(odd, h, h-1) + + lh = np.concatenate([l,h], axis=axis) + + # get low and high median + low_high = np.take_along_axis(asorted, lh, axis=axis) + + def replace_masked(s): + # Replace masked entries with minimum_full_value unless it all values + # are masked. This is required as the sort order of values equal or + # larger than the fill value is undefined and a valid value placed + # elsewhere, e.g. [4, --, inf]. + if np.ma.is_masked(s): + rep = (~np.all(asorted.mask, axis=axis, keepdims=True)) & s.mask + s.data[rep] = np.ma.minimum_fill_value(asorted) + s.mask[rep] = False + + replace_masked(low_high) + + if np.issubdtype(asorted.dtype, np.inexact): + # avoid inf / x = masked + s = np.ma.sum(low_high, axis=axis, out=out) + np.true_divide(s.data, 2., casting='unsafe', out=s.data) + + s = np.lib.utils._median_nancheck(asorted, s, axis) + else: + s = np.ma.mean(low_high, axis=axis, out=out) + + return s + + +def compress_nd(x, axis=None): + """Suppress slices from multiple dimensions which contain masked values. + + Parameters + ---------- + x : array_like, MaskedArray + The array to operate on. If not a MaskedArray instance (or if no array + elements are masked), `x` is interpreted as a MaskedArray with `mask` + set to `nomask`. + axis : tuple of ints or int, optional + Which dimensions to suppress slices from can be configured with this + parameter. + - If axis is a tuple of ints, those are the axes to suppress slices from. + - If axis is an int, then that is the only axis to suppress slices from. + - If axis is None, all axis are selected. + + Returns + ------- + compress_array : ndarray + The compressed array. + """ + x = asarray(x) + m = getmask(x) + # Set axis to tuple of ints + if axis is None: + axis = tuple(range(x.ndim)) + else: + axis = normalize_axis_tuple(axis, x.ndim) + + # Nothing is masked: return x + if m is nomask or not m.any(): + return x._data + # All is masked: return empty + if m.all(): + return nxarray([]) + # Filter elements through boolean indexing + data = x._data + for ax in axis: + axes = tuple(list(range(ax)) + list(range(ax + 1, x.ndim))) + data = data[(slice(None),)*ax + (~m.any(axis=axes),)] + return data + + +def compress_rowcols(x, axis=None): + """ + Suppress the rows and/or columns of a 2-D array that contain + masked values. + + The suppression behavior is selected with the `axis` parameter. + + - If axis is None, both rows and columns are suppressed. + - If axis is 0, only rows are suppressed. + - If axis is 1 or -1, only columns are suppressed. + + Parameters + ---------- + x : array_like, MaskedArray + The array to operate on. If not a MaskedArray instance (or if no array + elements are masked), `x` is interpreted as a MaskedArray with + `mask` set to `nomask`. Must be a 2D array. + axis : int, optional + Axis along which to perform the operation. Default is None. + + Returns + ------- + compressed_array : ndarray + The compressed array. + + Examples + -------- + >>> x = np.ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0], + ... [1, 0, 0], + ... [0, 0, 0]]) + >>> x + masked_array( + data=[[--, 1, 2], + [--, 4, 5], + [6, 7, 8]], + mask=[[ True, False, False], + [ True, False, False], + [False, False, False]], + fill_value=999999) + + >>> np.ma.compress_rowcols(x) + array([[7, 8]]) + >>> np.ma.compress_rowcols(x, 0) + array([[6, 7, 8]]) + >>> np.ma.compress_rowcols(x, 1) + array([[1, 2], + [4, 5], + [7, 8]]) + + """ + if asarray(x).ndim != 2: + raise NotImplementedError("compress_rowcols works for 2D arrays only.") + return compress_nd(x, axis=axis) + + +def compress_rows(a): + """ + Suppress whole rows of a 2-D array that contain masked values. + + This is equivalent to ``np.ma.compress_rowcols(a, 0)``, see + `compress_rowcols` for details. + + See Also + -------- + compress_rowcols + + """ + a = asarray(a) + if a.ndim != 2: + raise NotImplementedError("compress_rows works for 2D arrays only.") + return compress_rowcols(a, 0) + + +def compress_cols(a): + """ + Suppress whole columns of a 2-D array that contain masked values. + + This is equivalent to ``np.ma.compress_rowcols(a, 1)``, see + `compress_rowcols` for details. + + See Also + -------- + compress_rowcols + + """ + a = asarray(a) + if a.ndim != 2: + raise NotImplementedError("compress_cols works for 2D arrays only.") + return compress_rowcols(a, 1) + + +def mask_rowcols(a, axis=None): + """ + Mask rows and/or columns of a 2D array that contain masked values. + + Mask whole rows and/or columns of a 2D array that contain + masked values. The masking behavior is selected using the + `axis` parameter. + + - If `axis` is None, rows *and* columns are masked. + - If `axis` is 0, only rows are masked. + - If `axis` is 1 or -1, only columns are masked. + + Parameters + ---------- + a : array_like, MaskedArray + The array to mask. If not a MaskedArray instance (or if no array + elements are masked), the result is a MaskedArray with `mask` set + to `nomask` (False). Must be a 2D array. + axis : int, optional + Axis along which to perform the operation. If None, applies to a + flattened version of the array. + + Returns + ------- + a : MaskedArray + A modified version of the input array, masked depending on the value + of the `axis` parameter. + + Raises + ------ + NotImplementedError + If input array `a` is not 2D. + + See Also + -------- + mask_rows : Mask rows of a 2D array that contain masked values. + mask_cols : Mask cols of a 2D array that contain masked values. + masked_where : Mask where a condition is met. + + Notes + ----- + The input array's mask is modified by this function. + + Examples + -------- + >>> import numpy.ma as ma + >>> a = np.zeros((3, 3), dtype=int) + >>> a[1, 1] = 1 + >>> a + array([[0, 0, 0], + [0, 1, 0], + [0, 0, 0]]) + >>> a = ma.masked_equal(a, 1) + >>> a + masked_array( + data=[[0, 0, 0], + [0, --, 0], + [0, 0, 0]], + mask=[[False, False, False], + [False, True, False], + [False, False, False]], + fill_value=1) + >>> ma.mask_rowcols(a) + masked_array( + data=[[0, --, 0], + [--, --, --], + [0, --, 0]], + mask=[[False, True, False], + [ True, True, True], + [False, True, False]], + fill_value=1) + + """ + a = array(a, subok=False) + if a.ndim != 2: + raise NotImplementedError("mask_rowcols works for 2D arrays only.") + m = getmask(a) + # Nothing is masked: return a + if m is nomask or not m.any(): + return a + maskedval = m.nonzero() + a._mask = a._mask.copy() + if not axis: + a[np.unique(maskedval[0])] = masked + if axis in [None, 1, -1]: + a[:, np.unique(maskedval[1])] = masked + return a + + +def mask_rows(a, axis=np._NoValue): + """ + Mask rows of a 2D array that contain masked values. + + This function is a shortcut to ``mask_rowcols`` with `axis` equal to 0. + + See Also + -------- + mask_rowcols : Mask rows and/or columns of a 2D array. + masked_where : Mask where a condition is met. + + Examples + -------- + >>> import numpy.ma as ma + >>> a = np.zeros((3, 3), dtype=int) + >>> a[1, 1] = 1 + >>> a + array([[0, 0, 0], + [0, 1, 0], + [0, 0, 0]]) + >>> a = ma.masked_equal(a, 1) + >>> a + masked_array( + data=[[0, 0, 0], + [0, --, 0], + [0, 0, 0]], + mask=[[False, False, False], + [False, True, False], + [False, False, False]], + fill_value=1) + + >>> ma.mask_rows(a) + masked_array( + data=[[0, 0, 0], + [--, --, --], + [0, 0, 0]], + mask=[[False, False, False], + [ True, True, True], + [False, False, False]], + fill_value=1) + + """ + if axis is not np._NoValue: + # remove the axis argument when this deprecation expires + # NumPy 1.18.0, 2019-11-28 + warnings.warn( + "The axis argument has always been ignored, in future passing it " + "will raise TypeError", DeprecationWarning, stacklevel=2) + return mask_rowcols(a, 0) + + +def mask_cols(a, axis=np._NoValue): + """ + Mask columns of a 2D array that contain masked values. + + This function is a shortcut to ``mask_rowcols`` with `axis` equal to 1. + + See Also + -------- + mask_rowcols : Mask rows and/or columns of a 2D array. + masked_where : Mask where a condition is met. + + Examples + -------- + >>> import numpy.ma as ma + >>> a = np.zeros((3, 3), dtype=int) + >>> a[1, 1] = 1 + >>> a + array([[0, 0, 0], + [0, 1, 0], + [0, 0, 0]]) + >>> a = ma.masked_equal(a, 1) + >>> a + masked_array( + data=[[0, 0, 0], + [0, --, 0], + [0, 0, 0]], + mask=[[False, False, False], + [False, True, False], + [False, False, False]], + fill_value=1) + >>> ma.mask_cols(a) + masked_array( + data=[[0, --, 0], + [0, --, 0], + [0, --, 0]], + mask=[[False, True, False], + [False, True, False], + [False, True, False]], + fill_value=1) + + """ + if axis is not np._NoValue: + # remove the axis argument when this deprecation expires + # NumPy 1.18.0, 2019-11-28 + warnings.warn( + "The axis argument has always been ignored, in future passing it " + "will raise TypeError", DeprecationWarning, stacklevel=2) + return mask_rowcols(a, 1) + + +#####-------------------------------------------------------------------------- +#---- --- arraysetops --- +#####-------------------------------------------------------------------------- + +def ediff1d(arr, to_end=None, to_begin=None): + """ + Compute the differences between consecutive elements of an array. + + This function is the equivalent of `numpy.ediff1d` that takes masked + values into account, see `numpy.ediff1d` for details. + + See Also + -------- + numpy.ediff1d : Equivalent function for ndarrays. + + """ + arr = ma.asanyarray(arr).flat + ed = arr[1:] - arr[:-1] + arrays = [ed] + # + if to_begin is not None: + arrays.insert(0, to_begin) + if to_end is not None: + arrays.append(to_end) + # + if len(arrays) != 1: + # We'll save ourselves a copy of a potentially large array in the common + # case where neither to_begin or to_end was given. + ed = hstack(arrays) + # + return ed + + +def unique(ar1, return_index=False, return_inverse=False): + """ + Finds the unique elements of an array. + + Masked values are considered the same element (masked). The output array + is always a masked array. See `numpy.unique` for more details. + + See Also + -------- + numpy.unique : Equivalent function for ndarrays. + + Examples + -------- + >>> import numpy.ma as ma + >>> a = [1, 2, 1000, 2, 3] + >>> mask = [0, 0, 1, 0, 0] + >>> masked_a = ma.masked_array(a, mask) + >>> masked_a + masked_array(data=[1, 2, --, 2, 3], + mask=[False, False, True, False, False], + fill_value=999999) + >>> ma.unique(masked_a) + masked_array(data=[1, 2, 3, --], + mask=[False, False, False, True], + fill_value=999999) + >>> ma.unique(masked_a, return_index=True) + (masked_array(data=[1, 2, 3, --], + mask=[False, False, False, True], + fill_value=999999), array([0, 1, 4, 2])) + >>> ma.unique(masked_a, return_inverse=True) + (masked_array(data=[1, 2, 3, --], + mask=[False, False, False, True], + fill_value=999999), array([0, 1, 3, 1, 2])) + >>> ma.unique(masked_a, return_index=True, return_inverse=True) + (masked_array(data=[1, 2, 3, --], + mask=[False, False, False, True], + fill_value=999999), array([0, 1, 4, 2]), array([0, 1, 3, 1, 2])) + """ + output = np.unique(ar1, + return_index=return_index, + return_inverse=return_inverse) + if isinstance(output, tuple): + output = list(output) + output[0] = output[0].view(MaskedArray) + output = tuple(output) + else: + output = output.view(MaskedArray) + return output + + +def intersect1d(ar1, ar2, assume_unique=False): + """ + Returns the unique elements common to both arrays. + + Masked values are considered equal one to the other. + The output is always a masked array. + + See `numpy.intersect1d` for more details. + + See Also + -------- + numpy.intersect1d : Equivalent function for ndarrays. + + Examples + -------- + >>> x = np.ma.array([1, 3, 3, 3], mask=[0, 0, 0, 1]) + >>> y = np.ma.array([3, 1, 1, 1], mask=[0, 0, 0, 1]) + >>> np.ma.intersect1d(x, y) + masked_array(data=[1, 3, --], + mask=[False, False, True], + fill_value=999999) + + """ + if assume_unique: + aux = ma.concatenate((ar1, ar2)) + else: + # Might be faster than unique( intersect1d( ar1, ar2 ) )? + aux = ma.concatenate((unique(ar1), unique(ar2))) + aux.sort() + return aux[:-1][aux[1:] == aux[:-1]] + + +def setxor1d(ar1, ar2, assume_unique=False): + """ + Set exclusive-or of 1-D arrays with unique elements. + + The output is always a masked array. See `numpy.setxor1d` for more details. + + See Also + -------- + numpy.setxor1d : Equivalent function for ndarrays. + + """ + if not assume_unique: + ar1 = unique(ar1) + ar2 = unique(ar2) + + aux = ma.concatenate((ar1, ar2)) + if aux.size == 0: + return aux + aux.sort() + auxf = aux.filled() +# flag = ediff1d( aux, to_end = 1, to_begin = 1 ) == 0 + flag = ma.concatenate(([True], (auxf[1:] != auxf[:-1]), [True])) +# flag2 = ediff1d( flag ) == 0 + flag2 = (flag[1:] == flag[:-1]) + return aux[flag2] + + +def in1d(ar1, ar2, assume_unique=False, invert=False): + """ + Test whether each element of an array is also present in a second + array. + + The output is always a masked array. See `numpy.in1d` for more details. + + We recommend using :func:`isin` instead of `in1d` for new code. + + See Also + -------- + isin : Version of this function that preserves the shape of ar1. + numpy.in1d : Equivalent function for ndarrays. + + Notes + ----- + .. versionadded:: 1.4.0 + + """ + if not assume_unique: + ar1, rev_idx = unique(ar1, return_inverse=True) + ar2 = unique(ar2) + + ar = ma.concatenate((ar1, ar2)) + # We need this to be a stable sort, so always use 'mergesort' + # here. The values from the first array should always come before + # the values from the second array. + order = ar.argsort(kind='mergesort') + sar = ar[order] + if invert: + bool_ar = (sar[1:] != sar[:-1]) + else: + bool_ar = (sar[1:] == sar[:-1]) + flag = ma.concatenate((bool_ar, [invert])) + indx = order.argsort(kind='mergesort')[:len(ar1)] + + if assume_unique: + return flag[indx] + else: + return flag[indx][rev_idx] + + +def isin(element, test_elements, assume_unique=False, invert=False): + """ + Calculates `element in test_elements`, broadcasting over + `element` only. + + The output is always a masked array of the same shape as `element`. + See `numpy.isin` for more details. + + See Also + -------- + in1d : Flattened version of this function. + numpy.isin : Equivalent function for ndarrays. + + Notes + ----- + .. versionadded:: 1.13.0 + + """ + element = ma.asarray(element) + return in1d(element, test_elements, assume_unique=assume_unique, + invert=invert).reshape(element.shape) + + +def union1d(ar1, ar2): + """ + Union of two arrays. + + The output is always a masked array. See `numpy.union1d` for more details. + + See Also + -------- + numpy.union1d : Equivalent function for ndarrays. + + """ + return unique(ma.concatenate((ar1, ar2), axis=None)) + + +def setdiff1d(ar1, ar2, assume_unique=False): + """ + Set difference of 1D arrays with unique elements. + + The output is always a masked array. See `numpy.setdiff1d` for more + details. + + See Also + -------- + numpy.setdiff1d : Equivalent function for ndarrays. + + Examples + -------- + >>> x = np.ma.array([1, 2, 3, 4], mask=[0, 1, 0, 1]) + >>> np.ma.setdiff1d(x, [1, 2]) + masked_array(data=[3, --], + mask=[False, True], + fill_value=999999) + + """ + if assume_unique: + ar1 = ma.asarray(ar1).ravel() + else: + ar1 = unique(ar1) + ar2 = unique(ar2) + return ar1[in1d(ar1, ar2, assume_unique=True, invert=True)] + + +############################################################################### +# Covariance # +############################################################################### + + +def _covhelper(x, y=None, rowvar=True, allow_masked=True): + """ + Private function for the computation of covariance and correlation + coefficients. + + """ + x = ma.array(x, ndmin=2, copy=True, dtype=float) + xmask = ma.getmaskarray(x) + # Quick exit if we can't process masked data + if not allow_masked and xmask.any(): + raise ValueError("Cannot process masked data.") + # + if x.shape[0] == 1: + rowvar = True + # Make sure that rowvar is either 0 or 1 + rowvar = int(bool(rowvar)) + axis = 1 - rowvar + if rowvar: + tup = (slice(None), None) + else: + tup = (None, slice(None)) + # + if y is None: + xnotmask = np.logical_not(xmask).astype(int) + else: + y = array(y, copy=False, ndmin=2, dtype=float) + ymask = ma.getmaskarray(y) + if not allow_masked and ymask.any(): + raise ValueError("Cannot process masked data.") + if xmask.any() or ymask.any(): + if y.shape == x.shape: + # Define some common mask + common_mask = np.logical_or(xmask, ymask) + if common_mask is not nomask: + xmask = x._mask = y._mask = ymask = common_mask + x._sharedmask = False + y._sharedmask = False + x = ma.concatenate((x, y), axis) + xnotmask = np.logical_not(np.concatenate((xmask, ymask), axis)).astype(int) + x -= x.mean(axis=rowvar)[tup] + return (x, xnotmask, rowvar) + + +def cov(x, y=None, rowvar=True, bias=False, allow_masked=True, ddof=None): + """ + Estimate the covariance matrix. + + Except for the handling of missing data this function does the same as + `numpy.cov`. For more details and examples, see `numpy.cov`. + + By default, masked values are recognized as such. If `x` and `y` have the + same shape, a common mask is allocated: if ``x[i,j]`` is masked, then + ``y[i,j]`` will also be masked. + Setting `allow_masked` to False will raise an exception if values are + missing in either of the input arrays. + + Parameters + ---------- + x : array_like + A 1-D or 2-D array containing multiple variables and observations. + Each row of `x` represents a variable, and each column a single + observation of all those variables. Also see `rowvar` below. + y : array_like, optional + An additional set of variables and observations. `y` has the same + shape as `x`. + rowvar : bool, optional + If `rowvar` is True (default), then each row represents a + variable, with observations in the columns. Otherwise, the relationship + is transposed: each column represents a variable, while the rows + contain observations. + bias : bool, optional + Default normalization (False) is by ``(N-1)``, where ``N`` is the + number of observations given (unbiased estimate). If `bias` is True, + then normalization is by ``N``. This keyword can be overridden by + the keyword ``ddof`` in numpy versions >= 1.5. + allow_masked : bool, optional + If True, masked values are propagated pair-wise: if a value is masked + in `x`, the corresponding value is masked in `y`. + If False, raises a `ValueError` exception when some values are missing. + ddof : {None, int}, optional + If not ``None`` normalization is by ``(N - ddof)``, where ``N`` is + the number of observations; this overrides the value implied by + ``bias``. The default value is ``None``. + + .. versionadded:: 1.5 + + Raises + ------ + ValueError + Raised if some values are missing and `allow_masked` is False. + + See Also + -------- + numpy.cov + + """ + # Check inputs + if ddof is not None and ddof != int(ddof): + raise ValueError("ddof must be an integer") + # Set up ddof + if ddof is None: + if bias: + ddof = 0 + else: + ddof = 1 + + (x, xnotmask, rowvar) = _covhelper(x, y, rowvar, allow_masked) + if not rowvar: + fact = np.dot(xnotmask.T, xnotmask) * 1. - ddof + result = (dot(x.T, x.conj(), strict=False) / fact).squeeze() + else: + fact = np.dot(xnotmask, xnotmask.T) * 1. - ddof + result = (dot(x, x.T.conj(), strict=False) / fact).squeeze() + return result + + +def corrcoef(x, y=None, rowvar=True, bias=np._NoValue, allow_masked=True, + ddof=np._NoValue): + """ + Return Pearson product-moment correlation coefficients. + + Except for the handling of missing data this function does the same as + `numpy.corrcoef`. For more details and examples, see `numpy.corrcoef`. + + Parameters + ---------- + x : array_like + A 1-D or 2-D array containing multiple variables and observations. + Each row of `x` represents a variable, and each column a single + observation of all those variables. Also see `rowvar` below. + y : array_like, optional + An additional set of variables and observations. `y` has the same + shape as `x`. + rowvar : bool, optional + If `rowvar` is True (default), then each row represents a + variable, with observations in the columns. Otherwise, the relationship + is transposed: each column represents a variable, while the rows + contain observations. + bias : _NoValue, optional + Has no effect, do not use. + + .. deprecated:: 1.10.0 + allow_masked : bool, optional + If True, masked values are propagated pair-wise: if a value is masked + in `x`, the corresponding value is masked in `y`. + If False, raises an exception. Because `bias` is deprecated, this + argument needs to be treated as keyword only to avoid a warning. + ddof : _NoValue, optional + Has no effect, do not use. + + .. deprecated:: 1.10.0 + + See Also + -------- + numpy.corrcoef : Equivalent function in top-level NumPy module. + cov : Estimate the covariance matrix. + + Notes + ----- + This function accepts but discards arguments `bias` and `ddof`. This is + for backwards compatibility with previous versions of this function. These + arguments had no effect on the return values of the function and can be + safely ignored in this and previous versions of numpy. + """ + msg = 'bias and ddof have no effect and are deprecated' + if bias is not np._NoValue or ddof is not np._NoValue: + # 2015-03-15, 1.10 + warnings.warn(msg, DeprecationWarning, stacklevel=2) + # Get the data + (x, xnotmask, rowvar) = _covhelper(x, y, rowvar, allow_masked) + # Compute the covariance matrix + if not rowvar: + fact = np.dot(xnotmask.T, xnotmask) * 1. + c = (dot(x.T, x.conj(), strict=False) / fact).squeeze() + else: + fact = np.dot(xnotmask, xnotmask.T) * 1. + c = (dot(x, x.T.conj(), strict=False) / fact).squeeze() + # Check whether we have a scalar + try: + diag = ma.diagonal(c) + except ValueError: + return 1 + # + if xnotmask.all(): + _denom = ma.sqrt(ma.multiply.outer(diag, diag)) + else: + _denom = diagflat(diag) + _denom._sharedmask = False # We know return is always a copy + n = x.shape[1 - rowvar] + if rowvar: + for i in range(n - 1): + for j in range(i + 1, n): + _x = mask_cols(vstack((x[i], x[j]))).var(axis=1) + _denom[i, j] = _denom[j, i] = ma.sqrt(ma.multiply.reduce(_x)) + else: + for i in range(n - 1): + for j in range(i + 1, n): + _x = mask_cols( + vstack((x[:, i], x[:, j]))).var(axis=1) + _denom[i, j] = _denom[j, i] = ma.sqrt(ma.multiply.reduce(_x)) + return c / _denom + +#####-------------------------------------------------------------------------- +#---- --- Concatenation helpers --- +#####-------------------------------------------------------------------------- + +class MAxisConcatenator(AxisConcatenator): + """ + Translate slice objects to concatenation along an axis. + + For documentation on usage, see `mr_class`. + + See Also + -------- + mr_class + + """ + concatenate = staticmethod(concatenate) + + @classmethod + def makemat(cls, arr): + # There used to be a view as np.matrix here, but we may eventually + # deprecate that class. In preparation, we use the unmasked version + # to construct the matrix (with copy=False for backwards compatibility + # with the .view) + data = super().makemat(arr.data, copy=False) + return array(data, mask=arr.mask) + + def __getitem__(self, key): + # matrix builder syntax, like 'a, b; c, d' + if isinstance(key, str): + raise MAError("Unavailable for masked array.") + + return super().__getitem__(key) + + +class mr_class(MAxisConcatenator): + """ + Translate slice objects to concatenation along the first axis. + + This is the masked array version of `lib.index_tricks.RClass`. + + See Also + -------- + lib.index_tricks.RClass + + Examples + -------- + >>> np.ma.mr_[np.ma.array([1,2,3]), 0, 0, np.ma.array([4,5,6])] + masked_array(data=[1, 2, 3, ..., 4, 5, 6], + mask=False, + fill_value=999999) + + """ + def __init__(self): + MAxisConcatenator.__init__(self, 0) + +mr_ = mr_class() + + +#####-------------------------------------------------------------------------- +#---- Find unmasked data --- +#####-------------------------------------------------------------------------- + +def ndenumerate(a, compressed=True): + """ + Multidimensional index iterator. + + Return an iterator yielding pairs of array coordinates and values, + skipping elements that are masked. With `compressed=False`, + `ma.masked` is yielded as the value of masked elements. This + behavior differs from that of `numpy.ndenumerate`, which yields the + value of the underlying data array. + + Notes + ----- + .. versionadded:: 1.23.0 + + Parameters + ---------- + a : array_like + An array with (possibly) masked elements. + compressed : bool, optional + If True (default), masked elements are skipped. + + See Also + -------- + numpy.ndenumerate : Equivalent function ignoring any mask. + + Examples + -------- + >>> a = np.ma.arange(9).reshape((3, 3)) + >>> a[1, 0] = np.ma.masked + >>> a[1, 2] = np.ma.masked + >>> a[2, 1] = np.ma.masked + >>> a + masked_array( + data=[[0, 1, 2], + [--, 4, --], + [6, --, 8]], + mask=[[False, False, False], + [ True, False, True], + [False, True, False]], + fill_value=999999) + >>> for index, x in np.ma.ndenumerate(a): + ... print(index, x) + (0, 0) 0 + (0, 1) 1 + (0, 2) 2 + (1, 1) 4 + (2, 0) 6 + (2, 2) 8 + + >>> for index, x in np.ma.ndenumerate(a, compressed=False): + ... print(index, x) + (0, 0) 0 + (0, 1) 1 + (0, 2) 2 + (1, 0) -- + (1, 1) 4 + (1, 2) -- + (2, 0) 6 + (2, 1) -- + (2, 2) 8 + """ + for it, mask in zip(np.ndenumerate(a), getmaskarray(a).flat): + if not mask: + yield it + elif not compressed: + yield it[0], masked + + +def flatnotmasked_edges(a): + """ + Find the indices of the first and last unmasked values. + + Expects a 1-D `MaskedArray`, returns None if all values are masked. + + Parameters + ---------- + a : array_like + Input 1-D `MaskedArray` + + Returns + ------- + edges : ndarray or None + The indices of first and last non-masked value in the array. + Returns None if all values are masked. + + See Also + -------- + flatnotmasked_contiguous, notmasked_contiguous, notmasked_edges + clump_masked, clump_unmasked + + Notes + ----- + Only accepts 1-D arrays. + + Examples + -------- + >>> a = np.ma.arange(10) + >>> np.ma.flatnotmasked_edges(a) + array([0, 9]) + + >>> mask = (a < 3) | (a > 8) | (a == 5) + >>> a[mask] = np.ma.masked + >>> np.array(a[~a.mask]) + array([3, 4, 6, 7, 8]) + + >>> np.ma.flatnotmasked_edges(a) + array([3, 8]) + + >>> a[:] = np.ma.masked + >>> print(np.ma.flatnotmasked_edges(a)) + None + + """ + m = getmask(a) + if m is nomask or not np.any(m): + return np.array([0, a.size - 1]) + unmasked = np.flatnonzero(~m) + if len(unmasked) > 0: + return unmasked[[0, -1]] + else: + return None + + +def notmasked_edges(a, axis=None): + """ + Find the indices of the first and last unmasked values along an axis. + + If all values are masked, return None. Otherwise, return a list + of two tuples, corresponding to the indices of the first and last + unmasked values respectively. + + Parameters + ---------- + a : array_like + The input array. + axis : int, optional + Axis along which to perform the operation. + If None (default), applies to a flattened version of the array. + + Returns + ------- + edges : ndarray or list + An array of start and end indexes if there are any masked data in + the array. If there are no masked data in the array, `edges` is a + list of the first and last index. + + See Also + -------- + flatnotmasked_contiguous, flatnotmasked_edges, notmasked_contiguous + clump_masked, clump_unmasked + + Examples + -------- + >>> a = np.arange(9).reshape((3, 3)) + >>> m = np.zeros_like(a) + >>> m[1:, 1:] = 1 + + >>> am = np.ma.array(a, mask=m) + >>> np.array(am[~am.mask]) + array([0, 1, 2, 3, 6]) + + >>> np.ma.notmasked_edges(am) + array([0, 6]) + + """ + a = asarray(a) + if axis is None or a.ndim == 1: + return flatnotmasked_edges(a) + m = getmaskarray(a) + idx = array(np.indices(a.shape), mask=np.asarray([m] * a.ndim)) + return [tuple([idx[i].min(axis).compressed() for i in range(a.ndim)]), + tuple([idx[i].max(axis).compressed() for i in range(a.ndim)]), ] + + +def flatnotmasked_contiguous(a): + """ + Find contiguous unmasked data in a masked array. + + Parameters + ---------- + a : array_like + The input array. + + Returns + ------- + slice_list : list + A sorted sequence of `slice` objects (start index, end index). + + .. versionchanged:: 1.15.0 + Now returns an empty list instead of None for a fully masked array + + See Also + -------- + flatnotmasked_edges, notmasked_contiguous, notmasked_edges + clump_masked, clump_unmasked + + Notes + ----- + Only accepts 2-D arrays at most. + + Examples + -------- + >>> a = np.ma.arange(10) + >>> np.ma.flatnotmasked_contiguous(a) + [slice(0, 10, None)] + + >>> mask = (a < 3) | (a > 8) | (a == 5) + >>> a[mask] = np.ma.masked + >>> np.array(a[~a.mask]) + array([3, 4, 6, 7, 8]) + + >>> np.ma.flatnotmasked_contiguous(a) + [slice(3, 5, None), slice(6, 9, None)] + >>> a[:] = np.ma.masked + >>> np.ma.flatnotmasked_contiguous(a) + [] + + """ + m = getmask(a) + if m is nomask: + return [slice(0, a.size)] + i = 0 + result = [] + for (k, g) in itertools.groupby(m.ravel()): + n = len(list(g)) + if not k: + result.append(slice(i, i + n)) + i += n + return result + + +def notmasked_contiguous(a, axis=None): + """ + Find contiguous unmasked data in a masked array along the given axis. + + Parameters + ---------- + a : array_like + The input array. + axis : int, optional + Axis along which to perform the operation. + If None (default), applies to a flattened version of the array, and this + is the same as `flatnotmasked_contiguous`. + + Returns + ------- + endpoints : list + A list of slices (start and end indexes) of unmasked indexes + in the array. + + If the input is 2d and axis is specified, the result is a list of lists. + + See Also + -------- + flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges + clump_masked, clump_unmasked + + Notes + ----- + Only accepts 2-D arrays at most. + + Examples + -------- + >>> a = np.arange(12).reshape((3, 4)) + >>> mask = np.zeros_like(a) + >>> mask[1:, :-1] = 1; mask[0, 1] = 1; mask[-1, 0] = 0 + >>> ma = np.ma.array(a, mask=mask) + >>> ma + masked_array( + data=[[0, --, 2, 3], + [--, --, --, 7], + [8, --, --, 11]], + mask=[[False, True, False, False], + [ True, True, True, False], + [False, True, True, False]], + fill_value=999999) + >>> np.array(ma[~ma.mask]) + array([ 0, 2, 3, 7, 8, 11]) + + >>> np.ma.notmasked_contiguous(ma) + [slice(0, 1, None), slice(2, 4, None), slice(7, 9, None), slice(11, 12, None)] + + >>> np.ma.notmasked_contiguous(ma, axis=0) + [[slice(0, 1, None), slice(2, 3, None)], [], [slice(0, 1, None)], [slice(0, 3, None)]] + + >>> np.ma.notmasked_contiguous(ma, axis=1) + [[slice(0, 1, None), slice(2, 4, None)], [slice(3, 4, None)], [slice(0, 1, None), slice(3, 4, None)]] + + """ + a = asarray(a) + nd = a.ndim + if nd > 2: + raise NotImplementedError("Currently limited to at most 2D array.") + if axis is None or nd == 1: + return flatnotmasked_contiguous(a) + # + result = [] + # + other = (axis + 1) % 2 + idx = [0, 0] + idx[axis] = slice(None, None) + # + for i in range(a.shape[other]): + idx[other] = i + result.append(flatnotmasked_contiguous(a[tuple(idx)])) + return result + + +def _ezclump(mask): + """ + Finds the clumps (groups of data with the same values) for a 1D bool array. + + Returns a series of slices. + """ + if mask.ndim > 1: + mask = mask.ravel() + idx = (mask[1:] ^ mask[:-1]).nonzero() + idx = idx[0] + 1 + + if mask[0]: + if len(idx) == 0: + return [slice(0, mask.size)] + + r = [slice(0, idx[0])] + r.extend((slice(left, right) + for left, right in zip(idx[1:-1:2], idx[2::2]))) + else: + if len(idx) == 0: + return [] + + r = [slice(left, right) for left, right in zip(idx[:-1:2], idx[1::2])] + + if mask[-1]: + r.append(slice(idx[-1], mask.size)) + return r + + +def clump_unmasked(a): + """ + Return list of slices corresponding to the unmasked clumps of a 1-D array. + (A "clump" is defined as a contiguous region of the array). + + Parameters + ---------- + a : ndarray + A one-dimensional masked array. + + Returns + ------- + slices : list of slice + The list of slices, one for each continuous region of unmasked + elements in `a`. + + Notes + ----- + .. versionadded:: 1.4.0 + + See Also + -------- + flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges + notmasked_contiguous, clump_masked + + Examples + -------- + >>> a = np.ma.masked_array(np.arange(10)) + >>> a[[0, 1, 2, 6, 8, 9]] = np.ma.masked + >>> np.ma.clump_unmasked(a) + [slice(3, 6, None), slice(7, 8, None)] + + """ + mask = getattr(a, '_mask', nomask) + if mask is nomask: + return [slice(0, a.size)] + return _ezclump(~mask) + + +def clump_masked(a): + """ + Returns a list of slices corresponding to the masked clumps of a 1-D array. + (A "clump" is defined as a contiguous region of the array). + + Parameters + ---------- + a : ndarray + A one-dimensional masked array. + + Returns + ------- + slices : list of slice + The list of slices, one for each continuous region of masked elements + in `a`. + + Notes + ----- + .. versionadded:: 1.4.0 + + See Also + -------- + flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges + notmasked_contiguous, clump_unmasked + + Examples + -------- + >>> a = np.ma.masked_array(np.arange(10)) + >>> a[[0, 1, 2, 6, 8, 9]] = np.ma.masked + >>> np.ma.clump_masked(a) + [slice(0, 3, None), slice(6, 7, None), slice(8, 10, None)] + + """ + mask = ma.getmask(a) + if mask is nomask: + return [] + return _ezclump(mask) + + +############################################################################### +# Polynomial fit # +############################################################################### + + +def vander(x, n=None): + """ + Masked values in the input array result in rows of zeros. + + """ + _vander = np.vander(x, n) + m = getmask(x) + if m is not nomask: + _vander[m] = 0 + return _vander + +vander.__doc__ = ma.doc_note(np.vander.__doc__, vander.__doc__) + + +def polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False): + """ + Any masked values in x is propagated in y, and vice-versa. + + """ + x = asarray(x) + y = asarray(y) + + m = getmask(x) + if y.ndim == 1: + m = mask_or(m, getmask(y)) + elif y.ndim == 2: + my = getmask(mask_rows(y)) + if my is not nomask: + m = mask_or(m, my[:, 0]) + else: + raise TypeError("Expected a 1D or 2D array for y!") + + if w is not None: + w = asarray(w) + if w.ndim != 1: + raise TypeError("expected a 1-d array for weights") + if w.shape[0] != y.shape[0]: + raise TypeError("expected w and y to have the same length") + m = mask_or(m, getmask(w)) + + if m is not nomask: + not_m = ~m + if w is not None: + w = w[not_m] + return np.polyfit(x[not_m], y[not_m], deg, rcond, full, w, cov) + else: + return np.polyfit(x, y, deg, rcond, full, w, cov) + +polyfit.__doc__ = ma.doc_note(np.polyfit.__doc__, polyfit.__doc__) diff --git a/shared/package-files/30/302ff52ffbfabb324bd1fcc7cc7138f361866317118dc130caba713d5b21c458/blob b/shared/package-files/30/302ff52ffbfabb324bd1fcc7cc7138f361866317118dc130caba713d5b21c458/blob new file mode 100644 index 0000000000000000000000000000000000000000..1cabcfeb31411795d634fff3060c4fcbc0132790 --- /dev/null +++ b/shared/package-files/30/302ff52ffbfabb324bd1fcc7cc7138f361866317118dc130caba713d5b21c458/blob @@ -0,0 +1,16 @@ +# file generated by setuptools_scm +# don't change, don't track in version control +TYPE_CHECKING = False +if TYPE_CHECKING: + from typing import Tuple, Union + VERSION_TUPLE = Tuple[Union[int, str], ...] +else: + VERSION_TUPLE = object + +version: str +__version__: str +__version_tuple__: VERSION_TUPLE +version_tuple: VERSION_TUPLE + +__version__ = version = '24.3.0' +__version_tuple__ = version_tuple = (24, 3, 0) diff --git a/shared/package-files/30/30324c2169b58c2b0139cbb076c873ab0684fffbaa5f4e7adae4a3c4586e7773/blob b/shared/package-files/30/30324c2169b58c2b0139cbb076c873ab0684fffbaa5f4e7adae4a3c4586e7773/blob new file mode 100644 index 0000000000000000000000000000000000000000..6402f77730cc841f3d622974caf2db9f7db61a7e --- /dev/null +++ b/shared/package-files/30/30324c2169b58c2b0139cbb076c873ab0684fffbaa5f4e7adae4a3c4586e7773/blob @@ -0,0 +1,193 @@ +import ctypes + +import numpy as np + +from numba.cuda.cudadrv import driver, drvapi, devices +from numba.cuda.testing import unittest, ContextResettingTestCase +from numba.cuda.testing import skip_on_cudasim + + +@skip_on_cudasim('CUDA Memory API unsupported in the simulator') +class TestCudaMemory(ContextResettingTestCase): + def setUp(self): + super().setUp() + self.context = devices.get_context() + + def tearDown(self): + del self.context + super(TestCudaMemory, self).tearDown() + + def _template(self, obj): + self.assertTrue(driver.is_device_memory(obj)) + driver.require_device_memory(obj) + if driver.USE_NV_BINDING: + expected_class = driver.binding.CUdeviceptr + else: + expected_class = drvapi.cu_device_ptr + self.assertTrue(isinstance(obj.device_ctypes_pointer, + expected_class)) + + def test_device_memory(self): + devmem = self.context.memalloc(1024) + self._template(devmem) + + def test_device_view(self): + devmem = self.context.memalloc(1024) + self._template(devmem.view(10)) + + def test_host_alloc(self): + devmem = self.context.memhostalloc(1024, mapped=True) + self._template(devmem) + + def test_pinned_memory(self): + ary = np.arange(10) + devmem = self.context.mempin(ary, ary.ctypes.data, + ary.size * ary.dtype.itemsize, + mapped=True) + self._template(devmem) + + def test_managed_memory(self): + devmem = self.context.memallocmanaged(1024) + self._template(devmem) + + def test_derived_pointer(self): + # Use MemoryPointer.view to create derived pointer + + def handle_val(mem): + if driver.USE_NV_BINDING: + return int(mem.handle) + else: + return mem.handle.value + + def check(m, offset): + # create view + v1 = m.view(offset) + self.assertEqual(handle_val(v1.owner), handle_val(m)) + self.assertEqual(m.refct, 2) + self.assertEqual(handle_val(v1) - offset, handle_val(v1.owner)) + # create a view + v2 = v1.view(offset) + self.assertEqual(handle_val(v2.owner), handle_val(m)) + self.assertEqual(handle_val(v2.owner), handle_val(m)) + self.assertEqual(handle_val(v2) - offset * 2, + handle_val(v2.owner)) + self.assertEqual(m.refct, 3) + del v2 + self.assertEqual(m.refct, 2) + del v1 + self.assertEqual(m.refct, 1) + + m = self.context.memalloc(1024) + check(m=m, offset=0) + check(m=m, offset=1) + + def test_user_extension(self): + # User can use MemoryPointer to wrap externally defined pointers. + # This test checks if the finalizer is invokded at correct time + fake_ptr = ctypes.c_void_p(0xdeadbeef) + dtor_invoked = [0] + + def dtor(): + dtor_invoked[0] += 1 + + # Ensure finalizer is called when pointer is deleted + ptr = driver.MemoryPointer(context=self.context, pointer=fake_ptr, + size=40, finalizer=dtor) + self.assertEqual(dtor_invoked[0], 0) + del ptr + self.assertEqual(dtor_invoked[0], 1) + + # Ensure removing derived pointer doesn't call finalizer + ptr = driver.MemoryPointer(context=self.context, pointer=fake_ptr, + size=40, finalizer=dtor) + owned = ptr.own() + del owned + self.assertEqual(dtor_invoked[0], 1) + del ptr + self.assertEqual(dtor_invoked[0], 2) + + +class TestCudaMemoryFunctions(ContextResettingTestCase): + def setUp(self): + super().setUp() + self.context = devices.get_context() + + def tearDown(self): + del self.context + super(TestCudaMemoryFunctions, self).tearDown() + + def test_memcpy(self): + hstary = np.arange(100, dtype=np.uint32) + hstary2 = np.arange(100, dtype=np.uint32) + sz = hstary.size * hstary.dtype.itemsize + devary = self.context.memalloc(sz) + + driver.host_to_device(devary, hstary, sz) + driver.device_to_host(hstary2, devary, sz) + + self.assertTrue(np.all(hstary == hstary2)) + + def test_memset(self): + dtype = np.dtype('uint32') + n = 10 + sz = dtype.itemsize * 10 + devary = self.context.memalloc(sz) + driver.device_memset(devary, 0xab, sz) + + hstary = np.empty(n, dtype=dtype) + driver.device_to_host(hstary, devary, sz) + + hstary2 = np.array([0xabababab] * n, dtype=np.dtype('uint32')) + self.assertTrue(np.all(hstary == hstary2)) + + def test_d2d(self): + hst = np.arange(100, dtype=np.uint32) + hst2 = np.empty_like(hst) + sz = hst.size * hst.dtype.itemsize + dev1 = self.context.memalloc(sz) + dev2 = self.context.memalloc(sz) + driver.host_to_device(dev1, hst, sz) + driver.device_to_device(dev2, dev1, sz) + driver.device_to_host(hst2, dev2, sz) + self.assertTrue(np.all(hst == hst2)) + + +@skip_on_cudasim('CUDA Memory API unsupported in the simulator') +class TestMVExtent(ContextResettingTestCase): + def test_c_contiguous_array(self): + ary = np.arange(100) + arysz = ary.dtype.itemsize * ary.size + s, e = driver.host_memory_extents(ary) + self.assertTrue(ary.ctypes.data == s) + self.assertTrue(arysz == driver.host_memory_size(ary)) + + def test_f_contiguous_array(self): + ary = np.asfortranarray(np.arange(100).reshape(2, 50)) + arysz = ary.dtype.itemsize * np.prod(ary.shape) + s, e = driver.host_memory_extents(ary) + self.assertTrue(ary.ctypes.data == s) + self.assertTrue(arysz == driver.host_memory_size(ary)) + + def test_single_element_array(self): + ary = np.asarray(np.uint32(1234)) + arysz = ary.dtype.itemsize + s, e = driver.host_memory_extents(ary) + self.assertTrue(ary.ctypes.data == s) + self.assertTrue(arysz == driver.host_memory_size(ary)) + + def test_ctypes_struct(self): + class mystruct(ctypes.Structure): + _fields_ = [('x', ctypes.c_int), ('y', ctypes.c_int)] + + data = mystruct(x=123, y=432) + sz = driver.host_memory_size(data) + self.assertTrue(ctypes.sizeof(data) == sz) + + def test_ctypes_double(self): + data = ctypes.c_double(1.234) + sz = driver.host_memory_size(data) + self.assertTrue(ctypes.sizeof(data) == sz) + + +if __name__ == '__main__': + unittest.main() diff --git a/shared/package-files/30/303574d9bdd85c757d6025017942bf17baeedf2778f62bd7f425d07d880f4c4a/blob b/shared/package-files/30/303574d9bdd85c757d6025017942bf17baeedf2778f62bd7f425d07d880f4c4a/blob new file mode 100644 index 0000000000000000000000000000000000000000..e1720e0fb70684043842e94ede48622e6bffc62d --- /dev/null +++ b/shared/package-files/30/303574d9bdd85c757d6025017942bf17baeedf2778f62bd7f425d07d880f4c4a/blob @@ -0,0 +1,27 @@ +Copyright (c) 2014, Jonathan Slenders +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, this + list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. + +* Neither the name of the {organization} nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/shared/package-files/30/3035af27387a4ced2e7629c60b9185254282bf5a984929a70238147b7afcb12c/blob b/shared/package-files/30/3035af27387a4ced2e7629c60b9185254282bf5a984929a70238147b7afcb12c/blob new file mode 100644 index 0000000000000000000000000000000000000000..26cea6420d87a086ad0b30d93ef3e36f4638fed4 --- /dev/null +++ b/shared/package-files/30/3035af27387a4ced2e7629c60b9185254282bf5a984929a70238147b7afcb12c/blob @@ -0,0 +1,193 @@ +from itertools import product + +import numpy as np +import pandas as pd +import pytest + +from statsmodels.tsa.forecasting.theta import ThetaModel + +SMOKE_PARAMS = list(product(["array", "dataframe", "series"], [True, False])) +SMOKE_IDS = [f"type: {typ}, exponential: {exp}" for typ, exp in SMOKE_PARAMS] + + +@pytest.fixture(params=SMOKE_PARAMS, ids=SMOKE_IDS) +def data(request): + rs = np.random.RandomState([3290328901, 323293105, 121029109]) + scale = 0.01 if request.param[1] else 1 + y = np.cumsum(scale + scale * rs.standard_normal(300)) + if request.param[1]: + y = np.exp(y) + index = pd.date_range("2000-01-01", periods=300) + if request.param[0] == "array": + return y + elif request.param[0] == "dataframe": + return pd.DataFrame(y[:, None], columns=["y"], index=index) + else: + return pd.Series(y, name="y", index=index) + + +@pytest.fixture(params=["datetime", "period", "range", "nofreq"]) +def indexed_data(request): + rs = np.random.RandomState([3290328901, 323293105, 121029109]) + scale = 0.01 + y = np.cumsum(scale + scale * rs.standard_normal(300)) + y = np.exp(y) + if request.param == "datetime": + index = pd.date_range("2000-1-1", periods=300) + elif request.param == "period": + index = pd.period_range("2000-1-1", periods=300, freq="M") + elif request.param == "range": + index = pd.RangeIndex(100, 100 + 2 * 300, 2) + else: # request.param == "nofreq" + index = pd.date_range("2000-1-1", periods=1000) + locs = np.unique(rs.randint(0, 1000, size=500)) + index = index[locs[:300]] + return pd.Series(y, index=index, name=f"y_{request.param}") + + +@pytest.mark.smoke +@pytest.mark.parametrize("period", [None, 4, 12]) +@pytest.mark.parametrize("use_mle", [True, False]) +@pytest.mark.parametrize("deseasonalize", [True, False]) +@pytest.mark.parametrize("use_test", [True, False]) +@pytest.mark.parametrize("diff", [True, False]) +@pytest.mark.parametrize("model", ["auto", "additive", "multiplicative"]) +def test_smoke(data, period, use_mle, deseasonalize, use_test, diff, model): + if period is None and isinstance(data, np.ndarray): + return + res = ThetaModel( + data, + period=period, + deseasonalize=deseasonalize, + use_test=use_test, + difference=diff, + method=model, + ).fit(use_mle=use_mle) + assert "b0" in str(res.summary()) + res.forecast(36) + res.forecast_components(47) + assert res.model.use_test is (use_test and res.model.deseasonalize) + assert res.model.difference is diff + + +@pytest.mark.smoke +def test_alt_index(indexed_data): + idx = indexed_data.index + date_like = not hasattr(idx, "freq") or getattr(idx, "freq", None) is None + period = 12 if date_like else None + res = ThetaModel(indexed_data, period=period).fit() + if hasattr(idx, "freq") and idx.freq is None: + with pytest.warns(UserWarning, match="Only PeriodIndexes, DatetimeIndexes"): + res.forecast_components(37) + with pytest.warns(UserWarning, match="Only PeriodIndexes, DatetimeIndexes"): + res.forecast(23) + else: + res.forecast_components(37) + res.forecast(23) + + +def test_no_freq(): + rs = np.random.RandomState(3231298) + idx = pd.date_range("2000-1-1", periods=300) + locs = [] + for i in range(100): + locs.append(2 * i + int((i % 2) == 1)) + y = pd.Series(rs.standard_normal(100), index=idx[locs]) + with pytest.raises(ValueError, match="You must specify a period or"): + ThetaModel(y) + + +def test_forecast_errors(data): + res = ThetaModel(data, period=12).fit() + with pytest.raises(ValueError, match="steps must be a positive integer"): + res.forecast(-1) + with pytest.raises(ValueError, match="theta must be a float"): + res.forecast(7, theta=0.99) + with pytest.raises(ValueError, match="steps must be a positive integer"): + res.forecast_components(0) + + +def test_pi_width(): + # GH 7075 + rs = np.random.RandomState(1233091) + y = np.arange(100) + rs.standard_normal(100) + + th = ThetaModel(y, period=12, deseasonalize=False) + res = th.fit() + pi = res.prediction_intervals(24) + d = np.squeeze(np.diff(np.asarray(pi), axis=1)) + assert np.all(np.diff(d) > 0) + + +# GH7544 +@pytest.mark.parametrize("period", [4, 12]) +def test_forecast_seasonal_alignment(data, period): + res = ThetaModel( + data, + period=period, + deseasonalize=True, + use_test=False, + difference=False, + ).fit(use_mle=False) + seasonal = res._seasonal + comp = res.forecast_components(32) + index = np.arange(data.shape[0], data.shape[0] + comp.shape[0]) + expected = seasonal[index % period] + np.testing.assert_allclose(comp.seasonal, expected) + + +def test_auto(): + rs = np.random.RandomState(232387289) + m = 250 + e = rs.standard_normal(m) + s = 10 * np.sin(np.linspace(0, np.pi, 12)) + s = np.tile(s, (m // 12 + 1))[:m] + idx = pd.period_range("2000-01-01", freq="M", periods=m) + x = e + s + y = pd.DataFrame(10 + x - x.min(), index=idx) + + tm = ThetaModel(y, method="auto") + assert tm.method == "mul" + res = tm.fit() + + tm = ThetaModel(y, method="mul") + assert tm.method == "mul" + res2 = tm.fit() + + np.testing.assert_allclose(res.params, res2.params, rtol=1e-4) + + tm = ThetaModel(y - y.mean(), method="auto") + assert tm.method == "add" + res3 = tm.fit() + + assert not np.allclose(res.params, res3.params) + + +@pytest.mark.thread_unsafe(reason="Uses matplotlib") +@pytest.mark.matplotlib +def test_plot_predict(close_figures): + rs = np.random.RandomState([3290328901, 323293105, 121029109]) + y = np.cumsum(0.01 + 0.01 * rs.standard_normal(300)) + index = pd.date_range("2000-01-01", periods=300) + y = pd.Series(np.exp(y), index=index, name="y") + + res = ThetaModel(y, period=7).fit() + + fig = res.plot_predict(steps=12) + ax = fig.axes[0] + # forecast line covers the requested horizon + forecast_lines = [ln for ln in ax.get_lines() if len(ln.get_ydata()) == 12] + assert len(forecast_lines) >= 1 + fc = res.forecast(steps=12) + np.testing.assert_allclose(forecast_lines[0].get_ydata(), fc.values) + + # alpha=None must omit the confidence interval fill + fig_noci = res.plot_predict(steps=12, alpha=None) + assert len(fig_noci.axes[0].collections) == 0 + fig_ci = res.plot_predict(steps=12, alpha=0.05) + assert len(fig_ci.axes[0].collections) >= 1 + + fig_hist = res.plot_predict(steps=12, in_sample=True) + in_sample_lines = [ln for ln in fig_hist.axes[0].get_lines() + if len(ln.get_ydata()) == len(y)] + assert len(in_sample_lines) >= 1 diff --git a/shared/package-files/30/303697f62428adbea76072888ec4b5d2aab43e64be87cfdff8c5775c72f7e544/blob b/shared/package-files/30/303697f62428adbea76072888ec4b5d2aab43e64be87cfdff8c5775c72f7e544/blob new file mode 100644 index 0000000000000000000000000000000000000000..437262793e8f94b229671978b23a638820ff1290 --- /dev/null +++ b/shared/package-files/30/303697f62428adbea76072888ec4b5d2aab43e64be87cfdff8c5775c72f7e544/blob @@ -0,0 +1,257 @@ +/* Translated into C++ by SciPy developers in 2024. + * Original header with Copyright information appears below. + */ + +/* beta.c + * + * Beta function + * + * + * + * SYNOPSIS: + * + * double a, b, y, beta(); + * + * y = beta( a, b ); + * + * + * + * DESCRIPTION: + * + * - - + * | (a) | (b) + * beta( a, b ) = -----------. + * - + * | (a+b) + * + * For large arguments the logarithm of the function is + * evaluated using lgam(), then exponentiated. + * + * + * + * ACCURACY: + * + * Relative error: + * arithmetic domain # trials peak rms + * IEEE 0,30 30000 8.1e-14 1.1e-14 + * + * ERROR MESSAGES: + * + * message condition value returned + * beta overflow log(beta) > MAXLOG 0.0 + * a or b <0 integer 0.0 + * + */ + +/* + * Cephes Math Library Release 2.0: April, 1987 + * Copyright 1984, 1987 by Stephen L. Moshier + * Direct inquiries to 30 Frost Street, Cambridge, MA 02140 + */ +#pragma once + +#include "../config.h" +#include "const.h" +#include "gamma.h" +#include "rgamma.h" + +namespace xsf { +namespace cephes { + + XSF_HOST_DEVICE double beta(double, double); + XSF_HOST_DEVICE double lbeta(double, double); + + namespace detail { + constexpr double beta_ASYMP_FACTOR = 1e6; + + /* + * Asymptotic expansion for ln(|B(a, b)|) for a > ASYMP_FACTOR*max(|b|, 1). + */ + XSF_HOST_DEVICE inline double lbeta_asymp(double a, double b, int *sgn) { + double r = lgam_sgn(b, sgn); + r -= b * std::log(a); + + r += b * (1 - b) / (2 * a); + r += b * (1 - b) * (1 - 2 * b) / (12 * a * a); + r += -b * b * (1 - b) * (1 - b) / (12 * a * a * a); + + return r; + } + + /* + * Special case for a negative integer argument + */ + + XSF_HOST_DEVICE inline double beta_negint(int a, double b) { + int sgn; + if (b == static_cast(b) && 1 - a - b > 0) { + sgn = (static_cast(b) % 2 == 0) ? 1 : -1; + return sgn * xsf::cephes::beta(1 - a - b, b); + } else { + set_error("lbeta", SF_ERROR_OVERFLOW, NULL); + return std::numeric_limits::infinity(); + } + } + + XSF_HOST_DEVICE inline double lbeta_negint(int a, double b) { + double r; + if (b == static_cast(b) && 1 - a - b > 0) { + r = xsf::cephes::lbeta(1 - a - b, b); + return r; + } else { + set_error("lbeta", SF_ERROR_OVERFLOW, NULL); + return std::numeric_limits::infinity(); + } + } + } // namespace detail + + XSF_HOST_DEVICE inline double beta(double a, double b) { + double y; + int sign = 1; + + if (a <= 0.0) { + if (a == std::floor(a)) { + if (a == static_cast(a)) { + return detail::beta_negint(static_cast(a), b); + } else { + goto overflow; + } + } + } + + if (b <= 0.0) { + if (b == std::floor(b)) { + if (b == static_cast(b)) { + return detail::beta_negint(static_cast(b), a); + } else { + goto overflow; + } + } + } + + if (std::abs(a) < std::abs(b)) { + y = a; + a = b; + b = y; + } + + if (std::abs(a) > detail::beta_ASYMP_FACTOR * std::abs(b) && a > detail::beta_ASYMP_FACTOR) { + /* Avoid loss of precision in lgam(a + b) - lgam(a) */ + y = detail::lbeta_asymp(a, b, &sign); + return sign * std::exp(y); + } + + y = a + b; + if (std::abs(y) > detail::MAXGAM || std::abs(a) > detail::MAXGAM || std::abs(b) > detail::MAXGAM) { + int sgngam; + y = detail::lgam_sgn(y, &sgngam); + sign *= sgngam; /* keep track of the sign */ + y = detail::lgam_sgn(b, &sgngam) - y; + sign *= sgngam; + y = detail::lgam_sgn(a, &sgngam) + y; + sign *= sgngam; + if (y > detail::MAXLOG) { + goto overflow; + } + return (sign * std::exp(y)); + } + + y = rgamma(y); + a = Gamma(a); + b = Gamma(b); + if (std::isinf(y)) { + goto overflow; + } + + if (std::abs(std::abs(a*y) - 1.0) > std::abs(std::abs(b*y) - 1.0)) { + y = b * y; + y *= a; + } else { + y = a * y; + y *= b; + } + + return (y); + + overflow: + set_error("beta", SF_ERROR_OVERFLOW, NULL); + return (sign * std::numeric_limits::infinity()); + } + + /* Natural log of |beta|. */ + + XSF_HOST_DEVICE inline double lbeta(double a, double b) { + double y; + int sign; + + sign = 1; + + if (a <= 0.0) { + if (a == std::floor(a)) { + if (a == static_cast(a)) { + return detail::lbeta_negint(static_cast(a), b); + } else { + goto over; + } + } + } + + if (b <= 0.0) { + if (b == std::floor(b)) { + if (b == static_cast(b)) { + return detail::lbeta_negint(static_cast(b), a); + } else { + goto over; + } + } + } + + if (std::abs(a) < std::abs(b)) { + y = a; + a = b; + b = y; + } + + if (std::abs(a) > detail::beta_ASYMP_FACTOR * std::abs(b) && a > detail::beta_ASYMP_FACTOR) { + /* Avoid loss of precision in lgam(a + b) - lgam(a) */ + y = detail::lbeta_asymp(a, b, &sign); + return y; + } + + y = a + b; + if (std::abs(y) > detail::MAXGAM || std::abs(a) > detail::MAXGAM || std::abs(b) > detail::MAXGAM) { + int sgngam; + y = detail::lgam_sgn(y, &sgngam); + sign *= sgngam; /* keep track of the sign */ + y = detail::lgam_sgn(b, &sgngam) - y; + sign *= sgngam; + y = detail::lgam_sgn(a, &sgngam) + y; + sign *= sgngam; + return (y); + } + + y = rgamma(y); + a = Gamma(a); + b = Gamma(b); + if (std::isinf(y)) { + over: + set_error("lbeta", SF_ERROR_OVERFLOW, NULL); + return (sign * std::numeric_limits::infinity()); + } + + if (std::abs(std::abs(a*y) - 1.0) > std::abs(std::abs(b*y) - 1.0)) { + y = b * y; + y *= a; + } else { + y = a * y; + y *= b; + } + + if (y < 0) { + y = -y; + } + + return (std::log(y)); + } +} // namespace cephes +} // namespace xsf diff --git a/shared/package-files/30/303d3aa080851c379a9655fd2a1dfd6721e21bf74b72d97ff82890ed6c7c441a/blob b/shared/package-files/30/303d3aa080851c379a9655fd2a1dfd6721e21bf74b72d97ff82890ed6c7c441a/blob new file mode 100644 index 0000000000000000000000000000000000000000..2f660908ec14088af80803ecd2225d94fc5c8a0d --- /dev/null +++ b/shared/package-files/30/303d3aa080851c379a9655fd2a1dfd6721e21bf74b72d97ff82890ed6c7c441a/blob @@ -0,0 +1,25 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API at::Tensor zeros(at::IntArrayRef size, c10::optional names, c10::optional dtype={}, c10::optional layout={}, c10::optional device={}, c10::optional pin_memory={}); +TORCH_API at::Tensor & zeros_names_out(at::IntArrayRef size, c10::optional names, at::Tensor & out); +TORCH_API at::Tensor zeros_symint(c10::SymIntArrayRef size, c10::optional dtype={}, c10::optional layout={}, c10::optional device={}, c10::optional pin_memory={}); +TORCH_API at::Tensor & zeros_out(at::IntArrayRef size, at::Tensor & out); +TORCH_API at::Tensor & zeros_sparse_out(at::IntArrayRef size, at::Tensor & out); +} // namespace native +} // namespace at diff --git a/shared/package-files/30/303f075151f95d778018e9c55a0e5a573ff0fb6b5763009e5579b313186221e4/blob b/shared/package-files/30/303f075151f95d778018e9c55a0e5a573ff0fb6b5763009e5579b313186221e4/blob new file mode 100644 index 0000000000000000000000000000000000000000..6d961a9f53f6eb622726e55d7225551288b6f077 --- /dev/null +++ b/shared/package-files/30/303f075151f95d778018e9c55a0e5a573ff0fb6b5763009e5579b313186221e4/blob @@ -0,0 +1,33 @@ +# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license + +# Copyright (C) 2004-2007, 2009-2011 Nominum, Inc. +# +# Permission to use, copy, modify, and distribute this software and its +# documentation for any purpose with or without fee is hereby granted, +# provided that the above copyright notice and this permission notice +# appear in all copies. +# +# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES +# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR +# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +import dns.immutable +import dns.rdtypes.dnskeybase # lgtm[py/import-and-import-from] + +# pylint: disable=unused-import +from dns.rdtypes.dnskeybase import ( # noqa: F401 lgtm[py/unused-import] + REVOKE, + SEP, + ZONE, +) + +# pylint: enable=unused-import + + +@dns.immutable.immutable +class DNSKEY(dns.rdtypes.dnskeybase.DNSKEYBase): + """DNSKEY record""" diff --git a/shared/package-files/30/30414c2186ea0802bbf3db034122ddec1f8a10061b97c50871e14b74ee36d0ca/blob b/shared/package-files/30/30414c2186ea0802bbf3db034122ddec1f8a10061b97c50871e14b74ee36d0ca/blob new file mode 100644 index 0000000000000000000000000000000000000000..6753daf122df44ab9a4fb28b4fc493e2a521ddde --- /dev/null +++ b/shared/package-files/30/30414c2186ea0802bbf3db034122ddec1f8a10061b97c50871e14b74ee36d0ca/blob @@ -0,0 +1,307 @@ +""" Python Character Mapping Codec cp424 generated from 'MAPPINGS/VENDORS/MISC/CP424.TXT' with gencodec.py. + +"""#" + +import codecs + +### Codec APIs + +class Codec(codecs.Codec): + + def encode(self,input,errors='strict'): + return codecs.charmap_encode(input,errors,encoding_table) + + def decode(self,input,errors='strict'): + return codecs.charmap_decode(input,errors,decoding_table) + +class IncrementalEncoder(codecs.IncrementalEncoder): + def encode(self, input, final=False): + return codecs.charmap_encode(input,self.errors,encoding_table)[0] + +class IncrementalDecoder(codecs.IncrementalDecoder): + def decode(self, input, final=False): + return codecs.charmap_decode(input,self.errors,decoding_table)[0] + +class StreamWriter(Codec,codecs.StreamWriter): + pass + +class StreamReader(Codec,codecs.StreamReader): + pass + +### encodings module API + +def getregentry(): + return codecs.CodecInfo( + name='cp424', + encode=Codec().encode, + decode=Codec().decode, + incrementalencoder=IncrementalEncoder, + incrementaldecoder=IncrementalDecoder, + streamreader=StreamReader, + streamwriter=StreamWriter, + ) + + +### Decoding Table + +decoding_table = ( + '\x00' # 0x00 -> NULL + '\x01' # 0x01 -> START OF HEADING + '\x02' # 0x02 -> START OF TEXT + '\x03' # 0x03 -> END OF TEXT + '\x9c' # 0x04 -> SELECT + '\t' # 0x05 -> HORIZONTAL TABULATION + '\x86' # 0x06 -> REQUIRED NEW LINE + '\x7f' # 0x07 -> DELETE + '\x97' # 0x08 -> GRAPHIC ESCAPE + '\x8d' # 0x09 -> SUPERSCRIPT + '\x8e' # 0x0A -> REPEAT + '\x0b' # 0x0B -> VERTICAL TABULATION + '\x0c' # 0x0C -> FORM FEED + '\r' # 0x0D -> CARRIAGE RETURN + '\x0e' # 0x0E -> SHIFT OUT + '\x0f' # 0x0F -> SHIFT IN + '\x10' # 0x10 -> DATA LINK ESCAPE + '\x11' # 0x11 -> DEVICE CONTROL ONE + '\x12' # 0x12 -> DEVICE CONTROL TWO + '\x13' # 0x13 -> DEVICE CONTROL THREE + '\x9d' # 0x14 -> RESTORE/ENABLE PRESENTATION + '\x85' # 0x15 -> NEW LINE + '\x08' # 0x16 -> BACKSPACE + '\x87' # 0x17 -> PROGRAM OPERATOR COMMUNICATION + '\x18' # 0x18 -> CANCEL + '\x19' # 0x19 -> END OF MEDIUM + '\x92' # 0x1A -> UNIT BACK SPACE + '\x8f' # 0x1B -> CUSTOMER USE ONE + '\x1c' # 0x1C -> FILE SEPARATOR + '\x1d' # 0x1D -> GROUP SEPARATOR + '\x1e' # 0x1E -> RECORD SEPARATOR + '\x1f' # 0x1F -> UNIT SEPARATOR + '\x80' # 0x20 -> DIGIT SELECT + '\x81' # 0x21 -> START OF SIGNIFICANCE + '\x82' # 0x22 -> FIELD SEPARATOR + '\x83' # 0x23 -> WORD UNDERSCORE + '\x84' # 0x24 -> BYPASS OR INHIBIT PRESENTATION + '\n' # 0x25 -> LINE FEED + '\x17' # 0x26 -> END OF TRANSMISSION BLOCK + '\x1b' # 0x27 -> ESCAPE + '\x88' # 0x28 -> SET ATTRIBUTE + '\x89' # 0x29 -> START FIELD EXTENDED + '\x8a' # 0x2A -> SET MODE OR SWITCH + '\x8b' # 0x2B -> CONTROL SEQUENCE PREFIX + '\x8c' # 0x2C -> MODIFY FIELD ATTRIBUTE + '\x05' # 0x2D -> ENQUIRY + '\x06' # 0x2E -> ACKNOWLEDGE + '\x07' # 0x2F -> BELL + '\x90' # 0x30 -> + '\x91' # 0x31 -> + '\x16' # 0x32 -> SYNCHRONOUS IDLE + '\x93' # 0x33 -> INDEX RETURN + '\x94' # 0x34 -> PRESENTATION POSITION + '\x95' # 0x35 -> TRANSPARENT + '\x96' # 0x36 -> NUMERIC BACKSPACE + '\x04' # 0x37 -> END OF TRANSMISSION + '\x98' # 0x38 -> SUBSCRIPT + '\x99' # 0x39 -> INDENT TABULATION + '\x9a' # 0x3A -> REVERSE FORM FEED + '\x9b' # 0x3B -> CUSTOMER USE THREE + '\x14' # 0x3C -> DEVICE CONTROL FOUR + '\x15' # 0x3D -> NEGATIVE ACKNOWLEDGE + '\x9e' # 0x3E -> + '\x1a' # 0x3F -> SUBSTITUTE + ' ' # 0x40 -> SPACE + '\u05d0' # 0x41 -> HEBREW LETTER ALEF + '\u05d1' # 0x42 -> HEBREW LETTER BET + '\u05d2' # 0x43 -> HEBREW LETTER GIMEL + '\u05d3' # 0x44 -> HEBREW LETTER DALET + '\u05d4' # 0x45 -> HEBREW LETTER HE + '\u05d5' # 0x46 -> HEBREW LETTER VAV + '\u05d6' # 0x47 -> HEBREW LETTER ZAYIN + '\u05d7' # 0x48 -> HEBREW LETTER HET + '\u05d8' # 0x49 -> HEBREW LETTER TET + '\xa2' # 0x4A -> CENT SIGN + '.' # 0x4B -> FULL STOP + '<' # 0x4C -> LESS-THAN SIGN + '(' # 0x4D -> LEFT PARENTHESIS + '+' # 0x4E -> PLUS SIGN + '|' # 0x4F -> VERTICAL LINE + '&' # 0x50 -> AMPERSAND + '\u05d9' # 0x51 -> HEBREW LETTER YOD + '\u05da' # 0x52 -> HEBREW LETTER FINAL KAF + '\u05db' # 0x53 -> HEBREW LETTER KAF + '\u05dc' # 0x54 -> HEBREW LETTER LAMED + '\u05dd' # 0x55 -> HEBREW LETTER FINAL MEM + '\u05de' # 0x56 -> HEBREW LETTER MEM + '\u05df' # 0x57 -> HEBREW LETTER FINAL NUN + '\u05e0' # 0x58 -> HEBREW LETTER NUN + '\u05e1' # 0x59 -> HEBREW LETTER SAMEKH + '!' # 0x5A -> EXCLAMATION MARK + '$' # 0x5B -> DOLLAR SIGN + '*' # 0x5C -> ASTERISK + ')' # 0x5D -> RIGHT PARENTHESIS + ';' # 0x5E -> SEMICOLON + '\xac' # 0x5F -> NOT SIGN + '-' # 0x60 -> HYPHEN-MINUS + '/' # 0x61 -> SOLIDUS + '\u05e2' # 0x62 -> HEBREW LETTER AYIN + '\u05e3' # 0x63 -> HEBREW LETTER FINAL PE + '\u05e4' # 0x64 -> HEBREW LETTER PE + '\u05e5' # 0x65 -> HEBREW LETTER FINAL TSADI + '\u05e6' # 0x66 -> HEBREW LETTER TSADI + '\u05e7' # 0x67 -> HEBREW LETTER QOF + '\u05e8' # 0x68 -> HEBREW LETTER RESH + '\u05e9' # 0x69 -> HEBREW LETTER SHIN + '\xa6' # 0x6A -> BROKEN BAR + ',' # 0x6B -> COMMA + '%' # 0x6C -> PERCENT SIGN + '_' # 0x6D -> LOW LINE + '>' # 0x6E -> GREATER-THAN SIGN + '?' # 0x6F -> QUESTION MARK + '\ufffe' # 0x70 -> UNDEFINED + '\u05ea' # 0x71 -> HEBREW LETTER TAV + '\ufffe' # 0x72 -> UNDEFINED + '\ufffe' # 0x73 -> UNDEFINED + '\xa0' # 0x74 -> NO-BREAK SPACE + '\ufffe' # 0x75 -> UNDEFINED + '\ufffe' # 0x76 -> UNDEFINED + '\ufffe' # 0x77 -> UNDEFINED + '\u2017' # 0x78 -> DOUBLE LOW LINE + '`' # 0x79 -> GRAVE ACCENT + ':' # 0x7A -> COLON + '#' # 0x7B -> NUMBER SIGN + '@' # 0x7C -> COMMERCIAL AT + "'" # 0x7D -> APOSTROPHE + '=' # 0x7E -> EQUALS SIGN + '"' # 0x7F -> QUOTATION MARK + '\ufffe' # 0x80 -> UNDEFINED + 'a' # 0x81 -> LATIN SMALL LETTER A + 'b' # 0x82 -> LATIN SMALL LETTER B + 'c' # 0x83 -> LATIN SMALL LETTER C + 'd' # 0x84 -> LATIN SMALL LETTER D + 'e' # 0x85 -> LATIN SMALL LETTER E + 'f' # 0x86 -> LATIN SMALL LETTER F + 'g' # 0x87 -> LATIN SMALL LETTER G + 'h' # 0x88 -> LATIN SMALL LETTER H + 'i' # 0x89 -> LATIN SMALL LETTER I + '\xab' # 0x8A -> LEFT-POINTING DOUBLE ANGLE QUOTATION MARK + '\xbb' # 0x8B -> RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK + '\ufffe' # 0x8C -> UNDEFINED + '\ufffe' # 0x8D -> UNDEFINED + '\ufffe' # 0x8E -> UNDEFINED + '\xb1' # 0x8F -> PLUS-MINUS SIGN + '\xb0' # 0x90 -> DEGREE SIGN + 'j' # 0x91 -> LATIN SMALL LETTER J + 'k' # 0x92 -> LATIN SMALL LETTER K + 'l' # 0x93 -> LATIN SMALL LETTER L + 'm' # 0x94 -> LATIN SMALL LETTER M + 'n' # 0x95 -> LATIN SMALL LETTER N + 'o' # 0x96 -> LATIN SMALL LETTER O + 'p' # 0x97 -> LATIN SMALL LETTER P + 'q' # 0x98 -> LATIN SMALL LETTER Q + 'r' # 0x99 -> LATIN SMALL LETTER R + '\ufffe' # 0x9A -> UNDEFINED + '\ufffe' # 0x9B -> UNDEFINED + '\ufffe' # 0x9C -> UNDEFINED + '\xb8' # 0x9D -> CEDILLA + '\ufffe' # 0x9E -> UNDEFINED + '\xa4' # 0x9F -> CURRENCY SIGN + '\xb5' # 0xA0 -> MICRO SIGN + '~' # 0xA1 -> TILDE + 's' # 0xA2 -> LATIN SMALL LETTER S + 't' # 0xA3 -> LATIN SMALL LETTER T + 'u' # 0xA4 -> LATIN SMALL LETTER U + 'v' # 0xA5 -> LATIN SMALL LETTER V + 'w' # 0xA6 -> LATIN SMALL LETTER W + 'x' # 0xA7 -> LATIN SMALL LETTER X + 'y' # 0xA8 -> LATIN SMALL LETTER Y + 'z' # 0xA9 -> LATIN SMALL LETTER Z + '\ufffe' # 0xAA -> UNDEFINED + '\ufffe' # 0xAB -> UNDEFINED + '\ufffe' # 0xAC -> UNDEFINED + '\ufffe' # 0xAD -> UNDEFINED + '\ufffe' # 0xAE -> UNDEFINED + '\xae' # 0xAF -> REGISTERED SIGN + '^' # 0xB0 -> CIRCUMFLEX ACCENT + '\xa3' # 0xB1 -> POUND SIGN + '\xa5' # 0xB2 -> YEN SIGN + '\xb7' # 0xB3 -> MIDDLE DOT + '\xa9' # 0xB4 -> COPYRIGHT SIGN + '\xa7' # 0xB5 -> SECTION SIGN + '\xb6' # 0xB6 -> PILCROW SIGN + '\xbc' # 0xB7 -> VULGAR FRACTION ONE QUARTER + '\xbd' # 0xB8 -> VULGAR FRACTION ONE HALF + '\xbe' # 0xB9 -> VULGAR FRACTION THREE QUARTERS + '[' # 0xBA -> LEFT SQUARE BRACKET + ']' # 0xBB -> RIGHT SQUARE BRACKET + '\xaf' # 0xBC -> MACRON + '\xa8' # 0xBD -> DIAERESIS + '\xb4' # 0xBE -> ACUTE ACCENT + '\xd7' # 0xBF -> MULTIPLICATION SIGN + '{' # 0xC0 -> LEFT CURLY BRACKET + 'A' # 0xC1 -> LATIN CAPITAL LETTER A + 'B' # 0xC2 -> LATIN CAPITAL LETTER B + 'C' # 0xC3 -> LATIN CAPITAL LETTER C + 'D' # 0xC4 -> LATIN CAPITAL LETTER D + 'E' # 0xC5 -> LATIN CAPITAL LETTER E + 'F' # 0xC6 -> LATIN CAPITAL LETTER F + 'G' # 0xC7 -> LATIN CAPITAL LETTER G + 'H' # 0xC8 -> LATIN CAPITAL LETTER H + 'I' # 0xC9 -> LATIN CAPITAL LETTER I + '\xad' # 0xCA -> SOFT HYPHEN + '\ufffe' # 0xCB -> UNDEFINED + '\ufffe' # 0xCC -> UNDEFINED + '\ufffe' # 0xCD -> UNDEFINED + '\ufffe' # 0xCE -> UNDEFINED + '\ufffe' # 0xCF -> UNDEFINED + '}' # 0xD0 -> RIGHT CURLY BRACKET + 'J' # 0xD1 -> LATIN CAPITAL LETTER J + 'K' # 0xD2 -> LATIN CAPITAL LETTER K + 'L' # 0xD3 -> LATIN CAPITAL LETTER L + 'M' # 0xD4 -> LATIN CAPITAL LETTER M + 'N' # 0xD5 -> LATIN CAPITAL LETTER N + 'O' # 0xD6 -> LATIN CAPITAL LETTER O + 'P' # 0xD7 -> LATIN CAPITAL LETTER P + 'Q' # 0xD8 -> LATIN CAPITAL LETTER Q + 'R' # 0xD9 -> LATIN CAPITAL LETTER R + '\xb9' # 0xDA -> SUPERSCRIPT ONE + '\ufffe' # 0xDB -> UNDEFINED + '\ufffe' # 0xDC -> UNDEFINED + '\ufffe' # 0xDD -> UNDEFINED + '\ufffe' # 0xDE -> UNDEFINED + '\ufffe' # 0xDF -> UNDEFINED + '\\' # 0xE0 -> REVERSE SOLIDUS + '\xf7' # 0xE1 -> DIVISION SIGN + 'S' # 0xE2 -> LATIN CAPITAL LETTER S + 'T' # 0xE3 -> LATIN CAPITAL LETTER T + 'U' # 0xE4 -> LATIN CAPITAL LETTER U + 'V' # 0xE5 -> LATIN CAPITAL LETTER V + 'W' # 0xE6 -> LATIN CAPITAL LETTER W + 'X' # 0xE7 -> LATIN CAPITAL LETTER X + 'Y' # 0xE8 -> LATIN CAPITAL LETTER Y + 'Z' # 0xE9 -> LATIN CAPITAL LETTER Z + '\xb2' # 0xEA -> SUPERSCRIPT TWO + '\ufffe' # 0xEB -> UNDEFINED + '\ufffe' # 0xEC -> UNDEFINED + '\ufffe' # 0xED -> UNDEFINED + '\ufffe' # 0xEE -> UNDEFINED + '\ufffe' # 0xEF -> UNDEFINED + '0' # 0xF0 -> DIGIT ZERO + '1' # 0xF1 -> DIGIT ONE + '2' # 0xF2 -> DIGIT TWO + '3' # 0xF3 -> DIGIT THREE + '4' # 0xF4 -> DIGIT FOUR + '5' # 0xF5 -> DIGIT FIVE + '6' # 0xF6 -> DIGIT SIX + '7' # 0xF7 -> DIGIT SEVEN + '8' # 0xF8 -> DIGIT EIGHT + '9' # 0xF9 -> DIGIT NINE + '\xb3' # 0xFA -> SUPERSCRIPT THREE + '\ufffe' # 0xFB -> UNDEFINED + '\ufffe' # 0xFC -> UNDEFINED + '\ufffe' # 0xFD -> UNDEFINED + '\ufffe' # 0xFE -> UNDEFINED + '\x9f' # 0xFF -> EIGHT ONES +) + +### Encoding table +encoding_table=codecs.charmap_build(decoding_table) diff --git a/shared/package-files/30/3041b846eb79a8428182b90898acd1bebfa2344a9950ee22c86d522bd2984887/blob b/shared/package-files/30/3041b846eb79a8428182b90898acd1bebfa2344a9950ee22c86d522bd2984887/blob new file mode 100644 index 0000000000000000000000000000000000000000..cecc35131b4f73920f9249ff246f3e86157f1a97 --- /dev/null +++ b/shared/package-files/30/3041b846eb79a8428182b90898acd1bebfa2344a9950ee22c86d522bd2984887/blob @@ -0,0 +1,113 @@ +# Authors: The scikit-learn developers +# SPDX-License-Identifier: BSD-3-Clause + +import pytest + +from sklearn import metrics +from sklearn.ensemble import ( + BaggingClassifier, + BaggingRegressor, + IsolationForest, + StackingClassifier, + StackingRegressor, +) +from sklearn.utils._testing import assert_docstring_consistency, skip_if_no_numpydoc + +CLASS_DOCSTRING_CONSISTENCY_CASES = [ + { + "objects": [BaggingClassifier, BaggingRegressor, IsolationForest], + "include_params": ["max_samples"], + "exclude_params": None, + "include_attrs": False, + "exclude_attrs": None, + "include_returns": False, + "exclude_returns": None, + "descr_regex_pattern": r"The number of samples to draw from X to train each.*", + "ignore_types": ("max_samples"), + }, + { + "objects": [StackingClassifier, StackingRegressor], + "include_params": ["cv", "n_jobs", "passthrough", "verbose"], + "exclude_params": None, + "include_attrs": True, + "exclude_attrs": ["final_estimator_"], + "include_returns": False, + "exclude_returns": None, + "descr_regex_pattern": None, + }, +] + +FUNCTION_DOCSTRING_CONSISTENCY_CASES = [ + { + "objects": [ + metrics.precision_recall_fscore_support, + metrics.f1_score, + metrics.fbeta_score, + metrics.precision_score, + metrics.recall_score, + ], + "include_params": True, + "exclude_params": ["average", "zero_division"], + "include_attrs": False, + "exclude_attrs": None, + "include_returns": False, + "exclude_returns": None, + "descr_regex_pattern": None, + }, + { + "objects": [ + metrics.precision_recall_fscore_support, + metrics.f1_score, + metrics.fbeta_score, + metrics.precision_score, + metrics.recall_score, + ], + "include_params": ["average"], + "exclude_params": None, + "include_attrs": False, + "exclude_attrs": None, + "include_returns": False, + "exclude_returns": None, + "descr_regex_pattern": " ".join( + ( + r"""This parameter is required for multiclass/multilabel targets\. + If ``None``, the metrics for each class are returned\. Otherwise, this + determines the type of averaging performed on the data: + ``'binary'``: + Only report results for the class specified by ``pos_label``\. + This is applicable only if targets \(``y_\{true,pred\}``\) are binary\. + ``'micro'``: + Calculate metrics globally by counting the total true positives, + false negatives and false positives\. + ``'macro'``: + Calculate metrics for each label, and find their unweighted + mean\. This does not take label imbalance into account\. + ``'weighted'``: + Calculate metrics for each label, and find their average weighted + by support \(the number of true instances for each label\)\. This + alters 'macro' to account for label imbalance; it can result in an + F-score that is not between precision and recall\.""" + r"[\s\w]*\.*" # optionally match additional sentence + r""" + ``'samples'``: + Calculate metrics for each instance, and find their average \(only + meaningful for multilabel classification where this differs from + :func:`accuracy_score`\)\.""" + ).split() + ), + }, +] + + +@pytest.mark.parametrize("case", CLASS_DOCSTRING_CONSISTENCY_CASES) +@skip_if_no_numpydoc +def test_class_docstring_consistency(case): + """Check docstrings parameters consistency between related classes.""" + assert_docstring_consistency(**case) + + +@pytest.mark.parametrize("case", FUNCTION_DOCSTRING_CONSISTENCY_CASES) +@skip_if_no_numpydoc +def test_function_docstring_consistency(case): + """Check docstrings parameters consistency between related functions.""" + assert_docstring_consistency(**case) diff --git a/shared/package-files/30/3042c9107e802d0c57e504cd9fa7ecbc4c9a988f9685460d0adf7e4f4eb56e99/blob b/shared/package-files/30/3042c9107e802d0c57e504cd9fa7ecbc4c9a988f9685460d0adf7e4f4eb56e99/blob new file mode 100644 index 0000000000000000000000000000000000000000..70effa695e3e26b908d1bf694a3f2d6fefa3db77 --- /dev/null +++ b/shared/package-files/30/3042c9107e802d0c57e504cd9fa7ecbc4c9a988f9685460d0adf7e4f4eb56e99/blob @@ -0,0 +1,4124 @@ +error(0.005831798764596740105) D0 D3 +error(0.003729889994063774125) D0 D3 ^ D17 +error(0.005000000000000000104) D0 D4 +error(0.03185954565655577109) D0 D13 +error(0.002406545579698910354) D0 D13 ^ D16 D17 +error(0.003829833214406730586) D0 D13 ^ D17 +error(0.001668009353193683963) D0 D18 +error(0.002751510450816811379) D0 D18 ^ D16 +error(0.0009730212940470819513) D0 D18 ^ D17 +error(0.004208178207849784178) D0 D19 +error(0.0006997305971534518738) D0 D19 ^ D16 +error(0.001133420181578924206) D0 D19 ^ D16 D17 +error(3.59910209641319212e-05) D0 D19 ^ D17 +error(0.010646635810150476) D0 L0 +error(0.005400505937808928493) D1 D4 +error(0.004420901802102081453) D1 D4 ^ D23 +error(0.007232407415354691338) D1 D5 +error(0.02601273080780392224) D1 D18 +error(0.001869799680636963137) D1 D18 ^ D22 D23 +error(0.003738010215483404501) D1 D18 ^ D23 +error(0.002167703456268276624) D1 D26 +error(0.001677572125740872363) D1 D26 ^ D22 +error(0.0004415400055811998133) D1 D26 ^ D22 ^ D23 +error(0.005243506799610188167) D1 D27 +error(0.0002071450843875191855) D1 D27 ^ D22 +error(0.002391054003763235913) D1 D27 ^ D22 D23 +error(0.001019429532864149588) D1 D27 ^ D23 +error(0.01000000000000000021) D1 L0 +error(0.01192065327994629165) D2 D5 +error(0.01234700596994564581) D2 D26 +error(0.007548641033204358565) D2 L0 +error(0.005134355175549498718) D3 D6 +error(0.001924368205059059011) D3 D13 +error(0.004706778476267866294) D3 D13 ^ D17 +error(0.03930276271387611597) D3 D14 +error(0.01069547174951014125) D3 D14 ^ D17 +error(0.001678517926892172853) D3 D19 +error(0.001834958213155561159) D3 D19 ^ D17 +error(0.00637882081139190104) D3 D20 +error(0.00297840391954673836) D3 D20 ^ D17 +error(0.008341639749671890189) D4 D6 +error(0.003274261909330961322) D4 D6 ^ D24 +error(0.005000000000000000104) D4 D7 +error(0.0001371326447273941269) D4 D18 +error(0.002603321415510927335) D4 D18 ^ D23 +error(0.0009206009417092089189) D4 D18 ^ D23 ^ D24 +error(0.0003693772742852715219) D4 D18 ^ D24 +error(0.03527685096790652425) D4 D19 +error(0.001728123860635761904) D4 D19 ^ D23 +error(0.002174238817655955308) D4 D19 ^ D23 D24 +error(0.001525414340257753723) D4 D19 ^ D24 +error(0.001026630636911778256) D4 D27 +error(0.002044419663941492507) D4 D27 ^ D23 +error(0.0001560322004002956549) D4 D27 ^ D23 ^ D24 +error(0.003421979112216302129) D4 D28 +error(0.001179734278426512305) D4 D28 ^ D23 +error(0.002040088416920920328) D4 D28 ^ D23 D24 +error(0.0009343048368874809235) D4 D28 ^ D24 +error(0.01291723873570155799) D5 D7 +error(0.009070482682389321635) D5 D7 ^ D30 +error(0.006834259437395961978) D5 D8 +error(0.004063851687256672847) D5 D26 +error(0.02587752050786860589) D5 D27 +error(0.003946892437499132864) D5 D27 ^ D30 +error(0.003925494246030424191) D5 D33 +error(0.001244013288199615624) D5 D33 ^ D30 +error(0.008725344908030745542) D6 D9 +error(0.004245624753651791941) D6 D9 ^ D25 +error(0.005000000000000000104) D6 D10 +error(0.002691802883149134636) D6 D19 +error(0.000524346918673326075) D6 D19 ^ D24 +error(0.0005272462978398260308) D6 D19 ^ D24 ^ D25 +error(0.0008633307423123835886) D6 D19 ^ D25 +error(0.01741465340617168872) D6 D20 +error(0.001738684375807372307) D6 D20 ^ D24 +error(0.002705579525618018351) D6 D20 ^ D24 D25 +error(0.001411087079212964418) D6 D20 ^ D25 +error(0.001908972831144637589) D6 D28 +error(0.001509259376362172538) D6 D28 ^ D24 +error(6.399958417665390416e-05) D6 D28 ^ D24 ^ D25 +error(0.0001084933714258326558) D6 D28 ^ D25 +error(0.004680363077916394575) D6 D29 +error(0.0004596168812014383553) D6 D29 ^ D24 +error(0.000992334389565682545) D6 D29 ^ D24 D25 +error(0.003401276473602972764) D6 D29 ^ D25 +error(0.005000000000000000104) D7 D10 +error(0.005049984785073142329) D7 D10 ^ D31 +error(0.005777991036269303216) D7 D11 +error(0.002705082738091433171) D7 D27 +error(0.005906618023898708297) D7 D27 ^ D30 +error(0.002246968683674379925) D7 D27 ^ D30 ^ D31 +error(0.0003625993918336825952) D7 D27 ^ D31 +error(0.01673280811474383081) D7 D28 +error(0.0002210273591222219197) D7 D28 ^ D30 +error(0.001751652578125856242) D7 D28 ^ D30 D31 +error(0.0012976493616035094) D7 D28 ^ D31 +error(0.002654233395284913075) D7 D33 +error(0.001669715167525862541) D7 D33 ^ D30 +error(0.0001808662335099840398) D7 D33 ^ D31 +error(0.004441702206258192447) D7 D34 +error(0.0008560414347140723416) D7 D34 ^ D30 +error(0.0003229021178212825895) D7 D34 ^ D30 D31 +error(0.002245270431770918663) D7 D34 ^ D31 +error(0.007992297410533921731) D8 D11 +error(0.02693146071954177767) D8 D33 +error(0.008198382053687563661) D9 +error(0.001736743677720434254) D9 D20 +error(0.002918402744151886007) D9 D20 ^ D25 +error(0.02013645312489653616) D9 D21 +error(0.002837206777117264305) D9 D21 ^ D25 +error(0.002817778801981707555) D9 D29 +error(0.002810582491353701921) D9 D29 ^ D25 +error(0.01588181350627211261) D10 +error(0.001965363527407319559) D10 D28 +error(0.001903148113669813485) D10 D28 ^ D31 +error(0.0005061016246975065178) D10 D28 ^ D32 +error(0.02133046354984673154) D10 D29 +error(0.00162780554143355659) D10 D29 ^ D31 +error(0.000470736805920464723) D10 D29 ^ D31 D32 +error(0.001787514179927689965) D10 D29 ^ D32 +error(0.001675867642806056369) D10 D34 ^ D31 +error(0.00615434069518421608) D10 ^ D32 +error(0.01193577370981777248) D11 +error(0.003667215655349197363) D11 D33 +error(0.0009110557934850262987) D11 D33 ^ D35 +error(0.02089311441009504902) D11 D34 +error(0.004372165720922304398) D11 D34 ^ D35 +error(0.003867836990901566026) D11 ^ D35 +error(0.01512883658020688221) D12 +error(0.01454365148423407937) D12 D16 +error(0.01196544795735591735) D12 D16 ^ D13 L0 +error(0.0266862725621760527) D12 D36 +error(0.006857640050321386731) D12 D36 ^ D37 L0 +error(0.006904323411147515743) D12 D40 +error(0.004290343924348420136) D12 D40 ^ D13 L0 +error(0.004718005776907755952) D12 D40 ^ D37 L0 +error(0.002682747303679847845) D12 D40 ^ D37 L0 ^ D13 L0 +error(0.003222820645970455884) D12 D41 +error(0.002413814734477126925) D12 D41 ^ D13 D37 +error(0.0009759754382860813841) D12 D41 ^ D13 L0 +error(0.001484037307585785734) D12 D41 ^ D37 L0 +error(0.009701322865568471135) D12 ^ D13 L0 +error(0.005322407363730898185) D13 D37 ^ D12 +error(0.006041937514357918933) D13 D14 +error(0.0005122366275274266214) D13 D14 ^ D12 +error(0.0009515578865384848864) D13 D14 ^ D16 D17 +error(0.0002940482682934252782) D13 D14 ^ D16 D41 +error(0.01499712991061701375) D13 D14 ^ D17 +error(0.003440266269014606582) D13 D14 ^ D17 D41 +error(0.002728099968767540903) D13 D14 ^ D41 +error(0.0003101067761686230142) D13 D14 ^ D41 ^ D12 +error(0.02357962419788397351) D13 D19 +error(0.01258894510579270515) D13 D19 ^ D16 D17 +error(0.04054698510964466207) D13 D37 +error(0.003068906748310869584) D13 D37 ^ D40 D41 +error(0.004135165380719954369) D13 D37 ^ D41 +error(0.00170148481970367675) D13 D42 +error(0.002569670009209375477) D13 D42 ^ D16 D40 +error(0.0003645001291986636185) D13 D42 ^ D16 D41 +error(0.0006562264584675363841) D13 D42 ^ D40 D41 +error(0.00358204353642006942) D13 D43 +error(0.001864374047664434922) D13 D43 ^ D16 D17 +error(0.0003932828383309873183) D13 D43 ^ D16 D40 +error(0.001848434604000002719) D13 D43 ^ D16 D41 +error(0.0001774661344280517637) D13 D43 ^ D17 D41 +error(0.002210991227743962402) D13 D43 ^ D40 D41 +error(0.01000000000000000021) D13 L0 +error(0.01516226346324183946) D14 D20 +error(0.01382549418274907869) D14 D20 ^ D17 +error(0.004719946072497860183) D14 D37 +error(0.0007165835560042144777) D14 D37 ^ D12 +error(0.004779816248476202387) D14 D37 ^ D41 +error(0.0005462343302855433153) D14 D37 ^ D41 ^ D12 +error(0.04658633835913435217) D14 D38 +error(0.009873875383543916084) D14 D38 ^ D41 +error(0.002326384940569728357) D14 D43 +error(0.0005686665129455996306) D14 D43 ^ D16 D17 +error(0.0002337464378640189766) D14 D43 ^ D16 D41 +error(0.000491201243452230301) D14 D43 ^ D17 +error(0.001361197307204584225) D14 D43 ^ D17 D41 +error(0.0005238546515356713642) D14 D43 ^ D41 +error(0.003606535288512647489) D14 D44 +error(0.002939925401372571381) D14 D44 ^ D17 +error(0.002886682013661131477) D14 D44 ^ D41 +error(0.001451469642847544881) D14 D44 ^ D41 ^ D17 +error(0.01017247511817674643) D15 +error(0.008836793723736857675) D15 D16 +error(0.001112587024099789173) D15 D16 ^ D13 L0 +error(0.0009413446585989133529) D15 D16 ^ D18 D19 +error(0.002038993562470617187) D15 D16 ^ D18 D42 +error(0.006602262534192097042) D15 D16 ^ D18 L0 +error(1.613708403102963708e-05) D15 D16 ^ D19 D42 +error(0.001420262771992301942) D15 D16 ^ D42 L0 +error(0.0007398317957289404605) D15 D16 ^ D42 L0 ^ D13 L0 +error(0.01326210247137128359) D15 D22 +error(0.00976503370880560731) D15 D22 ^ D18 L0 +error(0.02360888144805250999) D15 D39 +error(0.003659423329073996974) D15 D39 ^ D42 L0 +error(0.002152186614080534195) D15 D40 +error(0.000456204478737577343) D15 D40 ^ D13 L0 +error(0.002391715036470463789) D15 D40 ^ D42 L0 +error(0.0001736009261800634882) D15 D40 ^ D42 L0 ^ D13 L0 +error(0.002929594954205079742) D15 D46 +error(0.003607534314359686634) D15 D46 ^ D18 L0 +error(0.002145454612411112471) D15 D46 ^ D42 L0 +error(0.0006842560657499791943) D15 D46 ^ D42 L0 ^ D18 L0 +error(0.002734468661554086567) D15 D47 +error(0.0003213799321281471302) D15 D47 ^ D18 D19 +error(0.001292369671938379096) D15 D47 ^ D18 D42 +error(0.0006814453156953355741) D15 D47 ^ D18 L0 +error(0.000171429172347746983) D15 D47 ^ D19 D42 +error(2.241052274140109318e-05) D15 D47 ^ D42 L0 +error(0.005000000000000000104) D15 ^ D18 L0 +error(0.01000000000000000021) D16 +error(0.007164755382378847418) D16 D17 +error(0.001029960559266682348) D16 D17 ^ D19 D20 +error(0.001594794524676789067) D16 D17 ^ D19 D43 +error(0.01268453028683181119) D16 D23 +error(0.009697688476464677923) D16 D23 ^ D18 D19 +error(0.02687355039480195801) D16 D40 +error(0.007485819796524218438) D16 D40 ^ D13 L0 +error(0.003107469568972692602) D16 D40 ^ D42 D43 +error(0.0005680536236455682427) D16 D40 ^ D42 L0 +error(0.003211879643569449851) D16 D41 +error(0.000376529833666304839) D16 D41 ^ D42 D43 +error(0.00120063201568994444) D16 D47 +error(0.002765100742562540039) D16 D47 ^ D18 D19 +error(0.001443006512690684761) D16 D47 ^ D18 D42 +error(0.001963765223827605017) D16 D47 ^ D19 D42 +error(0.001561962824876994256) D16 D47 ^ D19 D43 +error(0.001924240942830092883) D16 D47 ^ D42 D43 +error(0.001978648078269987665) D16 D48 +error(0.0003155662468816377805) D16 D48 ^ D19 D20 +error(0.0002941715103168643678) D16 D48 ^ D19 D42 +error(0.001543894821161831106) D16 D48 ^ D19 D43 +error(0.004795446385654044373) D16 ^ D0 L0 +error(0.001048545487988615131) D16 ^ D13 L0 ^ D0 L0 +error(0.0008405670066867826015) D16 ^ D17 ^ D0 L0 +error(0.004264008958930334131) D16 ^ D18 L0 +error(0.02812344421646416348) D17 +error(0.01994562998348835964) D17 D24 +error(0.01654124160852828498) D17 D24 ^ D19 D20 +error(0.03083190651367225324) D17 D41 +error(0.002851553572250035279) D17 D41 ^ D43 D44 +error(0.003781520367195873988) D17 D48 +error(0.002268950364954752229) D17 D48 ^ D19 D20 +error(0.001088491258235638843) D17 D48 ^ D19 D43 +error(0.002124756255297351182) D17 D48 ^ D20 D43 +error(0.0005882412221558847064) D17 D48 ^ D20 D44 +error(0.002574093098742098219) D17 D48 ^ D43 D44 +error(0.003029302145153121503) D17 D49 +error(0.001158629973361129974) D17 D49 ^ D20 D44 +error(0.0004212946613479972625) D17 D49 ^ D43 D44 +error(0.001581778928086844836) D17 ^ D0 L0 +error(0.0003542146911770389906) D17 ^ D13 L0 +error(0.007943644950603487992) D18 D19 +error(0.001330592496686052546) D18 D19 ^ D22 D23 +error(0.000456805822531424063) D18 D19 ^ D22 D47 +error(0.002978301507806489605) D18 D19 ^ D23 +error(0.002634276171414426122) D18 D19 ^ D23 D47 +error(0.000350121730674121689) D18 D19 ^ D24 +error(0.01148772863162424857) D18 D27 +error(0.01172232930451502092) D18 D27 ^ D22 D23 +error(0.03918384738513067123) D18 D42 +error(0.002228925530581629937) D18 D42 ^ D46 D47 +error(0.001722182253290977872) D18 D50 +error(0.00257234959439087401) D18 D50 ^ D22 D46 +error(0.0006935910585423644449) D18 D50 ^ D22 D47 +error(0.0005515214868894067427) D18 D50 ^ D46 D47 +error(0.003685515877434647394) D18 D51 +error(0.002490979275654284057) D18 D51 ^ D22 D23 +error(0.00230918351195979598) D18 D51 ^ D22 D46 +error(0.001594143301527340979) D18 D51 ^ D22 D47 +error(0.0006317460369945696042) D18 D51 ^ D23 D47 +error(0.001985781331922381338) D18 D51 ^ D46 D47 +error(0.01000000000000000021) D18 L0 +error(0.002783689788661022121) D22 D46 ^ D18 L0 +error(0.006949489693982552514) D19 D20 +error(0.003239773762674242816) D19 D20 ^ D17 +error(0.0007378755894707452519) D19 D20 ^ D23 D24 +error(0.0004743688286892290226) D19 D20 ^ D23 D48 +error(0.002193762443747511968) D19 D20 ^ D24 +error(0.001157504928862029348) D19 D20 ^ D24 D48 +error(0.0004291200308661721513) D19 D20 ^ D24 ^ D25 +error(0.002992161252631003483) D19 D20 ^ D25 +error(0.01497207521719459526) D19 D28 +error(0.01435436572955659656) D19 D28 ^ D23 D24 +error(0.003434296201232148876) D19 D42 +error(0.000572720380022092657) D19 D42 ^ D47 D48 +error(0.03896029464506293311) D19 D43 +error(0.001919558353366188335) D19 D43 ^ D47 D48 +error(0.000483343676407702429) D19 D51 +error(0.0002960171048330712418) D19 D51 ^ D22 D23 +error(0.002043284550463939) D19 D51 ^ D23 D47 +error(0.0008359769467140544747) D19 D51 ^ D23 D48 +error(0.000307975956330275866) D19 D51 ^ D47 D48 +error(0.001859072576991834544) D19 D52 +error(0.002165391394046252676) D19 D52 ^ D23 D24 +error(0.0009431680077149669911) D19 D52 ^ D23 D47 +error(0.001598928756437687122) D19 D52 ^ D23 D48 +error(0.001076978172298284934) D19 D52 ^ D24 D48 +error(0.002627582281132581458) D19 D52 ^ D47 D48 +error(0.009554565416175553327) D20 D21 +error(0.001422339258966346743) D20 D21 ^ D17 +error(3.756848122638768088e-05) D20 D21 ^ D24 D49 +error(0.01200642883997820112) D20 D21 ^ D25 +error(0.004635934828459368356) D20 D21 ^ D25 D49 +error(0.002185403898100024295) D20 D21 ^ D49 +error(0.009930141388163081506) D20 D29 +error(0.01091833325751625366) D20 D29 ^ D24 D25 +error(0.005797025101372838864) D20 D43 +error(0.0003417045946126709161) D20 D43 ^ D48 D49 +error(0.0244028701613570112) D20 D44 +error(0.005035374525287034803) D20 D44 ^ D17 +error(0.001425061471213253782) D20 D44 ^ D48 D49 +error(0.001025440560362546371) D20 D44 ^ D49 +error(0.001739025683189662557) D20 D52 +error(0.0005163048540822849121) D20 D52 ^ D23 D24 +error(0.0003872660728112318042) D20 D52 ^ D23 D48 +error(0.001010208392926537947) D20 D52 ^ D24 D48 +error(0.0003614633525562173117) D20 D52 ^ D24 D49 +error(0.0007708242313029848268) D20 D52 ^ D48 D49 +error(0.002829373934999426885) D20 D53 +error(0.001161648608437570009) D20 D53 ^ D24 D25 +error(0.0004817648811728498333) D20 D53 ^ D24 D48 +error(0.002369403621825834708) D20 D53 ^ D24 D49 +error(0.0004523255119455854285) D20 D53 ^ D25 D49 +error(0.00243362505591642516) D20 D53 ^ D48 D49 +error(0.008706200618664991508) D21 +error(0.003122593618286308333) D21 D44 +error(0.0003444676573668129416) D21 D44 ^ D17 +error(0.003029471903265145566) D21 D44 ^ D49 +error(0.02878109383905069762) D21 D45 +error(0.005245455859824325884) D21 D45 ^ D49 +error(0.002444244415730570993) D21 D53 +error(1.320503562624765046e-05) D21 D53 ^ D24 D25 +error(0.000319071422289989796) D21 D53 ^ D24 D49 +error(0.002504366306824067946) D21 D53 ^ D25 D49 +error(0.01634306768085980535) D21 ^ D25 +error(0.0004076332642725224499) D21 ^ D49 +error(0.001893217879630942077) D21 ^ D49 ^ D25 +error(0.05705525396143266287) D22 +error(0.01177726169163564526) D22 D23 +error(0.001712985178897279354) D22 D23 ^ D27 D51 +error(4.669523646288583138e-05) D22 D23 ^ D28 D51 +error(0.04918066768488339735) D22 D46 +error(0.00367209971397850464) D22 D46 ^ D50 D51 +error(0.001587061349442817852) D22 D47 +error(0.0006664841908282826029) D22 D47 ^ D50 D51 +error(0.0004431564671695123817) D22 D54 +error(9.765646950254146724e-06) D22 D54 ^ D27 D28 +error(0.0006406541570109316498) D22 D54 ^ D27 D51 +error(5.274589083871283256e-05) D22 D54 ^ D28 D51 +error(0.002869510657447999716) D22 ^ D1 L0 +error(0.0008012356144501512093) D22 ^ D18 L0 ^ D1 L0 +error(0.012598959007515469) D22 ^ D26 L0 +error(0.004137845564894525492) D26 D50 ^ D22 +error(0.01000000000000000021) D23 +error(0.01945289758831545562) D23 D24 +error(0.002753689268113585723) D23 D24 ^ D28 D52 +error(0.0005499538130014023632) D23 D24 ^ D29 D52 +error(0.02319369817133480269) D23 D30 +error(0.02074008940727325653) D23 D30 ^ D27 D28 +error(0.02812184381392778681) D23 D47 +error(0.002607359131359769482) D23 D47 ^ D51 D52 +error(0.003969053395153494292) D23 D48 +error(4.689775471165016457e-05) D23 D48 ^ D51 D52 +error(0.008075155730227432868) D23 D54 +error(0.005353779632917887721) D23 D54 ^ D27 D28 +error(0.0008750595983553233767) D23 D54 ^ D27 D51 +error(0.007885636642307748342) D23 D54 ^ D28 D51 +error(0.001752721336947414684) D23 D54 ^ D28 D52 +error(0.00216109320394393227) D23 D54 ^ D51 D52 +error(0.002431970761268770556) D23 D55 +error(0.0006784536717705084465) D23 D55 ^ D28 D29 +error(4.63592763270954906e-05) D23 D55 ^ D28 D51 +error(0.001397725395569435333) D23 D55 ^ D28 D52 +error(0.0004419636415501518398) D23 D55 ^ D29 D52 +error(0.0003189261836387721327) D23 D55 ^ D51 D52 +error(0.01000000000000000021) D24 +error(0.007215266581258073485) D24 D25 +error(0.001278512356325647685) D24 D25 ^ D29 D53 +error(0.0007020451534826920416) D24 D25 ^ D53 +error(0.01153886785341906931) D24 D31 +error(0.00982630123448554986) D24 D31 ^ D28 D29 +error(0.02278187818030543224) D24 D48 +error(0.002407124538276740958) D24 D48 ^ D52 D53 +error(0.003075712190512780442) D24 D49 +error(0.0005860246305094125689) D24 D49 ^ D52 D53 +error(0.002095085221072178795) D24 D55 +error(0.002204476815442909295) D24 D55 ^ D28 D29 +error(0.001398016024156229289) D24 D55 ^ D28 D52 +error(0.001998355767841102602) D24 D55 ^ D29 D52 +error(0.001286846742682906837) D24 D55 ^ D29 D53 +error(0.001863213582515296481) D24 D55 ^ D52 D53 +error(0.001997153633049718324) D24 D56 +error(2.598292875153643494e-05) D24 D56 ^ D29 D52 +error(0.001173331601012149233) D24 D56 ^ D29 D53 +error(0.0002874234325142206487) D24 D56 ^ D52 D53 +error(1.821438837082284888e-05) D24 D56 ^ D53 +error(0.03656468499327450439) D25 +error(0.01481360510259322784) D25 D32 +error(0.01497477726733952366) D25 D32 ^ D29 +error(0.0250505139273094167) D25 D49 +error(0.002345018263775333536) D25 D49 ^ D53 +error(0.003073065190622500248) D25 D56 +error(0.002579449672997942682) D25 D56 ^ D29 +error(0.003836377064377697373) D25 D56 ^ D53 +error(0.0006646277758526700783) D25 D56 ^ D53 ^ D29 +error(0.001517755165932300424) D25 ^ D9 +error(0.0007320317066671339469) D25 ^ D29 +error(0.02107167420230017171) D26 D27 +error(0.01957099750633325627) D26 D27 ^ D22 +error(0.0005701244036437331077) D26 D27 ^ D22 ^ D23 +error(0.0191985177099640858) D26 D50 +error(0.01833703582869726165) D26 L0 +error(0.01763891129167028532) D27 D28 +error(0.001961208692060903251) D27 D28 ^ D23 ^ D24 +error(0.0001667664003206925248) D27 D28 ^ D24 +error(0.003377679907839793976) D27 D28 ^ D30 D54 +error(0.002524736293611619907) D27 D28 ^ D30 ^ D31 +error(0.0009429228602723484839) D27 D28 ^ D31 +error(0.0004409901630161987838) D27 D28 ^ D54 +error(0.01235210009331834738) D27 D33 +error(0.01239714533997207831) D27 D33 ^ D30 +error(0.00378888098077427701) D27 D50 +error(0.002826407968055778298) D27 D50 ^ D22 +error(0.0001197399291263810575) D27 D50 ^ D54 +error(0.0003950766148601412729) D27 D50 ^ D54 ^ D22 +error(0.02650863068338265086) D27 D51 +error(0.002052387878255866605) D27 D51 ^ D22 +error(0.005693851689366329419) D27 D51 ^ D54 +error(0.00279004820284349574) D27 D57 +error(0.001376537795732491343) D27 D57 ^ D30 +error(0.002887687896721477781) D27 D57 ^ D54 +error(0.001094217013606597596) D27 D57 ^ D54 ^ D30 +error(0.005769844105912032284) D28 D29 +error(0.001271023912219724919) D28 D29 ^ D24 +error(0.004174960329978318237) D28 D29 ^ D25 +error(0.0008224068010659001636) D28 D29 ^ D30 D31 +error(0.0002961719484165020928) D28 D29 ^ D30 D55 +error(0.002862427649248453464) D28 D29 ^ D31 D55 +error(0.001583502169768804136) D28 D29 ^ D31 ^ D32 +error(0.0010092482514755688) D28 D29 ^ D32 +error(0.01488992990415833814) D28 D34 +error(0.008997901086616242813) D28 D34 ^ D30 D31 +error(0.008487365324421063117) D28 D51 +error(0.02457592249931421502) D28 D52 +error(0.002631812399044814853) D28 D52 ^ D54 D55 +error(0.002198804135129999587) D28 D57 +error(0.001654137015294186892) D28 D57 ^ D30 D54 +error(6.003632573794476984e-06) D28 D57 ^ D30 D55 +error(0.0004409060199606022593) D28 D57 ^ D54 +error(0.002192299185518550592) D28 D58 +error(0.001746414734417907517) D28 D58 ^ D30 D31 +error(0.0003598999091759262268) D28 D58 ^ D30 D54 +error(0.001561544017991810512) D28 D58 ^ D30 D55 +error(0.000466227982502727986) D28 D58 ^ D31 D55 +error(0.001724344060558972601) D28 D58 ^ D54 D55 +error(0.02409530565427575599) D29 +error(0.004387356071761702725) D29 D52 +error(0.000208029715498591483) D29 D52 ^ D55 D56 +error(0.02221100964778081194) D29 D53 +error(0.001439615781168439605) D29 D53 ^ D55 D56 +error(0.001201823867210177017) D29 D58 +error(0.0001012650403590720146) D29 D58 ^ D30 D31 +error(0.0003034946049630618146) D29 D58 ^ D30 D55 +error(0.001323584720901610371) D29 D58 ^ D31 D55 +error(0.005000000000000000104) D29 ^ D32 +error(0.04942579752798465648) D30 +error(0.005000000000000000104) D30 D31 +error(0.002903853997969320973) D30 D31 ^ D34 +error(0.002612338632211596515) D30 D31 ^ D34 D58 +error(0.0008620297320340863934) D30 D31 ^ D58 +error(0.03555466847524565294) D30 D54 +error(0.004257613433980646928) D30 D54 ^ D57 D58 +error(0.003914888887922909726) D30 D55 +error(0.0008393621947703528048) D30 D55 ^ D57 D58 +error(0.0006392754687906603917) D30 D59 +error(0.0002831750050793343447) D30 D59 ^ D34 +error(0.001693673795440791933) D30 D59 ^ D34 D58 +error(7.480679588459883279e-06) D30 D59 ^ D58 +error(0.01000000000000000021) D31 +error(0.01791296521561145175) D31 D32 +error(0.003155650310391343565) D31 D32 ^ D10 +error(0.01109893288376519703) D31 D32 ^ D29 +error(0.01371862271598929019) D31 D35 +error(0.01691198906740007391) D31 D35 ^ D34 +error(0.02667661522528785162) D31 D55 +error(0.001456372037112019452) D31 D55 ^ D29 +error(0.00368662532011345247) D31 D55 ^ D58 +error(0.002088453177880326885) D31 D56 +error(0.002632780704037000936) D31 D56 ^ D29 +error(0.0002114179196296893338) D31 D56 ^ D58 ^ D29 +error(0.004110481756233741457) D31 D59 +error(0.002802723964281605973) D31 D59 ^ D34 +error(0.003798397130707047414) D31 D59 ^ D58 +error(0.001977355296201686527) D31 D59 ^ D58 ^ D34 +error(0.0007270088820995817625) D31 ^ D10 +error(0.001014625758789009609) D31 ^ D34 ^ D32 +error(0.02782022952095405954) D32 +error(0.02679340452938059822) D32 D56 +error(0.002535959682426708415) D32 D56 ^ D29 +error(0.008246518009045484404) D33 D34 +error(0.01428236397635075823) D33 D34 ^ D30 +error(0.002964244877248868593) D33 D34 ^ D31 +error(0.00105720409874654757) D33 D34 ^ D35 +error(0.02900709638648528779) D33 D57 +error(0.003760545837299076113) D33 D57 ^ D30 +error(0.01336250093101065163) D34 +error(0.001742126190683423136) D34 D57 +error(0.002377235945765063599) D34 D57 ^ D30 +error(0.000899953914339936766) D34 D57 ^ D59 +error(0.0004872680715309037156) D34 D57 ^ D59 ^ D30 +error(0.02110557026819835647) D34 D58 +error(0.0003712607219078131976) D34 D58 ^ D30 +error(0.00170219714362124892) D34 D58 ^ D59 +error(0.01335745093167530449) D34 ^ D35 +error(0.001301279920715417773) D34 ^ D59 +error(0.003066610980423866654) D35 D59 ^ D34 +error(0.04381067742665674392) D35 +error(0.01920747822175144712) D35 D59 +error(0.005000000000000000104) D36 +error(0.01596805964649321286) D36 D40 +error(0.01829778043055142397) D36 D40 ^ D37 L0 +error(0.0266862725621760527) D36 D60 +error(0.006857640050321386731) D36 D60 ^ D61 L0 +error(0.006904323411147515743) D36 D64 +error(0.004290343924348420136) D36 D64 ^ D37 L0 +error(0.004718005776907755952) D36 D64 ^ D61 L0 +error(0.002682747303679847845) D36 D64 ^ D61 L0 ^ D37 L0 +error(0.003222820645970455884) D36 D65 +error(0.002413814734477126925) D36 D65 ^ D37 D61 +error(0.0009759754382860813841) D36 D65 ^ D37 L0 +error(0.001484037307585785734) D36 D65 ^ D61 L0 +error(0.006310960120927104275) D36 ^ D37 L0 +error(0.005322407363730898185) D37 D61 ^ D36 +error(0.006735703095373630871) D37 D38 +error(0.0008816988361899102695) D37 D38 ^ D36 +error(0.0001283013300070091228) D37 D38 ^ D40 D41 +error(0.0002940482682934252782) D37 D38 ^ D40 D65 +error(0.0147823200156403517) D37 D38 ^ D41 +error(0.003440266269014606582) D37 D38 ^ D41 D65 +error(0.002728099968767540903) D37 D38 ^ D65 +error(0.0003101067761686230142) D37 D38 ^ D65 ^ D36 +error(0.02055897619164840859) D37 D43 +error(0.01315370144244269388) D37 D43 ^ D40 D41 +error(0.04054698510964466207) D37 D61 +error(0.003068906748310869584) D37 D61 ^ D64 D65 +error(0.004135165380719954369) D37 D61 ^ D65 +error(0.00170148481970367675) D37 D66 +error(0.002569670009209375477) D37 D66 ^ D40 D64 +error(0.0003645001291986636185) D37 D66 ^ D40 D65 +error(0.0006562264584675363841) D37 D66 ^ D64 D65 +error(0.00358204353642006942) D37 D67 +error(0.001864374047664434922) D37 D67 ^ D40 D41 +error(0.0003932828383309873183) D37 D67 ^ D40 D64 +error(0.001848434604000002719) D37 D67 ^ D40 D65 +error(0.0001774661344280517637) D37 D67 ^ D41 D65 +error(0.002210991227743962402) D37 D67 ^ D64 D65 +error(0.01000000000000000021) D37 L0 +error(0.01675927044650943679) D38 D44 +error(0.01483521393192921423) D38 D44 ^ D41 +error(0.004719946072497860183) D38 D61 +error(0.0007165835560042144777) D38 D61 ^ D36 +error(0.004779816248476202387) D38 D61 ^ D65 +error(0.0005462343302855433153) D38 D61 ^ D65 ^ D36 +error(0.04658633835913435217) D38 D62 +error(0.009873875383543916084) D38 D62 ^ D65 +error(0.002326384940569728357) D38 D67 +error(0.0005686665129455996306) D38 D67 ^ D40 D41 +error(0.0002337464378640189766) D38 D67 ^ D40 D65 +error(0.000491201243452230301) D38 D67 ^ D41 +error(0.001361197307204584225) D38 D67 ^ D41 D65 +error(0.0005238546515356713642) D38 D67 ^ D65 +error(0.003606535288512647489) D38 D68 +error(0.002939925401372571381) D38 D68 ^ D41 +error(0.002886682013661131477) D38 D68 ^ D65 +error(0.001451469642847544881) D38 D68 ^ D65 ^ D41 +error(0.009299079482444108993) D39 D40 +error(0.0001618067361763870105) D39 D40 ^ D37 L0 +error(0.0004009870402910406875) D39 D40 ^ D42 D43 +error(0.002038993562470617187) D39 D40 ^ D42 D66 +error(0.009839797261860206215) D39 D40 ^ D42 L0 +error(1.613708403102963708e-05) D39 D40 ^ D43 D66 +error(0.001420262771992301942) D39 D40 ^ D66 L0 +error(0.0007398317957289404605) D39 D40 ^ D66 L0 ^ D37 L0 +error(0.01276385364945899735) D39 D46 +error(0.011096381866881758) D39 D46 ^ D42 L0 +error(0.02360888144805250999) D39 D63 +error(0.003659423329073996974) D39 D63 ^ D66 L0 +error(0.002152186614080534195) D39 D64 +error(0.000456204478737577343) D39 D64 ^ D37 L0 +error(0.002391715036470463789) D39 D64 ^ D66 L0 +error(0.0001736009261800634882) D39 D64 ^ D66 L0 ^ D37 L0 +error(0.002929594954205079742) D39 D70 +error(0.003607534314359686634) D39 D70 ^ D42 L0 +error(0.002145454612411112471) D39 D70 ^ D66 L0 +error(0.0006842560657499791943) D39 D70 ^ D66 L0 ^ D42 L0 +error(0.002734468661554086567) D39 D71 +error(0.0003213799321281471302) D39 D71 ^ D42 D43 +error(0.001292369671938379096) D39 D71 ^ D42 D66 +error(0.0006814453156953355741) D39 D71 ^ D42 L0 +error(0.000171429172347746983) D39 D71 ^ D43 D66 +error(2.241052274140109318e-05) D39 D71 ^ D66 L0 +error(0.008061141833768614012) D40 D41 +error(5.603595358604616684e-05) D40 D41 ^ D13 L0 +error(0.0003240145466437737223) D40 D41 ^ D37 L0 +error(0.0007894832832053461135) D40 D41 ^ D42 D43 +error(0.0009388025834094447519) D40 D41 ^ D43 D44 +error(0.001594794524676789067) D40 D41 ^ D43 D67 +error(0.01499707882523569624) D40 D47 +error(0.009686274303190828272) D40 D47 ^ D42 D43 +error(0.02687355039480195801) D40 D64 +error(0.007485819796524218438) D40 D64 ^ D37 L0 +error(0.003107469568972692602) D40 D64 ^ D66 D67 +error(0.0005680536236455682427) D40 D64 ^ D66 L0 +error(0.003211879643569449851) D40 D65 +error(0.000376529833666304839) D40 D65 ^ D66 D67 +error(0.00120063201568994444) D40 D71 +error(0.002765100742562540039) D40 D71 ^ D42 D43 +error(0.001443006512690684761) D40 D71 ^ D42 D66 +error(0.001963765223827605017) D40 D71 ^ D43 D66 +error(0.001561962824876994256) D40 D71 ^ D43 D67 +error(0.001924240942830092883) D40 D71 ^ D66 D67 +error(0.001978648078269987665) D40 D72 +error(0.0003155662468816377805) D40 D72 ^ D43 D44 +error(0.0002941715103168643678) D40 D72 ^ D43 D66 +error(0.001543894821161831106) D40 D72 ^ D43 D67 +error(0.01000000000000000021) D41 +error(0.01996187733386350568) D41 D48 +error(0.0188611843799036949) D41 D48 ^ D43 D44 +error(0.03083190651367225324) D41 D65 +error(0.002851553572250035279) D41 D65 ^ D67 D68 +error(0.003781520367195873988) D41 D72 +error(0.002268950364954752229) D41 D72 ^ D43 D44 +error(0.001088491258235638843) D41 D72 ^ D43 D67 +error(0.002124756255297351182) D41 D72 ^ D44 D67 +error(0.0005882412221558847064) D41 D72 ^ D44 D68 +error(0.002574093098742098219) D41 D72 ^ D67 D68 +error(0.003029302145153121503) D41 D73 +error(0.001158629973361129974) D41 D73 ^ D44 D68 +error(0.0004212946613479972625) D41 D73 ^ D67 D68 +error(0.00708325686996343247) D42 D43 +error(0.001146243462908609796) D42 D43 ^ D46 D47 +error(0.000456805822531424063) D42 D43 ^ D46 D71 +error(0.000304813137048891682) D42 D43 ^ D47 D48 +error(0.002634276171414426122) D42 D43 ^ D47 D71 +error(0.01612767423445998077) D42 D51 +error(0.01171697673212769748) D42 D51 ^ D46 D47 +error(0.03918384738513067123) D42 D66 +error(0.002228925530581629937) D42 D66 ^ D70 D71 +error(0.001722182253290977872) D42 D74 +error(0.00257234959439087401) D42 D74 ^ D46 D70 +error(0.0006935910585423644449) D42 D74 ^ D46 D71 +error(0.0005515214868894067427) D42 D74 ^ D70 D71 +error(0.003685515877434647394) D42 D75 +error(0.002490979275654284057) D42 D75 ^ D46 D47 +error(0.00230918351195979598) D42 D75 ^ D46 D70 +error(0.001594143301527340979) D42 D75 ^ D46 D71 +error(0.0006317460369945696042) D42 D75 ^ D47 D71 +error(0.001985781331922381338) D42 D75 ^ D70 D71 +error(0.01000000000000000021) D42 L0 +error(0.002783689788661022121) D46 D70 ^ D42 L0 +error(0.00974687687898492458) D43 D44 +error(0.0003747287983380178798) D43 D44 ^ D47 D48 +error(0.0004743688286892290226) D43 D44 ^ D47 D72 +error(5.278044991932393068e-05) D43 D44 ^ D48 D49 +error(0.001157504928862029348) D43 D44 ^ D48 D72 +error(0.01675403094458132944) D43 D52 +error(0.01519293603187372999) D43 D52 ^ D47 D48 +error(0.003434296201232148876) D43 D66 +error(0.000572720380022092657) D43 D66 ^ D71 D72 +error(0.03896029464506293311) D43 D67 +error(0.001919558353366188335) D43 D67 ^ D71 D72 +error(0.000483343676407702429) D43 D75 +error(0.0002960171048330712418) D43 D75 ^ D46 D47 +error(0.002043284550463939) D43 D75 ^ D47 D71 +error(0.0008359769467140544747) D43 D75 ^ D47 D72 +error(0.000307975956330275866) D43 D75 ^ D71 D72 +error(0.001859072576991834544) D43 D76 +error(0.002165391394046252676) D43 D76 ^ D47 D48 +error(0.0009431680077149669911) D43 D76 ^ D47 D71 +error(0.001598928756437687122) D43 D76 ^ D47 D72 +error(0.001076978172298284934) D43 D76 ^ D48 D72 +error(0.002627582281132581458) D43 D76 ^ D71 D72 +error(0.01064372101846713069) D44 D45 +error(0.0009906389095932167845) D44 D45 ^ D41 +error(0.0006750162503938480878) D44 D45 ^ D48 D49 +error(3.756848122638768088e-05) D44 D45 ^ D48 D73 +error(0.01267267767955587709) D44 D45 ^ D49 +error(0.004635934828459368356) D44 D45 ^ D49 D73 +error(0.002185403898100024295) D44 D45 ^ D73 +error(0.01336909531579565276) D44 D53 +error(0.01105500658491261057) D44 D53 ^ D48 D49 +error(0.005797025101372838864) D44 D67 +error(0.0003417045946126709161) D44 D67 ^ D72 D73 +error(0.0244028701613570112) D44 D68 +error(0.005035374525287034803) D44 D68 ^ D41 +error(0.001425061471213253782) D44 D68 ^ D72 D73 +error(0.001025440560362546371) D44 D68 ^ D73 +error(0.001739025683189662557) D44 D76 +error(0.0005163048540822849121) D44 D76 ^ D47 D48 +error(0.0003872660728112318042) D44 D76 ^ D47 D72 +error(0.001010208392926537947) D44 D76 ^ D48 D72 +error(0.0003614633525562173117) D44 D76 ^ D48 D73 +error(0.0007708242313029848268) D44 D76 ^ D72 D73 +error(0.002829373934999426885) D44 D77 +error(0.001161648608437570009) D44 D77 ^ D48 D49 +error(0.0004817648811728498333) D44 D77 ^ D48 D72 +error(0.002369403621825834708) D44 D77 ^ D48 D73 +error(0.0004523255119455854285) D44 D77 ^ D49 D73 +error(0.00243362505591642516) D44 D77 ^ D72 D73 +error(0.00845022675102432598) D45 +error(0.003122593618286308333) D45 D68 +error(0.0003444676573668129416) D45 D68 ^ D41 +error(0.003029471903265145566) D45 D68 ^ D73 +error(0.02878109383905069762) D45 D69 +error(0.005245455859824325884) D45 D69 ^ D73 +error(0.002444244415730570993) D45 D77 +error(1.320503562624765046e-05) D45 D77 ^ D48 D49 +error(0.000319071422289989796) D45 D77 ^ D48 D73 +error(0.002504366306824067946) D45 D77 ^ D49 D73 +error(0.01376696901986126757) D45 ^ D49 +error(0.0004076332642725224499) D45 ^ D73 +error(0.001893217879630942077) D45 ^ D73 ^ D49 +error(0.01079365791184803448) D46 +error(0.01463814118025971722) D46 D47 +error(0.0003749792498749710858) D46 D47 ^ D18 L0 +error(0.0005400820725793096383) D46 D47 ^ D50 D51 +error(0.000418692903235950032) D46 D47 ^ D51 D52 +error(0.001712985178897279354) D46 D47 ^ D51 D75 +error(4.669523646288583138e-05) D46 D47 ^ D52 D75 +error(0.04918066768488339735) D46 D70 +error(0.00367209971397850464) D46 D70 ^ D74 D75 +error(0.001587061349442817852) D46 D71 +error(0.0006664841908282826029) D46 D71 ^ D74 D75 +error(0.0004431564671695123817) D46 D78 +error(9.765646950254146724e-06) D46 D78 ^ D51 D52 +error(0.0006406541570109316498) D46 D78 ^ D51 D75 +error(5.274589083871283256e-05) D46 D78 ^ D52 D75 +error(0.0117889524045072993) D46 ^ D50 L0 +error(0.004137845564894525492) D50 D74 ^ D46 +error(0.02263828873602833844) D47 D48 +error(0.0001702276148531519891) D47 D48 ^ D51 D52 +error(0.0008834832228674967128) D47 D48 ^ D52 D53 +error(0.002753689268113585723) D47 D48 ^ D52 D76 +error(0.0005499538130014023632) D47 D48 ^ D53 D76 +error(0.01909106726931757148) D47 D54 +error(0.02001517208706354509) D47 D54 ^ D51 D52 +error(0.02812184381392778681) D47 D71 +error(0.002607359131359769482) D47 D71 ^ D75 D76 +error(0.003969053395153494292) D47 D72 +error(4.689775471165016457e-05) D47 D72 ^ D75 D76 +error(0.008075155730227432868) D47 D78 +error(0.005353779632917887721) D47 D78 ^ D51 D52 +error(0.0008750595983553233767) D47 D78 ^ D51 D75 +error(0.007885636642307748342) D47 D78 ^ D52 D75 +error(0.001752721336947414684) D47 D78 ^ D52 D76 +error(0.00216109320394393227) D47 D78 ^ D75 D76 +error(0.002431970761268770556) D47 D79 +error(0.0006784536717705084465) D47 D79 ^ D52 D53 +error(4.63592763270954906e-05) D47 D79 ^ D52 D75 +error(0.001397725395569435333) D47 D79 ^ D52 D76 +error(0.0004419636415501518398) D47 D79 ^ D53 D76 +error(0.0003189261836387721327) D47 D79 ^ D75 D76 +error(0.008150338982270402197) D48 D49 +error(0.0006312850411417316072) D48 D49 ^ D52 D53 +error(8.050646160119902803e-05) D48 D49 ^ D53 +error(0.001278512356325647685) D48 D49 ^ D53 D77 +error(0.0007020451534826920416) D48 D49 ^ D77 +error(0.01277332616325764329) D48 D55 +error(0.01048264638225490653) D48 D55 ^ D52 D53 +error(0.02278187818030543224) D48 D72 +error(0.002407124538276740958) D48 D72 ^ D76 D77 +error(0.003075712190512780442) D48 D73 +error(0.0005860246305094125689) D48 D73 ^ D76 D77 +error(0.002095085221072178795) D48 D79 +error(0.002204476815442909295) D48 D79 ^ D52 D53 +error(0.001398016024156229289) D48 D79 ^ D52 D76 +error(0.001998355767841102602) D48 D79 ^ D53 D76 +error(0.001286846742682906837) D48 D79 ^ D53 D77 +error(0.001863213582515296481) D48 D79 ^ D76 D77 +error(0.001997153633049718324) D48 D80 +error(2.598292875153643494e-05) D48 D80 ^ D53 D76 +error(0.001173331601012149233) D48 D80 ^ D53 D77 +error(0.0002874234325142206487) D48 D80 ^ D76 D77 +error(1.821438837082284888e-05) D48 D80 ^ D77 +error(0.01006454994273055757) D49 +error(0.0161206695668114873) D49 D56 +error(0.01737570254568924361) D49 D56 ^ D53 +error(0.0250505139273094167) D49 D73 +error(0.002345018263775333536) D49 D73 ^ D77 +error(0.003073065190622500248) D49 D80 +error(0.002579449672997942682) D49 D80 ^ D53 +error(0.003836377064377697373) D49 D80 ^ D77 +error(0.0006646277758526700783) D49 D80 ^ D77 ^ D53 +error(0.01577597104453927479) D50 D51 +error(0.003795651666848288541) D50 D51 ^ D22 +error(0.01692448812617893331) D50 D51 ^ D46 +error(0.0008288896859749987807) D50 D51 ^ D54 ^ D22 +error(0.0191985177099640858) D50 D74 +error(0.01034173018792707011) D50 L0 +error(0.0004662125493391324252) D50 L0 ^ D18 L0 ^ D46 +error(0.0007989884919774482971) D50 L0 ^ D46 ^ D22 +error(0.01669196318468137152) D51 D52 +error(0.0002275964588231474655) D51 D52 ^ D54 +error(0.001080582133475241997) D51 D52 ^ D54 D55 +error(0.003377679907839793976) D51 D52 ^ D54 D78 +error(0.0004409901630161987838) D51 D52 ^ D78 +error(0.01456851983540525391) D51 D57 +error(0.01235616231143815344) D51 D57 ^ D54 +error(0.00378888098077427701) D51 D74 +error(0.002826407968055778298) D51 D74 ^ D46 +error(0.0001197399291263810575) D51 D74 ^ D78 +error(0.0003950766148601412729) D51 D74 ^ D78 ^ D46 +error(0.02650863068338265086) D51 D75 +error(0.002052387878255866605) D51 D75 ^ D46 +error(0.005693851689366329419) D51 D75 ^ D78 +error(0.00279004820284349574) D51 D81 +error(0.001376537795732491343) D51 D81 ^ D54 +error(0.002887687896721477781) D51 D81 ^ D78 +error(0.001094217013606597596) D51 D81 ^ D78 ^ D54 +error(0.007394753493446600857) D52 D53 +error(0.0005665103155747660754) D52 D53 ^ D54 D55 +error(0.0002961719484165020928) D52 D53 ^ D54 D79 +error(0.0007675096502073114812) D52 D53 ^ D55 D56 +error(0.002862427649248453464) D52 D53 ^ D55 D79 +error(0.01375412502619386378) D52 D58 +error(0.01096105179196072039) D52 D58 ^ D54 D55 +error(0.008487365324421063117) D52 D75 +error(0.02457592249931421502) D52 D76 +error(0.002631812399044814853) D52 D76 ^ D78 D79 +error(0.002198804135129999587) D52 D81 +error(0.001654137015294186892) D52 D81 ^ D54 D78 +error(6.003632573794476984e-06) D52 D81 ^ D54 D79 +error(0.0004409060199606022593) D52 D81 ^ D78 +error(0.002192299185518550592) D52 D82 +error(0.001746414734417907517) D52 D82 ^ D54 D55 +error(0.0003598999091759262268) D52 D82 ^ D54 D78 +error(0.001561544017991810512) D52 D82 ^ D54 D79 +error(0.000466227982502727986) D52 D82 ^ D55 D79 +error(0.001724344060558972601) D52 D82 ^ D78 D79 +error(0.01203579788742147917) D53 +error(0.004387356071761702725) D53 D76 +error(0.000208029715498591483) D53 D76 ^ D79 D80 +error(0.02221100964778081194) D53 D77 +error(0.001439615781168439605) D53 D77 ^ D79 D80 +error(0.001201823867210177017) D53 D82 +error(0.0001012650403590720146) D53 D82 ^ D54 D55 +error(0.0003034946049630618146) D53 D82 ^ D54 D79 +error(0.001323584720901610371) D53 D82 ^ D55 D79 +error(0.0007926983696969233488) D53 ^ D21 ^ D25 +error(0.0005235978985522322894) D53 ^ D21 ^ D49 +error(0.001537789608391964321) D53 ^ D25 +error(0.01000000000000000021) D54 +error(0.007026141351062988212) D54 D55 +error(0.0009672799566260600846) D54 D55 ^ D57 D58 +error(0.002612338632211596515) D54 D55 ^ D58 D82 +error(0.0008620297320340863934) D54 D55 ^ D82 +error(0.03555466847524565294) D54 D78 +error(0.004257613433980646928) D54 D78 ^ D81 D82 +error(0.003914888887922909726) D54 D79 +error(0.0008393621947703528048) D54 D79 ^ D81 D82 +error(0.0006392754687906603917) D54 D83 +error(0.0002831750050793343447) D54 D83 ^ D58 +error(0.001693673795440791933) D54 D83 ^ D58 D82 +error(7.480679588459883279e-06) D54 D83 ^ D82 +error(0.01861532100512389154) D55 D56 +error(0.00222125091587972506) D55 D56 ^ D29 +error(0.01207571090899253741) D55 D56 ^ D53 +error(0.0002065846548685445908) D55 D56 ^ D58 +error(0.0003301188119060698405) D55 D56 ^ D58 ^ D29 +error(0.01744050413829207127) D55 D59 +error(0.01542382289075709852) D55 D59 ^ D58 +error(0.02667661522528785162) D55 D79 +error(0.001456372037112019452) D55 D79 ^ D53 +error(0.00368662532011345247) D55 D79 ^ D82 +error(0.002088453177880326885) D55 D80 +error(0.002632780704037000936) D55 D80 ^ D53 +error(0.0002114179196296893338) D55 D80 ^ D82 ^ D53 +error(0.004110481756233741457) D55 D83 +error(0.002802723964281605973) D55 D83 ^ D58 +error(0.003798397130707047414) D55 D83 ^ D82 +error(0.001977355296201686527) D55 D83 ^ D82 ^ D58 +error(0.02679340452938059822) D56 D80 +error(0.002535959682426708415) D56 D80 ^ D53 +error(0.006074521331256080119) D57 D58 +error(0.001500890887174470556) D57 D58 ^ D30 +error(0.01131498296823086475) D57 D58 ^ D54 +error(0.0004481007348183289017) D57 D58 ^ D59 +error(0.0004597114541739146941) D57 D58 ^ D59 ^ D30 +error(0.02900709638648528779) D57 D81 +error(0.003760545837299076113) D57 D81 ^ D54 +error(0.01000000000000000021) D58 +error(0.001742126190683423136) D58 D81 +error(0.002377235945765063599) D58 D81 ^ D54 +error(0.000899953914339936766) D58 D81 ^ D83 +error(0.0004872680715309037156) D58 D81 ^ D83 ^ D54 +error(0.02110557026819835647) D58 D82 +error(0.0003712607219078131976) D58 D82 ^ D54 +error(0.00170219714362124892) D58 D82 ^ D83 +error(0.009114652556981153037) D58 ^ D59 +error(0.001301279920715417773) D58 ^ D83 +error(0.003066610980423866654) D59 D83 ^ D58 +error(0.009282272384986160405) D59 +error(0.01920747822175144712) D59 D83 +error(0.005000000000000000104) D60 +error(0.01596805964649321286) D60 D64 +error(0.01829778043055142397) D60 D64 ^ D61 L0 +error(0.0266862725621760527) D60 D84 +error(0.006857640050321386731) D60 D84 ^ D85 L0 +error(0.006904323411147515743) D60 D88 +error(0.004290343924348420136) D60 D88 ^ D61 L0 +error(0.004718005776907755952) D60 D88 ^ D85 L0 +error(0.002682747303679847845) D60 D88 ^ D85 L0 ^ D61 L0 +error(0.003222820645970455884) D60 D89 +error(0.002413814734477126925) D60 D89 ^ D61 D85 +error(0.0009759754382860813841) D60 D89 ^ D61 L0 +error(0.001484037307585785734) D60 D89 ^ D85 L0 +error(0.006310960120927104275) D60 ^ D61 L0 +error(0.005322407363730898185) D61 D85 ^ D60 +error(0.006735703095373630871) D61 D62 +error(0.0008816988361899102695) D61 D62 ^ D60 +error(0.0001283013300070091228) D61 D62 ^ D64 D65 +error(0.0002940482682934252782) D61 D62 ^ D64 D89 +error(0.0147823200156403517) D61 D62 ^ D65 +error(0.003440266269014606582) D61 D62 ^ D65 D89 +error(0.002728099968767540903) D61 D62 ^ D89 +error(0.0003101067761686230142) D61 D62 ^ D89 ^ D60 +error(0.02055897619164840859) D61 D67 +error(0.01315370144244269388) D61 D67 ^ D64 D65 +error(0.04054698510964466207) D61 D85 +error(0.003068906748310869584) D61 D85 ^ D88 D89 +error(0.004135165380719954369) D61 D85 ^ D89 +error(0.00170148481970367675) D61 D90 +error(0.002569670009209375477) D61 D90 ^ D64 D88 +error(0.0003645001291986636185) D61 D90 ^ D64 D89 +error(0.0006562264584675363841) D61 D90 ^ D88 D89 +error(0.00358204353642006942) D61 D91 +error(0.001864374047664434922) D61 D91 ^ D64 D65 +error(0.0003932828383309873183) D61 D91 ^ D64 D88 +error(0.001848434604000002719) D61 D91 ^ D64 D89 +error(0.0001774661344280517637) D61 D91 ^ D65 D89 +error(0.002210991227743962402) D61 D91 ^ D88 D89 +error(0.01000000000000000021) D61 L0 +error(0.01675927044650943679) D62 D68 +error(0.01483521393192921423) D62 D68 ^ D65 +error(0.004719946072497860183) D62 D85 +error(0.0007165835560042144777) D62 D85 ^ D60 +error(0.004779816248476202387) D62 D85 ^ D89 +error(0.0005462343302855433153) D62 D85 ^ D89 ^ D60 +error(0.04658633835913435217) D62 D86 +error(0.009873875383543916084) D62 D86 ^ D89 +error(0.002326384940569728357) D62 D91 +error(0.0005686665129455996306) D62 D91 ^ D64 D65 +error(0.0002337464378640189766) D62 D91 ^ D64 D89 +error(0.000491201243452230301) D62 D91 ^ D65 +error(0.001361197307204584225) D62 D91 ^ D65 D89 +error(0.0005238546515356713642) D62 D91 ^ D89 +error(0.003606535288512647489) D62 D92 +error(0.002939925401372571381) D62 D92 ^ D65 +error(0.002886682013661131477) D62 D92 ^ D89 +error(0.001451469642847544881) D62 D92 ^ D89 ^ D65 +error(0.009299079482444108993) D63 D64 +error(0.0001618067361763870105) D63 D64 ^ D61 L0 +error(0.0004009870402910406875) D63 D64 ^ D66 D67 +error(0.002038993562470617187) D63 D64 ^ D66 D90 +error(0.009839797261860206215) D63 D64 ^ D66 L0 +error(1.613708403102963708e-05) D63 D64 ^ D67 D90 +error(0.001420262771992301942) D63 D64 ^ D90 L0 +error(0.0007398317957289404605) D63 D64 ^ D90 L0 ^ D61 L0 +error(0.01276385364945899735) D63 D70 +error(0.011096381866881758) D63 D70 ^ D66 L0 +error(0.02360888144805250999) D63 D87 +error(0.003659423329073996974) D63 D87 ^ D90 L0 +error(0.002152186614080534195) D63 D88 +error(0.000456204478737577343) D63 D88 ^ D61 L0 +error(0.002391715036470463789) D63 D88 ^ D90 L0 +error(0.0001736009261800634882) D63 D88 ^ D90 L0 ^ D61 L0 +error(0.002929594954205079742) D63 D94 +error(0.003607534314359686634) D63 D94 ^ D66 L0 +error(0.002145454612411112471) D63 D94 ^ D90 L0 +error(0.0006842560657499791943) D63 D94 ^ D90 L0 ^ D66 L0 +error(0.002734468661554086567) D63 D95 +error(0.0003213799321281471302) D63 D95 ^ D66 D67 +error(0.001292369671938379096) D63 D95 ^ D66 D90 +error(0.0006814453156953355741) D63 D95 ^ D66 L0 +error(0.000171429172347746983) D63 D95 ^ D67 D90 +error(2.241052274140109318e-05) D63 D95 ^ D90 L0 +error(0.008061141833768614012) D64 D65 +error(5.603595358604616684e-05) D64 D65 ^ D37 L0 +error(0.0003240145466437737223) D64 D65 ^ D61 L0 +error(0.0007894832832053461135) D64 D65 ^ D66 D67 +error(0.0009388025834094447519) D64 D65 ^ D67 D68 +error(0.001594794524676789067) D64 D65 ^ D67 D91 +error(0.01499707882523569624) D64 D71 +error(0.009686274303190828272) D64 D71 ^ D66 D67 +error(0.02687355039480195801) D64 D88 +error(0.007485819796524218438) D64 D88 ^ D61 L0 +error(0.003107469568972692602) D64 D88 ^ D90 D91 +error(0.0005680536236455682427) D64 D88 ^ D90 L0 +error(0.003211879643569449851) D64 D89 +error(0.000376529833666304839) D64 D89 ^ D90 D91 +error(0.00120063201568994444) D64 D95 +error(0.002765100742562540039) D64 D95 ^ D66 D67 +error(0.001443006512690684761) D64 D95 ^ D66 D90 +error(0.001963765223827605017) D64 D95 ^ D67 D90 +error(0.001561962824876994256) D64 D95 ^ D67 D91 +error(0.001924240942830092883) D64 D95 ^ D90 D91 +error(0.001978648078269987665) D64 D96 +error(0.0003155662468816377805) D64 D96 ^ D67 D68 +error(0.0002941715103168643678) D64 D96 ^ D67 D90 +error(0.001543894821161831106) D64 D96 ^ D67 D91 +error(0.01000000000000000021) D65 +error(0.01996187733386350568) D65 D72 +error(0.0188611843799036949) D65 D72 ^ D67 D68 +error(0.03083190651367225324) D65 D89 +error(0.002851553572250035279) D65 D89 ^ D91 D92 +error(0.003781520367195873988) D65 D96 +error(0.002268950364954752229) D65 D96 ^ D67 D68 +error(0.001088491258235638843) D65 D96 ^ D67 D91 +error(0.002124756255297351182) D65 D96 ^ D68 D91 +error(0.0005882412221558847064) D65 D96 ^ D68 D92 +error(0.002574093098742098219) D65 D96 ^ D91 D92 +error(0.003029302145153121503) D65 D97 +error(0.001158629973361129974) D65 D97 ^ D68 D92 +error(0.0004212946613479972625) D65 D97 ^ D91 D92 +error(0.00708325686996343247) D66 D67 +error(0.001146243462908609796) D66 D67 ^ D70 D71 +error(0.000456805822531424063) D66 D67 ^ D70 D95 +error(0.000304813137048891682) D66 D67 ^ D71 D72 +error(0.002634276171414426122) D66 D67 ^ D71 D95 +error(0.01612767423445998077) D66 D75 +error(0.01171697673212769748) D66 D75 ^ D70 D71 +error(0.03918384738513067123) D66 D90 +error(0.002228925530581629937) D66 D90 ^ D94 D95 +error(0.001722182253290977872) D66 D98 +error(0.00257234959439087401) D66 D98 ^ D70 D94 +error(0.0006935910585423644449) D66 D98 ^ D70 D95 +error(0.0005515214868894067427) D66 D98 ^ D94 D95 +error(0.003685515877434647394) D66 D99 +error(0.002490979275654284057) D66 D99 ^ D70 D71 +error(0.00230918351195979598) D66 D99 ^ D70 D94 +error(0.001594143301527340979) D66 D99 ^ D70 D95 +error(0.0006317460369945696042) D66 D99 ^ D71 D95 +error(0.001985781331922381338) D66 D99 ^ D94 D95 +error(0.01000000000000000021) D66 L0 +error(0.002783689788661022121) D70 D94 ^ D66 L0 +error(0.00974687687898492458) D67 D68 +error(0.0003747287983380178798) D67 D68 ^ D71 D72 +error(0.0004743688286892290226) D67 D68 ^ D71 D96 +error(5.278044991932393068e-05) D67 D68 ^ D72 D73 +error(0.001157504928862029348) D67 D68 ^ D72 D96 +error(0.01675403094458132944) D67 D76 +error(0.01519293603187372999) D67 D76 ^ D71 D72 +error(0.003434296201232148876) D67 D90 +error(0.000572720380022092657) D67 D90 ^ D95 D96 +error(0.03896029464506293311) D67 D91 +error(0.001919558353366188335) D67 D91 ^ D95 D96 +error(0.000483343676407702429) D67 D99 +error(0.0002960171048330712418) D67 D99 ^ D70 D71 +error(0.002043284550463939) D67 D99 ^ D71 D95 +error(0.0008359769467140544747) D67 D99 ^ D71 D96 +error(0.000307975956330275866) D67 D99 ^ D95 D96 +error(0.001859072576991834544) D67 D100 +error(0.002165391394046252676) D67 D100 ^ D71 D72 +error(0.0009431680077149669911) D67 D100 ^ D71 D95 +error(0.001598928756437687122) D67 D100 ^ D71 D96 +error(0.001076978172298284934) D67 D100 ^ D72 D96 +error(0.002627582281132581458) D67 D100 ^ D95 D96 +error(0.01064372101846713069) D68 D69 +error(0.0009906389095932167845) D68 D69 ^ D65 +error(0.0006750162503938480878) D68 D69 ^ D72 D73 +error(3.756848122638768088e-05) D68 D69 ^ D72 D97 +error(0.01267267767955587709) D68 D69 ^ D73 +error(0.004635934828459368356) D68 D69 ^ D73 D97 +error(0.002185403898100024295) D68 D69 ^ D97 +error(0.01336909531579565276) D68 D77 +error(0.01105500658491261057) D68 D77 ^ D72 D73 +error(0.005797025101372838864) D68 D91 +error(0.0003417045946126709161) D68 D91 ^ D96 D97 +error(0.0244028701613570112) D68 D92 +error(0.005035374525287034803) D68 D92 ^ D65 +error(0.001425061471213253782) D68 D92 ^ D96 D97 +error(0.001025440560362546371) D68 D92 ^ D97 +error(0.001739025683189662557) D68 D100 +error(0.0005163048540822849121) D68 D100 ^ D71 D72 +error(0.0003872660728112318042) D68 D100 ^ D71 D96 +error(0.001010208392926537947) D68 D100 ^ D72 D96 +error(0.0003614633525562173117) D68 D100 ^ D72 D97 +error(0.0007708242313029848268) D68 D100 ^ D96 D97 +error(0.002829373934999426885) D68 D101 +error(0.001161648608437570009) D68 D101 ^ D72 D73 +error(0.0004817648811728498333) D68 D101 ^ D72 D96 +error(0.002369403621825834708) D68 D101 ^ D72 D97 +error(0.0004523255119455854285) D68 D101 ^ D73 D97 +error(0.00243362505591642516) D68 D101 ^ D96 D97 +error(0.00845022675102432598) D69 +error(0.003122593618286308333) D69 D92 +error(0.0003444676573668129416) D69 D92 ^ D65 +error(0.003029471903265145566) D69 D92 ^ D97 +error(0.02878109383905069762) D69 D93 +error(0.005245455859824325884) D69 D93 ^ D97 +error(0.002444244415730570993) D69 D101 +error(1.320503562624765046e-05) D69 D101 ^ D72 D73 +error(0.000319071422289989796) D69 D101 ^ D72 D97 +error(0.002504366306824067946) D69 D101 ^ D73 D97 +error(0.01376696901986126757) D69 ^ D73 +error(0.0004076332642725224499) D69 ^ D97 +error(0.001893217879630942077) D69 ^ D97 ^ D73 +error(0.01079365791184803448) D70 +error(0.01463814118025971722) D70 D71 +error(0.0003749792498749710858) D70 D71 ^ D42 L0 +error(0.0005400820725793096383) D70 D71 ^ D74 D75 +error(0.000418692903235950032) D70 D71 ^ D75 D76 +error(0.001712985178897279354) D70 D71 ^ D75 D99 +error(4.669523646288583138e-05) D70 D71 ^ D76 D99 +error(0.04918066768488339735) D70 D94 +error(0.00367209971397850464) D70 D94 ^ D98 D99 +error(0.001587061349442817852) D70 D95 +error(0.0006664841908282826029) D70 D95 ^ D98 D99 +error(0.0004431564671695123817) D70 D102 +error(9.765646950254146724e-06) D70 D102 ^ D75 D76 +error(0.0006406541570109316498) D70 D102 ^ D75 D99 +error(5.274589083871283256e-05) D70 D102 ^ D76 D99 +error(0.0117889524045072993) D70 ^ D74 L0 +error(0.004137845564894525492) D74 D98 ^ D70 +error(0.02263828873602833844) D71 D72 +error(0.0001702276148531519891) D71 D72 ^ D75 D76 +error(0.0008834832228674967128) D71 D72 ^ D76 D77 +error(0.002753689268113585723) D71 D72 ^ D76 D100 +error(0.0005499538130014023632) D71 D72 ^ D77 D100 +error(0.01909106726931757148) D71 D78 +error(0.02001517208706354509) D71 D78 ^ D75 D76 +error(0.02812184381392778681) D71 D95 +error(0.002607359131359769482) D71 D95 ^ D99 D100 +error(0.003969053395153494292) D71 D96 +error(4.689775471165016457e-05) D71 D96 ^ D99 D100 +error(0.008075155730227432868) D71 D102 +error(0.005353779632917887721) D71 D102 ^ D75 D76 +error(0.0008750595983553233767) D71 D102 ^ D75 D99 +error(0.007885636642307748342) D71 D102 ^ D76 D99 +error(0.001752721336947414684) D71 D102 ^ D76 D100 +error(0.00216109320394393227) D71 D102 ^ D99 D100 +error(0.002431970761268770556) D71 D103 +error(0.0006784536717705084465) D71 D103 ^ D76 D77 +error(4.63592763270954906e-05) D71 D103 ^ D76 D99 +error(0.001397725395569435333) D71 D103 ^ D76 D100 +error(0.0004419636415501518398) D71 D103 ^ D77 D100 +error(0.0003189261836387721327) D71 D103 ^ D99 D100 +error(0.008150338982270402197) D72 D73 +error(0.0006312850411417316072) D72 D73 ^ D76 D77 +error(8.050646160119902803e-05) D72 D73 ^ D77 +error(0.001278512356325647685) D72 D73 ^ D77 D101 +error(0.0007020451534826920416) D72 D73 ^ D101 +error(0.01277332616325764329) D72 D79 +error(0.01048264638225490653) D72 D79 ^ D76 D77 +error(0.02278187818030543224) D72 D96 +error(0.002407124538276740958) D72 D96 ^ D100 D101 +error(0.003075712190512780442) D72 D97 +error(0.0005860246305094125689) D72 D97 ^ D100 D101 +error(0.002095085221072178795) D72 D103 +error(0.002204476815442909295) D72 D103 ^ D76 D77 +error(0.001398016024156229289) D72 D103 ^ D76 D100 +error(0.001998355767841102602) D72 D103 ^ D77 D100 +error(0.001286846742682906837) D72 D103 ^ D77 D101 +error(0.001863213582515296481) D72 D103 ^ D100 D101 +error(0.001997153633049718324) D72 D104 +error(2.598292875153643494e-05) D72 D104 ^ D77 D100 +error(0.001173331601012149233) D72 D104 ^ D77 D101 +error(0.0002874234325142206487) D72 D104 ^ D100 D101 +error(1.821438837082284888e-05) D72 D104 ^ D101 +error(0.01006454994273055757) D73 +error(0.0161206695668114873) D73 D80 +error(0.01737570254568924361) D73 D80 ^ D77 +error(0.0250505139273094167) D73 D97 +error(0.002345018263775333536) D73 D97 ^ D101 +error(0.003073065190622500248) D73 D104 +error(0.002579449672997942682) D73 D104 ^ D77 +error(0.003836377064377697373) D73 D104 ^ D101 +error(0.0006646277758526700783) D73 D104 ^ D101 ^ D77 +error(0.01577597104453927479) D74 D75 +error(0.003795651666848288541) D74 D75 ^ D46 +error(0.01692448812617893331) D74 D75 ^ D70 +error(0.0008288896859749987807) D74 D75 ^ D78 ^ D46 +error(0.0191985177099640858) D74 D98 +error(0.01034173018792707011) D74 L0 +error(0.0004662125493391324252) D74 L0 ^ D42 L0 ^ D70 +error(0.0007989884919774482971) D74 L0 ^ D70 ^ D46 +error(0.01669196318468137152) D75 D76 +error(0.0002275964588231474655) D75 D76 ^ D78 +error(0.001080582133475241997) D75 D76 ^ D78 D79 +error(0.003377679907839793976) D75 D76 ^ D78 D102 +error(0.0004409901630161987838) D75 D76 ^ D102 +error(0.01456851983540525391) D75 D81 +error(0.01235616231143815344) D75 D81 ^ D78 +error(0.00378888098077427701) D75 D98 +error(0.002826407968055778298) D75 D98 ^ D70 +error(0.0001197399291263810575) D75 D98 ^ D102 +error(0.0003950766148601412729) D75 D98 ^ D102 ^ D70 +error(0.02650863068338265086) D75 D99 +error(0.002052387878255866605) D75 D99 ^ D70 +error(0.005693851689366329419) D75 D99 ^ D102 +error(0.00279004820284349574) D75 D105 +error(0.001376537795732491343) D75 D105 ^ D78 +error(0.002887687896721477781) D75 D105 ^ D102 +error(0.001094217013606597596) D75 D105 ^ D102 ^ D78 +error(0.007394753493446600857) D76 D77 +error(0.0005665103155747660754) D76 D77 ^ D78 D79 +error(0.0002961719484165020928) D76 D77 ^ D78 D103 +error(0.0007675096502073114812) D76 D77 ^ D79 D80 +error(0.002862427649248453464) D76 D77 ^ D79 D103 +error(0.01375412502619386378) D76 D82 +error(0.01096105179196072039) D76 D82 ^ D78 D79 +error(0.008487365324421063117) D76 D99 +error(0.02457592249931421502) D76 D100 +error(0.002631812399044814853) D76 D100 ^ D102 D103 +error(0.002198804135129999587) D76 D105 +error(0.001654137015294186892) D76 D105 ^ D78 D102 +error(6.003632573794476984e-06) D76 D105 ^ D78 D103 +error(0.0004409060199606022593) D76 D105 ^ D102 +error(0.002192299185518550592) D76 D106 +error(0.001746414734417907517) D76 D106 ^ D78 D79 +error(0.0003598999091759262268) D76 D106 ^ D78 D102 +error(0.001561544017991810512) D76 D106 ^ D78 D103 +error(0.000466227982502727986) D76 D106 ^ D79 D103 +error(0.001724344060558972601) D76 D106 ^ D102 D103 +error(0.01203579788742147917) D77 +error(0.004387356071761702725) D77 D100 +error(0.000208029715498591483) D77 D100 ^ D103 D104 +error(0.02221100964778081194) D77 D101 +error(0.001439615781168439605) D77 D101 ^ D103 D104 +error(0.001201823867210177017) D77 D106 +error(0.0001012650403590720146) D77 D106 ^ D78 D79 +error(0.0003034946049630618146) D77 D106 ^ D78 D103 +error(0.001323584720901610371) D77 D106 ^ D79 D103 +error(0.0007926983696969233488) D77 ^ D45 ^ D49 +error(0.0005235978985522322894) D77 ^ D45 ^ D73 +error(0.001537789608391964321) D77 ^ D49 +error(0.01000000000000000021) D78 +error(0.007026141351062988212) D78 D79 +error(0.0009672799566260600846) D78 D79 ^ D81 D82 +error(0.002612338632211596515) D78 D79 ^ D82 D106 +error(0.0008620297320340863934) D78 D79 ^ D106 +error(0.03555466847524565294) D78 D102 +error(0.004257613433980646928) D78 D102 ^ D105 D106 +error(0.003914888887922909726) D78 D103 +error(0.0008393621947703528048) D78 D103 ^ D105 D106 +error(0.0006392754687906603917) D78 D107 +error(0.0002831750050793343447) D78 D107 ^ D82 +error(0.001693673795440791933) D78 D107 ^ D82 D106 +error(7.480679588459883279e-06) D78 D107 ^ D106 +error(0.01861532100512389154) D79 D80 +error(0.00222125091587972506) D79 D80 ^ D53 +error(0.01207571090899253741) D79 D80 ^ D77 +error(0.0002065846548685445908) D79 D80 ^ D82 +error(0.0003301188119060698405) D79 D80 ^ D82 ^ D53 +error(0.01744050413829207127) D79 D83 +error(0.01542382289075709852) D79 D83 ^ D82 +error(0.02667661522528785162) D79 D103 +error(0.001456372037112019452) D79 D103 ^ D77 +error(0.00368662532011345247) D79 D103 ^ D106 +error(0.002088453177880326885) D79 D104 +error(0.002632780704037000936) D79 D104 ^ D77 +error(0.0002114179196296893338) D79 D104 ^ D106 ^ D77 +error(0.004110481756233741457) D79 D107 +error(0.002802723964281605973) D79 D107 ^ D82 +error(0.003798397130707047414) D79 D107 ^ D106 +error(0.001977355296201686527) D79 D107 ^ D106 ^ D82 +error(0.02679340452938059822) D80 D104 +error(0.002535959682426708415) D80 D104 ^ D77 +error(0.006074521331256080119) D81 D82 +error(0.001500890887174470556) D81 D82 ^ D54 +error(0.01131498296823086475) D81 D82 ^ D78 +error(0.0004481007348183289017) D81 D82 ^ D83 +error(0.0004597114541739146941) D81 D82 ^ D83 ^ D54 +error(0.02900709638648528779) D81 D105 +error(0.003760545837299076113) D81 D105 ^ D78 +error(0.01000000000000000021) D82 +error(0.001742126190683423136) D82 D105 +error(0.002377235945765063599) D82 D105 ^ D78 +error(0.000899953914339936766) D82 D105 ^ D107 +error(0.0004872680715309037156) D82 D105 ^ D107 ^ D78 +error(0.02110557026819835647) D82 D106 +error(0.0003712607219078131976) D82 D106 ^ D78 +error(0.00170219714362124892) D82 D106 ^ D107 +error(0.009114652556981153037) D82 ^ D83 +error(0.001301279920715417773) D82 ^ D107 +error(0.003066610980423866654) D83 D107 ^ D82 +error(0.009282272384986160405) D83 +error(0.01920747822175144712) D83 D107 +error(0.005000000000000000104) D84 +error(0.01596805964649321286) D84 D88 +error(0.01829778043055142397) D84 D88 ^ D85 L0 +error(0.0266862725621760527) D84 D108 +error(0.006857640050321386731) D84 D108 ^ D109 L0 +error(0.006904323411147515743) D84 D112 +error(0.004290343924348420136) D84 D112 ^ D85 L0 +error(0.004718005776907755952) D84 D112 ^ D109 L0 +error(0.002682747303679847845) D84 D112 ^ D109 L0 ^ D85 L0 +error(0.003222820645970455884) D84 D113 +error(0.002413814734477126925) D84 D113 ^ D85 D109 +error(0.0009759754382860813841) D84 D113 ^ D85 L0 +error(0.001484037307585785734) D84 D113 ^ D109 L0 +error(0.006310960120927104275) D84 ^ D85 L0 +error(0.005322407363730898185) D85 D109 ^ D84 +error(0.006735703095373630871) D85 D86 +error(0.0008816988361899102695) D85 D86 ^ D84 +error(0.0001283013300070091228) D85 D86 ^ D88 D89 +error(0.0002940482682934252782) D85 D86 ^ D88 D113 +error(0.0147823200156403517) D85 D86 ^ D89 +error(0.003440266269014606582) D85 D86 ^ D89 D113 +error(0.002728099968767540903) D85 D86 ^ D113 +error(0.0003101067761686230142) D85 D86 ^ D113 ^ D84 +error(0.02055897619164840859) D85 D91 +error(0.01315370144244269388) D85 D91 ^ D88 D89 +error(0.04054698510964466207) D85 D109 +error(0.003068906748310869584) D85 D109 ^ D112 D113 +error(0.004135165380719954369) D85 D109 ^ D113 +error(0.00170148481970367675) D85 D114 +error(0.002569670009209375477) D85 D114 ^ D88 D112 +error(0.0003645001291986636185) D85 D114 ^ D88 D113 +error(0.0006562264584675363841) D85 D114 ^ D112 D113 +error(0.00358204353642006942) D85 D115 +error(0.001864374047664434922) D85 D115 ^ D88 D89 +error(0.0003932828383309873183) D85 D115 ^ D88 D112 +error(0.001848434604000002719) D85 D115 ^ D88 D113 +error(0.0001774661344280517637) D85 D115 ^ D89 D113 +error(0.002210991227743962402) D85 D115 ^ D112 D113 +error(0.01000000000000000021) D85 L0 +error(0.01675927044650943679) D86 D92 +error(0.01483521393192921423) D86 D92 ^ D89 +error(0.004719946072497860183) D86 D109 +error(0.0007165835560042144777) D86 D109 ^ D84 +error(0.004779816248476202387) D86 D109 ^ D113 +error(0.0005462343302855433153) D86 D109 ^ D113 ^ D84 +error(0.04658633835913435217) D86 D110 +error(0.009873875383543916084) D86 D110 ^ D113 +error(0.002326384940569728357) D86 D115 +error(0.0005686665129455996306) D86 D115 ^ D88 D89 +error(0.0002337464378640189766) D86 D115 ^ D88 D113 +error(0.000491201243452230301) D86 D115 ^ D89 +error(0.001361197307204584225) D86 D115 ^ D89 D113 +error(0.0005238546515356713642) D86 D115 ^ D113 +error(0.003606535288512647489) D86 D116 +error(0.002939925401372571381) D86 D116 ^ D89 +error(0.002886682013661131477) D86 D116 ^ D113 +error(0.001451469642847544881) D86 D116 ^ D113 ^ D89 +error(0.009299079482444108993) D87 D88 +error(0.0001618067361763870105) D87 D88 ^ D85 L0 +error(0.0004009870402910406875) D87 D88 ^ D90 D91 +error(0.002038993562470617187) D87 D88 ^ D90 D114 +error(0.009839797261860206215) D87 D88 ^ D90 L0 +error(1.613708403102963708e-05) D87 D88 ^ D91 D114 +error(0.001420262771992301942) D87 D88 ^ D114 L0 +error(0.0007398317957289404605) D87 D88 ^ D114 L0 ^ D85 L0 +error(0.01276385364945899735) D87 D94 +error(0.011096381866881758) D87 D94 ^ D90 L0 +error(0.02360888144805250999) D87 D111 +error(0.003659423329073996974) D87 D111 ^ D114 L0 +error(0.002152186614080534195) D87 D112 +error(0.000456204478737577343) D87 D112 ^ D85 L0 +error(0.002391715036470463789) D87 D112 ^ D114 L0 +error(0.0001736009261800634882) D87 D112 ^ D114 L0 ^ D85 L0 +error(0.002929594954205079742) D87 D118 +error(0.003607534314359686634) D87 D118 ^ D90 L0 +error(0.002145454612411112471) D87 D118 ^ D114 L0 +error(0.0006842560657499791943) D87 D118 ^ D114 L0 ^ D90 L0 +error(0.002734468661554086567) D87 D119 +error(0.0003213799321281471302) D87 D119 ^ D90 D91 +error(0.001292369671938379096) D87 D119 ^ D90 D114 +error(0.0006814453156953355741) D87 D119 ^ D90 L0 +error(0.000171429172347746983) D87 D119 ^ D91 D114 +error(2.241052274140109318e-05) D87 D119 ^ D114 L0 +error(0.008061141833768614012) D88 D89 +error(5.603595358604616684e-05) D88 D89 ^ D61 L0 +error(0.0003240145466437737223) D88 D89 ^ D85 L0 +error(0.0007894832832053461135) D88 D89 ^ D90 D91 +error(0.0009388025834094447519) D88 D89 ^ D91 D92 +error(0.001594794524676789067) D88 D89 ^ D91 D115 +error(0.01499707882523569624) D88 D95 +error(0.009686274303190828272) D88 D95 ^ D90 D91 +error(0.02687355039480195801) D88 D112 +error(0.007485819796524218438) D88 D112 ^ D85 L0 +error(0.003107469568972692602) D88 D112 ^ D114 D115 +error(0.0005680536236455682427) D88 D112 ^ D114 L0 +error(0.003211879643569449851) D88 D113 +error(0.000376529833666304839) D88 D113 ^ D114 D115 +error(0.00120063201568994444) D88 D119 +error(0.002765100742562540039) D88 D119 ^ D90 D91 +error(0.001443006512690684761) D88 D119 ^ D90 D114 +error(0.001963765223827605017) D88 D119 ^ D91 D114 +error(0.001561962824876994256) D88 D119 ^ D91 D115 +error(0.001924240942830092883) D88 D119 ^ D114 D115 +error(0.001978648078269987665) D88 D120 +error(0.0003155662468816377805) D88 D120 ^ D91 D92 +error(0.0002941715103168643678) D88 D120 ^ D91 D114 +error(0.001543894821161831106) D88 D120 ^ D91 D115 +error(0.01000000000000000021) D89 +error(0.01996187733386350568) D89 D96 +error(0.0188611843799036949) D89 D96 ^ D91 D92 +error(0.03083190651367225324) D89 D113 +error(0.002851553572250035279) D89 D113 ^ D115 D116 +error(0.003781520367195873988) D89 D120 +error(0.002268950364954752229) D89 D120 ^ D91 D92 +error(0.001088491258235638843) D89 D120 ^ D91 D115 +error(0.002124756255297351182) D89 D120 ^ D92 D115 +error(0.0005882412221558847064) D89 D120 ^ D92 D116 +error(0.002574093098742098219) D89 D120 ^ D115 D116 +error(0.003029302145153121503) D89 D121 +error(0.001158629973361129974) D89 D121 ^ D92 D116 +error(0.0004212946613479972625) D89 D121 ^ D115 D116 +error(0.00708325686996343247) D90 D91 +error(0.001146243462908609796) D90 D91 ^ D94 D95 +error(0.000456805822531424063) D90 D91 ^ D94 D119 +error(0.000304813137048891682) D90 D91 ^ D95 D96 +error(0.002634276171414426122) D90 D91 ^ D95 D119 +error(0.01612767423445998077) D90 D99 +error(0.01171697673212769748) D90 D99 ^ D94 D95 +error(0.03918384738513067123) D90 D114 +error(0.002228925530581629937) D90 D114 ^ D118 D119 +error(0.001722182253290977872) D90 D122 +error(0.00257234959439087401) D90 D122 ^ D94 D118 +error(0.0006935910585423644449) D90 D122 ^ D94 D119 +error(0.0005515214868894067427) D90 D122 ^ D118 D119 +error(0.003685515877434647394) D90 D123 +error(0.002490979275654284057) D90 D123 ^ D94 D95 +error(0.00230918351195979598) D90 D123 ^ D94 D118 +error(0.001594143301527340979) D90 D123 ^ D94 D119 +error(0.0006317460369945696042) D90 D123 ^ D95 D119 +error(0.001985781331922381338) D90 D123 ^ D118 D119 +error(0.01000000000000000021) D90 L0 +error(0.002783689788661022121) D94 D118 ^ D90 L0 +error(0.00974687687898492458) D91 D92 +error(0.0003747287983380178798) D91 D92 ^ D95 D96 +error(0.0004743688286892290226) D91 D92 ^ D95 D120 +error(5.278044991932393068e-05) D91 D92 ^ D96 D97 +error(0.001157504928862029348) D91 D92 ^ D96 D120 +error(0.01675403094458132944) D91 D100 +error(0.01519293603187372999) D91 D100 ^ D95 D96 +error(0.003434296201232148876) D91 D114 +error(0.000572720380022092657) D91 D114 ^ D119 D120 +error(0.03896029464506293311) D91 D115 +error(0.001919558353366188335) D91 D115 ^ D119 D120 +error(0.000483343676407702429) D91 D123 +error(0.0002960171048330712418) D91 D123 ^ D94 D95 +error(0.002043284550463939) D91 D123 ^ D95 D119 +error(0.0008359769467140544747) D91 D123 ^ D95 D120 +error(0.000307975956330275866) D91 D123 ^ D119 D120 +error(0.001859072576991834544) D91 D124 +error(0.002165391394046252676) D91 D124 ^ D95 D96 +error(0.0009431680077149669911) D91 D124 ^ D95 D119 +error(0.001598928756437687122) D91 D124 ^ D95 D120 +error(0.001076978172298284934) D91 D124 ^ D96 D120 +error(0.002627582281132581458) D91 D124 ^ D119 D120 +error(0.01064372101846713069) D92 D93 +error(0.0009906389095932167845) D92 D93 ^ D89 +error(0.0006750162503938480878) D92 D93 ^ D96 D97 +error(3.756848122638768088e-05) D92 D93 ^ D96 D121 +error(0.01267267767955587709) D92 D93 ^ D97 +error(0.004635934828459368356) D92 D93 ^ D97 D121 +error(0.002185403898100024295) D92 D93 ^ D121 +error(0.01336909531579565276) D92 D101 +error(0.01105500658491261057) D92 D101 ^ D96 D97 +error(0.005797025101372838864) D92 D115 +error(0.0003417045946126709161) D92 D115 ^ D120 D121 +error(0.0244028701613570112) D92 D116 +error(0.005035374525287034803) D92 D116 ^ D89 +error(0.001425061471213253782) D92 D116 ^ D120 D121 +error(0.001025440560362546371) D92 D116 ^ D121 +error(0.001739025683189662557) D92 D124 +error(0.0005163048540822849121) D92 D124 ^ D95 D96 +error(0.0003872660728112318042) D92 D124 ^ D95 D120 +error(0.001010208392926537947) D92 D124 ^ D96 D120 +error(0.0003614633525562173117) D92 D124 ^ D96 D121 +error(0.0007708242313029848268) D92 D124 ^ D120 D121 +error(0.002829373934999426885) D92 D125 +error(0.001161648608437570009) D92 D125 ^ D96 D97 +error(0.0004817648811728498333) D92 D125 ^ D96 D120 +error(0.002369403621825834708) D92 D125 ^ D96 D121 +error(0.0004523255119455854285) D92 D125 ^ D97 D121 +error(0.00243362505591642516) D92 D125 ^ D120 D121 +error(0.00845022675102432598) D93 +error(0.003122593618286308333) D93 D116 +error(0.0003444676573668129416) D93 D116 ^ D89 +error(0.003029471903265145566) D93 D116 ^ D121 +error(0.02878109383905069762) D93 D117 +error(0.005245455859824325884) D93 D117 ^ D121 +error(0.002444244415730570993) D93 D125 +error(1.320503562624765046e-05) D93 D125 ^ D96 D97 +error(0.000319071422289989796) D93 D125 ^ D96 D121 +error(0.002504366306824067946) D93 D125 ^ D97 D121 +error(0.01376696901986126757) D93 ^ D97 +error(0.0004076332642725224499) D93 ^ D121 +error(0.001893217879630942077) D93 ^ D121 ^ D97 +error(0.01079365791184803448) D94 +error(0.01463814118025971722) D94 D95 +error(0.0003749792498749710858) D94 D95 ^ D66 L0 +error(0.0005400820725793096383) D94 D95 ^ D98 D99 +error(0.000418692903235950032) D94 D95 ^ D99 D100 +error(0.001712985178897279354) D94 D95 ^ D99 D123 +error(4.669523646288583138e-05) D94 D95 ^ D100 D123 +error(0.04918066768488339735) D94 D118 +error(0.00367209971397850464) D94 D118 ^ D122 D123 +error(0.001587061349442817852) D94 D119 +error(0.0006664841908282826029) D94 D119 ^ D122 D123 +error(0.0004431564671695123817) D94 D126 +error(9.765646950254146724e-06) D94 D126 ^ D99 D100 +error(0.0006406541570109316498) D94 D126 ^ D99 D123 +error(5.274589083871283256e-05) D94 D126 ^ D100 D123 +error(0.0117889524045072993) D94 ^ D98 L0 +error(0.004137845564894525492) D98 D122 ^ D94 +error(0.02263828873602833844) D95 D96 +error(0.0001702276148531519891) D95 D96 ^ D99 D100 +error(0.0008834832228674967128) D95 D96 ^ D100 D101 +error(0.002753689268113585723) D95 D96 ^ D100 D124 +error(0.0005499538130014023632) D95 D96 ^ D101 D124 +error(0.01909106726931757148) D95 D102 +error(0.02001517208706354509) D95 D102 ^ D99 D100 +error(0.02812184381392778681) D95 D119 +error(0.002607359131359769482) D95 D119 ^ D123 D124 +error(0.003969053395153494292) D95 D120 +error(4.689775471165016457e-05) D95 D120 ^ D123 D124 +error(0.008075155730227432868) D95 D126 +error(0.005353779632917887721) D95 D126 ^ D99 D100 +error(0.0008750595983553233767) D95 D126 ^ D99 D123 +error(0.007885636642307748342) D95 D126 ^ D100 D123 +error(0.001752721336947414684) D95 D126 ^ D100 D124 +error(0.00216109320394393227) D95 D126 ^ D123 D124 +error(0.002431970761268770556) D95 D127 +error(0.0006784536717705084465) D95 D127 ^ D100 D101 +error(4.63592763270954906e-05) D95 D127 ^ D100 D123 +error(0.001397725395569435333) D95 D127 ^ D100 D124 +error(0.0004419636415501518398) D95 D127 ^ D101 D124 +error(0.0003189261836387721327) D95 D127 ^ D123 D124 +error(0.008150338982270402197) D96 D97 +error(0.0006312850411417316072) D96 D97 ^ D100 D101 +error(8.050646160119902803e-05) D96 D97 ^ D101 +error(0.001278512356325647685) D96 D97 ^ D101 D125 +error(0.0007020451534826920416) D96 D97 ^ D125 +error(0.01277332616325764329) D96 D103 +error(0.01048264638225490653) D96 D103 ^ D100 D101 +error(0.02278187818030543224) D96 D120 +error(0.002407124538276740958) D96 D120 ^ D124 D125 +error(0.003075712190512780442) D96 D121 +error(0.0005860246305094125689) D96 D121 ^ D124 D125 +error(0.002095085221072178795) D96 D127 +error(0.002204476815442909295) D96 D127 ^ D100 D101 +error(0.001398016024156229289) D96 D127 ^ D100 D124 +error(0.001998355767841102602) D96 D127 ^ D101 D124 +error(0.001286846742682906837) D96 D127 ^ D101 D125 +error(0.001863213582515296481) D96 D127 ^ D124 D125 +error(0.001997153633049718324) D96 D128 +error(2.598292875153643494e-05) D96 D128 ^ D101 D124 +error(0.001173331601012149233) D96 D128 ^ D101 D125 +error(0.0002874234325142206487) D96 D128 ^ D124 D125 +error(1.821438837082284888e-05) D96 D128 ^ D125 +error(0.01006454994273055757) D97 +error(0.0161206695668114873) D97 D104 +error(0.01737570254568924361) D97 D104 ^ D101 +error(0.0250505139273094167) D97 D121 +error(0.002345018263775333536) D97 D121 ^ D125 +error(0.003073065190622500248) D97 D128 +error(0.002579449672997942682) D97 D128 ^ D101 +error(0.003836377064377697373) D97 D128 ^ D125 +error(0.0006646277758526700783) D97 D128 ^ D125 ^ D101 +error(0.01577597104453927479) D98 D99 +error(0.003795651666848288541) D98 D99 ^ D70 +error(0.01692448812617893331) D98 D99 ^ D94 +error(0.0008288896859749987807) D98 D99 ^ D102 ^ D70 +error(0.0191985177099640858) D98 D122 +error(0.01034173018792707011) D98 L0 +error(0.0004662125493391324252) D98 L0 ^ D66 L0 ^ D94 +error(0.0007989884919774482971) D98 L0 ^ D94 ^ D70 +error(0.01669196318468137152) D99 D100 +error(0.0002275964588231474655) D99 D100 ^ D102 +error(0.001080582133475241997) D99 D100 ^ D102 D103 +error(0.003377679907839793976) D99 D100 ^ D102 D126 +error(0.0004409901630161987838) D99 D100 ^ D126 +error(0.01456851983540525391) D99 D105 +error(0.01235616231143815344) D99 D105 ^ D102 +error(0.00378888098077427701) D99 D122 +error(0.002826407968055778298) D99 D122 ^ D94 +error(0.0001197399291263810575) D99 D122 ^ D126 +error(0.0003950766148601412729) D99 D122 ^ D126 ^ D94 +error(0.02650863068338265086) D99 D123 +error(0.002052387878255866605) D99 D123 ^ D94 +error(0.005693851689366329419) D99 D123 ^ D126 +error(0.00279004820284349574) D99 D129 +error(0.001376537795732491343) D99 D129 ^ D102 +error(0.002887687896721477781) D99 D129 ^ D126 +error(0.001094217013606597596) D99 D129 ^ D126 ^ D102 +error(0.007394753493446600857) D100 D101 +error(0.0005665103155747660754) D100 D101 ^ D102 D103 +error(0.0002961719484165020928) D100 D101 ^ D102 D127 +error(0.0007675096502073114812) D100 D101 ^ D103 D104 +error(0.002862427649248453464) D100 D101 ^ D103 D127 +error(0.01375412502619386378) D100 D106 +error(0.01096105179196072039) D100 D106 ^ D102 D103 +error(0.008487365324421063117) D100 D123 +error(0.02457592249931421502) D100 D124 +error(0.002631812399044814853) D100 D124 ^ D126 D127 +error(0.002198804135129999587) D100 D129 +error(0.001654137015294186892) D100 D129 ^ D102 D126 +error(6.003632573794476984e-06) D100 D129 ^ D102 D127 +error(0.0004409060199606022593) D100 D129 ^ D126 +error(0.002192299185518550592) D100 D130 +error(0.001746414734417907517) D100 D130 ^ D102 D103 +error(0.0003598999091759262268) D100 D130 ^ D102 D126 +error(0.001561544017991810512) D100 D130 ^ D102 D127 +error(0.000466227982502727986) D100 D130 ^ D103 D127 +error(0.001724344060558972601) D100 D130 ^ D126 D127 +error(0.01203579788742147917) D101 +error(0.004387356071761702725) D101 D124 +error(0.000208029715498591483) D101 D124 ^ D127 D128 +error(0.02221100964778081194) D101 D125 +error(0.001439615781168439605) D101 D125 ^ D127 D128 +error(0.001201823867210177017) D101 D130 +error(0.0001012650403590720146) D101 D130 ^ D102 D103 +error(0.0003034946049630618146) D101 D130 ^ D102 D127 +error(0.001323584720901610371) D101 D130 ^ D103 D127 +error(0.0007926983696969233488) D101 ^ D69 ^ D73 +error(0.0005235978985522322894) D101 ^ D69 ^ D97 +error(0.001537789608391964321) D101 ^ D73 +error(0.01000000000000000021) D102 +error(0.007026141351062988212) D102 D103 +error(0.0009672799566260600846) D102 D103 ^ D105 D106 +error(0.002612338632211596515) D102 D103 ^ D106 D130 +error(0.0008620297320340863934) D102 D103 ^ D130 +error(0.03555466847524565294) D102 D126 +error(0.004257613433980646928) D102 D126 ^ D129 D130 +error(0.003914888887922909726) D102 D127 +error(0.0008393621947703528048) D102 D127 ^ D129 D130 +error(0.0006392754687906603917) D102 D131 +error(0.0002831750050793343447) D102 D131 ^ D106 +error(0.001693673795440791933) D102 D131 ^ D106 D130 +error(7.480679588459883279e-06) D102 D131 ^ D130 +error(0.01861532100512389154) D103 D104 +error(0.00222125091587972506) D103 D104 ^ D77 +error(0.01207571090899253741) D103 D104 ^ D101 +error(0.0002065846548685445908) D103 D104 ^ D106 +error(0.0003301188119060698405) D103 D104 ^ D106 ^ D77 +error(0.01744050413829207127) D103 D107 +error(0.01542382289075709852) D103 D107 ^ D106 +error(0.02667661522528785162) D103 D127 +error(0.001456372037112019452) D103 D127 ^ D101 +error(0.00368662532011345247) D103 D127 ^ D130 +error(0.002088453177880326885) D103 D128 +error(0.002632780704037000936) D103 D128 ^ D101 +error(0.0002114179196296893338) D103 D128 ^ D130 ^ D101 +error(0.004110481756233741457) D103 D131 +error(0.002802723964281605973) D103 D131 ^ D106 +error(0.003798397130707047414) D103 D131 ^ D130 +error(0.001977355296201686527) D103 D131 ^ D130 ^ D106 +error(0.02679340452938059822) D104 D128 +error(0.002535959682426708415) D104 D128 ^ D101 +error(0.006074521331256080119) D105 D106 +error(0.001500890887174470556) D105 D106 ^ D78 +error(0.01131498296823086475) D105 D106 ^ D102 +error(0.0004481007348183289017) D105 D106 ^ D107 +error(0.0004597114541739146941) D105 D106 ^ D107 ^ D78 +error(0.02900709638648528779) D105 D129 +error(0.003760545837299076113) D105 D129 ^ D102 +error(0.01000000000000000021) D106 +error(0.001742126190683423136) D106 D129 +error(0.002377235945765063599) D106 D129 ^ D102 +error(0.000899953914339936766) D106 D129 ^ D131 +error(0.0004872680715309037156) D106 D129 ^ D131 ^ D102 +error(0.02110557026819835647) D106 D130 +error(0.0003712607219078131976) D106 D130 ^ D102 +error(0.00170219714362124892) D106 D130 ^ D131 +error(0.009114652556981153037) D106 ^ D107 +error(0.001301279920715417773) D106 ^ D131 +error(0.003066610980423866654) D107 D131 ^ D106 +error(0.009282272384986160405) D107 +error(0.01920747822175144712) D107 D131 +error(0.005000000000000000104) D108 +error(0.01596805964649321286) D108 D112 +error(0.01829778043055142397) D108 D112 ^ D109 L0 +error(0.0266862725621760527) D108 D132 +error(0.006857640050321386731) D108 D132 ^ D133 L0 +error(0.006904323411147515743) D108 D136 +error(0.004290343924348420136) D108 D136 ^ D109 L0 +error(0.004718005776907755952) D108 D136 ^ D133 L0 +error(0.002682747303679847845) D108 D136 ^ D133 L0 ^ D109 L0 +error(0.003222820645970455884) D108 D137 +error(0.002413814734477126925) D108 D137 ^ D109 D133 +error(0.0009759754382860813841) D108 D137 ^ D109 L0 +error(0.001484037307585785734) D108 D137 ^ D133 L0 +error(0.006310960120927104275) D108 ^ D109 L0 +error(0.005322407363730898185) D109 D133 ^ D108 +error(0.006735703095373630871) D109 D110 +error(0.0008816988361899102695) D109 D110 ^ D108 +error(0.0001283013300070091228) D109 D110 ^ D112 D113 +error(0.0002940482682934252782) D109 D110 ^ D112 D137 +error(0.0147823200156403517) D109 D110 ^ D113 +error(0.003440266269014606582) D109 D110 ^ D113 D137 +error(0.002728099968767540903) D109 D110 ^ D137 +error(0.0003101067761686230142) D109 D110 ^ D137 ^ D108 +error(0.02055897619164840859) D109 D115 +error(0.01315370144244269388) D109 D115 ^ D112 D113 +error(0.04054698510964466207) D109 D133 +error(0.003068906748310869584) D109 D133 ^ D136 D137 +error(0.004135165380719954369) D109 D133 ^ D137 +error(0.00170148481970367675) D109 D138 +error(0.002569670009209375477) D109 D138 ^ D112 D136 +error(0.0003645001291986636185) D109 D138 ^ D112 D137 +error(0.0006562264584675363841) D109 D138 ^ D136 D137 +error(0.00358204353642006942) D109 D139 +error(0.001864374047664434922) D109 D139 ^ D112 D113 +error(0.0003932828383309873183) D109 D139 ^ D112 D136 +error(0.001848434604000002719) D109 D139 ^ D112 D137 +error(0.0001774661344280517637) D109 D139 ^ D113 D137 +error(0.002210991227743962402) D109 D139 ^ D136 D137 +error(0.01000000000000000021) D109 L0 +error(0.01675927044650943679) D110 D116 +error(0.01483521393192921423) D110 D116 ^ D113 +error(0.004719946072497860183) D110 D133 +error(0.0007165835560042144777) D110 D133 ^ D108 +error(0.004779816248476202387) D110 D133 ^ D137 +error(0.0005462343302855433153) D110 D133 ^ D137 ^ D108 +error(0.04658633835913435217) D110 D134 +error(0.009873875383543916084) D110 D134 ^ D137 +error(0.002326384940569728357) D110 D139 +error(0.0005686665129455996306) D110 D139 ^ D112 D113 +error(0.0002337464378640189766) D110 D139 ^ D112 D137 +error(0.000491201243452230301) D110 D139 ^ D113 +error(0.001361197307204584225) D110 D139 ^ D113 D137 +error(0.0005238546515356713642) D110 D139 ^ D137 +error(0.003606535288512647489) D110 D140 +error(0.002939925401372571381) D110 D140 ^ D113 +error(0.002886682013661131477) D110 D140 ^ D137 +error(0.001451469642847544881) D110 D140 ^ D137 ^ D113 +error(0.009299079482444108993) D111 D112 +error(0.0001618067361763870105) D111 D112 ^ D109 L0 +error(0.0004009870402910406875) D111 D112 ^ D114 D115 +error(0.002038993562470617187) D111 D112 ^ D114 D138 +error(0.009839797261860206215) D111 D112 ^ D114 L0 +error(1.613708403102963708e-05) D111 D112 ^ D115 D138 +error(0.001420262771992301942) D111 D112 ^ D138 L0 +error(0.0007398317957289404605) D111 D112 ^ D138 L0 ^ D109 L0 +error(0.01276385364945899735) D111 D118 +error(0.011096381866881758) D111 D118 ^ D114 L0 +error(0.02360888144805250999) D111 D135 +error(0.003659423329073996974) D111 D135 ^ D138 L0 +error(0.002152186614080534195) D111 D136 +error(0.000456204478737577343) D111 D136 ^ D109 L0 +error(0.002391715036470463789) D111 D136 ^ D138 L0 +error(0.0001736009261800634882) D111 D136 ^ D138 L0 ^ D109 L0 +error(0.002929594954205079742) D111 D142 +error(0.003607534314359686634) D111 D142 ^ D114 L0 +error(0.002145454612411112471) D111 D142 ^ D138 L0 +error(0.0006842560657499791943) D111 D142 ^ D138 L0 ^ D114 L0 +error(0.002734468661554086567) D111 D143 +error(0.0003213799321281471302) D111 D143 ^ D114 D115 +error(0.001292369671938379096) D111 D143 ^ D114 D138 +error(0.0006814453156953355741) D111 D143 ^ D114 L0 +error(0.000171429172347746983) D111 D143 ^ D115 D138 +error(2.241052274140109318e-05) D111 D143 ^ D138 L0 +error(0.008061141833768614012) D112 D113 +error(5.603595358604616684e-05) D112 D113 ^ D85 L0 +error(0.0003240145466437737223) D112 D113 ^ D109 L0 +error(0.0007894832832053461135) D112 D113 ^ D114 D115 +error(0.0009388025834094447519) D112 D113 ^ D115 D116 +error(0.001594794524676789067) D112 D113 ^ D115 D139 +error(0.01499707882523569624) D112 D119 +error(0.009686274303190828272) D112 D119 ^ D114 D115 +error(0.02687355039480195801) D112 D136 +error(0.007485819796524218438) D112 D136 ^ D109 L0 +error(0.003107469568972692602) D112 D136 ^ D138 D139 +error(0.0005680536236455682427) D112 D136 ^ D138 L0 +error(0.003211879643569449851) D112 D137 +error(0.000376529833666304839) D112 D137 ^ D138 D139 +error(0.00120063201568994444) D112 D143 +error(0.002765100742562540039) D112 D143 ^ D114 D115 +error(0.001443006512690684761) D112 D143 ^ D114 D138 +error(0.001963765223827605017) D112 D143 ^ D115 D138 +error(0.001561962824876994256) D112 D143 ^ D115 D139 +error(0.001924240942830092883) D112 D143 ^ D138 D139 +error(0.001978648078269987665) D112 D144 +error(0.0003155662468816377805) D112 D144 ^ D115 D116 +error(0.0002941715103168643678) D112 D144 ^ D115 D138 +error(0.001543894821161831106) D112 D144 ^ D115 D139 +error(0.01000000000000000021) D113 +error(0.01996187733386350568) D113 D120 +error(0.0188611843799036949) D113 D120 ^ D115 D116 +error(0.03083190651367225324) D113 D137 +error(0.002851553572250035279) D113 D137 ^ D139 D140 +error(0.003781520367195873988) D113 D144 +error(0.002268950364954752229) D113 D144 ^ D115 D116 +error(0.001088491258235638843) D113 D144 ^ D115 D139 +error(0.002124756255297351182) D113 D144 ^ D116 D139 +error(0.0005882412221558847064) D113 D144 ^ D116 D140 +error(0.002574093098742098219) D113 D144 ^ D139 D140 +error(0.003029302145153121503) D113 D145 +error(0.001158629973361129974) D113 D145 ^ D116 D140 +error(0.0004212946613479972625) D113 D145 ^ D139 D140 +error(0.00708325686996343247) D114 D115 +error(0.001146243462908609796) D114 D115 ^ D118 D119 +error(0.000456805822531424063) D114 D115 ^ D118 D143 +error(0.000304813137048891682) D114 D115 ^ D119 D120 +error(0.002634276171414426122) D114 D115 ^ D119 D143 +error(0.01612767423445998077) D114 D123 +error(0.01171697673212769748) D114 D123 ^ D118 D119 +error(0.03918384738513067123) D114 D138 +error(0.002228925530581629937) D114 D138 ^ D142 D143 +error(0.001722182253290977872) D114 D146 +error(0.00257234959439087401) D114 D146 ^ D118 D142 +error(0.0006935910585423644449) D114 D146 ^ D118 D143 +error(0.0005515214868894067427) D114 D146 ^ D142 D143 +error(0.003685515877434647394) D114 D147 +error(0.002490979275654284057) D114 D147 ^ D118 D119 +error(0.00230918351195979598) D114 D147 ^ D118 D142 +error(0.001594143301527340979) D114 D147 ^ D118 D143 +error(0.0006317460369945696042) D114 D147 ^ D119 D143 +error(0.001985781331922381338) D114 D147 ^ D142 D143 +error(0.01000000000000000021) D114 L0 +error(0.002783689788661022121) D118 D142 ^ D114 L0 +error(0.00974687687898492458) D115 D116 +error(0.0003747287983380178798) D115 D116 ^ D119 D120 +error(0.0004743688286892290226) D115 D116 ^ D119 D144 +error(5.278044991932393068e-05) D115 D116 ^ D120 D121 +error(0.001157504928862029348) D115 D116 ^ D120 D144 +error(0.01675403094458132944) D115 D124 +error(0.01519293603187372999) D115 D124 ^ D119 D120 +error(0.003434296201232148876) D115 D138 +error(0.000572720380022092657) D115 D138 ^ D143 D144 +error(0.03896029464506293311) D115 D139 +error(0.001919558353366188335) D115 D139 ^ D143 D144 +error(0.000483343676407702429) D115 D147 +error(0.0002960171048330712418) D115 D147 ^ D118 D119 +error(0.002043284550463939) D115 D147 ^ D119 D143 +error(0.0008359769467140544747) D115 D147 ^ D119 D144 +error(0.000307975956330275866) D115 D147 ^ D143 D144 +error(0.001859072576991834544) D115 D148 +error(0.002165391394046252676) D115 D148 ^ D119 D120 +error(0.0009431680077149669911) D115 D148 ^ D119 D143 +error(0.001598928756437687122) D115 D148 ^ D119 D144 +error(0.001076978172298284934) D115 D148 ^ D120 D144 +error(0.002627582281132581458) D115 D148 ^ D143 D144 +error(0.01064372101846713069) D116 D117 +error(0.0009906389095932167845) D116 D117 ^ D113 +error(0.0006750162503938480878) D116 D117 ^ D120 D121 +error(3.756848122638768088e-05) D116 D117 ^ D120 D145 +error(0.01267267767955587709) D116 D117 ^ D121 +error(0.004635934828459368356) D116 D117 ^ D121 D145 +error(0.002185403898100024295) D116 D117 ^ D145 +error(0.01336909531579565276) D116 D125 +error(0.01105500658491261057) D116 D125 ^ D120 D121 +error(0.005797025101372838864) D116 D139 +error(0.0003417045946126709161) D116 D139 ^ D144 D145 +error(0.0244028701613570112) D116 D140 +error(0.005035374525287034803) D116 D140 ^ D113 +error(0.001425061471213253782) D116 D140 ^ D144 D145 +error(0.001025440560362546371) D116 D140 ^ D145 +error(0.001739025683189662557) D116 D148 +error(0.0005163048540822849121) D116 D148 ^ D119 D120 +error(0.0003872660728112318042) D116 D148 ^ D119 D144 +error(0.001010208392926537947) D116 D148 ^ D120 D144 +error(0.0003614633525562173117) D116 D148 ^ D120 D145 +error(0.0007708242313029848268) D116 D148 ^ D144 D145 +error(0.002829373934999426885) D116 D149 +error(0.001161648608437570009) D116 D149 ^ D120 D121 +error(0.0004817648811728498333) D116 D149 ^ D120 D144 +error(0.002369403621825834708) D116 D149 ^ D120 D145 +error(0.0004523255119455854285) D116 D149 ^ D121 D145 +error(0.00243362505591642516) D116 D149 ^ D144 D145 +error(0.00845022675102432598) D117 +error(0.003122593618286308333) D117 D140 +error(0.0003444676573668129416) D117 D140 ^ D113 +error(0.003029471903265145566) D117 D140 ^ D145 +error(0.02878109383905069762) D117 D141 +error(0.005245455859824325884) D117 D141 ^ D145 +error(0.002444244415730570993) D117 D149 +error(1.320503562624765046e-05) D117 D149 ^ D120 D121 +error(0.000319071422289989796) D117 D149 ^ D120 D145 +error(0.002504366306824067946) D117 D149 ^ D121 D145 +error(0.01376696901986126757) D117 ^ D121 +error(0.0004076332642725224499) D117 ^ D145 +error(0.001893217879630942077) D117 ^ D145 ^ D121 +error(0.01079365791184803448) D118 +error(0.01463814118025971722) D118 D119 +error(0.0003749792498749710858) D118 D119 ^ D90 L0 +error(0.0005400820725793096383) D118 D119 ^ D122 D123 +error(0.000418692903235950032) D118 D119 ^ D123 D124 +error(0.001712985178897279354) D118 D119 ^ D123 D147 +error(4.669523646288583138e-05) D118 D119 ^ D124 D147 +error(0.04918066768488339735) D118 D142 +error(0.00367209971397850464) D118 D142 ^ D146 D147 +error(0.001587061349442817852) D118 D143 +error(0.0006664841908282826029) D118 D143 ^ D146 D147 +error(0.0004431564671695123817) D118 D150 +error(9.765646950254146724e-06) D118 D150 ^ D123 D124 +error(0.0006406541570109316498) D118 D150 ^ D123 D147 +error(5.274589083871283256e-05) D118 D150 ^ D124 D147 +error(0.0117889524045072993) D118 ^ D122 L0 +error(0.004137845564894525492) D122 D146 ^ D118 +error(0.02263828873602833844) D119 D120 +error(0.0001702276148531519891) D119 D120 ^ D123 D124 +error(0.0008834832228674967128) D119 D120 ^ D124 D125 +error(0.002753689268113585723) D119 D120 ^ D124 D148 +error(0.0005499538130014023632) D119 D120 ^ D125 D148 +error(0.01909106726931757148) D119 D126 +error(0.02001517208706354509) D119 D126 ^ D123 D124 +error(0.02812184381392778681) D119 D143 +error(0.002607359131359769482) D119 D143 ^ D147 D148 +error(0.003969053395153494292) D119 D144 +error(4.689775471165016457e-05) D119 D144 ^ D147 D148 +error(0.008075155730227432868) D119 D150 +error(0.005353779632917887721) D119 D150 ^ D123 D124 +error(0.0008750595983553233767) D119 D150 ^ D123 D147 +error(0.007885636642307748342) D119 D150 ^ D124 D147 +error(0.001752721336947414684) D119 D150 ^ D124 D148 +error(0.00216109320394393227) D119 D150 ^ D147 D148 +error(0.002431970761268770556) D119 D151 +error(0.0006784536717705084465) D119 D151 ^ D124 D125 +error(4.63592763270954906e-05) D119 D151 ^ D124 D147 +error(0.001397725395569435333) D119 D151 ^ D124 D148 +error(0.0004419636415501518398) D119 D151 ^ D125 D148 +error(0.0003189261836387721327) D119 D151 ^ D147 D148 +error(0.008150338982270402197) D120 D121 +error(0.0006312850411417316072) D120 D121 ^ D124 D125 +error(8.050646160119902803e-05) D120 D121 ^ D125 +error(0.001278512356325647685) D120 D121 ^ D125 D149 +error(0.0007020451534826920416) D120 D121 ^ D149 +error(0.01277332616325764329) D120 D127 +error(0.01048264638225490653) D120 D127 ^ D124 D125 +error(0.02278187818030543224) D120 D144 +error(0.002407124538276740958) D120 D144 ^ D148 D149 +error(0.003075712190512780442) D120 D145 +error(0.0005860246305094125689) D120 D145 ^ D148 D149 +error(0.002095085221072178795) D120 D151 +error(0.002204476815442909295) D120 D151 ^ D124 D125 +error(0.001398016024156229289) D120 D151 ^ D124 D148 +error(0.001998355767841102602) D120 D151 ^ D125 D148 +error(0.001286846742682906837) D120 D151 ^ D125 D149 +error(0.001863213582515296481) D120 D151 ^ D148 D149 +error(0.001997153633049718324) D120 D152 +error(2.598292875153643494e-05) D120 D152 ^ D125 D148 +error(0.001173331601012149233) D120 D152 ^ D125 D149 +error(0.0002874234325142206487) D120 D152 ^ D148 D149 +error(1.821438837082284888e-05) D120 D152 ^ D149 +error(0.01006454994273055757) D121 +error(0.0161206695668114873) D121 D128 +error(0.01737570254568924361) D121 D128 ^ D125 +error(0.0250505139273094167) D121 D145 +error(0.002345018263775333536) D121 D145 ^ D149 +error(0.003073065190622500248) D121 D152 +error(0.002579449672997942682) D121 D152 ^ D125 +error(0.003836377064377697373) D121 D152 ^ D149 +error(0.0006646277758526700783) D121 D152 ^ D149 ^ D125 +error(0.01577597104453927479) D122 D123 +error(0.003795651666848288541) D122 D123 ^ D94 +error(0.01692448812617893331) D122 D123 ^ D118 +error(0.0008288896859749987807) D122 D123 ^ D126 ^ D94 +error(0.0191985177099640858) D122 D146 +error(0.01034173018792707011) D122 L0 +error(0.0004662125493391324252) D122 L0 ^ D90 L0 ^ D118 +error(0.0007989884919774482971) D122 L0 ^ D118 ^ D94 +error(0.01669196318468137152) D123 D124 +error(0.0002275964588231474655) D123 D124 ^ D126 +error(0.001080582133475241997) D123 D124 ^ D126 D127 +error(0.003377679907839793976) D123 D124 ^ D126 D150 +error(0.0004409901630161987838) D123 D124 ^ D150 +error(0.01456851983540525391) D123 D129 +error(0.01235616231143815344) D123 D129 ^ D126 +error(0.00378888098077427701) D123 D146 +error(0.002826407968055778298) D123 D146 ^ D118 +error(0.0001197399291263810575) D123 D146 ^ D150 +error(0.0003950766148601412729) D123 D146 ^ D150 ^ D118 +error(0.02650863068338265086) D123 D147 +error(0.002052387878255866605) D123 D147 ^ D118 +error(0.005693851689366329419) D123 D147 ^ D150 +error(0.00279004820284349574) D123 D153 +error(0.001376537795732491343) D123 D153 ^ D126 +error(0.002887687896721477781) D123 D153 ^ D150 +error(0.001094217013606597596) D123 D153 ^ D150 ^ D126 +error(0.007394753493446600857) D124 D125 +error(0.0005665103155747660754) D124 D125 ^ D126 D127 +error(0.0002961719484165020928) D124 D125 ^ D126 D151 +error(0.0007675096502073114812) D124 D125 ^ D127 D128 +error(0.002862427649248453464) D124 D125 ^ D127 D151 +error(0.01375412502619386378) D124 D130 +error(0.01096105179196072039) D124 D130 ^ D126 D127 +error(0.008487365324421063117) D124 D147 +error(0.02457592249931421502) D124 D148 +error(0.002631812399044814853) D124 D148 ^ D150 D151 +error(0.002198804135129999587) D124 D153 +error(0.001654137015294186892) D124 D153 ^ D126 D150 +error(6.003632573794476984e-06) D124 D153 ^ D126 D151 +error(0.0004409060199606022593) D124 D153 ^ D150 +error(0.002192299185518550592) D124 D154 +error(0.001746414734417907517) D124 D154 ^ D126 D127 +error(0.0003598999091759262268) D124 D154 ^ D126 D150 +error(0.001561544017991810512) D124 D154 ^ D126 D151 +error(0.000466227982502727986) D124 D154 ^ D127 D151 +error(0.001724344060558972601) D124 D154 ^ D150 D151 +error(0.01203579788742147917) D125 +error(0.004387356071761702725) D125 D148 +error(0.000208029715498591483) D125 D148 ^ D151 D152 +error(0.02221100964778081194) D125 D149 +error(0.001439615781168439605) D125 D149 ^ D151 D152 +error(0.001201823867210177017) D125 D154 +error(0.0001012650403590720146) D125 D154 ^ D126 D127 +error(0.0003034946049630618146) D125 D154 ^ D126 D151 +error(0.001323584720901610371) D125 D154 ^ D127 D151 +error(0.0007926983696969233488) D125 ^ D93 ^ D97 +error(0.0005235978985522322894) D125 ^ D93 ^ D121 +error(0.001537789608391964321) D125 ^ D97 +error(0.01000000000000000021) D126 +error(0.007026141351062988212) D126 D127 +error(0.0009672799566260600846) D126 D127 ^ D129 D130 +error(0.002612338632211596515) D126 D127 ^ D130 D154 +error(0.0008620297320340863934) D126 D127 ^ D154 +error(0.03555466847524565294) D126 D150 +error(0.004257613433980646928) D126 D150 ^ D153 D154 +error(0.003914888887922909726) D126 D151 +error(0.0008393621947703528048) D126 D151 ^ D153 D154 +error(0.0006392754687906603917) D126 D155 +error(0.0002831750050793343447) D126 D155 ^ D130 +error(0.001693673795440791933) D126 D155 ^ D130 D154 +error(7.480679588459883279e-06) D126 D155 ^ D154 +error(0.01861532100512389154) D127 D128 +error(0.00222125091587972506) D127 D128 ^ D101 +error(0.01207571090899253741) D127 D128 ^ D125 +error(0.0002065846548685445908) D127 D128 ^ D130 +error(0.0003301188119060698405) D127 D128 ^ D130 ^ D101 +error(0.01744050413829207127) D127 D131 +error(0.01542382289075709852) D127 D131 ^ D130 +error(0.02667661522528785162) D127 D151 +error(0.001456372037112019452) D127 D151 ^ D125 +error(0.00368662532011345247) D127 D151 ^ D154 +error(0.002088453177880326885) D127 D152 +error(0.002632780704037000936) D127 D152 ^ D125 +error(0.0002114179196296893338) D127 D152 ^ D154 ^ D125 +error(0.004110481756233741457) D127 D155 +error(0.002802723964281605973) D127 D155 ^ D130 +error(0.003798397130707047414) D127 D155 ^ D154 +error(0.001977355296201686527) D127 D155 ^ D154 ^ D130 +error(0.02679340452938059822) D128 D152 +error(0.002535959682426708415) D128 D152 ^ D125 +error(0.006074521331256080119) D129 D130 +error(0.001500890887174470556) D129 D130 ^ D102 +error(0.01131498296823086475) D129 D130 ^ D126 +error(0.0004481007348183289017) D129 D130 ^ D131 +error(0.0004597114541739146941) D129 D130 ^ D131 ^ D102 +error(0.02900709638648528779) D129 D153 +error(0.003760545837299076113) D129 D153 ^ D126 +error(0.01000000000000000021) D130 +error(0.001742126190683423136) D130 D153 +error(0.002377235945765063599) D130 D153 ^ D126 +error(0.000899953914339936766) D130 D153 ^ D155 +error(0.0004872680715309037156) D130 D153 ^ D155 ^ D126 +error(0.02110557026819835647) D130 D154 +error(0.0003712607219078131976) D130 D154 ^ D126 +error(0.00170219714362124892) D130 D154 ^ D155 +error(0.009114652556981153037) D130 ^ D131 +error(0.001301279920715417773) D130 ^ D155 +error(0.003066610980423866654) D131 D155 ^ D130 +error(0.009282272384986160405) D131 +error(0.01920747822175144712) D131 D155 +error(0.005000000000000000104) D132 +error(0.01596805964649321286) D132 D136 +error(0.01829778043055142397) D132 D136 ^ D133 L0 +error(0.0266862725621760527) D132 D156 +error(0.006857640050321386731) D132 D156 ^ D157 L0 +error(0.006904323411147515743) D132 D160 +error(0.004290343924348420136) D132 D160 ^ D133 L0 +error(0.004718005776907755952) D132 D160 ^ D157 L0 +error(0.002682747303679847845) D132 D160 ^ D157 L0 ^ D133 L0 +error(0.003222820645970455884) D132 D161 +error(0.002413814734477126925) D132 D161 ^ D133 D157 +error(0.0009759754382860813841) D132 D161 ^ D133 L0 +error(0.001484037307585785734) D132 D161 ^ D157 L0 +error(0.006310960120927104275) D132 ^ D133 L0 +error(0.005322407363730898185) D133 D157 ^ D132 +error(0.006735703095373630871) D133 D134 +error(0.0008816988361899102695) D133 D134 ^ D132 +error(0.0001283013300070091228) D133 D134 ^ D136 D137 +error(0.0002940482682934252782) D133 D134 ^ D136 D161 +error(0.0147823200156403517) D133 D134 ^ D137 +error(0.003440266269014606582) D133 D134 ^ D137 D161 +error(0.002728099968767540903) D133 D134 ^ D161 +error(0.0003101067761686230142) D133 D134 ^ D161 ^ D132 +error(0.02055897619164840859) D133 D139 +error(0.01315370144244269388) D133 D139 ^ D136 D137 +error(0.04054698510964466207) D133 D157 +error(0.003068906748310869584) D133 D157 ^ D160 D161 +error(0.004135165380719954369) D133 D157 ^ D161 +error(0.00170148481970367675) D133 D162 +error(0.002569670009209375477) D133 D162 ^ D136 D160 +error(0.0003645001291986636185) D133 D162 ^ D136 D161 +error(0.0006562264584675363841) D133 D162 ^ D160 D161 +error(0.00358204353642006942) D133 D163 +error(0.001864374047664434922) D133 D163 ^ D136 D137 +error(0.0003932828383309873183) D133 D163 ^ D136 D160 +error(0.001848434604000002719) D133 D163 ^ D136 D161 +error(0.0001774661344280517637) D133 D163 ^ D137 D161 +error(0.002210991227743962402) D133 D163 ^ D160 D161 +error(0.01000000000000000021) D133 L0 +error(0.01675927044650943679) D134 D140 +error(0.01483521393192921423) D134 D140 ^ D137 +error(0.004719946072497860183) D134 D157 +error(0.0007165835560042144777) D134 D157 ^ D132 +error(0.004779816248476202387) D134 D157 ^ D161 +error(0.0005462343302855433153) D134 D157 ^ D161 ^ D132 +error(0.04658633835913435217) D134 D158 +error(0.009873875383543916084) D134 D158 ^ D161 +error(0.002326384940569728357) D134 D163 +error(0.0005686665129455996306) D134 D163 ^ D136 D137 +error(0.0002337464378640189766) D134 D163 ^ D136 D161 +error(0.000491201243452230301) D134 D163 ^ D137 +error(0.001361197307204584225) D134 D163 ^ D137 D161 +error(0.0005238546515356713642) D134 D163 ^ D161 +error(0.003606535288512647489) D134 D164 +error(0.002939925401372571381) D134 D164 ^ D137 +error(0.002886682013661131477) D134 D164 ^ D161 +error(0.001451469642847544881) D134 D164 ^ D161 ^ D137 +error(0.009299079482444108993) D135 D136 +error(0.0001618067361763870105) D135 D136 ^ D133 L0 +error(0.0004009870402910406875) D135 D136 ^ D138 D139 +error(0.002038993562470617187) D135 D136 ^ D138 D162 +error(0.009839797261860206215) D135 D136 ^ D138 L0 +error(1.613708403102963708e-05) D135 D136 ^ D139 D162 +error(0.001420262771992301942) D135 D136 ^ D162 L0 +error(0.0007398317957289404605) D135 D136 ^ D162 L0 ^ D133 L0 +error(0.01276385364945899735) D135 D142 +error(0.011096381866881758) D135 D142 ^ D138 L0 +error(0.02360888144805250999) D135 D159 +error(0.003659423329073996974) D135 D159 ^ D162 L0 +error(0.002152186614080534195) D135 D160 +error(0.000456204478737577343) D135 D160 ^ D133 L0 +error(0.002391715036470463789) D135 D160 ^ D162 L0 +error(0.0001736009261800634882) D135 D160 ^ D162 L0 ^ D133 L0 +error(0.002929594954205079742) D135 D166 +error(0.003607534314359686634) D135 D166 ^ D138 L0 +error(0.002145454612411112471) D135 D166 ^ D162 L0 +error(0.0006842560657499791943) D135 D166 ^ D162 L0 ^ D138 L0 +error(0.002734468661554086567) D135 D167 +error(0.0003213799321281471302) D135 D167 ^ D138 D139 +error(0.001292369671938379096) D135 D167 ^ D138 D162 +error(0.0006814453156953355741) D135 D167 ^ D138 L0 +error(0.000171429172347746983) D135 D167 ^ D139 D162 +error(2.241052274140109318e-05) D135 D167 ^ D162 L0 +error(0.008061141833768614012) D136 D137 +error(5.603595358604616684e-05) D136 D137 ^ D109 L0 +error(0.0003240145466437737223) D136 D137 ^ D133 L0 +error(0.0007894832832053461135) D136 D137 ^ D138 D139 +error(0.0009388025834094447519) D136 D137 ^ D139 D140 +error(0.001594794524676789067) D136 D137 ^ D139 D163 +error(0.01499707882523569624) D136 D143 +error(0.009686274303190828272) D136 D143 ^ D138 D139 +error(0.02687355039480195801) D136 D160 +error(0.007485819796524218438) D136 D160 ^ D133 L0 +error(0.003107469568972692602) D136 D160 ^ D162 D163 +error(0.0005680536236455682427) D136 D160 ^ D162 L0 +error(0.003211879643569449851) D136 D161 +error(0.000376529833666304839) D136 D161 ^ D162 D163 +error(0.00120063201568994444) D136 D167 +error(0.002765100742562540039) D136 D167 ^ D138 D139 +error(0.001443006512690684761) D136 D167 ^ D138 D162 +error(0.001963765223827605017) D136 D167 ^ D139 D162 +error(0.001561962824876994256) D136 D167 ^ D139 D163 +error(0.001924240942830092883) D136 D167 ^ D162 D163 +error(0.001978648078269987665) D136 D168 +error(0.0003155662468816377805) D136 D168 ^ D139 D140 +error(0.0002941715103168643678) D136 D168 ^ D139 D162 +error(0.001543894821161831106) D136 D168 ^ D139 D163 +error(0.01000000000000000021) D137 +error(0.01996187733386350568) D137 D144 +error(0.0188611843799036949) D137 D144 ^ D139 D140 +error(0.03083190651367225324) D137 D161 +error(0.002851553572250035279) D137 D161 ^ D163 D164 +error(0.003781520367195873988) D137 D168 +error(0.002268950364954752229) D137 D168 ^ D139 D140 +error(0.001088491258235638843) D137 D168 ^ D139 D163 +error(0.002124756255297351182) D137 D168 ^ D140 D163 +error(0.0005882412221558847064) D137 D168 ^ D140 D164 +error(0.002574093098742098219) D137 D168 ^ D163 D164 +error(0.003029302145153121503) D137 D169 +error(0.001158629973361129974) D137 D169 ^ D140 D164 +error(0.0004212946613479972625) D137 D169 ^ D163 D164 +error(0.00708325686996343247) D138 D139 +error(0.001146243462908609796) D138 D139 ^ D142 D143 +error(0.000456805822531424063) D138 D139 ^ D142 D167 +error(0.000304813137048891682) D138 D139 ^ D143 D144 +error(0.002634276171414426122) D138 D139 ^ D143 D167 +error(0.01612767423445998077) D138 D147 +error(0.01171697673212769748) D138 D147 ^ D142 D143 +error(0.03918384738513067123) D138 D162 +error(0.002228925530581629937) D138 D162 ^ D166 D167 +error(0.001722182253290977872) D138 D170 +error(0.00257234959439087401) D138 D170 ^ D142 D166 +error(0.0006935910585423644449) D138 D170 ^ D142 D167 +error(0.0005515214868894067427) D138 D170 ^ D166 D167 +error(0.003685515877434647394) D138 D171 +error(0.002490979275654284057) D138 D171 ^ D142 D143 +error(0.00230918351195979598) D138 D171 ^ D142 D166 +error(0.001594143301527340979) D138 D171 ^ D142 D167 +error(0.0006317460369945696042) D138 D171 ^ D143 D167 +error(0.001985781331922381338) D138 D171 ^ D166 D167 +error(0.01000000000000000021) D138 L0 +error(0.002783689788661022121) D142 D166 ^ D138 L0 +error(0.00974687687898492458) D139 D140 +error(0.0003747287983380178798) D139 D140 ^ D143 D144 +error(0.0004743688286892290226) D139 D140 ^ D143 D168 +error(5.278044991932393068e-05) D139 D140 ^ D144 D145 +error(0.001157504928862029348) D139 D140 ^ D144 D168 +error(0.01675403094458132944) D139 D148 +error(0.01519293603187372999) D139 D148 ^ D143 D144 +error(0.003434296201232148876) D139 D162 +error(0.000572720380022092657) D139 D162 ^ D167 D168 +error(0.03896029464506293311) D139 D163 +error(0.001919558353366188335) D139 D163 ^ D167 D168 +error(0.000483343676407702429) D139 D171 +error(0.0002960171048330712418) D139 D171 ^ D142 D143 +error(0.002043284550463939) D139 D171 ^ D143 D167 +error(0.0008359769467140544747) D139 D171 ^ D143 D168 +error(0.000307975956330275866) D139 D171 ^ D167 D168 +error(0.001859072576991834544) D139 D172 +error(0.002165391394046252676) D139 D172 ^ D143 D144 +error(0.0009431680077149669911) D139 D172 ^ D143 D167 +error(0.001598928756437687122) D139 D172 ^ D143 D168 +error(0.001076978172298284934) D139 D172 ^ D144 D168 +error(0.002627582281132581458) D139 D172 ^ D167 D168 +error(0.01064372101846713069) D140 D141 +error(0.0009906389095932167845) D140 D141 ^ D137 +error(0.0006750162503938480878) D140 D141 ^ D144 D145 +error(3.756848122638768088e-05) D140 D141 ^ D144 D169 +error(0.01267267767955587709) D140 D141 ^ D145 +error(0.004635934828459368356) D140 D141 ^ D145 D169 +error(0.002185403898100024295) D140 D141 ^ D169 +error(0.01336909531579565276) D140 D149 +error(0.01105500658491261057) D140 D149 ^ D144 D145 +error(0.005797025101372838864) D140 D163 +error(0.0003417045946126709161) D140 D163 ^ D168 D169 +error(0.0244028701613570112) D140 D164 +error(0.005035374525287034803) D140 D164 ^ D137 +error(0.001425061471213253782) D140 D164 ^ D168 D169 +error(0.001025440560362546371) D140 D164 ^ D169 +error(0.001739025683189662557) D140 D172 +error(0.0005163048540822849121) D140 D172 ^ D143 D144 +error(0.0003872660728112318042) D140 D172 ^ D143 D168 +error(0.001010208392926537947) D140 D172 ^ D144 D168 +error(0.0003614633525562173117) D140 D172 ^ D144 D169 +error(0.0007708242313029848268) D140 D172 ^ D168 D169 +error(0.002829373934999426885) D140 D173 +error(0.001161648608437570009) D140 D173 ^ D144 D145 +error(0.0004817648811728498333) D140 D173 ^ D144 D168 +error(0.002369403621825834708) D140 D173 ^ D144 D169 +error(0.0004523255119455854285) D140 D173 ^ D145 D169 +error(0.00243362505591642516) D140 D173 ^ D168 D169 +error(0.00845022675102432598) D141 +error(0.003122593618286308333) D141 D164 +error(0.0003444676573668129416) D141 D164 ^ D137 +error(0.003029471903265145566) D141 D164 ^ D169 +error(0.02878109383905069762) D141 D165 +error(0.005245455859824325884) D141 D165 ^ D169 +error(0.002444244415730570993) D141 D173 +error(1.320503562624765046e-05) D141 D173 ^ D144 D145 +error(0.000319071422289989796) D141 D173 ^ D144 D169 +error(0.002504366306824067946) D141 D173 ^ D145 D169 +error(0.01376696901986126757) D141 ^ D145 +error(0.0004076332642725224499) D141 ^ D169 +error(0.001893217879630942077) D141 ^ D169 ^ D145 +error(0.01079365791184803448) D142 +error(0.01463814118025971722) D142 D143 +error(0.0003749792498749710858) D142 D143 ^ D114 L0 +error(0.0005400820725793096383) D142 D143 ^ D146 D147 +error(0.000418692903235950032) D142 D143 ^ D147 D148 +error(0.001712985178897279354) D142 D143 ^ D147 D171 +error(4.669523646288583138e-05) D142 D143 ^ D148 D171 +error(0.04918066768488339735) D142 D166 +error(0.00367209971397850464) D142 D166 ^ D170 D171 +error(0.001587061349442817852) D142 D167 +error(0.0006664841908282826029) D142 D167 ^ D170 D171 +error(0.0004431564671695123817) D142 D174 +error(9.765646950254146724e-06) D142 D174 ^ D147 D148 +error(0.0006406541570109316498) D142 D174 ^ D147 D171 +error(5.274589083871283256e-05) D142 D174 ^ D148 D171 +error(0.0117889524045072993) D142 ^ D146 L0 +error(0.004137845564894525492) D146 D170 ^ D142 +error(0.02263828873602833844) D143 D144 +error(0.0001702276148531519891) D143 D144 ^ D147 D148 +error(0.0008834832228674967128) D143 D144 ^ D148 D149 +error(0.002753689268113585723) D143 D144 ^ D148 D172 +error(0.0005499538130014023632) D143 D144 ^ D149 D172 +error(0.01909106726931757148) D143 D150 +error(0.02001517208706354509) D143 D150 ^ D147 D148 +error(0.02812184381392778681) D143 D167 +error(0.002607359131359769482) D143 D167 ^ D171 D172 +error(0.003969053395153494292) D143 D168 +error(4.689775471165016457e-05) D143 D168 ^ D171 D172 +error(0.008075155730227432868) D143 D174 +error(0.005353779632917887721) D143 D174 ^ D147 D148 +error(0.0008750595983553233767) D143 D174 ^ D147 D171 +error(0.007885636642307748342) D143 D174 ^ D148 D171 +error(0.001752721336947414684) D143 D174 ^ D148 D172 +error(0.00216109320394393227) D143 D174 ^ D171 D172 +error(0.002431970761268770556) D143 D175 +error(0.0006784536717705084465) D143 D175 ^ D148 D149 +error(4.63592763270954906e-05) D143 D175 ^ D148 D171 +error(0.001397725395569435333) D143 D175 ^ D148 D172 +error(0.0004419636415501518398) D143 D175 ^ D149 D172 +error(0.0003189261836387721327) D143 D175 ^ D171 D172 +error(0.008150338982270402197) D144 D145 +error(0.0006312850411417316072) D144 D145 ^ D148 D149 +error(8.050646160119902803e-05) D144 D145 ^ D149 +error(0.001278512356325647685) D144 D145 ^ D149 D173 +error(0.0007020451534826920416) D144 D145 ^ D173 +error(0.01277332616325764329) D144 D151 +error(0.01048264638225490653) D144 D151 ^ D148 D149 +error(0.02278187818030543224) D144 D168 +error(0.002407124538276740958) D144 D168 ^ D172 D173 +error(0.003075712190512780442) D144 D169 +error(0.0005860246305094125689) D144 D169 ^ D172 D173 +error(0.002095085221072178795) D144 D175 +error(0.002204476815442909295) D144 D175 ^ D148 D149 +error(0.001398016024156229289) D144 D175 ^ D148 D172 +error(0.001998355767841102602) D144 D175 ^ D149 D172 +error(0.001286846742682906837) D144 D175 ^ D149 D173 +error(0.001863213582515296481) D144 D175 ^ D172 D173 +error(0.001997153633049718324) D144 D176 +error(2.598292875153643494e-05) D144 D176 ^ D149 D172 +error(0.001173331601012149233) D144 D176 ^ D149 D173 +error(0.0002874234325142206487) D144 D176 ^ D172 D173 +error(1.821438837082284888e-05) D144 D176 ^ D173 +error(0.01006454994273055757) D145 +error(0.0161206695668114873) D145 D152 +error(0.01737570254568924361) D145 D152 ^ D149 +error(0.0250505139273094167) D145 D169 +error(0.002345018263775333536) D145 D169 ^ D173 +error(0.003073065190622500248) D145 D176 +error(0.002579449672997942682) D145 D176 ^ D149 +error(0.003836377064377697373) D145 D176 ^ D173 +error(0.0006646277758526700783) D145 D176 ^ D173 ^ D149 +error(0.01577597104453927479) D146 D147 +error(0.003795651666848288541) D146 D147 ^ D118 +error(0.01692448812617893331) D146 D147 ^ D142 +error(0.0008288896859749987807) D146 D147 ^ D150 ^ D118 +error(0.0191985177099640858) D146 D170 +error(0.01034173018792707011) D146 L0 +error(0.0004662125493391324252) D146 L0 ^ D114 L0 ^ D142 +error(0.0007989884919774482971) D146 L0 ^ D142 ^ D118 +error(0.01669196318468137152) D147 D148 +error(0.0002275964588231474655) D147 D148 ^ D150 +error(0.001080582133475241997) D147 D148 ^ D150 D151 +error(0.003377679907839793976) D147 D148 ^ D150 D174 +error(0.0004409901630161987838) D147 D148 ^ D174 +error(0.01456851983540525391) D147 D153 +error(0.01235616231143815344) D147 D153 ^ D150 +error(0.00378888098077427701) D147 D170 +error(0.002826407968055778298) D147 D170 ^ D142 +error(0.0001197399291263810575) D147 D170 ^ D174 +error(0.0003950766148601412729) D147 D170 ^ D174 ^ D142 +error(0.02650863068338265086) D147 D171 +error(0.002052387878255866605) D147 D171 ^ D142 +error(0.005693851689366329419) D147 D171 ^ D174 +error(0.00279004820284349574) D147 D177 +error(0.001376537795732491343) D147 D177 ^ D150 +error(0.002887687896721477781) D147 D177 ^ D174 +error(0.001094217013606597596) D147 D177 ^ D174 ^ D150 +error(0.007394753493446600857) D148 D149 +error(0.0005665103155747660754) D148 D149 ^ D150 D151 +error(0.0002961719484165020928) D148 D149 ^ D150 D175 +error(0.0007675096502073114812) D148 D149 ^ D151 D152 +error(0.002862427649248453464) D148 D149 ^ D151 D175 +error(0.01375412502619386378) D148 D154 +error(0.01096105179196072039) D148 D154 ^ D150 D151 +error(0.008487365324421063117) D148 D171 +error(0.02457592249931421502) D148 D172 +error(0.002631812399044814853) D148 D172 ^ D174 D175 +error(0.002198804135129999587) D148 D177 +error(0.001654137015294186892) D148 D177 ^ D150 D174 +error(6.003632573794476984e-06) D148 D177 ^ D150 D175 +error(0.0004409060199606022593) D148 D177 ^ D174 +error(0.002192299185518550592) D148 D178 +error(0.001746414734417907517) D148 D178 ^ D150 D151 +error(0.0003598999091759262268) D148 D178 ^ D150 D174 +error(0.001561544017991810512) D148 D178 ^ D150 D175 +error(0.000466227982502727986) D148 D178 ^ D151 D175 +error(0.001724344060558972601) D148 D178 ^ D174 D175 +error(0.01203579788742147917) D149 +error(0.004387356071761702725) D149 D172 +error(0.000208029715498591483) D149 D172 ^ D175 D176 +error(0.02221100964778081194) D149 D173 +error(0.001439615781168439605) D149 D173 ^ D175 D176 +error(0.001201823867210177017) D149 D178 +error(0.0001012650403590720146) D149 D178 ^ D150 D151 +error(0.0003034946049630618146) D149 D178 ^ D150 D175 +error(0.001323584720901610371) D149 D178 ^ D151 D175 +error(0.0007926983696969233488) D149 ^ D117 ^ D121 +error(0.0005235978985522322894) D149 ^ D117 ^ D145 +error(0.001537789608391964321) D149 ^ D121 +error(0.01000000000000000021) D150 +error(0.007026141351062988212) D150 D151 +error(0.0009672799566260600846) D150 D151 ^ D153 D154 +error(0.002612338632211596515) D150 D151 ^ D154 D178 +error(0.0008620297320340863934) D150 D151 ^ D178 +error(0.03555466847524565294) D150 D174 +error(0.004257613433980646928) D150 D174 ^ D177 D178 +error(0.003914888887922909726) D150 D175 +error(0.0008393621947703528048) D150 D175 ^ D177 D178 +error(0.0006392754687906603917) D150 D179 +error(0.0002831750050793343447) D150 D179 ^ D154 +error(0.001693673795440791933) D150 D179 ^ D154 D178 +error(7.480679588459883279e-06) D150 D179 ^ D178 +error(0.01861532100512389154) D151 D152 +error(0.00222125091587972506) D151 D152 ^ D125 +error(0.01207571090899253741) D151 D152 ^ D149 +error(0.0002065846548685445908) D151 D152 ^ D154 +error(0.0003301188119060698405) D151 D152 ^ D154 ^ D125 +error(0.01744050413829207127) D151 D155 +error(0.01542382289075709852) D151 D155 ^ D154 +error(0.02667661522528785162) D151 D175 +error(0.001456372037112019452) D151 D175 ^ D149 +error(0.00368662532011345247) D151 D175 ^ D178 +error(0.002088453177880326885) D151 D176 +error(0.002632780704037000936) D151 D176 ^ D149 +error(0.0002114179196296893338) D151 D176 ^ D178 ^ D149 +error(0.004110481756233741457) D151 D179 +error(0.002802723964281605973) D151 D179 ^ D154 +error(0.003798397130707047414) D151 D179 ^ D178 +error(0.001977355296201686527) D151 D179 ^ D178 ^ D154 +error(0.02679340452938059822) D152 D176 +error(0.002535959682426708415) D152 D176 ^ D149 +error(0.006074521331256080119) D153 D154 +error(0.001500890887174470556) D153 D154 ^ D126 +error(0.01131498296823086475) D153 D154 ^ D150 +error(0.0004481007348183289017) D153 D154 ^ D155 +error(0.0004597114541739146941) D153 D154 ^ D155 ^ D126 +error(0.02900709638648528779) D153 D177 +error(0.003760545837299076113) D153 D177 ^ D150 +error(0.01000000000000000021) D154 +error(0.001742126190683423136) D154 D177 +error(0.002377235945765063599) D154 D177 ^ D150 +error(0.000899953914339936766) D154 D177 ^ D179 +error(0.0004872680715309037156) D154 D177 ^ D179 ^ D150 +error(0.02110557026819835647) D154 D178 +error(0.0003712607219078131976) D154 D178 ^ D150 +error(0.00170219714362124892) D154 D178 ^ D179 +error(0.009114652556981153037) D154 ^ D155 +error(0.001301279920715417773) D154 ^ D179 +error(0.003066610980423866654) D155 D179 ^ D154 +error(0.009282272384986160405) D155 +error(0.01920747822175144712) D155 D179 +error(0.005000000000000000104) D156 +error(0.01596805964649321286) D156 D160 +error(0.01829778043055142397) D156 D160 ^ D157 L0 +error(0.0266862725621760527) D156 D180 +error(0.006857640050321386731) D156 D180 ^ D181 L0 +error(0.006904323411147515743) D156 D184 +error(0.004290343924348420136) D156 D184 ^ D157 L0 +error(0.004718005776907755952) D156 D184 ^ D181 L0 +error(0.002682747303679847845) D156 D184 ^ D181 L0 ^ D157 L0 +error(0.003222820645970455884) D156 D185 +error(0.002413814734477126925) D156 D185 ^ D157 D181 +error(0.0009759754382860813841) D156 D185 ^ D157 L0 +error(0.001484037307585785734) D156 D185 ^ D181 L0 +error(0.006310960120927104275) D156 ^ D157 L0 +error(0.005322407363730898185) D157 D181 ^ D156 +error(0.006735703095373630871) D157 D158 +error(0.0008816988361899102695) D157 D158 ^ D156 +error(0.0001283013300070091228) D157 D158 ^ D160 D161 +error(0.0002940482682934252782) D157 D158 ^ D160 D185 +error(0.0147823200156403517) D157 D158 ^ D161 +error(0.003440266269014606582) D157 D158 ^ D161 D185 +error(0.002728099968767540903) D157 D158 ^ D185 +error(0.0003101067761686230142) D157 D158 ^ D185 ^ D156 +error(0.02055897619164840859) D157 D163 +error(0.01315370144244269388) D157 D163 ^ D160 D161 +error(0.04054698510964466207) D157 D181 +error(0.003068906748310869584) D157 D181 ^ D184 D185 +error(0.004135165380719954369) D157 D181 ^ D185 +error(0.00170148481970367675) D157 D186 +error(0.002569670009209375477) D157 D186 ^ D160 D184 +error(0.0003645001291986636185) D157 D186 ^ D160 D185 +error(0.0006562264584675363841) D157 D186 ^ D184 D185 +error(0.00358204353642006942) D157 D187 +error(0.001864374047664434922) D157 D187 ^ D160 D161 +error(0.0003932828383309873183) D157 D187 ^ D160 D184 +error(0.001848434604000002719) D157 D187 ^ D160 D185 +error(0.0001774661344280517637) D157 D187 ^ D161 D185 +error(0.002210991227743962402) D157 D187 ^ D184 D185 +error(0.01000000000000000021) D157 L0 +error(0.01675927044650943679) D158 D164 +error(0.01483521393192921423) D158 D164 ^ D161 +error(0.004719946072497860183) D158 D181 +error(0.0007165835560042144777) D158 D181 ^ D156 +error(0.004779816248476202387) D158 D181 ^ D185 +error(0.0005462343302855433153) D158 D181 ^ D185 ^ D156 +error(0.04658633835913435217) D158 D182 +error(0.009873875383543916084) D158 D182 ^ D185 +error(0.002326384940569728357) D158 D187 +error(0.0005686665129455996306) D158 D187 ^ D160 D161 +error(0.0002337464378640189766) D158 D187 ^ D160 D185 +error(0.000491201243452230301) D158 D187 ^ D161 +error(0.001361197307204584225) D158 D187 ^ D161 D185 +error(0.0005238546515356713642) D158 D187 ^ D185 +error(0.003606535288512647489) D158 D188 +error(0.002939925401372571381) D158 D188 ^ D161 +error(0.002886682013661131477) D158 D188 ^ D185 +error(0.001451469642847544881) D158 D188 ^ D185 ^ D161 +error(0.009299079482444108993) D159 D160 +error(0.0001618067361763870105) D159 D160 ^ D157 L0 +error(0.0004009870402910406875) D159 D160 ^ D162 D163 +error(0.002038993562470617187) D159 D160 ^ D162 D186 +error(0.009839797261860206215) D159 D160 ^ D162 L0 +error(1.613708403102963708e-05) D159 D160 ^ D163 D186 +error(0.001420262771992301942) D159 D160 ^ D186 L0 +error(0.0007398317957289404605) D159 D160 ^ D186 L0 ^ D157 L0 +error(0.01276385364945899735) D159 D166 +error(0.011096381866881758) D159 D166 ^ D162 L0 +error(0.02360888144805250999) D159 D183 +error(0.003659423329073996974) D159 D183 ^ D186 L0 +error(0.002152186614080534195) D159 D184 +error(0.000456204478737577343) D159 D184 ^ D157 L0 +error(0.002391715036470463789) D159 D184 ^ D186 L0 +error(0.0001736009261800634882) D159 D184 ^ D186 L0 ^ D157 L0 +error(0.002929594954205079742) D159 D190 +error(0.003607534314359686634) D159 D190 ^ D162 L0 +error(0.002145454612411112471) D159 D190 ^ D186 L0 +error(0.0006842560657499791943) D159 D190 ^ D186 L0 ^ D162 L0 +error(0.002734468661554086567) D159 D191 +error(0.0003213799321281471302) D159 D191 ^ D162 D163 +error(0.001292369671938379096) D159 D191 ^ D162 D186 +error(0.0006814453156953355741) D159 D191 ^ D162 L0 +error(0.000171429172347746983) D159 D191 ^ D163 D186 +error(2.241052274140109318e-05) D159 D191 ^ D186 L0 +error(0.008061141833768614012) D160 D161 +error(5.603595358604616684e-05) D160 D161 ^ D133 L0 +error(0.0003240145466437737223) D160 D161 ^ D157 L0 +error(0.0007894832832053461135) D160 D161 ^ D162 D163 +error(0.0009388025834094447519) D160 D161 ^ D163 D164 +error(0.001594794524676789067) D160 D161 ^ D163 D187 +error(0.01499707882523569624) D160 D167 +error(0.009686274303190828272) D160 D167 ^ D162 D163 +error(0.02687355039480195801) D160 D184 +error(0.007485819796524218438) D160 D184 ^ D157 L0 +error(0.003107469568972692602) D160 D184 ^ D186 D187 +error(0.0005680536236455682427) D160 D184 ^ D186 L0 +error(0.003211879643569449851) D160 D185 +error(0.000376529833666304839) D160 D185 ^ D186 D187 +error(0.00120063201568994444) D160 D191 +error(0.002765100742562540039) D160 D191 ^ D162 D163 +error(0.001443006512690684761) D160 D191 ^ D162 D186 +error(0.001963765223827605017) D160 D191 ^ D163 D186 +error(0.001561962824876994256) D160 D191 ^ D163 D187 +error(0.001924240942830092883) D160 D191 ^ D186 D187 +error(0.001978648078269987665) D160 D192 +error(0.0003155662468816377805) D160 D192 ^ D163 D164 +error(0.0002941715103168643678) D160 D192 ^ D163 D186 +error(0.001543894821161831106) D160 D192 ^ D163 D187 +error(0.01000000000000000021) D161 +error(0.01996187733386350568) D161 D168 +error(0.0188611843799036949) D161 D168 ^ D163 D164 +error(0.03083190651367225324) D161 D185 +error(0.002851553572250035279) D161 D185 ^ D187 D188 +error(0.003781520367195873988) D161 D192 +error(0.002268950364954752229) D161 D192 ^ D163 D164 +error(0.001088491258235638843) D161 D192 ^ D163 D187 +error(0.002124756255297351182) D161 D192 ^ D164 D187 +error(0.0005882412221558847064) D161 D192 ^ D164 D188 +error(0.002574093098742098219) D161 D192 ^ D187 D188 +error(0.003029302145153121503) D161 D193 +error(0.001158629973361129974) D161 D193 ^ D164 D188 +error(0.0004212946613479972625) D161 D193 ^ D187 D188 +error(0.00708325686996343247) D162 D163 +error(0.001146243462908609796) D162 D163 ^ D166 D167 +error(0.000456805822531424063) D162 D163 ^ D166 D191 +error(0.000304813137048891682) D162 D163 ^ D167 D168 +error(0.002634276171414426122) D162 D163 ^ D167 D191 +error(0.01612767423445998077) D162 D171 +error(0.01171697673212769748) D162 D171 ^ D166 D167 +error(0.03918384738513067123) D162 D186 +error(0.002228925530581629937) D162 D186 ^ D190 D191 +error(0.001722182253290977872) D162 D194 +error(0.00257234959439087401) D162 D194 ^ D166 D190 +error(0.0006935910585423644449) D162 D194 ^ D166 D191 +error(0.0005515214868894067427) D162 D194 ^ D190 D191 +error(0.003685515877434647394) D162 D195 +error(0.002490979275654284057) D162 D195 ^ D166 D167 +error(0.00230918351195979598) D162 D195 ^ D166 D190 +error(0.001594143301527340979) D162 D195 ^ D166 D191 +error(0.0006317460369945696042) D162 D195 ^ D167 D191 +error(0.001985781331922381338) D162 D195 ^ D190 D191 +error(0.01000000000000000021) D162 L0 +error(0.002783689788661022121) D166 D190 ^ D162 L0 +error(0.00974687687898492458) D163 D164 +error(0.0003747287983380178798) D163 D164 ^ D167 D168 +error(0.0004743688286892290226) D163 D164 ^ D167 D192 +error(5.278044991932393068e-05) D163 D164 ^ D168 D169 +error(0.001157504928862029348) D163 D164 ^ D168 D192 +error(0.01675403094458132944) D163 D172 +error(0.01519293603187372999) D163 D172 ^ D167 D168 +error(0.003434296201232148876) D163 D186 +error(0.000572720380022092657) D163 D186 ^ D191 D192 +error(0.03896029464506293311) D163 D187 +error(0.001919558353366188335) D163 D187 ^ D191 D192 +error(0.000483343676407702429) D163 D195 +error(0.0002960171048330712418) D163 D195 ^ D166 D167 +error(0.002043284550463939) D163 D195 ^ D167 D191 +error(0.0008359769467140544747) D163 D195 ^ D167 D192 +error(0.000307975956330275866) D163 D195 ^ D191 D192 +error(0.001859072576991834544) D163 D196 +error(0.002165391394046252676) D163 D196 ^ D167 D168 +error(0.0009431680077149669911) D163 D196 ^ D167 D191 +error(0.001598928756437687122) D163 D196 ^ D167 D192 +error(0.001076978172298284934) D163 D196 ^ D168 D192 +error(0.002627582281132581458) D163 D196 ^ D191 D192 +error(0.01064372101846713069) D164 D165 +error(0.0009906389095932167845) D164 D165 ^ D161 +error(0.0006750162503938480878) D164 D165 ^ D168 D169 +error(3.756848122638768088e-05) D164 D165 ^ D168 D193 +error(0.01267267767955587709) D164 D165 ^ D169 +error(0.004635934828459368356) D164 D165 ^ D169 D193 +error(0.002185403898100024295) D164 D165 ^ D193 +error(0.01336909531579565276) D164 D173 +error(0.01105500658491261057) D164 D173 ^ D168 D169 +error(0.005797025101372838864) D164 D187 +error(0.0003417045946126709161) D164 D187 ^ D192 D193 +error(0.0244028701613570112) D164 D188 +error(0.005035374525287034803) D164 D188 ^ D161 +error(0.001425061471213253782) D164 D188 ^ D192 D193 +error(0.001025440560362546371) D164 D188 ^ D193 +error(0.001739025683189662557) D164 D196 +error(0.0005163048540822849121) D164 D196 ^ D167 D168 +error(0.0003872660728112318042) D164 D196 ^ D167 D192 +error(0.001010208392926537947) D164 D196 ^ D168 D192 +error(0.0003614633525562173117) D164 D196 ^ D168 D193 +error(0.0007708242313029848268) D164 D196 ^ D192 D193 +error(0.002829373934999426885) D164 D197 +error(0.001161648608437570009) D164 D197 ^ D168 D169 +error(0.0004817648811728498333) D164 D197 ^ D168 D192 +error(0.002369403621825834708) D164 D197 ^ D168 D193 +error(0.0004523255119455854285) D164 D197 ^ D169 D193 +error(0.00243362505591642516) D164 D197 ^ D192 D193 +error(0.00845022675102432598) D165 +error(0.003122593618286308333) D165 D188 +error(0.0003444676573668129416) D165 D188 ^ D161 +error(0.003029471903265145566) D165 D188 ^ D193 +error(0.02878109383905069762) D165 D189 +error(0.005245455859824325884) D165 D189 ^ D193 +error(0.002444244415730570993) D165 D197 +error(1.320503562624765046e-05) D165 D197 ^ D168 D169 +error(0.000319071422289989796) D165 D197 ^ D168 D193 +error(0.002504366306824067946) D165 D197 ^ D169 D193 +error(0.01376696901986126757) D165 ^ D169 +error(0.0004076332642725224499) D165 ^ D193 +error(0.001893217879630942077) D165 ^ D193 ^ D169 +error(0.01079365791184803448) D166 +error(0.01463814118025971722) D166 D167 +error(0.0003749792498749710858) D166 D167 ^ D138 L0 +error(0.0005400820725793096383) D166 D167 ^ D170 D171 +error(0.000418692903235950032) D166 D167 ^ D171 D172 +error(0.001712985178897279354) D166 D167 ^ D171 D195 +error(4.669523646288583138e-05) D166 D167 ^ D172 D195 +error(0.04918066768488339735) D166 D190 +error(0.00367209971397850464) D166 D190 ^ D194 D195 +error(0.001587061349442817852) D166 D191 +error(0.0006664841908282826029) D166 D191 ^ D194 D195 +error(0.0004431564671695123817) D166 D198 +error(9.765646950254146724e-06) D166 D198 ^ D171 D172 +error(0.0006406541570109316498) D166 D198 ^ D171 D195 +error(5.274589083871283256e-05) D166 D198 ^ D172 D195 +error(0.0117889524045072993) D166 ^ D170 L0 +error(0.004137845564894525492) D170 D194 ^ D166 +error(0.02263828873602833844) D167 D168 +error(0.0001702276148531519891) D167 D168 ^ D171 D172 +error(0.0008834832228674967128) D167 D168 ^ D172 D173 +error(0.002753689268113585723) D167 D168 ^ D172 D196 +error(0.0005499538130014023632) D167 D168 ^ D173 D196 +error(0.01909106726931757148) D167 D174 +error(0.02001517208706354509) D167 D174 ^ D171 D172 +error(0.02812184381392778681) D167 D191 +error(0.002607359131359769482) D167 D191 ^ D195 D196 +error(0.003969053395153494292) D167 D192 +error(4.689775471165016457e-05) D167 D192 ^ D195 D196 +error(0.008075155730227432868) D167 D198 +error(0.005353779632917887721) D167 D198 ^ D171 D172 +error(0.0008750595983553233767) D167 D198 ^ D171 D195 +error(0.007885636642307748342) D167 D198 ^ D172 D195 +error(0.001752721336947414684) D167 D198 ^ D172 D196 +error(0.00216109320394393227) D167 D198 ^ D195 D196 +error(0.002431970761268770556) D167 D199 +error(0.0006784536717705084465) D167 D199 ^ D172 D173 +error(4.63592763270954906e-05) D167 D199 ^ D172 D195 +error(0.001397725395569435333) D167 D199 ^ D172 D196 +error(0.0004419636415501518398) D167 D199 ^ D173 D196 +error(0.0003189261836387721327) D167 D199 ^ D195 D196 +error(0.008150338982270402197) D168 D169 +error(0.0006312850411417316072) D168 D169 ^ D172 D173 +error(8.050646160119902803e-05) D168 D169 ^ D173 +error(0.001278512356325647685) D168 D169 ^ D173 D197 +error(0.0007020451534826920416) D168 D169 ^ D197 +error(0.01277332616325764329) D168 D175 +error(0.01048264638225490653) D168 D175 ^ D172 D173 +error(0.02278187818030543224) D168 D192 +error(0.002407124538276740958) D168 D192 ^ D196 D197 +error(0.003075712190512780442) D168 D193 +error(0.0005860246305094125689) D168 D193 ^ D196 D197 +error(0.002095085221072178795) D168 D199 +error(0.002204476815442909295) D168 D199 ^ D172 D173 +error(0.001398016024156229289) D168 D199 ^ D172 D196 +error(0.001998355767841102602) D168 D199 ^ D173 D196 +error(0.001286846742682906837) D168 D199 ^ D173 D197 +error(0.001863213582515296481) D168 D199 ^ D196 D197 +error(0.001997153633049718324) D168 D200 +error(2.598292875153643494e-05) D168 D200 ^ D173 D196 +error(0.001173331601012149233) D168 D200 ^ D173 D197 +error(0.0002874234325142206487) D168 D200 ^ D196 D197 +error(1.821438837082284888e-05) D168 D200 ^ D197 +error(0.01006454994273055757) D169 +error(0.0161206695668114873) D169 D176 +error(0.01737570254568924361) D169 D176 ^ D173 +error(0.0250505139273094167) D169 D193 +error(0.002345018263775333536) D169 D193 ^ D197 +error(0.003073065190622500248) D169 D200 +error(0.002579449672997942682) D169 D200 ^ D173 +error(0.003836377064377697373) D169 D200 ^ D197 +error(0.0006646277758526700783) D169 D200 ^ D197 ^ D173 +error(0.01577597104453927479) D170 D171 +error(0.003795651666848288541) D170 D171 ^ D142 +error(0.01692448812617893331) D170 D171 ^ D166 +error(0.0008288896859749987807) D170 D171 ^ D174 ^ D142 +error(0.0191985177099640858) D170 D194 +error(0.01034173018792707011) D170 L0 +error(0.0004662125493391324252) D170 L0 ^ D138 L0 ^ D166 +error(0.0007989884919774482971) D170 L0 ^ D166 ^ D142 +error(0.01669196318468137152) D171 D172 +error(0.0002275964588231474655) D171 D172 ^ D174 +error(0.001080582133475241997) D171 D172 ^ D174 D175 +error(0.003377679907839793976) D171 D172 ^ D174 D198 +error(0.0004409901630161987838) D171 D172 ^ D198 +error(0.01456851983540525391) D171 D177 +error(0.01235616231143815344) D171 D177 ^ D174 +error(0.00378888098077427701) D171 D194 +error(0.002826407968055778298) D171 D194 ^ D166 +error(0.0001197399291263810575) D171 D194 ^ D198 +error(0.0003950766148601412729) D171 D194 ^ D198 ^ D166 +error(0.02650863068338265086) D171 D195 +error(0.002052387878255866605) D171 D195 ^ D166 +error(0.005693851689366329419) D171 D195 ^ D198 +error(0.00279004820284349574) D171 D201 +error(0.001376537795732491343) D171 D201 ^ D174 +error(0.002887687896721477781) D171 D201 ^ D198 +error(0.001094217013606597596) D171 D201 ^ D198 ^ D174 +error(0.007394753493446600857) D172 D173 +error(0.0005665103155747660754) D172 D173 ^ D174 D175 +error(0.0002961719484165020928) D172 D173 ^ D174 D199 +error(0.0007675096502073114812) D172 D173 ^ D175 D176 +error(0.002862427649248453464) D172 D173 ^ D175 D199 +error(0.01375412502619386378) D172 D178 +error(0.01096105179196072039) D172 D178 ^ D174 D175 +error(0.008487365324421063117) D172 D195 +error(0.02457592249931421502) D172 D196 +error(0.002631812399044814853) D172 D196 ^ D198 D199 +error(0.002198804135129999587) D172 D201 +error(0.001654137015294186892) D172 D201 ^ D174 D198 +error(6.003632573794476984e-06) D172 D201 ^ D174 D199 +error(0.0004409060199606022593) D172 D201 ^ D198 +error(0.002192299185518550592) D172 D202 +error(0.001746414734417907517) D172 D202 ^ D174 D175 +error(0.0003598999091759262268) D172 D202 ^ D174 D198 +error(0.001561544017991810512) D172 D202 ^ D174 D199 +error(0.000466227982502727986) D172 D202 ^ D175 D199 +error(0.001724344060558972601) D172 D202 ^ D198 D199 +error(0.01203579788742147917) D173 +error(0.004387356071761702725) D173 D196 +error(0.000208029715498591483) D173 D196 ^ D199 D200 +error(0.02221100964778081194) D173 D197 +error(0.001439615781168439605) D173 D197 ^ D199 D200 +error(0.001201823867210177017) D173 D202 +error(0.0001012650403590720146) D173 D202 ^ D174 D175 +error(0.0003034946049630618146) D173 D202 ^ D174 D199 +error(0.001323584720901610371) D173 D202 ^ D175 D199 +error(0.0007926983696969233488) D173 ^ D141 ^ D145 +error(0.0005235978985522322894) D173 ^ D141 ^ D169 +error(0.001537789608391964321) D173 ^ D145 +error(0.01000000000000000021) D174 +error(0.007026141351062988212) D174 D175 +error(0.0009672799566260600846) D174 D175 ^ D177 D178 +error(0.002612338632211596515) D174 D175 ^ D178 D202 +error(0.0008620297320340863934) D174 D175 ^ D202 +error(0.03555466847524565294) D174 D198 +error(0.004257613433980646928) D174 D198 ^ D201 D202 +error(0.003914888887922909726) D174 D199 +error(0.0008393621947703528048) D174 D199 ^ D201 D202 +error(0.0006392754687906603917) D174 D203 +error(0.0002831750050793343447) D174 D203 ^ D178 +error(0.001693673795440791933) D174 D203 ^ D178 D202 +error(7.480679588459883279e-06) D174 D203 ^ D202 +error(0.01861532100512389154) D175 D176 +error(0.00222125091587972506) D175 D176 ^ D149 +error(0.01207571090899253741) D175 D176 ^ D173 +error(0.0002065846548685445908) D175 D176 ^ D178 +error(0.0003301188119060698405) D175 D176 ^ D178 ^ D149 +error(0.01744050413829207127) D175 D179 +error(0.01542382289075709852) D175 D179 ^ D178 +error(0.02667661522528785162) D175 D199 +error(0.001456372037112019452) D175 D199 ^ D173 +error(0.00368662532011345247) D175 D199 ^ D202 +error(0.002088453177880326885) D175 D200 +error(0.002632780704037000936) D175 D200 ^ D173 +error(0.0002114179196296893338) D175 D200 ^ D202 ^ D173 +error(0.004110481756233741457) D175 D203 +error(0.002802723964281605973) D175 D203 ^ D178 +error(0.003798397130707047414) D175 D203 ^ D202 +error(0.001977355296201686527) D175 D203 ^ D202 ^ D178 +error(0.02679340452938059822) D176 D200 +error(0.002535959682426708415) D176 D200 ^ D173 +error(0.006074521331256080119) D177 D178 +error(0.001500890887174470556) D177 D178 ^ D150 +error(0.01131498296823086475) D177 D178 ^ D174 +error(0.0004481007348183289017) D177 D178 ^ D179 +error(0.0004597114541739146941) D177 D178 ^ D179 ^ D150 +error(0.02900709638648528779) D177 D201 +error(0.003760545837299076113) D177 D201 ^ D174 +error(0.01000000000000000021) D178 +error(0.001742126190683423136) D178 D201 +error(0.002377235945765063599) D178 D201 ^ D174 +error(0.000899953914339936766) D178 D201 ^ D203 +error(0.0004872680715309037156) D178 D201 ^ D203 ^ D174 +error(0.02110557026819835647) D178 D202 +error(0.0003712607219078131976) D178 D202 ^ D174 +error(0.00170219714362124892) D178 D202 ^ D203 +error(0.009114652556981153037) D178 ^ D179 +error(0.001301279920715417773) D178 ^ D203 +error(0.003066610980423866654) D179 D203 ^ D178 +error(0.009282272384986160405) D179 +error(0.01920747822175144712) D179 D203 +error(0.005000000000000000104) D180 +error(0.01596805964649321286) D180 D184 +error(0.01829778043055142397) D180 D184 ^ D181 L0 +error(0.0266862725621760527) D180 D204 +error(0.006857640050321386731) D180 D204 ^ D205 L0 +error(0.006904323411147515743) D180 D208 +error(0.004290343924348420136) D180 D208 ^ D181 L0 +error(0.004718005776907755952) D180 D208 ^ D205 L0 +error(0.002682747303679847845) D180 D208 ^ D205 L0 ^ D181 L0 +error(0.003222820645970455884) D180 D209 +error(0.002413814734477126925) D180 D209 ^ D181 D205 +error(0.0009759754382860813841) D180 D209 ^ D181 L0 +error(0.001484037307585785734) D180 D209 ^ D205 L0 +error(0.006310960120927104275) D180 ^ D181 L0 +error(0.005322407363730898185) D181 D205 ^ D180 +error(0.006735703095373630871) D181 D182 +error(0.0008816988361899102695) D181 D182 ^ D180 +error(0.0001283013300070091228) D181 D182 ^ D184 D185 +error(0.0002940482682934252782) D181 D182 ^ D184 D209 +error(0.0147823200156403517) D181 D182 ^ D185 +error(0.003440266269014606582) D181 D182 ^ D185 D209 +error(0.002728099968767540903) D181 D182 ^ D209 +error(0.0003101067761686230142) D181 D182 ^ D209 ^ D180 +error(0.02055897619164840859) D181 D187 +error(0.01315370144244269388) D181 D187 ^ D184 D185 +error(0.04054698510964466207) D181 D205 +error(0.003068906748310869584) D181 D205 ^ D208 D209 +error(0.004135165380719954369) D181 D205 ^ D209 +error(0.00170148481970367675) D181 D210 +error(0.002569670009209375477) D181 D210 ^ D184 D208 +error(0.0003645001291986636185) D181 D210 ^ D184 D209 +error(0.0006562264584675363841) D181 D210 ^ D208 D209 +error(0.00358204353642006942) D181 D211 +error(0.001864374047664434922) D181 D211 ^ D184 D185 +error(0.0003932828383309873183) D181 D211 ^ D184 D208 +error(0.001848434604000002719) D181 D211 ^ D184 D209 +error(0.0001774661344280517637) D181 D211 ^ D185 D209 +error(0.002210991227743962402) D181 D211 ^ D208 D209 +error(0.01000000000000000021) D181 L0 +error(0.01675927044650943679) D182 D188 +error(0.01483521393192921423) D182 D188 ^ D185 +error(0.004719946072497860183) D182 D205 +error(0.0007165835560042144777) D182 D205 ^ D180 +error(0.004779816248476202387) D182 D205 ^ D209 +error(0.0005462343302855433153) D182 D205 ^ D209 ^ D180 +error(0.04658633835913435217) D182 D206 +error(0.009873875383543916084) D182 D206 ^ D209 +error(0.002326384940569728357) D182 D211 +error(0.0005686665129455996306) D182 D211 ^ D184 D185 +error(0.0002337464378640189766) D182 D211 ^ D184 D209 +error(0.000491201243452230301) D182 D211 ^ D185 +error(0.001361197307204584225) D182 D211 ^ D185 D209 +error(0.0005238546515356713642) D182 D211 ^ D209 +error(0.003606535288512647489) D182 D212 +error(0.002939925401372571381) D182 D212 ^ D185 +error(0.002886682013661131477) D182 D212 ^ D209 +error(0.001451469642847544881) D182 D212 ^ D209 ^ D185 +error(0.009299079482444108993) D183 D184 +error(0.0001618067361763870105) D183 D184 ^ D181 L0 +error(0.0004009870402910406875) D183 D184 ^ D186 D187 +error(0.002038993562470617187) D183 D184 ^ D186 D210 +error(0.009839797261860206215) D183 D184 ^ D186 L0 +error(1.613708403102963708e-05) D183 D184 ^ D187 D210 +error(0.001420262771992301942) D183 D184 ^ D210 L0 +error(0.0007398317957289404605) D183 D184 ^ D210 L0 ^ D181 L0 +error(0.01276385364945899735) D183 D190 +error(0.011096381866881758) D183 D190 ^ D186 L0 +error(0.02360888144805250999) D183 D207 +error(0.003659423329073996974) D183 D207 ^ D210 L0 +error(0.002152186614080534195) D183 D208 +error(0.000456204478737577343) D183 D208 ^ D181 L0 +error(0.002391715036470463789) D183 D208 ^ D210 L0 +error(0.0001736009261800634882) D183 D208 ^ D210 L0 ^ D181 L0 +error(0.002929594954205079742) D183 D214 +error(0.003607534314359686634) D183 D214 ^ D186 L0 +error(0.002145454612411112471) D183 D214 ^ D210 L0 +error(0.0006842560657499791943) D183 D214 ^ D210 L0 ^ D186 L0 +error(0.002734468661554086567) D183 D215 +error(0.0003213799321281471302) D183 D215 ^ D186 D187 +error(0.001292369671938379096) D183 D215 ^ D186 D210 +error(0.0006814453156953355741) D183 D215 ^ D186 L0 +error(0.000171429172347746983) D183 D215 ^ D187 D210 +error(2.241052274140109318e-05) D183 D215 ^ D210 L0 +error(0.008061141833768614012) D184 D185 +error(5.603595358604616684e-05) D184 D185 ^ D157 L0 +error(0.0003240145466437737223) D184 D185 ^ D181 L0 +error(0.0007894832832053461135) D184 D185 ^ D186 D187 +error(0.0009388025834094447519) D184 D185 ^ D187 D188 +error(0.001594794524676789067) D184 D185 ^ D187 D211 +error(0.01499707882523569624) D184 D191 +error(0.009686274303190828272) D184 D191 ^ D186 D187 +error(0.02687355039480195801) D184 D208 +error(0.007485819796524218438) D184 D208 ^ D181 L0 +error(0.003107469568972692602) D184 D208 ^ D210 D211 +error(0.0005680536236455682427) D184 D208 ^ D210 L0 +error(0.003211879643569449851) D184 D209 +error(0.000376529833666304839) D184 D209 ^ D210 D211 +error(0.00120063201568994444) D184 D215 +error(0.002765100742562540039) D184 D215 ^ D186 D187 +error(0.001443006512690684761) D184 D215 ^ D186 D210 +error(0.001963765223827605017) D184 D215 ^ D187 D210 +error(0.001561962824876994256) D184 D215 ^ D187 D211 +error(0.001924240942830092883) D184 D215 ^ D210 D211 +error(0.001978648078269987665) D184 D216 +error(0.0003155662468816377805) D184 D216 ^ D187 D188 +error(0.0002941715103168643678) D184 D216 ^ D187 D210 +error(0.001543894821161831106) D184 D216 ^ D187 D211 +error(0.01000000000000000021) D185 +error(0.01996187733386350568) D185 D192 +error(0.0188611843799036949) D185 D192 ^ D187 D188 +error(0.03083190651367225324) D185 D209 +error(0.002851553572250035279) D185 D209 ^ D211 D212 +error(0.003781520367195873988) D185 D216 +error(0.002268950364954752229) D185 D216 ^ D187 D188 +error(0.001088491258235638843) D185 D216 ^ D187 D211 +error(0.002124756255297351182) D185 D216 ^ D188 D211 +error(0.0005882412221558847064) D185 D216 ^ D188 D212 +error(0.002574093098742098219) D185 D216 ^ D211 D212 +error(0.003029302145153121503) D185 D217 +error(0.001158629973361129974) D185 D217 ^ D188 D212 +error(0.0004212946613479972625) D185 D217 ^ D211 D212 +error(0.00708325686996343247) D186 D187 +error(0.001146243462908609796) D186 D187 ^ D190 D191 +error(0.000456805822531424063) D186 D187 ^ D190 D215 +error(0.000304813137048891682) D186 D187 ^ D191 D192 +error(0.002634276171414426122) D186 D187 ^ D191 D215 +error(0.01612767423445998077) D186 D195 +error(0.01171697673212769748) D186 D195 ^ D190 D191 +error(0.03918384738513067123) D186 D210 +error(0.002228925530581629937) D186 D210 ^ D214 D215 +error(0.001722182253290977872) D186 D218 +error(0.00257234959439087401) D186 D218 ^ D190 D214 +error(0.0006935910585423644449) D186 D218 ^ D190 D215 +error(0.0005515214868894067427) D186 D218 ^ D214 D215 +error(0.003685515877434647394) D186 D219 +error(0.002490979275654284057) D186 D219 ^ D190 D191 +error(0.00230918351195979598) D186 D219 ^ D190 D214 +error(0.001594143301527340979) D186 D219 ^ D190 D215 +error(0.0006317460369945696042) D186 D219 ^ D191 D215 +error(0.001985781331922381338) D186 D219 ^ D214 D215 +error(0.01000000000000000021) D186 L0 +error(0.002783689788661022121) D190 D214 ^ D186 L0 +error(0.00974687687898492458) D187 D188 +error(0.0003747287983380178798) D187 D188 ^ D191 D192 +error(0.0004743688286892290226) D187 D188 ^ D191 D216 +error(5.278044991932393068e-05) D187 D188 ^ D192 D193 +error(0.001157504928862029348) D187 D188 ^ D192 D216 +error(0.01675403094458132944) D187 D196 +error(0.01519293603187372999) D187 D196 ^ D191 D192 +error(0.003434296201232148876) D187 D210 +error(0.000572720380022092657) D187 D210 ^ D215 D216 +error(0.03896029464506293311) D187 D211 +error(0.001919558353366188335) D187 D211 ^ D215 D216 +error(0.000483343676407702429) D187 D219 +error(0.0002960171048330712418) D187 D219 ^ D190 D191 +error(0.002043284550463939) D187 D219 ^ D191 D215 +error(0.0008359769467140544747) D187 D219 ^ D191 D216 +error(0.000307975956330275866) D187 D219 ^ D215 D216 +error(0.001859072576991834544) D187 D220 +error(0.002165391394046252676) D187 D220 ^ D191 D192 +error(0.0009431680077149669911) D187 D220 ^ D191 D215 +error(0.001598928756437687122) D187 D220 ^ D191 D216 +error(0.001076978172298284934) D187 D220 ^ D192 D216 +error(0.002627582281132581458) D187 D220 ^ D215 D216 +error(0.01064372101846713069) D188 D189 +error(0.0009906389095932167845) D188 D189 ^ D185 +error(0.0006750162503938480878) D188 D189 ^ D192 D193 +error(3.756848122638768088e-05) D188 D189 ^ D192 D217 +error(0.01267267767955587709) D188 D189 ^ D193 +error(0.004635934828459368356) D188 D189 ^ D193 D217 +error(0.002185403898100024295) D188 D189 ^ D217 +error(0.01336909531579565276) D188 D197 +error(0.01105500658491261057) D188 D197 ^ D192 D193 +error(0.005797025101372838864) D188 D211 +error(0.0003417045946126709161) D188 D211 ^ D216 D217 +error(0.0244028701613570112) D188 D212 +error(0.005035374525287034803) D188 D212 ^ D185 +error(0.001425061471213253782) D188 D212 ^ D216 D217 +error(0.001025440560362546371) D188 D212 ^ D217 +error(0.001739025683189662557) D188 D220 +error(0.0005163048540822849121) D188 D220 ^ D191 D192 +error(0.0003872660728112318042) D188 D220 ^ D191 D216 +error(0.001010208392926537947) D188 D220 ^ D192 D216 +error(0.0003614633525562173117) D188 D220 ^ D192 D217 +error(0.0007708242313029848268) D188 D220 ^ D216 D217 +error(0.002829373934999426885) D188 D221 +error(0.001161648608437570009) D188 D221 ^ D192 D193 +error(0.0004817648811728498333) D188 D221 ^ D192 D216 +error(0.002369403621825834708) D188 D221 ^ D192 D217 +error(0.0004523255119455854285) D188 D221 ^ D193 D217 +error(0.00243362505591642516) D188 D221 ^ D216 D217 +error(0.00845022675102432598) D189 +error(0.003122593618286308333) D189 D212 +error(0.0003444676573668129416) D189 D212 ^ D185 +error(0.003029471903265145566) D189 D212 ^ D217 +error(0.02878109383905069762) D189 D213 +error(0.005245455859824325884) D189 D213 ^ D217 +error(0.002444244415730570993) D189 D221 +error(1.320503562624765046e-05) D189 D221 ^ D192 D193 +error(0.000319071422289989796) D189 D221 ^ D192 D217 +error(0.002504366306824067946) D189 D221 ^ D193 D217 +error(0.01376696901986126757) D189 ^ D193 +error(0.0004076332642725224499) D189 ^ D217 +error(0.001893217879630942077) D189 ^ D217 ^ D193 +error(0.01079365791184803448) D190 +error(0.01463814118025971722) D190 D191 +error(0.0003749792498749710858) D190 D191 ^ D162 L0 +error(0.0005400820725793096383) D190 D191 ^ D194 D195 +error(0.000418692903235950032) D190 D191 ^ D195 D196 +error(0.001712985178897279354) D190 D191 ^ D195 D219 +error(4.669523646288583138e-05) D190 D191 ^ D196 D219 +error(0.04918066768488339735) D190 D214 +error(0.00367209971397850464) D190 D214 ^ D218 D219 +error(0.001587061349442817852) D190 D215 +error(0.0006664841908282826029) D190 D215 ^ D218 D219 +error(0.0004431564671695123817) D190 D222 +error(9.765646950254146724e-06) D190 D222 ^ D195 D196 +error(0.0006406541570109316498) D190 D222 ^ D195 D219 +error(5.274589083871283256e-05) D190 D222 ^ D196 D219 +error(0.0117889524045072993) D190 ^ D194 L0 +error(0.004137845564894525492) D194 D218 ^ D190 +error(0.02263828873602833844) D191 D192 +error(0.0001702276148531519891) D191 D192 ^ D195 D196 +error(0.0008834832228674967128) D191 D192 ^ D196 D197 +error(0.002753689268113585723) D191 D192 ^ D196 D220 +error(0.0005499538130014023632) D191 D192 ^ D197 D220 +error(0.01909106726931757148) D191 D198 +error(0.02001517208706354509) D191 D198 ^ D195 D196 +error(0.02812184381392778681) D191 D215 +error(0.002607359131359769482) D191 D215 ^ D219 D220 +error(0.003969053395153494292) D191 D216 +error(4.689775471165016457e-05) D191 D216 ^ D219 D220 +error(0.008075155730227432868) D191 D222 +error(0.005353779632917887721) D191 D222 ^ D195 D196 +error(0.0008750595983553233767) D191 D222 ^ D195 D219 +error(0.007885636642307748342) D191 D222 ^ D196 D219 +error(0.001752721336947414684) D191 D222 ^ D196 D220 +error(0.00216109320394393227) D191 D222 ^ D219 D220 +error(0.002431970761268770556) D191 D223 +error(0.0006784536717705084465) D191 D223 ^ D196 D197 +error(4.63592763270954906e-05) D191 D223 ^ D196 D219 +error(0.001397725395569435333) D191 D223 ^ D196 D220 +error(0.0004419636415501518398) D191 D223 ^ D197 D220 +error(0.0003189261836387721327) D191 D223 ^ D219 D220 +error(0.008150338982270402197) D192 D193 +error(0.0006312850411417316072) D192 D193 ^ D196 D197 +error(8.050646160119902803e-05) D192 D193 ^ D197 +error(0.001278512356325647685) D192 D193 ^ D197 D221 +error(0.0007020451534826920416) D192 D193 ^ D221 +error(0.01277332616325764329) D192 D199 +error(0.01048264638225490653) D192 D199 ^ D196 D197 +error(0.02278187818030543224) D192 D216 +error(0.002407124538276740958) D192 D216 ^ D220 D221 +error(0.003075712190512780442) D192 D217 +error(0.0005860246305094125689) D192 D217 ^ D220 D221 +error(0.002095085221072178795) D192 D223 +error(0.002204476815442909295) D192 D223 ^ D196 D197 +error(0.001398016024156229289) D192 D223 ^ D196 D220 +error(0.001998355767841102602) D192 D223 ^ D197 D220 +error(0.001286846742682906837) D192 D223 ^ D197 D221 +error(0.001863213582515296481) D192 D223 ^ D220 D221 +error(0.001997153633049718324) D192 D224 +error(2.598292875153643494e-05) D192 D224 ^ D197 D220 +error(0.001173331601012149233) D192 D224 ^ D197 D221 +error(0.0002874234325142206487) D192 D224 ^ D220 D221 +error(1.821438837082284888e-05) D192 D224 ^ D221 +error(0.01006454994273055757) D193 +error(0.0161206695668114873) D193 D200 +error(0.01737570254568924361) D193 D200 ^ D197 +error(0.0250505139273094167) D193 D217 +error(0.002345018263775333536) D193 D217 ^ D221 +error(0.003073065190622500248) D193 D224 +error(0.002579449672997942682) D193 D224 ^ D197 +error(0.003836377064377697373) D193 D224 ^ D221 +error(0.0006646277758526700783) D193 D224 ^ D221 ^ D197 +error(0.01577597104453927479) D194 D195 +error(0.003795651666848288541) D194 D195 ^ D166 +error(0.01692448812617893331) D194 D195 ^ D190 +error(0.0008288896859749987807) D194 D195 ^ D198 ^ D166 +error(0.0191985177099640858) D194 D218 +error(0.01034173018792707011) D194 L0 +error(0.0004662125493391324252) D194 L0 ^ D162 L0 ^ D190 +error(0.0007989884919774482971) D194 L0 ^ D190 ^ D166 +error(0.01669196318468137152) D195 D196 +error(0.0002275964588231474655) D195 D196 ^ D198 +error(0.001080582133475241997) D195 D196 ^ D198 D199 +error(0.003377679907839793976) D195 D196 ^ D198 D222 +error(0.0004409901630161987838) D195 D196 ^ D222 +error(0.01456851983540525391) D195 D201 +error(0.01235616231143815344) D195 D201 ^ D198 +error(0.00378888098077427701) D195 D218 +error(0.002826407968055778298) D195 D218 ^ D190 +error(0.0001197399291263810575) D195 D218 ^ D222 +error(0.0003950766148601412729) D195 D218 ^ D222 ^ D190 +error(0.02650863068338265086) D195 D219 +error(0.002052387878255866605) D195 D219 ^ D190 +error(0.005693851689366329419) D195 D219 ^ D222 +error(0.00279004820284349574) D195 D225 +error(0.001376537795732491343) D195 D225 ^ D198 +error(0.002887687896721477781) D195 D225 ^ D222 +error(0.001094217013606597596) D195 D225 ^ D222 ^ D198 +error(0.007394753493446600857) D196 D197 +error(0.0005665103155747660754) D196 D197 ^ D198 D199 +error(0.0002961719484165020928) D196 D197 ^ D198 D223 +error(0.0007675096502073114812) D196 D197 ^ D199 D200 +error(0.002862427649248453464) D196 D197 ^ D199 D223 +error(0.01375412502619386378) D196 D202 +error(0.01096105179196072039) D196 D202 ^ D198 D199 +error(0.008487365324421063117) D196 D219 +error(0.02457592249931421502) D196 D220 +error(0.002631812399044814853) D196 D220 ^ D222 D223 +error(0.002198804135129999587) D196 D225 +error(0.001654137015294186892) D196 D225 ^ D198 D222 +error(6.003632573794476984e-06) D196 D225 ^ D198 D223 +error(0.0004409060199606022593) D196 D225 ^ D222 +error(0.002192299185518550592) D196 D226 +error(0.001746414734417907517) D196 D226 ^ D198 D199 +error(0.0003598999091759262268) D196 D226 ^ D198 D222 +error(0.001561544017991810512) D196 D226 ^ D198 D223 +error(0.000466227982502727986) D196 D226 ^ D199 D223 +error(0.001724344060558972601) D196 D226 ^ D222 D223 +error(0.01203579788742147917) D197 +error(0.004387356071761702725) D197 D220 +error(0.000208029715498591483) D197 D220 ^ D223 D224 +error(0.02221100964778081194) D197 D221 +error(0.001439615781168439605) D197 D221 ^ D223 D224 +error(0.001201823867210177017) D197 D226 +error(0.0001012650403590720146) D197 D226 ^ D198 D199 +error(0.0003034946049630618146) D197 D226 ^ D198 D223 +error(0.001323584720901610371) D197 D226 ^ D199 D223 +error(0.0007926983696969233488) D197 ^ D165 ^ D169 +error(0.0005235978985522322894) D197 ^ D165 ^ D193 +error(0.001537789608391964321) D197 ^ D169 +error(0.01000000000000000021) D198 +error(0.007026141351062988212) D198 D199 +error(0.0009672799566260600846) D198 D199 ^ D201 D202 +error(0.002612338632211596515) D198 D199 ^ D202 D226 +error(0.0008620297320340863934) D198 D199 ^ D226 +error(0.03555466847524565294) D198 D222 +error(0.004257613433980646928) D198 D222 ^ D225 D226 +error(0.003914888887922909726) D198 D223 +error(0.0008393621947703528048) D198 D223 ^ D225 D226 +error(0.0006392754687906603917) D198 D227 +error(0.0002831750050793343447) D198 D227 ^ D202 +error(0.001693673795440791933) D198 D227 ^ D202 D226 +error(7.480679588459883279e-06) D198 D227 ^ D226 +error(0.01861532100512389154) D199 D200 +error(0.00222125091587972506) D199 D200 ^ D173 +error(0.01207571090899253741) D199 D200 ^ D197 +error(0.0002065846548685445908) D199 D200 ^ D202 +error(0.0003301188119060698405) D199 D200 ^ D202 ^ D173 +error(0.01744050413829207127) D199 D203 +error(0.01542382289075709852) D199 D203 ^ D202 +error(0.02667661522528785162) D199 D223 +error(0.001456372037112019452) D199 D223 ^ D197 +error(0.00368662532011345247) D199 D223 ^ D226 +error(0.002088453177880326885) D199 D224 +error(0.002632780704037000936) D199 D224 ^ D197 +error(0.0002114179196296893338) D199 D224 ^ D226 ^ D197 +error(0.004110481756233741457) D199 D227 +error(0.002802723964281605973) D199 D227 ^ D202 +error(0.003798397130707047414) D199 D227 ^ D226 +error(0.001977355296201686527) D199 D227 ^ D226 ^ D202 +error(0.02679340452938059822) D200 D224 +error(0.002535959682426708415) D200 D224 ^ D197 +error(0.006074521331256080119) D201 D202 +error(0.001500890887174470556) D201 D202 ^ D174 +error(0.01131498296823086475) D201 D202 ^ D198 +error(0.0004481007348183289017) D201 D202 ^ D203 +error(0.0004597114541739146941) D201 D202 ^ D203 ^ D174 +error(0.02900709638648528779) D201 D225 +error(0.003760545837299076113) D201 D225 ^ D198 +error(0.01000000000000000021) D202 +error(0.001742126190683423136) D202 D225 +error(0.002377235945765063599) D202 D225 ^ D198 +error(0.000899953914339936766) D202 D225 ^ D227 +error(0.0004872680715309037156) D202 D225 ^ D227 ^ D198 +error(0.02110557026819835647) D202 D226 +error(0.0003712607219078131976) D202 D226 ^ D198 +error(0.00170219714362124892) D202 D226 ^ D227 +error(0.009114652556981153037) D202 ^ D203 +error(0.001301279920715417773) D202 ^ D227 +error(0.003066610980423866654) D203 D227 ^ D202 +error(0.009282272384986160405) D203 +error(0.01920747822175144712) D203 D227 +error(0.005000000000000000104) D204 +error(0.01596805964649321286) D204 D208 +error(0.01829778043055142397) D204 D208 ^ D205 L0 +error(0.0266862725621760527) D204 D228 +error(0.006857640050321386731) D204 D228 ^ D229 L0 +error(0.006904323411147515743) D204 D232 +error(0.004290343924348420136) D204 D232 ^ D205 L0 +error(0.004718005776907755952) D204 D232 ^ D229 L0 +error(0.002682747303679847845) D204 D232 ^ D229 L0 ^ D205 L0 +error(0.003222820645970455884) D204 D233 +error(0.002413814734477126925) D204 D233 ^ D205 D229 +error(0.0009759754382860813841) D204 D233 ^ D205 L0 +error(0.001484037307585785734) D204 D233 ^ D229 L0 +error(0.006310960120927104275) D204 ^ D205 L0 +error(0.005322407363730898185) D205 D229 ^ D204 +error(0.006735703095373630871) D205 D206 +error(0.0008816988361899102695) D205 D206 ^ D204 +error(0.0001283013300070091228) D205 D206 ^ D208 D209 +error(0.0002940482682934252782) D205 D206 ^ D208 D233 +error(0.0147823200156403517) D205 D206 ^ D209 +error(0.003440266269014606582) D205 D206 ^ D209 D233 +error(0.002728099968767540903) D205 D206 ^ D233 +error(0.0003101067761686230142) D205 D206 ^ D233 ^ D204 +error(0.02055897619164840859) D205 D211 +error(0.01315370144244269388) D205 D211 ^ D208 D209 +error(0.04054698510964466207) D205 D229 +error(0.003068906748310869584) D205 D229 ^ D232 D233 +error(0.004135165380719954369) D205 D229 ^ D233 +error(0.00170148481970367675) D205 D234 +error(0.002569670009209375477) D205 D234 ^ D208 D232 +error(0.0003645001291986636185) D205 D234 ^ D208 D233 +error(0.0006562264584675363841) D205 D234 ^ D232 D233 +error(0.00358204353642006942) D205 D235 +error(0.001864374047664434922) D205 D235 ^ D208 D209 +error(0.0003932828383309873183) D205 D235 ^ D208 D232 +error(0.001848434604000002719) D205 D235 ^ D208 D233 +error(0.0001774661344280517637) D205 D235 ^ D209 D233 +error(0.002210991227743962402) D205 D235 ^ D232 D233 +error(0.01000000000000000021) D205 L0 +error(0.01675927044650943679) D206 D212 +error(0.01483521393192921423) D206 D212 ^ D209 +error(0.004719946072497860183) D206 D229 +error(0.0007165835560042144777) D206 D229 ^ D204 +error(0.004779816248476202387) D206 D229 ^ D233 +error(0.0005462343302855433153) D206 D229 ^ D233 ^ D204 +error(0.04658633835913435217) D206 D230 +error(0.009873875383543916084) D206 D230 ^ D233 +error(0.002326384940569728357) D206 D235 +error(0.0005686665129455996306) D206 D235 ^ D208 D209 +error(0.0002337464378640189766) D206 D235 ^ D208 D233 +error(0.000491201243452230301) D206 D235 ^ D209 +error(0.001361197307204584225) D206 D235 ^ D209 D233 +error(0.0005238546515356713642) D206 D235 ^ D233 +error(0.003606535288512647489) D206 D236 +error(0.002939925401372571381) D206 D236 ^ D209 +error(0.002886682013661131477) D206 D236 ^ D233 +error(0.001451469642847544881) D206 D236 ^ D233 ^ D209 +error(0.009299079482444108993) D207 D208 +error(0.0001618067361763870105) D207 D208 ^ D205 L0 +error(0.0004009870402910406875) D207 D208 ^ D210 D211 +error(0.002038993562470617187) D207 D208 ^ D210 D234 +error(0.009839797261860206215) D207 D208 ^ D210 L0 +error(1.613708403102963708e-05) D207 D208 ^ D211 D234 +error(0.001420262771992301942) D207 D208 ^ D234 L0 +error(0.0007398317957289404605) D207 D208 ^ D234 L0 ^ D205 L0 +error(0.01276385364945899735) D207 D214 +error(0.011096381866881758) D207 D214 ^ D210 L0 +error(0.02360888144805250999) D207 D231 +error(0.003659423329073996974) D207 D231 ^ D234 L0 +error(0.002152186614080534195) D207 D232 +error(0.000456204478737577343) D207 D232 ^ D205 L0 +error(0.002391715036470463789) D207 D232 ^ D234 L0 +error(0.0001736009261800634882) D207 D232 ^ D234 L0 ^ D205 L0 +error(0.002929594954205079742) D207 D238 +error(0.003607534314359686634) D207 D238 ^ D210 L0 +error(0.002145454612411112471) D207 D238 ^ D234 L0 +error(0.0006842560657499791943) D207 D238 ^ D234 L0 ^ D210 L0 +error(0.002734468661554086567) D207 D239 +error(0.0003213799321281471302) D207 D239 ^ D210 D211 +error(0.001292369671938379096) D207 D239 ^ D210 D234 +error(0.0006814453156953355741) D207 D239 ^ D210 L0 +error(0.000171429172347746983) D207 D239 ^ D211 D234 +error(2.241052274140109318e-05) D207 D239 ^ D234 L0 +error(0.008061141833768614012) D208 D209 +error(5.603595358604616684e-05) D208 D209 ^ D181 L0 +error(0.0003240145466437737223) D208 D209 ^ D205 L0 +error(0.0007894832832053461135) D208 D209 ^ D210 D211 +error(0.0009388025834094447519) D208 D209 ^ D211 D212 +error(0.001594794524676789067) D208 D209 ^ D211 D235 +error(0.01499707882523569624) D208 D215 +error(0.009686274303190828272) D208 D215 ^ D210 D211 +error(0.02687355039480195801) D208 D232 +error(0.007485819796524218438) D208 D232 ^ D205 L0 +error(0.003107469568972692602) D208 D232 ^ D234 D235 +error(0.0005680536236455682427) D208 D232 ^ D234 L0 +error(0.003211879643569449851) D208 D233 +error(0.000376529833666304839) D208 D233 ^ D234 D235 +error(0.00120063201568994444) D208 D239 +error(0.002765100742562540039) D208 D239 ^ D210 D211 +error(0.001443006512690684761) D208 D239 ^ D210 D234 +error(0.001963765223827605017) D208 D239 ^ D211 D234 +error(0.001561962824876994256) D208 D239 ^ D211 D235 +error(0.001924240942830092883) D208 D239 ^ D234 D235 +error(0.001978648078269987665) D208 D240 +error(0.0003155662468816377805) D208 D240 ^ D211 D212 +error(0.0002941715103168643678) D208 D240 ^ D211 D234 +error(0.001543894821161831106) D208 D240 ^ D211 D235 +error(0.01000000000000000021) D209 +error(0.01996187733386350568) D209 D216 +error(0.0188611843799036949) D209 D216 ^ D211 D212 +error(0.03083190651367225324) D209 D233 +error(0.002851553572250035279) D209 D233 ^ D235 D236 +error(0.003781520367195873988) D209 D240 +error(0.002268950364954752229) D209 D240 ^ D211 D212 +error(0.001088491258235638843) D209 D240 ^ D211 D235 +error(0.002124756255297351182) D209 D240 ^ D212 D235 +error(0.0005882412221558847064) D209 D240 ^ D212 D236 +error(0.002574093098742098219) D209 D240 ^ D235 D236 +error(0.003029302145153121503) D209 D241 +error(0.001158629973361129974) D209 D241 ^ D212 D236 +error(0.0004212946613479972625) D209 D241 ^ D235 D236 +error(0.00708325686996343247) D210 D211 +error(0.001146243462908609796) D210 D211 ^ D214 D215 +error(0.000456805822531424063) D210 D211 ^ D214 D239 +error(0.000304813137048891682) D210 D211 ^ D215 D216 +error(0.002634276171414426122) D210 D211 ^ D215 D239 +error(0.01612767423445998077) D210 D219 +error(0.01171697673212769748) D210 D219 ^ D214 D215 +error(0.03918384738513067123) D210 D234 +error(0.002228925530581629937) D210 D234 ^ D238 D239 +error(0.001722182253290977872) D210 D242 +error(0.00257234959439087401) D210 D242 ^ D214 D238 +error(0.0006935910585423644449) D210 D242 ^ D214 D239 +error(0.0005515214868894067427) D210 D242 ^ D238 D239 +error(0.003685515877434647394) D210 D243 +error(0.002490979275654284057) D210 D243 ^ D214 D215 +error(0.00230918351195979598) D210 D243 ^ D214 D238 +error(0.001594143301527340979) D210 D243 ^ D214 D239 +error(0.0006317460369945696042) D210 D243 ^ D215 D239 +error(0.001985781331922381338) D210 D243 ^ D238 D239 +error(0.01000000000000000021) D210 L0 +error(0.002783689788661022121) D214 D238 ^ D210 L0 +error(0.00974687687898492458) D211 D212 +error(0.0003747287983380178798) D211 D212 ^ D215 D216 +error(0.0004743688286892290226) D211 D212 ^ D215 D240 +error(5.278044991932393068e-05) D211 D212 ^ D216 D217 +error(0.001157504928862029348) D211 D212 ^ D216 D240 +error(0.01675403094458132944) D211 D220 +error(0.01519293603187372999) D211 D220 ^ D215 D216 +error(0.003434296201232148876) D211 D234 +error(0.000572720380022092657) D211 D234 ^ D239 D240 +error(0.03896029464506293311) D211 D235 +error(0.001919558353366188335) D211 D235 ^ D239 D240 +error(0.000483343676407702429) D211 D243 +error(0.0002960171048330712418) D211 D243 ^ D214 D215 +error(0.002043284550463939) D211 D243 ^ D215 D239 +error(0.0008359769467140544747) D211 D243 ^ D215 D240 +error(0.000307975956330275866) D211 D243 ^ D239 D240 +error(0.001859072576991834544) D211 D244 +error(0.002165391394046252676) D211 D244 ^ D215 D216 +error(0.0009431680077149669911) D211 D244 ^ D215 D239 +error(0.001598928756437687122) D211 D244 ^ D215 D240 +error(0.001076978172298284934) D211 D244 ^ D216 D240 +error(0.002627582281132581458) D211 D244 ^ D239 D240 +error(0.01064372101846713069) D212 D213 +error(0.0009906389095932167845) D212 D213 ^ D209 +error(0.0006750162503938480878) D212 D213 ^ D216 D217 +error(3.756848122638768088e-05) D212 D213 ^ D216 D241 +error(0.01267267767955587709) D212 D213 ^ D217 +error(0.004635934828459368356) D212 D213 ^ D217 D241 +error(0.002185403898100024295) D212 D213 ^ D241 +error(0.01336909531579565276) D212 D221 +error(0.01105500658491261057) D212 D221 ^ D216 D217 +error(0.005797025101372838864) D212 D235 +error(0.0003417045946126709161) D212 D235 ^ D240 D241 +error(0.0244028701613570112) D212 D236 +error(0.005035374525287034803) D212 D236 ^ D209 +error(0.001425061471213253782) D212 D236 ^ D240 D241 +error(0.001025440560362546371) D212 D236 ^ D241 +error(0.001739025683189662557) D212 D244 +error(0.0005163048540822849121) D212 D244 ^ D215 D216 +error(0.0003872660728112318042) D212 D244 ^ D215 D240 +error(0.001010208392926537947) D212 D244 ^ D216 D240 +error(0.0003614633525562173117) D212 D244 ^ D216 D241 +error(0.0007708242313029848268) D212 D244 ^ D240 D241 +error(0.002829373934999426885) D212 D245 +error(0.001161648608437570009) D212 D245 ^ D216 D217 +error(0.0004817648811728498333) D212 D245 ^ D216 D240 +error(0.002369403621825834708) D212 D245 ^ D216 D241 +error(0.0004523255119455854285) D212 D245 ^ D217 D241 +error(0.00243362505591642516) D212 D245 ^ D240 D241 +error(0.00845022675102432598) D213 +error(0.003122593618286308333) D213 D236 +error(0.0003444676573668129416) D213 D236 ^ D209 +error(0.003029471903265145566) D213 D236 ^ D241 +error(0.02878109383905069762) D213 D237 +error(0.005245455859824325884) D213 D237 ^ D241 +error(0.002444244415730570993) D213 D245 +error(1.320503562624765046e-05) D213 D245 ^ D216 D217 +error(0.000319071422289989796) D213 D245 ^ D216 D241 +error(0.002504366306824067946) D213 D245 ^ D217 D241 +error(0.01376696901986126757) D213 ^ D217 +error(0.0004076332642725224499) D213 ^ D241 +error(0.001893217879630942077) D213 ^ D241 ^ D217 +error(0.01079365791184803448) D214 +error(0.01463814118025971722) D214 D215 +error(0.0003749792498749710858) D214 D215 ^ D186 L0 +error(0.0005400820725793096383) D214 D215 ^ D218 D219 +error(0.000418692903235950032) D214 D215 ^ D219 D220 +error(0.001712985178897279354) D214 D215 ^ D219 D243 +error(4.669523646288583138e-05) D214 D215 ^ D220 D243 +error(0.04918066768488339735) D214 D238 +error(0.00367209971397850464) D214 D238 ^ D242 D243 +error(0.001587061349442817852) D214 D239 +error(0.0006664841908282826029) D214 D239 ^ D242 D243 +error(0.0004431564671695123817) D214 D246 +error(9.765646950254146724e-06) D214 D246 ^ D219 D220 +error(0.0006406541570109316498) D214 D246 ^ D219 D243 +error(5.274589083871283256e-05) D214 D246 ^ D220 D243 +error(0.0117889524045072993) D214 ^ D218 L0 +error(0.004137845564894525492) D218 D242 ^ D214 +error(0.02263828873602833844) D215 D216 +error(0.0001702276148531519891) D215 D216 ^ D219 D220 +error(0.0008834832228674967128) D215 D216 ^ D220 D221 +error(0.002753689268113585723) D215 D216 ^ D220 D244 +error(0.0005499538130014023632) D215 D216 ^ D221 D244 +error(0.01909106726931757148) D215 D222 +error(0.02001517208706354509) D215 D222 ^ D219 D220 +error(0.02812184381392778681) D215 D239 +error(0.002607359131359769482) D215 D239 ^ D243 D244 +error(0.003969053395153494292) D215 D240 +error(4.689775471165016457e-05) D215 D240 ^ D243 D244 +error(0.008075155730227432868) D215 D246 +error(0.005353779632917887721) D215 D246 ^ D219 D220 +error(0.0008750595983553233767) D215 D246 ^ D219 D243 +error(0.007885636642307748342) D215 D246 ^ D220 D243 +error(0.001752721336947414684) D215 D246 ^ D220 D244 +error(0.00216109320394393227) D215 D246 ^ D243 D244 +error(0.002431970761268770556) D215 D247 +error(0.0006784536717705084465) D215 D247 ^ D220 D221 +error(4.63592763270954906e-05) D215 D247 ^ D220 D243 +error(0.001397725395569435333) D215 D247 ^ D220 D244 +error(0.0004419636415501518398) D215 D247 ^ D221 D244 +error(0.0003189261836387721327) D215 D247 ^ D243 D244 +error(0.008150338982270402197) D216 D217 +error(0.0006312850411417316072) D216 D217 ^ D220 D221 +error(8.050646160119902803e-05) D216 D217 ^ D221 +error(0.001278512356325647685) D216 D217 ^ D221 D245 +error(0.0007020451534826920416) D216 D217 ^ D245 +error(0.01277332616325764329) D216 D223 +error(0.01048264638225490653) D216 D223 ^ D220 D221 +error(0.02278187818030543224) D216 D240 +error(0.002407124538276740958) D216 D240 ^ D244 D245 +error(0.003075712190512780442) D216 D241 +error(0.0005860246305094125689) D216 D241 ^ D244 D245 +error(0.002095085221072178795) D216 D247 +error(0.002204476815442909295) D216 D247 ^ D220 D221 +error(0.001398016024156229289) D216 D247 ^ D220 D244 +error(0.001998355767841102602) D216 D247 ^ D221 D244 +error(0.001286846742682906837) D216 D247 ^ D221 D245 +error(0.001863213582515296481) D216 D247 ^ D244 D245 +error(0.001997153633049718324) D216 D248 +error(2.598292875153643494e-05) D216 D248 ^ D221 D244 +error(0.001173331601012149233) D216 D248 ^ D221 D245 +error(0.0002874234325142206487) D216 D248 ^ D244 D245 +error(1.821438837082284888e-05) D216 D248 ^ D245 +error(0.01006454994273055757) D217 +error(0.0161206695668114873) D217 D224 +error(0.01737570254568924361) D217 D224 ^ D221 +error(0.0250505139273094167) D217 D241 +error(0.002345018263775333536) D217 D241 ^ D245 +error(0.003073065190622500248) D217 D248 +error(0.002579449672997942682) D217 D248 ^ D221 +error(0.003836377064377697373) D217 D248 ^ D245 +error(0.0006646277758526700783) D217 D248 ^ D245 ^ D221 +error(0.01577597104453927479) D218 D219 +error(0.003795651666848288541) D218 D219 ^ D190 +error(0.01692448812617893331) D218 D219 ^ D214 +error(0.0008288896859749987807) D218 D219 ^ D222 ^ D190 +error(0.0191985177099640858) D218 D242 +error(0.01034173018792707011) D218 L0 +error(0.0004662125493391324252) D218 L0 ^ D186 L0 ^ D214 +error(0.0007989884919774482971) D218 L0 ^ D214 ^ D190 +error(0.01669196318468137152) D219 D220 +error(0.0002275964588231474655) D219 D220 ^ D222 +error(0.001080582133475241997) D219 D220 ^ D222 D223 +error(0.003377679907839793976) D219 D220 ^ D222 D246 +error(0.0004409901630161987838) D219 D220 ^ D246 +error(0.01456851983540525391) D219 D225 +error(0.01235616231143815344) D219 D225 ^ D222 +error(0.00378888098077427701) D219 D242 +error(0.002826407968055778298) D219 D242 ^ D214 +error(0.0001197399291263810575) D219 D242 ^ D246 +error(0.0003950766148601412729) D219 D242 ^ D246 ^ D214 +error(0.02650863068338265086) D219 D243 +error(0.002052387878255866605) D219 D243 ^ D214 +error(0.005693851689366329419) D219 D243 ^ D246 +error(0.00279004820284349574) D219 D249 +error(0.001376537795732491343) D219 D249 ^ D222 +error(0.002887687896721477781) D219 D249 ^ D246 +error(0.001094217013606597596) D219 D249 ^ D246 ^ D222 +error(0.007394753493446600857) D220 D221 +error(0.0005665103155747660754) D220 D221 ^ D222 D223 +error(0.0002961719484165020928) D220 D221 ^ D222 D247 +error(0.0007675096502073114812) D220 D221 ^ D223 D224 +error(0.002862427649248453464) D220 D221 ^ D223 D247 +error(0.01375412502619386378) D220 D226 +error(0.01096105179196072039) D220 D226 ^ D222 D223 +error(0.008487365324421063117) D220 D243 +error(0.02457592249931421502) D220 D244 +error(0.002631812399044814853) D220 D244 ^ D246 D247 +error(0.002198804135129999587) D220 D249 +error(0.001654137015294186892) D220 D249 ^ D222 D246 +error(6.003632573794476984e-06) D220 D249 ^ D222 D247 +error(0.0004409060199606022593) D220 D249 ^ D246 +error(0.002192299185518550592) D220 D250 +error(0.001746414734417907517) D220 D250 ^ D222 D223 +error(0.0003598999091759262268) D220 D250 ^ D222 D246 +error(0.001561544017991810512) D220 D250 ^ D222 D247 +error(0.000466227982502727986) D220 D250 ^ D223 D247 +error(0.001724344060558972601) D220 D250 ^ D246 D247 +error(0.01203579788742147917) D221 +error(0.004387356071761702725) D221 D244 +error(0.000208029715498591483) D221 D244 ^ D247 D248 +error(0.02221100964778081194) D221 D245 +error(0.001439615781168439605) D221 D245 ^ D247 D248 +error(0.001201823867210177017) D221 D250 +error(0.0001012650403590720146) D221 D250 ^ D222 D223 +error(0.0003034946049630618146) D221 D250 ^ D222 D247 +error(0.001323584720901610371) D221 D250 ^ D223 D247 +error(0.0007926983696969233488) D221 ^ D189 ^ D193 +error(0.0005235978985522322894) D221 ^ D189 ^ D217 +error(0.001537789608391964321) D221 ^ D193 +error(0.01000000000000000021) D222 +error(0.007026141351062988212) D222 D223 +error(0.0009672799566260600846) D222 D223 ^ D225 D226 +error(0.002612338632211596515) D222 D223 ^ D226 D250 +error(0.0008620297320340863934) D222 D223 ^ D250 +error(0.03555466847524565294) D222 D246 +error(0.004257613433980646928) D222 D246 ^ D249 D250 +error(0.003914888887922909726) D222 D247 +error(0.0008393621947703528048) D222 D247 ^ D249 D250 +error(0.0006392754687906603917) D222 D251 +error(0.0002831750050793343447) D222 D251 ^ D226 +error(0.001693673795440791933) D222 D251 ^ D226 D250 +error(7.480679588459883279e-06) D222 D251 ^ D250 +error(0.01861532100512389154) D223 D224 +error(0.00222125091587972506) D223 D224 ^ D197 +error(0.01207571090899253741) D223 D224 ^ D221 +error(0.0002065846548685445908) D223 D224 ^ D226 +error(0.0003301188119060698405) D223 D224 ^ D226 ^ D197 +error(0.01744050413829207127) D223 D227 +error(0.01542382289075709852) D223 D227 ^ D226 +error(0.02667661522528785162) D223 D247 +error(0.001456372037112019452) D223 D247 ^ D221 +error(0.00368662532011345247) D223 D247 ^ D250 +error(0.002088453177880326885) D223 D248 +error(0.002632780704037000936) D223 D248 ^ D221 +error(0.0002114179196296893338) D223 D248 ^ D250 ^ D221 +error(0.004110481756233741457) D223 D251 +error(0.002802723964281605973) D223 D251 ^ D226 +error(0.003798397130707047414) D223 D251 ^ D250 +error(0.001977355296201686527) D223 D251 ^ D250 ^ D226 +error(0.02679340452938059822) D224 D248 +error(0.002535959682426708415) D224 D248 ^ D221 +error(0.006074521331256080119) D225 D226 +error(0.001500890887174470556) D225 D226 ^ D198 +error(0.01131498296823086475) D225 D226 ^ D222 +error(0.0004481007348183289017) D225 D226 ^ D227 +error(0.0004597114541739146941) D225 D226 ^ D227 ^ D198 +error(0.02900709638648528779) D225 D249 +error(0.003760545837299076113) D225 D249 ^ D222 +error(0.01000000000000000021) D226 +error(0.001742126190683423136) D226 D249 +error(0.002377235945765063599) D226 D249 ^ D222 +error(0.000899953914339936766) D226 D249 ^ D251 +error(0.0004872680715309037156) D226 D249 ^ D251 ^ D222 +error(0.02110557026819835647) D226 D250 +error(0.0003712607219078131976) D226 D250 ^ D222 +error(0.00170219714362124892) D226 D250 ^ D251 +error(0.009114652556981153037) D226 ^ D227 +error(0.001301279920715417773) D226 ^ D251 +error(0.003066610980423866654) D227 D251 ^ D226 +error(0.009282272384986160405) D227 +error(0.01920747822175144712) D227 D251 +error(0.03755139358345729872) D228 +error(0.01597172571916880696) D228 D232 +error(0.02387641033151550671) D228 D232 ^ D229 L0 +error(0.01153329886758091248) D228 ^ D229 L0 +error(0.01587365620540241024) D228 ^ D252 L0 +error(0.01602279682920603604) D229 D252 ^ D228 +error(0.01589829655544200415) D229 D230 +error(0.001213890217764157856) D229 D230 ^ D228 +error(0.0004029046028963090926) D229 D230 ^ D232 +error(0.01929656087899995348) D229 D230 ^ D233 +error(0.002794149899532490707) D229 D230 ^ D233 ^ D232 +error(0.02163547895039730565) D229 D235 +error(0.01515755938704413733) D229 D235 ^ D232 D233 +error(0.06023017736576494197) D229 D252 +error(0.002219400952996397787) D229 D253 +error(0.002380723312342853358) D229 D253 ^ D232 +error(0.0001140686839886168773) D229 D256 +error(0.003287488783004199975) D229 D256 ^ D232 +error(0.001244211382732216204) D229 D256 ^ D232 D233 +error(0.002503297381983508006) D229 D256 ^ D233 +error(0.01000000000000000021) D229 L0 +error(0.001838078354083519383) D229 L0 ^ D231 +error(0.0144097219996470842) D230 D236 +error(0.02024359177802033741) D230 D236 ^ D233 +error(0.02179993930028416987) D230 D252 +error(0.0005730677227658134741) D230 D252 ^ D228 +error(0.05133966729212513513) D230 D255 +error(0.0008418798786024116578) D230 D256 +error(0.001879872622725853619) D230 D256 ^ D233 +error(0.0009594928890744602607) D230 D256 ^ D233 ^ D232 +error(0.007116761884660421401) D230 D258 +error(0.008169075516332949954) D230 D258 ^ D233 +error(0.02216033716610662715) D231 +error(0.006635723691235503353) D231 D232 +error(0.002099778739727565721) D231 D232 ^ D234 D253 +error(0.01057568883520279383) D231 D232 ^ D234 L0 +error(0.01203948195465516686) D231 D238 +error(0.01111140377713464543) D231 D238 ^ D234 L0 +error(0.005000000000000000104) D231 ^ D234 L0 +error(0.008815461879105427473) D231 ^ D253 L0 +error(0.006409698015683033129) D234 D253 ^ D231 +error(0.01102626686209343121) D232 +error(0.007158155670729733286) D232 D233 +error(5.603595358604616684e-05) D232 D233 ^ D205 L0 +error(0.0008363182295883689983) D232 D233 ^ D234 D235 +error(0.0001814553259816101846) D232 D233 ^ D235 D256 +error(0.01674108272443954742) D232 D239 +error(0.008273194194718364036) D232 D239 ^ D234 D235 +error(0.001218544227941150554) D232 ^ D229 L0 +error(0.0007525207585164617836) D232 ^ D229 L0 ^ D231 +error(0.001366921074951626177) D232 ^ D253 L0 ^ D229 L0 ^ D231 +error(0.02728081465353987198) D233 +error(0.01925493708476772731) D233 D240 +error(0.01704933443520469105) D233 D240 ^ D235 D236 +error(0.0160900782600180807) D234 D235 +error(0.003279318030005532597) D234 D235 ^ D231 +error(0.002300225988895076863) D234 D235 ^ D232 +error(0.0007754253857613696219) D234 D235 ^ D238 +error(0.001608754916375342795) D234 D235 ^ D239 +error(0.0004512792990423430397) D234 D235 ^ D239 D240 +error(3.58313187550685536e-05) D234 D235 ^ D239 ^ D238 +error(0.01134628775627345883) D234 D243 +error(0.01195837419965869834) D234 D243 ^ D238 D239 +error(0.0326092931628014851) D234 D253 +error(0.004476267853307819289) D234 D253 ^ D232 +error(0.002087852176964046565) D234 D254 +error(0.003018824629924558509) D234 D254 ^ D238 +error(0.005316285605635874371) D234 D257 +error(0.003994770681215869222) D234 D257 ^ D238 +error(0.001282172186550792218) D234 D257 ^ D238 D239 +error(0.01000000000000000021) D234 L0 +error(0.01294861856292981762) D235 D236 +error(0.001981583296819180648) D235 D236 ^ D232 +error(0.003938860131425222025) D235 D236 ^ D233 +error(0.0009931331683427091234) D235 D236 ^ D240 D241 +error(0.002352593854940381556) D235 D236 ^ D240 ^ D239 +error(0.01717761561104249116) D235 D244 +error(0.01734983239373906472) D235 D244 ^ D239 D240 +error(0.003757044809881520536) D235 D253 +error(0.001179957412417967757) D235 D253 ^ D231 ^ D232 +error(0.002596655559219504267) D235 D253 ^ D232 +error(0.04336866758760712925) D235 D256 +error(0.002830528014334379294) D235 D256 ^ D232 +error(0.001103062728236350702) D235 D256 ^ D233 +error(0.0007994344624645944144) D235 D257 +error(0.001562077824325485732) D235 D257 ^ D238 +error(0.001711178079345862177) D235 D257 ^ D239 +error(0.0067747884970823357) D235 D259 +error(0.003147883366803665324) D235 D259 ^ D239 D240 +error(0.0002395476436968695989) D235 D259 ^ D240 +error(0.01085086238843023174) D236 D237 +error(0.0004673522699651438072) D236 D237 ^ D233 +error(0.002817255080911731154) D236 D237 ^ D240 +error(0.01705843105857223277) D236 D237 ^ D241 +error(0.01283708863321436112) D236 D245 +error(0.01080621356060933354) D236 D245 ^ D240 D241 +error(0.005110624602918830556) D236 D256 +error(0.0002526592452936231087) D236 D256 ^ D232 +error(0.0002084986973098341913) D236 D256 ^ D232 ^ D233 +error(0.002455729443811407574) D236 D256 ^ D233 +error(0.02527066512900896442) D236 D258 +error(0.008538410375612780212) D236 D258 ^ D233 +error(0.004595942601833803709) D236 D259 +error(0.001390669732103663476) D236 D259 ^ D240 +error(0.0008044986721194488091) D236 D259 ^ D240 ^ D239 +error(0.002778629364291161814) D236 D262 +error(0.003164777432166651118) D236 D262 ^ D240 +error(0.0005401015992579146375) D236 D262 ^ D240 D241 +error(0.0003987062887779509613) D236 D262 ^ D241 +error(0.01019696275648129292) D237 +error(0.008066779824078868996) D237 D258 +error(0.03299702249821706568) D237 D261 +error(0.003358763502838387534) D237 D262 +error(0.001443573005088161307) D237 D262 ^ D240 +error(0.002744974692788376431) D237 D262 ^ D241 +error(0.01772732597192370682) D237 ^ D241 +error(0.05975964709674118358) D238 +error(0.02189065043479011471) D238 D239 +error(0.0003749792498749710858) D238 D239 ^ D210 L0 +error(0.0009200878430825573141) D238 D239 ^ D243 D257 +error(0.0009855787571051268306) D238 ^ D234 L0 +error(0.01141611366821624306) D238 ^ D242 L0 +error(0.001413362567005038446) D238 ^ D254 L0 +error(0.003353318509581186806) D242 D254 ^ D238 +error(0.01211875107467405566) D239 +error(0.02555245724774379487) D239 D240 +error(0.0007949804403806064743) D239 D240 ^ D243 D244 +error(0.002221657042136971141) D239 D240 ^ D244 D259 +error(0.02316144349938298319) D239 D246 +error(0.01964912269637787354) D239 D246 ^ D243 D244 +error(0.01000000000000000021) D240 +error(0.007905657082071058245) D240 D241 +error(0.001102778217334439079) D240 D241 ^ D244 D245 +error(0.002032346556347154089) D240 D241 ^ D245 D262 +error(0.01517643748648460529) D240 D247 +error(0.01204337237811400549) D240 D247 ^ D244 D245 +error(0.0006271959341236233842) D240 ^ D241 ^ D262 +error(6.484800056249299092e-05) D240 ^ D262 +error(0.003606879512935114423) D245 D262 ^ D240 +error(0.03442850371684454819) D241 +error(0.01480976365997342149) D241 D248 +error(0.01574312198069232824) D241 D248 ^ D245 +error(0.001074199846915208827) D241 ^ D245 +error(0.006908571445943566432) D241 ^ D262 +error(0.001111809978343300748) D241 ^ D262 ^ D245 +error(0.01324250222063307406) D242 D243 +error(0.003795651666848288541) D242 D243 ^ D214 +error(0.01992340574141917078) D242 D243 ^ D238 +error(0.0008288896859749987807) D242 D243 ^ D246 ^ D214 +error(0.01784203386196980476) D242 D254 +error(0.01230203513557909072) D242 L0 +error(0.0004662125493391324252) D242 L0 ^ D210 L0 ^ D238 +error(0.0007989884919774482971) D242 L0 ^ D238 ^ D214 +error(0.02008586389356241397) D243 D244 +error(0.0002507329393703490688) D243 D244 ^ D238 +error(0.0005689111394992084781) D243 D244 ^ D238 ^ D239 +error(0.003644840215819198335) D243 D244 ^ D239 +error(0.005858235033740688893) D243 D244 ^ D246 +error(0.01268274910404439126) D243 D249 +error(0.01220049340034390015) D243 D249 ^ D246 +error(0.003823596269684820768) D243 D254 +error(0.003636169442420562718) D243 D254 ^ D238 +error(0.02956086956392405332) D243 D257 +error(0.00450228661656621159) D243 D257 ^ D238 +error(0.003257872532110966165) D243 D257 ^ D239 +error(0.002889458525459951722) D243 D260 +error(0.003147085302306836668) D243 D260 ^ D246 +error(0.01045740230556547502) D244 D245 +error(0.0006930381519566785643) D244 D245 ^ D239 +error(0.0010772537640421308) D244 D245 ^ D239 ^ D240 +error(0.0002513387909682272066) D244 D245 ^ D240 +error(0.001922085551726831782) D244 D245 ^ D246 +error(0.002054398344656037899) D244 D245 ^ D247 +error(0.0007936526247069361885) D244 D245 ^ D247 ^ D246 +error(0.0169734064446148171) D244 D250 +error(0.00987326814423324095) D244 D250 ^ D246 D247 +error(0.008436817061813792901) D244 D257 +error(0.0001892067424010697148) D244 D257 ^ D238 ^ D239 +error(0.008642709644021086615) D244 D257 ^ D239 +error(0.03137523067653334025) D244 D259 +error(0.002211822204286144431) D244 D259 ^ D239 +error(0.003912156998269319605) D244 D259 ^ D240 +error(0.002572412573074295099) D244 D260 +error(0.002921807206247442525) D244 D260 ^ D246 +error(0.001704899158043498815) D244 D263 ^ D246 +error(0.002173072371452006591) D244 D263 ^ D247 +error(0.01772220611332848972) D245 +error(0.002717266573196403402) D245 D259 +error(0.0007065365181676914932) D245 D259 ^ D239 +error(0.001416223305359502532) D245 D259 ^ D239 ^ D240 +error(0.003680128644617267075) D245 D259 ^ D240 +error(0.02202157673421107839) D245 D262 +error(0.003075967757197332376) D245 D263 ^ D246 +error(0.001689299456837233633) D245 D263 ^ D247 +error(0.0007926983696969233488) D245 ^ D213 ^ D217 +error(0.0005235978985522322894) D245 ^ D213 ^ D241 +error(0.001537789608391964321) D245 ^ D217 +error(0.004593008038657366357) D245 ^ D247 +error(0.03939128848630309848) D246 +error(0.01012714879595145133) D246 D247 +error(0.0003466292219694774575) D246 D247 ^ D249 D250 +error(0.001885163523605898469) D246 D247 ^ D250 D263 +error(0.0007630752347602874847) D246 ^ D247 ^ D250 +error(0.003200186251141323279) D246 ^ D247 ^ D263 +error(0.001503177311018191091) D246 ^ D250 +error(0.003320259826514232373) D250 D263 ^ D246 +error(0.01000000000000000021) D247 +error(0.02300364511728765493) D247 D248 +error(0.00222125091587972506) D247 D248 ^ D221 +error(0.0129837571947344823) D247 D248 ^ D245 +error(0.0003301188119060698405) D247 D248 ^ D250 ^ D221 +error(0.01779611261000263109) D247 D251 +error(0.0160616088723421549) D247 D251 ^ D250 +error(0.003115081542869148953) D247 ^ D250 +error(0.006685442608533484661) D247 ^ D263 +error(0.003094365082779486353) D247 ^ D263 ^ D250 +error(0.02458556471219261463) D248 +error(0.005000000000000000104) D248 ^ D245 +error(0.007295644578315814074) D249 D250 +error(0.001500890887174470556) D249 D250 ^ D222 +error(0.01094026148223470503) D249 D250 ^ D246 +error(8.844373265458972721e-05) D249 D250 ^ D251 +error(0.0004597114541739146941) D249 D250 ^ D251 ^ D222 +error(0.02927267764251219664) D249 D260 +error(0.007125669557571582928) D249 D260 ^ D246 +error(0.01000000000000000021) D250 +error(0.004539074242331001333) D250 D260 +error(0.003745651894184726712) D250 D260 ^ D246 +error(0.02544951517682179226) D250 D263 +error(0.01673852771922241384) D250 ^ D251 +error(0.03428638153140996236) D251 +error(0.01632902715500200719) D252 D255 +error(0.01487490015917009023) D252 D256 +error(0.04447423246045617562) D252 L0 +error(0.01424856238663424132) D253 D256 +error(0.006865350748933714622) D253 D256 ^ D232 +error(0.01407958483346105627) D253 D257 +error(0.02370412165204537763) D253 L0 +error(0.01712580105280680012) D254 D257 +error(0.007797575674154077346) D254 D257 ^ D238 +error(0.02389222801066624019) D254 L0 +error(0.01214603954463167046) D255 D258 +error(0.02008408819753969982) D256 D258 +error(0.006195724561523177458) D256 D258 ^ D233 +error(0.02149517636511460994) D256 D259 +error(0.01977946651515783208) D257 D259 +error(0.007699771923715943364) D257 D259 ^ D239 +error(0.01519401653659996354) D257 D260 +error(0.02145728493512993884) D258 D261 +error(0.01799033629545510049) D258 D262 +error(0.01357969817787661737) D259 D262 +error(0.003908857413044849148) D259 D262 ^ D240 +error(0.01459287777423012855) D259 D263 +error(0.01994966362530953968) D260 D263 +error(0.006177374748096364603) D260 D263 ^ D246 +error(0.01226250982574739537) D261 +error(0.02900701722989786416) D262 +error(0.04290728254813050424) D263 +detector(2, 5, 0) D0 +detector(4, 3, 0) D1 +detector(6, 1, 0) D2 +detector(2, 7, 0) D3 +detector(4, 5, 0) D4 +detector(6, 3, 0) D5 +detector(4, 7, 0) D6 +detector(6, 5, 0) D7 +detector(8, 3, 0) D8 +detector(4, 9, 0) D9 +detector(6, 7, 0) D10 +detector(8, 5, 0) D11 +detector(1, 4, 1) D12 +detector(2, 5, 1) D13 +detector(2, 7, 1) D14 +detector(3, 2, 1) D15 +detector(3, 4, 1) D16 +detector(3, 6, 1) D17 +detector(4, 3, 1) D18 +detector(4, 5, 1) D19 +detector(4, 7, 1) D20 +detector(4, 9, 1) D21 +detector(5, 2, 1) D22 +detector(5, 4, 1) D23 +detector(5, 6, 1) D24 +detector(5, 8, 1) D25 +detector(6, 1, 1) D26 +detector(6, 3, 1) D27 +detector(6, 5, 1) D28 +detector(6, 7, 1) D29 +detector(7, 4, 1) D30 +detector(7, 6, 1) D31 +detector(7, 8, 1) D32 +detector(8, 3, 1) D33 +detector(8, 5, 1) D34 +detector(9, 6, 1) D35 +detector(1, 4, 2) D36 +detector(2, 5, 2) D37 +detector(2, 7, 2) D38 +detector(3, 2, 2) D39 +detector(3, 4, 2) D40 +detector(3, 6, 2) D41 +detector(4, 3, 2) D42 +detector(4, 5, 2) D43 +detector(4, 7, 2) D44 +detector(4, 9, 2) D45 +detector(5, 2, 2) D46 +detector(5, 4, 2) D47 +detector(5, 6, 2) D48 +detector(5, 8, 2) D49 +detector(6, 1, 2) D50 +detector(6, 3, 2) D51 +detector(6, 5, 2) D52 +detector(6, 7, 2) D53 +detector(7, 4, 2) D54 +detector(7, 6, 2) D55 +detector(7, 8, 2) D56 +detector(8, 3, 2) D57 +detector(8, 5, 2) D58 +detector(9, 6, 2) D59 +detector(1, 4, 3) D60 +detector(2, 5, 3) D61 +detector(2, 7, 3) D62 +detector(3, 2, 3) D63 +detector(3, 4, 3) D64 +detector(3, 6, 3) D65 +detector(4, 3, 3) D66 +detector(4, 5, 3) D67 +detector(4, 7, 3) D68 +detector(4, 9, 3) D69 +detector(5, 2, 3) D70 +detector(5, 4, 3) D71 +detector(5, 6, 3) D72 +detector(5, 8, 3) D73 +detector(6, 1, 3) D74 +detector(6, 3, 3) D75 +detector(6, 5, 3) D76 +detector(6, 7, 3) D77 +detector(7, 4, 3) D78 +detector(7, 6, 3) D79 +detector(7, 8, 3) D80 +detector(8, 3, 3) D81 +detector(8, 5, 3) D82 +detector(9, 6, 3) D83 +detector(1, 4, 4) D84 +detector(2, 5, 4) D85 +detector(2, 7, 4) D86 +detector(3, 2, 4) D87 +detector(3, 4, 4) D88 +detector(3, 6, 4) D89 +detector(4, 3, 4) D90 +detector(4, 5, 4) D91 +detector(4, 7, 4) D92 +detector(4, 9, 4) D93 +detector(5, 2, 4) D94 +detector(5, 4, 4) D95 +detector(5, 6, 4) D96 +detector(5, 8, 4) D97 +detector(6, 1, 4) D98 +detector(6, 3, 4) D99 +detector(6, 5, 4) D100 +detector(6, 7, 4) D101 +detector(7, 4, 4) D102 +detector(7, 6, 4) D103 +detector(7, 8, 4) D104 +detector(8, 3, 4) D105 +detector(8, 5, 4) D106 +detector(9, 6, 4) D107 +detector(1, 4, 5) D108 +detector(2, 5, 5) D109 +detector(2, 7, 5) D110 +detector(3, 2, 5) D111 +detector(3, 4, 5) D112 +detector(3, 6, 5) D113 +detector(4, 3, 5) D114 +detector(4, 5, 5) D115 +detector(4, 7, 5) D116 +detector(4, 9, 5) D117 +detector(5, 2, 5) D118 +detector(5, 4, 5) D119 +detector(5, 6, 5) D120 +detector(5, 8, 5) D121 +detector(6, 1, 5) D122 +detector(6, 3, 5) D123 +detector(6, 5, 5) D124 +detector(6, 7, 5) D125 +detector(7, 4, 5) D126 +detector(7, 6, 5) D127 +detector(7, 8, 5) D128 +detector(8, 3, 5) D129 +detector(8, 5, 5) D130 +detector(9, 6, 5) D131 +detector(1, 4, 6) D132 +detector(2, 5, 6) D133 +detector(2, 7, 6) D134 +detector(3, 2, 6) D135 +detector(3, 4, 6) D136 +detector(3, 6, 6) D137 +detector(4, 3, 6) D138 +detector(4, 5, 6) D139 +detector(4, 7, 6) D140 +detector(4, 9, 6) D141 +detector(5, 2, 6) D142 +detector(5, 4, 6) D143 +detector(5, 6, 6) D144 +detector(5, 8, 6) D145 +detector(6, 1, 6) D146 +detector(6, 3, 6) D147 +detector(6, 5, 6) D148 +detector(6, 7, 6) D149 +detector(7, 4, 6) D150 +detector(7, 6, 6) D151 +detector(7, 8, 6) D152 +detector(8, 3, 6) D153 +detector(8, 5, 6) D154 +detector(9, 6, 6) D155 +detector(1, 4, 7) D156 +detector(2, 5, 7) D157 +detector(2, 7, 7) D158 +detector(3, 2, 7) D159 +detector(3, 4, 7) D160 +detector(3, 6, 7) D161 +detector(4, 3, 7) D162 +detector(4, 5, 7) D163 +detector(4, 7, 7) D164 +detector(4, 9, 7) D165 +detector(5, 2, 7) D166 +detector(5, 4, 7) D167 +detector(5, 6, 7) D168 +detector(5, 8, 7) D169 +detector(6, 1, 7) D170 +detector(6, 3, 7) D171 +detector(6, 5, 7) D172 +detector(6, 7, 7) D173 +detector(7, 4, 7) D174 +detector(7, 6, 7) D175 +detector(7, 8, 7) D176 +detector(8, 3, 7) D177 +detector(8, 5, 7) D178 +detector(9, 6, 7) D179 +detector(1, 4, 8) D180 +detector(2, 5, 8) D181 +detector(2, 7, 8) D182 +detector(3, 2, 8) D183 +detector(3, 4, 8) D184 +detector(3, 6, 8) D185 +detector(4, 3, 8) D186 +detector(4, 5, 8) D187 +detector(4, 7, 8) D188 +detector(4, 9, 8) D189 +detector(5, 2, 8) D190 +detector(5, 4, 8) D191 +detector(5, 6, 8) D192 +detector(5, 8, 8) D193 +detector(6, 1, 8) D194 +detector(6, 3, 8) D195 +detector(6, 5, 8) D196 +detector(6, 7, 8) D197 +detector(7, 4, 8) D198 +detector(7, 6, 8) D199 +detector(7, 8, 8) D200 +detector(8, 3, 8) D201 +detector(8, 5, 8) D202 +detector(9, 6, 8) D203 +detector(1, 4, 9) D204 +detector(2, 5, 9) D205 +detector(2, 7, 9) D206 +detector(3, 2, 9) D207 +detector(3, 4, 9) D208 +detector(3, 6, 9) D209 +detector(4, 3, 9) D210 +detector(4, 5, 9) D211 +detector(4, 7, 9) D212 +detector(4, 9, 9) D213 +detector(5, 2, 9) D214 +detector(5, 4, 9) D215 +detector(5, 6, 9) D216 +detector(5, 8, 9) D217 +detector(6, 1, 9) D218 +detector(6, 3, 9) D219 +detector(6, 5, 9) D220 +detector(6, 7, 9) D221 +detector(7, 4, 9) D222 +detector(7, 6, 9) D223 +detector(7, 8, 9) D224 +detector(8, 3, 9) D225 +detector(8, 5, 9) D226 +detector(9, 6, 9) D227 +detector(1, 4, 10) D228 +detector(2, 5, 10) D229 +detector(2, 7, 10) D230 +detector(3, 2, 10) D231 +detector(3, 4, 10) D232 +detector(3, 6, 10) D233 +detector(4, 3, 10) D234 +detector(4, 5, 10) D235 +detector(4, 7, 10) D236 +detector(4, 9, 10) D237 +detector(5, 2, 10) D238 +detector(5, 4, 10) D239 +detector(5, 6, 10) D240 +detector(5, 8, 10) D241 +detector(6, 1, 10) D242 +detector(6, 3, 10) D243 +detector(6, 5, 10) D244 +detector(6, 7, 10) D245 +detector(7, 4, 10) D246 +detector(7, 6, 10) D247 +detector(7, 8, 10) D248 +detector(8, 3, 10) D249 +detector(8, 5, 10) D250 +detector(9, 6, 10) D251 +detector(2, 5, 11) D252 +detector(4, 3, 11) D253 +detector(6, 1, 11) D254 +detector(2, 7, 11) D255 +detector(4, 5, 11) D256 +detector(6, 3, 11) D257 +detector(4, 7, 11) D258 +detector(6, 5, 11) D259 +detector(8, 3, 11) D260 +detector(4, 9, 11) D261 +detector(6, 7, 11) D262 +detector(8, 5, 11) D263 diff --git a/shared/package-files/30/30451024cecd038d2bce56535750f93c147f49d21fecaddb553da2c73aa460ac/blob b/shared/package-files/30/30451024cecd038d2bce56535750f93c147f49d21fecaddb553da2c73aa460ac/blob new file mode 100644 index 0000000000000000000000000000000000000000..c917f4be9eb9043aa347828fc4daed766c59911d --- /dev/null +++ b/shared/package-files/30/30451024cecd038d2bce56535750f93c147f49d21fecaddb553da2c73aa460ac/blob @@ -0,0 +1,4863 @@ +""" +This module defines tensors with abstract index notation. + +The abstract index notation has been first formalized by Penrose. + +Tensor indices are formal objects, with a tensor type; there is no +notion of index range, it is only possible to assign the dimension, +used to trace the Kronecker delta; the dimension can be a Symbol. + +The Einstein summation convention is used. +The covariant indices are indicated with a minus sign in front of the index. + +For instance the tensor ``t = p(a)*A(b,c)*q(-c)`` has the index ``c`` +contracted. + +A tensor expression ``t`` can be called; called with its +indices in sorted order it is equal to itself: +in the above example ``t(a, b) == t``; +one can call ``t`` with different indices; ``t(c, d) == p(c)*A(d,a)*q(-a)``. + +The contracted indices are dummy indices, internally they have no name, +the indices being represented by a graph-like structure. + +Tensors are put in canonical form using ``canon_bp``, which uses +the Butler-Portugal algorithm for canonicalization using the monoterm +symmetries of the tensors. + +If there is a (anti)symmetric metric, the indices can be raised and +lowered when the tensor is put in canonical form. +""" + +from __future__ import annotations +from typing import Any +from functools import reduce +from math import prod + +from abc import abstractmethod, ABC +from collections import defaultdict +import operator +import itertools +from sympy.core.numbers import (Integer, Rational) +from sympy.combinatorics import Permutation +from sympy.combinatorics.tensor_can import get_symmetric_group_sgs, \ + bsgs_direct_product, canonicalize, riemann_bsgs +from sympy.core import Basic, Expr, sympify, Add, Mul, S +from sympy.core.containers import Tuple, Dict +from sympy.core.sorting import default_sort_key +from sympy.core.symbol import Symbol, symbols +from sympy.core.sympify import CantSympify, _sympify +from sympy.core.operations import AssocOp +from sympy.external.gmpy import SYMPY_INTS +from sympy.matrices import eye +from sympy.utilities.exceptions import (sympy_deprecation_warning, + SymPyDeprecationWarning, + ignore_warnings) +from sympy.utilities.decorator import memoize_property, deprecated +from sympy.utilities.iterables import sift + + +def deprecate_data(): + sympy_deprecation_warning( + """ + The data attribute of TensorIndexType is deprecated. Use The + replace_with_arrays() method instead. + """, + deprecated_since_version="1.4", + active_deprecations_target="deprecated-tensorindextype-attrs", + stacklevel=4, + ) + +def deprecate_fun_eval(): + sympy_deprecation_warning( + """ + The Tensor.fun_eval() method is deprecated. Use + Tensor.substitute_indices() instead. + """, + deprecated_since_version="1.5", + active_deprecations_target="deprecated-tensor-fun-eval", + stacklevel=4, + ) + + +def deprecate_call(): + sympy_deprecation_warning( + """ + Calling a tensor like Tensor(*indices) is deprecated. Use + Tensor.substitute_indices() instead. + """, + deprecated_since_version="1.5", + active_deprecations_target="deprecated-tensor-fun-eval", + stacklevel=4, + ) + + +class _IndexStructure(CantSympify): + """ + This class handles the indices (free and dummy ones). It contains the + algorithms to manage the dummy indices replacements and contractions of + free indices under multiplications of tensor expressions, as well as stuff + related to canonicalization sorting, getting the permutation of the + expression and so on. It also includes tools to get the ``TensorIndex`` + objects corresponding to the given index structure. + """ + + def __init__(self, free, dum, index_types, indices, canon_bp=False): + self.free = free + self.dum = dum + self.index_types = index_types + self.indices = indices + self._ext_rank = len(self.free) + 2*len(self.dum) + self.dum.sort(key=lambda x: x[0]) + + @staticmethod + def from_indices(*indices): + """ + Create a new ``_IndexStructure`` object from a list of ``indices``. + + Explanation + =========== + + ``indices`` ``TensorIndex`` objects, the indices. Contractions are + detected upon construction. + + Examples + ======== + + >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, _IndexStructure + >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') + >>> m0, m1, m2, m3 = tensor_indices('m0,m1,m2,m3', Lorentz) + >>> _IndexStructure.from_indices(m0, m1, -m1, m3) + _IndexStructure([(m0, 0), (m3, 3)], [(1, 2)], [Lorentz, Lorentz, Lorentz, Lorentz]) + """ + + free, dum = _IndexStructure._free_dum_from_indices(*indices) + index_types = [i.tensor_index_type for i in indices] + indices = _IndexStructure._replace_dummy_names(indices, free, dum) + return _IndexStructure(free, dum, index_types, indices) + + @staticmethod + def from_components_free_dum(components, free, dum): + index_types = [] + for component in components: + index_types.extend(component.index_types) + indices = _IndexStructure.generate_indices_from_free_dum_index_types(free, dum, index_types) + return _IndexStructure(free, dum, index_types, indices) + + @staticmethod + def _free_dum_from_indices(*indices): + """ + Convert ``indices`` into ``free``, ``dum`` for single component tensor. + + Explanation + =========== + + ``free`` list of tuples ``(index, pos, 0)``, + where ``pos`` is the position of index in + the list of indices formed by the component tensors + + ``dum`` list of tuples ``(pos_contr, pos_cov, 0, 0)`` + + Examples + ======== + + >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, \ + _IndexStructure + >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') + >>> m0, m1, m2, m3 = tensor_indices('m0,m1,m2,m3', Lorentz) + >>> _IndexStructure._free_dum_from_indices(m0, m1, -m1, m3) + ([(m0, 0), (m3, 3)], [(1, 2)]) + """ + n = len(indices) + if n == 1: + return [(indices[0], 0)], [] + + # find the positions of the free indices and of the dummy indices + free = [True]*len(indices) + index_dict = {} + dum = [] + for i, index in enumerate(indices): + name = index.name + typ = index.tensor_index_type + contr = index.is_up + if (name, typ) in index_dict: + # found a pair of dummy indices + is_contr, pos = index_dict[(name, typ)] + # check consistency and update free + if is_contr: + if contr: + raise ValueError('two equal contravariant indices in slots %d and %d' %(pos, i)) + else: + free[pos] = False + free[i] = False + else: + if contr: + free[pos] = False + free[i] = False + else: + raise ValueError('two equal covariant indices in slots %d and %d' %(pos, i)) + if contr: + dum.append((i, pos)) + else: + dum.append((pos, i)) + else: + index_dict[(name, typ)] = index.is_up, i + + free = [(index, i) for i, index in enumerate(indices) if free[i]] + free.sort() + return free, dum + + def get_indices(self): + """ + Get a list of indices, creating new tensor indices to complete dummy indices. + """ + return self.indices[:] + + @staticmethod + def generate_indices_from_free_dum_index_types(free, dum, index_types): + indices = [None]*(len(free)+2*len(dum)) + for idx, pos in free: + indices[pos] = idx + + generate_dummy_name = _IndexStructure._get_generator_for_dummy_indices(free) + for pos1, pos2 in dum: + typ1 = index_types[pos1] + indname = generate_dummy_name(typ1) + indices[pos1] = TensorIndex(indname, typ1, True) + indices[pos2] = TensorIndex(indname, typ1, False) + + return _IndexStructure._replace_dummy_names(indices, free, dum) + + @staticmethod + def _get_generator_for_dummy_indices(free): + cdt = defaultdict(int) + # if the free indices have names with dummy_name, start with an + # index higher than those for the dummy indices + # to avoid name collisions + for indx, ipos in free: + if indx.name.split('_')[0] == indx.tensor_index_type.dummy_name: + cdt[indx.tensor_index_type] = max(cdt[indx.tensor_index_type], int(indx.name.split('_')[1]) + 1) + + def dummy_name_gen(tensor_index_type): + nd = str(cdt[tensor_index_type]) + cdt[tensor_index_type] += 1 + return tensor_index_type.dummy_name + '_' + nd + + return dummy_name_gen + + @staticmethod + def _replace_dummy_names(indices, free, dum): + dum.sort(key=lambda x: x[0]) + new_indices = list(indices) + assert len(indices) == len(free) + 2*len(dum) + generate_dummy_name = _IndexStructure._get_generator_for_dummy_indices(free) + for ipos1, ipos2 in dum: + typ1 = new_indices[ipos1].tensor_index_type + indname = generate_dummy_name(typ1) + new_indices[ipos1] = TensorIndex(indname, typ1, True) + new_indices[ipos2] = TensorIndex(indname, typ1, False) + return new_indices + + def get_free_indices(self) -> list[TensorIndex]: + """ + Get a list of free indices. + """ + # get sorted indices according to their position: + free = sorted(self.free, key=lambda x: x[1]) + return [i[0] for i in free] + + def __str__(self): + return "_IndexStructure({}, {}, {})".format(self.free, self.dum, self.index_types) + + def __repr__(self): + return self.__str__() + + def _get_sorted_free_indices_for_canon(self): + sorted_free = self.free[:] + sorted_free.sort(key=lambda x: x[0]) + return sorted_free + + def _get_sorted_dum_indices_for_canon(self): + return sorted(self.dum, key=lambda x: x[0]) + + def _get_lexicographically_sorted_index_types(self): + permutation = self.indices_canon_args()[0] + index_types = [None]*self._ext_rank + for i, it in enumerate(self.index_types): + index_types[permutation(i)] = it + return index_types + + def _get_lexicographically_sorted_indices(self): + permutation = self.indices_canon_args()[0] + indices = [None]*self._ext_rank + for i, it in enumerate(self.indices): + indices[permutation(i)] = it + return indices + + def perm2tensor(self, g, is_canon_bp=False): + """ + Returns a ``_IndexStructure`` instance corresponding to the permutation ``g``. + + Explanation + =========== + + ``g`` permutation corresponding to the tensor in the representation + used in canonicalization + + ``is_canon_bp`` if True, then ``g`` is the permutation + corresponding to the canonical form of the tensor + """ + sorted_free = [i[0] for i in self._get_sorted_free_indices_for_canon()] + lex_index_types = self._get_lexicographically_sorted_index_types() + lex_indices = self._get_lexicographically_sorted_indices() + nfree = len(sorted_free) + rank = self._ext_rank + dum = [[None]*2 for i in range((rank - nfree)//2)] + free = [] + + index_types = [None]*rank + indices = [None]*rank + for i in range(rank): + gi = g[i] + index_types[i] = lex_index_types[gi] + indices[i] = lex_indices[gi] + if gi < nfree: + ind = sorted_free[gi] + assert index_types[i] == sorted_free[gi].tensor_index_type + free.append((ind, i)) + else: + j = gi - nfree + idum, cov = divmod(j, 2) + if cov: + dum[idum][1] = i + else: + dum[idum][0] = i + dum = [tuple(x) for x in dum] + + return _IndexStructure(free, dum, index_types, indices) + + def indices_canon_args(self): + """ + Returns ``(g, dummies, msym, v)``, the entries of ``canonicalize`` + + See ``canonicalize`` in ``tensor_can.py`` in combinatorics module. + """ + # to be called after sorted_components + from sympy.combinatorics.permutations import _af_new + n = self._ext_rank + g = [None]*n + [n, n+1] + + # Converts the symmetry of the metric into msym from .canonicalize() + # method in the combinatorics module + def metric_symmetry_to_msym(metric): + if metric is None: + return None + sym = metric.symmetry + if sym == TensorSymmetry.fully_symmetric(2): + return 0 + if sym == TensorSymmetry.fully_symmetric(-2): + return 1 + return None + + # ordered indices: first the free indices, ordered by types + # then the dummy indices, ordered by types and contravariant before + # covariant + # g[position in tensor] = position in ordered indices + for i, (indx, ipos) in enumerate(self._get_sorted_free_indices_for_canon()): + g[ipos] = i + pos = len(self.free) + j = len(self.free) + dummies = [] + prev = None + a = [] + msym = [] + for ipos1, ipos2 in self._get_sorted_dum_indices_for_canon(): + g[ipos1] = j + g[ipos2] = j + 1 + j += 2 + typ = self.index_types[ipos1] + if typ != prev: + if a: + dummies.append(a) + a = [pos, pos + 1] + prev = typ + msym.append(metric_symmetry_to_msym(typ.metric)) + else: + a.extend([pos, pos + 1]) + pos += 2 + if a: + dummies.append(a) + + return _af_new(g), dummies, msym + + +def components_canon_args(components): + numtyp = [] + prev = None + for t in components: + if t == prev: + numtyp[-1][1] += 1 + else: + prev = t + numtyp.append([prev, 1]) + v = [] + for h, n in numtyp: + if h.comm in (0, 1): + comm = h.comm + else: + comm = TensorManager.get_comm(h.comm, h.comm) + v.append((h.symmetry.base, h.symmetry.generators, n, comm)) + return v + + +class _TensorDataLazyEvaluator(CantSympify): + """ + EXPERIMENTAL: do not rely on this class, it may change without deprecation + warnings in future versions of SymPy. + + Explanation + =========== + + This object contains the logic to associate components data to a tensor + expression. Components data are set via the ``.data`` property of tensor + expressions, is stored inside this class as a mapping between the tensor + expression and the ``ndarray``. + + Computations are executed lazily: whereas the tensor expressions can have + contractions, tensor products, and additions, components data are not + computed until they are accessed by reading the ``.data`` property + associated to the tensor expression. + """ + _substitutions_dict: dict[Any, Any] = {} + _substitutions_dict_tensmul: dict[Any, Any] = {} + + def __getitem__(self, key): + dat = self._get(key) + if dat is None: + return None + + from .array import NDimArray + if not isinstance(dat, NDimArray): + return dat + + if dat.rank() == 0: + return dat[()] + elif dat.rank() == 1 and len(dat) == 1: + return dat[0] + return dat + + def _get(self, key): + """ + Retrieve ``data`` associated with ``key``. + + Explanation + =========== + + This algorithm looks into ``self._substitutions_dict`` for all + ``TensorHead`` in the ``TensExpr`` (or just ``TensorHead`` if key is a + TensorHead instance). It reconstructs the components data that the + tensor expression should have by performing on components data the + operations that correspond to the abstract tensor operations applied. + + Metric tensor is handled in a different manner: it is pre-computed in + ``self._substitutions_dict_tensmul``. + """ + if key in self._substitutions_dict: + return self._substitutions_dict[key] + + if isinstance(key, TensorHead): + return None + + if isinstance(key, Tensor): + # special case to handle metrics. Metric tensors cannot be + # constructed through contraction by the metric, their + # components show if they are a matrix or its inverse. + signature = tuple([i.is_up for i in key.get_indices()]) + srch = (key.component,) + signature + if srch in self._substitutions_dict_tensmul: + return self._substitutions_dict_tensmul[srch] + array_list = [self.data_from_tensor(key)] + return self.data_contract_dum(array_list, key.dum, key.ext_rank) + + if isinstance(key, TensMul): + tensmul_args = key.args + if len(tensmul_args) == 1 and len(tensmul_args[0].components) == 1: + # special case to handle metrics. Metric tensors cannot be + # constructed through contraction by the metric, their + # components show if they are a matrix or its inverse. + signature = tuple([i.is_up for i in tensmul_args[0].get_indices()]) + srch = (tensmul_args[0].components[0],) + signature + if srch in self._substitutions_dict_tensmul: + return self._substitutions_dict_tensmul[srch] + #data_list = [self.data_from_tensor(i) for i in tensmul_args if isinstance(i, TensExpr)] + data_list = [self.data_from_tensor(i) if isinstance(i, Tensor) else i.data for i in tensmul_args if isinstance(i, TensExpr)] + coeff = prod([i for i in tensmul_args if not isinstance(i, TensExpr)]) + if all(i is None for i in data_list): + return None + if any(i is None for i in data_list): + raise ValueError("Mixing tensors with associated components "\ + "data with tensors without components data") + data_result = self.data_contract_dum(data_list, key.dum, key.ext_rank) + return coeff*data_result + + if isinstance(key, TensAdd): + data_list = [] + free_args_list = [] + for arg in key.args: + if isinstance(arg, TensExpr): + data_list.append(arg.data) + free_args_list.append([x[0] for x in arg.free]) + else: + data_list.append(arg) + free_args_list.append([]) + if all(i is None for i in data_list): + return None + if any(i is None for i in data_list): + raise ValueError("Mixing tensors with associated components "\ + "data with tensors without components data") + + sum_list = [] + from .array import permutedims + for data, free_args in zip(data_list, free_args_list): + if len(free_args) < 2: + sum_list.append(data) + else: + free_args_pos = {y: x for x, y in enumerate(free_args)} + axes = [free_args_pos[arg] for arg in key.free_args] + sum_list.append(permutedims(data, axes)) + return reduce(lambda x, y: x+y, sum_list) + + return None + + @staticmethod + def data_contract_dum(ndarray_list, dum, ext_rank): + from .array import tensorproduct, tensorcontraction, MutableDenseNDimArray + arrays = list(map(MutableDenseNDimArray, ndarray_list)) + prodarr = tensorproduct(*arrays) + return tensorcontraction(prodarr, *dum) + + def data_tensorhead_from_tensmul(self, data, tensmul, tensorhead): + """ + This method is used when assigning components data to a ``TensMul`` + object, it converts components data to a fully contravariant ndarray, + which is then stored according to the ``TensorHead`` key. + """ + if data is None: + return None + + return self._correct_signature_from_indices( + data, + tensmul.get_indices(), + tensmul.free, + tensmul.dum, + True) + + def data_from_tensor(self, tensor): + """ + This method corrects the components data to the right signature + (covariant/contravariant) using the metric associated with each + ``TensorIndexType``. + """ + tensorhead = tensor.component + + if tensorhead.data is None: + return None + + return self._correct_signature_from_indices( + tensorhead.data, + tensor.get_indices(), + tensor.free, + tensor.dum) + + def _assign_data_to_tensor_expr(self, key, data): + if isinstance(key, TensAdd): + raise ValueError('cannot assign data to TensAdd') + # here it is assumed that `key` is a `TensMul` instance. + if len(key.components) != 1: + raise ValueError('cannot assign data to TensMul with multiple components') + tensorhead = key.components[0] + newdata = self.data_tensorhead_from_tensmul(data, key, tensorhead) + return tensorhead, newdata + + def _check_permutations_on_data(self, tens, data): + from .array import permutedims + from .array.arrayop import Flatten + + if isinstance(tens, TensorHead): + rank = tens.rank + generators = tens.symmetry.generators + elif isinstance(tens, Tensor): + rank = tens.rank + generators = tens.components[0].symmetry.generators + elif isinstance(tens, TensorIndexType): + rank = tens.metric.rank + generators = tens.metric.symmetry.generators + + # Every generator is a permutation, check that by permuting the array + # by that permutation, the array will be the same, except for a + # possible sign change if the permutation admits it. + for gener in generators: + sign_change = +1 if (gener(rank) == rank) else -1 + data_swapped = data + last_data = data + permute_axes = list(map(gener, range(rank))) + # the order of a permutation is the number of times to get the + # identity by applying that permutation. + for i in range(gener.order()-1): + data_swapped = permutedims(data_swapped, permute_axes) + # if any value in the difference array is non-zero, raise an error: + if any(Flatten(last_data - sign_change*data_swapped)): + raise ValueError("Component data symmetry structure error") + last_data = data_swapped + + def __setitem__(self, key, value): + """ + Set the components data of a tensor object/expression. + + Explanation + =========== + + Components data are transformed to the all-contravariant form and stored + with the corresponding ``TensorHead`` object. If a ``TensorHead`` object + cannot be uniquely identified, it will raise an error. + """ + data = _TensorDataLazyEvaluator.parse_data(value) + self._check_permutations_on_data(key, data) + + # TensorHead and TensorIndexType can be assigned data directly, while + # TensMul must first convert data to a fully contravariant form, and + # assign it to its corresponding TensorHead single component. + if not isinstance(key, (TensorHead, TensorIndexType)): + key, data = self._assign_data_to_tensor_expr(key, data) + + if isinstance(key, TensorHead): + for dim, indextype in zip(data.shape, key.index_types): + if indextype.data is None: + raise ValueError("index type {} has no components data"\ + " associated (needed to raise/lower index)".format(indextype)) + if not indextype.dim.is_number: + continue + if dim != indextype.dim: + raise ValueError("wrong dimension of ndarray") + self._substitutions_dict[key] = data + + def __delitem__(self, key): + del self._substitutions_dict[key] + + def __contains__(self, key): + return key in self._substitutions_dict + + def add_metric_data(self, metric, data): + """ + Assign data to the ``metric`` tensor. The metric tensor behaves in an + anomalous way when raising and lowering indices. + + Explanation + =========== + + A fully covariant metric is the inverse transpose of the fully + contravariant metric (it is meant matrix inverse). If the metric is + symmetric, the transpose is not necessary and mixed + covariant/contravariant metrics are Kronecker deltas. + """ + # hard assignment, data should not be added to `TensorHead` for metric: + # the problem with `TensorHead` is that the metric is anomalous, i.e. + # raising and lowering the index means considering the metric or its + # inverse, this is not the case for other tensors. + self._substitutions_dict_tensmul[metric, True, True] = data + inverse_transpose = self.inverse_transpose_matrix(data) + # in symmetric spaces, the transpose is the same as the original matrix, + # the full covariant metric tensor is the inverse transpose, so this + # code will be able to handle non-symmetric metrics. + self._substitutions_dict_tensmul[metric, False, False] = inverse_transpose + # now mixed cases, these are identical to the unit matrix if the metric + # is symmetric. + m = data.tomatrix() + invt = inverse_transpose.tomatrix() + self._substitutions_dict_tensmul[metric, True, False] = m * invt + self._substitutions_dict_tensmul[metric, False, True] = invt * m + + @staticmethod + def _flip_index_by_metric(data, metric, pos): + from .array import tensorproduct, tensorcontraction + + mdim = metric.rank() + ddim = data.rank() + + if pos == 0: + data = tensorcontraction( + tensorproduct( + metric, + data + ), + (1, mdim+pos) + ) + else: + data = tensorcontraction( + tensorproduct( + data, + metric + ), + (pos, ddim) + ) + return data + + @staticmethod + def inverse_matrix(ndarray): + m = ndarray.tomatrix().inv() + return _TensorDataLazyEvaluator.parse_data(m) + + @staticmethod + def inverse_transpose_matrix(ndarray): + m = ndarray.tomatrix().inv().T + return _TensorDataLazyEvaluator.parse_data(m) + + @staticmethod + def _correct_signature_from_indices(data, indices, free, dum, inverse=False): + """ + Utility function to correct the values inside the components data + ndarray according to whether indices are covariant or contravariant. + + It uses the metric matrix to lower values of covariant indices. + """ + # change the ndarray values according covariantness/contravariantness of the indices + # use the metric + for i, indx in enumerate(indices): + if not indx.is_up and not inverse: + data = _TensorDataLazyEvaluator._flip_index_by_metric(data, indx.tensor_index_type.data, i) + elif not indx.is_up and inverse: + data = _TensorDataLazyEvaluator._flip_index_by_metric( + data, + _TensorDataLazyEvaluator.inverse_matrix(indx.tensor_index_type.data), + i + ) + return data + + @staticmethod + def _sort_data_axes(old, new): + from .array import permutedims + + new_data = old.data.copy() + + old_free = [i[0] for i in old.free] + new_free = [i[0] for i in new.free] + + for i in range(len(new_free)): + for j in range(i, len(old_free)): + if old_free[j] == new_free[i]: + old_free[i], old_free[j] = old_free[j], old_free[i] + new_data = permutedims(new_data, (i, j)) + break + return new_data + + @staticmethod + def add_rearrange_tensmul_parts(new_tensmul, old_tensmul): + def sorted_compo(): + return _TensorDataLazyEvaluator._sort_data_axes(old_tensmul, new_tensmul) + + _TensorDataLazyEvaluator._substitutions_dict[new_tensmul] = sorted_compo() + + @staticmethod + def parse_data(data): + """ + Transform ``data`` to array. The parameter ``data`` may + contain data in various formats, e.g. nested lists, SymPy ``Matrix``, + and so on. + + Examples + ======== + + >>> from sympy.tensor.tensor import _TensorDataLazyEvaluator + >>> _TensorDataLazyEvaluator.parse_data([1, 3, -6, 12]) + [1, 3, -6, 12] + + >>> _TensorDataLazyEvaluator.parse_data([[1, 2], [4, 7]]) + [[1, 2], [4, 7]] + """ + from .array import MutableDenseNDimArray + + if not isinstance(data, MutableDenseNDimArray): + if len(data) == 2 and hasattr(data[0], '__call__'): + data = MutableDenseNDimArray(data[0], data[1]) + else: + data = MutableDenseNDimArray(data) + return data + +_tensor_data_substitution_dict = _TensorDataLazyEvaluator() + + +class _TensorManager: + """ + Class to manage tensor properties. + + Notes + ===== + + Tensors belong to tensor commutation groups; each group has a label + ``comm``; there are predefined labels: + + ``0`` tensors commuting with any other tensor + + ``1`` tensors anticommuting among themselves + + ``2`` tensors not commuting, apart with those with ``comm=0`` + + Other groups can be defined using ``set_comm``; tensors in those + groups commute with those with ``comm=0``; by default they + do not commute with any other group. + """ + def __init__(self): + self._comm_init() + + def _comm_init(self): + self._comm = [{} for i in range(3)] + for i in range(3): + self._comm[0][i] = 0 + self._comm[i][0] = 0 + self._comm[1][1] = 1 + self._comm[2][1] = None + self._comm[1][2] = None + self._comm_symbols2i = {0:0, 1:1, 2:2} + self._comm_i2symbol = {0:0, 1:1, 2:2} + + @property + def comm(self): + return self._comm + + def comm_symbols2i(self, i): + """ + Get the commutation group number corresponding to ``i``. + + ``i`` can be a symbol or a number or a string. + + If ``i`` is not already defined its commutation group number + is set. + """ + if i not in self._comm_symbols2i: + n = len(self._comm) + self._comm.append({}) + self._comm[n][0] = 0 + self._comm[0][n] = 0 + self._comm_symbols2i[i] = n + self._comm_i2symbol[n] = i + return n + return self._comm_symbols2i[i] + + def comm_i2symbol(self, i): + """ + Returns the symbol corresponding to the commutation group number. + """ + return self._comm_i2symbol[i] + + def set_comm(self, i, j, c): + """ + Set the commutation parameter ``c`` for commutation groups ``i, j``. + + Parameters + ========== + + i, j : symbols representing commutation groups + + c : group commutation number + + Notes + ===== + + ``i, j`` can be symbols, strings or numbers, + apart from ``0, 1`` and ``2`` which are reserved respectively + for commuting, anticommuting tensors and tensors not commuting + with any other group apart with the commuting tensors. + For the remaining cases, use this method to set the commutation rules; + by default ``c=None``. + + The group commutation number ``c`` is assigned in correspondence + to the group commutation symbols; it can be + + 0 commuting + + 1 anticommuting + + None no commutation property + + Examples + ======== + + ``G`` and ``GH`` do not commute with themselves and commute with + each other; A is commuting. + + >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, TensorHead, TensorManager, TensorSymmetry + >>> Lorentz = TensorIndexType('Lorentz') + >>> i0,i1,i2,i3,i4 = tensor_indices('i0:5', Lorentz) + >>> A = TensorHead('A', [Lorentz]) + >>> G = TensorHead('G', [Lorentz], TensorSymmetry.no_symmetry(1), 'Gcomm') + >>> GH = TensorHead('GH', [Lorentz], TensorSymmetry.no_symmetry(1), 'GHcomm') + >>> TensorManager.set_comm('Gcomm', 'GHcomm', 0) + >>> (GH(i1)*G(i0)).canon_bp() + G(i0)*GH(i1) + >>> (G(i1)*G(i0)).canon_bp() + G(i1)*G(i0) + >>> (G(i1)*A(i0)).canon_bp() + A(i0)*G(i1) + """ + if c not in (0, 1, None): + raise ValueError('`c` can assume only the values 0, 1 or None') + + if i not in self._comm_symbols2i: + n = len(self._comm) + self._comm.append({}) + self._comm[n][0] = 0 + self._comm[0][n] = 0 + self._comm_symbols2i[i] = n + self._comm_i2symbol[n] = i + if j not in self._comm_symbols2i: + n = len(self._comm) + self._comm.append({}) + self._comm[0][n] = 0 + self._comm[n][0] = 0 + self._comm_symbols2i[j] = n + self._comm_i2symbol[n] = j + ni = self._comm_symbols2i[i] + nj = self._comm_symbols2i[j] + self._comm[ni][nj] = c + self._comm[nj][ni] = c + + def set_comms(self, *args): + """ + Set the commutation group numbers ``c`` for symbols ``i, j``. + + Parameters + ========== + + args : sequence of ``(i, j, c)`` + """ + for i, j, c in args: + self.set_comm(i, j, c) + + def get_comm(self, i, j): + """ + Return the commutation parameter for commutation group numbers ``i, j`` + + see ``_TensorManager.set_comm`` + """ + return self._comm[i].get(j, 0 if i == 0 or j == 0 else None) + + def clear(self): + """ + Clear the TensorManager. + """ + self._comm_init() + + +TensorManager = _TensorManager() + + +class TensorIndexType(Basic): + """ + A TensorIndexType is characterized by its name and its metric. + + Parameters + ========== + + name : name of the tensor type + dummy_name : name of the head of dummy indices + dim : dimension, it can be a symbol or an integer or ``None`` + eps_dim : dimension of the epsilon tensor + metric_symmetry : integer that denotes metric symmetry or ``None`` for no metric + metric_name : string with the name of the metric tensor + + Attributes + ========== + + ``metric`` : the metric tensor + ``delta`` : ``Kronecker delta`` + ``epsilon`` : the ``Levi-Civita epsilon`` tensor + ``data`` : (deprecated) a property to add ``ndarray`` values, to work in a specified basis. + + Notes + ===== + + The possible values of the ``metric_symmetry`` parameter are: + + ``1`` : metric tensor is fully symmetric + ``0`` : metric tensor possesses no index symmetry + ``-1`` : metric tensor is fully antisymmetric + ``None``: there is no metric tensor (metric equals to ``None``) + + The metric is assumed to be symmetric by default. It can also be set + to a custom tensor by the ``.set_metric()`` method. + + If there is a metric the metric is used to raise and lower indices. + + In the case of non-symmetric metric, the following raising and + lowering conventions will be adopted: + + ``psi(a) = g(a, b)*psi(-b); chi(-a) = chi(b)*g(-b, -a)`` + + From these it is easy to find: + + ``g(-a, b) = delta(-a, b)`` + + where ``delta(-a, b) = delta(b, -a)`` is the ``Kronecker delta`` + (see ``TensorIndex`` for the conventions on indices). + For antisymmetric metrics there is also the following equality: + + ``g(a, -b) = -delta(a, -b)`` + + If there is no metric it is not possible to raise or lower indices; + e.g. the index of the defining representation of ``SU(N)`` + is 'covariant' and the conjugate representation is + 'contravariant'; for ``N > 2`` they are linearly independent. + + ``eps_dim`` is by default equal to ``dim``, if the latter is an integer; + else it can be assigned (for use in naive dimensional regularization); + if ``eps_dim`` is not an integer ``epsilon`` is ``None``. + + Examples + ======== + + >>> from sympy.tensor.tensor import TensorIndexType + >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') + >>> Lorentz.metric + metric(Lorentz,Lorentz) + """ + + def __new__(cls, name, dummy_name=None, dim=None, eps_dim=None, + metric_symmetry=1, metric_name='metric', **kwargs): + if 'dummy_fmt' in kwargs: + dummy_fmt = kwargs['dummy_fmt'] + sympy_deprecation_warning( + f""" + The dummy_fmt keyword to TensorIndexType is deprecated. Use + dummy_name={dummy_fmt} instead. + """, + deprecated_since_version="1.5", + active_deprecations_target="deprecated-tensorindextype-dummy-fmt", + ) + dummy_name = dummy_fmt + + if isinstance(name, str): + name = Symbol(name) + + if dummy_name is None: + dummy_name = str(name)[0] + if isinstance(dummy_name, str): + dummy_name = Symbol(dummy_name) + + if dim is None: + dim = Symbol("dim_" + dummy_name.name) + else: + dim = sympify(dim) + + if eps_dim is None: + eps_dim = dim + else: + eps_dim = sympify(eps_dim) + + metric_symmetry = sympify(metric_symmetry) + + if isinstance(metric_name, str): + metric_name = Symbol(metric_name) + + if 'metric' in kwargs: + SymPyDeprecationWarning( + """ + The 'metric' keyword argument to TensorIndexType is + deprecated. Use the 'metric_symmetry' keyword argument or the + TensorIndexType.set_metric() method instead. + """, + deprecated_since_version="1.5", + active_deprecations_target="deprecated-tensorindextype-metric", + ) + metric = kwargs.get('metric') + if metric is not None: + if metric in (True, False, 0, 1): + metric_name = 'metric' + #metric_antisym = metric + else: + metric_name = metric.name + #metric_antisym = metric.antisym + + if metric: + metric_symmetry = -1 + else: + metric_symmetry = 1 + + obj = Basic.__new__(cls, name, dummy_name, dim, eps_dim, + metric_symmetry, metric_name) + + obj._autogenerated = [] + return obj + + @property + def name(self): + return self.args[0].name + + @property + def dummy_name(self): + return self.args[1].name + + @property + def dim(self): + return self.args[2] + + @property + def eps_dim(self): + return self.args[3] + + @memoize_property + def metric(self): + metric_symmetry = self.args[4] + metric_name = self.args[5] + if metric_symmetry is None: + return None + + if metric_symmetry == 0: + symmetry = TensorSymmetry.no_symmetry(2) + elif metric_symmetry == 1: + symmetry = TensorSymmetry.fully_symmetric(2) + elif metric_symmetry == -1: + symmetry = TensorSymmetry.fully_symmetric(-2) + + return TensorHead(metric_name, [self]*2, symmetry) + + @memoize_property + def delta(self): + return TensorHead('KD', [self]*2, TensorSymmetry.fully_symmetric(2)) + + @memoize_property + def epsilon(self): + if not isinstance(self.eps_dim, (SYMPY_INTS, Integer)): + return None + symmetry = TensorSymmetry.fully_symmetric(-self.eps_dim) + return TensorHead('Eps', [self]*self.eps_dim, symmetry) + + def set_metric(self, tensor): + self._metric = tensor + + def __lt__(self, other): + return self.name < other.name + + def __str__(self): + return self.name + + __repr__ = __str__ + + # Everything below this line is deprecated + + @property + def data(self): + deprecate_data() + with ignore_warnings(SymPyDeprecationWarning): + return _tensor_data_substitution_dict[self] + + @data.setter + def data(self, data): + deprecate_data() + # This assignment is a bit controversial, should metric components be assigned + # to the metric only or also to the TensorIndexType object? The advantage here + # is the ability to assign a 1D array and transform it to a 2D diagonal array. + from .array import MutableDenseNDimArray + + data = _TensorDataLazyEvaluator.parse_data(data) + if data.rank() > 2: + raise ValueError("data have to be of rank 1 (diagonal metric) or 2.") + if data.rank() == 1: + if self.dim.is_number: + nda_dim = data.shape[0] + if nda_dim != self.dim: + raise ValueError("Dimension mismatch") + + dim = data.shape[0] + newndarray = MutableDenseNDimArray.zeros(dim, dim) + for i, val in enumerate(data): + newndarray[i, i] = val + data = newndarray + dim1, dim2 = data.shape + if dim1 != dim2: + raise ValueError("Non-square matrix tensor.") + if self.dim.is_number: + if self.dim != dim1: + raise ValueError("Dimension mismatch") + _tensor_data_substitution_dict[self] = data + _tensor_data_substitution_dict.add_metric_data(self.metric, data) + with ignore_warnings(SymPyDeprecationWarning): + delta = self.get_kronecker_delta() + i1 = TensorIndex('i1', self) + i2 = TensorIndex('i2', self) + with ignore_warnings(SymPyDeprecationWarning): + delta(i1, -i2).data = _TensorDataLazyEvaluator.parse_data(eye(dim1)) + + @data.deleter + def data(self): + deprecate_data() + with ignore_warnings(SymPyDeprecationWarning): + if self in _tensor_data_substitution_dict: + del _tensor_data_substitution_dict[self] + if self.metric in _tensor_data_substitution_dict: + del _tensor_data_substitution_dict[self.metric] + + @deprecated( + """ + The TensorIndexType.get_kronecker_delta() method is deprecated. Use + the TensorIndexType.delta attribute instead. + """, + deprecated_since_version="1.5", + active_deprecations_target="deprecated-tensorindextype-methods", + ) + def get_kronecker_delta(self): + sym2 = TensorSymmetry(get_symmetric_group_sgs(2)) + delta = TensorHead('KD', [self]*2, sym2) + return delta + + @deprecated( + """ + The TensorIndexType.get_epsilon() method is deprecated. Use + the TensorIndexType.epsilon attribute instead. + """, + deprecated_since_version="1.5", + active_deprecations_target="deprecated-tensorindextype-methods", + ) + def get_epsilon(self): + if not isinstance(self._eps_dim, (SYMPY_INTS, Integer)): + return None + sym = TensorSymmetry(get_symmetric_group_sgs(self._eps_dim, 1)) + epsilon = TensorHead('Eps', [self]*self._eps_dim, sym) + return epsilon + + def _components_data_full_destroy(self): + """ + EXPERIMENTAL: do not rely on this API method. + + This destroys components data associated to the ``TensorIndexType``, if + any, specifically: + + * metric tensor data + * Kronecker tensor data + """ + if self in _tensor_data_substitution_dict: + del _tensor_data_substitution_dict[self] + + def delete_tensmul_data(key): + if key in _tensor_data_substitution_dict._substitutions_dict_tensmul: + del _tensor_data_substitution_dict._substitutions_dict_tensmul[key] + + # delete metric data: + delete_tensmul_data((self.metric, True, True)) + delete_tensmul_data((self.metric, True, False)) + delete_tensmul_data((self.metric, False, True)) + delete_tensmul_data((self.metric, False, False)) + + # delete delta tensor data: + delta = self.get_kronecker_delta() + if delta in _tensor_data_substitution_dict: + del _tensor_data_substitution_dict[delta] + + +class TensorIndex(Basic): + """ + Represents a tensor index + + Parameters + ========== + + name : name of the index, or ``True`` if you want it to be automatically assigned + tensor_index_type : ``TensorIndexType`` of the index + is_up : flag for contravariant index (is_up=True by default) + + Attributes + ========== + + ``name`` + ``tensor_index_type`` + ``is_up`` + + Notes + ===== + + Tensor indices are contracted with the Einstein summation convention. + + An index can be in contravariant or in covariant form; in the latter + case it is represented prepending a ``-`` to the index name. Adding + ``-`` to a covariant (is_up=False) index makes it contravariant. + + Dummy indices have a name with head given by + ``tensor_inde_type.dummy_name`` with underscore and a number. + + Similar to ``symbols`` multiple contravariant indices can be created + at once using ``tensor_indices(s, typ)``, where ``s`` is a string + of names. + + + Examples + ======== + + >>> from sympy.tensor.tensor import TensorIndexType, TensorIndex, TensorHead, tensor_indices + >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') + >>> mu = TensorIndex('mu', Lorentz, is_up=False) + >>> nu, rho = tensor_indices('nu, rho', Lorentz) + >>> A = TensorHead('A', [Lorentz, Lorentz]) + >>> A(mu, nu) + A(-mu, nu) + >>> A(-mu, -rho) + A(mu, -rho) + >>> A(mu, -mu) + A(-L_0, L_0) + """ + def __new__(cls, name, tensor_index_type, is_up=True): + if isinstance(name, str): + name_symbol = Symbol(name) + elif isinstance(name, Symbol): + name_symbol = name + elif name is True: + name = "_i{}".format(len(tensor_index_type._autogenerated)) + name_symbol = Symbol(name) + tensor_index_type._autogenerated.append(name_symbol) + else: + raise ValueError("invalid name") + + is_up = sympify(is_up) + return Basic.__new__(cls, name_symbol, tensor_index_type, is_up) + + @property + def name(self): + return self.args[0].name + + @property + def tensor_index_type(self): + return self.args[1] + + @property + def is_up(self): + return self.args[2] + + def _print(self): + s = self.name + if not self.is_up: + s = '-%s' % s + return s + + def __lt__(self, other): + return ((self.tensor_index_type, self.name) < + (other.tensor_index_type, other.name)) + + def __neg__(self): + t1 = TensorIndex(self.name, self.tensor_index_type, + (not self.is_up)) + return t1 + + +def tensor_indices(s, typ): + """ + Returns list of tensor indices given their names and their types. + + Parameters + ========== + + s : string of comma separated names of indices + + typ : ``TensorIndexType`` of the indices + + Examples + ======== + + >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices + >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') + >>> a, b, c, d = tensor_indices('a,b,c,d', Lorentz) + """ + if isinstance(s, str): + a = [x.name for x in symbols(s, seq=True)] + else: + raise ValueError('expecting a string') + + tilist = [TensorIndex(i, typ) for i in a] + if len(tilist) == 1: + return tilist[0] + return tilist + + +class TensorSymmetry(Basic): + """ + Monoterm symmetry of a tensor (i.e. any symmetric or anti-symmetric + index permutation). For the relevant terminology see ``tensor_can.py`` + section of the combinatorics module. + + Parameters + ========== + + bsgs : tuple ``(base, sgs)`` BSGS of the symmetry of the tensor + + Attributes + ========== + + ``base`` : base of the BSGS + ``generators`` : generators of the BSGS + ``rank`` : rank of the tensor + + Notes + ===== + + A tensor can have an arbitrary monoterm symmetry provided by its BSGS. + Multiterm symmetries, like the cyclic symmetry of the Riemann tensor + (i.e., Bianchi identity), are not covered. See combinatorics module for + information on how to generate BSGS for a general index permutation group. + Simple symmetries can be generated using built-in methods. + + See Also + ======== + + sympy.combinatorics.tensor_can.get_symmetric_group_sgs + + Examples + ======== + + Define a symmetric tensor of rank 2 + + >>> from sympy.tensor.tensor import TensorIndexType, TensorSymmetry, get_symmetric_group_sgs, TensorHead + >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') + >>> sym = TensorSymmetry(get_symmetric_group_sgs(2)) + >>> T = TensorHead('T', [Lorentz]*2, sym) + + Note, that the same can also be done using built-in TensorSymmetry methods + + >>> sym2 = TensorSymmetry.fully_symmetric(2) + >>> sym == sym2 + True + """ + def __new__(cls, *args, **kw_args): + if len(args) == 1: + base, generators = args[0] + elif len(args) == 2: + base, generators = args + else: + raise TypeError("bsgs required, either two separate parameters or one tuple") + + if not isinstance(base, Tuple): + base = Tuple(*base) + if not isinstance(generators, Tuple): + generators = Tuple(*generators) + + return Basic.__new__(cls, base, generators, **kw_args) + + @property + def base(self): + return self.args[0] + + @property + def generators(self): + return self.args[1] + + @property + def rank(self): + return self.generators[0].size - 2 + + @classmethod + def fully_symmetric(cls, rank): + """ + Returns a fully symmetric (antisymmetric if ``rank``<0) + TensorSymmetry object for ``abs(rank)`` indices. + """ + if rank > 0: + bsgs = get_symmetric_group_sgs(rank, False) + elif rank < 0: + bsgs = get_symmetric_group_sgs(-rank, True) + elif rank == 0: + bsgs = ([], [Permutation(1)]) + return TensorSymmetry(bsgs) + + @classmethod + def direct_product(cls, *args): + """ + Returns a TensorSymmetry object that is being a direct product of + fully (anti-)symmetric index permutation groups. + + Notes + ===== + + Some examples for different values of ``(*args)``: + ``(1)`` vector, equivalent to ``TensorSymmetry.fully_symmetric(1)`` + ``(2)`` tensor with 2 symmetric indices, equivalent to ``.fully_symmetric(2)`` + ``(-2)`` tensor with 2 antisymmetric indices, equivalent to ``.fully_symmetric(-2)`` + ``(2, -2)`` tensor with the first 2 indices commuting and the last 2 anticommuting + ``(1, 1, 1)`` tensor with 3 indices without any symmetry + """ + base, sgs = [], [Permutation(1)] + for arg in args: + if arg > 0: + bsgs2 = get_symmetric_group_sgs(arg, False) + elif arg < 0: + bsgs2 = get_symmetric_group_sgs(-arg, True) + else: + continue + base, sgs = bsgs_direct_product(base, sgs, *bsgs2) + + return TensorSymmetry(base, sgs) + + @classmethod + def riemann(cls): + """ + Returns a monotorem symmetry of the Riemann tensor + """ + return TensorSymmetry(riemann_bsgs) + + @classmethod + def no_symmetry(cls, rank): + """ + TensorSymmetry object for ``rank`` indices with no symmetry + """ + return TensorSymmetry([], [Permutation(rank+1)]) + + +@deprecated( + """ + The tensorsymmetry() function is deprecated. Use the TensorSymmetry + constructor instead. + """, + deprecated_since_version="1.5", + active_deprecations_target="deprecated-tensorsymmetry", +) +def tensorsymmetry(*args): + """ + Returns a ``TensorSymmetry`` object. This method is deprecated, use + ``TensorSymmetry.direct_product()`` or ``.riemann()`` instead. + + Explanation + =========== + + One can represent a tensor with any monoterm slot symmetry group + using a BSGS. + + ``args`` can be a BSGS + ``args[0]`` base + ``args[1]`` sgs + + Usually tensors are in (direct products of) representations + of the symmetric group; + ``args`` can be a list of lists representing the shapes of Young tableaux + + Notes + ===== + + For instance: + ``[[1]]`` vector + ``[[1]*n]`` symmetric tensor of rank ``n`` + ``[[n]]`` antisymmetric tensor of rank ``n`` + ``[[2, 2]]`` monoterm slot symmetry of the Riemann tensor + ``[[1],[1]]`` vector*vector + ``[[2],[1],[1]`` (antisymmetric tensor)*vector*vector + + Notice that with the shape ``[2, 2]`` we associate only the monoterm + symmetries of the Riemann tensor; this is an abuse of notation, + since the shape ``[2, 2]`` corresponds usually to the irreducible + representation characterized by the monoterm symmetries and by the + cyclic symmetry. + """ + from sympy.combinatorics import Permutation + + def tableau2bsgs(a): + if len(a) == 1: + # antisymmetric vector + n = a[0] + bsgs = get_symmetric_group_sgs(n, 1) + else: + if all(x == 1 for x in a): + # symmetric vector + n = len(a) + bsgs = get_symmetric_group_sgs(n) + elif a == [2, 2]: + bsgs = riemann_bsgs + else: + raise NotImplementedError + return bsgs + + if not args: + return TensorSymmetry(Tuple(), Tuple(Permutation(1))) + + if len(args) == 2 and isinstance(args[1][0], Permutation): + return TensorSymmetry(args) + base, sgs = tableau2bsgs(args[0]) + for a in args[1:]: + basex, sgsx = tableau2bsgs(a) + base, sgs = bsgs_direct_product(base, sgs, basex, sgsx) + return TensorSymmetry(Tuple(base, sgs)) + +@deprecated( + "TensorType is deprecated. Use tensor_heads() instead.", + deprecated_since_version="1.5", + active_deprecations_target="deprecated-tensortype", +) +class TensorType(Basic): + """ + Class of tensor types. Deprecated, use tensor_heads() instead. + + Parameters + ========== + + index_types : list of ``TensorIndexType`` of the tensor indices + symmetry : ``TensorSymmetry`` of the tensor + + Attributes + ========== + + ``index_types`` + ``symmetry`` + ``types`` : list of ``TensorIndexType`` without repetitions + """ + is_commutative = False + + def __new__(cls, index_types, symmetry, **kw_args): + assert symmetry.rank == len(index_types) + obj = Basic.__new__(cls, Tuple(*index_types), symmetry, **kw_args) + return obj + + @property + def index_types(self): + return self.args[0] + + @property + def symmetry(self): + return self.args[1] + + @property + def types(self): + return sorted(set(self.index_types), key=lambda x: x.name) + + def __str__(self): + return 'TensorType(%s)' % ([str(x) for x in self.index_types]) + + def __call__(self, s, comm=0): + """ + Return a TensorHead object or a list of TensorHead objects. + + Parameters + ========== + + s : name or string of names. + + comm : Commutation group. + + see ``_TensorManager.set_comm`` + """ + if isinstance(s, str): + names = [x.name for x in symbols(s, seq=True)] + else: + raise ValueError('expecting a string') + if len(names) == 1: + return TensorHead(names[0], self.index_types, self.symmetry, comm) + else: + return [TensorHead(name, self.index_types, self.symmetry, comm) for name in names] + + +@deprecated( + """ + The tensorhead() function is deprecated. Use tensor_heads() instead. + """, + deprecated_since_version="1.5", + active_deprecations_target="deprecated-tensorhead", +) +def tensorhead(name, typ, sym=None, comm=0): + """ + Function generating tensorhead(s). This method is deprecated, + use TensorHead constructor or tensor_heads() instead. + + Parameters + ========== + + name : name or sequence of names (as in ``symbols``) + + typ : index types + + sym : same as ``*args`` in ``tensorsymmetry`` + + comm : commutation group number + see ``_TensorManager.set_comm`` + """ + if sym is None: + sym = [[1] for i in range(len(typ))] + with ignore_warnings(SymPyDeprecationWarning): + sym = tensorsymmetry(*sym) + return TensorHead(name, typ, sym, comm) + + +class TensorHead(Basic): + """ + Tensor head of the tensor. + + Parameters + ========== + + name : name of the tensor + index_types : list of TensorIndexType + symmetry : TensorSymmetry of the tensor + comm : commutation group number + + Attributes + ========== + + ``name`` + ``index_types`` + ``rank`` : total number of indices + ``symmetry`` + ``comm`` : commutation group + + Notes + ===== + + Similar to ``symbols`` multiple TensorHeads can be created using + ``tensorhead(s, typ, sym=None, comm=0)`` function, where ``s`` + is the string of names and ``sym`` is the monoterm tensor symmetry + (see ``tensorsymmetry``). + + A ``TensorHead`` belongs to a commutation group, defined by a + symbol on number ``comm`` (see ``_TensorManager.set_comm``); + tensors in a commutation group have the same commutation properties; + by default ``comm`` is ``0``, the group of the commuting tensors. + + Examples + ======== + + Define a fully antisymmetric tensor of rank 2: + + >>> from sympy.tensor.tensor import TensorIndexType, TensorHead, TensorSymmetry + >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') + >>> asym2 = TensorSymmetry.fully_symmetric(-2) + >>> A = TensorHead('A', [Lorentz, Lorentz], asym2) + + Examples with ndarray values, the components data assigned to the + ``TensorHead`` object are assumed to be in a fully-contravariant + representation. In case it is necessary to assign components data which + represents the values of a non-fully covariant tensor, see the other + examples. + + >>> from sympy.tensor.tensor import tensor_indices + >>> from sympy import diag + >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') + >>> i0, i1 = tensor_indices('i0:2', Lorentz) + + Specify a replacement dictionary to keep track of the arrays to use for + replacements in the tensorial expression. The ``TensorIndexType`` is + associated to the metric used for contractions (in fully covariant form): + + >>> repl = {Lorentz: diag(1, -1, -1, -1)} + + Let's see some examples of working with components with the electromagnetic + tensor: + + >>> from sympy import symbols + >>> Ex, Ey, Ez, Bx, By, Bz = symbols('E_x E_y E_z B_x B_y B_z') + >>> c = symbols('c', positive=True) + + Let's define `F`, an antisymmetric tensor: + + >>> F = TensorHead('F', [Lorentz, Lorentz], asym2) + + Let's update the dictionary to contain the matrix to use in the + replacements: + + >>> repl.update({F(-i0, -i1): [ + ... [0, Ex/c, Ey/c, Ez/c], + ... [-Ex/c, 0, -Bz, By], + ... [-Ey/c, Bz, 0, -Bx], + ... [-Ez/c, -By, Bx, 0]]}) + + Now it is possible to retrieve the contravariant form of the Electromagnetic + tensor: + + >>> F(i0, i1).replace_with_arrays(repl, [i0, i1]) + [[0, -E_x/c, -E_y/c, -E_z/c], [E_x/c, 0, -B_z, B_y], [E_y/c, B_z, 0, -B_x], [E_z/c, -B_y, B_x, 0]] + + and the mixed contravariant-covariant form: + + >>> F(i0, -i1).replace_with_arrays(repl, [i0, -i1]) + [[0, E_x/c, E_y/c, E_z/c], [E_x/c, 0, B_z, -B_y], [E_y/c, -B_z, 0, B_x], [E_z/c, B_y, -B_x, 0]] + + Energy-momentum of a particle may be represented as: + + >>> from sympy import symbols + >>> P = TensorHead('P', [Lorentz], TensorSymmetry.no_symmetry(1)) + >>> E, px, py, pz = symbols('E p_x p_y p_z', positive=True) + >>> repl.update({P(i0): [E, px, py, pz]}) + + The contravariant and covariant components are, respectively: + + >>> P(i0).replace_with_arrays(repl, [i0]) + [E, p_x, p_y, p_z] + >>> P(-i0).replace_with_arrays(repl, [-i0]) + [E, -p_x, -p_y, -p_z] + + The contraction of a 1-index tensor by itself: + + >>> expr = P(i0)*P(-i0) + >>> expr.replace_with_arrays(repl, []) + E**2 - p_x**2 - p_y**2 - p_z**2 + """ + is_commutative = False + + def __new__(cls, name, index_types, symmetry=None, comm=0): + if isinstance(name, str): + name_symbol = Symbol(name) + elif isinstance(name, Symbol): + name_symbol = name + else: + raise ValueError("invalid name") + + if symmetry is None: + symmetry = TensorSymmetry.no_symmetry(len(index_types)) + else: + assert symmetry.rank == len(index_types) + + obj = Basic.__new__(cls, name_symbol, Tuple(*index_types), symmetry) + obj.comm = TensorManager.comm_symbols2i(comm) + return obj + + @property + def name(self): + return self.args[0].name + + @property + def index_types(self): + return list(self.args[1]) + + @property + def symmetry(self): + return self.args[2] + + @property + def rank(self): + return len(self.index_types) + + def __lt__(self, other): + return (self.name, self.index_types) < (other.name, other.index_types) + + def commutes_with(self, other): + """ + Returns ``0`` if ``self`` and ``other`` commute, ``1`` if they anticommute. + + Returns ``None`` if ``self`` and ``other`` neither commute nor anticommute. + """ + r = TensorManager.get_comm(self.comm, other.comm) + return r + + def _print(self): + return '%s(%s)' %(self.name, ','.join([str(x) for x in self.index_types])) + + def __call__(self, *indices, **kw_args): + """ + Returns a tensor with indices. + + Explanation + =========== + + There is a special behavior in case of indices denoted by ``True``, + they are considered auto-matrix indices, their slots are automatically + filled, and confer to the tensor the behavior of a matrix or vector + upon multiplication with another tensor containing auto-matrix indices + of the same ``TensorIndexType``. This means indices get summed over the + same way as in matrix multiplication. For matrix behavior, define two + auto-matrix indices, for vector behavior define just one. + + Indices can also be strings, in which case the attribute + ``index_types`` is used to convert them to proper ``TensorIndex``. + + Examples + ======== + + >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, TensorSymmetry, TensorHead + >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') + >>> a, b = tensor_indices('a,b', Lorentz) + >>> A = TensorHead('A', [Lorentz]*2, TensorSymmetry.no_symmetry(2)) + >>> t = A(a, -b) + >>> t + A(a, -b) + + """ + + updated_indices = [] + for idx, typ in zip(indices, self.index_types): + if isinstance(idx, str): + idx = idx.strip().replace(" ", "") + if idx.startswith('-'): + updated_indices.append(TensorIndex(idx[1:], typ, + is_up=False)) + else: + updated_indices.append(TensorIndex(idx, typ)) + else: + updated_indices.append(idx) + + updated_indices += indices[len(updated_indices):] + + tensor = Tensor(self, updated_indices, **kw_args) + return tensor.doit() + + # Everything below this line is deprecated + + def __pow__(self, other): + deprecate_data() + with ignore_warnings(SymPyDeprecationWarning): + if self.data is None: + raise ValueError("No power on abstract tensors.") + from .array import tensorproduct, tensorcontraction + metrics = [_.data for _ in self.index_types] + + marray = self.data + marraydim = marray.rank() + for metric in metrics: + marray = tensorproduct(marray, metric, marray) + marray = tensorcontraction(marray, (0, marraydim), (marraydim+1, marraydim+2)) + + return marray ** (other * S.Half) + + @property + def data(self): + deprecate_data() + with ignore_warnings(SymPyDeprecationWarning): + return _tensor_data_substitution_dict[self] + + @data.setter + def data(self, data): + deprecate_data() + with ignore_warnings(SymPyDeprecationWarning): + _tensor_data_substitution_dict[self] = data + + @data.deleter + def data(self): + deprecate_data() + if self in _tensor_data_substitution_dict: + del _tensor_data_substitution_dict[self] + + def __iter__(self): + deprecate_data() + with ignore_warnings(SymPyDeprecationWarning): + return self.data.__iter__() + + def _components_data_full_destroy(self): + """ + EXPERIMENTAL: do not rely on this API method. + + Destroy components data associated to the ``TensorHead`` object, this + checks for attached components data, and destroys components data too. + """ + # do not garbage collect Kronecker tensor (it should be done by + # ``TensorIndexType`` garbage collection) + deprecate_data() + if self.name == "KD": + return + + # the data attached to a tensor must be deleted only by the TensorHead + # destructor. If the TensorHead is deleted, it means that there are no + # more instances of that tensor anywhere. + if self in _tensor_data_substitution_dict: + del _tensor_data_substitution_dict[self] + + +def tensor_heads(s, index_types, symmetry=None, comm=0): + """ + Returns a sequence of TensorHeads from a string `s` + """ + if isinstance(s, str): + names = [x.name for x in symbols(s, seq=True)] + else: + raise ValueError('expecting a string') + + thlist = [TensorHead(name, index_types, symmetry, comm) for name in names] + if len(thlist) == 1: + return thlist[0] + return thlist + + +class TensExpr(Expr, ABC): + """ + Abstract base class for tensor expressions + + Notes + ===== + + A tensor expression is an expression formed by tensors; + currently the sums of tensors are distributed. + + A ``TensExpr`` can be a ``TensAdd`` or a ``TensMul``. + + ``TensMul`` objects are formed by products of component tensors, + and include a coefficient, which is a SymPy expression. + + + In the internal representation contracted indices are represented + by ``(ipos1, ipos2, icomp1, icomp2)``, where ``icomp1`` is the position + of the component tensor with contravariant index, ``ipos1`` is the + slot which the index occupies in that component tensor. + + Contracted indices are therefore nameless in the internal representation. + """ + + _op_priority = 12.0 + is_commutative = False + + def __neg__(self): + return self*S.NegativeOne + + def __abs__(self): + raise NotImplementedError + + def __add__(self, other): + return TensAdd(self, other).doit() + + def __radd__(self, other): + return TensAdd(other, self).doit() + + def __sub__(self, other): + return TensAdd(self, -other).doit() + + def __rsub__(self, other): + return TensAdd(other, -self).doit() + + def __mul__(self, other): + """ + Multiply two tensors using Einstein summation convention. + + Explanation + =========== + + If the two tensors have an index in common, one contravariant + and the other covariant, in their product the indices are summed + + Examples + ======== + + >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensor_heads + >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') + >>> m0, m1, m2 = tensor_indices('m0,m1,m2', Lorentz) + >>> g = Lorentz.metric + >>> p, q = tensor_heads('p,q', [Lorentz]) + >>> t1 = p(m0) + >>> t2 = q(-m0) + >>> t1*t2 + p(L_0)*q(-L_0) + """ + return TensMul(self, other).doit() + + def __rmul__(self, other): + return TensMul(other, self).doit() + + def __truediv__(self, other): + other = _sympify(other) + if isinstance(other, TensExpr): + raise ValueError('cannot divide by a tensor') + return TensMul(self, S.One/other).doit() + + def __rtruediv__(self, other): + raise ValueError('cannot divide by a tensor') + + def __pow__(self, other): + deprecate_data() + with ignore_warnings(SymPyDeprecationWarning): + if self.data is None: + raise ValueError("No power without ndarray data.") + from .array import tensorproduct, tensorcontraction + free = self.free + marray = self.data + mdim = marray.rank() + for metric in free: + marray = tensorcontraction( + tensorproduct( + marray, + metric[0].tensor_index_type.data, + marray), + (0, mdim), (mdim+1, mdim+2) + ) + return marray ** (other * S.Half) + + def __rpow__(self, other): + raise NotImplementedError + + @property + @abstractmethod + def nocoeff(self): + raise NotImplementedError("abstract method") + + @property + @abstractmethod + def coeff(self): + raise NotImplementedError("abstract method") + + @abstractmethod + def get_indices(self): + raise NotImplementedError("abstract method") + + @abstractmethod + def get_free_indices(self) -> list[TensorIndex]: + raise NotImplementedError("abstract method") + + @abstractmethod + def _replace_indices(self, repl: dict[TensorIndex, TensorIndex]) -> TensExpr: + raise NotImplementedError("abstract method") + + def fun_eval(self, *index_tuples): + deprecate_fun_eval() + return self.substitute_indices(*index_tuples) + + def get_matrix(self): + """ + DEPRECATED: do not use. + + Returns ndarray components data as a matrix, if components data are + available and ndarray dimension does not exceed 2. + """ + from sympy.matrices.dense import Matrix + deprecate_data() + with ignore_warnings(SymPyDeprecationWarning): + if 0 < self.rank <= 2: + rows = self.data.shape[0] + columns = self.data.shape[1] if self.rank == 2 else 1 + if self.rank == 2: + mat_list = [] * rows + for i in range(rows): + mat_list.append([]) + for j in range(columns): + mat_list[i].append(self[i, j]) + else: + mat_list = [None] * rows + for i in range(rows): + mat_list[i] = self[i] + return Matrix(mat_list) + else: + raise NotImplementedError( + "missing multidimensional reduction to matrix.") + + @staticmethod + def _get_indices_permutation(indices1, indices2): + return [indices1.index(i) for i in indices2] + + def expand(self, **hints): + return _expand(self, **hints).doit() + + def _expand(self, **kwargs): + return self + + def _get_free_indices_set(self): + indset = set() + for arg in self.args: + if isinstance(arg, TensExpr): + indset.update(arg._get_free_indices_set()) + return indset + + def _get_dummy_indices_set(self): + indset = set() + for arg in self.args: + if isinstance(arg, TensExpr): + indset.update(arg._get_dummy_indices_set()) + return indset + + def _get_indices_set(self): + indset = set() + for arg in self.args: + if isinstance(arg, TensExpr): + indset.update(arg._get_indices_set()) + return indset + + @property + def _iterate_dummy_indices(self): + dummy_set = self._get_dummy_indices_set() + + def recursor(expr, pos): + if isinstance(expr, TensorIndex): + if expr in dummy_set: + yield (expr, pos) + elif isinstance(expr, (Tuple, TensExpr)): + for p, arg in enumerate(expr.args): + yield from recursor(arg, pos+(p,)) + + return recursor(self, ()) + + @property + def _iterate_free_indices(self): + free_set = self._get_free_indices_set() + + def recursor(expr, pos): + if isinstance(expr, TensorIndex): + if expr in free_set: + yield (expr, pos) + elif isinstance(expr, (Tuple, TensExpr)): + for p, arg in enumerate(expr.args): + yield from recursor(arg, pos+(p,)) + + return recursor(self, ()) + + @property + def _iterate_indices(self): + def recursor(expr, pos): + if isinstance(expr, TensorIndex): + yield (expr, pos) + elif isinstance(expr, (Tuple, TensExpr)): + for p, arg in enumerate(expr.args): + yield from recursor(arg, pos+(p,)) + + return recursor(self, ()) + + @staticmethod + def _contract_and_permute_with_metric(metric, array, pos, dim): + # TODO: add possibility of metric after (spinors) + from .array import tensorcontraction, tensorproduct, permutedims + + array = tensorcontraction(tensorproduct(metric, array), (1, 2+pos)) + permu = list(range(dim)) + permu[0], permu[pos] = permu[pos], permu[0] + return permutedims(array, permu) + + @staticmethod + def _match_indices_with_other_tensor(array, free_ind1, free_ind2, replacement_dict): + from .array import permutedims + + index_types1 = [i.tensor_index_type for i in free_ind1] + + # Check if variance of indices needs to be fixed: + pos2up = [] + pos2down = [] + free2remaining = free_ind2[:] + for pos1, index1 in enumerate(free_ind1): + if index1 in free2remaining: + pos2 = free2remaining.index(index1) + free2remaining[pos2] = None + continue + if -index1 in free2remaining: + pos2 = free2remaining.index(-index1) + free2remaining[pos2] = None + free_ind2[pos2] = index1 + if index1.is_up: + pos2up.append(pos2) + else: + pos2down.append(pos2) + else: + index2 = free2remaining[pos1] + if index2 is None: + raise ValueError("incompatible indices: %s and %s" % (free_ind1, free_ind2)) + free2remaining[pos1] = None + free_ind2[pos1] = index1 + if index1.is_up ^ index2.is_up: + if index1.is_up: + pos2up.append(pos1) + else: + pos2down.append(pos1) + + if len(set(free_ind1) & set(free_ind2)) < len(free_ind1): + raise ValueError("incompatible indices: %s and %s" % (free_ind1, free_ind2)) + + # Raise indices: + for pos in pos2up: + index_type_pos = index_types1[pos] + if index_type_pos not in replacement_dict: + raise ValueError("No metric provided to lower index") + metric = replacement_dict[index_type_pos] + metric_inverse = _TensorDataLazyEvaluator.inverse_matrix(metric) + array = TensExpr._contract_and_permute_with_metric(metric_inverse, array, pos, len(free_ind1)) + # Lower indices: + for pos in pos2down: + index_type_pos = index_types1[pos] + if index_type_pos not in replacement_dict: + raise ValueError("No metric provided to lower index") + metric = replacement_dict[index_type_pos] + array = TensExpr._contract_and_permute_with_metric(metric, array, pos, len(free_ind1)) + + if free_ind1: + permutation = TensExpr._get_indices_permutation(free_ind2, free_ind1) + array = permutedims(array, permutation) + + if hasattr(array, "rank") and array.rank() == 0: + array = array[()] + + return free_ind2, array + + def replace_with_arrays(self, replacement_dict, indices=None): + """ + Replace the tensorial expressions with arrays. The final array will + correspond to the N-dimensional array with indices arranged according + to ``indices``. + + Parameters + ========== + + replacement_dict + dictionary containing the replacement rules for tensors. + indices + the index order with respect to which the array is read. The + original index order will be used if no value is passed. + + Examples + ======== + + >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices + >>> from sympy.tensor.tensor import TensorHead + >>> from sympy import symbols, diag + + >>> L = TensorIndexType("L") + >>> i, j = tensor_indices("i j", L) + >>> A = TensorHead("A", [L]) + >>> A(i).replace_with_arrays({A(i): [1, 2]}, [i]) + [1, 2] + + Since 'indices' is optional, we can also call replace_with_arrays by + this way if no specific index order is needed: + + >>> A(i).replace_with_arrays({A(i): [1, 2]}) + [1, 2] + + >>> expr = A(i)*A(j) + >>> expr.replace_with_arrays({A(i): [1, 2]}) + [[1, 2], [2, 4]] + + For contractions, specify the metric of the ``TensorIndexType``, which + in this case is ``L``, in its covariant form: + + >>> expr = A(i)*A(-i) + >>> expr.replace_with_arrays({A(i): [1, 2], L: diag(1, -1)}) + -3 + + Symmetrization of an array: + + >>> H = TensorHead("H", [L, L]) + >>> a, b, c, d = symbols("a b c d") + >>> expr = H(i, j)/2 + H(j, i)/2 + >>> expr.replace_with_arrays({H(i, j): [[a, b], [c, d]]}) + [[a, b/2 + c/2], [b/2 + c/2, d]] + + Anti-symmetrization of an array: + + >>> expr = H(i, j)/2 - H(j, i)/2 + >>> repl = {H(i, j): [[a, b], [c, d]]} + >>> expr.replace_with_arrays(repl) + [[0, b/2 - c/2], [-b/2 + c/2, 0]] + + The same expression can be read as the transpose by inverting ``i`` and + ``j``: + + >>> expr.replace_with_arrays(repl, [j, i]) + [[0, -b/2 + c/2], [b/2 - c/2, 0]] + """ + from .array import Array + + indices = indices or [] + remap = {k.args[0] if k.is_up else -k.args[0]: k for k in self.get_free_indices()} + for i, index in enumerate(indices): + if isinstance(index, (Symbol, Mul)): + if index in remap: + indices[i] = remap[index] + else: + indices[i] = -remap[-index] + + replacement_dict = {tensor: Array(array) for tensor, array in replacement_dict.items()} + + # Check dimensions of replaced arrays: + for tensor, array in replacement_dict.items(): + if isinstance(tensor, TensorIndexType): + expected_shape = [tensor.dim for i in range(2)] + else: + expected_shape = [index_type.dim for index_type in tensor.index_types] + if len(expected_shape) != array.rank() or (not all(dim1 == dim2 if + dim1.is_number else True for dim1, dim2 in zip(expected_shape, + array.shape))): + raise ValueError("shapes for tensor %s expected to be %s, "\ + "replacement array shape is %s" % (tensor, expected_shape, + array.shape)) + + ret_indices, array = self._extract_data(replacement_dict) + + last_indices, array = self._match_indices_with_other_tensor(array, indices, ret_indices, replacement_dict) + return array + + def _check_add_Sum(self, expr, index_symbols): + from sympy.concrete.summations import Sum + indices = self.get_indices() + dum = self.dum + sum_indices = [ (index_symbols[i], 0, + indices[i].tensor_index_type.dim-1) for i, j in dum] + if sum_indices: + expr = Sum(expr, *sum_indices) + return expr + + def _expand_partial_derivative(self): + # simply delegate the _expand_partial_derivative() to + # its arguments to expand a possibly found PartialDerivative + return self.func(*[ + a._expand_partial_derivative() + if isinstance(a, TensExpr) else a + for a in self.args]) + + +class TensAdd(TensExpr, AssocOp): + """ + Sum of tensors. + + Parameters + ========== + + free_args : list of the free indices + + Attributes + ========== + + ``args`` : tuple of addends + ``rank`` : rank of the tensor + ``free_args`` : list of the free indices in sorted order + + Examples + ======== + + >>> from sympy.tensor.tensor import TensorIndexType, tensor_heads, tensor_indices + >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') + >>> a, b = tensor_indices('a,b', Lorentz) + >>> p, q = tensor_heads('p,q', [Lorentz]) + >>> t = p(a) + q(a); t + p(a) + q(a) + + Examples with components data added to the tensor expression: + + >>> from sympy import symbols, diag + >>> x, y, z, t = symbols("x y z t") + >>> repl = {} + >>> repl[Lorentz] = diag(1, -1, -1, -1) + >>> repl[p(a)] = [1, 2, 3, 4] + >>> repl[q(a)] = [x, y, z, t] + + The following are: 2**2 - 3**2 - 2**2 - 7**2 ==> -58 + + >>> expr = p(a) + q(a) + >>> expr.replace_with_arrays(repl, [a]) + [x + 1, y + 2, z + 3, t + 4] + """ + + def __new__(cls, *args, **kw_args): + args = [_sympify(x) for x in args if x] + args = TensAdd._tensAdd_flatten(args) + args.sort(key=default_sort_key) + if not args: + return S.Zero + if len(args) == 1: + return args[0] + + return Basic.__new__(cls, *args, **kw_args) + + @property + def coeff(self): + return S.One + + @property + def nocoeff(self): + return self + + def get_free_indices(self) -> list[TensorIndex]: + return self.free_indices + + def _replace_indices(self, repl: dict[TensorIndex, TensorIndex]) -> TensExpr: + newargs = [arg._replace_indices(repl) if isinstance(arg, TensExpr) else arg for arg in self.args] + return self.func(*newargs) + + @memoize_property + def rank(self): + if isinstance(self.args[0], TensExpr): + return self.args[0].rank + else: + return 0 + + @memoize_property + def free_args(self): + if isinstance(self.args[0], TensExpr): + return self.args[0].free_args + else: + return [] + + @memoize_property + def free_indices(self): + if isinstance(self.args[0], TensExpr): + return self.args[0].get_free_indices() + else: + return set() + + def doit(self, **hints): + deep = hints.get('deep', True) + if deep: + args = [arg.doit(**hints) for arg in self.args] + else: + args = self.args + + # if any of the args are zero (after doit), drop them. Otherwise, _tensAdd_check will complain about non-matching indices, even though the TensAdd is correctly formed. + args = [arg for arg in args if arg != S.Zero] + + if len(args) == 0: + return S.Zero + elif len(args) == 1: + return args[0] + + # now check that all addends have the same indices: + TensAdd._tensAdd_check(args) + + # Collect terms appearing more than once, differing by their coefficients: + args = TensAdd._tensAdd_collect_terms(args) + + # collect canonicalized terms + def sort_key(t): + if not isinstance(t, TensExpr): + return [], [], [] + if hasattr(t, "_index_structure") and hasattr(t, "components"): + x = get_index_structure(t) + return t.components, x.free, x.dum + return [], [], [] + args.sort(key=sort_key) + + if not args: + return S.Zero + # it there is only a component tensor return it + if len(args) == 1: + return args[0] + + obj = self.func(*args) + return obj + + @staticmethod + def _tensAdd_flatten(args): + # flatten TensAdd, coerce terms which are not tensors to tensors + a = [] + for x in args: + if isinstance(x, (Add, TensAdd)): + a.extend(list(x.args)) + else: + a.append(x) + args = [x for x in a if x.coeff] + return args + + @staticmethod + def _tensAdd_check(args): + # check that all addends have the same free indices + + def get_indices_set(x: Expr) -> set[TensorIndex]: + if isinstance(x, TensExpr): + return set(x.get_free_indices()) + return set() + + indices0 = get_indices_set(args[0]) + list_indices = [get_indices_set(arg) for arg in args[1:]] + if not all(x == indices0 for x in list_indices): + raise ValueError('all tensors must have the same indices') + + @staticmethod + def _tensAdd_collect_terms(args): + # collect TensMul terms differing at most by their coefficient + terms_dict = defaultdict(list) + scalars = S.Zero + if isinstance(args[0], TensExpr): + free_indices = set(args[0].get_free_indices()) + else: + free_indices = set() + + for arg in args: + if not isinstance(arg, TensExpr): + if free_indices != set(): + raise ValueError("wrong valence") + scalars += arg + continue + if free_indices != set(arg.get_free_indices()): + raise ValueError("wrong valence") + # TODO: what is the part which is not a coeff? + # needs an implementation similar to .as_coeff_Mul() + terms_dict[arg.nocoeff].append(arg.coeff) + + new_args = [TensMul(Add(*coeff), t).doit() for t, coeff in terms_dict.items() if Add(*coeff) != 0] + if isinstance(scalars, Add): + new_args = list(scalars.args) + new_args + elif scalars != 0: + new_args = [scalars] + new_args + return new_args + + def get_indices(self): + indices = [] + for arg in self.args: + indices.extend([i for i in get_indices(arg) if i not in indices]) + return indices + + def _expand(self, **hints): + return TensAdd(*[_expand(i, **hints) for i in self.args]) + + def __call__(self, *indices): + deprecate_call() + free_args = self.free_args + indices = list(indices) + if [x.tensor_index_type for x in indices] != [x.tensor_index_type for x in free_args]: + raise ValueError('incompatible types') + if indices == free_args: + return self + index_tuples = list(zip(free_args, indices)) + a = [x.func(*x.substitute_indices(*index_tuples).args) for x in self.args] + res = TensAdd(*a).doit() + return res + + def canon_bp(self): + """ + Canonicalize using the Butler-Portugal algorithm for canonicalization + under monoterm symmetries. + """ + expr = self.expand() + args = [canon_bp(x) for x in expr.args] + res = TensAdd(*args).doit() + return res + + def equals(self, other): + other = _sympify(other) + if isinstance(other, TensMul) and other.coeff == 0: + return all(x.coeff == 0 for x in self.args) + if isinstance(other, TensExpr): + if self.rank != other.rank: + return False + if isinstance(other, TensAdd): + if set(self.args) != set(other.args): + return False + else: + return True + t = self - other + if not isinstance(t, TensExpr): + return t == 0 + else: + if isinstance(t, TensMul): + return t.coeff == 0 + else: + return all(x.coeff == 0 for x in t.args) + + def __getitem__(self, item): + deprecate_data() + with ignore_warnings(SymPyDeprecationWarning): + return self.data[item] + + def contract_delta(self, delta): + args = [x.contract_delta(delta) for x in self.args] + t = TensAdd(*args).doit() + return canon_bp(t) + + def contract_metric(self, g): + """ + Raise or lower indices with the metric ``g``. + + Parameters + ========== + + g : metric + + contract_all : if True, eliminate all ``g`` which are contracted + + Notes + ===== + + see the ``TensorIndexType`` docstring for the contraction conventions + """ + + args = [contract_metric(x, g) for x in self.args] + t = TensAdd(*args).doit() + return canon_bp(t) + + def substitute_indices(self, *index_tuples): + new_args = [] + for arg in self.args: + if isinstance(arg, TensExpr): + arg = arg.substitute_indices(*index_tuples) + new_args.append(arg) + return TensAdd(*new_args).doit() + + def _print(self): + a = [] + args = self.args + for x in args: + a.append(str(x)) + s = ' + '.join(a) + s = s.replace('+ -', '- ') + return s + + def _extract_data(self, replacement_dict): + from sympy.tensor.array import Array, permutedims + args_indices, arrays = zip(*[ + arg._extract_data(replacement_dict) if + isinstance(arg, TensExpr) else ([], arg) for arg in self.args + ]) + arrays = [Array(i) for i in arrays] + ref_indices = args_indices[0] + for i in range(1, len(args_indices)): + indices = args_indices[i] + array = arrays[i] + permutation = TensMul._get_indices_permutation(indices, ref_indices) + arrays[i] = permutedims(array, permutation) + return ref_indices, sum(arrays, Array.zeros(*array.shape)) + + @property + def data(self): + deprecate_data() + with ignore_warnings(SymPyDeprecationWarning): + return _tensor_data_substitution_dict[self.expand()] + + @data.setter + def data(self, data): + deprecate_data() + with ignore_warnings(SymPyDeprecationWarning): + _tensor_data_substitution_dict[self] = data + + @data.deleter + def data(self): + deprecate_data() + with ignore_warnings(SymPyDeprecationWarning): + if self in _tensor_data_substitution_dict: + del _tensor_data_substitution_dict[self] + + def __iter__(self): + deprecate_data() + if not self.data: + raise ValueError("No iteration on abstract tensors") + return self.data.flatten().__iter__() + + def _eval_rewrite_as_Indexed(self, *args): + return Add.fromiter(args) + + def _eval_partial_derivative(self, s): + # Evaluation like Add + list_addends = [] + for a in self.args: + if isinstance(a, TensExpr): + list_addends.append(a._eval_partial_derivative(s)) + # do not call diff if s is no symbol + elif s._diff_wrt: + list_addends.append(a._eval_derivative(s)) + + return self.func(*list_addends) + + +class Tensor(TensExpr): + """ + Base tensor class, i.e. this represents a tensor, the single unit to be + put into an expression. + + Explanation + =========== + + This object is usually created from a ``TensorHead``, by attaching indices + to it. Indices preceded by a minus sign are considered contravariant, + otherwise covariant. + + Examples + ======== + + >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, TensorHead + >>> Lorentz = TensorIndexType("Lorentz", dummy_name="L") + >>> mu, nu = tensor_indices('mu nu', Lorentz) + >>> A = TensorHead("A", [Lorentz, Lorentz]) + >>> A(mu, -nu) + A(mu, -nu) + >>> A(mu, -mu) + A(L_0, -L_0) + + It is also possible to use symbols instead of inidices (appropriate indices + are then generated automatically). + + >>> from sympy import Symbol + >>> x = Symbol('x') + >>> A(x, mu) + A(x, mu) + >>> A(x, -x) + A(L_0, -L_0) + + """ + + is_commutative = False + + _index_structure = None # type: _IndexStructure + args: tuple[TensorHead, Tuple] + + def __new__(cls, tensor_head, indices, *, is_canon_bp=False, **kw_args): + indices = cls._parse_indices(tensor_head, indices) + obj = Basic.__new__(cls, tensor_head, Tuple(*indices), **kw_args) + obj._index_structure = _IndexStructure.from_indices(*indices) + obj._free = obj._index_structure.free[:] + obj._dum = obj._index_structure.dum[:] + obj._ext_rank = obj._index_structure._ext_rank + obj._coeff = S.One + obj._nocoeff = obj + obj._component = tensor_head + obj._components = [tensor_head] + if tensor_head.rank != len(indices): + raise ValueError("wrong number of indices") + obj.is_canon_bp = is_canon_bp + obj._index_map = Tensor._build_index_map(indices, obj._index_structure) + return obj + + @property + def free(self): + return self._free + + @property + def dum(self): + return self._dum + + @property + def ext_rank(self): + return self._ext_rank + + @property + def coeff(self): + return self._coeff + + @property + def nocoeff(self): + return self._nocoeff + + @property + def component(self): + return self._component + + @property + def components(self): + return self._components + + @property + def head(self): + return self.args[0] + + @property + def indices(self): + return self.args[1] + + @property + def free_indices(self): + return set(self._index_structure.get_free_indices()) + + @property + def index_types(self): + return self.head.index_types + + @property + def rank(self): + return len(self.free_indices) + + @staticmethod + def _build_index_map(indices, index_structure): + index_map = {} + for idx in indices: + index_map[idx] = (indices.index(idx),) + return index_map + + def doit(self, **hints): + args, indices, free, dum = TensMul._tensMul_contract_indices([self]) + return args[0] + + @staticmethod + def _parse_indices(tensor_head, indices): + if not isinstance(indices, (tuple, list, Tuple)): + raise TypeError("indices should be an array, got %s" % type(indices)) + indices = list(indices) + for i, index in enumerate(indices): + if isinstance(index, Symbol): + indices[i] = TensorIndex(index, tensor_head.index_types[i], True) + elif isinstance(index, Mul): + c, e = index.as_coeff_Mul() + if c == -1 and isinstance(e, Symbol): + indices[i] = TensorIndex(e, tensor_head.index_types[i], False) + else: + raise ValueError("index not understood: %s" % index) + elif not isinstance(index, TensorIndex): + raise TypeError("wrong type for index: %s is %s" % (index, type(index))) + return indices + + def _set_new_index_structure(self, im, is_canon_bp=False): + indices = im.get_indices() + return self._set_indices(*indices, is_canon_bp=is_canon_bp) + + def _set_indices(self, *indices, is_canon_bp=False, **kw_args): + if len(indices) != self.ext_rank: + raise ValueError("indices length mismatch") + return self.func(self.args[0], indices, is_canon_bp=is_canon_bp).doit() + + def _get_free_indices_set(self): + return {i[0] for i in self._index_structure.free} + + def _get_dummy_indices_set(self): + dummy_pos = set(itertools.chain(*self._index_structure.dum)) + return {idx for i, idx in enumerate(self.args[1]) if i in dummy_pos} + + def _get_indices_set(self): + return set(self.args[1].args) + + @property + def free_in_args(self): + return [(ind, pos, 0) for ind, pos in self.free] + + @property + def dum_in_args(self): + return [(p1, p2, 0, 0) for p1, p2 in self.dum] + + @property + def free_args(self): + return sorted([x[0] for x in self.free]) + + def commutes_with(self, other): + """ + :param other: + :return: + 0 commute + 1 anticommute + None neither commute nor anticommute + """ + if not isinstance(other, TensExpr): + return 0 + elif isinstance(other, Tensor): + return self.component.commutes_with(other.component) + return NotImplementedError + + def perm2tensor(self, g, is_canon_bp=False): + """ + Returns the tensor corresponding to the permutation ``g``. + + For further details, see the method in ``TIDS`` with the same name. + """ + return perm2tensor(self, g, is_canon_bp) + + def canon_bp(self): + if self.is_canon_bp: + return self + expr = self.expand() + g, dummies, msym = expr._index_structure.indices_canon_args() + v = components_canon_args([expr.component]) + can = canonicalize(g, dummies, msym, *v) + if can == 0: + return S.Zero + tensor = self.perm2tensor(can, True) + return tensor + + def split(self): + return [self] + + def _expand(self, **kwargs): + return self + + def sorted_components(self): + return self + + def get_indices(self) -> list[TensorIndex]: + """ + Get a list of indices, corresponding to those of the tensor. + """ + return list(self.args[1]) + + def get_free_indices(self) -> list[TensorIndex]: + """ + Get a list of free indices, corresponding to those of the tensor. + """ + return self._index_structure.get_free_indices() + + def _replace_indices(self, repl: dict[TensorIndex, TensorIndex]) -> TensExpr: + # TODO: this could be optimized by only swapping the indices + # instead of visiting the whole expression tree: + return self.xreplace(repl) + + def as_base_exp(self): + return self, S.One + + def substitute_indices(self, *index_tuples): + """ + Return a tensor with free indices substituted according to ``index_tuples``. + + ``index_types`` list of tuples ``(old_index, new_index)``. + + Examples + ======== + + >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensor_heads, TensorSymmetry + >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') + >>> i, j, k, l = tensor_indices('i,j,k,l', Lorentz) + >>> A, B = tensor_heads('A,B', [Lorentz]*2, TensorSymmetry.fully_symmetric(2)) + >>> t = A(i, k)*B(-k, -j); t + A(i, L_0)*B(-L_0, -j) + >>> t.substitute_indices((i, k),(-j, l)) + A(k, L_0)*B(-L_0, l) + """ + indices = [] + for index in self.indices: + for ind_old, ind_new in index_tuples: + if (index.name == ind_old.name and index.tensor_index_type == + ind_old.tensor_index_type): + if index.is_up == ind_old.is_up: + indices.append(ind_new) + else: + indices.append(-ind_new) + break + else: + indices.append(index) + return self.head(*indices) + + def __call__(self, *indices): + deprecate_call() + free_args = self.free_args + indices = list(indices) + if [x.tensor_index_type for x in indices] != [x.tensor_index_type for x in free_args]: + raise ValueError('incompatible types') + if indices == free_args: + return self + t = self.substitute_indices(*list(zip(free_args, indices))) + + # object is rebuilt in order to make sure that all contracted indices + # get recognized as dummies, but only if there are contracted indices. + if len({i if i.is_up else -i for i in indices}) != len(indices): + return t.func(*t.args) + return t + + # TODO: put this into TensExpr? + def __iter__(self): + deprecate_data() + with ignore_warnings(SymPyDeprecationWarning): + return self.data.__iter__() + + # TODO: put this into TensExpr? + def __getitem__(self, item): + deprecate_data() + with ignore_warnings(SymPyDeprecationWarning): + return self.data[item] + + def _extract_data(self, replacement_dict): + from .array import Array + for k, v in replacement_dict.items(): + if isinstance(k, Tensor) and k.args[0] == self.args[0]: + other = k + array = v + break + else: + raise ValueError("%s not found in %s" % (self, replacement_dict)) + + # TODO: inefficient, this should be done at root level only: + replacement_dict = {k: Array(v) for k, v in replacement_dict.items()} + array = Array(array) + + dum1 = self.dum + dum2 = other.dum + + if len(dum2) > 0: + for pair in dum2: + # allow `dum2` if the contained values are also in `dum1`. + if pair not in dum1: + raise NotImplementedError("%s with contractions is not implemented" % other) + # Remove elements in `dum2` from `dum1`: + dum1 = [pair for pair in dum1 if pair not in dum2] + if len(dum1) > 0: + indices1 = self.get_indices() + indices2 = other.get_indices() + repl = {} + for p1, p2 in dum1: + repl[indices2[p2]] = -indices2[p1] + for pos in (p1, p2): + if indices1[pos].is_up ^ indices2[pos].is_up: + metric = replacement_dict[indices1[pos].tensor_index_type] + if indices1[pos].is_up: + metric = _TensorDataLazyEvaluator.inverse_matrix(metric) + array = self._contract_and_permute_with_metric(metric, array, pos, len(indices2)) + other = other.xreplace(repl).doit() + array = _TensorDataLazyEvaluator.data_contract_dum([array], dum1, len(indices2)) + + free_ind1 = self.get_free_indices() + free_ind2 = other.get_free_indices() + + return self._match_indices_with_other_tensor(array, free_ind1, free_ind2, replacement_dict) + + @property + def data(self): + deprecate_data() + with ignore_warnings(SymPyDeprecationWarning): + return _tensor_data_substitution_dict[self] + + @data.setter + def data(self, data): + deprecate_data() + # TODO: check data compatibility with properties of tensor. + with ignore_warnings(SymPyDeprecationWarning): + _tensor_data_substitution_dict[self] = data + + @data.deleter + def data(self): + deprecate_data() + with ignore_warnings(SymPyDeprecationWarning): + if self in _tensor_data_substitution_dict: + del _tensor_data_substitution_dict[self] + if self.metric in _tensor_data_substitution_dict: + del _tensor_data_substitution_dict[self.metric] + + def _print(self): + indices = [str(ind) for ind in self.indices] + component = self.component + if component.rank > 0: + return ('%s(%s)' % (component.name, ', '.join(indices))) + else: + return ('%s' % component.name) + + def equals(self, other): + if other == 0: + return self.coeff == 0 + other = _sympify(other) + if not isinstance(other, TensExpr): + assert not self.components + return S.One == other + + def _get_compar_comp(self): + t = self.canon_bp() + r = (t.coeff, tuple(t.components), \ + tuple(sorted(t.free)), tuple(sorted(t.dum))) + return r + + return _get_compar_comp(self) == _get_compar_comp(other) + + def contract_metric(self, g): + # if metric is not the same, ignore this step: + if self.component != g: + return self + # in case there are free components, do not perform anything: + if len(self.free) != 0: + return self + + #antisym = g.index_types[0].metric_antisym + if g.symmetry == TensorSymmetry.fully_symmetric(-2): + antisym = 1 + elif g.symmetry == TensorSymmetry.fully_symmetric(2): + antisym = 0 + elif g.symmetry == TensorSymmetry.no_symmetry(2): + antisym = None + else: + raise NotImplementedError + sign = S.One + typ = g.index_types[0] + + if not antisym: + # g(i, -i) + sign = sign*typ.dim + else: + # g(i, -i) + sign = sign*typ.dim + + dp0, dp1 = self.dum[0] + if dp0 < dp1: + # g(i, -i) = -D with antisymmetric metric + sign = -sign + + return sign + + def contract_delta(self, metric): + return self.contract_metric(metric) + + def _eval_rewrite_as_Indexed(self, tens, indices): + from sympy.tensor.indexed import Indexed + # TODO: replace .args[0] with .name: + index_symbols = [i.args[0] for i in self.get_indices()] + expr = Indexed(tens.args[0], *index_symbols) + return self._check_add_Sum(expr, index_symbols) + + def _eval_partial_derivative(self, s): # type: (Tensor) -> Expr + + if not isinstance(s, Tensor): + return S.Zero + else: + + # @a_i/@a_k = delta_i^k + # @a_i/@a^k = g_ij delta^j_k + # @a^i/@a^k = delta^i_k + # @a^i/@a_k = g^ij delta_j^k + # TODO: if there is no metric present, the derivative should be zero? + + if self.head != s.head: + return S.Zero + + # if heads are the same, provide delta and/or metric products + # for every free index pair in the appropriate tensor + # assumed that the free indices are in proper order + # A contravariante index in the derivative becomes covariant + # after performing the derivative and vice versa + + kronecker_delta_list = [1] + + # not guarantee a correct index order + + for (count, (iself, iother)) in enumerate(zip(self.get_free_indices(), s.get_free_indices())): + if iself.tensor_index_type != iother.tensor_index_type: + raise ValueError("index types not compatible") + else: + tensor_index_type = iself.tensor_index_type + tensor_metric = tensor_index_type.metric + dummy = TensorIndex("d_" + str(count), tensor_index_type, + is_up=iself.is_up) + if iself.is_up == iother.is_up: + kroneckerdelta = tensor_index_type.delta(iself, -iother) + else: + kroneckerdelta = ( + TensMul(tensor_metric(iself, dummy), + tensor_index_type.delta(-dummy, -iother)) + ) + kronecker_delta_list.append(kroneckerdelta) + return TensMul.fromiter(kronecker_delta_list).doit() + # doit necessary to rename dummy indices accordingly + + +class TensMul(TensExpr, AssocOp): + """ + Product of tensors. + + Parameters + ========== + + coeff : SymPy coefficient of the tensor + args + + Attributes + ========== + + ``components`` : list of ``TensorHead`` of the component tensors + ``types`` : list of nonrepeated ``TensorIndexType`` + ``free`` : list of ``(ind, ipos, icomp)``, see Notes + ``dum`` : list of ``(ipos1, ipos2, icomp1, icomp2)``, see Notes + ``ext_rank`` : rank of the tensor counting the dummy indices + ``rank`` : rank of the tensor + ``coeff`` : SymPy coefficient of the tensor + ``free_args`` : list of the free indices in sorted order + ``is_canon_bp`` : ``True`` if the tensor in in canonical form + + Notes + ===== + + ``args[0]`` list of ``TensorHead`` of the component tensors. + + ``args[1]`` list of ``(ind, ipos, icomp)`` + where ``ind`` is a free index, ``ipos`` is the slot position + of ``ind`` in the ``icomp``-th component tensor. + + ``args[2]`` list of tuples representing dummy indices. + ``(ipos1, ipos2, icomp1, icomp2)`` indicates that the contravariant + dummy index is the ``ipos1``-th slot position in the ``icomp1``-th + component tensor; the corresponding covariant index is + in the ``ipos2`` slot position in the ``icomp2``-th component tensor. + + """ + identity = S.One + + _index_structure = None # type: _IndexStructure + + def __new__(cls, *args, **kw_args): + is_canon_bp = kw_args.get('is_canon_bp', False) + args = list(map(_sympify, args)) + + """ + If the internal dummy indices in one arg conflict with the free indices + of the remaining args, we need to rename those internal dummy indices. + """ + free = [get_free_indices(arg) for arg in args] + free = set(itertools.chain(*free)) #flatten free + newargs = [] + for arg in args: + dum_this = set(get_dummy_indices(arg)) + dum_other = [get_dummy_indices(a) for a in newargs] + dum_other = set(itertools.chain(*dum_other)) #flatten dum_other + free_this = set(get_free_indices(arg)) + if len(dum_this.intersection(free)) > 0: + exclude = free_this.union(free, dum_other) + newarg = TensMul._dedupe_indices(arg, exclude) + else: + newarg = arg + newargs.append(newarg) + + args = newargs + + # Flatten: + args = [i for arg in args for i in (arg.args if isinstance(arg, (TensMul, Mul)) else [arg])] + + args, indices, free, dum = TensMul._tensMul_contract_indices(args, replace_indices=False) + + # Data for indices: + index_types = [i.tensor_index_type for i in indices] + index_structure = _IndexStructure(free, dum, index_types, indices, canon_bp=is_canon_bp) + + obj = TensExpr.__new__(cls, *args) + obj._indices = indices + obj._index_types = index_types[:] + obj._index_structure = index_structure + obj._free = index_structure.free[:] + obj._dum = index_structure.dum[:] + obj._free_indices = {x[0] for x in obj.free} + obj._rank = len(obj.free) + obj._ext_rank = len(obj._index_structure.free) + 2*len(obj._index_structure.dum) + obj._coeff = S.One + obj._is_canon_bp = is_canon_bp + return obj + + index_types = property(lambda self: self._index_types) + free = property(lambda self: self._free) + dum = property(lambda self: self._dum) + free_indices = property(lambda self: self._free_indices) + rank = property(lambda self: self._rank) + ext_rank = property(lambda self: self._ext_rank) + + @staticmethod + def _indices_to_free_dum(args_indices): + free2pos1 = {} + free2pos2 = {} + dummy_data = [] + indices = [] + + # Notation for positions (to better understand the code): + # `pos1`: position in the `args`. + # `pos2`: position in the indices. + + # Example: + # A(i, j)*B(k, m, n)*C(p) + # `pos1` of `n` is 1 because it's in `B` (second `args` of TensMul). + # `pos2` of `n` is 4 because it's the fifth overall index. + + # Counter for the index position wrt the whole expression: + pos2 = 0 + + for pos1, arg_indices in enumerate(args_indices): + + for index_pos, index in enumerate(arg_indices): + if not isinstance(index, TensorIndex): + raise TypeError("expected TensorIndex") + if -index in free2pos1: + # Dummy index detected: + other_pos1 = free2pos1.pop(-index) + other_pos2 = free2pos2.pop(-index) + if index.is_up: + dummy_data.append((index, pos1, other_pos1, pos2, other_pos2)) + else: + dummy_data.append((-index, other_pos1, pos1, other_pos2, pos2)) + indices.append(index) + elif index in free2pos1: + raise ValueError("Repeated index: %s" % index) + else: + free2pos1[index] = pos1 + free2pos2[index] = pos2 + indices.append(index) + pos2 += 1 + + free = [(i, p) for (i, p) in free2pos2.items()] + free_names = [i.name for i in free2pos2.keys()] + + dummy_data.sort(key=lambda x: x[3]) + return indices, free, free_names, dummy_data + + @staticmethod + def _dummy_data_to_dum(dummy_data): + return [(p2a, p2b) for (i, p1a, p1b, p2a, p2b) in dummy_data] + + @staticmethod + def _tensMul_contract_indices(args, replace_indices=True): + replacements = [{} for _ in args] + + #_index_order = all(_has_index_order(arg) for arg in args) + + args_indices = [get_indices(arg) for arg in args] + indices, free, free_names, dummy_data = TensMul._indices_to_free_dum(args_indices) + + cdt = defaultdict(int) + + def dummy_name_gen(tensor_index_type): + nd = str(cdt[tensor_index_type]) + cdt[tensor_index_type] += 1 + return tensor_index_type.dummy_name + '_' + nd + + if replace_indices: + for old_index, pos1cov, pos1contra, pos2cov, pos2contra in dummy_data: + index_type = old_index.tensor_index_type + while True: + dummy_name = dummy_name_gen(index_type) + if dummy_name not in free_names: + break + dummy = TensorIndex(dummy_name, index_type, True) + replacements[pos1cov][old_index] = dummy + replacements[pos1contra][-old_index] = -dummy + indices[pos2cov] = dummy + indices[pos2contra] = -dummy + args = [ + arg._replace_indices(repl) if isinstance(arg, TensExpr) else arg + for arg, repl in zip(args, replacements)] + + dum = TensMul._dummy_data_to_dum(dummy_data) + return args, indices, free, dum + + @staticmethod + def _get_components_from_args(args): + """ + Get a list of ``Tensor`` objects having the same ``TIDS`` if multiplied + by one another. + """ + components = [] + for arg in args: + if not isinstance(arg, TensExpr): + continue + if isinstance(arg, TensAdd): + continue + components.extend(arg.components) + return components + + @staticmethod + def _rebuild_tensors_list(args, index_structure): + indices = index_structure.get_indices() + #tensors = [None for i in components] # pre-allocate list + ind_pos = 0 + for i, arg in enumerate(args): + if not isinstance(arg, TensExpr): + continue + prev_pos = ind_pos + ind_pos += arg.ext_rank + args[i] = Tensor(arg.component, indices[prev_pos:ind_pos]) + + def doit(self, **hints): + is_canon_bp = self._is_canon_bp + deep = hints.get('deep', True) + if deep: + args = [arg.doit(**hints) for arg in self.args] + + """ + There may now be conflicts between dummy indices of different args + (each arg's doit method does not have any information about which + dummy indices are already used in the other args), so we + deduplicate them. + """ + rule = dict(zip(self.args, args)) + rule = self._dedupe_indices_in_rule(rule) + args = [rule[a] for a in self.args] + + else: + args = self.args + + args = [arg for arg in args if arg != self.identity] + + # Extract non-tensor coefficients: + coeff = reduce(lambda a, b: a*b, [arg for arg in args if not isinstance(arg, TensExpr)], S.One) + args = [arg for arg in args if isinstance(arg, TensExpr)] + + if len(args) == 0: + return coeff + + if coeff != self.identity: + args = [coeff] + args + if coeff == 0: + return S.Zero + + if len(args) == 1: + return args[0] + + args, indices, free, dum = TensMul._tensMul_contract_indices(args) + + # Data for indices: + index_types = [i.tensor_index_type for i in indices] + index_structure = _IndexStructure(free, dum, index_types, indices, canon_bp=is_canon_bp) + + obj = self.func(*args) + obj._index_types = index_types + obj._index_structure = index_structure + obj._ext_rank = len(obj._index_structure.free) + 2*len(obj._index_structure.dum) + obj._coeff = coeff + obj._is_canon_bp = is_canon_bp + return obj + + # TODO: this method should be private + # TODO: should this method be renamed _from_components_free_dum ? + @staticmethod + def from_data(coeff, components, free, dum, **kw_args): + return TensMul(coeff, *TensMul._get_tensors_from_components_free_dum(components, free, dum), **kw_args).doit() + + @staticmethod + def _get_tensors_from_components_free_dum(components, free, dum): + """ + Get a list of ``Tensor`` objects by distributing ``free`` and ``dum`` indices on the ``components``. + """ + index_structure = _IndexStructure.from_components_free_dum(components, free, dum) + indices = index_structure.get_indices() + tensors = [None for i in components] # pre-allocate list + + # distribute indices on components to build a list of tensors: + ind_pos = 0 + for i, component in enumerate(components): + prev_pos = ind_pos + ind_pos += component.rank + tensors[i] = Tensor(component, indices[prev_pos:ind_pos]) + return tensors + + def _get_free_indices_set(self): + return {i[0] for i in self.free} + + def _get_dummy_indices_set(self): + dummy_pos = set(itertools.chain(*self.dum)) + return {idx for i, idx in enumerate(self._index_structure.get_indices()) if i in dummy_pos} + + def _get_position_offset_for_indices(self): + arg_offset = [None for i in range(self.ext_rank)] + counter = 0 + for i, arg in enumerate(self.args): + if not isinstance(arg, TensExpr): + continue + for j in range(arg.ext_rank): + arg_offset[j + counter] = counter + counter += arg.ext_rank + return arg_offset + + @property + def free_args(self): + return sorted([x[0] for x in self.free]) + + @property + def components(self): + return self._get_components_from_args(self.args) + + @property + def free_in_args(self): + arg_offset = self._get_position_offset_for_indices() + argpos = self._get_indices_to_args_pos() + return [(ind, pos-arg_offset[pos], argpos[pos]) for (ind, pos) in self.free] + + @property + def coeff(self): + # return Mul.fromiter([c for c in self.args if not isinstance(c, TensExpr)]) + return self._coeff + + @property + def nocoeff(self): + return self.func(*[t for t in self.args if isinstance(t, TensExpr)]).doit() + + @property + def dum_in_args(self): + arg_offset = self._get_position_offset_for_indices() + argpos = self._get_indices_to_args_pos() + return [(p1-arg_offset[p1], p2-arg_offset[p2], argpos[p1], argpos[p2]) for p1, p2 in self.dum] + + def equals(self, other): + if other == 0: + return self.coeff == 0 + other = _sympify(other) + if not isinstance(other, TensExpr): + assert not self.components + return self.coeff == other + + return self.canon_bp() == other.canon_bp() + + def get_indices(self): + """ + Returns the list of indices of the tensor. + + Explanation + =========== + + The indices are listed in the order in which they appear in the + component tensors. + The dummy indices are given a name which does not collide with + the names of the free indices. + + Examples + ======== + + >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensor_heads + >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') + >>> m0, m1, m2 = tensor_indices('m0,m1,m2', Lorentz) + >>> g = Lorentz.metric + >>> p, q = tensor_heads('p,q', [Lorentz]) + >>> t = p(m1)*g(m0,m2) + >>> t.get_indices() + [m1, m0, m2] + >>> t2 = p(m1)*g(-m1, m2) + >>> t2.get_indices() + [L_0, -L_0, m2] + """ + return self._indices + + def get_free_indices(self) -> list[TensorIndex]: + """ + Returns the list of free indices of the tensor. + + Explanation + =========== + + The indices are listed in the order in which they appear in the + component tensors. + + Examples + ======== + + >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensor_heads + >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') + >>> m0, m1, m2 = tensor_indices('m0,m1,m2', Lorentz) + >>> g = Lorentz.metric + >>> p, q = tensor_heads('p,q', [Lorentz]) + >>> t = p(m1)*g(m0,m2) + >>> t.get_free_indices() + [m1, m0, m2] + >>> t2 = p(m1)*g(-m1, m2) + >>> t2.get_free_indices() + [m2] + """ + return self._index_structure.get_free_indices() + + def _replace_indices(self, repl: dict[TensorIndex, TensorIndex]) -> TensExpr: + return self.func(*[arg._replace_indices(repl) if isinstance(arg, TensExpr) else arg for arg in self.args]) + + def split(self): + """ + Returns a list of tensors, whose product is ``self``. + + Explanation + =========== + + Dummy indices contracted among different tensor components + become free indices with the same name as the one used to + represent the dummy indices. + + Examples + ======== + + >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensor_heads, TensorSymmetry + >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') + >>> a, b, c, d = tensor_indices('a,b,c,d', Lorentz) + >>> A, B = tensor_heads('A,B', [Lorentz]*2, TensorSymmetry.fully_symmetric(2)) + >>> t = A(a,b)*B(-b,c) + >>> t + A(a, L_0)*B(-L_0, c) + >>> t.split() + [A(a, L_0), B(-L_0, c)] + """ + if self.args == (): + return [self] + splitp = [] + res = 1 + for arg in self.args: + if isinstance(arg, Tensor): + splitp.append(res*arg) + res = 1 + else: + res *= arg + return splitp + + def _expand(self, **hints): + # TODO: temporary solution, in the future this should be linked to + # `Expr.expand`. + args = [_expand(arg, **hints) for arg in self.args] + args1 = [arg.args if isinstance(arg, (Add, TensAdd)) else (arg,) for arg in args] + return TensAdd(*[ + TensMul(*i) for i in itertools.product(*args1)] + ) + + def __neg__(self): + return TensMul(S.NegativeOne, self, is_canon_bp=self._is_canon_bp).doit() + + def __getitem__(self, item): + deprecate_data() + with ignore_warnings(SymPyDeprecationWarning): + return self.data[item] + + def _get_args_for_traditional_printer(self): + args = list(self.args) + if self.coeff.could_extract_minus_sign(): + # expressions like "-A(a)" + sign = "-" + if args[0] == S.NegativeOne: + args = args[1:] + else: + args[0] = -args[0] + else: + sign = "" + return sign, args + + def _sort_args_for_sorted_components(self): + """ + Returns the ``args`` sorted according to the components commutation + properties. + + Explanation + =========== + + The sorting is done taking into account the commutation group + of the component tensors. + """ + cv = [arg for arg in self.args if isinstance(arg, TensExpr)] + sign = 1 + n = len(cv) - 1 + for i in range(n): + for j in range(n, i, -1): + c = cv[j-1].commutes_with(cv[j]) + # if `c` is `None`, it does neither commute nor anticommute, skip: + if c not in (0, 1): + continue + typ1 = sorted(set(cv[j-1].component.index_types), key=lambda x: x.name) + typ2 = sorted(set(cv[j].component.index_types), key=lambda x: x.name) + if (typ1, cv[j-1].component.name) > (typ2, cv[j].component.name): + cv[j-1], cv[j] = cv[j], cv[j-1] + # if `c` is 1, the anticommute, so change sign: + if c: + sign = -sign + + coeff = sign * self.coeff + if coeff != 1: + return [coeff] + cv + return cv + + def sorted_components(self): + """ + Returns a tensor product with sorted components. + """ + return TensMul(*self._sort_args_for_sorted_components()).doit() + + def perm2tensor(self, g, is_canon_bp=False): + """ + Returns the tensor corresponding to the permutation ``g`` + + For further details, see the method in ``TIDS`` with the same name. + """ + return perm2tensor(self, g, is_canon_bp=is_canon_bp) + + def canon_bp(self): + """ + Canonicalize using the Butler-Portugal algorithm for canonicalization + under monoterm symmetries. + + Examples + ======== + + >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, TensorHead, TensorSymmetry + >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') + >>> m0, m1, m2 = tensor_indices('m0,m1,m2', Lorentz) + >>> A = TensorHead('A', [Lorentz]*2, TensorSymmetry.fully_symmetric(-2)) + >>> t = A(m0,-m1)*A(m1,-m0) + >>> t.canon_bp() + -A(L_0, L_1)*A(-L_0, -L_1) + >>> t = A(m0,-m1)*A(m1,-m2)*A(m2,-m0) + >>> t.canon_bp() + 0 + """ + if self._is_canon_bp: + return self + expr = self.expand() + if isinstance(expr, TensAdd): + return expr.canon_bp() + if not expr.components: + return expr + t = expr.sorted_components() + g, dummies, msym = t._index_structure.indices_canon_args() + v = components_canon_args(t.components) + can = canonicalize(g, dummies, msym, *v) + if can == 0: + return S.Zero + tmul = t.perm2tensor(can, True) + return tmul + + def contract_delta(self, delta): + t = self.contract_metric(delta) + return t + + def _get_indices_to_args_pos(self): + """ + Get a dict mapping the index position to TensMul's argument number. + """ + pos_map = {} + pos_counter = 0 + for arg_i, arg in enumerate(self.args): + if not isinstance(arg, TensExpr): + continue + assert isinstance(arg, Tensor) + for i in range(arg.ext_rank): + pos_map[pos_counter] = arg_i + pos_counter += 1 + return pos_map + + def contract_metric(self, g): + """ + Raise or lower indices with the metric ``g``. + + Parameters + ========== + + g : metric + + Notes + ===== + + See the ``TensorIndexType`` docstring for the contraction conventions. + + Examples + ======== + + >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensor_heads + >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') + >>> m0, m1, m2 = tensor_indices('m0,m1,m2', Lorentz) + >>> g = Lorentz.metric + >>> p, q = tensor_heads('p,q', [Lorentz]) + >>> t = p(m0)*q(m1)*g(-m0, -m1) + >>> t.canon_bp() + metric(L_0, L_1)*p(-L_0)*q(-L_1) + >>> t.contract_metric(g).canon_bp() + p(L_0)*q(-L_0) + """ + expr = self.expand() + if self != expr: + expr = canon_bp(expr) + return contract_metric(expr, g) + pos_map = self._get_indices_to_args_pos() + args = list(self.args) + + #antisym = g.index_types[0].metric_antisym + if g.symmetry == TensorSymmetry.fully_symmetric(-2): + antisym = 1 + elif g.symmetry == TensorSymmetry.fully_symmetric(2): + antisym = 0 + elif g.symmetry == TensorSymmetry.no_symmetry(2): + antisym = None + else: + raise NotImplementedError + + # list of positions of the metric ``g`` inside ``args`` + gpos = [i for i, x in enumerate(self.args) if isinstance(x, Tensor) and x.component == g] + if not gpos: + return self + + # Sign is either 1 or -1, to correct the sign after metric contraction + # (for spinor indices). + sign = 1 + dum = self.dum[:] + free = self.free[:] + elim = set() + for gposx in gpos: + if gposx in elim: + continue + free1 = [x for x in free if pos_map[x[1]] == gposx] + dum1 = [x for x in dum if pos_map[x[0]] == gposx or pos_map[x[1]] == gposx] + if not dum1: + continue + elim.add(gposx) + # subs with the multiplication neutral element, that is, remove it: + args[gposx] = 1 + if len(dum1) == 2: + if not antisym: + dum10, dum11 = dum1 + if pos_map[dum10[1]] == gposx: + # the index with pos p0 contravariant + p0 = dum10[0] + else: + # the index with pos p0 is covariant + p0 = dum10[1] + if pos_map[dum11[1]] == gposx: + # the index with pos p1 is contravariant + p1 = dum11[0] + else: + # the index with pos p1 is covariant + p1 = dum11[1] + + dum.append((p0, p1)) + else: + dum10, dum11 = dum1 + # change the sign to bring the indices of the metric to contravariant + # form; change the sign if dum10 has the metric index in position 0 + if pos_map[dum10[1]] == gposx: + # the index with pos p0 is contravariant + p0 = dum10[0] + if dum10[1] == 1: + sign = -sign + else: + # the index with pos p0 is covariant + p0 = dum10[1] + if dum10[0] == 0: + sign = -sign + if pos_map[dum11[1]] == gposx: + # the index with pos p1 is contravariant + p1 = dum11[0] + sign = -sign + else: + # the index with pos p1 is covariant + p1 = dum11[1] + + dum.append((p0, p1)) + + elif len(dum1) == 1: + if not antisym: + dp0, dp1 = dum1[0] + if pos_map[dp0] == pos_map[dp1]: + # g(i, -i) + typ = g.index_types[0] + sign = sign*typ.dim + + else: + # g(i0, i1)*p(-i1) + if pos_map[dp0] == gposx: + p1 = dp1 + else: + p1 = dp0 + + ind, p = free1[0] + free.append((ind, p1)) + else: + dp0, dp1 = dum1[0] + if pos_map[dp0] == pos_map[dp1]: + # g(i, -i) + typ = g.index_types[0] + sign = sign*typ.dim + + if dp0 < dp1: + # g(i, -i) = -D with antisymmetric metric + sign = -sign + else: + # g(i0, i1)*p(-i1) + if pos_map[dp0] == gposx: + p1 = dp1 + if dp0 == 0: + sign = -sign + else: + p1 = dp0 + ind, p = free1[0] + free.append((ind, p1)) + dum = [x for x in dum if x not in dum1] + free = [x for x in free if x not in free1] + + # shift positions: + shift = 0 + shifts = [0]*len(args) + for i in range(len(args)): + if i in elim: + shift += 2 + continue + shifts[i] = shift + free = [(ind, p - shifts[pos_map[p]]) for (ind, p) in free if pos_map[p] not in elim] + dum = [(p0 - shifts[pos_map[p0]], p1 - shifts[pos_map[p1]]) for i, (p0, p1) in enumerate(dum) if pos_map[p0] not in elim and pos_map[p1] not in elim] + + res = sign*TensMul(*args).doit() + if not isinstance(res, TensExpr): + return res + im = _IndexStructure.from_components_free_dum(res.components, free, dum) + return res._set_new_index_structure(im) + + def _set_new_index_structure(self, im, is_canon_bp=False): + indices = im.get_indices() + return self._set_indices(*indices, is_canon_bp=is_canon_bp) + + def _set_indices(self, *indices, is_canon_bp=False, **kw_args): + if len(indices) != self.ext_rank: + raise ValueError("indices length mismatch") + args = list(self.args)[:] + pos = 0 + for i, arg in enumerate(args): + if not isinstance(arg, TensExpr): + continue + assert isinstance(arg, Tensor) + ext_rank = arg.ext_rank + args[i] = arg._set_indices(*indices[pos:pos+ext_rank]) + pos += ext_rank + return TensMul(*args, is_canon_bp=is_canon_bp).doit() + + @staticmethod + def _index_replacement_for_contract_metric(args, free, dum): + for arg in args: + if not isinstance(arg, TensExpr): + continue + assert isinstance(arg, Tensor) + + def substitute_indices(self, *index_tuples): + new_args = [] + for arg in self.args: + if isinstance(arg, TensExpr): + arg = arg.substitute_indices(*index_tuples) + new_args.append(arg) + return TensMul(*new_args).doit() + + def __call__(self, *indices): + deprecate_call() + free_args = self.free_args + indices = list(indices) + if [x.tensor_index_type for x in indices] != [x.tensor_index_type for x in free_args]: + raise ValueError('incompatible types') + if indices == free_args: + return self + t = self.substitute_indices(*list(zip(free_args, indices))) + + # object is rebuilt in order to make sure that all contracted indices + # get recognized as dummies, but only if there are contracted indices. + if len({i if i.is_up else -i for i in indices}) != len(indices): + return t.func(*t.args) + return t + + def _extract_data(self, replacement_dict): + args_indices, arrays = zip(*[arg._extract_data(replacement_dict) for arg in self.args if isinstance(arg, TensExpr)]) + coeff = reduce(operator.mul, [a for a in self.args if not isinstance(a, TensExpr)], S.One) + indices, free, free_names, dummy_data = TensMul._indices_to_free_dum(args_indices) + dum = TensMul._dummy_data_to_dum(dummy_data) + ext_rank = self.ext_rank + free.sort(key=lambda x: x[1]) + free_indices = [i[0] for i in free] + return free_indices, coeff*_TensorDataLazyEvaluator.data_contract_dum(arrays, dum, ext_rank) + + @property + def data(self): + deprecate_data() + with ignore_warnings(SymPyDeprecationWarning): + dat = _tensor_data_substitution_dict[self.expand()] + return dat + + @data.setter + def data(self, data): + deprecate_data() + raise ValueError("Not possible to set component data to a tensor expression") + + @data.deleter + def data(self): + deprecate_data() + raise ValueError("Not possible to delete component data to a tensor expression") + + def __iter__(self): + deprecate_data() + with ignore_warnings(SymPyDeprecationWarning): + if self.data is None: + raise ValueError("No iteration on abstract tensors") + return self.data.__iter__() + + @staticmethod + def _dedupe_indices(new, exclude): + """ + exclude: set + new: TensExpr + + If ``new`` has any dummy indices that are in ``exclude``, return a version + of new with those indices replaced. If no replacements are needed, + return None + + """ + exclude = set(exclude) + dums_new = set(get_dummy_indices(new)) + free_new = set(get_free_indices(new)) + + conflicts = dums_new.intersection(exclude) + if len(conflicts) == 0: + return None + + """ + ``exclude_for_gen`` is to be passed to ``_IndexStructure._get_generator_for_dummy_indices()``. + Since the latter does not use the index position for anything, we just + set it as ``None`` here. + """ + exclude.update(dums_new) + exclude.update(free_new) + exclude_for_gen = [(i, None) for i in exclude] + gen = _IndexStructure._get_generator_for_dummy_indices(exclude_for_gen) + repl = {} + for d in conflicts: + if -d in repl.keys(): + continue + newname = gen(d.tensor_index_type) + new_d = d.func(newname, *d.args[1:]) + repl[d] = new_d + repl[-d] = -new_d + + if len(repl) == 0: + return None + + new_renamed = new._replace_indices(repl) + return new_renamed + + def _dedupe_indices_in_rule(self, rule): + """ + rule: dict + + This applies TensMul._dedupe_indices on all values of rule. + + """ + index_rules = {k:v for k,v in rule.items() if isinstance(k, TensorIndex)} + other_rules = {k:v for k,v in rule.items() if k not in index_rules.keys()} + exclude = set(self.get_indices()) + + newrule = {} + newrule.update(index_rules) + exclude.update(index_rules.keys()) + exclude.update(index_rules.values()) + for old, new in other_rules.items(): + new_renamed = TensMul._dedupe_indices(new, exclude) + if old == new or new_renamed is None: + newrule[old] = new + else: + newrule[old] = new_renamed + exclude.update(get_indices(new_renamed)) + return newrule + + def _eval_rewrite_as_Indexed(self, *args): + from sympy.concrete.summations import Sum + index_symbols = [i.args[0] for i in self.get_indices()] + args = [arg.args[0] if isinstance(arg, Sum) else arg for arg in args] + expr = Mul.fromiter(args) + return self._check_add_Sum(expr, index_symbols) + + def _eval_partial_derivative(self, s): + # Evaluation like Mul + terms = [] + for i, arg in enumerate(self.args): + # checking whether some tensor instance is differentiated + # or some other thing is necessary, but ugly + if isinstance(arg, TensExpr): + d = arg._eval_partial_derivative(s) + else: + # do not call diff is s is no symbol + if s._diff_wrt: + d = arg._eval_derivative(s) + else: + d = S.Zero + if d: + terms.append(TensMul.fromiter(self.args[:i] + (d,) + self.args[i + 1:])) + return TensAdd.fromiter(terms) + + +class TensorElement(TensExpr): + """ + Tensor with evaluated components. + + Examples + ======== + + >>> from sympy.tensor.tensor import TensorIndexType, TensorHead, TensorSymmetry + >>> from sympy import symbols + >>> L = TensorIndexType("L") + >>> i, j, k = symbols("i j k") + >>> A = TensorHead("A", [L, L], TensorSymmetry.fully_symmetric(2)) + >>> A(i, j).get_free_indices() + [i, j] + + If we want to set component ``i`` to a specific value, use the + ``TensorElement`` class: + + >>> from sympy.tensor.tensor import TensorElement + >>> te = TensorElement(A(i, j), {i: 2}) + + As index ``i`` has been accessed (``{i: 2}`` is the evaluation of its 3rd + element), the free indices will only contain ``j``: + + >>> te.get_free_indices() + [j] + """ + + def __new__(cls, expr, index_map): + if not isinstance(expr, Tensor): + # remap + if not isinstance(expr, TensExpr): + raise TypeError("%s is not a tensor expression" % expr) + return expr.func(*[TensorElement(arg, index_map) for arg in expr.args]) + expr_free_indices = expr.get_free_indices() + name_translation = {i.args[0]: i for i in expr_free_indices} + index_map = {name_translation.get(index, index): value for index, value in index_map.items()} + index_map = {index: value for index, value in index_map.items() if index in expr_free_indices} + if len(index_map) == 0: + return expr + free_indices = [i for i in expr_free_indices if i not in index_map.keys()] + index_map = Dict(index_map) + obj = TensExpr.__new__(cls, expr, index_map) + obj._free_indices = free_indices + return obj + + @property + def free(self): + return [(index, i) for i, index in enumerate(self.get_free_indices())] + + @property + def dum(self): + # TODO: inherit dummies from expr + return [] + + @property + def expr(self): + return self._args[0] + + @property + def index_map(self): + return self._args[1] + + @property + def coeff(self): + return S.One + + @property + def nocoeff(self): + return self + + def get_free_indices(self): + return self._free_indices + + def _replace_indices(self, repl: dict[TensorIndex, TensorIndex]) -> TensExpr: + # TODO: can be improved: + return self.xreplace(repl) + + def get_indices(self): + return self.get_free_indices() + + def _extract_data(self, replacement_dict): + ret_indices, array = self.expr._extract_data(replacement_dict) + index_map = self.index_map + slice_tuple = tuple(index_map.get(i, slice(None)) for i in ret_indices) + ret_indices = [i for i in ret_indices if i not in index_map] + array = array.__getitem__(slice_tuple) + return ret_indices, array + + +class WildTensorHead(TensorHead): + """ + A wild object that is used to create ``WildTensor`` instances + + Explanation + =========== + + Examples + ======== + >>> from sympy.tensor.tensor import TensorHead, TensorIndex, WildTensorHead, TensorIndexType + >>> R3 = TensorIndexType('R3', dim=3) + >>> p = TensorIndex('p', R3) + >>> q = TensorIndex('q', R3) + + A WildTensorHead can be created without specifying a ``TensorIndexType`` + + >>> W = WildTensorHead("W") + + Calling it with a ``TensorIndex`` creates a ``WildTensor`` instance. + + >>> type(W(p)) + + + The ``TensorIndexType`` is automatically detected from the index that is passed + + >>> W(p).component + W(R3) + + Calling it with no indices returns an object that can match tensors with any number of indices. + + >>> K = TensorHead('K', [R3]) + >>> Q = TensorHead('Q', [R3, R3]) + >>> W().matches(K(p)) + {W: K(p)} + >>> W().matches(Q(p,q)) + {W: Q(p, q)} + + If you want to ignore the order of indices while matching, pass ``unordered_indices=True``. + + >>> U = WildTensorHead("U", unordered_indices=True) + >>> W(p,q).matches(Q(q,p)) + >>> U(p,q).matches(Q(q,p)) + {U(R3,R3): _WildTensExpr(Q(q, p))} + + Parameters + ========== + name : name of the tensor + unordered_indices : whether the order of the indices matters for matching + (default: False) + + See also + ======== + ``WildTensor`` + ``TensorHead`` + + """ + def __new__(cls, name, index_types=None, symmetry=None, comm=0, unordered_indices=False): + if isinstance(name, str): + name_symbol = Symbol(name) + elif isinstance(name, Symbol): + name_symbol = name + else: + raise ValueError("invalid name") + + if index_types is None: + index_types = [] + + if symmetry is None: + symmetry = TensorSymmetry.no_symmetry(len(index_types)) + else: + assert symmetry.rank == len(index_types) + + if symmetry != TensorSymmetry.no_symmetry(len(index_types)): + raise NotImplementedError("Wild matching based on symmetry is not implemented.") + + obj = Basic.__new__(cls, name_symbol, Tuple(*index_types), sympify(symmetry), sympify(comm), sympify(unordered_indices)) + obj.comm = TensorManager.comm_symbols2i(comm) + obj.unordered_indices = unordered_indices + + return obj + + def __call__(self, *indices, **kwargs): + tensor = WildTensor(self, indices, **kwargs) + return tensor.doit() + + +class WildTensor(Tensor): + """ + A wild object which matches ``Tensor`` instances + + Explanation + =========== + This is instantiated by attaching indices to a ``WildTensorHead`` instance. + + Examples + ======== + >>> from sympy.tensor.tensor import TensorHead, TensorIndex, WildTensorHead, TensorIndexType + >>> W = WildTensorHead("W") + >>> R3 = TensorIndexType('R3', dim=3) + >>> p = TensorIndex('p', R3) + >>> q = TensorIndex('q', R3) + >>> K = TensorHead('K', [R3]) + >>> Q = TensorHead('Q', [R3, R3]) + + Matching also takes the indices into account + >>> W(p).matches(K(p)) + {W(R3): _WildTensExpr(K(p))} + >>> W(p).matches(K(q)) + >>> W(p).matches(K(-p)) + + If you want to match objects with any number of indices, just use a ``WildTensor`` with no indices. + >>> W().matches(K(p)) + {W: K(p)} + >>> W().matches(Q(p,q)) + {W: Q(p, q)} + + See Also + ======== + ``WildTensorHead`` + ``Tensor`` + + """ + def __new__(cls, tensor_head, indices, **kw_args): + is_canon_bp = kw_args.pop("is_canon_bp", False) + + if tensor_head.func == TensorHead: + """ + If someone tried to call WildTensor by supplying a TensorHead (not a WildTensorHead), return a normal tensor instead. This is helpful when using subs on an expression to replace occurrences of a WildTensorHead with a TensorHead. + """ + return Tensor(tensor_head, indices, is_canon_bp=is_canon_bp, **kw_args) + elif tensor_head.func == _WildTensExpr: + return tensor_head(*indices) + + indices = cls._parse_indices(tensor_head, indices) + index_types = [ind.tensor_index_type for ind in indices] + tensor_head = tensor_head.func( + tensor_head.name, + index_types, + symmetry=None, + comm=tensor_head.comm, + unordered_indices=tensor_head.unordered_indices, + ) + + obj = Basic.__new__(cls, tensor_head, Tuple(*indices)) + obj.name = tensor_head.name + obj._index_structure = _IndexStructure.from_indices(*indices) + obj._free = obj._index_structure.free[:] + obj._dum = obj._index_structure.dum[:] + obj._ext_rank = obj._index_structure._ext_rank + obj._coeff = S.One + obj._nocoeff = obj + obj._component = tensor_head + obj._components = [tensor_head] + if tensor_head.rank != len(indices): + raise ValueError("wrong number of indices") + obj.is_canon_bp = is_canon_bp + obj._index_map = obj._build_index_map(indices, obj._index_structure) + + return obj + + + def matches(self, expr, repl_dict=None, old=False): + if not isinstance(expr, TensExpr) and expr != S(1): + return None + + if repl_dict is None: + repl_dict = {} + else: + repl_dict = repl_dict.copy() + + if len(self.indices) > 0: + if not hasattr(expr, "get_free_indices"): + return None + expr_indices = expr.get_free_indices() + if len(expr_indices) != len(self.indices): + return None + if self._component.unordered_indices: + m = self._match_indices_ignoring_order(expr) + if m is None: + return None + else: + repl_dict.update(m) + else: + for i in range(len(expr_indices)): + m = self.indices[i].matches(expr_indices[i]) + if m is None: + return None + else: + repl_dict.update(m) + + repl_dict[self.component] = _WildTensExpr(expr) + else: + #If no indices were passed to the WildTensor, it may match tensors with any number of indices. + repl_dict[self] = expr + + return repl_dict + + def _match_indices_ignoring_order(self, expr, repl_dict=None, old=False): + """ + Helper method for matches. Checks if the indices of self and expr + match disregarding index ordering. + """ + if repl_dict is None: + repl_dict = {} + else: + repl_dict = repl_dict.copy() + + def siftkey(ind): + if isinstance(ind, WildTensorIndex): + if ind.ignore_updown: + return "wild, updown" + else: + return "wild" + else: + return "nonwild" + + indices_sifted = sift(self.indices, siftkey) + + matched_indices = [] + expr_indices_remaining = expr.get_indices() + for ind in indices_sifted["nonwild"]: + matched_this_ind = False + for e_ind in expr_indices_remaining: + if e_ind in matched_indices: + continue + m = ind.matches(e_ind) + if m is not None: + matched_this_ind = True + repl_dict.update(m) + matched_indices.append(e_ind) + break + if not matched_this_ind: + return None + + expr_indices_remaining = [i for i in expr_indices_remaining if i not in matched_indices] + for ind in indices_sifted["wild"]: + matched_this_ind = False + for e_ind in expr_indices_remaining: + m = ind.matches(e_ind) + if m is not None: + if -ind in repl_dict.keys() and -repl_dict[-ind] != m[ind]: + return None + matched_this_ind = True + repl_dict.update(m) + matched_indices.append(e_ind) + break + if not matched_this_ind: + return None + + expr_indices_remaining = [i for i in expr_indices_remaining if i not in matched_indices] + for ind in indices_sifted["wild, updown"]: + matched_this_ind = False + for e_ind in expr_indices_remaining: + m = ind.matches(e_ind) + if m is not None: + if -ind in repl_dict.keys() and -repl_dict[-ind] != m[ind]: + return None + matched_this_ind = True + repl_dict.update(m) + matched_indices.append(e_ind) + break + if not matched_this_ind: + return None + + if len(matched_indices) < len(self.indices): + return None + else: + return repl_dict + +class WildTensorIndex(TensorIndex): + """ + A wild object that matches TensorIndex instances. + + Examples + ======== + >>> from sympy.tensor.tensor import TensorIndex, TensorIndexType, WildTensorIndex + >>> R3 = TensorIndexType('R3', dim=3) + >>> p = TensorIndex("p", R3) + + By default, covariant indices only match with covariant indices (and + similarly for contravariant) + + >>> q = WildTensorIndex("q", R3) + >>> (q).matches(p) + {q: p} + >>> (q).matches(-p) + + If you want matching to ignore whether the index is co/contra-variant, set + ignore_updown=True + + >>> r = WildTensorIndex("r", R3, ignore_updown=True) + >>> (r).matches(-p) + {r: -p} + >>> (r).matches(p) + {r: p} + + Parameters + ========== + name : name of the index (string), or ``True`` if you want it to be + automatically assigned + tensor_index_type : ``TensorIndexType`` of the index + is_up : flag for contravariant index (is_up=True by default) + ignore_updown : bool, Whether this should match both co- and contra-variant + indices (default:False) + """ + def __new__(cls, name, tensor_index_type, is_up=True, ignore_updown=False): + if isinstance(name, str): + name_symbol = Symbol(name) + elif isinstance(name, Symbol): + name_symbol = name + elif name is True: + name = "_i{}".format(len(tensor_index_type._autogenerated)) + name_symbol = Symbol(name) + tensor_index_type._autogenerated.append(name_symbol) + else: + raise ValueError("invalid name") + + is_up = sympify(is_up) + ignore_updown = sympify(ignore_updown) + return Basic.__new__(cls, name_symbol, tensor_index_type, is_up, ignore_updown) + + @property + def ignore_updown(self): + return self.args[3] + + def __neg__(self): + t1 = WildTensorIndex(self.name, self.tensor_index_type, + (not self.is_up), self.ignore_updown) + return t1 + + def matches(self, expr, repl_dict=None, old=False): + if not isinstance(expr, TensorIndex): + return None + if self.tensor_index_type != expr.tensor_index_type: + return None + if not self.ignore_updown: + if self.is_up != expr.is_up: + return None + + if repl_dict is None: + repl_dict = {} + else: + repl_dict = repl_dict.copy() + + repl_dict[self] = expr + return repl_dict + + +class _WildTensExpr(Basic): + """ + INTERNAL USE ONLY + + This is an object that helps with replacement of WildTensors in expressions. + When this object is set as the tensor_head of a WildTensor, it replaces the + WildTensor by a TensExpr (passed when initializing this object). + + Examples + ======== + >>> from sympy.tensor.tensor import WildTensorHead, TensorIndex, TensorHead, TensorIndexType + >>> W = WildTensorHead("W") + >>> R3 = TensorIndexType('R3', dim=3) + >>> p = TensorIndex('p', R3) + >>> q = TensorIndex('q', R3) + >>> K = TensorHead('K', [R3]) + >>> print( ( K(p) ).replace( W(p), W(q)*W(-q)*W(p) ) ) + K(R_0)*K(-R_0)*K(p) + + """ + def __init__(self, expr): + if not isinstance(expr, TensExpr): + raise TypeError("_WildTensExpr expects a TensExpr as argument") + self.expr = expr + + def __call__(self, *indices): + return self.expr._replace_indices(dict(zip(self.expr.get_free_indices(), indices))) + + def __neg__(self): + return self.func(self.expr*S.NegativeOne) + + def __abs__(self): + raise NotImplementedError + + def __add__(self, other): + if other.func != self.func: + raise TypeError(f"Cannot add {self.func} to {other.func}") + return self.func(self.expr+other.expr) + + def __radd__(self, other): + if other.func != self.func: + raise TypeError(f"Cannot add {self.func} to {other.func}") + return self.func(other.expr+self.expr) + + def __sub__(self, other): + return self + (-other) + + def __rsub__(self, other): + return other + (-self) + + def __mul__(self, other): + raise NotImplementedError + + def __rmul__(self, other): + raise NotImplementedError + + def __truediv__(self, other): + raise NotImplementedError + + def __rtruediv__(self, other): + raise NotImplementedError + + def __pow__(self, other): + raise NotImplementedError + + def __rpow__(self, other): + raise NotImplementedError + + +def canon_bp(p): + """ + Butler-Portugal canonicalization. See ``tensor_can.py`` from the + combinatorics module for the details. + """ + if isinstance(p, TensExpr): + return p.canon_bp() + return p + + +def tensor_mul(*a): + """ + product of tensors + """ + if not a: + return TensMul.from_data(S.One, [], [], []) + t = a[0] + for tx in a[1:]: + t = t*tx + return t + + +def riemann_cyclic_replace(t_r): + """ + replace Riemann tensor with an equivalent expression + + ``R(m,n,p,q) -> 2/3*R(m,n,p,q) - 1/3*R(m,q,n,p) + 1/3*R(m,p,n,q)`` + + """ + free = sorted(t_r.free, key=lambda x: x[1]) + m, n, p, q = [x[0] for x in free] + t0 = t_r*Rational(2, 3) + t1 = -t_r.substitute_indices((m,m),(n,q),(p,n),(q,p))*Rational(1, 3) + t2 = t_r.substitute_indices((m,m),(n,p),(p,n),(q,q))*Rational(1, 3) + t3 = t0 + t1 + t2 + return t3 + +def riemann_cyclic(t2): + """ + Replace each Riemann tensor with an equivalent expression + satisfying the cyclic identity. + + This trick is discussed in the reference guide to Cadabra. + + Examples + ======== + + >>> from sympy.tensor.tensor import TensorIndexType, tensor_indices, TensorHead, riemann_cyclic, TensorSymmetry + >>> Lorentz = TensorIndexType('Lorentz', dummy_name='L') + >>> i, j, k, l = tensor_indices('i,j,k,l', Lorentz) + >>> R = TensorHead('R', [Lorentz]*4, TensorSymmetry.riemann()) + >>> t = R(i,j,k,l)*(R(-i,-j,-k,-l) - 2*R(-i,-k,-j,-l)) + >>> riemann_cyclic(t) + 0 + """ + t2 = t2.expand() + if isinstance(t2, (TensMul, Tensor)): + args = [t2] + else: + args = t2.args + a1 = [x.split() for x in args] + a2 = [[riemann_cyclic_replace(tx) for tx in y] for y in a1] + a3 = [tensor_mul(*v) for v in a2] + t3 = TensAdd(*a3).doit() + if not t3: + return t3 + else: + return canon_bp(t3) + + +def get_lines(ex, index_type): + """ + Returns ``(lines, traces, rest)`` for an index type, + where ``lines`` is the list of list of positions of a matrix line, + ``traces`` is the list of list of traced matrix lines, + ``rest`` is the rest of the elements of the tensor. + """ + def _join_lines(a): + i = 0 + while i < len(a): + x = a[i] + xend = x[-1] + xstart = x[0] + hit = True + while hit: + hit = False + for j in range(i + 1, len(a)): + if j >= len(a): + break + if a[j][0] == xend: + hit = True + x.extend(a[j][1:]) + xend = x[-1] + a.pop(j) + continue + if a[j][0] == xstart: + hit = True + a[i] = reversed(a[j][1:]) + x + x = a[i] + xstart = a[i][0] + a.pop(j) + continue + if a[j][-1] == xend: + hit = True + x.extend(reversed(a[j][:-1])) + xend = x[-1] + a.pop(j) + continue + if a[j][-1] == xstart: + hit = True + a[i] = a[j][:-1] + x + x = a[i] + xstart = x[0] + a.pop(j) + continue + i += 1 + return a + + arguments = ex.args + dt = {} + for c in ex.args: + if not isinstance(c, TensExpr): + continue + if c in dt: + continue + index_types = c.index_types + a = [] + for i in range(len(index_types)): + if index_types[i] is index_type: + a.append(i) + if len(a) > 2: + raise ValueError('at most two indices of type %s allowed' % index_type) + if len(a) == 2: + dt[c] = a + #dum = ex.dum + lines = [] + traces = [] + traces1 = [] + #indices_to_args_pos = ex._get_indices_to_args_pos() + # TODO: add a dum_to_components_map ? + for p0, p1, c0, c1 in ex.dum_in_args: + if arguments[c0] not in dt: + continue + if c0 == c1: + traces.append([c0]) + continue + ta0 = dt[arguments[c0]] + ta1 = dt[arguments[c1]] + if p0 not in ta0: + continue + if ta0.index(p0) == ta1.index(p1): + # case gamma(i,s0,-s1) in c0, gamma(j,-s0,s2) in c1; + # to deal with this case one could add to the position + # a flag for transposition; + # one could write [(c0, False), (c1, True)] + raise NotImplementedError + # if p0 == ta0[1] then G in pos c0 is mult on the right by G in c1 + # if p0 == ta0[0] then G in pos c1 is mult on the right by G in c0 + ta0 = dt[arguments[c0]] + b0, b1 = (c0, c1) if p0 == ta0[1] else (c1, c0) + lines1 = lines[:] + for line in lines: + if line[-1] == b0: + if line[0] == b1: + n = line.index(min(line)) + traces1.append(line) + traces.append(line[n:] + line[:n]) + else: + line.append(b1) + break + elif line[0] == b1: + line.insert(0, b0) + break + else: + lines1.append([b0, b1]) + + lines = [x for x in lines1 if x not in traces1] + lines = _join_lines(lines) + rest = [] + for line in lines: + for y in line: + rest.append(y) + for line in traces: + for y in line: + rest.append(y) + rest = [x for x in range(len(arguments)) if x not in rest] + + return lines, traces, rest + + +def get_free_indices(t): + if not isinstance(t, TensExpr): + return () + return t.get_free_indices() + + +def get_indices(t): + if not isinstance(t, TensExpr): + return () + return t.get_indices() + +def get_dummy_indices(t): + if not isinstance(t, TensExpr): + return () + inds = t.get_indices() + free = t.get_free_indices() + return [i for i in inds if i not in free] + +def get_index_structure(t): + if isinstance(t, TensExpr): + return t._index_structure + return _IndexStructure([], [], [], []) + + +def get_coeff(t): + if isinstance(t, Tensor): + return S.One + if isinstance(t, TensMul): + return t.coeff + if isinstance(t, TensExpr): + raise ValueError("no coefficient associated to this tensor expression") + return t + +def contract_metric(t, g): + if isinstance(t, TensExpr): + return t.contract_metric(g) + return t + + +def perm2tensor(t, g, is_canon_bp=False): + """ + Returns the tensor corresponding to the permutation ``g`` + + For further details, see the method in ``TIDS`` with the same name. + """ + if not isinstance(t, TensExpr): + return t + elif isinstance(t, (Tensor, TensMul)): + nim = get_index_structure(t).perm2tensor(g, is_canon_bp=is_canon_bp) + res = t._set_new_index_structure(nim, is_canon_bp=is_canon_bp) + if g[-1] != len(g) - 1: + return -res + + return res + raise NotImplementedError() + + +def substitute_indices(t, *index_tuples): + if not isinstance(t, TensExpr): + return t + return t.substitute_indices(*index_tuples) + + +def _expand(expr, **kwargs): + if isinstance(expr, TensExpr): + return expr._expand(**kwargs) + else: + return expr.expand(**kwargs) diff --git a/shared/package-files/30/3054ba7160a1b37681c37bdbfa7db7e29395f3f6187adda339d0cd37496b3248/blob b/shared/package-files/30/3054ba7160a1b37681c37bdbfa7db7e29395f3f6187adda339d0cd37496b3248/blob new file mode 100644 index 0000000000000000000000000000000000000000..bf983f04a3f3f17566299bafe756e95e2727f6ad --- /dev/null +++ b/shared/package-files/30/3054ba7160a1b37681c37bdbfa7db7e29395f3f6187adda339d0cd37496b3248/blob @@ -0,0 +1,115 @@ +import numpy as np +import pytest + +from pandas import ( + MultiIndex, + Series, + date_range, +) +import pandas._testing as tm + + +def test_nlargest(): + a = Series([1, 3, 5, 7, 2, 9, 0, 4, 6, 10]) + b = Series(list("a" * 5 + "b" * 5)) + gb = a.groupby(b) + r = gb.nlargest(3) + e = Series( + [7, 5, 3, 10, 9, 6], + index=MultiIndex.from_arrays([list("aaabbb"), [3, 2, 1, 9, 5, 8]]), + ) + tm.assert_series_equal(r, e) + + a = Series([1, 1, 3, 2, 0, 3, 3, 2, 1, 0]) + gb = a.groupby(b) + e = Series( + [3, 2, 1, 3, 3, 2], + index=MultiIndex.from_arrays([list("aaabbb"), [2, 3, 1, 6, 5, 7]]), + ) + tm.assert_series_equal(gb.nlargest(3, keep="last"), e) + + +def test_nlargest_mi_grouper(): + # see gh-21411 + npr = np.random.default_rng(2) + + dts = date_range("20180101", periods=10) + iterables = [dts, ["one", "two"]] + + idx = MultiIndex.from_product(iterables, names=["first", "second"]) + s = Series(npr.standard_normal(20), index=idx) + + result = s.groupby("first").nlargest(1) + + exp_idx = MultiIndex.from_tuples( + [ + (dts[0], dts[0], "one"), + (dts[1], dts[1], "one"), + (dts[2], dts[2], "one"), + (dts[3], dts[3], "two"), + (dts[4], dts[4], "one"), + (dts[5], dts[5], "one"), + (dts[6], dts[6], "one"), + (dts[7], dts[7], "one"), + (dts[8], dts[8], "one"), + (dts[9], dts[9], "one"), + ], + names=["first", "first", "second"], + ) + + exp_values = [ + 0.18905338179353307, + -0.41306354339189344, + 1.799707382720902, + 0.7738065867276614, + 0.28121066979764925, + 0.9775674511260357, + -0.3288239040579627, + 0.45495807124085547, + 0.5452887139646817, + 0.12682784711186987, + ] + + expected = Series(exp_values, index=exp_idx) + tm.assert_series_equal(result, expected, check_exact=False, rtol=1e-3) + + +def test_nsmallest(): + a = Series([1, 3, 5, 7, 2, 9, 0, 4, 6, 10]) + b = Series(list("a" * 5 + "b" * 5)) + gb = a.groupby(b) + r = gb.nsmallest(3) + e = Series( + [1, 2, 3, 0, 4, 6], + index=MultiIndex.from_arrays([list("aaabbb"), [0, 4, 1, 6, 7, 8]]), + ) + tm.assert_series_equal(r, e) + + a = Series([1, 1, 3, 2, 0, 3, 3, 2, 1, 0]) + gb = a.groupby(b) + e = Series( + [0, 1, 1, 0, 1, 2], + index=MultiIndex.from_arrays([list("aaabbb"), [4, 1, 0, 9, 8, 7]]), + ) + tm.assert_series_equal(gb.nsmallest(3, keep="last"), e) + + +@pytest.mark.parametrize( + "data, groups", + [([0, 1, 2, 3], [0, 0, 1, 1]), ([0], [0])], +) +@pytest.mark.parametrize("dtype", [None, *tm.ALL_INT_NUMPY_DTYPES]) +@pytest.mark.parametrize("method", ["nlargest", "nsmallest"]) +def test_nlargest_and_smallest_noop(data, groups, dtype, method): + # GH 15272, GH 16345, GH 29129 + # Test nlargest/smallest when it results in a noop, + # i.e. input is sorted and group size <= n + if dtype is not None: + data = np.array(data, dtype=dtype) + if method == "nlargest": + data = list(reversed(data)) + ser = Series(data, name="a") + result = getattr(ser.groupby(groups), method)(n=2) + expidx = np.array(groups, dtype=int) if isinstance(groups, list) else groups + expected = Series(data, index=MultiIndex.from_arrays([expidx, ser.index]), name="a") + tm.assert_series_equal(result, expected) diff --git a/shared/package-files/30/3055058b13a54824a729288d1772c97a488cf63cdee84ea99ac3aa5d3a1b277e/blob b/shared/package-files/30/3055058b13a54824a729288d1772c97a488cf63cdee84ea99ac3aa5d3a1b277e/blob new file mode 100644 index 0000000000000000000000000000000000000000..bd06e0f3e30b482f6521c869e605790618742404 --- /dev/null +++ b/shared/package-files/30/3055058b13a54824a729288d1772c97a488cf63cdee84ea99ac3aa5d3a1b277e/blob @@ -0,0 +1,21 @@ +#pragma once + +#include +#include + +namespace torch { +namespace utils { + +const at::Tensor& apply_(const at::Tensor& self, PyObject* fn); +const at::Tensor& map_( + const at::Tensor& self, + const at::Tensor& other_, + PyObject* fn); +const at::Tensor& map2_( + const at::Tensor& self, + const at::Tensor& x_, + const at::Tensor& y_, + PyObject* fn); + +} // namespace utils +} // namespace torch diff --git a/shared/package-files/30/305eeac911fe3f1c4ca18726173c21b69c03a1a7916def04ba430f512ef781a0/blob b/shared/package-files/30/305eeac911fe3f1c4ca18726173c21b69c03a1a7916def04ba430f512ef781a0/blob new file mode 100644 index 0000000000000000000000000000000000000000..0c01a198f804361185c527ac086694a67a0f673e --- /dev/null +++ b/shared/package-files/30/305eeac911fe3f1c4ca18726173c21b69c03a1a7916def04ba430f512ef781a0/blob @@ -0,0 +1,431 @@ +# Copyright 2019 Kakao Brain +# +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +# +# This source code is licensed under the BSD license found in the +# LICENSE file in the root directory of this source tree. +"""The user interface to define skip connections.""" +from typing import ( + TYPE_CHECKING, + Any, + Callable, + ClassVar, + Dict, + FrozenSet, + Generator, + Iterable, + List, + Optional, + Set, + Sequence, + Tuple, + Type, + TypeVar, + Union, + cast, +) + +from torch import Tensor, nn + +from ..microbatch import Batch +from .namespace import Namespace +from .tracker import current_skip_tracker + +__all__ = ["skippable", "stash", "pop", "verify_skippables"] + + +Tensors = Sequence[Tensor] +TensorOrTensors = Union[Tensor, Tensors] + +StashPop = Union["stash", "pop"] +StashPopGenerator = Generator[StashPop, Optional[Tensor], TensorOrTensors] +if TYPE_CHECKING: + # Typechecking: nn.Module is not a Generic + SkippableModule = nn.Module[Union[StashPopGenerator, TensorOrTensors]] # type: ignore[type-arg] +else: + SkippableModule = nn.Module + +T = TypeVar("T", bound="Skippable") + + +class Skippable(nn.Module): + """The base class for skippable modules. + + Do not use this class directly. Define a subclass by :func:`skippable` + instead. + + """ + + module_cls: ClassVar[Type[SkippableModule]] + stashable_names: ClassVar[FrozenSet[str]] + poppable_names: ClassVar[FrozenSet[str]] + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__() + self.module = self.module_cls(*args, **kwargs) # type: ignore[call-arg] + self.namespaces: Dict[str, Namespace] = {} + + def __repr__(self) -> str: + return f"@skippable({self.module})" + + def namespaced(self, name: str) -> Tuple[Namespace, str]: + """Prepend namespace for the given skip name.""" + ns = self.namespaces.get(name) + ns = cast(Namespace, ns) + return (ns, name) + + def stashable(self) -> Iterable[Tuple[Namespace, str]]: + """Iterate over namespaced skip names to be stashed.""" + for name in self.stashable_names: + yield self.namespaced(name) + + def poppable(self) -> Iterable[Tuple[Namespace, str]]: + """Iterate over namespaced skip names to be popped.""" + for name in self.poppable_names: + yield self.namespaced(name) + + def isolate(self: T, ns: Namespace, *, only: Optional[Iterable[str]] = None) -> T: + r"""Isolate a specified subset or the whole set of skip tensors. + + In a single sequential module, skip tensors with the same + name are not allowed unless they are isolated by different namespaces. + + Here's an example using the same name for skip tensors twice. Each pair + of ``Layer1`` and ``Layer2`` is isolated with its own namespace ``ns1`` + and ``ns2``. There is no conflict anymore:: + + ns1 = Namespace() + ns2 = Namespace() + + model = nn.Sequential( + Layer1().isolate(ns1), + Layer1().isolate(ns2), + Layer2(), + Layer3().isolate(ns2), + Layer3().isolate(ns1), + ) + + When `only` parameter is omitted, all skip tensors are isolated. You + can isolate a subset of skip tensors by passing `only` parameter:: + + ns_alice = Namespace() + ns_bob = Namespace() + + model = nn.Sequential( + ... + StashStashPop().isolate(ns_alice, only=['alice']) \ + .isolate(ns_bob, only=['bob']), + ... + ) + + Args: + ns (Namespace): + namespace for isolation + + Keyword Args: + only (iterable of strs): + names of specific skip tensors to be isolated (omit this option + to isolate all skip tensors declared in this module) + + Returns: + this module itself + + """ + names: Iterable[str] + + if only is None: + names = self.stashable_names | self.poppable_names + else: + names = set(only) + + for name in names: + self.namespaces[name] = ns + + return self + + def dispatch( + self, + input, + handle_stash: Callable[[str, Optional[Tensor]], None], + handle_pop: Callable[[str], Optional[Tensor]], + ): + """Dispatch :class:`stash` or :class:`pop` commands. + + The commands are generated by the module's ``forward()``. + """ + generator = self.module(input) + + if not isinstance(generator, Generator): + # The underlying module returned output without any yield. + output = generator + return output + + try: + op = next(generator) + + while True: + if isinstance(op, stash): + handle_stash(op.name, op.tensor) + op = next(generator) + continue + + if isinstance(op, pop): + tensor = handle_pop(op.name) + op = generator.send(tensor) + continue + + raise TypeError(f"{op!r} is not a command from @skippable") + + except StopIteration as stop: + output = stop.args[0] + return output + + def forward(self, input: Union[List[Any], Tensor]) -> TensorOrTensors: + """Perform the forward propagation. + + :class:`stash` or :class:`pop` commands will be handled by portals + silently. The portals won't be exposed to users. + + Raises: + RuntimeError: + illegal 'stash' or 'pop' is found. + + """ + skip_tracker = current_skip_tracker() + stashed_tensors: Dict[str, Optional[Tensor]] = {} + + # Load skip tensors that might be popped. + poppable_tensors = {} + batch = Batch(input) + for ns, name in self.poppable(): + try: + poppable_tensors[name] = skip_tracker.load(batch, ns, name) + except KeyError as e: + raise RuntimeError(f"'{name}' has not been stashed") from e + input = batch.values + + # Handle skip commands. + def handle_stash(name: str, tensor: Optional[Tensor]) -> None: + if name not in self.stashable_names: + raise RuntimeError(f"'{name}' has not been declared as stashable") + stashed_tensors[name] = tensor + + def handle_pop(name: str) -> Optional[Tensor]: + if name not in self.poppable_names: + raise RuntimeError(f"'{name}' has not been declared as poppable") + return poppable_tensors.pop(name) + + output = self.dispatch(input, handle_stash, handle_pop) + + # All declared skips must be stashed or popped. + not_stashed = self.stashable_names - stashed_tensors.keys() + if not_stashed: + comma_names = ", ".join(f"'{n}'" for n in not_stashed) + raise RuntimeError(f"{comma_names} must be stashed but have not") + + not_popped = poppable_tensors.keys() + if not_popped: + comma_names = ", ".join(f"'{n}'" for n in not_popped) + raise RuntimeError(f"{comma_names} must be popped but have not") + + # Save stashed skip tensors. + batch = Batch(output) + for ns, name in self.stashable(): + tensor = stashed_tensors[name] + skip_tracker.save(batch, ns, name, tensor) + output = batch.values + + return output + + +# TODO(sublee): Move to above of Skippable class for better read flow. +def skippable( + stash: Iterable[str] = (), pop: Iterable[str] = (), +) -> Callable[[Type[SkippableModule]], Type[Skippable]]: + """Define a decorator to create :class:`nn.Module ` with skip connections. + + These decorated modules are called "skippable". This functionality works perfectly + fine even when the module is not wrapped by :class:`~torch.distributed.pipeline.sync.Pipe`. + + Each skip tensor is managed by its name. Before manipulating skip tensors, + a skippable module must statically declare the names for skip tensors by + `stash` and/or `pop` parameters. Skip tensors with pre-declared name can be + stashed by ``yield stash(name, tensor)`` or popped by ``tensor = yield + pop(name)``. + + Here is an example with three layers. A skip tensor named "1to3" is stashed + and popped at the first and last layer, respectively:: + + @skippable(stash=['1to3']) + class Layer1(nn.Module): + def forward(self, input): + yield stash('1to3', input) + return f1(input) + + class Layer2(nn.Module): + def forward(self, input): + return f2(input) + + @skippable(pop=['1to3']) + class Layer3(nn.Module): + def forward(self, input): + skip_1to3 = yield pop('1to3') + return f3(input) + skip_1to3 + + model = nn.Sequential(Layer1(), Layer2(), Layer3()) + + One skippable module can stash or pop multiple skip tensors:: + + @skippable(stash=['alice', 'bob'], pop=['carol']) + class StashStashPop(nn.Module): + def forward(self, input): + yield stash('alice', f_alice(input)) + yield stash('bob', f_bob(input)) + carol = yield pop('carol') + return input + carol + + Every skip tensor must be associated with exactly one pair of `stash` and + `pop`. :class:`~torch.distributed.pipeline.sync.Pipe` checks this + restriction automatically when wrapping a module. You can also check the + restriction by :func:`verify_skippables` + without :class:`~torch.distributed.pipeline.sync.Pipe`. + + """ + stashable_names = frozenset(stash) + poppable_names = frozenset(pop) + + def extend_skippable(module_cls: Type[SkippableModule]) -> Type[Skippable]: + name = module_cls.__name__ + bases = (Skippable,) + attrs = {"module_cls": module_cls, "stashable_names": stashable_names, "poppable_names": poppable_names} + return type(name, bases, attrs) + + return extend_skippable + + +class stash: + """The command to stash a skip tensor. + + :: + + def forward(self, input): + yield stash('name', input) + return f(input) + + Args: + name (str): name of skip tensor + input (torch.Tensor or None): tensor to pass to the skip connection + + """ + + __slots__ = ("name", "tensor") + + def __init__(self, name: str, tensor: Optional[Tensor]) -> None: + self.name = name + self.tensor = tensor + + +class pop: + """The command to pop a skip tensor. + + :: + + def forward(self, input): + skip = yield pop('name') + return f(input) + skip + + Args: + name (str): name of skip tensor + + Returns: + the skip tensor previously stashed by another layer under the same name + + """ + + __slots__ = ("name",) + + def __init__(self, name: str) -> None: + self.name = name + + +def verify_skippables(module: nn.Sequential) -> None: + """Verify if the underlying skippable modules satisfy integrity. + + Every skip tensor must have only one pair of `stash` and `pop`. If there + are one or more unmatched pairs, it will raise :exc:`TypeError` with the + detailed messages. + + Here are a few failure cases. :func:`verify_skippables` will report failure + for these cases:: + + # Layer1 stashes "1to3". + # Layer3 pops "1to3". + + nn.Sequential(Layer1(), Layer2()) + # └──── ? + + nn.Sequential(Layer2(), Layer3()) + # ? ────┘ + + nn.Sequential(Layer1(), Layer2(), Layer3(), Layer3()) + # └───────────────────┘ ^^^^^^ + + nn.Sequential(Layer1(), Layer1(), Layer2(), Layer3()) + # ^^^^^^ └───────────────────┘ + + To use the same name for multiple skip tensors, they must be isolated by + different namespaces. See :meth:`isolate() + `. + + Raises: + TypeError: + one or more pairs of `stash` and `pop` are not matched. + + """ + stashed: Set[Tuple[Namespace, str]] = set() + popped: Set[Tuple[Namespace, str]] = set() + msgs: List[str] = [] + + for layer_name, layer in module.named_children(): + if not isinstance(layer, Skippable): + continue + + for name in layer.stashable_names & layer.poppable_names: + msg = f"'{layer_name}' declared '{name}' both as stashable and as poppable" + msgs.append(msg) + + for ns, name in layer.stashable(): + if name in layer.poppable_names: + continue + + if (ns, name) in stashed: + msg = f"'{layer_name}' redeclared '{name}' as stashable but not isolated by namespace" + msgs.append(msg) + continue + + stashed.add((ns, name)) + + for ns, name in layer.poppable(): + if name in layer.stashable_names: + continue + + if (ns, name) in popped: + msg = f"'{layer_name}' redeclared '{name}' as poppable but not isolated by namespace" + msgs.append(msg) + continue + + if (ns, name) not in stashed: + msg = f"'{layer_name}' declared '{name}' as poppable but it was not stashed" + msgs.append(msg) + continue + + popped.add((ns, name)) + + for (_, name) in stashed - popped: + msg = f"no module declared '{name}' as poppable but stashed" + msgs.append(msg) + + if msgs: + raise TypeError( + "one or more pairs of stash and pop do not match:\n\n%s" "" % "\n".join("* %s" % x for x in msgs) + ) diff --git a/shared/package-files/30/306290415b6833aa273643ba6aa477b33558996f8e29f5494f8cd6c185d22fdb/blob b/shared/package-files/30/306290415b6833aa273643ba6aa477b33558996f8e29f5494f8cd6c185d22fdb/blob new file mode 100644 index 0000000000000000000000000000000000000000..cd042073ea98193f0b0a990c6bb8ee4c8594e6a8 --- /dev/null +++ b/shared/package-files/30/306290415b6833aa273643ba6aa477b33558996f8e29f5494f8cd6c185d22fdb/blob @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor argsort(const at::Tensor & self, bool stable, int64_t dim=-1, bool descending=false); + +} // namespace cuda +} // namespace at diff --git a/shared/package-files/30/306322d62980ad3cd8844a6010e49a083ed9f64f98e456aaf94f5927a6c877bd/blob b/shared/package-files/30/306322d62980ad3cd8844a6010e49a083ed9f64f98e456aaf94f5927a6c877bd/blob new file mode 100644 index 0000000000000000000000000000000000000000..34c0e024dcd5924c7287e6ce8105975c4d9ab7f5 Binary files /dev/null and b/shared/package-files/30/306322d62980ad3cd8844a6010e49a083ed9f64f98e456aaf94f5927a6c877bd/blob differ diff --git a/shared/package-files/30/3064124d0eac2adf5abac925e1368b0f8ca1e6be8e39549abbdd048377a02ef5/blob b/shared/package-files/30/3064124d0eac2adf5abac925e1368b0f8ca1e6be8e39549abbdd048377a02ef5/blob new file mode 100644 index 0000000000000000000000000000000000000000..e3465a8e6f977747e7299f5f680d3293d52b7586 --- /dev/null +++ b/shared/package-files/30/3064124d0eac2adf5abac925e1368b0f8ca1e6be8e39549abbdd048377a02ef5/blob @@ -0,0 +1,28 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API fbgemm_linear_fp16_weight { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::fbgemm_linear_fp16_weight") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "fbgemm_linear_fp16_weight(Tensor input, Tensor packed_weight, Tensor bias) -> Tensor") + static at::Tensor call(const at::Tensor & input, const at::Tensor & packed_weight, const at::Tensor & bias); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const at::Tensor & packed_weight, const at::Tensor & bias); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/30/306506253bca633a374609e3ca43b94ce63fa29d1fb03ba2e691ea92b25954f7/blob b/shared/package-files/30/306506253bca633a374609e3ca43b94ce63fa29d1fb03ba2e691ea92b25954f7/blob new file mode 100644 index 0000000000000000000000000000000000000000..45be9d7513b5bb8956986f05c2fb9fa94f25b563 --- /dev/null +++ b/shared/package-files/30/306506253bca633a374609e3ca43b94ce63fa29d1fb03ba2e691ea92b25954f7/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API col2im_out { + using schema = at::Tensor & (const at::Tensor &, c10::SymIntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::col2im") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "col2im.out(Tensor self, SymInt[2] output_size, int[2] kernel_size, int[2] dilation, int[2] padding, int[2] stride, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, c10::SymIntArrayRef output_size, at::IntArrayRef kernel_size, at::IntArrayRef dilation, at::IntArrayRef padding, at::IntArrayRef stride, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, c10::SymIntArrayRef output_size, at::IntArrayRef kernel_size, at::IntArrayRef dilation, at::IntArrayRef padding, at::IntArrayRef stride, at::Tensor & out); +}; + +struct TORCH_API col2im { + using schema = at::Tensor (const at::Tensor &, c10::SymIntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef, at::IntArrayRef); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::col2im") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "col2im(Tensor self, SymInt[2] output_size, int[2] kernel_size, int[2] dilation, int[2] padding, int[2] stride) -> Tensor") + static at::Tensor call(const at::Tensor & self, c10::SymIntArrayRef output_size, at::IntArrayRef kernel_size, at::IntArrayRef dilation, at::IntArrayRef padding, at::IntArrayRef stride); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, c10::SymIntArrayRef output_size, at::IntArrayRef kernel_size, at::IntArrayRef dilation, at::IntArrayRef padding, at::IntArrayRef stride); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/30/3065be6f11db29e63b171a408fe14e14ed6477fc0d2a6ab212577ab7f3aea263/blob b/shared/package-files/30/3065be6f11db29e63b171a408fe14e14ed6477fc0d2a6ab212577ab7f3aea263/blob new file mode 100644 index 0000000000000000000000000000000000000000..e6e4a11a0f5ab4056606a127f8ed61ee3a4456a8 --- /dev/null +++ b/shared/package-files/30/3065be6f11db29e63b171a408fe14e14ed6477fc0d2a6ab212577ab7f3aea263/blob @@ -0,0 +1,133 @@ +import numpy as np +import pytest + +from pandas._libs.sparse import IntIndex + +from pandas import ( + SparseDtype, + Timestamp, +) +import pandas._testing as tm +from pandas.core.arrays.sparse import SparseArray + + +class TestAstype: + def test_astype(self): + # float -> float + arr = SparseArray([None, None, 0, 2]) + result = arr.astype("Sparse[float32]") + expected = SparseArray([None, None, 0, 2], dtype=np.dtype("float32")) + tm.assert_sp_array_equal(result, expected) + + dtype = SparseDtype("float64", fill_value=0) + result = arr.astype(dtype) + expected = SparseArray._simple_new( + np.array([0.0, 2.0], dtype=dtype.subtype), IntIndex(4, [2, 3]), dtype + ) + tm.assert_sp_array_equal(result, expected) + + dtype = SparseDtype("int64", 0) + result = arr.astype(dtype) + expected = SparseArray._simple_new( + np.array([0, 2], dtype=np.int64), IntIndex(4, [2, 3]), dtype + ) + tm.assert_sp_array_equal(result, expected) + + arr = SparseArray([0, np.nan, 0, 1], fill_value=0) + with pytest.raises(ValueError, match="NA"): + arr.astype("Sparse[i8]") + + def test_astype_bool(self): + a = SparseArray([1, 0, 0, 1], dtype=SparseDtype(int, 0)) + result = a.astype(bool) + expected = np.array([1, 0, 0, 1], dtype=bool) + tm.assert_numpy_array_equal(result, expected) + + # update fill value + result = a.astype(SparseDtype(bool, False)) + expected = SparseArray( + [True, False, False, True], dtype=SparseDtype(bool, False) + ) + tm.assert_sp_array_equal(result, expected) + + def test_astype_all(self, any_real_numpy_dtype): + vals = np.array([1, 2, 3]) + arr = SparseArray(vals, fill_value=1) + typ = np.dtype(any_real_numpy_dtype) + res = arr.astype(typ) + tm.assert_numpy_array_equal(res, vals.astype(any_real_numpy_dtype)) + + @pytest.mark.parametrize( + "arr, dtype, expected", + [ + ( + SparseArray([0, 1]), + "float", + SparseArray([0.0, 1.0], dtype=SparseDtype(float, 0.0)), + ), + (SparseArray([0, 1]), bool, SparseArray([False, True])), + ( + SparseArray([0, 1], fill_value=1), + bool, + SparseArray([False, True], dtype=SparseDtype(bool, True)), + ), + pytest.param( + SparseArray([0, 1]), + "datetime64[ns]", + SparseArray( + np.array([0, 1], dtype="datetime64[ns]"), + dtype=SparseDtype("datetime64[ns]", Timestamp("1970")), + ), + ), + ( + SparseArray([0, 1, 10]), + np.str_, + SparseArray(["0", "1", "10"], dtype=SparseDtype(np.str_, "0")), + ), + (SparseArray(["10", "20"]), float, SparseArray([10.0, 20.0])), + ( + SparseArray([0, 1, 0]), + object, + SparseArray([0, 1, 0], dtype=SparseDtype(object, 0)), + ), + ], + ) + def test_astype_more(self, arr, dtype, expected): + result = arr.astype(arr.dtype.update_dtype(dtype)) + tm.assert_sp_array_equal(result, expected) + + def test_astype_nan_raises(self): + arr = SparseArray([1.0, np.nan]) + with pytest.raises(ValueError, match="Cannot convert non-finite"): + arr.astype(int) + + def test_astype_copy_false(self): + # GH#34456 bug caused by using .view instead of .astype in astype_nansafe + arr = SparseArray([1, 2, 3]) + + dtype = SparseDtype(float, 0) + + result = arr.astype(dtype, copy=False) + expected = SparseArray([1.0, 2.0, 3.0], fill_value=0.0) + tm.assert_sp_array_equal(result, expected) + + def test_astype_dt64_to_int64(self): + # GH#49631 match non-sparse behavior + values = np.array(["NaT", "2016-01-02", "2016-01-03"], dtype="M8[ns]") + + arr = SparseArray(values) + result = arr.astype("int64") + expected = values.astype("int64") + tm.assert_numpy_array_equal(result, expected) + + # we should also be able to cast to equivalent Sparse[int64] + dtype_int64 = SparseDtype("int64", np.iinfo(np.int64).min) + result2 = arr.astype(dtype_int64) + tm.assert_numpy_array_equal(result2.to_numpy(), expected) + + # GH#50087 we should match the non-sparse behavior regardless of + # if we have a fill_value other than NaT + dtype = SparseDtype("datetime64[ns]", values[1]) + arr3 = SparseArray(values, dtype=dtype) + result3 = arr3.astype("int64") + tm.assert_numpy_array_equal(result3, expected) diff --git a/shared/package-files/30/306777b0fe8b370a44951896f39887c411229e16a8865cb481f38bc61b54b3bb/blob b/shared/package-files/30/306777b0fe8b370a44951896f39887c411229e16a8865cb481f38bc61b54b3bb/blob new file mode 100644 index 0000000000000000000000000000000000000000..0b47c57cb3a12c6f4a7adb5506089c569336b4c4 --- /dev/null +++ b/shared/package-files/30/306777b0fe8b370a44951896f39887c411229e16a8865cb481f38bc61b54b3bb/blob @@ -0,0 +1,1131 @@ +""" +Unified interfaces to minimization algorithms. + +Functions +--------- +- minimize : minimization of a function of several variables. +- minimize_scalar : minimization of a function of one variable. +""" + +__all__ = ['minimize', 'minimize_scalar'] + + +from warnings import warn + +import numpy as np + +# unconstrained minimization +from ._optimize import (_minimize_neldermead, _minimize_powell, _minimize_cg, + _minimize_bfgs, _minimize_newtoncg, + _minimize_scalar_brent, _minimize_scalar_bounded, + _minimize_scalar_golden, MemoizeJac, OptimizeResult, + _wrap_callback, _recover_from_bracket_error) +from ._trustregion_dogleg import _minimize_dogleg +from ._trustregion_ncg import _minimize_trust_ncg +from ._trustregion_krylov import _minimize_trust_krylov +from ._trustregion_exact import _minimize_trustregion_exact +from ._trustregion_constr import _minimize_trustregion_constr + +# constrained minimization +from ._lbfgsb_py import _minimize_lbfgsb +from ._tnc import _minimize_tnc +from ._cobyla_py import _minimize_cobyla +from ._cobyqa_py import _minimize_cobyqa +from ._slsqp_py import _minimize_slsqp +from ._constraints import (old_bound_to_new, new_bounds_to_old, + old_constraint_to_new, new_constraint_to_old, + NonlinearConstraint, LinearConstraint, Bounds, + PreparedConstraint) +from ._differentiable_functions import FD_METHODS + +MINIMIZE_METHODS = ['nelder-mead', 'powell', 'cg', 'bfgs', 'newton-cg', + 'l-bfgs-b', 'tnc', 'cobyla', 'cobyqa', 'slsqp', + 'trust-constr', 'dogleg', 'trust-ncg', 'trust-exact', + 'trust-krylov'] + +# These methods support the new callback interface (passed an OptimizeResult) +MINIMIZE_METHODS_NEW_CB = ['nelder-mead', 'powell', 'cg', 'bfgs', 'newton-cg', + 'l-bfgs-b', 'trust-constr', 'dogleg', 'trust-ncg', + 'trust-exact', 'trust-krylov', 'cobyqa'] + +MINIMIZE_SCALAR_METHODS = ['brent', 'bounded', 'golden'] + +def minimize(fun, x0, args=(), method=None, jac=None, hess=None, + hessp=None, bounds=None, constraints=(), tol=None, + callback=None, options=None): + """Minimization of scalar function of one or more variables. + + Parameters + ---------- + fun : callable + The objective function to be minimized:: + + fun(x, *args) -> float + + where ``x`` is a 1-D array with shape (n,) and ``args`` + is a tuple of the fixed parameters needed to completely + specify the function. + + Suppose the callable has signature ``f0(x, *my_args, **my_kwargs)``, where + ``my_args`` and ``my_kwargs`` are required positional and keyword arguments. + Rather than passing ``f0`` as the callable, wrap it to accept + only ``x``; e.g., pass ``fun=lambda x: f0(x, *my_args, **my_kwargs)`` as the + callable, where ``my_args`` (tuple) and ``my_kwargs`` (dict) have been + gathered before invoking this function. + x0 : ndarray, shape (n,) + Initial guess. Array of real elements of size (n,), + where ``n`` is the number of independent variables. + args : tuple, optional + Extra arguments passed to the objective function and its + derivatives (`fun`, `jac` and `hess` functions). + method : str or callable, optional + Type of solver. Should be one of + + - 'Nelder-Mead' :ref:`(see here) ` + - 'Powell' :ref:`(see here) ` + - 'CG' :ref:`(see here) ` + - 'BFGS' :ref:`(see here) ` + - 'Newton-CG' :ref:`(see here) ` + - 'L-BFGS-B' :ref:`(see here) ` + - 'TNC' :ref:`(see here) ` + - 'COBYLA' :ref:`(see here) ` + - 'COBYQA' :ref:`(see here) ` + - 'SLSQP' :ref:`(see here) ` + - 'trust-constr':ref:`(see here) ` + - 'dogleg' :ref:`(see here) ` + - 'trust-ncg' :ref:`(see here) ` + - 'trust-exact' :ref:`(see here) ` + - 'trust-krylov' :ref:`(see here) ` + - custom - a callable object, see below for description. + + If not given, chosen to be one of ``BFGS``, ``L-BFGS-B``, ``SLSQP``, + depending on whether or not the problem has constraints or bounds. + jac : {callable, '2-point', '3-point', 'cs', bool}, optional + Method for computing the gradient vector. Only for CG, BFGS, + Newton-CG, L-BFGS-B, TNC, SLSQP, dogleg, trust-ncg, trust-krylov, + trust-exact and trust-constr. + If it is a callable, it should be a function that returns the gradient + vector:: + + jac(x, *args) -> array_like, shape (n,) + + where ``x`` is an array with shape (n,) and ``args`` is a tuple with + the fixed parameters. If `jac` is a Boolean and is True, `fun` is + assumed to return a tuple ``(f, g)`` containing the objective + function and the gradient. + Methods 'Newton-CG', 'trust-ncg', 'dogleg', 'trust-exact', and + 'trust-krylov' require that either a callable be supplied, or that + `fun` return the objective and gradient. + If None or False, the gradient will be estimated using 2-point finite + difference estimation with an absolute step size. + Alternatively, the keywords {'2-point', '3-point', 'cs'} can be used + to select a finite difference scheme for numerical estimation of the + gradient with a relative step size. These finite difference schemes + obey any specified `bounds`. + hess : {callable, '2-point', '3-point', 'cs', HessianUpdateStrategy}, optional + Method for computing the Hessian matrix. Only for Newton-CG, dogleg, + trust-ncg, trust-krylov, trust-exact and trust-constr. + If it is callable, it should return the Hessian matrix:: + + hess(x, *args) -> {LinearOperator, spmatrix, array}, (n, n) + + where ``x`` is a (n,) ndarray and ``args`` is a tuple with the fixed + parameters. + The keywords {'2-point', '3-point', 'cs'} can also be used to select + a finite difference scheme for numerical estimation of the hessian. + Alternatively, objects implementing the `HessianUpdateStrategy` + interface can be used to approximate the Hessian. Available + quasi-Newton methods implementing this interface are: + + - `BFGS` + - `SR1` + + Not all of the options are available for each of the methods; for + availability refer to the notes. + hessp : callable, optional + Hessian of objective function times an arbitrary vector p. Only for + Newton-CG, trust-ncg, trust-krylov, trust-constr. + Only one of `hessp` or `hess` needs to be given. If `hess` is + provided, then `hessp` will be ignored. `hessp` must compute the + Hessian times an arbitrary vector:: + + hessp(x, p, *args) -> ndarray shape (n,) + + where ``x`` is a (n,) ndarray, ``p`` is an arbitrary vector with + dimension (n,) and ``args`` is a tuple with the fixed + parameters. + bounds : sequence or `Bounds`, optional + Bounds on variables for Nelder-Mead, L-BFGS-B, TNC, SLSQP, Powell, + trust-constr, COBYLA, and COBYQA methods. There are two ways to specify + the bounds: + + 1. Instance of `Bounds` class. + 2. Sequence of ``(min, max)`` pairs for each element in `x`. None + is used to specify no bound. + + constraints : {Constraint, dict} or List of {Constraint, dict}, optional + Constraints definition. Only for COBYLA, COBYQA, SLSQP and trust-constr. + + Constraints for 'trust-constr' and 'cobyqa' are defined as a single object + or a list of objects specifying constraints to the optimization problem. + Available constraints are: + + - `LinearConstraint` + - `NonlinearConstraint` + + Constraints for COBYLA, SLSQP are defined as a list of dictionaries. + Each dictionary with fields: + + type : str + Constraint type: 'eq' for equality, 'ineq' for inequality. + fun : callable + The function defining the constraint. + jac : callable, optional + The Jacobian of `fun` (only for SLSQP). + args : sequence, optional + Extra arguments to be passed to the function and Jacobian. + + Equality constraint means that the constraint function result is to + be zero whereas inequality means that it is to be non-negative. + Note that COBYLA only supports inequality constraints. + + tol : float, optional + Tolerance for termination. When `tol` is specified, the selected + minimization algorithm sets some relevant solver-specific tolerance(s) + equal to `tol`. For detailed control, use solver-specific + options. + options : dict, optional + A dictionary of solver options. All methods except `TNC` accept the + following generic options: + + maxiter : int + Maximum number of iterations to perform. Depending on the + method each iteration may use several function evaluations. + + For `TNC` use `maxfun` instead of `maxiter`. + disp : bool + Set to True to print convergence messages. + + For method-specific options, see :func:`show_options()`. + callback : callable, optional + A callable called after each iteration. + + All methods except TNC, SLSQP, and COBYLA support a callable with + the signature:: + + callback(intermediate_result: OptimizeResult) + + where ``intermediate_result`` is a keyword parameter containing an + `OptimizeResult` with attributes ``x`` and ``fun``, the present values + of the parameter vector and objective function. Note that the name + of the parameter must be ``intermediate_result`` for the callback + to be passed an `OptimizeResult`. These methods will also terminate if + the callback raises ``StopIteration``. + + All methods except trust-constr (also) support a signature like:: + + callback(xk) + + where ``xk`` is the current parameter vector. + + Introspection is used to determine which of the signatures above to + invoke. + + Returns + ------- + res : OptimizeResult + The optimization result represented as a ``OptimizeResult`` object. + Important attributes are: ``x`` the solution array, ``success`` a + Boolean flag indicating if the optimizer exited successfully and + ``message`` which describes the cause of the termination. See + `OptimizeResult` for a description of other attributes. + + See also + -------- + minimize_scalar : Interface to minimization algorithms for scalar + univariate functions + show_options : Additional options accepted by the solvers + + Notes + ----- + This section describes the available solvers that can be selected by the + 'method' parameter. The default method is *BFGS*. + + **Unconstrained minimization** + + Method :ref:`CG ` uses a nonlinear conjugate + gradient algorithm by Polak and Ribiere, a variant of the + Fletcher-Reeves method described in [5]_ pp.120-122. Only the + first derivatives are used. + + Method :ref:`BFGS ` uses the quasi-Newton + method of Broyden, Fletcher, Goldfarb, and Shanno (BFGS) [5]_ + pp. 136. It uses the first derivatives only. BFGS has proven good + performance even for non-smooth optimizations. This method also + returns an approximation of the Hessian inverse, stored as + `hess_inv` in the OptimizeResult object. + + Method :ref:`Newton-CG ` uses a + Newton-CG algorithm [5]_ pp. 168 (also known as the truncated + Newton method). It uses a CG method to the compute the search + direction. See also *TNC* method for a box-constrained + minimization with a similar algorithm. Suitable for large-scale + problems. + + Method :ref:`dogleg ` uses the dog-leg + trust-region algorithm [5]_ for unconstrained minimization. This + algorithm requires the gradient and Hessian; furthermore the + Hessian is required to be positive definite. + + Method :ref:`trust-ncg ` uses the + Newton conjugate gradient trust-region algorithm [5]_ for + unconstrained minimization. This algorithm requires the gradient + and either the Hessian or a function that computes the product of + the Hessian with a given vector. Suitable for large-scale problems. + + Method :ref:`trust-krylov ` uses + the Newton GLTR trust-region algorithm [14]_, [15]_ for unconstrained + minimization. This algorithm requires the gradient + and either the Hessian or a function that computes the product of + the Hessian with a given vector. Suitable for large-scale problems. + On indefinite problems it requires usually less iterations than the + `trust-ncg` method and is recommended for medium and large-scale problems. + + Method :ref:`trust-exact ` + is a trust-region method for unconstrained minimization in which + quadratic subproblems are solved almost exactly [13]_. This + algorithm requires the gradient and the Hessian (which is + *not* required to be positive definite). It is, in many + situations, the Newton method to converge in fewer iterations + and the most recommended for small and medium-size problems. + + **Bound-Constrained minimization** + + Method :ref:`Nelder-Mead ` uses the + Simplex algorithm [1]_, [2]_. This algorithm is robust in many + applications. However, if numerical computation of derivative can be + trusted, other algorithms using the first and/or second derivatives + information might be preferred for their better performance in + general. + + Method :ref:`L-BFGS-B ` uses the L-BFGS-B + algorithm [6]_, [7]_ for bound constrained minimization. + + Method :ref:`Powell ` is a modification + of Powell's method [3]_, [4]_ which is a conjugate direction + method. It performs sequential one-dimensional minimizations along + each vector of the directions set (`direc` field in `options` and + `info`), which is updated at each iteration of the main + minimization loop. The function need not be differentiable, and no + derivatives are taken. If bounds are not provided, then an + unbounded line search will be used. If bounds are provided and + the initial guess is within the bounds, then every function + evaluation throughout the minimization procedure will be within + the bounds. If bounds are provided, the initial guess is outside + the bounds, and `direc` is full rank (default has full rank), then + some function evaluations during the first iteration may be + outside the bounds, but every function evaluation after the first + iteration will be within the bounds. If `direc` is not full rank, + then some parameters may not be optimized and the solution is not + guaranteed to be within the bounds. + + Method :ref:`TNC ` uses a truncated Newton + algorithm [5]_, [8]_ to minimize a function with variables subject + to bounds. This algorithm uses gradient information; it is also + called Newton Conjugate-Gradient. It differs from the *Newton-CG* + method described above as it wraps a C implementation and allows + each variable to be given upper and lower bounds. + + **Constrained Minimization** + + Method :ref:`COBYLA ` uses the + Constrained Optimization BY Linear Approximation (COBYLA) method + [9]_, [10]_, [11]_. The algorithm is based on linear + approximations to the objective function and each constraint. The + method wraps a FORTRAN implementation of the algorithm. The + constraints functions 'fun' may return either a single number + or an array or list of numbers. + + Method :ref:`COBYQA ` uses the Constrained + Optimization BY Quadratic Approximations (COBYQA) method [18]_. The + algorithm is a derivative-free trust-region SQP method based on quadratic + approximations to the objective function and each nonlinear constraint. The + bounds are treated as unrelaxable constraints, in the sense that the + algorithm always respects them throughout the optimization process. + + Method :ref:`SLSQP ` uses Sequential + Least SQuares Programming to minimize a function of several + variables with any combination of bounds, equality and inequality + constraints. The method wraps the SLSQP Optimization subroutine + originally implemented by Dieter Kraft [12]_. Note that the + wrapper handles infinite values in bounds by converting them into + large floating values. + + Method :ref:`trust-constr ` is a + trust-region algorithm for constrained optimization. It switches + between two implementations depending on the problem definition. + It is the most versatile constrained minimization algorithm + implemented in SciPy and the most appropriate for large-scale problems. + For equality constrained problems it is an implementation of Byrd-Omojokun + Trust-Region SQP method described in [17]_ and in [5]_, p. 549. When + inequality constraints are imposed as well, it switches to the trust-region + interior point method described in [16]_. This interior point algorithm, + in turn, solves inequality constraints by introducing slack variables + and solving a sequence of equality-constrained barrier problems + for progressively smaller values of the barrier parameter. + The previously described equality constrained SQP method is + used to solve the subproblems with increasing levels of accuracy + as the iterate gets closer to a solution. + + **Finite-Difference Options** + + For Method :ref:`trust-constr ` + the gradient and the Hessian may be approximated using + three finite-difference schemes: {'2-point', '3-point', 'cs'}. + The scheme 'cs' is, potentially, the most accurate but it + requires the function to correctly handle complex inputs and to + be differentiable in the complex plane. The scheme '3-point' is more + accurate than '2-point' but requires twice as many operations. If the + gradient is estimated via finite-differences the Hessian must be + estimated using one of the quasi-Newton strategies. + + **Method specific options for the** `hess` **keyword** + + +--------------+------+----------+-------------------------+-----+ + | method/Hess | None | callable | '2-point/'3-point'/'cs' | HUS | + +==============+======+==========+=========================+=====+ + | Newton-CG | x | (n, n) | x | x | + | | | LO | | | + +--------------+------+----------+-------------------------+-----+ + | dogleg | | (n, n) | | | + +--------------+------+----------+-------------------------+-----+ + | trust-ncg | | (n, n) | x | x | + +--------------+------+----------+-------------------------+-----+ + | trust-krylov | | (n, n) | x | x | + +--------------+------+----------+-------------------------+-----+ + | trust-exact | | (n, n) | | | + +--------------+------+----------+-------------------------+-----+ + | trust-constr | x | (n, n) | x | x | + | | | LO | | | + | | | sp | | | + +--------------+------+----------+-------------------------+-----+ + + where LO=LinearOperator, sp=Sparse matrix, HUS=HessianUpdateStrategy + + **Custom minimizers** + + It may be useful to pass a custom minimization method, for example + when using a frontend to this method such as `scipy.optimize.basinhopping` + or a different library. You can simply pass a callable as the ``method`` + parameter. + + The callable is called as ``method(fun, x0, args, **kwargs, **options)`` + where ``kwargs`` corresponds to any other parameters passed to `minimize` + (such as `callback`, `hess`, etc.), except the `options` dict, which has + its contents also passed as `method` parameters pair by pair. Also, if + `jac` has been passed as a bool type, `jac` and `fun` are mangled so that + `fun` returns just the function values and `jac` is converted to a function + returning the Jacobian. The method shall return an `OptimizeResult` + object. + + The provided `method` callable must be able to accept (and possibly ignore) + arbitrary parameters; the set of parameters accepted by `minimize` may + expand in future versions and then these parameters will be passed to + the method. You can find an example in the scipy.optimize tutorial. + + References + ---------- + .. [1] Nelder, J A, and R Mead. 1965. A Simplex Method for Function + Minimization. The Computer Journal 7: 308-13. + .. [2] Wright M H. 1996. Direct search methods: Once scorned, now + respectable, in Numerical Analysis 1995: Proceedings of the 1995 + Dundee Biennial Conference in Numerical Analysis (Eds. D F + Griffiths and G A Watson). Addison Wesley Longman, Harlow, UK. + 191-208. + .. [3] Powell, M J D. 1964. An efficient method for finding the minimum of + a function of several variables without calculating derivatives. The + Computer Journal 7: 155-162. + .. [4] Press W, S A Teukolsky, W T Vetterling and B P Flannery. + Numerical Recipes (any edition), Cambridge University Press. + .. [5] Nocedal, J, and S J Wright. 2006. Numerical Optimization. + Springer New York. + .. [6] Byrd, R H and P Lu and J. Nocedal. 1995. A Limited Memory + Algorithm for Bound Constrained Optimization. SIAM Journal on + Scientific and Statistical Computing 16 (5): 1190-1208. + .. [7] Zhu, C and R H Byrd and J Nocedal. 1997. L-BFGS-B: Algorithm + 778: L-BFGS-B, FORTRAN routines for large scale bound constrained + optimization. ACM Transactions on Mathematical Software 23 (4): + 550-560. + .. [8] Nash, S G. Newton-Type Minimization Via the Lanczos Method. + 1984. SIAM Journal of Numerical Analysis 21: 770-778. + .. [9] Powell, M J D. A direct search optimization method that models + the objective and constraint functions by linear interpolation. + 1994. Advances in Optimization and Numerical Analysis, eds. S. Gomez + and J-P Hennart, Kluwer Academic (Dordrecht), 51-67. + .. [10] Powell M J D. Direct search algorithms for optimization + calculations. 1998. Acta Numerica 7: 287-336. + .. [11] Powell M J D. A view of algorithms for optimization without + derivatives. 2007.Cambridge University Technical Report DAMTP + 2007/NA03 + .. [12] Kraft, D. A software package for sequential quadratic + programming. 1988. Tech. Rep. DFVLR-FB 88-28, DLR German Aerospace + Center -- Institute for Flight Mechanics, Koln, Germany. + .. [13] Conn, A. R., Gould, N. I., and Toint, P. L. + Trust region methods. 2000. Siam. pp. 169-200. + .. [14] F. Lenders, C. Kirches, A. Potschka: "trlib: A vector-free + implementation of the GLTR method for iterative solution of + the trust region problem", :arxiv:`1611.04718` + .. [15] N. Gould, S. Lucidi, M. Roma, P. Toint: "Solving the + Trust-Region Subproblem using the Lanczos Method", + SIAM J. Optim., 9(2), 504--525, (1999). + .. [16] Byrd, Richard H., Mary E. Hribar, and Jorge Nocedal. 1999. + An interior point algorithm for large-scale nonlinear programming. + SIAM Journal on Optimization 9.4: 877-900. + .. [17] Lalee, Marucha, Jorge Nocedal, and Todd Plantenga. 1998. On the + implementation of an algorithm for large-scale equality constrained + optimization. SIAM Journal on Optimization 8.3: 682-706. + .. [18] Ragonneau, T. M. *Model-Based Derivative-Free Optimization Methods + and Software*. PhD thesis, Department of Applied Mathematics, The Hong + Kong Polytechnic University, Hong Kong, China, 2022. URL: + https://theses.lib.polyu.edu.hk/handle/200/12294. + + Examples + -------- + Let us consider the problem of minimizing the Rosenbrock function. This + function (and its respective derivatives) is implemented in `rosen` + (resp. `rosen_der`, `rosen_hess`) in the `scipy.optimize`. + + >>> from scipy.optimize import minimize, rosen, rosen_der + + A simple application of the *Nelder-Mead* method is: + + >>> x0 = [1.3, 0.7, 0.8, 1.9, 1.2] + >>> res = minimize(rosen, x0, method='Nelder-Mead', tol=1e-6) + >>> res.x + array([ 1., 1., 1., 1., 1.]) + + Now using the *BFGS* algorithm, using the first derivative and a few + options: + + >>> res = minimize(rosen, x0, method='BFGS', jac=rosen_der, + ... options={'gtol': 1e-6, 'disp': True}) + Optimization terminated successfully. + Current function value: 0.000000 + Iterations: 26 + Function evaluations: 31 + Gradient evaluations: 31 + >>> res.x + array([ 1., 1., 1., 1., 1.]) + >>> print(res.message) + Optimization terminated successfully. + >>> res.hess_inv + array([ + [ 0.00749589, 0.01255155, 0.02396251, 0.04750988, 0.09495377], # may vary + [ 0.01255155, 0.02510441, 0.04794055, 0.09502834, 0.18996269], + [ 0.02396251, 0.04794055, 0.09631614, 0.19092151, 0.38165151], + [ 0.04750988, 0.09502834, 0.19092151, 0.38341252, 0.7664427 ], + [ 0.09495377, 0.18996269, 0.38165151, 0.7664427, 1.53713523] + ]) + + + Next, consider a minimization problem with several constraints (namely + Example 16.4 from [5]_). The objective function is: + + >>> fun = lambda x: (x[0] - 1)**2 + (x[1] - 2.5)**2 + + There are three constraints defined as: + + >>> cons = ({'type': 'ineq', 'fun': lambda x: x[0] - 2 * x[1] + 2}, + ... {'type': 'ineq', 'fun': lambda x: -x[0] - 2 * x[1] + 6}, + ... {'type': 'ineq', 'fun': lambda x: -x[0] + 2 * x[1] + 2}) + + And variables must be positive, hence the following bounds: + + >>> bnds = ((0, None), (0, None)) + + The optimization problem is solved using the SLSQP method as: + + >>> res = minimize(fun, (2, 0), method='SLSQP', bounds=bnds, + ... constraints=cons) + + It should converge to the theoretical solution (1.4 ,1.7). + + """ + x0 = np.atleast_1d(np.asarray(x0)) + + if x0.ndim != 1: + raise ValueError("'x0' must only have one dimension.") + + if x0.dtype.kind in np.typecodes["AllInteger"]: + x0 = np.asarray(x0, dtype=float) + + if not isinstance(args, tuple): + args = (args,) + + if method is None: + # Select automatically + if constraints: + method = 'SLSQP' + elif bounds is not None: + method = 'L-BFGS-B' + else: + method = 'BFGS' + + if callable(method): + meth = "_custom" + else: + meth = method.lower() + + if options is None: + options = {} + # check if optional parameters are supported by the selected method + # - jac + if meth in ('nelder-mead', 'powell', 'cobyla', 'cobyqa') and bool(jac): + warn(f'Method {method} does not use gradient information (jac).', + RuntimeWarning, stacklevel=2) + # - hess + if meth not in ('newton-cg', 'dogleg', 'trust-ncg', 'trust-constr', + 'trust-krylov', 'trust-exact', '_custom') and hess is not None: + warn(f'Method {method} does not use Hessian information (hess).', + RuntimeWarning, stacklevel=2) + # - hessp + if meth not in ('newton-cg', 'trust-ncg', 'trust-constr', + 'trust-krylov', '_custom') \ + and hessp is not None: + warn(f'Method {method} does not use Hessian-vector product' + ' information (hessp).', + RuntimeWarning, stacklevel=2) + # - constraints or bounds + if (meth not in ('cobyla', 'cobyqa', 'slsqp', 'trust-constr', '_custom') and + np.any(constraints)): + warn(f'Method {method} cannot handle constraints.', + RuntimeWarning, stacklevel=2) + if meth not in ( + 'nelder-mead', 'powell', 'l-bfgs-b', 'cobyla', 'cobyqa', 'slsqp', + 'tnc', 'trust-constr', '_custom') and bounds is not None: + warn(f'Method {method} cannot handle bounds.', + RuntimeWarning, stacklevel=2) + # - return_all + if (meth in ('l-bfgs-b', 'tnc', 'cobyla', 'cobyqa', 'slsqp') and + options.get('return_all', False)): + warn(f'Method {method} does not support the return_all option.', + RuntimeWarning, stacklevel=2) + + # check gradient vector + if callable(jac): + pass + elif jac is True: + # fun returns func and grad + fun = MemoizeJac(fun) + jac = fun.derivative + elif (jac in FD_METHODS and + meth in ['trust-constr', 'bfgs', 'cg', 'l-bfgs-b', 'tnc', 'slsqp']): + # finite differences with relative step + pass + elif meth in ['trust-constr']: + # default jac calculation for this method + jac = '2-point' + elif jac is None or bool(jac) is False: + # this will cause e.g. LBFGS to use forward difference, absolute step + jac = None + else: + # default if jac option is not understood + jac = None + + # set default tolerances + if tol is not None: + options = dict(options) + if meth == 'nelder-mead': + options.setdefault('xatol', tol) + options.setdefault('fatol', tol) + if meth in ('newton-cg', 'powell', 'tnc'): + options.setdefault('xtol', tol) + if meth in ('powell', 'l-bfgs-b', 'tnc', 'slsqp'): + options.setdefault('ftol', tol) + if meth in ('bfgs', 'cg', 'l-bfgs-b', 'tnc', 'dogleg', + 'trust-ncg', 'trust-exact', 'trust-krylov'): + options.setdefault('gtol', tol) + if meth in ('cobyla', '_custom'): + options.setdefault('tol', tol) + if meth == 'cobyqa': + options.setdefault('final_tr_radius', tol) + if meth == 'trust-constr': + options.setdefault('xtol', tol) + options.setdefault('gtol', tol) + options.setdefault('barrier_tol', tol) + + if meth == '_custom': + # custom method called before bounds and constraints are 'standardised' + # custom method should be able to accept whatever bounds/constraints + # are provided to it. + return method(fun, x0, args=args, jac=jac, hess=hess, hessp=hessp, + bounds=bounds, constraints=constraints, + callback=callback, **options) + + constraints = standardize_constraints(constraints, x0, meth) + + remove_vars = False + if bounds is not None: + # convert to new-style bounds so we only have to consider one case + bounds = standardize_bounds(bounds, x0, 'new') + bounds = _validate_bounds(bounds, x0, meth) + + if meth in {"tnc", "slsqp", "l-bfgs-b"}: + # These methods can't take the finite-difference derivatives they + # need when a variable is fixed by the bounds. To avoid this issue, + # remove fixed variables from the problem. + # NOTE: if this list is expanded, then be sure to update the + # accompanying tests and test_optimize.eb_data. Consider also if + # default OptimizeResult will need updating. + + # determine whether any variables are fixed + i_fixed = (bounds.lb == bounds.ub) + + if np.all(i_fixed): + # all the parameters are fixed, a minimizer is not able to do + # anything + return _optimize_result_for_equal_bounds( + fun, bounds, meth, args=args, constraints=constraints + ) + + # determine whether finite differences are needed for any grad/jac + fd_needed = (not callable(jac)) + for con in constraints: + if not callable(con.get('jac', None)): + fd_needed = True + + # If finite differences are ever used, remove all fixed variables + # Always remove fixed variables for TNC; see gh-14565 + remove_vars = i_fixed.any() and (fd_needed or meth == "tnc") + if remove_vars: + x_fixed = (bounds.lb)[i_fixed] + x0 = x0[~i_fixed] + bounds = _remove_from_bounds(bounds, i_fixed) + fun = _remove_from_func(fun, i_fixed, x_fixed) + if callable(callback): + callback = _remove_from_func(callback, i_fixed, x_fixed) + if callable(jac): + jac = _remove_from_func(jac, i_fixed, x_fixed, remove=1) + + # make a copy of the constraints so the user's version doesn't + # get changed. (Shallow copy is ok) + constraints = [con.copy() for con in constraints] + for con in constraints: # yes, guaranteed to be a list + con['fun'] = _remove_from_func(con['fun'], i_fixed, + x_fixed, min_dim=1, + remove=0) + if callable(con.get('jac', None)): + con['jac'] = _remove_from_func(con['jac'], i_fixed, + x_fixed, min_dim=2, + remove=1) + bounds = standardize_bounds(bounds, x0, meth) + + callback = _wrap_callback(callback, meth) + + if meth == 'nelder-mead': + res = _minimize_neldermead(fun, x0, args, callback, bounds=bounds, + **options) + elif meth == 'powell': + res = _minimize_powell(fun, x0, args, callback, bounds, **options) + elif meth == 'cg': + res = _minimize_cg(fun, x0, args, jac, callback, **options) + elif meth == 'bfgs': + res = _minimize_bfgs(fun, x0, args, jac, callback, **options) + elif meth == 'newton-cg': + res = _minimize_newtoncg(fun, x0, args, jac, hess, hessp, callback, + **options) + elif meth == 'l-bfgs-b': + res = _minimize_lbfgsb(fun, x0, args, jac, bounds, + callback=callback, **options) + elif meth == 'tnc': + res = _minimize_tnc(fun, x0, args, jac, bounds, callback=callback, + **options) + elif meth == 'cobyla': + res = _minimize_cobyla(fun, x0, args, constraints, callback=callback, + bounds=bounds, **options) + elif meth == 'cobyqa': + res = _minimize_cobyqa(fun, x0, args, bounds, constraints, callback, + **options) + elif meth == 'slsqp': + res = _minimize_slsqp(fun, x0, args, jac, bounds, + constraints, callback=callback, **options) + elif meth == 'trust-constr': + res = _minimize_trustregion_constr(fun, x0, args, jac, hess, hessp, + bounds, constraints, + callback=callback, **options) + elif meth == 'dogleg': + res = _minimize_dogleg(fun, x0, args, jac, hess, + callback=callback, **options) + elif meth == 'trust-ncg': + res = _minimize_trust_ncg(fun, x0, args, jac, hess, hessp, + callback=callback, **options) + elif meth == 'trust-krylov': + res = _minimize_trust_krylov(fun, x0, args, jac, hess, hessp, + callback=callback, **options) + elif meth == 'trust-exact': + res = _minimize_trustregion_exact(fun, x0, args, jac, hess, + callback=callback, **options) + else: + raise ValueError(f'Unknown solver {method}') + + if remove_vars: + res.x = _add_to_array(res.x, i_fixed, x_fixed) + res.jac = _add_to_array(res.jac, i_fixed, np.nan) + if "hess_inv" in res: + res.hess_inv = None # unknown + + if getattr(callback, 'stop_iteration', False): + res.success = False + res.status = 99 + res.message = "`callback` raised `StopIteration`." + + return res + + +def minimize_scalar(fun, bracket=None, bounds=None, args=(), + method=None, tol=None, options=None): + """Local minimization of scalar function of one variable. + + Parameters + ---------- + fun : callable + Objective function. + Scalar function, must return a scalar. + + Suppose the callable has signature ``f0(x, *my_args, **my_kwargs)``, where + ``my_args`` and ``my_kwargs`` are required positional and keyword arguments. + Rather than passing ``f0`` as the callable, wrap it to accept + only ``x``; e.g., pass ``fun=lambda x: f0(x, *my_args, **my_kwargs)`` as the + callable, where ``my_args`` (tuple) and ``my_kwargs`` (dict) have been + gathered before invoking this function. + + bracket : sequence, optional + For methods 'brent' and 'golden', `bracket` defines the bracketing + interval and is required. + Either a triple ``(xa, xb, xc)`` satisfying ``xa < xb < xc`` and + ``func(xb) < func(xa) and func(xb) < func(xc)``, or a pair + ``(xa, xb)`` to be used as initial points for a downhill bracket search + (see `scipy.optimize.bracket`). + The minimizer ``res.x`` will not necessarily satisfy + ``xa <= res.x <= xb``. + bounds : sequence, optional + For method 'bounded', `bounds` is mandatory and must have two finite + items corresponding to the optimization bounds. + args : tuple, optional + Extra arguments passed to the objective function. + method : str or callable, optional + Type of solver. Should be one of: + + - :ref:`Brent ` + - :ref:`Bounded ` + - :ref:`Golden ` + - custom - a callable object (added in version 0.14.0), see below + + Default is "Bounded" if bounds are provided and "Brent" otherwise. + See the 'Notes' section for details of each solver. + + tol : float, optional + Tolerance for termination. For detailed control, use solver-specific + options. + options : dict, optional + A dictionary of solver options. + + maxiter : int + Maximum number of iterations to perform. + disp : bool + Set to True to print convergence messages. + + See :func:`show_options()` for solver-specific options. + + Returns + ------- + res : OptimizeResult + The optimization result represented as a ``OptimizeResult`` object. + Important attributes are: ``x`` the solution array, ``success`` a + Boolean flag indicating if the optimizer exited successfully and + ``message`` which describes the cause of the termination. See + `OptimizeResult` for a description of other attributes. + + See also + -------- + minimize : Interface to minimization algorithms for scalar multivariate + functions + show_options : Additional options accepted by the solvers + + Notes + ----- + This section describes the available solvers that can be selected by the + 'method' parameter. The default method is the ``"Bounded"`` Brent method if + `bounds` are passed and unbounded ``"Brent"`` otherwise. + + Method :ref:`Brent ` uses Brent's + algorithm [1]_ to find a local minimum. The algorithm uses inverse + parabolic interpolation when possible to speed up convergence of + the golden section method. + + Method :ref:`Golden ` uses the + golden section search technique [1]_. It uses analog of the bisection + method to decrease the bracketed interval. It is usually + preferable to use the *Brent* method. + + Method :ref:`Bounded ` can + perform bounded minimization [2]_ [3]_. It uses the Brent method to find a + local minimum in the interval x1 < xopt < x2. + + Note that the Brent and Golden methods do not guarantee success unless a + valid ``bracket`` triple is provided. If a three-point bracket cannot be + found, consider `scipy.optimize.minimize`. Also, all methods are intended + only for local minimization. When the function of interest has more than + one local minimum, consider :ref:`global_optimization`. + + **Custom minimizers** + + It may be useful to pass a custom minimization method, for example + when using some library frontend to minimize_scalar. You can simply + pass a callable as the ``method`` parameter. + + The callable is called as ``method(fun, args, **kwargs, **options)`` + where ``kwargs`` corresponds to any other parameters passed to `minimize` + (such as `bracket`, `tol`, etc.), except the `options` dict, which has + its contents also passed as `method` parameters pair by pair. The method + shall return an `OptimizeResult` object. + + The provided `method` callable must be able to accept (and possibly ignore) + arbitrary parameters; the set of parameters accepted by `minimize` may + expand in future versions and then these parameters will be passed to + the method. You can find an example in the scipy.optimize tutorial. + + .. versionadded:: 0.11.0 + + References + ---------- + .. [1] Press, W., S.A. Teukolsky, W.T. Vetterling, and B.P. Flannery. + Numerical Recipes in C. Cambridge University Press. + .. [2] Forsythe, G.E., M. A. Malcolm, and C. B. Moler. "Computer Methods + for Mathematical Computations." Prentice-Hall Series in Automatic + Computation 259 (1977). + .. [3] Brent, Richard P. Algorithms for Minimization Without Derivatives. + Courier Corporation, 2013. + + Examples + -------- + Consider the problem of minimizing the following function. + + >>> def f(x): + ... return (x - 2) * x * (x + 2)**2 + + Using the *Brent* method, we find the local minimum as: + + >>> from scipy.optimize import minimize_scalar + >>> res = minimize_scalar(f) + >>> res.fun + -9.9149495908 + + The minimizer is: + + >>> res.x + 1.28077640403 + + Using the *Bounded* method, we find a local minimum with specified + bounds as: + + >>> res = minimize_scalar(f, bounds=(-3, -1), method='bounded') + >>> res.fun # minimum + 3.28365179850e-13 + >>> res.x # minimizer + -2.0000002026 + + """ + if not isinstance(args, tuple): + args = (args,) + + if callable(method): + meth = "_custom" + elif method is None: + meth = 'brent' if bounds is None else 'bounded' + else: + meth = method.lower() + if options is None: + options = {} + + if bounds is not None and meth in {'brent', 'golden'}: + message = f"Use of `bounds` is incompatible with 'method={method}'." + raise ValueError(message) + + if tol is not None: + options = dict(options) + if meth == 'bounded' and 'xatol' not in options: + warn("Method 'bounded' does not support relative tolerance in x; " + "defaulting to absolute tolerance.", + RuntimeWarning, stacklevel=2) + options['xatol'] = tol + elif meth == '_custom': + options.setdefault('tol', tol) + else: + options.setdefault('xtol', tol) + + # replace boolean "disp" option, if specified, by an integer value. + disp = options.get('disp') + if isinstance(disp, bool): + options['disp'] = 2 * int(disp) + + if meth == '_custom': + res = method(fun, args=args, bracket=bracket, bounds=bounds, **options) + elif meth == 'brent': + res = _recover_from_bracket_error(_minimize_scalar_brent, + fun, bracket, args, **options) + elif meth == 'bounded': + if bounds is None: + raise ValueError('The `bounds` parameter is mandatory for ' + 'method `bounded`.') + res = _minimize_scalar_bounded(fun, bounds, args, **options) + elif meth == 'golden': + res = _recover_from_bracket_error(_minimize_scalar_golden, + fun, bracket, args, **options) + else: + raise ValueError(f'Unknown solver {method}') + + # gh-16196 reported inconsistencies in the output shape of `res.x`. While + # fixing this, future-proof it for when the function is vectorized: + # the shape of `res.x` should match that of `res.fun`. + res.fun = np.asarray(res.fun)[()] + res.x = np.reshape(res.x, res.fun.shape)[()] + return res + + +def _remove_from_bounds(bounds, i_fixed): + """Removes fixed variables from a `Bounds` instance""" + lb = bounds.lb[~i_fixed] + ub = bounds.ub[~i_fixed] + return Bounds(lb, ub) # don't mutate original Bounds object + + +def _remove_from_func(fun_in, i_fixed, x_fixed, min_dim=None, remove=0): + """Wraps a function such that fixed variables need not be passed in""" + def fun_out(x_in, *args, **kwargs): + x_out = np.zeros_like(i_fixed, dtype=x_in.dtype) + x_out[i_fixed] = x_fixed + x_out[~i_fixed] = x_in + y_out = fun_in(x_out, *args, **kwargs) + y_out = np.array(y_out) + + if min_dim == 1: + y_out = np.atleast_1d(y_out) + elif min_dim == 2: + y_out = np.atleast_2d(y_out) + + if remove == 1: + y_out = y_out[..., ~i_fixed] + elif remove == 2: + y_out = y_out[~i_fixed, ~i_fixed] + + return y_out + return fun_out + + +def _add_to_array(x_in, i_fixed, x_fixed): + """Adds fixed variables back to an array""" + i_free = ~i_fixed + if x_in.ndim == 2: + i_free = i_free[:, None] @ i_free[None, :] + x_out = np.zeros_like(i_free, dtype=x_in.dtype) + x_out[~i_free] = x_fixed + x_out[i_free] = x_in.ravel() + return x_out + + +def _validate_bounds(bounds, x0, meth): + """Check that bounds are valid.""" + + msg = "An upper bound is less than the corresponding lower bound." + if np.any(bounds.ub < bounds.lb): + raise ValueError(msg) + + msg = "The number of bounds is not compatible with the length of `x0`." + try: + bounds.lb = np.broadcast_to(bounds.lb, x0.shape) + bounds.ub = np.broadcast_to(bounds.ub, x0.shape) + except Exception as e: + raise ValueError(msg) from e + + return bounds + +def standardize_bounds(bounds, x0, meth): + """Converts bounds to the form required by the solver.""" + if meth in {'trust-constr', 'powell', 'nelder-mead', 'cobyla', 'cobyqa', + 'new'}: + if not isinstance(bounds, Bounds): + lb, ub = old_bound_to_new(bounds) + bounds = Bounds(lb, ub) + elif meth in ('l-bfgs-b', 'tnc', 'slsqp', 'old'): + if isinstance(bounds, Bounds): + bounds = new_bounds_to_old(bounds.lb, bounds.ub, x0.shape[0]) + return bounds + + +def standardize_constraints(constraints, x0, meth): + """Converts constraints to the form required by the solver.""" + all_constraint_types = (NonlinearConstraint, LinearConstraint, dict) + new_constraint_types = all_constraint_types[:-1] + if constraints is None: + constraints = [] + elif isinstance(constraints, all_constraint_types): + constraints = [constraints] + else: + constraints = list(constraints) # ensure it's a mutable sequence + + if meth in ['trust-constr', 'cobyqa', 'new']: + for i, con in enumerate(constraints): + if not isinstance(con, new_constraint_types): + constraints[i] = old_constraint_to_new(i, con) + else: + # iterate over copy, changing original + for i, con in enumerate(list(constraints)): + if isinstance(con, new_constraint_types): + old_constraints = new_constraint_to_old(con, x0) + constraints[i] = old_constraints[0] + constraints.extend(old_constraints[1:]) # appends 1 if present + + return constraints + + +def _optimize_result_for_equal_bounds( + fun, bounds, method, args=(), constraints=() +): + """ + Provides a default OptimizeResult for when a bounded minimization method + has (lb == ub).all(). + + Parameters + ---------- + fun: callable + bounds: Bounds + method: str + constraints: Constraint + """ + success = True + message = 'All independent variables were fixed by bounds.' + + # bounds is new-style + x0 = bounds.lb + + if constraints: + message = ("All independent variables were fixed by bounds at values" + " that satisfy the constraints.") + constraints = standardize_constraints(constraints, x0, 'new') + + maxcv = 0 + for c in constraints: + pc = PreparedConstraint(c, x0) + violation = pc.violation(x0) + if np.sum(violation): + maxcv = max(maxcv, np.max(violation)) + success = False + message = (f"All independent variables were fixed by bounds, but " + f"the independent variables do not satisfy the " + f"constraints exactly. (Maximum violation: {maxcv}).") + + return OptimizeResult( + x=x0, fun=fun(x0, *args), success=success, message=message, nfev=1, + njev=0, nhev=0, + ) diff --git a/shared/package-files/30/30684f6f245c8ab15783fb801b1c90feaf01932e99529059d271d741ae4b61df/blob b/shared/package-files/30/30684f6f245c8ab15783fb801b1c90feaf01932e99529059d271d741ae4b61df/blob new file mode 100644 index 0000000000000000000000000000000000000000..5e56b1bc7ba4377cc5de9d68a1424524aef21cb5 --- /dev/null +++ b/shared/package-files/30/30684f6f245c8ab15783fb801b1c90feaf01932e99529059d271d741ae4b61df/blob @@ -0,0 +1,9 @@ +# ruff: noqa: TCH004 +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + # import modules that have public classes/functions + from pandas.io.formats import style + + # and mark only those modules as public + __all__ = ["style"] diff --git a/shared/package-files/30/30695c36d02980aff0078ed450226e96b158c8e9a6d23b5bfeb547bd329ec22c/blob b/shared/package-files/30/30695c36d02980aff0078ed450226e96b158c8e9a6d23b5bfeb547bd329ec22c/blob new file mode 100644 index 0000000000000000000000000000000000000000..a29a968917229d832d9a6789d9f73cb974bd011a --- /dev/null +++ b/shared/package-files/30/30695c36d02980aff0078ed450226e96b158c8e9a6d23b5bfeb547bd329ec22c/blob @@ -0,0 +1,43 @@ +from typing import Any + +import torch + +__all__ = ["autocast"] + + +class autocast(torch.amp.autocast_mode.autocast): + r""" + See :class:`torch.autocast`. + ``torch.cpu.amp.autocast(args...)`` is equivalent to ``torch.autocast("cpu", args...)`` + """ + + def __init__( + self, + enabled: bool = True, + dtype: torch.dtype = torch.bfloat16, + cache_enabled: bool = True, + ): + if torch._jit_internal.is_scripting(): + self._enabled = enabled + self.device = "cpu" + self.fast_dtype = dtype + return + super().__init__( + "cpu", enabled=enabled, dtype=dtype, cache_enabled=cache_enabled + ) + + def __enter__(self): + if torch._jit_internal.is_scripting(): + return self + return super().__enter__() + + # TODO: discuss a unified TorchScript-friendly API for autocast + def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any): # type: ignore[override] + if torch._jit_internal.is_scripting(): + return + return super().__exit__(exc_type, exc_val, exc_tb) + + def __call__(self, func): + if torch._jit_internal.is_scripting(): + return func + return super().__call__(func) diff --git a/shared/package-files/30/3069adb7cd1b37f36d4a09ed418b83b70f087c284d2f7cbc236d5c8b03acd931/blob b/shared/package-files/30/3069adb7cd1b37f36d4a09ed418b83b70f087c284d2f7cbc236d5c8b03acd931/blob new file mode 100644 index 0000000000000000000000000000000000000000..0262f50a9e043812acb6946b1442f855f3035685 --- /dev/null +++ b/shared/package-files/30/3069adb7cd1b37f36d4a09ed418b83b70f087c284d2f7cbc236d5c8b03acd931/blob @@ -0,0 +1,91 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::adaptive_avg_pool2d.out(Tensor self, SymInt[2] output_size, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & adaptive_avg_pool2d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size) { + return at::_ops::adaptive_avg_pool2d_out::call(self, c10::fromIntArrayRefSlow(output_size), out); +} +namespace symint { + template ::value>> + at::Tensor & adaptive_avg_pool2d_out(at::Tensor & out, const at::Tensor & self, at::IntArrayRef output_size) { + return at::_ops::adaptive_avg_pool2d_out::call(self, c10::fromIntArrayRefSlow(output_size), out); + } +} + +// aten::adaptive_avg_pool2d.out(Tensor self, SymInt[2] output_size, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & adaptive_avg_pool2d_outf(const at::Tensor & self, at::IntArrayRef output_size, at::Tensor & out) { + return at::_ops::adaptive_avg_pool2d_out::call(self, c10::fromIntArrayRefSlow(output_size), out); +} +namespace symint { + template ::value>> + at::Tensor & adaptive_avg_pool2d_outf(const at::Tensor & self, at::IntArrayRef output_size, at::Tensor & out) { + return at::_ops::adaptive_avg_pool2d_out::call(self, c10::fromIntArrayRefSlow(output_size), out); + } +} + +// aten::adaptive_avg_pool2d.out(Tensor self, SymInt[2] output_size, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & adaptive_avg_pool2d_symint_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size) { + return at::_ops::adaptive_avg_pool2d_out::call(self, output_size, out); +} +namespace symint { + template ::value>> + at::Tensor & adaptive_avg_pool2d_out(at::Tensor & out, const at::Tensor & self, c10::SymIntArrayRef output_size) { + return at::_ops::adaptive_avg_pool2d_out::call(self, output_size, out); + } +} + +// aten::adaptive_avg_pool2d.out(Tensor self, SymInt[2] output_size, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & adaptive_avg_pool2d_symint_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, at::Tensor & out) { + return at::_ops::adaptive_avg_pool2d_out::call(self, output_size, out); +} +namespace symint { + template ::value>> + at::Tensor & adaptive_avg_pool2d_outf(const at::Tensor & self, c10::SymIntArrayRef output_size, at::Tensor & out) { + return at::_ops::adaptive_avg_pool2d_out::call(self, output_size, out); + } +} + +// aten::adaptive_avg_pool2d(Tensor self, SymInt[2] output_size) -> Tensor +inline at::Tensor adaptive_avg_pool2d(const at::Tensor & self, at::IntArrayRef output_size) { + return at::_ops::adaptive_avg_pool2d::call(self, c10::fromIntArrayRefSlow(output_size)); +} +namespace symint { + template ::value>> + at::Tensor adaptive_avg_pool2d(const at::Tensor & self, at::IntArrayRef output_size) { + return at::_ops::adaptive_avg_pool2d::call(self, c10::fromIntArrayRefSlow(output_size)); + } +} + +// aten::adaptive_avg_pool2d(Tensor self, SymInt[2] output_size) -> Tensor +inline at::Tensor adaptive_avg_pool2d_symint(const at::Tensor & self, c10::SymIntArrayRef output_size) { + return at::_ops::adaptive_avg_pool2d::call(self, output_size); +} +namespace symint { + template ::value>> + at::Tensor adaptive_avg_pool2d(const at::Tensor & self, c10::SymIntArrayRef output_size) { + return at::_ops::adaptive_avg_pool2d::call(self, output_size); + } +} + +} diff --git a/shared/package-files/30/306b80e0a72c0d16dd934b7d51ab0c9a4224f83be5d6cbad8a7158a0a5d73551/blob b/shared/package-files/30/306b80e0a72c0d16dd934b7d51ab0c9a4224f83be5d6cbad8a7158a0a5d73551/blob new file mode 100644 index 0000000000000000000000000000000000000000..f227c9f49815388ed58a79e773c8114bced1e58f --- /dev/null +++ b/shared/package-files/30/306b80e0a72c0d16dd934b7d51ab0c9a4224f83be5d6cbad8a7158a0a5d73551/blob @@ -0,0 +1,19 @@ +# Copyright 2006 Google, Inc. All Rights Reserved. +# Licensed to PSF under a Contributor Agreement. + +"""Fixer that turns 'long' into 'int' everywhere. +""" + +# Local imports +from lib2to3 import fixer_base +from lib2to3.fixer_util import is_probably_builtin + + +class FixLong(fixer_base.BaseFix): + BM_compatible = True + PATTERN = "'long'" + + def transform(self, node, results): + if is_probably_builtin(node): + node.value = "int" + node.changed() diff --git a/shared/package-files/30/306d0b2ea8169bdca711c6a31c0b1a3ce710d38ae2b6568ef519aa38451af608/blob b/shared/package-files/30/306d0b2ea8169bdca711c6a31c0b1a3ce710d38ae2b6568ef519aa38451af608/blob new file mode 100644 index 0000000000000000000000000000000000000000..c2a3a47f503286e05e9bd9d69759e6a2ca214b2c --- /dev/null +++ b/shared/package-files/30/306d0b2ea8169bdca711c6a31c0b1a3ce710d38ae2b6568ef519aa38451af608/blob @@ -0,0 +1,453 @@ +"""Utility functions, node construction macros, etc.""" +# Author: Collin Winter + +# Local imports +from .pgen2 import token +from .pytree import Leaf, Node +from .pygram import python_symbols as syms +from . import patcomp + + +########################################################### +### Common node-construction "macros" +########################################################### + +def KeywordArg(keyword, value): + return Node(syms.argument, + [keyword, Leaf(token.EQUAL, "="), value]) + +def LParen(): + return Leaf(token.LPAR, "(") + +def RParen(): + return Leaf(token.RPAR, ")") + +def Assign(target, source): + """Build an assignment statement""" + if not isinstance(target, list): + target = [target] + if not isinstance(source, list): + source.prefix = " " + source = [source] + + return Node(syms.atom, + target + [Leaf(token.EQUAL, "=", prefix=" ")] + source) + +def Name(name, prefix=None): + """Return a NAME leaf""" + return Leaf(token.NAME, name, prefix=prefix) + +def Attr(obj, attr): + """A node tuple for obj.attr""" + return [obj, Node(syms.trailer, [Dot(), attr])] + +def Comma(): + """A comma leaf""" + return Leaf(token.COMMA, ",") + +def Dot(): + """A period (.) leaf""" + return Leaf(token.DOT, ".") + +def ArgList(args, lparen=LParen(), rparen=RParen()): + """A parenthesised argument list, used by Call()""" + node = Node(syms.trailer, [lparen.clone(), rparen.clone()]) + if args: + node.insert_child(1, Node(syms.arglist, args)) + return node + +def Call(func_name, args=None, prefix=None): + """A function call""" + node = Node(syms.power, [func_name, ArgList(args)]) + if prefix is not None: + node.prefix = prefix + return node + +def Newline(): + """A newline literal""" + return Leaf(token.NEWLINE, "\n") + +def BlankLine(): + """A blank line""" + return Leaf(token.NEWLINE, "") + +def Number(n, prefix=None): + return Leaf(token.NUMBER, n, prefix=prefix) + +def Subscript(index_node): + """A numeric or string subscript""" + return Node(syms.trailer, [Leaf(token.LBRACE, "["), + index_node, + Leaf(token.RBRACE, "]")]) + +def String(string, prefix=None): + """A string leaf""" + return Leaf(token.STRING, string, prefix=prefix) + +def ListComp(xp, fp, it, test=None): + """A list comprehension of the form [xp for fp in it if test]. + + If test is None, the "if test" part is omitted. + """ + xp.prefix = "" + fp.prefix = " " + it.prefix = " " + for_leaf = Leaf(token.NAME, "for") + for_leaf.prefix = " " + in_leaf = Leaf(token.NAME, "in") + in_leaf.prefix = " " + inner_args = [for_leaf, fp, in_leaf, it] + if test: + test.prefix = " " + if_leaf = Leaf(token.NAME, "if") + if_leaf.prefix = " " + inner_args.append(Node(syms.comp_if, [if_leaf, test])) + inner = Node(syms.listmaker, [xp, Node(syms.comp_for, inner_args)]) + return Node(syms.atom, + [Leaf(token.LBRACE, "["), + inner, + Leaf(token.RBRACE, "]")]) + +def FromImport(package_name, name_leafs): + """ Return an import statement in the form: + from package import name_leafs""" + # XXX: May not handle dotted imports properly (eg, package_name='foo.bar') + #assert package_name == '.' or '.' not in package_name, "FromImport has "\ + # "not been tested with dotted package names -- use at your own "\ + # "peril!" + + for leaf in name_leafs: + # Pull the leaves out of their old tree + leaf.remove() + + children = [Leaf(token.NAME, "from"), + Leaf(token.NAME, package_name, prefix=" "), + Leaf(token.NAME, "import", prefix=" "), + Node(syms.import_as_names, name_leafs)] + imp = Node(syms.import_from, children) + return imp + +def ImportAndCall(node, results, names): + """Returns an import statement and calls a method + of the module: + + import module + module.name()""" + obj = results["obj"].clone() + if obj.type == syms.arglist: + newarglist = obj.clone() + else: + newarglist = Node(syms.arglist, [obj.clone()]) + after = results["after"] + if after: + after = [n.clone() for n in after] + new = Node(syms.power, + Attr(Name(names[0]), Name(names[1])) + + [Node(syms.trailer, + [results["lpar"].clone(), + newarglist, + results["rpar"].clone()])] + after) + new.prefix = node.prefix + return new + + +########################################################### +### Determine whether a node represents a given literal +########################################################### + +def is_tuple(node): + """Does the node represent a tuple literal?""" + if isinstance(node, Node) and node.children == [LParen(), RParen()]: + return True + return (isinstance(node, Node) + and len(node.children) == 3 + and isinstance(node.children[0], Leaf) + and isinstance(node.children[1], Node) + and isinstance(node.children[2], Leaf) + and node.children[0].value == "(" + and node.children[2].value == ")") + +def is_list(node): + """Does the node represent a list literal?""" + return (isinstance(node, Node) + and len(node.children) > 1 + and isinstance(node.children[0], Leaf) + and isinstance(node.children[-1], Leaf) + and node.children[0].value == "[" + and node.children[-1].value == "]") + + +########################################################### +### Misc +########################################################### + +def parenthesize(node): + return Node(syms.atom, [LParen(), node, RParen()]) + + +consuming_calls = {"sorted", "list", "set", "any", "all", "tuple", "sum", + "min", "max", "enumerate"} + +def attr_chain(obj, attr): + """Follow an attribute chain. + + If you have a chain of objects where a.foo -> b, b.foo-> c, etc, + use this to iterate over all objects in the chain. Iteration is + terminated by getattr(x, attr) is None. + + Args: + obj: the starting object + attr: the name of the chaining attribute + + Yields: + Each successive object in the chain. + """ + next = getattr(obj, attr) + while next: + yield next + next = getattr(next, attr) + +p0 = """for_stmt< 'for' any 'in' node=any ':' any* > + | comp_for< 'for' any 'in' node=any any* > + """ +p1 = """ +power< + ( 'iter' | 'list' | 'tuple' | 'sorted' | 'set' | 'sum' | + 'any' | 'all' | 'enumerate' | (any* trailer< '.' 'join' >) ) + trailer< '(' node=any ')' > + any* +> +""" +p2 = """ +power< + ( 'sorted' | 'enumerate' ) + trailer< '(' arglist ')' > + any* +> +""" +pats_built = False +def in_special_context(node): + """ Returns true if node is in an environment where all that is required + of it is being iterable (ie, it doesn't matter if it returns a list + or an iterator). + See test_map_nochange in test_fixers.py for some examples and tests. + """ + global p0, p1, p2, pats_built + if not pats_built: + p0 = patcomp.compile_pattern(p0) + p1 = patcomp.compile_pattern(p1) + p2 = patcomp.compile_pattern(p2) + pats_built = True + patterns = [p0, p1, p2] + for pattern, parent in zip(patterns, attr_chain(node, "parent")): + results = {} + if pattern.match(parent, results) and results["node"] is node: + return True + return False + +def is_probably_builtin(node): + """ + Check that something isn't an attribute or function name etc. + """ + prev = node.prev_sibling + if prev is not None and prev.type == token.DOT: + # Attribute lookup. + return False + parent = node.parent + if parent.type in (syms.funcdef, syms.classdef): + return False + if parent.type == syms.expr_stmt and parent.children[0] is node: + # Assignment. + return False + if parent.type == syms.parameters or \ + (parent.type == syms.typedargslist and ( + (prev is not None and prev.type == token.COMMA) or + parent.children[0] is node + )): + # The name of an argument. + return False + return True + +def find_indentation(node): + """Find the indentation of *node*.""" + while node is not None: + if node.type == syms.suite and len(node.children) > 2: + indent = node.children[1] + if indent.type == token.INDENT: + return indent.value + node = node.parent + return "" + +########################################################### +### The following functions are to find bindings in a suite +########################################################### + +def make_suite(node): + if node.type == syms.suite: + return node + node = node.clone() + parent, node.parent = node.parent, None + suite = Node(syms.suite, [node]) + suite.parent = parent + return suite + +def find_root(node): + """Find the top level namespace.""" + # Scamper up to the top level namespace + while node.type != syms.file_input: + node = node.parent + if not node: + raise ValueError("root found before file_input node was found.") + return node + +def does_tree_import(package, name, node): + """ Returns true if name is imported from package at the + top level of the tree which node belongs to. + To cover the case of an import like 'import foo', use + None for the package and 'foo' for the name. """ + binding = find_binding(name, find_root(node), package) + return bool(binding) + +def is_import(node): + """Returns true if the node is an import statement.""" + return node.type in (syms.import_name, syms.import_from) + +def touch_import(package, name, node): + """ Works like `does_tree_import` but adds an import statement + if it was not imported. """ + def is_import_stmt(node): + return (node.type == syms.simple_stmt and node.children and + is_import(node.children[0])) + + root = find_root(node) + + if does_tree_import(package, name, root): + return + + # figure out where to insert the new import. First try to find + # the first import and then skip to the last one. + insert_pos = offset = 0 + for idx, node in enumerate(root.children): + if not is_import_stmt(node): + continue + for offset, node2 in enumerate(root.children[idx:]): + if not is_import_stmt(node2): + break + insert_pos = idx + offset + break + + # if there are no imports where we can insert, find the docstring. + # if that also fails, we stick to the beginning of the file + if insert_pos == 0: + for idx, node in enumerate(root.children): + if (node.type == syms.simple_stmt and node.children and + node.children[0].type == token.STRING): + insert_pos = idx + 1 + break + + if package is None: + import_ = Node(syms.import_name, [ + Leaf(token.NAME, "import"), + Leaf(token.NAME, name, prefix=" ") + ]) + else: + import_ = FromImport(package, [Leaf(token.NAME, name, prefix=" ")]) + + children = [import_, Newline()] + root.insert_child(insert_pos, Node(syms.simple_stmt, children)) + + +_def_syms = {syms.classdef, syms.funcdef} +def find_binding(name, node, package=None): + """ Returns the node which binds variable name, otherwise None. + If optional argument package is supplied, only imports will + be returned. + See test cases for examples.""" + for child in node.children: + ret = None + if child.type == syms.for_stmt: + if _find(name, child.children[1]): + return child + n = find_binding(name, make_suite(child.children[-1]), package) + if n: ret = n + elif child.type in (syms.if_stmt, syms.while_stmt): + n = find_binding(name, make_suite(child.children[-1]), package) + if n: ret = n + elif child.type == syms.try_stmt: + n = find_binding(name, make_suite(child.children[2]), package) + if n: + ret = n + else: + for i, kid in enumerate(child.children[3:]): + if kid.type == token.COLON and kid.value == ":": + # i+3 is the colon, i+4 is the suite + n = find_binding(name, make_suite(child.children[i+4]), package) + if n: ret = n + elif child.type in _def_syms and child.children[1].value == name: + ret = child + elif _is_import_binding(child, name, package): + ret = child + elif child.type == syms.simple_stmt: + ret = find_binding(name, child, package) + elif child.type == syms.expr_stmt: + if _find(name, child.children[0]): + ret = child + + if ret: + if not package: + return ret + if is_import(ret): + return ret + return None + +_block_syms = {syms.funcdef, syms.classdef, syms.trailer} +def _find(name, node): + nodes = [node] + while nodes: + node = nodes.pop() + if node.type > 256 and node.type not in _block_syms: + nodes.extend(node.children) + elif node.type == token.NAME and node.value == name: + return node + return None + +def _is_import_binding(node, name, package=None): + """ Will return node if node will import name, or node + will import * from package. None is returned otherwise. + See test cases for examples. """ + + if node.type == syms.import_name and not package: + imp = node.children[1] + if imp.type == syms.dotted_as_names: + for child in imp.children: + if child.type == syms.dotted_as_name: + if child.children[2].value == name: + return node + elif child.type == token.NAME and child.value == name: + return node + elif imp.type == syms.dotted_as_name: + last = imp.children[-1] + if last.type == token.NAME and last.value == name: + return node + elif imp.type == token.NAME and imp.value == name: + return node + elif node.type == syms.import_from: + # str(...) is used to make life easier here, because + # from a.b import parses to ['import', ['a', '.', 'b'], ...] + if package and str(node.children[1]).strip() != package: + return None + n = node.children[3] + if package and _find("as", n): + # See test_from_import_as for explanation + return None + elif n.type == syms.import_as_names and _find(name, n): + return node + elif n.type == syms.import_as_name: + child = n.children[2] + if child.type == token.NAME and child.value == name: + return node + elif n.type == token.NAME and n.value == name: + return node + elif package and n.type == token.STAR: + return node + return None diff --git a/shared/package-files/30/306f7e969a844072411fd7a84604635850a9da0c0645d49f4538ab579dd0ddc6/blob b/shared/package-files/30/306f7e969a844072411fd7a84604635850a9da0c0645d49f4538ab579dd0ddc6/blob new file mode 100644 index 0000000000000000000000000000000000000000..d27d670a1aac01f7129d483e0a048a38dce35404 --- /dev/null +++ b/shared/package-files/30/306f7e969a844072411fd7a84604635850a9da0c0645d49f4538ab579dd0ddc6/blob @@ -0,0 +1,874 @@ +from itertools import product + +import numpy as np +from numpy.linalg import norm +from numpy.testing import (assert_, assert_allclose, + assert_equal, suppress_warnings) +import pytest +from pytest import raises as assert_raises +from scipy.sparse import issparse, lil_matrix +from scipy.sparse.linalg import aslinearoperator + +from scipy.optimize import least_squares, Bounds +from scipy.optimize._lsq.least_squares import IMPLEMENTED_LOSSES +from scipy.optimize._lsq.common import EPS, make_strictly_feasible, CL_scaling_vector + + +def fun_trivial(x, a=0): + return (x - a)**2 + 5.0 + + +def jac_trivial(x, a=0.0): + return 2 * (x - a) + + +def fun_2d_trivial(x): + return np.array([x[0], x[1]]) + + +def jac_2d_trivial(x): + return np.identity(2) + + +def fun_rosenbrock(x): + return np.array([10 * (x[1] - x[0]**2), (1 - x[0])]) + + +def jac_rosenbrock(x): + return np.array([ + [-20 * x[0], 10], + [-1, 0] + ]) + + +def jac_rosenbrock_bad_dim(x): + return np.array([ + [-20 * x[0], 10], + [-1, 0], + [0.0, 0.0] + ]) + + +def fun_rosenbrock_cropped(x): + return fun_rosenbrock(x)[0] + + +def jac_rosenbrock_cropped(x): + return jac_rosenbrock(x)[0] + + +# When x is 1-D array, return is 2-D array. +def fun_wrong_dimensions(x): + return np.array([x, x**2, x**3]) + + +def jac_wrong_dimensions(x, a=0.0): + return np.atleast_3d(jac_trivial(x, a=a)) + + +def fun_bvp(x): + n = int(np.sqrt(x.shape[0])) + u = np.zeros((n + 2, n + 2)) + x = x.reshape((n, n)) + u[1:-1, 1:-1] = x + y = u[:-2, 1:-1] + u[2:, 1:-1] + u[1:-1, :-2] + u[1:-1, 2:] - 4 * x + x**3 + return y.ravel() + + +class BroydenTridiagonal: + def __init__(self, n=100, mode='sparse'): + rng = np.random.RandomState(0) + + self.n = n + + self.x0 = -np.ones(n) + self.lb = np.linspace(-2, -1.5, n) + self.ub = np.linspace(-0.8, 0.0, n) + + self.lb += 0.1 * rng.randn(n) + self.ub += 0.1 * rng.randn(n) + + self.x0 += 0.1 * rng.randn(n) + self.x0 = make_strictly_feasible(self.x0, self.lb, self.ub) + + if mode == 'sparse': + self.sparsity = lil_matrix((n, n), dtype=int) + i = np.arange(n) + self.sparsity[i, i] = 1 + i = np.arange(1, n) + self.sparsity[i, i - 1] = 1 + i = np.arange(n - 1) + self.sparsity[i, i + 1] = 1 + + self.jac = self._jac + elif mode == 'operator': + self.jac = lambda x: aslinearoperator(self._jac(x)) + elif mode == 'dense': + self.sparsity = None + self.jac = lambda x: self._jac(x).toarray() + else: + assert_(False) + + def fun(self, x): + f = (3 - x) * x + 1 + f[1:] -= x[:-1] + f[:-1] -= 2 * x[1:] + return f + + def _jac(self, x): + J = lil_matrix((self.n, self.n)) + i = np.arange(self.n) + J[i, i] = 3 - 2 * x + i = np.arange(1, self.n) + J[i, i - 1] = -1 + i = np.arange(self.n - 1) + J[i, i + 1] = -2 + return J + + +class ExponentialFittingProblem: + """Provide data and function for exponential fitting in the form + y = a + exp(b * x) + noise.""" + + def __init__(self, a, b, noise, n_outliers=1, x_range=(-1, 1), + n_points=11, random_seed=None): + rng = np.random.RandomState(random_seed) + self.m = n_points + self.n = 2 + + self.p0 = np.zeros(2) + self.x = np.linspace(x_range[0], x_range[1], n_points) + + self.y = a + np.exp(b * self.x) + self.y += noise * rng.randn(self.m) + + outliers = rng.randint(0, self.m, n_outliers) + self.y[outliers] += 50 * noise * rng.rand(n_outliers) + + self.p_opt = np.array([a, b]) + + def fun(self, p): + return p[0] + np.exp(p[1] * self.x) - self.y + + def jac(self, p): + J = np.empty((self.m, self.n)) + J[:, 0] = 1 + J[:, 1] = self.x * np.exp(p[1] * self.x) + return J + + +def cubic_soft_l1(z): + rho = np.empty((3, z.size)) + + t = 1 + z + rho[0] = 3 * (t**(1/3) - 1) + rho[1] = t ** (-2/3) + rho[2] = -2/3 * t**(-5/3) + + return rho + + +LOSSES = list(IMPLEMENTED_LOSSES.keys()) + [cubic_soft_l1] + + +class BaseMixin: + def test_basic(self): + # Test that the basic calling sequence works. + res = least_squares(fun_trivial, 2., method=self.method) + assert_allclose(res.x, 0, atol=1e-4) + assert_allclose(res.fun, fun_trivial(res.x)) + + def test_args_kwargs(self): + # Test that args and kwargs are passed correctly to the functions. + a = 3.0 + for jac in ['2-point', '3-point', 'cs', jac_trivial]: + with suppress_warnings() as sup: + sup.filter( + UserWarning, + "jac='(3-point|cs)' works equivalently to '2-point' for method='lm'" + ) + res = least_squares(fun_trivial, 2.0, jac, args=(a,), + method=self.method) + res1 = least_squares(fun_trivial, 2.0, jac, kwargs={'a': a}, + method=self.method) + + assert_allclose(res.x, a, rtol=1e-4) + assert_allclose(res1.x, a, rtol=1e-4) + + assert_raises(TypeError, least_squares, fun_trivial, 2.0, + args=(3, 4,), method=self.method) + assert_raises(TypeError, least_squares, fun_trivial, 2.0, + kwargs={'kaboom': 3}, method=self.method) + + def test_jac_options(self): + for jac in ['2-point', '3-point', 'cs', jac_trivial]: + with suppress_warnings() as sup: + sup.filter( + UserWarning, + "jac='(3-point|cs)' works equivalently to '2-point' for method='lm'" + ) + res = least_squares(fun_trivial, 2.0, jac, method=self.method) + assert_allclose(res.x, 0, atol=1e-4) + + assert_raises(ValueError, least_squares, fun_trivial, 2.0, jac='oops', + method=self.method) + + def test_nfev_options(self): + for max_nfev in [None, 20]: + res = least_squares(fun_trivial, 2.0, max_nfev=max_nfev, + method=self.method) + assert_allclose(res.x, 0, atol=1e-4) + + def test_x_scale_options(self): + for x_scale in [1.0, np.array([0.5]), 'jac']: + res = least_squares(fun_trivial, 2.0, x_scale=x_scale) + assert_allclose(res.x, 0) + assert_raises(ValueError, least_squares, fun_trivial, + 2.0, x_scale='auto', method=self.method) + assert_raises(ValueError, least_squares, fun_trivial, + 2.0, x_scale=-1.0, method=self.method) + assert_raises(ValueError, least_squares, fun_trivial, + 2.0, x_scale=None, method=self.method) + assert_raises(ValueError, least_squares, fun_trivial, + 2.0, x_scale=1.0+2.0j, method=self.method) + + def test_diff_step(self): + # res1 and res2 should be equivalent. + # res2 and res3 should be different. + res1 = least_squares(fun_trivial, 2.0, diff_step=1e-1, + method=self.method) + res2 = least_squares(fun_trivial, 2.0, diff_step=-1e-1, + method=self.method) + res3 = least_squares(fun_trivial, 2.0, + diff_step=None, method=self.method) + assert_allclose(res1.x, 0, atol=1e-4) + assert_allclose(res2.x, 0, atol=1e-4) + assert_allclose(res3.x, 0, atol=1e-4) + assert_equal(res1.x, res2.x) + assert_equal(res1.nfev, res2.nfev) + + def test_incorrect_options_usage(self): + assert_raises(TypeError, least_squares, fun_trivial, 2.0, + method=self.method, options={'no_such_option': 100}) + assert_raises(TypeError, least_squares, fun_trivial, 2.0, + method=self.method, options={'max_nfev': 100}) + + def test_full_result(self): + # MINPACK doesn't work very well with factor=100 on this problem, + # thus using low 'atol'. + res = least_squares(fun_trivial, 2.0, method=self.method) + assert_allclose(res.x, 0, atol=1e-4) + assert_allclose(res.cost, 12.5) + assert_allclose(res.fun, 5) + assert_allclose(res.jac, 0, atol=1e-4) + assert_allclose(res.grad, 0, atol=1e-2) + assert_allclose(res.optimality, 0, atol=1e-2) + assert_equal(res.active_mask, 0) + if self.method == 'lm': + assert_(res.nfev < 30) + assert_(res.njev is None) + else: + assert_(res.nfev < 10) + assert_(res.njev < 10) + assert_(res.status > 0) + assert_(res.success) + + def test_full_result_single_fev(self): + # MINPACK checks the number of nfev after the iteration, + # so it's hard to tell what he is going to compute. + if self.method == 'lm': + return + + res = least_squares(fun_trivial, 2.0, method=self.method, + max_nfev=1) + assert_equal(res.x, np.array([2])) + assert_equal(res.cost, 40.5) + assert_equal(res.fun, np.array([9])) + assert_equal(res.jac, np.array([[4]])) + assert_equal(res.grad, np.array([36])) + assert_equal(res.optimality, 36) + assert_equal(res.active_mask, np.array([0])) + assert_equal(res.nfev, 1) + assert_equal(res.njev, 1) + assert_equal(res.status, 0) + assert_equal(res.success, 0) + + def test_rosenbrock(self): + x0 = [-2, 1] + x_opt = [1, 1] + for jac, x_scale, tr_solver in product( + ['2-point', '3-point', 'cs', jac_rosenbrock], + [1.0, np.array([1.0, 0.2]), 'jac'], + ['exact', 'lsmr']): + with suppress_warnings() as sup: + sup.filter( + UserWarning, + "jac='(3-point|cs)' works equivalently to '2-point' for method='lm'" + ) + res = least_squares(fun_rosenbrock, x0, jac, x_scale=x_scale, + tr_solver=tr_solver, method=self.method) + assert_allclose(res.x, x_opt) + + def test_rosenbrock_cropped(self): + x0 = [-2, 1] + if self.method == 'lm': + assert_raises(ValueError, least_squares, fun_rosenbrock_cropped, + x0, method='lm') + else: + for jac, x_scale, tr_solver in product( + ['2-point', '3-point', 'cs', jac_rosenbrock_cropped], + [1.0, np.array([1.0, 0.2]), 'jac'], + ['exact', 'lsmr']): + res = least_squares( + fun_rosenbrock_cropped, x0, jac, x_scale=x_scale, + tr_solver=tr_solver, method=self.method) + assert_allclose(res.cost, 0, atol=1e-14) + + def test_fun_wrong_dimensions(self): + assert_raises(ValueError, least_squares, fun_wrong_dimensions, + 2.0, method=self.method) + + def test_jac_wrong_dimensions(self): + assert_raises(ValueError, least_squares, fun_trivial, + 2.0, jac_wrong_dimensions, method=self.method) + + def test_fun_and_jac_inconsistent_dimensions(self): + x0 = [1, 2] + assert_raises(ValueError, least_squares, fun_rosenbrock, x0, + jac_rosenbrock_bad_dim, method=self.method) + + def test_x0_multidimensional(self): + x0 = np.ones(4).reshape(2, 2) + assert_raises(ValueError, least_squares, fun_trivial, x0, + method=self.method) + + def test_x0_complex_scalar(self): + x0 = 2.0 + 0.0*1j + assert_raises(ValueError, least_squares, fun_trivial, x0, + method=self.method) + + def test_x0_complex_array(self): + x0 = [1.0, 2.0 + 0.0*1j] + assert_raises(ValueError, least_squares, fun_trivial, x0, + method=self.method) + + def test_bvp(self): + # This test was introduced with fix #5556. It turned out that + # dogbox solver had a bug with trust-region radius update, which + # could block its progress and create an infinite loop. And this + # discrete boundary value problem is the one which triggers it. + n = 10 + x0 = np.ones(n**2) + if self.method == 'lm': + max_nfev = 5000 # To account for Jacobian estimation. + else: + max_nfev = 100 + res = least_squares(fun_bvp, x0, ftol=1e-2, method=self.method, + max_nfev=max_nfev) + + assert_(res.nfev < max_nfev) + assert_(res.cost < 0.5) + + def test_error_raised_when_all_tolerances_below_eps(self): + # Test that all 0 tolerances are not allowed. + assert_raises(ValueError, least_squares, fun_trivial, 2.0, + method=self.method, ftol=None, xtol=None, gtol=None) + + def test_convergence_with_only_one_tolerance_enabled(self): + if self.method == 'lm': + return # should not do test + x0 = [-2, 1] + x_opt = [1, 1] + for ftol, xtol, gtol in [(1e-8, None, None), + (None, 1e-8, None), + (None, None, 1e-8)]: + res = least_squares(fun_rosenbrock, x0, jac=jac_rosenbrock, + ftol=ftol, gtol=gtol, xtol=xtol, + method=self.method) + assert_allclose(res.x, x_opt) + + +class BoundsMixin: + def test_inconsistent(self): + assert_raises(ValueError, least_squares, fun_trivial, 2.0, + bounds=(10.0, 0.0), method=self.method) + + def test_infeasible(self): + assert_raises(ValueError, least_squares, fun_trivial, 2.0, + bounds=(3., 4), method=self.method) + + def test_wrong_number(self): + assert_raises(ValueError, least_squares, fun_trivial, 2., + bounds=(1., 2, 3), method=self.method) + + def test_inconsistent_shape(self): + assert_raises(ValueError, least_squares, fun_trivial, 2.0, + bounds=(1.0, [2.0, 3.0]), method=self.method) + # 1-D array won't be broadcast + assert_raises(ValueError, least_squares, fun_rosenbrock, [1.0, 2.0], + bounds=([0.0], [3.0, 4.0]), method=self.method) + + def test_in_bounds(self): + for jac in ['2-point', '3-point', 'cs', jac_trivial]: + res = least_squares(fun_trivial, 2.0, jac=jac, + bounds=(-1.0, 3.0), method=self.method) + assert_allclose(res.x, 0.0, atol=1e-4) + assert_equal(res.active_mask, [0]) + assert_(-1 <= res.x <= 3) + res = least_squares(fun_trivial, 2.0, jac=jac, + bounds=(0.5, 3.0), method=self.method) + assert_allclose(res.x, 0.5, atol=1e-4) + assert_equal(res.active_mask, [-1]) + assert_(0.5 <= res.x <= 3) + + def test_bounds_shape(self): + def get_bounds_direct(lb, ub): + return lb, ub + + def get_bounds_instances(lb, ub): + return Bounds(lb, ub) + + for jac in ['2-point', '3-point', 'cs', jac_2d_trivial]: + for bounds_func in [get_bounds_direct, get_bounds_instances]: + x0 = [1.0, 1.0] + res = least_squares(fun_2d_trivial, x0, jac=jac) + assert_allclose(res.x, [0.0, 0.0]) + res = least_squares(fun_2d_trivial, x0, jac=jac, + bounds=bounds_func(0.5, [2.0, 2.0]), + method=self.method) + assert_allclose(res.x, [0.5, 0.5]) + res = least_squares(fun_2d_trivial, x0, jac=jac, + bounds=bounds_func([0.3, 0.2], 3.0), + method=self.method) + assert_allclose(res.x, [0.3, 0.2]) + res = least_squares( + fun_2d_trivial, x0, jac=jac, + bounds=bounds_func([-1, 0.5], [1.0, 3.0]), + method=self.method) + assert_allclose(res.x, [0.0, 0.5], atol=1e-5) + + def test_bounds_instances(self): + res = least_squares(fun_trivial, 0.5, bounds=Bounds()) + assert_allclose(res.x, 0.0, atol=1e-4) + + res = least_squares(fun_trivial, 3.0, bounds=Bounds(lb=1.0)) + assert_allclose(res.x, 1.0, atol=1e-4) + + res = least_squares(fun_trivial, 0.5, bounds=Bounds(lb=-1.0, ub=1.0)) + assert_allclose(res.x, 0.0, atol=1e-4) + + res = least_squares(fun_trivial, -3.0, bounds=Bounds(ub=-1.0)) + assert_allclose(res.x, -1.0, atol=1e-4) + + res = least_squares(fun_2d_trivial, [0.5, 0.5], + bounds=Bounds(lb=[-1.0, -1.0], ub=1.0)) + assert_allclose(res.x, [0.0, 0.0], atol=1e-5) + + res = least_squares(fun_2d_trivial, [0.5, 0.5], + bounds=Bounds(lb=[0.1, 0.1])) + assert_allclose(res.x, [0.1, 0.1], atol=1e-5) + + @pytest.mark.fail_slow(10) + def test_rosenbrock_bounds(self): + x0_1 = np.array([-2.0, 1.0]) + x0_2 = np.array([2.0, 2.0]) + x0_3 = np.array([-2.0, 2.0]) + x0_4 = np.array([0.0, 2.0]) + x0_5 = np.array([-1.2, 1.0]) + problems = [ + (x0_1, ([-np.inf, -1.5], np.inf)), + (x0_2, ([-np.inf, 1.5], np.inf)), + (x0_3, ([-np.inf, 1.5], np.inf)), + (x0_4, ([-np.inf, 1.5], [1.0, np.inf])), + (x0_2, ([1.0, 1.5], [3.0, 3.0])), + (x0_5, ([-50.0, 0.0], [0.5, 100])) + ] + for x0, bounds in problems: + for jac, x_scale, tr_solver in product( + ['2-point', '3-point', 'cs', jac_rosenbrock], + [1.0, [1.0, 0.5], 'jac'], + ['exact', 'lsmr']): + res = least_squares(fun_rosenbrock, x0, jac, bounds, + x_scale=x_scale, tr_solver=tr_solver, + method=self.method) + assert_allclose(res.optimality, 0.0, atol=1e-5) + + +class SparseMixin: + def test_exact_tr_solver(self): + p = BroydenTridiagonal() + assert_raises(ValueError, least_squares, p.fun, p.x0, p.jac, + tr_solver='exact', method=self.method) + assert_raises(ValueError, least_squares, p.fun, p.x0, + tr_solver='exact', jac_sparsity=p.sparsity, + method=self.method) + + def test_equivalence(self): + sparse = BroydenTridiagonal(mode='sparse') + dense = BroydenTridiagonal(mode='dense') + res_sparse = least_squares( + sparse.fun, sparse.x0, jac=sparse.jac, + method=self.method) + res_dense = least_squares( + dense.fun, dense.x0, jac=sparse.jac, + method=self.method) + assert_equal(res_sparse.nfev, res_dense.nfev) + assert_allclose(res_sparse.x, res_dense.x, atol=1e-20) + assert_allclose(res_sparse.cost, 0, atol=1e-20) + assert_allclose(res_dense.cost, 0, atol=1e-20) + + def test_tr_options(self): + p = BroydenTridiagonal() + res = least_squares(p.fun, p.x0, p.jac, method=self.method, + tr_options={'btol': 1e-10}) + assert_allclose(res.cost, 0, atol=1e-20) + + def test_wrong_parameters(self): + p = BroydenTridiagonal() + assert_raises(ValueError, least_squares, p.fun, p.x0, p.jac, + tr_solver='best', method=self.method) + assert_raises(TypeError, least_squares, p.fun, p.x0, p.jac, + tr_solver='lsmr', tr_options={'tol': 1e-10}) + + def test_solver_selection(self): + sparse = BroydenTridiagonal(mode='sparse') + dense = BroydenTridiagonal(mode='dense') + res_sparse = least_squares(sparse.fun, sparse.x0, jac=sparse.jac, + method=self.method) + res_dense = least_squares(dense.fun, dense.x0, jac=dense.jac, + method=self.method) + assert_allclose(res_sparse.cost, 0, atol=1e-20) + assert_allclose(res_dense.cost, 0, atol=1e-20) + assert_(issparse(res_sparse.jac)) + assert_(isinstance(res_dense.jac, np.ndarray)) + + def test_numerical_jac(self): + p = BroydenTridiagonal() + for jac in ['2-point', '3-point', 'cs']: + res_dense = least_squares(p.fun, p.x0, jac, method=self.method) + res_sparse = least_squares( + p.fun, p.x0, jac,method=self.method, + jac_sparsity=p.sparsity) + assert_equal(res_dense.nfev, res_sparse.nfev) + assert_allclose(res_dense.x, res_sparse.x, atol=1e-20) + assert_allclose(res_dense.cost, 0, atol=1e-20) + assert_allclose(res_sparse.cost, 0, atol=1e-20) + + @pytest.mark.fail_slow(10) + def test_with_bounds(self): + p = BroydenTridiagonal() + for jac, jac_sparsity in product( + [p.jac, '2-point', '3-point', 'cs'], [None, p.sparsity]): + res_1 = least_squares( + p.fun, p.x0, jac, bounds=(p.lb, np.inf), + method=self.method,jac_sparsity=jac_sparsity) + res_2 = least_squares( + p.fun, p.x0, jac, bounds=(-np.inf, p.ub), + method=self.method, jac_sparsity=jac_sparsity) + res_3 = least_squares( + p.fun, p.x0, jac, bounds=(p.lb, p.ub), + method=self.method, jac_sparsity=jac_sparsity) + assert_allclose(res_1.optimality, 0, atol=1e-10) + assert_allclose(res_2.optimality, 0, atol=1e-10) + assert_allclose(res_3.optimality, 0, atol=1e-10) + + def test_wrong_jac_sparsity(self): + p = BroydenTridiagonal() + sparsity = p.sparsity[:-1] + assert_raises(ValueError, least_squares, p.fun, p.x0, + jac_sparsity=sparsity, method=self.method) + + def test_linear_operator(self): + p = BroydenTridiagonal(mode='operator') + res = least_squares(p.fun, p.x0, p.jac, method=self.method) + assert_allclose(res.cost, 0.0, atol=1e-20) + assert_raises(ValueError, least_squares, p.fun, p.x0, p.jac, + method=self.method, tr_solver='exact') + + def test_x_scale_jac_scale(self): + p = BroydenTridiagonal() + res = least_squares(p.fun, p.x0, p.jac, method=self.method, + x_scale='jac') + assert_allclose(res.cost, 0.0, atol=1e-20) + + p = BroydenTridiagonal(mode='operator') + assert_raises(ValueError, least_squares, p.fun, p.x0, p.jac, + method=self.method, x_scale='jac') + + +class LossFunctionMixin: + def test_options(self): + for loss in LOSSES: + res = least_squares(fun_trivial, 2.0, loss=loss, + method=self.method) + assert_allclose(res.x, 0, atol=1e-15) + + assert_raises(ValueError, least_squares, fun_trivial, 2.0, + loss='hinge', method=self.method) + + def test_fun(self): + # Test that res.fun is actual residuals, and not modified by loss + # function stuff. + for loss in LOSSES: + res = least_squares(fun_trivial, 2.0, loss=loss, + method=self.method) + assert_equal(res.fun, fun_trivial(res.x)) + + def test_grad(self): + # Test that res.grad is true gradient of loss function at the + # solution. Use max_nfev = 1, to avoid reaching minimum. + x = np.array([2.0]) # res.x will be this. + + res = least_squares(fun_trivial, x, jac_trivial, loss='linear', + max_nfev=1, method=self.method) + assert_equal(res.grad, 2 * x * (x**2 + 5)) + + res = least_squares(fun_trivial, x, jac_trivial, loss='huber', + max_nfev=1, method=self.method) + assert_equal(res.grad, 2 * x) + + res = least_squares(fun_trivial, x, jac_trivial, loss='soft_l1', + max_nfev=1, method=self.method) + assert_allclose(res.grad, + 2 * x * (x**2 + 5) / (1 + (x**2 + 5)**2)**0.5) + + res = least_squares(fun_trivial, x, jac_trivial, loss='cauchy', + max_nfev=1, method=self.method) + assert_allclose(res.grad, 2 * x * (x**2 + 5) / (1 + (x**2 + 5)**2)) + + res = least_squares(fun_trivial, x, jac_trivial, loss='arctan', + max_nfev=1, method=self.method) + assert_allclose(res.grad, 2 * x * (x**2 + 5) / (1 + (x**2 + 5)**4)) + + res = least_squares(fun_trivial, x, jac_trivial, loss=cubic_soft_l1, + max_nfev=1, method=self.method) + assert_allclose(res.grad, + 2 * x * (x**2 + 5) / (1 + (x**2 + 5)**2)**(2/3)) + + def test_jac(self): + # Test that res.jac.T.dot(res.jac) gives Gauss-Newton approximation + # of Hessian. This approximation is computed by doubly differentiating + # the cost function and dropping the part containing second derivative + # of f. For a scalar function it is computed as + # H = (rho' + 2 * rho'' * f**2) * f'**2, if the expression inside the + # brackets is less than EPS it is replaced by EPS. Here, we check + # against the root of H. + + x = 2.0 # res.x will be this. + f = x**2 + 5 # res.fun will be this. + + res = least_squares(fun_trivial, x, jac_trivial, loss='linear', + max_nfev=1, method=self.method) + assert_equal(res.jac, 2 * x) + + # For `huber` loss the Jacobian correction is identically zero + # in outlier region, in such cases it is modified to be equal EPS**0.5. + res = least_squares(fun_trivial, x, jac_trivial, loss='huber', + max_nfev=1, method=self.method) + assert_equal(res.jac, 2 * x * EPS**0.5) + + # Now, let's apply `loss_scale` to turn the residual into an inlier. + # The loss function becomes linear. + res = least_squares(fun_trivial, x, jac_trivial, loss='huber', + f_scale=10, max_nfev=1) + assert_equal(res.jac, 2 * x) + + # 'soft_l1' always gives a positive scaling. + res = least_squares(fun_trivial, x, jac_trivial, loss='soft_l1', + max_nfev=1, method=self.method) + assert_allclose(res.jac, 2 * x * (1 + f**2)**-0.75) + + # For 'cauchy' the correction term turns out to be negative, and it + # replaced by EPS**0.5. + res = least_squares(fun_trivial, x, jac_trivial, loss='cauchy', + max_nfev=1, method=self.method) + assert_allclose(res.jac, 2 * x * EPS**0.5) + + # Now use scaling to turn the residual to inlier. + res = least_squares(fun_trivial, x, jac_trivial, loss='cauchy', + f_scale=10, max_nfev=1, method=self.method) + fs = f / 10 + assert_allclose(res.jac, 2 * x * (1 - fs**2)**0.5 / (1 + fs**2)) + + # 'arctan' gives an outlier. + res = least_squares(fun_trivial, x, jac_trivial, loss='arctan', + max_nfev=1, method=self.method) + assert_allclose(res.jac, 2 * x * EPS**0.5) + + # Turn to inlier. + res = least_squares(fun_trivial, x, jac_trivial, loss='arctan', + f_scale=20.0, max_nfev=1, method=self.method) + fs = f / 20 + assert_allclose(res.jac, 2 * x * (1 - 3 * fs**4)**0.5 / (1 + fs**4)) + + # cubic_soft_l1 will give an outlier. + res = least_squares(fun_trivial, x, jac_trivial, loss=cubic_soft_l1, + max_nfev=1) + assert_allclose(res.jac, 2 * x * EPS**0.5) + + # Turn to inlier. + res = least_squares(fun_trivial, x, jac_trivial, + loss=cubic_soft_l1, f_scale=6, max_nfev=1) + fs = f / 6 + assert_allclose(res.jac, + 2 * x * (1 - fs**2 / 3)**0.5 * (1 + fs**2)**(-5/6)) + + def test_robustness(self): + for noise in [0.1, 1.0]: + p = ExponentialFittingProblem(1, 0.1, noise, random_seed=0) + + for jac in ['2-point', '3-point', 'cs', p.jac]: + res_lsq = least_squares(p.fun, p.p0, jac=jac, + method=self.method) + assert_allclose(res_lsq.optimality, 0, atol=1e-2) + for loss in LOSSES: + if loss == 'linear': + continue + res_robust = least_squares( + p.fun, p.p0, jac=jac, loss=loss, f_scale=noise, + method=self.method) + assert_allclose(res_robust.optimality, 0, atol=1e-2) + assert_(norm(res_robust.x - p.p_opt) < + norm(res_lsq.x - p.p_opt)) + + +class TestDogbox(BaseMixin, BoundsMixin, SparseMixin, LossFunctionMixin): + method = 'dogbox' + + +class TestTRF(BaseMixin, BoundsMixin, SparseMixin, LossFunctionMixin): + method = 'trf' + + def test_lsmr_regularization(self): + p = BroydenTridiagonal() + for regularize in [True, False]: + res = least_squares(p.fun, p.x0, p.jac, method='trf', + tr_options={'regularize': regularize}) + assert_allclose(res.cost, 0, atol=1e-20) + + +class TestLM(BaseMixin): + method = 'lm' + + def test_bounds_not_supported(self): + assert_raises(ValueError, least_squares, fun_trivial, + 2.0, bounds=(-3.0, 3.0), method='lm') + + def test_m_less_n_not_supported(self): + x0 = [-2, 1] + assert_raises(ValueError, least_squares, fun_rosenbrock_cropped, x0, + method='lm') + + def test_sparse_not_supported(self): + p = BroydenTridiagonal() + assert_raises(ValueError, least_squares, p.fun, p.x0, p.jac, + method='lm') + + def test_jac_sparsity_not_supported(self): + assert_raises(ValueError, least_squares, fun_trivial, 2.0, + jac_sparsity=[1], method='lm') + + def test_LinearOperator_not_supported(self): + p = BroydenTridiagonal(mode="operator") + assert_raises(ValueError, least_squares, p.fun, p.x0, p.jac, + method='lm') + + def test_loss(self): + res = least_squares(fun_trivial, 2.0, loss='linear', method='lm') + assert_allclose(res.x, 0.0, atol=1e-4) + + assert_raises(ValueError, least_squares, fun_trivial, 2.0, + method='lm', loss='huber') + + +def test_basic(): + # test that 'method' arg is really optional + res = least_squares(fun_trivial, 2.0) + assert_allclose(res.x, 0, atol=1e-10) + + +def test_small_tolerances_for_lm(): + for ftol, xtol, gtol in [(None, 1e-13, 1e-13), + (1e-13, None, 1e-13), + (1e-13, 1e-13, None)]: + assert_raises(ValueError, least_squares, fun_trivial, 2.0, xtol=xtol, + ftol=ftol, gtol=gtol, method='lm') + + +def test_fp32_gh12991(): + # checks that smaller FP sizes can be used in least_squares + # this is the minimum working example reported for gh12991 + rng = np.random.RandomState(1) + + x = np.linspace(0, 1, 100).astype("float32") + y = rng.random(100).astype("float32") + + def func(p, x): + return p[0] + p[1] * x + + def err(p, x, y): + return func(p, x) - y + + res = least_squares(err, [-1.0, -1.0], args=(x, y)) + # previously the initial jacobian calculated for this would be all 0 + # and the minimize would terminate immediately, with nfev=1, would + # report a successful minimization (it shouldn't have done), but be + # unchanged from the initial solution. + # It was terminating early because the underlying approx_derivative + # used a step size for FP64 when the working space was FP32. + assert res.nfev > 2 + assert_allclose(res.x, np.array([0.4082241, 0.15530563]), atol=5e-5) + + +def test_gh_18793_and_19351(): + answer = 1e-12 + initial_guess = 1.1e-12 + + def chi2(x): + return (x-answer)**2 + + gtol = 1e-15 + res = least_squares(chi2, x0=initial_guess, gtol=1e-15, bounds=(0, np.inf)) + # Original motivation: gh-18793 + # if we choose an initial condition that is close to the solution + # we shouldn't return an answer that is further away from the solution + + # Update: gh-19351 + # However this requirement does not go well with 'trf' algorithm logic. + # Some regressions were reported after the presumed fix. + # The returned solution is good as long as it satisfies the convergence + # conditions. + # Specifically in this case the scaled gradient will be sufficiently low. + + scaling, _ = CL_scaling_vector(res.x, res.grad, + np.atleast_1d(0), np.atleast_1d(np.inf)) + assert res.status == 1 # Converged by gradient + assert np.linalg.norm(res.grad * scaling, ord=np.inf) < gtol + + +def test_gh_19103(): + # Checks that least_squares trf method selects a strictly feasible point, + # and thus succeeds instead of failing, + # when the initial guess is reported exactly at a boundary point. + # This is a reduced example from gh191303 + + ydata = np.array([0.] * 66 + [ + 1., 0., 0., 0., 0., 0., 1., 1., 0., 0., 1., + 1., 1., 1., 0., 0., 0., 1., 0., 0., 2., 1., + 0., 3., 1., 6., 5., 0., 0., 2., 8., 4., 4., + 6., 9., 7., 2., 7., 8., 2., 13., 9., 8., 11., + 10., 13., 14., 19., 11., 15., 18., 26., 19., 32., 29., + 28., 36., 32., 35., 36., 43., 52., 32., 58., 56., 52., + 67., 53., 72., 88., 77., 95., 94., 84., 86., 101., 107., + 108., 118., 96., 115., 138., 137., + ]) + xdata = np.arange(0, ydata.size) * 0.1 + + def exponential_wrapped(params): + A, B, x0 = params + return A * np.exp(B * (xdata - x0)) - ydata + + x0 = [0.01, 1., 5.] + bounds = ((0.01, 0, 0), (np.inf, 10, 20.9)) + res = least_squares(exponential_wrapped, x0, method='trf', bounds=bounds) + assert res.success diff --git a/shared/package-files/30/307010744e213d5ce0bbe72c5556e6d43349f3474fed7b6127591bd889fc2263/blob b/shared/package-files/30/307010744e213d5ce0bbe72c5556e6d43349f3474fed7b6127591bd889fc2263/blob new file mode 100644 index 0000000000000000000000000000000000000000..df0d838f517f6c0afd8954ad87bc83886e0e3de4 --- /dev/null +++ b/shared/package-files/30/307010744e213d5ce0bbe72c5556e6d43349f3474fed7b6127591bd889fc2263/blob @@ -0,0 +1,100 @@ +0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 0 0 1 0 0 1 0 0 0 1 1 0 0 1 1 +1 1 1 1 1 1 1 0 0 1 1 1 0 0 0 0 1 0 1 0 1 1 1 0 1 0 1 1 1 1 +0 1 0 1 1 0 0 1 1 1 1 0 1 0 0 1 1 0 1 1 1 0 1 1 0 1 1 1 0 1 +1 1 1 0 0 1 1 0 0 1 1 1 0 0 1 1 0 1 1 1 0 1 1 0 0 0 0 1 0 0 +1 0 0 0 0 1 1 0 1 1 0 1 0 0 0 0 1 0 0 1 0 1 0 0 1 1 1 1 0 0 +1 0 1 1 0 0 0 1 1 1 1 1 0 1 1 0 1 0 1 0 1 0 0 0 0 0 0 0 1 1 +0 1 0 0 1 0 0 0 1 0 0 1 1 0 0 0 0 1 1 0 0 1 0 1 1 1 1 0 1 0 +1 0 1 1 1 0 0 0 0 1 1 0 0 0 0 1 0 1 0 0 0 1 1 1 0 1 0 0 1 0 +1 1 1 0 0 1 1 0 0 1 0 0 1 0 0 1 0 1 1 0 1 1 0 1 1 1 0 0 1 1 +1 1 0 1 0 0 1 1 1 1 1 1 1 0 1 0 1 1 1 1 0 0 0 0 0 0 1 1 0 0 +1 0 1 0 1 1 0 1 1 0 1 1 0 1 1 1 1 0 0 1 1 0 0 0 0 1 0 0 0 0 +1 1 1 1 0 1 0 0 0 0 0 1 0 1 1 1 1 0 1 1 1 1 1 1 0 1 0 1 1 1 +1 1 1 1 1 1 1 1 1 0 1 1 0 0 1 0 1 0 1 0 1 0 0 0 1 0 0 1 0 1 +0 1 1 0 0 1 1 0 0 0 0 1 0 1 1 0 1 0 1 0 1 1 0 1 0 0 1 1 1 1 +1 0 0 1 0 0 1 0 1 0 0 1 0 0 0 1 1 0 0 0 1 0 1 0 0 1 1 0 1 1 +1 0 0 1 1 0 0 1 1 0 0 1 1 1 1 1 1 1 1 0 1 1 1 1 0 1 1 1 0 0 +1 1 0 0 1 0 0 0 1 0 0 1 0 1 0 0 1 0 1 1 0 1 0 0 0 1 1 1 1 1 +0 0 0 1 1 1 1 1 0 1 0 1 1 1 1 0 0 1 1 1 1 1 0 0 1 0 1 0 0 0 +1 0 1 1 0 1 0 0 1 0 0 1 0 0 1 0 0 0 1 0 0 1 1 1 0 1 1 0 1 1 +0 0 0 0 1 0 1 0 1 1 0 0 1 0 0 0 0 0 0 0 0 1 1 1 0 0 0 1 1 1 +0 1 0 0 1 1 0 0 1 1 1 0 0 0 1 0 0 0 0 1 1 0 0 1 0 1 1 0 1 0 +1 0 1 0 1 1 1 0 0 0 1 0 1 1 0 0 0 0 0 0 0 1 0 0 1 1 1 0 1 1 +0 0 1 0 0 0 0 0 1 1 0 0 1 1 1 1 1 1 1 1 0 1 0 0 0 0 0 0 1 0 +0 1 0 1 1 1 0 1 1 1 0 1 0 1 1 1 0 0 0 0 1 1 1 0 0 1 1 0 0 1 +0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 1 1 0 1 1 0 0 +1 0 0 0 1 0 1 0 0 1 0 1 1 0 1 0 1 0 1 0 1 1 1 0 0 0 1 1 1 0 +1 0 0 0 1 1 1 0 0 1 0 1 1 1 0 0 0 1 1 1 0 0 0 0 1 0 0 0 1 1 +0 1 0 0 0 1 1 1 0 1 1 1 0 1 0 0 1 1 1 1 0 1 0 1 0 1 1 0 1 1 +0 0 1 0 0 0 0 0 0 0 0 1 1 0 1 0 0 1 0 0 0 1 0 1 0 1 0 1 0 1 +0 0 1 0 1 0 1 1 1 1 0 0 1 1 1 1 0 0 1 1 1 1 0 0 1 0 1 0 1 0 +1 1 0 1 1 1 1 1 0 1 0 0 0 1 1 1 0 1 0 0 0 1 1 0 1 0 0 0 0 1 +0 1 0 0 0 1 0 1 1 0 0 1 0 0 0 1 1 1 0 0 1 1 0 1 1 0 0 1 0 1 +1 1 0 0 0 0 0 1 1 0 1 1 0 0 1 0 1 1 0 0 0 1 0 1 0 1 0 1 0 1 +1 1 1 0 1 0 0 1 1 0 1 1 1 0 1 0 1 1 0 0 0 1 1 0 0 1 1 1 1 1 +0 1 0 0 1 1 0 0 1 1 1 1 0 1 0 1 0 1 1 1 0 1 1 0 1 1 0 0 1 0 +1 1 1 1 0 1 0 1 0 1 1 1 1 0 1 0 1 0 1 0 1 1 0 0 1 0 1 0 0 0 +0 0 0 0 1 1 1 0 1 1 0 0 1 1 1 1 0 1 0 1 1 1 1 1 1 0 0 0 0 0 +0 1 1 1 0 0 0 1 1 1 0 1 0 0 1 1 1 1 1 0 1 0 0 1 0 0 0 0 1 1 +0 1 0 0 1 1 1 1 0 0 1 0 1 0 1 1 0 0 1 0 0 1 1 0 0 0 0 1 0 0 +1 1 0 1 0 0 1 1 0 0 1 1 1 0 0 1 1 1 0 0 0 0 1 1 1 0 1 0 0 1 +0 1 1 0 1 0 1 1 0 0 0 1 1 0 0 0 0 0 0 1 0 0 1 1 0 1 0 0 1 1 +0 0 1 1 1 0 1 0 0 1 1 0 0 0 1 1 1 0 1 0 0 0 0 1 1 0 1 1 0 0 +1 0 1 1 1 1 1 1 1 1 0 1 0 0 0 1 0 1 0 0 0 1 1 0 0 1 0 0 0 0 +1 0 1 1 1 0 1 1 1 1 0 0 1 0 1 1 1 0 0 0 0 1 1 1 1 1 0 1 0 0 +1 0 0 0 1 1 1 0 1 1 0 0 1 1 1 0 1 0 0 1 0 1 0 1 1 1 0 0 0 1 +1 0 1 0 1 0 0 0 1 0 0 1 1 0 1 1 0 0 0 1 0 1 1 0 1 0 0 1 0 0 +0 1 1 0 1 0 1 1 1 1 1 0 0 0 0 1 0 1 0 0 1 1 1 1 0 1 0 1 1 1 +0 1 0 1 1 0 1 0 0 1 0 0 1 0 0 1 1 0 1 0 0 0 1 1 1 0 0 1 0 1 +1 0 1 1 1 0 1 0 1 0 1 1 0 1 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 1 +1 1 1 1 1 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 0 0 1 1 1 1 0 1 0 1 +1 1 1 1 0 0 0 1 0 1 1 0 0 0 1 1 0 0 1 1 1 1 0 0 0 1 0 1 0 0 +1 0 1 0 0 1 1 1 1 0 1 1 0 0 1 0 0 1 1 0 1 1 1 1 1 1 0 0 0 0 +0 1 1 0 0 1 0 0 0 0 0 1 0 1 0 0 1 1 0 1 0 1 0 0 0 1 0 0 1 0 +0 0 0 1 0 0 0 1 1 1 1 1 0 0 0 1 1 0 0 0 1 1 1 0 1 0 1 1 1 0 +1 1 0 0 0 0 1 1 1 0 1 0 1 1 1 0 0 1 0 0 0 0 0 0 1 1 1 0 0 0 +1 0 1 1 1 0 1 0 1 0 0 1 1 1 1 1 0 0 1 1 0 1 1 1 1 0 0 0 0 1 +0 0 1 1 1 0 0 0 0 1 0 0 0 0 0 0 1 0 0 1 0 0 1 1 1 0 0 1 0 0 +0 0 1 1 1 1 1 0 1 0 1 0 0 1 1 1 1 0 0 0 1 0 1 1 0 1 1 1 0 0 +0 0 0 0 0 1 0 0 1 1 0 1 1 0 0 0 0 1 0 1 1 0 0 1 0 0 1 0 1 0 +1 0 0 1 0 1 1 1 0 1 0 1 1 0 0 1 1 0 1 1 1 0 1 0 0 0 1 1 1 1 +0 0 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 1 1 0 0 1 1 0 0 0 +1 0 0 1 1 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 1 0 1 1 0 0 1 0 1 0 +0 1 0 1 1 1 1 1 0 1 0 1 1 0 0 1 1 0 1 1 0 1 1 0 1 1 0 0 0 1 +1 0 1 1 1 0 0 0 1 0 0 1 0 0 0 1 0 1 1 1 0 0 1 1 1 1 0 0 0 1 +0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 1 1 0 1 0 1 0 1 1 1 0 1 1 0 1 +0 0 1 0 1 1 1 0 0 0 1 0 1 0 1 1 0 0 1 1 0 1 0 1 1 0 0 1 0 1 +0 1 1 1 1 1 0 0 0 0 0 1 0 1 1 1 1 1 0 1 1 1 0 0 1 0 0 1 1 1 +1 1 1 1 0 1 1 1 1 1 1 0 0 1 1 0 1 1 0 1 0 1 0 1 0 1 1 0 0 0 +1 0 0 0 1 0 1 0 0 0 1 0 1 0 0 1 0 1 1 1 1 1 0 0 1 1 1 1 1 0 +0 0 0 0 1 1 1 0 1 0 0 1 1 0 0 1 1 1 1 0 0 1 0 1 0 0 0 1 0 0 +1 1 1 1 1 0 0 0 1 1 0 0 1 1 1 1 0 1 0 1 0 0 0 0 1 1 0 1 1 0 +1 0 1 1 0 1 0 1 0 1 1 0 1 1 1 0 0 1 0 0 1 1 0 0 1 1 0 1 0 1 +1 1 1 1 1 0 0 0 0 1 0 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 0 1 1 1 +0 1 1 0 0 1 0 0 0 0 0 0 0 0 1 1 1 0 0 1 0 1 1 1 0 1 1 1 1 1 +1 1 1 0 1 1 1 1 1 0 0 0 0 1 0 0 1 0 1 0 1 1 1 0 0 1 0 0 1 1 +1 1 0 1 0 1 0 1 0 0 1 0 0 0 1 0 1 1 0 1 1 0 1 0 0 1 0 0 1 0 +1 0 1 1 0 0 1 1 0 0 1 1 0 0 0 1 1 0 0 1 0 0 0 0 0 1 0 1 1 0 +1 1 1 1 1 0 0 1 0 0 1 1 1 0 1 0 0 1 1 1 0 1 1 1 1 1 1 1 1 1 +1 0 1 1 0 0 1 1 0 1 1 1 0 0 0 1 0 1 0 0 0 1 1 1 1 1 0 0 1 0 +0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 1 1 1 0 0 1 1 0 0 1 0 0 1 0 0 +1 1 1 0 0 0 0 1 0 1 1 1 1 1 1 1 0 1 0 1 1 1 1 0 1 1 1 0 1 0 +1 0 0 1 0 1 0 0 0 0 0 0 1 0 1 0 1 1 0 1 0 1 1 0 0 1 0 1 0 1 +1 0 0 0 1 0 1 1 0 1 0 0 0 1 0 1 0 0 0 0 1 1 1 0 1 0 1 1 0 1 +0 1 0 0 0 0 1 0 1 1 1 0 1 1 0 1 0 1 0 1 1 0 0 0 0 0 0 1 1 1 +0 1 0 0 1 0 1 1 0 0 0 0 1 1 0 1 1 1 0 0 1 1 0 0 1 0 1 0 0 0 +0 1 0 1 1 1 1 1 1 1 0 0 1 0 1 0 0 0 0 0 0 1 0 0 1 0 0 1 1 0 +0 0 0 1 0 0 1 0 0 1 1 0 0 0 0 0 0 0 1 0 0 1 0 0 0 1 0 1 0 0 +1 0 0 0 1 0 1 1 1 1 1 1 1 0 1 0 1 1 1 0 0 1 0 1 0 1 0 1 0 0 +1 0 0 0 1 0 1 0 0 0 1 1 0 0 0 1 1 0 0 1 1 1 1 1 1 0 1 1 1 0 +0 0 0 1 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 1 1 1 0 1 0 0 0 1 1 0 +1 0 0 0 0 0 1 0 1 0 1 0 0 1 1 1 0 1 1 1 0 0 1 0 1 1 1 0 1 0 +0 1 0 0 1 1 1 0 0 1 0 0 0 1 0 1 0 0 0 1 0 0 1 0 0 1 1 1 0 1 +0 0 0 1 1 0 1 0 1 0 1 0 0 0 1 1 1 0 1 1 0 0 0 1 1 0 0 1 0 1 +1 1 1 1 1 1 1 1 0 0 1 1 0 0 0 1 0 1 0 1 0 0 0 1 1 0 1 0 1 0 +0 1 1 0 0 0 1 1 0 0 1 1 0 1 1 1 1 1 0 1 0 0 0 0 1 0 1 0 0 0 +1 1 1 0 1 1 1 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 1 0 1 1 0 0 1 +0 0 1 0 0 1 0 0 1 0 0 0 1 0 0 1 1 1 1 1 1 1 0 1 0 0 0 1 1 0 +1 1 1 0 1 1 0 1 1 0 1 1 0 1 0 0 1 0 0 0 1 1 1 1 0 1 1 0 1 1 +0 0 1 1 1 0 0 0 0 1 1 0 0 1 1 0 1 0 1 0 0 1 0 0 0 1 1 0 0 1 +0 0 0 1 0 0 1 1 1 1 1 1 0 0 1 0 0 1 0 0 0 0 1 1 1 1 1 1 0 0 diff --git a/shared/package-files/30/3070cf501a0b0c97ca3f7527302c24b401fa625bec8d515d2fd3a4c67e222286/blob b/shared/package-files/30/3070cf501a0b0c97ca3f7527302c24b401fa625bec8d515d2fd3a4c67e222286/blob new file mode 100644 index 0000000000000000000000000000000000000000..143534ff639ffd081fe4ba5691f4be95c83774a8 --- /dev/null +++ b/shared/package-files/30/3070cf501a0b0c97ca3f7527302c24b401fa625bec8d515d2fd3a4c67e222286/blob @@ -0,0 +1,2121 @@ +"""Functions to export models into the ONNX IR format. + +These models can be loaded with the ONNX library and then +converted to models which run on other deep learning frameworks. +""" +from __future__ import annotations + +import contextlib +import copy +import inspect +import io +import re +import textwrap +import typing +import warnings +from typing import ( + Any, + Callable, + cast, + Collection, + Dict, + List, + Mapping, + Optional, + Sequence, + Set, + Tuple, + Type, + Union, +) + +import torch +import torch._C._onnx as _C_onnx +import torch.jit._trace +import torch.serialization +from torch import _C +from torch.onnx import ( # noqa: F401 + _constants, + _exporter_states, + errors, + symbolic_caffe2, + symbolic_helper, +) +from torch.onnx._globals import GLOBALS +from torch.onnx._internal import ( + _beartype, + diagnostics, + jit_utils, + onnx_proto_utils, + registration, +) + +__all__ = [ + "is_in_onnx_export", + "select_model_mode_for_export", + "disable_apex_o2_state_dict_hook", + "setup_onnx_logging", + "exporter_context", + "export", + "model_signature", + "warn_on_static_input_change", + "unpack_quantized_tensor", + "export_to_pretty_string", + "unconvertible_ops", + "register_custom_op_symbolic", + "unregister_custom_op_symbolic", +] + + +def is_in_onnx_export() -> bool: + """Returns whether it is in the middle of ONNX export.""" + return GLOBALS.in_onnx_export + + +# TODO(justinchuby): Remove dependency to this global variable from constant_fold.cpp +# Skip check due to cannot import IValue from torch._C +_params_dict = {} # type: ignore[var-annotated] + + +@contextlib.contextmanager +@_beartype.beartype +def select_model_mode_for_export(model, mode: _C_onnx.TrainingMode): + r"""A context manager to temporarily set the training mode of ``model`` + to ``mode``, resetting it when we exit the with-block. + + Args: + model: Same type and meaning as ``model`` arg to :func:`export`. + mode: Same type and meaning as ``training`` arg to :func:`export`. + """ + if not isinstance(mode, _C_onnx.TrainingMode): + raise TypeError( + f"'mode' should be a torch.onnx.TrainingMode enum, but got '{type(mode)}'." + ) + originally_training: bool = False + + if hasattr(model, "training"): + originally_training = model.training + + # ONNX opset 12 has better support for training amenable models, with updated + # versions of the dropout and batch_norm operators + if mode == _C_onnx.TrainingMode.TRAINING or ( + mode == _C_onnx.TrainingMode.PRESERVE and originally_training + ): + GLOBALS.export_training = True + if GLOBALS.export_onnx_opset_version < 12: + warnings.warn( + "You are exporting the model in training mode with onnx opset " + f"version {GLOBALS.export_onnx_opset_version}. " + "Opset versions lower than opset 12 will not be able to export " + "nodes such as Dropout and BatchNorm correctly." + ) + else: + GLOBALS.export_training = False + + GLOBALS.training_mode = mode + if mode == _C_onnx.TrainingMode.TRAINING: + model.train(True) + elif mode == _C_onnx.TrainingMode.EVAL: + model.train(False) + # else mode == _C_onnx.TrainingMode.PRESERVE, do nothing + + try: + yield + finally: + if hasattr(model, "training") and not mode == _C_onnx.TrainingMode.PRESERVE: + model.train(originally_training) + + +@contextlib.contextmanager +@_beartype.beartype +def disable_apex_o2_state_dict_hook( + model: Union[torch.nn.Module, torch.jit.ScriptFunction] +): + # Apex O2 hook state_dict to return fp16 weights as fp32. + # Exporter cannot identify them as same tensors. + # Since this hook is only used by optimizer, it is safe to + # remove this hook while exporting. + if not isinstance(model, torch.jit.ScriptFunction): + model_hooks = {} # type: ignore[var-annotated] + for module in model.modules(): + for key, hook in module._state_dict_hooks.items(): + if type(hook).__name__ == "O2StateDictHook": + if module not in model_hooks: + model_hooks[module] = {} + model_hooks[module][key] = hook + if module in model_hooks: + for key in model_hooks[module]: + module._state_dict_hooks.pop(key) + try: + yield + finally: + # Add the hooks back + for module, m_map in model_hooks.items(): + for key, hook in m_map.items(): + module._state_dict_hooks[key] = hook + else: + try: + yield + finally: + pass + + +@contextlib.contextmanager +@_beartype.beartype +def setup_onnx_logging(verbose: bool): + is_originally_enabled = torch.onnx.is_onnx_log_enabled() + if is_originally_enabled or verbose: + torch.onnx.enable_log() + try: + yield + finally: + if not is_originally_enabled: + torch.onnx.disable_log() + + +@contextlib.contextmanager +@_beartype.beartype +def exporter_context(model, mode: _C_onnx.TrainingMode, verbose: bool): + with select_model_mode_for_export( + model, mode + ) as mode_ctx, disable_apex_o2_state_dict_hook( + model + ) as apex_ctx, setup_onnx_logging( + verbose + ) as log_ctx, diagnostics.create_export_diagnostic_context() as diagnostic_ctx: + yield (mode_ctx, apex_ctx, log_ctx, diagnostic_ctx) + + +@_beartype.beartype +def export( + model: Union[torch.nn.Module, torch.jit.ScriptModule, torch.jit.ScriptFunction], + args: Union[Tuple[Any, ...], torch.Tensor], + f: Union[str, io.BytesIO], + export_params: bool = True, + verbose: bool = False, + training: _C_onnx.TrainingMode = _C_onnx.TrainingMode.EVAL, + input_names: Optional[Sequence[str]] = None, + output_names: Optional[Sequence[str]] = None, + operator_export_type: _C_onnx.OperatorExportTypes = _C_onnx.OperatorExportTypes.ONNX, + opset_version: Optional[int] = None, + do_constant_folding: bool = True, + dynamic_axes: Optional[ + Union[Mapping[str, Mapping[int, str]], Mapping[str, Sequence[int]]] + ] = None, + keep_initializers_as_inputs: Optional[bool] = None, + custom_opsets: Optional[Mapping[str, int]] = None, + export_modules_as_functions: Union[bool, Collection[Type[torch.nn.Module]]] = False, + autograd_inlining: Optional[bool] = True, +) -> None: + r"""Exports a model into ONNX format. + + If ``model`` is not a :class:`torch.jit.ScriptModule` nor a + :class:`torch.jit.ScriptFunction`, this runs + ``model`` once in order to convert it to a TorchScript graph to be exported + (the equivalent of :func:`torch.jit.trace`). Thus this has the same limited support + for dynamic control flow as :func:`torch.jit.trace`. + + Args: + model (:class:`torch.nn.Module`, :class:`torch.jit.ScriptModule` or :class:`torch.jit.ScriptFunction`): + the model to be exported. + args (tuple or torch.Tensor): + + args can be structured either as: + + 1. ONLY A TUPLE OF ARGUMENTS:: + + args = (x, y, z) + + The tuple should contain model inputs such that ``model(*args)`` is a valid + invocation of the model. Any non-Tensor arguments will be hard-coded into the + exported model; any Tensor arguments will become inputs of the exported model, + in the order they occur in the tuple. + + 2. A TENSOR:: + + args = torch.Tensor([1]) + + This is equivalent to a 1-ary tuple of that Tensor. + + 3. A TUPLE OF ARGUMENTS ENDING WITH A DICTIONARY OF NAMED ARGUMENTS:: + + args = ( + x, + { + "y": input_y, + "z": input_z + } + ) + + All but the last element of the tuple will be passed as non-keyword arguments, + and named arguments will be set from the last element. If a named argument is + not present in the dictionary, it is assigned the default value, or None if a + default value is not provided. + + .. note:: + If a dictionary is the last element of the args tuple, it will be + interpreted as containing named arguments. In order to pass a dict as the + last non-keyword arg, provide an empty dict as the last element of the args + tuple. For example, instead of:: + + torch.onnx.export( + model, + ( + x, + # WRONG: will be interpreted as named arguments + {y: z} + ), + "test.onnx.pb" + ) + + Write:: + + torch.onnx.export( + model, + ( + x, + {y: z}, + {} + ), + "test.onnx.pb" + ) + + f: a file-like object (such that ``f.fileno()`` returns a file descriptor) + or a string containing a file name. A binary protocol buffer will be written + to this file. + export_params (bool, default True): if True, all parameters will + be exported. Set this to False if you want to export an untrained model. + In this case, the exported model will first take all of its parameters + as arguments, with the ordering as specified by ``model.state_dict().values()`` + verbose (bool, default False): if True, prints a description of the + model being exported to stdout. In addition, the final ONNX graph will include the + field ``doc_string``` from the exported model which mentions the source code locations + for ``model``. If True, ONNX exporter logging will be turned on. + training (enum, default TrainingMode.EVAL): + * ``TrainingMode.EVAL``: export the model in inference mode. + * ``TrainingMode.PRESERVE``: export the model in inference mode if model.training is + False and in training mode if model.training is True. + * ``TrainingMode.TRAINING``: export the model in training mode. Disables optimizations + which might interfere with training. + input_names (list of str, default empty list): names to assign to the + input nodes of the graph, in order. + output_names (list of str, default empty list): names to assign to the + output nodes of the graph, in order. + operator_export_type (enum, default OperatorExportTypes.ONNX): + + * ``OperatorExportTypes.ONNX``: Export all ops as regular ONNX ops + (in the default opset domain). + * ``OperatorExportTypes.ONNX_FALLTHROUGH``: Try to convert all ops + to standard ONNX ops in the default opset domain. If unable to do so + (e.g. because support has not been added to convert a particular torch op to ONNX), + fall back to exporting the op into a custom opset domain without conversion. Applies + to `custom ops `_ + as well as ATen ops. For the exported model to be usable, the runtime must support + these non-standard ops. + * ``OperatorExportTypes.ONNX_ATEN``: All ATen ops (in the TorchScript namespace "aten") + are exported as ATen ops (in opset domain "org.pytorch.aten"). + `ATen `_ is PyTorch's built-in tensor library, so + this instructs the runtime to use PyTorch's implementation of these ops. + + .. warning:: + + Models exported this way are probably runnable only by Caffe2. + + This may be useful if the numeric differences in implementations of operators are + causing large differences in behavior between PyTorch and Caffe2 (which is more + common on untrained models). + + * ``OperatorExportTypes.ONNX_ATEN_FALLBACK``: Try to export each ATen op + (in the TorchScript namespace "aten") as a regular ONNX op. If we are unable to do so + (e.g. because support has not been added to convert a particular torch op to ONNX), + fall back to exporting an ATen op. See documentation on OperatorExportTypes.ONNX_ATEN for + context. + For example:: + + graph(%0 : Float): + %3 : int = prim::Constant[value=0]() + # conversion unsupported + %4 : Float = aten::triu(%0, %3) + # conversion supported + %5 : Float = aten::mul(%4, %0) + return (%5) + + Assuming ``aten::triu`` is not supported in ONNX, this will be exported as:: + + graph(%0 : Float): + %1 : Long() = onnx::Constant[value={0}]() + # not converted + %2 : Float = aten::ATen[operator="triu"](%0, %1) + # converted + %3 : Float = onnx::Mul(%2, %0) + return (%3) + + If PyTorch was built with Caffe2 (i.e. with ``BUILD_CAFFE2=1``), then + Caffe2-specific behavior will be enabled, including special support + for ops are produced by the modules described in + `Quantization `_. + + .. warning:: + + Models exported this way are probably runnable only by Caffe2. + + opset_version (int, default 17): The version of the + `default (ai.onnx) opset `_ + to target. Must be >= 7 and <= 17. + do_constant_folding (bool, default True): Apply the constant-folding optimization. + Constant-folding will replace some of the ops that have all constant inputs + with pre-computed constant nodes. + dynamic_axes (dict[string, dict[int, string]] or dict[string, list(int)], default empty dict): + + By default the exported model will have the shapes of all input and output tensors + set to exactly match those given in ``args``. To specify axes of tensors as + dynamic (i.e. known only at run-time), set ``dynamic_axes`` to a dict with schema: + + * KEY (str): an input or output name. Each name must also be provided in ``input_names`` or + ``output_names``. + * VALUE (dict or list): If a dict, keys are axis indices and values are axis names. If a + list, each element is an axis index. + + For example:: + + class SumModule(torch.nn.Module): + def forward(self, x): + return torch.sum(x, dim=1) + + torch.onnx.export( + SumModule(), + (torch.ones(2, 2),), + "onnx.pb", + input_names=["x"], + output_names=["sum"] + ) + + Produces:: + + input { + name: "x" + ... + shape { + dim { + dim_value: 2 # axis 0 + } + dim { + dim_value: 2 # axis 1 + ... + output { + name: "sum" + ... + shape { + dim { + dim_value: 2 # axis 0 + ... + + While:: + + torch.onnx.export( + SumModule(), + (torch.ones(2, 2),), + "onnx.pb", + input_names=["x"], + output_names=["sum"], + dynamic_axes={ + # dict value: manually named axes + "x": {0: "my_custom_axis_name"}, + # list value: automatic names + "sum": [0], + } + ) + + Produces:: + + input { + name: "x" + ... + shape { + dim { + dim_param: "my_custom_axis_name" # axis 0 + } + dim { + dim_value: 2 # axis 1 + ... + output { + name: "sum" + ... + shape { + dim { + dim_param: "sum_dynamic_axes_1" # axis 0 + ... + + keep_initializers_as_inputs (bool, default None): If True, all the + initializers (typically corresponding to parameters) in the + exported graph will also be added as inputs to the graph. If False, + then initializers are not added as inputs to the graph, and only + the non-parameter inputs are added as inputs. + This may allow for better optimizations (e.g. constant folding) by + backends/runtimes. + + If True, `deduplicate_initializers` pass will not be executed. This means + initializers with duplicated values will not be deduplicated and + will be treated as distinct inputs to the graph. This allows different + input initializers to be supplied at the runtime following export. + + If ``opset_version < 9``, initializers MUST be part of graph + inputs and this argument will be ignored and the behavior will be + equivalent to setting this argument to True. + + If None, then the behavior is chosen automatically as follows: + + * If ``operator_export_type=OperatorExportTypes.ONNX``, the behavior is equivalent + to setting this argument to False. + * Else, the behavior is equivalent to setting this argument to True. + + custom_opsets (dict[str, int], default empty dict): A dict with schema: + + * KEY (str): opset domain name + * VALUE (int): opset version + + If a custom opset is referenced by ``model`` but not mentioned in this dictionary, + the opset version is set to 1. Only custom opset domain name and version should be + indicated through this argument. + + export_modules_as_functions (bool or set of type of nn.Module, default False): Flag to enable + exporting all ``nn.Module`` forward calls as local functions in ONNX. Or a set to indicate the + particular types of modules to export as local functions in ONNX. + This feature requires ``opset_version`` >= 15, otherwise the export will fail. This is because + ``opset_version`` < 15 implies IR version < 8, which means no local function support. + Module variables will be exported as function attributes. There are two categories of function + attributes. + + 1. Annotated attributes: class variables that have type annotations via + `PEP 526-style `_ + will be exported as attributes. + Annotated attributes are not used inside the subgraph of ONNX local function because + they are not created by PyTorch JIT tracing, but they may be used by consumers + to determine whether or not to replace the function with a particular fused kernel. + + 2. Inferred attributes: variables that are used by operators inside the module. Attribute names + will have prefix "inferred::". This is to differentiate from predefined attributes retrieved from + python module annotations. Inferred attributes are used inside the subgraph of ONNX local function. + + * ``False`` (default): export ``nn.Module`` forward calls as fine grained nodes. + * ``True``: export all ``nn.Module`` forward calls as local function nodes. + * Set of type of nn.Module: export ``nn.Module`` forward calls as local function nodes, + only if the type of the ``nn.Module`` is found in the set. + + autograd_inlining (bool, default True): Flag used to control whether to inline autograd functions. + Refer to https://github.com/pytorch/pytorch/pull/74765 for more details. + + Raises: + :class:`torch.onnx.errors.CheckerError`: If the ONNX checker detects an invalid ONNX graph. + :class:`torch.onnx.errors.UnsupportedOperatorError`: If the ONNX graph cannot be exported because it + uses an operator that is not supported by the exporter. + :class:`torch.onnx.errors.OnnxExporterError`: Other errors that can occur during export. + All errors are subclasses of :class:`errors.OnnxExporterError`. + """ + + _export( + model, + args, + f, + export_params, + verbose, + training, + input_names, + output_names, + operator_export_type=operator_export_type, + opset_version=opset_version, + do_constant_folding=do_constant_folding, + dynamic_axes=dynamic_axes, + keep_initializers_as_inputs=keep_initializers_as_inputs, + custom_opsets=custom_opsets, + export_modules_as_functions=export_modules_as_functions, + autograd_inlining=autograd_inlining, + ) + + +@_beartype.beartype +def _is_constant_tensor_list(node): + if node.kind() != "prim::Constant": + return False + output_type = node.output().type() + if output_type.isSubtypeOf(_C.ListType.ofTensors()): + return True + if output_type.isSubtypeOf(_C.ListType(_C.OptionalType.ofTensor())): + return True + + +# ONNX can't handle constants that are lists of tensors, which can +# get generated in constant prop. So we split them back into prim::ListConstructs + + +@_beartype.beartype +def _split_tensor_list_constants(g, block): + for node in block.nodes(): + for subblock in node.blocks(): + _split_tensor_list_constants(g, subblock) + if _is_constant_tensor_list(node): + inputs = [] + for val in node.output().toIValue(): + input = g.insertConstant(val) + input.node().moveBefore(node) + input.node().copyMetadata(node) + inputs.append(input) + + lc = ( + g.create("prim::ListConstruct", inputs) + .insertBefore(node) + .output() + .setType(_C.ListType.ofTensors()) + ) + lc.node().copyMetadata(node) + node.output().replaceAllUsesWith(lc) + + +@_beartype.beartype +def _optimize_graph( + graph: _C.Graph, + operator_export_type: _C_onnx.OperatorExportTypes, + _disable_torch_constant_prop: bool = False, + fixed_batch_size: bool = False, + params_dict=None, + dynamic_axes=None, + input_names=None, + module=None, +): + if params_dict is None: + params_dict = {} + + # Inline everything + _C._jit_pass_inline(graph) + + # Remove fork/wait nodes + _C._jit_pass_inline_fork_wait(graph) + _C._jit_pass_lint(graph) + if GLOBALS.autograd_inlining: + _C._jit_pass_onnx_autograd_function_process(graph) + _C._jit_pass_lower_all_tuples(graph) + + # we now record some ops like ones/zeros + # into a trace where we previously recorded constants. + # use constant prop to maintain our current level of onnx support + # without implementing symbolics for all of them + if _disable_torch_constant_prop is False: + _C._jit_pass_constant_propagation(graph) + + _split_tensor_list_constants(graph, graph) + # run dce to eliminate dead parts of the graph that might have been + # left behind by things like symbolic_override + _C._jit_pass_dce(graph) + _C._jit_pass_lint(graph) + + # CSE should improve perf when Autocast is used with disabled cache + # Autocast is disabled due to a limitation on tracer as described at https://github.com/pytorch/pytorch/issues/84092 + # Must run before _C._jit_pass_erase_number_types to prevent type substitution + if _C._jit_pass_cse(graph): + _C._jit_pass_onnx_lint(graph) + + _C._jit_pass_canonicalize_graph_fuser_ops(graph) + _C._jit_pass_lint(graph) + _C._jit_pass_peephole(graph, True) + _C._jit_pass_fuse_addmm(graph) + _C._jit_pass_lint(graph) + + _C._jit_pass_peephole(graph, True) + _C._jit_pass_lower_all_tuples(graph) + # in _jit_pass_onnx, symbolic functions are called for each node for conversion. + # However, there are nodes that cannot be converted without additional context. + # For example, the number of outputs from split (and whether it is static or dynamic) is unknown + # until the point where it is unpacked by listUnpack node. + # This pass does a preprocess, and prepares the nodes such that enough context can be received + # by the symbolic function. + _C._jit_pass_onnx_remove_inplace_ops_for_onnx(graph, module) + _C._jit_pass_onnx_preprocess(graph) + + # onnx does not support tuples, so try to remove them + _C._jit_pass_lint(graph) + + # onnx only supports tensors, but 1 / 2 = 0.5 and tensor(1) / tensor(2) = 0 + _C._jit_pass_prepare_division_for_onnx(graph) + + _C._jit_pass_onnx_remove_print(graph) + _C._jit_pass_onnx_preprocess_caffe2(graph) + + symbolic_helper._quantized_ops.clear() + # Unpack quantized weights for conv and linear ops and insert into graph. + _C._jit_pass_onnx_unpack_quantized_weights( + graph, params_dict, symbolic_helper.is_caffe2_aten_fallback() + ) + if symbolic_helper.is_caffe2_aten_fallback(): + # Insert permutes before and after each conv op to ensure correct order. + _C._jit_pass_onnx_quantization_insert_permutes(graph, params_dict) + + # Find consecutive permutes that are no-ops and remove them. + _C._jit_pass_custom_pattern_based_rewrite_graph( + textwrap.dedent( + """\ + graph(%Pi): + %Pq = quantized::nhwc2nchw(%Pi) + %Pr = quantized::nchw2nhwc(%Pq) + return (%Pr)""" + ), + textwrap.dedent( + """\ + graph(%Ri): + return (%Ri)""" + ), + graph, + ) + + # onnx only supports tensors, so we turn all out number types into tensors + _C._jit_pass_erase_number_types(graph) + if GLOBALS.onnx_shape_inference: + input_names = [] if input_names is None else input_names + dynamic_axes = {} if dynamic_axes is None else dynamic_axes + _C._jit_pass_onnx_set_dynamic_input_shape(graph, dynamic_axes, input_names) + _C._jit_pass_onnx_lint(graph) + + graph = _C._jit_pass_onnx(graph, operator_export_type) + _C._jit_pass_onnx_lint(graph) + _C._jit_pass_lint(graph) + + _C._jit_pass_onnx_scalar_type_analysis( + graph, True, GLOBALS.export_onnx_opset_version + ) + _C._jit_pass_lint(graph) + + _C._jit_pass_onnx_peephole( + graph, GLOBALS.export_onnx_opset_version, fixed_batch_size + ) + _C._jit_pass_lint(graph) + + # graph is not a valid jit graph anymore because types have been replaced + # (e.g. int with Tensor), so it now contains operators that don't actually + # exist. We can't run normal dead code elimination because it'd fail trying + # to look up if an operator has side effects, but we can run a dead code + # elimination variant that doesn't need to look up if an op has side effects. + _C._jit_pass_dce_allow_deleting_nodes_with_side_effects(graph) + _C._jit_pass_lint(graph) + graph = _C._jit_pass_canonicalize(graph) + _C._jit_pass_lint(graph) + if GLOBALS.onnx_shape_inference: + try: + _C._jit_pass_onnx_graph_shape_type_inference( + graph, params_dict, GLOBALS.export_onnx_opset_version + ) + except RuntimeError as exc: + if ( + _C_onnx._CAFFE2_ATEN_FALLBACK + and exc.args[0] + == "ScalarType UNKNOWN_SCALAR is an unexpected tensor scalar type!" + ): + # Caffe2 builds can have UNKNOWN_SCALAR for some tensors + pass + + return graph + + +@_beartype.beartype +def warn_on_static_input_change(input_states): + """Warns that changes to input dictionaries and strings won't take effect in the traced ONNX graph. + + We accept dictionaries and strings as ONNX inputs, but they should be only for + configuration use. we detect here if these inputs are modified, and if so we warn + the user that the changes won't take effect in the traced ONNX graph. + """ + for input, traced_input in zip(input_states[0], input_states[1]): + if isinstance(input, dict): + if list(input.keys()) != list(traced_input.keys()): + warning = ( + "We detected that you are modifying a dictionary that is an input to your " + "model. " + "Note that dictionaries are allowed as inputs in ONNX but they should be " + "handled with care. " + "Usages of dictionaries is not recommended, and should not be used except " + "for configuration use. " + "Also note that the order and values of the keys must remain the same. " + ) + warnings.warn(warning) + elif isinstance(input, str): + if input != traced_input: + warning = ( + "The model seems to have string inputs/outputs. " + "Note that strings will not appear as inputs/outputs of the ONNX graph. " + ) + warnings.warn(warning) + + +@_beartype.beartype +def _resolve_args_by_export_type(arg_name, arg_value, operator_export_type): + """Resolves the arguments that are ignored when export_type != operator_export_type.ONNX.""" + if ( + operator_export_type is not operator_export_type.ONNX + and _C_onnx._CAFFE2_ATEN_FALLBACK + ): + if arg_value is True: + warnings.warn( + f"'{arg_name}' can be set to True only when 'operator_export_type' is " + "`ONNX`. Since 'operator_export_type' is not set to 'ONNX', " + f"'{arg_name}' argument will be ignored." + ) + arg_value = False + return arg_value + + +@_beartype.beartype +def _decide_keep_init_as_input( + keep_initializers_as_inputs: Optional[bool], + operator_export_type: _C_onnx.OperatorExportTypes, + opset_version: int, +): + """Decides whether the initializers in the graph should be listed as ONNX graph inputs. + + This method encapsulates the logic to decide whether the initializers in the graph + should be listed as ONNX graph inputs (i.e., whether to choose ONNX IR v3 or v4). + If keep_initializers_as_inputs is not specified (None), then we decide whether to keep + initializers as graph inputs (val_keep_init_as_ip) based on export type. If export type + is ONNX, then do not keep initializers as input (val_keep_init_as_ip=False). For all other + export types keep initializers as input (val_keep_init_as_ip=True). + If keep_initializers_as_inputs is specified, then respect it. Unless opset version <= 8, + in which case it must be ignored because for opset version <= 8, all initializers MUST be + part of graph input (only ONNX IR v3 is allowed), i.e. val_keep_init_as_ip=True. + + Special handling is needed for opset version 8 or lower, because irrespective + of user input for keep_initializers_as_inputs, the graph must follow ONNX IR v3 + semantics, i.e. all initializers must be listed as ONNX graph input. + """ + + if opset_version < 9: + if keep_initializers_as_inputs is False: + warnings.warn( + "Setting 'keep_initializers_as_inputs=False' for opset version" + "8 or lower would lead to an invalid ONNX graph. Therefore, " + "'keep_initializers_as_inputs=False' is ignored during export." + "Exported model will have initializers as graph inputs (compliant " + " to ONNX IR v3)." + ) + return True # i.e. True == initializers are part of graph input (ONNX IR v3) + val_keep_init_as_ip = ( + True if keep_initializers_as_inputs is None else keep_initializers_as_inputs + ) + if ( + keep_initializers_as_inputs is None + and operator_export_type is _C_onnx.OperatorExportTypes.ONNX + ): + val_keep_init_as_ip = False + return val_keep_init_as_ip + + +@_beartype.beartype +def _decide_add_node_names(add_node_names, operator_export_type): + return _resolve_args_by_export_type( + "add_node_names", add_node_names, operator_export_type + ) + + +@_beartype.beartype +def _decide_constant_folding(do_constant_folding, operator_export_type, training): + do_constant_folding = _resolve_args_by_export_type( + "do_constant_folding", do_constant_folding, operator_export_type + ) + if do_constant_folding and ( + training is not None and training is not _C_onnx.TrainingMode.EVAL + ): + warnings.warn( + "It is recommended that constant folding be turned off ('do_constant_folding=False') " + "when exporting the model in training-amenable mode, i.e. with 'training=TrainingMode.TRAIN' " + "or 'training=TrainingMode.PRESERVE' (when model is in training mode). Otherwise, some " + "learnable model parameters may not translate correctly in the exported ONNX model " + "because constant folding mutates model parameters. Please consider " + "turning off constant folding or setting the training=TrainingMode.EVAL." + ) + return do_constant_folding + + +@_beartype.beartype +def _signature(model) -> inspect.Signature: + should_be_callable = getattr(model, "forward", model) + if callable(should_be_callable): + return inspect.signature(should_be_callable) + raise ValueError("model has no forward method and is not callable") + + +@_beartype.beartype +def _decide_input_format(model, args): + try: + sig = _signature(model) + except ValueError as e: + warnings.warn(f"{e}, skipping _decide_input_format") + return args + try: + ordered_list_keys = list(sig.parameters.keys()) + if ordered_list_keys[0] == "self": + ordered_list_keys = ordered_list_keys[1:] + args_dict: Dict = {} + if isinstance(args, list): + args_list = args + elif isinstance(args, tuple): + args_list = list(args) + else: + args_list = [args] + if isinstance(args_list[-1], dict): + args_dict = args_list[-1] + args_list = args_list[:-1] + n_nonkeyword = len(args_list) + for optional_arg in ordered_list_keys[n_nonkeyword:]: + if optional_arg in args_dict: + args_list.append(args_dict[optional_arg]) + # Check if this arg has a default value + else: + param = sig.parameters[optional_arg] + if param.default != param.empty: + args_list.append(param.default) + args = args_list if isinstance(args, list) else tuple(args_list) + # Cases of models with no input args + except IndexError: + warnings.warn("No input args, skipping _decide_input_format") + except Exception as e: + warnings.warn(f"Skipping _decide_input_format\n {e.args[0]}") + + return args + + +@_beartype.beartype +def _trace(func, args, operator_export_type, return_outs=False): + # Special case for common case of passing a single Tensor + if isinstance(args, torch.Tensor): + args = (args,) + + trace_graph, torch_out, inputs_states = torch.jit._get_trace_graph( + func, + args, + strict=False, + _force_outplace=False, + _return_inputs_states=True, + ) + warn_on_static_input_change(inputs_states) + + trace_graph = _optimize_graph(trace_graph, operator_export_type, params_dict={}) + if return_outs: + return trace_graph, torch_out + return trace_graph + + +@_beartype.beartype +def _trace_and_get_graph_from_model(model, args): + # A basic sanity check: make sure the state_dict keys are the same + # before and after running the model. Fail fast! + orig_state_dict_keys = torch.jit._unique_state_dict(model).keys() + + # Disable Autocast cache because it replaces kernel's weight and bias + # by (undesired) constants. + # No perf impact for when there are reused weights since https://github.com/pytorch/pytorch/pull/85665 + prev_autocast_cache_enabled = torch.is_autocast_cache_enabled() + torch.set_autocast_cache_enabled(False) + trace_graph, torch_out, inputs_states = torch.jit._get_trace_graph( + model, + args, + strict=False, + _force_outplace=False, + _return_inputs_states=True, + ) + torch.set_autocast_cache_enabled(prev_autocast_cache_enabled) + + warn_on_static_input_change(inputs_states) + + if orig_state_dict_keys != torch.jit._unique_state_dict(model).keys(): + raise RuntimeError( + "state_dict changed after running the tracer; " + "something weird is happening in your model!" + ) + + return trace_graph, torch_out + + +@_beartype.beartype +def _get_param_count_list(method_graph, args_params): + param_count_list = [] + for input_, arg_params_ in zip(method_graph.inputs(), args_params): + if "PackedParams" in str(input_.type()): + in_vars, _ = torch.jit._flatten(arg_params_) + param_count_list.append(len(in_vars)) + else: + param_count_list.append(arg_params_ is not None) + + return param_count_list + + +@_beartype.beartype +def _check_flatten_did_not_remove(original, jit_flattened): + """torch.jit._flatten removes None. Check if it did so in this case.""" + + @_beartype.beartype + def flatten(x): + if isinstance(x, (list, tuple)): + for inner in x: + yield from flatten(inner) + elif isinstance(x, dict): + for inner in x.values(): + yield from flatten(inner) + else: + yield x + + flattened_with_none = list(flatten(original)) + num_none = len(flattened_with_none) - len(jit_flattened) + assert num_none >= 0 + if num_none: + raise ValueError( + f"args contained {num_none} None's after flattening. " + "When exporting a ScriptModule or ScriptFunction, no args may " + "be None because that breaks type propagation." + ) + + +def _create_jit_graph( + model: Union[torch.nn.Module, torch.jit.ScriptFunction], args: Sequence[Any] +) -> Tuple[_C.Graph, List[_C.IValue], Optional[Any], Optional[_C.ScriptModule]]: + if isinstance(model, (torch.jit.ScriptFunction, torch.jit.ScriptModule)): + flattened_args = tuple(torch.jit._flatten(tuple(args))[0]) + _check_flatten_did_not_remove(args, flattened_args) + torch_out = None + + if isinstance(model, torch.jit.ScriptModule): + try: + graph = model.forward.graph # type: ignore[attr-defined] + except AttributeError as e: + raise RuntimeError("'forward' method must be a script method") from e + _C._jit_pass_onnx_function_substitution(graph) + freezed_module = _C._freeze_module( + cast(_C.ScriptModule, model._c), preserveParameters=True + ) + module, params = _C._jit_onnx_list_model_parameters(freezed_module) + method_graph = module._get_method("forward").graph + args_params = tuple(args) + tuple(params) + param_count_list = _get_param_count_list(method_graph, args_params) + in_vars, _ = torch.jit._flatten(args_params) + graph = _C._propagate_and_assign_input_shapes( + method_graph, tuple(in_vars), param_count_list, False, False + ) + return graph, params, torch_out, module + + # torch.jit.ScriptFunction + params = [] + graph = model.graph + _C._jit_pass_onnx_function_substitution(graph) + param_count_list = _get_param_count_list(graph, args) + graph = _C._propagate_and_assign_input_shapes( + graph, flattened_args, param_count_list, False, False + ) + return graph, params, torch_out, None + + graph, torch_out = _trace_and_get_graph_from_model(model, args) + _C._jit_pass_onnx_lint(graph) + state_dict = torch.jit._unique_state_dict(model) + params = list(state_dict.values()) + graph_inputs = list(graph.inputs()) + user_input_num = len(graph_inputs) - len(state_dict) + param_names = list(state_dict.keys()) + for i, inp in enumerate(graph_inputs): + if i >= user_input_num: + inp.setDebugName(param_names[i - user_input_num]) + _C._jit_pass_onnx_function_substitution(graph) + return graph, params, torch_out, None + + +@_beartype.beartype +def _get_named_param_dict(graph, params): + input_and_param_names = [val.debugName() for val in graph.inputs()] + param_names = input_and_param_names[len(input_and_param_names) - len(params) :] + _params_dict = dict(zip(param_names, params)) + return _params_dict + + +@_beartype.beartype +def _get_example_outputs(model, args): + input_args = copy.deepcopy(args) + input_kwargs = {} + if input_args and isinstance(input_args[-1], dict): + input_kwargs = input_args[-1] + input_args = input_args[:-1] + + example_outputs = model(*input_args, **input_kwargs) + if isinstance(example_outputs, list): + example_outputs = [example_outputs] + elif not isinstance(example_outputs, tuple): + example_outputs = (example_outputs,) + + return example_outputs + + +_qtype_vtype_map = { + torch.quint8: torch.uint8, + torch.qint8: torch.int8, + torch.qint32: torch.int32, + torch.quint4x2: torch.int8, +} + + +@_beartype.beartype +def unpack_quantized_tensor(value, cast_onnx_accepted=True): + if isinstance(value, torch.Tensor) and value.dtype in _qtype_vtype_map: + q_value_dequantize = value.dequantize() + q_scale = ( + torch.tensor(value.q_scale(), dtype=torch.double) + if cast_onnx_accepted + else torch.tensor(value.q_scale(), dtype=torch.float32) + ) + q_zero_point = ( + torch.tensor(value.q_zero_point(), dtype=torch.int64) + if cast_onnx_accepted + else torch.tensor(value.q_zero_point(), dtype=_qtype_vtype_map[value.dtype]) + ) + q_value = q_value_dequantize / q_scale + q_zero_point + q_value = q_value.to(dtype=_qtype_vtype_map[value.dtype]) + return q_value, q_scale, q_zero_point + else: + return (value,) + + +@_beartype.beartype +def _pre_trace_quant_model(model, args): + r"""Returns `torch.jit.trace(model, args)` if model is quantized. Otherwise do nothing and return + original model. + + This is due to https://github.com/pytorch/pytorch/issues/75761. + """ + if any( + hasattr(m, "_packed_params") for m in getattr(model, "modules", list)() + ) or any(getattr(arg, "is_quantized", False) for arg in args): + return torch.jit.trace(model, args) + return model + + +@_beartype.beartype +def _model_to_graph( + model, + args, + verbose=False, + input_names=None, + output_names=None, + operator_export_type=_C_onnx.OperatorExportTypes.ONNX, + do_constant_folding=True, + _disable_torch_constant_prop=False, + fixed_batch_size=False, + training=_C_onnx.TrainingMode.EVAL, + dynamic_axes=None, +) -> Tuple[ + _C.Graph, + Dict[str, torch.Tensor], + Optional[ + Union[ + torch.Tensor, + Tuple[torch.Tensor, ...], + List[torch.Tensor], + Dict[str, torch.Tensor], + Any, # Can be nested tuples etc. + ] + ], +]: + """Converts model into an ONNX graph. + + Returns: + graph: A TorchScript IR Graph with ONNX nodes. + params_dict: Dict from input param name to param value. + torch_out: The output tensors resulting from the trace of ``model``. + If ``model`` is a :class:`torch.jit.ScriptModule` or :class:`torch.jit.ScriptFunction`, + this will be None, since we are not doing any tracing. + """ + # TODO: can we simplify this to always return a tuple of Tensor or None? + + # Special case for common case of passing a single Tensor + if isinstance(args, (torch.Tensor, int, float, bool)): + args = (args,) + + model = _pre_trace_quant_model(model, args) + graph, params, torch_out, module = _create_jit_graph(model, args) + params_dict = _get_named_param_dict(graph, params) + + try: + graph = _optimize_graph( + graph, + operator_export_type, + _disable_torch_constant_prop=_disable_torch_constant_prop, + fixed_batch_size=fixed_batch_size, + params_dict=params_dict, + dynamic_axes=dynamic_axes, + input_names=input_names, + module=module, + ) + except Exception as e: + torch.onnx.log("Torch IR graph at exception: ", graph) + raise + + is_script = isinstance(model, (torch.jit.ScriptFunction, torch.jit.ScriptModule)) + if is_script: + example_outputs = _get_example_outputs(model, args) + example_outputs_final = () + for example_output in example_outputs: + example_outputs_final += unpack_quantized_tensor(example_output) + out_vars, desc = torch.jit._flatten(example_outputs_final) + _C._jit_pass_onnx_assign_output_shape( + graph, + out_vars, + desc, + GLOBALS.onnx_shape_inference, + is_script, + GLOBALS.export_onnx_opset_version, + ) + + # NB: ONNX requires complete information about output types, which might be + # erased by some optimizations, so we need to set it explicitly again. + else: + if not isinstance(torch_out, (list, tuple)): + output_wrapped = [torch_out] + else: + output_wrapped = torch_out # type: ignore[assignment] + + output_tensors, out_desc = torch.jit._flatten(tuple(output_wrapped)) + # assign_output_shape pass is not compatible with quantized outputs. + # Quantized outputs are flattened to 3 values in ONNX, while packed as + # single value in PyTorch. + if not any(getattr(out, "is_quantized", False) for out in output_tensors): + _C._jit_pass_onnx_assign_output_shape( + graph, + output_tensors, + out_desc, + GLOBALS.onnx_shape_inference, + is_script, + GLOBALS.export_onnx_opset_version, + ) + + _set_input_and_output_names(graph, input_names, output_names) + params_dict = _get_named_param_dict(graph, params) + + if ( + do_constant_folding + and GLOBALS.export_onnx_opset_version + >= _constants.ONNX_CONSTANT_FOLDING_MIN_OPSET + ): + if training is None or training == _C_onnx.TrainingMode.EVAL: + params_dict = _C._jit_pass_onnx_eval_peephole(graph, params_dict) + + params_dict = _C._jit_pass_onnx_constant_fold( + graph, params_dict, GLOBALS.export_onnx_opset_version + ) + _C._jit_pass_dce_allow_deleting_nodes_with_side_effects(graph) + + if GLOBALS.onnx_shape_inference: + try: + _C._jit_pass_onnx_graph_shape_type_inference( + graph, params_dict, GLOBALS.export_onnx_opset_version + ) + except RuntimeError as exc: + if ( + _C_onnx._CAFFE2_ATEN_FALLBACK + and exc.args[0] + == "ScalarType UNKNOWN_SCALAR is an unexpected tensor scalar type!" + ): + # Caffe2 builds can have UNKNOWN_SCALAR for some tensors + pass + + params_dict = _C._jit_pass_onnx_eliminate_unused_items(graph, params_dict) + + # For ONNX opset < 9, constants only have three data types: float16, float, double. + # In this pass transform constants of other data types to float/double + cast operator. + if GLOBALS.export_onnx_opset_version < 9: + _C._jit_pass_onnx_cast_all_constant_to_floating(graph) + + params_dict = _C._jit_pass_filter_non_tensor_arguments(params_dict) + _C._jit_decay_packed_param_input_types(graph) + + # If output names lack a proper name and are identified only by their unique + # give them a legible name for debugging purposes + _apply_friendly_debug_names(graph, params_dict) + + return graph, params_dict, torch_out + + +@_beartype.beartype +@torch._disable_dynamo +def export_to_pretty_string( + model, + args, + export_params=True, + verbose=False, + training=_C_onnx.TrainingMode.EVAL, + input_names=None, + output_names=None, + operator_export_type=_C_onnx.OperatorExportTypes.ONNX, + export_type=None, + google_printer=False, + opset_version=None, + keep_initializers_as_inputs=None, + custom_opsets=None, + add_node_names=True, + do_constant_folding=True, + dynamic_axes=None, +): + r""" + Similar to :func:`export`, but returns a text representation of the ONNX + model. Only differences in args listed below. All other args are the same + as :func:`export`. + + Args: + add_node_names (bool, default True): Whether or not to set + NodeProto.name. This makes no difference unless + ``google_printer=True``. + google_printer (bool, default False): If False, will return a custom, + compact representation of the model. If True will return the + protobuf's `Message::DebugString()`, which is more verbose. + + Returns: + A UTF-8 str containing a human-readable representation of the ONNX model. + """ + if opset_version is None: + opset_version = _constants.ONNX_DEFAULT_OPSET + if custom_opsets is None: + custom_opsets = {} + GLOBALS.export_onnx_opset_version = opset_version + GLOBALS.operator_export_type = operator_export_type + + with exporter_context(model, training, verbose): + val_keep_init_as_ip = _decide_keep_init_as_input( + keep_initializers_as_inputs, operator_export_type, opset_version + ) + val_add_node_names = _decide_add_node_names( + add_node_names, operator_export_type + ) + val_do_constant_folding = _decide_constant_folding( + do_constant_folding, operator_export_type, training + ) + args = _decide_input_format(model, args) + graph, params_dict, torch_out = _model_to_graph( + model, + args, + verbose, + input_names, + output_names, + operator_export_type, + val_do_constant_folding, + training=training, + dynamic_axes=dynamic_axes, + ) + + return graph._pretty_print_onnx( # type: ignore[attr-defined] + params_dict, + opset_version, + False, + operator_export_type, + google_printer, + val_keep_init_as_ip, + custom_opsets, + val_add_node_names, + ) + + +@_beartype.beartype +def unconvertible_ops( + model, + args, + training: _C_onnx.TrainingMode = _C_onnx.TrainingMode.EVAL, + opset_version: Optional[int] = None, +) -> Tuple[_C.Graph, List[str]]: + """Returns an approximated list of all ops that are yet supported by :mod:`torch.onnx`. + + The list is approximated because some ops may be removed during the conversion + process and don't need to be converted. Some other ops may have partial support + that will fail conversion with particular inputs. Please open a Github Issue + for op support requests. + + Args: + model: Same as the `model` parameter in :func:`torch.onnx.export`. + args: Same as the `args` parameter in :func:`torch.onnx.export`. + training: Same as the `training` parameter in :func:`torch.onnx.export`. + opset_version: Same as the `opset_version` parameter in :func:`torch.onnx.export`. + + Returns: + The JIT graph and a list of unconvertible ops in the format of "domain::op". + """ + + opset_version = opset_version or _constants.ONNX_DEFAULT_OPSET + GLOBALS.export_onnx_opset_version = opset_version + + try: + with exporter_context(model, training, verbose=False): + # Create a mostly clean JIT graph that contains the plain aten and + # other ops we can check with the symbolic registry. + # NOTE: We don't want to actually convert any ops to ONNX or run any + # symbolic functions because there is a higher chance that a pass + # fails or an unconvertible op messes up the graph during ONNX conversion. + # This way we can always generate a list just by looking at the names + # of the ops in the graph. + args = _decide_input_format(model, args) + model = _pre_trace_quant_model(model, args) + graph, _, _, module = _create_jit_graph(model, args) + _C._jit_pass_inline(graph) + _C._jit_pass_onnx_remove_inplace_ops_for_onnx(graph, module) + _C._jit_pass_erase_number_types(graph) + _C._jit_pass_dce_allow_deleting_nodes_with_side_effects(graph) + except Exception as e: + raise errors.OnnxExporterError( + "Failed to discover unconvertible ops because of errors during the JIT graph " + "generation process." + ) from e + + unsupported_ops = [] + for node in graph.nodes(): + domain_op = node.kind() + if domain_op.startswith(("onnx::", "prim::")): + # We consider onnx and prim ops as supported ops, even though some "prim" + # ops are not implemented as symbolic functions, because they may be + # eliminated in the conversion passes. Users may still see errors caused + # by prim ops even though they don't show up in the list. + continue + if not registration.registry.is_registered_op( + domain_op.rstrip("_"), opset_version + ): + # We consider all registered ops supported, even though some of them are + # only partially supported, because there is not yet a good way to check + # if an op is fully supported. + # TODO(justinchuby): Create a way to check if an op is fully supported. + unsupported_ops.append(domain_op) + return graph, unsupported_ops + + +@_beartype.beartype +def _setup_trace_module_map( + model: Union[torch.nn.Module, torch.jit.ScriptModule], + export_modules_as_functions: Union[bool, Collection[Type[torch.nn.Module]]], +) -> Set[str]: + def __register_attribute_hook(): + attr_name = "_onnx_attrs" + + def _track_module_attributes_forward_pre_hook(module, input): + setattr(module, attr_name, _get_module_attributes(module)) + + def _track_module_attributes_forward_hook(module, input, output): + tracing_state = _C._get_tracing_state() + if not tracing_state: + return + + graph = tracing_state.graph() + onnx_attrs = {} + if hasattr(module, attr_name): + onnx_attrs = getattr(module, attr_name) + delattr(module, attr_name) + + _C._jit_pass_onnx_track_scope_attributes(graph, onnx_attrs) + + for m in model.modules(): + m.register_forward_hook(_track_module_attributes_forward_hook) + m.register_forward_pre_hook(_track_module_attributes_forward_pre_hook) + + def _unqualified_variable_name(qualified_name: str) -> str: + """ + Parse qualified variable name and return the unqualified version. + + Pure numeric atoms are considered inadequate, so this function will look past them, + and start from the first non-numeric atom. + + Example: + >>> _unqualified_variable_name('__main__.Foo.bar') + 'bar' + >>> _unqualified_variable_name('__main__.Foo.bar.0') + 'bar.0' + """ + name_atoms = qualified_name.split(".") + for i, atom in reversed(list(enumerate(name_atoms))): + if not atom.isnumeric(): + return ".".join(name_atoms[i:]) + return qualified_name + + trace_module_map = { + _m: torch._C._jit_onnx_create_full_scope_name( + torch.typename(type(_m)), _unqualified_variable_name(_n) + ) + for _n, _m in model.named_modules() + } + torch.jit._trace._trace_module_map = trace_module_map + if isinstance(export_modules_as_functions, bool) and export_modules_as_functions: + module_typenames = {torch.typename(type(module)) for module in trace_module_map} + elif isinstance(export_modules_as_functions, set) and export_modules_as_functions: + + def _find_typename(v): + if isinstance(v, type): + return torch.typename(v) + else: + raise RuntimeError( + "Only type of the `nn.Module` should be " + "passed in the set for argument `export_modules_as_functions`. " + "Got `%s`." % (type(v).__name__) + ) + + module_typenames = {_find_typename(v) for v in export_modules_as_functions} + else: + module_typenames = set() + + if module_typenames: + __register_attribute_hook() + + return module_typenames + + +@_beartype.beartype +def _reset_trace_module_map(): + torch.jit._trace._trace_module_map = None + _C._jit_pass_onnx_clear_scope_records() + + +@_beartype.beartype +def _get_module_attributes(module): + annotations = typing.get_type_hints(type(module)) + base_m_annotations = typing.get_type_hints(torch.nn.Module) + [annotations.pop(k, None) for k in base_m_annotations] + # Check whether module attributes can be accessed. Some classes + # define attributes but don't provide access to them in their + # constructor. + # + # For example, torch.nn.Embedding has the `freeze` variable and its + # type specified in the class but the attribute is not created in the + # constructor. In other words, there is no `self.freeze = ` + # in the constructor. + # + # Reference: https://github.com/pytorch/pytorch/blob/92de1d322223fb5584e384971b32c46b93bc2f4b/torch/nn/modules/sparse.py#L120 + attrs = {} + for k in annotations: + try: + attrs[k] = getattr(module, k) + except AttributeError: + torch.onnx.log(f"Skipping module attribute '{k}'") + continue + return attrs + + +@_beartype.beartype +def _export( + model, + args, + f, + export_params=True, + verbose=False, + training=_C_onnx.TrainingMode.EVAL, + input_names=None, + output_names=None, + operator_export_type=_C_onnx.OperatorExportTypes.ONNX, + export_type=None, + opset_version=None, + do_constant_folding=True, + dynamic_axes=None, + keep_initializers_as_inputs=None, + fixed_batch_size=False, + custom_opsets=None, + add_node_names=True, + onnx_shape_inference=True, + export_modules_as_functions=False, + autograd_inlining=True, +): + assert GLOBALS.in_onnx_export is False + + if export_type is None: + export_type = _exporter_states.ExportTypes.PROTOBUF_FILE + + # Discussed deprecation with Nikita Shulga and Sergii Dymchenko from Meta + if _C_onnx._CAFFE2_ATEN_FALLBACK: + warnings.warn( + "Caffe2 ONNX exporter is deprecated in version 2.0 and will be " + "removed in 2.2. Please use PyTorch 2.1 or older for this capability.", + category=FutureWarning, + stacklevel=2, + ) + + if isinstance(model, torch.nn.DataParallel): + raise ValueError( + "torch.nn.DataParallel is not supported by ONNX " + "exporter, please use 'attribute' module to " + "unwrap model from torch.nn.DataParallel. Try " + "torch.onnx.export(model.module, ...)" + ) + + GLOBALS.onnx_shape_inference = onnx_shape_inference + + if opset_version is None: + opset_version = _constants.ONNX_DEFAULT_OPSET + + # torch.onnx.export does not support opset versions >=18 + if opset_version > _constants.ONNX_TORCHSCRIPT_EXPORTER_MAX_OPSET: + # We do not want to fail because we should still allow users to create + # custom symbolic functions for opset>17 + warnings.warn( + f"Exporting to ONNX opset version {opset_version} is not supported. " + f"by 'torch.onnx.export()'. " + f"The highest opset version supported is {_constants.ONNX_TORCHSCRIPT_EXPORTER_MAX_OPSET}. " + f"To use a newer opset version, consider 'torch.onnx.dynamo_export()'. " + f"Note that dynamo_export() is in preview. Please report errors with " + f"dynamo_export() as Github issues to https://github.com/pytorch/pytorch/issues.", + category=errors.OnnxExporterWarning, + ) + + if export_modules_as_functions and opset_version < 15: + raise ValueError( + "`export_modules_as_functions` is not supported for `opset_version` < 15." + "This is because `opset_version` < 15 implies IR version < 8, which means " + "no local function support. " + ) + if not operator_export_type: + if _C_onnx._CAFFE2_ATEN_FALLBACK: + operator_export_type = _C_onnx.OperatorExportTypes.ONNX_ATEN_FALLBACK + else: + operator_export_type = _C_onnx.OperatorExportTypes.ONNX + + # By default, training=TrainingMode.EVAL, + # which is good because running a model in training mode could result in + # internal buffers getting updated, dropout getting applied, etc. + # If you really know what you're doing, you can turn + # training=TrainingMode.TRAINING or training=TrainingMode.PRESERVE, + # (to preserve whatever the original training mode was.) + GLOBALS.export_onnx_opset_version = opset_version + GLOBALS.operator_export_type = operator_export_type + + try: + GLOBALS.in_onnx_export = True + _autograd_inlining_previous = GLOBALS.autograd_inlining + GLOBALS.autograd_inlining = autograd_inlining + + module_typenames_to_export_as_functions: Set[str] = set() + if isinstance(model, (torch.nn.Module, torch.jit.ScriptModule)): + module_typenames_to_export_as_functions = _setup_trace_module_map( + model, export_modules_as_functions + ) + + with exporter_context(model, training, verbose): + val_keep_init_as_ip = _decide_keep_init_as_input( + keep_initializers_as_inputs, + operator_export_type, + opset_version, + ) + val_add_node_names = _decide_add_node_names( + add_node_names, operator_export_type + ) + val_do_constant_folding = _decide_constant_folding( + do_constant_folding, operator_export_type, training + ) + # Normally f can be a file-like object, but for large models, the external data format requires a + # valid `model_file_location`. Code in export.cpp will enforce this. + if isinstance(f, str): + model_file_location = f + else: + model_file_location = "" + args = _decide_input_format(model, args) + if dynamic_axes is None: + dynamic_axes = {} + _validate_dynamic_axes(dynamic_axes, model, input_names, output_names) + + graph, params_dict, torch_out = _model_to_graph( + model, + args, + verbose, + input_names, + output_names, + operator_export_type, + val_do_constant_folding, + fixed_batch_size=fixed_batch_size, + training=training, + dynamic_axes=dynamic_axes, + ) + + # TODO: Don't allocate a in-memory string for the protobuf + defer_weight_export = ( + export_type is not _exporter_states.ExportTypes.PROTOBUF_FILE + ) + if custom_opsets is None: + custom_opsets = {} + + _C._jit_pass_dce_allow_deleting_nodes_with_side_effects(graph) + node_attr_to_name = {} # type: ignore[var-annotated] + if module_typenames_to_export_as_functions: + # NOTE: cannot call DCE after this pass. DCE will remove function definition nodes. + node_attr_to_name = _C._jit_pass_onnx_function_extraction( + graph, + module_typenames_to_export_as_functions, + list(params_dict.keys()), + ) + + if keep_initializers_as_inputs is not True: + params_dict = _C._jit_pass_onnx_deduplicate_initializers( # type: ignore[assignment] + graph, params_dict, getattr(model, "training", False) # type: ignore[arg-type] + ) + _C._jit_pass_onnx_assign_scoped_names_for_node_and_value(graph) + if export_params: + ( + proto, + export_map, + val_use_external_data_format, + node_names, + ) = graph._export_onnx( # type: ignore[attr-defined] + params_dict, + opset_version, + dynamic_axes, + defer_weight_export, + operator_export_type, + not verbose, + val_keep_init_as_ip, + custom_opsets, + val_add_node_names, + model_file_location, + node_attr_to_name, + ) + else: + ( + proto, + export_map, + val_use_external_data_format, + node_names, + ) = graph._export_onnx( # type: ignore[attr-defined] + {}, + opset_version, + dynamic_axes, + False, + operator_export_type, + not verbose, + val_keep_init_as_ip, + custom_opsets, + val_add_node_names, + model_file_location, + node_attr_to_name, + ) + # insert function_proto into model_proto. + proto = onnx_proto_utils._add_onnxscript_fn( + proto, + custom_opsets, + ) + if verbose: + torch.onnx.log("Exported graph: ", graph) + onnx_proto_utils._export_file(proto, f, export_type, export_map) + # The ONNX checker only works for ONNX graph. So if the operator_export_type is not ONNX, + # we can skip this check. + # If large model format export is enabled, proto will only contain data location instead of + # raw data and _check_onnx_proto() will fail because it can only handle the raw ONNX proto + # string in memory. + if (operator_export_type is _C_onnx.OperatorExportTypes.ONNX) and ( + not val_use_external_data_format + ): + try: + _C._check_onnx_proto(proto) + except RuntimeError as e: + raise errors.CheckerError(e) from e + finally: + assert GLOBALS.in_onnx_export + GLOBALS.in_onnx_export = False + GLOBALS.autograd_inlining = _autograd_inlining_previous + _reset_trace_module_map() + + return torch_out + + +@_beartype.beartype +def _apply_friendly_debug_names(graph, params): + for n in graph.nodes(): + for v in n.inputs(): + old_name = v.debugName() + if old_name != str(v.unique()): + continue + new_name = f"{n.kind()}_{v.unique()}" + v.setDebugName(new_name) + if old_name in params: + params[new_name] = params.pop(old_name) + + +@_beartype.beartype +def _set_input_and_output_names(graph, input_names, output_names): + @_beartype.beartype + def set_names(node_list, name_list, descriptor): + if name_list is None: + return + if len(name_list) > len(node_list): + raise RuntimeError( + "number of %s names provided (%d) exceeded number of %ss (%d)" + % (descriptor, len(name_list), descriptor, len(node_list)) + ) + + # Mark if the output node DebugName is set before. + output_node_set = set() + for i, (name, node) in enumerate(zip(name_list, node_list)): + # Duplicated output node, insert onnx::Identity to avoid setting the same DebugName after setDebugName(). + if descriptor == "output": + if node in output_node_set: + identity_node = graph.create("onnx::Identity") + identity_node.insertAfter(node.node()) + identity_node.addInput(node) + identity_node.output().setType(node.type()) + graph.return_node().replaceInput(i, identity_node.output()) + node = identity_node.output() + output_node_set.add(node) + + if node.debugName() != name: + node.setDebugName(name) + + set_names(list(graph.inputs()), input_names, "input") + set_names(list(graph.outputs()), output_names, "output") + + +@_beartype.beartype +def _run_symbolic_method(g, op_name, symbolic_fn, args): + r""" + This trampoline function gets invoked for every symbolic method + call from C++. + """ + try: + graph_context = jit_utils.GraphContext( + graph=g, + block=g.block(), + opset=GLOBALS.export_onnx_opset_version, + original_node=None, # type: ignore[arg-type] + params_dict=_params_dict, + env={}, + ) + return symbolic_fn(graph_context, *args) + except TypeError as e: + # Handle the specific case where we didn't successfully dispatch + # to symbolic_fn. Otherwise, the backtrace will have the clues + # you need. + e.args = (f"{e.args[0]} (occurred when translating {op_name})",) + raise + + +@_beartype.beartype +def _add_block(node: _C.Node) -> _C.Block: + return node.addBlock() + + +@_beartype.beartype +def _add_input_to_block(block: _C.Block): + return block.addInputToBlock() # type: ignore[attr-defined] + + +@_beartype.beartype +def _add_output_to_block(block: _C.Block, value: _C.Value) -> int: + return block.registerOutput(value) + + +@_beartype.beartype +def _should_aten_fallback( + name: str, opset_version: int, operator_export_type: _C_onnx.OperatorExportTypes +): + # For BUILD_CAFFE2=0 builds, if domain=="aten" and operator_export_type==ONNX_ATEN, + # an aten::ATen operator is created regardless of symbolics existence + # For BUILD_CAFFE2=1, the same applies only if there is no symbolic available + + is_exportable_aten_op = registration.registry.is_registered_op(name, opset_version) + is_onnx_aten_export = operator_export_type == _C_onnx.OperatorExportTypes.ONNX_ATEN + is_aten_fallback_export = ( + operator_export_type == _C_onnx.OperatorExportTypes.ONNX_ATEN_FALLBACK + ) + is_caffe2_build = _C_onnx._CAFFE2_ATEN_FALLBACK + + if not name.startswith("aten::"): + return False + + if is_caffe2_build: + if ( + is_onnx_aten_export or is_aten_fallback_export + ) and not is_exportable_aten_op: + return True + else: + if is_onnx_aten_export or ( + is_aten_fallback_export and not is_exportable_aten_op + ): + return True + + return False + + +@_beartype.beartype +def _need_symbolic_context(symbolic_fn: Callable) -> bool: + """Checks if the first argument to symbolic_fn is annotated as type `torch.onnx.SymbolicContext`.""" + params = tuple(inspect.signature(symbolic_fn).parameters.values()) + # When the annotation is postpone-evaluated, the annotation is a string + # and not a type. We need to use get_type_hints to get the real type. + if not params: + return False + first_param_name = params[0].name + type_hints = typing.get_type_hints(symbolic_fn) + if first_param_name not in type_hints: + return False + param_type = type_hints[first_param_name] + return issubclass(param_type, _exporter_states.SymbolicContext) + + +@_beartype.beartype +def _symbolic_context_handler(symbolic_fn: Callable) -> Callable: + """Decorator that provides the symbolic context to the symbolic function if needed.""" + if _need_symbolic_context(symbolic_fn): + # TODO(justinchuby): Update the module name of GraphContext when it is public + warnings.warn( + "The first argument to symbolic functions is deprecated in 1.13 and will be " + "removed in the future. Please annotate treat the first argument (g) as GraphContext " + "and use context information from the object instead.", + category=FutureWarning, + ) + + def wrapper(graph_context: jit_utils.GraphContext, *args, **kwargs): + symbolic_context = _exporter_states.SymbolicContext( + params_dict=graph_context.params_dict, + env=graph_context.env, + cur_node=graph_context.original_node, + onnx_block=graph_context.block, + ) + return symbolic_fn(symbolic_context, graph_context, *args, **kwargs) + + return wrapper + return symbolic_fn + + +@_beartype.beartype +def _get_aten_op_overload_name(n: _C.Node) -> str: + # Returns `overload_name` attribute to ATen ops on non-Caffe2 builds + schema = n.schema() + if not schema.startswith("aten::") or symbolic_helper.is_caffe2_aten_fallback(): + return "" + return _C.parse_schema(schema).overload_name + + +@_beartype.beartype +def _run_symbolic_function( + graph: _C.Graph, + block: _C.Block, + node: _C.Node, + inputs: Any, + env: Dict[_C.Value, _C.Value], + operator_export_type=_C_onnx.OperatorExportTypes.ONNX, +) -> Optional[Union[_C.Value, Sequence[Optional[_C.Value]]]]: + """Runs a symbolic function. + + The function is used in C++ to export the node to ONNX. + + Returns: + A single or a tuple of Values. + None when the node gets cloned as is into the new graph. + """ + + opset_version = GLOBALS.export_onnx_opset_version + + # See Note [Export inplace] + node_kind = node.kind() + if node_kind.endswith("_"): + # Treat relu_ -> relu; add_ -> add etc. + ns_op_name = node_kind[:-1] + else: + ns_op_name = node_kind + + namespace, op_name = jit_utils.parse_node_kind(ns_op_name) + + graph_context = jit_utils.GraphContext( + graph=graph, + block=block, + opset=opset_version, + original_node=node, + params_dict=_params_dict, + env=env, + ) + + # Direct ATen export requested + if _should_aten_fallback(ns_op_name, opset_version, operator_export_type): + attrs = { + k + "_" + node.kindOf(k)[0]: symbolic_helper._node_get(node, k) + for k in node.attributeNames() + } + outputs = node.outputsSize() + attrs["outputs"] = outputs + return graph_context.aten_op( + op_name, + *inputs, + overload_name=_get_aten_op_overload_name(node), + **attrs, + ) + + try: + # Caffe2-specific: Quantized op symbolics are registered for opset 9 only. + if symbolic_helper.is_caffe2_aten_fallback() and opset_version == 9: + symbolic_caffe2.register_quantized_ops("caffe2", opset_version) + + if namespace == "quantized" and symbolic_helper.is_caffe2_aten_fallback(): + domain = "caffe2" + else: + domain = namespace + symbolic_function_name = f"{domain}::{op_name}" + + symbolic_function_group = registration.registry.get_function_group( + symbolic_function_name + ) + if symbolic_function_group is not None: + symbolic_fn = symbolic_function_group.get(opset_version) + if symbolic_fn is not None: + # TODO Wrap almost identical attrs assignment or comment the difference. + attrs = { + k: symbolic_helper._node_get(node, k) for k in node.attributeNames() + } + return symbolic_fn(graph_context, *inputs, **attrs) + + attrs = { + k + "_" + node.kindOf(k)[0]: symbolic_helper._node_get(node, k) + for k in node.attributeNames() + } + if namespace == "onnx": + # Clone node to trigger ONNX shape inference + return graph_context.op(op_name, *inputs, **attrs, outputs=node.outputsSize()) # type: ignore[attr-defined] + + raise errors.UnsupportedOperatorError( + symbolic_function_name, + opset_version, + symbolic_function_group.get_min_supported() + if symbolic_function_group + else None, + ) + + except RuntimeError: + if operator_export_type == _C_onnx.OperatorExportTypes.ONNX_FALLTHROUGH: + return None + elif ( + operator_export_type == _C_onnx.OperatorExportTypes.ONNX_ATEN_FALLBACK + and not symbolic_helper.is_caffe2_aten_fallback() + ): + # Emit ATen op for non-Caffe2 builds when `operator_export_type==ONNX_ATEN_FALLBACK` + attrs = { + k + "_" + node.kindOf(k)[0]: symbolic_helper._node_get(node, k) + for k in node.attributeNames() + } + return graph_context.aten_op( + op_name, + *inputs, + overload_name=_get_aten_op_overload_name(node), + **attrs, + ) + raise + except TypeError as e: + # Handle the specific case where we didn't successfully dispatch. + # Otherwise, the backtrace will have the clues you need. + e.args = (f"{e.args[0]} \n(Occurred when translating {op_name}).",) + raise + + +@_beartype.beartype +def _verify_custom_op_name(symbolic_name: str): + if not re.match(r"^[a-zA-Z0-9-_]+::[a-zA-Z-_]+[a-zA-Z0-9-_]*$", symbolic_name): + raise errors.OnnxExporterError( + f"Failed to register operator {symbolic_name}. " + "The symbolic name must match the format domain::name, " + "and should start with a letter and contain only " + "alphanumerical characters" + ) + + ns, _ = jit_utils.parse_node_kind(symbolic_name) + if ns == "onnx": + raise ValueError( + f"Failed to register operator {symbolic_name}. {ns} domain cannot be modified." + ) + + +@_beartype.beartype +def register_custom_op_symbolic( + symbolic_name: str, + symbolic_fn: Callable, + opset_version: int, +): + """Registers a symbolic function for a custom operator. + + When the user registers symbolic for custom/contrib ops, + it is highly recommended to add shape inference for that operator via setType API, + otherwise the exported graph may have incorrect shape inference in some extreme cases. + An example of setType is `test_aten_embedding_2` in `test_operators.py`. + + See "Custom Operators" in the module documentation for an example usage. + + Args: + symbolic_name (str): The name of the custom operator in "::" + format. + symbolic_fn (Callable): A function that takes in the ONNX graph and + the input arguments to the current operator, and returns new + operator nodes to add to the graph. + opset_version (int): The ONNX opset version in which to register. + """ + if symbolic_name.startswith("::"): + symbolic_name = f"aten{symbolic_name}" + + _verify_custom_op_name(symbolic_name) + + registration.custom_onnx_symbolic( + symbolic_name, + opset_version, + decorate=[ + _symbolic_context_handler, + ], + )(symbolic_fn) + + +@_beartype.beartype +def unregister_custom_op_symbolic(symbolic_name: str, opset_version: int): + """Unregisters ``symbolic_name``. + + See "Custom Operators" in the module documentation for an example usage. + + Args: + symbolic_name (str): The name of the custom operator in "::" + format. + opset_version (int): The ONNX opset version in which to unregister. + """ + if symbolic_name.startswith("::"): + symbolic_name = f"aten{symbolic_name}" + + _verify_custom_op_name(symbolic_name) + + registration.registry.unregister(symbolic_name, opset_version) + + +@_beartype.beartype +def _validate_dynamic_axes(dynamic_axes, model, input_names, output_names): + """Ensures dynamic axes argument is follows the expected format.""" + if len(dynamic_axes) == 0: + return + + if hasattr(model, "graph"): + # Extracting set of valid input/output names that shall be used for dynamic_axes + if (input_names is None) or len(input_names) == 0: + input_names = [x.debugName() for x in model.graph.inputs()] + if (output_names is None) or len(output_names) == 0: + output_names = [y.debugName() for y in model.graph.outputs()] + + valid_names = set((input_names or []) + (output_names or [])) + + # If dynamic axes are provided as a list rather than dictionary, they should + # first get converted to a dictionary in expected format. If desired axes names + # are not provided for dynamic axes, automatic names shall be generated for + # provided dynamic axes of specified input/output + for key, value in dynamic_axes.items(): + if key not in valid_names: + warnings.warn( + f"Provided key {key} for dynamic axes is not a valid input/output name" + ) + if isinstance(value, list): + warnings.warn( + "No names were found for specified dynamic axes of provided input." + f"Automatically generated names will be applied to each dynamic axes of input {key}" + ) + + value_dict = {} + for i, x in enumerate(value): + if not isinstance(x, int): + raise ValueError( + "The type of axis index is expected to be an integer" + ) + if x in value_dict: + warnings.warn( + f"Duplicate dynamic axis index {x} was provided for input {key}." + ) + else: + value_dict[x] = str(key) + "_dynamic_axes_" + str(i + 1) + dynamic_axes[key] = value_dict + + +def model_signature(model: Union[torch.nn.Module, Callable]) -> inspect.Signature: + return inspect.signature( + model.forward if isinstance(model, torch.nn.Module) else model + ) diff --git a/shared/package-files/30/3071a8f4379604f1b20b7ed3d34c0afc5b49281607222e64202f4b0595d52444/blob b/shared/package-files/30/3071a8f4379604f1b20b7ed3d34c0afc5b49281607222e64202f4b0595d52444/blob new file mode 100644 index 0000000000000000000000000000000000000000..c789400c88690eb79d71587daacf6a3a4b1e91ed Binary files /dev/null and b/shared/package-files/30/3071a8f4379604f1b20b7ed3d34c0afc5b49281607222e64202f4b0595d52444/blob differ diff --git a/shared/package-files/30/307225229c4a1b407e2d7fb7511371bde5c4f91639cfbc5f922d533fb86e6fbf/blob b/shared/package-files/30/307225229c4a1b407e2d7fb7511371bde5c4f91639cfbc5f922d533fb86e6fbf/blob new file mode 100644 index 0000000000000000000000000000000000000000..5fa60d28748c07e93ee95d3bdb18590872be9942 --- /dev/null +++ b/shared/package-files/30/307225229c4a1b407e2d7fb7511371bde5c4f91639cfbc5f922d533fb86e6fbf/blob @@ -0,0 +1,24 @@ +# Copyright 2019-2020 Lawrence Livermore National Security, LLC and other +# Archspec Project Developers. See the top-level COPYRIGHT file for details. +# +# SPDX-License-Identifier: (Apache-2.0 OR MIT) +"""The "cpu" package permits to query and compare different +CPU microarchitectures. +""" +from .detect import host +from .microarchitecture import ( + TARGETS, + Microarchitecture, + UnsupportedMicroarchitecture, + generic_microarchitecture, + version_components, +) + +__all__ = [ + "Microarchitecture", + "UnsupportedMicroarchitecture", + "TARGETS", + "generic_microarchitecture", + "host", + "version_components", +] diff --git a/shared/package-files/30/3075257be4961a7a1666ae0b2a74845debb5743aa7f913a964160be618d199dd/blob b/shared/package-files/30/3075257be4961a7a1666ae0b2a74845debb5743aa7f913a964160be618d199dd/blob new file mode 100644 index 0000000000000000000000000000000000000000..133c86bd4546a6d4fb76cf24cf3c9d7c87580139 --- /dev/null +++ b/shared/package-files/30/3075257be4961a7a1666ae0b2a74845debb5743aa7f913a964160be618d199dd/blob @@ -0,0 +1,1399 @@ +import copy +import itertools +import math +import random +import sys +import unittest + +import numpy as np + +from numba import jit, njit +from numba.core import utils, errors +from numba.tests.support import TestCase, MemoryLeakMixin + +from numba.misc.quicksort import make_py_quicksort, make_jit_quicksort +from numba.misc.mergesort import make_jit_mergesort +from numba.misc.timsort import make_py_timsort, make_jit_timsort, MergeRun + + +def make_temp_list(keys, n): + return [keys[0]] * n + +def make_temp_array(keys, n): + return np.empty(n, keys.dtype) + + +py_list_timsort = make_py_timsort(make_temp_list) + +py_array_timsort = make_py_timsort(make_temp_array) + +jit_list_timsort = make_jit_timsort(make_temp_list) + +jit_array_timsort = make_jit_timsort(make_temp_array) + +py_quicksort = make_py_quicksort() + +jit_quicksort = make_jit_quicksort() + + +def sort_usecase(val): + val.sort() + +def sort_kind_usecase(val, is_stable=False): + if is_stable: + val.sort(kind='mergesort') + else: + val.sort(kind='quicksort') + +def argsort_usecase(val): + return val.argsort() + +def argsort_kind_usecase(val, is_stable=False): + if is_stable: + return val.argsort(kind='mergesort') + else: + return val.argsort(kind='quicksort') + +def sorted_usecase(val): + return sorted(val) + +def sorted_reverse_usecase(val, b): + return sorted(val, reverse=b) + +def np_sort_usecase(val): + return np.sort(val) + +def np_argsort_usecase(val): + return np.argsort(val) + +def np_argsort_kind_usecase(val, is_stable=False): + if is_stable: + return np.argsort(val, kind='mergesort') + else: + return np.argsort(val, kind='quicksort') + +def list_sort_usecase(n): + np.random.seed(42) + l = [] + for i in range(n): + l.append(np.random.random()) + ll = l[:] + ll.sort() + return l, ll + +def list_sort_reverse_usecase(n, b): + np.random.seed(42) + l = [] + for i in range(n): + l.append(np.random.random()) + ll = l[:] + ll.sort(reverse=b) + return l, ll + + +class BaseSortingTest(object): + + def random_list(self, n, offset=10): + random.seed(42) + l = list(range(offset, offset + n)) + random.shuffle(l) + return l + + def sorted_list(self, n, offset=10): + return list(range(offset, offset + n)) + + def revsorted_list(self, n, offset=10): + return list(range(offset, offset + n))[::-1] + + def initially_sorted_list(self, n, m=None, offset=10): + if m is None: + m = n // 2 + l = self.sorted_list(m, offset) + l += self.random_list(n - m, offset=l[-1] + offset) + return l + + def duprandom_list(self, n, factor=None, offset=10): + random.seed(42) + if factor is None: + factor = int(math.sqrt(n)) + l = (list(range(offset, offset + (n // factor) + 1)) * (factor + 1))[:n] + assert len(l) == n + random.shuffle(l) + return l + + def dupsorted_list(self, n, factor=None, offset=10): + if factor is None: + factor = int(math.sqrt(n)) + l = (list(range(offset, offset + (n // factor) + 1)) * (factor + 1))[:n] + assert len(l) == n, (len(l), n) + l.sort() + return l + + def assertSorted(self, orig, result): + self.assertEqual(len(result), len(orig)) + # sorted() returns a list, so make sure we compare to another list + self.assertEqual(list(result), sorted(orig)) + + def assertSortedValues(self, orig, orig_values, result, result_values): + self.assertEqual(len(result), len(orig)) + self.assertEqual(list(result), sorted(orig)) + zip_sorted = sorted(zip(orig, orig_values), key=lambda x: x[0]) + zip_result = list(zip(result, result_values)) + self.assertEqual(zip_sorted, zip_result) + # Check stability + for i in range(len(zip_result) - 1): + (k1, v1), (k2, v2) = zip_result[i], zip_result[i + 1] + if k1 == k2: + # Assuming values are unique, which is enforced by the tests + self.assertLess(orig_values.index(v1), orig_values.index(v2)) + + def fibo(self): + a = 1 + b = 1 + while True: + yield a + a, b = b, a + b + + def make_sample_sorted_lists(self, n): + lists = [] + for offset in (20, 120): + lists.append(self.sorted_list(n, offset)) + lists.append(self.dupsorted_list(n, offset)) + return lists + + def make_sample_lists(self, n): + lists = [] + for offset in (20, 120): + lists.append(self.sorted_list(n, offset)) + lists.append(self.dupsorted_list(n, offset)) + lists.append(self.revsorted_list(n, offset)) + lists.append(self.duprandom_list(n, offset)) + return lists + + +class BaseTimsortTest(BaseSortingTest): + + def merge_init(self, keys): + f = self.timsort.merge_init + return f(keys) + + def test_binarysort(self): + n = 20 + def check(l, n, start=0): + res = self.array_factory(l) + f(res, res, 0, n, start) + self.assertSorted(l, res) + + f = self.timsort.binarysort + l = self.sorted_list(n) + check(l, n) + check(l, n, n//2) + l = self.revsorted_list(n) + check(l, n) + l = self.initially_sorted_list(n, n//2) + check(l, n) + check(l, n, n//2) + l = self.revsorted_list(n) + check(l, n) + l = self.random_list(n) + check(l, n) + l = self.duprandom_list(n) + check(l, n) + + def test_binarysort_with_values(self): + n = 20 + v = list(range(100, 100+n)) + + def check(l, n, start=0): + res = self.array_factory(l) + res_v = self.array_factory(v) + f(res, res_v, 0, n, start) + self.assertSortedValues(l, v, res, res_v) + + f = self.timsort.binarysort + l = self.sorted_list(n) + check(l, n) + check(l, n, n//2) + l = self.revsorted_list(n) + check(l, n) + l = self.initially_sorted_list(n, n//2) + check(l, n) + check(l, n, n//2) + l = self.revsorted_list(n) + check(l, n) + l = self.random_list(n) + check(l, n) + l = self.duprandom_list(n) + check(l, n) + + def test_count_run(self): + n = 16 + f = self.timsort.count_run + + def check(l, lo, hi): + n, desc = f(self.array_factory(l), lo, hi) + # Fully check invariants + if desc: + for k in range(lo, lo + n - 1): + a, b = l[k], l[k + 1] + self.assertGreater(a, b) + if lo + n < hi: + self.assertLessEqual(l[lo + n - 1], l[lo + n]) + else: + for k in range(lo, lo + n - 1): + a, b = l[k], l[k + 1] + self.assertLessEqual(a, b) + if lo + n < hi: + self.assertGreater(l[lo + n - 1], l[lo + n], l) + + + l = self.sorted_list(n, offset=100) + check(l, 0, n) + check(l, 1, n - 1) + check(l, 1, 2) + l = self.revsorted_list(n, offset=100) + check(l, 0, n) + check(l, 1, n - 1) + check(l, 1, 2) + l = self.random_list(n, offset=100) + for i in range(len(l) - 1): + check(l, i, n) + l = self.duprandom_list(n, offset=100) + for i in range(len(l) - 1): + check(l, i, n) + + def test_gallop_left(self): + n = 20 + f = self.timsort.gallop_left + + def check(l, key, start, stop, hint): + k = f(key, l, start, stop, hint) + # Fully check invariants + self.assertGreaterEqual(k, start) + self.assertLessEqual(k, stop) + if k > start: + self.assertLess(l[k - 1], key) + if k < stop: + self.assertGreaterEqual(l[k], key) + + def check_all_hints(l, key, start, stop): + for hint in range(start, stop): + check(l, key, start, stop, hint) + + def check_sorted_list(l): + l = self.array_factory(l) + for key in (l[5], l[15], l[0], -1000, l[-1], 1000): + check_all_hints(l, key, 0, n) + check_all_hints(l, key, 1, n - 1) + check_all_hints(l, key, 8, n - 8) + + l = self.sorted_list(n, offset=100) + check_sorted_list(l) + l = self.dupsorted_list(n, offset=100) + check_sorted_list(l) + + def test_gallop_right(self): + n = 20 + f = self.timsort.gallop_right + + def check(l, key, start, stop, hint): + k = f(key, l, start, stop, hint) + # Fully check invariants + self.assertGreaterEqual(k, start) + self.assertLessEqual(k, stop) + if k > start: + self.assertLessEqual(l[k - 1], key) + if k < stop: + self.assertGreater(l[k], key) + + def check_all_hints(l, key, start, stop): + for hint in range(start, stop): + check(l, key, start, stop, hint) + + def check_sorted_list(l): + l = self.array_factory(l) + for key in (l[5], l[15], l[0], -1000, l[-1], 1000): + check_all_hints(l, key, 0, n) + check_all_hints(l, key, 1, n - 1) + check_all_hints(l, key, 8, n - 8) + + l = self.sorted_list(n, offset=100) + check_sorted_list(l) + l = self.dupsorted_list(n, offset=100) + check_sorted_list(l) + + def test_merge_compute_minrun(self): + f = self.timsort.merge_compute_minrun + + for i in range(0, 64): + self.assertEqual(f(i), i) + for i in range(6, 63): + if 2**i > sys.maxsize: + break + self.assertEqual(f(2**i), 32) + for i in self.fibo(): + if i < 64: + continue + if i >= sys.maxsize: + break + k = f(i) + self.assertGreaterEqual(k, 32) + self.assertLessEqual(k, 64) + if i > 500: + # i/k is close to, but strictly less than, an exact power of 2 + quot = i // k + p = 2 ** utils.bit_length(quot) + self.assertLess(quot, p) + self.assertGreaterEqual(quot, 0.9 * p) + + def check_merge_lo_hi(self, func, a, b): + na = len(a) + nb = len(b) + + # Add sentinels at start and end, to check they weren't moved + orig_keys = [42] + a + b + [-42] + keys = self.array_factory(orig_keys) + ms = self.merge_init(keys) + ssa = 1 + ssb = ssa + na + + #new_ms = func(ms, keys, [], ssa, na, ssb, nb) + new_ms = func(ms, keys, keys, ssa, na, ssb, nb) + self.assertEqual(keys[0], orig_keys[0]) + self.assertEqual(keys[-1], orig_keys[-1]) + self.assertSorted(orig_keys[1:-1], keys[1:-1]) + # Check the MergeState result + self.assertGreaterEqual(len(new_ms.keys), len(ms.keys)) + self.assertGreaterEqual(len(new_ms.values), len(ms.values)) + self.assertIs(new_ms.pending, ms.pending) + self.assertGreaterEqual(new_ms.min_gallop, 1) + + def test_merge_lo_hi(self): + f_lo = self.timsort.merge_lo + f_hi = self.timsort.merge_hi + + # The larger sizes exercise galloping + for (na, nb) in [(12, 16), (40, 40), (100, 110), (1000, 1100)]: + for a, b in itertools.product(self.make_sample_sorted_lists(na), + self.make_sample_sorted_lists(nb)): + self.check_merge_lo_hi(f_lo, a, b) + self.check_merge_lo_hi(f_hi, b, a) + + def check_merge_at(self, a, b): + f = self.timsort.merge_at + # Prepare the array to be sorted + na = len(a) + nb = len(b) + # Add sentinels at start and end, to check they weren't moved + orig_keys = [42] + a + b + [-42] + ssa = 1 + ssb = ssa + na + + stack_sentinel = MergeRun(-42, -42) + + def run_merge_at(ms, keys, i): + new_ms = f(ms, keys, keys, i) + self.assertEqual(keys[0], orig_keys[0]) + self.assertEqual(keys[-1], orig_keys[-1]) + self.assertSorted(orig_keys[1:-1], keys[1:-1]) + # Check stack state + self.assertIs(new_ms.pending, ms.pending) + self.assertEqual(ms.pending[i], (ssa, na + nb)) + self.assertEqual(ms.pending[0], stack_sentinel) + return new_ms + + # First check with i == len(stack) - 2 + keys = self.array_factory(orig_keys) + ms = self.merge_init(keys) + # Push sentinel on stack, to check it wasn't touched + ms = self.timsort.merge_append(ms, stack_sentinel) + i = ms.n + ms = self.timsort.merge_append(ms, MergeRun(ssa, na)) + ms = self.timsort.merge_append(ms, MergeRun(ssb, nb)) + ms = run_merge_at(ms, keys, i) + self.assertEqual(ms.n, i + 1) + + # Now check with i == len(stack) - 3 + keys = self.array_factory(orig_keys) + ms = self.merge_init(keys) + # Push sentinel on stack, to check it wasn't touched + ms = self.timsort.merge_append(ms, stack_sentinel) + i = ms.n + ms = self.timsort.merge_append(ms, MergeRun(ssa, na)) + ms = self.timsort.merge_append(ms, MergeRun(ssb, nb)) + # A last run (trivial here) + last_run = MergeRun(ssb + nb, 1) + ms = self.timsort.merge_append(ms, last_run) + ms = run_merge_at(ms, keys, i) + self.assertEqual(ms.n, i + 2) + self.assertEqual(ms.pending[ms.n - 1], last_run) + + def test_merge_at(self): + # The larger sizes exercise galloping + for (na, nb) in [(12, 16), (40, 40), (100, 110), (500, 510)]: + for a, b in itertools.product(self.make_sample_sorted_lists(na), + self.make_sample_sorted_lists(nb)): + self.check_merge_at(a, b) + self.check_merge_at(b, a) + + def test_merge_force_collapse(self): + f = self.timsort.merge_force_collapse + + # Test with runs of ascending sizes, then descending sizes + sizes_list = [(8, 10, 15, 20)] + sizes_list.append(sizes_list[0][::-1]) + + for sizes in sizes_list: + for chunks in itertools.product(*(self.make_sample_sorted_lists(n) + for n in sizes)): + # Create runs of the given sizes + orig_keys = sum(chunks, []) + keys = self.array_factory(orig_keys) + ms = self.merge_init(keys) + pos = 0 + for c in chunks: + ms = self.timsort.merge_append(ms, MergeRun(pos, len(c))) + pos += len(c) + # Sanity check + self.assertEqual(sum(ms.pending[ms.n - 1]), len(keys)) + # Now merge the runs + ms = f(ms, keys, keys) + # Remaining run is the whole list + self.assertEqual(ms.n, 1) + self.assertEqual(ms.pending[0], MergeRun(0, len(keys))) + # The list is now sorted + self.assertSorted(orig_keys, keys) + + def test_run_timsort(self): + f = self.timsort.run_timsort + + for size_factor in (1, 10): + # Make lists to be sorted from three chunks of different kinds. + sizes = (15, 30, 20) + + all_lists = [self.make_sample_lists(n * size_factor) for n in sizes] + for chunks in itertools.product(*all_lists): + orig_keys = sum(chunks, []) + keys = self.array_factory(orig_keys) + f(keys) + # The list is now sorted + self.assertSorted(orig_keys, keys) + + def test_run_timsort_with_values(self): + # Run timsort, but also with a values array + f = self.timsort.run_timsort_with_values + + for size_factor in (1, 5): + chunk_size = 80 * size_factor + a = self.dupsorted_list(chunk_size) + b = self.duprandom_list(chunk_size) + c = self.revsorted_list(chunk_size) + orig_keys = a + b + c + orig_values = list(range(1000, 1000 + len(orig_keys))) + + keys = self.array_factory(orig_keys) + values = self.array_factory(orig_values) + f(keys, values) + # This checks sort stability + self.assertSortedValues(orig_keys, orig_values, keys, values) + + +class TestTimsortPurePython(BaseTimsortTest, TestCase): + + timsort = py_list_timsort + + # Much faster than a Numpy array in pure Python + array_factory = list + + +class TestTimsortArraysPurePython(BaseTimsortTest, TestCase): + + timsort = py_array_timsort + + def array_factory(self, lst): + return np.array(lst, dtype=np.int32) + + +class JITTimsortMixin(object): + + timsort = jit_array_timsort + + test_merge_at = None + test_merge_force_collapse = None + + def wrap_with_mergestate(self, timsort, func, _cache=None): + """ + Wrap *func* into another compiled function inserting a runtime-created + mergestate as the first function argument. + """ + if _cache is None: + _cache = {} + key = timsort, func + if key in _cache: + return _cache[key] + + merge_init = timsort.merge_init + + @timsort.compile + def wrapper(keys, values, *args): + ms = merge_init(keys) + res = func(ms, keys, values, *args) + return res + + _cache[key] = wrapper + return wrapper + + +class TestTimsortArrays(JITTimsortMixin, BaseTimsortTest, TestCase): + + def array_factory(self, lst): + return np.array(lst, dtype=np.int32) + + def check_merge_lo_hi(self, func, a, b): + na = len(a) + nb = len(b) + + func = self.wrap_with_mergestate(self.timsort, func) + + # Add sentinels at start and end, to check they weren't moved + orig_keys = [42] + a + b + [-42] + keys = self.array_factory(orig_keys) + ssa = 1 + ssb = ssa + na + + new_ms = func(keys, keys, ssa, na, ssb, nb) + self.assertEqual(keys[0], orig_keys[0]) + self.assertEqual(keys[-1], orig_keys[-1]) + self.assertSorted(orig_keys[1:-1], keys[1:-1]) + + + +class BaseQuicksortTest(BaseSortingTest): + + # NOTE these tests assume a non-argsort quicksort. + + def test_insertion_sort(self): + n = 20 + def check(l, n): + res = self.array_factory([9999] + l + [-9999]) + f(res, res, 1, n) + self.assertEqual(res[0], 9999) + self.assertEqual(res[-1], -9999) + self.assertSorted(l, res[1:-1]) + + f = self.quicksort.insertion_sort + l = self.sorted_list(n) + check(l, n) + l = self.revsorted_list(n) + check(l, n) + l = self.initially_sorted_list(n, n//2) + check(l, n) + l = self.revsorted_list(n) + check(l, n) + l = self.random_list(n) + check(l, n) + l = self.duprandom_list(n) + check(l, n) + + def test_partition(self): + n = 20 + def check(l, n): + res = self.array_factory([9999] + l + [-9999]) + index = f(res, res, 1, n) + self.assertEqual(res[0], 9999) + self.assertEqual(res[-1], -9999) + pivot = res[index] + for i in range(1, index): + self.assertLessEqual(res[i], pivot) + for i in range(index + 1, n): + self.assertGreaterEqual(res[i], pivot) + + f = self.quicksort.partition + l = self.sorted_list(n) + check(l, n) + l = self.revsorted_list(n) + check(l, n) + l = self.initially_sorted_list(n, n//2) + check(l, n) + l = self.revsorted_list(n) + check(l, n) + l = self.random_list(n) + check(l, n) + l = self.duprandom_list(n) + check(l, n) + + def test_partition3(self): + # Test the unused partition3() function + n = 20 + def check(l, n): + res = self.array_factory([9999] + l + [-9999]) + lt, gt = f(res, 1, n) + self.assertEqual(res[0], 9999) + self.assertEqual(res[-1], -9999) + pivot = res[lt] + for i in range(1, lt): + self.assertLessEqual(res[i], pivot) + for i in range(lt, gt + 1): + self.assertEqual(res[i], pivot) + for i in range(gt + 1, n): + self.assertGreater(res[i], pivot) + + f = self.quicksort.partition3 + l = self.sorted_list(n) + check(l, n) + l = self.revsorted_list(n) + check(l, n) + l = self.initially_sorted_list(n, n//2) + check(l, n) + l = self.revsorted_list(n) + check(l, n) + l = self.random_list(n) + check(l, n) + l = self.duprandom_list(n) + check(l, n) + + def test_run_quicksort(self): + f = self.quicksort.run_quicksort + + for size_factor in (1, 5): + # Make lists to be sorted from two chunks of different kinds. + sizes = (15, 20) + + all_lists = [self.make_sample_lists(n * size_factor) for n in sizes] + for chunks in itertools.product(*all_lists): + orig_keys = sum(chunks, []) + keys = self.array_factory(orig_keys) + f(keys) + # The list is now sorted + self.assertSorted(orig_keys, keys) + + def test_run_quicksort_lt(self): + def lt(a, b): + return a > b + + f = self.make_quicksort(lt=lt).run_quicksort + + for size_factor in (1, 5): + # Make lists to be sorted from two chunks of different kinds. + sizes = (15, 20) + + all_lists = [self.make_sample_lists(n * size_factor) for n in sizes] + for chunks in itertools.product(*all_lists): + orig_keys = sum(chunks, []) + keys = self.array_factory(orig_keys) + f(keys) + # The list is now rev-sorted + self.assertSorted(orig_keys, keys[::-1]) + + # An imperfect comparison function, as LT(a, b) does not imply not LT(b, a). + # The sort should handle it gracefully. + def lt_floats(a, b): + return math.isnan(b) or a < b + + f = self.make_quicksort(lt=lt_floats).run_quicksort + + np.random.seed(42) + for size in (5, 20, 50, 500): + orig = np.random.random(size=size) * 100 + orig[np.random.random(size=size) < 0.1] = float('nan') + orig_keys = list(orig) + keys = self.array_factory(orig_keys) + f(keys) + non_nans = orig[~np.isnan(orig)] + # Non-NaNs are sorted at the front + self.assertSorted(non_nans, keys[:len(non_nans)]) + + +class TestQuicksortPurePython(BaseQuicksortTest, TestCase): + + quicksort = py_quicksort + make_quicksort = staticmethod(make_py_quicksort) + + # Much faster than a Numpy array in pure Python + array_factory = list + + +class TestQuicksortArrays(BaseQuicksortTest, TestCase): + + quicksort = jit_quicksort + make_quicksort = staticmethod(make_jit_quicksort) + + def array_factory(self, lst): + return np.array(lst, dtype=np.float64) + +class TestQuicksortMultidimensionalArrays(BaseSortingTest, TestCase): + + quicksort = make_jit_quicksort(is_np_array=True) + make_quicksort = staticmethod(make_jit_quicksort) + + def assertSorted(self, orig, result): + self.assertEqual(orig.shape, result.shape) + self.assertPreciseEqual(orig, result) + + def array_factory(self, lst, shape=None): + array = np.array(lst, dtype=np.float64) + if shape is None: + return array.reshape(-1, array.shape[0]) + else: + return array.reshape(shape) + + def get_shapes(self, n): + shapes = [] + if n == 1: + return shapes + + for i in range(2, int(math.sqrt(n)) + 1): + if n % i == 0: + shapes.append((n // i, i)) + shapes.append((i, n // i)) + _shapes = self.get_shapes(n // i) + for _shape in _shapes: + shapes.append((i,) + _shape) + shapes.append(_shape + (i,)) + + return shapes + + def test_run_quicksort(self): + f = self.quicksort.run_quicksort + + for size_factor in (1, 5): + # Make lists to be sorted from two chunks of different kinds. + sizes = (15, 20) + + all_lists = [self.make_sample_lists(n * size_factor) for n in sizes] + for chunks in itertools.product(*all_lists): + orig_keys = sum(chunks, []) + shape_list = self.get_shapes(len(orig_keys)) + shape_list.append(None) + for shape in shape_list: + keys = self.array_factory(orig_keys, shape=shape) + keys_copy = self.array_factory(orig_keys, shape=shape) + f(keys) + keys_copy.sort() + # The list is now sorted + self.assertSorted(keys_copy, keys) + + def test_run_quicksort_lt(self): + def lt(a, b): + return a > b + + f = self.make_quicksort(lt=lt, is_np_array=True).run_quicksort + + for size_factor in (1, 5): + # Make lists to be sorted from two chunks of different kinds. + sizes = (15, 20) + + all_lists = [self.make_sample_lists(n * size_factor) for n in sizes] + for chunks in itertools.product(*all_lists): + orig_keys = sum(chunks, []) + shape_list = self.get_shapes(len(orig_keys)) + shape_list.append(None) + for shape in shape_list: + keys = self.array_factory(orig_keys, shape=shape) + keys_copy = -self.array_factory(orig_keys, shape=shape) + f(keys) + # The list is now rev-sorted + keys_copy.sort() + keys_copy = -keys_copy + self.assertSorted(keys_copy, keys) + + # An imperfect comparison function, as LT(a, b) does not imply not LT(b, a). + # The sort should handle it gracefully. + def lt_floats(a, b): + return math.isnan(b) or a < b + + f = self.make_quicksort(lt=lt_floats, is_np_array=True).run_quicksort + + np.random.seed(42) + for size in (5, 20, 50, 500): + orig = np.random.random(size=size) * 100 + orig[np.random.random(size=size) < 0.1] = float('nan') + orig_keys = list(orig) + shape_list = self.get_shapes(len(orig_keys)) + shape_list.append(None) + for shape in shape_list: + keys = self.array_factory(orig_keys, shape=shape) + keys_copy = self.array_factory(orig_keys, shape=shape) + f(keys) + keys_copy.sort() + # Non-NaNs are sorted at the front + self.assertSorted(keys_copy, keys) + +class TestNumpySort(TestCase): + + def setUp(self): + np.random.seed(42) + + def int_arrays(self): + for size in (5, 20, 50, 500): + yield np.random.randint(99, size=size) + + def float_arrays(self): + for size in (5, 20, 50, 500): + yield np.random.random(size=size) * 100 + # Now with NaNs. Numpy sorts them at the end. + for size in (5, 20, 50, 500): + orig = np.random.random(size=size) * 100 + orig[np.random.random(size=size) < 0.1] = float('nan') + yield orig + # 90% of values are NaNs. + for size in (50, 500): + orig = np.random.random(size=size) * 100 + orig[np.random.random(size=size) < 0.9] = float('nan') + yield orig + + def has_duplicates(self, arr): + """ + Whether the array has duplicates. Takes NaNs into account. + """ + if np.count_nonzero(np.isnan(arr)) > 1: + return True + if np.unique(arr).size < arr.size: + return True + return False + + def check_sort_inplace(self, pyfunc, cfunc, val, kwargs=None): + if kwargs is None: + kwargs = {} + expected = copy.copy(val) + got = copy.copy(val) + pyfunc(expected, **kwargs) + cfunc(got, **kwargs) + self.assertPreciseEqual(got, expected) + + def check_sort_copy(self, pyfunc, cfunc, val): + orig = copy.copy(val) + expected = pyfunc(val) + got = cfunc(val) + self.assertPreciseEqual(got, expected) + # The original wasn't mutated + self.assertPreciseEqual(val, orig) + + def check_argsort(self, pyfunc, cfunc, val, kwargs=None): + if kwargs is None: + kwargs = {} + orig = copy.copy(val) + expected = pyfunc(val, **kwargs) + got = cfunc(val, **kwargs) + self.assertPreciseEqual(orig[got], np.sort(orig), + msg="the array wasn't argsorted") + # Numba and Numpy results may differ if there are duplicates + # in the array + if not self.has_duplicates(orig): + self.assertPreciseEqual(got, expected) + # The original wasn't mutated + self.assertPreciseEqual(val, orig) + + def test_array_sort_int(self): + pyfunc = sort_usecase + cfunc = jit(nopython=True)(pyfunc) + + for orig in self.int_arrays(): + self.check_sort_inplace(pyfunc, cfunc, orig) + + def test_array_sort_float(self): + pyfunc = sort_usecase + cfunc = jit(nopython=True)(pyfunc) + + for orig in self.float_arrays(): + self.check_sort_inplace(pyfunc, cfunc, orig) + + def test_array_sort_complex(self): + pyfunc = sort_usecase + cfunc = jit(nopython=True)(pyfunc) + + for real in self.float_arrays(): + imag = real[::] + np.random.shuffle(imag) + orig = np.array([complex(*x) for x in zip(real, imag)]) + self.check_sort_inplace(pyfunc, cfunc, orig) + + def test_array_sort_kind_int(self): + def check(pyfunc, is_stable): + cfunc = jit(nopython=True)(pyfunc) + for orig in self.int_arrays(): + self.check_sort_inplace(pyfunc, cfunc, orig, + dict(is_stable=is_stable)) + + check(sort_kind_usecase, is_stable=True) + check(sort_kind_usecase, is_stable=False) + + def test_array_sort_kind_float(self): + def check(pyfunc, is_stable): + cfunc = jit(nopython=True)(pyfunc) + for orig in self.float_arrays(): + self.check_sort_inplace(pyfunc, cfunc, orig, + dict(is_stable=is_stable)) + + check(sort_kind_usecase, is_stable=True) + check(sort_kind_usecase, is_stable=False) + + def test_array_sort_kind_complex(self): + def check(pyfunc, is_stable): + cfunc = jit(nopython=True)(pyfunc) + for real in self.float_arrays(): + imag = real[::] + np.random.shuffle(imag) + orig = np.array([complex(*x) for x in zip(real, imag)]) + self.check_sort_inplace(pyfunc, cfunc, orig, + dict(is_stable=is_stable)) + + check(sort_kind_usecase, is_stable=True) + check(sort_kind_usecase, is_stable=False) + + def test_array_sort_kind_multidim(self): + def check(pyfunc, is_stable): + cfunc = jit(nopython=True)(pyfunc) + for shape in ((4, 5), (3, 4, 5), (2, 30)): + orig = np.random.random(shape) * 100 + self.check_sort_inplace(pyfunc, cfunc, orig, + dict(is_stable=is_stable)) + + check(sort_kind_usecase, is_stable=True) + check(sort_kind_usecase, is_stable=False) + + def test_np_sort_int(self): + pyfunc = np_sort_usecase + cfunc = jit(nopython=True)(pyfunc) + + for orig in self.int_arrays(): + self.check_sort_copy(pyfunc, cfunc, orig) + + def test_np_sort_float(self): + pyfunc = np_sort_usecase + cfunc = jit(nopython=True)(pyfunc) + + for size in (5, 20, 50, 500): + orig = np.random.random(size=size) * 100 + orig[np.random.random(size=size) < 0.1] = float('nan') + self.check_sort_copy(pyfunc, cfunc, orig) + + def test_np_sort_complex(self): + pyfunc = np_sort_usecase + cfunc = jit(nopython=True)(pyfunc) + + for size in (5, 20, 50, 500): + real = np.random.random(size=size) * 100 + imag = np.random.random(size=size) * 100 + real[np.random.random(size=size) < 0.1] = float('nan') + imag[np.random.random(size=size) < 0.1] = float('nan') + orig = np.array([complex(*x) for x in zip(real, imag)]) + self.check_sort_copy(pyfunc, cfunc, orig) + + def test_argsort_int(self): + def check(pyfunc): + cfunc = jit(nopython=True)(pyfunc) + for orig in self.int_arrays(): + self.check_argsort(pyfunc, cfunc, orig) + + check(argsort_usecase) + check(np_argsort_usecase) + + def test_argsort_kind_int(self): + def check(pyfunc, is_stable): + cfunc = jit(nopython=True)(pyfunc) + for orig in self.int_arrays(): + self.check_argsort(pyfunc, cfunc, orig, + dict(is_stable=is_stable)) + + check(argsort_kind_usecase, is_stable=True) + check(np_argsort_kind_usecase, is_stable=True) + check(argsort_kind_usecase, is_stable=False) + check(np_argsort_kind_usecase, is_stable=False) + + def test_argsort_float(self): + def check(pyfunc): + cfunc = jit(nopython=True)(pyfunc) + for orig in self.float_arrays(): + self.check_argsort(pyfunc, cfunc, orig) + + check(argsort_usecase) + check(np_argsort_usecase) + + def test_argsort_float_supplemental(self): + def check(pyfunc, is_stable): + cfunc = jit(nopython=True)(pyfunc) + for orig in self.float_arrays(): + self.check_argsort(pyfunc, cfunc, orig, + dict(is_stable=is_stable)) + + check(argsort_kind_usecase, is_stable=True) + check(np_argsort_kind_usecase, is_stable=True) + check(argsort_kind_usecase, is_stable=False) + check(np_argsort_kind_usecase, is_stable=False) + + def test_argsort_complex(self): + def check(pyfunc): + cfunc = jit(nopython=True)(pyfunc) + for real in self.float_arrays(): + imag = real[::] + np.random.shuffle(imag) + orig = np.array([complex(*x) for x in zip(real, imag)]) + self.check_argsort(pyfunc, cfunc, orig) + + check(argsort_usecase) + check(np_argsort_usecase) + + def test_argsort_complex_supplemental(self): + def check(pyfunc, is_stable): + cfunc = jit(nopython=True)(pyfunc) + for real in self.float_arrays(): + imag = real[::] + np.random.shuffle(imag) + orig = np.array([complex(*x) for x in zip(real, imag)]) + self.check_argsort(pyfunc, cfunc, orig, + dict(is_stable=is_stable)) + + check(argsort_kind_usecase, is_stable=True) + check(np_argsort_kind_usecase, is_stable=True) + check(argsort_kind_usecase, is_stable=False) + check(np_argsort_kind_usecase, is_stable=False) + + def test_bad_array(self): + cfunc = jit(nopython=True)(np_sort_usecase) + msg = '.*Argument "a" must be array-like.*' + with self.assertRaisesRegex(errors.TypingError, msg) as raises: + cfunc(None) + + +class TestPythonSort(TestCase): + + def test_list_sort(self): + pyfunc = list_sort_usecase + cfunc = jit(nopython=True)(pyfunc) + + for size in (20, 50, 500): + orig, ret = cfunc(size) + self.assertEqual(sorted(orig), ret) + self.assertNotEqual(orig, ret) # sanity check + + def test_list_sort_reverse(self): + pyfunc = list_sort_reverse_usecase + cfunc = jit(nopython=True)(pyfunc) + + for size in (20, 50, 500): + for b in (False, True): + orig, ret = cfunc(size, b) + self.assertEqual(sorted(orig, reverse=b), ret) + self.assertNotEqual(orig, ret) # sanity check + + def test_sorted(self): + pyfunc = sorted_usecase + cfunc = jit(nopython=True)(pyfunc) + + for size in (20, 50, 500): + orig = np.random.random(size=size) * 100 + expected = sorted(orig) + got = cfunc(orig) + self.assertPreciseEqual(got, expected) + self.assertNotEqual(list(orig), got) # sanity check + + def test_sorted_reverse(self): + pyfunc = sorted_reverse_usecase + cfunc = jit(nopython=True)(pyfunc) + size = 20 + + orig = np.random.random(size=size) * 100 + for b in (False, True): + expected = sorted(orig, reverse=b) + got = cfunc(orig, b) + self.assertPreciseEqual(got, expected) + self.assertNotEqual(list(orig), got) # sanity check + + +class TestMergeSort(TestCase): + def setUp(self): + np.random.seed(321) + + def check_argsort_stable(self, sorter, low, high, count): + # make data with high possibility of duplicated key + data = np.random.randint(low, high, count) + expect = np.argsort(data, kind='mergesort') + got = sorter(data) + np.testing.assert_equal(expect, got) + + def test_argsort_stable(self): + arglist = [ + (-2, 2, 5), + (-5, 5, 10), + (0, 10, 101), + (0, 100, 1003), + ] + imp = make_jit_mergesort(is_argsort=True) + toplevel = imp.run_mergesort + sorter = njit(lambda arr: toplevel(arr)) + for args in arglist: + self.check_argsort_stable(sorter, *args) + + +nop_compiler = lambda x:x + + +class TestSortSlashSortedWithKey(MemoryLeakMixin, TestCase): + + def test_01(self): + + a = [3, 1, 4, 1, 5, 9] + + @njit + def external_key(z): + return 1. / z + + @njit + def foo(x, key=None): + new_x = x[:] + new_x.sort(key=key) + return sorted(x[:], key=key), new_x + + self.assertPreciseEqual(foo(a[:]), foo.py_func(a[:])) + self.assertPreciseEqual(foo(a[:], external_key), + foo.py_func(a[:], external_key)) + + def test_02(self): + + a = [3, 1, 4, 1, 5, 9] + + @njit + def foo(x): + def closure_key(z): + return 1. / z + new_x = x[:] + new_x.sort(key=closure_key) + return sorted(x[:], key=closure_key), new_x + + self.assertPreciseEqual(foo(a[:]), foo.py_func(a[:])) + + def test_03(self): + + a = [3, 1, 4, 1, 5, 9] + + def gen(compiler): + + @compiler + def bar(x, func): + new_x = x[:] + new_x.sort(key=func) + return sorted(x[:], key=func), new_x + + @compiler + def foo(x): + def closure_escapee_key(z): + return 1. / z + return bar(x, closure_escapee_key) + + return foo + + self.assertPreciseEqual(gen(njit)(a[:]), gen(nop_compiler)(a[:])) + + def test_04(self): + + a = ['a','b','B','b','C','A'] + + @njit + def external_key(z): + return z.upper() + + @njit + def foo(x, key=None): + new_x = x[:] + new_x.sort(key=key) + return sorted(x[:], key=key), new_x + + self.assertPreciseEqual(foo(a[:]), foo.py_func(a[:])) + self.assertPreciseEqual(foo(a[:], external_key), + foo.py_func(a[:], external_key)) + + def test_05(self): + + a = ['a','b','B','b','C','A'] + + @njit + def external_key(z): + return z.upper() + + @njit + def foo(x, key=None, reverse=False): + new_x = x[:] + new_x.sort(key=key, reverse=reverse) + return (sorted(x[:], key=key, reverse=reverse), new_x) + + for key, rev in itertools.product((None, external_key), + (True, False, 1, -12, 0)): + self.assertPreciseEqual(foo(a[:], key, rev), + foo.py_func(a[:], key, rev)) + + def test_optional_on_key(self): + a = [3, 1, 4, 1, 5, 9] + + @njit + def foo(x, predicate): + if predicate: + def closure_key(z): + return 1. / z + else: + closure_key = None + + new_x = x[:] + new_x.sort(key=closure_key) + + return (sorted(x[:], key=closure_key), new_x) + + with self.assertRaises(errors.TypingError) as raises: + TF = True + foo(a[:], TF) + + msg = "Key must concretely be None or a Numba JIT compiled function" + self.assertIn(msg, str(raises.exception)) + + def test_exceptions_sorted(self): + + @njit + def foo_sorted(x, key=None, reverse=False): + return sorted(x[:], key=key, reverse=reverse) + + @njit + def foo_sort(x, key=None, reverse=False): + new_x = x[:] + new_x.sort(key=key, reverse=reverse) + return new_x + + @njit + def external_key(z): + return 1. / z + + a = [3, 1, 4, 1, 5, 9] + + for impl in (foo_sort, foo_sorted): + + # check illegal key + with self.assertRaises(errors.TypingError) as raises: + impl(a, key="illegal") + + expect = "Key must be None or a Numba JIT compiled function" + self.assertIn(expect, str(raises.exception)) + + # check illegal reverse + with self.assertRaises(errors.TypingError) as raises: + impl(a, key=external_key, reverse="go backwards") + + expect = "an integer is required for 'reverse'" + self.assertIn(expect, str(raises.exception)) + + +class TestArraySort(MemoryLeakMixin, TestCase): + """Tests specific to array.sort""" + + def test_exceptions(self): + + @njit + def nonliteral_kind(kind): + np.arange(5).sort(kind=kind) + + # check non-literal kind + with self.assertRaises(errors.TypingError) as raises: + # valid spelling but not literal + nonliteral_kind('quicksort') + + expect = '"kind" must be a string literal' + self.assertIn(expect, str(raises.exception)) + + @njit + def unsupported_kwarg(): + np.arange(5).sort(foo='') + + with self.assertRaises(errors.TypingError) as raises: + unsupported_kwarg() + + expect = "Unsupported keywords: ['foo']" + self.assertIn(expect, str(raises.exception)) + + @jit + def unsupported_kind(): + np.arange(5).sort(kind='heapsort') + + with self.assertRaises(errors.TypingError) as raises: + unsupported_kind() + + expect = "Unsupported \"kind\": 'heapsort'" + self.assertIn(expect, str(raises.exception)) + + def test_kinds(self): + for kind in ('quicksort', 'mergesort', 'stable'): + @jit + def sort_kind(arr): + arr.sort(kind=kind) + + for arr in (np.array([3, 1, 4, 1, 5, 9, 2, 6]), + np.array([[3, 1, 4, 1], [5, 9, 2, 6]])): + expected = np.sort(arr, kind=kind) + sort_kind(arr) + self.assertPreciseEqual(arr, expected) + + +class TestArrayArgsort(MemoryLeakMixin, TestCase): + """Tests specific to array.argsort""" + + def test_exceptions(self): + + @njit + def nonliteral_kind(kind): + np.arange(5).argsort(kind=kind) + + # check non-literal kind + with self.assertRaises(errors.TypingError) as raises: + # valid spelling but not literal + nonliteral_kind('quicksort') + + expect = '"kind" must be a string literal' + self.assertIn(expect, str(raises.exception)) + + @njit + def unsupported_kwarg(): + np.arange(5).argsort(foo='') + + with self.assertRaises(errors.TypingError) as raises: + unsupported_kwarg() + + expect = "Unsupported keywords: ['foo']" + self.assertIn(expect, str(raises.exception)) + + @jit + def unsupported_kind(): + np.arange(5).argsort(kind='heapsort') + + with self.assertRaises(errors.TypingError) as raises: + unsupported_kind() + + expect = "Unsupported \"kind\": 'heapsort'" + self.assertIn(expect, str(raises.exception)) + + def test_kinds(self): + arr = np.array([3, 1, 4, 7, 5, 9, 2, 6]) + for kind in ('quicksort', 'mergesort', 'stable'): + @jit + def argsort_kind(arr): + return arr.argsort(kind=kind) + + expected = np.argsort(arr, kind=kind) + self.assertPreciseEqual(argsort_kind(arr), expected) + + # ties and more than SMALL_QUICKSORT elements, so only a stable + # sort reproduces numpy's index order + arr = np.array([3, 2, 2, 1, 1, 0, 0, 0, 0, 3, + 2, 3, 2, 2, 3, 2, 2, 2, 2, 3]) + expected = np.argsort(arr, kind='stable') + for kind in ('mergesort', 'stable'): + @jit + def argsort_stable(arr): + return arr.argsort(kind=kind) + + @jit + def np_argsort_stable(arr): + return np.argsort(arr, kind=kind) + + self.assertPreciseEqual(argsort_stable(arr), expected) + self.assertPreciseEqual(np_argsort_stable(arr), expected) + + +if __name__ == '__main__': + unittest.main() diff --git a/shared/package-files/30/307692187b5e94a8a8fd0f6dc8eb63115ed7fccf3ef87457f0cb5e40bfb4a1e0/blob b/shared/package-files/30/307692187b5e94a8a8fd0f6dc8eb63115ed7fccf3ef87457f0cb5e40bfb4a1e0/blob new file mode 100644 index 0000000000000000000000000000000000000000..3acdf2131cd669c2ced29fa4ba0809a8301ae623 Binary files /dev/null and b/shared/package-files/30/307692187b5e94a8a8fd0f6dc8eb63115ed7fccf3ef87457f0cb5e40bfb4a1e0/blob differ diff --git a/shared/package-files/30/307d3bbc5fdf249dfa587f3a68bfd61fb9ba538fa6bff964af92bc0fa5a429ca/blob b/shared/package-files/30/307d3bbc5fdf249dfa587f3a68bfd61fb9ba538fa6bff964af92bc0fa5a429ca/blob new file mode 100644 index 0000000000000000000000000000000000000000..b3aae65ca4b9d9905ca90771a01c4c556cca0bff --- /dev/null +++ b/shared/package-files/30/307d3bbc5fdf249dfa587f3a68bfd61fb9ba538fa6bff964af92bc0fa5a429ca/blob @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API ::std::tuple native_group_norm_backward(const at::Tensor & grad_out, const at::Tensor & input, const at::Tensor & mean, const at::Tensor & rstd, const c10::optional & weight, int64_t N, int64_t C, int64_t HxW, int64_t group, ::std::array output_mask); +TORCH_API ::std::tuple native_group_norm_backward_symint(const at::Tensor & grad_out, const at::Tensor & input, const at::Tensor & mean, const at::Tensor & rstd, const c10::optional & weight, c10::SymInt N, c10::SymInt C, c10::SymInt HxW, int64_t group, ::std::array output_mask); + +} // namespace cuda +} // namespace at diff --git a/shared/package-files/30/307d6f9301ead09e6d366eecb3c57abfe9a3ac31945f07ceb1aae22307e2dfc7/blob b/shared/package-files/30/307d6f9301ead09e6d366eecb3c57abfe9a3ac31945f07ceb1aae22307e2dfc7/blob new file mode 100644 index 0000000000000000000000000000000000000000..0619d1c3ebbd6c6a7d663093c7ed2202114148af --- /dev/null +++ b/shared/package-files/30/307d6f9301ead09e6d366eecb3c57abfe9a3ac31945f07ceb1aae22307e2dfc7/blob @@ -0,0 +1,60 @@ +"""The module helps converting SymPy expressions into shorter forms of them. + +for example: +the expression E**(pi*I) will be converted into -1 +the expression (x+x)**2 will be converted into 4*x**2 +""" +from .simplify import (simplify, hypersimp, hypersimilar, + logcombine, separatevars, posify, besselsimp, kroneckersimp, + signsimp, nsimplify) + +from .fu import FU, fu + +from .sqrtdenest import sqrtdenest + +from .cse_main import cse + +from .epathtools import epath, EPath + +from .hyperexpand import hyperexpand + +from .radsimp import collect, rcollect, radsimp, collect_const, fraction, numer, denom + +from .trigsimp import trigsimp, exptrigsimp + +from .powsimp import powsimp, powdenest + +from .combsimp import combsimp + +from .gammasimp import gammasimp + +from .ratsimp import ratsimp, ratsimpmodprime + +__all__ = [ + 'simplify', 'hypersimp', 'hypersimilar', 'logcombine', 'separatevars', + 'posify', 'besselsimp', 'kroneckersimp', 'signsimp', + 'nsimplify', + + 'FU', 'fu', + + 'sqrtdenest', + + 'cse', + + 'epath', 'EPath', + + 'hyperexpand', + + 'collect', 'rcollect', 'radsimp', 'collect_const', 'fraction', 'numer', + 'denom', + + 'trigsimp', 'exptrigsimp', + + 'powsimp', 'powdenest', + + 'combsimp', + + 'gammasimp', + + 'ratsimp', 'ratsimpmodprime', +] diff --git a/shared/package-files/30/307d780bacaadb81bf295b56ce3c1a23b5a0d783c2248625596d64a64c586a4d/blob b/shared/package-files/30/307d780bacaadb81bf295b56ce3c1a23b5a0d783c2248625596d64a64c586a4d/blob new file mode 100644 index 0000000000000000000000000000000000000000..17c6aaba570742652f70bf1e7bf1a576c9d256ae --- /dev/null +++ b/shared/package-files/30/307d780bacaadb81bf295b56ce3c1a23b5a0d783c2248625596d64a64c586a4d/blob @@ -0,0 +1,92 @@ +"""API for traversing the AST nodes. Implemented by the compiler and +meta introspection. +""" +import typing as t + +from .nodes import Node + +if t.TYPE_CHECKING: + import typing_extensions as te + + class VisitCallable(te.Protocol): + def __call__(self, node: Node, *args: t.Any, **kwargs: t.Any) -> t.Any: + ... + + +class NodeVisitor: + """Walks the abstract syntax tree and call visitor functions for every + node found. The visitor functions may return values which will be + forwarded by the `visit` method. + + Per default the visitor functions for the nodes are ``'visit_'`` + + class name of the node. So a `TryFinally` node visit function would + be `visit_TryFinally`. This behavior can be changed by overriding + the `get_visitor` function. If no visitor function exists for a node + (return value `None`) the `generic_visit` visitor is used instead. + """ + + def get_visitor(self, node: Node) -> "t.Optional[VisitCallable]": + """Return the visitor function for this node or `None` if no visitor + exists for this node. In that case the generic visit function is + used instead. + """ + return getattr(self, f"visit_{type(node).__name__}", None) + + def visit(self, node: Node, *args: t.Any, **kwargs: t.Any) -> t.Any: + """Visit a node.""" + f = self.get_visitor(node) + + if f is not None: + return f(node, *args, **kwargs) + + return self.generic_visit(node, *args, **kwargs) + + def generic_visit(self, node: Node, *args: t.Any, **kwargs: t.Any) -> t.Any: + """Called if no explicit visitor function exists for a node.""" + for child_node in node.iter_child_nodes(): + self.visit(child_node, *args, **kwargs) + + +class NodeTransformer(NodeVisitor): + """Walks the abstract syntax tree and allows modifications of nodes. + + The `NodeTransformer` will walk the AST and use the return value of the + visitor functions to replace or remove the old node. If the return + value of the visitor function is `None` the node will be removed + from the previous location otherwise it's replaced with the return + value. The return value may be the original node in which case no + replacement takes place. + """ + + def generic_visit(self, node: Node, *args: t.Any, **kwargs: t.Any) -> Node: + for field, old_value in node.iter_fields(): + if isinstance(old_value, list): + new_values = [] + for value in old_value: + if isinstance(value, Node): + value = self.visit(value, *args, **kwargs) + if value is None: + continue + elif not isinstance(value, Node): + new_values.extend(value) + continue + new_values.append(value) + old_value[:] = new_values + elif isinstance(old_value, Node): + new_node = self.visit(old_value, *args, **kwargs) + if new_node is None: + delattr(node, field) + else: + setattr(node, field, new_node) + return node + + def visit_list(self, node: Node, *args: t.Any, **kwargs: t.Any) -> t.List[Node]: + """As transformers may return lists in some places this method + can be used to enforce a list as return value. + """ + rv = self.visit(node, *args, **kwargs) + + if not isinstance(rv, list): + return [rv] + + return rv diff --git a/shared/package-files/30/307d7fbe4f07db091e8b9ff7c1f6300ac6dc258d0488d66fd4a9840209ed0d51/blob b/shared/package-files/30/307d7fbe4f07db091e8b9ff7c1f6300ac6dc258d0488d66fd4a9840209ed0d51/blob new file mode 100644 index 0000000000000000000000000000000000000000..6ecec5c0565b983bdf58cfdeff0fa7edc49914be Binary files /dev/null and b/shared/package-files/30/307d7fbe4f07db091e8b9ff7c1f6300ac6dc258d0488d66fd4a9840209ed0d51/blob differ diff --git a/shared/package-files/30/30835df38014205dd1ccd0854d176af912c46aff0feb3984686522794ed000ce/blob b/shared/package-files/30/30835df38014205dd1ccd0854d176af912c46aff0feb3984686522794ed000ce/blob new file mode 100644 index 0000000000000000000000000000000000000000..653254910278f0229fcc4f941ada5190723ff129 Binary files /dev/null and b/shared/package-files/30/30835df38014205dd1ccd0854d176af912c46aff0feb3984686522794ed000ce/blob differ diff --git a/shared/package-files/30/3086bd1e7a9e7b2f9ce4898f193934f88f522168b72085f659b1ce433ef8b333/blob b/shared/package-files/30/3086bd1e7a9e7b2f9ce4898f193934f88f522168b72085f659b1ce433ef8b333/blob new file mode 100644 index 0000000000000000000000000000000000000000..6d56a2072355c80c99dde39e49c7506600c9f044 Binary files /dev/null and b/shared/package-files/30/3086bd1e7a9e7b2f9ce4898f193934f88f522168b72085f659b1ce433ef8b333/blob differ diff --git a/shared/package-files/30/308e8c05f29c1cc799e072958d761e67272983d491511d90476b7c2eac8dd130/blob b/shared/package-files/30/308e8c05f29c1cc799e072958d761e67272983d491511d90476b7c2eac8dd130/blob new file mode 100644 index 0000000000000000000000000000000000000000..ca843b40a3a2e1f879cd5d3eb2a5d48632faed7a --- /dev/null +++ b/shared/package-files/30/308e8c05f29c1cc799e072958d761e67272983d491511d90476b7c2eac8dd130/blob @@ -0,0 +1,46 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor randn(at::IntArrayRef size, at::TensorOptions options={}); +TORCH_API at::Tensor randn(at::IntArrayRef size, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory); +TORCH_API at::Tensor randn_symint(c10::SymIntArrayRef size, at::TensorOptions options={}); +TORCH_API at::Tensor randn_symint(c10::SymIntArrayRef size, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory); +TORCH_API at::Tensor randn(at::IntArrayRef size, c10::optional generator, at::TensorOptions options={}); +TORCH_API at::Tensor randn(at::IntArrayRef size, c10::optional generator, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory); +TORCH_API at::Tensor randn_symint(c10::SymIntArrayRef size, c10::optional generator, at::TensorOptions options={}); +TORCH_API at::Tensor randn_symint(c10::SymIntArrayRef size, c10::optional generator, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory); +TORCH_API at::Tensor randn(at::IntArrayRef size, c10::optional names, at::TensorOptions options={}); +TORCH_API at::Tensor randn(at::IntArrayRef size, c10::optional names, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory); +TORCH_API at::Tensor randn_symint(c10::SymIntArrayRef size, c10::optional names, at::TensorOptions options={}); +TORCH_API at::Tensor randn_symint(c10::SymIntArrayRef size, c10::optional names, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory); +TORCH_API at::Tensor & randn_out(at::Tensor & out, at::IntArrayRef size, c10::optional names); +TORCH_API at::Tensor & randn_outf(at::IntArrayRef size, c10::optional names, at::Tensor & out); +TORCH_API at::Tensor & randn_symint_out(at::Tensor & out, c10::SymIntArrayRef size, c10::optional names); +TORCH_API at::Tensor & randn_symint_outf(c10::SymIntArrayRef size, c10::optional names, at::Tensor & out); +TORCH_API at::Tensor randn(at::IntArrayRef size, c10::optional generator, c10::optional names, at::TensorOptions options={}); +TORCH_API at::Tensor randn(at::IntArrayRef size, c10::optional generator, c10::optional names, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory); +TORCH_API at::Tensor randn_symint(c10::SymIntArrayRef size, c10::optional generator, c10::optional names, at::TensorOptions options={}); +TORCH_API at::Tensor randn_symint(c10::SymIntArrayRef size, c10::optional generator, c10::optional names, c10::optional dtype, c10::optional layout, c10::optional device, c10::optional pin_memory); +TORCH_API at::Tensor & randn_out(at::Tensor & out, at::IntArrayRef size, c10::optional generator, c10::optional names); +TORCH_API at::Tensor & randn_outf(at::IntArrayRef size, c10::optional generator, c10::optional names, at::Tensor & out); +TORCH_API at::Tensor & randn_symint_out(at::Tensor & out, c10::SymIntArrayRef size, c10::optional generator, c10::optional names); +TORCH_API at::Tensor & randn_symint_outf(c10::SymIntArrayRef size, c10::optional generator, c10::optional names, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/shared/package-files/30/308fcd3cce6ba6f1a4a95334f97044d1cb75f8c7d9779e4e6e65bb85e25e0687/blob b/shared/package-files/30/308fcd3cce6ba6f1a4a95334f97044d1cb75f8c7d9779e4e6e65bb85e25e0687/blob new file mode 100644 index 0000000000000000000000000000000000000000..e8f6bcb9bc213c4041229dab1f52265425214907 --- /dev/null +++ b/shared/package-files/30/308fcd3cce6ba6f1a4a95334f97044d1cb75f8c7d9779e4e6e65bb85e25e0687/blob @@ -0,0 +1,27 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeMetaFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace meta { + +struct TORCH_API structured_upsample_nearest3d_backward : public at::impl::MetaBase { + + + void meta(const at::Tensor & grad_output, at::ArrayRef output_size, at::ArrayRef input_size, c10::optional scales_d, c10::optional scales_h, c10::optional scales_w); +}; + +} // namespace native +} // namespace at diff --git a/shared/package-files/30/3090c822defabc38ccb88417c02e1e38c22ae5424ec47bb93f2d0681cfb113da/blob b/shared/package-files/30/3090c822defabc38ccb88417c02e1e38c22ae5424ec47bb93f2d0681cfb113da/blob new file mode 100644 index 0000000000000000000000000000000000000000..7e3a55ab689c990dc7f28a480c17fce5c656837b --- /dev/null +++ b/shared/package-files/30/3090c822defabc38ccb88417c02e1e38c22ae5424ec47bb93f2d0681cfb113da/blob @@ -0,0 +1,340 @@ +import os +import platform +import re +import textwrap +import warnings + +import numpy as np + +from numba.tests.support import (TestCase, override_config, override_env_config, + captured_stdout, forbid_codegen, skip_parfors_unsupported, + needs_blas) +from numba import jit, njit +from numba.core import types, compiler, utils +from numba.core.errors import NumbaPerformanceWarning +from numba import prange +from numba.experimental import jitclass +import unittest + + +def simple_nopython(somearg): + retval = somearg + 1 + return retval + +def simple_gen(x, y): + yield x + yield y + + +class SimpleClass(object): + def __init__(self): + self.h = 5 + +simple_class_spec = [('h', types.int32)] + +def simple_class_user(obj): + return obj.h + +def unsupported_parfor(a, b): + return np.dot(a, b) # dot as gemm unsupported + +def supported_parfor(n): + a = np.ones(n) + for i in prange(n): + a[i] = a[i] + np.sin(i) + return a + +def unsupported_prange(n): + a = np.ones(n) + for i in prange(n): + a[i] = a[i] + np.sin(i) + assert i + 13 < 100000 + return a + + +class DebugTestBase(TestCase): + + all_dumps = set(['bytecode', 'cfg', 'ir', 'typeinfer', 'llvm', + 'func_opt_llvm', 'optimized_llvm', 'assembly']) + + def assert_fails(self, *args, **kwargs): + self.assertRaises(AssertionError, *args, **kwargs) + + def check_debug_output(self, out, dump_names): + enabled_dumps = dict.fromkeys(self.all_dumps, False) + for name in dump_names: + assert name in enabled_dumps + enabled_dumps[name] = True + for name, enabled in sorted(enabled_dumps.items()): + check_meth = getattr(self, '_check_dump_%s' % name) + if enabled: + check_meth(out) + else: + self.assert_fails(check_meth, out) + + def _check_dump_bytecode(self, out): + if utils.PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14), (3, 15)): + self.assertIn('BINARY_OP', out) + elif utils.PYVERSION in ((3, 10),): + self.assertIn('BINARY_ADD', out) + else: + raise NotImplementedError(utils.PYVERSION) + + def _check_dump_cfg(self, out): + self.assertIn('CFG dominators', out) + + def _check_dump_ir(self, out): + self.assertIn('--IR DUMP: %s--' % self.func_name, out) + + def _check_dump_typeinfer(self, out): + self.assertIn('--propagate--', out) + + def _check_dump_llvm(self, out): + self.assertIn('--LLVM DUMP', out) + if compiler.Flags.options["auto_parallel"].default.enabled == False: + self.assertRegex(out, r'store i64 %\"\.\d", i64\* %"retptr"', out) + + def _check_dump_func_opt_llvm(self, out): + self.assertIn('--FUNCTION OPTIMIZED DUMP %s' % self.func_name, out) + # allocas have been optimized away + self.assertIn('add nsw i64 %arg.somearg, 1', out) + + def _check_dump_optimized_llvm(self, out): + self.assertIn('--OPTIMIZED DUMP %s' % self.func_name, out) + self.assertIn('add nsw i64 %arg.somearg, 1', out) + + def _check_dump_assembly(self, out): + self.assertIn('--ASSEMBLY %s' % self.func_name, out) + if platform.machine() in ('x86_64', 'AMD64', 'i386', 'i686'): + self.assertIn('xorl', out) + + +class FunctionDebugTestBase(DebugTestBase): + + func_name = 'simple_nopython' + + def compile_simple_nopython(self): + with captured_stdout() as out: + cfunc = njit((types.int64,))(simple_nopython) + # Sanity check compiled function + self.assertPreciseEqual(cfunc(2), 3) + return out.getvalue() + + +class TestFunctionDebugOutput(FunctionDebugTestBase): + + def test_dump_bytecode(self): + with override_config('DUMP_BYTECODE', True): + out = self.compile_simple_nopython() + self.check_debug_output(out, ['bytecode']) + + def test_dump_ir(self): + with override_config('DUMP_IR', True): + out = self.compile_simple_nopython() + self.check_debug_output(out, ['ir']) + + def test_dump_cfg(self): + with override_config('DUMP_CFG', True): + out = self.compile_simple_nopython() + self.check_debug_output(out, ['cfg']) + + def test_dump_llvm(self): + with override_config('DUMP_LLVM', True): + out = self.compile_simple_nopython() + self.check_debug_output(out, ['llvm']) + + def test_dump_func_opt_llvm(self): + with override_config('DUMP_FUNC_OPT', True): + out = self.compile_simple_nopython() + self.check_debug_output(out, ['func_opt_llvm']) + + def test_dump_optimized_llvm(self): + with override_config('DUMP_OPTIMIZED', True): + out = self.compile_simple_nopython() + self.check_debug_output(out, ['optimized_llvm']) + + def test_dump_assembly(self): + with override_config('DUMP_ASSEMBLY', True): + out = self.compile_simple_nopython() + self.check_debug_output(out, ['assembly']) + + +class TestGeneratorDebugOutput(DebugTestBase): + + func_name = 'simple_gen' + + def compile_simple_gen(self): + with captured_stdout() as out: + cfunc = njit((types.int64, types.int64))(simple_gen) + # Sanity check compiled function + self.assertPreciseEqual(list(cfunc(2, 5)), [2, 5]) + return out.getvalue() + + def test_dump_ir_generator(self): + with override_config('DUMP_IR', True): + out = self.compile_simple_gen() + self.check_debug_output(out, ['ir']) + self.assertIn('--GENERATOR INFO: %s' % self.func_name, out) + expected_gen_info = textwrap.dedent(""" + generator state variables: ['x', 'y'] + yield point #1: live variables = ['y'], weak live variables = ['x'] + yield point #2: live variables = [], weak live variables = ['y'] + """) + self.assertIn(expected_gen_info, out) + + +class TestDisableJIT(DebugTestBase): + """ + Test the NUMBA_DISABLE_JIT environment variable. + """ + + def test_jit(self): + with override_config('DISABLE_JIT', True): + with forbid_codegen(): + cfunc = jit(nopython=True)(simple_nopython) + self.assertPreciseEqual(cfunc(2), 3) + + def test_jitclass(self): + with override_config('DISABLE_JIT', True): + with forbid_codegen(): + SimpleJITClass = jitclass(simple_class_spec)(SimpleClass) + + obj = SimpleJITClass() + self.assertPreciseEqual(obj.h, 5) + + cfunc = jit(nopython=True)(simple_class_user) + self.assertPreciseEqual(cfunc(obj), 5) + + +class TestEnvironmentOverride(FunctionDebugTestBase): + """ + Test that environment variables are reloaded by Numba when modified. + """ + + # mutates env with os.environ so must be run serially + _numba_parallel_test_ = False + + def test_debug(self): + out = self.compile_simple_nopython() + self.assertFalse(out) + with override_env_config('NUMBA_DEBUG', '1'): + out = self.compile_simple_nopython() + # Note that all variables dependent on NUMBA_DEBUG are + # updated too. + self.check_debug_output(out, ['ir', 'typeinfer', + 'llvm', 'func_opt_llvm', + 'optimized_llvm', 'assembly']) + out = self.compile_simple_nopython() + self.assertFalse(out) + +class TestParforsDebug(TestCase): + """ + Tests debug options associated with parfors + """ + + # mutates env with os.environ so must be run serially + _numba_parallel_test_ = False + + def check_parfors_warning(self, warn_list): + msg = ("'parallel=True' was specified but no transformation for " + "parallel execution was possible.") + warning_found = False + for w in warn_list: + if msg in str(w.message): + warning_found = True + break + self.assertTrue(warning_found, "Warning message should be found.") + + def check_parfors_unsupported_prange_warning(self, warn_list): + msg = ("prange or pndindex loop will not be executed in parallel " + "due to there being more than one entry to or exit from the " + "loop (e.g., an assertion).") + warning_found = False + for w in warn_list: + if msg in str(w.message): + warning_found = True + break + self.assertTrue(warning_found, "Warning message should be found.") + + @needs_blas + @skip_parfors_unsupported + def test_warns(self): + """ + Test that using parallel=True on a function that does not have parallel + semantics warns. + """ + arr_ty = types.Array(types.float64, 2, "C") + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always", NumbaPerformanceWarning) + njit((arr_ty, arr_ty), parallel=True)(unsupported_parfor) + self.check_parfors_warning(w) + + @needs_blas + @skip_parfors_unsupported + def test_unsupported_prange_warns(self): + """ + Test that prange with multiple exits issues a warning + """ + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always", NumbaPerformanceWarning) + njit((types.int64,), parallel=True)(unsupported_prange) + self.check_parfors_unsupported_prange_warning(w) + + @skip_parfors_unsupported + def test_array_debug_opt_stats(self): + """ + Test that NUMBA_DEBUG_ARRAY_OPT_STATS produces valid output + """ + # deliberately trigger a compilation loop to increment the + # Parfor class state, this is to ensure the test works based + # on indices computed based on this state and not hard coded + # indices. + njit((types.int64,), parallel=True)(supported_parfor) + + with override_env_config('NUMBA_DEBUG_ARRAY_OPT_STATS', '1'): + with captured_stdout() as out: + njit((types.int64,), parallel=True)(supported_parfor) + + # grab the various parts out the output + output = out.getvalue().split('\n') + parallel_loop_output = \ + [x for x in output if 'is produced from pattern' in x] + fuse_output = \ + [x for x in output if 'is fused into' in x] + after_fusion_output = \ + [x for x in output if 'After fusion, function' in x] + + # Parfor's have a shared state index, grab the current value + # as it will be used as an offset for all loop messages + parfor_state = int(re.compile(r'#([0-9]+)').search( + parallel_loop_output[0]).group(1)) + bounds = range(parfor_state, + parfor_state + len(parallel_loop_output)) + + # Check the Parallel for-loop is produced from + # works first + pattern = ("('ones function', 'NumPy mapping')", + ('prange', 'user', '')) + fmt = 'Parallel for-loop #{} is produced from pattern \'{}\' at' + for i, trials, lpattern in zip(bounds, parallel_loop_output, + pattern): + to_match = fmt.format(i, lpattern) + self.assertIn(to_match, trials) + + # Check the fusion statements are correct + pattern = (parfor_state + 1, parfor_state + 0) + fmt = 'Parallel for-loop #{} is fused into for-loop #{}.' + for trials in fuse_output: + to_match = fmt.format(*pattern) + self.assertIn(to_match, trials) + + # Check the post fusion statements are correct + pattern = (supported_parfor.__name__, 1, set([parfor_state])) + fmt = 'After fusion, function {} has {} parallel for-loop(s) #{}.' + for trials in after_fusion_output: + to_match = fmt.format(*pattern) + self.assertIn(to_match, trials) + + +if __name__ == '__main__': + unittest.main() diff --git a/shared/package-files/30/3092965b8811fd6a6765799664845181fc1dd1330b937f915808c485d316234d/blob b/shared/package-files/30/3092965b8811fd6a6765799664845181fc1dd1330b937f915808c485d316234d/blob new file mode 100644 index 0000000000000000000000000000000000000000..8d326610412db20c62cd2f9aa0cfc06f334ab648 Binary files /dev/null and b/shared/package-files/30/3092965b8811fd6a6765799664845181fc1dd1330b937f915808c485d316234d/blob differ diff --git a/shared/package-files/30/309a7e1cb76dcfcfe387d53ad829c75577c3667168ca0f03957498d6bd5674ac/blob b/shared/package-files/30/309a7e1cb76dcfcfe387d53ad829c75577c3667168ca0f03957498d6bd5674ac/blob new file mode 100644 index 0000000000000000000000000000000000000000..0e344c2404f8f213cff1914b859f1c300d1f3f12 --- /dev/null +++ b/shared/package-files/30/309a7e1cb76dcfcfe387d53ad829c75577c3667168ca0f03957498d6bd5674ac/blob @@ -0,0 +1,202 @@ +import copy +import sys +import re +import os +from itertools import chain +from contextlib import contextmanager + +from parso.python import tree + + +def is_stdlib_path(path): + # Python standard library paths look like this: + # /usr/lib/python3.9/... + # TODO The implementation below is probably incorrect and not complete. + parts = path.parts + if 'dist-packages' in parts or 'site-packages' in parts: + return False + + base_path = os.path.join(sys.prefix, 'lib', 'python') + return bool(re.match(re.escape(base_path) + r'\d.\d', str(path))) + + +def deep_ast_copy(obj): + """ + Much, much faster than copy.deepcopy, but just for parser tree nodes. + """ + # If it's already in the cache, just return it. + new_obj = copy.copy(obj) + + # Copy children + new_children = [] + for child in obj.children: + if isinstance(child, tree.Leaf): + new_child = copy.copy(child) + new_child.parent = new_obj + else: + new_child = deep_ast_copy(child) + new_child.parent = new_obj + new_children.append(new_child) + new_obj.children = new_children + + return new_obj + + +def infer_call_of_leaf(context, leaf, cut_own_trailer=False): + """ + Creates a "call" node that consist of all ``trailer`` and ``power`` + objects. E.g. if you call it with ``append``:: + + list([]).append(3) or None + + You would get a node with the content ``list([]).append`` back. + + This generates a copy of the original ast node. + + If you're using the leaf, e.g. the bracket `)` it will return ``list([])``. + + We use this function for two purposes. Given an expression ``bar.foo``, + we may want to + - infer the type of ``foo`` to offer completions after foo + - infer the type of ``bar`` to be able to jump to the definition of foo + The option ``cut_own_trailer`` must be set to true for the second purpose. + """ + trailer = leaf.parent + if trailer.type == 'fstring': + from jedi.inference import compiled + return compiled.get_string_value_set(context.inference_state) + + # The leaf may not be the last or first child, because there exist three + # different trailers: `( x )`, `[ x ]` and `.x`. In the first two examples + # we should not match anything more than x. + if trailer.type != 'trailer' or leaf not in (trailer.children[0], trailer.children[-1]): + if leaf == ':': + # Basically happens with foo[:] when the cursor is on the colon + from jedi.inference.base_value import NO_VALUES + return NO_VALUES + if trailer.type == 'atom': + return context.infer_node(trailer) + return context.infer_node(leaf) + + power = trailer.parent + index = power.children.index(trailer) + if cut_own_trailer: + cut = index + else: + cut = index + 1 + + if power.type == 'error_node': + start = index + while True: + start -= 1 + base = power.children[start] + if base.type != 'trailer': + break + trailers = power.children[start + 1:cut] + else: + base = power.children[0] + trailers = power.children[1:cut] + + if base == 'await': + base = trailers[0] + trailers = trailers[1:] + + values = context.infer_node(base) + from jedi.inference.syntax_tree import infer_trailer + for trailer in trailers: + values = infer_trailer(context, values, trailer) + return values + + +def get_names_of_node(node): + try: + children = node.children + except AttributeError: + if node.type == 'name': + return [node] + else: + return [] + else: + return list(chain.from_iterable(get_names_of_node(c) for c in children)) + + +def is_string(value): + return value.is_compiled() and isinstance(value.get_safe_value(default=None), str) + + +def is_literal(value): + return is_number(value) or is_string(value) + + +def _get_safe_value_or_none(value, accept): + value = value.get_safe_value(default=None) + if isinstance(value, accept): + return value + + +def get_int_or_none(value): + return _get_safe_value_or_none(value, int) + + +def get_str_or_none(value): + return _get_safe_value_or_none(value, str) + + +def is_number(value): + return _get_safe_value_or_none(value, (int, float)) is not None + + +class SimpleGetItemNotFound(Exception): + pass + + +@contextmanager +def reraise_getitem_errors(*exception_classes): + try: + yield + except exception_classes as e: + raise SimpleGetItemNotFound(e) + + +def parse_dotted_names(nodes, is_import_from, until_node=None): + level = 0 + names = [] + for node in nodes[1:]: + if node in ('.', '...'): + if not names: + level += len(node.value) + elif node.type == 'dotted_name': + for n in node.children[::2]: + names.append(n) + if n is until_node: + break + else: + continue + break + elif node.type == 'name': + names.append(node) + if node is until_node: + break + elif node == ',': + if not is_import_from: + names = [] + else: + # Here if the keyword `import` comes along it stops checking + # for names. + break + return level, names + + +def values_from_qualified_names(inference_state, *names): + return inference_state.import_module(names[:-1]).py__getattribute__(names[-1]) + + +def is_big_annoying_library(context): + string_names = context.get_root_context().string_names + if string_names is None: + return False + + # Especially pandas and tensorflow are huge complicated Python libraries + # that get even slower than they already are when Jedi tries to undrstand + # dynamic features like decorators, ifs and other stuff. + return string_names[0] in ('pandas', 'numpy', 'tensorflow', 'matplotlib') diff --git a/shared/package-files/30/309ac06c4c68c7d507bf5527303c747fa246fe8038ddcbe1cc74284ce4a5ec86/blob b/shared/package-files/30/309ac06c4c68c7d507bf5527303c747fa246fe8038ddcbe1cc74284ce4a5ec86/blob new file mode 100644 index 0000000000000000000000000000000000000000..964b0ce910f027dfb48790b49e2360dcd806ad7c --- /dev/null +++ b/shared/package-files/30/309ac06c4c68c7d507bf5527303c747fa246fe8038ddcbe1cc74284ce4a5ec86/blob @@ -0,0 +1,4 @@ +import sys +from numba.testing import run_tests + +sys.exit(0 if run_tests(sys.argv).wasSuccessful() else 1) diff --git a/shared/package-files/30/309c029c9e3d85f9ce0e1e8980c1ce090d8a0654db9b2494ebf5f85d66aa8b3e/blob b/shared/package-files/30/309c029c9e3d85f9ce0e1e8980c1ce090d8a0654db9b2494ebf5f85d66aa8b3e/blob new file mode 100644 index 0000000000000000000000000000000000000000..912da70dd0c471f5022b86f92cf1b9c94ae36e01 --- /dev/null +++ b/shared/package-files/30/309c029c9e3d85f9ce0e1e8980c1ce090d8a0654db9b2494ebf5f85d66aa8b3e/blob @@ -0,0 +1,17 @@ +from __future__ import annotations + +from typing import TYPE_CHECKING + +from narwhals._compliant.any_namespace import CatNamespace +from narwhals._pandas_like.utils import PandasLikeSeriesNamespace + +if TYPE_CHECKING: + from narwhals._pandas_like.series import PandasLikeSeries + + +class PandasLikeSeriesCatNamespace( + PandasLikeSeriesNamespace, CatNamespace["PandasLikeSeries"] +): + def get_categories(self) -> PandasLikeSeries: + s = self.native + return self.with_native(type(s)(s.cat.categories, name=s.name)) diff --git a/shared/package-files/30/309c70245c0e6b828d962fa2c7bbd80068d1cf0e7d14b02660a1cccbd9c2df69/blob b/shared/package-files/30/309c70245c0e6b828d962fa2c7bbd80068d1cf0e7d14b02660a1cccbd9c2df69/blob new file mode 100644 index 0000000000000000000000000000000000000000..17118d2bb21ccd185780d44c83a5242b12bd2a0d --- /dev/null +++ b/shared/package-files/30/309c70245c0e6b828d962fa2c7bbd80068d1cf0e7d14b02660a1cccbd9c2df69/blob @@ -0,0 +1,63 @@ +{% block before_table %}{% endblock before_table %} +{% block table %} +{% if exclude_styles %} + +{% else %} +
+{% endif %} +{% block caption %} +{% if caption and caption is string %} + +{% elif caption and caption is sequence %} + +{% endif %} +{% endblock caption %} +{% block thead %} + +{% block before_head_rows %}{% endblock %} +{% for r in head %} +{% block head_tr scoped %} + +{% if exclude_styles %} +{% for c in r %} +{% if c.is_visible != False %} + <{{c.type}} {{c.attributes}}>{{c.display_value}} +{% endif %} +{% endfor %} +{% else %} +{% for c in r %} +{% if c.is_visible != False %} + <{{c.type}} {%- if c.id is defined %} id="T_{{uuid}}_{{c.id}}" {%- endif %} class="{{c.class}}" {{c.attributes}}>{{c.display_value}} +{% endif %} +{% endfor %} +{% endif %} + +{% endblock head_tr %} +{% endfor %} +{% block after_head_rows %}{% endblock %} + +{% endblock thead %} +{% block tbody %} + +{% block before_rows %}{% endblock before_rows %} +{% for r in body %} +{% block tr scoped %} + +{% if exclude_styles %} +{% for c in r %}{% if c.is_visible != False %} + <{{c.type}} {{c.attributes}}>{{c.display_value}} +{% endif %}{% endfor %} +{% else %} +{% for c in r %}{% if c.is_visible != False %} + <{{c.type}} {%- if c.id is defined %} id="T_{{uuid}}_{{c.id}}" {%- endif %} class="{{c.class}}" {{c.attributes}}>{{c.display_value}} +{% endif %}{% endfor %} +{% endif %} + +{% endblock tr %} +{% endfor %} +{% block after_rows %}{% endblock after_rows %} + +{% endblock tbody %} +
{{caption}}{{caption[0]}}
+{% endblock table %} +{% block after_table %}{% endblock after_table %} diff --git a/shared/package-files/30/309cec31661564791bff957247a4233ae8c360d0e314cbf10396c64757858b52/blob b/shared/package-files/30/309cec31661564791bff957247a4233ae8c360d0e314cbf10396c64757858b52/blob new file mode 100644 index 0000000000000000000000000000000000000000..410ba97addc361f48364faef9bf8a941cb873adf --- /dev/null +++ b/shared/package-files/30/309cec31661564791bff957247a4233ae8c360d0e314cbf10396c64757858b52/blob @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautogradnonfunctional { + +TORCH_API at::Tensor bitwise_and(const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & bitwise_and_(at::Tensor & self, const at::Tensor & other); + +} // namespace compositeexplicitautogradnonfunctional +} // namespace at diff --git a/shared/package-files/30/309e1c9d40d9583ad70a9622fa424ba9ed47a73276e0332d36cc037ae4a75427/blob b/shared/package-files/30/309e1c9d40d9583ad70a9622fa424ba9ed47a73276e0332d36cc037ae4a75427/blob new file mode 100644 index 0000000000000000000000000000000000000000..3b676cce2a71e7035a1c5c42130cdd0a5e96ad59 --- /dev/null +++ b/shared/package-files/30/309e1c9d40d9583ad70a9622fa424ba9ed47a73276e0332d36cc037ae4a75427/blob @@ -0,0 +1,552 @@ +""" + pygments.lexers.robotframework + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + Lexer for Robot Framework. + + :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS. + :license: BSD, see LICENSE for details. +""" + +# Copyright 2012 Nokia Siemens Networks Oyj +# +# 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 re + +from pygments.lexer import Lexer +from pygments.token import Token + +__all__ = ['RobotFrameworkLexer'] + + +HEADING = Token.Generic.Heading +SETTING = Token.Keyword.Namespace +IMPORT = Token.Name.Namespace +TC_KW_NAME = Token.Generic.Subheading +KEYWORD = Token.Name.Function +ARGUMENT = Token.String +VARIABLE = Token.Name.Variable +COMMENT = Token.Comment +SEPARATOR = Token.Punctuation +SYNTAX = Token.Punctuation +GHERKIN = Token.Generic.Emph +ERROR = Token.Error + + +def normalize(string, remove=''): + string = string.lower() + for char in remove + ' ': + if char in string: + string = string.replace(char, '') + return string + + +class RobotFrameworkLexer(Lexer): + """ + For Robot Framework test data. + + Supports both space and pipe separated plain text formats. + + .. versionadded:: 1.6 + """ + name = 'RobotFramework' + url = 'http://robotframework.org' + aliases = ['robotframework'] + filenames = ['*.robot', '*.resource'] + mimetypes = ['text/x-robotframework'] + + def __init__(self, **options): + options['tabsize'] = 2 + options['encoding'] = 'UTF-8' + Lexer.__init__(self, **options) + + def get_tokens_unprocessed(self, text): + row_tokenizer = RowTokenizer() + var_tokenizer = VariableTokenizer() + index = 0 + for row in text.splitlines(): + for value, token in row_tokenizer.tokenize(row): + for value, token in var_tokenizer.tokenize(value, token): + if value: + yield index, token, str(value) + index += len(value) + + +class VariableTokenizer: + + def tokenize(self, string, token): + var = VariableSplitter(string, identifiers='$@%&') + if var.start < 0 or token in (COMMENT, ERROR): + yield string, token + return + for value, token in self._tokenize(var, string, token): + if value: + yield value, token + + def _tokenize(self, var, string, orig_token): + before = string[:var.start] + yield before, orig_token + yield var.identifier + '{', SYNTAX + yield from self.tokenize(var.base, VARIABLE) + yield '}', SYNTAX + if var.index is not None: + yield '[', SYNTAX + yield from self.tokenize(var.index, VARIABLE) + yield ']', SYNTAX + yield from self.tokenize(string[var.end:], orig_token) + + +class RowTokenizer: + + def __init__(self): + self._table = UnknownTable() + self._splitter = RowSplitter() + testcases = TestCaseTable() + settings = SettingTable(testcases.set_default_template) + variables = VariableTable() + keywords = KeywordTable() + self._tables = {'settings': settings, 'setting': settings, + 'metadata': settings, + 'variables': variables, 'variable': variables, + 'testcases': testcases, 'testcase': testcases, + 'tasks': testcases, 'task': testcases, + 'keywords': keywords, 'keyword': keywords, + 'userkeywords': keywords, 'userkeyword': keywords} + + def tokenize(self, row): + commented = False + heading = False + for index, value in enumerate(self._splitter.split(row)): + # First value, and every second after that, is a separator. + index, separator = divmod(index-1, 2) + if value.startswith('#'): + commented = True + elif index == 0 and value.startswith('*'): + self._table = self._start_table(value) + heading = True + yield from self._tokenize(value, index, commented, + separator, heading) + self._table.end_row() + + def _start_table(self, header): + name = normalize(header, remove='*') + return self._tables.get(name, UnknownTable()) + + def _tokenize(self, value, index, commented, separator, heading): + if commented: + yield value, COMMENT + elif separator: + yield value, SEPARATOR + elif heading: + yield value, HEADING + else: + yield from self._table.tokenize(value, index) + + +class RowSplitter: + _space_splitter = re.compile('( {2,})') + _pipe_splitter = re.compile(r'((?:^| +)\|(?: +|$))') + + def split(self, row): + splitter = (row.startswith('| ') and self._split_from_pipes + or self._split_from_spaces) + yield from splitter(row) + yield '\n' + + def _split_from_spaces(self, row): + yield '' # Start with (pseudo)separator similarly as with pipes + yield from self._space_splitter.split(row) + + def _split_from_pipes(self, row): + _, separator, rest = self._pipe_splitter.split(row, 1) + yield separator + while self._pipe_splitter.search(rest): + cell, separator, rest = self._pipe_splitter.split(rest, 1) + yield cell + yield separator + yield rest + + +class Tokenizer: + _tokens = None + + def __init__(self): + self._index = 0 + + def tokenize(self, value): + values_and_tokens = self._tokenize(value, self._index) + self._index += 1 + if isinstance(values_and_tokens, type(Token)): + values_and_tokens = [(value, values_and_tokens)] + return values_and_tokens + + def _tokenize(self, value, index): + index = min(index, len(self._tokens) - 1) + return self._tokens[index] + + def _is_assign(self, value): + if value.endswith('='): + value = value[:-1].strip() + var = VariableSplitter(value, identifiers='$@&') + return var.start == 0 and var.end == len(value) + + +class Comment(Tokenizer): + _tokens = (COMMENT,) + + +class Setting(Tokenizer): + _tokens = (SETTING, ARGUMENT) + _keyword_settings = ('suitesetup', 'suiteprecondition', 'suiteteardown', + 'suitepostcondition', 'testsetup', 'tasksetup', 'testprecondition', + 'testteardown','taskteardown', 'testpostcondition', 'testtemplate', 'tasktemplate') + _import_settings = ('library', 'resource', 'variables') + _other_settings = ('documentation', 'metadata', 'forcetags', 'defaulttags', + 'testtimeout','tasktimeout') + _custom_tokenizer = None + + def __init__(self, template_setter=None): + Tokenizer.__init__(self) + self._template_setter = template_setter + + def _tokenize(self, value, index): + if index == 1 and self._template_setter: + self._template_setter(value) + if index == 0: + normalized = normalize(value) + if normalized in self._keyword_settings: + self._custom_tokenizer = KeywordCall(support_assign=False) + elif normalized in self._import_settings: + self._custom_tokenizer = ImportSetting() + elif normalized not in self._other_settings: + return ERROR + elif self._custom_tokenizer: + return self._custom_tokenizer.tokenize(value) + return Tokenizer._tokenize(self, value, index) + + +class ImportSetting(Tokenizer): + _tokens = (IMPORT, ARGUMENT) + + +class TestCaseSetting(Setting): + _keyword_settings = ('setup', 'precondition', 'teardown', 'postcondition', + 'template') + _import_settings = () + _other_settings = ('documentation', 'tags', 'timeout') + + def _tokenize(self, value, index): + if index == 0: + type = Setting._tokenize(self, value[1:-1], index) + return [('[', SYNTAX), (value[1:-1], type), (']', SYNTAX)] + return Setting._tokenize(self, value, index) + + +class KeywordSetting(TestCaseSetting): + _keyword_settings = ('teardown',) + _other_settings = ('documentation', 'arguments', 'return', 'timeout', 'tags') + + +class Variable(Tokenizer): + _tokens = (SYNTAX, ARGUMENT) + + def _tokenize(self, value, index): + if index == 0 and not self._is_assign(value): + return ERROR + return Tokenizer._tokenize(self, value, index) + + +class KeywordCall(Tokenizer): + _tokens = (KEYWORD, ARGUMENT) + + def __init__(self, support_assign=True): + Tokenizer.__init__(self) + self._keyword_found = not support_assign + self._assigns = 0 + + def _tokenize(self, value, index): + if not self._keyword_found and self._is_assign(value): + self._assigns += 1 + return SYNTAX # VariableTokenizer tokenizes this later. + if self._keyword_found: + return Tokenizer._tokenize(self, value, index - self._assigns) + self._keyword_found = True + return GherkinTokenizer().tokenize(value, KEYWORD) + + +class GherkinTokenizer: + _gherkin_prefix = re.compile('^(Given|When|Then|And|But) ', re.IGNORECASE) + + def tokenize(self, value, token): + match = self._gherkin_prefix.match(value) + if not match: + return [(value, token)] + end = match.end() + return [(value[:end], GHERKIN), (value[end:], token)] + + +class TemplatedKeywordCall(Tokenizer): + _tokens = (ARGUMENT,) + + +class ForLoop(Tokenizer): + + def __init__(self): + Tokenizer.__init__(self) + self._in_arguments = False + + def _tokenize(self, value, index): + token = self._in_arguments and ARGUMENT or SYNTAX + if value.upper() in ('IN', 'IN RANGE'): + self._in_arguments = True + return token + + +class _Table: + _tokenizer_class = None + + def __init__(self, prev_tokenizer=None): + self._tokenizer = self._tokenizer_class() + self._prev_tokenizer = prev_tokenizer + self._prev_values_on_row = [] + + def tokenize(self, value, index): + if self._continues(value, index): + self._tokenizer = self._prev_tokenizer + yield value, SYNTAX + else: + yield from self._tokenize(value, index) + self._prev_values_on_row.append(value) + + def _continues(self, value, index): + return value == '...' and all(self._is_empty(t) + for t in self._prev_values_on_row) + + def _is_empty(self, value): + return value in ('', '\\') + + def _tokenize(self, value, index): + return self._tokenizer.tokenize(value) + + def end_row(self): + self.__init__(prev_tokenizer=self._tokenizer) + + +class UnknownTable(_Table): + _tokenizer_class = Comment + + def _continues(self, value, index): + return False + + +class VariableTable(_Table): + _tokenizer_class = Variable + + +class SettingTable(_Table): + _tokenizer_class = Setting + + def __init__(self, template_setter, prev_tokenizer=None): + _Table.__init__(self, prev_tokenizer) + self._template_setter = template_setter + + def _tokenize(self, value, index): + if index == 0 and normalize(value) == 'testtemplate': + self._tokenizer = Setting(self._template_setter) + return _Table._tokenize(self, value, index) + + def end_row(self): + self.__init__(self._template_setter, prev_tokenizer=self._tokenizer) + + +class TestCaseTable(_Table): + _setting_class = TestCaseSetting + _test_template = None + _default_template = None + + @property + def _tokenizer_class(self): + if self._test_template or (self._default_template and + self._test_template is not False): + return TemplatedKeywordCall + return KeywordCall + + def _continues(self, value, index): + return index > 0 and _Table._continues(self, value, index) + + def _tokenize(self, value, index): + if index == 0: + if value: + self._test_template = None + return GherkinTokenizer().tokenize(value, TC_KW_NAME) + if index == 1 and self._is_setting(value): + if self._is_template(value): + self._test_template = False + self._tokenizer = self._setting_class(self.set_test_template) + else: + self._tokenizer = self._setting_class() + if index == 1 and self._is_for_loop(value): + self._tokenizer = ForLoop() + if index == 1 and self._is_empty(value): + return [(value, SYNTAX)] + return _Table._tokenize(self, value, index) + + def _is_setting(self, value): + return value.startswith('[') and value.endswith(']') + + def _is_template(self, value): + return normalize(value) == '[template]' + + def _is_for_loop(self, value): + return value.startswith(':') and normalize(value, remove=':') == 'for' + + def set_test_template(self, template): + self._test_template = self._is_template_set(template) + + def set_default_template(self, template): + self._default_template = self._is_template_set(template) + + def _is_template_set(self, template): + return normalize(template) not in ('', '\\', 'none', '${empty}') + + +class KeywordTable(TestCaseTable): + _tokenizer_class = KeywordCall + _setting_class = KeywordSetting + + def _is_template(self, value): + return False + + +# Following code copied directly from Robot Framework 2.7.5. + +class VariableSplitter: + + def __init__(self, string, identifiers): + self.identifier = None + self.base = None + self.index = None + self.start = -1 + self.end = -1 + self._identifiers = identifiers + self._may_have_internal_variables = False + try: + self._split(string) + except ValueError: + pass + else: + self._finalize() + + def get_replaced_base(self, variables): + if self._may_have_internal_variables: + return variables.replace_string(self.base) + return self.base + + def _finalize(self): + self.identifier = self._variable_chars[0] + self.base = ''.join(self._variable_chars[2:-1]) + self.end = self.start + len(self._variable_chars) + if self._has_list_or_dict_variable_index(): + self.index = ''.join(self._list_and_dict_variable_index_chars[1:-1]) + self.end += len(self._list_and_dict_variable_index_chars) + + def _has_list_or_dict_variable_index(self): + return self._list_and_dict_variable_index_chars\ + and self._list_and_dict_variable_index_chars[-1] == ']' + + def _split(self, string): + start_index, max_index = self._find_variable(string) + self.start = start_index + self._open_curly = 1 + self._state = self._variable_state + self._variable_chars = [string[start_index], '{'] + self._list_and_dict_variable_index_chars = [] + self._string = string + start_index += 2 + for index, char in enumerate(string[start_index:]): + index += start_index # Giving start to enumerate only in Py 2.6+ + try: + self._state(char, index) + except StopIteration: + return + if index == max_index and not self._scanning_list_variable_index(): + return + + def _scanning_list_variable_index(self): + return self._state in [self._waiting_list_variable_index_state, + self._list_variable_index_state] + + def _find_variable(self, string): + max_end_index = string.rfind('}') + if max_end_index == -1: + raise ValueError('No variable end found') + if self._is_escaped(string, max_end_index): + return self._find_variable(string[:max_end_index]) + start_index = self._find_start_index(string, 1, max_end_index) + if start_index == -1: + raise ValueError('No variable start found') + return start_index, max_end_index + + def _find_start_index(self, string, start, end): + index = string.find('{', start, end) - 1 + if index < 0: + return -1 + if self._start_index_is_ok(string, index): + return index + return self._find_start_index(string, index+2, end) + + def _start_index_is_ok(self, string, index): + return string[index] in self._identifiers\ + and not self._is_escaped(string, index) + + def _is_escaped(self, string, index): + escaped = False + while index > 0 and string[index-1] == '\\': + index -= 1 + escaped = not escaped + return escaped + + def _variable_state(self, char, index): + self._variable_chars.append(char) + if char == '}' and not self._is_escaped(self._string, index): + self._open_curly -= 1 + if self._open_curly == 0: + if not self._is_list_or_dict_variable(): + raise StopIteration + self._state = self._waiting_list_variable_index_state + elif char in self._identifiers: + self._state = self._internal_variable_start_state + + def _is_list_or_dict_variable(self): + return self._variable_chars[0] in ('@','&') + + def _internal_variable_start_state(self, char, index): + self._state = self._variable_state + if char == '{': + self._variable_chars.append(char) + self._open_curly += 1 + self._may_have_internal_variables = True + else: + self._variable_state(char, index) + + def _waiting_list_variable_index_state(self, char, index): + if char != '[': + raise StopIteration + self._list_and_dict_variable_index_chars.append(char) + self._state = self._list_variable_index_state + + def _list_variable_index_state(self, char, index): + self._list_and_dict_variable_index_chars.append(char) + if char == ']': + raise StopIteration diff --git a/shared/package-files/30/309e2bf8d61117d8126642c9be262aec37a2a327e021633d12b22409abcd00d5/blob b/shared/package-files/30/309e2bf8d61117d8126642c9be262aec37a2a327e021633d12b22409abcd00d5/blob new file mode 100644 index 0000000000000000000000000000000000000000..f044281ac17c9cce38e51df4824fad7cb4764c9c --- /dev/null +++ b/shared/package-files/30/309e2bf8d61117d8126642c9be262aec37a2a327e021633d12b22409abcd00d5/blob @@ -0,0 +1,51 @@ +"""Backends with which array-api-extra interacts in delegation and testing.""" + +from collections.abc import Callable +from enum import Enum +from types import ModuleType +from typing import cast + +from ._utils import _compat + +__all__ = ["Backend"] + + +class Backend(Enum): # numpydoc ignore=PR01,PR02 # type: ignore[no-subclass-any] + """ + All array library backends explicitly tested by array-api-extra. + + Parameters + ---------- + value : str + Name of the backend's module. + is_namespace : Callable[[ModuleType], bool] + Function to check whether an input module is the array namespace + corresponding to the backend. + """ + + ARRAY_API_STRICT = "array_api_strict", _compat.is_array_api_strict_namespace + NUMPY = "numpy", _compat.is_numpy_namespace + NUMPY_READONLY = "numpy_readonly", _compat.is_numpy_namespace + CUPY = "cupy", _compat.is_cupy_namespace + TORCH = "torch", _compat.is_torch_namespace + DASK = "dask.array", _compat.is_dask_namespace + SPARSE = "sparse", _compat.is_pydata_sparse_namespace + JAX = "jax.numpy", _compat.is_jax_namespace + + def __new__( + cls, value: str, _is_namespace: Callable[[ModuleType], bool] + ): # numpydoc ignore=GL08 + obj = object.__new__(cls) + obj._value_ = value + return obj + + def __init__( + self, + value: str, # noqa: ARG002 # pylint: disable=unused-argument + is_namespace: Callable[[ModuleType], bool], + ): # numpydoc ignore=GL08 + self.is_namespace = is_namespace + + def __str__(self) -> str: # type: ignore[explicit-override] # pyright: ignore[reportImplicitOverride] # numpydoc ignore=RT01 + """Pretty-print parameterized test names.""" + return cast(str, self.value) diff --git a/shared/package-files/30/30a142a48e57f194ecc3aa9243930f3e6e1b4e8b331a8cdd2705ec9c280dccbb/blob b/shared/package-files/30/30a142a48e57f194ecc3aa9243930f3e6e1b4e8b331a8cdd2705ec9c280dccbb/blob new file mode 100644 index 0000000000000000000000000000000000000000..4abb90ca04180622396b6ffb11f5876b9245900a --- /dev/null +++ b/shared/package-files/30/30a142a48e57f194ecc3aa9243930f3e6e1b4e8b331a8cdd2705ec9c280dccbb/blob @@ -0,0 +1,39 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset ta DAYS_OF_WEEK_FULL [list \ + "\u0b9e\u0bbe\u0baf\u0bbf\u0bb1\u0bc1"\ + "\u0ba4\u0bbf\u0b99\u0bcd\u0b95\u0bb3\u0bcd"\ + "\u0b9a\u0bc6\u0bb5\u0bcd\u0bb5\u0bbe\u0baf\u0bcd"\ + "\u0baa\u0bc1\u0ba4\u0ba9\u0bcd"\ + "\u0bb5\u0bbf\u0baf\u0bbe\u0bb4\u0ba9\u0bcd"\ + "\u0bb5\u0bc6\u0bb3\u0bcd\u0bb3\u0bbf"\ + "\u0b9a\u0ba9\u0bbf"] + ::msgcat::mcset ta MONTHS_ABBREV [list \ + "\u0b9c\u0ba9\u0bb5\u0bb0\u0bbf"\ + "\u0baa\u0bc6\u0baa\u0bcd\u0bb0\u0bb5\u0bb0\u0bbf"\ + "\u0bae\u0bbe\u0bb0\u0bcd\u0b9a\u0bcd"\ + "\u0b8f\u0baa\u0bcd\u0bb0\u0bb2\u0bcd"\ + "\u0bae\u0bc7"\ + "\u0b9c\u0bc2\u0ba9\u0bcd"\ + "\u0b9c\u0bc2\u0bb2\u0bc8"\ + "\u0b86\u0b95\u0bb8\u0bcd\u0b9f\u0bcd"\ + "\u0b9a\u0bc6\u0baa\u0bcd\u0b9f\u0bae\u0bcd\u0baa\u0bb0\u0bcd"\ + "\u0b85\u0b95\u0bcd\u0b9f\u0bcb\u0baa\u0bb0\u0bcd"\ + "\u0ba8\u0bb5\u0bae\u0bcd\u0baa\u0bb0\u0bcd"\ + "\u0b9f\u0bbf\u0b9a\u0bae\u0bcd\u0baa\u0bb0\u0bcdr"] + ::msgcat::mcset ta MONTHS_FULL [list \ + "\u0b9c\u0ba9\u0bb5\u0bb0\u0bbf"\ + "\u0baa\u0bc6\u0baa\u0bcd\u0bb0\u0bb5\u0bb0\u0bbf"\ + "\u0bae\u0bbe\u0bb0\u0bcd\u0b9a\u0bcd"\ + "\u0b8f\u0baa\u0bcd\u0bb0\u0bb2\u0bcd"\ + "\u0bae\u0bc7"\ + "\u0b9c\u0bc2\u0ba9\u0bcd"\ + "\u0b9c\u0bc2\u0bb2\u0bc8"\ + "\u0b86\u0b95\u0bb8\u0bcd\u0b9f\u0bcd"\ + "\u0b9a\u0bc6\u0baa\u0bcd\u0b9f\u0bae\u0bcd\u0baa\u0bb0\u0bcd"\ + "\u0b85\u0b95\u0bcd\u0b9f\u0bcb\u0baa\u0bb0\u0bcd"\ + "\u0ba8\u0bb5\u0bae\u0bcd\u0baa\u0bb0\u0bcd"\ + "\u0b9f\u0bbf\u0b9a\u0bae\u0bcd\u0baa\u0bb0\u0bcdr"] + ::msgcat::mcset ta AM "\u0b95\u0bbf\u0bae\u0bc1" + ::msgcat::mcset ta PM "\u0b95\u0bbf\u0baa\u0bbf" +} diff --git a/shared/package-files/30/30a32467913e69920e6d62689b9535fb825c28c114bb292428336cd6d724a363/blob b/shared/package-files/30/30a32467913e69920e6d62689b9535fb825c28c114bb292428336cd6d724a363/blob new file mode 100644 index 0000000000000000000000000000000000000000..23babea287e316dc056f97b2e53fcdcd4460dfe3 --- /dev/null +++ b/shared/package-files/30/30a32467913e69920e6d62689b9535fb825c28c114bb292428336cd6d724a363/blob @@ -0,0 +1,116 @@ +import sys +from builtins import open as _builtin_open +from os import PathLike +from token import * # noqa: F403 +from typing import ( + Any, + Callable, + Dict, + Generator, + Iterable, + List, + NamedTuple, + Optional, + Pattern, + Sequence, + Set, + TextIO, + Tuple, + Union, +) + +if sys.version_info < (3, 7): + COMMENT: int + NL: int + ENCODING: int + +cookie_re: Pattern[str] +blank_re: Pattern[bytes] + +_Position = Tuple[int, int] + +class _TokenInfo(NamedTuple): + type: int + string: str + start: _Position + end: _Position + line: str + +class TokenInfo(_TokenInfo): + @property + def exact_type(self) -> int: ... + +# Backwards compatible tokens can be sequences of a shorter length too +_Token = Union[TokenInfo, Sequence[Union[int, str, _Position]]] + +class TokenError(Exception): ... +class StopTokenizing(Exception): ... # undocumented + +class Untokenizer: + tokens: List[str] + prev_row: int + prev_col: int + encoding: Optional[str] + def __init__(self) -> None: ... + def add_whitespace(self, start: _Position) -> None: ... + def untokenize(self, iterable: Iterable[_Token]) -> str: ... + def compat(self, token: Sequence[Union[int, str]], iterable: Iterable[_Token]) -> None: ... + +# the docstring says "returns bytes" but is incorrect -- +# if the ENCODING token is missing, it skips the encode +def untokenize(iterable: Iterable[_Token]) -> Any: ... +def detect_encoding(readline: Callable[[], bytes]) -> Tuple[str, Sequence[bytes]]: ... +def tokenize(readline: Callable[[], bytes]) -> Generator[TokenInfo, None, None]: ... +def generate_tokens(readline: Callable[[], str]) -> Generator[TokenInfo, None, None]: ... # undocumented +def open(filename: Union[str, bytes, int, PathLike[Any]]) -> TextIO: ... +def group(*choices: str) -> str: ... # undocumented +def any(*choices: str) -> str: ... # undocumented +def maybe(*choices: str) -> str: ... # undocumented + +Whitespace: str # undocumented +Comment: str # undocumented +Ignore: str # undocumented +Name: str # undocumented + +Hexnumber: str # undocumented +Binnumber: str # undocumented +Octnumber: str # undocumented +Decnumber: str # undocumented +Intnumber: str # undocumented +Exponent: str # undocumented +Pointfloat: str # undocumented +Expfloat: str # undocumented +Floatnumber: str # undocumented +Imagnumber: str # undocumented +Number: str # undocumented + +def _all_string_prefixes() -> Set[str]: ... # undocumented + +StringPrefix: str # undocumented + +Single: str # undocumented +Double: str # undocumented +Single3: str # undocumented +Double3: str # undocumented +Triple: str # undocumented +String: str # undocumented + +if sys.version_info < (3, 7): + Operator: str # undocumented + Bracket: str # undocumented + +Special: str # undocumented +Funny: str # undocumented + +PlainToken: str # undocumented +Token: str # undocumented + +ContStr: str # undocumented +PseudoExtras: str # undocumented +PseudoToken: str # undocumented + +endpats: Dict[str, str] # undocumented +single_quoted: Set[str] # undocumented +triple_quoted: Set[str] # undocumented + +tabsize: int # undocumented diff --git a/shared/package-files/30/30a5d57c0e7d32727a1ff7fd6624bb383f43690bfe34ff2deede7754f17eb1b4/blob b/shared/package-files/30/30a5d57c0e7d32727a1ff7fd6624bb383f43690bfe34ff2deede7754f17eb1b4/blob new file mode 100644 index 0000000000000000000000000000000000000000..2d9e4a24331ef088b811e41b5b323479863288a5 --- /dev/null +++ b/shared/package-files/30/30a5d57c0e7d32727a1ff7fd6624bb383f43690bfe34ff2deede7754f17eb1b4/blob @@ -0,0 +1,787 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +namespace c10 { + +DispatchKey computeDispatchKey( + c10::optional dtype, + c10::optional layout, + c10::optional device); + +inline ScalarType dtype_or_default(c10::optional dtype) { + return value_or_else(dtype, [] { return get_default_dtype_as_scalartype(); }); +} + +inline caffe2::TypeMeta dtype_or_default( + c10::optional dtype) { + return value_or_else(dtype, [] { return get_default_dtype(); }); +} + +inline Layout layout_or_default(c10::optional layout) { + return layout.value_or(kStrided); +} + +inline Device device_or_default(c10::optional device) { + return value_or_else(device, [] { return Device(kCPU); }); +} + +inline bool pinned_memory_or_default(c10::optional pinned_memory) { + return pinned_memory.value_or(false); +} + +/// A class to encapsulate construction axes of an Tensor. TensorOptions was +/// designed to support the Python style API for specifying construction options +/// on factory functions, e.g., +/// +/// torch.zeros(2, 3, dtype=torch.int32) +/// +/// Because C++ doesn't natively support keyword arguments, there must be +/// another way of specifying keyword-like arguments. TensorOptions is a +/// builder class which can be used to construct this "dictionary" of keyword +/// arguments: functions which support TensorOptions conventionally take this +/// argument optionally as their last argument. +/// +/// WARNING: In PyTorch, there are `torch::` variants of factory functions, +/// e.g., torch::zeros for at::zeros. These return Variables (while the +/// stock ATen functions return plain Tensors). If you mix these functions +/// up, you WILL BE SAD. +/// +/// Rather than use the constructor of this class directly, you should prefer to +/// use the constructor functions, and then chain setter methods on top of them. +/// +/// at::device(at::kCUDA).dtype(kInt) +/// at::dtype(at::kInt) +/// +/// Additionally, anywhere a TensorOptions is expected, you can directly +/// pass at::kCUDA / at::kInt, and it will implicitly convert to a +/// TensorOptions. +/// +/// Here are some recommended ways to create a 2x2 tensor of zeros +/// with certain properties. These all *implicitly* make use of +/// TensorOptions, even if they don't mention the class explicitly: +/// +/// at::zeros({2,2}, at::kCUDA); +/// at::zeros({2,2}, at::kLong); +/// at::zeros({2,2}, at::device(at::kCUDA).dtype(at::kLong())); +/// at::zeros({2,2}, at::device({at::kCUDA, 1})); // place on device 1 +/// at::zeros({2,2}, at::requires_grad()); +/// + +/// NOTE [ TensorOptions Constructors ] +/// +/// TensorOptions is like a dictionary with entries from the set: +/// {requires_grad, device, dtype, layout}, where each entry may be +/// unspecified (i.e., is optional). It is used to specify the properties of +/// tensors in many places both in C++ internal and API, e.g., tensor factory +/// methods like `at::empty({10}, options)`, tensor conversions like +/// `tensor.to(...)`, etc. +/// +/// To provide a simple API that is consistent with Python, where one can do +/// `torch.empty(sizes, X)` with `X` being a `torch.device`, `torch.dtype`, or a +/// `torch.layout`, we want TensorOptions to be implicitly convertible from +/// `ScalarType dtype`, `Layout layout` and `Device device`. Therefore, we have +/// three implicit constructors from each of these three types. +/// +/// This is sufficient for `ScalarType` and `Layout` as they are simple Enum +/// classes. However, `Device` is an ordinary class with implicit constructors +/// `Device(DeviceType, DeviceIndex = -1)` and `Device(std::string)` to be +/// consistent with Python API, where strings are treated as equivalent with a +/// `torch.device` object (e.g., "cuda:1" can be passed to everywhere a +/// `torch.device("cuda:1")` is accepted). To support the syntax +/// `at::empty({10}, {kCUDA, 1})` and `tensor.to(kCUDA)`, we need to make sure +/// that `TensorOptions` is implicitly constructible with any arguments that a +/// `Device` can constructed from. So we have, +/// +/// /* implicit */ TensorOptions(T&& device) : TensorOptions() { +/// this->set_device(device); +/// } +/// +/// template ::value>> +/// /* implicit */ TensorOptions(Args&&... args) +/// : TensorOptions(Device(std::forward(args)...)) {} +/// +/// +/// But this will be problematic. Consider this: `TensorOptions({kCUDA, 1})`. +/// Compiler will complain about ambiguity between the copy constructor and the +/// `Device` constructor because `{kCUDA, 1}` can be converted to both a +/// `TensorOption` and a `Device`. +/// +/// To get around this, we templatize the `Device` constructor. Since overload +/// resolution is done before template resolution, our problem is solved. + +DispatchKey computeDispatchKey( + optional dtype, + optional layout, + optional device); + +struct C10_API TensorOptions { + TensorOptions() + : requires_grad_(false), + pinned_memory_(false), + has_device_(false), + has_dtype_(false), + has_layout_(false), + has_requires_grad_(false), + has_pinned_memory_(false), + has_memory_format_(false) {} + + /// Constructs a `TensorOptions` object with the given layout. + /* implicit */ TensorOptions(Layout layout) : TensorOptions() { + this->set_layout(layout); + } + + /// Constructs a `TensorOptions` object with the given device. + /// See NOTE [ TensorOptions Constructors ] on why this is templatized. + template < + typename T, + typename = std::enable_if_t, Device>>> + /* implicit */ TensorOptions(T&& device) : TensorOptions() { + this->set_device(std::forward(device)); + } + + /// Constructs a `TensorOptions` object from arguments allowed in `Device` + /// constructors. + /// + /// See NOTE [ TensorOptions Constructors ]. + /// + /// NB: Ideally we only allow implicit constructors here. But there is no easy + /// way to detect them. So we have this one that allows explicit + /// constructors too. + template < + typename... Args, + typename = std::enable_if_t>> + /* implicit */ TensorOptions(Args&&... args) + : TensorOptions(Device(std::forward(args)...)) {} + + /// Constructs a `TensorOptions` object with the given dtype. + /* implicit */ TensorOptions(caffe2::TypeMeta dtype) : TensorOptions() { + this->set_dtype(dtype); + } + + /// legacy constructor to support ScalarType + /* implicit */ TensorOptions(ScalarType dtype) : TensorOptions() { + this->set_dtype(dtype); + } + + /// Constructs a `TensorOptions` object with the given memory format. + /* implicit */ TensorOptions(MemoryFormat memory_format) : TensorOptions() { + set_memory_format(memory_format); + } + + /// Return a copy of `TensorOptions` with `device` set to the given one, or + /// cleared if `device` is `nullopt`. + C10_NODISCARD TensorOptions + device(c10::optional device) const noexcept { + TensorOptions r = *this; + r.set_device(device); + return r; + } + + /// Return a copy of `TensorOptions` with `device` set to the given one. + /// (This overload ensures that variadic template c10::optional constructor + /// for Device work correctly.) + template + C10_NODISCARD TensorOptions device(Args&&... args) const noexcept { + return device( + c10::optional(std::in_place, std::forward(args)...)); + } + + /// Return a copy of `TensorOptions`, but with device set to CUDA, and the + /// device index set to the given one. + /// + /// TODO: This function encourages bad behavior (assuming CUDA is + /// the only device that matters). Get rid of it / rename it. + C10_NODISCARD TensorOptions + device_index(c10::DeviceIndex device_index) const noexcept { + return device(Device::Type::CUDA, device_index); + } + + /// Return a copy of `TensorOptions` with `dtype` set to the given one. + C10_NODISCARD TensorOptions + dtype(c10::optional dtype) const noexcept { + TensorOptions r = *this; + r.set_dtype(dtype); + return r; + } + + // legacy function to support ScalarType + C10_NODISCARD TensorOptions + dtype(c10::optional dtype) const noexcept { + TensorOptions r = *this; + r.set_dtype(dtype); + return r; + } + + // Since dtype is taken... + template + TensorOptions& dtype() { + dtype_ = caffe2::TypeMeta::Make(); + has_dtype_ = true; + return *this; + } + + /// Sets the layout of the `TensorOptions`. + C10_NODISCARD TensorOptions + layout(c10::optional layout) const noexcept { + TensorOptions r = *this; + r.set_layout(layout); + return r; + } + + /// Sets the `requires_grad` property of the `TensorOptions`. + C10_NODISCARD TensorOptions + requires_grad(c10::optional requires_grad) const noexcept { + TensorOptions r = *this; + r.set_requires_grad(requires_grad); + return r; + } + + /// Sets the `pinned_memory` property on the `TensorOptions`. + C10_NODISCARD TensorOptions + pinned_memory(c10::optional pinned_memory) const noexcept { + TensorOptions r = *this; + r.set_pinned_memory(pinned_memory); + return r; + } + + /// Sets the `memory_format` property on `TensorOptions`. + C10_NODISCARD TensorOptions + memory_format(c10::optional memory_format) const noexcept { + TensorOptions r = *this; + r.set_memory_format(memory_format); + return r; + } + + /// Returns the device of the `TensorOptions`. + Device device() const noexcept { + return device_or_default(device_opt()); + } + + /// Returns whether the device is specified. + bool has_device() const noexcept { + return has_device_; + } + + /// Returns the device of the `TensorOptions`, or `c10::nullopt` if + /// device is not specified. + c10::optional device_opt() const noexcept { + return has_device_ ? c10::make_optional(device_) : c10::nullopt; + } + + /// Returns the device index of the `TensorOptions`. + c10::DeviceIndex device_index() const noexcept { + return device().index(); + } + + /// Returns the dtype of the `TensorOptions`. + caffe2::TypeMeta dtype() const noexcept { + return dtype_or_default(dtype_opt()); + } + + /// Returns whether the dtype is specified. + bool has_dtype() const noexcept { + return has_dtype_; + } + + /// Returns the dtype of the `TensorOptions`, or `c10::nullopt` if + /// device is not specified. + c10::optional dtype_opt() const noexcept { + return has_dtype_ ? c10::make_optional(dtype_) : c10::nullopt; + } + + /// Returns the layout of the `TensorOptions`. + Layout layout() const noexcept { + return layout_or_default(layout_opt()); + } + + /// Returns whether the layout is specified. + bool has_layout() const noexcept { + return has_layout_; + } + + /// Returns the layout of the `TensorOptions`, or `c10::nullopt` if + /// layout is not specified. + c10::optional layout_opt() const noexcept { + return has_layout_ ? c10::make_optional(layout_) : c10::nullopt; + } + + /// Returns the `requires_grad` property of the `TensorOptions`. + bool requires_grad() const noexcept { + return has_requires_grad_ ? requires_grad_ : false; + } + + /// Returns whether the `requires_grad` is specified. + bool has_requires_grad() const noexcept { + return has_requires_grad_; + } + + /// Returns the `requires_grad` property of the `TensorOptions`, or + /// `c10::nullopt` if `requires_grad` is not specified. + c10::optional requires_grad_opt() const noexcept { + return has_requires_grad_ ? c10::make_optional(requires_grad_) + : c10::nullopt; + } + + /// Returns the `pinned_memory` property of the `TensorOptions`. + bool pinned_memory() const noexcept { + return pinned_memory_or_default(pinned_memory_opt()); + } + + /// Returns whether the `pinned_memory` is specified. + bool has_pinned_memory() const noexcept { + return has_pinned_memory_; + } + + /// Returns if the layout is sparse + bool is_sparse() const { + return layout_ == c10::Layout::Sparse; + } + + /// Returns if the layout is sparse CSR, deprecated, use + /// is_sparse_compressed() instead + bool is_sparse_csr() const { + return layout_ == c10::Layout::SparseCsr; + } + + bool is_sparse_compressed() const { + return layout_ == c10::Layout::SparseCsr || + layout_ == c10::Layout::SparseCsc || + layout_ == c10::Layout::SparseBsr || layout_ == c10::Layout::SparseBsc; + } + + // For compatibility with legacy tensor.type() comparisons + bool type_equal(const TensorOptions& other) const { + return computeDispatchKey() == other.computeDispatchKey() && + typeMetaToScalarType(dtype_) == typeMetaToScalarType(other.dtype()); + } + + /// Returns the `pinned_memory` property of the `TensorOptions`, or + /// `c10::nullopt` if `pinned_memory` is not specified. + c10::optional pinned_memory_opt() const noexcept { + return has_pinned_memory_ ? c10::make_optional(pinned_memory_) + : c10::nullopt; + } + + /// Returns whether the `memory_layout` is specified + bool has_memory_format() const noexcept { + return has_memory_format_; + } + + // NB: memory_format() getter is PURPOSELY not defined, as the default + // behavior of memory_format varies from function to function. + + /// Returns the `memory_layout` property of `TensorOptions, or + /// `c10::nullopt` if `memory_format` is not specified. + c10::optional memory_format_opt() const noexcept { + return has_memory_format_ ? c10::make_optional(memory_format_) + : c10::nullopt; + } + + // Resolves the ATen backend specified by the current construction axes. + // TODO: Deprecate this + Backend backend() const { + return at::dispatchKeyToBackend(computeDispatchKey()); + } + + /// Return the right-biased merge of two TensorOptions. This has the + /// effect of overwriting settings from self with specified options + /// of options. + /// + /// NB: This merging operation does NOT respect device merges. + /// For example, if you device({kCUDA, 1}).merge_in(kCUDA) + /// you will get kCUDA in the end! Functions like Tensor.new_empty + /// ensure the right device is selected anyway by way of a + /// device guard. + /// + TensorOptions merge_in(TensorOptions options) const noexcept { + TensorOptions merged = *this; + if (options.has_device()) + merged.set_device(options.device_opt()); + if (options.has_dtype()) + merged.set_dtype(options.dtype_opt()); + if (options.has_layout()) + merged.set_layout(options.layout_opt()); + // NB: requires grad is right biased; not a logical AND/OR! + if (options.has_requires_grad()) + merged.set_requires_grad(options.requires_grad_opt()); + if (options.has_pinned_memory()) + merged.set_pinned_memory(options.pinned_memory_opt()); + if (options.has_memory_format()) + merged.set_memory_format(options.memory_format_opt()); + return merged; + } + + // TODO remove after TensorOptions rationalization + TensorOptions merge_memory_format( + c10::optional optional_memory_format) const noexcept { + TensorOptions merged = *this; + if (optional_memory_format.has_value()) { + merged.set_memory_format(*optional_memory_format); + } + return merged; + } + + // INVARIANT: computeDispatchKey returns only the subset of dispatch keys for + // which dispatchKeyToBackend is injective, if it is defined at all (for + // the most part, this just means that this function never returns an + // Autograd key) + DispatchKey computeDispatchKey() const { + return c10::computeDispatchKey( + optTypeMetaToScalarType(dtype_opt()), layout_opt(), device_opt()); + } + + private: + // These methods are currently private because I'm not sure if it's wise + // to actually publish them. They are methods because I need them in + // the constructor and the functional API implementation. + // + // If you really, really need it, you can make these public, but check if you + // couldn't just do what you need with the functional API. Similarly, these + // methods are not chainable, because if you wanted chaining, you probably + // want to use the functional API instead. (It's probably OK to make + // these chainable, because these functions are all explicitly annotated + // with a ref-qualifier, the trailing &, that makes them illegal to call + // on temporaries.) + + /// Mutably set the device of `TensorOptions`. + void set_device(c10::optional device) & noexcept { + if (device) { + device_ = *device; + has_device_ = true; + } else { + has_device_ = false; + } + } + + /// Mutably set the dtype of `TensorOptions`. + void set_dtype(c10::optional dtype) & noexcept { + if (dtype) { + dtype_ = *dtype; + has_dtype_ = true; + } else { + has_dtype_ = false; + } + } + + // legacy function to support ScalarType + void set_dtype(c10::optional dtype) & noexcept { + if (dtype) { + dtype_ = scalarTypeToTypeMeta(*dtype); + has_dtype_ = true; + } else { + has_dtype_ = false; + } + } + + /// Mutably set the layout of `TensorOptions`. + void set_layout(c10::optional layout) & noexcept { + if (layout) { + layout_ = *layout; + has_layout_ = true; + } else { + has_layout_ = false; + } + } + + /// Mutably set the `requires_grad` property of `TensorOptions`. + void set_requires_grad(c10::optional requires_grad) & noexcept { + if (requires_grad) { + requires_grad_ = *requires_grad; + has_requires_grad_ = true; + } else { + has_requires_grad_ = false; + } + } + + /// Mutably set the `pinned_memory` property of `TensorOptions`. + void set_pinned_memory(c10::optional pinned_memory) & noexcept { + if (pinned_memory) { + pinned_memory_ = *pinned_memory; + has_pinned_memory_ = true; + } else { + has_pinned_memory_ = false; + } + } + + /// Mutably set the `memory_Format` property of `TensorOptions`. + void set_memory_format(c10::optional memory_format) & noexcept { + if (memory_format) { + memory_format_ = *memory_format; + has_memory_format_ = true; + } else { + has_memory_format_ = false; + } + } + + // WARNING: If you edit TensorOptions to add more options, you + // may need to adjust the implementation of Tensor::options. + // The criteria for whether or not Tensor::options must be adjusted + // is whether or not the new option you added should preserved + // by functions such as empty_like(); if it should be preserved, + // you must adjust options(). + // + // TODO: MemoryFormat is not implemented in this way + + // NB: We didn't use c10::optional here, because then we can't pack + // the has_***_ boolean fields. + + Device device_ = at::kCPU; // 16-bit + caffe2::TypeMeta dtype_ = caffe2::TypeMeta::Make(); // 16-bit + Layout layout_ = at::kStrided; // 8-bit + MemoryFormat memory_format_ = MemoryFormat::Contiguous; // 8-bit + + // Bitmask required here to get this to fit inside 32 bits (or even 64 bits, + // for that matter) + + bool requires_grad_ : 1; + bool pinned_memory_ : 1; + + bool has_device_ : 1; + bool has_dtype_ : 1; + bool has_layout_ : 1; + bool has_requires_grad_ : 1; + bool has_pinned_memory_ : 1; + bool has_memory_format_ : 1; +}; + +// We should aspire to fit in one machine-size word; but a size greater than two +// words is too much. (We are doing terribly on 32-bit archs, where we require +// three machine size words to store tensor options. Eek!) +static_assert( + sizeof(TensorOptions) <= sizeof(int64_t) * 2, + "TensorOptions must fit in 128-bits"); + +/// Convenience function that returns a `TensorOptions` object with the `dtype` +/// set to the given one. +inline TensorOptions dtype(caffe2::TypeMeta dtype) { + return TensorOptions().dtype(dtype); +} + +// legacy function to support ScalarType +inline TensorOptions dtype(ScalarType dtype) { + return TensorOptions().dtype(scalarTypeToTypeMeta(dtype)); +} + +/// Convenience function that returns a `TensorOptions` object with the `layout` +/// set to the given one. +inline TensorOptions layout(Layout layout) { + return TensorOptions().layout(layout); +} + +/// Convenience function that returns a `TensorOptions` object with the `device` +/// set to the given one. +inline TensorOptions device(Device device) { + return TensorOptions().device(device); +} + +/// Convenience function that returns a `TensorOptions` object with the +/// `device` set to CUDA and the `device_index` set to the given one. +inline TensorOptions device_index(c10::DeviceIndex device_index) { + return TensorOptions().device_index(device_index); +} + +/// Convenience function that returns a `TensorOptions` object with the +/// `requires_grad` set to the given one. +inline TensorOptions requires_grad(bool requires_grad = true) { + return TensorOptions().requires_grad(requires_grad); +} + +/// Convenience function that returns a `TensorOptions` object with the +/// `memory_format` set to the given one. +inline TensorOptions memory_format(MemoryFormat memory_format) { + return TensorOptions().memory_format(memory_format); +} + +C10_API std::ostream& operator<<( + std::ostream& stream, + const TensorOptions& options); + +template +inline TensorOptions dtype() { + return dtype(caffe2::TypeMeta::Make()); +} + +inline std::string toString(const TensorOptions& options) { + std::ostringstream stream; + stream << options; + return stream.str(); +} + +// This is intended to be a centralized location by which we can determine +// what an appropriate DispatchKey for a tensor is. +inline DispatchKey computeDispatchKey( + c10::optional dtype, + c10::optional layout, + c10::optional device) { + const auto layout_ = layout_or_default(layout); + const auto device_ = device_or_default(device); + switch (layout_) { + case Layout::Jagged: + case Layout::Strided: { + const auto dtype_ = dtype_or_default(dtype); + switch (device_.type()) { +#define DO_CASE(device, _) \ + case c10::DeviceType::device: { \ + if (isQIntType(dtype_)) { \ + return DispatchKey::Quantized##device; \ + } \ + return DispatchKey::device; \ + } + C10_FORALL_BACKEND_DEVICE_TYPES(DO_CASE, unused) +#undef DO_CASE + case c10::DeviceType::FPGA: + return DispatchKey::FPGA; + case c10::DeviceType::ORT: + return DispatchKey::ORT; + case c10::DeviceType::Vulkan: + return DispatchKey::Vulkan; + case c10::DeviceType::Metal: + return DispatchKey::Metal; + case c10::DeviceType::MKLDNN: + case c10::DeviceType::OPENGL: + case c10::DeviceType::OPENCL: + case c10::DeviceType::IDEEP: + TORCH_INTERNAL_ASSERT( + 0, + "This is a grandfathered Caffe2 device type ", + device_.type(), + ", it shouldn't ever convert to a DispatchKey. File a bug describing what you were doing if you think this is in error."); + default: + TORCH_CHECK_NOT_IMPLEMENTED( + false, + "Unsupported device type for dense layout: ", + device_.type()); + } + } + case Layout::Sparse: + switch (device_.type()) { +#define DO_CASE(device, _) \ + case c10::DeviceType::device: { \ + return DispatchKey::Sparse##device; \ + } + C10_FORALL_BACKEND_DEVICE_TYPES(DO_CASE, unused) +#undef DO_CASE + default: + TORCH_CHECK_NOT_IMPLEMENTED( + false, + "Unsupported device type for sparse layout: ", + device_.type()); + } + case Layout::Mkldnn: + switch (device_.type()) { + case c10::DeviceType::CPU: + return DispatchKey::MkldnnCPU; + default: + TORCH_CHECK_NOT_IMPLEMENTED( + false, + "Unsupported device type for mkldnn layout: ", + device_.type()); + } + case Layout::SparseCsr: + case Layout::SparseCsc: + case Layout::SparseBsr: + case Layout::SparseBsc: + switch (device_.type()) { +#define DO_CASE(device, _) \ + case c10::DeviceType::device: { \ + return DispatchKey::SparseCsr##device; \ + } + C10_FORALL_BACKEND_DEVICE_TYPES(DO_CASE, unused) +#undef DO_CASE + default: + TORCH_CHECK_NOT_IMPLEMENTED( + false, + "Unsupported device type for ", + layout_, + " layout: ", + device_.type()); + } + default: + TORCH_CHECK(false, "Unsupported layout: ", layout_); + } +} + +inline Layout dispatchKeyToLayout(DispatchKey dispatch_key) { + switch (dispatch_key) { +#define DO_CASE(bc, _) case DispatchKey::Sparse##bc: + C10_FORALL_BACKEND_COMPONENTS(DO_CASE, unused) +#undef DO_CASE + return Layout::Sparse; +#define DO_CASE(bc, _) case DispatchKey::SparseCsr##bc: + C10_FORALL_BACKEND_COMPONENTS(DO_CASE, unused) +#undef DO_CASE + TORCH_CHECK( + false, "Cannot map DispatchKey ", dispatch_key, " to a unique layout."); + case DispatchKey::MkldnnCPU: + return Layout::Mkldnn; + default: + return Layout::Strided; + } +} + +inline c10::DeviceType dispatchKeyToDeviceType(DispatchKey dispatch_key) { + switch (dispatch_key) { + // stuff that's real +#define DO_CASE(suffix, prefix) \ + case DispatchKey::prefix##suffix: \ + return c10::DeviceType::suffix; +#define DO_CASES(_, prefix) C10_FORALL_BACKEND_DEVICE_TYPES(DO_CASE, prefix) + C10_FORALL_FUNCTIONALITY_KEYS(DO_CASES) +#undef DO_CASES +#undef DO_CASE + + case DispatchKey::MkldnnCPU: + return c10::DeviceType::CPU; + case DispatchKey::Vulkan: + return c10::DeviceType::Vulkan; + + case DispatchKey::ORT: + return c10::DeviceType::ORT; + default: + TORCH_CHECK( + false, + "DispatchKey ", + dispatch_key, + " doesn't correspond to a device"); + } +} + +inline TensorOptions dispatchKeyToTensorOptions(DispatchKey dispatch_key) { + return TensorOptions() + .layout(dispatchKeyToLayout(dispatch_key)) + .device(dispatchKeyToDeviceType(dispatch_key)); +} + +namespace detail { +inline bool backend_supports_empty_operator(const TensorOptions& options) { + // Quantized backends don't support at::empty(). + // They have separate operators like at::empty_quantized() that take in + // extra information about how to quantize the tensor. + return !isQIntType(typeMetaToScalarType(options.dtype())); +} + +} // namespace detail + +} // namespace c10 diff --git a/shared/package-files/30/30a92c9cde344de84f86055fc422618e3fc18cbf78ddaa6b78004a633f9b9746/blob b/shared/package-files/30/30a92c9cde344de84f86055fc422618e3fc18cbf78ddaa6b78004a633f9b9746/blob new file mode 100644 index 0000000000000000000000000000000000000000..f6f6952d605ee5fa0a25eff03f18769b6b445fae --- /dev/null +++ b/shared/package-files/30/30a92c9cde344de84f86055fc422618e3fc18cbf78ddaa6b78004a633f9b9746/blob @@ -0,0 +1,133 @@ +# ---------------------------------------------------------------------- +# ctokens.py +# +# Token specifications for symbols in ANSI C and C++. This file is +# meant to be used as a library in other tokenizers. +# ---------------------------------------------------------------------- + +# Reserved words + +tokens = [ + # Literals (identifier, integer constant, float constant, string constant, char const) + 'ID', 'TYPEID', 'INTEGER', 'FLOAT', 'STRING', 'CHARACTER', + + # Operators (+,-,*,/,%,|,&,~,^,<<,>>, ||, &&, !, <, <=, >, >=, ==, !=) + 'PLUS', 'MINUS', 'TIMES', 'DIVIDE', 'MODULO', + 'OR', 'AND', 'NOT', 'XOR', 'LSHIFT', 'RSHIFT', + 'LOR', 'LAND', 'LNOT', + 'LT', 'LE', 'GT', 'GE', 'EQ', 'NE', + + # Assignment (=, *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |=) + 'EQUALS', 'TIMESEQUAL', 'DIVEQUAL', 'MODEQUAL', 'PLUSEQUAL', 'MINUSEQUAL', + 'LSHIFTEQUAL','RSHIFTEQUAL', 'ANDEQUAL', 'XOREQUAL', 'OREQUAL', + + # Increment/decrement (++,--) + 'INCREMENT', 'DECREMENT', + + # Structure dereference (->) + 'ARROW', + + # Ternary operator (?) + 'TERNARY', + + # Delimeters ( ) [ ] { } , . ; : + 'LPAREN', 'RPAREN', + 'LBRACKET', 'RBRACKET', + 'LBRACE', 'RBRACE', + 'COMMA', 'PERIOD', 'SEMI', 'COLON', + + # Ellipsis (...) + 'ELLIPSIS', +] + +# Operators +t_PLUS = r'\+' +t_MINUS = r'-' +t_TIMES = r'\*' +t_DIVIDE = r'/' +t_MODULO = r'%' +t_OR = r'\|' +t_AND = r'&' +t_NOT = r'~' +t_XOR = r'\^' +t_LSHIFT = r'<<' +t_RSHIFT = r'>>' +t_LOR = r'\|\|' +t_LAND = r'&&' +t_LNOT = r'!' +t_LT = r'<' +t_GT = r'>' +t_LE = r'<=' +t_GE = r'>=' +t_EQ = r'==' +t_NE = r'!=' + +# Assignment operators + +t_EQUALS = r'=' +t_TIMESEQUAL = r'\*=' +t_DIVEQUAL = r'/=' +t_MODEQUAL = r'%=' +t_PLUSEQUAL = r'\+=' +t_MINUSEQUAL = r'-=' +t_LSHIFTEQUAL = r'<<=' +t_RSHIFTEQUAL = r'>>=' +t_ANDEQUAL = r'&=' +t_OREQUAL = r'\|=' +t_XOREQUAL = r'\^=' + +# Increment/decrement +t_INCREMENT = r'\+\+' +t_DECREMENT = r'--' + +# -> +t_ARROW = r'->' + +# ? +t_TERNARY = r'\?' + +# Delimeters +t_LPAREN = r'\(' +t_RPAREN = r'\)' +t_LBRACKET = r'\[' +t_RBRACKET = r'\]' +t_LBRACE = r'\{' +t_RBRACE = r'\}' +t_COMMA = r',' +t_PERIOD = r'\.' +t_SEMI = r';' +t_COLON = r':' +t_ELLIPSIS = r'\.\.\.' + +# Identifiers +t_ID = r'[A-Za-z_][A-Za-z0-9_]*' + +# Integer literal +t_INTEGER = r'\d+([uU]|[lL]|[uU][lL]|[lL][uU])?' + +# Floating literal +t_FLOAT = r'((\d+)(\.\d+)(e(\+|-)?(\d+))? | (\d+)e(\+|-)?(\d+))([lL]|[fF])?' + +# String literal +t_STRING = r'\"([^\\\n]|(\\.))*?\"' + +# Character constant 'c' or L'c' +t_CHARACTER = r'(L)?\'([^\\\n]|(\\.))*?\'' + +# Comment (C-Style) +def t_COMMENT(t): + r'/\*(.|\n)*?\*/' + t.lexer.lineno += t.value.count('\n') + return t + +# Comment (C++-Style) +def t_CPPCOMMENT(t): + r'//.*\n' + t.lexer.lineno += 1 + return t + + + + + + diff --git a/shared/package-files/30/30aa6a82e55c9b6882c41c9aaf9e9137c4c8c4545b627542d6b23ef5743b0acc/blob b/shared/package-files/30/30aa6a82e55c9b6882c41c9aaf9e9137c4c8c4545b627542d6b23ef5743b0acc/blob new file mode 100644 index 0000000000000000000000000000000000000000..e6a6551f59227bb57c93c1802bdf64846c59b2fe --- /dev/null +++ b/shared/package-files/30/30aa6a82e55c9b6882c41c9aaf9e9137c4c8c4545b627542d6b23ef5743b0acc/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:30aa6a82e55c9b6882c41c9aaf9e9137c4c8c4545b627542d6b23ef5743b0acc +size 212725134 diff --git a/shared/package-files/30/30af398778f0d1db8b0a587fd85884841b74a9fb42cb1e6be96544b180a2ba0a/blob b/shared/package-files/30/30af398778f0d1db8b0a587fd85884841b74a9fb42cb1e6be96544b180a2ba0a/blob new file mode 100644 index 0000000000000000000000000000000000000000..2223e14b8a12ea9625b017c98b8f15cbc574fb70 --- /dev/null +++ b/shared/package-files/30/30af398778f0d1db8b0a587fd85884841b74a9fb42cb1e6be96544b180a2ba0a/blob @@ -0,0 +1,26 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + + +} diff --git a/shared/package-files/30/30afdb5d7fd8fead5efce18b4d9e05584687c7ed6555b7f8c07cbcf83a17e76b/blob b/shared/package-files/30/30afdb5d7fd8fead5efce18b4d9e05584687c7ed6555b7f8c07cbcf83a17e76b/blob new file mode 100644 index 0000000000000000000000000000000000000000..26468d046f29a589d9d3d3c34babf86404fdbce0 --- /dev/null +++ b/shared/package-files/30/30afdb5d7fd8fead5efce18b4d9e05584687c7ed6555b7f8c07cbcf83a17e76b/blob @@ -0,0 +1,348 @@ +# Copyright (c) Meta Platforms, Inc. and affiliates + +import dataclasses +from typing import cast, Dict, List, Optional, Sequence, Tuple, Union + +import torch +import torch.distributed as dist +from torch._utils import _get_device_module +from torch.distributed._shard.sharded_tensor.api import ShardedTensor +from torch.distributed._shard.sharded_tensor.metadata import ( + TensorProperties as ShardTensorProperties, +) +from torch.distributed._shard.sharded_tensor.shard import Shard +from torch.distributed._shard.sharding_spec.chunk_sharding_spec import ChunkShardingSpec +from torch.distributed._tensor import DTensor +from torch.distributed.checkpoint._nested_dict import unflatten_state_dict +from torch.distributed.checkpoint.default_planner import DefaultLoadPlanner +from torch.distributed.checkpoint.metadata import ( + BytesStorageMetadata, + ChunkStorageMetadata, + Metadata, + MetadataIndex, + STATE_DICT_TYPE, + TensorProperties, + TensorStorageMetadata, +) +from torch.distributed.checkpoint.planner import LoadPlan, LoadPlanner +from torch.distributed.checkpoint.planner_helpers import ( + _create_read_items, + create_read_items_for_chunk_list, +) +from torch.distributed.checkpoint.state_dict_loader import load_state_dict +from torch.distributed.checkpoint.storage import StorageReader +from torch.distributed.checkpoint.utils import ( + _element_wise_add, + _element_wise_sub, + _normalize_device_info, +) +from torch.distributed.distributed_c10d import _get_default_group +from torch.distributed.fsdp._shard_utils import _create_chunk_sharded_tensor +from torch.distributed.remote_device import _remote_device + +STATE_DICT_2D_LAYOUT = Dict[str, Tuple[Optional[Sequence[int]], Sequence[int]]] + + +# TODO: Update docstrings for optimizer.py +__all__ = [ + "load_sharded_optimizer_state_dict", +] + + +def _gen_rank_device(global_rank: int, device_type: str = "cuda") -> str: + if device_type == "cpu": + return "cpu" + device_module = _get_device_module(device_type) + if device_module.is_available(): + return _normalize_device_info( + device_type, global_rank % device_module.device_count() + ) + return "cpu" + + +def _create_colwise_spec( + pg: Optional[dist.ProcessGroup] = None, +) -> ChunkShardingSpec: + pg_device_type = dist.distributed_c10d._get_pg_default_device(pg).type + if pg is None: + placements = [ + f"rank:{idx}/{_gen_rank_device(idx, pg_device_type)}" + for idx in range(dist.get_world_size()) + ] + else: + placements = [ + f"rank:{idx}/{_gen_rank_device(dist.get_global_rank(pg, idx), pg_device_type)}" + for idx in range(pg.size()) + ] + return ChunkShardingSpec( + dim=0, + placements=cast(List[Union[_remote_device, str]], placements), + ) + + +def _is_nested_tensor(val: torch.Tensor) -> bool: + if type(val) is ShardedTensor: + if len(val.local_shards()) == 0: + return False + if type(val.local_shards()[0].tensor) is ShardedTensor: + return True + if type(val.local_shards()[0].tensor) is DTensor: + raise ValueError("Cannot handle DTensor nested insided ShardedTensor") + elif type(val) is DTensor and ( + type(val._local_tensor) is DTensor or type(val._local_tensor) is ShardedTensor + ): + raise ValueError("Cannot handle nested DTensor") + return False + + +def _alloc_tensor( + props: TensorProperties, size: Sequence[int], device_type: str = "cuda" +) -> torch.Tensor: + return torch.empty( + size=size, + dtype=props.dtype, + layout=props.layout, + requires_grad=props.requires_grad, + pin_memory=props.pin_memory, + device=cast(torch.device, _get_device_module(device_type).current_device()), + ) + + +def _get_state_dict_2d_layout( + state_dict: STATE_DICT_TYPE, +) -> Tuple[STATE_DICT_2D_LAYOUT, Optional[dist.ProcessGroup]]: + """ + Load the right TP slice of the optimizer state. + + This is not easy since the per-tensor slicing can't be inferred from checkpoint metadata. + We take advantage of the model state_dict producing a sliced ST to figure out what we need to load. + This is pretty fragile and it might be easier for FSDP to compute this info for us. + Returns a dictionary where keys are the same of the state_dict and the value is a tuple of + (offset, size) for the current rank TP slice. + N.B. The state_dict *MUST* come from FSDP.sharded_state_dict. + """ + specs: STATE_DICT_2D_LAYOUT = {} + dp_pg: Optional[dist.ProcessGroup] = None + for key, value in state_dict.items(): + specs[key] = (None, value.size()) + if _is_nested_tensor(value): + assert ( + len(value.local_shards()) == 1 + ), "Cannot handle ST with multiple shards" + assert isinstance( + value, ShardedTensor + ), "Can only handle nested ShardedTensor" + shard = value.local_shards()[0] + specs[key] = ( + shard.metadata.shard_offsets, + shard.metadata.shard_sizes, + ) + dp_pg = shard.tensor._process_group # type: ignore[attr-defined] + + return ( + specs, + dp_pg, + ) + + +class _ReaderWithOffset(DefaultLoadPlanner): + translation: Dict[MetadataIndex, MetadataIndex] + state_dict: STATE_DICT_TYPE + metadata: Metadata + + def __init__(self, fqn_to_offset: Dict[str, Sequence[int]]) -> None: + super().__init__() + self.fqn_to_offset = fqn_to_offset + self.metadata = Metadata({}) + self.state_dict = {} + self.translation = {} + + def create_local_plan(self) -> LoadPlan: + requests = [] + self.translation = {} + for fqn, obj in self.state_dict.items(): + md = self.metadata.state_dict_metadata[fqn] + if not isinstance(obj, ShardedTensor): + requests += _create_read_items(fqn, md, obj) + continue + + if fqn not in self.fqn_to_offset: + requests += _create_read_items(fqn, md, obj) + continue + + offset = self.fqn_to_offset[fqn] + + assert len(obj.local_shards()) == 1 + original_shard = obj.local_shards()[0] + local_chunks = [ + ChunkStorageMetadata( + offsets=torch.Size( + _element_wise_add(original_shard.metadata.shard_offsets, offset) + ), + sizes=torch.Size(original_shard.metadata.shard_sizes), + ) + ] + + reqs = create_read_items_for_chunk_list( + fqn, cast(TensorStorageMetadata, md), local_chunks + ) + # TODO: The ReadItems will have a displaced MetadataIndex, fix it. + # TODO: we should change _create_sharded_read_items to have more ergonomic API + for ri in reqs: + assert ri.dest_index.offset is not None + original_offset = _element_wise_sub(ri.dest_index.offset, offset) + original_index = dataclasses.replace( + ri.dest_index, offset=torch.Size(original_offset) + ) + self.translation[ri.dest_index] = original_index + + requests += reqs + return LoadPlan(requests) + + def lookup_tensor(self, index: MetadataIndex) -> torch.Tensor: + return super().lookup_tensor(self.translation.get(index, index)) + + +def load_sharded_optimizer_state_dict( + model_state_dict: STATE_DICT_TYPE, + optimizer_key: str, + storage_reader: StorageReader, + planner: Optional[LoadPlanner] = None, +) -> STATE_DICT_TYPE: + """ + Load a state_dict in conjunction with FSDP sharded optimizer state. + + This is the current recommended way to checkpoint FSDP. + >>> # xdoctest: +SKIP + >>> import torch.distributed.checkpoint as dist_cp + >>> # Save + >>> model: torch.nn.Model + >>> optim_params = model.parameters() + >>> optim = torch.optim.SGD(optim_params, lr=0.01) + >>> # Save + >>> with FSDP.state_dict_type(model, StateDictType.SHARDED_STATE_DICT): + >>> state_dict = { + >>> "optimizer": FSDP.optim_state_dict(model, optim), + >>> "model": model.state_dict() + >>> } + >>> dist_cp.save_state_dict( + >>> state_dict=optim_state, + >>> storage_writer=dist_cp.FileSystemWriter("checkpoint"), + >>> planner=dist_cp.DefaultSavePlanner(), + >>> ) + >>> + >>> # Load + >>> with FSDP.state_dict_type(model_tp, StateDictType.SHARDED_STATE_DICT): + >>> model_state_dict = model_tp.state_dict() + >>> checkpoint = { + >>> "model": model_state_dict + >>> } + >>> dist_cp.load_state_dict( + >>> state_dict=checkpoint, + >>> storage_reader=dist_cp.FileSystemReader(checkpoint_file), + >>> planner=dist_cp.DefaultLoadPlanner(), + >>> ) + >>> model.load_state_dict(checkpoint["model_state"]) + >>> + >>> optim_state = dist_cp.load_sharded_optimizer_state_dict( + >>> model_state_dict, + >>> optimizer_key="optimizer", + >>> storage_reader=dist_cp.FileSystemReader("checkpoint"), + >>> ) + >>> + >>> flattened_osd = FSDP.optim_state_dict_to_load( + >>> model, optim, optim_state["optimizer"] + >>> ) + >>> + >>> optim.load_state_dict(flattened_osd) + """ + metadata = storage_reader.read_metadata() + + layout_specs, dp_pg = _get_state_dict_2d_layout(model_state_dict) + dp_pg_device_type = dist.distributed_c10d._get_pg_default_device(dp_pg).type + device_module = _get_device_module(dp_pg_device_type) + + if dp_pg is None: + placements = [] + for i in range(dist.get_world_size()): + device_info = _normalize_device_info( + dp_pg_device_type, i % device_module.device_count() + ) + placements.append(f"rank:{i}/{device_info}") + sharding_spec = ChunkShardingSpec(dim=0, placements=placements) # type: ignore[arg-type] + else: + sharding_spec = _create_colwise_spec(dp_pg) + + # Create a state_dict for optimizer state + state_dict: STATE_DICT_TYPE = {} + + fqn_to_offset: Dict[str, Sequence[int]] = {} + for key, value in metadata.state_dict_metadata.items(): + key_path = metadata.planner_data[key] + if key_path[0] != optimizer_key: + continue + + if isinstance(value, BytesStorageMetadata): + state_dict[key] = "" + continue + + # value: TensorStorageMetadata + if value.size.numel() == 1: + state_dict[key] = _alloc_tensor( + value.properties, value.size, dp_pg_device_type + ) + elif dp_pg is None: + state_dict[key] = _create_chunk_sharded_tensor( + _alloc_tensor(value.properties, value.size, dp_pg_device_type), + rank=dist.get_rank(), + world_size=dist.get_world_size(), + num_devices_per_node=device_module.device_count(), + pg=_get_default_group(), + ) + else: + spec_key = key_path[2] + alloc_size = layout_specs.get(spec_key, (None, value.size))[1] + + properties = ShardTensorProperties( + dtype=value.properties.dtype, + layout=value.properties.layout, + requires_grad=value.properties.requires_grad, + memory_format=value.properties.memory_format, + pin_memory=value.properties.pin_memory, + ) + + st_md = sharding_spec.build_metadata(torch.Size(alloc_size), properties) + local_shards = [] + current_rank = dist.get_rank(dp_pg) + for shard_md in st_md.shards_metadata: + if cast(_remote_device, shard_md.placement).rank() != current_rank: + continue + local_shards.append( + Shard( + tensor=_alloc_tensor( + value.properties, shard_md.shard_sizes, dp_pg_device_type + ), + metadata=shard_md, + ) + ) + + st = ShardedTensor._init_from_local_shards_and_global_metadata( + local_shards, st_md, process_group=dp_pg + ) + + if spec_key in layout_specs and layout_specs[spec_key][0] is not None: + fqn_to_offset[key] = cast(Sequence[int], layout_specs[spec_key][0]) + + state_dict[key] = st + + # Whether we unflatten before or after doesn't matter + load_state_dict( + state_dict=state_dict, + storage_reader=storage_reader, + # FIXME the type of planner is wrong in load_state_dict + planner=_ReaderWithOffset(fqn_to_offset) if dp_pg is not None else planner, + ) + + state_dict = unflatten_state_dict(state_dict, metadata.planner_data) + + return state_dict diff --git a/shared/package-files/30/30b0e9f5c3f693a51e504372849281ca79f04d2a149df006f89df64ee70e6699/blob b/shared/package-files/30/30b0e9f5c3f693a51e504372849281ca79f04d2a149df006f89df64ee70e6699/blob new file mode 100644 index 0000000000000000000000000000000000000000..9ff9fc89800d7bcd04a0a9d202d828a2079a6f28 --- /dev/null +++ b/shared/package-files/30/30b0e9f5c3f693a51e504372849281ca79f04d2a149df006f89df64ee70e6699/blob @@ -0,0 +1,43 @@ +from ...utils._typedefs cimport float32_t, float64_t, intp_t, uint8_t, uint32_t + + +ctypedef float64_t X_DTYPE_C +ctypedef uint8_t X_BINNED_DTYPE_C +ctypedef float64_t Y_DTYPE_C +ctypedef float32_t G_H_DTYPE_C +ctypedef uint32_t BITSET_INNER_DTYPE_C +ctypedef BITSET_INNER_DTYPE_C[8] BITSET_DTYPE_C + + +cdef packed struct hist_struct: + # Same as histogram dtype but we need a struct to declare views. It needs + # to be packed since by default numpy dtypes aren't aligned + Y_DTYPE_C sum_gradients + Y_DTYPE_C sum_hessians + unsigned int count + + +cdef packed struct node_struct: + # Equivalent struct to PREDICTOR_RECORD_DTYPE to use in memory views. It + # needs to be packed since by default numpy dtypes aren't aligned + Y_DTYPE_C value + unsigned int count + intp_t feature_idx + X_DTYPE_C num_threshold + uint8_t missing_go_to_left + unsigned int left + unsigned int right + Y_DTYPE_C gain + unsigned int depth + uint8_t is_leaf + X_BINNED_DTYPE_C bin_threshold + uint8_t is_categorical + # The index of the corresponding bitsets in the Predictor's bitset arrays. + # Only used if is_categorical is True + unsigned int bitset_idx + + +cpdef enum MonotonicConstraint: + NO_CST = 0 + POS = 1 + NEG = -1 diff --git a/shared/package-files/30/30b160d3a276c65966d6d9a00e794b630f204f2efffcd1a791fe1264ffb7992b/blob b/shared/package-files/30/30b160d3a276c65966d6d9a00e794b630f204f2efffcd1a791fe1264ffb7992b/blob new file mode 100644 index 0000000000000000000000000000000000000000..bf92ec985ae25ace261ae286c65935fa769f3dca --- /dev/null +++ b/shared/package-files/30/30b160d3a276c65966d6d9a00e794b630f204f2efffcd1a791fe1264ffb7992b/blob @@ -0,0 +1,1786 @@ +""" +The image module supports basic image loading, rescaling and display +operations. +""" + +import math +import os +import logging +from pathlib import Path +import warnings + +import numpy as np +import PIL.Image +import PIL.PngImagePlugin + +import matplotlib as mpl +from matplotlib import _api, cbook +# For clarity, names from _image are given explicitly in this module +from matplotlib import _image +# For user convenience, the names from _image are also imported into +# the image namespace +from matplotlib._image import * # noqa: F401, F403 +import matplotlib.artist as martist +import matplotlib.colorizer as mcolorizer +from matplotlib.backend_bases import FigureCanvasBase +import matplotlib.colors as mcolors +from matplotlib.transforms import ( + Affine2D, BboxBase, Bbox, BboxTransform, BboxTransformTo, + IdentityTransform, TransformedBbox) + +_log = logging.getLogger(__name__) + +# map interpolation strings to module constants +_interpd_ = { + 'auto': _image.NEAREST, # this will use nearest or Hanning... + 'none': _image.NEAREST, # fall back to nearest when not supported + 'nearest': _image.NEAREST, + 'bilinear': _image.BILINEAR, + 'bicubic': _image.BICUBIC, + 'spline16': _image.SPLINE16, + 'spline36': _image.SPLINE36, + 'hanning': _image.HANNING, + 'hamming': _image.HAMMING, + 'hermite': _image.HERMITE, + 'kaiser': _image.KAISER, + 'quadric': _image.QUADRIC, + 'catrom': _image.CATROM, + 'gaussian': _image.GAUSSIAN, + 'bessel': _image.BESSEL, + 'mitchell': _image.MITCHELL, + 'sinc': _image.SINC, + 'lanczos': _image.LANCZOS, + 'blackman': _image.BLACKMAN, + 'antialiased': _image.NEAREST, # this will use nearest or Hanning... +} + +interpolations_names = set(_interpd_) + + +def composite_images(images, renderer, magnification=1.0): + """ + Composite a number of RGBA images into one. The images are + composited in the order in which they appear in the *images* list. + + Parameters + ---------- + images : list of Images + Each must have a `make_image` method. For each image, + `can_composite` should return `True`, though this is not + enforced by this function. Each image must have a purely + affine transformation with no shear. + + renderer : `.RendererBase` + + magnification : float, default: 1 + The additional magnification to apply for the renderer in use. + + Returns + ------- + image : (M, N, 4) `numpy.uint8` array + The composited RGBA image. + offset_x, offset_y : float + The (left, bottom) offset where the composited image should be placed + in the output figure. + """ + if len(images) == 0: + return np.empty((0, 0, 4), dtype=np.uint8), 0, 0 + + parts = [] + bboxes = [] + for image in images: + data, x, y, trans = image.make_image(renderer, magnification) + if data is not None: + x *= magnification + y *= magnification + parts.append((data, x, y, image._get_scalar_alpha())) + bboxes.append( + Bbox([[x, y], [x + data.shape[1], y + data.shape[0]]])) + + if len(parts) == 0: + return np.empty((0, 0, 4), dtype=np.uint8), 0, 0 + + bbox = Bbox.union(bboxes) + + output = np.zeros( + (int(bbox.height), int(bbox.width), 4), dtype=np.uint8) + + for data, x, y, alpha in parts: + trans = Affine2D().translate(x - bbox.x0, y - bbox.y0) + _image.resample(data, output, trans, _image.NEAREST, + resample=False, alpha=alpha) + + return output, bbox.x0 / magnification, bbox.y0 / magnification + + +def _draw_list_compositing_images( + renderer, parent, artists, suppress_composite=None): + """ + Draw a sorted list of artists, compositing images into a single + image where possible. + + For internal Matplotlib use only: It is here to reduce duplication + between `Figure.draw` and `Axes.draw`, but otherwise should not be + generally useful. + """ + has_images = any(isinstance(x, _ImageBase) for x in artists) + + # override the renderer default if suppressComposite is not None + not_composite = (suppress_composite if suppress_composite is not None + else renderer.option_image_nocomposite()) + + if not_composite or not has_images: + for a in artists: + a.draw(renderer) + else: + # Composite any adjacent images together + image_group = [] + mag = renderer.get_image_magnification() + + def flush_images(): + if len(image_group) == 1: + image_group[0].draw(renderer) + elif len(image_group) > 1: + data, l, b = composite_images(image_group, renderer, mag) + if data.size != 0: + gc = renderer.new_gc() + gc.set_clip_rectangle(parent.bbox) + gc.set_clip_path(parent.get_clip_path()) + renderer.draw_image(gc, round(l), round(b), data) + gc.restore() + del image_group[:] + + for a in artists: + if (isinstance(a, _ImageBase) and a.can_composite() and + a.get_clip_on() and not a.get_clip_path()): + image_group.append(a) + else: + flush_images() + a.draw(renderer) + flush_images() + + +def _resample( + image_obj, data, out_shape, transform, *, resample=None, alpha=1): + """ + Convenience wrapper around `._image.resample` to resample *data* to + *out_shape* (with a third dimension if *data* is RGBA) that takes care of + allocating the output array and fetching the relevant properties from the + Image object *image_obj*. + """ + # AGG can only handle coordinates smaller than 24-bit signed integers, + # so raise errors if the input data is larger than _image.resample can + # handle. + msg = ('Data with more than {n} cannot be accurately displayed. ' + 'Downsampling to less than {n} before displaying. ' + 'To remove this warning, manually downsample your data.') + if data.shape[1] > 2**23: + warnings.warn(msg.format(n='2**23 columns')) + step = int(np.ceil(data.shape[1] / 2**23)) + data = data[:, ::step] + transform = Affine2D().scale(step, 1) + transform + if data.shape[0] > 2**24: + warnings.warn(msg.format(n='2**24 rows')) + step = int(np.ceil(data.shape[0] / 2**24)) + data = data[::step, :] + transform = Affine2D().scale(1, step) + transform + # decide if we need to apply anti-aliasing if the data is upsampled: + # compare the number of displayed pixels to the number of + # the data pixels. + interpolation = image_obj.get_interpolation() + if interpolation in ['antialiased', 'auto']: + # don't antialias if upsampling by an integer number or + # if zooming in more than a factor of 3 + pos = np.array([[0, 0], [data.shape[1], data.shape[0]]]) + disp = transform.transform(pos) + dispx = np.abs(np.diff(disp[:, 0])) + dispy = np.abs(np.diff(disp[:, 1])) + if ((dispx > 3 * data.shape[1] or + dispx == data.shape[1] or + dispx == 2 * data.shape[1]) and + (dispy > 3 * data.shape[0] or + dispy == data.shape[0] or + dispy == 2 * data.shape[0])): + interpolation = 'nearest' + else: + interpolation = 'hanning' + out = np.zeros(out_shape + data.shape[2:], data.dtype) # 2D->2D, 3D->3D. + if resample is None: + resample = image_obj.get_resample() + _image.resample(data, out, transform, + _interpd_[interpolation], + resample, + alpha, + image_obj.get_filternorm(), + image_obj.get_filterrad()) + return out + + +def _rgb_to_rgba(A): + """ + Convert an RGB image to RGBA, as required by the image resample C++ + extension. + """ + rgba = np.zeros((A.shape[0], A.shape[1], 4), dtype=A.dtype) + rgba[:, :, :3] = A + if rgba.dtype == np.uint8: + rgba[:, :, 3] = 255 + else: + rgba[:, :, 3] = 1.0 + return rgba + + +class _ImageBase(mcolorizer.ColorizingArtist): + """ + Base class for images. + + interpolation and cmap default to their rc settings + + cmap is a colors.Colormap instance + norm is a colors.Normalize instance to map luminance to 0-1 + + extent is data axes (left, right, bottom, top) for making image plots + registered with data plots. Default is to label the pixel + centers with the zero-based row and column indices. + + Additional kwargs are matplotlib.artist properties + """ + zorder = 0 + + def __init__(self, ax, + cmap=None, + norm=None, + colorizer=None, + interpolation=None, + origin=None, + filternorm=True, + filterrad=4.0, + resample=False, + *, + interpolation_stage=None, + **kwargs + ): + super().__init__(self._get_colorizer(cmap, norm, colorizer)) + if origin is None: + origin = mpl.rcParams['image.origin'] + _api.check_in_list(["upper", "lower"], origin=origin) + self.origin = origin + self.set_filternorm(filternorm) + self.set_filterrad(filterrad) + self.set_interpolation(interpolation) + self.set_interpolation_stage(interpolation_stage) + self.set_resample(resample) + self.axes = ax + + self._imcache = None + + self._internal_update(kwargs) + + def __str__(self): + try: + shape = self.get_shape() + return f"{type(self).__name__}(shape={shape!r})" + except RuntimeError: + return type(self).__name__ + + def __getstate__(self): + # Save some space on the pickle by not saving the cache. + return {**super().__getstate__(), "_imcache": None} + + def get_size(self): + """Return the size of the image as tuple (numrows, numcols).""" + return self.get_shape()[:2] + + def get_shape(self): + """ + Return the shape of the image as tuple (numrows, numcols, channels). + """ + if self._A is None: + raise RuntimeError('You must first set the image array') + + return self._A.shape + + def set_alpha(self, alpha): + """ + Set the alpha value used for blending - not supported on all backends. + + Parameters + ---------- + alpha : float or 2D array-like or None + """ + martist.Artist._set_alpha_for_array(self, alpha) + if np.ndim(alpha) not in (0, 2): + raise TypeError('alpha must be a float, two-dimensional ' + 'array, or None') + self._imcache = None + + def _get_scalar_alpha(self): + """ + Get a scalar alpha value to be applied to the artist as a whole. + + If the alpha value is a matrix, the method returns 1.0 because pixels + have individual alpha values (see `~._ImageBase._make_image` for + details). If the alpha value is a scalar, the method returns said value + to be applied to the artist as a whole because pixels do not have + individual alpha values. + """ + return 1.0 if self._alpha is None or np.ndim(self._alpha) > 0 \ + else self._alpha + + def changed(self): + """ + Call this whenever the mappable is changed so observers can update. + """ + self._imcache = None + super().changed() + + def _make_image(self, A, in_bbox, out_bbox, clip_bbox, magnification=1.0, + unsampled=False, round_to_pixel_border=True): + """ + Normalize, rescale, and colormap the image *A* from the given *in_bbox* + (in data space), to the given *out_bbox* (in pixel space) clipped to + the given *clip_bbox* (also in pixel space), and magnified by the + *magnification* factor. + + Parameters + ---------- + A : ndarray + + - a (M, N) array interpreted as scalar (greyscale) image, + with one of the dtypes `~numpy.float32`, `~numpy.float64`, + `~numpy.float128`, `~numpy.uint16` or `~numpy.uint8`. + - (M, N, 4) RGBA image with a dtype of `~numpy.float32`, + `~numpy.float64`, `~numpy.float128`, or `~numpy.uint8`. + + in_bbox : `~matplotlib.transforms.Bbox` + + out_bbox : `~matplotlib.transforms.Bbox` + + clip_bbox : `~matplotlib.transforms.Bbox` + + magnification : float, default: 1 + + unsampled : bool, default: False + If True, the image will not be scaled, but an appropriate + affine transformation will be returned instead. + + round_to_pixel_border : bool, default: True + If True, the output image size will be rounded to the nearest pixel + boundary. This makes the images align correctly with the Axes. + It should not be used if exact scaling is needed, such as for + `.FigureImage`. + + Returns + ------- + image : (M, N, 4) `numpy.uint8` array + The RGBA image, resampled unless *unsampled* is True. + x, y : float + The upper left corner where the image should be drawn, in pixel + space. + trans : `~matplotlib.transforms.Affine2D` + The affine transformation from image to pixel space. + """ + if A is None: + raise RuntimeError('You must first set the image ' + 'array or the image attribute') + if A.size == 0: + raise RuntimeError("_make_image must get a non-empty image. " + "Your Artist's draw method must filter before " + "this method is called.") + + clipped_bbox = Bbox.intersection(out_bbox, clip_bbox) + + if clipped_bbox is None: + return None, 0, 0, None + + out_width_base = clipped_bbox.width * magnification + out_height_base = clipped_bbox.height * magnification + + if out_width_base == 0 or out_height_base == 0: + return None, 0, 0, None + + if self.origin == 'upper': + # Flip the input image using a transform. This avoids the + # problem with flipping the array, which results in a copy + # when it is converted to contiguous in the C wrapper + t0 = Affine2D().translate(0, -A.shape[0]).scale(1, -1) + else: + t0 = IdentityTransform() + + t0 += ( + Affine2D() + .scale( + in_bbox.width / A.shape[1], + in_bbox.height / A.shape[0]) + .translate(in_bbox.x0, in_bbox.y0) + + self.get_transform()) + + t = (t0 + + (Affine2D() + .translate(-clipped_bbox.x0, -clipped_bbox.y0) + .scale(magnification))) + + # So that the image is aligned with the edge of the Axes, we want to + # round up the output width to the next integer. This also means + # scaling the transform slightly to account for the extra subpixel. + if ((not unsampled) and t.is_affine and round_to_pixel_border and + (out_width_base % 1.0 != 0.0 or out_height_base % 1.0 != 0.0)): + out_width = math.ceil(out_width_base) + out_height = math.ceil(out_height_base) + extra_width = (out_width - out_width_base) / out_width_base + extra_height = (out_height - out_height_base) / out_height_base + t += Affine2D().scale(1.0 + extra_width, 1.0 + extra_height) + else: + out_width = int(out_width_base) + out_height = int(out_height_base) + out_shape = (out_height, out_width) + + if not unsampled: + if not (A.ndim == 2 or A.ndim == 3 and A.shape[-1] in (3, 4)): + raise ValueError(f"Invalid shape {A.shape} for image data") + + # if antialiased, this needs to change as window sizes + # change: + interpolation_stage = self._interpolation_stage + if interpolation_stage in ['antialiased', 'auto']: + pos = np.array([[0, 0], [A.shape[1], A.shape[0]]]) + disp = t.transform(pos) + dispx = np.abs(np.diff(disp[:, 0])) / A.shape[1] + dispy = np.abs(np.diff(disp[:, 1])) / A.shape[0] + if (dispx < 3) or (dispy < 3): + interpolation_stage = 'rgba' + else: + interpolation_stage = 'data' + + if A.ndim == 2 and interpolation_stage == 'data': + # if we are a 2D array, then we are running through the + # norm + colormap transformation. However, in general the + # input data is not going to match the size on the screen so we + # have to resample to the correct number of pixels + + if A.dtype.kind == 'f': # Float dtype: scale to same dtype. + scaled_dtype = np.dtype("f8" if A.dtype.itemsize > 4 else "f4") + if scaled_dtype.itemsize < A.dtype.itemsize: + _api.warn_external(f"Casting input data from {A.dtype}" + f" to {scaled_dtype} for imshow.") + else: # Int dtype, likely. + # TODO slice input array first + # Scale to appropriately sized float: use float32 if the + # dynamic range is small, to limit the memory footprint. + da = A.max().astype("f8") - A.min().astype("f8") + scaled_dtype = "f8" if da > 1e8 else "f4" + + # resample the input data to the correct resolution and shape + A_resampled = _resample(self, A.astype(scaled_dtype), out_shape, t) + + # if using NoNorm, cast back to the original datatype + if isinstance(self.norm, mcolors.NoNorm): + A_resampled = A_resampled.astype(A.dtype) + + # Compute out_mask (what screen pixels include "bad" data + # pixels) and out_alpha (to what extent screen pixels are + # covered by data pixels: 0 outside the data extent, 1 inside + # (even for bad data), and intermediate values at the edges). + mask = (np.where(A.mask, np.float32(np.nan), np.float32(1)) + if A.mask.shape == A.shape # nontrivial mask + else np.ones_like(A, np.float32)) + # we always have to interpolate the mask to account for + # non-affine transformations + out_alpha = _resample(self, mask, out_shape, t, resample=True) + del mask # Make sure we don't use mask anymore! + out_mask = np.isnan(out_alpha) + out_alpha[out_mask] = 1 + # Apply the pixel-by-pixel alpha values if present + alpha = self.get_alpha() + if alpha is not None and np.ndim(alpha) > 0: + out_alpha *= _resample(self, alpha, out_shape, t, resample=True) + # mask and run through the norm + resampled_masked = np.ma.masked_array(A_resampled, out_mask) + output = self.norm(resampled_masked) + else: + if A.ndim == 2: # interpolation_stage = 'rgba' + self.norm.autoscale_None(A) + A = self.to_rgba(A) + alpha = self.get_alpha() + if alpha is None: # alpha parameter not specified + if A.shape[2] == 3: # image has no alpha channel + output_alpha = 255 if A.dtype == np.uint8 else 1.0 + else: + output_alpha = _resample( # resample alpha channel + self, A[..., 3], out_shape, t) + output = _resample( # resample rgb channels + self, _rgb_to_rgba(A[..., :3]), out_shape, t) + elif np.ndim(alpha) > 0: # Array alpha + # user-specified array alpha overrides the existing alpha channel + output_alpha = _resample(self, alpha, out_shape, t) + output = _resample( + self, _rgb_to_rgba(A[..., :3]), out_shape, t) + else: # Scalar alpha + if A.shape[2] == 3: # broadcast scalar alpha + output_alpha = (255 * alpha) if A.dtype == np.uint8 else alpha + else: # or apply scalar alpha to existing alpha channel + output_alpha = _resample(self, A[..., 3], out_shape, t) * alpha + output = _resample( + self, _rgb_to_rgba(A[..., :3]), out_shape, t) + output[..., 3] = output_alpha # recombine rgb and alpha + + # output is now either a 2D array of normed (int or float) data + # or an RGBA array of re-sampled input + output = self.to_rgba(output, bytes=True, norm=False) + # output is now a correctly sized RGBA array of uint8 + + # Apply alpha *after* if the input was greyscale without a mask + if A.ndim == 2: + alpha = self._get_scalar_alpha() + alpha_channel = output[:, :, 3] + alpha_channel[:] = ( # Assignment will cast to uint8. + alpha_channel.astype(np.float32) * out_alpha * alpha) + + else: + if self._imcache is None: + self._imcache = self.to_rgba(A, bytes=True, norm=(A.ndim == 2)) + output = self._imcache + + # Subset the input image to only the part that will be displayed. + subset = TransformedBbox(clip_bbox, t0.inverted()).frozen() + output = output[ + int(max(subset.ymin, 0)): + int(min(subset.ymax + 1, output.shape[0])), + int(max(subset.xmin, 0)): + int(min(subset.xmax + 1, output.shape[1]))] + + t = Affine2D().translate( + int(max(subset.xmin, 0)), int(max(subset.ymin, 0))) + t + + return output, clipped_bbox.x0, clipped_bbox.y0, t + + def make_image(self, renderer, magnification=1.0, unsampled=False): + """ + Normalize, rescale, and colormap this image's data for rendering using + *renderer*, with the given *magnification*. + + If *unsampled* is True, the image will not be scaled, but an + appropriate affine transformation will be returned instead. + + Returns + ------- + image : (M, N, 4) `numpy.uint8` array + The RGBA image, resampled unless *unsampled* is True. + x, y : float + The upper left corner where the image should be drawn, in pixel + space. + trans : `~matplotlib.transforms.Affine2D` + The affine transformation from image to pixel space. + """ + raise NotImplementedError('The make_image method must be overridden') + + def _check_unsampled_image(self): + """ + Return whether the image is better to be drawn unsampled. + + The derived class needs to override it. + """ + return False + + @martist.allow_rasterization + def draw(self, renderer): + # if not visible, declare victory and return + if not self.get_visible(): + self.stale = False + return + # for empty images, there is nothing to draw! + if self.get_array().size == 0: + self.stale = False + return + # actually render the image. + gc = renderer.new_gc() + self._set_gc_clip(gc) + gc.set_alpha(self._get_scalar_alpha()) + gc.set_url(self.get_url()) + gc.set_gid(self.get_gid()) + if (renderer.option_scale_image() # Renderer supports transform kwarg. + and self._check_unsampled_image() + and self.get_transform().is_affine): + im, l, b, trans = self.make_image(renderer, unsampled=True) + if im is not None: + trans = Affine2D().scale(im.shape[1], im.shape[0]) + trans + renderer.draw_image(gc, l, b, im, trans) + else: + im, l, b, trans = self.make_image( + renderer, renderer.get_image_magnification()) + if im is not None: + renderer.draw_image(gc, l, b, im) + gc.restore() + self.stale = False + + def contains(self, mouseevent): + """Test whether the mouse event occurred within the image.""" + if (self._different_canvas(mouseevent) + # This doesn't work for figimage. + or not self.axes.contains(mouseevent)[0]): + return False, {} + # TODO: make sure this is consistent with patch and patch + # collection on nonlinear transformed coordinates. + # TODO: consider returning image coordinates (shouldn't + # be too difficult given that the image is rectilinear + trans = self.get_transform().inverted() + x, y = trans.transform([mouseevent.x, mouseevent.y]) + xmin, xmax, ymin, ymax = self.get_extent() + # This checks xmin <= x <= xmax *or* xmax <= x <= xmin. + inside = (x is not None and (x - xmin) * (x - xmax) <= 0 + and y is not None and (y - ymin) * (y - ymax) <= 0) + return inside, {} + + def write_png(self, fname): + """Write the image to png file *fname*.""" + im = self.to_rgba(self._A[::-1] if self.origin == 'lower' else self._A, + bytes=True, norm=True) + PIL.Image.fromarray(im).save(fname, format="png") + + @staticmethod + def _normalize_image_array(A): + """ + Check validity of image-like input *A* and normalize it to a format suitable for + Image subclasses. + """ + A = cbook.safe_masked_invalid(A, copy=True) + if A.dtype != np.uint8 and not np.can_cast(A.dtype, float, "same_kind"): + raise TypeError(f"Image data of dtype {A.dtype} cannot be " + f"converted to float") + if A.ndim == 3 and A.shape[-1] == 1: + A = A.squeeze(-1) # If just (M, N, 1), assume scalar and apply colormap. + if not (A.ndim == 2 or A.ndim == 3 and A.shape[-1] in [3, 4]): + raise TypeError(f"Invalid shape {A.shape} for image data") + if A.ndim == 3: + # If the input data has values outside the valid range (after + # normalisation), we issue a warning and then clip X to the bounds + # - otherwise casting wraps extreme values, hiding outliers and + # making reliable interpretation impossible. + high = 255 if np.issubdtype(A.dtype, np.integer) else 1 + if A.min() < 0 or high < A.max(): + _log.warning( + 'Clipping input data to the valid range for imshow with ' + 'RGB data ([0..1] for floats or [0..255] for integers). ' + 'Got range [%s..%s].', + A.min(), A.max() + ) + A = np.clip(A, 0, high) + # Cast unsupported integer types to uint8 + if A.dtype != np.uint8 and np.issubdtype(A.dtype, np.integer): + A = A.astype(np.uint8) + return A + + def set_data(self, A): + """ + Set the image array. + + Note that this function does *not* update the normalization used. + + Parameters + ---------- + A : array-like or `PIL.Image.Image` + """ + if isinstance(A, PIL.Image.Image): + A = pil_to_array(A) # Needed e.g. to apply png palette. + self._A = self._normalize_image_array(A) + self._imcache = None + self.stale = True + + def set_array(self, A): + """ + Retained for backwards compatibility - use set_data instead. + + Parameters + ---------- + A : array-like + """ + # This also needs to be here to override the inherited + # cm.ScalarMappable.set_array method so it is not invoked by mistake. + self.set_data(A) + + def get_interpolation(self): + """ + Return the interpolation method the image uses when resizing. + + One of 'auto', 'antialiased', 'nearest', 'bilinear', 'bicubic', + 'spline16', 'spline36', 'hanning', 'hamming', 'hermite', 'kaiser', + 'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell', 'sinc', 'lanczos', + or 'none'. + """ + return self._interpolation + + def set_interpolation(self, s): + """ + Set the interpolation method the image uses when resizing. + + If None, use :rc:`image.interpolation`. If 'none', the image is + shown as is without interpolating. 'none' is only supported in + agg, ps and pdf backends and will fall back to 'nearest' mode + for other backends. + + Parameters + ---------- + s : {'auto', 'nearest', 'bilinear', 'bicubic', 'spline16', \ +'spline36', 'hanning', 'hamming', 'hermite', 'kaiser', 'quadric', 'catrom', \ +'gaussian', 'bessel', 'mitchell', 'sinc', 'lanczos', 'none'} or None + """ + s = mpl._val_or_rc(s, 'image.interpolation').lower() + _api.check_in_list(interpolations_names, interpolation=s) + self._interpolation = s + self.stale = True + + def get_interpolation_stage(self): + """ + Return when interpolation happens during the transform to RGBA. + + One of 'data', 'rgba', 'auto'. + """ + return self._interpolation_stage + + def set_interpolation_stage(self, s): + """ + Set when interpolation happens during the transform to RGBA. + + Parameters + ---------- + s : {'data', 'rgba', 'auto'} or None + Whether to apply up/downsampling interpolation in data or RGBA + space. If None, use :rc:`image.interpolation_stage`. + If 'auto' we will check upsampling rate and if less + than 3 then use 'rgba', otherwise use 'data'. + """ + s = mpl._val_or_rc(s, 'image.interpolation_stage') + _api.check_in_list(['data', 'rgba', 'auto'], s=s) + self._interpolation_stage = s + self.stale = True + + def can_composite(self): + """Return whether the image can be composited with its neighbors.""" + trans = self.get_transform() + return ( + self._interpolation != 'none' and + trans.is_affine and + trans.is_separable) + + def set_resample(self, v): + """ + Set whether image resampling is used. + + Parameters + ---------- + v : bool or None + If None, use :rc:`image.resample`. + """ + v = mpl._val_or_rc(v, 'image.resample') + self._resample = v + self.stale = True + + def get_resample(self): + """Return whether image resampling is used.""" + return self._resample + + def set_filternorm(self, filternorm): + """ + Set whether the resize filter normalizes the weights. + + See help for `~.Axes.imshow`. + + Parameters + ---------- + filternorm : bool + """ + self._filternorm = bool(filternorm) + self.stale = True + + def get_filternorm(self): + """Return whether the resize filter normalizes the weights.""" + return self._filternorm + + def set_filterrad(self, filterrad): + """ + Set the resize filter radius only applicable to some + interpolation schemes -- see help for imshow + + Parameters + ---------- + filterrad : positive float + """ + r = float(filterrad) + if r <= 0: + raise ValueError("The filter radius must be a positive number") + self._filterrad = r + self.stale = True + + def get_filterrad(self): + """Return the filterrad setting.""" + return self._filterrad + + +class AxesImage(_ImageBase): + """ + An image with pixels on a regular grid, attached to an Axes. + + Parameters + ---------- + ax : `~matplotlib.axes.Axes` + The Axes the image will belong to. + cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap` + The Colormap instance or registered colormap name used to map scalar + data to colors. + norm : str or `~matplotlib.colors.Normalize` + Maps luminance to 0-1. + interpolation : str, default: :rc:`image.interpolation` + Supported values are 'none', 'auto', 'nearest', 'bilinear', + 'bicubic', 'spline16', 'spline36', 'hanning', 'hamming', 'hermite', + 'kaiser', 'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell', + 'sinc', 'lanczos', 'blackman'. + interpolation_stage : {'data', 'rgba'}, default: 'data' + If 'data', interpolation + is carried out on the data provided by the user. If 'rgba', the + interpolation is carried out after the colormapping has been + applied (visual interpolation). + origin : {'upper', 'lower'}, default: :rc:`image.origin` + Place the [0, 0] index of the array in the upper left or lower left + corner of the Axes. The convention 'upper' is typically used for + matrices and images. + extent : tuple, optional + The data axes (left, right, bottom, top) for making image plots + registered with data plots. Default is to label the pixel + centers with the zero-based row and column indices. + filternorm : bool, default: True + A parameter for the antigrain image resize filter + (see the antigrain documentation). + If filternorm is set, the filter normalizes integer values and corrects + the rounding errors. It doesn't do anything with the source floating + point values, it corrects only integers according to the rule of 1.0 + which means that any sum of pixel weights must be equal to 1.0. So, + the filter function must produce a graph of the proper shape. + filterrad : float > 0, default: 4 + The filter radius for filters that have a radius parameter, i.e. when + interpolation is one of: 'sinc', 'lanczos' or 'blackman'. + resample : bool, default: False + When True, use a full resampling method. When False, only resample when + the output image is larger than the input image. + **kwargs : `~matplotlib.artist.Artist` properties + """ + + def __init__(self, ax, + *, + cmap=None, + norm=None, + colorizer=None, + interpolation=None, + origin=None, + extent=None, + filternorm=True, + filterrad=4.0, + resample=False, + interpolation_stage=None, + **kwargs + ): + + self._extent = extent + + super().__init__( + ax, + cmap=cmap, + norm=norm, + colorizer=colorizer, + interpolation=interpolation, + origin=origin, + filternorm=filternorm, + filterrad=filterrad, + resample=resample, + interpolation_stage=interpolation_stage, + **kwargs + ) + + def get_window_extent(self, renderer=None): + x0, x1, y0, y1 = self._extent + bbox = Bbox.from_extents([x0, y0, x1, y1]) + return bbox.transformed(self.get_transform()) + + def make_image(self, renderer, magnification=1.0, unsampled=False): + # docstring inherited + trans = self.get_transform() + # image is created in the canvas coordinate. + x1, x2, y1, y2 = self.get_extent() + bbox = Bbox(np.array([[x1, y1], [x2, y2]])) + transformed_bbox = TransformedBbox(bbox, trans) + clip = ((self.get_clip_box() or self.axes.bbox) if self.get_clip_on() + else self.get_figure(root=True).bbox) + return self._make_image(self._A, bbox, transformed_bbox, clip, + magnification, unsampled=unsampled) + + def _check_unsampled_image(self): + """Return whether the image would be better drawn unsampled.""" + return self.get_interpolation() == "none" + + def set_extent(self, extent, **kwargs): + """ + Set the image extent. + + Parameters + ---------- + extent : 4-tuple of float + The position and size of the image as tuple + ``(left, right, bottom, top)`` in data coordinates. + **kwargs + Other parameters from which unit info (i.e., the *xunits*, + *yunits*, *zunits* (for 3D Axes), *runits* and *thetaunits* (for + polar Axes) entries are applied, if present. + + Notes + ----- + This updates `.Axes.dataLim`, and, if autoscaling, sets `.Axes.viewLim` + to tightly fit the image, regardless of `~.Axes.dataLim`. Autoscaling + state is not changed, so a subsequent call to `.Axes.autoscale_view` + will redo the autoscaling in accord with `~.Axes.dataLim`. + """ + (xmin, xmax), (ymin, ymax) = self.axes._process_unit_info( + [("x", [extent[0], extent[1]]), + ("y", [extent[2], extent[3]])], + kwargs) + if kwargs: + raise _api.kwarg_error("set_extent", kwargs) + xmin = self.axes._validate_converted_limits( + xmin, self.convert_xunits) + xmax = self.axes._validate_converted_limits( + xmax, self.convert_xunits) + ymin = self.axes._validate_converted_limits( + ymin, self.convert_yunits) + ymax = self.axes._validate_converted_limits( + ymax, self.convert_yunits) + extent = [xmin, xmax, ymin, ymax] + + self._extent = extent + corners = (xmin, ymin), (xmax, ymax) + self.axes.update_datalim(corners) + self.sticky_edges.x[:] = [xmin, xmax] + self.sticky_edges.y[:] = [ymin, ymax] + if self.axes.get_autoscalex_on(): + self.axes.set_xlim((xmin, xmax), auto=None) + if self.axes.get_autoscaley_on(): + self.axes.set_ylim((ymin, ymax), auto=None) + self.stale = True + + def get_extent(self): + """Return the image extent as tuple (left, right, bottom, top).""" + if self._extent is not None: + return self._extent + else: + sz = self.get_size() + numrows, numcols = sz + if self.origin == 'upper': + return (-0.5, numcols-0.5, numrows-0.5, -0.5) + else: + return (-0.5, numcols-0.5, -0.5, numrows-0.5) + + def get_cursor_data(self, event): + """ + Return the image value at the event position or *None* if the event is + outside the image. + + See Also + -------- + matplotlib.artist.Artist.get_cursor_data + """ + xmin, xmax, ymin, ymax = self.get_extent() + if self.origin == 'upper': + ymin, ymax = ymax, ymin + arr = self.get_array() + data_extent = Bbox([[xmin, ymin], [xmax, ymax]]) + array_extent = Bbox([[0, 0], [arr.shape[1], arr.shape[0]]]) + trans = self.get_transform().inverted() + trans += BboxTransform(boxin=data_extent, boxout=array_extent) + point = trans.transform([event.x, event.y]) + if any(np.isnan(point)): + return None + j, i = point.astype(int) + # Clip the coordinates at array bounds + if not (0 <= i < arr.shape[0]) or not (0 <= j < arr.shape[1]): + return None + else: + return arr[i, j] + + +class NonUniformImage(AxesImage): + """ + An image with pixels on a rectilinear grid. + + In contrast to `.AxesImage`, where pixels are on a regular grid, + NonUniformImage allows rows and columns with individual heights / widths. + + See also :doc:`/gallery/images_contours_and_fields/image_nonuniform`. + """ + + def __init__(self, ax, *, interpolation='nearest', **kwargs): + """ + Parameters + ---------- + ax : `~matplotlib.axes.Axes` + The Axes the image will belong to. + interpolation : {'nearest', 'bilinear'}, default: 'nearest' + The interpolation scheme used in the resampling. + **kwargs + All other keyword arguments are identical to those of `.AxesImage`. + """ + super().__init__(ax, **kwargs) + self.set_interpolation(interpolation) + + def _check_unsampled_image(self): + """Return False. Do not use unsampled image.""" + return False + + def make_image(self, renderer, magnification=1.0, unsampled=False): + # docstring inherited + if self._A is None: + raise RuntimeError('You must first set the image array') + if unsampled: + raise ValueError('unsampled not supported on NonUniformImage') + A = self._A + if A.ndim == 2: + if A.dtype != np.uint8: + A = self.to_rgba(A, bytes=True) + else: + A = np.repeat(A[:, :, np.newaxis], 4, 2) + A[:, :, 3] = 255 + else: + if A.dtype != np.uint8: + A = (255*A).astype(np.uint8) + if A.shape[2] == 3: + B = np.zeros(tuple([*A.shape[0:2], 4]), np.uint8) + B[:, :, 0:3] = A + B[:, :, 3] = 255 + A = B + l, b, r, t = self.axes.bbox.extents + width = int(((round(r) + 0.5) - (round(l) - 0.5)) * magnification) + height = int(((round(t) + 0.5) - (round(b) - 0.5)) * magnification) + + invertedTransform = self.axes.transData.inverted() + x_pix = invertedTransform.transform( + [(x, b) for x in np.linspace(l, r, width)])[:, 0] + y_pix = invertedTransform.transform( + [(l, y) for y in np.linspace(b, t, height)])[:, 1] + + if self._interpolation == "nearest": + x_mid = (self._Ax[:-1] + self._Ax[1:]) / 2 + y_mid = (self._Ay[:-1] + self._Ay[1:]) / 2 + x_int = x_mid.searchsorted(x_pix) + y_int = y_mid.searchsorted(y_pix) + # The following is equal to `A[y_int[:, None], x_int[None, :]]`, + # but many times faster. Both casting to uint32 (to have an + # effectively 1D array) and manual index flattening matter. + im = ( + np.ascontiguousarray(A).view(np.uint32).ravel()[ + np.add.outer(y_int * A.shape[1], x_int)] + .view(np.uint8).reshape((height, width, 4))) + else: # self._interpolation == "bilinear" + # Use np.interp to compute x_int/x_float has similar speed. + x_int = np.clip( + self._Ax.searchsorted(x_pix) - 1, 0, len(self._Ax) - 2) + y_int = np.clip( + self._Ay.searchsorted(y_pix) - 1, 0, len(self._Ay) - 2) + idx_int = np.add.outer(y_int * A.shape[1], x_int) + x_frac = np.clip( + np.divide(x_pix - self._Ax[x_int], np.diff(self._Ax)[x_int], + dtype=np.float32), # Downcasting helps with speed. + 0, 1) + y_frac = np.clip( + np.divide(y_pix - self._Ay[y_int], np.diff(self._Ay)[y_int], + dtype=np.float32), + 0, 1) + f00 = np.outer(1 - y_frac, 1 - x_frac) + f10 = np.outer(y_frac, 1 - x_frac) + f01 = np.outer(1 - y_frac, x_frac) + f11 = np.outer(y_frac, x_frac) + im = np.empty((height, width, 4), np.uint8) + for chan in range(4): + ac = A[:, :, chan].reshape(-1) # reshape(-1) avoids a copy. + # Shifting the buffer start (`ac[offset:]`) avoids an array + # addition (`ac[idx_int + offset]`). + buf = f00 * ac[idx_int] + buf += f10 * ac[A.shape[1]:][idx_int] + buf += f01 * ac[1:][idx_int] + buf += f11 * ac[A.shape[1] + 1:][idx_int] + im[:, :, chan] = buf # Implicitly casts to uint8. + return im, l, b, IdentityTransform() + + def set_data(self, x, y, A): + """ + Set the grid for the pixel centers, and the pixel values. + + Parameters + ---------- + x, y : 1D array-like + Monotonic arrays of shapes (N,) and (M,), respectively, specifying + pixel centers. + A : array-like + (M, N) `~numpy.ndarray` or masked array of values to be + colormapped, or (M, N, 3) RGB array, or (M, N, 4) RGBA array. + """ + A = self._normalize_image_array(A) + x = np.array(x, np.float32) + y = np.array(y, np.float32) + if not (x.ndim == y.ndim == 1 and A.shape[:2] == y.shape + x.shape): + raise TypeError("Axes don't match array shape") + self._A = A + self._Ax = x + self._Ay = y + self._imcache = None + self.stale = True + + def set_array(self, *args): + raise NotImplementedError('Method not supported') + + def set_interpolation(self, s): + """ + Parameters + ---------- + s : {'nearest', 'bilinear'} or None + If None, use :rc:`image.interpolation`. + """ + if s is not None and s not in ('nearest', 'bilinear'): + raise NotImplementedError('Only nearest neighbor and ' + 'bilinear interpolations are supported') + super().set_interpolation(s) + + def get_extent(self): + if self._A is None: + raise RuntimeError('Must set data first') + return self._Ax[0], self._Ax[-1], self._Ay[0], self._Ay[-1] + + def set_filternorm(self, filternorm): + pass + + def set_filterrad(self, filterrad): + pass + + def set_norm(self, norm): + if self._A is not None: + raise RuntimeError('Cannot change colors after loading data') + super().set_norm(norm) + + def set_cmap(self, cmap): + if self._A is not None: + raise RuntimeError('Cannot change colors after loading data') + super().set_cmap(cmap) + + def get_cursor_data(self, event): + # docstring inherited + x, y = event.xdata, event.ydata + if (x < self._Ax[0] or x > self._Ax[-1] or + y < self._Ay[0] or y > self._Ay[-1]): + return None + j = np.searchsorted(self._Ax, x) - 1 + i = np.searchsorted(self._Ay, y) - 1 + return self._A[i, j] + + +class PcolorImage(AxesImage): + """ + Make a pcolor-style plot with an irregular rectangular grid. + + This uses a variation of the original irregular image code, + and it is used by pcolorfast for the corresponding grid type. + """ + + def __init__(self, ax, + x=None, + y=None, + A=None, + *, + cmap=None, + norm=None, + colorizer=None, + **kwargs + ): + """ + Parameters + ---------- + ax : `~matplotlib.axes.Axes` + The Axes the image will belong to. + x, y : 1D array-like, optional + Monotonic arrays of length N+1 and M+1, respectively, specifying + rectangle boundaries. If not given, will default to + ``range(N + 1)`` and ``range(M + 1)``, respectively. + A : array-like + The data to be color-coded. The interpretation depends on the + shape: + + - (M, N) `~numpy.ndarray` or masked array: values to be colormapped + - (M, N, 3): RGB array + - (M, N, 4): RGBA array + + cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap` + The Colormap instance or registered colormap name used to map + scalar data to colors. + norm : str or `~matplotlib.colors.Normalize` + Maps luminance to 0-1. + **kwargs : `~matplotlib.artist.Artist` properties + """ + super().__init__(ax, norm=norm, cmap=cmap, colorizer=colorizer) + self._internal_update(kwargs) + if A is not None: + self.set_data(x, y, A) + + def make_image(self, renderer, magnification=1.0, unsampled=False): + # docstring inherited + if self._A is None: + raise RuntimeError('You must first set the image array') + if unsampled: + raise ValueError('unsampled not supported on PColorImage') + + if self._imcache is None: + A = self.to_rgba(self._A, bytes=True) + self._imcache = np.pad(A, [(1, 1), (1, 1), (0, 0)], "constant") + padded_A = self._imcache + bg = mcolors.to_rgba(self.axes.patch.get_facecolor(), 0) + bg = (np.array(bg) * 255).astype(np.uint8) + if (padded_A[0, 0] != bg).all(): + padded_A[[0, -1], :] = padded_A[:, [0, -1]] = bg + + l, b, r, t = self.axes.bbox.extents + width = (round(r) + 0.5) - (round(l) - 0.5) + height = (round(t) + 0.5) - (round(b) - 0.5) + width = round(width * magnification) + height = round(height * magnification) + vl = self.axes.viewLim + + x_pix = np.linspace(vl.x0, vl.x1, width) + y_pix = np.linspace(vl.y0, vl.y1, height) + x_int = self._Ax.searchsorted(x_pix) + y_int = self._Ay.searchsorted(y_pix) + im = ( # See comment in NonUniformImage.make_image re: performance. + padded_A.view(np.uint32).ravel()[ + np.add.outer(y_int * padded_A.shape[1], x_int)] + .view(np.uint8).reshape((height, width, 4))) + return im, l, b, IdentityTransform() + + def _check_unsampled_image(self): + return False + + def set_data(self, x, y, A): + """ + Set the grid for the rectangle boundaries, and the data values. + + Parameters + ---------- + x, y : 1D array-like, optional + Monotonic arrays of length N+1 and M+1, respectively, specifying + rectangle boundaries. If not given, will default to + ``range(N + 1)`` and ``range(M + 1)``, respectively. + A : array-like + The data to be color-coded. The interpretation depends on the + shape: + + - (M, N) `~numpy.ndarray` or masked array: values to be colormapped + - (M, N, 3): RGB array + - (M, N, 4): RGBA array + """ + A = self._normalize_image_array(A) + x = np.arange(0., A.shape[1] + 1) if x is None else np.array(x, float).ravel() + y = np.arange(0., A.shape[0] + 1) if y is None else np.array(y, float).ravel() + if A.shape[:2] != (y.size - 1, x.size - 1): + raise ValueError( + "Axes don't match array shape. Got %s, expected %s." % + (A.shape[:2], (y.size - 1, x.size - 1))) + # For efficient cursor readout, ensure x and y are increasing. + if x[-1] < x[0]: + x = x[::-1] + A = A[:, ::-1] + if y[-1] < y[0]: + y = y[::-1] + A = A[::-1] + self._A = A + self._Ax = x + self._Ay = y + self._imcache = None + self.stale = True + + def set_array(self, *args): + raise NotImplementedError('Method not supported') + + def get_cursor_data(self, event): + # docstring inherited + x, y = event.xdata, event.ydata + if (x < self._Ax[0] or x > self._Ax[-1] or + y < self._Ay[0] or y > self._Ay[-1]): + return None + j = np.searchsorted(self._Ax, x) - 1 + i = np.searchsorted(self._Ay, y) - 1 + return self._A[i, j] + + +class FigureImage(_ImageBase): + """An image attached to a figure.""" + + zorder = 0 + + _interpolation = 'nearest' + + def __init__(self, fig, + *, + cmap=None, + norm=None, + colorizer=None, + offsetx=0, + offsety=0, + origin=None, + **kwargs + ): + """ + cmap is a colors.Colormap instance + norm is a colors.Normalize instance to map luminance to 0-1 + + kwargs are an optional list of Artist keyword args + """ + super().__init__( + None, + norm=norm, + cmap=cmap, + colorizer=colorizer, + origin=origin + ) + self.set_figure(fig) + self.ox = offsetx + self.oy = offsety + self._internal_update(kwargs) + self.magnification = 1.0 + + def get_extent(self): + """Return the image extent as tuple (left, right, bottom, top).""" + numrows, numcols = self.get_size() + return (-0.5 + self.ox, numcols-0.5 + self.ox, + -0.5 + self.oy, numrows-0.5 + self.oy) + + def make_image(self, renderer, magnification=1.0, unsampled=False): + # docstring inherited + fig = self.get_figure(root=True) + fac = renderer.dpi/fig.dpi + # fac here is to account for pdf, eps, svg backends where + # figure.dpi is set to 72. This means we need to scale the + # image (using magnification) and offset it appropriately. + bbox = Bbox([[self.ox/fac, self.oy/fac], + [(self.ox/fac + self._A.shape[1]), + (self.oy/fac + self._A.shape[0])]]) + width, height = fig.get_size_inches() + width *= renderer.dpi + height *= renderer.dpi + clip = Bbox([[0, 0], [width, height]]) + return self._make_image( + self._A, bbox, bbox, clip, magnification=magnification / fac, + unsampled=unsampled, round_to_pixel_border=False) + + def set_data(self, A): + """Set the image array.""" + super().set_data(A) + self.stale = True + + +class BboxImage(_ImageBase): + """The Image class whose size is determined by the given bbox.""" + + def __init__(self, bbox, + *, + cmap=None, + norm=None, + colorizer=None, + interpolation=None, + origin=None, + filternorm=True, + filterrad=4.0, + resample=False, + **kwargs + ): + """ + cmap is a colors.Colormap instance + norm is a colors.Normalize instance to map luminance to 0-1 + + kwargs are an optional list of Artist keyword args + """ + super().__init__( + None, + cmap=cmap, + norm=norm, + colorizer=colorizer, + interpolation=interpolation, + origin=origin, + filternorm=filternorm, + filterrad=filterrad, + resample=resample, + **kwargs + ) + self.bbox = bbox + + def get_window_extent(self, renderer=None): + if renderer is None: + renderer = self.get_figure()._get_renderer() + + if isinstance(self.bbox, BboxBase): + return self.bbox + elif callable(self.bbox): + return self.bbox(renderer) + else: + raise ValueError("Unknown type of bbox") + + def contains(self, mouseevent): + """Test whether the mouse event occurred within the image.""" + if self._different_canvas(mouseevent) or not self.get_visible(): + return False, {} + x, y = mouseevent.x, mouseevent.y + inside = self.get_window_extent().contains(x, y) + return inside, {} + + def make_image(self, renderer, magnification=1.0, unsampled=False): + # docstring inherited + width, height = renderer.get_canvas_width_height() + bbox_in = self.get_window_extent(renderer).frozen() + bbox_in._points /= [width, height] + bbox_out = self.get_window_extent(renderer) + clip = Bbox([[0, 0], [width, height]]) + self._transform = BboxTransformTo(clip) + return self._make_image( + self._A, + bbox_in, bbox_out, clip, magnification, unsampled=unsampled) + + +def imread(fname, format=None): + """ + Read an image from a file into an array. + + .. note:: + + This function exists for historical reasons. It is recommended to + use `PIL.Image.open` instead for loading images. + + Parameters + ---------- + fname : str or file-like + The image file to read: a filename, a URL or a file-like object opened + in read-binary mode. + + Passing a URL is deprecated. Please open the URL + for reading and pass the result to Pillow, e.g. with + ``np.array(PIL.Image.open(urllib.request.urlopen(url)))``. + format : str, optional + The image file format assumed for reading the data. The image is + loaded as a PNG file if *format* is set to "png", if *fname* is a path + or opened file with a ".png" extension, or if it is a URL. In all + other cases, *format* is ignored and the format is auto-detected by + `PIL.Image.open`. + + Returns + ------- + `numpy.array` + The image data. The returned array has shape + + - (M, N) for grayscale images. + - (M, N, 3) for RGB images. + - (M, N, 4) for RGBA images. + + PNG images are returned as float arrays (0-1). All other formats are + returned as int arrays, with a bit depth determined by the file's + contents. + """ + # hide imports to speed initial import on systems with slow linkers + from urllib import parse + + if format is None: + if isinstance(fname, str): + parsed = parse.urlparse(fname) + # If the string is a URL (Windows paths appear as if they have a + # length-1 scheme), assume png. + if len(parsed.scheme) > 1: + ext = 'png' + else: + ext = Path(fname).suffix.lower()[1:] + elif hasattr(fname, 'geturl'): # Returned by urlopen(). + # We could try to parse the url's path and use the extension, but + # returning png is consistent with the block above. Note that this + # if clause has to come before checking for fname.name as + # urlopen("file:///...") also has a name attribute (with the fixed + # value ""). + ext = 'png' + elif hasattr(fname, 'name'): + ext = Path(fname.name).suffix.lower()[1:] + else: + ext = 'png' + else: + ext = format + img_open = ( + PIL.PngImagePlugin.PngImageFile if ext == 'png' else PIL.Image.open) + if isinstance(fname, str) and len(parse.urlparse(fname).scheme) > 1: + # Pillow doesn't handle URLs directly. + raise ValueError( + "Please open the URL for reading and pass the " + "result to Pillow, e.g. with " + "``np.array(PIL.Image.open(urllib.request.urlopen(url)))``." + ) + with img_open(fname) as image: + return (_pil_png_to_float_array(image) + if isinstance(image, PIL.PngImagePlugin.PngImageFile) else + pil_to_array(image)) + + +def imsave(fname, arr, vmin=None, vmax=None, cmap=None, format=None, + origin=None, dpi=100, *, metadata=None, pil_kwargs=None): + """ + Colormap and save an array as an image file. + + RGB(A) images are passed through. Single channel images will be + colormapped according to *cmap* and *norm*. + + .. note:: + + If you want to save a single channel image as gray scale please use an + image I/O library (such as pillow, tifffile, or imageio) directly. + + Parameters + ---------- + fname : str or path-like or file-like + A path or a file-like object to store the image in. + If *format* is not set, then the output format is inferred from the + extension of *fname*, if any, and from :rc:`savefig.format` otherwise. + If *format* is set, it determines the output format. + arr : array-like + The image data. Accepts NumPy arrays or sequences + (e.g., lists or tuples). The shape can be one of + MxN (luminance), MxNx3 (RGB) or MxNx4 (RGBA). + vmin, vmax : float, optional + *vmin* and *vmax* set the color scaling for the image by fixing the + values that map to the colormap color limits. If either *vmin* + or *vmax* is None, that limit is determined from the *arr* + min/max value. + cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap` + A Colormap instance or registered colormap name. The colormap + maps scalar data to colors. It is ignored for RGB(A) data. + format : str, optional + The file format, e.g. 'png', 'pdf', 'svg', ... The behavior when this + is unset is documented under *fname*. + origin : {'upper', 'lower'}, default: :rc:`image.origin` + Indicates whether the ``(0, 0)`` index of the array is in the upper + left or lower left corner of the Axes. + dpi : float + The DPI to store in the metadata of the file. This does not affect the + resolution of the output image. Depending on file format, this may be + rounded to the nearest integer. + metadata : dict, optional + Metadata in the image file. The supported keys depend on the output + format, see the documentation of the respective backends for more + information. + Currently only supported for "png", "pdf", "ps", "eps", and "svg". + pil_kwargs : dict, optional + Keyword arguments passed to `PIL.Image.Image.save`. If the 'pnginfo' + key is present, it completely overrides *metadata*, including the + default 'Software' key. + """ + from matplotlib.figure import Figure + + # Normalizing input (e.g., list or tuples) to NumPy array if needed + arr = np.asanyarray(arr) + + if isinstance(fname, os.PathLike): + fname = os.fspath(fname) + if format is None: + format = (Path(fname).suffix[1:] if isinstance(fname, str) + else mpl.rcParams["savefig.format"]).lower() + if format in ["pdf", "ps", "eps", "svg"]: + # Vector formats that are not handled by PIL. + if pil_kwargs is not None: + raise ValueError( + f"Cannot use 'pil_kwargs' when saving to {format}") + fig = Figure(dpi=dpi, frameon=False) + fig.figimage(arr, cmap=cmap, vmin=vmin, vmax=vmax, origin=origin, + resize=True) + fig.savefig(fname, dpi=dpi, format=format, transparent=True, + metadata=metadata) + else: + # Don't bother creating an image; this avoids rounding errors on the + # size when dividing and then multiplying by dpi. + if origin is None: + origin = mpl.rcParams["image.origin"] + else: + _api.check_in_list(('upper', 'lower'), origin=origin) + if origin == "lower": + arr = arr[::-1] + if (isinstance(arr, memoryview) and arr.format == "B" + and arr.ndim == 3 and arr.shape[-1] == 4): + # Such an ``arr`` would also be handled fine by sm.to_rgba below + # (after casting with asarray), but it is useful to special-case it + # because that's what backend_agg passes, and can be in fact used + # as is, saving a few operations. + rgba = arr + else: + sm = mcolorizer.Colorizer(cmap=cmap) + sm.set_clim(vmin, vmax) + rgba = sm.to_rgba(arr, bytes=True) + if pil_kwargs is None: + pil_kwargs = {} + else: + # we modify this below, so make a copy (don't modify caller's dict) + pil_kwargs = pil_kwargs.copy() + pil_shape = (rgba.shape[1], rgba.shape[0]) + rgba = np.require(rgba, requirements='C') + image = PIL.Image.frombuffer( + "RGBA", pil_shape, rgba, "raw", "RGBA", 0, 1) + if format == "png": + # Only use the metadata kwarg if pnginfo is not set, because the + # semantics of duplicate keys in pnginfo is unclear. + if "pnginfo" in pil_kwargs: + if metadata: + _api.warn_external("'metadata' is overridden by the " + "'pnginfo' entry in 'pil_kwargs'.") + else: + metadata = { + "Software": (f"Matplotlib version{mpl.__version__}, " + f"https://matplotlib.org/"), + **(metadata if metadata is not None else {}), + } + pil_kwargs["pnginfo"] = pnginfo = PIL.PngImagePlugin.PngInfo() + for k, v in metadata.items(): + if v is not None: + pnginfo.add_text(k, v) + elif metadata is not None: + raise ValueError(f"metadata not supported for format {format!r}") + if format in ["jpg", "jpeg"]: + format = "jpeg" # Pillow doesn't recognize "jpg". + facecolor = mpl.rcParams["savefig.facecolor"] + if cbook._str_equal(facecolor, "auto"): + facecolor = mpl.rcParams["figure.facecolor"] + color = tuple(int(x * 255) for x in mcolors.to_rgb(facecolor)) + background = PIL.Image.new("RGB", pil_shape, color) + background.paste(image, image) + image = background + pil_kwargs.setdefault("format", format) + pil_kwargs.setdefault("dpi", (dpi, dpi)) + image.save(fname, **pil_kwargs) + + +def pil_to_array(pilImage): + """ + Load a `PIL image`_ and return it as a numpy int array. + + .. _PIL image: https://pillow.readthedocs.io/en/latest/reference/Image.html + + Returns + ------- + numpy.array + + The array shape depends on the image type: + + - (M, N) for grayscale images. + - (M, N, 3) for RGB images. + - (M, N, 4) for RGBA images. + """ + if pilImage.mode in ['RGBA', 'RGBX', 'RGB', 'L']: + # return MxNx4 RGBA, MxNx3 RBA, or MxN luminance array + return np.asarray(pilImage) + elif pilImage.mode.startswith('I;16'): + # return MxN luminance array of uint16 + raw = pilImage.tobytes('raw', pilImage.mode) + if pilImage.mode.endswith('B'): + x = np.frombuffer(raw, '>u2') + else: + x = np.frombuffer(raw, '`_ +provides an example of an algorithm for such conversion, which avoids illegal +characters, reserved file names, ambiguity between upper- and lower-case +characters, and clashes with existing files. + +This code was originally copied from +`ufoLib `_ +by Tal Leming and is copyright (c) 2005-2016, The RoboFab Developers: + +- Erik van Blokland +- Tal Leming +- Just van Rossum +""" + +illegalCharacters = r"\" * + / : < > ? [ \ ] | \0".split(" ") +illegalCharacters += [chr(i) for i in range(1, 32)] +illegalCharacters += [chr(0x7F)] +reservedFileNames = "CON PRN AUX CLOCK$ NUL A:-Z: COM1".lower().split(" ") +reservedFileNames += "LPT1 LPT2 LPT3 COM2 COM3 COM4".lower().split(" ") +maxFileNameLength = 255 + + +class NameTranslationError(Exception): + pass + + +def userNameToFileName(userName, existing=[], prefix="", suffix=""): + """Converts from a user name to a file name. + + Takes care to avoid illegal characters, reserved file names, ambiguity between + upper- and lower-case characters, and clashes with existing files. + + Args: + userName (str): The input file name. + existing: A case-insensitive list of all existing file names. + prefix: Prefix to be prepended to the file name. + suffix: Suffix to be appended to the file name. + + Returns: + A suitable filename. + + Raises: + NameTranslationError: If no suitable name could be generated. + + Examples:: + + >>> userNameToFileName("a") == "a" + True + >>> userNameToFileName("A") == "A_" + True + >>> userNameToFileName("AE") == "A_E_" + True + >>> userNameToFileName("Ae") == "A_e" + True + >>> userNameToFileName("ae") == "ae" + True + >>> userNameToFileName("aE") == "aE_" + True + >>> userNameToFileName("a.alt") == "a.alt" + True + >>> userNameToFileName("A.alt") == "A_.alt" + True + >>> userNameToFileName("A.Alt") == "A_.A_lt" + True + >>> userNameToFileName("A.aLt") == "A_.aL_t" + True + >>> userNameToFileName(u"A.alT") == "A_.alT_" + True + >>> userNameToFileName("T_H") == "T__H_" + True + >>> userNameToFileName("T_h") == "T__h" + True + >>> userNameToFileName("t_h") == "t_h" + True + >>> userNameToFileName("F_F_I") == "F__F__I_" + True + >>> userNameToFileName("f_f_i") == "f_f_i" + True + >>> userNameToFileName("Aacute_V.swash") == "A_acute_V_.swash" + True + >>> userNameToFileName(".notdef") == "_notdef" + True + >>> userNameToFileName("con") == "_con" + True + >>> userNameToFileName("CON") == "C_O_N_" + True + >>> userNameToFileName("con.alt") == "_con.alt" + True + >>> userNameToFileName("alt.con") == "alt._con" + True + """ + # the incoming name must be a str + if not isinstance(userName, str): + raise ValueError("The value for userName must be a string.") + # establish the prefix and suffix lengths + prefixLength = len(prefix) + suffixLength = len(suffix) + # replace an initial period with an _ + # if no prefix is to be added + if not prefix and userName[0] == ".": + userName = "_" + userName[1:] + # filter the user name + filteredUserName = [] + for character in userName: + # replace illegal characters with _ + if character in illegalCharacters: + character = "_" + # add _ to all non-lower characters + elif character != character.lower(): + character += "_" + filteredUserName.append(character) + userName = "".join(filteredUserName) + # clip to 255 + sliceLength = maxFileNameLength - prefixLength - suffixLength + userName = userName[:sliceLength] + # test for illegal files names + parts = [] + for part in userName.split("."): + if part.lower() in reservedFileNames: + part = "_" + part + parts.append(part) + userName = ".".join(parts) + # test for clash + fullName = prefix + userName + suffix + if fullName.lower() in existing: + fullName = handleClash1(userName, existing, prefix, suffix) + # finished + return fullName + + +def handleClash1(userName, existing=[], prefix="", suffix=""): + """ + existing should be a case-insensitive list + of all existing file names. + + >>> prefix = ("0" * 5) + "." + >>> suffix = "." + ("0" * 10) + >>> existing = ["a" * 5] + + >>> e = list(existing) + >>> handleClash1(userName="A" * 5, existing=e, + ... prefix=prefix, suffix=suffix) == ( + ... '00000.AAAAA000000000000001.0000000000') + True + + >>> e = list(existing) + >>> e.append(prefix + "aaaaa" + "1".zfill(15) + suffix) + >>> handleClash1(userName="A" * 5, existing=e, + ... prefix=prefix, suffix=suffix) == ( + ... '00000.AAAAA000000000000002.0000000000') + True + + >>> e = list(existing) + >>> e.append(prefix + "AAAAA" + "2".zfill(15) + suffix) + >>> handleClash1(userName="A" * 5, existing=e, + ... prefix=prefix, suffix=suffix) == ( + ... '00000.AAAAA000000000000001.0000000000') + True + """ + # if the prefix length + user name length + suffix length + 15 is at + # or past the maximum length, silce 15 characters off of the user name + prefixLength = len(prefix) + suffixLength = len(suffix) + if prefixLength + len(userName) + suffixLength + 15 > maxFileNameLength: + l = prefixLength + len(userName) + suffixLength + 15 + sliceLength = maxFileNameLength - l + userName = userName[:sliceLength] + finalName = None + # try to add numbers to create a unique name + counter = 1 + while finalName is None: + name = userName + str(counter).zfill(15) + fullName = prefix + name + suffix + if fullName.lower() not in existing: + finalName = fullName + break + else: + counter += 1 + if counter >= 999999999999999: + break + # if there is a clash, go to the next fallback + if finalName is None: + finalName = handleClash2(existing, prefix, suffix) + # finished + return finalName + + +def handleClash2(existing=[], prefix="", suffix=""): + """ + existing should be a case-insensitive list + of all existing file names. + + >>> prefix = ("0" * 5) + "." + >>> suffix = "." + ("0" * 10) + >>> existing = [prefix + str(i) + suffix for i in range(100)] + + >>> e = list(existing) + >>> handleClash2(existing=e, prefix=prefix, suffix=suffix) == ( + ... '00000.100.0000000000') + True + + >>> e = list(existing) + >>> e.remove(prefix + "1" + suffix) + >>> handleClash2(existing=e, prefix=prefix, suffix=suffix) == ( + ... '00000.1.0000000000') + True + + >>> e = list(existing) + >>> e.remove(prefix + "2" + suffix) + >>> handleClash2(existing=e, prefix=prefix, suffix=suffix) == ( + ... '00000.2.0000000000') + True + """ + # calculate the longest possible string + maxLength = maxFileNameLength - len(prefix) - len(suffix) + maxValue = int("9" * maxLength) + # try to find a number + finalName = None + counter = 1 + while finalName is None: + fullName = prefix + str(counter) + suffix + if fullName.lower() not in existing: + finalName = fullName + break + else: + counter += 1 + if counter >= maxValue: + break + # raise an error if nothing has been found + if finalName is None: + raise NameTranslationError("No unique name could be found.") + # finished + return finalName + + +if __name__ == "__main__": + import doctest + import sys + + sys.exit(doctest.testmod().failed) diff --git a/shared/package-files/30/30c13e462ae4c1c8f11dafa99c95d298487aab93c23766a0a9011c1e0482cac3/blob b/shared/package-files/30/30c13e462ae4c1c8f11dafa99c95d298487aab93c23766a0a9011c1e0482cac3/blob new file mode 100644 index 0000000000000000000000000000000000000000..ad2c5a27bea9e44037a3708d7bd5ba2fa1a4d456 --- /dev/null +++ b/shared/package-files/30/30c13e462ae4c1c8f11dafa99c95d298487aab93c23766a0a9011c1e0482cac3/blob @@ -0,0 +1,1847 @@ +from datetime import ( + date, + datetime, +) +from decimal import Decimal +import os + +import numpy as np +import pytest + +from pandas.compat.numpy import ( + np_version_gt2, + np_version_gte1p24, +) +from pandas.errors import IndexingError + +from pandas.core.dtypes.common import is_list_like + +from pandas import ( + NA, + Categorical, + DataFrame, + DatetimeIndex, + Index, + Interval, + IntervalIndex, + MultiIndex, + NaT, + Period, + Series, + Timedelta, + Timestamp, + array, + concat, + date_range, + interval_range, + period_range, + timedelta_range, +) +import pandas._testing as tm + +from pandas.tseries.offsets import BDay + + +class TestSetitemDT64Values: + def test_setitem_none_nan(self): + series = Series(date_range("1/1/2000", periods=10)) + series[3] = None + assert series[3] is NaT + + series[3:5] = None + assert series[4] is NaT + + series[5] = np.nan + assert series[5] is NaT + + series[5:7] = np.nan + assert series[6] is NaT + + def test_setitem_multiindex_empty_slice(self): + # https://github.com/pandas-dev/pandas/issues/35878 + idx = MultiIndex.from_tuples([("a", 1), ("b", 2)]) + result = Series([1, 2], index=idx) + expected = result.copy() + result.loc[[]] = 0 + tm.assert_series_equal(result, expected) + + def test_setitem_with_string_index(self): + # GH#23451 + # Set object dtype to avoid upcast when setting date.today() + ser = Series([1, 2, 3], index=["Date", "b", "other"], dtype=object) + ser["Date"] = date.today() + assert ser.Date == date.today() + assert ser["Date"] == date.today() + + def test_setitem_tuple_with_datetimetz_values(self): + # GH#20441 + arr = date_range("2017", periods=4, tz="US/Eastern") + index = [(0, 1), (0, 2), (0, 3), (0, 4)] + result = Series(arr, index=index) + expected = result.copy() + result[(0, 1)] = np.nan + expected.iloc[0] = np.nan + tm.assert_series_equal(result, expected) + + @pytest.mark.parametrize("tz", ["US/Eastern", "UTC", "Asia/Tokyo"]) + def test_setitem_with_tz(self, tz, indexer_sli): + orig = Series(date_range("2016-01-01", freq="h", periods=3, tz=tz)) + assert orig.dtype == f"datetime64[ns, {tz}]" + + exp = Series( + [ + Timestamp("2016-01-01 00:00", tz=tz), + Timestamp("2011-01-01 00:00", tz=tz), + Timestamp("2016-01-01 02:00", tz=tz), + ], + dtype=orig.dtype, + ) + + # scalar + ser = orig.copy() + indexer_sli(ser)[1] = Timestamp("2011-01-01", tz=tz) + tm.assert_series_equal(ser, exp) + + # vector + vals = Series( + [Timestamp("2011-01-01", tz=tz), Timestamp("2012-01-01", tz=tz)], + index=[1, 2], + dtype=orig.dtype, + ) + assert vals.dtype == f"datetime64[ns, {tz}]" + + exp = Series( + [ + Timestamp("2016-01-01 00:00", tz=tz), + Timestamp("2011-01-01 00:00", tz=tz), + Timestamp("2012-01-01 00:00", tz=tz), + ], + dtype=orig.dtype, + ) + + ser = orig.copy() + indexer_sli(ser)[[1, 2]] = vals + tm.assert_series_equal(ser, exp) + + def test_setitem_with_tz_dst(self, indexer_sli): + # GH#14146 trouble setting values near DST boundary + tz = "US/Eastern" + orig = Series(date_range("2016-11-06", freq="h", periods=3, tz=tz)) + assert orig.dtype == f"datetime64[ns, {tz}]" + + exp = Series( + [ + Timestamp("2016-11-06 00:00-04:00", tz=tz), + Timestamp("2011-01-01 00:00-05:00", tz=tz), + Timestamp("2016-11-06 01:00-05:00", tz=tz), + ], + dtype=orig.dtype, + ) + + # scalar + ser = orig.copy() + indexer_sli(ser)[1] = Timestamp("2011-01-01", tz=tz) + tm.assert_series_equal(ser, exp) + + # vector + vals = Series( + [Timestamp("2011-01-01", tz=tz), Timestamp("2012-01-01", tz=tz)], + index=[1, 2], + dtype=orig.dtype, + ) + assert vals.dtype == f"datetime64[ns, {tz}]" + + exp = Series( + [ + Timestamp("2016-11-06 00:00", tz=tz), + Timestamp("2011-01-01 00:00", tz=tz), + Timestamp("2012-01-01 00:00", tz=tz), + ], + dtype=orig.dtype, + ) + + ser = orig.copy() + indexer_sli(ser)[[1, 2]] = vals + tm.assert_series_equal(ser, exp) + + def test_object_series_setitem_dt64array_exact_match(self): + # make sure the dt64 isn't cast by numpy to integers + # https://github.com/numpy/numpy/issues/12550 + + ser = Series({"X": np.nan}, dtype=object) + + indexer = [True] + + # "exact_match" -> size of array being set matches size of ser + value = np.array([4], dtype="M8[ns]") + + ser.iloc[indexer] = value + + expected = Series([value[0]], index=["X"], dtype=object) + assert all(isinstance(x, np.datetime64) for x in expected.values) + + tm.assert_series_equal(ser, expected) + + +class TestSetitemScalarIndexer: + def test_setitem_negative_out_of_bounds(self): + ser = Series(["a"] * 10, index=["a"] * 10) + + # string index falls back to positional + msg = "index -11|-1 is out of bounds for axis 0 with size 10" + warn_msg = "Series.__setitem__ treating keys as positions is deprecated" + with pytest.raises(IndexError, match=msg): + with tm.assert_produces_warning(FutureWarning, match=warn_msg): + ser[-11] = "foo" + + @pytest.mark.parametrize("indexer", [tm.loc, tm.at]) + @pytest.mark.parametrize("ser_index", [0, 1]) + def test_setitem_series_object_dtype(self, indexer, ser_index): + # GH#38303 + ser = Series([0, 0], dtype="object") + idxr = indexer(ser) + idxr[0] = Series([42], index=[ser_index]) + expected = Series([Series([42], index=[ser_index]), 0], dtype="object") + tm.assert_series_equal(ser, expected) + + @pytest.mark.parametrize("index, exp_value", [(0, 42), (1, np.nan)]) + def test_setitem_series(self, index, exp_value): + # GH#38303 + ser = Series([0, 0]) + ser.loc[0] = Series([42], index=[index]) + expected = Series([exp_value, 0]) + tm.assert_series_equal(ser, expected) + + +class TestSetitemSlices: + def test_setitem_slice_float_raises(self, datetime_series): + msg = ( + "cannot do slice indexing on DatetimeIndex with these indexers " + r"\[{key}\] of type float" + ) + with pytest.raises(TypeError, match=msg.format(key=r"4\.0")): + datetime_series[4.0:10.0] = 0 + + with pytest.raises(TypeError, match=msg.format(key=r"4\.5")): + datetime_series[4.5:10.0] = 0 + + def test_setitem_slice(self): + ser = Series(range(10), index=list(range(10))) + ser[-12:] = 0 + assert (ser == 0).all() + + ser[:-12] = 5 + assert (ser == 0).all() + + def test_setitem_slice_integers(self): + ser = Series( + np.random.default_rng(2).standard_normal(8), + index=[2, 4, 6, 8, 10, 12, 14, 16], + ) + + ser[:4] = 0 + assert (ser[:4] == 0).all() + assert not (ser[4:] == 0).any() + + def test_setitem_slicestep(self): + # caught this bug when writing tests + series = Series( + np.arange(20, dtype=np.float64), index=np.arange(20, dtype=np.int64) + ) + + series[::2] = 0 + assert (series[::2] == 0).all() + + def test_setitem_multiindex_slice(self, indexer_sli): + # GH 8856 + mi = MultiIndex.from_product(([0, 1], list("abcde"))) + result = Series(np.arange(10, dtype=np.int64), mi) + indexer_sli(result)[::4] = 100 + expected = Series([100, 1, 2, 3, 100, 5, 6, 7, 100, 9], mi) + tm.assert_series_equal(result, expected) + + +class TestSetitemBooleanMask: + def test_setitem_mask_cast(self): + # GH#2746 + # need to upcast + ser = Series([1, 2], index=[1, 2], dtype="int64") + ser[[True, False]] = Series([0], index=[1], dtype="int64") + expected = Series([0, 2], index=[1, 2], dtype="int64") + + tm.assert_series_equal(ser, expected) + + def test_setitem_mask_align_and_promote(self): + # GH#8387: test that changing types does not break alignment + ts = Series( + np.random.default_rng(2).standard_normal(100), index=np.arange(100, 0, -1) + ).round(5) + mask = ts > 0 + left = ts.copy() + right = ts[mask].copy().map(str) + with tm.assert_produces_warning( + FutureWarning, match="item of incompatible dtype" + ): + left[mask] = right + expected = ts.map(lambda t: str(t) if t > 0 else t) + tm.assert_series_equal(left, expected) + + def test_setitem_mask_promote_strs(self): + ser = Series([0, 1, 2, 0]) + mask = ser > 0 + ser2 = ser[mask].map(str) + with tm.assert_produces_warning( + FutureWarning, match="item of incompatible dtype" + ): + ser[mask] = ser2 + + expected = Series([0, "1", "2", 0]) + tm.assert_series_equal(ser, expected) + + def test_setitem_mask_promote(self): + ser = Series([0, "foo", "bar", 0]) + mask = Series([False, True, True, False]) + ser2 = ser[mask] + ser[mask] = ser2 + + expected = Series([0, "foo", "bar", 0]) + tm.assert_series_equal(ser, expected) + + def test_setitem_boolean(self, string_series): + mask = string_series > string_series.median() + + # similar indexed series + result = string_series.copy() + result[mask] = string_series * 2 + expected = string_series * 2 + tm.assert_series_equal(result[mask], expected[mask]) + + # needs alignment + result = string_series.copy() + result[mask] = (string_series * 2)[0:5] + expected = (string_series * 2)[0:5].reindex_like(string_series) + expected[-mask] = string_series[mask] + tm.assert_series_equal(result[mask], expected[mask]) + + def test_setitem_boolean_corner(self, datetime_series): + ts = datetime_series + mask_shifted = ts.shift(1, freq=BDay()) > ts.median() + + msg = ( + r"Unalignable boolean Series provided as indexer \(index of " + r"the boolean Series and of the indexed object do not match" + ) + with pytest.raises(IndexingError, match=msg): + ts[mask_shifted] = 1 + + with pytest.raises(IndexingError, match=msg): + ts.loc[mask_shifted] = 1 + + def test_setitem_boolean_different_order(self, string_series): + ordered = string_series.sort_values() + + copy = string_series.copy() + copy[ordered > 0] = 0 + + expected = string_series.copy() + expected[expected > 0] = 0 + + tm.assert_series_equal(copy, expected) + + @pytest.mark.parametrize("func", [list, np.array, Series]) + def test_setitem_boolean_python_list(self, func): + # GH19406 + ser = Series([None, "b", None]) + mask = func([True, False, True]) + ser[mask] = ["a", "c"] + expected = Series(["a", "b", "c"]) + tm.assert_series_equal(ser, expected) + + def test_setitem_boolean_nullable_int_types(self, any_numeric_ea_dtype): + # GH: 26468 + ser = Series([5, 6, 7, 8], dtype=any_numeric_ea_dtype) + ser[ser > 6] = Series(range(4), dtype=any_numeric_ea_dtype) + expected = Series([5, 6, 2, 3], dtype=any_numeric_ea_dtype) + tm.assert_series_equal(ser, expected) + + ser = Series([5, 6, 7, 8], dtype=any_numeric_ea_dtype) + ser.loc[ser > 6] = Series(range(4), dtype=any_numeric_ea_dtype) + tm.assert_series_equal(ser, expected) + + ser = Series([5, 6, 7, 8], dtype=any_numeric_ea_dtype) + loc_ser = Series(range(4), dtype=any_numeric_ea_dtype) + ser.loc[ser > 6] = loc_ser.loc[loc_ser > 1] + tm.assert_series_equal(ser, expected) + + def test_setitem_with_bool_mask_and_values_matching_n_trues_in_length(self): + # GH#30567 + ser = Series([None] * 10) + mask = [False] * 3 + [True] * 5 + [False] * 2 + ser[mask] = range(5) + result = ser + expected = Series([None] * 3 + list(range(5)) + [None] * 2, dtype=object) + tm.assert_series_equal(result, expected) + + def test_setitem_nan_with_bool(self): + # GH 13034 + result = Series([True, False, True]) + with tm.assert_produces_warning( + FutureWarning, match="item of incompatible dtype" + ): + result[0] = np.nan + expected = Series([np.nan, False, True], dtype=object) + tm.assert_series_equal(result, expected) + + def test_setitem_mask_smallint_upcast(self): + orig = Series([1, 2, 3], dtype="int8") + alt = np.array([999, 1000, 1001], dtype=np.int64) + + mask = np.array([True, False, True]) + + ser = orig.copy() + with tm.assert_produces_warning( + FutureWarning, match="item of incompatible dtype" + ): + ser[mask] = Series(alt) + expected = Series([999, 2, 1001]) + tm.assert_series_equal(ser, expected) + + ser2 = orig.copy() + with tm.assert_produces_warning( + FutureWarning, match="item of incompatible dtype" + ): + ser2.mask(mask, alt, inplace=True) + tm.assert_series_equal(ser2, expected) + + ser3 = orig.copy() + res = ser3.where(~mask, Series(alt)) + tm.assert_series_equal(res, expected) + + def test_setitem_mask_smallint_no_upcast(self): + # like test_setitem_mask_smallint_upcast, but while we can't hold 'alt', + # we *can* hold alt[mask] without casting + orig = Series([1, 2, 3], dtype="uint8") + alt = Series([245, 1000, 246], dtype=np.int64) + + mask = np.array([True, False, True]) + + ser = orig.copy() + ser[mask] = alt + expected = Series([245, 2, 246], dtype="uint8") + tm.assert_series_equal(ser, expected) + + ser2 = orig.copy() + ser2.mask(mask, alt, inplace=True) + tm.assert_series_equal(ser2, expected) + + # TODO: ser.where(~mask, alt) unnecessarily upcasts to int64 + ser3 = orig.copy() + res = ser3.where(~mask, alt) + tm.assert_series_equal(res, expected, check_dtype=False) + + +class TestSetitemViewCopySemantics: + def test_setitem_invalidates_datetime_index_freq(self, using_copy_on_write): + # GH#24096 altering a datetime64tz Series inplace invalidates the + # `freq` attribute on the underlying DatetimeIndex + + dti = date_range("20130101", periods=3, tz="US/Eastern") + ts = dti[1] + ser = Series(dti) + assert ser._values is not dti + if using_copy_on_write: + assert ser._values._ndarray.base is dti._data._ndarray.base + else: + assert ser._values._ndarray.base is not dti._data._ndarray.base + assert dti.freq == "D" + ser.iloc[1] = NaT + assert ser._values.freq is None + + # check that the DatetimeIndex was not altered in place + assert ser._values is not dti + assert ser._values._ndarray.base is not dti._data._ndarray.base + assert dti[1] == ts + assert dti.freq == "D" + + def test_dt64tz_setitem_does_not_mutate_dti(self, using_copy_on_write): + # GH#21907, GH#24096 + dti = date_range("2016-01-01", periods=10, tz="US/Pacific") + ts = dti[0] + ser = Series(dti) + assert ser._values is not dti + if using_copy_on_write: + assert ser._values._ndarray.base is dti._data._ndarray.base + assert ser._mgr.arrays[0]._ndarray.base is dti._data._ndarray.base + else: + assert ser._values._ndarray.base is not dti._data._ndarray.base + assert ser._mgr.arrays[0]._ndarray.base is not dti._data._ndarray.base + + assert ser._mgr.arrays[0] is not dti + + ser[::3] = NaT + assert ser[0] is NaT + assert dti[0] == ts + + +class TestSetitemCallable: + def test_setitem_callable_key(self): + # GH#12533 + ser = Series([1, 2, 3, 4], index=list("ABCD")) + ser[lambda x: "A"] = -1 + + expected = Series([-1, 2, 3, 4], index=list("ABCD")) + tm.assert_series_equal(ser, expected) + + def test_setitem_callable_other(self): + # GH#13299 + inc = lambda x: x + 1 + + # set object dtype to avoid upcast when setting inc + ser = Series([1, 2, -1, 4], dtype=object) + ser[ser < 0] = inc + + expected = Series([1, 2, inc, 4]) + tm.assert_series_equal(ser, expected) + + +class TestSetitemWithExpansion: + def test_setitem_empty_series(self): + # GH#10193 + key = Timestamp("2012-01-01") + series = Series(dtype=object) + series[key] = 47 + expected = Series(47, [key]) + tm.assert_series_equal(series, expected) + + def test_setitem_empty_series_datetimeindex_preserves_freq(self): + # GH#33573 our index should retain its freq + dti = DatetimeIndex([], freq="D", dtype="M8[ns]") + series = Series([], index=dti, dtype=object) + key = Timestamp("2012-01-01") + series[key] = 47 + expected = Series(47, DatetimeIndex([key], freq="D").as_unit("ns")) + tm.assert_series_equal(series, expected) + assert series.index.freq == expected.index.freq + + def test_setitem_empty_series_timestamp_preserves_dtype(self): + # GH 21881 + timestamp = Timestamp(1412526600000000000) + series = Series([timestamp], index=["timestamp"], dtype=object) + expected = series["timestamp"] + + series = Series([], dtype=object) + series["anything"] = 300.0 + series["timestamp"] = timestamp + result = series["timestamp"] + assert result == expected + + @pytest.mark.parametrize( + "td", + [ + Timedelta("9 days"), + Timedelta("9 days").to_timedelta64(), + Timedelta("9 days").to_pytimedelta(), + ], + ) + def test_append_timedelta_does_not_cast(self, td, using_infer_string, request): + # GH#22717 inserting a Timedelta should _not_ cast to int64 + if using_infer_string and not isinstance(td, Timedelta): + # TODO: GH#56010 + request.applymarker(pytest.mark.xfail(reason="inferred as string")) + + expected = Series(["x", td], index=[0, "td"], dtype=object) + + ser = Series(["x"]) + ser["td"] = td + tm.assert_series_equal(ser, expected) + assert isinstance(ser["td"], Timedelta) + + ser = Series(["x"]) + ser.loc["td"] = Timedelta("9 days") + tm.assert_series_equal(ser, expected) + assert isinstance(ser["td"], Timedelta) + + def test_setitem_with_expansion_type_promotion(self): + # GH#12599 + ser = Series(dtype=object) + ser["a"] = Timestamp("2016-01-01") + ser["b"] = 3.0 + ser["c"] = "foo" + expected = Series([Timestamp("2016-01-01"), 3.0, "foo"], index=["a", "b", "c"]) + tm.assert_series_equal(ser, expected) + + def test_setitem_not_contained(self, string_series): + # set item that's not contained + ser = string_series.copy() + assert "foobar" not in ser.index + ser["foobar"] = 1 + + app = Series([1], index=["foobar"], name="series") + expected = concat([string_series, app]) + tm.assert_series_equal(ser, expected) + + def test_setitem_keep_precision(self, any_numeric_ea_dtype): + # GH#32346 + ser = Series([1, 2], dtype=any_numeric_ea_dtype) + ser[2] = 10 + expected = Series([1, 2, 10], dtype=any_numeric_ea_dtype) + tm.assert_series_equal(ser, expected) + + @pytest.mark.parametrize( + "na, target_na, dtype, target_dtype, indexer, warn", + [ + (NA, NA, "Int64", "Int64", 1, None), + (NA, NA, "Int64", "Int64", 2, None), + (NA, np.nan, "int64", "float64", 1, None), + (NA, np.nan, "int64", "float64", 2, None), + (NaT, NaT, "int64", "object", 1, FutureWarning), + (NaT, NaT, "int64", "object", 2, None), + (np.nan, NA, "Int64", "Int64", 1, None), + (np.nan, NA, "Int64", "Int64", 2, None), + (np.nan, NA, "Float64", "Float64", 1, None), + (np.nan, NA, "Float64", "Float64", 2, None), + (np.nan, np.nan, "int64", "float64", 1, None), + (np.nan, np.nan, "int64", "float64", 2, None), + ], + ) + def test_setitem_enlarge_with_na( + self, na, target_na, dtype, target_dtype, indexer, warn + ): + # GH#32346 + ser = Series([1, 2], dtype=dtype) + with tm.assert_produces_warning(warn, match="incompatible dtype"): + ser[indexer] = na + expected_values = [1, target_na] if indexer == 1 else [1, 2, target_na] + expected = Series(expected_values, dtype=target_dtype) + tm.assert_series_equal(ser, expected) + + def test_setitem_enlargement_object_none(self, nulls_fixture, using_infer_string): + # GH#48665 + ser = Series(["a", "b"]) + ser[3] = nulls_fixture + dtype = ( + "str" + if using_infer_string and not isinstance(nulls_fixture, Decimal) + else object + ) + expected = Series(["a", "b", nulls_fixture], index=[0, 1, 3], dtype=dtype) + tm.assert_series_equal(ser, expected) + if using_infer_string: + ser[3] is np.nan + else: + assert ser[3] is nulls_fixture + + +def test_setitem_scalar_into_readonly_backing_data(): + # GH#14359: test that you cannot mutate a read only buffer + + array = np.zeros(5) + array.flags.writeable = False # make the array immutable + series = Series(array, copy=False) + + for n in series.index: + msg = "assignment destination is read-only" + with pytest.raises(ValueError, match=msg): + series[n] = 1 + + assert array[n] == 0 + + +def test_setitem_slice_into_readonly_backing_data(): + # GH#14359: test that you cannot mutate a read only buffer + + array = np.zeros(5) + array.flags.writeable = False # make the array immutable + series = Series(array, copy=False) + + msg = "assignment destination is read-only" + with pytest.raises(ValueError, match=msg): + series[1:3] = 1 + + assert not array.any() + + +def test_setitem_categorical_assigning_ops(): + orig = Series(Categorical(["b", "b"], categories=["a", "b"])) + ser = orig.copy() + ser[:] = "a" + exp = Series(Categorical(["a", "a"], categories=["a", "b"])) + tm.assert_series_equal(ser, exp) + + ser = orig.copy() + ser[1] = "a" + exp = Series(Categorical(["b", "a"], categories=["a", "b"])) + tm.assert_series_equal(ser, exp) + + ser = orig.copy() + ser[ser.index > 0] = "a" + exp = Series(Categorical(["b", "a"], categories=["a", "b"])) + tm.assert_series_equal(ser, exp) + + ser = orig.copy() + ser[[False, True]] = "a" + exp = Series(Categorical(["b", "a"], categories=["a", "b"])) + tm.assert_series_equal(ser, exp) + + ser = orig.copy() + ser.index = ["x", "y"] + ser["y"] = "a" + exp = Series(Categorical(["b", "a"], categories=["a", "b"]), index=["x", "y"]) + tm.assert_series_equal(ser, exp) + + +def test_setitem_nan_into_categorical(): + # ensure that one can set something to np.nan + ser = Series(Categorical([1, 2, 3])) + exp = Series(Categorical([1, np.nan, 3], categories=[1, 2, 3])) + ser[1] = np.nan + tm.assert_series_equal(ser, exp) + + +class TestSetitemCasting: + @pytest.mark.parametrize("unique", [True, False]) + @pytest.mark.parametrize("val", [3, 3.0, "3"], ids=type) + def test_setitem_non_bool_into_bool(self, val, indexer_sli, unique): + # dont cast these 3-like values to bool + ser = Series([True, False]) + if not unique: + ser.index = [1, 1] + + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + indexer_sli(ser)[1] = val + assert type(ser.iloc[1]) == type(val) + + expected = Series([True, val], dtype=object, index=ser.index) + if not unique and indexer_sli is not tm.iloc: + expected = Series([val, val], dtype=object, index=[1, 1]) + tm.assert_series_equal(ser, expected) + + def test_setitem_boolean_array_into_npbool(self): + # GH#45462 + ser = Series([True, False, True]) + values = ser._values + arr = array([True, False, None]) + + ser[:2] = arr[:2] # no NAs -> can set inplace + assert ser._values is values + + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + ser[1:] = arr[1:] # has an NA -> cast to boolean dtype + expected = Series(arr) + tm.assert_series_equal(ser, expected) + + +class SetitemCastingEquivalents: + """ + Check each of several methods that _should_ be equivalent to `obj[key] = val` + + We assume that + - obj.index is the default Index(range(len(obj))) + - the setitem does not expand the obj + """ + + @pytest.fixture + def is_inplace(self, obj, expected): + """ + Whether we expect the setting to be in-place or not. + """ + return expected.dtype == obj.dtype + + def check_indexer(self, obj, key, expected, val, indexer, is_inplace): + orig = obj + obj = obj.copy() + arr = obj._values + + indexer(obj)[key] = val + tm.assert_series_equal(obj, expected) + + self._check_inplace(is_inplace, orig, arr, obj) + + def _check_inplace(self, is_inplace, orig, arr, obj): + if is_inplace is None: + # We are not (yet) checking whether setting is inplace or not + pass + elif is_inplace: + if arr.dtype.kind in ["m", "M"]: + # We may not have the same DTA/TDA, but will have the same + # underlying data + assert arr._ndarray is obj._values._ndarray + else: + assert obj._values is arr + else: + # otherwise original array should be unchanged + tm.assert_equal(arr, orig._values) + + def test_int_key(self, obj, key, expected, warn, val, indexer_sli, is_inplace): + if not isinstance(key, int): + pytest.skip("Not relevant for int key") + + with tm.assert_produces_warning(warn, match="incompatible dtype"): + self.check_indexer(obj, key, expected, val, indexer_sli, is_inplace) + + if indexer_sli is tm.loc: + with tm.assert_produces_warning(warn, match="incompatible dtype"): + self.check_indexer(obj, key, expected, val, tm.at, is_inplace) + elif indexer_sli is tm.iloc: + with tm.assert_produces_warning(warn, match="incompatible dtype"): + self.check_indexer(obj, key, expected, val, tm.iat, is_inplace) + + rng = range(key, key + 1) + with tm.assert_produces_warning(warn, match="incompatible dtype"): + self.check_indexer(obj, rng, expected, val, indexer_sli, is_inplace) + + if indexer_sli is not tm.loc: + # Note: no .loc because that handles slice edges differently + slc = slice(key, key + 1) + with tm.assert_produces_warning(warn, match="incompatible dtype"): + self.check_indexer(obj, slc, expected, val, indexer_sli, is_inplace) + + ilkey = [key] + with tm.assert_produces_warning(warn, match="incompatible dtype"): + self.check_indexer(obj, ilkey, expected, val, indexer_sli, is_inplace) + + indkey = np.array(ilkey) + with tm.assert_produces_warning(warn, match="incompatible dtype"): + self.check_indexer(obj, indkey, expected, val, indexer_sli, is_inplace) + + genkey = (x for x in [key]) + with tm.assert_produces_warning(warn, match="incompatible dtype"): + self.check_indexer(obj, genkey, expected, val, indexer_sli, is_inplace) + + def test_slice_key(self, obj, key, expected, warn, val, indexer_sli, is_inplace): + if not isinstance(key, slice): + pytest.skip("Not relevant for slice key") + + if indexer_sli is not tm.loc: + # Note: no .loc because that handles slice edges differently + with tm.assert_produces_warning(warn, match="incompatible dtype"): + self.check_indexer(obj, key, expected, val, indexer_sli, is_inplace) + + ilkey = list(range(len(obj)))[key] + with tm.assert_produces_warning(warn, match="incompatible dtype"): + self.check_indexer(obj, ilkey, expected, val, indexer_sli, is_inplace) + + indkey = np.array(ilkey) + with tm.assert_produces_warning(warn, match="incompatible dtype"): + self.check_indexer(obj, indkey, expected, val, indexer_sli, is_inplace) + + genkey = (x for x in indkey) + with tm.assert_produces_warning(warn, match="incompatible dtype"): + self.check_indexer(obj, genkey, expected, val, indexer_sli, is_inplace) + + def test_mask_key(self, obj, key, expected, warn, val, indexer_sli): + # setitem with boolean mask + mask = np.zeros(obj.shape, dtype=bool) + mask[key] = True + + obj = obj.copy() + + if is_list_like(val) and len(val) < mask.sum(): + msg = "boolean index did not match indexed array along dimension" + with pytest.raises(IndexError, match=msg): + indexer_sli(obj)[mask] = val + return + + with tm.assert_produces_warning(warn, match="incompatible dtype"): + indexer_sli(obj)[mask] = val + tm.assert_series_equal(obj, expected) + + def test_series_where(self, obj, key, expected, warn, val, is_inplace): + mask = np.zeros(obj.shape, dtype=bool) + mask[key] = True + + if is_list_like(val) and len(val) < len(obj): + # Series.where is not valid here + msg = "operands could not be broadcast together with shapes" + with pytest.raises(ValueError, match=msg): + obj.where(~mask, val) + return + + orig = obj + obj = obj.copy() + arr = obj._values + + res = obj.where(~mask, val) + + if val is NA and res.dtype == object: + expected = expected.fillna(NA) + elif val is None and res.dtype == object: + assert expected.dtype == object + expected = expected.copy() + expected[expected.isna()] = None + tm.assert_series_equal(res, expected) + + self._check_inplace(is_inplace, orig, arr, obj) + + def test_index_where(self, obj, key, expected, warn, val): + mask = np.zeros(obj.shape, dtype=bool) + mask[key] = True + + res = Index(obj, dtype=obj.dtype).where(~mask, val) + expected_idx = Index(expected, dtype=expected.dtype) + tm.assert_index_equal(res, expected_idx) + + def test_index_putmask(self, obj, key, expected, warn, val): + mask = np.zeros(obj.shape, dtype=bool) + mask[key] = True + + res = Index(obj, dtype=obj.dtype).putmask(mask, val) + tm.assert_index_equal(res, Index(expected, dtype=expected.dtype)) + + +@pytest.mark.parametrize( + "obj,expected,key,warn", + [ + pytest.param( + # GH#45568 setting a valid NA value into IntervalDtype[int] should + # cast to IntervalDtype[float] + Series(interval_range(1, 5)), + Series( + [Interval(1, 2), np.nan, Interval(3, 4), Interval(4, 5)], + dtype="interval[float64]", + ), + 1, + FutureWarning, + id="interval_int_na_value", + ), + pytest.param( + # these induce dtype changes + Series([2, 3, 4, 5, 6, 7, 8, 9, 10]), + Series([np.nan, 3, np.nan, 5, np.nan, 7, np.nan, 9, np.nan]), + slice(None, None, 2), + None, + id="int_series_slice_key_step", + ), + pytest.param( + Series([True, True, False, False]), + Series([np.nan, True, np.nan, False], dtype=object), + slice(None, None, 2), + FutureWarning, + id="bool_series_slice_key_step", + ), + pytest.param( + # these induce dtype changes + Series(np.arange(10)), + Series([np.nan, np.nan, np.nan, np.nan, np.nan, 5, 6, 7, 8, 9]), + slice(None, 5), + None, + id="int_series_slice_key", + ), + pytest.param( + # changes dtype GH#4463 + Series([1, 2, 3]), + Series([np.nan, 2, 3]), + 0, + None, + id="int_series_int_key", + ), + pytest.param( + # changes dtype GH#4463 + Series([False]), + Series([np.nan], dtype=object), + # TODO: maybe go to float64 since we are changing the _whole_ Series? + 0, + FutureWarning, + id="bool_series_int_key_change_all", + ), + pytest.param( + # changes dtype GH#4463 + Series([False, True]), + Series([np.nan, True], dtype=object), + 0, + FutureWarning, + id="bool_series_int_key", + ), + ], +) +class TestSetitemCastingEquivalents(SetitemCastingEquivalents): + @pytest.fixture(params=[np.nan, np.float64("NaN"), None, NA]) + def val(self, request): + """ + NA values that should generally be valid_na for *all* dtypes. + + Include both python float NaN and np.float64; only np.float64 has a + `dtype` attribute. + """ + return request.param + + +class TestSetitemTimedelta64IntoNumeric(SetitemCastingEquivalents): + # timedelta64 should not be treated as integers when setting into + # numeric Series + + @pytest.fixture + def val(self): + td = np.timedelta64(4, "ns") + return td + # TODO: could also try np.full((1,), td) + + @pytest.fixture(params=[complex, int, float]) + def dtype(self, request): + return request.param + + @pytest.fixture + def obj(self, dtype): + arr = np.arange(5).astype(dtype) + ser = Series(arr) + return ser + + @pytest.fixture + def expected(self, dtype): + arr = np.arange(5).astype(dtype) + ser = Series(arr) + ser = ser.astype(object) + ser.iloc[0] = np.timedelta64(4, "ns") + return ser + + @pytest.fixture + def key(self): + return 0 + + @pytest.fixture + def warn(self): + return FutureWarning + + +class TestSetitemDT64IntoInt(SetitemCastingEquivalents): + # GH#39619 dont cast dt64 to int when doing this setitem + + @pytest.fixture(params=["M8[ns]", "m8[ns]"]) + def dtype(self, request): + return request.param + + @pytest.fixture + def scalar(self, dtype): + val = np.datetime64("2021-01-18 13:25:00", "ns") + if dtype == "m8[ns]": + val = val - val + return val + + @pytest.fixture + def expected(self, scalar): + expected = Series([scalar, scalar, 3], dtype=object) + assert isinstance(expected[0], type(scalar)) + return expected + + @pytest.fixture + def obj(self): + return Series([1, 2, 3]) + + @pytest.fixture + def key(self): + return slice(None, -1) + + @pytest.fixture(params=[None, list, np.array]) + def val(self, scalar, request): + box = request.param + if box is None: + return scalar + return box([scalar, scalar]) + + @pytest.fixture + def warn(self): + return FutureWarning + + +class TestSetitemNAPeriodDtype(SetitemCastingEquivalents): + # Setting compatible NA values into Series with PeriodDtype + + @pytest.fixture + def expected(self, key): + exp = Series(period_range("2000-01-01", periods=10, freq="D")) + exp._values.view("i8")[key] = NaT._value + assert exp[key] is NaT or all(x is NaT for x in exp[key]) + return exp + + @pytest.fixture + def obj(self): + return Series(period_range("2000-01-01", periods=10, freq="D")) + + @pytest.fixture(params=[3, slice(3, 5)]) + def key(self, request): + return request.param + + @pytest.fixture(params=[None, np.nan]) + def val(self, request): + return request.param + + @pytest.fixture + def warn(self): + return None + + +class TestSetitemNADatetimeLikeDtype(SetitemCastingEquivalents): + # some nat-like values should be cast to datetime64/timedelta64 when + # inserting into a datetime64/timedelta64 series. Others should coerce + # to object and retain their dtypes. + # GH#18586 for td64 and boolean mask case + + @pytest.fixture( + params=["m8[ns]", "M8[ns]", "datetime64[ns, UTC]", "datetime64[ns, US/Central]"] + ) + def dtype(self, request): + return request.param + + @pytest.fixture + def obj(self, dtype): + i8vals = date_range("2016-01-01", periods=3).asi8 + idx = Index(i8vals, dtype=dtype) + assert idx.dtype == dtype + return Series(idx) + + @pytest.fixture( + params=[ + None, + np.nan, + NaT, + np.timedelta64("NaT", "ns"), + np.datetime64("NaT", "ns"), + ] + ) + def val(self, request): + return request.param + + @pytest.fixture + def is_inplace(self, val, obj): + # td64 -> cast to object iff val is datetime64("NaT") + # dt64 -> cast to object iff val is timedelta64("NaT") + # dt64tz -> cast to object with anything _but_ NaT + return val is NaT or val is None or val is np.nan or obj.dtype == val.dtype + + @pytest.fixture + def expected(self, obj, val, is_inplace): + dtype = obj.dtype if is_inplace else object + expected = Series([val] + list(obj[1:]), dtype=dtype) + return expected + + @pytest.fixture + def key(self): + return 0 + + @pytest.fixture + def warn(self, is_inplace): + return None if is_inplace else FutureWarning + + +class TestSetitemMismatchedTZCastsToObject(SetitemCastingEquivalents): + # GH#24024 + @pytest.fixture + def obj(self): + return Series(date_range("2000", periods=2, tz="US/Central")) + + @pytest.fixture + def val(self): + return Timestamp("2000", tz="US/Eastern") + + @pytest.fixture + def key(self): + return 0 + + @pytest.fixture + def expected(self, obj, val): + # pre-2.0 this would cast to object, in 2.0 we cast the val to + # the target tz + expected = Series( + [ + val.tz_convert("US/Central"), + Timestamp("2000-01-02 00:00:00-06:00", tz="US/Central"), + ], + dtype=obj.dtype, + ) + return expected + + @pytest.fixture + def warn(self): + return None + + +@pytest.mark.parametrize( + "obj,expected,warn", + [ + # For numeric series, we should coerce to NaN. + (Series([1, 2, 3]), Series([np.nan, 2, 3]), None), + (Series([1.0, 2.0, 3.0]), Series([np.nan, 2.0, 3.0]), None), + # For datetime series, we should coerce to NaT. + ( + Series([datetime(2000, 1, 1), datetime(2000, 1, 2), datetime(2000, 1, 3)]), + Series([NaT, datetime(2000, 1, 2), datetime(2000, 1, 3)]), + None, + ), + # For objects, we should preserve the None value. + (Series(["foo", "bar", "baz"]), Series([None, "bar", "baz"]), None), + ], +) +class TestSeriesNoneCoercion(SetitemCastingEquivalents): + @pytest.fixture + def key(self): + return 0 + + @pytest.fixture + def val(self): + return None + + +class TestSetitemFloatIntervalWithIntIntervalValues(SetitemCastingEquivalents): + # GH#44201 Cast to shared IntervalDtype rather than object + + def test_setitem_example(self): + # Just a case here to make obvious what this test class is aimed at + idx = IntervalIndex.from_breaks(range(4)) + obj = Series(idx) + val = Interval(0.5, 1.5) + + with tm.assert_produces_warning( + FutureWarning, match="Setting an item of incompatible dtype" + ): + obj[0] = val + assert obj.dtype == "Interval[float64, right]" + + @pytest.fixture + def obj(self): + idx = IntervalIndex.from_breaks(range(4)) + return Series(idx) + + @pytest.fixture + def val(self): + return Interval(0.5, 1.5) + + @pytest.fixture + def key(self): + return 0 + + @pytest.fixture + def expected(self, obj, val): + data = [val] + list(obj[1:]) + idx = IntervalIndex(data, dtype="Interval[float64]") + return Series(idx) + + @pytest.fixture + def warn(self): + return FutureWarning + + +class TestSetitemRangeIntoIntegerSeries(SetitemCastingEquivalents): + # GH#44261 Setting a range with sufficiently-small integers into + # small-itemsize integer dtypes should not need to upcast + + @pytest.fixture + def obj(self, any_int_numpy_dtype): + dtype = np.dtype(any_int_numpy_dtype) + ser = Series(range(5), dtype=dtype) + return ser + + @pytest.fixture + def val(self): + return range(2, 4) + + @pytest.fixture + def key(self): + return slice(0, 2) + + @pytest.fixture + def expected(self, any_int_numpy_dtype): + dtype = np.dtype(any_int_numpy_dtype) + exp = Series([2, 3, 2, 3, 4], dtype=dtype) + return exp + + @pytest.fixture + def warn(self): + return None + + +@pytest.mark.parametrize( + "val, warn", + [ + (np.array([2.0, 3.0]), None), + (np.array([2.5, 3.5]), FutureWarning), + ( + np.array([2**65, 2**65 + 1], dtype=np.float64), + FutureWarning, + ), # all ints, but can't cast + ], +) +class TestSetitemFloatNDarrayIntoIntegerSeries(SetitemCastingEquivalents): + @pytest.fixture + def obj(self): + return Series(range(5), dtype=np.int64) + + @pytest.fixture + def key(self): + return slice(0, 2) + + @pytest.fixture + def expected(self, val): + if val[0] == 2: + # NB: this condition is based on currently-hardcoded "val" cases + dtype = np.int64 + else: + dtype = np.float64 + res_values = np.array(range(5), dtype=dtype) + res_values[:2] = val + return Series(res_values) + + +@pytest.mark.parametrize("val", [512, np.int16(512)]) +class TestSetitemIntoIntegerSeriesNeedsUpcast(SetitemCastingEquivalents): + @pytest.fixture + def obj(self): + return Series([1, 2, 3], dtype=np.int8) + + @pytest.fixture + def key(self): + return 1 + + @pytest.fixture + def expected(self): + return Series([1, 512, 3], dtype=np.int16) + + @pytest.fixture + def warn(self): + return FutureWarning + + +@pytest.mark.parametrize("val", [2**33 + 1.0, 2**33 + 1.1, 2**62]) +class TestSmallIntegerSetitemUpcast(SetitemCastingEquivalents): + # https://github.com/pandas-dev/pandas/issues/39584#issuecomment-941212124 + @pytest.fixture + def obj(self): + return Series([1, 2, 3], dtype="i4") + + @pytest.fixture + def key(self): + return 0 + + @pytest.fixture + def expected(self, val): + if val % 1 != 0: + dtype = "f8" + else: + dtype = "i8" + return Series([val, 2, 3], dtype=dtype) + + @pytest.fixture + def warn(self): + return FutureWarning + + +class CoercionTest(SetitemCastingEquivalents): + # Tests ported from tests.indexing.test_coercion + + @pytest.fixture + def key(self): + return 1 + + @pytest.fixture + def expected(self, obj, key, val, exp_dtype): + vals = list(obj) + vals[key] = val + return Series(vals, dtype=exp_dtype) + + +@pytest.mark.parametrize( + "val,exp_dtype,warn", + [(np.int32(1), np.int8, None), (np.int16(2**9), np.int16, FutureWarning)], +) +class TestCoercionInt8(CoercionTest): + # previously test_setitem_series_int8 in tests.indexing.test_coercion + @pytest.fixture + def obj(self): + return Series([1, 2, 3, 4], dtype=np.int8) + + +@pytest.mark.parametrize("val", [1, 1.1, 1 + 1j, True]) +@pytest.mark.parametrize("exp_dtype", [object]) +class TestCoercionObject(CoercionTest): + # previously test_setitem_series_object in tests.indexing.test_coercion + @pytest.fixture + def obj(self): + return Series(["a", "b", "c", "d"], dtype=object) + + @pytest.fixture + def warn(self): + return None + + +@pytest.mark.parametrize( + "val,exp_dtype,warn", + [ + (1, np.complex128, None), + (1.1, np.complex128, None), + (1 + 1j, np.complex128, None), + (True, object, FutureWarning), + ], +) +class TestCoercionComplex(CoercionTest): + # previously test_setitem_series_complex128 in tests.indexing.test_coercion + @pytest.fixture + def obj(self): + return Series([1 + 1j, 2 + 2j, 3 + 3j, 4 + 4j]) + + +@pytest.mark.parametrize( + "val,exp_dtype,warn", + [ + (1, object, FutureWarning), + ("3", object, FutureWarning), + (3, object, FutureWarning), + (1.1, object, FutureWarning), + (1 + 1j, object, FutureWarning), + (True, bool, None), + ], +) +class TestCoercionBool(CoercionTest): + # previously test_setitem_series_bool in tests.indexing.test_coercion + @pytest.fixture + def obj(self): + return Series([True, False, True, False], dtype=bool) + + +@pytest.mark.parametrize( + "val,exp_dtype,warn", + [ + (1, np.int64, None), + (1.1, np.float64, FutureWarning), + (1 + 1j, np.complex128, FutureWarning), + (True, object, FutureWarning), + ], +) +class TestCoercionInt64(CoercionTest): + # previously test_setitem_series_int64 in tests.indexing.test_coercion + @pytest.fixture + def obj(self): + return Series([1, 2, 3, 4]) + + +@pytest.mark.parametrize( + "val,exp_dtype,warn", + [ + (1, np.float64, None), + (1.1, np.float64, None), + (1 + 1j, np.complex128, FutureWarning), + (True, object, FutureWarning), + ], +) +class TestCoercionFloat64(CoercionTest): + # previously test_setitem_series_float64 in tests.indexing.test_coercion + @pytest.fixture + def obj(self): + return Series([1.1, 2.2, 3.3, 4.4]) + + +@pytest.mark.parametrize( + "val,exp_dtype,warn", + [ + (1, np.float32, None), + pytest.param( + 1.1, + np.float32, + None, + marks=pytest.mark.xfail( + ( + not np_version_gte1p24 + or ( + np_version_gte1p24 + and not np_version_gt2 + and os.environ.get("NPY_PROMOTION_STATE", "legacy") != "weak" + ) + ), + reason="np.float32(1.1) ends up as 1.100000023841858, so " + "np_can_hold_element raises and we cast to float64", + ), + ), + (1 + 1j, np.complex128, FutureWarning), + (True, object, FutureWarning), + (np.uint8(2), np.float32, None), + (np.uint32(2), np.float32, None), + # float32 cannot hold np.iinfo(np.uint32).max exactly + # (closest it can hold is 4294967300.0 which off by 5.0), so + # we cast to float64 + (np.uint32(np.iinfo(np.uint32).max), np.float64, FutureWarning), + (np.uint64(2), np.float32, None), + (np.int64(2), np.float32, None), + ], +) +class TestCoercionFloat32(CoercionTest): + @pytest.fixture + def obj(self): + return Series([1.1, 2.2, 3.3, 4.4], dtype=np.float32) + + def test_slice_key(self, obj, key, expected, warn, val, indexer_sli, is_inplace): + super().test_slice_key(obj, key, expected, warn, val, indexer_sli, is_inplace) + + if isinstance(val, float): + # the xfail would xpass bc test_slice_key short-circuits + raise AssertionError("xfail not relevant for this test.") + + +@pytest.mark.parametrize( + "val,exp_dtype,warn", + [ + (Timestamp("2012-01-01"), "datetime64[ns]", None), + (1, object, FutureWarning), + ("x", object, FutureWarning), + ], +) +class TestCoercionDatetime64(CoercionTest): + # previously test_setitem_series_datetime64 in tests.indexing.test_coercion + + @pytest.fixture + def obj(self): + return Series(date_range("2011-01-01", freq="D", periods=4)) + + @pytest.fixture + def warn(self): + return None + + +@pytest.mark.parametrize( + "val,exp_dtype,warn", + [ + (Timestamp("2012-01-01", tz="US/Eastern"), "datetime64[ns, US/Eastern]", None), + # pre-2.0, a mis-matched tz would end up casting to object + (Timestamp("2012-01-01", tz="US/Pacific"), "datetime64[ns, US/Eastern]", None), + (Timestamp("2012-01-01"), object, FutureWarning), + (1, object, FutureWarning), + ], +) +class TestCoercionDatetime64TZ(CoercionTest): + # previously test_setitem_series_datetime64tz in tests.indexing.test_coercion + @pytest.fixture + def obj(self): + tz = "US/Eastern" + return Series(date_range("2011-01-01", freq="D", periods=4, tz=tz)) + + @pytest.fixture + def warn(self): + return None + + +@pytest.mark.parametrize( + "val,exp_dtype,warn", + [ + (Timedelta("12 day"), "timedelta64[ns]", None), + (1, object, FutureWarning), + ("x", object, FutureWarning), + ], +) +class TestCoercionTimedelta64(CoercionTest): + # previously test_setitem_series_timedelta64 in tests.indexing.test_coercion + @pytest.fixture + def obj(self): + return Series(timedelta_range("1 day", periods=4)) + + @pytest.fixture + def warn(self): + return None + + +@pytest.mark.parametrize( + "val", ["foo", Period("2016", freq="Y"), Interval(1, 2, closed="both")] +) +@pytest.mark.parametrize("exp_dtype", [object]) +class TestPeriodIntervalCoercion(CoercionTest): + # GH#45768 + @pytest.fixture( + params=[ + period_range("2016-01-01", periods=3, freq="D"), + interval_range(1, 5), + ] + ) + def obj(self, request): + return Series(request.param) + + @pytest.fixture + def warn(self): + return FutureWarning + + +def test_20643(): + # closed by GH#45121 + orig = Series([0, 1, 2], index=["a", "b", "c"]) + + expected = Series([0, 2.7, 2], index=["a", "b", "c"]) + + ser = orig.copy() + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + ser.at["b"] = 2.7 + tm.assert_series_equal(ser, expected) + + ser = orig.copy() + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + ser.loc["b"] = 2.7 + tm.assert_series_equal(ser, expected) + + ser = orig.copy() + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + ser["b"] = 2.7 + tm.assert_series_equal(ser, expected) + + ser = orig.copy() + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + ser.iat[1] = 2.7 + tm.assert_series_equal(ser, expected) + + ser = orig.copy() + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + ser.iloc[1] = 2.7 + tm.assert_series_equal(ser, expected) + + orig_df = orig.to_frame("A") + expected_df = expected.to_frame("A") + + df = orig_df.copy() + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + df.at["b", "A"] = 2.7 + tm.assert_frame_equal(df, expected_df) + + df = orig_df.copy() + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + df.loc["b", "A"] = 2.7 + tm.assert_frame_equal(df, expected_df) + + df = orig_df.copy() + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + df.iloc[1, 0] = 2.7 + tm.assert_frame_equal(df, expected_df) + + df = orig_df.copy() + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + df.iat[1, 0] = 2.7 + tm.assert_frame_equal(df, expected_df) + + +def test_20643_comment(): + # https://github.com/pandas-dev/pandas/issues/20643#issuecomment-431244590 + # fixed sometime prior to GH#45121 + orig = Series([0, 1, 2], index=["a", "b", "c"]) + expected = Series([np.nan, 1, 2], index=["a", "b", "c"]) + + ser = orig.copy() + ser.iat[0] = None + tm.assert_series_equal(ser, expected) + + ser = orig.copy() + ser.iloc[0] = None + tm.assert_series_equal(ser, expected) + + +def test_15413(): + # fixed by GH#45121 + ser = Series([1, 2, 3]) + + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + ser[ser == 2] += 0.5 + expected = Series([1, 2.5, 3]) + tm.assert_series_equal(ser, expected) + + ser = Series([1, 2, 3]) + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + ser[1] += 0.5 + tm.assert_series_equal(ser, expected) + + ser = Series([1, 2, 3]) + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + ser.loc[1] += 0.5 + tm.assert_series_equal(ser, expected) + + ser = Series([1, 2, 3]) + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + ser.iloc[1] += 0.5 + tm.assert_series_equal(ser, expected) + + ser = Series([1, 2, 3]) + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + ser.iat[1] += 0.5 + tm.assert_series_equal(ser, expected) + + ser = Series([1, 2, 3]) + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + ser.at[1] += 0.5 + tm.assert_series_equal(ser, expected) + + +def test_32878_int_itemsize(): + # Fixed by GH#45121 + arr = np.arange(5).astype("i4") + ser = Series(arr) + val = np.int64(np.iinfo(np.int64).max) + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + ser[0] = val + expected = Series([val, 1, 2, 3, 4], dtype=np.int64) + tm.assert_series_equal(ser, expected) + + +def test_32878_complex_itemsize(): + arr = np.arange(5).astype("c8") + ser = Series(arr) + val = np.finfo(np.float64).max + val = val.astype("c16") + + # GH#32878 used to coerce val to inf+0.000000e+00j + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + ser[0] = val + assert ser[0] == val + expected = Series([val, 1, 2, 3, 4], dtype="c16") + tm.assert_series_equal(ser, expected) + + +def test_37692(indexer_al): + # GH#37692 + ser = Series([1, 2, 3], index=["a", "b", "c"]) + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + indexer_al(ser)["b"] = "test" + expected = Series([1, "test", 3], index=["a", "b", "c"], dtype=object) + tm.assert_series_equal(ser, expected) + + +def test_setitem_bool_int_float_consistency(indexer_sli): + # GH#21513 + # bool-with-int and bool-with-float both upcast to object + # int-with-float and float-with-int are both non-casting so long + # as the setitem can be done losslessly + for dtype in [np.float64, np.int64]: + ser = Series(0, index=range(3), dtype=dtype) + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + indexer_sli(ser)[0] = True + assert ser.dtype == object + + ser = Series(0, index=range(3), dtype=bool) + with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"): + ser[0] = dtype(1) + assert ser.dtype == object + + # 1.0 can be held losslessly, so no casting + ser = Series(0, index=range(3), dtype=np.int64) + indexer_sli(ser)[0] = np.float64(1.0) + assert ser.dtype == np.int64 + + # 1 can be held losslessly, so no casting + ser = Series(0, index=range(3), dtype=np.float64) + indexer_sli(ser)[0] = np.int64(1) + + +def test_setitem_positional_with_casting(): + # GH#45070 case where in __setitem__ we get a KeyError, then when + # we fallback we *also* get a ValueError if we try to set inplace. + ser = Series([1, 2, 3], index=["a", "b", "c"]) + + warn_msg = "Series.__setitem__ treating keys as positions is deprecated" + with tm.assert_produces_warning(FutureWarning, match=warn_msg): + ser[0] = "X" + expected = Series(["X", 2, 3], index=["a", "b", "c"], dtype=object) + tm.assert_series_equal(ser, expected) + + +def test_setitem_positional_float_into_int_coerces(): + # Case where we hit a KeyError and then trying to set in-place incorrectly + # casts a float to an int + ser = Series([1, 2, 3], index=["a", "b", "c"]) + + warn_msg = "Series.__setitem__ treating keys as positions is deprecated" + with tm.assert_produces_warning(FutureWarning, match=warn_msg): + ser[0] = 1.5 + expected = Series([1.5, 2, 3], index=["a", "b", "c"]) + tm.assert_series_equal(ser, expected) + + +def test_setitem_int_not_positional(): + # GH#42215 deprecated falling back to positional on __setitem__ with an + # int not contained in the index; enforced in 2.0 + ser = Series([1, 2, 3, 4], index=[1.1, 2.1, 3.0, 4.1]) + assert not ser.index._should_fallback_to_positional + # assert not ser.index.astype(object)._should_fallback_to_positional + + # 3.0 is in our index, so post-enforcement behavior is unchanged + ser[3] = 10 + expected = Series([1, 2, 10, 4], index=ser.index) + tm.assert_series_equal(ser, expected) + + # pre-enforcement `ser[5] = 5` raised IndexError + ser[5] = 5 + expected = Series([1, 2, 10, 4, 5], index=[1.1, 2.1, 3.0, 4.1, 5.0]) + tm.assert_series_equal(ser, expected) + + ii = IntervalIndex.from_breaks(range(10))[::2] + ser2 = Series(range(len(ii)), index=ii) + exp_index = ii.astype(object).append(Index([4])) + expected2 = Series([0, 1, 2, 3, 4, 9], index=exp_index) + # pre-enforcement `ser2[4] = 9` interpreted 4 as positional + ser2[4] = 9 + tm.assert_series_equal(ser2, expected2) + + mi = MultiIndex.from_product([ser.index, ["A", "B"]]) + ser3 = Series(range(len(mi)), index=mi) + expected3 = ser3.copy() + expected3.loc[4] = 99 + # pre-enforcement `ser3[4] = 99` interpreted 4 as positional + ser3[4] = 99 + tm.assert_series_equal(ser3, expected3) + + +def test_setitem_with_bool_indexer(): + # GH#42530 + + df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}) + result = df.pop("b").copy() + result[[True, False, False]] = 9 + expected = Series(data=[9, 5, 6], name="b") + tm.assert_series_equal(result, expected) + + df.loc[[True, False, False], "a"] = 10 + expected = DataFrame({"a": [10, 2, 3]}) + tm.assert_frame_equal(df, expected) + + +@pytest.mark.parametrize("size", range(2, 6)) +@pytest.mark.parametrize( + "mask", [[True, False, False, False, False], [True, False], [False]] +) +@pytest.mark.parametrize( + "item", [2.0, np.nan, np.finfo(float).max, np.finfo(float).min] +) +# Test numpy arrays, lists and tuples as the input to be +# broadcast +@pytest.mark.parametrize( + "box", [lambda x: np.array([x]), lambda x: [x], lambda x: (x,)] +) +def test_setitem_bool_indexer_dont_broadcast_length1_values(size, mask, item, box): + # GH#44265 + # see also tests.series.indexing.test_where.test_broadcast + + selection = np.resize(mask, size) + + data = np.arange(size, dtype=float) + + ser = Series(data) + + if selection.sum() != 1: + msg = ( + "cannot set using a list-like indexer with a different " + "length than the value" + ) + with pytest.raises(ValueError, match=msg): + # GH#44265 + ser[selection] = box(item) + else: + # In this corner case setting is equivalent to setting with the unboxed + # item + ser[selection] = box(item) + + expected = Series(np.arange(size, dtype=float)) + expected[selection] = item + tm.assert_series_equal(ser, expected) + + +def test_setitem_empty_mask_dont_upcast_dt64(): + dti = date_range("2016-01-01", periods=3) + ser = Series(dti) + orig = ser.copy() + mask = np.zeros(3, dtype=bool) + + ser[mask] = "foo" + assert ser.dtype == dti.dtype # no-op -> dont upcast + tm.assert_series_equal(ser, orig) + + ser.mask(mask, "foo", inplace=True) + assert ser.dtype == dti.dtype # no-op -> dont upcast + tm.assert_series_equal(ser, orig) diff --git a/shared/package-files/30/30c23618679108f3e8ea1d2a658c7ca417bdfc891c98ef1a89fa4ff0c9828654/blob b/shared/package-files/30/30c23618679108f3e8ea1d2a658c7ca417bdfc891c98ef1a89fa4ff0c9828654/blob new file mode 100644 index 0000000000000000000000000000000000000000..a31470f14c5978d5fcc3bc173b8399b6c9a6443f --- /dev/null +++ b/shared/package-files/30/30c23618679108f3e8ea1d2a658c7ca417bdfc891c98ef1a89fa4ff0c9828654/blob @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2012 Daniel Holth and contributors + +Permission is hereby granted, free of charge, to any 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 shall be included +in all 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. diff --git a/shared/package-files/30/30c24f0b11e57fdae05248b39f82a3abdbd878011fc72a9fabc5ec4c4f84a563/blob b/shared/package-files/30/30c24f0b11e57fdae05248b39f82a3abdbd878011fc72a9fabc5ec4c4f84a563/blob new file mode 100644 index 0000000000000000000000000000000000000000..1a9bd1200f82358c5a758c69c433bb55621e157e --- /dev/null +++ b/shared/package-files/30/30c24f0b11e57fdae05248b39f82a3abdbd878011fc72a9fabc5ec4c4f84a563/blob @@ -0,0 +1,754 @@ +"""distutils.command.build_ext + +Implements the Distutils 'build_ext' command, for building extension +modules (currently limited to C extensions, should accommodate C++ +extensions ASAP).""" + +import contextlib +import os +import re +import sys +from distutils.core import Command +from distutils.errors import * +from distutils.sysconfig import customize_compiler, get_python_version +from distutils.sysconfig import get_config_h_filename +from distutils.dep_util import newer_group +from distutils.extension import Extension +from distutils.util import get_platform +from distutils import log + +from site import USER_BASE + +# An extension name is just a dot-separated list of Python NAMEs (ie. +# the same as a fully-qualified module name). +extension_name_re = re.compile \ + (r'^[a-zA-Z_][a-zA-Z_0-9]*(\.[a-zA-Z_][a-zA-Z_0-9]*)*$') + + +def show_compilers (): + from distutils.ccompiler import show_compilers + show_compilers() + + +class build_ext(Command): + + description = "build C/C++ extensions (compile/link to build directory)" + + # XXX thoughts on how to deal with complex command-line options like + # these, i.e. how to make it so fancy_getopt can suck them off the + # command line and make it look like setup.py defined the appropriate + # lists of tuples of what-have-you. + # - each command needs a callback to process its command-line options + # - Command.__init__() needs access to its share of the whole + # command line (must ultimately come from + # Distribution.parse_command_line()) + # - it then calls the current command class' option-parsing + # callback to deal with weird options like -D, which have to + # parse the option text and churn out some custom data + # structure + # - that data structure (in this case, a list of 2-tuples) + # will then be present in the command object by the time + # we get to finalize_options() (i.e. the constructor + # takes care of both command-line and client options + # in between initialize_options() and finalize_options()) + + sep_by = " (separated by '%s')" % os.pathsep + user_options = [ + ('build-lib=', 'b', + "directory for compiled extension modules"), + ('build-temp=', 't', + "directory for temporary files (build by-products)"), + ('plat-name=', 'p', + "platform name to cross-compile for, if supported " + "(default: %s)" % get_platform()), + ('inplace', 'i', + "ignore build-lib and put compiled extensions into the source " + + "directory alongside your pure Python modules"), + ('include-dirs=', 'I', + "list of directories to search for header files" + sep_by), + ('define=', 'D', + "C preprocessor macros to define"), + ('undef=', 'U', + "C preprocessor macros to undefine"), + ('libraries=', 'l', + "external C libraries to link with"), + ('library-dirs=', 'L', + "directories to search for external C libraries" + sep_by), + ('rpath=', 'R', + "directories to search for shared C libraries at runtime"), + ('link-objects=', 'O', + "extra explicit link objects to include in the link"), + ('debug', 'g', + "compile/link with debugging information"), + ('force', 'f', + "forcibly build everything (ignore file timestamps)"), + ('compiler=', 'c', + "specify the compiler type"), + ('parallel=', 'j', + "number of parallel build jobs"), + ('swig-cpp', None, + "make SWIG create C++ files (default is C)"), + ('swig-opts=', None, + "list of SWIG command line options"), + ('swig=', None, + "path to the SWIG executable"), + ('user', None, + "add user include, library and rpath") + ] + + boolean_options = ['inplace', 'debug', 'force', 'swig-cpp', 'user'] + + help_options = [ + ('help-compiler', None, + "list available compilers", show_compilers), + ] + + def initialize_options(self): + self.extensions = None + self.build_lib = None + self.plat_name = None + self.build_temp = None + self.inplace = 0 + self.package = None + + self.include_dirs = None + self.define = None + self.undef = None + self.libraries = None + self.library_dirs = None + self.rpath = None + self.link_objects = None + self.debug = None + self.force = None + self.compiler = None + self.swig = None + self.swig_cpp = None + self.swig_opts = None + self.user = None + self.parallel = None + + def finalize_options(self): + from distutils import sysconfig + + self.set_undefined_options('build', + ('build_lib', 'build_lib'), + ('build_temp', 'build_temp'), + ('compiler', 'compiler'), + ('debug', 'debug'), + ('force', 'force'), + ('parallel', 'parallel'), + ('plat_name', 'plat_name'), + ) + + if self.package is None: + self.package = self.distribution.ext_package + + self.extensions = self.distribution.ext_modules + + # Make sure Python's include directories (for Python.h, pyconfig.h, + # etc.) are in the include search path. + py_include = sysconfig.get_python_inc() + plat_py_include = sysconfig.get_python_inc(plat_specific=1) + if self.include_dirs is None: + self.include_dirs = self.distribution.include_dirs or [] + if isinstance(self.include_dirs, str): + self.include_dirs = self.include_dirs.split(os.pathsep) + + # If in a virtualenv, add its include directory + # Issue 16116 + if sys.exec_prefix != sys.base_exec_prefix: + self.include_dirs.append(os.path.join(sys.exec_prefix, 'include')) + + # Put the Python "system" include dir at the end, so that + # any local include dirs take precedence. + self.include_dirs.extend(py_include.split(os.path.pathsep)) + if plat_py_include != py_include: + self.include_dirs.extend( + plat_py_include.split(os.path.pathsep)) + + self.ensure_string_list('libraries') + self.ensure_string_list('link_objects') + + # Life is easier if we're not forever checking for None, so + # simplify these options to empty lists if unset + if self.libraries is None: + self.libraries = [] + if self.library_dirs is None: + self.library_dirs = [] + elif isinstance(self.library_dirs, str): + self.library_dirs = self.library_dirs.split(os.pathsep) + + if self.rpath is None: + self.rpath = [] + elif isinstance(self.rpath, str): + self.rpath = self.rpath.split(os.pathsep) + + # for extensions under windows use different directories + # for Release and Debug builds. + # also Python's library directory must be appended to library_dirs + if os.name == 'nt': + # the 'libs' directory is for binary installs - we assume that + # must be the *native* platform. But we don't really support + # cross-compiling via a binary install anyway, so we let it go. + self.library_dirs.append(os.path.join(sys.exec_prefix, 'libs')) + if sys.base_exec_prefix != sys.prefix: # Issue 16116 + self.library_dirs.append(os.path.join(sys.base_exec_prefix, 'libs')) + if self.debug: + self.build_temp = os.path.join(self.build_temp, "Debug") + else: + self.build_temp = os.path.join(self.build_temp, "Release") + + # Append the source distribution include and library directories, + # this allows distutils on windows to work in the source tree + self.include_dirs.append(os.path.dirname(get_config_h_filename())) + _sys_home = getattr(sys, '_home', None) + if _sys_home: + self.library_dirs.append(_sys_home) + + # Use the .lib files for the correct architecture + if self.plat_name == 'win32': + suffix = 'win32' + else: + # win-amd64 + suffix = self.plat_name[4:] + new_lib = os.path.join(sys.exec_prefix, 'PCbuild') + if suffix: + new_lib = os.path.join(new_lib, suffix) + self.library_dirs.append(new_lib) + + # For extensions under Cygwin, Python's library directory must be + # appended to library_dirs + if sys.platform[:6] == 'cygwin': + if sys.executable.startswith(os.path.join(sys.exec_prefix, "bin")): + # building third party extensions + self.library_dirs.append(os.path.join(sys.prefix, "lib", + "python" + get_python_version(), + "config")) + else: + # building python standard extensions + self.library_dirs.append('.') + + # For building extensions with a shared Python library, + # Python's library directory must be appended to library_dirs + # See Issues: #1600860, #4366 + if (sysconfig.get_config_var('Py_ENABLE_SHARED')): + if not sysconfig.python_build: + # building third party extensions + self.library_dirs.append(sysconfig.get_config_var('LIBDIR')) + else: + # building python standard extensions + self.library_dirs.append('.') + + # The argument parsing will result in self.define being a string, but + # it has to be a list of 2-tuples. All the preprocessor symbols + # specified by the 'define' option will be set to '1'. Multiple + # symbols can be separated with commas. + + if self.define: + defines = self.define.split(',') + self.define = [(symbol, '1') for symbol in defines] + + # The option for macros to undefine is also a string from the + # option parsing, but has to be a list. Multiple symbols can also + # be separated with commas here. + if self.undef: + self.undef = self.undef.split(',') + + if self.swig_opts is None: + self.swig_opts = [] + else: + self.swig_opts = self.swig_opts.split(' ') + + # Finally add the user include and library directories if requested + if self.user: + user_include = os.path.join(USER_BASE, "include") + user_lib = os.path.join(USER_BASE, "lib") + if os.path.isdir(user_include): + self.include_dirs.append(user_include) + if os.path.isdir(user_lib): + self.library_dirs.append(user_lib) + self.rpath.append(user_lib) + + if isinstance(self.parallel, str): + try: + self.parallel = int(self.parallel) + except ValueError: + raise DistutilsOptionError("parallel should be an integer") + + def run(self): + from distutils.ccompiler import new_compiler + + # 'self.extensions', as supplied by setup.py, is a list of + # Extension instances. See the documentation for Extension (in + # distutils.extension) for details. + # + # For backwards compatibility with Distutils 0.8.2 and earlier, we + # also allow the 'extensions' list to be a list of tuples: + # (ext_name, build_info) + # where build_info is a dictionary containing everything that + # Extension instances do except the name, with a few things being + # differently named. We convert these 2-tuples to Extension + # instances as needed. + + if not self.extensions: + return + + # If we were asked to build any C/C++ libraries, make sure that the + # directory where we put them is in the library search path for + # linking extensions. + if self.distribution.has_c_libraries(): + build_clib = self.get_finalized_command('build_clib') + self.libraries.extend(build_clib.get_library_names() or []) + self.library_dirs.append(build_clib.build_clib) + + # Setup the CCompiler object that we'll use to do all the + # compiling and linking + self.compiler = new_compiler(compiler=self.compiler, + verbose=self.verbose, + dry_run=self.dry_run, + force=self.force) + customize_compiler(self.compiler) + # If we are cross-compiling, init the compiler now (if we are not + # cross-compiling, init would not hurt, but people may rely on + # late initialization of compiler even if they shouldn't...) + if os.name == 'nt' and self.plat_name != get_platform(): + self.compiler.initialize(self.plat_name) + + # And make sure that any compile/link-related options (which might + # come from the command-line or from the setup script) are set in + # that CCompiler object -- that way, they automatically apply to + # all compiling and linking done here. + if self.include_dirs is not None: + self.compiler.set_include_dirs(self.include_dirs) + if self.define is not None: + # 'define' option is a list of (name,value) tuples + for (name, value) in self.define: + self.compiler.define_macro(name, value) + if self.undef is not None: + for macro in self.undef: + self.compiler.undefine_macro(macro) + if self.libraries is not None: + self.compiler.set_libraries(self.libraries) + if self.library_dirs is not None: + self.compiler.set_library_dirs(self.library_dirs) + if self.rpath is not None: + self.compiler.set_runtime_library_dirs(self.rpath) + if self.link_objects is not None: + self.compiler.set_link_objects(self.link_objects) + + # Now actually compile and link everything. + self.build_extensions() + + def check_extensions_list(self, extensions): + """Ensure that the list of extensions (presumably provided as a + command option 'extensions') is valid, i.e. it is a list of + Extension objects. We also support the old-style list of 2-tuples, + where the tuples are (ext_name, build_info), which are converted to + Extension instances here. + + Raise DistutilsSetupError if the structure is invalid anywhere; + just returns otherwise. + """ + if not isinstance(extensions, list): + raise DistutilsSetupError( + "'ext_modules' option must be a list of Extension instances") + + for i, ext in enumerate(extensions): + if isinstance(ext, Extension): + continue # OK! (assume type-checking done + # by Extension constructor) + + if not isinstance(ext, tuple) or len(ext) != 2: + raise DistutilsSetupError( + "each element of 'ext_modules' option must be an " + "Extension instance or 2-tuple") + + ext_name, build_info = ext + + log.warn("old-style (ext_name, build_info) tuple found in " + "ext_modules for extension '%s' " + "-- please convert to Extension instance", ext_name) + + if not (isinstance(ext_name, str) and + extension_name_re.match(ext_name)): + raise DistutilsSetupError( + "first element of each tuple in 'ext_modules' " + "must be the extension name (a string)") + + if not isinstance(build_info, dict): + raise DistutilsSetupError( + "second element of each tuple in 'ext_modules' " + "must be a dictionary (build info)") + + # OK, the (ext_name, build_info) dict is type-safe: convert it + # to an Extension instance. + ext = Extension(ext_name, build_info['sources']) + + # Easy stuff: one-to-one mapping from dict elements to + # instance attributes. + for key in ('include_dirs', 'library_dirs', 'libraries', + 'extra_objects', 'extra_compile_args', + 'extra_link_args'): + val = build_info.get(key) + if val is not None: + setattr(ext, key, val) + + # Medium-easy stuff: same syntax/semantics, different names. + ext.runtime_library_dirs = build_info.get('rpath') + if 'def_file' in build_info: + log.warn("'def_file' element of build info dict " + "no longer supported") + + # Non-trivial stuff: 'macros' split into 'define_macros' + # and 'undef_macros'. + macros = build_info.get('macros') + if macros: + ext.define_macros = [] + ext.undef_macros = [] + for macro in macros: + if not (isinstance(macro, tuple) and len(macro) in (1, 2)): + raise DistutilsSetupError( + "'macros' element of build info dict " + "must be 1- or 2-tuple") + if len(macro) == 1: + ext.undef_macros.append(macro[0]) + elif len(macro) == 2: + ext.define_macros.append(macro) + + extensions[i] = ext + + def get_source_files(self): + self.check_extensions_list(self.extensions) + filenames = [] + + # Wouldn't it be neat if we knew the names of header files too... + for ext in self.extensions: + filenames.extend(ext.sources) + return filenames + + def get_outputs(self): + # Sanity check the 'extensions' list -- can't assume this is being + # done in the same run as a 'build_extensions()' call (in fact, we + # can probably assume that it *isn't*!). + self.check_extensions_list(self.extensions) + + # And build the list of output (built) filenames. Note that this + # ignores the 'inplace' flag, and assumes everything goes in the + # "build" tree. + outputs = [] + for ext in self.extensions: + outputs.append(self.get_ext_fullpath(ext.name)) + return outputs + + def build_extensions(self): + # First, sanity-check the 'extensions' list + self.check_extensions_list(self.extensions) + if self.parallel: + self._build_extensions_parallel() + else: + self._build_extensions_serial() + + def _build_extensions_parallel(self): + workers = self.parallel + if self.parallel is True: + workers = os.cpu_count() # may return None + try: + from concurrent.futures import ThreadPoolExecutor + except ImportError: + workers = None + + if workers is None: + self._build_extensions_serial() + return + + with ThreadPoolExecutor(max_workers=workers) as executor: + futures = [executor.submit(self.build_extension, ext) + for ext in self.extensions] + for ext, fut in zip(self.extensions, futures): + with self._filter_build_errors(ext): + fut.result() + + def _build_extensions_serial(self): + for ext in self.extensions: + with self._filter_build_errors(ext): + self.build_extension(ext) + + @contextlib.contextmanager + def _filter_build_errors(self, ext): + try: + yield + except (CCompilerError, DistutilsError, CompileError) as e: + if not ext.optional: + raise + self.warn('building extension "%s" failed: %s' % + (ext.name, e)) + + def build_extension(self, ext): + sources = ext.sources + if sources is None or not isinstance(sources, (list, tuple)): + raise DistutilsSetupError( + "in 'ext_modules' option (extension '%s'), " + "'sources' must be present and must be " + "a list of source filenames" % ext.name) + # sort to make the resulting .so file build reproducible + sources = sorted(sources) + + ext_path = self.get_ext_fullpath(ext.name) + depends = sources + ext.depends + if not (self.force or newer_group(depends, ext_path, 'newer')): + log.debug("skipping '%s' extension (up-to-date)", ext.name) + return + else: + log.info("building '%s' extension", ext.name) + + # First, scan the sources for SWIG definition files (.i), run + # SWIG on 'em to create .c files, and modify the sources list + # accordingly. + sources = self.swig_sources(sources, ext) + + # Next, compile the source code to object files. + + # XXX not honouring 'define_macros' or 'undef_macros' -- the + # CCompiler API needs to change to accommodate this, and I + # want to do one thing at a time! + + # Two possible sources for extra compiler arguments: + # - 'extra_compile_args' in Extension object + # - CFLAGS environment variable (not particularly + # elegant, but people seem to expect it and I + # guess it's useful) + # The environment variable should take precedence, and + # any sensible compiler will give precedence to later + # command line args. Hence we combine them in order: + extra_args = ext.extra_compile_args or [] + + macros = ext.define_macros[:] + for undef in ext.undef_macros: + macros.append((undef,)) + + objects = self.compiler.compile(sources, + output_dir=self.build_temp, + macros=macros, + include_dirs=ext.include_dirs, + debug=self.debug, + extra_postargs=extra_args, + depends=ext.depends) + + # XXX outdated variable, kept here in case third-part code + # needs it. + self._built_objects = objects[:] + + # Now link the object files together into a "shared object" -- + # of course, first we have to figure out all the other things + # that go into the mix. + if ext.extra_objects: + objects.extend(ext.extra_objects) + extra_args = ext.extra_link_args or [] + + # Detect target language, if not provided + language = ext.language or self.compiler.detect_language(sources) + + self.compiler.link_shared_object( + objects, ext_path, + libraries=self.get_libraries(ext), + library_dirs=ext.library_dirs, + runtime_library_dirs=ext.runtime_library_dirs, + extra_postargs=extra_args, + export_symbols=self.get_export_symbols(ext), + debug=self.debug, + build_temp=self.build_temp, + target_lang=language) + + def swig_sources(self, sources, extension): + """Walk the list of source files in 'sources', looking for SWIG + interface (.i) files. Run SWIG on all that are found, and + return a modified 'sources' list with SWIG source files replaced + by the generated C (or C++) files. + """ + new_sources = [] + swig_sources = [] + swig_targets = {} + + # XXX this drops generated C/C++ files into the source tree, which + # is fine for developers who want to distribute the generated + # source -- but there should be an option to put SWIG output in + # the temp dir. + + if self.swig_cpp: + log.warn("--swig-cpp is deprecated - use --swig-opts=-c++") + + if self.swig_cpp or ('-c++' in self.swig_opts) or \ + ('-c++' in extension.swig_opts): + target_ext = '.cpp' + else: + target_ext = '.c' + + for source in sources: + (base, ext) = os.path.splitext(source) + if ext == ".i": # SWIG interface file + new_sources.append(base + '_wrap' + target_ext) + swig_sources.append(source) + swig_targets[source] = new_sources[-1] + else: + new_sources.append(source) + + if not swig_sources: + return new_sources + + swig = self.swig or self.find_swig() + swig_cmd = [swig, "-python"] + swig_cmd.extend(self.swig_opts) + if self.swig_cpp: + swig_cmd.append("-c++") + + # Do not override commandline arguments + if not self.swig_opts: + for o in extension.swig_opts: + swig_cmd.append(o) + + for source in swig_sources: + target = swig_targets[source] + log.info("swigging %s to %s", source, target) + self.spawn(swig_cmd + ["-o", target, source]) + + return new_sources + + def find_swig(self): + """Return the name of the SWIG executable. On Unix, this is + just "swig" -- it should be in the PATH. Tries a bit harder on + Windows. + """ + if os.name == "posix": + return "swig" + elif os.name == "nt": + # Look for SWIG in its standard installation directory on + # Windows (or so I presume!). If we find it there, great; + # if not, act like Unix and assume it's in the PATH. + for vers in ("1.3", "1.2", "1.1"): + fn = os.path.join("c:\\swig%s" % vers, "swig.exe") + if os.path.isfile(fn): + return fn + else: + return "swig.exe" + else: + raise DistutilsPlatformError( + "I don't know how to find (much less run) SWIG " + "on platform '%s'" % os.name) + + # -- Name generators ----------------------------------------------- + # (extension names, filenames, whatever) + def get_ext_fullpath(self, ext_name): + """Returns the path of the filename for a given extension. + + The file is located in `build_lib` or directly in the package + (inplace option). + """ + fullname = self.get_ext_fullname(ext_name) + modpath = fullname.split('.') + filename = self.get_ext_filename(modpath[-1]) + + if not self.inplace: + # no further work needed + # returning : + # build_dir/package/path/filename + filename = os.path.join(*modpath[:-1]+[filename]) + return os.path.join(self.build_lib, filename) + + # the inplace option requires to find the package directory + # using the build_py command for that + package = '.'.join(modpath[0:-1]) + build_py = self.get_finalized_command('build_py') + package_dir = os.path.abspath(build_py.get_package_dir(package)) + + # returning + # package_dir/filename + return os.path.join(package_dir, filename) + + def get_ext_fullname(self, ext_name): + """Returns the fullname of a given extension name. + + Adds the `package.` prefix""" + if self.package is None: + return ext_name + else: + return self.package + '.' + ext_name + + def get_ext_filename(self, ext_name): + r"""Convert the name of an extension (eg. "foo.bar") into the name + of the file from which it will be loaded (eg. "foo/bar.so", or + "foo\bar.pyd"). + """ + from distutils.sysconfig import get_config_var + ext_path = ext_name.split('.') + ext_suffix = get_config_var('EXT_SUFFIX') + return os.path.join(*ext_path) + ext_suffix + + def get_export_symbols(self, ext): + """Return the list of symbols that a shared extension has to + export. This either uses 'ext.export_symbols' or, if it's not + provided, "PyInit_" + module_name. Only relevant on Windows, where + the .pyd file (DLL) must export the module "PyInit_" function. + """ + suffix = '_' + ext.name.split('.')[-1] + try: + # Unicode module name support as defined in PEP-489 + # https://www.python.org/dev/peps/pep-0489/#export-hook-name + suffix.encode('ascii') + except UnicodeEncodeError: + suffix = 'U' + suffix.encode('punycode').replace(b'-', b'_').decode('ascii') + + initfunc_name = "PyInit" + suffix + if initfunc_name not in ext.export_symbols: + ext.export_symbols.append(initfunc_name) + return ext.export_symbols + + def get_libraries(self, ext): + """Return the list of libraries to link against when building a + shared extension. On most platforms, this is just 'ext.libraries'; + on Windows, we add the Python library (eg. python20.dll). + """ + # The python library is always needed on Windows. For MSVC, this + # is redundant, since the library is mentioned in a pragma in + # pyconfig.h that MSVC groks. The other Windows compilers all seem + # to need it mentioned explicitly, though, so that's what we do. + # Append '_d' to the python import library on debug builds. + if sys.platform == "win32": + from distutils._msvccompiler import MSVCCompiler + if not isinstance(self.compiler, MSVCCompiler): + template = "python%d%d" + if self.debug: + template = template + '_d' + pythonlib = (template % + (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff)) + # don't extend ext.libraries, it may be shared with other + # extensions, it is a reference to the original list + return ext.libraries + [pythonlib] + else: + # On Android only the main executable and LD_PRELOADs are considered + # to be RTLD_GLOBAL, all the dependencies of the main executable + # remain RTLD_LOCAL and so the shared libraries must be linked with + # libpython when python is built with a shared python library (issue + # bpo-21536). + # On Cygwin (and if required, other POSIX-like platforms based on + # Windows like MinGW) it is simply necessary that all symbols in + # shared libraries are resolved at link time. + from distutils.sysconfig import get_config_var + link_libpython = False + if get_config_var('Py_ENABLE_SHARED'): + # A native build on an Android device or on Cygwin + if hasattr(sys, 'getandroidapilevel'): + link_libpython = True + elif sys.platform == 'cygwin': + link_libpython = True + elif '_PYTHON_HOST_PLATFORM' in os.environ: + # We are cross-compiling for one of the relevant platforms + if get_config_var('ANDROID_API_LEVEL') != 0: + link_libpython = True + elif get_config_var('MACHDEP') == 'cygwin': + link_libpython = True + + if link_libpython: + ldversion = get_config_var('LDVERSION') + return ext.libraries + ['python' + ldversion] + + return ext.libraries diff --git a/shared/package-files/30/30c36bbf011e49363364559ac124b31e74c5606f9c480222203fb516e2757fc5/blob b/shared/package-files/30/30c36bbf011e49363364559ac124b31e74c5606f9c480222203fb516e2757fc5/blob new file mode 100644 index 0000000000000000000000000000000000000000..6baefd83bd0ae114941145349c10c583b3c43a31 --- /dev/null +++ b/shared/package-files/30/30c36bbf011e49363364559ac124b31e74c5606f9c480222203fb516e2757fc5/blob @@ -0,0 +1,402 @@ +import os +import sys +import ast +import types +import warnings +import unittest +import contextlib +from re import Pattern +from collections.abc import Callable, Iterable, Sequence +from typing import ( + Literal as L, + Any, + AnyStr, + ClassVar, + NoReturn, + overload, + type_check_only, + TypeVar, + Union, + Final, + SupportsIndex, +) +if sys.version_info >= (3, 10): + from typing import ParamSpec +else: + from typing_extensions import ParamSpec + +from numpy import generic, dtype, number, object_, bool_, _FloatValue +from numpy._typing import ( + NDArray, + ArrayLike, + DTypeLike, + _ArrayLikeNumber_co, + _ArrayLikeObject_co, + _ArrayLikeTD64_co, + _ArrayLikeDT64_co, +) + +from unittest.case import ( + SkipTest as SkipTest, +) + +_P = ParamSpec("_P") +_T = TypeVar("_T") +_ET = TypeVar("_ET", bound=BaseException) +_FT = TypeVar("_FT", bound=Callable[..., Any]) + +# Must return a bool or an ndarray/generic type +# that is supported by `np.logical_and.reduce` +_ComparisonFunc = Callable[ + [NDArray[Any], NDArray[Any]], + Union[ + bool, + bool_, + number[Any], + NDArray[Union[bool_, number[Any], object_]], + ], +] + +__all__: list[str] + +class KnownFailureException(Exception): ... +class IgnoreException(Exception): ... + +class clear_and_catch_warnings(warnings.catch_warnings): + class_modules: ClassVar[tuple[types.ModuleType, ...]] + modules: set[types.ModuleType] + @overload + def __new__( + cls, + record: L[False] = ..., + modules: Iterable[types.ModuleType] = ..., + ) -> _clear_and_catch_warnings_without_records: ... + @overload + def __new__( + cls, + record: L[True], + modules: Iterable[types.ModuleType] = ..., + ) -> _clear_and_catch_warnings_with_records: ... + @overload + def __new__( + cls, + record: bool, + modules: Iterable[types.ModuleType] = ..., + ) -> clear_and_catch_warnings: ... + def __enter__(self) -> None | list[warnings.WarningMessage]: ... + def __exit__( + self, + __exc_type: None | type[BaseException] = ..., + __exc_val: None | BaseException = ..., + __exc_tb: None | types.TracebackType = ..., + ) -> None: ... + +# Type-check only `clear_and_catch_warnings` subclasses for both values of the +# `record` parameter. Copied from the stdlib `warnings` stubs. + +@type_check_only +class _clear_and_catch_warnings_with_records(clear_and_catch_warnings): + def __enter__(self) -> list[warnings.WarningMessage]: ... + +@type_check_only +class _clear_and_catch_warnings_without_records(clear_and_catch_warnings): + def __enter__(self) -> None: ... + +class suppress_warnings: + log: list[warnings.WarningMessage] + def __init__( + self, + forwarding_rule: L["always", "module", "once", "location"] = ..., + ) -> None: ... + def filter( + self, + category: type[Warning] = ..., + message: str = ..., + module: None | types.ModuleType = ..., + ) -> None: ... + def record( + self, + category: type[Warning] = ..., + message: str = ..., + module: None | types.ModuleType = ..., + ) -> list[warnings.WarningMessage]: ... + def __enter__(self: _T) -> _T: ... + def __exit__( + self, + __exc_type: None | type[BaseException] = ..., + __exc_val: None | BaseException = ..., + __exc_tb: None | types.TracebackType = ..., + ) -> None: ... + def __call__(self, func: _FT) -> _FT: ... + +verbose: int +IS_PYPY: Final[bool] +IS_PYSTON: Final[bool] +HAS_REFCOUNT: Final[bool] +HAS_LAPACK64: Final[bool] + +def assert_(val: object, msg: str | Callable[[], str] = ...) -> None: ... + +# Contrary to runtime we can't do `os.name` checks while type checking, +# only `sys.platform` checks +if sys.platform == "win32" or sys.platform == "cygwin": + def memusage(processName: str = ..., instance: int = ...) -> int: ... +elif sys.platform == "linux": + def memusage(_proc_pid_stat: str | bytes | os.PathLike[Any] = ...) -> None | int: ... +else: + def memusage() -> NoReturn: ... + +if sys.platform == "linux": + def jiffies( + _proc_pid_stat: str | bytes | os.PathLike[Any] = ..., + _load_time: list[float] = ..., + ) -> int: ... +else: + def jiffies(_load_time: list[float] = ...) -> int: ... + +def build_err_msg( + arrays: Iterable[object], + err_msg: str, + header: str = ..., + verbose: bool = ..., + names: Sequence[str] = ..., + precision: None | SupportsIndex = ..., +) -> str: ... + +def assert_equal( + actual: object, + desired: object, + err_msg: str = ..., + verbose: bool = ..., +) -> None: ... + +def print_assert_equal( + test_string: str, + actual: object, + desired: object, +) -> None: ... + +def assert_almost_equal( + actual: _ArrayLikeNumber_co | _ArrayLikeObject_co, + desired: _ArrayLikeNumber_co | _ArrayLikeObject_co, + decimal: int = ..., + err_msg: str = ..., + verbose: bool = ..., +) -> None: ... + +# Anything that can be coerced into `builtins.float` +def assert_approx_equal( + actual: _FloatValue, + desired: _FloatValue, + significant: int = ..., + err_msg: str = ..., + verbose: bool = ..., +) -> None: ... + +def assert_array_compare( + comparison: _ComparisonFunc, + x: ArrayLike, + y: ArrayLike, + err_msg: str = ..., + verbose: bool = ..., + header: str = ..., + precision: SupportsIndex = ..., + equal_nan: bool = ..., + equal_inf: bool = ..., + *, + strict: bool = ... +) -> None: ... + +def assert_array_equal( + x: ArrayLike, + y: ArrayLike, + err_msg: str = ..., + verbose: bool = ..., + *, + strict: bool = ... +) -> None: ... + +def assert_array_almost_equal( + x: _ArrayLikeNumber_co | _ArrayLikeObject_co, + y: _ArrayLikeNumber_co | _ArrayLikeObject_co, + decimal: float = ..., + err_msg: str = ..., + verbose: bool = ..., +) -> None: ... + +@overload +def assert_array_less( + x: _ArrayLikeNumber_co | _ArrayLikeObject_co, + y: _ArrayLikeNumber_co | _ArrayLikeObject_co, + err_msg: str = ..., + verbose: bool = ..., +) -> None: ... +@overload +def assert_array_less( + x: _ArrayLikeTD64_co, + y: _ArrayLikeTD64_co, + err_msg: str = ..., + verbose: bool = ..., +) -> None: ... +@overload +def assert_array_less( + x: _ArrayLikeDT64_co, + y: _ArrayLikeDT64_co, + err_msg: str = ..., + verbose: bool = ..., +) -> None: ... + +def runstring( + astr: str | bytes | types.CodeType, + dict: None | dict[str, Any], +) -> Any: ... + +def assert_string_equal(actual: str, desired: str) -> None: ... + +def rundocs( + filename: None | str | os.PathLike[str] = ..., + raise_on_error: bool = ..., +) -> None: ... + +def raises(*args: type[BaseException]) -> Callable[[_FT], _FT]: ... + +@overload +def assert_raises( # type: ignore + expected_exception: type[BaseException] | tuple[type[BaseException], ...], + callable: Callable[_P, Any], + /, + *args: _P.args, + **kwargs: _P.kwargs, +) -> None: ... +@overload +def assert_raises( + expected_exception: type[_ET] | tuple[type[_ET], ...], + *, + msg: None | str = ..., +) -> unittest.case._AssertRaisesContext[_ET]: ... + +@overload +def assert_raises_regex( + expected_exception: type[BaseException] | tuple[type[BaseException], ...], + expected_regex: str | bytes | Pattern[Any], + callable: Callable[_P, Any], + /, + *args: _P.args, + **kwargs: _P.kwargs, +) -> None: ... +@overload +def assert_raises_regex( + expected_exception: type[_ET] | tuple[type[_ET], ...], + expected_regex: str | bytes | Pattern[Any], + *, + msg: None | str = ..., +) -> unittest.case._AssertRaisesContext[_ET]: ... + +def decorate_methods( + cls: type[Any], + decorator: Callable[[Callable[..., Any]], Any], + testmatch: None | str | bytes | Pattern[Any] = ..., +) -> None: ... + +def measure( + code_str: str | bytes | ast.mod | ast.AST, + times: int = ..., + label: None | str = ..., +) -> float: ... + +@overload +def assert_allclose( + actual: _ArrayLikeNumber_co | _ArrayLikeObject_co, + desired: _ArrayLikeNumber_co | _ArrayLikeObject_co, + rtol: float = ..., + atol: float = ..., + equal_nan: bool = ..., + err_msg: str = ..., + verbose: bool = ..., +) -> None: ... +@overload +def assert_allclose( + actual: _ArrayLikeTD64_co, + desired: _ArrayLikeTD64_co, + rtol: float = ..., + atol: float = ..., + equal_nan: bool = ..., + err_msg: str = ..., + verbose: bool = ..., +) -> None: ... + +def assert_array_almost_equal_nulp( + x: _ArrayLikeNumber_co, + y: _ArrayLikeNumber_co, + nulp: float = ..., +) -> None: ... + +def assert_array_max_ulp( + a: _ArrayLikeNumber_co, + b: _ArrayLikeNumber_co, + maxulp: float = ..., + dtype: DTypeLike = ..., +) -> NDArray[Any]: ... + +@overload +def assert_warns( + warning_class: type[Warning], +) -> contextlib._GeneratorContextManager[None]: ... +@overload +def assert_warns( + warning_class: type[Warning], + func: Callable[_P, _T], + /, + *args: _P.args, + **kwargs: _P.kwargs, +) -> _T: ... + +@overload +def assert_no_warnings() -> contextlib._GeneratorContextManager[None]: ... +@overload +def assert_no_warnings( + func: Callable[_P, _T], + /, + *args: _P.args, + **kwargs: _P.kwargs, +) -> _T: ... + +@overload +def tempdir( + suffix: None = ..., + prefix: None = ..., + dir: None = ..., +) -> contextlib._GeneratorContextManager[str]: ... +@overload +def tempdir( + suffix: None | AnyStr = ..., + prefix: None | AnyStr = ..., + dir: None | AnyStr | os.PathLike[AnyStr] = ..., +) -> contextlib._GeneratorContextManager[AnyStr]: ... + +@overload +def temppath( + suffix: None = ..., + prefix: None = ..., + dir: None = ..., + text: bool = ..., +) -> contextlib._GeneratorContextManager[str]: ... +@overload +def temppath( + suffix: None | AnyStr = ..., + prefix: None | AnyStr = ..., + dir: None | AnyStr | os.PathLike[AnyStr] = ..., + text: bool = ..., +) -> contextlib._GeneratorContextManager[AnyStr]: ... + +@overload +def assert_no_gc_cycles() -> contextlib._GeneratorContextManager[None]: ... +@overload +def assert_no_gc_cycles( + func: Callable[_P, Any], + /, + *args: _P.args, + **kwargs: _P.kwargs, +) -> None: ... + +def break_cycles() -> None: ... diff --git a/shared/package-files/30/30c6319da7d1f01784ec668e3fb9978bae41598d48940d824a5ed00b1c4381de/blob b/shared/package-files/30/30c6319da7d1f01784ec668e3fb9978bae41598d48940d824a5ed00b1c4381de/blob new file mode 100644 index 0000000000000000000000000000000000000000..f43baad39cc2ab4b87c0299237a31c0938e2e3f6 --- /dev/null +++ b/shared/package-files/30/30c6319da7d1f01784ec668e3fb9978bae41598d48940d824a5ed00b1c4381de/blob @@ -0,0 +1,50 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API softmax_int { + using schema = at::Tensor (const at::Tensor &, int64_t, c10::optional); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::softmax") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "int") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "softmax.int(Tensor self, int dim, ScalarType? dtype=None) -> Tensor") + static at::Tensor call(const at::Tensor & self, int64_t dim, c10::optional dtype); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, int64_t dim, c10::optional dtype); +}; + +struct TORCH_API softmax_int_out { + using schema = at::Tensor & (const at::Tensor &, int64_t, c10::optional, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::softmax") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "int_out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "softmax.int_out(Tensor self, int dim, ScalarType? dtype=None, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, int64_t dim, c10::optional dtype, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, int64_t dim, c10::optional dtype, at::Tensor & out); +}; + +struct TORCH_API softmax_Dimname { + using schema = at::Tensor (const at::Tensor &, at::Dimname, c10::optional); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::softmax") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Dimname") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "softmax.Dimname(Tensor self, Dimname dim, *, ScalarType? dtype=None) -> Tensor") + static at::Tensor call(const at::Tensor & self, at::Dimname dim, c10::optional dtype); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Dimname dim, c10::optional dtype); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/30/30c8ff35a0f16696234f28e3cbc560fa8861f69c7c21532cc915b7eb70a32fa4/blob b/shared/package-files/30/30c8ff35a0f16696234f28e3cbc560fa8861f69c7c21532cc915b7eb70a32fa4/blob new file mode 100644 index 0000000000000000000000000000000000000000..10e3e44bd171428f605d86198f580919c7b369c7 Binary files /dev/null and b/shared/package-files/30/30c8ff35a0f16696234f28e3cbc560fa8861f69c7c21532cc915b7eb70a32fa4/blob differ diff --git a/shared/package-files/30/30c909576074514a7cde3865dd3dca9f0e48852b7a9456d76d821369cec55d2b/blob b/shared/package-files/30/30c909576074514a7cde3865dd3dca9f0e48852b7a9456d76d821369cec55d2b/blob new file mode 100644 index 0000000000000000000000000000000000000000..fe584cb22402b8f8feaa3a4203e6b38d70579db2 --- /dev/null +++ b/shared/package-files/30/30c909576074514a7cde3865dd3dca9f0e48852b7a9456d76d821369cec55d2b/blob @@ -0,0 +1,214 @@ +""" +Descriptive Statistics for Time Series + +Created on Sat Oct 30 14:24:08 2010 + +Author: josef-pktd +License: BSD(3clause) +""" + +import warnings + +from statsmodels.graphics.utils import _import_mpl + +from . import stattools as stt + + +# TODO: check subclassing for descriptive stats classes +class TsaDescriptive: + """ + Collection of descriptive statistical methods for time series + + Parameters + ---------- + data : array_like + The time series data. + label : str, optional + A label used to identify the series. + name : str, optional + A name used as the base for labeling series derived from `data`, + such as those produced by `filter` and `detrend`. + + Attributes + ---------- + data : array_like + The time series data. + label : str + The label identifying the series. + name : str + The base name used for derived series. + mod : None + Placeholder for the model instance created by `fit`. + res : None + Placeholder for the results instance created by `fit`. + """ + + def __init__(self, data, label=None, name=""): + warnings.warn( + "TsaDescriptive is deprecated. Although documented, it has had " + "no test coverage and no internal callers, and its behavior is " + "not guaranteed. It will be removed after statsmodels 0.16 is " + "released. If you rely on this class, please open an issue at " + "https://github.com/statsmodels/statsmodels/issues.", + FutureWarning, + stacklevel=2, + ) + self.data = data + self.label = label + self.name = name + self.mod = None + self.res = None + + def filter(self, num, den): + """ + Filter the time series using a linear filter. + + Parameters + ---------- + num : array_like + The numerator coefficient vector of the filter. + den : array_like + The denominator coefficient vector of the filter. + + Returns + ------- + TsaDescriptive + A new instance containing the filtered data. + """ + from scipy.signal import lfilter + xfiltered = lfilter(num, den, self.data) + return self.__class__(xfiltered, self.label, self.name + "_filtered") + + def detrend(self, order=1): + """ + Detrend the time series. + + Parameters + ---------- + order : int, optional + The polynomial order of the trend to remove. + + Returns + ------- + TsaDescriptive + A new instance containing the detrended data. + """ + from . import tsatools + xdetrended = tsatools.detrend(self.data, order=order) + return self.__class__(xdetrended, self.label, self.name + "_detrended") + + def fit(self, order=(1, 0, 1), **kwds): + """ + Fit an ARMA model to the time series. + + Parameters + ---------- + order : tuple of int, optional + The (p, q) order, or (p, d, q) order, of the ARMA model to fit. + **kwds + Additional keyword arguments passed to the model's `fit` method. + + Returns + ------- + Results + The results instance from fitting the model. + """ + from statsmodels.tsa.arima.model import ARIMA + self.mod = ARIMA(self.data, order=order) + self.res = self.mod.fit(**kwds) + + return self.res + + def acf(self, nlags=40): + """ + Compute the autocorrelation function of the time series. + + Parameters + ---------- + nlags : int, optional + The number of lags to include. + + Returns + ------- + ndarray + The autocorrelation function. + """ + return stt.acf(self.data, nlags=nlags) + + def pacf(self, nlags=40): + """ + Compute the partial autocorrelation function of the time series. + + Parameters + ---------- + nlags : int, optional + The number of lags to include. + + Returns + ------- + ndarray + The partial autocorrelation function. + """ + return stt.pacf(self.data, nlags=nlags) + + def periodogram(self): + """ + Compute the periodogram of the time series. + + Returns + ------- + ndarray + The periodogram values. + """ + # does not return frequencies + return stt.periodogram(self.data) + + # copied from fftarma.py + def plot4(self, fig=None, nobs=100, nacf=20, nfreq=100): + """ + Plot the series, its ACF, PACF, and power spectrum. + + Parameters + ---------- + fig : Figure, optional + An existing matplotlib figure to draw the plots in. If not + provided, a new figure is created. + nobs : int, optional + The number of observations to use. Not used. + nacf : int, optional + The number of lags to include in the ACF and PACF plots. + nfreq : int, optional + The number of frequencies to include in the power spectrum + plot. + + Returns + ------- + Figure + The figure containing the plots. + """ + data = self.data + acf = self.acf(nacf) + pacf = self.pacf(nacf) + spdr = self.periodogram()[:nfreq] # (w) + + if fig is None: + plt = _import_mpl() + fig = plt.figure() + ax = fig.add_subplot(2, 2, 1) + namestr = f" for {self.name}" if self.name else "" + ax.plot(data) + ax.set_title("Time series" + namestr) + + ax = fig.add_subplot(2, 2, 2) + ax.plot(acf) + ax.set_title("Autocorrelation" + namestr) + + ax = fig.add_subplot(2, 2, 3) + ax.plot(spdr) # (wr, spdr) + ax.set_title("Power Spectrum" + namestr) + + ax = fig.add_subplot(2, 2, 4) + ax.plot(pacf) + ax.set_title("Partial Autocorrelation" + namestr) + + return fig diff --git a/shared/package-files/30/30c92eb161f5977aa63107874aa7165ed5d0d3e0ca1813c26d826d33235d93f1/blob b/shared/package-files/30/30c92eb161f5977aa63107874aa7165ed5d0d3e0ca1813c26d826d33235d93f1/blob new file mode 100644 index 0000000000000000000000000000000000000000..1aeaca19652a652db6ff3aded81e2bdec8b3a4af --- /dev/null +++ b/shared/package-files/30/30c92eb161f5977aa63107874aa7165ed5d0d3e0ca1813c26d826d33235d93f1/blob @@ -0,0 +1,429 @@ +#include +#include +#include +#include +#include + +namespace at { +namespace native { + +template +struct TopKTypeConfig {}; + +template <> +struct TopKTypeConfig { + typedef uint32_t RadixType; + + // Converts a float to an integer representation with the same + // sorting; i.e., for floats f1, f2: + // if f1 < f2 then convert(f1) < convert(f2) + // We use this to enable radix selection of floating-point values. + // This also gives a relative order for NaNs, but that's ok, as they + // will all be adjacent + // neg inf: signbit=1 exp=ff fraction=0 --> radix = 0 00 ff.. + // pos inf: signbit=0 exp=ff fraction=0 --> radix = 1 ff 00.. + // pos nan: signbit=0 exp=ff fraction>0 --> radix = 1 ff x>0 + // neg nan: signbit=1 exp=ff fraction>0 --> radix = 0 00 x +struct TopKTypeConfig { + typedef uint32_t RadixType; + + static inline __device__ RadixType convert(uint8_t v) { + return v; + } + + static inline __device__ uint8_t deconvert(RadixType v) { + return v; + } +}; + +template <> +struct TopKTypeConfig { + typedef uint32_t RadixType; + + static inline __device__ RadixType convert(int8_t v) { + return 128u + v; + } + + static inline __device__ int8_t deconvert(RadixType v) { + return v - 128; + } +}; + +template <> +struct TopKTypeConfig { + typedef uint32_t RadixType; + + static inline __device__ RadixType convert(int16_t v) { + static_assert(sizeof(short) == 2, ""); + return 32768u + v; + } + + static inline __device__ int16_t deconvert(RadixType v) { + return v - 32768; + } +}; + +template <> +struct TopKTypeConfig { + typedef uint32_t RadixType; + + static inline __device__ RadixType convert(int32_t v) { + static_assert(sizeof(int) == 4, ""); + return 2147483648u + v; + } + + static inline __device__ int32_t deconvert(RadixType v) { + return v - 2147483648u; + } +}; + +template <> +struct TopKTypeConfig { + typedef uint64_t RadixType; + + static inline __device__ RadixType convert(int64_t v) { + static_assert(sizeof(int64_t) == 8, ""); + return 9223372036854775808ull + v; + } + + static inline __device__ int64_t deconvert(RadixType v) { + return v - 9223372036854775808ull; + } +}; + +template <> +struct TopKTypeConfig { + typedef uint64_t RadixType; + + static inline __device__ RadixType convert(double v) { + RadixType x = __double_as_longlong(v); + RadixType mask = -((x >> 63)) | 0x8000000000000000; + return (v == v) ? (x ^ mask) : 0xffffffffffffffff; + } + + static inline __device__ double deconvert(RadixType v) { + RadixType mask = ((v >> 63) - 1) | 0x8000000000000000; + return __longlong_as_double(v ^ mask); + } +}; + +template <> +struct TopKTypeConfig { + typedef uint32_t RadixType; + + static inline __device__ RadixType convert(at::Half v) { +#if defined(__CUDA_ARCH__) || defined(USE_ROCM) + RadixType x = __half_as_ushort(v); + RadixType mask = (x & 0x00008000) ? 0x0000ffff : 0x00008000; + return (v == v) ? (x ^ mask) : 0xffff; +#else + CUDA_KERNEL_ASSERT(false); + return 0u; +#endif + } + + static inline __device__ at::Half deconvert(RadixType v) { +#if defined(__CUDA_ARCH__) || defined(USE_ROCM) + RadixType mask = (v & 0x00008000) ? 0x00008000 : 0x0000ffff; + return __ushort_as_half(v ^ mask); +#else + CUDA_KERNEL_ASSERT(false); + return static_cast(0); +#endif + } +}; + +template <> +struct TopKTypeConfig { + typedef uint32_t RadixType; + + static inline __device__ RadixType convert(at::BFloat16 v) { + RadixType x = v.x; + RadixType mask = (x & 0x00008000) ? 0x0000ffff : 0x00008000; + return (v == v) ? (x ^ mask) : 0xffff; + } + + static inline __device__ at::BFloat16 deconvert(RadixType v) { + RadixType mask = (v & 0x00008000) ? 0x00008000 : 0x0000ffff; + at::BFloat16 r; + r.x = (v ^ mask); + return r; + } +}; + +// This function counts the distribution of all input values in a +// slice we are selecting by radix digit at `radixDigitPos`, but only +// those that pass the filter `((v & desiredMask) == desired)`. +// This produces and broadcasts the seen counts for a single block only. +// `smem` must have at least `RadixSize` elements. +template < + typename scalar_t, + typename bitwise_t, + typename index_t, + typename CountType, + int RadixSize, + int RadixBits> +__device__ void countRadixUsingMask( + CountType counts[RadixSize], + CountType* smem, + bitwise_t desired, + bitwise_t desiredMask, + int radixDigitPos, + index_t sliceSize, + index_t withinSliceStride, + const scalar_t* data) { + // Clear out per-thread counts from a previous round +#pragma unroll + for (int i = 0; i < RadixSize; ++i) { + counts[i] = 0; + } + + if (threadIdx.x < RadixSize) { + smem[threadIdx.x] = 0; + } + __syncthreads(); + + // Scan over all the data. Upon a read, the warp will accumulate + // counts per each digit in the radix using warp voting. +#if !defined(USE_ROCM) + // Must be called outside of loop to ensure all threads participate + unsigned mask = WARP_BALLOT(threadIdx.x < sliceSize); +#endif + for (index_t i = threadIdx.x; i < sliceSize;) { + bitwise_t val = + TopKTypeConfig::convert(doLdg(&data[i * withinSliceStride])); + + bool hasVal = ((val & desiredMask) == desired); + bitwise_t digitInRadix = at::cuda::Bitfield::getBitfield( + val, radixDigitPos, RadixBits); + +#pragma unroll + for (uint32_t j = 0; j < RadixSize; ++j) { + bool vote = hasVal && (digitInRadix == j); +#if defined(USE_ROCM) + counts[j] += __popcll(WARP_BALLOT(vote)); +#else + counts[j] += __popc(WARP_BALLOT(vote, mask)); +#endif + } + i += blockDim.x; +#if !defined(USE_ROCM) + mask = WARP_BALLOT(i < sliceSize, mask); +#endif + } + + // Now, for each warp, sum values + if (at::cuda::getLaneId() == 0) { +#pragma unroll + for (uint32_t i = 0; i < RadixSize; ++i) { + gpuAtomicAddNoReturn(&smem[i], counts[i]); + } + } + + __syncthreads(); + + // For each thread, read in the total counts +#pragma unroll + for (uint32_t i = 0; i < RadixSize; ++i) { + counts[i] = smem[i]; + } + + __syncthreads(); +} + +// Over what radix we are selecting values +constexpr int RADIX_BITS = 2; // digits are base-(2 ^ RADIX_BITS) +constexpr int RADIX_SIZE = 4; // 2 ^ RADIX_BITS +constexpr int RADIX_MASK = (RADIX_SIZE - 1); + +// This finds the unique value `v` that matches the pattern +// ((v & desired) == desiredMask) in our sorted int format +template +__device__ scalar_t findPattern( + scalar_t* smem, + const scalar_t* data, + index_t sliceSize, + index_t withinSliceStride, + bitwise_t desired, + bitwise_t desiredMask) { + if (threadIdx.x < 2) { + smem[threadIdx.x] = static_cast(0); + } + __syncthreads(); + + // All threads participate in the loop, in order to sync on the flag + index_t numIterations = + round_up(sliceSize, static_cast(blockDim.x)); + for (index_t i = threadIdx.x; i < numIterations; i += blockDim.x) { + bool inRange = (i < sliceSize); + scalar_t v = inRange ? doLdg(&data[i * withinSliceStride]) + : static_cast(0); + + if (inRange && + ((TopKTypeConfig::convert(v) & desiredMask) == desired)) { + // There should not be conflicts if we are using findPattern, + // since the result is unique + smem[0] = static_cast(1); + smem[1] = v; // can't use val as the flag, since it could be 0 + } + + __syncthreads(); + + scalar_t found = smem[0]; + scalar_t val = smem[1]; + + __syncthreads(); + + // Check to see if a thread found the value + if (found != static_cast(0)) { + // all threads return this value + return val; + } + } + + // should not get here + CUDA_KERNEL_ASSERT(false); + return static_cast(0); +} + +// Returns the top-Kth element found in the data using radix selection +template +__device__ void radixSelect( + const scalar_t* data, + index_t k, + bool largest, + index_t sliceSize, + index_t withinSliceStride, + int* smem, + scalar_t* topK) { + // Per-thread buckets into which we accumulate digit counts in our + // radix + int counts[RADIX_SIZE]; + + // We only consider elements x such that (x & desiredMask) == desired + // Initially, we consider all elements of the array, so the above + // statement is true regardless of input. + bitwise_t desired = 0; + bitwise_t desiredMask = 0; + + // We are looking for the top kToFind-th element when iterating over + // digits; this count gets reduced by elimination when counting + // successive digits + int kToFind = k; + + // We start at the most significant digit in our radix, scanning + // through to the least significant digit + for (int digitPos = sizeof(scalar_t) * 8 - RADIX_BITS; digitPos >= 0; + digitPos -= RADIX_BITS) { + // Count radix distribution for the current position and reduce + // across all threads + countRadixUsingMask< + scalar_t, + bitwise_t, + index_t, + int, + RADIX_SIZE, + RADIX_BITS>( + counts, + smem, + desired, + desiredMask, + digitPos, + sliceSize, + withinSliceStride, + data); + + auto found_unique = [&](int i, int count) -> bool { + /* All threads have the same value in counts here, so all */ + /* threads will return from the function. */ + if (count == 1 && kToFind == 1) { + /* There is a unique answer. */ + desired = at::cuda::Bitfield::setBitfield( + desired, i, digitPos, RADIX_BITS); + desiredMask = at::cuda::Bitfield::setBitfield( + desiredMask, RADIX_MASK, digitPos, RADIX_BITS); + + /* The answer is now the unique element v such that: */ + /* (v & desiredMask) == desired */ + /* However, we do not yet know what the actual element is. We */ + /* need to perform a search through the data to find the */ + /* element that matches this pattern. */ + *topK = findPattern( + (scalar_t*)smem, + data, + sliceSize, + withinSliceStride, + desired, + desiredMask); + return true; + } + return false; + }; + auto found_non_unique = [&](int i, int count) -> bool { + if (count >= kToFind) { + desired = + at::cuda::Bitfield::setBitfield( + desired, i, digitPos, RADIX_BITS); + desiredMask = at::cuda::Bitfield::setBitfield( + desiredMask, RADIX_MASK, digitPos, RADIX_BITS); + + /* The top-Kth element v must now be one such that: */ + /* (v & desiredMask == desired) */ + /* but we haven't narrowed it down; we must check the next */ + /* least-significant digit */ + return true; + } + kToFind -= count; + return false; // continue the loop + }; + + // All threads participate in the comparisons below to know the + // final result + if (largest) { + // Process in descending order +#pragma unroll + for (int i = RADIX_SIZE - 1; i >= 0; --i) { + int count = counts[i]; + if (found_unique(i, count)) { + return; + } + if (found_non_unique(i, count)) { + break; + } + } + } else { + // Process in ascending order +#pragma unroll + for (int i = 0; i < RADIX_SIZE; ++i) { + int count = counts[i]; + if (found_unique(i, count)) { + return; + } + if (found_non_unique(i, count)) { + break; + } + } + } + } // end digitPos for + + // There is no unique result, but there is a non-unique result + // matching `desired` exactly + *topK = TopKTypeConfig::deconvert(desired); +} +} // namespace native +} // namespace at diff --git a/shared/package-files/30/30c9a22afb80c865ac36315f285a490da419745009c4affaa81d26b92d78ca0a/blob b/shared/package-files/30/30c9a22afb80c865ac36315f285a490da419745009c4affaa81d26b92d78ca0a/blob new file mode 100644 index 0000000000000000000000000000000000000000..90aa9800cd8ec98ddddcb50dc55bc696e340296b --- /dev/null +++ b/shared/package-files/30/30c9a22afb80c865ac36315f285a490da419745009c4affaa81d26b92d78ca0a/blob @@ -0,0 +1,22 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API ::std::tuple miopen_rnn_out(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const at::Tensor & hx, const c10::optional & cx, int64_t mode, int64_t hidden_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const c10::optional & dropout_state, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, at::Tensor & out3, at::Tensor & out4); +TORCH_API ::std::tuple miopen_rnn(const at::Tensor & input, at::TensorList weight, int64_t weight_stride0, const at::Tensor & hx, const c10::optional & cx, int64_t mode, int64_t hidden_size, int64_t num_layers, bool batch_first, double dropout, bool train, bool bidirectional, at::IntArrayRef batch_sizes, const c10::optional & dropout_state); +} // namespace native +} // namespace at diff --git a/shared/package-files/30/30cb961bf60e52781f5b9d77ef2bba8803ae8234717a1adf92089dbc3d49e913/blob b/shared/package-files/30/30cb961bf60e52781f5b9d77ef2bba8803ae8234717a1adf92089dbc3d49e913/blob new file mode 100644 index 0000000000000000000000000000000000000000..e191ee694211eabae51e9706b9bc65df9ad0ba78 --- /dev/null +++ b/shared/package-files/30/30cb961bf60e52781f5b9d77ef2bba8803ae8234717a1adf92089dbc3d49e913/blob @@ -0,0 +1,1780 @@ +"""Elliptical geometrical entities. + +Contains +* Ellipse +* Circle + +""" + +from sympy.core.expr import Expr +from sympy.core.relational import Eq +from sympy.core import S, pi, sympify +from sympy.core.evalf import N +from sympy.core.parameters import global_parameters +from sympy.core.logic import fuzzy_bool +from sympy.core.numbers import Rational, oo +from sympy.core.sorting import ordered +from sympy.core.symbol import Dummy, uniquely_named_symbol, _symbol +from sympy.simplify import simplify, trigsimp +from sympy.functions.elementary.miscellaneous import sqrt, Max +from sympy.functions.elementary.trigonometric import cos, sin +from sympy.functions.special.elliptic_integrals import elliptic_e +from .entity import GeometryEntity, GeometrySet +from .exceptions import GeometryError +from .line import Line, Segment, Ray2D, Segment2D, Line2D, LinearEntity3D +from .point import Point, Point2D, Point3D +from .util import idiff, find +from sympy.polys import DomainError, Poly, PolynomialError +from sympy.polys.polyutils import _not_a_coeff, _nsort +from sympy.solvers import solve +from sympy.solvers.solveset import linear_coeffs +from sympy.utilities.misc import filldedent, func_name + +from mpmath.libmp.libmpf import prec_to_dps + +import random + +x, y = [Dummy('ellipse_dummy', real=True) for i in range(2)] + + +class Ellipse(GeometrySet): + """An elliptical GeometryEntity. + + Parameters + ========== + + center : Point, optional + Default value is Point(0, 0) + hradius : number or SymPy expression, optional + vradius : number or SymPy expression, optional + eccentricity : number or SymPy expression, optional + Two of `hradius`, `vradius` and `eccentricity` must be supplied to + create an Ellipse. The third is derived from the two supplied. + + Attributes + ========== + + center + hradius + vradius + area + circumference + eccentricity + periapsis + apoapsis + focus_distance + foci + + Raises + ====== + + GeometryError + When `hradius`, `vradius` and `eccentricity` are incorrectly supplied + as parameters. + TypeError + When `center` is not a Point. + + See Also + ======== + + Circle + + Notes + ----- + Constructed from a center and two radii, the first being the horizontal + radius (along the x-axis) and the second being the vertical radius (along + the y-axis). + + When symbolic value for hradius and vradius are used, any calculation that + refers to the foci or the major or minor axis will assume that the ellipse + has its major radius on the x-axis. If this is not true then a manual + rotation is necessary. + + Examples + ======== + + >>> from sympy import Ellipse, Point, Rational + >>> e1 = Ellipse(Point(0, 0), 5, 1) + >>> e1.hradius, e1.vradius + (5, 1) + >>> e2 = Ellipse(Point(3, 1), hradius=3, eccentricity=Rational(4, 5)) + >>> e2 + Ellipse(Point2D(3, 1), 3, 9/5) + + """ + + def __contains__(self, o): + if isinstance(o, Point): + res = self.equation(x, y).subs({x: o.x, y: o.y}) + return trigsimp(simplify(res)) is S.Zero + elif isinstance(o, Ellipse): + return self == o + return False + + def __eq__(self, o): + """Is the other GeometryEntity the same as this ellipse?""" + return isinstance(o, Ellipse) and (self.center == o.center and + self.hradius == o.hradius and + self.vradius == o.vradius) + + def __hash__(self): + return super().__hash__() + + def __new__( + cls, center=None, hradius=None, vradius=None, eccentricity=None, **kwargs): + + hradius = sympify(hradius) + vradius = sympify(vradius) + + if center is None: + center = Point(0, 0) + else: + if len(center) != 2: + raise ValueError('The center of "{}" must be a two dimensional point'.format(cls)) + center = Point(center, dim=2) + + if len(list(filter(lambda x: x is not None, (hradius, vradius, eccentricity)))) != 2: + raise ValueError(filldedent(''' + Exactly two arguments of "hradius", "vradius", and + "eccentricity" must not be None.''')) + + if eccentricity is not None: + eccentricity = sympify(eccentricity) + if eccentricity.is_negative: + raise GeometryError("Eccentricity of ellipse/circle should lie between [0, 1)") + elif hradius is None: + hradius = vradius / sqrt(1 - eccentricity**2) + elif vradius is None: + vradius = hradius * sqrt(1 - eccentricity**2) + + if hradius == vradius: + return Circle(center, hradius, **kwargs) + + if S.Zero in (hradius, vradius): + return Segment(Point(center[0] - hradius, center[1] - vradius), Point(center[0] + hradius, center[1] + vradius)) + + if hradius.is_real is False or vradius.is_real is False: + raise GeometryError("Invalid value encountered when computing hradius / vradius.") + + return GeometryEntity.__new__(cls, center, hradius, vradius, **kwargs) + + def _svg(self, scale_factor=1., fill_color="#66cc99"): + """Returns SVG ellipse element for the Ellipse. + + Parameters + ========== + + scale_factor : float + Multiplication factor for the SVG stroke-width. Default is 1. + fill_color : str, optional + Hex string for fill color. Default is "#66cc99". + """ + + c = N(self.center) + h, v = N(self.hradius), N(self.vradius) + return ( + '' + ).format(2. * scale_factor, fill_color, c.x, c.y, h, v) + + @property + def ambient_dimension(self): + return 2 + + @property + def apoapsis(self): + """The apoapsis of the ellipse. + + The greatest distance between the focus and the contour. + + Returns + ======= + + apoapsis : number + + See Also + ======== + + periapsis : Returns shortest distance between foci and contour + + Examples + ======== + + >>> from sympy import Point, Ellipse + >>> p1 = Point(0, 0) + >>> e1 = Ellipse(p1, 3, 1) + >>> e1.apoapsis + 2*sqrt(2) + 3 + + """ + return self.major * (1 + self.eccentricity) + + def arbitrary_point(self, parameter='t'): + """A parameterized point on the ellipse. + + Parameters + ========== + + parameter : str, optional + Default value is 't'. + + Returns + ======= + + arbitrary_point : Point + + Raises + ====== + + ValueError + When `parameter` already appears in the functions. + + See Also + ======== + + sympy.geometry.point.Point + + Examples + ======== + + >>> from sympy import Point, Ellipse + >>> e1 = Ellipse(Point(0, 0), 3, 2) + >>> e1.arbitrary_point() + Point2D(3*cos(t), 2*sin(t)) + + """ + t = _symbol(parameter, real=True) + if t.name in (f.name for f in self.free_symbols): + raise ValueError(filldedent('Symbol %s already appears in object ' + 'and cannot be used as a parameter.' % t.name)) + return Point(self.center.x + self.hradius*cos(t), + self.center.y + self.vradius*sin(t)) + + @property + def area(self): + """The area of the ellipse. + + Returns + ======= + + area : number + + Examples + ======== + + >>> from sympy import Point, Ellipse + >>> p1 = Point(0, 0) + >>> e1 = Ellipse(p1, 3, 1) + >>> e1.area + 3*pi + + """ + return simplify(S.Pi * self.hradius * self.vradius) + + @property + def bounds(self): + """Return a tuple (xmin, ymin, xmax, ymax) representing the bounding + rectangle for the geometric figure. + + """ + + h, v = self.hradius, self.vradius + return (self.center.x - h, self.center.y - v, self.center.x + h, self.center.y + v) + + @property + def center(self): + """The center of the ellipse. + + Returns + ======= + + center : number + + See Also + ======== + + sympy.geometry.point.Point + + Examples + ======== + + >>> from sympy import Point, Ellipse + >>> p1 = Point(0, 0) + >>> e1 = Ellipse(p1, 3, 1) + >>> e1.center + Point2D(0, 0) + + """ + return self.args[0] + + @property + def circumference(self): + """The circumference of the ellipse. + + Examples + ======== + + >>> from sympy import Point, Ellipse + >>> p1 = Point(0, 0) + >>> e1 = Ellipse(p1, 3, 1) + >>> e1.circumference + 12*elliptic_e(8/9) + + """ + if self.eccentricity == 1: + # degenerate + return 4*self.major + elif self.eccentricity == 0: + # circle + return 2*pi*self.hradius + else: + return 4*self.major*elliptic_e(self.eccentricity**2) + + @property + def eccentricity(self): + """The eccentricity of the ellipse. + + Returns + ======= + + eccentricity : number + + Examples + ======== + + >>> from sympy import Point, Ellipse, sqrt + >>> p1 = Point(0, 0) + >>> e1 = Ellipse(p1, 3, sqrt(2)) + >>> e1.eccentricity + sqrt(7)/3 + + """ + return self.focus_distance / self.major + + def encloses_point(self, p): + """ + Return True if p is enclosed by (is inside of) self. + + Notes + ----- + Being on the border of self is considered False. + + Parameters + ========== + + p : Point + + Returns + ======= + + encloses_point : True, False or None + + See Also + ======== + + sympy.geometry.point.Point + + Examples + ======== + + >>> from sympy import Ellipse, S + >>> from sympy.abc import t + >>> e = Ellipse((0, 0), 3, 2) + >>> e.encloses_point((0, 0)) + True + >>> e.encloses_point(e.arbitrary_point(t).subs(t, S.Half)) + False + >>> e.encloses_point((4, 0)) + False + + """ + p = Point(p, dim=2) + if p in self: + return False + + if len(self.foci) == 2: + # if the combined distance from the foci to p (h1 + h2) is less + # than the combined distance from the foci to the minor axis + # (which is the same as the major axis length) then p is inside + # the ellipse + h1, h2 = [f.distance(p) for f in self.foci] + test = 2*self.major - (h1 + h2) + else: + test = self.radius - self.center.distance(p) + + return fuzzy_bool(test.is_positive) + + def equation(self, x='x', y='y', _slope=None): + """ + Returns the equation of an ellipse aligned with the x and y axes; + when slope is given, the equation returned corresponds to an ellipse + with a major axis having that slope. + + Parameters + ========== + + x : str, optional + Label for the x-axis. Default value is 'x'. + y : str, optional + Label for the y-axis. Default value is 'y'. + _slope : Expr, optional + The slope of the major axis. Ignored when 'None'. + + Returns + ======= + + equation : SymPy expression + + See Also + ======== + + arbitrary_point : Returns parameterized point on ellipse + + Examples + ======== + + >>> from sympy import Point, Ellipse, pi + >>> from sympy.abc import x, y + >>> e1 = Ellipse(Point(1, 0), 3, 2) + >>> eq1 = e1.equation(x, y); eq1 + y**2/4 + (x/3 - 1/3)**2 - 1 + >>> eq2 = e1.equation(x, y, _slope=1); eq2 + (-x + y + 1)**2/8 + (x + y - 1)**2/18 - 1 + + A point on e1 satisfies eq1. Let's use one on the x-axis: + + >>> p1 = e1.center + Point(e1.major, 0) + >>> assert eq1.subs(x, p1.x).subs(y, p1.y) == 0 + + When rotated the same as the rotated ellipse, about the center + point of the ellipse, it will satisfy the rotated ellipse's + equation, too: + + >>> r1 = p1.rotate(pi/4, e1.center) + >>> assert eq2.subs(x, r1.x).subs(y, r1.y) == 0 + + References + ========== + + .. [1] https://math.stackexchange.com/questions/108270/what-is-the-equation-of-an-ellipse-that-is-not-aligned-with-the-axis + .. [2] https://en.wikipedia.org/wiki/Ellipse#Shifted_ellipse + + """ + + x = _symbol(x, real=True) + y = _symbol(y, real=True) + + dx = x - self.center.x + dy = y - self.center.y + + if _slope is not None: + L = (dy - _slope*dx)**2 + l = (_slope*dy + dx)**2 + h = 1 + _slope**2 + b = h*self.major**2 + a = h*self.minor**2 + return l/b + L/a - 1 + + else: + t1 = (dx/self.hradius)**2 + t2 = (dy/self.vradius)**2 + return t1 + t2 - 1 + + def evolute(self, x='x', y='y'): + """The equation of evolute of the ellipse. + + Parameters + ========== + + x : str, optional + Label for the x-axis. Default value is 'x'. + y : str, optional + Label for the y-axis. Default value is 'y'. + + Returns + ======= + + equation : SymPy expression + + Examples + ======== + + >>> from sympy import Point, Ellipse + >>> e1 = Ellipse(Point(1, 0), 3, 2) + >>> e1.evolute() + 2**(2/3)*y**(2/3) + (3*x - 3)**(2/3) - 5**(2/3) + """ + if len(self.args) != 3: + raise NotImplementedError('Evolute of arbitrary Ellipse is not supported.') + x = _symbol(x, real=True) + y = _symbol(y, real=True) + t1 = (self.hradius*(x - self.center.x))**Rational(2, 3) + t2 = (self.vradius*(y - self.center.y))**Rational(2, 3) + return t1 + t2 - (self.hradius**2 - self.vradius**2)**Rational(2, 3) + + @property + def foci(self): + """The foci of the ellipse. + + Notes + ----- + The foci can only be calculated if the major/minor axes are known. + + Raises + ====== + + ValueError + When the major and minor axis cannot be determined. + + See Also + ======== + + sympy.geometry.point.Point + focus_distance : Returns the distance between focus and center + + Examples + ======== + + >>> from sympy import Point, Ellipse + >>> p1 = Point(0, 0) + >>> e1 = Ellipse(p1, 3, 1) + >>> e1.foci + (Point2D(-2*sqrt(2), 0), Point2D(2*sqrt(2), 0)) + + """ + c = self.center + hr, vr = self.hradius, self.vradius + if hr == vr: + return (c, c) + + # calculate focus distance manually, since focus_distance calls this + # routine + fd = sqrt(self.major**2 - self.minor**2) + if hr == self.minor: + # foci on the y-axis + return (c + Point(0, -fd), c + Point(0, fd)) + elif hr == self.major: + # foci on the x-axis + return (c + Point(-fd, 0), c + Point(fd, 0)) + + @property + def focus_distance(self): + """The focal distance of the ellipse. + + The distance between the center and one focus. + + Returns + ======= + + focus_distance : number + + See Also + ======== + + foci + + Examples + ======== + + >>> from sympy import Point, Ellipse + >>> p1 = Point(0, 0) + >>> e1 = Ellipse(p1, 3, 1) + >>> e1.focus_distance + 2*sqrt(2) + + """ + return Point.distance(self.center, self.foci[0]) + + @property + def hradius(self): + """The horizontal radius of the ellipse. + + Returns + ======= + + hradius : number + + See Also + ======== + + vradius, major, minor + + Examples + ======== + + >>> from sympy import Point, Ellipse + >>> p1 = Point(0, 0) + >>> e1 = Ellipse(p1, 3, 1) + >>> e1.hradius + 3 + + """ + return self.args[1] + + def intersection(self, o): + """The intersection of this ellipse and another geometrical entity + `o`. + + Parameters + ========== + + o : GeometryEntity + + Returns + ======= + + intersection : list of GeometryEntity objects + + Notes + ----- + Currently supports intersections with Point, Line, Segment, Ray, + Circle and Ellipse types. + + See Also + ======== + + sympy.geometry.entity.GeometryEntity + + Examples + ======== + + >>> from sympy import Ellipse, Point, Line + >>> e = Ellipse(Point(0, 0), 5, 7) + >>> e.intersection(Point(0, 0)) + [] + >>> e.intersection(Point(5, 0)) + [Point2D(5, 0)] + >>> e.intersection(Line(Point(0,0), Point(0, 1))) + [Point2D(0, -7), Point2D(0, 7)] + >>> e.intersection(Line(Point(5,0), Point(5, 1))) + [Point2D(5, 0)] + >>> e.intersection(Line(Point(6,0), Point(6, 1))) + [] + >>> e = Ellipse(Point(-1, 0), 4, 3) + >>> e.intersection(Ellipse(Point(1, 0), 4, 3)) + [Point2D(0, -3*sqrt(15)/4), Point2D(0, 3*sqrt(15)/4)] + >>> e.intersection(Ellipse(Point(5, 0), 4, 3)) + [Point2D(2, -3*sqrt(7)/4), Point2D(2, 3*sqrt(7)/4)] + >>> e.intersection(Ellipse(Point(100500, 0), 4, 3)) + [] + >>> e.intersection(Ellipse(Point(0, 0), 3, 4)) + [Point2D(3, 0), Point2D(-363/175, -48*sqrt(111)/175), Point2D(-363/175, 48*sqrt(111)/175)] + >>> e.intersection(Ellipse(Point(-1, 0), 3, 4)) + [Point2D(-17/5, -12/5), Point2D(-17/5, 12/5), Point2D(7/5, -12/5), Point2D(7/5, 12/5)] + """ + # TODO: Replace solve with nonlinsolve, when nonlinsolve will be able to solve in real domain + + if isinstance(o, Point): + if o in self: + return [o] + else: + return [] + + elif isinstance(o, (Segment2D, Ray2D)): + ellipse_equation = self.equation(x, y) + result = solve([ellipse_equation, Line( + o.points[0], o.points[1]).equation(x, y)], [x, y], + set=True)[1] + return list(ordered([Point(i) for i in result if i in o])) + + elif isinstance(o, Polygon): + return o.intersection(self) + + elif isinstance(o, (Ellipse, Line2D)): + if o == self: + return self + else: + ellipse_equation = self.equation(x, y) + return list(ordered([Point(i) for i in solve( + [ellipse_equation, o.equation(x, y)], [x, y], + set=True)[1]])) + elif isinstance(o, LinearEntity3D): + raise TypeError('Entity must be two dimensional, not three dimensional') + else: + raise TypeError('Intersection not handled for %s' % func_name(o)) + + def is_tangent(self, o): + """Is `o` tangent to the ellipse? + + Parameters + ========== + + o : GeometryEntity + An Ellipse, LinearEntity or Polygon + + Raises + ====== + + NotImplementedError + When the wrong type of argument is supplied. + + Returns + ======= + + is_tangent: boolean + True if o is tangent to the ellipse, False otherwise. + + See Also + ======== + + tangent_lines + + Examples + ======== + + >>> from sympy import Point, Ellipse, Line + >>> p0, p1, p2 = Point(0, 0), Point(3, 0), Point(3, 3) + >>> e1 = Ellipse(p0, 3, 2) + >>> l1 = Line(p1, p2) + >>> e1.is_tangent(l1) + True + + """ + if isinstance(o, Point2D): + return False + elif isinstance(o, Ellipse): + intersect = self.intersection(o) + if isinstance(intersect, Ellipse): + return True + elif intersect: + return all((self.tangent_lines(i)[0]).equals(o.tangent_lines(i)[0]) for i in intersect) + else: + return False + elif isinstance(o, Line2D): + hit = self.intersection(o) + if not hit: + return False + if len(hit) == 1: + return True + # might return None if it can't decide + return hit[0].equals(hit[1]) + elif isinstance(o, Ray2D): + intersect = self.intersection(o) + if len(intersect) == 1: + return intersect[0] != o.source and not self.encloses_point(o.source) + else: + return False + elif isinstance(o, (Segment2D, Polygon)): + all_tangents = False + segments = o.sides if isinstance(o, Polygon) else [o] + for segment in segments: + intersect = self.intersection(segment) + if len(intersect) == 1: + if not any(intersect[0] in i for i in segment.points) \ + and not any(self.encloses_point(i) for i in segment.points): + all_tangents = True + continue + else: + return False + else: + return all_tangents + return all_tangents + elif isinstance(o, (LinearEntity3D, Point3D)): + raise TypeError('Entity must be two dimensional, not three dimensional') + else: + raise TypeError('Is_tangent not handled for %s' % func_name(o)) + + @property + def major(self): + """Longer axis of the ellipse (if it can be determined) else hradius. + + Returns + ======= + + major : number or expression + + See Also + ======== + + hradius, vradius, minor + + Examples + ======== + + >>> from sympy import Point, Ellipse, Symbol + >>> p1 = Point(0, 0) + >>> e1 = Ellipse(p1, 3, 1) + >>> e1.major + 3 + + >>> a = Symbol('a') + >>> b = Symbol('b') + >>> Ellipse(p1, a, b).major + a + >>> Ellipse(p1, b, a).major + b + + >>> m = Symbol('m') + >>> M = m + 1 + >>> Ellipse(p1, m, M).major + m + 1 + + """ + ab = self.args[1:3] + if len(ab) == 1: + return ab[0] + a, b = ab + o = b - a < 0 + if o == True: + return a + elif o == False: + return b + return self.hradius + + @property + def minor(self): + """Shorter axis of the ellipse (if it can be determined) else vradius. + + Returns + ======= + + minor : number or expression + + See Also + ======== + + hradius, vradius, major + + Examples + ======== + + >>> from sympy import Point, Ellipse, Symbol + >>> p1 = Point(0, 0) + >>> e1 = Ellipse(p1, 3, 1) + >>> e1.minor + 1 + + >>> a = Symbol('a') + >>> b = Symbol('b') + >>> Ellipse(p1, a, b).minor + b + >>> Ellipse(p1, b, a).minor + a + + >>> m = Symbol('m') + >>> M = m + 1 + >>> Ellipse(p1, m, M).minor + m + + """ + ab = self.args[1:3] + if len(ab) == 1: + return ab[0] + a, b = ab + o = a - b < 0 + if o == True: + return a + elif o == False: + return b + return self.vradius + + def normal_lines(self, p, prec=None): + """Normal lines between `p` and the ellipse. + + Parameters + ========== + + p : Point + + Returns + ======= + + normal_lines : list with 1, 2 or 4 Lines + + Examples + ======== + + >>> from sympy import Point, Ellipse + >>> e = Ellipse((0, 0), 2, 3) + >>> c = e.center + >>> e.normal_lines(c + Point(1, 0)) + [Line2D(Point2D(0, 0), Point2D(1, 0))] + >>> e.normal_lines(c) + [Line2D(Point2D(0, 0), Point2D(0, 1)), Line2D(Point2D(0, 0), Point2D(1, 0))] + + Off-axis points require the solution of a quartic equation. This + often leads to very large expressions that may be of little practical + use. An approximate solution of `prec` digits can be obtained by + passing in the desired value: + + >>> e.normal_lines((3, 3), prec=2) + [Line2D(Point2D(-0.81, -2.7), Point2D(0.19, -1.2)), + Line2D(Point2D(1.5, -2.0), Point2D(2.5, -2.7))] + + Whereas the above solution has an operation count of 12, the exact + solution has an operation count of 2020. + """ + p = Point(p, dim=2) + + # XXX change True to something like self.angle == 0 if the arbitrarily + # rotated ellipse is introduced. + # https://github.com/sympy/sympy/issues/2815) + if True: + rv = [] + if p.x == self.center.x: + rv.append(Line(self.center, slope=oo)) + if p.y == self.center.y: + rv.append(Line(self.center, slope=0)) + if rv: + # at these special orientations of p either 1 or 2 normals + # exist and we are done + return rv + + # find the 4 normal points and construct lines through them with + # the corresponding slope + eq = self.equation(x, y) + dydx = idiff(eq, y, x) + norm = -1/dydx + slope = Line(p, (x, y)).slope + seq = slope - norm + + # TODO: Replace solve with solveset, when this line is tested + yis = solve(seq, y)[0] + xeq = eq.subs(y, yis).as_numer_denom()[0].expand() + if len(xeq.free_symbols) == 1: + try: + # this is so much faster, it's worth a try + xsol = Poly(xeq, x).real_roots() + except (DomainError, PolynomialError, NotImplementedError): + # TODO: Replace solve with solveset, when these lines are tested + xsol = _nsort(solve(xeq, x), separated=True)[0] + points = [Point(i, solve(eq.subs(x, i), y)[0]) for i in xsol] + else: + raise NotImplementedError( + 'intersections for the general ellipse are not supported') + slopes = [norm.subs(zip((x, y), pt.args)) for pt in points] + if prec is not None: + points = [pt.n(prec) for pt in points] + slopes = [i if _not_a_coeff(i) else i.n(prec) for i in slopes] + return [Line(pt, slope=s) for pt, s in zip(points, slopes)] + + @property + def periapsis(self): + """The periapsis of the ellipse. + + The shortest distance between the focus and the contour. + + Returns + ======= + + periapsis : number + + See Also + ======== + + apoapsis : Returns greatest distance between focus and contour + + Examples + ======== + + >>> from sympy import Point, Ellipse + >>> p1 = Point(0, 0) + >>> e1 = Ellipse(p1, 3, 1) + >>> e1.periapsis + 3 - 2*sqrt(2) + + """ + return self.major * (1 - self.eccentricity) + + @property + def semilatus_rectum(self): + """ + Calculates the semi-latus rectum of the Ellipse. + + Semi-latus rectum is defined as one half of the chord through a + focus parallel to the conic section directrix of a conic section. + + Returns + ======= + + semilatus_rectum : number + + See Also + ======== + + apoapsis : Returns greatest distance between focus and contour + + periapsis : The shortest distance between the focus and the contour + + Examples + ======== + + >>> from sympy import Point, Ellipse + >>> p1 = Point(0, 0) + >>> e1 = Ellipse(p1, 3, 1) + >>> e1.semilatus_rectum + 1/3 + + References + ========== + + .. [1] https://mathworld.wolfram.com/SemilatusRectum.html + .. [2] https://en.wikipedia.org/wiki/Ellipse#Semi-latus_rectum + + """ + return self.major * (1 - self.eccentricity ** 2) + + def auxiliary_circle(self): + """Returns a Circle whose diameter is the major axis of the ellipse. + + Examples + ======== + + >>> from sympy import Ellipse, Point, symbols + >>> c = Point(1, 2) + >>> Ellipse(c, 8, 7).auxiliary_circle() + Circle(Point2D(1, 2), 8) + >>> a, b = symbols('a b') + >>> Ellipse(c, a, b).auxiliary_circle() + Circle(Point2D(1, 2), Max(a, b)) + """ + return Circle(self.center, Max(self.hradius, self.vradius)) + + def director_circle(self): + """ + Returns a Circle consisting of all points where two perpendicular + tangent lines to the ellipse cross each other. + + Returns + ======= + + Circle + A director circle returned as a geometric object. + + Examples + ======== + + >>> from sympy import Ellipse, Point, symbols + >>> c = Point(3,8) + >>> Ellipse(c, 7, 9).director_circle() + Circle(Point2D(3, 8), sqrt(130)) + >>> a, b = symbols('a b') + >>> Ellipse(c, a, b).director_circle() + Circle(Point2D(3, 8), sqrt(a**2 + b**2)) + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Director_circle + + """ + return Circle(self.center, sqrt(self.hradius**2 + self.vradius**2)) + + def plot_interval(self, parameter='t'): + """The plot interval for the default geometric plot of the Ellipse. + + Parameters + ========== + + parameter : str, optional + Default value is 't'. + + Returns + ======= + + plot_interval : list + [parameter, lower_bound, upper_bound] + + Examples + ======== + + >>> from sympy import Point, Ellipse + >>> e1 = Ellipse(Point(0, 0), 3, 2) + >>> e1.plot_interval() + [t, -pi, pi] + + """ + t = _symbol(parameter, real=True) + return [t, -S.Pi, S.Pi] + + def random_point(self, seed=None): + """A random point on the ellipse. + + Returns + ======= + + point : Point + + Examples + ======== + + >>> from sympy import Point, Ellipse + >>> e1 = Ellipse(Point(0, 0), 3, 2) + >>> e1.random_point() # gives some random point + Point2D(...) + >>> p1 = e1.random_point(seed=0); p1.n(2) + Point2D(2.1, 1.4) + + Notes + ===== + + When creating a random point, one may simply replace the + parameter with a random number. When doing so, however, the + random number should be made a Rational or else the point + may not test as being in the ellipse: + + >>> from sympy.abc import t + >>> from sympy import Rational + >>> arb = e1.arbitrary_point(t); arb + Point2D(3*cos(t), 2*sin(t)) + >>> arb.subs(t, .1) in e1 + False + >>> arb.subs(t, Rational(.1)) in e1 + True + >>> arb.subs(t, Rational('.1')) in e1 + True + + See Also + ======== + sympy.geometry.point.Point + arbitrary_point : Returns parameterized point on ellipse + """ + t = _symbol('t', real=True) + x, y = self.arbitrary_point(t).args + # get a random value in [-1, 1) corresponding to cos(t) + # and confirm that it will test as being in the ellipse + if seed is not None: + rng = random.Random(seed) + else: + rng = random + # simplify this now or else the Float will turn s into a Float + r = Rational(rng.random()) + c = 2*r - 1 + s = sqrt(1 - c**2) + return Point(x.subs(cos(t), c), y.subs(sin(t), s)) + + def reflect(self, line): + """Override GeometryEntity.reflect since the radius + is not a GeometryEntity. + + Examples + ======== + + >>> from sympy import Circle, Line + >>> Circle((0, 1), 1).reflect(Line((0, 0), (1, 1))) + Circle(Point2D(1, 0), -1) + >>> from sympy import Ellipse, Line, Point + >>> Ellipse(Point(3, 4), 1, 3).reflect(Line(Point(0, -4), Point(5, 0))) + Traceback (most recent call last): + ... + NotImplementedError: + General Ellipse is not supported but the equation of the reflected + Ellipse is given by the zeros of: f(x, y) = (9*x/41 + 40*y/41 + + 37/41)**2 + (40*x/123 - 3*y/41 - 364/123)**2 - 1 + + Notes + ===== + + Until the general ellipse (with no axis parallel to the x-axis) is + supported a NotImplemented error is raised and the equation whose + zeros define the rotated ellipse is given. + + """ + + if line.slope in (0, oo): + c = self.center + c = c.reflect(line) + return self.func(c, -self.hradius, self.vradius) + else: + x, y = [uniquely_named_symbol( + name, (self, line), modify=lambda s: '_' + s, real=True) + for name in 'xy'] + expr = self.equation(x, y) + p = Point(x, y).reflect(line) + result = expr.subs(zip((x, y), p.args + ), simultaneous=True) + raise NotImplementedError(filldedent( + 'General Ellipse is not supported but the equation ' + 'of the reflected Ellipse is given by the zeros of: ' + + "f(%s, %s) = %s" % (str(x), str(y), str(result)))) + + def rotate(self, angle=0, pt=None): + """Rotate ``angle`` radians counterclockwise about Point ``pt``. + + Note: since the general ellipse is not supported, only rotations that + are integer multiples of pi/2 are allowed. + + Examples + ======== + + >>> from sympy import Ellipse, pi + >>> Ellipse((1, 0), 2, 1).rotate(pi/2) + Ellipse(Point2D(0, 1), 1, 2) + >>> Ellipse((1, 0), 2, 1).rotate(pi) + Ellipse(Point2D(-1, 0), 2, 1) + """ + if self.hradius == self.vradius: + return self.func(self.center.rotate(angle, pt), self.hradius) + if (angle/S.Pi).is_integer: + return super().rotate(angle, pt) + if (2*angle/S.Pi).is_integer: + return self.func(self.center.rotate(angle, pt), self.vradius, self.hradius) + # XXX see https://github.com/sympy/sympy/issues/2815 for general ellipes + raise NotImplementedError('Only rotations of pi/2 are currently supported for Ellipse.') + + def scale(self, x=1, y=1, pt=None): + """Override GeometryEntity.scale since it is the major and minor + axes which must be scaled and they are not GeometryEntities. + + Examples + ======== + + >>> from sympy import Ellipse + >>> Ellipse((0, 0), 2, 1).scale(2, 4) + Circle(Point2D(0, 0), 4) + >>> Ellipse((0, 0), 2, 1).scale(2) + Ellipse(Point2D(0, 0), 4, 1) + """ + c = self.center + if pt: + pt = Point(pt, dim=2) + return self.translate(*(-pt).args).scale(x, y).translate(*pt.args) + h = self.hradius + v = self.vradius + return self.func(c.scale(x, y), hradius=h*x, vradius=v*y) + + def tangent_lines(self, p): + """Tangent lines between `p` and the ellipse. + + If `p` is on the ellipse, returns the tangent line through point `p`. + Otherwise, returns the tangent line(s) from `p` to the ellipse, or + None if no tangent line is possible (e.g., `p` inside ellipse). + + Parameters + ========== + + p : Point + + Returns + ======= + + tangent_lines : list with 1 or 2 Lines + + Raises + ====== + + NotImplementedError + Can only find tangent lines for a point, `p`, on the ellipse. + + See Also + ======== + + sympy.geometry.point.Point, sympy.geometry.line.Line + + Examples + ======== + + >>> from sympy import Point, Ellipse + >>> e1 = Ellipse(Point(0, 0), 3, 2) + >>> e1.tangent_lines(Point(3, 0)) + [Line2D(Point2D(3, 0), Point2D(3, -12))] + + """ + p = Point(p, dim=2) + if self.encloses_point(p): + return [] + + if p in self: + delta = self.center - p + rise = (self.vradius**2)*delta.x + run = -(self.hradius**2)*delta.y + p2 = Point(simplify(p.x + run), + simplify(p.y + rise)) + return [Line(p, p2)] + else: + if len(self.foci) == 2: + f1, f2 = self.foci + maj = self.hradius + test = (2*maj - + Point.distance(f1, p) - + Point.distance(f2, p)) + else: + test = self.radius - Point.distance(self.center, p) + if test.is_number and test.is_positive: + return [] + # else p is outside the ellipse or we can't tell. In case of the + # latter, the solutions returned will only be valid if + # the point is not inside the ellipse; if it is, nan will result. + eq = self.equation(x, y) + dydx = idiff(eq, y, x) + slope = Line(p, Point(x, y)).slope + + # TODO: Replace solve with solveset, when this line is tested + tangent_points = solve([slope - dydx, eq], [x, y]) + + # handle horizontal and vertical tangent lines + if len(tangent_points) == 1: + if tangent_points[0][ + 0] == p.x or tangent_points[0][1] == p.y: + return [Line(p, p + Point(1, 0)), Line(p, p + Point(0, 1))] + else: + return [Line(p, p + Point(0, 1)), Line(p, tangent_points[0])] + + # others + return [Line(p, tangent_points[0]), Line(p, tangent_points[1])] + + @property + def vradius(self): + """The vertical radius of the ellipse. + + Returns + ======= + + vradius : number + + See Also + ======== + + hradius, major, minor + + Examples + ======== + + >>> from sympy import Point, Ellipse + >>> p1 = Point(0, 0) + >>> e1 = Ellipse(p1, 3, 1) + >>> e1.vradius + 1 + + """ + return self.args[2] + + + def second_moment_of_area(self, point=None): + """Returns the second moment and product moment area of an ellipse. + + Parameters + ========== + + point : Point, two-tuple of sympifiable objects, or None(default=None) + point is the point about which second moment of area is to be found. + If "point=None" it will be calculated about the axis passing through the + centroid of the ellipse. + + Returns + ======= + + I_xx, I_yy, I_xy : number or SymPy expression + I_xx, I_yy are second moment of area of an ellise. + I_xy is product moment of area of an ellipse. + + Examples + ======== + + >>> from sympy import Point, Ellipse + >>> p1 = Point(0, 0) + >>> e1 = Ellipse(p1, 3, 1) + >>> e1.second_moment_of_area() + (3*pi/4, 27*pi/4, 0) + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/List_of_second_moments_of_area + + """ + + I_xx = (S.Pi*(self.hradius)*(self.vradius**3))/4 + I_yy = (S.Pi*(self.hradius**3)*(self.vradius))/4 + I_xy = 0 + + if point is None: + return I_xx, I_yy, I_xy + + # parallel axis theorem + I_xx = I_xx + self.area*((point[1] - self.center.y)**2) + I_yy = I_yy + self.area*((point[0] - self.center.x)**2) + I_xy = I_xy + self.area*(point[0] - self.center.x)*(point[1] - self.center.y) + + return I_xx, I_yy, I_xy + + + def polar_second_moment_of_area(self): + """Returns the polar second moment of area of an Ellipse + + It is a constituent of the second moment of area, linked through + the perpendicular axis theorem. While the planar second moment of + area describes an object's resistance to deflection (bending) when + subjected to a force applied to a plane parallel to the central + axis, the polar second moment of area describes an object's + resistance to deflection when subjected to a moment applied in a + plane perpendicular to the object's central axis (i.e. parallel to + the cross-section) + + Examples + ======== + + >>> from sympy import symbols, Circle, Ellipse + >>> c = Circle((5, 5), 4) + >>> c.polar_second_moment_of_area() + 128*pi + >>> a, b = symbols('a, b') + >>> e = Ellipse((0, 0), a, b) + >>> e.polar_second_moment_of_area() + pi*a**3*b/4 + pi*a*b**3/4 + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Polar_moment_of_inertia + + """ + second_moment = self.second_moment_of_area() + return second_moment[0] + second_moment[1] + + + def section_modulus(self, point=None): + """Returns a tuple with the section modulus of an ellipse + + Section modulus is a geometric property of an ellipse defined as the + ratio of second moment of area to the distance of the extreme end of + the ellipse from the centroidal axis. + + Parameters + ========== + + point : Point, two-tuple of sympifyable objects, or None(default=None) + point is the point at which section modulus is to be found. + If "point=None" section modulus will be calculated for the + point farthest from the centroidal axis of the ellipse. + + Returns + ======= + + S_x, S_y: numbers or SymPy expressions + S_x is the section modulus with respect to the x-axis + S_y is the section modulus with respect to the y-axis + A negative sign indicates that the section modulus is + determined for a point below the centroidal axis. + + Examples + ======== + + >>> from sympy import Symbol, Ellipse, Circle, Point2D + >>> d = Symbol('d', positive=True) + >>> c = Circle((0, 0), d/2) + >>> c.section_modulus() + (pi*d**3/32, pi*d**3/32) + >>> e = Ellipse(Point2D(0, 0), 2, 4) + >>> e.section_modulus() + (8*pi, 4*pi) + >>> e.section_modulus((2, 2)) + (16*pi, 4*pi) + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Section_modulus + + """ + x_c, y_c = self.center + if point is None: + # taking x and y as maximum distances from centroid + x_min, y_min, x_max, y_max = self.bounds + y = max(y_c - y_min, y_max - y_c) + x = max(x_c - x_min, x_max - x_c) + else: + # taking x and y as distances of the given point from the center + point = Point2D(point) + y = point.y - y_c + x = point.x - x_c + + second_moment = self.second_moment_of_area() + S_x = second_moment[0]/y + S_y = second_moment[1]/x + + return S_x, S_y + + +class Circle(Ellipse): + """A circle in space. + + Constructed simply from a center and a radius, from three + non-collinear points, or the equation of a circle. + + Parameters + ========== + + center : Point + radius : number or SymPy expression + points : sequence of three Points + equation : equation of a circle + + Attributes + ========== + + radius (synonymous with hradius, vradius, major and minor) + circumference + equation + + Raises + ====== + + GeometryError + When the given equation is not that of a circle. + When trying to construct circle from incorrect parameters. + + See Also + ======== + + Ellipse, sympy.geometry.point.Point + + Examples + ======== + + >>> from sympy import Point, Circle, Eq + >>> from sympy.abc import x, y, a, b + + A circle constructed from a center and radius: + + >>> c1 = Circle(Point(0, 0), 5) + >>> c1.hradius, c1.vradius, c1.radius + (5, 5, 5) + + A circle constructed from three points: + + >>> c2 = Circle(Point(0, 0), Point(1, 1), Point(1, 0)) + >>> c2.hradius, c2.vradius, c2.radius, c2.center + (sqrt(2)/2, sqrt(2)/2, sqrt(2)/2, Point2D(1/2, 1/2)) + + A circle can be constructed from an equation in the form + `a*x**2 + by**2 + gx + hy + c = 0`, too: + + >>> Circle(x**2 + y**2 - 25) + Circle(Point2D(0, 0), 5) + + If the variables corresponding to x and y are named something + else, their name or symbol can be supplied: + + >>> Circle(Eq(a**2 + b**2, 25), x='a', y=b) + Circle(Point2D(0, 0), 5) + """ + + def __new__(cls, *args, **kwargs): + evaluate = kwargs.get('evaluate', global_parameters.evaluate) + if len(args) == 1 and isinstance(args[0], (Expr, Eq)): + x = kwargs.get('x', 'x') + y = kwargs.get('y', 'y') + equation = args[0].expand() + if isinstance(equation, Eq): + equation = equation.lhs - equation.rhs + x = find(x, equation) + y = find(y, equation) + + try: + a, b, c, d, e = linear_coeffs(equation, x**2, y**2, x, y) + except ValueError: + raise GeometryError("The given equation is not that of a circle.") + + if S.Zero in (a, b) or a != b: + raise GeometryError("The given equation is not that of a circle.") + + center_x = -c/a/2 + center_y = -d/b/2 + r2 = (center_x**2) + (center_y**2) - e/a + + return Circle((center_x, center_y), sqrt(r2), evaluate=evaluate) + + else: + c, r = None, None + if len(args) == 3: + args = [Point(a, dim=2, evaluate=evaluate) for a in args] + t = Triangle(*args) + if not isinstance(t, Triangle): + return t + c = t.circumcenter + r = t.circumradius + elif len(args) == 2: + # Assume (center, radius) pair + c = Point(args[0], dim=2, evaluate=evaluate) + r = args[1] + # this will prohibit imaginary radius + try: + r = Point(r, 0, evaluate=evaluate).x + except ValueError: + raise GeometryError("Circle with imaginary radius is not permitted") + + if not (c is None or r is None): + if r == 0: + return c + return GeometryEntity.__new__(cls, c, r, **kwargs) + + raise GeometryError("Circle.__new__ received unknown arguments") + + def _eval_evalf(self, prec=15, **options): + pt, r = self.args + dps = prec_to_dps(prec) + pt = pt.evalf(n=dps, **options) + r = r.evalf(n=dps, **options) + return self.func(pt, r, evaluate=False) + + @property + def circumference(self): + """The circumference of the circle. + + Returns + ======= + + circumference : number or SymPy expression + + Examples + ======== + + >>> from sympy import Point, Circle + >>> c1 = Circle(Point(3, 4), 6) + >>> c1.circumference + 12*pi + + """ + return 2 * S.Pi * self.radius + + def equation(self, x='x', y='y'): + """The equation of the circle. + + Parameters + ========== + + x : str or Symbol, optional + Default value is 'x'. + y : str or Symbol, optional + Default value is 'y'. + + Returns + ======= + + equation : SymPy expression + + Examples + ======== + + >>> from sympy import Point, Circle + >>> c1 = Circle(Point(0, 0), 5) + >>> c1.equation() + x**2 + y**2 - 25 + + """ + x = _symbol(x, real=True) + y = _symbol(y, real=True) + t1 = (x - self.center.x)**2 + t2 = (y - self.center.y)**2 + return t1 + t2 - self.major**2 + + def intersection(self, o): + """The intersection of this circle with another geometrical entity. + + Parameters + ========== + + o : GeometryEntity + + Returns + ======= + + intersection : list of GeometryEntities + + Examples + ======== + + >>> from sympy import Point, Circle, Line, Ray + >>> p1, p2, p3 = Point(0, 0), Point(5, 5), Point(6, 0) + >>> p4 = Point(5, 0) + >>> c1 = Circle(p1, 5) + >>> c1.intersection(p2) + [] + >>> c1.intersection(p4) + [Point2D(5, 0)] + >>> c1.intersection(Ray(p1, p2)) + [Point2D(5*sqrt(2)/2, 5*sqrt(2)/2)] + >>> c1.intersection(Line(p2, p3)) + [] + + """ + return Ellipse.intersection(self, o) + + @property + def radius(self): + """The radius of the circle. + + Returns + ======= + + radius : number or SymPy expression + + See Also + ======== + + Ellipse.major, Ellipse.minor, Ellipse.hradius, Ellipse.vradius + + Examples + ======== + + >>> from sympy import Point, Circle + >>> c1 = Circle(Point(3, 4), 6) + >>> c1.radius + 6 + + """ + return self.args[1] + + def reflect(self, line): + """Override GeometryEntity.reflect since the radius + is not a GeometryEntity. + + Examples + ======== + + >>> from sympy import Circle, Line + >>> Circle((0, 1), 1).reflect(Line((0, 0), (1, 1))) + Circle(Point2D(1, 0), -1) + """ + c = self.center + c = c.reflect(line) + return self.func(c, -self.radius) + + def scale(self, x=1, y=1, pt=None): + """Override GeometryEntity.scale since the radius + is not a GeometryEntity. + + Examples + ======== + + >>> from sympy import Circle + >>> Circle((0, 0), 1).scale(2, 2) + Circle(Point2D(0, 0), 2) + >>> Circle((0, 0), 1).scale(2, 4) + Ellipse(Point2D(0, 0), 2, 4) + """ + c = self.center + if pt: + pt = Point(pt, dim=2) + return self.translate(*(-pt).args).scale(x, y).translate(*pt.args) + c = c.scale(x, y) + x, y = [abs(i) for i in (x, y)] + if x == y: + return self.func(c, x*self.radius) + h = v = self.radius + return Ellipse(c, hradius=h*x, vradius=v*y) + + @property + def vradius(self): + """ + This Ellipse property is an alias for the Circle's radius. + + Whereas hradius, major and minor can use Ellipse's conventions, + the vradius does not exist for a circle. It is always a positive + value in order that the Circle, like Polygons, will have an + area that can be positive or negative as determined by the sign + of the hradius. + + Examples + ======== + + >>> from sympy import Point, Circle + >>> c1 = Circle(Point(3, 4), 6) + >>> c1.vradius + 6 + """ + return abs(self.radius) + + +from .polygon import Polygon, Triangle diff --git a/shared/package-files/30/30ce631cb1cccd20570018162c6ffef31bad378ef5b2de2d982c96e65eb62ef6/blob b/shared/package-files/30/30ce631cb1cccd20570018162c6ffef31bad378ef5b2de2d982c96e65eb62ef6/blob new file mode 100644 index 0000000000000000000000000000000000000000..68dd9b0dd03046664ef51c0a8c05c00cd269449c --- /dev/null +++ b/shared/package-files/30/30ce631cb1cccd20570018162c6ffef31bad378ef5b2de2d982c96e65eb62ef6/blob @@ -0,0 +1,308 @@ +# choosedir.tcl -- +# +# Choose directory dialog implementation for Unix/Mac. +# +# Copyright (c) 1998-2000 by Scriptics Corporation. +# All rights reserved. + +# Make sure the tk::dialog namespace, in which all dialogs should live, exists +namespace eval ::tk::dialog {} +namespace eval ::tk::dialog::file {} + +# Make the chooseDir namespace inside the dialog namespace +namespace eval ::tk::dialog::file::chooseDir { + namespace import -force ::tk::msgcat::* +} + +# ::tk::dialog::file::chooseDir:: -- +# +# Implements the TK directory selection dialog. +# +# Arguments: +# args Options parsed by the procedure. +# +proc ::tk::dialog::file::chooseDir:: {args} { + variable ::tk::Priv + set dataName __tk_choosedir + upvar ::tk::dialog::file::$dataName data + Config $dataName $args + + if {$data(-parent) eq "."} { + set w .$dataName + } else { + set w $data(-parent).$dataName + } + + # (re)create the dialog box if necessary + # + if {![winfo exists $w]} { + ::tk::dialog::file::Create $w TkChooseDir + } elseif {[winfo class $w] ne "TkChooseDir"} { + destroy $w + ::tk::dialog::file::Create $w TkChooseDir + } else { + set data(dirMenuBtn) $w.contents.f1.menu + set data(dirMenu) $w.contents.f1.menu.menu + set data(upBtn) $w.contents.f1.up + set data(icons) $w.contents.icons + set data(ent) $w.contents.f2.ent + set data(okBtn) $w.contents.f2.ok + set data(cancelBtn) $w.contents.f2.cancel + set data(hiddenBtn) $w.contents.f2.hidden + } + if {$::tk::dialog::file::showHiddenBtn} { + $data(hiddenBtn) configure -state normal + grid $data(hiddenBtn) + } else { + $data(hiddenBtn) configure -state disabled + grid remove $data(hiddenBtn) + } + + # When using -mustexist, manage the OK button state for validity + $data(okBtn) configure -state normal + if {$data(-mustexist)} { + $data(ent) configure -validate key \ + -validatecommand [list ::tk::dialog::file::chooseDir::IsOK? $w %P] + } else { + $data(ent) configure -validate none + } + + # Dialog boxes should be transient with respect to their parent, + # so that they will always stay on top of their parent window. However, + # some window managers will create the window as withdrawn if the parent + # window is withdrawn or iconified. Combined with the grab we put on the + # window, this can hang the entire application. Therefore we only make + # the dialog transient if the parent is viewable. + + if {[winfo viewable [winfo toplevel $data(-parent)]] } { + wm transient $w $data(-parent) + } + + trace add variable data(selectPath) write \ + [list ::tk::dialog::file::SetPath $w] + $data(dirMenuBtn) configure \ + -textvariable ::tk::dialog::file::${dataName}(selectPath) + + set data(filter) "*" + set data(previousEntryText) "" + ::tk::dialog::file::UpdateWhenIdle $w + + # Withdraw the window, then update all the geometry information + # so we know how big it wants to be, then center the window in the + # display (Motif style) and de-iconify it. + + ::tk::PlaceWindow $w widget $data(-parent) + wm title $w $data(-title) + + # Set a grab and claim the focus too. + + ::tk::SetFocusGrab $w $data(ent) + $data(ent) delete 0 end + $data(ent) insert 0 $data(selectPath) + $data(ent) selection range 0 end + $data(ent) icursor end + + # Wait for the user to respond, then restore the focus and + # return the index of the selected button. Restore the focus + # before deleting the window, since otherwise the window manager + # may take the focus away so we can't redirect it. Finally, + # restore any grab that was in effect. + + vwait ::tk::Priv(selectFilePath) + + ::tk::RestoreFocusGrab $w $data(ent) withdraw + + # Cleanup traces on selectPath variable + # + + foreach trace [trace info variable data(selectPath)] { + trace remove variable data(selectPath) [lindex $trace 0] [lindex $trace 1] + } + $data(dirMenuBtn) configure -textvariable {} + + # Return value to user + # + + return $Priv(selectFilePath) +} + +# ::tk::dialog::file::chooseDir::Config -- +# +# Configures the Tk choosedir dialog according to the argument list +# +proc ::tk::dialog::file::chooseDir::Config {dataName argList} { + upvar ::tk::dialog::file::$dataName data + + # 0: Delete all variable that were set on data(selectPath) the + # last time the file dialog is used. The traces may cause troubles + # if the dialog is now used with a different -parent option. + # + foreach trace [trace info variable data(selectPath)] { + trace remove variable data(selectPath) [lindex $trace 0] [lindex $trace 1] + } + + # 1: the configuration specs + # + set specs { + {-mustexist "" "" 0} + {-initialdir "" "" ""} + {-parent "" "" "."} + {-title "" "" ""} + } + + # 2: default values depending on the type of the dialog + # + if {![info exists data(selectPath)]} { + # first time the dialog has been popped up + set data(selectPath) [pwd] + } + + # 3: parse the arguments + # + tclParseConfigSpec ::tk::dialog::file::$dataName $specs "" $argList + + if {$data(-title) eq ""} { + set data(-title) "[mc "Choose Directory"]" + } + + # Stub out the -multiple value for the dialog; it doesn't make sense for + # choose directory dialogs, but we have to have something there because we + # share so much code with the file dialogs. + set data(-multiple) 0 + + # 4: set the default directory and selection according to the -initial + # settings + # + if {$data(-initialdir) ne ""} { + # Ensure that initialdir is an absolute path name. + if {[file isdirectory $data(-initialdir)]} { + set old [pwd] + cd $data(-initialdir) + set data(selectPath) [pwd] + cd $old + } else { + set data(selectPath) [pwd] + } + } + + if {![winfo exists $data(-parent)]} { + return -code error -errorcode [list TK LOOKUP WINDOW $data(-parent)] \ + "bad window path name \"$data(-parent)\"" + } +} + +# Gets called when user presses Return in the "Selection" entry or presses OK. +# +proc ::tk::dialog::file::chooseDir::OkCmd {w} { + upvar ::tk::dialog::file::[winfo name $w] data + + # This is the brains behind selecting non-existant directories. Here's + # the flowchart: + # 1. If the icon list has a selection, join it with the current dir, + # and return that value. + # 1a. If the icon list does not have a selection ... + # 2. If the entry is empty, do nothing. + # 3. If the entry contains an invalid directory, then... + # 3a. If the value is the same as last time through here, end dialog. + # 3b. If the value is different than last time, save it and return. + # 4. If entry contains a valid directory, then... + # 4a. If the value is the same as the current directory, end dialog. + # 4b. If the value is different from the current directory, change to + # that directory. + + set selection [$data(icons) selection get] + if {[llength $selection] != 0} { + set iconText [$data(icons) get [lindex $selection 0]] + set iconText [file join $data(selectPath) $iconText] + Done $w $iconText + } else { + set text [$data(ent) get] + if {$text eq ""} { + return + } + set text [file join {*}[file split [string trim $text]]] + if {![file exists $text] || ![file isdirectory $text]} { + # Entry contains an invalid directory. If it's the same as the + # last time they came through here, reset the saved value and end + # the dialog. Otherwise, save the value (so we can do this test + # next time). + if {$text eq $data(previousEntryText)} { + set data(previousEntryText) "" + Done $w $text + } else { + set data(previousEntryText) $text + } + } else { + # Entry contains a valid directory. If it is the same as the + # current directory, end the dialog. Otherwise, change to that + # directory. + if {$text eq $data(selectPath)} { + Done $w $text + } else { + set data(selectPath) $text + } + } + } + return +} + +# Change state of OK button to match -mustexist correctness of entry +# +proc ::tk::dialog::file::chooseDir::IsOK? {w text} { + upvar ::tk::dialog::file::[winfo name $w] data + + set ok [file isdirectory $text] + $data(okBtn) configure -state [expr {$ok ? "normal" : "disabled"}] + + # always return 1 + return 1 +} + +proc ::tk::dialog::file::chooseDir::DblClick {w} { + upvar ::tk::dialog::file::[winfo name $w] data + set selection [$data(icons) selection get] + if {[llength $selection] != 0} { + set filenameFragment [$data(icons) get [lindex $selection 0]] + set file $data(selectPath) + if {[file isdirectory $file]} { + ::tk::dialog::file::ListInvoke $w [list $filenameFragment] + return + } + } +} + +# Gets called when user browses the IconList widget (dragging mouse, arrow +# keys, etc) +# +proc ::tk::dialog::file::chooseDir::ListBrowse {w text} { + upvar ::tk::dialog::file::[winfo name $w] data + + if {$text eq ""} { + return + } + + set file [::tk::dialog::file::JoinFile $data(selectPath) $text] + $data(ent) delete 0 end + $data(ent) insert 0 $file +} + +# ::tk::dialog::file::chooseDir::Done -- +# +# Gets called when user has input a valid filename. Pops up a +# dialog box to confirm selection when necessary. Sets the +# Priv(selectFilePath) variable, which will break the "vwait" +# loop in tk_chooseDirectory and return the selected filename to the +# script that calls tk_getOpenFile or tk_getSaveFile +# +proc ::tk::dialog::file::chooseDir::Done {w {selectFilePath ""}} { + upvar ::tk::dialog::file::[winfo name $w] data + variable ::tk::Priv + + if {$selectFilePath eq ""} { + set selectFilePath $data(selectPath) + } + if {$data(-mustexist) && ![file isdirectory $selectFilePath]} { + return + } + set Priv(selectFilePath) $selectFilePath +} diff --git a/shared/package-files/30/30cf3bd2a442ff2738864cf1ef154f68f9b5d84ad1f2ca858034c72d61dc457d/blob b/shared/package-files/30/30cf3bd2a442ff2738864cf1ef154f68f9b5d84ad1f2ca858034c72d61dc457d/blob new file mode 100644 index 0000000000000000000000000000000000000000..9c67e7cae492de85df5ab656b3f0c0e1f92a7b96 --- /dev/null +++ b/shared/package-files/30/30cf3bd2a442ff2738864cf1ef154f68f9b5d84ad1f2ca858034c72d61dc457d/blob @@ -0,0 +1,97 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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. + +#pragma once + +#include +#include +#include + +#include "arrow/util/mutex.h" +#include "arrow/util/secure_string.h" + +#include "parquet/exception.h" +#include "parquet/platform.h" + +namespace parquet::encryption { + +/// This class wraps the key access token of a KMS server. If your token changes over +/// time, you should keep the reference to the KeyAccessToken object and call Refresh() +/// method every time you have a new token. +class PARQUET_EXPORT KeyAccessToken { + public: + KeyAccessToken() = default; + + explicit KeyAccessToken(const std::string value) : value_(value) {} + + void Refresh(const std::string& new_value) { + auto lock = mutex_.Lock(); + value_ = new_value; + } + + const std::string& value() const { + auto lock = mutex_.Lock(); + return value_; + } + + private: + std::string value_; + mutable ::arrow::util::Mutex mutex_; +}; + +struct PARQUET_EXPORT KmsConnectionConfig { + std::string kms_instance_id; + std::string kms_instance_url; + /// If the access token is changed in the future, you should keep a reference to + /// this object and call Refresh() on it whenever there is a new access token. + std::shared_ptr refreshable_key_access_token; + std::unordered_map custom_kms_conf; + + KmsConnectionConfig(); + + const std::string& key_access_token() const { + if (refreshable_key_access_token == NULLPTR || + refreshable_key_access_token->value().empty()) { + throw ParquetException("key access token is not set!"); + } + return refreshable_key_access_token->value(); + } + + void SetDefaultIfEmpty(); +}; + +class PARQUET_EXPORT KmsClient { + public: + static constexpr const char kKmsInstanceIdDefault[] = "DEFAULT"; + static constexpr const char kKmsInstanceUrlDefault[] = "DEFAULT"; + static constexpr const char kKeyAccessTokenDefault[] = "DEFAULT"; + + /// \brief Wraps a key. + /// + /// Encrypts it with the master key, encodes the result + /// and potentially adds a KMS-specific metadata. + virtual std::string WrapKey(const ::arrow::util::SecureString& key_bytes, + const std::string& master_key_identifier) = 0; + + /// \brief Decrypts (unwraps) a key with the master key. + virtual ::arrow::util::SecureString UnwrapKey( + const std::string& wrapped_key, const std::string& master_key_identifier) = 0; + + virtual ~KmsClient() {} +}; + +} // namespace parquet::encryption diff --git a/shared/package-files/30/30d02dcd366f8bf99a56f9ce87a7c53249e0d4fe5ef87edeb4d73f2b09a0250d/blob b/shared/package-files/30/30d02dcd366f8bf99a56f9ce87a7c53249e0d4fe5ef87edeb4d73f2b09a0250d/blob new file mode 100644 index 0000000000000000000000000000000000000000..09a41c603cd966d6ddac40b5688cc63fad87899d --- /dev/null +++ b/shared/package-files/30/30d02dcd366f8bf99a56f9ce87a7c53249e0d4fe5ef87edeb4d73f2b09a0250d/blob @@ -0,0 +1,28 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API _cast_Int { + using schema = at::Tensor (const at::Tensor &, bool); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_cast_Int") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_cast_Int(Tensor self, bool non_blocking=False) -> Tensor") + static at::Tensor call(const at::Tensor & self, bool non_blocking); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, bool non_blocking); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/30/30d61cdc56104406525c6f876edaed5f4e51c9c36e58de309e20644f758a357c/blob b/shared/package-files/30/30d61cdc56104406525c6f876edaed5f4e51c9c36e58de309e20644f758a357c/blob new file mode 100644 index 0000000000000000000000000000000000000000..94cd5b7588adbf37f7465c8a7867df5121f453ea --- /dev/null +++ b/shared/package-files/30/30d61cdc56104406525c6f876edaed5f4e51c9c36e58de309e20644f758a357c/blob @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor & logical_xor_out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & logical_xor_outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); + +} // namespace cpu +} // namespace at diff --git a/shared/package-files/30/30d79030b037a0150233c4d2c8d6c143fb96d270dcd4611961d35d53078f026e/blob b/shared/package-files/30/30d79030b037a0150233c4d2c8d6c143fb96d270dcd4611961d35d53078f026e/blob new file mode 100644 index 0000000000000000000000000000000000000000..46d6300649d3b4658a7263cad04354988b4da312 --- /dev/null +++ b/shared/package-files/30/30d79030b037a0150233c4d2c8d6c143fb96d270dcd4611961d35d53078f026e/blob @@ -0,0 +1,81 @@ +import networkx as nx + + +class BaseTestAttributeMixing: + @classmethod + def setup_class(cls): + G = nx.Graph() + G.add_nodes_from([0, 1], fish="one") + G.add_nodes_from([2, 3], fish="two") + G.add_nodes_from([4], fish="red") + G.add_nodes_from([5], fish="blue") + G.add_edges_from([(0, 1), (2, 3), (0, 4), (2, 5)]) + cls.G = G + + D = nx.DiGraph() + D.add_nodes_from([0, 1], fish="one") + D.add_nodes_from([2, 3], fish="two") + D.add_nodes_from([4], fish="red") + D.add_nodes_from([5], fish="blue") + D.add_edges_from([(0, 1), (2, 3), (0, 4), (2, 5)]) + cls.D = D + + M = nx.MultiGraph() + M.add_nodes_from([0, 1], fish="one") + M.add_nodes_from([2, 3], fish="two") + M.add_nodes_from([4], fish="red") + M.add_nodes_from([5], fish="blue") + M.add_edges_from([(0, 1), (0, 1), (2, 3)]) + cls.M = M + + S = nx.Graph() + S.add_nodes_from([0, 1], fish="one") + S.add_nodes_from([2, 3], fish="two") + S.add_nodes_from([4], fish="red") + S.add_nodes_from([5], fish="blue") + S.add_edge(0, 0) + S.add_edge(2, 2) + cls.S = S + + N = nx.Graph() + N.add_nodes_from([0, 1], margin=-2) + N.add_nodes_from([2, 3], margin=-2) + N.add_nodes_from([4], margin=-3) + N.add_nodes_from([5], margin=-4) + N.add_edges_from([(0, 1), (2, 3), (0, 4), (2, 5)]) + cls.N = N + + F = nx.Graph() + F.add_edges_from([(0, 3), (1, 3), (2, 3)], weight=0.5) + F.add_edge(0, 2, weight=1) + nx.set_node_attributes(F, dict(F.degree(weight="weight")), "margin") + cls.F = F + + K = nx.Graph() + K.add_nodes_from([1, 2], margin=-1) + K.add_nodes_from([3], margin=1) + K.add_nodes_from([4], margin=2) + K.add_edges_from([(3, 4), (1, 2), (1, 3)]) + cls.K = K + + +class BaseTestDegreeMixing: + @classmethod + def setup_class(cls): + cls.P4 = nx.path_graph(4) + cls.D = nx.DiGraph() + cls.D.add_edges_from([(0, 2), (0, 3), (1, 3), (2, 3)]) + cls.D2 = nx.DiGraph() + cls.D2.add_edges_from([(0, 3), (1, 0), (1, 2), (2, 4), (4, 1), (4, 3), (4, 2)]) + cls.M = nx.MultiGraph() + nx.add_path(cls.M, range(4)) + cls.M.add_edge(0, 1) + cls.S = nx.Graph() + cls.S.add_edges_from([(0, 0), (1, 1)]) + cls.W = nx.Graph() + cls.W.add_edges_from([(0, 3), (1, 3), (2, 3)], weight=0.5) + cls.W.add_edge(0, 2, weight=1) + S1 = nx.star_graph(4) + S2 = nx.star_graph(4) + cls.DS = nx.disjoint_union(S1, S2) + cls.DS.add_edge(4, 5) diff --git a/shared/package-files/30/30d9f0f609de40555ebd236362b77eccf98559c5bfeb8361c16500015bc720fe/blob b/shared/package-files/30/30d9f0f609de40555ebd236362b77eccf98559c5bfeb8361c16500015bc720fe/blob new file mode 100644 index 0000000000000000000000000000000000000000..20aa6e98c30c69ec0a4a49c77f72bf736683803b --- /dev/null +++ b/shared/package-files/30/30d9f0f609de40555ebd236362b77eccf98559c5bfeb8361c16500015bc720fe/blob @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor leaky_relu(const at::Tensor & self, const at::Scalar & negative_slope=0.01); +TORCH_API at::Tensor & leaky_relu_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & negative_slope=0.01); +TORCH_API at::Tensor & leaky_relu_outf(const at::Tensor & self, const at::Scalar & negative_slope, at::Tensor & out); +TORCH_API at::Tensor & leaky_relu_(at::Tensor & self, const at::Scalar & negative_slope=0.01); + +} // namespace cpu +} // namespace at diff --git a/shared/package-files/30/30da15f353c2c49be593dfda1bcee35295a41a19f4dd608293448f1b9e274687/blob b/shared/package-files/30/30da15f353c2c49be593dfda1bcee35295a41a19f4dd608293448f1b9e274687/blob new file mode 100644 index 0000000000000000000000000000000000000000..566fd2ee21728ab935f1ae7332aa590f8cf01d24 --- /dev/null +++ b/shared/package-files/30/30da15f353c2c49be593dfda1bcee35295a41a19f4dd608293448f1b9e274687/blob @@ -0,0 +1,1129 @@ +"""Module for compiling codegen output, and wrap the binary for use in +python. + +.. note:: To use the autowrap module it must first be imported + + >>> from sympy.utilities.autowrap import autowrap + +This module provides a common interface for different external backends, such +as f2py, fwrap, Cython, SWIG(?) etc. (Currently only f2py and Cython are +implemented) The goal is to provide access to compiled binaries of acceptable +performance with a one-button user interface, e.g., + + >>> from sympy.abc import x,y + >>> expr = (x - y)**25 + >>> flat = expr.expand() + >>> binary_callable = autowrap(flat) + >>> binary_callable(2, 3) + -1.0 + +Although a SymPy user might primarily be interested in working with +mathematical expressions and not in the details of wrapping tools +needed to evaluate such expressions efficiently in numerical form, +the user cannot do so without some understanding of the +limits in the target language. For example, the expanded expression +contains large coefficients which result in loss of precision when +computing the expression: + + >>> binary_callable(3, 2) + 0.0 + >>> binary_callable(4, 5), binary_callable(5, 4) + (-22925376.0, 25165824.0) + +Wrapping the unexpanded expression gives the expected behavior: + + >>> e = autowrap(expr) + >>> e(4, 5), e(5, 4) + (-1.0, 1.0) + +The callable returned from autowrap() is a binary Python function, not a +SymPy object. If it is desired to use the compiled function in symbolic +expressions, it is better to use binary_function() which returns a SymPy +Function object. The binary callable is attached as the _imp_ attribute and +invoked when a numerical evaluation is requested with evalf(), or with +lambdify(). + + >>> from sympy.utilities.autowrap import binary_function + >>> f = binary_function('f', expr) + >>> 2*f(x, y) + y + y + 2*f(x, y) + >>> (2*f(x, y) + y).evalf(2, subs={x: 1, y:2}) + 0.e-110 + +When is this useful? + + 1) For computations on large arrays, Python iterations may be too slow, + and depending on the mathematical expression, it may be difficult to + exploit the advanced index operations provided by NumPy. + + 2) For *really* long expressions that will be called repeatedly, the + compiled binary should be significantly faster than SymPy's .evalf() + + 3) If you are generating code with the codegen utility in order to use + it in another project, the automatic Python wrappers let you test the + binaries immediately from within SymPy. + + 4) To create customized ufuncs for use with numpy arrays. + See *ufuncify*. + +When is this module NOT the best approach? + + 1) If you are really concerned about speed or memory optimizations, + you will probably get better results by working directly with the + wrapper tools and the low level code. However, the files generated + by this utility may provide a useful starting point and reference + code. Temporary files will be left intact if you supply the keyword + tempdir="path/to/files/". + + 2) If the array computation can be handled easily by numpy, and you + do not need the binaries for another project. + +""" + +import sys +import os +import shutil +import tempfile +from subprocess import STDOUT, CalledProcessError, check_output +from string import Template +from warnings import warn + +from sympy.core.cache import cacheit +from sympy.core.function import Lambda +from sympy.core.relational import Eq +from sympy.core.symbol import Dummy, Symbol +from sympy.tensor.indexed import Idx, IndexedBase +from sympy.utilities.codegen import (make_routine, get_code_generator, + OutputArgument, InOutArgument, + InputArgument, CodeGenArgumentListError, + Result, ResultBase, C99CodeGen) +from sympy.utilities.iterables import iterable +from sympy.utilities.lambdify import implemented_function +from sympy.utilities.decorator import doctest_depends_on + +_doctest_depends_on = {'exe': ('f2py', 'gfortran', 'gcc'), + 'modules': ('numpy',)} + + +class CodeWrapError(Exception): + pass + + +class CodeWrapper: + """Base Class for code wrappers""" + _filename = "wrapped_code" + _module_basename = "wrapper_module" + _module_counter = 0 + + @property + def filename(self): + return "%s_%s" % (self._filename, CodeWrapper._module_counter) + + @property + def module_name(self): + return "%s_%s" % (self._module_basename, CodeWrapper._module_counter) + + def __init__(self, generator, filepath=None, flags=[], verbose=False): + """ + generator -- the code generator to use + """ + self.generator = generator + self.filepath = filepath + self.flags = flags + self.quiet = not verbose + + @property + def include_header(self): + return bool(self.filepath) + + @property + def include_empty(self): + return bool(self.filepath) + + def _generate_code(self, main_routine, routines): + routines.append(main_routine) + self.generator.write( + routines, self.filename, True, self.include_header, + self.include_empty) + + def wrap_code(self, routine, helpers=None): + helpers = helpers or [] + if self.filepath: + workdir = os.path.abspath(self.filepath) + else: + workdir = tempfile.mkdtemp("_sympy_compile") + if not os.access(workdir, os.F_OK): + os.mkdir(workdir) + oldwork = os.getcwd() + os.chdir(workdir) + try: + sys.path.append(workdir) + self._generate_code(routine, helpers) + self._prepare_files(routine) + self._process_files(routine) + mod = __import__(self.module_name) + finally: + sys.path.remove(workdir) + CodeWrapper._module_counter += 1 + os.chdir(oldwork) + if not self.filepath: + try: + shutil.rmtree(workdir) + except OSError: + # Could be some issues on Windows + pass + + return self._get_wrapped_function(mod, routine.name) + + def _process_files(self, routine): + command = self.command + command.extend(self.flags) + try: + retoutput = check_output(command, stderr=STDOUT) + except CalledProcessError as e: + raise CodeWrapError( + "Error while executing command: %s. Command output is:\n%s" % ( + " ".join(command), e.output.decode('utf-8'))) + if not self.quiet: + print(retoutput) + + +class DummyWrapper(CodeWrapper): + """Class used for testing independent of backends """ + + template = """# dummy module for testing of SymPy +def %(name)s(): + return "%(expr)s" +%(name)s.args = "%(args)s" +%(name)s.returns = "%(retvals)s" +""" + + def _prepare_files(self, routine): + return + + def _generate_code(self, routine, helpers): + with open('%s.py' % self.module_name, 'w') as f: + printed = ", ".join( + [str(res.expr) for res in routine.result_variables]) + # convert OutputArguments to return value like f2py + args = filter(lambda x: not isinstance( + x, OutputArgument), routine.arguments) + retvals = [] + for val in routine.result_variables: + if isinstance(val, Result): + retvals.append('nameless') + else: + retvals.append(val.result_var) + + print(DummyWrapper.template % { + 'name': routine.name, + 'expr': printed, + 'args': ", ".join([str(a.name) for a in args]), + 'retvals': ", ".join([str(val) for val in retvals]) + }, end="", file=f) + + def _process_files(self, routine): + return + + @classmethod + def _get_wrapped_function(cls, mod, name): + return getattr(mod, name) + + +class CythonCodeWrapper(CodeWrapper): + """Wrapper that uses Cython""" + + setup_template = """\ +from setuptools import setup +from setuptools import Extension +from Cython.Build import cythonize +cy_opts = {cythonize_options} +{np_import} +ext_mods = [Extension( + {ext_args}, + include_dirs={include_dirs}, + library_dirs={library_dirs}, + libraries={libraries}, + extra_compile_args={extra_compile_args}, + extra_link_args={extra_link_args} +)] +setup(ext_modules=cythonize(ext_mods, **cy_opts)) +""" + + _cythonize_options = {'compiler_directives':{'language_level' : "3"}} + + pyx_imports = ( + "import numpy as np\n" + "cimport numpy as np\n\n") + + pyx_header = ( + "cdef extern from '{header_file}.h':\n" + " {prototype}\n\n") + + pyx_func = ( + "def {name}_c({arg_string}):\n" + "\n" + "{declarations}" + "{body}") + + std_compile_flag = '-std=c99' + + def __init__(self, *args, **kwargs): + """Instantiates a Cython code wrapper. + + The following optional parameters get passed to ``setuptools.Extension`` + for building the Python extension module. Read its documentation to + learn more. + + Parameters + ========== + include_dirs : [list of strings] + A list of directories to search for C/C++ header files (in Unix + form for portability). + library_dirs : [list of strings] + A list of directories to search for C/C++ libraries at link time. + libraries : [list of strings] + A list of library names (not filenames or paths) to link against. + extra_compile_args : [list of strings] + Any extra platform- and compiler-specific information to use when + compiling the source files in 'sources'. For platforms and + compilers where "command line" makes sense, this is typically a + list of command-line arguments, but for other platforms it could be + anything. Note that the attribute ``std_compile_flag`` will be + appended to this list. + extra_link_args : [list of strings] + Any extra platform- and compiler-specific information to use when + linking object files together to create the extension (or to create + a new static Python interpreter). Similar interpretation as for + 'extra_compile_args'. + cythonize_options : [dictionary] + Keyword arguments passed on to cythonize. + + """ + + self._include_dirs = kwargs.pop('include_dirs', []) + self._library_dirs = kwargs.pop('library_dirs', []) + self._libraries = kwargs.pop('libraries', []) + self._extra_compile_args = kwargs.pop('extra_compile_args', []) + self._extra_compile_args.append(self.std_compile_flag) + self._extra_link_args = kwargs.pop('extra_link_args', []) + self._cythonize_options = kwargs.pop('cythonize_options', self._cythonize_options) + + self._need_numpy = False + + super().__init__(*args, **kwargs) + + @property + def command(self): + command = [sys.executable, "setup.py", "build_ext", "--inplace"] + return command + + def _prepare_files(self, routine, build_dir=os.curdir): + # NOTE : build_dir is used for testing purposes. + pyxfilename = self.module_name + '.pyx' + codefilename = "%s.%s" % (self.filename, self.generator.code_extension) + + # pyx + with open(os.path.join(build_dir, pyxfilename), 'w') as f: + self.dump_pyx([routine], f, self.filename) + + # setup.py + ext_args = [repr(self.module_name), repr([pyxfilename, codefilename])] + if self._need_numpy: + np_import = 'import numpy as np\n' + self._include_dirs.append('np.get_include()') + else: + np_import = '' + + with open(os.path.join(build_dir, 'setup.py'), 'w') as f: + includes = str(self._include_dirs).replace("'np.get_include()'", + 'np.get_include()') + f.write(self.setup_template.format( + ext_args=", ".join(ext_args), + np_import=np_import, + include_dirs=includes, + library_dirs=self._library_dirs, + libraries=self._libraries, + extra_compile_args=self._extra_compile_args, + extra_link_args=self._extra_link_args, + cythonize_options=self._cythonize_options + )) + + @classmethod + def _get_wrapped_function(cls, mod, name): + return getattr(mod, name + '_c') + + def dump_pyx(self, routines, f, prefix): + """Write a Cython file with Python wrappers + + This file contains all the definitions of the routines in c code and + refers to the header file. + + Arguments + --------- + routines + List of Routine instances + f + File-like object to write the file to + prefix + The filename prefix, used to refer to the proper header file. + Only the basename of the prefix is used. + """ + headers = [] + functions = [] + for routine in routines: + prototype = self.generator.get_prototype(routine) + + # C Function Header Import + headers.append(self.pyx_header.format(header_file=prefix, + prototype=prototype)) + + # Partition the C function arguments into categories + py_rets, py_args, py_loc, py_inf = self._partition_args(routine.arguments) + + # Function prototype + name = routine.name + arg_string = ", ".join(self._prototype_arg(arg) for arg in py_args) + + # Local Declarations + local_decs = [] + for arg, val in py_inf.items(): + proto = self._prototype_arg(arg) + mat, ind = [self._string_var(v) for v in val] + local_decs.append(" cdef {} = {}.shape[{}]".format(proto, mat, ind)) + local_decs.extend([" cdef {}".format(self._declare_arg(a)) for a in py_loc]) + declarations = "\n".join(local_decs) + if declarations: + declarations = declarations + "\n" + + # Function Body + args_c = ", ".join([self._call_arg(a) for a in routine.arguments]) + rets = ", ".join([self._string_var(r.name) for r in py_rets]) + if routine.results: + body = ' return %s(%s)' % (routine.name, args_c) + if rets: + body = body + ', ' + rets + else: + body = ' %s(%s)\n' % (routine.name, args_c) + body = body + ' return ' + rets + + functions.append(self.pyx_func.format(name=name, arg_string=arg_string, + declarations=declarations, body=body)) + + # Write text to file + if self._need_numpy: + # Only import numpy if required + f.write(self.pyx_imports) + f.write('\n'.join(headers)) + f.write('\n'.join(functions)) + + def _partition_args(self, args): + """Group function arguments into categories.""" + py_args = [] + py_returns = [] + py_locals = [] + py_inferred = {} + for arg in args: + if isinstance(arg, OutputArgument): + py_returns.append(arg) + py_locals.append(arg) + elif isinstance(arg, InOutArgument): + py_returns.append(arg) + py_args.append(arg) + else: + py_args.append(arg) + # Find arguments that are array dimensions. These can be inferred + # locally in the Cython code. + if isinstance(arg, (InputArgument, InOutArgument)) and arg.dimensions: + dims = [d[1] + 1 for d in arg.dimensions] + sym_dims = [(i, d) for (i, d) in enumerate(dims) if + isinstance(d, Symbol)] + for (i, d) in sym_dims: + py_inferred[d] = (arg.name, i) + for arg in args: + if arg.name in py_inferred: + py_inferred[arg] = py_inferred.pop(arg.name) + # Filter inferred arguments from py_args + py_args = [a for a in py_args if a not in py_inferred] + return py_returns, py_args, py_locals, py_inferred + + def _prototype_arg(self, arg): + mat_dec = "np.ndarray[{mtype}, ndim={ndim}] {name}" + np_types = {'double': 'np.double_t', + 'int': 'np.int_t'} + t = arg.get_datatype('c') + if arg.dimensions: + self._need_numpy = True + ndim = len(arg.dimensions) + mtype = np_types[t] + return mat_dec.format(mtype=mtype, ndim=ndim, name=self._string_var(arg.name)) + else: + return "%s %s" % (t, self._string_var(arg.name)) + + def _declare_arg(self, arg): + proto = self._prototype_arg(arg) + if arg.dimensions: + shape = '(' + ','.join(self._string_var(i[1] + 1) for i in arg.dimensions) + ')' + return proto + " = np.empty({shape})".format(shape=shape) + else: + return proto + " = 0" + + def _call_arg(self, arg): + if arg.dimensions: + t = arg.get_datatype('c') + return "<{}*> {}.data".format(t, self._string_var(arg.name)) + elif isinstance(arg, ResultBase): + return "&{}".format(self._string_var(arg.name)) + else: + return self._string_var(arg.name) + + def _string_var(self, var): + printer = self.generator.printer.doprint + return printer(var) + + +class F2PyCodeWrapper(CodeWrapper): + """Wrapper that uses f2py""" + + def __init__(self, *args, **kwargs): + + ext_keys = ['include_dirs', 'library_dirs', 'libraries', + 'extra_compile_args', 'extra_link_args'] + msg = ('The compilation option kwarg {} is not supported with the f2py ' + 'backend.') + + for k in ext_keys: + if k in kwargs.keys(): + warn(msg.format(k)) + kwargs.pop(k, None) + + super().__init__(*args, **kwargs) + + @property + def command(self): + filename = self.filename + '.' + self.generator.code_extension + args = ['-c', '-m', self.module_name, filename] + command = [sys.executable, "-c", "import numpy.f2py as f2py2e;f2py2e.main()"]+args + return command + + def _prepare_files(self, routine): + pass + + @classmethod + def _get_wrapped_function(cls, mod, name): + return getattr(mod, name) + + +# Here we define a lookup of backends -> tuples of languages. For now, each +# tuple is of length 1, but if a backend supports more than one language, +# the most preferable language is listed first. +_lang_lookup = {'CYTHON': ('C99', 'C89', 'C'), + 'F2PY': ('F95',), + 'NUMPY': ('C99', 'C89', 'C'), + 'DUMMY': ('F95',)} # Dummy here just for testing + + +def _infer_language(backend): + """For a given backend, return the top choice of language""" + langs = _lang_lookup.get(backend.upper(), False) + if not langs: + raise ValueError("Unrecognized backend: " + backend) + return langs[0] + + +def _validate_backend_language(backend, language): + """Throws error if backend and language are incompatible""" + langs = _lang_lookup.get(backend.upper(), False) + if not langs: + raise ValueError("Unrecognized backend: " + backend) + if language.upper() not in langs: + raise ValueError(("Backend {} and language {} are " + "incompatible").format(backend, language)) + + +@cacheit +@doctest_depends_on(exe=('f2py', 'gfortran'), modules=('numpy',)) +def autowrap(expr, language=None, backend='f2py', tempdir=None, args=None, + flags=None, verbose=False, helpers=None, code_gen=None, **kwargs): + """Generates Python callable binaries based on the math expression. + + Parameters + ========== + + expr + The SymPy expression that should be wrapped as a binary routine. + language : string, optional + If supplied, (options: 'C' or 'F95'), specifies the language of the + generated code. If ``None`` [default], the language is inferred based + upon the specified backend. + backend : string, optional + Backend used to wrap the generated code. Either 'f2py' [default], + or 'cython'. + tempdir : string, optional + Path to directory for temporary files. If this argument is supplied, + the generated code and the wrapper input files are left intact in the + specified path. + args : iterable, optional + An ordered iterable of symbols. Specifies the argument sequence for the + function. + flags : iterable, optional + Additional option flags that will be passed to the backend. + verbose : bool, optional + If True, autowrap will not mute the command line backends. This can be + helpful for debugging. + helpers : 3-tuple or iterable of 3-tuples, optional + Used to define auxiliary expressions needed for the main expr. If the + main expression needs to call a specialized function it should be + passed in via ``helpers``. Autowrap will then make sure that the + compiled main expression can link to the helper routine. Items should + be 3-tuples with (, , + ). It is mandatory to supply an argument sequence to + helper routines. + code_gen : CodeGen instance + An instance of a CodeGen subclass. Overrides ``language``. + include_dirs : [string] + A list of directories to search for C/C++ header files (in Unix form + for portability). + library_dirs : [string] + A list of directories to search for C/C++ libraries at link time. + libraries : [string] + A list of library names (not filenames or paths) to link against. + extra_compile_args : [string] + Any extra platform- and compiler-specific information to use when + compiling the source files in 'sources'. For platforms and compilers + where "command line" makes sense, this is typically a list of + command-line arguments, but for other platforms it could be anything. + extra_link_args : [string] + Any extra platform- and compiler-specific information to use when + linking object files together to create the extension (or to create a + new static Python interpreter). Similar interpretation as for + 'extra_compile_args'. + + Examples + ======== + + >>> from sympy.abc import x, y, z + >>> from sympy.utilities.autowrap import autowrap + >>> expr = ((x - y + z)**(13)).expand() + >>> binary_func = autowrap(expr) + >>> binary_func(1, 4, 2) + -1.0 + + """ + if language: + if not isinstance(language, type): + _validate_backend_language(backend, language) + else: + language = _infer_language(backend) + + # two cases 1) helpers is an iterable of 3-tuples and 2) helpers is a + # 3-tuple + if iterable(helpers) and len(helpers) != 0 and iterable(helpers[0]): + helpers = helpers if helpers else () + else: + helpers = [helpers] if helpers else () + args = list(args) if iterable(args, exclude=set) else args + + if code_gen is None: + code_gen = get_code_generator(language, "autowrap") + + CodeWrapperClass = { + 'F2PY': F2PyCodeWrapper, + 'CYTHON': CythonCodeWrapper, + 'DUMMY': DummyWrapper + }[backend.upper()] + code_wrapper = CodeWrapperClass(code_gen, tempdir, flags if flags else (), + verbose, **kwargs) + + helps = [] + for name_h, expr_h, args_h in helpers: + helps.append(code_gen.routine(name_h, expr_h, args_h)) + + for name_h, expr_h, args_h in helpers: + if expr.has(expr_h): + name_h = binary_function(name_h, expr_h, backend='dummy') + expr = expr.subs(expr_h, name_h(*args_h)) + try: + routine = code_gen.routine('autofunc', expr, args) + except CodeGenArgumentListError as e: + # if all missing arguments are for pure output, we simply attach them + # at the end and try again, because the wrappers will silently convert + # them to return values anyway. + new_args = [] + for missing in e.missing_args: + if not isinstance(missing, OutputArgument): + raise + new_args.append(missing.name) + routine = code_gen.routine('autofunc', expr, args + new_args) + + return code_wrapper.wrap_code(routine, helpers=helps) + + +@doctest_depends_on(exe=('f2py', 'gfortran'), modules=('numpy',)) +def binary_function(symfunc, expr, **kwargs): + """Returns a SymPy function with expr as binary implementation + + This is a convenience function that automates the steps needed to + autowrap the SymPy expression and attaching it to a Function object + with implemented_function(). + + Parameters + ========== + + symfunc : SymPy Function + The function to bind the callable to. + expr : SymPy Expression + The expression used to generate the function. + kwargs : dict + Any kwargs accepted by autowrap. + + Examples + ======== + + >>> from sympy.abc import x, y + >>> from sympy.utilities.autowrap import binary_function + >>> expr = ((x - y)**(25)).expand() + >>> f = binary_function('f', expr) + >>> type(f) + + >>> 2*f(x, y) + 2*f(x, y) + >>> f(x, y).evalf(2, subs={x: 1, y: 2}) + -1.0 + + """ + binary = autowrap(expr, **kwargs) + return implemented_function(symfunc, binary) + +################################################################# +# UFUNCIFY # +################################################################# + +_ufunc_top = Template("""\ +#include "Python.h" +#include "math.h" +#include "numpy/ndarraytypes.h" +#include "numpy/ufuncobject.h" +#include "numpy/halffloat.h" +#include ${include_file} + +static PyMethodDef ${module}Methods[] = { + {NULL, NULL, 0, NULL} +};""") + +_ufunc_outcalls = Template("*((double *)out${outnum}) = ${funcname}(${call_args});") + +_ufunc_body = Template("""\ +static void ${funcname}_ufunc(char **args, npy_intp *dimensions, npy_intp* steps, void* data) +{ + npy_intp i; + npy_intp n = dimensions[0]; + ${declare_args} + ${declare_steps} + for (i = 0; i < n; i++) { + ${outcalls} + ${step_increments} + } +} +PyUFuncGenericFunction ${funcname}_funcs[1] = {&${funcname}_ufunc}; +static char ${funcname}_types[${n_types}] = ${types} +static void *${funcname}_data[1] = {NULL};""") + +_ufunc_bottom = Template("""\ +#if PY_VERSION_HEX >= 0x03000000 +static struct PyModuleDef moduledef = { + PyModuleDef_HEAD_INIT, + "${module}", + NULL, + -1, + ${module}Methods, + NULL, + NULL, + NULL, + NULL +}; + +PyMODINIT_FUNC PyInit_${module}(void) +{ + PyObject *m, *d; + ${function_creation} + m = PyModule_Create(&moduledef); + if (!m) { + return NULL; + } + import_array(); + import_umath(); + d = PyModule_GetDict(m); + ${ufunc_init} + return m; +} +#else +PyMODINIT_FUNC init${module}(void) +{ + PyObject *m, *d; + ${function_creation} + m = Py_InitModule("${module}", ${module}Methods); + if (m == NULL) { + return; + } + import_array(); + import_umath(); + d = PyModule_GetDict(m); + ${ufunc_init} +} +#endif\ +""") + +_ufunc_init_form = Template("""\ +ufunc${ind} = PyUFunc_FromFuncAndData(${funcname}_funcs, ${funcname}_data, ${funcname}_types, 1, ${n_in}, ${n_out}, + PyUFunc_None, "${module}", ${docstring}, 0); + PyDict_SetItemString(d, "${funcname}", ufunc${ind}); + Py_DECREF(ufunc${ind});""") + +_ufunc_setup = Template("""\ +from setuptools.extension import Extension +from setuptools import setup + +from numpy import get_include + +if __name__ == "__main__": + setup(ext_modules=[ + Extension('${module}', + sources=['${module}.c', '${filename}.c'], + include_dirs=[get_include()])]) +""") + + +class UfuncifyCodeWrapper(CodeWrapper): + """Wrapper for Ufuncify""" + + def __init__(self, *args, **kwargs): + + ext_keys = ['include_dirs', 'library_dirs', 'libraries', + 'extra_compile_args', 'extra_link_args'] + msg = ('The compilation option kwarg {} is not supported with the numpy' + ' backend.') + + for k in ext_keys: + if k in kwargs.keys(): + warn(msg.format(k)) + kwargs.pop(k, None) + + super().__init__(*args, **kwargs) + + @property + def command(self): + command = [sys.executable, "setup.py", "build_ext", "--inplace"] + return command + + def wrap_code(self, routines, helpers=None): + # This routine overrides CodeWrapper because we can't assume funcname == routines[0].name + # Therefore we have to break the CodeWrapper private API. + # There isn't an obvious way to extend multi-expr support to + # the other autowrap backends, so we limit this change to ufuncify. + helpers = helpers if helpers is not None else [] + # We just need a consistent name + funcname = 'wrapped_' + str(id(routines) + id(helpers)) + + workdir = self.filepath or tempfile.mkdtemp("_sympy_compile") + if not os.access(workdir, os.F_OK): + os.mkdir(workdir) + oldwork = os.getcwd() + os.chdir(workdir) + try: + sys.path.append(workdir) + self._generate_code(routines, helpers) + self._prepare_files(routines, funcname) + self._process_files(routines) + mod = __import__(self.module_name) + finally: + sys.path.remove(workdir) + CodeWrapper._module_counter += 1 + os.chdir(oldwork) + if not self.filepath: + try: + shutil.rmtree(workdir) + except OSError: + # Could be some issues on Windows + pass + + return self._get_wrapped_function(mod, funcname) + + def _generate_code(self, main_routines, helper_routines): + all_routines = main_routines + helper_routines + self.generator.write( + all_routines, self.filename, True, self.include_header, + self.include_empty) + + def _prepare_files(self, routines, funcname): + + # C + codefilename = self.module_name + '.c' + with open(codefilename, 'w') as f: + self.dump_c(routines, f, self.filename, funcname=funcname) + + # setup.py + with open('setup.py', 'w') as f: + self.dump_setup(f) + + @classmethod + def _get_wrapped_function(cls, mod, name): + return getattr(mod, name) + + def dump_setup(self, f): + setup = _ufunc_setup.substitute(module=self.module_name, + filename=self.filename) + f.write(setup) + + def dump_c(self, routines, f, prefix, funcname=None): + """Write a C file with Python wrappers + + This file contains all the definitions of the routines in c code. + + Arguments + --------- + routines + List of Routine instances + f + File-like object to write the file to + prefix + The filename prefix, used to name the imported module. + funcname + Name of the main function to be returned. + """ + if funcname is None: + if len(routines) == 1: + funcname = routines[0].name + else: + msg = 'funcname must be specified for multiple output routines' + raise ValueError(msg) + functions = [] + function_creation = [] + ufunc_init = [] + module = self.module_name + include_file = "\"{}.h\"".format(prefix) + top = _ufunc_top.substitute(include_file=include_file, module=module) + + name = funcname + + # Partition the C function arguments into categories + # Here we assume all routines accept the same arguments + r_index = 0 + py_in, _ = self._partition_args(routines[0].arguments) + n_in = len(py_in) + n_out = len(routines) + + # Declare Args + form = "char *{0}{1} = args[{2}];" + arg_decs = [form.format('in', i, i) for i in range(n_in)] + arg_decs.extend([form.format('out', i, i+n_in) for i in range(n_out)]) + declare_args = '\n '.join(arg_decs) + + # Declare Steps + form = "npy_intp {0}{1}_step = steps[{2}];" + step_decs = [form.format('in', i, i) for i in range(n_in)] + step_decs.extend([form.format('out', i, i+n_in) for i in range(n_out)]) + declare_steps = '\n '.join(step_decs) + + # Call Args + form = "*(double *)in{0}" + call_args = ', '.join([form.format(a) for a in range(n_in)]) + + # Step Increments + form = "{0}{1} += {0}{1}_step;" + step_incs = [form.format('in', i) for i in range(n_in)] + step_incs.extend([form.format('out', i, i) for i in range(n_out)]) + step_increments = '\n '.join(step_incs) + + # Types + n_types = n_in + n_out + types = "{" + ', '.join(["NPY_DOUBLE"]*n_types) + "};" + + # Docstring + docstring = '"Created in SymPy with Ufuncify"' + + # Function Creation + function_creation.append("PyObject *ufunc{};".format(r_index)) + + # Ufunc initialization + init_form = _ufunc_init_form.substitute(module=module, + funcname=name, + docstring=docstring, + n_in=n_in, n_out=n_out, + ind=r_index) + ufunc_init.append(init_form) + + outcalls = [_ufunc_outcalls.substitute( + outnum=i, call_args=call_args, funcname=routines[i].name) for i in + range(n_out)] + + body = _ufunc_body.substitute(module=module, funcname=name, + declare_args=declare_args, + declare_steps=declare_steps, + call_args=call_args, + step_increments=step_increments, + n_types=n_types, types=types, + outcalls='\n '.join(outcalls)) + functions.append(body) + + body = '\n\n'.join(functions) + ufunc_init = '\n '.join(ufunc_init) + function_creation = '\n '.join(function_creation) + bottom = _ufunc_bottom.substitute(module=module, + ufunc_init=ufunc_init, + function_creation=function_creation) + text = [top, body, bottom] + f.write('\n\n'.join(text)) + + def _partition_args(self, args): + """Group function arguments into categories.""" + py_in = [] + py_out = [] + for arg in args: + if isinstance(arg, OutputArgument): + py_out.append(arg) + elif isinstance(arg, InOutArgument): + raise ValueError("Ufuncify doesn't support InOutArguments") + else: + py_in.append(arg) + return py_in, py_out + + +@cacheit +@doctest_depends_on(exe=('f2py', 'gfortran', 'gcc'), modules=('numpy',)) +def ufuncify(args, expr, language=None, backend='numpy', tempdir=None, + flags=None, verbose=False, helpers=None, **kwargs): + """Generates a binary function that supports broadcasting on numpy arrays. + + Parameters + ========== + + args : iterable + Either a Symbol or an iterable of symbols. Specifies the argument + sequence for the function. + expr + A SymPy expression that defines the element wise operation. + language : string, optional + If supplied, (options: 'C' or 'F95'), specifies the language of the + generated code. If ``None`` [default], the language is inferred based + upon the specified backend. + backend : string, optional + Backend used to wrap the generated code. Either 'numpy' [default], + 'cython', or 'f2py'. + tempdir : string, optional + Path to directory for temporary files. If this argument is supplied, + the generated code and the wrapper input files are left intact in + the specified path. + flags : iterable, optional + Additional option flags that will be passed to the backend. + verbose : bool, optional + If True, autowrap will not mute the command line backends. This can + be helpful for debugging. + helpers : iterable, optional + Used to define auxiliary expressions needed for the main expr. If + the main expression needs to call a specialized function it should + be put in the ``helpers`` iterable. Autowrap will then make sure + that the compiled main expression can link to the helper routine. + Items should be tuples with (, , + ). It is mandatory to supply an argument sequence to + helper routines. + kwargs : dict + These kwargs will be passed to autowrap if the `f2py` or `cython` + backend is used and ignored if the `numpy` backend is used. + + Notes + ===== + + The default backend ('numpy') will create actual instances of + ``numpy.ufunc``. These support ndimensional broadcasting, and implicit type + conversion. Use of the other backends will result in a "ufunc-like" + function, which requires equal length 1-dimensional arrays for all + arguments, and will not perform any type conversions. + + References + ========== + + .. [1] https://numpy.org/doc/stable/reference/ufuncs.html + + Examples + ======== + + >>> from sympy.utilities.autowrap import ufuncify + >>> from sympy.abc import x, y + >>> import numpy as np + >>> f = ufuncify((x, y), y + x**2) + >>> type(f) + + >>> f([1, 2, 3], 2) + array([ 3., 6., 11.]) + >>> f(np.arange(5), 3) + array([ 3., 4., 7., 12., 19.]) + + For the 'f2py' and 'cython' backends, inputs are required to be equal length + 1-dimensional arrays. The 'f2py' backend will perform type conversion, but + the Cython backend will error if the inputs are not of the expected type. + + >>> f_fortran = ufuncify((x, y), y + x**2, backend='f2py') + >>> f_fortran(1, 2) + array([ 3.]) + >>> f_fortran(np.array([1, 2, 3]), np.array([1.0, 2.0, 3.0])) + array([ 2., 6., 12.]) + >>> f_cython = ufuncify((x, y), y + x**2, backend='Cython') + >>> f_cython(1, 2) # doctest: +ELLIPSIS + Traceback (most recent call last): + ... + TypeError: Argument '_x' has incorrect type (expected numpy.ndarray, got int) + >>> f_cython(np.array([1.0]), np.array([2.0])) + array([ 3.]) + + """ + + if isinstance(args, Symbol): + args = (args,) + else: + args = tuple(args) + + if language: + _validate_backend_language(backend, language) + else: + language = _infer_language(backend) + + helpers = helpers if helpers else () + flags = flags if flags else () + + if backend.upper() == 'NUMPY': + # maxargs is set by numpy compile-time constant NPY_MAXARGS + # If a future version of numpy modifies or removes this restriction + # this variable should be changed or removed + maxargs = 32 + helps = [] + for name, expr, args in helpers: + helps.append(make_routine(name, expr, args)) + code_wrapper = UfuncifyCodeWrapper(C99CodeGen("ufuncify"), tempdir, + flags, verbose) + if not isinstance(expr, (list, tuple)): + expr = [expr] + if len(expr) == 0: + raise ValueError('Expression iterable has zero length') + if len(expr) + len(args) > maxargs: + msg = ('Cannot create ufunc with more than {0} total arguments: ' + 'got {1} in, {2} out') + raise ValueError(msg.format(maxargs, len(args), len(expr))) + routines = [make_routine('autofunc{}'.format(idx), exprx, args) for + idx, exprx in enumerate(expr)] + return code_wrapper.wrap_code(routines, helpers=helps) + else: + # Dummies are used for all added expressions to prevent name clashes + # within the original expression. + y = IndexedBase(Dummy('y')) + m = Dummy('m', integer=True) + i = Idx(Dummy('i', integer=True), m) + f_dummy = Dummy('f') + f = implemented_function('%s_%d' % (f_dummy.name, f_dummy.dummy_index), Lambda(args, expr)) + # For each of the args create an indexed version. + indexed_args = [IndexedBase(Dummy(str(a))) for a in args] + # Order the arguments (out, args, dim) + args = [y] + indexed_args + [m] + args_with_indices = [a[i] for a in indexed_args] + return autowrap(Eq(y[i], f(*args_with_indices)), language, backend, + tempdir, args, flags, verbose, helpers, **kwargs) diff --git a/shared/package-files/30/30de75b16bd96cbcc1a730766a57b4f1f2a4de8634b70c592321e259a91e8510/blob b/shared/package-files/30/30de75b16bd96cbcc1a730766a57b4f1f2a4de8634b70c592321e259a91e8510/blob new file mode 100644 index 0000000000000000000000000000000000000000..6939122aec61a6209d10a976933c1756b29188f9 --- /dev/null +++ b/shared/package-files/30/30de75b16bd96cbcc1a730766a57b4f1f2a4de8634b70c592321e259a91e8510/blob @@ -0,0 +1,27 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeMetaFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace meta { + +struct TORCH_API structured_sign : public TensorIteratorBase { + + + void meta(const at::Tensor & self); +}; + +} // namespace native +} // namespace at diff --git a/shared/package-files/30/30dfaae7d0a20ea1d707cc45297c7309b2496c998d0e105ef650c9240a0c4cf0/blob b/shared/package-files/30/30dfaae7d0a20ea1d707cc45297c7309b2496c998d0e105ef650c9240a0c4cf0/blob new file mode 100644 index 0000000000000000000000000000000000000000..75c95bf16a1f1c1265c6554fba5da038f75bab91 --- /dev/null +++ b/shared/package-files/30/30dfaae7d0a20ea1d707cc45297c7309b2496c998d0e105ef650c9240a0c4cf0/blob @@ -0,0 +1,19 @@ +# This style is used for the plot_types gallery. It is considered part of the private API. + +axes.grid: True +axes.axisbelow: True + +figure.figsize: 2, 2 +# make it so the axes labels don't show up. Obviously +# not good style for any quantitative analysis: +figure.subplot.left: 0.01 +figure.subplot.right: 0.99 +figure.subplot.bottom: 0.01 +figure.subplot.top: 0.99 + +xtick.major.size: 0.0 +ytick.major.size: 0.0 + +# colors: +image.cmap : Blues +axes.prop_cycle: cycler('color', ['1f77b4', '58a1cf', 'abd0e6']) diff --git a/shared/package-files/30/30e2c5853b7762551f32be245e79fd9d06e52a7cfdfd9c31bfece83405563292/blob b/shared/package-files/30/30e2c5853b7762551f32be245e79fd9d06e52a7cfdfd9c31bfece83405563292/blob new file mode 100644 index 0000000000000000000000000000000000000000..16b3beae01b0416295b9e89f643fdb51f7e1f8eb --- /dev/null +++ b/shared/package-files/30/30e2c5853b7762551f32be245e79fd9d06e52a7cfdfd9c31bfece83405563292/blob @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:30e2c5853b7762551f32be245e79fd9d06e52a7cfdfd9c31bfece83405563292 +size 210768 diff --git a/shared/package-files/30/30e456f11b1d9904e0169611ecf2d1437e60c4562ea777a342ed1bca22319a28/blob b/shared/package-files/30/30e456f11b1d9904e0169611ecf2d1437e60c4562ea777a342ed1bca22319a28/blob new file mode 100644 index 0000000000000000000000000000000000000000..86f2376f751cd991f227e55355e2f61b897462bd --- /dev/null +++ b/shared/package-files/30/30e456f11b1d9904e0169611ecf2d1437e60c4562ea777a342ed1bca22319a28/blob @@ -0,0 +1,62 @@ +import shutil +from sympy.external import import_module +from sympy.testing.pytest import skip + +from sympy.utilities._compilation.compilation import compile_link_import_strings + +numpy = import_module('numpy') +cython = import_module('cython') + +_sources1 = [ + ('sigmoid.c', r""" +#include + +void sigmoid(int n, const double * const restrict in, + double * const restrict out, double lim){ + for (int i=0; i +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API diagflat { + using schema = at::Tensor (const at::Tensor &, int64_t); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::diagflat") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "diagflat(Tensor self, int offset=0) -> Tensor") + static at::Tensor call(const at::Tensor & self, int64_t offset); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, int64_t offset); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/30/30e82de4df61fc47b5afa7c9d928348c3743c43756917b24b465dc74775c457a/blob b/shared/package-files/30/30e82de4df61fc47b5afa7c9d928348c3743c43756917b24b465dc74775c457a/blob new file mode 100644 index 0000000000000000000000000000000000000000..674829faa68acd87469e1a182d5a0cdc3f0b83de --- /dev/null +++ b/shared/package-files/30/30e82de4df61fc47b5afa7c9d928348c3743c43756917b24b465dc74775c457a/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API multilabel_margin_loss_out { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, int64_t, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::multilabel_margin_loss") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "multilabel_margin_loss.out(Tensor self, Tensor target, int reduction=Mean, *, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, const at::Tensor & target, int64_t reduction, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & target, int64_t reduction, at::Tensor & out); +}; + +struct TORCH_API multilabel_margin_loss { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, int64_t); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::multilabel_margin_loss") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "multilabel_margin_loss(Tensor self, Tensor target, int reduction=Mean) -> Tensor") + static at::Tensor call(const at::Tensor & self, const at::Tensor & target, int64_t reduction); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & target, int64_t reduction); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/30/30ebdd6cb6f38cde59d4941082d2328f08ee20c3d7e2cd9b4dcfe4c5a5faef07/blob b/shared/package-files/30/30ebdd6cb6f38cde59d4941082d2328f08ee20c3d7e2cd9b4dcfe4c5a5faef07/blob new file mode 100644 index 0000000000000000000000000000000000000000..89616b92329691ca76039fe11a7e08f7f3db1150 --- /dev/null +++ b/shared/package-files/30/30ebdd6cb6f38cde59d4941082d2328f08ee20c3d7e2cd9b4dcfe4c5a5faef07/blob @@ -0,0 +1,36 @@ +import pytest + +from scipy.special._testutils import MissingModule, check_version +from scipy.special._mptestutils import mp_assert_allclose +from scipy.special._precompute.utils import lagrange_inversion + +try: + import sympy +except ImportError: + sympy = MissingModule('sympy') + +try: + import mpmath as mp +except ImportError: + mp = MissingModule('mpmath') + + +@pytest.mark.slow +@check_version(sympy, '0.7') +@check_version(mp, '0.19') +class TestInversion: + @pytest.mark.xfail_on_32bit("rtol only 2e-9, see gh-6938") + def test_log(self): + with mp.workdps(30): + logcoeffs = mp.taylor(lambda x: mp.log(1 + x), 0, 10) + expcoeffs = mp.taylor(lambda x: mp.exp(x) - 1, 0, 10) + invlogcoeffs = lagrange_inversion(logcoeffs) + mp_assert_allclose(invlogcoeffs, expcoeffs) + + @pytest.mark.xfail_on_32bit("rtol only 1e-15, see gh-6938") + def test_sin(self): + with mp.workdps(30): + sincoeffs = mp.taylor(mp.sin, 0, 10) + asincoeffs = mp.taylor(mp.asin, 0, 10) + invsincoeffs = lagrange_inversion(sincoeffs) + mp_assert_allclose(invsincoeffs, asincoeffs, atol=1e-30) diff --git a/shared/package-files/30/30ee90a82d3146b37aec687dc54fe732669dc015656333cd92afe1e2062ecda4/blob b/shared/package-files/30/30ee90a82d3146b37aec687dc54fe732669dc015656333cd92afe1e2062ecda4/blob new file mode 100644 index 0000000000000000000000000000000000000000..0883ff0705bf11267d4d921b9bf48392b3e23889 --- /dev/null +++ b/shared/package-files/30/30ee90a82d3146b37aec687dc54fe732669dc015656333cd92afe1e2062ecda4/blob @@ -0,0 +1 @@ +tzdata diff --git a/shared/package-files/30/30ef1aed5a51de4c55a4dc59ca9313f570b2e41ebe26cfb99be8b09d7eea6ea1/blob b/shared/package-files/30/30ef1aed5a51de4c55a4dc59ca9313f570b2e41ebe26cfb99be8b09d7eea6ea1/blob new file mode 100644 index 0000000000000000000000000000000000000000..cee42b42fa084388703541118678b77b41919bea --- /dev/null +++ b/shared/package-files/30/30ef1aed5a51de4c55a4dc59ca9313f570b2e41ebe26cfb99be8b09d7eea6ea1/blob @@ -0,0 +1,28 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace meta { + +TORCH_API at::Tensor _upsample_nearest_exact3d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, c10::optional scales_d=c10::nullopt, c10::optional scales_h=c10::nullopt, c10::optional scales_w=c10::nullopt); +TORCH_API at::Tensor _upsample_nearest_exact3d_backward_symint(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, c10::optional scales_d=c10::nullopt, c10::optional scales_h=c10::nullopt, c10::optional scales_w=c10::nullopt); +TORCH_API at::Tensor & _upsample_nearest_exact3d_backward_out(at::Tensor & grad_input, const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, c10::optional scales_d=c10::nullopt, c10::optional scales_h=c10::nullopt, c10::optional scales_w=c10::nullopt); +TORCH_API at::Tensor & _upsample_nearest_exact3d_backward_outf(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, c10::optional scales_d, c10::optional scales_h, c10::optional scales_w, at::Tensor & grad_input); +TORCH_API at::Tensor & _upsample_nearest_exact3d_backward_symint_out(at::Tensor & grad_input, const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, c10::optional scales_d=c10::nullopt, c10::optional scales_h=c10::nullopt, c10::optional scales_w=c10::nullopt); +TORCH_API at::Tensor & _upsample_nearest_exact3d_backward_symint_outf(const at::Tensor & grad_output, c10::SymIntArrayRef output_size, c10::SymIntArrayRef input_size, c10::optional scales_d, c10::optional scales_h, c10::optional scales_w, at::Tensor & grad_input); + +} // namespace meta +} // namespace at diff --git a/shared/package-files/30/30f0ac863d120d491161de2c55eab84c5e19bcb896a30c24dfdfb49b89c010cd/blob b/shared/package-files/30/30f0ac863d120d491161de2c55eab84c5e19bcb896a30c24dfdfb49b89c010cd/blob new file mode 100644 index 0000000000000000000000000000000000000000..8b1203dde7a3d7f3deaea73e0fb1efa9c89669f3 --- /dev/null +++ b/shared/package-files/30/30f0ac863d120d491161de2c55eab84c5e19bcb896a30c24dfdfb49b89c010cd/blob @@ -0,0 +1,27 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeMetaFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace meta { + +struct TORCH_API structured_triu : public at::impl::MetaBase { + + + void meta(const at::Tensor & self, int64_t diagonal); +}; + +} // namespace native +} // namespace at diff --git a/shared/package-files/30/30f2c072f22afe082d3b733444feb64cd52b5558c6eebbc2434fa94a6dcc32b9/blob b/shared/package-files/30/30f2c072f22afe082d3b733444feb64cd52b5558c6eebbc2434fa94a6dcc32b9/blob new file mode 100644 index 0000000000000000000000000000000000000000..10e462098bef511c4260dd023961ab585b746714 --- /dev/null +++ b/shared/package-files/30/30f2c072f22afe082d3b733444feb64cd52b5558c6eebbc2434fa94a6dcc32b9/blob @@ -0,0 +1,27 @@ +# -*- coding: utf-8 -*- +"""Test IPython.core.logger""" + +import os.path + +import pytest +from tempfile import TemporaryDirectory + + +def test_logstart_inaccessible_file(): + with pytest.raises(IOError): + _ip.logger.logstart(logfname="/") # Opening that filename will fail. + + try: + _ip.run_cell("a=1") # Check it doesn't try to log this + finally: + _ip.logger.log_active = False # If this fails, don't let later tests fail + +def test_logstart_unicode(): + with TemporaryDirectory() as tdir: + logfname = os.path.join(tdir, "test_unicode.log") + _ip.run_cell("'abc€'") + try: + _ip.magic("logstart -to %s" % logfname) + _ip.run_cell("'abc€'") + finally: + _ip.logger.logstop() diff --git a/shared/package-files/30/30f940d3632a280e0e9210a1ca52921ef48a2aa2b0178b6fc45a4d49821bb7ac/blob b/shared/package-files/30/30f940d3632a280e0e9210a1ca52921ef48a2aa2b0178b6fc45a4d49821bb7ac/blob new file mode 100644 index 0000000000000000000000000000000000000000..8db242e33253ac743d0643bae1474620266bffe9 --- /dev/null +++ b/shared/package-files/30/30f940d3632a280e0e9210a1ca52921ef48a2aa2b0178b6fc45a4d49821bb7ac/blob @@ -0,0 +1,214 @@ +from typing import Dict + +import torch +from torch.distributions import Categorical, constraints +from torch.distributions.distribution import Distribution + +__all__ = ["MixtureSameFamily"] + + +class MixtureSameFamily(Distribution): + r""" + The `MixtureSameFamily` distribution implements a (batch of) mixture + distribution where all component are from different parameterizations of + the same distribution type. It is parameterized by a `Categorical` + "selecting distribution" (over `k` component) and a component + distribution, i.e., a `Distribution` with a rightmost batch shape + (equal to `[k]`) which indexes each (batch of) component. + + Examples:: + + >>> # xdoctest: +SKIP("undefined vars") + >>> # Construct Gaussian Mixture Model in 1D consisting of 5 equally + >>> # weighted normal distributions + >>> mix = D.Categorical(torch.ones(5,)) + >>> comp = D.Normal(torch.randn(5,), torch.rand(5,)) + >>> gmm = MixtureSameFamily(mix, comp) + + >>> # Construct Gaussian Mixture Model in 2D consisting of 5 equally + >>> # weighted bivariate normal distributions + >>> mix = D.Categorical(torch.ones(5,)) + >>> comp = D.Independent(D.Normal( + ... torch.randn(5,2), torch.rand(5,2)), 1) + >>> gmm = MixtureSameFamily(mix, comp) + + >>> # Construct a batch of 3 Gaussian Mixture Models in 2D each + >>> # consisting of 5 random weighted bivariate normal distributions + >>> mix = D.Categorical(torch.rand(3,5)) + >>> comp = D.Independent(D.Normal( + ... torch.randn(3,5,2), torch.rand(3,5,2)), 1) + >>> gmm = MixtureSameFamily(mix, comp) + + Args: + mixture_distribution: `torch.distributions.Categorical`-like + instance. Manages the probability of selecting component. + The number of categories must match the rightmost batch + dimension of the `component_distribution`. Must have either + scalar `batch_shape` or `batch_shape` matching + `component_distribution.batch_shape[:-1]` + component_distribution: `torch.distributions.Distribution`-like + instance. Right-most batch dimension indexes component. + """ + arg_constraints: Dict[str, constraints.Constraint] = {} + has_rsample = False + + def __init__( + self, mixture_distribution, component_distribution, validate_args=None + ): + self._mixture_distribution = mixture_distribution + self._component_distribution = component_distribution + + if not isinstance(self._mixture_distribution, Categorical): + raise ValueError( + " The Mixture distribution needs to be an " + " instance of torch.distributions.Categorical" + ) + + if not isinstance(self._component_distribution, Distribution): + raise ValueError( + "The Component distribution need to be an " + "instance of torch.distributions.Distribution" + ) + + # Check that batch size matches + mdbs = self._mixture_distribution.batch_shape + cdbs = self._component_distribution.batch_shape[:-1] + for size1, size2 in zip(reversed(mdbs), reversed(cdbs)): + if size1 != 1 and size2 != 1 and size1 != size2: + raise ValueError( + f"`mixture_distribution.batch_shape` ({mdbs}) is not " + "compatible with `component_distribution." + f"batch_shape`({cdbs})" + ) + + # Check that the number of mixture component matches + km = self._mixture_distribution.logits.shape[-1] + kc = self._component_distribution.batch_shape[-1] + if km is not None and kc is not None and km != kc: + raise ValueError( + f"`mixture_distribution component` ({km}) does not" + " equal `component_distribution.batch_shape[-1]`" + f" ({kc})" + ) + self._num_component = km + + event_shape = self._component_distribution.event_shape + self._event_ndims = len(event_shape) + super().__init__( + batch_shape=cdbs, event_shape=event_shape, validate_args=validate_args + ) + + def expand(self, batch_shape, _instance=None): + batch_shape = torch.Size(batch_shape) + batch_shape_comp = batch_shape + (self._num_component,) + new = self._get_checked_instance(MixtureSameFamily, _instance) + new._component_distribution = self._component_distribution.expand( + batch_shape_comp + ) + new._mixture_distribution = self._mixture_distribution.expand(batch_shape) + new._num_component = self._num_component + new._event_ndims = self._event_ndims + event_shape = new._component_distribution.event_shape + super(MixtureSameFamily, new).__init__( + batch_shape=batch_shape, event_shape=event_shape, validate_args=False + ) + new._validate_args = self._validate_args + return new + + @constraints.dependent_property + def support(self): + # FIXME this may have the wrong shape when support contains batched + # parameters + return self._component_distribution.support + + @property + def mixture_distribution(self): + return self._mixture_distribution + + @property + def component_distribution(self): + return self._component_distribution + + @property + def mean(self): + probs = self._pad_mixture_dimensions(self.mixture_distribution.probs) + return torch.sum( + probs * self.component_distribution.mean, dim=-1 - self._event_ndims + ) # [B, E] + + @property + def variance(self): + # Law of total variance: Var(Y) = E[Var(Y|X)] + Var(E[Y|X]) + probs = self._pad_mixture_dimensions(self.mixture_distribution.probs) + mean_cond_var = torch.sum( + probs * self.component_distribution.variance, dim=-1 - self._event_ndims + ) + var_cond_mean = torch.sum( + probs * (self.component_distribution.mean - self._pad(self.mean)).pow(2.0), + dim=-1 - self._event_ndims, + ) + return mean_cond_var + var_cond_mean + + def cdf(self, x): + x = self._pad(x) + cdf_x = self.component_distribution.cdf(x) + mix_prob = self.mixture_distribution.probs + + return torch.sum(cdf_x * mix_prob, dim=-1) + + def log_prob(self, x): + if self._validate_args: + self._validate_sample(x) + x = self._pad(x) + log_prob_x = self.component_distribution.log_prob(x) # [S, B, k] + log_mix_prob = torch.log_softmax( + self.mixture_distribution.logits, dim=-1 + ) # [B, k] + return torch.logsumexp(log_prob_x + log_mix_prob, dim=-1) # [S, B] + + def sample(self, sample_shape=torch.Size()): + with torch.no_grad(): + sample_len = len(sample_shape) + batch_len = len(self.batch_shape) + gather_dim = sample_len + batch_len + es = self.event_shape + + # mixture samples [n, B] + mix_sample = self.mixture_distribution.sample(sample_shape) + mix_shape = mix_sample.shape + + # component samples [n, B, k, E] + comp_samples = self.component_distribution.sample(sample_shape) + + # Gather along the k dimension + mix_sample_r = mix_sample.reshape( + mix_shape + torch.Size([1] * (len(es) + 1)) + ) + mix_sample_r = mix_sample_r.repeat( + torch.Size([1] * len(mix_shape)) + torch.Size([1]) + es + ) + + samples = torch.gather(comp_samples, gather_dim, mix_sample_r) + return samples.squeeze(gather_dim) + + def _pad(self, x): + return x.unsqueeze(-1 - self._event_ndims) + + def _pad_mixture_dimensions(self, x): + dist_batch_ndims = len(self.batch_shape) + cat_batch_ndims = len(self.mixture_distribution.batch_shape) + pad_ndims = 0 if cat_batch_ndims == 1 else dist_batch_ndims - cat_batch_ndims + xs = x.shape + x = x.reshape( + xs[:-1] + + torch.Size(pad_ndims * [1]) + + xs[-1:] + + torch.Size(self._event_ndims * [1]) + ) + return x + + def __repr__(self): + args_string = ( + f"\n {self.mixture_distribution},\n {self.component_distribution}" + ) + return "MixtureSameFamily" + "(" + args_string + ")" diff --git a/shared/package-files/30/30fb32b3f930fa6daef559c986efab538613900dde62821430daebdbd1609586/blob b/shared/package-files/30/30fb32b3f930fa6daef559c986efab538613900dde62821430daebdbd1609586/blob new file mode 100644 index 0000000000000000000000000000000000000000..0c5bac38a8c52d8cd4e460ccaaf24a8e75a7be05 --- /dev/null +++ b/shared/package-files/30/30fb32b3f930fa6daef559c986efab538613900dde62821430daebdbd1609586/blob @@ -0,0 +1,25 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor polygamma(int64_t n, const at::Tensor & self); +TORCH_API at::Tensor & polygamma_out(at::Tensor & out, int64_t n, const at::Tensor & self); +TORCH_API at::Tensor & polygamma_outf(int64_t n, const at::Tensor & self, at::Tensor & out); + +} // namespace cuda +} // namespace at diff --git a/shared/package-files/30/30fd5bc89c2eb2364a466ceccb47cc05193349cbab1b6faae7ca6e685e931745/blob b/shared/package-files/30/30fd5bc89c2eb2364a466ceccb47cc05193349cbab1b6faae7ca6e685e931745/blob new file mode 100644 index 0000000000000000000000000000000000000000..70795a76aad88cdb3a6477911b610805b70fce01 --- /dev/null +++ b/shared/package-files/30/30fd5bc89c2eb2364a466ceccb47cc05193349cbab1b6faae7ca6e685e931745/blob @@ -0,0 +1,870 @@ +""" +Finite Discrete Random Variables - Prebuilt variable types + +Contains +======== +FiniteRV +DiscreteUniform +Die +Bernoulli +Coin +Binomial +BetaBinomial +Hypergeometric +Rademacher +IdealSoliton +RobustSoliton +""" + + +from sympy.core.cache import cacheit +from sympy.core.function import Lambda +from sympy.core.numbers import (Integer, Rational) +from sympy.core.relational import (Eq, Ge, Gt, Le, Lt) +from sympy.core.singleton import S +from sympy.core.symbol import (Dummy, Symbol) +from sympy.core.sympify import sympify +from sympy.functions.combinatorial.factorials import binomial +from sympy.functions.elementary.exponential import log +from sympy.functions.elementary.piecewise import Piecewise +from sympy.logic.boolalg import Or +from sympy.sets.contains import Contains +from sympy.sets.fancysets import Range +from sympy.sets.sets import (Intersection, Interval) +from sympy.functions.special.beta_functions import beta as beta_fn +from sympy.stats.frv import (SingleFiniteDistribution, + SingleFinitePSpace) +from sympy.stats.rv import _value_check, Density, is_random +from sympy.utilities.iterables import multiset +from sympy.utilities.misc import filldedent + + +__all__ = ['FiniteRV', +'DiscreteUniform', +'Die', +'Bernoulli', +'Coin', +'Binomial', +'BetaBinomial', +'Hypergeometric', +'Rademacher', +'IdealSoliton', +'RobustSoliton', +] + +def rv(name, cls, *args, **kwargs): + args = list(map(sympify, args)) + dist = cls(*args) + if kwargs.pop('check', True): + dist.check(*args) + pspace = SingleFinitePSpace(name, dist) + if any(is_random(arg) for arg in args): + from sympy.stats.compound_rv import CompoundPSpace, CompoundDistribution + pspace = CompoundPSpace(name, CompoundDistribution(dist)) + return pspace.value + +class FiniteDistributionHandmade(SingleFiniteDistribution): + + @property + def dict(self): + return self.args[0] + + def pmf(self, x): + x = Symbol('x') + return Lambda(x, Piecewise(*( + [(v, Eq(k, x)) for k, v in self.dict.items()] + [(S.Zero, True)]))) + + @property + def set(self): + return set(self.dict.keys()) + + @staticmethod + def check(density): + for p in density.values(): + _value_check((p >= 0, p <= 1), + "Probability at a point must be between 0 and 1.") + val = sum(density.values()) + _value_check(Eq(val, 1) != S.false, "Total Probability must be 1.") + +def FiniteRV(name, density, **kwargs): + r""" + Create a Finite Random Variable given a dict representing the density. + + Parameters + ========== + + name : Symbol + Represents name of the random variable. + density : dict + Dictionary containing the pdf of finite distribution + check : bool + If True, it will check whether the given density + integrates to 1 over the given set. If False, it + will not perform this check. Default is False. + + Examples + ======== + + >>> from sympy.stats import FiniteRV, P, E + + >>> density = {0: .1, 1: .2, 2: .3, 3: .4} + >>> X = FiniteRV('X', density) + + >>> E(X) + 2.00000000000000 + >>> P(X >= 2) + 0.700000000000000 + + Returns + ======= + + RandomSymbol + + """ + # have a default of False while `rv` should have a default of True + kwargs['check'] = kwargs.pop('check', False) + return rv(name, FiniteDistributionHandmade, density, **kwargs) + +class DiscreteUniformDistribution(SingleFiniteDistribution): + + @staticmethod + def check(*args): + # not using _value_check since there is a + # suggestion for the user + if len(set(args)) != len(args): + weights = multiset(args) + n = Integer(len(args)) + for k in weights: + weights[k] /= n + raise ValueError(filldedent(""" + Repeated args detected but set expected. For a + distribution having different weights for each + item use the following:""") + ( + '\nS("FiniteRV(%s, %s)")' % ("'X'", weights))) + + @property + def p(self): + return Rational(1, len(self.args)) + + @property # type: ignore + @cacheit + def dict(self): + return {k: self.p for k in self.set} + + @property + def set(self): + return set(self.args) + + def pmf(self, x): + if x in self.args: + return self.p + else: + return S.Zero + + +def DiscreteUniform(name, items): + r""" + Create a Finite Random Variable representing a uniform distribution over + the input set. + + Parameters + ========== + + items : list/tuple + Items over which Uniform distribution is to be made + + Examples + ======== + + >>> from sympy.stats import DiscreteUniform, density + >>> from sympy import symbols + + >>> X = DiscreteUniform('X', symbols('a b c')) # equally likely over a, b, c + >>> density(X).dict + {a: 1/3, b: 1/3, c: 1/3} + + >>> Y = DiscreteUniform('Y', list(range(5))) # distribution over a range + >>> density(Y).dict + {0: 1/5, 1: 1/5, 2: 1/5, 3: 1/5, 4: 1/5} + + Returns + ======= + + RandomSymbol + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Discrete_uniform_distribution + .. [2] https://mathworld.wolfram.com/DiscreteUniformDistribution.html + + """ + return rv(name, DiscreteUniformDistribution, *items) + + +class DieDistribution(SingleFiniteDistribution): + _argnames = ('sides',) + + @staticmethod + def check(sides): + _value_check((sides.is_positive, sides.is_integer), + "number of sides must be a positive integer.") + + @property + def is_symbolic(self): + return not self.sides.is_number + + @property + def high(self): + return self.sides + + @property + def low(self): + return S.One + + @property + def set(self): + if self.is_symbolic: + return Intersection(S.Naturals0, Interval(0, self.sides)) + return set(map(Integer, range(1, self.sides + 1))) + + def pmf(self, x): + x = sympify(x) + if not (x.is_number or x.is_Symbol or is_random(x)): + raise ValueError("'x' expected as an argument of type 'number', 'Symbol', or " + "'RandomSymbol' not %s" % (type(x))) + cond = Ge(x, 1) & Le(x, self.sides) & Contains(x, S.Integers) + return Piecewise((S.One/self.sides, cond), (S.Zero, True)) + +def Die(name, sides=6): + r""" + Create a Finite Random Variable representing a fair die. + + Parameters + ========== + + sides : Integer + Represents the number of sides of the Die, by default is 6 + + Examples + ======== + + >>> from sympy.stats import Die, density + >>> from sympy import Symbol + + >>> D6 = Die('D6', 6) # Six sided Die + >>> density(D6).dict + {1: 1/6, 2: 1/6, 3: 1/6, 4: 1/6, 5: 1/6, 6: 1/6} + + >>> D4 = Die('D4', 4) # Four sided Die + >>> density(D4).dict + {1: 1/4, 2: 1/4, 3: 1/4, 4: 1/4} + + >>> n = Symbol('n', positive=True, integer=True) + >>> Dn = Die('Dn', n) # n sided Die + >>> density(Dn).dict + Density(DieDistribution(n)) + >>> density(Dn).dict.subs(n, 4).doit() + {1: 1/4, 2: 1/4, 3: 1/4, 4: 1/4} + + Returns + ======= + + RandomSymbol + """ + + return rv(name, DieDistribution, sides) + + +class BernoulliDistribution(SingleFiniteDistribution): + _argnames = ('p', 'succ', 'fail') + + @staticmethod + def check(p, succ, fail): + _value_check((p >= 0, p <= 1), + "p should be in range [0, 1].") + + @property + def set(self): + return {self.succ, self.fail} + + def pmf(self, x): + if isinstance(self.succ, Symbol) and isinstance(self.fail, Symbol): + return Piecewise((self.p, x == self.succ), + (1 - self.p, x == self.fail), + (S.Zero, True)) + return Piecewise((self.p, Eq(x, self.succ)), + (1 - self.p, Eq(x, self.fail)), + (S.Zero, True)) + + +def Bernoulli(name, p, succ=1, fail=0): + r""" + Create a Finite Random Variable representing a Bernoulli process. + + Parameters + ========== + + p : Rational number between 0 and 1 + Represents probability of success + succ : Integer/symbol/string + Represents event of success + fail : Integer/symbol/string + Represents event of failure + + Examples + ======== + + >>> from sympy.stats import Bernoulli, density + >>> from sympy import S + + >>> X = Bernoulli('X', S(3)/4) # 1-0 Bernoulli variable, probability = 3/4 + >>> density(X).dict + {0: 1/4, 1: 3/4} + + >>> X = Bernoulli('X', S.Half, 'Heads', 'Tails') # A fair coin toss + >>> density(X).dict + {Heads: 1/2, Tails: 1/2} + + Returns + ======= + + RandomSymbol + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Bernoulli_distribution + .. [2] https://mathworld.wolfram.com/BernoulliDistribution.html + + """ + + return rv(name, BernoulliDistribution, p, succ, fail) + + +def Coin(name, p=S.Half): + r""" + Create a Finite Random Variable representing a Coin toss. + + Parameters + ========== + + p : Rational Number between 0 and 1 + Represents probability of getting "Heads", by default is Half + + Examples + ======== + + >>> from sympy.stats import Coin, density + >>> from sympy import Rational + + >>> C = Coin('C') # A fair coin toss + >>> density(C).dict + {H: 1/2, T: 1/2} + + >>> C2 = Coin('C2', Rational(3, 5)) # An unfair coin + >>> density(C2).dict + {H: 3/5, T: 2/5} + + Returns + ======= + + RandomSymbol + + See Also + ======== + + sympy.stats.Binomial + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Coin_flipping + + """ + return rv(name, BernoulliDistribution, p, 'H', 'T') + + +class BinomialDistribution(SingleFiniteDistribution): + _argnames = ('n', 'p', 'succ', 'fail') + + @staticmethod + def check(n, p, succ, fail): + _value_check((n.is_integer, n.is_nonnegative), + "'n' must be nonnegative integer.") + _value_check((p <= 1, p >= 0), + "p should be in range [0, 1].") + + @property + def high(self): + return self.n + + @property + def low(self): + return S.Zero + + @property + def is_symbolic(self): + return not self.n.is_number + + @property + def set(self): + if self.is_symbolic: + return Intersection(S.Naturals0, Interval(0, self.n)) + return set(self.dict.keys()) + + def pmf(self, x): + n, p = self.n, self.p + x = sympify(x) + if not (x.is_number or x.is_Symbol or is_random(x)): + raise ValueError("'x' expected as an argument of type 'number', 'Symbol', or " + "'RandomSymbol' not %s" % (type(x))) + cond = Ge(x, 0) & Le(x, n) & Contains(x, S.Integers) + return Piecewise((binomial(n, x) * p**x * (1 - p)**(n - x), cond), (S.Zero, True)) + + @property # type: ignore + @cacheit + def dict(self): + if self.is_symbolic: + return Density(self) + return {k*self.succ + (self.n-k)*self.fail: self.pmf(k) + for k in range(0, self.n + 1)} + + +def Binomial(name, n, p, succ=1, fail=0): + r""" + Create a Finite Random Variable representing a binomial distribution. + + Parameters + ========== + + n : Positive Integer + Represents number of trials + p : Rational Number between 0 and 1 + Represents probability of success + succ : Integer/symbol/string + Represents event of success, by default is 1 + fail : Integer/symbol/string + Represents event of failure, by default is 0 + + Examples + ======== + + >>> from sympy.stats import Binomial, density + >>> from sympy import S, Symbol + + >>> X = Binomial('X', 4, S.Half) # Four "coin flips" + >>> density(X).dict + {0: 1/16, 1: 1/4, 2: 3/8, 3: 1/4, 4: 1/16} + + >>> n = Symbol('n', positive=True, integer=True) + >>> p = Symbol('p', positive=True) + >>> X = Binomial('X', n, S.Half) # n "coin flips" + >>> density(X).dict + Density(BinomialDistribution(n, 1/2, 1, 0)) + >>> density(X).dict.subs(n, 4).doit() + {0: 1/16, 1: 1/4, 2: 3/8, 3: 1/4, 4: 1/16} + + Returns + ======= + + RandomSymbol + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Binomial_distribution + .. [2] https://mathworld.wolfram.com/BinomialDistribution.html + + """ + + return rv(name, BinomialDistribution, n, p, succ, fail) + +#------------------------------------------------------------------------------- +# Beta-binomial distribution ---------------------------------------------------------- + +class BetaBinomialDistribution(SingleFiniteDistribution): + _argnames = ('n', 'alpha', 'beta') + + @staticmethod + def check(n, alpha, beta): + _value_check((n.is_integer, n.is_nonnegative), + "'n' must be nonnegative integer. n = %s." % str(n)) + _value_check((alpha > 0), + "'alpha' must be: alpha > 0 . alpha = %s" % str(alpha)) + _value_check((beta > 0), + "'beta' must be: beta > 0 . beta = %s" % str(beta)) + + @property + def high(self): + return self.n + + @property + def low(self): + return S.Zero + + @property + def is_symbolic(self): + return not self.n.is_number + + @property + def set(self): + if self.is_symbolic: + return Intersection(S.Naturals0, Interval(0, self.n)) + return set(map(Integer, range(self.n + 1))) + + def pmf(self, k): + n, a, b = self.n, self.alpha, self.beta + return binomial(n, k) * beta_fn(k + a, n - k + b) / beta_fn(a, b) + + +def BetaBinomial(name, n, alpha, beta): + r""" + Create a Finite Random Variable representing a Beta-binomial distribution. + + Parameters + ========== + + n : Positive Integer + Represents number of trials + alpha : Real positive number + beta : Real positive number + + Examples + ======== + + >>> from sympy.stats import BetaBinomial, density + + >>> X = BetaBinomial('X', 2, 1, 1) + >>> density(X).dict + {0: 1/3, 1: 2*beta(2, 2), 2: 1/3} + + Returns + ======= + + RandomSymbol + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Beta-binomial_distribution + .. [2] https://mathworld.wolfram.com/BetaBinomialDistribution.html + + """ + + return rv(name, BetaBinomialDistribution, n, alpha, beta) + + +class HypergeometricDistribution(SingleFiniteDistribution): + _argnames = ('N', 'm', 'n') + + @staticmethod + def check(n, N, m): + _value_check((N.is_integer, N.is_nonnegative), + "'N' must be nonnegative integer. N = %s." % str(n)) + _value_check((n.is_integer, n.is_nonnegative), + "'n' must be nonnegative integer. n = %s." % str(n)) + _value_check((m.is_integer, m.is_nonnegative), + "'m' must be nonnegative integer. m = %s." % str(n)) + + @property + def is_symbolic(self): + return not all(x.is_number for x in (self.N, self.m, self.n)) + + @property + def high(self): + return Piecewise((self.n, Lt(self.n, self.m) != False), (self.m, True)) + + @property + def low(self): + return Piecewise((0, Gt(0, self.n + self.m - self.N) != False), (self.n + self.m - self.N, True)) + + @property + def set(self): + N, m, n = self.N, self.m, self.n + if self.is_symbolic: + return Intersection(S.Naturals0, Interval(self.low, self.high)) + return set(range(max(0, n + m - N), min(n, m) + 1)) + + def pmf(self, k): + N, m, n = self.N, self.m, self.n + return S(binomial(m, k) * binomial(N - m, n - k))/binomial(N, n) + + +def Hypergeometric(name, N, m, n): + r""" + Create a Finite Random Variable representing a hypergeometric distribution. + + Parameters + ========== + + N : Positive Integer + Represents finite population of size N. + m : Positive Integer + Represents number of trials with required feature. + n : Positive Integer + Represents numbers of draws. + + + Examples + ======== + + >>> from sympy.stats import Hypergeometric, density + + >>> X = Hypergeometric('X', 10, 5, 3) # 10 marbles, 5 white (success), 3 draws + >>> density(X).dict + {0: 1/12, 1: 5/12, 2: 5/12, 3: 1/12} + + Returns + ======= + + RandomSymbol + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Hypergeometric_distribution + .. [2] https://mathworld.wolfram.com/HypergeometricDistribution.html + + """ + return rv(name, HypergeometricDistribution, N, m, n) + + +class RademacherDistribution(SingleFiniteDistribution): + + @property + def set(self): + return {-1, 1} + + @property + def pmf(self): + k = Dummy('k') + return Lambda(k, Piecewise((S.Half, Or(Eq(k, -1), Eq(k, 1))), (S.Zero, True))) + +def Rademacher(name): + r""" + Create a Finite Random Variable representing a Rademacher distribution. + + Examples + ======== + + >>> from sympy.stats import Rademacher, density + + >>> X = Rademacher('X') + >>> density(X).dict + {-1: 1/2, 1: 1/2} + + Returns + ======= + + RandomSymbol + + See Also + ======== + + sympy.stats.Bernoulli + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Rademacher_distribution + + """ + return rv(name, RademacherDistribution) + +class IdealSolitonDistribution(SingleFiniteDistribution): + _argnames = ('k',) + + @staticmethod + def check(k): + _value_check(k.is_integer and k.is_positive, + "'k' must be a positive integer.") + + @property + def low(self): + return S.One + + @property + def high(self): + return self.k + + @property + def set(self): + return set(map(Integer, range(1, self.k + 1))) + + @property # type: ignore + @cacheit + def dict(self): + if self.k.is_Symbol: + return Density(self) + d = {1: Rational(1, self.k)} + d.update({i: Rational(1, i*(i - 1)) for i in range(2, self.k + 1)}) + return d + + def pmf(self, x): + x = sympify(x) + if not (x.is_number or x.is_Symbol or is_random(x)): + raise ValueError("'x' expected as an argument of type 'number', 'Symbol', or " + "'RandomSymbol' not %s" % (type(x))) + cond1 = Eq(x, 1) & x.is_integer + cond2 = Ge(x, 1) & Le(x, self.k) & x.is_integer + return Piecewise((1/self.k, cond1), (1/(x*(x - 1)), cond2), (S.Zero, True)) + +def IdealSoliton(name, k): + r""" + Create a Finite Random Variable of Ideal Soliton Distribution + + Parameters + ========== + + k : Positive Integer + Represents the number of input symbols in an LT (Luby Transform) code. + + Examples + ======== + + >>> from sympy.stats import IdealSoliton, density, P, E + >>> sol = IdealSoliton('sol', 5) + >>> density(sol).dict + {1: 1/5, 2: 1/2, 3: 1/6, 4: 1/12, 5: 1/20} + >>> density(sol).set + {1, 2, 3, 4, 5} + + >>> from sympy import Symbol + >>> k = Symbol('k', positive=True, integer=True) + >>> sol = IdealSoliton('sol', k) + >>> density(sol).dict + Density(IdealSolitonDistribution(k)) + >>> density(sol).dict.subs(k, 10).doit() + {1: 1/10, 2: 1/2, 3: 1/6, 4: 1/12, 5: 1/20, 6: 1/30, 7: 1/42, 8: 1/56, 9: 1/72, 10: 1/90} + + >>> E(sol.subs(k, 10)) + 7381/2520 + + >>> P(sol.subs(k, 4) > 2) + 1/4 + + Returns + ======= + + RandomSymbol + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Soliton_distribution#Ideal_distribution + .. [2] https://pages.cs.wisc.edu/~suman/courses/740/papers/luby02lt.pdf + + """ + return rv(name, IdealSolitonDistribution, k) + +class RobustSolitonDistribution(SingleFiniteDistribution): + _argnames= ('k', 'delta', 'c') + + @staticmethod + def check(k, delta, c): + _value_check(k.is_integer and k.is_positive, + "'k' must be a positive integer") + _value_check(Gt(delta, 0) and Le(delta, 1), + "'delta' must be a real number in the interval (0,1)") + _value_check(c.is_positive, + "'c' must be a positive real number.") + + @property + def R(self): + return self.c * log(self.k/self.delta) * self.k**0.5 + + @property + def Z(self): + z = 0 + for i in Range(1, round(self.k/self.R)): + z += (1/i) + z += log(self.R/self.delta) + return 1 + z * self.R/self.k + + @property + def low(self): + return S.One + + @property + def high(self): + return self.k + + @property + def set(self): + return set(map(Integer, range(1, self.k + 1))) + + @property + def is_symbolic(self): + return not (self.k.is_number and self.c.is_number and self.delta.is_number) + + def pmf(self, x): + x = sympify(x) + if not (x.is_number or x.is_Symbol or is_random(x)): + raise ValueError("'x' expected as an argument of type 'number', 'Symbol', or " + "'RandomSymbol' not %s" % (type(x))) + + cond1 = Eq(x, 1) & x.is_integer + cond2 = Ge(x, 1) & Le(x, self.k) & x.is_integer + rho = Piecewise((Rational(1, self.k), cond1), (Rational(1, x*(x-1)), cond2), (S.Zero, True)) + + cond1 = Ge(x, 1) & Le(x, round(self.k/self.R)-1) + cond2 = Eq(x, round(self.k/self.R)) + tau = Piecewise((self.R/(self.k * x), cond1), (self.R * log(self.R/self.delta)/self.k, cond2), (S.Zero, True)) + + return (rho + tau)/self.Z + +def RobustSoliton(name, k, delta, c): + r''' + Create a Finite Random Variable of Robust Soliton Distribution + + Parameters + ========== + + k : Positive Integer + Represents the number of input symbols in an LT (Luby Transform) code. + delta : Positive Rational Number + Represents the failure probability. Must be in the interval (0,1). + c : Positive Rational Number + Constant of proportionality. Values close to 1 are recommended + + Examples + ======== + + >>> from sympy.stats import RobustSoliton, density, P, E + >>> robSol = RobustSoliton('robSol', 5, 0.5, 0.01) + >>> density(robSol).dict + {1: 0.204253668152708, 2: 0.490631107897393, 3: 0.165210624506162, 4: 0.0834387731899302, 5: 0.0505633404760675} + >>> density(robSol).set + {1, 2, 3, 4, 5} + + >>> from sympy import Symbol + >>> k = Symbol('k', positive=True, integer=True) + >>> c = Symbol('c', positive=True) + >>> robSol = RobustSoliton('robSol', k, 0.5, c) + >>> density(robSol).dict + Density(RobustSolitonDistribution(k, 0.5, c)) + >>> density(robSol).dict.subs(k, 10).subs(c, 0.03).doit() + {1: 0.116641095387194, 2: 0.467045731687165, 3: 0.159984123349381, 4: 0.0821431680681869, 5: 0.0505765646770100, + 6: 0.0345781523420719, 7: 0.0253132820710503, 8: 0.0194459129233227, 9: 0.0154831166726115, 10: 0.0126733075238887} + + >>> E(robSol.subs(k, 10).subs(c, 0.05)) + 2.91358846104106 + + >>> P(robSol.subs(k, 4).subs(c, 0.1) > 2) + 0.243650614389834 + + Returns + ======= + + RandomSymbol + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Soliton_distribution#Robust_distribution + .. [2] https://www.inference.org.uk/mackay/itprnn/ps/588.596.pdf + .. [3] https://pages.cs.wisc.edu/~suman/courses/740/papers/luby02lt.pdf + + ''' + return rv(name, RobustSolitonDistribution, k, delta, c) diff --git a/shared/package-files/30/30fef4a94c20b214ed4e12996990e9effe94f99eba34857581e5616ac1977a34/blob b/shared/package-files/30/30fef4a94c20b214ed4e12996990e9effe94f99eba34857581e5616ac1977a34/blob new file mode 100644 index 0000000000000000000000000000000000000000..a772bb388847404a0497efa3a6b4fd241c5ec8a8 --- /dev/null +++ b/shared/package-files/30/30fef4a94c20b214ed4e12996990e9effe94f99eba34857581e5616ac1977a34/blob @@ -0,0 +1,17 @@ +import numpy as np +from numpy.testing import assert_equal + +class TestDot: + def test_matscalar(self): + b1 = np.matrix(np.ones((3, 3), dtype=complex)) + assert_equal(b1*1.0, b1) + + +def test_diagonal(): + b1 = np.matrix([[1,2],[3,4]]) + diag_b1 = np.matrix([[1, 4]]) + array_b1 = np.array([1, 4]) + + assert_equal(b1.diagonal(), diag_b1) + assert_equal(np.diagonal(b1), array_b1) + assert_equal(np.diag(b1), array_b1) diff --git a/shared/package-files/31/310079b38295a29a2bd55d4282f17a959354497e9970e4b6fc7e494587fb7a65/blob b/shared/package-files/31/310079b38295a29a2bd55d4282f17a959354497e9970e4b6fc7e494587fb7a65/blob new file mode 100644 index 0000000000000000000000000000000000000000..14e247332503253ede23e94fe1335e712a2675e7 --- /dev/null +++ b/shared/package-files/31/310079b38295a29a2bd55d4282f17a959354497e9970e4b6fc7e494587fb7a65/blob @@ -0,0 +1,76 @@ +import numpy as np + +from pandas import ( + Categorical, + IntervalIndex, + Series, + date_range, +) +import pandas._testing as tm + + +class TestUnique: + def test_unique_uint64(self): + ser = Series([1, 2, 2**63, 2**63], dtype=np.uint64) + res = ser.unique() + exp = np.array([1, 2, 2**63], dtype=np.uint64) + tm.assert_numpy_array_equal(res, exp) + + def test_unique_data_ownership(self): + # it works! GH#1807 + Series(Series(["a", "c", "b"]).unique()).sort_values() + + def test_unique(self): + # GH#714 also, dtype=float + ser = Series([1.2345] * 100) + ser[::2] = np.nan + result = ser.unique() + assert len(result) == 2 + + # explicit f4 dtype + ser = Series([1.2345] * 100, dtype="f4") + ser[::2] = np.nan + result = ser.unique() + assert len(result) == 2 + + def test_unique_nan_object_dtype(self): + # NAs in object arrays GH#714 + ser = Series(["foo"] * 100, dtype="O") + ser[::2] = np.nan + result = ser.unique() + assert len(result) == 2 + + def test_unique_none(self): + # decision about None + ser = Series([1, 2, 3, None, None, None], dtype=object) + result = ser.unique() + expected = np.array([1, 2, 3, None], dtype=object) + tm.assert_numpy_array_equal(result, expected) + + def test_unique_categorical(self): + # GH#18051 + cat = Categorical([]) + ser = Series(cat) + result = ser.unique() + tm.assert_categorical_equal(result, cat) + + cat = Categorical([np.nan]) + ser = Series(cat) + result = ser.unique() + tm.assert_categorical_equal(result, cat) + + def test_tz_unique(self): + # GH 46128 + dti1 = date_range("2016-01-01", periods=3) + ii1 = IntervalIndex.from_breaks(dti1) + ser1 = Series(ii1) + uni1 = ser1.unique() + tm.assert_interval_array_equal(ser1.array, uni1) + + dti2 = date_range("2016-01-01", periods=3, tz="US/Eastern") + ii2 = IntervalIndex.from_breaks(dti2) + ser2 = Series(ii2) + uni2 = ser2.unique() + tm.assert_interval_array_equal(ser2.array, uni2) + + assert uni1.dtype != uni2.dtype diff --git a/shared/package-files/31/3101559f62839fa4970d253a9f4b00cdccb4e9d21554420b793553cac605a26f/blob b/shared/package-files/31/3101559f62839fa4970d253a9f4b00cdccb4e9d21554420b793553cac605a26f/blob new file mode 100644 index 0000000000000000000000000000000000000000..0a38a89cc5bec9095dcc522e1d530bebb2899885 --- /dev/null +++ b/shared/package-files/31/3101559f62839fa4970d253a9f4b00cdccb4e9d21554420b793553cac605a26f/blob @@ -0,0 +1,713 @@ +from __future__ import annotations + +import os +from typing import TYPE_CHECKING, Final, Literal, overload +from urllib.request import urlretrieve + +import numpy as np +import pandas as pd +import sklearn.datasets + +import shap + +if TYPE_CHECKING: # pragma: no cover + import scipy.sparse as ssp + +github_data_url: Final[str] = "https://github.com/shap/shap/raw/master/data/" + + +def imagenet50(resolution: int = 224, n_points: int | None = None) -> tuple[np.ndarray, np.ndarray]: + """Return a set of 50 images representative of ImageNet images. + + Parameters + ---------- + resolution : int + The resolution of the images. At present, the only supported value is 224. + n_points : int, optional + Number of data points to sample. If None, the entire dataset is used. + + Returns + ------- + X : np.ndarray + Represents images from ImageNet of a certain resolution. + y : np.ndarray + The target variables, that is, the ImageNet classes. + + Notes + ----- + This dataset was collected by randomly finding a working ImageNet link and then pasting the + original ImageNet image into Google image search restricted to images licensed for reuse. A + similar image (now with rights to reuse) was downloaded as a rough replacement for the original + ImageNet image. The point is to have a random sample of ImageNet for use as a background + distribution for explaining models trained on ImageNet data. + + Note that because the images are only rough replacements, the labels might no longer be correct. + + Examples + -------- + To get the processed images and labels:: + + images, labels = shap.datasets.imagenet50() + + """ + prefix = github_data_url + "imagenet50_" + X: np.ndarray = np.load(cache(f"{prefix}{resolution}x{resolution}.npy")).astype(np.float32) + y: np.ndarray = np.loadtxt(cache(f"{prefix}labels.csv")) + + if n_points is not None: + X = shap.utils.sample(X, n_points, random_state=0) + y = shap.utils.sample(y, n_points, random_state=0) + + return X, y + + +def california(n_points: int | None = None) -> tuple[pd.DataFrame, np.ndarray]: + """Return the California housing data in a tabular format. + + Used in predictive regression tasks. + + Parameters + ---------- + n_points : int, optional + Number of data points to sample. If provided, randomly samples the specified number of points. + + Returns + ------- + X : pd.DataFrame + The feature data. + y : np.ndarray + The target variable. + + Notes + ----- + The returned feature matrix ``X`` includes the following features: + + - ``MedInc`` (float): Median income in block + - ``HouseAge`` (float): Median house age in block + - ``AveRooms`` (float): Average rooms in dwelling + - ``AveBedrms`` (float): Average bedrooms in dwelling + - ``Population`` (float): Block population + - ``AveOccup`` (float): Average house occupancy + - ``Latitude`` (float): House block latitude + - ``Longitude`` (float): House block longitude + + The target column represents the median house value for California districts. + + References + ---------- + California housing dataset: :external+scikit-learn:func:`sklearn.datasets.fetch_california_housing` + + Examples + -------- + To get the processed data and target labels:: + + data, target = shap.datasets.california() + + """ + d = sklearn.datasets.fetch_california_housing() + df = pd.DataFrame(data=d.data, columns=d.feature_names) + target: np.ndarray = d.target + + if n_points is not None: + df = shap.utils.sample(df, n_points, random_state=0) + target = shap.utils.sample(target, n_points, random_state=0) + + return df, target + + +def linnerud(n_points: int | None = None) -> tuple[pd.DataFrame, pd.DataFrame]: + """Return the Linnerud dataset in a convenient package for multi-target regression. + + Parameters + ---------- + n_points : int, optional + Number of data points to sample. If provided, randomly samples the specified number + of points. + + Returns + ------- + X : pd.DataFrame + The feature data. + y : pd.DataFrame + The multiclass target variables. + + Notes + ----- + - The Linnerud dataset contains physiological and exercise data for 20 individuals. + - The feature matrix ``X`` includes three exercise variables: ``Chins``, ``Situps``, ``Jumps``. + - The target variables ``y`` include three physiological measurements: ``Weight``, ``Waist``, ``Pulse``. + + More details: :external+scikit-learn:func:`sklearn.datasets.load_linnerud` + + Examples + -------- + To get the feature matrix and target variables:: + + features, targets = shap.datasets.linnerud() + + To get a subset of the data:: + + subset_features, subset_targets = shap.datasets.linnerud(n_points=100) + + """ + d = sklearn.datasets.load_linnerud() + X = pd.DataFrame(d.data, columns=d.feature_names) + y = pd.DataFrame(d.target, columns=d.target_names) + + if n_points is not None: + X = shap.utils.sample(X, n_points, random_state=0) + y = shap.utils.sample(y, n_points, random_state=0) + + return X, y + + +def imdb(n_points: int | None = None) -> tuple[list[str], np.ndarray]: + """Return the classic IMDB sentiment analysis training data in a nice package. + + Used in binary text classification tasks. + + Parameters + ---------- + n_points : int, optional + Number of data points to sample. If provided, randomly samples the specified number of points. + + Returns + ------- + X : list of strings + Text data, where each string is a movie review. + y : np.ndarray + The target variable. Contains booleans, where True indicates a positive sentiment and False + indicates a negative sentiment. + + Notes + ----- + Full data is at: http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz + + Paper to cite when using the data is: http://www.aclweb.org/anthology/P11-1015 + + Examples + -------- + To get the processed text data and labels:: + + text_data, labels = shap.datasets.imdb() + + """ + with open(cache(github_data_url + "imdb_train.txt"), encoding="utf-8") as f: + data = f.readlines() + y = np.ones(25000, dtype=bool) + y[:12500] = 0 + + if n_points is not None: + data = shap.utils.sample(data, n_points, random_state=0) + y = shap.utils.sample(y, n_points, random_state=0) + + return data, y + + +def communitiesandcrime(n_points: int | None = None) -> tuple[pd.DataFrame, np.ndarray]: + """Predict the total number of violent crimes per 100K population. + + This dataset is from the classic UCI Machine Learning repository: + https://archive.ics.uci.edu/ml/datasets/Communities+and+Crime+Unnormalized + + Used in predictive regression tasks. + + Parameters + ---------- + n_points : int, optional + Number of data points to sample. If provided, randomly samples the specified number of points. + + Returns + ------- + X : pd.DataFrame + The feature data. + y : np.ndarray + The target variable. + + Examples + -------- + To get the processed data and target labels:: + + data, target = shap.datasets.communitiesandcrime() + + """ + raw_data = pd.read_csv(cache(github_data_url + "CommViolPredUnnormalizedData.txt"), na_values="?") + + # find the indices where the total violent crimes are known + valid_inds = np.where(np.invert(np.isnan(raw_data.iloc[:, -2])))[0] + + if n_points is not None: + valid_inds = shap.utils.sample(valid_inds, n_points, random_state=0) + + y = np.array(raw_data.iloc[valid_inds, -2], dtype=float) + + # extract the predictive features and remove columns with missing values + X = raw_data.iloc[valid_inds, 5:-18] + valid_cols = np.where(np.isnan(X.values).sum(0) == 0)[0] + X = X.iloc[:, valid_cols] + + return X, y + + +def diabetes(n_points: int | None = None) -> tuple[pd.DataFrame, np.ndarray]: + """Return the diabetes data in a nice package. + + Used in predictive regression tasks. + + Parameters + ---------- + n_points : int, optional + Number of data points to sample. If provided, randomly samples the specified number of points. + + Returns + ------- + X : pd.DataFrame + The feature data. + y : np.ndarray + The target variable. + + Notes + ----- + Feature Columns in ``X``: + + - ``age`` (float): Age in years + - ``sex`` (float): Sex + - ``bmi`` (float): Body mass index + - ``bp`` (float): Average blood pressure + - ``s1`` (float): Total serum cholesterol + - ``s2`` (float): Low-density lipoproteins (LDL cholesterol) + - ``s3`` (float): High-density lipoproteins (HDL cholesterol) + - ``s4`` (float): Total cholesterol / HDL cholesterol ratio + - ``s5`` (float): Log of serum triglycerides level + - ``s6`` (float): Blood sugar level + + Target ``y``: + + - Progression of diabetes one year after baseline (float) + + The diabetes dataset is a subset of the larger diabetes dataset from scikit-learn. + More details: :external+scikit-learn:func:`sklearn.datasets.load_diabetes` + + Examples + -------- + To get the processed data and target labels:: + + data, target = shap.datasets.diabetes() + + """ + d = sklearn.datasets.load_diabetes() + df = pd.DataFrame(data=d.data, columns=d.feature_names) + target = d.target + + if n_points is not None: + df = shap.utils.sample(df, n_points, random_state=0) + target = shap.utils.sample(target, n_points, random_state=0) + + return df, target + + +@overload +def iris(display: Literal[False] = ..., n_points: int | None = ...) -> tuple[pd.DataFrame, np.ndarray]: ... +@overload +def iris(display: Literal[True] = ..., n_points: int | None = ...) -> tuple[pd.DataFrame, list[str]]: ... + + +def iris(display: bool = False, n_points: int | None = None) -> tuple[pd.DataFrame, np.ndarray | list[str]]: + """Return the classic Iris dataset in a convenient package. + + Parameters + ---------- + display : bool + If True, return the original feature matrix along with class labels (as strings). Default is False. + n_points : int, optional + Number of data points to sample. If provided, randomly samples the specified number of points. + + Returns + ------- + X : pd.DataFrame + The feature matrix. + y : np.ndarray or a list of strings + If ``display`` is False, a numpy array representing the class labels encoded as integers is returned. + If ``display`` is True, then a list of class labels is returned. + + Notes + ----- + - The dataset includes measurements of sepal length, sepal width, petal length, and petal width for three + species of iris flowers. + - Class labels are encoded as integers (0, 1, 2) representing the species (setosa, versicolor, virginica). + - If ``display`` is True, class labels are returned as strings. + + Examples + -------- + To get the feature matrix and class labels:: + + features, labels = shap.datasets.iris() + + To get the feature matrix and class labels as strings:: + + features, class_labels = shap.datasets.iris(display=True) + + """ + d = sklearn.datasets.load_iris() + df = pd.DataFrame(data=d.data, columns=d.feature_names) + target: np.ndarray = d.target + + if n_points is not None: + df = shap.utils.sample(df, n_points, random_state=0) + target = shap.utils.sample(target, n_points, random_state=0) + + if display: + return df, [str(d.target_names[v]) for v in target] + return df, target + + +def adult(display: bool = False, n_points: int | None = None) -> tuple[pd.DataFrame, np.ndarray]: + """Return the Adult census data in a structured format. + + Used in binary classification tasks. + + Parameters + ---------- + display : bool, optional + If True, return the raw data without target and redundant columns. + n_points : int, optional + Number of data points to sample. If provided, randomly samples the specified number of points. + + Returns + ------- + X : pd.DataFrame + If ``display`` is True, ``X`` contains the raw data without the 'Education', 'Target', and 'fnlwgt' columns. + Otherwise, ``X`` contains the processed data without the 'Target' and 'fnlwgt' columns. + y : np.ndarray + The 'Target' column returned as an array. + + Notes + ----- + - The original data includes the following columns: + + - ``Age`` (float) : Age in years. + - ``Workclass`` (category) : Type of employment. + - ``fnlwgt`` (float) : Final weight; the number of units in the target population that the record represents. + - ``Education`` (category) : Highest level of education achieved. + - ``Education-Num`` (float) : Numeric representation of education level. + - ``Marital Status`` (category) : Marital status of the individual. + - ``Occupation`` (category) : Type of occupation. + - ``Relationship`` (category) : Relationship status. + - ``Race`` (category) : Ethnicity of the individual. + - ``Sex`` (category) : Gender of the individual. + - ``Capital Gain`` (float) : Capital gains recorded. + - ``Capital Loss`` (float) : Capital losses recorded. + - ``Hours per week`` (float) : Number of hours worked per week. + - ``Country`` (category) : Country of origin. + - ``Target`` (category) : Binary target variable indicating whether the individual earns more than 50K. + + - The Education' column is redundant with 'Education-Num' and is dropped for simplicity. + - The 'Target' column is converted to binary (True/False) where '>50K' is True and '<=50K' is False. + - Certain categorical columns are encoded for numerical representation. + + Examples + -------- + To get the processed data and target labels:: + + data, target = shap.datasets.adult() + + To get the raw data for display:: + + raw_data, target = shap.datasets.adult(display=True) + + """ + dtypes = [ + ("Age", "float32"), + ("Workclass", "category"), + ("fnlwgt", "float32"), + ("Education", "category"), + ("Education-Num", "float32"), + ("Marital Status", "category"), + ("Occupation", "category"), + ("Relationship", "category"), + ("Race", "category"), + ("Sex", "category"), + ("Capital Gain", "float32"), + ("Capital Loss", "float32"), + ("Hours per week", "float32"), + ("Country", "category"), + ("Target", "category"), + ] + raw_data = pd.read_csv( + cache(github_data_url + "adult.data"), names=[d[0] for d in dtypes], na_values="?", dtype=dict(dtypes) + ) + + if n_points is not None: + raw_data = shap.utils.sample(raw_data, n_points, random_state=0) + + data = raw_data.drop(["Education"], axis=1) # redundant with Education-Num + filt_dtypes = list(filter(lambda x: x[0] not in ["Target", "Education"], dtypes)) + data["Target"] = data["Target"] == " >50K" + rcode = {"Not-in-family": 0, "Unmarried": 1, "Other-relative": 2, "Own-child": 3, "Husband": 4, "Wife": 5} + for k, dtype in filt_dtypes: + if dtype == "category": + if k == "Relationship": + data[k] = np.array([rcode[v.strip()] for v in data[k]]) + else: + data[k] = data[k].cat.codes + + if display: + return raw_data.drop(["Education", "Target", "fnlwgt"], axis=1), data["Target"].values + return data.drop(["Target", "fnlwgt"], axis=1), data["Target"].values + + +def nhanesi(display: bool = False, n_points: int | None = None) -> tuple[pd.DataFrame, np.ndarray]: + """Return a nicely packaged version of NHANES I data with survival times as labels. + + Used in survival analysis tasks. + + Parameters + ---------- + display : bool, optional + If True, returns the features with a modified display. Default is False. + n_points : int, optional + Number of data points to sample. Default is None (returns the entire dataset). + + Returns + ------- + X : pd.DataFrame + The feature data matrix. If ``display`` is True, a modified version of the features for display + is returned as ``X`` instead. + y : np.ndarray + The target variables representing survival times. + + Examples + -------- + Usage example:: + + features, survival_times = shap.datasets.nhanesi(display=True, n_points=100) + + """ + X = pd.read_csv(cache(github_data_url + "NHANESI_X.csv"), index_col=0) + y = pd.read_csv(cache(github_data_url + "NHANESI_y.csv"), index_col=0)["y"] + + if n_points is not None: + X = shap.utils.sample(X, n_points, random_state=0) + y = shap.utils.sample(y, n_points, random_state=0) + + if display: + X_display = X.copy() + # X_display["sex_isFemale"] = ["Female" if v else "Male" for v in X["sex_isFemale"]] + return X_display, np.array(y) + return X, np.array(y) + + +def corrgroups60(n_points: int = 1_000) -> tuple[pd.DataFrame, np.ndarray]: + """Correlated Groups (60 features) + + A synthetic dataset consisting of 60 features with tight correlations among distinct groups of features. + + Parameters + ---------- + n_points : int, optional + Number of data points to generate. Default is 1,000. + + Returns + ------- + X : pd.DataFrame + The feature data matrix + y : np.ndarray + The target variables + + Notes + ----- + - The dataset is generated with known correlations among distinct groups of features. + - Each feature is a unit variance Gaussian random variable centred around 0. + - The labels are generated based on a linear function of the features with added random noise. + + Examples + -------- + .. code-block:: python + + data, target = shap.datasets.corrgroups60() + + """ + # set a constant seed + old_seed = np.random.seed() + np.random.seed(0) + + # generate dataset with known correlation + N, M = n_points, 60 + + # set one coefficient from each group of 3 to 1 + beta = np.zeros(M) + beta[0:30:3] = 1 + + # build a correlation matrix with groups of 3 tightly correlated features + C = np.eye(M) + for i in range(0, 30, 3): + C[i, i + 1] = C[i + 1, i] = 0.99 + C[i, i + 2] = C[i + 2, i] = 0.99 + C[i + 1, i + 2] = C[i + 2, i + 1] = 0.99 + + def f(X): + return np.matmul(X, beta) + + # Make sure the sample correlation is a perfect match + X_start = np.random.randn(N, M) + X_centered = X_start - X_start.mean(0) + Sigma = np.matmul(X_centered.T, X_centered) / X_centered.shape[0] + W = np.linalg.cholesky(np.linalg.inv(Sigma)).T + X_white = np.matmul(X_centered, W.T) + assert ( + np.linalg.norm(np.corrcoef(np.matmul(X_centered, W.T).T) - np.eye(M)) < 1e-6 + ) # ensure this decorrelates the data + + # create the final data + X_final = np.matmul(X_white, np.linalg.cholesky(C).T) + X = X_final + y = f(X) + np.random.randn(N) * 1e-2 + + # restore the previous numpy random seed + np.random.seed(old_seed) + + return pd.DataFrame(X), y + + +def independentlinear60(n_points: int = 1_000) -> tuple[pd.DataFrame, np.ndarray]: + """Independent Linear (60 features) + + A synthetic dataset consisting of 60 features. + + Parameters + ---------- + n_points : int, optional + Number of data points to generate. Default is 1,000. + + Returns + ------- + X : pd.DataFrame + The feature data matrix + y : np.ndarray + The target variables + + Notes + ----- + - Each feature is a unit variance Gaussian random variable centred around 0. + - The labels are generated based on a linear function of the features with added random noise. + + Examples + -------- + .. code-block:: python + + features, labels = shap.datasets.independentlinear60() + + """ + # set a constant seed + old_seed = np.random.seed() + np.random.seed(0) + + # generate dataset with known correlation + N, M = n_points, 60 + + # set one coefficient from each group of 3 to 1 + beta = np.zeros(M) + beta[0:30:3] = 1 + + def f(X): + return np.matmul(X, beta) + + # Make sure the sample correlation is a perfect match + X_start = np.random.randn(N, M) + X = X_start - X_start.mean(0) + y = f(X) + np.random.randn(N) * 1e-2 + + # restore the previous numpy random seed + np.random.seed(old_seed) + + return pd.DataFrame(X), y + + +def a1a(n_points: int | None = None) -> tuple[ssp.csr_matrix, np.ndarray]: + """ + Return a sparse dataset in scipy csr matrix format. + + Data Source: :external+scikit-learn:func:`sklearn.datasets.load_svmlight_file` + + Parameters + ---------- + n_points : int, optional + Number of data points to sample. If None, returns the entire dataset. Default is None. + + Returns + ------- + X : scipy.sparse.csr_matrix + Sparse feature matrix. + y : np.ndarray + Target labels. + + Examples + -------- + .. code-block:: python + + data, target = shap.datasets.a1a() + + """ + data: ssp.csr_matrix + target: np.ndarray + data, target = sklearn.datasets.load_svmlight_file(cache(github_data_url + "a1a.svmlight")) + + if n_points is not None: + data = shap.utils.sample(data, n_points, random_state=0) + target = shap.utils.sample(target, n_points, random_state=0) + + return data, target + + +def rank() -> tuple[ssp.csr_matrix, np.ndarray, ssp.csr_matrix, np.ndarray, np.ndarray, np.ndarray]: + """Return ranking datasets from the LightGBM repository. + + Used in ranking tasks. + + Returns + ------- + x_train : scipy.sparse.csr_matrix + Training feature matrix. + y_train : numpy.ndarray + Training labels. + x_test : scipy.sparse.csr_matrix + Testing feature matrix. + y_test : numpy.ndarray + Testing labels. + q_train : numpy.ndarray + Training query information. + q_test : numpy.ndarray + Testing query information. + + Notes + ----- + Data Source: LightGBM repository https://github.com/microsoft/LightGBM/tree/master/examples/lambdarank + + Examples + -------- + .. code-block:: python + + x_train, y_train, x_test, y_test, q_train, q_test = shap.datasets.rank() + + """ + rank_data_url = "https://raw.githubusercontent.com/Microsoft/LightGBM/master/examples/lambdarank/" + x_train, y_train = sklearn.datasets.load_svmlight_file(cache(rank_data_url + "rank.train")) + x_test, y_test = sklearn.datasets.load_svmlight_file(cache(rank_data_url + "rank.test")) + q_train = np.loadtxt(cache(rank_data_url + "rank.train.query")) + q_test = np.loadtxt(cache(rank_data_url + "rank.test.query")) + + return x_train, y_train, x_test, y_test, q_train, q_test + + +def cache(url: str, file_name: str | None = None) -> str: + """Loads a file from the URL and caches it locally.""" + if file_name is None: + file_name = os.path.basename(url) + data_dir = os.path.join(os.path.dirname(__file__), "cached_data") + os.makedirs(data_dir, exist_ok=True) + + file_path: str = os.path.join(data_dir, file_name) + if not os.path.isfile(file_path): + urlretrieve(url, file_path) + + return file_path diff --git a/shared/package-files/31/3103bf1f9753e489d925e6cba838096ef65fe2da0f1ff0118e453879ee894fe2/blob b/shared/package-files/31/3103bf1f9753e489d925e6cba838096ef65fe2da0f1ff0118e453879ee894fe2/blob new file mode 100644 index 0000000000000000000000000000000000000000..39ab6a3a9b932b80349a4b30359a1708b38a0aeb Binary files /dev/null and b/shared/package-files/31/3103bf1f9753e489d925e6cba838096ef65fe2da0f1ff0118e453879ee894fe2/blob differ diff --git a/shared/package-files/31/3103d3e2c01e26eb6dbbd93912d207383772cda9f4b3f57bcc61dc11026f19a0/blob b/shared/package-files/31/3103d3e2c01e26eb6dbbd93912d207383772cda9f4b3f57bcc61dc11026f19a0/blob new file mode 100644 index 0000000000000000000000000000000000000000..95ec9ade86ac88ec36a375cb87954b40e3ee820b Binary files /dev/null and b/shared/package-files/31/3103d3e2c01e26eb6dbbd93912d207383772cda9f4b3f57bcc61dc11026f19a0/blob differ diff --git a/shared/package-files/31/3103ffe331059299647b26a6efe17c41f7e3ee85b975b03fad3ff25263190ce8/blob b/shared/package-files/31/3103ffe331059299647b26a6efe17c41f7e3ee85b975b03fad3ff25263190ce8/blob new file mode 100644 index 0000000000000000000000000000000000000000..fdee2c170645781986e0dd49083b8dfbc7122483 Binary files /dev/null and b/shared/package-files/31/3103ffe331059299647b26a6efe17c41f7e3ee85b975b03fad3ff25263190ce8/blob differ diff --git a/shared/package-files/31/310599c758f795b1295a62294356d5f6cceb18e57754737442b1272518c0856e/blob b/shared/package-files/31/310599c758f795b1295a62294356d5f6cceb18e57754737442b1272518c0856e/blob new file mode 100644 index 0000000000000000000000000000000000000000..1660d4d42fc1de142d4762a0ed7859278f99f2fb --- /dev/null +++ b/shared/package-files/31/310599c758f795b1295a62294356d5f6cceb18e57754737442b1272518c0856e/blob @@ -0,0 +1,20 @@ +import unittest +from numba.cuda.testing import ContextResettingTestCase +from numba import cuda +from numba.cuda.testing import skip_on_cudasim + + +@skip_on_cudasim('CUDA Profiler unsupported in the simulator') +class TestProfiler(ContextResettingTestCase): + def test_profiling(self): + with cuda.profiling(): + a = cuda.device_array(10) + del a + + with cuda.profiling(): + a = cuda.device_array(100) + del a + + +if __name__ == '__main__': + unittest.main() diff --git a/shared/package-files/31/310660dc989512f699bb33253947978cf2ee0109616f9f9034353c330e663672/blob b/shared/package-files/31/310660dc989512f699bb33253947978cf2ee0109616f9f9034353c330e663672/blob new file mode 100644 index 0000000000000000000000000000000000000000..d7b674f8f7f0909edfadba23373569230ab2d79d --- /dev/null +++ b/shared/package-files/31/310660dc989512f699bb33253947978cf2ee0109616f9f9034353c330e663672/blob @@ -0,0 +1,632 @@ +"""Module for querying SymPy objects about assumptions.""" + +from sympy.assumptions.assume import (global_assumptions, Predicate, + AppliedPredicate) +from sympy.assumptions.cnf import CNF, EncodedCNF, Literal +from sympy.core import sympify +from sympy.core.kind import BooleanKind +from sympy.core.relational import Eq, Ne, Gt, Lt, Ge, Le +from sympy.logic.inference import satisfiable +from sympy.utilities.decorator import memoize_property +from sympy.utilities.exceptions import (sympy_deprecation_warning, + SymPyDeprecationWarning, + ignore_warnings) + + +# Memoization is necessary for the properties of AssumptionKeys to +# ensure that only one object of Predicate objects are created. +# This is because assumption handlers are registered on those objects. + + +class AssumptionKeys: + """ + This class contains all the supported keys by ``ask``. + It should be accessed via the instance ``sympy.Q``. + + """ + + # DO NOT add methods or properties other than predicate keys. + # SAT solver checks the properties of Q and use them to compute the + # fact system. Non-predicate attributes will break this. + + @memoize_property + def hermitian(self): + from .handlers.sets import HermitianPredicate + return HermitianPredicate() + + @memoize_property + def antihermitian(self): + from .handlers.sets import AntihermitianPredicate + return AntihermitianPredicate() + + @memoize_property + def real(self): + from .handlers.sets import RealPredicate + return RealPredicate() + + @memoize_property + def extended_real(self): + from .handlers.sets import ExtendedRealPredicate + return ExtendedRealPredicate() + + @memoize_property + def imaginary(self): + from .handlers.sets import ImaginaryPredicate + return ImaginaryPredicate() + + @memoize_property + def complex(self): + from .handlers.sets import ComplexPredicate + return ComplexPredicate() + + @memoize_property + def algebraic(self): + from .handlers.sets import AlgebraicPredicate + return AlgebraicPredicate() + + @memoize_property + def transcendental(self): + from .predicates.sets import TranscendentalPredicate + return TranscendentalPredicate() + + @memoize_property + def integer(self): + from .handlers.sets import IntegerPredicate + return IntegerPredicate() + + @memoize_property + def rational(self): + from .handlers.sets import RationalPredicate + return RationalPredicate() + + @memoize_property + def irrational(self): + from .handlers.sets import IrrationalPredicate + return IrrationalPredicate() + + @memoize_property + def finite(self): + from .handlers.calculus import FinitePredicate + return FinitePredicate() + + @memoize_property + def infinite(self): + from .handlers.calculus import InfinitePredicate + return InfinitePredicate() + + @memoize_property + def positive_infinite(self): + from .handlers.calculus import PositiveInfinitePredicate + return PositiveInfinitePredicate() + + @memoize_property + def negative_infinite(self): + from .handlers.calculus import NegativeInfinitePredicate + return NegativeInfinitePredicate() + + @memoize_property + def positive(self): + from .handlers.order import PositivePredicate + return PositivePredicate() + + @memoize_property + def negative(self): + from .handlers.order import NegativePredicate + return NegativePredicate() + + @memoize_property + def zero(self): + from .handlers.order import ZeroPredicate + return ZeroPredicate() + + @memoize_property + def extended_positive(self): + from .handlers.order import ExtendedPositivePredicate + return ExtendedPositivePredicate() + + @memoize_property + def extended_negative(self): + from .handlers.order import ExtendedNegativePredicate + return ExtendedNegativePredicate() + + @memoize_property + def nonzero(self): + from .handlers.order import NonZeroPredicate + return NonZeroPredicate() + + @memoize_property + def nonpositive(self): + from .handlers.order import NonPositivePredicate + return NonPositivePredicate() + + @memoize_property + def nonnegative(self): + from .handlers.order import NonNegativePredicate + return NonNegativePredicate() + + @memoize_property + def extended_nonzero(self): + from .handlers.order import ExtendedNonZeroPredicate + return ExtendedNonZeroPredicate() + + @memoize_property + def extended_nonpositive(self): + from .handlers.order import ExtendedNonPositivePredicate + return ExtendedNonPositivePredicate() + + @memoize_property + def extended_nonnegative(self): + from .handlers.order import ExtendedNonNegativePredicate + return ExtendedNonNegativePredicate() + + @memoize_property + def even(self): + from .handlers.ntheory import EvenPredicate + return EvenPredicate() + + @memoize_property + def odd(self): + from .handlers.ntheory import OddPredicate + return OddPredicate() + + @memoize_property + def prime(self): + from .handlers.ntheory import PrimePredicate + return PrimePredicate() + + @memoize_property + def composite(self): + from .handlers.ntheory import CompositePredicate + return CompositePredicate() + + @memoize_property + def commutative(self): + from .handlers.common import CommutativePredicate + return CommutativePredicate() + + @memoize_property + def is_true(self): + from .handlers.common import IsTruePredicate + return IsTruePredicate() + + @memoize_property + def symmetric(self): + from .handlers.matrices import SymmetricPredicate + return SymmetricPredicate() + + @memoize_property + def invertible(self): + from .handlers.matrices import InvertiblePredicate + return InvertiblePredicate() + + @memoize_property + def orthogonal(self): + from .handlers.matrices import OrthogonalPredicate + return OrthogonalPredicate() + + @memoize_property + def unitary(self): + from .handlers.matrices import UnitaryPredicate + return UnitaryPredicate() + + @memoize_property + def positive_definite(self): + from .handlers.matrices import PositiveDefinitePredicate + return PositiveDefinitePredicate() + + @memoize_property + def upper_triangular(self): + from .handlers.matrices import UpperTriangularPredicate + return UpperTriangularPredicate() + + @memoize_property + def lower_triangular(self): + from .handlers.matrices import LowerTriangularPredicate + return LowerTriangularPredicate() + + @memoize_property + def diagonal(self): + from .handlers.matrices import DiagonalPredicate + return DiagonalPredicate() + + @memoize_property + def fullrank(self): + from .handlers.matrices import FullRankPredicate + return FullRankPredicate() + + @memoize_property + def square(self): + from .handlers.matrices import SquarePredicate + return SquarePredicate() + + @memoize_property + def integer_elements(self): + from .handlers.matrices import IntegerElementsPredicate + return IntegerElementsPredicate() + + @memoize_property + def real_elements(self): + from .handlers.matrices import RealElementsPredicate + return RealElementsPredicate() + + @memoize_property + def complex_elements(self): + from .handlers.matrices import ComplexElementsPredicate + return ComplexElementsPredicate() + + @memoize_property + def singular(self): + from .predicates.matrices import SingularPredicate + return SingularPredicate() + + @memoize_property + def normal(self): + from .predicates.matrices import NormalPredicate + return NormalPredicate() + + @memoize_property + def triangular(self): + from .predicates.matrices import TriangularPredicate + return TriangularPredicate() + + @memoize_property + def unit_triangular(self): + from .predicates.matrices import UnitTriangularPredicate + return UnitTriangularPredicate() + + @memoize_property + def eq(self): + from .relation.equality import EqualityPredicate + return EqualityPredicate() + + @memoize_property + def ne(self): + from .relation.equality import UnequalityPredicate + return UnequalityPredicate() + + @memoize_property + def gt(self): + from .relation.equality import StrictGreaterThanPredicate + return StrictGreaterThanPredicate() + + @memoize_property + def ge(self): + from .relation.equality import GreaterThanPredicate + return GreaterThanPredicate() + + @memoize_property + def lt(self): + from .relation.equality import StrictLessThanPredicate + return StrictLessThanPredicate() + + @memoize_property + def le(self): + from .relation.equality import LessThanPredicate + return LessThanPredicate() + + +Q = AssumptionKeys() + +def _extract_all_facts(assump, exprs): + """ + Extract all relevant assumptions from *assump* with respect to given *exprs*. + + Parameters + ========== + + assump : sympy.assumptions.cnf.CNF + + exprs : tuple of expressions + + Returns + ======= + + sympy.assumptions.cnf.CNF + + Examples + ======== + + >>> from sympy import Q + >>> from sympy.assumptions.cnf import CNF + >>> from sympy.assumptions.ask import _extract_all_facts + >>> from sympy.abc import x, y + >>> assump = CNF.from_prop(Q.positive(x) & Q.integer(y)) + >>> exprs = (x,) + >>> cnf = _extract_all_facts(assump, exprs) + >>> cnf.clauses + {frozenset({Literal(Q.positive, False)})} + + """ + facts = set() + + for clause in assump.clauses: + args = [] + for literal in clause: + if isinstance(literal.lit, AppliedPredicate) and len(literal.lit.arguments) == 1: + if literal.lit.arg in exprs: + # Add literal if it has matching in it + args.append(Literal(literal.lit.function, literal.is_Not)) + else: + # If any of the literals doesn't have matching expr don't add the whole clause. + break + else: + if args: + facts.add(frozenset(args)) + return CNF(facts) + + +def ask(proposition, assumptions=True, context=global_assumptions): + """ + Function to evaluate the proposition with assumptions. + + Explanation + =========== + + This function evaluates the proposition to ``True`` or ``False`` if + the truth value can be determined. If not, it returns ``None``. + + It should be discerned from :func:`~.refine()` which, when applied to a + proposition, simplifies the argument to symbolic ``Boolean`` instead of + Python built-in ``True``, ``False`` or ``None``. + + **Syntax** + + * ask(proposition) + Evaluate the *proposition* in global assumption context. + + * ask(proposition, assumptions) + Evaluate the *proposition* with respect to *assumptions* in + global assumption context. + + Parameters + ========== + + proposition : Boolean + Proposition which will be evaluated to boolean value. If this is + not ``AppliedPredicate``, it will be wrapped by ``Q.is_true``. + + assumptions : Boolean, optional + Local assumptions to evaluate the *proposition*. + + context : AssumptionsContext, optional + Default assumptions to evaluate the *proposition*. By default, + this is ``sympy.assumptions.global_assumptions`` variable. + + Returns + ======= + + ``True``, ``False``, or ``None`` + + Raises + ====== + + TypeError : *proposition* or *assumptions* is not valid logical expression. + + ValueError : assumptions are inconsistent. + + Examples + ======== + + >>> from sympy import ask, Q, pi + >>> from sympy.abc import x, y + >>> ask(Q.rational(pi)) + False + >>> ask(Q.even(x*y), Q.even(x) & Q.integer(y)) + True + >>> ask(Q.prime(4*x), Q.integer(x)) + False + + If the truth value cannot be determined, ``None`` will be returned. + + >>> print(ask(Q.odd(3*x))) # cannot determine unless we know x + None + + ``ValueError`` is raised if assumptions are inconsistent. + + >>> ask(Q.integer(x), Q.even(x) & Q.odd(x)) + Traceback (most recent call last): + ... + ValueError: inconsistent assumptions Q.even(x) & Q.odd(x) + + Notes + ===== + + Relations in assumptions are not implemented (yet), so the following + will not give a meaningful result. + + >>> ask(Q.positive(x), x > 0) + + It is however a work in progress. + + See Also + ======== + + sympy.assumptions.refine.refine : Simplification using assumptions. + Proposition is not reduced to ``None`` if the truth value cannot + be determined. + """ + from sympy.assumptions.satask import satask + + proposition = sympify(proposition) + assumptions = sympify(assumptions) + + if isinstance(proposition, Predicate) or proposition.kind is not BooleanKind: + raise TypeError("proposition must be a valid logical expression") + + if isinstance(assumptions, Predicate) or assumptions.kind is not BooleanKind: + raise TypeError("assumptions must be a valid logical expression") + + binrelpreds = {Eq: Q.eq, Ne: Q.ne, Gt: Q.gt, Lt: Q.lt, Ge: Q.ge, Le: Q.le} + if isinstance(proposition, AppliedPredicate): + key, args = proposition.function, proposition.arguments + elif proposition.func in binrelpreds: + key, args = binrelpreds[type(proposition)], proposition.args + else: + key, args = Q.is_true, (proposition,) + + # convert local and global assumptions to CNF + assump_cnf = CNF.from_prop(assumptions) + assump_cnf.extend(context) + + # extract the relevant facts from assumptions with respect to args + local_facts = _extract_all_facts(assump_cnf, args) + + # convert default facts and assumed facts to encoded CNF + known_facts_cnf = get_all_known_facts() + enc_cnf = EncodedCNF() + enc_cnf.from_cnf(CNF(known_facts_cnf)) + enc_cnf.add_from_cnf(local_facts) + + # check the satisfiability of given assumptions + if local_facts.clauses and satisfiable(enc_cnf) is False: + raise ValueError("inconsistent assumptions %s" % assumptions) + + # quick computation for single fact + res = _ask_single_fact(key, local_facts) + if res is not None: + return res + + # direct resolution method, no logic + res = key(*args)._eval_ask(assumptions) + if res is not None: + return bool(res) + + # using satask (still costly) + res = satask(proposition, assumptions=assumptions, context=context) + return res + + +def _ask_single_fact(key, local_facts): + """ + Compute the truth value of single predicate using assumptions. + + Parameters + ========== + + key : sympy.assumptions.assume.Predicate + Proposition predicate. + + local_facts : sympy.assumptions.cnf.CNF + Local assumption in CNF form. + + Returns + ======= + + ``True``, ``False`` or ``None`` + + Examples + ======== + + >>> from sympy import Q + >>> from sympy.assumptions.cnf import CNF + >>> from sympy.assumptions.ask import _ask_single_fact + + If prerequisite of proposition is rejected by the assumption, + return ``False``. + + >>> key, assump = Q.zero, ~Q.zero + >>> local_facts = CNF.from_prop(assump) + >>> _ask_single_fact(key, local_facts) + False + >>> key, assump = Q.zero, ~Q.even + >>> local_facts = CNF.from_prop(assump) + >>> _ask_single_fact(key, local_facts) + False + + If assumption implies the proposition, return ``True``. + + >>> key, assump = Q.even, Q.zero + >>> local_facts = CNF.from_prop(assump) + >>> _ask_single_fact(key, local_facts) + True + + If proposition rejects the assumption, return ``False``. + + >>> key, assump = Q.even, Q.odd + >>> local_facts = CNF.from_prop(assump) + >>> _ask_single_fact(key, local_facts) + False + """ + if local_facts.clauses: + + known_facts_dict = get_known_facts_dict() + + if len(local_facts.clauses) == 1: + cl, = local_facts.clauses + if len(cl) == 1: + f, = cl + prop_facts = known_facts_dict.get(key, None) + prop_req = prop_facts[0] if prop_facts is not None else set() + if f.is_Not and f.arg in prop_req: + # the prerequisite of proposition is rejected + return False + + for clause in local_facts.clauses: + if len(clause) == 1: + f, = clause + prop_facts = known_facts_dict.get(f.arg, None) if not f.is_Not else None + if prop_facts is None: + continue + + prop_req, prop_rej = prop_facts + if key in prop_req: + # assumption implies the proposition + return True + elif key in prop_rej: + # proposition rejects the assumption + return False + + return None + + +def register_handler(key, handler): + """ + Register a handler in the ask system. key must be a string and handler a + class inheriting from AskHandler. + + .. deprecated:: 1.8. + Use multipledispatch handler instead. See :obj:`~.Predicate`. + + """ + sympy_deprecation_warning( + """ + The AskHandler system is deprecated. The register_handler() function + should be replaced with the multipledispatch handler of Predicate. + """, + deprecated_since_version="1.8", + active_deprecations_target='deprecated-askhandler', + ) + if isinstance(key, Predicate): + key = key.name.name + Qkey = getattr(Q, key, None) + if Qkey is not None: + Qkey.add_handler(handler) + else: + setattr(Q, key, Predicate(key, handlers=[handler])) + + +def remove_handler(key, handler): + """ + Removes a handler from the ask system. + + .. deprecated:: 1.8. + Use multipledispatch handler instead. See :obj:`~.Predicate`. + + """ + sympy_deprecation_warning( + """ + The AskHandler system is deprecated. The remove_handler() function + should be replaced with the multipledispatch handler of Predicate. + """, + deprecated_since_version="1.8", + active_deprecations_target='deprecated-askhandler', + ) + if isinstance(key, Predicate): + key = key.name.name + # Don't show the same warning again recursively + with ignore_warnings(SymPyDeprecationWarning): + getattr(Q, key).remove_handler(handler) + + +from sympy.assumptions.ask_generated import (get_all_known_facts, + get_known_facts_dict) diff --git a/shared/package-files/31/310e1969ca53b8ff8d9abb855ca7562d06ada1e54943c49a050d839d8bedc84f/blob b/shared/package-files/31/310e1969ca53b8ff8d9abb855ca7562d06ada1e54943c49a050d839d8bedc84f/blob new file mode 100644 index 0000000000000000000000000000000000000000..9b71e9f51fd455558a9eb42dc840604c6c96e4b3 --- /dev/null +++ b/shared/package-files/31/310e1969ca53b8ff8d9abb855ca7562d06ada1e54943c49a050d839d8bedc84f/blob @@ -0,0 +1,5 @@ +# *** GENERATED BY `setup.py antlr`, DO NOT EDIT BY HAND *** +# +# Generated with antlr4 +# antlr4 is licensed under the BSD-3-Clause License +# https://github.com/antlr/antlr4/blob/master/LICENSE.txt diff --git a/shared/package-files/31/310f2f3244ae0c75f9e6503136713c1b1b3141d60fbbc21c5d7feabb2bc7c51b/blob b/shared/package-files/31/310f2f3244ae0c75f9e6503136713c1b1b3141d60fbbc21c5d7feabb2bc7c51b/blob new file mode 100644 index 0000000000000000000000000000000000000000..3e04fe431c72122a911407d3a136cb9e28a364e0 --- /dev/null +++ b/shared/package-files/31/310f2f3244ae0c75f9e6503136713c1b1b3141d60fbbc21c5d7feabb2bc7c51b/blob @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor elu(const at::Tensor & self, const at::Scalar & alpha=1, const at::Scalar & scale=1, const at::Scalar & input_scale=1); +TORCH_API at::Tensor & elu_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & alpha=1, const at::Scalar & scale=1, const at::Scalar & input_scale=1); +TORCH_API at::Tensor & elu_outf(const at::Tensor & self, const at::Scalar & alpha, const at::Scalar & scale, const at::Scalar & input_scale, at::Tensor & out); +TORCH_API at::Tensor & elu_(at::Tensor & self, const at::Scalar & alpha=1, const at::Scalar & scale=1, const at::Scalar & input_scale=1); + +} // namespace cpu +} // namespace at diff --git a/shared/package-files/31/310fdbf3b555d7c3bd3227e17549bb4db0487669f084045f1b8ba789dbb51188/blob b/shared/package-files/31/310fdbf3b555d7c3bd3227e17549bb4db0487669f084045f1b8ba789dbb51188/blob new file mode 100644 index 0000000000000000000000000000000000000000..ed9d20beb6b3a5cb7fb7c419993ece8d55067c16 --- /dev/null +++ b/shared/package-files/31/310fdbf3b555d7c3bd3227e17549bb4db0487669f084045f1b8ba789dbb51188/blob @@ -0,0 +1,1558 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + +# cython: profile=False +# distutils: language = c++ +# cython: language_level = 3 + +from cython.operator cimport dereference as deref + +from collections import namedtuple +from collections.abc import Mapping + +from pyarrow.includes.common cimport * +from pyarrow.includes.libarrow cimport * +from pyarrow.includes.libarrow_python cimport * +from pyarrow.lib cimport (check_status, Field, MemoryPool, Schema, + RecordBatchReader, ensure_type, + maybe_unbox_memory_pool, get_input_stream, + get_writer, native_transcoding_input_stream, + pyarrow_unwrap_batch, pyarrow_unwrap_schema, + pyarrow_unwrap_table, pyarrow_wrap_schema, + pyarrow_wrap_table, pyarrow_wrap_data_type, + pyarrow_unwrap_data_type, Table, RecordBatch, + StopToken, _CRecordBatchWriter) +from pyarrow.lib import frombytes, tobytes, SignalStopHandler + + +cdef unsigned char _single_char(s) except 0: + val = ord(s) + if val == 0 or val > 127: + raise ValueError("Expecting an ASCII character") + return val + + +_InvalidRow = namedtuple( + "_InvalidRow", ("expected_columns", "actual_columns", "number", "text"), + module=__name__) + + +class InvalidRow(_InvalidRow): + """ + Description of an invalid row in a CSV file. + + Parameters + ---------- + expected_columns : int + The expected number of columns in the row. + actual_columns : int + The actual number of columns in the row. + number : int or None + The physical row number if known, otherwise None. + text : str + The contents of the row. + """ + __slots__ = () + + +cdef CInvalidRowResult _handle_invalid_row( + handler, const CCSVInvalidRow& c_row) except CInvalidRowResult_Error: + # A negative row number means undetermined (because of parallel reading) + row_number = c_row.number if c_row.number >= 0 else None + row = InvalidRow(c_row.expected_columns, c_row.actual_columns, + row_number, frombytes( c_row.text)) + result = handler(row) + if result == 'error': + return CInvalidRowResult_Error + elif result == 'skip': + return CInvalidRowResult_Skip + else: + raise ValueError("Invalid return value for invalid row handler: " + f"expected 'error' or 'skip', got {result!r}") + + +cdef class ReadOptions(_Weakrefable): + """ + Options for reading CSV files. + + Parameters + ---------- + use_threads : bool, optional (default True) + Whether to use multiple threads to accelerate reading + block_size : int, optional + How much bytes to process at a time from the input stream. + This will determine multi-threading granularity as well as + the size of individual record batches or table chunks. + Minimum valid value for block size is 1 + skip_rows : int, optional (default 0) + The number of rows to skip before the column names (if any) + and the CSV data. + skip_rows_after_names : int, optional (default 0) + The number of rows to skip after the column names. + This number can be larger than the number of rows in one + block, and empty rows are counted. + The order of application is as follows: + - `skip_rows` is applied (if non-zero); + - column names are read (unless `column_names` is set); + - `skip_rows_after_names` is applied (if non-zero). + column_names : list, optional + The column names of the target table. If empty, fall back on + `autogenerate_column_names`. + autogenerate_column_names : bool, optional (default False) + Whether to autogenerate column names if `column_names` is empty. + If true, column names will be of the form "f0", "f1"... + If false, column names will be read from the first CSV row + after `skip_rows`. + encoding : str, optional (default 'utf8') + The character encoding of the CSV data. Columns that cannot + decode using this encoding can still be read as Binary. + + Examples + -------- + + Defining an example data: + + >>> import io + >>> s = "1,2,3\\nFlamingo,2,2022-03-01\\nHorse,4,2022-03-02\\nBrittle stars,5,2022-03-03\\nCentipede,100,2022-03-04" + >>> print(s) + 1,2,3 + Flamingo,2,2022-03-01 + Horse,4,2022-03-02 + Brittle stars,5,2022-03-03 + Centipede,100,2022-03-04 + + Ignore the first numbered row and substitute it with defined + or autogenerated column names: + + >>> from pyarrow import csv + >>> read_options = csv.ReadOptions( + ... column_names=["animals", "n_legs", "entry"], + ... skip_rows=1) + >>> csv.read_csv(io.BytesIO(s.encode()), read_options=read_options) + pyarrow.Table + animals: string + n_legs: int64 + entry: date32[day] + ---- + animals: [["Flamingo","Horse","Brittle stars","Centipede"]] + n_legs: [[2,4,5,100]] + entry: [[2022-03-01,2022-03-02,2022-03-03,2022-03-04]] + + >>> read_options = csv.ReadOptions(autogenerate_column_names=True, + ... skip_rows=1) + >>> csv.read_csv(io.BytesIO(s.encode()), read_options=read_options) + pyarrow.Table + f0: string + f1: int64 + f2: date32[day] + ---- + f0: [["Flamingo","Horse","Brittle stars","Centipede"]] + f1: [[2,4,5,100]] + f2: [[2022-03-01,2022-03-02,2022-03-03,2022-03-04]] + + Remove the first 2 rows of the data: + + >>> read_options = csv.ReadOptions(skip_rows_after_names=2) + >>> csv.read_csv(io.BytesIO(s.encode()), read_options=read_options) + pyarrow.Table + 1: string + 2: int64 + 3: date32[day] + ---- + 1: [["Brittle stars","Centipede"]] + 2: [[5,100]] + 3: [[2022-03-03,2022-03-04]] + """ + + # Avoid mistakingly creating attributes + __slots__ = () + + # __init__() is not called when unpickling, initialize storage here + def __cinit__(self, *argw, **kwargs): + self.options.reset(new CCSVReadOptions(CCSVReadOptions.Defaults())) + + def __init__(self, *, use_threads=None, block_size=None, skip_rows=None, + skip_rows_after_names=None, column_names=None, + autogenerate_column_names=None, encoding='utf8'): + if use_threads is not None: + self.use_threads = use_threads + if block_size is not None: + self.block_size = block_size + if skip_rows is not None: + self.skip_rows = skip_rows + if skip_rows_after_names is not None: + self.skip_rows_after_names = skip_rows_after_names + if column_names is not None: + self.column_names = column_names + if autogenerate_column_names is not None: + self.autogenerate_column_names= autogenerate_column_names + # Python-specific option + self.encoding = encoding + + @property + def use_threads(self): + """ + Whether to use multiple threads to accelerate reading. + """ + return deref(self.options).use_threads + + @use_threads.setter + def use_threads(self, value): + deref(self.options).use_threads = value + + @property + def block_size(self): + """ + How much bytes to process at a time from the input stream. + This will determine multi-threading granularity as well as + the size of individual record batches or table chunks. + """ + return deref(self.options).block_size + + @block_size.setter + def block_size(self, value): + deref(self.options).block_size = value + + @property + def skip_rows(self): + """ + The number of rows to skip before the column names (if any) + and the CSV data. + See `skip_rows_after_names` for interaction description + """ + return deref(self.options).skip_rows + + @skip_rows.setter + def skip_rows(self, value): + deref(self.options).skip_rows = value + + @property + def skip_rows_after_names(self): + """ + The number of rows to skip after the column names. + This number can be larger than the number of rows in one + block, and empty rows are counted. + The order of application is as follows: + - `skip_rows` is applied (if non-zero); + - column names are read (unless `column_names` is set); + - `skip_rows_after_names` is applied (if non-zero). + """ + return deref(self.options).skip_rows_after_names + + @skip_rows_after_names.setter + def skip_rows_after_names(self, value): + deref(self.options).skip_rows_after_names = value + + @property + def column_names(self): + """ + The column names of the target table. If empty, fall back on + `autogenerate_column_names`. + """ + return [frombytes(s) for s in deref(self.options).column_names] + + @column_names.setter + def column_names(self, value): + deref(self.options).column_names.clear() + for item in value: + deref(self.options).column_names.push_back(tobytes(item)) + + @property + def autogenerate_column_names(self): + """ + Whether to autogenerate column names if `column_names` is empty. + If true, column names will be of the form "f0", "f1"... + If false, column names will be read from the first CSV row + after `skip_rows`. + """ + return deref(self.options).autogenerate_column_names + + @autogenerate_column_names.setter + def autogenerate_column_names(self, value): + deref(self.options).autogenerate_column_names = value + + def validate(self): + check_status(deref(self.options).Validate()) + + def equals(self, ReadOptions other): + """ + Parameters + ---------- + other : pyarrow.csv.ReadOptions + + Returns + ------- + bool + """ + return ( + self.use_threads == other.use_threads and + self.block_size == other.block_size and + self.skip_rows == other.skip_rows and + self.skip_rows_after_names == other.skip_rows_after_names and + self.column_names == other.column_names and + self.autogenerate_column_names == + other.autogenerate_column_names and + self.encoding == other.encoding + ) + + @staticmethod + cdef ReadOptions wrap(CCSVReadOptions options): + out = ReadOptions() + out.options.reset(new CCSVReadOptions(move(options))) + out.encoding = 'utf8' # No way to know this + return out + + def __getstate__(self): + return (self.use_threads, self.block_size, self.skip_rows, + self.column_names, self.autogenerate_column_names, + self.encoding, self.skip_rows_after_names) + + def __setstate__(self, state): + (self.use_threads, self.block_size, self.skip_rows, + self.column_names, self.autogenerate_column_names, + self.encoding, self.skip_rows_after_names) = state + + def __eq__(self, other): + try: + return self.equals(other) + except TypeError: + return False + + +cdef class ParseOptions(_Weakrefable): + """ + Options for parsing CSV files. + + Parameters + ---------- + delimiter : 1-character string, optional (default ',') + The character delimiting individual cells in the CSV data. + quote_char : 1-character string or False, optional (default '"') + The character used optionally for quoting CSV values + (False if quoting is not allowed). + double_quote : bool, optional (default True) + Whether two quotes in a quoted CSV value denote a single quote + in the data. + escape_char : 1-character string or False, optional (default False) + The character used optionally for escaping special characters + (False if escaping is not allowed). + newlines_in_values : bool, optional (default False) + Whether newline characters are allowed in CSV values. + Setting this to True reduces the performance of multi-threaded + CSV reading. + ignore_empty_lines : bool, optional (default True) + Whether empty lines are ignored in CSV input. + If False, an empty line is interpreted as containing a single empty + value (assuming a one-column CSV file). + invalid_row_handler : callable, optional (default None) + If not None, this object is called for each CSV row that fails + parsing (because of a mismatching number of columns). + It should accept a single InvalidRow argument and return either + "skip" or "error" depending on the desired outcome. + + Examples + -------- + + Defining an example file from bytes object: + + >>> import io + >>> s = ( + ... "animals;n_legs;entry\\n" + ... "Flamingo;2;2022-03-01\\n" + ... "# Comment here:\\n" + ... "Horse;4;2022-03-02\\n" + ... "Brittle stars;5;2022-03-03\\n" + ... "Centipede;100;2022-03-04" + ... ) + >>> print(s) + animals;n_legs;entry + Flamingo;2;2022-03-01 + # Comment here: + Horse;4;2022-03-02 + Brittle stars;5;2022-03-03 + Centipede;100;2022-03-04 + >>> source = io.BytesIO(s.encode()) + + Read the data from a file skipping rows with comments + and defining the delimiter: + + >>> from pyarrow import csv + >>> def skip_comment(row): + ... if row.text.startswith("# "): + ... return 'skip' + ... else: + ... return 'error' + ... + >>> parse_options = csv.ParseOptions(delimiter=";", invalid_row_handler=skip_comment) + >>> csv.read_csv(source, parse_options=parse_options) + pyarrow.Table + animals: string + n_legs: int64 + entry: date32[day] + ---- + animals: [["Flamingo","Horse","Brittle stars","Centipede"]] + n_legs: [[2,4,5,100]] + entry: [[2022-03-01,2022-03-02,2022-03-03,2022-03-04]] + """ + __slots__ = () + + def __cinit__(self, *argw, **kwargs): + self._invalid_row_handler = None + self.options.reset(new CCSVParseOptions(CCSVParseOptions.Defaults())) + + def __init__(self, *, delimiter=None, quote_char=None, double_quote=None, + escape_char=None, newlines_in_values=None, + ignore_empty_lines=None, invalid_row_handler=None): + if delimiter is not None: + self.delimiter = delimiter + if quote_char is not None: + self.quote_char = quote_char + if double_quote is not None: + self.double_quote = double_quote + if escape_char is not None: + self.escape_char = escape_char + if newlines_in_values is not None: + self.newlines_in_values = newlines_in_values + if ignore_empty_lines is not None: + self.ignore_empty_lines = ignore_empty_lines + if invalid_row_handler is not None: + self.invalid_row_handler = invalid_row_handler + + @property + def delimiter(self): + """ + The character delimiting individual cells in the CSV data. + """ + return chr(deref(self.options).delimiter) + + @delimiter.setter + def delimiter(self, value): + deref(self.options).delimiter = _single_char(value) + + @property + def quote_char(self): + """ + The character used optionally for quoting CSV values + (False if quoting is not allowed). + """ + if deref(self.options).quoting: + return chr(deref(self.options).quote_char) + else: + return False + + @quote_char.setter + def quote_char(self, value): + if value is False: + deref(self.options).quoting = False + else: + deref(self.options).quote_char = _single_char(value) + deref(self.options).quoting = True + + @property + def double_quote(self): + """ + Whether two quotes in a quoted CSV value denote a single quote + in the data. + """ + return deref(self.options).double_quote + + @double_quote.setter + def double_quote(self, value): + deref(self.options).double_quote = value + + @property + def escape_char(self): + """ + The character used optionally for escaping special characters + (False if escaping is not allowed). + """ + if deref(self.options).escaping: + return chr(deref(self.options).escape_char) + else: + return False + + @escape_char.setter + def escape_char(self, value): + if value is False: + deref(self.options).escaping = False + else: + deref(self.options).escape_char = _single_char(value) + deref(self.options).escaping = True + + @property + def newlines_in_values(self): + """ + Whether newline characters are allowed in CSV values. + Setting this to True reduces the performance of multi-threaded + CSV reading. + """ + return deref(self.options).newlines_in_values + + @newlines_in_values.setter + def newlines_in_values(self, value): + deref(self.options).newlines_in_values = value + + @property + def ignore_empty_lines(self): + """ + Whether empty lines are ignored in CSV input. + If False, an empty line is interpreted as containing a single empty + value (assuming a one-column CSV file). + """ + return deref(self.options).ignore_empty_lines + + @property + def invalid_row_handler(self): + """ + Optional handler for invalid rows. + + If not None, this object is called for each CSV row that fails + parsing (because of a mismatching number of columns). + It should accept a single InvalidRow argument and return either + "skip" or "error" depending on the desired outcome. + """ + return self._invalid_row_handler + + @invalid_row_handler.setter + def invalid_row_handler(self, value): + if value is not None and not callable(value): + raise TypeError("Expected callable or None, " + f"got instance of {type(value)!r}") + self._invalid_row_handler = value + deref(self.options).invalid_row_handler = MakeInvalidRowHandler( + &_handle_invalid_row, value) + + @ignore_empty_lines.setter + def ignore_empty_lines(self, value): + deref(self.options).ignore_empty_lines = value + + def validate(self): + check_status(deref(self.options).Validate()) + + def equals(self, ParseOptions other): + """ + Parameters + ---------- + other : pyarrow.csv.ParseOptions + + Returns + ------- + bool + """ + return ( + self.delimiter == other.delimiter and + self.quote_char == other.quote_char and + self.double_quote == other.double_quote and + self.escape_char == other.escape_char and + self.newlines_in_values == other.newlines_in_values and + self.ignore_empty_lines == other.ignore_empty_lines and + self._invalid_row_handler == other._invalid_row_handler + ) + + @staticmethod + cdef ParseOptions wrap(CCSVParseOptions options): + out = ParseOptions() + out.options.reset(new CCSVParseOptions(move(options))) + return out + + def __getstate__(self): + return (self.delimiter, self.quote_char, self.double_quote, + self.escape_char, self.newlines_in_values, + self.ignore_empty_lines, self.invalid_row_handler) + + def __setstate__(self, state): + (self.delimiter, self.quote_char, self.double_quote, + self.escape_char, self.newlines_in_values, + self.ignore_empty_lines, self.invalid_row_handler) = state + + def __eq__(self, other): + try: + return self.equals(other) + except TypeError: + return False + + +cdef class _ISO8601(_Weakrefable): + """ + A special object indicating ISO-8601 parsing. + """ + __slots__ = () + + def __str__(self): + return 'ISO8601' + + def __eq__(self, other): + return isinstance(other, _ISO8601) + + +ISO8601 = _ISO8601() + + +cdef class ConvertOptions(_Weakrefable): + """ + Options for converting CSV data. + + Parameters + ---------- + check_utf8 : bool, optional (default True) + Whether to check UTF8 validity of string columns. + column_types : pyarrow.Schema or dict, optional + Explicitly map column names to column types. Passing this argument + disables type inference on the defined columns. + null_values : list, optional + A sequence of strings that denote nulls in the data + (defaults are appropriate in most cases). Note that by default, + string columns are not checked for null values. To enable + null checking for those, specify ``strings_can_be_null=True``. + true_values : list, optional + A sequence of strings that denote true booleans in the data + (defaults are appropriate in most cases). + false_values : list, optional + A sequence of strings that denote false booleans in the data + (defaults are appropriate in most cases). + decimal_point : 1-character string, optional (default '.') + The character used as decimal point in floating-point and decimal + data. + strings_can_be_null : bool, optional (default False) + Whether string / binary columns can have null values. + If true, then strings in null_values are considered null for + string columns. + If false, then all strings are valid string values. + quoted_strings_can_be_null : bool, optional (default True) + Whether quoted values can be null. + If true, then strings in "null_values" are also considered null + when they appear quoted in the CSV file. Otherwise, quoted values + are never considered null. + include_columns : list, optional + The names of columns to include in the Table. + If empty, the Table will include all columns from the CSV file. + If not empty, only these columns will be included, in this order. + include_missing_columns : bool, optional (default False) + If false, columns in `include_columns` but not in the CSV file will + error out. + If true, columns in `include_columns` but not in the CSV file will + produce a column of nulls (whose type is selected using + `column_types`, or null by default). + This option is ignored if `include_columns` is empty. + auto_dict_encode : bool, optional (default False) + Whether to try to automatically dict-encode string / binary data. + If true, then when type inference detects a string or binary column, + it it dict-encoded up to `auto_dict_max_cardinality` distinct values + (per chunk), after which it switches to regular encoding. + This setting is ignored for non-inferred columns (those in + `column_types`). + auto_dict_max_cardinality : int, optional + The maximum dictionary cardinality for `auto_dict_encode`. + This value is per chunk. + timestamp_parsers : list, optional + A sequence of strptime()-compatible format strings, tried in order + when attempting to infer or convert timestamp values (the special + value ISO8601() can also be given). By default, a fast built-in + ISO-8601 parser is used. + + Examples + -------- + + Defining an example data: + + >>> import io + >>> s = ( + ... "animals,n_legs,entry,fast\\n" + ... "Flamingo,2,01/03/2022,Yes\\n" + ... "Horse,4,02/03/2022,Yes\\n" + ... "Brittle stars,5,03/03/2022,No\\n" + ... "Centipede,100,04/03/2022,No\\n" + ... ",6,05/03/2022," + ... ) + >>> print(s) + animals,n_legs,entry,fast + Flamingo,2,01/03/2022,Yes + Horse,4,02/03/2022,Yes + Brittle stars,5,03/03/2022,No + Centipede,100,04/03/2022,No + ,6,05/03/2022, + + Change the type of a column: + + >>> import pyarrow as pa + >>> from pyarrow import csv + >>> convert_options = csv.ConvertOptions(column_types={"n_legs": pa.float64()}) + >>> csv.read_csv(io.BytesIO(s.encode()), convert_options=convert_options) + pyarrow.Table + animals: string + n_legs: double + entry: string + fast: string + ---- + animals: [["Flamingo","Horse","Brittle stars","Centipede",""]] + n_legs: [[2,4,5,100,6]] + entry: [["01/03/2022","02/03/2022","03/03/2022","04/03/2022","05/03/2022"]] + fast: [["Yes","Yes","No","No",""]] + + Define a date parsing format to get a timestamp type column + (in case dates are not in ISO format and not converted by default): + + >>> convert_options = csv.ConvertOptions( + ... timestamp_parsers=["%m/%d/%Y", "%m-%d-%Y"]) + >>> csv.read_csv(io.BytesIO(s.encode()), convert_options=convert_options) + pyarrow.Table + animals: string + n_legs: int64 + entry: timestamp[s] + fast: string + ---- + animals: [["Flamingo","Horse","Brittle stars","Centipede",""]] + n_legs: [[2,4,5,100,6]] + entry: [[2022-01-03 00:00:00,2022-02-03 00:00:00,2022-03-03 00:00:00,2022-04-03 00:00:00,2022-05-03 00:00:00]] + fast: [["Yes","Yes","No","No",""]] + + Specify a subset of columns to be read: + + >>> convert_options = csv.ConvertOptions( + ... include_columns=["animals", "n_legs"]) + >>> csv.read_csv(io.BytesIO(s.encode()), convert_options=convert_options) + pyarrow.Table + animals: string + n_legs: int64 + ---- + animals: [["Flamingo","Horse","Brittle stars","Centipede",""]] + n_legs: [[2,4,5,100,6]] + + List additional column to be included as a null typed column: + + >>> convert_options = csv.ConvertOptions( + ... include_columns=["animals", "n_legs", "location"], + ... include_missing_columns=True) + >>> csv.read_csv(io.BytesIO(s.encode()), convert_options=convert_options) + pyarrow.Table + animals: string + n_legs: int64 + location: null + ---- + animals: [["Flamingo","Horse","Brittle stars","Centipede",""]] + n_legs: [[2,4,5,100,6]] + location: [5 nulls] + + Define columns as dictionary type (by default only the + string/binary columns are dictionary encoded): + + >>> convert_options = csv.ConvertOptions( + ... timestamp_parsers=["%m/%d/%Y", "%m-%d-%Y"], + ... auto_dict_encode=True) + >>> csv.read_csv(io.BytesIO(s.encode()), convert_options=convert_options) + pyarrow.Table + animals: dictionary + n_legs: int64 + entry: timestamp[s] + fast: dictionary + ---- + animals: [ -- dictionary: + ["Flamingo","Horse","Brittle stars","Centipede",""] -- indices: + [0,1,2,3,4]] + n_legs: [[2,4,5,100,6]] + entry: [[2022-01-03 00:00:00,2022-02-03 00:00:00,2022-03-03 00:00:00,2022-04-03 00:00:00,2022-05-03 00:00:00]] + fast: [ -- dictionary: + ["Yes","No",""] -- indices: + [0,0,1,1,2]] + + Set upper limit for the number of categories. If the categories + is more than the limit, the conversion to dictionary will not + happen: + + >>> convert_options = csv.ConvertOptions( + ... include_columns=["animals"], + ... auto_dict_encode=True, + ... auto_dict_max_cardinality=2) + >>> csv.read_csv(io.BytesIO(s.encode()), convert_options=convert_options) + pyarrow.Table + animals: string + ---- + animals: [["Flamingo","Horse","Brittle stars","Centipede",""]] + + Set empty strings to missing values: + + >>> convert_options = csv.ConvertOptions(include_columns=["animals", "n_legs"], + ... strings_can_be_null=True) + >>> csv.read_csv(io.BytesIO(s.encode()), convert_options=convert_options) + pyarrow.Table + animals: string + n_legs: int64 + ---- + animals: [["Flamingo","Horse","Brittle stars","Centipede",null]] + n_legs: [[2,4,5,100,6]] + + Define values to be True and False when converting a column + into a bool type: + + >>> convert_options = csv.ConvertOptions( + ... include_columns=["fast"], + ... false_values=["No"], + ... true_values=["Yes"]) + >>> csv.read_csv(io.BytesIO(s.encode()), convert_options=convert_options) + pyarrow.Table + fast: bool + ---- + fast: [[true,true,false,false,null]] + """ + + # Avoid mistakingly creating attributes + __slots__ = () + + def __cinit__(self, *argw, **kwargs): + self.options.reset( + new CCSVConvertOptions(CCSVConvertOptions.Defaults())) + + def __init__(self, *, check_utf8=None, column_types=None, null_values=None, + true_values=None, false_values=None, decimal_point=None, + strings_can_be_null=None, quoted_strings_can_be_null=None, + include_columns=None, include_missing_columns=None, + auto_dict_encode=None, auto_dict_max_cardinality=None, + timestamp_parsers=None): + if check_utf8 is not None: + self.check_utf8 = check_utf8 + if column_types is not None: + self.column_types = column_types + if null_values is not None: + self.null_values = null_values + if true_values is not None: + self.true_values = true_values + if false_values is not None: + self.false_values = false_values + if decimal_point is not None: + self.decimal_point = decimal_point + if strings_can_be_null is not None: + self.strings_can_be_null = strings_can_be_null + if quoted_strings_can_be_null is not None: + self.quoted_strings_can_be_null = quoted_strings_can_be_null + if include_columns is not None: + self.include_columns = include_columns + if include_missing_columns is not None: + self.include_missing_columns = include_missing_columns + if auto_dict_encode is not None: + self.auto_dict_encode = auto_dict_encode + if auto_dict_max_cardinality is not None: + self.auto_dict_max_cardinality = auto_dict_max_cardinality + if timestamp_parsers is not None: + self.timestamp_parsers = timestamp_parsers + + @property + def check_utf8(self): + """ + Whether to check UTF8 validity of string columns. + """ + return deref(self.options).check_utf8 + + @check_utf8.setter + def check_utf8(self, value): + deref(self.options).check_utf8 = value + + @property + def strings_can_be_null(self): + """ + Whether string / binary columns can have null values. + """ + return deref(self.options).strings_can_be_null + + @strings_can_be_null.setter + def strings_can_be_null(self, value): + deref(self.options).strings_can_be_null = value + + @property + def quoted_strings_can_be_null(self): + """ + Whether quoted values can be null. + """ + return deref(self.options).quoted_strings_can_be_null + + @quoted_strings_can_be_null.setter + def quoted_strings_can_be_null(self, value): + deref(self.options).quoted_strings_can_be_null = value + + @property + def column_types(self): + """ + Explicitly map column names to column types. + """ + d = {frombytes(item.first): pyarrow_wrap_data_type(item.second) + for item in deref(self.options).column_types} + return d + + @column_types.setter + def column_types(self, value): + cdef: + shared_ptr[CDataType] typ + + if isinstance(value, Mapping): + value = value.items() + + deref(self.options).column_types.clear() + for item in value: + if isinstance(item, Field): + k = item.name + v = item.type + else: + k, v = item + typ = pyarrow_unwrap_data_type(ensure_type(v)) + assert typ != NULL + deref(self.options).column_types[tobytes(k)] = typ + + @property + def null_values(self): + """ + A sequence of strings that denote nulls in the data. + """ + return [frombytes(x) for x in deref(self.options).null_values] + + @null_values.setter + def null_values(self, value): + deref(self.options).null_values = [tobytes(x) for x in value] + + @property + def true_values(self): + """ + A sequence of strings that denote true booleans in the data. + """ + return [frombytes(x) for x in deref(self.options).true_values] + + @true_values.setter + def true_values(self, value): + deref(self.options).true_values = [tobytes(x) for x in value] + + @property + def false_values(self): + """ + A sequence of strings that denote false booleans in the data. + """ + return [frombytes(x) for x in deref(self.options).false_values] + + @false_values.setter + def false_values(self, value): + deref(self.options).false_values = [tobytes(x) for x in value] + + @property + def decimal_point(self): + """ + The character used as decimal point in floating-point and decimal + data. + """ + return chr(deref(self.options).decimal_point) + + @decimal_point.setter + def decimal_point(self, value): + deref(self.options).decimal_point = _single_char(value) + + @property + def auto_dict_encode(self): + """ + Whether to try to automatically dict-encode string / binary data. + """ + return deref(self.options).auto_dict_encode + + @auto_dict_encode.setter + def auto_dict_encode(self, value): + deref(self.options).auto_dict_encode = value + + @property + def auto_dict_max_cardinality(self): + """ + The maximum dictionary cardinality for `auto_dict_encode`. + + This value is per chunk. + """ + return deref(self.options).auto_dict_max_cardinality + + @auto_dict_max_cardinality.setter + def auto_dict_max_cardinality(self, value): + deref(self.options).auto_dict_max_cardinality = value + + @property + def include_columns(self): + """ + The names of columns to include in the Table. + + If empty, the Table will include all columns from the CSV file. + If not empty, only these columns will be included, in this order. + """ + return [frombytes(s) for s in deref(self.options).include_columns] + + @include_columns.setter + def include_columns(self, value): + deref(self.options).include_columns.clear() + for item in value: + deref(self.options).include_columns.push_back(tobytes(item)) + + @property + def include_missing_columns(self): + """ + If false, columns in `include_columns` but not in the CSV file will + error out. + If true, columns in `include_columns` but not in the CSV file will + produce a null column (whose type is selected using `column_types`, + or null by default). + This option is ignored if `include_columns` is empty. + """ + return deref(self.options).include_missing_columns + + @include_missing_columns.setter + def include_missing_columns(self, value): + deref(self.options).include_missing_columns = value + + @property + def timestamp_parsers(self): + """ + A sequence of strptime()-compatible format strings, tried in order + when attempting to infer or convert timestamp values (the special + value ISO8601() can also be given). By default, a fast built-in + ISO-8601 parser is used. + """ + cdef: + shared_ptr[CTimestampParser] c_parser + c_string kind + + parsers = [] + for c_parser in deref(self.options).timestamp_parsers: + kind = deref(c_parser).kind() + if kind == b'strptime': + parsers.append(frombytes(deref(c_parser).format())) + else: + assert kind == b'iso8601' + parsers.append(ISO8601) + + return parsers + + @timestamp_parsers.setter + def timestamp_parsers(self, value): + cdef: + vector[shared_ptr[CTimestampParser]] c_parsers + + for v in value: + if isinstance(v, str): + c_parsers.push_back(CTimestampParser.MakeStrptime(tobytes(v))) + elif v == ISO8601: + c_parsers.push_back(CTimestampParser.MakeISO8601()) + else: + raise TypeError("Expected list of str or ISO8601 objects") + + deref(self.options).timestamp_parsers = move(c_parsers) + + @staticmethod + cdef ConvertOptions wrap(CCSVConvertOptions options): + out = ConvertOptions() + out.options.reset(new CCSVConvertOptions(move(options))) + return out + + def validate(self): + check_status(deref(self.options).Validate()) + + def equals(self, ConvertOptions other): + """ + Parameters + ---------- + other : pyarrow.csv.ConvertOptions + + Returns + ------- + bool + """ + return ( + self.check_utf8 == other.check_utf8 and + self.column_types == other.column_types and + self.null_values == other.null_values and + self.true_values == other.true_values and + self.false_values == other.false_values and + self.decimal_point == other.decimal_point and + self.timestamp_parsers == other.timestamp_parsers and + self.strings_can_be_null == other.strings_can_be_null and + self.quoted_strings_can_be_null == + other.quoted_strings_can_be_null and + self.auto_dict_encode == other.auto_dict_encode and + self.auto_dict_max_cardinality == + other.auto_dict_max_cardinality and + self.include_columns == other.include_columns and + self.include_missing_columns == other.include_missing_columns + ) + + def __getstate__(self): + return (self.check_utf8, self.column_types, self.null_values, + self.true_values, self.false_values, self.decimal_point, + self.timestamp_parsers, self.strings_can_be_null, + self.quoted_strings_can_be_null, self.auto_dict_encode, + self.auto_dict_max_cardinality, self.include_columns, + self.include_missing_columns) + + def __setstate__(self, state): + (self.check_utf8, self.column_types, self.null_values, + self.true_values, self.false_values, self.decimal_point, + self.timestamp_parsers, self.strings_can_be_null, + self.quoted_strings_can_be_null, self.auto_dict_encode, + self.auto_dict_max_cardinality, self.include_columns, + self.include_missing_columns) = state + + def __eq__(self, other): + try: + return self.equals(other) + except TypeError: + return False + + +cdef _get_reader(input_file, ReadOptions read_options, + shared_ptr[CInputStream]* out): + use_memory_map = False + get_input_stream(input_file, use_memory_map, out) + if read_options is not None: + out[0] = native_transcoding_input_stream(out[0], + read_options.encoding, + 'utf8') + + +cdef _get_read_options(ReadOptions read_options, CCSVReadOptions* out): + if read_options is None: + out[0] = CCSVReadOptions.Defaults() + else: + out[0] = deref(read_options.options) + + +cdef _get_parse_options(ParseOptions parse_options, CCSVParseOptions* out): + if parse_options is None: + out[0] = CCSVParseOptions.Defaults() + else: + out[0] = deref(parse_options.options) + + +cdef _get_convert_options(ConvertOptions convert_options, + CCSVConvertOptions* out): + if convert_options is None: + out[0] = CCSVConvertOptions.Defaults() + else: + out[0] = deref(convert_options.options) + + +cdef class CSVStreamingReader(RecordBatchReader): + """An object that reads record batches incrementally from a CSV file. + + Should not be instantiated directly by user code. + """ + cdef readonly: + Schema schema + + def __init__(self): + raise TypeError(f"Do not call {self.__class__.__name__}'s constructor directly, " + "use pyarrow.csv.open_csv() instead.") + + # Note about cancellation: we cannot create a SignalStopHandler + # by default here, as several CSVStreamingReader instances may be + # created (including by the same thread). Handling cancellation + # would require having the user pass the SignalStopHandler. + # (in addition to solving ARROW-11853) + + cdef _open(self, shared_ptr[CInputStream] stream, + CCSVReadOptions c_read_options, + CCSVParseOptions c_parse_options, + CCSVConvertOptions c_convert_options, + MemoryPool memory_pool): + cdef: + shared_ptr[CSchema] c_schema + CIOContext io_context + + io_context = CIOContext(maybe_unbox_memory_pool(memory_pool)) + + with nogil: + self.reader = GetResultValue( + CCSVStreamingReader.Make( + io_context, stream, + move(c_read_options), move(c_parse_options), + move(c_convert_options))) + c_schema = self.reader.get().schema() + + self.schema = pyarrow_wrap_schema(c_schema) + + +def read_csv(input_file, read_options=None, parse_options=None, + convert_options=None, MemoryPool memory_pool=None): + """ + Read a Table from a stream of CSV data. + + Parameters + ---------- + input_file : string, path or file-like object + The location of CSV data. If a string or path, and if it ends + with a recognized compressed file extension (e.g. ".gz" or ".bz2"), + the data is automatically decompressed when reading. + read_options : pyarrow.csv.ReadOptions, optional + Options for the CSV reader (see pyarrow.csv.ReadOptions constructor + for defaults) + parse_options : pyarrow.csv.ParseOptions, optional + Options for the CSV parser + (see pyarrow.csv.ParseOptions constructor for defaults) + convert_options : pyarrow.csv.ConvertOptions, optional + Options for converting CSV data + (see pyarrow.csv.ConvertOptions constructor for defaults) + memory_pool : MemoryPool, optional + Pool to allocate Table memory from + + Returns + ------- + :class:`pyarrow.Table` + Contents of the CSV file as a in-memory table. + + Examples + -------- + + Defining an example file from bytes object: + + >>> import io + >>> s = ( + ... "animals,n_legs,entry\\n" + ... "Flamingo,2,2022-03-01\\n" + ... "Horse,4,2022-03-02\\n" + ... "Brittle stars,5,2022-03-03\\n" + ... "Centipede,100,2022-03-04" + ... ) + >>> print(s) + animals,n_legs,entry + Flamingo,2,2022-03-01 + Horse,4,2022-03-02 + Brittle stars,5,2022-03-03 + Centipede,100,2022-03-04 + >>> source = io.BytesIO(s.encode()) + + Reading from the file + + >>> from pyarrow import csv + >>> csv.read_csv(source) + pyarrow.Table + animals: string + n_legs: int64 + entry: date32[day] + ---- + animals: [["Flamingo","Horse","Brittle stars","Centipede"]] + n_legs: [[2,4,5,100]] + entry: [[2022-03-01,2022-03-02,2022-03-03,2022-03-04]] + """ + cdef: + shared_ptr[CInputStream] stream + CCSVReadOptions c_read_options + CCSVParseOptions c_parse_options + CCSVConvertOptions c_convert_options + CIOContext io_context + SharedPtrNoGIL[CCSVReader] reader + shared_ptr[CTable] table + + _get_reader(input_file, read_options, &stream) + _get_read_options(read_options, &c_read_options) + _get_parse_options(parse_options, &c_parse_options) + _get_convert_options(convert_options, &c_convert_options) + + with SignalStopHandler() as stop_handler: + io_context = CIOContext( + maybe_unbox_memory_pool(memory_pool), + ( stop_handler.stop_token).stop_token) + reader = GetResultValue(CCSVReader.Make( + io_context, stream, + c_read_options, c_parse_options, c_convert_options)) + + with nogil: + table = GetResultValue(reader.get().Read()) + + return pyarrow_wrap_table(table) + + +def open_csv(input_file, read_options=None, parse_options=None, + convert_options=None, MemoryPool memory_pool=None): + """ + Open a streaming reader of CSV data. + + Reading using this function is always single-threaded. + + Parameters + ---------- + input_file : string, path or file-like object + The location of CSV data. If a string or path, and if it ends + with a recognized compressed file extension (e.g. ".gz" or ".bz2"), + the data is automatically decompressed when reading. + read_options : pyarrow.csv.ReadOptions, optional + Options for the CSV reader (see pyarrow.csv.ReadOptions constructor + for defaults) + parse_options : pyarrow.csv.ParseOptions, optional + Options for the CSV parser + (see pyarrow.csv.ParseOptions constructor for defaults) + convert_options : pyarrow.csv.ConvertOptions, optional + Options for converting CSV data + (see pyarrow.csv.ConvertOptions constructor for defaults) + memory_pool : MemoryPool, optional + Pool to allocate RecordBatch memory from + + Returns + ------- + :class:`pyarrow.csv.CSVStreamingReader` + """ + cdef: + shared_ptr[CInputStream] stream + CCSVReadOptions c_read_options + CCSVParseOptions c_parse_options + CCSVConvertOptions c_convert_options + CSVStreamingReader reader + + _get_reader(input_file, read_options, &stream) + _get_read_options(read_options, &c_read_options) + _get_parse_options(parse_options, &c_parse_options) + _get_convert_options(convert_options, &c_convert_options) + + reader = CSVStreamingReader.__new__(CSVStreamingReader) + reader._open(stream, move(c_read_options), move(c_parse_options), + move(c_convert_options), memory_pool) + return reader + + +def _raise_invalid_function_option(value, description, *, + exception_class=ValueError): + raise exception_class(f"\"{value}\" is not a valid {description}") + + +cdef CQuotingStyle unwrap_quoting_style(quoting_style) except *: + if quoting_style == "needed": + return CQuotingStyle_Needed + elif quoting_style == "all_valid": + return CQuotingStyle_AllValid + elif quoting_style == "none": + return CQuotingStyle_None + _raise_invalid_function_option(quoting_style, "quoting style") + + +cdef wrap_quoting_style(quoting_style): + if quoting_style == CQuotingStyle_Needed: + return 'needed' + elif quoting_style == CQuotingStyle_AllValid: + return 'all_valid' + elif quoting_style == CQuotingStyle_None: + return 'none' + + +cdef class WriteOptions(_Weakrefable): + """ + Options for writing CSV files. + + Parameters + ---------- + include_header : bool, optional (default True) + Whether to write an initial header line with column names + batch_size : int, optional (default 1024) + How many rows to process together when converting and writing + CSV data + delimiter : 1-character string, optional (default ",") + The character delimiting individual cells in the CSV data. + quoting_style : str, optional (default "needed") + Whether to quote values, and if so, which quoting style to use. + The following values are accepted: + + - "needed" (default): only enclose values in quotes when needed. + - "all_valid": enclose all valid values in quotes; nulls are not quoted. + - "none": do not enclose any values in quotes; values containing + special characters (such as quotes, cell delimiters or line endings) + will raise an error. + quoting_header : str, optional (default "needed") + Same as quoting_style, but for header column names. Accepts same values. + Note : both "needed" and "all_valid" have the same effect of quoting all column names. + """ + + # Avoid mistakingly creating attributes + __slots__ = () + + def __init__(self, *, include_header=None, batch_size=None, + delimiter=None, quoting_style=None, quoting_header=None): + self.options.reset(new CCSVWriteOptions(CCSVWriteOptions.Defaults())) + if include_header is not None: + self.include_header = include_header + if batch_size is not None: + self.batch_size = batch_size + if delimiter is not None: + self.delimiter = delimiter + if quoting_style is not None: + self.quoting_style = quoting_style + if quoting_header is not None: + self.quoting_header = quoting_header + + @property + def include_header(self): + """ + Whether to write an initial header line with column names. + """ + return deref(self.options).include_header + + @include_header.setter + def include_header(self, value): + deref(self.options).include_header = value + + @property + def batch_size(self): + """ + How many rows to process together when converting and writing + CSV data. + """ + return deref(self.options).batch_size + + @batch_size.setter + def batch_size(self, value): + deref(self.options).batch_size = value + + @property + def delimiter(self): + """ + The character delimiting individual cells in the CSV data. + """ + return chr(deref(self.options).delimiter) + + @delimiter.setter + def delimiter(self, value): + deref(self.options).delimiter = _single_char(value) + + @property + def quoting_style(self): + """ + Whether to quote values, and if so, which quoting style to use. + The following values are accepted: + + - "needed" (default): only enclose values in quotes when needed. + - "all_valid": enclose all valid values in quotes; nulls are not quoted. + - "none": do not enclose any values in quotes; values containing + special characters (such as quotes, cell delimiters or line endings) + will raise an error. + """ + return wrap_quoting_style(deref(self.options).quoting_style) + + @quoting_style.setter + def quoting_style(self, value): + deref(self.options).quoting_style = unwrap_quoting_style(value) + + @property + def quoting_header(self): + """ + Same as quoting_style, but for header column names. + Note : both "needed" and "all_valid" have the same effect of quoting all column names. + """ + return wrap_quoting_style(deref(self.options).quoting_header) + + @quoting_header.setter + def quoting_header(self, value): + deref(self.options).quoting_header = unwrap_quoting_style(value) + + @staticmethod + cdef WriteOptions wrap(CCSVWriteOptions options): + out = WriteOptions() + out.options.reset(new CCSVWriteOptions(move(options))) + return out + + def validate(self): + check_status(self.options.get().Validate()) + + +cdef _get_write_options(WriteOptions write_options, CCSVWriteOptions* out): + if write_options is None: + out[0] = CCSVWriteOptions.Defaults() + else: + out[0] = deref(write_options.options) + + +def write_csv(data, output_file, write_options=None, + MemoryPool memory_pool=None): + """ + Write record batch or table to a CSV file. + + Parameters + ---------- + data : pyarrow.RecordBatch or pyarrow.Table + The data to write. + output_file : string, path, pyarrow.NativeFile, or file-like object + The location where to write the CSV data. + write_options : pyarrow.csv.WriteOptions + Options to configure writing the CSV data. + memory_pool : MemoryPool, optional + Pool for temporary allocations. + + Examples + -------- + + >>> import pyarrow as pa + >>> from pyarrow import csv + + >>> legs = pa.array([2, 4, 5, 100]) + >>> animals = pa.array(["Flamingo", "Horse", "Brittle stars", "Centipede"]) + >>> entry_date = pa.array(["01/03/2022", "02/03/2022", + ... "03/03/2022", "04/03/2022"]) + >>> table = pa.table([animals, legs, entry_date], + ... names=["animals", "n_legs", "entry"]) + + >>> csv.write_csv(table, "animals.csv") + + >>> write_options = csv.WriteOptions(include_header=False) + >>> csv.write_csv(table, "animals.csv", write_options=write_options) + + >>> write_options = csv.WriteOptions(delimiter=";") + >>> csv.write_csv(table, "animals.csv", write_options=write_options) + """ + cdef: + shared_ptr[COutputStream] stream + CCSVWriteOptions c_write_options + CMemoryPool* c_memory_pool + CRecordBatch* batch + CTable* table + _get_write_options(write_options, &c_write_options) + + get_writer(output_file, &stream) + c_memory_pool = maybe_unbox_memory_pool(memory_pool) + c_write_options.io_context = CIOContext(c_memory_pool) + if isinstance(data, RecordBatch): + batch = pyarrow_unwrap_batch(data).get() + with nogil: + check_status(WriteCSV(deref(batch), c_write_options, stream.get())) + elif isinstance(data, Table): + table = pyarrow_unwrap_table(data).get() + with nogil: + check_status(WriteCSV(deref(table), c_write_options, stream.get())) + else: + raise TypeError(f"Expected Table or RecordBatch, got '{type(data)}'") + + +cdef class CSVWriter(_CRecordBatchWriter): + """ + Writer to create a CSV file. + + Parameters + ---------- + sink : str, path, pyarrow.OutputStream or file-like object + The location where to write the CSV data. + schema : pyarrow.Schema + The schema of the data to be written. + write_options : pyarrow.csv.WriteOptions + Options to configure writing the CSV data. + memory_pool : MemoryPool, optional + Pool for temporary allocations. + """ + + def __init__(self, sink, Schema schema, *, + WriteOptions write_options=None, MemoryPool memory_pool=None): + cdef: + shared_ptr[COutputStream] c_stream + shared_ptr[CSchema] c_schema = pyarrow_unwrap_schema(schema) + CCSVWriteOptions c_write_options + CMemoryPool* c_memory_pool = maybe_unbox_memory_pool(memory_pool) + _get_write_options(write_options, &c_write_options) + c_write_options.io_context = CIOContext(c_memory_pool) + get_writer(sink, &c_stream) + with nogil: + self.writer = GetResultValue(MakeCSVWriter( + c_stream, c_schema, c_write_options)) diff --git a/shared/package-files/31/311165957fcb3ba0105cd93202e8c475ac7680462b9d000bc92c01f6db8ff395/blob b/shared/package-files/31/311165957fcb3ba0105cd93202e8c475ac7680462b9d000bc92c01f6db8ff395/blob new file mode 100644 index 0000000000000000000000000000000000000000..bf84f802b1ab502fc50794997645b52756bb6df2 --- /dev/null +++ b/shared/package-files/31/311165957fcb3ba0105cd93202e8c475ac7680462b9d000bc92c01f6db8ff395/blob @@ -0,0 +1,899 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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. + +// Array accessor classes for List, LargeList, ListView, LargeListView, FixedSizeList, +// Map, Struct, and Union + +#pragma once + +#include +#include +#include +#include +#include + +#include "arrow/array/array_base.h" +#include "arrow/array/data.h" +#include "arrow/result.h" +#include "arrow/status.h" +#include "arrow/type.h" +#include "arrow/type_fwd.h" +#include "arrow/util/checked_cast.h" +#include "arrow/util/macros.h" +#include "arrow/util/visibility.h" + +namespace arrow { + +/// \addtogroup nested-arrays +/// +/// @{ + +// ---------------------------------------------------------------------- +// VarLengthListLikeArray + +template +class VarLengthListLikeArray; + +namespace internal { + +// Private helper for [Large]List[View]Array::SetData. +// Unfortunately, trying to define VarLengthListLikeArray::SetData outside of this header +// doesn't play well with MSVC. +template +void SetListData(VarLengthListLikeArray* self, + const std::shared_ptr& data, + Type::type expected_type_id = TYPE::type_id); + +/// \brief A version of Flatten that keeps recursively flattening until an array of +/// non-list values is reached. +/// +/// Array types considered to be lists by this function: +/// - list +/// - large_list +/// - list_view +/// - large_list_view +/// - fixed_size_list +/// +/// \see ListArray::Flatten +ARROW_EXPORT Result> FlattenLogicalListRecursively( + const Array& in_array, MemoryPool* memory_pool); + +} // namespace internal + +/// Base class for variable-sized list and list-view arrays, regardless of offset size. +template +class VarLengthListLikeArray : public Array { + public: + using TypeClass = TYPE; + using offset_type = typename TypeClass::offset_type; + + const TypeClass* var_length_list_like_type() const { return this->list_type_; } + + /// \brief Return array object containing the list's values + /// + /// Note that this buffer does not account for any slice offset or length. + const std::shared_ptr& values() const { return values_; } + + /// Note that this buffer does not account for any slice offset or length. + const std::shared_ptr& value_offsets() const { return data_->buffers[1]; } + + const std::shared_ptr& value_type() const { return list_type_->value_type(); } + + /// Return pointer to raw value offsets accounting for any slice offset + const offset_type* raw_value_offsets() const { return raw_value_offsets_; } + + // The following functions will not perform boundschecking + + offset_type value_offset(int64_t i) const { return raw_value_offsets_[i]; } + + /// \brief Return the size of the value at a particular index + /// + /// Since non-empty null lists and list-views are possible, avoid calling this + /// function when the list at slot i is null. + /// + /// \pre IsValid(i) + virtual offset_type value_length(int64_t i) const = 0; + + /// \pre IsValid(i) + std::shared_ptr value_slice(int64_t i) const { + return values_->Slice(value_offset(i), value_length(i)); + } + + /// \brief Flatten all level recursively until reach a non-list type, and return + /// a non-list type Array. + /// + /// \see internal::FlattenLogicalListRecursively + Result> FlattenRecursively( + MemoryPool* memory_pool = default_memory_pool()) const { + return internal::FlattenLogicalListRecursively(*this, memory_pool); + } + + protected: + friend void internal::SetListData(VarLengthListLikeArray* self, + const std::shared_ptr& data, + Type::type expected_type_id); + + const TypeClass* list_type_ = NULLPTR; + std::shared_ptr values_; + const offset_type* raw_value_offsets_ = NULLPTR; +}; + +// ---------------------------------------------------------------------- +// ListArray / LargeListArray + +template +class BaseListArray : public VarLengthListLikeArray { + public: + using TypeClass = TYPE; + using offset_type = typename TYPE::offset_type; + + const TypeClass* list_type() const { return this->var_length_list_like_type(); } + + /// \brief Return the size of the value at a particular index + /// + /// Since non-empty null lists are possible, avoid calling this + /// function when the list at slot i is null. + /// + /// \pre IsValid(i) + offset_type value_length(int64_t i) const final { + return this->raw_value_offsets_[i + 1] - this->raw_value_offsets_[i]; + } +}; + +/// Concrete Array class for list data +class ARROW_EXPORT ListArray : public BaseListArray { + public: + explicit ListArray(std::shared_ptr data); + + ListArray(std::shared_ptr type, int64_t length, + std::shared_ptr value_offsets, std::shared_ptr values, + std::shared_ptr null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount, int64_t offset = 0); + + /// \brief Construct ListArray from array of offsets and child value array + /// + /// This function does the bare minimum of validation of the offsets and + /// input types, and will allocate a new offsets array if necessary (i.e. if + /// the offsets contain any nulls). If the offsets do not have nulls, they + /// are assumed to be well-formed. + /// + /// If a null_bitmap is not provided, the nulls will be inferred from the offsets' + /// null bitmap. But if a null_bitmap is provided, the offsets array can't have nulls. + /// + /// And when a null_bitmap is provided, the offsets array cannot be a slice (i.e. an + /// array with offset() > 0). + /// + /// \param[in] offsets Array containing n + 1 offsets encoding length and + /// size. Must be of int32 type + /// \param[in] values Array containing list values + /// \param[in] pool MemoryPool in case new offsets array needs to be + /// allocated because of null values + /// \param[in] null_bitmap Optional validity bitmap + /// \param[in] null_count Optional null count in null_bitmap + static Result> FromArrays( + const Array& offsets, const Array& values, MemoryPool* pool = default_memory_pool(), + std::shared_ptr null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount); + + static Result> FromArrays( + std::shared_ptr type, const Array& offsets, const Array& values, + MemoryPool* pool = default_memory_pool(), + std::shared_ptr null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount); + + /// \brief Build a ListArray from a ListViewArray + static Result> FromListView(const ListViewArray& source, + MemoryPool* pool); + + /// \brief Return an Array that is a concatenation of the lists in this array. + /// + /// Note that it's different from `values()` in that it takes into + /// consideration of this array's offsets as well as null elements backed + /// by non-empty lists (they are skipped, thus copying may be needed). + Result> Flatten( + MemoryPool* memory_pool = default_memory_pool()) const; + + /// \brief Return list offsets as an Int32Array + /// + /// The returned array will not have a validity bitmap, so you cannot expect + /// to pass it to ListArray::FromArrays() and get back the same list array + /// if the original one has nulls. + std::shared_ptr offsets() const; + + protected: + // This constructor defers SetData to a derived array class + ListArray() = default; + + void SetData(const std::shared_ptr& data); +}; + +/// Concrete Array class for large list data (with 64-bit offsets) +class ARROW_EXPORT LargeListArray : public BaseListArray { + public: + explicit LargeListArray(const std::shared_ptr& data); + + LargeListArray(const std::shared_ptr& type, int64_t length, + const std::shared_ptr& value_offsets, + const std::shared_ptr& values, + const std::shared_ptr& null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount, int64_t offset = 0); + + /// \brief Construct LargeListArray from array of offsets and child value array + /// + /// This function does the bare minimum of validation of the offsets and + /// input types, and will allocate a new offsets array if necessary (i.e. if + /// the offsets contain any nulls). If the offsets do not have nulls, they + /// are assumed to be well-formed. + /// + /// If a null_bitmap is not provided, the nulls will be inferred from the offsets' + /// null bitmap. But if a null_bitmap is provided, the offsets array can't have nulls. + /// + /// And when a null_bitmap is provided, the offsets array cannot be a slice (i.e. an + /// array with offset() > 0). + /// + /// \param[in] offsets Array containing n + 1 offsets encoding length and + /// size. Must be of int64 type + /// \param[in] values Array containing list values + /// \param[in] pool MemoryPool in case new offsets array needs to be + /// allocated because of null values + /// \param[in] null_bitmap Optional validity bitmap + /// \param[in] null_count Optional null count in null_bitmap + static Result> FromArrays( + const Array& offsets, const Array& values, MemoryPool* pool = default_memory_pool(), + std::shared_ptr null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount); + + static Result> FromArrays( + std::shared_ptr type, const Array& offsets, const Array& values, + MemoryPool* pool = default_memory_pool(), + std::shared_ptr null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount); + + /// \brief Build a LargeListArray from a LargeListViewArray + static Result> FromListView( + const LargeListViewArray& source, MemoryPool* pool); + + /// \brief Return an Array that is a concatenation of the lists in this array. + /// + /// Note that it's different from `values()` in that it takes into + /// consideration of this array's offsets as well as null elements backed + /// by non-empty lists (they are skipped, thus copying may be needed). + Result> Flatten( + MemoryPool* memory_pool = default_memory_pool()) const; + + /// \brief Return list offsets as an Int64Array + std::shared_ptr offsets() const; + + protected: + void SetData(const std::shared_ptr& data); +}; + +// ---------------------------------------------------------------------- +// ListViewArray / LargeListViewArray + +template +class BaseListViewArray : public VarLengthListLikeArray { + public: + using TypeClass = TYPE; + using offset_type = typename TYPE::offset_type; + + const TypeClass* list_view_type() const { return this->var_length_list_like_type(); } + + /// \brief Note that this buffer does not account for any slice offset or length. + const std::shared_ptr& value_sizes() const { return this->data_->buffers[2]; } + + /// \brief Return pointer to raw value offsets accounting for any slice offset + const offset_type* raw_value_sizes() const { return raw_value_sizes_; } + + /// \brief Return the size of the value at a particular index + /// + /// This should not be called if the list-view at slot i is null. + /// The returned size in those cases could be any value from 0 to the + /// length of the child values array. + /// + /// \pre IsValid(i) + offset_type value_length(int64_t i) const final { return this->raw_value_sizes_[i]; } + + protected: + const offset_type* raw_value_sizes_ = NULLPTR; +}; + +/// \brief Concrete Array class for list-view data +class ARROW_EXPORT ListViewArray : public BaseListViewArray { + public: + explicit ListViewArray(std::shared_ptr data); + + ListViewArray(std::shared_ptr type, int64_t length, + std::shared_ptr value_offsets, + std::shared_ptr value_sizes, std::shared_ptr values, + std::shared_ptr null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount, int64_t offset = 0); + + /// \brief Construct ListViewArray from array of offsets, sizes, and child + /// value array + /// + /// Construct a ListViewArray using buffers from offsets and sizes arrays + /// that project views into the child values array. + /// + /// This function does the bare minimum of validation of the offsets/sizes and + /// input types. The offset and length of the offsets and sizes arrays must + /// match and that will be checked, but their contents will be assumed to be + /// well-formed. + /// + /// If a null_bitmap is not provided, the nulls will be inferred from the + /// offsets's null bitmap. But if a null_bitmap is provided, the offsets array + /// can't have nulls. + /// + /// And when a null_bitmap is provided, neither the offsets or sizes array can be a + /// slice (i.e. an array with offset() > 0). + /// + /// \param[in] offsets An array of int32 offsets into the values array. NULL values are + /// supported if the corresponding values in sizes is NULL or 0. + /// \param[in] sizes An array containing the int32 sizes of every view. NULL values are + /// taken to represent a NULL list-view in the array being created. + /// \param[in] values Array containing list values + /// \param[in] pool MemoryPool + /// \param[in] null_bitmap Optional validity bitmap + /// \param[in] null_count Optional null count in null_bitmap + static Result> FromArrays( + const Array& offsets, const Array& sizes, const Array& values, + MemoryPool* pool = default_memory_pool(), + std::shared_ptr null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount); + + static Result> FromArrays( + std::shared_ptr type, const Array& offsets, const Array& sizes, + const Array& values, MemoryPool* pool = default_memory_pool(), + std::shared_ptr null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount); + + /// \brief Build a ListViewArray from a ListArray + static Result> FromList(const ListArray& list_array, + MemoryPool* pool); + + /// \brief Return an Array that is a concatenation of the list-views in this array. + /// + /// Note that it's different from `values()` in that it takes into + /// consideration this array's offsets (which can be in any order) + /// and sizes. Nulls are skipped. + /// + /// This function invokes Concatenate() if list-views are non-contiguous. It + /// will try to minimize the number of array slices passed to Concatenate() by + /// maximizing the size of each slice (containing as many contiguous + /// list-views as possible). + Result> Flatten( + MemoryPool* memory_pool = default_memory_pool()) const; + + /// \brief Return list-view offsets as an Int32Array + /// + /// The returned array will not have a validity bitmap, so you cannot expect + /// to pass it to ListArray::FromArrays() and get back the same list array + /// if the original one has nulls. + std::shared_ptr offsets() const; + + /// \brief Return list-view sizes as an Int32Array + /// + /// The returned array will not have a validity bitmap, so you cannot expect + /// to pass it to ListViewArray::FromArrays() and get back the same list + /// array if the original one has nulls. + std::shared_ptr sizes() const; + + protected: + // This constructor defers SetData to a derived array class + ListViewArray() = default; + + void SetData(const std::shared_ptr& data); +}; + +/// \brief Concrete Array class for large list-view data (with 64-bit offsets +/// and sizes) +class ARROW_EXPORT LargeListViewArray : public BaseListViewArray { + public: + explicit LargeListViewArray(std::shared_ptr data); + + LargeListViewArray(std::shared_ptr type, int64_t length, + std::shared_ptr value_offsets, + std::shared_ptr value_sizes, std::shared_ptr values, + std::shared_ptr null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount, int64_t offset = 0); + + /// \brief Construct LargeListViewArray from array of offsets, sizes, and child + /// value array + /// + /// Construct an LargeListViewArray using buffers from offsets and sizes arrays + /// that project views into the values array. + /// + /// This function does the bare minimum of validation of the offsets/sizes and + /// input types. The offset and length of the offsets and sizes arrays must + /// match and that will be checked, but their contents will be assumed to be + /// well-formed. + /// + /// If a null_bitmap is not provided, the nulls will be inferred from the offsets' or + /// sizes' null bitmap. Only one of these two is allowed to have a null bitmap. But if a + /// null_bitmap is provided, the offsets array and the sizes array can't have nulls. + /// + /// And when a null_bitmap is provided, neither the offsets or sizes array can be a + /// slice (i.e. an array with offset() > 0). + /// + /// \param[in] offsets An array of int64 offsets into the values array. NULL values are + /// supported if the corresponding values in sizes is NULL or 0. + /// \param[in] sizes An array containing the int64 sizes of every view. NULL values are + /// taken to represent a NULL list-view in the array being created. + /// \param[in] values Array containing list values + /// \param[in] pool MemoryPool + /// \param[in] null_bitmap Optional validity bitmap + /// \param[in] null_count Optional null count in null_bitmap + static Result> FromArrays( + const Array& offsets, const Array& sizes, const Array& values, + MemoryPool* pool = default_memory_pool(), + std::shared_ptr null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount); + + static Result> FromArrays( + std::shared_ptr type, const Array& offsets, const Array& sizes, + const Array& values, MemoryPool* pool = default_memory_pool(), + std::shared_ptr null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount); + + /// \brief Build a LargeListViewArray from a LargeListArray + static Result> FromList( + const LargeListArray& list_array, MemoryPool* pool); + + /// \brief Return an Array that is a concatenation of the large list-views in this + /// array. + /// + /// Note that it's different from `values()` in that it takes into + /// consideration this array's offsets (which can be in any order) + /// and sizes. Nulls are skipped. + Result> Flatten( + MemoryPool* memory_pool = default_memory_pool()) const; + + /// \brief Return list-view offsets as an Int64Array + /// + /// The returned array will not have a validity bitmap, so you cannot expect + /// to pass it to LargeListArray::FromArrays() and get back the same list array + /// if the original one has nulls. + std::shared_ptr offsets() const; + + /// \brief Return list-view sizes as an Int64Array + /// + /// The returned array will not have a validity bitmap, so you cannot expect + /// to pass it to LargeListViewArray::FromArrays() and get back the same list + /// array if the original one has nulls. + std::shared_ptr sizes() const; + + protected: + // This constructor defers SetData to a derived array class + LargeListViewArray() = default; + + void SetData(const std::shared_ptr& data); +}; + +// ---------------------------------------------------------------------- +// MapArray + +/// Concrete Array class for map data +/// +/// NB: "value" in this context refers to a pair of a key and the corresponding item +class ARROW_EXPORT MapArray : public ListArray { + public: + using TypeClass = MapType; + + explicit MapArray(const std::shared_ptr& data); + + MapArray(const std::shared_ptr& type, int64_t length, + const std::shared_ptr& value_offsets, + const std::shared_ptr& keys, const std::shared_ptr& items, + const std::shared_ptr& null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount, int64_t offset = 0); + + MapArray(const std::shared_ptr& type, int64_t length, BufferVector buffers, + const std::shared_ptr& keys, const std::shared_ptr& items, + int64_t null_count = kUnknownNullCount, int64_t offset = 0); + + MapArray(const std::shared_ptr& type, int64_t length, + const std::shared_ptr& value_offsets, + const std::shared_ptr& values, + const std::shared_ptr& null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount, int64_t offset = 0); + + /// \brief Construct MapArray from array of offsets and child key, item arrays + /// + /// This function does the bare minimum of validation of the offsets and + /// input types, and will allocate a new offsets array if necessary (i.e. if + /// the offsets contain any nulls). If the offsets do not have nulls, they + /// are assumed to be well-formed + /// + /// \param[in] offsets Array containing n + 1 offsets encoding length and + /// size. Must be of int32 type + /// \param[in] keys Array containing key values + /// \param[in] items Array containing item values + /// \param[in] pool MemoryPool in case new offsets array needs to be + /// \param[in] null_bitmap Optional validity bitmap + /// allocated because of null values + static Result> FromArrays( + const std::shared_ptr& offsets, const std::shared_ptr& keys, + const std::shared_ptr& items, MemoryPool* pool = default_memory_pool(), + std::shared_ptr null_bitmap = NULLPTR); + + static Result> FromArrays( + std::shared_ptr type, const std::shared_ptr& offsets, + const std::shared_ptr& keys, const std::shared_ptr& items, + MemoryPool* pool = default_memory_pool(), + std::shared_ptr null_bitmap = NULLPTR); + + const MapType* map_type() const { return map_type_; } + + /// \brief Return array object containing all map keys + const std::shared_ptr& keys() const { return keys_; } + + /// \brief Return array object containing all mapped items + const std::shared_ptr& items() const { return items_; } + + /// Validate child data before constructing the actual MapArray. + static Status ValidateChildData( + const std::vector>& child_data); + + protected: + void SetData(const std::shared_ptr& data); + + static Result> FromArraysInternal( + std::shared_ptr type, const std::shared_ptr& offsets, + const std::shared_ptr& keys, const std::shared_ptr& items, + MemoryPool* pool, std::shared_ptr null_bitmap = NULLPTR); + + private: + const MapType* map_type_; + std::shared_ptr keys_, items_; +}; + +// ---------------------------------------------------------------------- +// FixedSizeListArray + +/// Concrete Array class for fixed size list data +class ARROW_EXPORT FixedSizeListArray : public Array { + public: + using TypeClass = FixedSizeListType; + using offset_type = TypeClass::offset_type; + + explicit FixedSizeListArray(const std::shared_ptr& data); + + FixedSizeListArray(const std::shared_ptr& type, int64_t length, + const std::shared_ptr& values, + const std::shared_ptr& null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount, int64_t offset = 0); + + const FixedSizeListType* list_type() const; + + /// \brief Return array object containing the list's values + const std::shared_ptr& values() const; + + const std::shared_ptr& value_type() const; + + // The following functions will not perform boundschecking + int64_t value_offset(int64_t i) const { + i += data_->offset; + return list_size_ * i; + } + /// \brief Return the fixed-size of the values + /// + /// No matter the value of the index parameter, the result is the same. + /// So even when the value at slot i is null, this function will return a + /// non-zero size. + /// + /// \pre IsValid(i) + int32_t value_length(int64_t i = 0) const { + ARROW_UNUSED(i); + return list_size_; + } + /// \pre IsValid(i) + std::shared_ptr value_slice(int64_t i) const { + return values_->Slice(value_offset(i), value_length(i)); + } + + /// \brief Return an Array that is a concatenation of the lists in this array. + /// + /// Note that it's different from `values()` in that it takes into + /// consideration null elements (they are skipped, thus copying may be needed). + Result> Flatten( + MemoryPool* memory_pool = default_memory_pool()) const; + + /// \brief Flatten all level recursively until reach a non-list type, and return + /// a non-list type Array. + /// + /// \see internal::FlattenLogicalListRecursively + Result> FlattenRecursively( + MemoryPool* memory_pool = default_memory_pool()) const { + return internal::FlattenLogicalListRecursively(*this, memory_pool); + } + + /// \brief Construct FixedSizeListArray from child value array and value_length + /// + /// \param[in] values Array containing list values + /// \param[in] list_size The fixed length of each list + /// \param[in] null_bitmap Optional validity bitmap + /// \param[in] null_count Optional null count in null_bitmap + /// \return Will have length equal to values.length() / list_size + static Result> FromArrays( + const std::shared_ptr& values, int32_t list_size, + std::shared_ptr null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount); + + /// \brief Construct FixedSizeListArray from child value array and type + /// + /// \param[in] values Array containing list values + /// \param[in] type The fixed sized list type + /// \param[in] null_bitmap Optional validity bitmap + /// \param[in] null_count Optional null count in null_bitmap + /// \return Will have length equal to values.length() / type.list_size() + static Result> FromArrays( + const std::shared_ptr& values, std::shared_ptr type, + std::shared_ptr null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount); + + protected: + void SetData(const std::shared_ptr& data); + int32_t list_size_; + + private: + std::shared_ptr values_; +}; + +// ---------------------------------------------------------------------- +// Struct + +/// Concrete Array class for struct data +class ARROW_EXPORT StructArray : public Array { + public: + using TypeClass = StructType; + + ~StructArray() override; + + explicit StructArray(const std::shared_ptr& data); + + StructArray(const std::shared_ptr& type, int64_t length, + const std::vector>& children, + std::shared_ptr null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount, int64_t offset = 0); + + /// \brief Return a StructArray from child arrays and field names. + /// + /// The length and data type are automatically inferred from the arguments. + /// There should be at least one child array. + static Result> Make( + const ArrayVector& children, const std::vector& field_names, + std::shared_ptr null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount, int64_t offset = 0); + + /// \brief Return a StructArray from child arrays and fields. + /// + /// The length is automatically inferred from the arguments. + /// There should be at least one child array. This method does not + /// check that field types and child array types are consistent. + static Result> Make( + const ArrayVector& children, const FieldVector& fields, + std::shared_ptr null_bitmap = NULLPTR, + int64_t null_count = kUnknownNullCount, int64_t offset = 0); + + const StructType* struct_type() const; + + // Return a shared pointer in case the requestor desires to share ownership + // with this array. The returned array has its offset, length and null + // count adjusted. + std::shared_ptr field(int pos) const; + + const ArrayVector& fields() const; + + /// Returns null if name not found + std::shared_ptr GetFieldByName(const std::string& name) const; + + /// Indicate if field named `name` can be found unambiguously in the struct. + Status CanReferenceFieldByName(const std::string& name) const; + + /// Indicate if fields named `names` can be found unambiguously in the struct. + Status CanReferenceFieldsByNames(const std::vector& names) const; + + /// \brief Flatten this array as a vector of arrays, one for each field + /// + /// \param[in] pool The pool to allocate null bitmaps from, if necessary + Result Flatten(MemoryPool* pool = default_memory_pool()) const; + + /// \brief Get one of the child arrays, combining its null bitmap + /// with the parent struct array's bitmap. + /// + /// \param[in] index Which child array to get + /// \param[in] pool The pool to allocate null bitmaps from, if necessary + Result> GetFlattenedField( + int index, MemoryPool* pool = default_memory_pool()) const; + + private: + // For caching boxed child data + struct ARROW_NO_EXPORT Impl; + std::unique_ptr impl_; +}; + +// ---------------------------------------------------------------------- +// Union + +/// Base class for SparseUnionArray and DenseUnionArray +class ARROW_EXPORT UnionArray : public Array { + public: + using type_code_t = int8_t; + + ~UnionArray() override; + + /// Note that this buffer does not account for any slice offset + const std::shared_ptr& type_codes() const { return data_->buffers[1]; } + + const type_code_t* raw_type_codes() const { return raw_type_codes_; } + + /// The logical type code of the value at index. + type_code_t type_code(int64_t i) const { return raw_type_codes_[i]; } + + /// The physical child id containing value at index. + int child_id(int64_t i) const { return union_type_->child_ids()[raw_type_codes_[i]]; } + + const UnionType* union_type() const { return union_type_; } + + UnionMode::type mode() const { return union_type_->mode(); } + + /// \brief Return the given field as an individual array. + /// + /// For sparse unions, the returned array has its offset, length and null + /// count adjusted. + std::shared_ptr field(int pos) const; + + protected: + UnionArray(); + + void SetData(std::shared_ptr data); + + const type_code_t* raw_type_codes_; + const UnionType* union_type_; + + private: + // For caching boxed child data + struct ARROW_NO_EXPORT Impl; + std::unique_ptr impl_; +}; + +/// Concrete Array class for sparse union data +class ARROW_EXPORT SparseUnionArray : public UnionArray { + public: + using TypeClass = SparseUnionType; + + ~SparseUnionArray() override; + + explicit SparseUnionArray(std::shared_ptr data); + + SparseUnionArray(std::shared_ptr type, int64_t length, ArrayVector children, + std::shared_ptr type_ids, int64_t offset = 0); + + /// \brief Construct SparseUnionArray from type_ids and children + /// + /// This function does the bare minimum of validation of the input types. + /// + /// \param[in] type_ids An array of logical type ids for the union type + /// \param[in] children Vector of children Arrays containing the data for each type. + /// \param[in] type_codes Vector of type codes. + static Result> Make(const Array& type_ids, ArrayVector children, + std::vector type_codes) { + return Make(std::move(type_ids), std::move(children), std::vector{}, + std::move(type_codes)); + } + + /// \brief Construct SparseUnionArray with custom field names from type_ids and children + /// + /// This function does the bare minimum of validation of the input types. + /// + /// \param[in] type_ids An array of logical type ids for the union type + /// \param[in] children Vector of children Arrays containing the data for each type. + /// \param[in] field_names Vector of strings containing the name of each field. + /// \param[in] type_codes Vector of type codes. + static Result> Make(const Array& type_ids, ArrayVector children, + std::vector field_names = {}, + std::vector type_codes = {}); + + const SparseUnionType* union_type() const { + return internal::checked_cast(union_type_); + } + + /// \brief Get one of the child arrays, adjusting its null bitmap + /// where the union array type code does not match. + /// + /// \param[in] index Which child array to get (i.e. the physical index, not the type + /// code) \param[in] pool The pool to allocate null bitmaps from, if necessary + Result> GetFlattenedField( + int index, MemoryPool* pool = default_memory_pool()) const; + + protected: + void SetData(std::shared_ptr data); +}; + +/// \brief Concrete Array class for dense union data +/// +/// Note that union types do not have a validity bitmap +class ARROW_EXPORT DenseUnionArray : public UnionArray { + public: + using TypeClass = DenseUnionType; + + ~DenseUnionArray() override; + + explicit DenseUnionArray(const std::shared_ptr& data); + + DenseUnionArray(std::shared_ptr type, int64_t length, ArrayVector children, + std::shared_ptr type_ids, + std::shared_ptr value_offsets = NULLPTR, int64_t offset = 0); + + /// \brief Construct DenseUnionArray from type_ids, value_offsets, and children + /// + /// This function does the bare minimum of validation of the offsets and + /// input types. + /// + /// \param[in] type_ids An array of logical type ids for the union type + /// \param[in] value_offsets An array of signed int32 values indicating the + /// relative offset into the respective child array for the type in a given slot. + /// The respective offsets for each child value array must be in order / increasing. + /// \param[in] children Vector of children Arrays containing the data for each type. + /// \param[in] type_codes Vector of type codes. + static Result> Make(const Array& type_ids, + const Array& value_offsets, + ArrayVector children, + std::vector type_codes) { + return Make(type_ids, value_offsets, std::move(children), std::vector{}, + std::move(type_codes)); + } + + /// \brief Construct DenseUnionArray with custom field names from type_ids, + /// value_offsets, and children + /// + /// This function does the bare minimum of validation of the offsets and + /// input types. + /// + /// \param[in] type_ids An array of logical type ids for the union type + /// \param[in] value_offsets An array of signed int32 values indicating the + /// relative offset into the respective child array for the type in a given slot. + /// The respective offsets for each child value array must be in order / increasing. + /// \param[in] children Vector of children Arrays containing the data for each type. + /// \param[in] field_names Vector of strings containing the name of each field. + /// \param[in] type_codes Vector of type codes. + static Result> Make(const Array& type_ids, + const Array& value_offsets, + ArrayVector children, + std::vector field_names = {}, + std::vector type_codes = {}); + + const DenseUnionType* union_type() const { + return internal::checked_cast(union_type_); + } + + /// Note that this buffer does not account for any slice offset + const std::shared_ptr& value_offsets() const { return data_->buffers[2]; } + + int32_t value_offset(int64_t i) const { return raw_value_offsets_[i]; } + + const int32_t* raw_value_offsets() const { return raw_value_offsets_; } + + protected: + const int32_t* raw_value_offsets_; + + void SetData(const std::shared_ptr& data); +}; + +/// @} + +} // namespace arrow diff --git a/shared/package-files/31/31146fd47e783c183ea3e8830b8ddfb10498e687c2a2fce7d9f00f9c254132e9/blob b/shared/package-files/31/31146fd47e783c183ea3e8830b8ddfb10498e687c2a2fce7d9f00f9c254132e9/blob new file mode 100644 index 0000000000000000000000000000000000000000..7baed3c80a7b6c4b6af47d0ab7730cfd8e6a2367 Binary files /dev/null and b/shared/package-files/31/31146fd47e783c183ea3e8830b8ddfb10498e687c2a2fce7d9f00f9c254132e9/blob differ diff --git a/shared/package-files/31/31153ac42973232d4f5ff1638b22db8c8e1f0b69f1d4ae122e504032fe028046/blob b/shared/package-files/31/31153ac42973232d4f5ff1638b22db8c8e1f0b69f1d4ae122e504032fe028046/blob new file mode 100644 index 0000000000000000000000000000000000000000..1f11935c70e9a7ce3f453143895e9c48e19b38ed --- /dev/null +++ b/shared/package-files/31/31153ac42973232d4f5ff1638b22db8c8e1f0b69f1d4ae122e504032fe028046/blob @@ -0,0 +1,1214 @@ +"""Rewrite assertion AST to produce nice error messages.""" + +from __future__ import annotations + +import ast +from collections import defaultdict +import errno +import functools +import importlib.abc +import importlib.machinery +import importlib.util +import io +import itertools +import marshal +import os +from pathlib import Path +from pathlib import PurePath +import struct +import sys +import tokenize +import types +from typing import Callable +from typing import IO +from typing import Iterable +from typing import Iterator +from typing import Sequence +from typing import TYPE_CHECKING + +from _pytest._io.saferepr import DEFAULT_REPR_MAX_SIZE +from _pytest._io.saferepr import saferepr +from _pytest._io.saferepr import saferepr_unlimited +from _pytest._version import version +from _pytest.assertion import util +from _pytest.config import Config +from _pytest.main import Session +from _pytest.pathlib import absolutepath +from _pytest.pathlib import fnmatch_ex +from _pytest.stash import StashKey + + +# fmt: off +from _pytest.assertion.util import format_explanation as _format_explanation # noqa:F401, isort:skip +# fmt:on + +if TYPE_CHECKING: + from _pytest.assertion import AssertionState + + +class Sentinel: + pass + + +assertstate_key = StashKey["AssertionState"]() + +# pytest caches rewritten pycs in pycache dirs +PYTEST_TAG = f"{sys.implementation.cache_tag}-pytest-{version}" +PYC_EXT = ".py" + (__debug__ and "c" or "o") +PYC_TAIL = "." + PYTEST_TAG + PYC_EXT + +# Special marker that denotes we have just left a scope definition +_SCOPE_END_MARKER = Sentinel() + + +class AssertionRewritingHook(importlib.abc.MetaPathFinder, importlib.abc.Loader): + """PEP302/PEP451 import hook which rewrites asserts.""" + + def __init__(self, config: Config) -> None: + self.config = config + try: + self.fnpats = config.getini("python_files") + except ValueError: + self.fnpats = ["test_*.py", "*_test.py"] + self.session: Session | None = None + self._rewritten_names: dict[str, Path] = {} + self._must_rewrite: set[str] = set() + # flag to guard against trying to rewrite a pyc file while we are already writing another pyc file, + # which might result in infinite recursion (#3506) + self._writing_pyc = False + self._basenames_to_check_rewrite = {"conftest"} + self._marked_for_rewrite_cache: dict[str, bool] = {} + self._session_paths_checked = False + + def set_session(self, session: Session | None) -> None: + self.session = session + self._session_paths_checked = False + + # Indirection so we can mock calls to find_spec originated from the hook during testing + _find_spec = importlib.machinery.PathFinder.find_spec + + def find_spec( + self, + name: str, + path: Sequence[str | bytes] | None = None, + target: types.ModuleType | None = None, + ) -> importlib.machinery.ModuleSpec | None: + if self._writing_pyc: + return None + state = self.config.stash[assertstate_key] + if self._early_rewrite_bailout(name, state): + return None + state.trace(f"find_module called for: {name}") + + # Type ignored because mypy is confused about the `self` binding here. + spec = self._find_spec(name, path) # type: ignore + + if spec is None and path is not None: + # With --import-mode=importlib, PathFinder cannot find spec without modifying `sys.path`, + # causing inability to assert rewriting (#12659). + # At this point, try using the file path to find the module spec. + for _path_str in path: + spec = importlib.util.spec_from_file_location(name, _path_str) + if spec is not None: + break + + if ( + # the import machinery could not find a file to import + spec is None + # this is a namespace package (without `__init__.py`) + # there's nothing to rewrite there + or spec.origin is None + # we can only rewrite source files + or not isinstance(spec.loader, importlib.machinery.SourceFileLoader) + # if the file doesn't exist, we can't rewrite it + or not os.path.exists(spec.origin) + ): + return None + else: + fn = spec.origin + + if not self._should_rewrite(name, fn, state): + return None + + return importlib.util.spec_from_file_location( + name, + fn, + loader=self, + submodule_search_locations=spec.submodule_search_locations, + ) + + def create_module( + self, spec: importlib.machinery.ModuleSpec + ) -> types.ModuleType | None: + return None # default behaviour is fine + + def exec_module(self, module: types.ModuleType) -> None: + assert module.__spec__ is not None + assert module.__spec__.origin is not None + fn = Path(module.__spec__.origin) + state = self.config.stash[assertstate_key] + + self._rewritten_names[module.__name__] = fn + + # The requested module looks like a test file, so rewrite it. This is + # the most magical part of the process: load the source, rewrite the + # asserts, and load the rewritten source. We also cache the rewritten + # module code in a special pyc. We must be aware of the possibility of + # concurrent pytest processes rewriting and loading pycs. To avoid + # tricky race conditions, we maintain the following invariant: The + # cached pyc is always a complete, valid pyc. Operations on it must be + # atomic. POSIX's atomic rename comes in handy. + write = not sys.dont_write_bytecode + cache_dir = get_cache_dir(fn) + if write: + ok = try_makedirs(cache_dir) + if not ok: + write = False + state.trace(f"read only directory: {cache_dir}") + + cache_name = fn.name[:-3] + PYC_TAIL + pyc = cache_dir / cache_name + # Notice that even if we're in a read-only directory, I'm going + # to check for a cached pyc. This may not be optimal... + co = _read_pyc(fn, pyc, state.trace) + if co is None: + state.trace(f"rewriting {fn!r}") + source_stat, co = _rewrite_test(fn, self.config) + if write: + self._writing_pyc = True + try: + _write_pyc(state, co, source_stat, pyc) + finally: + self._writing_pyc = False + else: + state.trace(f"found cached rewritten pyc for {fn}") + exec(co, module.__dict__) + + def _early_rewrite_bailout(self, name: str, state: AssertionState) -> bool: + """A fast way to get out of rewriting modules. + + Profiling has shown that the call to PathFinder.find_spec (inside of + the find_spec from this class) is a major slowdown, so, this method + tries to filter what we're sure won't be rewritten before getting to + it. + """ + if self.session is not None and not self._session_paths_checked: + self._session_paths_checked = True + for initial_path in self.session._initialpaths: + # Make something as c:/projects/my_project/path.py -> + # ['c:', 'projects', 'my_project', 'path.py'] + parts = str(initial_path).split(os.sep) + # add 'path' to basenames to be checked. + self._basenames_to_check_rewrite.add(os.path.splitext(parts[-1])[0]) + + # Note: conftest already by default in _basenames_to_check_rewrite. + parts = name.split(".") + if parts[-1] in self._basenames_to_check_rewrite: + return False + + # For matching the name it must be as if it was a filename. + path = PurePath(*parts).with_suffix(".py") + + for pat in self.fnpats: + # if the pattern contains subdirectories ("tests/**.py" for example) we can't bail out based + # on the name alone because we need to match against the full path + if os.path.dirname(pat): + return False + if fnmatch_ex(pat, path): + return False + + if self._is_marked_for_rewrite(name, state): + return False + + state.trace(f"early skip of rewriting module: {name}") + return True + + def _should_rewrite(self, name: str, fn: str, state: AssertionState) -> bool: + # always rewrite conftest files + if os.path.basename(fn) == "conftest.py": + state.trace(f"rewriting conftest file: {fn!r}") + return True + + if self.session is not None: + if self.session.isinitpath(absolutepath(fn)): + state.trace(f"matched test file (was specified on cmdline): {fn!r}") + return True + + # modules not passed explicitly on the command line are only + # rewritten if they match the naming convention for test files + fn_path = PurePath(fn) + for pat in self.fnpats: + if fnmatch_ex(pat, fn_path): + state.trace(f"matched test file {fn!r}") + return True + + return self._is_marked_for_rewrite(name, state) + + def _is_marked_for_rewrite(self, name: str, state: AssertionState) -> bool: + try: + return self._marked_for_rewrite_cache[name] + except KeyError: + for marked in self._must_rewrite: + if name == marked or name.startswith(marked + "."): + state.trace(f"matched marked file {name!r} (from {marked!r})") + self._marked_for_rewrite_cache[name] = True + return True + + self._marked_for_rewrite_cache[name] = False + return False + + def mark_rewrite(self, *names: str) -> None: + """Mark import names as needing to be rewritten. + + The named module or package as well as any nested modules will + be rewritten on import. + """ + already_imported = ( + set(names).intersection(sys.modules).difference(self._rewritten_names) + ) + for name in already_imported: + mod = sys.modules[name] + if not AssertionRewriter.is_rewrite_disabled( + mod.__doc__ or "" + ) and not isinstance(mod.__loader__, type(self)): + self._warn_already_imported(name) + self._must_rewrite.update(names) + self._marked_for_rewrite_cache.clear() + + def _warn_already_imported(self, name: str) -> None: + from _pytest.warning_types import PytestAssertRewriteWarning + + self.config.issue_config_time_warning( + PytestAssertRewriteWarning( + f"Module already imported so cannot be rewritten: {name}" + ), + stacklevel=5, + ) + + def get_data(self, pathname: str | bytes) -> bytes: + """Optional PEP302 get_data API.""" + with open(pathname, "rb") as f: + return f.read() + + if sys.version_info >= (3, 10): + if sys.version_info >= (3, 12): + from importlib.resources.abc import TraversableResources + else: + from importlib.abc import TraversableResources + + def get_resource_reader(self, name: str) -> TraversableResources: + if sys.version_info < (3, 11): + from importlib.readers import FileReader + else: + from importlib.resources.readers import FileReader + + return FileReader(types.SimpleNamespace(path=self._rewritten_names[name])) + + +def _write_pyc_fp( + fp: IO[bytes], source_stat: os.stat_result, co: types.CodeType +) -> None: + # Technically, we don't have to have the same pyc format as + # (C)Python, since these "pycs" should never be seen by builtin + # import. However, there's little reason to deviate. + fp.write(importlib.util.MAGIC_NUMBER) + # https://www.python.org/dev/peps/pep-0552/ + flags = b"\x00\x00\x00\x00" + fp.write(flags) + # as of now, bytecode header expects 32-bit numbers for size and mtime (#4903) + mtime = int(source_stat.st_mtime) & 0xFFFFFFFF + size = source_stat.st_size & 0xFFFFFFFF + # " bool: + proc_pyc = f"{pyc}.{os.getpid()}" + try: + with open(proc_pyc, "wb") as fp: + _write_pyc_fp(fp, source_stat, co) + except OSError as e: + state.trace(f"error writing pyc file at {proc_pyc}: errno={e.errno}") + return False + + try: + os.replace(proc_pyc, pyc) + except OSError as e: + state.trace(f"error writing pyc file at {pyc}: {e}") + # we ignore any failure to write the cache file + # there are many reasons, permission-denied, pycache dir being a + # file etc. + return False + return True + + +def _rewrite_test(fn: Path, config: Config) -> tuple[os.stat_result, types.CodeType]: + """Read and rewrite *fn* and return the code object.""" + stat = os.stat(fn) + source = fn.read_bytes() + strfn = str(fn) + tree = ast.parse(source, filename=strfn) + rewrite_asserts(tree, source, strfn, config) + co = compile(tree, strfn, "exec", dont_inherit=True) + return stat, co + + +def _read_pyc( + source: Path, pyc: Path, trace: Callable[[str], None] = lambda x: None +) -> types.CodeType | None: + """Possibly read a pytest pyc containing rewritten code. + + Return rewritten code if successful or None if not. + """ + try: + fp = open(pyc, "rb") + except OSError: + return None + with fp: + try: + stat_result = os.stat(source) + mtime = int(stat_result.st_mtime) + size = stat_result.st_size + data = fp.read(16) + except OSError as e: + trace(f"_read_pyc({source}): OSError {e}") + return None + # Check for invalid or out of date pyc file. + if len(data) != (16): + trace(f"_read_pyc({source}): invalid pyc (too short)") + return None + if data[:4] != importlib.util.MAGIC_NUMBER: + trace(f"_read_pyc({source}): invalid pyc (bad magic number)") + return None + if data[4:8] != b"\x00\x00\x00\x00": + trace(f"_read_pyc({source}): invalid pyc (unsupported flags)") + return None + mtime_data = data[8:12] + if int.from_bytes(mtime_data, "little") != mtime & 0xFFFFFFFF: + trace(f"_read_pyc({source}): out of date") + return None + size_data = data[12:16] + if int.from_bytes(size_data, "little") != size & 0xFFFFFFFF: + trace(f"_read_pyc({source}): invalid pyc (incorrect size)") + return None + try: + co = marshal.load(fp) + except Exception as e: + trace(f"_read_pyc({source}): marshal.load error {e}") + return None + if not isinstance(co, types.CodeType): + trace(f"_read_pyc({source}): not a code object") + return None + return co + + +def rewrite_asserts( + mod: ast.Module, + source: bytes, + module_path: str | None = None, + config: Config | None = None, +) -> None: + """Rewrite the assert statements in mod.""" + AssertionRewriter(module_path, config, source).run(mod) + + +def _saferepr(obj: object) -> str: + r"""Get a safe repr of an object for assertion error messages. + + The assertion formatting (util.format_explanation()) requires + newlines to be escaped since they are a special character for it. + Normally assertion.util.format_explanation() does this but for a + custom repr it is possible to contain one of the special escape + sequences, especially '\n{' and '\n}' are likely to be present in + JSON reprs. + """ + if isinstance(obj, types.MethodType): + # for bound methods, skip redundant information + return obj.__name__ + + maxsize = _get_maxsize_for_saferepr(util._config) + if not maxsize: + return saferepr_unlimited(obj).replace("\n", "\\n") + return saferepr(obj, maxsize=maxsize).replace("\n", "\\n") + + +def _get_maxsize_for_saferepr(config: Config | None) -> int | None: + """Get `maxsize` configuration for saferepr based on the given config object.""" + if config is None: + verbosity = 0 + else: + verbosity = config.get_verbosity(Config.VERBOSITY_ASSERTIONS) + if verbosity >= 2: + return None + if verbosity >= 1: + return DEFAULT_REPR_MAX_SIZE * 10 + return DEFAULT_REPR_MAX_SIZE + + +def _format_assertmsg(obj: object) -> str: + r"""Format the custom assertion message given. + + For strings this simply replaces newlines with '\n~' so that + util.format_explanation() will preserve them instead of escaping + newlines. For other objects saferepr() is used first. + """ + # reprlib appears to have a bug which means that if a string + # contains a newline it gets escaped, however if an object has a + # .__repr__() which contains newlines it does not get escaped. + # However in either case we want to preserve the newline. + replaces = [("\n", "\n~"), ("%", "%%")] + if not isinstance(obj, str): + obj = saferepr(obj, _get_maxsize_for_saferepr(util._config)) + replaces.append(("\\n", "\n~")) + + for r1, r2 in replaces: + obj = obj.replace(r1, r2) + + return obj + + +def _should_repr_global_name(obj: object) -> bool: + if callable(obj): + return False + + try: + return not hasattr(obj, "__name__") + except Exception: + return True + + +def _format_boolop(explanations: Iterable[str], is_or: bool) -> str: + explanation = "(" + (is_or and " or " or " and ").join(explanations) + ")" + return explanation.replace("%", "%%") + + +def _call_reprcompare( + ops: Sequence[str], + results: Sequence[bool], + expls: Sequence[str], + each_obj: Sequence[object], +) -> str: + for i, res, expl in zip(range(len(ops)), results, expls): + try: + done = not res + except Exception: + done = True + if done: + break + if util._reprcompare is not None: + custom = util._reprcompare(ops[i], each_obj[i], each_obj[i + 1]) + if custom is not None: + return custom + return expl + + +def _call_assertion_pass(lineno: int, orig: str, expl: str) -> None: + if util._assertion_pass is not None: + util._assertion_pass(lineno, orig, expl) + + +def _check_if_assertion_pass_impl() -> bool: + """Check if any plugins implement the pytest_assertion_pass hook + in order not to generate explanation unnecessarily (might be expensive).""" + return True if util._assertion_pass else False + + +UNARY_MAP = {ast.Not: "not %s", ast.Invert: "~%s", ast.USub: "-%s", ast.UAdd: "+%s"} + +BINOP_MAP = { + ast.BitOr: "|", + ast.BitXor: "^", + ast.BitAnd: "&", + ast.LShift: "<<", + ast.RShift: ">>", + ast.Add: "+", + ast.Sub: "-", + ast.Mult: "*", + ast.Div: "/", + ast.FloorDiv: "//", + ast.Mod: "%%", # escaped for string formatting + ast.Eq: "==", + ast.NotEq: "!=", + ast.Lt: "<", + ast.LtE: "<=", + ast.Gt: ">", + ast.GtE: ">=", + ast.Pow: "**", + ast.Is: "is", + ast.IsNot: "is not", + ast.In: "in", + ast.NotIn: "not in", + ast.MatMult: "@", +} + + +def traverse_node(node: ast.AST) -> Iterator[ast.AST]: + """Recursively yield node and all its children in depth-first order.""" + yield node + for child in ast.iter_child_nodes(node): + yield from traverse_node(child) + + +@functools.lru_cache(maxsize=1) +def _get_assertion_exprs(src: bytes) -> dict[int, str]: + """Return a mapping from {lineno: "assertion test expression"}.""" + ret: dict[int, str] = {} + + depth = 0 + lines: list[str] = [] + assert_lineno: int | None = None + seen_lines: set[int] = set() + + def _write_and_reset() -> None: + nonlocal depth, lines, assert_lineno, seen_lines + assert assert_lineno is not None + ret[assert_lineno] = "".join(lines).rstrip().rstrip("\\") + depth = 0 + lines = [] + assert_lineno = None + seen_lines = set() + + tokens = tokenize.tokenize(io.BytesIO(src).readline) + for tp, source, (lineno, offset), _, line in tokens: + if tp == tokenize.NAME and source == "assert": + assert_lineno = lineno + elif assert_lineno is not None: + # keep track of depth for the assert-message `,` lookup + if tp == tokenize.OP and source in "([{": + depth += 1 + elif tp == tokenize.OP and source in ")]}": + depth -= 1 + + if not lines: + lines.append(line[offset:]) + seen_lines.add(lineno) + # a non-nested comma separates the expression from the message + elif depth == 0 and tp == tokenize.OP and source == ",": + # one line assert with message + if lineno in seen_lines and len(lines) == 1: + offset_in_trimmed = offset + len(lines[-1]) - len(line) + lines[-1] = lines[-1][:offset_in_trimmed] + # multi-line assert with message + elif lineno in seen_lines: + lines[-1] = lines[-1][:offset] + # multi line assert with escaped newline before message + else: + lines.append(line[:offset]) + _write_and_reset() + elif tp in {tokenize.NEWLINE, tokenize.ENDMARKER}: + _write_and_reset() + elif lines and lineno not in seen_lines: + lines.append(line) + seen_lines.add(lineno) + + return ret + + +class AssertionRewriter(ast.NodeVisitor): + """Assertion rewriting implementation. + + The main entrypoint is to call .run() with an ast.Module instance, + this will then find all the assert statements and rewrite them to + provide intermediate values and a detailed assertion error. See + http://pybites.blogspot.be/2011/07/behind-scenes-of-pytests-new-assertion.html + for an overview of how this works. + + The entry point here is .run() which will iterate over all the + statements in an ast.Module and for each ast.Assert statement it + finds call .visit() with it. Then .visit_Assert() takes over and + is responsible for creating new ast statements to replace the + original assert statement: it rewrites the test of an assertion + to provide intermediate values and replace it with an if statement + which raises an assertion error with a detailed explanation in + case the expression is false and calls pytest_assertion_pass hook + if expression is true. + + For this .visit_Assert() uses the visitor pattern to visit all the + AST nodes of the ast.Assert.test field, each visit call returning + an AST node and the corresponding explanation string. During this + state is kept in several instance attributes: + + :statements: All the AST statements which will replace the assert + statement. + + :variables: This is populated by .variable() with each variable + used by the statements so that they can all be set to None at + the end of the statements. + + :variable_counter: Counter to create new unique variables needed + by statements. Variables are created using .variable() and + have the form of "@py_assert0". + + :expl_stmts: The AST statements which will be executed to get + data from the assertion. This is the code which will construct + the detailed assertion message that is used in the AssertionError + or for the pytest_assertion_pass hook. + + :explanation_specifiers: A dict filled by .explanation_param() + with %-formatting placeholders and their corresponding + expressions to use in the building of an assertion message. + This is used by .pop_format_context() to build a message. + + :stack: A stack of the explanation_specifiers dicts maintained by + .push_format_context() and .pop_format_context() which allows + to build another %-formatted string while already building one. + + :scope: A tuple containing the current scope used for variables_overwrite. + + :variables_overwrite: A dict filled with references to variables + that change value within an assert. This happens when a variable is + reassigned with the walrus operator + + This state, except the variables_overwrite, is reset on every new assert + statement visited and used by the other visitors. + """ + + def __init__( + self, module_path: str | None, config: Config | None, source: bytes + ) -> None: + super().__init__() + self.module_path = module_path + self.config = config + if config is not None: + self.enable_assertion_pass_hook = config.getini( + "enable_assertion_pass_hook" + ) + else: + self.enable_assertion_pass_hook = False + self.source = source + self.scope: tuple[ast.AST, ...] = () + self.variables_overwrite: defaultdict[tuple[ast.AST, ...], dict[str, str]] = ( + defaultdict(dict) + ) + + def run(self, mod: ast.Module) -> None: + """Find all assert statements in *mod* and rewrite them.""" + if not mod.body: + # Nothing to do. + return + + # We'll insert some special imports at the top of the module, but after any + # docstrings and __future__ imports, so first figure out where that is. + doc = getattr(mod, "docstring", None) + expect_docstring = doc is None + if doc is not None and self.is_rewrite_disabled(doc): + return + pos = 0 + item = None + for item in mod.body: + if ( + expect_docstring + and isinstance(item, ast.Expr) + and isinstance(item.value, ast.Constant) + and isinstance(item.value.value, str) + ): + doc = item.value.value + if self.is_rewrite_disabled(doc): + return + expect_docstring = False + elif ( + isinstance(item, ast.ImportFrom) + and item.level == 0 + and item.module == "__future__" + ): + pass + else: + break + pos += 1 + # Special case: for a decorated function, set the lineno to that of the + # first decorator, not the `def`. Issue #4984. + if isinstance(item, ast.FunctionDef) and item.decorator_list: + lineno = item.decorator_list[0].lineno + else: + lineno = item.lineno + # Now actually insert the special imports. + if sys.version_info >= (3, 10): + aliases = [ + ast.alias("builtins", "@py_builtins", lineno=lineno, col_offset=0), + ast.alias( + "_pytest.assertion.rewrite", + "@pytest_ar", + lineno=lineno, + col_offset=0, + ), + ] + else: + aliases = [ + ast.alias("builtins", "@py_builtins"), + ast.alias("_pytest.assertion.rewrite", "@pytest_ar"), + ] + imports = [ + ast.Import([alias], lineno=lineno, col_offset=0) for alias in aliases + ] + mod.body[pos:pos] = imports + + # Collect asserts. + self.scope = (mod,) + nodes: list[ast.AST | Sentinel] = [mod] + while nodes: + node = nodes.pop() + if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)): + self.scope = tuple((*self.scope, node)) + nodes.append(_SCOPE_END_MARKER) + if node == _SCOPE_END_MARKER: + self.scope = self.scope[:-1] + continue + assert isinstance(node, ast.AST) + for name, field in ast.iter_fields(node): + if isinstance(field, list): + new: list[ast.AST] = [] + for i, child in enumerate(field): + if isinstance(child, ast.Assert): + # Transform assert. + new.extend(self.visit(child)) + else: + new.append(child) + if isinstance(child, ast.AST): + nodes.append(child) + setattr(node, name, new) + elif ( + isinstance(field, ast.AST) + # Don't recurse into expressions as they can't contain + # asserts. + and not isinstance(field, ast.expr) + ): + nodes.append(field) + + @staticmethod + def is_rewrite_disabled(docstring: str) -> bool: + return "PYTEST_DONT_REWRITE" in docstring + + def variable(self) -> str: + """Get a new variable.""" + # Use a character invalid in python identifiers to avoid clashing. + name = "@py_assert" + str(next(self.variable_counter)) + self.variables.append(name) + return name + + def assign(self, expr: ast.expr) -> ast.Name: + """Give *expr* a name.""" + name = self.variable() + self.statements.append(ast.Assign([ast.Name(name, ast.Store())], expr)) + return ast.copy_location(ast.Name(name, ast.Load()), expr) + + def display(self, expr: ast.expr) -> ast.expr: + """Call saferepr on the expression.""" + return self.helper("_saferepr", expr) + + def helper(self, name: str, *args: ast.expr) -> ast.expr: + """Call a helper in this module.""" + py_name = ast.Name("@pytest_ar", ast.Load()) + attr = ast.Attribute(py_name, name, ast.Load()) + return ast.Call(attr, list(args), []) + + def builtin(self, name: str) -> ast.Attribute: + """Return the builtin called *name*.""" + builtin_name = ast.Name("@py_builtins", ast.Load()) + return ast.Attribute(builtin_name, name, ast.Load()) + + def explanation_param(self, expr: ast.expr) -> str: + """Return a new named %-formatting placeholder for expr. + + This creates a %-formatting placeholder for expr in the + current formatting context, e.g. ``%(py0)s``. The placeholder + and expr are placed in the current format context so that it + can be used on the next call to .pop_format_context(). + """ + specifier = "py" + str(next(self.variable_counter)) + self.explanation_specifiers[specifier] = expr + return "%(" + specifier + ")s" + + def push_format_context(self) -> None: + """Create a new formatting context. + + The format context is used for when an explanation wants to + have a variable value formatted in the assertion message. In + this case the value required can be added using + .explanation_param(). Finally .pop_format_context() is used + to format a string of %-formatted values as added by + .explanation_param(). + """ + self.explanation_specifiers: dict[str, ast.expr] = {} + self.stack.append(self.explanation_specifiers) + + def pop_format_context(self, expl_expr: ast.expr) -> ast.Name: + """Format the %-formatted string with current format context. + + The expl_expr should be an str ast.expr instance constructed from + the %-placeholders created by .explanation_param(). This will + add the required code to format said string to .expl_stmts and + return the ast.Name instance of the formatted string. + """ + current = self.stack.pop() + if self.stack: + self.explanation_specifiers = self.stack[-1] + keys: list[ast.expr | None] = [ast.Constant(key) for key in current.keys()] + format_dict = ast.Dict(keys, list(current.values())) + form = ast.BinOp(expl_expr, ast.Mod(), format_dict) + name = "@py_format" + str(next(self.variable_counter)) + if self.enable_assertion_pass_hook: + self.format_variables.append(name) + self.expl_stmts.append(ast.Assign([ast.Name(name, ast.Store())], form)) + return ast.Name(name, ast.Load()) + + def generic_visit(self, node: ast.AST) -> tuple[ast.Name, str]: + """Handle expressions we don't have custom code for.""" + assert isinstance(node, ast.expr) + res = self.assign(node) + return res, self.explanation_param(self.display(res)) + + def visit_Assert(self, assert_: ast.Assert) -> list[ast.stmt]: + """Return the AST statements to replace the ast.Assert instance. + + This rewrites the test of an assertion to provide + intermediate values and replace it with an if statement which + raises an assertion error with a detailed explanation in case + the expression is false. + """ + if isinstance(assert_.test, ast.Tuple) and len(assert_.test.elts) >= 1: + import warnings + + from _pytest.warning_types import PytestAssertRewriteWarning + + # TODO: This assert should not be needed. + assert self.module_path is not None + warnings.warn_explicit( + PytestAssertRewriteWarning( + "assertion is always true, perhaps remove parentheses?" + ), + category=None, + filename=self.module_path, + lineno=assert_.lineno, + ) + + self.statements: list[ast.stmt] = [] + self.variables: list[str] = [] + self.variable_counter = itertools.count() + + if self.enable_assertion_pass_hook: + self.format_variables: list[str] = [] + + self.stack: list[dict[str, ast.expr]] = [] + self.expl_stmts: list[ast.stmt] = [] + self.push_format_context() + # Rewrite assert into a bunch of statements. + top_condition, explanation = self.visit(assert_.test) + + negation = ast.UnaryOp(ast.Not(), top_condition) + + if self.enable_assertion_pass_hook: # Experimental pytest_assertion_pass hook + msg = self.pop_format_context(ast.Constant(explanation)) + + # Failed + if assert_.msg: + assertmsg = self.helper("_format_assertmsg", assert_.msg) + gluestr = "\n>assert " + else: + assertmsg = ast.Constant("") + gluestr = "assert " + err_explanation = ast.BinOp(ast.Constant(gluestr), ast.Add(), msg) + err_msg = ast.BinOp(assertmsg, ast.Add(), err_explanation) + err_name = ast.Name("AssertionError", ast.Load()) + fmt = self.helper("_format_explanation", err_msg) + exc = ast.Call(err_name, [fmt], []) + raise_ = ast.Raise(exc, None) + statements_fail = [] + statements_fail.extend(self.expl_stmts) + statements_fail.append(raise_) + + # Passed + fmt_pass = self.helper("_format_explanation", msg) + orig = _get_assertion_exprs(self.source)[assert_.lineno] + hook_call_pass = ast.Expr( + self.helper( + "_call_assertion_pass", + ast.Constant(assert_.lineno), + ast.Constant(orig), + fmt_pass, + ) + ) + # If any hooks implement assert_pass hook + hook_impl_test = ast.If( + self.helper("_check_if_assertion_pass_impl"), + [*self.expl_stmts, hook_call_pass], + [], + ) + statements_pass: list[ast.stmt] = [hook_impl_test] + + # Test for assertion condition + main_test = ast.If(negation, statements_fail, statements_pass) + self.statements.append(main_test) + if self.format_variables: + variables: list[ast.expr] = [ + ast.Name(name, ast.Store()) for name in self.format_variables + ] + clear_format = ast.Assign(variables, ast.Constant(None)) + self.statements.append(clear_format) + + else: # Original assertion rewriting + # Create failure message. + body = self.expl_stmts + self.statements.append(ast.If(negation, body, [])) + if assert_.msg: + assertmsg = self.helper("_format_assertmsg", assert_.msg) + explanation = "\n>assert " + explanation + else: + assertmsg = ast.Constant("") + explanation = "assert " + explanation + template = ast.BinOp(assertmsg, ast.Add(), ast.Constant(explanation)) + msg = self.pop_format_context(template) + fmt = self.helper("_format_explanation", msg) + err_name = ast.Name("AssertionError", ast.Load()) + exc = ast.Call(err_name, [fmt], []) + raise_ = ast.Raise(exc, None) + + body.append(raise_) + + # Clear temporary variables by setting them to None. + if self.variables: + variables = [ast.Name(name, ast.Store()) for name in self.variables] + clear = ast.Assign(variables, ast.Constant(None)) + self.statements.append(clear) + # Fix locations (line numbers/column offsets). + for stmt in self.statements: + for node in traverse_node(stmt): + if getattr(node, "lineno", None) is None: + # apply the assertion location to all generated ast nodes without source location + # and preserve the location of existing nodes or generated nodes with an correct location. + ast.copy_location(node, assert_) + return self.statements + + def visit_NamedExpr(self, name: ast.NamedExpr) -> tuple[ast.NamedExpr, str]: + # This method handles the 'walrus operator' repr of the target + # name if it's a local variable or _should_repr_global_name() + # thinks it's acceptable. + locs = ast.Call(self.builtin("locals"), [], []) + target_id = name.target.id + inlocs = ast.Compare(ast.Constant(target_id), [ast.In()], [locs]) + dorepr = self.helper("_should_repr_global_name", name) + test = ast.BoolOp(ast.Or(), [inlocs, dorepr]) + expr = ast.IfExp(test, self.display(name), ast.Constant(target_id)) + return name, self.explanation_param(expr) + + def visit_Name(self, name: ast.Name) -> tuple[ast.Name, str]: + # Display the repr of the name if it's a local variable or + # _should_repr_global_name() thinks it's acceptable. + locs = ast.Call(self.builtin("locals"), [], []) + inlocs = ast.Compare(ast.Constant(name.id), [ast.In()], [locs]) + dorepr = self.helper("_should_repr_global_name", name) + test = ast.BoolOp(ast.Or(), [inlocs, dorepr]) + expr = ast.IfExp(test, self.display(name), ast.Constant(name.id)) + return name, self.explanation_param(expr) + + def visit_BoolOp(self, boolop: ast.BoolOp) -> tuple[ast.Name, str]: + res_var = self.variable() + expl_list = self.assign(ast.List([], ast.Load())) + app = ast.Attribute(expl_list, "append", ast.Load()) + is_or = int(isinstance(boolop.op, ast.Or)) + body = save = self.statements + fail_save = self.expl_stmts + levels = len(boolop.values) - 1 + self.push_format_context() + # Process each operand, short-circuiting if needed. + for i, v in enumerate(boolop.values): + if i: + fail_inner: list[ast.stmt] = [] + # cond is set in a prior loop iteration below + self.expl_stmts.append(ast.If(cond, fail_inner, [])) # noqa: F821 + self.expl_stmts = fail_inner + # Check if the left operand is a ast.NamedExpr and the value has already been visited + if ( + isinstance(v, ast.Compare) + and isinstance(v.left, ast.NamedExpr) + and v.left.target.id + in [ + ast_expr.id + for ast_expr in boolop.values[:i] + if hasattr(ast_expr, "id") + ] + ): + pytest_temp = self.variable() + self.variables_overwrite[self.scope][v.left.target.id] = v.left # type:ignore[assignment] + v.left.target.id = pytest_temp + self.push_format_context() + res, expl = self.visit(v) + body.append(ast.Assign([ast.Name(res_var, ast.Store())], res)) + expl_format = self.pop_format_context(ast.Constant(expl)) + call = ast.Call(app, [expl_format], []) + self.expl_stmts.append(ast.Expr(call)) + if i < levels: + cond: ast.expr = res + if is_or: + cond = ast.UnaryOp(ast.Not(), cond) + inner: list[ast.stmt] = [] + self.statements.append(ast.If(cond, inner, [])) + self.statements = body = inner + self.statements = save + self.expl_stmts = fail_save + expl_template = self.helper("_format_boolop", expl_list, ast.Constant(is_or)) + expl = self.pop_format_context(expl_template) + return ast.Name(res_var, ast.Load()), self.explanation_param(expl) + + def visit_UnaryOp(self, unary: ast.UnaryOp) -> tuple[ast.Name, str]: + pattern = UNARY_MAP[unary.op.__class__] + operand_res, operand_expl = self.visit(unary.operand) + res = self.assign(ast.copy_location(ast.UnaryOp(unary.op, operand_res), unary)) + return res, pattern % (operand_expl,) + + def visit_BinOp(self, binop: ast.BinOp) -> tuple[ast.Name, str]: + symbol = BINOP_MAP[binop.op.__class__] + left_expr, left_expl = self.visit(binop.left) + right_expr, right_expl = self.visit(binop.right) + explanation = f"({left_expl} {symbol} {right_expl})" + res = self.assign( + ast.copy_location(ast.BinOp(left_expr, binop.op, right_expr), binop) + ) + return res, explanation + + def visit_Call(self, call: ast.Call) -> tuple[ast.Name, str]: + new_func, func_expl = self.visit(call.func) + arg_expls = [] + new_args = [] + new_kwargs = [] + for arg in call.args: + if isinstance(arg, ast.Name) and arg.id in self.variables_overwrite.get( + self.scope, {} + ): + arg = self.variables_overwrite[self.scope][arg.id] # type:ignore[assignment] + res, expl = self.visit(arg) + arg_expls.append(expl) + new_args.append(res) + for keyword in call.keywords: + if isinstance( + keyword.value, ast.Name + ) and keyword.value.id in self.variables_overwrite.get(self.scope, {}): + keyword.value = self.variables_overwrite[self.scope][keyword.value.id] # type:ignore[assignment] + res, expl = self.visit(keyword.value) + new_kwargs.append(ast.keyword(keyword.arg, res)) + if keyword.arg: + arg_expls.append(keyword.arg + "=" + expl) + else: # **args have `arg` keywords with an .arg of None + arg_expls.append("**" + expl) + + expl = "{}({})".format(func_expl, ", ".join(arg_expls)) + new_call = ast.copy_location(ast.Call(new_func, new_args, new_kwargs), call) + res = self.assign(new_call) + res_expl = self.explanation_param(self.display(res)) + outer_expl = f"{res_expl}\n{{{res_expl} = {expl}\n}}" + return res, outer_expl + + def visit_Starred(self, starred: ast.Starred) -> tuple[ast.Starred, str]: + # A Starred node can appear in a function call. + res, expl = self.visit(starred.value) + new_starred = ast.Starred(res, starred.ctx) + return new_starred, "*" + expl + + def visit_Attribute(self, attr: ast.Attribute) -> tuple[ast.Name, str]: + if not isinstance(attr.ctx, ast.Load): + return self.generic_visit(attr) + value, value_expl = self.visit(attr.value) + res = self.assign( + ast.copy_location(ast.Attribute(value, attr.attr, ast.Load()), attr) + ) + res_expl = self.explanation_param(self.display(res)) + pat = "%s\n{%s = %s.%s\n}" + expl = pat % (res_expl, res_expl, value_expl, attr.attr) + return res, expl + + def visit_Compare(self, comp: ast.Compare) -> tuple[ast.expr, str]: + self.push_format_context() + # We first check if we have overwritten a variable in the previous assert + if isinstance( + comp.left, ast.Name + ) and comp.left.id in self.variables_overwrite.get(self.scope, {}): + comp.left = self.variables_overwrite[self.scope][comp.left.id] # type:ignore[assignment] + if isinstance(comp.left, ast.NamedExpr): + self.variables_overwrite[self.scope][comp.left.target.id] = comp.left # type:ignore[assignment] + left_res, left_expl = self.visit(comp.left) + if isinstance(comp.left, (ast.Compare, ast.BoolOp)): + left_expl = f"({left_expl})" + res_variables = [self.variable() for i in range(len(comp.ops))] + load_names: list[ast.expr] = [ast.Name(v, ast.Load()) for v in res_variables] + store_names = [ast.Name(v, ast.Store()) for v in res_variables] + it = zip(range(len(comp.ops)), comp.ops, comp.comparators) + expls: list[ast.expr] = [] + syms: list[ast.expr] = [] + results = [left_res] + for i, op, next_operand in it: + if ( + isinstance(next_operand, ast.NamedExpr) + and isinstance(left_res, ast.Name) + and next_operand.target.id == left_res.id + ): + next_operand.target.id = self.variable() + self.variables_overwrite[self.scope][left_res.id] = next_operand # type:ignore[assignment] + next_res, next_expl = self.visit(next_operand) + if isinstance(next_operand, (ast.Compare, ast.BoolOp)): + next_expl = f"({next_expl})" + results.append(next_res) + sym = BINOP_MAP[op.__class__] + syms.append(ast.Constant(sym)) + expl = f"{left_expl} {sym} {next_expl}" + expls.append(ast.Constant(expl)) + res_expr = ast.copy_location(ast.Compare(left_res, [op], [next_res]), comp) + self.statements.append(ast.Assign([store_names[i]], res_expr)) + left_res, left_expl = next_res, next_expl + # Use pytest.assertion.util._reprcompare if that's available. + expl_call = self.helper( + "_call_reprcompare", + ast.Tuple(syms, ast.Load()), + ast.Tuple(load_names, ast.Load()), + ast.Tuple(expls, ast.Load()), + ast.Tuple(results, ast.Load()), + ) + if len(comp.ops) > 1: + res: ast.expr = ast.BoolOp(ast.And(), load_names) + else: + res = load_names[0] + + return res, self.explanation_param(self.pop_format_context(expl_call)) + + +def try_makedirs(cache_dir: Path) -> bool: + """Attempt to create the given directory and sub-directories exist. + + Returns True if successful or if it already exists. + """ + try: + os.makedirs(cache_dir, exist_ok=True) + except (FileNotFoundError, NotADirectoryError, FileExistsError): + # One of the path components was not a directory: + # - we're in a zip file + # - it is a file + return False + except PermissionError: + return False + except OSError as e: + # as of now, EROFS doesn't have an equivalent OSError-subclass + # + # squashfuse_ll returns ENOSYS "OSError: [Errno 38] Function not + # implemented" for a read-only error + if e.errno in {errno.EROFS, errno.ENOSYS}: + return False + raise + return True + + +def get_cache_dir(file_path: Path) -> Path: + """Return the cache directory to write .pyc files for the given .py file path.""" + if sys.pycache_prefix: + # given: + # prefix = '/tmp/pycs' + # path = '/home/user/proj/test_app.py' + # we want: + # '/tmp/pycs/home/user/proj' + return Path(sys.pycache_prefix) / Path(*file_path.parts[1:-1]) + else: + # classic pycache directory + return file_path.parent / "__pycache__" diff --git a/shared/package-files/31/31154c507c028325eeadc931641b0db9ed4b1c41985a71a7564bd1774d525207/blob b/shared/package-files/31/31154c507c028325eeadc931641b0db9ed4b1c41985a71a7564bd1774d525207/blob new file mode 100644 index 0000000000000000000000000000000000000000..d395550f05a2c843ab57ef2c9152580480b75fc4 Binary files /dev/null and b/shared/package-files/31/31154c507c028325eeadc931641b0db9ed4b1c41985a71a7564bd1774d525207/blob differ diff --git a/shared/package-files/31/31187551a386f911c77ddb59955ab053e713beb373a87ca3b2aa985d46b82013/blob b/shared/package-files/31/31187551a386f911c77ddb59955ab053e713beb373a87ca3b2aa985d46b82013/blob new file mode 100644 index 0000000000000000000000000000000000000000..f393929bb7c2bbca028d43d8bf1ef27af7ccb23f --- /dev/null +++ b/shared/package-files/31/31187551a386f911c77ddb59955ab053e713beb373a87ca3b2aa985d46b82013/blob @@ -0,0 +1,146 @@ +import hashlib +import json +from typing import Dict, Tuple + +import coremltools as ct # type: ignore[import] +from coremltools.converters.mil.input_types import TensorType # type: ignore[import] +from coremltools.converters.mil.mil import types # type: ignore[import] +from coremltools.models.neural_network import quantization_utils # type: ignore[import] + +import torch + +CT_METADATA_VERSION = "com.github.apple.coremltools.version" +CT_METADATA_SOURCE = "com.github.apple.coremltools.source" + + +class ScalarType: + Float = 0 + Double = 1 + Int = 2 + Long = 3 + Undefined = 4 + + +# Supported Tensor types in coremltools: +# https://github.com/apple/coremltools/blob/main/coremltools/converters/mil/frontend/torch/converter.py#L28 +torch_to_mil_types = { + ScalarType.Float: types.fp32, + ScalarType.Double: types.fp64, + ScalarType.Int: types.int32, + ScalarType.Long: types.int64, +} + + +class CoreMLComputeUnit: + CPU = "cpuOnly" + CPUAndGPU = "cpuAndGPU" + ALL = "all" + + +class CoreMLQuantizationMode: + LINEAR = "linear" + LINEAR_SYMMETRIC = "linear_symmetric" + NONE = "none" + + +def TensorSpec(shape, dtype=ScalarType.Float): + return (shape, dtype) + + +def CompileSpec( + inputs, + outputs, + backend=CoreMLComputeUnit.CPU, + allow_low_precision=True, + quantization_mode=CoreMLQuantizationMode.NONE, + mlmodel_export_path=None, +): + return ( + inputs, + outputs, + backend, + allow_low_precision, + quantization_mode, + mlmodel_export_path, + ) + + +def _check_enumerated_shape(shape): + for s in shape: + if not isinstance(s, (list, tuple)): + return False + return True + + +def _convert_to_mil_type(shape, dtype, name: str): + mil_shape = shape + if _check_enumerated_shape(shape): + mil_shape = ct.EnumeratedShapes(shape) + ml_type = TensorType(shape=mil_shape, dtype=torch_to_mil_types[dtype]) + ml_type.name = name + return ml_type + + +def preprocess(script_module: torch._C.ScriptObject, compile_spec: Dict[str, Tuple]): + spec = compile_spec["forward"] + ( + input_specs, + output_specs, + backend, + allow_low_precision, + quantization_mode, + mlmodel_export_path, + ) = spec + mil_inputs = [] + inputs = [] + for index, input in enumerate(input_specs): + shape, dtype = input + name = "input_" + str(index) + inputs.append([name, str(dtype), str(shape)]) + ml_type = _convert_to_mil_type(shape, dtype, name) + mil_inputs.append(ml_type) + model = torch.jit.RecursiveScriptModule._construct(script_module, lambda x: None) + mlmodel = ct.convert(model, inputs=mil_inputs) + + if quantization_mode != CoreMLQuantizationMode.NONE: + quant_model_spec = quantization_utils.quantize_weights( + mlmodel, nbits=8, quantization_mode=quantization_mode + ) + mlmodel = ct.models.MLModel(quant_model_spec) + + spec = mlmodel.get_spec() + assert len(spec.description.output) == len(output_specs) # type: ignore[attr-defined] + outputs = [] + for index, output in enumerate(output_specs): + shape, dtype = output + name = spec.description.output[index].name # type: ignore[attr-defined] + outputs.append([name, str(dtype), str(shape)]) + mlmodel = ct.models.model.MLModel(spec) + print(mlmodel) + + if mlmodel_export_path is not None: + print(f"Saving CoreML .mlmodel file to {mlmodel_export_path}") + mlmodel.save(mlmodel_export_path) + + config = { + "spec_ver": str(spec.specificationVersion), # type: ignore[attr-defined] + "backend": backend, + "allow_low_precision": str(allow_low_precision), + } + metadata = { + "coremltool_ver": mlmodel.user_defined_metadata[CT_METADATA_VERSION], + "torch_ver": mlmodel.user_defined_metadata[CT_METADATA_SOURCE], + } + coreml_compile_spec = { + "inputs": inputs, + "outputs": outputs, + "config": config, + "metadata": metadata, + } + mlmodel = spec.SerializeToString() # type: ignore[attr-defined] + + return { + "model": mlmodel, + "hash": str(hashlib.sha256(mlmodel).hexdigest()), + "extra": json.dumps(coreml_compile_spec), + } diff --git a/shared/package-files/31/311bfca694884d86006fb96de443b0f4359635921b95fc6c161bb94d013b7292/blob b/shared/package-files/31/311bfca694884d86006fb96de443b0f4359635921b95fc6c161bb94d013b7292/blob new file mode 100644 index 0000000000000000000000000000000000000000..047ae70a17540bae9a246cb206480a1760d820b2 --- /dev/null +++ b/shared/package-files/31/311bfca694884d86006fb96de443b0f4359635921b95fc6c161bb94d013b7292/blob @@ -0,0 +1,15 @@ +Font Metrics for the 14 PDF Core Fonts +====================================== + +This directory contains font metrics for the 14 PDF Core Fonts, +downloaded from Adobe. The title and this paragraph were added by +Matplotlib developers. The download URL was +. + +This file and the 14 PostScript(R) AFM files it accompanies may be used, copied, +and distributed for any purpose and without charge, with or without modification, +provided that all copyright notices are retained; that the AFM files are not +distributed without this file; that all modifications to this file or any of +the AFM files are prominently noted in the modified file(s); and that this +paragraph is not modified. Adobe Systems has no responsibility or obligation +to support the use of the AFM files. diff --git a/shared/package-files/31/311c030cc844bf33a3588ed78df34333caccc9c3dff0fdcea8578531f19646df/blob b/shared/package-files/31/311c030cc844bf33a3588ed78df34333caccc9c3dff0fdcea8578531f19646df/blob new file mode 100644 index 0000000000000000000000000000000000000000..d48b12bce3b23f2cc3fa768bb605d8022b7a21e4 --- /dev/null +++ b/shared/package-files/31/311c030cc844bf33a3588ed78df34333caccc9c3dff0fdcea8578531f19646df/blob @@ -0,0 +1,1964 @@ +/* + * This file contains wrappers of BLAS and LAPACK functions + */ +/* + * BLAS calling helpers. The helpers can be called without the GIL held. + * The caller is responsible for checking arguments (especially dimensions). + */ + +/* Fast getters caching the value of a function's address after + the first call to import_cblas_function(). */ + +#define EMIT_GET_CBLAS_FUNC(name) \ + static void *cblas_ ## name = NULL; \ + static void *get_cblas_ ## name(void) { \ + if (cblas_ ## name == NULL) { \ + PyGILState_STATE st = PyGILState_Ensure(); \ + const char *mod = "scipy.linalg.cython_blas"; \ + cblas_ ## name = import_cython_function(mod, # name); \ + PyGILState_Release(st); \ + } \ + return cblas_ ## name; \ + } + +EMIT_GET_CBLAS_FUNC(dgemm) +EMIT_GET_CBLAS_FUNC(sgemm) +EMIT_GET_CBLAS_FUNC(cgemm) +EMIT_GET_CBLAS_FUNC(zgemm) +EMIT_GET_CBLAS_FUNC(dgemv) +EMIT_GET_CBLAS_FUNC(sgemv) +EMIT_GET_CBLAS_FUNC(cgemv) +EMIT_GET_CBLAS_FUNC(zgemv) +EMIT_GET_CBLAS_FUNC(ddot) +EMIT_GET_CBLAS_FUNC(sdot) +EMIT_GET_CBLAS_FUNC(cdotu) +EMIT_GET_CBLAS_FUNC(zdotu) +EMIT_GET_CBLAS_FUNC(cdotc) +EMIT_GET_CBLAS_FUNC(zdotc) +EMIT_GET_CBLAS_FUNC(snrm2) +EMIT_GET_CBLAS_FUNC(dnrm2) +EMIT_GET_CBLAS_FUNC(scnrm2) +EMIT_GET_CBLAS_FUNC(dznrm2) + + +#undef EMIT_GET_CBLAS_FUNC + +/* + * NOTE: On return value convention. + * For LAPACK wrapper development the following conventions are followed: + * Publicly exposed wrapper functions must return:- + * STATUS_ERROR : For an unrecoverable error e.g. caught by xerbla, this is so + * a Py_FatalError can be raised. + * STATUS_SUCCESS: For successful execution + * +n : Where n is an integer for a routine specific error + * (typically derived from an `info` argument). + * + * The caller is responsible for checking and handling the error status. + */ + +/* return STATUS_SUCCESS if everything went ok */ +#define STATUS_SUCCESS (0) + +/* return STATUS_ERROR if an unrecoverable error is encountered */ +#define STATUS_ERROR (-1) + +/* + * A union of all the types accepted by BLAS/LAPACK for use in cases where + * stack based allocation is needed (typically for work space query args length + * 1). + */ +typedef union all_dtypes_ +{ + float s; + double d; + npy_complex64 c; + npy_complex128 z; +} all_dtypes; + +/* + * A checked PyMem_RawMalloc, ensures that the var is either NULL + * and an exception is raised, or that the allocation was successful. + * Returns zero on success for status checking. + */ +static int checked_PyMem_RawMalloc(void** var, size_t bytes) +{ + *var = NULL; + *var = PyMem_RawMalloc(bytes); + if (!(*var)) + { + { + PyGILState_STATE st = PyGILState_Ensure(); + + PyErr_SetString(PyExc_MemoryError, + "Insufficient memory for buffer allocation\ + required by LAPACK."); + PyGILState_Release(st); + } + return 1; + } + return 0; +} + +/* + * Checks that the char kind is valid (one of [s,d,c,z]) for use in blas/lapack. + * Returns zero on success for status checking. + */ +static int check_kind(char kind) +{ + switch (kind) + { + case 's': + case 'd': + case 'c': + case 'z': + break; + default: + { + PyGILState_STATE st = PyGILState_Ensure(); + PyErr_SetString(PyExc_ValueError, + "invalid data type (kind) found"); + PyGILState_Release(st); + } + return 1; + } + return 0; +} + +/* + * Guard macro for ensuring a valid data "kind" is being used. + * Place at the top of all routines with switches on "kind" that accept + * one of [s,d,c,z]. + */ +#define ENSURE_VALID_KIND(__KIND) \ +if (check_kind( __KIND )) \ +{ \ + return STATUS_ERROR; \ +} \ + +/* + * Checks that the char kind is valid for the real domain (one of [s,d]) + * for use in blas/lapack. + * Returns zero on success for status checking. + */ +static int check_real_kind(char kind) +{ + switch (kind) + { + case 's': + case 'd': + break; + default: + { + PyGILState_STATE st = PyGILState_Ensure(); + PyErr_SetString(PyExc_ValueError, + "invalid data type (kind) found"); + PyGILState_Release(st); + } + return 1; + } + return 0; +} + +/* + * Guard macro for ensuring a valid data "kind" is being used for the + * real domain routines. + * Place at the top of all routines with switches on "kind" that accept + * one of [s,d]. + */ +#define ENSURE_VALID_REAL_KIND(__KIND) \ +if (check_real_kind( __KIND )) \ +{ \ + return STATUS_ERROR; \ +} \ + + +/* + * Checks that the char kind is valid for the complex domain (one of [c,z]) + * for use in blas/lapack. + * Returns zero on success for status checking. + */ +static int check_complex_kind(char kind) +{ + switch (kind) + { + case 'c': + case 'z': + break; + default: + { + PyGILState_STATE st = PyGILState_Ensure(); + PyErr_SetString(PyExc_ValueError, + "invalid data type (kind) found"); + PyGILState_Release(st); + } + return 1; + } + return 0; +} + +/* + * Guard macro for ensuring a valid data "kind" is being used for the + * real domain routines. + * Place at the top of all routines with switches on "kind" that accept + * one of [c,z]. + */ +#define ENSURE_VALID_COMPLEX_KIND(__KIND) \ +if (check_complex_kind( __KIND )) \ +{ \ + return STATUS_ERROR; \ +} \ + + +/* + * Checks that a function is found (i.e. not null) + * Returns zero on success for status checking. + */ +static int check_func(void *func) +{ + if (func == NULL) + { + PyGILState_STATE st = PyGILState_Ensure(); + PyErr_SetString(PyExc_RuntimeError, + "Specified LAPACK function could not be found."); + PyGILState_Release(st); + return STATUS_ERROR; + } + return STATUS_SUCCESS; +} + + +/* + * Guard macro for ensuring a valid function is found. + */ +#define ENSURE_VALID_FUNC(__FUNC) \ +if (check_func(__FUNC)) \ +{ \ + return STATUS_ERROR; \ +} \ + + +/* + * Define what a Fortran "int" is. The width is a *build-time* decision, + * fixed by NUMBA_LAPACK_BUILD_ILP64 -- a macro baked in via + * Extension(define_macros=...) in setup.py, driven by the + * NUMBA_LAPACK_ILP64 build-time environment variable (see the "Build time + * environment variables" section of the install docs). It is not + * re-probed or chosen at runtime. + * + * Which width is *correct* to call through is a property of the scipy + * actually installed: scipy.linalg.cython_blas/cython_lapack are compiled + * for exactly one ABI, LP64 or ILP64, recorded in + * scipy.__config__.CONFIG['Build Dependencies']['blas']['cython blas + * ilp64']. numba.np.linalg._check_lapack_int_width() compares the + * build-time choice made here against the scipy actually present at + * runtime, and raises if they disagree, rather than silently doing the + * wrong thing. + */ +#ifndef NUMBA_LAPACK_BUILD_ILP64 +#define NUMBA_LAPACK_BUILD_ILP64 0 +#endif + +#if NUMBA_LAPACK_BUILD_ILP64 +typedef npy_int64 F_INT; +#else +typedef npy_int32 F_INT; +#endif + + +typedef float (*sdot_t)(F_INT *n, void *dx, F_INT *incx, void *dy, F_INT *incy); +typedef double (*ddot_t)(F_INT *n, void *dx, F_INT *incx, void *dy, F_INT + *incy); +typedef npy_complex64 (*cdot_t)(F_INT *n, void *dx, F_INT *incx, void *dy, + F_INT *incy); +typedef npy_complex128 (*zdot_t)(F_INT *n, void *dx, F_INT *incx, void *dy, + F_INT *incy); + +typedef void (*xxgemv_t)(char *trans, F_INT *m, F_INT *n, + void *alpha, void *a, F_INT *lda, + void *x, F_INT *incx, void *beta, + void *y, F_INT *incy); + +typedef void (*xxgemm_t)(char *transa, char *transb, + F_INT *m, F_INT *n, F_INT *k, + void *alpha, void *a, F_INT *lda, + void *b, F_INT *ldb, void *beta, + void *c, F_INT *ldc); + +typedef float (*sxnrm2_t) (F_INT *n, void *x, F_INT *incx); +typedef double (*dxnrm2_t) (F_INT *n, void *x, F_INT *incx); + +/* Vector * vector: result = dx * dy */ +NUMBA_EXPORT_FUNC(int) +numba_xxdot(char kind, char conjugate, Py_ssize_t n, void *dx, void *dy, + void *result) +{ + void *raw_func = NULL; + F_INT _n; + F_INT inc = 1; + + ENSURE_VALID_KIND(kind) + + switch (kind) + { + case 's': + raw_func = get_cblas_sdot(); + break; + case 'd': + raw_func = get_cblas_ddot(); + break; + case 'c': + raw_func = conjugate ? get_cblas_cdotc() : get_cblas_cdotu(); + break; + case 'z': + raw_func = conjugate ? get_cblas_zdotc() : get_cblas_zdotu(); + break; + } + ENSURE_VALID_FUNC(raw_func) + + _n = (F_INT) n; + + switch (kind) + { + case 's': + *(float *) result = (*(sdot_t) raw_func)(&_n, dx, &inc, dy, &inc);; + break; + case 'd': + *(double *) result = (*(ddot_t) raw_func)(&_n, dx, &inc, dy, &inc);; + break; + case 'c': + *(npy_complex64 *) result = (*(cdot_t) raw_func)(&_n, dx, &inc, dy,\ + &inc);; + break; + case 'z': + *(npy_complex128 *) result = (*(zdot_t) raw_func)(&_n, dx, &inc,\ + dy, &inc);; + break; + } + + return 0; +} + +/* Matrix * vector: y = alpha * a * x + beta * y */ +NUMBA_EXPORT_FUNC(int) +numba_xxgemv(char kind, char trans, Py_ssize_t m, Py_ssize_t n, + void *alpha, void *a, Py_ssize_t lda, + void *x, void *beta, void *y) +{ + void *raw_func = NULL; + F_INT _m, _n; + F_INT _lda; + F_INT inc = 1; + + ENSURE_VALID_KIND(kind) + + switch (kind) + { + case 's': + raw_func = get_cblas_sgemv(); + break; + case 'd': + raw_func = get_cblas_dgemv(); + break; + case 'c': + raw_func = get_cblas_cgemv(); + break; + case 'z': + raw_func = get_cblas_zgemv(); + break; + } + ENSURE_VALID_FUNC(raw_func) + + _m = (F_INT) m; + _n = (F_INT) n; + _lda = (F_INT) lda; + + (*(xxgemv_t) raw_func)(&trans, &_m, &_n, alpha, a, &_lda, + x, &inc, beta, y, &inc); + return 0; +} + +/* Matrix * matrix: c = alpha * a * b + beta * c */ +NUMBA_EXPORT_FUNC(int) +numba_xxgemm(char kind, char transa, char transb, + Py_ssize_t m, Py_ssize_t n, Py_ssize_t k, + void *alpha, void *a, Py_ssize_t lda, + void *b, Py_ssize_t ldb, void *beta, + void *c, Py_ssize_t ldc) +{ + void *raw_func = NULL; + F_INT _m, _n, _k; + F_INT _lda, _ldb, _ldc; + + ENSURE_VALID_KIND(kind) + + switch (kind) + { + case 's': + raw_func = get_cblas_sgemm(); + break; + case 'd': + raw_func = get_cblas_dgemm(); + break; + case 'c': + raw_func = get_cblas_cgemm(); + break; + case 'z': + raw_func = get_cblas_zgemm(); + break; + } + ENSURE_VALID_FUNC(raw_func) + + _m = (F_INT) m; + _n = (F_INT) n; + _k = (F_INT) k; + _lda = (F_INT) lda; + _ldb = (F_INT) ldb; + _ldc = (F_INT) ldc; + + (*(xxgemm_t) raw_func)(&transa, &transb, &_m, &_n, &_k, alpha, a, &_lda, + b, &_ldb, beta, c, &_ldc); + return 0; +} + + +/* L2-norms */ +NUMBA_EXPORT_FUNC(int) +numba_xxnrm2(char kind, Py_ssize_t n, void * x, Py_ssize_t incx, void * result) +{ + void *raw_func = NULL; + F_INT _incx; + F_INT _n; + + ENSURE_VALID_KIND(kind) + + switch (kind) + { + case 's': + raw_func = get_cblas_snrm2(); + break; + case 'd': + raw_func = get_cblas_dnrm2(); + break; + case 'c': + raw_func = get_cblas_scnrm2(); + break; + case 'z': + raw_func = get_cblas_dznrm2(); + break; + } + ENSURE_VALID_FUNC(raw_func) + + _n = (F_INT) n; + _incx = (F_INT) incx; + + switch (kind) + { + case 's': + *(float *) result = (*(sxnrm2_t) raw_func)(&_n, x, &_incx);; + break; + case 'd': + *(double *) result = (*(dxnrm2_t) raw_func)(&_n, x, &_incx);; + break; + case 'c': + *(float *) result = (*(sxnrm2_t) raw_func)(&_n, x, &_incx);; + break; + case 'z': + *(double *) result = (*(dxnrm2_t) raw_func)(&_n, x, &_incx);; + break; + } + + return 0; +} + + +/* + * LAPACK calling helpers. The helpers can be called without the GIL held. + * The caller is responsible for checking arguments (especially dimensions). + */ + +/* Fast getters caching the value of a function's address after + the first call to import_clapack_function(). */ + +#define EMIT_GET_CLAPACK_FUNC(name) \ + static void *clapack_ ## name = NULL; \ + static void *get_clapack_ ## name(void) { \ + if (clapack_ ## name == NULL) { \ + PyGILState_STATE st = PyGILState_Ensure(); \ + const char *mod = "scipy.linalg.cython_lapack"; \ + clapack_ ## name = import_cython_function(mod, # name); \ + PyGILState_Release(st); \ + } \ + return clapack_ ## name; \ + } + +/* Computes an LU factorization of a general M-by-N matrix A + * using partial pivoting with row interchanges. + */ +EMIT_GET_CLAPACK_FUNC(sgetrf) +EMIT_GET_CLAPACK_FUNC(dgetrf) +EMIT_GET_CLAPACK_FUNC(cgetrf) +EMIT_GET_CLAPACK_FUNC(zgetrf) + +/* Computes the inverse of a matrix using the LU factorization + * computed by xGETRF. + */ +EMIT_GET_CLAPACK_FUNC(sgetri) +EMIT_GET_CLAPACK_FUNC(dgetri) +EMIT_GET_CLAPACK_FUNC(cgetri) +EMIT_GET_CLAPACK_FUNC(zgetri) + +/* Compute Cholesky factorizations */ +EMIT_GET_CLAPACK_FUNC(spotrf) +EMIT_GET_CLAPACK_FUNC(dpotrf) +EMIT_GET_CLAPACK_FUNC(cpotrf) +EMIT_GET_CLAPACK_FUNC(zpotrf) + +/* Computes for an N-by-N real nonsymmetric matrix A, the + * eigenvalues and, optionally, the left and/or right eigenvectors. + */ +EMIT_GET_CLAPACK_FUNC(sgeev) +EMIT_GET_CLAPACK_FUNC(dgeev) +EMIT_GET_CLAPACK_FUNC(cgeev) +EMIT_GET_CLAPACK_FUNC(zgeev) + +/* Computes for an N-by-N Hermitian matrix A, the + * eigenvalues and, optionally, the left and/or right eigenvectors. + */ +EMIT_GET_CLAPACK_FUNC(ssyevd) +EMIT_GET_CLAPACK_FUNC(dsyevd) +EMIT_GET_CLAPACK_FUNC(cheevd) +EMIT_GET_CLAPACK_FUNC(zheevd) + +/* Computes generalised SVD */ +EMIT_GET_CLAPACK_FUNC(sgesdd) +EMIT_GET_CLAPACK_FUNC(dgesdd) +EMIT_GET_CLAPACK_FUNC(cgesdd) +EMIT_GET_CLAPACK_FUNC(zgesdd) + +/* Computes QR decompositions */ +EMIT_GET_CLAPACK_FUNC(sgeqrf) +EMIT_GET_CLAPACK_FUNC(dgeqrf) +EMIT_GET_CLAPACK_FUNC(cgeqrf) +EMIT_GET_CLAPACK_FUNC(zgeqrf) + +/* Computes columns of Q from elementary reflectors produced by xgeqrf() (QR). + */ +EMIT_GET_CLAPACK_FUNC(sorgqr) +EMIT_GET_CLAPACK_FUNC(dorgqr) +EMIT_GET_CLAPACK_FUNC(cungqr) +EMIT_GET_CLAPACK_FUNC(zungqr) + +/* Computes the minimum norm solution to linear least squares problems */ +EMIT_GET_CLAPACK_FUNC(sgelsd) +EMIT_GET_CLAPACK_FUNC(dgelsd) +EMIT_GET_CLAPACK_FUNC(cgelsd) +EMIT_GET_CLAPACK_FUNC(zgelsd) + +// Computes the solution to a system of linear equations +EMIT_GET_CLAPACK_FUNC(sgesv) +EMIT_GET_CLAPACK_FUNC(dgesv) +EMIT_GET_CLAPACK_FUNC(cgesv) +EMIT_GET_CLAPACK_FUNC(zgesv) + + +#undef EMIT_GET_CLAPACK_FUNC + +typedef void (*xxgetrf_t)(F_INT *m, F_INT *n, void *a, F_INT *lda, F_INT *ipiv, + F_INT *info); + +typedef void (*xxgetri_t)(F_INT *n, void *a, F_INT *lda, F_INT *ipiv, void + *work, F_INT *lwork, F_INT *info); + +typedef void (*xxpotrf_t)(char *uplo, F_INT *n, void *a, F_INT *lda, F_INT + *info); + +typedef void (*rgeev_t)(char *jobvl, char *jobvr, F_INT *n, void *a, F_INT *lda, + void *wr, void *wi, void *vl, F_INT *ldvl, void *vr, + F_INT *ldvr, void *work, F_INT *lwork, F_INT *info); + +typedef void (*cgeev_t)(char *jobvl, char *jobvr, F_INT *n, void *a, F_INT + *lda, void *w, void *vl, F_INT *ldvl, void *vr, + F_INT *ldvr, void *work, F_INT *lwork, void *rwork, + F_INT *info); + +typedef void (*rgesdd_t)(char *jobz, F_INT *m, F_INT *n, void *a, F_INT *lda, + void *s, void *u, F_INT *ldu, void *vt, F_INT *ldvt, + void *work, F_INT *lwork, F_INT *iwork, F_INT *info); + +typedef void (*cgesdd_t)(char *jobz, F_INT *m, F_INT *n, void *a, F_INT *lda, + void *s, void * u, F_INT *ldu, void * vt, F_INT *ldvt, + void *work, F_INT *lwork, void *rwork, F_INT *iwork, + F_INT *info); + +typedef void (*xsyevd_t)(char *jobz, char *uplo, F_INT *n, void *a, F_INT *lda, + void *w, void *work, F_INT *lwork, F_INT *iwork, + F_INT *liwork, F_INT *info); + +typedef void (*xheevd_t)(char *jobz, char *uplo, F_INT *n, void *a, F_INT *lda, + void *w, void *work, F_INT *lwork, void *rwork, + F_INT *lrwork, F_INT *iwork, F_INT *liwork, + F_INT *info); + +typedef void (*xgeqrf_t)(F_INT *m, F_INT *n, void *a, F_INT *lda, void *tau, + void *work, F_INT *lwork, F_INT *info); + +typedef void (*xxxgqr_t)(F_INT *m, F_INT *n, F_INT *k, void *a, F_INT *lda, + void *tau, void *work, F_INT *lwork, F_INT *info); + +typedef void (*rgelsd_t)(F_INT *m, F_INT *n, F_INT *nrhs, void *a, F_INT *lda, + void *b, F_INT *ldb, void *s, void *rcond, F_INT *rank, + void *work, F_INT *lwork, F_INT *iwork, F_INT *info); + +typedef void (*cgelsd_t)(F_INT *m, F_INT *n, F_INT *nrhs, void *a, F_INT *lda, + void *b, F_INT *ldb, void *s, void *rcond, F_INT *rank, + void *work, F_INT *lwork, void *rwork, F_INT *iwork, + F_INT *info); + +typedef void (*xgesv_t)(F_INT *n, F_INT *nrhs, void *a, F_INT *lda, F_INT *ipiv, + void *b, F_INT *ldb, F_INT *info); + + + +/* + * kind_size() + * gets the data size appropriate for a specified kind. + * + * Input: + * kind - the kind, one of: + * (s, d, c, z) = (float, double, complex, double complex). + * + * Returns: + * data_size - the appropriate data size. + * + */ +static size_t kind_size(char kind) +{ + size_t data_size = 0; + switch (kind) + { + case 's': + data_size = sizeof(float); + break; + case 'd': + data_size = sizeof(double); + break; + case 'c': + data_size = sizeof(npy_complex64); + break; + case 'z': + data_size = sizeof(npy_complex128); + break; + } + return data_size; + +} + +/* + * underlying_float_kind() + * gets the underlying float kind for a given kind. + * + * Input: + * kind - the kind, one of: + * (s, d, c, z) = (float, double, complex, double complex). + * + * Returns: + * underlying_float_kind - the underlying float kind, one of: + * (s, d) = (float, double). + * + * This function essentially provides a map between the char kind + * of a type and the char kind of the underlying float used in the + * type. Essentially: + * --------------- + * Input -> Output + * --------------- + * s -> s + * d -> d + * c -> s + * z -> d + * --------------- + * + */ +static char underlying_float_kind(char kind) +{ + switch(kind) + { + case 's': + case 'c': + return 's'; + case 'd': + case 'z': + return 'd'; + default: + { + PyGILState_STATE st = PyGILState_Ensure(); + PyErr_SetString(PyExc_ValueError, + "invalid kind in underlying_float_kind()"); + PyGILState_Release(st); + } + } + return -1; +} + +/* + * cast_from_X() + * cast from a kind (s, d, c, z) = (float, double, complex, double complex) + * to a Fortran integer. + * + * Parameters: + * kind the kind of val + * val a pointer to the value to cast + * + * Returns: + * A Fortran int from a cast of val (in complex case, takes the real part). + * + * Struct access via non c99 (python only) cmplx types, used for compatibility. + */ +static F_INT +cast_from_X(char kind, void *val) +{ + switch(kind) + { + case 's': + return (F_INT)(*((float *) val)); + case 'd': + return (F_INT)(*((double *) val)); + case 'c': + return (F_INT)crealf(*((_complex_float_t *)val)); + case 'z': + return (F_INT)creal(*((_complex_double_t *)val)); + default: + { + PyGILState_STATE st = PyGILState_Ensure(); + PyErr_SetString(PyExc_ValueError, + "invalid kind in cast"); + PyGILState_Release(st); + } + } + return -1; +} + + +#define CATCH_LAPACK_INVALID_ARG(__routine, info) \ + do { \ + if (info < 0) { \ + PyGILState_STATE st = PyGILState_Ensure(); \ + PyErr_Format(PyExc_RuntimeError, \ + "LAPACK Error: Routine " #__routine ". On input %d\n",\ + -(int) info); \ + PyGILState_Release(st); \ + return STATUS_ERROR; \ + } \ + } while(0) + +/* Compute LU decomposition of A + * NOTE: ipiv is an array of Fortran integers allocated by the caller, + * which is therefore expected to use the right dtype. + */ +NUMBA_EXPORT_FUNC(int) +numba_xxgetrf(char kind, Py_ssize_t m, Py_ssize_t n, void *a, Py_ssize_t lda, + F_INT *ipiv) +{ + void *raw_func = NULL; + F_INT _m, _n, _lda, info; + + ENSURE_VALID_KIND(kind) + + switch (kind) + { + case 's': + raw_func = get_clapack_sgetrf(); + break; + case 'd': + raw_func = get_clapack_dgetrf(); + break; + case 'c': + raw_func = get_clapack_cgetrf(); + break; + case 'z': + raw_func = get_clapack_zgetrf(); + break; + } + ENSURE_VALID_FUNC(raw_func) + + _m = (F_INT) m; + _n = (F_INT) n; + _lda = (F_INT) lda; + + (*(xxgetrf_t) raw_func)(&_m, &_n, a, &_lda, ipiv, &info); + CATCH_LAPACK_INVALID_ARG("xxgetrf", info); + + return (int)info; +} + +/* Compute the inverse of a matrix given its LU decomposition + * Args are as per LAPACK. + */ +static int +numba_raw_xxgetri(char kind, F_INT n, void *a, F_INT lda, + F_INT *ipiv, void *work, F_INT *lwork, F_INT *info) +{ + void *raw_func = NULL; + + ENSURE_VALID_KIND(kind) + + switch (kind) + { + case 's': + raw_func = get_clapack_sgetri(); + break; + case 'd': + raw_func = get_clapack_dgetri(); + break; + case 'c': + raw_func = get_clapack_cgetri(); + break; + case 'z': + raw_func = get_clapack_zgetri(); + break; + } + ENSURE_VALID_FUNC(raw_func) + + (*(xxgetri_t) raw_func)(&n, a, &lda, ipiv, work, lwork, info); + + return 0; +} + +/* Compute the inverse of a matrix from the factorization provided by + * xxgetrf. (see numba_xxgetrf() about ipiv) + * Args are as per LAPACK. + */ +NUMBA_EXPORT_FUNC(int) +numba_ez_xxgetri(char kind, Py_ssize_t n, void *a, Py_ssize_t lda, + F_INT *ipiv) +{ + F_INT _n, _lda; + F_INT lwork = -1; + F_INT info = 0; + size_t base_size = -1; + void * work = NULL; + all_dtypes stack_slot; + + ENSURE_VALID_KIND(kind) + + _n = (F_INT)n; + _lda = (F_INT)lda; + + base_size = kind_size(kind); + + work = &stack_slot; + + numba_raw_xxgetri(kind, _n, a, _lda, ipiv, work, &lwork, &info); + CATCH_LAPACK_INVALID_ARG("xxgetri", info); + + lwork = cast_from_X(kind, work); + + if (checked_PyMem_RawMalloc(&work, base_size * lwork)) + { + return STATUS_ERROR; + } + + numba_raw_xxgetri(kind, _n, a, _lda, ipiv, work, &lwork, &info); + PyMem_RawFree(work); + CATCH_LAPACK_INVALID_ARG("xxgetri", info); + + return (int)info; +} + +/* Compute the Cholesky factorization of a matrix. */ +NUMBA_EXPORT_FUNC(int) +numba_xxpotrf(char kind, char uplo, Py_ssize_t n, void *a, Py_ssize_t lda) +{ + void *raw_func = NULL; + F_INT _n, _lda, info; + + ENSURE_VALID_KIND(kind) + + switch (kind) + { + case 's': + raw_func = get_clapack_spotrf(); + break; + case 'd': + raw_func = get_clapack_dpotrf(); + break; + case 'c': + raw_func = get_clapack_cpotrf(); + break; + case 'z': + raw_func = get_clapack_zpotrf(); + break; + } + ENSURE_VALID_FUNC(raw_func) + + _n = (F_INT) n; + _lda = (F_INT) lda; + + (*(xxpotrf_t) raw_func)(&uplo, &_n, a, &_lda, &info); + CATCH_LAPACK_INVALID_ARG("xxpotrf", info); + return (int)info; +} + + +/* real space eigen systems info from dgeev/sgeev */ +static int +numba_raw_rgeev(char kind, char jobvl, char jobvr, + Py_ssize_t n, void *a, Py_ssize_t lda, void *wr, void *wi, + void *vl, Py_ssize_t ldvl, void *vr, Py_ssize_t ldvr, + void *work, Py_ssize_t lwork, F_INT *info) +{ + void *raw_func = NULL; + F_INT _n, _lda, _ldvl, _ldvr, _lwork; + + ENSURE_VALID_REAL_KIND(kind) + + switch (kind) + { + case 's': + raw_func = get_clapack_sgeev(); + break; + case 'd': + raw_func = get_clapack_dgeev(); + break; + } + ENSURE_VALID_FUNC(raw_func) + + _n = (F_INT) n; + _lda = (F_INT) lda; + _ldvl = (F_INT) ldvl; + _ldvr = (F_INT) ldvr; + _lwork = (F_INT) lwork; + + (*(rgeev_t) raw_func)(&jobvl, &jobvr, &_n, a, &_lda, wr, wi, vl, &_ldvl, vr, + &_ldvr, work, &_lwork, info); + return 0; +} + +/* Real space eigen systems info from dgeev/sgeev + * as numba_raw_rgeev but the allocation and error handling is done for the user. + * Args are as per LAPACK. + */ +NUMBA_EXPORT_FUNC(int) +numba_ez_rgeev(char kind, char jobvl, char jobvr, Py_ssize_t n, void *a, + Py_ssize_t lda, void *wr, void *wi, void *vl, Py_ssize_t ldvl, + void *vr, Py_ssize_t ldvr) +{ + F_INT info = 0; + F_INT lwork = -1; + F_INT _n, _lda, _ldvl, _ldvr; + size_t base_size = -1; + void * work = NULL; + all_dtypes stack_slot; + + ENSURE_VALID_REAL_KIND(kind) + + _n = (F_INT) n; + _lda = (F_INT) lda; + _ldvl = (F_INT) ldvl; + _ldvr = (F_INT) ldvr; + + base_size = kind_size(kind); + + work = &stack_slot; + numba_raw_rgeev(kind, jobvl, jobvr, _n, a, _lda, wr, wi, vl, _ldvl, + vr, _ldvr, work, lwork, &info); + CATCH_LAPACK_INVALID_ARG("numba_raw_rgeev", info); + + lwork = cast_from_X(kind, work); + if (checked_PyMem_RawMalloc(&work, base_size * lwork)) + { + return STATUS_ERROR; + } + numba_raw_rgeev(kind, jobvl, jobvr, _n, a, _lda, wr, wi, vl, _ldvl, + vr, _ldvr, work, lwork, &info); + PyMem_RawFree(work); + + CATCH_LAPACK_INVALID_ARG("numba_raw_rgeev", info); + + return (int)info; +} + +/* Complex space eigen systems info from cgeev/zgeev + * Args are as per LAPACK. + */ +static int +numba_raw_cgeev(char kind, char jobvl, char jobvr, + Py_ssize_t n, void *a, Py_ssize_t lda, void *w, void *vl, + Py_ssize_t ldvl, void *vr, Py_ssize_t ldvr, void *work, + Py_ssize_t lwork, void *rwork, F_INT *info) +{ + void *raw_func = NULL; + F_INT _n, _lda, _ldvl, _ldvr, _lwork; + + ENSURE_VALID_COMPLEX_KIND(kind) + + _n = (F_INT) n; + _lda = (F_INT) lda; + _ldvl = (F_INT) ldvl; + _ldvr = (F_INT) ldvr; + _lwork = (F_INT) lwork; + + switch (kind) + { + case 'c': + raw_func = get_clapack_cgeev(); + break; + case 'z': + raw_func = get_clapack_zgeev(); + break; + } + ENSURE_VALID_FUNC(raw_func) + + (*(cgeev_t) raw_func)(&jobvl, &jobvr, &_n, a, &_lda, w, vl, &_ldvl, vr, + &_ldvr, work, &_lwork, rwork, info); + return 0; +} + + +/* Complex space eigen systems info from cgeev/zgeev + * as numba_raw_cgeev but the allocation and error handling is done for the user. + * Args are as per LAPACK. + */ +NUMBA_EXPORT_FUNC(int) +numba_ez_cgeev(char kind, char jobvl, char jobvr, Py_ssize_t n, void *a, + Py_ssize_t lda, void *w, void *vl, Py_ssize_t ldvl, void *vr, + Py_ssize_t ldvr) +{ + F_INT info = 0; + F_INT lwork = -1; + F_INT _n, _lda, _ldvl, _ldvr; + size_t base_size = -1; + all_dtypes stack_slot, wk; + void * work = NULL; + void * rwork = (void *)&wk; + + ENSURE_VALID_COMPLEX_KIND(kind) + + _n = (F_INT) n; + _lda = (F_INT) lda; + _ldvl = (F_INT) ldvl; + _ldvr = (F_INT) ldvr; + + base_size = kind_size(kind); + + work = &stack_slot; + numba_raw_cgeev(kind, jobvl, jobvr, n, a, lda, w, vl, ldvl, + vr, ldvr, work, lwork, rwork, &info); + CATCH_LAPACK_INVALID_ARG("numba_raw_cgeev", info); + + lwork = cast_from_X(kind, work); + if (checked_PyMem_RawMalloc((void**)&rwork, 2*n*base_size)) + { + return STATUS_ERROR; + } + if (checked_PyMem_RawMalloc(&work, base_size * lwork)) + { + PyMem_RawFree(rwork); + return STATUS_ERROR; + } + numba_raw_cgeev(kind, jobvl, jobvr, _n, a, _lda, w, vl, _ldvl, + vr, _ldvr, work, lwork, rwork, &info); + PyMem_RawFree(work); + PyMem_RawFree(rwork); + CATCH_LAPACK_INVALID_ARG("numba_raw_cgeev", info); + + return (int)info; +} + +/* real space symmetric eigen systems info from ssyevd/dsyevd */ +static int +numba_raw_rsyevd(char kind, char jobz, char uplo, Py_ssize_t n, void *a, + Py_ssize_t lda, void *w, void *work, Py_ssize_t lwork, + F_INT *iwork, Py_ssize_t liwork, F_INT *info) +{ + void *raw_func = NULL; + F_INT _n, _lda, _lwork, _liwork; + + ENSURE_VALID_REAL_KIND(kind) + + switch (kind) + { + case 's': + raw_func = get_clapack_ssyevd(); + break; + case 'd': + raw_func = get_clapack_dsyevd(); + break; + } + ENSURE_VALID_FUNC(raw_func) + + _n = (F_INT) n; + _lda = (F_INT) lda; + _lwork = (F_INT) lwork; + _liwork = (F_INT) liwork; + + (*(xsyevd_t) raw_func)(&jobz, &uplo, &_n, a, &_lda, w, work, &_lwork, iwork, &_liwork, info); + return 0; +} + +/* Real space eigen systems info from dsyevd/ssyevd + * as numba_raw_rsyevd but the allocation and error handling is done for the user. + * Args are as per LAPACK. + */ +static int +numba_ez_rsyevd(char kind, char jobz, char uplo, Py_ssize_t n, void *a, Py_ssize_t lda, void *w) +{ + F_INT info = 0; + F_INT lwork = -1, liwork=-1; + F_INT _n, _lda; + size_t base_size = -1; + void *work = NULL; + F_INT *iwork = NULL; + all_dtypes stack_slot; + F_INT stack_int = -1; + + ENSURE_VALID_REAL_KIND(kind) + + _n = (F_INT) n; + _lda = (F_INT) lda; + + base_size = kind_size(kind); + + work = &stack_slot; + iwork = &stack_int; + numba_raw_rsyevd(kind, jobz, uplo, _n, a, _lda, w, work, lwork, iwork, liwork, &info); + CATCH_LAPACK_INVALID_ARG("numba_raw_rsyevd", info); + + lwork = cast_from_X(kind, work); + if (checked_PyMem_RawMalloc(&work, base_size * lwork)) + { + return STATUS_ERROR; + } + liwork = *iwork; + if (checked_PyMem_RawMalloc((void**)&iwork, base_size * liwork)) + { + PyMem_RawFree(work); + return STATUS_ERROR; + } + numba_raw_rsyevd(kind, jobz, uplo, _n, a, _lda, w, work, lwork, iwork, liwork, &info); + PyMem_RawFree(work); + PyMem_RawFree(iwork); + + CATCH_LAPACK_INVALID_ARG("numba_raw_rsyevd", info); + + return (int)info; +} + + +/* complex space symmetric eigen systems info from cheevd/zheevd*/ +static int +numba_raw_cheevd(char kind, char jobz, char uplo, Py_ssize_t n, void *a, + Py_ssize_t lda, void *w, void *work, Py_ssize_t lwork, + void *rwork, Py_ssize_t lrwork, F_INT *iwork, + Py_ssize_t liwork, F_INT *info) +{ + void *raw_func = NULL; + F_INT _n, _lda, _lwork, _lrwork, _liwork; + + ENSURE_VALID_COMPLEX_KIND(kind) + + switch (kind) + { + case 'c': + raw_func = get_clapack_cheevd(); + break; + case 'z': + raw_func = get_clapack_zheevd(); + break; + } + ENSURE_VALID_FUNC(raw_func) + + _n = (F_INT) n; + _lda = (F_INT) lda; + _lwork = (F_INT) lwork; + _lrwork = (F_INT) lrwork; + _liwork = (F_INT) liwork; + + (*(xheevd_t) raw_func)(&jobz, &uplo, &_n, a, &_lda, w, work, &_lwork, rwork, &_lrwork, iwork, &_liwork, info); + return 0; +} + +/* complex space eigen systems info from cheevd/zheevd + * as numba_raw_cheevd but the allocation and error handling is done for the user. + * Args are as per LAPACK. + */ +static int +numba_ez_cheevd(char kind, char jobz, char uplo, Py_ssize_t n, void *a, Py_ssize_t lda, void *w) +{ + F_INT info = 0; + F_INT lwork = -1, lrwork = -1, liwork=-1; + F_INT _n, _lda; + size_t base_size = -1, underlying_float_size = -1; + void *work = NULL, *rwork = NULL; + F_INT *iwork = NULL; + all_dtypes stack_slot1, stack_slot2; + char uf_kind; + F_INT stack_int = -1; + + ENSURE_VALID_COMPLEX_KIND(kind) + + _n = (F_INT) n; + _lda = (F_INT) lda; + + base_size = kind_size(kind); + uf_kind = underlying_float_kind(kind); + underlying_float_size = kind_size(uf_kind); + + work = &stack_slot1; + rwork = &stack_slot2; + iwork = &stack_int; + numba_raw_cheevd(kind, jobz, uplo, _n, a, _lda, w, work, lwork, rwork, lrwork, iwork, liwork, &info); + CATCH_LAPACK_INVALID_ARG("numba_raw_cheevd", info); + + lwork = cast_from_X(uf_kind, work); + if (checked_PyMem_RawMalloc(&work, base_size * lwork)) + { + return STATUS_ERROR; + } + + lrwork = cast_from_X(uf_kind, rwork); + if (checked_PyMem_RawMalloc(&rwork, underlying_float_size * lrwork)) + { + PyMem_RawFree(work); + return STATUS_ERROR; + } + + liwork = *iwork; + if (checked_PyMem_RawMalloc((void**)&iwork, base_size * liwork)) + { + PyMem_RawFree(work); + PyMem_RawFree(rwork); + return STATUS_ERROR; + } + numba_raw_cheevd(kind, jobz, uplo, _n, a, _lda, w, work, lwork, rwork, lrwork, iwork, liwork, &info); + PyMem_RawFree(work); + PyMem_RawFree(rwork); + PyMem_RawFree(iwork); + + CATCH_LAPACK_INVALID_ARG("numba_raw_cheevd", info); + + return (int)info; +} + +/* Hermitian eigenvalue systems info from *syevd and *heevd. + * This routine hides the type and general complexity involved with making the + * calls. The work space computation and error handling etc is hidden. + * Args are as per LAPACK. + */ +NUMBA_EXPORT_FUNC(int) +numba_ez_xxxevd(char kind, char jobz, char uplo, Py_ssize_t n, void *a, Py_ssize_t lda, void *w) +{ + ENSURE_VALID_KIND(kind) + + switch (kind) + { + case 's': + case 'd': + return numba_ez_rsyevd(kind, jobz, uplo, n, a, lda, w); + case 'c': + case 'z': + return numba_ez_cheevd(kind, jobz, uplo, n, a, lda, w); + } + return STATUS_ERROR; /* unreachable */ +} + +/* Real space svd systems info from dgesdd/sgesdd + * Args are as per LAPACK. + */ +static int +numba_raw_rgesdd(char kind, char jobz, Py_ssize_t m, Py_ssize_t n, void *a, + Py_ssize_t lda, void *s, void *u, Py_ssize_t ldu, void *vt, + Py_ssize_t ldvt, void *work, Py_ssize_t lwork, + F_INT *iwork, F_INT *info) +{ + void *raw_func = NULL; + F_INT _m, _n, _lda, _ldu, _ldvt, _lwork; + + ENSURE_VALID_REAL_KIND(kind) + + _m = (F_INT) m; + _n = (F_INT) n; + _lda = (F_INT) lda; + _ldu = (F_INT) ldu; + _ldvt = (F_INT) ldvt; + _lwork = (F_INT) lwork; + + switch (kind) + { + case 's': + raw_func = get_clapack_sgesdd(); + break; + case 'd': + raw_func = get_clapack_dgesdd(); + break; + } + ENSURE_VALID_FUNC(raw_func) + + (*(rgesdd_t) raw_func)(&jobz, &_m, &_n, a, &_lda, s, u, &_ldu, vt, &_ldvt, + work, &_lwork, iwork, info); + return 0; +} + +/* Real space svd info from dgesdd/sgesdd. + * As numba_raw_rgesdd but the allocation and error handling is done for the + * user. + * Args are as per LAPACK. + */ +static int +numba_ez_rgesdd(char kind, char jobz, Py_ssize_t m, Py_ssize_t n, void *a, + Py_ssize_t lda, void *s, void *u, Py_ssize_t ldu, void *vt, + Py_ssize_t ldvt) +{ + F_INT info = 0; + Py_ssize_t minmn = -1; + Py_ssize_t lwork = -1; + all_dtypes stack_slot, wk; + size_t base_size = -1; + F_INT *iwork = (F_INT *)&wk; + void *work = NULL; + + ENSURE_VALID_REAL_KIND(kind) + + base_size = kind_size(kind); + + work = &stack_slot; + + /* Compute optimal work size (lwork) */ + numba_raw_rgesdd(kind, jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, + lwork, iwork, &info); + CATCH_LAPACK_INVALID_ARG("numba_raw_rgesdd", info); + + /* Allocate work array */ + lwork = cast_from_X(kind, work); + if (checked_PyMem_RawMalloc(&work, base_size * lwork)) + return -1; + minmn = m > n ? n : m; + if (checked_PyMem_RawMalloc((void**) &iwork, 8 * minmn * sizeof(F_INT))) + { + PyMem_RawFree(work); + return STATUS_ERROR; + } + numba_raw_rgesdd(kind, jobz, m, n, a, lda, s, u ,ldu, vt, ldvt, work, lwork, + iwork, &info); + PyMem_RawFree(work); + PyMem_RawFree(iwork); + CATCH_LAPACK_INVALID_ARG("numba_raw_rgesdd", info); + + return (int)info; +} + +/* Complex space svd systems info from cgesdd/zgesdd + * Args are as per LAPACK. + */ +static int +numba_raw_cgesdd(char kind, char jobz, Py_ssize_t m, Py_ssize_t n, void *a, + Py_ssize_t lda, void *s, void *u, Py_ssize_t ldu, void *vt, + Py_ssize_t ldvt, void *work, Py_ssize_t lwork, void *rwork, + F_INT *iwork, F_INT *info) +{ + void *raw_func = NULL; + F_INT _m, _n, _lda, _ldu, _ldvt, _lwork; + + ENSURE_VALID_COMPLEX_KIND(kind) + + _m = (F_INT) m; + _n = (F_INT) n; + _lda = (F_INT) lda; + _ldu = (F_INT) ldu; + _ldvt = (F_INT) ldvt; + _lwork = (F_INT) lwork; + + switch (kind) + { + case 'c': + raw_func = get_clapack_cgesdd(); + break; + case 'z': + raw_func = get_clapack_zgesdd(); + break; + } + ENSURE_VALID_FUNC(raw_func) + + (*(cgesdd_t) raw_func)(&jobz, &_m, &_n, a, &_lda, s, u, &_ldu, vt, &_ldvt, + work, &_lwork, rwork, iwork, info); + return 0; +} + +/* complex space svd info from cgesdd/zgesdd. + * As numba_raw_cgesdd but the allocation and error handling is done for the + * user. + * Args are as per LAPACK. + */ +static int +numba_ez_cgesdd(char kind, char jobz, Py_ssize_t m, Py_ssize_t n, void *a, + Py_ssize_t lda, void *s, void *u, Py_ssize_t ldu, void *vt, + Py_ssize_t ldvt) +{ + F_INT info = 0; + Py_ssize_t lwork = -1; + Py_ssize_t lrwork = -1; + Py_ssize_t minmn = -1; + Py_ssize_t tmp1, tmp2; + Py_ssize_t maxmn = -1; + size_t real_base_size = -1; + size_t complex_base_size = -1; + all_dtypes stack_slot, wk1, wk2; + void *work = NULL; + void *rwork = (void *)&wk1; + F_INT *iwork = (F_INT *)&wk2; + + ENSURE_VALID_COMPLEX_KIND(kind) + + switch (kind) + { + case 'c': + real_base_size = sizeof(float); + complex_base_size = sizeof(npy_complex64); + break; + case 'z': + real_base_size = sizeof(double); + complex_base_size = sizeof(npy_complex128); + break; + default: + { + PyGILState_STATE st = PyGILState_Ensure(); + PyErr_SetString(PyExc_ValueError,\ + "Invalid kind in numba_ez_rgesdd"); + PyGILState_Release(st); + } + return STATUS_ERROR; + } + + work = &stack_slot; + + /* Compute optimal work size (lwork) */ + numba_raw_cgesdd(kind, jobz, m, n, a, lda, s, u ,ldu, vt, ldvt, work, lwork, + rwork, iwork, &info); + CATCH_LAPACK_INVALID_ARG("numba_raw_cgesdd", info); + + /* Allocate work array */ + lwork = cast_from_X(kind, work); + if (checked_PyMem_RawMalloc(&work, complex_base_size * lwork)) + return STATUS_ERROR; + + minmn = m > n ? n : m; + if (jobz == 'n') + { + lrwork = 7 * minmn; + } + else + { + maxmn = m > n ? m : n; + tmp1 = 5 * minmn + 7; + tmp2 = 2 * maxmn + 2 * minmn + 1; + lrwork = minmn * (tmp1 > tmp2 ? tmp1: tmp2); + } + + if (checked_PyMem_RawMalloc(&rwork, + real_base_size * (lrwork > 1 ? lrwork : 1))) + { + PyMem_RawFree(work); + return STATUS_ERROR; + } + if (checked_PyMem_RawMalloc((void **) &iwork, + 8 * minmn * sizeof(F_INT))) + { + PyMem_RawFree(work); + PyMem_RawFree(rwork); + return STATUS_ERROR; + } + numba_raw_cgesdd(kind, jobz, m, n, a, lda, s, u ,ldu, vt, ldvt, work, lwork, + rwork, iwork, &info); + PyMem_RawFree(work); + PyMem_RawFree(rwork); + PyMem_RawFree(iwork); + CATCH_LAPACK_INVALID_ARG("numba_raw_cgesdd", info); + + return (int)info; +} + + +/* SVD systems info from *gesdd. + * This routine hides the type and general complexity involved with making the + * calls to *gesdd. The work space computation and error handling etc is hidden. + * Args are as per LAPACK. + */ +NUMBA_EXPORT_FUNC(int) +numba_ez_gesdd(char kind, char jobz, Py_ssize_t m, Py_ssize_t n, void *a, + Py_ssize_t lda, void *s, void *u, Py_ssize_t ldu, void *vt, + Py_ssize_t ldvt) +{ + ENSURE_VALID_KIND(kind) + + switch (kind) + { + case 's': + case 'd': + return numba_ez_rgesdd(kind, jobz, m, n, a, lda, s, u, ldu, vt, + ldvt); + case 'c': + case 'z': + return numba_ez_cgesdd(kind, jobz, m, n, a, lda, s, u, ldu, vt, + ldvt); + } + return STATUS_ERROR; /* unreachable */ +} + + +/* + * Compute the QR factorization of a matrix. + * Return -1 on internal error, 0 on success, > 0 on failure. + */ +static int +numba_raw_xgeqrf(char kind, Py_ssize_t m, Py_ssize_t n, void *a, Py_ssize_t + lda, void *tau, void *work, Py_ssize_t lwork, F_INT *info) +{ + void *raw_func = NULL; + F_INT _m, _n, _lda, _lwork; + + ENSURE_VALID_KIND(kind) + + switch (kind) + { + case 's': + raw_func = get_clapack_sgeqrf(); + break; + case 'd': + raw_func = get_clapack_dgeqrf(); + break; + case 'c': + raw_func = get_clapack_cgeqrf(); + break; + case 'z': + raw_func = get_clapack_zgeqrf(); + break; + } + ENSURE_VALID_FUNC(raw_func) + + _m = (F_INT) m; + _n = (F_INT) n; + _lda = (F_INT) lda; + _lwork = (F_INT) lwork; + + (*(xgeqrf_t) raw_func)(&_m, &_n, a, &_lda, tau, work, &_lwork, info); + return 0; +} + +/* + * Compute the QR factorization of a matrix. + * This routine hides the type and general complexity involved with making the + * xgeqrf calls. The work space computation and error handling etc is hidden. + * Args are as per LAPACK. + */ +NUMBA_EXPORT_FUNC(int) +numba_ez_geqrf(char kind, Py_ssize_t m, Py_ssize_t n, void *a, Py_ssize_t + lda, void *tau) +{ + F_INT info = 0; + Py_ssize_t lwork = -1; + size_t base_size = -1; + all_dtypes stack_slot; + void *work = NULL; + + base_size = kind_size(kind); + + work = &stack_slot; + + /* Compute optimal work size (lwork) */ + numba_raw_xgeqrf(kind, m, n, a, lda, tau, work, lwork, &info); + CATCH_LAPACK_INVALID_ARG("numba_raw_xgeqrf", info); + + /* Allocate work array */ + lwork = cast_from_X(kind, work); + if (checked_PyMem_RawMalloc(&work, base_size * lwork)) + return STATUS_ERROR; + + numba_raw_xgeqrf(kind, m, n, a, lda, tau, work, lwork, &info); + PyMem_RawFree(work); + CATCH_LAPACK_INVALID_ARG("numba_raw_xgeqrf", info); + + return 0; /* info cannot be >0 */ + +} + + +/* + * Compute the orthogonal Q matrix (in QR) from elementary relectors. + */ +static int +numba_raw_xxxgqr(char kind, Py_ssize_t m, Py_ssize_t n, Py_ssize_t k, void *a, + Py_ssize_t lda, void *tau, void * work, Py_ssize_t lwork, F_INT *info) +{ + void *raw_func = NULL; + F_INT _m, _n, _k, _lda, _lwork; + + ENSURE_VALID_KIND(kind) + + switch (kind) + { + case 's': + raw_func = get_clapack_sorgqr(); + break; + case 'd': + raw_func = get_clapack_dorgqr(); + break; + case 'c': + raw_func = get_clapack_cungqr(); + break; + case 'z': + raw_func = get_clapack_zungqr(); + break; + } + ENSURE_VALID_FUNC(raw_func) + + _m = (F_INT) m; + _n = (F_INT) n; + _k = (F_INT) k; + _lda = (F_INT) lda; + _lwork = (F_INT) lwork; + + (*(xxxgqr_t) raw_func)(&_m, &_n, &_k, a, &_lda, tau, work, &_lwork, info); + return 0; +} + + +/* + * Compute the orthogonal Q matrix (in QR) from elementary reflectors. + * This routine hides the type and general complexity involved with making the + * x{or,un}qrf calls. The work space computation and error handling etc is + * hidden. Args are as per LAPACK. + */ +NUMBA_EXPORT_FUNC(int) +numba_ez_xxgqr(char kind, Py_ssize_t m, Py_ssize_t n, Py_ssize_t k, void *a, + Py_ssize_t lda, void *tau) +{ + F_INT info = 0; + Py_ssize_t lwork = -1; + size_t base_size = -1; + all_dtypes stack_slot; + void *work = NULL; + + work = &stack_slot; + + /* Compute optimal work size (lwork) */ + numba_raw_xxxgqr(kind, m, n, k, a, lda, tau, work, lwork, &info); + CATCH_LAPACK_INVALID_ARG("numba_raw_xxxgqr", info); + + base_size = kind_size(kind); + + /* Allocate work array */ + lwork = cast_from_X(kind, work); + if (checked_PyMem_RawMalloc(&work, base_size * lwork)) + return STATUS_ERROR; + + numba_raw_xxxgqr(kind, m, n, k, a, lda, tau, work, lwork, &info); + PyMem_RawFree(work); + CATCH_LAPACK_INVALID_ARG("numba_raw_xxxgqr", info); + + return 0; /* info cannot be >0 */ + +} + + +/* + * Compute the minimum-norm solution to a real linear least squares problem. + */ +static int +numba_raw_rgelsd(char kind, Py_ssize_t m, Py_ssize_t n, Py_ssize_t nrhs, + void *a, Py_ssize_t lda, void *b, Py_ssize_t ldb, void *S, + void * rcond, Py_ssize_t * rank, void * work, + Py_ssize_t lwork, F_INT *iwork, F_INT *info) +{ + void *raw_func = NULL; + F_INT _m, _n, _nrhs, _lda, _ldb, _rank, _lwork; + + ENSURE_VALID_REAL_KIND(kind) + + switch (kind) + { + case 's': + raw_func = get_clapack_sgelsd(); + break; + case 'd': + raw_func = get_clapack_dgelsd(); + break; + } + ENSURE_VALID_FUNC(raw_func) + + _m = (F_INT) m; + _n = (F_INT) n; + _nrhs = (F_INT) nrhs; + _lda = (F_INT) lda; + _ldb = (F_INT) ldb; + _lwork = (F_INT) lwork; + + (*(rgelsd_t) raw_func)(&_m, &_n, &_nrhs, a, &_lda, b, &_ldb, S, rcond, + &_rank, work, &_lwork, iwork, info); + *rank = (Py_ssize_t) _rank; + return 0; +} + +/* + * Compute the minimum-norm solution to a real linear least squares problem. + * This routine hides the type and general complexity involved with making the + * {s,d}gelsd calls. The work space computation and error handling etc is + * hidden. Args are as per LAPACK. + */ +static int +numba_ez_rgelsd(char kind, Py_ssize_t m, Py_ssize_t n, Py_ssize_t nrhs, + void *a, Py_ssize_t lda, void *b, Py_ssize_t ldb, void *S, + double rcond, Py_ssize_t * rank) +{ + F_INT info = 0; + Py_ssize_t lwork = -1; + size_t base_size = -1; + all_dtypes stack_slot; + void *work = NULL, *rcond_cast = NULL; + F_INT *iwork = NULL; + F_INT iwork_tmp; + float tmpf; + + ENSURE_VALID_REAL_KIND(kind) + + base_size = kind_size(kind); + + work = &stack_slot; + rcond_cast = work; /* stop checks on null ptr complaining */ + + /* Compute optimal work size (lwork) */ + numba_raw_rgelsd(kind, m, n, nrhs, a, lda, b, ldb, S, rcond_cast, rank, + work, lwork, &iwork_tmp, &info); + CATCH_LAPACK_INVALID_ARG("numba_raw_rgelsd", info); + + /* Allocate work array */ + lwork = cast_from_X(kind, work); + if (checked_PyMem_RawMalloc(&work, base_size * lwork)) + return STATUS_ERROR; + + /* Allocate iwork array */ + if (checked_PyMem_RawMalloc((void **)&iwork, sizeof(F_INT) * iwork_tmp)) + { + PyMem_RawFree(work); + return STATUS_ERROR; + } + + /* cast rcond to the right type */ + switch (kind) + { + case 's': + tmpf = (float)rcond; + rcond_cast = (void * )&tmpf; + break; + case 'd': + rcond_cast = (void * )&rcond; + break; + } + + numba_raw_rgelsd(kind, m, n, nrhs, a, lda, b, ldb, S, rcond_cast, rank, + work, lwork, iwork, &info); + PyMem_RawFree(work); + PyMem_RawFree(iwork); + CATCH_LAPACK_INVALID_ARG("numba_raw_rgelsd", info); + + return (int)info; +} + + +/* + * Compute the minimum-norm solution to a complex linear least squares problem. + */ +static int +numba_raw_cgelsd(char kind, Py_ssize_t m, Py_ssize_t n, Py_ssize_t nrhs, + void *a, Py_ssize_t lda, void *b, Py_ssize_t ldb, void *S, + void *rcond, Py_ssize_t * rank, void * work, + Py_ssize_t lwork, void * rwork, F_INT *iwork, F_INT *info) +{ + void *raw_func = NULL; + F_INT _m, _n, _nrhs, _lda, _ldb, _rank, _lwork; + + ENSURE_VALID_COMPLEX_KIND(kind) + + switch (kind) + { + case 'c': + raw_func = get_clapack_cgelsd(); + break; + case 'z': + raw_func = get_clapack_zgelsd(); + break; + } + ENSURE_VALID_FUNC(raw_func) + + _m = (F_INT) m; + _n = (F_INT) n; + _nrhs = (F_INT) nrhs; + _lda = (F_INT) lda; + _ldb = (F_INT) ldb; + _lwork = (F_INT) lwork; + + (*(cgelsd_t) raw_func)(&_m, &_n, &_nrhs, a, &_lda, b, &_ldb, S, rcond, + &_rank, work, &_lwork, rwork, iwork, info); + *rank = (Py_ssize_t) _rank; + return 0; +} + + +/* + * Compute the minimum-norm solution to a complex linear least squares problem. + * This routine hides the type and general complexity involved with making the + * {c,z}gelsd calls. The work space computation and error handling etc is + * hidden. Args are as per LAPACK. + */ +static int +numba_ez_cgelsd(char kind, Py_ssize_t m, Py_ssize_t n, Py_ssize_t nrhs, + void *a, Py_ssize_t lda, void *b, Py_ssize_t ldb, void *S, + double rcond, Py_ssize_t * rank) +{ + F_INT info = 0; + Py_ssize_t lwork = -1; + size_t base_size = -1; + all_dtypes stack_slot1, stack_slot2; + size_t real_base_size = 0; + void *work = NULL, *rwork = NULL, *rcond_cast = NULL; + Py_ssize_t lrwork; + F_INT *iwork = NULL; + F_INT iwork_tmp; + char real_kind = '-'; + float tmpf; + + ENSURE_VALID_COMPLEX_KIND(kind) + + base_size = kind_size(kind); + + work = &stack_slot1; + rwork = &stack_slot2; + rcond_cast = work; /* stop checks on null ptr complaining */ + + /* Compute optimal work size */ + numba_raw_cgelsd(kind, m, n, nrhs, a, lda, b, ldb, S, rcond_cast, rank, + work, lwork, rwork, &iwork_tmp, &info); + CATCH_LAPACK_INVALID_ARG("numba_raw_cgelsd", info); + + /* Allocate work array */ + lwork = cast_from_X(kind, work); + if (checked_PyMem_RawMalloc(&work, base_size * lwork)) + return STATUS_ERROR; + + /* Allocate iwork array */ + if (checked_PyMem_RawMalloc((void **)&iwork, sizeof(F_INT) * iwork_tmp)) + { + PyMem_RawFree(work); + return STATUS_ERROR; + } + + switch (kind) + { + case 'c': + real_kind = 's'; + tmpf = (float)rcond; + rcond_cast = (void * )&tmpf; + break; + case 'z': + real_kind = 'd'; + rcond_cast = (void * )&rcond; + break; + } + + real_base_size = kind_size(real_kind); + + lrwork = cast_from_X(real_kind, rwork); + if (checked_PyMem_RawMalloc((void **)&rwork, real_base_size * lrwork)) + { + PyMem_RawFree(work); + PyMem_RawFree(iwork); + return STATUS_ERROR; + } + + numba_raw_cgelsd(kind, m, n, nrhs, a, lda, b, ldb, S, rcond_cast, rank, + work, lwork, rwork, iwork, &info); + PyMem_RawFree(work); + PyMem_RawFree(rwork); + PyMem_RawFree(iwork); + CATCH_LAPACK_INVALID_ARG("numba_raw_cgelsd", info); + + return (int)info; +} + + +/* + * Compute the minimum-norm solution to a linear least squares problems. + * This routine hides the type and general complexity involved with making the + * calls to *gelsd. The work space computation and error handling etc is hidden. + * Args are as per LAPACK. + */ +NUMBA_EXPORT_FUNC(int) +numba_ez_gelsd(char kind, Py_ssize_t m, Py_ssize_t n, Py_ssize_t nrhs, + void *a, Py_ssize_t lda, void *b, Py_ssize_t ldb, void *S, + double rcond, Py_ssize_t * rank) +{ + ENSURE_VALID_KIND(kind) + + switch (kind) + { + case 's': + case 'd': + return numba_ez_rgelsd(kind, m, n, nrhs, a, lda, b, ldb, S, rcond, + rank); + case 'c': + case 'z': + return numba_ez_cgelsd(kind, m, n, nrhs, a, lda, b, ldb, S, rcond, + rank); + } + return STATUS_ERROR; /* unreachable */ +} + + +/* + * Compute the solution to a system of linear equations + */ +NUMBA_EXPORT_FUNC(int) +numba_xgesv(char kind, Py_ssize_t n, Py_ssize_t nrhs, void *a, Py_ssize_t lda, + F_INT *ipiv, void *b, Py_ssize_t ldb) +{ + void *raw_func = NULL; + F_INT _n, _nrhs, _lda, _ldb, info; + + ENSURE_VALID_KIND(kind) + + switch (kind) + { + case 's': + raw_func = get_clapack_sgesv(); + break; + case 'd': + raw_func = get_clapack_dgesv(); + break; + case 'c': + raw_func = get_clapack_cgesv(); + break; + case 'z': + raw_func = get_clapack_zgesv(); + break; + } + + ENSURE_VALID_FUNC(raw_func) + + _n = (F_INT) n; + _nrhs = (F_INT) nrhs; + _lda = (F_INT) lda; + _ldb = (F_INT) ldb; + + (*(xgesv_t) raw_func)(&_n, &_nrhs, a, &_lda, ipiv, b, &_ldb, &info); + CATCH_LAPACK_INVALID_ARG("xgesv", info); + + return (int)info; +} + +/* undef defines and macros */ +#undef STATUS_SUCCESS +#undef STATUS_ERROR +#undef ENSURE_VALID_KIND +#undef ENSURE_VALID_REAL_KIND +#undef ENSURE_VALID_COMPLEX_KIND +#undef ENSURE_VALID_FUNC +#undef EMIT_GET_CLAPACK_FUNC +#undef CATCH_LAPACK_INVALID_ARG diff --git a/shared/package-files/31/311e3b9a6f2be45b876706df252955ed1360f01b253715278a540cb6695a2f1b/blob b/shared/package-files/31/311e3b9a6f2be45b876706df252955ed1360f01b253715278a540cb6695a2f1b/blob new file mode 100644 index 0000000000000000000000000000000000000000..99e254426f259cbedd7b6428ac46e800e3097041 --- /dev/null +++ b/shared/package-files/31/311e3b9a6f2be45b876706df252955ed1360f01b253715278a540cb6695a2f1b/blob @@ -0,0 +1,28 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API rnn_tanh_cell { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const c10::optional &, const c10::optional &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::rnn_tanh_cell") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "rnn_tanh_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor? b_ih=None, Tensor? b_hh=None) -> Tensor") + static at::Tensor call(const at::Tensor & input, const at::Tensor & hx, const at::Tensor & w_ih, const at::Tensor & w_hh, const c10::optional & b_ih, const c10::optional & b_hh); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const at::Tensor & hx, const at::Tensor & w_ih, const at::Tensor & w_hh, const c10::optional & b_ih, const c10::optional & b_hh); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/31/31200b0210718501a7ebb0bf8019161242ca7db17c97636073b797815a6181f5/blob b/shared/package-files/31/31200b0210718501a7ebb0bf8019161242ca7db17c97636073b797815a6181f5/blob new file mode 100644 index 0000000000000000000000000000000000000000..d71f1c337e6249394b4e22180270f4943b77a96c --- /dev/null +++ b/shared/package-files/31/31200b0210718501a7ebb0bf8019161242ca7db17c97636073b797815a6181f5/blob @@ -0,0 +1,192 @@ +# This file is part of Hypothesis, which may be found at +# https://github.com/HypothesisWorks/hypothesis/ +# +# Copyright the Hypothesis Authors. +# Individual contributors are listed in AUTHORS.rst and the git log. +# +# This Source Code Form is subject to the terms of the Mozilla Public License, +# v. 2.0. If a copy of the MPL was not distributed with this file, You can +# obtain one at https://mozilla.org/MPL/2.0/. + +class HypothesisException(Exception): + """Generic parent class for exceptions thrown by Hypothesis.""" + + +class _Trimmable(HypothesisException): + """Hypothesis can trim these tracebacks even if they're raised internally.""" + + +class UnsatisfiedAssumption(HypothesisException): + """An internal error raised by assume. + + If you're seeing this error something has gone wrong. + """ + + def __init__(self, reason=None): + self.reason = reason + + +class NoSuchExample(HypothesisException): + """The condition we have been asked to satisfy appears to be always false. + + This does not guarantee that no example exists, only that we were + unable to find one. + """ + + def __init__(self, condition_string, extra=""): + super().__init__(f"No examples found of condition {condition_string}{extra}") + + +class Unsatisfiable(_Trimmable): + """We ran out of time or examples before we could find enough examples + which satisfy the assumptions of this hypothesis. + + This could be because the function is too slow. If so, try upping + the timeout. It could also be because the function is using assume + in a way that is too hard to satisfy. If so, try writing a custom + strategy or using a better starting point (e.g if you are requiring + a list has unique values you could instead filter out all duplicate + values from the list) + """ + + +class Flaky(_Trimmable): + """This function appears to fail non-deterministically: We have seen it + fail when passed this example at least once, but a subsequent invocation + did not fail. + + Common causes for this problem are: + 1. The function depends on external state. e.g. it uses an external + random number generator. Try to make a version that passes all the + relevant state in from Hypothesis. + 2. The function is suffering from too much recursion and its failure + depends sensitively on where it's been called from. + 3. The function is timing sensitive and can fail or pass depending on + how long it takes. Try breaking it up into smaller functions which + don't do that and testing those instead. + """ + + +class InvalidArgument(_Trimmable, TypeError): + """Used to indicate that the arguments to a Hypothesis function were in + some manner incorrect.""" + + +class ResolutionFailed(InvalidArgument): + """Hypothesis had to resolve a type to a strategy, but this failed. + + Type inference is best-effort, so this only happens when an + annotation exists but could not be resolved for a required argument + to the target of ``builds()``, or where the user passed ``...``. + """ + + +class InvalidState(HypothesisException): + """The system is not in a state where you were allowed to do that.""" + + +class InvalidDefinition(_Trimmable, TypeError): + """Used to indicate that a class definition was not well put together and + has something wrong with it.""" + + +class HypothesisWarning(HypothesisException, Warning): + """A generic warning issued by Hypothesis.""" + + +class FailedHealthCheck(_Trimmable): + """Raised when a test fails a healthcheck.""" + + +class NonInteractiveExampleWarning(HypothesisWarning): + """SearchStrategy.example() is designed for interactive use, + but should never be used in the body of a test. + """ + + +class HypothesisDeprecationWarning(HypothesisWarning, FutureWarning): + """A deprecation warning issued by Hypothesis. + + Actually inherits from FutureWarning, because DeprecationWarning is + hidden by the default warnings filter. + + You can configure the Python :mod:`python:warnings` to handle these + warnings differently to others, either turning them into errors or + suppressing them entirely. Obviously we would prefer the former! + """ + + +class HypothesisSideeffectWarning(HypothesisWarning): + """A warning issued by Hypothesis when it sees actions that are + discouraged at import or initialization time because they are + slow or have user-visible side effects. + """ + + +class Frozen(HypothesisException): + """Raised when a mutation method has been called on a ConjectureData object + after freeze() has been called.""" + + +def __getattr__(name): + if name == "MultipleFailures": + from hypothesis._settings import note_deprecation + from hypothesis.internal.compat import BaseExceptionGroup + + note_deprecation( + "MultipleFailures is deprecated; use the builtin `BaseExceptionGroup` type " + "instead, or `exceptiongroup.BaseExceptionGroup` before Python 3.11", + since="2022-08-02", + has_codemod=False, # This would be a great PR though! + stacklevel=1, + ) + return BaseExceptionGroup + + raise AttributeError(f"Module 'hypothesis.errors' has no attribute {name}") + + +class DeadlineExceeded(_Trimmable): + """Raised when an individual test body has taken too long to run.""" + + def __init__(self, runtime, deadline): + super().__init__( + "Test took %.2fms, which exceeds the deadline of %.2fms" + % (runtime.total_seconds() * 1000, deadline.total_seconds() * 1000) + ) + self.runtime = runtime + self.deadline = deadline + + def __reduce__(self): + return (type(self), (self.runtime, self.deadline)) + + +class StopTest(BaseException): + """Raised when a test should stop running and return control to + the Hypothesis engine, which should then continue normally. + """ + + def __init__(self, testcounter): + super().__init__(repr(testcounter)) + self.testcounter = testcounter + + +class DidNotReproduce(HypothesisException): + pass + + +class Found(Exception): + """Signal that the example matches condition. Internal use only.""" + + hypothesis_internal_never_escalate = True + + +class RewindRecursive(Exception): + """Signal that the type inference should be rewound due to recursive types. Internal use only.""" + + def __init__(self, target): + self.target = target + + +class SmallSearchSpaceWarning(HypothesisWarning): + """Indicates that an inferred strategy does not span the search space + in a meaningful way, for example by only creating default instances.""" diff --git a/shared/package-files/31/312163953dc1d78c041a8c739f13e6e6d800a59602c26817b881bec5f9f48b38/blob b/shared/package-files/31/312163953dc1d78c041a8c739f13e6e6d800a59602c26817b881bec5f9f48b38/blob new file mode 100644 index 0000000000000000000000000000000000000000..01aab769ee9e990baa7720b039e7373a362177fa --- /dev/null +++ b/shared/package-files/31/312163953dc1d78c041a8c739f13e6e6d800a59602c26817b881bec5f9f48b38/blob @@ -0,0 +1,24 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor & _sparse_log_softmax_backward_data_out(at::Tensor & out, const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, const at::Tensor & self); +TORCH_API at::Tensor & _sparse_log_softmax_backward_data_outf(const at::Tensor & grad_output, const at::Tensor & output, int64_t dim, const at::Tensor & self, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/shared/package-files/31/31250272d0f7c3f9a65ebae3b5f60ab90dbf0c5fb6e8618d9efae137c00f199f/blob b/shared/package-files/31/31250272d0f7c3f9a65ebae3b5f60ab90dbf0c5fb6e8618d9efae137c00f199f/blob new file mode 100644 index 0000000000000000000000000000000000000000..059bd93607080145c6910adc5ddf32e33b84583b --- /dev/null +++ b/shared/package-files/31/31250272d0f7c3f9a65ebae3b5f60ab90dbf0c5fb6e8618d9efae137c00f199f/blob @@ -0,0 +1,67 @@ +import _random +from typing import AbstractSet, Any, Callable, Iterator, List, MutableSequence, Protocol, Sequence, TypeVar, Union, overload + +_T = TypeVar("_T") +_T_co = TypeVar("_T_co", covariant=True) + +class _Sampleable(Protocol[_T_co]): + def __iter__(self) -> Iterator[_T_co]: ... + def __len__(self) -> int: ... + +class Random(_random.Random): + def __init__(self, x: object = ...) -> None: ... + def seed(self, x: object = ...) -> None: ... + def getstate(self) -> _random._State: ... + def setstate(self, state: _random._State) -> None: ... + def jumpahead(self, n: int) -> None: ... + def getrandbits(self, k: int) -> int: ... + @overload + def randrange(self, stop: int) -> int: ... + @overload + def randrange(self, start: int, stop: int, step: int = ...) -> int: ... + def randint(self, a: int, b: int) -> int: ... + def choice(self, seq: Sequence[_T]) -> _T: ... + def shuffle(self, x: MutableSequence[Any], random: Callable[[], None] = ...) -> None: ... + def sample(self, population: _Sampleable[_T], k: int) -> List[_T]: ... + def random(self) -> float: ... + def uniform(self, a: float, b: float) -> float: ... + def triangular(self, low: float = ..., high: float = ..., mode: float = ...) -> float: ... + def betavariate(self, alpha: float, beta: float) -> float: ... + def expovariate(self, lambd: float) -> float: ... + def gammavariate(self, alpha: float, beta: float) -> float: ... + def gauss(self, mu: float, sigma: float) -> float: ... + def lognormvariate(self, mu: float, sigma: float) -> float: ... + def normalvariate(self, mu: float, sigma: float) -> float: ... + def vonmisesvariate(self, mu: float, kappa: float) -> float: ... + def paretovariate(self, alpha: float) -> float: ... + def weibullvariate(self, alpha: float, beta: float) -> float: ... + +# SystemRandom is not implemented for all OS's; good on Windows & Linux +class SystemRandom(Random): ... + +# ----- random function stubs ----- +def seed(x: object = ...) -> None: ... +def getstate() -> object: ... +def setstate(state: object) -> None: ... +def jumpahead(n: int) -> None: ... +def getrandbits(k: int) -> int: ... +@overload +def randrange(stop: int) -> int: ... +@overload +def randrange(start: int, stop: int, step: int = ...) -> int: ... +def randint(a: int, b: int) -> int: ... +def choice(seq: Sequence[_T]) -> _T: ... +def shuffle(x: MutableSequence[Any], random: Callable[[], float] = ...) -> None: ... +def sample(population: _Sampleable[_T], k: int) -> List[_T]: ... +def random() -> float: ... +def uniform(a: float, b: float) -> float: ... +def triangular(low: float = ..., high: float = ..., mode: float = ...) -> float: ... +def betavariate(alpha: float, beta: float) -> float: ... +def expovariate(lambd: float) -> float: ... +def gammavariate(alpha: float, beta: float) -> float: ... +def gauss(mu: float, sigma: float) -> float: ... +def lognormvariate(mu: float, sigma: float) -> float: ... +def normalvariate(mu: float, sigma: float) -> float: ... +def vonmisesvariate(mu: float, kappa: float) -> float: ... +def paretovariate(alpha: float) -> float: ... +def weibullvariate(alpha: float, beta: float) -> float: ... diff --git a/shared/package-files/31/3125660dd7735efc6bd5a4419e04bb2fec776a633796d1266886f37072dbe2f0/blob b/shared/package-files/31/3125660dd7735efc6bd5a4419e04bb2fec776a633796d1266886f37072dbe2f0/blob new file mode 100644 index 0000000000000000000000000000000000000000..af399a994c59609c86c2a4c8e9b95bc1ce7b538f --- /dev/null +++ b/shared/package-files/31/3125660dd7735efc6bd5a4419e04bb2fec776a633796d1266886f37072dbe2f0/blob @@ -0,0 +1 @@ +{"dir_info": {}, "url": "file:///croot/sympy_1701397643339/work"} \ No newline at end of file diff --git a/shared/package-files/31/31267020feab619113baa2b871efb50dd267fb4bad54ed160df021bd7f6000a0/blob b/shared/package-files/31/31267020feab619113baa2b871efb50dd267fb4bad54ed160df021bd7f6000a0/blob new file mode 100644 index 0000000000000000000000000000000000000000..ff6b24434a4ca2e43ffc3f52c06d84ddc7b3bc40 --- /dev/null +++ b/shared/package-files/31/31267020feab619113baa2b871efb50dd267fb4bad54ed160df021bd7f6000a0/blob @@ -0,0 +1,27 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeMetaFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace meta { + +struct TORCH_API structured_mish : public TensorIteratorBase { + + + void meta(const at::Tensor & self); +}; + +} // namespace native +} // namespace at diff --git a/shared/package-files/31/31267a76b8613f7d77947f689bdcdf75d4489feddb75640a88eca6ad35fb0938/blob b/shared/package-files/31/31267a76b8613f7d77947f689bdcdf75d4489feddb75640a88eca6ad35fb0938/blob new file mode 100644 index 0000000000000000000000000000000000000000..8ab364c881747b418b58a006be4b0ca7728aea5d --- /dev/null +++ b/shared/package-files/31/31267a76b8613f7d77947f689bdcdf75d4489feddb75640a88eca6ad35fb0938/blob @@ -0,0 +1,80 @@ +"""First 100 days of the US House of Representatives 1995""" +from statsmodels.datasets import utils as du + +__docformat__ = "restructuredtext" + +COPYRIGHT = """Used with express permission from the original author, +who retains all rights.""" +TITLE = __doc__ +SOURCE = """ +Jeff Gill's *Generalized Linear Models: A Unified Approach* + +http://jgill.wustl.edu/research/books.html +""" + +DESCRSHORT = """Number of bill assignments in the 104th House in 1995""" + +DESCRLONG = """The example in Gill, seeks to explain the number of bill +assignments in the first 100 days of the US' 104th House of Representatives. +The response variable is the number of bill assignments in the first 100 days +over 20 Committees. The explanatory variables in the example are the number of +assignments in the first 100 days of the 103rd House, the number of members on +the committee, the number of subcommittees, the log of the number of staff +assigned to the committee, a dummy variable indicating whether +the committee is a high prestige committee, and an interaction term between +the number of subcommittees and the log of the staff size. + +The data returned by load are not cleaned to represent the above example. +""" + +NOTE = """:: + + Number of Observations - 20 + Number of Variables - 6 + Variable name definitions:: + + BILLS104 - Number of bill assignments in the first 100 days of the + 104th House of Representatives. + SIZE - Number of members on the committee. + SUBS - Number of subcommittees. + STAFF - Number of staff members assigned to the committee. + PRESTIGE - PRESTIGE == 1 is a high prestige committee. + BILLS103 - Number of bill assignments in the first 100 days of the + 103rd House of Representatives. + + Committee names are included as a variable in the data file though not + returned by load. +""" + + +def load_pandas(): + """ + Load the committee data and returns a Dataset class. + + Returns + ------- + Dataset + A `Dataset` instance with ``data``, ``names``, ``endog``, ``exog``, + ``endog_name`` and ``exog_name`` attributes. + """ + data = _get_data() + return du.process_pandas(data, endog_idx=0) + + +def load(): + """ + Load the committee data and returns a Dataset class. + + Returns + ------- + Dataset + A `Dataset` instance with ``data``, ``names``, ``endog``, ``exog``, + ``endog_name`` and ``exog_name`` attributes. + """ + return load_pandas() + + +def _get_data(): + data = du.load_csv(__file__, "committee.csv") + data = data.iloc[:, 1:7].astype(float) + return data diff --git a/shared/package-files/31/3126d9418c15e54e260173f67c1421ef442133bd4dfb5be1ed3e0245112a5688/blob b/shared/package-files/31/3126d9418c15e54e260173f67c1421ef442133bd4dfb5be1ed3e0245112a5688/blob new file mode 100644 index 0000000000000000000000000000000000000000..f1263cdc1b683773c8f3de5140e3087587afdb09 --- /dev/null +++ b/shared/package-files/31/3126d9418c15e54e260173f67c1421ef442133bd4dfb5be1ed3e0245112a5688/blob @@ -0,0 +1,13 @@ +from typing import List, Optional + +__version__ = "23.3.1" + + +def main(args: Optional[List[str]] = None) -> int: + """This is an internal API only meant for use by pip's own console scripts. + + For additional details, see https://github.com/pypa/pip/issues/7498. + """ + from pip._internal.utils.entrypoints import _wrapper + + return _wrapper(args) diff --git a/shared/package-files/31/3128665b40b8771336f009a84a9fa5a3b7030592b6f6de1e0ea4340752614c40/blob b/shared/package-files/31/3128665b40b8771336f009a84a9fa5a3b7030592b6f6de1e0ea4340752614c40/blob new file mode 100644 index 0000000000000000000000000000000000000000..388606ee844763225eb67c9289b069dcd0e84a59 --- /dev/null +++ b/shared/package-files/31/3128665b40b8771336f009a84a9fa5a3b7030592b6f6de1e0ea4340752614c40/blob @@ -0,0 +1,23 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace at { +namespace native { +struct TORCH_API structured_special_erfcx_out : public at::meta::structured_special_erfcx { +void impl(const at::Tensor & self, const at::Tensor & out); +}; +} // namespace native +} // namespace at diff --git a/shared/package-files/31/3128e8e54eca2eeaae82712d5110bcce7a65748dfe70b21f5d094884dbd02c8e/blob b/shared/package-files/31/3128e8e54eca2eeaae82712d5110bcce7a65748dfe70b21f5d094884dbd02c8e/blob new file mode 100644 index 0000000000000000000000000000000000000000..8dfca117a658b2a163ef35699c903ad14a032062 --- /dev/null +++ b/shared/package-files/31/3128e8e54eca2eeaae82712d5110bcce7a65748dfe70b21f5d094884dbd02c8e/blob @@ -0,0 +1,73 @@ +import pytest + +from pandas import ( + Interval, + Timedelta, + Timestamp, +) + + +class TestContains: + def test_contains(self): + interval = Interval(0, 1) + assert 0.5 in interval + assert 1 in interval + assert 0 not in interval + + interval_both = Interval(0, 1, "both") + assert 0 in interval_both + assert 1 in interval_both + + interval_neither = Interval(0, 1, closed="neither") + assert 0 not in interval_neither + assert 0.5 in interval_neither + assert 1 not in interval_neither + + def test_contains_interval(self, inclusive_endpoints_fixture): + interval1 = Interval(0, 1, "both") + interval2 = Interval(0, 1, inclusive_endpoints_fixture) + assert interval1 in interval1 + assert interval2 in interval2 + assert interval2 in interval1 + assert interval1 not in interval2 or inclusive_endpoints_fixture == "both" + + def test_contains_infinite_length(self): + interval1 = Interval(0, 1, "both") + interval2 = Interval(float("-inf"), float("inf"), "neither") + assert interval1 in interval2 + assert interval2 not in interval1 + + def test_contains_zero_length(self): + interval1 = Interval(0, 1, "both") + interval2 = Interval(-1, -1, "both") + interval3 = Interval(0.5, 0.5, "both") + assert interval2 not in interval1 + assert interval3 in interval1 + assert interval2 not in interval3 and interval3 not in interval2 + assert interval1 not in interval2 and interval1 not in interval3 + + @pytest.mark.parametrize( + "type1", + [ + (0, 1), + (Timestamp(2000, 1, 1, 0), Timestamp(2000, 1, 1, 1)), + (Timedelta("0h"), Timedelta("1h")), + ], + ) + @pytest.mark.parametrize( + "type2", + [ + (0, 1), + (Timestamp(2000, 1, 1, 0), Timestamp(2000, 1, 1, 1)), + (Timedelta("0h"), Timedelta("1h")), + ], + ) + def test_contains_mixed_types(self, type1, type2): + interval1 = Interval(*type1) + interval2 = Interval(*type2) + if type1 == type2: + assert interval1 in interval2 + else: + msg = "^'<=' not supported between instances of" + with pytest.raises(TypeError, match=msg): + interval1 in interval2 diff --git a/shared/package-files/31/31297df47816879225aabdff595caec27226f65a009c4d5b3ed7770bafa092fc/blob b/shared/package-files/31/31297df47816879225aabdff595caec27226f65a009c4d5b3ed7770bafa092fc/blob new file mode 100644 index 0000000000000000000000000000000000000000..ca856a13fe23a3e381bce9aa16b07a581827a20a --- /dev/null +++ b/shared/package-files/31/31297df47816879225aabdff595caec27226f65a009c4d5b3ed7770bafa092fc/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API linalg_lu_factor { + using schema = ::std::tuple (const at::Tensor &, bool); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::linalg_lu_factor") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "linalg_lu_factor(Tensor A, *, bool pivot=True) -> (Tensor LU, Tensor pivots)") + static ::std::tuple call(const at::Tensor & A, bool pivot); + static ::std::tuple redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & A, bool pivot); +}; + +struct TORCH_API linalg_lu_factor_out { + using schema = ::std::tuple (const at::Tensor &, bool, at::Tensor &, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::linalg_lu_factor") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "linalg_lu_factor.out(Tensor A, *, bool pivot=True, Tensor(a!) LU, Tensor(b!) pivots) -> (Tensor(a!) LU, Tensor(b!) pivots)") + static ::std::tuple call(const at::Tensor & A, bool pivot, at::Tensor & LU, at::Tensor & pivots); + static ::std::tuple redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & A, bool pivot, at::Tensor & LU, at::Tensor & pivots); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/31/312b35586608b26c989d8b14f6045f1b6830f83cc52e22f0033fd6a61e5c1fcb/blob b/shared/package-files/31/312b35586608b26c989d8b14f6045f1b6830f83cc52e22f0033fd6a61e5c1fcb/blob new file mode 100644 index 0000000000000000000000000000000000000000..6c8c90743107a29e6fb9900173870846ee5ab9a5 --- /dev/null +++ b/shared/package-files/31/312b35586608b26c989d8b14f6045f1b6830f83cc52e22f0033fd6a61e5c1fcb/blob @@ -0,0 +1,83 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API isin_Tensor_Tensor_out { + using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, bool, bool, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::isin") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor_Tensor_out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "isin.Tensor_Tensor_out(Tensor elements, Tensor test_elements, *, bool assume_unique=False, bool invert=False, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & elements, const at::Tensor & test_elements, bool assume_unique, bool invert, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & elements, const at::Tensor & test_elements, bool assume_unique, bool invert, at::Tensor & out); +}; + +struct TORCH_API isin_Tensor_Tensor { + using schema = at::Tensor (const at::Tensor &, const at::Tensor &, bool, bool); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::isin") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor_Tensor") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "isin.Tensor_Tensor(Tensor elements, Tensor test_elements, *, bool assume_unique=False, bool invert=False) -> Tensor") + static at::Tensor call(const at::Tensor & elements, const at::Tensor & test_elements, bool assume_unique, bool invert); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & elements, const at::Tensor & test_elements, bool assume_unique, bool invert); +}; + +struct TORCH_API isin_Tensor_Scalar_out { + using schema = at::Tensor & (const at::Tensor &, const at::Scalar &, bool, bool, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::isin") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor_Scalar_out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "isin.Tensor_Scalar_out(Tensor elements, Scalar test_element, *, bool assume_unique=False, bool invert=False, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & elements, const at::Scalar & test_element, bool assume_unique, bool invert, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & elements, const at::Scalar & test_element, bool assume_unique, bool invert, at::Tensor & out); +}; + +struct TORCH_API isin_Tensor_Scalar { + using schema = at::Tensor (const at::Tensor &, const at::Scalar &, bool, bool); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::isin") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor_Scalar") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "isin.Tensor_Scalar(Tensor elements, Scalar test_element, *, bool assume_unique=False, bool invert=False) -> Tensor") + static at::Tensor call(const at::Tensor & elements, const at::Scalar & test_element, bool assume_unique, bool invert); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & elements, const at::Scalar & test_element, bool assume_unique, bool invert); +}; + +struct TORCH_API isin_Scalar_Tensor_out { + using schema = at::Tensor & (const at::Scalar &, const at::Tensor &, bool, bool, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::isin") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar_Tensor_out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "isin.Scalar_Tensor_out(Scalar element, Tensor test_elements, *, bool assume_unique=False, bool invert=False, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Scalar & element, const at::Tensor & test_elements, bool assume_unique, bool invert, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Scalar & element, const at::Tensor & test_elements, bool assume_unique, bool invert, at::Tensor & out); +}; + +struct TORCH_API isin_Scalar_Tensor { + using schema = at::Tensor (const at::Scalar &, const at::Tensor &, bool, bool); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::isin") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar_Tensor") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "isin.Scalar_Tensor(Scalar element, Tensor test_elements, *, bool assume_unique=False, bool invert=False) -> Tensor") + static at::Tensor call(const at::Scalar & element, const at::Tensor & test_elements, bool assume_unique, bool invert); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Scalar & element, const at::Tensor & test_elements, bool assume_unique, bool invert); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/31/312e3f9f7006ad47f526eb97391e0878480de5d6472ad86c4c84c34f7bfff49b/blob b/shared/package-files/31/312e3f9f7006ad47f526eb97391e0878480de5d6472ad86c4c84c34f7bfff49b/blob new file mode 100644 index 0000000000000000000000000000000000000000..d1dc94e656f5470b9f65a1099a04de06ba52a516 --- /dev/null +++ b/shared/package-files/31/312e3f9f7006ad47f526eb97391e0878480de5d6472ad86c4c84c34f7bfff49b/blob @@ -0,0 +1,116 @@ +from statsmodels.compat.pandas import ( + deprecate_kwarg, + is_float_index, + is_int_index, +) + +import warnings + +import numpy as np +import pandas as pd +import pytest + + +@pytest.mark.parametrize("int_type", ["u", "i"]) +@pytest.mark.parametrize("int_size", [1, 2, 4, 8]) +def test_is_int_index(int_type, int_size): + index = pd.Index(np.arange(100), dtype=f"{int_type}{int_size}") + assert is_int_index(index) + assert not is_float_index(index) + + +@pytest.mark.parametrize("float_size", [4, 8]) +def test_is_float_index(float_size): + index = pd.Index(np.arange(100.0), dtype=f"f{float_size}") + assert is_float_index(index) + assert not is_int_index(index) + + +# Tests for vendored deprecate_kwarg. Adapted directly from: +# pandas/tests/util/test_deprecate_kwarg.py +# (relocated from test_docstring_helpers.py, which does not test this +# module: deprecate_kwarg lives in statsmodels.compat.pandas, not +# statsmodels.tools.docstring_helpers) + + +@deprecate_kwarg(old_arg_name="old", new_arg_name="new") +def _f1(new=False): + return new + + +_f2_mappings = {"yes": True, "no": False} + + +@deprecate_kwarg(old_arg_name="old", new_arg_name="new", mapping=_f2_mappings) +def _f2(new=False): + return new + + +def _f3_mapping(x): + return x + 1 + + +@deprecate_kwarg(old_arg_name="old", new_arg_name="new", mapping=_f3_mapping) +def _f3(new=0): + return new + + +@deprecate_kwarg(old_arg_name="old", new_arg_name=None) +def _f4(old=True, unchanged=True): + return old, unchanged + + +@pytest.mark.parametrize("key,warns", [("old", True), ("new", False)]) +def test_deprecate_kwarg(key, warns): + x = 78 + if warns: + with pytest.warns(FutureWarning): + assert _f1(**{key: x}) == x + else: + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always") + assert _f1(**{key: x}) == x + assert len(w) == 0 + + +@pytest.mark.parametrize("key", list(_f2_mappings.keys())) +def test_dict_deprecate_kwarg(key): + with pytest.warns(FutureWarning): + assert _f2(old=key) == _f2_mappings[key] + + +@pytest.mark.parametrize("key", ["bogus", 12345, -1.23]) +def test_missing_deprecate_kwarg(key): + # keys not in mapping are forwarded unchanged + with pytest.warns(FutureWarning): + assert _f2(old=key) == key + + +@pytest.mark.parametrize("x", [1, -1.4, 0]) +def test_callable_deprecate_kwarg(x): + with pytest.warns(FutureWarning): + assert _f3(old=x) == _f3_mapping(x) + + +def test_bad_deprecate_kwarg(): + msg = "mapping from old to new argument values must be dict or callable!" + with pytest.raises(TypeError, match=msg): + + @deprecate_kwarg("old", "new", mapping=0) + def f4(new=None): + return new + + +@pytest.mark.parametrize("key", ["old", "unchanged"]) +def test_deprecate_keyword(key): + x = 9 + if key == "old": + expected = (x, True) + with pytest.warns(FutureWarning): + assert _f4(**{key: x}) == expected + else: + expected = (True, x) + with warnings.catch_warnings(record=True) as w: + warnings.simplefilter("always") + assert _f4(**{key: x}) == expected + assert len(w) == 0 diff --git a/shared/package-files/31/312e48a8c460bf1c1035268e10fcead33d60080f86e36f64029a81b9b46e3fef/blob b/shared/package-files/31/312e48a8c460bf1c1035268e10fcead33d60080f86e36f64029a81b9b46e3fef/blob new file mode 100644 index 0000000000000000000000000000000000000000..dec149d6e6d0c7195bf785f54bf8433e3a752d09 --- /dev/null +++ b/shared/package-files/31/312e48a8c460bf1c1035268e10fcead33d60080f86e36f64029a81b9b46e3fef/blob @@ -0,0 +1,91 @@ +# This module provides functions for reading and writing the +# anonymous token set. It has been designed to rely only on the +# Python standard library. In particular, hard dependencies on +# conda must be avoided so that this package can be used in +# child environments. + +import sys +from collections import namedtuple +from os.path import expanduser, join + +from . import __version__ +from .utils import _debug, _random_token, _saved_token, cached + +Tokens = namedtuple("Tokens", ("version", "client", "session", "environment")) +CONFIG_DIR = expanduser("~/.conda") + + +@cached +def version_token(): + """ + Returns the version token, which is just the + version string itself. + """ + return __version__ + + +@cached +def client_token(): + """ + Returns the client token. If a token has not yet + been generated, an attempt is made to do so. If + that fails, an empty string is returned. + """ + fpath = join(CONFIG_DIR, "aau_token") + return _saved_token(fpath, "client") + + +@cached +def session_token(): + """ + Returns the session token, generated randomly for each + execution of the process. + """ + return _random_token("session") + + +@cached +def environment_token(prefix=None): + """ + Returns the environment token for the given prefix, or + sys.prefix if one is not supplied. If a token has not + yet been generated, an attempt is made to do so. If that + fails, an empty string is returned. + """ + if prefix is None: + prefix = sys.prefix + fpath = join(prefix, "etc", "aau_token") + return _saved_token(fpath, "environment", prefix) + + +@cached +def all_tokens(prefix=None): + """ + Returns the token set, in the form of a Tokens namedtuple. + Fields: version, client, session, environment + """ + return Tokens( + version_token(), client_token(), session_token(), environment_token(prefix) + ) + + +@cached +def token_string(prefix=None, enabled=True): + """ + Returns the token set, formatted into the string that is + appended to the conda user agent. + """ + parts = ["aau/" + __version__] + if enabled: + values = all_tokens(prefix) + if values.client: + parts.append("c/" + values.client) + if values.session: + parts.append("s/" + values.session) + if values.environment: + parts.append("e/" + values.environment) + else: + _debug("anaconda_anon_usage disabled by config") + result = " ".join(parts) + _debug("Full client token: %s", result) + return result diff --git a/shared/package-files/31/3130f1254158dc5bd819ea3ae7088a8d4f416c3ced129e9b9def0c717f611d02/blob b/shared/package-files/31/3130f1254158dc5bd819ea3ae7088a8d4f416c3ced129e9b9def0c717f611d02/blob new file mode 100644 index 0000000000000000000000000000000000000000..8de166c470fbde219ea24df9d9e8f4bd8628d0db Binary files /dev/null and b/shared/package-files/31/3130f1254158dc5bd819ea3ae7088a8d4f416c3ced129e9b9def0c717f611d02/blob differ diff --git a/shared/package-files/31/313155871a785156a917ef7f5b2710ae42ce2679b6f33fb63645b56d121a24d4/blob b/shared/package-files/31/313155871a785156a917ef7f5b2710ae42ce2679b6f33fb63645b56d121a24d4/blob new file mode 100644 index 0000000000000000000000000000000000000000..4b2ff3c676b3d7b35485ace2b37c1545b6a66381 --- /dev/null +++ b/shared/package-files/31/313155871a785156a917ef7f5b2710ae42ce2679b6f33fb63645b56d121a24d4/blob @@ -0,0 +1,109 @@ +#pragma once + +#include +#include +#include +#include +#include + +#include +#include + +namespace torch { +namespace serialize { +class OutputArchive; +class InputArchive; +} // namespace serialize +} // namespace torch + +namespace torch { +namespace optim { + +struct TORCH_API AdagradOptions + : public OptimizerCloneableOptions { + AdagradOptions(double lr = 1e-2); + TORCH_ARG(double, lr) = 1e-2; + TORCH_ARG(double, lr_decay) = 0; + TORCH_ARG(double, weight_decay) = 0; + TORCH_ARG(double, initial_accumulator_value) = 0; + TORCH_ARG(double, eps) = 1e-10; + + public: + void serialize(torch::serialize::InputArchive& archive) override; + void serialize(torch::serialize::OutputArchive& archive) const override; + TORCH_API friend bool operator==( + const AdagradOptions& lhs, + const AdagradOptions& rhs); + double get_lr() const override; + void set_lr(const double lr) override; +}; + +struct TORCH_API AdagradParamState + : public OptimizerCloneableParamState { + TORCH_ARG(torch::Tensor, sum); + TORCH_ARG(int64_t, step) = 0; + + public: + AdagradParamState() = default; + AdagradParamState(const AdagradParamState&) = default; + AdagradParamState& operator=(const AdagradParamState&) = default; + AdagradParamState(AdagradParamState&&) noexcept = default; + AdagradParamState& operator=(AdagradParamState&&) noexcept = default; + void serialize(torch::serialize::InputArchive& archive) override; + void serialize(torch::serialize::OutputArchive& archive) const override; + TORCH_API friend bool operator==( + const AdagradParamState& lhs, + const AdagradParamState& rhs); +}; + +class TORCH_API Adagrad : public Optimizer { + public: + explicit Adagrad( + std::vector param_groups, + AdagradOptions defaults = {}) + : Optimizer( + std::move(param_groups), + std::make_unique(defaults)) { + TORCH_CHECK(defaults.lr() >= 0, "Invalid learning rate: ", defaults.lr()); + TORCH_CHECK( + defaults.lr_decay() >= 0, + "Invalid lr_decay value: ", + defaults.lr_decay()); + TORCH_CHECK( + defaults.weight_decay() >= 0, + "Invalid weight_decay value: ", + defaults.weight_decay()); + TORCH_CHECK( + defaults.initial_accumulator_value() >= 0, + "Invalid initial_accumulator_value value: ", + defaults.initial_accumulator_value()); + TORCH_CHECK(defaults.eps() >= 0, "Invalid epsilon value: ", defaults.eps()); + + for (const auto& group : param_groups_) { + for (const auto& p : group.params()) { + auto state = std::make_unique(); + state->step(0); + state->sum(torch::full_like( + p.data(), + defaults.initial_accumulator_value(), + at::MemoryFormat::Preserve)); + state_[p.unsafeGetTensorImpl()] = std::move(state); + } + } + } + + explicit Adagrad(std::vector params, AdagradOptions defaults = {}) + : Adagrad({OptimizerParamGroup(std::move(params))}, defaults) {} + + torch::Tensor step(LossClosure closure = nullptr) override; + void save(serialize::OutputArchive& archive) const override; + void load(serialize::InputArchive& archive) override; + + private: + template + static void serialize(Self& self, Archive& archive) { + _TORCH_OPTIM_SERIALIZE_WITH_TEMPLATE_ARG(Adagrad); + } +}; +} // namespace optim +} // namespace torch diff --git a/shared/package-files/31/31319e9fed604242e530d22478ba28b1211fdcd6b8c0df4371af4a271eedf170/blob b/shared/package-files/31/31319e9fed604242e530d22478ba28b1211fdcd6b8c0df4371af4a271eedf170/blob new file mode 100644 index 0000000000000000000000000000000000000000..caa3549b1f9d2062ff0e97e7a4ee9b3857451110 --- /dev/null +++ b/shared/package-files/31/31319e9fed604242e530d22478ba28b1211fdcd6b8c0df4371af4a271eedf170/blob @@ -0,0 +1,328 @@ +import functools +import os +from itertools import chain, count +from typing import Any, List, Optional, TYPE_CHECKING + +import sympy + +from torch._inductor.codecache import get_cpp_wrapper_cubin_path_name + +from .. import config +from ..codecache import CudaKernelParamCache +from ..triton_heuristics import grid as default_grid +from ..virtualized import V +from .cpp_wrapper_cpu import CppWrapperCpu +from .wrapper import SymbolicCallArg + +if TYPE_CHECKING: + from ..graph import GraphLowering + + +def is_int(s: str) -> bool: + # Cpp code gen adds L at the end of ints + # Lets remove it for checking whether we have an int or not + if s and s[-1] == "L": + s = s[:-1] + try: + int(s) + except ValueError: + return False + except TypeError: + return False + return True + + +def is_float(s: str) -> bool: + try: + float(s) + except ValueError: + return False + return True + + +class CppWrapperCuda(CppWrapperCpu): + """ + Generates cpp wrapper for running on GPU and calls CUDA kernels + """ + + def __init__(self): + self.device = "cuda" + super().__init__() + self.grid_id = count() + self.cuda = True + + def write_header(self): + if V.graph.is_const_graph: + # We do not write header for constant graph, it will be written by main module. + return + + super().write_header() + + self.header.splice("#include ") + if config.abi_compatible: + self.header.splice( + "#include " + ) + else: + self.header.splice( + """ + #include + #include + #include + """ + ) + + self.header.splice( + """ + #define CUDA_DRIVER_CHECK(EXPR) \\ + do { \\ + CUresult code = EXPR; \\ + const char *msg; \\ + cuGetErrorString(code, &msg); \\ + if (code != CUDA_SUCCESS) { \\ + throw std::runtime_error( \\ + std::string("CUDA driver error: ") + \\ + std::string(msg)); \\ + } \\ + } while (0); + + namespace { + + struct Grid { + Grid(uint32_t x, uint32_t y, uint32_t z) + : grid_x(x), grid_y(y), grid_z(z) {} + uint32_t grid_x; + uint32_t grid_y; + uint32_t grid_z; + + bool is_non_zero() { + return grid_x > 0 && grid_y > 0 && grid_z > 0; + } + }; + + } // anonymous namespace + + static inline CUfunction loadKernel( + std::string filePath, + const std::string &funcName, + uint32_t sharedMemBytes, + const std::optional &cubinDir = std::nullopt) { + if (cubinDir) { + std::filesystem::path p1{*cubinDir}; + std::filesystem::path p2{filePath}; + filePath = (p1 / p2.filename()).string(); + } + + CUmodule mod; + CUfunction func; + CUDA_DRIVER_CHECK(cuModuleLoad(&mod, filePath.c_str())); + CUDA_DRIVER_CHECK(cuModuleGetFunction(&func, mod, funcName.c_str())); + if (sharedMemBytes > 0) { + CUDA_DRIVER_CHECK(cuFuncSetAttribute( + func, + CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES, + sharedMemBytes + )) + } + return func; + } + + static inline void launchKernel( + CUfunction func, + uint32_t gridX, + uint32_t gridY, + uint32_t gridZ, + uint32_t numWarps, + uint32_t sharedMemBytes, + void* args[], + cudaStream_t stream) { + CUDA_DRIVER_CHECK(cuLaunchKernel( + func, gridX, gridY, gridZ, 32*numWarps, 1, 1, sharedMemBytes, stream, args, nullptr + )); + } + """ + ) + + def write_get_raw_stream(self, index, graph=None): + name = f"stream{index}" + self.writeline(f"cudaStream_t {name};") + self.writeline( + f"AOTI_TORCH_ERROR_CODE_CHECK(aoti_torch_get_current_cuda_stream({index}, (void**)&{name}));" + ) + return name + + def define_kernel( + self, name: str, kernel: str, metadata: Optional[str] = None, cuda=True + ): + if not cuda: + return super().define_kernel(name, kernel, metadata, cuda) + + def generate(self, is_inference): + self.prefix.writeline("\n") + if not V.graph.aot_mode: + for kernel in chain( + self.src_to_kernel.values(), + [entry[0] for entry in self.user_defined_kernel_cache.values()], + ): + self.prefix.writeline(f"static CUfunction {kernel} = nullptr;") + self.prefix.writeline("\n") + return super().generate(is_inference) + + @functools.lru_cache(None) + def generate_load_kernel_once( + self, + name: str, + mangled_name: str, + cubin_path: str, + shared_mem: int, + graph: "GraphLowering", # for per-graph caching + ): + if V.graph.aot_mode: + self.writeline(f"if (kernels.{name} == nullptr) {{") + self.writeline( + f""" kernels.{name} = loadKernel("{cubin_path}", "{mangled_name}", {shared_mem}, this->cubin_dir_);""" + ) + self.writeline("}") + else: + self.writeline(f"if ({name} == nullptr) {{") + self.writeline( + f""" {name} = loadKernel("{cubin_path}", "{mangled_name}", {shared_mem});""" + ) + self.writeline("}") + + def generate_args_decl(self, call_args): + dynamic_symbols = V.graph.sizevars.free_symbols() + # TODO: only works for constant now, need type info + new_args = [] + for arg in call_args: + var_name = f"var_{next(self.arg_var_id)}" + if isinstance(arg, (sympy.Integer, sympy.Symbol, SymbolicCallArg)): + self.writeline(f"auto {var_name} = {arg};") + elif isinstance(arg, sympy.Expr): + self.writeline(f"auto {var_name} = {self.expr_printer(arg)};") + elif is_int(arg): + self.writeline(f"int {var_name} = {arg};") + elif is_float(arg): + self.writeline(f"float {var_name} = {arg};") + elif any(str(arg) == s.name for s in dynamic_symbols): + self.writeline(f"auto {var_name} = {arg};") + elif arg == "nullptr": + self.writeline(f"auto {var_name} = nullptr;") + elif arg == "c10::nullopt": + self.writeline(f"auto {var_name} = c10::nullopt;") + else: + if config.abi_compatible: + self.writeline(f"CUdeviceptr {var_name};") + self.writeline( + f"AOTI_TORCH_ERROR_CODE_CHECK(aoti_torch_get_data_ptr({arg}, reinterpret_cast(&{var_name})));" + ) + else: + self.writeline( + f"CUdeviceptr {var_name} = reinterpret_cast({arg}.data_ptr());" + ) + new_args.append(f"&{var_name}") + + return ", ".join(new_args) + + def generate_default_grid(self, name: str, grid: List[Any], cuda: bool = True): + """ + Generate grid configs for launching a CUDA kernel using the grid + function from triton_heuristics. + """ + if not cuda: + return grid + assert isinstance(grid, list), f"expected {grid=} to be a list" + grid = [e.inner_expr if isinstance(e, SymbolicCallArg) else e for e in grid] + grid_fn = default_grid(*grid) + params = CudaKernelParamCache.get(name) + assert ( + params is not None + ), f"cuda kernel parameters for {name} should already exist at this moment, only found {CudaKernelParamCache.get_keys()}" + block_cfg = { + "XBLOCK": params["x_block"], + "YBLOCK": params["y_block"], + "ZBLOCK": params["z_block"], + } + return grid_fn(block_cfg) + + def generate_kernel_call( + self, + name, + call_args, + grid=None, + device_index=None, + cuda=True, + triton=True, + arg_types=None, + grid_fn: str = "grid", + triton_meta=None, + ): + if not cuda: + # Even in CppWrapperCuda, we may see cpp kernels + return super().generate_kernel_call( + name, call_args, grid, device_index, cuda, triton, arg_types + ) + + params = CudaKernelParamCache.get(name) + assert ( + params is not None + ), f"cuda kernel parameters for {name} should already exist at this moment" + mangled_name = params.get("mangled_name", None) + assert mangled_name is not None, "missing mangled_name" + cubin_path = params.get(get_cpp_wrapper_cubin_path_name(), None) + assert cubin_path is not None and os.path.exists( + cubin_path + ), f"cubin file should already exist at this moment: {cubin_path}" + shared_mem = params.get("shared_mem", 0) + + self.generate_load_kernel_once( + name, mangled_name, cubin_path, shared_mem, V.graph + ) + + # args with value 1 are added into equal_to_1 and constants + # in triton_meta (in the Python codegen) which makes them + # inlined in the PTX and compiled CUBIN + if ( + triton_meta is not None + and "configs" in triton_meta + and triton_meta["configs"] + ): + equal_to_1 = triton_meta["configs"][0].equal_to_1 + call_args = [arg for i, arg in enumerate(call_args) if i not in equal_to_1] + + call_args = self.generate_args_decl(call_args) + kernel_args_var = f"kernel_args_var_{next(self.kernel_callsite_id)}" + self.writeline(f"void* {kernel_args_var}[] = {{{call_args}}};") + stream = ( + "stream" + if V.graph.aot_mode + else self.write_get_raw_stream(device_index, V.graph) + ) + grid_name = f"{name}_grid_{next(self.grid_id)}" + assert isinstance( + grid, (list, tuple) + ), f"expected grid to be a list or tuple but got: {grid=}" + + grid = [V.graph.sizevars.simplify(item) for item in grid] + grid_uses_symbolic_shapes = any(item.free_symbols for item in grid) + grid_args = [self.grid_expr_printer(item) for item in grid] + grid_args_str = ", ".join(grid_args) + self.writeline(f"Grid {grid_name} = Grid({grid_args_str});") + + if grid_uses_symbolic_shapes: + self.writeline(f"if ({grid_name}.is_non_zero()) {{") + kernel_var_name = f"kernels.{name}" if V.graph.aot_mode else name + self.writeline( + "launchKernel({}, {}, {}, {}, {}, {}, {}, {});".format( + kernel_var_name, + f"{grid_name}.grid_x", + f"{grid_name}.grid_y", + f"{grid_name}.grid_z", + params["num_warps"], + params["shared_mem"], + kernel_args_var, + stream, + ) + ) + if grid_uses_symbolic_shapes: + self.writeline("}") diff --git a/shared/package-files/31/3132540d06df28ff08afbd341686e5ef171b8d7ed672bb145789b115795fc27d/blob b/shared/package-files/31/3132540d06df28ff08afbd341686e5ef171b8d7ed672bb145789b115795fc27d/blob new file mode 100644 index 0000000000000000000000000000000000000000..722e947bfeca238af0bd6ee002e7f3f9f1063ed6 --- /dev/null +++ b/shared/package-files/31/3132540d06df28ff08afbd341686e5ef171b8d7ed672bb145789b115795fc27d/blob @@ -0,0 +1,50 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you 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. + +# distutils: language = c++ + +from pyarrow.includes.libarrow cimport (CCompressionType, CStatus, CTable, + COutputStream, CResult, shared_ptr, + vector, CRandomAccessFile, CSchema, + c_string, CIpcReadOptions) + + +cdef extern from "arrow/ipc/api.h" namespace "arrow::ipc" nogil: + int kFeatherV1Version" arrow::ipc::feather::kFeatherV1Version" + int kFeatherV2Version" arrow::ipc::feather::kFeatherV2Version" + + cdef cppclass CFeatherProperties" arrow::ipc::feather::WriteProperties": + int version + int chunksize + CCompressionType compression + int compression_level + + CStatus WriteFeather" arrow::ipc::feather::WriteTable" \ + (const CTable& table, COutputStream* out, + CFeatherProperties properties) + + cdef cppclass CFeatherReader" arrow::ipc::feather::Reader": + @staticmethod + CResult[shared_ptr[CFeatherReader]] Open( + const shared_ptr[CRandomAccessFile]& file, + const CIpcReadOptions& options) + int version() + shared_ptr[CSchema] schema() + + CStatus Read(shared_ptr[CTable]* out) + CStatus Read(const vector[int] indices, shared_ptr[CTable]* out) + CStatus Read(const vector[c_string] names, shared_ptr[CTable]* out) diff --git a/shared/package-files/31/3132d1279617fd3c9de8ca1e68e37eab31df7e274538c66041aba630deba470b/blob b/shared/package-files/31/3132d1279617fd3c9de8ca1e68e37eab31df7e274538c66041aba630deba470b/blob new file mode 100644 index 0000000000000000000000000000000000000000..9b907eb69905ac0dcdc2aa70c2145b2aa172a742 --- /dev/null +++ b/shared/package-files/31/3132d1279617fd3c9de8ca1e68e37eab31df7e274538c66041aba630deba470b/blob @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: setuptools (84.0.0) +Root-Is-Purelib: false +Tag: cp310-cp310-manylinux_2_27_x86_64 +Tag: cp310-cp310-manylinux_2_28_x86_64 + diff --git a/shared/package-files/31/3136a1cc70ecc06e7d79878d6c4c0a3f5ea9918e03576176337466f990ea9962/blob b/shared/package-files/31/3136a1cc70ecc06e7d79878d6c4c0a3f5ea9918e03576176337466f990ea9962/blob new file mode 100644 index 0000000000000000000000000000000000000000..e70197dc469ff0b53b3b3b98e6bf7f29a3b5d091 --- /dev/null +++ b/shared/package-files/31/3136a1cc70ecc06e7d79878d6c4c0a3f5ea9918e03576176337466f990ea9962/blob @@ -0,0 +1,605 @@ +""" + pygments.lexers.html + ~~~~~~~~~~~~~~~~~~~~ + + Lexers for HTML, XML and related markup. + + :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS. + :license: BSD, see LICENSE for details. +""" + +import re + +from pygments.lexer import RegexLexer, ExtendedRegexLexer, include, bygroups, \ + default, using +from pygments.token import Text, Comment, Operator, Keyword, Name, String, \ + Punctuation, Whitespace +from pygments.util import looks_like_xml, html_doctype_matches + +from pygments.lexers.javascript import JavascriptLexer +from pygments.lexers.jvm import ScalaLexer +from pygments.lexers.css import CssLexer, _indentation, _starts_block +from pygments.lexers.ruby import RubyLexer + +__all__ = ['HtmlLexer', 'DtdLexer', 'XmlLexer', 'XsltLexer', 'HamlLexer', + 'ScamlLexer', 'PugLexer'] + + +class HtmlLexer(RegexLexer): + """ + For HTML 4 and XHTML 1 markup. Nested JavaScript and CSS is highlighted + by the appropriate lexer. + """ + + name = 'HTML' + url = 'https://html.spec.whatwg.org/' + aliases = ['html'] + filenames = ['*.html', '*.htm', '*.xhtml', '*.xslt'] + mimetypes = ['text/html', 'application/xhtml+xml'] + + flags = re.IGNORECASE | re.DOTALL + tokens = { + 'root': [ + ('[^<&]+', Text), + (r'&\S*?;', Name.Entity), + (r'\<\!\[CDATA\[.*?\]\]\>', Comment.Preproc), + (r'', Comment.Multiline), + (r'<\?.*?\?>', Comment.Preproc), + (']*>', Comment.Preproc), + (r'(<)(\s*)(script)(\s*)', + bygroups(Punctuation, Text, Name.Tag, Text), + ('script-content', 'tag')), + (r'(<)(\s*)(style)(\s*)', + bygroups(Punctuation, Text, Name.Tag, Text), + ('style-content', 'tag')), + # note: this allows tag names not used in HTML like , + # this is to support yet-unknown template engines and the like + (r'(<)(\s*)([\w:.-]+)', + bygroups(Punctuation, Text, Name.Tag), 'tag'), + (r'(<)(\s*)(/)(\s*)([\w:.-]+)(\s*)(>)', + bygroups(Punctuation, Text, Punctuation, Text, Name.Tag, Text, + Punctuation)), + ], + 'tag': [ + (r'\s+', Text), + (r'([\w:-]+\s*)(=)(\s*)', bygroups(Name.Attribute, Operator, Text), + 'attr'), + (r'[\w:-]+', Name.Attribute), + (r'(/?)(\s*)(>)', bygroups(Punctuation, Text, Punctuation), '#pop'), + ], + 'script-content': [ + (r'(<)(\s*)(/)(\s*)(script)(\s*)(>)', + bygroups(Punctuation, Text, Punctuation, Text, Name.Tag, Text, + Punctuation), '#pop'), + (r'.+?(?=<\s*/\s*script\s*>)', using(JavascriptLexer)), + # fallback cases for when there is no closing script tag + # first look for newline and then go back into root state + # if that fails just read the rest of the file + # this is similar to the error handling logic in lexer.py + (r'.+?\n', using(JavascriptLexer), '#pop'), + (r'.+', using(JavascriptLexer), '#pop'), + ], + 'style-content': [ + (r'(<)(\s*)(/)(\s*)(style)(\s*)(>)', + bygroups(Punctuation, Text, Punctuation, Text, Name.Tag, Text, + Punctuation),'#pop'), + (r'.+?(?=<\s*/\s*style\s*>)', using(CssLexer)), + # fallback cases for when there is no closing style tag + # first look for newline and then go back into root state + # if that fails just read the rest of the file + # this is similar to the error handling logic in lexer.py + (r'.+?\n', using(CssLexer), '#pop'), + (r'.+', using(CssLexer), '#pop'), + ], + 'attr': [ + ('".*?"', String, '#pop'), + ("'.*?'", String, '#pop'), + (r'[^\s>]+', String, '#pop'), + ], + } + + def analyse_text(text): + if html_doctype_matches(text): + return 0.5 + + +class DtdLexer(RegexLexer): + """ + A lexer for DTDs (Document Type Definitions). + + .. versionadded:: 1.5 + """ + + flags = re.MULTILINE | re.DOTALL + + name = 'DTD' + aliases = ['dtd'] + filenames = ['*.dtd'] + mimetypes = ['application/xml-dtd'] + + tokens = { + 'root': [ + include('common'), + + (r'(\s]+)', + bygroups(Keyword, Text, Name.Tag)), + (r'PUBLIC|SYSTEM', Keyword.Constant), + (r'[\[\]>]', Keyword), + ], + + 'common': [ + (r'\s+', Text), + (r'(%|&)[^;]*;', Name.Entity), + ('', Comment, '#pop'), + ('-', Comment), + ], + + 'element': [ + include('common'), + (r'EMPTY|ANY|#PCDATA', Keyword.Constant), + (r'[^>\s|()?+*,]+', Name.Tag), + (r'>', Keyword, '#pop'), + ], + + 'attlist': [ + include('common'), + (r'CDATA|IDREFS|IDREF|ID|NMTOKENS|NMTOKEN|ENTITIES|ENTITY|NOTATION', + Keyword.Constant), + (r'#REQUIRED|#IMPLIED|#FIXED', Keyword.Constant), + (r'xml:space|xml:lang', Keyword.Reserved), + (r'[^>\s|()?+*,]+', Name.Attribute), + (r'>', Keyword, '#pop'), + ], + + 'entity': [ + include('common'), + (r'SYSTEM|PUBLIC|NDATA', Keyword.Constant), + (r'[^>\s|()?+*,]+', Name.Entity), + (r'>', Keyword, '#pop'), + ], + + 'notation': [ + include('common'), + (r'SYSTEM|PUBLIC', Keyword.Constant), + (r'[^>\s|()?+*,]+', Name.Attribute), + (r'>', Keyword, '#pop'), + ], + } + + def analyse_text(text): + if not looks_like_xml(text) and \ + ('', Comment.Preproc), + (r'', Comment.Multiline), + (r'<\?.*?\?>', Comment.Preproc), + (']*>', Comment.Preproc), + (r'<\s*[\w:.-]+', Name.Tag, 'tag'), + (r'<\s*/\s*[\w:.-]+\s*>', Name.Tag), + ], + 'tag': [ + (r'\s+', Whitespace), + (r'[\w.:-]+\s*=', Name.Attribute, 'attr'), + (r'/?\s*>', Name.Tag, '#pop'), + ], + 'attr': [ + (r'\s+', Whitespace), + ('".*?"', String, '#pop'), + ("'.*?'", String, '#pop'), + (r'[^\s>]+', String, '#pop'), + ], + } + + def analyse_text(text): + if looks_like_xml(text): + return 0.45 # less than HTML + + +class XsltLexer(XmlLexer): + """ + A lexer for XSLT. + + .. versionadded:: 0.10 + """ + + name = 'XSLT' + aliases = ['xslt'] + filenames = ['*.xsl', '*.xslt', '*.xpl'] # xpl is XProc + mimetypes = ['application/xsl+xml', 'application/xslt+xml'] + + EXTRA_KEYWORDS = { + 'apply-imports', 'apply-templates', 'attribute', + 'attribute-set', 'call-template', 'choose', 'comment', + 'copy', 'copy-of', 'decimal-format', 'element', 'fallback', + 'for-each', 'if', 'import', 'include', 'key', 'message', + 'namespace-alias', 'number', 'otherwise', 'output', 'param', + 'preserve-space', 'processing-instruction', 'sort', + 'strip-space', 'stylesheet', 'template', 'text', 'transform', + 'value-of', 'variable', 'when', 'with-param' + } + + def get_tokens_unprocessed(self, text): + for index, token, value in XmlLexer.get_tokens_unprocessed(self, text): + m = re.match(']*)/?>?', value) + + if token is Name.Tag and m and m.group(1) in self.EXTRA_KEYWORDS: + yield index, Keyword, value + else: + yield index, token, value + + def analyse_text(text): + if looks_like_xml(text) and ']{1,2}(?=[ \t=])', Punctuation), + include('eval-or-plain'), + ], + + 'plain': [ + (r'([^#\n]|#[^{\n]|(\\\\)*\\#\{)+', Text), + (r'(#\{)(' + _dot + r'*?)(\})', + bygroups(String.Interpol, using(RubyLexer), String.Interpol)), + (r'\n', Text, 'root'), + ], + + 'html-attributes': [ + (r'\s+', Text), + (r'[\w:-]+[ \t]*=', Name.Attribute, 'html-attribute-value'), + (r'[\w:-]+', Name.Attribute), + (r'\)', Text, '#pop'), + ], + + 'html-attribute-value': [ + (r'[ \t]+', Text), + (r'\w+', Name.Variable, '#pop'), + (r'@\w+', Name.Variable.Instance, '#pop'), + (r'\$\w+', Name.Variable.Global, '#pop'), + (r"'(\\\\|\\[^\\]|[^'\\\n])*'", String, '#pop'), + (r'"(\\\\|\\[^\\]|[^"\\\n])*"', String, '#pop'), + ], + + 'html-comment-block': [ + (_dot + '+', Comment), + (r'\n', Text, 'root'), + ], + + 'haml-comment-block': [ + (_dot + '+', Comment.Preproc), + (r'\n', Text, 'root'), + ], + + 'filter-block': [ + (r'([^#\n]|#[^{\n]|(\\\\)*\\#\{)+', Name.Decorator), + (r'(#\{)(' + _dot + r'*?)(\})', + bygroups(String.Interpol, using(RubyLexer), String.Interpol)), + (r'\n', Text, 'root'), + ], + } + + +class ScamlLexer(ExtendedRegexLexer): + """ + For `Scaml markup `_. Scaml is Haml for Scala. + + .. versionadded:: 1.4 + """ + + name = 'Scaml' + aliases = ['scaml'] + filenames = ['*.scaml'] + mimetypes = ['text/x-scaml'] + + flags = re.IGNORECASE + # Scaml does not yet support the " |\n" notation to + # wrap long lines. Once it does, use the custom faux + # dot instead. + # _dot = r'(?: \|\n(?=.* \|)|.)' + _dot = r'.' + + tokens = { + 'root': [ + (r'[ \t]*\n', Text), + (r'[ \t]*', _indentation), + ], + + 'css': [ + (r'\.[\w:-]+', Name.Class, 'tag'), + (r'\#[\w:-]+', Name.Function, 'tag'), + ], + + 'eval-or-plain': [ + (r'[&!]?==', Punctuation, 'plain'), + (r'([&!]?[=~])(' + _dot + r'*\n)', + bygroups(Punctuation, using(ScalaLexer)), + 'root'), + default('plain'), + ], + + 'content': [ + include('css'), + (r'%[\w:-]+', Name.Tag, 'tag'), + (r'!!!' + _dot + r'*\n', Name.Namespace, '#pop'), + (r'(/)(\[' + _dot + r'*?\])(' + _dot + r'*\n)', + bygroups(Comment, Comment.Special, Comment), + '#pop'), + (r'/' + _dot + r'*\n', _starts_block(Comment, 'html-comment-block'), + '#pop'), + (r'-#' + _dot + r'*\n', _starts_block(Comment.Preproc, + 'scaml-comment-block'), '#pop'), + (r'(-@\s*)(import)?(' + _dot + r'*\n)', + bygroups(Punctuation, Keyword, using(ScalaLexer)), + '#pop'), + (r'(-)(' + _dot + r'*\n)', + bygroups(Punctuation, using(ScalaLexer)), + '#pop'), + (r':' + _dot + r'*\n', _starts_block(Name.Decorator, 'filter-block'), + '#pop'), + include('eval-or-plain'), + ], + + 'tag': [ + include('css'), + (r'\{(,\n|' + _dot + r')*?\}', using(ScalaLexer)), + (r'\[' + _dot + r'*?\]', using(ScalaLexer)), + (r'\(', Text, 'html-attributes'), + (r'/[ \t]*\n', Punctuation, '#pop:2'), + (r'[<>]{1,2}(?=[ \t=])', Punctuation), + include('eval-or-plain'), + ], + + 'plain': [ + (r'([^#\n]|#[^{\n]|(\\\\)*\\#\{)+', Text), + (r'(#\{)(' + _dot + r'*?)(\})', + bygroups(String.Interpol, using(ScalaLexer), String.Interpol)), + (r'\n', Text, 'root'), + ], + + 'html-attributes': [ + (r'\s+', Text), + (r'[\w:-]+[ \t]*=', Name.Attribute, 'html-attribute-value'), + (r'[\w:-]+', Name.Attribute), + (r'\)', Text, '#pop'), + ], + + 'html-attribute-value': [ + (r'[ \t]+', Text), + (r'\w+', Name.Variable, '#pop'), + (r'@\w+', Name.Variable.Instance, '#pop'), + (r'\$\w+', Name.Variable.Global, '#pop'), + (r"'(\\\\|\\[^\\]|[^'\\\n])*'", String, '#pop'), + (r'"(\\\\|\\[^\\]|[^"\\\n])*"', String, '#pop'), + ], + + 'html-comment-block': [ + (_dot + '+', Comment), + (r'\n', Text, 'root'), + ], + + 'scaml-comment-block': [ + (_dot + '+', Comment.Preproc), + (r'\n', Text, 'root'), + ], + + 'filter-block': [ + (r'([^#\n]|#[^{\n]|(\\\\)*\\#\{)+', Name.Decorator), + (r'(#\{)(' + _dot + r'*?)(\})', + bygroups(String.Interpol, using(ScalaLexer), String.Interpol)), + (r'\n', Text, 'root'), + ], + } + + +class PugLexer(ExtendedRegexLexer): + """ + For Pug markup. + Pug is a variant of Scaml, see: + http://scalate.fusesource.org/documentation/scaml-reference.html + + .. versionadded:: 1.4 + """ + + name = 'Pug' + aliases = ['pug', 'jade'] + filenames = ['*.pug', '*.jade'] + mimetypes = ['text/x-pug', 'text/x-jade'] + + flags = re.IGNORECASE + _dot = r'.' + + tokens = { + 'root': [ + (r'[ \t]*\n', Text), + (r'[ \t]*', _indentation), + ], + + 'css': [ + (r'\.[\w:-]+', Name.Class, 'tag'), + (r'\#[\w:-]+', Name.Function, 'tag'), + ], + + 'eval-or-plain': [ + (r'[&!]?==', Punctuation, 'plain'), + (r'([&!]?[=~])(' + _dot + r'*\n)', + bygroups(Punctuation, using(ScalaLexer)), 'root'), + default('plain'), + ], + + 'content': [ + include('css'), + (r'!!!' + _dot + r'*\n', Name.Namespace, '#pop'), + (r'(/)(\[' + _dot + r'*?\])(' + _dot + r'*\n)', + bygroups(Comment, Comment.Special, Comment), + '#pop'), + (r'/' + _dot + r'*\n', _starts_block(Comment, 'html-comment-block'), + '#pop'), + (r'-#' + _dot + r'*\n', _starts_block(Comment.Preproc, + 'scaml-comment-block'), '#pop'), + (r'(-@\s*)(import)?(' + _dot + r'*\n)', + bygroups(Punctuation, Keyword, using(ScalaLexer)), + '#pop'), + (r'(-)(' + _dot + r'*\n)', + bygroups(Punctuation, using(ScalaLexer)), + '#pop'), + (r':' + _dot + r'*\n', _starts_block(Name.Decorator, 'filter-block'), + '#pop'), + (r'[\w:-]+', Name.Tag, 'tag'), + (r'\|', Text, 'eval-or-plain'), + ], + + 'tag': [ + include('css'), + (r'\{(,\n|' + _dot + r')*?\}', using(ScalaLexer)), + (r'\[' + _dot + r'*?\]', using(ScalaLexer)), + (r'\(', Text, 'html-attributes'), + (r'/[ \t]*\n', Punctuation, '#pop:2'), + (r'[<>]{1,2}(?=[ \t=])', Punctuation), + include('eval-or-plain'), + ], + + 'plain': [ + (r'([^#\n]|#[^{\n]|(\\\\)*\\#\{)+', Text), + (r'(#\{)(' + _dot + r'*?)(\})', + bygroups(String.Interpol, using(ScalaLexer), String.Interpol)), + (r'\n', Text, 'root'), + ], + + 'html-attributes': [ + (r'\s+', Text), + (r'[\w:-]+[ \t]*=', Name.Attribute, 'html-attribute-value'), + (r'[\w:-]+', Name.Attribute), + (r'\)', Text, '#pop'), + ], + + 'html-attribute-value': [ + (r'[ \t]+', Text), + (r'\w+', Name.Variable, '#pop'), + (r'@\w+', Name.Variable.Instance, '#pop'), + (r'\$\w+', Name.Variable.Global, '#pop'), + (r"'(\\\\|\\[^\\]|[^'\\\n])*'", String, '#pop'), + (r'"(\\\\|\\[^\\]|[^"\\\n])*"', String, '#pop'), + ], + + 'html-comment-block': [ + (_dot + '+', Comment), + (r'\n', Text, 'root'), + ], + + 'scaml-comment-block': [ + (_dot + '+', Comment.Preproc), + (r'\n', Text, 'root'), + ], + + 'filter-block': [ + (r'([^#\n]|#[^{\n]|(\\\\)*\\#\{)+', Name.Decorator), + (r'(#\{)(' + _dot + r'*?)(\})', + bygroups(String.Interpol, using(ScalaLexer), String.Interpol)), + (r'\n', Text, 'root'), + ], + } +JadeLexer = PugLexer # compat diff --git a/shared/package-files/31/3136b05be93d679e6d866647e0c255517deda19194e23e378399395000efe594/blob b/shared/package-files/31/3136b05be93d679e6d866647e0c255517deda19194e23e378399395000efe594/blob new file mode 100644 index 0000000000000000000000000000000000000000..faef8929e67f7e69199791305817f903168c3b78 --- /dev/null +++ b/shared/package-files/31/3136b05be93d679e6d866647e0c255517deda19194e23e378399395000efe594/blob @@ -0,0 +1,511 @@ +from pathlib import Path +import warnings + +import numpy as np +import numpy.testing as npt +import pandas as pd +import pytest +from scipy import stats + +from statsmodels.distributions.mixture_rvs import mixture_rvs +from statsmodels.nonparametric import bandwidths +from statsmodels.nonparametric.kde import ( + KDEResult, + KDEUnivariate as KDE, + kdensity, + kdensityfft, +) +from statsmodels.sandbox.nonparametric import kernels + +# get results from Stata + +curdir = Path(__file__).resolve().parent +rfname = Path(curdir).joinpath("results", "results_kde.csv") +# print rfname +KDEResults = pd.read_csv(rfname, dtype=float) + +rfname = Path(curdir).joinpath("results", "results_kde_univ_weights.csv") +KDEWResults = pd.read_csv(rfname) + +# get results from R +curdir = Path(__file__).resolve().parent +rfname = Path(curdir).joinpath("results", "results_kcde.csv") +# print rfname +KCDEResults = pd.read_csv(rfname, dtype=float) + +# setup test data + +RANDOM_STATE = np.random.RandomState(12345) +Xi = mixture_rvs( + [0.25, 0.75], + size=200, + dist=[stats.norm, stats.norm], + kwargs=(dict(loc=-1, scale=0.5), dict(loc=1, scale=0.5)), + rng=RANDOM_STATE, +) + + +class TestKDEExceptions: + + @classmethod + def setup_class(cls): + cls.kde = KDE(Xi) + cls.weights_200 = np.linspace(1, 100, 200) + cls.weights_100 = np.linspace(1, 100, 100) + + def test_check_is_fit_exception(self): + with pytest.raises(ValueError): + self.kde.evaluate(0) + + def test_non_weighted_fft_exception(self): + with pytest.raises(NotImplementedError): + self.kde.fit( + kernel="gau", + gridsize=50, + weights=self.weights_200, + fft=True, + bw="silverman", + ) + + def test_wrong_weight_length_exception(self): + with pytest.raises(ValueError): + self.kde.fit( + kernel="gau", + gridsize=50, + weights=self.weights_100, + fft=False, + bw="silverman", + ) + + def test_non_gaussian_fft_exception(self): + with pytest.raises(NotImplementedError): + self.kde.fit(kernel="epa", gridsize=50, fft=True, bw="silverman") + + +class CheckKDE: + decimal_density = 7 + + def test_density(self): + npt.assert_almost_equal( + self.res1.density, self.res_density, self.decimal_density + ) + + def test_evaluate(self): + # disable test + # fails for Epan, Triangular and Biweight, only Gaussian is correct + # added it as test method to TestKDEGauss below + # inDomain is not vectorized + # kde_vals = self.res1.evaluate(self.res1.support) + kde_vals = [np.squeeze(self.res1.evaluate(xi)) for xi in self.res1.support] + kde_vals = np.squeeze(kde_vals) # kde_vals is a "column_list" + mask_valid = np.isfinite(kde_vals) + # TODO: nans at the boundaries + kde_vals[~mask_valid] = 0 + npt.assert_almost_equal(kde_vals, self.res_density, self.decimal_density) + + +class TestKDEGauss(CheckKDE): + @classmethod + def setup_class(cls): + cls.res1 = cls.result_factory() + cls.res_density = KDEResults["gau_d"] + + @classmethod + def result_factory(cls): + return KDE(Xi).fit(kernel="gau", fft=False, bw="silverman") + + def test_evaluate(self): + # kde_vals = self.res1.evaluate(self.res1.support) + kde_vals = [self.res1.evaluate(xi) for xi in self.res1.support] + kde_vals = np.squeeze(kde_vals) # kde_vals is a "column_list" + mask_valid = np.isfinite(kde_vals) + # TODO: nans at the boundaries + kde_vals[~mask_valid] = 0 + npt.assert_almost_equal(kde_vals, self.res_density, self.decimal_density) + + # The following tests are regression tests + # Values have been checked to be very close to R 'ks' package (Dec 2013) + def test_support_gridded(self): + kde = self.res1 + support = KCDEResults["gau_support"] + npt.assert_allclose(support, kde.support) + + def test_cdf_gridded(self): + kde = self.res1 + cdf = KCDEResults["gau_cdf"] + npt.assert_allclose(cdf, kde.cdf) + + def test_sf_gridded(self): + kde = self.res1 + sf = KCDEResults["gau_sf"] + npt.assert_allclose(sf, kde.sf) + + def test_icdf_gridded(self): + kde = self.res1 + icdf = KCDEResults["gau_icdf"] + npt.assert_allclose(icdf, kde.icdf) + + +class TestKDEGaussPandas(TestKDEGauss): + @classmethod + def setup_class(cls): + cls.res1 = cls.result_factory() + cls.res_density = KDEResults["gau_d"] + + @classmethod + def result_factory(cls): + return KDE(pd.Series(Xi)).fit(kernel="gau", fft=False, bw="silverman") + + +class TestKDEEpanechnikov(CheckKDE): + @classmethod + def setup_class(cls): + cls.res1 = cls.result_factory() + cls.res_density = KDEResults["epa2_d"] + + @classmethod + def result_factory(cls): + return KDE(Xi).fit(kernel="epa", fft=False, bw="silverman") + + +class TestKDETriangular(CheckKDE): + @classmethod + def setup_class(cls): + cls.res1 = cls.result_factory() + cls.res_density = KDEResults["tri_d"] + + @classmethod + def result_factory(cls): + return KDE(Xi).fit(kernel="tri", fft=False, bw="silverman") + + +class TestKDEBiweight(CheckKDE): + @classmethod + def setup_class(cls): + cls.res1 = cls.result_factory() + cls.res_density = KDEResults["biw_d"] + + @classmethod + def result_factory(cls): + return KDE(Xi).fit(kernel="biw", fft=False, bw="silverman") + + +# FIXME: enable/xfail/skip or delete +# NOTE: This is a knownfailure due to a definitional difference of Cosine kernel +# class TestKDECosine(CheckKDE): +# @classmethod +# def setup_class(cls): +# res1 = KDE(Xi) +# res1.fit(kernel="cos", fft=False, bw="silverman") +# cls.res1 = res1 +# cls.res_density = KDEResults["cos_d"] + + +# weighted estimates taken from matlab so we can allow len(weights) != gridsize +class TestKdeWeights(CheckKDE): + + @classmethod + def setup_class(cls): + cls.res1 = cls.result_factory() + fname = Path(curdir).joinpath("results", "results_kde_weights.csv") + cls.res_density = pd.read_csv(fname, skiprows=1, header=None).values.squeeze() + cls.res_density2 = np.genfromtxt(Path(fname).open("rb"), skip_header=1) + + @classmethod + def result_factory(cls): + weights = np.linspace(1, 100, 200) + return KDE(Xi).fit( + kernel="gau", gridsize=50, weights=weights, fft=False, bw="silverman" + ) + + def test_evaluate(self): + # kde_vals = self.res1.evaluate(self.res1.support) + kde_vals = [self.res1.evaluate(xi) for xi in self.res1.support] + kde_vals = np.squeeze(kde_vals) # kde_vals is a "column_list" + mask_valid = np.isfinite(kde_vals) + # TODO: nans at the boundaries + kde_vals[~mask_valid] = 0 + npt.assert_almost_equal(kde_vals, self.res_density, self.decimal_density) + + +class TestKDEGaussFFT(CheckKDE): + @classmethod + def setup_class(cls): + cls.decimal_density = 2 # low accuracy because binning is different + cls.res1 = cls.result_factory() + rfname2 = Path(curdir).joinpath("results", "results_kde_fft.csv") + cls.res_density = pd.read_csv(rfname2, header=None).values.squeeze() + + @classmethod + def result_factory(cls): + return KDE(Xi).fit(kernel="gau", fft=True, bw="silverman") + + +class CheckKDEWeights: + kernel_name = "dummy_kernel" + + @classmethod + def setup_class(cls): + cls.x = KDEWResults["x"] + cls.res1 = cls.result_factory() + cls.res_density = KDEWResults[cls.res_kernel_name] + + @classmethod + def result_factory(cls): + weights = KDEWResults["weights"] + # default kernel was scott when reference values computed + return KDE(cls.x).fit( + kernel=cls.kernel_name, weights=weights, fft=False, bw="scott" + ) + + decimal_density = 7 + + @pytest.mark.xfail( + reason="Not almost equal to 7 decimals", raises=AssertionError, strict=True + ) + def test_density(self): + npt.assert_almost_equal( + self.res1.density, self.res_density, self.decimal_density + ) + + def test_evaluate(self): + if self.kernel_name == "cos": + pytest.skip("Cosine kernel fails against Stata") + kde_vals = [self.res1.evaluate(xi) for xi in self.x] + kde_vals = np.squeeze(kde_vals) # kde_vals is a "column_list" + npt.assert_almost_equal(kde_vals, self.res_density, self.decimal_density) + + def test_compare(self): + xx = self.res1.support + kde_vals = [np.squeeze(self.res1.evaluate(xi)) for xi in xx] + kde_vals = np.squeeze(kde_vals) # kde_vals is a "column_list" + mask_valid = np.isfinite(kde_vals) + # TODO: nans at the boundaries + kde_vals[~mask_valid] = 0 + npt.assert_almost_equal(self.res1.density, kde_vals, self.decimal_density) + + # regression test, not compared to another package + nobs = len(self.res1.endog) + kern = self.res1.kernel + v = kern.density_var(kde_vals, nobs) + v_direct = kde_vals * kern.L2Norm / kern.h / nobs + npt.assert_allclose(v, v_direct, rtol=1e-10) + + ci = kern.density_confint(kde_vals, nobs) + crit = 1.9599639845400545 # stats.norm.isf(0.05 / 2) + hw = kde_vals - ci[:, 0] + npt.assert_allclose(hw, crit * np.sqrt(v), rtol=1e-10) + hw = ci[:, 1] - kde_vals + npt.assert_allclose(hw, crit * np.sqrt(v), rtol=1e-10) + + def test_kernel_constants(self): + # Copy the kernel since attributes are set in the test + kern = self.result_factory().kernel + + nc = kern.norm_const + # trigger numerical integration + kern._norm_const = None + nc2 = kern.norm_const + npt.assert_allclose(nc, nc2, rtol=1e-10) + + l2n = kern.L2Norm + # trigger numerical integration + kern._L2Norm = None + l2n2 = kern.L2Norm + npt.assert_allclose(l2n, l2n2, rtol=1e-10) + + v = kern.kernel_var + # trigger numerical integration + kern._kernel_var = None + v2 = kern.kernel_var + npt.assert_allclose(v, v2, rtol=1e-10) + + +class TestKDEWGauss(CheckKDEWeights): + kernel_name = "gau" + res_kernel_name = "x_gau_wd" + + +class TestKDEWEpa(CheckKDEWeights): + kernel_name = "epa" + res_kernel_name = "x_epan2_wd" + + +class TestKDEWTri(CheckKDEWeights): + kernel_name = "tri" + res_kernel_name = "x_" + kernel_name + "_wd" + + +class TestKDEWBiw(CheckKDEWeights): + kernel_name = "biw" + res_kernel_name = "x_bi_wd" + + +class TestKDEWCos(CheckKDEWeights): + kernel_name = "cos" + res_kernel_name = "x_cos_wd" + + +class TestKDEWCos2(CheckKDEWeights): + kernel_name = "cos2" + res_kernel_name = "x_cos_wd" + + +class _TestKDEWRect(CheckKDEWeights): + # TODO in docstring but not in kernel_switch + kernel_name = "rect" + res_kernel_name = "x_rec_wd" + + +class _TestKDEWPar(CheckKDEWeights): + # TODO in docstring but not implemented in kernels + kernel_name = "par" + res_kernel_name = "x_par_wd" + + +class TestKdeRefit: + rs = np.random.RandomState(12345) + data1 = rs.randn(100) * 100 + pdf = KDE(data1) + pdf.fit() + + data2 = rs.randn(100) * 100 + pdf2 = KDE(data2) + pdf2.fit() + + for attr in ["icdf", "cdf", "sf"]: + assert not np.allclose(getattr(pdf, attr)[:10], getattr(pdf2, attr)[:10]) + + +class TestNormConstant: + def test_norm_constant_calculation(self): + custom_gauss = kernels.CustomKernel(lambda x: np.exp(-(x**2) / 2.0)) + gauss_true_const = 0.3989422804014327 + npt.assert_almost_equal(gauss_true_const, custom_gauss.norm_const) + + +def test_kde_bw_positive(): + # GH 6679 + x = np.array( + [ + 4.59511985, + 4.59511985, + 4.59511985, + 4.59511985, + 4.59511985, + 4.59511985, + 4.59511985, + 4.59511985, + 4.59511985, + 4.59511985, + 5.67332327, + 6.19847872, + 7.43189192, + ] + ) + kde = KDE(x) + kde.fit() + assert kde.bw > 0 + + +def test_fit_self(): + rs = np.random.RandomState(38923801) + x = rs.standard_normal(100) + kde = KDE(x) + assert isinstance(kde, KDE) + assert isinstance(kde.fit(), KDE) + + +class TestKDECustomBandwidth: + decimal_density = 7 + + @classmethod + def setup_class(cls): + cls.kde = KDE(Xi) + cls.weights_200 = np.linspace(1, 100, 200) + cls.weights_100 = np.linspace(1, 100, 100) + + def test_check_is_fit_ok_with_custom_bandwidth(self): + def custom_bw(X, kern): + return np.std(X) * len(X) + + kde = self.kde.fit(bw=custom_bw) + assert isinstance(kde, KDE) + + def test_check_is_fit_ok_with_standard_custom_bandwidth(self): + # Note, we are passing the function, not the string - this is intended + kde = self.kde.fit(bw=bandwidths.bw_silverman) + s1 = kde.support.copy() + d1 = kde.density.copy() + + kde = self.kde.fit(bw="silverman") + + npt.assert_almost_equal(s1, kde.support, self.decimal_density) + npt.assert_almost_equal(d1, kde.density, self.decimal_density) + + @pytest.mark.parametrize("fft", [True, False]) + def test_check_is_fit_ok_with_float_bandwidth(self, fft): + # Note, we are passing the function, not the string - this is intended + kde = self.kde.fit(bw=bandwidths.bw_silverman, fft=fft) + s1 = kde.support.copy() + d1 = kde.density.copy() + + kde = self.kde.fit(bw=kde.bw, fft=fft) + + npt.assert_almost_equal(s1, kde.support, self.decimal_density) + npt.assert_almost_equal(d1, kde.density, self.decimal_density) + + +@pytest.mark.parametrize("kernel", ["epa", "tri", "uni", "cos", "biw", "triw"]) +def test_entropy_finite_domain_kernel(kernel): + # Kernels with a bounded domain used to read the integration limits off + # the KDE instead of the kernel, which has no such attribute. GH#9917 + kde = KDE(Xi).fit(kernel=kernel, fft=False, bw="silverman") + + entropy = kde.entropy + + assert np.isfinite(entropy) + + +def test_entropy_infinite_domain_kernel(): + kde = KDE(Xi).fit(kernel="gau", fft=False, bw="silverman") + + assert np.isfinite(kde.entropy) + + +@pytest.mark.parametrize("func", [kdensity, kdensityfft]) +def test_kdensity_result_object_default(func): + # retgrid=True (the default) yields a KDEResult with the same length and + # contents as the legacy (density, grid, bw) tuple, so it is adopted + # without a warning. + with warnings.catch_warnings(): + warnings.filterwarnings("error", category=FutureWarning) + res = func(Xi) + assert isinstance(res, KDEResult) + assert len(res) == 3 + + # retgrid=False does change shape, so that path still warns. + with pytest.warns(FutureWarning, match="result_object"): + res = func(Xi, retgrid=False) + assert not isinstance(res, KDEResult) + assert len(res) == 2 + + +@pytest.mark.parametrize("func", [kdensity, kdensityfft]) +def test_kdensity_result_object_true(func): + with warnings.catch_warnings(): + warnings.filterwarnings("error", category=FutureWarning) + res = func(Xi, result_object=True) + assert isinstance(res, KDEResult) + assert res.grid is not None + assert res[0] is res.density + assert res[1] is res.grid + assert res[2] == res.bw + + with warnings.catch_warnings(): + warnings.filterwarnings("error", category=FutureWarning) + res = func(Xi, retgrid=False, result_object=True) + assert isinstance(res, KDEResult) + # The grid is computed regardless of retgrid, so it is reported rather + # than None-filled. + assert res.grid is not None diff --git a/shared/package-files/31/3138edec0118438c6d8a7594a41ff00695baaa4f346c8e36cbac5b9ebabb8bbf/blob b/shared/package-files/31/3138edec0118438c6d8a7594a41ff00695baaa4f346c8e36cbac5b9ebabb8bbf/blob new file mode 100644 index 0000000000000000000000000000000000000000..fc6e733d7b8e34b5f76327392660a7940167e468 --- /dev/null +++ b/shared/package-files/31/3138edec0118438c6d8a7594a41ff00695baaa4f346c8e36cbac5b9ebabb8bbf/blob @@ -0,0 +1,28 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API _shape_as_tensor { + using schema = at::Tensor (const at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_shape_as_tensor") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_shape_as_tensor(Tensor self) -> Tensor") + static at::Tensor call(const at::Tensor & self); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/31/313a7f2d87ae78959524158acd65328b0730bbd32f8c4b41cc40b44a8cef5acf/blob b/shared/package-files/31/313a7f2d87ae78959524158acd65328b0730bbd32f8c4b41cc40b44a8cef5acf/blob new file mode 100644 index 0000000000000000000000000000000000000000..cd98087c06c18634304c29d88837017a6952a4fc --- /dev/null +++ b/shared/package-files/31/313a7f2d87ae78959524158acd65328b0730bbd32f8c4b41cc40b44a8cef5acf/blob @@ -0,0 +1,262 @@ +""" +Support pre-0.12 series pickle compatibility. +""" +from __future__ import annotations + +import contextlib +import copy +import io +import pickle as pkl +from typing import TYPE_CHECKING + +import numpy as np + +from pandas._libs.arrays import NDArrayBacked +from pandas._libs.tslibs import BaseOffset + +from pandas import Index +from pandas.core.arrays import ( + DatetimeArray, + PeriodArray, + TimedeltaArray, +) +from pandas.core.internals import BlockManager + +if TYPE_CHECKING: + from collections.abc import Generator + + +def load_reduce(self) -> None: + stack = self.stack + args = stack.pop() + func = stack[-1] + + try: + stack[-1] = func(*args) + return + except TypeError as err: + # If we have a deprecated function, + # try to replace and try again. + + msg = "_reconstruct: First argument must be a sub-type of ndarray" + + if msg in str(err): + try: + cls = args[0] + stack[-1] = object.__new__(cls) + return + except TypeError: + pass + elif args and isinstance(args[0], type) and issubclass(args[0], BaseOffset): + # TypeError: object.__new__(Day) is not safe, use Day.__new__() + cls = args[0] + stack[-1] = cls.__new__(*args) + return + elif args and issubclass(args[0], PeriodArray): + cls = args[0] + stack[-1] = NDArrayBacked.__new__(*args) + return + + raise + + +# If classes are moved, provide compat here. +_class_locations_map = { + ("pandas.core.sparse.array", "SparseArray"): ("pandas.core.arrays", "SparseArray"), + # 15477 + ("pandas.core.base", "FrozenNDArray"): ("numpy", "ndarray"), + # Re-routing unpickle block logic to go through _unpickle_block instead + # for pandas <= 1.3.5 + ("pandas.core.internals.blocks", "new_block"): ( + "pandas._libs.internals", + "_unpickle_block", + ), + ("pandas.core.indexes.frozen", "FrozenNDArray"): ("numpy", "ndarray"), + ("pandas.core.base", "FrozenList"): ("pandas.core.indexes.frozen", "FrozenList"), + # 10890 + ("pandas.core.series", "TimeSeries"): ("pandas.core.series", "Series"), + ("pandas.sparse.series", "SparseTimeSeries"): ( + "pandas.core.sparse.series", + "SparseSeries", + ), + # 12588, extensions moving + ("pandas._sparse", "BlockIndex"): ("pandas._libs.sparse", "BlockIndex"), + ("pandas.tslib", "Timestamp"): ("pandas._libs.tslib", "Timestamp"), + # 18543 moving period + ("pandas._period", "Period"): ("pandas._libs.tslibs.period", "Period"), + ("pandas._libs.period", "Period"): ("pandas._libs.tslibs.period", "Period"), + # 18014 moved __nat_unpickle from _libs.tslib-->_libs.tslibs.nattype + ("pandas.tslib", "__nat_unpickle"): ( + "pandas._libs.tslibs.nattype", + "__nat_unpickle", + ), + ("pandas._libs.tslib", "__nat_unpickle"): ( + "pandas._libs.tslibs.nattype", + "__nat_unpickle", + ), + # 15998 top-level dirs moving + ("pandas.sparse.array", "SparseArray"): ( + "pandas.core.arrays.sparse", + "SparseArray", + ), + ("pandas.indexes.base", "_new_Index"): ("pandas.core.indexes.base", "_new_Index"), + ("pandas.indexes.base", "Index"): ("pandas.core.indexes.base", "Index"), + ("pandas.indexes.numeric", "Int64Index"): ( + "pandas.core.indexes.base", + "Index", # updated in 50775 + ), + ("pandas.indexes.range", "RangeIndex"): ("pandas.core.indexes.range", "RangeIndex"), + ("pandas.indexes.multi", "MultiIndex"): ("pandas.core.indexes.multi", "MultiIndex"), + ("pandas.tseries.index", "_new_DatetimeIndex"): ( + "pandas.core.indexes.datetimes", + "_new_DatetimeIndex", + ), + ("pandas.tseries.index", "DatetimeIndex"): ( + "pandas.core.indexes.datetimes", + "DatetimeIndex", + ), + ("pandas.tseries.period", "PeriodIndex"): ( + "pandas.core.indexes.period", + "PeriodIndex", + ), + # 19269, arrays moving + ("pandas.core.categorical", "Categorical"): ("pandas.core.arrays", "Categorical"), + # 19939, add timedeltaindex, float64index compat from 15998 move + ("pandas.tseries.tdi", "TimedeltaIndex"): ( + "pandas.core.indexes.timedeltas", + "TimedeltaIndex", + ), + ("pandas.indexes.numeric", "Float64Index"): ( + "pandas.core.indexes.base", + "Index", # updated in 50775 + ), + # 50775, remove Int64Index, UInt64Index & Float64Index from codabase + ("pandas.core.indexes.numeric", "Int64Index"): ( + "pandas.core.indexes.base", + "Index", + ), + ("pandas.core.indexes.numeric", "UInt64Index"): ( + "pandas.core.indexes.base", + "Index", + ), + ("pandas.core.indexes.numeric", "Float64Index"): ( + "pandas.core.indexes.base", + "Index", + ), + ("pandas.core.arrays.sparse.dtype", "SparseDtype"): ( + "pandas.core.dtypes.dtypes", + "SparseDtype", + ), +} + + +# our Unpickler sub-class to override methods and some dispatcher +# functions for compat and uses a non-public class of the pickle module. + + +class Unpickler(pkl._Unpickler): + def find_class(self, module, name): + # override superclass + key = (module, name) + module, name = _class_locations_map.get(key, key) + return super().find_class(module, name) + + +Unpickler.dispatch = copy.copy(Unpickler.dispatch) +Unpickler.dispatch[pkl.REDUCE[0]] = load_reduce + + +def load_newobj(self) -> None: + args = self.stack.pop() + cls = self.stack[-1] + + # compat + if issubclass(cls, Index): + obj = object.__new__(cls) + elif issubclass(cls, DatetimeArray) and not args: + arr = np.array([], dtype="M8[ns]") + obj = cls.__new__(cls, arr, arr.dtype) + elif issubclass(cls, TimedeltaArray) and not args: + arr = np.array([], dtype="m8[ns]") + obj = cls.__new__(cls, arr, arr.dtype) + elif cls is BlockManager and not args: + obj = cls.__new__(cls, (), [], False) + else: + obj = cls.__new__(cls, *args) + + self.stack[-1] = obj + + +Unpickler.dispatch[pkl.NEWOBJ[0]] = load_newobj + + +def load_newobj_ex(self) -> None: + kwargs = self.stack.pop() + args = self.stack.pop() + cls = self.stack.pop() + + # compat + if issubclass(cls, Index): + obj = object.__new__(cls) + else: + obj = cls.__new__(cls, *args, **kwargs) + self.append(obj) + + +try: + Unpickler.dispatch[pkl.NEWOBJ_EX[0]] = load_newobj_ex +except (AttributeError, KeyError): + pass + + +def load(fh, encoding: str | None = None, is_verbose: bool = False): + """ + Load a pickle, with a provided encoding, + + Parameters + ---------- + fh : a filelike object + encoding : an optional encoding + is_verbose : show exception output + """ + try: + fh.seek(0) + if encoding is not None: + up = Unpickler(fh, encoding=encoding) + else: + up = Unpickler(fh) + # "Unpickler" has no attribute "is_verbose" [attr-defined] + up.is_verbose = is_verbose # type: ignore[attr-defined] + + return up.load() + except (ValueError, TypeError): + raise + + +def loads( + bytes_object: bytes, + *, + fix_imports: bool = True, + encoding: str = "ASCII", + errors: str = "strict", +): + """ + Analogous to pickle._loads. + """ + fd = io.BytesIO(bytes_object) + return Unpickler( + fd, fix_imports=fix_imports, encoding=encoding, errors=errors + ).load() + + +@contextlib.contextmanager +def patch_pickle() -> Generator[None, None, None]: + """ + Temporarily patch pickle to use our unpickler. + """ + orig_loads = pkl.loads + try: + setattr(pkl, "loads", loads) + yield + finally: + setattr(pkl, "loads", orig_loads) diff --git a/shared/package-files/31/313b17c461aff31388947ff384e79251d79d236f421c122c2743dcafc0fac8ad/blob b/shared/package-files/31/313b17c461aff31388947ff384e79251d79d236f421c122c2743dcafc0fac8ad/blob new file mode 100644 index 0000000000000000000000000000000000000000..aa7e32d5b961a80b2637995a3e3be07eaa5d7165 --- /dev/null +++ b/shared/package-files/31/313b17c461aff31388947ff384e79251d79d236f421c122c2743dcafc0fac8ad/blob @@ -0,0 +1,711 @@ +import math +from typing import Dict, List, Optional, Tuple + +import torch +from torchaudio.models import Conformer, RNNT +from torchaudio.models.rnnt import _Joiner, _Predictor, _TimeReduction, _Transcriber + + +TrieNode = Tuple[Dict[int, "TrieNode"], int, Optional[Tuple[int, int]]] + + +class _ConformerEncoder(torch.nn.Module, _Transcriber): + def __init__( + self, + *, + input_dim: int, + output_dim: int, + time_reduction_stride: int, + conformer_input_dim: int, + conformer_ffn_dim: int, + conformer_num_layers: int, + conformer_num_heads: int, + conformer_depthwise_conv_kernel_size: int, + conformer_dropout: float, + ) -> None: + super().__init__() + self.time_reduction = _TimeReduction(time_reduction_stride) + self.input_linear = torch.nn.Linear(input_dim * time_reduction_stride, conformer_input_dim) + self.conformer = Conformer( + num_layers=conformer_num_layers, + input_dim=conformer_input_dim, + ffn_dim=conformer_ffn_dim, + num_heads=conformer_num_heads, + depthwise_conv_kernel_size=conformer_depthwise_conv_kernel_size, + dropout=conformer_dropout, + use_group_norm=True, + convolution_first=True, + ) + self.output_linear = torch.nn.Linear(conformer_input_dim, output_dim) + self.layer_norm = torch.nn.LayerNorm(output_dim) + + def forward(self, input: torch.Tensor, lengths: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: + time_reduction_out, time_reduction_lengths = self.time_reduction(input, lengths) + input_linear_out = self.input_linear(time_reduction_out) + x, lengths = self.conformer(input_linear_out, time_reduction_lengths) + output_linear_out = self.output_linear(x) + layer_norm_out = self.layer_norm(output_linear_out) + return layer_norm_out, lengths + + def infer( + self, + input: torch.Tensor, + lengths: torch.Tensor, + states: Optional[List[List[torch.Tensor]]], + ) -> Tuple[torch.Tensor, torch.Tensor, List[List[torch.Tensor]]]: + raise RuntimeError("Conformer does not support streaming inference.") + + +class _JoinerBiasing(torch.nn.Module): + r"""Recurrent neural network transducer (RNN-T) joint network. + + Args: + input_dim (int): source and target input dimension. + output_dim (int): output dimension. + activation (str, optional): activation function to use in the joiner. + Must be one of ("relu", "tanh"). (Default: "relu") + biasing (bool): perform biasing + deepbiasing (bool): perform deep biasing + attndim (int): dimension of the biasing vector hptr + + """ + + def __init__( + self, + input_dim: int, + output_dim: int, + activation: str = "relu", + biasing: bool = False, + deepbiasing: bool = False, + attndim: int = 1, + ) -> None: + super().__init__() + self.linear = torch.nn.Linear(input_dim, output_dim, bias=True) + self.biasing = biasing + self.deepbiasing = deepbiasing + if self.biasing and self.deepbiasing: + self.biasinglinear = torch.nn.Linear(attndim, input_dim, bias=True) + self.attndim = attndim + if activation == "relu": + self.activation = torch.nn.ReLU() + elif activation == "tanh": + self.activation = torch.nn.Tanh() + else: + raise ValueError(f"Unsupported activation {activation}") + + def forward( + self, + source_encodings: torch.Tensor, + source_lengths: torch.Tensor, + target_encodings: torch.Tensor, + target_lengths: torch.Tensor, + hptr: torch.Tensor = None, + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: + r"""Forward pass for training. + + B: batch size; + T: maximum source sequence length in batch; + U: maximum target sequence length in batch; + D: dimension of each source and target sequence encoding. + + Args: + source_encodings (torch.Tensor): source encoding sequences, with + shape `(B, T, D)`. + source_lengths (torch.Tensor): with shape `(B,)` and i-th element representing + valid sequence length of i-th batch element in ``source_encodings``. + target_encodings (torch.Tensor): target encoding sequences, with shape `(B, U, D)`. + target_lengths (torch.Tensor): with shape `(B,)` and i-th element representing + valid sequence length of i-th batch element in ``target_encodings``. + hptr (torch.Tensor): deep biasing vector with shape `(B, T, U, A)`. + + Returns: + (torch.Tensor, torch.Tensor, torch.Tensor): + torch.Tensor + joint network output, with shape `(B, T, U, output_dim)`. + torch.Tensor + output source lengths, with shape `(B,)` and i-th element representing + number of valid elements along dim 1 for i-th batch element in joint network output. + torch.Tensor + output target lengths, with shape `(B,)` and i-th element representing + number of valid elements along dim 2 for i-th batch element in joint network output. + torch.Tensor + joint network second last layer output (i.e. before self.linear), with shape `(B, T, U, D)`. + """ + joint_encodings = source_encodings.unsqueeze(2).contiguous() + target_encodings.unsqueeze(1).contiguous() + if self.biasing and self.deepbiasing and hptr is not None: + hptr = self.biasinglinear(hptr) + joint_encodings += hptr + elif self.biasing and self.deepbiasing: + # Hack here for unused parameters + joint_encodings += self.biasinglinear(joint_encodings.new_zeros(1, self.attndim)).mean() * 0 + activation_out = self.activation(joint_encodings) + output = self.linear(activation_out) + return output, source_lengths, target_lengths, activation_out + + +class RNNTBiasing(RNNT): + r"""torchaudio.models.RNNT() + + Recurrent neural network transducer (RNN-T) model. + + Note: + To build the model, please use one of the factory functions. + + Args: + transcriber (torch.nn.Module): transcription network. + predictor (torch.nn.Module): prediction network. + joiner (torch.nn.Module): joint network. + attndim (int): TCPGen attention dimension + biasing (bool): If true, use biasing, otherwise use standard RNN-T + deepbiasing (bool): If true, use deep biasing by extracting the biasing vector + embdim (int): dimension of symbol embeddings + jointdim (int): dimension of the joint network joint dimension + charlist (list): The list of word piece tokens in the same order as the output layer + encoutdim (int): dimension of the encoder output vectors + dropout_tcpgen (float): dropout rate for TCPGen + tcpsche (int): The epoch at which TCPGen starts to train + DBaverage (bool): If true, instead of TCPGen, use DBRNNT for biasing + """ + + def __init__( + self, + transcriber: _Transcriber, + predictor: _Predictor, + joiner: _Joiner, + attndim: int, + biasing: bool, + deepbiasing: bool, + embdim: int, + jointdim: int, + charlist: List[str], + encoutdim: int, + dropout_tcpgen: float, + tcpsche: int, + DBaverage: bool, + ) -> None: + super().__init__(transcriber, predictor, joiner) + self.attndim = attndim + self.deepbiasing = deepbiasing + self.jointdim = jointdim + self.embdim = embdim + self.encoutdim = encoutdim + self.char_list = charlist or [] + self.blank_idx = self.char_list.index("") + self.nchars = len(self.char_list) + self.DBaverage = DBaverage + self.biasing = biasing + if self.biasing: + if self.deepbiasing and self.DBaverage: + # Deep biasing without TCPGen + self.biasingemb = torch.nn.Linear(self.nchars, self.attndim, bias=False) + else: + # TCPGen parameters + self.ooKBemb = torch.nn.Embedding(1, self.embdim) + self.Qproj_char = torch.nn.Linear(self.embdim, self.attndim) + self.Qproj_acoustic = torch.nn.Linear(self.encoutdim, self.attndim) + self.Kproj = torch.nn.Linear(self.embdim, self.attndim) + self.pointer_gate = torch.nn.Linear(self.attndim + self.jointdim, 1) + self.dropout_tcpgen = torch.nn.Dropout(dropout_tcpgen) + self.tcpsche = tcpsche + + def forward( + self, + sources: torch.Tensor, + source_lengths: torch.Tensor, + targets: torch.Tensor, + target_lengths: torch.Tensor, + tries: TrieNode, + current_epoch: int, + predictor_state: Optional[List[List[torch.Tensor]]] = None, + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, List[List[torch.Tensor]], torch.Tensor, torch.Tensor]: + r"""Forward pass for training. + + B: batch size; + T: maximum source sequence length in batch; + U: maximum target sequence length in batch; + D: feature dimension of each source sequence element. + + Args: + sources (torch.Tensor): source frame sequences right-padded with right context, with + shape `(B, T, D)`. + source_lengths (torch.Tensor): with shape `(B,)` and i-th element representing + number of valid frames for i-th batch element in ``sources``. + targets (torch.Tensor): target sequences, with shape `(B, U)` and each element + mapping to a target symbol. + target_lengths (torch.Tensor): with shape `(B,)` and i-th element representing + number of valid frames for i-th batch element in ``targets``. + tries (TrieNode): wordpiece prefix trees representing the biasing list to be searched + current_epoch (Int): the current epoch number to determine if TCPGen should be trained + at this epoch + predictor_state (List[List[torch.Tensor]] or None, optional): list of lists of tensors + representing prediction network internal state generated in preceding invocation + of ``forward``. (Default: ``None``) + + Returns: + (torch.Tensor, torch.Tensor, torch.Tensor, List[List[torch.Tensor]]): + torch.Tensor + joint network output, with shape + `(B, max output source length, max output target length, output_dim (number of target symbols))`. + torch.Tensor + output source lengths, with shape `(B,)` and i-th element representing + number of valid elements along dim 1 for i-th batch element in joint network output. + torch.Tensor + output target lengths, with shape `(B,)` and i-th element representing + number of valid elements along dim 2 for i-th batch element in joint network output. + List[List[torch.Tensor]] + output states; list of lists of tensors + representing prediction network internal state generated in current invocation + of ``forward``. + torch.Tensor + TCPGen distribution, with shape + `(B, max output source length, max output target length, output_dim (number of target symbols))`. + torch.Tensor + Generation probability (or copy probability), with shape + `(B, max output source length, max output target length, 1)`. + """ + source_encodings, source_lengths = self.transcriber( + input=sources, + lengths=source_lengths, + ) + target_encodings, target_lengths, predictor_state = self.predictor( + input=targets, + lengths=target_lengths, + state=predictor_state, + ) + # Forward TCPGen + hptr = None + tcpgen_dist, p_gen = None, None + if self.biasing and current_epoch >= self.tcpsche and tries != []: + ptrdist_mask, p_gen_mask = self.get_tcpgen_step_masks(targets, tries) + hptr, tcpgen_dist = self.forward_tcpgen(targets, ptrdist_mask, source_encodings) + hptr = self.dropout_tcpgen(hptr) + elif self.biasing: + # Hack here to bypass unused parameters + if self.DBaverage and self.deepbiasing: + dummy = self.biasingemb(source_encodings.new_zeros(1, len(self.char_list))).mean() + else: + dummy = source_encodings.new_zeros(1, self.embdim) + dummy = self.Qproj_char(dummy).mean() + dummy += self.Qproj_acoustic(source_encodings.new_zeros(1, source_encodings.size(-1))).mean() + dummy += self.Kproj(source_encodings.new_zeros(1, self.embdim)).mean() + dummy += self.pointer_gate(source_encodings.new_zeros(1, self.attndim + self.jointdim)).mean() + dummy += self.ooKBemb.weight.mean() + dummy = dummy * 0 + source_encodings += dummy + + output, source_lengths, target_lengths, jointer_activation = self.joiner( + source_encodings=source_encodings, + source_lengths=source_lengths, + target_encodings=target_encodings, + target_lengths=target_lengths, + hptr=hptr, + ) + + # Calculate Generation Probability + if self.biasing and hptr is not None and tcpgen_dist is not None: + p_gen = torch.sigmoid(self.pointer_gate(torch.cat((jointer_activation, hptr), dim=-1))) + # avoid collapsing to ooKB token in the first few updates + # if current_epoch == self.tcpsche: + # p_gen = p_gen * 0.1 + p_gen = p_gen.masked_fill(p_gen_mask.bool().unsqueeze(1).unsqueeze(-1), 0) + + return (output, source_lengths, target_lengths, predictor_state, tcpgen_dist, p_gen) + + def get_tcpgen_distribution(self, query, ptrdist_mask): + # Make use of the predictor embedding matrix + keyvalues = torch.cat([self.predictor.embedding.weight.data, self.ooKBemb.weight], dim=0) + keyvalues = self.dropout_tcpgen(self.Kproj(keyvalues)) + # B * T * U * attndim, nbpe * attndim -> B * T * U * nbpe + tcpgendist = torch.einsum("ntuj,ij->ntui", query, keyvalues) + tcpgendist = tcpgendist / math.sqrt(query.size(-1)) + ptrdist_mask = ptrdist_mask.unsqueeze(1).repeat(1, tcpgendist.size(1), 1, 1) + tcpgendist.masked_fill_(ptrdist_mask.bool(), -1e9) + tcpgendist = torch.nn.functional.softmax(tcpgendist, dim=-1) + # B * T * U * nbpe, nbpe * attndim -> B * T * U * attndim + hptr = torch.einsum("ntui,ij->ntuj", tcpgendist[:, :, :, :-1], keyvalues[:-1, :]) + return hptr, tcpgendist + + def forward_tcpgen(self, targets, ptrdist_mask, source_encodings): + tcpgen_dist = None + if self.DBaverage and self.deepbiasing: + hptr = self.biasingemb(1 - ptrdist_mask[:, :, :-1].float()).unsqueeze(1) + else: + query_char = self.predictor.embedding(targets) + query_char = self.Qproj_char(query_char).unsqueeze(1) # B * 1 * U * attndim + query_acoustic = self.Qproj_acoustic(source_encodings).unsqueeze(2) # B * T * 1 * attndim + query = query_char + query_acoustic # B * T * U * attndim + hptr, tcpgen_dist = self.get_tcpgen_distribution(query, ptrdist_mask) + return hptr, tcpgen_dist + + def get_tcpgen_step_masks(self, yseqs, resettrie): + seqlen = len(yseqs[0]) + batch_masks = yseqs.new_ones(len(yseqs), seqlen, len(self.char_list) + 1) + p_gen_masks = [] + for i, yseq in enumerate(yseqs): + new_tree = resettrie + p_gen_mask = [] + for j, vy in enumerate(yseq): + vy = vy.item() + new_tree = new_tree[0] + if vy in [self.blank_idx]: + new_tree = resettrie + p_gen_mask.append(0) + elif self.char_list[vy].endswith("▁"): + if vy in new_tree and new_tree[vy][0] != {}: + new_tree = new_tree[vy] + else: + new_tree = resettrie + p_gen_mask.append(0) + elif vy not in new_tree: + new_tree = [{}] + p_gen_mask.append(1) + else: + new_tree = new_tree[vy] + p_gen_mask.append(0) + batch_masks[i, j, list(new_tree[0].keys())] = 0 + # In the original paper, ooKB node was not masked + # In this implementation, if not masking ooKB, ooKB probability + # would quickly collapse to 1.0 in the first few updates. + # Haven't found out why this happened. + # batch_masks[i, j, -1] = 0 + p_gen_masks.append(p_gen_mask + [1] * (seqlen - len(p_gen_mask))) + p_gen_masks = torch.Tensor(p_gen_masks).to(yseqs.device).byte() + return batch_masks, p_gen_masks + + def get_tcpgen_step_masks_prefix(self, yseqs, resettrie): + # Implemented for prefix-based wordpieces, not tested yet + seqlen = len(yseqs[0]) + batch_masks = yseqs.new_ones(len(yseqs), seqlen, len(self.char_list) + 1) + p_gen_masks = [] + for i, yseq in enumerate(yseqs): + p_gen_mask = [] + new_tree = resettrie + for j, vy in enumerate(yseq): + vy = vy.item() + new_tree = new_tree[0] + if vy in [self.blank_idx]: + new_tree = resettrie + batch_masks[i, j, list(new_tree[0].keys())] = 0 + elif self.char_list[vy].startswith("▁"): + new_tree = resettrie + if vy not in new_tree[0]: + batch_masks[i, j, list(new_tree[0].keys())] = 0 + else: + new_tree = new_tree[0][vy] + batch_masks[i, j, list(new_tree[0].keys())] = 0 + if new_tree[1] != -1: + batch_masks[i, j, list(resettrie[0].keys())] = 0 + else: + if vy not in new_tree: + new_tree = resettrie + batch_masks[i, j, list(new_tree[0].keys())] = 0 + else: + new_tree = new_tree[vy] + batch_masks[i, j, list(new_tree[0].keys())] = 0 + if new_tree[1] != -1: + batch_masks[i, j, list(resettrie[0].keys())] = 0 + p_gen_mask.append(0) + # batch_masks[i, j, -1] = 0 + p_gen_masks.append(p_gen_mask + [1] * (seqlen - len(p_gen_mask))) + p_gen_masks = torch.Tensor(p_gen_masks).to(yseqs.device).byte() + + return batch_masks, p_gen_masks + + def get_tcpgen_step(self, vy, trie, resettrie): + new_tree = trie[0] + if vy in [self.blank_idx]: + new_tree = resettrie + elif self.char_list[vy].endswith("▁"): + if vy in new_tree and new_tree[vy][0] != {}: + new_tree = new_tree[vy] + else: + new_tree = resettrie + elif vy not in new_tree: + new_tree = [{}] + else: + new_tree = new_tree[vy] + return new_tree + + def join( + self, + source_encodings: torch.Tensor, + source_lengths: torch.Tensor, + target_encodings: torch.Tensor, + target_lengths: torch.Tensor, + hptr: torch.Tensor = None, + ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + r"""Applies joint network to source and target encodings. + + B: batch size; + T: maximum source sequence length in batch; + U: maximum target sequence length in batch; + D: dimension of each source and target sequence encoding. + A: TCPGen attention dimension + + Args: + source_encodings (torch.Tensor): source encoding sequences, with + shape `(B, T, D)`. + source_lengths (torch.Tensor): with shape `(B,)` and i-th element representing + valid sequence length of i-th batch element in ``source_encodings``. + target_encodings (torch.Tensor): target encoding sequences, with shape `(B, U, D)`. + target_lengths (torch.Tensor): with shape `(B,)` and i-th element representing + valid sequence length of i-th batch element in ``target_encodings``. + hptr (torch.Tensor): deep biasing vector with shape `(B, T, U, A)`. + + Returns: + (torch.Tensor, torch.Tensor, torch.Tensor): + torch.Tensor + joint network output, with shape `(B, T, U, output_dim)`. + torch.Tensor + output source lengths, with shape `(B,)` and i-th element representing + number of valid elements along dim 1 for i-th batch element in joint network output. + torch.Tensor + joint network second last layer output, with shape `(B, T, U, D)`. + """ + output, source_lengths, target_lengths, jointer_activation = self.joiner( + source_encodings=source_encodings, + source_lengths=source_lengths, + target_encodings=target_encodings, + target_lengths=target_lengths, + hptr=hptr, + ) + return output, source_lengths, jointer_activation + + +def conformer_rnnt_model( + *, + input_dim: int, + encoding_dim: int, + time_reduction_stride: int, + conformer_input_dim: int, + conformer_ffn_dim: int, + conformer_num_layers: int, + conformer_num_heads: int, + conformer_depthwise_conv_kernel_size: int, + conformer_dropout: float, + num_symbols: int, + symbol_embedding_dim: int, + num_lstm_layers: int, + lstm_hidden_dim: int, + lstm_layer_norm: int, + lstm_layer_norm_epsilon: int, + lstm_dropout: int, + joiner_activation: str, +) -> RNNT: + r"""Builds Conformer-based recurrent neural network transducer (RNN-T) model. + + Args: + input_dim (int): dimension of input sequence frames passed to transcription network. + encoding_dim (int): dimension of transcription- and prediction-network-generated encodings + passed to joint network. + time_reduction_stride (int): factor by which to reduce length of input sequence. + conformer_input_dim (int): dimension of Conformer input. + conformer_ffn_dim (int): hidden layer dimension of each Conformer layer's feedforward network. + conformer_num_layers (int): number of Conformer layers to instantiate. + conformer_num_heads (int): number of attention heads in each Conformer layer. + conformer_depthwise_conv_kernel_size (int): kernel size of each Conformer layer's depthwise convolution layer. + conformer_dropout (float): Conformer dropout probability. + num_symbols (int): cardinality of set of target tokens. + symbol_embedding_dim (int): dimension of each target token embedding. + num_lstm_layers (int): number of LSTM layers to instantiate. + lstm_hidden_dim (int): output dimension of each LSTM layer. + lstm_layer_norm (bool): if ``True``, enables layer normalization for LSTM layers. + lstm_layer_norm_epsilon (float): value of epsilon to use in LSTM layer normalization layers. + lstm_dropout (float): LSTM dropout probability. + joiner_activation (str): activation function to use in the joiner. + Must be one of ("relu", "tanh"). (Default: "relu") + + Returns: + RNNT: + Conformer RNN-T model. + """ + encoder = _ConformerEncoder( + input_dim=input_dim, + output_dim=encoding_dim, + time_reduction_stride=time_reduction_stride, + conformer_input_dim=conformer_input_dim, + conformer_ffn_dim=conformer_ffn_dim, + conformer_num_layers=conformer_num_layers, + conformer_num_heads=conformer_num_heads, + conformer_depthwise_conv_kernel_size=conformer_depthwise_conv_kernel_size, + conformer_dropout=conformer_dropout, + ) + predictor = _Predictor( + num_symbols=num_symbols, + output_dim=encoding_dim, + symbol_embedding_dim=symbol_embedding_dim, + num_lstm_layers=num_lstm_layers, + lstm_hidden_dim=lstm_hidden_dim, + lstm_layer_norm=lstm_layer_norm, + lstm_layer_norm_epsilon=lstm_layer_norm_epsilon, + lstm_dropout=lstm_dropout, + ) + joiner = _Joiner(encoding_dim, num_symbols, activation=joiner_activation) + return RNNT(encoder, predictor, joiner) + + +def conformer_rnnt_base() -> RNNT: + r"""Builds basic version of Conformer RNN-T model. + + Returns: + RNNT: + Conformer RNN-T model. + """ + return conformer_rnnt_model( + input_dim=80, + encoding_dim=1024, + time_reduction_stride=4, + conformer_input_dim=256, + conformer_ffn_dim=1024, + conformer_num_layers=16, + conformer_num_heads=4, + conformer_depthwise_conv_kernel_size=31, + conformer_dropout=0.1, + num_symbols=1024, + symbol_embedding_dim=256, + num_lstm_layers=2, + lstm_hidden_dim=512, + lstm_layer_norm=True, + lstm_layer_norm_epsilon=1e-5, + lstm_dropout=0.3, + joiner_activation="tanh", + ) + + +def conformer_rnnt_biasing( + *, + input_dim: int, + encoding_dim: int, + time_reduction_stride: int, + conformer_input_dim: int, + conformer_ffn_dim: int, + conformer_num_layers: int, + conformer_num_heads: int, + conformer_depthwise_conv_kernel_size: int, + conformer_dropout: float, + num_symbols: int, + symbol_embedding_dim: int, + num_lstm_layers: int, + lstm_hidden_dim: int, + lstm_layer_norm: int, + lstm_layer_norm_epsilon: int, + lstm_dropout: int, + joiner_activation: str, + attndim: int, + biasing: bool, + charlist: List[str], + deepbiasing: bool, + tcpsche: int, + DBaverage: bool, +) -> RNNTBiasing: + r"""Builds Conformer-based recurrent neural network transducer (RNN-T) model. + + Args: + input_dim (int): dimension of input sequence frames passed to transcription network. + encoding_dim (int): dimension of transcription- and prediction-network-generated encodings + passed to joint network. + time_reduction_stride (int): factor by which to reduce length of input sequence. + conformer_input_dim (int): dimension of Conformer input. + conformer_ffn_dim (int): hidden layer dimension of each Conformer layer's feedforward network. + conformer_num_layers (int): number of Conformer layers to instantiate. + conformer_num_heads (int): number of attention heads in each Conformer layer. + conformer_depthwise_conv_kernel_size (int): kernel size of each Conformer layer's depthwise convolution layer. + conformer_dropout (float): Conformer dropout probability. + num_symbols (int): cardinality of set of target tokens. + symbol_embedding_dim (int): dimension of each target token embedding. + num_lstm_layers (int): number of LSTM layers to instantiate. + lstm_hidden_dim (int): output dimension of each LSTM layer. + lstm_layer_norm (bool): if ``True``, enables layer normalization for LSTM layers. + lstm_layer_norm_epsilon (float): value of epsilon to use in LSTM layer normalization layers. + lstm_dropout (float): LSTM dropout probability. + joiner_activation (str): activation function to use in the joiner. + Must be one of ("relu", "tanh"). (Default: "relu") + attndim (int): TCPGen attention dimension + biasing (bool): If true, use biasing, otherwise use standard RNN-T + charlist (list): The list of word piece tokens in the same order as the output layer + deepbiasing (bool): If true, use deep biasing by extracting the biasing vector + tcpsche (int): The epoch at which TCPGen starts to train + DBaverage (bool): If true, instead of TCPGen, use DBRNNT for biasing + + Returns: + RNNT: + Conformer RNN-T model with TCPGen-based biasing support. + """ + encoder = _ConformerEncoder( + input_dim=input_dim, + output_dim=encoding_dim, + time_reduction_stride=time_reduction_stride, + conformer_input_dim=conformer_input_dim, + conformer_ffn_dim=conformer_ffn_dim, + conformer_num_layers=conformer_num_layers, + conformer_num_heads=conformer_num_heads, + conformer_depthwise_conv_kernel_size=conformer_depthwise_conv_kernel_size, + conformer_dropout=conformer_dropout, + ) + predictor = _Predictor( + num_symbols=num_symbols, + output_dim=encoding_dim, + symbol_embedding_dim=symbol_embedding_dim, + num_lstm_layers=num_lstm_layers, + lstm_hidden_dim=lstm_hidden_dim, + lstm_layer_norm=lstm_layer_norm, + lstm_layer_norm_epsilon=lstm_layer_norm_epsilon, + lstm_dropout=lstm_dropout, + ) + joiner = _JoinerBiasing( + encoding_dim, + num_symbols, + activation=joiner_activation, + deepbiasing=deepbiasing, + attndim=attndim, + biasing=biasing, + ) + return RNNTBiasing( + encoder, + predictor, + joiner, + attndim, + biasing, + deepbiasing, + symbol_embedding_dim, + encoding_dim, + charlist, + encoding_dim, + conformer_dropout, + tcpsche, + DBaverage, + ) + + +def conformer_rnnt_biasing_base(charlist=None, biasing=True) -> RNNT: + r"""Builds basic version of Conformer RNN-T model with TCPGen. + + Returns: + RNNT: + Conformer RNN-T model with TCPGen-based biasing support. + """ + return conformer_rnnt_biasing( + input_dim=80, + encoding_dim=576, + time_reduction_stride=4, + conformer_input_dim=144, + conformer_ffn_dim=576, + conformer_num_layers=16, + conformer_num_heads=4, + conformer_depthwise_conv_kernel_size=31, + conformer_dropout=0.1, + num_symbols=601, + symbol_embedding_dim=256, + num_lstm_layers=1, + lstm_hidden_dim=320, + lstm_layer_norm=True, + lstm_layer_norm_epsilon=1e-5, + lstm_dropout=0.3, + joiner_activation="tanh", + attndim=256, + biasing=biasing, + charlist=charlist, + deepbiasing=True, + tcpsche=30, + DBaverage=False, + ) diff --git a/shared/package-files/31/313e8cdbbc0288aed922b9927a7331d0faa2e451d4174b1f5b76c5c9faec8f9b/blob b/shared/package-files/31/313e8cdbbc0288aed922b9927a7331d0faa2e451d4174b1f5b76c5c9faec8f9b/blob new file mode 100644 index 0000000000000000000000000000000000000000..757666875e32ebe79728b293425faaec96117238 --- /dev/null +++ b/shared/package-files/31/313e8cdbbc0288aed922b9927a7331d0faa2e451d4174b1f5b76c5c9faec8f9b/blob @@ -0,0 +1,52 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset sr DAYS_OF_WEEK_ABBREV [list \ + "\u041d\u0435\u0434"\ + "\u041f\u043e\u043d"\ + "\u0423\u0442\u043e"\ + "\u0421\u0440\u0435"\ + "\u0427\u0435\u0442"\ + "\u041f\u0435\u0442"\ + "\u0421\u0443\u0431"] + ::msgcat::mcset sr DAYS_OF_WEEK_FULL [list \ + "\u041d\u0435\u0434\u0435\u0459\u0430"\ + "\u041f\u043e\u043d\u0435\u0434\u0435\u0459\u0430\u043a"\ + "\u0423\u0442\u043e\u0440\u0430\u043a"\ + "\u0421\u0440\u0435\u0434\u0430"\ + "\u0427\u0435\u0442\u0432\u0440\u0442\u0430\u043a"\ + "\u041f\u0435\u0442\u0430\u043a"\ + "\u0421\u0443\u0431\u043e\u0442\u0430"] + ::msgcat::mcset sr MONTHS_ABBREV [list \ + "\u0408\u0430\u043d"\ + "\u0424\u0435\u0431"\ + "\u041c\u0430\u0440"\ + "\u0410\u043f\u0440"\ + "\u041c\u0430\u0458"\ + "\u0408\u0443\u043d"\ + "\u0408\u0443\u043b"\ + "\u0410\u0432\u0433"\ + "\u0421\u0435\u043f"\ + "\u041e\u043a\u0442"\ + "\u041d\u043e\u0432"\ + "\u0414\u0435\u0446"\ + ""] + ::msgcat::mcset sr MONTHS_FULL [list \ + "\u0408\u0430\u043d\u0443\u0430\u0440"\ + "\u0424\u0435\u0431\u0440\u0443\u0430\u0440"\ + "\u041c\u0430\u0440\u0442"\ + "\u0410\u043f\u0440\u0438\u043b"\ + "\u041c\u0430\u0458"\ + "\u0408\u0443\u043d\u0438"\ + "\u0408\u0443\u043b\u0438"\ + "\u0410\u0432\u0433\u0443\u0441\u0442"\ + "\u0421\u0435\u043f\u0442\u0435\u043c\u0431\u0430\u0440"\ + "\u041e\u043a\u0442\u043e\u0431\u0430\u0440"\ + "\u041d\u043e\u0432\u0435\u043c\u0431\u0430\u0440"\ + "\u0414\u0435\u0446\u0435\u043c\u0431\u0430\u0440"\ + ""] + ::msgcat::mcset sr BCE "\u043f. \u043d. \u0435." + ::msgcat::mcset sr CE "\u043d. \u0435" + ::msgcat::mcset sr DATE_FORMAT "%Y.%m.%e" + ::msgcat::mcset sr TIME_FORMAT "%k.%M.%S" + ::msgcat::mcset sr DATE_TIME_FORMAT "%Y.%m.%e %k.%M.%S %z" +} diff --git a/shared/package-files/31/3140981eb03466a162484fcf8c81a525980cbafefd694810a84ec3b6ede4ba8d/blob b/shared/package-files/31/3140981eb03466a162484fcf8c81a525980cbafefd694810a84ec3b6ede4ba8d/blob new file mode 100644 index 0000000000000000000000000000000000000000..bd5f93f0e48d5d993b349c160cb2efac071e8599 Binary files /dev/null and b/shared/package-files/31/3140981eb03466a162484fcf8c81a525980cbafefd694810a84ec3b6ede4ba8d/blob differ diff --git a/shared/package-files/31/31423556bf21042536a1b6391128848ec177eb5fa403017772a5c821bae172bb/blob b/shared/package-files/31/31423556bf21042536a1b6391128848ec177eb5fa403017772a5c821bae172bb/blob new file mode 100644 index 0000000000000000000000000000000000000000..0453e1438e29128f0e0d6b9fea0a5b286a4e42b3 Binary files /dev/null and b/shared/package-files/31/31423556bf21042536a1b6391128848ec177eb5fa403017772a5c821bae172bb/blob differ diff --git a/shared/package-files/31/31446114601ffe7ff29aceb87ae5e938605e118dfddf6b626de1fd824c43b107/blob b/shared/package-files/31/31446114601ffe7ff29aceb87ae5e938605e118dfddf6b626de1fd824c43b107/blob new file mode 100644 index 0000000000000000000000000000000000000000..1e909c2a77d3a752bd681c583b897fc821739bec --- /dev/null +++ b/shared/package-files/31/31446114601ffe7ff29aceb87ae5e938605e118dfddf6b626de1fd824c43b107/blob @@ -0,0 +1,8 @@ +from typing import MutableSequence, Optional, Sequence, TypeVar + +_T = TypeVar("_T") + +def bisect_left(a: Sequence[_T], x: _T, lo: int = ..., hi: Optional[int] = ...) -> int: ... +def bisect_right(a: Sequence[_T], x: _T, lo: int = ..., hi: Optional[int] = ...) -> int: ... +def insort_left(a: MutableSequence[_T], x: _T, lo: int = ..., hi: Optional[int] = ...) -> None: ... +def insort_right(a: MutableSequence[_T], x: _T, lo: int = ..., hi: Optional[int] = ...) -> None: ... diff --git a/shared/package-files/31/3147b27ccfe731801891ab067db63b23fd79266c1fb5a663b1eb8fd4be37313d/blob b/shared/package-files/31/3147b27ccfe731801891ab067db63b23fd79266c1fb5a663b1eb8fd4be37313d/blob new file mode 100644 index 0000000000000000000000000000000000000000..03ccaa770431324d68b42ae13e21ac48abeb71dd --- /dev/null +++ b/shared/package-files/31/3147b27ccfe731801891ab067db63b23fd79266c1fb5a663b1eb8fd4be37313d/blob @@ -0,0 +1,92 @@ +# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license + +import importlib.metadata +import itertools +import string +from typing import Dict, List, Tuple + + +def _tuple_from_text(version: str) -> Tuple: + text_parts = version.split(".") + int_parts = [] + for text_part in text_parts: + digit_prefix = "".join( + itertools.takewhile(lambda x: x in string.digits, text_part) + ) + try: + int_parts.append(int(digit_prefix)) + except Exception: + break + return tuple(int_parts) + + +def _version_check( + requirement: str, +) -> bool: + """Is the requirement fulfilled? + + The requirement must be of the form + + package>=version + """ + package, minimum = requirement.split(">=") + try: + version = importlib.metadata.version(package) + except Exception: + return False + t_version = _tuple_from_text(version) + t_minimum = _tuple_from_text(minimum) + if t_version < t_minimum: + return False + return True + + +_cache: Dict[str, bool] = {} + + +def have(feature: str) -> bool: + """Is *feature* available? + + This tests if all optional packages needed for the + feature are available and recent enough. + + Returns ``True`` if the feature is available, + and ``False`` if it is not or if metadata is + missing. + """ + value = _cache.get(feature) + if value is not None: + return value + requirements = _requirements.get(feature) + if requirements is None: + # we make a cache entry here for consistency not performance + _cache[feature] = False + return False + ok = True + for requirement in requirements: + if not _version_check(requirement): + ok = False + break + _cache[feature] = ok + return ok + + +def force(feature: str, enabled: bool) -> None: + """Force the status of *feature* to be *enabled*. + + This method is provided as a workaround for any cases + where importlib.metadata is ineffective, or for testing. + """ + _cache[feature] = enabled + + +_requirements: Dict[str, List[str]] = { + ### BEGIN generated requirements + "dnssec": ["cryptography>=41"], + "doh": ["httpcore>=1.0.0", "httpx>=0.26.0", "h2>=4.1.0"], + "doq": ["aioquic>=0.9.25"], + "idna": ["idna>=3.6"], + "trio": ["trio>=0.23"], + "wmi": ["wmi>=1.5.1"], + ### END generated requirements +} diff --git a/shared/package-files/31/3147c222dab7ff2cdbf724627863a09699f463be21f0803b9b98bbd01eb78917/blob b/shared/package-files/31/3147c222dab7ff2cdbf724627863a09699f463be21f0803b9b98bbd01eb78917/blob new file mode 100644 index 0000000000000000000000000000000000000000..bb0318c40e72343d52227ef29048224b5c7177ae Binary files /dev/null and b/shared/package-files/31/3147c222dab7ff2cdbf724627863a09699f463be21f0803b9b98bbd01eb78917/blob differ diff --git a/shared/package-files/31/31483a6f213bdbbf38108a84e803d36d05125d6da4816b0f94452b6cc992277c/blob b/shared/package-files/31/31483a6f213bdbbf38108a84e803d36d05125d6da4816b0f94452b6cc992277c/blob new file mode 100644 index 0000000000000000000000000000000000000000..5a48c737ffb349b6d1c2a64cb7082336eb49d580 --- /dev/null +++ b/shared/package-files/31/31483a6f213bdbbf38108a84e803d36d05125d6da4816b0f94452b6cc992277c/blob @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor _histogramdd_from_bin_cts(const at::Tensor & self, at::IntArrayRef bins, c10::optional> range=c10::nullopt, const c10::optional & weight={}, bool density=false); + +} // namespace cpu +} // namespace at diff --git a/shared/package-files/31/314871f445610aea3e7d3398447da7ce1407f22a7dfb941a34c8c43d6c7e348e/blob b/shared/package-files/31/314871f445610aea3e7d3398447da7ce1407f22a7dfb941a34c8c43d6c7e348e/blob new file mode 100644 index 0000000000000000000000000000000000000000..6564e381af0ea9b821e44f780ce209936f9524dc --- /dev/null +++ b/shared/package-files/31/314871f445610aea3e7d3398447da7ce1407f22a7dfb941a34c8c43d6c7e348e/blob @@ -0,0 +1,504 @@ +from copy import ( + copy, + deepcopy, +) + +import numpy as np +import pytest + +from pandas.core.dtypes.common import is_scalar + +from pandas import ( + DataFrame, + Index, + Series, + date_range, +) +import pandas._testing as tm + +# ---------------------------------------------------------------------- +# Generic types test cases + + +def construct(box, shape, value=None, dtype=None, **kwargs): + """ + construct an object for the given shape + if value is specified use that if its a scalar + if value is an array, repeat it as needed + """ + if isinstance(shape, int): + shape = tuple([shape] * box._AXIS_LEN) + if value is not None: + if is_scalar(value): + if value == "empty": + arr = None + dtype = np.float64 + + # remove the info axis + kwargs.pop(box._info_axis_name, None) + else: + arr = np.empty(shape, dtype=dtype) + arr.fill(value) + else: + fshape = np.prod(shape) + arr = value.ravel() + new_shape = fshape / arr.shape[0] + if fshape % arr.shape[0] != 0: + raise Exception("invalid value passed in construct") + + arr = np.repeat(arr, new_shape).reshape(shape) + else: + arr = np.random.default_rng(2).standard_normal(shape) + return box(arr, dtype=dtype, **kwargs) + + +class TestGeneric: + @pytest.mark.parametrize( + "func", + [ + str.lower, + {x: x.lower() for x in list("ABCD")}, + Series({x: x.lower() for x in list("ABCD")}), + ], + ) + def test_rename(self, frame_or_series, func): + # single axis + idx = list("ABCD") + + for axis in frame_or_series._AXIS_ORDERS: + kwargs = {axis: idx} + obj = construct(frame_or_series, 4, **kwargs) + + # rename a single axis + result = obj.rename(**{axis: func}) + expected = obj.copy() + setattr(expected, axis, list("abcd")) + tm.assert_equal(result, expected) + + def test_get_numeric_data(self, frame_or_series): + n = 4 + kwargs = { + frame_or_series._get_axis_name(i): list(range(n)) + for i in range(frame_or_series._AXIS_LEN) + } + + # get the numeric data + o = construct(frame_or_series, n, **kwargs) + result = o._get_numeric_data() + tm.assert_equal(result, o) + + # non-inclusion + result = o._get_bool_data() + expected = construct(frame_or_series, n, value="empty", **kwargs) + if isinstance(o, DataFrame): + # preserve columns dtype + expected.columns = o.columns[:0] + # https://github.com/pandas-dev/pandas/issues/50862 + tm.assert_equal(result.reset_index(drop=True), expected) + + # get the bool data + arr = np.array([True, True, False, True]) + o = construct(frame_or_series, n, value=arr, **kwargs) + result = o._get_numeric_data() + tm.assert_equal(result, o) + + def test_nonzero(self, frame_or_series): + # GH 4633 + # look at the boolean/nonzero behavior for objects + obj = construct(frame_or_series, shape=4) + msg = f"The truth value of a {frame_or_series.__name__} is ambiguous" + with pytest.raises(ValueError, match=msg): + bool(obj == 0) + with pytest.raises(ValueError, match=msg): + bool(obj == 1) + with pytest.raises(ValueError, match=msg): + bool(obj) + + obj = construct(frame_or_series, shape=4, value=1) + with pytest.raises(ValueError, match=msg): + bool(obj == 0) + with pytest.raises(ValueError, match=msg): + bool(obj == 1) + with pytest.raises(ValueError, match=msg): + bool(obj) + + obj = construct(frame_or_series, shape=4, value=np.nan) + with pytest.raises(ValueError, match=msg): + bool(obj == 0) + with pytest.raises(ValueError, match=msg): + bool(obj == 1) + with pytest.raises(ValueError, match=msg): + bool(obj) + + # empty + obj = construct(frame_or_series, shape=0) + with pytest.raises(ValueError, match=msg): + bool(obj) + + # invalid behaviors + + obj1 = construct(frame_or_series, shape=4, value=1) + obj2 = construct(frame_or_series, shape=4, value=1) + + with pytest.raises(ValueError, match=msg): + if obj1: + pass + + with pytest.raises(ValueError, match=msg): + obj1 and obj2 + with pytest.raises(ValueError, match=msg): + obj1 or obj2 + with pytest.raises(ValueError, match=msg): + not obj1 + + def test_frame_or_series_compound_dtypes(self, frame_or_series): + # see gh-5191 + # Compound dtypes should raise NotImplementedError. + + def f(dtype): + return construct(frame_or_series, shape=3, value=1, dtype=dtype) + + msg = ( + "compound dtypes are not implemented " + f"in the {frame_or_series.__name__} constructor" + ) + + with pytest.raises(NotImplementedError, match=msg): + f([("A", "datetime64[h]"), ("B", "str"), ("C", "int32")]) + + # these work (though results may be unexpected) + f("int64") + f("float64") + f("M8[ns]") + + def test_metadata_propagation(self, frame_or_series): + # check that the metadata matches up on the resulting ops + + o = construct(frame_or_series, shape=3) + o.name = "foo" + o2 = construct(frame_or_series, shape=3) + o2.name = "bar" + + # ---------- + # preserving + # ---------- + + # simple ops with scalars + for op in ["__add__", "__sub__", "__truediv__", "__mul__"]: + result = getattr(o, op)(1) + tm.assert_metadata_equivalent(o, result) + + # ops with like + for op in ["__add__", "__sub__", "__truediv__", "__mul__"]: + result = getattr(o, op)(o) + tm.assert_metadata_equivalent(o, result) + + # simple boolean + for op in ["__eq__", "__le__", "__ge__"]: + v1 = getattr(o, op)(o) + tm.assert_metadata_equivalent(o, v1) + tm.assert_metadata_equivalent(o, v1 & v1) + tm.assert_metadata_equivalent(o, v1 | v1) + + # combine_first + result = o.combine_first(o2) + tm.assert_metadata_equivalent(o, result) + + # --------------------------- + # non-preserving (by default) + # --------------------------- + + # add non-like + result = o + o2 + tm.assert_metadata_equivalent(result) + + # simple boolean + for op in ["__eq__", "__le__", "__ge__"]: + # this is a name matching op + v1 = getattr(o, op)(o) + v2 = getattr(o, op)(o2) + tm.assert_metadata_equivalent(v2) + tm.assert_metadata_equivalent(v1 & v2) + tm.assert_metadata_equivalent(v1 | v2) + + def test_size_compat(self, frame_or_series): + # GH8846 + # size property should be defined + + o = construct(frame_or_series, shape=10) + assert o.size == np.prod(o.shape) + assert o.size == 10 ** len(o.axes) + + def test_split_compat(self, frame_or_series): + # xref GH8846 + o = construct(frame_or_series, shape=10) + with tm.assert_produces_warning( + FutureWarning, match=".swapaxes' is deprecated", check_stacklevel=False + ): + assert len(np.array_split(o, 5)) == 5 + assert len(np.array_split(o, 2)) == 2 + + # See gh-12301 + def test_stat_unexpected_keyword(self, frame_or_series): + obj = construct(frame_or_series, 5) + starwars = "Star Wars" + errmsg = "unexpected keyword" + + with pytest.raises(TypeError, match=errmsg): + obj.max(epic=starwars) # stat_function + with pytest.raises(TypeError, match=errmsg): + obj.var(epic=starwars) # stat_function_ddof + with pytest.raises(TypeError, match=errmsg): + obj.sum(epic=starwars) # cum_function + with pytest.raises(TypeError, match=errmsg): + obj.any(epic=starwars) # logical_function + + @pytest.mark.parametrize("func", ["sum", "cumsum", "any", "var"]) + def test_api_compat(self, func, frame_or_series): + # GH 12021 + # compat for __name__, __qualname__ + + obj = construct(frame_or_series, 5) + f = getattr(obj, func) + assert f.__name__ == func + assert f.__qualname__.endswith(func) + + def test_stat_non_defaults_args(self, frame_or_series): + obj = construct(frame_or_series, 5) + out = np.array([0]) + errmsg = "the 'out' parameter is not supported" + + with pytest.raises(ValueError, match=errmsg): + obj.max(out=out) # stat_function + with pytest.raises(ValueError, match=errmsg): + obj.var(out=out) # stat_function_ddof + with pytest.raises(ValueError, match=errmsg): + obj.sum(out=out) # cum_function + with pytest.raises(ValueError, match=errmsg): + obj.any(out=out) # logical_function + + def test_truncate_out_of_bounds(self, frame_or_series): + # GH11382 + + # small + shape = [2000] + ([1] * (frame_or_series._AXIS_LEN - 1)) + small = construct(frame_or_series, shape, dtype="int8", value=1) + tm.assert_equal(small.truncate(), small) + tm.assert_equal(small.truncate(before=0, after=3e3), small) + tm.assert_equal(small.truncate(before=-1, after=2e3), small) + + # big + shape = [2_000_000] + ([1] * (frame_or_series._AXIS_LEN - 1)) + big = construct(frame_or_series, shape, dtype="int8", value=1) + tm.assert_equal(big.truncate(), big) + tm.assert_equal(big.truncate(before=0, after=3e6), big) + tm.assert_equal(big.truncate(before=-1, after=2e6), big) + + @pytest.mark.parametrize( + "func", + [copy, deepcopy, lambda x: x.copy(deep=False), lambda x: x.copy(deep=True)], + ) + @pytest.mark.parametrize("shape", [0, 1, 2]) + def test_copy_and_deepcopy(self, frame_or_series, shape, func): + # GH 15444 + obj = construct(frame_or_series, shape) + obj_copy = func(obj) + assert obj_copy is not obj + tm.assert_equal(obj_copy, obj) + + def test_data_deprecated(self, frame_or_series): + obj = frame_or_series() + msg = "(Series|DataFrame)._data is deprecated" + with tm.assert_produces_warning(DeprecationWarning, match=msg): + mgr = obj._data + assert mgr is obj._mgr + + +class TestNDFrame: + # tests that don't fit elsewhere + + @pytest.mark.parametrize( + "ser", + [ + Series(range(10), dtype=np.float64), + Series([str(i) for i in range(10)], dtype=object), + ], + ) + def test_squeeze_series_noop(self, ser): + # noop + tm.assert_series_equal(ser.squeeze(), ser) + + def test_squeeze_frame_noop(self): + # noop + df = DataFrame(np.eye(2)) + tm.assert_frame_equal(df.squeeze(), df) + + def test_squeeze_frame_reindex(self): + # squeezing + df = DataFrame( + np.random.default_rng(2).standard_normal((10, 4)), + columns=Index(list("ABCD"), dtype=object), + index=date_range("2000-01-01", periods=10, freq="B"), + ).reindex(columns=["A"]) + tm.assert_series_equal(df.squeeze(), df["A"]) + + def test_squeeze_0_len_dim(self): + # don't fail with 0 length dimensions GH11229 & GH8999 + empty_series = Series([], name="five", dtype=np.float64) + empty_frame = DataFrame([empty_series]) + tm.assert_series_equal(empty_series, empty_series.squeeze()) + tm.assert_series_equal(empty_series, empty_frame.squeeze()) + + def test_squeeze_axis(self): + # axis argument + df = DataFrame( + np.random.default_rng(2).standard_normal((1, 4)), + columns=Index(list("ABCD"), dtype=object), + index=date_range("2000-01-01", periods=1, freq="B"), + ).iloc[:, :1] + assert df.shape == (1, 1) + tm.assert_series_equal(df.squeeze(axis=0), df.iloc[0]) + tm.assert_series_equal(df.squeeze(axis="index"), df.iloc[0]) + tm.assert_series_equal(df.squeeze(axis=1), df.iloc[:, 0]) + tm.assert_series_equal(df.squeeze(axis="columns"), df.iloc[:, 0]) + assert df.squeeze() == df.iloc[0, 0] + msg = "No axis named 2 for object type DataFrame" + with pytest.raises(ValueError, match=msg): + df.squeeze(axis=2) + msg = "No axis named x for object type DataFrame" + with pytest.raises(ValueError, match=msg): + df.squeeze(axis="x") + + def test_squeeze_axis_len_3(self): + df = DataFrame( + np.random.default_rng(2).standard_normal((3, 4)), + columns=Index(list("ABCD"), dtype=object), + index=date_range("2000-01-01", periods=3, freq="B"), + ) + tm.assert_frame_equal(df.squeeze(axis=0), df) + + def test_numpy_squeeze(self): + s = Series(range(2), dtype=np.float64) + tm.assert_series_equal(np.squeeze(s), s) + + df = DataFrame( + np.random.default_rng(2).standard_normal((10, 4)), + columns=Index(list("ABCD"), dtype=object), + index=date_range("2000-01-01", periods=10, freq="B"), + ).reindex(columns=["A"]) + tm.assert_series_equal(np.squeeze(df), df["A"]) + + @pytest.mark.parametrize( + "ser", + [ + Series(range(10), dtype=np.float64), + Series([str(i) for i in range(10)], dtype=object), + ], + ) + def test_transpose_series(self, ser): + # calls implementation in pandas/core/base.py + tm.assert_series_equal(ser.transpose(), ser) + + def test_transpose_frame(self): + df = DataFrame( + np.random.default_rng(2).standard_normal((10, 4)), + columns=Index(list("ABCD"), dtype=object), + index=date_range("2000-01-01", periods=10, freq="B"), + ) + tm.assert_frame_equal(df.transpose().transpose(), df) + + def test_numpy_transpose(self, frame_or_series): + obj = DataFrame( + np.random.default_rng(2).standard_normal((10, 4)), + columns=Index(list("ABCD"), dtype=object), + index=date_range("2000-01-01", periods=10, freq="B"), + ) + obj = tm.get_obj(obj, frame_or_series) + + if frame_or_series is Series: + # 1D -> np.transpose is no-op + tm.assert_series_equal(np.transpose(obj), obj) + + # round-trip preserved + tm.assert_equal(np.transpose(np.transpose(obj)), obj) + + msg = "the 'axes' parameter is not supported" + with pytest.raises(ValueError, match=msg): + np.transpose(obj, axes=1) + + @pytest.mark.parametrize( + "ser", + [ + Series(range(10), dtype=np.float64), + Series([str(i) for i in range(10)], dtype=object), + ], + ) + def test_take_series(self, ser): + indices = [1, 5, -2, 6, 3, -1] + out = ser.take(indices) + expected = Series( + data=ser.values.take(indices), + index=ser.index.take(indices), + dtype=ser.dtype, + ) + tm.assert_series_equal(out, expected) + + def test_take_frame(self): + indices = [1, 5, -2, 6, 3, -1] + df = DataFrame( + np.random.default_rng(2).standard_normal((10, 4)), + columns=Index(list("ABCD"), dtype=object), + index=date_range("2000-01-01", periods=10, freq="B"), + ) + out = df.take(indices) + expected = DataFrame( + data=df.values.take(indices, axis=0), + index=df.index.take(indices), + columns=df.columns, + ) + tm.assert_frame_equal(out, expected) + + def test_take_invalid_kwargs(self, frame_or_series): + indices = [-3, 2, 0, 1] + + obj = DataFrame(range(5)) + obj = tm.get_obj(obj, frame_or_series) + + msg = r"take\(\) got an unexpected keyword argument 'foo'" + with pytest.raises(TypeError, match=msg): + obj.take(indices, foo=2) + + msg = "the 'out' parameter is not supported" + with pytest.raises(ValueError, match=msg): + obj.take(indices, out=indices) + + msg = "the 'mode' parameter is not supported" + with pytest.raises(ValueError, match=msg): + obj.take(indices, mode="clip") + + def test_axis_classmethods(self, frame_or_series): + box = frame_or_series + obj = box(dtype=object) + values = box._AXIS_TO_AXIS_NUMBER.keys() + for v in values: + assert obj._get_axis_number(v) == box._get_axis_number(v) + assert obj._get_axis_name(v) == box._get_axis_name(v) + assert obj._get_block_manager_axis(v) == box._get_block_manager_axis(v) + + def test_flags_identity(self, frame_or_series): + obj = Series([1, 2]) + if frame_or_series is DataFrame: + obj = obj.to_frame() + + assert obj.flags is obj.flags + obj2 = obj.copy() + assert obj2.flags is not obj.flags + + def test_bool_dep(self) -> None: + # GH-51749 + msg_warn = ( + "DataFrame.bool is now deprecated and will be removed " + "in future version of pandas" + ) + with tm.assert_produces_warning(FutureWarning, match=msg_warn): + DataFrame({"col": [False]}).bool() diff --git a/shared/package-files/31/314c2dcb3bbbc63931f6605c4bae526837022bbb607aa4208fe29810cc5c1d67/blob b/shared/package-files/31/314c2dcb3bbbc63931f6605c4bae526837022bbb607aa4208fe29810cc5c1d67/blob new file mode 100644 index 0000000000000000000000000000000000000000..a33cdf8610dd6aa3b22bc24eef8ea3f871b8be9f --- /dev/null +++ b/shared/package-files/31/314c2dcb3bbbc63931f6605c4bae526837022bbb607aa4208fe29810cc5c1d67/blob @@ -0,0 +1,18 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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. + +#include "arrow/vendored/xxhash/xxhash.h" diff --git a/shared/package-files/31/314c6060df0dd98a74ad6a7ada329034058396b0353000767fd6f04e08e170ec/blob b/shared/package-files/31/314c6060df0dd98a74ad6a7ada329034058396b0353000767fd6f04e08e170ec/blob new file mode 100644 index 0000000000000000000000000000000000000000..dfaec55e3bfe6dc3bc70c27f184994b234ffa0e8 --- /dev/null +++ b/shared/package-files/31/314c6060df0dd98a74ad6a7ada329034058396b0353000767fd6f04e08e170ec/blob @@ -0,0 +1,39 @@ +#pragma once + +// @generated by torchgen/gen.py from Function.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include + +namespace at { + + +// aten::trace(Tensor self) -> Tensor +inline at::Tensor trace(const at::Tensor & self) { + return at::_ops::trace::call(self); +} + +// aten::trace.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & trace_out(at::Tensor & out, const at::Tensor & self) { + return at::_ops::trace_out::call(self, out); +} +// aten::trace.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!) +inline at::Tensor & trace_outf(const at::Tensor & self, at::Tensor & out) { + return at::_ops::trace_out::call(self, out); +} + +} diff --git a/shared/package-files/31/314c84a495139e61a0d0495a867455303fb5fd5a7db31a72d7bee3716f80b1e8/blob b/shared/package-files/31/314c84a495139e61a0d0495a867455303fb5fd5a7db31a72d7bee3716f80b1e8/blob new file mode 100644 index 0000000000000000000000000000000000000000..c86e0483fe12b93729d646b76a46d758e8e76029 --- /dev/null +++ b/shared/package-files/31/314c84a495139e61a0d0495a867455303fb5fd5a7db31a72d7bee3716f80b1e8/blob @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor & uniform_(at::Tensor & self, double from=0, double to=1, c10::optional generator=c10::nullopt); + +} // namespace cpu +} // namespace at diff --git a/shared/package-files/31/314e4e91be3baa93c0fb4bccc9e4e97cd643eb839b065af921782c2175fe9909/blob b/shared/package-files/31/314e4e91be3baa93c0fb4bccc9e4e97cd643eb839b065af921782c2175fe9909/blob new file mode 100644 index 0000000000000000000000000000000000000000..119a1f205aa85f584e0dbc04d7b34deaebe9199d --- /dev/null +++ b/shared/package-files/31/314e4e91be3baa93c0fb4bccc9e4e97cd643eb839b065af921782c2175fe9909/blob @@ -0,0 +1,19 @@ +Copyright (c) 2023 Julian Berman + +Permission is hereby granted, free of charge, to any 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 shall be included in +all 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. diff --git a/shared/package-files/31/314f4180c05de4a4860f65af6460900fff77f12c08edd728f68ca0065126b9ae/blob b/shared/package-files/31/314f4180c05de4a4860f65af6460900fff77f12c08edd728f68ca0065126b9ae/blob new file mode 100644 index 0000000000000000000000000000000000000000..e5e68d925876c5840eab2616674ef5df913078e2 --- /dev/null +++ b/shared/package-files/31/314f4180c05de4a4860f65af6460900fff77f12c08edd728f68ca0065126b9ae/blob @@ -0,0 +1,54 @@ +# created by tools/loadICU.tcl -- do not edit +namespace eval ::tcl::clock { + ::msgcat::mcset hu DAYS_OF_WEEK_ABBREV [list \ + "V"\ + "H"\ + "K"\ + "Sze"\ + "Cs"\ + "P"\ + "Szo"] + ::msgcat::mcset hu DAYS_OF_WEEK_FULL [list \ + "vas\u00e1rnap"\ + "h\u00e9tf\u0151"\ + "kedd"\ + "szerda"\ + "cs\u00fct\u00f6rt\u00f6k"\ + "p\u00e9ntek"\ + "szombat"] + ::msgcat::mcset hu MONTHS_ABBREV [list \ + "jan."\ + "febr."\ + "m\u00e1rc."\ + "\u00e1pr."\ + "m\u00e1j."\ + "j\u00fan."\ + "j\u00fal."\ + "aug."\ + "szept."\ + "okt."\ + "nov."\ + "dec."\ + ""] + ::msgcat::mcset hu MONTHS_FULL [list \ + "janu\u00e1r"\ + "febru\u00e1r"\ + "m\u00e1rcius"\ + "\u00e1prilis"\ + "m\u00e1jus"\ + "j\u00fanius"\ + "j\u00falius"\ + "augusztus"\ + "szeptember"\ + "okt\u00f3ber"\ + "november"\ + "december"\ + ""] + ::msgcat::mcset hu BCE "i.e." + ::msgcat::mcset hu CE "i.u." + ::msgcat::mcset hu AM "DE" + ::msgcat::mcset hu PM "DU" + ::msgcat::mcset hu DATE_FORMAT "%Y.%m.%d." + ::msgcat::mcset hu TIME_FORMAT "%k:%M:%S" + ::msgcat::mcset hu DATE_TIME_FORMAT "%Y.%m.%d. %k:%M:%S %z" +} diff --git a/shared/package-files/31/3153db569db686645f714e3060e9d60dad0ec6567e1722784732a6b25ecd4f37/blob b/shared/package-files/31/3153db569db686645f714e3060e9d60dad0ec6567e1722784732a6b25ecd4f37/blob new file mode 100644 index 0000000000000000000000000000000000000000..5f58b55c26fe2add41fac2085caaf4c1161b16c7 --- /dev/null +++ b/shared/package-files/31/3153db569db686645f714e3060e9d60dad0ec6567e1722784732a6b25ecd4f37/blob @@ -0,0 +1,465 @@ +import warnings + +import numpy as np +import pandas as pd +from scipy.sparse import issparse +from tqdm.auto import tqdm + +from .. import links, maskers +from ..utils._exceptions import ( + DimensionError, + InvalidFeaturePerturbationError, + InvalidModelError, +) +from ._explainer import Explainer + + +class LinearExplainer(Explainer): + """Computes SHAP values for a linear model, optionally accounting for inter-feature correlations. + + This computes the SHAP values for a linear model and can account for the + correlations among the input features. Assuming features are independent + leads to interventional SHAP values which for a linear model are ``coef[i] * + (x[i] - X.mean(0)[i])`` for the ith feature. If instead we account for + correlations, then we prevent any problems arising from collinearity and + share credit among correlated features. Accounting for correlations can be + computationally challenging, but ``LinearExplainer`` uses sampling to + estimate a transform that can then be applied to explain any prediction of + the model. + + Parameters + ---------- + model : (coef, intercept) or sklearn.linear_model.* + User supplied linear model either as either a parameter pair or sklearn object. + + masker : function, numpy.array, pandas.DataFrame, tuple of (mean, cov), shap.maskers.Masker + A callable Python object used to "mask" out hidden features of the form + ``masker(binary_mask, x)``. It takes a single input sample and a binary + mask and returns a matrix of masked samples. These masked samples are + evaluated using the model function and the outputs are then averaged. + + As a shortcut for the standard masking using by SHAP you can pass a + background data matrix instead of a function and that matrix will be + used for masking. + + You can also provide a tuple of ``(mean, covariance)``, or pass in a + masker meant for tabular data (i.e., :class:`.maskers.Independent`, + :class:`.maskers.Impute`, or :class:`.maskers.Partition`) directly. + + data : (mean, cov), numpy.array, pandas.DataFrame, iml.DenseData or scipy.csr_matrix + The background dataset to use for computing conditional expectations. + Note that only the mean and covariance of the dataset are used. This + means passing a raw data matrix is just a convenient alternative to + passing the mean and covariance directly. + + nsamples : int + Number of samples to use when estimating the transformation matrix used + to account for feature correlations. + + feature_perturbation : None (default), "interventional" or "correlation_dependent" + + DEPRECATED: this option is now deprecated in favor of using the appropriate + tabular masker and will be removed in a future release. + + There are two ways we might want to compute SHAP values, either the full + conditional SHAP values or the interventional SHAP values. + + - For interventional SHAP values we break any dependence structure between + features in the model and so uncover how the model would behave if we + intervened and changed some of the inputs. This approach is used by the + Independent and Partition maskers. + - For the full conditional SHAP values we respect the correlations among the + input features, so if the model depends on one input but that input is + correlated with another input, then both get some credit for the model's + behavior. This approach is used by the Impute masker. + + The interventional option stays "true to the model" meaning it will only + give credit to features that are actually used by the model, while the + correlation option stays "true to the data" in the sense that it only + considers how the model would behave when respecting the correlations in + the input data. For sparse case only interventional option is supported. + + + Examples + -------- + See `Linear explainer examples `_ + + """ + + def __init__(self, model, masker, link=links.identity, nsamples=1000, feature_perturbation=None, **kwargs): + if "feature_dependence" in kwargs: + emsg = "The option feature_dependence has been renamed to feature_perturbation!" + raise ValueError(emsg) + + if feature_perturbation is not None: # pragma: no cover + wmsg = ( + "The feature_perturbation option is now deprecated in favor of using the appropriate " + "masker (maskers.Independent, maskers.Partition or maskers.Impute)." + ) + warnings.warn(wmsg, FutureWarning) + else: + feature_perturbation = "interventional" + + if feature_perturbation not in ("interventional", "correlation_dependent"): + emsg = "feature_perturbation must be one of 'interventional' or 'correlation_dependent'" + raise InvalidFeaturePerturbationError(emsg) + self.feature_perturbation = feature_perturbation + + # wrap the incoming masker object as a shap.Masker object before calling + # parent class constructor, which does the same but without respecting + # the user-provided feature_perturbation choice + if isinstance(masker, pd.DataFrame) or ( + (isinstance(masker, np.ndarray) or issparse(masker)) and len(masker.shape) == 2 + ): + if self.feature_perturbation == "correlation_dependent": + masker = maskers.Impute(masker) + else: + masker = maskers.Independent(masker) + elif issubclass(type(masker), tuple) and len(masker) == 2: + if self.feature_perturbation == "correlation_dependent": + masker = maskers.Impute({"mean": masker[0], "cov": masker[1]}, method="linear") + else: + masker = maskers.Independent({"mean": masker[0], "cov": masker[1]}) + + super().__init__(model, masker, link=link, **kwargs) + + self.nsamples = nsamples + + # extract what we need from the given model object + self.coef, self.intercept = LinearExplainer._parse_model(model) + + # extract the data + if issubclass(type(self.masker), (maskers.Independent, maskers.Partition)): + self.feature_perturbation = "interventional" + elif issubclass(type(self.masker), maskers.Impute): + self.feature_perturbation = "correlation_dependent" + else: + raise NotImplementedError( + "The Linear explainer only supports the Independent, Partition, and Impute maskers right now!" + ) + data = getattr(self.masker, "data", None) + + # convert DataFrame's to numpy arrays + if isinstance(data, pd.DataFrame): + data = data.values + + # get the mean and covariance of the model + if getattr(self.masker, "mean", None) is not None: + self.mean = self.masker.mean + self.cov = self.masker.cov + elif isinstance(data, dict) and len(data) == 2: + self.mean = data["mean"] + if isinstance(self.mean, pd.Series): + self.mean = self.mean.values + + self.cov = data["cov"] + if isinstance(self.cov, pd.DataFrame): + self.cov = self.cov.values + elif isinstance(data, tuple) and len(data) == 2: + self.mean = data[0] + if isinstance(self.mean, pd.Series): + self.mean = self.mean.values + + self.cov = data[1] + if isinstance(self.cov, pd.DataFrame): + self.cov = self.cov.values + elif data is None: + raise ValueError("A background data distribution must be provided!") + else: + if issparse(data): + self.mean = np.array(np.mean(data, 0))[0] + if self.feature_perturbation != "interventional": + raise NotImplementedError( + "Only feature_perturbation = 'interventional' is supported for sparse data" + ) + else: + self.mean = np.array(np.mean(data, 0)).flatten() # assumes it is an array + if self.feature_perturbation == "correlation_dependent": + self.cov = np.cov(data, rowvar=False) + # print(self.coef, self.mean.flatten(), self.intercept) + # Note: mean can be numpy.matrixlib.defmatrix.matrix or numpy.matrix type depending on numpy version + if issparse(self.mean) or str(type(self.mean)).endswith("matrix'>"): + # accept both sparse and dense coef + # if not issparse(self.coef): + # self.coef = np.asmatrix(self.coef) + self.expected_value = np.dot(self.coef, self.mean) + self.intercept + + # unwrap the matrix form + if len(self.expected_value) == 1: + self.expected_value = self.expected_value[0, 0] + else: + self.expected_value = np.array(self.expected_value)[0] + else: + self.expected_value = np.dot(self.coef, self.mean) + self.intercept + + self.M = len(self.mean) + + # if needed, estimate the transform matrices + if self.feature_perturbation == "correlation_dependent": + self.valid_inds = np.where(np.diag(self.cov) > 1e-8)[0] + self.mean = self.mean[self.valid_inds] + self.cov = self.cov[:, self.valid_inds][self.valid_inds, :] + self.coef = self.coef[self.valid_inds] + + # group perfectly redundant variables together + self.avg_proj, sum_proj = duplicate_components(self.cov) + self.cov = np.matmul(np.matmul(self.avg_proj, self.cov), self.avg_proj.T) + self.mean = np.matmul(self.avg_proj, self.mean) + self.coef = np.matmul(sum_proj, self.coef) + + # if we still have some multi-collinearity present then we just add regularization... + e, _ = np.linalg.eig(self.cov) + if e.min() < 1e-7: + self.cov = self.cov + np.eye(self.cov.shape[0]) * 1e-6 + + mean_transform, x_transform = self._estimate_transforms(nsamples) + self.mean_transformed = np.matmul(mean_transform, self.mean) + self.x_transform = x_transform + elif self.feature_perturbation == "interventional": + if nsamples != 1000: + warnings.warn("Setting nsamples has no effect when feature_perturbation = 'interventional'!") + else: + raise InvalidFeaturePerturbationError( + "Unknown type of feature_perturbation provided: " + self.feature_perturbation + ) + + def _estimate_transforms(self, nsamples): + """Uses block matrix inversion identities to quickly estimate transforms. + + After a bit of matrix math we can isolate a transform matrix (# features x # features) + that is independent of any sample we are explaining. It is the result of averaging over + all feature permutations, but we just use a fixed number of samples to estimate the value. + + TODO: Do a brute force enumeration when # feature subsets is less than nsamples. This could + happen through a recursive method that uses the same block matrix inversion as below. + """ + M = len(self.coef) + + mean_transform = np.zeros((M, M)) + x_transform = np.zeros((M, M)) + inds = np.arange(M, dtype=int) + for _ in tqdm(range(nsamples), "Estimating transforms"): + np.random.shuffle(inds) + cov_inv_SiSi = np.zeros((0, 0)) + cov_Si = np.zeros((M, 0)) + for j in range(M): + i = inds[j] + + # use the last Si as the new S + cov_S = cov_Si + cov_inv_SS = cov_inv_SiSi + + # get the new cov_Si + cov_Si = self.cov[:, inds[: j + 1]] + + # compute the new cov_inv_SiSi from cov_inv_SS + d = cov_Si[i, :-1].T + t = np.matmul(cov_inv_SS, d) + Z = self.cov[i, i] + u = Z - np.matmul(t.T, d) + cov_inv_SiSi = np.zeros((j + 1, j + 1)) + if j > 0: + cov_inv_SiSi[:-1, :-1] = cov_inv_SS + np.outer(t, t) / u + cov_inv_SiSi[:-1, -1] = cov_inv_SiSi[-1, :-1] = -t / u + cov_inv_SiSi[-1, -1] = 1 / u + + # + coef @ (Q(bar(Sui)) - Q(bar(S))) + mean_transform[i, i] += self.coef[i] + + # + coef @ R(Sui) + coef_R_Si = np.matmul(self.coef[inds[j + 1 :]], np.matmul(cov_Si, cov_inv_SiSi)[inds[j + 1 :]]) + mean_transform[i, inds[: j + 1]] += coef_R_Si + + # - coef @ R(S) + coef_R_S = np.matmul(self.coef[inds[j:]], np.matmul(cov_S, cov_inv_SS)[inds[j:]]) + mean_transform[i, inds[:j]] -= coef_R_S + + # - coef @ (Q(Sui) - Q(S)) + x_transform[i, i] += self.coef[i] + + # + coef @ R(Sui) + x_transform[i, inds[: j + 1]] += coef_R_Si + + # - coef @ R(S) + x_transform[i, inds[:j]] -= coef_R_S + + mean_transform /= nsamples + x_transform /= nsamples + return mean_transform, x_transform + + @staticmethod + def _parse_model(model): + """Attempt to pull out the coefficients and intercept from the given model object.""" + # raw coefficients + if isinstance(model, tuple) and len(model) == 2: + coef = model[0] + intercept = model[1] + + # sklearn style model + elif hasattr(model, "coef_") and hasattr(model, "intercept_"): + # work around for multi-class with a single class + if len(model.coef_.shape) > 1 and model.coef_.shape[0] == 1: + coef = model.coef_[0] + try: + intercept = model.intercept_[0] + except TypeError: + intercept = model.intercept_ + else: + coef = model.coef_ + intercept = model.intercept_ + else: + raise InvalidModelError("An unknown model type was passed: " + str(type(model))) + + return coef, intercept + + @staticmethod + def supports_model_with_masker(model, masker): + """Determines if we can parse the given model.""" + if not isinstance(masker, (maskers.Independent, maskers.Partition, maskers.Impute)): + return False + + try: + LinearExplainer._parse_model(model) + except Exception: + return False + return True + + def explain_row(self, *row_args, max_evals, main_effects, error_bounds, batch_size, outputs, silent): + """Explains a single row and returns the tuple (row_values, row_expected_values, row_mask_shapes).""" + assert len(row_args) == 1, "Only single-argument functions are supported by the Linear explainer!" + + X = row_args[0] + if len(X.shape) == 1: + X = X.reshape(1, -1) + + # convert dataframes + if isinstance(X, (pd.Series, pd.DataFrame)): + X = X.values + + if len(X.shape) not in (1, 2): + raise DimensionError(f"Instance must have 1 or 2 dimensions! Not: {len(X.shape)}") + + if self.feature_perturbation == "correlation_dependent": + if issparse(X): + raise InvalidFeaturePerturbationError( + "Only feature_perturbation = 'interventional' is supported for sparse data" + ) + phi = ( + np.matmul(np.matmul(X[:, self.valid_inds], self.avg_proj.T), self.x_transform.T) - self.mean_transformed + ) + phi = np.matmul(phi, self.avg_proj) + + full_phi = np.zeros((phi.shape[0], self.M)) + full_phi[:, self.valid_inds] = phi + phi = full_phi + + elif self.feature_perturbation == "interventional": + if issparse(X): + phi = np.array(np.multiply(X - self.mean, self.coef)) + + # if len(self.coef.shape) == 1: + # return np.array(np.multiply(X - self.mean, self.coef)) + # else: + # return [np.array(np.multiply(X - self.mean, self.coef[i])) for i in range(self.coef.shape[0])] + else: + phi = np.array(X - self.mean) * self.coef + # if len(self.coef.shape) == 1: + # phi = np.array(X - self.mean) * self.coef + # return np.array(X - self.mean) * self.coef + # else: + # return [np.array(X - self.mean) * self.coef[i] for i in range(self.coef.shape[0])] + + return { + "values": phi.T, + "expected_values": self.expected_value, + "mask_shapes": (X.shape[1:],), + "main_effects": phi.T, + "clustering": None, + } + + def shap_values(self, X): + """Estimate the SHAP values for a set of samples. + + Parameters + ---------- + X : numpy.array, pandas.DataFrame or scipy.csr_matrix + A matrix of samples (# samples x # features) on which to explain the model's output. + + Returns + ------- + np.array + Estimated SHAP values, usually of shape ``(# samples x # features)``. + + Each row sums to the difference between the model output for that + sample and the expected value of the model output (which is stored + as the ``expected_value`` attribute of the explainer). + + The shape of the returned array depends on the number of model outputs: + + * one output: array of shape ``(#num_samples, *X.shape[1:])``. + * multiple outputs: array of shape ``(#num_samples, *X.shape[1:], + #num_outputs)``. + + .. versionchanged:: 0.45.0 + Return type for models with multiple outputs changed from list to np.ndarray. + + """ + # convert dataframes + if isinstance(X, (pd.Series, pd.DataFrame)): + X = X.values + + # assert isinstance(X, np.ndarray), "Unknown instance type: " + str(type(X)) + if len(X.shape) not in (1, 2): + raise DimensionError(f"Instance must have 1 or 2 dimensions! Not: {len(X.shape)}") + + if self.feature_perturbation == "correlation_dependent": + if issparse(X): + raise InvalidFeaturePerturbationError( + "Only feature_perturbation = 'interventional' is supported for sparse data" + ) + phi = ( + np.matmul(np.matmul(X[:, self.valid_inds], self.avg_proj.T), self.x_transform.T) - self.mean_transformed + ) + phi = np.matmul(phi, self.avg_proj) + + full_phi = np.zeros((phi.shape[0], self.M)) + full_phi[:, self.valid_inds] = phi + + return full_phi + + elif self.feature_perturbation == "interventional": + if issparse(X): + if len(self.coef.shape) == 1: + return np.array(np.multiply(X - self.mean, self.coef)) + else: + return np.stack( + [np.array(np.multiply(X - self.mean, self.coef[i])) for i in range(self.coef.shape[0])], axis=-1 + ) + else: + if len(self.coef.shape) == 1: + return np.array(X - self.mean) * self.coef + else: + return np.stack( + [np.array(X - self.mean) * self.coef[i] for i in range(self.coef.shape[0])], axis=-1 + ) + + +def duplicate_components(C): + D = np.diag(1 / np.sqrt(np.diag(C))) + C = np.matmul(np.matmul(D, C), D) + components = -np.ones(C.shape[0], dtype=int) + count = -1 + for i in range(C.shape[0]): + found_group = False + for j in range(C.shape[0]): + if components[j] < 0 and np.abs(2 * C[i, j] - C[i, i] - C[j, j]) < 1e-8: + if not found_group: + count += 1 + found_group = True + components[j] = count + + proj = np.zeros((len(np.unique(components)), C.shape[0])) + proj[0, 0] = 1 + for i in range(1, C.shape[0]): + proj[components[i], i] = 1 + return (proj.T / proj.sum(1)).T, proj diff --git a/shared/package-files/31/31571d5f233f4d05b93202958b765537efc1c5f9a08ddfbfc3f565c775dca39d/blob b/shared/package-files/31/31571d5f233f4d05b93202958b765537efc1c5f9a08ddfbfc3f565c775dca39d/blob new file mode 100644 index 0000000000000000000000000000000000000000..53285c6e6a97ed4e114a1f0e98a59c5221ac2ad0 --- /dev/null +++ b/shared/package-files/31/31571d5f233f4d05b93202958b765537efc1c5f9a08ddfbfc3f565c775dca39d/blob @@ -0,0 +1,116 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API _foreach_clamp_min_Scalar { + using schema = ::std::vector (at::TensorList, const at::Scalar &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_foreach_clamp_min") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_foreach_clamp_min.Scalar(Tensor[] self, Scalar scalar) -> Tensor[]") + static ::std::vector call(at::TensorList self, const at::Scalar & scalar); + static ::std::vector redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList self, const at::Scalar & scalar); +}; + +struct TORCH_API _foreach_clamp_min__Scalar { + using schema = void (at::TensorList, const at::Scalar &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_foreach_clamp_min_") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_foreach_clamp_min_.Scalar(Tensor(a!)[] self, Scalar scalar) -> ()") + static void call(at::TensorList self, const at::Scalar & scalar); + static void redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList self, const at::Scalar & scalar); +}; + +struct TORCH_API _foreach_clamp_min_List { + using schema = ::std::vector (at::TensorList, at::TensorList); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_foreach_clamp_min") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "List") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_foreach_clamp_min.List(Tensor[] self, Tensor[] other) -> Tensor[]") + static ::std::vector call(at::TensorList self, at::TensorList other); + static ::std::vector redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList self, at::TensorList other); +}; + +struct TORCH_API _foreach_clamp_min__List { + using schema = void (at::TensorList, at::TensorList); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_foreach_clamp_min_") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "List") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_foreach_clamp_min_.List(Tensor(a!)[] self, Tensor[] other) -> ()") + static void call(at::TensorList self, at::TensorList other); + static void redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList self, at::TensorList other); +}; + +struct TORCH_API _foreach_clamp_min_ScalarList { + using schema = ::std::vector (at::TensorList, at::ArrayRef); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_foreach_clamp_min") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "ScalarList") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_foreach_clamp_min.ScalarList(Tensor[] self, Scalar[] scalars) -> Tensor[]") + static ::std::vector call(at::TensorList self, at::ArrayRef scalars); + static ::std::vector redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList self, at::ArrayRef scalars); +}; + +struct TORCH_API _foreach_clamp_min__ScalarList { + using schema = void (at::TensorList, at::ArrayRef); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_foreach_clamp_min_") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "ScalarList") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_foreach_clamp_min_.ScalarList(Tensor(a!)[] self, Scalar[] scalars) -> ()") + static void call(at::TensorList self, at::ArrayRef scalars); + static void redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList self, at::ArrayRef scalars); +}; + +struct TORCH_API _foreach_clamp_min_Scalar_out { + using schema = void (at::TensorList, const at::Scalar &, at::TensorList); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_foreach_clamp_min") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar_out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_foreach_clamp_min.Scalar_out(Tensor[] self, Scalar scalar, *, Tensor(a!)[] out) -> ()") + static void call(at::TensorList self, const at::Scalar & scalar, at::TensorList out); + static void redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList self, const at::Scalar & scalar, at::TensorList out); +}; + +struct TORCH_API _foreach_clamp_min_List_out { + using schema = void (at::TensorList, at::TensorList, at::TensorList); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_foreach_clamp_min") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "List_out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_foreach_clamp_min.List_out(Tensor[] self, Tensor[] other, *, Tensor(a!)[] out) -> ()") + static void call(at::TensorList self, at::TensorList other, at::TensorList out); + static void redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList self, at::TensorList other, at::TensorList out); +}; + +struct TORCH_API _foreach_clamp_min_ScalarList_out { + using schema = void (at::TensorList, at::ArrayRef, at::TensorList); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::_foreach_clamp_min") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "ScalarList_out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "_foreach_clamp_min.ScalarList_out(Tensor[] self, Scalar[] scalars, *, Tensor(a!)[] out) -> ()") + static void call(at::TensorList self, at::ArrayRef scalars, at::TensorList out); + static void redispatch(c10::DispatchKeySet dispatchKeySet, at::TensorList self, at::ArrayRef scalars, at::TensorList out); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/31/315948301831326233ff7e649dfb8f6098c487ce49186a74a5049da967abc5e5/blob b/shared/package-files/31/315948301831326233ff7e649dfb8f6098c487ce49186a74a5049da967abc5e5/blob new file mode 100644 index 0000000000000000000000000000000000000000..f53e45baf2f8135590230d3664e2ed83884cd0ac Binary files /dev/null and b/shared/package-files/31/315948301831326233ff7e649dfb8f6098c487ce49186a74a5049da967abc5e5/blob differ diff --git a/shared/package-files/31/315b27d08498e607335ee61f0ee5587b6e17532d491d96a91e65f3c4a94f617b/blob b/shared/package-files/31/315b27d08498e607335ee61f0ee5587b6e17532d491d96a91e65f3c4a94f617b/blob new file mode 100644 index 0000000000000000000000000000000000000000..05645975b071f4e4e790593051e5f08637ed0bda --- /dev/null +++ b/shared/package-files/31/315b27d08498e607335ee61f0ee5587b6e17532d491d96a91e65f3c4a94f617b/blob @@ -0,0 +1,21 @@ +#pragma once + +// @generated by torchgen/gen.py from NativeFunction.h + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace at { +namespace native { +TORCH_API void _validate_sparse_csr_tensor_args(const at::Tensor & crow_indices, const at::Tensor & col_indices, const at::Tensor & values, at::IntArrayRef size); +} // namespace native +} // namespace at diff --git a/shared/package-files/31/315b7a680a562a24775675519d8ec612841d23cc3e7f633efb0eb4bd2d01e6f0/blob b/shared/package-files/31/315b7a680a562a24775675519d8ec612841d23cc3e7f633efb0eb4bd2d01e6f0/blob new file mode 100644 index 0000000000000000000000000000000000000000..0ba273f94cc496550ab6b9a4d2b688a88d6fc43b --- /dev/null +++ b/shared/package-files/31/315b7a680a562a24775675519d8ec612841d23cc3e7f633efb0eb4bd2d01e6f0/blob @@ -0,0 +1,53 @@ +"""Tests for making sure experimental imports work as expected.""" + +import textwrap + +import pytest + +from sklearn.utils._testing import assert_run_python_script_without_output +from sklearn.utils.fixes import _IS_WASM + + +@pytest.mark.xfail(_IS_WASM, reason="cannot start subprocess") +def test_imports_strategies(): + # Make sure different import strategies work or fail as expected. + + # Since Python caches the imported modules, we need to run a child process + # for every test case. Else, the tests would not be independent + # (manually removing the imports from the cache (sys.modules) is not + # recommended and can lead to many complications). + pattern = "Halving(Grid|Random)SearchCV is experimental" + good_import = """ + from sklearn.experimental import enable_halving_search_cv + from sklearn.model_selection import HalvingGridSearchCV + from sklearn.model_selection import HalvingRandomSearchCV + """ + assert_run_python_script_without_output( + textwrap.dedent(good_import), pattern=pattern + ) + + good_import_with_model_selection_first = """ + import sklearn.model_selection + from sklearn.experimental import enable_halving_search_cv + from sklearn.model_selection import HalvingGridSearchCV + from sklearn.model_selection import HalvingRandomSearchCV + """ + assert_run_python_script_without_output( + textwrap.dedent(good_import_with_model_selection_first), + pattern=pattern, + ) + + bad_imports = f""" + import pytest + + with pytest.raises(ImportError, match={pattern!r}): + from sklearn.model_selection import HalvingGridSearchCV + + import sklearn.experimental + with pytest.raises(ImportError, match={pattern!r}): + from sklearn.model_selection import HalvingRandomSearchCV + """ + assert_run_python_script_without_output( + textwrap.dedent(bad_imports), + pattern=pattern, + ) diff --git a/shared/package-files/31/315d3465b062f852a01e2f4f618d994bbb67795dab821bb67958b52a0c51673b/blob b/shared/package-files/31/315d3465b062f852a01e2f4f618d994bbb67795dab821bb67958b52a0c51673b/blob new file mode 100644 index 0000000000000000000000000000000000000000..eff812f2a418bd3c4dce8c4a62d923de5cb6eac6 --- /dev/null +++ b/shared/package-files/31/315d3465b062f852a01e2f4f618d994bbb67795dab821bb67958b52a0c51673b/blob @@ -0,0 +1 @@ +class InvalidToken(Exception): ... diff --git a/shared/package-files/31/316015417ca16c1901574ffb0d622c8293d71d481fca4ed7ece78929b6e628f4/blob b/shared/package-files/31/316015417ca16c1901574ffb0d622c8293d71d481fca4ed7ece78929b6e628f4/blob new file mode 100644 index 0000000000000000000000000000000000000000..7274b5f03e413618b07f81a5ba88f238efd700d5 --- /dev/null +++ b/shared/package-files/31/316015417ca16c1901574ffb0d622c8293d71d481fca4ed7ece78929b6e628f4/blob @@ -0,0 +1,1504 @@ +""" +Line editing functionality. +--------------------------- + +This provides a UI for a line input, similar to GNU Readline, libedit and +linenoise. + +Either call the `prompt` function for every line input. Or create an instance +of the :class:`.PromptSession` class and call the `prompt` method from that +class. In the second case, we'll have a 'session' that keeps all the state like +the history in between several calls. + +There is a lot of overlap between the arguments taken by the `prompt` function +and the `PromptSession` (like `completer`, `style`, etcetera). There we have +the freedom to decide which settings we want for the whole 'session', and which +we want for an individual `prompt`. + +Example:: + + # Simple `prompt` call. + result = prompt('Say something: ') + + # Using a 'session'. + s = PromptSession() + result = s.prompt('Say something: ') +""" +from __future__ import annotations + +from asyncio import get_running_loop +from contextlib import contextmanager +from enum import Enum +from functools import partial +from typing import TYPE_CHECKING, Callable, Generic, Iterator, TypeVar, Union, cast + +from prompt_toolkit.application import Application +from prompt_toolkit.application.current import get_app +from prompt_toolkit.auto_suggest import AutoSuggest, DynamicAutoSuggest +from prompt_toolkit.buffer import Buffer +from prompt_toolkit.clipboard import Clipboard, DynamicClipboard, InMemoryClipboard +from prompt_toolkit.completion import Completer, DynamicCompleter, ThreadedCompleter +from prompt_toolkit.cursor_shapes import ( + AnyCursorShapeConfig, + CursorShapeConfig, + DynamicCursorShapeConfig, +) +from prompt_toolkit.document import Document +from prompt_toolkit.enums import DEFAULT_BUFFER, SEARCH_BUFFER, EditingMode +from prompt_toolkit.eventloop import InputHook +from prompt_toolkit.filters import ( + Condition, + FilterOrBool, + has_arg, + has_focus, + is_done, + is_true, + renderer_height_is_known, + to_filter, +) +from prompt_toolkit.formatted_text import ( + AnyFormattedText, + StyleAndTextTuples, + fragment_list_to_text, + merge_formatted_text, + to_formatted_text, +) +from prompt_toolkit.history import History, InMemoryHistory +from prompt_toolkit.input.base import Input +from prompt_toolkit.key_binding.bindings.auto_suggest import load_auto_suggest_bindings +from prompt_toolkit.key_binding.bindings.completion import ( + display_completions_like_readline, +) +from prompt_toolkit.key_binding.bindings.open_in_editor import ( + load_open_in_editor_bindings, +) +from prompt_toolkit.key_binding.key_bindings import ( + ConditionalKeyBindings, + DynamicKeyBindings, + KeyBindings, + KeyBindingsBase, + merge_key_bindings, +) +from prompt_toolkit.key_binding.key_processor import KeyPressEvent +from prompt_toolkit.keys import Keys +from prompt_toolkit.layout import Float, FloatContainer, HSplit, Window +from prompt_toolkit.layout.containers import ConditionalContainer, WindowAlign +from prompt_toolkit.layout.controls import ( + BufferControl, + FormattedTextControl, + SearchBufferControl, +) +from prompt_toolkit.layout.dimension import Dimension +from prompt_toolkit.layout.layout import Layout +from prompt_toolkit.layout.menus import CompletionsMenu, MultiColumnCompletionsMenu +from prompt_toolkit.layout.processors import ( + AfterInput, + AppendAutoSuggestion, + ConditionalProcessor, + DisplayMultipleCursors, + DynamicProcessor, + HighlightIncrementalSearchProcessor, + HighlightSelectionProcessor, + PasswordProcessor, + Processor, + ReverseSearchProcessor, + merge_processors, +) +from prompt_toolkit.layout.utils import explode_text_fragments +from prompt_toolkit.lexers import DynamicLexer, Lexer +from prompt_toolkit.output import ColorDepth, DummyOutput, Output +from prompt_toolkit.styles import ( + BaseStyle, + ConditionalStyleTransformation, + DynamicStyle, + DynamicStyleTransformation, + StyleTransformation, + SwapLightAndDarkStyleTransformation, + merge_style_transformations, +) +from prompt_toolkit.utils import ( + get_cwidth, + is_dumb_terminal, + suspend_to_background_supported, + to_str, +) +from prompt_toolkit.validation import DynamicValidator, Validator +from prompt_toolkit.widgets.toolbars import ( + SearchToolbar, + SystemToolbar, + ValidationToolbar, +) + +if TYPE_CHECKING: + from prompt_toolkit.formatted_text.base import MagicFormattedText + +__all__ = [ + "PromptSession", + "prompt", + "confirm", + "create_confirm_session", # Used by '_display_completions_like_readline'. + "CompleteStyle", +] + +_StyleAndTextTuplesCallable = Callable[[], StyleAndTextTuples] +E = KeyPressEvent + + +def _split_multiline_prompt( + get_prompt_text: _StyleAndTextTuplesCallable, +) -> tuple[ + Callable[[], bool], _StyleAndTextTuplesCallable, _StyleAndTextTuplesCallable +]: + """ + Take a `get_prompt_text` function and return three new functions instead. + One that tells whether this prompt consists of multiple lines; one that + returns the fragments to be shown on the lines above the input; and another + one with the fragments to be shown at the first line of the input. + """ + + def has_before_fragments() -> bool: + for fragment, char, *_ in get_prompt_text(): + if "\n" in char: + return True + return False + + def before() -> StyleAndTextTuples: + result: StyleAndTextTuples = [] + found_nl = False + for fragment, char, *_ in reversed(explode_text_fragments(get_prompt_text())): + if found_nl: + result.insert(0, (fragment, char)) + elif char == "\n": + found_nl = True + return result + + def first_input_line() -> StyleAndTextTuples: + result: StyleAndTextTuples = [] + for fragment, char, *_ in reversed(explode_text_fragments(get_prompt_text())): + if char == "\n": + break + else: + result.insert(0, (fragment, char)) + return result + + return has_before_fragments, before, first_input_line + + +class _RPrompt(Window): + """ + The prompt that is displayed on the right side of the Window. + """ + + def __init__(self, text: AnyFormattedText) -> None: + super().__init__( + FormattedTextControl(text=text), + align=WindowAlign.RIGHT, + style="class:rprompt", + ) + + +class CompleteStyle(str, Enum): + """ + How to display autocompletions for the prompt. + """ + + value: str + + COLUMN = "COLUMN" + MULTI_COLUMN = "MULTI_COLUMN" + READLINE_LIKE = "READLINE_LIKE" + + +# Formatted text for the continuation prompt. It's the same like other +# formatted text, except that if it's a callable, it takes three arguments. +PromptContinuationText = Union[ + str, + "MagicFormattedText", + StyleAndTextTuples, + # (prompt_width, line_number, wrap_count) -> AnyFormattedText. + Callable[[int, int, int], AnyFormattedText], +] + +_T = TypeVar("_T") + + +class PromptSession(Generic[_T]): + """ + PromptSession for a prompt application, which can be used as a GNU Readline + replacement. + + This is a wrapper around a lot of ``prompt_toolkit`` functionality and can + be a replacement for `raw_input`. + + All parameters that expect "formatted text" can take either just plain text + (a unicode object), a list of ``(style_str, text)`` tuples or an HTML object. + + Example usage:: + + s = PromptSession(message='>') + text = s.prompt() + + :param message: Plain text or formatted text to be shown before the prompt. + This can also be a callable that returns formatted text. + :param multiline: `bool` or :class:`~prompt_toolkit.filters.Filter`. + When True, prefer a layout that is more adapted for multiline input. + Text after newlines is automatically indented, and search/arg input is + shown below the input, instead of replacing the prompt. + :param wrap_lines: `bool` or :class:`~prompt_toolkit.filters.Filter`. + When True (the default), automatically wrap long lines instead of + scrolling horizontally. + :param is_password: Show asterisks instead of the actual typed characters. + :param editing_mode: ``EditingMode.VI`` or ``EditingMode.EMACS``. + :param vi_mode: `bool`, if True, Identical to ``editing_mode=EditingMode.VI``. + :param complete_while_typing: `bool` or + :class:`~prompt_toolkit.filters.Filter`. Enable autocompletion while + typing. + :param validate_while_typing: `bool` or + :class:`~prompt_toolkit.filters.Filter`. Enable input validation while + typing. + :param enable_history_search: `bool` or + :class:`~prompt_toolkit.filters.Filter`. Enable up-arrow parting + string matching. + :param search_ignore_case: + :class:`~prompt_toolkit.filters.Filter`. Search case insensitive. + :param lexer: :class:`~prompt_toolkit.lexers.Lexer` to be used for the + syntax highlighting. + :param validator: :class:`~prompt_toolkit.validation.Validator` instance + for input validation. + :param completer: :class:`~prompt_toolkit.completion.Completer` instance + for input completion. + :param complete_in_thread: `bool` or + :class:`~prompt_toolkit.filters.Filter`. Run the completer code in a + background thread in order to avoid blocking the user interface. + For ``CompleteStyle.READLINE_LIKE``, this setting has no effect. There + we always run the completions in the main thread. + :param reserve_space_for_menu: Space to be reserved for displaying the menu. + (0 means that no space needs to be reserved.) + :param auto_suggest: :class:`~prompt_toolkit.auto_suggest.AutoSuggest` + instance for input suggestions. + :param style: :class:`.Style` instance for the color scheme. + :param include_default_pygments_style: `bool` or + :class:`~prompt_toolkit.filters.Filter`. Tell whether the default + styling for Pygments lexers has to be included. By default, this is + true, but it is recommended to be disabled if another Pygments style is + passed as the `style` argument, otherwise, two Pygments styles will be + merged. + :param style_transformation: + :class:`~prompt_toolkit.style.StyleTransformation` instance. + :param swap_light_and_dark_colors: `bool` or + :class:`~prompt_toolkit.filters.Filter`. When enabled, apply + :class:`~prompt_toolkit.style.SwapLightAndDarkStyleTransformation`. + This is useful for switching between dark and light terminal + backgrounds. + :param enable_system_prompt: `bool` or + :class:`~prompt_toolkit.filters.Filter`. Pressing Meta+'!' will show + a system prompt. + :param enable_suspend: `bool` or :class:`~prompt_toolkit.filters.Filter`. + Enable Control-Z style suspension. + :param enable_open_in_editor: `bool` or + :class:`~prompt_toolkit.filters.Filter`. Pressing 'v' in Vi mode or + C-X C-E in emacs mode will open an external editor. + :param history: :class:`~prompt_toolkit.history.History` instance. + :param clipboard: :class:`~prompt_toolkit.clipboard.Clipboard` instance. + (e.g. :class:`~prompt_toolkit.clipboard.InMemoryClipboard`) + :param rprompt: Text or formatted text to be displayed on the right side. + This can also be a callable that returns (formatted) text. + :param bottom_toolbar: Formatted text or callable which is supposed to + return formatted text. + :param prompt_continuation: Text that needs to be displayed for a multiline + prompt continuation. This can either be formatted text or a callable + that takes a `prompt_width`, `line_number` and `wrap_count` as input + and returns formatted text. When this is `None` (the default), then + `prompt_width` spaces will be used. + :param complete_style: ``CompleteStyle.COLUMN``, + ``CompleteStyle.MULTI_COLUMN`` or ``CompleteStyle.READLINE_LIKE``. + :param mouse_support: `bool` or :class:`~prompt_toolkit.filters.Filter` + to enable mouse support. + :param placeholder: Text to be displayed when no input has been given + yet. Unlike the `default` parameter, this won't be returned as part of + the output ever. This can be formatted text or a callable that returns + formatted text. + :param refresh_interval: (number; in seconds) When given, refresh the UI + every so many seconds. + :param input: `Input` object. (Note that the preferred way to change the + input/output is by creating an `AppSession`.) + :param output: `Output` object. + """ + + _fields = ( + "message", + "lexer", + "completer", + "complete_in_thread", + "is_password", + "editing_mode", + "key_bindings", + "is_password", + "bottom_toolbar", + "style", + "style_transformation", + "swap_light_and_dark_colors", + "color_depth", + "cursor", + "include_default_pygments_style", + "rprompt", + "multiline", + "prompt_continuation", + "wrap_lines", + "enable_history_search", + "search_ignore_case", + "complete_while_typing", + "validate_while_typing", + "complete_style", + "mouse_support", + "auto_suggest", + "clipboard", + "validator", + "refresh_interval", + "input_processors", + "placeholder", + "enable_system_prompt", + "enable_suspend", + "enable_open_in_editor", + "reserve_space_for_menu", + "tempfile_suffix", + "tempfile", + ) + + def __init__( + self, + message: AnyFormattedText = "", + *, + multiline: FilterOrBool = False, + wrap_lines: FilterOrBool = True, + is_password: FilterOrBool = False, + vi_mode: bool = False, + editing_mode: EditingMode = EditingMode.EMACS, + complete_while_typing: FilterOrBool = True, + validate_while_typing: FilterOrBool = True, + enable_history_search: FilterOrBool = False, + search_ignore_case: FilterOrBool = False, + lexer: Lexer | None = None, + enable_system_prompt: FilterOrBool = False, + enable_suspend: FilterOrBool = False, + enable_open_in_editor: FilterOrBool = False, + validator: Validator | None = None, + completer: Completer | None = None, + complete_in_thread: bool = False, + reserve_space_for_menu: int = 8, + complete_style: CompleteStyle = CompleteStyle.COLUMN, + auto_suggest: AutoSuggest | None = None, + style: BaseStyle | None = None, + style_transformation: StyleTransformation | None = None, + swap_light_and_dark_colors: FilterOrBool = False, + color_depth: ColorDepth | None = None, + cursor: AnyCursorShapeConfig = None, + include_default_pygments_style: FilterOrBool = True, + history: History | None = None, + clipboard: Clipboard | None = None, + prompt_continuation: PromptContinuationText | None = None, + rprompt: AnyFormattedText = None, + bottom_toolbar: AnyFormattedText = None, + mouse_support: FilterOrBool = False, + input_processors: list[Processor] | None = None, + placeholder: AnyFormattedText | None = None, + key_bindings: KeyBindingsBase | None = None, + erase_when_done: bool = False, + tempfile_suffix: str | Callable[[], str] | None = ".txt", + tempfile: str | Callable[[], str] | None = None, + refresh_interval: float = 0, + input: Input | None = None, + output: Output | None = None, + ) -> None: + history = history or InMemoryHistory() + clipboard = clipboard or InMemoryClipboard() + + # Ensure backwards-compatibility, when `vi_mode` is passed. + if vi_mode: + editing_mode = EditingMode.VI + + # Store all settings in this class. + self._input = input + self._output = output + + # Store attributes. + # (All except 'editing_mode'.) + self.message = message + self.lexer = lexer + self.completer = completer + self.complete_in_thread = complete_in_thread + self.is_password = is_password + self.key_bindings = key_bindings + self.bottom_toolbar = bottom_toolbar + self.style = style + self.style_transformation = style_transformation + self.swap_light_and_dark_colors = swap_light_and_dark_colors + self.color_depth = color_depth + self.cursor = cursor + self.include_default_pygments_style = include_default_pygments_style + self.rprompt = rprompt + self.multiline = multiline + self.prompt_continuation = prompt_continuation + self.wrap_lines = wrap_lines + self.enable_history_search = enable_history_search + self.search_ignore_case = search_ignore_case + self.complete_while_typing = complete_while_typing + self.validate_while_typing = validate_while_typing + self.complete_style = complete_style + self.mouse_support = mouse_support + self.auto_suggest = auto_suggest + self.clipboard = clipboard + self.validator = validator + self.refresh_interval = refresh_interval + self.input_processors = input_processors + self.placeholder = placeholder + self.enable_system_prompt = enable_system_prompt + self.enable_suspend = enable_suspend + self.enable_open_in_editor = enable_open_in_editor + self.reserve_space_for_menu = reserve_space_for_menu + self.tempfile_suffix = tempfile_suffix + self.tempfile = tempfile + + # Create buffers, layout and Application. + self.history = history + self.default_buffer = self._create_default_buffer() + self.search_buffer = self._create_search_buffer() + self.layout = self._create_layout() + self.app = self._create_application(editing_mode, erase_when_done) + + def _dyncond(self, attr_name: str) -> Condition: + """ + Dynamically take this setting from this 'PromptSession' class. + `attr_name` represents an attribute name of this class. Its value + can either be a boolean or a `Filter`. + + This returns something that can be used as either a `Filter` + or `Filter`. + """ + + @Condition + def dynamic() -> bool: + value = cast(FilterOrBool, getattr(self, attr_name)) + return to_filter(value)() + + return dynamic + + def _create_default_buffer(self) -> Buffer: + """ + Create and return the default input buffer. + """ + dyncond = self._dyncond + + # Create buffers list. + def accept(buff: Buffer) -> bool: + """Accept the content of the default buffer. This is called when + the validation succeeds.""" + cast(Application[str], get_app()).exit(result=buff.document.text) + return True # Keep text, we call 'reset' later on. + + return Buffer( + name=DEFAULT_BUFFER, + # Make sure that complete_while_typing is disabled when + # enable_history_search is enabled. (First convert to Filter, + # to avoid doing bitwise operations on bool objects.) + complete_while_typing=Condition( + lambda: is_true(self.complete_while_typing) + and not is_true(self.enable_history_search) + and not self.complete_style == CompleteStyle.READLINE_LIKE + ), + validate_while_typing=dyncond("validate_while_typing"), + enable_history_search=dyncond("enable_history_search"), + validator=DynamicValidator(lambda: self.validator), + completer=DynamicCompleter( + lambda: ThreadedCompleter(self.completer) + if self.complete_in_thread and self.completer + else self.completer + ), + history=self.history, + auto_suggest=DynamicAutoSuggest(lambda: self.auto_suggest), + accept_handler=accept, + tempfile_suffix=lambda: to_str(self.tempfile_suffix or ""), + tempfile=lambda: to_str(self.tempfile or ""), + ) + + def _create_search_buffer(self) -> Buffer: + return Buffer(name=SEARCH_BUFFER) + + def _create_layout(self) -> Layout: + """ + Create `Layout` for this prompt. + """ + dyncond = self._dyncond + + # Create functions that will dynamically split the prompt. (If we have + # a multiline prompt.) + ( + has_before_fragments, + get_prompt_text_1, + get_prompt_text_2, + ) = _split_multiline_prompt(self._get_prompt) + + default_buffer = self.default_buffer + search_buffer = self.search_buffer + + # Create processors list. + @Condition + def display_placeholder() -> bool: + return self.placeholder is not None and self.default_buffer.text == "" + + all_input_processors = [ + HighlightIncrementalSearchProcessor(), + HighlightSelectionProcessor(), + ConditionalProcessor( + AppendAutoSuggestion(), has_focus(default_buffer) & ~is_done + ), + ConditionalProcessor(PasswordProcessor(), dyncond("is_password")), + DisplayMultipleCursors(), + # Users can insert processors here. + DynamicProcessor(lambda: merge_processors(self.input_processors or [])), + ConditionalProcessor( + AfterInput(lambda: self.placeholder), + filter=display_placeholder, + ), + ] + + # Create bottom toolbars. + bottom_toolbar = ConditionalContainer( + Window( + FormattedTextControl( + lambda: self.bottom_toolbar, style="class:bottom-toolbar.text" + ), + style="class:bottom-toolbar", + dont_extend_height=True, + height=Dimension(min=1), + ), + filter=Condition(lambda: self.bottom_toolbar is not None) + & ~is_done + & renderer_height_is_known, + ) + + search_toolbar = SearchToolbar( + search_buffer, ignore_case=dyncond("search_ignore_case") + ) + + search_buffer_control = SearchBufferControl( + buffer=search_buffer, + input_processors=[ReverseSearchProcessor()], + ignore_case=dyncond("search_ignore_case"), + ) + + system_toolbar = SystemToolbar( + enable_global_bindings=dyncond("enable_system_prompt") + ) + + def get_search_buffer_control() -> SearchBufferControl: + "Return the UIControl to be focused when searching start." + if is_true(self.multiline): + return search_toolbar.control + else: + return search_buffer_control + + default_buffer_control = BufferControl( + buffer=default_buffer, + search_buffer_control=get_search_buffer_control, + input_processors=all_input_processors, + include_default_input_processors=False, + lexer=DynamicLexer(lambda: self.lexer), + preview_search=True, + ) + + default_buffer_window = Window( + default_buffer_control, + height=self._get_default_buffer_control_height, + get_line_prefix=partial( + self._get_line_prefix, get_prompt_text_2=get_prompt_text_2 + ), + wrap_lines=dyncond("wrap_lines"), + ) + + @Condition + def multi_column_complete_style() -> bool: + return self.complete_style == CompleteStyle.MULTI_COLUMN + + # Build the layout. + layout = HSplit( + [ + # The main input, with completion menus floating on top of it. + FloatContainer( + HSplit( + [ + ConditionalContainer( + Window( + FormattedTextControl(get_prompt_text_1), + dont_extend_height=True, + ), + Condition(has_before_fragments), + ), + ConditionalContainer( + default_buffer_window, + Condition( + lambda: get_app().layout.current_control + != search_buffer_control + ), + ), + ConditionalContainer( + Window(search_buffer_control), + Condition( + lambda: get_app().layout.current_control + == search_buffer_control + ), + ), + ] + ), + [ + # Completion menus. + # NOTE: Especially the multi-column menu needs to be + # transparent, because the shape is not always + # rectangular due to the meta-text below the menu. + Float( + xcursor=True, + ycursor=True, + transparent=True, + content=CompletionsMenu( + max_height=16, + scroll_offset=1, + extra_filter=has_focus(default_buffer) + & ~multi_column_complete_style, + ), + ), + Float( + xcursor=True, + ycursor=True, + transparent=True, + content=MultiColumnCompletionsMenu( + show_meta=True, + extra_filter=has_focus(default_buffer) + & multi_column_complete_style, + ), + ), + # The right prompt. + Float( + right=0, + top=0, + hide_when_covering_content=True, + content=_RPrompt(lambda: self.rprompt), + ), + ], + ), + ConditionalContainer(ValidationToolbar(), filter=~is_done), + ConditionalContainer( + system_toolbar, dyncond("enable_system_prompt") & ~is_done + ), + # In multiline mode, we use two toolbars for 'arg' and 'search'. + ConditionalContainer( + Window(FormattedTextControl(self._get_arg_text), height=1), + dyncond("multiline") & has_arg, + ), + ConditionalContainer(search_toolbar, dyncond("multiline") & ~is_done), + bottom_toolbar, + ] + ) + + return Layout(layout, default_buffer_window) + + def _create_application( + self, editing_mode: EditingMode, erase_when_done: bool + ) -> Application[_T]: + """ + Create the `Application` object. + """ + dyncond = self._dyncond + + # Default key bindings. + auto_suggest_bindings = load_auto_suggest_bindings() + open_in_editor_bindings = load_open_in_editor_bindings() + prompt_bindings = self._create_prompt_bindings() + + # Create application + application: Application[_T] = Application( + layout=self.layout, + style=DynamicStyle(lambda: self.style), + style_transformation=merge_style_transformations( + [ + DynamicStyleTransformation(lambda: self.style_transformation), + ConditionalStyleTransformation( + SwapLightAndDarkStyleTransformation(), + dyncond("swap_light_and_dark_colors"), + ), + ] + ), + include_default_pygments_style=dyncond("include_default_pygments_style"), + clipboard=DynamicClipboard(lambda: self.clipboard), + key_bindings=merge_key_bindings( + [ + merge_key_bindings( + [ + auto_suggest_bindings, + ConditionalKeyBindings( + open_in_editor_bindings, + dyncond("enable_open_in_editor") + & has_focus(DEFAULT_BUFFER), + ), + prompt_bindings, + ] + ), + DynamicKeyBindings(lambda: self.key_bindings), + ] + ), + mouse_support=dyncond("mouse_support"), + editing_mode=editing_mode, + erase_when_done=erase_when_done, + reverse_vi_search_direction=True, + color_depth=lambda: self.color_depth, + cursor=DynamicCursorShapeConfig(lambda: self.cursor), + refresh_interval=self.refresh_interval, + input=self._input, + output=self._output, + ) + + # During render time, make sure that we focus the right search control + # (if we are searching). - This could be useful if people make the + # 'multiline' property dynamic. + """ + def on_render(app): + multiline = is_true(self.multiline) + current_control = app.layout.current_control + + if multiline: + if current_control == search_buffer_control: + app.layout.current_control = search_toolbar.control + app.invalidate() + else: + if current_control == search_toolbar.control: + app.layout.current_control = search_buffer_control + app.invalidate() + + app.on_render += on_render + """ + + return application + + def _create_prompt_bindings(self) -> KeyBindings: + """ + Create the KeyBindings for a prompt application. + """ + kb = KeyBindings() + handle = kb.add + default_focused = has_focus(DEFAULT_BUFFER) + + @Condition + def do_accept() -> bool: + return not is_true(self.multiline) and self.app.layout.has_focus( + DEFAULT_BUFFER + ) + + @handle("enter", filter=do_accept & default_focused) + def _accept_input(event: E) -> None: + "Accept input when enter has been pressed." + self.default_buffer.validate_and_handle() + + @Condition + def readline_complete_style() -> bool: + return self.complete_style == CompleteStyle.READLINE_LIKE + + @handle("tab", filter=readline_complete_style & default_focused) + def _complete_like_readline(event: E) -> None: + "Display completions (like Readline)." + display_completions_like_readline(event) + + @handle("c-c", filter=default_focused) + @handle("") + def _keyboard_interrupt(event: E) -> None: + "Abort when Control-C has been pressed." + event.app.exit(exception=KeyboardInterrupt, style="class:aborting") + + @Condition + def ctrl_d_condition() -> bool: + """Ctrl-D binding is only active when the default buffer is selected + and empty.""" + app = get_app() + return ( + app.current_buffer.name == DEFAULT_BUFFER + and not app.current_buffer.text + ) + + @handle("c-d", filter=ctrl_d_condition & default_focused) + def _eof(event: E) -> None: + "Exit when Control-D has been pressed." + event.app.exit(exception=EOFError, style="class:exiting") + + suspend_supported = Condition(suspend_to_background_supported) + + @Condition + def enable_suspend() -> bool: + return to_filter(self.enable_suspend)() + + @handle("c-z", filter=suspend_supported & enable_suspend) + def _suspend(event: E) -> None: + """ + Suspend process to background. + """ + event.app.suspend_to_background() + + return kb + + def prompt( + self, + # When any of these arguments are passed, this value is overwritten + # in this PromptSession. + message: AnyFormattedText | None = None, + # `message` should go first, because people call it as + # positional argument. + *, + editing_mode: EditingMode | None = None, + refresh_interval: float | None = None, + vi_mode: bool | None = None, + lexer: Lexer | None = None, + completer: Completer | None = None, + complete_in_thread: bool | None = None, + is_password: bool | None = None, + key_bindings: KeyBindingsBase | None = None, + bottom_toolbar: AnyFormattedText | None = None, + style: BaseStyle | None = None, + color_depth: ColorDepth | None = None, + cursor: AnyCursorShapeConfig | None = None, + include_default_pygments_style: FilterOrBool | None = None, + style_transformation: StyleTransformation | None = None, + swap_light_and_dark_colors: FilterOrBool | None = None, + rprompt: AnyFormattedText | None = None, + multiline: FilterOrBool | None = None, + prompt_continuation: PromptContinuationText | None = None, + wrap_lines: FilterOrBool | None = None, + enable_history_search: FilterOrBool | None = None, + search_ignore_case: FilterOrBool | None = None, + complete_while_typing: FilterOrBool | None = None, + validate_while_typing: FilterOrBool | None = None, + complete_style: CompleteStyle | None = None, + auto_suggest: AutoSuggest | None = None, + validator: Validator | None = None, + clipboard: Clipboard | None = None, + mouse_support: FilterOrBool | None = None, + input_processors: list[Processor] | None = None, + placeholder: AnyFormattedText | None = None, + reserve_space_for_menu: int | None = None, + enable_system_prompt: FilterOrBool | None = None, + enable_suspend: FilterOrBool | None = None, + enable_open_in_editor: FilterOrBool | None = None, + tempfile_suffix: str | Callable[[], str] | None = None, + tempfile: str | Callable[[], str] | None = None, + # Following arguments are specific to the current `prompt()` call. + default: str | Document = "", + accept_default: bool = False, + pre_run: Callable[[], None] | None = None, + set_exception_handler: bool = True, + handle_sigint: bool = True, + in_thread: bool = False, + inputhook: InputHook | None = None, + ) -> _T: + """ + Display the prompt. + + The first set of arguments is a subset of the :class:`~.PromptSession` + class itself. For these, passing in ``None`` will keep the current + values that are active in the session. Passing in a value will set the + attribute for the session, which means that it applies to the current, + but also to the next prompts. + + Note that in order to erase a ``Completer``, ``Validator`` or + ``AutoSuggest``, you can't use ``None``. Instead pass in a + ``DummyCompleter``, ``DummyValidator`` or ``DummyAutoSuggest`` instance + respectively. For a ``Lexer`` you can pass in an empty ``SimpleLexer``. + + Additional arguments, specific for this prompt: + + :param default: The default input text to be shown. (This can be edited + by the user). + :param accept_default: When `True`, automatically accept the default + value without allowing the user to edit the input. + :param pre_run: Callable, called at the start of `Application.run`. + :param in_thread: Run the prompt in a background thread; block the + current thread. This avoids interference with an event loop in the + current thread. Like `Application.run(in_thread=True)`. + + This method will raise ``KeyboardInterrupt`` when control-c has been + pressed (for abort) and ``EOFError`` when control-d has been pressed + (for exit). + """ + # NOTE: We used to create a backup of the PromptSession attributes and + # restore them after exiting the prompt. This code has been + # removed, because it was confusing and didn't really serve a use + # case. (People were changing `Application.editing_mode` + # dynamically and surprised that it was reset after every call.) + + # NOTE 2: YES, this is a lot of repeation below... + # However, it is a very convenient for a user to accept all + # these parameters in this `prompt` method as well. We could + # use `locals()` and `setattr` to avoid the repetition, but + # then we loose the advantage of mypy and pyflakes to be able + # to verify the code. + if message is not None: + self.message = message + if editing_mode is not None: + self.editing_mode = editing_mode + if refresh_interval is not None: + self.refresh_interval = refresh_interval + if vi_mode: + self.editing_mode = EditingMode.VI + if lexer is not None: + self.lexer = lexer + if completer is not None: + self.completer = completer + if complete_in_thread is not None: + self.complete_in_thread = complete_in_thread + if is_password is not None: + self.is_password = is_password + if key_bindings is not None: + self.key_bindings = key_bindings + if bottom_toolbar is not None: + self.bottom_toolbar = bottom_toolbar + if style is not None: + self.style = style + if color_depth is not None: + self.color_depth = color_depth + if cursor is not None: + self.cursor = cursor + if include_default_pygments_style is not None: + self.include_default_pygments_style = include_default_pygments_style + if style_transformation is not None: + self.style_transformation = style_transformation + if swap_light_and_dark_colors is not None: + self.swap_light_and_dark_colors = swap_light_and_dark_colors + if rprompt is not None: + self.rprompt = rprompt + if multiline is not None: + self.multiline = multiline + if prompt_continuation is not None: + self.prompt_continuation = prompt_continuation + if wrap_lines is not None: + self.wrap_lines = wrap_lines + if enable_history_search is not None: + self.enable_history_search = enable_history_search + if search_ignore_case is not None: + self.search_ignore_case = search_ignore_case + if complete_while_typing is not None: + self.complete_while_typing = complete_while_typing + if validate_while_typing is not None: + self.validate_while_typing = validate_while_typing + if complete_style is not None: + self.complete_style = complete_style + if auto_suggest is not None: + self.auto_suggest = auto_suggest + if validator is not None: + self.validator = validator + if clipboard is not None: + self.clipboard = clipboard + if mouse_support is not None: + self.mouse_support = mouse_support + if input_processors is not None: + self.input_processors = input_processors + if placeholder is not None: + self.placeholder = placeholder + if reserve_space_for_menu is not None: + self.reserve_space_for_menu = reserve_space_for_menu + if enable_system_prompt is not None: + self.enable_system_prompt = enable_system_prompt + if enable_suspend is not None: + self.enable_suspend = enable_suspend + if enable_open_in_editor is not None: + self.enable_open_in_editor = enable_open_in_editor + if tempfile_suffix is not None: + self.tempfile_suffix = tempfile_suffix + if tempfile is not None: + self.tempfile = tempfile + + self._add_pre_run_callables(pre_run, accept_default) + self.default_buffer.reset( + default if isinstance(default, Document) else Document(default) + ) + self.app.refresh_interval = self.refresh_interval # This is not reactive. + + # If we are using the default output, and have a dumb terminal. Use the + # dumb prompt. + if self._output is None and is_dumb_terminal(): + with self._dumb_prompt(self.message) as dump_app: + return dump_app.run(in_thread=in_thread, handle_sigint=handle_sigint) + + return self.app.run( + set_exception_handler=set_exception_handler, + in_thread=in_thread, + handle_sigint=handle_sigint, + inputhook=inputhook, + ) + + @contextmanager + def _dumb_prompt(self, message: AnyFormattedText = "") -> Iterator[Application[_T]]: + """ + Create prompt `Application` for prompt function for dumb terminals. + + Dumb terminals have minimum rendering capabilities. We can only print + text to the screen. We can't use colors, and we can't do cursor + movements. The Emacs inferior shell is an example of a dumb terminal. + + We will show the prompt, and wait for the input. We still handle arrow + keys, and all custom key bindings, but we don't really render the + cursor movements. Instead we only print the typed character that's + right before the cursor. + """ + # Send prompt to output. + self.output.write(fragment_list_to_text(to_formatted_text(self.message))) + self.output.flush() + + # Key bindings for the dumb prompt: mostly the same as the full prompt. + key_bindings: KeyBindingsBase = self._create_prompt_bindings() + if self.key_bindings: + key_bindings = merge_key_bindings([self.key_bindings, key_bindings]) + + # Create and run application. + application = cast( + Application[_T], + Application( + input=self.input, + output=DummyOutput(), + layout=self.layout, + key_bindings=key_bindings, + ), + ) + + def on_text_changed(_: object) -> None: + self.output.write(self.default_buffer.document.text_before_cursor[-1:]) + self.output.flush() + + self.default_buffer.on_text_changed += on_text_changed + + try: + yield application + finally: + # Render line ending. + self.output.write("\r\n") + self.output.flush() + + self.default_buffer.on_text_changed -= on_text_changed + + async def prompt_async( + self, + # When any of these arguments are passed, this value is overwritten + # in this PromptSession. + message: AnyFormattedText | None = None, + # `message` should go first, because people call it as + # positional argument. + *, + editing_mode: EditingMode | None = None, + refresh_interval: float | None = None, + vi_mode: bool | None = None, + lexer: Lexer | None = None, + completer: Completer | None = None, + complete_in_thread: bool | None = None, + is_password: bool | None = None, + key_bindings: KeyBindingsBase | None = None, + bottom_toolbar: AnyFormattedText | None = None, + style: BaseStyle | None = None, + color_depth: ColorDepth | None = None, + cursor: CursorShapeConfig | None = None, + include_default_pygments_style: FilterOrBool | None = None, + style_transformation: StyleTransformation | None = None, + swap_light_and_dark_colors: FilterOrBool | None = None, + rprompt: AnyFormattedText | None = None, + multiline: FilterOrBool | None = None, + prompt_continuation: PromptContinuationText | None = None, + wrap_lines: FilterOrBool | None = None, + enable_history_search: FilterOrBool | None = None, + search_ignore_case: FilterOrBool | None = None, + complete_while_typing: FilterOrBool | None = None, + validate_while_typing: FilterOrBool | None = None, + complete_style: CompleteStyle | None = None, + auto_suggest: AutoSuggest | None = None, + validator: Validator | None = None, + clipboard: Clipboard | None = None, + mouse_support: FilterOrBool | None = None, + input_processors: list[Processor] | None = None, + placeholder: AnyFormattedText | None = None, + reserve_space_for_menu: int | None = None, + enable_system_prompt: FilterOrBool | None = None, + enable_suspend: FilterOrBool | None = None, + enable_open_in_editor: FilterOrBool | None = None, + tempfile_suffix: str | Callable[[], str] | None = None, + tempfile: str | Callable[[], str] | None = None, + # Following arguments are specific to the current `prompt()` call. + default: str | Document = "", + accept_default: bool = False, + pre_run: Callable[[], None] | None = None, + set_exception_handler: bool = True, + handle_sigint: bool = True, + ) -> _T: + if message is not None: + self.message = message + if editing_mode is not None: + self.editing_mode = editing_mode + if refresh_interval is not None: + self.refresh_interval = refresh_interval + if vi_mode: + self.editing_mode = EditingMode.VI + if lexer is not None: + self.lexer = lexer + if completer is not None: + self.completer = completer + if complete_in_thread is not None: + self.complete_in_thread = complete_in_thread + if is_password is not None: + self.is_password = is_password + if key_bindings is not None: + self.key_bindings = key_bindings + if bottom_toolbar is not None: + self.bottom_toolbar = bottom_toolbar + if style is not None: + self.style = style + if color_depth is not None: + self.color_depth = color_depth + if cursor is not None: + self.cursor = cursor + if include_default_pygments_style is not None: + self.include_default_pygments_style = include_default_pygments_style + if style_transformation is not None: + self.style_transformation = style_transformation + if swap_light_and_dark_colors is not None: + self.swap_light_and_dark_colors = swap_light_and_dark_colors + if rprompt is not None: + self.rprompt = rprompt + if multiline is not None: + self.multiline = multiline + if prompt_continuation is not None: + self.prompt_continuation = prompt_continuation + if wrap_lines is not None: + self.wrap_lines = wrap_lines + if enable_history_search is not None: + self.enable_history_search = enable_history_search + if search_ignore_case is not None: + self.search_ignore_case = search_ignore_case + if complete_while_typing is not None: + self.complete_while_typing = complete_while_typing + if validate_while_typing is not None: + self.validate_while_typing = validate_while_typing + if complete_style is not None: + self.complete_style = complete_style + if auto_suggest is not None: + self.auto_suggest = auto_suggest + if validator is not None: + self.validator = validator + if clipboard is not None: + self.clipboard = clipboard + if mouse_support is not None: + self.mouse_support = mouse_support + if input_processors is not None: + self.input_processors = input_processors + if placeholder is not None: + self.placeholder = placeholder + if reserve_space_for_menu is not None: + self.reserve_space_for_menu = reserve_space_for_menu + if enable_system_prompt is not None: + self.enable_system_prompt = enable_system_prompt + if enable_suspend is not None: + self.enable_suspend = enable_suspend + if enable_open_in_editor is not None: + self.enable_open_in_editor = enable_open_in_editor + if tempfile_suffix is not None: + self.tempfile_suffix = tempfile_suffix + if tempfile is not None: + self.tempfile = tempfile + + self._add_pre_run_callables(pre_run, accept_default) + self.default_buffer.reset( + default if isinstance(default, Document) else Document(default) + ) + self.app.refresh_interval = self.refresh_interval # This is not reactive. + + # If we are using the default output, and have a dumb terminal. Use the + # dumb prompt. + if self._output is None and is_dumb_terminal(): + with self._dumb_prompt(self.message) as dump_app: + return await dump_app.run_async(handle_sigint=handle_sigint) + + return await self.app.run_async( + set_exception_handler=set_exception_handler, handle_sigint=handle_sigint + ) + + def _add_pre_run_callables( + self, pre_run: Callable[[], None] | None, accept_default: bool + ) -> None: + def pre_run2() -> None: + if pre_run: + pre_run() + + if accept_default: + # Validate and handle input. We use `call_from_executor` in + # order to run it "soon" (during the next iteration of the + # event loop), instead of right now. Otherwise, it won't + # display the default value. + get_running_loop().call_soon(self.default_buffer.validate_and_handle) + + self.app.pre_run_callables.append(pre_run2) + + @property + def editing_mode(self) -> EditingMode: + return self.app.editing_mode + + @editing_mode.setter + def editing_mode(self, value: EditingMode) -> None: + self.app.editing_mode = value + + def _get_default_buffer_control_height(self) -> Dimension: + # If there is an autocompletion menu to be shown, make sure that our + # layout has at least a minimal height in order to display it. + if ( + self.completer is not None + and self.complete_style != CompleteStyle.READLINE_LIKE + ): + space = self.reserve_space_for_menu + else: + space = 0 + + if space and not get_app().is_done: + buff = self.default_buffer + + # Reserve the space, either when there are completions, or when + # `complete_while_typing` is true and we expect completions very + # soon. + if buff.complete_while_typing() or buff.complete_state is not None: + return Dimension(min=space) + + return Dimension() + + def _get_prompt(self) -> StyleAndTextTuples: + return to_formatted_text(self.message, style="class:prompt") + + def _get_continuation( + self, width: int, line_number: int, wrap_count: int + ) -> StyleAndTextTuples: + """ + Insert the prompt continuation. + + :param width: The width that was used for the prompt. (more or less can + be used.) + :param line_number: + :param wrap_count: Amount of times that the line has been wrapped. + """ + prompt_continuation = self.prompt_continuation + + if callable(prompt_continuation): + continuation: AnyFormattedText = prompt_continuation( + width, line_number, wrap_count + ) + else: + continuation = prompt_continuation + + # When the continuation prompt is not given, choose the same width as + # the actual prompt. + if continuation is None and is_true(self.multiline): + continuation = " " * width + + return to_formatted_text(continuation, style="class:prompt-continuation") + + def _get_line_prefix( + self, + line_number: int, + wrap_count: int, + get_prompt_text_2: _StyleAndTextTuplesCallable, + ) -> StyleAndTextTuples: + """ + Return whatever needs to be inserted before every line. + (the prompt, or a line continuation.) + """ + # First line: display the "arg" or the prompt. + if line_number == 0 and wrap_count == 0: + if not is_true(self.multiline) and get_app().key_processor.arg is not None: + return self._inline_arg() + else: + return get_prompt_text_2() + + # For the next lines, display the appropriate continuation. + prompt_width = get_cwidth(fragment_list_to_text(get_prompt_text_2())) + return self._get_continuation(prompt_width, line_number, wrap_count) + + def _get_arg_text(self) -> StyleAndTextTuples: + "'arg' toolbar, for in multiline mode." + arg = self.app.key_processor.arg + if arg is None: + # Should not happen because of the `has_arg` filter in the layout. + return [] + + if arg == "-": + arg = "-1" + + return [("class:arg-toolbar", "Repeat: "), ("class:arg-toolbar.text", arg)] + + def _inline_arg(self) -> StyleAndTextTuples: + "'arg' prefix, for in single line mode." + app = get_app() + if app.key_processor.arg is None: + return [] + else: + arg = app.key_processor.arg + + return [ + ("class:prompt.arg", "(arg: "), + ("class:prompt.arg.text", str(arg)), + ("class:prompt.arg", ") "), + ] + + # Expose the Input and Output objects as attributes, mainly for + # backward-compatibility. + + @property + def input(self) -> Input: + return self.app.input + + @property + def output(self) -> Output: + return self.app.output + + +def prompt( + message: AnyFormattedText | None = None, + *, + history: History | None = None, + editing_mode: EditingMode | None = None, + refresh_interval: float | None = None, + vi_mode: bool | None = None, + lexer: Lexer | None = None, + completer: Completer | None = None, + complete_in_thread: bool | None = None, + is_password: bool | None = None, + key_bindings: KeyBindingsBase | None = None, + bottom_toolbar: AnyFormattedText | None = None, + style: BaseStyle | None = None, + color_depth: ColorDepth | None = None, + cursor: AnyCursorShapeConfig = None, + include_default_pygments_style: FilterOrBool | None = None, + style_transformation: StyleTransformation | None = None, + swap_light_and_dark_colors: FilterOrBool | None = None, + rprompt: AnyFormattedText | None = None, + multiline: FilterOrBool | None = None, + prompt_continuation: PromptContinuationText | None = None, + wrap_lines: FilterOrBool | None = None, + enable_history_search: FilterOrBool | None = None, + search_ignore_case: FilterOrBool | None = None, + complete_while_typing: FilterOrBool | None = None, + validate_while_typing: FilterOrBool | None = None, + complete_style: CompleteStyle | None = None, + auto_suggest: AutoSuggest | None = None, + validator: Validator | None = None, + clipboard: Clipboard | None = None, + mouse_support: FilterOrBool | None = None, + input_processors: list[Processor] | None = None, + placeholder: AnyFormattedText | None = None, + reserve_space_for_menu: int | None = None, + enable_system_prompt: FilterOrBool | None = None, + enable_suspend: FilterOrBool | None = None, + enable_open_in_editor: FilterOrBool | None = None, + tempfile_suffix: str | Callable[[], str] | None = None, + tempfile: str | Callable[[], str] | None = None, + # Following arguments are specific to the current `prompt()` call. + default: str = "", + accept_default: bool = False, + pre_run: Callable[[], None] | None = None, + set_exception_handler: bool = True, + handle_sigint: bool = True, + in_thread: bool = False, + inputhook: InputHook | None = None, +) -> str: + """ + The global `prompt` function. This will create a new `PromptSession` + instance for every call. + """ + # The history is the only attribute that has to be passed to the + # `PromptSession`, it can't be passed into the `prompt()` method. + session: PromptSession[str] = PromptSession(history=history) + + return session.prompt( + message, + editing_mode=editing_mode, + refresh_interval=refresh_interval, + vi_mode=vi_mode, + lexer=lexer, + completer=completer, + complete_in_thread=complete_in_thread, + is_password=is_password, + key_bindings=key_bindings, + bottom_toolbar=bottom_toolbar, + style=style, + color_depth=color_depth, + cursor=cursor, + include_default_pygments_style=include_default_pygments_style, + style_transformation=style_transformation, + swap_light_and_dark_colors=swap_light_and_dark_colors, + rprompt=rprompt, + multiline=multiline, + prompt_continuation=prompt_continuation, + wrap_lines=wrap_lines, + enable_history_search=enable_history_search, + search_ignore_case=search_ignore_case, + complete_while_typing=complete_while_typing, + validate_while_typing=validate_while_typing, + complete_style=complete_style, + auto_suggest=auto_suggest, + validator=validator, + clipboard=clipboard, + mouse_support=mouse_support, + input_processors=input_processors, + placeholder=placeholder, + reserve_space_for_menu=reserve_space_for_menu, + enable_system_prompt=enable_system_prompt, + enable_suspend=enable_suspend, + enable_open_in_editor=enable_open_in_editor, + tempfile_suffix=tempfile_suffix, + tempfile=tempfile, + default=default, + accept_default=accept_default, + pre_run=pre_run, + set_exception_handler=set_exception_handler, + handle_sigint=handle_sigint, + in_thread=in_thread, + inputhook=inputhook, + ) + + +prompt.__doc__ = PromptSession.prompt.__doc__ + + +def create_confirm_session( + message: str, suffix: str = " (y/n) " +) -> PromptSession[bool]: + """ + Create a `PromptSession` object for the 'confirm' function. + """ + bindings = KeyBindings() + + @bindings.add("y") + @bindings.add("Y") + def yes(event: E) -> None: + session.default_buffer.text = "y" + event.app.exit(result=True) + + @bindings.add("n") + @bindings.add("N") + def no(event: E) -> None: + session.default_buffer.text = "n" + event.app.exit(result=False) + + @bindings.add(Keys.Any) + def _(event: E) -> None: + "Disallow inserting other text." + pass + + complete_message = merge_formatted_text([message, suffix]) + session: PromptSession[bool] = PromptSession( + complete_message, key_bindings=bindings + ) + return session + + +def confirm(message: str = "Confirm?", suffix: str = " (y/n) ") -> bool: + """ + Display a confirmation prompt that returns True/False. + """ + session = create_confirm_session(message, suffix) + return session.prompt() diff --git a/shared/package-files/31/3161457268ced10c4cf054bc897482b5f1a793a7aa1b6905cafd6edaa9d2794a/blob b/shared/package-files/31/3161457268ced10c4cf054bc897482b5f1a793a7aa1b6905cafd6edaa9d2794a/blob new file mode 100644 index 0000000000000000000000000000000000000000..461b0f2ed2dd4d043902d054e10a5f39ffb069c9 --- /dev/null +++ b/shared/package-files/31/3161457268ced10c4cf054bc897482b5f1a793a7aa1b6905cafd6edaa9d2794a/blob @@ -0,0 +1,280 @@ +import itertools + +import networkx as nx +from networkx.algorithms.approximation import ( + treewidth_min_degree, + treewidth_min_fill_in, +) +from networkx.algorithms.approximation.treewidth import ( + MinDegreeHeuristic, + min_fill_in_heuristic, +) + + +def is_tree_decomp(graph, decomp): + """Check if the given tree decomposition is valid.""" + for x in graph.nodes(): + appear_once = False + for bag in decomp.nodes(): + if x in bag: + appear_once = True + break + assert appear_once + + # Check if each connected pair of nodes are at least once together in a bag + for x, y in graph.edges(): + appear_together = False + for bag in decomp.nodes(): + if x in bag and y in bag: + appear_together = True + break + assert appear_together + + # Check if the nodes associated with vertex v form a connected subset of T + for v in graph.nodes(): + subset = [] + for bag in decomp.nodes(): + if v in bag: + subset.append(bag) + sub_graph = decomp.subgraph(subset) + assert nx.is_connected(sub_graph) + + +class TestTreewidthMinDegree: + """Unit tests for the min_degree function""" + + @classmethod + def setup_class(cls): + """Setup for different kinds of trees""" + cls.complete = nx.Graph() + cls.complete.add_edge(1, 2) + cls.complete.add_edge(2, 3) + cls.complete.add_edge(1, 3) + + cls.small_tree = nx.Graph() + cls.small_tree.add_edge(1, 3) + cls.small_tree.add_edge(4, 3) + cls.small_tree.add_edge(2, 3) + cls.small_tree.add_edge(3, 5) + cls.small_tree.add_edge(5, 6) + cls.small_tree.add_edge(5, 7) + cls.small_tree.add_edge(6, 7) + + cls.deterministic_graph = nx.Graph() + cls.deterministic_graph.add_edge(0, 1) # deg(0) = 1 + + cls.deterministic_graph.add_edge(1, 2) # deg(1) = 2 + + cls.deterministic_graph.add_edge(2, 3) + cls.deterministic_graph.add_edge(2, 4) # deg(2) = 3 + + cls.deterministic_graph.add_edge(3, 4) + cls.deterministic_graph.add_edge(3, 5) + cls.deterministic_graph.add_edge(3, 6) # deg(3) = 4 + + cls.deterministic_graph.add_edge(4, 5) + cls.deterministic_graph.add_edge(4, 6) + cls.deterministic_graph.add_edge(4, 7) # deg(4) = 5 + + cls.deterministic_graph.add_edge(5, 6) + cls.deterministic_graph.add_edge(5, 7) + cls.deterministic_graph.add_edge(5, 8) + cls.deterministic_graph.add_edge(5, 9) # deg(5) = 6 + + cls.deterministic_graph.add_edge(6, 7) + cls.deterministic_graph.add_edge(6, 8) + cls.deterministic_graph.add_edge(6, 9) # deg(6) = 6 + + cls.deterministic_graph.add_edge(7, 8) + cls.deterministic_graph.add_edge(7, 9) # deg(7) = 5 + + cls.deterministic_graph.add_edge(8, 9) # deg(8) = 4 + + def test_petersen_graph(self): + """Test Petersen graph tree decomposition result""" + G = nx.petersen_graph() + _, decomp = treewidth_min_degree(G) + is_tree_decomp(G, decomp) + + def test_small_tree_treewidth(self): + """Test small tree + + Test if the computed treewidth of the known self.small_tree is 2. + As we know which value we can expect from our heuristic, values other + than two are regressions + """ + G = self.small_tree + # the order of removal should be [1,2,4]3[5,6,7] + # (with [] denoting any order of the containing nodes) + # resulting in treewidth 2 for the heuristic + treewidth, _ = treewidth_min_fill_in(G) + assert treewidth == 2 + + def test_heuristic_abort(self): + """Test heuristic abort condition for fully connected graph""" + graph = {} + for u in self.complete: + graph[u] = set() + for v in self.complete[u]: + if u != v: # ignore self-loop + graph[u].add(v) + + deg_heuristic = MinDegreeHeuristic(graph) + node = deg_heuristic.best_node(graph) + if node is None: + pass + else: + assert False + + def test_empty_graph(self): + """Test empty graph""" + G = nx.Graph() + _, _ = treewidth_min_degree(G) + + def test_two_component_graph(self): + G = nx.Graph() + G.add_node(1) + G.add_node(2) + treewidth, _ = treewidth_min_degree(G) + assert treewidth == 0 + + def test_not_sortable_nodes(self): + G = nx.Graph([(0, "a")]) + treewidth_min_degree(G) + + def test_heuristic_first_steps(self): + """Test first steps of min_degree heuristic""" + graph = { + n: set(self.deterministic_graph[n]) - {n} for n in self.deterministic_graph + } + deg_heuristic = MinDegreeHeuristic(graph) + elim_node = deg_heuristic.best_node(graph) + print(f"Graph {graph}:") + steps = [] + + while elim_node is not None: + print(f"Removing {elim_node}:") + steps.append(elim_node) + nbrs = graph[elim_node] + + for u, v in itertools.permutations(nbrs, 2): + if v not in graph[u]: + graph[u].add(v) + + for u in graph: + if elim_node in graph[u]: + graph[u].remove(elim_node) + + del graph[elim_node] + print(f"Graph {graph}:") + elim_node = deg_heuristic.best_node(graph) + + # check only the first 5 elements for equality + assert steps[:5] == [0, 1, 2, 3, 4] + + +class TestTreewidthMinFillIn: + """Unit tests for the treewidth_min_fill_in function.""" + + @classmethod + def setup_class(cls): + """Setup for different kinds of trees""" + cls.complete = nx.Graph() + cls.complete.add_edge(1, 2) + cls.complete.add_edge(2, 3) + cls.complete.add_edge(1, 3) + + cls.small_tree = nx.Graph() + cls.small_tree.add_edge(1, 2) + cls.small_tree.add_edge(2, 3) + cls.small_tree.add_edge(3, 4) + cls.small_tree.add_edge(1, 4) + cls.small_tree.add_edge(2, 4) + cls.small_tree.add_edge(4, 5) + cls.small_tree.add_edge(5, 6) + cls.small_tree.add_edge(5, 7) + cls.small_tree.add_edge(6, 7) + + cls.deterministic_graph = nx.Graph() + cls.deterministic_graph.add_edge(1, 2) + cls.deterministic_graph.add_edge(1, 3) + cls.deterministic_graph.add_edge(3, 4) + cls.deterministic_graph.add_edge(2, 4) + cls.deterministic_graph.add_edge(3, 5) + cls.deterministic_graph.add_edge(4, 5) + cls.deterministic_graph.add_edge(3, 6) + cls.deterministic_graph.add_edge(5, 6) + + def test_petersen_graph(self): + """Test Petersen graph tree decomposition result""" + G = nx.petersen_graph() + _, decomp = treewidth_min_fill_in(G) + is_tree_decomp(G, decomp) + + def test_small_tree_treewidth(self): + """Test if the computed treewidth of the known self.small_tree is 2""" + G = self.small_tree + # the order of removal should be [1,2,4]3[5,6,7] + # (with [] denoting any order of the containing nodes) + # resulting in treewidth 2 for the heuristic + treewidth, _ = treewidth_min_fill_in(G) + assert treewidth == 2 + + def test_heuristic_abort(self): + """Test if min_fill_in returns None for fully connected graph""" + graph = {} + for u in self.complete: + graph[u] = set() + for v in self.complete[u]: + if u != v: # ignore self-loop + graph[u].add(v) + next_node = min_fill_in_heuristic(graph) + if next_node is None: + pass + else: + assert False + + def test_empty_graph(self): + """Test empty graph""" + G = nx.Graph() + _, _ = treewidth_min_fill_in(G) + + def test_two_component_graph(self): + G = nx.Graph() + G.add_node(1) + G.add_node(2) + treewidth, _ = treewidth_min_fill_in(G) + assert treewidth == 0 + + def test_not_sortable_nodes(self): + G = nx.Graph([(0, "a")]) + treewidth_min_fill_in(G) + + def test_heuristic_first_steps(self): + """Test first steps of min_fill_in heuristic""" + graph = { + n: set(self.deterministic_graph[n]) - {n} for n in self.deterministic_graph + } + print(f"Graph {graph}:") + elim_node = min_fill_in_heuristic(graph) + steps = [] + + while elim_node is not None: + print(f"Removing {elim_node}:") + steps.append(elim_node) + nbrs = graph[elim_node] + + for u, v in itertools.permutations(nbrs, 2): + if v not in graph[u]: + graph[u].add(v) + + for u in graph: + if elim_node in graph[u]: + graph[u].remove(elim_node) + + del graph[elim_node] + print(f"Graph {graph}:") + elim_node = min_fill_in_heuristic(graph) + + # check only the first 2 elements for equality + assert steps[:2] == [6, 5] diff --git a/shared/package-files/31/3162c6ef898b0f58aaaab51bc7b64de803ee6797868bcf323db2b4cda8e5dd54/blob b/shared/package-files/31/3162c6ef898b0f58aaaab51bc7b64de803ee6797868bcf323db2b4cda8e5dd54/blob new file mode 100644 index 0000000000000000000000000000000000000000..34643f3946896ce2c76b7f8c94ce2df0cc85d7bb --- /dev/null +++ b/shared/package-files/31/3162c6ef898b0f58aaaab51bc7b64de803ee6797868bcf323db2b4cda8e5dd54/blob @@ -0,0 +1,217 @@ +""" + pygments.sphinxext + ~~~~~~~~~~~~~~~~~~ + + Sphinx extension to generate automatic documentation of lexers, + formatters and filters. + + :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS. + :license: BSD, see LICENSE for details. +""" + +import sys + +from docutils import nodes +from docutils.statemachine import ViewList +from docutils.parsers.rst import Directive +from sphinx.util.nodes import nested_parse_with_titles + + +MODULEDOC = ''' +.. module:: %s + +%s +%s +''' + +LEXERDOC = ''' +.. class:: %s + + :Short names: %s + :Filenames: %s + :MIME types: %s + + %s + +''' + +FMTERDOC = ''' +.. class:: %s + + :Short names: %s + :Filenames: %s + + %s + +''' + +FILTERDOC = ''' +.. class:: %s + + :Name: %s + + %s + +''' + + +class PygmentsDoc(Directive): + """ + A directive to collect all lexers/formatters/filters and generate + autoclass directives for them. + """ + has_content = False + required_arguments = 1 + optional_arguments = 0 + final_argument_whitespace = False + option_spec = {} + + def run(self): + self.filenames = set() + if self.arguments[0] == 'lexers': + out = self.document_lexers() + elif self.arguments[0] == 'formatters': + out = self.document_formatters() + elif self.arguments[0] == 'filters': + out = self.document_filters() + elif self.arguments[0] == 'lexers_overview': + out = self.document_lexers_overview() + else: + raise Exception('invalid argument for "pygmentsdoc" directive') + node = nodes.compound() + vl = ViewList(out.split('\n'), source='') + nested_parse_with_titles(self.state, vl, node) + for fn in self.filenames: + self.state.document.settings.record_dependencies.add(fn) + return node.children + + def document_lexers_overview(self): + """Generate a tabular overview of all lexers. + + The columns are the lexer name, the extensions handled by this lexer + (or "None"), the aliases and a link to the lexer class.""" + from pygments.lexers._mapping import LEXERS + import pygments.lexers + out = [] + + table = [] + + def format_link(name, url): + if url: + return f'`{name} <{url}>`_' + return name + + for classname, data in sorted(LEXERS.items(), key=lambda x: x[1][1].lower()): + lexer_cls = pygments.lexers.find_lexer_class(data[1]) + extensions = lexer_cls.filenames + lexer_cls.alias_filenames + + table.append({ + 'name': format_link(data[1], lexer_cls.url), + 'extensions': ', '.join(extensions).replace('*', '\\*').replace('_', '\\') or 'None', + 'aliases': ', '.join(data[2]), + 'class': f'{data[0]}.{classname}' + }) + + column_names = ['name', 'extensions', 'aliases', 'class'] + column_lengths = [max([len(row[column]) for row in table if row[column]]) + for column in column_names] + + def write_row(*columns): + """Format a table row""" + out = [] + for l, c in zip(column_lengths, columns): + if c: + out.append(c.ljust(l)) + else: + out.append(' '*l) + + return ' '.join(out) + + def write_seperator(): + """Write a table separator row""" + sep = ['='*c for c in column_lengths] + return write_row(*sep) + + out.append(write_seperator()) + out.append(write_row('Name', 'Extension(s)', 'Short name(s)', 'Lexer class')) + out.append(write_seperator()) + for row in table: + out.append(write_row( + row['name'], + row['extensions'], + row['aliases'], + f':class:`~{row["class"]}`')) + out.append(write_seperator()) + + return '\n'.join(out) + + def document_lexers(self): + from pygments.lexers._mapping import LEXERS + out = [] + modules = {} + moduledocstrings = {} + for classname, data in sorted(LEXERS.items(), key=lambda x: x[0]): + module = data[0] + mod = __import__(module, None, None, [classname]) + self.filenames.add(mod.__file__) + cls = getattr(mod, classname) + if not cls.__doc__: + print("Warning: %s does not have a docstring." % classname) + docstring = cls.__doc__ + if isinstance(docstring, bytes): + docstring = docstring.decode('utf8') + modules.setdefault(module, []).append(( + classname, + ', '.join(data[2]) or 'None', + ', '.join(data[3]).replace('*', '\\*').replace('_', '\\') or 'None', + ', '.join(data[4]) or 'None', + docstring)) + if module not in moduledocstrings: + moddoc = mod.__doc__ + if isinstance(moddoc, bytes): + moddoc = moddoc.decode('utf8') + moduledocstrings[module] = moddoc + + for module, lexers in sorted(modules.items(), key=lambda x: x[0]): + if moduledocstrings[module] is None: + raise Exception("Missing docstring for %s" % (module,)) + heading = moduledocstrings[module].splitlines()[4].strip().rstrip('.') + out.append(MODULEDOC % (module, heading, '-'*len(heading))) + for data in lexers: + out.append(LEXERDOC % data) + + return ''.join(out) + + def document_formatters(self): + from pygments.formatters import FORMATTERS + + out = [] + for classname, data in sorted(FORMATTERS.items(), key=lambda x: x[0]): + module = data[0] + mod = __import__(module, None, None, [classname]) + self.filenames.add(mod.__file__) + cls = getattr(mod, classname) + docstring = cls.__doc__ + if isinstance(docstring, bytes): + docstring = docstring.decode('utf8') + heading = cls.__name__ + out.append(FMTERDOC % (heading, ', '.join(data[2]) or 'None', + ', '.join(data[3]).replace('*', '\\*') or 'None', + docstring)) + return ''.join(out) + + def document_filters(self): + from pygments.filters import FILTERS + + out = [] + for name, cls in FILTERS.items(): + self.filenames.add(sys.modules[cls.__module__].__file__) + docstring = cls.__doc__ + if isinstance(docstring, bytes): + docstring = docstring.decode('utf8') + out.append(FILTERDOC % (cls.__name__, name, docstring)) + return ''.join(out) + + +def setup(app): + app.add_directive('pygmentsdoc', PygmentsDoc) diff --git a/shared/package-files/31/316647a481a6e4ae573f235c6d6a9f260a26ce1ca7176c57d9d8f166925f10ba/blob b/shared/package-files/31/316647a481a6e4ae573f235c6d6a9f260a26ce1ca7176c57d9d8f166925f10ba/blob new file mode 100644 index 0000000000000000000000000000000000000000..65ddaa2b70b4adb06bb4bfc61433c1f6cd4ae112 --- /dev/null +++ b/shared/package-files/31/316647a481a6e4ae573f235c6d6a9f260a26ce1ca7176c57d9d8f166925f10ba/blob @@ -0,0 +1,430 @@ +"""Betweenness centrality measures.""" +from collections import deque +from heapq import heappop, heappush +from itertools import count + +import networkx as nx +from networkx.algorithms.shortest_paths.weighted import _weight_function +from networkx.utils import py_random_state +from networkx.utils.decorators import not_implemented_for + +__all__ = ["betweenness_centrality", "edge_betweenness_centrality"] + + +@nx._dispatch +@py_random_state(5) +def betweenness_centrality( + G, k=None, normalized=True, weight=None, endpoints=False, seed=None +): + r"""Compute the shortest-path betweenness centrality for nodes. + + Betweenness centrality of a node $v$ is the sum of the + fraction of all-pairs shortest paths that pass through $v$ + + .. math:: + + c_B(v) =\sum_{s,t \in V} \frac{\sigma(s, t|v)}{\sigma(s, t)} + + where $V$ is the set of nodes, $\sigma(s, t)$ is the number of + shortest $(s, t)$-paths, and $\sigma(s, t|v)$ is the number of + those paths passing through some node $v$ other than $s, t$. + If $s = t$, $\sigma(s, t) = 1$, and if $v \in {s, t}$, + $\sigma(s, t|v) = 0$ [2]_. + + Parameters + ---------- + G : graph + A NetworkX graph. + + k : int, optional (default=None) + If k is not None use k node samples to estimate betweenness. + The value of k <= n where n is the number of nodes in the graph. + Higher values give better approximation. + + normalized : bool, optional + If True the betweenness values are normalized by `2/((n-1)(n-2))` + for graphs, and `1/((n-1)(n-2))` for directed graphs where `n` + is the number of nodes in G. + + weight : None or string, optional (default=None) + If None, all edge weights are considered equal. + Otherwise holds the name of the edge attribute used as weight. + Weights are used to calculate weighted shortest paths, so they are + interpreted as distances. + + endpoints : bool, optional + If True include the endpoints in the shortest path counts. + + seed : integer, random_state, or None (default) + Indicator of random number generation state. + See :ref:`Randomness`. + Note that this is only used if k is not None. + + Returns + ------- + nodes : dictionary + Dictionary of nodes with betweenness centrality as the value. + + See Also + -------- + edge_betweenness_centrality + load_centrality + + Notes + ----- + The algorithm is from Ulrik Brandes [1]_. + See [4]_ for the original first published version and [2]_ for details on + algorithms for variations and related metrics. + + For approximate betweenness calculations set k=#samples to use + k nodes ("pivots") to estimate the betweenness values. For an estimate + of the number of pivots needed see [3]_. + + For weighted graphs the edge weights must be greater than zero. + Zero edge weights can produce an infinite number of equal length + paths between pairs of nodes. + + The total number of paths between source and target is counted + differently for directed and undirected graphs. Directed paths + are easy to count. Undirected paths are tricky: should a path + from "u" to "v" count as 1 undirected path or as 2 directed paths? + + For betweenness_centrality we report the number of undirected + paths when G is undirected. + + For betweenness_centrality_subset the reporting is different. + If the source and target subsets are the same, then we want + to count undirected paths. But if the source and target subsets + differ -- for example, if sources is {0} and targets is {1}, + then we are only counting the paths in one direction. They are + undirected paths but we are counting them in a directed way. + To count them as undirected paths, each should count as half a path. + + References + ---------- + .. [1] Ulrik Brandes: + A Faster Algorithm for Betweenness Centrality. + Journal of Mathematical Sociology 25(2):163-177, 2001. + https://doi.org/10.1080/0022250X.2001.9990249 + .. [2] Ulrik Brandes: + On Variants of Shortest-Path Betweenness + Centrality and their Generic Computation. + Social Networks 30(2):136-145, 2008. + https://doi.org/10.1016/j.socnet.2007.11.001 + .. [3] Ulrik Brandes and Christian Pich: + Centrality Estimation in Large Networks. + International Journal of Bifurcation and Chaos 17(7):2303-2318, 2007. + https://dx.doi.org/10.1142/S0218127407018403 + .. [4] Linton C. Freeman: + A set of measures of centrality based on betweenness. + Sociometry 40: 35–41, 1977 + https://doi.org/10.2307/3033543 + """ + betweenness = dict.fromkeys(G, 0.0) # b[v]=0 for v in G + if k is None: + nodes = G + else: + nodes = seed.sample(list(G.nodes()), k) + for s in nodes: + # single source shortest paths + if weight is None: # use BFS + S, P, sigma, _ = _single_source_shortest_path_basic(G, s) + else: # use Dijkstra's algorithm + S, P, sigma, _ = _single_source_dijkstra_path_basic(G, s, weight) + # accumulation + if endpoints: + betweenness, _ = _accumulate_endpoints(betweenness, S, P, sigma, s) + else: + betweenness, _ = _accumulate_basic(betweenness, S, P, sigma, s) + # rescaling + betweenness = _rescale( + betweenness, + len(G), + normalized=normalized, + directed=G.is_directed(), + k=k, + endpoints=endpoints, + ) + return betweenness + + +@nx._dispatch +@py_random_state(4) +def edge_betweenness_centrality(G, k=None, normalized=True, weight=None, seed=None): + r"""Compute betweenness centrality for edges. + + Betweenness centrality of an edge $e$ is the sum of the + fraction of all-pairs shortest paths that pass through $e$ + + .. math:: + + c_B(e) =\sum_{s,t \in V} \frac{\sigma(s, t|e)}{\sigma(s, t)} + + where $V$ is the set of nodes, $\sigma(s, t)$ is the number of + shortest $(s, t)$-paths, and $\sigma(s, t|e)$ is the number of + those paths passing through edge $e$ [2]_. + + Parameters + ---------- + G : graph + A NetworkX graph. + + k : int, optional (default=None) + If k is not None use k node samples to estimate betweenness. + The value of k <= n where n is the number of nodes in the graph. + Higher values give better approximation. + + normalized : bool, optional + If True the betweenness values are normalized by $2/(n(n-1))$ + for graphs, and $1/(n(n-1))$ for directed graphs where $n$ + is the number of nodes in G. + + weight : None or string, optional (default=None) + If None, all edge weights are considered equal. + Otherwise holds the name of the edge attribute used as weight. + Weights are used to calculate weighted shortest paths, so they are + interpreted as distances. + + seed : integer, random_state, or None (default) + Indicator of random number generation state. + See :ref:`Randomness`. + Note that this is only used if k is not None. + + Returns + ------- + edges : dictionary + Dictionary of edges with betweenness centrality as the value. + + See Also + -------- + betweenness_centrality + edge_load + + Notes + ----- + The algorithm is from Ulrik Brandes [1]_. + + For weighted graphs the edge weights must be greater than zero. + Zero edge weights can produce an infinite number of equal length + paths between pairs of nodes. + + References + ---------- + .. [1] A Faster Algorithm for Betweenness Centrality. Ulrik Brandes, + Journal of Mathematical Sociology 25(2):163-177, 2001. + https://doi.org/10.1080/0022250X.2001.9990249 + .. [2] Ulrik Brandes: On Variants of Shortest-Path Betweenness + Centrality and their Generic Computation. + Social Networks 30(2):136-145, 2008. + https://doi.org/10.1016/j.socnet.2007.11.001 + """ + betweenness = dict.fromkeys(G, 0.0) # b[v]=0 for v in G + # b[e]=0 for e in G.edges() + betweenness.update(dict.fromkeys(G.edges(), 0.0)) + if k is None: + nodes = G + else: + nodes = seed.sample(list(G.nodes()), k) + for s in nodes: + # single source shortest paths + if weight is None: # use BFS + S, P, sigma, _ = _single_source_shortest_path_basic(G, s) + else: # use Dijkstra's algorithm + S, P, sigma, _ = _single_source_dijkstra_path_basic(G, s, weight) + # accumulation + betweenness = _accumulate_edges(betweenness, S, P, sigma, s) + # rescaling + for n in G: # remove nodes to only return edges + del betweenness[n] + betweenness = _rescale_e( + betweenness, len(G), normalized=normalized, directed=G.is_directed() + ) + if G.is_multigraph(): + betweenness = _add_edge_keys(G, betweenness, weight=weight) + return betweenness + + +# helpers for betweenness centrality + + +def _single_source_shortest_path_basic(G, s): + S = [] + P = {} + for v in G: + P[v] = [] + sigma = dict.fromkeys(G, 0.0) # sigma[v]=0 for v in G + D = {} + sigma[s] = 1.0 + D[s] = 0 + Q = deque([s]) + while Q: # use BFS to find shortest paths + v = Q.popleft() + S.append(v) + Dv = D[v] + sigmav = sigma[v] + for w in G[v]: + if w not in D: + Q.append(w) + D[w] = Dv + 1 + if D[w] == Dv + 1: # this is a shortest path, count paths + sigma[w] += sigmav + P[w].append(v) # predecessors + return S, P, sigma, D + + +def _single_source_dijkstra_path_basic(G, s, weight): + weight = _weight_function(G, weight) + # modified from Eppstein + S = [] + P = {} + for v in G: + P[v] = [] + sigma = dict.fromkeys(G, 0.0) # sigma[v]=0 for v in G + D = {} + sigma[s] = 1.0 + push = heappush + pop = heappop + seen = {s: 0} + c = count() + Q = [] # use Q as heap with (distance,node id) tuples + push(Q, (0, next(c), s, s)) + while Q: + (dist, _, pred, v) = pop(Q) + if v in D: + continue # already searched this node. + sigma[v] += sigma[pred] # count paths + S.append(v) + D[v] = dist + for w, edgedata in G[v].items(): + vw_dist = dist + weight(v, w, edgedata) + if w not in D and (w not in seen or vw_dist < seen[w]): + seen[w] = vw_dist + push(Q, (vw_dist, next(c), v, w)) + sigma[w] = 0.0 + P[w] = [v] + elif vw_dist == seen[w]: # handle equal paths + sigma[w] += sigma[v] + P[w].append(v) + return S, P, sigma, D + + +def _accumulate_basic(betweenness, S, P, sigma, s): + delta = dict.fromkeys(S, 0) + while S: + w = S.pop() + coeff = (1 + delta[w]) / sigma[w] + for v in P[w]: + delta[v] += sigma[v] * coeff + if w != s: + betweenness[w] += delta[w] + return betweenness, delta + + +def _accumulate_endpoints(betweenness, S, P, sigma, s): + betweenness[s] += len(S) - 1 + delta = dict.fromkeys(S, 0) + while S: + w = S.pop() + coeff = (1 + delta[w]) / sigma[w] + for v in P[w]: + delta[v] += sigma[v] * coeff + if w != s: + betweenness[w] += delta[w] + 1 + return betweenness, delta + + +def _accumulate_edges(betweenness, S, P, sigma, s): + delta = dict.fromkeys(S, 0) + while S: + w = S.pop() + coeff = (1 + delta[w]) / sigma[w] + for v in P[w]: + c = sigma[v] * coeff + if (v, w) not in betweenness: + betweenness[(w, v)] += c + else: + betweenness[(v, w)] += c + delta[v] += c + if w != s: + betweenness[w] += delta[w] + return betweenness + + +def _rescale(betweenness, n, normalized, directed=False, k=None, endpoints=False): + if normalized: + if endpoints: + if n < 2: + scale = None # no normalization + else: + # Scale factor should include endpoint nodes + scale = 1 / (n * (n - 1)) + elif n <= 2: + scale = None # no normalization b=0 for all nodes + else: + scale = 1 / ((n - 1) * (n - 2)) + else: # rescale by 2 for undirected graphs + if not directed: + scale = 0.5 + else: + scale = None + if scale is not None: + if k is not None: + scale = scale * n / k + for v in betweenness: + betweenness[v] *= scale + return betweenness + + +def _rescale_e(betweenness, n, normalized, directed=False, k=None): + if normalized: + if n <= 1: + scale = None # no normalization b=0 for all nodes + else: + scale = 1 / (n * (n - 1)) + else: # rescale by 2 for undirected graphs + if not directed: + scale = 0.5 + else: + scale = None + if scale is not None: + if k is not None: + scale = scale * n / k + for v in betweenness: + betweenness[v] *= scale + return betweenness + + +@not_implemented_for("graph") +def _add_edge_keys(G, betweenness, weight=None): + r"""Adds the corrected betweenness centrality (BC) values for multigraphs. + + Parameters + ---------- + G : NetworkX graph. + + betweenness : dictionary + Dictionary mapping adjacent node tuples to betweenness centrality values. + + weight : string or function + See `_weight_function` for details. Defaults to `None`. + + Returns + ------- + edges : dictionary + The parameter `betweenness` including edges with keys and their + betweenness centrality values. + + The BC value is divided among edges of equal weight. + """ + _weight = _weight_function(G, weight) + + edge_bc = dict.fromkeys(G.edges, 0.0) + for u, v in betweenness: + d = G[u][v] + wt = _weight(u, v, d) + keys = [k for k in d if _weight(u, v, {k: d[k]}) == wt] + bc = betweenness[(u, v)] / len(keys) + for k in keys: + edge_bc[(u, v, k)] = bc + + return edge_bc diff --git a/shared/package-files/31/31670da18ce8b5394cd53fe6bf216268e7e8eae4c0247532e420e2e103727d50/blob b/shared/package-files/31/31670da18ce8b5394cd53fe6bf216268e7e8eae4c0247532e420e2e103727d50/blob new file mode 100644 index 0000000000000000000000000000000000000000..da9d4b134ade7721535354bd50c9f809d4535017 --- /dev/null +++ b/shared/package-files/31/31670da18ce8b5394cd53fe6bf216268e7e8eae4c0247532e420e2e103727d50/blob @@ -0,0 +1,312 @@ +""" Python Character Mapping Codec mac_latin2 generated from 'MAPPINGS/VENDORS/MICSFT/MAC/LATIN2.TXT' with gencodec.py. + +Written by Marc-Andre Lemburg (mal@lemburg.com). + +(c) Copyright CNRI, All Rights Reserved. NO WARRANTY. +(c) Copyright 2000 Guido van Rossum. + +"""#" + +import codecs + +### Codec APIs + +class Codec(codecs.Codec): + + def encode(self,input,errors='strict'): + return codecs.charmap_encode(input,errors,encoding_table) + + def decode(self,input,errors='strict'): + return codecs.charmap_decode(input,errors,decoding_table) + +class IncrementalEncoder(codecs.IncrementalEncoder): + def encode(self, input, final=False): + return codecs.charmap_encode(input,self.errors,encoding_table)[0] + +class IncrementalDecoder(codecs.IncrementalDecoder): + def decode(self, input, final=False): + return codecs.charmap_decode(input,self.errors,decoding_table)[0] + +class StreamWriter(Codec,codecs.StreamWriter): + pass + +class StreamReader(Codec,codecs.StreamReader): + pass + +### encodings module API + +def getregentry(): + return codecs.CodecInfo( + name='mac-latin2', + encode=Codec().encode, + decode=Codec().decode, + incrementalencoder=IncrementalEncoder, + incrementaldecoder=IncrementalDecoder, + streamreader=StreamReader, + streamwriter=StreamWriter, + ) + + +### Decoding Table + +decoding_table = ( + '\x00' # 0x00 -> NULL + '\x01' # 0x01 -> START OF HEADING + '\x02' # 0x02 -> START OF TEXT + '\x03' # 0x03 -> END OF TEXT + '\x04' # 0x04 -> END OF TRANSMISSION + '\x05' # 0x05 -> ENQUIRY + '\x06' # 0x06 -> ACKNOWLEDGE + '\x07' # 0x07 -> BELL + '\x08' # 0x08 -> BACKSPACE + '\t' # 0x09 -> HORIZONTAL TABULATION + '\n' # 0x0A -> LINE FEED + '\x0b' # 0x0B -> VERTICAL TABULATION + '\x0c' # 0x0C -> FORM FEED + '\r' # 0x0D -> CARRIAGE RETURN + '\x0e' # 0x0E -> SHIFT OUT + '\x0f' # 0x0F -> SHIFT IN + '\x10' # 0x10 -> DATA LINK ESCAPE + '\x11' # 0x11 -> DEVICE CONTROL ONE + '\x12' # 0x12 -> DEVICE CONTROL TWO + '\x13' # 0x13 -> DEVICE CONTROL THREE + '\x14' # 0x14 -> DEVICE CONTROL FOUR + '\x15' # 0x15 -> NEGATIVE ACKNOWLEDGE + '\x16' # 0x16 -> SYNCHRONOUS IDLE + '\x17' # 0x17 -> END OF TRANSMISSION BLOCK + '\x18' # 0x18 -> CANCEL + '\x19' # 0x19 -> END OF MEDIUM + '\x1a' # 0x1A -> SUBSTITUTE + '\x1b' # 0x1B -> ESCAPE + '\x1c' # 0x1C -> FILE SEPARATOR + '\x1d' # 0x1D -> GROUP SEPARATOR + '\x1e' # 0x1E -> RECORD SEPARATOR + '\x1f' # 0x1F -> UNIT SEPARATOR + ' ' # 0x20 -> SPACE + '!' # 0x21 -> EXCLAMATION MARK + '"' # 0x22 -> QUOTATION MARK + '#' # 0x23 -> NUMBER SIGN + '$' # 0x24 -> DOLLAR SIGN + '%' # 0x25 -> PERCENT SIGN + '&' # 0x26 -> AMPERSAND + "'" # 0x27 -> APOSTROPHE + '(' # 0x28 -> LEFT PARENTHESIS + ')' # 0x29 -> RIGHT PARENTHESIS + '*' # 0x2A -> ASTERISK + '+' # 0x2B -> PLUS SIGN + ',' # 0x2C -> COMMA + '-' # 0x2D -> HYPHEN-MINUS + '.' # 0x2E -> FULL STOP + '/' # 0x2F -> SOLIDUS + '0' # 0x30 -> DIGIT ZERO + '1' # 0x31 -> DIGIT ONE + '2' # 0x32 -> DIGIT TWO + '3' # 0x33 -> DIGIT THREE + '4' # 0x34 -> DIGIT FOUR + '5' # 0x35 -> DIGIT FIVE + '6' # 0x36 -> DIGIT SIX + '7' # 0x37 -> DIGIT SEVEN + '8' # 0x38 -> DIGIT EIGHT + '9' # 0x39 -> DIGIT NINE + ':' # 0x3A -> COLON + ';' # 0x3B -> SEMICOLON + '<' # 0x3C -> LESS-THAN SIGN + '=' # 0x3D -> EQUALS SIGN + '>' # 0x3E -> GREATER-THAN SIGN + '?' # 0x3F -> QUESTION MARK + '@' # 0x40 -> COMMERCIAL AT + 'A' # 0x41 -> LATIN CAPITAL LETTER A + 'B' # 0x42 -> LATIN CAPITAL LETTER B + 'C' # 0x43 -> LATIN CAPITAL LETTER C + 'D' # 0x44 -> LATIN CAPITAL LETTER D + 'E' # 0x45 -> LATIN CAPITAL LETTER E + 'F' # 0x46 -> LATIN CAPITAL LETTER F + 'G' # 0x47 -> LATIN CAPITAL LETTER G + 'H' # 0x48 -> LATIN CAPITAL LETTER H + 'I' # 0x49 -> LATIN CAPITAL LETTER I + 'J' # 0x4A -> LATIN CAPITAL LETTER J + 'K' # 0x4B -> LATIN CAPITAL LETTER K + 'L' # 0x4C -> LATIN CAPITAL LETTER L + 'M' # 0x4D -> LATIN CAPITAL LETTER M + 'N' # 0x4E -> LATIN CAPITAL LETTER N + 'O' # 0x4F -> LATIN CAPITAL LETTER O + 'P' # 0x50 -> LATIN CAPITAL LETTER P + 'Q' # 0x51 -> LATIN CAPITAL LETTER Q + 'R' # 0x52 -> LATIN CAPITAL LETTER R + 'S' # 0x53 -> LATIN CAPITAL LETTER S + 'T' # 0x54 -> LATIN CAPITAL LETTER T + 'U' # 0x55 -> LATIN CAPITAL LETTER U + 'V' # 0x56 -> LATIN CAPITAL LETTER V + 'W' # 0x57 -> LATIN CAPITAL LETTER W + 'X' # 0x58 -> LATIN CAPITAL LETTER X + 'Y' # 0x59 -> LATIN CAPITAL LETTER Y + 'Z' # 0x5A -> LATIN CAPITAL LETTER Z + '[' # 0x5B -> LEFT SQUARE BRACKET + '\\' # 0x5C -> REVERSE SOLIDUS + ']' # 0x5D -> RIGHT SQUARE BRACKET + '^' # 0x5E -> CIRCUMFLEX ACCENT + '_' # 0x5F -> LOW LINE + '`' # 0x60 -> GRAVE ACCENT + 'a' # 0x61 -> LATIN SMALL LETTER A + 'b' # 0x62 -> LATIN SMALL LETTER B + 'c' # 0x63 -> LATIN SMALL LETTER C + 'd' # 0x64 -> LATIN SMALL LETTER D + 'e' # 0x65 -> LATIN SMALL LETTER E + 'f' # 0x66 -> LATIN SMALL LETTER F + 'g' # 0x67 -> LATIN SMALL LETTER G + 'h' # 0x68 -> LATIN SMALL LETTER H + 'i' # 0x69 -> LATIN SMALL LETTER I + 'j' # 0x6A -> LATIN SMALL LETTER J + 'k' # 0x6B -> LATIN SMALL LETTER K + 'l' # 0x6C -> LATIN SMALL LETTER L + 'm' # 0x6D -> LATIN SMALL LETTER M + 'n' # 0x6E -> LATIN SMALL LETTER N + 'o' # 0x6F -> LATIN SMALL LETTER O + 'p' # 0x70 -> LATIN SMALL LETTER P + 'q' # 0x71 -> LATIN SMALL LETTER Q + 'r' # 0x72 -> LATIN SMALL LETTER R + 's' # 0x73 -> LATIN SMALL LETTER S + 't' # 0x74 -> LATIN SMALL LETTER T + 'u' # 0x75 -> LATIN SMALL LETTER U + 'v' # 0x76 -> LATIN SMALL LETTER V + 'w' # 0x77 -> LATIN SMALL LETTER W + 'x' # 0x78 -> LATIN SMALL LETTER X + 'y' # 0x79 -> LATIN SMALL LETTER Y + 'z' # 0x7A -> LATIN SMALL LETTER Z + '{' # 0x7B -> LEFT CURLY BRACKET + '|' # 0x7C -> VERTICAL LINE + '}' # 0x7D -> RIGHT CURLY BRACKET + '~' # 0x7E -> TILDE + '\x7f' # 0x7F -> DELETE + '\xc4' # 0x80 -> LATIN CAPITAL LETTER A WITH DIAERESIS + '\u0100' # 0x81 -> LATIN CAPITAL LETTER A WITH MACRON + '\u0101' # 0x82 -> LATIN SMALL LETTER A WITH MACRON + '\xc9' # 0x83 -> LATIN CAPITAL LETTER E WITH ACUTE + '\u0104' # 0x84 -> LATIN CAPITAL LETTER A WITH OGONEK + '\xd6' # 0x85 -> LATIN CAPITAL LETTER O WITH DIAERESIS + '\xdc' # 0x86 -> LATIN CAPITAL LETTER U WITH DIAERESIS + '\xe1' # 0x87 -> LATIN SMALL LETTER A WITH ACUTE + '\u0105' # 0x88 -> LATIN SMALL LETTER A WITH OGONEK + '\u010c' # 0x89 -> LATIN CAPITAL LETTER C WITH CARON + '\xe4' # 0x8A -> LATIN SMALL LETTER A WITH DIAERESIS + '\u010d' # 0x8B -> LATIN SMALL LETTER C WITH CARON + '\u0106' # 0x8C -> LATIN CAPITAL LETTER C WITH ACUTE + '\u0107' # 0x8D -> LATIN SMALL LETTER C WITH ACUTE + '\xe9' # 0x8E -> LATIN SMALL LETTER E WITH ACUTE + '\u0179' # 0x8F -> LATIN CAPITAL LETTER Z WITH ACUTE + '\u017a' # 0x90 -> LATIN SMALL LETTER Z WITH ACUTE + '\u010e' # 0x91 -> LATIN CAPITAL LETTER D WITH CARON + '\xed' # 0x92 -> LATIN SMALL LETTER I WITH ACUTE + '\u010f' # 0x93 -> LATIN SMALL LETTER D WITH CARON + '\u0112' # 0x94 -> LATIN CAPITAL LETTER E WITH MACRON + '\u0113' # 0x95 -> LATIN SMALL LETTER E WITH MACRON + '\u0116' # 0x96 -> LATIN CAPITAL LETTER E WITH DOT ABOVE + '\xf3' # 0x97 -> LATIN SMALL LETTER O WITH ACUTE + '\u0117' # 0x98 -> LATIN SMALL LETTER E WITH DOT ABOVE + '\xf4' # 0x99 -> LATIN SMALL LETTER O WITH CIRCUMFLEX + '\xf6' # 0x9A -> LATIN SMALL LETTER O WITH DIAERESIS + '\xf5' # 0x9B -> LATIN SMALL LETTER O WITH TILDE + '\xfa' # 0x9C -> LATIN SMALL LETTER U WITH ACUTE + '\u011a' # 0x9D -> LATIN CAPITAL LETTER E WITH CARON + '\u011b' # 0x9E -> LATIN SMALL LETTER E WITH CARON + '\xfc' # 0x9F -> LATIN SMALL LETTER U WITH DIAERESIS + '\u2020' # 0xA0 -> DAGGER + '\xb0' # 0xA1 -> DEGREE SIGN + '\u0118' # 0xA2 -> LATIN CAPITAL LETTER E WITH OGONEK + '\xa3' # 0xA3 -> POUND SIGN + '\xa7' # 0xA4 -> SECTION SIGN + '\u2022' # 0xA5 -> BULLET + '\xb6' # 0xA6 -> PILCROW SIGN + '\xdf' # 0xA7 -> LATIN SMALL LETTER SHARP S + '\xae' # 0xA8 -> REGISTERED SIGN + '\xa9' # 0xA9 -> COPYRIGHT SIGN + '\u2122' # 0xAA -> TRADE MARK SIGN + '\u0119' # 0xAB -> LATIN SMALL LETTER E WITH OGONEK + '\xa8' # 0xAC -> DIAERESIS + '\u2260' # 0xAD -> NOT EQUAL TO + '\u0123' # 0xAE -> LATIN SMALL LETTER G WITH CEDILLA + '\u012e' # 0xAF -> LATIN CAPITAL LETTER I WITH OGONEK + '\u012f' # 0xB0 -> LATIN SMALL LETTER I WITH OGONEK + '\u012a' # 0xB1 -> LATIN CAPITAL LETTER I WITH MACRON + '\u2264' # 0xB2 -> LESS-THAN OR EQUAL TO + '\u2265' # 0xB3 -> GREATER-THAN OR EQUAL TO + '\u012b' # 0xB4 -> LATIN SMALL LETTER I WITH MACRON + '\u0136' # 0xB5 -> LATIN CAPITAL LETTER K WITH CEDILLA + '\u2202' # 0xB6 -> PARTIAL DIFFERENTIAL + '\u2211' # 0xB7 -> N-ARY SUMMATION + '\u0142' # 0xB8 -> LATIN SMALL LETTER L WITH STROKE + '\u013b' # 0xB9 -> LATIN CAPITAL LETTER L WITH CEDILLA + '\u013c' # 0xBA -> LATIN SMALL LETTER L WITH CEDILLA + '\u013d' # 0xBB -> LATIN CAPITAL LETTER L WITH CARON + '\u013e' # 0xBC -> LATIN SMALL LETTER L WITH CARON + '\u0139' # 0xBD -> LATIN CAPITAL LETTER L WITH ACUTE + '\u013a' # 0xBE -> LATIN SMALL LETTER L WITH ACUTE + '\u0145' # 0xBF -> LATIN CAPITAL LETTER N WITH CEDILLA + '\u0146' # 0xC0 -> LATIN SMALL LETTER N WITH CEDILLA + '\u0143' # 0xC1 -> LATIN CAPITAL LETTER N WITH ACUTE + '\xac' # 0xC2 -> NOT SIGN + '\u221a' # 0xC3 -> SQUARE ROOT + '\u0144' # 0xC4 -> LATIN SMALL LETTER N WITH ACUTE + '\u0147' # 0xC5 -> LATIN CAPITAL LETTER N WITH CARON + '\u2206' # 0xC6 -> INCREMENT + '\xab' # 0xC7 -> LEFT-POINTING DOUBLE ANGLE QUOTATION MARK + '\xbb' # 0xC8 -> RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK + '\u2026' # 0xC9 -> HORIZONTAL ELLIPSIS + '\xa0' # 0xCA -> NO-BREAK SPACE + '\u0148' # 0xCB -> LATIN SMALL LETTER N WITH CARON + '\u0150' # 0xCC -> LATIN CAPITAL LETTER O WITH DOUBLE ACUTE + '\xd5' # 0xCD -> LATIN CAPITAL LETTER O WITH TILDE + '\u0151' # 0xCE -> LATIN SMALL LETTER O WITH DOUBLE ACUTE + '\u014c' # 0xCF -> LATIN CAPITAL LETTER O WITH MACRON + '\u2013' # 0xD0 -> EN DASH + '\u2014' # 0xD1 -> EM DASH + '\u201c' # 0xD2 -> LEFT DOUBLE QUOTATION MARK + '\u201d' # 0xD3 -> RIGHT DOUBLE QUOTATION MARK + '\u2018' # 0xD4 -> LEFT SINGLE QUOTATION MARK + '\u2019' # 0xD5 -> RIGHT SINGLE QUOTATION MARK + '\xf7' # 0xD6 -> DIVISION SIGN + '\u25ca' # 0xD7 -> LOZENGE + '\u014d' # 0xD8 -> LATIN SMALL LETTER O WITH MACRON + '\u0154' # 0xD9 -> LATIN CAPITAL LETTER R WITH ACUTE + '\u0155' # 0xDA -> LATIN SMALL LETTER R WITH ACUTE + '\u0158' # 0xDB -> LATIN CAPITAL LETTER R WITH CARON + '\u2039' # 0xDC -> SINGLE LEFT-POINTING ANGLE QUOTATION MARK + '\u203a' # 0xDD -> SINGLE RIGHT-POINTING ANGLE QUOTATION MARK + '\u0159' # 0xDE -> LATIN SMALL LETTER R WITH CARON + '\u0156' # 0xDF -> LATIN CAPITAL LETTER R WITH CEDILLA + '\u0157' # 0xE0 -> LATIN SMALL LETTER R WITH CEDILLA + '\u0160' # 0xE1 -> LATIN CAPITAL LETTER S WITH CARON + '\u201a' # 0xE2 -> SINGLE LOW-9 QUOTATION MARK + '\u201e' # 0xE3 -> DOUBLE LOW-9 QUOTATION MARK + '\u0161' # 0xE4 -> LATIN SMALL LETTER S WITH CARON + '\u015a' # 0xE5 -> LATIN CAPITAL LETTER S WITH ACUTE + '\u015b' # 0xE6 -> LATIN SMALL LETTER S WITH ACUTE + '\xc1' # 0xE7 -> LATIN CAPITAL LETTER A WITH ACUTE + '\u0164' # 0xE8 -> LATIN CAPITAL LETTER T WITH CARON + '\u0165' # 0xE9 -> LATIN SMALL LETTER T WITH CARON + '\xcd' # 0xEA -> LATIN CAPITAL LETTER I WITH ACUTE + '\u017d' # 0xEB -> LATIN CAPITAL LETTER Z WITH CARON + '\u017e' # 0xEC -> LATIN SMALL LETTER Z WITH CARON + '\u016a' # 0xED -> LATIN CAPITAL LETTER U WITH MACRON + '\xd3' # 0xEE -> LATIN CAPITAL LETTER O WITH ACUTE + '\xd4' # 0xEF -> LATIN CAPITAL LETTER O WITH CIRCUMFLEX + '\u016b' # 0xF0 -> LATIN SMALL LETTER U WITH MACRON + '\u016e' # 0xF1 -> LATIN CAPITAL LETTER U WITH RING ABOVE + '\xda' # 0xF2 -> LATIN CAPITAL LETTER U WITH ACUTE + '\u016f' # 0xF3 -> LATIN SMALL LETTER U WITH RING ABOVE + '\u0170' # 0xF4 -> LATIN CAPITAL LETTER U WITH DOUBLE ACUTE + '\u0171' # 0xF5 -> LATIN SMALL LETTER U WITH DOUBLE ACUTE + '\u0172' # 0xF6 -> LATIN CAPITAL LETTER U WITH OGONEK + '\u0173' # 0xF7 -> LATIN SMALL LETTER U WITH OGONEK + '\xdd' # 0xF8 -> LATIN CAPITAL LETTER Y WITH ACUTE + '\xfd' # 0xF9 -> LATIN SMALL LETTER Y WITH ACUTE + '\u0137' # 0xFA -> LATIN SMALL LETTER K WITH CEDILLA + '\u017b' # 0xFB -> LATIN CAPITAL LETTER Z WITH DOT ABOVE + '\u0141' # 0xFC -> LATIN CAPITAL LETTER L WITH STROKE + '\u017c' # 0xFD -> LATIN SMALL LETTER Z WITH DOT ABOVE + '\u0122' # 0xFE -> LATIN CAPITAL LETTER G WITH CEDILLA + '\u02c7' # 0xFF -> CARON +) + +### Encoding table +encoding_table=codecs.charmap_build(decoding_table) diff --git a/shared/package-files/31/3167916b6a73650b7d91a7c918e4ced0fc1414558a4d7c18c3afcf6042255313/blob b/shared/package-files/31/3167916b6a73650b7d91a7c918e4ced0fc1414558a4d7c18c3afcf6042255313/blob new file mode 100644 index 0000000000000000000000000000000000000000..a212b93deb938d8e1df076c0c3c17fabb7b69913 --- /dev/null +++ b/shared/package-files/31/3167916b6a73650b7d91a7c918e4ced0fc1414558a4d7c18c3afcf6042255313/blob @@ -0,0 +1,136384 @@ +{ + "schema": "natural-disease-progression-report/v3", + "reward_metric": "panel_recall_at_5pct", + "panel": { + "panel_recall_at_5pct": 0.2797451402099912, + "panel_recall_at_1pct": 0.09023987928868529, + "panel_ppv_at_5pct": 0.09167378065115829, + "panel_auroc": 0.7921305530196128, + "panel_auprc": 0.10299745104743717, + "panel_calibration_slope_median": 0.719380616986771, + "panel_prediction_to_observed_median": 0.9433898300211392, + "panel_ece_decile": 0.0067960512947036755, + "endpoints_in_reward": [ + "I50", + "I48", + "I21", + "I26", + "I82", + "E11", + "N18", + "N17", + "A41", + "J18", + "J96", + "K72", + "J44", + "C78" + ], + "min_positives": 20, + "endpoints": { + "I50": { + "name": "heart failure", + "eligible": 2408, + "positives": 52, + "family_history_excluded": 7, + "in_reward": true, + "recall_at_5pct": 0.3076923076923077, + "ppv_at_5pct": 0.1322314049586777, + "recall_at_1pct": 0.11538461538461539, + "ppv_at_1pct": 0.24, + "auroc": 0.81392026903487, + "auprc": 0.11198299615613434, + "prevalence": 0.02159468438538206, + "calibration": { + "observed_rate": 0.02159468438538206, + "mean_prediction": 0.021794648412370433, + "prediction_to_observed": 1.0092598726343847, + "slope": 0.6807659803343914, + "ece_decile": 0.008195485173142709 + } + }, + "I48": { + "name": "atrial fibrillation/flutter", + "eligible": 2385, + "positives": 32, + "family_history_excluded": 0, + "in_reward": true, + "recall_at_5pct": 0.1875, + "ppv_at_5pct": 0.05, + "recall_at_1pct": 0.03125, + "ppv_at_1pct": 0.041666666666666664, + "auroc": 0.7460821291967701, + "auprc": 0.03366071498318168, + "prevalence": 0.013417190775681341, + "calibration": { + "observed_rate": 0.013417190775681341, + "mean_prediction": 0.013643976428206283, + "prediction_to_observed": 1.0169026181647496, + "slope": 0.6751542014299204, + "ece_decile": 0.007565328102330414 + } + }, + "I21": { + "name": "acute myocardial infarction", + "eligible": 2671, + "positives": 23, + "family_history_excluded": 0, + "in_reward": true, + "recall_at_5pct": 0.2608695652173913, + "ppv_at_5pct": 0.04477611940298507, + "recall_at_1pct": 0.043478260869565216, + "ppv_at_1pct": 0.037037037037037035, + "auroc": 0.8213746223564955, + "auprc": 0.03985769575234076, + "prevalence": 0.008611007113440658, + "calibration": { + "observed_rate": 0.008611007113440658, + "mean_prediction": 0.014428555449024001, + "prediction_to_observed": 1.6755944175801352, + "slope": 0.8249170814712041, + "ece_decile": 0.0075367727738414846 + } + }, + "I63": { + "name": "ischaemic stroke", + "eligible": 2662, + "positives": 14, + "family_history_excluded": 73, + "in_reward": false, + "recall_at_5pct": 0.07142857142857142, + "ppv_at_5pct": 0.007462686567164179, + "recall_at_1pct": 0.0, + "ppv_at_1pct": 0.0, + "auroc": 0.7183858437634872, + "auprc": 0.010841949391508737, + "prevalence": 0.005259203606311044, + "calibration": { + "observed_rate": 0.005259203606311044, + "mean_prediction": 0.005066297094594329, + "prediction_to_observed": 0.9633202047007217, + "slope": 0.4805660313427141, + "ece_decile": 0.0046925428872260444 + } + }, + "I61": { + "name": "intracerebral haemorrhage", + "eligible": 2802, + "positives": 9, + "family_history_excluded": 0, + "in_reward": false, + "recall_at_5pct": 0.0, + "ppv_at_5pct": 0.0, + "recall_at_1pct": 0.0, + "ppv_at_1pct": 0.0, + "auroc": 0.8328360583999681, + "auprc": 0.011615595373315732, + "prevalence": 0.0032119914346895075, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.0013513174892716368, + "prediction_to_observed": 0.4207101783265696, + "slope": 0.8405643229880396, + "ece_decile": 0.0023663043961755954 + } + }, + "I26": { + "name": "pulmonary embolism", + "eligible": 2760, + "positives": 20, + "family_history_excluded": 0, + "in_reward": true, + "recall_at_5pct": 0.3, + "ppv_at_5pct": 0.043478260869565216, + "recall_at_1pct": 0.15, + "ppv_at_1pct": 0.10714285714285714, + "auroc": 0.7397080291970802, + "auprc": 0.1273961377122822, + "prevalence": 0.007246376811594203, + "calibration": { + "observed_rate": 0.007246376811594203, + "mean_prediction": 0.006837631840323371, + "prediction_to_observed": 0.9435931939646252, + "slope": 0.9473023122091498, + "ece_decile": 0.0033272472646469556 + } + }, + "I82": { + "name": "venous thrombosis", + "eligible": 2739, + "positives": 35, + "family_history_excluded": 0, + "in_reward": true, + "recall_at_5pct": 0.2571428571428571, + "ppv_at_5pct": 0.06569343065693431, + "recall_at_1pct": 0.08571428571428572, + "ppv_at_1pct": 0.10714285714285714, + "auroc": 0.7461644125105664, + "auprc": 0.051564845826954, + "prevalence": 0.012778386272362175, + "calibration": { + "observed_rate": 0.012778386272362175, + "mean_prediction": 0.012205258748976835, + "prediction_to_observed": 0.955148677527073, + "slope": 0.6381401550393884, + "ece_decile": 0.005523924625105255 + } + }, + "I71": { + "name": "aortic aneurysm/dissection", + "eligible": 2769, + "positives": 5, + "family_history_excluded": 0, + "in_reward": false, + "recall_at_5pct": 0.0, + "ppv_at_5pct": 0.0, + "recall_at_1pct": 0.0, + "ppv_at_1pct": 0.0, + "auroc": 0.7470332850940666, + "auprc": 0.005420311783930537, + "prevalence": 0.0018057060310581437, + "calibration": { + "observed_rate": 0.0018057060310581437, + "mean_prediction": 0.003027730002209298, + "prediction_to_observed": 1.6767568752235094, + "slope": 0.5723189206806059, + "ece_decile": 0.0021265905056520613 + } + }, + "E11": { + "name": "type 2 diabetes", + "eligible": 2161, + "positives": 21, + "family_history_excluded": 33, + "in_reward": true, + "recall_at_5pct": 0.19047619047619047, + "ppv_at_5pct": 0.03669724770642202, + "recall_at_1pct": 0.047619047619047616, + "ppv_at_1pct": 0.045454545454545456, + "auroc": 0.7334223408989764, + "auprc": 0.07194402805270196, + "prevalence": 0.00971772327626099, + "calibration": { + "observed_rate": 0.00971772327626099, + "mean_prediction": 0.009165625075257157, + "prediction_to_observed": 0.9431864660776531, + "slope": 0.6894702609441605, + "ece_decile": 0.005108274601920077 + } + }, + "N18": { + "name": "chronic kidney disease", + "eligible": 2439, + "positives": 49, + "family_history_excluded": 1, + "in_reward": true, + "recall_at_5pct": 0.42857142857142855, + "ppv_at_5pct": 0.1721311475409836, + "recall_at_1pct": 0.12244897959183673, + "ppv_at_1pct": 0.24, + "auroc": 0.8550678848945436, + "auprc": 0.23194571384783647, + "prevalence": 0.02009020090200902, + "calibration": { + "observed_rate": 0.02009020090200902, + "mean_prediction": 0.013409920747664852, + "prediction_to_observed": 0.667485647011318, + "slope": 0.923002424740795, + "ece_decile": 0.007240690792309681 + } + }, + "N17": { + "name": "acute kidney injury", + "eligible": 2292, + "positives": 104, + "family_history_excluded": 0, + "in_reward": true, + "recall_at_5pct": 0.23076923076923078, + "ppv_at_5pct": 0.20869565217391303, + "recall_at_1pct": 0.0673076923076923, + "ppv_at_1pct": 0.30434782608695654, + "auroc": 0.7903731894248347, + "auprc": 0.1829244448334517, + "prevalence": 0.04537521815008726, + "calibration": { + "observed_rate": 0.04537521815008726, + "mean_prediction": 0.0474192372273453, + "prediction_to_observed": 1.045047035818033, + "slope": 0.7589178598047255, + "ece_decile": 0.009848617396736356 + } + }, + "A41": { + "name": "sepsis", + "eligible": 2661, + "positives": 76, + "family_history_excluded": 3, + "in_reward": true, + "recall_at_5pct": 0.14473684210526316, + "ppv_at_5pct": 0.08208955223880597, + "recall_at_1pct": 0.05263157894736842, + "ppv_at_1pct": 0.14814814814814814, + "auroc": 0.7435763005191897, + "auprc": 0.07658919802547483, + "prevalence": 0.028560691469372415, + "calibration": { + "observed_rate": 0.028560691469372415, + "mean_prediction": 0.030553923937099558, + "prediction_to_observed": 1.0697893631134463, + "slope": 0.6318139824530623, + "ece_decile": 0.010744991376085193 + } + }, + "J18": { + "name": "pneumonia", + "eligible": 2671, + "positives": 64, + "family_history_excluded": 0, + "in_reward": true, + "recall_at_5pct": 0.234375, + "ppv_at_5pct": 0.11194029850746269, + "recall_at_1pct": 0.03125, + "ppv_at_1pct": 0.07407407407407407, + "auroc": 0.7712229094744918, + "auprc": 0.07567395429830688, + "prevalence": 0.023961063272182705, + "calibration": { + "observed_rate": 0.023961063272182705, + "mean_prediction": 0.022199512766121067, + "prediction_to_observed": 0.9264827905985838, + "slope": 0.7130264487548983, + "ece_decile": 0.010257566372245654 + } + }, + "J96": { + "name": "respiratory failure", + "eligible": 2602, + "positives": 81, + "family_history_excluded": 3, + "in_reward": true, + "recall_at_5pct": 0.2345679012345679, + "ppv_at_5pct": 0.1450381679389313, + "recall_at_1pct": 0.024691358024691357, + "ppv_at_1pct": 0.07407407407407407, + "auroc": 0.8146385179308623, + "auprc": 0.11144713874369933, + "prevalence": 0.03112990007686395, + "calibration": { + "observed_rate": 0.03112990007686395, + "mean_prediction": 0.028801098108239907, + "prediction_to_observed": 0.9251908305881511, + "slope": 0.7692074263706802, + "ece_decile": 0.005308222357318096 + } + }, + "K74": { + "name": "hepatic fibrosis/cirrhosis", + "eligible": 2705, + "positives": 5, + "family_history_excluded": 58, + "in_reward": false, + "recall_at_5pct": 0.8, + "ppv_at_5pct": 0.029411764705882353, + "recall_at_1pct": 0.4, + "ppv_at_1pct": 0.07142857142857142, + "auroc": 0.9788148148148148, + "auprc": 0.2569194793301936, + "prevalence": 0.0018484288354898336, + "calibration": { + "observed_rate": 0.0018484288354898336, + "mean_prediction": 0.002376122802662241, + "prediction_to_observed": 1.2854824362402724, + "slope": 1.7656423428581627, + "ece_decile": 0.001293679362250044 + } + }, + "K72": { + "name": "hepatic failure", + "eligible": 2787, + "positives": 22, + "family_history_excluded": 0, + "in_reward": true, + "recall_at_5pct": 0.7272727272727273, + "ppv_at_5pct": 0.11428571428571428, + "recall_at_1pct": 0.4090909090909091, + "ppv_at_1pct": 0.32142857142857145, + "auroc": 0.8937530823606773, + "auprc": 0.25808964909894666, + "prevalence": 0.007893792608539648, + "calibration": { + "observed_rate": 0.007893792608539648, + "mean_prediction": 0.004409029721652773, + "prediction_to_observed": 0.5585439015566491, + "slope": 0.9016388793328649, + "ece_decile": 0.004771368817523767 + } + }, + "F03": { + "name": "dementia", + "eligible": 2665, + "positives": 13, + "family_history_excluded": 74, + "in_reward": false, + "recall_at_5pct": 0.15384615384615385, + "ppv_at_5pct": 0.014925373134328358, + "recall_at_1pct": 0.15384615384615385, + "ppv_at_1pct": 0.07407407407407407, + "auroc": 0.8517229376957884, + "auprc": 0.030847716830212778, + "prevalence": 0.004878048780487805, + "calibration": { + "observed_rate": 0.004878048780487805, + "mean_prediction": 0.007911577064882342, + "prediction_to_observed": 1.6218732983008801, + "slope": 0.7598668309810654, + "ece_decile": 0.005115056782782064 + } + }, + "J44": { + "name": "COPD", + "eligible": 2543, + "positives": 27, + "family_history_excluded": 27, + "in_reward": true, + "recall_at_5pct": 0.18518518518518517, + "ppv_at_5pct": 0.0390625, + "recall_at_1pct": 0.037037037037037035, + "ppv_at_1pct": 0.038461538461538464, + "auroc": 0.800918565624448, + "auprc": 0.03511607401145733, + "prevalence": 0.01061738104600865, + "calibration": { + "observed_rate": 0.01061738104600865, + "mean_prediction": 0.009233601179892097, + "prediction_to_observed": 0.8696684370542817, + "slope": 0.7257347852186438, + "ece_decile": 0.00610096816979302 + } + }, + "J84": { + "name": "interstitial lung disease", + "eligible": 2817, + "positives": 7, + "family_history_excluded": 0, + "in_reward": false, + "recall_at_5pct": 0.42857142857142855, + "ppv_at_5pct": 0.02127659574468085, + "recall_at_1pct": 0.14285714285714285, + "ppv_at_1pct": 0.034482758620689655, + "auroc": 0.9143365531265888, + "auprc": 0.03260577754033331, + "prevalence": 0.0024849130280440185, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.001935254032819637, + "prediction_to_observed": 0.7788015157789882, + "slope": 1.489143863041831, + "ece_decile": 0.0013722730321476624 + } + }, + "C18": { + "name": "colon cancer", + "eligible": 2824, + "positives": 2, + "family_history_excluded": 0, + "in_reward": false, + "recall_at_5pct": 1.0, + "ppv_at_5pct": 0.014084507042253521, + "recall_at_1pct": 0.5, + "ppv_at_1pct": 0.034482758620689655, + "auroc": 0.9764351523742028, + "auprc": 0.03250517598343685, + "prevalence": 0.000708215297450425, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0007881878527218284, + "prediction_to_observed": 1.1129212480432216, + "slope": 2.21972601207577, + "ece_decile": 0.0007072251360606774 + } + }, + "C22": { + "name": "liver cancer", + "eligible": 2812, + "positives": 7, + "family_history_excluded": 0, + "in_reward": false, + "recall_at_5pct": 0.42857142857142855, + "ppv_at_5pct": 0.02127659574468085, + "recall_at_1pct": 0.2857142857142857, + "ppv_at_1pct": 0.06896551724137931, + "auroc": 0.891825821237586, + "auprc": 0.04575571821224431, + "prevalence": 0.0024893314366998577, + "calibration": { + "observed_rate": 0.0024893314366998577, + "mean_prediction": 0.0009145903809097075, + "prediction_to_observed": 0.36740402158829966, + "slope": 0.7056767110183148, + "ece_decile": 0.0016622663783096119 + } + }, + "C25": { + "name": "pancreatic cancer", + "eligible": 2809, + "positives": 4, + "family_history_excluded": 0, + "in_reward": false, + "recall_at_5pct": 0.5, + "ppv_at_5pct": 0.014184397163120567, + "recall_at_1pct": 0.25, + "ppv_at_1pct": 0.034482758620689655, + "auroc": 0.9417112299465241, + "auprc": 0.09630737278237556, + "prevalence": 0.001423994304022784, + "calibration": { + "observed_rate": 0.001423994304022784, + "mean_prediction": 0.0006531163991040444, + "prediction_to_observed": 0.45865099127081516, + "slope": 0.8580011110223568, + "ece_decile": 0.0009967009473425712 + } + }, + "C61": { + "name": "prostate cancer", + "eligible": 2805, + "positives": 2, + "family_history_excluded": 0, + "in_reward": false, + "recall_at_5pct": 1.0, + "ppv_at_5pct": 0.014184397163120567, + "recall_at_1pct": 0.0, + "ppv_at_1pct": 0.0, + "auroc": 0.9703888690688548, + "auprc": 0.019363636363636364, + "prevalence": 0.00071301247771836, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.001323420144907688, + "prediction_to_observed": 1.8560967532330324, + "slope": 1.107947261820282, + "ece_decile": 0.0006104076671893278 + } + }, + "C67": { + "name": "bladder cancer", + "eligible": 2829, + "positives": 2, + "family_history_excluded": 0, + "in_reward": false, + "recall_at_5pct": 0.5, + "ppv_at_5pct": 0.007042253521126761, + "recall_at_1pct": 0.5, + "ppv_at_1pct": 0.034482758620689655, + "auroc": 0.9548991864166961, + "auprc": 0.026964560862865947, + "prevalence": 0.0007069635913750442, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0009803426773045236, + "prediction_to_observed": 1.3866947170472486, + "slope": 1.050110599208832, + "ece_decile": 0.0005451133127813658 + } + }, + "C78": { + "name": "metastasis, respiratory/digestive", + "eligible": 2672, + "positives": 22, + "family_history_excluded": 90, + "in_reward": true, + "recall_at_5pct": 0.22727272727272727, + "ppv_at_5pct": 0.03731343283582089, + "recall_at_1pct": 0.045454545454545456, + "ppv_at_1pct": 0.037037037037037035, + "auroc": 0.8196054888507719, + "auprc": 0.033771723321352407, + "prevalence": 0.008233532934131737, + "calibration": { + "observed_rate": 0.008233532934131737, + "mean_prediction": 0.004830569613037249, + "prediction_to_observed": 0.5866946366379786, + "slope": 0.6058296635910542, + "ece_decile": 0.003615260302852814 + } + }, + "C79": { + "name": "metastasis, other sites", + "eligible": 2672, + "positives": 19, + "family_history_excluded": 79, + "in_reward": false, + "recall_at_5pct": 0.42105263157894735, + "ppv_at_5pct": 0.05970149253731343, + "recall_at_1pct": 0.21052631578947367, + "ppv_at_1pct": 0.14814814814814814, + "auroc": 0.8629158648600393, + "auprc": 0.11369531530044238, + "prevalence": 0.007110778443113772, + "calibration": { + "observed_rate": 0.007110778443113772, + "mean_prediction": 0.00565119748551264, + "prediction_to_observed": 0.7947368253310407, + "slope": 0.8465131142322045, + "ece_decile": 0.0018755188549237538 + } + } + } + }, + "primary": { + "macro_time_averaged_auroc": 0.7922112518128868, + "macro_time_averaged_auprc": 0.047074062530318005, + "valid_diseases": 258, + "frozen_diseases": 262, + "valid_disease_time_cells": 3257, + "frozen_disease_time_cells": 3406, + "positive_support": 50984, + "negative_support": 8834988 + }, + "auxiliary": { + "raw_disease_time_brier_macro": 0.005597796883472468, + "age_sex_normalized_disease_time_brier": 1.5147825913718411 + }, + "normalization": { + "cells": 3406, + "floor_applied_cells": 1056, + "minimum_denominator": 0.001, + "maximum_weight": 1000.0, + "mean_train_reference_ratio": 0.8822734534079052 + }, + "mortality": { + "death_time_brier": 0.04694351908121337, + "by_time": { + "30": { + "valid": 2843, + "positives": 64, + "negatives": 2779, + "auroc": 0.9595965275278877, + "auprc": 0.4708247656564181, + "brier": 0.016072786876900967, + "calibration": { + "observed_rate": 0.022511431586352444, + "mean_prediction": 0.03002193933244034, + "calibration_in_the_large": 0.007510507746087896, + "expected_calibration_error_10bin": 0.009071136139276547, + "nonempty_bins": 8 + }, + "reason": null + }, + "60": { + "valid": 2843, + "positives": 107, + "negatives": 2736, + "auroc": 0.9421489861725966, + "auprc": 0.49893216091883635, + "brier": 0.025936122658472918, + "calibration": { + "observed_rate": 0.037636299683432996, + "mean_prediction": 0.04635802148221675, + "calibration_in_the_large": 0.008721721798783756, + "expected_calibration_error_10bin": 0.010625571473321247, + "nonempty_bins": 9 + }, + "reason": null + }, + "90": { + "valid": 2843, + "positives": 134, + "negatives": 2709, + "auroc": 0.9411800355916982, + "auprc": 0.5341862708009135, + "brier": 0.03125460045904289, + "calibration": { + "observed_rate": 0.04713330988392543, + "mean_prediction": 0.05898993808057277, + "calibration_in_the_large": 0.011856628196647338, + "expected_calibration_error_10bin": 0.013787148926560284, + "nonempty_bins": 9 + }, + "reason": null + }, + "120": { + "valid": 2843, + "positives": 161, + "negatives": 2682, + "auroc": 0.9373810218572401, + "auprc": 0.5565357426888627, + "brier": 0.03612032642520048, + "calibration": { + "observed_rate": 0.056630320084417866, + "mean_prediction": 0.06828734405390605, + "calibration_in_the_large": 0.01165702396948818, + "expected_calibration_error_10bin": 0.013691110400856622, + "nonempty_bins": 9 + }, + "reason": null + }, + "150": { + "valid": 2843, + "positives": 192, + "negatives": 2651, + "auroc": 0.9277788256004024, + "auprc": 0.5688657618288304, + "brier": 0.042395295921576925, + "calibration": { + "observed_rate": 0.06753429475905734, + "mean_prediction": 0.07819253005973041, + "calibration_in_the_large": 0.010658235300673072, + "expected_calibration_error_10bin": 0.011104492571569256, + "nonempty_bins": 9 + }, + "reason": null + }, + "180": { + "valid": 2843, + "positives": 221, + "negatives": 2622, + "auroc": 0.9230251509158496, + "auprc": 0.5860586447127465, + "brier": 0.04711201431118399, + "calibration": { + "observed_rate": 0.07773478719662329, + "mean_prediction": 0.08657483781451931, + "calibration_in_the_large": 0.008840050617896028, + "expected_calibration_error_10bin": 0.009935590572004702, + "nonempty_bins": 10 + }, + "reason": null + }, + "210": { + "valid": 2843, + "positives": 238, + "negatives": 2605, + "auroc": 0.9201954870239842, + "auprc": 0.5887811767886091, + "brier": 0.050365069026859714, + "calibration": { + "observed_rate": 0.08371438621174815, + "mean_prediction": 0.09159739877472721, + "calibration_in_the_large": 0.007883012562979061, + "expected_calibration_error_10bin": 0.008840556338287278, + "nonempty_bins": 10 + }, + "reason": null + }, + "240": { + "valid": 2843, + "positives": 255, + "negatives": 2588, + "auroc": 0.9158287117010637, + "auprc": 0.59574314202349, + "brier": 0.05342684581649499, + "calibration": { + "observed_rate": 0.08969398522687302, + "mean_prediction": 0.09702243650719626, + "calibration_in_the_large": 0.0073284512803232366, + "expected_calibration_error_10bin": 0.00947052153668291, + "nonempty_bins": 10 + }, + "reason": null + }, + "270": { + "valid": 2843, + "positives": 273, + "negatives": 2570, + "auroc": 0.910890665754479, + "auprc": 0.5957697937852973, + "brier": 0.05708771189414019, + "calibration": { + "observed_rate": 0.09602532536053465, + "mean_prediction": 0.10218160258434258, + "calibration_in_the_large": 0.006156277223807932, + "expected_calibration_error_10bin": 0.012072170909529865, + "nonempty_bins": 10 + }, + "reason": null + }, + "300": { + "valid": 2843, + "positives": 287, + "negatives": 2556, + "auroc": 0.9099461266242441, + "auprc": 0.6082454805321182, + "brier": 0.058973439939750315, + "calibration": { + "observed_rate": 0.10094970102004924, + "mean_prediction": 0.10718597860137037, + "calibration_in_the_large": 0.0062362775813211285, + "expected_calibration_error_10bin": 0.011401623644324057, + "nonempty_bins": 10 + }, + "reason": null + }, + "330": { + "valid": 2843, + "positives": 305, + "negatives": 2538, + "auroc": 0.9078479246599233, + "auprc": 0.6179717883522111, + "brier": 0.06149721789598214, + "calibration": { + "observed_rate": 0.10728104115371087, + "mean_prediction": 0.11125186028578452, + "calibration_in_the_large": 0.003970819132073644, + "expected_calibration_error_10bin": 0.011518100245714561, + "nonempty_bins": 10 + }, + "reason": null + }, + "360": { + "valid": 2843, + "positives": 319, + "negatives": 2524, + "auroc": 0.9053164852525474, + "auprc": 0.6167113081162152, + "brier": 0.06429607707740467, + "calibration": { + "observed_rate": 0.11220541681322546, + "mean_prediction": 0.11552687823490954, + "calibration_in_the_large": 0.0033214614216840743, + "expected_calibration_error_10bin": 0.012514168357711963, + "nonempty_bins": 10 + }, + "reason": null + }, + "365": { + "valid": 2843, + "positives": 325, + "negatives": 2518, + "auroc": 0.9038467648316735, + "auprc": 0.6142407038776933, + "brier": 0.0657282397527637, + "calibration": { + "observed_rate": 0.114315863524446, + "mean_prediction": 0.11622304442345853, + "calibration_in_the_large": 0.0019071808990125255, + "expected_calibration_error_10bin": 0.012508384377695296, + "nonempty_bins": 10 + }, + "reason": null + } + } + }, + "cohort": { + "all_samples": 3915, + "primary_complete_year": 2843, + "partial_observation_outside_primary": 1072 + }, + "horizons": { + "30": { + "macro_auroc": 0.7970935728690925, + "macro_auprc": 0.026902097285963694, + "macro_brier": 0.0016780778769214903, + "macro_normalized_brier": 0.9816516512588244, + "macro_expected_calibration_error_10bin": 0.0006941417457034879, + "valid_pairs": 715885, + "positive_pairs": 1140, + "valid_patients": 2843, + "scorable_auroc_diseases": 216, + "frozen_diseases": 262, + "disease_without_auc": { + "B00": "single_class", + "B02": "single_class", + "B20": "single_class", + "B34": "single_class", + "B35": "single_class", + "C25": "single_class", + "C83": "single_class", + "D59": "single_class", + "D73": "single_class", + "D75": "single_class", + "E27": "single_class", + "F02": "single_class", + "F20": "single_class", + "F22": "single_class", + "G31": "single_class", + "G51": "single_class", + "G90": "single_class", + "G99": "single_class", + "H10": "single_class", + "H26": "single_class", + "I07": "single_class", + "I46": "single_class", + "I65": "single_class", + "I96": "single_class", + "J02": "single_class", + "J12": "single_class", + "J30": "single_class", + "J47": "single_class", + "K04": "single_class", + "K26": "single_class", + "K29": "single_class", + "K30": "single_class", + "K40": "single_class", + "K70": "single_class", + "K81": "single_class", + "L53": "single_class", + "L98": "single_class", + "M46": "single_class", + "M51": "single_class", + "M62": "single_class", + "M84": "single_class", + "M96": "single_class", + "O69": "single_class", + "O99": "single_class", + "Q21": "single_class", + "U07": "single_class" + }, + "death": { + "valid": 2843, + "positives": 64, + "negatives": 2779, + "auroc": 0.9595965275278877, + "auprc": 0.4708247656564181, + "brier": 0.016072786876900967, + "calibration": { + "observed_rate": 0.022511431586352444, + "mean_prediction": 0.03002193933244034, + "calibration_in_the_large": 0.007510507746087896, + "expected_calibration_error_10bin": 0.009071136139276547, + "nonempty_bins": 8 + }, + "reason": null + } + }, + "60": { + "macro_auroc": 0.7985711066383105, + "macro_auprc": 0.036435759382095784, + "macro_brier": 0.0028046407900448734, + "macro_normalized_brier": 1.2351774475210262, + "macro_expected_calibration_error_10bin": 0.0009714680316886317, + "valid_pairs": 715885, + "positive_pairs": 1922, + "valid_patients": 2843, + "scorable_auroc_diseases": 241, + "frozen_diseases": 262, + "disease_without_auc": { + "B02": "single_class", + "B20": "single_class", + "B35": "single_class", + "C83": "single_class", + "D59": "single_class", + "D75": "single_class", + "E27": "single_class", + "F22": "single_class", + "G51": "single_class", + "G90": "single_class", + "G99": "single_class", + "H26": "single_class", + "I46": "single_class", + "J12": "single_class", + "K04": "single_class", + "K30": "single_class", + "K40": "single_class", + "L53": "single_class", + "M51": "single_class", + "O99": "single_class", + "U07": "single_class" + }, + "death": { + "valid": 2843, + "positives": 107, + "negatives": 2736, + "auroc": 0.9421489861725966, + "auprc": 0.49893216091883635, + "brier": 0.025936122658472918, + "calibration": { + "observed_rate": 0.037636299683432996, + "mean_prediction": 0.04635802148221675, + "calibration_in_the_large": 0.008721721798783756, + "expected_calibration_error_10bin": 0.010625571473321247, + "nonempty_bins": 9 + }, + "reason": null + } + }, + "90": { + "macro_auroc": 0.7937517822254155, + "macro_auprc": 0.041233582855930255, + "macro_brier": 0.00378531947028451, + "macro_normalized_brier": 1.429658541619893, + "macro_expected_calibration_error_10bin": 0.0012017360218193923, + "valid_pairs": 715885, + "positive_pairs": 2618, + "valid_patients": 2843, + "scorable_auroc_diseases": 248, + "frozen_diseases": 262, + "disease_without_auc": { + "B35": "single_class", + "C83": "single_class", + "D59": "single_class", + "E27": "single_class", + "F22": "single_class", + "G51": "single_class", + "G90": "single_class", + "G99": "single_class", + "H26": "single_class", + "J12": "single_class", + "K04": "single_class", + "K40": "single_class", + "L53": "single_class", + "U07": "single_class" + }, + "death": { + "valid": 2843, + "positives": 134, + "negatives": 2709, + "auroc": 0.9411800355916982, + "auprc": 0.5341862708009135, + "brier": 0.03125460045904289, + "calibration": { + "observed_rate": 0.04713330988392543, + "mean_prediction": 0.05898993808057277, + "calibration_in_the_large": 0.011856628196647338, + "expected_calibration_error_10bin": 0.013787148926560284, + "nonempty_bins": 9 + }, + "reason": null + } + }, + "120": { + "macro_auroc": 0.7896390663830978, + "macro_auprc": 0.04495617337694016, + "macro_brier": 0.004525509552847342, + "macro_normalized_brier": 1.5171457120986958, + "macro_expected_calibration_error_10bin": 0.0014653711385568802, + "valid_pairs": 715885, + "positive_pairs": 3140, + "valid_patients": 2843, + "scorable_auroc_diseases": 252, + "frozen_diseases": 262, + "disease_without_auc": { + "B35": "single_class", + "C83": "single_class", + "D59": "single_class", + "G51": "single_class", + "G90": "single_class", + "G99": "single_class", + "H26": "single_class", + "J12": "single_class", + "L53": "single_class", + "U07": "single_class" + }, + "death": { + "valid": 2843, + "positives": 161, + "negatives": 2682, + "auroc": 0.9373810218572401, + "auprc": 0.5565357426888627, + "brier": 0.03612032642520048, + "calibration": { + "observed_rate": 0.056630320084417866, + "mean_prediction": 0.06828734405390605, + "calibration_in_the_large": 0.01165702396948818, + "expected_calibration_error_10bin": 0.013691110400856622, + "nonempty_bins": 9 + }, + "reason": null + } + }, + "150": { + "macro_auroc": 0.78951465015514, + "macro_auprc": 0.045584722403622525, + "macro_brier": 0.004996496597276671, + "macro_normalized_brier": 1.5337997115861777, + "macro_expected_calibration_error_10bin": 0.0015539950509856591, + "valid_pairs": 715885, + "positive_pairs": 3476, + "valid_patients": 2843, + "scorable_auroc_diseases": 252, + "frozen_diseases": 262, + "disease_without_auc": { + "B35": "single_class", + "C83": "single_class", + "D59": "single_class", + "G51": "single_class", + "G90": "single_class", + "G99": "single_class", + "H26": "single_class", + "J12": "single_class", + "L53": "single_class", + "U07": "single_class" + }, + "death": { + "valid": 2843, + "positives": 192, + "negatives": 2651, + "auroc": 0.9277788256004024, + "auprc": 0.5688657618288304, + "brier": 0.042395295921576925, + "calibration": { + "observed_rate": 0.06753429475905734, + "mean_prediction": 0.07819253005973041, + "calibration_in_the_large": 0.010658235300673072, + "expected_calibration_error_10bin": 0.011104492571569256, + "nonempty_bins": 9 + }, + "reason": null + } + }, + "180": { + "macro_auroc": 0.7915507668094741, + "macro_auprc": 0.04643259992414633, + "macro_brier": 0.005427656781992186, + "macro_normalized_brier": 1.543410123328058, + "macro_expected_calibration_error_10bin": 0.001656745861483857, + "valid_pairs": 715885, + "positive_pairs": 3784, + "valid_patients": 2843, + "scorable_auroc_diseases": 253, + "frozen_diseases": 262, + "disease_without_auc": { + "B35": "single_class", + "C83": "single_class", + "G51": "single_class", + "G90": "single_class", + "G99": "single_class", + "H26": "single_class", + "J12": "single_class", + "L53": "single_class", + "U07": "single_class" + }, + "death": { + "valid": 2843, + "positives": 221, + "negatives": 2622, + "auroc": 0.9230251509158496, + "auprc": 0.5860586447127465, + "brier": 0.04711201431118399, + "calibration": { + "observed_rate": 0.07773478719662329, + "mean_prediction": 0.08657483781451931, + "calibration_in_the_large": 0.008840050617896028, + "expected_calibration_error_10bin": 0.009935590572004702, + "nonempty_bins": 10 + }, + "reason": null + } + }, + "210": { + "macro_auroc": 0.7917393648072861, + "macro_auprc": 0.048994289744177764, + "macro_brier": 0.006010318351315692, + "macro_normalized_brier": 1.597616731521943, + "macro_expected_calibration_error_10bin": 0.0017818509585388806, + "valid_pairs": 715885, + "positive_pairs": 4211, + "valid_patients": 2843, + "scorable_auroc_diseases": 253, + "frozen_diseases": 262, + "disease_without_auc": { + "B35": "single_class", + "C83": "single_class", + "G51": "single_class", + "G90": "single_class", + "G99": "single_class", + "H26": "single_class", + "J12": "single_class", + "L53": "single_class", + "U07": "single_class" + }, + "death": { + "valid": 2843, + "positives": 238, + "negatives": 2605, + "auroc": 0.9201954870239842, + "auprc": 0.5887811767886091, + "brier": 0.050365069026859714, + "calibration": { + "observed_rate": 0.08371438621174815, + "mean_prediction": 0.09159739877472721, + "calibration_in_the_large": 0.007883012562979061, + "expected_calibration_error_10bin": 0.008840556338287278, + "nonempty_bins": 10 + }, + "reason": null + } + }, + "240": { + "macro_auroc": 0.7925502867186948, + "macro_auprc": 0.05234657656056576, + "macro_brier": 0.006391982819226292, + "macro_normalized_brier": 1.6096961820599223, + "macro_expected_calibration_error_10bin": 0.0019158315882121437, + "valid_pairs": 715885, + "positive_pairs": 4489, + "valid_patients": 2843, + "scorable_auroc_diseases": 254, + "frozen_diseases": 262, + "disease_without_auc": { + "C83": "single_class", + "G51": "single_class", + "G90": "single_class", + "G99": "single_class", + "H26": "single_class", + "J12": "single_class", + "L53": "single_class", + "U07": "single_class" + }, + "death": { + "valid": 2843, + "positives": 255, + "negatives": 2588, + "auroc": 0.9158287117010637, + "auprc": 0.59574314202349, + "brier": 0.05342684581649499, + "calibration": { + "observed_rate": 0.08969398522687302, + "mean_prediction": 0.09702243650719626, + "calibration_in_the_large": 0.0073284512803232366, + "expected_calibration_error_10bin": 0.00947052153668291, + "nonempty_bins": 10 + }, + "reason": null + } + }, + "270": { + "macro_auroc": 0.7878225971671111, + "macro_auprc": 0.052170056040663715, + "macro_brier": 0.006771460290888535, + "macro_normalized_brier": 1.6327650399623075, + "macro_expected_calibration_error_10bin": 0.0020307721582929223, + "valid_pairs": 715885, + "positive_pairs": 4765, + "valid_patients": 2843, + "scorable_auroc_diseases": 256, + "frozen_diseases": 262, + "disease_without_auc": { + "G51": "single_class", + "G90": "single_class", + "H26": "single_class", + "J12": "single_class", + "L53": "single_class", + "U07": "single_class" + }, + "death": { + "valid": 2843, + "positives": 273, + "negatives": 2570, + "auroc": 0.910890665754479, + "auprc": 0.5957697937852973, + "brier": 0.05708771189414019, + "calibration": { + "observed_rate": 0.09602532536053465, + "mean_prediction": 0.10218160258434258, + "calibration_in_the_large": 0.006156277223807932, + "expected_calibration_error_10bin": 0.012072170909529865, + "nonempty_bins": 10 + }, + "reason": null + } + }, + "300": { + "macro_auroc": 0.7912213800873222, + "macro_auprc": 0.053069057562848555, + "macro_brier": 0.00714970379209874, + "macro_normalized_brier": 1.6451365073603945, + "macro_expected_calibration_error_10bin": 0.0021411400629328197, + "valid_pairs": 715885, + "positive_pairs": 5033, + "valid_patients": 2843, + "scorable_auroc_diseases": 258, + "frozen_diseases": 262, + "disease_without_auc": { + "G51": "single_class", + "G90": "single_class", + "H26": "single_class", + "L53": "single_class" + }, + "death": { + "valid": 2843, + "positives": 287, + "negatives": 2556, + "auroc": 0.9099461266242441, + "auprc": 0.6082454805321182, + "brier": 0.058973439939750315, + "calibration": { + "observed_rate": 0.10094970102004924, + "mean_prediction": 0.10718597860137037, + "calibration_in_the_large": 0.0062362775813211285, + "expected_calibration_error_10bin": 0.011401623644324057, + "nonempty_bins": 10 + }, + "reason": null + } + }, + "330": { + "macro_auroc": 0.7901638233910793, + "macro_auprc": 0.05438781458815862, + "macro_brier": 0.0075142695726335305, + "macro_normalized_brier": 1.653231602620288, + "macro_expected_calibration_error_10bin": 0.0022693476610364848, + "valid_pairs": 715885, + "positive_pairs": 5304, + "valid_patients": 2843, + "scorable_auroc_diseases": 258, + "frozen_diseases": 262, + "disease_without_auc": { + "G51": "single_class", + "G90": "single_class", + "H26": "single_class", + "L53": "single_class" + }, + "death": { + "valid": 2843, + "positives": 305, + "negatives": 2538, + "auroc": 0.9078479246599233, + "auprc": 0.6179717883522111, + "brier": 0.06149721789598214, + "calibration": { + "observed_rate": 0.10728104115371087, + "mean_prediction": 0.11125186028578452, + "calibration_in_the_large": 0.003970819132073644, + "expected_calibration_error_10bin": 0.011518100245714561, + "nonempty_bins": 10 + }, + "reason": null + } + }, + "360": { + "macro_auroc": 0.7882274865944398, + "macro_auprc": 0.055868264533307135, + "macro_brier": 0.007837125936796408, + "macro_normalized_brier": 1.6572085783046864, + "macro_expected_calibration_error_10bin": 0.002368419413040252, + "valid_pairs": 715885, + "positive_pairs": 5535, + "valid_patients": 2843, + "scorable_auroc_diseases": 258, + "frozen_diseases": 262, + "disease_without_auc": { + "G51": "single_class", + "G90": "single_class", + "H26": "single_class", + "L53": "single_class" + }, + "death": { + "valid": 2843, + "positives": 319, + "negatives": 2524, + "auroc": 0.9053164852525474, + "auprc": 0.6167113081162152, + "brier": 0.06429607707740467, + "calibration": { + "observed_rate": 0.11220541681322546, + "mean_prediction": 0.11552687823490954, + "calibration_in_the_large": 0.0033214614216840743, + "expected_calibration_error_10bin": 0.012514168357711963, + "nonempty_bins": 10 + }, + "reason": null + } + }, + "365": { + "macro_auroc": 0.7886151791433809, + "macro_auprc": 0.05639199990963603, + "macro_brier": 0.00787879783928891, + "macro_normalized_brier": 1.6556759766912044, + "macro_expected_calibration_error_10bin": 0.0023697320728796986, + "valid_pairs": 715885, + "positive_pairs": 5567, + "valid_patients": 2843, + "scorable_auroc_diseases": 258, + "frozen_diseases": 262, + "disease_without_auc": { + "G51": "single_class", + "G90": "single_class", + "H26": "single_class", + "L53": "single_class" + }, + "death": { + "valid": 2843, + "positives": 325, + "negatives": 2518, + "auroc": 0.9038467648316735, + "auprc": 0.6142407038776933, + "brier": 0.0657282397527637, + "calibration": { + "observed_rate": 0.114315863524446, + "mean_prediction": 0.11622304442345853, + "calibration_in_the_large": 0.0019071808990125255, + "expected_calibration_error_10bin": 0.012508384377695296, + "nonempty_bins": 10 + }, + "reason": null + } + } + }, + "per_disease": { + "time_brier": { + "A04": { + "normalized_time_brier": 2.154959171374933, + "normalized_timepoint_brier": [ + 1.079364912584424, + 1.6078283091606527, + 2.208064396549329, + 2.417303965328234, + 2.5043475687043535, + 2.4030097957559624, + 2.2871831908213234, + 2.211309085828993, + 2.290239136002412, + 2.235696980210537, + 2.226724599293416, + 2.271659574458964, + 2.27173771317553 + ], + "raw_time_brier": 0.007163394152974853, + "raw_timepoint_brier": [ + 0.001079364912584424, + 0.0024913535453379154, + 0.004978782497346401, + 0.006382584106177092, + 0.007073995657265186, + 0.007431035861372948, + 0.007762775290757418, + 0.008098205551505089, + 0.008808988146483898, + 0.009159967303276062, + 0.009495915845036507, + 0.010180402547121048, + 0.010180752724409103 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0015495146659275432, + 0.0022548176154314316, + 0.002640372993104502, + 0.002824686056227004, + 0.003092386836914753, + 0.00339403302801024, + 0.0036621771254872625, + 0.003846318058235566, + 0.004097141689753261, + 0.004264521911712723, + 0.00448148246400242, + 0.004481482464002423 + ] + }, + "A08": { + "normalized_time_brier": 2.3050251898552974, + "normalized_timepoint_brier": [ + 1.76801101770252, + 2.4650769773870707, + 2.461759839206934, + 2.334070297648733, + 2.939204330034512, + 2.768052274855757, + 2.58207610446137, + 2.446553645793724, + 2.3013490121212743, + 2.152283332746146, + 2.005302214411651, + 1.8781349076187044, + 1.86345351413047 + ], + "raw_time_brier": 0.003346276550123898, + "raw_timepoint_brier": [ + 0.00176801101770252, + 0.0024650769773870707, + 0.002461759839206934, + 0.00246358010917902, + 0.0034956929739564657, + 0.0038476302288472652, + 0.003848171327263117, + 0.003850775770843029, + 0.003852952504530549, + 0.0038551015313714743, + 0.0038596864324063063, + 0.0038660981226712465, + 0.003867058316245675 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.0010554866799259435, + 0.0011893330920329107, + 0.0013900135715636964, + 0.0014903400099687838, + 0.0015739592620270296, + 0.001674214768918983, + 0.0017911682317646649, + 0.0019247405227339886, + 0.0020584773260900035, + 0.0020752105093698207 + ] + }, + "A41": { + "normalized_time_brier": 2.1712011552946406, + "normalized_timepoint_brier": [ + 1.0430827158607627, + 1.8833452873906276, + 1.9714919432468283, + 1.9729596568578336, + 2.1669920423606577, + 2.374562141808182, + 2.3790698200353053, + 2.3352244996449922, + 2.4050705685492724, + 2.3805597713777216, + 2.3929279912835852, + 2.466944551239044, + 2.4533840291755133 + ], + "raw_time_brier": 0.01787589014901851, + "raw_timepoint_brier": [ + 0.001917145331390202, + 0.007068480830639601, + 0.010072639212012291, + 0.012176825664937496, + 0.014745589345693588, + 0.01794024556875229, + 0.019757239148020744, + 0.02090204507112503, + 0.022875435650348663, + 0.024093089625239372, + 0.025470653548836708, + 0.02767675742506981, + 0.027690425515174866 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0018379609806957195, + 0.00375315183995441, + 0.0051091455111014926, + 0.006171857403476004, + 0.006804634745972659, + 0.007555180491124627, + 0.008304606691924472, + 0.008950764722750477, + 0.00951133656928288, + 0.010120766516732228, + 0.010644137074586207, + 0.01121904317272511, + 0.011286624998729016 + ] + }, + "B00": { + "normalized_time_brier": 1.005414660348178, + "normalized_timepoint_brier": [ + 0.0008428953037764586, + 0.3499302256386727, + 0.357060314854607, + 0.36222831113263965, + 1.0817130096256733, + 1.0878186440095305, + 1.449646195396781, + 1.4510274631902575, + 1.4569720951840281, + 1.461672829464078, + 1.3733750575099777, + 1.3188991788303202, + 1.3192043643859708 + ], + "raw_time_brier": 0.001036795630043868, + "raw_timepoint_brier": [ + 8.428953037764586e-07, + 0.0003499302256386727, + 0.000357060314854607, + 0.00036222831113263965, + 0.0010817130096256733, + 0.0010878186440095305, + 0.001449646195396781, + 0.0014510274631902575, + 0.0014569720951840281, + 0.001461672829464078, + 0.0014678817242383957, + 0.0014756040181964636, + 0.001475945464335382 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001068813443357392, + 0.0011188148737078742, + 0.001118814873707886 + ] + }, + "B02": { + "normalized_time_brier": 0.2402904457243674, + "normalized_timepoint_brier": [ + 0.00018999215001258563, + 0.0005244220915301412, + 0.354104588041082, + 0.3543233615346253, + 0.35459824721328914, + 0.35499632940627635, + 0.31883341300929724, + 0.2745768853479586, + 0.2464978561848617, + 0.2358022810943633, + 0.21505016838902843, + 0.2071339386189053, + 0.2071443113355457 + ], + "raw_time_brier": 0.00030160812196829037, + "raw_timepoint_brier": [ + 1.8999215001258563e-07, + 5.244220915301412e-07, + 0.000354104588041082, + 0.0003543233615346253, + 0.00035459824721328914, + 0.00035499632940627635, + 0.0003558502357918769, + 0.0003567043459042907, + 0.000357113458449021, + 0.0003572979767341167, + 0.0003580114571377635, + 0.00035858660703524947, + 0.0003586045640986413 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0011161008265513886, + 0.0012991055144800545, + 0.0014487487395476691, + 0.001515243936894458, + 0.0016647811058213928, + 0.0017311822940565711, + 0.0017311822940565842 + ] + }, + "B18": { + "normalized_time_brier": 1.488889287441873, + "normalized_timepoint_brier": [ + 0.3561595513019711, + 1.057905494235456, + 1.0551157174631953, + 1.048991922289133, + 1.3901629718020558, + 1.7282598460425354, + 1.6695865978854103, + 1.5644800028346846, + 2.0475356770854227, + 1.883978331341699, + 1.7437593025828158, + 1.9048767769264943, + 1.9047485449534802 + ], + "raw_time_brier": 0.0017628327410560674, + "raw_timepoint_brier": [ + 0.0003561595513019711, + 0.001057905494235456, + 0.0010551157174631953, + 0.001048991922289133, + 0.0013901629718020558, + 0.001735154539346695, + 0.0017328673275187612, + 0.0017300553154200315, + 0.0024379633832722902, + 0.0024349677842110395, + 0.0024314443580806255, + 0.0027531113009899855, + 0.002752925967797637 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010039893846518204, + 0.0010379020349788972, + 0.0011058340869076887, + 0.0011906817598131547, + 0.0012924606104556132, + 0.0013943692541047532, + 0.0014452962702564476, + 0.0014452962702564353 + ] + }, + "B19": { + "normalized_time_brier": 1.3019678973729536, + "normalized_timepoint_brier": [ + 1.8803609676933655, + 1.781158508899319, + 1.3738545640556876, + 1.4071791861473355, + 1.3741809488045118, + 1.2631333731133187, + 1.2280301015311552, + 1.24579170712915, + 1.1755825774867217, + 1.1057387279185227, + 1.0535709242482565, + 1.019927068463971, + 1.017074010357081 + ], + "raw_time_brier": 0.005259948048310785, + "raw_timepoint_brier": [ + 0.0025299449916929007, + 0.0042997729033231735, + 0.004292326979339123, + 0.004966661334037781, + 0.00531351612880826, + 0.005308785941451788, + 0.005656520836055279, + 0.006010204553604126, + 0.00600550277158618, + 0.006001623347401619, + 0.006000712979584932, + 0.00599683728069067, + 0.005996914580464363 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001345457087846478, + 0.002414031587778368, + 0.0031242950248445206, + 0.0035295159159053663, + 0.0038666786447817, + 0.004202870460438325, + 0.004606174416248031, + 0.004824405652413814, + 0.0051085333234738356, + 0.005427704751464447, + 0.005695594706988103, + 0.005879672641419369, + 0.005896242082086954 + ] + }, + "B20": { + "normalized_time_brier": 1.0046743614055589, + "normalized_timepoint_brier": [ + 0.0005234366540207702, + 0.000908245567643462, + 0.3543564525898546, + 1.0534864850342274, + 1.0530536528676748, + 1.0526403784751892, + 1.2983917227030006, + 1.5320518784606556, + 1.4659076583018806, + 1.3519350696809387, + 1.3327171720171123, + 1.282433782650465, + 1.2823607632696004 + ], + "raw_time_brier": 0.0011775789836729717, + "raw_timepoint_brier": [ + 5.234366540207702e-07, + 9.08245567643462e-07, + 0.0003543564525898546, + 0.0010534864850342274, + 0.0010530536528676748, + 0.0010526403784751892, + 0.0013866013614460826, + 0.0017379563068971038, + 0.0017363294027745724, + 0.0017358351033180952, + 0.001733393408358097, + 0.0017317705787718296, + 0.0017316719749942422 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010679376163608364, + 0.0011343978172875795, + 0.0011844739284505481, + 0.0012839633664712598, + 0.0013006461121338655, + 0.001350378165485238, + 0.0013503781654852299 + ] + }, + "B34": { + "normalized_time_brier": 1.377218532659605, + "normalized_timepoint_brier": [ + 0.00022374881325504248, + 0.7023831713013351, + 1.0518052149564028, + 1.4021373353898525, + 1.4022322138771415, + 1.401442219503224, + 1.716863363981247, + 1.714357640594244, + 1.706387149170041, + 1.7034757183864713, + 1.7008702270686626, + 1.7008408904075623, + 1.7008220311254263 + ], + "raw_time_brier": 0.001377218532659605, + "raw_timepoint_brier": [ + 2.2374881325504248e-07, + 0.0007023831713013351, + 0.0010518052149564028, + 0.0014021373353898525, + 0.0014022322138771415, + 0.001401442219503224, + 0.001716863363981247, + 0.001714357640594244, + 0.001706387149170041, + 0.0017034757183864713, + 0.0017008702270686626, + 0.0017008408904075623, + 0.0017008220311254263 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "B35": { + "normalized_time_brier": 0.1490387012983131, + "normalized_timepoint_brier": [ + 0.000292739031237943, + 0.0017958841453946661, + 0.00446865215053549, + 0.005229125683765797, + 0.005846980045134354, + 0.00665147913719359, + 0.007893268231761109, + 0.22793889156901562, + 0.2077220199671278, + 0.3876172369302289, + 0.37774593723537736, + 0.35353197348602733, + 0.35076892926527 + ], + "raw_time_brier": 0.00027978436768176626, + "raw_timepoint_brier": [ + 2.92739031237943e-07, + 1.7958841453946661e-06, + 4.46865215053549e-06, + 6.008408490743022e-06, + 7.009879027464194e-06, + 8.52716311783297e-06, + 1.156229518528562e-05, + 0.00036417823866941035, + 0.00036635695141740143, + 0.0007157371728681028, + 0.0007163420668803155, + 0.0007173536578193307, + 0.0007175636710599065 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.0011490273621451797, + 0.0011988888235213943, + 0.001281995018243532, + 0.0014648298836166494, + 0.0015977011915895188, + 0.0017636885654942975, + 0.0018465050175179268, + 0.0018963594211576006, + 0.00202910546037976, + 0.002045687662709849 + ] + }, + "B37": { + "normalized_time_brier": 1.6752502424295366, + "normalized_timepoint_brier": [ + 2.0157602052047903, + 1.8191860638837465, + 1.6339364212478074, + 1.6272574390115238, + 1.498020961125211, + 1.5336256688887029, + 1.6706092355102748, + 1.6495932244960576, + 1.6906471191314933, + 1.6695698512507666, + 1.635211705320687, + 1.6708226277021436, + 1.6640126288107708 + ], + "raw_time_brier": 0.009701374685391784, + "raw_timepoint_brier": [ + 0.002872308949008584, + 0.005360638257116079, + 0.0064407167956233025, + 0.007865086197853088, + 0.008246813900768757, + 0.009318449534475803, + 0.010710337199270725, + 0.011017784476280212, + 0.012083799578249454, + 0.012463618069887161, + 0.01278043631464243, + 0.01347846258431673, + 0.01347941905260086 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0014249259121160065, + 0.002946723462509246, + 0.003941840521985944, + 0.004833338603528357, + 0.005505139190158136, + 0.006076091267583012, + 0.006411036747321306, + 0.006679091737689508, + 0.007147440433611631, + 0.007465167186955358, + 0.00781576860846652, + 0.008066961962834709, + 0.008100550932858167 + ] + }, + "B95": { + "normalized_time_brier": 1.4834117473312363, + "normalized_timepoint_brier": [ + 1.7445579331620453, + 1.6307171201066921, + 1.5750979065115087, + 1.5263987455235468, + 1.4587396359992448, + 1.333820773356138, + 1.4883116997777206, + 1.4631457189732286, + 1.4405963928598615, + 1.4740686160315748, + 1.4106414886755536, + 1.3717263809818074, + 1.3665303033471465 + ], + "raw_time_brier": 0.017081408976362303, + "raw_timepoint_brier": [ + 0.005568539723753929, + 0.00994949135929346, + 0.012568407692015171, + 0.014486323110759258, + 0.015589823015034199, + 0.015641620382666588, + 0.018793266266584396, + 0.019868342205882072, + 0.020613519474864006, + 0.022015009075403214, + 0.02204410918056965, + 0.02245650626718998, + 0.022463358938694 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0031919488701993644, + 0.006101298156876222, + 0.007979445366574956, + 0.009490523464620986, + 0.010687186822311222, + 0.011726928156403952, + 0.012627238144664972, + 0.013579195802742602, + 0.014309017832497967, + 0.014934860450845966, + 0.015627010376156443, + 0.01637098081551572, + 0.016438244277256632 + ] + }, + "B96": { + "normalized_time_brier": 1.3760056728197312, + "normalized_timepoint_brier": [ + 1.1283975358976286, + 1.2563323310102792, + 1.4463272008912573, + 1.451696723276633, + 1.4193270713212378, + 1.3818188341582953, + 1.4659528696440893, + 1.4126808825240404, + 1.3773521133695081, + 1.3650485526576388, + 1.3923802164562868, + 1.3895122417740287, + 1.4012471736755823 + ], + "raw_time_brier": 0.02248157335158724, + "raw_timepoint_brier": [ + 0.005658063571900129, + 0.01105338055640459, + 0.01603912189602852, + 0.018857112154364586, + 0.020708909258246422, + 0.02211030200123787, + 0.025241581723093987, + 0.02594502456486225, + 0.026735151186585426, + 0.027757063508033752, + 0.029669014737010002, + 0.031065240502357483, + 0.03142048791050911 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.005014246656785898, + 0.00879813428626486, + 0.01108955282466158, + 0.01298970497901386, + 0.014590653329093976, + 0.016000868894442213, + 0.01721854927656866, + 0.018365807087660314, + 0.019410542102543008, + 0.020334121781963727, + 0.021308127181324, + 0.02235693905272517, + 0.022423230177221826 + ] + }, + "B97": { + "normalized_time_brier": 0.5475325899449393, + "normalized_timepoint_brier": [ + 0.3536997828632593, + 0.3553440619725734, + 0.35860008210875094, + 0.3597088507376611, + 0.3607148246373981, + 0.3628513659350574, + 0.7035245653241873, + 0.7047997787594795, + 0.7066709222272038, + 0.7104967953637242, + 0.7132996688596904, + 0.7140483940020204, + 0.7141645764932036 + ], + "raw_time_brier": 0.0005475325899449392, + "raw_timepoint_brier": [ + 0.0003536997828632593, + 0.0003553440619725734, + 0.00035860008210875094, + 0.0003597088507376611, + 0.0003607148246373981, + 0.0003628513659350574, + 0.0007035245653241873, + 0.0007047997787594795, + 0.0007066709222272038, + 0.0007104967953637242, + 0.0007132996688596904, + 0.0007140483940020204, + 0.0007141645764932036 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "C18": { + "normalized_time_brier": 0.6490272510116204, + "normalized_timepoint_brier": [ + 0.35288388608023524, + 0.3516113793011755, + 0.7043679361231625, + 0.7031691493466496, + 0.7031559362076223, + 0.7030991255305707, + 0.7030523847788572, + 0.7028030231595039, + 0.702651625033468, + 0.7026537205092609, + 0.7026347448118031, + 0.7026353268884122, + 0.7026360253803432 + ], + "raw_time_brier": 0.0006490272510116204, + "raw_timepoint_brier": [ + 0.00035288388608023524, + 0.0003516113793011755, + 0.0007043679361231625, + 0.0007031691493466496, + 0.0007031559362076223, + 0.0007030991255305707, + 0.0007030523847788572, + 0.0007028030231595039, + 0.000702651625033468, + 0.0007026537205092609, + 0.0007026347448118031, + 0.0007026353268884122, + 0.0007026360253803432 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "C22": { + "normalized_time_brier": 1.8298323989855083, + "normalized_timepoint_brier": [ + 0.7060678908601403, + 1.0560458758845925, + 1.7542329151183367, + 1.752486452460289, + 1.7506947042420506, + 1.747218193486333, + 1.7461060779169202, + 2.0981081761419773, + 2.0973184145987034, + 2.0963840652257204, + 2.403257381636309, + 2.2899691260328794, + 2.289931913207358 + ], + "raw_time_brier": 0.0018581436911168008, + "raw_timepoint_brier": [ + 0.0007060678908601403, + 0.0010560458758845925, + 0.0017542329151183367, + 0.001752486452460289, + 0.0017506947042420506, + 0.001747218193486333, + 0.0017461060779169202, + 0.0020981081761419773, + 0.0020973184145987034, + 0.0020963840652257204, + 0.0024511644151061773, + 0.0024500403087586164, + 0.0024500004947185516 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001019934208393963, + 0.0010699010222041914, + 0.0010699010222041912 + ] + }, + "C25": { + "normalized_time_brier": 0.6446085864528339, + "normalized_timepoint_brier": [ + 0.001223321646648401, + 0.3329400788061321, + 0.32982698758132756, + 0.3291316970717162, + 0.684240716509521, + 0.6686837290592487, + 0.6467340457053232, + 0.6167513343846922, + 0.8583781242955749, + 0.8128151407189742, + 1.0504468354057224, + 1.0243744831735317, + 1.024365129528429 + ], + "raw_time_brier": 0.0007665074506786158, + "raw_timepoint_brier": [ + 1.223321646648401e-06, + 0.0003329400788061321, + 0.00032982698758132756, + 0.0003291316970717162, + 0.000684240716509521, + 0.0006834161467850208, + 0.0006826048484072089, + 0.0006819222471676767, + 0.0010352627141401172, + 0.0010347351199015975, + 0.001389947603456676, + 0.0013896790333092213, + 0.0013896663440391421 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010220319668111243, + 0.0010554645343632176, + 0.001105668053151442, + 0.00120606838040019, + 0.0012730263845556868, + 0.0013231965260953216, + 0.0013566123094007271, + 0.001356612309400732 + ] + }, + "C61": { + "normalized_time_brier": 0.5990433633886906, + "normalized_timepoint_brier": [ + 0.35549045423977077, + 0.7102068047970533, + 0.7100662915036082, + 0.7107885321602225, + 0.7105213007889688, + 0.708127241102176, + 0.6858022867687532, + 0.607870086216944, + 0.5678185937547034, + 0.5261803972583496, + 0.5135508804471794, + 0.49612632442103505, + 0.4850145305942135 + ], + "raw_time_brier": 0.0006840614704952503, + "raw_timepoint_brier": [ + 0.00035549045423977077, + 0.0007102068047970533, + 0.0007100662915036082, + 0.0007107885321602225, + 0.0007105213007889688, + 0.0007109523867256939, + 0.0007113251485861838, + 0.0007115599000826478, + 0.0007118522771634161, + 0.0007121644448488951, + 0.0007122098468244076, + 0.0007127306889742613, + 0.0007129310397431254 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.00100398960166978, + 0.0010372160640316392, + 0.0011705789052904598, + 0.001253661442215707, + 0.001353460616472242, + 0.0013868340488565494, + 0.0014365911540896307, + 0.0014699168679950289 + ] + }, + "C67": { + "normalized_time_brier": 0.7040050650875156, + "normalized_timepoint_brier": [ + 0.7059142808429897, + 0.705552869476378, + 0.7050500717014074, + 0.7030612323433161, + 0.7030681008473039, + 0.7031321874819696, + 0.7033382426016033, + 0.7034145528450608, + 0.703739351592958, + 0.7034575683064759, + 0.7039582123979926, + 0.7041600183583796, + 0.7042191573418677 + ], + "raw_time_brier": 0.0007040050650875156, + "raw_timepoint_brier": [ + 0.0007059142808429897, + 0.000705552869476378, + 0.0007050500717014074, + 0.0007030612323433161, + 0.0007030681008473039, + 0.0007031321874819696, + 0.0007033382426016033, + 0.0007034145528450608, + 0.000703739351592958, + 0.0007034575683064759, + 0.0007039582123979926, + 0.0007041600183583796, + 0.0007042191573418677 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "C77": { + "normalized_time_brier": 1.1889834632823988, + "normalized_timepoint_brier": [ + 0.985216042371044, + 1.1492986918371362, + 1.217648050825657, + 1.1583679798357682, + 1.0967212409005926, + 1.169557011619114, + 1.1984636628847969, + 1.3123152082780376, + 1.2237227066460379, + 1.1876057865958587, + 1.243254460289642, + 1.2624758512015477, + 1.252138329385954 + ], + "raw_time_brier": 0.005555432379389038, + "raw_timepoint_brier": [ + 0.0013895700685679913, + 0.0027497096452862024, + 0.003818696364760399, + 0.0044346400536596775, + 0.004789876751601696, + 0.0055014388635754585, + 0.00585921760648489, + 0.006813390646129847, + 0.0068056415766477585, + 0.006804223638027906, + 0.007519271224737167, + 0.007868235930800438, + 0.007866708561778069 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0014104216829679502, + 0.002392510898007579, + 0.003136124894357639, + 0.003828351724888333, + 0.004367451429743808, + 0.004703865488317978, + 0.004888940556096035, + 0.005191885762773471, + 0.005561424610074096, + 0.005729362145945301, + 0.0060480548953634125, + 0.006232385295379654, + 0.006282619401672566 + ] + }, + "C78": { + "normalized_time_brier": 1.7738875107632408, + "normalized_timepoint_brier": [ + 2.0040639726259184, + 1.9326500095653678, + 1.7427002671448832, + 1.6605534431986666, + 1.7513705478073416, + 1.737463479216785, + 1.7703520143170572, + 1.6118754216180733, + 1.6703019391261336, + 1.7692613977685703, + 1.7771216817157034, + 1.821081941582167, + 1.8117415242354638 + ], + "raw_time_brier": 0.008213924566427102, + "raw_timepoint_brier": [ + 0.0024056839756667614, + 0.004731140099465847, + 0.005395391955971718, + 0.006101351231336594, + 0.007119144778698683, + 0.007770353462547064, + 0.008487597107887268, + 0.008493397384881973, + 0.009395424276590347, + 0.010817200876772404, + 0.011584723368287086, + 0.012240838259458542, + 0.012238772585988045 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0012004027858025918, + 0.002448006662380546, + 0.0030959953686190375, + 0.0036742877841882474, + 0.004064899222846712, + 0.004472239880431783, + 0.004794299122009077, + 0.005269264157124449, + 0.005624985552914962, + 0.006113964217167279, + 0.00651881268878715, + 0.0067217394121341, + 0.006755253120973027 + ] + }, + "C79": { + "normalized_time_brier": 2.1180216150656497, + "normalized_timepoint_brier": [ + 1.4052405022084713, + 2.247578919982781, + 2.047681810062293, + 2.3369445177587904, + 2.0782960401520003, + 2.069450963061145, + 2.2357278106265572, + 2.152304792113144, + 2.18772740923585, + 2.214115948065617, + 2.104692679392962, + 2.242684789753743, + 2.2118348134400923 + ], + "raw_time_brier": 0.006679561651813297, + "raw_timepoint_brier": [ + 0.0014052405022084713, + 0.003001853358000517, + 0.003644227748736739, + 0.00523665314540267, + 0.0053302389569580555, + 0.006082428619265556, + 0.007293239235877991, + 0.007681252900511026, + 0.008365410380065441, + 0.00891690794378519, + 0.009369244799017906, + 0.010249529033899307, + 0.010258074849843979 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001335594194851905, + 0.00177968458323409, + 0.0022408119258324538, + 0.002564715927846457, + 0.0029391508800326394, + 0.003262132000690226, + 0.0035688499735994795, + 0.0038237900868040003, + 0.004027299451763369, + 0.00445159756136948, + 0.0045702049082986616, + 0.004637812366236101 + ] + }, + "C83": { + "normalized_time_brier": 0.2600353273185017, + "normalized_timepoint_brier": [ + 0.0012255050023668446, + 0.0034825000057026045, + 0.008620467269793153, + 0.013140757801011205, + 0.014168375855660997, + 0.015341511243605055, + 0.016643623894196935, + 0.016934796803980134, + 0.3719726810231805, + 0.7267207838594913, + 0.7279712008312345, + 0.7320777513086796, + 0.7321593002416193 + ], + "raw_time_brier": 0.0002600353273185017, + "raw_timepoint_brier": [ + 1.2255050023668446e-06, + 3.4825000057026045e-06, + 8.620467269793153e-06, + 1.3140757801011205e-05, + 1.4168375855660997e-05, + 1.5341511243605055e-05, + 1.6643623894196935e-05, + 1.6934796803980134e-05, + 0.0003719726810231805, + 0.0007267207838594913, + 0.0007279712008312345, + 0.0007320777513086796, + 0.0007321593002416193 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "D25": { + "normalized_time_brier": 0.7877274569123797, + "normalized_timepoint_brier": [ + 0.714555790182203, + 0.713344372343272, + 0.7109832367859781, + 0.7105555268935859, + 0.7088786805979908, + 0.7085687830112875, + 0.6767206364352312, + 0.9328806934871678, + 0.9054397627193553, + 0.9050937095686306, + 0.8913399695136357, + 0.8311924627411843, + 0.8309033155814138 + ], + "raw_time_brier": 0.0008682795540572932, + "raw_timepoint_brier": [ + 0.0007145557901822031, + 0.000713344372343272, + 0.0007109832367859781, + 0.0007105555268935859, + 0.0007088786805979908, + 0.0007085687830112875, + 0.0007075706380419433, + 0.0010538583155721426, + 0.0010532995220273733, + 0.0010528969578444958, + 0.001051876344718039, + 0.0010508057894185185, + 0.001050440245307982 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010455874993988968, + 0.0011296817727385403, + 0.0011633015970758153, + 0.0011633015970758526, + 0.0011801067838257055, + 0.0012642147715741705, + 0.0012642147715741753 + ] + }, + "D47": { + "normalized_time_brier": 1.6578391424554786, + "normalized_timepoint_brier": [ + 1.4310353435575962, + 1.7980335978791118, + 1.9843805914653387, + 1.7067811654850724, + 1.4579104325009467, + 1.3173840620803818, + 1.410556766782043, + 1.695328920074283, + 1.6569637054184998, + 1.7511430119962392, + 1.6991438350544974, + 1.7649507236517823, + 1.8782966959754313 + ], + "raw_time_brier": 0.0028482154101276626, + "raw_timepoint_brier": [ + 0.0014310353435575962, + 0.0017980335978791118, + 0.0021685922984033823, + 0.0021802217233926058, + 0.002204935299232602, + 0.0022134929895401, + 0.0025827765930444, + 0.0033032549545168877, + 0.0033119963482022285, + 0.0036763236857950687, + 0.0036809358280152082, + 0.0040601324290037155, + 0.004415069241076708 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0010928308348359802, + 0.0012773879671756163, + 0.0015123942116596182, + 0.0016802184368654074, + 0.0018310334286911311, + 0.0019484448801664702, + 0.0019988345775900484, + 0.002099385179057531, + 0.0021663473992460137, + 0.0023004225413177956, + 0.002350570732801022 + ] + }, + "D50": { + "normalized_time_brier": 1.0681064278944854, + "normalized_timepoint_brier": [ + 1.3195295016900945, + 1.0051506942537258, + 1.0946331610365065, + 1.145152347915681, + 1.1251753461928167, + 1.0952791223544467, + 1.0235450570022135, + 0.995629532731423, + 1.0097507779277817, + 0.983746130500618, + 1.0334424303427399, + 1.0305933125950952, + 1.023756148085168 + ], + "raw_time_brier": 0.01484865011074222, + "raw_timepoint_brier": [ + 0.005524448584765196, + 0.006863608956336975, + 0.010011445730924606, + 0.01283900998532772, + 0.01383043359965086, + 0.014907514676451683, + 0.015554066747426987, + 0.016297046095132828, + 0.01765354536473751, + 0.01824706420302391, + 0.019952327013015747, + 0.020675981417298317, + 0.020675959065556526 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.004186680614332086, + 0.006828437761198446, + 0.009145936819093608, + 0.01121161739631963, + 0.012291802914495067, + 0.01361069920186739, + 0.01519626971086369, + 0.01636858445773831, + 0.017483071813983894, + 0.018548549912707837, + 0.019306665206690405, + 0.020062211897372947, + 0.02019617572429607 + ] + }, + "D53": { + "normalized_time_brier": 2.3900218292261264, + "normalized_timepoint_brier": [ + 1.77340442314744, + 2.4871716741472483, + 2.452307991127293, + 2.5463732820788194, + 2.466837402980952, + 2.2693609697780768, + 2.5073542228257577, + 2.346210859123724, + 2.4770005851206656, + 2.399734590413888, + 2.406991482022536, + 2.4763411493356124, + 2.461195147837625 + ], + "raw_time_brier": 0.004692472804051179, + "raw_timepoint_brier": [ + 0.00177340442314744, + 0.0024871716741472483, + 0.0031983309891074896, + 0.003915965091437101, + 0.004287417978048325, + 0.004322221037000418, + 0.005026216618716717, + 0.005055602174252272, + 0.0057915495708584785, + 0.005810469388961792, + 0.006188324186950922, + 0.006572327110916376, + 0.00657314620912075 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0013042126032616562, + 0.0015378597941619026, + 0.001738022122117722, + 0.0019045982964195829, + 0.0020045897675567484, + 0.0021547944655496425, + 0.002338130077824082, + 0.0024212966767960978, + 0.0025709788477319513, + 0.0026540475300342575, + 0.0026707131349969684 + ] + }, + "D59": { + "normalized_time_brier": 0.3513548495102616, + "normalized_timepoint_brier": [ + 0.00025143563675555924, + 0.0007210003332147608, + 0.0020329734979895875, + 0.0024767689410509774, + 0.0031440556540474063, + 0.35272855893708766, + 0.3531448601279408, + 0.3531918628141284, + 0.6999202887527645, + 0.6999277975410223, + 0.6999358884058893, + 0.7000666810199618, + 0.7000708719715476 + ], + "raw_time_brier": 0.00035135484951026157, + "raw_timepoint_brier": [ + 2.5143563675555924e-07, + 7.210003332147608e-07, + 2.0329734979895875e-06, + 2.4767689410509774e-06, + 3.1440556540474063e-06, + 0.00035272855893708766, + 0.0003531448601279408, + 0.0003531918628141284, + 0.0006999202887527645, + 0.0006999277975410223, + 0.0006999358884058893, + 0.0007000666810199618, + 0.0007000708719715476 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "D61": { + "normalized_time_brier": 1.0796416973793117, + "normalized_timepoint_brier": [ + 0.8937079181168677, + 0.8881744665844663, + 1.026395884867688, + 1.006610005215603, + 1.0747864217517296, + 1.1168419540289254, + 1.233112041585044, + 1.1957399063241196, + 1.1439553063576962, + 1.1327563890445487, + 1.1171993800538929, + 1.1083589264134868, + 1.0977034655869808 + ], + "raw_time_brier": 0.008014028560585128, + "raw_timepoint_brier": [ + 0.0014428662834689021, + 0.0032035275362432003, + 0.004968329798430204, + 0.005726806353777647, + 0.0070416368544101715, + 0.00807614903897047, + 0.009610958397388458, + 0.010031480342149734, + 0.010049025528132915, + 0.010567867197096348, + 0.010920262895524502, + 0.011271852999925613, + 0.01127160806208849 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0016144718584447213, + 0.003606867408114734, + 0.004840558961390096, + 0.005689200707428929, + 0.006551661531910156, + 0.007231237159238472, + 0.007794067427185706, + 0.008389349798475807, + 0.00878445641388611, + 0.009329337975317072, + 0.009774676830735187, + 0.010169858094976458, + 0.010268354264565578 + ] + }, + "D62": { + "normalized_time_brier": 1.0999275583863974, + "normalized_timepoint_brier": [ + 0.7947917640617913, + 0.9510126875971676, + 1.030239195129973, + 1.0402862310131398, + 1.1158721166339853, + 1.1182944204578158, + 1.1759715233421402, + 1.1821758418769728, + 1.1799148471665708, + 1.1985814103977697, + 1.1861990737731092, + 1.1669487501613471, + 1.1587703974113845 + ], + "raw_time_brier": 0.019350578578618858, + "raw_timepoint_brier": [ + 0.0039722975343465805, + 0.008306915871798992, + 0.011777888983488083, + 0.014137777499854565, + 0.017368577420711517, + 0.018863335251808167, + 0.021137554198503494, + 0.022908082231879234, + 0.024370193481445312, + 0.026303619146347046, + 0.02696266584098339, + 0.02772323600947857, + 0.027725378051400185 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.00499790978462851, + 0.008734810776065752, + 0.011432188795731274, + 0.0135902764819695, + 0.015565025025541116, + 0.016867950788921716, + 0.01797454596385977, + 0.019377897450101374, + 0.02065419681764961, + 0.021945625819123744, + 0.022730304244142994, + 0.023757029608751406, + 0.023926550171920878 + ] + }, + "D63": { + "normalized_time_brier": 1.9188030416164508, + "normalized_timepoint_brier": [ + 2.450160253759164, + 1.9781092466497543, + 2.0623288302813476, + 2.0345178887026014, + 1.8904333354118212, + 1.9101383725052916, + 1.8943469501960006, + 1.850275647418786, + 1.8313661635444356, + 1.8253984364010147, + 1.8015885344288947, + 1.7106519809309795, + 1.7051239007837695 + ], + "raw_time_brier": 0.02056329597074252, + "raw_timepoint_brier": [ + 0.007169995456933975, + 0.010953321121633053, + 0.014956760220229626, + 0.017912844195961952, + 0.018982982262969017, + 0.02137068472802639, + 0.02284632995724678, + 0.023579200729727745, + 0.02461758442223072, + 0.02565416879951954, + 0.026386814191937447, + 0.02644508332014084, + 0.026447078213095665 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0029263373470912336, + 0.005537268045323716, + 0.007252364414742333, + 0.008804466303997383, + 0.010041603640486837, + 0.011188029639966403, + 0.012060266972152572, + 0.012743615127087547, + 0.013442196821298543, + 0.014054010504194206, + 0.014646415475941121, + 0.015459066844063025, + 0.015510355699629289 + ] + }, + "D64": { + "normalized_time_brier": 0.8342746405790907, + "normalized_timepoint_brier": [ + 1.0382374501784482, + 0.843757766313097, + 0.8596355632519758, + 0.8415944636435316, + 0.8366462814857638, + 0.8085317422386352, + 0.8119837579735235, + 0.8120468413493409, + 0.7975858491343761, + 0.8204683656543008, + 0.8044981092856992, + 0.7847921725634937, + 0.7857919644559946 + ], + "raw_time_brier": 0.03360076420582258, + "raw_timepoint_brier": [ + 0.014506550505757332, + 0.019576121121644974, + 0.024938037618994713, + 0.028568603098392487, + 0.03157738223671913, + 0.033001698553562164, + 0.03572597727179527, + 0.03761814162135124, + 0.03898023068904877, + 0.041847024112939835, + 0.04291684180498123, + 0.04360068589448929, + 0.043952640146017075 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.013972285919048675, + 0.02320111518165366, + 0.02901001155030727, + 0.03394580683754723, + 0.03774281071403584, + 0.040816824905585254, + 0.04399838903299861, + 0.046325088290280036, + 0.04887277116482722, + 0.05100382399212673, + 0.053346106485056125, + 0.0555569836432865, + 0.05593419395227028 + ] + }, + "D65": { + "normalized_time_brier": 1.025797546406515, + "normalized_timepoint_brier": [ + 0.35313970874994993, + 0.3540743491612375, + 0.7053666049614549, + 1.0570414597168565, + 1.0581236565485597, + 1.0283753364579076, + 1.0127398461970731, + 0.9526553257190429, + 1.2129430749777623, + 1.2130079934085696, + 1.1799632004454785, + 1.6139266213274805, + 1.5940109256133241 + ], + "raw_time_brier": 0.0011667225357646553, + "raw_timepoint_brier": [ + 0.00035313970874994993, + 0.0003540743491612375, + 0.0007053666049614549, + 0.0010570414597168565, + 0.0010581236565485597, + 0.0010586512507870793, + 0.001059341011568904, + 0.0010596644133329391, + 0.0014094755752012134, + 0.0014095510123297572, + 0.001410272321663797, + 0.0021162047050893307, + 0.002116486895829439 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001029440529401894, + 0.0010460149420868767, + 0.001112327181431677, + 0.0011620294507448787, + 0.0011620294507449197, + 0.0011951833083704377, + 0.0013112149444246223, + 0.0013277743971642371 + ] + }, + "D68": { + "normalized_time_brier": 2.7522621045972744, + "normalized_timepoint_brier": [ + 2.671875235889997, + 2.7871873907506073, + 2.8590466356333195, + 2.6724559179886627, + 2.7973355343913564, + 2.8070865849131987, + 2.8870081905309037, + 2.7493612210251843, + 2.740208741603418, + 2.7513308282389395, + 2.665800894136648, + 2.7069402849535646, + 2.6837698997087736 + ], + "raw_time_brier": 0.01540587955297759, + "raw_timepoint_brier": [ + 0.003672187915071845, + 0.007601331919431686, + 0.010483496822416782, + 0.011575473472476006, + 0.014020866714417934, + 0.01569143496453762, + 0.017216693609952927, + 0.017933951690793037, + 0.018895402550697327, + 0.019809754565358162, + 0.020186610519886017, + 0.021596428006887436, + 0.021592801436781883 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0013743859989213327, + 0.0027272410691355055, + 0.0036667806295137746, + 0.004331399217685847, + 0.005012222002702508, + 0.0055899362167422546, + 0.005963507019627429, + 0.0065229521510839555, + 0.006895606989283883, + 0.007200062734018035, + 0.007572437448080194, + 0.00797816934748448, + 0.008045697747457784 + ] + }, + "D69": { + "normalized_time_brier": 1.189459882898757, + "normalized_timepoint_brier": [ + 1.1245377651102932, + 1.272421779089561, + 1.2287714799753413, + 1.1744288557827678, + 1.1450463072720494, + 1.1920349268991826, + 1.1979132385570426, + 1.1840607422141844, + 1.1721388714393088, + 1.20655812327139, + 1.2039914028014047, + 1.178298356462463, + 1.182776628808852 + ], + "raw_time_brier": 0.02033590668669114, + "raw_timepoint_brier": [ + 0.004737899638712406, + 0.010510188527405262, + 0.013536723330616951, + 0.015830351039767265, + 0.01752878725528717, + 0.020206734538078308, + 0.021858803927898407, + 0.02337994985282421, + 0.02475922554731369, + 0.02681627683341503, + 0.02808242104947567, + 0.028395751491189003, + 0.02872367389500141 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0042131974449499425, + 0.008259987922342447, + 0.011016469336420961, + 0.013479191150507103, + 0.015308365385717573, + 0.016951461808792548, + 0.01824740158496673, + 0.019745566269770826, + 0.02112311616874458, + 0.02222543308622959, + 0.0233244365234955, + 0.024098948568883626, + 0.024284952200931114 + ] + }, + "D70": { + "normalized_time_brier": 0.9935817147475047, + "normalized_timepoint_brier": [ + 0.9910627295795646, + 0.8150684951977296, + 1.0569592762357216, + 1.088820377934244, + 0.9995379209657018, + 1.0273901740282037, + 1.028603275389652, + 1.0456637159226756, + 1.0172353915550796, + 0.9927240917586695, + 0.9680210154787818, + 0.9434967811757575, + 0.9419790464957819 + ], + "raw_time_brier": 0.007079744854798684, + "raw_timepoint_brier": [ + 0.0016835944261401892, + 0.0029946903232485056, + 0.005346788093447685, + 0.006576779764145613, + 0.00675131194293499, + 0.007467449177056551, + 0.007969973608851433, + 0.008690097369253635, + 0.008773308247327805, + 0.008857031352818012, + 0.008939625695347786, + 0.008992500603199005, + 0.008993532508611679 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0016987768542707836, + 0.003674157866354552, + 0.005058650994094925, + 0.006040279827076121, + 0.0067544330248243325, + 0.00726836733096063, + 0.007748345547346497, + 0.008310604295555616, + 0.008624658874595164, + 0.008921946617742758, + 0.00923495001906158, + 0.009531034745018228, + 0.009547486796089738 + ] + }, + "D72": { + "normalized_time_brier": 1.0677518109013069, + "normalized_timepoint_brier": [ + 1.0916107374601645, + 1.0705220555811767, + 1.1012569048718697, + 1.0688793944065527, + 1.0990965622738116, + 1.0315554979719448, + 1.0493176877246129, + 1.0511817714388594, + 1.0629083381477642, + 1.045605564757476, + 1.0879827308896863, + 1.0649144918637459, + 1.055941804329324 + ], + "raw_time_brier": 0.017974869097368076, + "raw_timepoint_brier": [ + 0.006061457563191652, + 0.009780045598745346, + 0.012766076251864433, + 0.014651685021817684, + 0.016780102625489235, + 0.01715693436563015, + 0.01863001473248005, + 0.020143279805779457, + 0.02159099467098713, + 0.02231713756918907, + 0.02413967251777649, + 0.02482597902417183, + 0.024829918518662453 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0055527646945785466, + 0.00913577216625943, + 0.011592278055545772, + 0.013707519387584766, + 0.015267177790798062, + 0.016632100162677594, + 0.017754408364999738, + 0.01916250866699039, + 0.020313129454428626, + 0.02134374406697562, + 0.02218755117375487, + 0.02331265018351189, + 0.02351447628729222 + ] + }, + "D73": { + "normalized_time_brier": 0.8349155545546659, + "normalized_timepoint_brier": [ + 0.003227074330425239, + 0.34779959241859615, + 0.7061660871841013, + 0.7106304401531816, + 1.0665967129170895, + 1.0704869637265801, + 1.0712997755035758, + 1.075391424819827, + 1.048234434289815, + 0.9908336738921251, + 0.9435654452072091, + 0.909779824195999, + 0.9098907605721315 + ], + "raw_time_brier": 0.0008868068475224461, + "raw_timepoint_brier": [ + 3.227074330425239e-06, + 0.00034779959241859615, + 0.0007061660871841013, + 0.0007106304401531816, + 0.0010665967129170895, + 0.0010704869637265801, + 0.0010712997755035758, + 0.001075391424819827, + 0.0010811531683430076, + 0.001087817596271634, + 0.0010985814733430743, + 0.001104602008126676, + 0.0011047367006540298 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010314039808046328, + 0.0010978811327622157, + 0.0011642875212559563, + 0.001214142124005495, + 0.0012141421240055026 + ] + }, + "D75": { + "normalized_time_brier": 0.6569698402264486, + "normalized_timepoint_brier": [ + 0.00020832963798511628, + 0.0007328077913371089, + 0.3544573555700481, + 0.6964090867784658, + 0.6164693527648554, + 0.8611504575027645, + 0.8072064016760349, + 0.9879687820978341, + 0.9443985621107709, + 0.8864114802851457, + 0.8270381899828774, + 0.7825833696506129, + 0.7755737470950993 + ], + "raw_time_brier": 0.0009532280723793571, + "raw_timepoint_brier": [ + 2.0832963798511628e-07, + 7.328077913371089e-07, + 0.0003544573555700481, + 0.0007074344321154058, + 0.0007081266958266497, + 0.0010606900323182344, + 0.0010613595368340611, + 0.0014139206614345312, + 0.0014141956344246864, + 0.0014157266123220325, + 0.0014171687653288245, + 0.001418877742253244, + 0.0014190663350746036 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.0010158317080380763, + 0.0011486811025571873, + 0.0012317127896489903, + 0.0013148552026226725, + 0.0014311390066720925, + 0.0014974563612887117, + 0.0015971438139165501, + 0.0017135469467959696, + 0.001813069121168147, + 0.0018296987751193188 + ] + }, + "D80": { + "normalized_time_brier": 1.6705399713704274, + "normalized_timepoint_brier": [ + 0.3524394123815, + 1.0391906835138798, + 1.3760693836957216, + 1.7044729320332408, + 2.05655163154006, + 2.064391737803817, + 2.0742840133607388, + 2.0772679708898067, + 1.9187275335794618, + 1.8472741035440718, + 1.7506416524881545, + 1.7277493610812409, + 1.7279592119038614 + ], + "raw_time_brier": 0.0017952129217939307, + "raw_timepoint_brier": [ + 0.0003524394123815, + 0.0010391906835138798, + 0.0013760693836957216, + 0.0017044729320332408, + 0.00205655163154006, + 0.002064391737803817, + 0.0020742840133607388, + 0.0020772679708898067, + 0.0021041473373770714, + 0.002117640571668744, + 0.0021230988204479218, + 0.002123977756127715, + 0.0021242357324808836 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010966368598733253, + 0.0011463596916158588, + 0.0012127546590876555, + 0.0012293321033546851, + 0.0012293321033546884 + ] + }, + "D89": { + "normalized_time_brier": 0.6799788390872188, + "normalized_timepoint_brier": [ + 0.35292882239446044, + 0.7107065175659955, + 0.7280025165528059, + 0.7708393968641758, + 0.7896929164417088, + 0.8208879153244197, + 0.8217542340718015, + 0.7279912698397399, + 0.6848323856014518, + 0.6580633190877725, + 0.6094741306879671, + 0.5822074216700796, + 0.5823440620314667 + ], + "raw_time_brier": 0.000812382423856224, + "raw_timepoint_brier": [ + 0.00035292882239446044, + 0.0007107065175659955, + 0.0007280025165528059, + 0.0007708393968641758, + 0.0007896929164417088, + 0.0008208879153244197, + 0.0008326201932504773, + 0.0008583869785070419, + 0.000886954425368458, + 0.0009176500025205314, + 0.0009406866156496108, + 0.0009756931103765965, + 0.00097592209931463 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010132228818887064, + 0.0011791171324018863, + 0.0012951408899704608, + 0.0013944706776737015, + 0.0015434397758404856, + 0.0016758513788398494, + 0.0016758513788398457 + ] + }, + "E03": { + "normalized_time_brier": 1.157368005214097, + "normalized_timepoint_brier": [ + 1.2904106999515144, + 1.2990756113783617, + 1.289971620229398, + 1.3335094686016271, + 1.2671216211271739, + 1.126287509083916, + 1.1128887595690562, + 1.0789995843507245, + 1.059807612575963, + 1.0384662229707575, + 1.041668371934536, + 1.0567607425708914, + 1.0508162434393427 + ], + "raw_time_brier": 0.00757345870638696, + "raw_timepoint_brier": [ + 0.002813587198033929, + 0.004413621034473181, + 0.005610608961433172, + 0.006792725995182991, + 0.007184057030826807, + 0.0071800341829657555, + 0.007959562353789806, + 0.008356237784028053, + 0.008754854090511799, + 0.009153267368674278, + 0.009546143002808094, + 0.01034542266279459, + 0.01034484151750803 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0021803811748768403, + 0.0033975089639241124, + 0.004349404958564458, + 0.005093871588558065, + 0.005669587599993911, + 0.006374956771744501, + 0.0071521634892529485, + 0.007744430957363457, + 0.008260795626134724, + 0.00881421770511647, + 0.009164282280241897, + 0.009789749227082574, + 0.00984457709147049 + ] + }, + "E04": { + "normalized_time_brier": 2.5899939811383317, + "normalized_timepoint_brier": [ + 1.0799370938912034, + 1.4398728962987661, + 2.1584585774689913, + 2.8757706750184298, + 3.232025308534503, + 3.0952525244518214, + 2.7831781514984675, + 2.744549542670489, + 3.132949387471725, + 2.9384722139467376, + 2.834384663092515, + 2.6772139837545033, + 2.677856736700154 + ], + "raw_time_brier": 0.0031010397584535754, + "raw_timepoint_brier": [ + 0.0010799370938912034, + 0.0014398728962987661, + 0.0021584585774689913, + 0.0028757706750184298, + 0.003232025308534503, + 0.0032340234611183405, + 0.0032358579337596893, + 0.0032370781991630793, + 0.0039588832296431065, + 0.003960645291954279, + 0.003963223658502102, + 0.00396839389577508, + 0.003969346638768911 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001044833478228435, + 0.0011626485110259645, + 0.0011794570106442139, + 0.0012636282109995739, + 0.0013478586842359942, + 0.001398265983480853, + 0.0014822849125454799, + 0.0014822849125454797 + ] + }, + "E05": { + "normalized_time_brier": 0.9374100971653925, + "normalized_timepoint_brier": [ + 0.7128939614631236, + 0.7132341852411628, + 0.7136184140108526, + 0.714167661499232, + 0.7148777949623764, + 0.7151831523515284, + 1.0713038500398397, + 1.0171651468520835, + 1.2310111421473375, + 1.2134675080547488, + 1.1479625733442884, + 1.1179992209714358, + 1.1034466522120927 + ], + "raw_time_brier": 0.001040849642147525, + "raw_timepoint_brier": [ + 0.0007128939614631236, + 0.0007132341852411628, + 0.0007136184140108526, + 0.000714167661499232, + 0.0007148777949623764, + 0.0007151831523515284, + 0.0010713038500398397, + 0.001071894890628755, + 0.0014205781044438481, + 0.0014206080231815577, + 0.0014207009226083755, + 0.001420996617525816, + 0.0014209877699613571 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010538061532545122, + 0.0011539928891023976, + 0.0011707013280140197, + 0.0012375847049347047, + 0.001271017538179592, + 0.0012877720613975183 + ] + }, + "E11": { + "normalized_time_brier": 2.625532778590699, + "normalized_timepoint_brier": [ + 2.7070376090705395, + 2.8081178364359105, + 2.652355769373356, + 2.8076871111763118, + 2.494451873708967, + 2.5832597544509843, + 2.635914420011447, + 2.721180195932058, + 2.57961452401878, + 2.4967263736170615, + 2.501721879139578, + 2.5719401013120216, + 2.5719186734320765 + ], + "raw_time_brier": 0.0071825250051915646, + "raw_timepoint_brier": [ + 0.0027070376090705395, + 0.004058415535837412, + 0.0049178143963217735, + 0.005809382069855928, + 0.005804458167403936, + 0.006677848286926746, + 0.007549645844846964, + 0.008435704745352268, + 0.008438955061137676, + 0.008755659684538841, + 0.009202496148645878, + 0.010507747530937195, + 0.010507659986615181 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001445244029000005, + 0.0018541307516538978, + 0.0020690988133011813, + 0.0023269473460609865, + 0.002585047158119017, + 0.0028641467976089218, + 0.0031000169551296006, + 0.0032714015922001524, + 0.003506855928250691, + 0.003678464910660217, + 0.004085533533839644, + 0.0040855335338396675 + ] + }, + "E16": { + "normalized_time_brier": 1.3072550440272346, + "normalized_timepoint_brier": [ + 0.35586365265771747, + 1.0690762428566813, + 1.2395004795463276, + 1.0843076694863116, + 1.1653886848547566, + 1.073736703163424, + 1.2257188618513226, + 1.2877910569768516, + 1.3986081965052122, + 1.6081732327070257, + 1.8057250893803412, + 1.8402091192687358, + 1.8402165830993447 + ], + "raw_time_brier": 0.002482512979230915, + "raw_timepoint_brier": [ + 0.00035586365265771747, + 0.0010690762428566813, + 0.0014245809288695455, + 0.0014267194783315063, + 0.0017854194156825542, + 0.0017878395738080144, + 0.002142720390111208, + 0.0024865863379091024, + 0.002839975757524371, + 0.003532704897224903, + 0.00423645181581378, + 0.00459235580638051, + 0.004592374432832003 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0011493185782315788, + 0.0013157884228628682, + 0.0015320377131558237, + 0.0016650632958161095, + 0.0017481336518513294, + 0.0019308926898020846, + 0.0020305727970283544, + 0.002196719125388207, + 0.0023461222534530853, + 0.002495561921900173, + 0.0024955619219001906 + ] + }, + "E21": { + "normalized_time_brier": 0.44991592550936943, + "normalized_timepoint_brier": [ + 0.3547827946022153, + 0.3564436046872288, + 0.3587744722608477, + 0.31264497199877506, + 0.28245370864770625, + 0.2353109613661508, + 0.4101523522124913, + 0.39051555791239906, + 0.540994115345336, + 0.4966435804123228, + 0.627951848863642, + 0.7461742718843737, + 0.7360647914283149 + ], + "raw_time_brier": 0.0008299492004040915, + "raw_timepoint_brier": [ + 0.0003547827946022153, + 0.0003564436046872288, + 0.0003587744722608477, + 0.0003603168879635632, + 0.00036320171784609556, + 0.00036929018096998334, + 0.000725726131349802, + 0.0007300005527213216, + 0.0010743243619799614, + 0.001077153254300356, + 0.001435045967809856, + 0.0017920418176800013, + 0.0017922378610819578 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.0011524793943111131, + 0.0012858805061720865, + 0.0015693709244396692, + 0.0017694062399862054, + 0.0018693251470536193, + 0.0019858337299920193, + 0.0021688657556110623, + 0.002285280265368678, + 0.002401639784703933, + 0.0024348914415593306 + ] + }, + "E22": { + "normalized_time_brier": 0.7124030652808426, + "normalized_timepoint_brier": [ + 1.069658149312243, + 0.6119238070990789, + 0.6403284577975477, + 0.5506843795829169, + 0.49889511598469066, + 0.6588921792465646, + 0.7252699252281, + 0.8474765258502482, + 0.7888742485040205, + 0.7573347613335106, + 0.7209138107782858, + 0.6987981256769664, + 0.6921903622567793 + ], + "raw_time_brier": 0.0023885212408808563, + "raw_timepoint_brier": [ + 0.0010762156452983618, + 0.0010970146395266056, + 0.0014688621740788221, + 0.0014838154893368483, + 0.0015023432206362486, + 0.002192792249843478, + 0.002558736130595207, + 0.003243917366489768, + 0.00325571745634079, + 0.0032766112126410007, + 0.003287006402388215, + 0.003302277997136116, + 0.0033054661471396685 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001006130459521423, + 0.0017927307726874953, + 0.002293919872202887, + 0.0026944935145258265, + 0.003011340805914705, + 0.003327998599635695, + 0.0035279777109060127, + 0.0038277371319934096, + 0.004127042380347388, + 0.004326503126400223, + 0.00455949983651946, + 0.0047256537700884746, + 0.004775371526934742 + ] + }, + "E27": { + "normalized_time_brier": 1.4318788891380125, + "normalized_timepoint_brier": [ + 0.0017228816204806208, + 0.00551998437003931, + 0.008988482477434445, + 1.4296658337116241, + 1.7829590942710638, + 1.6455657170584348, + 1.9155779573033807, + 1.836990135747498, + 1.9463442004974005, + 2.0388501021916836, + 1.928473598028408, + 2.0368075369938157, + 2.0369600345229 + ], + "raw_time_brier": 0.0018447131887586903, + "raw_timepoint_brier": [ + 1.7228816204806208e-06, + 5.51998437003931e-06, + 8.988482477434445e-06, + 0.0014296658337116241, + 0.0017829590942710638, + 0.0017855599289759994, + 0.002142303856089711, + 0.0021461837459355593, + 0.0025010390672832727, + 0.0028576499316841364, + 0.0028635684866458178, + 0.003227934241294861, + 0.0032281759195029736 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010850736074933635, + 0.0011183590038306244, + 0.001168315335053362, + 0.001284993202458289, + 0.001401598836820949, + 0.001484888613239721, + 0.001584800813364558, + 0.00158480081336455 + ] + }, + "E43": { + "normalized_time_brier": 2.141743638163854, + "normalized_timepoint_brier": [ + 3.53730252526179, + 2.231778448097523, + 2.2842181206671373, + 2.2228146227876038, + 2.1515174694976182, + 2.003696055889882, + 1.971926466655934, + 1.9001418142101856, + 1.9142556829087165, + 1.8628288851909383, + 1.886583373507763, + 1.9249205768234003, + 1.9506832546316126 + ], + "raw_time_brier": 0.01126545535113949, + "raw_timepoint_brier": [ + 0.005001816898584366, + 0.006712470669299364, + 0.008819532580673695, + 0.010178101249039173, + 0.011214347556233406, + 0.01124374009668827, + 0.011623620986938477, + 0.012021836824715137, + 0.012748013250529766, + 0.013117475435137749, + 0.01381575595587492, + 0.014797541312873363, + 0.015156666748225689 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001414020107939224, + 0.0030076778790571273, + 0.0038610728550291986, + 0.004578924911099849, + 0.005212296769708298, + 0.005611499839827102, + 0.005894550929503088, + 0.00632681031216196, + 0.006659514381672947, + 0.007041696389517398, + 0.007323162151157413, + 0.007687351619095372, + 0.007769927133089596 + ] + }, + "E44": { + "normalized_time_brier": 1.344567595481688, + "normalized_timepoint_brier": [ + 1.4219320894006506, + 1.2195961483213382, + 1.3232418821798093, + 1.2857606407943327, + 1.3867665068549353, + 1.2569054734816247, + 1.3009024767196677, + 1.3432789202407676, + 1.286540371356517, + 1.364219285953721, + 1.4356461902128281, + 1.4309321264226575, + 1.4236566293230912 + ], + "raw_time_brier": 0.005900094294562363, + "raw_timepoint_brier": [ + 0.0017833738820627332, + 0.002851861994713545, + 0.003931025974452496, + 0.004311219789087772, + 0.005386903416365385, + 0.00542449951171875, + 0.006110561080276966, + 0.00682143634185195, + 0.006853117141872644, + 0.0075829848647117615, + 0.008312654681503773, + 0.008664296008646488, + 0.008667291142046452 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0012541906152595736, + 0.0023383658587630587, + 0.0029707538941987073, + 0.0033530500563653397, + 0.0038845064325806434, + 0.004315757728934779, + 0.0046971707638571395, + 0.005078198011645477, + 0.00532677970660709, + 0.005558479448859663, + 0.005790183360059945, + 0.006055001385919891, + 0.006088048876060448 + ] + }, + "E46": { + "normalized_time_brier": 2.472328272927598, + "normalized_timepoint_brier": [ + 2.9649697931610834, + 2.452229684832144, + 2.766236103833219, + 2.7159648273385115, + 2.533614938734593, + 2.44182747132662, + 2.4724558337118117, + 2.313506564179661, + 2.2650646975083504, + 2.253321424849063, + 2.2966522667328078, + 2.3380747752798423, + 2.3263491665710734 + ], + "raw_time_brier": 0.0106251875583369, + "raw_timepoint_brier": [ + 0.0036110603250563145, + 0.005633615888655186, + 0.008079411461949348, + 0.009394196793437004, + 0.009743273258209229, + 0.010454538278281689, + 0.011456572450697422, + 0.011495305225253105, + 0.01216424535959959, + 0.01292886771261692, + 0.013676032423973083, + 0.014743096195161343, + 0.014747222885489464 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0012179079643190583, + 0.002297344299965445, + 0.0029207237410984457, + 0.003458880136766268, + 0.0038456014405549247, + 0.004281440192251521, + 0.004633681335976817, + 0.004968780034271997, + 0.0053703743530949385, + 0.005737693508809091, + 0.005954768434939634, + 0.0063056564105811175, + 0.006339213002674985 + ] + }, + "E53": { + "normalized_time_brier": 1.7699654390968875, + "normalized_timepoint_brier": [ + 0.35772041883319616, + 0.7159109809435904, + 1.0762872407212853, + 1.4345846138894558, + 1.4365287497639656, + 1.4402848901227117, + 2.158328192308545, + 2.1092274084412184, + 2.2070402586377815, + 2.1170302353547554, + 2.412692254960151, + 2.7718663776022576, + 2.772049086680625 + ], + "raw_time_brier": 0.002075333788525313, + "raw_timepoint_brier": [ + 0.00035772041883319616, + 0.0007159109809435904, + 0.0010762872407212853, + 0.0014345846138894558, + 0.0014365287497639656, + 0.0014402848901227117, + 0.002158328192308545, + 0.0021611538249999285, + 0.0025205365382134914, + 0.0025243195705115795, + 0.003241167636588216, + 0.003956127911806107, + 0.003956388682126999 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010246186904033668, + 0.0011420437521919987, + 0.0011923871130204117, + 0.0013433821200879794, + 0.0014272433706664707, + 0.0014272433706664822 + ] + }, + "E55": { + "normalized_time_brier": 2.0295928969401866, + "normalized_timepoint_brier": [ + 2.9873032769734187, + 2.039076077464883, + 1.5908355055026075, + 1.8198097235046296, + 2.1197008797285797, + 2.0901517633041564, + 2.2074061581851696, + 2.0484658089252554, + 1.9578969666311548, + 1.9047765603789424, + 1.902434343715186, + 1.8606049825395352, + 1.856245613368917 + ], + "raw_time_brier": 0.007858019232606659, + "raw_timepoint_brier": [ + 0.0032902744133025408, + 0.004038217477500439, + 0.004063395317643881, + 0.005170026794075966, + 0.006985985208302736, + 0.007733672391623259, + 0.009206783957779408, + 0.009232651442289352, + 0.009613140486180782, + 0.009992191568017006, + 0.010682100430130959, + 0.011070449836552143, + 0.01107536070048809 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0011014196110132068, + 0.0019804153077608673, + 0.002554252343242801, + 0.002840971079173824, + 0.0032957410524815495, + 0.003700053042750209, + 0.004170860864748521, + 0.0045071054650081465, + 0.004909931753314671, + 0.005245860210516832, + 0.005614964040898422, + 0.005949919483415611, + 0.0059665383830253575 + ] + }, + "E66": { + "normalized_time_brier": 2.3884847554525757, + "normalized_timepoint_brier": [ + 2.106205815034438, + 2.4143714209603537, + 2.561097337456686, + 2.7176029925794136, + 2.4708663725467277, + 2.3485593037040924, + 2.358314103312856, + 2.35141149011498, + 2.3481455024776636, + 2.3971867036950307, + 2.4086808391746124, + 2.289656908308722, + 2.2782030315179123 + ], + "raw_time_brier": 0.012551595761369053, + "raw_timepoint_brier": [ + 0.0037813850212842226, + 0.006679851561784744, + 0.008741602301597595, + 0.011234953999519348, + 0.011244761757552624, + 0.012020939961075783, + 0.013185303658246994, + 0.013945003040134907, + 0.014767002314329147, + 0.01597745344042778, + 0.01718982309103012, + 0.017201056703925133, + 0.017201608046889305 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001795353993561353, + 0.0027667042045783205, + 0.003413225328748535, + 0.004134141016990745, + 0.004550938845779273, + 0.005118431517618755, + 0.0055909870698414845, + 0.005930481797319542, + 0.006288793560172329, + 0.006665085124909163, + 0.007136613042066873, + 0.007512504009446055, + 0.007550515827129018 + ] + }, + "E78": { + "normalized_time_brier": 2.374500666770528, + "normalized_timepoint_brier": [ + 2.788133457044282, + 2.4586633944828926, + 2.6667499375467587, + 2.5833793385060737, + 2.329620519422246, + 2.1536073903961275, + 2.2072617988783394, + 2.2123208980158644, + 2.136167341684704, + 2.364274805125507, + 2.3770534938691017, + 2.2963773989228224, + 2.2948988941221424 + ], + "raw_time_brier": 0.022007484562121905, + "raw_timepoint_brier": [ + 0.008194634690880775, + 0.012045884504914284, + 0.01646093837916851, + 0.01887786015868187, + 0.01972525753080845, + 0.019969351589679718, + 0.02194761298596859, + 0.023652900010347366, + 0.024540843442082405, + 0.028607666492462158, + 0.030593905597925186, + 0.03072025440633297, + 0.03076018951833248 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0029391113507055574, + 0.004899363016484727, + 0.006172659141153495, + 0.00730742863709618, + 0.008467154786093823, + 0.009272512566000538, + 0.009943366481095117, + 0.010691441748600141, + 0.011488258884590985, + 0.012099975193426605, + 0.012870516240729546, + 0.013377702820426265, + 0.013403723186724111 + ] + }, + "E80": { + "normalized_time_brier": 1.709791353777881, + "normalized_timepoint_brier": [ + 0.7106665871106088, + 1.0628064628690481, + 1.407286967150867, + 1.410727621987462, + 1.411447417922318, + 1.4129597693681717, + 2.1241093054413795, + 2.046275022649939, + 1.9592320658069107, + 2.1538426660607093, + 2.0679801219355185, + 2.2298773537395387, + 2.230076237069983 + ], + "raw_time_brier": 0.001888725884222927, + "raw_timepoint_brier": [ + 0.0007106665871106088, + 0.0010628064628690481, + 0.001407286967150867, + 0.001410727621987462, + 0.001411447417922318, + 0.0014129597693681717, + 0.0021241093054413795, + 0.0021426056046038866, + 0.002149192150682211, + 0.002505845157429576, + 0.002508994657546282, + 0.0028532701544463634, + 0.002853524638339877 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001047076067922287, + 0.0010969563984739425, + 0.0011634299927824649, + 0.001213258595154192, + 0.0012795637166597461, + 0.001279563716659759 + ] + }, + "E83": { + "normalized_time_brier": 1.9347514581294205, + "normalized_timepoint_brier": [ + 1.7888212556106529, + 1.843364625578832, + 2.0544217615977347, + 2.022837303593838, + 2.009425123966705, + 1.9588061390290443, + 2.007575797127124, + 1.941524773187942, + 1.9341254917636166, + 1.9133118569371936, + 1.9004792992627009, + 1.8972500082011285, + 1.8798255198259481 + ], + "raw_time_brier": 0.02046486226698527, + "raw_timepoint_brier": [ + 0.005104346200823784, + 0.009374120272696018, + 0.014303505420684814, + 0.016720427200198174, + 0.01867370679974556, + 0.020409300923347473, + 0.02249389886856079, + 0.023538921028375626, + 0.024891870096325874, + 0.026080576702952385, + 0.0272232498973608, + 0.028619034215807915, + 0.02861025184392929 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0028534691125868274, + 0.005085331541366899, + 0.006962302331513907, + 0.008265828977195607, + 0.009293059281991424, + 0.010419255135408197, + 0.011204507894919809, + 0.012123935451889818, + 0.01286983197436089, + 0.01363111643739137, + 0.014324412745733235, + 0.015084482325522801, + 0.015219631578668161 + ] + }, + "E86": { + "normalized_time_brier": 0.8017484522260774, + "normalized_timepoint_brier": [ + 0.930865423678169, + 0.8023597189602591, + 0.7075431145300993, + 0.750278635438411, + 0.7514432981271064, + 0.8220655637152189, + 0.8364871434249626, + 0.822217117630353, + 0.8070563928052684, + 0.7909772858614775, + 0.7962571466318321, + 0.8010449813913063, + 0.804134056744539 + ], + "raw_time_brier": 0.025516692477350052, + "raw_timepoint_brier": [ + 0.009759506210684776, + 0.014241675846278667, + 0.015866784378886223, + 0.019598614424467087, + 0.02182452753186226, + 0.026064235717058182, + 0.028755901381373405, + 0.029857369139790535, + 0.030932538211345673, + 0.03164958953857422, + 0.03323749825358391, + 0.03481714800000191, + 0.03511161357164383 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.01048433636316796, + 0.01774973931235456, + 0.022425183784628915, + 0.026121781293978883, + 0.029043478844322127, + 0.031705787065528256, + 0.03437697949980861, + 0.036313241964409715, + 0.03832760447361857, + 0.040013272320587163, + 0.041742166326768346, + 0.04346466029851314, + 0.0436638807636004 + ] + }, + "E87": { + "normalized_time_brier": 0.9353909628550329, + "normalized_timepoint_brier": [ + 0.9070166940448615, + 0.8584739510984581, + 0.9247390936292191, + 0.9395146885686028, + 0.9277377837023955, + 0.9250921643796586, + 0.9580705699391165, + 0.9530295961312276, + 0.9630679525381433, + 0.9725967856303238, + 0.9606998215539866, + 0.9343409239119943, + 0.9357024919874367 + ], + "raw_time_brier": 0.044743177767556444, + "raw_timepoint_brier": [ + 0.013730940409004688, + 0.022416086867451668, + 0.031159749254584312, + 0.03693894296884537, + 0.04045635089278221, + 0.04422703757882118, + 0.04865170642733574, + 0.051295313984155655, + 0.054320842027664185, + 0.05765581503510475, + 0.05950791388750076, + 0.060490936040878296, + 0.060809675604104996 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.015138575176352321, + 0.026111551595443545, + 0.033695719656768444, + 0.03931704678840485, + 0.04360752747541433, + 0.04780825012011492, + 0.05078092152483867, + 0.05382342184585476, + 0.05640395559264833, + 0.05928028540392407, + 0.06194225558535373, + 0.06474182441630476, + 0.06498825868780679 + ] + }, + "E88": { + "normalized_time_brier": 1.8298103880991254, + "normalized_timepoint_brier": [ + 1.0565891861915588, + 1.0513152228668332, + 2.410929197664795, + 2.115714423869164, + 1.9125844046108766, + 1.9285183128223184, + 1.8065011836373968, + 1.8421885742762076, + 1.9023364184760794, + 1.9014753500515191, + 2.008465458440398, + 1.9314930607031184, + 1.9194242516783662 + ], + "raw_time_brier": 0.0035220605518239047, + "raw_timepoint_brier": [ + 0.0010565891861915588, + 0.0010513152228668332, + 0.0027833024505525827, + 0.003113827668130398, + 0.0031019351445138454, + 0.0034498076420277357, + 0.003442301182076335, + 0.0037865121848881245, + 0.004132108762860298, + 0.004478815943002701, + 0.005132597871124744, + 0.005128887016326189, + 0.005128786899149418 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0011544521727342575, + 0.0014717617997025848, + 0.0016218552953980335, + 0.0017888384150104668, + 0.0019055072940197299, + 0.0020554422265786974, + 0.0021721230391890628, + 0.002355442547746596, + 0.0025554822710818635, + 0.002655400177549242, + 0.002672044439714018 + ] + }, + "E89": { + "normalized_time_brier": 1.8122645205793495, + "normalized_timepoint_brier": [ + 1.077028689906001, + 1.4372516889125109, + 1.438432838767767, + 1.440278603695333, + 1.4407243579626083, + 1.8004403682425618, + 1.8037495901808143, + 1.8046543700620532, + 2.432982087930893, + 2.364865464478386, + 2.181994522583338, + 2.182304973203368, + 2.1547312116059056 + ], + "raw_time_brier": 0.002051220669482763, + "raw_timepoint_brier": [ + 0.001077028689906001, + 0.0014372516889125109, + 0.001438432838767767, + 0.001440278603695333, + 0.0014407243579626083, + 0.0018004403682425618, + 0.0018037495901808143, + 0.0018046543700620532, + 0.0028832510579377413, + 0.0028836154378950596, + 0.0028850515373051167, + 0.0028854620177298784, + 0.0028859281446784735 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0011850687566671628, + 0.0012193570759980181, + 0.0013222084232775275, + 0.001322208423277503, + 0.001339344846881209 + ] + }, + "F02": { + "normalized_time_brier": 0.4393622724558834, + "normalized_timepoint_brier": [ + 0.0020103655060665915, + 0.366207241313532, + 0.30866696209715966, + 0.28006428647143966, + 0.2488701884602698, + 0.6153740028449021, + 0.5584727349966532, + 0.6493751854285251, + 0.6001203427825439, + 0.5592727768301011, + 0.5369818566506226, + 0.494361032241166, + 0.49193256630350246 + ], + "raw_time_brier": 0.0009831576667063647, + "raw_timepoint_brier": [ + 2.0103655060665915e-06, + 0.000366207241313532, + 0.0003787463647313416, + 0.00038577619125135243, + 0.00039678122266195714, + 0.0011044223792850971, + 0.0011141332797706127, + 0.001479466212913394, + 0.001487120520323515, + 0.0014978785766288638, + 0.0015094387345016003, + 0.0015291667077690363, + 0.0015299018705263734 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0012270388841035826, + 0.0013774558552673336, + 0.0015943300606504752, + 0.0017947173169150829, + 0.001994964498629086, + 0.0022782918813522087, + 0.0024780371773905677, + 0.002678261196832574, + 0.002810967848926205, + 0.0030932185347146398, + 0.003109982902783643 + ] + }, + "F03": { + "normalized_time_brier": 1.4956337401788553, + "normalized_timepoint_brier": [ + 1.8254555761814117, + 1.6671338252078582, + 1.8899243554082703, + 1.6100754511488682, + 1.4435389206668199, + 1.3977056673392774, + 1.5037644101517693, + 1.4211020865801922, + 1.3126157056033136, + 1.23747838503649, + 1.3128457132134126, + 1.4151715469558843, + 1.406426978831552 + ], + "raw_time_brier": 0.004656394406293447, + "raw_timepoint_brier": [ + 0.0018254555761814117, + 0.002556826453655958, + 0.003657885827124119, + 0.004004324786365032, + 0.004023819696158171, + 0.004404752049595118, + 0.005162971094250679, + 0.005184831563383341, + 0.005222637206315994, + 0.005250951740890741, + 0.005916408728808165, + 0.006658412516117096, + 0.006663850042968988 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.00153366599309277, + 0.001935466790856783, + 0.0024870416995102615, + 0.0027874687952988693, + 0.0031514160330909737, + 0.003433364335128532, + 0.003648458201803339, + 0.003978801399390181, + 0.004243267441585175, + 0.004506552955355851, + 0.004705021472795807, + 0.004738141505579807 + ] + }, + "F05": { + "normalized_time_brier": 2.32636965353408, + "normalized_timepoint_brier": [ + 0.3691368910949677, + 2.214260633535671, + 2.550132613390814, + 2.3243428582943664, + 2.142262057279376, + 2.3082841320557046, + 2.246389722168616, + 2.416159059961143, + 2.739775870679709, + 2.7041020911664257, + 2.765188366357289, + 2.70928078652912, + 2.7534904134298333 + ], + "raw_time_brier": 0.00772542599364757, + "raw_timepoint_brier": [ + 0.0003691368910949677, + 0.003273859852924943, + 0.005110190249979496, + 0.005522863939404488, + 0.005958311725407839, + 0.007080370094627142, + 0.00753435306251049, + 0.00867426861077547, + 0.010436708107590675, + 0.010800875723361969, + 0.011508721858263016, + 0.011914198286831379, + 0.01224667951464653 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0014785340999796093, + 0.002003891963557405, + 0.002376096934106029, + 0.0027813178621922466, + 0.003067373724187727, + 0.0033539830547466127, + 0.0035901066095023445, + 0.003809329156914372, + 0.003994255896863334, + 0.004162002848805555, + 0.004397550208184493, + 0.004447692810156432 + ] + }, + "F06": { + "normalized_time_brier": 0.642297135737653, + "normalized_timepoint_brier": [ + 0.3547572414390743, + 0.355765427229926, + 0.3618932969402522, + 0.7156042847782373, + 0.7174059865064919, + 0.7200848194770515, + 0.7205104921013117, + 0.7231013150885701, + 0.728559447452426, + 0.7326201885007322, + 0.7371595711447299, + 0.7411086116917431, + 0.7412920822389424 + ], + "raw_time_brier": 0.000642297135737653, + "raw_timepoint_brier": [ + 0.0003547572414390743, + 0.000355765427229926, + 0.0003618932969402522, + 0.0007156042847782373, + 0.0007174059865064919, + 0.0007200848194770515, + 0.0007205104921013117, + 0.0007231013150885701, + 0.000728559447452426, + 0.0007326201885007322, + 0.0007371595711447299, + 0.0007411086116917431, + 0.0007412920822389424 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "F10": { + "normalized_time_brier": 1.0265108457072996, + "normalized_timepoint_brier": [ + 1.2701061229038884, + 1.3715719153780852, + 1.064864248332031, + 0.8999743010637576, + 0.7573274584301073, + 0.7785096661626524, + 1.0593481160092713, + 1.035382896109134, + 1.0472581815760071, + 1.0636528724513856, + 1.022405713084593, + 0.9923311998634848, + 0.981908302830497 + ], + "raw_time_brier": 0.004759506582139203, + "raw_timepoint_brier": [ + 0.0018999675521627069, + 0.0033464792650192976, + 0.0033314120955765247, + 0.0033360421657562256, + 0.003353319363668561, + 0.003741656895726919, + 0.005623919423669577, + 0.0056267427280545235, + 0.006010184995830059, + 0.006390859372913837, + 0.006398961879312992, + 0.006405678577721119, + 0.006408361252397299 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001495912442197148, + 0.0024398861098703767, + 0.0031284852513310886, + 0.0037068193634118974, + 0.004427832803817497, + 0.004806179111647899, + 0.005308849224045211, + 0.00543445593818409, + 0.005738971632368055, + 0.006008407007997745, + 0.006258730558153236, + 0.006455182078929242, + 0.006526435547926667 + ] + }, + "F11": { + "normalized_time_brier": 1.5027701661919808, + "normalized_timepoint_brier": [ + 1.4290816616266966, + 1.8999124571629868, + 1.5098853105941616, + 1.5360024954960607, + 1.6223833934431187, + 1.4406563081362462, + 1.5318498295816136, + 1.4540510195406144, + 1.3772804819351387, + 1.4450162654405663, + 1.3910125078364024, + 1.462352856389215, + 1.4365275733129286 + ], + "raw_time_brier": 0.0030417083762586117, + "raw_timepoint_brier": [ + 0.0014290816616266966, + 0.002165926154702902, + 0.0021824813447892666, + 0.0025589680299162865, + 0.0029229745268821716, + 0.002937275217846036, + 0.003304861718788743, + 0.003309681313112378, + 0.003321566851809621, + 0.003680572845041752, + 0.003684208495542407, + 0.004021371714770794, + 0.004023239016532898 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0011400136603857715, + 0.0014454616714765101, + 0.0016659921044528338, + 0.0018016546142517282, + 0.0020388452132944473, + 0.002157431919871273, + 0.0022761796309994833, + 0.0024116851254166296, + 0.0025470805644665835, + 0.0026485804223808666, + 0.002749932546854806, + 0.0028006695390151684 + ] + }, + "F12": { + "normalized_time_brier": 2.2308553945339806, + "normalized_timepoint_brier": [ + 1.7867499263957143, + 2.8599118813872337, + 3.245402580416521, + 2.850907744019294, + 2.3427697678502706, + 2.209824187190952, + 2.260347410828246, + 2.110791588940079, + 1.9046302508771897, + 1.8766203607942435, + 1.8112026332460132, + 1.8773517788214078, + 1.8646100181745835 + ], + "raw_time_brier": 0.003837104179323293, + "raw_timepoint_brier": [ + 0.0017867499263957143, + 0.0028599118813872337, + 0.003567647887393832, + 0.003566560335457325, + 0.0035627891775220633, + 0.003919010981917381, + 0.004275140818208456, + 0.004275290761142969, + 0.004273989703506231, + 0.004274158272892237, + 0.004276717081665993, + 0.004622177686542273, + 0.004622209817171097 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0010992928608986173, + 0.001251026218908467, + 0.0015207594132441297, + 0.0017734492203649401, + 0.001891364485710602, + 0.0020254442852360335, + 0.0022439996957613257, + 0.002277582809068149, + 0.002361258206654281, + 0.0024620732985077805, + 0.0024789150396693402 + ] + }, + "F14": { + "normalized_time_brier": 1.9268176061187252, + "normalized_timepoint_brier": [ + 1.4260231982916594, + 1.4208742650225759, + 2.5940536192150585, + 2.2775436673487426, + 2.2852885595159496, + 2.084385584370561, + 2.0394991137270138, + 1.8417310709244281, + 1.8925362946035158, + 1.858756032731107, + 1.842270696117494, + 1.7501041539043956, + 1.7355626237709236 + ], + "raw_time_brier": 0.003000775038694533, + "raw_timepoint_brier": [ + 0.0014260231982916594, + 0.0014208742650225759, + 0.0028439753223210573, + 0.002842147368937731, + 0.0031975656747817993, + 0.0031970434356480837, + 0.0031969116535037756, + 0.0031964548397809267, + 0.003539056982845068, + 0.0035382425412535667, + 0.003537670476362109, + 0.0035371824633330107, + 0.003536927280947566 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0010963440775683053, + 0.0012479002750565198, + 0.001399195590187998, + 0.0015338061535354176, + 0.0015674984274259807, + 0.001735570893190457, + 0.0018700074566266093, + 0.0019035540323464383, + 0.0019202772338601471, + 0.0020211268314755623, + 0.002037913949346724 + ] + }, + "F15": { + "normalized_time_brier": 2.1026805222321014, + "normalized_timepoint_brier": [ + 1.4073478523641825, + 1.7600591527298093, + 1.756820478476584, + 2.110663102939725, + 2.108195098116994, + 2.1074286196380854, + 2.1071387454867363, + 2.1066665649414062, + 2.1042663138359785, + 2.1007354371249676, + 2.100719604641199, + 2.78311176225543, + 2.781694056466222 + ], + "raw_time_brier": 0.0021026805222321013, + "raw_timepoint_brier": [ + 0.0014073478523641825, + 0.0017600591527298093, + 0.001756820478476584, + 0.002110663102939725, + 0.002108195098116994, + 0.0021074286196380854, + 0.0021071387454867363, + 0.0021066665649414062, + 0.0021042663138359785, + 0.0021007354371249676, + 0.002100719604641199, + 0.0027831117622554302, + 0.002781694056466222 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "F17": { + "normalized_time_brier": 2.9050576514748974, + "normalized_timepoint_brier": [ + 3.430408066982136, + 3.4616510037086567, + 2.986035616217938, + 3.0997668761969948, + 2.8442410788357924, + 2.6815585399498607, + 2.7185190065704012, + 2.865031109807884, + 2.8816267846869836, + 2.8051170159682757, + 2.737970791138326, + 2.6318630272116166, + 2.6219605518988036 + ], + "raw_time_brier": 0.010563604497852234, + "raw_timepoint_brier": [ + 0.005168943200260401, + 0.0075153568759560585, + 0.008633237332105637, + 0.009782768785953522, + 0.009781504981219769, + 0.009778214618563652, + 0.010581446811556816, + 0.01179927121847868, + 0.012574754655361176, + 0.012929433956742287, + 0.012930451892316341, + 0.01292531006038189, + 0.012926164083182812 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0015068012607630443, + 0.0021710325124931554, + 0.002891203736893249, + 0.0031559691991920663, + 0.003439056222767004, + 0.0036464669604962204, + 0.0038923571201755322, + 0.00411837455380018, + 0.00436376935492953, + 0.004609231587538347, + 0.004722640553422572, + 0.004911087669359406, + 0.004929961312279006 + ] + }, + "F19": { + "normalized_time_brier": 2.6381638764228694, + "normalized_timepoint_brier": [ + 2.089274115860462, + 2.784119453281164, + 2.7777478098869324, + 3.1161813531070948, + 2.949663636070966, + 2.5685849959762557, + 2.4993257128081505, + 2.499121570936264, + 2.7730794627937905, + 2.7111237379771054, + 2.600780864586404, + 2.475049706780568, + 2.4520779734321407 + ], + "raw_time_brier": 0.003624378005042672, + "raw_timepoint_brier": [ + 0.002089274115860462, + 0.002784119453281164, + 0.0027777478098869324, + 0.0031161813531070948, + 0.0034524768125265837, + 0.003440410830080509, + 0.0034321134444326162, + 0.003769512753933668, + 0.004463857505470514, + 0.0044555324129760265, + 0.004449256230145693, + 0.0044432771392166615, + 0.004443154204636812 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.0011704645812175992, + 0.0013394187209961857, + 0.0013732157544910062, + 0.0015083350877250314, + 0.001609711357125453, + 0.0016434264325760745, + 0.0017107386057507183, + 0.0017952274360567384, + 0.001811995480069416 + ] + }, + "F20": { + "normalized_time_brier": 0.9822026746775236, + "normalized_timepoint_brier": [ + 0.00019633564818377636, + 0.35336444852873683, + 0.7094383472576737, + 0.7091194274835289, + 1.0641977423802018, + 1.0642062406986952, + 1.0642223060131073, + 1.0643707355484366, + 1.0645388392731547, + 1.418597879819572, + 1.4187309425324202, + 1.4188194181770086, + 1.4188321074470878 + ], + "raw_time_brier": 0.0009822026746775236, + "raw_timepoint_brier": [ + 1.9633564818377636e-07, + 0.00035336444852873683, + 0.0007094383472576737, + 0.0007091194274835289, + 0.0010641977423802018, + 0.0010642062406986952, + 0.0010642223060131073, + 0.0010643707355484366, + 0.0010645388392731547, + 0.001418597879819572, + 0.0014187309425324202, + 0.0014188194181770086, + 0.0014188321074470878 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "F22": { + "normalized_time_brier": 0.27561814242569826, + "normalized_timepoint_brier": [ + 0.0007186541779446998, + 0.0012570001217682147, + 0.0016312538946294808, + 0.3559064934961498, + 0.3560869372449815, + 0.35646933247335255, + 0.3568593820091337, + 0.3575291484594345, + 0.35824053338728845, + 0.35864164237864316, + 0.3591152490116656, + 0.36026956513524055, + 0.36031065974384546 + ], + "raw_time_brier": 0.0002756181424256983, + "raw_timepoint_brier": [ + 7.186541779446998e-07, + 1.2570001217682147e-06, + 1.6312538946294808e-06, + 0.0003559064934961498, + 0.00035608693724498153, + 0.00035646933247335255, + 0.0003568593820091337, + 0.0003575291484594345, + 0.00035824053338728845, + 0.00035864164237864316, + 0.0003591152490116656, + 0.00036026956513524055, + 0.00036031065974384546 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "F25": { + "normalized_time_brier": 0.95630631235858, + "normalized_timepoint_brier": [ + 0.35396203747950494, + 0.7084943354129791, + 0.7091108709573746, + 1.0638309177011251, + 1.064457930624485, + 1.0651140473783016, + 1.0652014752849936, + 1.0654875077307224, + 1.066154451109469, + 1.0668803006410599, + 1.0670145275071263, + 1.068119308911264, + 1.0681543499231339 + ], + "raw_time_brier": 0.00095630631235858, + "raw_timepoint_brier": [ + 0.00035396203747950494, + 0.0007084943354129791, + 0.0007091108709573746, + 0.0010638309177011251, + 0.001064457930624485, + 0.0010651140473783016, + 0.0010652014752849936, + 0.0010654875077307224, + 0.001066154451109469, + 0.0010668803006410599, + 0.0010670145275071263, + 0.001068119308911264, + 0.0010681543499231339 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "F29": { + "normalized_time_brier": 2.435551786150497, + "normalized_timepoint_brier": [ + 1.0686678579077125, + 1.780036836862564, + 2.136251190677285, + 2.49207834713161, + 2.4920885916799307, + 2.491989405825734, + 2.491862280294299, + 2.491892082616687, + 2.8448349330574274, + 2.84401117824018, + 2.8437096625566483, + 2.842375310137868, + 2.8423755429685116 + ], + "raw_time_brier": 0.002435551786150497, + "raw_timepoint_brier": [ + 0.0010686678579077125, + 0.001780036836862564, + 0.002136251190677285, + 0.00249207834713161, + 0.0024920885916799307, + 0.002491989405825734, + 0.002491862280294299, + 0.002491892082616687, + 0.0028448349330574274, + 0.00284401117824018, + 0.0028437096625566483, + 0.002842375310137868, + 0.0028423755429685116 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "F31": { + "normalized_time_brier": 1.9770186723029741, + "normalized_timepoint_brier": [ + 1.8256132025271654, + 2.5426060892641544, + 2.5414905976504087, + 2.5063092313150284, + 2.1523481077913984, + 2.09861887817097, + 1.9081531091454376, + 1.8255138038968153, + 1.6967841376416095, + 1.7662738797365867, + 1.658386015549348, + 1.6028431361045798, + 1.5763025511451603 + ], + "raw_time_brier": 0.0028689417522400618, + "raw_timepoint_brier": [ + 0.0018256132025271654, + 0.0025426060892641544, + 0.0025414905976504087, + 0.002894565463066101, + 0.002893319819122553, + 0.0028934108559042215, + 0.00289307814091444, + 0.002893636468797922, + 0.002893872791901231, + 0.003255149582400918, + 0.0032557907979935408, + 0.0032568005844950676, + 0.0032569083850830793 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001154911543595664, + 0.0013442620218583007, + 0.0013787214467573762, + 0.0015161666676790414, + 0.0015851079639173636, + 0.0017055043878023732, + 0.0018429472460332, + 0.0019632285652837257, + 0.0020318897783161314, + 0.0020661695831913638 + ] + }, + "F32": { + "normalized_time_brier": 2.195415942686533, + "normalized_timepoint_brier": [ + 2.091593722746181, + 2.21117784547987, + 2.239921064766492, + 2.18197197011466, + 2.1834079099191164, + 2.107320520301199, + 2.161368356845917, + 2.1657568968158465, + 2.198163163484591, + 2.2695571112557955, + 2.246133544149491, + 2.2492626961277957, + 2.234772452917969 + ], + "raw_time_brier": 0.022471138598540656, + "raw_timepoint_brier": [ + 0.007344154175370932, + 0.012985959649085999, + 0.016087157651782036, + 0.017897576093673706, + 0.020086904987692833, + 0.0211004838347435, + 0.023612409830093384, + 0.024887405335903168, + 0.02641402930021286, + 0.02892499975860119, + 0.02989601157605648, + 0.03143300116062164, + 0.03145470842719078 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.003511271857198129, + 0.005872869826202417, + 0.007182019895624802, + 0.00820247754728637, + 0.00919979491529686, + 0.01001294469990147, + 0.010924750404207338, + 0.011491319904137577, + 0.012016409763841456, + 0.012744777214527266, + 0.013309988470599483, + 0.013974802149493223, + 0.014075128045416881 + ] + }, + "F33": { + "normalized_time_brier": 1.4446751925673487, + "normalized_timepoint_brier": [ + 1.7728032209048112, + 1.675913158647569, + 1.3965401463086844, + 1.2900953561336184, + 1.1618762292883196, + 1.3692769632451152, + 1.5698017652318115, + 1.4726496930526196, + 1.4200074708811625, + 1.477257928424108, + 1.4365550169476873, + 1.3761251957340772, + 1.3618753585759464 + ], + "raw_time_brier": 0.003410654429059762, + "raw_timepoint_brier": [ + 0.00214545545168221, + 0.002505750162526965, + 0.002509201178327203, + 0.0025121201761066914, + 0.0025155653711408377, + 0.003216652199625969, + 0.003923999611288309, + 0.00392716471105814, + 0.003929106052964926, + 0.004285103175789118, + 0.004286677576601505, + 0.004290301352739334, + 0.004291410557925701 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0012102050731762563, + 0.0014951551335446636, + 0.0017967268502516655, + 0.001947236042795665, + 0.0021650889378137025, + 0.0023491611163914353, + 0.0024996784295938505, + 0.0026667337993447823, + 0.002766961536143738, + 0.002900714285121712, + 0.0029839981943118343, + 0.00311766790262911, + 0.0031511037562299694 + ] + }, + "F39": { + "normalized_time_brier": 2.4846185622680963, + "normalized_timepoint_brier": [ + 1.7802381189540029, + 2.1323503460735083, + 2.4855148512870073, + 2.8330383356660604, + 2.5922966616193066, + 2.706449317136999, + 2.6313468450395985, + 2.7345454297181355, + 2.5079107333022304, + 2.6657339415365366, + 2.494031264216941, + 2.3923744814981265, + 2.344210983436805 + ], + "raw_time_brier": 0.00316288923092473, + "raw_timepoint_brier": [ + 0.0017802381189540029, + 0.0021323503460735083, + 0.0024855148512870073, + 0.0028330383356660604, + 0.0028338669799268246, + 0.0031859443988651037, + 0.003185993991792202, + 0.0035403945948928595, + 0.003541588317602873, + 0.0038988052401691675, + 0.0038988806772977114, + 0.003900446929037571, + 0.0039004972204566 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010931877596743185, + 0.0011771675821497872, + 0.0012107845067244477, + 0.0012946921840891804, + 0.001412166817014086, + 0.001462563528722557, + 0.001563284604021135, + 0.0016303663825218014, + 0.001663884884089295 + ] + }, + "F41": { + "normalized_time_brier": 1.0596897062696462, + "normalized_timepoint_brier": [ + 0.8079979403741588, + 1.0875189795469187, + 1.0911714803892305, + 1.103217636870066, + 1.1522395460558825, + 1.120295127018873, + 1.133279274170604, + 1.1009060292109851, + 1.0909907760906605, + 1.0616202074074317, + 1.0258382405206576, + 1.0033502574631883, + 0.997540686386746 + ], + "raw_time_brier": 0.026149071144083373, + "raw_timepoint_brier": [ + 0.007004170212894678, + 0.014447652734816074, + 0.018264124169945717, + 0.02149965986609459, + 0.025583356618881226, + 0.027582935988903046, + 0.03012467920780182, + 0.03094879724085331, + 0.03221520781517029, + 0.03263028711080551, + 0.03265341371297836, + 0.033488959074020386, + 0.03349468111991882 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.008668549587702246, + 0.013284966061774154, + 0.016738087915779052, + 0.019488140098168828, + 0.022203157934001735, + 0.024621133595664, + 0.026581867236430943, + 0.028112115311998236, + 0.02952839613420639, + 0.030736309353503632, + 0.03183095777011133, + 0.03337713707144691, + 0.03357725812792858 + ] + }, + "F43": { + "normalized_time_brier": 1.7018948273744714, + "normalized_timepoint_brier": [ + 1.8715617001800477, + 1.7029965621955345, + 1.9821432708176006, + 2.0219645301030735, + 1.7913682214537832, + 1.6938084459295066, + 1.5833593953429133, + 1.6415938289084844, + 1.5361739789972844, + 1.6368861393305982, + 1.5769657874868193, + 1.515705577706378, + 1.5701053174161035 + ], + "raw_time_brier": 0.005703618535055564, + "raw_timepoint_brier": [ + 0.0021531605161726475, + 0.0032148808240890503, + 0.004658587276935577, + 0.005374729633331299, + 0.005373313557356596, + 0.005715727806091309, + 0.005720735993236303, + 0.006434896029531956, + 0.006440011318773031, + 0.007168251555413008, + 0.007173217833042145, + 0.007177611812949181, + 0.00754191679880023 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0011504619462802158, + 0.0018877788102780236, + 0.0023502777753365875, + 0.0026581720664789863, + 0.0029995583783416057, + 0.0033744830000270215, + 0.003613036945410202, + 0.00391990754120378, + 0.004192240857364774, + 0.004379199861967462, + 0.004548746643688426, + 0.004735492115698756, + 0.004803446440912536 + ] + }, + "F60": { + "normalized_time_brier": 1.2832810834747859, + "normalized_timepoint_brier": [ + 0.7073984015733004, + 1.4075568178668618, + 1.760807354003191, + 1.6729421020590471, + 1.485388131234528, + 1.3542818283736653, + 1.2743263482600462, + 1.2035087086191103, + 1.3059933221800253, + 1.2278749839932783, + 1.1593234052777077, + 1.0615794299513395, + 1.0616732517801157 + ], + "raw_time_brier": 0.0017727482705735243, + "raw_timepoint_brier": [ + 0.0007073984015733004, + 0.0014075568178668618, + 0.001760807354003191, + 0.001761134946718812, + 0.001761849969625473, + 0.0017640169244259596, + 0.0017656347481533885, + 0.001767625566571951, + 0.0020702569745481014, + 0.0020688383374363184, + 0.002069080714136362, + 0.0020706718787550926, + 0.0020708548836410046 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.0010527172127183706, + 0.0011861209421144179, + 0.0013025478799670069, + 0.0013855436251193976, + 0.0014687268599826758, + 0.0015851972130242835, + 0.0016848933029876302, + 0.001784731253347489, + 0.0019505576505471735, + 0.0019505576505471774 + ] + }, + "F90": { + "normalized_time_brier": 2.367802009058113, + "normalized_timepoint_brier": [ + 1.0798181174322963, + 1.7957348609343171, + 1.7937206430360675, + 2.1493106614798307, + 2.5077571626752615, + 2.507656579837203, + 2.5054982397705317, + 2.504815347492695, + 2.504587173461914, + 2.859459025785327, + 2.8577728662639856, + 2.8576625045388937, + 2.8576329350471497 + ], + "raw_time_brier": 0.002367802009058113, + "raw_timepoint_brier": [ + 0.0010798181174322963, + 0.0017957348609343171, + 0.0017937206430360675, + 0.0021493106614798307, + 0.0025077571626752615, + 0.002507656579837203, + 0.0025054982397705317, + 0.002504815347492695, + 0.002504587173461914, + 0.002859459025785327, + 0.0028577728662639856, + 0.0028576625045388937, + 0.0028576329350471497 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "G25": { + "normalized_time_brier": 0.7180362585163699, + "normalized_timepoint_brier": [ + 0.35912985913455486, + 0.8781485628472115, + 0.8658879645297397, + 0.7469747306558775, + 0.6674316249734301, + 0.59973200945898, + 0.690532497084177, + 0.7607803854185625, + 0.7124589096636023, + 0.6871287186796953, + 0.6476011398419643, + 0.8156786970232448, + 0.9029862614017663 + ], + "raw_time_brier": 0.0018432435687058247, + "raw_timepoint_brier": [ + 0.00035912985913455486, + 0.0010812667896971107, + 0.0014451862080022693, + 0.001447766786441207, + 0.0014506569132208824, + 0.00145467568654567, + 0.00181413849350065, + 0.002177331829443574, + 0.002182317664846778, + 0.002185429912060499, + 0.002189932856708765, + 0.0029088545124977827, + 0.0032654788810759783 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0012313028062032364, + 0.001669022168228362, + 0.0019381737119407005, + 0.0021734914243517183, + 0.002425542848476501, + 0.0026271587523555807, + 0.0028619715639036356, + 0.0030630786354783474, + 0.0031805247730872918, + 0.003381607477162841, + 0.0035661768820411987, + 0.0036163107022323415 + ] + }, + "G31": { + "normalized_time_brier": 0.997340109273755, + "normalized_timepoint_brier": [ + 0.0031134673008637037, + 0.3823394945356995, + 0.39287496620391027, + 0.3552815420012907, + 0.6215995392211111, + 1.0420571864985304, + 1.3538357101371186, + 1.3972846458098978, + 1.5383857205131295, + 1.4499633646518189, + 1.5446233900496544, + 1.4516171512020546, + 1.432445242433737 + ], + "raw_time_brier": 0.0018880903302698033, + "raw_timepoint_brier": [ + 3.1134673008637037e-06, + 0.0003823394945356995, + 0.0004006246745120734, + 0.00042154788388870656, + 0.0007893606671132147, + 0.001514208153821528, + 0.002238078974187374, + 0.0026124422438442707, + 0.002978699980303645, + 0.0030003131832927465, + 0.0033757861237972975, + 0.003413129597902298, + 0.0034155298490077257 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0010197256353160992, + 0.0011865178289706228, + 0.0012698861844433072, + 0.0014530950637262972, + 0.0016531392675117856, + 0.0018696564452191772, + 0.0019362504088442124, + 0.002069233786477919, + 0.0021855075777978327, + 0.0023512601756433883, + 0.002384405175031131 + ] + }, + "G40": { + "normalized_time_brier": 3.505717825951367, + "normalized_timepoint_brier": [ + 2.183422213420272, + 2.9282725881785154, + 3.6637593439803555, + 4.223566122531867, + 3.975363080614102, + 3.9530463570917544, + 3.769538900774767, + 3.4500835760699875, + 3.7321385883594416, + 3.5534113468375295, + 3.4583210229075667, + 3.2847324198451577, + 3.3986761767564544 + ], + "raw_time_brier": 0.006766336898391063, + "raw_timepoint_brier": [ + 0.002183422213420272, + 0.0029282725881785154, + 0.003979857079684734, + 0.006114599760621786, + 0.006507302168756723, + 0.007218646816909313, + 0.0075962236151099205, + 0.007604588288813829, + 0.008676026947796345, + 0.008687412366271019, + 0.008692198432981968, + 0.00870673917233944, + 0.009067090228199959 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001086276882848142, + 0.0014477338777772741, + 0.001636907632535415, + 0.0018260971829887804, + 0.0020151598949008434, + 0.0022041750934846237, + 0.0023246797358642884, + 0.0024448090914108932, + 0.0025134157226601376, + 0.0026506692355628392, + 0.0026678299892792926 + ] + }, + "G43": { + "normalized_time_brier": 0.9453586657091958, + "normalized_timepoint_brier": [ + 0.7397934059016141, + 1.0898812012920236, + 1.0256748986179798, + 1.136825721380431, + 1.0050552012231828, + 0.8868884573367837, + 0.9710802811508769, + 1.0258694690805528, + 0.9608777736394031, + 0.9088086611159177, + 0.8718274593608528, + 0.8378290777066933, + 0.8292510464132334 + ], + "raw_time_brier": 0.0043179073209802694, + "raw_timepoint_brier": [ + 0.0010992841562256217, + 0.0025577314663678408, + 0.0029177076648920774, + 0.0040152668952941895, + 0.0040148524567484856, + 0.004012587480247021, + 0.004741260316222906, + 0.005464107263833284, + 0.005462202709168196, + 0.005461212247610092, + 0.0054620252922177315, + 0.00546224182471633, + 0.005462315399199724 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0014859339748857082, + 0.0023467984064095442, + 0.0028446710247306143, + 0.0035319986342484486, + 0.003994658653437431, + 0.004524342883316268, + 0.0048824596773850626, + 0.005326318238840418, + 0.005684596791618622, + 0.0060091991650963366, + 0.006265030119861111, + 0.006519518085559389, + 0.006587046736722158 + ] + }, + "G44": { + "normalized_time_brier": 1.7051790088701706, + "normalized_timepoint_brier": [ + 0.3572247223928571, + 1.0695458622649312, + 1.070418511517346, + 1.0720111895352602, + 1.4291431289166212, + 1.431947574019432, + 1.7872252501547337, + 1.787592307664454, + 2.1448349580168724, + 2.5023752823472023, + 2.502882620319724, + 2.506016520783305, + 2.5061091873794794 + ], + "raw_time_brier": 0.0017051790088701707, + "raw_timepoint_brier": [ + 0.0003572247223928571, + 0.0010695458622649312, + 0.001070418511517346, + 0.0010720111895352602, + 0.0014291431289166212, + 0.001431947574019432, + 0.0017872252501547337, + 0.001787592307664454, + 0.0021448349580168724, + 0.0025023752823472023, + 0.002502882620319724, + 0.002506016520783305, + 0.0025061091873794794 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "G47": { + "normalized_time_brier": 1.5289723818422838, + "normalized_timepoint_brier": [ + 1.6711506955422881, + 1.595721529818052, + 1.5893834437658314, + 1.705086249831031, + 1.6677180392826816, + 1.5888311319669768, + 1.55817042575479, + 1.479018813214788, + 1.4606572875158432, + 1.4166847535929796, + 1.4138667493008916, + 1.3711094587159316, + 1.3592423856476048 + ], + "raw_time_brier": 0.02801688860815305, + "raw_timepoint_brier": [ + 0.009779727086424828, + 0.01514647901058197, + 0.019582277163863182, + 0.024498675018548965, + 0.027236299589276314, + 0.028819488361477852, + 0.031069280579686165, + 0.03186682611703873, + 0.033518437296152115, + 0.03436523675918579, + 0.03591005876660347, + 0.03621140494942665, + 0.03621536120772362 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.005852091683001279, + 0.00949193122205289, + 0.012320675190541558, + 0.014367997525624707, + 0.016331477472649503, + 0.01813879888279836, + 0.01993959073163384, + 0.02154592344080678, + 0.022947502869175636, + 0.02425750448152214, + 0.025398474633030133, + 0.02641029475745815, + 0.026643784500929153 + ] + }, + "G51": { + "normalized_time_brier": 0.000655787381731443, + "normalized_timepoint_brier": [ + 4.696595823361349e-05, + 0.00013917798469265108, + 0.00020042672588260757, + 0.00029814054869348183, + 0.000502646059885592, + 0.0005384535484154185, + 0.0006102524707785051, + 0.0007368490173575992, + 0.0008499346222379245, + 0.0010208723324467428, + 0.0011063769989050343, + 0.0012340705097813043, + 0.0012410691851982847 + ], + "raw_time_brier": 6.55787381731443e-07, + "raw_timepoint_brier": [ + 4.696595823361349e-08, + 1.3917798469265108e-07, + 2.0042672588260757e-07, + 2.9814054869348183e-07, + 5.02646059885592e-07, + 5.384535484154185e-07, + 6.102524707785051e-07, + 7.368490173575992e-07, + 8.499346222379245e-07, + 1.0208723324467428e-06, + 1.1063769989050343e-06, + 1.2340705097813043e-06, + 1.2410691851982847e-06 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "G62": { + "normalized_time_brier": 2.414318948287051, + "normalized_timepoint_brier": [ + 2.5072440039366484, + 2.4614482796118233, + 2.5469428560878526, + 2.4664641192388608, + 2.504273279112337, + 2.442694964830374, + 2.6181533197532567, + 2.496235846802532, + 2.3510268290091263, + 2.3237508223339916, + 2.259231792952798, + 2.2110143581175206, + 2.197665855944545 + ], + "raw_time_brier": 0.009389152195161352, + "raw_timepoint_brier": [ + 0.0025072440039366484, + 0.004540088586509228, + 0.006869001779705286, + 0.00784690584987402, + 0.009219995699822903, + 0.009562949649989605, + 0.010990054346621037, + 0.010976750403642654, + 0.011315706185996532, + 0.011647237464785576, + 0.011999179609119892, + 0.012292635627090931, + 0.012291229330003262 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001844478563338008, + 0.002696959518854769, + 0.003181439287385838, + 0.0036817050985310257, + 0.003914917657618243, + 0.004197635892330696, + 0.004397321037474463, + 0.004813091048716657, + 0.005012257490279018, + 0.005311176855136701, + 0.005559726729932682, + 0.005592856301041523 + ] + }, + "G81": { + "normalized_time_brier": 3.2849017869298387, + "normalized_timepoint_brier": [ + 2.8581449296325445, + 3.2102058175951242, + 3.564937971532345, + 3.5635381937026978, + 3.638210087118771, + 3.58174068214977, + 3.3906345706578263, + 3.6979407692240738, + 3.362519182918844, + 3.052262777809991, + 2.876391901250241, + 2.967358686026234, + 2.939837660469436 + ], + "raw_time_brier": 0.004325819667428732, + "raw_timepoint_brier": [ + 0.0028581449296325445, + 0.0032102058175951242, + 0.003564937971532345, + 0.0035635381937026978, + 0.0039160288870334625, + 0.00427588913589716, + 0.004275428131222725, + 0.004973329603672028, + 0.00497411610558629, + 0.004975832998752594, + 0.004978655371814966, + 0.005334921646863222, + 0.005334626883268356 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010763613956484592, + 0.0011938019849417909, + 0.0012609522029362302, + 0.0013448916340311108, + 0.0014792825958745892, + 0.0016302112108193946, + 0.0017308682344888274, + 0.0017978688157876633, + 0.0018145991375647997 + ] + }, + "G83": { + "normalized_time_brier": 0.9847517917828205, + "normalized_timepoint_brier": [ + 0.3548358508851379, + 0.7098904461599886, + 1.0620765388011932, + 1.0631760815158486, + 1.0648054303601384, + 1.0653671342879534, + 1.0668477043509483, + 1.067175529897213, + 1.0680455015972257, + 1.0690678609535098, + 1.0698530822992325, + 1.070271129719913, + 1.0703610023483634 + ], + "raw_time_brier": 0.0009847517917828204, + "raw_timepoint_brier": [ + 0.0003548358508851379, + 0.0007098904461599886, + 0.0010620765388011932, + 0.0010631760815158486, + 0.0010648054303601384, + 0.0010653671342879534, + 0.0010668477043509483, + 0.001067175529897213, + 0.0010680455015972257, + 0.0010690678609535098, + 0.0010698530822992325, + 0.001070271129719913, + 0.0010703610023483634 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "G89": { + "normalized_time_brier": 0.7817964274129703, + "normalized_timepoint_brier": [ + 0.8409750600531574, + 0.75175310715145, + 0.759663395179818, + 0.7821118963984885, + 0.7586826736938457, + 0.7561741504111464, + 0.772332966654454, + 0.8041878714347442, + 0.7793092337813079, + 0.7738298896145605, + 0.7684429484976933, + 0.8057550035758498, + 0.8101353599220966 + ], + "raw_time_brier": 0.017808567087810773, + "raw_timepoint_brier": [ + 0.005879625678062439, + 0.008210837841033936, + 0.011217189021408558, + 0.014161670580506325, + 0.015492234379053116, + 0.017127178609371185, + 0.018920602276921272, + 0.02113099955022335, + 0.021811572834849358, + 0.022637074813246727, + 0.02342095412313938, + 0.025600209832191467, + 0.025901222601532936 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.006991438815903521, + 0.010922253280929585, + 0.01476599911563906, + 0.018106962246347048, + 0.02041991324729364, + 0.022649780609478396, + 0.024497986093848116, + 0.026276197765235786, + 0.02798834132763553, + 0.029253295998326073, + 0.03047845538686687, + 0.03177170444934332, + 0.031971475240907425 + ] + }, + "G90": { + "normalized_time_brier": 0.01861194254633329, + "normalized_timepoint_brier": [ + 0.0005657795441038616, + 0.0028289132387726568, + 0.0040667418943485245, + 0.006027206836733967, + 0.012538173905340955, + 0.015406785678351298, + 0.017456102796131745, + 0.020426970877451822, + 0.024649580154800788, + 0.02611340823932551, + 0.03190756251569837, + 0.03929002195945941, + 0.04067800546181388 + ], + "raw_time_brier": 1.8611942546333292e-05, + "raw_timepoint_brier": [ + 5.657795441038616e-07, + 2.8289132387726568e-06, + 4.0667418943485245e-06, + 6.027206836733967e-06, + 1.2538173905340955e-05, + 1.5406785678351298e-05, + 1.7456102796131745e-05, + 2.0426970877451822e-05, + 2.4649580154800788e-05, + 2.611340823932551e-05, + 3.190756251569837e-05, + 3.929002195945941e-05, + 4.067800546181388e-05 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "G92": { + "normalized_time_brier": 2.297042646223418, + "normalized_timepoint_brier": [ + 1.309990894021192, + 1.9967927373672978, + 2.3877427274840546, + 2.3807021309476064, + 2.366342547481226, + 2.377022803137788, + 2.513469830797057, + 2.4182457654913714, + 2.3727656393266687, + 2.4083713406978777, + 2.455187658354486, + 2.432908583019871, + 2.442011742777945 + ], + "raw_time_brier": 0.01158625880578676, + "raw_timepoint_brier": [ + 0.0014908305602148175, + 0.004403280094265938, + 0.006959061603993177, + 0.008866170421242714, + 0.010325673967599869, + 0.011450710706412792, + 0.01328798197209835, + 0.013715521432459354, + 0.014172584749758244, + 0.015229755081236362, + 0.01626504585146904, + 0.01705269142985344, + 0.017402056604623795 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0011380465062917453, + 0.0022051763369650024, + 0.002914493895800024, + 0.003724183007184378, + 0.004363558428423934, + 0.004817248993698035, + 0.0052867083619955535, + 0.005671682187220724, + 0.005973023426696311, + 0.006323673938431443, + 0.006624766867054955, + 0.007009178868811677, + 0.007126115038590208 + ] + }, + "G93": { + "normalized_time_brier": 1.4028850396038404, + "normalized_timepoint_brier": [ + 1.5352263915067093, + 1.3493445727695264, + 1.4864963374039946, + 1.459971015689447, + 1.4453858998699518, + 1.389926321627247, + 1.3868469996856263, + 1.3891678942378, + 1.3322479194789283, + 1.3039978740756712, + 1.3264782772380255, + 1.4195058431104888, + 1.4129101681565082 + ], + "raw_time_brier": 0.0138192072403259, + "raw_timepoint_brier": [ + 0.0033552858512848616, + 0.006328147370368242, + 0.009587584994733334, + 0.011391147039830685, + 0.012727435678243637, + 0.01346233393996954, + 0.01491355150938034, + 0.016009101644158363, + 0.016361452639102936, + 0.01702069863677025, + 0.01808483712375164, + 0.020202504470944405, + 0.02020561322569847 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0021855316387519243, + 0.004689793473122833, + 0.00644978716293174, + 0.007802310400286547, + 0.008805562361850067, + 0.009685645728479048, + 0.010753566552590861, + 0.011524238150452028, + 0.012281087025830945, + 0.013052704283613376, + 0.01363372279371784, + 0.014232068553290147, + 0.014300706216915196 + ] + }, + "G99": { + "normalized_time_brier": 0.1360693811284145, + "normalized_timepoint_brier": [ + 5.0961666886450985e-05, + 0.00017084464332128846, + 0.00036636339473261614, + 0.000574491764382401, + 0.0007186259836089448, + 0.000821911271486897, + 0.0009871598649624502, + 0.001063733520823007, + 0.3526661021169275, + 0.35275472328066826, + 0.3528775123413652, + 0.3529225941747427, + 0.35292693064548075 + ], + "raw_time_brier": 0.0001360693811284145, + "raw_timepoint_brier": [ + 5.0961666886450985e-08, + 1.7084464332128846e-07, + 3.6636339473261614e-07, + 5.74491764382401e-07, + 7.186259836089448e-07, + 8.21911271486897e-07, + 9.871598649624502e-07, + 1.063733520823007e-06, + 0.0003526661021169275, + 0.00035275472328066826, + 0.0003528775123413652, + 0.0003529225941747427, + 0.00035292693064548075 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "H10": { + "normalized_time_brier": 1.4155898940421292, + "normalized_timepoint_brier": [ + 0.0002213013345908621, + 0.351516529917717, + 1.0553495958447456, + 1.4076752122491598, + 1.407627947628498, + 1.4077102532610297, + 1.7602361040189862, + 1.7603002488613129, + 1.7604370368644595, + 1.736900894017347, + 1.9570556763537372, + 1.8988147277385747, + 1.8988230944575195 + ], + "raw_time_brier": 0.0014624791037505247, + "raw_timepoint_brier": [ + 2.213013345908621e-07, + 0.000351516529917717, + 0.0010553495958447456, + 0.0014076752122491598, + 0.001407627947628498, + 0.0014077102532610297, + 0.0017602361040189862, + 0.0017603002488613129, + 0.0017604370368644595, + 0.0017604136373847723, + 0.00211348501034081, + 0.0021136230789124966, + 0.0021136323921382427 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010135371819131498, + 0.0010799309574465055, + 0.0011131275990416145, + 0.0011131275990416015 + ] + }, + "H26": { + "normalized_time_brier": 0.004763854404709803, + "normalized_timepoint_brier": [ + 0.0002385338291333028, + 0.0012118746326450491, + 0.002063383817585418, + 0.0030544711883968177, + 0.004207610627028913, + 0.004659179503280874, + 0.0049658178627873, + 0.006190656202916223, + 0.0064716835529979415, + 0.006735111847528149, + 0.007156564744703886, + 0.007467557601249128, + 0.007507661850974438 + ], + "raw_time_brier": 7.988543789959014e-06, + "raw_timepoint_brier": [ + 2.385338291333028e-07, + 1.2118746326450491e-06, + 2.063383817585418e-06, + 3.263242206230643e-06, + 5.4058159548731055e-06, + 6.451940407714574e-06, + 7.290092980838381e-06, + 9.912883797369432e-06, + 1.1116036148450803e-05, + 1.2240341675351374e-05, + 1.3957604096503928e-05, + 1.5184406038315501e-05, + 1.5514913684455678e-05 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.00106834931644695, + 0.0012847709624429465, + 0.0013847803895881848, + 0.0014680548466081823, + 0.00160126543494691, + 0.0017176421030817262, + 0.0018173924876754197, + 0.0019503217806885705, + 0.002033383182176666, + 0.002066544017621406 + ] + }, + "H35": { + "normalized_time_brier": 1.2216905372211389, + "normalized_timepoint_brier": [ + 1.0685368906706572, + 1.0685025481507182, + 1.425047405064106, + 1.4251945540308952, + 1.3512223911252732, + 1.1511289758856935, + 1.2818628466616675, + 1.209167395423746, + 1.1323313851970078, + 1.2903210302237367, + 1.205641546682928, + 1.1414933639596458, + 1.1315266507987305 + ], + "raw_time_brier": 0.0016712788223790436, + "raw_timepoint_brier": [ + 0.0010685368906706572, + 0.0010685025481507182, + 0.001425047405064106, + 0.0014251945540308952, + 0.001425510854460299, + 0.00142589898314327, + 0.0017803736263886094, + 0.0017805305542424321, + 0.001780679915100336, + 0.002136455848813057, + 0.0021365315187722445, + 0.0021366386208683252, + 0.0021367233712226152 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010549787095173577, + 0.0012386961087884742, + 0.0013888955679035434, + 0.001472526104310359, + 0.001572578432762001, + 0.0016557552723469164, + 0.0017721117231323579, + 0.0018717924153818033, + 0.0018883544366492197 + ] + }, + "H40": { + "normalized_time_brier": 0.7932536041466858, + "normalized_timepoint_brier": [ + 1.0835815919563174, + 0.8514373420780877, + 0.8342757536125709, + 0.7079327551093926, + 0.6000648644344471, + 0.5638463058880769, + 0.6434765349300776, + 0.6003525179092762, + 0.8321536228561046, + 0.7773297613914961, + 0.9655608983622622, + 0.929345354363134, + 0.9229395510156718 + ], + "raw_time_brier": 0.0026093399008879294, + "raw_timepoint_brier": [ + 0.0010835815919563174, + 0.0014525881269946694, + 0.0018199431942775846, + 0.001832695328630507, + 0.00184777588583529, + 0.0018605003133416176, + 0.002177935093641281, + 0.0021843714639544487, + 0.0032804221846163273, + 0.003287176601588726, + 0.004358835984021425, + 0.004367375280708075, + 0.004368217661976814 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0017060423065887195, + 0.0021814648051281466, + 0.002588798604674411, + 0.003079293581997662, + 0.003299658601844109, + 0.003384637940026738, + 0.0036384813901697423, + 0.003942087247493214, + 0.0042288057975605605, + 0.004514304578214251, + 0.004699410461572673, + 0.0047329401553652135 + ] + }, + "H53": { + "normalized_time_brier": 1.585908659280226, + "normalized_timepoint_brier": [ + 1.073541585355997, + 1.0738008422777057, + 1.9786829197359241, + 1.7881813709696552, + 1.8579705425985387, + 1.5962662658182718, + 1.6373426765319916, + 1.5893190905893029, + 1.5532818920206248, + 1.5803325891529212, + 1.603615452508621, + 1.5914494929454532, + 1.693027850137929 + ], + "raw_time_brier": 0.003419205555334114, + "raw_timepoint_brier": [ + 0.001073541585355997, + 0.0010738008422777057, + 0.002500243252143264, + 0.0028608182910829782, + 0.003222133032977581, + 0.00322426063939929, + 0.003582184901461005, + 0.0035839774645864964, + 0.003946217242628336, + 0.00430654501542449, + 0.004665783606469631, + 0.005030341912060976, + 0.005379824433475733 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0012635896470349819, + 0.0015998479446923649, + 0.001734221807667165, + 0.0020198764507163734, + 0.00218780402710099, + 0.0022550395863285043, + 0.0025405673386784946, + 0.0027250877726522453, + 0.0029095401888094164, + 0.0031608555184185106, + 0.003177634929654255 + ] + }, + "H54": { + "normalized_time_brier": 0.7055175366038843, + "normalized_timepoint_brier": [ + 0.3568808315321803, + 0.7157239015214145, + 0.7191566983237863, + 0.7232071366161108, + 0.7258265977725387, + 0.7002608197924133, + 0.6418361272616129, + 0.5788299112301344, + 0.5525848644912651, + 0.7456660917815872, + 0.9460539753582965, + 0.8828086194572282, + 0.8828924007119286 + ], + "raw_time_brier": 0.0008980368684905653, + "raw_timepoint_brier": [ + 0.0003568808315321803, + 0.0007157239015214145, + 0.0007191566983237863, + 0.0007232071366161108, + 0.0007258265977725387, + 0.0007286819745786488, + 0.0007324085454456508, + 0.0007380935130640864, + 0.0007417105371132493, + 0.0011008528526872396, + 0.0014600420836359262, + 0.0014658777508884668, + 0.00146601686719805 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001040586527166636, + 0.0011411145529785995, + 0.0012751474979851743, + 0.0013422563388450785, + 0.0014763348700180538, + 0.0015432968114562052, + 0.0016604705919044192, + 0.0016604705919044194 + ] + }, + "H91": { + "normalized_time_brier": 1.765847643741637, + "normalized_timepoint_brier": [ + 0.35864944220520556, + 0.7152055623009801, + 1.7864403780549765, + 1.7865955596789718, + 1.7878536600619555, + 1.7893781187012792, + 2.367567354502807, + 2.296519864417899, + 2.2285932193637317, + 2.0775742401912476, + 1.9692424726762738, + 1.8961405676668162, + 1.8962589288191414 + ], + "raw_time_brier": 0.0019838914225916737, + "raw_timepoint_brier": [ + 0.00035864944220520556, + 0.0007152055623009801, + 0.0017864403780549765, + 0.0017865955596789718, + 0.0017878536600619555, + 0.0017893781187012792, + 0.0025038772728294134, + 0.002505650045350194, + 0.0025063108187168837, + 0.0025105648674070835, + 0.002511950908228755, + 0.0025139774661511183, + 0.002514134394004941 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010575738291319834, + 0.0010910639547136265, + 0.0011246156530227804, + 0.0012084116268095322, + 0.0012755924895398586, + 0.0013258391856699448, + 0.0013258391856699493 + ] + }, + "I07": { + "normalized_time_brier": 1.642659597918667, + "normalized_timepoint_brier": [ + 0.0005524535140466469, + 0.7101554656401277, + 0.7109179859980941, + 1.418081927113235, + 1.7715537687763572, + 1.7733325948938727, + 2.1298034116625786, + 2.131473273038864, + 2.136060269549489, + 2.137682167813182, + 2.1412442438304424, + 2.146767219528556, + 2.146949991583824 + ], + "raw_time_brier": 0.001642659597918667, + "raw_timepoint_brier": [ + 5.524535140466469e-07, + 0.0007101554656401277, + 0.0007109179859980941, + 0.001418081927113235, + 0.0017715537687763572, + 0.0017733325948938727, + 0.0021298034116625786, + 0.002131473273038864, + 0.002136060269549489, + 0.002137682167813182, + 0.0021412442438304424, + 0.002146767219528556, + 0.002146949991583824 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "I08": { + "normalized_time_brier": 1.8569810140742538, + "normalized_timepoint_brier": [ + 0.4002196073997766, + 1.5010199276730418, + 1.798715212394757, + 2.3814715902396393, + 2.2047554651778123, + 1.9207673139266104, + 1.816816384612339, + 2.169821655251348, + 2.0719224401455443, + 1.9916681300065755, + 2.0218957200047702, + 1.9150567780939303, + 1.946622958039148 + ], + "raw_time_brier": 0.0034976435059574074, + "raw_timepoint_brier": [ + 0.0004002196073997766, + 0.0015010199276730418, + 0.0019375855335965753, + 0.003005248261615634, + 0.0030410492327064276, + 0.003100487170740962, + 0.0034811084624379873, + 0.004557341802865267, + 0.0045950040221214294, + 0.004650144837796688, + 0.004990929737687111, + 0.005046722013503313, + 0.005162504967302084 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001077205285330817, + 0.001261929083652527, + 0.001379313615835019, + 0.0016141919681060476, + 0.0019160485847229765, + 0.0021003301316657535, + 0.0022177490494280513, + 0.0023347990399290746, + 0.0024684407253581487, + 0.002635285841773502, + 0.00265203127600135 + ] + }, + "I10": { + "normalized_time_brier": 1.9425492488177478, + "normalized_timepoint_brier": [ + 2.3233855471610583, + 2.2810276275621653, + 2.028168012174362, + 1.924707475180848, + 1.9557284958384373, + 1.924247458865623, + 1.8446865150945029, + 1.8572930361033515, + 1.876444663784372, + 1.8483532157619948, + 1.771877954187165, + 1.813601926888016, + 1.8036183060288207 + ], + "raw_time_brier": 0.021284601866052702, + "raw_timepoint_brier": [ + 0.00926443375647068, + 0.014434631913900375, + 0.01565522328019142, + 0.01758606545627117, + 0.020101753994822502, + 0.021447770297527313, + 0.022104470059275627, + 0.02341083250939846, + 0.024654464796185493, + 0.025987999513745308, + 0.026014620438218117, + 0.028016142547130585, + 0.028021415695548058 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.003987471544613368, + 0.006328126735285229, + 0.007718898624876616, + 0.009137006887043322, + 0.010278397046214081, + 0.011146056188724886, + 0.011982778579667354, + 0.012604813593936144, + 0.013138924516144759, + 0.014060082938764276, + 0.01468194825537638, + 0.015447790461495518, + 0.015536222715129337 + ] + }, + "I11": { + "normalized_time_brier": 3.239071308767999, + "normalized_timepoint_brier": [ + 2.5793635709763585, + 3.2604306969724157, + 3.2671854784731895, + 3.1965853351963602, + 2.9746667873796846, + 3.1221470847404276, + 3.2540941423696923, + 3.3996774771258704, + 3.3098087831278105, + 3.391644250990128, + 3.4082493138953014, + 3.4867159247407753, + 3.45735816799597 + ], + "raw_time_brier": 0.013254670408339454, + "raw_timepoint_brier": [ + 0.0029782953206449747, + 0.006302380468696356, + 0.008135844953358173, + 0.00995614193379879, + 0.010317833162844181, + 0.011775236576795578, + 0.013914045877754688, + 0.015562350861728191, + 0.016259081661701202, + 0.017343012616038322, + 0.01896914280951023, + 0.020398331806063652, + 0.02039901725947857 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0011546628610861593, + 0.0019329901643205135, + 0.002490169293100614, + 0.0031146179093595834, + 0.00346856770869887, + 0.0037715188481501536, + 0.004275858432178677, + 0.004577596247419563, + 0.004912393049587647, + 0.005113452748169372, + 0.00556565587270091, + 0.005850299320722606, + 0.0059001747196191405 + ] + }, + "I12": { + "normalized_time_brier": 2.285250487742906, + "normalized_timepoint_brier": [ + 3.1185129191726446, + 2.1608476345112217, + 1.8946378550768976, + 2.3472411043644117, + 2.15815839168992, + 2.1988780914445964, + 2.166212930700825, + 2.170670119626519, + 2.333396609727063, + 2.3176861295745868, + 2.3012528700585877, + 2.2742277717938544, + 2.2665339129166484 + ], + "raw_time_brier": 0.00799227267718659, + "raw_timepoint_brier": [ + 0.0031185129191726446, + 0.003886745311319828, + 0.004290844779461622, + 0.006235165987163782, + 0.006658052559942007, + 0.007396999280899763, + 0.008132435381412506, + 0.008916051127016544, + 0.010017743334174156, + 0.010809659026563168, + 0.011201492510735989, + 0.011616378091275692, + 0.011619464494287968 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0017987132684618924, + 0.0022647308391753156, + 0.002656380708215378, + 0.0030850620536375458, + 0.0033639878944085335, + 0.003754217910047031, + 0.0041075108771251815, + 0.004293202146782038, + 0.0046639874522385345, + 0.004867562646625101, + 0.005107834068050704, + 0.005126534585725951 + ] + }, + "I13": { + "normalized_time_brier": 2.2017473235092306, + "normalized_timepoint_brier": [ + 1.4761126367375255, + 1.7876493440121612, + 2.0052232217986456, + 2.3936986291329636, + 2.4250487386117126, + 2.363423180163968, + 2.3903853962335226, + 2.346083551925514, + 2.349353206103547, + 2.3294468234688015, + 2.269219442874065, + 2.24727365037948, + 2.239797384178088 + ], + "raw_time_brier": 0.007123433796760554, + "raw_timepoint_brier": [ + 0.0014761126367375255, + 0.002560738008469343, + 0.004017549566924572, + 0.005799246486276388, + 0.0064840675331652164, + 0.0071879224851727486, + 0.007908548228442669, + 0.008311723358929157, + 0.008990003727376461, + 0.009301003068685532, + 0.009928219020366669, + 0.010318610817193985, + 0.010320894420146942 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0014324610232127955, + 0.0020035423105268595, + 0.0024227137099447514, + 0.002673788542855103, + 0.003041318433998803, + 0.003308482490272905, + 0.0035428079072918916, + 0.0038265866979987125, + 0.003992794759244737, + 0.004375169202583663, + 0.004591612959753059, + 0.004607958957829696 + ] + }, + "I16": { + "normalized_time_brier": 2.6227771713276313, + "normalized_timepoint_brier": [ + 0.417816627305001, + 0.8349846466444433, + 1.660433947108686, + 2.9039005748927593, + 3.3014831467797054, + 3.143955363833864, + 3.0007482053489816, + 3.22897827166723, + 3.166968500457464, + 3.11751272641339, + 3.0810112268706153, + 3.1418147688762295, + 3.096495221060835 + ], + "raw_time_brier": 0.0033734825511391345, + "raw_timepoint_brier": [ + 0.000417816627305001, + 0.0008349846466444433, + 0.001660433947108686, + 0.0029039005748927593, + 0.003318115370348096, + 0.003317191731184721, + 0.0033168764784932137, + 0.0037312384229153395, + 0.004136516246944666, + 0.004541089758276939, + 0.004951021168380976, + 0.005363099742680788, + 0.0053629884496331215 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001005037803565532, + 0.001055101408036406, + 0.0011053498166159752, + 0.0011555477023971349, + 0.0013061437921934342, + 0.001456638723493307, + 0.001606946811878297, + 0.001707006980745422, + 0.001731954376404884 + ] + }, + "I21": { + "normalized_time_brier": 1.5789787745575212, + "normalized_timepoint_brier": [ + 1.1021076934412122, + 1.1013061810694718, + 1.393198259957362, + 1.2769723384837706, + 1.3744651611530898, + 1.5486184504521954, + 1.8158639944370454, + 1.8421706852027306, + 1.742932923741024, + 1.7698765556495912, + 1.8529208215654647, + 1.8582991209309911, + 1.8479918831638273 + ], + "raw_time_brier": 0.005646365166355211, + "raw_timepoint_brier": [ + 0.0011021076934412122, + 0.0018740978557616472, + 0.003022035351023078, + 0.0034549273550510406, + 0.004217192996293306, + 0.005311460234224796, + 0.006789558567106724, + 0.007140574976801872, + 0.007175663486123085, + 0.007560034282505512, + 0.008328917436301708, + 0.008705605752766132, + 0.008720571175217628 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0017017046557767633, + 0.0021691351747134434, + 0.00270556162489259, + 0.003068242917670861, + 0.003429805600387787, + 0.0037390237308007335, + 0.003876174468608512, + 0.0041170049566344015, + 0.004271503714975636, + 0.004495020693471895, + 0.004684717145216483, + 0.0047189445227907075 + ] + }, + "I24": { + "normalized_time_brier": 1.6284197517641177, + "normalized_timepoint_brier": [ + 0.35499822115525603, + 0.7101072114892304, + 1.0616714134812355, + 1.0610262397676706, + 1.7622268060222268, + 2.040740865548366, + 1.8059745086440884, + 2.016236679537123, + 2.156377400085225, + 1.9783736185986356, + 1.8889817331150236, + 2.166391389603757, + 2.1663506858856945 + ], + "raw_time_brier": 0.002082270561144329, + "raw_timepoint_brier": [ + 0.00035499822115525603, + 0.0007101072114892304, + 0.0010616714134812355, + 0.0010610262397676706, + 0.0017622268060222268, + 0.002113664522767067, + 0.00211158930324018, + 0.0024584592320024967, + 0.0028085620142519474, + 0.002807286102324724, + 0.0028060947079211473, + 0.0035069487057626247, + 0.0035068828146904707 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010357339133301013, + 0.001169224312487968, + 0.0012193306752890224, + 0.0013024445600946044, + 0.0014189868263170845, + 0.0014855065344087576, + 0.0016187973801003988, + 0.0016187973801004018 + ] + }, + "I25": { + "normalized_time_brier": 2.044048613568485, + "normalized_timepoint_brier": [ + 2.9072037110342523, + 2.3337436216399317, + 2.261742765500072, + 2.1218414184705083, + 2.010734863732495, + 1.9115963537154548, + 1.9421885346815453, + 1.961833641084411, + 1.898613215420543, + 1.8058089421546066, + 1.8352600352373134, + 1.7960302286203236, + 1.7860346450988427 + ], + "raw_time_brier": 0.014373136827578912, + "raw_timepoint_brier": [ + 0.005687100812792778, + 0.00828064139932394, + 0.010402648709714413, + 0.012112559750676155, + 0.012879409827291965, + 0.013692212291061878, + 0.01533292792737484, + 0.01660550944507122, + 0.017031554132699966, + 0.017040127888321877, + 0.018655503168702126, + 0.019564924761652946, + 0.019565658643841743 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0019562099453875434, + 0.003548222402212758, + 0.0045993951515588835, + 0.005708513202370835, + 0.006405324769365227, + 0.00716271103177674, + 0.007894665040790663, + 0.008464280098638977, + 0.008970523324271434, + 0.009436285030237138, + 0.01016504626620381, + 0.010893427320921181, + 0.010954803535045056 + ] + }, + "I26": { + "normalized_time_brier": 2.0733789387731627, + "normalized_timepoint_brier": [ + 1.0748326312750578, + 1.5014612224891888, + 2.221282362053563, + 2.304250080567297, + 2.1525837154988356, + 2.1784299482628735, + 2.2779664112668754, + 2.2398764730311664, + 2.1173259275610894, + 2.1647882072621023, + 2.2986780349839884, + 2.2112523483419335, + 2.2111988414571453 + ], + "raw_time_brier": 0.005052563519431994, + "raw_timepoint_brier": [ + 0.0010748326312750578, + 0.002160134958103299, + 0.003908257465809584, + 0.004559626802802086, + 0.004550226964056492, + 0.004898535553365946, + 0.00562205258756876, + 0.005905665457248688, + 0.005903666839003563, + 0.006255059503018856, + 0.006951157469302416, + 0.00694713881239295, + 0.006946970708668232 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0014386884760980586, + 0.0017594600004820736, + 0.001978789907074463, + 0.002113844368186178, + 0.00224865415446209, + 0.0024680138213460726, + 0.002636603191450422, + 0.0027882655013835747, + 0.0028894556437601302, + 0.0030239804633408933, + 0.0031417213949380914, + 0.0031417213949380906 + ] + }, + "I27": { + "normalized_time_brier": 1.9780971354850327, + "normalized_timepoint_brier": [ + 1.6345756997565577, + 2.0770191818844497, + 1.8757317680418815, + 1.9366157443016392, + 1.9378424800787086, + 2.0379632893651682, + 2.1576008518630445, + 2.0475685774960923, + 1.9190768476395825, + 2.018885851261287, + 1.9779161923717365, + 2.0143287826448697, + 2.0801374946004025 + ], + "raw_time_brier": 0.009489493552022256, + "raw_timepoint_brier": [ + 0.00219928240403533, + 0.004759702365845442, + 0.005522062070667744, + 0.006962260697036982, + 0.007993869483470917, + 0.009418676607310772, + 0.011150026693940163, + 0.01117468811571598, + 0.011191983707249165, + 0.01225616130977869, + 0.012950709089636803, + 0.013633781112730503, + 0.01415021251887083 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0013454760182491858, + 0.0022916025077471995, + 0.0029439508168229984, + 0.003595065628028153, + 0.004125138944805376, + 0.004621612497369723, + 0.005167789345426121, + 0.00545754034249791, + 0.005831962237997416, + 0.006070754967212102, + 0.006547653100563121, + 0.006768399096610718, + 0.006802537118628837 + ] + }, + "I31": { + "normalized_time_brier": 2.1874625515090296, + "normalized_timepoint_brier": [ + 1.4271055115386844, + 2.2721231050993773, + 2.3437051351013194, + 2.131343799466083, + 1.9549970483294392, + 2.0660987673701166, + 2.4602633856140126, + 2.315103818141771, + 2.401141126460991, + 2.286508759191089, + 2.2255772308989585, + 2.2765189303407456, + 2.2765265520647935 + ], + "raw_time_brier": 0.0043611348911116905, + "raw_timepoint_brier": [ + 0.0014271055115386844, + 0.0024757173378020525, + 0.003181242384016514, + 0.0031781853176653385, + 0.003176672151312232, + 0.0038751938845962286, + 0.005272529553622007, + 0.005270829889923334, + 0.0056266942992806435, + 0.005625128746032715, + 0.005623907316476107, + 0.0059807635843753815, + 0.005980783607810736 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0010896052824980055, + 0.0013573560668411419, + 0.0014911650192059567, + 0.001624898694362083, + 0.0018756092137496708, + 0.0021430752432655222, + 0.0022767142659520087, + 0.002343341770824504, + 0.002460138726091191, + 0.002526943230006217, + 0.002627153020634092, + 0.002627153020634092 + ] + }, + "I34": { + "normalized_time_brier": 2.938752691006157, + "normalized_timepoint_brier": [ + 1.4550240011885762, + 3.633627202361822, + 3.642590716481209, + 3.7427732779836127, + 3.3838146767222277, + 3.093597497336951, + 2.9014234434401143, + 2.8918531001081136, + 2.696059466008716, + 2.853822361447344, + 2.6449300532748, + 2.6400699427916217, + 2.6241992439349398 + ], + "raw_time_brier": 0.005258363967116635, + "raw_timepoint_brier": [ + 0.0014550240011885762, + 0.003633627202361822, + 0.003642590716481209, + 0.004741060547530651, + 0.0050969538278877735, + 0.005452699493616819, + 0.005460747517645359, + 0.005837668664753437, + 0.005856296047568321, + 0.0065886955708265305, + 0.006601998116821051, + 0.006994446273893118, + 0.006996923591941595 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001266723949168745, + 0.0015062745199819862, + 0.0017625756092415528, + 0.001882092574247193, + 0.0020186601679508523, + 0.0021721687230579017, + 0.0023087265906364994, + 0.0024960955427334786, + 0.002649341277109181, + 0.0026663080587775163 + ] + }, + "I35": { + "normalized_time_brier": 1.6308010765416552, + "normalized_timepoint_brier": [ + 0.7408594246953726, + 1.4945862349122763, + 1.85986771248281, + 1.8741287058219314, + 1.8330246894514746, + 1.6363963166416984, + 1.7810890406252748, + 1.6797744081269288, + 1.5957278264675299, + 1.7856027245016601, + 1.6993537656167157, + 1.609813547157397, + 1.6101895985404486 + ], + "raw_time_brier": 0.002120174467563629, + "raw_timepoint_brier": [ + 0.0007408594246953726, + 0.0014945862349122763, + 0.00185986771248281, + 0.0018741287058219314, + 0.0018886978505179286, + 0.0019101961515843868, + 0.0022928407415747643, + 0.0023054780904203653, + 0.002326368819922209, + 0.0026947909500449896, + 0.0027098546270281076, + 0.0027319802902638912, + 0.0027326184790581465 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001030372291975573, + 0.0011673187797834911, + 0.0012873251641421768, + 0.0013724926866763864, + 0.0014578731919917085, + 0.001509177216783802, + 0.001594638315962815, + 0.0016970787052252182, + 0.0016970787052252231 + ] + }, + "I42": { + "normalized_time_brier": 1.876109142800768, + "normalized_timepoint_brier": [ + 0.3681475354824215, + 1.4384528622031212, + 1.3598722251284816, + 2.1966109923381127, + 2.4221974675570204, + 2.41186695829319, + 2.268580155026532, + 2.2314526085843513, + 2.083677122814489, + 2.0697294613472583, + 1.846123687588136, + 1.852166507800315, + 1.8405412722465528 + ], + "raw_time_brier": 0.003481602996963864, + "raw_timepoint_brier": [ + 0.0003681475354824215, + 0.0014384528622031212, + 0.0014409328578040004, + 0.002852275501936674, + 0.0035585639998316765, + 0.003913281485438347, + 0.003912726417183876, + 0.004267116077244282, + 0.004267989657819271, + 0.004627223126590252, + 0.004630058538168669, + 0.004992002155631781, + 0.004992068745195866 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0010596090067711032, + 0.001298489132525309, + 0.0014691469409472931, + 0.001622511337941984, + 0.0017247468239173216, + 0.0019122593331486297, + 0.002048297027926458, + 0.0022356656814355984, + 0.002507989345078822, + 0.002695223207313268, + 0.0027122829683153904 + ] + }, + "I44": { + "normalized_time_brier": 1.6130900028829858, + "normalized_timepoint_brier": [ + 1.2655776408954902, + 1.5975448235634802, + 1.564042146577155, + 1.761314444656686, + 1.627395338988097, + 1.4550852076559673, + 1.617195843770529, + 1.6016400824660277, + 1.7306433256361866, + 1.7652219898799477, + 1.662654366239626, + 1.673787138174314, + 1.6480676889753063 + ], + "raw_time_brier": 0.005869814266379063, + "raw_timepoint_brier": [ + 0.0014672556426376104, + 0.002882802626118064, + 0.0035649873316287994, + 0.00464162603020668, + 0.005003503058105707, + 0.005014288704842329, + 0.006089920178055763, + 0.006462116725742817, + 0.007479592692106962, + 0.008223314769566059, + 0.008247444406151772, + 0.008612294681370258, + 0.008618438616394997 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0011593564829411951, + 0.001804520651688314, + 0.002279342241147807, + 0.0026353193458942092, + 0.0030745467547036542, + 0.0034460447253944464, + 0.003765728313929484, + 0.0040346871912653225, + 0.0043218568386166195, + 0.004658515935508669, + 0.004960408232532875, + 0.005145394229020145, + 0.0052294202926540904 + ] + }, + "I45": { + "normalized_time_brier": 1.5459655091664173, + "normalized_timepoint_brier": [ + 0.720987853128463, + 1.3318200856695717, + 1.3825234060337062, + 1.2257361257672874, + 1.2484250204374825, + 1.3955304376519941, + 1.5362586397018605, + 1.6318320900115537, + 1.7614489711366457, + 1.8556401549656396, + 2.0890733880018093, + 1.9672067913802616, + 1.9510686552771503 + ], + "raw_time_brier": 0.004545832406550359, + "raw_timepoint_brier": [ + 0.000720987853128463, + 0.001793510396964848, + 0.0025120708160102367, + 0.002515273168683052, + 0.0028761776629835367, + 0.003589381230995059, + 0.004311363212764263, + 0.005016328766942024, + 0.005739134736359119, + 0.006449547130614519, + 0.007855654694139957, + 0.007858002558350563, + 0.007858389057219028 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001346661171627519, + 0.0018170186523040984, + 0.00205205110284935, + 0.002303844937340045, + 0.0025720551369945465, + 0.0028064045345912348, + 0.0030740471385793788, + 0.003258189610032082, + 0.003475645379496513, + 0.0037603536281958293, + 0.003994497473667784, + 0.004027735792876412 + ] + }, + "I46": { + "normalized_time_brier": 0.6605400735067563, + "normalized_timepoint_brier": [ + 0.0007638742545168498, + 0.004593599442159757, + 0.3590596897993237, + 0.36030294722877443, + 0.36212109262123704, + 0.36338865174911916, + 0.3645126707851887, + 0.36663186619989574, + 0.7212265627458692, + 1.0735297109931707, + 1.0749162174761295, + 1.7679508309811354, + 1.7680232413113117 + ], + "raw_time_brier": 0.0006605400735067563, + "raw_timepoint_brier": [ + 7.638742545168498e-07, + 4.593599442159757e-06, + 0.0003590596897993237, + 0.00036030294722877443, + 0.00036212109262123704, + 0.00036338865174911916, + 0.0003645126707851887, + 0.00036663186619989574, + 0.0007212265627458692, + 0.0010735297109931707, + 0.0010749162174761295, + 0.0017679508309811354, + 0.0017680232413113117 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "I47": { + "normalized_time_brier": 1.4211648373557535, + "normalized_timepoint_brier": [ + 1.1055880459025502, + 1.1813949052463795, + 1.3231344163362022, + 1.2446957122495081, + 1.2443885531635155, + 1.3261560414227318, + 1.3700676663168412, + 1.4174885330646796, + 1.6344304285866156, + 1.725786195904214, + 1.622811068842093, + 1.6422576045946324, + 1.6369437139948333 + ], + "raw_time_brier": 0.004507015969675894, + "raw_timepoint_brier": [ + 0.0011055880459025502, + 0.0018527042120695114, + 0.0025922490749508142, + 0.002967279637232423, + 0.0033468231558799744, + 0.00408330699428916, + 0.004450925625860691, + 0.004820908419787884, + 0.005918849725276232, + 0.006658909376710653, + 0.006672982592135668, + 0.007057956885546446, + 0.007062723860144615 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0015682344691364068, + 0.001959172887459785, + 0.0023839397918947844, + 0.002689532258530985, + 0.0030790547015179985, + 0.003248690364196488, + 0.0034010211069325858, + 0.0036213531158953006, + 0.0038584787574000514, + 0.004111989818319991, + 0.0042977160622060875, + 0.004314579542205876 + ] + }, + "I48": { + "normalized_time_brier": 1.9545166010494652, + "normalized_timepoint_brier": [ + 2.166218536730161, + 2.077429717361352, + 1.9861691448857102, + 1.8726799310045672, + 1.9197118453418316, + 1.9011961636962755, + 1.8271788771903859, + 1.8341515233766694, + 1.849297830121468, + 2.0778508952022317, + 2.0301563022168923, + 1.9381832024336143, + 1.9284918440818881 + ], + "raw_time_brier": 0.009186080925596448, + "raw_timepoint_brier": [ + 0.0029299433808773756, + 0.004996837116777897, + 0.00624480564147234, + 0.007088996469974518, + 0.007864714600145817, + 0.008707351982593536, + 0.009145879186689854, + 0.009569833055138588, + 0.01043414045125246, + 0.012485670857131481, + 0.013293780386447906, + 0.013324636034667492, + 0.01333246286958456 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0013525613095805343, + 0.0024052977942014956, + 0.003144145934173035, + 0.003785482159875418, + 0.004096820373968883, + 0.0045799334907476565, + 0.005005464599477681, + 0.0052175804087988015, + 0.005642217430475821, + 0.006008934946179708, + 0.006548156105976348, + 0.0068748073030128745, + 0.006913414184508438 + ] + }, + "I49": { + "normalized_time_brier": 1.9640427683393027, + "normalized_timepoint_brier": [ + 1.461138715967536, + 1.7838433749449107, + 1.5139328960982577, + 1.988719226178254, + 2.103887021340651, + 2.1598642674018254, + 2.1103532242872043, + 2.002001687689833, + 2.1587241523912155, + 2.034918720418537, + 2.1340889063332416, + 2.045798465319529, + 2.0352853300399407 + ], + "raw_time_brier": 0.004807316733954044, + "raw_timepoint_brier": [ + 0.001461138715967536, + 0.0018213919829577208, + 0.002184297889471054, + 0.003637077286839485, + 0.004364428576081991, + 0.005086323246359825, + 0.005450150463730097, + 0.00545103894546628, + 0.00617957953363657, + 0.006180882453918457, + 0.0068923416547477245, + 0.0068931677378714085, + 0.006893299054354429 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0010210492740227093, + 0.0014427970322201705, + 0.0018288540880800458, + 0.0020744595749732156, + 0.00235492726238688, + 0.002582577362408583, + 0.002722794380736207, + 0.002862607307557781, + 0.003037409991809004, + 0.003229641292962831, + 0.00336942658562156, + 0.0033868956615626736 + ] + }, + "I50": { + "normalized_time_brier": 2.27864923037213, + "normalized_timepoint_brier": [ + 1.8184784995256926, + 2.227098679053169, + 2.4424721239753815, + 2.4943101263220315, + 2.3687950024597075, + 2.259635674329954, + 2.2588523684748307, + 2.370036444109459, + 2.299231301945955, + 2.304000421798042, + 2.287759369802134, + 2.25418669634837, + 2.23758328669296 + ], + "raw_time_brier": 0.014619885908009915, + "raw_timepoint_brier": [ + 0.0028755860403180122, + 0.0070236134342849255, + 0.010265563614666462, + 0.012722882442176342, + 0.013343071565032005, + 0.014098791405558586, + 0.015418393537402153, + 0.016982777044177055, + 0.017864538356661797, + 0.018594756722450256, + 0.019714083522558212, + 0.020570015534758568, + 0.02058444358408451 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0015813142916278862, + 0.0031537055364205735, + 0.004202939928730148, + 0.0051007620535690095, + 0.005632851956871252, + 0.0062394091072841985, + 0.0068257641590860575, + 0.007165618523034287, + 0.007769787381348774, + 0.008070639461054832, + 0.008617201521619497, + 0.009125249283069856, + 0.009199408891951158 + ] + }, + "I51": { + "normalized_time_brier": 1.4405500639335287, + "normalized_timepoint_brier": [ + 0.7118781213648617, + 1.0657154489308596, + 1.655020384798099, + 1.4719276471475653, + 1.3946996442149335, + 1.5141503353463015, + 1.3980685396043246, + 1.4827586019095547, + 1.4540526493576265, + 1.5839492099190116, + 1.6210341613342467, + 1.6869564996503612, + 1.6869395875581281 + ], + "raw_time_brier": 0.002262026819293029, + "raw_timepoint_brier": [ + 0.0007118781213648617, + 0.0010657154489308596, + 0.0017749666003510356, + 0.0017754799919202924, + 0.0017758036265149713, + 0.002130491193383932, + 0.0021309915464371443, + 0.0024832687340676785, + 0.0024838868994265795, + 0.0028380879666656256, + 0.003175560850650072, + 0.00353012653067708, + 0.0035300911404192448 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001072474162043369, + 0.0012062277621872097, + 0.0012732516523402129, + 0.0014070539388657648, + 0.0015242396821548165, + 0.0016747626558157394, + 0.0017082510048889322, + 0.0017917796535980716, + 0.001958972195895193, + 0.0020926008058943634, + 0.002092600805894364 + ] + }, + "I61": { + "normalized_time_brier": 2.217757193228373, + "normalized_timepoint_brier": [ + 0.7133244653232396, + 0.7131316815502942, + 1.4256569556891918, + 1.7817041371017694, + 1.781514030881226, + 2.13740230537951, + 2.4924729950726032, + 2.8468891978263855, + 2.8461667243391275, + 2.8458740562200546, + 2.845301292836666, + 3.200707258656621, + 3.200698411092162 + ], + "raw_time_brier": 0.0022177571932283733, + "raw_timepoint_brier": [ + 0.0007133244653232396, + 0.0007131316815502942, + 0.0014256569556891918, + 0.0017817041371017694, + 0.001781514030881226, + 0.00213740230537951, + 0.0024924729950726032, + 0.0028468891978263855, + 0.0028461667243391275, + 0.0028458740562200546, + 0.002845301292836666, + 0.003200707258656621, + 0.003200698411092162 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "I63": { + "normalized_time_brier": 2.4132344139485973, + "normalized_timepoint_brier": [ + 1.4589829370379448, + 2.1985971834510565, + 2.8057680023173006, + 2.6453406673055757, + 2.588165435689318, + 2.5142557781946975, + 2.3216584818360793, + 2.394949773762822, + 2.5147145290453663, + 2.439122584450277, + 2.437885226363159, + 2.5437989178838474, + 2.5088078639943174 + ], + "raw_time_brier": 0.004116284858005552, + "raw_timepoint_brier": [ + 0.0014589829370379448, + 0.0021985971834510565, + 0.002914260607212782, + 0.0032868250273168087, + 0.0036554327234625816, + 0.0040207551792263985, + 0.004028383642435074, + 0.004398933611810207, + 0.005130968522280455, + 0.0051420521922409534, + 0.00551155861467123, + 0.005880360491573811, + 0.005884592421352863 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0010386677033902578, + 0.0012424959355668242, + 0.0014123644003031103, + 0.0015991830322503655, + 0.0017351318783326109, + 0.0018367540146359016, + 0.002040378127623205, + 0.0021081565252284587, + 0.002260794952555409, + 0.002311645173772463, + 0.0023455731727434477 + ] + }, + "I65": { + "normalized_time_brier": 1.3112719268698538, + "normalized_timepoint_brier": [ + 0.001051455569722748, + 0.7224622531794012, + 0.7247125613503158, + 1.0794405825436115, + 1.082074362784624, + 1.8028479535132647, + 1.8061331938952208, + 1.617281876805349, + 1.830631469897595, + 1.7112984322058837, + 1.6059535334336994, + 1.531283806180101, + 1.5313635679493145 + ], + "raw_time_brier": 0.0015305306917788096, + "raw_timepoint_brier": [ + 1.051455569722748e-06, + 0.0007224622531794012, + 0.0007247125613503158, + 0.0010794405825436115, + 0.001082074362784624, + 0.0018028479535132647, + 0.0018061331938952208, + 0.0018074591644108295, + 0.002169510815292597, + 0.0021726491395384073, + 0.0021747290156781673, + 0.002176857553422451, + 0.0021769709419459105 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0011175906873952869, + 0.0011851160929807235, + 0.0012695910302084699, + 0.0013541668363395082, + 0.0014215898742198421, + 0.0014215898742198393 + ] + }, + "I67": { + "normalized_time_brier": 0.6121133608332608, + "normalized_timepoint_brier": [ + 0.7209203322418034, + 0.7239460828714073, + 0.7022361034304895, + 0.5494461138087653, + 0.4674752404548715, + 0.6527641509974932, + 0.5913102109013636, + 0.5458491063980947, + 0.5135403974714673, + 0.49290040195582413, + 0.5983380688181339, + 0.7014548131499473, + 0.6972926683327308 + ], + "raw_time_brier": 0.0011111236347530324, + "raw_timepoint_brier": [ + 0.0007209203322418034, + 0.0007239460828714073, + 0.0007275118259713054, + 0.0007367178914137185, + 0.000745597411878407, + 0.0011075102956965566, + 0.0011131935752928257, + 0.001119813066907227, + 0.001123031135648489, + 0.0011278947349637747, + 0.001490280730649829, + 0.0018537183059379458, + 0.0018544718623161316 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0010359931971844535, + 0.0013408373867762637, + 0.0015949452449137453, + 0.0016966469344313147, + 0.0018825881149522672, + 0.0020515066412704415, + 0.002186840881804017, + 0.002288281223728565, + 0.0024907001715493435, + 0.0026426767215605145, + 0.002659531566207754 + ] + }, + "I69": { + "normalized_time_brier": 2.606949278683196, + "normalized_timepoint_brier": [ + 1.449509640224278, + 2.936538630405553, + 3.0724119675031525, + 3.016157599050623, + 2.744495270993825, + 2.523649053562027, + 2.6223114300916057, + 2.525049700642145, + 2.52012922236117, + 2.5804414276585157, + 2.6758601917293126, + 2.6117949799332556, + 2.6119915087260748 + ], + "raw_time_brier": 0.005216817756613286, + "raw_timepoint_brier": [ + 0.001449509640224278, + 0.0032560599502176046, + 0.004348267801105976, + 0.005089311394840479, + 0.005097236949950457, + 0.0051157306879758835, + 0.00549397524446249, + 0.005504358094185591, + 0.0057933214120566845, + 0.006150419823825359, + 0.006831037346273661, + 0.0068444437347352505, + 0.006844958756119013 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0011088088256369791, + 0.0014152619658748659, + 0.0016873492938308029, + 0.0018572584197256302, + 0.0020271165203241074, + 0.002095088776038538, + 0.002179900891766914, + 0.0022988191877830696, + 0.002383475849481393, + 0.0025528379126037244, + 0.0026205899725368796, + 0.0026205899725368744 + ] + }, + "I70": { + "normalized_time_brier": 1.133147658947795, + "normalized_timepoint_brier": [ + 0.7188630988821387, + 0.6869510709716157, + 1.276255592372425, + 1.0903868586882424, + 0.9186738043625853, + 1.1841987822348818, + 1.0502116595689854, + 1.320915357386467, + 1.4528033420337934, + 1.3443624787382509, + 1.2635895722406694, + 1.2147882442349704, + 1.2089197046063107 + ], + "raw_time_brier": 0.002839132780746485, + "raw_timepoint_brier": [ + 0.0007188630988821387, + 0.0007182142580859363, + 0.0017927046865224838, + 0.0017924867570400238, + 0.0017925085267052054, + 0.0025127290282398462, + 0.0025149190332740545, + 0.0035913554020226, + 0.004295626655220985, + 0.004294988699257374, + 0.004295246675610542, + 0.0042945765890181065, + 0.00429450673982501 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0010455100638683077, + 0.0014046596130403897, + 0.0016438998166177663, + 0.0019511915091003642, + 0.00212188111146145, + 0.002394678263528512, + 0.002718838403944651, + 0.002956784673421453, + 0.003194814469449064, + 0.0033992419453050446, + 0.0035352470765163476, + 0.003552350684219787 + ] + }, + "I71": { + "normalized_time_brier": 0.8510326431681622, + "normalized_timepoint_brier": [ + 0.36071642534807324, + 1.0834741406142712, + 1.0346423177722457, + 0.8925095815645613, + 0.8048070934701743, + 0.9419645268932099, + 0.8594881841747641, + 0.8273098264704526, + 0.9421634169411214, + 0.8887409056197115, + 0.8416304223439597, + 0.7929027604376564, + 0.793074759535907 + ], + "raw_time_brier": 0.001396193119804733, + "raw_timepoint_brier": [ + 0.00036071642534807324, + 0.0010834741406142712, + 0.0010853615822270513, + 0.0010869980324059725, + 0.0010888477554544806, + 0.0014490499161183834, + 0.0014521422563120723, + 0.0014535753289237618, + 0.001814157236367464, + 0.0018162199994549155, + 0.001818832359276712, + 0.0018203703220933676, + 0.0018207652028650045 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0010490210612726651, + 0.0012179118912095876, + 0.0013529301174018949, + 0.0015383274791648939, + 0.0016895430129808518, + 0.001756990286366043, + 0.0019255229015974797, + 0.0020435877182771066, + 0.0021610820034418704, + 0.002295830476222056, + 0.002295830476222044 + ] + }, + "I72": { + "normalized_time_brier": 1.2944521639994642, + "normalized_timepoint_brier": [ + 0.7094120956026018, + 0.7103249081410468, + 1.0646908776834607, + 1.7698685405775905, + 1.5828254610529575, + 1.4333504024417312, + 1.3779388164496833, + 1.536336188804196, + 1.4504832410027426, + 1.3585145574087147, + 1.3033472879372048, + 1.265376223301178, + 1.2654095315899256 + ], + "raw_time_brier": 0.001719088347342152, + "raw_timepoint_brier": [ + 0.0007094120956026018, + 0.0007103249081410468, + 0.0010646908776834607, + 0.0017698685405775905, + 0.0017703794874250889, + 0.0017705269856378436, + 0.0017710720421746373, + 0.002128046005964279, + 0.002129583852365613, + 0.0021302211098372936, + 0.0021305817645043135, + 0.0021316923666745424, + 0.002131748478859663 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.0011184931825947272, + 0.001235236675290095, + 0.001285305284263548, + 0.0013851434480760616, + 0.0014681892159563298, + 0.0015680517357874787, + 0.0016346999638725337, + 0.0016846312799471406, + 0.0016846312799471523 + ] + }, + "I73": { + "normalized_time_brier": 0.3629904728507271, + "normalized_timepoint_brier": [ + 0.21246311944312676, + 0.1263721912748456, + 0.28229038077320406, + 0.4622031492746665, + 0.39538887575792014, + 0.35440364947791253, + 0.384584234507504, + 0.4120935920385211, + 0.3864908286151597, + 0.4526621418993482, + 0.43325709497025877, + 0.4087452162294606, + 0.40792167279752395 + ], + "raw_time_brier": 0.0023459516814909875, + "raw_timepoint_brier": [ + 0.0003679221263155341, + 0.00037406611954793334, + 0.001109265605919063, + 0.0021530494559556246, + 0.0021497379057109356, + 0.0021482163574546576, + 0.0025128063280135393, + 0.002845195820555091, + 0.0028439981397241354, + 0.0035055114421993494, + 0.003500710241496563, + 0.003493586089462042, + 0.00349330622702837 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0017316987874407136, + 0.002960035081882696, + 0.003929519677152096, + 0.0046582319037297695, + 0.005437021720932606, + 0.006061496151688305, + 0.006533825629205582, + 0.006904246694253697, + 0.007358513913291298, + 0.007744211670740554, + 0.008079983645130778, + 0.008547099637493541, + 0.00856366910605975 + ] + }, + "I74": { + "normalized_time_brier": 1.2179791433579654, + "normalized_timepoint_brier": [ + 0.7084260578267276, + 1.0627915617078543, + 1.4171595685184002, + 1.4171268558129668, + 1.4145100953088656, + 1.3471220951466454, + 1.4735396482107421, + 1.4147606418176444, + 1.2632924903373235, + 1.1791441730666852, + 1.0942589398261164, + 1.020792799327065, + 1.0208039367465145 + ], + "raw_time_brier": 0.0015259686579856162, + "raw_timepoint_brier": [ + 0.0007084260578267276, + 0.0010627915617078543, + 0.0014171595685184002, + 0.0014171268558129668, + 0.001417128136381507, + 0.0014170906506478786, + 0.0017712425906211138, + 0.0017711766995489597, + 0.001771034556441009, + 0.0017710131360217929, + 0.0017709536477923393, + 0.001771214883774519, + 0.0017712342087179422 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001001850846509561, + 0.0010519392828261915, + 0.0012020325294754438, + 0.0012519267550964678, + 0.001401919642511378, + 0.0015019479182225796, + 0.0016184045506393151, + 0.0017351365379361544, + 0.0017351365379361524 + ] + }, + "I77": { + "normalized_time_brier": 0.7688352307847818, + "normalized_timepoint_brier": [ + 0.7177357911132276, + 1.0359987355202156, + 0.7654140108492373, + 0.6438852108295123, + 0.7652681263932052, + 0.6703140221696055, + 0.6312338047293768, + 0.9043329262964734, + 0.8565857115721524, + 0.7937682929800106, + 0.7480273243609918, + 0.7311429496856523, + 0.7311510937024999 + ], + "raw_time_brier": 0.0016285897581838071, + "raw_timepoint_brier": [ + 0.0007177357911132276, + 0.001077001797966659, + 0.0010775414993986487, + 0.0010786911007016897, + 0.0014355374732986093, + 0.0014366972027346492, + 0.0014373306185007095, + 0.0021498873829841614, + 0.0021507106721401215, + 0.0021518582943826914, + 0.002152681117877364, + 0.0021529849618673325, + 0.002153008943423629 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001039578293911579, + 0.0014077890973057858, + 0.0016752847907657645, + 0.0018758620982484387, + 0.0021433196311252617, + 0.002277017814527413, + 0.002377318485780036, + 0.0025107944751877427, + 0.002710940098531854, + 0.0028778108068663252, + 0.0029446840221778615, + 0.0029446840221778736 + ] + }, + "I80": { + "normalized_time_brier": 1.365540182003035, + "normalized_timepoint_brier": [ + 0.7081330404616892, + 0.7090243743732572, + 0.7110643782652915, + 1.3904053485020995, + 1.3876541052013636, + 1.3874026481062174, + 1.3872218551114202, + 1.385146053507924, + 1.73722964245826, + 1.737319864332676, + 1.7377182375639677, + 1.736831502057612, + 1.7368713160976768 + ], + "raw_time_brier": 0.001365540182003035, + "raw_timepoint_brier": [ + 0.0007081330404616892, + 0.0007090243743732572, + 0.0007110643782652915, + 0.0013904053485020995, + 0.0013876541052013636, + 0.0013874026481062174, + 0.0013872218551114202, + 0.001385146053507924, + 0.00173722964245826, + 0.001737319864332676, + 0.0017377182375639677, + 0.001736831502057612, + 0.0017368713160976768 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "I81": { + "normalized_time_brier": 1.2119799926775416, + "normalized_timepoint_brier": [ + 1.4127976028248668, + 1.7466934556973144, + 1.3631758931058857, + 1.2025933221703597, + 1.2297986991524563, + 1.090620869906226, + 1.1465444159926177, + 1.2145071376974488, + 1.1139195043685586, + 1.0648767213678652, + 1.010244635532003, + 1.082788314435591, + 1.0771793325568493 + ], + "raw_time_brier": 0.002459514536894858, + "raw_timepoint_brier": [ + 0.0014127976028248668, + 0.0017758050234988332, + 0.0017939930548891425, + 0.0018026581965386868, + 0.002170505467802286, + 0.0021964311599731445, + 0.0025372477248311043, + 0.002909161150455475, + 0.0029268376529216766, + 0.00293927313759923, + 0.00295627536252141, + 0.0032759131863713264, + 0.0032767902594059706 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0010166666725100295, + 0.0013160393049510837, + 0.0014989757246326382, + 0.001764927438367059, + 0.002013927314779882, + 0.002212951970669613, + 0.0023953429833033957, + 0.0026275127075549294, + 0.0027602003862227807, + 0.002926296521203116, + 0.003025441947144501, + 0.0030420099609857996 + ] + }, + "I82": { + "normalized_time_brier": 2.3273875631920973, + "normalized_timepoint_brier": [ + 2.183161210268736, + 2.301447660812354, + 2.380889806685842, + 2.285227114197302, + 2.223468012371803, + 2.213172630880868, + 2.363410446901005, + 2.3408713786423117, + 2.460981338250319, + 2.3830390580947896, + 2.439615264383363, + 2.351048536188908, + 2.329705863819658 + ], + "raw_time_brier": 0.009044510384018604, + "raw_timepoint_brier": [ + 0.002183161210268736, + 0.004741919692605734, + 0.006522002629935741, + 0.007267404347658157, + 0.00801167730242014, + 0.00838704314082861, + 0.00947630312293768, + 0.010137338191270828, + 0.011572204530239105, + 0.011608199216425419, + 0.01254233717918396, + 0.012562484480440617, + 0.012566559948027134 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0020604073572248667, + 0.0027393130969863145, + 0.0031801672151132647, + 0.003603234792603999, + 0.0037896018700947294, + 0.004009588404486988, + 0.0043305831682005575, + 0.004702272361994659, + 0.004871174552088975, + 0.005141112765727083, + 0.005343353949129707, + 0.00539405430667702 + ] + }, + "I85": { + "normalized_time_brier": 0.8829398880670977, + "normalized_timepoint_brier": [ + 0.4002239147666842, + 0.5874377769595472, + 0.91811976125517, + 0.7747950803765411, + 0.7088082067667943, + 1.0316266444472182, + 1.0919236962435235, + 1.1340614517437524, + 1.05138911257954, + 1.0164510332176884, + 0.9708268924301875, + 0.8962677986878657, + 0.8962871753977575 + ], + "raw_time_brier": 0.002210900476291919, + "raw_timepoint_brier": [ + 0.0004002239147666842, + 0.0007895969320088625, + 0.0013881438644602895, + 0.0014181688893586397, + 0.0014395802281796932, + 0.002336766803637147, + 0.0026922952383756638, + 0.0030239096377044916, + 0.003049068618565798, + 0.003049805061891675, + 0.0030585110653191805, + 0.003047785023227334, + 0.003047850914299488 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001344137137546121, + 0.0015119420396338546, + 0.0018303793161275968, + 0.0020309869643669784, + 0.0022651283933144907, + 0.002465644117476155, + 0.002666442486917156, + 0.00290003822760256, + 0.003000444647330604, + 0.0031504185650060358, + 0.003400529426237655, + 0.0034005294262376366 + ] + }, + "I87": { + "normalized_time_brier": 1.8402233929712346, + "normalized_timepoint_brier": [ + 1.4344534138217568, + 2.512275241315365, + 2.8655192732318073, + 2.4840205882019877, + 2.126999013502892, + 1.9368973555236522, + 1.8179335001571506, + 1.626422436573449, + 1.4976457239064653, + 1.5123367614733367, + 1.4232397890358401, + 1.3069036989002056, + 1.3782573129821403 + ], + "raw_time_brier": 0.003960819171669965, + "raw_timepoint_brier": [ + 0.0014344534138217568, + 0.002512275241315365, + 0.0035850233398377895, + 0.003945569973438978, + 0.003952247090637684, + 0.003958370070904493, + 0.004328093025833368, + 0.004337860271334648, + 0.004347405396401882, + 0.00466986745595932, + 0.004681868012994528, + 0.00469438498839736, + 0.005043230950832367 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001251090290450047, + 0.0015883805440980285, + 0.0018581330153646118, + 0.0020436653804167767, + 0.0023807763185282782, + 0.0026671178248583827, + 0.002902826300643447, + 0.003087848933467622, + 0.0032895848254539126, + 0.003591989977798525, + 0.003659135999736007 + ] + }, + "I89": { + "normalized_time_brier": 1.2401294173348296, + "normalized_timepoint_brier": [ + 0.35367117379792035, + 1.0600521927699447, + 1.413271646015346, + 1.413070596754551, + 1.709153485243656, + 1.4921614212236094, + 1.412482262456134, + 1.3582314066707086, + 1.2765512404648118, + 1.2613179261438625, + 1.164309515527455, + 1.1037039773859896, + 1.1037055808987921 + ], + "raw_time_brier": 0.001546875978909576, + "raw_timepoint_brier": [ + 0.00035367117379792035, + 0.0010600521927699447, + 0.001413271646015346, + 0.001413070596754551, + 0.0017641019076108932, + 0.001763558597303927, + 0.0017633348470553756, + 0.0017633032985031605, + 0.0017632367089390755, + 0.0017631563823670149, + 0.0017629469512030482, + 0.0017628404311835766, + 0.0017628429923206568 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010321494955494905, + 0.0011818819145302424, + 0.0012483943295607492, + 0.0012982348146589853, + 0.0013812502413119382, + 0.001397868329484056, + 0.001514156611873432, + 0.0015972040214611571, + 0.0015972040214611422 + ] + }, + "I95": { + "normalized_time_brier": 1.1966770897338403, + "normalized_timepoint_brier": [ + 1.1219920038235383, + 1.1171839386345275, + 1.0691657114938051, + 1.1422313879184303, + 1.1443807298530735, + 1.169865358800734, + 1.2499285190732967, + 1.2453196375338926, + 1.243373928449717, + 1.2647957034907245, + 1.2542665118999081, + 1.265323428775188, + 1.2689753067930871 + ], + "raw_time_brier": 0.02683055203837844, + "raw_timepoint_brier": [ + 0.0075719221495091915, + 0.013042698614299297, + 0.016233017668128014, + 0.020368609577417374, + 0.02267509140074253, + 0.025652913376688957, + 0.02951059676706791, + 0.03126072883605957, + 0.033064354211091995, + 0.03515591844916344, + 0.03660883754491806, + 0.03865128010511398, + 0.039001207798719406 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.006748641811800352, + 0.011674620591342076, + 0.015182882778243745, + 0.017832297197275013, + 0.01981428978068669, + 0.021928090428275072, + 0.023609827535535564, + 0.02510257438641634, + 0.02659244612947435, + 0.027795728869204887, + 0.029187447163413933, + 0.03054656163486025, + 0.030734410346629975 + ] + }, + "I96": { + "normalized_time_brier": 1.4442927278805664, + "normalized_timepoint_brier": [ + 0.00070349415182136, + 0.34828591742552817, + 1.0462126228958368, + 1.3984639663249254, + 1.395553001202643, + 1.3946514809504151, + 1.7448158469051123, + 1.744617591612041, + 1.7445222474634647, + 1.743655651807785, + 2.091943984851241, + 2.0611853547394703, + 2.061194302117076 + ], + "raw_time_brier": 0.001449007032463739, + "raw_timepoint_brier": [ + 7.0349415182136e-07, + 0.00034828591742552817, + 0.0010462126228958368, + 0.0013984639663249254, + 0.001395553001202643, + 0.0013946514809504151, + 0.0017448158469051123, + 0.001744617591612041, + 0.0017445222474634647, + 0.001743655651807785, + 0.002091943984851241, + 0.002091828268021345, + 0.0020918373484164476 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010148666461322437, + 0.0010148666461322435 + ] + }, + "I97": { + "normalized_time_brier": 1.705759748792325, + "normalized_timepoint_brier": [ + 1.451149582862854, + 1.4506985899060965, + 2.0539988737445127, + 1.846856493620013, + 1.603982706567216, + 1.4606886345085879, + 1.7223415052203725, + 1.7794657157592617, + 1.7073045431157199, + 1.7770939308748699, + 1.7506689065666687, + 1.7251064305384338, + 1.845520821015618 + ], + "raw_time_brier": 0.003070828755601094, + "raw_timepoint_brier": [ + 0.001451149582862854, + 0.0014506985899060965, + 0.002542379777878523, + 0.002542565343901515, + 0.0025432489346712828, + 0.002544817514717579, + 0.0032708891667425632, + 0.0036267649848014116, + 0.0036280639469623566, + 0.003992567304521799, + 0.003993762657046318, + 0.003995367791503668, + 0.00433849822729826 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0012377707750363437, + 0.0013766989220249848, + 0.001585583762379988, + 0.001742203954077947, + 0.001899094434424638, + 0.0020381201799406093, + 0.00212502447884393, + 0.0022466833267255847, + 0.0022812781115069333, + 0.0023160123461232755, + 0.002350825944575753 + ] + }, + "J02": { + "normalized_time_brier": 0.6668107604486277, + "normalized_timepoint_brier": [ + 0.00053572904334942, + 0.3560494224075228, + 0.3572162822820246, + 0.7123516988940537, + 0.7160514942370355, + 0.7190681644715369, + 0.7207962335087359, + 0.7222979911603034, + 0.7238205871544778, + 0.7291727233678102, + 0.7328937062993646, + 1.0890478733927011, + 1.0892379796132445 + ], + "raw_time_brier": 0.0006668107604486278, + "raw_timepoint_brier": [ + 5.3572904334942e-07, + 0.0003560494224075228, + 0.0003572162822820246, + 0.0007123516988940537, + 0.0007160514942370355, + 0.0007190681644715369, + 0.0007207962335087359, + 0.0007222979911603034, + 0.0007238205871544778, + 0.0007291727233678102, + 0.0007328937062993646, + 0.0010890478733927011, + 0.0010892379796132445 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "J06": { + "normalized_time_brier": 1.7842516455112873, + "normalized_timepoint_brier": [ + 0.35950352321378887, + 0.7259058183990419, + 1.0922272922471166, + 2.1515372209250927, + 1.954975198303993, + 2.0987208270094637, + 2.1237633163024228, + 2.0055823747375983, + 1.9001968845519153, + 1.9781503204976407, + 2.072931691881448, + 2.3651843844807483, + 2.3665925390964655 + ], + "raw_time_brier": 0.002561036338402818, + "raw_timepoint_brier": [ + 0.00035950352321378887, + 0.0007259058183990419, + 0.0010922272922471166, + 0.0021515372209250927, + 0.002159315859898925, + 0.0025286192540079355, + 0.002878359751775861, + 0.002885436872020364, + 0.0028923689387738705, + 0.003275359980762005, + 0.0036401518154889345, + 0.004351047798991203, + 0.004353638272732496 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.0011045234035563236, + 0.0012048383098246793, + 0.0013553109848357433, + 0.0014387027470750893, + 0.0015221417118868284, + 0.0016557690013861166, + 0.0017560404087338909, + 0.0018396230871219924, + 0.0018396230871219846 + ] + }, + "J12": { + "normalized_time_brier": 0.15289465699749344, + "normalized_timepoint_brier": [ + 0.002260613655380439, + 0.00610469533057767, + 0.018989507225342095, + 0.023607273760717362, + 0.03380258567631245, + 0.04443697980605066, + 0.05458308078232221, + 0.0719753879820928, + 0.08628450450487435, + 0.4348969598244798, + 0.4125618066969015, + 0.4035146896652576, + 0.3946124560571057 + ], + "raw_time_brier": 0.00017895823325139086, + "raw_timepoint_brier": [ + 2.260613655380439e-06, + 6.10469533057767e-06, + 1.8989507225342095e-05, + 2.3607273760717362e-05, + 3.3802585676312447e-05, + 4.443697980605066e-05, + 5.458308078232221e-05, + 7.19753879820928e-05, + 8.628450450487435e-05, + 0.0004698001721408218, + 0.0004936095792800188, + 0.0005095768719911575, + 0.0005114257801324129 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010802562803162124, + 0.0011964500137131235, + 0.001262845901381894, + 0.0012960203670266373 + ] + }, + "J15": { + "normalized_time_brier": 0.8457481271811111, + "normalized_timepoint_brier": [ + 0.3453854594056176, + 0.5890270001282708, + 0.9499915963191243, + 0.9571087490117286, + 0.8599332664271863, + 0.8732162758798402, + 0.9453058841469255, + 0.8895745451072559, + 0.9541862084347843, + 0.9779196885146828, + 0.9272706004665175, + 0.8661707175889941, + 0.8596356619235156 + ], + "raw_time_brier": 0.003814245618951435, + "raw_timepoint_brier": [ + 0.00036591559182852507, + 0.0010983417741954327, + 0.0025354078970849514, + 0.0032424069941043854, + 0.0032576413359493017, + 0.0036139413714408875, + 0.004337201360613108, + 0.004348158370703459, + 0.0050604999996721745, + 0.005413994193077087, + 0.005426127463579178, + 0.005441942252218723, + 0.005443614441901445 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0010594412181052389, + 0.0018646713545495365, + 0.0026688740267900735, + 0.00338771011909813, + 0.0037882489992322427, + 0.004138655532731032, + 0.004588145946565368, + 0.004887907814605017, + 0.005303472168155996, + 0.005536236008603277, + 0.005851719509762574, + 0.006282759439578485, + 0.006332466977604031 + ] + }, + "J18": { + "normalized_time_brier": 2.3034394225576285, + "normalized_timepoint_brier": [ + 2.074423322419751, + 1.7151719899195155, + 2.022770390122351, + 2.120008635445248, + 2.173272376623066, + 2.3070844009464833, + 2.4171618914696147, + 2.5421232258510145, + 2.455894848047511, + 2.4669860562812933, + 2.607184624583472, + 2.5232725897991135, + 2.5193581417407396 + ], + "raw_time_brier": 0.01492985114097022, + "raw_timepoint_brier": [ + 0.003381503513082862, + 0.0053388457745313644, + 0.008218370378017426, + 0.01006622239947319, + 0.011462235823273659, + 0.01366178784519434, + 0.016087619587779045, + 0.018473660573363304, + 0.01883406937122345, + 0.019950438290834427, + 0.02235398069024086, + 0.023125583305954933, + 0.023133747279644012 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0016300932777493277, + 0.0031127174451944556, + 0.004062927961645871, + 0.004748198772010693, + 0.00527418281600037, + 0.0059216679890816215, + 0.006655582170376641, + 0.007267020097807794, + 0.007668923360540838, + 0.008086968404234717, + 0.008573992221134768, + 0.009164916782849863, + 0.009182397252841491 + ] + }, + "J30": { + "normalized_time_brier": 1.5850776683829404, + "normalized_timepoint_brier": [ + 0.0012643795344047248, + 0.34051344846375287, + 1.0479079792276025, + 1.0538644855841994, + 2.1162296179682016, + 2.1209269762039185, + 2.0160730189039153, + 2.276319525507118, + 2.2447215681629844, + 2.004404753590742, + 1.8794589803229433, + 1.7724884742222666, + 1.7318364812861766 + ], + "raw_time_brier": 0.0018222050919296006, + "raw_timepoint_brier": [ + 1.2643795344047248e-06, + 0.00034051344846375287, + 0.0010479079792276025, + 0.0010538644855841994, + 0.0021162296179682016, + 0.0021209269762039185, + 0.002122901612892747, + 0.0024729834403842688, + 0.0024761436507105827, + 0.002478733891621232, + 0.0024810857139527798, + 0.002487662946805358, + 0.0024884480517357588 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010529884547767578, + 0.0010863955664718635, + 0.001103096119282619, + 0.0012366433911019043, + 0.001320106339073418, + 0.0014034861061067807, + 0.0014368839544756976 + ] + }, + "J32": { + "normalized_time_brier": 0.4620658916650531, + "normalized_timepoint_brier": [ + 0.35376023151911795, + 0.35445636603981256, + 0.35863282391801476, + 0.7136868662200868, + 0.6721301143527015, + 0.5984322477276656, + 0.5268355918875818, + 0.4736629492718817, + 0.43679750084512436, + 0.4129409356312837, + 0.388913476757073, + 0.36099981798930997, + 0.35560766948603695 + ], + "raw_time_brier": 0.0006398317122008079, + "raw_timepoint_brier": [ + 0.00035376023151911795, + 0.00035445636603981256, + 0.00035863282391801476, + 0.0007136868662200868, + 0.0007169628515839577, + 0.0007180292159318924, + 0.0007198788225650787, + 0.0007259967969730496, + 0.0007276386604644358, + 0.00072910962626338, + 0.0007319719297811389, + 0.0007334193796850741, + 0.0007342686876654625 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010667024676828125, + 0.0011998504737309092, + 0.0013664202526367834, + 0.0015327287010500979, + 0.0016658489553090076, + 0.0017656511218698946, + 0.0018820945365139673, + 0.0020316336550252564, + 0.002064828041326296 + ] + }, + "J38": { + "normalized_time_brier": 0.717686785365139, + "normalized_timepoint_brier": [ + 0.3543162893038243, + 0.3561560879461467, + 0.35675655817613006, + 0.7107227575033903, + 0.7117265486158431, + 0.713456654921174, + 0.7147291908040643, + 1.0671301279217005, + 0.9573526030470404, + 0.9172480216538813, + 0.8689325969221864, + 0.8056075989622731, + 0.7957931739691544 + ], + "raw_time_brier": 0.0007954332999920902, + "raw_timepoint_brier": [ + 0.0003543162893038243, + 0.0003561560879461467, + 0.00035675655817613006, + 0.0007107227575033903, + 0.0007117265486158431, + 0.000713456654921174, + 0.0007147291908040643, + 0.0010671301279217005, + 0.0010684824083000422, + 0.0010695072123780847, + 0.0010709634516388178, + 0.001073253806680441, + 0.0010734318057075143 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0011160803291277428, + 0.0011659956599848165, + 0.001232504633192767, + 0.0013322290008968769, + 0.0013488829017640222 + ] + }, + "J43": { + "normalized_time_brier": 2.0671040183001343, + "normalized_timepoint_brier": [ + 0.3572205896489322, + 0.7160330424085259, + 1.4297717716544867, + 1.7867187270894647, + 1.7885571578517556, + 1.792252529412508, + 2.5022721383720636, + 2.7482019896709557, + 2.584380916633462, + 2.5462543570577476, + 2.7401786753625417, + 2.9604356842770687, + 2.9200746584622346 + ], + "raw_time_brier": 0.002256507022628704, + "raw_timepoint_brier": [ + 0.0003572205896489322, + 0.0007160330424085259, + 0.0014297717716544867, + 0.0017867187270894647, + 0.0017885571578517556, + 0.001792252529412508, + 0.0025022721383720636, + 0.002860493492335081, + 0.0028631228487938643, + 0.0028635242488235235, + 0.003219589125365019, + 0.0035774698480963707, + 0.003577565774321556 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010408599888531375, + 0.0011078563652774161, + 0.0011246025916014095, + 0.0011749559086467413, + 0.0012084268093025571, + 0.0012251624334172224 + ] + }, + "J44": { + "normalized_time_brier": 2.979259131476846, + "normalized_timepoint_brier": [ + 2.329352078959346, + 3.218286697003431, + 3.5681815645023134, + 3.1558249338701043, + 2.847890465927512, + 3.0401985065209307, + 3.04473969598902, + 2.9778404362999567, + 2.8010578908241954, + 2.953505686087496, + 2.9016389881714257, + 2.966039911974711, + 2.9258118530685553 + ], + "raw_time_brier": 0.007899923214259056, + "raw_timepoint_brier": [ + 0.002329352078959346, + 0.0038601530250161886, + 0.005379400681704283, + 0.006129587069153786, + 0.00651005981490016, + 0.007664110511541367, + 0.008445593528449535, + 0.009175194427371025, + 0.009184890426695347, + 0.01032384391874075, + 0.010717448778450489, + 0.011488697491586208, + 0.011490670032799244 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001199443489174039, + 0.0015076028460044456, + 0.0019423089675753488, + 0.0022859235257771536, + 0.002520924372241679, + 0.0027738310567485673, + 0.0030811571753560575, + 0.0032790791139246126, + 0.0034954542215277495, + 0.0036935844955696857, + 0.00387341297910497, + 0.00392734413894317 + ] + }, + "J45": { + "normalized_time_brier": 2.5018588350510944, + "normalized_timepoint_brier": [ + 2.9544015914117714, + 2.8586871058783285, + 3.0677651675384268, + 2.8830318141862734, + 2.6724029354351027, + 2.47230094728182, + 2.446938698575755, + 2.41813300845451, + 2.245573070214117, + 2.219081455894796, + 2.11564407925141, + 2.0850858076394863, + 2.085119173902429 + ], + "raw_time_brier": 0.007872933683057245, + "raw_timepoint_brier": [ + 0.003565738210454583, + 0.005145487375557423, + 0.006714574061334133, + 0.007483607158064842, + 0.007875187322497368, + 0.007878633216023445, + 0.008249831385910511, + 0.008643516339361668, + 0.008647550828754902, + 0.009037363342940807, + 0.009435185231268406, + 0.009835653007030487, + 0.009835810400545597 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0012069240081713747, + 0.0017999477329913927, + 0.0021887509944973735, + 0.0025957421354981013, + 0.0029468562611106334, + 0.003186761395163334, + 0.0033714908308542183, + 0.0035744586046926995, + 0.0038509327278004593, + 0.004072569449370071, + 0.004459722371925106, + 0.004717145438808283, + 0.004717145438808311 + ] + }, + "J47": { + "normalized_time_brier": 1.4136726156554607, + "normalized_timepoint_brier": [ + 0.00018542607449489878, + 0.3539441677276045, + 0.7074841996654868, + 1.0612297337502241, + 1.413572346791625, + 1.4138312544673681, + 2.117866650223732, + 2.0850786794873275, + 1.9273286881058294, + 1.8175301020086072, + 1.7195783446312538, + 1.8800508305239056, + 1.880063580063529 + ], + "raw_time_brier": 0.0015757045838252172, + "raw_timepoint_brier": [ + 1.8542607449489878e-07, + 0.0003539441677276045, + 0.0007074841996654868, + 0.0010612297337502241, + 0.001413572346791625, + 0.0014138312544673681, + 0.002117866650223732, + 0.002118009375408292, + 0.002117851050570607, + 0.002118032891303301, + 0.0021181441843509674, + 0.002471995772793889, + 0.002472012536600232 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001015793502779982, + 0.001098853072462706, + 0.001165335797719443, + 0.0012317811462118535, + 0.0013148558180764872, + 0.0013148558180764826 + ] + }, + "J69": { + "normalized_time_brier": 1.1130197262578365, + "normalized_timepoint_brier": [ + 1.2467715709566618, + 1.3200293192638053, + 1.3412833970911913, + 1.2335165104524621, + 1.1401097784373626, + 1.0443226547526139, + 1.035950289357375, + 1.0233250398526859, + 1.0016131739856027, + 1.0013618431002822, + 1.0350101820710844, + 1.02592689142865, + 1.0200357906020983 + ], + "raw_time_brier": 0.008166769465718132, + "raw_timepoint_brier": [ + 0.0021495043765753508, + 0.0049603902734816074, + 0.006746989209204912, + 0.007442994508892298, + 0.0078109800815582275, + 0.007830054499208927, + 0.008557413704693317, + 0.008927339687943459, + 0.009299338795244694, + 0.009660759940743446, + 0.010684004984796047, + 0.011047209613025188, + 0.011051023378968239 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0017240562959949528, + 0.0037577879529585535, + 0.005030248807848471, + 0.006033964236248575, + 0.00685107717632593, + 0.007497734980252595, + 0.00826044820162335, + 0.008723855412771495, + 0.009284361504792232, + 0.009647621394113737, + 0.01032260857899683, + 0.010768028117131666, + 0.01083395649523742 + ] + }, + "J81": { + "normalized_time_brier": 2.03621493179599, + "normalized_timepoint_brier": [ + 1.7962076235562563, + 1.8952494913520495, + 2.168609707961181, + 1.9377939377738578, + 2.028522170491619, + 2.1151774274286153, + 2.16571246081159, + 1.9872871638603407, + 2.0711836279806253, + 2.064035459624402, + 2.0580895129624777, + 2.100332315197182, + 2.08259321434767 + ], + "raw_time_brier": 0.0056161622588451095, + "raw_timepoint_brier": [ + 0.0017962076235562563, + 0.0025101390201598406, + 0.0039245011284947395, + 0.004283556714653969, + 0.004992366302758455, + 0.005700134206563234, + 0.006053293589502573, + 0.006052514538168907, + 0.00675650779157877, + 0.007111485116183758, + 0.00746820867061615, + 0.008180523291230202, + 0.008180671371519566 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0013244372477679105, + 0.0018096853085585237, + 0.00221053262225339, + 0.0024610854026547507, + 0.0026948728426497955, + 0.0027950587619716295, + 0.0030456164807162495, + 0.003262148126463451, + 0.0034454277822716537, + 0.003628709355729712, + 0.003894870936393798, + 0.0039281177501012815 + ] + }, + "J84": { + "normalized_time_brier": 2.210246664547618, + "normalized_timepoint_brier": [ + 1.4176509575918317, + 1.7669147346168756, + 1.763835083693266, + 1.7615192336961627, + 2.4636201560497284, + 2.4618010502308607, + 2.458931179717183, + 2.4578929878771305, + 2.4560585152357817, + 2.4554231204092503, + 2.455319045111537, + 2.40713215751348, + 2.407108417375946 + ], + "raw_time_brier": 0.002217644556926993, + "raw_timepoint_brier": [ + 0.0014176509575918317, + 0.0017669147346168756, + 0.001763835083693266, + 0.0017615192336961627, + 0.0024636201560497284, + 0.0024618010502308607, + 0.002458931179717183, + 0.0024578929878771305, + 0.0024560585152357817, + 0.0024554231204092503, + 0.002455319045111537, + 0.002455218695104122, + 0.002455194480717182 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010199766919487773, + 0.0010199766919487807 + ] + }, + "J90": { + "normalized_time_brier": 3.008257514939863, + "normalized_timepoint_brier": [ + 3.5382528204592476, + 2.666138773416687, + 3.2024917560016744, + 2.92558675042951, + 2.9676017700337036, + 2.7918331007284944, + 2.8782430263693266, + 2.826472721790114, + 2.8609434937076466, + 3.114673370460426, + 3.137348676711746, + 3.1043017047435177, + 3.093459729366119 + ], + "raw_time_brier": 0.0099184990573961, + "raw_timepoint_brier": [ + 0.0039864820428192616, + 0.004748114850372076, + 0.007258392404764891, + 0.00800152774900198, + 0.009108545258641243, + 0.009128252975642681, + 0.01017950288951397, + 0.010561483912169933, + 0.01126245129853487, + 0.013040238991379738, + 0.013396442867815495, + 0.014133395627140999, + 0.014135656878352165 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0011266809482262594, + 0.0017808956149297935, + 0.0022664827758454645, + 0.0027350164023771514, + 0.0030693286918135904, + 0.003269627032239419, + 0.003536707219040707, + 0.0037366304053629566, + 0.003936621370993689, + 0.004186711555392425, + 0.0042699885311620195, + 0.004552842143385906, + 0.004569529948672939 + ] + }, + "J91": { + "normalized_time_brier": 1.0153504663773947, + "normalized_timepoint_brier": [ + 0.3614453598856926, + 0.7250122362007632, + 0.9738449570298707, + 1.1055768607884402, + 1.2745912530828318, + 1.3105120624247195, + 1.2240001895837036, + 1.1393295808565722, + 1.0437001124794951, + 0.9915511985472417, + 1.026688508339725, + 0.9713037967711206, + 1.0519999469159524 + ], + "raw_time_brier": 0.0029325294039713647, + "raw_timepoint_brier": [ + 0.0003614453598856926, + 0.0010864060604944825, + 0.0018070449586957693, + 0.0024270969443023205, + 0.0031229250598698854, + 0.0034775405656546354, + 0.003476264886558056, + 0.003486824221909046, + 0.003494543954730034, + 0.003504425287246704, + 0.0038368292152881622, + 0.003843373851850629, + 0.004198161885142326 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001498465827539007, + 0.001855577672453195, + 0.0021953217640349677, + 0.0024501384677766466, + 0.002653573870369772, + 0.002840085251735437, + 0.003060417530182599, + 0.003348226097655699, + 0.003534285765960615, + 0.0037370918093675384, + 0.003956922504191844, + 0.003990648381161687 + ] + }, + "J94": { + "normalized_time_brier": 2.765541278327314, + "normalized_timepoint_brier": [ + 1.412510871887207, + 1.4145933091640472, + 1.7687019426375628, + 1.7698960145935416, + 2.7947777416557074, + 3.1432087998837233, + 3.1397794373333454, + 3.1387535855174065, + 3.476364305242896, + 3.475224832072854, + 3.474271623417735, + 3.4719924442470074, + 3.471961710602045 + ], + "raw_time_brier": 0.0027655412783273137, + "raw_timepoint_brier": [ + 0.001412510871887207, + 0.0014145933091640472, + 0.0017687019426375628, + 0.0017698960145935416, + 0.0027947777416557074, + 0.0031432087998837233, + 0.0031397794373333454, + 0.0031387535855174065, + 0.003476364305242896, + 0.003475224832072854, + 0.003474271623417735, + 0.0034719924442470074, + 0.003471961710602045 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "J95": { + "normalized_time_brier": 2.006727361080792, + "normalized_timepoint_brier": [ + 1.7980654956772923, + 2.8694788925349712, + 2.859063798202784, + 2.327495716602609, + 2.1019762331416336, + 2.01631964592134, + 1.7955488499626406, + 1.6750465795292122, + 1.6853363264456922, + 1.6977195991299994, + 1.8168463809112436, + 1.722260162649356, + 1.7222980133415273 + ], + "raw_time_brier": 0.004327502934477077, + "raw_timepoint_brier": [ + 0.0017980654956772923, + 0.0028694788925349712, + 0.003927838522940874, + 0.003924741875380278, + 0.004273746628314257, + 0.004274534992873669, + 0.004273019731044769, + 0.004276801832020283, + 0.004624596796929836, + 0.0049814339727163315, + 0.005676253233104944, + 0.0056784506887197495, + 0.005678575485944748 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0013738198236114651, + 0.001686250955215132, + 0.002033204068119588, + 0.002119968925324068, + 0.0023797847277358545, + 0.002553243524262065, + 0.0027440201248631058, + 0.002934191238216888, + 0.003124233998395619, + 0.00329709228133372, + 0.0032970922813337186 + ] + }, + "J96": { + "normalized_time_brier": 2.542073515085188, + "normalized_timepoint_brier": [ + 2.049116012211742, + 2.117623461537627, + 2.740700279169331, + 2.576879988375066, + 2.602504553624091, + 2.589446649629125, + 2.6050228423175783, + 2.656468679462075, + 2.644962258498394, + 2.5632375017882, + 2.6321882449969864, + 2.6456800823244206, + 2.6231251421728086 + ], + "raw_time_brier": 0.02007653725405152, + "raw_timepoint_brier": [ + 0.0038341782055795193, + 0.007647053338587284, + 0.01341505441814661, + 0.015600320883095264, + 0.01813562773168087, + 0.019962288439273834, + 0.021738233044743538, + 0.02353520691394806, + 0.02479049749672413, + 0.025601163506507874, + 0.02772754430770874, + 0.029494917020201683, + 0.02951289899647236 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0018711376919265032, + 0.0036111487606180397, + 0.004894754278717602, + 0.00605395709286894, + 0.006968528722236542, + 0.007709094312536984, + 0.008344737977577177, + 0.008859583813619008, + 0.009372722585008932, + 0.009987823402492999, + 0.010534027860815283, + 0.01114833090261173, + 0.011251044992853827 + ] + }, + "J98": { + "normalized_time_brier": 1.537249779380705, + "normalized_timepoint_brier": [ + 1.1673841258574387, + 1.147941627392199, + 1.5086389331031838, + 1.551840136585682, + 1.3771715878069297, + 1.6602095846772782, + 1.6214626987324954, + 1.6193714726289898, + 1.668630046214985, + 1.6546686736033889, + 1.6800232670917454, + 1.6702681049095927, + 1.6566368733452568 + ], + "raw_time_brier": 0.009517021907063631, + "raw_timepoint_brier": [ + 0.0022199403028935194, + 0.0033207654487341642, + 0.0058822608552873135, + 0.007339500356465578, + 0.007346294354647398, + 0.00982888787984848, + 0.01049366407096386, + 0.01117717381566763, + 0.012235291302204132, + 0.01258778665214777, + 0.013299716636538506, + 0.013995124027132988, + 0.013994879089295864 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0019016365339583343, + 0.002892799920739882, + 0.0038990514736271854, + 0.004729546673933666, + 0.00533433482050408, + 0.005920269326573657, + 0.006471727088860449, + 0.006902167911802164, + 0.007332536849589814, + 0.007607436372585225, + 0.007916388360240617, + 0.008378968613479277, + 0.008447765056101836 + ] + }, + "K04": { + "normalized_time_brier": 0.4337634651337706, + "normalized_timepoint_brier": [ + 2.2863702042741352e-05, + 0.00017756072168140236, + 0.0004164976985521207, + 0.3526697400957346, + 0.352853792719543, + 0.35290364758111537, + 0.3532417176757008, + 0.703922298271209, + 0.7040579803287983, + 0.7042634533718228, + 0.7044640369713306, + 0.7049587438814342, + 0.7049727137200534 + ], + "raw_time_brier": 0.0004337634651337706, + "raw_timepoint_brier": [ + 2.2863702042741352e-08, + 1.7756072168140236e-07, + 4.164976985521207e-07, + 0.0003526697400957346, + 0.000352853792719543, + 0.00035290364758111537, + 0.0003532417176757008, + 0.000703922298271209, + 0.0007040579803287983, + 0.0007042634533718228, + 0.0007044640369713306, + 0.0007049587438814342, + 0.0007049727137200534 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "K12": { + "normalized_time_brier": 2.0358788955629135, + "normalized_timepoint_brier": [ + 0.6838949047960341, + 0.6990796537138522, + 1.745857706146602, + 2.27811219312519, + 2.0491041005099544, + 1.928882316808211, + 2.08300171448461, + 2.4426507593677464, + 2.5905458613304733, + 2.5641810364784474, + 2.499580790769394, + 2.4588930396593063, + 2.442641565128051 + ], + "raw_time_brier": 0.0037527107812750796, + "raw_timepoint_brier": [ + 0.0006838949047960341, + 0.0006990796537138522, + 0.0018370774341747165, + 0.003346118377521634, + 0.00338485324755311, + 0.003475210862234235, + 0.0038568463642150164, + 0.004847726318985224, + 0.005270315799862146, + 0.005301952362060547, + 0.0053349826484918594, + 0.0053710490465164185, + 0.005376133136451244 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0010522492341196875, + 0.0014688119345567952, + 0.0016518698326311151, + 0.001801670756142753, + 0.001851580984017242, + 0.0019846170396622745, + 0.0020344421917145197, + 0.0020676981409011802, + 0.0021343509552454606, + 0.002184336187010643, + 0.002200950484591222 + ] + }, + "K20": { + "normalized_time_brier": 0.8581109570772537, + "normalized_timepoint_brier": [ + 0.3642167430371046, + 0.7294036857778367, + 0.8038810682234916, + 0.6847496536241495, + 0.7640289422890609, + 0.6995431037116904, + 0.769014340999094, + 0.8400482106835123, + 1.1290893287202488, + 1.075129953316651, + 1.128176609508805, + 1.089040073271805, + 1.079120728840848 + ], + "raw_time_brier": 0.0024235918670176314, + "raw_timepoint_brier": [ + 0.0003642167430371046, + 0.0010738411219790578, + 0.0014385938411578536, + 0.0014539434341713786, + 0.0018134369747713208, + 0.0018236296018585563, + 0.002171206520870328, + 0.0024977154098451138, + 0.003545063314959407, + 0.003554699709638953, + 0.003917535301297903, + 0.00392629811540246, + 0.003926514182239771 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0014722178444079464, + 0.0017895605432492931, + 0.002123321167781751, + 0.0023735186907163385, + 0.0026068866838692283, + 0.0028233628491889018, + 0.002973300077400113, + 0.003139754512583616, + 0.003306297716544049, + 0.0034724486115729277, + 0.003605283415886319, + 0.003638623628755134 + ] + }, + "K21": { + "normalized_time_brier": 0.9308859179266119, + "normalized_timepoint_brier": [ + 0.8545951219939354, + 0.994313434596293, + 0.9979059410519131, + 0.9947973372371243, + 0.9259001534737116, + 0.8867644972930333, + 0.8997910299113564, + 0.9185635139161038, + 0.8929507672604011, + 0.936649180503563, + 0.922032646523811, + 0.9412796094049131, + 0.9359736998797955 + ], + "raw_time_brier": 0.029085976143295948, + "raw_timepoint_brier": [ + 0.007681705057621002, + 0.015412136912345886, + 0.02036859840154648, + 0.02399563044309616, + 0.02566969208419323, + 0.027048062533140182, + 0.03021225333213806, + 0.03302435204386711, + 0.03424336761236191, + 0.03792915120720863, + 0.03910626843571663, + 0.041710786521434784, + 0.04171568527817726 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.008988706885780136, + 0.015500280269876328, + 0.020411340952710955, + 0.0241211245194321, + 0.027724039128720214, + 0.03050196824039302, + 0.03357696657090974, + 0.03595217047439069, + 0.038348550522467835, + 0.04049451170908738, + 0.04241310606858944, + 0.04431285465516966, + 0.044569292153758905 + ] + }, + "K22": { + "normalized_time_brier": 1.2496719851526552, + "normalized_timepoint_brier": [ + 0.3611573192756623, + 0.9258882648336667, + 1.278723901665985, + 1.1886531417766406, + 1.4328391121366328, + 1.4389789130110675, + 1.3172590812658653, + 1.3185288076792214, + 1.3758672908813818, + 1.360175648134525, + 1.3710901749459028, + 1.4429172857229424, + 1.4336568656550193 + ], + "raw_time_brier": 0.004780521408135358, + "raw_timepoint_brier": [ + 0.0003611573192756623, + 0.0014309262624010444, + 0.002864442765712738, + 0.0032257065176963806, + 0.004639158956706524, + 0.00499955378472805, + 0.004999430384486914, + 0.005360190756618977, + 0.006080040708184242, + 0.006423436105251312, + 0.006774908397346735, + 0.007493899669498205, + 0.007493926677852869 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0015454632235328161, + 0.002240079161718022, + 0.0027137492043095295, + 0.0032377389180761997, + 0.003474375989476086, + 0.0037953280835859105, + 0.004065281490552789, + 0.004419060434447397, + 0.004722504857413839, + 0.0049412566154622495, + 0.005193575365439987, + 0.005227141066582198 + ] + }, + "K25": { + "normalized_time_brier": 1.751429197002054, + "normalized_timepoint_brier": [ + 0.708197767380625, + 0.7124659605324268, + 1.0694972006604075, + 1.7941290279850364, + 1.8005692400038242, + 2.159138210117817, + 2.127742829009671, + 2.0969216390755476, + 2.0445332031932817, + 2.2402153045873887, + 2.0690402693405816, + 1.9729173470221197, + 1.973211562117973 + ], + "raw_time_brier": 0.0019256772625689895, + "raw_timepoint_brier": [ + 0.000708197767380625, + 0.0007124659605324268, + 0.0010694972006604075, + 0.0017941290279850364, + 0.0018005692400038242, + 0.002159138210117817, + 0.00217134109698236, + 0.0021750128362327814, + 0.002188857877627015, + 0.002547853160649538, + 0.002560340566560626, + 0.002573008881881833, + 0.0025733925867825747 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010204903841659195, + 0.001037240875243989, + 0.0010705905260957943, + 0.0011373251291660162, + 0.0012374532310947361, + 0.001304164559030047, + 0.001304164559030046 + ] + }, + "K26": { + "normalized_time_brier": 1.4789733076586455, + "normalized_timepoint_brier": [ + 0.00041998163169409963, + 0.7090342696756124, + 1.0623328853398561, + 1.0624792193993926, + 1.403984846547246, + 1.7553818179294467, + 1.7543379217386246, + 1.7535373335704207, + 2.0695328648442586, + 1.972695065095896, + 1.9131246895177136, + 1.8849615604039502, + 1.8848305438682793 + ], + "raw_time_brier": 0.0015411481781965309, + "raw_timepoint_brier": [ + 4.1998163169409963e-07, + 0.0007090342696756124, + 0.0010623328853398561, + 0.0010624792193993926, + 0.001403984846547246, + 0.0017553818179294467, + 0.0017543379217386246, + 0.0017535373335704207, + 0.002106445375829935, + 0.0021064335014671087, + 0.002106660045683384, + 0.0021070127841085196, + 0.0021068663336336613 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010178361559812458, + 0.001067794784271289, + 0.001101161914446078, + 0.0011178014599178263, + 0.00111780145991782 + ] + }, + "K29": { + "normalized_time_brier": 0.8346603240600978, + "normalized_timepoint_brier": [ + 0.015236635590554215, + 0.5956762310478677, + 0.6361940362640803, + 0.5730888047452356, + 0.7371987020886535, + 0.7826794134226769, + 1.0146985576991088, + 0.9730797684037181, + 1.0714220365971274, + 1.0990068910619621, + 1.1063262256276412, + 1.124716676912383, + 1.1212602333202628 + ], + "raw_time_brier": 0.003148977651038037, + "raw_timepoint_brier": [ + 1.5236635590554215e-05, + 0.0010916253086179495, + 0.0014460302190855145, + 0.001457588979974389, + 0.00217428058385849, + 0.002533407649025321, + 0.0036097897682338953, + 0.0036261368077248335, + 0.004353949334472418, + 0.004725357051938772, + 0.00505511648952961, + 0.0054229674860835075, + 0.005425223149359226 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.00183258161350109, + 0.002272938972482408, + 0.0025433911252591202, + 0.0029493820020277477, + 0.0032368395099938367, + 0.003557499654300598, + 0.003726453807248818, + 0.004063710830795219, + 0.0042996609851760756, + 0.004569281982501807, + 0.004821629835676353, + 0.0048385049145051 + ] + }, + "K30": { + "normalized_time_brier": 0.510409396745541, + "normalized_timepoint_brier": [ + 0.0007299707931451849, + 0.0029072857614664827, + 0.7051743450574577, + 0.7059465860947967, + 0.5989386595782296, + 0.5752070160236502, + 0.539463425672276, + 0.5202731033372989, + 0.4917579377789801, + 0.6612411088875768, + 0.6289000209780672, + 0.6052077261874694, + 0.5995749715416193 + ], + "raw_time_brier": 0.0007058735023100291, + "raw_timepoint_brier": [ + 7.299707931451849e-07, + 2.9072857614664827e-06, + 0.0007051743450574577, + 0.0007059465860947967, + 0.0007066297112032771, + 0.0007073065498843789, + 0.0007081266958266497, + 0.0007088167476467788, + 0.0007107456913217902, + 0.0010543324751779437, + 0.0010549381840974092, + 0.0010552937164902687, + 0.0010554075706750154 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.0011798031399423827, + 0.0012296556373284871, + 0.0013126500558294318, + 0.0013623936027060868, + 0.0014453161539839422, + 0.0015944750878415209, + 0.001677433851022562, + 0.0017436884408897654, + 0.0017602595517977764 + ] + }, + "K31": { + "normalized_time_brier": 1.25336300803153, + "normalized_timepoint_brier": [ + 1.07025564648211, + 1.0468982727169855, + 1.0810216711215, + 1.004049527701087, + 1.1194200633178006, + 1.1341427415849505, + 1.3928079342507664, + 1.4656823957771317, + 1.4418840933147306, + 1.3709328053657635, + 1.3594760820405842, + 1.405711186424286, + 1.4014366843121928 + ], + "raw_time_brier": 0.0047139788064389275, + "raw_timepoint_brier": [ + 0.00107025564648211, + 0.0017651686212047935, + 0.002465195953845978, + 0.0028347449842840433, + 0.003558908822014928, + 0.0039321789517998695, + 0.005323739256709814, + 0.006024060770869255, + 0.006389579735696316, + 0.00639848317950964, + 0.0066892001777887344, + 0.007414594758301973, + 0.007415613625198603 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0016860937372871017, + 0.00228043157662924, + 0.002823311904517889, + 0.0031792433766702666, + 0.0034670935214950968, + 0.0038223068133034542, + 0.004110072406017531, + 0.004431410101076423, + 0.004667247843560452, + 0.004920425056502791, + 0.0052746217216656805, + 0.005291436786413288 + ] + }, + "K40": { + "normalized_time_brier": 0.6601344959086328, + "normalized_timepoint_brier": [ + 0.00018540080759521516, + 0.0007182832177932141, + 0.0012205329085190897, + 0.3542124468367547, + 0.7070692372508347, + 0.7073743618093431, + 1.0594810592010617, + 0.9648073786346044, + 0.9508232461145627, + 0.8978726588282122, + 0.8506005556051388, + 1.0568219605732747, + 1.0305613250245336 + ], + "raw_time_brier": 0.0007576222248028094, + "raw_timepoint_brier": [ + 1.8540080759521516e-07, + 7.182832177932141e-07, + 1.2205329085190897e-06, + 0.0003542124468367547, + 0.0007070692372508347, + 0.0007073743618093431, + 0.0010594810592010617, + 0.0010598654625937343, + 0.0010602227412164211, + 0.0010607109870761633, + 0.0010610452154651284, + 0.0013885808875784278, + 0.0013884023064747453 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010985254529185464, + 0.001115057657192236, + 0.0011813601590903399, + 0.001247407150716324, + 0.0013139213030974393, + 0.0013472291970996419 + ] + }, + "K42": { + "normalized_time_brier": 1.0829682807786876, + "normalized_timepoint_brier": [ + 0.7088684942573309, + 0.7091981242410839, + 1.0647138115018606, + 1.0674037039279938, + 1.0683904401957989, + 0.9042371699495749, + 1.2505035400313802, + 1.1570848291571911, + 1.2600822065954504, + 1.1473444921305818, + 1.2926903059531674, + 1.2290427542757687, + 1.219027777905756 + ], + "raw_time_brier": 0.0016096033594714333, + "raw_timepoint_brier": [ + 0.0007088684942573309, + 0.0007091981242410839, + 0.0010647138115018606, + 0.0010674037039279938, + 0.0010683904401957989, + 0.0010716029210016131, + 0.0017736407462507486, + 0.0017760440241545439, + 0.0021229677367955446, + 0.0021239083725959063, + 0.002478949259966612, + 0.0024795630015432835, + 0.002479593036696315 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0011850905455051924, + 0.0014183412437251003, + 0.001534929833492153, + 0.0016847851082124863, + 0.0018511514084596135, + 0.0019176667826396009, + 0.0020174749762911235, + 0.002034074269378966 + ] + }, + "K43": { + "normalized_time_brier": 0.9293260441019269, + "normalized_timepoint_brier": [ + 0.35531201865524054, + 0.3554440045263618, + 0.710146501660347, + 1.3634413536792105, + 1.1597996134715143, + 0.9228811580804479, + 0.980900306759467, + 0.8572870421829337, + 1.045838520918207, + 1.2206317234531727, + 1.1143701192133932, + 1.0001266881801103, + 0.9950595225446409 + ], + "raw_time_brier": 0.001886230998654635, + "raw_timepoint_brier": [ + 0.00035531201865524054, + 0.0003554440045263618, + 0.000710146501660347, + 0.0014199581928551197, + 0.0014217138523235917, + 0.0014248837251216173, + 0.0017772604478523135, + 0.0017828226555138826, + 0.002489763777703047, + 0.0031909546814858913, + 0.003192863194271922, + 0.003199766855686903, + 0.0032001130748540163 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.0010414516099452316, + 0.0012258271479054172, + 0.001543951474841368, + 0.0018118665430167178, + 0.0020796099413496697, + 0.0023806388155574224, + 0.0026141829842490625, + 0.0028651730149814917, + 0.0031993615343965955, + 0.0032160016585444525 + ] + }, + "K44": { + "normalized_time_brier": 0.5580157907153676, + "normalized_timepoint_brier": [ + 0.3599576884880662, + 0.48480830780790735, + 0.6975104570465669, + 0.6086892463967161, + 0.664233143787348, + 0.6042921003526002, + 0.5328803509307183, + 0.5966386395317517, + 0.5486438141462124, + 0.5119658442484439, + 0.5764620302430914, + 0.5359380627791518, + 0.5321855935412065 + ], + "raw_time_brier": 0.0017977059648658794, + "raw_timepoint_brier": [ + 0.0003599576884880662, + 0.0007215486257337034, + 0.0014381209621205926, + 0.00143975461833179, + 0.0017948993481695652, + 0.0017953558126464486, + 0.0017984439618885517, + 0.0021537269931286573, + 0.0021555875428020954, + 0.00215761736035347, + 0.0025163949467241764, + 0.0025192343164235353, + 0.00251953536644578 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0014883173702122247, + 0.0020617912571661724, + 0.002365336050956654, + 0.0027022128675111643, + 0.0029710065903540213, + 0.003374948914418453, + 0.003609767873597535, + 0.003928938023581973, + 0.004214377549972715, + 0.004365239711734395, + 0.004700607199570477, + 0.004734317119861485 + ] + }, + "K52": { + "normalized_time_brier": 2.4703974029341014, + "normalized_timepoint_brier": [ + 1.4487190637737513, + 1.943272129799946, + 2.5346922753473464, + 2.6524450240975317, + 2.687431232080196, + 2.582790965718137, + 2.6938492760369304, + 2.6437754030019267, + 2.6511723726174337, + 2.540288594812287, + 2.6428720602379525, + 2.518974024728267, + 2.5748838158916145 + ], + "raw_time_brier": 0.009836919820652558, + "raw_timepoint_brier": [ + 0.0014487190637737513, + 0.0036147136706858873, + 0.006033268291503191, + 0.008105243556201458, + 0.009187659248709679, + 0.00994632113724947, + 0.011025840416550636, + 0.011779196560382843, + 0.012543228454887867, + 0.012588303536176682, + 0.013688215985894203, + 0.013784495182335377, + 0.014134752564132214 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0018601170753465245, + 0.0023802764344150653, + 0.0030557630723973958, + 0.0034187513857230887, + 0.003850997339416481, + 0.0040929685690401195, + 0.004455445249625941, + 0.0047312006508668705, + 0.00495546197462926, + 0.00517929573354443, + 0.005472265710966342, + 0.0054894719819572595 + ] + }, + "K55": { + "normalized_time_brier": 1.4766132371750442, + "normalized_timepoint_brier": [ + 0.7107915007509291, + 1.7728750826790929, + 1.82201210455132, + 1.8609708307113408, + 1.8314055760240104, + 1.5940069232199405, + 1.460514304465248, + 1.3472135120028899, + 1.2890304455734947, + 1.3682272809262632, + 1.4375764624943799, + 1.3506461052075724, + 1.350701954669091 + ], + "raw_time_brier": 0.0027204550256451163, + "raw_timepoint_brier": [ + 0.0007107915007509291, + 0.0017728750826790929, + 0.0021343203261494637, + 0.0024911074433475733, + 0.002848854288458824, + 0.002851532306522131, + 0.0028561821673065424, + 0.0028595803305506706, + 0.0028650430031120777, + 0.003223600098863244, + 0.0035783632192760706, + 0.003586758626624942, + 0.0035869069397449493 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001171408423038469, + 0.0013386063887929763, + 0.0015555561945179283, + 0.0017889083572874026, + 0.001955600269421739, + 0.0021225888139285057, + 0.002222634083586295, + 0.0023560413856687098, + 0.0024891637506829728, + 0.0026555872872958937, + 0.002655587287295891 + ] + }, + "K56": { + "normalized_time_brier": 2.392392512478062, + "normalized_timepoint_brier": [ + 2.525634365156293, + 2.059331309587262, + 2.483358394897618, + 2.614537503906764, + 2.432192426613472, + 2.4956779092880623, + 2.549515878119692, + 2.4453683223392875, + 2.2710875437896267, + 2.3842180313246177, + 2.2334269366813175, + 2.2791303291808953, + 2.3276237113298963 + ], + "raw_time_brier": 0.008235129706848126, + "raw_timepoint_brier": [ + 0.002525634365156293, + 0.0036208147648721933, + 0.005391834769397974, + 0.006844877265393734, + 0.0075358315370976925, + 0.008246425539255142, + 0.009298545308411121, + 0.009589061141014099, + 0.009606295265257359, + 0.010656257160007954, + 0.010669892653822899, + 0.011355414986610413, + 0.011715801432728767 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0017582478098669269, + 0.0021711867205620413, + 0.002618006915244397, + 0.003098369789593667, + 0.0033042827796667023, + 0.0036471807797757057, + 0.003921315678057453, + 0.004229821651537005, + 0.004469497764047853, + 0.0047773636462348085, + 0.004982345608419627, + 0.005033374327517441 + ] + }, + "K57": { + "normalized_time_brier": 3.20026022810901, + "normalized_timepoint_brier": [ + 1.0954755125567317, + 1.468135858885944, + 3.4033255541223255, + 3.294916638876729, + 3.5338514817628752, + 3.56723053918228, + 3.498601723248155, + 3.719666115097263, + 3.603861954609009, + 3.496532491198328, + 3.6625999916161396, + 3.6535828054472352, + 3.6056022988141194 + ], + "raw_time_brier": 0.006326834563739025, + "raw_timepoint_brier": [ + 0.0010954755125567317, + 0.0014681358588859439, + 0.003647781675681472, + 0.004384324885904789, + 0.0057989018969237804, + 0.006529942620545626, + 0.007248640060424805, + 0.00796266458928585, + 0.007962986826896667, + 0.008327306248247623, + 0.009037521667778492, + 0.009392613545060158, + 0.009392553940415382 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001071828603426741, + 0.0013306330224486197, + 0.0016409580105021778, + 0.0018305356350875185, + 0.002071867744264145, + 0.002140693369484761, + 0.0022095704350475294, + 0.0023815898377062407, + 0.0024675153411417563, + 0.0025707953111275953, + 0.002604988892841728 + ] + }, + "K58": { + "normalized_time_brier": 2.205988778952261, + "normalized_timepoint_brier": [ + 1.075242180377245, + 1.7854096367955208, + 1.7857961356639862, + 1.7868324648588896, + 2.4967824574559927, + 2.496997592970729, + 2.498209709301591, + 2.501030918210745, + 2.5040965992957354, + 2.507106401026249, + 2.5090319104492664, + 2.3655728326496486, + 2.3657452873237936 + ], + "raw_time_brier": 0.0022282538971362207, + "raw_timepoint_brier": [ + 0.001075242180377245, + 0.0017854096367955208, + 0.0017857961356639862, + 0.0017868324648588896, + 0.0024967824574559927, + 0.002496997592970729, + 0.002498209709301591, + 0.002501030918210745, + 0.0025040965992957354, + 0.002507106401026249, + 0.0025090319104492664, + 0.002510290825739503, + 0.002510473830625415 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001061176722649354, + 0.0010611767226493527 + ] + }, + "K59": { + "normalized_time_brier": 1.271459235382226, + "normalized_timepoint_brier": [ + 1.583773783771957, + 1.347359293274341, + 1.3305966311044863, + 1.4337606515365964, + 1.312422210166059, + 1.2450131816973908, + 1.2643084925436834, + 1.2046640990724344, + 1.213102268425645, + 1.182083801762077, + 1.1499283713310773, + 1.1323657624370178, + 1.1295915128461702 + ], + "raw_time_brier": 0.02568180851924878, + "raw_timepoint_brier": [ + 0.011101489886641502, + 0.01510994415730238, + 0.019343942403793335, + 0.024601582437753677, + 0.025191139429807663, + 0.02609226666390896, + 0.028213709592819214, + 0.028202619403600693, + 0.029809003695845604, + 0.030518854036927223, + 0.03125222399830818, + 0.03221471607685089, + 0.032212018966674805 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.007009517394713975, + 0.011214487652051831, + 0.014537796016916515, + 0.017158779194691637, + 0.01919438671082857, + 0.020957422015673778, + 0.02231552643932303, + 0.023411189413975318, + 0.02457253973692713, + 0.02581784302554032, + 0.02717753972982924, + 0.0284490375331731, + 0.02851651999890822 + ] + }, + "K62": { + "normalized_time_brier": 1.2536031639983531, + "normalized_timepoint_brier": [ + 0.3563213685993105, + 0.5495038746969131, + 0.9688892307950264, + 1.2247222687424424, + 1.364539385974118, + 1.4180978422128272, + 1.4247601357472572, + 1.4981836806740052, + 1.411327437891827, + 1.3589645377441488, + 1.4919007976837244, + 1.6217045517512172, + 1.6079260194657743 + ], + "raw_time_brier": 0.003863319600126348, + "raw_timepoint_brier": [ + 0.0003563213685993105, + 0.0007089818245731294, + 0.001768660033121705, + 0.002828632714226842, + 0.003516127821058035, + 0.003866831073537469, + 0.004217593930661678, + 0.0049098823219537735, + 0.004907424561679363, + 0.004906284157186747, + 0.005609652493149042, + 0.006313473917543888, + 0.00631328858435154 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001290221702193053, + 0.0018254512248736866, + 0.002309611563715022, + 0.0025767873446525254, + 0.0027267731170816756, + 0.002960213319310508, + 0.0032772232038630325, + 0.003477169386722785, + 0.0036103106600052053, + 0.003760070711040843, + 0.0038931098212224955, + 0.003926355135697785 + ] + }, + "K63": { + "normalized_time_brier": 2.047836064312945, + "normalized_timepoint_brier": [ + 0.7107937126420438, + 2.065518906679647, + 2.3313757013701446, + 2.5985960092171743, + 2.3343808238444894, + 2.1944020308161516, + 2.173296391803905, + 1.9958231013908745, + 1.912239585449107, + 1.8142897844023798, + 2.1116850630084607, + 2.205895090327905, + 2.173572635115999 + ], + "raw_time_brier": 0.004884347530046048, + "raw_timepoint_brier": [ + 0.0007107937126420438, + 0.002131254645064473, + 0.003546994412317872, + 0.004610834177583456, + 0.004614264704287052, + 0.004965909291058779, + 0.005320905242115259, + 0.005323560442775488, + 0.005325774196535349, + 0.005327681079506874, + 0.006733821704983711, + 0.007442213129252195, + 0.007442511152476072 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0010318252900867887, + 0.0015214169085803334, + 0.0017743559065083255, + 0.0019766546474143084, + 0.002262989744505402, + 0.002448310898679926, + 0.002667350848412135, + 0.0027850977655002065, + 0.0029365105427531205, + 0.0031888380625234984, + 0.0033737838040819586, + 0.003424091301222552 + ] + }, + "K64": { + "normalized_time_brier": 2.629400312936379, + "normalized_timepoint_brier": [ + 0.7207294693216681, + 1.8018274568021297, + 2.5400716751168413, + 2.6879363278360553, + 2.8414887203893375, + 3.1033010980727163, + 2.95490546672414, + 2.8259925081793527, + 2.9214046369738305, + 3.012617889088811, + 3.0526023806480844, + 2.868242627722725, + 2.851083811297234 + ], + "raw_time_brier": 0.0054656162660998795, + "raw_timepoint_brier": [ + 0.0007207294693216681, + 0.0018018274568021297, + 0.003257148200646043, + 0.003990156576037407, + 0.004696249961853027, + 0.005755960009992123, + 0.006127063184976578, + 0.006429828237742186, + 0.007138521410524845, + 0.007513164076954126, + 0.007869458757340908, + 0.007876148447394371, + 0.00787675566971302 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0012823056264726139, + 0.0014844684134499996, + 0.00165274277816227, + 0.0018547861867373495, + 0.0020735225725407548, + 0.0022752460309544862, + 0.002443523680416747, + 0.0024938987795848676, + 0.002577950802642753, + 0.0027459840291292692, + 0.0027627232978918014 + ] + }, + "K65": { + "normalized_time_brier": 0.7492499516521908, + "normalized_timepoint_brier": [ + 0.9609091817135028, + 0.7867140365615207, + 0.8314991110805892, + 0.728399834547236, + 0.657900323724732, + 0.6642876295044992, + 0.6932455206032961, + 0.7321036622412097, + 0.7120105601434774, + 0.7469007213323937, + 0.7222207028021381, + 0.7541702494079355, + 0.7498878378159497 + ], + "raw_time_brier": 0.0038888250889543155, + "raw_timepoint_brier": [ + 0.0017741305055096745, + 0.002530880505219102, + 0.003243695478886366, + 0.0032903961837291718, + 0.00332206254824996, + 0.003652405459433794, + 0.0040184915997087955, + 0.004389304667711258, + 0.004410752095282078, + 0.004775015637278557, + 0.00479690870270133, + 0.005171419586986303, + 0.005179263185709715 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0018463040412893415, + 0.0032170272647997784, + 0.0039010209820560904, + 0.004517293974640233, + 0.0050494921927412275, + 0.005498228925560711, + 0.005796635506871661, + 0.005995468803248648, + 0.006194784659364134, + 0.006393106206619298, + 0.0066418875616412595, + 0.006857098368765074, + 0.0069067171442523095 + ] + }, + "K66": { + "normalized_time_brier": 1.1443476123985084, + "normalized_timepoint_brier": [ + 0.3578204195946455, + 0.3613678563851863, + 1.2767573782905983, + 1.6054225710342251, + 1.3120142755920898, + 1.1715913060205598, + 1.2441162980980802, + 1.3234285306019598, + 1.2482143141781008, + 1.3243851342580522, + 1.2574577418158415, + 1.1969334907508753, + 1.1970096445603937 + ], + "raw_time_brier": 0.0022916760264286916, + "raw_timepoint_brier": [ + 0.0003578204195946455, + 0.0003613678563851863, + 0.0014202249003574252, + 0.002137145958840847, + 0.002143830293789506, + 0.002150676678866148, + 0.002513740910217166, + 0.0028741646092385054, + 0.0028784333262592554, + 0.0032319980673491955, + 0.0032375932205468416, + 0.003242292907088995, + 0.0032424991950392723 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0011123686649525458, + 0.0013312046294852338, + 0.001633999213020782, + 0.001835688492919225, + 0.002020503158796329, + 0.002171756572250407, + 0.0023060409527145896, + 0.0024403762800915365, + 0.0025747133385743606, + 0.0027088329737143535, + 0.0027088329737143366 + ] + }, + "K70": { + "normalized_time_brier": 0.7003311526665787, + "normalized_timepoint_brier": [ + 0.001393709794683673, + 0.36390096647664905, + 0.3662815724965185, + 0.36804674891754985, + 0.37201386294327676, + 0.3735443751793355, + 0.37514467840082943, + 0.3615325390337611, + 0.6741426479842012, + 0.9697200432546296, + 1.511894670017421, + 1.683352469887831, + 1.6833367002788364 + ], + "raw_time_brier": 0.0008136436842523136, + "raw_timepoint_brier": [ + 1.393709794683673e-06, + 0.00036390096647664905, + 0.0003662815724965185, + 0.00036804674891754985, + 0.00037201386294327676, + 0.0003735443751793355, + 0.00037514467840082943, + 0.0003790226182900369, + 0.000740810006391257, + 0.0010982698295265436, + 0.001814383896999061, + 0.0021622879430651665, + 0.0021622676867991686 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010483776074569115, + 0.0010988920647676012, + 0.0011325638127891715, + 0.0012000729501732781, + 0.0012845128882659072, + 0.0012845128882659064 + ] + }, + "K72": { + "normalized_time_brier": 2.162298543458326, + "normalized_timepoint_brier": [ + 1.3466901145875454, + 1.9670510664582253, + 2.49203167048806, + 2.6928609282842415, + 2.6112767158412513, + 2.335915746105591, + 2.3586282886190704, + 2.1176196476445126, + 1.9434037103218222, + 2.0460933990732233, + 2.050549590285196, + 2.073884243298493, + 2.0738759439510046 + ], + "raw_time_brier": 0.004925001932021517, + "raw_timepoint_brier": [ + 0.0013466901145875454, + 0.0019670510664582253, + 0.0031803150195628405, + 0.004203761462122202, + 0.004819622728973627, + 0.004818889778107405, + 0.005615123547613621, + 0.005607892293483019, + 0.005600885022431612, + 0.006272369064390659, + 0.006629028357565403, + 0.0069817123003304005, + 0.006981684360653162 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0012761936604682, + 0.001561076332597923, + 0.001845695900298691, + 0.002062955303992191, + 0.0023806733662560977, + 0.0026482056396297765, + 0.002881997699543406, + 0.003065534089124047, + 0.0032328056775468763, + 0.0033664908361645367, + 0.0033664908361645493 + ] + }, + "K74": { + "normalized_time_brier": 1.592896336322577, + "normalized_timepoint_brier": [ + 0.36863566492684186, + 1.1009711306542158, + 1.8288104329258204, + 2.1406749729067087, + 1.860027782514981, + 1.7342060421912848, + 1.8724450070885492, + 1.7845026339764607, + 1.7467795001089566, + 1.6606522175274583, + 1.5460696357786528, + 1.5318695002866092, + 1.5320078513069586 + ], + "raw_time_brier": 0.0021135960190664404, + "raw_timepoint_brier": [ + 0.00036863566492684186, + 0.0011009711306542158, + 0.0018288104329258204, + 0.0021406749729067087, + 0.0021494345273822546, + 0.0021513267420232296, + 0.0025132109876722097, + 0.002516181906685233, + 0.0025222934782505035, + 0.002538712229579687, + 0.0025470214895904064, + 0.00254962220788002, + 0.002549852477386594 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.0011555927000595448, + 0.0012405254564243618, + 0.0013422081706848004, + 0.001410018600576873, + 0.0014439678723577726, + 0.001528744069820694, + 0.0016474170571933136, + 0.0016643860377160012, + 0.0016643860377160014 + ] + }, + "K75": { + "normalized_time_brier": 1.5382687267047233, + "normalized_timepoint_brier": [ + 0.7146499119699001, + 1.4222169993445277, + 1.2986682980214888, + 1.9088870304155987, + 1.985065973437158, + 1.8170962113154567, + 1.702322213083294, + 1.6013089611757487, + 1.5017894117169353, + 1.4229478294693023, + 1.502306418133885, + 1.5694662372468238, + 1.5507679518312831 + ], + "raw_time_brier": 0.003151055908976839, + "raw_timepoint_brier": [ + 0.0007146499119699001, + 0.0014222169993445277, + 0.0017836432671174407, + 0.0031956809107214212, + 0.0035553572233766317, + 0.003557597054168582, + 0.003560418961569667, + 0.003562897676602006, + 0.003566891886293888, + 0.0035697210114449263, + 0.003919119015336037, + 0.004277484025806189, + 0.004278048872947693 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001373440215515238, + 0.001674106879978992, + 0.0017910524239254887, + 0.001957847378699402, + 0.0020915070802729734, + 0.0022249907812830674, + 0.0023750945761536594, + 0.00250868017612162, + 0.0026087347880762142, + 0.002725438702848302, + 0.0027586647427784387 + ] + }, + "K76": { + "normalized_time_brier": 1.5408312252173089, + "normalized_timepoint_brier": [ + 2.2031037182959983, + 1.7926442769682205, + 1.6010880111047427, + 1.4029343337222882, + 1.4823383342554177, + 1.3110390019907452, + 1.4922309036849262, + 1.5308802541992785, + 1.502839681292773, + 1.46157195942487, + 1.4364527929679487, + 1.3872996426968869, + 1.4263830172209158 + ], + "raw_time_brier": 0.008283331649951063, + "raw_timepoint_brier": [ + 0.003488601418212056, + 0.004858946427702904, + 0.005751877091825008, + 0.006057645194232464, + 0.007117211818695068, + 0.007106967270374298, + 0.008934419602155685, + 0.00987659115344286, + 0.01018571387976408, + 0.010534019209444523, + 0.010894234292209148, + 0.011255811899900436, + 0.011621272191405296 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001583493954115938, + 0.002710491138777692, + 0.003592480270872956, + 0.004317839437402762, + 0.004801340999030469, + 0.005420866396486096, + 0.005987290291397238, + 0.006451576553000075, + 0.006777645018663683, + 0.007207321638538871, + 0.007584122740086614, + 0.008113468463106737, + 0.008147371394008552 + ] + }, + "K80": { + "normalized_time_brier": 1.581281112884695, + "normalized_timepoint_brier": [ + 0.7316155824810266, + 1.0816047983251176, + 1.436221830608529, + 1.3432365205735017, + 1.3534934078092702, + 1.7238867585135442, + 1.7645828681349789, + 1.6611227580756536, + 1.710281008850626, + 1.7344986423097832, + 2.0838784941471866, + 1.9761977543877438, + 1.9560340432840724 + ], + "raw_time_brier": 0.0038694994918142375, + "raw_timepoint_brier": [ + 0.0007316155824810266, + 0.0010993489995598793, + 0.0018302532844245434, + 0.0021968092769384384, + 0.0025622937828302383, + 0.003648256417363882, + 0.004370007663965225, + 0.004370131064206362, + 0.004734186455607414, + 0.005098643712699413, + 0.00655415328219533, + 0.006553887855261564, + 0.006553906016051769 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001016405438716839, + 0.0012743527813172584, + 0.001635459759536987, + 0.001893096610627385, + 0.002116297024353075, + 0.0024765103089683565, + 0.0026308296861027834, + 0.002768075205833554, + 0.00293954897878138, + 0.0031451705560585352, + 0.0033164129656103464, + 0.00335060938154641 + ] + }, + "K81": { + "normalized_time_brier": 0.7559305158930341, + "normalized_timepoint_brier": [ + 0.0019423177946009673, + 0.5904097190034393, + 1.0385491363421164, + 1.0746995837737712, + 0.9662673078177425, + 0.8705211534621047, + 0.8229804798236706, + 0.7861513427888948, + 0.736668686288297, + 0.6886754622441618, + 0.6798126204971658, + 0.7900693685390798, + 0.7803495282343968 + ], + "raw_time_brier": 0.0015664130725361667, + "raw_timepoint_brier": [ + 1.9423177946009673e-06, + 0.0006995710427872837, + 0.0014035963686183095, + 0.0017565820598974824, + 0.0017562498105689883, + 0.0017560914857313037, + 0.0017558244289830327, + 0.0017556706443428993, + 0.001755329198203981, + 0.001755405217409134, + 0.0017554310616105795, + 0.0021058120764791965, + 0.002105864230543375 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0011848907974755212, + 0.0013514973143802607, + 0.0016344865918057807, + 0.0018175610375718645, + 0.002017287550965583, + 0.0021334946235410475, + 0.002233247657015514, + 0.0023827932839770916, + 0.002548958564152785, + 0.0025822278208468444, + 0.002665350867067611, + 0.0026986166510641215 + ] + }, + "K82": { + "normalized_time_brier": 0.8492208159626731, + "normalized_timepoint_brier": [ + 0.35415124148130417, + 0.35451960866339505, + 0.7083100499585271, + 0.9972029320068351, + 1.1986089935725683, + 1.1200703002399133, + 1.014067763731097, + 0.9468007210077374, + 0.92635565354332, + 0.9164469964502888, + 0.8702544173577201, + 0.8204332186951706, + 0.8126487108068746 + ], + "raw_time_brier": 0.0011728165711526973, + "raw_timepoint_brier": [ + 0.00035415124148130417, + 0.00035451960866339505, + 0.0007083100499585271, + 0.0010627559386193752, + 0.0014169916976243258, + 0.001417325809597969, + 0.0014180428115651011, + 0.0014183660969138145, + 0.0014185128966346383, + 0.0014185660984367132, + 0.0014192858943715692, + 0.0014198865974321961, + 0.0014199006836861372 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.0010657368771275241, + 0.00118219678412461, + 0.0012653900467625872, + 0.0013983708606884848, + 0.0014980619104347128, + 0.001531283250886214, + 0.001547897591384229, + 0.0016308861708290167, + 0.0017306546895924147, + 0.0017472502753081653 + ] + }, + "K83": { + "normalized_time_brier": 1.156221695442373, + "normalized_timepoint_brier": [ + 0.3906274796463549, + 0.9231030850012288, + 0.9970878387010724, + 1.1693233530841898, + 1.1569374256460452, + 1.1891988188887004, + 1.212640980272932, + 1.2434696625732757, + 1.2499722428120699, + 1.3616307115592563, + 1.4317077362218513, + 1.357861306704048, + 1.3473213996398221 + ], + "raw_time_brier": 0.003558499644546268, + "raw_timepoint_brier": [ + 0.0003906274796463549, + 0.0013904744992032647, + 0.001757315592840314, + 0.002499862341210246, + 0.0028680614195764065, + 0.003231786424294114, + 0.003605566220358014, + 0.003972811624407768, + 0.00433380389586091, + 0.005044747609645128, + 0.005718210246413946, + 0.005722888745367527, + 0.005724339280277491 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001506304682322033, + 0.001762448126064406, + 0.0021378708760212877, + 0.0024790117045222675, + 0.002717616577616685, + 0.002973317147459836, + 0.0031949405313084238, + 0.0034671201066922308, + 0.0037049308353717956, + 0.003993978730256632, + 0.0042146342318706755, + 0.0042486813330566645 + ] + }, + "K85": { + "normalized_time_brier": 1.6558279235469147, + "normalized_timepoint_brier": [ + 0.35996001679450274, + 0.7198360399343073, + 0.7213599164970219, + 1.0740285506471992, + 1.0738825658336282, + 1.4266808284446597, + 1.4273417182266712, + 1.786400331184268, + 2.5136395588358966, + 2.5909042120423518, + 2.765631527960262, + 2.5330449796029484, + 2.5330527601061723 + ], + "raw_time_brier": 0.0019490478040937048, + "raw_timepoint_brier": [ + 0.00035996001679450274, + 0.0007198360399343073, + 0.0007213599164970219, + 0.0010740285506471992, + 0.0010738825658336282, + 0.0014266808284446597, + 0.0014273417182266712, + 0.001786400331184268, + 0.0028548184782266617, + 0.003205665620043874, + 0.0035623356234282255, + 0.0035626504104584455, + 0.0035626613534986973 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001135731043136817, + 0.0012372767797219795, + 0.0012880731172657542, + 0.001406469462305753, + 0.0014064694623057788 + ] + }, + "K86": { + "normalized_time_brier": 1.18287278193327, + "normalized_timepoint_brier": [ + 0.3617049951571971, + 1.4307800447568297, + 1.3610475891238032, + 1.3727391325241458, + 1.2455120285460395, + 1.31854521062318, + 1.4218554054057333, + 1.2985031955472057, + 1.225356506574997, + 1.160609441872372, + 1.0946208153231807, + 1.0572787197419398, + 1.0287930799358869 + ], + "raw_time_brier": 0.0020451533200684935, + "raw_timepoint_brier": [ + 0.0003617049951571971, + 0.0014307800447568297, + 0.0014320015907287598, + 0.0017932318150997162, + 0.0017957502277567983, + 0.0021466081961989403, + 0.0025074139703065157, + 0.0025097252801060677, + 0.002513563958927989, + 0.0025182748213410378, + 0.0025232371408492327, + 0.002526662778109312, + 0.002528038341552019 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0010521319035219294, + 0.0013063165262888535, + 0.0014417767043591579, + 0.0016280125845547573, + 0.0017634802813096266, + 0.0019327832913406406, + 0.002051291967228109, + 0.002169786605628841, + 0.002305124391503793, + 0.002389779280458817, + 0.00245728552306122 + ] + }, + "K90": { + "normalized_time_brier": 0.6810062667892243, + "normalized_timepoint_brier": [ + 0.3534142451826483, + 0.353874231223017, + 0.3540826728567481, + 0.3542607300914824, + 0.354492716724053, + 0.3549740940798074, + 0.3553153946995735, + 0.7094868924468756, + 0.7098925998434424, + 1.0628210147842765, + 1.0628725867718458, + 1.4137672260403633, + 1.4138270635157824 + ], + "raw_time_brier": 0.0006810062667892242, + "raw_timepoint_brier": [ + 0.0003534142451826483, + 0.000353874231223017, + 0.0003540826728567481, + 0.0003542607300914824, + 0.000354492716724053, + 0.0003549740940798074, + 0.0003553153946995735, + 0.0007094868924468756, + 0.0007098925998434424, + 0.0010628210147842765, + 0.0010628725867718458, + 0.0014137672260403633, + 0.0014138270635157824 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "K91": { + "normalized_time_brier": 2.3841470655732975, + "normalized_timepoint_brier": [ + 2.788924402024342, + 2.6966725977437562, + 2.5387385348638123, + 2.31053057054161, + 2.3080813350992413, + 2.176579289828633, + 2.282452464817583, + 2.3889586039882995, + 2.2565055945981394, + 2.334379523491029, + 2.390560560082793, + 2.265718834767161, + 2.255809540606467 + ], + "raw_time_brier": 0.00672098992464061, + "raw_timepoint_brier": [ + 0.0028516186866909266, + 0.004622851964086294, + 0.004966632928699255, + 0.0053187585435807705, + 0.005950327031314373, + 0.005949307233095169, + 0.006985935382544994, + 0.007682466879487038, + 0.007683759555220604, + 0.008351084776222706, + 0.009004874154925346, + 0.009002904407680035, + 0.009002347476780415 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0010224797361380888, + 0.0017142800234459785, + 0.0019563388905528565, + 0.0023019641511750283, + 0.0025780404446009374, + 0.002733328972161438, + 0.0030607145122311767, + 0.003215822520600137, + 0.003405158654875395, + 0.003577432329312839, + 0.003766846280862878, + 0.003973531167915293, + 0.003990739162473869 + ] + }, + "K92": { + "normalized_time_brier": 0.9133810193570256, + "normalized_timepoint_brier": [ + 0.8835616849937354, + 0.7910757745816598, + 0.900652848232149, + 0.8606687840340799, + 0.9112849178791504, + 0.92816841412501, + 0.957851617523753, + 0.9210217032186225, + 0.9449528091458079, + 0.9555092539270207, + 0.9477500558168063, + 0.938596267816457, + 0.9328591203470802 + ], + "raw_time_brier": 0.009089509365507044, + "raw_timepoint_brier": [ + 0.0025147225242108107, + 0.003927183803170919, + 0.005975283682346344, + 0.006694160867482424, + 0.00801964569836855, + 0.009022501297295094, + 0.010047747753560543, + 0.01036685798317194, + 0.011389230377972126, + 0.012102790176868439, + 0.012460554018616676, + 0.012821963988244534, + 0.012820979580283165 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.002846119933582951, + 0.004964358572663548, + 0.006634391590583386, + 0.007777859487485903, + 0.008800371366874822, + 0.009720758819185481, + 0.010489879193957071, + 0.011255823773689253, + 0.012052697518585552, + 0.012666324399400132, + 0.013147510719878257, + 0.013660787313882518, + 0.013743746832333035 + ] + }, + "K94": { + "normalized_time_brier": 2.4402558621147286, + "normalized_timepoint_brier": [ + 1.7850396689027548, + 2.741160336881876, + 3.1677650440240352, + 2.851173582730714, + 2.8008710805982995, + 2.5323898212782177, + 2.543390053335401, + 2.439028598028618, + 2.321920262225, + 2.1669817769594015, + 2.104625227046573, + 2.134442199365369, + 2.1345385561152055 + ], + "raw_time_brier": 0.004265832141614878, + "raw_timepoint_brier": [ + 0.0017850396689027548, + 0.002741160336881876, + 0.003745505353435874, + 0.00408215494826436, + 0.0044291215017437935, + 0.004425078630447388, + 0.004782548639923334, + 0.004788924008607864, + 0.004790582228451967, + 0.0047945501282811165, + 0.004796475172042847, + 0.005147222429513931, + 0.005147454794496298 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0011823810482730535, + 0.0014317455005158517, + 0.001581337153439308, + 0.0017473923616601174, + 0.0018803834801710815, + 0.0019634554561921026, + 0.0020631984251954245, + 0.002212547506979309, + 0.0022790162877472275, + 0.00241150705839884, + 0.0024115070583988455 + ] + }, + "L02": { + "normalized_time_brier": 2.796693943488215, + "normalized_timepoint_brier": [ + 1.0749921202659607, + 3.0899964491838827, + 3.035376279068585, + 2.783590375629627, + 2.930058455013138, + 3.0512438978595666, + 2.8337520697643854, + 2.8703961654959858, + 2.834902588703943, + 2.688865660335797, + 2.866727427443262, + 3.159175828455658, + 3.1379439481270044 + ], + "raw_time_brier": 0.005122108617797494, + "raw_timepoint_brier": [ + 0.0010749921202659607, + 0.003191117662936449, + 0.0035387238021939993, + 0.0038928366266191006, + 0.004584742709994316, + 0.005281364545226097, + 0.005281461868435144, + 0.005635945592075586, + 0.0059894961304962635, + 0.005993778817355633, + 0.006675804499536753, + 0.00772355729714036, + 0.007723590359091759 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001032725349499762, + 0.0011658270595960077, + 0.0013984947859789069, + 0.001564727386974182, + 0.001730889015109854, + 0.0018637699200248932, + 0.0019634730772787705, + 0.0021127696430777655, + 0.0022291105523684304, + 0.002328719652810061, + 0.0024448013395050473, + 0.002461353831288753 + ] + }, + "L03": { + "normalized_time_brier": 2.7333551922671626, + "normalized_timepoint_brier": [ + 2.577481997740182, + 2.1536700760803784, + 2.901067786582111, + 2.7877729076583573, + 2.66673477785687, + 2.753384700665849, + 2.7716816277583796, + 2.6567539891229917, + 2.7801898460665306, + 2.809978210974346, + 2.854283598773036, + 2.8656958001221913, + 2.9549221800718906 + ], + "raw_time_brier": 0.011652969003010254, + "raw_timepoint_brier": [ + 0.002589693758636713, + 0.004058183636516333, + 0.007708630990236998, + 0.009069317951798439, + 0.009796748869121075, + 0.01122258510440588, + 0.012605361640453339, + 0.012963651679456234, + 0.014682023786008358, + 0.01537765096873045, + 0.016466237604618073, + 0.0171304140239954, + 0.01781809702515602 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0010047378646707282, + 0.0018843107315221269, + 0.0026571702412093276, + 0.0032532484718837394, + 0.0036736869937228117, + 0.004075923390469894, + 0.0045479110999657015, + 0.004879507749882255, + 0.005280942884810829, + 0.005472516088798541, + 0.00576895638951097, + 0.005977750333187832, + 0.0060299716673833095 + ] + }, + "L08": { + "normalized_time_brier": 1.6259943077757095, + "normalized_timepoint_brier": [ + 1.059197005815804, + 1.0590952588245273, + 1.4112683711573482, + 1.764287007972598, + 1.7645849147811532, + 1.7653879476711154, + 1.7662282334640622, + 1.7683483893051744, + 1.7692090477794409, + 1.7700602766126394, + 1.7464996298784865, + 1.746854174865099, + 1.7469057429567783 + ], + "raw_time_brier": 0.001631484725154363, + "raw_timepoint_brier": [ + 0.001059197005815804, + 0.0010590952588245273, + 0.0014112683711573482, + 0.001764287007972598, + 0.0017645849147811532, + 0.0017653879476711154, + 0.0017662282334640622, + 0.0017683483893051744, + 0.0017692090477794409, + 0.0017700602766126394, + 0.001770287984982133, + 0.0017706473590806127, + 0.001770699629560113 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010136205898339076, + 0.001013620589833923, + 0.0010136205898339207 + ] + }, + "L27": { + "normalized_time_brier": 2.4928023364812217, + "normalized_timepoint_brier": [ + 1.0756906121969223, + 1.7948090098798275, + 1.8756985664367676, + 2.6414925393636866, + 2.496768358358525, + 2.3765544024370113, + 2.536034863639761, + 2.58870188325088, + 2.7577183593988024, + 2.9796103448990485, + 3.0891733172783167, + 3.096654845795497, + 3.0975232713208376 + ], + "raw_time_brier": 0.00315694623770049, + "raw_timepoint_brier": [ + 0.0010756906121969223, + 0.0017948090098798275, + 0.0018756985664367676, + 0.0027022724971175194, + 0.002721527824178338, + 0.0027496980037540197, + 0.003104182193055749, + 0.0033853657077997923, + 0.0037910144310444593, + 0.004145959857851267, + 0.004556909669190645, + 0.004567945841699839, + 0.004569226875901222 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.0010230097026011188, + 0.0010900201514759578, + 0.0011570103343455434, + 0.0012240297787549234, + 0.0013077464538127758, + 0.0013746923858718194, + 0.001391443637906867, + 0.001475122695027504, + 0.0014751226950275055, + 0.0014751226950275097 + ] + }, + "L29": { + "normalized_time_brier": 0.47851954041454553, + "normalized_timepoint_brier": [ + 0.7144821574911475, + 0.6961828459638867, + 0.4937894963266192, + 0.5912567538592539, + 0.505499597477547, + 0.46086809440852194, + 0.42229544900964616, + 0.38174930683178937, + 0.37358132034179586, + 0.3619658241693321, + 0.3517571903525481, + 0.43737565183383204, + 0.4299503373231727 + ], + "raw_time_brier": 0.001098585534446801, + "raw_timepoint_brier": [ + 0.0007144821574911475, + 0.0007210634066723287, + 0.0007337798597291112, + 0.0010952857555821538, + 0.001104712369851768, + 0.0011145432945340872, + 0.0011265904176980257, + 0.0011389973806217313, + 0.0011455985950306058, + 0.0011579783167690039, + 0.0011661836178973317, + 0.001529933768324554, + 0.001532463007606566 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001035738543189748, + 0.0014860175544190784, + 0.001852470603393533, + 0.0021853872394049464, + 0.0024183563758400153, + 0.002667777785292429, + 0.002983626584877098, + 0.0030665307194226903, + 0.003199137154526741, + 0.003315308542033003, + 0.003497985683267543, + 0.003564279114531054 + ] + }, + "L30": { + "normalized_time_brier": 1.8695812736660196, + "normalized_timepoint_brier": [ + 0.35181400016881526, + 0.7039335905574262, + 1.0570356389507651, + 1.7635561525821686, + 2.1176568698138, + 2.4737503845244646, + 2.475485671311617, + 2.3283339720990974, + 2.391109269272688, + 2.2356896141235727, + 2.207076729635533, + 2.099506062754762, + 2.0996086018635474 + ], + "raw_time_brier": 0.002119025893849679, + "raw_timepoint_brier": [ + 0.00035181400016881526, + 0.0007039335905574262, + 0.0010570356389507651, + 0.0017635561525821686, + 0.0021176568698138, + 0.0024737503845244646, + 0.002475485671311617, + 0.002477629343047738, + 0.002822505310177803, + 0.0028246548026800156, + 0.002825220813974738, + 0.002826977986842394, + 0.0028271160554140806 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010641211152427777, + 0.0011804166988304697, + 0.0012634378157127715, + 0.001280073672128872, + 0.0013464967008159604, + 0.0013464967008159617 + ] + }, + "L50": { + "normalized_time_brier": 0.8473187151455869, + "normalized_timepoint_brier": [ + 0.35272754030302167, + 0.703408382833004, + 0.703174329828471, + 0.7033076253719628, + 0.7038222975097597, + 1.0563133982941508, + 1.0566703276708722, + 1.0567979188635945, + 1.0570535669103265, + 0.9789922025253818, + 0.9094811227370009, + 0.8843172737034106, + 0.8490773103416731 + ], + "raw_time_brier": 0.0008942061641181891, + "raw_timepoint_brier": [ + 0.00035272754030302167, + 0.000703408382833004, + 0.0007031743298284709, + 0.0007033076253719628, + 0.0007038222975097597, + 0.0010563133982941508, + 0.0010566703276708722, + 0.0010567979188635945, + 0.0010570535669103265, + 0.0010575042106211185, + 0.0010578727815300226, + 0.0010579561349004507, + 0.001058071618899703 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001080196765503555, + 0.0011631607903487325, + 0.0011963535784728734, + 0.0012461428494349113 + ] + }, + "L53": { + "normalized_time_brier": 0.005394365299834265, + "normalized_timepoint_brier": [ + 0.0004017355763608066, + 0.001798616267478792, + 0.0028065837796020787, + 0.004048489245178644, + 0.005165391485206783, + 0.005827893898976154, + 0.006140320589393226, + 0.006211606415618101, + 0.007199742896944744, + 0.007466349456983992, + 0.007490807064683868, + 0.007769324970165866, + 0.007799887251252394 + ], + "raw_time_brier": 6.35897035076246e-06, + "raw_timepoint_brier": [ + 4.017355763608066e-07, + 1.798616267478792e-06, + 2.8065837796020787e-06, + 4.048489245178644e-06, + 5.165391485206783e-06, + 6.005969680700218e-06, + 6.5315625761286356e-06, + 6.813719210185809e-06, + 8.614200851297937e-06, + 9.304496416007169e-06, + 9.70791734289378e-06, + 1.0712895345932338e-05, + 1.0755036782938987e-05 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010305557693415367, + 0.0010637168664143107, + 0.0010969335070962949, + 0.001196459508985165, + 0.0012461908553320902, + 0.0012959774906849079, + 0.0013788708011403506, + 0.001378870801140375 + ] + }, + "L76": { + "normalized_time_brier": 2.240609298447119, + "normalized_timepoint_brier": [ + 2.159120049327612, + 2.3074137057780066, + 2.0090622805830214, + 2.3409671120189746, + 2.1308466810055657, + 2.227260490617896, + 2.4112341488956712, + 2.331599988168855, + 2.256861886457924, + 2.170261656393505, + 2.1208734063116075, + 2.3311534522480506, + 2.3312660220058583 + ], + "raw_time_brier": 0.004093994816335348, + "raw_timepoint_brier": [ + 0.002159120049327612, + 0.0028836168348789215, + 0.0028883591294288635, + 0.0036055580712854862, + 0.0036091809161007404, + 0.003962684888392687, + 0.004660595674067736, + 0.0046659717336297035, + 0.004670256748795509, + 0.004676146898418665, + 0.004678417928516865, + 0.005380881950259209, + 0.005381141789257526 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001249718170459871, + 0.0014376653015409128, + 0.0015402002244174465, + 0.0016937778528474585, + 0.0017791744185671528, + 0.001932867314525326, + 0.0020011887790813425, + 0.0020693586864215844, + 0.002154646599705119, + 0.0022058921171787716, + 0.0023082487105557763, + 0.0023082487105557806 + ] + }, + "L89": { + "normalized_time_brier": 2.5767412761776027, + "normalized_timepoint_brier": [ + 2.844427712261677, + 2.883207889638349, + 2.5226274028781557, + 2.4781097323888557, + 2.4110840195809735, + 2.5363903822859406, + 2.5465514583616593, + 2.4922488383194095, + 2.4986937482762026, + 2.5304412066145483, + 2.56962680417849, + 2.5983701133707746, + 2.5858572821538024 + ], + "raw_time_brier": 0.006293424405157566, + "raw_timepoint_brier": [ + 0.002844427712261677, + 0.0035508242435753345, + 0.003913284745067358, + 0.004970063921064138, + 0.005321998614817858, + 0.006024080328643322, + 0.006732707377523184, + 0.007090356666594744, + 0.007443368900567293, + 0.007792916614562273, + 0.00847281888127327, + 0.008828326128423214, + 0.008829343132674694 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0012315533182106848, + 0.0015512733829032982, + 0.002005586700260073, + 0.0022073053330355437, + 0.0023750603892505203, + 0.002643852868323625, + 0.002844963375076127, + 0.0029789040396416408, + 0.003079667132431951, + 0.0032972954934528055, + 0.0033976399601404494, + 0.003414474261054574 + ] + }, + "L97": { + "normalized_time_brier": 1.7312974711618307, + "normalized_timepoint_brier": [ + 0.7156698266044259, + 1.0839009191840887, + 1.4413318131119013, + 1.746167428791523, + 1.4864428526445557, + 2.0216349742378092, + 1.847234749475485, + 2.105831247577875, + 2.050802774640203, + 2.0624077481884604, + 1.9482496016706348, + 1.9984954756117272, + 1.9986977133651112 + ], + "raw_time_brier": 0.0029274677553285775, + "raw_timepoint_brier": [ + 0.0007156698266044259, + 0.0010839009191840887, + 0.0014413318131119013, + 0.001746167428791523, + 0.0017707149963825941, + 0.0028546517714858055, + 0.0028904788196086884, + 0.0038668736815452576, + 0.003870115615427494, + 0.004241530317813158, + 0.004270692355930805, + 0.0046522412449121475, + 0.004652712028473616 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001191243237661162, + 0.0014120510417871346, + 0.0015647598771241329, + 0.0018362694950001014, + 0.0018871222836659535, + 0.0020565915355674723, + 0.002192066330858563, + 0.0023278717923982915, + 0.0023278717923982954 + ] + }, + "L98": { + "normalized_time_brier": 1.5401534886344155, + "normalized_timepoint_brier": [ + 0.0027849011985381367, + 0.36496363463811576, + 0.3700714441947639, + 1.0732056107372046, + 1.7818826017901301, + 1.7834593309089541, + 1.7896215431392193, + 1.7971497727558017, + 1.772106907810569, + 2.281549813809954, + 2.4234717152819245, + 2.3054442439542284, + 2.2762838320280014 + ], + "raw_time_brier": 0.0016870847757148183, + "raw_timepoint_brier": [ + 2.7849011985381367e-06, + 0.00036496363463811576, + 0.0003700714441947639, + 0.0010732056107372046, + 0.0017818826017901301, + 0.0017834593309089541, + 0.0017896215431392193, + 0.0017971497727558017, + 0.0018053068779408932, + 0.0025146901607513428, + 0.0028732127975672483, + 0.0028871558606624603, + 0.002888597548007965 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010187347444919916, + 0.001102185078550649, + 0.0011855771946705, + 0.0012523208350120399, + 0.001268997085233627 + ] + }, + "M10": { + "normalized_time_brier": 2.333786646094881, + "normalized_timepoint_brier": [ + 1.468062400817871, + 2.908836817368865, + 3.148519509171274, + 2.7350612413639253, + 2.475331653445851, + 2.125930783411909, + 2.3115187381929174, + 2.38619436743579, + 2.2322678611017115, + 2.200163662659787, + 2.178983314046984, + 2.0336909471342786, + 2.134665103082292 + ], + "raw_time_brier": 0.004078286753680844, + "raw_timepoint_brier": [ + 0.001468062400817871, + 0.002908836817368865, + 0.0036326011177152395, + 0.0036327694542706013, + 0.003633012529462576, + 0.003638952737674117, + 0.004359130281955004, + 0.004707247018814087, + 0.004714158829301596, + 0.004723080433905125, + 0.005093925632536411, + 0.005107744596898556, + 0.0053982059471309185 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0011537489626898903, + 0.001328222344468969, + 0.001467687178162629, + 0.0017116985962421396, + 0.001885829524082878, + 0.0019727005825902213, + 0.0021118248895878357, + 0.002146695045492831, + 0.0023377533915464274, + 0.0025115638165651463, + 0.002528830372191087 + ] + }, + "M16": { + "normalized_time_brier": 0.8248469362465235, + "normalized_timepoint_brier": [ + 0.35850697895511985, + 0.3588866093195975, + 0.7151452009566128, + 0.7149100420065224, + 0.7145951967686415, + 0.7155106286518276, + 0.7155507919378579, + 1.0710220085456967, + 1.0709726484492421, + 1.0714465752243996, + 1.0719915153458714, + 1.0721994331106544, + 1.0722725419327617 + ], + "raw_time_brier": 0.0008248469362465235, + "raw_timepoint_brier": [ + 0.00035850697895511985, + 0.0003588866093195975, + 0.0007151452009566128, + 0.0007149100420065224, + 0.0007145951967686415, + 0.0007155106286518276, + 0.0007155507919378579, + 0.0010710220085456967, + 0.0010709726484492421, + 0.0010714465752243996, + 0.0010719915153458714, + 0.0010721994331106544, + 0.0010722725419327617 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "M17": { + "normalized_time_brier": 2.39801076214231, + "normalized_timepoint_brier": [ + 0.7304418832063675, + 1.4612579252570868, + 1.8289376748725772, + 2.198134083300829, + 2.566947601735592, + 2.9388375114649534, + 2.8478704756857276, + 2.552031869123454, + 2.5669858576441973, + 3.0389331599139444, + 2.946220999377631, + 2.7751564189683893, + 2.722384447299276 + ], + "raw_time_brier": 0.003161298120036148, + "raw_timepoint_brier": [ + 0.0007304418832063675, + 0.0014612579252570868, + 0.0018289376748725772, + 0.002198134083300829, + 0.002566947601735592, + 0.0029388375114649534, + 0.003302337136119604, + 0.003306683385744691, + 0.0036753718741238117, + 0.004764891229569912, + 0.004769805818796158, + 0.0047757504507899284, + 0.004777478985488415 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001159581225450377, + 0.0012957061491870934, + 0.001431785010883081, + 0.0015679486776553001, + 0.0016189572404119537, + 0.001720894151460198, + 0.0017548877015617253 + ] + }, + "M19": { + "normalized_time_brier": 3.0550967018991377, + "normalized_timepoint_brier": [ + 2.9819412156939507, + 3.1883476874144576, + 3.033911809209184, + 3.43922159030858, + 3.079603202838644, + 3.122653491981113, + 3.1191620646451805, + 3.143666492339755, + 3.0129743711350447, + 2.9619701892543833, + 2.895955180269784, + 2.873345038853258, + 2.8635047907454507 + ], + "raw_time_brier": 0.010042293462902308, + "raw_timepoint_brier": [ + 0.0029819412156939507, + 0.0055644023232162, + 0.006298428401350975, + 0.008874427527189255, + 0.009230523370206356, + 0.009954375214874744, + 0.011024406179785728, + 0.0117662213742733, + 0.012164165265858173, + 0.012521428056061268, + 0.012894025072455406, + 0.013636424206197262, + 0.013639046810567379 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0017452307178357227, + 0.0020760090594039767, + 0.0025803593325293725, + 0.002997309316245048, + 0.0031877937274940376, + 0.0035344127529454957, + 0.0037428338543367516, + 0.004037261445830255, + 0.004227398405793303, + 0.004452425631550767, + 0.004745835958371192, + 0.004763060587377872 + ] + }, + "M21": { + "normalized_time_brier": 0.5740133906678798, + "normalized_timepoint_brier": [ + 0.35418919287621975, + 0.3537807788234204, + 0.3538623859640211, + 0.35433354787528515, + 0.3548747336026281, + 0.3554539871402085, + 0.3564651415217668, + 0.3577341849450022, + 0.711265136487782, + 0.7121545495465398, + 1.065469696186483, + 1.0662630666047335, + 1.0663276771083474 + ], + "raw_time_brier": 0.0005740133906678798, + "raw_timepoint_brier": [ + 0.00035418919287621975, + 0.0003537807788234204, + 0.0003538623859640211, + 0.00035433354787528515, + 0.0003548747336026281, + 0.0003554539871402085, + 0.0003564651415217668, + 0.0003577341849450022, + 0.000711265136487782, + 0.0007121545495465398, + 0.001065469696186483, + 0.0010662630666047335, + 0.0010663276771083474 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "M25": { + "normalized_time_brier": 2.4306486279331474, + "normalized_timepoint_brier": [ + 1.6131939361903151, + 1.6621580578702158, + 2.0125955924019987, + 2.4097096417834365, + 2.324656195117255, + 2.5370754439351777, + 2.4848656119302177, + 2.5433877592797063, + 2.6182797971333427, + 2.642546731004751, + 2.7388407292119132, + 2.9971976154656548, + 3.013925051806934 + ], + "raw_time_brier": 0.010195509799254628, + "raw_timepoint_brier": [ + 0.0018310227897018194, + 0.0029423674568533897, + 0.004769937600940466, + 0.007319692987948656, + 0.00805394072085619, + 0.009526374749839306, + 0.010264077223837376, + 0.011373138055205345, + 0.012466358952224255, + 0.013572181575000286, + 0.01499853003770113, + 0.017534513026475906, + 0.017889492213726044 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0011350295513916475, + 0.001770209182527174, + 0.002370042754216522, + 0.00303758297723012, + 0.003464572842114381, + 0.003754864591280442, + 0.004130636753375305, + 0.004471649284978177, + 0.004761278365235529, + 0.005136023297434692, + 0.0054762330199525245, + 0.0058503026080086095, + 0.005935612832509151 + ] + }, + "M35": { + "normalized_time_brier": 0.5243421362068218, + "normalized_timepoint_brier": [ + 0.35647026379592717, + 0.3567489329725504, + 0.35705696791410446, + 0.35782461054623127, + 0.3588697873055935, + 0.3598924959078431, + 0.36046691820956767, + 0.7166090072132647, + 0.7169290911406279, + 0.7178325322456658, + 0.7183620473369956, + 0.7196738733910024, + 0.7197112427093089 + ], + "raw_time_brier": 0.0005243421362068218, + "raw_timepoint_brier": [ + 0.00035647026379592717, + 0.0003567489329725504, + 0.00035705696791410446, + 0.00035782461054623127, + 0.0003588697873055935, + 0.0003598924959078431, + 0.00036046691820956767, + 0.0007166090072132647, + 0.0007169290911406279, + 0.0007178325322456658, + 0.0007183620473369956, + 0.0007196738733910024, + 0.0007197112427093089 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "M46": { + "normalized_time_brier": 1.3704612056008036, + "normalized_timepoint_brier": [ + 0.0003548528582086874, + 0.3568410174921155, + 0.7126579293981194, + 1.0690171038731933, + 1.0705833556130528, + 1.4254694106057286, + 1.4265791978687048, + 1.427896786481142, + 1.4287414960563183, + 1.4290721155703068, + 2.4897432886064053, + 2.489485229004061, + 2.4895538893830915 + ], + "raw_time_brier": 0.0013705987694856083, + "raw_timepoint_brier": [ + 3.548528582086874e-07, + 0.0003568410174921155, + 0.0007126579293981194, + 0.0010690171038731933, + 0.0010705833556130528, + 0.0014254694106057286, + 0.0014265791978687048, + 0.001427896786481142, + 0.0014287414960563183, + 0.0014290721155703068, + 0.0024897432886064053, + 0.0024903793819248676, + 0.0024904480669647455 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010003591718120634, + 0.0010003591718120532 + ] + }, + "M47": { + "normalized_time_brier": 1.73714558814097, + "normalized_timepoint_brier": [ + 0.36476468085311353, + 0.7284503662958741, + 1.0923539521172643, + 1.0940119391307235, + 1.454268000088632, + 1.7450212107686833, + 2.152520510098144, + 2.386153310524635, + 2.4673256478553642, + 2.3573593726540434, + 2.335036025076454, + 2.2028093063373237, + 2.202818324032353 + ], + "raw_time_brier": 0.0024248693527904553, + "raw_timepoint_brier": [ + 0.00036476468085311353, + 0.0007284503662958741, + 0.0010923539521172643, + 0.0010940119391307235, + 0.001454268000088632, + 0.0018164312932640314, + 0.0025341655127704144, + 0.0032564818393439054, + 0.003619394265115261, + 0.0036186242941766977, + 0.003981837537139654, + 0.003981250803917646, + 0.003981267102062702 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010409221859623654, + 0.001177301447712974, + 0.0013647412448229968, + 0.0014669301023402775, + 0.0015350329424328093, + 0.0017052574325954052, + 0.0018073515453488754, + 0.0018073515453488793 + ] + }, + "M48": { + "normalized_time_brier": 0.7742485395299337, + "normalized_timepoint_brier": [ + 0.7419672328978777, + 0.7151889323755968, + 0.6610221766696117, + 0.7044083034925455, + 0.8366391881706977, + 0.8630973245919874, + 0.9511286410844134, + 0.8726613267706465, + 0.7947923948792317, + 0.7552274448001187, + 0.7106586726161446, + 0.732378503502464, + 0.7260608720378017 + ], + "raw_time_brier": 0.0028972700238227844, + "raw_timepoint_brier": [ + 0.0007419672328978777, + 0.0011099026305601, + 0.0014913303311914206, + 0.0018673095619305968, + 0.002605186076834798, + 0.0029832867439836264, + 0.0037103465292602777, + 0.0037172245793044567, + 0.003725391114130616, + 0.003733133664354682, + 0.003742688801139593, + 0.004117519594728947, + 0.004119223449379206 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001551901295331023, + 0.0022560972745348734, + 0.002650890900451116, + 0.0031138704876244303, + 0.003456489388834472, + 0.0039009933767003256, + 0.004259641702079713, + 0.0046872505803187605, + 0.004943058796469859, + 0.005266506897554138, + 0.005622119675874803, + 0.005673385811051862 + ] + }, + "M51": { + "normalized_time_brier": 0.822262135853545, + "normalized_timepoint_brier": [ + 0.0007922405984572833, + 0.002352153614992858, + 0.35982709960080683, + 0.3608194529078901, + 0.3612090367823839, + 0.7179640233516693, + 0.718663795851171, + 1.0753257665783167, + 1.0764636099338531, + 1.381922117021632, + 1.6214461170324599, + 1.506296467349535, + 1.5063258854729193 + ], + "raw_time_brier": 0.0008821114261081675, + "raw_timepoint_brier": [ + 7.922405984572833e-07, + 2.352153614992858e-06, + 0.00035982709960080683, + 0.0003608194529078901, + 0.0003612090367823839, + 0.0007179640233516693, + 0.000718663795851171, + 0.0010753257665783167, + 0.0010764636099338531, + 0.0014298859750851989, + 0.0017876215279102325, + 0.0017882444662973285, + 0.0017882793908938766 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001034708076144653, + 0.0011024859285376093, + 0.0011871796190585952, + 0.0011871796190586184 + ] + }, + "M54": { + "normalized_time_brier": 1.1271115960845872, + "normalized_timepoint_brier": [ + 1.143547270489124, + 0.9288315361316443, + 1.1743882933028418, + 1.22066613071733, + 1.1538771885188883, + 1.1251853150025293, + 1.1342778193553904, + 1.1786353012225732, + 1.128782699523544, + 1.1270572116258588, + 1.1310624605729498, + 1.1095734683055694, + 1.0965660543313887 + ], + "raw_time_brier": 0.012600430735171987, + "raw_timepoint_brier": [ + 0.0038774602580815554, + 0.005037523806095123, + 0.008477012626826763, + 0.010388486087322235, + 0.011144467629492283, + 0.012234448455274105, + 0.013390879146754742, + 0.014844893477857113, + 0.015164255164563656, + 0.016301807016134262, + 0.01740495301783085, + 0.017768869176506996, + 0.017770543694496155 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.003390730193796945, + 0.005423506427306695, + 0.007218236655770868, + 0.008510505719706823, + 0.009658278836240165, + 0.01087327419950073, + 0.011805643131031843, + 0.012594984608435554, + 0.013434166887005307, + 0.014464045700588495, + 0.015388144885486002, + 0.016014143888679902, + 0.01620562995207017 + ] + }, + "M62": { + "normalized_time_brier": 0.8423236240354497, + "normalized_timepoint_brier": [ + 0.0010528708571655443, + 0.5404517270298161, + 0.9567306261071352, + 0.7986798061976055, + 0.8666324042749832, + 0.873758032987783, + 0.9134977970155147, + 0.9704899233416086, + 0.9753832107137326, + 0.9209739088129523, + 0.9588047838654498, + 1.050790162769896, + 1.1229618584872034 + ], + "raw_time_brier": 0.0027494030887457764, + "raw_timepoint_brier": [ + 1.0528708571655443e-06, + 0.0007197150262072682, + 0.001789158908650279, + 0.0017889540176838636, + 0.002144977217540145, + 0.0024996870197355747, + 0.0028586057014763355, + 0.0032159071415662766, + 0.003575179260224104, + 0.0035759734455496073, + 0.00393132958561182, + 0.004642637912184, + 0.004999062046408653 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.0013316916020652523, + 0.001870075922969281, + 0.0022398888813788907, + 0.0024750715608593166, + 0.002860845823858109, + 0.003129296765482824, + 0.0033136945209005435, + 0.003665409882960751, + 0.003882817321240617, + 0.004100239852540732, + 0.004418235035571659, + 0.004451675725783895 + ] + }, + "M79": { + "normalized_time_brier": 1.9842846877244216, + "normalized_timepoint_brier": [ + 1.6758561945919745, + 2.121844483237465, + 2.118266923999895, + 1.8933537936536577, + 1.9262046638608687, + 1.8020813499438002, + 1.9619756936962787, + 1.9050628799007165, + 1.9302916110410895, + 2.1196695490168587, + 2.152574654420846, + 2.103496336614374, + 2.085022806439653 + ], + "raw_time_brier": 0.010322503566455383, + "raw_timepoint_brier": [ + 0.0025701909326016903, + 0.0055022998712956905, + 0.006963184569031, + 0.006978251039981842, + 0.00839943252503872, + 0.008793185465037823, + 0.010623733513057232, + 0.011334406211972237, + 0.012116863392293453, + 0.014216897077858448, + 0.015288984403014183, + 0.01569966785609722, + 0.015705449506640434 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0015336584015357368, + 0.002593168309347723, + 0.003287208278682137, + 0.0036856561427517018, + 0.004360612702599819, + 0.004879460888550923, + 0.005414814030158839, + 0.0059496231497424045, + 0.006277219111861708, + 0.006707128988314478, + 0.0071026500156983925, + 0.007463605989143865, + 0.007532507298305659 + ] + }, + "M81": { + "normalized_time_brier": 2.210567494177113, + "normalized_timepoint_brier": [ + 0.7433788850903511, + 1.8318085931241512, + 2.1940500009804964, + 2.5517841289098033, + 2.14664246796171, + 2.205121639034731, + 2.3749179783356684, + 2.554650592736148, + 2.486222094146918, + 2.2292968985158903, + 2.49400294429125, + 2.4706246620637535, + 2.454876539111601 + ], + "raw_time_brier": 0.0038752878407159676, + "raw_timepoint_brier": [ + 0.0007433788850903511, + 0.0018318085931241512, + 0.0021940500009804964, + 0.002937717130407691, + 0.0029556802473962307, + 0.003266389248892665, + 0.003971407189965248, + 0.004714366514235735, + 0.004717184696346521, + 0.004731739405542612, + 0.005856503266841173, + 0.006228046957403421, + 0.006230469793081284 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.0011512404584406478, + 0.0013768852016622598, + 0.0014812739538134923, + 0.0016722291995736173, + 0.0018454056017055671, + 0.0018973303742460305, + 0.0021225254512724045, + 0.0023482343035106097, + 0.002520838981750077, + 0.0025379972042651223 + ] + }, + "M84": { + "normalized_time_brier": 1.433525106102393, + "normalized_timepoint_brier": [ + 0.0006673573693660728, + 0.35608632606454194, + 1.0599378729239106, + 1.0613810736685991, + 1.0630717733874917, + 1.7670715460553765, + 1.7739218892529607, + 1.7781301867216825, + 2.1312835160642862, + 2.0310741874833838, + 1.943287897904931, + 1.8606420110404895, + 1.8092707413940896 + ], + "raw_time_brier": 0.001507428661043902, + "raw_timepoint_brier": [ + 6.673573693660728e-07, + 0.00035608632606454194, + 0.0010599378729239106, + 0.0010613810736685991, + 0.0010630717733874917, + 0.0017670715460553765, + 0.0017739218892529607, + 0.0017781301867216825, + 0.0021312835160642862, + 0.002146350219845772, + 0.0021511935628950596, + 0.00215319124981761, + 0.0021542860195040703 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010567561899377106, + 0.0011069865485264807, + 0.0011572302662420935, + 0.0011906930069759143 + ] + }, + "M85": { + "normalized_time_brier": 1.9196529981717654, + "normalized_timepoint_brier": [ + 0.7222441490739584, + 0.7228389731608331, + 1.08626380097121, + 2.5255512446165085, + 2.527655800804496, + 2.529437653720379, + 2.4072274067042394, + 2.1988574240875214, + 2.168051600862348, + 2.0826889044232066, + 2.0287817716544345, + 1.9776284672415345, + 1.9782617789122787 + ], + "raw_time_brier": 0.0021472012740559876, + "raw_timepoint_brier": [ + 0.0007222441490739584, + 0.0007228389731608331, + 0.00108626380097121, + 0.0025255512446165085, + 0.002527655800804496, + 0.002529437653720379, + 0.0025328148622065783, + 0.0025370316579937935, + 0.0025383217725902796, + 0.0025441106408834457, + 0.002546964678913355, + 0.002549782395362854, + 0.002550598932430148 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010521709977015766, + 0.0011537954349389466, + 0.0011707847597265007, + 0.0012215509649474165, + 0.001255415794098126, + 0.0012893131534050882, + 0.0012893131534050875 + ] + }, + "M86": { + "normalized_time_brier": 2.5290198086183953, + "normalized_timepoint_brier": [ + 1.06356805190444, + 1.41571753192693, + 2.8280429542064667, + 2.8308863622425235, + 2.851692107271028, + 3.106452664502825, + 3.035863706132569, + 2.753340140204003, + 2.630981865651298, + 2.63674069056875, + 2.5349646856463095, + 2.541085294111027, + 2.6479214576709698 + ], + "raw_time_brier": 0.004111227140618632, + "raw_timepoint_brier": [ + 0.00106356805190444, + 0.00141571753192693, + 0.0028280429542064667, + 0.0031854920089244843, + 0.003830669214949012, + 0.0045371269807219505, + 0.004891697783023119, + 0.004897914826869965, + 0.004900368861854076, + 0.005264210980385542, + 0.005272935144603252, + 0.00554049713537097, + 0.005817711353302002 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.0011252631159666385, + 0.0013432969166558557, + 0.0014605492086093314, + 0.001611303489396342, + 0.0017788992922999566, + 0.001862562766330962, + 0.0019964841439337904, + 0.0020800822885068617, + 0.0021803664553138335, + 0.0021970860715857794 + ] + }, + "M94": { + "normalized_time_brier": 0.7835502941627202, + "normalized_timepoint_brier": [ + 0.35467339330352843, + 0.3546428051777184, + 0.3546282823663205, + 0.3546852385625243, + 0.7093668100424111, + 0.7093748426996171, + 1.063803443685174, + 1.0637337109073997, + 1.0637836530804634, + 1.0638637468218803, + 1.0639805113896728, + 1.0311660437077623, + 0.9984513423708896 + ], + "raw_time_brier": 0.0007911227204693625, + "raw_timepoint_brier": [ + 0.00035467339330352843, + 0.0003546428051777184, + 0.0003546282823663205, + 0.0003546852385625243, + 0.0007093668100424111, + 0.0007093748426996171, + 0.001063803443685174, + 0.0010637337109073997, + 0.0010637836530804634, + 0.0010638637468218803, + 0.0010639805113896728, + 0.001064024749211967, + 0.001064034178853035 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001031865581401473, + 0.001065684559376138 + ] + }, + "M96": { + "normalized_time_brier": 0.8425845350922826, + "normalized_timepoint_brier": [ + 0.00622070319877821, + 0.3655242617242038, + 0.3668024728540331, + 0.3703641705214977, + 0.7274515810422599, + 0.7279458222910762, + 0.729378720279783, + 1.080147922039032, + 1.0812700493261218, + 1.4350289711728692, + 1.4100121862086585, + 1.347425134606246, + 1.306026960935114 + ], + "raw_time_brier": 0.0008622254171873814, + "raw_timepoint_brier": [ + 6.22070319877821e-06, + 0.0003655242617242038, + 0.0003668024728540331, + 0.0003703641705214977, + 0.0007274515810422599, + 0.0007279458222910762, + 0.000729378720279783, + 0.001080147922039032, + 0.0010812700493261218, + 0.0014350289711728692, + 0.0014353791484609246, + 0.0014413321623578668, + 0.0014420844381675124 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.00101799059788304, + 0.0010696936886063527, + 0.001104176622154095 + ] + }, + "N12": { + "normalized_time_brier": 2.0427274822185817, + "normalized_timepoint_brier": [ + 1.0594415944069624, + 1.414858503267169, + 1.4151543145999312, + 1.41819822601974, + 1.4212013920769095, + 1.7690203385427594, + 2.4748314172029495, + 2.476209541782737, + 2.478125737980008, + 2.480215160176158, + 2.480645664036274, + 2.8337258845567703, + 2.8338294941931963 + ], + "raw_time_brier": 0.0020427274822185817, + "raw_timepoint_brier": [ + 0.0010594415944069624, + 0.001414858503267169, + 0.0014151543145999312, + 0.00141819822601974, + 0.0014212013920769095, + 0.0017690203385427594, + 0.0024748314172029495, + 0.0024762095417827368, + 0.002478125737980008, + 0.002480215160176158, + 0.002480645664036274, + 0.0028337258845567703, + 0.0028338294941931963 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "N13": { + "normalized_time_brier": 2.1438243894589655, + "normalized_timepoint_brier": [ + 0.7274715462699533, + 0.735231616999954, + 1.4582310104742646, + 1.4995879640605096, + 1.798651053120655, + 1.7520245832813415, + 2.1806692920449744, + 2.6665131770493704, + 3.129654509001258, + 3.102552849927712, + 3.0198521368282307, + 2.899647267429279, + 2.8996300564790483 + ], + "raw_time_brier": 0.004295919757658759, + "raw_timepoint_brier": [ + 0.0007274715462699533, + 0.000735231616999954, + 0.0014582310104742646, + 0.0018288277788087726, + 0.002558325417339802, + 0.0029067357536405325, + 0.003986380062997341, + 0.005369402933865786, + 0.006777145899832249, + 0.007136884145438671, + 0.007456263992935419, + 0.007453050464391708, + 0.007453006226569414 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.0012195535191258562, + 0.00142235783472348, + 0.0016590724704310651, + 0.0018280534685105867, + 0.002013642002627303, + 0.0021654613569454303, + 0.0023003263733621677, + 0.0024690824765899893, + 0.002570330035694069, + 0.0025703300356940783 + ] + }, + "N14": { + "normalized_time_brier": 2.230532521603181, + "normalized_timepoint_brier": [ + 1.0610682656988502, + 1.0609994642436504, + 1.7646991182118654, + 2.1157439332455397, + 2.4645556695759296, + 2.463717944920063, + 2.463537734001875, + 2.4619512259960175, + 2.813356928527355, + 2.7321651344661997, + 2.6467867782712537, + 2.4921433794723185, + 2.4561972042104365 + ], + "raw_time_brier": 0.002301791584334121, + "raw_timepoint_brier": [ + 0.0010610682656988502, + 0.0010609994642436504, + 0.0017646991182118654, + 0.0021157439332455397, + 0.0024645556695759296, + 0.002463717944920063, + 0.002463537734001875, + 0.0024619512259960175, + 0.002813356928527355, + 0.002812825608998537, + 0.002812793478369713, + 0.0028139082714915276, + 0.0028141329530626535 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010295225473434264, + 0.0010627200881692805, + 0.0011291117094905426, + 0.001145727610241816 + ] + }, + "N17": { + "normalized_time_brier": 0.8508841316409601, + "normalized_timepoint_brier": [ + 1.0176396593374062, + 0.9091796153111409, + 0.8990291820991442, + 0.8890168332173528, + 0.8241980555496996, + 0.8102435044212825, + 0.8181999323759096, + 0.819295147475254, + 0.8222563267731853, + 0.8120971554825925, + 0.8229441667161193, + 0.8070813118000677, + 0.8103128207733269 + ], + "raw_time_brier": 0.029815486489007108, + "raw_timepoint_brier": [ + 0.010721801780164242, + 0.017157528549432755, + 0.021994609385728836, + 0.02532275579869747, + 0.026577237993478775, + 0.02858322113752365, + 0.031210578978061676, + 0.03334449604153633, + 0.035433486104011536, + 0.03695661574602127, + 0.03933189436793327, + 0.04028448835015297, + 0.040682610124349594 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.010535951190370565, + 0.018871439988853114, + 0.024464844772194825, + 0.028484000361449168, + 0.0322461789548303, + 0.03527732216494504, + 0.03814541867222063, + 0.040699003459609126, + 0.043092992963720496, + 0.04550762860886962, + 0.04779412256469776, + 0.04991379153644974, + 0.05020605509551719 + ] + }, + "N18": { + "normalized_time_brier": 0.9707980541660391, + "normalized_timepoint_brier": [ + 1.0789640462078918, + 0.8819808534548428, + 0.9187635319813611, + 1.1027647108170164, + 1.0313341451768752, + 0.9681213344445798, + 0.9532312344774339, + 0.9791262735832591, + 0.9847320204131194, + 0.9428237872432811, + 0.9406024953252337, + 0.9224394480386834, + 0.9154908229949302 + ], + "raw_time_brier": 0.013349042954639746, + "raw_timepoint_brier": [ + 0.004433813504874706, + 0.005887831095606089, + 0.008127816021442413, + 0.011600705794990063, + 0.01233525387942791, + 0.013019505888223648, + 0.014019303023815155, + 0.015468031167984009, + 0.01676567643880844, + 0.017120201140642166, + 0.01800728216767311, + 0.018379271030426025, + 0.01837286725640297 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.004109324606744506, + 0.006675690376432355, + 0.008846472175396816, + 0.010519656352074715, + 0.011960482387899993, + 0.013448217103585533, + 0.01470713769833676, + 0.015797789912608957, + 0.0170256233079278, + 0.018158431482408668, + 0.019144412498551477, + 0.01992463686316164, + 0.020068871030621695 + ] + }, + "N20": { + "normalized_time_brier": 2.7374362465567312, + "normalized_timepoint_brier": [ + 2.1369026508182287, + 2.4920953437685966, + 2.4910394567996264, + 2.8467450756579638, + 2.8466973453760147, + 2.8464102651923895, + 2.8462964110076427, + 2.8464014176279306, + 2.8463895432651043, + 2.8466847725212574, + 2.846814226359129, + 2.8470861725509167, + 2.8471085242927074 + ], + "raw_time_brier": 0.0027374362465567314, + "raw_timepoint_brier": [ + 0.0021369026508182287, + 0.0024920953437685966, + 0.0024910394567996264, + 0.0028467450756579638, + 0.0028466973453760147, + 0.0028464102651923895, + 0.0028462964110076427, + 0.0028464014176279306, + 0.0028463895432651043, + 0.0028466847725212574, + 0.002846814226359129, + 0.0028470861725509167, + 0.0028471085242927074 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "N25": { + "normalized_time_brier": 1.1985422094058529, + "normalized_timepoint_brier": [ + 0.7050447748042643, + 1.404173788614571, + 1.7470426391810179, + 1.4307200384362733, + 1.435676774774829, + 1.2591546990189957, + 1.162446808193474, + 1.1000101086490726, + 1.2106282208183219, + 1.0990060861368212, + 1.0356385701700095, + 0.9991906090950802, + 0.9923156043833568 + ], + "raw_time_brier": 0.0019978939134699223, + "raw_timepoint_brier": [ + 0.0007050447748042643, + 0.001404173788614571, + 0.0017470426391810179, + 0.0017413109308108687, + 0.0020818316843360662, + 0.0020771080162376165, + 0.002072199946269393, + 0.0020706262439489365, + 0.0024197883903980255, + 0.0024157261941581964, + 0.002414015354588628, + 0.002411968307569623, + 0.00241178460419178 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.0012170871197932339, + 0.0014500699049495873, + 0.0016496051024198109, + 0.0017826191544108075, + 0.001882370196117454, + 0.0019987873641028903, + 0.0021981008336813246, + 0.0023309438486752627, + 0.0024139221141740203, + 0.002430461229812573 + ] + }, + "N28": { + "normalized_time_brier": 1.0250067963817868, + "normalized_timepoint_brier": [ + 1.0704967426136136, + 1.0710317874327302, + 0.9095695758081284, + 0.7344337843032037, + 0.8533560145102473, + 0.772350982400074, + 0.8838240348062782, + 1.0017992406297382, + 1.1218056454774612, + 1.2024958203172245, + 1.231019347381338, + 1.186451198523672, + 1.2864541787595185 + ], + "raw_time_brier": 0.0020380119900577343, + "raw_timepoint_brier": [ + 0.0010704967426136136, + 0.0010710317874327302, + 0.001073337160050869, + 0.0010768406791612506, + 0.001437729806639254, + 0.0014440749073401093, + 0.0018009782070294023, + 0.0021591170225292444, + 0.0025118913035839796, + 0.0028540263883769512, + 0.003210629103705287, + 0.0032135904766619205, + 0.0035704122856259346 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0011800495405722398, + 0.001466218877965842, + 0.001684794836143959, + 0.0018697133042449936, + 0.0020377112820021367, + 0.002155239228542445, + 0.0022391501716100496, + 0.0023734189675803153, + 0.0026081061280921664, + 0.0027085736696635, + 0.0027753901729082606 + ] + }, + "N30": { + "normalized_time_brier": 2.737391093117229, + "normalized_timepoint_brier": [ + 1.4115788508206606, + 2.118119038641453, + 2.4701664224267006, + 2.8311475180089474, + 3.1881481409072876, + 3.192264586687088, + 3.198671853169799, + 3.1488125314514814, + 2.944426232312686, + 2.7987068726575006, + 2.8877681750471496, + 2.6979723670063844, + 2.6983016213868374 + ], + "raw_time_brier": 0.0031533899108091225, + "raw_timepoint_brier": [ + 0.0014115788508206606, + 0.002118119038641453, + 0.0024701664224267006, + 0.0028311475180089474, + 0.0031881481409072876, + 0.003192264586687088, + 0.003198671853169799, + 0.0035663056187331676, + 0.003579716430976987, + 0.003588495310395956, + 0.003942808602005243, + 0.003953082021325827, + 0.0039535644464194775 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0011325874700737544, + 0.0012157602699271277, + 0.0012821976268591912, + 0.0013653480345391187, + 0.001465204784774014, + 0.0014652047847740152 + ] + }, + "N32": { + "normalized_time_brier": 2.4032932380614245, + "normalized_timepoint_brier": [ + 1.7700553871691227, + 2.4712977465242147, + 2.9664565599583987, + 2.7694084651276794, + 2.5919016242004345, + 2.3801357844924005, + 2.2233806170821726, + 2.314964654125173, + 2.3621405584848487, + 2.359311304978936, + 2.317354219698811, + 2.3854991918444832, + 2.330905981111843 + ], + "raw_time_brier": 0.0037209336610081103, + "raw_timepoint_brier": [ + 0.0017700553871691227, + 0.0024712977465242147, + 0.003176445607095957, + 0.0034746448509395123, + 0.003468266222625971, + 0.0034626517444849014, + 0.0034572684671729803, + 0.0037930395919829607, + 0.004106403328478336, + 0.004455782938748598, + 0.0044538709335029125, + 0.005141829140484333, + 0.005140581633895636 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.0010707878382485072, + 0.0012546523543537009, + 0.001338116458681522, + 0.0014548126905387306, + 0.0015549602441484293, + 0.0016384870435165904, + 0.0017384246308832327, + 0.0018885947476898898, + 0.0019219638049472586, + 0.0021554520571891865, + 0.002205400679200101 + ] + }, + "N39": { + "normalized_time_brier": 0.8538571270507167, + "normalized_timepoint_brier": [ + 0.7103896390010104, + 0.7999024371179421, + 0.8968281418487872, + 0.92354373406916, + 0.915801656232583, + 0.8807108105704189, + 0.8966693914115819, + 0.8742628805472159, + 0.8687451998700594, + 0.8616753362529781, + 0.8395349172753933, + 0.817564859025719, + 0.8145136484364666 + ], + "raw_time_brier": 0.024008619742324717, + "raw_timepoint_brier": [ + 0.006327246315777302, + 0.012050241231918335, + 0.017007309943437576, + 0.020531341433525085, + 0.023041624575853348, + 0.02457343228161335, + 0.026826191693544388, + 0.027988703921437263, + 0.029490752145648003, + 0.030550917610526085, + 0.030952423810958862, + 0.031375255435705185, + 0.031396616250276566 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.008906726630578437, + 0.015064638726862112, + 0.018963845077806615, + 0.02223104404927681, + 0.025160059952983472, + 0.02790181747138726, + 0.029917594991519955, + 0.03201405955142309, + 0.033946377085086646, + 0.03545525364968399, + 0.0368685365838161, + 0.03837647263006712, + 0.03854645813553308 + ] + }, + "N40": { + "normalized_time_brier": 2.140898188913083, + "normalized_timepoint_brier": [ + 1.8276159323920091, + 1.7859875809155186, + 2.1722724468129293, + 2.3188091530423205, + 2.0328171556406223, + 2.143489693019481, + 2.0587914975402657, + 2.2171918483855197, + 2.2575601991805327, + 2.2342414359088822, + 2.320235574284055, + 2.231255291979027, + 2.2314086467689154 + ], + "raw_time_brier": 0.0062507385692487545, + "raw_timepoint_brier": [ + 0.0019105965038761497, + 0.002684607869014144, + 0.004218003246933222, + 0.004949357360601425, + 0.004978770390152931, + 0.006106665823608637, + 0.0061177643947303295, + 0.0072027696296572685, + 0.007880065590143204, + 0.008262407965958118, + 0.008980147540569305, + 0.00898391380906105, + 0.00898453127592802 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.0010454037251555004, + 0.0015031503565315846, + 0.0019417468803794415, + 0.0021344392892825082, + 0.002449197349765538, + 0.0028489364065970046, + 0.0029715317952495475, + 0.0032486000861414264, + 0.003490522907430585, + 0.0036980819678500846, + 0.0038703602513896766, + 0.004026394398416286, + 0.0040263943984162835 + ] + }, + "N73": { + "normalized_time_brier": 1.1267750860474646, + "normalized_timepoint_brier": [ + 0.3531121474225074, + 0.35294232657179236, + 0.698234245646745, + 0.6976888398639858, + 0.6976734148338437, + 0.6973163690418005, + 1.0489008855074644, + 1.3914970913901925, + 1.6159061618018984, + 1.887349141899936, + 1.7528135410641792, + 1.727354962790268, + 1.7272869907824258 + ], + "raw_time_brier": 0.001226809455637032, + "raw_timepoint_brier": [ + 0.0003531121474225074, + 0.00035294232657179236, + 0.000698234245646745, + 0.0006976888398639858, + 0.0006976734148338437, + 0.0006973163690418005, + 0.0010489008855074644, + 0.0013914970913901925, + 0.0017224092734977603, + 0.002074652584269643, + 0.002072372008115053, + 0.0020709026139229536, + 0.0020708211231976748 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010659092181300306, + 0.0010992415437141398, + 0.0011823117288658448, + 0.0011988865395551004, + 0.0011988865395550945 + ] + }, + "N99": { + "normalized_time_brier": 1.5366157794442887, + "normalized_timepoint_brier": [ + 0.7139217923395336, + 1.070166821591556, + 1.0707270121201873, + 1.0703710140660405, + 1.0706967441365123, + 1.0706513421609998, + 1.7811876023188233, + 1.7818930791690946, + 1.7820060020312667, + 2.1393010392785072, + 2.140674041584134, + 2.1421751007437706, + 2.1422335412353277 + ], + "raw_time_brier": 0.0015366157794442887, + "raw_timepoint_brier": [ + 0.0007139217923395336, + 0.001070166821591556, + 0.0010707270121201873, + 0.0010703710140660405, + 0.0010706967441365123, + 0.0010706513421609998, + 0.0017811876023188233, + 0.0017818930791690946, + 0.0017820060020312667, + 0.0021393010392785072, + 0.002140674041584134, + 0.0021421751007437706, + 0.0021422335412353277 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "O69": { + "normalized_time_brier": 1.6482315478207545, + "normalized_timepoint_brier": [ + 0.0013828332612320082, + 1.026220852509141, + 1.3679758412763476, + 1.3649945612996817, + 1.6948854317888618, + 1.6887899255380034, + 2.045642351731658, + 2.0453098695725203, + 2.039015758782625, + 2.038672100752592, + 2.0383186638355255, + 2.03795381821692, + 2.037848113104701 + ], + "raw_time_brier": 0.0016482315478207545, + "raw_timepoint_brier": [ + 1.3828332612320082e-06, + 0.001026220852509141, + 0.0013679758412763476, + 0.0013649945612996817, + 0.0016948854317888618, + 0.0016887899255380034, + 0.002045642351731658, + 0.0020453098695725203, + 0.002039015758782625, + 0.002038672100752592, + 0.0020383186638355255, + 0.00203795381821692, + 0.002037848113104701 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "O99": { + "normalized_time_brier": 0.499543824774334, + "normalized_timepoint_brier": [ + 0.006315517566690687, + 0.017670989109319635, + 0.28290142654441297, + 0.26688643265515566, + 0.263870635535568, + 0.25674246717244387, + 0.24249426496680826, + 0.23903424153104424, + 0.9887010091915727, + 0.9862375445663929, + 0.9812886128202081, + 0.9810042101889849, + 0.9809223702177405 + ], + "raw_time_brier": 0.000499543824774334, + "raw_timepoint_brier": [ + 6.315517566690687e-06, + 1.7670989109319635e-05, + 0.00028290142654441297, + 0.00026688643265515566, + 0.000263870635535568, + 0.00025674246717244387, + 0.00024249426496680826, + 0.00023903424153104424, + 0.0009887010091915727, + 0.000986237544566393, + 0.000981288612820208, + 0.0009810042101889849, + 0.0009809223702177405 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001 + ] + }, + "Q21": { + "normalized_time_brier": 0.6829948485515109, + "normalized_timepoint_brier": [ + 0.00023838998686187551, + 0.3557708114385605, + 0.3561446792446077, + 0.356581702362746, + 0.697363665070294, + 0.6350997271258733, + 0.8993091304553453, + 0.8294394903571802, + 0.7984771861717936, + 0.7698538212253516, + 0.966029431234753, + 1.1073139866485286, + 1.1073110098477463 + ], + "raw_time_brier": 0.000902350098739974, + "raw_timepoint_brier": [ + 2.3838998686187551e-07, + 0.0003557708114385605, + 0.0003561446792446077, + 0.000356581702362746, + 0.00071097252657637, + 0.0007111054146662354, + 0.0010669153416529298, + 0.0010670953197404742, + 0.001067240838892758, + 0.001067493692971766, + 0.0014200436417013407, + 0.001775476848706603, + 0.0017754720756784081 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.00101951472694624, + 0.0011196752010653884, + 0.001186372188963233, + 0.0012865258191178631, + 0.0013365952808364137, + 0.0013866186846649283, + 0.001469979687768186, + 0.0016034086718983668, + 0.0016034086718983613 + ] + }, + "U07": { + "normalized_time_brier": 0.24020370115868755, + "normalized_timepoint_brier": [ + 0.0007319185897358693, + 0.003945990101783536, + 0.010537843991187401, + 0.012260576113476418, + 0.0202990195248276, + 0.025017880034283735, + 0.03422550071263686, + 0.03966669464716688, + 0.04549322329694405, + 0.3903798933606595, + 0.687857906864536, + 0.9324606192173464, + 0.9197710486083542 + ], + "raw_time_brier": 0.0002710053836730927, + "raw_timepoint_brier": [ + 7.319185897358693e-07, + 3.945990101783536e-06, + 1.0537843991187401e-05, + 1.2260576113476418e-05, + 2.02990195248276e-05, + 2.5017880034283735e-05, + 3.422550071263686e-05, + 3.966669464716688e-05, + 4.549322329694405e-05, + 0.0003903798933606595, + 0.0007422680500894785, + 0.0010989679722115397, + 0.0010992754250764847 + ], + "reason": null, + "horizons_days": [ + 30, + 60, + 90, + 120, + 150, + 180, + 210, + 240, + 270, + 300, + 330, + 360, + 365 + ], + "normalization_denominator": [ + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.001, + 0.0010791008472563184, + 0.0011785677052334393, + 0.0011951620207438871 + ] + } + }, + "discrimination": { + "A04": { + "time_averaged_auroc": 0.7552959036343795, + "time_averaged_auprc": 0.05622643079982252, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2782, + "positives": 3, + "negatives": 2779, + "auroc": 0.815881012354564, + "auprc": 0.020274151758257402, + "brier": 0.0010793648855543794, + "calibration": { + "observed_rate": 0.0010783608914450035, + "mean_prediction": 0.002781798076584872, + "calibration_in_the_large": 0.0017034371851398684, + "expected_calibration_error_10bin": 0.0017034371851398684, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 7, + "negatives": 2775, + "auroc": 0.7689060489060489, + "auprc": 0.05015998942363244, + "brier": 0.00249135353683862, + "calibration": { + "observed_rate": 0.0025161754133716753, + "mean_prediction": 0.0041906232880550625, + "calibration_in_the_large": 0.0016744478746833873, + "expected_calibration_error_10bin": 0.0016744478746833873, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 14, + "negatives": 2768, + "auroc": 0.7242981007431875, + "auprc": 0.0862556807831821, + "brier": 0.004978782181682981, + "calibration": { + "observed_rate": 0.0050323508267433505, + "mean_prediction": 0.005623828742002762, + "calibration_in_the_large": 0.0005914779152594116, + "expected_calibration_error_10bin": 0.0005914779152594116, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 18, + "negatives": 2764, + "auroc": 0.7053384788551214, + "auprc": 0.07583365441111248, + "brier": 0.006382584068076843, + "calibration": { + "observed_rate": 0.006470165348670022, + "mean_prediction": 0.0065892746400799534, + "calibration_in_the_large": 0.00011910929140993183, + "expected_calibration_error_10bin": 0.000762309879927632, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 20, + "negatives": 2762, + "auroc": 0.7297610427226647, + "auprc": 0.07373571461269256, + "brier": 0.0070739953954285445, + "calibration": { + "observed_rate": 0.007189072609633357, + "mean_prediction": 0.00705605490449898, + "calibration_in_the_large": -0.00013301770513437713, + "expected_calibration_error_10bin": 0.00019498468395484956, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 21, + "negatives": 2761, + "auroc": 0.7360342181059313, + "auprc": 0.04756087487764919, + "brier": 0.007431035710147347, + "calibration": { + "observed_rate": 0.007548526240115025, + "mean_prediction": 0.007429221620015588, + "calibration_in_the_large": -0.00011930462009943684, + "expected_calibration_error_10bin": 0.00017952413419877506, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 22, + "negatives": 2760, + "auroc": 0.748534255599473, + "auprc": 0.05091500654639323, + "brier": 0.007762775045758519, + "calibration": { + "observed_rate": 0.007907979870596693, + "mean_prediction": 0.008035421419132913, + "calibration_in_the_large": 0.00012744154853622063, + "expected_calibration_error_10bin": 0.0003250322636106571, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 23, + "negatives": 2759, + "auroc": 0.7615865861922246, + "auprc": 0.053841441288056145, + "brier": 0.008098206422744636, + "calibration": { + "observed_rate": 0.00826743350107836, + "mean_prediction": 0.00862765540020697, + "calibration_in_the_large": 0.0003602218991286092, + "expected_calibration_error_10bin": 0.0003602218991286102, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 25, + "negatives": 2757, + "auroc": 0.7561697497279651, + "auprc": 0.05161498480224061, + "brier": 0.008808987677562746, + "calibration": { + "observed_rate": 0.008986340762041696, + "mean_prediction": 0.009168448508602043, + "calibration_in_the_large": 0.00018210774656034732, + "expected_calibration_error_10bin": 0.0003975560421291992, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 26, + "negatives": 2756, + "auroc": 0.7634392095567712, + "auprc": 0.05173107759658407, + "brier": 0.009159966921777193, + "calibration": { + "observed_rate": 0.009345794392523364, + "mean_prediction": 0.009709339156549519, + "calibration_in_the_large": 0.0003635447640261552, + "expected_calibration_error_10bin": 0.0004806226542000916, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 27, + "negatives": 2755, + "auroc": 0.7724675673858977, + "auprc": 0.05501206336903487, + "brier": 0.009495915501865446, + "calibration": { + "observed_rate": 0.009705248023005032, + "mean_prediction": 0.01009780703932914, + "calibration_in_the_large": 0.00039255901632410765, + "expected_calibration_error_10bin": 0.0005826620202979228, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 29, + "negatives": 2753, + "auroc": 0.7681776619862971, + "auprc": 0.057012585837588704, + "brier": 0.010180403322864979, + "calibration": { + "observed_rate": 0.010424155283968369, + "mean_prediction": 0.010558504197711533, + "calibration_in_the_large": 0.00013434891374316388, + "expected_calibration_error_10bin": 0.0009641898639667862, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 29, + "negatives": 2753, + "auroc": 0.7682528151107882, + "auprc": 0.05699637509126913, + "brier": 0.010180752626566645, + "calibration": { + "observed_rate": 0.010424155283968369, + "mean_prediction": 0.010574865206936474, + "calibration_in_the_large": 0.00015070992296810533, + "expected_calibration_error_10bin": 0.001022233486004471, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + } + ], + "reason": null + }, + "A08": { + "time_averaged_auroc": 0.7995968704687214, + "time_averaged_auprc": 0.026047317554643054, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.6975471027372911, + "auprc": 0.014463583260444671, + "brier": 0.0017680112453248645, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0006777897598999338, + "calibration_in_the_large": -0.001096518259972316, + "expected_calibration_error_10bin": 0.001096518259972316, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 7, + "negatives": 2811, + "auroc": 0.7897037149972048, + "auprc": 0.02308984784957232, + "brier": 0.002465076737147334, + "calibration": { + "observed_rate": 0.00248403122782115, + "mean_prediction": 0.0013261277750344278, + "calibration_in_the_large": -0.001157903452786722, + "expected_calibration_error_10bin": 0.001157903452786722, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 7, + "negatives": 2811, + "auroc": 0.785993799867866, + "auprc": 0.02257485648693185, + "brier": 0.0024617597720808133, + "calibration": { + "observed_rate": 0.00248403122782115, + "mean_prediction": 0.0019389119130297807, + "calibration_in_the_large": -0.0005451193147913691, + "expected_calibration_error_10bin": 0.0005451193147913691, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 7, + "negatives": 2811, + "auroc": 0.7871118564821873, + "auprc": 0.019844103519310135, + "brier": 0.002463580063905062, + "calibration": { + "observed_rate": 0.00248403122782115, + "mean_prediction": 0.0027230848936157953, + "calibration_in_the_large": 0.00023905366579464547, + "expected_calibration_error_10bin": 0.00023905366579464547, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 10, + "negatives": 2808, + "auroc": 0.8403133903133904, + "auprc": 0.03138506894393284, + "brier": 0.0034956928244408007, + "calibration": { + "observed_rate": 0.0035486160397444995, + "mean_prediction": 0.0030016612794945604, + "calibration_in_the_large": -0.0005469547602499391, + "expected_calibration_error_10bin": 0.0005469547602499391, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 11, + "negatives": 2807, + "auroc": 0.8127084885189624, + "auprc": 0.029260888597767667, + "brier": 0.003847630327043297, + "calibration": { + "observed_rate": 0.0039034776437189495, + "mean_prediction": 0.003375941500622481, + "calibration_in_the_large": -0.0005275361430964686, + "expected_calibration_error_10bin": 0.0005275361430964686, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 11, + "negatives": 2807, + "auroc": 0.8124170094244907, + "auprc": 0.02885599960688705, + "brier": 0.003848171391788484, + "calibration": { + "observed_rate": 0.0039034776437189495, + "mean_prediction": 0.003781046456569109, + "calibration_in_the_large": -0.00012243118714984043, + "expected_calibration_error_10bin": 0.00019559005611312412, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 11, + "negatives": 2807, + "auroc": 0.8119312109337047, + "auprc": 0.028482835344447566, + "brier": 0.003850775571252781, + "calibration": { + "observed_rate": 0.0039034776437189495, + "mean_prediction": 0.0040465304782673845, + "calibration_in_the_large": 0.00014305283454843498, + "expected_calibration_error_10bin": 0.00014305283454843536, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 11, + "negatives": 2807, + "auroc": 0.8115749587071283, + "auprc": 0.02866498317898546, + "brier": 0.0038529528236185243, + "calibration": { + "observed_rate": 0.0039034776437189495, + "mean_prediction": 0.0042841379618684845, + "calibration_in_the_large": 0.00038066031814953504, + "expected_calibration_error_10bin": 0.00038066031814953445, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 11, + "negatives": 2807, + "auroc": 0.8112510930466043, + "auprc": 0.028451182135252984, + "brier": 0.003855101829056001, + "calibration": { + "observed_rate": 0.0039034776437189495, + "mean_prediction": 0.0044947498281131424, + "calibration_in_the_large": 0.000591272184394193, + "expected_calibration_error_10bin": 0.0005912721843941928, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 11, + "negatives": 2807, + "auroc": 0.8116073452731807, + "auprc": 0.028213360303634093, + "brier": 0.0038596865137545742, + "calibration": { + "observed_rate": 0.0039034776437189495, + "mean_prediction": 0.004848472302488372, + "calibration_in_the_large": 0.0009449946587694229, + "expected_calibration_error_10bin": 0.0009449946587694229, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 11, + "negatives": 2807, + "auroc": 0.8111863199144995, + "auprc": 0.027627451023927083, + "brier": 0.003866098100729552, + "calibration": { + "observed_rate": 0.0039034776437189495, + "mean_prediction": 0.005268241101759093, + "calibration_in_the_large": 0.0013647634580401437, + "expected_calibration_error_10bin": 0.0013647634580401442, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 11, + "negatives": 2807, + "auroc": 0.8114130258768663, + "auprc": 0.02770096795926597, + "brier": 0.003867058292455252, + "calibration": { + "observed_rate": 0.0039034776437189495, + "mean_prediction": 0.005348854656993978, + "calibration_in_the_large": 0.001445377013275029, + "expected_calibration_error_10bin": 0.0014453770132750285, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + } + ], + "reason": null + }, + "A41": { + "time_averaged_auroc": 0.7561465873197972, + "time_averaged_auprc": 0.060690374023331634, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2664, + "positives": 5, + "negatives": 2659, + "auroc": 0.7462203836028583, + "auprc": 0.008083531699572263, + "brier": 0.0019171454312153485, + "calibration": { + "observed_rate": 0.0018768768768768769, + "mean_prediction": 0.005080742696752002, + "calibration_in_the_large": 0.0032038658198751246, + "expected_calibration_error_10bin": 0.0032038658198751246, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + { + "valid": 2664, + "positives": 19, + "negatives": 2645, + "auroc": 0.8166749577156501, + "auprc": 0.04621478637790553, + "brier": 0.0070684810886954596, + "calibration": { + "observed_rate": 0.007132132132132132, + "mean_prediction": 0.01130297018877806, + "calibration_in_the_large": 0.004170838056645928, + "expected_calibration_error_10bin": 0.004170838056645927, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + { + "valid": 2664, + "positives": 27, + "negatives": 2637, + "auroc": 0.78537619910392, + "auprc": 0.044400570196306, + "brier": 0.010072639508335281, + "calibration": { + "observed_rate": 0.010135135135135136, + "mean_prediction": 0.015118735175607842, + "calibration_in_the_large": 0.004983600040472706, + "expected_calibration_error_10bin": 0.005048433605631952, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + { + "valid": 2664, + "positives": 33, + "negatives": 2631, + "auroc": 0.7637492369533418, + "auprc": 0.056810786303751776, + "brier": 0.012176824385489957, + "calibration": { + "observed_rate": 0.012387387387387387, + "mean_prediction": 0.017432221600767673, + "calibration_in_the_large": 0.0050448342133802854, + "expected_calibration_error_10bin": 0.0050448342133802854, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + { + "valid": 2664, + "positives": 40, + "negatives": 2624, + "auroc": 0.7438262195121951, + "auprc": 0.0597752504745417, + "brier": 0.014745589081547232, + "calibration": { + "observed_rate": 0.015015015015015015, + "mean_prediction": 0.019676424841067103, + "calibration_in_the_large": 0.004661409826052088, + "expected_calibration_error_10bin": 0.004769821624568641, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + { + "valid": 2664, + "positives": 49, + "negatives": 2615, + "auroc": 0.7495219885277247, + "auprc": 0.06219035182383311, + "brier": 0.017940245044447342, + "calibration": { + "observed_rate": 0.01839339339339339, + "mean_prediction": 0.021253452548443783, + "calibration_in_the_large": 0.002860059155050391, + "expected_calibration_error_10bin": 0.002971455668538492, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + { + "valid": 2664, + "positives": 54, + "negatives": 2610, + "auroc": 0.7438697318007663, + "auprc": 0.06537338680233297, + "brier": 0.01975723865752423, + "calibration": { + "observed_rate": 0.02027027027027027, + "mean_prediction": 0.02352960275304934, + "calibration_in_the_large": 0.003259332482779067, + "expected_calibration_error_10bin": 0.003259332482779068, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + { + "valid": 2664, + "positives": 57, + "negatives": 2607, + "auroc": 0.7430736411415958, + "auprc": 0.06597026862528749, + "brier": 0.02090204554801041, + "calibration": { + "observed_rate": 0.021396396396396396, + "mean_prediction": 0.024816042912390514, + "calibration_in_the_large": 0.0034196465159941174, + "expected_calibration_error_10bin": 0.004283507107480851, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + { + "valid": 2664, + "positives": 63, + "negatives": 2601, + "auroc": 0.7540201265691462, + "auprc": 0.07632669273712227, + "brier": 0.02287543591017794, + "calibration": { + "observed_rate": 0.02364864864864865, + "mean_prediction": 0.026289502764435334, + "calibration_in_the_large": 0.002640854115786684, + "expected_calibration_error_10bin": 0.006513190882066516, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + { + "valid": 2664, + "positives": 66, + "negatives": 2598, + "auroc": 0.7452935824760305, + "auprc": 0.07460836662895982, + "brier": 0.024093090837592517, + "calibration": { + "observed_rate": 0.024774774774774775, + "mean_prediction": 0.02781265195683393, + "calibration_in_the_large": 0.003037877182059154, + "expected_calibration_error_10bin": 0.00814373736702746, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + { + "valid": 2664, + "positives": 70, + "negatives": 2594, + "auroc": 0.7507765172375812, + "auprc": 0.07608926282887542, + "brier": 0.025470654593381784, + "calibration": { + "observed_rate": 0.026276276276276277, + "mean_prediction": 0.029202420597013425, + "calibration_in_the_large": 0.0029261443207371472, + "expected_calibration_error_10bin": 0.007999989383385689, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + { + "valid": 2664, + "positives": 76, + "negatives": 2588, + "auroc": 0.7436752623444236, + "auprc": 0.07654443661949686, + "brier": 0.027676756686905002, + "calibration": { + "observed_rate": 0.028528528528528527, + "mean_prediction": 0.03036026948889544, + "calibration_in_the_large": 0.0018317409603669128, + "expected_calibration_error_10bin": 0.00877800468333043, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + { + "valid": 2664, + "positives": 76, + "negatives": 2588, + "auroc": 0.7438277881721305, + "auprc": 0.07658717118532606, + "brier": 0.027690425614143914, + "calibration": { + "observed_rate": 0.028528528528528527, + "mean_prediction": 0.030525308143424936, + "calibration_in_the_large": 0.0019967796148964087, + "expected_calibration_error_10bin": 0.008822462667821027, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + } + ], + "reason": null + }, + "B00": { + "time_averaged_auroc": 0.7536733503857683, + "time_averaged_auprc": 0.024715469127777234, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 8.428952619159184e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00016096267806259675, + "calibration_in_the_large": 0.00016096267806259675, + "expected_calibration_error_10bin": 0.00016096267806259675, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 1, + "negatives": 2818, + "auroc": 0.9932576295244855, + "auprc": 0.05, + "brier": 0.00034993020414633843, + "calibration": { + "observed_rate": 0.000354735721887194, + "mean_prediction": 0.0003805702174321253, + "calibration_in_the_large": 2.5834495544931285e-05, + "expected_calibration_error_10bin": 2.5834495544931285e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 1, + "negatives": 2818, + "auroc": 0.9932576295244855, + "auprc": 0.05, + "brier": 0.0003570603288321953, + "calibration": { + "observed_rate": 0.000354735721887194, + "mean_prediction": 0.0008557984868408771, + "calibration_in_the_large": 0.0005010627649536831, + "expected_calibration_error_10bin": 0.0005010627649536831, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 1, + "negatives": 2818, + "auroc": 0.9932576295244855, + "auprc": 0.05, + "brier": 0.0003622282898106182, + "calibration": { + "observed_rate": 0.000354735721887194, + "mean_prediction": 0.0010488824266010922, + "calibration_in_the_large": 0.0006941467047138982, + "expected_calibration_error_10bin": 0.000694146704713898, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.6956676136363636, + "auprc": 0.02091772340155283, + "brier": 0.001081712881821528, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0012979181931469757, + "calibration_in_the_large": 0.00023371102748539368, + "expected_calibration_error_10bin": 0.00023371102748539363, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.6959043560606061, + "auprc": 0.01949272288933122, + "brier": 0.001087818648353656, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0014263986384737018, + "calibration_in_the_large": 0.00036219147281211974, + "expected_calibration_error_10bin": 0.0003621914728121196, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 4, + "negatives": 2815, + "auroc": 0.6559502664298401, + "auprc": 0.015301151565231666, + "brier": 0.0014496460825571562, + "calibration": { + "observed_rate": 0.001418942887548776, + "mean_prediction": 0.0015567596789022797, + "calibration_in_the_large": 0.00013781679135350358, + "expected_calibration_error_10bin": 0.00036936793747326764, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 4, + "negatives": 2815, + "auroc": 0.66651865008881, + "auprc": 0.01533317340590082, + "brier": 0.0014510275841539408, + "calibration": { + "observed_rate": 0.001418942887548776, + "mean_prediction": 0.0016043991954288036, + "calibration_in_the_large": 0.00018545630788002754, + "expected_calibration_error_10bin": 0.0004010138840528729, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 4, + "negatives": 2815, + "auroc": 0.6680284191829485, + "auprc": 0.015232618046882265, + "brier": 0.0014569723465387924, + "calibration": { + "observed_rate": 0.001418942887548776, + "mean_prediction": 0.001776835146872302, + "calibration_in_the_large": 0.0003578922593235258, + "expected_calibration_error_10bin": 0.00035789225932352577, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 4, + "negatives": 2815, + "auroc": 0.672380106571936, + "auprc": 0.015185947160177123, + "brier": 0.0014616728105283025, + "calibration": { + "observed_rate": 0.001418942887548776, + "mean_prediction": 0.001978781267548776, + "calibration_in_the_large": 0.0005598383799999998, + "expected_calibration_error_10bin": 0.0005598383799999997, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 4, + "negatives": 2815, + "auroc": 0.6705150976909414, + "auprc": 0.015024803324239817, + "brier": 0.0014678815935864071, + "calibration": { + "observed_rate": 0.001418942887548776, + "mean_prediction": 0.0021149128973550527, + "calibration_in_the_large": 0.0006959700098062766, + "expected_calibration_error_10bin": 0.0006959700098062764, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 4, + "negatives": 2815, + "auroc": 0.669538188277087, + "auprc": 0.015048137938595706, + "brier": 0.0014756039438281216, + "calibration": { + "observed_rate": 0.001418942887548776, + "mean_prediction": 0.002216306739263463, + "calibration_in_the_large": 0.0007973638517146868, + "expected_calibration_error_10bin": 0.0007973638517146866, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 4, + "negatives": 2815, + "auroc": 0.6698046181172291, + "auprc": 0.015049351801415334, + "brier": 0.0014759454453550035, + "calibration": { + "observed_rate": 0.001418942887548776, + "mean_prediction": 0.0022223307763766242, + "calibration_in_the_large": 0.0008033878888278482, + "expected_calibration_error_10bin": 0.0008033878888278482, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + } + ], + "reason": null + }, + "B02": { + "time_averaged_auroc": 0.78981895359681, + "time_averaged_auprc": 0.0016850794687553164, + "valid_timepoint_cells": 11, + "timepoints": [ + { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 1.8999213602812124e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00014674968090446248, + "calibration_in_the_large": 0.00014674968090446248, + "expected_calibration_error_10bin": 0.00014674968090446248, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 5.244220705278826e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0002742087241697896, + "calibration_in_the_large": 0.0002742087241697896, + "expected_calibration_error_10bin": 0.0002742087241697896, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.798019101521047, + "auprc": 0.0017482517482517483, + "brier": 0.00035410456892655034, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0003444244007510485, + "calibration_in_the_large": -9.182388499305095e-06, + "expected_calibration_error_10bin": 9.182388499305095e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7962504421648391, + "auprc": 0.0017331022530329288, + "brier": 0.00035432336349102306, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.000405015802714552, + "calibration_in_the_large": 5.140901346419838e-05, + "expected_calibration_error_10bin": 5.140901346419838e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7856384860275911, + "auprc": 0.0016474464579901153, + "brier": 0.00035459823759919924, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0004921666503333838, + "calibration_in_the_large": 0.00013855986108303014, + "expected_calibration_error_10bin": 0.00013855986108303014, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7824548991864166, + "auprc": 0.0016233766233766235, + "brier": 0.0003549963880356371, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0005707628735976682, + "calibration_in_the_large": 0.0002171560843473146, + "expected_calibration_error_10bin": 0.0002171560843473146, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7725504067916519, + "auprc": 0.0015527950310559005, + "brier": 0.0003558502391010236, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.000694394699048528, + "calibration_in_the_large": 0.0003407879097981744, + "expected_calibration_error_10bin": 0.0003407879097981744, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.8043862752033958, + "auprc": 0.0018050541516245488, + "brier": 0.00035670438074149167, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0008010678431167176, + "calibration_in_the_large": 0.000447461053866364, + "expected_calibration_error_10bin": 0.000447461053866364, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.8054474708171206, + "auprc": 0.0018148820326678765, + "brier": 0.0003571135151789423, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0009158834667239516, + "calibration_in_the_large": 0.0005622766774735981, + "expected_calibration_error_10bin": 0.0005622766774735981, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.803325079589671, + "auprc": 0.0017953321364452424, + "brier": 0.00035729790606744125, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0009489987563992514, + "calibration_in_the_large": 0.0005953919671488979, + "expected_calibration_error_10bin": 0.0005953919671488979, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7821011673151751, + "auprc": 0.0016207455429497568, + "brier": 0.0003580114619341099, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.001044692809474331, + "calibration_in_the_large": 0.0006910860202239773, + "expected_calibration_error_10bin": 0.0006910860202239773, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7789175804740007, + "auprc": 0.001597444089456869, + "brier": 0.00035858655392324385, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0011109679962545511, + "calibration_in_the_large": 0.0007573612070041974, + "expected_calibration_error_10bin": 0.0007573612070041974, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7789175804740007, + "auprc": 0.001597444089456869, + "brier": 0.00035860455717643276, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0011130530170880947, + "calibration_in_the_large": 0.0007594462278377411, + "expected_calibration_error_10bin": 0.0007594462278377411, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + } + ], + "reason": null + }, + "B18": { + "time_averaged_auroc": 0.9610992561735254, + "time_averaged_auprc": 0.08780866997293456, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2782, + "positives": 1, + "negatives": 2781, + "auroc": 0.9938870909744696, + "auprc": 0.05555555555555555, + "brier": 0.00035615960067015765, + "calibration": { + "observed_rate": 0.0003594536304816679, + "mean_prediction": 0.0002320223765636659, + "calibration_in_the_large": -0.00012743125391800197, + "expected_calibration_error_10bin": 0.00012743125391800197, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 3, + "negatives": 2779, + "auroc": 0.9716924553196593, + "auprc": 0.09351851851851851, + "brier": 0.0010579054796425614, + "calibration": { + "observed_rate": 0.0010783608914450035, + "mean_prediction": 0.0004622741473576164, + "calibration_in_the_large": -0.0006160867440873871, + "expected_calibration_error_10bin": 0.0006160867440873871, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 3, + "negatives": 2779, + "auroc": 0.9710927192035504, + "auprc": 0.06670022483975972, + "brier": 0.0010551157369714998, + "calibration": { + "observed_rate": 0.0010783608914450035, + "mean_prediction": 0.0006650988765299049, + "calibration_in_the_large": -0.00041326201491509863, + "expected_calibration_error_10bin": 0.00041326201491509863, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 3, + "negatives": 2779, + "auroc": 0.9702530886409979, + "auprc": 0.10007695267410543, + "brier": 0.0010489918776416622, + "calibration": { + "observed_rate": 0.0010783608914450035, + "mean_prediction": 0.0007496750396228068, + "calibration_in_the_large": -0.00032868585182219676, + "expected_calibration_error_10bin": 0.00032868585182219676, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 4, + "negatives": 2778, + "auroc": 0.9642728581713463, + "auprc": 0.09137188845218043, + "brier": 0.001390163137155126, + "calibration": { + "observed_rate": 0.0014378145219266715, + "mean_prediction": 0.0009288055600497855, + "calibration_in_the_large": -0.000509008961876886, + "expected_calibration_error_10bin": 0.000509008961876886, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 5, + "negatives": 2777, + "auroc": 0.9680950666186532, + "auprc": 0.08994597397823204, + "brier": 0.0017351546425813185, + "calibration": { + "observed_rate": 0.0017972681524083393, + "mean_prediction": 0.001002815331405376, + "calibration_in_the_large": -0.0007944528210029633, + "expected_calibration_error_10bin": 0.0007944528210029633, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 5, + "negatives": 2777, + "auroc": 0.9675189052934822, + "auprc": 0.0895331291883016, + "brier": 0.0017328673829779754, + "calibration": { + "observed_rate": 0.0017972681524083393, + "mean_prediction": 0.0010788608820881155, + "calibration_in_the_large": -0.0007184072703202238, + "expected_calibration_error_10bin": 0.0007184072703202238, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 5, + "negatives": 2777, + "auroc": 0.9684551674468851, + "auprc": 0.09101977351405269, + "brier": 0.0017300554435452232, + "calibration": { + "observed_rate": 0.0017972681524083393, + "mean_prediction": 0.0011699593466286586, + "calibration_in_the_large": -0.0006273088057796806, + "expected_calibration_error_10bin": 0.0006992474180590858, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 7, + "negatives": 2775, + "auroc": 0.940952380952381, + "auprc": 0.0777177750374691, + "brier": 0.00243796317659309, + "calibration": { + "observed_rate": 0.0025161754133716753, + "mean_prediction": 0.0012504372261618367, + "calibration_in_the_large": -0.0012657381872098385, + "expected_calibration_error_10bin": 0.001416256519724817, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 7, + "negatives": 2775, + "auroc": 0.9417245817245817, + "auprc": 0.07848265957509656, + "brier": 0.002434967808272016, + "calibration": { + "observed_rate": 0.0025161754133716753, + "mean_prediction": 0.0013597690219618928, + "calibration_in_the_large": -0.0011564063914097824, + "expected_calibration_error_10bin": 0.0013173988743935311, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 7, + "negatives": 2775, + "auroc": 0.9404375804375804, + "auprc": 0.09005232071424889, + "brier": 0.0024314442713906314, + "calibration": { + "observed_rate": 0.0025161754133716753, + "mean_prediction": 0.001509829278856768, + "calibration_in_the_large": -0.0010063461345149072, + "expected_calibration_error_10bin": 0.001006346134514907, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 8, + "negatives": 2774, + "auroc": 0.9479542177361211, + "auprc": 0.10876294214155076, + "brier": 0.0027531111171952365, + "calibration": { + "observed_rate": 0.002875629043853343, + "mean_prediction": 0.001581338558431927, + "calibration_in_the_large": -0.001294290485421416, + "expected_calibration_error_10bin": 0.0012942904854214155, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + { + "valid": 2782, + "positives": 8, + "negatives": 2774, + "auroc": 0.9479542177361211, + "auprc": 0.10877499545907768, + "brier": 0.0027529261843463712, + "calibration": { + "observed_rate": 0.002875629043853343, + "mean_prediction": 0.0015862949148547829, + "calibration_in_the_large": -0.0012893341289985602, + "expected_calibration_error_10bin": 0.0012893341289985597, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + } + ], + "reason": null + }, + "B19": { + "time_averaged_auroc": 0.8490244800726692, + "time_averaged_auprc": 0.06530235936052839, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2763, + "positives": 7, + "negatives": 2756, + "auroc": 0.8084698320547378, + "auprc": 0.011870507138740724, + "brier": 0.002529944852090597, + "calibration": { + "observed_rate": 0.0025334781035106766, + "mean_prediction": 0.0004342344789001747, + "calibration_in_the_large": -0.002099243624610502, + "expected_calibration_error_10bin": 0.002099243624610502, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 12, + "negatives": 2751, + "auroc": 0.8521749666787835, + "auprc": 0.047469525591229245, + "brier": 0.004299772648089387, + "calibration": { + "observed_rate": 0.004343105320304018, + "mean_prediction": 0.000851976718816865, + "calibration_in_the_large": -0.0034911286014871526, + "expected_calibration_error_10bin": 0.0034911286014871526, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 12, + "negatives": 2751, + "auroc": 0.8620804555919059, + "auprc": 0.04843594122182119, + "brier": 0.0042923268838261286, + "calibration": { + "observed_rate": 0.004343105320304018, + "mean_prediction": 0.0011686871420566911, + "calibration_in_the_large": -0.0031744181782473267, + "expected_calibration_error_10bin": 0.0032498774374154866, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 14, + "negatives": 2749, + "auroc": 0.83414748220132, + "auprc": 0.06782213804152169, + "brier": 0.004966661507933206, + "calibration": { + "observed_rate": 0.005066956207021353, + "mean_prediction": 0.0013252574538024637, + "calibration_in_the_large": -0.0037416987532188895, + "expected_calibration_error_10bin": 0.0038254369637972397, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 15, + "negatives": 2748, + "auroc": 0.844517224648229, + "auprc": 0.0722432830069903, + "brier": 0.005313515936672734, + "calibration": { + "observed_rate": 0.0054288816503800215, + "mean_prediction": 0.001430823097251763, + "calibration_in_the_large": -0.003998058553128259, + "expected_calibration_error_10bin": 0.004086451702019225, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 15, + "negatives": 2748, + "auroc": 0.84463852498787, + "auprc": 0.07306564879754131, + "brier": 0.005308785778168112, + "calibration": { + "observed_rate": 0.0054288816503800215, + "mean_prediction": 0.00154467507664963, + "calibration_in_the_large": -0.0038842065737303916, + "expected_calibration_error_10bin": 0.004059731191326597, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 16, + "negatives": 2747, + "auroc": 0.852156898434656, + "auprc": 0.07497429500919428, + "brier": 0.005656520829499682, + "calibration": { + "observed_rate": 0.00579080709373869, + "mean_prediction": 0.001690609544136765, + "calibration_in_the_large": -0.004100197549601925, + "expected_calibration_error_10bin": 0.004296082778402, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 17, + "negatives": 2746, + "auroc": 0.8584250888993616, + "auprc": 0.07575733031784426, + "brier": 0.006010204540888551, + "calibration": { + "observed_rate": 0.006152732537097358, + "mean_prediction": 0.0017787006115917536, + "calibration_in_the_large": -0.004374031925505605, + "expected_calibration_error_10bin": 0.004582003295773247, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 17, + "negatives": 2746, + "auroc": 0.8573968553189666, + "auprc": 0.07562404485433917, + "brier": 0.006005503730698629, + "calibration": { + "observed_rate": 0.006152732537097358, + "mean_prediction": 0.0018813716797038936, + "calibration_in_the_large": -0.0042713608573934645, + "expected_calibration_error_10bin": 0.004491832441280013, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 17, + "negatives": 2746, + "auroc": 0.8570326892592434, + "auprc": 0.0754107215561686, + "brier": 0.00600162340237811, + "calibration": { + "observed_rate": 0.006152732537097358, + "mean_prediction": 0.0020087861866660396, + "calibration_in_the_large": -0.004143946350431318, + "expected_calibration_error_10bin": 0.004376170576688112, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 17, + "negatives": 2746, + "auroc": 0.8559401910800737, + "auprc": 0.07551593695631924, + "brier": 0.006000712654193283, + "calibration": { + "observed_rate": 0.006152732537097358, + "mean_prediction": 0.002117607892020464, + "calibration_in_the_large": -0.004035124645076894, + "expected_calibration_error_10bin": 0.004356433729646444, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 17, + "negatives": 2746, + "auroc": 0.8551690158947775, + "auprc": 0.07536584665133617, + "brier": 0.005996837659045276, + "calibration": { + "observed_rate": 0.006152732537097358, + "mean_prediction": 0.0022290050484125253, + "calibration_in_the_large": -0.003923727488684832, + "expected_calibration_error_10bin": 0.003923727488684832, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 17, + "negatives": 2746, + "auroc": 0.8551690158947775, + "auprc": 0.07537545254382277, + "brier": 0.005996914810027664, + "calibration": { + "observed_rate": 0.006152732537097358, + "mean_prediction": 0.002236160843292433, + "calibration_in_the_large": -0.003916571693804926, + "expected_calibration_error_10bin": 0.003916571693804925, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + } + ], + "reason": null + }, + "B20": { + "time_averaged_auroc": 0.9873727853703479, + "time_averaged_auprc": 0.19157033290695935, + "valid_timepoint_cells": 11, + "timepoints": [ + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 5.234367019896663e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 8.015299245050204e-05, + "calibration_in_the_large": 8.015299245050204e-05, + "expected_calibration_error_10bin": 8.015299245050204e-05, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 9.082456975099996e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00011453496810207256, + "calibration_in_the_large": 0.00011453496810207256, + "expected_calibration_error_10bin": 0.00011453496810207256, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.9791371994342292, + "auprc": 0.016666666666666666, + "brier": 0.0003543564339330188, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.000142903783835134, + "calibration_in_the_large": -0.0002105780118523881, + "expected_calibration_error_10bin": 0.0002105780118523881, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 3, + "negatives": 2826, + "auroc": 0.9880868129275773, + "auprc": 0.11872759856630825, + "brier": 0.001053486491783324, + "calibration": { + "observed_rate": 0.0010604453870625664, + "mean_prediction": 0.00016777084854888874, + "calibration_in_the_large": -0.0008926745385136776, + "expected_calibration_error_10bin": 0.0008926745385136776, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 3, + "negatives": 2826, + "auroc": 0.9885586223165841, + "auprc": 0.11709401709401708, + "brier": 0.0010530536122878194, + "calibration": { + "observed_rate": 0.0010604453870625664, + "mean_prediction": 0.00020558540925039615, + "calibration_in_the_large": -0.0008548599778121702, + "expected_calibration_error_10bin": 0.0008548599778121702, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 3, + "negatives": 2826, + "auroc": 0.9877329558858221, + "auprc": 0.11646545942320591, + "brier": 0.0010526403126242324, + "calibration": { + "observed_rate": 0.0010604453870625664, + "mean_prediction": 0.00023379547146029574, + "calibration_in_the_large": -0.0008266499156022707, + "expected_calibration_error_10bin": 0.0008266499156022707, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 4, + "negatives": 2825, + "auroc": 0.9898230088495575, + "auprc": 0.2828815261044177, + "brier": 0.001386601412380034, + "calibration": { + "observed_rate": 0.0014139271827500884, + "mean_prediction": 0.00025152592319710655, + "calibration_in_the_large": -0.001162401259552982, + "expected_calibration_error_10bin": 0.001162401259552982, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 5, + "negatives": 2824, + "auroc": 0.988314447592068, + "auprc": 0.24384719405003383, + "brier": 0.0017379563017631793, + "calibration": { + "observed_rate": 0.0017674089784376105, + "mean_prediction": 0.0002621402547964798, + "calibration_in_the_large": -0.0015052687236411307, + "expected_calibration_error_10bin": 0.0015781491653057685, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 5, + "negatives": 2824, + "auroc": 0.9878895184135977, + "auprc": 0.2421253071253071, + "brier": 0.0017363294362197487, + "calibration": { + "observed_rate": 0.0017674089784376105, + "mean_prediction": 0.00028044855551106123, + "calibration_in_the_large": -0.0014869604229265493, + "expected_calibration_error_10bin": 0.0015650898973833928, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 5, + "negatives": 2824, + "auroc": 0.988456090651558, + "auprc": 0.24381598793363501, + "brier": 0.0017358350591302675, + "calibration": { + "observed_rate": 0.0017674089784376105, + "mean_prediction": 0.00030837415171473066, + "calibration_in_the_large": -0.00145903482672288, + "expected_calibration_error_10bin": 0.0015457094824160445, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 5, + "negatives": 2824, + "auroc": 0.9881019830028328, + "auprc": 0.24256514276798252, + "brier": 0.0017333934194734594, + "calibration": { + "observed_rate": 0.0017674089784376105, + "mean_prediction": 0.00032356098258004996, + "calibration_in_the_large": -0.0014438479958575605, + "expected_calibration_error_10bin": 0.0015344489837440072, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 5, + "negatives": 2824, + "auroc": 0.9875354107648725, + "auprc": 0.24159720568389295, + "brier": 0.001731770519175251, + "calibration": { + "observed_rate": 0.0017674089784376105, + "mean_prediction": 0.0003403443559914662, + "calibration_in_the_large": -0.0014270646224461443, + "expected_calibration_error_10bin": 0.0015207592578427732, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 5, + "negatives": 2824, + "auroc": 0.9874645892351275, + "auprc": 0.24148755656108595, + "brier": 0.0017316720629385798, + "calibration": { + "observed_rate": 0.0017674089784376105, + "mean_prediction": 0.0003413447957368231, + "calibration_in_the_large": -0.0014260641827007873, + "expected_calibration_error_10bin": 0.0015198634159266802, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + } + ], + "reason": null + }, + "B34": { + "time_averaged_auroc": 0.9770176155035549, + "time_averaged_auprc": 0.08147758114954523, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2831, + "positives": 0, + "negatives": 2831, + "auroc": null, + "auprc": null, + "brier": 2.2374879145328458e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00017572632694629826, + "calibration_in_the_large": 0.00017572632694629826, + "expected_calibration_error_10bin": 0.00017572632694629826, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 2, + "negatives": 2829, + "auroc": 0.9747260516083421, + "auprc": 0.034189805221715705, + "brier": 0.0007023831824509456, + "calibration": { + "observed_rate": 0.0007064641469445425, + "mean_prediction": 0.00038118560151317193, + "calibration_in_the_large": -0.0003252785454313706, + "expected_calibration_error_10bin": 0.0003252785454313706, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 3, + "negatives": 2828, + "auroc": 0.9754832626119755, + "auprc": 0.034995112414467254, + "brier": 0.0010518051614735592, + "calibration": { + "observed_rate": 0.0010596962204168139, + "mean_prediction": 0.0005931656146922633, + "calibration_in_the_large": -0.00046653060572455054, + "expected_calibration_error_10bin": 0.00046653060572455054, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.9733816766890697, + "auprc": 0.035600455132844974, + "brier": 0.0014021372985689522, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0007981952802505689, + "calibration_in_the_large": -0.0006147330136385162, + "expected_calibration_error_10bin": 0.0006147330136385162, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.9731163777856385, + "auprc": 0.03496025959622928, + "brier": 0.0014022322372510253, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0008623988849572862, + "calibration_in_the_large": -0.0005505294089317989, + "expected_calibration_error_10bin": 0.0005505294089317989, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.9736469755925009, + "auprc": 0.036195856603018425, + "brier": 0.0014014423241147113, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0010032004338086675, + "calibration_in_the_large": -0.0004097278600804176, + "expected_calibration_error_10bin": 0.0004097278600804176, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.9794055201698514, + "auprc": 0.11466735019366599, + "brier": 0.0017168634356865432, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0011454546613598603, + "calibration_in_the_large": -0.000620705706001496, + "expected_calibration_error_10bin": 0.000620705706001496, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.9787685774946921, + "auprc": 0.11288164162306039, + "brier": 0.0017143575684716345, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0012575582422926874, + "calibration_in_the_large": -0.0005086021250686689, + "expected_calibration_error_10bin": 0.0005086021250686689, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.9790516631280962, + "auprc": 0.11483153809597435, + "brier": 0.001706387100247172, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0014750985724869417, + "calibration_in_the_large": -0.00029106179487441456, + "expected_calibration_error_10bin": 0.00037097450113129574, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.9790516631280962, + "auprc": 0.11446172248803828, + "brier": 0.001703475754063011, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0016682383093889548, + "calibration_in_the_large": -9.792205797240147e-05, + "expected_calibration_error_10bin": 0.00018302271587609926, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.9793347487615004, + "auprc": 0.11519096827346384, + "brier": 0.0017008702306425339, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0017824051012507213, + "calibration_in_the_large": 1.624473388936497e-05, + "expected_calibration_error_10bin": 0.00015837887389974508, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.9791224345364473, + "auprc": 0.11487813207603212, + "brier": 0.001700840923709183, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0018099942817259365, + "calibration_in_the_large": 4.383391436458021e-05, + "expected_calibration_error_10bin": 0.00013319357022367908, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.9791224345364473, + "auprc": 0.11487813207603212, + "brier": 0.0017008219339496402, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.001816128175309773, + "calibration_in_the_large": 4.996780794841666e-05, + "expected_calibration_error_10bin": 0.00012759522363625013, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + } + ], + "reason": null + }, + "B35": { + "time_averaged_auroc": 0.8320365433260438, + "time_averaged_auprc": 0.0036927171546205424, + "valid_timepoint_cells": 6, + "timepoints": [ + { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 2.9273903497076196e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0002618243110999216, + "calibration_in_the_large": 0.0002618243110999216, + "expected_calibration_error_10bin": 0.0002618243110999216, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 1.7958840945157558e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0006073141128965356, + "calibration_in_the_large": 0.0006073141128965356, + "expected_calibration_error_10bin": 0.0006073141128965356, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 4.468652274849919e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0008636864438935569, + "calibration_in_the_large": 0.0008636864438935569, + "expected_calibration_error_10bin": 0.0008636864438935569, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 6.008408421178278e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0010619743561138498, + "calibration_in_the_large": 0.0010619743561138498, + "expected_calibration_error_10bin": 0.0010619743561138498, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 7.0098792824643575e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001149105197575604, + "calibration_in_the_large": 0.001149105197575604, + "expected_calibration_error_10bin": 0.001149105197575604, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 8.527163344004138e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0012929379103290136, + "calibration_in_the_large": 0.0012929379103290136, + "expected_calibration_error_10bin": 0.0012929379103290136, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 1.1562294894725849e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001482568335733435, + "calibration_in_the_large": 0.001482568335733435, + "expected_calibration_error_10bin": 0.001482568335733435, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 1, + "negatives": 2835, + "auroc": 0.7714285714285715, + "auprc": 0.0015408320493066256, + "brier": 0.00036417821407595363, + "calibration": { + "observed_rate": 0.0003526093088857546, + "mean_prediction": 0.0015947904666318824, + "calibration_in_the_large": 0.001242181157746128, + "expected_calibration_error_10bin": 0.001242181157746128, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 1, + "negatives": 2835, + "auroc": 0.7791887125220458, + "auprc": 0.001594896331738437, + "brier": 0.00036635700524052957, + "calibration": { + "observed_rate": 0.0003526093088857546, + "mean_prediction": 0.0017648920820121676, + "calibration_in_the_large": 0.001412282773126413, + "expected_calibration_error_10bin": 0.001412282773126413, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.8600917431192661, + "auprc": 0.004842268715266426, + "brier": 0.0007157372623650274, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0018436707939307893, + "calibration_in_the_large": 0.0011384521761592802, + "expected_calibration_error_10bin": 0.0011384521761592802, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.8602681721947777, + "auprc": 0.004734415674741172, + "brier": 0.0007163420985552769, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.001902432273736503, + "calibration_in_the_large": 0.0011972136559649938, + "expected_calibration_error_10bin": 0.0011972136559649938, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.8607974594213126, + "auprc": 0.00472443291901398, + "brier": 0.0007173536605728163, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.002056878399109237, + "calibration_in_the_large": 0.0013516597813377277, + "expected_calibration_error_10bin": 0.0013516597813377277, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.8604446012702893, + "auprc": 0.004719457237656614, + "brier": 0.0007175636806720772, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0020742700964331605, + "calibration_in_the_large": 0.0013690514786616514, + "expected_calibration_error_10bin": 0.0013690514786616514, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + } + ], + "reason": null + }, + "B37": { + "time_averaged_auroc": 0.7677064602076331, + "time_averaged_auprc": 0.03259089028913724, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2768, + "positives": 8, + "negatives": 2760, + "auroc": 0.8608242753623189, + "auprc": 0.016128633062346964, + "brier": 0.0028723088174688063, + "calibration": { + "observed_rate": 0.002890173410404624, + "mean_prediction": 0.0018573069000895974, + "calibration_in_the_large": -0.0010328665103150267, + "expected_calibration_error_10bin": 0.0010328665103150267, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 15, + "negatives": 2753, + "auroc": 0.7480324494490859, + "auprc": 0.02290404258509681, + "brier": 0.005360638068162199, + "calibration": { + "observed_rate": 0.00541907514450867, + "mean_prediction": 0.003718300593916897, + "calibration_in_the_large": -0.0017007745505917735, + "expected_calibration_error_10bin": 0.0017007745505917735, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 18, + "negatives": 2750, + "auroc": 0.7480404040404041, + "auprc": 0.022878973022695346, + "brier": 0.006440716789790314, + "calibration": { + "observed_rate": 0.006502890173410405, + "mean_prediction": 0.005182209680757727, + "calibration_in_the_large": -0.0013206804926526776, + "expected_calibration_error_10bin": 0.001472809645000953, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 22, + "negatives": 2746, + "auroc": 0.770343640336357, + "auprc": 0.02701812149777749, + "brier": 0.007865085981645455, + "calibration": { + "observed_rate": 0.007947976878612716, + "mean_prediction": 0.006439647744123328, + "calibration_in_the_large": -0.0015083291344893885, + "expected_calibration_error_10bin": 0.0017682411043533444, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 23, + "negatives": 2745, + "auroc": 0.767767482379029, + "auprc": 0.026794597819706525, + "brier": 0.008246814560483979, + "calibration": { + "observed_rate": 0.008309248554913294, + "mean_prediction": 0.007352137680623393, + "calibration_in_the_large": -0.0009571108742899015, + "expected_calibration_error_10bin": 0.0018025770063987783, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 26, + "negatives": 2742, + "auroc": 0.7523144251809459, + "auprc": 0.028802334450055162, + "brier": 0.009318449550101075, + "calibration": { + "observed_rate": 0.00939306358381503, + "mean_prediction": 0.008214623548424059, + "calibration_in_the_large": -0.0011784400353909708, + "expected_calibration_error_10bin": 0.0024908302313181494, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 30, + "negatives": 2738, + "auroc": 0.7542731921110299, + "auprc": 0.033324402087502425, + "brier": 0.010710336970106312, + "calibration": { + "observed_rate": 0.01083815028901734, + "mean_prediction": 0.008759001367741414, + "calibration_in_the_large": -0.0020791489212759265, + "expected_calibration_error_10bin": 0.003748626048940622, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 31, + "negatives": 2737, + "auroc": 0.7617594022181102, + "auprc": 0.03774637866000645, + "brier": 0.011017785462714882, + "calibration": { + "observed_rate": 0.011199421965317919, + "mean_prediction": 0.009203197468369355, + "calibration_in_the_large": -0.0019962244969485635, + "expected_calibration_error_10bin": 0.003938571543044076, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 34, + "negatives": 2734, + "auroc": 0.7686109557209863, + "auprc": 0.03944031367290314, + "brier": 0.012083800221260309, + "calibration": { + "observed_rate": 0.012283236994219654, + "mean_prediction": 0.009781964186324878, + "calibration_in_the_large": -0.002501272807894776, + "expected_calibration_error_10bin": 0.0049533241018394686, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 35, + "negatives": 2733, + "auroc": 0.7552035962573833, + "auprc": 0.03864745539355039, + "brier": 0.012463618280690508, + "calibration": { + "observed_rate": 0.012644508670520232, + "mean_prediction": 0.01020790426182272, + "calibration_in_the_large": -0.002436604408697512, + "expected_calibration_error_10bin": 0.0045708674342834835, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 36, + "negatives": 2732, + "auroc": 0.7608182853424434, + "auprc": 0.04239042530592727, + "brier": 0.012780435228002736, + "calibration": { + "observed_rate": 0.01300578034682081, + "mean_prediction": 0.010682272004571574, + "calibration_in_the_large": -0.002323508342249236, + "expected_calibration_error_10bin": 0.004670922664834274, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 38, + "negatives": 2730, + "auroc": 0.7660401002506265, + "auprc": 0.04380228581229119, + "brier": 0.013478462113006438, + "calibration": { + "observed_rate": 0.013728323699421965, + "mean_prediction": 0.011078363918255028, + "calibration_in_the_large": -0.002649959781166937, + "expected_calibration_error_10bin": 0.0051582651119653974, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 38, + "negatives": 2730, + "auroc": 0.7661557740505109, + "auprc": 0.0438036103889249, + "brier": 0.013479419400671818, + "calibration": { + "observed_rate": 0.013728323699421965, + "mean_prediction": 0.011128713382266541, + "calibration_in_the_large": -0.002599610317155424, + "expected_calibration_error_10bin": 0.005120467378377189, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + } + ], + "reason": null + }, + "B95": { + "time_averaged_auroc": 0.7056072111085784, + "time_averaged_auprc": 0.03795497518082277, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2678, + "positives": 15, + "negatives": 2663, + "auroc": 0.6624608837151083, + "auprc": 0.017574134887788855, + "brier": 0.005568539745483353, + "calibration": { + "observed_rate": 0.005601194921583271, + "mean_prediction": 0.006088700011777107, + "calibration_in_the_large": 0.00048750509019383596, + "expected_calibration_error_10bin": 0.00048750509019383596, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + { + "valid": 2678, + "positives": 27, + "negatives": 2651, + "auroc": 0.7413973762521481, + "auprc": 0.030614511687450878, + "brier": 0.009949490896696292, + "calibration": { + "observed_rate": 0.010082150858849889, + "mean_prediction": 0.011393045489711942, + "calibration_in_the_large": 0.0013108946308620535, + "expected_calibration_error_10bin": 0.0013108946308620553, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + { + "valid": 2678, + "positives": 34, + "negatives": 2644, + "auroc": 0.7055486339770402, + "auprc": 0.029085085602904306, + "brier": 0.012568407453497495, + "calibration": { + "observed_rate": 0.012696041822255415, + "mean_prediction": 0.013914825682462415, + "calibration_in_the_large": 0.0012187838602070004, + "expected_calibration_error_10bin": 0.0012187838602069991, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + { + "valid": 2678, + "positives": 39, + "negatives": 2639, + "auroc": 0.68725527346217, + "auprc": 0.029604462768836503, + "brier": 0.014486322422999624, + "calibration": { + "observed_rate": 0.014563106796116505, + "mean_prediction": 0.016153852224400054, + "calibration_in_the_large": 0.0015907454282835486, + "expected_calibration_error_10bin": 0.0015907454282835496, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + { + "valid": 2678, + "positives": 42, + "negatives": 2636, + "auroc": 0.7003486523592745, + "auprc": 0.033179135081324064, + "brier": 0.015589822303590612, + "calibration": { + "observed_rate": 0.01568334578043316, + "mean_prediction": 0.018185598616705805, + "calibration_in_the_large": 0.002502252836272645, + "expected_calibration_error_10bin": 0.0025022528362726474, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + { + "valid": 2678, + "positives": 42, + "negatives": 2636, + "auroc": 0.7007370474745285, + "auprc": 0.03318868631030191, + "brier": 0.015641621382594947, + "calibration": { + "observed_rate": 0.01568334578043316, + "mean_prediction": 0.019489696587200636, + "calibration_in_the_large": 0.0038063508067674758, + "expected_calibration_error_10bin": 0.0038063508067674775, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + { + "valid": 2678, + "positives": 51, + "negatives": 2627, + "auroc": 0.7082782865715758, + "auprc": 0.040946201514074305, + "brier": 0.01879326695709092, + "calibration": { + "observed_rate": 0.019044062733383122, + "mean_prediction": 0.020522890690730815, + "calibration_in_the_large": 0.0014788279573476927, + "expected_calibration_error_10bin": 0.003679375445555069, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + { + "valid": 2678, + "positives": 54, + "negatives": 2624, + "auroc": 0.7133440605239386, + "auprc": 0.04365709260115959, + "brier": 0.019868342173302543, + "calibration": { + "observed_rate": 0.020164301717699777, + "mean_prediction": 0.02163987572206573, + "calibration_in_the_large": 0.0014755740043659524, + "expected_calibration_error_10bin": 0.0051362357700104125, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + { + "valid": 2678, + "positives": 56, + "negatives": 2622, + "auroc": 0.7142652827721477, + "auprc": 0.04457989895293635, + "brier": 0.020613518025292498, + "calibration": { + "observed_rate": 0.020911127707244213, + "mean_prediction": 0.022481182807308077, + "calibration_in_the_large": 0.0015700551000638642, + "expected_calibration_error_10bin": 0.004488575907112493, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + { + "valid": 2678, + "positives": 60, + "negatives": 2618, + "auroc": 0.7142284186401834, + "auprc": 0.04782118280397353, + "brier": 0.022015007692019608, + "calibration": { + "observed_rate": 0.022404779686333084, + "mean_prediction": 0.023381651270447078, + "calibration_in_the_large": 0.000976871584113994, + "expected_calibration_error_10bin": 0.0043239285364761685, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + { + "valid": 2678, + "positives": 60, + "negatives": 2618, + "auroc": 0.713878278584161, + "auprc": 0.04796019314472051, + "brier": 0.02204410883346001, + "calibration": { + "observed_rate": 0.022404779686333084, + "mean_prediction": 0.02425530897280413, + "calibration_in_the_large": 0.0018505292864710449, + "expected_calibration_error_10bin": 0.004001661300611533, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + { + "valid": 2678, + "positives": 61, + "negatives": 2617, + "auroc": 0.7055193971322438, + "auprc": 0.04760180903211338, + "brier": 0.022456506170720886, + "calibration": { + "observed_rate": 0.022778192681105303, + "mean_prediction": 0.02539477717815436, + "calibration_in_the_large": 0.0026165844970490564, + "expected_calibration_error_10bin": 0.0037081541287134765, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + { + "valid": 2678, + "positives": 61, + "negatives": 2617, + "auroc": 0.7056321529469985, + "auprc": 0.047602282963111885, + "brier": 0.022463358369237574, + "calibration": { + "observed_rate": 0.022778192681105303, + "mean_prediction": 0.025544772664578167, + "calibration_in_the_large": 0.002766579983472864, + "expected_calibration_error_10bin": 0.003763363634819016, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + } + ], + "reason": null + }, + "B96": { + "time_averaged_auroc": 0.7709923009749097, + "time_averaged_auprc": 0.08473078284022512, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2630, + "positives": 15, + "negatives": 2615, + "auroc": 0.790031867431485, + "auprc": 0.019596165838812574, + "brier": 0.005658063159457557, + "calibration": { + "observed_rate": 0.005703422053231939, + "mean_prediction": 0.008594121435500448, + "calibration_in_the_large": 0.0028906993822685086, + "expected_calibration_error_10bin": 0.0028906993822685086, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + { + "valid": 2630, + "positives": 30, + "negatives": 2600, + "auroc": 0.7968846153846154, + "auprc": 0.0711855869121642, + "brier": 0.011053380665508155, + "calibration": { + "observed_rate": 0.011406844106463879, + "mean_prediction": 0.01582336810387816, + "calibration_in_the_large": 0.004416523997414282, + "expected_calibration_error_10bin": 0.0044165239974142834, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + { + "valid": 2630, + "positives": 44, + "negatives": 2586, + "auroc": 0.7772533923926035, + "auprc": 0.09153216062312329, + "brier": 0.01603912335180003, + "calibration": { + "observed_rate": 0.016730038022813688, + "mean_prediction": 0.019063226651920877, + "calibration_in_the_large": 0.00233318862910719, + "expected_calibration_error_10bin": 0.0028366496296911114, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + { + "valid": 2630, + "positives": 52, + "negatives": 2578, + "auroc": 0.7796890851584413, + "auprc": 0.07882778197404422, + "brier": 0.018857111967610606, + "calibration": { + "observed_rate": 0.01977186311787072, + "mean_prediction": 0.022154236024094234, + "calibration_in_the_large": 0.0023823729062235136, + "expected_calibration_error_10bin": 0.00432586968806041, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + { + "valid": 2630, + "positives": 57, + "negatives": 2573, + "auroc": 0.7756254218913003, + "auprc": 0.07749876216998988, + "brier": 0.02070890949649418, + "calibration": { + "observed_rate": 0.02167300380228137, + "mean_prediction": 0.024459386284696825, + "calibration_in_the_large": 0.0027863824824154552, + "expected_calibration_error_10bin": 0.0034803628063665095, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + { + "valid": 2630, + "positives": 61, + "negatives": 2569, + "auroc": 0.7701791218117657, + "auprc": 0.08243834503811502, + "brier": 0.02211030049523188, + "calibration": { + "observed_rate": 0.023193916349809884, + "mean_prediction": 0.026337286727277195, + "calibration_in_the_large": 0.0031433703774673104, + "expected_calibration_error_10bin": 0.003143370377467308, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + { + "valid": 2630, + "positives": 70, + "negatives": 2560, + "auroc": 0.7651785714285714, + "auprc": 0.08751906249908288, + "brier": 0.02524158355700214, + "calibration": { + "observed_rate": 0.026615969581749048, + "mean_prediction": 0.028057191672689767, + "calibration_in_the_large": 0.0014412220909407192, + "expected_calibration_error_10bin": 0.001441222090940717, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + { + "valid": 2630, + "positives": 72, + "negatives": 2558, + "auroc": 0.7645893058813309, + "auprc": 0.09077193630238753, + "brier": 0.025945022310605862, + "calibration": { + "observed_rate": 0.02737642585551331, + "mean_prediction": 0.029572645436349135, + "calibration_in_the_large": 0.0021962195808358266, + "expected_calibration_error_10bin": 0.002296437516086116, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + { + "valid": 2630, + "positives": 74, + "negatives": 2556, + "auroc": 0.7578247261345853, + "auprc": 0.09035135164057617, + "brier": 0.02673514825753859, + "calibration": { + "observed_rate": 0.028136882129277566, + "mean_prediction": 0.03121341411084089, + "calibration_in_the_large": 0.003076531981563324, + "expected_calibration_error_10bin": 0.003640413349348265, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + { + "valid": 2630, + "positives": 77, + "negatives": 2553, + "auroc": 0.7575248879596705, + "auprc": 0.09441734476746036, + "brier": 0.027757063207416555, + "calibration": { + "observed_rate": 0.029277566539923954, + "mean_prediction": 0.03241278580551482, + "calibration_in_the_large": 0.003135219265590867, + "expected_calibration_error_10bin": 0.003417898758120669, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + { + "valid": 2630, + "positives": 83, + "negatives": 2547, + "auroc": 0.7632934565115586, + "auprc": 0.10566919399324594, + "brier": 0.029669016593834956, + "calibration": { + "observed_rate": 0.03155893536121673, + "mean_prediction": 0.03373707001873898, + "calibration_in_the_large": 0.0021781346575222432, + "expected_calibration_error_10bin": 0.00302443400768124, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + { + "valid": 2630, + "positives": 87, + "negatives": 2543, + "auroc": 0.7626705719102698, + "auprc": 0.10601427312785583, + "brier": 0.031065241482676545, + "calibration": { + "observed_rate": 0.03307984790874525, + "mean_prediction": 0.03549711726134034, + "calibration_in_the_large": 0.0024172693525950917, + "expected_calibration_error_10bin": 0.004240118796510458, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + { + "valid": 2630, + "positives": 88, + "negatives": 2542, + "auroc": 0.7621548887776268, + "auprc": 0.10567821203606868, + "brier": 0.03142048388325736, + "calibration": { + "observed_rate": 0.033460076045627375, + "mean_prediction": 0.035680025221670165, + "calibration_in_the_large": 0.0022199491760427903, + "expected_calibration_error_10bin": 0.0044681394955199995, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + } + ], + "reason": null + }, + "B97": { + "time_averaged_auroc": 0.8210576251729687, + "time_averaged_auprc": 0.039290556448577825, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.6215068977714893, + "auprc": 0.0009337068160597573, + "brier": 0.0003536997697645465, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 7.740961095289513e-05, + "calibration_in_the_large": -0.0002761971782974585, + "expected_calibration_error_10bin": 0.0002761971782974585, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7856384860275911, + "auprc": 0.0016474464579901153, + "brier": 0.0003553440566083058, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0002574908743595426, + "calibration_in_the_large": -9.611591489081103e-05, + "expected_calibration_error_10bin": 9.611591489081103e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7693668199504775, + "auprc": 0.0015313935681470138, + "brier": 0.00035860008756675814, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.00042483629806659376, + "calibration_in_the_large": 7.122950881624014e-05, + "expected_calibration_error_10bin": 7.122950881624014e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7789175804740007, + "auprc": 0.001597444089456869, + "brier": 0.00035970886813903015, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0005010145245864516, + "calibration_in_the_large": 0.00014740773533609795, + "expected_calibration_error_10bin": 0.00014740773533609795, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7661832331093031, + "auprc": 0.0015105740181268882, + "brier": 0.0003607148681856676, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0006283767476039144, + "calibration_in_the_large": 0.00027476995835356075, + "expected_calibration_error_10bin": 0.00027476995835356075, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7633533781393703, + "auprc": 0.0014925373134328358, + "brier": 0.0003628513678285792, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0006936673131694139, + "calibration_in_the_large": 0.0003400605239190603, + "expected_calibration_error_10bin": 0.00034006052391906036, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.8788039631988677, + "auprc": 0.04693165032899154, + "brier": 0.0007035246322477768, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0007442137376764404, + "calibration_in_the_large": 3.700015917573317e-05, + "expected_calibration_error_10bin": 5.827571568380824e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.8782731776362349, + "auprc": 0.05146842878120411, + "brier": 0.0007047998568648126, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0008226118942005703, + "calibration_in_the_large": 0.00011539831569986302, + "expected_calibration_error_10bin": 0.00011539831569986312, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.8830502476999292, + "auprc": 0.06402439024390244, + "brier": 0.0007066708712084695, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.001030474308866153, + "calibration_in_the_large": 0.00032326073036544566, + "expected_calibration_error_10bin": 0.0003232607303654456, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.8819886765746638, + "auprc": 0.08483935742971888, + "brier": 0.0007104967834860068, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0011421155055781067, + "calibration_in_the_large": 0.00043490192707739946, + "expected_calibration_error_10bin": 0.00043490192707739935, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.8901273885350318, + "auprc": 0.0849514563106796, + "brier": 0.0007132996613775732, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0012472305460849067, + "calibration_in_the_large": 0.0005400169675841994, + "expected_calibration_error_10bin": 0.0005400169675841997, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.8883581033262562, + "auprc": 0.08492569002123142, + "brier": 0.0007140484048560611, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0013015516304818715, + "calibration_in_the_large": 0.0005943380519811643, + "expected_calibration_error_10bin": 0.0005943380519811643, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.8881811748053786, + "auprc": 0.08492315845257022, + "brier": 0.000714164524613754, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0013065406630265264, + "calibration_in_the_large": 0.0005993270845258192, + "expected_calibration_error_10bin": 0.0005993270845258193, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + } + ], + "reason": null + }, + "C18": { + "time_averaged_auroc": 0.9805650731276093, + "time_averaged_auprc": 0.043883553920295575, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2824, + "positives": 1, + "negatives": 2823, + "auroc": 0.9943322706340773, + "auprc": 0.058823529411764705, + "brier": 0.0003528838931479987, + "calibration": { + "observed_rate": 0.0003541076487252125, + "mean_prediction": 0.0001547864331755465, + "calibration_in_the_large": -0.00019932121554966598, + "expected_calibration_error_10bin": 0.00019932121554966598, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 1, + "negatives": 2823, + "auroc": 0.9953949698901877, + "auprc": 0.07142857142857142, + "brier": 0.0003516113777640893, + "calibration": { + "observed_rate": 0.0003541076487252125, + "mean_prediction": 0.0002840751526779901, + "calibration_in_the_large": -7.003249604722238e-05, + "expected_calibration_error_10bin": 7.003249604722238e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9785613040396882, + "auprc": 0.04050925925925926, + "brier": 0.000704367998987495, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.00035938681878762186, + "calibration_in_the_large": -0.0003488284786628031, + "expected_calibration_error_10bin": 0.0003488284786628031, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9803330970942594, + "auprc": 0.05961538461538462, + "brier": 0.0007031692222511959, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0004795187164982298, + "calibration_in_the_large": -0.00022869658095219517, + "expected_calibration_error_10bin": 0.00022869658095219517, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9803330970942594, + "auprc": 0.05961538461538462, + "brier": 0.0007031559423504111, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0004899668464230267, + "calibration_in_the_large": -0.00021824845102739825, + "expected_calibration_error_10bin": 0.00021824845102739825, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9780297661233168, + "auprc": 0.042261904761904764, + "brier": 0.0007030991331385299, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0005347387465061531, + "calibration_in_the_large": -0.00017347655094427186, + "expected_calibration_error_10bin": 0.00017347655094427186, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9776754075124026, + "auprc": 0.03678678678678678, + "brier": 0.0007030523314844014, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0005607191947892677, + "calibration_in_the_large": -0.00014749610266115724, + "expected_calibration_error_10bin": 0.00014749610266115724, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9780297661233168, + "auprc": 0.03557504873294347, + "brier": 0.0007028030286083171, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0006083776093809804, + "calibration_in_the_large": -9.98376880694446e-05, + "expected_calibration_error_10bin": 9.98376880694446e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9780297661233168, + "auprc": 0.03434579439252337, + "brier": 0.0007026516398527892, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0006670086449082034, + "calibration_in_the_large": -4.120665254222155e-05, + "expected_calibration_error_10bin": 4.120665254222155e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9773210489014883, + "auprc": 0.03400900900900901, + "brier": 0.0007026537389318854, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0006957783647497389, + "calibration_in_the_large": -1.2436932700686108e-05, + "expected_calibration_error_10bin": 1.2436932700686108e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9764351523742026, + "auprc": 0.03250517598343685, + "brier": 0.0007026347925452741, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0007513788382781966, + "calibration_in_the_large": 4.31635408277716e-05, + "expected_calibration_error_10bin": 4.31635408277716e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9764351523742026, + "auprc": 0.03250517598343685, + "brier": 0.0007026352527715723, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0007859895555258753, + "calibration_in_the_large": 7.77742580754503e-05, + "expected_calibration_error_10bin": 7.77742580754503e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9764351523742026, + "auprc": 0.03250517598343685, + "brier": 0.0007026359978206454, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0007881878527218284, + "calibration_in_the_large": 7.997255527140339e-05, + "expected_calibration_error_10bin": 7.997255527140339e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + } + ], + "reason": null + }, + "C22": { + "time_averaged_auroc": 0.9118890721448689, + "time_averaged_auprc": 0.05401951963791619, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2812, + "positives": 2, + "negatives": 2810, + "auroc": 0.9208185053380783, + "auprc": 0.04396024464831804, + "brier": 0.0007060678283516284, + "calibration": { + "observed_rate": 0.0007112375533428165, + "mean_prediction": 0.00027875212895846153, + "calibration_in_the_large": -0.000432485424384355, + "expected_calibration_error_10bin": 0.000432485424384355, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + { + "valid": 2812, + "positives": 3, + "negatives": 2809, + "auroc": 0.9428028954550849, + "auprc": 0.05011043887448382, + "brier": 0.0010560458742047232, + "calibration": { + "observed_rate": 0.0010668563300142249, + "mean_prediction": 0.000415735159615938, + "calibration_in_the_large": -0.0006511211703982868, + "expected_calibration_error_10bin": 0.0006511211703982868, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + { + "valid": 2812, + "positives": 5, + "negatives": 2807, + "auroc": 0.9182757392233701, + "auprc": 0.06204375620050009, + "brier": 0.001754232834736266, + "calibration": { + "observed_rate": 0.0017780938833570413, + "mean_prediction": 0.0004923491451986203, + "calibration_in_the_large": -0.001285744738158421, + "expected_calibration_error_10bin": 0.001285744738158421, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + { + "valid": 2812, + "positives": 5, + "negatives": 2807, + "auroc": 0.9182757392233701, + "auprc": 0.06287053720387054, + "brier": 0.0017524865257811276, + "calibration": { + "observed_rate": 0.0017780938833570413, + "mean_prediction": 0.000537025693932429, + "calibration_in_the_large": -0.0012410681894246124, + "expected_calibration_error_10bin": 0.0012410681894246124, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + { + "valid": 2812, + "positives": 5, + "negatives": 2807, + "auroc": 0.9168507303170644, + "auprc": 0.06114408333288619, + "brier": 0.0017506946693485242, + "calibration": { + "observed_rate": 0.0017780938833570413, + "mean_prediction": 0.0005878883908441022, + "calibration_in_the_large": -0.001190205492512939, + "expected_calibration_error_10bin": 0.001190205492512939, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + { + "valid": 2812, + "positives": 5, + "negatives": 2807, + "auroc": 0.9153544709654435, + "auprc": 0.060322515870585326, + "brier": 0.001747218117061817, + "calibration": { + "observed_rate": 0.0017780938833570413, + "mean_prediction": 0.0006611074772143033, + "calibration_in_the_large": -0.0011169864061427379, + "expected_calibration_error_10bin": 0.0011169864061427379, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + { + "valid": 2812, + "positives": 5, + "negatives": 2807, + "auroc": 0.9147844674029213, + "auprc": 0.060303719668144753, + "brier": 0.001746106064042926, + "calibration": { + "observed_rate": 0.0017780938833570413, + "mean_prediction": 0.0006931453586421115, + "calibration_in_the_large": -0.0010849485247149298, + "expected_calibration_error_10bin": 0.0010849485247149298, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + { + "valid": 2812, + "positives": 6, + "negatives": 2806, + "auroc": 0.909895462105013, + "auprc": 0.05428640511163848, + "brier": 0.0020981081792812435, + "calibration": { + "observed_rate": 0.0021337126600284497, + "mean_prediction": 0.0007656151551714498, + "calibration_in_the_large": -0.001368097504857, + "expected_calibration_error_10bin": 0.001368097504857, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + { + "valid": 2812, + "positives": 6, + "negatives": 2806, + "auroc": 0.9106676170111665, + "auprc": 0.054608543603672094, + "brier": 0.002097318476371525, + "calibration": { + "observed_rate": 0.0021337126600284497, + "mean_prediction": 0.0007932402958315551, + "calibration_in_the_large": -0.0013404723641968945, + "expected_calibration_error_10bin": 0.0013404723641968945, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + { + "valid": 2812, + "positives": 6, + "negatives": 2806, + "auroc": 0.9115585649798051, + "auprc": 0.0537634691569606, + "brier": 0.0020963840916934473, + "calibration": { + "observed_rate": 0.0021337126600284497, + "mean_prediction": 0.0008539459480911996, + "calibration_in_the_large": -0.0012797667119372501, + "expected_calibration_error_10bin": 0.0012797667119372501, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + { + "valid": 2812, + "positives": 7, + "negatives": 2805, + "auroc": 0.8916221033868093, + "auprc": 0.04732860519736183, + "brier": 0.002451164683372533, + "calibration": { + "observed_rate": 0.0024893314366998577, + "mean_prediction": 0.0008726261746534039, + "calibration_in_the_large": -0.001616705262046454, + "expected_calibration_error_10bin": 0.001616705262046454, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + { + "valid": 2812, + "positives": 7, + "negatives": 2805, + "auroc": 0.8918258212375859, + "auprc": 0.04575571821224432, + "brier": 0.0024500402961177676, + "calibration": { + "observed_rate": 0.0024893314366998577, + "mean_prediction": 0.0009127940972244547, + "calibration_in_the_large": -0.001576537339475403, + "expected_calibration_error_10bin": 0.001576537339475403, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + { + "valid": 2812, + "positives": 7, + "negatives": 2805, + "auroc": 0.8918258212375859, + "auprc": 0.04575571821224432, + "brier": 0.0024500006845028987, + "calibration": { + "observed_rate": 0.0024893314366998577, + "mean_prediction": 0.0009145903809097075, + "calibration_in_the_large": -0.0015747410557901502, + "expected_calibration_error_10bin": 0.0015747410557901502, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + } + ], + "reason": null + }, + "C25": { + "time_averaged_auroc": 0.957840421631158, + "time_averaged_auprc": 0.17767189798481864, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2809, + "positives": 0, + "negatives": 2809, + "auroc": null, + "auprc": null, + "brier": 1.2233215113879197e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00012656371625303182, + "calibration_in_the_large": 0.00012656371625303182, + "expected_calibration_error_10bin": 0.00012656371625303182, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 1, + "negatives": 2808, + "auroc": 0.9989316239316239, + "auprc": 0.25, + "brier": 0.00033294007716267246, + "calibration": { + "observed_rate": 0.000355998576005696, + "mean_prediction": 0.00031430111194878706, + "calibration_in_the_large": -4.169746405690894e-05, + "expected_calibration_error_10bin": 0.00011631139230007141, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 1, + "negatives": 2808, + "auroc": 0.9992877492877493, + "auprc": 0.3333333333333333, + "brier": 0.00032982695302178255, + "calibration": { + "observed_rate": 0.000355998576005696, + "mean_prediction": 0.0003772138722228268, + "calibration_in_the_large": 2.1215296217130786e-05, + "expected_calibration_error_10bin": 6.438180634599325e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 1, + "negatives": 2808, + "auroc": 0.9992877492877493, + "auprc": 0.3333333333333333, + "brier": 0.0003291317094461688, + "calibration": { + "observed_rate": 0.000355998576005696, + "mean_prediction": 0.0004055828513691973, + "calibration_in_the_large": 4.958427536350129e-05, + "expected_calibration_error_10bin": 4.95842753635013e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.9360527253295333, + "auprc": 0.16945218198700093, + "brier": 0.0006842406525092006, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0004400499553069006, + "calibration_in_the_large": -0.0002719471967044914, + "expected_calibration_error_10bin": 0.0003655499998407337, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.9428215176344852, + "auprc": 0.16978193146417445, + "brier": 0.000683416122738082, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0004786934134901102, + "calibration_in_the_large": -0.0002333037385212818, + "expected_calibration_error_10bin": 0.00033199446331004127, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.9413965087281796, + "auprc": 0.1697061803444782, + "brier": 0.0006826048870902903, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0005143310983835701, + "calibration_in_the_large": -0.0001976660536278219, + "expected_calibration_error_10bin": 0.00029946232045589236, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.9419308870680442, + "auprc": 0.16973415132924335, + "brier": 0.0006819223110387211, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0005407443724165018, + "calibration_in_the_large": -0.00017125277959489016, + "expected_calibration_error_10bin": 0.0002761262078241845, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 3, + "negatives": 2806, + "auroc": 0.9542646709432169, + "auprc": 0.12404003267973857, + "brier": 0.0010352626635887136, + "calibration": { + "observed_rate": 0.001067995728017088, + "mean_prediction": 0.0005779991475532258, + "calibration_in_the_large": -0.0004899965804638622, + "expected_calibration_error_10bin": 0.0005976452425434693, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 3, + "negatives": 2806, + "auroc": 0.953551912568306, + "auprc": 0.1235967577048116, + "brier": 0.0010347351140497776, + "calibration": { + "observed_rate": 0.001067995728017088, + "mean_prediction": 0.000616092120475062, + "calibration_in_the_large": -0.00045190360754202594, + "expected_calibration_error_10bin": 0.0006387574848747465, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 4, + "negatives": 2805, + "auroc": 0.9431372549019608, + "auprc": 0.09647012807695883, + "brier": 0.0013899476251098115, + "calibration": { + "observed_rate": 0.001423994304022784, + "mean_prediction": 0.0006296441577137857, + "calibration_in_the_large": -0.0007943501463089983, + "expected_calibration_error_10bin": 0.0009827610809334444, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 4, + "negatives": 2805, + "auroc": 0.941711229946524, + "auprc": 0.09630737278237556, + "brier": 0.0013896790502422008, + "calibration": { + "observed_rate": 0.001423994304022784, + "mean_prediction": 0.0006517281181991889, + "calibration_in_the_large": -0.0007722661858235951, + "expected_calibration_error_10bin": 0.0009621898084580915, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 4, + "negatives": 2805, + "auroc": 0.941711229946524, + "auprc": 0.09630737278237556, + "brier": 0.0013896663473735756, + "calibration": { + "observed_rate": 0.001423994304022784, + "mean_prediction": 0.0006531163991040444, + "calibration_in_the_large": -0.0007708779049187395, + "expected_calibration_error_10bin": 0.0009609629629884268, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + } + ], + "reason": null + }, + "C61": { + "time_averaged_auroc": 0.968715220195446, + "time_averaged_auprc": 0.018494079045366933, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2805, + "positives": 1, + "negatives": 2804, + "auroc": 0.9860912981455064, + "auprc": 0.025, + "brier": 0.00035549043991589166, + "calibration": { + "observed_rate": 0.00035650623885918, + "mean_prediction": 0.00020481075376906663, + "calibration_in_the_large": -0.0001516954850901134, + "expected_calibration_error_10bin": 0.0001516954850901134, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9628968961826614, + "auprc": 0.017821921668075513, + "brier": 0.0007102068953846075, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0004568420150857534, + "calibration_in_the_large": -0.00025617046263260666, + "expected_calibration_error_10bin": 0.00025617046263260666, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9662861220121298, + "auprc": 0.018571428571428572, + "brier": 0.0007100663180742796, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0005462121118349864, + "calibration_in_the_large": -0.00016680036588337366, + "expected_calibration_error_10bin": 0.00016680036588337366, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9641455583303603, + "auprc": 0.015802318486882246, + "brier": 0.0007107883890998077, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0006970757841032236, + "calibration_in_the_large": -1.5936693615136496e-05, + "expected_calibration_error_10bin": 1.5936693615136496e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9668212629325722, + "auprc": 0.017346938775510204, + "brier": 0.0007105213183741003, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0007613328664100178, + "calibration_in_the_large": 4.832038869165777e-05, + "expected_calibration_error_10bin": 4.832038869165777e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9661077417053158, + "auprc": 0.016993006993006994, + "brier": 0.0007109523360756232, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0008626853959295447, + "calibration_in_the_large": 0.0001496729182111846, + "expected_calibration_error_10bin": 0.0001496729182111846, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9662861220121298, + "auprc": 0.01704225352112676, + "brier": 0.0007113251602768912, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0009252220495666388, + "calibration_in_the_large": 0.00021220957184827879, + "expected_calibration_error_10bin": 0.00021220957184827879, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9671780235462005, + "auprc": 0.017450458444247263, + "brier": 0.0007115598967927753, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0010146582764448174, + "calibration_in_the_large": 0.0003016457987264574, + "expected_calibration_error_10bin": 0.0003016457987264574, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9675347841598287, + "auprc": 0.017884674683934627, + "brier": 0.0007118522832717488, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0011228692085208287, + "calibration_in_the_large": 0.00040985673080246867, + "expected_calibration_error_10bin": 0.00040985673080246867, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9696753478415983, + "auprc": 0.018923611111111113, + "brier": 0.0007121644540295471, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0012037762028997733, + "calibration_in_the_large": 0.0004907637251814133, + "expected_calibration_error_10bin": 0.0004907637251814133, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9698537281484124, + "auprc": 0.01898512685914261, + "brier": 0.0007122097853511681, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0012166992593957923, + "calibration_in_the_large": 0.0005036867816774322, + "expected_calibration_error_10bin": 0.0005036867816774322, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9700321084552266, + "auprc": 0.01923765211166786, + "brier": 0.0007127307679793439, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0012971166741230192, + "calibration_in_the_large": 0.0005841041964046591, + "expected_calibration_error_10bin": 0.0005841041964046591, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9703888690688548, + "auprc": 0.019363636363636364, + "brier": 0.0007129310103150307, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.001323420144907688, + "calibration_in_the_large": 0.0006104076671893279, + "expected_calibration_error_10bin": 0.0006104076671893279, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + } + ], + "reason": null + }, + "C67": { + "time_averaged_auroc": 0.9502870670185846, + "time_averaged_auprc": 0.027323055264709104, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9419879731163778, + "auprc": 0.018507219849501728, + "brier": 0.0007059142735014069, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.00014203626397502598, + "calibration_in_the_large": -0.0005649273274000182, + "expected_calibration_error_10bin": 0.0005649273274000182, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9361513972408914, + "auprc": 0.01622537939941879, + "brier": 0.0007055528363628442, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.00022349752249434905, + "calibration_in_the_large": -0.0004834660688806952, + "expected_calibration_error_10bin": 0.0004834660688806952, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9478245489918642, + "auprc": 0.020958851429303933, + "brier": 0.000705050062848144, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0002963797546735551, + "calibration_in_the_large": -0.00041058383670148914, + "expected_calibration_error_10bin": 0.00041058383670148914, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9511850017686594, + "auprc": 0.03505228136882129, + "brier": 0.000703061332616117, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.000496910078489676, + "calibration_in_the_large": -0.00021005351288536827, + "expected_calibration_error_10bin": 0.00021005351288536827, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9517155995755218, + "auprc": 0.03327276856688621, + "brier": 0.0007030681030809465, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0005386514939887332, + "calibration_in_the_large": -0.00016831209738631104, + "expected_calibration_error_10bin": 0.00016831209738631104, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9522461973823841, + "auprc": 0.03331801470588235, + "brier": 0.0007031322150965236, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.000599776793303456, + "calibration_in_the_large": -0.0001071867980715882, + "expected_calibration_error_10bin": 0.0001071867980715882, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.949770074283693, + "auprc": 0.0300471327572663, + "brier": 0.0007033382026973343, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0006667940544772014, + "calibration_in_the_large": -4.016953689784286e-05, + "expected_calibration_error_10bin": 4.016953689784286e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9517155995755218, + "auprc": 0.02890625, + "brier": 0.000703414552842913, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0007255357906926125, + "calibration_in_the_large": 1.857219931756832e-05, + "expected_calibration_error_10bin": 1.857219931756832e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9495932083480721, + "auprc": 0.02648667122351333, + "brier": 0.0007037393851275729, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0007659688516722687, + "calibration_in_the_large": 5.9005260297224525e-05, + "expected_calibration_error_10bin": 5.9005260297224525e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9564909798372834, + "auprc": 0.029366812227074237, + "brier": 0.0007034576136908611, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0008743940955873919, + "calibration_in_the_large": 0.00016743050421234764, + "expected_calibration_error_10bin": 0.00016743050421234764, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9552529182879378, + "auprc": 0.028064842958459978, + "brier": 0.0007039582101139526, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0009394549797428163, + "calibration_in_the_large": 0.0002324913883677721, + "expected_calibration_error_10bin": 0.0002324913883677721, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9548991864166961, + "auprc": 0.02802893309222423, + "brier": 0.0007041600505798942, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.000969298598436686, + "calibration_in_the_large": 0.0002623350070616418, + "expected_calibration_error_10bin": 0.0002623350070616418, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9548991864166961, + "auprc": 0.026964560862865947, + "brier": 0.0007042191567337818, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0009803426773045236, + "calibration_in_the_large": 0.0002733790859294794, + "expected_calibration_error_10bin": 0.0002733790859294794, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + } + ], + "reason": null + }, + "C77": { + "time_averaged_auroc": 0.85311503349704, + "time_averaged_auprc": 0.12573519990364201, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2762, + "positives": 4, + "negatives": 2758, + "auroc": 0.7873459028281363, + "auprc": 0.1472339260792146, + "brier": 0.0013895700102996686, + "calibration": { + "observed_rate": 0.001448225923244026, + "mean_prediction": 0.0011123982056656023, + "calibration_in_the_large": -0.0003358277175784237, + "expected_calibration_error_10bin": 0.0003358277175784237, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 8, + "negatives": 2754, + "auroc": 0.8671023965141612, + "auprc": 0.11788895498609095, + "brier": 0.002749709324197718, + "calibration": { + "observed_rate": 0.002896451846488052, + "mean_prediction": 0.001945778652245556, + "calibration_in_the_large": -0.000950673194242496, + "expected_calibration_error_10bin": 0.0009506731942424963, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 11, + "negatives": 2751, + "auroc": 0.8414791315554674, + "auprc": 0.09196641283536766, + "brier": 0.0038186965691718814, + "calibration": { + "observed_rate": 0.0039826212889210715, + "mean_prediction": 0.0025033350080765023, + "calibration_in_the_large": -0.0014792862808445692, + "expected_calibration_error_10bin": 0.0019706848462132352, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 13, + "negatives": 2749, + "auroc": 0.8649299045806866, + "auprc": 0.12421080261327702, + "brier": 0.004434640464886088, + "calibration": { + "observed_rate": 0.004706734250543085, + "mean_prediction": 0.0029136339734242415, + "calibration_in_the_large": -0.0017931002771188437, + "expected_calibration_error_10bin": 0.0021207810630803946, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 14, + "negatives": 2748, + "auroc": 0.8648627573300063, + "auprc": 0.12118901577974514, + "brier": 0.004789876268333504, + "calibration": { + "observed_rate": 0.005068790731354091, + "mean_prediction": 0.0033614876988622036, + "calibration_in_the_large": -0.0017073030324918875, + "expected_calibration_error_10bin": 0.002013334038967249, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 16, + "negatives": 2746, + "auroc": 0.8404042243262928, + "auprc": 0.11543122699415845, + "brier": 0.005501438471005535, + "calibration": { + "observed_rate": 0.005792903692976104, + "mean_prediction": 0.0035446311117575046, + "calibration_in_the_large": -0.0022482725812185992, + "expected_calibration_error_10bin": 0.0028904365367192417, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 17, + "negatives": 2745, + "auroc": 0.8436087003107254, + "auprc": 0.1112248781711873, + "brier": 0.00585921730998317, + "calibration": { + "observed_rate": 0.006154960173787111, + "mean_prediction": 0.003740950765523578, + "calibration_in_the_large": -0.0024140094082635327, + "expected_calibration_error_10bin": 0.003088698412082246, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 20, + "negatives": 2742, + "auroc": 0.8652990517870168, + "auprc": 0.13727957784476147, + "brier": 0.00681339071200404, + "calibration": { + "observed_rate": 0.00724112961622013, + "mean_prediction": 0.003946618014080588, + "calibration_in_the_large": -0.003294511602139542, + "expected_calibration_error_10bin": 0.004003116425724378, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 20, + "negatives": 2742, + "auroc": 0.8640773158278628, + "auprc": 0.1392395659858207, + "brier": 0.006805641422517435, + "calibration": { + "observed_rate": 0.00724112961622013, + "mean_prediction": 0.004179705685133631, + "calibration_in_the_large": -0.0030614239310864993, + "expected_calibration_error_10bin": 0.003798023310480279, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 20, + "negatives": 2742, + "auroc": 0.8632385120350109, + "auprc": 0.13848106202711488, + "brier": 0.0068042239488553926, + "calibration": { + "observed_rate": 0.00724112961622013, + "mean_prediction": 0.004310204937242107, + "calibration_in_the_large": -0.0029309246789780237, + "expected_calibration_error_10bin": 0.003690731133289176, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 22, + "negatives": 2740, + "auroc": 0.860335102853351, + "auprc": 0.13034983274907289, + "brier": 0.007519270974178952, + "calibration": { + "observed_rate": 0.007965242577842143, + "mean_prediction": 0.004473566616705325, + "calibration_in_the_large": -0.003491675961136818, + "expected_calibration_error_10bin": 0.004430732605276119, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 23, + "negatives": 2739, + "auroc": 0.8639141546422846, + "auprc": 0.12978120518211964, + "brier": 0.007868236126692664, + "calibration": { + "observed_rate": 0.00832729905865315, + "mean_prediction": 0.004653457129693804, + "calibration_in_the_large": -0.003673841928959346, + "expected_calibration_error_10bin": 0.004636287709777658, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 23, + "negatives": 2739, + "auroc": 0.8638982808705177, + "auprc": 0.13028113749941547, + "brier": 0.007866708246759288, + "calibration": { + "observed_rate": 0.00832729905865315, + "mean_prediction": 0.004697787376122541, + "calibration_in_the_large": -0.0036295116825306086, + "expected_calibration_error_10bin": 0.004598797225818384, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + } + ], + "reason": null + }, + "C78": { + "time_averaged_auroc": 0.8790249043384544, + "time_averaged_auprc": 0.14723450769304017, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2762, + "positives": 7, + "negatives": 2755, + "auroc": 0.947005444646098, + "auprc": 0.12373446943095467, + "brier": 0.002405684190859022, + "calibration": { + "observed_rate": 0.0025343953656770456, + "mean_prediction": 0.0015402597410777582, + "calibration_in_the_large": -0.0009941356245992874, + "expected_calibration_error_10bin": 0.0014139004182694389, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 14, + "negatives": 2748, + "auroc": 0.9048918694115201, + "auprc": 0.14757751797946872, + "brier": 0.004731140202662636, + "calibration": { + "observed_rate": 0.005068790731354091, + "mean_prediction": 0.0029291022250806324, + "calibration_in_the_large": -0.0021396885062734588, + "expected_calibration_error_10bin": 0.0023829781141964435, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 16, + "negatives": 2746, + "auroc": 0.9068417698470502, + "auprc": 0.14979721047648617, + "brier": 0.005395391894854472, + "calibration": { + "observed_rate": 0.005792903692976104, + "mean_prediction": 0.0037771367022275595, + "calibration_in_the_large": -0.0020157669907485444, + "expected_calibration_error_10bin": 0.0023085162825752714, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 18, + "negatives": 2744, + "auroc": 0.8586613216715258, + "auprc": 0.1442203083638084, + "brier": 0.006101351567799488, + "calibration": { + "observed_rate": 0.0065170166545981175, + "mean_prediction": 0.004492413596781499, + "calibration_in_the_large": -0.0020246030578166185, + "expected_calibration_error_10bin": 0.0033100981796875505, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 21, + "negatives": 2741, + "auroc": 0.8568996369069335, + "auprc": 0.13918249625526805, + "brier": 0.0071191449179617275, + "calibration": { + "observed_rate": 0.007603186097031137, + "mean_prediction": 0.004830477924838586, + "calibration_in_the_large": -0.0027727081721925515, + "expected_calibration_error_10bin": 0.004631701371597628, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 23, + "negatives": 2739, + "auroc": 0.8639617759575853, + "auprc": 0.1422446438347636, + "brier": 0.00777035313508506, + "calibration": { + "observed_rate": 0.00832729905865315, + "mean_prediction": 0.00512411198707698, + "calibration_in_the_large": -0.00320318707157617, + "expected_calibration_error_10bin": 0.0046862986525084225, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 25, + "negatives": 2737, + "auroc": 0.8640555352575813, + "auprc": 0.13411050406476316, + "brier": 0.00848759718506765, + "calibration": { + "observed_rate": 0.009051412020275163, + "mean_prediction": 0.005515646435585115, + "calibration_in_the_large": -0.0035357655846900487, + "expected_calibration_error_10bin": 0.004943215548549383, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 25, + "negatives": 2737, + "auroc": 0.8639824625502375, + "auprc": 0.13397624192252688, + "brier": 0.008493397097069718, + "calibration": { + "observed_rate": 0.009051412020275163, + "mean_prediction": 0.006035030109147776, + "calibration_in_the_large": -0.0030163819111273873, + "expected_calibration_error_10bin": 0.004589912502714713, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 28, + "negatives": 2734, + "auroc": 0.8685599331173581, + "auprc": 0.1486860494487457, + "brier": 0.009395423324219578, + "calibration": { + "observed_rate": 0.010137581462708182, + "mean_prediction": 0.006402739009950671, + "calibration_in_the_large": -0.0037348424527575115, + "expected_calibration_error_10bin": 0.005375638304875167, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 32, + "negatives": 2730, + "auroc": 0.8685668498168498, + "auprc": 0.1411932884997218, + "brier": 0.010817200380576724, + "calibration": { + "observed_rate": 0.011585807385952208, + "mean_prediction": 0.0068503778362160725, + "calibration_in_the_large": -0.004735429549736135, + "expected_calibration_error_10bin": 0.007075601189634701, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 35, + "negatives": 2727, + "auroc": 0.8779611294462779, + "auprc": 0.16983576841228193, + "brier": 0.011584723580146545, + "calibration": { + "observed_rate": 0.012671976828385228, + "mean_prediction": 0.007204741439392891, + "calibration_in_the_large": -0.0054672353889923374, + "expected_calibration_error_10bin": 0.00724036773612931, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 37, + "negatives": 2725, + "auroc": 0.8729580957103893, + "auprc": 0.16969526346581906, + "brier": 0.01224083826778906, + "calibration": { + "observed_rate": 0.013396089790007242, + "mean_prediction": 0.007497510477367754, + "calibration_in_the_large": -0.005898579312639488, + "expected_calibration_error_10bin": 0.0077733356045258176, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + { + "valid": 2762, + "positives": 37, + "negatives": 2725, + "auroc": 0.8729779320605009, + "auprc": 0.1697948378549138, + "brier": 0.012238772332080825, + "calibration": { + "observed_rate": 0.013396089790007242, + "mean_prediction": 0.007541309982074069, + "calibration_in_the_large": -0.005854779807933173, + "expected_calibration_error_10bin": 0.007745569139622077, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + } + ], + "reason": null + }, + "C79": { + "time_averaged_auroc": 0.890851610878281, + "time_averaged_auprc": 0.13984213687756222, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2751, + "positives": 4, + "negatives": 2747, + "auroc": 0.9277393520203858, + "auprc": 0.0955394434072852, + "brier": 0.0014052405723874984, + "calibration": { + "observed_rate": 0.0014540167211922936, + "mean_prediction": 0.0016964700996565058, + "calibration_in_the_large": 0.00024245337846421212, + "expected_calibration_error_10bin": 0.00024245337846421207, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 8, + "negatives": 2743, + "auroc": 0.9150109369303682, + "auprc": 0.06008515514365798, + "brier": 0.0030018531042520034, + "calibration": { + "observed_rate": 0.0029080334423845873, + "mean_prediction": 0.003366127608687143, + "calibration_in_the_large": 0.00045809416630255553, + "expected_calibration_error_10bin": 0.0017932711237807525, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 9, + "negatives": 2742, + "auroc": 0.9209417294756463, + "auprc": 0.06498286916079948, + "brier": 0.0036442276842902754, + "calibration": { + "observed_rate": 0.003271537622682661, + "mean_prediction": 0.004927303007315006, + "calibration_in_the_large": 0.0016557653846323455, + "expected_calibration_error_10bin": 0.0019406252924467312, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 14, + "negatives": 2737, + "auroc": 0.8635628164309201, + "auprc": 0.13633507790755187, + "brier": 0.005236652874855836, + "calibration": { + "observed_rate": 0.005089058524173028, + "mean_prediction": 0.005926548452542474, + "calibration_in_the_large": 0.0008374899283694458, + "expected_calibration_error_10bin": 0.0036764565028709535, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 14, + "negatives": 2737, + "auroc": 0.8665640169111123, + "auprc": 0.13670696655779718, + "brier": 0.005330238985050127, + "calibration": { + "observed_rate": 0.005089058524173028, + "mean_prediction": 0.006524582754563602, + "calibration_in_the_large": 0.0014355242303905735, + "expected_calibration_error_10bin": 0.0029258361789636883, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 16, + "negatives": 2735, + "auroc": 0.8785420475319927, + "auprc": 0.141265414158312, + "brier": 0.006082428121369399, + "calibration": { + "observed_rate": 0.0058160668847691745, + "mean_prediction": 0.007142389420115161, + "calibration_in_the_large": 0.0013263225353459867, + "expected_calibration_error_10bin": 0.0035116790583793423, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 19, + "negatives": 2732, + "auroc": 0.8690953224936426, + "auprc": 0.13388323585604597, + "brier": 0.007293239323071102, + "calibration": { + "observed_rate": 0.0069065794256633955, + "mean_prediction": 0.007707556936019121, + "calibration_in_the_large": 0.0008009775103557252, + "expected_calibration_error_10bin": 0.004600170782195486, + "nonempty_bins": 8 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 20, + "negatives": 2731, + "auroc": 0.8758879531307213, + "auprc": 0.13987392279243738, + "brier": 0.0076812530406336465, + "calibration": { + "observed_rate": 0.007270083605961469, + "mean_prediction": 0.008371310684169502, + "calibration_in_the_large": 0.0011012270782080336, + "expected_calibration_error_10bin": 0.004218063410522827, + "nonempty_bins": 8 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 23, + "negatives": 2728, + "auroc": 0.8917187300777764, + "auprc": 0.16320547199553243, + "brier": 0.00836540918243974, + "calibration": { + "observed_rate": 0.008360596146855689, + "mean_prediction": 0.008887117064426426, + "calibration_in_the_large": 0.0005265209175707372, + "expected_calibration_error_10bin": 0.004453529724587719, + "nonempty_bins": 8 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 25, + "negatives": 2726, + "auroc": 0.8990315480557594, + "auprc": 0.1776765151220698, + "brier": 0.008916908190391046, + "calibration": { + "observed_rate": 0.009087604507451835, + "mean_prediction": 0.009378586193809846, + "calibration_in_the_large": 0.0002909816863580113, + "expected_calibration_error_10bin": 0.004387251466202768, + "nonempty_bins": 8 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 26, + "negatives": 2725, + "auroc": 0.8886520818630911, + "auprc": 0.17817740314178188, + "brier": 0.009369244329679538, + "calibration": { + "observed_rate": 0.009451108687749909, + "mean_prediction": 0.009979284598138693, + "calibration_in_the_large": 0.000528175910388784, + "expected_calibration_error_10bin": 0.004524451338402987, + "nonempty_bins": 9 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 29, + "negatives": 2722, + "auroc": 0.8922445463528339, + "auprc": 0.19499435827666262, + "brier": 0.010249528923911354, + "calibration": { + "observed_rate": 0.010541621228644129, + "mean_prediction": 0.010232432039499605, + "calibration_in_the_large": -0.00030918918914452434, + "expected_calibration_error_10bin": 0.0049989711262115755, + "nonempty_bins": 9 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 29, + "negatives": 2722, + "auroc": 0.8920798601434037, + "auprc": 0.19522194588837513, + "brier": 0.010258074021073097, + "calibration": { + "observed_rate": 0.010541621228644129, + "mean_prediction": 0.010322328570563082, + "calibration_in_the_large": -0.0002192926580810474, + "expected_calibration_error_10bin": 0.0049489966747252815, + "nonempty_bins": 9 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + } + ], + "reason": null + }, + "C83": { + "time_averaged_auroc": 0.3303736104820504, + "time_averaged_auprc": 0.0010042674317064355, + "valid_timepoint_cells": 5, + "timepoints": [ + { + "valid": 2820, + "positives": 0, + "negatives": 2820, + "auroc": null, + "auprc": null, + "brier": 1.2255049540225954e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00012363318808071095, + "calibration_in_the_large": 0.00012363318808071095, + "expected_calibration_error_10bin": 0.00012363318808071095, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 0, + "negatives": 2820, + "auroc": null, + "auprc": null, + "brier": 3.482500131865699e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00020263903368675153, + "calibration_in_the_large": 0.00020263903368675153, + "expected_calibration_error_10bin": 0.00020263903368675153, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 0, + "negatives": 2820, + "auroc": null, + "auprc": null, + "brier": 8.6204665346556e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0003089594705795581, + "calibration_in_the_large": 0.0003089594705795581, + "expected_calibration_error_10bin": 0.0003089594705795581, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 0, + "negatives": 2820, + "auroc": null, + "auprc": null, + "brier": 1.3140757307764607e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00038348435296674526, + "calibration_in_the_large": 0.00038348435296674526, + "expected_calibration_error_10bin": 0.00038348435296674526, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 0, + "negatives": 2820, + "auroc": null, + "auprc": null, + "brier": 1.4168374985006761e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004227784032575576, + "calibration_in_the_large": 0.0004227784032575576, + "expected_calibration_error_10bin": 0.0004227784032575576, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 0, + "negatives": 2820, + "auroc": null, + "auprc": null, + "brier": 1.53415125825947e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00044731414271603087, + "calibration_in_the_large": 0.00044731414271603087, + "expected_calibration_error_10bin": 0.00044731414271603087, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 0, + "negatives": 2820, + "auroc": null, + "auprc": null, + "brier": 1.6643622567202448e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00047259045290554, + "calibration_in_the_large": 0.00047259045290554, + "expected_calibration_error_10bin": 0.00047259045290554006, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 0, + "negatives": 2820, + "auroc": null, + "auprc": null, + "brier": 1.693479757208866e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004831406754132692, + "calibration_in_the_large": 0.0004831406754132692, + "expected_calibration_error_10bin": 0.0004831406754132692, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 1, + "negatives": 2819, + "auroc": 0.0358283079106066, + "auprc": 0.0003677822728944465, + "brier": 0.0003719726250668387, + "calibration": { + "observed_rate": 0.0003546099290780142, + "mean_prediction": 0.0005033430904082152, + "calibration_in_the_large": 0.00014873316133020095, + "expected_calibration_error_10bin": 0.00014873316133020103, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 2, + "negatives": 2818, + "auroc": 0.40507452093683466, + "auprc": 0.0011707836920459129, + "brier": 0.0007267208043557104, + "calibration": { + "observed_rate": 0.0007092198581560284, + "mean_prediction": 0.0005141076521553298, + "calibration_in_the_large": -0.0001951122060006986, + "expected_calibration_error_10bin": 0.00029327329888738656, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 2, + "negatives": 2818, + "auroc": 0.4027679205110007, + "auprc": 0.001158747544289713, + "brier": 0.000727971317716531, + "calibration": { + "observed_rate": 0.0007092198581560284, + "mean_prediction": 0.0005347253911451896, + "calibration_in_the_large": -0.00017449446701083883, + "expected_calibration_error_10bin": 0.0002764304361877061, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 2, + "negatives": 2818, + "auroc": 0.40454222853087296, + "auprc": 0.001163480376703772, + "brier": 0.0007320777528648113, + "calibration": { + "observed_rate": 0.0007092198581560284, + "mean_prediction": 0.0005839042221763753, + "calibration_in_the_large": -0.00012531563597965314, + "expected_calibration_error_10bin": 0.00031342458176026515, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 2, + "negatives": 2818, + "auroc": 0.40365507452093685, + "auprc": 0.0011605432725983324, + "brier": 0.0007321592730996599, + "calibration": { + "observed_rate": 0.0007092198581560284, + "mean_prediction": 0.0005861399417029889, + "calibration_in_the_large": -0.00012307991645303955, + "expected_calibration_error_10bin": 0.0003115736133861367, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + } + ], + "reason": null + }, + "D25": { + "time_averaged_auroc": 0.9482746231280218, + "time_averaged_auprc": 0.4292018806202951, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2792, + "positives": 2, + "negatives": 2790, + "auroc": 0.932258064516129, + "auprc": 0.1276525198938992, + "brier": 0.0007145557782585815, + "calibration": { + "observed_rate": 0.0007163323782234957, + "mean_prediction": 0.0001263426421963363, + "calibration_in_the_large": -0.0005899897360271593, + "expected_calibration_error_10bin": 0.0005899897360271593, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 2, + "negatives": 2790, + "auroc": 0.9424731182795699, + "auprc": 0.16978193146417445, + "brier": 0.0007133443686460268, + "calibration": { + "observed_rate": 0.0007163323782234957, + "mean_prediction": 0.0001973243105945757, + "calibration_in_the_large": -0.00051900806762892, + "expected_calibration_error_10bin": 0.00051900806762892, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 2, + "negatives": 2790, + "auroc": 0.9410394265232975, + "auprc": 0.25303030303030305, + "brier": 0.0007109832724271869, + "calibration": { + "observed_rate": 0.0007163323782234957, + "mean_prediction": 0.0002706365691185113, + "calibration_in_the_large": -0.00044569580910498437, + "expected_calibration_error_10bin": 0.00044569580910498437, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 2, + "negatives": 2790, + "auroc": 0.9419354838709677, + "auprc": 0.2530769230769231, + "brier": 0.0007105554704747896, + "calibration": { + "observed_rate": 0.0007163323782234957, + "mean_prediction": 0.00029768954705450284, + "calibration_in_the_large": -0.00041864283116899284, + "expected_calibration_error_10bin": 0.00041864283116899284, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 2, + "negatives": 2790, + "auroc": 0.9378136200716846, + "auprc": 0.25287356321839083, + "brier": 0.0007088786588731285, + "calibration": { + "observed_rate": 0.0007163323782234957, + "mean_prediction": 0.00037173822934366454, + "calibration_in_the_large": -0.00034459414887983114, + "expected_calibration_error_10bin": 0.00034459414887983114, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 2, + "negatives": 2790, + "auroc": 0.9372759856630825, + "auprc": 0.25284900284900286, + "brier": 0.0007085688401575147, + "calibration": { + "observed_rate": 0.0007163323782234957, + "mean_prediction": 0.00038763569158029384, + "calibration_in_the_large": -0.00032869668664320184, + "expected_calibration_error_10bin": 0.00032869668664320184, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 2, + "negatives": 2790, + "auroc": 0.9408602150537635, + "auprc": 0.25302114803625375, + "brier": 0.0007075706171173061, + "calibration": { + "observed_rate": 0.0007163323782234957, + "mean_prediction": 0.000426448805266687, + "calibration_in_the_large": -0.0002898835729568087, + "expected_calibration_error_10bin": 0.0002898835729568087, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 3, + "negatives": 2789, + "auroc": 0.9602007888131947, + "auprc": 0.6696428571428572, + "brier": 0.0010538583273237967, + "calibration": { + "observed_rate": 0.0010744985673352436, + "mean_prediction": 0.000459370656666094, + "calibration_in_the_large": -0.0006151279106691495, + "expected_calibration_error_10bin": 0.0006151279106691495, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 3, + "negatives": 2789, + "auroc": 0.9585275487032389, + "auprc": 0.6695238095238095, + "brier": 0.001053299506295539, + "calibration": { + "observed_rate": 0.0010744985673352436, + "mean_prediction": 0.0004860030475138724, + "calibration_in_the_large": -0.0005884955198213711, + "expected_calibration_error_10bin": 0.0005884955198213711, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 3, + "negatives": 2789, + "auroc": 0.9581689972511055, + "auprc": 0.6694995278564684, + "brier": 0.001052896889070611, + "calibration": { + "observed_rate": 0.0010744985673352436, + "mean_prediction": 0.0005001326924392818, + "calibration_in_the_large": -0.0005743658748959617, + "expected_calibration_error_10bin": 0.0005743658748959617, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 3, + "negatives": 2789, + "auroc": 0.9580494801003944, + "auprc": 0.6694915254237288, + "brier": 0.0010518761951687993, + "calibration": { + "observed_rate": 0.0010744985673352436, + "mean_prediction": 0.0005174600949640679, + "calibration_in_the_large": -0.0005570384723711756, + "expected_calibration_error_10bin": 0.0005570384723711756, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 3, + "negatives": 2789, + "auroc": 0.9593641687582168, + "auprc": 0.6695821185617103, + "brier": 0.0010508058013933153, + "calibration": { + "observed_rate": 0.0010744985673352436, + "mean_prediction": 0.0005604246216287533, + "calibration_in_the_large": -0.0005140739457064903, + "expected_calibration_error_10bin": 0.0005140739457064903, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 3, + "negatives": 2789, + "auroc": 0.9596032030596391, + "auprc": 0.6695992179863147, + "brier": 0.0010504402542301564, + "calibration": { + "observed_rate": 0.0010744985673352436, + "mean_prediction": 0.000565826335988592, + "calibration_in_the_large": -0.0005086722313466515, + "expected_calibration_error_10bin": 0.0005086722313466515, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + } + ], + "reason": null + }, + "D47": { + "time_averaged_auroc": 0.6457429053030428, + "time_averaged_auprc": 0.005269146850052911, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2796, + "positives": 4, + "negatives": 2792, + "auroc": 0.7215257879656161, + "auprc": 0.0038288518198131573, + "brier": 0.0014310353570118443, + "calibration": { + "observed_rate": 0.001430615164520744, + "mean_prediction": 0.0012580696375595298, + "calibration_in_the_large": -0.0001725455269612141, + "expected_calibration_error_10bin": 0.0001725455269612141, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 5, + "negatives": 2791, + "auroc": 0.6940164815478324, + "auprc": 0.00447593168959943, + "brier": 0.0017980334487064438, + "calibration": { + "observed_rate": 0.00178826895565093, + "mean_prediction": 0.0020966306777626697, + "calibration_in_the_large": 0.0003083617221117398, + "expected_calibration_error_10bin": 0.0003083617221117398, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 6, + "negatives": 2790, + "auroc": 0.5994623655913979, + "auprc": 0.00383263802726138, + "brier": 0.0021685922808060434, + "calibration": { + "observed_rate": 0.002145922746781116, + "mean_prediction": 0.002832822037987544, + "calibration_in_the_large": 0.0006868992912064283, + "expected_calibration_error_10bin": 0.0006868992912064283, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 6, + "negatives": 2790, + "auroc": 0.5981481481481481, + "auprc": 0.0038289343090854174, + "brier": 0.002180221844325743, + "calibration": { + "observed_rate": 0.002145922746781116, + "mean_prediction": 0.0031853273274240505, + "calibration_in_the_large": 0.0010394045806429346, + "expected_calibration_error_10bin": 0.0010394045806429346, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 6, + "negatives": 2790, + "auroc": 0.5942652329749104, + "auprc": 0.0036808065329270658, + "brier": 0.002204935459720973, + "calibration": { + "observed_rate": 0.002145922746781116, + "mean_prediction": 0.0038454722764257117, + "calibration_in_the_large": 0.0016995495296445958, + "expected_calibration_error_10bin": 0.0016995495296445958, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 6, + "negatives": 2790, + "auroc": 0.5955794504181601, + "auprc": 0.003716315913289718, + "brier": 0.002213492914552572, + "calibration": { + "observed_rate": 0.002145922746781116, + "mean_prediction": 0.00401428055664862, + "calibration_in_the_large": 0.001868357809867504, + "expected_calibration_error_10bin": 0.001868357809867504, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 7, + "negatives": 2789, + "auroc": 0.6375557035291707, + "auprc": 0.004732363423732723, + "brier": 0.0025827764248854148, + "calibration": { + "observed_rate": 0.002503576537911302, + "mean_prediction": 0.004461054875188265, + "calibration_in_the_large": 0.0019574783372769628, + "expected_calibration_error_10bin": 0.001957478337276962, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 9, + "negatives": 2787, + "auroc": 0.6797033847625882, + "auprc": 0.006649186974707509, + "brier": 0.003303255167097043, + "calibration": { + "observed_rate": 0.003218884120171674, + "mean_prediction": 0.0047922575759315215, + "calibration_in_the_large": 0.0015733734557598477, + "expected_calibration_error_10bin": 0.0015733734557598475, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 9, + "negatives": 2787, + "auroc": 0.680181796435833, + "auprc": 0.006674493098108279, + "brier": 0.0033119965928128207, + "calibration": { + "observed_rate": 0.003218884120171674, + "mean_prediction": 0.005003167089034963, + "calibration_in_the_large": 0.001784282968863289, + "expected_calibration_error_10bin": 0.0017842829688632885, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 10, + "negatives": 2786, + "auroc": 0.6575017946877243, + "auprc": 0.006651497190603771, + "brier": 0.0036763238541857894, + "calibration": { + "observed_rate": 0.00357653791130186, + "mean_prediction": 0.0051690258220665995, + "calibration_in_the_large": 0.0015924879107647397, + "expected_calibration_error_10bin": 0.0015924879107647404, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 10, + "negatives": 2786, + "auroc": 0.6573582196697775, + "auprc": 0.006642822525921055, + "brier": 0.0036809360600668973, + "calibration": { + "observed_rate": 0.00357653791130186, + "mean_prediction": 0.005276579111289256, + "calibration_in_the_large": 0.0017000411999873958, + "expected_calibration_error_10bin": 0.0017000411999873967, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 11, + "negatives": 2785, + "auroc": 0.6346335890321527, + "auprc": 0.006646396105832743, + "brier": 0.004060132874808369, + "calibration": { + "observed_rate": 0.003934191702432046, + "mean_prediction": 0.005829872404534446, + "calibration_in_the_large": 0.0018956807021024, + "expected_calibration_error_10bin": 0.0018956807021024002, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 12, + "negatives": 2784, + "auroc": 0.6447258141762452, + "auprc": 0.007138671439805591, + "brier": 0.0044150693908399565, + "calibration": { + "observed_rate": 0.004291845493562232, + "mean_prediction": 0.005877777165810305, + "calibration_in_the_large": 0.0015859316722480737, + "expected_calibration_error_10bin": 0.0015859316722480737, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + } + ], + "reason": null + }, + "D50": { + "time_averaged_auroc": 0.7973787486792623, + "time_averaged_auprc": 0.09720647185780155, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2663, + "positives": 15, + "negatives": 2648, + "auroc": 0.7870090634441088, + "auprc": 0.04176393411798029, + "brier": 0.005524448847326335, + "calibration": { + "observed_rate": 0.005632745024408562, + "mean_prediction": 0.003945808796176623, + "calibration_in_the_large": -0.0016869362282319385, + "expected_calibration_error_10bin": 0.0016869362282319385, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + { + "valid": 2663, + "positives": 19, + "negatives": 2644, + "auroc": 0.81732223903177, + "auprc": 0.08503271551231087, + "brier": 0.006863608332510444, + "calibration": { + "observed_rate": 0.007134810364250845, + "mean_prediction": 0.0067258274604841285, + "calibration_in_the_large": -0.0004089829037667164, + "expected_calibration_error_10bin": 0.0004866687227325562, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + { + "valid": 2663, + "positives": 28, + "negatives": 2635, + "auroc": 0.8306993765248035, + "auprc": 0.09873950624761132, + "brier": 0.010011445959010445, + "calibration": { + "observed_rate": 0.010514457378895982, + "mean_prediction": 0.008509544617330923, + "calibration_in_the_large": -0.0020049127615650586, + "expected_calibration_error_10bin": 0.0020049127615650586, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + { + "valid": 2663, + "positives": 36, + "negatives": 2627, + "auroc": 0.7989785560208096, + "auprc": 0.09735943577147979, + "brier": 0.012839010332726249, + "calibration": { + "observed_rate": 0.013518588058580548, + "mean_prediction": 0.010474213828299104, + "calibration_in_the_large": -0.003044374230281444, + "expected_calibration_error_10bin": 0.0030443742302814453, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + { + "valid": 2663, + "positives": 39, + "negatives": 2624, + "auroc": 0.8057575046904315, + "auprc": 0.1018646498967127, + "brier": 0.013830433096580287, + "calibration": { + "observed_rate": 0.01464513706346226, + "mean_prediction": 0.011397788674350774, + "calibration_in_the_large": -0.0032473483891114867, + "expected_calibration_error_10bin": 0.0032473483891114876, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + { + "valid": 2663, + "positives": 42, + "negatives": 2621, + "auroc": 0.7998582874584401, + "auprc": 0.09475295452465307, + "brier": 0.014907514260547164, + "calibration": { + "observed_rate": 0.015771686068343973, + "mean_prediction": 0.012514289277707133, + "calibration_in_the_large": -0.00325739679063684, + "expected_calibration_error_10bin": 0.0032573967906368386, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + { + "valid": 2663, + "positives": 44, + "negatives": 2619, + "auroc": 0.8062671387413656, + "auprc": 0.0995722899509554, + "brier": 0.01555406709182243, + "calibration": { + "observed_rate": 0.016522718738265114, + "mean_prediction": 0.01384489681742039, + "calibration_in_the_large": -0.0026778219208447238, + "expected_calibration_error_10bin": 0.0026778219208447238, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + { + "valid": 2663, + "positives": 46, + "negatives": 2617, + "auroc": 0.7925686564436544, + "auprc": 0.09492117530811735, + "brier": 0.016297046267587934, + "calibration": { + "observed_rate": 0.017273751408186256, + "mean_prediction": 0.014754110174038064, + "calibration_in_the_large": -0.0025196412341481917, + "expected_calibration_error_10bin": 0.0026777626762983764, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + { + "valid": 2663, + "positives": 50, + "negatives": 2613, + "auroc": 0.7835591274397244, + "auprc": 0.10032770063604297, + "brier": 0.017653545016981357, + "calibration": { + "observed_rate": 0.01877581674802854, + "mean_prediction": 0.015663025196568415, + "calibration_in_the_large": -0.0031127915514601243, + "expected_calibration_error_10bin": 0.003281482197553264, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + { + "valid": 2663, + "positives": 52, + "negatives": 2611, + "auroc": 0.7897725598797984, + "auprc": 0.11062850612041206, + "brier": 0.01824706519114005, + "calibration": { + "observed_rate": 0.01952684941794968, + "mean_prediction": 0.016433086772623742, + "calibration_in_the_large": -0.0030937626453259384, + "expected_calibration_error_10bin": 0.003586509453825294, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + { + "valid": 2663, + "positives": 57, + "negatives": 2606, + "auroc": 0.7894198273888866, + "auprc": 0.11438580278737526, + "brier": 0.019952327540032566, + "calibration": { + "observed_rate": 0.021404431092752536, + "mean_prediction": 0.016957075982735784, + "calibration_in_the_large": -0.004447355110016753, + "expected_calibration_error_10bin": 0.005260015311902733, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + { + "valid": 2663, + "positives": 59, + "negatives": 2604, + "auroc": 0.7823817334478899, + "auprc": 0.11220954986464683, + "brier": 0.020675982136810826, + "calibration": { + "observed_rate": 0.022155463762673678, + "mean_prediction": 0.017638277970766333, + "calibration_in_the_large": -0.004517185791907345, + "expected_calibration_error_10bin": 0.004517185791907342, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + { + "valid": 2663, + "positives": 59, + "negatives": 2604, + "auroc": 0.7823296623187274, + "auprc": 0.11212591341312216, + "brier": 0.020675959723059505, + "calibration": { + "observed_rate": 0.022155463762673678, + "mean_prediction": 0.017772140193531162, + "calibration_in_the_large": -0.004383323569142516, + "expected_calibration_error_10bin": 0.004383323569142514, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + } + ], + "reason": null + }, + "D53": { + "time_averaged_auroc": 0.8193060209227002, + "time_averaged_auprc": 0.024880102170439906, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2805, + "positives": 5, + "negatives": 2800, + "auroc": 0.7966428571428571, + "auprc": 0.016301319484265397, + "brier": 0.0017734044510107694, + "calibration": { + "observed_rate": 0.0017825311942959, + "mean_prediction": 0.0012750843343574468, + "calibration_in_the_large": -0.0005074468599384533, + "expected_calibration_error_10bin": 0.0005074468599384533, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 7, + "negatives": 2798, + "auroc": 0.8347799448585724, + "auprc": 0.024014583763546975, + "brier": 0.0024871716837666304, + "calibration": { + "observed_rate": 0.0024955436720142605, + "mean_prediction": 0.0028371372387229646, + "calibration_in_the_large": 0.0003415935667087041, + "expected_calibration_error_10bin": 0.00034159356670870444, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 9, + "negatives": 2796, + "auroc": 0.8280082657765061, + "auprc": 0.027725152323451716, + "brier": 0.003198331001208034, + "calibration": { + "observed_rate": 0.0032085561497326204, + "mean_prediction": 0.0037775179067216858, + "calibration_in_the_large": 0.0005689617569890654, + "expected_calibration_error_10bin": 0.0005689617569890656, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 11, + "negatives": 2794, + "auroc": 0.8307737359276371, + "auprc": 0.02565251923915747, + "brier": 0.003915965486304453, + "calibration": { + "observed_rate": 0.00392156862745098, + "mean_prediction": 0.0040776602752223634, + "calibration_in_the_large": 0.0001560916477713831, + "expected_calibration_error_10bin": 0.0006508872921298908, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 12, + "negatives": 2793, + "auroc": 0.8306182121971596, + "auprc": 0.02587077562317473, + "brier": 0.004287418340397021, + "calibration": { + "observed_rate": 0.0042780748663101605, + "mean_prediction": 0.004582510386121701, + "calibration_in_the_large": 0.00030443551981154063, + "expected_calibration_error_10bin": 0.0003044355198115407, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 12, + "negatives": 2793, + "auroc": 0.8306480486931614, + "auprc": 0.025538576371290186, + "brier": 0.0043222209034165585, + "calibration": { + "observed_rate": 0.0042780748663101605, + "mean_prediction": 0.0051810200217122055, + "calibration_in_the_large": 0.000902945155402045, + "expected_calibration_error_10bin": 0.0009029451554020461, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 14, + "negatives": 2791, + "auroc": 0.8200337820545631, + "auprc": 0.025760537692481437, + "brier": 0.005026216893262058, + "calibration": { + "observed_rate": 0.004991087344028521, + "mean_prediction": 0.005335085885171258, + "calibration_in_the_large": 0.00034399854114273726, + "expected_calibration_error_10bin": 0.000874404954851531, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 14, + "negatives": 2791, + "auroc": 0.8205968162972821, + "auprc": 0.02630752220652523, + "brier": 0.005055602426654589, + "calibration": { + "observed_rate": 0.004991087344028521, + "mean_prediction": 0.005810619733955866, + "calibration_in_the_large": 0.0008195323899273452, + "expected_calibration_error_10bin": 0.0008957698383627842, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 16, + "negatives": 2789, + "auroc": 0.8177438149874507, + "auprc": 0.025980368881329815, + "brier": 0.005791550154143512, + "calibration": { + "observed_rate": 0.00570409982174688, + "mean_prediction": 0.006301415642771325, + "calibration_in_the_large": 0.0005973158210244448, + "expected_calibration_error_10bin": 0.0013137139723374853, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 16, + "negatives": 2789, + "auroc": 0.8178558623162424, + "auprc": 0.025721368434203067, + "brier": 0.005810469514630808, + "calibration": { + "observed_rate": 0.00570409982174688, + "mean_prediction": 0.0065675625295025805, + "calibration_in_the_large": 0.0008634627077557001, + "expected_calibration_error_10bin": 0.001372746865624537, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 17, + "negatives": 2788, + "auroc": 0.8141193349649759, + "auprc": 0.025486987492421672, + "brier": 0.006188324028026998, + "calibration": { + "observed_rate": 0.006060606060606061, + "mean_prediction": 0.006950223992432181, + "calibration_in_the_large": 0.0008896179318261203, + "expected_calibration_error_10bin": 0.00163027636252166, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 18, + "negatives": 2787, + "auroc": 0.8045887652992066, + "auprc": 0.024538348520957837, + "brier": 0.0065723264562435775, + "calibration": { + "observed_rate": 0.006417112299465241, + "mean_prediction": 0.0072800606854535755, + "calibration_in_the_large": 0.0008629483859883347, + "expected_calibration_error_10bin": 0.0019623356341601614, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 18, + "negatives": 2787, + "auroc": 0.8045688314794881, + "auprc": 0.02454326818291331, + "brier": 0.006573146111847409, + "calibration": { + "observed_rate": 0.006417112299465241, + "mean_prediction": 0.007292897156188629, + "calibration_in_the_large": 0.0008757848567233885, + "expected_calibration_error_10bin": 0.0019543443941872287, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + } + ], + "reason": null + }, + "D59": { + "time_averaged_auroc": 0.9803533388969169, + "time_averaged_auprc": 0.023945824900013356, + "valid_timepoint_cells": 8, + "timepoints": [ + { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 2.5143563119556716e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00022820042579560796, + "calibration_in_the_large": 0.00022820042579560796, + "expected_calibration_error_10bin": 0.00022820042579560796, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 7.210002290779953e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0003676219773716378, + "calibration_in_the_large": 0.0003676219773716378, + "expected_calibration_error_10bin": 0.0003676219773716378, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 2.0329733639102867e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0005229880152461508, + "calibration_in_the_large": 0.0005229880152461508, + "expected_calibration_error_10bin": 0.0005229880152461508, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 2.476769123016642e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0005668691258285803, + "calibration_in_the_large": 0.0005668691258285803, + "expected_calibration_error_10bin": 0.0005668691258285803, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 3.144055767215128e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0006189368050201103, + "calibration_in_the_large": 0.0006189368050201103, + "expected_calibration_error_10bin": 0.0006189368050201103, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 1, + "negatives": 2835, + "auroc": 0.9767195767195768, + "auprc": 0.014925373134328358, + "brier": 0.00035272854822490163, + "calibration": { + "observed_rate": 0.0003526093088857546, + "mean_prediction": 0.0006596067518386971, + "calibration_in_the_large": 0.0003069974429529425, + "expected_calibration_error_10bin": 0.0003069974429529425, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 1, + "negatives": 2835, + "auroc": 0.9760141093474427, + "auprc": 0.014492753623188406, + "brier": 0.00035314486405050926, + "calibration": { + "observed_rate": 0.0003526093088857546, + "mean_prediction": 0.0007322453062681545, + "calibration_in_the_large": 0.0003796359973823999, + "expected_calibration_error_10bin": 0.0003796359973823999, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 1, + "negatives": 2835, + "auroc": 0.9763668430335097, + "auprc": 0.014705882352941176, + "brier": 0.00035319185354031914, + "calibration": { + "observed_rate": 0.0003526093088857546, + "mean_prediction": 0.0007462576745990982, + "calibration_in_the_large": 0.00039364836571334364, + "expected_calibration_error_10bin": 0.00039364836571334364, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9828863796753705, + "auprc": 0.029857397504456328, + "brier": 0.0006999202423084635, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0007895136208959442, + "calibration_in_the_large": 8.429500312443503e-05, + "expected_calibration_error_10bin": 8.429500312443503e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9827099505998589, + "auprc": 0.029437229437229435, + "brier": 0.0006999277982162726, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0008039314902278072, + "calibration_in_the_large": 9.8712872456298e-05, + "expected_calibration_error_10bin": 9.8712872456298e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9828863796753705, + "auprc": 0.02967032967032967, + "brier": 0.0006999359322433663, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0008614800720150525, + "calibration_in_the_large": 0.00015626145424354337, + "expected_calibration_error_10bin": 0.00015626145424354337, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9827099505998589, + "auprc": 0.029437229437229435, + "brier": 0.0007000666594942501, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0008971488933127362, + "calibration_in_the_large": 0.00019193027554122708, + "expected_calibration_error_10bin": 0.00019193027554122708, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9825335215243473, + "auprc": 0.02904040404040404, + "brier": 0.000700070951584648, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0009001136916072894, + "calibration_in_the_large": 0.0001948950738357802, + "expected_calibration_error_10bin": 0.0001948950738357802, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + } + ], + "reason": null + }, + "D61": { + "time_averaged_auroc": 0.9112353165599291, + "time_averaged_auprc": 0.18294398559635716, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2773, + "positives": 4, + "negatives": 2769, + "auroc": 0.9665944384254244, + "auprc": 0.02536786786786787, + "brier": 0.0014428662002351907, + "calibration": { + "observed_rate": 0.00144248106743599, + "mean_prediction": 0.001512894662284949, + "calibration_in_the_large": 7.041359484895901e-05, + "expected_calibration_error_10bin": 7.041359484895912e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 9, + "negatives": 2764, + "auroc": 0.9701720533847885, + "auprc": 0.06969347321496379, + "brier": 0.003203527554108105, + "calibration": { + "observed_rate": 0.0032455824017309774, + "mean_prediction": 0.003915203729148939, + "calibration_in_the_large": 0.0006696213274179617, + "expected_calibration_error_10bin": 0.0006696213274179618, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 15, + "negatives": 2758, + "auroc": 0.9404399323181049, + "auprc": 0.14782762754196435, + "brier": 0.0049683297513795875, + "calibration": { + "observed_rate": 0.005409304002884962, + "mean_prediction": 0.005824868733144596, + "calibration_in_the_large": 0.00041556473025963336, + "expected_calibration_error_10bin": 0.0008559120882905508, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 17, + "negatives": 2756, + "auroc": 0.8928540937419961, + "auprc": 0.12981210099733986, + "brier": 0.005726806178122827, + "calibration": { + "observed_rate": 0.006130544536602957, + "mean_prediction": 0.006902876924752144, + "calibration_in_the_large": 0.000772332388149187, + "expected_calibration_error_10bin": 0.0012915170451143305, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 21, + "negatives": 2752, + "auroc": 0.8942933277962348, + "auprc": 0.14089104376665976, + "brier": 0.007041637024380965, + "calibration": { + "observed_rate": 0.007573025604038947, + "mean_prediction": 0.007895347568472402, + "calibration_in_the_large": 0.0003223219644334545, + "expected_calibration_error_10bin": 0.0025868887941255117, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 24, + "negatives": 2749, + "auroc": 0.8979022674912089, + "auprc": 0.14102718757106544, + "brier": 0.00807614897988707, + "calibration": { + "observed_rate": 0.00865488640461594, + "mean_prediction": 0.00852368378368821, + "calibration_in_the_large": -0.00013120262092772977, + "expected_calibration_error_10bin": 0.002990374408510219, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 30, + "negatives": 2743, + "auroc": 0.8940089925871917, + "auprc": 0.19193002671051837, + "brier": 0.00961095835702231, + "calibration": { + "observed_rate": 0.010818608005769925, + "mean_prediction": 0.009090105273165639, + "calibration_in_the_large": -0.001728502732604286, + "expected_calibration_error_10bin": 0.00373060130970336, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 32, + "negatives": 2741, + "auroc": 0.8997400583728566, + "auprc": 0.21681384946879242, + "brier": 0.010031479641218987, + "calibration": { + "observed_rate": 0.01153984853948792, + "mean_prediction": 0.009703000189376577, + "calibration_in_the_large": -0.001836848350111343, + "expected_calibration_error_10bin": 0.003115621423877964, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 33, + "negatives": 2740, + "auroc": 0.903605397036054, + "auprc": 0.2592953964965838, + "brier": 0.010049025775629375, + "calibration": { + "observed_rate": 0.011900468806346917, + "mean_prediction": 0.010209851687153111, + "calibration_in_the_large": -0.001690617119193806, + "expected_calibration_error_10bin": 0.0027767549990472726, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 35, + "negatives": 2738, + "auroc": 0.9089533548993008, + "auprc": 0.27342836539662685, + "brier": 0.01056786670783074, + "calibration": { + "observed_rate": 0.012621709340064912, + "mean_prediction": 0.010794716479433785, + "calibration_in_the_large": -0.0018269928606311266, + "expected_calibration_error_10bin": 0.0029310741459619904, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 36, + "negatives": 2737, + "auroc": 0.8934051881622214, + "auprc": 0.2657018723993211, + "brier": 0.010920263136781357, + "calibration": { + "observed_rate": 0.01298232960692391, + "mean_prediction": 0.0112785772854494, + "calibration_in_the_large": -0.0017037523214745096, + "expected_calibration_error_10bin": 0.002713555985801994, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 37, + "negatives": 2736, + "auroc": 0.8920993361782835, + "auprc": 0.25834005783254066, + "brier": 0.011271853677462758, + "calibration": { + "observed_rate": 0.013342949873782907, + "mean_prediction": 0.011695702326964043, + "calibration_in_the_large": -0.0016472475468188637, + "expected_calibration_error_10bin": 0.0030130527198852534, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 37, + "negatives": 2736, + "auroc": 0.8919906748854117, + "auprc": 0.2581429434883987, + "brier": 0.011271607153864814, + "calibration": { + "observed_rate": 0.013342949873782907, + "mean_prediction": 0.011810959145599128, + "calibration_in_the_large": -0.0015319907281837793, + "expected_calibration_error_10bin": 0.0029523300564901793, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + } + ], + "reason": null + }, + "D62": { + "time_averaged_auroc": 0.7882789324307792, + "time_averaged_auprc": 0.05814089321328873, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2499, + "positives": 10, + "negatives": 2489, + "auroc": 0.8008437123342708, + "auprc": 0.01887950441253526, + "brier": 0.003972297655459969, + "calibration": { + "observed_rate": 0.004001600640256103, + "mean_prediction": 0.006544245297289813, + "calibration_in_the_large": 0.0025426446570337106, + "expected_calibration_error_10bin": 0.0025426446570337106, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + { + "valid": 2499, + "positives": 21, + "negatives": 2478, + "auroc": 0.7783927130174103, + "auprc": 0.021987589421410894, + "brier": 0.008306915721903306, + "calibration": { + "observed_rate": 0.008403361344537815, + "mean_prediction": 0.01084326511652277, + "calibration_in_the_large": 0.0024399037719849553, + "expected_calibration_error_10bin": 0.0024399037719849553, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + { + "valid": 2499, + "positives": 30, + "negatives": 2469, + "auroc": 0.7908329958147698, + "auprc": 0.03258371834487977, + "brier": 0.011777888801700078, + "calibration": { + "observed_rate": 0.012004801920768308, + "mean_prediction": 0.01398957171044139, + "calibration_in_the_large": 0.001984769789673083, + "expected_calibration_error_10bin": 0.001984769789673084, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + { + "valid": 2499, + "positives": 36, + "negatives": 2463, + "auroc": 0.7758492353498444, + "auprc": 0.03590656915887488, + "brier": 0.014137779359188375, + "calibration": { + "observed_rate": 0.014405762304921969, + "mean_prediction": 0.016489135343259072, + "calibration_in_the_large": 0.002083373038337104, + "expected_calibration_error_10bin": 0.002083373038337103, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + { + "valid": 2499, + "positives": 45, + "negatives": 2454, + "auroc": 0.7987775061124694, + "auprc": 0.05561464430801152, + "brier": 0.017368577867522255, + "calibration": { + "observed_rate": 0.01800720288115246, + "mean_prediction": 0.0184002954326216, + "calibration_in_the_large": 0.00039309255146913885, + "expected_calibration_error_10bin": 0.001532819278926932, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + { + "valid": 2499, + "positives": 49, + "negatives": 2450, + "auroc": 0.7996917950853811, + "auprc": 0.05935058108085419, + "brier": 0.018863334791027305, + "calibration": { + "observed_rate": 0.0196078431372549, + "mean_prediction": 0.019933864094491, + "calibration_in_the_large": 0.0003260209572360992, + "expected_calibration_error_10bin": 0.0018318281447956134, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + { + "valid": 2499, + "positives": 55, + "negatives": 2444, + "auroc": 0.7892426722213957, + "auprc": 0.06265389068846255, + "brier": 0.02113755331218561, + "calibration": { + "observed_rate": 0.022008803521408563, + "mean_prediction": 0.020951024989052273, + "calibration_in_the_large": -0.0010577785323562898, + "expected_calibration_error_10bin": 0.004129942027194536, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + { + "valid": 2499, + "positives": 60, + "negatives": 2439, + "auroc": 0.796972803061364, + "auprc": 0.07179254963386278, + "brier": 0.022908080816770617, + "calibration": { + "observed_rate": 0.024009603841536616, + "mean_prediction": 0.022244573790062384, + "calibration_in_the_large": -0.001765030051474232, + "expected_calibration_error_10bin": 0.005477185223802025, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + { + "valid": 2499, + "positives": 64, + "negatives": 2435, + "auroc": 0.794276180698152, + "auprc": 0.07661247285438731, + "brier": 0.024370193941723437, + "calibration": { + "observed_rate": 0.025610244097639057, + "mean_prediction": 0.023553841725541872, + "calibration_in_the_large": -0.0020564023720971852, + "expected_calibration_error_10bin": 0.0045147047738875205, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + { + "valid": 2499, + "positives": 69, + "negatives": 2430, + "auroc": 0.7768652710681696, + "auprc": 0.07571499190039206, + "brier": 0.026303619385163842, + "calibration": { + "observed_rate": 0.027611044417767107, + "mean_prediction": 0.024580467785593075, + "calibration_in_the_large": -0.003030576632174032, + "expected_calibration_error_10bin": 0.004971402235190887, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + { + "valid": 2499, + "positives": 71, + "negatives": 2428, + "auroc": 0.7823514397753903, + "auprc": 0.0814220289198379, + "brier": 0.026962663460537776, + "calibration": { + "observed_rate": 0.028411364545818326, + "mean_prediction": 0.025525717317320857, + "calibration_in_the_large": -0.002885647228497469, + "expected_calibration_error_10bin": 0.004850095506998246, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + { + "valid": 2499, + "positives": 73, + "negatives": 2426, + "auroc": 0.7817423121661453, + "auprc": 0.08164296763311665, + "brier": 0.02772323667268977, + "calibration": { + "observed_rate": 0.02921168467386955, + "mean_prediction": 0.02649538461332295, + "calibration_in_the_large": -0.0027163000605466003, + "expected_calibration_error_10bin": 0.004636458635489335, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + { + "valid": 2499, + "positives": 73, + "negatives": 2426, + "auroc": 0.7817874848953686, + "auprc": 0.08167010341612777, + "brier": 0.02772538124317179, + "calibration": { + "observed_rate": 0.02921168467386955, + "mean_prediction": 0.02665757790243081, + "calibration_in_the_large": -0.0025541067714387397, + "expected_calibration_error_10bin": 0.004487403543383141, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + } + ], + "reason": null + }, + "D63": { + "time_averaged_auroc": 0.877947039195306, + "time_averaged_auprc": 0.1256829203774776, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2686, + "positives": 20, + "negatives": 2666, + "auroc": 0.9210240060015004, + "auprc": 0.06691482178737743, + "brier": 0.007169995681982845, + "calibration": { + "observed_rate": 0.007446016381236039, + "mean_prediction": 0.005643855671737045, + "calibration_in_the_large": -0.001802160709498994, + "expected_calibration_error_10bin": 0.0030322709996950725, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + { + "valid": 2686, + "positives": 31, + "negatives": 2655, + "auroc": 0.9180851710102667, + "auprc": 0.09078382473138455, + "brier": 0.01095332041957463, + "calibration": { + "observed_rate": 0.01154132539091586, + "mean_prediction": 0.010590559852044535, + "calibration_in_the_large": -0.0009507655388713253, + "expected_calibration_error_10bin": 0.001747169377380127, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + { + "valid": 2686, + "positives": 43, + "negatives": 2643, + "auroc": 0.8986792668655246, + "auprc": 0.11713107233493347, + "brier": 0.01495676048428244, + "calibration": { + "observed_rate": 0.01600893521965748, + "mean_prediction": 0.013468455732372611, + "calibration_in_the_large": -0.0025404794872848704, + "expected_calibration_error_10bin": 0.004837578742593194, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + { + "valid": 2686, + "positives": 52, + "negatives": 2634, + "auroc": 0.8916170200338766, + "auprc": 0.1326258187951842, + "brier": 0.017912844011366478, + "calibration": { + "observed_rate": 0.0193596425912137, + "mean_prediction": 0.016071345991246242, + "calibration_in_the_large": -0.0032882965999674572, + "expected_calibration_error_10bin": 0.007052837966133454, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + { + "valid": 2686, + "positives": 55, + "negatives": 2631, + "auroc": 0.8869216682215542, + "auprc": 0.1310738408708993, + "brier": 0.01898298378464056, + "calibration": { + "observed_rate": 0.020476545048399106, + "mean_prediction": 0.017983054373348226, + "calibration_in_the_large": -0.0024934906750508808, + "expected_calibration_error_10bin": 0.0060489990512838905, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + { + "valid": 2686, + "positives": 62, + "negatives": 2624, + "auroc": 0.8785958398898505, + "auprc": 0.1367386937140342, + "brier": 0.021370685475674778, + "calibration": { + "observed_rate": 0.02308265078183172, + "mean_prediction": 0.019857998818401338, + "calibration_in_the_large": -0.0032246519634303826, + "expected_calibration_error_10bin": 0.007867729256337823, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + { + "valid": 2686, + "positives": 66, + "negatives": 2620, + "auroc": 0.8607506361323155, + "auprc": 0.13358932581019206, + "brier": 0.022846329844923664, + "calibration": { + "observed_rate": 0.024571854058078928, + "mean_prediction": 0.02140502333014117, + "calibration_in_the_large": -0.0031668307279377576, + "expected_calibration_error_10bin": 0.008616152356531036, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + { + "valid": 2686, + "positives": 68, + "negatives": 2618, + "auroc": 0.8594290657439446, + "auprc": 0.1336740856417583, + "brier": 0.023579200903332646, + "calibration": { + "observed_rate": 0.02531645569620253, + "mean_prediction": 0.022333721347493504, + "calibration_in_the_large": -0.0029827343487090277, + "expected_calibration_error_10bin": 0.00930453148084604, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + { + "valid": 2686, + "positives": 71, + "negatives": 2615, + "auroc": 0.8616648264347077, + "auprc": 0.13550112982161477, + "brier": 0.024617585670419075, + "calibration": { + "observed_rate": 0.02643335815338794, + "mean_prediction": 0.023394826129928794, + "calibration_in_the_large": -0.0030385320234591444, + "expected_calibration_error_10bin": 0.00948523963163879, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + { + "valid": 2686, + "positives": 74, + "negatives": 2612, + "auroc": 0.8586099499192914, + "auprc": 0.1382718158697274, + "brier": 0.025654170018568494, + "calibration": { + "observed_rate": 0.027550260610573342, + "mean_prediction": 0.024490287716345992, + "calibration_in_the_large": -0.0030599728942273495, + "expected_calibration_error_10bin": 0.009914561044850388, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + { + "valid": 2686, + "positives": 76, + "negatives": 2610, + "auroc": 0.8594978826376286, + "auprc": 0.13947793358440727, + "brier": 0.026386816503963132, + "calibration": { + "observed_rate": 0.028294862248696945, + "mean_prediction": 0.02524494096504667, + "calibration_in_the_large": -0.003049921283650274, + "expected_calibration_error_10bin": 0.010541017150366991, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + { + "valid": 2686, + "positives": 76, + "negatives": 2610, + "auroc": 0.8592458156886469, + "auprc": 0.13934470848643454, + "brier": 0.026445081522602335, + "calibration": { + "observed_rate": 0.028294862248696945, + "mean_prediction": 0.02635434233446204, + "calibration_in_the_large": -0.0019405199142349047, + "expected_calibration_error_10bin": 0.009349703870412748, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + { + "valid": 2686, + "positives": 76, + "negatives": 2610, + "auroc": 0.8591903609598709, + "auprc": 0.13875089345926161, + "brier": 0.026447078824828645, + "calibration": { + "observed_rate": 0.028294862248696945, + "mean_prediction": 0.026452136908627338, + "calibration_in_the_large": -0.0018427253400696078, + "expected_calibration_error_10bin": 0.009304330738074799, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + } + ], + "reason": null + }, + "D64": { + "time_averaged_auroc": 0.8178742074313694, + "time_averaged_auprc": 0.16181122904878806, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2434, + "positives": 37, + "negatives": 2397, + "auroc": 0.8465875136713685, + "auprc": 0.0840596593616801, + "brier": 0.014506551242183441, + "calibration": { + "observed_rate": 0.015201314708299097, + "mean_prediction": 0.013306173589979754, + "calibration_in_the_large": -0.0018951411183193434, + "expected_calibration_error_10bin": 0.0018951411183193434, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + { + "valid": 2434, + "positives": 51, + "negatives": 2383, + "auroc": 0.8476051771946714, + "auprc": 0.10531875171185595, + "brier": 0.01957611979108239, + "calibration": { + "observed_rate": 0.0209531635168447, + "mean_prediction": 0.022967793545421694, + "calibration_in_the_large": 0.002014630028576995, + "expected_calibration_error_10bin": 0.0031496735162276947, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + { + "valid": 2434, + "positives": 66, + "negatives": 2368, + "auroc": 0.8312730343980343, + "auprc": 0.12751706842416097, + "brier": 0.024938037465014332, + "calibration": { + "observed_rate": 0.027115858668857847, + "mean_prediction": 0.027886486189740642, + "calibration_in_the_large": 0.0007706275208827947, + "expected_calibration_error_10bin": 0.0021891341878150184, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + { + "valid": 2434, + "positives": 77, + "negatives": 2357, + "auroc": 0.8364639179234004, + "auprc": 0.15164954842145, + "brier": 0.02856860121744379, + "calibration": { + "observed_rate": 0.031635168447000823, + "mean_prediction": 0.032421906931115727, + "calibration_in_the_large": 0.000786738484114903, + "expected_calibration_error_10bin": 0.0038020569088734117, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + { + "valid": 2434, + "positives": 85, + "negatives": 2349, + "auroc": 0.81139408509253, + "auprc": 0.1503863822435443, + "brier": 0.03157738422804296, + "calibration": { + "observed_rate": 0.03492193919474117, + "mean_prediction": 0.03644012509835249, + "calibration_in_the_large": 0.001518185903611323, + "expected_calibration_error_10bin": 0.0019277056641631802, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + { + "valid": 2434, + "positives": 89, + "negatives": 2345, + "auroc": 0.8133106537936322, + "auprc": 0.1513736405781658, + "brier": 0.03300169856269511, + "calibration": { + "observed_rate": 0.03656532456861134, + "mean_prediction": 0.03905833399678208, + "calibration_in_the_large": 0.0024930094281707393, + "expected_calibration_error_10bin": 0.0030091552741270036, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + { + "valid": 2434, + "positives": 97, + "negatives": 2337, + "auroc": 0.8023591793161556, + "auprc": 0.17506238320595208, + "brier": 0.035725979525062, + "calibration": { + "observed_rate": 0.039852095316351685, + "mean_prediction": 0.04194230788682749, + "calibration_in_the_large": 0.0020902125704758065, + "expected_calibration_error_10bin": 0.0025659426838242224, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + { + "valid": 2434, + "positives": 103, + "negatives": 2331, + "auroc": 0.8044507753245618, + "auprc": 0.18420436149644753, + "brier": 0.037618141786084115, + "calibration": { + "observed_rate": 0.042317173377156944, + "mean_prediction": 0.044114195109511846, + "calibration_in_the_large": 0.0017970217323549018, + "expected_calibration_error_10bin": 0.004152815662620586, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + { + "valid": 2434, + "positives": 107, + "negatives": 2327, + "auroc": 0.8038788862158569, + "auprc": 0.18715511106969346, + "brier": 0.03898023204564764, + "calibration": { + "observed_rate": 0.04396055875102712, + "mean_prediction": 0.04609457375661561, + "calibration_in_the_large": 0.002134015005588491, + "expected_calibration_error_10bin": 0.0061293578851698656, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + { + "valid": 2434, + "positives": 116, + "negatives": 2318, + "auroc": 0.8101105292910059, + "auprc": 0.19684046861443108, + "brier": 0.041847022678201916, + "calibration": { + "observed_rate": 0.047658175842235, + "mean_prediction": 0.0477665685825685, + "calibration_in_the_large": 0.00010839274033350166, + "expected_calibration_error_10bin": 0.007888773740414644, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + { + "valid": 2434, + "positives": 119, + "negatives": 2315, + "auroc": 0.8077172985825, + "auprc": 0.1962026832191183, + "brier": 0.042916841243539824, + "calibration": { + "observed_rate": 0.04889071487263763, + "mean_prediction": 0.04948896347155187, + "calibration_in_the_large": 0.0005982485989142403, + "expected_calibration_error_10bin": 0.008048490258702821, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + { + "valid": 2434, + "positives": 121, + "negatives": 2313, + "auroc": 0.8086489229043173, + "auprc": 0.1966529054729099, + "brier": 0.043600683754049484, + "calibration": { + "observed_rate": 0.04971240755957272, + "mean_prediction": 0.051377558496060585, + "calibration_in_the_large": 0.0016651509364878636, + "expected_calibration_error_10bin": 0.007415950560028572, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + { + "valid": 2434, + "positives": 122, + "negatives": 2312, + "auroc": 0.8085647228997674, + "auprc": 0.19712301381483513, + "brier": 0.04395264275157496, + "calibration": { + "observed_rate": 0.05012325390304026, + "mean_prediction": 0.05169912035151897, + "calibration_in_the_large": 0.0015758664484787077, + "expected_calibration_error_10bin": 0.006847425902605931, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + } + ], + "reason": null + }, + "D65": { + "time_averaged_auroc": 0.944159361663017, + "time_averaged_auprc": 0.015886426339184148, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2833, + "positives": 1, + "negatives": 2832, + "auroc": 0.9477401129943502, + "auprc": 0.006711409395973154, + "brier": 0.00035313974160504173, + "calibration": { + "observed_rate": 0.00035298270384751147, + "mean_prediction": 0.0002695634925698071, + "calibration_in_the_large": -8.341921127770437e-05, + "expected_calibration_error_10bin": 8.341921127770437e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + { + "valid": 2833, + "positives": 1, + "negatives": 2832, + "auroc": 0.9456214689265536, + "auprc": 0.0064516129032258064, + "brier": 0.00035407439404620226, + "calibration": { + "observed_rate": 0.00035298270384751147, + "mean_prediction": 0.00042813982265550764, + "calibration_in_the_large": 7.515711880799617e-05, + "expected_calibration_error_10bin": 7.515711880799617e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + { + "valid": 2833, + "positives": 2, + "negatives": 2831, + "auroc": 0.9533733663016601, + "auprc": 0.011302681992337166, + "brier": 0.0007053666417099417, + "calibration": { + "observed_rate": 0.0007059654076950229, + "mean_prediction": 0.0005288345609153321, + "calibration_in_the_large": -0.0001771308467796908, + "expected_calibration_error_10bin": 0.0001771308467796908, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + { + "valid": 2833, + "positives": 3, + "negatives": 2830, + "auroc": 0.9555948174322733, + "auprc": 0.015202351582033119, + "brier": 0.0010570415290933042, + "calibration": { + "observed_rate": 0.0010589481115425344, + "mean_prediction": 0.0006373076399403475, + "calibration_in_the_large": -0.0004216404716021869, + "expected_calibration_error_10bin": 0.0004216404716021869, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + { + "valid": 2833, + "positives": 3, + "negatives": 2830, + "auroc": 0.9619552414605418, + "auprc": 0.017680372962838115, + "brier": 0.001058123748963202, + "calibration": { + "observed_rate": 0.0010589481115425344, + "mean_prediction": 0.0008378243724098543, + "calibration_in_the_large": -0.00022112373913268013, + "expected_calibration_error_10bin": 0.00022112373913268013, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + { + "valid": 2833, + "positives": 3, + "negatives": 2830, + "auroc": 0.9617196702002355, + "auprc": 0.01766148991127106, + "brier": 0.0010586512179167691, + "calibration": { + "observed_rate": 0.0010589481115425344, + "mean_prediction": 0.0008759226374661254, + "calibration_in_the_large": -0.00018302547407640906, + "expected_calibration_error_10bin": 0.00018302547407640906, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + { + "valid": 2833, + "positives": 3, + "negatives": 2830, + "auroc": 0.9613663133097762, + "auprc": 0.01747214374411414, + "brier": 0.0010593409937053307, + "calibration": { + "observed_rate": 0.0010589481115425344, + "mean_prediction": 0.0009284818749921625, + "calibration_in_the_large": -0.00013046623655037194, + "expected_calibration_error_10bin": 0.00013046623655037194, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + { + "valid": 2833, + "positives": 3, + "negatives": 2830, + "auroc": 0.9607773851590106, + "auprc": 0.01725537534066234, + "brier": 0.0010596643758331139, + "calibration": { + "observed_rate": 0.0010589481115425344, + "mean_prediction": 0.0009650031250349421, + "calibration_in_the_large": -9.39449865075923e-05, + "expected_calibration_error_10bin": 9.39449865075923e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + { + "valid": 2833, + "positives": 4, + "negatives": 2829, + "auroc": 0.9610286320254506, + "auprc": 0.021319861549424817, + "brier": 0.0014094756984508862, + "calibration": { + "observed_rate": 0.0014119308153900459, + "mean_prediction": 0.0009975111955010578, + "calibration_in_the_large": -0.0004144196198889881, + "expected_calibration_error_10bin": 0.0004144196198889881, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + { + "valid": 2833, + "positives": 4, + "negatives": 2829, + "auroc": 0.9609402615765288, + "auprc": 0.021265036988021308, + "brier": 0.0014095510508728125, + "calibration": { + "observed_rate": 0.0014119308153900459, + "mean_prediction": 0.0010085415087500293, + "calibration_in_the_large": -0.00040338930664001664, + "expected_calibration_error_10bin": 0.00040338930664001664, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + { + "valid": 2833, + "positives": 4, + "negatives": 2829, + "auroc": 0.9604100388829975, + "auprc": 0.020983883013958204, + "brier": 0.0014102723433290644, + "calibration": { + "observed_rate": 0.0014119308153900459, + "mean_prediction": 0.0010493932148847708, + "calibration_in_the_large": -0.0003625376005052751, + "expected_calibration_error_10bin": 0.0003625376005052751, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + { + "valid": 2833, + "positives": 6, + "negatives": 2827, + "auroc": 0.871536375427426, + "auprc": 0.01660392712596543, + "brier": 0.0021162046322423032, + "calibration": { + "observed_rate": 0.002117896223085069, + "mean_prediction": 0.0011131163993914762, + "calibration_in_the_large": -0.0010047798236935926, + "expected_calibration_error_10bin": 0.0010047798236935926, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + { + "valid": 2833, + "positives": 6, + "negatives": 2827, + "auroc": 0.8720080179224148, + "auprc": 0.016613395899569287, + "brier": 0.002116486976906138, + "calibration": { + "observed_rate": 0.002117896223085069, + "mean_prediction": 0.0011255209813293226, + "calibration_in_the_large": -0.0009923752417557463, + "expected_calibration_error_10bin": 0.0009923752417557463, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + } + ], + "reason": null + }, + "D68": { + "time_averaged_auroc": 0.8228113738317397, + "time_averaged_auprc": 0.10419090711045396, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2682, + "positives": 10, + "negatives": 2672, + "auroc": 0.8525823353293414, + "auprc": 0.03561724006498467, + "brier": 0.0036721880820170705, + "calibration": { + "observed_rate": 0.0037285607755406414, + "mean_prediction": 0.0028985177241928587, + "calibration_in_the_large": -0.0008300430513477827, + "expected_calibration_error_10bin": 0.0008300430513477827, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + { + "valid": 2682, + "positives": 21, + "negatives": 2661, + "auroc": 0.859558705105492, + "auprc": 0.062245849596423396, + "brier": 0.007601331549262677, + "calibration": { + "observed_rate": 0.007829977628635347, + "mean_prediction": 0.00522837045628848, + "calibration_in_the_large": -0.0026016071723468674, + "expected_calibration_error_10bin": 0.0032319369194526507, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + { + "valid": 2682, + "positives": 29, + "negatives": 2653, + "auroc": 0.8277291810182357, + "auprc": 0.06158357457216069, + "brier": 0.010483497276894235, + "calibration": { + "observed_rate": 0.01081282624906786, + "mean_prediction": 0.006726104818559663, + "calibration_in_the_large": -0.0040867214305081966, + "expected_calibration_error_10bin": 0.0042492221491597535, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + { + "valid": 2682, + "positives": 32, + "negatives": 2650, + "auroc": 0.8205542452830189, + "auprc": 0.06297396418321248, + "brier": 0.011575473347757317, + "calibration": { + "observed_rate": 0.011931394481730051, + "mean_prediction": 0.008041642674254142, + "calibration_in_the_large": -0.0038897518074759094, + "expected_calibration_error_10bin": 0.0051029432415613234, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + { + "valid": 2682, + "positives": 39, + "negatives": 2643, + "auroc": 0.8004307459472045, + "auprc": 0.07294312993002008, + "brier": 0.0140208672966509, + "calibration": { + "observed_rate": 0.0145413870246085, + "mean_prediction": 0.009357959766968415, + "calibration_in_the_large": -0.0051834272576400855, + "expected_calibration_error_10bin": 0.006262297807915912, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + { + "valid": 2682, + "positives": 44, + "negatives": 2638, + "auroc": 0.8057068026742022, + "auprc": 0.08573959847259821, + "brier": 0.015691434787907334, + "calibration": { + "observed_rate": 0.01640566741237882, + "mean_prediction": 0.010190081000763861, + "calibration_in_the_large": -0.0062155864116149595, + "expected_calibration_error_10bin": 0.007043702310372399, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + { + "valid": 2682, + "positives": 49, + "negatives": 2633, + "auroc": 0.8192563770665882, + "auprc": 0.12257755359811114, + "brier": 0.017216694766276557, + "calibration": { + "observed_rate": 0.018269947800149143, + "mean_prediction": 0.010765310513601106, + "calibration_in_the_large": -0.007504637286548037, + "expected_calibration_error_10bin": 0.008132528826986484, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + { + "valid": 2682, + "positives": 51, + "negatives": 2631, + "auroc": 0.818096451807633, + "auprc": 0.12077919920882345, + "brier": 0.017933951826780637, + "calibration": { + "observed_rate": 0.01901565995525727, + "mean_prediction": 0.011816600237909747, + "calibration_in_the_large": -0.007199059717347522, + "expected_calibration_error_10bin": 0.008752716977153501, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + { + "valid": 2682, + "positives": 54, + "negatives": 2628, + "auroc": 0.8100090196741643, + "auprc": 0.12608367153523842, + "brier": 0.018895403469514953, + "calibration": { + "observed_rate": 0.020134228187919462, + "mean_prediction": 0.012533582248744964, + "calibration_in_the_large": -0.007600645939174498, + "expected_calibration_error_10bin": 0.008991289729260967, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + { + "valid": 2682, + "positives": 57, + "negatives": 2625, + "auroc": 0.8193817878028404, + "auprc": 0.13624614423190842, + "brier": 0.019809753669639052, + "calibration": { + "observed_rate": 0.021252796420581657, + "mean_prediction": 0.01295238567749212, + "calibration_in_the_large": -0.008300410743089537, + "expected_calibration_error_10bin": 0.009552106816591773, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + { + "valid": 2682, + "positives": 59, + "negatives": 2623, + "auroc": 0.82573970805844, + "auprc": 0.1629327227861043, + "brier": 0.020186610112914186, + "calibration": { + "observed_rate": 0.021998508575689784, + "mean_prediction": 0.013618158252697436, + "calibration_in_the_large": -0.008380350322992348, + "expected_calibration_error_10bin": 0.009691310148038727, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + { + "valid": 2682, + "positives": 63, + "negatives": 2619, + "auroc": 0.8188148875434099, + "auprc": 0.15243577957759719, + "brier": 0.021596428583141102, + "calibration": { + "observed_rate": 0.02348993288590604, + "mean_prediction": 0.014182759188145114, + "calibration_in_the_large": -0.009307173697760927, + "expected_calibration_error_10bin": 0.009699194935453594, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + { + "valid": 2682, + "positives": 63, + "negatives": 2619, + "auroc": 0.8186876125020455, + "auprc": 0.15232336467871913, + "brier": 0.02159280144415217, + "calibration": { + "observed_rate": 0.02348993288590604, + "mean_prediction": 0.014316451436140116, + "calibration_in_the_large": -0.009173481449765925, + "expected_calibration_error_10bin": 0.009584187976869262, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + } + ], + "reason": null + }, + "D69": { + "time_averaged_auroc": 0.8511346252081147, + "time_averaged_auprc": 0.2244306402826352, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2586, + "positives": 13, + "negatives": 2573, + "auroc": 0.8973063469759933, + "auprc": 0.1758423646888154, + "brier": 0.004737900005876372, + "calibration": { + "observed_rate": 0.005027068832173241, + "mean_prediction": 0.0044167870241663435, + "calibration_in_the_large": -0.0006102818080068973, + "expected_calibration_error_10bin": 0.0006102818080068967, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + { + "valid": 2586, + "positives": 30, + "negatives": 2556, + "auroc": 0.8857459572248305, + "auprc": 0.1842340462521022, + "brier": 0.010510188720934826, + "calibration": { + "observed_rate": 0.01160092807424594, + "mean_prediction": 0.008714577081691663, + "calibration_in_the_large": -0.002886350992554276, + "expected_calibration_error_10bin": 0.003597411252031076, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + { + "valid": 2586, + "positives": 40, + "negatives": 2546, + "auroc": 0.8793499607227023, + "auprc": 0.22352782653283598, + "brier": 0.013536723592942284, + "calibration": { + "observed_rate": 0.015467904098994586, + "mean_prediction": 0.011718464468070377, + "calibration_in_the_large": -0.003749439630924209, + "expected_calibration_error_10bin": 0.004745096568769, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + { + "valid": 2586, + "positives": 47, + "negatives": 2539, + "auroc": 0.868661644306269, + "auprc": 0.21854805607795344, + "brier": 0.015830351527155943, + "calibration": { + "observed_rate": 0.01817478731631864, + "mean_prediction": 0.014149275043638415, + "calibration_in_the_large": -0.004025512272680224, + "expected_calibration_error_10bin": 0.004344442206020205, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + { + "valid": 2586, + "positives": 52, + "negatives": 2534, + "auroc": 0.849364033756299, + "auprc": 0.2111454328325288, + "brier": 0.017528789025392476, + "calibration": { + "observed_rate": 0.020108275328692964, + "mean_prediction": 0.015957231449085913, + "calibration_in_the_large": -0.0041510438796070505, + "expected_calibration_error_10bin": 0.004839772553620169, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + { + "valid": 2586, + "positives": 60, + "negatives": 2526, + "auroc": 0.8515373449458961, + "auprc": 0.21620584896760234, + "brier": 0.02020673610845373, + "calibration": { + "observed_rate": 0.02320185614849188, + "mean_prediction": 0.017257487924064726, + "calibration_in_the_large": -0.005944368224427152, + "expected_calibration_error_10bin": 0.006886767513255181, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + { + "valid": 2586, + "positives": 65, + "negatives": 2521, + "auroc": 0.8361150947426235, + "auprc": 0.21737576833903116, + "brier": 0.021858803516267282, + "calibration": { + "observed_rate": 0.025135344160866203, + "mean_prediction": 0.01867977067434185, + "calibration_in_the_large": -0.006455573486524351, + "expected_calibration_error_10bin": 0.006866847287196513, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + { + "valid": 2586, + "positives": 71, + "negatives": 2515, + "auroc": 0.841351888667992, + "auprc": 0.2485969661107862, + "brier": 0.023379949743847668, + "calibration": { + "observed_rate": 0.02745552977571539, + "mean_prediction": 0.019952139989347778, + "calibration_in_the_large": -0.007503389786367613, + "expected_calibration_error_10bin": 0.008705697329915671, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + { + "valid": 2586, + "positives": 75, + "negatives": 2511, + "auroc": 0.835433426257799, + "auprc": 0.24355631262200178, + "brier": 0.024759226518027217, + "calibration": { + "observed_rate": 0.029002320185614848, + "mean_prediction": 0.021374217220416405, + "calibration_in_the_large": -0.007628102965198443, + "expected_calibration_error_10bin": 0.008339417477898958, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + { + "valid": 2586, + "positives": 81, + "negatives": 2505, + "auroc": 0.8304181759936916, + "auprc": 0.24097118715726062, + "brier": 0.02681627572843891, + "calibration": { + "observed_rate": 0.031322505800464036, + "mean_prediction": 0.02235813286409001, + "calibration_in_the_large": -0.008964372936374025, + "expected_calibration_error_10bin": 0.009912863135343593, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + { + "valid": 2586, + "positives": 85, + "negatives": 2501, + "auroc": 0.8285485805677729, + "auprc": 0.24434386150778425, + "brier": 0.028082423726446152, + "calibration": { + "observed_rate": 0.0328692962103635, + "mean_prediction": 0.023393930147574137, + "calibration_in_the_large": -0.00947536606278936, + "expected_calibration_error_10bin": 0.010311599015038567, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + { + "valid": 2586, + "positives": 86, + "negatives": 2500, + "auroc": 0.8297116279069767, + "auprc": 0.2463260942491276, + "brier": 0.028395751120489466, + "calibration": { + "observed_rate": 0.033255993812838364, + "mean_prediction": 0.024109908985595268, + "calibration_in_the_large": -0.009146084827243096, + "expected_calibration_error_10bin": 0.00964309086270266, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + { + "valid": 2586, + "positives": 87, + "negatives": 2499, + "auroc": 0.8312060456366455, + "auprc": 0.2469245583364275, + "brier": 0.028723672375776273, + "calibration": { + "observed_rate": 0.033642691415313224, + "mean_prediction": 0.024295917812045893, + "calibration_in_the_large": -0.009346773603267331, + "expected_calibration_error_10bin": 0.00987154338315269, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + } + ], + "reason": null + }, + "D70": { + "time_averaged_auroc": 0.905027100898386, + "time_averaged_auprc": 0.24271962409424813, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2787, + "positives": 5, + "negatives": 2782, + "auroc": 0.9329259525521207, + "auprc": 0.2549895858589483, + "brier": 0.0016835945166211543, + "calibration": { + "observed_rate": 0.001794043774668102, + "mean_prediction": 0.0016390292514826643, + "calibration_in_the_large": -0.00015501452318543766, + "expected_calibration_error_10bin": 0.00018578889638434494, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 8, + "negatives": 2779, + "auroc": 0.9433249370277078, + "auprc": 0.1809153328056664, + "brier": 0.002994690090135352, + "calibration": { + "observed_rate": 0.0028704700394689632, + "mean_prediction": 0.003757206464241417, + "calibration_in_the_large": 0.0008867364247724537, + "expected_calibration_error_10bin": 0.002238806099399012, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 17, + "negatives": 2770, + "auroc": 0.902951794436186, + "auprc": 0.2846495567104899, + "brier": 0.005346787623792651, + "calibration": { + "observed_rate": 0.006099748833871547, + "mean_prediction": 0.005148950806453757, + "calibration_in_the_large": -0.0009507980274177895, + "expected_calibration_error_10bin": 0.004130656465754257, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 20, + "negatives": 2767, + "auroc": 0.8860679436212504, + "auprc": 0.24892540411850708, + "brier": 0.006576779898289773, + "calibration": { + "observed_rate": 0.007176175098672408, + "mean_prediction": 0.006144997797958654, + "calibration_in_the_large": -0.0010311773007137537, + "expected_calibration_error_10bin": 0.004312955858749167, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 20, + "negatives": 2767, + "auroc": 0.8873147813516444, + "auprc": 0.2435798241838924, + "brier": 0.006751311893805725, + "calibration": { + "observed_rate": 0.007176175098672408, + "mean_prediction": 0.0069680535182036285, + "calibration_in_the_large": -0.0002081215804687793, + "expected_calibration_error_10bin": 0.004538764660576868, + "nonempty_bins": 8 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 22, + "negatives": 2765, + "auroc": 0.8923886240341936, + "auprc": 0.23739689617693954, + "brier": 0.00746744933321381, + "calibration": { + "observed_rate": 0.007893792608539648, + "mean_prediction": 0.007307758041519235, + "calibration_in_the_large": -0.0005860345670204124, + "expected_calibration_error_10bin": 0.0052684772316072305, + "nonempty_bins": 8 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 24, + "negatives": 2763, + "auroc": 0.8972734949933647, + "auprc": 0.24565658674062182, + "brier": 0.007969973461832923, + "calibration": { + "observed_rate": 0.008611410118406888, + "mean_prediction": 0.007688641087227304, + "calibration_in_the_large": -0.0009227690311795845, + "expected_calibration_error_10bin": 0.005367074383434043, + "nonempty_bins": 8 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 26, + "negatives": 2761, + "auroc": 0.9040481430919678, + "auprc": 0.24951643911625548, + "brier": 0.00869009780334189, + "calibration": { + "observed_rate": 0.009329027628274129, + "mean_prediction": 0.008131508944788321, + "calibration_in_the_large": -0.0011975186834858077, + "expected_calibration_error_10bin": 0.006475545052482791, + "nonempty_bins": 9 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 26, + "negatives": 2761, + "auroc": 0.9038809795781907, + "auprc": 0.24276565592644517, + "brier": 0.008773308400989183, + "calibration": { + "observed_rate": 0.009329027628274129, + "mean_prediction": 0.008444075931239263, + "calibration_in_the_large": -0.0008849516970348657, + "expected_calibration_error_10bin": 0.006595929930425649, + "nonempty_bins": 9 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 26, + "negatives": 2761, + "auroc": 0.9041456551416711, + "auprc": 0.24220722368349604, + "brier": 0.008857031330627577, + "calibration": { + "observed_rate": 0.009329027628274129, + "mean_prediction": 0.008816111617042884, + "calibration_in_the_large": -0.0005129160112312455, + "expected_calibration_error_10bin": 0.006272434368190956, + "nonempty_bins": 9 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 26, + "negatives": 2761, + "auroc": 0.9038809795781907, + "auprc": 0.2421532551267808, + "brier": 0.008939625212918991, + "calibration": { + "observed_rate": 0.009329027628274129, + "mean_prediction": 0.009131208129566571, + "calibration_in_the_large": -0.000197819498707558, + "expected_calibration_error_10bin": 0.006283507603292592, + "nonempty_bins": 9 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 26, + "negatives": 2761, + "auroc": 0.9035605828434514, + "auprc": 0.24129962189362886, + "brier": 0.008992500978608804, + "calibration": { + "observed_rate": 0.009329027628274129, + "mean_prediction": 0.009426659136453101, + "calibration_in_the_large": 9.763150817897193e-05, + "expected_calibration_error_10bin": 0.005557025981979522, + "nonempty_bins": 9 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 26, + "negatives": 2761, + "auroc": 0.9035884434290808, + "auprc": 0.24129973088355408, + "brier": 0.008993532722659757, + "calibration": { + "observed_rate": 0.009329027628274129, + "mean_prediction": 0.009433900804943527, + "calibration_in_the_large": 0.00010487317666939798, + "expected_calibration_error_10bin": 0.005552994174386262, + "nonempty_bins": 9 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + } + ], + "reason": null + }, + "D72": { + "time_averaged_auroc": 0.7161150890045902, + "time_averaged_auprc": 0.058728347153057005, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2595, + "positives": 16, + "negatives": 2579, + "auroc": 0.7388037999224506, + "auprc": 0.06220558143263286, + "brier": 0.006061457512180186, + "calibration": { + "observed_rate": 0.006165703275529865, + "mean_prediction": 0.006790034401343565, + "calibration_in_the_large": 0.0006243311258136994, + "expected_calibration_error_10bin": 0.0006243311258136994, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + { + "valid": 2595, + "positives": 26, + "negatives": 2569, + "auroc": 0.7342725394496512, + "auprc": 0.057374394306040216, + "brier": 0.009780046214573379, + "calibration": { + "observed_rate": 0.01001926782273603, + "mean_prediction": 0.011398342410654282, + "calibration_in_the_large": 0.0013790745879182515, + "expected_calibration_error_10bin": 0.0013790745879182515, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + { + "valid": 2595, + "positives": 34, + "negatives": 2561, + "auroc": 0.709672232813469, + "auprc": 0.05157529701806407, + "brier": 0.012766077053201725, + "calibration": { + "observed_rate": 0.013102119460500963, + "mean_prediction": 0.013764015933555265, + "calibration_in_the_large": 0.0006618964730543027, + "expected_calibration_error_10bin": 0.000901083481208259, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + { + "valid": 2595, + "positives": 39, + "negatives": 2556, + "auroc": 0.7026704385859316, + "auprc": 0.050463891273248684, + "brier": 0.01465168442683102, + "calibration": { + "observed_rate": 0.015028901734104046, + "mean_prediction": 0.01629299984207226, + "calibration_in_the_large": 0.001264098107968216, + "expected_calibration_error_10bin": 0.0013115824583104984, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + { + "valid": 2595, + "positives": 45, + "negatives": 2550, + "auroc": 0.713359477124183, + "auprc": 0.06053065510015915, + "brier": 0.01678010126396935, + "calibration": { + "observed_rate": 0.017341040462427744, + "mean_prediction": 0.018065390557630314, + "calibration_in_the_large": 0.0007243500952025701, + "expected_calibration_error_10bin": 0.0014746701827107681, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + { + "valid": 2595, + "positives": 46, + "negatives": 2549, + "auroc": 0.7195745987343716, + "auprc": 0.05896415087303386, + "brier": 0.01715693344039814, + "calibration": { + "observed_rate": 0.017726396917148363, + "mean_prediction": 0.019494765087009293, + "calibration_in_the_large": 0.0017683681698609302, + "expected_calibration_error_10bin": 0.0017683681698609332, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + { + "valid": 2595, + "positives": 50, + "negatives": 2545, + "auroc": 0.7259882121807466, + "auprc": 0.05806604163665836, + "brier": 0.018630015188409493, + "calibration": { + "observed_rate": 0.019267822736030827, + "mean_prediction": 0.020734403851201583, + "calibration_in_the_large": 0.0014665811151707564, + "expected_calibration_error_10bin": 0.0014665811151707549, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + { + "valid": 2595, + "positives": 54, + "negatives": 2541, + "auroc": 0.7086376025769965, + "auprc": 0.056907575329799454, + "brier": 0.020143279314557536, + "calibration": { + "observed_rate": 0.020809248554913295, + "mean_prediction": 0.022075911050057666, + "calibration_in_the_large": 0.0012666624951443717, + "expected_calibration_error_10bin": 0.0012666624951443728, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + { + "valid": 2595, + "positives": 58, + "negatives": 2537, + "auroc": 0.707195574463458, + "auprc": 0.058582896654353116, + "brier": 0.021590995008624304, + "calibration": { + "observed_rate": 0.022350674373795763, + "mean_prediction": 0.023394864228166466, + "calibration_in_the_large": 0.0010441898543707036, + "expected_calibration_error_10bin": 0.001044189854370708, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + { + "valid": 2595, + "positives": 60, + "negatives": 2535, + "auroc": 0.713405654174885, + "auprc": 0.05940864667687797, + "brier": 0.022317136662694213, + "calibration": { + "observed_rate": 0.023121387283236993, + "mean_prediction": 0.024450828943864546, + "calibration_in_the_large": 0.0013294416606275533, + "expected_calibration_error_10bin": 0.0013294416606275492, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + { + "valid": 2595, + "positives": 65, + "negatives": 2530, + "auroc": 0.7129340224992399, + "auprc": 0.061121133467490894, + "brier": 0.024139673145018744, + "calibration": { + "observed_rate": 0.025048169556840076, + "mean_prediction": 0.02527522407965609, + "calibration_in_the_large": 0.00022705452281601354, + "expected_calibration_error_10bin": 0.0017629093977735728, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + { + "valid": 2595, + "positives": 67, + "negatives": 2528, + "auroc": 0.7112873134328358, + "auprc": 0.06420355574154434, + "brier": 0.024825981279309746, + "calibration": { + "observed_rate": 0.02581888246628131, + "mean_prediction": 0.026355730289205737, + "calibration_in_the_large": 0.0005368478229244265, + "expected_calibration_error_10bin": 0.001485794028339042, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + { + "valid": 2595, + "positives": 67, + "negatives": 2528, + "auroc": 0.7116946911014548, + "auprc": 0.0640646934798381, + "brier": 0.024829920074924464, + "calibration": { + "observed_rate": 0.02581888246628131, + "mean_prediction": 0.026548389451100933, + "calibration_in_the_large": 0.000729506984819623, + "expected_calibration_error_10bin": 0.0013444128801583227, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + } + ], + "reason": null + }, + "D73": { + "time_averaged_auroc": 0.8281880326457446, + "time_averaged_auprc": 0.025351502226577647, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2824, + "positives": 0, + "negatives": 2824, + "auroc": null, + "auprc": null, + "brier": 3.2270743261077267e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00030420228418787505, + "calibration_in_the_large": 0.00030420228418787505, + "expected_calibration_error_10bin": 0.00030420228418787505, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 1, + "negatives": 2823, + "auroc": 0.9943322706340773, + "auprc": 0.058823529411764705, + "brier": 0.00034779960870819467, + "calibration": { + "observed_rate": 0.0003541076487252125, + "mean_prediction": 0.0005543361497176849, + "calibration_in_the_large": 0.00020022850099247238, + "expected_calibration_error_10bin": 0.00020022850099247238, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.7629340892983699, + "auprc": 0.030167051714945797, + "brier": 0.0007061661210853564, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0008527993405774814, + "calibration_in_the_large": 0.0001445840431270564, + "expected_calibration_error_10bin": 0.00014458404312705643, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.7604535790219702, + "auprc": 0.025749063670411985, + "brier": 0.0007106305484891897, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0009919093235103713, + "calibration_in_the_large": 0.0002836940260599463, + "expected_calibration_error_10bin": 0.0002836940260599463, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.8219307574146284, + "auprc": 0.02171512609093978, + "brier": 0.0010665967965201657, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0010901334976342542, + "calibration_in_the_large": 2.7810551458616693e-05, + "expected_calibration_error_10bin": 6.809055703864623e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.8244121469927922, + "auprc": 0.02135302795997085, + "brier": 0.001070486929185017, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0012110697438802627, + "calibration_in_the_large": 0.00014874679770462518, + "expected_calibration_error_10bin": 0.00014874679770462534, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.8278388278388278, + "auprc": 0.02140296979006656, + "brier": 0.0010712997621199042, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.001252263205425015, + "calibration_in_the_large": 0.0001899402592493776, + "expected_calibration_error_10bin": 0.0001899402592493778, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.8278388278388278, + "auprc": 0.02140296979006656, + "brier": 0.0010753914995077077, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.001372468764040821, + "calibration_in_the_large": 0.0003101458178651835, + "expected_calibration_error_10bin": 0.00031014581786518357, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.82642089093702, + "auprc": 0.021297797041504137, + "brier": 0.0010811532089998043, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0014849677370424197, + "calibration_in_the_large": 0.00042264479086678223, + "expected_calibration_error_10bin": 0.00042264479086678256, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.8233486943164362, + "auprc": 0.020594293988586445, + "brier": 0.0010878175407725088, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.001604789875567811, + "calibration_in_the_large": 0.0005424669293921736, + "expected_calibration_error_10bin": 0.0005424669293921738, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.8228760486825003, + "auprc": 0.020592062987374454, + "brier": 0.00109858158356754, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0017756171216692937, + "calibration_in_the_large": 0.0007132941754936562, + "expected_calibration_error_10bin": 0.0007132941754936566, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.8228760486825003, + "auprc": 0.02055978847023623, + "brier": 0.0011046020614906965, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0018425339911559075, + "calibration_in_the_large": 0.00078021104498027, + "expected_calibration_error_10bin": 0.00078021104498027, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.8229942100909843, + "auprc": 0.02056034580306425, + "brier": 0.0011047367996780532, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0018462793918559677, + "calibration_in_the_large": 0.0007839564456803302, + "expected_calibration_error_10bin": 0.0007839564456803306, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + } + ], + "reason": null + }, + "D75": { + "time_averaged_auroc": 0.8824877604229914, + "time_averaged_auprc": 0.006013995080802259, + "valid_timepoint_cells": 11, + "timepoints": [ + { + "valid": 2831, + "positives": 0, + "negatives": 2831, + "auroc": null, + "auprc": null, + "brier": 2.0832965407355065e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0003042988700803543, + "calibration_in_the_large": 0.0003042988700803543, + "expected_calibration_error_10bin": 0.0003042988700803543, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 0, + "negatives": 2831, + "auroc": null, + "auprc": null, + "brier": 7.328078131572421e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00048004396094002865, + "calibration_in_the_large": 0.00048004396094002865, + "expected_calibration_error_10bin": 0.00048004396094002865, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.9321554770318021, + "auprc": 0.0051813471502590676, + "brier": 0.0003544573909263853, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0007624157497902704, + "calibration_in_the_large": 0.0004091836763179991, + "expected_calibration_error_10bin": 0.0004091836763179991, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 2, + "negatives": 2829, + "auroc": 0.8923647932131495, + "auprc": 0.004985119047619047, + "brier": 0.0007074343896524882, + "calibration": { + "observed_rate": 0.0007064641469445425, + "mean_prediction": 0.0009098821169095982, + "calibration_in_the_large": 0.00020341796996505566, + "expected_calibration_error_10bin": 0.00020341796996505566, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 2, + "negatives": 2829, + "auroc": 0.8911276069282432, + "auprc": 0.00486061894637373, + "brier": 0.0007081266225107403, + "calibration": { + "observed_rate": 0.0007064641469445425, + "mean_prediction": 0.0010160640316969457, + "calibration_in_the_large": 0.0003095998847524032, + "expected_calibration_error_10bin": 0.0003095998847524032, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 3, + "negatives": 2828, + "auroc": 0.8730551626591231, + "auprc": 0.005394681196860044, + "brier": 0.001060690038738493, + "calibration": { + "observed_rate": 0.0010596962204168139, + "mean_prediction": 0.001108622061750143, + "calibration_in_the_large": 4.8925841333329187e-05, + "expected_calibration_error_10bin": 4.8925841333329187e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 3, + "negatives": 2828, + "auroc": 0.874941065535125, + "auprc": 0.005447163124396189, + "brier": 0.0010613595620154288, + "calibration": { + "observed_rate": 0.0010596962204168139, + "mean_prediction": 0.0012009370490203468, + "calibration_in_the_large": 0.00014124082860353295, + "expected_calibration_error_10bin": 0.00014124082860353295, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.8775203395825963, + "auprc": 0.006783365410193484, + "brier": 0.001413920810620539, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0012903563768506025, + "calibration_in_the_large": -0.00012257191703848262, + "expected_calibration_error_10bin": 0.00012257191703848262, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.8779625044216484, + "auprc": 0.00687611705553047, + "brier": 0.0014141955430232063, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.001376199860362065, + "calibration_in_the_large": -3.672843352702003e-05, + "expected_calibration_error_10bin": 3.672843352702003e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.8737177219667492, + "auprc": 0.006742171204190739, + "brier": 0.0014157267465841033, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.001532043298656326, + "calibration_in_the_large": 0.000119115004767241, + "expected_calibration_error_10bin": 0.000119115004767241, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.8726565263530244, + "auprc": 0.00667333447344723, + "brier": 0.0014171689033767394, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0016540935808999223, + "calibration_in_the_large": 0.0002411652870108372, + "expected_calibration_error_10bin": 0.0002411652870108372, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.8710647329324372, + "auprc": 0.006612102215716447, + "brier": 0.0014188777150490833, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0017407153333958449, + "calibration_in_the_large": 0.0003277870395067598, + "expected_calibration_error_10bin": 0.0003277870395067598, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.8707994340290061, + "auprc": 0.006597926064238405, + "brier": 0.0014190664255818524, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0017575355472081563, + "calibration_in_the_large": 0.00034460725331907126, + "expected_calibration_error_10bin": 0.00034460725331907126, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + } + ], + "reason": null + }, + "D80": { + "time_averaged_auroc": 0.9886694522569097, + "time_averaged_auprc": 0.08911102774433835, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2832, + "positives": 1, + "negatives": 2831, + "auroc": 0.986930413281526, + "auprc": 0.02631578947368421, + "brier": 0.00035243942525111055, + "calibration": { + "observed_rate": 0.00035310734463276836, + "mean_prediction": 0.00023331761971031602, + "calibration_in_the_large": -0.00011978972492245234, + "expected_calibration_error_10bin": 0.00011978972492245234, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 3, + "negatives": 2829, + "auroc": 0.9903381642512077, + "auprc": 0.07913105413105413, + "brier": 0.0010391906703815922, + "calibration": { + "observed_rate": 0.001059322033898305, + "mean_prediction": 0.0005255873743918929, + "calibration_in_the_large": -0.0005337346595064122, + "expected_calibration_error_10bin": 0.0005337346595064122, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 4, + "negatives": 2828, + "auroc": 0.9907178217821783, + "auprc": 0.08641774891774892, + "brier": 0.001376069339307882, + "calibration": { + "observed_rate": 0.0014124293785310734, + "mean_prediction": 0.0008402862824741494, + "calibration_in_the_large": -0.000572143096056924, + "expected_calibration_error_10bin": 0.0007626599246215247, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 5, + "negatives": 2827, + "auroc": 0.9912274495932083, + "auprc": 0.10348499992428029, + "brier": 0.0017044730436385769, + "calibration": { + "observed_rate": 0.0017655367231638418, + "mean_prediction": 0.0009790182633349176, + "calibration_in_the_large": -0.0007865184598289242, + "expected_calibration_error_10bin": 0.0009995301013262532, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.9884996461429583, + "auprc": 0.0987650749129878, + "brier": 0.0020565514648307284, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.001091056390711758, + "calibration_in_the_large": -0.001027587677084852, + "expected_calibration_error_10bin": 0.0012734884175635238, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.9882637414484549, + "auprc": 0.09622775372775372, + "brier": 0.002064391867014502, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.0012921444211258725, + "calibration_in_the_large": -0.0008264996466707376, + "expected_calibration_error_10bin": 0.001284557542815384, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.9881457891012031, + "auprc": 0.0959860617085899, + "brier": 0.00207428415581379, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.0014696605214682143, + "calibration_in_the_large": -0.0006489835463283958, + "expected_calibration_error_10bin": 0.001316790229531317, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.9882047652748289, + "auprc": 0.09534818055616018, + "brier": 0.002077267889207908, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.0016640906410812202, + "calibration_in_the_large": -0.0004545534267153899, + "expected_calibration_error_10bin": 0.0012653690216374047, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.9882637414484549, + "auprc": 0.09587728108526071, + "brier": 0.0021041472332200785, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.0019524769029983277, + "calibration_in_the_large": -0.0001661671647982825, + "expected_calibration_error_10bin": 0.0013810799048173642, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.9881457891012031, + "auprc": 0.09553989916893142, + "brier": 0.0021176404151380815, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.0020709912362274164, + "calibration_in_the_large": -4.765283156919374e-05, + "expected_calibration_error_10bin": 0.0013372805568171399, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.9880278367539514, + "auprc": 0.0952193863484186, + "brier": 0.002123098922901851, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.002219262741095404, + "calibration_in_the_large": 0.00010061867329879369, + "expected_calibration_error_10bin": 0.0006738000777210855, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.9879688605803255, + "auprc": 0.0950650653607643, + "brier": 0.0021239777188262953, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.002261054202265789, + "calibration_in_the_large": 0.00014241013446917878, + "expected_calibration_error_10bin": 0.0006402783611233668, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.9879688605803255, + "auprc": 0.0950650653607643, + "brier": 0.0021242357644532138, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.0022653633488393466, + "calibration_in_the_large": 0.0001467192810427364, + "expected_calibration_error_10bin": 0.0006374094391400837, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + } + ], + "reason": null + }, + "D89": { + "time_averaged_auroc": 0.845585126708775, + "time_averaged_auprc": 0.007322106652424395, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2837, + "positives": 1, + "negatives": 2836, + "auroc": 0.9601551480959097, + "auprc": 0.008771929824561403, + "brier": 0.0003529288559432424, + "calibration": { + "observed_rate": 0.00035248501938667606, + "mean_prediction": 6.148695924008289e-05, + "calibration_in_the_large": -0.00029099806014659316, + "expected_calibration_error_10bin": 0.00029099806014659316, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.8343915343915344, + "auprc": 0.007188240739442053, + "brier": 0.0007107065478269824, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.00020157833322300038, + "calibration_in_the_large": -0.0005033917055503517, + "expected_calibration_error_10bin": 0.0005033917055503517, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.8222222222222222, + "auprc": 0.006581462016244625, + "brier": 0.0007280025613646637, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.00037250139139643535, + "calibration_in_the_large": -0.00033246864737691677, + "expected_calibration_error_10bin": 0.0006047650768557071, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.82663139329806, + "auprc": 0.006925064599483204, + "brier": 0.0007708394246915555, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0006263494167406404, + "calibration_in_the_large": -7.862062203271175e-05, + "expected_calibration_error_10bin": 0.0006783740605977343, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.82663139329806, + "auprc": 0.007061028402491816, + "brier": 0.0007896930711807005, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0007200642272205647, + "calibration_in_the_large": 1.5094188447212589e-05, + "expected_calibration_error_10bin": 0.0006640664088460644, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.828395061728395, + "auprc": 0.006937548993990071, + "brier": 0.0008208879656628991, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0008304606452263318, + "calibration_in_the_large": 0.00012549060645297965, + "expected_calibration_error_10bin": 0.0007383671315615266, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.8271604938271605, + "auprc": 0.007064728004661264, + "brier": 0.0008326201648533166, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0008828796616819509, + "calibration_in_the_large": 0.0001779096229085988, + "expected_calibration_error_10bin": 0.0007281040358717838, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.845679012345679, + "auprc": 0.007353842382644932, + "brier": 0.0008583869392550051, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0009765297007024641, + "calibration_in_the_large": 0.000271559661929112, + "expected_calibration_error_10bin": 0.0008698598889114494, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.8409171075837742, + "auprc": 0.0074621212121212125, + "brier": 0.0008869543775689438, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0010705465127618615, + "calibration_in_the_large": 0.0003655764739885094, + "expected_calibration_error_10bin": 0.0008790750861023955, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.8430335097001763, + "auprc": 0.0074043665997688985, + "brier": 0.0009176499232852342, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0011609029883524863, + "calibration_in_the_large": 0.0004559329495791342, + "expected_calibration_error_10bin": 0.0008898351906210698, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.8447971781305115, + "auprc": 0.007419722299190296, + "brier": 0.0009406866557978677, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0012315638974733506, + "calibration_in_the_large": 0.0005265938586999985, + "expected_calibration_error_10bin": 0.0008884398422813164, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.8458553791887126, + "auprc": 0.007504705144291092, + "brier": 0.0009756931480413126, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0013232676661466918, + "calibration_in_the_large": 0.0006182976273733397, + "expected_calibration_error_10bin": 0.0008932740631561298, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.8467372134038801, + "auprc": 0.007512626262626263, + "brier": 0.0009759221096618955, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0013248749098726084, + "calibration_in_the_large": 0.0006199048710992563, + "expected_calibration_error_10bin": 0.0008922929308221593, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + } + ], + "reason": null + }, + "E03": { + "time_averaged_auroc": 0.7219583339184011, + "time_averaged_auprc": 0.019805354899219967, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2480, + "positives": 7, + "negatives": 2473, + "auroc": 0.7517185604528912, + "auprc": 0.007217916326414894, + "brier": 0.0028135872878334352, + "calibration": { + "observed_rate": 0.00282258064516129, + "mean_prediction": 0.0014328864125702475, + "calibration_in_the_large": -0.0013896942325910427, + "expected_calibration_error_10bin": 0.0013896942325910427, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + { + "valid": 2480, + "positives": 11, + "negatives": 2469, + "auroc": 0.7031923119407931, + "auprc": 0.010339792587287443, + "brier": 0.004413620405155744, + "calibration": { + "observed_rate": 0.004435483870967742, + "mean_prediction": 0.002328693321138534, + "calibration_in_the_large": -0.002106790549829208, + "expected_calibration_error_10bin": 0.002106790549829208, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + { + "valid": 2480, + "positives": 14, + "negatives": 2466, + "auroc": 0.7038002548951454, + "auprc": 0.012113944011970941, + "brier": 0.005610609269926346, + "calibration": { + "observed_rate": 0.00564516129032258, + "mean_prediction": 0.0029770003928499666, + "calibration_in_the_large": -0.0026681608974726137, + "expected_calibration_error_10bin": 0.0026681608974726137, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + { + "valid": 2480, + "positives": 17, + "negatives": 2463, + "auroc": 0.7418738506364787, + "auprc": 0.01894127489247665, + "brier": 0.00679272636534709, + "calibration": { + "observed_rate": 0.0068548387096774195, + "mean_prediction": 0.0035408270038861963, + "calibration_in_the_large": -0.003314011705791223, + "expected_calibration_error_10bin": 0.003314011705791223, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + { + "valid": 2480, + "positives": 18, + "negatives": 2462, + "auroc": 0.748894304540121, + "auprc": 0.020761503059650643, + "brier": 0.007184057090844736, + "calibration": { + "observed_rate": 0.007258064516129033, + "mean_prediction": 0.004008693053953222, + "calibration_in_the_large": -0.0032493714621758107, + "expected_calibration_error_10bin": 0.0032493714621758107, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + { + "valid": 2480, + "positives": 18, + "negatives": 2462, + "auroc": 0.7489168697535878, + "auprc": 0.0206364891868379, + "brier": 0.007180034096980154, + "calibration": { + "observed_rate": 0.007258064516129033, + "mean_prediction": 0.004476648749386508, + "calibration_in_the_large": -0.0027814157667425243, + "expected_calibration_error_10bin": 0.0027814157667425243, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + { + "valid": 2480, + "positives": 20, + "negatives": 2460, + "auroc": 0.7470121951219513, + "auprc": 0.025254195982144907, + "brier": 0.007959563360072112, + "calibration": { + "observed_rate": 0.008064516129032258, + "mean_prediction": 0.004977666514112629, + "calibration_in_the_large": -0.003086849614919629, + "expected_calibration_error_10bin": 0.003086849614919629, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + { + "valid": 2480, + "positives": 21, + "negatives": 2459, + "auroc": 0.7313464629446736, + "auprc": 0.024426723819249714, + "brier": 0.00835623662781612, + "calibration": { + "observed_rate": 0.008467741935483872, + "mean_prediction": 0.005416642695044791, + "calibration_in_the_large": -0.003051099240439081, + "expected_calibration_error_10bin": 0.003051099240439081, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + { + "valid": 2480, + "positives": 22, + "negatives": 2458, + "auroc": 0.7193024631999408, + "auprc": 0.023902159286498314, + "brier": 0.00875485414862613, + "calibration": { + "observed_rate": 0.008870967741935484, + "mean_prediction": 0.005766959152594697, + "calibration_in_the_large": -0.0031040085893407872, + "expected_calibration_error_10bin": 0.0031040085893407872, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + { + "valid": 2480, + "positives": 23, + "negatives": 2457, + "auroc": 0.7063226628444019, + "auprc": 0.02333107723931554, + "brier": 0.009153267917109353, + "calibration": { + "observed_rate": 0.009274193548387096, + "mean_prediction": 0.006167060725537369, + "calibration_in_the_large": -0.003107132822849727, + "expected_calibration_error_10bin": 0.003107132822849727, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + { + "valid": 2480, + "positives": 24, + "negatives": 2456, + "auroc": 0.7102334419109664, + "auprc": 0.023938440061548046, + "brier": 0.009546142466002269, + "calibration": { + "observed_rate": 0.00967741935483871, + "mean_prediction": 0.006443196581676603, + "calibration_in_the_large": -0.0032342227731621074, + "expected_calibration_error_10bin": 0.0032342227731621074, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + { + "valid": 2480, + "positives": 26, + "negatives": 2454, + "auroc": 0.6864459908469689, + "auprc": 0.02327924991316751, + "brier": 0.010345423082331044, + "calibration": { + "observed_rate": 0.010483870967741936, + "mean_prediction": 0.006849041787814537, + "calibration_in_the_large": -0.0036348291799273994, + "expected_calibration_error_10bin": 0.0036348291799273994, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + { + "valid": 2480, + "positives": 26, + "negatives": 2454, + "auroc": 0.6863989718512946, + "auprc": 0.023326847323297057, + "brier": 0.010344841328738467, + "calibration": { + "observed_rate": 0.010483870967741936, + "mean_prediction": 0.006922524662161689, + "calibration_in_the_large": -0.003561346305580247, + "expected_calibration_error_10bin": 0.003561346305580247, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + } + ], + "reason": null + }, + "E04": { + "time_averaged_auroc": 0.7143163685620568, + "time_averaged_auprc": 0.008281708294179133, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2775, + "positives": 3, + "negatives": 2772, + "auroc": 0.7146464646464646, + "auprc": 0.004262913629629096, + "brier": 0.0010799370709230424, + "calibration": { + "observed_rate": 0.001081081081081081, + "mean_prediction": 0.0004726489342145804, + "calibration_in_the_large": -0.0006084321468665006, + "expected_calibration_error_10bin": 0.0006084321468665006, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 4, + "negatives": 2771, + "auroc": 0.6196319018404908, + "auprc": 0.0038315779271375474, + "brier": 0.0014398729508369491, + "calibration": { + "observed_rate": 0.0014414414414414415, + "mean_prediction": 0.0010155878484543824, + "calibration_in_the_large": -0.0004258535929870591, + "expected_calibration_error_10bin": 0.0004258535929870591, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 6, + "negatives": 2769, + "auroc": 0.7096424702058505, + "auprc": 0.0054376677498259, + "brier": 0.0021584585112332266, + "calibration": { + "observed_rate": 0.002162162162162162, + "mean_prediction": 0.001504587216521949, + "calibration_in_the_large": -0.0006575749456402132, + "expected_calibration_error_10bin": 0.0006575749456402132, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 8, + "negatives": 2767, + "auroc": 0.7534784965666788, + "auprc": 0.00808064907648098, + "brier": 0.0028757708578128474, + "calibration": { + "observed_rate": 0.002882882882882883, + "mean_prediction": 0.002027297062977104, + "calibration_in_the_large": -0.000855585819905779, + "expected_calibration_error_10bin": 0.000855585819905779, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 9, + "negatives": 2766, + "auroc": 0.7718325700972122, + "auprc": 0.010198522628465594, + "brier": 0.0032320255476822606, + "calibration": { + "observed_rate": 0.003243243243243243, + "mean_prediction": 0.002362933934357873, + "calibration_in_the_large": -0.0008803093088853701, + "expected_calibration_error_10bin": 0.0008803093088853701, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 9, + "negatives": 2766, + "auroc": 0.7683779223909376, + "auprc": 0.009948291807011825, + "brier": 0.003234023250061297, + "calibration": { + "observed_rate": 0.003243243243243243, + "mean_prediction": 0.0026689508190978453, + "calibration_in_the_large": -0.0005742924241453977, + "expected_calibration_error_10bin": 0.0005742924241453977, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 9, + "negatives": 2766, + "auroc": 0.7664497469269703, + "auprc": 0.009953323408954566, + "brier": 0.003235858078355121, + "calibration": { + "observed_rate": 0.003243243243243243, + "mean_prediction": 0.003027762308027721, + "calibration_in_the_large": -0.00021548093521552188, + "expected_calibration_error_10bin": 0.00021548093521552188, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 9, + "negatives": 2766, + "auroc": 0.7660882140274765, + "auprc": 0.009864133739414742, + "brier": 0.0032370783254810523, + "calibration": { + "observed_rate": 0.003243243243243243, + "mean_prediction": 0.003148352715647192, + "calibration_in_the_large": -9.489052759605087e-05, + "expected_calibration_error_10bin": 9.489052759605087e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 11, + "negatives": 2764, + "auroc": 0.68382449677674, + "auprc": 0.009220861353869882, + "brier": 0.003958883294681375, + "calibration": { + "observed_rate": 0.003963963963963964, + "mean_prediction": 0.00337470388868488, + "calibration_in_the_large": -0.000589260075279084, + "expected_calibration_error_10bin": 0.000589260075279084, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 11, + "negatives": 2764, + "auroc": 0.6840876200499935, + "auprc": 0.009265643566755395, + "brier": 0.0039606450987681625, + "calibration": { + "observed_rate": 0.003963963963963964, + "mean_prediction": 0.0034763139089556863, + "calibration_in_the_large": -0.00048765005500827794, + "expected_calibration_error_10bin": 0.00048765005500827794, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 11, + "negatives": 2764, + "auroc": 0.6838902775950533, + "auprc": 0.009193544451932928, + "brier": 0.003963223608088505, + "calibration": { + "observed_rate": 0.003963963963963964, + "mean_prediction": 0.0036495854437397376, + "calibration_in_the_large": -0.0003143785202242267, + "expected_calibration_error_10bin": 0.0003143785202242267, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 11, + "negatives": 2764, + "auroc": 0.682114195500592, + "auprc": 0.009217268470031953, + "brier": 0.003968393553469026, + "calibration": { + "observed_rate": 0.003963963963963964, + "mean_prediction": 0.003950835459887654, + "calibration_in_the_large": -1.3128504076310478e-05, + "expected_calibration_error_10bin": 1.3128504076310478e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 11, + "negatives": 2764, + "auroc": 0.6820484146822786, + "auprc": 0.00918781001481832, + "brier": 0.00396934606104984, + "calibration": { + "observed_rate": 0.003963963963963964, + "mean_prediction": 0.004005405154825935, + "calibration_in_the_large": 4.144119086197089e-05, + "expected_calibration_error_10bin": 4.144119086197089e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + } + ], + "reason": null + }, + "E05": { + "time_averaged_auroc": 0.27761080261304716, + "time_averaged_auprc": 0.0124446034178481, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.10823823109843081, + "auprc": 0.0005870878624710697, + "brier": 0.000712894068375789, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0003069746433614164, + "calibration_in_the_large": -0.00040578373154948885, + "expected_calibration_error_10bin": 0.00040578373154948885, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.11911554921540657, + "auprc": 0.0005939560457683415, + "brier": 0.0007132342765646067, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0004951043785467684, + "calibration_in_the_large": -0.00021765399636413686, + "expected_calibration_error_10bin": 0.00021765399636413686, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.1144793152639087, + "auprc": 0.000591926725564978, + "brier": 0.0007136184889920264, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0006201494786836678, + "calibration_in_the_large": -9.260889622723749e-05, + "expected_calibration_error_10bin": 9.260889622723749e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.10627674750356633, + "auprc": 0.0005873625026883498, + "brier": 0.0007141677025772864, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0007590326729636761, + "calibration_in_the_large": 4.6274298052770843e-05, + "expected_calibration_error_10bin": 4.6274298052770843e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.10431526390870186, + "auprc": 0.000585834967194674, + "brier": 0.0007148778127345639, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0009138006688080611, + "calibration_in_the_large": 0.00020104229389715587, + "expected_calibration_error_10bin": 0.00020104229389715587, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.10859486447931527, + "auprc": 0.0005892333736645114, + "brier": 0.0007151831386979978, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0009740935658733448, + "calibration_in_the_large": 0.00026133519096243956, + "expected_calibration_error_10bin": 0.00026133519096243956, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 3, + "negatives": 2803, + "auroc": 0.29670591033416577, + "auprc": 0.0009967076719535855, + "brier": 0.001071303905447406, + "calibration": { + "observed_rate": 0.0010691375623663579, + "mean_prediction": 0.0010655901403714741, + "calibration_in_the_large": -3.5474219948837104e-06, + "expected_calibration_error_10bin": 3.5474219948837104e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 3, + "negatives": 2803, + "auroc": 0.2968248305387085, + "auprc": 0.0009990064494525871, + "brier": 0.0010718948190053797, + "calibration": { + "observed_rate": 0.0010691375623663579, + "mean_prediction": 0.0011724467880975383, + "calibration_in_the_large": 0.00010330922573118049, + "expected_calibration_error_10bin": 0.00010330922573118049, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 4, + "negatives": 2802, + "auroc": 0.4719842969307637, + "auprc": 0.03691281953734751, + "brier": 0.0014205780041212663, + "calibration": { + "observed_rate": 0.0014255167498218105, + "mean_prediction": 0.0012572742792547273, + "calibration_in_the_large": -0.00016824247056708322, + "expected_calibration_error_10bin": 0.00016824247056708322, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 4, + "negatives": 2802, + "auroc": 0.4719842969307637, + "auprc": 0.032445158718276496, + "brier": 0.0014206080505966045, + "calibration": { + "observed_rate": 0.0014255167498218105, + "mean_prediction": 0.0013013754872327255, + "calibration_in_the_large": -0.00012414126258908495, + "expected_calibration_error_10bin": 0.00012414126258908495, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 4, + "negatives": 2802, + "auroc": 0.4706459671663098, + "auprc": 0.028966536551879835, + "brier": 0.001420700820282628, + "calibration": { + "observed_rate": 0.0014255167498218105, + "mean_prediction": 0.0013818358889156877, + "calibration_in_the_large": -4.36808609061228e-05, + "expected_calibration_error_10bin": 4.36808609061228e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 4, + "negatives": 2802, + "auroc": 0.47002141327623126, + "auprc": 0.02896262624831695, + "brier": 0.0014209965426962249, + "calibration": { + "observed_rate": 0.0014255167498218105, + "mean_prediction": 0.0014683815978796422, + "calibration_in_the_large": 4.286484805783174e-05, + "expected_calibration_error_10bin": 4.286484805783174e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 4, + "negatives": 2802, + "auroc": 0.46975374732334046, + "auprc": 0.028961587777446417, + "brier": 0.0014209878060548163, + "calibration": { + "observed_rate": 0.0014255167498218105, + "mean_prediction": 0.0014801860165753896, + "calibration_in_the_large": 5.4669266753579106e-05, + "expected_calibration_error_10bin": 5.4669266753579106e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + } + ], + "reason": null + }, + "E11": { + "time_averaged_auroc": 0.7727441452662448, + "time_averaged_auprc": 0.09270553576560012, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2194, + "positives": 6, + "negatives": 2188, + "auroc": 0.6793113954905545, + "auprc": 0.05963132271760544, + "brier": 0.0027070375469001053, + "calibration": { + "observed_rate": 0.0027347310847766638, + "mean_prediction": 0.00206814515841027, + "calibration_in_the_large": -0.0006665859263663937, + "expected_calibration_error_10bin": 0.0006665859263663937, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + { + "valid": 2194, + "positives": 9, + "negatives": 2185, + "auroc": 0.7042461225527588, + "auprc": 0.054312580053143655, + "brier": 0.004058415632710041, + "calibration": { + "observed_rate": 0.004102096627164996, + "mean_prediction": 0.0030988525374820745, + "calibration_in_the_large": -0.0010032440896829212, + "expected_calibration_error_10bin": 0.0010032440896829212, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + { + "valid": 2194, + "positives": 11, + "negatives": 2183, + "auroc": 0.7716653479365344, + "auprc": 0.09053401244077744, + "brier": 0.004917814581008486, + "calibration": { + "observed_rate": 0.005013673655423883, + "mean_prediction": 0.003662995449120482, + "calibration_in_the_large": -0.0013506782063034011, + "expected_calibration_error_10bin": 0.0013506782063034011, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + { + "valid": 2194, + "positives": 13, + "negatives": 2181, + "auroc": 0.7747328325044969, + "auprc": 0.09108966538847466, + "brier": 0.005809382283337496, + "calibration": { + "observed_rate": 0.005925250683682771, + "mean_prediction": 0.0045075746989855035, + "calibration_in_the_large": -0.0014176759846972675, + "expected_calibration_error_10bin": 0.0014176759846972675, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + { + "valid": 2194, + "positives": 13, + "negatives": 2181, + "auroc": 0.7723697668677036, + "auprc": 0.07572578371338722, + "brier": 0.005804458034148376, + "calibration": { + "observed_rate": 0.005925250683682771, + "mean_prediction": 0.005302662221216109, + "calibration_in_the_large": -0.0006225884624666616, + "expected_calibration_error_10bin": 0.0006225884624666616, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + { + "valid": 2194, + "positives": 15, + "negatives": 2179, + "auroc": 0.7940339605323543, + "auprc": 0.0734259662933246, + "brier": 0.006677848711683165, + "calibration": { + "observed_rate": 0.0068368277119416595, + "mean_prediction": 0.005676156037881782, + "calibration_in_the_large": -0.0011606716740598776, + "expected_calibration_error_10bin": 0.0012570914441776477, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + { + "valid": 2194, + "positives": 17, + "negatives": 2177, + "auroc": 0.8022372936312788, + "auprc": 0.0730342919036633, + "brier": 0.007549646376192538, + "calibration": { + "observed_rate": 0.007748404740200547, + "mean_prediction": 0.006101906146669936, + "calibration_in_the_large": -0.0016464985935306115, + "expected_calibration_error_10bin": 0.001747617920934509, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + { + "valid": 2194, + "positives": 19, + "negatives": 2175, + "auroc": 0.8050090744101633, + "auprc": 0.06156459630011027, + "brier": 0.008435705332759084, + "calibration": { + "observed_rate": 0.008659981768459436, + "mean_prediction": 0.006864799139701514, + "calibration_in_the_large": -0.0017951826287579218, + "expected_calibration_error_10bin": 0.0019116463691710684, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + { + "valid": 2194, + "positives": 19, + "negatives": 2175, + "auroc": 0.8039685420447671, + "auprc": 0.060374989972309556, + "brier": 0.008438955524664914, + "calibration": { + "observed_rate": 0.008659981768459436, + "mean_prediction": 0.007413442606301558, + "calibration_in_the_large": -0.001246539162157878, + "expected_calibration_error_10bin": 0.0012465391621578764, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + { + "valid": 2194, + "positives": 20, + "negatives": 2174, + "auroc": 0.8152023919043239, + "auprc": 0.15142462137349258, + "brier": 0.008755659481605579, + "calibration": { + "observed_rate": 0.009115770282588878, + "mean_prediction": 0.007945189809812894, + "calibration_in_the_large": -0.0011705804727759842, + "expected_calibration_error_10bin": 0.001170580472775985, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + { + "valid": 2194, + "positives": 21, + "negatives": 2173, + "auroc": 0.7948633664234216, + "auprc": 0.14464398950071114, + "brier": 0.009202496407010327, + "calibration": { + "observed_rate": 0.009571558796718322, + "mean_prediction": 0.00868255130089917, + "calibration_in_the_large": -0.000889007495819152, + "expected_calibration_error_10bin": 0.0009665220297281719, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + { + "valid": 2194, + "positives": 24, + "negatives": 2170, + "auroc": 0.7639976958525345, + "auprc": 0.13466087591959905, + "brier": 0.010507747250060286, + "calibration": { + "observed_rate": 0.010938924339106655, + "mean_prediction": 0.009468789459847934, + "calibration_in_the_large": -0.001470134879258721, + "expected_calibration_error_10bin": 0.0014701348792587206, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + { + "valid": 2194, + "positives": 24, + "negatives": 2170, + "auroc": 0.7640360983102918, + "auprc": 0.13474926937620238, + "brier": 0.010507659815283638, + "calibration": { + "observed_rate": 0.010938924339106655, + "mean_prediction": 0.009484219990050188, + "calibration_in_the_large": -0.0014547043490564671, + "expected_calibration_error_10bin": 0.0014547043490564671, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + } + ], + "reason": null + }, + "E16": { + "time_averaged_auroc": 0.6791822174970815, + "time_averaged_auprc": 0.00711701910954236, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2816, + "positives": 1, + "negatives": 2815, + "auroc": 0.7904085257548845, + "auprc": 0.001692047377326565, + "brier": 0.00035586365100828324, + "calibration": { + "observed_rate": 0.0003551136363636364, + "mean_prediction": 0.0005583668758882125, + "calibration_in_the_large": 0.0002032532395245761, + "expected_calibration_error_10bin": 0.0002032532395245761, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 3, + "negatives": 2813, + "auroc": 0.665481692143619, + "auprc": 0.0022666803116541466, + "brier": 0.0010690762989067236, + "calibration": { + "observed_rate": 0.001065340909090909, + "mean_prediction": 0.0012029257794853006, + "calibration_in_the_large": 0.0001375848703943916, + "expected_calibration_error_10bin": 0.0001375848703943916, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 4, + "negatives": 2812, + "auroc": 0.6985241820768137, + "auprc": 0.0031198556247761305, + "brier": 0.0014245808423998091, + "calibration": { + "observed_rate": 0.0014204545454545455, + "mean_prediction": 0.0015276190730149478, + "calibration_in_the_large": 0.00010716452756040235, + "expected_calibration_error_10bin": 0.00010716452756040235, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 4, + "negatives": 2812, + "auroc": 0.6904338549075392, + "auprc": 0.0030973809921938087, + "brier": 0.001426719399623738, + "calibration": { + "observed_rate": 0.0014204545454545455, + "mean_prediction": 0.0018243282409687563, + "calibration_in_the_large": 0.0004038736955142108, + "expected_calibration_error_10bin": 0.0004038736955142108, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 5, + "negatives": 2811, + "auroc": 0.6258271077908217, + "auprc": 0.0030332161310819396, + "brier": 0.0017854192997023503, + "calibration": { + "observed_rate": 0.0017755681818181818, + "mean_prediction": 0.0021166625373738993, + "calibration_in_the_large": 0.0003410943555557176, + "expected_calibration_error_10bin": 0.0003410943555557176, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 5, + "negatives": 2811, + "auroc": 0.624404126645322, + "auprc": 0.0030308161374016295, + "brier": 0.0017878397073544912, + "calibration": { + "observed_rate": 0.0017755681818181818, + "mean_prediction": 0.0023107748992352776, + "calibration_in_the_large": 0.0005352067174170959, + "expected_calibration_error_10bin": 0.0005352067174170959, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 6, + "negatives": 2810, + "auroc": 0.6331553973902728, + "auprc": 0.0034507210289810293, + "brier": 0.0021427204321191463, + "calibration": { + "observed_rate": 0.002130681818181818, + "mean_prediction": 0.002448280424762185, + "calibration_in_the_large": 0.00031759860658036676, + "expected_calibration_error_10bin": 0.00031759860658036676, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 7, + "negatives": 2809, + "auroc": 0.6833138381732188, + "auprc": 0.0076116853926925035, + "brier": 0.002486586329540309, + "calibration": { + "observed_rate": 0.0024857954545454545, + "mean_prediction": 0.0025853494831616012, + "calibration_in_the_large": 9.955402861614674e-05, + "expected_calibration_error_10bin": 9.955402861614674e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 8, + "negatives": 2808, + "auroc": 0.6957353988603988, + "auprc": 0.007873609072984379, + "brier": 0.002839975741098533, + "calibration": { + "observed_rate": 0.002840909090909091, + "mean_prediction": 0.002730697207919196, + "calibration_in_the_large": -0.00011021188298989499, + "expected_calibration_error_10bin": 0.00011021188298989499, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 10, + "negatives": 2806, + "auroc": 0.7040270848182466, + "auprc": 0.014845672956652206, + "brier": 0.003532704731675722, + "calibration": { + "observed_rate": 0.0035511363636363635, + "mean_prediction": 0.0029305264798102307, + "calibration_in_the_large": -0.0006206098838261328, + "expected_calibration_error_10bin": 0.0006206098838261328, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 12, + "negatives": 2804, + "auroc": 0.6857762719923918, + "auprc": 0.014656186341608438, + "brier": 0.0042364519208726616, + "calibration": { + "observed_rate": 0.004261363636363636, + "mean_prediction": 0.003088621707625159, + "calibration_in_the_large": -0.001172741928738477, + "expected_calibration_error_10bin": 0.001172741928738477, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 13, + "negatives": 2803, + "auroc": 0.6661543950163287, + "auprc": 0.013922534165817112, + "brier": 0.004592355923152228, + "calibration": { + "observed_rate": 0.004616477272727273, + "mean_prediction": 0.0033011956502946305, + "calibration_in_the_large": -0.0013152816224326425, + "expected_calibration_error_10bin": 0.0013152816224326425, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 13, + "negatives": 2803, + "auroc": 0.6661269518922034, + "auprc": 0.013920842890880794, + "brier": 0.004592374358633789, + "calibration": { + "observed_rate": 0.004616477272727273, + "mean_prediction": 0.0033064718758272315, + "calibration_in_the_large": -0.0013100053969000414, + "expected_calibration_error_10bin": 0.0013100053969000414, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + } + ], + "reason": null + }, + "E21": { + "time_averaged_auroc": 0.9097931198853575, + "time_averaged_auprc": 0.016225215301605297, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2814, + "positives": 1, + "negatives": 2813, + "auroc": 0.9786704585851405, + "auprc": 0.01639344262295082, + "brier": 0.000354782801311867, + "calibration": { + "observed_rate": 0.00035536602700781805, + "mean_prediction": 0.000441302159830506, + "calibration_in_the_large": 8.593613282268796e-05, + "expected_calibration_error_10bin": 8.593613282268796e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 1, + "negatives": 2813, + "auroc": 0.9729825808745112, + "auprc": 0.012987012987012988, + "brier": 0.00035644358698635407, + "calibration": { + "observed_rate": 0.00035536602700781805, + "mean_prediction": 0.0006524489211051364, + "calibration_in_the_large": 0.00029708289409731837, + "expected_calibration_error_10bin": 0.00029708289409731837, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 1, + "negatives": 2813, + "auroc": 0.9704941343761109, + "auprc": 0.011904761904761904, + "brier": 0.0003587744386924874, + "calibration": { + "observed_rate": 0.00035536602700781805, + "mean_prediction": 0.0008480758540723011, + "calibration_in_the_large": 0.000492709827064483, + "expected_calibration_error_10bin": 0.000492709827064483, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 1, + "negatives": 2813, + "auroc": 0.9832918592250267, + "auprc": 0.020833333333333332, + "brier": 0.00036031687576104133, + "calibration": { + "observed_rate": 0.00035536602700781805, + "mean_prediction": 0.0010424987693503937, + "calibration_in_the_large": 0.0006871327423425757, + "expected_calibration_error_10bin": 0.0006871327423425757, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 1, + "negatives": 2813, + "auroc": 0.9808034127266264, + "auprc": 0.01818181818181818, + "brier": 0.000363201719838301, + "calibration": { + "observed_rate": 0.00035536602700781805, + "mean_prediction": 0.0011819252308659395, + "calibration_in_the_large": 0.0008265592038581215, + "expected_calibration_error_10bin": 0.0008265592038581215, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 1, + "negatives": 2813, + "auroc": 0.9811589050835408, + "auprc": 0.018518518518518517, + "brier": 0.0003692901830526412, + "calibration": { + "observed_rate": 0.00035536602700781805, + "mean_prediction": 0.0013991962200760638, + "calibration_in_the_large": 0.0010438301930682458, + "expected_calibration_error_10bin": 0.0010438301930682458, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 2, + "negatives": 2812, + "auroc": 0.9139402560455192, + "auprc": 0.011248757043420616, + "brier": 0.0007257260696557346, + "calibration": { + "observed_rate": 0.0007107320540156361, + "mean_prediction": 0.0015185619292845047, + "calibration_in_the_large": 0.0008078298752688686, + "expected_calibration_error_10bin": 0.0008078298752688686, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 2, + "negatives": 2812, + "auroc": 0.9160739687055477, + "auprc": 0.0107429718875502, + "brier": 0.0007300006156526901, + "calibration": { + "observed_rate": 0.0007107320540156361, + "mean_prediction": 0.0016448928586360048, + "calibration_in_the_large": 0.0009341608046203687, + "expected_calibration_error_10bin": 0.0009341608046203687, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 3, + "negatives": 2811, + "auroc": 0.9426064271315072, + "auprc": 0.02239881459830309, + "brier": 0.0010743243389627892, + "calibration": { + "observed_rate": 0.0010660980810234541, + "mean_prediction": 0.0017693632299211179, + "calibration_in_the_large": 0.0007032651488976637, + "expected_calibration_error_10bin": 0.0007032651488976637, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 3, + "negatives": 2811, + "auroc": 0.9421321000830072, + "auprc": 0.021911289768432624, + "brier": 0.0010771533043189559, + "calibration": { + "observed_rate": 0.0010660980810234541, + "mean_prediction": 0.0019209125837431928, + "calibration_in_the_large": 0.0008548145027197386, + "expected_calibration_error_10bin": 0.0008548145027197387, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 4, + "negatives": 2810, + "auroc": 0.7555160142348755, + "auprc": 0.016810429003284177, + "brier": 0.0014350458409541366, + "calibration": { + "observed_rate": 0.0014214641080312722, + "mean_prediction": 0.002032058129754224, + "calibration_in_the_large": 0.0006105940217229519, + "expected_calibration_error_10bin": 0.0006105940217229516, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 5, + "negatives": 2809, + "auroc": 0.7449626201495194, + "auprc": 0.014494245408754181, + "brier": 0.0017920417936068472, + "calibration": { + "observed_rate": 0.0017768301350390902, + "mean_prediction": 0.002126032032808662, + "calibration_in_the_large": 0.00034920189776957173, + "expected_calibration_error_10bin": 0.00034920189776957195, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 5, + "negatives": 2809, + "auroc": 0.7446778212887148, + "auprc": 0.014502403662728234, + "brier": 0.001792237912637659, + "calibration": { + "observed_rate": 0.0017768301350390902, + "mean_prediction": 0.002144912776303385, + "calibration_in_the_large": 0.00036808264126429475, + "expected_calibration_error_10bin": 0.00036808264126429475, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + } + ], + "reason": null + }, + "E22": { + "time_averaged_auroc": 0.8259030060755811, + "time_averaged_auprc": 0.01217144424214837, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2802, + "positives": 3, + "negatives": 2799, + "auroc": 0.834702870072645, + "auprc": 0.004710651087333477, + "brier": 0.0010762156512438897, + "calibration": { + "observed_rate": 0.0010706638115631692, + "mean_prediction": 0.0015715481970286396, + "calibration_in_the_large": 0.0005008843854654704, + "expected_calibration_error_10bin": 0.0005008843854654704, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 3, + "negatives": 2799, + "auroc": 0.8513754912468738, + "auprc": 0.005398984763719929, + "brier": 0.001097014482228127, + "calibration": { + "observed_rate": 0.0010706638115631692, + "mean_prediction": 0.002643877428817827, + "calibration_in_the_large": 0.0015732136172546577, + "expected_calibration_error_10bin": 0.0015732136172546577, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8132594710507506, + "auprc": 0.005786226842285457, + "brier": 0.0014688621883062584, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.0032973859610336527, + "calibration_in_the_large": 0.0018698342122827605, + "expected_calibration_error_10bin": 0.0018698342122827605, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8177269478198713, + "auprc": 0.005881969104643357, + "brier": 0.0014838153882638517, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.0038799363583860887, + "calibration_in_the_large": 0.0024523846096351967, + "expected_calibration_error_10bin": 0.0024523846096351967, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8243388134381702, + "auprc": 0.0062101587080295294, + "brier": 0.0015023431116899706, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.0043706135527724855, + "calibration_in_the_large": 0.0029430618040215935, + "expected_calibration_error_10bin": 0.0029430618040215935, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 6, + "negatives": 2796, + "auroc": 0.8491297091082499, + "auprc": 0.011900414652370043, + "brier": 0.00219279234206114, + "calibration": { + "observed_rate": 0.0021413276231263384, + "mean_prediction": 0.004715528055673455, + "calibration_in_the_large": 0.002574200432547116, + "expected_calibration_error_10bin": 0.002574200432547116, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 7, + "negatives": 2795, + "auroc": 0.8125223613595707, + "auprc": 0.01138511128370947, + "brier": 0.0025587361019576167, + "calibration": { + "observed_rate": 0.0024982155603140615, + "mean_prediction": 0.004990278493638473, + "calibration_in_the_large": 0.0024920629333244114, + "expected_calibration_error_10bin": 0.0024920629333244114, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.8187930142817361, + "auprc": 0.018210086590356032, + "brier": 0.0032439172765495444, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.005409274334973339, + "calibration_in_the_large": 0.002197282900283832, + "expected_calibration_error_10bin": 0.0021972829002838315, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.8213390619405657, + "auprc": 0.017966985831840553, + "brier": 0.0032557172265707413, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.005747002785096762, + "calibration_in_the_large": 0.0025350113504072546, + "expected_calibration_error_10bin": 0.0025350113504072546, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.8225325217806421, + "auprc": 0.017650262587823436, + "brier": 0.0032766113060274504, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.006058906827100659, + "calibration_in_the_large": 0.0028469153924111515, + "expected_calibration_error_10bin": 0.0028469153924111515, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.8235668536420416, + "auprc": 0.017649648969642558, + "brier": 0.003287005961298312, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.006346147380803571, + "calibration_in_the_large": 0.0031341559461140634, + "expected_calibration_error_10bin": 0.0031341559461140625, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.8233281616740263, + "auprc": 0.017742846101709196, + "brier": 0.003302278182343536, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.006606462744858721, + "calibration_in_the_large": 0.0033944713101692137, + "expected_calibration_error_10bin": 0.0033944713101692137, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.8241238015674106, + "auprc": 0.01773542862446578, + "brier": 0.0033054661471720987, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.0067011243349890896, + "calibration_in_the_large": 0.003489132900299582, + "expected_calibration_error_10bin": 0.0034891329002995812, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + } + ], + "reason": null + }, + "E27": { + "time_averaged_auroc": 0.7986836583015179, + "time_averaged_auprc": 0.0079287813143229, + "valid_timepoint_cells": 10, + "timepoints": [ + { + "valid": 2811, + "positives": 0, + "negatives": 2811, + "auroc": null, + "auprc": null, + "brier": 1.7228816111291856e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0006511066311737025, + "calibration_in_the_large": 0.0006511066311737025, + "expected_calibration_error_10bin": 0.0006511066311737025, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9887442842068238 + }, + { + "valid": 2811, + "positives": 0, + "negatives": 2811, + "auroc": null, + "auprc": null, + "brier": 5.519984459682209e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0010473434329777472, + "calibration_in_the_large": 0.0010473434329777472, + "expected_calibration_error_10bin": 0.0010473434329777472, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9887442842068238 + }, + { + "valid": 2811, + "positives": 0, + "negatives": 2811, + "auroc": null, + "auprc": null, + "brier": 8.988482086415122e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0013219003751498396, + "calibration_in_the_large": 0.0013219003751498396, + "expected_calibration_error_10bin": 0.0013219003751498396, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9887442842068238 + }, + { + "valid": 2811, + "positives": 4, + "negatives": 2807, + "auroc": 0.7250623441396509, + "auprc": 0.0034237944934689046, + "brier": 0.001429665917376868, + "calibration": { + "observed_rate": 0.001422981145499822, + "mean_prediction": 0.0015061655334792396, + "calibration_in_the_large": 8.318438797941751e-05, + "expected_calibration_error_10bin": 8.318438797941751e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + }, + { + "valid": 2811, + "positives": 5, + "negatives": 2806, + "auroc": 0.7715609408410549, + "auprc": 0.005565091631796452, + "brier": 0.0017829590468811463, + "calibration": { + "observed_rate": 0.0017787264318747777, + "mean_prediction": 0.0016831482702781028, + "calibration_in_the_large": -9.557816159667487e-05, + "expected_calibration_error_10bin": 9.557816159667487e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + }, + { + "valid": 2811, + "positives": 5, + "negatives": 2806, + "auroc": 0.7812544547398432, + "auprc": 0.005653244005247849, + "brier": 0.0017855600794792323, + "calibration": { + "observed_rate": 0.0017787264318747777, + "mean_prediction": 0.0018853845173827841, + "calibration_in_the_large": 0.00010665808550800642, + "expected_calibration_error_10bin": 0.00010665808550800642, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + }, + { + "valid": 2811, + "positives": 6, + "negatives": 2805, + "auroc": 0.7944741532976827, + "auprc": 0.006601819344947034, + "brier": 0.0021423038380747393, + "calibration": { + "observed_rate": 0.0021344717182497333, + "mean_prediction": 0.0020803369066483405, + "calibration_in_the_large": -5.4134811601392815e-05, + "expected_calibration_error_10bin": 5.4134811601392815e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + }, + { + "valid": 2811, + "positives": 6, + "negatives": 2805, + "auroc": 0.7929887106357695, + "auprc": 0.006557955548116318, + "brier": 0.002146183964056934, + "calibration": { + "observed_rate": 0.0021344717182497333, + "mean_prediction": 0.0022338608694460658, + "calibration_in_the_large": 9.938915119633244e-05, + "expected_calibration_error_10bin": 9.938915119633244e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + }, + { + "valid": 2811, + "positives": 7, + "negatives": 2804, + "auroc": 0.8155186468310577, + "auprc": 0.008637453660872662, + "brier": 0.002501039097724582, + "calibration": { + "observed_rate": 0.0024902170046246885, + "mean_prediction": 0.0024638778244443025, + "calibration_in_the_large": -2.6339180180386026e-05, + "expected_calibration_error_10bin": 2.6339180180386026e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + }, + { + "valid": 2811, + "positives": 8, + "negatives": 2803, + "auroc": 0.832991437745273, + "auprc": 0.010827994635731836, + "brier": 0.002857650320385664, + "calibration": { + "observed_rate": 0.002845962290999644, + "mean_prediction": 0.0026577847302770366, + "calibration_in_the_large": -0.00018817756072260754, + "expected_calibration_error_10bin": 0.00018817756072260754, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + }, + { + "valid": 2811, + "positives": 8, + "negatives": 2803, + "auroc": 0.832411701748127, + "auprc": 0.010742409568906968, + "brier": 0.0028635683890609175, + "calibration": { + "observed_rate": 0.002845962290999644, + "mean_prediction": 0.0028692728231067307, + "calibration_in_the_large": 2.3310532107086602e-05, + "expected_calibration_error_10bin": 2.3310532107086602e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + }, + { + "valid": 2811, + "positives": 9, + "negatives": 2802, + "auroc": 0.8202474423031169, + "auprc": 0.010640046579857973, + "brier": 0.0032279341607800304, + "calibration": { + "observed_rate": 0.0032017075773745998, + "mean_prediction": 0.0031317852687964103, + "calibration_in_the_large": -6.992230857818952e-05, + "expected_calibration_error_10bin": 0.00014476836567954768, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + }, + { + "valid": 2811, + "positives": 9, + "negatives": 2802, + "auroc": 0.820326750733603, + "auprc": 0.01063800367428301, + "brier": 0.0032281758644304524, + "calibration": { + "observed_rate": 0.0032017075773745998, + "mean_prediction": 0.0031397467430352307, + "calibration_in_the_large": -6.196083433936909e-05, + "expected_calibration_error_10bin": 0.00013699456867690885, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + } + ], + "reason": null + }, + "E43": { + "time_averaged_auroc": 0.8284181711995051, + "time_averaged_auprc": 0.07113609690699876, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2748, + "positives": 14, + "negatives": 2734, + "auroc": 0.8604347371721183, + "auprc": 0.04382073656929226, + "brier": 0.005001817429788346, + "calibration": { + "observed_rate": 0.005094614264919942, + "mean_prediction": 0.002650999514367058, + "calibration_in_the_large": -0.002443614750552884, + "expected_calibration_error_10bin": 0.002443614750552884, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + { + "valid": 2748, + "positives": 19, + "negatives": 2729, + "auroc": 0.8602341324178897, + "auprc": 0.05961218678680008, + "brier": 0.006712470838939421, + "calibration": { + "observed_rate": 0.006914119359534207, + "mean_prediction": 0.006062887500278656, + "calibration_in_the_large": -0.0008512318592555513, + "expected_calibration_error_10bin": 0.0010089041583900562, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + { + "valid": 2748, + "positives": 25, + "negatives": 2723, + "auroc": 0.8066838046272493, + "auprc": 0.06565976789027038, + "brier": 0.008819533146898017, + "calibration": { + "observed_rate": 0.009097525473071324, + "mean_prediction": 0.007761421241177557, + "calibration_in_the_large": -0.0013361042318937666, + "expected_calibration_error_10bin": 0.0016910887061279526, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + { + "valid": 2748, + "positives": 29, + "negatives": 2719, + "auroc": 0.8280934927901993, + "auprc": 0.0728582187037735, + "brier": 0.010178100518447189, + "calibration": { + "observed_rate": 0.010553129548762736, + "mean_prediction": 0.009654361670458075, + "calibration_in_the_large": -0.0008987678783046616, + "expected_calibration_error_10bin": 0.0016354791024417495, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + { + "valid": 2748, + "positives": 32, + "negatives": 2716, + "auroc": 0.8331300625920471, + "auprc": 0.07582502163421574, + "brier": 0.01121434776045596, + "calibration": { + "observed_rate": 0.011644832605531296, + "mean_prediction": 0.011096994163047555, + "calibration_in_the_large": -0.0005478384424837408, + "expected_calibration_error_10bin": 0.0016209177102309326, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + { + "valid": 2748, + "positives": 32, + "negatives": 2716, + "auroc": 0.8334177098674521, + "auprc": 0.07526547495090878, + "brier": 0.011243739521222394, + "calibration": { + "observed_rate": 0.011644832605531296, + "mean_prediction": 0.012162243176558871, + "calibration_in_the_large": 0.0005174105710275753, + "expected_calibration_error_10bin": 0.001264678488675813, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + { + "valid": 2748, + "positives": 33, + "negatives": 2715, + "auroc": 0.8222222222222222, + "auprc": 0.07322207829561461, + "brier": 0.011623620546017354, + "calibration": { + "observed_rate": 0.012008733624454149, + "mean_prediction": 0.012806490572073512, + "calibration_in_the_large": 0.0007977569476193633, + "expected_calibration_error_10bin": 0.001734827176030261, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + { + "valid": 2748, + "positives": 34, + "negatives": 2714, + "auroc": 0.8208526594130652, + "auprc": 0.07156333826529356, + "brier": 0.01202183691966258, + "calibration": { + "observed_rate": 0.012372634643377001, + "mean_prediction": 0.013609187422145116, + "calibration_in_the_large": 0.0012365527787681144, + "expected_calibration_error_10bin": 0.0014774441382412384, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + { + "valid": 2748, + "positives": 36, + "negatives": 2712, + "auroc": 0.8163409537856441, + "auprc": 0.07293536797058767, + "brier": 0.012748013750575793, + "calibration": { + "observed_rate": 0.013100436681222707, + "mean_prediction": 0.014519421344626275, + "calibration_in_the_large": 0.001418984663403568, + "expected_calibration_error_10bin": 0.0022250619773222418, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + { + "valid": 2748, + "positives": 37, + "negatives": 2711, + "auroc": 0.8205010617404568, + "auprc": 0.07467809812494786, + "brier": 0.013117475904486548, + "calibration": { + "observed_rate": 0.013464337700145561, + "mean_prediction": 0.015355191126194585, + "calibration_in_the_large": 0.0018908534260490238, + "expected_calibration_error_10bin": 0.0018908534260490238, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + { + "valid": 2748, + "positives": 39, + "negatives": 2709, + "auroc": 0.823588986379684, + "auprc": 0.07681152875947808, + "brier": 0.01381575596666898, + "calibration": { + "observed_rate": 0.014192139737991267, + "mean_prediction": 0.016010129134060313, + "calibration_in_the_large": 0.0018179893960690464, + "expected_calibration_error_10bin": 0.002586560878491152, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + { + "valid": 2748, + "positives": 42, + "negatives": 2706, + "auroc": 0.8236810614859396, + "auprc": 0.08161940301509565, + "brier": 0.014797541269436925, + "calibration": { + "observed_rate": 0.015283842794759825, + "mean_prediction": 0.01670967592160091, + "calibration_in_the_large": 0.0014258331268410859, + "expected_calibration_error_10bin": 0.002963449129480356, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + { + "valid": 2748, + "positives": 43, + "negatives": 2705, + "auroc": 0.8202553410996002, + "auprc": 0.08089803882470598, + "brier": 0.015156667708778153, + "calibration": { + "observed_rate": 0.01564774381368268, + "mean_prediction": 0.016783158215202286, + "calibration_in_the_large": 0.001135414401519607, + "expected_calibration_error_10bin": 0.0033609976167211907, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + } + ], + "reason": null + }, + "E44": { + "time_averaged_auroc": 0.763422543253988, + "time_averaged_auprc": 0.020833780932871318, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2800, + "positives": 5, + "negatives": 2795, + "auroc": 0.7128443649373882, + "auprc": 0.011685079989700609, + "brier": 0.0017833739369731523, + "calibration": { + "observed_rate": 0.0017857142857142857, + "mean_prediction": 0.00226576967780602, + "calibration_in_the_large": 0.00048005539209173436, + "expected_calibration_error_10bin": 0.00048005539209173436, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 8, + "negatives": 2792, + "auroc": 0.7776235673352435, + "auprc": 0.01811978563657555, + "brier": 0.002851862069348053, + "calibration": { + "observed_rate": 0.002857142857142857, + "mean_prediction": 0.004224369546487391, + "calibration_in_the_large": 0.0013672266893445342, + "expected_calibration_error_10bin": 0.0013672266893445342, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 11, + "negatives": 2789, + "auroc": 0.7535773656246945, + "auprc": 0.018656591111139768, + "brier": 0.003931026341575784, + "calibration": { + "observed_rate": 0.003928571428571429, + "mean_prediction": 0.005219285058345641, + "calibration_in_the_large": 0.0012907136297742126, + "expected_calibration_error_10bin": 0.0012907136297742126, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 12, + "negatives": 2788, + "auroc": 0.74925274988044, + "auprc": 0.017561269160776268, + "brier": 0.0043112193926992635, + "calibration": { + "observed_rate": 0.004285714285714286, + "mean_prediction": 0.006107852925997577, + "calibration_in_the_large": 0.0018221386402832909, + "expected_calibration_error_10bin": 0.0018221386402832913, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 15, + "negatives": 2785, + "auroc": 0.7673249551166966, + "auprc": 0.01899919176480263, + "brier": 0.005386904075590773, + "calibration": { + "observed_rate": 0.005357142857142857, + "mean_prediction": 0.006910364539346899, + "calibration_in_the_large": 0.001553221682204042, + "expected_calibration_error_10bin": 0.0015532216822040411, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 15, + "negatives": 2785, + "auroc": 0.7679712746858168, + "auprc": 0.01882735732930482, + "brier": 0.005424499828094548, + "calibration": { + "observed_rate": 0.005357142857142857, + "mean_prediction": 0.00771549717916579, + "calibration_in_the_large": 0.0023583543220229326, + "expected_calibration_error_10bin": 0.002358354322022933, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 17, + "negatives": 2783, + "auroc": 0.7790788611527975, + "auprc": 0.022481604931619034, + "brier": 0.0061105613822227, + "calibration": { + "observed_rate": 0.006071428571428571, + "mean_prediction": 0.008355092843407224, + "calibration_in_the_large": 0.0022836642719786526, + "expected_calibration_error_10bin": 0.0022836642719786535, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 19, + "negatives": 2781, + "auroc": 0.790173924563296, + "auprc": 0.024139358681949635, + "brier": 0.006821435864817865, + "calibration": { + "observed_rate": 0.0067857142857142855, + "mean_prediction": 0.008855501115826232, + "calibration_in_the_large": 0.0020697868301119467, + "expected_calibration_error_10bin": 0.002069786830111947, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 19, + "negatives": 2781, + "auroc": 0.7899657449989591, + "auprc": 0.024348116874906737, + "brier": 0.006853117478994971, + "calibration": { + "observed_rate": 0.0067857142857142855, + "mean_prediction": 0.009362609162729183, + "calibration_in_the_large": 0.002576894877014898, + "expected_calibration_error_10bin": 0.002576894877014898, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 21, + "negatives": 2779, + "auroc": 0.7784574787093679, + "auprc": 0.02396795285690865, + "brier": 0.00758298462843279, + "calibration": { + "observed_rate": 0.0075, + "mean_prediction": 0.009791168485800361, + "calibration_in_the_large": 0.0022911684858003614, + "expected_calibration_error_10bin": 0.002291168485800361, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 23, + "negatives": 2777, + "auroc": 0.7478511374489205, + "auprc": 0.023021112539108327, + "brier": 0.008312654783974385, + "calibration": { + "observed_rate": 0.008214285714285714, + "mean_prediction": 0.010163447005054747, + "calibration_in_the_large": 0.0019491612907690335, + "expected_calibration_error_10bin": 0.0019491612907690332, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 24, + "negatives": 2776, + "auroc": 0.7552083333333334, + "auprc": 0.02457687184534345, + "brier": 0.008664295768724847, + "calibration": { + "observed_rate": 0.008571428571428572, + "mean_prediction": 0.010528540708260802, + "calibration_in_the_large": 0.00195711213683223, + "expected_calibration_error_10bin": 0.00195711213683223, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 24, + "negatives": 2776, + "auroc": 0.7551633045148896, + "auprc": 0.02445485940519163, + "brier": 0.008667290904579532, + "calibration": { + "observed_rate": 0.008571428571428572, + "mean_prediction": 0.010592874129813155, + "calibration_in_the_large": 0.0020214455583845835, + "expected_calibration_error_10bin": 0.0020214455583845853, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + } + ], + "reason": null + }, + "E46": { + "time_averaged_auroc": 0.8092853075232521, + "time_averaged_auprc": 0.0693919286531496, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2772, + "positives": 10, + "negatives": 2762, + "auroc": 0.7712889210716872, + "auprc": 0.018472652040638995, + "brier": 0.003611060565307189, + "calibration": { + "observed_rate": 0.0036075036075036075, + "mean_prediction": 0.0035804447792911346, + "calibration_in_the_large": -2.705882821247294e-05, + "expected_calibration_error_10bin": 0.00035088865390586787, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + { + "valid": 2772, + "positives": 16, + "negatives": 2756, + "auroc": 0.8190312046444121, + "auprc": 0.061224530814539116, + "brier": 0.005633615689558362, + "calibration": { + "observed_rate": 0.005772005772005772, + "mean_prediction": 0.006710335259308778, + "calibration_in_the_large": 0.000938329487303006, + "expected_calibration_error_10bin": 0.0010715681018546109, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + { + "valid": 2772, + "positives": 23, + "negatives": 2749, + "auroc": 0.8179100700650038, + "auprc": 0.05979506658432233, + "brier": 0.008079411349253267, + "calibration": { + "observed_rate": 0.008297258297258298, + "mean_prediction": 0.008499669854895078, + "calibration_in_the_large": 0.00020241155763678007, + "expected_calibration_error_10bin": 0.0004135129907693239, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + { + "valid": 2772, + "positives": 27, + "negatives": 2745, + "auroc": 0.815408486811037, + "auprc": 0.07175490874324718, + "brier": 0.009394196913671545, + "calibration": { + "observed_rate": 0.00974025974025974, + "mean_prediction": 0.009492539104521422, + "calibration_in_the_large": -0.0002477206357383178, + "expected_calibration_error_10bin": 0.0008871700240666667, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + { + "valid": 2772, + "positives": 28, + "negatives": 2744, + "auroc": 0.8196454602249063, + "auprc": 0.0763286340597834, + "brier": 0.009743273163555664, + "calibration": { + "observed_rate": 0.010101010101010102, + "mean_prediction": 0.010564319327957225, + "calibration_in_the_large": 0.00046330922694712284, + "expected_calibration_error_10bin": 0.001084661560947282, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + { + "valid": 2772, + "positives": 30, + "negatives": 2742, + "auroc": 0.8199367858011184, + "auprc": 0.07533912027068576, + "brier": 0.010454537804116032, + "calibration": { + "observed_rate": 0.010822510822510822, + "mean_prediction": 0.01108059980471301, + "calibration_in_the_large": 0.0002580889822021877, + "expected_calibration_error_10bin": 0.0005275520459632854, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + { + "valid": 2772, + "positives": 33, + "negatives": 2739, + "auroc": 0.8181154369544293, + "auprc": 0.07924851361489613, + "brier": 0.011456572525066468, + "calibration": { + "observed_rate": 0.011904761904761904, + "mean_prediction": 0.012035177358801963, + "calibration_in_the_large": 0.00013041545404005907, + "expected_calibration_error_10bin": 0.0012444856825825719, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + { + "valid": 2772, + "positives": 33, + "negatives": 2739, + "auroc": 0.816832066558244, + "auprc": 0.07831212013405782, + "brier": 0.011495305335927936, + "calibration": { + "observed_rate": 0.011904761904761904, + "mean_prediction": 0.013042954502216398, + "calibration_in_the_large": 0.0011381925974544935, + "expected_calibration_error_10bin": 0.0011381925974544929, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + { + "valid": 2772, + "positives": 35, + "negatives": 2737, + "auroc": 0.8230700976042591, + "auprc": 0.0815468374941293, + "brier": 0.012164244877204114, + "calibration": { + "observed_rate": 0.012626262626262626, + "mean_prediction": 0.0137483059388457, + "calibration_in_the_large": 0.0011220433125830737, + "expected_calibration_error_10bin": 0.001266101978215881, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + { + "valid": 2772, + "positives": 37, + "negatives": 2735, + "auroc": 0.8162853895943476, + "auprc": 0.07722667776756309, + "brier": 0.012928868598760794, + "calibration": { + "observed_rate": 0.013347763347763348, + "mean_prediction": 0.01451064172281818, + "calibration_in_the_large": 0.0011628783750548318, + "expected_calibration_error_10bin": 0.0019267891311493613, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + { + "valid": 2772, + "positives": 39, + "negatives": 2733, + "auroc": 0.8027995909444867, + "auprc": 0.07437537324449496, + "brier": 0.013676032241524074, + "calibration": { + "observed_rate": 0.01406926406926407, + "mean_prediction": 0.015181392044677973, + "calibration_in_the_large": 0.0011121279754139034, + "expected_calibration_error_10bin": 0.0025688002545277027, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + { + "valid": 2772, + "positives": 42, + "negatives": 2730, + "auroc": 0.7902494331065759, + "auprc": 0.07428960157322129, + "brier": 0.014743096807981313, + "calibration": { + "observed_rate": 0.015151515151515152, + "mean_prediction": 0.016010467536903224, + "calibration_in_the_large": 0.0008589523853880718, + "expected_calibration_error_10bin": 0.004107806483522981, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + { + "valid": 2772, + "positives": 42, + "negatives": 2730, + "auroc": 0.7901360544217687, + "auprc": 0.07418103614936548, + "brier": 0.014747222708386071, + "calibration": { + "observed_rate": 0.015151515151515152, + "mean_prediction": 0.016069583953074333, + "calibration_in_the_large": 0.0009180688015591812, + "expected_calibration_error_10bin": 0.004080124572196621, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + } + ], + "reason": null + }, + "E53": { + "time_averaged_auroc": 0.7182180809059149, + "time_averaged_auprc": 0.004763459338514572, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2804, + "positives": 1, + "negatives": 2803, + "auroc": 0.8965394220478059, + "auprc": 0.003436426116838488, + "brier": 0.0003577204554555446, + "calibration": { + "observed_rate": 0.0003566333808844508, + "mean_prediction": 0.000617346578059782, + "calibration_in_the_large": 0.00026071319717533117, + "expected_calibration_error_10bin": 0.00026071319717533117, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 2, + "negatives": 2802, + "auroc": 0.8734832262669522, + "auprc": 0.004189809330771188, + "brier": 0.0007159109881170214, + "calibration": { + "observed_rate": 0.0007132667617689016, + "mean_prediction": 0.0010479716124399123, + "calibration_in_the_large": 0.00033470485067101075, + "expected_calibration_error_10bin": 0.00033470485067101075, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 3, + "negatives": 2801, + "auroc": 0.7318814709032488, + "auprc": 0.003960097174943993, + "brier": 0.0010762872178110901, + "calibration": { + "observed_rate": 0.0010699001426533524, + "mean_prediction": 0.0015346988090158746, + "calibration_in_the_large": 0.0004647986663625222, + "expected_calibration_error_10bin": 0.0004647986663625222, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 4, + "negatives": 2800, + "auroc": 0.7470535714285714, + "auprc": 0.004449873617421847, + "brier": 0.0014345847169078365, + "calibration": { + "observed_rate": 0.0014265335235378032, + "mean_prediction": 0.0017889361353975433, + "calibration_in_the_large": 0.0003624026118597401, + "expected_calibration_error_10bin": 0.0003624026118597401, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 4, + "negatives": 2800, + "auroc": 0.7458928571428571, + "auprc": 0.004426291201221916, + "brier": 0.0014365286484885416, + "calibration": { + "observed_rate": 0.0014265335235378032, + "mean_prediction": 0.0019748320522092805, + "calibration_in_the_large": 0.0005482985286714773, + "expected_calibration_error_10bin": 0.0005482985286714773, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 4, + "negatives": 2800, + "auroc": 0.7416071428571429, + "auprc": 0.0043742920507181425, + "brier": 0.0014402850392695537, + "calibration": { + "observed_rate": 0.0014265335235378032, + "mean_prediction": 0.0022241811638923797, + "calibration_in_the_large": 0.0007976476403545765, + "expected_calibration_error_10bin": 0.0007976476403545765, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 6, + "negatives": 2798, + "auroc": 0.6386704789135097, + "auprc": 0.004095556040109908, + "brier": 0.002158328100757741, + "calibration": { + "observed_rate": 0.0021398002853067048, + "mean_prediction": 0.0025031956387317564, + "calibration_in_the_large": 0.0003633953534250517, + "expected_calibration_error_10bin": 0.0003633953534250517, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 6, + "negatives": 2798, + "auroc": 0.6374195854181558, + "auprc": 0.004070958237801782, + "brier": 0.00216115379241538, + "calibration": { + "observed_rate": 0.0021398002853067048, + "mean_prediction": 0.002668647942390117, + "calibration_in_the_large": 0.0005288476570834122, + "expected_calibration_error_10bin": 0.0005288476570834122, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 7, + "negatives": 2797, + "auroc": 0.6379794677971296, + "auprc": 0.004339141242057012, + "brier": 0.002520536337384871, + "calibration": { + "observed_rate": 0.0024964336661911554, + "mean_prediction": 0.0028844796182415987, + "calibration_in_the_large": 0.0003880459520504433, + "expected_calibration_error_10bin": 0.0003880459520504433, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 7, + "negatives": 2797, + "auroc": 0.6361407630624649, + "auprc": 0.004314923942502051, + "brier": 0.0025243193980988934, + "calibration": { + "observed_rate": 0.0024964336661911554, + "mean_prediction": 0.003049777263897104, + "calibration_in_the_large": 0.0005533435977059485, + "expected_calibration_error_10bin": 0.0005533435977059485, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 9, + "negatives": 2795, + "auroc": 0.6891671635857682, + "auprc": 0.0063957452816916895, + "brier": 0.0032411679233607933, + "calibration": { + "observed_rate": 0.003209700427960057, + "mean_prediction": 0.0034242718018584533, + "calibration_in_the_large": 0.0002145713738983964, + "expected_calibration_error_10bin": 0.0002145713738983964, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 11, + "negatives": 2793, + "auroc": 0.6805325000813722, + "auprc": 0.006935394366599222, + "brier": 0.003956127544964669, + "calibration": { + "observed_rate": 0.0039229671897289585, + "mean_prediction": 0.0036462895823296875, + "calibration_in_the_large": -0.000276677607399271, + "expected_calibration_error_10bin": 0.0003486495410556158, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 11, + "negatives": 2793, + "auroc": 0.6804674022719136, + "auprc": 0.006936462798012199, + "brier": 0.0039563885392666295, + "calibration": { + "observed_rate": 0.0039229671897289585, + "mean_prediction": 0.0036558126229466713, + "calibration_in_the_large": -0.00026715456678228725, + "expected_calibration_error_10bin": 0.0003393002126915219, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + } + ], + "reason": null + }, + "E55": { + "time_averaged_auroc": 0.5784687362120308, + "time_averaged_auprc": 0.011954289108078846, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2737, + "positives": 9, + "negatives": 2728, + "auroc": 0.4906321277289019, + "auprc": 0.004237323538564416, + "brier": 0.003290274412954896, + "calibration": { + "observed_rate": 0.003288271830471319, + "mean_prediction": 0.002197186647103909, + "calibration_in_the_large": -0.0010910851833674101, + "expected_calibration_error_10bin": 0.0010910851833674101, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + { + "valid": 2737, + "positives": 11, + "negatives": 2726, + "auroc": 0.5051023811111852, + "auprc": 0.005331974251045097, + "brier": 0.004038217183637117, + "calibration": { + "observed_rate": 0.00401899890390939, + "mean_prediction": 0.004384270758639186, + "calibration_in_the_large": 0.00036527185472979597, + "expected_calibration_error_10bin": 0.0003652718547297963, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + { + "valid": 2737, + "positives": 11, + "negatives": 2726, + "auroc": 0.5054692189688521, + "auprc": 0.005318941129121924, + "brier": 0.004063395181571917, + "calibration": { + "observed_rate": 0.00401899890390939, + "mean_prediction": 0.005813236261359754, + "calibration_in_the_large": 0.0017942373574503642, + "expected_calibration_error_10bin": 0.0017942373574503655, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + { + "valid": 2737, + "positives": 14, + "negatives": 2723, + "auroc": 0.5496301348302818, + "auprc": 0.006859008535724606, + "brier": 0.00517002682796103, + "calibration": { + "observed_rate": 0.005115089514066497, + "mean_prediction": 0.00661063312930698, + "calibration_in_the_large": 0.0014955436152404838, + "expected_calibration_error_10bin": 0.0014955436152404844, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + { + "valid": 2737, + "positives": 19, + "negatives": 2718, + "auroc": 0.5736028813756245, + "auprc": 0.010090948886197996, + "brier": 0.006985985135893551, + "calibration": { + "observed_rate": 0.006941907197661673, + "mean_prediction": 0.0076994266771492955, + "calibration_in_the_large": 0.0007575194794876223, + "expected_calibration_error_10bin": 0.0007575194794876217, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + { + "valid": 2737, + "positives": 21, + "negatives": 2716, + "auroc": 0.5843502349393366, + "auprc": 0.011098687065932972, + "brier": 0.007733672082418567, + "calibration": { + "observed_rate": 0.0076726342710997444, + "mean_prediction": 0.0084528515172716, + "calibration_in_the_large": 0.0007802172461718552, + "expected_calibration_error_10bin": 0.0007802172461718571, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + { + "valid": 2737, + "positives": 25, + "negatives": 2712, + "auroc": 0.5949262536873157, + "auprc": 0.01318937204349199, + "brier": 0.00920678389364504, + "calibration": { + "observed_rate": 0.009134088417975887, + "mean_prediction": 0.009672490697763084, + "calibration_in_the_large": 0.0005384022797871972, + "expected_calibration_error_10bin": 0.0005384022797871981, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + { + "valid": 2737, + "positives": 25, + "negatives": 2712, + "auroc": 0.5960324483775811, + "auprc": 0.01321778195475651, + "brier": 0.009232652144228441, + "calibration": { + "observed_rate": 0.009134088417975887, + "mean_prediction": 0.010465952659033955, + "calibration_in_the_large": 0.001331864241058068, + "expected_calibration_error_10bin": 0.001331864241058068, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + { + "valid": 2737, + "positives": 26, + "negatives": 2711, + "auroc": 0.6098516017365151, + "auprc": 0.014491627247545612, + "brier": 0.009613140568840222, + "calibration": { + "observed_rate": 0.009499451954694921, + "mean_prediction": 0.011269388629498207, + "calibration_in_the_large": 0.001769936674803286, + "expected_calibration_error_10bin": 0.0017699366748032874, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + { + "valid": 2737, + "positives": 27, + "negatives": 2710, + "auroc": 0.6200355336886703, + "auprc": 0.015510483973153475, + "brier": 0.009992191058133442, + "calibration": { + "observed_rate": 0.009864815491413957, + "mean_prediction": 0.011903862458690156, + "calibration_in_the_large": 0.0020390469672761993, + "expected_calibration_error_10bin": 0.0020390469672761998, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + { + "valid": 2737, + "positives": 29, + "negatives": 2708, + "auroc": 0.6319334793459991, + "auprc": 0.018597393129062282, + "brier": 0.010682101012369959, + "calibration": { + "observed_rate": 0.010595542564852027, + "mean_prediction": 0.0125230190254068, + "calibration_in_the_large": 0.0019274764605547723, + "expected_calibration_error_10bin": 0.001927476460554772, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + { + "valid": 2737, + "positives": 30, + "negatives": 2707, + "auroc": 0.629245166851373, + "auprc": 0.01871138819985985, + "brier": 0.011070449079075296, + "calibration": { + "observed_rate": 0.010960906101571063, + "mean_prediction": 0.013312233946874641, + "calibration_in_the_large": 0.0023513278453035774, + "expected_calibration_error_10bin": 0.0023513278453035774, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + { + "valid": 2737, + "positives": 30, + "negatives": 2707, + "auroc": 0.6292821081147641, + "auprc": 0.018750828450568243, + "brier": 0.011075360957049462, + "calibration": { + "observed_rate": 0.010960906101571063, + "mean_prediction": 0.013425875729123272, + "calibration_in_the_large": 0.002464969627552209, + "expected_calibration_error_10bin": 0.0024649696275522077, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + } + ], + "reason": null + }, + "E66": { + "time_averaged_auroc": 0.7238581867053467, + "time_averaged_auprc": 0.03806086432511191, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2371, + "positives": 9, + "negatives": 2362, + "auroc": 0.7173299463731301, + "auprc": 0.009509562193279949, + "brier": 0.0037813850079391675, + "calibration": { + "observed_rate": 0.003795866722901729, + "mean_prediction": 0.004001063903538522, + "calibration_in_the_large": 0.0002051971806367927, + "expected_calibration_error_10bin": 0.0002051971806367927, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + { + "valid": 2371, + "positives": 16, + "negatives": 2355, + "auroc": 0.7208067940552016, + "auprc": 0.018856646074745645, + "brier": 0.006679851416787735, + "calibration": { + "observed_rate": 0.006748207507380852, + "mean_prediction": 0.006379357560598443, + "calibration_in_the_large": -0.00036884994678240864, + "expected_calibration_error_10bin": 0.00036884994678240864, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + { + "valid": 2371, + "positives": 21, + "negatives": 2350, + "auroc": 0.707517730496454, + "auprc": 0.024681776173927233, + "brier": 0.008741602167468308, + "calibration": { + "observed_rate": 0.008857022353437369, + "mean_prediction": 0.008077342443023614, + "calibration_in_the_large": -0.0007796799104137549, + "expected_calibration_error_10bin": 0.0007796799104137549, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + { + "valid": 2371, + "positives": 27, + "negatives": 2344, + "auroc": 0.6888667677916824, + "auprc": 0.024774387724164067, + "brier": 0.011234954750317827, + "calibration": { + "observed_rate": 0.011387600168705188, + "mean_prediction": 0.009715378884894233, + "calibration_in_the_large": -0.0016722212838109554, + "expected_calibration_error_10bin": 0.0019313805384163912, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + { + "valid": 2371, + "positives": 27, + "negatives": 2344, + "auroc": 0.6905100492984452, + "auprc": 0.02574953857361139, + "brier": 0.011244762684150813, + "calibration": { + "observed_rate": 0.011387600168705188, + "mean_prediction": 0.010901368701803403, + "calibration_in_the_large": -0.00048623146690178476, + "expected_calibration_error_10bin": 0.0009670028396132275, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + { + "valid": 2371, + "positives": 29, + "negatives": 2342, + "auroc": 0.7121970611619894, + "auprc": 0.032934504465434486, + "brier": 0.012020938746309238, + "calibration": { + "observed_rate": 0.012231126107127795, + "mean_prediction": 0.01204351952173486, + "calibration_in_the_large": -0.0001876065853929354, + "expected_calibration_error_10bin": 0.0009757303584432635, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + { + "valid": 2371, + "positives": 32, + "negatives": 2339, + "auroc": 0.7361853356135101, + "auprc": 0.04270867785034602, + "brier": 0.01318530348827966, + "calibration": { + "observed_rate": 0.013496415014761703, + "mean_prediction": 0.012940180384453217, + "calibration_in_the_large": -0.0005562346303084869, + "expected_calibration_error_10bin": 0.0015239551042926184, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + { + "valid": 2371, + "positives": 34, + "negatives": 2337, + "auroc": 0.7460167635732085, + "auprc": 0.050252539979273654, + "brier": 0.01394500317707135, + "calibration": { + "observed_rate": 0.01433994095318431, + "mean_prediction": 0.01341995093812899, + "calibration_in_the_large": -0.0009199900150553206, + "expected_calibration_error_10bin": 0.0022294513693596665, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + { + "valid": 2371, + "positives": 36, + "negatives": 2335, + "auroc": 0.7368665239114918, + "auprc": 0.05033159350697519, + "brier": 0.014767002064757631, + "calibration": { + "observed_rate": 0.015183466891606916, + "mean_prediction": 0.014184976196498266, + "calibration_in_the_large": -0.0009984906951086506, + "expected_calibration_error_10bin": 0.0025006434584126016, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + { + "valid": 2371, + "positives": 39, + "negatives": 2332, + "auroc": 0.7392466024541496, + "auprc": 0.052518535972248745, + "brier": 0.015977453055890316, + "calibration": { + "observed_rate": 0.016448755799240825, + "mean_prediction": 0.015050178176455533, + "calibration_in_the_large": -0.001398577622785292, + "expected_calibration_error_10bin": 0.0025345080417534956, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + { + "valid": 2371, + "positives": 42, + "negatives": 2329, + "auroc": 0.7380747919605799, + "auprc": 0.0540941257460959, + "brier": 0.017189822123337382, + "calibration": { + "observed_rate": 0.017714044706874738, + "mean_prediction": 0.01623210465177683, + "calibration_in_the_large": -0.0014819400550979064, + "expected_calibration_error_10bin": 0.0028845526342634142, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + { + "valid": 2371, + "positives": 42, + "negatives": 2329, + "auroc": 0.7382281379705167, + "auprc": 0.05409561682980596, + "brier": 0.017201056817440313, + "calibration": { + "observed_rate": 0.017714044706874738, + "mean_prediction": 0.017258780142156864, + "calibration_in_the_large": -0.0004552645647178735, + "expected_calibration_error_10bin": 0.0016193399336899995, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + { + "valid": 2371, + "positives": 42, + "negatives": 2329, + "auroc": 0.7383099225091496, + "auprc": 0.054283731136546554, + "brier": 0.017201606535688405, + "calibration": { + "observed_rate": 0.017714044706874738, + "mean_prediction": 0.017376977632610573, + "calibration_in_the_large": -0.0003370670742641642, + "expected_calibration_error_10bin": 0.0015243461091116134, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + } + ], + "reason": null + }, + "E78": { + "time_averaged_auroc": 0.7094290519017673, + "time_averaged_auprc": 0.08201317943726888, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 1572, + "positives": 13, + "negatives": 1559, + "auroc": 0.6244140721369714, + "auprc": 0.02169925070159869, + "brier": 0.00819463471532225, + "calibration": { + "observed_rate": 0.00826972010178117, + "mean_prediction": 0.0058900309239976875, + "calibration_in_the_large": -0.0023796891777834823, + "expected_calibration_error_10bin": 0.0023796891777834823, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + { + "valid": 1572, + "positives": 19, + "negatives": 1553, + "auroc": 0.6419832582099163, + "auprc": 0.027437567890324616, + "brier": 0.01204588462257119, + "calibration": { + "observed_rate": 0.012086513994910942, + "mean_prediction": 0.010664035943334564, + "calibration_in_the_large": -0.0014224780515763782, + "expected_calibration_error_10bin": 0.002676676010499553, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + { + "valid": 1572, + "positives": 26, + "negatives": 1546, + "auroc": 0.69907453477958, + "auprc": 0.04038673076294167, + "brier": 0.016460938949106618, + "calibration": { + "observed_rate": 0.01653944020356234, + "mean_prediction": 0.014672821172452416, + "calibration_in_the_large": -0.0018666190311099236, + "expected_calibration_error_10bin": 0.006829431723188546, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + { + "valid": 1572, + "positives": 30, + "negatives": 1542, + "auroc": 0.6901426718547341, + "auprc": 0.04952360615199737, + "brier": 0.018877860052491112, + "calibration": { + "observed_rate": 0.019083969465648856, + "mean_prediction": 0.01741407643569849, + "calibration_in_the_large": -0.0016698930299503638, + "expected_calibration_error_10bin": 0.008049242912316458, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + { + "valid": 1572, + "positives": 31, + "negatives": 1541, + "auroc": 0.7013041384940655, + "auprc": 0.057504898165867846, + "brier": 0.019725257440506294, + "calibration": { + "observed_rate": 0.019720101781170483, + "mean_prediction": 0.021291269551840127, + "calibration_in_the_large": 0.0015711677706696445, + "expected_calibration_error_10bin": 0.006838072481595243, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + { + "valid": 1572, + "positives": 31, + "negatives": 1541, + "auroc": 0.7010110736639383, + "auprc": 0.05716035658040881, + "brier": 0.019969352155540986, + "calibration": { + "observed_rate": 0.019720101781170483, + "mean_prediction": 0.023380317527346244, + "calibration_in_the_large": 0.0036602157461757615, + "expected_calibration_error_10bin": 0.00687393052837087, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + { + "valid": 1572, + "positives": 35, + "negatives": 1537, + "auroc": 0.717836230132912, + "auprc": 0.09857162192026903, + "brier": 0.021947614224180404, + "calibration": { + "observed_rate": 0.022264631043257, + "mean_prediction": 0.02521666142243152, + "calibration_in_the_large": 0.002952030379174523, + "expected_calibration_error_10bin": 0.009465105783875764, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + { + "valid": 1572, + "positives": 38, + "negatives": 1534, + "auroc": 0.7345261785493721, + "auprc": 0.10496553493953245, + "brier": 0.023652899426652337, + "calibration": { + "observed_rate": 0.024173027989821884, + "mean_prediction": 0.027298656317938454, + "calibration_in_the_large": 0.0031256283281165705, + "expected_calibration_error_10bin": 0.009812374559380548, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + { + "valid": 1572, + "positives": 39, + "negatives": 1533, + "auroc": 0.7355277903223109, + "auprc": 0.10543439239611627, + "brier": 0.024540842764663406, + "calibration": { + "observed_rate": 0.02480916030534351, + "mean_prediction": 0.02967148892747051, + "calibration_in_the_large": 0.004862328622126998, + "expected_calibration_error_10bin": 0.008524468736844518, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + { + "valid": 1572, + "positives": 47, + "negatives": 1525, + "auroc": 0.7460481339379142, + "auprc": 0.12720512191703634, + "brier": 0.0286076646425152, + "calibration": { + "observed_rate": 0.02989821882951654, + "mean_prediction": 0.030779142719140288, + "calibration_in_the_large": 0.0008809238896237484, + "expected_calibration_error_10bin": 0.00998508144423242, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + { + "valid": 1572, + "positives": 50, + "negatives": 1522, + "auroc": 0.7433508541392904, + "auprc": 0.12657196450365477, + "brier": 0.03059390791018518, + "calibration": { + "observed_rate": 0.031806615776081425, + "mean_prediction": 0.0331079534454696, + "calibration_in_the_large": 0.0013013376693881765, + "expected_calibration_error_10bin": 0.013571840518208414, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + { + "valid": 1572, + "positives": 50, + "negatives": 1522, + "auroc": 0.743718791064389, + "auprc": 0.12489467776023179, + "brier": 0.03072025599616788, + "calibration": { + "observed_rate": 0.031806615776081425, + "mean_prediction": 0.03431782367399748, + "calibration_in_the_large": 0.0025112078979160554, + "expected_calibration_error_10bin": 0.010699719520329864, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + { + "valid": 1572, + "positives": 50, + "negatives": 1522, + "auroc": 0.7436399474375821, + "auprc": 0.12481560899451585, + "brier": 0.030760190644500238, + "calibration": { + "observed_rate": 0.031806615776081425, + "mean_prediction": 0.03470083468665639, + "calibration_in_the_large": 0.0028942189105749666, + "expected_calibration_error_10bin": 0.00965881197508626, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + } + ], + "reason": null + }, + "E80": { + "time_averaged_auroc": 0.8954869559621138, + "time_averaged_auprc": 0.024468988036881852, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2823, + "positives": 2, + "negatives": 2821, + "auroc": 0.9608294930875576, + "auprc": 0.013578201233545062, + "brier": 0.0007106666727370216, + "calibration": { + "observed_rate": 0.0007084661707403471, + "mean_prediction": 0.0005722033171757001, + "calibration_in_the_large": -0.00013626285356464708, + "expected_calibration_error_10bin": 0.00013626285356464708, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 3, + "negatives": 2820, + "auroc": 0.9654846335697399, + "auprc": 0.019604902860553202, + "brier": 0.0010628065362542445, + "calibration": { + "observed_rate": 0.0010626992561105207, + "mean_prediction": 0.0008841774622576381, + "calibration_in_the_large": -0.00017852179385288258, + "expected_calibration_error_10bin": 0.00017852179385288258, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 4, + "negatives": 2819, + "auroc": 0.9703795672224192, + "auprc": 0.032896441990644884, + "brier": 0.0014072870949756043, + "calibration": { + "observed_rate": 0.0014169323414806943, + "mean_prediction": 0.0012719866593695916, + "calibration_in_the_large": -0.00014494568211110268, + "expected_calibration_error_10bin": 0.00014494568211110268, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 4, + "negatives": 2819, + "auroc": 0.9699361475700603, + "auprc": 0.03161251626392304, + "brier": 0.0014107276613592199, + "calibration": { + "observed_rate": 0.0014169323414806943, + "mean_prediction": 0.001461270616449895, + "calibration_in_the_large": 4.4338274969200724e-05, + "expected_calibration_error_10bin": 4.4338274969200724e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 4, + "negatives": 2819, + "auroc": 0.9698474636395885, + "auprc": 0.031539051673855456, + "brier": 0.0014114473735108626, + "calibration": { + "observed_rate": 0.0014169323414806943, + "mean_prediction": 0.0015233290343619102, + "calibration_in_the_large": 0.00010639669288121587, + "expected_calibration_error_10bin": 0.00010639669288121587, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 4, + "negatives": 2819, + "auroc": 0.9701135154310039, + "auprc": 0.0316027133270714, + "brier": 0.0014129596587814913, + "calibration": { + "observed_rate": 0.0014169323414806943, + "mean_prediction": 0.001639817930825594, + "calibration_in_the_large": 0.00022288558934489963, + "expected_calibration_error_10bin": 0.00022288558934489963, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.8765234883445746, + "auprc": 0.02394400892276015, + "brier": 0.0021241092967916545, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0018133407258807406, + "calibration_in_the_large": -0.00031205778634030073, + "expected_calibration_error_10bin": 0.0003893229410940692, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.8756951840018933, + "auprc": 0.02273343117038218, + "brier": 0.0021426056982918264, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0020838136058835078, + "calibration_in_the_large": -4.158490633753356e-05, + "expected_calibration_error_10bin": 0.0004806091196497321, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.874866879659212, + "auprc": 0.02271378514775874, + "brier": 0.002149192247971112, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0022578353959297384, + "calibration_in_the_large": 0.00013243688370869703, + "expected_calibration_error_10bin": 0.00033894319795114774, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 7, + "negatives": 2816, + "auroc": 0.789163961038961, + "auprc": 0.019872317042868952, + "brier": 0.0025058450988324635, + "calibration": { + "observed_rate": 0.002479631597591215, + "mean_prediction": 0.0024000609264514887, + "calibration_in_the_large": -7.957067113972642e-05, + "expected_calibration_error_10bin": 0.0005646742102461271, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 7, + "negatives": 2816, + "auroc": 0.7896712662337663, + "auprc": 0.01979630918683267, + "brier": 0.002508994605440931, + "calibration": { + "observed_rate": 0.002479631597591215, + "mean_prediction": 0.002507392511289672, + "calibration_in_the_large": 2.7760913698456676e-05, + "expected_calibration_error_10bin": 0.0004706858261236311, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 8, + "negatives": 2815, + "auroc": 0.8143872113676732, + "auprc": 0.02410157539381859, + "brier": 0.002853270250672069, + "calibration": { + "observed_rate": 0.0028338646829613886, + "mean_prediction": 0.002589242817508589, + "calibration_in_the_large": -0.0002446218654527997, + "expected_calibration_error_10bin": 0.0007542369437731696, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 8, + "negatives": 2815, + "auroc": 0.8144316163410302, + "auprc": 0.0241015902654498, + "brier": 0.002853524645984802, + "calibration": { + "observed_rate": 0.0028338646829613886, + "mean_prediction": 0.0025969592825328324, + "calibration_in_the_large": -0.00023690540042855613, + "expected_calibration_error_10bin": 0.0007477268129950896, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + } + ], + "reason": null + }, + "E83": { + "time_averaged_auroc": 0.810996757972955, + "time_averaged_auprc": 0.1465798606317756, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2653, + "positives": 14, + "negatives": 2639, + "auroc": 0.8879987008065826, + "auprc": 0.0816843950853339, + "brier": 0.005104346467039365, + "calibration": { + "observed_rate": 0.005277044854881266, + "mean_prediction": 0.0050266449560034425, + "calibration_in_the_large": -0.00025039989887782384, + "expected_calibration_error_10bin": 0.00025039989887782384, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + { + "valid": 2653, + "positives": 26, + "negatives": 2627, + "auroc": 0.8332113261690727, + "auprc": 0.07934295526556828, + "brier": 0.00937412009947449, + "calibration": { + "observed_rate": 0.00980022615906521, + "mean_prediction": 0.009006512709169695, + "calibration_in_the_large": -0.0007937134498955146, + "expected_calibration_error_10bin": 0.0009989080562559402, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + { + "valid": 2653, + "positives": 40, + "negatives": 2613, + "auroc": 0.7906620742441638, + "auprc": 0.09365055298925837, + "brier": 0.014303505477043345, + "calibration": { + "observed_rate": 0.015077271013946476, + "mean_prediction": 0.012306588981236965, + "calibration_in_the_large": -0.0027706820327095105, + "expected_calibration_error_10bin": 0.0033096943730531432, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + { + "valid": 2653, + "positives": 47, + "negatives": 2606, + "auroc": 0.7915612089939746, + "auprc": 0.1024372475160379, + "brier": 0.0167204272853866, + "calibration": { + "observed_rate": 0.017715793441387108, + "mean_prediction": 0.014336487634740757, + "calibration_in_the_large": -0.0033793058066463513, + "expected_calibration_error_10bin": 0.003844318025658744, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + { + "valid": 2653, + "positives": 53, + "negatives": 2600, + "auroc": 0.7928374455732946, + "auprc": 0.11582995076557548, + "brier": 0.01867370684595696, + "calibration": { + "observed_rate": 0.01997738409347908, + "mean_prediction": 0.015885192463142867, + "calibration_in_the_large": -0.004092191630336212, + "expected_calibration_error_10bin": 0.005089344210007191, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + { + "valid": 2653, + "positives": 58, + "negatives": 2595, + "auroc": 0.7963789781409873, + "auprc": 0.11766813332112755, + "brier": 0.020409300083120908, + "calibration": { + "observed_rate": 0.02186204297022239, + "mean_prediction": 0.01778420864476633, + "calibration_in_the_large": -0.00407783432545606, + "expected_calibration_error_10bin": 0.005807619946375152, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + { + "valid": 2653, + "positives": 65, + "negatives": 2588, + "auroc": 0.7982166210914279, + "auprc": 0.14252718012747373, + "brier": 0.02249389971129007, + "calibration": { + "observed_rate": 0.024500565397663022, + "mean_prediction": 0.019244538422146847, + "calibration_in_the_large": -0.005256026975516175, + "expected_calibration_error_10bin": 0.00613962043997106, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + { + "valid": 2653, + "positives": 70, + "negatives": 2583, + "auroc": 0.812875394060063, + "auprc": 0.18937389549287464, + "brier": 0.023538920398255364, + "calibration": { + "observed_rate": 0.026385224274406333, + "mean_prediction": 0.020702527809592895, + "calibration_in_the_large": -0.005682696464813439, + "expected_calibration_error_10bin": 0.006069085225885923, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + { + "valid": 2653, + "positives": 74, + "negatives": 2579, + "auroc": 0.8123198809511334, + "auprc": 0.18781569444796334, + "brier": 0.024891870809010726, + "calibration": { + "observed_rate": 0.02789295137580098, + "mean_prediction": 0.02183465907309198, + "calibration_in_the_large": -0.006058292302709, + "expected_calibration_error_10bin": 0.006462773915531715, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + { + "valid": 2653, + "positives": 78, + "negatives": 2575, + "auroc": 0.80554642768235, + "auprc": 0.19411493833697266, + "brier": 0.026080578003398875, + "calibration": { + "observed_rate": 0.029400678477195626, + "mean_prediction": 0.023098410744276363, + "calibration_in_the_large": -0.006302267732919264, + "expected_calibration_error_10bin": 0.007272809557191068, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + { + "valid": 2653, + "positives": 82, + "negatives": 2571, + "auroc": 0.8095597233685289, + "auprc": 0.2046997732668237, + "brier": 0.02722324914693117, + "calibration": { + "observed_rate": 0.030908405578590276, + "mean_prediction": 0.02412800574347853, + "calibration_in_the_large": -0.006780399835111747, + "expected_calibration_error_10bin": 0.008731755298348914, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + { + "valid": 2653, + "positives": 86, + "negatives": 2567, + "auroc": 0.8058859767532456, + "auprc": 0.19815973238226142, + "brier": 0.02861903800795415, + "calibration": { + "observed_rate": 0.03241613267998492, + "mean_prediction": 0.02528893528045413, + "calibration_in_the_large": -0.007127197399530792, + "expected_calibration_error_10bin": 0.00905131392204264, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + { + "valid": 2653, + "positives": 86, + "negatives": 2567, + "auroc": 0.8059040958135911, + "auprc": 0.19823373921581178, + "brier": 0.028610251107303294, + "calibration": { + "observed_rate": 0.03241613267998492, + "mean_prediction": 0.025576548804355243, + "calibration_in_the_large": -0.00683958387562968, + "expected_calibration_error_10bin": 0.008483701546950623, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + } + ], + "reason": null + }, + "E86": { + "time_averaged_auroc": 0.7906765304410487, + "time_averaged_auprc": 0.09104789922074749, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2587, + "positives": 26, + "negatives": 2561, + "auroc": 0.8274111675126904, + "auprc": 0.05702337047035667, + "brier": 0.009759506050931377, + "calibration": { + "observed_rate": 0.010050251256281407, + "mean_prediction": 0.01208489161818337, + "calibration_in_the_large": 0.0020346403619019623, + "expected_calibration_error_10bin": 0.0020346403619019623, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + { + "valid": 2587, + "positives": 38, + "negatives": 2549, + "auroc": 0.8071999339266173, + "auprc": 0.05861058470420746, + "brier": 0.014241676697520906, + "calibration": { + "observed_rate": 0.014688828759180518, + "mean_prediction": 0.019829094044204115, + "calibration_in_the_large": 0.0051402652850235965, + "expected_calibration_error_10bin": 0.005140265285023597, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + { + "valid": 2587, + "positives": 42, + "negatives": 2545, + "auroc": 0.8029843764617831, + "auprc": 0.05873259109283963, + "brier": 0.015866784164652335, + "calibration": { + "observed_rate": 0.01623502126014689, + "mean_prediction": 0.02457196911993848, + "calibration_in_the_large": 0.00833694785979159, + "expected_calibration_error_10bin": 0.008336947859791591, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + { + "valid": 2587, + "positives": 52, + "negatives": 2535, + "auroc": 0.7828629949931725, + "auprc": 0.06622008077613686, + "brier": 0.019598615192182266, + "calibration": { + "observed_rate": 0.020100502512562814, + "mean_prediction": 0.02866305298712659, + "calibration_in_the_large": 0.008562550474563776, + "expected_calibration_error_10bin": 0.008562550474563776, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + { + "valid": 2587, + "positives": 58, + "negatives": 2529, + "auroc": 0.7767483399462783, + "auprc": 0.07114089518996192, + "brier": 0.02182452833425412, + "calibration": { + "observed_rate": 0.02241979126401237, + "mean_prediction": 0.03163570249696638, + "calibration_in_the_large": 0.00921591123295401, + "expected_calibration_error_10bin": 0.009215911232954007, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + { + "valid": 2587, + "positives": 71, + "negatives": 2516, + "auroc": 0.7919960142412503, + "auprc": 0.09053125463579527, + "brier": 0.026064234383803165, + "calibration": { + "observed_rate": 0.027444916892153073, + "mean_prediction": 0.033898246326536166, + "calibration_in_the_large": 0.006453329434383093, + "expected_calibration_error_10bin": 0.006453329434383093, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + { + "valid": 2587, + "positives": 79, + "negatives": 2508, + "auroc": 0.7840076312761189, + "auprc": 0.10230192792496914, + "brier": 0.028755900409375635, + "calibration": { + "observed_rate": 0.030537301894085815, + "mean_prediction": 0.03617938333358378, + "calibration_in_the_large": 0.005642081439497966, + "expected_calibration_error_10bin": 0.005642081439497968, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + { + "valid": 2587, + "positives": 82, + "negatives": 2505, + "auroc": 0.7808237184168249, + "auprc": 0.10490399460732781, + "brier": 0.029857369511412955, + "calibration": { + "observed_rate": 0.031696946269810594, + "mean_prediction": 0.0382368518707836, + "calibration_in_the_large": 0.006539905600973006, + "expected_calibration_error_10bin": 0.0065399056009730104, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + { + "valid": 2587, + "positives": 85, + "negatives": 2502, + "auroc": 0.7831005783608408, + "auprc": 0.10654284920305492, + "brier": 0.030932539617374466, + "calibration": { + "observed_rate": 0.032856590645535366, + "mean_prediction": 0.040145927785581126, + "calibration_in_the_large": 0.00728933714004576, + "expected_calibration_error_10bin": 0.007289337140045757, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + { + "valid": 2587, + "positives": 87, + "negatives": 2500, + "auroc": 0.785448275862069, + "auprc": 0.10861071812469882, + "brier": 0.03164959015076291, + "calibration": { + "observed_rate": 0.03362968689601856, + "mean_prediction": 0.041750024874548125, + "calibration_in_the_large": 0.008120337978529568, + "expected_calibration_error_10bin": 0.008171232442425909, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + { + "valid": 2587, + "positives": 92, + "negatives": 2495, + "auroc": 0.784612703668206, + "auprc": 0.11430183891244373, + "brier": 0.03323749842306599, + "calibration": { + "observed_rate": 0.03556242752222652, + "mean_prediction": 0.043220796591510825, + "calibration_in_the_large": 0.007658369069284306, + "expected_calibration_error_10bin": 0.0076583690692843065, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + { + "valid": 2587, + "positives": 97, + "negatives": 2490, + "auroc": 0.7849542499896494, + "auprc": 0.1215053303266857, + "brier": 0.03481714788857436, + "calibration": { + "observed_rate": 0.03749516814843448, + "mean_prediction": 0.04487274307951117, + "calibration_in_the_large": 0.007377574931076686, + "expected_calibration_error_10bin": 0.007382508200394575, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + { + "valid": 2587, + "positives": 98, + "negatives": 2489, + "auroc": 0.7866449110781315, + "auprc": 0.12319725390123934, + "brier": 0.03511161400001131, + "calibration": { + "observed_rate": 0.03788171627367607, + "mean_prediction": 0.045103692129543425, + "calibration_in_the_large": 0.007221975855867355, + "expected_calibration_error_10bin": 0.007711485250702519, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + } + ], + "reason": null + }, + "E87": { + "time_averaged_auroc": 0.7898815749199707, + "time_averaged_auprc": 0.17468539180081016, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2185, + "positives": 31, + "negatives": 2154, + "auroc": 0.7842423697846467, + "auprc": 0.054975322393395795, + "brier": 0.013730941003144509, + "calibration": { + "observed_rate": 0.014187643020594966, + "mean_prediction": 0.014368746417107857, + "calibration_in_the_large": 0.0001811033965128904, + "expected_calibration_error_10bin": 0.0010862337342235386, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + { + "valid": 2185, + "positives": 52, + "negatives": 2133, + "auroc": 0.801642684554077, + "auprc": 0.09449888223882265, + "brier": 0.022416086622184347, + "calibration": { + "observed_rate": 0.02379862700228833, + "mean_prediction": 0.02468723384072062, + "calibration_in_the_large": 0.0008886068384322925, + "expected_calibration_error_10bin": 0.0008886068384322909, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + { + "valid": 2185, + "positives": 74, + "negatives": 2111, + "auroc": 0.8017463223526701, + "auprc": 0.12865189196894916, + "brier": 0.031159748906545392, + "calibration": { + "observed_rate": 0.033867276887871854, + "mean_prediction": 0.031063788309874486, + "calibration_in_the_large": -0.0028034885779973685, + "expected_calibration_error_10bin": 0.006194102724223425, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + { + "valid": 2185, + "positives": 88, + "negatives": 2097, + "auroc": 0.7814085056574327, + "auprc": 0.1351738539855921, + "brier": 0.03693894427493211, + "calibration": { + "observed_rate": 0.040274599542334096, + "mean_prediction": 0.036070576244304535, + "calibration_in_the_large": -0.0042040232980295605, + "expected_calibration_error_10bin": 0.007256778526744322, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + { + "valid": 2185, + "positives": 97, + "negatives": 2088, + "auroc": 0.779036813208516, + "auprc": 0.14352907092588185, + "brier": 0.040456349395075634, + "calibration": { + "observed_rate": 0.044393592677345536, + "mean_prediction": 0.03976580442112681, + "calibration_in_the_large": -0.0046277882562187275, + "expected_calibration_error_10bin": 0.008236779690372762, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + { + "valid": 2185, + "positives": 107, + "negatives": 2078, + "auroc": 0.781606145377025, + "auprc": 0.1560872840089439, + "brier": 0.04422703793309166, + "calibration": { + "observed_rate": 0.04897025171624714, + "mean_prediction": 0.04344874293369175, + "calibration_in_the_large": -0.00552150878255539, + "expected_calibration_error_10bin": 0.010188543411835952, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + { + "valid": 2185, + "positives": 121, + "negatives": 2064, + "auroc": 0.7940691267858286, + "auprc": 0.19032274566685783, + "brier": 0.04865170462655584, + "calibration": { + "observed_rate": 0.05537757437070938, + "mean_prediction": 0.04651057348928672, + "calibration_in_the_large": -0.008867000881422657, + "expected_calibration_error_10bin": 0.012128372325932764, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + { + "valid": 2185, + "positives": 129, + "negatives": 2056, + "auroc": 0.788635266793352, + "auprc": 0.20524392878733444, + "brier": 0.05129531373364515, + "calibration": { + "observed_rate": 0.059038901601830666, + "mean_prediction": 0.04882184376991279, + "calibration_in_the_large": -0.010217057831917876, + "expected_calibration_error_10bin": 0.013079713675613329, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + { + "valid": 2185, + "positives": 138, + "negatives": 2047, + "auroc": 0.7919967715214206, + "auprc": 0.2179337536894848, + "brier": 0.05432084383368681, + "calibration": { + "observed_rate": 0.06315789473684211, + "mean_prediction": 0.05116627707846198, + "calibration_in_the_large": -0.011991617658380124, + "expected_calibration_error_10bin": 0.015319040596956126, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + { + "valid": 2185, + "positives": 147, + "negatives": 2038, + "auroc": 0.7886717002797193, + "auprc": 0.22284552813830563, + "brier": 0.057655813589332125, + "calibration": { + "observed_rate": 0.06727688787185354, + "mean_prediction": 0.05333521825738797, + "calibration_in_the_large": -0.013941669614465572, + "expected_calibration_error_10bin": 0.017063279624163114, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + { + "valid": 2185, + "positives": 153, + "negatives": 2032, + "auroc": 0.7885337862178993, + "auprc": 0.2330324117118477, + "brier": 0.05950791814126638, + "calibration": { + "observed_rate": 0.0700228832951945, + "mean_prediction": 0.05543689008187332, + "calibration_in_the_large": -0.014585993213321179, + "expected_calibration_error_10bin": 0.01862880975733676, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + { + "valid": 2185, + "positives": 157, + "negatives": 2028, + "auroc": 0.7929528009145843, + "auprc": 0.24369398223327335, + "brier": 0.060490934411094724, + "calibration": { + "observed_rate": 0.07185354691075514, + "mean_prediction": 0.057572922979436766, + "calibration_in_the_large": -0.014280623931318376, + "expected_calibration_error_10bin": 0.0175077912845229, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + { + "valid": 2185, + "positives": 158, + "negatives": 2027, + "auroc": 0.793918180512449, + "auprc": 0.24492143766184282, + "brier": 0.060809680630384305, + "calibration": { + "observed_rate": 0.07231121281464531, + "mean_prediction": 0.05780810533001916, + "calibration_in_the_large": -0.014503107484626146, + "expected_calibration_error_10bin": 0.017206157174907637, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + } + ], + "reason": null + }, + "E88": { + "time_averaged_auroc": 0.8338744567273495, + "time_averaged_auprc": 0.07956784400595945, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.9419568822553898, + "auprc": 0.06510474498482494, + "brier": 0.0010565891342337065, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.0008872731105711018, + "calibration_in_the_large": -0.00017768961573347763, + "expected_calibration_error_10bin": 0.00017768961573347763, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.9483534707415304, + "auprc": 0.05732924482924482, + "brier": 0.001051315228456849, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.0016408090831128862, + "calibration_in_the_large": 0.0005758463568083067, + "expected_calibration_error_10bin": 0.0005758463568083067, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 8, + "negatives": 2809, + "auroc": 0.7908508365966536, + "auprc": 0.08767680443540055, + "brier": 0.0027833025183718373, + "calibration": { + "observed_rate": 0.0028399006034788782, + "mean_prediction": 0.0020301176623074013, + "calibration_in_the_large": -0.0008097829411714769, + "expected_calibration_error_10bin": 0.0008097829411714769, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 9, + "negatives": 2808, + "auroc": 0.8068217790440013, + "auprc": 0.08419242928073277, + "brier": 0.003113827464177075, + "calibration": { + "observed_rate": 0.003194888178913738, + "mean_prediction": 0.0024963165573044462, + "calibration_in_the_large": -0.0006985716216092916, + "expected_calibration_error_10bin": 0.0006985716216092916, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 9, + "negatives": 2808, + "auroc": 0.8045267489711934, + "auprc": 0.0852721163770955, + "brier": 0.0031019353602032944, + "calibration": { + "observed_rate": 0.003194888178913738, + "mean_prediction": 0.002818275734867123, + "calibration_in_the_large": -0.0003766124440466147, + "expected_calibration_error_10bin": 0.0003766124440466147, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 10, + "negatives": 2807, + "auroc": 0.8156394727467047, + "auprc": 0.07996371773482376, + "brier": 0.0034498077262182483, + "calibration": { + "observed_rate": 0.003549875754348598, + "mean_prediction": 0.002937515275853102, + "calibration_in_the_large": -0.000612360478495496, + "expected_calibration_error_10bin": 0.0006842794492291542, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 10, + "negatives": 2807, + "auroc": 0.8128607053794086, + "auprc": 0.08459254722723095, + "brier": 0.003442300827027644, + "calibration": { + "observed_rate": 0.003549875754348598, + "mean_prediction": 0.0031955930403631525, + "calibration_in_the_large": -0.00035428271398544545, + "expected_calibration_error_10bin": 0.00043068456444071853, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 11, + "negatives": 2806, + "auroc": 0.8242078662606104, + "auprc": 0.082229718722242, + "brier": 0.0037865124077872524, + "calibration": { + "observed_rate": 0.0039048633297834577, + "mean_prediction": 0.0033026007992496636, + "calibration_in_the_large": -0.0006022625305337941, + "expected_calibration_error_10bin": 0.0006796920744565515, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 12, + "negatives": 2805, + "auroc": 0.8049613784907903, + "auprc": 0.08369593698351369, + "brier": 0.004132108622222519, + "calibration": { + "observed_rate": 0.004259850905218318, + "mean_prediction": 0.003516079664968553, + "calibration_in_the_large": -0.0007437712402497648, + "expected_calibration_error_10bin": 0.0009038622014335367, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 13, + "negatives": 2804, + "auroc": 0.807033907604521, + "auprc": 0.07612094615408672, + "brier": 0.004478816237494802, + "calibration": { + "observed_rate": 0.004614838480653177, + "mean_prediction": 0.003802324117049216, + "calibration_in_the_large": -0.0008125143636039615, + "expected_calibration_error_10bin": 0.0008125143636039611, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 15, + "negatives": 2802, + "auroc": 0.8287175826790388, + "auprc": 0.08274989250408528, + "brier": 0.005132597607335404, + "calibration": { + "observed_rate": 0.005324813631522897, + "mean_prediction": 0.00420420967972343, + "calibration_in_the_large": -0.001120603951799467, + "expected_calibration_error_10bin": 0.0011206039517994667, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 15, + "negatives": 2802, + "auroc": 0.8272424458719962, + "auprc": 0.08272770368483458, + "brier": 0.005128886678961526, + "calibration": { + "observed_rate": 0.005324813631522897, + "mean_prediction": 0.004425217107717646, + "calibration_in_the_large": -0.0008995965238052508, + "expected_calibration_error_10bin": 0.0008995965238052504, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 15, + "negatives": 2802, + "auroc": 0.8271948608137045, + "auprc": 0.08272616915935735, + "brier": 0.005128787031150934, + "calibration": { + "observed_rate": 0.005324813631522897, + "mean_prediction": 0.0044333255576985775, + "calibration_in_the_large": -0.0008914880738243192, + "expected_calibration_error_10bin": 0.0008914880738243199, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + } + ], + "reason": null + }, + "E89": { + "time_averaged_auroc": 0.6727061417310188, + "time_averaged_auprc": 0.003589346280792249, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2780, + "positives": 3, + "negatives": 2777, + "auroc": 0.8560797023166486, + "auprc": 0.004771341730135063, + "brier": 0.0010770286333699475, + "calibration": { + "observed_rate": 0.001079136690647482, + "mean_prediction": 0.0011284554683913858, + "calibration_in_the_large": 4.93187777439038e-05, + "expected_calibration_error_10bin": 4.93187777439038e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 4, + "negatives": 2776, + "auroc": 0.7287463976945245, + "auprc": 0.0032868646927853946, + "brier": 0.0014372516853695765, + "calibration": { + "observed_rate": 0.0014388489208633094, + "mean_prediction": 0.001707503472415273, + "calibration_in_the_large": 0.0002686545515519637, + "expected_calibration_error_10bin": 0.0002686545515519637, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 4, + "negatives": 2776, + "auroc": 0.7112752161383286, + "auprc": 0.0030286298966701354, + "brier": 0.0014384328144095245, + "calibration": { + "observed_rate": 0.0014388489208633094, + "mean_prediction": 0.0019810289140276046, + "calibration_in_the_large": 0.0005421799931642952, + "expected_calibration_error_10bin": 0.0005421799931642952, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 4, + "negatives": 2776, + "auroc": 0.694614553314121, + "auprc": 0.0028264090038692745, + "brier": 0.001440278553926299, + "calibration": { + "observed_rate": 0.0014388489208633094, + "mean_prediction": 0.0022319450462477785, + "calibration_in_the_large": 0.0007930961253844692, + "expected_calibration_error_10bin": 0.0007930961253844692, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 4, + "negatives": 2776, + "auroc": 0.6924531700288185, + "auprc": 0.002799488084918845, + "brier": 0.0014407243602705697, + "calibration": { + "observed_rate": 0.0014388489208633094, + "mean_prediction": 0.0023139964510153197, + "calibration_in_the_large": 0.0008751475301520103, + "expected_calibration_error_10bin": 0.0008751475301520103, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 5, + "negatives": 2775, + "auroc": 0.6926126126126126, + "auprc": 0.0033173642844381707, + "brier": 0.0018004402597659372, + "calibration": { + "observed_rate": 0.0017985611510791368, + "mean_prediction": 0.0025379194855952147, + "calibration_in_the_large": 0.0007393583345160779, + "expected_calibration_error_10bin": 0.0007393583345160779, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 5, + "negatives": 2775, + "auroc": 0.6883603603603604, + "auprc": 0.0032690909196582026, + "brier": 0.0018037495740747763, + "calibration": { + "observed_rate": 0.0017985611510791368, + "mean_prediction": 0.002856493875528384, + "calibration_in_the_large": 0.0010579327244492473, + "expected_calibration_error_10bin": 0.0010579327244492473, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 5, + "negatives": 2775, + "auroc": 0.6877117117117117, + "auprc": 0.0032689905069257603, + "brier": 0.001804654310721322, + "calibration": { + "observed_rate": 0.0017985611510791368, + "mean_prediction": 0.002933692820843396, + "calibration_in_the_large": 0.0011351316697642594, + "expected_calibration_error_10bin": 0.0011351316697642594, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 8, + "negatives": 2772, + "auroc": 0.5975378787878788, + "auprc": 0.004005576677629431, + "brier": 0.0028832509839809505, + "calibration": { + "observed_rate": 0.0028776978417266188, + "mean_prediction": 0.003259345164657369, + "calibration_in_the_large": 0.00038164732293075043, + "expected_calibration_error_10bin": 0.00038164732293075043, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 8, + "negatives": 2772, + "auroc": 0.597267316017316, + "auprc": 0.004008837821776511, + "brier": 0.0028836154727941298, + "calibration": { + "observed_rate": 0.0028776978417266188, + "mean_prediction": 0.003296239036351037, + "calibration_in_the_large": 0.0004185411946244183, + "expected_calibration_error_10bin": 0.0004185411946244183, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 8, + "negatives": 2772, + "auroc": 0.5994318181818182, + "auprc": 0.004021036022081377, + "brier": 0.0028850517239719675, + "calibration": { + "observed_rate": 0.0028776978417266188, + "mean_prediction": 0.0035014705351707124, + "calibration_in_the_large": 0.0006237726934440937, + "expected_calibration_error_10bin": 0.0006237726934440937, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 8, + "negatives": 2772, + "auroc": 0.5997023809523809, + "auprc": 0.0040296106467358084, + "brier": 0.0028854619836774253, + "calibration": { + "observed_rate": 0.0028776978417266188, + "mean_prediction": 0.0035389511728124933, + "calibration_in_the_large": 0.0006612533310858745, + "expected_calibration_error_10bin": 0.0006612533310858745, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 8, + "negatives": 2772, + "auroc": 0.5993867243867244, + "auprc": 0.00402826136267526, + "brier": 0.0028859282596409882, + "calibration": { + "observed_rate": 0.0028776978417266188, + "mean_prediction": 0.003570607627991992, + "calibration_in_the_large": 0.0006929097862653734, + "expected_calibration_error_10bin": 0.0006929097862653734, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + } + ], + "reason": null + }, + "F02": { + "time_averaged_auroc": 0.7695515551233943, + "time_averaged_auprc": 0.004488872949617453, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2802, + "positives": 0, + "negatives": 2802, + "auroc": null, + "auprc": null, + "brier": 2.0103656679519883e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0005346107848933377, + "calibration_in_the_large": 0.0005346107848933377, + "expected_calibration_error_10bin": 0.0005346107848933377, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 1, + "negatives": 2801, + "auroc": 0.7115315958586219, + "auprc": 0.0012360939431396785, + "brier": 0.00036620725747898135, + "calibration": { + "observed_rate": 0.00035688793718772306, + "mean_prediction": 0.001072210505915708, + "calibration_in_the_large": 0.0007153225687279851, + "expected_calibration_error_10bin": 0.0007153225687279851, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 1, + "negatives": 2801, + "auroc": 0.682256337022492, + "auprc": 0.001122334455667789, + "brier": 0.0003787464187045151, + "calibration": { + "observed_rate": 0.00035688793718772306, + "mean_prediction": 0.001531085545730158, + "calibration_in_the_large": 0.001174197608542435, + "expected_calibration_error_10bin": 0.001174197608542435, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 1, + "negatives": 2801, + "auroc": 0.6644055694394859, + "auprc": 0.0010626992561105207, + "brier": 0.0003857761929882231, + "calibration": { + "observed_rate": 0.00035688793718772306, + "mean_prediction": 0.0017668499214794975, + "calibration_in_the_large": 0.0014099619842917745, + "expected_calibration_error_10bin": 0.0014099619842917745, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 1, + "negatives": 2801, + "auroc": 0.6465548018564798, + "auprc": 0.0010090817356205853, + "brier": 0.0003967812412472316, + "calibration": { + "observed_rate": 0.00035688793718772306, + "mean_prediction": 0.0020419196466571173, + "calibration_in_the_large": 0.0016850317094693943, + "expected_calibration_error_10bin": 0.001685031709469394, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 3, + "negatives": 2799, + "auroc": 0.8376801238537573, + "auprc": 0.0067320145207121805, + "brier": 0.0011044224289963988, + "calibration": { + "observed_rate": 0.0010706638115631692, + "mean_prediction": 0.0022130275786319447, + "calibration_in_the_large": 0.0011423637670687754, + "expected_calibration_error_10bin": 0.0011423637670687757, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 3, + "negatives": 2799, + "auroc": 0.8350601405263784, + "auprc": 0.00663332394101625, + "brier": 0.0011141333087891895, + "calibration": { + "observed_rate": 0.0010706638115631692, + "mean_prediction": 0.002425544194939305, + "calibration_in_the_large": 0.0013548803833761359, + "expected_calibration_error_10bin": 0.0013548803833761359, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8097748391708363, + "auprc": 0.006071563175786184, + "brier": 0.0014794661220913087, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.0026562550744667563, + "calibration_in_the_large": 0.001228703325715864, + "expected_calibration_error_10bin": 0.0012287033257158643, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8093280914939243, + "auprc": 0.006052226072247383, + "brier": 0.001487120503498938, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.0028324120990970507, + "calibration_in_the_large": 0.0014048603503461585, + "expected_calibration_error_10bin": 0.0014048603503461585, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8106683345246605, + "auprc": 0.006095521127254679, + "brier": 0.0014978784702837562, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.0030485601661188527, + "calibration_in_the_large": 0.0016210084173679605, + "expected_calibration_error_10bin": 0.0016210084173679602, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8104896354538956, + "auprc": 0.006021752117115099, + "brier": 0.0015094387681890127, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.003241487260579045, + "calibration_in_the_large": 0.0018139355118281526, + "expected_calibration_error_10bin": 0.0018139355118281526, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8085239456754825, + "auprc": 0.005916153742929268, + "brier": 0.001529166583769849, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.0035477965015148984, + "calibration_in_the_large": 0.002120244752764006, + "expected_calibration_error_10bin": 0.002120244752764006, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8083452466047176, + "auprc": 0.0059137113078098205, + "brier": 0.0015299019286715376, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.003563101181759789, + "calibration_in_the_large": 0.0021355494330088966, + "expected_calibration_error_10bin": 0.0021355494330088966, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + } + ], + "reason": null + }, + "F03": { + "time_averaged_auroc": 0.8520850772003496, + "time_averaged_auprc": 0.0244903423614515, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2739, + "positives": 5, + "negatives": 2734, + "auroc": 0.8440380395025604, + "auprc": 0.007271384500148167, + "brier": 0.0018254557877024683, + "calibration": { + "observed_rate": 0.0018254837531945967, + "mean_prediction": 0.0014793293101128565, + "calibration_in_the_large": -0.00034615444308174013, + "expected_calibration_error_10bin": 0.00034615444308174013, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 7, + "negatives": 2732, + "auroc": 0.8708952102070696, + "auprc": 0.0130871741684604, + "brier": 0.0025568266052817834, + "calibration": { + "observed_rate": 0.002555677254472435, + "mean_prediction": 0.0026799884185707457, + "calibration_in_the_large": 0.00012431116409831067, + "expected_calibration_error_10bin": 0.00012431116409831067, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 10, + "negatives": 2729, + "auroc": 0.8359105899596921, + "auprc": 0.013737675308486874, + "brier": 0.0036578860804645985, + "calibration": { + "observed_rate": 0.0036509675063891934, + "mean_prediction": 0.0032813537556745914, + "calibration_in_the_large": -0.000369613750714602, + "expected_calibration_error_10bin": 0.00045554490642145564, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 11, + "negatives": 2728, + "auroc": 0.8519394828045854, + "auprc": 0.026605220895301963, + "brier": 0.00400432455245496, + "calibration": { + "observed_rate": 0.004016064257028112, + "mean_prediction": 0.00438885354836595, + "calibration_in_the_large": 0.00037278929133783764, + "expected_calibration_error_10bin": 0.0003727892913378371, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 11, + "negatives": 2728, + "auroc": 0.8508731005065316, + "auprc": 0.027687557341375235, + "brier": 0.004023819622627906, + "calibration": { + "observed_rate": 0.004016064257028112, + "mean_prediction": 0.005045035115240832, + "calibration_in_the_large": 0.0010289708582127202, + "expected_calibration_error_10bin": 0.0010289708582127198, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 12, + "negatives": 2727, + "auroc": 0.8590636841461924, + "auprc": 0.027683525453171015, + "brier": 0.0044047520594994016, + "calibration": { + "observed_rate": 0.004381161007667032, + "mean_prediction": 0.005647545209832014, + "calibration_in_the_large": 0.0012663842021649824, + "expected_calibration_error_10bin": 0.0012663842021649826, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 14, + "negatives": 2725, + "auroc": 0.8479423328964614, + "auprc": 0.026672828881050856, + "brier": 0.0051629710194328726, + "calibration": { + "observed_rate": 0.00511135450894487, + "mean_prediction": 0.006251871420310607, + "calibration_in_the_large": 0.0011405169113657366, + "expected_calibration_error_10bin": 0.0011405169113657358, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 14, + "negatives": 2725, + "auroc": 0.8473132372214941, + "auprc": 0.02572010319101865, + "brier": 0.00518483159057174, + "calibration": { + "observed_rate": 0.00511135450894487, + "mean_prediction": 0.00665706497945791, + "calibration_in_the_large": 0.0015457104705130396, + "expected_calibration_error_10bin": 0.00154571047051304, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 14, + "negatives": 2725, + "auroc": 0.8484141546526868, + "auprc": 0.02529790598483476, + "brier": 0.005222637323653796, + "calibration": { + "observed_rate": 0.00511135450894487, + "mean_prediction": 0.0072568870560988435, + "calibration_in_the_large": 0.0021455325471539735, + "expected_calibration_error_10bin": 0.0021455325471539735, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 14, + "negatives": 2725, + "auroc": 0.8481258191349934, + "auprc": 0.024756136350233583, + "brier": 0.005250951589904259, + "calibration": { + "observed_rate": 0.00511135450894487, + "mean_prediction": 0.00772071422335033, + "calibration_in_the_large": 0.0026093597144054596, + "expected_calibration_error_10bin": 0.0026093597144054587, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 16, + "negatives": 2723, + "auroc": 0.8623531031950055, + "auprc": 0.0335305125578859, + "brier": 0.005916408486686381, + "calibration": { + "observed_rate": 0.005841548010222709, + "mean_prediction": 0.00821437733157956, + "calibration_in_the_large": 0.0023728293213568516, + "expected_calibration_error_10bin": 0.002372829321356852, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 18, + "negatives": 2721, + "auroc": 0.8551390420188656, + "auprc": 0.03317756936038211, + "brier": 0.0066584133736979694, + "calibration": { + "observed_rate": 0.0065717415115005475, + "mean_prediction": 0.008611883335138418, + "calibration_in_the_large": 0.0020401418236378702, + "expected_calibration_error_10bin": 0.0020401418236378694, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 18, + "negatives": 2721, + "auroc": 0.8550982073584058, + "auprc": 0.03314685670651997, + "brier": 0.006663850197362196, + "calibration": { + "observed_rate": 0.0065717415115005475, + "mean_prediction": 0.008692472288812453, + "calibration_in_the_large": 0.0021207307773119053, + "expected_calibration_error_10bin": 0.0021207307773119053, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + } + ], + "reason": null + }, + "F05": { + "time_averaged_auroc": 0.7471089900639748, + "time_averaged_auprc": 0.02627334563297153, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2750, + "positives": 1, + "negatives": 2749, + "auroc": 0.9970898508548564, + "auprc": 0.1111111111111111, + "brier": 0.0003691368736340336, + "calibration": { + "observed_rate": 0.0003636363636363636, + "mean_prediction": 0.002552933731197382, + "calibration_in_the_large": 0.0021892973675610183, + "expected_calibration_error_10bin": 0.0021892973675610183, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 9, + "negatives": 2741, + "auroc": 0.7483481292310187, + "auprc": 0.016246519600453882, + "brier": 0.003273860132201981, + "calibration": { + "observed_rate": 0.0032727272727272726, + "mean_prediction": 0.004301069324133674, + "calibration_in_the_large": 0.0010283420514064015, + "expected_calibration_error_10bin": 0.0010283420514064022, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 14, + "negatives": 2736, + "auroc": 0.7391917293233082, + "auprc": 0.016441017767335024, + "brier": 0.005110190490043966, + "calibration": { + "observed_rate": 0.005090909090909091, + "mean_prediction": 0.006598435252875788, + "calibration_in_the_large": 0.0015075261619666965, + "expected_calibration_error_10bin": 0.0015075261619666974, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 15, + "negatives": 2735, + "auroc": 0.7352102376599634, + "auprc": 0.015293950849351597, + "brier": 0.005522863972649958, + "calibration": { + "observed_rate": 0.005454545454545455, + "mean_prediction": 0.007986498047339741, + "calibration_in_the_large": 0.0025319525927942864, + "expected_calibration_error_10bin": 0.002531952592794286, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 16, + "negatives": 2734, + "auroc": 0.7273454645208486, + "auprc": 0.014314381584063254, + "brier": 0.0059583118304043755, + "calibration": { + "observed_rate": 0.005818181818181818, + "mean_prediction": 0.00939188958354035, + "calibration_in_the_large": 0.0035737077653585324, + "expected_calibration_error_10bin": 0.0035737077653585324, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 19, + "negatives": 2731, + "auroc": 0.7207500626336989, + "auprc": 0.015615620180567063, + "brier": 0.007080370007413691, + "calibration": { + "observed_rate": 0.006909090909090909, + "mean_prediction": 0.010448716089681098, + "calibration_in_the_large": 0.003539625180590189, + "expected_calibration_error_10bin": 0.0035396251805901876, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 20, + "negatives": 2730, + "auroc": 0.717014652014652, + "auprc": 0.01574123140243029, + "brier": 0.007534353249752751, + "calibration": { + "observed_rate": 0.007272727272727273, + "mean_prediction": 0.01146553733851893, + "calibration_in_the_large": 0.004192810065791657, + "expected_calibration_error_10bin": 0.004192810065791656, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 23, + "negatives": 2727, + "auroc": 0.7106072926133193, + "auprc": 0.016767774646333753, + "brier": 0.008674268787659421, + "calibration": { + "observed_rate": 0.008363636363636363, + "mean_prediction": 0.012298044220118423, + "calibration_in_the_large": 0.00393440785648206, + "expected_calibration_error_10bin": 0.0039344078564820615, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 28, + "negatives": 2722, + "auroc": 0.7088669045869633, + "auprc": 0.020531750577856372, + "brier": 0.010436707293725757, + "calibration": { + "observed_rate": 0.010181818181818183, + "mean_prediction": 0.012918316355504264, + "calibration_in_the_large": 0.0027364981736860815, + "expected_calibration_error_10bin": 0.0027364981736860824, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 29, + "negatives": 2721, + "auroc": 0.7149374596053683, + "auprc": 0.021558984414295414, + "brier": 0.010800876313490035, + "calibration": { + "observed_rate": 0.010545454545454545, + "mean_prediction": 0.01323043720423117, + "calibration_in_the_large": 0.0026849826587766242, + "expected_calibration_error_10bin": 0.0026849826587766225, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 31, + "negatives": 2719, + "auroc": 0.7303088184697885, + "auprc": 0.02521520047657075, + "brier": 0.011508721916523489, + "calibration": { + "observed_rate": 0.011272727272727273, + "mean_prediction": 0.013864467442083299, + "calibration_in_the_large": 0.002591740169356026, + "expected_calibration_error_10bin": 0.002591740169356028, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 32, + "negatives": 2718, + "auroc": 0.7278559602649006, + "auprc": 0.025379956952964845, + "brier": 0.011914197512029196, + "calibration": { + "observed_rate": 0.011636363636363636, + "mean_prediction": 0.014409895673097873, + "calibration_in_the_large": 0.0027735320367342376, + "expected_calibration_error_10bin": 0.0027735320367342376, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 33, + "negatives": 2717, + "auroc": 0.7348903090529885, + "auprc": 0.027335993665296557, + "brier": 0.012246679927856666, + "calibration": { + "observed_rate": 0.012, + "mean_prediction": 0.014578682034003908, + "calibration_in_the_large": 0.002578682034003908, + "expected_calibration_error_10bin": 0.0025786820340039083, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + } + ], + "reason": null + }, + "F06": { + "time_averaged_auroc": 0.7031136242269108, + "time_averaged_auprc": 0.0016367323668027604, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.6636009904492395, + "auprc": 0.0010504201680672268, + "brier": 0.00035475720640890156, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0006378291176861111, + "calibration_in_the_large": 0.0002842223284357575, + "expected_calibration_error_10bin": 0.0002842223284357575, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.6752741422002122, + "auprc": 0.001088139281828074, + "brier": 0.0003557653712779867, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0008955991180401111, + "calibration_in_the_large": 0.0005419923287897574, + "expected_calibration_error_10bin": 0.0005419923287897574, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.672798019101521, + "auprc": 0.0010799136069114472, + "brier": 0.00036189331728836844, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0015843878935164451, + "calibration_in_the_large": 0.0012307811042660914, + "expected_calibration_error_10bin": 0.0012307811042660914, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7153220099079972, + "auprc": 0.0018085378323108386, + "brier": 0.0007156043526741042, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0017384454642043242, + "calibration_in_the_large": 0.0010312318857036169, + "expected_calibration_error_10bin": 0.0010312318857036169, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7096602972399151, + "auprc": 0.0017798440875363953, + "brier": 0.0007174059580060421, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0019159244906021286, + "calibration_in_the_large": 0.0012087109121014213, + "expected_calibration_error_10bin": 0.0012087109121014213, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7172682236376504, + "auprc": 0.001831946755407654, + "brier": 0.000720084753059133, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.002180147043195208, + "calibration_in_the_large": 0.0014729334646945008, + "expected_calibration_error_10bin": 0.0014729334646945008, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7154989384288747, + "auprc": 0.0018212508884150676, + "brier": 0.0007205103455473895, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0022164642621574594, + "calibration_in_the_large": 0.001509250683656752, + "expected_calibration_error_10bin": 0.001509250683656752, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7084217975937721, + "auprc": 0.0017760267654737894, + "brier": 0.0007231013149608555, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.002401681609250761, + "calibration_in_the_large": 0.0016944680307500537, + "expected_calibration_error_10bin": 0.0016944680307500537, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7070063694267515, + "auprc": 0.0017611606392440074, + "brier": 0.0007285593846643912, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.002651432421609372, + "calibration_in_the_large": 0.0019442188431086646, + "expected_calibration_error_10bin": 0.0019442188431086646, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7112526539278131, + "auprc": 0.0018082032753099545, + "brier": 0.0007326201857754716, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.00292062432838845, + "calibration_in_the_large": 0.0022134107498877425, + "expected_calibration_error_10bin": 0.0022134107498877425, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7119603680113235, + "auprc": 0.001809643162518684, + "brier": 0.0007371595795341821, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0031270084994025863, + "calibration_in_the_large": 0.002419794920901879, + "expected_calibration_error_10bin": 0.002419794920901879, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7163835810332626, + "auprc": 0.0018326584071742644, + "brier": 0.0007411085889747082, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0032832535497023057, + "calibration_in_the_large": 0.0025760399712015983, + "expected_calibration_error_10bin": 0.0025760399712015983, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7160297239915074, + "auprc": 0.0018297758982384867, + "brier": 0.0007412921513026699, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0032919887290920736, + "calibration_in_the_large": 0.0025847751505913663, + "expected_calibration_error_10bin": 0.0025847751505913663, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + } + ], + "reason": null + }, + "F10": { + "time_averaged_auroc": 0.8232659781185462, + "time_averaged_auprc": 0.11981743002857281, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2560, + "positives": 5, + "negatives": 2555, + "auroc": 0.8631702544031311, + "auprc": 0.11417058066958186, + "brier": 0.0018999677205351368, + "calibration": { + "observed_rate": 0.001953125, + "mean_prediction": 0.002374229365869951, + "calibration_in_the_large": 0.0004211043658699509, + "expected_calibration_error_10bin": 0.00042110436586995114, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 9, + "negatives": 2551, + "auroc": 0.8520405941025306, + "auprc": 0.10954843591297114, + "brier": 0.003346479107819785, + "calibration": { + "observed_rate": 0.003515625, + "mean_prediction": 0.003685563259983837, + "calibration_in_the_large": 0.0001699382599838371, + "expected_calibration_error_10bin": 0.0005396081877336198, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 9, + "negatives": 2551, + "auroc": 0.8443747549980399, + "auprc": 0.1645988826687351, + "brier": 0.0033314116088599645, + "calibration": { + "observed_rate": 0.003515625, + "mean_prediction": 0.004515074702084121, + "calibration_in_the_large": 0.0009994497020841208, + "expected_calibration_error_10bin": 0.0017085382212997046, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 9, + "negatives": 2551, + "auroc": 0.8420662920858922, + "auprc": 0.1645405147999129, + "brier": 0.0033360419591764072, + "calibration": { + "observed_rate": 0.003515625, + "mean_prediction": 0.005579643940058077, + "calibration_in_the_large": 0.002064018940058077, + "expected_calibration_error_10bin": 0.0024100664178547506, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 9, + "negatives": 2551, + "auroc": 0.8446360904220567, + "auprc": 0.10926462479217855, + "brier": 0.0033533193560994594, + "calibration": { + "observed_rate": 0.003515625, + "mean_prediction": 0.006601019810386788, + "calibration_in_the_large": 0.0030853948103867876, + "expected_calibration_error_10bin": 0.00336513868669499, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 10, + "negatives": 2550, + "auroc": 0.8270196078431372, + "auprc": 0.15606579920853206, + "brier": 0.0037416570320296743, + "calibration": { + "observed_rate": 0.00390625, + "mean_prediction": 0.007068332020548951, + "calibration_in_the_large": 0.0031620820205489506, + "expected_calibration_error_10bin": 0.003396452466381561, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 15, + "negatives": 2545, + "auroc": 0.7944990176817289, + "auprc": 0.1098669315117465, + "brier": 0.005623919548968938, + "calibration": { + "observed_rate": 0.005859375, + "mean_prediction": 0.007520395845313032, + "calibration_in_the_large": 0.0016610208453130323, + "expected_calibration_error_10bin": 0.0018508142811697324, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 15, + "negatives": 2545, + "auroc": 0.7922986247544205, + "auprc": 0.11146819704952345, + "brier": 0.005626742105504454, + "calibration": { + "observed_rate": 0.005859375, + "mean_prediction": 0.007806336809107961, + "calibration_in_the_large": 0.0019469618091079608, + "expected_calibration_error_10bin": 0.002397980004707279, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 16, + "negatives": 2544, + "auroc": 0.8013217374213837, + "auprc": 0.10771336861186917, + "brier": 0.006010184840041561, + "calibration": { + "observed_rate": 0.00625, + "mean_prediction": 0.008189301666595839, + "calibration_in_the_large": 0.0019393016665958385, + "expected_calibration_error_10bin": 0.0023802921723358856, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 17, + "negatives": 2543, + "auroc": 0.8105526127084731, + "auprc": 0.10273260263313594, + "brier": 0.0063908589126583735, + "calibration": { + "observed_rate": 0.006640625, + "mean_prediction": 0.008519959579416536, + "calibration_in_the_large": 0.0018793345794165363, + "expected_calibration_error_10bin": 0.0023144828055137617, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 17, + "negatives": 2543, + "auroc": 0.8104369549628738, + "auprc": 0.1026760510033139, + "brier": 0.00639896183400219, + "calibration": { + "observed_rate": 0.006640625, + "mean_prediction": 0.008790335025980766, + "calibration_in_the_large": 0.002149710025980766, + "expected_calibration_error_10bin": 0.002574950726113911, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 17, + "negatives": 2543, + "auroc": 0.8099049293331174, + "auprc": 0.10248614295608836, + "brier": 0.006405678188100711, + "calibration": { + "observed_rate": 0.006640625, + "mean_prediction": 0.009089995549459218, + "calibration_in_the_large": 0.002449370549459218, + "expected_calibration_error_10bin": 0.002545665601667224, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 17, + "negatives": 2543, + "auroc": 0.8101362448243159, + "auprc": 0.10249445855385765, + "brier": 0.006408360836741856, + "calibration": { + "observed_rate": 0.006640625, + "mean_prediction": 0.009181668244286812, + "calibration_in_the_large": 0.002541043244286812, + "expected_calibration_error_10bin": 0.002634124395422077, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + } + ], + "reason": null + }, + "F11": { + "time_averaged_auroc": 0.8735971100784252, + "time_averaged_auprc": 0.03981745824586909, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2741, + "positives": 4, + "negatives": 2737, + "auroc": 0.9763427109974424, + "auprc": 0.084816859969299, + "brier": 0.0014290816759318463, + "calibration": { + "observed_rate": 0.001459321415541773, + "mean_prediction": 0.0012393619503265206, + "calibration_in_the_large": -0.00021995946521525243, + "expected_calibration_error_10bin": 0.0003130613332236541, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 6, + "negatives": 2735, + "auroc": 0.8694698354661792, + "auprc": 0.04456617196286522, + "brier": 0.002165926386928108, + "calibration": { + "observed_rate": 0.0021889821233126595, + "mean_prediction": 0.002133875032864605, + "calibration_in_the_large": -5.5107090448054414e-05, + "expected_calibration_error_10bin": 0.0002693026387401153, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 6, + "negatives": 2735, + "auroc": 0.8599024984765387, + "auprc": 0.03586521561483196, + "brier": 0.0021824812468110256, + "calibration": { + "observed_rate": 0.0021889821233126595, + "mean_prediction": 0.002649979504721999, + "calibration_in_the_large": 0.0004609973814093393, + "expected_calibration_error_10bin": 0.00046099738140933916, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 7, + "negatives": 2734, + "auroc": 0.8598077124046399, + "auprc": 0.03458384981261382, + "brier": 0.0025589678936977895, + "calibration": { + "observed_rate": 0.002553812477198103, + "mean_prediction": 0.003118550318263713, + "calibration_in_the_large": 0.00056473784106561, + "expected_calibration_error_10bin": 0.0005647378410656103, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 8, + "negatives": 2733, + "auroc": 0.8570252469813392, + "auprc": 0.03191779721470629, + "brier": 0.002922974565039722, + "calibration": { + "observed_rate": 0.002918642831083546, + "mean_prediction": 0.003285606426645752, + "calibration_in_the_large": 0.000366963595562206, + "expected_calibration_error_10bin": 0.0003669635955622059, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 8, + "negatives": 2733, + "auroc": 0.8562019758507134, + "auprc": 0.033931140313108864, + "brier": 0.0029372754012955316, + "calibration": { + "observed_rate": 0.002918642831083546, + "mean_prediction": 0.0036486667900853587, + "calibration_in_the_large": 0.0007300239590018126, + "expected_calibration_error_10bin": 0.0007300239590018129, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 9, + "negatives": 2732, + "auroc": 0.8639580283064909, + "auprc": 0.0323421346118985, + "brier": 0.0033048617142284885, + "calibration": { + "observed_rate": 0.003283473184968989, + "mean_prediction": 0.0039530036386050795, + "calibration_in_the_large": 0.0006695304536360903, + "expected_calibration_error_10bin": 0.0006695304536360901, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 9, + "negatives": 2732, + "auroc": 0.8617211647958354, + "auprc": 0.03242434561921866, + "brier": 0.003309681449265005, + "calibration": { + "observed_rate": 0.003283473184968989, + "mean_prediction": 0.0041357005592624705, + "calibration_in_the_large": 0.0008522273742934813, + "expected_calibration_error_10bin": 0.0008522273742934811, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 9, + "negatives": 2732, + "auroc": 0.8597689930047178, + "auprc": 0.03154416710840984, + "brier": 0.0033215670006712518, + "calibration": { + "observed_rate": 0.003283473184968989, + "mean_prediction": 0.004402013048827034, + "calibration_in_the_large": 0.001118539863858045, + "expected_calibration_error_10bin": 0.001118539863858045, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 10, + "negatives": 2731, + "auroc": 0.8682533870377152, + "auprc": 0.033934103611858814, + "brier": 0.0036805729474208883, + "calibration": { + "observed_rate": 0.0036483035388544327, + "mean_prediction": 0.004629662746835225, + "calibration_in_the_large": 0.0009813592079807925, + "expected_calibration_error_10bin": 0.0009813592079807923, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 10, + "negatives": 2731, + "auroc": 0.8676675210545588, + "auprc": 0.033961397265925716, + "brier": 0.003684208647141529, + "calibration": { + "observed_rate": 0.0036483035388544327, + "mean_prediction": 0.004781719482962389, + "calibration_in_the_large": 0.0011334159441079563, + "expected_calibration_error_10bin": 0.0011334159441079566, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 11, + "negatives": 2730, + "auroc": 0.8783549783549783, + "auprc": 0.04397422344437113, + "brier": 0.004021371753335971, + "calibration": { + "observed_rate": 0.004013133892739876, + "mean_prediction": 0.004997133210235186, + "calibration_in_the_large": 0.0009839993174953097, + "expected_calibration_error_10bin": 0.0009839993174953097, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 11, + "negatives": 2730, + "auroc": 0.8782883782883782, + "auprc": 0.04376555064719024, + "brier": 0.004023238870790232, + "calibration": { + "observed_rate": 0.004013133892739876, + "mean_prediction": 0.0050504681899623685, + "calibration_in_the_large": 0.0010373342972224923, + "expected_calibration_error_10bin": 0.0010373342972224925, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + } + ], + "reason": null + }, + "F12": { + "time_averaged_auroc": 0.9017819389633158, + "time_averaged_auprc": 0.02471406607286643, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2777, + "positives": 5, + "negatives": 2772, + "auroc": 0.9434343434343434, + "auprc": 0.0208145202691981, + "brier": 0.0017867499208269937, + "calibration": { + "observed_rate": 0.0018005041411595247, + "mean_prediction": 0.0011196377654663298, + "calibration_in_the_large": -0.0006808663756931949, + "expected_calibration_error_10bin": 0.0006808663756931949, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 8, + "negatives": 2769, + "auroc": 0.9087667027807873, + "auprc": 0.019871207080874267, + "brier": 0.002859912160194408, + "calibration": { + "observed_rate": 0.0028808066258552397, + "mean_prediction": 0.0014398199381053546, + "calibration_in_the_large": -0.001440986687749885, + "expected_calibration_error_10bin": 0.001440986687749885, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 10, + "negatives": 2767, + "auroc": 0.9000361402240694, + "auprc": 0.0246638239645944, + "brier": 0.003567648159949805, + "calibration": { + "observed_rate": 0.0036010082823190494, + "mean_prediction": 0.001797859459289909, + "calibration_in_the_large": -0.0018031488230291404, + "expected_calibration_error_10bin": 0.0018031488230291404, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 10, + "negatives": 2767, + "auroc": 0.8968196602818937, + "auprc": 0.023728474189544456, + "brier": 0.0035665604066273593, + "calibration": { + "observed_rate": 0.0036010082823190494, + "mean_prediction": 0.002077336412103227, + "calibration_in_the_large": -0.0015236718702158225, + "expected_calibration_error_10bin": 0.0015236718702158225, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 10, + "negatives": 2767, + "auroc": 0.9007950849295265, + "auprc": 0.024981610711261905, + "brier": 0.003562789288644232, + "calibration": { + "observed_rate": 0.0036010082823190494, + "mean_prediction": 0.0025144426478592823, + "calibration_in_the_large": -0.0010865656344597671, + "expected_calibration_error_10bin": 0.0010865656344597671, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 11, + "negatives": 2766, + "auroc": 0.8969959902714784, + "auprc": 0.02468955805660947, + "brier": 0.003919010806228045, + "calibration": { + "observed_rate": 0.003961109110550955, + "mean_prediction": 0.002812901922371678, + "calibration_in_the_large": -0.0011482071881792765, + "expected_calibration_error_10bin": 0.0011482071881792765, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 12, + "negatives": 2765, + "auroc": 0.8947257383966245, + "auprc": 0.02462017341005383, + "brier": 0.004275140740568771, + "calibration": { + "observed_rate": 0.004321209938782859, + "mean_prediction": 0.003056400612340908, + "calibration_in_the_large": -0.0012648093264419511, + "expected_calibration_error_10bin": 0.0012648093264419511, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 12, + "negatives": 2765, + "auroc": 0.8949668474984931, + "auprc": 0.02505284553775028, + "brier": 0.0042752906967690706, + "calibration": { + "observed_rate": 0.004321209938782859, + "mean_prediction": 0.0032052260983836374, + "calibration_in_the_large": -0.0011159838403992216, + "expected_calibration_error_10bin": 0.0011159838403992216, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 12, + "negatives": 2765, + "auroc": 0.8964737793851718, + "auprc": 0.02565779324845498, + "brier": 0.004273990059032741, + "calibration": { + "observed_rate": 0.004321209938782859, + "mean_prediction": 0.0035551182258492945, + "calibration_in_the_large": -0.0007660917129335646, + "expected_calibration_error_10bin": 0.0008416335600986932, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 12, + "negatives": 2765, + "auroc": 0.8963833634719711, + "auprc": 0.02560245378641403, + "brier": 0.004274158382561639, + "calibration": { + "observed_rate": 0.004321209938782859, + "mean_prediction": 0.003664919623374639, + "calibration_in_the_large": -0.0006562903154082203, + "expected_calibration_error_10bin": 0.0007329114262587653, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 12, + "negatives": 2765, + "auroc": 0.8944243520192887, + "auprc": 0.025091053647632037, + "brier": 0.004276717248317689, + "calibration": { + "observed_rate": 0.004321209938782859, + "mean_prediction": 0.003864246879013099, + "calibration_in_the_large": -0.0004569630597697602, + "expected_calibration_error_10bin": 0.0005368471815028467, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 13, + "negatives": 2764, + "auroc": 0.8996159412223088, + "auprc": 0.028247657480170885, + "brier": 0.0046221772969836546, + "calibration": { + "observed_rate": 0.004681310767014764, + "mean_prediction": 0.003997738250832523, + "calibration_in_the_large": -0.0006835725161822414, + "expected_calibration_error_10bin": 0.0007654711439802754, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 13, + "negatives": 2764, + "auroc": 0.8997272626071469, + "auprc": 0.028261687564704936, + "brier": 0.0046222096144222045, + "calibration": { + "observed_rate": 0.004681310767014764, + "mean_prediction": 0.004022491788642208, + "calibration_in_the_large": -0.000658818978372556, + "expected_calibration_error_10bin": 0.0007409635316724532, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + } + ], + "reason": null + }, + "F14": { + "time_averaged_auroc": 0.9531547743714717, + "time_averaged_auprc": 0.04386404356916976, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2787, + "positives": 4, + "negatives": 2783, + "auroc": 0.9771828961552281, + "auprc": 0.04084889511360099, + "brier": 0.001426023161772527, + "calibration": { + "observed_rate": 0.0014352350197344816, + "mean_prediction": 0.00033946911981366616, + "calibration_in_the_large": -0.0010957658999208154, + "expected_calibration_error_10bin": 0.0010957658999208154, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 4, + "negatives": 2783, + "auroc": 0.9771828961552281, + "auprc": 0.040399263998006245, + "brier": 0.0014208742570854152, + "calibration": { + "observed_rate": 0.0014352350197344816, + "mean_prediction": 0.0006108810772703796, + "calibration_in_the_large": -0.000824353942464102, + "expected_calibration_error_10bin": 0.000824353942464102, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 8, + "negatives": 2779, + "auroc": 0.948452680820439, + "auprc": 0.04227602908796281, + "brier": 0.0028439753887716094, + "calibration": { + "observed_rate": 0.0028704700394689632, + "mean_prediction": 0.0007846000699405181, + "calibration_in_the_large": -0.002085869969528445, + "expected_calibration_error_10bin": 0.002085869969528445, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 8, + "negatives": 2779, + "auroc": 0.9483177401943145, + "auprc": 0.041753151398341036, + "brier": 0.0028421473358636526, + "calibration": { + "observed_rate": 0.0028704700394689632, + "mean_prediction": 0.0008869216925774526, + "calibration_in_the_large": -0.0019835483468915107, + "expected_calibration_error_10bin": 0.0019835483468915107, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 9, + "negatives": 2778, + "auroc": 0.9474842012638989, + "auprc": 0.041284751801929004, + "brier": 0.003197565637233751, + "calibration": { + "observed_rate": 0.0032292787944025836, + "mean_prediction": 0.0010240873385982305, + "calibration_in_the_large": -0.002205191455804353, + "expected_calibration_error_10bin": 0.002205191455804353, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 9, + "negatives": 2778, + "auroc": 0.947244220462363, + "auprc": 0.04055648450899321, + "brier": 0.003197043762941404, + "calibration": { + "observed_rate": 0.0032292787944025836, + "mean_prediction": 0.0011055177718553371, + "calibration_in_the_large": -0.0021237610225472462, + "expected_calibration_error_10bin": 0.0021237610225472462, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 9, + "negatives": 2778, + "auroc": 0.9461643068554516, + "auprc": 0.0393738384758511, + "brier": 0.003196911620703519, + "calibration": { + "observed_rate": 0.0032292787944025836, + "mean_prediction": 0.001208536595433522, + "calibration_in_the_large": -0.0020207421989690616, + "expected_calibration_error_10bin": 0.0020207421989690616, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 9, + "negatives": 2778, + "auroc": 0.9460843132549396, + "auprc": 0.03912304106733373, + "brier": 0.003196454785336325, + "calibration": { + "observed_rate": 0.0032292787944025836, + "mean_prediction": 0.0013267578188423804, + "calibration_in_the_large": -0.0019025209755602031, + "expected_calibration_error_10bin": 0.0019025209755602031, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 10, + "negatives": 2777, + "auroc": 0.9505221462009362, + "auprc": 0.04901292615797006, + "brier": 0.0035390569144883965, + "calibration": { + "observed_rate": 0.003588087549336204, + "mean_prediction": 0.0014322032450231547, + "calibration_in_the_large": -0.002155884304313049, + "expected_calibration_error_10bin": 0.002155884304313049, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 10, + "negatives": 2777, + "auroc": 0.9504861361181131, + "auprc": 0.04887091669997306, + "brier": 0.0035382428243063983, + "calibration": { + "observed_rate": 0.003588087549336204, + "mean_prediction": 0.0014766176611323994, + "calibration_in_the_large": -0.0021114698882038043, + "expected_calibration_error_10bin": 0.0021114698882038043, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 10, + "negatives": 2777, + "auroc": 0.9504141159524667, + "auprc": 0.048870731331837135, + "brier": 0.003537670530347967, + "calibration": { + "observed_rate": 0.003588087549336204, + "mean_prediction": 0.0015172582665508457, + "calibration_in_the_large": -0.0020708292827853582, + "expected_calibration_error_10bin": 0.0020708292827853582, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 10, + "negatives": 2777, + "auroc": 0.9507742167806986, + "auprc": 0.04894086479608696, + "brier": 0.0035371822561759, + "calibration": { + "observed_rate": 0.003588087549336204, + "mean_prediction": 0.001586769635784324, + "calibration_in_the_large": -0.00200131791355188, + "expected_calibration_error_10bin": 0.00200131791355188, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 10, + "negatives": 2777, + "auroc": 0.9507021966150522, + "auprc": 0.04892167196132146, + "brier": 0.0035369275512002534, + "calibration": { + "observed_rate": 0.003588087549336204, + "mean_prediction": 0.0016005843752221391, + "calibration_in_the_large": -0.001987503174114065, + "expected_calibration_error_10bin": 0.001987503174114065, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + } + ], + "reason": null + }, + "F15": { + "time_averaged_auroc": 0.9661015069089365, + "time_averaged_auprc": 0.06120458230838636, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2823, + "positives": 4, + "negatives": 2819, + "auroc": 0.9852784675416815, + "auprc": 0.07059576023391813, + "brier": 0.0014073477231448417, + "calibration": { + "observed_rate": 0.0014169323414806943, + "mean_prediction": 0.00018654697625461084, + "calibration_in_the_large": -0.0012303853652260834, + "expected_calibration_error_10bin": 0.0012303853652260834, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 5, + "negatives": 2818, + "auroc": 0.9801277501774308, + "auprc": 0.06034802270422732, + "brier": 0.0017600593200430112, + "calibration": { + "observed_rate": 0.001771165426850868, + "mean_prediction": 0.00021450131379724605, + "calibration_in_the_large": -0.001556664113053622, + "expected_calibration_error_10bin": 0.001556664113053622, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 5, + "negatives": 2818, + "auroc": 0.979985805535841, + "auprc": 0.05755768361081455, + "brier": 0.0017568203989402024, + "calibration": { + "observed_rate": 0.001771165426850868, + "mean_prediction": 0.0002942619104538982, + "calibration_in_the_large": -0.0014769035163969698, + "expected_calibration_error_10bin": 0.0014769035163969698, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.9643829132647024, + "auprc": 0.050293739575308465, + "brier": 0.002110663156190062, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0003077409971369417, + "calibration_in_the_large": -0.0018176575150840996, + "expected_calibration_error_10bin": 0.0018176575150840996, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.9631996213465862, + "auprc": 0.04978348203228184, + "brier": 0.0021081952059674772, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.00038090552316717697, + "calibration_in_the_large": -0.0017444929890538642, + "expected_calibration_error_10bin": 0.0017444929890538642, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.962312152407999, + "auprc": 0.049083945200244006, + "brier": 0.002107428741446621, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.00041918159348651695, + "calibration_in_the_large": -0.0017062169187345244, + "expected_calibration_error_10bin": 0.0017062169187345244, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.9598864039758609, + "auprc": 0.045207026560794235, + "brier": 0.0021071388682831122, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.00047940023690268177, + "calibration_in_the_large": -0.0016459982753183596, + "expected_calibration_error_10bin": 0.0016459982753183596, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.9578748077150633, + "auprc": 0.04167403606769058, + "brier": 0.0021066664536938872, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0005441197282664174, + "calibration_in_the_large": -0.001581278783954624, + "expected_calibration_error_10bin": 0.001581278783954624, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.9593539226127086, + "auprc": 0.045026533411905774, + "brier": 0.00210426639111829, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0006022963206962164, + "calibration_in_the_large": -0.0015231021915248248, + "expected_calibration_error_10bin": 0.0015231021915248248, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.9610696958939771, + "auprc": 0.045969096166763444, + "brier": 0.002100735368247352, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0006948468601482472, + "calibration_in_the_large": -0.0014305516520727942, + "expected_calibration_error_10bin": 0.0014305516520727942, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.9605372145308247, + "auprc": 0.04571991567669157, + "brier": 0.002100719467735235, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.000710074540024372, + "calibration_in_the_large": -0.0014153239721966693, + "expected_calibration_error_10bin": 0.0014153239721966693, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 8, + "negatives": 2815, + "auroc": 0.9625666074600355, + "auprc": 0.11708001957964861, + "brier": 0.002783111937523737, + "calibration": { + "observed_rate": 0.0028338646829613886, + "mean_prediction": 0.0007254460924495117, + "calibration_in_the_large": -0.0021084185905118767, + "expected_calibration_error_10bin": 0.0021084185905118767, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 8, + "negatives": 2815, + "auroc": 0.9627442273534635, + "auprc": 0.11732030918873412, + "brier": 0.002781694080467573, + "calibration": { + "observed_rate": 0.0028338646829613886, + "mean_prediction": 0.0007407961948973407, + "calibration_in_the_large": -0.002093068488064048, + "expected_calibration_error_10bin": 0.002093068488064048, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + } + ], + "reason": null + }, + "F17": { + "time_averaged_auroc": 0.8735403029389972, + "time_averaged_auprc": 0.09324814952526965, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2426, + "positives": 13, + "negatives": 2413, + "auroc": 0.8745576843380407, + "auprc": 0.0938430876064622, + "brier": 0.005168942846855446, + "calibration": { + "observed_rate": 0.0053586150041220115, + "mean_prediction": 0.004880520753296521, + "calibration_in_the_large": -0.0004780942508254907, + "expected_calibration_error_10bin": 0.000478094250825491, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + { + "valid": 2426, + "positives": 19, + "negatives": 2407, + "auroc": 0.8820763999737607, + "auprc": 0.08585445582502872, + "brier": 0.007515357092282297, + "calibration": { + "observed_rate": 0.007831821929101401, + "mean_prediction": 0.006578561823556532, + "calibration_in_the_large": -0.0012532601055448688, + "expected_calibration_error_10bin": 0.0018472140519029672, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + { + "valid": 2426, + "positives": 22, + "negatives": 2404, + "auroc": 0.8830736651036152, + "auprc": 0.09289347691980812, + "brier": 0.008633237534261482, + "calibration": { + "observed_rate": 0.009068425391591096, + "mean_prediction": 0.008528141960199619, + "calibration_in_the_large": -0.0005402834313914771, + "expected_calibration_error_10bin": 0.0013684301693479273, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + { + "valid": 2426, + "positives": 25, + "negatives": 2401, + "auroc": 0.8894793835901708, + "auprc": 0.09839658771315112, + "brier": 0.009782769387737563, + "calibration": { + "observed_rate": 0.010305028854080791, + "mean_prediction": 0.009344634922879054, + "calibration_in_the_large": -0.0009603939312017376, + "expected_calibration_error_10bin": 0.002313529916283716, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + { + "valid": 2426, + "positives": 25, + "negatives": 2401, + "auroc": 0.8911453561016244, + "auprc": 0.09731770607063968, + "brier": 0.009781504744288239, + "calibration": { + "observed_rate": 0.010305028854080791, + "mean_prediction": 0.009874704150600915, + "calibration_in_the_large": -0.00043032470347987607, + "expected_calibration_error_10bin": 0.001942168632275335, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + { + "valid": 2426, + "positives": 25, + "negatives": 2401, + "auroc": 0.8919283631820075, + "auprc": 0.09725459618677533, + "brier": 0.009778214723433381, + "calibration": { + "observed_rate": 0.010305028854080791, + "mean_prediction": 0.010493403668507706, + "calibration_in_the_large": 0.00018837481442691463, + "expected_calibration_error_10bin": 0.0014494406012357552, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + { + "valid": 2426, + "positives": 27, + "negatives": 2399, + "auroc": 0.8882404705664397, + "auprc": 0.0940820126347879, + "brier": 0.010581446685759383, + "calibration": { + "observed_rate": 0.011129431162407255, + "mean_prediction": 0.011194337326676261, + "calibration_in_the_large": 6.490616426900638e-05, + "expected_calibration_error_10bin": 0.00093375738667553, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + { + "valid": 2426, + "positives": 30, + "negatives": 2396, + "auroc": 0.8585002782415136, + "auprc": 0.08763241236741477, + "brier": 0.011799270967061518, + "calibration": { + "observed_rate": 0.01236603462489695, + "mean_prediction": 0.01177337785118612, + "calibration_in_the_large": -0.0005926567737108302, + "expected_calibration_error_10bin": 0.001756300588475459, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + { + "valid": 2426, + "positives": 32, + "negatives": 2394, + "auroc": 0.8562291144527987, + "auprc": 0.0887097818041189, + "brier": 0.01257475474006477, + "calibration": { + "observed_rate": 0.013190436933223413, + "mean_prediction": 0.012479642987894685, + "calibration_in_the_large": -0.000710793945328728, + "expected_calibration_error_10bin": 0.0020349988775667164, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + { + "valid": 2426, + "positives": 33, + "negatives": 2393, + "auroc": 0.8600336841038889, + "auprc": 0.0937398737403406, + "brier": 0.012929433844865732, + "calibration": { + "observed_rate": 0.013602638087386645, + "mean_prediction": 0.01302606839053114, + "calibration_in_the_large": -0.0005765696968555046, + "expected_calibration_error_10bin": 0.0017333739646240198, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + { + "valid": 2426, + "positives": 33, + "negatives": 2393, + "auroc": 0.8596284618014663, + "auprc": 0.09340907139532803, + "brier": 0.012930450930284736, + "calibration": { + "observed_rate": 0.013602638087386645, + "mean_prediction": 0.013517138963278847, + "calibration_in_the_large": -8.549912410779799e-05, + "expected_calibration_error_10bin": 0.0013183566091139944, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + { + "valid": 2426, + "positives": 33, + "negatives": 2393, + "auroc": 0.8606288543605719, + "auprc": 0.09465675716890376, + "brier": 0.012925309472616383, + "calibration": { + "observed_rate": 0.013602638087386645, + "mean_prediction": 0.014217515756265335, + "calibration_in_the_large": 0.0006148776688786901, + "expected_calibration_error_10bin": 0.0010857589048652477, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + { + "valid": 2426, + "positives": 33, + "negatives": 2393, + "auroc": 0.8605022223910649, + "auprc": 0.0944361243957464, + "brier": 0.012926164303176575, + "calibration": { + "observed_rate": 0.013602638087386645, + "mean_prediction": 0.01428535861368268, + "calibration_in_the_large": 0.0006827205262960358, + "expected_calibration_error_10bin": 0.0010288931850084046, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + } + ], + "reason": null + }, + "F19": { + "time_averaged_auroc": 0.9661276341715751, + "time_averaged_auprc": 0.14348891213232928, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2801, + "positives": 6, + "negatives": 2795, + "auroc": 0.9768634466308885, + "auprc": 0.19239426612307967, + "brier": 0.0020892739854102174, + "calibration": { + "observed_rate": 0.0021420921099607284, + "mean_prediction": 0.0005222175708940907, + "calibration_in_the_large": -0.0016198745390666376, + "expected_calibration_error_10bin": 0.0016198745390666376, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 8, + "negatives": 2793, + "auroc": 0.9652703186537773, + "auprc": 0.16071445966270065, + "brier": 0.0027841195372997713, + "calibration": { + "observed_rate": 0.002856122813280971, + "mean_prediction": 0.0006877157105065095, + "calibration_in_the_large": -0.0021684071027744615, + "expected_calibration_error_10bin": 0.0021684071027744615, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 8, + "negatives": 2793, + "auroc": 0.9640171858216972, + "auprc": 0.1490612467666717, + "brier": 0.002777747884576193, + "calibration": { + "observed_rate": 0.002856122813280971, + "mean_prediction": 0.0007748727412935234, + "calibration_in_the_large": -0.002081250071987448, + "expected_calibration_error_10bin": 0.002081250071987448, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 9, + "negatives": 2792, + "auroc": 0.964541547277937, + "auprc": 0.13861940876708806, + "brier": 0.0031161813012768494, + "calibration": { + "observed_rate": 0.0032131381649410924, + "mean_prediction": 0.0009442429278560592, + "calibration_in_the_large": -0.002268895237085033, + "expected_calibration_error_10bin": 0.002268895237085033, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 10, + "negatives": 2791, + "auroc": 0.9653529201003225, + "auprc": 0.13130458111649865, + "brier": 0.0034524764870177715, + "calibration": { + "observed_rate": 0.003570153516601214, + "mean_prediction": 0.0011558255334266235, + "calibration_in_the_large": -0.0024143279831745903, + "expected_calibration_error_10bin": 0.0024143279831745903, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 10, + "negatives": 2791, + "auroc": 0.9655678968111788, + "auprc": 0.13730662252290943, + "brier": 0.0034404110521934657, + "calibration": { + "observed_rate": 0.003570153516601214, + "mean_prediction": 0.001315942234483017, + "calibration_in_the_large": -0.0022542112821181967, + "expected_calibration_error_10bin": 0.0022542112821181967, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 10, + "negatives": 2791, + "auroc": 0.9648871372268004, + "auprc": 0.13691170507944855, + "brier": 0.0034321135115382, + "calibration": { + "observed_rate": 0.003570153516601214, + "mean_prediction": 0.0014295244828349276, + "calibration_in_the_large": -0.0021406290337662864, + "expected_calibration_error_10bin": 0.0021406290337662864, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 11, + "negatives": 2790, + "auroc": 0.9660149885956337, + "auprc": 0.13660644756478366, + "brier": 0.0037695129573725836, + "calibration": { + "observed_rate": 0.003927168868261335, + "mean_prediction": 0.0015674477918228666, + "calibration_in_the_large": -0.002359721076438469, + "expected_calibration_error_10bin": 0.002359721076438469, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 13, + "negatives": 2788, + "auroc": 0.966284074605452, + "auprc": 0.1384781517653411, + "brier": 0.00446385786571948, + "calibration": { + "observed_rate": 0.0046411995715815784, + "mean_prediction": 0.0016593975185778685, + "calibration_in_the_large": -0.00298180205300371, + "expected_calibration_error_10bin": 0.00298180205300371, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 13, + "negatives": 2788, + "auroc": 0.9663392561527425, + "auprc": 0.13886371469662567, + "brier": 0.0044555326847396624, + "calibration": { + "observed_rate": 0.0046411995715815784, + "mean_prediction": 0.0017642450486251328, + "calibration_in_the_large": -0.0028769545229564457, + "expected_calibration_error_10bin": 0.0028769545229564457, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 13, + "negatives": 2788, + "auroc": 0.9662564838318066, + "auprc": 0.14425151835426187, + "brier": 0.004449256034834294, + "calibration": { + "observed_rate": 0.0046411995715815784, + "mean_prediction": 0.0018483005202617887, + "calibration_in_the_large": -0.0027928990513197897, + "expected_calibration_error_10bin": 0.0027928990513197897, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 13, + "negatives": 2788, + "auroc": 0.9641319942611191, + "auprc": 0.1304629118270728, + "brier": 0.0044432773013112605, + "calibration": { + "observed_rate": 0.0046411995715815784, + "mean_prediction": 0.0020028431890727924, + "calibration_in_the_large": -0.002638356382508786, + "expected_calibration_error_10bin": 0.002638356382508786, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 13, + "negatives": 2788, + "auroc": 0.9641319942611191, + "auprc": 0.13038082347379917, + "brier": 0.004443154307569562, + "calibration": { + "observed_rate": 0.0046411995715815784, + "mean_prediction": 0.0020077210350274, + "calibration_in_the_large": -0.0026334785365541786, + "expected_calibration_error_10bin": 0.0026334785365541786, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + } + ], + "reason": null + }, + "F20": { + "time_averaged_auroc": 0.8166184681308373, + "time_averaged_auprc": 0.018039749525495127, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2808, + "positives": 0, + "negatives": 2808, + "auroc": null, + "auprc": null, + "brier": 1.9633565381693165e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00015679541127844247, + "calibration_in_the_large": 0.00015679541127844247, + "expected_calibration_error_10bin": 0.00015679541127844247, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9876890608512136 + }, + { + "valid": 2808, + "positives": 1, + "negatives": 2807, + "auroc": 0.9921624510153189, + "auprc": 0.043478260869565216, + "brier": 0.00035336449244524875, + "calibration": { + "observed_rate": 0.00035612535612535614, + "mean_prediction": 0.0003154247069514416, + "calibration_in_the_large": -4.070064917391456e-05, + "expected_calibration_error_10bin": 4.070064917391456e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + { + "valid": 2808, + "positives": 2, + "negatives": 2806, + "auroc": 0.7576621525302922, + "auprc": 0.019267021512530492, + "brier": 0.0007094383580664572, + "calibration": { + "observed_rate": 0.0007122507122507123, + "mean_prediction": 0.000412424799550467, + "calibration_in_the_large": -0.0002998259127002453, + "expected_calibration_error_10bin": 0.0002998259127002453, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + { + "valid": 2808, + "positives": 2, + "negatives": 2806, + "auroc": 0.7549893086243763, + "auprc": 0.019258710968555526, + "brier": 0.0007091194537879653, + "calibration": { + "observed_rate": 0.0007122507122507123, + "mean_prediction": 0.0005391206868911432, + "calibration_in_the_large": -0.00017313002535956912, + "expected_calibration_error_10bin": 0.00017313002535956912, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + { + "valid": 2808, + "positives": 3, + "negatives": 2805, + "auroc": 0.806060606060606, + "auprc": 0.015369066763589482, + "brier": 0.0010641977709638735, + "calibration": { + "observed_rate": 0.0010683760683760685, + "mean_prediction": 0.0006095642219124291, + "calibration_in_the_large": -0.00045881184646363936, + "expected_calibration_error_10bin": 0.00045881184646363936, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + { + "valid": 2808, + "positives": 3, + "negatives": 2805, + "auroc": 0.8030897207367795, + "auprc": 0.015263397019516062, + "brier": 0.0010642062477158388, + "calibration": { + "observed_rate": 0.0010683760683760685, + "mean_prediction": 0.000678865195416353, + "calibration_in_the_large": -0.0003895108729597155, + "expected_calibration_error_10bin": 0.0003895108729597155, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + { + "valid": 2808, + "positives": 3, + "negatives": 2805, + "auroc": 0.8009506833036245, + "auprc": 0.015234448571989597, + "brier": 0.0010642221834212349, + "calibration": { + "observed_rate": 0.0010683760683760685, + "mean_prediction": 0.0008274507320051494, + "calibration_in_the_large": -0.0002409253363709191, + "expected_calibration_error_10bin": 0.0002409253363709191, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + { + "valid": 2808, + "positives": 3, + "negatives": 2805, + "auroc": 0.7984551396316102, + "auprc": 0.015185478259683206, + "brier": 0.0010643707891573402, + "calibration": { + "observed_rate": 0.0010683760683760685, + "mean_prediction": 0.0009082461501754663, + "calibration_in_the_large": -0.0001601299182006022, + "expected_calibration_error_10bin": 0.0001601299182006022, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + { + "valid": 2808, + "positives": 3, + "negatives": 2805, + "auroc": 0.7947712418300653, + "auprc": 0.01514229185984911, + "brier": 0.001064538926339842, + "calibration": { + "observed_rate": 0.0010683760683760685, + "mean_prediction": 0.0009611722743564812, + "calibration_in_the_large": -0.00010720379401958733, + "expected_calibration_error_10bin": 0.00010720379401958733, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + { + "valid": 2808, + "positives": 4, + "negatives": 2804, + "auroc": 0.8246255349500713, + "auprc": 0.014692291234105415, + "brier": 0.001418597939562498, + "calibration": { + "observed_rate": 0.0014245014245014246, + "mean_prediction": 0.0010017881552772305, + "calibration_in_the_large": -0.00042271326922419406, + "expected_calibration_error_10bin": 0.00042271326922419406, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + { + "valid": 2808, + "positives": 4, + "negatives": 2804, + "auroc": 0.821950784593438, + "auprc": 0.014536273693064365, + "brier": 0.001418730905736508, + "calibration": { + "observed_rate": 0.0014245014245014246, + "mean_prediction": 0.0010436272124223205, + "calibration_in_the_large": -0.0003808742120791041, + "expected_calibration_error_10bin": 0.0003808742120791041, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + { + "valid": 2808, + "positives": 4, + "negatives": 2804, + "auroc": 0.8223965763195435, + "auprc": 0.014529542580757865, + "brier": 0.0014188194032570157, + "calibration": { + "observed_rate": 0.0014245014245014246, + "mean_prediction": 0.0010891792858973741, + "calibration_in_the_large": -0.0003353221386040504, + "expected_calibration_error_10bin": 0.0003353221386040504, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + { + "valid": 2808, + "positives": 4, + "negatives": 2804, + "auroc": 0.8223074179743224, + "auprc": 0.01452021097273517, + "brier": 0.001418832156763306, + "calibration": { + "observed_rate": 0.0014245014245014246, + "mean_prediction": 0.0010929920802377287, + "calibration_in_the_large": -0.0003315093442636959, + "expected_calibration_error_10bin": 0.0003315093442636959, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + } + ], + "reason": null + }, + "F22": { + "time_averaged_auroc": 0.7497872340425533, + "time_averaged_auprc": 0.0014184587980889572, + "valid_timepoint_cells": 10, + "timepoints": [ + { + "valid": 2821, + "positives": 0, + "negatives": 2821, + "auroc": null, + "auprc": null, + "brier": 7.186541796773733e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.000358207472912005, + "calibration_in_the_large": 0.000358207472912005, + "expected_calibration_error_10bin": 0.000358207472912005, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 0, + "negatives": 2821, + "auroc": null, + "auprc": null, + "brier": 1.2570001338045597e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0005181075270389396, + "calibration_in_the_large": 0.0005181075270389396, + "expected_calibration_error_10bin": 0.0005181075270389396, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 0, + "negatives": 2821, + "auroc": null, + "auprc": null, + "brier": 1.6312538174357724e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0005997795582930727, + "calibration_in_the_large": 0.0005997795582930727, + "expected_calibration_error_10bin": 0.0005997795582930727, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.7354609929078014, + "auprc": 0.0013386880856760374, + "brier": 0.00035590647435943706, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0006546607128618254, + "calibration_in_the_large": 0.000300176487409858, + "expected_calibration_error_10bin": 0.000300176487409858, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.7439716312056738, + "auprc": 0.0013831258644536654, + "brier": 0.00035608692636843046, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0007013884547575445, + "calibration_in_the_large": 0.0003469042293055771, + "expected_calibration_error_10bin": 0.0003469042293055771, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.7400709219858156, + "auprc": 0.0013623978201634877, + "brier": 0.0003564692729831947, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.000784976552647705, + "calibration_in_the_large": 0.0004304923271957376, + "expected_calibration_error_10bin": 0.0004304923271957376, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.7585106382978724, + "auprc": 0.001466275659824047, + "brier": 0.00035685936075563875, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0008689882750800016, + "calibration_in_the_large": 0.0005145040496280343, + "expected_calibration_error_10bin": 0.0005145040496280343, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.7400709219858156, + "auprc": 0.0013623978201634877, + "brier": 0.0003575291276611991, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0009631272075162986, + "calibration_in_the_large": 0.0006086429820643312, + "expected_calibration_error_10bin": 0.0006086429820643312, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.747872340425532, + "auprc": 0.0014044943820224719, + "brier": 0.00035824055113952644, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0010927195775374654, + "calibration_in_the_large": 0.000738235352085498, + "expected_calibration_error_10bin": 0.000738235352085498, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.7464539007092199, + "auprc": 0.0013966480446927375, + "brier": 0.0003586416524580187, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0011473633375391624, + "calibration_in_the_large": 0.000792879112087195, + "expected_calibration_error_10bin": 0.000792879112087195, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.7450354609929078, + "auprc": 0.001388888888888889, + "brier": 0.0003591152494035595, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0012013625169700135, + "calibration_in_the_large": 0.0008468782915180462, + "expected_calibration_error_10bin": 0.0008468782915180462, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.7705673758865248, + "auprc": 0.0015432098765432098, + "brier": 0.0003602695960660801, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0013223042336128691, + "calibration_in_the_large": 0.0009678200081609017, + "expected_calibration_error_10bin": 0.0009678200081609017, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.7698581560283688, + "auprc": 0.0015384615384615385, + "brier": 0.000360310652673649, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.001327071938779342, + "calibration_in_the_large": 0.0009725877133273746, + "expected_calibration_error_10bin": 0.0009725877133273746, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + } + ], + "reason": null + }, + "F25": { + "time_averaged_auroc": 0.8052454355470753, + "time_averaged_auprc": 0.007013165249662482, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2819, + "positives": 1, + "negatives": 2818, + "auroc": 0.9779985805535841, + "auprc": 0.015873015873015872, + "brier": 0.00035396205286104343, + "calibration": { + "observed_rate": 0.000354735721887194, + "mean_prediction": 0.000226588722552583, + "calibration_in_the_large": -0.000128146999334611, + "expected_calibration_error_10bin": 0.000128146999334611, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 2, + "negatives": 2817, + "auroc": 0.8127440539581114, + "auprc": 0.009068532193289286, + "brier": 0.0007084943694291216, + "calibration": { + "observed_rate": 0.000709471443774388, + "mean_prediction": 0.00031319331564271424, + "calibration_in_the_large": -0.0003962781281316738, + "expected_calibration_error_10bin": 0.0003962781281316738, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 2, + "negatives": 2817, + "auroc": 0.806354277600284, + "auprc": 0.008906440041260604, + "brier": 0.0007091109033616983, + "calibration": { + "observed_rate": 0.000709471443774388, + "mean_prediction": 0.0004812019670206513, + "calibration_in_the_large": -0.00022826947675373677, + "expected_calibration_error_10bin": 0.00022826947675373677, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7765151515151515, + "auprc": 0.006712159693949494, + "brier": 0.001063830796452406, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0005415552756447525, + "calibration_in_the_large": -0.0005226518900168296, + "expected_calibration_error_10bin": 0.0005226518900168296, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7971117424242424, + "auprc": 0.005895363254745083, + "brier": 0.0010644579656421778, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0006845738962117341, + "calibration_in_the_large": -0.00037963326944984795, + "expected_calibration_error_10bin": 0.00037963326944984795, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7926136363636364, + "auprc": 0.006082863877901634, + "brier": 0.0010651140465036512, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0007854460855524378, + "calibration_in_the_large": -0.00027876108010914424, + "expected_calibration_error_10bin": 0.00027876108010914424, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7901278409090909, + "auprc": 0.006009457016636274, + "brier": 0.0010652014843384686, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.000804698287945645, + "calibration_in_the_large": -0.000259508877715937, + "expected_calibration_error_10bin": 0.000259508877715937, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7885890151515151, + "auprc": 0.005854660324322205, + "brier": 0.0010654874370677777, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0008546609478624707, + "calibration_in_the_large": -0.00020954621779911134, + "expected_calibration_error_10bin": 0.00020954621779911134, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7889441287878788, + "auprc": 0.005352763644445852, + "brier": 0.0010661543713314683, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0009504074874665928, + "calibration_in_the_large": -0.00011379967819498925, + "expected_calibration_error_10bin": 0.00011379967819498925, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7872869318181818, + "auprc": 0.0055141412784142745, + "brier": 0.0010668803285155406, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0010290198024410922, + "calibration_in_the_large": -3.518736322048982e-05, + "expected_calibration_error_10bin": 3.518736322048982e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.78515625, + "auprc": 0.005385549705891911, + "brier": 0.001067014464395827, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0010493518526376697, + "calibration_in_the_large": -1.485531302391238e-05, + "expected_calibration_error_10bin": 1.485531302391238e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7825520833333334, + "auprc": 0.005259741721190362, + "brier": 0.001068119224988776, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0011332723031841972, + "calibration_in_the_large": 6.906513752261514e-05, + "expected_calibration_error_10bin": 6.906513752261514e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7821969696969697, + "auprc": 0.005256459620549397, + "brier": 0.0010681543382391279, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0011375861841593404, + "calibration_in_the_large": 7.337901849775838e-05, + "expected_calibration_error_10bin": 7.337901849775838e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + } + ], + "reason": null + }, + "F29": { + "time_averaged_auroc": 0.7520781480051538, + "time_averaged_auprc": 0.007684253738004138, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2806, + "positives": 3, + "negatives": 2803, + "auroc": 0.7734570103460578, + "auprc": 0.0035550749228473455, + "brier": 0.0010686678872460107, + "calibration": { + "observed_rate": 0.0010691375623663579, + "mean_prediction": 0.00018687211599953326, + "calibration_in_the_large": -0.0008822654463668246, + "expected_calibration_error_10bin": 0.0008822654463668246, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 5, + "negatives": 2801, + "auroc": 0.8197786504819707, + "auprc": 0.006895779540274946, + "brier": 0.0017800368490208179, + "calibration": { + "observed_rate": 0.001781895937277263, + "mean_prediction": 0.0003721550521196388, + "calibration_in_the_large": -0.0014097408851576243, + "expected_calibration_error_10bin": 0.0014097408851576243, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 6, + "negatives": 2800, + "auroc": 0.7242857142857143, + "auprc": 0.006163112255292743, + "brier": 0.002136251278939009, + "calibration": { + "observed_rate": 0.0021382751247327157, + "mean_prediction": 0.00043347784429147705, + "calibration_in_the_large": -0.0017047972804412387, + "expected_calibration_error_10bin": 0.0017047972804412387, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 7, + "negatives": 2799, + "auroc": 0.7262797938039096, + "auprc": 0.006465350381960069, + "brier": 0.0024920781894529806, + "calibration": { + "observed_rate": 0.0024946543121881683, + "mean_prediction": 0.0005216427713319106, + "calibration_in_the_large": -0.0019730115408562576, + "expected_calibration_error_10bin": 0.0019730115408562576, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 7, + "negatives": 2799, + "auroc": 0.7210738529066504, + "auprc": 0.006231725882978329, + "brier": 0.002492088636713055, + "calibration": { + "observed_rate": 0.0024946543121881683, + "mean_prediction": 0.0005402019282033767, + "calibration_in_the_large": -0.0019544523839847916, + "expected_calibration_error_10bin": 0.0019544523839847916, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 7, + "negatives": 2799, + "auroc": 0.7258204460776808, + "auprc": 0.006302579458523601, + "brier": 0.002491989357346362, + "calibration": { + "observed_rate": 0.0024946543121881683, + "mean_prediction": 0.0005751231002497911, + "calibration_in_the_large": -0.0019195312119383774, + "expected_calibration_error_10bin": 0.0019195312119383774, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 7, + "negatives": 2799, + "auroc": 0.7257183688051855, + "auprc": 0.006182053731198724, + "brier": 0.002491862446089049, + "calibration": { + "observed_rate": 0.0024946543121881683, + "mean_prediction": 0.000647613452361561, + "calibration_in_the_large": -0.0018470408598266074, + "expected_calibration_error_10bin": 0.0018470408598266074, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 7, + "negatives": 2799, + "auroc": 0.7210738529066504, + "auprc": 0.006048873031160097, + "brier": 0.002491892167799549, + "calibration": { + "observed_rate": 0.0024946543121881683, + "mean_prediction": 0.0006672654630086112, + "calibration_in_the_large": -0.001827388849179557, + "expected_calibration_error_10bin": 0.001827388849179557, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7573266619013581, + "auprc": 0.0096248210876531, + "brier": 0.002844834927268325, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.0007172954899849504, + "calibration_in_the_large": -0.0021337380096586706, + "expected_calibration_error_10bin": 0.0021337380096586706, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7629110078627591, + "auprc": 0.010136458841637188, + "brier": 0.0028440113534710055, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.0008051672162091705, + "calibration_in_the_large": -0.0020458662834344503, + "expected_calibration_error_10bin": 0.0020458662834344503, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7680039313795568, + "auprc": 0.010231828331681197, + "brier": 0.0028437096311750205, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.0008426388603597555, + "calibration_in_the_large": -0.0020083946392838656, + "expected_calibration_error_10bin": 0.0020083946392838656, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7759560400285919, + "auprc": 0.011056957660844018, + "brier": 0.002842375198035855, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.0010014091169486179, + "calibration_in_the_large": -0.001849624382695003, + "expected_calibration_error_10bin": 0.001849624382695003, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7753305932809149, + "auprc": 0.01100068346800245, + "brier": 0.0028423754493362525, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.001020150101752434, + "calibration_in_the_large": -0.001830883397891187, + "expected_calibration_error_10bin": 0.001830883397891187, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + } + ], + "reason": null + }, + "F31": { + "time_averaged_auroc": 0.8546247283188068, + "time_averaged_auprc": 0.033109352463792284, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2724, + "positives": 5, + "negatives": 2719, + "auroc": 0.8931224714968738, + "auprc": 0.016052859015979, + "brier": 0.0018256131926110075, + "calibration": { + "observed_rate": 0.0018355359765051395, + "mean_prediction": 0.0011247984468118455, + "calibration_in_the_large": -0.0007107375296932939, + "expected_calibration_error_10bin": 0.0007107375296932939, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + { + "valid": 2724, + "positives": 7, + "negatives": 2717, + "auroc": 0.8365318891634681, + "auprc": 0.03376255683167551, + "brier": 0.0025426060754416163, + "calibration": { + "observed_rate": 0.0025697503671071953, + "mean_prediction": 0.001374021576877364, + "calibration_in_the_large": -0.0011957287902298313, + "expected_calibration_error_10bin": 0.0011957287902298313, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + { + "valid": 2724, + "positives": 7, + "negatives": 2717, + "auroc": 0.8469951101530049, + "auprc": 0.031351311772159586, + "brier": 0.0025414906547455377, + "calibration": { + "observed_rate": 0.0025697503671071953, + "mean_prediction": 0.0016927425128512546, + "calibration_in_the_large": -0.0008770078542559407, + "expected_calibration_error_10bin": 0.0008770078542559407, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + { + "valid": 2724, + "positives": 8, + "negatives": 2716, + "auroc": 0.8587536818851251, + "auprc": 0.03780911544442593, + "brier": 0.0028945655037213003, + "calibration": { + "observed_rate": 0.002936857562408223, + "mean_prediction": 0.0019823898601503587, + "calibration_in_the_large": -0.0009544677022578643, + "expected_calibration_error_10bin": 0.0009544677022578643, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + { + "valid": 2724, + "positives": 8, + "negatives": 2716, + "auroc": 0.8587997054491899, + "auprc": 0.036986590004020985, + "brier": 0.0028933200186461983, + "calibration": { + "observed_rate": 0.002936857562408223, + "mean_prediction": 0.002176701651756442, + "calibration_in_the_large": -0.0007601559106517812, + "expected_calibration_error_10bin": 0.0007601559106517812, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + { + "valid": 2724, + "positives": 8, + "negatives": 2716, + "auroc": 0.8552558910162003, + "auprc": 0.036920600116885235, + "brier": 0.0028934109338826547, + "calibration": { + "observed_rate": 0.002936857562408223, + "mean_prediction": 0.0022913713854559024, + "calibration_in_the_large": -0.0006454861769523207, + "expected_calibration_error_10bin": 0.0006454861769523207, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + { + "valid": 2724, + "positives": 8, + "negatives": 2716, + "auroc": 0.854611561119293, + "auprc": 0.03594622934849237, + "brier": 0.0028930784411328263, + "calibration": { + "observed_rate": 0.002936857562408223, + "mean_prediction": 0.0025629943952808175, + "calibration_in_the_large": -0.00037386316712740555, + "expected_calibration_error_10bin": 0.00037386316712740555, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + { + "valid": 2724, + "positives": 8, + "negatives": 2716, + "auroc": 0.8493188512518409, + "auprc": 0.035493594412706546, + "brier": 0.002893636320290228, + "calibration": { + "observed_rate": 0.002936857562408223, + "mean_prediction": 0.002715530413942589, + "calibration_in_the_large": -0.0002213271484656342, + "expected_calibration_error_10bin": 0.0002213271484656342, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + { + "valid": 2724, + "positives": 8, + "negatives": 2716, + "auroc": 0.8467875552282769, + "auprc": 0.03442130987455626, + "brier": 0.002893872857886495, + "calibration": { + "observed_rate": 0.002936857562408223, + "mean_prediction": 0.0029622335456283154, + "calibration_in_the_large": 2.5375983220092373e-05, + "expected_calibration_error_10bin": 2.5375983220092373e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + { + "valid": 2724, + "positives": 9, + "negatives": 2715, + "auroc": 0.8550439942705136, + "auprc": 0.03343233759421324, + "brier": 0.0032551493787464163, + "calibration": { + "observed_rate": 0.003303964757709251, + "mean_prediction": 0.0032119541733483642, + "calibration_in_the_large": -9.201058436088694e-05, + "expected_calibration_error_10bin": 9.201058436088694e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + { + "valid": 2724, + "positives": 9, + "negatives": 2715, + "auroc": 0.8527521997135257, + "auprc": 0.03279670142809012, + "brier": 0.003255790985271357, + "calibration": { + "observed_rate": 0.003303964757709251, + "mean_prediction": 0.0033293288695260474, + "calibration_in_the_large": 2.5364111816796216e-05, + "expected_calibration_error_10bin": 2.5364111816796216e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + { + "valid": 2724, + "positives": 9, + "negatives": 2715, + "auroc": 0.8513607530182116, + "auprc": 0.0327079019906461, + "brier": 0.003256800458807034, + "calibration": { + "observed_rate": 0.003303964757709251, + "mean_prediction": 0.0034991369746544564, + "calibration_in_the_large": 0.00019517221694520526, + "expected_calibration_error_10bin": 0.00019517221694520526, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + { + "valid": 2724, + "positives": 9, + "negatives": 2715, + "auroc": 0.8507878043789646, + "auprc": 0.032740474195448815, + "brier": 0.003256908592866931, + "calibration": { + "observed_rate": 0.003303964757709251, + "mean_prediction": 0.0035253251844658256, + "calibration_in_the_large": 0.0002213604267565744, + "expected_calibration_error_10bin": 0.0002213604267565744, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + } + ], + "reason": null + }, + "F32": { + "time_averaged_auroc": 0.7092033474133994, + "time_averaged_auprc": 0.06457406416878898, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2200, + "positives": 16, + "negatives": 2184, + "auroc": 0.6871565934065934, + "auprc": 0.02537710550005707, + "brier": 0.007344154136464515, + "calibration": { + "observed_rate": 0.007272727272727273, + "mean_prediction": 0.012888302964645184, + "calibration_in_the_large": 0.005615575691917911, + "expected_calibration_error_10bin": 0.005615575691917911, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + { + "valid": 2200, + "positives": 29, + "negatives": 2171, + "auroc": 0.7245032481456186, + "auprc": 0.046910741543430085, + "brier": 0.0129859596996316, + "calibration": { + "observed_rate": 0.013181818181818182, + "mean_prediction": 0.019723094734257426, + "calibration_in_the_large": 0.006541276552439244, + "expected_calibration_error_10bin": 0.006541276552439244, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + { + "valid": 2200, + "positives": 36, + "negatives": 2164, + "auroc": 0.7090521667693571, + "auprc": 0.05153386644176028, + "brier": 0.016087157025959732, + "calibration": { + "observed_rate": 0.016363636363636365, + "mean_prediction": 0.02333804415687072, + "calibration_in_the_large": 0.006974407793234355, + "expected_calibration_error_10bin": 0.006974407793234354, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + { + "valid": 2200, + "positives": 40, + "negatives": 2160, + "auroc": 0.7005208333333334, + "auprc": 0.05273132352007076, + "brier": 0.017897576520676875, + "calibration": { + "observed_rate": 0.01818181818181818, + "mean_prediction": 0.02597279036475811, + "calibration_in_the_large": 0.007790972182939931, + "expected_calibration_error_10bin": 0.00779097218293993, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + { + "valid": 2200, + "positives": 45, + "negatives": 2155, + "auroc": 0.6978499613302398, + "auprc": 0.05655804065333569, + "brier": 0.02008690535657108, + "calibration": { + "observed_rate": 0.020454545454545454, + "mean_prediction": 0.028577385467784055, + "calibration_in_the_large": 0.0081228400132386, + "expected_calibration_error_10bin": 0.008122840013238602, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + { + "valid": 2200, + "positives": 47, + "negatives": 2153, + "auroc": 0.6928481781976658, + "auprc": 0.05595672375785261, + "brier": 0.02110048533942111, + "calibration": { + "observed_rate": 0.021363636363636362, + "mean_prediction": 0.031176308580748314, + "calibration_in_the_large": 0.009812672217111951, + "expected_calibration_error_10bin": 0.00981267221711195, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + { + "valid": 2200, + "positives": 53, + "negatives": 2147, + "auroc": 0.7065233630076192, + "auprc": 0.06386784720278224, + "brier": 0.023612409327876928, + "calibration": { + "observed_rate": 0.02409090909090909, + "mean_prediction": 0.03405258944469758, + "calibration_in_the_large": 0.009961680353788489, + "expected_calibration_error_10bin": 0.00996168035378849, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + { + "valid": 2200, + "positives": 56, + "negatives": 2144, + "auroc": 0.7064065831556503, + "auprc": 0.06861263576240247, + "brier": 0.02488740493999048, + "calibration": { + "observed_rate": 0.025454545454545455, + "mean_prediction": 0.0358809934776615, + "calibration_in_the_large": 0.010426448023116045, + "expected_calibration_error_10bin": 0.010426448023116045, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + { + "valid": 2200, + "positives": 60, + "negatives": 2140, + "auroc": 0.7188395638629284, + "auprc": 0.07833237674085103, + "brier": 0.02641402903956916, + "calibration": { + "observed_rate": 0.02727272727272727, + "mean_prediction": 0.037635397435673935, + "calibration_in_the_large": 0.010362670162946664, + "expected_calibration_error_10bin": 0.010362670162946664, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + { + "valid": 2200, + "positives": 66, + "negatives": 2134, + "auroc": 0.7159907415296356, + "auprc": 0.082116716450268, + "brier": 0.028924998189938263, + "calibration": { + "observed_rate": 0.03, + "mean_prediction": 0.03949591207222759, + "calibration_in_the_large": 0.009495912072227594, + "expected_calibration_error_10bin": 0.009495912072227589, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + { + "valid": 2200, + "positives": 68, + "negatives": 2132, + "auroc": 0.712166151638892, + "auprc": 0.08099173816812799, + "brier": 0.02989601156792764, + "calibration": { + "observed_rate": 0.03090909090909091, + "mean_prediction": 0.04105929955395616, + "calibration_in_the_large": 0.010150208644865249, + "expected_calibration_error_10bin": 0.01015020864486525, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + { + "valid": 2200, + "positives": 72, + "negatives": 2128, + "auroc": 0.7237168441938179, + "auprc": 0.08831650194277756, + "brier": 0.03143300419245595, + "calibration": { + "observed_rate": 0.03272727272727273, + "mean_prediction": 0.04254516236759214, + "calibration_in_the_large": 0.009817889640319412, + "expected_calibration_error_10bin": 0.009817889640319417, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + { + "valid": 2200, + "positives": 72, + "negatives": 2128, + "auroc": 0.7240692878028404, + "auprc": 0.08815721651054101, + "brier": 0.031454709405306175, + "calibration": { + "observed_rate": 0.03272727272727273, + "mean_prediction": 0.042916376883248716, + "calibration_in_the_large": 0.010189104155975987, + "expected_calibration_error_10bin": 0.010189104155975987, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + } + ], + "reason": null + }, + "F33": { + "time_averaged_auroc": 0.7869257777906353, + "time_averaged_auprc": 0.01284882829737332, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2800, + "positives": 6, + "negatives": 2794, + "auroc": 0.7987950369840133, + "auprc": 0.011287032342103648, + "brier": 0.0021454553209119885, + "calibration": { + "observed_rate": 0.002142857142857143, + "mean_prediction": 0.0013980702991193538, + "calibration_in_the_large": -0.0007447868437377892, + "expected_calibration_error_10bin": 0.0007447868437377892, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 7, + "negatives": 2793, + "auroc": 0.7940258810291033, + "auprc": 0.01089298198199697, + "brier": 0.0025057501577909124, + "calibration": { + "observed_rate": 0.0025, + "mean_prediction": 0.0017289169844785387, + "calibration_in_the_large": -0.0007710830155214614, + "expected_calibration_error_10bin": 0.0007710830155214614, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 7, + "negatives": 2793, + "auroc": 0.7792440284384431, + "auprc": 0.010011575579401761, + "brier": 0.0025092012373483788, + "calibration": { + "observed_rate": 0.0025, + "mean_prediction": 0.0020195366195626513, + "calibration_in_the_large": -0.0004804633804373487, + "expected_calibration_error_10bin": 0.0004804633804373487, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 7, + "negatives": 2793, + "auroc": 0.7777095800726306, + "auprc": 0.009952290449986852, + "brier": 0.002512120152828131, + "calibration": { + "observed_rate": 0.0025, + "mean_prediction": 0.002221230707303091, + "calibration_in_the_large": -0.00027876929269690914, + "expected_calibration_error_10bin": 0.00027876929269690914, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 7, + "negatives": 2793, + "auroc": 0.7678891105314306, + "auprc": 0.00932421444659277, + "brier": 0.002515565394990297, + "calibration": { + "observed_rate": 0.0025, + "mean_prediction": 0.002418472089363734, + "calibration_in_the_large": -8.152791063626612e-05, + "expected_calibration_error_10bin": 8.152791063626612e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 9, + "negatives": 2791, + "auroc": 0.7915522114733867, + "auprc": 0.012731127806678406, + "brier": 0.003216652344591163, + "calibration": { + "observed_rate": 0.0032142857142857142, + "mean_prediction": 0.0025908967643226786, + "calibration_in_the_large": -0.0006233889499630356, + "expected_calibration_error_10bin": 0.0006233889499630356, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 11, + "negatives": 2789, + "auroc": 0.7881938785488445, + "auprc": 0.014589965890413763, + "brier": 0.003923999734581666, + "calibration": { + "observed_rate": 0.003928571428571429, + "mean_prediction": 0.002721103754586563, + "calibration_in_the_large": -0.001207467673984866, + "expected_calibration_error_10bin": 0.001207467673984866, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 11, + "negatives": 2789, + "auroc": 0.7858144007301412, + "auprc": 0.014312161256099288, + "brier": 0.003927164880250189, + "calibration": { + "observed_rate": 0.003928571428571429, + "mean_prediction": 0.0029433343712064793, + "calibration_in_the_large": -0.0009852370573649495, + "expected_calibration_error_10bin": 0.0009852370573649495, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 11, + "negatives": 2789, + "auroc": 0.7834023273248802, + "auprc": 0.014029437284194058, + "brier": 0.003929106138386079, + "calibration": { + "observed_rate": 0.003928571428571429, + "mean_prediction": 0.003052557144874299, + "calibration_in_the_large": -0.0008760142836971296, + "expected_calibration_error_10bin": 0.0008760142836971296, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 12, + "negatives": 2788, + "auroc": 0.7924736967957915, + "auprc": 0.015211382646314253, + "brier": 0.004285103429936338, + "calibration": { + "observed_rate": 0.004285714285714286, + "mean_prediction": 0.00322703494356704, + "calibration_in_the_large": -0.0010586793421472457, + "expected_calibration_error_10bin": 0.0010586793421472457, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 12, + "negatives": 2788, + "auroc": 0.7923840267814443, + "auprc": 0.015130864130146159, + "brier": 0.004286677401291494, + "calibration": { + "observed_rate": 0.004285714285714286, + "mean_prediction": 0.003345826927486217, + "calibration_in_the_large": -0.0009398873582280691, + "expected_calibration_error_10bin": 0.0009398873582280691, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 12, + "negatives": 2788, + "auroc": 0.7896341463414634, + "auprc": 0.014825971214755094, + "brier": 0.0042903017269537705, + "calibration": { + "observed_rate": 0.004285714285714286, + "mean_prediction": 0.0035179729539361556, + "calibration_in_the_large": -0.0007677413317781303, + "expected_calibration_error_10bin": 0.0007677413317781303, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + { + "valid": 2800, + "positives": 12, + "negatives": 2788, + "auroc": 0.7889167862266858, + "auprc": 0.014735762837170154, + "brier": 0.004291410450640203, + "calibration": { + "observed_rate": 0.004285714285714286, + "mean_prediction": 0.0035552100694517972, + "calibration_in_the_large": -0.0007305042162624887, + "expected_calibration_error_10bin": 0.0008020527164938229, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + } + ], + "reason": null + }, + "F39": { + "time_averaged_auroc": 0.7566110336044537, + "time_averaged_auprc": 0.019815535336763626, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2801, + "positives": 5, + "negatives": 2796, + "auroc": 0.8170243204577968, + "auprc": 0.012407380316201868, + "brier": 0.0017802378735668988, + "calibration": { + "observed_rate": 0.001785076758300607, + "mean_prediction": 0.0005902562642060657, + "calibration_in_the_large": -0.0011948204940945414, + "expected_calibration_error_10bin": 0.0011948204940945414, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 6, + "negatives": 2795, + "auroc": 0.8403697078115683, + "auprc": 0.019562510430772045, + "brier": 0.0021323504373585564, + "calibration": { + "observed_rate": 0.0021420921099607284, + "mean_prediction": 0.000808368301869375, + "calibration_in_the_large": -0.0013337238080913534, + "expected_calibration_error_10bin": 0.0013337238080913534, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 7, + "negatives": 2794, + "auroc": 0.7324879844564884, + "auprc": 0.01754211139146753, + "brier": 0.0024855151297189697, + "calibration": { + "observed_rate": 0.0024991074616208496, + "mean_prediction": 0.0013536860039293716, + "calibration_in_the_large": -0.001145421457691478, + "expected_calibration_error_10bin": 0.001145421457691478, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 8, + "negatives": 2793, + "auroc": 0.7575187969924813, + "auprc": 0.024584042764136026, + "brier": 0.002833038154684806, + "calibration": { + "observed_rate": 0.002856122813280971, + "mean_prediction": 0.001838842182109123, + "calibration_in_the_large": -0.0010172806311718483, + "expected_calibration_error_10bin": 0.0010172806311718483, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 8, + "negatives": 2793, + "auroc": 0.74968671679198, + "auprc": 0.02256364892180552, + "brier": 0.0028338670793212764, + "calibration": { + "observed_rate": 0.002856122813280971, + "mean_prediction": 0.002144499025001699, + "calibration_in_the_large": -0.0007116237882792724, + "expected_calibration_error_10bin": 0.0007116237882792724, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 9, + "negatives": 2792, + "auroc": 0.7690226042661573, + "auprc": 0.02334627690220218, + "brier": 0.0031859445033756892, + "calibration": { + "observed_rate": 0.0032131381649410924, + "mean_prediction": 0.002232776119759788, + "calibration_in_the_large": -0.0009803620451813043, + "expected_calibration_error_10bin": 0.0009803620451813043, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 9, + "negatives": 2792, + "auroc": 0.7677093282394142, + "auprc": 0.022550293104149504, + "brier": 0.0031859941048225527, + "calibration": { + "observed_rate": 0.0032131381649410924, + "mean_prediction": 0.0024258716138894918, + "calibration_in_the_large": -0.0007872665510516006, + "expected_calibration_error_10bin": 0.0007872665510516006, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 10, + "negatives": 2791, + "auroc": 0.7744536008599069, + "auprc": 0.021603857487652634, + "brier": 0.003540394596909255, + "calibration": { + "observed_rate": 0.003570153516601214, + "mean_prediction": 0.0025466232698140223, + "calibration_in_the_large": -0.0010235302467871917, + "expected_calibration_error_10bin": 0.0010235302467871917, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 10, + "negatives": 2791, + "auroc": 0.7723754926549624, + "auprc": 0.020603180389777584, + "brier": 0.003541588089299786, + "calibration": { + "observed_rate": 0.003570153516601214, + "mean_prediction": 0.0028393005182135683, + "calibration_in_the_large": -0.0007308529983876457, + "expected_calibration_error_10bin": 0.0007308529983876457, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 11, + "negatives": 2790, + "auroc": 0.7157706093189964, + "auprc": 0.01882071861352778, + "brier": 0.003898805181935963, + "calibration": { + "observed_rate": 0.003927168868261335, + "mean_prediction": 0.00295741195296276, + "calibration_in_the_large": -0.0009697569152985752, + "expected_calibration_error_10bin": 0.0009697569152985752, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 11, + "negatives": 2790, + "auroc": 0.7147605083088954, + "auprc": 0.018629410789996328, + "brier": 0.003898880294023865, + "calibration": { + "observed_rate": 0.003927168868261335, + "mean_prediction": 0.00309591087969148, + "calibration_in_the_large": -0.0008312579885698551, + "expected_calibration_error_10bin": 0.0008312579885698551, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 11, + "negatives": 2790, + "auroc": 0.7123492994460736, + "auprc": 0.017666885940494738, + "brier": 0.0039004471620267015, + "calibration": { + "observed_rate": 0.003927168868261335, + "mean_prediction": 0.0032094439148649114, + "calibration_in_the_large": -0.0007177249533964238, + "expected_calibration_error_10bin": 0.0007177249533964238, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 11, + "negatives": 2790, + "auroc": 0.7124144672531769, + "auprc": 0.0177216423257434, + "brier": 0.0039004971984916443, + "calibration": { + "observed_rate": 0.003927168868261335, + "mean_prediction": 0.0032421668715484826, + "calibration_in_the_large": -0.0006850019967128526, + "expected_calibration_error_10bin": 0.0006850019967128526, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + } + ], + "reason": null + }, + "F41": { + "time_averaged_auroc": 0.7193935485890106, + "time_averaged_auprc": 0.09346035026119097, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2247, + "positives": 16, + "negatives": 2231, + "auroc": 0.757675930076199, + "auprc": 0.0364091799320598, + "brier": 0.007004170316305385, + "calibration": { + "observed_rate": 0.007120605251446373, + "mean_prediction": 0.010912821266214099, + "calibration_in_the_large": 0.0037922160147677263, + "expected_calibration_error_10bin": 0.0037922160147677263, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + { + "valid": 2247, + "positives": 34, + "negatives": 2213, + "auroc": 0.7514685946678716, + "auprc": 0.09728731914635558, + "brier": 0.014447652517404404, + "calibration": { + "observed_rate": 0.015131286159323543, + "mean_prediction": 0.016586377436652013, + "calibration_in_the_large": 0.0014550912773284696, + "expected_calibration_error_10bin": 0.002133615831342997, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + { + "valid": 2247, + "positives": 43, + "negatives": 2204, + "auroc": 0.7191997636432702, + "auprc": 0.08127448445302451, + "brier": 0.018264123770466743, + "calibration": { + "observed_rate": 0.01913662661326213, + "mean_prediction": 0.020986191337657938, + "calibration_in_the_large": 0.0018495647243958087, + "expected_calibration_error_10bin": 0.0035472951615357737, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + { + "valid": 2247, + "positives": 51, + "negatives": 2196, + "auroc": 0.7269545340905033, + "auprc": 0.09312184936871, + "brier": 0.021499658906481124, + "calibration": { + "observed_rate": 0.022696929238985315, + "mean_prediction": 0.024329338092597314, + "calibration_in_the_large": 0.001632408853611999, + "expected_calibration_error_10bin": 0.0046132473448315435, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + { + "valid": 2247, + "positives": 61, + "negatives": 2186, + "auroc": 0.7218589234022768, + "auprc": 0.09948883076451906, + "brier": 0.02558335706919687, + "calibration": { + "observed_rate": 0.027147307521139297, + "mean_prediction": 0.02724200656262865, + "calibration_in_the_large": 9.469904148935379e-05, + "expected_calibration_error_10bin": 0.0033722289362909863, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + { + "valid": 2247, + "positives": 66, + "negatives": 2181, + "auroc": 0.7258902644047073, + "auprc": 0.10344624270186306, + "brier": 0.027582935366087115, + "calibration": { + "observed_rate": 0.029372496662216287, + "mean_prediction": 0.029352690991280333, + "calibration_in_the_large": -1.980567093595384e-05, + "expected_calibration_error_10bin": 0.00263244738111386, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + { + "valid": 2247, + "positives": 72, + "negatives": 2175, + "auroc": 0.7130651340996168, + "auprc": 0.10097900110060037, + "brier": 0.03012468277881355, + "calibration": { + "observed_rate": 0.03204272363150868, + "mean_prediction": 0.03163205364364244, + "calibration_in_the_large": -0.0004106699878662426, + "expected_calibration_error_10bin": 0.000491070910719603, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + { + "valid": 2247, + "positives": 74, + "negatives": 2173, + "auroc": 0.7085484011392893, + "auprc": 0.1014658368158152, + "brier": 0.0309487975715953, + "calibration": { + "observed_rate": 0.032932799287939477, + "mean_prediction": 0.0330969305469853, + "calibration_in_the_large": 0.00016413125904582437, + "expected_calibration_error_10bin": 0.0005226491284807458, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + { + "valid": 2247, + "positives": 77, + "negatives": 2170, + "auroc": 0.7044586749655875, + "auprc": 0.10051556293849667, + "brier": 0.03221520836533166, + "calibration": { + "observed_rate": 0.03426791277258567, + "mean_prediction": 0.03466319298845416, + "calibration_in_the_large": 0.00039528021586849454, + "expected_calibration_error_10bin": 0.0028329421079112045, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + { + "valid": 2247, + "positives": 78, + "negatives": 2169, + "auroc": 0.7060561998321334, + "auprc": 0.10049530945317835, + "brier": 0.03263028525458922, + "calibration": { + "observed_rate": 0.03471295060080107, + "mean_prediction": 0.035790574983505075, + "calibration_in_the_large": 0.0010776243827040066, + "expected_calibration_error_10bin": 0.0033560369054330542, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + { + "valid": 2247, + "positives": 78, + "negatives": 2169, + "auroc": 0.7062394344552021, + "auprc": 0.09969169517448344, + "brier": 0.03265341590153064, + "calibration": { + "observed_rate": 0.03471295060080107, + "mean_prediction": 0.03715412480745035, + "calibration_in_the_large": 0.0024411742066492853, + "expected_calibration_error_10bin": 0.00380737318470411, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + { + "valid": 2247, + "positives": 80, + "negatives": 2167, + "auroc": 0.7052953391785879, + "auprc": 0.10043234735630857, + "brier": 0.03348895697816536, + "calibration": { + "observed_rate": 0.035603026257231864, + "mean_prediction": 0.03869997803018187, + "calibration_in_the_large": 0.003096951772950003, + "expected_calibration_error_10bin": 0.00413647238484285, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + { + "valid": 2247, + "positives": 80, + "negatives": 2167, + "auroc": 0.705404937701892, + "auprc": 0.10037689419006797, + "brier": 0.03349468273243087, + "calibration": { + "observed_rate": 0.035603026257231864, + "mean_prediction": 0.03900153339957768, + "calibration_in_the_large": 0.0033985071423458177, + "expected_calibration_error_10bin": 0.004124039932662677, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + } + ], + "reason": null + }, + "F43": { + "time_averaged_auroc": 0.7822406375154236, + "time_averaged_auprc": 0.06527701532090233, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2734, + "positives": 6, + "negatives": 2728, + "auroc": 0.9218597262952102, + "auprc": 0.0423821355998247, + "brier": 0.0021531603788734924, + "calibration": { + "observed_rate": 0.0021945866861741038, + "mean_prediction": 0.0024455146227927915, + "calibration_in_the_large": 0.00025092793661868774, + "expected_calibration_error_10bin": 0.00025092793661868774, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 9, + "negatives": 2725, + "auroc": 0.7976350662589194, + "auprc": 0.07157894308020538, + "brier": 0.003214880937467188, + "calibration": { + "observed_rate": 0.0032918800292611556, + "mean_prediction": 0.004019450856590173, + "calibration_in_the_large": 0.0007275708273290172, + "expected_calibration_error_10bin": 0.0007275708273290172, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 13, + "negatives": 2721, + "auroc": 0.7761004155711984, + "auprc": 0.07583180947674197, + "brier": 0.00465858764705935, + "calibration": { + "observed_rate": 0.004754937820043892, + "mean_prediction": 0.005003201749342532, + "calibration_in_the_large": 0.0002482639292986401, + "expected_calibration_error_10bin": 0.00024826392929864095, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 15, + "negatives": 2719, + "auroc": 0.7730292999877406, + "auprc": 0.0698825910469436, + "brier": 0.0053747299142471805, + "calibration": { + "observed_rate": 0.005486466715435259, + "mean_prediction": 0.005623955463291992, + "calibration_in_the_large": 0.00013748874785673298, + "expected_calibration_error_10bin": 0.00013748874785673174, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 15, + "negatives": 2719, + "auroc": 0.78146377344612, + "auprc": 0.0705921331907037, + "brier": 0.005373313746450066, + "calibration": { + "observed_rate": 0.005486466715435259, + "mean_prediction": 0.00615014643510445, + "calibration_in_the_large": 0.0006636797196691909, + "expected_calibration_error_10bin": 0.0006636797196691905, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 16, + "negatives": 2718, + "auroc": 0.7940351361295069, + "auprc": 0.08208001257881274, + "brier": 0.005715728246747531, + "calibration": { + "observed_rate": 0.005852231163130944, + "mean_prediction": 0.006727002451085433, + "calibration_in_the_large": 0.0008747712879544891, + "expected_calibration_error_10bin": 0.00087477128795449, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 16, + "negatives": 2718, + "auroc": 0.8000137969094923, + "auprc": 0.07734156976513407, + "brier": 0.005720736044455176, + "calibration": { + "observed_rate": 0.005852231163130944, + "mean_prediction": 0.007287719665019331, + "calibration_in_the_large": 0.0014354885018883871, + "expected_calibration_error_10bin": 0.0014354885018883884, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 18, + "negatives": 2716, + "auroc": 0.7707412862052038, + "auprc": 0.0731684653212303, + "brier": 0.006434895720967603, + "calibration": { + "observed_rate": 0.006583760058522311, + "mean_prediction": 0.007901825011468454, + "calibration_in_the_large": 0.0013180649529461429, + "expected_calibration_error_10bin": 0.0017891717807720386, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 18, + "negatives": 2716, + "auroc": 0.7711708394698086, + "auprc": 0.06339630434385288, + "brier": 0.006440011631717963, + "calibration": { + "observed_rate": 0.006583760058522311, + "mean_prediction": 0.008286110449275503, + "calibration_in_the_large": 0.001702350390753192, + "expected_calibration_error_10bin": 0.002153211860024082, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 20, + "negatives": 2714, + "auroc": 0.7484893146647016, + "auprc": 0.05874346353143761, + "brier": 0.007168251039164135, + "calibration": { + "observed_rate": 0.0073152889539136795, + "mean_prediction": 0.00858051651955186, + "calibration_in_the_large": 0.0012652275656381802, + "expected_calibration_error_10bin": 0.0017040121233891782, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 20, + "negatives": 2714, + "auroc": 0.7489314664701547, + "auprc": 0.05445547058035331, + "brier": 0.007173218105310361, + "calibration": { + "observed_rate": 0.0073152889539136795, + "mean_prediction": 0.008887207674351572, + "calibration_in_the_large": 0.0015719187204378928, + "expected_calibration_error_10bin": 0.0019943065560109785, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 20, + "negatives": 2714, + "auroc": 0.7498710390567428, + "auprc": 0.05644180452557973, + "brier": 0.007177611552156009, + "calibration": { + "observed_rate": 0.0073152889539136795, + "mean_prediction": 0.009270288938128961, + "calibration_in_the_large": 0.001954999984215282, + "expected_calibration_error_10bin": 0.0023604414060917262, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 21, + "negatives": 2713, + "auroc": 0.7357871272357082, + "auprc": 0.052706496130910274, + "brier": 0.007541917292666264, + "calibration": { + "observed_rate": 0.007681053401609363, + "mean_prediction": 0.009316836910295653, + "calibration_in_the_large": 0.0016357835086862902, + "expected_calibration_error_10bin": 0.002039534417261647, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + } + ], + "reason": null + }, + "F60": { + "time_averaged_auroc": 0.9444486510899087, + "time_averaged_auprc": 0.04075720483677733, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2818, + "positives": 2, + "negatives": 2816, + "auroc": 0.9541903409090909, + "auprc": 0.016740576496674056, + "brier": 0.000707398398652512, + "calibration": { + "observed_rate": 0.0007097232079489, + "mean_prediction": 0.00046576865804960984, + "calibration_in_the_large": -0.00024395454989929011, + "expected_calibration_error_10bin": 0.00024395454989929011, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 4, + "negatives": 2814, + "auroc": 0.9582444918265813, + "auprc": 0.030328702883843508, + "brier": 0.0014075567778315513, + "calibration": { + "observed_rate": 0.0014194464158978, + "mean_prediction": 0.0006841929447971513, + "calibration_in_the_large": -0.0007352534711006486, + "expected_calibration_error_10bin": 0.0007352534711006486, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.9442587984358336, + "auprc": 0.026757579878754913, + "brier": 0.0017608073878784911, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.000968161668704063, + "calibration_in_the_large": -0.0008061463511681867, + "expected_calibration_error_10bin": 0.0008061463511681867, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.9414859580519019, + "auprc": 0.025639665802675203, + "brier": 0.001761134928090409, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.001168628119544747, + "calibration_in_the_large": -0.0006056799003275027, + "expected_calibration_error_10bin": 0.0006056799003275027, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.9412015641663705, + "auprc": 0.02597870645606264, + "brier": 0.0017618499848083848, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0013757513417530821, + "calibration_in_the_large": -0.0003985566781191676, + "expected_calibration_error_10bin": 0.0003985566781191676, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.9375044436544614, + "auprc": 0.024893751408401305, + "brier": 0.0017640170882302023, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0015476129466539118, + "calibration_in_the_large": -0.00022669507321833792, + "expected_calibration_error_10bin": 0.00022669507321833792, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.9357980803412727, + "auprc": 0.024722981712310983, + "brier": 0.0017656348632863906, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0016609244222909867, + "calibration_in_the_large": -0.000113383597581263, + "expected_calibration_error_10bin": 0.000113383597581263, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.9349448986846782, + "auprc": 0.024419948859650365, + "brier": 0.0017676255294919907, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0017860558813787438, + "calibration_in_the_large": 1.1747861506494067e-05, + "expected_calibration_error_10bin": 5.9506530126506816e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.9464201043148411, + "auprc": 0.06497211725987322, + "brier": 0.0020702570624802252, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0019099970254097954, + "calibration_in_the_large": -0.00021917259843690431, + "expected_calibration_error_10bin": 0.00029426849673483917, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.9475462304409673, + "auprc": 0.06681427636817895, + "brier": 0.002068838558120871, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.002051100264755601, + "calibration_in_the_large": -7.806935909109892e-05, + "expected_calibration_error_10bin": 0.0001585791961337165, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.9464201043148411, + "auprc": 0.06615853381862243, + "brier": 0.002069080678524142, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0021855872269536973, + "calibration_in_the_large": 5.6417603106997515e-05, + "expected_calibration_error_10bin": 5.641760310699727e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.9449976292081556, + "auprc": 0.06646192145434789, + "brier": 0.002070671809317029, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0023479263830398917, + "calibration_in_the_large": 0.0002187567591931919, + "expected_calibration_error_10bin": 0.00021875675919319184, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.9448198198198198, + "auprc": 0.06595490047871, + "brier": 0.002070854810746044, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.002366461607356305, + "calibration_in_the_large": 0.00023729198350960507, + "expected_calibration_error_10bin": 0.00023729198350960534, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + } + ], + "reason": null + }, + "F90": { + "time_averaged_auroc": 0.8811071757723106, + "time_averaged_auprc": 0.03031681962260121, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2775, + "positives": 3, + "negatives": 2772, + "auroc": 0.7824675324675324, + "auprc": 0.010930268952502443, + "brier": 0.0010798180563237993, + "calibration": { + "observed_rate": 0.001081081081081081, + "mean_prediction": 0.0001998405405513925, + "calibration_in_the_large": -0.0008812405405296886, + "expected_calibration_error_10bin": 0.0008812405405296886, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 5, + "negatives": 2770, + "auroc": 0.8688086642599278, + "auprc": 0.025258052730721108, + "brier": 0.0017957348802108857, + "calibration": { + "observed_rate": 0.0018018018018018018, + "mean_prediction": 0.0003825929787057543, + "calibration_in_the_large": -0.0014192088230960474, + "expected_calibration_error_10bin": 0.0014192088230960474, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 5, + "negatives": 2770, + "auroc": 0.875956678700361, + "auprc": 0.02587721015509417, + "brier": 0.001793720800913963, + "calibration": { + "observed_rate": 0.0018018018018018018, + "mean_prediction": 0.0005162521991351732, + "calibration_in_the_large": -0.0012855496026666286, + "expected_calibration_error_10bin": 0.0012855496026666286, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 6, + "negatives": 2769, + "auroc": 0.8919585891416877, + "auprc": 0.03504862685543015, + "brier": 0.002149310792954949, + "calibration": { + "observed_rate": 0.002162162162162162, + "mean_prediction": 0.0006156787537900954, + "calibration_in_the_large": -0.0015464834083720668, + "expected_calibration_error_10bin": 0.0015464834083720668, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 7, + "negatives": 2768, + "auroc": 0.8948183319570603, + "auprc": 0.03364919146735235, + "brier": 0.002507757184335655, + "calibration": { + "observed_rate": 0.0025225225225225223, + "mean_prediction": 0.0006612352647442111, + "calibration_in_the_large": -0.0018612872577783114, + "expected_calibration_error_10bin": 0.0018612872577783114, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 7, + "negatives": 2768, + "auroc": 0.8921345995045417, + "auprc": 0.03284284931943995, + "brier": 0.002507656548537169, + "calibration": { + "observed_rate": 0.0025225225225225223, + "mean_prediction": 0.0006807762795676706, + "calibration_in_the_large": -0.0018417462429548518, + "expected_calibration_error_10bin": 0.0018417462429548518, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 7, + "negatives": 2768, + "auroc": 0.893270024772915, + "auprc": 0.03341037417532666, + "brier": 0.002505498434144635, + "calibration": { + "observed_rate": 0.0025225225225225223, + "mean_prediction": 0.0007964624550276402, + "calibration_in_the_large": -0.0017260600674948823, + "expected_calibration_error_10bin": 0.0017260600674948823, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 7, + "negatives": 2768, + "auroc": 0.8887799339388934, + "auprc": 0.032136285860320704, + "brier": 0.0025048155305338322, + "calibration": { + "observed_rate": 0.0025225225225225223, + "mean_prediction": 0.0008735195399161852, + "calibration_in_the_large": -0.0016490029826063371, + "expected_calibration_error_10bin": 0.0016490029826063371, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 7, + "negatives": 2768, + "auroc": 0.8847027250206441, + "auprc": 0.031152693974488523, + "brier": 0.0025045871945018807, + "calibration": { + "observed_rate": 0.0025225225225225223, + "mean_prediction": 0.0009286266922657609, + "calibration_in_the_large": -0.0015938958302567615, + "expected_calibration_error_10bin": 0.0015938958302567615, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 8, + "negatives": 2767, + "auroc": 0.8955095771593784, + "auprc": 0.033193906341783874, + "brier": 0.002859458999806959, + "calibration": { + "observed_rate": 0.002882882882882883, + "mean_prediction": 0.0010474637065249022, + "calibration_in_the_large": -0.0018354191763579808, + "expected_calibration_error_10bin": 0.0018354191763579808, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 8, + "negatives": 2767, + "auroc": 0.8965034333212866, + "auprc": 0.03366064669553218, + "brier": 0.00285777289451496, + "calibration": { + "observed_rate": 0.002882882882882883, + "mean_prediction": 0.0011338851081617995, + "calibration_in_the_large": -0.0017489977747210835, + "expected_calibration_error_10bin": 0.0017489977747210835, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 8, + "negatives": 2767, + "auroc": 0.8947867726779906, + "auprc": 0.033489179693629426, + "brier": 0.002857662508927493, + "calibration": { + "observed_rate": 0.002882882882882883, + "mean_prediction": 0.0011549855112651392, + "calibration_in_the_large": -0.0017278973716177437, + "expected_calibration_error_10bin": 0.0017278973716177437, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + { + "valid": 2775, + "positives": 8, + "negatives": 2767, + "auroc": 0.8946964221178171, + "auprc": 0.03346936887219412, + "brier": 0.002857633256758364, + "calibration": { + "observed_rate": 0.002882882882882883, + "mean_prediction": 0.0011594824791966668, + "calibration_in_the_large": -0.0017234004036862161, + "expected_calibration_error_10bin": 0.0017234004036862161, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + } + ], + "reason": null + }, + "G25": { + "time_averaged_auroc": 0.7164114449451593, + "time_averaged_auprc": 0.006281075063162224, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2774, + "positives": 1, + "negatives": 2773, + "auroc": 0.985935809592499, + "auprc": 0.025, + "brier": 0.00035912982666402236, + "calibration": { + "observed_rate": 0.0003604902667627974, + "mean_prediction": 0.0007825514503585172, + "calibration_in_the_large": 0.00042206118359571984, + "expected_calibration_error_10bin": 0.00042206118359571984, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 3, + "negatives": 2771, + "auroc": 0.73042223024179, + "auprc": 0.004500581101898671, + "brier": 0.0010812666562834195, + "calibration": { + "observed_rate": 0.0010814708002883922, + "mean_prediction": 0.0013868475362484591, + "calibration_in_the_large": 0.000305376735960067, + "expected_calibration_error_10bin": 0.000305376735960067, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 4, + "negatives": 2770, + "auroc": 0.6845667870036101, + "auprc": 0.00379359477710247, + "brier": 0.0014451861585640146, + "calibration": { + "observed_rate": 0.0014419610670511895, + "mean_prediction": 0.0018391469400801518, + "calibration_in_the_large": 0.00039718587302896226, + "expected_calibration_error_10bin": 0.00039718587302896226, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 4, + "negatives": 2770, + "auroc": 0.6879061371841155, + "auprc": 0.003857315249546797, + "brier": 0.0014477667914224864, + "calibration": { + "observed_rate": 0.0014419610670511895, + "mean_prediction": 0.002165596042979412, + "calibration_in_the_large": 0.0007236349759282223, + "expected_calibration_error_10bin": 0.0007236349759282223, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 4, + "negatives": 2770, + "auroc": 0.6843862815884476, + "auprc": 0.004017993763354365, + "brier": 0.0014506569086058648, + "calibration": { + "observed_rate": 0.0014419610670511895, + "mean_prediction": 0.0024574540432937323, + "calibration_in_the_large": 0.0010154929762425428, + "expected_calibration_error_10bin": 0.0010154929762425428, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 4, + "negatives": 2770, + "auroc": 0.6765342960288808, + "auprc": 0.003950726967118256, + "brier": 0.001454675638781966, + "calibration": { + "observed_rate": 0.0014419610670511895, + "mean_prediction": 0.002738832771785157, + "calibration_in_the_large": 0.0012968717047339676, + "expected_calibration_error_10bin": 0.0012968717047339676, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 5, + "negatives": 2769, + "auroc": 0.7160707836764175, + "auprc": 0.0048818393409717515, + "brier": 0.0018141385323288777, + "calibration": { + "observed_rate": 0.001802451333813987, + "mean_prediction": 0.0030181648847646173, + "calibration_in_the_large": 0.0012157135509506304, + "expected_calibration_error_10bin": 0.0012157135509506304, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.6990004816955684, + "auprc": 0.005024467947730488, + "brier": 0.002177331931611825, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.0033030383814392195, + "calibration_in_the_large": 0.0011400967808624352, + "expected_calibration_error_10bin": 0.0011400967808624352, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.6971339113680154, + "auprc": 0.004946636217088443, + "brier": 0.0021823176328670136, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.003630492251718414, + "calibration_in_the_large": 0.0014675506511416295, + "expected_calibration_error_10bin": 0.0014675506511416295, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.6980973025048169, + "auprc": 0.0049183250443565335, + "brier": 0.0021854300334644004, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.0038038373711375964, + "calibration_in_the_large": 0.001640895770560812, + "expected_calibration_error_10bin": 0.001640895770560812, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.698759633911368, + "auprc": 0.0048629233272086715, + "brier": 0.0021899328102330516, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.004027227830669429, + "calibration_in_the_large": 0.0018642862300926443, + "expected_calibration_error_10bin": 0.0018642862300926443, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 8, + "negatives": 2766, + "auroc": 0.6687002892263196, + "auprc": 0.005576367603927675, + "brier": 0.002908854464622225, + "calibration": { + "observed_rate": 0.002883922134102379, + "mean_prediction": 0.004252541026416903, + "calibration_in_the_large": 0.0013686188923145238, + "expected_calibration_error_10bin": 0.0013686188923145238, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 9, + "negatives": 2765, + "auroc": 0.68583484026522, + "auprc": 0.0063232044808048, + "brier": 0.0032654789922131303, + "calibration": { + "observed_rate": 0.0032444124008651765, + "mean_prediction": 0.004292635060270814, + "calibration_in_the_large": 0.0010482226594056374, + "expected_calibration_error_10bin": 0.0010482226594056374, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + } + ], + "reason": null + }, + "G31": { + "time_averaged_auroc": 0.7486219582288772, + "time_averaged_auprc": 0.005940475656958964, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2802, + "positives": 0, + "negatives": 2802, + "auroc": null, + "auprc": null, + "brier": 3.1134672150705148e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0007885831621152945, + "calibration_in_the_large": 0.0007885831621152945, + "expected_calibration_error_10bin": 0.0007885831621152945, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 1, + "negatives": 2801, + "auroc": 0.6404855408782578, + "auprc": 0.000992063492063492, + "brier": 0.00038233948463298266, + "calibration": { + "observed_rate": 0.00035688793718772306, + "mean_prediction": 0.0019307026534934955, + "calibration_in_the_large": 0.0015738147163057725, + "expected_calibration_error_10bin": 0.0015738147163057725, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 1, + "negatives": 2801, + "auroc": 0.6197786504819707, + "auprc": 0.0009380863039399625, + "brier": 0.0004006247460592733, + "calibration": { + "observed_rate": 0.00035688793718772306, + "mean_prediction": 0.0025017041484670733, + "calibration_in_the_large": 0.0021448162112793503, + "expected_calibration_error_10bin": 0.00214481621127935, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 1, + "negatives": 2801, + "auroc": 0.6133523741520885, + "auprc": 0.0009225092250922509, + "brier": 0.00042154790164437416, + "calibration": { + "observed_rate": 0.00035688793718772306, + "mean_prediction": 0.0029445555888439577, + "calibration_in_the_large": 0.0025876676516562347, + "expected_calibration_error_10bin": 0.0025876676516562347, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 2, + "negatives": 2800, + "auroc": 0.7069642857142857, + "auprc": 0.0018231676915406348, + "brier": 0.000789360661767265, + "calibration": { + "observed_rate": 0.0007137758743754461, + "mean_prediction": 0.003256330423895274, + "calibration_in_the_large": 0.002542554549519828, + "expected_calibration_error_10bin": 0.002542554549519828, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8120085775553967, + "auprc": 0.005434880160489917, + "brier": 0.001514208153904758, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.0037343433156809503, + "calibration_in_the_large": 0.0023067915669300583, + "expected_calibration_error_10bin": 0.002306791566930058, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 6, + "negatives": 2796, + "auroc": 0.8437649022412971, + "auprc": 0.008685502441611667, + "brier": 0.0022380789129906042, + "calibration": { + "observed_rate": 0.0021413276231263384, + "mean_prediction": 0.004246810964027051, + "calibration_in_the_large": 0.0021054833409007126, + "expected_calibration_error_10bin": 0.002105483340900713, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 7, + "negatives": 2795, + "auroc": 0.8381293125479172, + "auprc": 0.009147373817991248, + "brier": 0.0026124422287101324, + "calibration": { + "observed_rate": 0.0024982155603140615, + "mean_prediction": 0.004606213637081451, + "calibration_in_the_large": 0.002107998076767389, + "expected_calibration_error_10bin": 0.002107998076767389, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 8, + "negatives": 2794, + "auroc": 0.7973783106657122, + "auprc": 0.008736504904996254, + "brier": 0.0029787002418701935, + "calibration": { + "observed_rate": 0.0028551034975017845, + "mean_prediction": 0.004787926721762676, + "calibration_in_the_large": 0.0019328232242608917, + "expected_calibration_error_10bin": 0.0019328232242608917, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 8, + "negatives": 2794, + "auroc": 0.7968861846814602, + "auprc": 0.008760687884495586, + "brier": 0.0030003131018974598, + "calibration": { + "observed_rate": 0.0028551034975017845, + "mean_prediction": 0.0051400842421117305, + "calibration_in_the_large": 0.002284980744609946, + "expected_calibration_error_10bin": 0.0022849807446099456, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.7712137486573577, + "auprc": 0.008574172495218545, + "brier": 0.0033757864097263383, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.005432635410974766, + "calibration_in_the_large": 0.002220643976285259, + "expected_calibration_error_10bin": 0.0022206439762852584, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.7718502605720651, + "auprc": 0.008638330802470022, + "brier": 0.0034131299857010204, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.005865169600329967, + "calibration_in_the_large": 0.0026531781656404596, + "expected_calibration_error_10bin": 0.0026531781656404596, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.771651350598719, + "auprc": 0.008632428663597999, + "brier": 0.0034155297001949468, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.0058956933841223325, + "calibration_in_the_large": 0.002683701949432825, + "expected_calibration_error_10bin": 0.002683701949432825, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + } + ], + "reason": null + }, + "G40": { + "time_averaged_auroc": 0.7386685320774034, + "time_averaged_auprc": 0.04347632167971546, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2723, + "positives": 6, + "negatives": 2717, + "auroc": 0.7615016562384983, + "auprc": 0.027198741548825258, + "brier": 0.0021834221778918943, + "calibration": { + "observed_rate": 0.0022034520749173708, + "mean_prediction": 0.0021622767884910766, + "calibration_in_the_large": -4.117528642629421e-05, + "expected_calibration_error_10bin": 4.117528642629421e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 8, + "negatives": 2715, + "auroc": 0.6589318600368325, + "auprc": 0.019752324779219642, + "brier": 0.0029282725332343868, + "calibration": { + "observed_rate": 0.0029379360998898272, + "mean_prediction": 0.003086811894693884, + "calibration_in_the_large": 0.0001488757948040569, + "expected_calibration_error_10bin": 0.000148875794804057, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 11, + "negatives": 2712, + "auroc": 0.7375972110485385, + "auprc": 0.04032463721521418, + "brier": 0.003979856778925553, + "calibration": { + "observed_rate": 0.004039662137348513, + "mean_prediction": 0.003744128791260435, + "calibration_in_the_large": -0.00029553334608807807, + "expected_calibration_error_10bin": 0.0004553306516200225, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 17, + "negatives": 2706, + "auroc": 0.7555975827137951, + "auprc": 0.05132940346591923, + "brier": 0.006114599620689003, + "calibration": { + "observed_rate": 0.006243114212265883, + "mean_prediction": 0.004454409440079975, + "calibration_in_the_large": -0.0017887047721859076, + "expected_calibration_error_10bin": 0.002046255101538927, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 18, + "negatives": 2705, + "auroc": 0.7218525364551243, + "auprc": 0.04532160801705817, + "brier": 0.006507301961345982, + "calibration": { + "observed_rate": 0.006610356224752111, + "mean_prediction": 0.005460994574194312, + "calibration_in_the_large": -0.0011493616505577993, + "expected_calibration_error_10bin": 0.0014162242972497899, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 20, + "negatives": 2703, + "auroc": 0.7418793932667407, + "auprc": 0.04783283705959561, + "brier": 0.007218647425134686, + "calibration": { + "observed_rate": 0.007344840249724568, + "mean_prediction": 0.006163734201905731, + "calibration_in_the_large": -0.001181106047818837, + "expected_calibration_error_10bin": 0.0014900585264581018, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 21, + "negatives": 2702, + "auroc": 0.747400514609989, + "auprc": 0.047170337093324376, + "brier": 0.007596223451665602, + "calibration": { + "observed_rate": 0.007712082262210797, + "mean_prediction": 0.0069430325401868154, + "calibration_in_the_large": -0.0007690497220239813, + "expected_calibration_error_10bin": 0.0014960730261675307, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 21, + "negatives": 2702, + "auroc": 0.7475415036480914, + "auprc": 0.046895103905450965, + "brier": 0.007604588361590129, + "calibration": { + "observed_rate": 0.007712082262210797, + "mean_prediction": 0.007362112447827558, + "calibration_in_the_large": -0.0003499698143832391, + "expected_calibration_error_10bin": 0.0013505861923408778, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 24, + "negatives": 2699, + "auroc": 0.7460170433493887, + "auprc": 0.0485556518192152, + "brier": 0.008676027243246525, + "calibration": { + "observed_rate": 0.008813808299669483, + "mean_prediction": 0.007824569405283125, + "calibration_in_the_large": -0.0009892388943863583, + "expected_calibration_error_10bin": 0.002059634630269913, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 24, + "negatives": 2699, + "auroc": 0.7451062121773496, + "auprc": 0.047952900807445985, + "brier": 0.008687412405814094, + "calibration": { + "observed_rate": 0.008813808299669483, + "mean_prediction": 0.008128900396315862, + "calibration_in_the_large": -0.0006849079033536213, + "expected_calibration_error_10bin": 0.0012253412365477476, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 24, + "negatives": 2699, + "auroc": 0.7462949240459429, + "auprc": 0.04819369558731573, + "brier": 0.008692197690658212, + "calibration": { + "observed_rate": 0.008813808299669483, + "mean_prediction": 0.008458695459421389, + "calibration_in_the_large": -0.0003551128402480945, + "expected_calibration_error_10bin": 0.0010980992554712615, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 24, + "negatives": 2699, + "auroc": 0.745646535753983, + "auprc": 0.047630048667992884, + "brier": 0.008706738896969693, + "calibration": { + "observed_rate": 0.008813808299669483, + "mean_prediction": 0.00887014924127154, + "calibration_in_the_large": 5.634094160205695e-05, + "expected_calibration_error_10bin": 0.0009318968179334549, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 25, + "negatives": 2698, + "auroc": 0.7473239436619719, + "auprc": 0.047034891869723816, + "brier": 0.00906708974686086, + "calibration": { + "observed_rate": 0.00918105031215571, + "mean_prediction": 0.008884623772311211, + "calibration_in_the_large": -0.00029642653984449964, + "expected_calibration_error_10bin": 0.0012873068941804794, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + } + ], + "reason": null + }, + "G43": { + "time_averaged_auroc": 0.7771706633660572, + "time_averaged_auprc": 0.014683774404856704, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2725, + "positives": 3, + "negatives": 2722, + "auroc": 0.8196179279941219, + "auprc": 0.005464489347010837, + "brier": 0.001099284253773928, + "calibration": { + "observed_rate": 0.0011009174311926607, + "mean_prediction": 0.0009006818050346145, + "calibration_in_the_large": -0.0002002356261580462, + "expected_calibration_error_10bin": 0.0002002356261580462, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + { + "valid": 2725, + "positives": 7, + "negatives": 2718, + "auroc": 0.7881320298538842, + "auprc": 0.010977534502314092, + "brier": 0.002557731577837054, + "calibration": { + "observed_rate": 0.002568807339449541, + "mean_prediction": 0.0015279355733238862, + "calibration_in_the_large": -0.001040871766125655, + "expected_calibration_error_10bin": 0.001040871766125655, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + { + "valid": 2725, + "positives": 8, + "negatives": 2717, + "auroc": 0.8150073610599926, + "auprc": 0.015398309046025384, + "brier": 0.0029177074304990052, + "calibration": { + "observed_rate": 0.0029357798165137615, + "mean_prediction": 0.0018099905335111543, + "calibration_in_the_large": -0.0011257892830026071, + "expected_calibration_error_10bin": 0.0011257892830026071, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + { + "valid": 2725, + "positives": 11, + "negatives": 2714, + "auroc": 0.7597306893548603, + "auprc": 0.013080706309705347, + "brier": 0.004015267453316172, + "calibration": { + "observed_rate": 0.004036697247706422, + "mean_prediction": 0.002119679084948025, + "calibration_in_the_large": -0.001917018162758397, + "expected_calibration_error_10bin": 0.001917018162758397, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + { + "valid": 2725, + "positives": 11, + "negatives": 2714, + "auroc": 0.7592952368191868, + "auprc": 0.013072391006007805, + "brier": 0.004014852716633668, + "calibration": { + "observed_rate": 0.004036697247706422, + "mean_prediction": 0.002315814600891109, + "calibration_in_the_large": -0.001720882646815313, + "expected_calibration_error_10bin": 0.001720882646815313, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + { + "valid": 2725, + "positives": 11, + "negatives": 2714, + "auroc": 0.7592952368191868, + "auprc": 0.013754693122425297, + "brier": 0.004012587121587464, + "calibration": { + "observed_rate": 0.004036697247706422, + "mean_prediction": 0.0026759861798000034, + "calibration_in_the_large": -0.0013607110679064185, + "expected_calibration_error_10bin": 0.0013607110679064185, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + { + "valid": 2725, + "positives": 13, + "negatives": 2712, + "auroc": 0.7513898343544361, + "auprc": 0.014493811259822374, + "brier": 0.004741260265441664, + "calibration": { + "observed_rate": 0.0047706422018348625, + "mean_prediction": 0.002917577705913172, + "calibration_in_the_large": -0.0018530644959216906, + "expected_calibration_error_10bin": 0.0018530644959216906, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + { + "valid": 2725, + "positives": 15, + "negatives": 2710, + "auroc": 0.7741697416974169, + "auprc": 0.01711243418808989, + "brier": 0.00546410721192882, + "calibration": { + "observed_rate": 0.005504587155963303, + "mean_prediction": 0.0032206061324467797, + "calibration_in_the_large": -0.0022839810235165234, + "expected_calibration_error_10bin": 0.0022839810235165234, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + { + "valid": 2725, + "positives": 15, + "negatives": 2710, + "auroc": 0.7745879458794588, + "auprc": 0.01744684483317212, + "brier": 0.005462202711697819, + "calibration": { + "observed_rate": 0.005504587155963303, + "mean_prediction": 0.0034439935697319515, + "calibration_in_the_large": -0.0020605935862313515, + "expected_calibration_error_10bin": 0.0020605935862313515, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + { + "valid": 2725, + "positives": 15, + "negatives": 2710, + "auroc": 0.7753013530135301, + "auprc": 0.017589184460402238, + "brier": 0.005461212531880303, + "calibration": { + "observed_rate": 0.005504587155963303, + "mean_prediction": 0.0036349745773616325, + "calibration_in_the_large": -0.0018696125786016706, + "expected_calibration_error_10bin": 0.0018696125786016706, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + { + "valid": 2725, + "positives": 15, + "negatives": 2710, + "auroc": 0.7755965559655597, + "auprc": 0.01754857105065327, + "brier": 0.005462025228017344, + "calibration": { + "observed_rate": 0.005504587155963303, + "mean_prediction": 0.003795187045978126, + "calibration_in_the_large": -0.001709400109985177, + "expected_calibration_error_10bin": 0.001709400109985177, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + { + "valid": 2725, + "positives": 15, + "negatives": 2710, + "auroc": 0.7754981549815498, + "auprc": 0.017464403809127768, + "brier": 0.005462242134602875, + "calibration": { + "observed_rate": 0.005504587155963303, + "mean_prediction": 0.003950528497946525, + "calibration_in_the_large": -0.0015540586580167779, + "expected_calibration_error_10bin": 0.0015540586580167779, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + { + "valid": 2725, + "positives": 15, + "negatives": 2710, + "auroc": 0.7755965559655597, + "auprc": 0.017485694328380697, + "brier": 0.005462315344600671, + "calibration": { + "observed_rate": 0.005504587155963303, + "mean_prediction": 0.003978578481094809, + "calibration_in_the_large": -0.0015260086748684941, + "expected_calibration_error_10bin": 0.0015260086748684941, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + } + ], + "reason": null + }, + "G44": { + "time_averaged_auroc": 0.7232576975295929, + "time_averaged_auprc": 0.0059619295806451495, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2805, + "positives": 1, + "negatives": 2804, + "auroc": 0.7129101283880172, + "auprc": 0.0012406947890818859, + "brier": 0.00035722476851447754, + "calibration": { + "observed_rate": 0.00035650623885918, + "mean_prediction": 0.0005698580778238248, + "calibration_in_the_large": 0.00021335183896464474, + "expected_calibration_error_10bin": 0.00021335183896464474, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 3, + "negatives": 2802, + "auroc": 0.7831310968355937, + "auprc": 0.0067086841879770605, + "brier": 0.0010695459692888368, + "calibration": { + "observed_rate": 0.0010695187165775401, + "mean_prediction": 0.0008457085308843996, + "calibration_in_the_large": -0.0002238101856931405, + "expected_calibration_error_10bin": 0.0002238101856931405, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 3, + "negatives": 2802, + "auroc": 0.7750416369260053, + "auprc": 0.006199877663481359, + "brier": 0.001070418534595204, + "calibration": { + "observed_rate": 0.0010695187165775401, + "mean_prediction": 0.000952438487706178, + "calibration_in_the_large": -0.00011708022887136217, + "expected_calibration_error_10bin": 0.00011708022887136217, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 3, + "negatives": 2802, + "auroc": 0.7532714727575541, + "auprc": 0.006211561030576389, + "brier": 0.0010720111703934009, + "calibration": { + "observed_rate": 0.0010695187165775401, + "mean_prediction": 0.0011507437460364378, + "calibration_in_the_large": 8.122502945889765e-05, + "expected_calibration_error_10bin": 8.122502945889765e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 4, + "negatives": 2801, + "auroc": 0.7228668332738307, + "auprc": 0.005523900037566922, + "brier": 0.001429143297902415, + "calibration": { + "observed_rate": 0.00142602495543672, + "mean_prediction": 0.001248902391467813, + "calibration_in_the_large": -0.0001771225639689072, + "expected_calibration_error_10bin": 0.0001771225639689072, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 4, + "negatives": 2801, + "auroc": 0.7172438414851838, + "auprc": 0.0053077722896870735, + "brier": 0.0014319475568216893, + "calibration": { + "observed_rate": 0.00142602495543672, + "mean_prediction": 0.0013828625962349426, + "calibration_in_the_large": -4.31623592017775e-05, + "expected_calibration_error_10bin": 4.31623592017775e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 5, + "negatives": 2800, + "auroc": 0.7598571428571429, + "auprc": 0.007168686418716856, + "brier": 0.0017872253317007007, + "calibration": { + "observed_rate": 0.0017825311942959, + "mean_prediction": 0.0014621401483571961, + "calibration_in_the_large": -0.00032039104593870396, + "expected_calibration_error_10bin": 0.00032039104593870396, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 5, + "negatives": 2800, + "auroc": 0.7604285714285715, + "auprc": 0.007204878410899828, + "brier": 0.0017875922450657168, + "calibration": { + "observed_rate": 0.0017825311942959, + "mean_prediction": 0.0015797059165877033, + "calibration_in_the_large": -0.00020282527770819673, + "expected_calibration_error_10bin": 0.00020282527770819673, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 6, + "negatives": 2799, + "auroc": 0.69989281886388, + "auprc": 0.006558336410503109, + "brier": 0.002144834993230762, + "calibration": { + "observed_rate": 0.0021390374331550803, + "mean_prediction": 0.0016641735286433614, + "calibration_in_the_large": -0.00047486390451171884, + "expected_calibration_error_10bin": 0.00047486390451171884, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 7, + "negatives": 2798, + "auroc": 0.6822730521801287, + "auprc": 0.006380319356974281, + "brier": 0.0025023751206187336, + "calibration": { + "observed_rate": 0.0024955436720142605, + "mean_prediction": 0.0017245438425984722, + "calibration_in_the_large": -0.0007709998294157883, + "expected_calibration_error_10bin": 0.0007709998294157883, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 7, + "negatives": 2798, + "auroc": 0.6809455733687327, + "auprc": 0.006338895992797286, + "brier": 0.0025028825615955094, + "calibration": { + "observed_rate": 0.0024955436720142605, + "mean_prediction": 0.001788946519027474, + "calibration_in_the_large": -0.0007065971529867864, + "expected_calibration_error_10bin": 0.0007065971529867864, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 7, + "negatives": 2798, + "auroc": 0.6772694781987134, + "auprc": 0.006330930149963001, + "brier": 0.002506016248946595, + "calibration": { + "observed_rate": 0.0024955436720142605, + "mean_prediction": 0.0019506475425747833, + "calibration_in_the_large": -0.0005448961294394772, + "expected_calibration_error_10bin": 0.0005448961294394772, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + { + "valid": 2805, + "positives": 7, + "negatives": 2798, + "auroc": 0.677218421321352, + "auprc": 0.006330547810161909, + "brier": 0.002506109206825157, + "calibration": { + "observed_rate": 0.0024955436720142605, + "mean_prediction": 0.0019566997965389395, + "calibration_in_the_large": -0.0005388438754753209, + "expected_calibration_error_10bin": 0.0005388438754753209, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + } + ], + "reason": null + }, + "G47": { + "time_averaged_auroc": 0.7015549447370467, + "time_averaged_auprc": 0.0740988509160266, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2315, + "positives": 23, + "negatives": 2292, + "auroc": 0.6951969041657182, + "auprc": 0.0295123114066248, + "brier": 0.009779726991732789, + "calibration": { + "observed_rate": 0.009935205183585313, + "mean_prediction": 0.007993078958376393, + "calibration_in_the_large": -0.0019421262252089198, + "expected_calibration_error_10bin": 0.0019421262252089198, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + { + "valid": 2315, + "positives": 36, + "negatives": 2279, + "auroc": 0.6887279996099653, + "auprc": 0.04553322773211858, + "brier": 0.015146479204913937, + "calibration": { + "observed_rate": 0.015550755939524838, + "mean_prediction": 0.013624608770820472, + "calibration_in_the_large": -0.001926147168704366, + "expected_calibration_error_10bin": 0.0022097956124928486, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + { + "valid": 2315, + "positives": 47, + "negatives": 2268, + "auroc": 0.7175972832001201, + "auprc": 0.0596759189128188, + "brier": 0.019582274546423282, + "calibration": { + "observed_rate": 0.020302375809935207, + "mean_prediction": 0.017486073515055094, + "calibration_in_the_large": -0.002816302294880113, + "expected_calibration_error_10bin": 0.003869477715157173, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + { + "valid": 2315, + "positives": 59, + "negatives": 2256, + "auroc": 0.7060343791321072, + "auprc": 0.06439835680330692, + "brier": 0.02449867511984189, + "calibration": { + "observed_rate": 0.025485961123110152, + "mean_prediction": 0.01972227887477782, + "calibration_in_the_large": -0.005763682248332333, + "expected_calibration_error_10bin": 0.006801482154857005, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + { + "valid": 2315, + "positives": 66, + "negatives": 2249, + "auroc": 0.7114070900198067, + "auprc": 0.07312557661687288, + "brier": 0.027236298320137044, + "calibration": { + "observed_rate": 0.028509719222462204, + "mean_prediction": 0.0215837511746414, + "calibration_in_the_large": -0.006925968047820804, + "expected_calibration_error_10bin": 0.007588626065424223, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + { + "valid": 2315, + "positives": 70, + "negatives": 2245, + "auroc": 0.6999045497931912, + "auprc": 0.07709936314393791, + "brier": 0.028819487022349762, + "calibration": { + "observed_rate": 0.03023758099352052, + "mean_prediction": 0.023503610634694548, + "calibration_in_the_large": -0.006733970358825971, + "expected_calibration_error_10bin": 0.007286135017440392, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + { + "valid": 2315, + "positives": 76, + "negatives": 2239, + "auroc": 0.7103676453303872, + "auprc": 0.08710083976385483, + "brier": 0.031069281367550623, + "calibration": { + "observed_rate": 0.03282937365010799, + "mean_prediction": 0.025830761800906328, + "calibration_in_the_large": -0.006998611849201662, + "expected_calibration_error_10bin": 0.007944617854264315, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + { + "valid": 2315, + "positives": 78, + "negatives": 2237, + "auroc": 0.7106186169664042, + "auprc": 0.0866251960452942, + "brier": 0.03186682799251734, + "calibration": { + "observed_rate": 0.033693304535637146, + "mean_prediction": 0.027719289031418817, + "calibration_in_the_large": -0.0059740155042183295, + "expected_calibration_error_10bin": 0.007162323968231551, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + { + "valid": 2315, + "positives": 82, + "negatives": 2233, + "auroc": 0.6996821513221849, + "auprc": 0.08591205231594834, + "brier": 0.03351843714120547, + "calibration": { + "observed_rate": 0.035421166306695465, + "mean_prediction": 0.029448493297481365, + "calibration_in_the_large": -0.0059726730092140995, + "expected_calibration_error_10bin": 0.007211880447678916, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + { + "valid": 2315, + "positives": 84, + "negatives": 2231, + "auroc": 0.6916661330601268, + "auprc": 0.08369206045639098, + "brier": 0.034365234121902295, + "calibration": { + "observed_rate": 0.03628509719222462, + "mean_prediction": 0.03085062549837722, + "calibration_in_the_large": -0.005434471693847399, + "expected_calibration_error_10bin": 0.006873137592368197, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + { + "valid": 2315, + "positives": 88, + "negatives": 2227, + "auroc": 0.6938400620484141, + "auprc": 0.08704210728783761, + "brier": 0.03591006138994762, + "calibration": { + "observed_rate": 0.03801295896328294, + "mean_prediction": 0.03258719332274814, + "calibration_in_the_large": -0.005425765640534798, + "expected_calibration_error_10bin": 0.0063125958131147455, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + { + "valid": 2315, + "positives": 89, + "negatives": 2226, + "auroc": 0.6976084476614475, + "auprc": 0.09198821688758445, + "brier": 0.036211406227813825, + "calibration": { + "observed_rate": 0.03844492440604751, + "mean_prediction": 0.03365516820892322, + "calibration_in_the_large": -0.004789756197124295, + "expected_calibration_error_10bin": 0.0050479687964563825, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + { + "valid": 2315, + "positives": 89, + "negatives": 2226, + "auroc": 0.6975630192717325, + "auprc": 0.09157983453575547, + "brier": 0.03621535914673906, + "calibration": { + "observed_rate": 0.03844492440604751, + "mean_prediction": 0.033936147940029304, + "calibration_in_the_large": -0.004508776466018209, + "expected_calibration_error_10bin": 0.004802614684291104, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + } + ], + "reason": null + }, + "G51": { + "time_averaged_auroc": null, + "time_averaged_auprc": null, + "valid_timepoint_cells": 0, + "timepoints": [ + { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 4.6965958738453605e-08, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00014442844577666232, + "calibration_in_the_large": 0.00014442844577666232, + "expected_calibration_error_10bin": 0.00014442844577666232, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 1.3917799617747335e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00024578010085277586, + "calibration_in_the_large": 0.00024578010085277586, + "expected_calibration_error_10bin": 0.00024578010085277586, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 2.004267137712584e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.000287026985138277, + "calibration_in_the_large": 0.000287026985138277, + "expected_calibration_error_10bin": 0.000287026985138277, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 2.9814054497279024e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0003550959981283473, + "calibration_in_the_large": 0.0003550959981283473, + "expected_calibration_error_10bin": 0.0003550959981283473, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 5.026460847142919e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004339487593698941, + "calibration_in_the_large": 0.0004339487593698941, + "expected_calibration_error_10bin": 0.0004339487593698941, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 5.384535159495669e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004529534658922592, + "calibration_in_the_large": 0.0004529534658922592, + "expected_calibration_error_10bin": 0.0004529534658922592, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 6.102524525270023e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004944891165741904, + "calibration_in_the_large": 0.0004944891165741904, + "expected_calibration_error_10bin": 0.0004944891165741904, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 7.36849051037564e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0005616606787398506, + "calibration_in_the_large": 0.0005616606787398506, + "expected_calibration_error_10bin": 0.0005616606787398506, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 8.499346412672081e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.000595217910406587, + "calibration_in_the_large": 0.000595217910406587, + "expected_calibration_error_10bin": 0.000595217910406587, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 1.020872277188829e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0006535024206262207, + "calibration_in_the_large": 0.0006535024206262207, + "expected_calibration_error_10bin": 0.0006535024206262207, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 1.1063769451396054e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0006793420999511783, + "calibration_in_the_large": 0.0006793420999511783, + "expected_calibration_error_10bin": 0.0006793420999511783, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 1.234070528121397e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0007192669908348551, + "calibration_in_the_large": 0.0007192669908348551, + "expected_calibration_error_10bin": 0.0007192669908348551, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 1.2410691300132462e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0007211612069084588, + "calibration_in_the_large": 0.0007211612069084588, + "expected_calibration_error_10bin": 0.0007211612069084588, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + } + ], + "reason": "no_two_class_timepoint" + }, + "G62": { + "time_averaged_auroc": 0.8400618089204599, + "time_averaged_auprc": 0.11413972927448718, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2751, + "positives": 7, + "negatives": 2744, + "auroc": 0.8212203248646397, + "auprc": 0.15891577142697472, + "brier": 0.0025072441806071144, + "calibration": { + "observed_rate": 0.002544529262086514, + "mean_prediction": 0.0013403629474295108, + "calibration_in_the_large": -0.0012041663146570034, + "expected_calibration_error_10bin": 0.0012041663146570034, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 13, + "negatives": 2738, + "auroc": 0.8807383266842727, + "auprc": 0.09142689098391338, + "brier": 0.004540088818875144, + "calibration": { + "observed_rate": 0.004725554343874954, + "mean_prediction": 0.0030008423804530285, + "calibration_in_the_large": -0.0017247119634219259, + "expected_calibration_error_10bin": 0.001724711963421926, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 20, + "negatives": 2731, + "auroc": 0.8701025265470523, + "auprc": 0.11622898533869955, + "brier": 0.0068690021140475005, + "calibration": { + "observed_rate": 0.007270083605961469, + "mean_prediction": 0.004341701514869475, + "calibration_in_the_large": -0.0029283820910919935, + "expected_calibration_error_10bin": 0.002928382091091993, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 23, + "negatives": 2728, + "auroc": 0.8722427642483743, + "auprc": 0.129766039221253, + "brier": 0.007846906491515024, + "calibration": { + "observed_rate": 0.008360596146855689, + "mean_prediction": 0.005407722733927505, + "calibration_in_the_large": -0.002952873412928184, + "expected_calibration_error_10bin": 0.003099137729572994, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 27, + "negatives": 2724, + "auroc": 0.8602681242181976, + "auprc": 0.1257723407419296, + "brier": 0.009219995333476767, + "calibration": { + "observed_rate": 0.009814612868047983, + "mean_prediction": 0.0063791764861875645, + "calibration_in_the_large": -0.0034354363818604183, + "expected_calibration_error_10bin": 0.0034354363818604183, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 28, + "negatives": 2723, + "auroc": 0.8591364566392109, + "auprc": 0.12407453503496643, + "brier": 0.009562949207510463, + "calibration": { + "observed_rate": 0.010178117048346057, + "mean_prediction": 0.006903236277206956, + "calibration_in_the_large": -0.0032748807711391005, + "expected_calibration_error_10bin": 0.003274880771139099, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 32, + "negatives": 2719, + "auroc": 0.8244644170650974, + "auprc": 0.10705116347512672, + "brier": 0.010990054301670112, + "calibration": { + "observed_rate": 0.011632133769538349, + "mean_prediction": 0.0075077718620367795, + "calibration_in_the_large": -0.0041243619075015696, + "expected_calibration_error_10bin": 0.0041610554346532234, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 32, + "negatives": 2719, + "auroc": 0.8235794409709452, + "auprc": 0.10518562967508313, + "brier": 0.010976750018675345, + "calibration": { + "observed_rate": 0.011632133769538349, + "mean_prediction": 0.007961717618308401, + "calibration_in_the_large": -0.003670416151229948, + "expected_calibration_error_10bin": 0.00388957750093177, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 33, + "negatives": 2718, + "auroc": 0.8265547305282405, + "auprc": 0.10210304527547395, + "brier": 0.011315706491961782, + "calibration": { + "observed_rate": 0.011995637949836423, + "mean_prediction": 0.008563269660341384, + "calibration_in_the_large": -0.003432368289495039, + "expected_calibration_error_10bin": 0.003559706224768359, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 34, + "negatives": 2717, + "auroc": 0.8290177314945116, + "auprc": 0.10434080560660058, + "brier": 0.01164723741095772, + "calibration": { + "observed_rate": 0.012359142130134497, + "mean_prediction": 0.008890979629603592, + "calibration_in_the_large": -0.0034681625005309052, + "expected_calibration_error_10bin": 0.003763416058414182, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 35, + "negatives": 2716, + "auroc": 0.814927414264675, + "auprc": 0.10200362710933249, + "brier": 0.01199918078937246, + "calibration": { + "observed_rate": 0.01272264631043257, + "mean_prediction": 0.009447717379447024, + "calibration_in_the_large": -0.0032749289309855455, + "expected_calibration_error_10bin": 0.003604403203257649, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 36, + "negatives": 2715, + "auroc": 0.8192960916717823, + "auprc": 0.10858421520132283, + "brier": 0.012292634209056599, + "calibration": { + "observed_rate": 0.013086150490730643, + "mean_prediction": 0.00977144375918599, + "calibration_in_the_large": -0.0033147067315446536, + "expected_calibration_error_10bin": 0.0038694326222225243, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 36, + "negatives": 2715, + "auroc": 0.8192551667689789, + "auprc": 0.10836343147765697, + "brier": 0.012291228229877356, + "calibration": { + "observed_rate": 0.013086150490730643, + "mean_prediction": 0.009843890261075482, + "calibration_in_the_large": -0.0032422602296551615, + "expected_calibration_error_10bin": 0.0038035316354905232, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + } + ], + "reason": null + }, + "G81": { + "time_averaged_auroc": 0.7585263001309663, + "time_averaged_auprc": 0.02786727822028224, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2789, + "positives": 8, + "negatives": 2781, + "auroc": 0.7559780654440849, + "auprc": 0.027142790622865426, + "brier": 0.002858145089443252, + "calibration": { + "observed_rate": 0.0028684116170670493, + "mean_prediction": 0.0006486478635684441, + "calibration_in_the_large": -0.002219763753498605, + "expected_calibration_error_10bin": 0.002219763753498605, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 9, + "negatives": 2780, + "auroc": 0.7690647482014389, + "auprc": 0.025980812689512585, + "brier": 0.0032102059118072363, + "calibration": { + "observed_rate": 0.0032269630692004303, + "mean_prediction": 0.0011189220683895213, + "calibration_in_the_large": -0.0021080410008109092, + "expected_calibration_error_10bin": 0.0021080410008109092, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 10, + "negatives": 2779, + "auroc": 0.7813961856783016, + "auprc": 0.026234954352391447, + "brier": 0.0035649381822054427, + "calibration": { + "observed_rate": 0.0035855145213338113, + "mean_prediction": 0.001531335567776024, + "calibration_in_the_large": -0.0020541789535577872, + "expected_calibration_error_10bin": 0.0020541789535577872, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 10, + "negatives": 2779, + "auroc": 0.780820439006837, + "auprc": 0.02632436111162509, + "brier": 0.003563538344847712, + "calibration": { + "observed_rate": 0.0035855145213338113, + "mean_prediction": 0.0018583895414626993, + "calibration_in_the_large": -0.001727124979871112, + "expected_calibration_error_10bin": 0.001727124979871112, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 11, + "negatives": 2778, + "auroc": 0.7934092545323647, + "auprc": 0.027452544643030964, + "brier": 0.003916028767020749, + "calibration": { + "observed_rate": 0.003944065973467192, + "mean_prediction": 0.0023254910408770572, + "calibration_in_the_large": -0.0016185749325901351, + "expected_calibration_error_10bin": 0.0017759074405617168, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 12, + "negatives": 2777, + "auroc": 0.7425579162165407, + "auprc": 0.025481990524437472, + "brier": 0.004275889294725581, + "calibration": { + "observed_rate": 0.004302617425600574, + "mean_prediction": 0.0024051924008868385, + "calibration_in_the_large": -0.0018974250247137353, + "expected_calibration_error_10bin": 0.0020648167728582684, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 12, + "negatives": 2777, + "auroc": 0.7419577481694875, + "auprc": 0.023645349483604777, + "brier": 0.004275427934347806, + "calibration": { + "observed_rate": 0.004302617425600574, + "mean_prediction": 0.0025777061383480604, + "calibration_in_the_large": -0.0017249112872525134, + "expected_calibration_error_10bin": 0.0018977576511332766, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 14, + "negatives": 2775, + "auroc": 0.75006435006435, + "auprc": 0.030921967926476796, + "brier": 0.004973329660757567, + "calibration": { + "observed_rate": 0.005019720329867336, + "mean_prediction": 0.0027256671420495993, + "calibration_in_the_large": -0.0022940531878177365, + "expected_calibration_error_10bin": 0.0024849522684136, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 14, + "negatives": 2775, + "auroc": 0.747979407979408, + "auprc": 0.030414915074993866, + "brier": 0.004974116517521534, + "calibration": { + "observed_rate": 0.005019720329867336, + "mean_prediction": 0.0029026310421711573, + "calibration_in_the_large": -0.0021170892876961785, + "expected_calibration_error_10bin": 0.002318035469548452, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 14, + "negatives": 2775, + "auroc": 0.7482368082368083, + "auprc": 0.03038392981854321, + "brier": 0.004975832710333216, + "calibration": { + "observed_rate": 0.005019720329867336, + "mean_prediction": 0.003237737936101043, + "calibration_in_the_large": -0.0017819823937662927, + "expected_calibration_error_10bin": 0.002077195095151397, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 14, + "negatives": 2775, + "auroc": 0.7473101673101673, + "auprc": 0.029980220904429113, + "brier": 0.004978655152506802, + "calibration": { + "observed_rate": 0.005019720329867336, + "mean_prediction": 0.003358106880747352, + "calibration_in_the_large": -0.001661613449119984, + "expected_calibration_error_10bin": 0.0019714249554375085, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 15, + "negatives": 2774, + "auroc": 0.7507810622446527, + "auprc": 0.02911608612503125, + "brier": 0.005334921887056448, + "calibration": { + "observed_rate": 0.005378271782000717, + "mean_prediction": 0.00346296603887618, + "calibration_in_the_large": -0.0019153057431245371, + "expected_calibration_error_10bin": 0.002232354228919097, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 15, + "negatives": 2774, + "auroc": 0.7512857486181207, + "auprc": 0.029194693586727202, + "brier": 0.005334626785010273, + "calibration": { + "observed_rate": 0.005378271782000717, + "mean_prediction": 0.003503818986652835, + "calibration_in_the_large": -0.0018744527953478821, + "expected_calibration_error_10bin": 0.0021926880739476288, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + } + ], + "reason": null + }, + "G83": { + "time_averaged_auroc": 0.7185460677974791, + "time_averaged_auprc": 0.00412851640720125, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2824, + "positives": 1, + "negatives": 2823, + "auroc": 0.5614594403117251, + "auprc": 0.0008071025020177562, + "brier": 0.0003548358611778002, + "calibration": { + "observed_rate": 0.0003541076487252125, + "mean_prediction": 0.00036944198777813986, + "calibration_in_the_large": 1.5334339052927375e-05, + "expected_calibration_error_10bin": 1.5334339052927375e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.6371367824238129, + "auprc": 0.0014208910121793453, + "brier": 0.0007098905725789219, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0006118989192999919, + "calibration_in_the_large": -9.63163781504331e-05, + "expected_calibration_error_10bin": 9.63163781504331e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.7359092520382843, + "auprc": 0.004965419101983338, + "brier": 0.001062076582348748, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0007483006996626345, + "calibration_in_the_large": -0.000314022246513003, + "expected_calibration_error_10bin": 0.000314022246513003, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.7455984875339714, + "auprc": 0.004832919736278336, + "brier": 0.0010631760391573443, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0009325635064747062, + "calibration_in_the_large": -0.00012975943970093128, + "expected_calibration_error_10bin": 0.00012975943970093128, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.7424081295049036, + "auprc": 0.004723352704296443, + "brier": 0.0010648054589612876, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0010751586712049639, + "calibration_in_the_large": 1.2835725029326393e-05, + "expected_calibration_error_10bin": 1.2835725029326393e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.7383906416164481, + "auprc": 0.004733533692863606, + "brier": 0.0010653671330907541, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0011293177431070944, + "calibration_in_the_large": 6.699479693145693e-05, + "expected_calibration_error_10bin": 6.699479693145693e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.7409901926030958, + "auprc": 0.004670650267103433, + "brier": 0.0010668476687213217, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0012399802920237573, + "calibration_in_the_large": 0.0001776573458481198, + "expected_calibration_error_10bin": 0.0001776573458481198, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.73992673992674, + "auprc": 0.00466710540503027, + "brier": 0.0010671755739223286, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0012630485596766433, + "calibration_in_the_large": 0.00020072561350100576, + "expected_calibration_error_10bin": 0.00020072561350100576, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.7411083540115798, + "auprc": 0.00468750998597396, + "brier": 0.0010680454750260457, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0013684484224180233, + "calibration_in_the_large": 0.0003061254762423858, + "expected_calibration_error_10bin": 0.0003061254762423858, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.7411083540115798, + "auprc": 0.00455804422270818, + "brier": 0.0010690679225061426, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0014355498801177657, + "calibration_in_the_large": 0.0003732269339421282, + "expected_calibration_error_10bin": 0.0003732269339421282, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.739454094292804, + "auprc": 0.004543500475703865, + "brier": 0.0010698530747128654, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0015009064230563196, + "calibration_in_the_large": 0.00043858347688068206, + "expected_calibration_error_10bin": 0.00043858347688068206, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.738863287250384, + "auprc": 0.0045422112481802975, + "brier": 0.0010702711761306563, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0015250079584006604, + "calibration_in_the_large": 0.00046268501222502287, + "expected_calibration_error_10bin": 0.00046268501222502287, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.7387451258419, + "auprc": 0.004518472939297423, + "brier": 0.0010703611023380618, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0015302497466008862, + "calibration_in_the_large": 0.00046792680042524867, + "expected_calibration_error_10bin": 0.00046792680042524867, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + } + ], + "reason": null + }, + "G89": { + "time_averaged_auroc": 0.7696688977711823, + "time_averaged_auprc": 0.09355651781997007, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2537, + "positives": 15, + "negatives": 2522, + "auroc": 0.7335976738038593, + "auprc": 0.023349194964273495, + "brier": 0.005879625836268523, + "calibration": { + "observed_rate": 0.005912495072920773, + "mean_prediction": 0.008229355443351427, + "calibration_in_the_large": 0.0023168603704306545, + "expected_calibration_error_10bin": 0.002316860370430655, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + { + "valid": 2537, + "positives": 21, + "negatives": 2516, + "auroc": 0.7550722991899462, + "auprc": 0.036079760744903204, + "brier": 0.008210836929718506, + "calibration": { + "observed_rate": 0.008277493102089082, + "mean_prediction": 0.012647368609139389, + "calibration_in_the_large": 0.004369875507050307, + "expected_calibration_error_10bin": 0.004369875507050308, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + { + "valid": 2537, + "positives": 29, + "negatives": 2508, + "auroc": 0.7999230050046747, + "auprc": 0.053191970010511555, + "brier": 0.011217188360877468, + "calibration": { + "observed_rate": 0.011430823807646828, + "mean_prediction": 0.01684684684444988, + "calibration_in_the_large": 0.005416023036803053, + "expected_calibration_error_10bin": 0.0054160230368030535, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + { + "valid": 2537, + "positives": 37, + "negatives": 2500, + "auroc": 0.7708324324324324, + "auprc": 0.07384557315717628, + "brier": 0.014161670030902348, + "calibration": { + "observed_rate": 0.014584154513204573, + "mean_prediction": 0.019852161642251544, + "calibration_in_the_large": 0.005268007129046971, + "expected_calibration_error_10bin": 0.005308688826225573, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + { + "valid": 2537, + "positives": 41, + "negatives": 2496, + "auroc": 0.7876700281425891, + "auprc": 0.09616312528736559, + "brier": 0.015492234937794589, + "calibration": { + "observed_rate": 0.016160819865983445, + "mean_prediction": 0.02183410815291098, + "calibration_in_the_large": 0.005673288286927536, + "expected_calibration_error_10bin": 0.006138988045897008, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + { + "valid": 2537, + "positives": 45, + "negatives": 2492, + "auroc": 0.7567415730337078, + "auprc": 0.08948661763879182, + "brier": 0.017127180061815385, + "calibration": { + "observed_rate": 0.017737485218762318, + "mean_prediction": 0.023736585800390606, + "calibration_in_the_large": 0.0059991005816282875, + "expected_calibration_error_10bin": 0.006272368612724906, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + { + "valid": 2537, + "positives": 50, + "negatives": 2487, + "auroc": 0.7591395255327704, + "auprc": 0.09214800876106917, + "brier": 0.018920603192333324, + "calibration": { + "observed_rate": 0.019708316909735908, + "mean_prediction": 0.025189148182047375, + "calibration_in_the_large": 0.005480831272311467, + "expected_calibration_error_10bin": 0.005718400256157068, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + { + "valid": 2537, + "positives": 57, + "negatives": 2480, + "auroc": 0.7792586304470854, + "auprc": 0.12072919006193175, + "brier": 0.021131000482619157, + "calibration": { + "observed_rate": 0.022467481277098935, + "mean_prediction": 0.02698724439471265, + "calibration_in_the_large": 0.0045197631176137135, + "expected_calibration_error_10bin": 0.005564867740407604, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + { + "valid": 2537, + "positives": 59, + "negatives": 2478, + "auroc": 0.7850918592084923, + "auprc": 0.12385047919954599, + "brier": 0.021811571477377452, + "calibration": { + "observed_rate": 0.023255813953488372, + "mean_prediction": 0.028487987869516805, + "calibration_in_the_large": 0.005232173916028433, + "expected_calibration_error_10bin": 0.006309691554048839, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + { + "valid": 2537, + "positives": 61, + "negatives": 2476, + "auroc": 0.7707831245530867, + "auprc": 0.12023882139716746, + "brier": 0.022637074956436062, + "calibration": { + "observed_rate": 0.02404414662987781, + "mean_prediction": 0.029621454600481906, + "calibration_in_the_large": 0.005577307970604097, + "expected_calibration_error_10bin": 0.0066274977130371185, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + { + "valid": 2537, + "positives": 63, + "negatives": 2474, + "auroc": 0.768769809190181, + "auprc": 0.11792656063979966, + "brier": 0.023420952641165345, + "calibration": { + "observed_rate": 0.024832479306267245, + "mean_prediction": 0.03050637349511497, + "calibration_in_the_large": 0.005673894188847724, + "expected_calibration_error_10bin": 0.00701409602776547, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + { + "valid": 2537, + "positives": 70, + "negatives": 2467, + "auroc": 0.7679830910880769, + "auprc": 0.1335423895655335, + "brier": 0.02560020980132972, + "calibration": { + "observed_rate": 0.027591643673630272, + "mean_prediction": 0.03189305769255554, + "calibration_in_the_large": 0.004301414018925271, + "expected_calibration_error_10bin": 0.004782264000515185, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + { + "valid": 2537, + "positives": 71, + "negatives": 2466, + "auroc": 0.770832619398467, + "auprc": 0.13568304023154135, + "brier": 0.025901223460243632, + "calibration": { + "observed_rate": 0.02798581001182499, + "mean_prediction": 0.03206710614507947, + "calibration_in_the_large": 0.0040812961332544785, + "expected_calibration_error_10bin": 0.004552397219554856, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + } + ], + "reason": null + }, + "G90": { + "time_averaged_auroc": null, + "time_averaged_auprc": null, + "valid_timepoint_cells": 0, + "timepoints": [ + { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 5.657795265382998e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004053380320493589, + "calibration_in_the_large": 0.0004053380320493589, + "expected_calibration_error_10bin": 0.0004053380320493589, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 2.828913399461543e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0008624720113275151, + "calibration_in_the_large": 0.0008624720113275151, + "expected_calibration_error_10bin": 0.0008624720113275151, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 4.066742082029411e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0010641545609615802, + "calibration_in_the_large": 0.0010641545609615802, + "expected_calibration_error_10bin": 0.0010641545609615802, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 6.027206851415448e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0012819829474779681, + "calibration_in_the_large": 0.0012819829474779681, + "expected_calibration_error_10bin": 0.0012819829474779681, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 1.253817350461917e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0016118020053863592, + "calibration_in_the_large": 0.0016118020053863592, + "expected_calibration_error_10bin": 0.0016118020053863592, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 1.540678624379365e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001774123925815134, + "calibration_in_the_large": 0.001774123925815134, + "expected_calibration_error_10bin": 0.001774123925815134, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 1.7456102961493217e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0018557458949203826, + "calibration_in_the_large": 0.0018557458949203826, + "expected_calibration_error_10bin": 0.0018557458949203826, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 2.0426970332876522e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0019543444930631916, + "calibration_in_the_large": 0.0019543444930631916, + "expected_calibration_error_10bin": 0.0019543444930631916, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 2.464957993369754e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0021091919028791385, + "calibration_in_the_large": 0.0021091919028791385, + "expected_calibration_error_10bin": 0.002109191902879139, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 2.6113409406275343e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0021822143737850806, + "calibration_in_the_large": 0.0021822143737850806, + "expected_calibration_error_10bin": 0.0021822143737850806, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 3.1907561350547254e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00240540261618229, + "calibration_in_the_large": 0.00240540261618229, + "expected_calibration_error_10bin": 0.00240540261618229, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 3.929002184534591e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0026631878422853274, + "calibration_in_the_large": 0.0026631878422853274, + "expected_calibration_error_10bin": 0.002663187842285327, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 4.067800872838146e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.002700966778626388, + "calibration_in_the_large": 0.002700966778626388, + "expected_calibration_error_10bin": 0.0027009667786263877, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + } + ], + "reason": "no_two_class_timepoint" + }, + "G92": { + "time_averaged_auroc": 0.7661763799709804, + "time_averaged_auprc": 0.05477633567944844, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2733, + "positives": 4, + "negatives": 2729, + "auroc": 0.7985525833638696, + "auprc": 0.008749497647491439, + "brier": 0.0014908306039815302, + "calibration": { + "observed_rate": 0.0014635931211123307, + "mean_prediction": 0.004330471010374695, + "calibration_in_the_large": 0.002866877889262364, + "expected_calibration_error_10bin": 0.002866877889262364, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 12, + "negatives": 2721, + "auroc": 0.7601678304544898, + "auprc": 0.024283382973763673, + "brier": 0.004403280127795962, + "calibration": { + "observed_rate": 0.0043907793633369925, + "mean_prediction": 0.007753619698712842, + "calibration_in_the_large": 0.0033628403353758492, + "expected_calibration_error_10bin": 0.0033628403353758492, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 19, + "negatives": 2714, + "auroc": 0.7675600201683279, + "auprc": 0.024404118862562166, + "brier": 0.006959062139358657, + "calibration": { + "observed_rate": 0.006952067325283571, + "mean_prediction": 0.01014009571965317, + "calibration_in_the_large": 0.0031880283943695993, + "expected_calibration_error_10bin": 0.003188028394369598, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 24, + "negatives": 2709, + "auroc": 0.7621354743447767, + "auprc": 0.025695796035518387, + "brier": 0.008866170508387563, + "calibration": { + "observed_rate": 0.008781558726673985, + "mean_prediction": 0.013162796799003352, + "calibration_in_the_large": 0.004381238072329367, + "expected_calibration_error_10bin": 0.004381238072329366, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 29, + "negatives": 2704, + "auroc": 0.7977198530912059, + "auprc": 0.08292678748516061, + "brier": 0.010325673939821556, + "calibration": { + "observed_rate": 0.010611050128064398, + "mean_prediction": 0.015023137850309102, + "calibration_in_the_large": 0.004412087722244704, + "expected_calibration_error_10bin": 0.00486976695965858, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 32, + "negatives": 2701, + "auroc": 0.7797343576453165, + "auprc": 0.07783195431743, + "brier": 0.011450710201198658, + "calibration": { + "observed_rate": 0.011708744968898645, + "mean_prediction": 0.016211635648165527, + "calibration_in_the_large": 0.004502890679266881, + "expected_calibration_error_10bin": 0.004858444947472609, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 37, + "negatives": 2696, + "auroc": 0.7652578394418157, + "auprc": 0.0681290830387156, + "brier": 0.013287982034653145, + "calibration": { + "observed_rate": 0.01353823637028906, + "mean_prediction": 0.01764231282021025, + "calibration_in_the_large": 0.0041040764499211905, + "expected_calibration_error_10bin": 0.004373143985991561, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 38, + "negatives": 2695, + "auroc": 0.7648178888780393, + "auprc": 0.0667723272273836, + "brier": 0.013715520884871291, + "calibration": { + "observed_rate": 0.013904134650567142, + "mean_prediction": 0.01864712505653346, + "calibration_in_the_large": 0.004742990405966317, + "expected_calibration_error_10bin": 0.0047528789757419814, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 39, + "negatives": 2694, + "auroc": 0.7574952886756896, + "auprc": 0.06506336269905039, + "brier": 0.014172583522802812, + "calibration": { + "observed_rate": 0.014270032930845226, + "mean_prediction": 0.0198353404214533, + "calibration_in_the_large": 0.0055653074906080735, + "expected_calibration_error_10bin": 0.006028670684087933, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 42, + "negatives": 2691, + "auroc": 0.745483180265789, + "auprc": 0.0647940678126089, + "brier": 0.015229755512988177, + "calibration": { + "observed_rate": 0.015367727771679473, + "mean_prediction": 0.02055706494723741, + "calibration_in_the_large": 0.005189337175557937, + "expected_calibration_error_10bin": 0.005922218483944998, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 45, + "negatives": 2688, + "auroc": 0.7537946428571428, + "auprc": 0.06814121789270842, + "brier": 0.016265045321671348, + "calibration": { + "observed_rate": 0.01646542261251372, + "mean_prediction": 0.021539700315068955, + "calibration_in_the_large": 0.005074277702555235, + "expected_calibration_error_10bin": 0.005765926292958574, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 47, + "negatives": 2686, + "auroc": 0.7525150108521728, + "auprc": 0.06758793675143064, + "brier": 0.017052691547480188, + "calibration": { + "observed_rate": 0.017197219173069888, + "mean_prediction": 0.02297952036971623, + "calibration_in_the_large": 0.005782301196646342, + "expected_calibration_error_10bin": 0.005889589600860521, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 48, + "negatives": 2685, + "auroc": 0.7550589695841092, + "auprc": 0.06771283108900593, + "brier": 0.017402055325562396, + "calibration": { + "observed_rate": 0.01756311745334797, + "mean_prediction": 0.023185631790390453, + "calibration_in_the_large": 0.005622514337042483, + "expected_calibration_error_10bin": 0.005723105909700379, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + } + ], + "reason": null + }, + "G93": { + "time_averaged_auroc": 0.801451437760863, + "time_averaged_auprc": 0.0536146260521924, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2656, + "positives": 9, + "negatives": 2647, + "auroc": 0.8665575284389035, + "auprc": 0.01787758493188527, + "brier": 0.0033552857955534802, + "calibration": { + "observed_rate": 0.00338855421686747, + "mean_prediction": 0.002916224158651452, + "calibration_in_the_large": -0.0004723300582160179, + "expected_calibration_error_10bin": 0.0004723300582160179, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + { + "valid": 2656, + "positives": 17, + "negatives": 2639, + "auroc": 0.7938836011858325, + "auprc": 0.022054761347434497, + "brier": 0.006328147354311844, + "calibration": { + "observed_rate": 0.006400602409638554, + "mean_prediction": 0.006515280162972546, + "calibration_in_the_large": 0.00011467775333399207, + "expected_calibration_error_10bin": 0.00011467775333399207, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + { + "valid": 2656, + "positives": 26, + "negatives": 2630, + "auroc": 0.8057180462123428, + "auprc": 0.03498572135809531, + "brier": 0.009587585468006414, + "calibration": { + "observed_rate": 0.009789156626506024, + "mean_prediction": 0.008908400973657728, + "calibration_in_the_large": -0.0008807556528482967, + "expected_calibration_error_10bin": 0.00104366410118106, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + { + "valid": 2656, + "positives": 31, + "negatives": 2625, + "auroc": 0.7873794162826421, + "auprc": 0.04070643066905817, + "brier": 0.011391147110152725, + "calibration": { + "observed_rate": 0.011671686746987951, + "mean_prediction": 0.010742368983345107, + "calibration_in_the_large": -0.0009293177636428441, + "expected_calibration_error_10bin": 0.0016489448598146833, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + { + "valid": 2656, + "positives": 35, + "negatives": 2621, + "auroc": 0.7991824276448466, + "auprc": 0.05732337478969548, + "brier": 0.01272743540531303, + "calibration": { + "observed_rate": 0.013177710843373495, + "mean_prediction": 0.012018580596918307, + "calibration_in_the_large": -0.0011591302464551874, + "expected_calibration_error_10bin": 0.0013568333998887569, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + { + "valid": 2656, + "positives": 37, + "negatives": 2619, + "auroc": 0.7956306822286203, + "auprc": 0.05859272208002482, + "brier": 0.013462333336069344, + "calibration": { + "observed_rate": 0.013930722891566265, + "mean_prediction": 0.013095156145597236, + "calibration_in_the_large": -0.000835566745969029, + "expected_calibration_error_10bin": 0.0018609427851110215, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + { + "valid": 2656, + "positives": 41, + "negatives": 2615, + "auroc": 0.7934057734458798, + "auprc": 0.05963202858856042, + "brier": 0.01491355165025116, + "calibration": { + "observed_rate": 0.015436746987951807, + "mean_prediction": 0.014420157833140924, + "calibration_in_the_large": -0.001016589154810883, + "expected_calibration_error_10bin": 0.0023595120808048626, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + { + "valid": 2656, + "positives": 44, + "negatives": 2612, + "auroc": 0.7908777669497424, + "auprc": 0.05944222205789374, + "brier": 0.016009100979440614, + "calibration": { + "observed_rate": 0.016566265060240965, + "mean_prediction": 0.01524991596888648, + "calibration_in_the_large": -0.0013163490913544844, + "expected_calibration_error_10bin": 0.0035980394499763716, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + { + "valid": 2656, + "positives": 45, + "negatives": 2611, + "auroc": 0.7938635686624963, + "auprc": 0.060311232357086235, + "brier": 0.01636145214787706, + "calibration": { + "observed_rate": 0.01694277108433735, + "mean_prediction": 0.01605957586708614, + "calibration_in_the_large": -0.0008831952172512099, + "expected_calibration_error_10bin": 0.002294726865165354, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + { + "valid": 2656, + "positives": 47, + "negatives": 2609, + "auroc": 0.7997276204300987, + "auprc": 0.06927075799454578, + "brier": 0.01702069836610844, + "calibration": { + "observed_rate": 0.017695783132530122, + "mean_prediction": 0.01711002977689455, + "calibration_in_the_large": -0.000585753355635571, + "expected_calibration_error_10bin": 0.0020655149464801075, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + { + "valid": 2656, + "positives": 50, + "negatives": 2606, + "auroc": 0.7977590176515733, + "auprc": 0.07032625171504071, + "brier": 0.01808483692779734, + "calibration": { + "observed_rate": 0.01882530120481928, + "mean_prediction": 0.01775624148594724, + "calibration_in_the_large": -0.001069059718872039, + "expected_calibration_error_10bin": 0.0019430964118974635, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + { + "valid": 2656, + "positives": 56, + "negatives": 2600, + "auroc": 0.7974725274725275, + "auprc": 0.07328506868082561, + "brier": 0.02020250514843282, + "calibration": { + "observed_rate": 0.02108433734939759, + "mean_prediction": 0.018524468766602707, + "calibration_in_the_large": -0.0025598685827948817, + "expected_calibration_error_10bin": 0.004053752676225989, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + { + "valid": 2656, + "positives": 56, + "negatives": 2600, + "auroc": 0.7974107142857143, + "auprc": 0.07318198210835514, + "brier": 0.020205612910027104, + "calibration": { + "observed_rate": 0.02108433734939759, + "mean_prediction": 0.018675899764297444, + "calibration_in_the_large": -0.002408437585100145, + "expected_calibration_error_10bin": 0.004050013011681543, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + } + ], + "reason": null + }, + "G99": { + "time_averaged_auroc": 0.8740140845070423, + "time_averaged_auprc": 0.002792414489672997, + "valid_timepoint_cells": 5, + "timepoints": [ + { + "valid": 2841, + "positives": 0, + "negatives": 2841, + "auroc": null, + "auprc": null, + "brier": 5.0961670790987256e-08, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 8.244744241384828e-05, + "calibration_in_the_large": 8.244744241384828e-05, + "expected_calibration_error_10bin": 8.244744241384828e-05, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9992965177629265 + }, + { + "valid": 2841, + "positives": 0, + "negatives": 2841, + "auroc": null, + "auprc": null, + "brier": 1.708446517372246e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00015271966601764647, + "calibration_in_the_large": 0.00015271966601764647, + "expected_calibration_error_10bin": 0.00015271966601764647, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9992965177629265 + }, + { + "valid": 2841, + "positives": 0, + "negatives": 2841, + "auroc": null, + "auprc": null, + "brier": 3.663634531861243e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0002335644414178045, + "calibration_in_the_large": 0.0002335644414178045, + "expected_calibration_error_10bin": 0.0002335644414178045, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9992965177629265 + }, + { + "valid": 2841, + "positives": 0, + "negatives": 2841, + "auroc": null, + "auprc": null, + "brier": 5.744917787986795e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0002935493583768152, + "calibration_in_the_large": 0.0002935493583768152, + "expected_calibration_error_10bin": 0.0002935493583768152, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9992965177629265 + }, + { + "valid": 2841, + "positives": 0, + "negatives": 2841, + "auroc": null, + "auprc": null, + "brier": 7.186259657454076e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00033533374064597516, + "calibration_in_the_large": 0.00033533374064597516, + "expected_calibration_error_10bin": 0.00033533374064597516, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9992965177629265 + }, + { + "valid": 2841, + "positives": 0, + "negatives": 2841, + "auroc": null, + "auprc": null, + "brier": 8.219112726136195e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00036455545543247084, + "calibration_in_the_large": 0.00036455545543247084, + "expected_calibration_error_10bin": 0.00036455545543247084, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9992965177629265 + }, + { + "valid": 2841, + "positives": 0, + "negatives": 2841, + "auroc": null, + "auprc": null, + "brier": 9.871598509042215e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00039933431803865666, + "calibration_in_the_large": 0.00039933431803865666, + "expected_calibration_error_10bin": 0.00039933431803865666, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9992965177629265 + }, + { + "valid": 2841, + "positives": 0, + "negatives": 2841, + "auroc": null, + "auprc": null, + "brier": 1.0637333888480857e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004214299940746051, + "calibration_in_the_large": 0.0004214299940746051, + "expected_calibration_error_10bin": 0.0004214299940746051, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9992965177629265 + }, + { + "valid": 2841, + "positives": 1, + "negatives": 2840, + "auroc": 0.8647887323943662, + "auprc": 0.0025974025974025974, + "brier": 0.0003526661468908914, + "calibration": { + "observed_rate": 0.00035198873636043646, + "mean_prediction": 0.00044789497429690493, + "calibration_in_the_large": 9.590623793646847e-05, + "expected_calibration_error_10bin": 9.590623793646847e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9992965177629265 + }, + { + "valid": 2841, + "positives": 1, + "negatives": 2840, + "auroc": 0.8718309859154929, + "auprc": 0.0027397260273972603, + "brier": 0.0003527546686154955, + "calibration": { + "observed_rate": 0.00035198873636043646, + "mean_prediction": 0.0004801167743329113, + "calibration_in_the_large": 0.00012812803797247486, + "expected_calibration_error_10bin": 0.00012812803797247486, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9992965177629265 + }, + { + "valid": 2841, + "positives": 1, + "negatives": 2840, + "auroc": 0.8739436619718309, + "auprc": 0.002785515320334262, + "brier": 0.00035287749589179803, + "calibration": { + "observed_rate": 0.00035198873636043646, + "mean_prediction": 0.000512512089357897, + "calibration_in_the_large": 0.0001605233529974605, + "expected_calibration_error_10bin": 0.0001605233529974605, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9992965177629265 + }, + { + "valid": 2841, + "positives": 1, + "negatives": 2840, + "auroc": 0.8795774647887324, + "auprc": 0.0029154518950437317, + "brier": 0.0003529225769016019, + "calibration": { + "observed_rate": 0.00035198873636043646, + "mean_prediction": 0.0005269599859640602, + "calibration_in_the_large": 0.00017497124960362374, + "expected_calibration_error_10bin": 0.00017497124960362374, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9992965177629265 + }, + { + "valid": 2841, + "positives": 1, + "negatives": 2840, + "auroc": 0.8799295774647887, + "auprc": 0.0029239766081871343, + "brier": 0.0003529269468714582, + "calibration": { + "observed_rate": 0.00035198873636043646, + "mean_prediction": 0.0005284171427682511, + "calibration_in_the_large": 0.00017642840640781464, + "expected_calibration_error_10bin": 0.00017642840640781464, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9992965177629265 + } + ], + "reason": null + }, + "H10": { + "time_averaged_auroc": 0.8689767863693884, + "time_averaged_auprc": 0.01577963210046379, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2832, + "positives": 0, + "negatives": 2832, + "auroc": null, + "auprc": null, + "brier": 2.2130132886131183e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0001922652487036556, + "calibration_in_the_large": 0.0001922652487036556, + "expected_calibration_error_10bin": 0.0001922652487036556, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 1, + "negatives": 2831, + "auroc": 0.990815966089721, + "auprc": 0.037037037037037035, + "brier": 0.00035151647130424245, + "calibration": { + "observed_rate": 0.00035310734463276836, + "mean_prediction": 0.00029284351064933037, + "calibration_in_the_large": -6.026383398343799e-05, + "expected_calibration_error_10bin": 6.026383398343799e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 3, + "negatives": 2829, + "auroc": 0.9214092140921409, + "auprc": 0.020264279127452125, + "brier": 0.001055349664472037, + "calibration": { + "observed_rate": 0.001059322033898305, + "mean_prediction": 0.0004743514444365986, + "calibration_in_the_large": -0.0005849705894617064, + "expected_calibration_error_10bin": 0.0005849705894617064, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 4, + "negatives": 2828, + "auroc": 0.9077086280056577, + "auprc": 0.01649921056365993, + "brier": 0.001407675347484286, + "calibration": { + "observed_rate": 0.0014124293785310734, + "mean_prediction": 0.0006358431691338965, + "calibration_in_the_large": -0.0007765862093971769, + "expected_calibration_error_10bin": 0.0007765862093971769, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 4, + "negatives": 2828, + "auroc": 0.9054101838755304, + "auprc": 0.01595892331358522, + "brier": 0.001407628024255339, + "calibration": { + "observed_rate": 0.0014124293785310734, + "mean_prediction": 0.0007301702681429098, + "calibration_in_the_large": -0.0006822591103881636, + "expected_calibration_error_10bin": 0.0006822591103881636, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 4, + "negatives": 2828, + "auroc": 0.9061173974540311, + "auprc": 0.015007420997154882, + "brier": 0.0014077102411443978, + "calibration": { + "observed_rate": 0.0014124293785310734, + "mean_prediction": 0.0007938634842950916, + "calibration_in_the_large": -0.0006185658942359819, + "expected_calibration_error_10bin": 0.0006185658942359819, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 5, + "negatives": 2827, + "auroc": 0.8754156349487089, + "auprc": 0.013233655416524251, + "brier": 0.0017602361829113962, + "calibration": { + "observed_rate": 0.0017655367231638418, + "mean_prediction": 0.0008573743826393266, + "calibration_in_the_large": -0.0009081623405245152, + "expected_calibration_error_10bin": 0.0009081623405245152, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 5, + "negatives": 2827, + "auroc": 0.8757693668199504, + "auprc": 0.013256010914250119, + "brier": 0.0017603000627820994, + "calibration": { + "observed_rate": 0.0017655367231638418, + "mean_prediction": 0.0009139232123952958, + "calibration_in_the_large": -0.000851613510768546, + "expected_calibration_error_10bin": 0.000851613510768546, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 5, + "negatives": 2827, + "auroc": 0.8752741422002123, + "auprc": 0.012405100604767577, + "brier": 0.0017604371473012783, + "calibration": { + "observed_rate": 0.0017655367231638418, + "mean_prediction": 0.0010367609301557283, + "calibration_in_the_large": -0.0007287757930081135, + "expected_calibration_error_10bin": 0.0007287757930081135, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 5, + "negatives": 2827, + "auroc": 0.8759816059426955, + "auprc": 0.012791389377504472, + "brier": 0.0017604136020387474, + "calibration": { + "observed_rate": 0.0017655367231638418, + "mean_prediction": 0.0010971006794146384, + "calibration_in_the_large": -0.0006684360437492034, + "expected_calibration_error_10bin": 0.0006684360437492034, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.7645671148855863, + "auprc": 0.01096380532704831, + "brier": 0.002113485135084528, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.0011542743698865156, + "calibration_in_the_large": -0.0009643696979100946, + "expected_calibration_error_10bin": 0.0009643696979100946, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.7645671148855863, + "auprc": 0.010964110597097744, + "brier": 0.0021136230489956606, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.0011939783397308488, + "calibration_in_the_large": -0.0009246657280657614, + "expected_calibration_error_10bin": 0.0009246657280657614, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.7646850672328379, + "auprc": 0.01097464192948381, + "brier": 0.00211363236034263, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.001196619135788299, + "calibration_in_the_large": -0.0009220249320083113, + "expected_calibration_error_10bin": 0.0009220249320083113, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + } + ], + "reason": null + }, + "H26": { + "time_averaged_auroc": null, + "time_averaged_auprc": null, + "valid_timepoint_cells": 0, + "timepoints": [ + { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 2.385338219387749e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0003167813403671688, + "calibration_in_the_large": 0.0003167813403671688, + "expected_calibration_error_10bin": 0.0003167813403671688, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 1.2118746702977596e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0006145537647907537, + "calibration_in_the_large": 0.0006145537647907537, + "expected_calibration_error_10bin": 0.0006145537647907537, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 2.063383800127631e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0007830347154113064, + "calibration_in_the_large": 0.0007830347154113064, + "expected_calibration_error_10bin": 0.0007830347154113064, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 3.263242337200269e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00100104767202033, + "calibration_in_the_large": 0.00100104767202033, + "expected_calibration_error_10bin": 0.00100104767202033, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 5.4058159868140446e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0012125756380405985, + "calibration_in_the_large": 0.0012125756380405985, + "expected_calibration_error_10bin": 0.0012125756380405985, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 6.451940407148011e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0013357899371466571, + "calibration_in_the_large": 0.0013357899371466571, + "expected_calibration_error_10bin": 0.0013357899371466571, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 7.2900927154443135e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0014238311651726667, + "calibration_in_the_large": 0.0014238311651726667, + "expected_calibration_error_10bin": 0.0014238311651726667, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 9.912884217888545e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001580757693475406, + "calibration_in_the_large": 0.001580757693475406, + "expected_calibration_error_10bin": 0.001580757693475406, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 1.1116036307788043e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0016919678975596008, + "calibration_in_the_large": 0.0016919678975596008, + "expected_calibration_error_10bin": 0.0016919678975596008, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 1.2240340944251123e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0017733755167821884, + "calibration_in_the_large": 0.0017733755167821884, + "expected_calibration_error_10bin": 0.0017733755167821884, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 1.3957604879891647e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0018947462894274953, + "calibration_in_the_large": 0.0018947462894274953, + "expected_calibration_error_10bin": 0.0018947462894274953, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 1.5184406000931246e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0019617951233859635, + "calibration_in_the_large": 0.0019617951233859635, + "expected_calibration_error_10bin": 0.0019617951233859635, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 1.55149132172556e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001981149350226018, + "calibration_in_the_large": 0.001981149350226018, + "expected_calibration_error_10bin": 0.001981149350226018, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + } + ], + "reason": "no_two_class_timepoint" + }, + "H35": { + "time_averaged_auroc": 0.7156959929388732, + "time_averaged_auprc": 0.005692275082579777, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2806, + "positives": 3, + "negatives": 2803, + "auroc": 0.802116779640861, + "auprc": 0.0044781207636564535, + "brier": 0.0010685368264986026, + "calibration": { + "observed_rate": 0.0010691375623663579, + "mean_prediction": 0.00017667701051727602, + "calibration_in_the_large": -0.0008924605518490818, + "expected_calibration_error_10bin": 0.0008924605518490818, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 3, + "negatives": 2803, + "auroc": 0.7990248543227494, + "auprc": 0.004329142990257661, + "brier": 0.0010685026007141536, + "calibration": { + "observed_rate": 0.0010691375623663579, + "mean_prediction": 0.0003191064777287503, + "calibration_in_the_large": -0.0007500310846376075, + "expected_calibration_error_10bin": 0.0007500310846376075, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 4, + "negatives": 2802, + "auroc": 0.6586366880799429, + "auprc": 0.003822649122629984, + "brier": 0.0014250474356757607, + "calibration": { + "observed_rate": 0.0014255167498218105, + "mean_prediction": 0.00043146555865345424, + "calibration_in_the_large": -0.0009940511911683562, + "expected_calibration_error_10bin": 0.0009940511911683562, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 4, + "negatives": 2802, + "auroc": 0.6557815845824411, + "auprc": 0.004026200553694501, + "brier": 0.001425194703652775, + "calibration": { + "observed_rate": 0.0014255167498218105, + "mean_prediction": 0.0005499791525019316, + "calibration_in_the_large": -0.0008755375973198789, + "expected_calibration_error_10bin": 0.0008755375973198789, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 4, + "negatives": 2802, + "auroc": 0.654621698786581, + "auprc": 0.003903621753260462, + "brier": 0.001425510791942011, + "calibration": { + "observed_rate": 0.0014255167498218105, + "mean_prediction": 0.000615076894867441, + "calibration_in_the_large": -0.0008104398549543695, + "expected_calibration_error_10bin": 0.0008104398549543695, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 4, + "negatives": 2802, + "auroc": 0.6531049250535332, + "auprc": 0.003989381655586642, + "brier": 0.0014258988498746018, + "calibration": { + "observed_rate": 0.0014255167498218105, + "mean_prediction": 0.0007032909153308236, + "calibration_in_the_large": -0.0007222258344909869, + "expected_calibration_error_10bin": 0.0007222258344909869, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 5, + "negatives": 2801, + "auroc": 0.7107461620849697, + "auprc": 0.006656992656700236, + "brier": 0.0017803735861672053, + "calibration": { + "observed_rate": 0.001781895937277263, + "mean_prediction": 0.0007924761407409154, + "calibration_in_the_large": -0.0009894197965363478, + "expected_calibration_error_10bin": 0.0009894197965363478, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 5, + "negatives": 2801, + "auroc": 0.7115315958586219, + "auprc": 0.006683892156154494, + "brier": 0.0017805304893753497, + "calibration": { + "observed_rate": 0.001781895937277263, + "mean_prediction": 0.000852779106053218, + "calibration_in_the_large": -0.0009291168312240451, + "expected_calibration_error_10bin": 0.0009291168312240451, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 5, + "negatives": 2801, + "auroc": 0.7125312388432703, + "auprc": 0.006712402928313358, + "brier": 0.0017806800321236438, + "calibration": { + "observed_rate": 0.001781895937277263, + "mean_prediction": 0.0008992015720137905, + "calibration_in_the_large": -0.0008826943652634726, + "expected_calibration_error_10bin": 0.0008826943652634726, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 6, + "negatives": 2800, + "auroc": 0.7328571428571429, + "auprc": 0.007203475263272777, + "brier": 0.002136455791034304, + "calibration": { + "observed_rate": 0.0021382751247327157, + "mean_prediction": 0.0009433783757422374, + "calibration_in_the_large": -0.0011948967489904783, + "expected_calibration_error_10bin": 0.0011948967489904783, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 6, + "negatives": 2800, + "auroc": 0.7390476190476191, + "auprc": 0.007442547149185762, + "brier": 0.0021365316925432607, + "calibration": { + "observed_rate": 0.0021382751247327157, + "mean_prediction": 0.001022895766989921, + "calibration_in_the_large": -0.0011153793577427947, + "expected_calibration_error_10bin": 0.0011153793577427947, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 6, + "negatives": 2800, + "auroc": 0.7370238095238095, + "auprc": 0.007376912122886662, + "brier": 0.002136638782148765, + "calibration": { + "observed_rate": 0.0021382751247327157, + "mean_prediction": 0.0010753882566446246, + "calibration_in_the_large": -0.001062886868088091, + "expected_calibration_error_10bin": 0.001062886868088091, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 6, + "negatives": 2800, + "auroc": 0.7370238095238095, + "auprc": 0.007374236957938107, + "brier": 0.002136723278225813, + "calibration": { + "observed_rate": 0.0021382751247327157, + "mean_prediction": 0.001088642002056311, + "calibration_in_the_large": -0.0010496331226764047, + "expected_calibration_error_10bin": 0.0010496331226764047, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + } + ], + "reason": null + }, + "H40": { + "time_averaged_auroc": 0.758881782725238, + "time_averaged_auprc": 0.0209408618365457, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2750, + "positives": 3, + "negatives": 2747, + "auroc": 0.7880111636937265, + "auprc": 0.02639583416406947, + "brier": 0.0010835816961773956, + "calibration": { + "observed_rate": 0.001090909090909091, + "mean_prediction": 0.0011025187454599126, + "calibration_in_the_large": 1.1609654550821628e-05, + "expected_calibration_error_10bin": 1.1609654550821628e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 4, + "negatives": 2746, + "auroc": 0.7738528769118718, + "auprc": 0.016330581696959962, + "brier": 0.001452588239762425, + "calibration": { + "observed_rate": 0.0014545454545454545, + "mean_prediction": 0.0019150828036052355, + "calibration_in_the_large": 0.0004605373490597811, + "expected_calibration_error_10bin": 0.0004605373490597811, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 5, + "negatives": 2745, + "auroc": 0.7643715846994535, + "auprc": 0.01328370901053374, + "brier": 0.0018199432997654268, + "calibration": { + "observed_rate": 0.0018181818181818182, + "mean_prediction": 0.0023787783924966457, + "calibration_in_the_large": 0.0005605965743148275, + "expected_calibration_error_10bin": 0.0005605965743148275, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 5, + "negatives": 2745, + "auroc": 0.7596357012750455, + "auprc": 0.013634728226702022, + "brier": 0.0018326951876388084, + "calibration": { + "observed_rate": 0.0018181818181818182, + "mean_prediction": 0.002967355977544106, + "calibration_in_the_large": 0.0011491741593622879, + "expected_calibration_error_10bin": 0.0011491741593622879, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 5, + "negatives": 2745, + "auroc": 0.7548998178506375, + "auprc": 0.01155932449811003, + "brier": 0.0018477758272290184, + "calibration": { + "observed_rate": 0.0018181818181818182, + "mean_prediction": 0.003517057608109264, + "calibration_in_the_large": 0.0016988757899274458, + "expected_calibration_error_10bin": 0.0016988757899274458, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 5, + "negatives": 2745, + "auroc": 0.7535154826958106, + "auprc": 0.010940046807945305, + "brier": 0.0018605002717161994, + "calibration": { + "observed_rate": 0.0018181818181818182, + "mean_prediction": 0.003801313070122639, + "calibration_in_the_large": 0.001983131251940821, + "expected_calibration_error_10bin": 0.0019831312519408215, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 6, + "negatives": 2744, + "auroc": 0.7957361516034985, + "auprc": 0.03190184050599738, + "brier": 0.0021779350229136052, + "calibration": { + "observed_rate": 0.002181818181818182, + "mean_prediction": 0.003931253343993872, + "calibration_in_the_large": 0.0017494351621756897, + "expected_calibration_error_10bin": 0.0017494351621756903, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 6, + "negatives": 2744, + "auroc": 0.7946428571428571, + "auprc": 0.0318682972745543, + "brier": 0.00218437147563276, + "calibration": { + "observed_rate": 0.002181818181818182, + "mean_prediction": 0.004207556445738936, + "calibration_in_the_large": 0.0020257382639207538, + "expected_calibration_error_10bin": 0.0020257382639207533, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 9, + "negatives": 2741, + "auroc": 0.7135676354939398, + "auprc": 0.0230648278419005, + "brier": 0.003280422408048609, + "calibration": { + "observed_rate": 0.0032727272727272726, + "mean_prediction": 0.004541531483269699, + "calibration_in_the_large": 0.0012688042105424265, + "expected_calibration_error_10bin": 0.0012688042105424256, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 9, + "negatives": 2741, + "auroc": 0.7137297823178889, + "auprc": 0.023525080738848198, + "brier": 0.003287176658187545, + "calibration": { + "observed_rate": 0.0032727272727272726, + "mean_prediction": 0.004810249031128478, + "calibration_in_the_large": 0.0015375217584012056, + "expected_calibration_error_10bin": 0.0015375217584012051, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 12, + "negatives": 2738, + "auroc": 0.7510956902848794, + "auprc": 0.02346887212812024, + "brier": 0.004358836230861964, + "calibration": { + "observed_rate": 0.004363636363636364, + "mean_prediction": 0.005061294709898489, + "calibration_in_the_large": 0.0006976583462621252, + "expected_calibration_error_10bin": 0.0006976583462621256, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 12, + "negatives": 2738, + "auroc": 0.7511261261261262, + "auprc": 0.023124330596188392, + "brier": 0.004367375611097658, + "calibration": { + "observed_rate": 0.004363636363636364, + "mean_prediction": 0.005303584634090922, + "calibration_in_the_large": 0.0009399482704545584, + "expected_calibration_error_10bin": 0.0009399482704545584, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + { + "valid": 2750, + "positives": 12, + "negatives": 2738, + "auroc": 0.7512783053323594, + "auprc": 0.02313373038516452, + "brier": 0.0043682171167759316, + "calibration": { + "observed_rate": 0.004363636363636364, + "mean_prediction": 0.005330056761798914, + "calibration_in_the_large": 0.0009664203981625506, + "expected_calibration_error_10bin": 0.0009664203981625508, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + } + ], + "reason": null + }, + "H53": { + "time_averaged_auroc": 0.6158971175286049, + "time_averaged_auprc": 0.009940147855474535, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2790, + "positives": 3, + "negatives": 2787, + "auroc": 0.6724076067456046, + "auprc": 0.005329941823378308, + "brier": 0.0010735415911514682, + "calibration": { + "observed_rate": 0.001075268817204301, + "mean_prediction": 0.0014087620562845406, + "calibration_in_the_large": 0.0003334932390802396, + "expected_calibration_error_10bin": 0.0003334932390802396, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 3, + "negatives": 2787, + "auroc": 0.6856835306781486, + "auprc": 0.007929716296955264, + "brier": 0.0010738007848296429, + "calibration": { + "observed_rate": 0.001075268817204301, + "mean_prediction": 0.00200619443339975, + "calibration_in_the_large": 0.0009309256161954488, + "expected_calibration_error_10bin": 0.0009309256161954488, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 7, + "negatives": 2783, + "auroc": 0.6506852830963503, + "auprc": 0.012668230961322855, + "brier": 0.0025002432384965113, + "calibration": { + "observed_rate": 0.0025089605734767025, + "mean_prediction": 0.002577637066780072, + "calibration_in_the_large": 6.867649330336966e-05, + "expected_calibration_error_10bin": 6.867649330336966e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 8, + "negatives": 2782, + "auroc": 0.6062185478073329, + "auprc": 0.009255757211928199, + "brier": 0.002860818474494734, + "calibration": { + "observed_rate": 0.002867383512544803, + "mean_prediction": 0.003285573033877151, + "calibration_in_the_large": 0.0004181895213323482, + "expected_calibration_error_10bin": 0.0004181895213323482, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 9, + "negatives": 2781, + "auroc": 0.5754125214750889, + "auprc": 0.009402812097437239, + "brier": 0.0032221329443476044, + "calibration": { + "observed_rate": 0.0032258064516129032, + "mean_prediction": 0.00365118721540096, + "calibration_in_the_large": 0.0004253807637880566, + "expected_calibration_error_10bin": 0.0004253807637880566, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 9, + "negatives": 2781, + "auroc": 0.5877182468336729, + "auprc": 0.009623857642685418, + "brier": 0.00322426057822827, + "calibration": { + "observed_rate": 0.0032258064516129032, + "mean_prediction": 0.004233168740704652, + "calibration_in_the_large": 0.0010073622890917487, + "expected_calibration_error_10bin": 0.0010073622890917487, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 10, + "negatives": 2780, + "auroc": 0.6092446043165468, + "auprc": 0.009814532817903971, + "brier": 0.003582184989909509, + "calibration": { + "observed_rate": 0.0035842293906810036, + "mean_prediction": 0.00457911697860163, + "calibration_in_the_large": 0.000994887587920626, + "expected_calibration_error_10bin": 0.000994887587920626, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 10, + "negatives": 2780, + "auroc": 0.6152158273381295, + "auprc": 0.010412665110269483, + "brier": 0.0035839775772893968, + "calibration": { + "observed_rate": 0.0035842293906810036, + "mean_prediction": 0.004734564579081952, + "calibration_in_the_large": 0.0011503351884009482, + "expected_calibration_error_10bin": 0.0011503351884009482, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 11, + "negatives": 2779, + "auroc": 0.5849717033596127, + "auprc": 0.010256737965451729, + "brier": 0.003946217577156892, + "calibration": { + "observed_rate": 0.003942652329749104, + "mean_prediction": 0.005120218684896827, + "calibration_in_the_large": 0.0011775663551477225, + "expected_calibration_error_10bin": 0.0011775663551477225, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 12, + "negatives": 2778, + "auroc": 0.6025917926565875, + "auprc": 0.010471118628856649, + "brier": 0.004306544928865659, + "calibration": { + "observed_rate": 0.004301075268817204, + "mean_prediction": 0.005499711490797854, + "calibration_in_the_large": 0.0011986362219806495, + "expected_calibration_error_10bin": 0.0011986362219806495, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 13, + "negatives": 2777, + "auroc": 0.6152738151297747, + "auprc": 0.011179957852460147, + "brier": 0.004665783167463408, + "calibration": { + "observed_rate": 0.004659498207885305, + "mean_prediction": 0.005884845098096704, + "calibration_in_the_large": 0.001225346890211399, + "expected_calibration_error_10bin": 0.0012253468902113985, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 14, + "negatives": 2776, + "auroc": 0.5902120214079868, + "auprc": 0.01097145087209744, + "brier": 0.005030342003962854, + "calibration": { + "observed_rate": 0.005017921146953405, + "mean_prediction": 0.006324078591759934, + "calibration_in_the_large": 0.001306157444806529, + "expected_calibration_error_10bin": 0.0013061574448065291, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 15, + "negatives": 2775, + "auroc": 0.611027027027027, + "auprc": 0.01190514284042224, + "brier": 0.005379824649114014, + "calibration": { + "observed_rate": 0.005376344086021506, + "mean_prediction": 0.006333698792045929, + "calibration_in_the_large": 0.0009573547060244235, + "expected_calibration_error_10bin": 0.0009573547060244238, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + } + ], + "reason": null + }, + "H54": { + "time_averaged_auroc": 0.4399227446891102, + "time_averaged_auprc": 0.0010607735576166333, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2809, + "positives": 1, + "negatives": 2808, + "auroc": 0.5847578347578347, + "auprc": 0.000856898029134533, + "brier": 0.0003568808447539952, + "calibration": { + "observed_rate": 0.000355998576005696, + "mean_prediction": 0.0006171053800956398, + "calibration_in_the_large": 0.0002611068040899438, + "expected_calibration_error_10bin": 0.0002611068040899438, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.4271464196651229, + "auprc": 0.0009117591982293598, + "brier": 0.0007157239255891897, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0011308062391097969, + "calibration_in_the_large": 0.0004188090870984049, + "expected_calibration_error_10bin": 0.0004188090870984049, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.4178838617741361, + "auprc": 0.0008938907868131591, + "brier": 0.000719156630976581, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0014684850960990357, + "calibration_in_the_large": 0.0007564879440876437, + "expected_calibration_error_10bin": 0.0007564879440876437, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.41913074456715355, + "auprc": 0.0008971363312738618, + "brier": 0.0007232072410049116, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0017832213711011266, + "calibration_in_the_large": 0.0010712242190897346, + "expected_calibration_error_10bin": 0.0010712242190897346, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.420377627360171, + "auprc": 0.0008991719216714236, + "brier": 0.0007258267131919758, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.00193558661323473, + "calibration_in_the_large": 0.001223589461223338, + "expected_calibration_error_10bin": 0.001223589461223338, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.4228713929462059, + "auprc": 0.000902179385512692, + "brier": 0.0007286819508887798, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0021077715362897405, + "calibration_in_the_large": 0.0013957743842783485, + "expected_calibration_error_10bin": 0.0013957743842783485, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.4248307801923762, + "auprc": 0.0009056094262851767, + "brier": 0.0007324084257791153, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0022865918232690104, + "calibration_in_the_large": 0.0015745946712576184, + "expected_calibration_error_10bin": 0.0015745946712576184, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.41895261845386533, + "auprc": 0.0008959891252021378, + "brier": 0.0007380935320765841, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0025323826771081097, + "calibration_in_the_large": 0.0018203855250967177, + "expected_calibration_error_10bin": 0.0018203855250967177, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.43231207695048096, + "auprc": 0.0009175289440946223, + "brier": 0.0007417105344267018, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.00275727381769565, + "calibration_in_the_large": 0.002045276665684258, + "expected_calibration_error_10bin": 0.002045276665684258, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 3, + "negatives": 2806, + "auroc": 0.4458303635067712, + "auprc": 0.0012290008387772805, + "brier": 0.0011008529439700016, + "calibration": { + "observed_rate": 0.001067995728017088, + "mean_prediction": 0.0029555653158543013, + "calibration_in_the_large": 0.0018875695878372133, + "expected_calibration_error_10bin": 0.0018875695878372133, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 4, + "negatives": 2805, + "auroc": 0.43440285204991086, + "auprc": 0.001492028868850458, + "brier": 0.0014600421931414457, + "calibration": { + "observed_rate": 0.001423994304022784, + "mean_prediction": 0.003128538170946846, + "calibration_in_the_large": 0.0017045438669240618, + "expected_calibration_error_10bin": 0.0017045438669240618, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 4, + "negatives": 2805, + "auroc": 0.435204991087344, + "auprc": 0.0014943398335895016, + "brier": 0.0014658777985701239, + "calibration": { + "observed_rate": 0.001423994304022784, + "mean_prediction": 0.0033341239372329822, + "calibration_in_the_large": 0.0019101296332101982, + "expected_calibration_error_10bin": 0.0019101296332101982, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 4, + "negatives": 2805, + "auroc": 0.43529411764705883, + "auprc": 0.001494523559582026, + "brier": 0.0014660168616114691, + "calibration": { + "observed_rate": 0.001423994304022784, + "mean_prediction": 0.003340074726906722, + "calibration_in_the_large": 0.001916080422883938, + "expected_calibration_error_10bin": 0.001916080422883938, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + } + ], + "reason": null + }, + "H91": { + "time_averaged_auroc": 0.7271963790369538, + "time_averaged_auprc": 0.007826050197766218, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2791, + "positives": 1, + "negatives": 2790, + "auroc": 0.4505376344086022, + "auprc": 0.000651890482398957, + "brier": 0.0003586494895495738, + "calibration": { + "observed_rate": 0.00035829451809387314, + "mean_prediction": 0.00045910300356448143, + "calibration_in_the_large": 0.0001008084854706083, + "expected_calibration_error_10bin": 0.0001008084854706083, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + { + "valid": 2791, + "positives": 2, + "negatives": 2789, + "auroc": 0.7592326998924346, + "auprc": 0.010033253067308795, + "brier": 0.0007152055986076118, + "calibration": { + "observed_rate": 0.0007165890361877463, + "mean_prediction": 0.0011021939787436168, + "calibration_in_the_large": 0.0003856049425558705, + "expected_calibration_error_10bin": 0.0003856049425558705, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + { + "valid": 2791, + "positives": 5, + "negatives": 2786, + "auroc": 0.7376884422110552, + "auprc": 0.007347911583322176, + "brier": 0.0017864402257653355, + "calibration": { + "observed_rate": 0.0017914725904693658, + "mean_prediction": 0.0015613176076705736, + "calibration_in_the_large": -0.0002301549827987922, + "expected_calibration_error_10bin": 0.0002301549827987922, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + { + "valid": 2791, + "positives": 5, + "negatives": 2786, + "auroc": 0.7382627422828428, + "auprc": 0.007855239912526854, + "brier": 0.001786595691533572, + "calibration": { + "observed_rate": 0.0017914725904693658, + "mean_prediction": 0.0016990428792087251, + "calibration_in_the_large": -9.242971126064065e-05, + "expected_calibration_error_10bin": 9.242971126064065e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + { + "valid": 2791, + "positives": 5, + "negatives": 2786, + "auroc": 0.7379038047379756, + "auprc": 0.007876635574969617, + "brier": 0.0017878537772437826, + "calibration": { + "observed_rate": 0.0017914725904693658, + "mean_prediction": 0.0019449292168630954, + "calibration_in_the_large": 0.00015345662639372959, + "expected_calibration_error_10bin": 0.00015345662639372959, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + { + "valid": 2791, + "positives": 5, + "negatives": 2786, + "auroc": 0.7407753050969131, + "auprc": 0.008021930125326574, + "brier": 0.0017893782235624811, + "calibration": { + "observed_rate": 0.0017914725904693658, + "mean_prediction": 0.002148221372313942, + "calibration_in_the_large": 0.0003567487818445761, + "expected_calibration_error_10bin": 0.0003567487818445761, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + { + "valid": 2791, + "positives": 7, + "negatives": 2784, + "auroc": 0.7565168308702791, + "auprc": 0.00843653154053553, + "brier": 0.0025038775068960874, + "calibration": { + "observed_rate": 0.0025080616266571123, + "mean_prediction": 0.0024749242173237648, + "calibration_in_the_large": -3.313740933334752e-05, + "expected_calibration_error_10bin": 3.313740933334752e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + { + "valid": 2791, + "positives": 7, + "negatives": 2784, + "auroc": 0.7563115763546798, + "auprc": 0.008483110742694604, + "brier": 0.002505649904385833, + "calibration": { + "observed_rate": 0.0025080616266571123, + "mean_prediction": 0.0026132100009391246, + "calibration_in_the_large": 0.00010514837428201229, + "expected_calibration_error_10bin": 0.00010514837428201229, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + { + "valid": 2791, + "positives": 7, + "negatives": 2784, + "auroc": 0.7556444991789819, + "auprc": 0.00846365354786772, + "brier": 0.0025063107000505417, + "calibration": { + "observed_rate": 0.0025080616266571123, + "mean_prediction": 0.0026849557164381186, + "calibration_in_the_large": 0.00017689408978100634, + "expected_calibration_error_10bin": 0.00017689408978100634, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + { + "valid": 2791, + "positives": 7, + "negatives": 2784, + "auroc": 0.7559523809523809, + "auprc": 0.00855697594632038, + "brier": 0.002510564756899044, + "calibration": { + "observed_rate": 0.0025080616266571123, + "mean_prediction": 0.0030777330689021115, + "calibration_in_the_large": 0.0005696714422449992, + "expected_calibration_error_10bin": 0.0005696714422449992, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + { + "valid": 2791, + "positives": 7, + "negatives": 2784, + "auroc": 0.7548747947454844, + "auprc": 0.008614417656133844, + "brier": 0.002511950939738713, + "calibration": { + "observed_rate": 0.0025080616266571123, + "mean_prediction": 0.0031829207510706723, + "calibration_in_the_large": 0.0006748591244135601, + "expected_calibration_error_10bin": 0.0006748591244135601, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + { + "valid": 2791, + "positives": 7, + "negatives": 2784, + "auroc": 0.7548747947454844, + "auprc": 0.008696656513582417, + "brier": 0.0025139774586269525, + "calibration": { + "observed_rate": 0.0025080616266571123, + "mean_prediction": 0.0033819004943330014, + "calibration_in_the_large": 0.0008738388676758891, + "expected_calibration_error_10bin": 0.0008738388676758891, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + { + "valid": 2791, + "positives": 7, + "negatives": 2784, + "auroc": 0.7549774220032841, + "auprc": 0.00870044587797338, + "brier": 0.002514134485278175, + "calibration": { + "observed_rate": 0.0025080616266571123, + "mean_prediction": 0.0033905448696826073, + "calibration_in_the_large": 0.000882483243025495, + "expected_calibration_error_10bin": 0.000882483243025495, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + } + ], + "reason": null + }, + "I07": { + "time_averaged_auroc": 0.8737723872893898, + "time_averaged_auprc": 0.009058260844691302, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2823, + "positives": 0, + "negatives": 2823, + "auroc": null, + "auprc": null, + "brier": 5.524535308363646e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0002233209153057736, + "calibration_in_the_large": 0.0002233209153057736, + "expected_calibration_error_10bin": 0.0002233209153057736, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 2, + "negatives": 2821, + "auroc": 0.858738036157391, + "auprc": 0.003891693713186681, + "brier": 0.0007101555005144452, + "calibration": { + "observed_rate": 0.0007084661707403471, + "mean_prediction": 0.0004211151089943853, + "calibration_in_the_large": -0.00028735106174596184, + "expected_calibration_error_10bin": 0.00028735106174596184, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 2, + "negatives": 2821, + "auroc": 0.8566111308046792, + "auprc": 0.0038430006148800983, + "brier": 0.0007109179702082878, + "calibration": { + "observed_rate": 0.0007084661707403471, + "mean_prediction": 0.0004980391821325694, + "calibration_in_the_large": -0.00021042698860777777, + "expected_calibration_error_10bin": 0.00021042698860777777, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 4, + "negatives": 2819, + "auroc": 0.882493792124867, + "auprc": 0.008207574006945627, + "brier": 0.0014180819487550167, + "calibration": { + "observed_rate": 0.0014169323414806943, + "mean_prediction": 0.0007190732099971347, + "calibration_in_the_large": -0.0006978591314835596, + "expected_calibration_error_10bin": 0.0006978591314835596, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 5, + "negatives": 2818, + "auroc": 0.8964513839602555, + "auprc": 0.01084502237808183, + "brier": 0.0017715538963612566, + "calibration": { + "observed_rate": 0.001771165426850868, + "mean_prediction": 0.0008243848880683278, + "calibration_in_the_large": -0.0009467805387825401, + "expected_calibration_error_10bin": 0.0009467805387825401, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 5, + "negatives": 2818, + "auroc": 0.8920511000709723, + "auprc": 0.010423905317559903, + "brier": 0.00177333247552087, + "calibration": { + "observed_rate": 0.001771165426850868, + "mean_prediction": 0.0009715672193839739, + "calibration_in_the_large": -0.000799598207466894, + "expected_calibration_error_10bin": 0.000799598207466894, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.8693645722399717, + "auprc": 0.010149021673809303, + "brier": 0.0021298034303848194, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.00113053111459477, + "calibration_in_the_large": -0.0009948673976262713, + "expected_calibration_error_10bin": 0.0009948673976262713, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.8697195598154065, + "auprc": 0.01010325210647089, + "brier": 0.002131473328994385, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0012205432135699104, + "calibration_in_the_large": -0.0009048552986511309, + "expected_calibration_error_10bin": 0.0009048552986511309, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.8710803455212401, + "auprc": 0.010182612839942094, + "brier": 0.0021360602577484376, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.001382243762183776, + "calibration_in_the_large": -0.0007431547500372654, + "expected_calibration_error_10bin": 0.0008955823119799764, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.8719678144598272, + "auprc": 0.010255338853631443, + "brier": 0.0021376818731943968, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0014448684310051565, + "calibration_in_the_large": -0.0006805300812158849, + "expected_calibration_error_10bin": 0.0008383542441071904, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.8722636374393563, + "auprc": 0.010249400617757403, + "brier": 0.002141244306484354, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0015263072834073718, + "calibration_in_the_large": -0.0005990912288136696, + "expected_calibration_error_10bin": 0.0007710295836737464, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.8722044728434505, + "auprc": 0.010271788655453385, + "brier": 0.0021467672065153633, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.00166289613058187, + "calibration_in_the_large": -0.00046250238163917127, + "expected_calibration_error_10bin": 0.000652308970670492, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.8723228020352621, + "auprc": 0.01027651935857695, + "brier": 0.0021469501845024783, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0016688780469343194, + "calibration_in_the_large": -0.0004565204652867219, + "expected_calibration_error_10bin": 0.0006468738525072282, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + } + ], + "reason": null + }, + "I08": { + "time_averaged_auroc": 0.875412045030035, + "time_averaged_auprc": 0.027307090809132288, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2767, + "positives": 1, + "negatives": 2766, + "auroc": 0.9125090383224873, + "auprc": 0.00411522633744856, + "brier": 0.0004002196543146946, + "calibration": { + "observed_rate": 0.0003614022406938923, + "mean_prediction": 0.0020016824274590103, + "calibration_in_the_large": 0.001640280186765118, + "expected_calibration_error_10bin": 0.001640280186765118, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + { + "valid": 2767, + "positives": 4, + "negatives": 2763, + "auroc": 0.8906080347448425, + "auprc": 0.008467823966521355, + "brier": 0.001501019911987942, + "calibration": { + "observed_rate": 0.0014456089627755693, + "mean_prediction": 0.0028612748829397387, + "calibration_in_the_large": 0.0014156659201641694, + "expected_calibration_error_10bin": 0.0014156659201641697, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + { + "valid": 2767, + "positives": 5, + "negatives": 2762, + "auroc": 0.8640839971035481, + "auprc": 0.008064686825399996, + "brier": 0.001937585341133701, + "calibration": { + "observed_rate": 0.0018070112034694614, + "mean_prediction": 0.004058139441917553, + "calibration_in_the_large": 0.002251128238448091, + "expected_calibration_error_10bin": 0.0022511282384480905, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + { + "valid": 2767, + "positives": 8, + "negatives": 2759, + "auroc": 0.8631750634287786, + "auprc": 0.018927897684757684, + "brier": 0.0030052481328057172, + "calibration": { + "observed_rate": 0.0028912179255511385, + "mean_prediction": 0.005107413086438693, + "calibration_in_the_large": 0.0022161951608875544, + "expected_calibration_error_10bin": 0.002216195160887554, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + { + "valid": 2767, + "positives": 8, + "negatives": 2759, + "auroc": 0.8621330192098586, + "auprc": 0.018806813535392906, + "brier": 0.003041049374229686, + "calibration": { + "observed_rate": 0.0028912179255511385, + "mean_prediction": 0.0055966981708137735, + "calibration_in_the_large": 0.002705480245262635, + "expected_calibration_error_10bin": 0.0027054802452626354, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + { + "valid": 2767, + "positives": 8, + "negatives": 2759, + "auroc": 0.8616346502355926, + "auprc": 0.01876560348219335, + "brier": 0.003100487393562853, + "calibration": { + "observed_rate": 0.0028912179255511385, + "mean_prediction": 0.006221516622913026, + "calibration_in_the_large": 0.003330298697361887, + "expected_calibration_error_10bin": 0.0033302986973618868, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + { + "valid": 2767, + "positives": 9, + "negatives": 2758, + "auroc": 0.8734590282813633, + "auprc": 0.023470339906502092, + "brier": 0.0034811085086358198, + "calibration": { + "observed_rate": 0.0032526201662450307, + "mean_prediction": 0.00687343648466368, + "calibration_in_the_large": 0.0036208163184186493, + "expected_calibration_error_10bin": 0.0036208163184186493, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + { + "valid": 2767, + "positives": 12, + "negatives": 2755, + "auroc": 0.8712038717483364, + "auprc": 0.02670634920518837, + "brier": 0.004557341842827637, + "calibration": { + "observed_rate": 0.0043368268883267076, + "mean_prediction": 0.007356097833657, + "calibration_in_the_large": 0.0030192709453302925, + "expected_calibration_error_10bin": 0.003019270945330293, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + { + "valid": 2767, + "positives": 12, + "negatives": 2755, + "auroc": 0.869903206291591, + "auprc": 0.026574463208169617, + "brier": 0.004595003821531304, + "calibration": { + "observed_rate": 0.0043368268883267076, + "mean_prediction": 0.00772871604905852, + "calibration_in_the_large": 0.0033918891607318128, + "expected_calibration_error_10bin": 0.0033918891607318128, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + { + "valid": 2767, + "positives": 12, + "negatives": 2755, + "auroc": 0.8698124621899577, + "auprc": 0.026677377392102204, + "brier": 0.004650145046721754, + "calibration": { + "observed_rate": 0.0043368268883267076, + "mean_prediction": 0.008179050983321447, + "calibration_in_the_large": 0.0038422240949947395, + "expected_calibration_error_10bin": 0.0038422240949947404, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + { + "valid": 2767, + "positives": 13, + "negatives": 2754, + "auroc": 0.8785542707111335, + "auprc": 0.032507693946604244, + "brier": 0.00499092983003986, + "calibration": { + "observed_rate": 0.0046982291290206, + "mean_prediction": 0.00852122968387192, + "calibration_in_the_large": 0.003823000554851321, + "expected_calibration_error_10bin": 0.0038230005548513194, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + { + "valid": 2767, + "positives": 13, + "negatives": 2754, + "auroc": 0.877129769286632, + "auprc": 0.03136804415341628, + "brier": 0.0050467218601213774, + "calibration": { + "observed_rate": 0.0046982291290206, + "mean_prediction": 0.009000315609503427, + "calibration_in_the_large": 0.004302086480482827, + "expected_calibration_error_10bin": 0.004302086480482827, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + { + "valid": 2767, + "positives": 14, + "negatives": 2753, + "auroc": 0.8861501738363344, + "auprc": 0.11053986087502306, + "brier": 0.005162504591412194, + "calibration": { + "observed_rate": 0.005059631369714492, + "mean_prediction": 0.009012682176821905, + "calibration_in_the_large": 0.0039530508071074135, + "expected_calibration_error_10bin": 0.00420741187307434, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + } + ], + "reason": null + }, + "I10": { + "time_averaged_auroc": 0.6710269859033169, + "time_averaged_auprc": 0.05519865761924073, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 1498, + "positives": 14, + "negatives": 1484, + "auroc": 0.6330381209087409, + "auprc": 0.022605333733593098, + "brier": 0.00926443382894454, + "calibration": { + "observed_rate": 0.009345794392523364, + "mean_prediction": 0.006038658783437084, + "calibration_in_the_large": -0.00330713560908628, + "expected_calibration_error_10bin": 0.00330713560908628, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + { + "valid": 1498, + "positives": 22, + "negatives": 1476, + "auroc": 0.6431079083518108, + "auprc": 0.03559381453860556, + "brier": 0.014434632128636436, + "calibration": { + "observed_rate": 0.014686248331108143, + "mean_prediction": 0.009048042952649429, + "calibration_in_the_large": -0.005638205378458714, + "expected_calibration_error_10bin": 0.006234045159640549, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + { + "valid": 1498, + "positives": 24, + "negatives": 1474, + "auroc": 0.6571687019448214, + "auprc": 0.04669732838715448, + "brier": 0.015655223652629915, + "calibration": { + "observed_rate": 0.01602136181575434, + "mean_prediction": 0.011173576176828967, + "calibration_in_the_large": -0.004847785638925373, + "expected_calibration_error_10bin": 0.006455592939840598, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + { + "valid": 1498, + "positives": 27, + "negatives": 1471, + "auroc": 0.6692096583327038, + "auprc": 0.05059163307629828, + "brier": 0.017586066612314998, + "calibration": { + "observed_rate": 0.018024032042723633, + "mean_prediction": 0.013015500295320365, + "calibration_in_the_large": -0.005008531747403268, + "expected_calibration_error_10bin": 0.006373425869169199, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + { + "valid": 1498, + "positives": 31, + "negatives": 1467, + "auroc": 0.6859511401367724, + "auprc": 0.05974013604072841, + "brier": 0.020101754055532425, + "calibration": { + "observed_rate": 0.02069425901201602, + "mean_prediction": 0.014475272037399727, + "calibration_in_the_large": -0.006218986974616293, + "expected_calibration_error_10bin": 0.00757366404259386, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + { + "valid": 1498, + "positives": 33, + "negatives": 1465, + "auroc": 0.6753335401799566, + "auprc": 0.058294681966327144, + "brier": 0.021447771582769545, + "calibration": { + "observed_rate": 0.022029372496662217, + "mean_prediction": 0.015671013848693204, + "calibration_in_the_large": -0.006358358647969013, + "expected_calibration_error_10bin": 0.008496324475313748, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + { + "valid": 1498, + "positives": 34, + "negatives": 1464, + "auroc": 0.6776960784313726, + "auprc": 0.057802575051274736, + "brier": 0.022104469811172034, + "calibration": { + "observed_rate": 0.022696929238985315, + "mean_prediction": 0.01676216640619086, + "calibration_in_the_large": -0.005934762832794455, + "expected_calibration_error_10bin": 0.008467843294459505, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + { + "valid": 1498, + "positives": 36, + "negatives": 1462, + "auroc": 0.6768315853473172, + "auprc": 0.058850558233233215, + "brier": 0.023410831572547076, + "calibration": { + "observed_rate": 0.02403204272363151, + "mean_prediction": 0.017907434710048423, + "calibration_in_the_large": -0.006124608013583086, + "expected_calibration_error_10bin": 0.008839228426809431, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + { + "valid": 1498, + "positives": 38, + "negatives": 1460, + "auroc": 0.6800829127613555, + "auprc": 0.06407893742838744, + "brier": 0.024654464969888063, + "calibration": { + "observed_rate": 0.025367156208277702, + "mean_prediction": 0.018848096422222536, + "calibration_in_the_large": -0.006519059786055166, + "expected_calibration_error_10bin": 0.009471526923940675, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + { + "valid": 1498, + "positives": 40, + "negatives": 1458, + "auroc": 0.6801097393689987, + "auprc": 0.06453995193046583, + "brier": 0.02598800014901961, + "calibration": { + "observed_rate": 0.0267022696929239, + "mean_prediction": 0.020202559426048265, + "calibration_in_the_large": -0.006499710266875635, + "expected_calibration_error_10bin": 0.00993243938298568, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + { + "valid": 1498, + "positives": 40, + "negatives": 1458, + "auroc": 0.6815672153635116, + "auprc": 0.06445352074000801, + "brier": 0.0260146185118163, + "calibration": { + "observed_rate": 0.0267022696929239, + "mean_prediction": 0.021194234507258495, + "calibration_in_the_large": -0.005508035185665405, + "expected_calibration_error_10bin": 0.008013003423001161, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + { + "valid": 1498, + "positives": 43, + "negatives": 1455, + "auroc": 0.6813873571485655, + "auprc": 0.0671629940241298, + "brier": 0.028016143087438067, + "calibration": { + "observed_rate": 0.02870493991989319, + "mean_prediction": 0.022110243377963378, + "calibration_in_the_large": -0.006594696541929814, + "expected_calibration_error_10bin": 0.010096142153990502, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + { + "valid": 1498, + "positives": 43, + "negatives": 1455, + "auroc": 0.6818668584671941, + "auprc": 0.0671710838999236, + "brier": 0.02802141604050129, + "calibration": { + "observed_rate": 0.02870493991989319, + "mean_prediction": 0.022362400157947854, + "calibration_in_the_large": -0.006342539761945338, + "expected_calibration_error_10bin": 0.009877612599661604, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + } + ], + "reason": null + }, + "I11": { + "time_averaged_auroc": 0.816231682076056, + "time_averaged_auprc": 0.052408150489239205, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2676, + "positives": 8, + "negatives": 2668, + "auroc": 0.8320839580209896, + "auprc": 0.013217271252680332, + "brier": 0.0029782956036406134, + "calibration": { + "observed_rate": 0.0029895366218236174, + "mean_prediction": 0.0024656688166425048, + "calibration_in_the_large": -0.0005238678051811127, + "expected_calibration_error_10bin": 0.0005238678051811127, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + { + "valid": 2676, + "positives": 17, + "negatives": 2659, + "auroc": 0.8297458133309736, + "auprc": 0.025596620307771333, + "brier": 0.00630238073036184, + "calibration": { + "observed_rate": 0.006352765321375187, + "mean_prediction": 0.005015048052506538, + "calibration_in_the_large": -0.0013377172688686483, + "expected_calibration_error_10bin": 0.001627923753420926, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + { + "valid": 2676, + "positives": 22, + "negatives": 2654, + "auroc": 0.8385798451736658, + "auprc": 0.03141619292907201, + "brier": 0.008135844979783011, + "calibration": { + "observed_rate": 0.008221225710014948, + "mean_prediction": 0.006376483280450103, + "calibration_in_the_large": -0.0018447424295648454, + "expected_calibration_error_10bin": 0.0021200351125511127, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + { + "valid": 2676, + "positives": 27, + "negatives": 2649, + "auroc": 0.8160451882611188, + "auprc": 0.03694384925802748, + "brier": 0.009956141070086102, + "calibration": { + "observed_rate": 0.010089686098654708, + "mean_prediction": 0.00797280529756623, + "calibration_in_the_large": -0.0021168808010884783, + "expected_calibration_error_10bin": 0.002994037515553174, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + { + "valid": 2676, + "positives": 28, + "negatives": 2648, + "auroc": 0.8187446050927925, + "auprc": 0.03909675108448839, + "brier": 0.010317833397945536, + "calibration": { + "observed_rate": 0.01046337817638266, + "mean_prediction": 0.008668181158022707, + "calibration_in_the_large": -0.0017951970183599543, + "expected_calibration_error_10bin": 0.0030804891931440113, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + { + "valid": 2676, + "positives": 32, + "negatives": 2644, + "auroc": 0.8128072995461422, + "auprc": 0.041556459541285645, + "brier": 0.011775235345142422, + "calibration": { + "observed_rate": 0.01195814648729447, + "mean_prediction": 0.00952615682031606, + "calibration_in_the_large": -0.002431989666978409, + "expected_calibration_error_10bin": 0.004324260680115345, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + { + "valid": 2676, + "positives": 38, + "negatives": 2638, + "auroc": 0.8055544471489565, + "auprc": 0.04705005692411059, + "brier": 0.01391404645953211, + "calibration": { + "observed_rate": 0.014200298953662182, + "mean_prediction": 0.010556690377558563, + "calibration_in_the_large": -0.0036436085761036192, + "expected_calibration_error_10bin": 0.005628110588166833, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + { + "valid": 2676, + "positives": 43, + "negatives": 2633, + "auroc": 0.8164354039516336, + "auprc": 0.06308384023091065, + "brier": 0.015562350911770587, + "calibration": { + "observed_rate": 0.016068759342301942, + "mean_prediction": 0.011156922532074766, + "calibration_in_the_large": -0.004911836810227176, + "expected_calibration_error_10bin": 0.005909477888118771, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + { + "valid": 2676, + "positives": 45, + "negatives": 2631, + "auroc": 0.8092824865914946, + "auprc": 0.0663650455282426, + "brier": 0.01625907913018351, + "calibration": { + "observed_rate": 0.016816143497757848, + "mean_prediction": 0.011760906495859813, + "calibration_in_the_large": -0.005055237001898034, + "expected_calibration_error_10bin": 0.006463183463239162, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + { + "valid": 2676, + "positives": 48, + "negatives": 2628, + "auroc": 0.80900399543379, + "auprc": 0.06784018604474637, + "brier": 0.01734301235471971, + "calibration": { + "observed_rate": 0.017937219730941704, + "mean_prediction": 0.012245317376936217, + "calibration_in_the_large": -0.005691902354005487, + "expected_calibration_error_10bin": 0.007471891029379573, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + { + "valid": 2676, + "positives": 53, + "negatives": 2623, + "auroc": 0.8097454304807257, + "auprc": 0.08254578060417839, + "brier": 0.018969142030296482, + "calibration": { + "observed_rate": 0.019805680119581465, + "mean_prediction": 0.013047144007011938, + "calibration_in_the_large": -0.006758536112569527, + "expected_calibration_error_10bin": 0.008773035415016282, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + { + "valid": 2676, + "positives": 57, + "negatives": 2619, + "auroc": 0.806535238439742, + "auprc": 0.08330995098537382, + "brier": 0.02039833352055531, + "calibration": { + "observed_rate": 0.021300448430493273, + "mean_prediction": 0.013520418447195145, + "calibration_in_the_large": -0.007780029983298128, + "expected_calibration_error_10bin": 0.010028593640858821, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + { + "valid": 2676, + "positives": 57, + "negatives": 2619, + "auroc": 0.8064481555167031, + "auprc": 0.08328395166922202, + "brier": 0.02039901609388742, + "calibration": { + "observed_rate": 0.021300448430493273, + "mean_prediction": 0.013595073624503908, + "calibration_in_the_large": -0.007705374805989365, + "expected_calibration_error_10bin": 0.010583686059037747, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + } + ], + "reason": null + }, + "I12": { + "time_averaged_auroc": 0.8235345135735191, + "time_averaged_auprc": 0.04697709006999918, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2552, + "positives": 8, + "negatives": 2544, + "auroc": 0.7987421383647799, + "auprc": 0.023198438160260976, + "brier": 0.003118513158422045, + "calibration": { + "observed_rate": 0.003134796238244514, + "mean_prediction": 0.0015934728022546773, + "calibration_in_the_large": -0.0015413234359898367, + "expected_calibration_error_10bin": 0.0016484496822284137, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + { + "valid": 2552, + "positives": 10, + "negatives": 2542, + "auroc": 0.8302911093627066, + "auprc": 0.03385608858021495, + "brier": 0.003886745251749079, + "calibration": { + "observed_rate": 0.003918495297805642, + "mean_prediction": 0.0028913911533053004, + "calibration_in_the_large": -0.0010271041445003419, + "expected_calibration_error_10bin": 0.0012774333758940903, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + { + "valid": 2552, + "positives": 11, + "negatives": 2541, + "auroc": 0.8351400665450253, + "auprc": 0.03224784275869246, + "brier": 0.004290844733131521, + "calibration": { + "observed_rate": 0.004310344827586207, + "mean_prediction": 0.003454862139485406, + "calibration_in_the_large": -0.000855482688100801, + "expected_calibration_error_10bin": 0.001341636750628275, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + { + "valid": 2552, + "positives": 16, + "negatives": 2536, + "auroc": 0.797910094637224, + "auprc": 0.03215454936693705, + "brier": 0.006235166169214403, + "calibration": { + "observed_rate": 0.006269592476489028, + "mean_prediction": 0.004271152281023625, + "calibration_in_the_large": -0.001998440195465403, + "expected_calibration_error_10bin": 0.0029788021470680674, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + { + "valid": 2552, + "positives": 17, + "negatives": 2535, + "auroc": 0.8044320686854624, + "auprc": 0.03277080225882184, + "brier": 0.006658052597712876, + "calibration": { + "observed_rate": 0.0066614420062695925, + "mean_prediction": 0.00500266629015416, + "calibration_in_the_large": -0.001658775716115433, + "expected_calibration_error_10bin": 0.003295870863654888, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + { + "valid": 2552, + "positives": 19, + "negatives": 2533, + "auroc": 0.8098572526856027, + "auprc": 0.04014991081501453, + "brier": 0.0073969991224258754, + "calibration": { + "observed_rate": 0.007445141065830721, + "mean_prediction": 0.005668381020791529, + "calibration_in_the_large": -0.0017767600450391916, + "expected_calibration_error_10bin": 0.003063817865665005, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + { + "valid": 2552, + "positives": 21, + "negatives": 2531, + "auroc": 0.817613967752253, + "auprc": 0.04970919447895047, + "brier": 0.00813243584048054, + "calibration": { + "observed_rate": 0.008228840125391849, + "mean_prediction": 0.006447038917991837, + "calibration_in_the_large": -0.0017818012074000125, + "expected_calibration_error_10bin": 0.0032414840932026637, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + { + "valid": 2552, + "positives": 23, + "negatives": 2529, + "auroc": 0.8255540082864855, + "auprc": 0.05130945253318322, + "brier": 0.008916050848074007, + "calibration": { + "observed_rate": 0.009012539184952978, + "mean_prediction": 0.006974160792088585, + "calibration_in_the_large": -0.0020383783928643933, + "expected_calibration_error_10bin": 0.003944646376183637, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + { + "valid": 2552, + "positives": 26, + "negatives": 2526, + "auroc": 0.8405505816432183, + "auprc": 0.06072213687100792, + "brier": 0.010017743188180672, + "calibration": { + "observed_rate": 0.01018808777429467, + "mean_prediction": 0.007378884786273052, + "calibration_in_the_large": -0.002809202988021618, + "expected_calibration_error_10bin": 0.00419214628336105, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + { + "valid": 2552, + "positives": 28, + "negatives": 2524, + "auroc": 0.8443089200815033, + "auprc": 0.06287585682744874, + "brier": 0.010809658913405662, + "calibration": { + "observed_rate": 0.0109717868338558, + "mean_prediction": 0.008206241321090246, + "calibration_in_the_large": -0.0027655455127655534, + "expected_calibration_error_10bin": 0.004947691235466438, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + { + "valid": 2552, + "positives": 29, + "negatives": 2523, + "auroc": 0.8476362294477018, + "auprc": 0.06461218629574332, + "brier": 0.011201492664383614, + "calibration": { + "observed_rate": 0.011363636363636364, + "mean_prediction": 0.008667555754352371, + "calibration_in_the_large": -0.002696080609283993, + "expected_calibration_error_10bin": 0.005033932220521534, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + { + "valid": 2552, + "positives": 30, + "negatives": 2522, + "auroc": 0.8269627279936558, + "auprc": 0.06345675880070688, + "brier": 0.01161637782116618, + "calibration": { + "observed_rate": 0.011755485893416929, + "mean_prediction": 0.009094502037675787, + "calibration_in_the_large": -0.0026609838557411416, + "expected_calibration_error_10bin": 0.005109893751288272, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + { + "valid": 2552, + "positives": 30, + "negatives": 2522, + "auroc": 0.8269495109701295, + "auprc": 0.06363895316300708, + "brier": 0.011619465386968609, + "calibration": { + "observed_rate": 0.011755485893416929, + "mean_prediction": 0.009151173116416918, + "calibration_in_the_large": -0.0026043127770000105, + "expected_calibration_error_10bin": 0.005066130324632245, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + } + ], + "reason": null + }, + "I13": { + "time_averaged_auroc": 0.8830483133391218, + "time_averaged_auprc": 0.09867074924728247, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2727, + "positives": 4, + "negatives": 2723, + "auroc": 0.8412596401028277, + "auprc": 0.011664587918641249, + "brier": 0.0014761125119752566, + "calibration": { + "observed_rate": 0.0014668133480014668, + "mean_prediction": 0.002128738211377313, + "calibration_in_the_large": 0.0006619248633758462, + "expected_calibration_error_10bin": 0.0006619248633758462, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + { + "valid": 2727, + "positives": 7, + "negatives": 2720, + "auroc": 0.8848214285714285, + "auprc": 0.04876815185303688, + "brier": 0.002560738217404051, + "calibration": { + "observed_rate": 0.002566923359002567, + "mean_prediction": 0.004272747338710311, + "calibration_in_the_large": 0.0017058239797077442, + "expected_calibration_error_10bin": 0.001705823979707744, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + { + "valid": 2727, + "positives": 11, + "negatives": 2716, + "auroc": 0.8772258669165885, + "auprc": 0.048652927953894975, + "brier": 0.004017550046712887, + "calibration": { + "observed_rate": 0.004033736707004034, + "mean_prediction": 0.0056849794681377, + "calibration_in_the_large": 0.0016512427611336663, + "expected_calibration_error_10bin": 0.0016512427611336668, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + { + "valid": 2727, + "positives": 16, + "negatives": 2711, + "auroc": 0.8551733677609739, + "auprc": 0.05262847562697052, + "brier": 0.005799247135756655, + "calibration": { + "observed_rate": 0.005867253392005867, + "mean_prediction": 0.006565176132503507, + "calibration_in_the_large": 0.0006979227404976399, + "expected_calibration_error_10bin": 0.0014655693452812965, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + { + "valid": 2727, + "positives": 18, + "negatives": 2709, + "auroc": 0.869385997292974, + "auprc": 0.06387249527158653, + "brier": 0.006484067245604567, + "calibration": { + "observed_rate": 0.006600660066006601, + "mean_prediction": 0.00755321446500378, + "calibration_in_the_large": 0.0009525543989971795, + "expected_calibration_error_10bin": 0.0019820280313653463, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + { + "valid": 2727, + "positives": 20, + "negatives": 2707, + "auroc": 0.8782046545991873, + "auprc": 0.07165306863159264, + "brier": 0.007187922293697547, + "calibration": { + "observed_rate": 0.007334066740007334, + "mean_prediction": 0.008618144137104105, + "calibration_in_the_large": 0.001284077397096771, + "expected_calibration_error_10bin": 0.0012840773970967715, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + { + "valid": 2727, + "positives": 23, + "negatives": 2704, + "auroc": 0.8936358374067405, + "auprc": 0.11257125699712466, + "brier": 0.007908548010688002, + "calibration": { + "observed_rate": 0.008434176751008434, + "mean_prediction": 0.009319941791559724, + "calibration_in_the_large": 0.0008857650405512899, + "expected_calibration_error_10bin": 0.0008857650405512895, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + { + "valid": 2727, + "positives": 24, + "negatives": 2703, + "auroc": 0.8902299913676163, + "auprc": 0.10918722778517444, + "brier": 0.008311723520116169, + "calibration": { + "observed_rate": 0.0088008800880088, + "mean_prediction": 0.009963564244720313, + "calibration_in_the_large": 0.0011626841567115125, + "expected_calibration_error_10bin": 0.0012517380313795388, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + { + "valid": 2727, + "positives": 26, + "negatives": 2701, + "auroc": 0.89294563267166, + "auprc": 0.11601511090811562, + "brier": 0.008990003905651862, + "calibration": { + "observed_rate": 0.009534286762009535, + "mean_prediction": 0.010791431811178828, + "calibration_in_the_large": 0.001257145049169293, + "expected_calibration_error_10bin": 0.002201017330377759, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + { + "valid": 2727, + "positives": 27, + "negatives": 2700, + "auroc": 0.8964471879286694, + "auprc": 0.12006044613738569, + "brier": 0.00930100286499386, + "calibration": { + "observed_rate": 0.009900990099009901, + "mean_prediction": 0.011180770982663938, + "calibration_in_the_large": 0.0012797808836540366, + "expected_calibration_error_10bin": 0.002289205695284091, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + { + "valid": 2727, + "positives": 30, + "negatives": 2697, + "auroc": 0.9017797552836485, + "auprc": 0.1786771175950128, + "brier": 0.009928218313239562, + "calibration": { + "observed_rate": 0.011001100110011002, + "mean_prediction": 0.012121835370735435, + "calibration_in_the_large": 0.0011207352607244328, + "expected_calibration_error_10bin": 0.004184259766691482, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + { + "valid": 2727, + "positives": 31, + "negatives": 2696, + "auroc": 0.8992533741744041, + "auprc": 0.1744900330371831, + "brier": 0.010318610738986966, + "calibration": { + "observed_rate": 0.011367803447011368, + "mean_prediction": 0.012680112254506458, + "calibration_in_the_large": 0.0013123088074950898, + "expected_calibration_error_10bin": 0.0034637031557847526, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + { + "valid": 2727, + "positives": 31, + "negatives": 2696, + "auroc": 0.8992653393318656, + "auprc": 0.1744788404989531, + "brier": 0.010320894304744869, + "calibration": { + "observed_rate": 0.011367803447011368, + "mean_prediction": 0.012743645713856675, + "calibration_in_the_large": 0.0013758422668453067, + "expected_calibration_error_10bin": 0.0035005412750172328, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + } + ], + "reason": null + }, + "I16": { + "time_averaged_auroc": 0.8912746479842821, + "time_averaged_auprc": 0.02461268588520911, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2390, + "positives": 1, + "negatives": 2389, + "auroc": 0.9363750523231478, + "auprc": 0.006535947712418301, + "brier": 0.00041781660935433565, + "calibration": { + "observed_rate": 0.00041841004184100416, + "mean_prediction": 0.0004256600298994953, + "calibration_in_the_large": 7.249988058491115e-06, + "expected_calibration_error_10bin": 7.249988058491115e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + { + "valid": 2390, + "positives": 2, + "negatives": 2388, + "auroc": 0.8990787269681743, + "auprc": 0.009105691056910569, + "brier": 0.0008349846961243634, + "calibration": { + "observed_rate": 0.0008368200836820083, + "mean_prediction": 0.0008361778862095607, + "calibration_in_the_large": -6.42197472447599e-07, + "expected_calibration_error_10bin": 6.42197472447599e-07, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + { + "valid": 2390, + "positives": 4, + "negatives": 2386, + "auroc": 0.9255029337803856, + "auprc": 0.025252007753769557, + "brier": 0.0016604340876432634, + "calibration": { + "observed_rate": 0.0016736401673640166, + "mean_prediction": 0.001104604264618802, + "calibration_in_the_large": -0.0005690359027452146, + "expected_calibration_error_10bin": 0.0005690359027452146, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + { + "valid": 2390, + "positives": 7, + "negatives": 2383, + "auroc": 0.8790839877705173, + "auprc": 0.02483530084204844, + "brier": 0.00290390055630264, + "calibration": { + "observed_rate": 0.0029288702928870294, + "mean_prediction": 0.001493726641998958, + "calibration_in_the_large": -0.0014351436508880714, + "expected_calibration_error_10bin": 0.0014351436508880714, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + { + "valid": 2390, + "positives": 8, + "negatives": 2382, + "auroc": 0.87053946263644, + "auprc": 0.02336135939183502, + "brier": 0.003318115247654445, + "calibration": { + "observed_rate": 0.0033472803347280333, + "mean_prediction": 0.0017313951050203754, + "calibration_in_the_large": -0.001615885229707658, + "expected_calibration_error_10bin": 0.001615885229707658, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + { + "valid": 2390, + "positives": 8, + "negatives": 2382, + "auroc": 0.869857262804366, + "auprc": 0.022485753313367832, + "brier": 0.0033171917360568775, + "calibration": { + "observed_rate": 0.0033472803347280333, + "mean_prediction": 0.0019568879341015084, + "calibration_in_the_large": -0.0013903924006265249, + "expected_calibration_error_10bin": 0.0013903924006265249, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + { + "valid": 2390, + "positives": 8, + "negatives": 2382, + "auroc": 0.8705919395465995, + "auprc": 0.022087188875337997, + "brier": 0.00331687655251513, + "calibration": { + "observed_rate": 0.0033472803347280333, + "mean_prediction": 0.002112661163578595, + "calibration_in_the_large": -0.001234619171149438, + "expected_calibration_error_10bin": 0.001234619171149438, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + { + "valid": 2390, + "positives": 9, + "negatives": 2381, + "auroc": 0.872789210882449, + "auprc": 0.022756021010146135, + "brier": 0.0037312383755873737, + "calibration": { + "observed_rate": 0.0037656903765690376, + "mean_prediction": 0.00226056850072051, + "calibration_in_the_large": -0.0015051218758485277, + "expected_calibration_error_10bin": 0.0015051218758485277, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + { + "valid": 2390, + "positives": 10, + "negatives": 2380, + "auroc": 0.882563025210084, + "auprc": 0.027593113006813785, + "brier": 0.0041365161473644226, + "calibration": { + "observed_rate": 0.0041841004184100415, + "mean_prediction": 0.0025919454053159275, + "calibration_in_the_large": -0.001592155013094114, + "expected_calibration_error_10bin": 0.001592155013094114, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + { + "valid": 2390, + "positives": 11, + "negatives": 2379, + "auroc": 0.8951813214108296, + "auprc": 0.03301715663393849, + "brier": 0.00454108965940709, + "calibration": { + "observed_rate": 0.004602510460251046, + "mean_prediction": 0.002826799949289277, + "calibration_in_the_large": -0.0017757105109617692, + "expected_calibration_error_10bin": 0.0017757105109617692, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + { + "valid": 2390, + "positives": 12, + "negatives": 2378, + "auroc": 0.8974278104850014, + "auprc": 0.03439535115442565, + "brier": 0.0049510216454872885, + "calibration": { + "observed_rate": 0.00502092050209205, + "mean_prediction": 0.0030630937024565446, + "calibration_in_the_large": -0.0019578267996355056, + "expected_calibration_error_10bin": 0.0019578267996355056, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + { + "valid": 2390, + "positives": 13, + "negatives": 2377, + "auroc": 0.8936603993398272, + "auprc": 0.03420658035822067, + "brier": 0.005363099598947774, + "calibration": { + "observed_rate": 0.005439330543933054, + "mean_prediction": 0.0032832932961222067, + "calibration_in_the_large": -0.0021560372478108473, + "expected_calibration_error_10bin": 0.0021560372478108473, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + { + "valid": 2390, + "positives": 13, + "negatives": 2377, + "auroc": 0.8939192906378435, + "auprc": 0.03433344539848596, + "brier": 0.005362988506048239, + "calibration": { + "observed_rate": 0.005439330543933054, + "mean_prediction": 0.0033214858617615557, + "calibration_in_the_large": -0.0021178446821714983, + "expected_calibration_error_10bin": 0.0021178446821714983, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + } + ], + "reason": null + }, + "I21": { + "time_averaged_auroc": 0.8505621889400108, + "time_averaged_auprc": 0.04629681587284245, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2671, + "positives": 3, + "negatives": 2668, + "auroc": 0.9307846076961519, + "auprc": 0.17286062412756997, + "brier": 0.0011021076263909879, + "calibration": { + "observed_rate": 0.0011231748408835642, + "mean_prediction": 0.00217127827451877, + "calibration_in_the_large": 0.001048103433635206, + "expected_calibration_error_10bin": 0.001048103433635206, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 5, + "negatives": 2666, + "auroc": 0.9304576144036009, + "auprc": 0.04532753089546006, + "brier": 0.0018740980462777627, + "calibration": { + "observed_rate": 0.0018719580681392737, + "mean_prediction": 0.004885202565031725, + "calibration_in_the_large": 0.0030132444968924517, + "expected_calibration_error_10bin": 0.0030132444968924512, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 8, + "negatives": 2663, + "auroc": 0.8910063837776944, + "auprc": 0.03171787843929604, + "brier": 0.0030220356733604496, + "calibration": { + "observed_rate": 0.002995132909022838, + "mean_prediction": 0.006567004809474405, + "calibration_in_the_large": 0.0035718719004515665, + "expected_calibration_error_10bin": 0.0035791172176925165, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 9, + "negatives": 2662, + "auroc": 0.8408882210535104, + "auprc": 0.026475284515623202, + "brier": 0.003454927632779338, + "calibration": { + "observed_rate": 0.0033695245226506927, + "mean_prediction": 0.008350546298066879, + "calibration_in_the_large": 0.0049810217754161865, + "expected_calibration_error_10bin": 0.0049810217754161865, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 11, + "negatives": 2660, + "auroc": 0.8411825017088175, + "auprc": 0.02832454375024657, + "brier": 0.004217192896280929, + "calibration": { + "observed_rate": 0.0041183077499064025, + "mean_prediction": 0.009724824872303613, + "calibration_in_the_large": 0.0056065171223972105, + "expected_calibration_error_10bin": 0.005606517122397211, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 14, + "negatives": 2657, + "auroc": 0.8442658207430507, + "auprc": 0.03184339493439445, + "brier": 0.005311459765051809, + "calibration": { + "observed_rate": 0.005241482590789966, + "mean_prediction": 0.010571934886839447, + "calibration_in_the_large": 0.005330452296049481, + "expected_calibration_error_10bin": 0.0053304522960494795, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 18, + "negatives": 2653, + "auroc": 0.8235121665200821, + "auprc": 0.0347474150333235, + "brier": 0.0067895582340114875, + "calibration": { + "observed_rate": 0.0067390490453013855, + "mean_prediction": 0.011532184178769882, + "calibration_in_the_large": 0.004793135133468496, + "expected_calibration_error_10bin": 0.004793135133468496, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 19, + "negatives": 2652, + "auroc": 0.8316861157418433, + "auprc": 0.03780246796485587, + "brier": 0.007140574985230976, + "calibration": { + "observed_rate": 0.00711344065892924, + "mean_prediction": 0.011961327710459413, + "calibration_in_the_large": 0.004847887051530173, + "expected_calibration_error_10bin": 0.004847887051530175, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 19, + "negatives": 2652, + "auroc": 0.8312891958402794, + "auprc": 0.037862396388695305, + "brier": 0.007175663371790274, + "calibration": { + "observed_rate": 0.00711344065892924, + "mean_prediction": 0.012629725252282639, + "calibration_in_the_large": 0.005516284593353399, + "expected_calibration_error_10bin": 0.0055162845933533974, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 20, + "negatives": 2651, + "auroc": 0.8352319879290834, + "auprc": 0.03854673305586736, + "brier": 0.0075600345209558065, + "calibration": { + "observed_rate": 0.007487832272557095, + "mean_prediction": 0.013149935357906001, + "calibration_in_the_large": 0.005662103085348907, + "expected_calibration_error_10bin": 0.005662103085348905, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 22, + "negatives": 2649, + "auroc": 0.814303853941453, + "auprc": 0.036585262132837006, + "brier": 0.008328917445592594, + "calibration": { + "observed_rate": 0.008236615499812805, + "mean_prediction": 0.013627470302291268, + "calibration_in_the_large": 0.005390854802478463, + "expected_calibration_error_10bin": 0.0053908548024784635, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 23, + "negatives": 2648, + "auroc": 0.8213253645080782, + "auprc": 0.03990737935644175, + "brier": 0.008705606506461211, + "calibration": { + "observed_rate": 0.008611007113440658, + "mean_prediction": 0.014226441256201287, + "calibration_in_the_large": 0.005615434142760629, + "expected_calibration_error_10bin": 0.005615434142760628, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 23, + "negatives": 2648, + "auroc": 0.8213746223564955, + "auprc": 0.03985769575234076, + "brier": 0.008720571176127867, + "calibration": { + "observed_rate": 0.008611007113440658, + "mean_prediction": 0.014428555449024001, + "calibration_in_the_large": 0.005817548335583343, + "expected_calibration_error_10bin": 0.005817548335583342, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + } + ], + "reason": null + }, + "I24": { + "time_averaged_auroc": 0.912491793664446, + "time_averaged_auprc": 0.027881819069773436, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2809, + "positives": 1, + "negatives": 2808, + "auroc": 0.9704415954415955, + "auprc": 0.011904761904761904, + "brier": 0.0003549982548715471, + "calibration": { + "observed_rate": 0.000355998576005696, + "mean_prediction": 0.0004698240958920762, + "calibration_in_the_large": 0.00011382551988638022, + "expected_calibration_error_10bin": 0.00011382551988638022, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.9218026362664766, + "auprc": 0.010026737967914439, + "brier": 0.0007101072548618018, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0007647342867936532, + "calibration_in_the_large": 5.2737134782261164e-05, + "expected_calibration_error_10bin": 5.2737134782261164e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 3, + "negatives": 2806, + "auroc": 0.9390591589451176, + "auprc": 0.017580567580567582, + "brier": 0.0010616714049727746, + "calibration": { + "observed_rate": 0.001067995728017088, + "mean_prediction": 0.00095366647639906, + "calibration_in_the_large": -0.00011432925161802799, + "expected_calibration_error_10bin": 0.00011432925161802799, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 3, + "negatives": 2806, + "auroc": 0.9419101924447613, + "auprc": 0.019091183868216805, + "brier": 0.0010610262373717564, + "calibration": { + "observed_rate": 0.001067995728017088, + "mean_prediction": 0.0011977989143543998, + "calibration_in_the_large": 0.00012980318633731185, + "expected_calibration_error_10bin": 0.00012980318633731185, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 5, + "negatives": 2804, + "auroc": 0.8703994293865905, + "auprc": 0.029554895415088316, + "brier": 0.001762226960122071, + "calibration": { + "observed_rate": 0.00177999288002848, + "mean_prediction": 0.001319118841025254, + "calibration_in_the_large": -0.000460874039003226, + "expected_calibration_error_10bin": 0.000460874039003226, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 6, + "negatives": 2803, + "auroc": 0.885955523843501, + "auprc": 0.029174564423153606, + "brier": 0.0021136645261847524, + "calibration": { + "observed_rate": 0.002135991456034176, + "mean_prediction": 0.001378275343631232, + "calibration_in_the_large": -0.000757716112402944, + "expected_calibration_error_10bin": 0.000757716112402944, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 6, + "negatives": 2803, + "auroc": 0.8889285289570698, + "auprc": 0.030230155070327305, + "brier": 0.002111589492420123, + "calibration": { + "observed_rate": 0.002135991456034176, + "mean_prediction": 0.001525029182178214, + "calibration_in_the_large": -0.000610962273855962, + "expected_calibration_error_10bin": 0.000610962273855962, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 7, + "negatives": 2802, + "auroc": 0.901040073416947, + "auprc": 0.03635642550388813, + "brier": 0.0024584593085436946, + "calibration": { + "observed_rate": 0.002491990032039872, + "mean_prediction": 0.0016474012706261686, + "calibration_in_the_large": -0.0008445887614137034, + "expected_calibration_error_10bin": 0.0008445887614137034, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 8, + "negatives": 2801, + "auroc": 0.9072652624062835, + "auprc": 0.03652817240284092, + "brier": 0.002808562048724611, + "calibration": { + "observed_rate": 0.002847988608045568, + "mean_prediction": 0.0017854804473850633, + "calibration_in_the_large": -0.0010625081606605046, + "expected_calibration_error_10bin": 0.0010625081606605046, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 8, + "negatives": 2801, + "auroc": 0.9074883970010711, + "auprc": 0.03575920329953816, + "brier": 0.002807285963763098, + "calibration": { + "observed_rate": 0.002847988608045568, + "mean_prediction": 0.001966583585826005, + "calibration_in_the_large": -0.000881405022219563, + "expected_calibration_error_10bin": 0.000881405022219563, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 8, + "negatives": 2801, + "auroc": 0.9080239200285612, + "auprc": 0.03525747693344345, + "brier": 0.0028060946329230303, + "calibration": { + "observed_rate": 0.002847988608045568, + "mean_prediction": 0.0021571994304690335, + "calibration_in_the_large": -0.0006907891775765345, + "expected_calibration_error_10bin": 0.0006907891775765345, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 10, + "negatives": 2799, + "auroc": 0.9100035727045374, + "auprc": 0.03549753779614028, + "brier": 0.0035069488709201942, + "calibration": { + "observed_rate": 0.00355998576005696, + "mean_prediction": 0.002340963706719239, + "calibration_in_the_large": -0.0012190220533377211, + "expected_calibration_error_10bin": 0.0012190220533377211, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + { + "valid": 2809, + "positives": 10, + "negatives": 2799, + "auroc": 0.9100750267952841, + "auprc": 0.03550196574117374, + "brier": 0.003506882586594799, + "calibration": { + "observed_rate": 0.00355998576005696, + "mean_prediction": 0.002347107131289833, + "calibration_in_the_large": -0.001212878628767127, + "expected_calibration_error_10bin": 0.001212878628767127, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + } + ], + "reason": null + }, + "I25": { + "time_averaged_auroc": 0.8370144336435881, + "time_averaged_auprc": 0.06642145140981721, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2243, + "positives": 13, + "negatives": 2230, + "auroc": 0.8619868920317351, + "auprc": 0.04693255565738252, + "brier": 0.0056871009338909755, + "calibration": { + "observed_rate": 0.0057958091841284, + "mean_prediction": 0.004012276194129931, + "calibration_in_the_large": -0.0017835329899984686, + "expected_calibration_error_10bin": 0.0017835329899984686, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + { + "valid": 2243, + "positives": 19, + "negatives": 2224, + "auroc": 0.8326154865581219, + "auprc": 0.04553449224465551, + "brier": 0.008280641666621144, + "calibration": { + "observed_rate": 0.008470798038341507, + "mean_prediction": 0.007513321586255251, + "calibration_in_the_large": -0.0009574764520862561, + "expected_calibration_error_10bin": 0.0009574764520862561, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + { + "valid": 2243, + "positives": 24, + "negatives": 2219, + "auroc": 0.8314556106354214, + "auprc": 0.05060922240200046, + "brier": 0.010402648282947699, + "calibration": { + "observed_rate": 0.01069995541685243, + "mean_prediction": 0.008813060011851821, + "calibration_in_the_large": -0.001886895405000609, + "expected_calibration_error_10bin": 0.001886895405000609, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + { + "valid": 2243, + "positives": 28, + "negatives": 2215, + "auroc": 0.8196549500161239, + "auprc": 0.05146088034407916, + "brier": 0.012112560535699647, + "calibration": { + "observed_rate": 0.012483281319661168, + "mean_prediction": 0.00997222979837257, + "calibration_in_the_large": -0.0025110515212885976, + "expected_calibration_error_10bin": 0.0031015428055199863, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + { + "valid": 2243, + "positives": 30, + "negatives": 2213, + "auroc": 0.830607019129387, + "auprc": 0.06500631317192186, + "brier": 0.012879409809477558, + "calibration": { + "observed_rate": 0.013374944271065538, + "mean_prediction": 0.011155479994069057, + "calibration_in_the_large": -0.0022194642769964804, + "expected_calibration_error_10bin": 0.0032033847086437783, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + { + "valid": 2243, + "positives": 32, + "negatives": 2211, + "auroc": 0.8378561736770692, + "auprc": 0.06789878177769929, + "brier": 0.013692212992283837, + "calibration": { + "observed_rate": 0.014266607222469906, + "mean_prediction": 0.012447374563983808, + "calibration_in_the_large": -0.0018192326584860977, + "expected_calibration_error_10bin": 0.0018192326584860977, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + { + "valid": 2243, + "positives": 36, + "negatives": 2207, + "auroc": 0.8431379952675829, + "auprc": 0.07430579507024727, + "brier": 0.015332928358379195, + "calibration": { + "observed_rate": 0.016049933125278644, + "mean_prediction": 0.013511642701017125, + "calibration_in_the_large": -0.0025382904242615186, + "expected_calibration_error_10bin": 0.0027217330857612094, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + { + "valid": 2243, + "positives": 39, + "negatives": 2204, + "auroc": 0.8396970543068547, + "auprc": 0.07504772624294856, + "brier": 0.01660551078582296, + "calibration": { + "observed_rate": 0.017387427552385197, + "mean_prediction": 0.014358807150750972, + "calibration_in_the_large": -0.003028620401634225, + "expected_calibration_error_10bin": 0.0036200961457285973, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + { + "valid": 2243, + "positives": 40, + "negatives": 2203, + "auroc": 0.8404788924194281, + "auprc": 0.07491102706168917, + "brier": 0.01703155491354836, + "calibration": { + "observed_rate": 0.017833259028087384, + "mean_prediction": 0.015272406129165653, + "calibration_in_the_large": -0.002560852898921731, + "expected_calibration_error_10bin": 0.003648530620860698, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + { + "valid": 2243, + "positives": 40, + "negatives": 2203, + "auroc": 0.8398433953699501, + "auprc": 0.07409980561728718, + "brier": 0.017040129058848823, + "calibration": { + "observed_rate": 0.017833259028087384, + "mean_prediction": 0.015985531567289057, + "calibration_in_the_large": -0.001847727460798327, + "expected_calibration_error_10bin": 0.0033400151968904176, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + { + "valid": 2243, + "positives": 44, + "negatives": 2199, + "auroc": 0.8447538137169788, + "auprc": 0.08052411932698014, + "brier": 0.018655501160102065, + "calibration": { + "observed_rate": 0.01961658493089612, + "mean_prediction": 0.01705858754624193, + "calibration_in_the_large": -0.00255799738465419, + "expected_calibration_error_10bin": 0.004935197494029283, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + { + "valid": 2243, + "positives": 46, + "negatives": 2197, + "auroc": 0.8294710177910589, + "auprc": 0.07850891124360082, + "brier": 0.019564924299888684, + "calibration": { + "observed_rate": 0.02050824788230049, + "mean_prediction": 0.018150545126791526, + "calibration_in_the_large": -0.002357702755508964, + "expected_calibration_error_10bin": 0.006271840591847064, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + { + "valid": 2243, + "positives": 46, + "negatives": 2197, + "auroc": 0.8296293364469336, + "auprc": 0.07863923816713173, + "brier": 0.019565659386021946, + "calibration": { + "observed_rate": 0.02050824788230049, + "mean_prediction": 0.0182950015851835, + "calibration_in_the_large": -0.0022132462971169893, + "expected_calibration_error_10bin": 0.006271116083946265, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + } + ], + "reason": null + }, + "I26": { + "time_averaged_auroc": 0.7529615629727313, + "time_averaged_auprc": 0.10876915276674756, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2760, + "positives": 3, + "negatives": 2757, + "auroc": 0.9173014145810664, + "auprc": 0.04474983051706551, + "brier": 0.0010748326075399313, + "calibration": { + "observed_rate": 0.0010869565217391304, + "mean_prediction": 0.00171454091101702, + "calibration_in_the_large": 0.0006275843892778895, + "expected_calibration_error_10bin": 0.0006275843892778895, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + { + "valid": 2760, + "positives": 6, + "negatives": 2754, + "auroc": 0.6539578794480755, + "auprc": 0.0280067197170315, + "brier": 0.002160134899369591, + "calibration": { + "observed_rate": 0.002173913043478261, + "mean_prediction": 0.0031351070762036175, + "calibration_in_the_large": 0.0009611940327253566, + "expected_calibration_error_10bin": 0.0009611940327253566, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + { + "valid": 2760, + "positives": 11, + "negatives": 2749, + "auroc": 0.7865008763517312, + "auprc": 0.04426607403263464, + "brier": 0.003908257677899776, + "calibration": { + "observed_rate": 0.003985507246376811, + "mean_prediction": 0.0038098159742968045, + "calibration_in_the_large": -0.00017569127208000692, + "expected_calibration_error_10bin": 0.00017569127208000692, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + { + "valid": 2760, + "positives": 13, + "negatives": 2747, + "auroc": 0.7675786172327854, + "auprc": 0.13135844504242072, + "brier": 0.004559626615036148, + "calibration": { + "observed_rate": 0.004710144927536232, + "mean_prediction": 0.004311854818893218, + "calibration_in_the_large": -0.0003982901086430138, + "expected_calibration_error_10bin": 0.0003982901086430138, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + { + "valid": 2760, + "positives": 13, + "negatives": 2747, + "auroc": 0.7679706533001036, + "auprc": 0.1325207957479437, + "brier": 0.004550226911435542, + "calibration": { + "observed_rate": 0.004710144927536232, + "mean_prediction": 0.004695729541698171, + "calibration_in_the_large": -1.4415385838061415e-05, + "expected_calibration_error_10bin": 0.0005572406307138681, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + { + "valid": 2760, + "positives": 14, + "negatives": 2746, + "auroc": 0.77671418166684, + "auprc": 0.12683151733402812, + "brier": 0.004898535346105042, + "calibration": { + "observed_rate": 0.005072463768115942, + "mean_prediction": 0.00495450839575758, + "calibration_in_the_large": -0.00011795537235836148, + "expected_calibration_error_10bin": 0.00036529205483047027, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + { + "valid": 2760, + "positives": 16, + "negatives": 2744, + "auroc": 0.7116891399416909, + "auprc": 0.11049252500283381, + "brier": 0.005622052739134974, + "calibration": { + "observed_rate": 0.005797101449275362, + "mean_prediction": 0.0053435009381760405, + "calibration_in_the_large": -0.0004536005110993219, + "expected_calibration_error_10bin": 0.0004536005110993217, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + { + "valid": 2760, + "positives": 17, + "negatives": 2743, + "auroc": 0.7275203191010272, + "auprc": 0.14062094913968112, + "brier": 0.00590566496674521, + "calibration": { + "observed_rate": 0.006159420289855073, + "mean_prediction": 0.005631420708290323, + "calibration_in_the_large": -0.0005279995815647498, + "expected_calibration_error_10bin": 0.0010608960870213452, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + { + "valid": 2760, + "positives": 17, + "negatives": 2743, + "auroc": 0.7279921082541657, + "auprc": 0.13956320007251202, + "brier": 0.0059036661401847415, + "calibration": { + "observed_rate": 0.006159420289855073, + "mean_prediction": 0.005977641518731379, + "calibration_in_the_large": -0.00018177877112369404, + "expected_calibration_error_10bin": 0.0013054694200273721, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + { + "valid": 2760, + "positives": 18, + "negatives": 2742, + "auroc": 0.7336291433665613, + "auprc": 0.13324135094354114, + "brier": 0.0062550595160891275, + "calibration": { + "observed_rate": 0.006521739130434782, + "mean_prediction": 0.0062594271182404, + "calibration_in_the_large": -0.00026231201219438244, + "expected_calibration_error_10bin": 0.0011172780913973153, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + { + "valid": 2760, + "positives": 20, + "negatives": 2740, + "auroc": 0.7381934306569343, + "auprc": 0.12754359975631463, + "brier": 0.006951157246137131, + "calibration": { + "observed_rate": 0.007246376811594203, + "mean_prediction": 0.006455770496867827, + "calibration_in_the_large": -0.0007906063147263762, + "expected_calibration_error_10bin": 0.0007906063147263767, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + { + "valid": 2760, + "positives": 20, + "negatives": 2740, + "auroc": 0.7397445255474453, + "auprc": 0.12740784094942934, + "brier": 0.006947138039796887, + "calibration": { + "observed_rate": 0.007246376811594203, + "mean_prediction": 0.006825961481703469, + "calibration_in_the_large": -0.000420415329890734, + "expected_calibration_error_10bin": 0.0005519826356907872, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + { + "valid": 2760, + "positives": 20, + "negatives": 2740, + "auroc": 0.7397080291970803, + "auprc": 0.12739613771228214, + "brier": 0.006946970831503576, + "calibration": { + "observed_rate": 0.007246376811594203, + "mean_prediction": 0.006837631840323371, + "calibration_in_the_large": -0.00040874497127083194, + "expected_calibration_error_10bin": 0.0005616769545641562, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + } + ], + "reason": null + }, + "I27": { + "time_averaged_auroc": 0.8372442734110611, + "time_averaged_auprc": 0.04383175242320555, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2716, + "positives": 6, + "negatives": 2710, + "auroc": 0.8813038130381304, + "auprc": 0.014774382932086105, + "brier": 0.002199282268660442, + "calibration": { + "observed_rate": 0.0022091310751104565, + "mean_prediction": 0.00209227676414491, + "calibration_in_the_large": -0.00011685431096554672, + "expected_calibration_error_10bin": 0.00011685431096554672, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 13, + "negatives": 2703, + "auroc": 0.8501664816870145, + "auprc": 0.022147069512979956, + "brier": 0.004759702205142101, + "calibration": { + "observed_rate": 0.004786450662739323, + "mean_prediction": 0.004039260899212965, + "calibration_in_the_large": -0.0007471897635263581, + "expected_calibration_error_10bin": 0.0009016455662795088, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 15, + "negatives": 2701, + "auroc": 0.8222139948167345, + "auprc": 0.02129534946712478, + "brier": 0.005522062320015331, + "calibration": { + "observed_rate": 0.005522827687776142, + "mean_prediction": 0.005183296608336656, + "calibration_in_the_large": -0.0003395310794394859, + "expected_calibration_error_10bin": 0.0007911867730221384, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 19, + "negatives": 2697, + "auroc": 0.8233319672930937, + "auprc": 0.026851829787877087, + "brier": 0.006962260386466818, + "calibration": { + "observed_rate": 0.006995581737849779, + "mean_prediction": 0.00619928954086354, + "calibration_in_the_large": -0.0007962921969862395, + "expected_calibration_error_10bin": 0.0016220598450921832, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 22, + "negatives": 2694, + "auroc": 0.8217250455557805, + "auprc": 0.03624658634498529, + "brier": 0.00799386939193585, + "calibration": { + "observed_rate": 0.008100147275405008, + "mean_prediction": 0.006992391692328001, + "calibration_in_the_large": -0.001107755583077007, + "expected_calibration_error_10bin": 0.0023221994248423155, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 26, + "negatives": 2690, + "auroc": 0.8290105804975694, + "auprc": 0.04083307628108601, + "brier": 0.009418676854431967, + "calibration": { + "observed_rate": 0.009572901325478646, + "mean_prediction": 0.0076078540312367335, + "calibration_in_the_large": -0.0019650472942419122, + "expected_calibration_error_10bin": 0.0035177386125670724, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 31, + "negatives": 2685, + "auroc": 0.8322100078092148, + "auprc": 0.05220864370509203, + "brier": 0.01115002650898654, + "calibration": { + "observed_rate": 0.011413843888070692, + "mean_prediction": 0.008475329820669984, + "calibration_in_the_large": -0.002938514067400708, + "expected_calibration_error_10bin": 0.005074395692066691, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 31, + "negatives": 2685, + "auroc": 0.8317054123866162, + "auprc": 0.05145588111094335, + "brier": 0.011174688059934827, + "calibration": { + "observed_rate": 0.011413843888070692, + "mean_prediction": 0.009037836580857444, + "calibration_in_the_large": -0.0023760073072132473, + "expected_calibration_error_10bin": 0.004850951226537281, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 31, + "negatives": 2685, + "auroc": 0.8315131855589596, + "auprc": 0.05122994138971522, + "brier": 0.011191983102300363, + "calibration": { + "observed_rate": 0.011413843888070692, + "mean_prediction": 0.009704108715440416, + "calibration_in_the_large": -0.001709735172630275, + "expected_calibration_error_10bin": 0.005021811026153619, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 34, + "negatives": 2682, + "auroc": 0.8360529894284335, + "auprc": 0.05374651262328337, + "brier": 0.012256161567521694, + "calibration": { + "observed_rate": 0.012518409425625921, + "mean_prediction": 0.01006217455265408, + "calibration_in_the_large": -0.0024562348729718405, + "expected_calibration_error_10bin": 0.006051202792279021, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 36, + "negatives": 2680, + "auroc": 0.8405161691542289, + "auprc": 0.057974586831909515, + "brier": 0.012950709185282697, + "calibration": { + "observed_rate": 0.013254786450662739, + "mean_prediction": 0.010825925892684352, + "calibration_in_the_large": -0.002428860557978387, + "expected_calibration_error_10bin": 0.005955488284622797, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 38, + "negatives": 2678, + "auroc": 0.8394520655634605, + "auprc": 0.06136969006738136, + "brier": 0.013633781543904547, + "calibration": { + "observed_rate": 0.013991163475699559, + "mean_prediction": 0.011179047001236264, + "calibration_in_the_large": -0.002812116474463295, + "expected_calibration_error_10bin": 0.006607110597403184, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 40, + "negatives": 2676, + "auroc": 0.844973841554559, + "auprc": 0.07967923144720804, + "brier": 0.01415021234909028, + "calibration": { + "observed_rate": 0.014727540500736377, + "mean_prediction": 0.011190611508735935, + "calibration_in_the_large": -0.003536928992000442, + "expected_calibration_error_10bin": 0.0065999475999444735, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + } + ], + "reason": null + }, + "I31": { + "time_averaged_auroc": 0.8473895473590793, + "time_averaged_auprc": 0.07360299243850828, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2793, + "positives": 4, + "negatives": 2789, + "auroc": 0.8545177482968807, + "auprc": 0.009278308071179285, + "brier": 0.0014271054515872976, + "calibration": { + "observed_rate": 0.0014321518080916578, + "mean_prediction": 0.001338110823479995, + "calibration_in_the_large": -9.404098461166291e-05, + "expected_calibration_error_10bin": 9.404098461166291e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 7, + "negatives": 2786, + "auroc": 0.8966772638703723, + "auprc": 0.03980328270432922, + "brier": 0.002475717128169302, + "calibration": { + "observed_rate": 0.002506265664160401, + "mean_prediction": 0.001956308807227245, + "calibration_in_the_large": -0.0005499568569331558, + "expected_calibration_error_10bin": 0.0005499568569331558, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 9, + "negatives": 2784, + "auroc": 0.8753192848020435, + "auprc": 0.052167584214911626, + "brier": 0.003181242482718533, + "calibration": { + "observed_rate": 0.00322234156820623, + "mean_prediction": 0.002223345971820012, + "calibration_in_the_large": -0.000998995596386218, + "expected_calibration_error_10bin": 0.000998995596386218, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 9, + "negatives": 2784, + "auroc": 0.874161877394636, + "auprc": 0.12603926686125766, + "brier": 0.003178185318852675, + "calibration": { + "observed_rate": 0.00322234156820623, + "mean_prediction": 0.0024079226976228304, + "calibration_in_the_large": -0.0008144188705833996, + "expected_calibration_error_10bin": 0.0008144188705833996, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 9, + "negatives": 2784, + "auroc": 0.8751596424010217, + "auprc": 0.12586604548206168, + "brier": 0.003176671937327711, + "calibration": { + "observed_rate": 0.00322234156820623, + "mean_prediction": 0.002701678727038942, + "calibration_in_the_large": -0.000520662841167288, + "expected_calibration_error_10bin": 0.000520662841167288, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 11, + "negatives": 2782, + "auroc": 0.8547153780798641, + "auprc": 0.10530890954364726, + "brier": 0.003875194114723819, + "calibration": { + "observed_rate": 0.003938417472252059, + "mean_prediction": 0.0029899289920177438, + "calibration_in_the_large": -0.0009484884802343154, + "expected_calibration_error_10bin": 0.0009484884802343154, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 15, + "negatives": 2778, + "auroc": 0.842668586513079, + "auprc": 0.08827675188840627, + "brier": 0.005272529860829195, + "calibration": { + "observed_rate": 0.0053705692803437165, + "mean_prediction": 0.0034140006381651283, + "calibration_in_the_large": -0.001956568642178588, + "expected_calibration_error_10bin": 0.001956568642178588, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 15, + "negatives": 2778, + "auroc": 0.8436285097192224, + "auprc": 0.08856311116891437, + "brier": 0.005270829701301881, + "calibration": { + "observed_rate": 0.0053705692803437165, + "mean_prediction": 0.0036182312946530073, + "calibration_in_the_large": -0.0017523379856907093, + "expected_calibration_error_10bin": 0.0017523379856907093, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 16, + "negatives": 2777, + "auroc": 0.825711199135758, + "auprc": 0.08387307196948321, + "brier": 0.005626694604810537, + "calibration": { + "observed_rate": 0.005728607232366631, + "mean_prediction": 0.0037681264674956747, + "calibration_in_the_large": -0.0019604807648709566, + "expected_calibration_error_10bin": 0.001960480764870956, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 16, + "negatives": 2777, + "auroc": 0.825846236946345, + "auprc": 0.0840704877654926, + "brier": 0.005625128492589412, + "calibration": { + "observed_rate": 0.005728607232366631, + "mean_prediction": 0.003981085743734074, + "calibration_in_the_large": -0.0017475214886325573, + "expected_calibration_error_10bin": 0.0017475214886325573, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 16, + "negatives": 2777, + "auroc": 0.8260487936622254, + "auprc": 0.05274045964206484, + "brier": 0.005623907098456486, + "calibration": { + "observed_rate": 0.005728607232366631, + "mean_prediction": 0.004073318465096775, + "calibration_in_the_large": -0.0016552887672698566, + "expected_calibration_error_10bin": 0.0016552887672698564, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 17, + "negatives": 2776, + "auroc": 0.8107730123749788, + "auprc": 0.050422363210839066, + "brier": 0.005980764084289489, + "calibration": { + "observed_rate": 0.006086645184389545, + "mean_prediction": 0.004170319692340627, + "calibration_in_the_large": -0.001916325492048918, + "expected_calibration_error_10bin": 0.001916325492048918, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 17, + "negatives": 2776, + "auroc": 0.8108365824716054, + "auprc": 0.05042925917802046, + "brier": 0.00598078392912838, + "calibration": { + "observed_rate": 0.006086645184389545, + "mean_prediction": 0.004176824382314515, + "calibration_in_the_large": -0.00190982080207503, + "expected_calibration_error_10bin": 0.001909820802075031, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + } + ], + "reason": null + }, + "I34": { + "time_averaged_auroc": 0.7433501733923424, + "time_averaged_auprc": 0.01546781457965447, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2753, + "positives": 4, + "negatives": 2749, + "auroc": 0.6507821025827574, + "auprc": 0.003693931840755174, + "brier": 0.001455023903738475, + "calibration": { + "observed_rate": 0.001452960406828914, + "mean_prediction": 0.0009448559904879665, + "calibration_in_the_large": -0.0005081044163409475, + "expected_calibration_error_10bin": 0.0005081044163409475, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + { + "valid": 2753, + "positives": 10, + "negatives": 2743, + "auroc": 0.7385344513306599, + "auprc": 0.009328419108966484, + "brier": 0.0036336272293574024, + "calibration": { + "observed_rate": 0.003632401017072285, + "mean_prediction": 0.001709283124914108, + "calibration_in_the_large": -0.001923117892158177, + "expected_calibration_error_10bin": 0.001923117892158177, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + { + "valid": 2753, + "positives": 10, + "negatives": 2743, + "auroc": 0.7424352898286548, + "auprc": 0.009400584227895832, + "brier": 0.003642590554086001, + "calibration": { + "observed_rate": 0.003632401017072285, + "mean_prediction": 0.0022935693400641674, + "calibration_in_the_large": -0.0013388316770081175, + "expected_calibration_error_10bin": 0.0014204805897774114, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + { + "valid": 2753, + "positives": 13, + "negatives": 2740, + "auroc": 0.7258001122964627, + "auprc": 0.011800478757468435, + "brier": 0.00474106004707155, + "calibration": { + "observed_rate": 0.00472212132219397, + "mean_prediction": 0.0032350854622643877, + "calibration_in_the_large": -0.0014870358599295827, + "expected_calibration_error_10bin": 0.00168797690902526, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + { + "valid": 2753, + "positives": 14, + "negatives": 2739, + "auroc": 0.7463881500026078, + "auprc": 0.015297809721128194, + "brier": 0.005096953874564262, + "calibration": { + "observed_rate": 0.005085361423901199, + "mean_prediction": 0.003805901036159159, + "calibration_in_the_large": -0.00127946038774204, + "expected_calibration_error_10bin": 0.001591895042604887, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + { + "valid": 2753, + "positives": 15, + "negatives": 2738, + "auroc": 0.7619673727781836, + "auprc": 0.018289792354364835, + "brier": 0.0054526996381433586, + "calibration": { + "observed_rate": 0.005448601525608427, + "mean_prediction": 0.004219158975808317, + "calibration_in_the_large": -0.0012294425498001107, + "expected_calibration_error_10bin": 0.00171966579512119, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + { + "valid": 2753, + "positives": 15, + "negatives": 2738, + "auroc": 0.7624299975651327, + "auprc": 0.018383895591224494, + "brier": 0.005460747329223236, + "calibration": { + "observed_rate": 0.005448601525608427, + "mean_prediction": 0.004601027060224281, + "calibration_in_the_large": -0.0008475744653841464, + "expected_calibration_error_10bin": 0.001369065700049534, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + { + "valid": 2753, + "positives": 16, + "negatives": 2737, + "auroc": 0.7572387650712459, + "auprc": 0.018579018837353953, + "brier": 0.005837668592822873, + "calibration": { + "observed_rate": 0.005811841627315656, + "mean_prediction": 0.004997986909819467, + "calibration_in_the_large": -0.0008138547174961885, + "expected_calibration_error_10bin": 0.001547911601163338, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + { + "valid": 2753, + "positives": 16, + "negatives": 2737, + "auroc": 0.7569875776397516, + "auprc": 0.01840269915814579, + "brier": 0.005856296070333494, + "calibration": { + "observed_rate": 0.005811841627315656, + "mean_prediction": 0.005454145238286574, + "calibration_in_the_large": -0.00035769638902908175, + "expected_calibration_error_10bin": 0.0013089710501496944, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + { + "valid": 2753, + "positives": 18, + "negatives": 2735, + "auroc": 0.7639244363193175, + "auprc": 0.019491422748964576, + "brier": 0.006588695877024296, + "calibration": { + "observed_rate": 0.006538321830730113, + "mean_prediction": 0.005775719914556745, + "calibration_in_the_large": -0.000762601916173368, + "expected_calibration_error_10bin": 0.0018573978231024827, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + { + "valid": 2753, + "positives": 18, + "negatives": 2735, + "auroc": 0.7630509851716433, + "auprc": 0.019529254642348687, + "brier": 0.006601997731437411, + "calibration": { + "observed_rate": 0.006538321830730113, + "mean_prediction": 0.006197806877107799, + "calibration_in_the_large": -0.000340514953622314, + "expected_calibration_error_10bin": 0.0016444068718684255, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + { + "valid": 2753, + "positives": 19, + "negatives": 2734, + "auroc": 0.7469872559966119, + "auprc": 0.019404464109696422, + "brier": 0.006994446306917576, + "calibration": { + "observed_rate": 0.006901561932437341, + "mean_prediction": 0.006697791615192818, + "calibration_in_the_large": -0.000203770317244523, + "expected_calibration_error_10bin": 0.0018455973562997699, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + { + "valid": 2753, + "positives": 19, + "negatives": 2734, + "auroc": 0.747025757517422, + "auprc": 0.019479818437195196, + "brier": 0.006996924606742085, + "calibration": { + "observed_rate": 0.006901561932437341, + "mean_prediction": 0.006742135306024205, + "calibration_in_the_large": -0.00015942662641313648, + "expected_calibration_error_10bin": 0.0018123403404918799, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + } + ], + "reason": null + }, + "I35": { + "time_averaged_auroc": 0.6927168356373967, + "time_averaged_auprc": 0.007331558339857965, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2723, + "positives": 2, + "negatives": 2721, + "auroc": 0.45387725101065785, + "auprc": 0.0009815463597000098, + "brier": 0.0007408594631488309, + "calibration": { + "observed_rate": 0.0007344840249724568, + "mean_prediction": 0.0009783556634242257, + "calibration_in_the_large": 0.00024387163845176888, + "expected_calibration_error_10bin": 0.00024387163845176888, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 4, + "negatives": 2719, + "auroc": 0.65529606472968, + "auprc": 0.0032816811905479926, + "brier": 0.0014945861901700754, + "calibration": { + "observed_rate": 0.0014689680499449136, + "mean_prediction": 0.0021119985906056238, + "calibration_in_the_large": 0.0006430305406607102, + "expected_calibration_error_10bin": 0.0006430305406607102, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 5, + "negatives": 2718, + "auroc": 0.7280353200883002, + "auprc": 0.008618913192552438, + "brier": 0.00185986776061973, + "calibration": { + "observed_rate": 0.001836210062431142, + "mean_prediction": 0.0025162238400208005, + "calibration_in_the_large": 0.0006800137775896584, + "expected_calibration_error_10bin": 0.0006800137775896584, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 5, + "negatives": 2718, + "auroc": 0.7306107431935247, + "auprc": 0.008908991768241288, + "brier": 0.0018741286373060912, + "calibration": { + "observed_rate": 0.001836210062431142, + "mean_prediction": 0.0029561896073865656, + "calibration_in_the_large": 0.0011199795449554236, + "expected_calibration_error_10bin": 0.0011199795449554231, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 5, + "negatives": 2718, + "auroc": 0.7306107431935247, + "auprc": 0.008750312924807577, + "brier": 0.001888697895956404, + "calibration": { + "observed_rate": 0.001836210062431142, + "mean_prediction": 0.0033158741018788256, + "calibration_in_the_large": 0.0014796640394476835, + "expected_calibration_error_10bin": 0.0014796640394476833, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 5, + "negatives": 2718, + "auroc": 0.7295805739514348, + "auprc": 0.00876652671824647, + "brier": 0.0019101962448523082, + "calibration": { + "observed_rate": 0.001836210062431142, + "mean_prediction": 0.003784145153102397, + "calibration_in_the_large": 0.001947935090671255, + "expected_calibration_error_10bin": 0.001947935090671255, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 6, + "negatives": 2717, + "auroc": 0.717764691448902, + "auprc": 0.008225890895908658, + "brier": 0.0022928408186000527, + "calibration": { + "observed_rate": 0.0022034520749173708, + "mean_prediction": 0.004149086841496751, + "calibration_in_the_large": 0.0019456347665793806, + "expected_calibration_error_10bin": 0.0019456347665793808, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 6, + "negatives": 2717, + "auroc": 0.7175193227824807, + "auprc": 0.008169950489502066, + "brier": 0.0023054781891316193, + "calibration": { + "observed_rate": 0.0022034520749173708, + "mean_prediction": 0.004323497578313005, + "calibration_in_the_large": 0.0021200455033956343, + "expected_calibration_error_10bin": 0.0021200455033956343, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 6, + "negatives": 2717, + "auroc": 0.7195436142804564, + "auprc": 0.008211030325468856, + "brier": 0.0023263686255413575, + "calibration": { + "observed_rate": 0.0022034520749173708, + "mean_prediction": 0.004692399765620066, + "calibration_in_the_large": 0.0024889476907026956, + "expected_calibration_error_10bin": 0.002488947690702695, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 7, + "negatives": 2716, + "auroc": 0.7059751735745845, + "auprc": 0.007942056403173286, + "brier": 0.002694791066069988, + "calibration": { + "observed_rate": 0.002570694087403599, + "mean_prediction": 0.004738830734551963, + "calibration_in_the_large": 0.002168136647148364, + "expected_calibration_error_10bin": 0.0021681366471483637, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 7, + "negatives": 2716, + "auroc": 0.7061855670103093, + "auprc": 0.007903464937238461, + "brier": 0.0027098547276997414, + "calibration": { + "observed_rate": 0.002570694087403599, + "mean_prediction": 0.004976630016011463, + "calibration_in_the_large": 0.0024059359286078643, + "expected_calibration_error_10bin": 0.0024059359286078643, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 7, + "negatives": 2716, + "auroc": 0.7051335998316852, + "auprc": 0.00777424657553699, + "brier": 0.0027319802239039086, + "calibration": { + "observed_rate": 0.002570694087403599, + "mean_prediction": 0.005355229608924063, + "calibration_in_the_large": 0.002784535521520464, + "expected_calibration_error_10bin": 0.0027845355215204643, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + { + "valid": 2723, + "positives": 7, + "negatives": 2716, + "auroc": 0.7051861981906165, + "auprc": 0.007775646637229443, + "brier": 0.0027326181490632323, + "calibration": { + "observed_rate": 0.002570694087403599, + "mean_prediction": 0.00536599058826589, + "calibration_in_the_large": 0.0027952965008622914, + "expected_calibration_error_10bin": 0.002795296500862292, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + } + ], + "reason": null + }, + "I42": { + "time_averaged_auroc": 0.9210544681384506, + "time_averaged_auprc": 0.060751180350644675, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2740, + "positives": 1, + "negatives": 2739, + "auroc": 0.940854326396495, + "auprc": 0.006134969325153374, + "brier": 0.0003681475583026647, + "calibration": { + "observed_rate": 0.000364963503649635, + "mean_prediction": 0.0009840416869384258, + "calibration_in_the_large": 0.0006190781832887907, + "expected_calibration_error_10bin": 0.0006190781832887907, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 4, + "negatives": 2736, + "auroc": 0.9088084795321637, + "auprc": 0.06988473303045296, + "brier": 0.0014384527939526606, + "calibration": { + "observed_rate": 0.00145985401459854, + "mean_prediction": 0.0018443789624774064, + "calibration_in_the_large": 0.00038452494787886635, + "expected_calibration_error_10bin": 0.00038452494787886635, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 4, + "negatives": 2736, + "auroc": 0.9182200292397661, + "auprc": 0.07048289063092092, + "brier": 0.0014409328498328961, + "calibration": { + "observed_rate": 0.00145985401459854, + "mean_prediction": 0.0025011505719537597, + "calibration_in_the_large": 0.0010412965573552196, + "expected_calibration_error_10bin": 0.0010412965573552196, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 8, + "negatives": 2732, + "auroc": 0.9199304538799414, + "auprc": 0.07496824959535464, + "brier": 0.002852275611349781, + "calibration": { + "observed_rate": 0.00291970802919708, + "mean_prediction": 0.0028461902925626115, + "calibration_in_the_large": -7.351773663446864e-05, + "expected_calibration_error_10bin": 0.00014720327174864612, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 10, + "negatives": 2730, + "auroc": 0.923040293040293, + "auprc": 0.07665753941939193, + "brier": 0.003558563721159224, + "calibration": { + "observed_rate": 0.0036496350364963502, + "mean_prediction": 0.003133865586595589, + "calibration_in_the_large": -0.0005157694499007613, + "expected_calibration_error_10bin": 0.0006003243270601309, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 11, + "negatives": 2729, + "auroc": 0.9228155501515707, + "auprc": 0.0658828428448376, + "brier": 0.003913281488172818, + "calibration": { + "observed_rate": 0.0040145985401459855, + "mean_prediction": 0.0034711979606576954, + "calibration_in_the_large": -0.0005434005794882901, + "expected_calibration_error_10bin": 0.0006346111364322107, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 11, + "negatives": 2729, + "auroc": 0.9225157400313135, + "auprc": 0.06562051795228276, + "brier": 0.003912726752291772, + "calibration": { + "observed_rate": 0.0040145985401459855, + "mean_prediction": 0.0037605116792391972, + "calibration_in_the_large": -0.0002540868609067883, + "expected_calibration_error_10bin": 0.0003566680534489544, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 12, + "negatives": 2728, + "auroc": 0.9225012218963832, + "auprc": 0.06387863925194781, + "brier": 0.00426711584969585, + "calibration": { + "observed_rate": 0.004379562043795621, + "mean_prediction": 0.004028193245590478, + "calibration_in_the_large": -0.00035136879820514295, + "expected_calibration_error_10bin": 0.00046095575536745737, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 12, + "negatives": 2728, + "auroc": 0.9227150537634409, + "auprc": 0.06389964650345252, + "brier": 0.0042679896825515195, + "calibration": { + "observed_rate": 0.004379562043795621, + "mean_prediction": 0.004203114538641738, + "calibration_in_the_large": -0.00017644750515388285, + "expected_calibration_error_10bin": 0.00029573991490454936, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 13, + "negatives": 2727, + "auroc": 0.9209049110039209, + "auprc": 0.059602416864197524, + "brier": 0.00462722286498165, + "calibration": { + "observed_rate": 0.004744525547445255, + "mean_prediction": 0.0044754544763004125, + "calibration_in_the_large": -0.0002690710711448427, + "expected_calibration_error_10bin": 0.0003986336983698692, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 13, + "negatives": 2727, + "auroc": 0.9198330089419199, + "auprc": 0.05926403190055751, + "brier": 0.004630058432968205, + "calibration": { + "observed_rate": 0.004744525547445255, + "mean_prediction": 0.005085904479766499, + "calibration_in_the_large": 0.00034137893232124347, + "expected_calibration_error_10bin": 0.00034137893232124347, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 14, + "negatives": 2726, + "auroc": 0.9157059008489676, + "auprc": 0.05672765107191564, + "brier": 0.004992002256492261, + "calibration": { + "observed_rate": 0.0051094890510948905, + "mean_prediction": 0.005280322798762095, + "calibration_in_the_large": 0.00017083374766720463, + "expected_calibration_error_10bin": 0.0005308642545338965, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 14, + "negatives": 2726, + "auroc": 0.915863117073682, + "auprc": 0.05676121616791553, + "brier": 0.004992068471445141, + "calibration": { + "observed_rate": 0.0051094890510948905, + "mean_prediction": 0.005289427707750133, + "calibration_in_the_large": 0.00017993865665524248, + "expected_calibration_error_10bin": 0.0005395221504396384, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + } + ], + "reason": null + }, + "I44": { + "time_averaged_auroc": 0.864280988460294, + "time_averaged_auprc": 0.06301621525912281, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2722, + "positives": 4, + "negatives": 2718, + "auroc": 0.9120676968359087, + "auprc": 0.029988709286666165, + "brier": 0.0014672556374443558, + "calibration": { + "observed_rate": 0.0014695077149155032, + "mean_prediction": 0.002583431948492345, + "calibration_in_the_large": 0.001113924233576842, + "expected_calibration_error_10bin": 0.001113924233576842, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + { + "valid": 2722, + "positives": 8, + "negatives": 2714, + "auroc": 0.8570836403831983, + "auprc": 0.054281259293413736, + "brier": 0.0028828023507603737, + "calibration": { + "observed_rate": 0.0029390154298310064, + "mean_prediction": 0.003984975844332272, + "calibration_in_the_large": 0.0010459604145012652, + "expected_calibration_error_10bin": 0.0010459604145012654, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + { + "valid": 2722, + "positives": 10, + "negatives": 2712, + "auroc": 0.8792035398230088, + "auprc": 0.07301591466554402, + "brier": 0.00356498776381805, + "calibration": { + "observed_rate": 0.0036737692872887582, + "mean_prediction": 0.005071379765234789, + "calibration_in_the_large": 0.0013976104779460305, + "expected_calibration_error_10bin": 0.0013976104779460303, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + { + "valid": 2722, + "positives": 13, + "negatives": 2709, + "auroc": 0.8834085810829997, + "auprc": 0.06956921890573158, + "brier": 0.004641626157184625, + "calibration": { + "observed_rate": 0.004775900073475386, + "mean_prediction": 0.005763175328552643, + "calibration_in_the_large": 0.0009872752550772572, + "expected_calibration_error_10bin": 0.0009872752550772578, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + { + "valid": 2722, + "positives": 14, + "negatives": 2708, + "auroc": 0.8884258282338046, + "auprc": 0.06904046831748567, + "brier": 0.00500350294805011, + "calibration": { + "observed_rate": 0.005143277002204262, + "mean_prediction": 0.006626352454003102, + "calibration_in_the_large": 0.00148307545179884, + "expected_calibration_error_10bin": 0.002137746669806927, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + { + "valid": 2722, + "positives": 14, + "negatives": 2708, + "auroc": 0.8895336568896391, + "auprc": 0.06937274583833615, + "brier": 0.0050142889109707975, + "calibration": { + "observed_rate": 0.005143277002204262, + "mean_prediction": 0.007274182990543554, + "calibration_in_the_large": 0.002130905988339292, + "expected_calibration_error_10bin": 0.0032402596717300393, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + { + "valid": 2722, + "positives": 17, + "negatives": 2705, + "auroc": 0.8706752201804936, + "auprc": 0.06372147014081178, + "brier": 0.006089920708015001, + "calibration": { + "observed_rate": 0.006245407788390889, + "mean_prediction": 0.007890294257555793, + "calibration_in_the_large": 0.0016448864691649048, + "expected_calibration_error_10bin": 0.002168652020735837, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + { + "valid": 2722, + "positives": 18, + "negatives": 2704, + "auroc": 0.8678911900065747, + "auprc": 0.0649472562244474, + "brier": 0.0064621164465726005, + "calibration": { + "observed_rate": 0.006612784717119765, + "mean_prediction": 0.008370299119420768, + "calibration_in_the_large": 0.0017575144023010032, + "expected_calibration_error_10bin": 0.0019048335773576403, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + { + "valid": 2722, + "positives": 21, + "negatives": 2701, + "auroc": 0.8696778970751573, + "auprc": 0.06893667484958446, + "brier": 0.007479593370174523, + "calibration": { + "observed_rate": 0.007714915503306392, + "mean_prediction": 0.00877674586666001, + "calibration_in_the_large": 0.0010618303633536177, + "expected_calibration_error_10bin": 0.001061830363353617, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + { + "valid": 2722, + "positives": 23, + "negatives": 2699, + "auroc": 0.827730077162234, + "auprc": 0.06366206929705609, + "brier": 0.008223315195027947, + "calibration": { + "observed_rate": 0.008449669360764144, + "mean_prediction": 0.009362895868920683, + "calibration_in_the_large": 0.000913226508156539, + "expected_calibration_error_10bin": 0.0009132265081565385, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + { + "valid": 2722, + "positives": 23, + "negatives": 2699, + "auroc": 0.8282616750165117, + "auprc": 0.0641090056849417, + "brier": 0.008247444997527628, + "calibration": { + "observed_rate": 0.008449669360764144, + "mean_prediction": 0.00994448265013994, + "calibration_in_the_large": 0.0014948132893757952, + "expected_calibration_error_10bin": 0.0014948132893757948, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + { + "valid": 2722, + "positives": 24, + "negatives": 2698, + "auroc": 0.8308314801087225, + "auprc": 0.06427034374029321, + "brier": 0.008612294625259254, + "calibration": { + "observed_rate": 0.00881704628949302, + "mean_prediction": 0.010293082637945938, + "calibration_in_the_large": 0.0014760363484529176, + "expected_calibration_error_10bin": 0.0014760363484529195, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + { + "valid": 2722, + "positives": 24, + "negatives": 2698, + "auroc": 0.8308623671855696, + "auprc": 0.06429566212428466, + "brier": 0.008618438293139224, + "calibration": { + "observed_rate": 0.00881704628949302, + "mean_prediction": 0.010503280850313894, + "calibration_in_the_large": 0.0016862345608208741, + "expected_calibration_error_10bin": 0.0016862345608208748, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + } + ], + "reason": null + }, + "I45": { + "time_averaged_auroc": 0.729512365616064, + "time_averaged_auprc": 0.07094685680502695, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2766, + "positives": 2, + "negatives": 2764, + "auroc": 0.8751808972503617, + "auprc": 0.021497005988023954, + "brier": 0.0007209879197984392, + "calibration": { + "observed_rate": 0.0007230657989877079, + "mean_prediction": 0.001538933754930763, + "calibration_in_the_large": 0.0008158679559430551, + "expected_calibration_error_10bin": 0.0008158679559430551, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + { + "valid": 2766, + "positives": 5, + "negatives": 2761, + "auroc": 0.7512495472654835, + "auprc": 0.22334751015811083, + "brier": 0.0017935103522235072, + "calibration": { + "observed_rate": 0.0018076644974692696, + "mean_prediction": 0.003119712606121374, + "calibration_in_the_large": 0.0013120481086521046, + "expected_calibration_error_10bin": 0.0013120481086521046, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + { + "valid": 2766, + "positives": 7, + "negatives": 2759, + "auroc": 0.7460777714492829, + "auprc": 0.15822429388493467, + "brier": 0.002512070783267869, + "calibration": { + "observed_rate": 0.0025307302964569776, + "mean_prediction": 0.0041400884501005975, + "calibration_in_the_large": 0.00160935815364362, + "expected_calibration_error_10bin": 0.00160935815364362, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + { + "valid": 2766, + "positives": 7, + "negatives": 2759, + "auroc": 0.7407445761922021, + "auprc": 0.15512797341486148, + "brier": 0.0025152734312416727, + "calibration": { + "observed_rate": 0.0025307302964569776, + "mean_prediction": 0.004612468342832854, + "calibration_in_the_large": 0.0020817380463758763, + "expected_calibration_error_10bin": 0.0020817380463758763, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + { + "valid": 2766, + "positives": 8, + "negatives": 2758, + "auroc": 0.7319162436548223, + "auprc": 0.07347006728419266, + "brier": 0.002876177752367166, + "calibration": { + "observed_rate": 0.0028922631959508315, + "mean_prediction": 0.005060977607482131, + "calibration_in_the_large": 0.0021687144115312995, + "expected_calibration_error_10bin": 0.0021687144115312995, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + { + "valid": 2766, + "positives": 10, + "negatives": 2756, + "auroc": 0.7384615384615385, + "auprc": 0.06176307696895215, + "brier": 0.003589380949858408, + "calibration": { + "observed_rate": 0.0036153289949385392, + "mean_prediction": 0.0055115840492515195, + "calibration_in_the_large": 0.0018962550543129802, + "expected_calibration_error_10bin": 0.0018962550543129802, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + { + "valid": 2766, + "positives": 12, + "negatives": 2754, + "auroc": 0.7051561365286856, + "auprc": 0.03885399322466187, + "brier": 0.00431136300717556, + "calibration": { + "observed_rate": 0.004338394793926247, + "mean_prediction": 0.0059550916132851675, + "calibration_in_the_large": 0.00161669681935892, + "expected_calibration_error_10bin": 0.00161669681935892, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + { + "valid": 2766, + "positives": 14, + "negatives": 2752, + "auroc": 0.7352315199335548, + "auprc": 0.048516573295153013, + "brier": 0.0050163287617262685, + "calibration": { + "observed_rate": 0.005061460592913955, + "mean_prediction": 0.006357083136599817, + "calibration_in_the_large": 0.0012956225436858617, + "expected_calibration_error_10bin": 0.0012956225436858617, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + { + "valid": 2766, + "positives": 16, + "negatives": 2750, + "auroc": 0.6913181818181818, + "auprc": 0.03331787023544165, + "brier": 0.005739134697639883, + "calibration": { + "observed_rate": 0.005784526391901663, + "mean_prediction": 0.006899878712557778, + "calibration_in_the_large": 0.0011153523206561154, + "expected_calibration_error_10bin": 0.0011153523206561154, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + { + "valid": 2766, + "positives": 18, + "negatives": 2748, + "auroc": 0.6908660844250364, + "auprc": 0.02766751856590062, + "brier": 0.006449547054728393, + "calibration": { + "observed_rate": 0.006507592190889371, + "mean_prediction": 0.007352094394939367, + "calibration_in_the_large": 0.0008445022040499961, + "expected_calibration_error_10bin": 0.0008445022040499961, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + { + "valid": 2766, + "positives": 22, + "negatives": 2744, + "auroc": 0.6924695202756427, + "auprc": 0.026998528815807384, + "brier": 0.007855654183109415, + "calibration": { + "observed_rate": 0.007953723788864787, + "mean_prediction": 0.007756706226578125, + "calibration_in_the_large": -0.0001970175622866624, + "expected_calibration_error_10bin": 0.0001970175622866624, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + { + "valid": 2766, + "positives": 22, + "negatives": 2744, + "auroc": 0.6923204346673735, + "auprc": 0.02675515384920716, + "brier": 0.007858002540453926, + "calibration": { + "observed_rate": 0.007953723788864787, + "mean_prediction": 0.008075381826940353, + "calibration_in_the_large": 0.00012165803807556545, + "expected_calibration_error_10bin": 0.00012165803807556545, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + { + "valid": 2766, + "positives": 22, + "negatives": 2744, + "auroc": 0.6926683010866684, + "auprc": 0.02676957278010291, + "brier": 0.007858388643875044, + "calibration": { + "observed_rate": 0.007953723788864787, + "mean_prediction": 0.008168731385858212, + "calibration_in_the_large": 0.00021500759699342488, + "expected_calibration_error_10bin": 0.00021500759699342488, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + } + ], + "reason": null + }, + "I46": { + "time_averaged_auroc": 0.5485155967321546, + "time_averaged_auprc": 0.002277618499591436, + "valid_timepoint_cells": 11, + "timepoints": [ + { + "valid": 2831, + "positives": 0, + "negatives": 2831, + "auroc": null, + "auprc": null, + "brier": 7.63874230268552e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004001331148308807, + "calibration_in_the_large": 0.0004001331148308807, + "expected_calibration_error_10bin": 0.0004001331148308807, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 0, + "negatives": 2831, + "auroc": null, + "auprc": null, + "brier": 4.593599574781127e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0010944896083000448, + "calibration_in_the_large": 0.0010944896083000448, + "expected_calibration_error_10bin": 0.0010944896083000448, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.496113074204947, + "auprc": 0.000700770847932726, + "brier": 0.0003590597275026914, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0012570495035397818, + "calibration_in_the_large": 0.0009038174300675106, + "expected_calibration_error_10bin": 0.0009038174300675106, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.4901060070671378, + "auprc": 0.0006925207756232687, + "brier": 0.0003603029450206072, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.001383196666110451, + "calibration_in_the_large": 0.0010299645926381798, + "expected_calibration_error_10bin": 0.0010299645926381798, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.4851590106007067, + "auprc": 0.0006858710562414266, + "brier": 0.00036212112908619125, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.001565822501887906, + "calibration_in_the_large": 0.0012125904284156347, + "expected_calibration_error_10bin": 0.0012125904284156347, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.4872791519434629, + "auprc": 0.0006887052341597796, + "brier": 0.00036338862032832996, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.001712846512257169, + "calibration_in_the_large": 0.0013596144387848978, + "expected_calibration_error_10bin": 0.0013596144387848978, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.4784452296819788, + "auprc": 0.0006770480704129993, + "brier": 0.00036451262307789196, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0018140891305089759, + "calibration_in_the_large": 0.0014608570570367047, + "expected_calibration_error_10bin": 0.0014608570570367047, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.4713780918727915, + "auprc": 0.0006680026720106881, + "brier": 0.0003666318705170449, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0019637140051968487, + "calibration_in_the_large": 0.0016104819317245775, + "expected_calibration_error_10bin": 0.0016104819317245775, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 2, + "negatives": 2829, + "auroc": 0.5159066808059385, + "auprc": 0.0010662233909192814, + "brier": 0.0007212265399356907, + "calibration": { + "observed_rate": 0.0007064641469445425, + "mean_prediction": 0.0021193530716421675, + "calibration_in_the_large": 0.001412888924697625, + "expected_calibration_error_10bin": 0.001412888924697625, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 3, + "negatives": 2828, + "auroc": 0.5759075907590759, + "auprc": 0.0015903188042999822, + "brier": 0.0010735298532562679, + "calibration": { + "observed_rate": 0.0010596962204168139, + "mean_prediction": 0.002155510641432701, + "calibration_in_the_large": 0.0010958144210158872, + "expected_calibration_error_10bin": 0.0010958144210158872, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 3, + "negatives": 2828, + "auroc": 0.572017916077322, + "auprc": 0.0015760722151560113, + "brier": 0.0010749161510747573, + "calibration": { + "observed_rate": 0.0010596962204168139, + "mean_prediction": 0.0022588501661475763, + "calibration_in_the_large": 0.0011991539457307625, + "expected_calibration_error_10bin": 0.0011991539457307625, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.7307855626326963, + "auprc": 0.008355073371232452, + "brier": 0.0017679508513969218, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0024814488558561787, + "calibration_in_the_large": 0.0007152884884948224, + "expected_calibration_error_10bin": 0.0007152884884948224, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.7305732484076433, + "auprc": 0.008353197057517175, + "brier": 0.001768023319183648, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.002489504774362982, + "calibration_in_the_large": 0.0007233444070016259, + "expected_calibration_error_10bin": 0.0007233444070016259, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + } + ], + "reason": null + }, + "I47": { + "time_averaged_auroc": 0.7034627359671737, + "time_averaged_auprc": 0.010363265504124513, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2716, + "positives": 3, + "negatives": 2713, + "auroc": 0.8562476962771839, + "auprc": 0.004875786672176971, + "brier": 0.001105588057767497, + "calibration": { + "observed_rate": 0.0011045655375552283, + "mean_prediction": 0.0021181099864366676, + "calibration_in_the_large": 0.0010135444488814393, + "expected_calibration_error_10bin": 0.0010135444488814393, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 5, + "negatives": 2711, + "auroc": 0.6536333456289192, + "auprc": 0.004311462349972715, + "brier": 0.001852704297208304, + "calibration": { + "observed_rate": 0.001840942562592047, + "mean_prediction": 0.0034940356694578346, + "calibration_in_the_large": 0.0016530931068657875, + "expected_calibration_error_10bin": 0.0016530931068657875, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 7, + "negatives": 2709, + "auroc": 0.6839107736117703, + "auprc": 0.006207822188155553, + "brier": 0.002592249076428243, + "calibration": { + "observed_rate": 0.002577319587628866, + "mean_prediction": 0.004544449258571788, + "calibration_in_the_large": 0.001967129670942922, + "expected_calibration_error_10bin": 0.001967129670942922, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 8, + "negatives": 2708, + "auroc": 0.6870845642540621, + "auprc": 0.0067603256692587745, + "brier": 0.002967279668585019, + "calibration": { + "observed_rate": 0.0029455081001472753, + "mean_prediction": 0.005449357258505016, + "calibration_in_the_large": 0.002503849158357741, + "expected_calibration_error_10bin": 0.002503849158357741, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 9, + "negatives": 2707, + "auroc": 0.6649837868899561, + "auprc": 0.00666858489202847, + "brier": 0.003346823346972993, + "calibration": { + "observed_rate": 0.0033136966126656848, + "mean_prediction": 0.00611560153006816, + "calibration_in_the_large": 0.0028019049174024756, + "expected_calibration_error_10bin": 0.0028019049174024756, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 11, + "negatives": 2705, + "auroc": 0.7013947235758696, + "auprc": 0.008806921911435606, + "brier": 0.004083306986047605, + "calibration": { + "observed_rate": 0.004050073637702504, + "mean_prediction": 0.006813640463241292, + "calibration_in_the_large": 0.002763566825538788, + "expected_calibration_error_10bin": 0.002763566825538788, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 12, + "negatives": 2704, + "auroc": 0.7251602564102564, + "auprc": 0.01121612256375021, + "brier": 0.004450926087478212, + "calibration": { + "observed_rate": 0.004418262150220913, + "mean_prediction": 0.007448006235485275, + "calibration_in_the_large": 0.0030297440852643616, + "expected_calibration_error_10bin": 0.0030297440852643616, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 13, + "negatives": 2703, + "auroc": 0.7418822391075444, + "auprc": 0.013077455382048905, + "brier": 0.004820908711269073, + "calibration": { + "observed_rate": 0.004786450662739323, + "mean_prediction": 0.007887599703126974, + "calibration_in_the_large": 0.0031011490403876508, + "expected_calibration_error_10bin": 0.0031011490403876508, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 16, + "negatives": 2700, + "auroc": 0.6939120370370371, + "auprc": 0.014118797276130995, + "brier": 0.005918850030059002, + "calibration": { + "observed_rate": 0.005891016200294551, + "mean_prediction": 0.008310173861630122, + "calibration_in_the_large": 0.0024191576613355713, + "expected_calibration_error_10bin": 0.002419157661335572, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 18, + "negatives": 2698, + "auroc": 0.6946709496746561, + "auprc": 0.014638246342350189, + "brier": 0.0066589096312734235, + "calibration": { + "observed_rate": 0.0066273932253313695, + "mean_prediction": 0.008705670738147656, + "calibration_in_the_large": 0.0020782775128162867, + "expected_calibration_error_10bin": 0.0020782775128162867, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 18, + "negatives": 2698, + "auroc": 0.6947121324437855, + "auprc": 0.014827431214506411, + "brier": 0.0066729834206221035, + "calibration": { + "observed_rate": 0.0066273932253313695, + "mean_prediction": 0.009319496125610602, + "calibration_in_the_large": 0.0026921029002792323, + "expected_calibration_error_10bin": 0.0026921029002792323, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 19, + "negatives": 2697, + "auroc": 0.6736139570282771, + "auprc": 0.014577974975716338, + "brier": 0.007057956514311629, + "calibration": { + "observed_rate": 0.006995581737849779, + "mean_prediction": 0.009924057851418554, + "calibration_in_the_large": 0.0029284761135687743, + "expected_calibration_error_10bin": 0.0029284761135687743, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + { + "valid": 2716, + "positives": 19, + "negatives": 2697, + "auroc": 0.6738091056339403, + "auprc": 0.014635520116087536, + "brier": 0.007062724299726049, + "calibration": { + "observed_rate": 0.006995581737849779, + "mean_prediction": 0.010050935623112899, + "calibration_in_the_large": 0.003055353885263119, + "expected_calibration_error_10bin": 0.0030553538852631204, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + } + ], + "reason": null + }, + "I48": { + "time_averaged_auroc": 0.7745585646000728, + "time_averaged_auprc": 0.026165283044565054, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2385, + "positives": 7, + "negatives": 2378, + "auroc": 0.8196563739036405, + "auprc": 0.00921437443285648, + "brier": 0.0029299433827854973, + "calibration": { + "observed_rate": 0.0029350104821802936, + "mean_prediction": 0.002501695460065871, + "calibration_in_the_large": -0.00043331502211442236, + "expected_calibration_error_10bin": 0.00043331502211442236, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + { + "valid": 2385, + "positives": 12, + "negatives": 2373, + "auroc": 0.8002879617923866, + "auprc": 0.01823246674196644, + "brier": 0.0049968370175210485, + "calibration": { + "observed_rate": 0.005031446540880503, + "mean_prediction": 0.004351234489410483, + "calibration_in_the_large": -0.0006802120514700196, + "expected_calibration_error_10bin": 0.0007941174273285422, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + { + "valid": 2385, + "positives": 15, + "negatives": 2370, + "auroc": 0.7971870604781998, + "auprc": 0.020068143173952516, + "brier": 0.006244805920748971, + "calibration": { + "observed_rate": 0.006289308176100629, + "mean_prediction": 0.0058628701315023716, + "calibration_in_the_large": -0.0004264380445982577, + "expected_calibration_error_10bin": 0.0005664459688321001, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + { + "valid": 2385, + "positives": 17, + "negatives": 2368, + "auroc": 0.7792378775834659, + "auprc": 0.021071838006305785, + "brier": 0.007088996792272469, + "calibration": { + "observed_rate": 0.007127882599580713, + "mean_prediction": 0.007381354279638477, + "calibration_in_the_large": 0.00025347168005776435, + "expected_calibration_error_10bin": 0.00025347168005776435, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + { + "valid": 2385, + "positives": 19, + "negatives": 2366, + "auroc": 0.8015971882368643, + "auprc": 0.029234438391274997, + "brier": 0.007864714107101583, + "calibration": { + "observed_rate": 0.007966457023060796, + "mean_prediction": 0.00794879253232506, + "calibration_in_the_large": -1.7664490735735602e-05, + "expected_calibration_error_10bin": 0.00038386986138683665, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + { + "valid": 2385, + "positives": 21, + "negatives": 2364, + "auroc": 0.781101442268955, + "auprc": 0.028278314173502128, + "brier": 0.008707352062765685, + "calibration": { + "observed_rate": 0.00880503144654088, + "mean_prediction": 0.008863626251305186, + "calibration_in_the_large": 5.85948047643059e-05, + "expected_calibration_error_10bin": 0.00034509871978228765, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + { + "valid": 2385, + "positives": 22, + "negatives": 2363, + "auroc": 0.7825953141230331, + "auprc": 0.028019985030123387, + "brier": 0.009145879047720762, + "calibration": { + "observed_rate": 0.009224318658280923, + "mean_prediction": 0.009753608837088206, + "calibration_in_the_large": 0.0005292901788072832, + "expected_calibration_error_10bin": 0.0005292901788072837, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + { + "valid": 2385, + "positives": 23, + "negatives": 2362, + "auroc": 0.7829768435003498, + "auprc": 0.028221976674965704, + "brier": 0.009569832286124156, + "calibration": { + "observed_rate": 0.009643605870020965, + "mean_prediction": 0.010219006336038342, + "calibration_in_the_large": 0.0005754004660173777, + "expected_calibration_error_10bin": 0.0005754004660173775, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + { + "valid": 2385, + "positives": 25, + "negatives": 2360, + "auroc": 0.7533559322033898, + "auprc": 0.027211983210040095, + "brier": 0.010434141359388131, + "calibration": { + "observed_rate": 0.010482180293501049, + "mean_prediction": 0.01106703310074437, + "calibration_in_the_large": 0.0005848528072433211, + "expected_calibration_error_10bin": 0.0005848528072433213, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + { + "valid": 2385, + "positives": 30, + "negatives": 2355, + "auroc": 0.7334041047416844, + "auprc": 0.029723846509149488, + "brier": 0.012485671105908331, + "calibration": { + "observed_rate": 0.012578616352201259, + "mean_prediction": 0.011730652529049755, + "calibration_in_the_large": -0.0008479638231515037, + "expected_calibration_error_10bin": 0.002338037700712021, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + { + "valid": 2385, + "positives": 32, + "negatives": 2353, + "auroc": 0.7454977688057799, + "auprc": 0.03350344086589373, + "brier": 0.013293779884847505, + "calibration": { + "observed_rate": 0.013417190775681341, + "mean_prediction": 0.012758192114177622, + "calibration_in_the_large": -0.000658998661503719, + "expected_calibration_error_10bin": 0.001869296196304395, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + { + "valid": 2385, + "positives": 32, + "negatives": 2353, + "auroc": 0.7462813429664258, + "auprc": 0.033707157386133245, + "brier": 0.013324635824565287, + "calibration": { + "observed_rate": 0.013417190775681341, + "mean_prediction": 0.01351303421322108, + "calibration_in_the_large": 9.584343753973878e-05, + "expected_calibration_error_10bin": 0.0019305109230906893, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + { + "valid": 2385, + "positives": 32, + "negatives": 2353, + "auroc": 0.7460821291967701, + "auprc": 0.033660714983181676, + "brier": 0.013332462387984075, + "calibration": { + "observed_rate": 0.013417190775681341, + "mean_prediction": 0.013643976428206283, + "calibration_in_the_large": 0.00022678565252494225, + "expected_calibration_error_10bin": 0.0019241983778247574, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + } + ], + "reason": null + }, + "I49": { + "time_averaged_auroc": 0.7327954057954298, + "time_averaged_auprc": 0.011864033334555142, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2734, + "positives": 4, + "negatives": 2730, + "auroc": 0.6945054945054945, + "auprc": 0.004529369854230053, + "brier": 0.0014611386690294422, + "calibration": { + "observed_rate": 0.001463057790782736, + "mean_prediction": 0.0005453167267358928, + "calibration_in_the_large": -0.0009177410640468432, + "expected_calibration_error_10bin": 0.0009177410640468432, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 5, + "negatives": 2729, + "auroc": 0.7865884939538292, + "auprc": 0.009660403678429002, + "brier": 0.001821392011204752, + "calibration": { + "observed_rate": 0.0018288222384784199, + "mean_prediction": 0.0016616519860557395, + "calibration_in_the_large": -0.00016717025242268032, + "expected_calibration_error_10bin": 0.00016717025242268032, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 6, + "negatives": 2728, + "auroc": 0.8004032258064516, + "auprc": 0.010080398108154254, + "brier": 0.002184297987376007, + "calibration": { + "observed_rate": 0.0021945866861741038, + "mean_prediction": 0.0021658682581038135, + "calibration_in_the_large": -2.8718428070290212e-05, + "expected_calibration_error_10bin": 2.8718428070290212e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 10, + "negatives": 2724, + "auroc": 0.786784140969163, + "auprc": 0.010864949128329388, + "brier": 0.0036370775485256475, + "calibration": { + "observed_rate": 0.0036576444769568397, + "mean_prediction": 0.002676194169716218, + "calibration_in_the_large": -0.0009814503072406219, + "expected_calibration_error_10bin": 0.0009814503072406219, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 12, + "negatives": 2722, + "auroc": 0.7365601273573353, + "auprc": 0.011006411716885644, + "brier": 0.004364428874884036, + "calibration": { + "observed_rate": 0.0043891733723482075, + "mean_prediction": 0.0030933010241730565, + "calibration_in_the_large": -0.001295872348175151, + "expected_calibration_error_10bin": 0.001295872348175151, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 14, + "negatives": 2720, + "auroc": 0.7498424369747899, + "auprc": 0.01262638851870401, + "brier": 0.005086323521987567, + "calibration": { + "observed_rate": 0.005120702267739576, + "mean_prediction": 0.0035064022684651724, + "calibration_in_the_large": -0.0016142999992744033, + "expected_calibration_error_10bin": 0.0016142999992744033, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 15, + "negatives": 2719, + "auroc": 0.7340934166973152, + "auprc": 0.012681789397074043, + "brier": 0.005450150720257779, + "calibration": { + "observed_rate": 0.005486466715435259, + "mean_prediction": 0.00392619129676534, + "calibration_in_the_large": -0.0015602754186699198, + "expected_calibration_error_10bin": 0.0015602754186699198, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 15, + "negatives": 2719, + "auroc": 0.7327448816967023, + "auprc": 0.012572240855128635, + "brier": 0.005451039323533301, + "calibration": { + "observed_rate": 0.005486466715435259, + "mean_prediction": 0.00413838663748118, + "calibration_in_the_large": -0.0013480800779540796, + "expected_calibration_error_10bin": 0.0013480800779540796, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 17, + "negatives": 2717, + "auroc": 0.6964645261858884, + "auprc": 0.012353040338036587, + "brier": 0.006179579250978851, + "calibration": { + "observed_rate": 0.006217995610826628, + "mean_prediction": 0.004496957890638447, + "calibration_in_the_large": -0.0017210377201881807, + "expected_calibration_error_10bin": 0.0017210377201881807, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 17, + "negatives": 2717, + "auroc": 0.6956851198337266, + "auprc": 0.012294064371799706, + "brier": 0.006180882414585099, + "calibration": { + "observed_rate": 0.006217995610826628, + "mean_prediction": 0.00471988997295737, + "calibration_in_the_large": -0.0014981056378692579, + "expected_calibration_error_10bin": 0.0014981056378692579, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 19, + "negatives": 2715, + "auroc": 0.7046815934864786, + "auprc": 0.01529476328421725, + "brier": 0.00689234221812848, + "calibration": { + "observed_rate": 0.006949524506217996, + "mean_prediction": 0.004945464502114274, + "calibration_in_the_large": -0.002004060004103722, + "expected_calibration_error_10bin": 0.002004060004103722, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 19, + "negatives": 2715, + "auroc": 0.7040418726373946, + "auprc": 0.015145295443721861, + "brier": 0.006893167915088271, + "calibration": { + "observed_rate": 0.006949524506217996, + "mean_prediction": 0.005212769411530158, + "calibration_in_the_large": -0.0017367550946878378, + "expected_calibration_error_10bin": 0.0017367550946878378, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 19, + "negatives": 2715, + "auroc": 0.7039449452360182, + "auprc": 0.015123318654506408, + "brier": 0.006893299236140528, + "calibration": { + "observed_rate": 0.006949524506217996, + "mean_prediction": 0.005250787538143819, + "calibration_in_the_large": -0.0016987369680741765, + "expected_calibration_error_10bin": 0.0016987369680741765, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + } + ], + "reason": null + }, + "I50": { + "time_averaged_auroc": 0.817506343557998, + "time_averaged_auprc": 0.0774723272696202, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2415, + "positives": 7, + "negatives": 2408, + "auroc": 0.8633720930232558, + "auprc": 0.03130887244090785, + "brier": 0.0028755859871143256, + "calibration": { + "observed_rate": 0.002898550724637681, + "mean_prediction": 0.0034708689884898167, + "calibration_in_the_large": 0.0005723182638521355, + "expected_calibration_error_10bin": 0.0005723182638521357, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + { + "valid": 2415, + "positives": 17, + "negatives": 2398, + "auroc": 0.8623607908551244, + "auprc": 0.038781407881893756, + "brier": 0.007023614009370407, + "calibration": { + "observed_rate": 0.007039337474120083, + "mean_prediction": 0.007766375255460028, + "calibration_in_the_large": 0.0007270377813399448, + "expected_calibration_error_10bin": 0.0009904718719173414, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + { + "valid": 2415, + "positives": 25, + "negatives": 2390, + "auroc": 0.8371213389121339, + "auprc": 0.049783339543293906, + "brier": 0.010265563066295329, + "calibration": { + "observed_rate": 0.010351966873706004, + "mean_prediction": 0.010199243543707482, + "calibration_in_the_large": -0.000152723329998522, + "expected_calibration_error_10bin": 0.0027744515303482695, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + { + "valid": 2415, + "positives": 31, + "negatives": 2384, + "auroc": 0.7973587356570686, + "auprc": 0.05232169277523121, + "brier": 0.012722882566080469, + "calibration": { + "observed_rate": 0.012836438923395446, + "mean_prediction": 0.012080321235148506, + "calibration_in_the_large": -0.0007561176882469392, + "expected_calibration_error_10bin": 0.004474259156168666, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + { + "valid": 2415, + "positives": 33, + "negatives": 2382, + "auroc": 0.8089077169681703, + "auprc": 0.07212112642458933, + "brier": 0.013343073016680106, + "calibration": { + "observed_rate": 0.013664596273291925, + "mean_prediction": 0.013511850846669584, + "calibration_in_the_large": -0.0001527454266223409, + "expected_calibration_error_10bin": 0.002940497126449074, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + { + "valid": 2415, + "positives": 35, + "negatives": 2380, + "auroc": 0.8149819927971188, + "auprc": 0.0815215731498301, + "brier": 0.014098790310629853, + "calibration": { + "observed_rate": 0.014492753623188406, + "mean_prediction": 0.014984326210711368, + "calibration_in_the_large": 0.0004915725875229617, + "expected_calibration_error_10bin": 0.002232430099810817, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + { + "valid": 2415, + "positives": 38, + "negatives": 2377, + "auroc": 0.8000686402586188, + "auprc": 0.07953195748507892, + "brier": 0.015418391964628327, + "calibration": { + "observed_rate": 0.015734989648033125, + "mean_prediction": 0.016584733304411934, + "calibration_in_the_large": 0.000849743656378809, + "expected_calibration_error_10bin": 0.00410591606705114, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + { + "valid": 2415, + "positives": 42, + "negatives": 2373, + "auroc": 0.8046876567736239, + "auprc": 0.0841426517468212, + "brier": 0.016982776978137538, + "calibration": { + "observed_rate": 0.017391304347826087, + "mean_prediction": 0.017286113381339285, + "calibration_in_the_large": -0.00010519096648680185, + "expected_calibration_error_10bin": 0.004044926029107704, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + { + "valid": 2415, + "positives": 44, + "negatives": 2371, + "auroc": 0.7979563667037307, + "auprc": 0.08403661924786425, + "brier": 0.017864538930759902, + "calibration": { + "observed_rate": 0.018219461697722567, + "mean_prediction": 0.018604880775920696, + "calibration_in_the_large": 0.00038541907819812996, + "expected_calibration_error_10bin": 0.005128383314684464, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + { + "valid": 2415, + "positives": 46, + "negatives": 2369, + "auroc": 0.8024849964211647, + "auprc": 0.08866701759525573, + "brier": 0.018594755558792204, + "calibration": { + "observed_rate": 0.01904761904761905, + "mean_prediction": 0.01929733795927925, + "calibration_in_the_large": 0.00024971891166020166, + "expected_calibration_error_10bin": 0.004755147383072293, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + { + "valid": 2415, + "positives": 50, + "negatives": 2365, + "auroc": 0.8115771670190275, + "auprc": 0.12177675413600504, + "brier": 0.01971408247374623, + "calibration": { + "observed_rate": 0.020703933747412008, + "mean_prediction": 0.020588968349856906, + "calibration_in_the_large": -0.00011496539755510155, + "expected_calibration_error_10bin": 0.004941379939476858, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + { + "valid": 2415, + "positives": 52, + "negatives": 2363, + "auroc": 0.8133728311468472, + "auprc": 0.11171997247451451, + "brier": 0.020570014972117343, + "calibration": { + "observed_rate": 0.021532091097308487, + "mean_prediction": 0.021711687116021307, + "calibration_in_the_large": 0.0001795960187128201, + "expected_calibration_error_10bin": 0.006150731192740242, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + { + "valid": 2415, + "positives": 52, + "negatives": 2363, + "auroc": 0.8133321397180898, + "auprc": 0.11142726960377672, + "brier": 0.020584443745622724, + "calibration": { + "observed_rate": 0.021532091097308487, + "mean_prediction": 0.021873207109730584, + "calibration_in_the_large": 0.000341116012422097, + "expected_calibration_error_10bin": 0.006390360663967944, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + } + ], + "reason": null + }, + "I51": { + "time_averaged_auroc": 0.8374488133180649, + "time_averaged_auprc": 0.012447861009776018, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2807, + "positives": 2, + "negatives": 2805, + "auroc": 0.7607843137254902, + "auprc": 0.002554095779360569, + "brier": 0.0007118781445066031, + "calibration": { + "observed_rate": 0.0007125044531528322, + "mean_prediction": 0.0005559915936026875, + "calibration_in_the_large": -0.00015651285955014464, + "expected_calibration_error_10bin": 0.00015651285955014464, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 3, + "negatives": 2804, + "auroc": 0.8509272467902995, + "auprc": 0.008090314608382663, + "brier": 0.0010657155284766692, + "calibration": { + "observed_rate": 0.0010687566797292483, + "mean_prediction": 0.0010408690772866832, + "calibration_in_the_large": -2.7887602442565112e-05, + "expected_calibration_error_10bin": 2.7887602442565112e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 5, + "negatives": 2802, + "auroc": 0.8553176302640971, + "auprc": 0.008486872049025079, + "brier": 0.0017749666441074796, + "calibration": { + "observed_rate": 0.0017812611328820805, + "mean_prediction": 0.0012657378071083067, + "calibration_in_the_large": -0.0005155233257737738, + "expected_calibration_error_10bin": 0.0005155233257737738, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 5, + "negatives": 2802, + "auroc": 0.8460385438972162, + "auprc": 0.007788677051687622, + "brier": 0.0017754800813692916, + "calibration": { + "observed_rate": 0.0017812611328820805, + "mean_prediction": 0.0014693090818070017, + "calibration_in_the_large": -0.00031195205107507873, + "expected_calibration_error_10bin": 0.00031195205107507873, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 5, + "negatives": 2802, + "auroc": 0.8413276231263384, + "auprc": 0.007511945307796593, + "brier": 0.0017758035957628898, + "calibration": { + "observed_rate": 0.0017812611328820805, + "mean_prediction": 0.0015356693152587272, + "calibration_in_the_large": -0.0002455918176233532, + "expected_calibration_error_10bin": 0.0002455918176233532, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 6, + "negatives": 2801, + "auroc": 0.838034035463525, + "auprc": 0.008093764717757013, + "brier": 0.0021304912905243025, + "calibration": { + "observed_rate": 0.0021375133594584966, + "mean_prediction": 0.0017488280186319881, + "calibration_in_the_large": -0.00038868534082650845, + "expected_calibration_error_10bin": 0.00038868534082650845, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 6, + "negatives": 2801, + "auroc": 0.8385100559324051, + "auprc": 0.008068767466342481, + "brier": 0.0021309916118125694, + "calibration": { + "observed_rate": 0.0021375133594584966, + "mean_prediction": 0.0018945445583272158, + "calibration_in_the_large": -0.00024296880113128076, + "expected_calibration_error_10bin": 0.00024296880113128076, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 7, + "negatives": 2800, + "auroc": 0.8545408163265306, + "auprc": 0.010466196777351605, + "brier": 0.002483268740310128, + "calibration": { + "observed_rate": 0.0024937655860349127, + "mean_prediction": 0.002050596143068419, + "calibration_in_the_large": -0.00044316944296649355, + "expected_calibration_error_10bin": 0.00044316944296649355, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 7, + "negatives": 2800, + "auroc": 0.8525510204081632, + "auprc": 0.010317645454144474, + "brier": 0.002483886774476622, + "calibration": { + "observed_rate": 0.0024937655860349127, + "mean_prediction": 0.0021350034030116318, + "calibration_in_the_large": -0.0003587621830232809, + "expected_calibration_error_10bin": 0.0003587621830232809, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 8, + "negatives": 2799, + "auroc": 0.8481153983565559, + "auprc": 0.010781259431152346, + "brier": 0.0028380879144994206, + "calibration": { + "observed_rate": 0.0028500178126113287, + "mean_prediction": 0.002259024218875516, + "calibration_in_the_large": -0.0005909935937358128, + "expected_calibration_error_10bin": 0.0005909935937358128, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 9, + "negatives": 2798, + "auroc": 0.8648637915971726, + "auprc": 0.02684196493495935, + "brier": 0.003175560854642843, + "calibration": { + "observed_rate": 0.003206270039187745, + "mean_prediction": 0.002405953226350836, + "calibration_in_the_large": -0.000800316812836909, + "expected_calibration_error_10bin": 0.000800316812836909, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.8179120486235252, + "auprc": 0.026412459597814585, + "brier": 0.0035301263249121794, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.002521667961950411, + "calibration_in_the_large": -0.0010408543038137501, + "expected_calibration_error_10bin": 0.0010408543038137501, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.8179120486235252, + "auprc": 0.026408229951313877, + "brier": 0.003530091433600938, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.002526566964426887, + "calibration_in_the_large": -0.001035955301337274, + "expected_calibration_error_10bin": 0.001035955301337274, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + } + ], + "reason": null + }, + "I61": { + "time_averaged_auroc": 0.8125233905657395, + "time_averaged_auprc": 0.008813071297021621, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2802, + "positives": 2, + "negatives": 2800, + "auroc": 0.6894642857142858, + "auprc": 0.0035113183204316207, + "brier": 0.0007133244435423889, + "calibration": { + "observed_rate": 0.0007137758743754461, + "mean_prediction": 0.00023264917996255894, + "calibration_in_the_large": -0.0004811266944128872, + "expected_calibration_error_10bin": 0.0004811266944128872, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 2, + "negatives": 2800, + "auroc": 0.7575, + "auprc": 0.004573730743797605, + "brier": 0.0007131316456381397, + "calibration": { + "observed_rate": 0.0007137758743754461, + "mean_prediction": 0.00037659534923026447, + "calibration_in_the_large": -0.00033718052514518165, + "expected_calibration_error_10bin": 0.00033718052514518165, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.7949428162973553, + "auprc": 0.005576811420412093, + "brier": 0.001425657026994077, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.0005023815933431761, + "calibration_in_the_large": -0.0009251701554077161, + "expected_calibration_error_10bin": 0.0009251701554077161, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 5, + "negatives": 2797, + "auroc": 0.8119413657490168, + "auprc": 0.006603733046504875, + "brier": 0.0017817040692911358, + "calibration": { + "observed_rate": 0.0017844396859386152, + "mean_prediction": 0.0005609203055634663, + "calibration_in_the_large": -0.001223519380375149, + "expected_calibration_error_10bin": 0.001223519380375149, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 5, + "negatives": 2797, + "auroc": 0.8150875938505542, + "auprc": 0.006682754731813791, + "brier": 0.0017815140021945695, + "calibration": { + "observed_rate": 0.0017844396859386152, + "mean_prediction": 0.0006287215529845526, + "calibration_in_the_large": -0.0011557181329540627, + "expected_calibration_error_10bin": 0.0011557181329540627, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 6, + "negatives": 2796, + "auroc": 0.8145565092989986, + "auprc": 0.00727812239436196, + "brier": 0.002137402261524719, + "calibration": { + "observed_rate": 0.0021413276231263384, + "mean_prediction": 0.0007188776819097462, + "calibration_in_the_large": -0.0014224499412165922, + "expected_calibration_error_10bin": 0.0014224499412165922, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 7, + "negatives": 2795, + "auroc": 0.8335292614362382, + "auprc": 0.009593485076685672, + "brier": 0.002492473305602333, + "calibration": { + "observed_rate": 0.0024982155603140615, + "mean_prediction": 0.0007401938932854032, + "calibration_in_the_large": -0.0017580216670286582, + "expected_calibration_error_10bin": 0.0017580216670286582, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 8, + "negatives": 2794, + "auroc": 0.8447566213314245, + "auprc": 0.01195929430110062, + "brier": 0.0028468891177952592, + "calibration": { + "observed_rate": 0.0028551034975017845, + "mean_prediction": 0.0008640652344440837, + "calibration_in_the_large": -0.0019910382630577007, + "expected_calibration_error_10bin": 0.0019910382630577007, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 8, + "negatives": 2794, + "auroc": 0.842474946313529, + "auprc": 0.011907457934129898, + "brier": 0.002846166974646197, + "calibration": { + "observed_rate": 0.0028551034975017845, + "mean_prediction": 0.0009888388534381115, + "calibration_in_the_large": -0.001866264644063673, + "expected_calibration_error_10bin": 0.001866264644063673, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 8, + "negatives": 2794, + "auroc": 0.8465909090909091, + "auprc": 0.011839644905634376, + "brier": 0.002845874237579053, + "calibration": { + "observed_rate": 0.0028551034975017845, + "mean_prediction": 0.0011185886834702262, + "calibration_in_the_large": -0.0017365148140315583, + "expected_calibration_error_10bin": 0.0017365148140315583, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 8, + "negatives": 2794, + "auroc": 0.8463672154617037, + "auprc": 0.011825214868843937, + "brier": 0.002845301223251309, + "calibration": { + "observed_rate": 0.0028551034975017845, + "mean_prediction": 0.0012220946739851506, + "calibration_in_the_large": -0.0016330088235166338, + "expected_calibration_error_10bin": 0.0016330088235166338, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.8327564944106297, + "auprc": 0.011602763744248904, + "brier": 0.00320070710457863, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.0013463942866281035, + "calibration_in_the_large": -0.001865597148061404, + "expected_calibration_error_10bin": 0.001865597148061404, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.8328360583999682, + "auprc": 0.011615595373315732, + "brier": 0.0032006984201617475, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.0013513174892716368, + "calibration_in_the_large": -0.0018606739454178707, + "expected_calibration_error_10bin": 0.0018606739454178707, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + } + ], + "reason": null + }, + "I63": { + "time_averaged_auroc": 0.7945687367746321, + "time_averaged_auprc": 0.016542466816276132, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2735, + "positives": 4, + "negatives": 2731, + "auroc": 0.8916147931160747, + "auprc": 0.008058063180484847, + "brier": 0.0014589829604016679, + "calibration": { + "observed_rate": 0.0014625228519195613, + "mean_prediction": 0.0013114562630767775, + "calibration_in_the_large": -0.00015106658884278383, + "expected_calibration_error_10bin": 0.00015106658884278383, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + { + "valid": 2735, + "positives": 6, + "negatives": 2729, + "auroc": 0.8031635519726396, + "auprc": 0.007058373459693505, + "brier": 0.002198597403518905, + "calibration": { + "observed_rate": 0.0021937842778793418, + "mean_prediction": 0.0020588753497424303, + "calibration_in_the_large": -0.0001349089281369115, + "expected_calibration_error_10bin": 0.0001349089281369115, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + { + "valid": 2735, + "positives": 8, + "negatives": 2727, + "auroc": 0.8472222222222222, + "auprc": 0.021578478367237947, + "brier": 0.00291426069143416, + "calibration": { + "observed_rate": 0.0029250457038391227, + "mean_prediction": 0.002753018578397536, + "calibration_in_the_large": -0.00017202712544158675, + "expected_calibration_error_10bin": 0.00035175045556971364, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + { + "valid": 2735, + "positives": 9, + "negatives": 2726, + "auroc": 0.7954267547077525, + "auprc": 0.019795064536387245, + "brier": 0.0032868251425216366, + "calibration": { + "observed_rate": 0.0032906764168190127, + "mean_prediction": 0.0033159192267487323, + "calibration_in_the_large": 2.524280992971962e-05, + "expected_calibration_error_10bin": 0.0001858646703129382, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + { + "valid": 2735, + "positives": 10, + "negatives": 2725, + "auroc": 0.7950091743119266, + "auprc": 0.018509409315296873, + "brier": 0.003655432795411994, + "calibration": { + "observed_rate": 0.003656307129798903, + "mean_prediction": 0.003669255420972926, + "calibration_in_the_large": 1.2948291174022866e-05, + "expected_calibration_error_10bin": 0.0002960854524681256, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + { + "valid": 2735, + "positives": 11, + "negatives": 2724, + "auroc": 0.8039981310906421, + "auprc": 0.018352494626899536, + "brier": 0.004020755322070144, + "calibration": { + "observed_rate": 0.0040219378427787935, + "mean_prediction": 0.0038908434724279316, + "calibration_in_the_large": -0.00013109437035086196, + "expected_calibration_error_10bin": 0.00046382120546572636, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + { + "valid": 2735, + "positives": 11, + "negatives": 2724, + "auroc": 0.8043318649045521, + "auprc": 0.018440968618051296, + "brier": 0.004028384268093244, + "calibration": { + "observed_rate": 0.0040219378427787935, + "mean_prediction": 0.00419224670005305, + "calibration_in_the_large": 0.00017030885727425688, + "expected_calibration_error_10bin": 0.00018845198997781605, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + { + "valid": 2735, + "positives": 12, + "negatives": 2723, + "auroc": 0.8021177622720039, + "auprc": 0.01831115853241926, + "brier": 0.004398933673563035, + "calibration": { + "observed_rate": 0.0043875685557586835, + "mean_prediction": 0.004425788392308621, + "calibration_in_the_large": 3.8219836549937755e-05, + "expected_calibration_error_10bin": 0.00034955317381903746, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + { + "valid": 2735, + "positives": 14, + "negatives": 2721, + "auroc": 0.7779440331810784, + "auprc": 0.01776756387705962, + "brier": 0.0051309686778777674, + "calibration": { + "observed_rate": 0.005118829981718464, + "mean_prediction": 0.004697721161383131, + "calibration_in_the_large": -0.0004211088203353334, + "expected_calibration_error_10bin": 0.0008229154228656646, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + { + "valid": 2735, + "positives": 14, + "negatives": 2721, + "auroc": 0.7778127789153148, + "auprc": 0.01774408093906301, + "brier": 0.005142052251570009, + "calibration": { + "observed_rate": 0.005118829981718464, + "mean_prediction": 0.004945819203705562, + "calibration_in_the_large": -0.00017301077801290272, + "expected_calibration_error_10bin": 0.000684633343115, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + { + "valid": 2735, + "positives": 15, + "negatives": 2720, + "auroc": 0.7672549019607843, + "auprc": 0.017096457534607434, + "brier": 0.005511558894587352, + "calibration": { + "observed_rate": 0.005484460694698354, + "mean_prediction": 0.005196492079443956, + "calibration_in_the_large": -0.0002879686152543982, + "expected_calibration_error_10bin": 0.000815810132687132, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + { + "valid": 2735, + "positives": 16, + "negatives": 2719, + "auroc": 0.7320706141963957, + "auprc": 0.016188331450013086, + "brier": 0.005880360884746466, + "calibration": { + "observed_rate": 0.005850091407678245, + "mean_prediction": 0.00529488103047215, + "calibration_in_the_large": -0.0005552103772060949, + "expected_calibration_error_10bin": 0.0010920550999556405, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + { + "valid": 2735, + "positives": 16, + "negatives": 2719, + "auroc": 0.7314269952188305, + "auprc": 0.016151624174376097, + "brier": 0.005884592765603617, + "calibration": { + "observed_rate": 0.005850091407678245, + "mean_prediction": 0.00541068374499765, + "calibration_in_the_large": -0.00043940766268059546, + "expected_calibration_error_10bin": 0.0011330855051886629, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + } + ], + "reason": null + }, + "I65": { + "time_averaged_auroc": 0.6582975225760975, + "time_averaged_auprc": 0.011208387113379138, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2774, + "positives": 0, + "negatives": 2774, + "auroc": null, + "auprc": null, + "brier": 1.0514555419810433e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.000649111463539086, + "calibration_in_the_large": 0.000649111463539086, + "expected_calibration_error_10bin": 0.000649111463539086, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 2, + "negatives": 2772, + "auroc": 0.6329365079365079, + "auprc": 0.001430266168193714, + "brier": 0.0007224622207142649, + "calibration": { + "observed_rate": 0.0007209805335255948, + "mean_prediction": 0.0009486909151052898, + "calibration_in_the_large": 0.00022771038157969503, + "expected_calibration_error_10bin": 0.00022771038157969503, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 2, + "negatives": 2772, + "auroc": 0.6165223665223665, + "auprc": 0.001368830272312751, + "brier": 0.0007247125705687501, + "calibration": { + "observed_rate": 0.0007209805335255948, + "mean_prediction": 0.0013050807804633375, + "calibration_in_the_large": 0.0005841002469377428, + "expected_calibration_error_10bin": 0.0005841002469377428, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 3, + "negatives": 2771, + "auroc": 0.735474557921328, + "auprc": 0.025316194152646552, + "brier": 0.0010794404993334018, + "calibration": { + "observed_rate": 0.0010814708002883922, + "mean_prediction": 0.0017468872121272215, + "calibration_in_the_large": 0.0006654164118388294, + "expected_calibration_error_10bin": 0.0006654164118388294, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 3, + "negatives": 2771, + "auroc": 0.7325875135330205, + "auprc": 0.02232500616233866, + "brier": 0.0010820744406278176, + "calibration": { + "observed_rate": 0.0010814708002883922, + "mean_prediction": 0.002166087873785305, + "calibration_in_the_large": 0.001084617073496913, + "expected_calibration_error_10bin": 0.001084617073496913, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 5, + "negatives": 2769, + "auroc": 0.6711448176236908, + "auprc": 0.012412259871892357, + "brier": 0.0018028478255897957, + "calibration": { + "observed_rate": 0.001802451333813987, + "mean_prediction": 0.0023435966122345026, + "calibration_in_the_large": 0.0005411452784205156, + "expected_calibration_error_10bin": 0.0005411452784205156, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 5, + "negatives": 2769, + "auroc": 0.6776453593355002, + "auprc": 0.011548368165711467, + "brier": 0.0018061332067535693, + "calibration": { + "observed_rate": 0.001802451333813987, + "mean_prediction": 0.0027090210151335115, + "calibration_in_the_large": 0.0009065696813195245, + "expected_calibration_error_10bin": 0.0009065696813195245, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 5, + "negatives": 2769, + "auroc": 0.6720115565185988, + "auprc": 0.01150755266137933, + "brier": 0.0018074591402872364, + "calibration": { + "observed_rate": 0.001802451333813987, + "mean_prediction": 0.0028339166381460687, + "calibration_in_the_large": 0.0010314653043320817, + "expected_calibration_error_10bin": 0.0010314653043320817, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.6260236030828517, + "auprc": 0.01018640543104152, + "brier": 0.0021695105077093493, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.0030305655696332787, + "calibration_in_the_large": 0.0008676239690564944, + "expected_calibration_error_10bin": 0.0008676239690564944, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.6313222543352601, + "auprc": 0.00958587720825824, + "brier": 0.0021726491674021902, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.003325920083655041, + "calibration_in_the_large": 0.0011629784830782565, + "expected_calibration_error_10bin": 0.0011629784830782565, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.6349349710982659, + "auprc": 0.009609051986132962, + "brier": 0.0021747290094150467, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.003560512356155039, + "calibration_in_the_large": 0.0013975707555782548, + "expected_calibration_error_10bin": 0.0013975707555782548, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.6345134874759152, + "auprc": 0.009605554531344726, + "brier": 0.002176857501518911, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.00369872869620135, + "calibration_in_the_large": 0.0015357870956245658, + "expected_calibration_error_10bin": 0.0015357870956245658, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.6344532755298651, + "auprc": 0.009605278749297378, + "brier": 0.0021769710630753325, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.0037068830327062112, + "calibration_in_the_large": 0.001543941432129427, + "expected_calibration_error_10bin": 0.001543941432129427, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + } + ], + "reason": null + }, + "I67": { + "time_averaged_auroc": 0.7428027354911719, + "time_averaged_auprc": 0.0040452761182496475, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2773, + "positives": 2, + "negatives": 2771, + "auroc": 0.8863226272103933, + "auprc": 0.0046940347787805415, + "brier": 0.0007209203123300066, + "calibration": { + "observed_rate": 0.000721240533717995, + "mean_prediction": 0.0006673485415089178, + "calibration_in_the_large": -5.389199220907719e-05, + "expected_calibration_error_10bin": 5.389199220907719e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 2, + "negatives": 2771, + "auroc": 0.8720678455431252, + "auprc": 0.004436031838477966, + "brier": 0.0007239461932990495, + "calibration": { + "observed_rate": 0.000721240533717995, + "mean_prediction": 0.001090352988034397, + "calibration_in_the_large": 0.0003691124543164021, + "expected_calibration_error_10bin": 0.0003691124543164021, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 2, + "negatives": 2771, + "auroc": 0.8702634428004331, + "auprc": 0.004185932464620989, + "brier": 0.0007275118501637599, + "calibration": { + "observed_rate": 0.000721240533717995, + "mean_prediction": 0.0014841124780172255, + "calibration_in_the_large": 0.0007628719442992305, + "expected_calibration_error_10bin": 0.0007628719442992305, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 2, + "negatives": 2771, + "auroc": 0.865211115120895, + "auprc": 0.004044117647058823, + "brier": 0.0007367179629506115, + "calibration": { + "observed_rate": 0.000721240533717995, + "mean_prediction": 0.001948306488843885, + "calibration_in_the_large": 0.0012270659551258901, + "expected_calibration_error_10bin": 0.0012270659551258901, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 2, + "negatives": 2771, + "auroc": 0.856910862504511, + "auprc": 0.0037562692663106736, + "brier": 0.0007455973260415573, + "calibration": { + "observed_rate": 0.000721240533717995, + "mean_prediction": 0.0023714074379934586, + "calibration_in_the_large": 0.0016501669042754638, + "expected_calibration_error_10bin": 0.0016501669042754638, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 3, + "negatives": 2770, + "auroc": 0.6316486161251504, + "auprc": 0.0029445141652110784, + "brier": 0.0011075104305872064, + "calibration": { + "observed_rate": 0.0010818608005769925, + "mean_prediction": 0.0024438875443192993, + "calibration_in_the_large": 0.0013620267437423068, + "expected_calibration_error_10bin": 0.0013620267437423068, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 3, + "negatives": 2770, + "auroc": 0.6316486161251504, + "auprc": 0.0029747445536919223, + "brier": 0.001113193611674584, + "calibration": { + "observed_rate": 0.0010818608005769925, + "mean_prediction": 0.002689040780319759, + "calibration_in_the_large": 0.0016071799797427665, + "expected_calibration_error_10bin": 0.0016071799797427665, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 3, + "negatives": 2770, + "auroc": 0.6320096269554754, + "auprc": 0.0030477296843850568, + "brier": 0.0011198131573045902, + "calibration": { + "observed_rate": 0.0010818608005769925, + "mean_prediction": 0.002918650402197857, + "calibration_in_the_large": 0.0018367896016208646, + "expected_calibration_error_10bin": 0.0018367896016208646, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 3, + "negatives": 2770, + "auroc": 0.6315282791817087, + "auprc": 0.0030343446133560483, + "brier": 0.001123031083839128, + "calibration": { + "observed_rate": 0.0010818608005769925, + "mean_prediction": 0.003031506388405263, + "calibration_in_the_large": 0.0019496455878282705, + "expected_calibration_error_10bin": 0.0019496455878282705, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 3, + "negatives": 2770, + "auroc": 0.6303249097472924, + "auprc": 0.00310688138604324, + "brier": 0.0011278947474103109, + "calibration": { + "observed_rate": 0.0010818608005769925, + "mean_prediction": 0.0031819218038573547, + "calibration_in_the_large": 0.0021000610032803624, + "expected_calibration_error_10bin": 0.0021000610032803624, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 4, + "negatives": 2769, + "auroc": 0.7030516431924883, + "auprc": 0.005131468447242681, + "brier": 0.0014902808736468518, + "calibration": { + "observed_rate": 0.00144248106743599, + "mean_prediction": 0.00341642217011692, + "calibration_in_the_large": 0.0019739411026809296, + "expected_calibration_error_10bin": 0.0019739411026809296, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 5, + "negatives": 2768, + "auroc": 0.7226878612716763, + "auprc": 0.005616591561382759, + "brier": 0.0018537182609357095, + "calibration": { + "observed_rate": 0.0018031013342949874, + "mean_prediction": 0.003624360992031501, + "calibration_in_the_large": 0.0018212596577365135, + "expected_calibration_error_10bin": 0.0018212596577365137, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + { + "valid": 2773, + "positives": 5, + "negatives": 2768, + "auroc": 0.7227601156069364, + "auprc": 0.005615929130683641, + "brier": 0.001854471894133874, + "calibration": { + "observed_rate": 0.0018031013342949874, + "mean_prediction": 0.00364332704863292, + "calibration_in_the_large": 0.0018402257143379328, + "expected_calibration_error_10bin": 0.0018402257143379328, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + } + ], + "reason": null + }, + "I69": { + "time_averaged_auroc": 0.7738607027174538, + "time_averaged_auprc": 0.02155733415495052, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2752, + "positives": 4, + "negatives": 2748, + "auroc": 0.8861899563318777, + "auprc": 0.014989697907927953, + "brier": 0.0014495096783940099, + "calibration": { + "observed_rate": 0.0014534883720930232, + "mean_prediction": 0.002255195992356173, + "calibration_in_the_large": 0.0008017076202631499, + "expected_calibration_error_10bin": 0.0008017076202631499, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + { + "valid": 2752, + "positives": 9, + "negatives": 2743, + "auroc": 0.7885931866974522, + "auprc": 0.01777807856058182, + "brier": 0.003256060165885707, + "calibration": { + "observed_rate": 0.0032703488372093025, + "mean_prediction": 0.0037566928376862917, + "calibration_in_the_large": 0.0004863440004769892, + "expected_calibration_error_10bin": 0.0004863440004769892, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + { + "valid": 2752, + "positives": 12, + "negatives": 2740, + "auroc": 0.7702250608272506, + "auprc": 0.0169679465883848, + "brier": 0.004348267673119302, + "calibration": { + "observed_rate": 0.00436046511627907, + "mean_prediction": 0.004459142059859851, + "calibration_in_the_large": 9.867694358078102e-05, + "expected_calibration_error_10bin": 9.867694358078102e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + { + "valid": 2752, + "positives": 14, + "negatives": 2738, + "auroc": 0.7587916101429615, + "auprc": 0.01592417414747963, + "brier": 0.005089311289338121, + "calibration": { + "observed_rate": 0.005087209302325582, + "mean_prediction": 0.005162467144841262, + "calibration_in_the_large": 7.525784251568007e-05, + "expected_calibration_error_10bin": 0.0001548050566424172, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + { + "valid": 2752, + "positives": 14, + "negatives": 2738, + "auroc": 0.7583220285922989, + "auprc": 0.015857550646791077, + "brier": 0.005097237235608872, + "calibration": { + "observed_rate": 0.005087209302325582, + "mean_prediction": 0.005486926458214057, + "calibration_in_the_large": 0.0003997171558884748, + "expected_calibration_error_10bin": 0.0003997171558884746, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + { + "valid": 2752, + "positives": 14, + "negatives": 2738, + "auroc": 0.7563654387978712, + "auprc": 0.015318668977112824, + "brier": 0.00511573082539502, + "calibration": { + "observed_rate": 0.005087209302325582, + "mean_prediction": 0.005979603595839106, + "calibration_in_the_large": 0.0008923942935135246, + "expected_calibration_error_10bin": 0.0008923942935135249, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + { + "valid": 2752, + "positives": 15, + "negatives": 2737, + "auroc": 0.7387163561076605, + "auprc": 0.014630703476529276, + "brier": 0.0054939753157431616, + "calibration": { + "observed_rate": 0.005450581395348837, + "mean_prediction": 0.006313724375614626, + "calibration_in_the_large": 0.0008631429802657886, + "expected_calibration_error_10bin": 0.0008631429802657887, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + { + "valid": 2752, + "positives": 15, + "negatives": 2737, + "auroc": 0.7373036170990135, + "auprc": 0.014419984144938048, + "brier": 0.0055043579053087295, + "calibration": { + "observed_rate": 0.005450581395348837, + "mean_prediction": 0.006563082961258451, + "calibration_in_the_large": 0.0011125015659096136, + "expected_calibration_error_10bin": 0.0011125015659096131, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + { + "valid": 2752, + "positives": 16, + "negatives": 2736, + "auroc": 0.7522158260233918, + "auprc": 0.02729396098578216, + "brier": 0.005793321150306289, + "calibration": { + "observed_rate": 0.005813953488372093, + "mean_prediction": 0.006803343106615864, + "calibration_in_the_large": 0.0009893896182437707, + "expected_calibration_error_10bin": 0.000989389618243771, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + { + "valid": 2752, + "positives": 17, + "negatives": 2735, + "auroc": 0.7628777287880417, + "auprc": 0.028100679242274978, + "brier": 0.006150419912210225, + "calibration": { + "observed_rate": 0.0061773255813953485, + "mean_prediction": 0.007119124487052283, + "calibration_in_the_large": 0.0009417989056569346, + "expected_calibration_error_10bin": 0.0009417989056569343, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + { + "valid": 2752, + "positives": 19, + "negatives": 2733, + "auroc": 0.7836385695303022, + "auprc": 0.033085307524862224, + "brier": 0.006831037577904721, + "calibration": { + "observed_rate": 0.006904069767441861, + "mean_prediction": 0.007476702379343552, + "calibration_in_the_large": 0.0005726326119016916, + "expected_calibration_error_10bin": 0.0005726326119016916, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + { + "valid": 2752, + "positives": 19, + "negatives": 2733, + "auroc": 0.783503764900726, + "auprc": 0.03294073859369359, + "brier": 0.006844443462012972, + "calibration": { + "observed_rate": 0.006904069767441861, + "mean_prediction": 0.007860770761659973, + "calibration_in_the_large": 0.0009567009942181119, + "expected_calibration_error_10bin": 0.000956700994218113, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + { + "valid": 2752, + "positives": 19, + "negatives": 2733, + "auroc": 0.7834459914880505, + "auprc": 0.0329378532179984, + "brier": 0.006844959589994862, + "calibration": { + "observed_rate": 0.006904069767441861, + "mean_prediction": 0.007872904461818993, + "calibration_in_the_large": 0.0009688346943771322, + "expected_calibration_error_10bin": 0.0009688346943771335, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + } + ], + "reason": null + }, + "I70": { + "time_averaged_auroc": 0.8294528795361811, + "time_averaged_auprc": 0.021001125004459373, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2771, + "positives": 2, + "negatives": 2769, + "auroc": 0.887143373058866, + "auprc": 0.02165837479270315, + "brier": 0.0007188631010385373, + "calibration": { + "observed_rate": 0.0007217610970768675, + "mean_prediction": 0.0005136062085292516, + "calibration_in_the_large": -0.0002081548885476159, + "expected_calibration_error_10bin": 0.0002081548885476159, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + { + "valid": 2771, + "positives": 2, + "negatives": 2769, + "auroc": 0.8979776092452149, + "auprc": 0.02267156862745098, + "brier": 0.000718214287244949, + "calibration": { + "observed_rate": 0.0007217610970768675, + "mean_prediction": 0.0011397330046491144, + "calibration_in_the_large": 0.0004179719075722469, + "expected_calibration_error_10bin": 0.0004179719075722469, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + { + "valid": 2771, + "positives": 5, + "negatives": 2766, + "auroc": 0.83470715835141, + "auprc": 0.017642714802032076, + "brier": 0.001792704673137112, + "calibration": { + "observed_rate": 0.001804402742692169, + "mean_prediction": 0.0014310709930335657, + "calibration_in_the_large": -0.0003733317496586032, + "expected_calibration_error_10bin": 0.0003733317496586032, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + { + "valid": 2771, + "positives": 5, + "negatives": 2766, + "auroc": 0.840997830802603, + "auprc": 0.017879794259325277, + "brier": 0.0017924869233589735, + "calibration": { + "observed_rate": 0.001804402742692169, + "mean_prediction": 0.0016496977232988153, + "calibration_in_the_large": -0.00015470501939335367, + "expected_calibration_error_10bin": 0.00015470501939335367, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + { + "valid": 2771, + "positives": 5, + "negatives": 2766, + "auroc": 0.8452639190166306, + "auprc": 0.02046931898894722, + "brier": 0.0017925087844507942, + "calibration": { + "observed_rate": 0.001804402742692169, + "mean_prediction": 0.0019269452441005178, + "calibration_in_the_large": 0.00012254250140834888, + "expected_calibration_error_10bin": 0.00012254250140834888, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + { + "valid": 2771, + "positives": 7, + "negatives": 2764, + "auroc": 0.8032354765350423, + "auprc": 0.01685840161215032, + "brier": 0.002512729054746906, + "calibration": { + "observed_rate": 0.0025261638397690365, + "mean_prediction": 0.0020789158724886193, + "calibration_in_the_large": -0.00044724796728041723, + "expected_calibration_error_10bin": 0.00044724796728041723, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + { + "valid": 2771, + "positives": 7, + "negatives": 2764, + "auroc": 0.8059747777548067, + "auprc": 0.015446238043286745, + "brier": 0.0025149190105239975, + "calibration": { + "observed_rate": 0.0025261638397690365, + "mean_prediction": 0.0023407933921885298, + "calibration_in_the_large": -0.00018537044758050675, + "expected_calibration_error_10bin": 0.00018537044758050675, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + { + "valid": 2771, + "positives": 10, + "negatives": 2761, + "auroc": 0.7966678739587106, + "auprc": 0.01859126512261919, + "brier": 0.003591355583496644, + "calibration": { + "observed_rate": 0.003608805485384338, + "mean_prediction": 0.00250058725682502, + "calibration_in_the_large": -0.001108218228559318, + "expected_calibration_error_10bin": 0.001108218228559318, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + { + "valid": 2771, + "positives": 12, + "negatives": 2759, + "auroc": 0.813187145100882, + "auprc": 0.022132444863008183, + "brier": 0.004295626657244893, + "calibration": { + "observed_rate": 0.004330566582461205, + "mean_prediction": 0.0026277878843283917, + "calibration_in_the_large": -0.0017027786981328136, + "expected_calibration_error_10bin": 0.0017027786981328136, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + { + "valid": 2771, + "positives": 12, + "negatives": 2759, + "auroc": 0.8145161290322581, + "auprc": 0.024255680858652522, + "brier": 0.004294988634577167, + "calibration": { + "observed_rate": 0.004330566582461205, + "mean_prediction": 0.002844595395811002, + "calibration_in_the_large": -0.001485971186650203, + "expected_calibration_error_10bin": 0.001485971186650203, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + { + "valid": 2771, + "positives": 12, + "negatives": 2759, + "auroc": 0.8139724537876042, + "auprc": 0.02411009717131474, + "brier": 0.004295246710763247, + "calibration": { + "observed_rate": 0.004330566582461205, + "mean_prediction": 0.002988681388430126, + "calibration_in_the_large": -0.001341885194031079, + "expected_calibration_error_10bin": 0.001341885194031079, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + { + "valid": 2771, + "positives": 12, + "negatives": 2759, + "auroc": 0.8146671499335508, + "auprc": 0.02565256706375152, + "brier": 0.004294576814440683, + "calibration": { + "observed_rate": 0.004330566582461205, + "mean_prediction": 0.0030881712390559636, + "calibration_in_the_large": -0.0012423953434052416, + "expected_calibration_error_10bin": 0.0012423953434052416, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + { + "valid": 2771, + "positives": 12, + "negatives": 2759, + "auroc": 0.8145765373927751, + "auprc": 0.02564615885272996, + "brier": 0.004294506435339851, + "calibration": { + "observed_rate": 0.004330566582461205, + "mean_prediction": 0.003095767179255315, + "calibration_in_the_large": -0.00123479940320589, + "expected_calibration_error_10bin": 0.00123479940320589, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + } + ], + "reason": null + }, + "I71": { + "time_averaged_auroc": 0.7360289626734073, + "time_averaged_auprc": 0.005018647448664547, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2769, + "positives": 1, + "negatives": 2768, + "auroc": 0.9483381502890174, + "auprc": 0.006944444444444444, + "brier": 0.0003607164397228949, + "calibration": { + "observed_rate": 0.00036114120621162876, + "mean_prediction": 0.0005622275501518375, + "calibration_in_the_large": 0.00020108634394020873, + "expected_calibration_error_10bin": 0.00020108634394020873, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + { + "valid": 2769, + "positives": 3, + "negatives": 2766, + "auroc": 0.6726922149915643, + "auprc": 0.00416526981209159, + "brier": 0.0010834740760150802, + "calibration": { + "observed_rate": 0.0010834236186348862, + "mean_prediction": 0.001070565852714988, + "calibration_in_the_large": -1.2857765919898267e-05, + "expected_calibration_error_10bin": 1.2857765919898267e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + { + "valid": 2769, + "positives": 3, + "negatives": 2766, + "auroc": 0.6751024343215233, + "auprc": 0.0040457681090019975, + "brier": 0.0010853614639309355, + "calibration": { + "observed_rate": 0.0010834236186348862, + "mean_prediction": 0.001329415102839679, + "calibration_in_the_large": 0.0002459914842047929, + "expected_calibration_error_10bin": 0.0002459914842047929, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + { + "valid": 2769, + "positives": 3, + "negatives": 2766, + "auroc": 0.6763075439865027, + "auprc": 0.004215514087083791, + "brier": 0.0010869980200127, + "calibration": { + "observed_rate": 0.0010834236186348862, + "mean_prediction": 0.0015558687681111298, + "calibration_in_the_large": 0.0004724451494762436, + "expected_calibration_error_10bin": 0.0004724451494762436, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + { + "valid": 2769, + "positives": 3, + "negatives": 2766, + "auroc": 0.6753434562545192, + "auprc": 0.0038973925582791846, + "brier": 0.0010888478191413361, + "calibration": { + "observed_rate": 0.0010834236186348862, + "mean_prediction": 0.0017463611024779364, + "calibration_in_the_large": 0.0006629374838430502, + "expected_calibration_error_10bin": 0.0006629374838430502, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + { + "valid": 2769, + "positives": 4, + "negatives": 2765, + "auroc": 0.7255877034358047, + "auprc": 0.004824371404673907, + "brier": 0.001449049942434521, + "calibration": { + "observed_rate": 0.001444564824846515, + "mean_prediction": 0.0019690740758988193, + "calibration_in_the_large": 0.0005245092510523042, + "expected_calibration_error_10bin": 0.0005245092510523042, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + { + "valid": 2769, + "positives": 4, + "negatives": 2765, + "auroc": 0.7282097649186257, + "auprc": 0.004886829623737581, + "brier": 0.0014521421418557392, + "calibration": { + "observed_rate": 0.001444564824846515, + "mean_prediction": 0.002210088632127946, + "calibration_in_the_large": 0.0007655238072814311, + "expected_calibration_error_10bin": 0.0007655238072814311, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + { + "valid": 2769, + "positives": 4, + "negatives": 2765, + "auroc": 0.7279385171790235, + "auprc": 0.004847096220566756, + "brier": 0.00145357527991531, + "calibration": { + "observed_rate": 0.001444564824846515, + "mean_prediction": 0.0023138490234645426, + "calibration_in_the_large": 0.0008692841986180275, + "expected_calibration_error_10bin": 0.0008692841986180275, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + { + "valid": 2769, + "positives": 5, + "negatives": 2764, + "auroc": 0.7489146164978292, + "auprc": 0.005563123911126818, + "brier": 0.0018141572124830572, + "calibration": { + "observed_rate": 0.0018057060310581437, + "mean_prediction": 0.0025715071514527, + "calibration_in_the_large": 0.0007658011203945563, + "expected_calibration_error_10bin": 0.0007658011203945563, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + { + "valid": 2769, + "positives": 5, + "negatives": 2764, + "auroc": 0.7477568740955137, + "auprc": 0.005510206278485093, + "brier": 0.0018162203013981587, + "calibration": { + "observed_rate": 0.0018057060310581437, + "mean_prediction": 0.002710853444559751, + "calibration_in_the_large": 0.0009051474135016073, + "expected_calibration_error_10bin": 0.0009051474135016073, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + { + "valid": 2769, + "positives": 5, + "negatives": 2764, + "auroc": 0.7479739507959479, + "auprc": 0.005493514956782115, + "brier": 0.0018188323447793121, + "calibration": { + "observed_rate": 0.0018057060310581437, + "mean_prediction": 0.0028947572985011365, + "calibration_in_the_large": 0.0010890512674429928, + "expected_calibration_error_10bin": 0.0010890512674429928, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + { + "valid": 2769, + "positives": 5, + "negatives": 2764, + "auroc": 0.747178002894356, + "auprc": 0.005428573642435286, + "brier": 0.0018203701861878778, + "calibration": { + "observed_rate": 0.0018057060310581437, + "mean_prediction": 0.003011266873018628, + "calibration_in_the_large": 0.0012055608419604845, + "expected_calibration_error_10bin": 0.0012055608419604845, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + { + "valid": 2769, + "positives": 5, + "negatives": 2764, + "auroc": 0.7470332850940665, + "auprc": 0.005420311783930538, + "brier": 0.0018207652511710878, + "calibration": { + "observed_rate": 0.0018057060310581437, + "mean_prediction": 0.003027730002209298, + "calibration_in_the_large": 0.0012220239711511543, + "expected_calibration_error_10bin": 0.0012220239711511543, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + } + ], + "reason": null + }, + "I72": { + "time_averaged_auroc": 0.6991272254727151, + "time_averaged_auprc": 0.008022733903242152, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2818, + "positives": 2, + "negatives": 2816, + "auroc": 0.5790127840909091, + "auprc": 0.004291786644727821, + "brier": 0.0007094120477151682, + "calibration": { + "observed_rate": 0.0007097232079489, + "mean_prediction": 0.00043893463099960774, + "calibration_in_the_large": -0.0002707885769492922, + "expected_calibration_error_10bin": 0.0002707885769492922, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 2, + "negatives": 2816, + "auroc": 0.5662286931818182, + "auprc": 0.003088568662339154, + "brier": 0.0007103248536633564, + "calibration": { + "observed_rate": 0.0007097232079489, + "mean_prediction": 0.0006466560525046941, + "calibration_in_the_large": -6.306715544420589e-05, + "expected_calibration_error_10bin": 6.306715544420589e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 3, + "negatives": 2815, + "auroc": 0.6859680284191829, + "auprc": 0.005326856840318777, + "brier": 0.001064690860830933, + "calibration": { + "observed_rate": 0.0010645848119233499, + "mean_prediction": 0.0008264337107697063, + "calibration_in_the_large": -0.00023815110115364354, + "expected_calibration_error_10bin": 0.00023815110115364354, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.774120156416637, + "auprc": 0.010043003351960733, + "brier": 0.0017698684655364325, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0008790055528595603, + "calibration_in_the_large": -0.0008953024670126894, + "expected_calibration_error_10bin": 0.0008953024670126894, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.7728403839317455, + "auprc": 0.009886506773998775, + "brier": 0.0017703795245876577, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0010063237310058925, + "calibration_in_the_large": -0.0007679842888663573, + "expected_calibration_error_10bin": 0.0007679842888663573, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.7776039815143975, + "auprc": 0.010393936551355582, + "brier": 0.0017705269641352225, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0011912781078919838, + "calibration_in_the_large": -0.0005830299119802659, + "expected_calibration_error_10bin": 0.0005830299119802659, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.7750444365446143, + "auprc": 0.01015133444786921, + "brier": 0.001771071942808015, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0012593444736174334, + "calibration_in_the_large": -0.0005149635462548163, + "expected_calibration_error_10bin": 0.0005149635462548163, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.6952939781887151, + "auprc": 0.008621066432846478, + "brier": 0.0021280459599886236, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0013737487253537566, + "calibration_in_the_large": -0.0007554208984929432, + "expected_calibration_error_10bin": 0.0007554208984929432, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.6941678520625889, + "auprc": 0.008437089583943728, + "brier": 0.002129583689854608, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0014655419833827254, + "calibration_in_the_large": -0.0006636276404639744, + "expected_calibration_error_10bin": 0.0006636276404639744, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.6928046467520151, + "auprc": 0.008430655902349472, + "brier": 0.002130221179623407, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.001546987179352936, + "calibration_in_the_large": -0.0005821824444937637, + "expected_calibration_error_10bin": 0.0005821824444937637, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.6926861071597914, + "auprc": 0.008649535756205534, + "brier": 0.002130581890827664, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0016315688990457173, + "calibration_in_the_large": -0.0004976007248009824, + "expected_calibration_error_10bin": 0.0004976007248009824, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.6915599810336652, + "auprc": 0.008489641334406882, + "brier": 0.0021316924544331375, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0016859517152513878, + "calibration_in_the_large": -0.0004432179085953119, + "expected_calibration_error_10bin": 0.0004432179085953119, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.6913229018492176, + "auprc": 0.008485558459825827, + "brier": 0.00213174842509492, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0016891650711905615, + "calibration_in_the_large": -0.0004400045526561382, + "expected_calibration_error_10bin": 0.0004400045526561382, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + } + ], + "reason": null + }, + "I73": { + "time_averaged_auroc": 0.816096770055367, + "time_averaged_auprc": 0.06180921959026507, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2734, + "positives": 1, + "negatives": 2733, + "auroc": 0.867178924259056, + "auprc": 0.0027472527472527475, + "brier": 0.00036792212505661704, + "calibration": { + "observed_rate": 0.000365764447695684, + "mean_prediction": 0.0005941106603228767, + "calibration_in_the_large": 0.0002283462126271927, + "expected_calibration_error_10bin": 0.0002283462126271927, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 1, + "negatives": 2733, + "auroc": 0.8902305159165752, + "auprc": 0.0033222591362126247, + "brier": 0.00037406614577033633, + "calibration": { + "observed_rate": 0.000365764447695684, + "mean_prediction": 0.0010669539041158456, + "calibration_in_the_large": 0.0007011894564201616, + "expected_calibration_error_10bin": 0.0007011894564201616, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 3, + "negatives": 2731, + "auroc": 0.6620285609666788, + "auprc": 0.003240933280962393, + "brier": 0.0011092655166921284, + "calibration": { + "observed_rate": 0.0010972933430870519, + "mean_prediction": 0.0013467619526951915, + "calibration_in_the_large": 0.00024946860960813966, + "expected_calibration_error_10bin": 0.00024946860960813966, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 6, + "negatives": 2728, + "auroc": 0.823069403714565, + "auprc": 0.05518709411105036, + "brier": 0.0021530496429321105, + "calibration": { + "observed_rate": 0.0021945866861741038, + "mean_prediction": 0.0015471687700419146, + "calibration_in_the_large": -0.0006474179161321892, + "expected_calibration_error_10bin": 0.0006474179161321892, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 6, + "negatives": 2728, + "auroc": 0.822702834799609, + "auprc": 0.05540985197230419, + "brier": 0.0021497378408166087, + "calibration": { + "observed_rate": 0.0021945866861741038, + "mean_prediction": 0.0018399517586090292, + "calibration_in_the_large": -0.0003546349275650746, + "expected_calibration_error_10bin": 0.0003546349275650746, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 6, + "negatives": 2728, + "auroc": 0.8218475073313783, + "auprc": 0.05572274485841517, + "brier": 0.0021482161418398134, + "calibration": { + "observed_rate": 0.0021945866861741038, + "mean_prediction": 0.0020932883593281276, + "calibration_in_the_large": -0.00010129832684597617, + "expected_calibration_error_10bin": 0.00010129832684597617, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 7, + "negatives": 2727, + "auroc": 0.7703913248467704, + "auprc": 0.04833042178649417, + "brier": 0.0025128065617076017, + "calibration": { + "observed_rate": 0.002560351133869788, + "mean_prediction": 0.002290803194276488, + "calibration_in_the_large": -0.00026954793959330006, + "expected_calibration_error_10bin": 0.0003455962501096464, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 8, + "negatives": 2726, + "auroc": 0.7986977256052825, + "auprc": 0.06941114845079603, + "brier": 0.0028451958066154216, + "calibration": { + "observed_rate": 0.002926115581565472, + "mean_prediction": 0.002439791356538089, + "calibration_in_the_large": -0.0004863242250273828, + "expected_calibration_error_10bin": 0.0005657654765344811, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 8, + "negatives": 2726, + "auroc": 0.800027512839325, + "auprc": 0.06957620914838773, + "brier": 0.002843997965271514, + "calibration": { + "observed_rate": 0.002926115581565472, + "mean_prediction": 0.002581535258313362, + "calibration_in_the_large": -0.0003445803232521101, + "expected_calibration_error_10bin": 0.000427620690265557, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 10, + "negatives": 2724, + "auroc": 0.8372613803230543, + "auprc": 0.11158030580391291, + "brier": 0.003505511437091176, + "calibration": { + "observed_rate": 0.0036576444769568397, + "mean_prediction": 0.0027477154351496593, + "calibration_in_the_large": -0.0009099290418071804, + "expected_calibration_error_10bin": 0.000996423894768293, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 10, + "negatives": 2724, + "auroc": 0.8380690161527166, + "auprc": 0.1090786907397167, + "brier": 0.0035007102581959453, + "calibration": { + "observed_rate": 0.0036576444769568397, + "mean_prediction": 0.002875365846088624, + "calibration_in_the_large": -0.0007822786308682157, + "expected_calibration_error_10bin": 0.00102170587251416, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 10, + "negatives": 2724, + "auroc": 0.8388399412628488, + "auprc": 0.10995624499285213, + "brier": 0.003493585926450354, + "calibration": { + "observed_rate": 0.0036576444769568397, + "mean_prediction": 0.0030475412102788056, + "calibration_in_the_large": -0.0006101032666780341, + "expected_calibration_error_10bin": 0.0008657177421947768, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + { + "valid": 2734, + "positives": 10, + "negatives": 2724, + "auroc": 0.838913362701909, + "auprc": 0.10995669764508868, + "brier": 0.0034933066118359823, + "calibration": { + "observed_rate": 0.0036576444769568397, + "mean_prediction": 0.003056488432717402, + "calibration_in_the_large": -0.0006011560442394379, + "expected_calibration_error_10bin": 0.0008574964036077238, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + } + ], + "reason": null + }, + "I74": { + "time_averaged_auroc": 0.5965154283963622, + "time_averaged_auprc": 0.003696004038611096, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2821, + "positives": 2, + "negatives": 2819, + "auroc": 0.7726144022703086, + "auprc": 0.006392375639237564, + "brier": 0.0007084259690322508, + "calibration": { + "observed_rate": 0.0007089684509039348, + "mean_prediction": 0.00021701206534688924, + "calibration_in_the_large": -0.0004919563855570455, + "expected_calibration_error_10bin": 0.0004919563855570455, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 3, + "negatives": 2818, + "auroc": 0.6854743316773125, + "auprc": 0.0029754819169500444, + "brier": 0.0010627915037559337, + "calibration": { + "observed_rate": 0.0010634526763559022, + "mean_prediction": 0.0003990629839838965, + "calibration_in_the_large": -0.0006643896923720057, + "expected_calibration_error_10bin": 0.0006643896923720057, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 4, + "negatives": 2817, + "auroc": 0.5484558040468583, + "auprc": 0.003036785542057107, + "brier": 0.0014171595985770758, + "calibration": { + "observed_rate": 0.0014179369018078695, + "mean_prediction": 0.0005052152712941936, + "calibration_in_the_large": -0.0009127216305136759, + "expected_calibration_error_10bin": 0.0009127216305136759, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 4, + "negatives": 2817, + "auroc": 0.5457933972310969, + "auprc": 0.003089319518566047, + "brier": 0.0014171270095652494, + "calibration": { + "observed_rate": 0.0014179369018078695, + "mean_prediction": 0.0005397213958684351, + "calibration_in_the_large": -0.0008782155059394345, + "expected_calibration_error_10bin": 0.0008782155059394345, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 4, + "negatives": 2817, + "auroc": 0.5469471068512602, + "auprc": 0.0030713898919901323, + "brier": 0.0014171280085743495, + "calibration": { + "observed_rate": 0.0014179369018078695, + "mean_prediction": 0.0006024081387433143, + "calibration_in_the_large": -0.0008155287630645553, + "expected_calibration_error_10bin": 0.0008155287630645553, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 4, + "negatives": 2817, + "auroc": 0.5498757543485978, + "auprc": 0.0031318337729706776, + "brier": 0.0014170906745821605, + "calibration": { + "observed_rate": 0.0014179369018078695, + "mean_prediction": 0.0006258023723960944, + "calibration_in_the_large": -0.0007921345294117752, + "expected_calibration_error_10bin": 0.0007921345294117752, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 5, + "negatives": 2816, + "auroc": 0.5803267045454545, + "auprc": 0.0034125908755918226, + "brier": 0.0017712425758297423, + "calibration": { + "observed_rate": 0.001772421127259837, + "mean_prediction": 0.0007038848885185929, + "calibration_in_the_large": -0.001068536238741244, + "expected_calibration_error_10bin": 0.001068536238741244, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 5, + "negatives": 2816, + "auroc": 0.5753551136363636, + "auprc": 0.0034384917884819873, + "brier": 0.001771176669908409, + "calibration": { + "observed_rate": 0.001772421127259837, + "mean_prediction": 0.0007478915992747165, + "calibration_in_the_large": -0.0010245295279851204, + "expected_calibration_error_10bin": 0.0010245295279851204, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 5, + "negatives": 2816, + "auroc": 0.5840909090909091, + "auprc": 0.00377572689154801, + "brier": 0.0017710346900582793, + "calibration": { + "observed_rate": 0.001772421127259837, + "mean_prediction": 0.0008222431971539211, + "calibration_in_the_large": -0.0009501779301059159, + "expected_calibration_error_10bin": 0.0009501779301059159, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 5, + "negatives": 2816, + "auroc": 0.5866477272727273, + "auprc": 0.0038869186592101527, + "brier": 0.0017710131154186214, + "calibration": { + "observed_rate": 0.001772421127259837, + "mean_prediction": 0.0008928618679143121, + "calibration_in_the_large": -0.0008795592593455248, + "expected_calibration_error_10bin": 0.0008795592593455248, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 5, + "negatives": 2816, + "auroc": 0.5919744318181818, + "auprc": 0.003970996348006605, + "brier": 0.00177095359760074, + "calibration": { + "observed_rate": 0.001772421127259837, + "mean_prediction": 0.000984729905381205, + "calibration_in_the_large": -0.0007876912218786319, + "expected_calibration_error_10bin": 0.0007876912218786319, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 5, + "negatives": 2816, + "auroc": 0.5935369318181818, + "auprc": 0.003932407740101063, + "brier": 0.0017712150859546076, + "calibration": { + "observed_rate": 0.001772421127259837, + "mean_prediction": 0.00106836148484543, + "calibration_in_the_large": -0.000704059642414407, + "expected_calibration_error_10bin": 0.000704059642414407, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 5, + "negatives": 2816, + "auroc": 0.5936079545454546, + "auprc": 0.003933733917233029, + "brier": 0.0017712341045527347, + "calibration": { + "observed_rate": 0.001772421127259837, + "mean_prediction": 0.001073345406437073, + "calibration_in_the_large": -0.0006990757208227638, + "expected_calibration_error_10bin": 0.0006990757208227638, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + } + ], + "reason": null + }, + "I77": { + "time_averaged_auroc": 0.6989594951379741, + "time_averaged_auprc": 0.006663307780220914, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2785, + "positives": 2, + "negatives": 2783, + "auroc": 0.7080488681279196, + "auprc": 0.00269630597485358, + "brier": 0.0007177358766566988, + "calibration": { + "observed_rate": 0.000718132854578097, + "mean_prediction": 0.0004323310653244971, + "calibration_in_the_large": -0.0002858017892535999, + "expected_calibration_error_10bin": 0.0002858017892535999, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 3, + "negatives": 2782, + "auroc": 0.633477114785526, + "auprc": 0.0028935420796598146, + "brier": 0.0010770016988850208, + "calibration": { + "observed_rate": 0.0010771992818671453, + "mean_prediction": 0.0008429097630585902, + "calibration_in_the_large": -0.00023428951880855508, + "expected_calibration_error_10bin": 0.00023428951880855508, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 3, + "negatives": 2782, + "auroc": 0.6519290678169183, + "auprc": 0.003919883999883148, + "brier": 0.0010775415278532193, + "calibration": { + "observed_rate": 0.0010771992818671453, + "mean_prediction": 0.0011434769765430535, + "calibration_in_the_large": 6.627769467590816e-05, + "expected_calibration_error_10bin": 6.627769467590816e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 3, + "negatives": 2782, + "auroc": 0.6506110711718188, + "auprc": 0.004447328097298134, + "brier": 0.001078691241716167, + "calibration": { + "observed_rate": 0.0010771992818671453, + "mean_prediction": 0.0014235096124682828, + "calibration_in_the_large": 0.00034631033060113746, + "expected_calibration_error_10bin": 0.00034631033060113746, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.7155699388709097, + "auprc": 0.006112821476764386, + "brier": 0.0014355375373278619, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.001559311523855893, + "calibration_in_the_large": 0.000123045814699699, + "expected_calibration_error_10bin": 0.000123045814699699, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.7163790003595829, + "auprc": 0.006295783515780854, + "brier": 0.001436697075250459, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.0017879070225856233, + "calibration_in_the_large": 0.0003516413134294293, + "expected_calibration_error_10bin": 0.0003516413134294293, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.7180870190578929, + "auprc": 0.006746563407811952, + "brier": 0.0014373307837648982, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.0019369655372984574, + "calibration_in_the_large": 0.0005006998281422634, + "expected_calibration_error_10bin": 0.0005006998281422634, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.7165647115269281, + "auprc": 0.008783970941914174, + "brier": 0.0021498874326882117, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.0020314754312967713, + "calibration_in_the_large": -0.00012292313243751933, + "expected_calibration_error_10bin": 0.00012292313243751933, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.7147655031786014, + "auprc": 0.008922482194424819, + "brier": 0.002150710665761352, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.002163620815068233, + "calibration_in_the_large": 9.22225133394251e-06, + "expected_calibration_error_10bin": 9.22225133394251e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.715005397625045, + "auprc": 0.008703428030520351, + "brier": 0.002151858314386399, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.0023143841375373605, + "calibration_in_the_large": 0.0001599855738030698, + "expected_calibration_error_10bin": 0.0001599855738030698, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.7152452920714886, + "auprc": 0.009018879410460248, + "brier": 0.0021526811763350213, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.002443284970553319, + "calibration_in_the_large": 0.00028888640681902847, + "expected_calibration_error_10bin": 0.00028888640681902847, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.7154252129063212, + "auprc": 0.009041231979517781, + "brier": 0.0021529849055507626, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.0025331417953154936, + "calibration_in_the_large": 0.00037874323158120296, + "expected_calibration_error_10bin": 0.00037874323158120296, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.7153652392947103, + "auprc": 0.009040780033982643, + "brier": 0.002153009037582867, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.0025368732854326196, + "calibration_in_the_large": 0.00038247472169832897, + "expected_calibration_error_10bin": 0.00038247472169832897, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + } + ], + "reason": null + }, + "I80": { + "time_averaged_auroc": 0.8722312445989953, + "time_averaged_auprc": 0.0637982833549329, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2827, + "positives": 2, + "negatives": 2825, + "auroc": 0.8210619469026549, + "auprc": 0.003389500129948887, + "brier": 0.000708133039942745, + "calibration": { + "observed_rate": 0.0007074637424831977, + "mean_prediction": 0.00026784584265566254, + "calibration_in_the_large": -0.0004396178998275352, + "expected_calibration_error_10bin": 0.0004396178998275352, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 2, + "negatives": 2825, + "auroc": 0.8191150442477876, + "auprc": 0.0032535151170351106, + "brier": 0.000709024372515875, + "calibration": { + "observed_rate": 0.0007074637424831977, + "mean_prediction": 0.00047655875771092577, + "calibration_in_the_large": -0.00023090498477227196, + "expected_calibration_error_10bin": 0.00023090498477227196, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 2, + "negatives": 2825, + "auroc": 0.8207079646017699, + "auprc": 0.0034782121653411, + "brier": 0.0007110644105469841, + "calibration": { + "observed_rate": 0.0007074637424831977, + "mean_prediction": 0.0006057843863069269, + "calibration_in_the_large": -0.0001016793561762708, + "expected_calibration_error_10bin": 0.0001016793561762708, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 4, + "negatives": 2823, + "auroc": 0.8844314558979809, + "auprc": 0.08937766507315904, + "brier": 0.0013904054541916766, + "calibration": { + "observed_rate": 0.0014149274849663955, + "mean_prediction": 0.0008147075568127547, + "calibration_in_the_large": -0.0006002199281536408, + "expected_calibration_error_10bin": 0.0006002199281536408, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 4, + "negatives": 2823, + "auroc": 0.889656393907191, + "auprc": 0.08946448624830129, + "brier": 0.0013876542027213854, + "calibration": { + "observed_rate": 0.0014149274849663955, + "mean_prediction": 0.000935697279620281, + "calibration_in_the_large": -0.00047923020534611444, + "expected_calibration_error_10bin": 0.00047923020534611444, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 4, + "negatives": 2823, + "auroc": 0.887708111937655, + "auprc": 0.08952491614610081, + "brier": 0.0013874026660502215, + "calibration": { + "observed_rate": 0.0014149274849663955, + "mean_prediction": 0.0010720720040518507, + "calibration_in_the_large": -0.0003428554809145447, + "expected_calibration_error_10bin": 0.0003428554809145447, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 4, + "negatives": 2823, + "auroc": 0.8905419766206164, + "auprc": 0.08953399586156613, + "brier": 0.0013872217746619209, + "calibration": { + "observed_rate": 0.0014149274849663955, + "mean_prediction": 0.0011373964713209466, + "calibration_in_the_large": -0.00027753101364544884, + "expected_calibration_error_10bin": 0.00027753101364544884, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 4, + "negatives": 2823, + "auroc": 0.8895678356358484, + "auprc": 0.08963505137746479, + "brier": 0.0013851460009365124, + "calibration": { + "observed_rate": 0.0014149274849663955, + "mean_prediction": 0.0012516616380380814, + "calibration_in_the_large": -0.00016326584692831405, + "expected_calibration_error_10bin": 0.00024251774389650395, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 5, + "negatives": 2822, + "auroc": 0.8875265768958186, + "auprc": 0.07427414448661171, + "brier": 0.001737229545113088, + "calibration": { + "observed_rate": 0.0017686593562079944, + "mean_prediction": 0.0013811962489506159, + "calibration_in_the_large": -0.00038746310725737854, + "expected_calibration_error_10bin": 0.0004781644355612792, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 5, + "negatives": 2822, + "auroc": 0.8874557051736357, + "auprc": 0.07428065160586249, + "brier": 0.0017373199578752455, + "calibration": { + "observed_rate": 0.0017686593562079944, + "mean_prediction": 0.0014079729755048986, + "calibration_in_the_large": -0.0003606863807030958, + "expected_calibration_error_10bin": 0.000453147015894747, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 5, + "negatives": 2822, + "auroc": 0.8865343727852587, + "auprc": 0.07431279448599845, + "brier": 0.0017377183214661615, + "calibration": { + "observed_rate": 0.0017686593562079944, + "mean_prediction": 0.0014806119331943915, + "calibration_in_the_large": -0.0002880474230136029, + "expected_calibration_error_10bin": 0.00038435771284655565, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 5, + "negatives": 2822, + "auroc": 0.8873848334514529, + "auprc": 0.0744297485947111, + "brier": 0.0017368316406146662, + "calibration": { + "observed_rate": 0.0017686593562079944, + "mean_prediction": 0.001585566027487215, + "calibration_in_the_large": -0.0001830933287207794, + "expected_calibration_error_10bin": 0.00028945737455715056, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 5, + "negatives": 2822, + "auroc": 0.88731396172927, + "auprc": 0.07442300232202675, + "brier": 0.0017368714599444116, + "calibration": { + "observed_rate": 0.0017686593562079944, + "mean_prediction": 0.0015915169134947066, + "calibration_in_the_large": -0.00017714244271328783, + "expected_calibration_error_10bin": 0.00028387445815098296, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + } + ], + "reason": null + }, + "I81": { + "time_averaged_auroc": 0.8076673096005658, + "time_averaged_auprc": 0.019865576090242372, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2826, + "positives": 4, + "negatives": 2822, + "auroc": 0.8152019844082211, + "auprc": 0.01389447853711575, + "brier": 0.0014127975906011389, + "calibration": { + "observed_rate": 0.0014154281670205238, + "mean_prediction": 0.0004858501672987041, + "calibration_in_the_large": -0.0009295779997218197, + "expected_calibration_error_10bin": 0.0009295779997218197, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8417582417582418, + "auprc": 0.01584256031760872, + "brier": 0.0017758050788682655, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0009256142958665915, + "calibration_in_the_large": -0.000843670912909063, + "expected_calibration_error_10bin": 0.0009437287196786481, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.833888691953208, + "auprc": 0.014251118610517921, + "brier": 0.001793993212687795, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0012608882598699488, + "calibration_in_the_large": -0.0005083969489057057, + "expected_calibration_error_10bin": 0.0007984459634831464, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8328961361219426, + "auprc": 0.014227364041754967, + "brier": 0.0018026584077234676, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.001393446456282838, + "calibration_in_the_large": -0.0003758387524928166, + "expected_calibration_error_10bin": 0.0007769261899585086, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 6, + "negatives": 2820, + "auroc": 0.8490543735224586, + "auprc": 0.015546110781377654, + "brier": 0.002170505611954952, + "calibration": { + "observed_rate": 0.0021231422505307855, + "mean_prediction": 0.0016642971378594148, + "calibration_in_the_large": -0.00045884511267137076, + "expected_calibration_error_10bin": 0.0009216756328200292, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 6, + "negatives": 2820, + "auroc": 0.8469858156028369, + "auprc": 0.015494824018017106, + "brier": 0.0021964312927838948, + "calibration": { + "observed_rate": 0.0021231422505307855, + "mean_prediction": 0.0019153767893009945, + "calibration_in_the_large": -0.00020776546122979107, + "expected_calibration_error_10bin": 0.0007553682550340219, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 7, + "negatives": 2819, + "auroc": 0.8664673389753206, + "auprc": 0.02494945478001397, + "brier": 0.0025372476747551106, + "calibration": { + "observed_rate": 0.0024769992922859165, + "mean_prediction": 0.0020820008045701215, + "calibration_in_the_large": -0.00039499848771579497, + "expected_calibration_error_10bin": 0.0009962271227383897, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 8, + "negatives": 2818, + "auroc": 0.7624201561391057, + "auprc": 0.021414803452554455, + "brier": 0.0029091611293486546, + "calibration": { + "observed_rate": 0.0028308563340410475, + "mean_prediction": 0.0022342710487837183, + "calibration_in_the_large": -0.0005965852852573292, + "expected_calibration_error_10bin": 0.0013251220120310847, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 8, + "negatives": 2818, + "auroc": 0.7616217175301633, + "auprc": 0.02063410226661368, + "brier": 0.0029268377404096796, + "calibration": { + "observed_rate": 0.0028308563340410475, + "mean_prediction": 0.002398246120966871, + "calibration_in_the_large": -0.0004326102130741763, + "expected_calibration_error_10bin": 0.0013536713661502643, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 8, + "negatives": 2818, + "auroc": 0.7605571327182399, + "auprc": 0.020606903465845317, + "brier": 0.0029392732738220927, + "calibration": { + "observed_rate": 0.0028308563340410475, + "mean_prediction": 0.0024878134021490573, + "calibration_in_the_large": -0.0003430429318919902, + "expected_calibration_error_10bin": 0.0012991118954848, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 8, + "negatives": 2818, + "auroc": 0.7599361249112846, + "auprc": 0.020585974220867036, + "brier": 0.0029562752653467406, + "calibration": { + "observed_rate": 0.0028308563340410475, + "mean_prediction": 0.002598608684671317, + "calibration_in_the_large": -0.0002322476493697304, + "expected_calibration_error_10bin": 0.0013795771719156604, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 9, + "negatives": 2817, + "auroc": 0.7844436555831658, + "auprc": 0.03042115087777589, + "brier": 0.0032759131693487972, + "calibration": { + "observed_rate": 0.0031847133757961785, + "mean_prediction": 0.0026848756647400553, + "calibration_in_the_large": -0.0004998377110561232, + "expected_calibration_error_10bin": 0.0018912434503628515, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 9, + "negatives": 2817, + "auroc": 0.7844436555831658, + "auprc": 0.030383643803088414, + "brier": 0.003276790091765058, + "calibration": { + "observed_rate": 0.0031847133757961785, + "mean_prediction": 0.0026959404165419923, + "calibration_in_the_large": -0.0004887729592541862, + "expected_calibration_error_10bin": 0.0018837705269729727, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + } + ], + "reason": null + }, + "I82": { + "time_averaged_auroc": 0.7101544124399589, + "time_averaged_auprc": 0.03343774701435079, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2739, + "positives": 6, + "negatives": 2733, + "auroc": 0.6666666666666666, + "auprc": 0.014161721695405092, + "brier": 0.002183161295911753, + "calibration": { + "observed_rate": 0.002190580503833516, + "mean_prediction": 0.002201432176802701, + "calibration_in_the_large": 1.0851672969185242e-05, + "expected_calibration_error_10bin": 1.0851672969185242e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 13, + "negatives": 2726, + "auroc": 0.6318076640893956, + "auprc": 0.012867092498719777, + "brier": 0.004741919814594892, + "calibration": { + "observed_rate": 0.004746257758305951, + "mean_prediction": 0.004563584656975028, + "calibration_in_the_large": -0.0001826731013309232, + "expected_calibration_error_10bin": 0.0001826731013309232, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 18, + "negatives": 2721, + "auroc": 0.695353015639675, + "auprc": 0.0238204625209752, + "brier": 0.006522003310911197, + "calibration": { + "observed_rate": 0.0065717415115005475, + "mean_prediction": 0.0058996893355771265, + "calibration_in_the_large": -0.000672052175923421, + "expected_calibration_error_10bin": 0.0011018168977774787, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 20, + "negatives": 2719, + "auroc": 0.6945384332475175, + "auprc": 0.026693749522900417, + "brier": 0.0072674044945979475, + "calibration": { + "observed_rate": 0.007301935012778387, + "mean_prediction": 0.007090782937393569, + "calibration_in_the_large": -0.00021115207538481735, + "expected_calibration_error_10bin": 0.000768139141338631, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 22, + "negatives": 2717, + "auroc": 0.6963562753036437, + "auprc": 0.028467083273206326, + "brier": 0.008011677945486871, + "calibration": { + "observed_rate": 0.008032128514056224, + "mean_prediction": 0.00805867951623634, + "calibration_in_the_large": 2.655100218011512e-05, + "expected_calibration_error_10bin": 0.001050723316064406, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 23, + "negatives": 2716, + "auroc": 0.7043766408401101, + "auprc": 0.029126747065806303, + "brier": 0.00838704308250095, + "calibration": { + "observed_rate": 0.008397225264695144, + "mean_prediction": 0.008655766312775846, + "calibration_in_the_large": 0.0002585410480807019, + "expected_calibration_error_10bin": 0.0014359052067578091, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 26, + "negatives": 2713, + "auroc": 0.7090220873855227, + "auprc": 0.029900263819503815, + "brier": 0.009476302654247093, + "calibration": { + "observed_rate": 0.009492515516611903, + "mean_prediction": 0.009134285454148457, + "calibration_in_the_large": -0.0003582300624634452, + "expected_calibration_error_10bin": 0.0022845930774729236, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 28, + "negatives": 2711, + "auroc": 0.727881119249618, + "auprc": 0.03662279000119844, + "brier": 0.010137338080948797, + "calibration": { + "observed_rate": 0.01022270901788974, + "mean_prediction": 0.009773492749398571, + "calibration_in_the_large": -0.0004492162684911691, + "expected_calibration_error_10bin": 0.0029548260239393265, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 32, + "negatives": 2707, + "auroc": 0.7339882711488733, + "auprc": 0.03921397343574224, + "brier": 0.011572204615713537, + "calibration": { + "observed_rate": 0.011683096020445418, + "mean_prediction": 0.010524856828405345, + "calibration_in_the_large": -0.0011582391920400732, + "expected_calibration_error_10bin": 0.002892938934509429, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 32, + "negatives": 2707, + "auroc": 0.7337458441078685, + "auprc": 0.039298446576952466, + "brier": 0.011608199082631047, + "calibration": { + "observed_rate": 0.011683096020445418, + "mean_prediction": 0.011146424289619535, + "calibration_in_the_large": -0.0005366717308258832, + "expected_calibration_error_10bin": 0.0028649126272810082, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 35, + "negatives": 2704, + "auroc": 0.7460059171597633, + "auprc": 0.05162141451669939, + "brier": 0.01254233738351754, + "calibration": { + "observed_rate": 0.012778386272362175, + "mean_prediction": 0.011662062894104201, + "calibration_in_the_large": -0.0011163233782579742, + "expected_calibration_error_10bin": 0.0024890045397875, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 35, + "negatives": 2704, + "auroc": 0.7461010143702451, + "auprc": 0.05133212043249687, + "brier": 0.012562483727025087, + "calibration": { + "observed_rate": 0.012778386272362175, + "mean_prediction": 0.012074473265077094, + "calibration_in_the_large": -0.000703913007285081, + "expected_calibration_error_10bin": 0.0024747338499743815, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + { + "valid": 2739, + "positives": 35, + "negatives": 2704, + "auroc": 0.7461644125105663, + "auprc": 0.051564845826953996, + "brier": 0.012566560294860725, + "calibration": { + "observed_rate": 0.012778386272362175, + "mean_prediction": 0.012205258748976835, + "calibration_in_the_large": -0.0005731275233853399, + "expected_calibration_error_10bin": 0.002472551785047411, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + } + ], + "reason": null + }, + "I85": { + "time_averaged_auroc": 0.990547376702555, + "time_averaged_auprc": 0.18025571624951847, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2793, + "positives": 1, + "negatives": 2792, + "auroc": 0.9799426934097422, + "auprc": 0.017543859649122806, + "brier": 0.0004002239454427516, + "calibration": { + "observed_rate": 0.00035803795202291446, + "mean_prediction": 0.0005356639829542629, + "calibration_in_the_large": 0.00017762603093134848, + "expected_calibration_error_10bin": 0.00022689099033492089, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 2, + "negatives": 2791, + "auroc": 0.9874596918667145, + "auprc": 0.06587301587301587, + "brier": 0.0007895968771241309, + "calibration": { + "observed_rate": 0.0007160759040458289, + "mean_prediction": 0.0009345053570344405, + "calibration_in_the_large": 0.0002184294529886116, + "expected_calibration_error_10bin": 0.0009684159609917595, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 4, + "negatives": 2789, + "auroc": 0.9932771602724991, + "auprc": 0.16414141414141414, + "brier": 0.0013881438599294268, + "calibration": { + "observed_rate": 0.0014321518080916578, + "mean_prediction": 0.0011138465249485004, + "calibration_in_the_large": -0.0003183052831431574, + "expected_calibration_error_10bin": 0.0010147246082331499, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 4, + "negatives": 2789, + "auroc": 0.9931875224094657, + "auprc": 0.1638167388167388, + "brier": 0.0014181689372041587, + "calibration": { + "observed_rate": 0.0014321518080916578, + "mean_prediction": 0.0013087376664016343, + "calibration_in_the_large": -0.0001234141416900235, + "expected_calibration_error_10bin": 0.001523975069761476, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 4, + "negatives": 2789, + "auroc": 0.9931875224094657, + "auprc": 0.1638167388167388, + "brier": 0.001439580398083525, + "calibration": { + "observed_rate": 0.0014321518080916578, + "mean_prediction": 0.0014811482823725859, + "calibration_in_the_large": 4.899647428092805e-05, + "expected_calibration_error_10bin": 0.0016267682075601444, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 7, + "negatives": 2786, + "auroc": 0.9913854989231874, + "auprc": 0.20534702053689394, + "brier": 0.002336766659098227, + "calibration": { + "observed_rate": 0.002506265664160401, + "mean_prediction": 0.001594685379156085, + "calibration_in_the_large": -0.0009115802850043159, + "expected_calibration_error_10bin": 0.002008811534723096, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 8, + "negatives": 2785, + "auroc": 0.9904398563734291, + "auprc": 0.2074648730898731, + "brier": 0.0026922953131832458, + "calibration": { + "observed_rate": 0.0028643036161833156, + "mean_prediction": 0.001711258644654829, + "calibration_in_the_large": -0.0011530449715284866, + "expected_calibration_error_10bin": 0.002352362129245166, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 9, + "negatives": 2784, + "auroc": 0.9911797573435505, + "auprc": 0.2240497944703311, + "brier": 0.003023909788959703, + "calibration": { + "observed_rate": 0.00322234156820623, + "mean_prediction": 0.0018408555151392806, + "calibration_in_the_large": -0.0013814860530669494, + "expected_calibration_error_10bin": 0.0031849425736146216, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 9, + "negatives": 2784, + "auroc": 0.9912994891443168, + "auprc": 0.2261317429556033, + "brier": 0.0030490687229154084, + "calibration": { + "observed_rate": 0.00322234156820623, + "mean_prediction": 0.002006461324343259, + "calibration_in_the_large": -0.001215880243862971, + "expected_calibration_error_10bin": 0.0023516947453484436, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 9, + "negatives": 2784, + "auroc": 0.9912994891443168, + "auprc": 0.2255604918602432, + "brier": 0.003049804928259563, + "calibration": { + "observed_rate": 0.00322234156820623, + "mean_prediction": 0.0020654738168263236, + "calibration_in_the_large": -0.0011568677513799064, + "expected_calibration_error_10bin": 0.002310187644065165, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 9, + "negatives": 2784, + "auroc": 0.9912196679438059, + "auprc": 0.2250916808923345, + "brier": 0.0030585108799289803, + "calibration": { + "observed_rate": 0.00322234156820623, + "mean_prediction": 0.002136961475657753, + "calibration_in_the_large": -0.001085380092548477, + "expected_calibration_error_10bin": 0.0022832452486805255, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 9, + "negatives": 2784, + "auroc": 0.9916187739463601, + "auprc": 0.22724347007071513, + "brier": 0.003047785363107579, + "calibration": { + "observed_rate": 0.00322234156820623, + "mean_prediction": 0.0023189804430983267, + "calibration_in_the_large": -0.0009033611251079033, + "expected_calibration_error_10bin": 0.002196263294436232, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 9, + "negatives": 2784, + "auroc": 0.9916187739463601, + "auprc": 0.22724347007071513, + "brier": 0.0030478511790546165, + "calibration": { + "observed_rate": 0.00322234156820623, + "mean_prediction": 0.002321324909488665, + "calibration_in_the_large": -0.000901016658717565, + "expected_calibration_error_10bin": 0.002194510243556334, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + } + ], + "reason": null + }, + "I87": { + "time_averaged_auroc": 0.7446920822262603, + "time_averaged_auprc": 0.012804912011011433, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2780, + "positives": 4, + "negatives": 2776, + "auroc": 0.8870677233429395, + "auprc": 0.00785725254577881, + "brier": 0.0014344535002786861, + "calibration": { + "observed_rate": 0.0014388489208633094, + "mean_prediction": 0.0010292978841403547, + "calibration_in_the_large": -0.0004095510367229547, + "expected_calibration_error_10bin": 0.0004095510367229547, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 7, + "negatives": 2773, + "auroc": 0.7586935242903509, + "auprc": 0.006735993524110663, + "brier": 0.0025122753552136406, + "calibration": { + "observed_rate": 0.002517985611510791, + "mean_prediction": 0.0017990648179319114, + "calibration_in_the_large": -0.0007189207935788798, + "expected_calibration_error_10bin": 0.0007189207935788798, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 10, + "negatives": 2770, + "auroc": 0.7163898916967509, + "auprc": 0.010021574499978711, + "brier": 0.003585023346032475, + "calibration": { + "observed_rate": 0.0035971223021582736, + "mean_prediction": 0.002606444574318872, + "calibration_in_the_large": -0.0009906777278394017, + "expected_calibration_error_10bin": 0.0009906777278394017, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 11, + "negatives": 2769, + "auroc": 0.722183919367018, + "auprc": 0.010559629870039416, + "brier": 0.003945569951530942, + "calibration": { + "observed_rate": 0.003956834532374101, + "mean_prediction": 0.003180192808783739, + "calibration_in_the_large": -0.0007766417235903619, + "expected_calibration_error_10bin": 0.0007766417235903619, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 11, + "negatives": 2769, + "auroc": 0.7239567943793296, + "auprc": 0.010722656735612991, + "brier": 0.003952246767011924, + "calibration": { + "observed_rate": 0.003956834532374101, + "mean_prediction": 0.003740446416565038, + "calibration_in_the_large": -0.00021638811580906294, + "expected_calibration_error_10bin": 0.00021638811580906294, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 11, + "negatives": 2769, + "auroc": 0.7194589448110574, + "auprc": 0.010417572044431582, + "brier": 0.003958370004113057, + "calibration": { + "observed_rate": 0.003956834532374101, + "mean_prediction": 0.004070783106436079, + "calibration_in_the_large": 0.00011394857406197851, + "expected_calibration_error_10bin": 0.00011394857406197851, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 12, + "negatives": 2768, + "auroc": 0.725674373795761, + "auprc": 0.010802584670906404, + "brier": 0.004328092835128613, + "calibration": { + "observed_rate": 0.004316546762589928, + "mean_prediction": 0.00460050165334814, + "calibration_in_the_large": 0.0002839548907582123, + "expected_calibration_error_10bin": 0.00028395489075821204, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 12, + "negatives": 2768, + "auroc": 0.724349710982659, + "auprc": 0.010926823694938997, + "brier": 0.0043378608359116895, + "calibration": { + "observed_rate": 0.004316546762589928, + "mean_prediction": 0.005008721764591709, + "calibration_in_the_large": 0.0006921750020017813, + "expected_calibration_error_10bin": 0.0006921750020017813, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 12, + "negatives": 2768, + "auroc": 0.7221218689788054, + "auprc": 0.010771520664538535, + "brier": 0.004347405289183813, + "calibration": { + "observed_rate": 0.004316546762589928, + "mean_prediction": 0.005342192514560319, + "calibration_in_the_large": 0.0010256457519703908, + "expected_calibration_error_10bin": 0.0010256457519703908, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 13, + "negatives": 2767, + "auroc": 0.7424592032470602, + "auprc": 0.020059886488986187, + "brier": 0.004669867836515801, + "calibration": { + "observed_rate": 0.004676258992805755, + "mean_prediction": 0.005638248764533129, + "calibration_in_the_large": 0.0009619897717273737, + "expected_calibration_error_10bin": 0.0009619897717273737, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 13, + "negatives": 2767, + "auroc": 0.7427372049706709, + "auprc": 0.01915921009127383, + "brier": 0.004681868053078438, + "calibration": { + "observed_rate": 0.004676258992805755, + "mean_prediction": 0.006032789006940547, + "calibration_in_the_large": 0.0013565300141347922, + "expected_calibration_error_10bin": 0.0013565300141347913, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 13, + "negatives": 2767, + "auroc": 0.7418753996274777, + "auprc": 0.01873975704927164, + "brier": 0.004694385072927051, + "calibration": { + "observed_rate": 0.004676258992805755, + "mean_prediction": 0.006383956109048805, + "calibration_in_the_large": 0.0017076971162430501, + "expected_calibration_error_10bin": 0.00170769711624305, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + { + "valid": 2780, + "positives": 14, + "negatives": 2766, + "auroc": 0.7540285094515029, + "auprc": 0.019689394263280872, + "brier": 0.0050432310048982125, + "calibration": { + "observed_rate": 0.005035971223021582, + "mean_prediction": 0.00646043668245426, + "calibration_in_the_large": 0.0014244654594326774, + "expected_calibration_error_10bin": 0.0014244654594326774, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + } + ], + "reason": null + }, + "I89": { + "time_averaged_auroc": 0.8442198514480197, + "time_averaged_auprc": 0.010673479781514785, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2826, + "positives": 1, + "negatives": 2825, + "auroc": 0.9097345132743363, + "auprc": 0.00390625, + "brier": 0.00035367117325577085, + "calibration": { + "observed_rate": 0.00035385704175513094, + "mean_prediction": 0.00015009281984961303, + "calibration_in_the_large": -0.0002037642219055179, + "expected_calibration_error_10bin": 0.0002037642219055179, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 3, + "negatives": 2823, + "auroc": 0.8193411264612115, + "auprc": 0.008023390546320862, + "brier": 0.0010600521915389285, + "calibration": { + "observed_rate": 0.0010615711252653928, + "mean_prediction": 0.00028101651920836725, + "calibration_in_the_large": -0.0007805546060570255, + "expected_calibration_error_10bin": 0.0007805546060570255, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 4, + "negatives": 2822, + "auroc": 0.8247696669029058, + "auprc": 0.007681802502971984, + "brier": 0.0014132715892377892, + "calibration": { + "observed_rate": 0.0014154281670205238, + "mean_prediction": 0.0003565868217499205, + "calibration_in_the_large": -0.0010588413452706034, + "expected_calibration_error_10bin": 0.0010588413452706034, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 4, + "negatives": 2822, + "auroc": 0.8229978738483346, + "auprc": 0.007437508683444479, + "brier": 0.0014130706928639602, + "calibration": { + "observed_rate": 0.0014154281670205238, + "mean_prediction": 0.00042488408557695247, + "calibration_in_the_large": -0.0009905440814435714, + "expected_calibration_error_10bin": 0.0009905440814435714, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8548032612548742, + "auprc": 0.013245826101434077, + "brier": 0.0017641020379076367, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0004993973515448531, + "calibration_in_the_large": -0.0012698878572308015, + "expected_calibration_error_10bin": 0.0012698878572308015, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8501240694789082, + "auprc": 0.012847455872070668, + "brier": 0.001763558635255779, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0005829852618461413, + "calibration_in_the_large": -0.0011862999469295131, + "expected_calibration_error_10bin": 0.0011862999469295131, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8470046082949308, + "auprc": 0.012516279669533392, + "brier": 0.001763334788533019, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0006402802820377792, + "calibration_in_the_large": -0.0011290049267378753, + "expected_calibration_error_10bin": 0.0011290049267378753, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8447359092520382, + "auprc": 0.012429039205438471, + "brier": 0.0017633034939404494, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0006693374544868637, + "calibration_in_the_large": -0.0010999477542887907, + "expected_calibration_error_10bin": 0.0010999477542887907, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.842538107054236, + "auprc": 0.012255332934440418, + "brier": 0.0017632367235675048, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0007138008131604199, + "calibration_in_the_large": -0.0010554843956152348, + "expected_calibration_error_10bin": 0.0010554843956152348, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8416873449131513, + "auprc": 0.01220872877122877, + "brier": 0.0017631563445240418, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0007437053506092632, + "calibration_in_the_large": -0.0010255798581663912, + "expected_calibration_error_10bin": 0.0010255798581663912, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8400567174760724, + "auprc": 0.01215040661722875, + "brier": 0.0017629470589529013, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0007962971928295962, + "calibration_in_the_large": -0.0009729880159460583, + "expected_calibration_error_10bin": 0.0009729880159460583, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.838567883729174, + "auprc": 0.012026849421898722, + "brier": 0.001762840647958712, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0008595546796622119, + "calibration_in_the_large": -0.0009097305291134426, + "expected_calibration_error_10bin": 0.0009097305291134426, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8384969868840837, + "auprc": 0.012026366833681596, + "brier": 0.0017628431172594498, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.000861342228195012, + "calibration_in_the_large": -0.0009079429805806425, + "expected_calibration_error_10bin": 0.0009079429805806425, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + } + ], + "reason": null + }, + "I95": { + "time_averaged_auroc": 0.7362389397263495, + "time_averaged_auprc": 0.06674335297982999, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2485, + "positives": 19, + "negatives": 2466, + "auroc": 0.7142826653007214, + "auprc": 0.019482177942996587, + "brier": 0.007571922367072781, + "calibration": { + "observed_rate": 0.007645875251509054, + "mean_prediction": 0.009300192276491846, + "calibration_in_the_large": 0.0016543170249827916, + "expected_calibration_error_10bin": 0.0016543170249827916, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + { + "valid": 2485, + "positives": 33, + "negatives": 2452, + "auroc": 0.7332913144495526, + "auprc": 0.030144563266190517, + "brier": 0.01304269930300032, + "calibration": { + "observed_rate": 0.013279678068410463, + "mean_prediction": 0.015006125316265558, + "calibration_in_the_large": 0.0017264472478550948, + "expected_calibration_error_10bin": 0.0017264472478550968, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + { + "valid": 2485, + "positives": 41, + "negatives": 2444, + "auroc": 0.707037643207856, + "auprc": 0.033058786426090586, + "brier": 0.01623301974174861, + "calibration": { + "observed_rate": 0.016498993963782696, + "mean_prediction": 0.019215517329455915, + "calibration_in_the_large": 0.0027165233656732193, + "expected_calibration_error_10bin": 0.002716523365673219, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + { + "valid": 2485, + "positives": 52, + "negatives": 2433, + "auroc": 0.7155774763666256, + "auprc": 0.04578349360518612, + "brier": 0.02036860822787765, + "calibration": { + "observed_rate": 0.020925553319919517, + "mean_prediction": 0.022242206085676616, + "calibration_in_the_large": 0.0013166527657570981, + "expected_calibration_error_10bin": 0.0013166527657570994, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + { + "valid": 2485, + "positives": 58, + "negatives": 2427, + "auroc": 0.7157694329596636, + "auprc": 0.04974202635189756, + "brier": 0.02267509213123756, + "calibration": { + "observed_rate": 0.023340040241448694, + "mean_prediction": 0.024646177920709614, + "calibration_in_the_large": 0.0013061376792609207, + "expected_calibration_error_10bin": 0.002284372737537508, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + { + "valid": 2485, + "positives": 66, + "negatives": 2419, + "auroc": 0.7293710148195472, + "auprc": 0.057788173429150144, + "brier": 0.02565291322039268, + "calibration": { + "observed_rate": 0.026559356136820925, + "mean_prediction": 0.027304377971110225, + "calibration_in_the_large": 0.0007450218342892993, + "expected_calibration_error_10bin": 0.004424799185094444, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + { + "valid": 2485, + "positives": 77, + "negatives": 2408, + "auroc": 0.743101997670104, + "auprc": 0.07421684690583036, + "brier": 0.02951059665065825, + "calibration": { + "observed_rate": 0.030985915492957747, + "mean_prediction": 0.029559115897180133, + "calibration_in_the_large": -0.0014267995957776142, + "expected_calibration_error_10bin": 0.007470443656328896, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + { + "valid": 2485, + "positives": 82, + "negatives": 2403, + "auroc": 0.7509921541162977, + "auprc": 0.08120551953458216, + "brier": 0.03126072742092773, + "calibration": { + "observed_rate": 0.03299798792756539, + "mean_prediction": 0.03123153258200315, + "calibration_in_the_large": -0.0017664553455622421, + "expected_calibration_error_10bin": 0.007419889815708238, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + { + "valid": 2485, + "positives": 87, + "negatives": 2398, + "auroc": 0.7495949689875663, + "auprc": 0.08506287445950403, + "brier": 0.03306435442245387, + "calibration": { + "observed_rate": 0.03501006036217304, + "mean_prediction": 0.03275672694386154, + "calibration_in_the_large": -0.0022533334183114997, + "expected_calibration_error_10bin": 0.008956793095153834, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + { + "valid": 2485, + "positives": 93, + "negatives": 2392, + "auroc": 0.7532455856439026, + "auprc": 0.09199588240873419, + "brier": 0.035155916842679234, + "calibration": { + "observed_rate": 0.03742454728370221, + "mean_prediction": 0.033977597314954346, + "calibration_in_the_large": -0.0034469499687478644, + "expected_calibration_error_10bin": 0.009576357941384943, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + { + "valid": 2485, + "positives": 97, + "negatives": 2388, + "auroc": 0.7533069125697215, + "auprc": 0.09446790167179188, + "brier": 0.03660883831447198, + "calibration": { + "observed_rate": 0.03903420523138833, + "mean_prediction": 0.035445237676078975, + "calibration_in_the_large": -0.0035889675553093525, + "expected_calibration_error_10bin": 0.009664737601938773, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + { + "valid": 2485, + "positives": 103, + "negatives": 2382, + "auroc": 0.7522437700227433, + "auprc": 0.10198580242173094, + "brier": 0.038651278713168126, + "calibration": { + "observed_rate": 0.04144869215291751, + "mean_prediction": 0.03696420152017648, + "calibration_in_the_large": -0.004484490632741027, + "expected_calibration_error_10bin": 0.007925466793613651, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + { + "valid": 2485, + "positives": 104, + "negatives": 2381, + "auroc": 0.7532912803282396, + "auprc": 0.10272954031410479, + "brier": 0.039001206092873886, + "calibration": { + "observed_rate": 0.041851106639839035, + "mean_prediction": 0.03720096656837139, + "calibration_in_the_large": -0.004650140071467648, + "expected_calibration_error_10bin": 0.007744879968618031, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + } + ], + "reason": null + }, + "I96": { + "time_averaged_auroc": 0.8911423007980154, + "time_averaged_auprc": 0.0479576002318102, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2831, + "positives": 0, + "negatives": 2831, + "auroc": null, + "auprc": null, + "brier": 7.034941337223455e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00039700280679932844, + "calibration_in_the_large": 0.00039700280679932844, + "expected_calibration_error_10bin": 0.00039700280679932844, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.9975265017667845, + "auprc": 0.125, + "brier": 0.0003482859469648408, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0006795005582730012, + "calibration_in_the_large": 0.0003262684848007299, + "expected_calibration_error_10bin": 0.0003262684848007299, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 3, + "negatives": 2828, + "auroc": 0.9744224422442245, + "auprc": 0.06428070577123968, + "brier": 0.0010462126627224634, + "calibration": { + "observed_rate": 0.0010596962204168139, + "mean_prediction": 0.0009189413998881347, + "calibration_in_the_large": -0.00014075482052867917, + "expected_calibration_error_10bin": 0.00014075482052867917, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.864166961443226, + "auprc": 0.04877498340154199, + "brier": 0.001398463979374219, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0009950430244751833, + "calibration_in_the_large": -0.0004178852694139018, + "expected_calibration_error_10bin": 0.0004178852694139018, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.873452423063318, + "auprc": 0.04470045421749967, + "brier": 0.0013955529997326766, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0012349551519215993, + "calibration_in_the_large": -0.00017797314196748583, + "expected_calibration_error_10bin": 0.00017797314196748583, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.87168376370711, + "auprc": 0.04355456353945582, + "brier": 0.001394651471760122, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0013026520236805404, + "calibration_in_the_large": -0.00011027627020854464, + "expected_calibration_error_10bin": 0.00011027627020854464, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.8709837225760793, + "auprc": 0.03653186602549953, + "brier": 0.001744815968126745, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0015036643695423171, + "calibration_in_the_large": -0.00026249599781903916, + "expected_calibration_error_10bin": 0.00026249599781903916, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.870417551309271, + "auprc": 0.036575871330586, + "brier": 0.0017446175141683587, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0015839096673996873, + "calibration_in_the_large": -0.00018225069996166904, + "expected_calibration_error_10bin": 0.00018225069996166904, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.8698513800424629, + "auprc": 0.036145526350284125, + "brier": 0.0017445225026520884, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0017023660406470895, + "calibration_in_the_large": -6.37943267142668e-05, + "expected_calibration_error_10bin": 6.37943267142668e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.8685774946921444, + "auprc": 0.03583936630395253, + "brier": 0.0017436557513310568, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0017741539145681303, + "calibration_in_the_large": 7.99354720677401e-06, + "expected_calibration_error_10bin": 7.99354720677401e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 6, + "negatives": 2825, + "auroc": 0.8789380530973452, + "auprc": 0.034795896601112264, + "brier": 0.0020919440944601993, + "calibration": { + "observed_rate": 0.0021193924408336277, + "mean_prediction": 0.00199045766897383, + "calibration_in_the_large": -0.00012893477185979768, + "expected_calibration_error_10bin": 0.00012893477185979768, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 6, + "negatives": 2825, + "auroc": 0.8768731563421829, + "auprc": 0.03464778182124272, + "brier": 0.002091828403887865, + "calibration": { + "observed_rate": 0.0021193924408336277, + "mean_prediction": 0.0021019784848881, + "calibration_in_the_large": -1.7413955945527575e-05, + "expected_calibration_error_10bin": 1.7413955945527575e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 6, + "negatives": 2825, + "auroc": 0.8768141592920354, + "auprc": 0.03464418741930807, + "brier": 0.002091837392707981, + "calibration": { + "observed_rate": 0.0021193924408336277, + "mean_prediction": 0.00210891569547892, + "calibration_in_the_large": -1.047674535470779e-05, + "expected_calibration_error_10bin": 1.047674535470779e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + } + ], + "reason": null + }, + "I97": { + "time_averaged_auroc": 0.8038931373654358, + "time_averaged_auprc": 0.013997748655740373, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2740, + "positives": 4, + "negatives": 2736, + "auroc": 0.9042397660818714, + "auprc": 0.019492094971115013, + "brier": 0.0014511495109964, + "calibration": { + "observed_rate": 0.00145985401459854, + "mean_prediction": 0.0009661986620885993, + "calibration_in_the_large": -0.0004936553525099408, + "expected_calibration_error_10bin": 0.0004936553525099408, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 4, + "negatives": 2736, + "auroc": 0.8940972222222222, + "auprc": 0.017157291262334805, + "brier": 0.001450698556558343, + "calibration": { + "observed_rate": 0.00145985401459854, + "mean_prediction": 0.0014561668292814305, + "calibration_in_the_large": -3.687185317109579e-06, + "expected_calibration_error_10bin": 3.687185317109579e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 7, + "negatives": 2733, + "auroc": 0.8037739794051539, + "auprc": 0.012587306537037737, + "brier": 0.002542379885228703, + "calibration": { + "observed_rate": 0.0025547445255474453, + "mean_prediction": 0.001808572855926107, + "calibration_in_the_large": -0.0007461716696213383, + "expected_calibration_error_10bin": 0.0007461716696213383, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 7, + "negatives": 2733, + "auroc": 0.802937640478804, + "auprc": 0.011988397634680476, + "brier": 0.0025425654541593548, + "calibration": { + "observed_rate": 0.0025547445255474453, + "mean_prediction": 0.0021283959890798627, + "calibration_in_the_large": -0.0004263485364675826, + "expected_calibration_error_10bin": 0.0004263485364675826, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 7, + "negatives": 2733, + "auroc": 0.8010558778945167, + "auprc": 0.01152747194698862, + "brier": 0.0025432490819410334, + "calibration": { + "observed_rate": 0.0025547445255474453, + "mean_prediction": 0.002402543053473898, + "calibration_in_the_large": -0.00015220147207354717, + "expected_calibration_error_10bin": 0.00015220147207354717, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 7, + "negatives": 2733, + "auroc": 0.7938947258376458, + "auprc": 0.010915221017265943, + "brier": 0.0025448173567556402, + "calibration": { + "observed_rate": 0.0025547445255474453, + "mean_prediction": 0.0027153562822319266, + "calibration_in_the_large": 0.0001606117566844813, + "expected_calibration_error_10bin": 0.0001606117566844813, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 9, + "negatives": 2731, + "auroc": 0.7793238130111071, + "auprc": 0.010827963371316343, + "brier": 0.003270889346809464, + "calibration": { + "observed_rate": 0.0032846715328467154, + "mean_prediction": 0.0029247561077622147, + "calibration_in_the_large": -0.00035991542508450073, + "expected_calibration_error_10bin": 0.00035991542508450073, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 10, + "negatives": 2730, + "auroc": 0.796923076923077, + "auprc": 0.014218261324769416, + "brier": 0.0036267647709101996, + "calibration": { + "observed_rate": 0.0036496350364963502, + "mean_prediction": 0.0031007884656071467, + "calibration_in_the_large": -0.0005488465708892035, + "expected_calibration_error_10bin": 0.0005488465708892035, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 10, + "negatives": 2730, + "auroc": 0.7939560439560439, + "auprc": 0.013978125842205053, + "brier": 0.003628064058497759, + "calibration": { + "observed_rate": 0.0036496350364963502, + "mean_prediction": 0.0033069040269287555, + "calibration_in_the_large": -0.00034273100956759475, + "expected_calibration_error_10bin": 0.00034273100956759475, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 11, + "negatives": 2729, + "auroc": 0.7667144142043373, + "auprc": 0.01334897909784376, + "brier": 0.003992567292246592, + "calibration": { + "observed_rate": 0.0040145985401459855, + "mean_prediction": 0.003537432932225651, + "calibration_in_the_large": -0.0004771656079203346, + "expected_calibration_error_10bin": 0.0004771656079203346, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 11, + "negatives": 2729, + "auroc": 0.7655484859588927, + "auprc": 0.01315541130614384, + "brier": 0.003993762956987772, + "calibration": { + "observed_rate": 0.0040145985401459855, + "mean_prediction": 0.0036550124761853264, + "calibration_in_the_large": -0.0003595860639606591, + "expected_calibration_error_10bin": 0.0003595860639606591, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 11, + "negatives": 2729, + "auroc": 0.7644824944202006, + "auprc": 0.01292239424635326, + "brier": 0.003995367504221956, + "calibration": { + "observed_rate": 0.0040145985401459855, + "mean_prediction": 0.0038125638412201206, + "calibration_in_the_large": -0.0002020346989258649, + "expected_calibration_error_10bin": 0.0002020346989258649, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + { + "valid": 2740, + "positives": 12, + "negatives": 2728, + "auroc": 0.7836632453567938, + "auprc": 0.0198518139665706, + "brier": 0.004338498157352252, + "calibration": { + "observed_rate": 0.004379562043795621, + "mean_prediction": 0.003850682678491805, + "calibration_in_the_large": -0.0005288793653038157, + "expected_calibration_error_10bin": 0.0005288793653038157, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + } + ], + "reason": null + }, + "J02": { + "time_averaged_auroc": 0.6620395667822287, + "time_averaged_auprc": 0.0016675450299063052, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2825, + "positives": 0, + "negatives": 2825, + "auroc": null, + "auprc": null, + "brier": 5.35729054310034e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0003408214956186135, + "calibration_in_the_large": 0.0003408214956186135, + "expected_calibration_error_10bin": 0.0003408214956186135, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 1, + "negatives": 2824, + "auroc": 0.5230169971671388, + "auprc": 0.000741839762611276, + "brier": 0.00035604942665863875, + "calibration": { + "observed_rate": 0.00035398230088495576, + "mean_prediction": 0.0007695842929755181, + "calibration_in_the_large": 0.00041560199209056235, + "expected_calibration_error_10bin": 0.00041560199209056235, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 1, + "negatives": 2824, + "auroc": 0.5630311614730878, + "auprc": 0.0008097165991902834, + "brier": 0.0003572162565671642, + "calibration": { + "observed_rate": 0.00035398230088495576, + "mean_prediction": 0.0009165675456370886, + "calibration_in_the_large": 0.0005625852447521328, + "expected_calibration_error_10bin": 0.0005625852447521328, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.628409493446688, + "auprc": 0.0013932413363388128, + "brier": 0.0007123517137812846, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0010363124156694248, + "calibration_in_the_large": 0.0003283478138995133, + "expected_calibration_error_10bin": 0.0003283478138995133, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.648955012398158, + "auprc": 0.0014794230352403268, + "brier": 0.0007160515308344697, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0012293694964048568, + "calibration_in_the_large": 0.0005214048946349453, + "expected_calibration_error_10bin": 0.0005214048946349453, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.6833156216790648, + "auprc": 0.0016653194419495839, + "brier": 0.0007190681032418003, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0013618082619520457, + "calibration_in_the_large": 0.0006538436601821342, + "expected_calibration_error_10bin": 0.0006538436601821342, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.6806588735387885, + "auprc": 0.001631918101112414, + "brier": 0.0007207962009052599, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0015107873686181332, + "calibration_in_the_large": 0.0008028227668482217, + "expected_calibration_error_10bin": 0.0008028227668482217, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.6831385051363797, + "auprc": 0.0016489446754077391, + "brier": 0.000722298049732172, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0015808460485670238, + "calibration_in_the_large": 0.0008728814467971123, + "expected_calibration_error_10bin": 0.0008728814467971123, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.6762309599716614, + "auprc": 0.0016148750325965518, + "brier": 0.0007238206266104697, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0016621176049677836, + "calibration_in_the_large": 0.0009541530031978721, + "expected_calibration_error_10bin": 0.0009541530031978721, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.6769394261424017, + "auprc": 0.0016260562467910731, + "brier": 0.0007291728536517379, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0018071582407095115, + "calibration_in_the_large": 0.0010991936389396, + "expected_calibration_error_10bin": 0.0010991936389396, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.675699610343606, + "auprc": 0.0016241337953091684, + "brier": 0.0007328937170320527, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0019559870054275705, + "calibration_in_the_large": 0.001248022403657659, + "expected_calibration_error_10bin": 0.0012480224036576588, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 3, + "negatives": 2822, + "auroc": 0.7523033309709426, + "auprc": 0.0028833541777633837, + "brier": 0.0010890479710077084, + "calibration": { + "observed_rate": 0.0010619469026548673, + "mean_prediction": 0.002074889934954514, + "calibration_in_the_large": 0.0010129430322996466, + "expected_calibration_error_10bin": 0.0010129430322996466, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 3, + "negatives": 2822, + "auroc": 0.7527758091188282, + "auprc": 0.002891718154565051, + "brier": 0.0010892380697913769, + "calibration": { + "observed_rate": 0.0010619469026548673, + "mean_prediction": 0.0020825391673107954, + "calibration_in_the_large": 0.001020592264655928, + "expected_calibration_error_10bin": 0.001020592264655928, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + } + ], + "reason": null + }, + "J06": { + "time_averaged_auroc": 0.6738006778105061, + "time_averaged_auprc": 0.008868664262860754, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2816, + "positives": 1, + "negatives": 2815, + "auroc": 0.38579040852575486, + "auprc": 0.0005780346820809249, + "brier": 0.0003595034729756781, + "calibration": { + "observed_rate": 0.0003551136363636364, + "mean_prediction": 0.0005329218399607265, + "calibration_in_the_large": 0.00017780820359709014, + "expected_calibration_error_10bin": 0.00017780820359709014, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 2, + "negatives": 2814, + "auroc": 0.6018123667377399, + "auprc": 0.001815467007537356, + "brier": 0.0007259057695983748, + "calibration": { + "observed_rate": 0.0007102272727272727, + "mean_prediction": 0.0012495049965508542, + "calibration_in_the_large": 0.0005392777238235815, + "expected_calibration_error_10bin": 0.0005392777238235815, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 3, + "negatives": 2813, + "auroc": 0.6326578978551961, + "auprc": 0.0021174580456835203, + "brier": 0.0010922272760215852, + "calibration": { + "observed_rate": 0.001065340909090909, + "mean_prediction": 0.0016709426129582735, + "calibration_in_the_large": 0.0006056017038673644, + "expected_calibration_error_10bin": 0.0006056017038673643, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 6, + "negatives": 2810, + "auroc": 0.6797153024911032, + "auprc": 0.007657504339512056, + "brier": 0.0021515372541160583, + "calibration": { + "observed_rate": 0.002130681818181818, + "mean_prediction": 0.0020396966051547142, + "calibration_in_the_large": -9.09852130271038e-05, + "expected_calibration_error_10bin": 0.0002579961894520526, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 6, + "negatives": 2810, + "auroc": 0.674673784104389, + "auprc": 0.007595194048907297, + "brier": 0.002159315549309715, + "calibration": { + "observed_rate": 0.002130681818181818, + "mean_prediction": 0.002367312231973012, + "calibration_in_the_large": 0.00023663041379119384, + "expected_calibration_error_10bin": 0.00023663041379119368, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 7, + "negatives": 2809, + "auroc": 0.6882978182372985, + "auprc": 0.007837038106626944, + "brier": 0.002528619275656096, + "calibration": { + "observed_rate": 0.0024857954545454545, + "mean_prediction": 0.002712096852181131, + "calibration_in_the_large": 0.0002263013976356765, + "expected_calibration_error_10bin": 0.0002263013976356765, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 8, + "negatives": 2808, + "auroc": 0.7312589031339032, + "auprc": 0.012400963499288044, + "brier": 0.002878359820504345, + "calibration": { + "observed_rate": 0.002840909090909091, + "mean_prediction": 0.003024561603826793, + "calibration_in_the_large": 0.0001836525129177021, + "expected_calibration_error_10bin": 0.00022028838697255284, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 8, + "negatives": 2808, + "auroc": 0.7318376068376068, + "auprc": 0.012495004794626384, + "brier": 0.0028854369004969616, + "calibration": { + "observed_rate": 0.002840909090909091, + "mean_prediction": 0.003190457827269132, + "calibration_in_the_large": 0.00034954873636004096, + "expected_calibration_error_10bin": 0.0003495487363600409, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 8, + "negatives": 2808, + "auroc": 0.7324608262108262, + "auprc": 0.012464891979655833, + "brier": 0.0028923690226570513, + "calibration": { + "observed_rate": 0.002840909090909091, + "mean_prediction": 0.0034802130832981056, + "calibration_in_the_large": 0.0006393039923890146, + "expected_calibration_error_10bin": 0.0006393039923890142, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 9, + "negatives": 2807, + "auroc": 0.7473380041958596, + "auprc": 0.01278166251838033, + "brier": 0.003275360203764475, + "calibration": { + "observed_rate": 0.0031960227272727275, + "mean_prediction": 0.0038084013440311537, + "calibration_in_the_large": 0.0006123786167584262, + "expected_calibration_error_10bin": 0.0006123786167584266, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 10, + "negatives": 2806, + "auroc": 0.7172843905915894, + "auprc": 0.012013143404357303, + "brier": 0.003640152029830292, + "calibration": { + "observed_rate": 0.0035511363636363635, + "mean_prediction": 0.004140573732503195, + "calibration_in_the_large": 0.0005894373688668316, + "expected_calibration_error_10bin": 0.0005894373688668316, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 12, + "negatives": 2804, + "auroc": 0.7181407513076558, + "auprc": 0.012764523648746666, + "brier": 0.0043510473880921585, + "calibration": { + "observed_rate": 0.004261363636363636, + "mean_prediction": 0.004283192162864163, + "calibration_in_the_large": 2.1828526500526982e-05, + "expected_calibration_error_10bin": 0.0009425215987862016, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 12, + "negatives": 2804, + "auroc": 0.7181407513076558, + "auprc": 0.012771749341787153, + "brier": 0.004353638292236914, + "calibration": { + "observed_rate": 0.004261363636363636, + "mean_prediction": 0.004335177641104854, + "calibration_in_the_large": 7.3814004741218e-05, + "expected_calibration_error_10bin": 0.0008996063081409291, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + } + ], + "reason": null + }, + "J12": { + "time_averaged_auroc": 0.9625176803394625, + "time_averaged_auprc": 0.009347835743456307, + "valid_timepoint_cells": 4, + "timepoints": [ + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 2.2606136755695523e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004881461609972542, + "calibration_in_the_large": 0.0004881461609972542, + "expected_calibration_error_10bin": 0.0004881461609972542, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 6.104695056599535e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0007464090063695617, + "calibration_in_the_large": 0.0007464090063695617, + "expected_calibration_error_10bin": 0.0007464090063695617, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 1.898950797897923e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001475394029935647, + "calibration_in_the_large": 0.001475394029935647, + "expected_calibration_error_10bin": 0.001475394029935647, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 2.3607274129797302e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0015830240183197326, + "calibration_in_the_large": 0.0015830240183197326, + "expected_calibration_error_10bin": 0.0015830240183197326, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 3.3802585370223186e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0019177683536681376, + "calibration_in_the_large": 0.0019177683536681376, + "expected_calibration_error_10bin": 0.0019177683536681378, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 4.44369773330671e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.002139609428978934, + "calibration_in_the_large": 0.002139609428978934, + "expected_calibration_error_10bin": 0.002139609428978934, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 5.458307939134798e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0023654505743166713, + "calibration_in_the_large": 0.0023654505743166713, + "expected_calibration_error_10bin": 0.0023654505743166713, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 7.197539242568787e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00259203834380418, + "calibration_in_the_large": 0.00259203834380418, + "expected_calibration_error_10bin": 0.0025920383438041805, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 8.628451424460103e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.002792341317199824, + "calibration_in_the_large": 0.002792341317199824, + "expected_calibration_error_10bin": 0.002792341317199824, + "nonempty_bins": 3 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.9632248939179632, + "auprc": 0.009523809523809525, + "brier": 0.0004698001765422277, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.0031422907541622737, + "calibration_in_the_large": 0.0027888089584747516, + "expected_calibration_error_10bin": 0.002788808958474751, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.9628712871287128, + "auprc": 0.009433962264150943, + "brier": 0.0004936095252706421, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.0034145212112999196, + "calibration_in_the_large": 0.0030610394156123976, + "expected_calibration_error_10bin": 0.003061039415612397, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.9621640735502122, + "auprc": 0.009259259259259259, + "brier": 0.0005095769607520547, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.0036110474028038485, + "calibration_in_the_large": 0.0032575656071163264, + "expected_calibration_error_10bin": 0.0032575656071163264, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.9618104667609618, + "auprc": 0.009174311926605505, + "brier": 0.000511425727478625, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.003646117845796281, + "calibration_in_the_large": 0.003292636050108759, + "expected_calibration_error_10bin": 0.003292636050108759, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + } + ], + "reason": null + }, + "J15": { + "time_averaged_auroc": 0.8133265956082663, + "time_averaged_auprc": 0.016859613073887073, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2795, + "positives": 1, + "negatives": 2794, + "auroc": 0.9180386542591267, + "auprc": 0.004347826086956522, + "brier": 0.0003659155883992793, + "calibration": { + "observed_rate": 0.00035778175313059033, + "mean_prediction": 0.00134643378212555, + "calibration_in_the_large": 0.0009886520289949597, + "expected_calibration_error_10bin": 0.0009886520289949597, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + { + "valid": 2795, + "positives": 3, + "negatives": 2792, + "auroc": 0.8689111747851003, + "auprc": 0.005213208768659675, + "brier": 0.001098341807432863, + "calibration": { + "observed_rate": 0.001073345259391771, + "mean_prediction": 0.002477863284109906, + "calibration_in_the_large": 0.001404518024718135, + "expected_calibration_error_10bin": 0.001404518024718135, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + { + "valid": 2795, + "positives": 7, + "negatives": 2788, + "auroc": 0.7661406025824964, + "auprc": 0.01146083681544636, + "brier": 0.002535407881552367, + "calibration": { + "observed_rate": 0.0025044722719141325, + "mean_prediction": 0.0034763014071131286, + "calibration_in_the_large": 0.0009718291351989961, + "expected_calibration_error_10bin": 0.0009718291351989964, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + { + "valid": 2795, + "positives": 9, + "negatives": 2786, + "auroc": 0.7954454813751296, + "auprc": 0.01842319314497788, + "brier": 0.0032424073210247954, + "calibration": { + "observed_rate": 0.0032200357781753132, + "mean_prediction": 0.004066128657491626, + "calibration_in_the_large": 0.0008460928793163126, + "expected_calibration_error_10bin": 0.000846092879316313, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + { + "valid": 2795, + "positives": 9, + "negatives": 2786, + "auroc": 0.7959639467177155, + "auprc": 0.01814628853814872, + "brier": 0.0032576413599870566, + "calibration": { + "observed_rate": 0.0032200357781753132, + "mean_prediction": 0.004541196441581135, + "calibration_in_the_large": 0.001321160663405822, + "expected_calibration_error_10bin": 0.0013211606634058219, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + { + "valid": 2795, + "positives": 10, + "negatives": 2785, + "auroc": 0.8115978456014362, + "auprc": 0.019930142565963215, + "brier": 0.0036139412472509544, + "calibration": { + "observed_rate": 0.0035778175313059034, + "mean_prediction": 0.004946512929062608, + "calibration_in_the_large": 0.0013686953977567048, + "expected_calibration_error_10bin": 0.001368695397756705, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + { + "valid": 2795, + "positives": 12, + "negatives": 2783, + "auroc": 0.7925200622829082, + "auprc": 0.01870298472366771, + "brier": 0.004337201130078476, + "calibration": { + "observed_rate": 0.004293381037567084, + "mean_prediction": 0.005443593097989119, + "calibration_in_the_large": 0.0011502120604220348, + "expected_calibration_error_10bin": 0.0011502120604220344, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + { + "valid": 2795, + "positives": 12, + "negatives": 2783, + "auroc": 0.7921607378129117, + "auprc": 0.018534395107060342, + "brier": 0.00434815844784424, + "calibration": { + "observed_rate": 0.004293381037567084, + "mean_prediction": 0.005731120268564202, + "calibration_in_the_large": 0.0014377392309971185, + "expected_calibration_error_10bin": 0.0014377392309971183, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + { + "valid": 2795, + "positives": 14, + "negatives": 2781, + "auroc": 0.7982226331740895, + "auprc": 0.019370896332060687, + "brier": 0.0050604997750869785, + "calibration": { + "observed_rate": 0.005008944543828265, + "mean_prediction": 0.0061064562425221965, + "calibration_in_the_large": 0.0010975116986939315, + "expected_calibration_error_10bin": 0.0010975116986939324, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + { + "valid": 2795, + "positives": 15, + "negatives": 2780, + "auroc": 0.8070023980815347, + "auprc": 0.02095564870878765, + "brier": 0.005413994320266226, + "calibration": { + "observed_rate": 0.005366726296958855, + "mean_prediction": 0.0063379339733464985, + "calibration_in_the_large": 0.0009712076763876438, + "expected_calibration_error_10bin": 0.0009712076763876427, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + { + "valid": 2795, + "positives": 15, + "negatives": 2780, + "auroc": 0.8088489208633094, + "auprc": 0.02151248867079313, + "brier": 0.005426127483469391, + "calibration": { + "observed_rate": 0.005366726296958855, + "mean_prediction": 0.006658298332210421, + "calibration_in_the_large": 0.001291572035251566, + "expected_calibration_error_10bin": 0.0012915720352515646, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + { + "valid": 2795, + "positives": 15, + "negatives": 2780, + "auroc": 0.8091846522781775, + "auprc": 0.021284626586491953, + "brier": 0.0054419419001946944, + "calibration": { + "observed_rate": 0.005366726296958855, + "mean_prediction": 0.0070024926895848934, + "calibration_in_the_large": 0.0016357663926260388, + "expected_calibration_error_10bin": 0.001635766392626038, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + { + "valid": 2795, + "positives": 15, + "negatives": 2780, + "auroc": 0.8092086330935252, + "auprc": 0.021292433911518072, + "brier": 0.005443614414151968, + "calibration": { + "observed_rate": 0.005366726296958855, + "mean_prediction": 0.007043134374022082, + "calibration_in_the_large": 0.0016764080770632272, + "expected_calibration_error_10bin": 0.0016764080770632261, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + } + ], + "reason": null + }, + "J18": { + "time_averaged_auroc": 0.7784642683781653, + "time_averaged_auprc": 0.052833235083543685, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2671, + "positives": 9, + "negatives": 2662, + "auroc": 0.792720594373487, + "auprc": 0.013044545914880261, + "brier": 0.00338150366204229, + "calibration": { + "observed_rate": 0.0033695245226506927, + "mean_prediction": 0.004571223750148885, + "calibration_in_the_large": 0.0012016992274981922, + "expected_calibration_error_10bin": 0.0012016992274981922, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 14, + "negatives": 2657, + "auroc": 0.7801494704016345, + "auprc": 0.018485435538503136, + "brier": 0.005338846219070355, + "calibration": { + "observed_rate": 0.005241482590789966, + "mean_prediction": 0.008829338510156125, + "calibration_in_the_large": 0.0035878559193661588, + "expected_calibration_error_10bin": 0.0035878559193661596, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 22, + "negatives": 2649, + "auroc": 0.7979340402896462, + "auprc": 0.035627274684151736, + "brier": 0.008218370285433534, + "calibration": { + "observed_rate": 0.008236615499812805, + "mean_prediction": 0.010900019349556752, + "calibration_in_the_large": 0.002663403849743947, + "expected_calibration_error_10bin": 0.002663403849743948, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 27, + "negatives": 2644, + "auroc": 0.7770773799518126, + "auprc": 0.037987103453590666, + "brier": 0.010066221746932608, + "calibration": { + "observed_rate": 0.010108573567952079, + "mean_prediction": 0.012501942523547364, + "calibration_in_the_large": 0.002393368955595285, + "expected_calibration_error_10bin": 0.0023933689555952877, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 31, + "negatives": 2640, + "auroc": 0.78069403714565, + "auprc": 0.045402940211138096, + "brier": 0.011462236534623938, + "calibration": { + "observed_rate": 0.011606140022463497, + "mean_prediction": 0.01393826454003213, + "calibration_in_the_large": 0.0023321245175686334, + "expected_calibration_error_10bin": 0.002332124517568633, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 37, + "negatives": 2634, + "auroc": 0.7782121529274149, + "auprc": 0.048309027201076216, + "brier": 0.013661787918653254, + "calibration": { + "observed_rate": 0.013852489704230626, + "mean_prediction": 0.0152158254793492, + "calibration_in_the_large": 0.0013633357751185737, + "expected_calibration_error_10bin": 0.0021789005921924076, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 44, + "negatives": 2627, + "auroc": 0.7801069315153822, + "auprc": 0.057487836258537504, + "brier": 0.01608762131246806, + "calibration": { + "observed_rate": 0.01647323099962561, + "mean_prediction": 0.017159552630129905, + "calibration_in_the_large": 0.0006863216305042948, + "expected_calibration_error_10bin": 0.0030560499287280323, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 51, + "negatives": 2620, + "auroc": 0.7699221673402186, + "auprc": 0.06738566812662615, + "brier": 0.018473660246165025, + "calibration": { + "observed_rate": 0.019093972295020592, + "mean_prediction": 0.0183099166317149, + "calibration_in_the_large": -0.0007840556633056904, + "expected_calibration_error_10bin": 0.0029014176357189158, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 52, + "negatives": 2619, + "auroc": 0.7729462213998296, + "auprc": 0.06822238670492324, + "brier": 0.01883406929060165, + "calibration": { + "observed_rate": 0.019468363908648447, + "mean_prediction": 0.018988304219817714, + "calibration_in_the_large": -0.00048005968883073347, + "expected_calibration_error_10bin": 0.0031039454862852828, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 55, + "negatives": 2616, + "auroc": 0.7733110925771476, + "auprc": 0.06850398399856275, + "brier": 0.01995043768479414, + "calibration": { + "observed_rate": 0.02059153874953201, + "mean_prediction": 0.020169520036045264, + "calibration_in_the_large": -0.0004220187134867451, + "expected_calibration_error_10bin": 0.004540684955986618, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 62, + "negatives": 2609, + "auroc": 0.7745335624822265, + "auprc": 0.07495028489102401, + "brier": 0.022353980151989302, + "calibration": { + "observed_rate": 0.023212280044926994, + "mean_prediction": 0.02098446804175843, + "calibration_in_the_large": -0.0022278120031685653, + "expected_calibration_error_10bin": 0.0061789173882165925, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 64, + "negatives": 2607, + "auroc": 0.7712049290372075, + "auprc": 0.07575161480474726, + "brier": 0.023125583102220005, + "calibration": { + "observed_rate": 0.023961063272182705, + "mean_prediction": 0.022086550448471118, + "calibration_in_the_large": -0.0018745128237115868, + "expected_calibration_error_10bin": 0.006567705207875153, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + { + "valid": 2671, + "positives": 64, + "negatives": 2607, + "auroc": 0.7712229094744918, + "auprc": 0.07567395429830687, + "brier": 0.023133746237566, + "calibration": { + "observed_rate": 0.023961063272182705, + "mean_prediction": 0.022199512766121067, + "calibration_in_the_large": -0.0017615505060616377, + "expected_calibration_error_10bin": 0.006604034555847986, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + } + ], + "reason": null + }, + "J30": { + "time_averaged_auroc": 0.7721425827056169, + "time_averaged_auprc": 0.058306874130902436, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2815, + "positives": 0, + "negatives": 2815, + "auroc": null, + "auprc": null, + "brier": 1.2643794933292211e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0007086977894785694, + "calibration_in_the_large": 0.0007086977894785694, + "expected_calibration_error_10bin": 0.0007086977894785694, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 1, + "negatives": 2814, + "auroc": 0.9989339019189766, + "auprc": 0.25, + "brier": 0.0003405134492985159, + "calibration": { + "observed_rate": 0.00035523978685612787, + "mean_prediction": 0.001226856934556367, + "calibration_in_the_large": 0.0008716171477002393, + "expected_calibration_error_10bin": 0.0008716171477002393, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 3, + "negatives": 2812, + "auroc": 0.809506875296349, + "auprc": 0.08549916672137398, + "brier": 0.0010479080253278906, + "calibration": { + "observed_rate": 0.0010657193605683837, + "mean_prediction": 0.0016985932108398187, + "calibration_in_the_large": 0.000632873850271435, + "expected_calibration_error_10bin": 0.000632873850271435, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 3, + "negatives": 2812, + "auroc": 0.825154101469891, + "auprc": 0.08567614887939946, + "brier": 0.0010538644785540706, + "calibration": { + "observed_rate": 0.0010657193605683837, + "mean_prediction": 0.0020173101395445704, + "calibration_in_the_large": 0.0009515907789761867, + "expected_calibration_error_10bin": 0.0009515907789761867, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 6, + "negatives": 2809, + "auroc": 0.7111664886673786, + "auprc": 0.046531885980045186, + "brier": 0.002116229611564819, + "calibration": { + "observed_rate": 0.0021314387211367673, + "mean_prediction": 0.0022397126105841874, + "calibration_in_the_large": 0.0001082738894474201, + "expected_calibration_error_10bin": 0.00010827388944742036, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 6, + "negatives": 2809, + "auroc": 0.7141331434674262, + "auprc": 0.033289385146513514, + "brier": 0.0021209270966186656, + "calibration": { + "observed_rate": 0.0021314387211367673, + "mean_prediction": 0.0024533151436889077, + "calibration_in_the_large": 0.00032187642255214043, + "expected_calibration_error_10bin": 0.0003218764225521403, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 6, + "negatives": 2809, + "auroc": 0.7117004865313872, + "auprc": 0.0293586743508491, + "brier": 0.0021229017027134573, + "calibration": { + "observed_rate": 0.0021314387211367673, + "mean_prediction": 0.002588222442862915, + "calibration_in_the_large": 0.0004567837217261477, + "expected_calibration_error_10bin": 0.00045678372172614797, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 7, + "negatives": 2808, + "auroc": 0.7498982498982499, + "auprc": 0.03004699711581325, + "brier": 0.0024729836093772967, + "calibration": { + "observed_rate": 0.002486678507992895, + "mean_prediction": 0.002718131034986528, + "calibration_in_the_large": 0.0002314525269936328, + "expected_calibration_error_10bin": 0.0002314525269936328, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 7, + "negatives": 2808, + "auroc": 0.749033374033374, + "auprc": 0.027376568719806517, + "brier": 0.002476143717236257, + "calibration": { + "observed_rate": 0.002486678507992895, + "mean_prediction": 0.00286688848616155, + "calibration_in_the_large": 0.00038020997816865486, + "expected_calibration_error_10bin": 0.0003802099781686551, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 7, + "negatives": 2808, + "auroc": 0.747914122914123, + "auprc": 0.029688402003588056, + "brier": 0.0024787338659917357, + "calibration": { + "observed_rate": 0.002486678507992895, + "mean_prediction": 0.003144536456431272, + "calibration_in_the_large": 0.0006578579484383769, + "expected_calibration_error_10bin": 0.000657857948438377, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 7, + "negatives": 2808, + "auroc": 0.7480667480667481, + "auprc": 0.029688703092922427, + "brier": 0.002481085699886181, + "calibration": { + "observed_rate": 0.002486678507992895, + "mean_prediction": 0.0032833420026275703, + "calibration_in_the_large": 0.0007966634946346752, + "expected_calibration_error_10bin": 0.0007966634946346755, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 7, + "negatives": 2808, + "auroc": 0.7490842490842491, + "auprc": 0.025279606078928086, + "brier": 0.0024876631123642583, + "calibration": { + "observed_rate": 0.002486678507992895, + "mean_prediction": 0.003547520131639041, + "calibration_in_the_large": 0.0010608416236461459, + "expected_calibration_error_10bin": 0.001060841623646146, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 7, + "negatives": 2808, + "auroc": 0.7511192511192512, + "auprc": 0.027246951481589777, + "brier": 0.002488448280821636, + "calibration": { + "observed_rate": 0.002486678507992895, + "mean_prediction": 0.003655819918031492, + "calibration_in_the_large": 0.0011691414100385967, + "expected_calibration_error_10bin": 0.0011691414100385965, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + } + ], + "reason": null + }, + "J32": { + "time_averaged_auroc": 0.6050522367411838, + "time_averaged_auprc": 0.0028715145844468554, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.8967468175388967, + "auprc": 0.0034129692832764505, + "brier": 0.0003537602488802286, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.00024367937541172678, + "calibration_in_the_large": -0.00010980242027579533, + "expected_calibration_error_10bin": 0.00010980242027579533, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.9066478076379066, + "auprc": 0.0037735849056603774, + "brier": 0.0003544563973835663, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.0003754012691418739, + "calibration_in_the_large": 2.1919473454351805e-05, + "expected_calibration_error_10bin": 2.1919473454351805e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.9218528995756718, + "auprc": 0.0045045045045045045, + "brier": 0.00035863280536683963, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.0006272841662946056, + "calibration_in_the_large": 0.00027380237060708345, + "expected_calibration_error_10bin": 0.00027380237060708345, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.5173328616908384, + "auprc": 0.0025829266888467463, + "brier": 0.0007136869253332894, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0007516678281442242, + "calibration_in_the_large": 4.470423676918001e-05, + "expected_calibration_error_10bin": 4.470423676918001e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.5139724089140432, + "auprc": 0.0024987710961822053, + "brier": 0.0007169628077060396, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0008971474526037852, + "calibration_in_the_large": 0.000190183861228741, + "expected_calibration_error_10bin": 0.000190183861228741, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.5169791298195967, + "auprc": 0.0026503414242267744, + "brier": 0.0007180291616202527, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0009887152219993384, + "calibration_in_the_large": 0.0002817516306242942, + "expected_calibration_error_10bin": 0.0002817516306242942, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.5136186770428015, + "auprc": 0.0025702665908425098, + "brier": 0.0007198788365052696, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0011316420632363924, + "calibration_in_the_large": 0.00042467847186134823, + "expected_calibration_error_10bin": 0.00042467847186134823, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.5137955429784223, + "auprc": 0.0025986827757665636, + "brier": 0.00072599682994258, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0012531654897437728, + "calibration_in_the_large": 0.0005462018983687285, + "expected_calibration_error_10bin": 0.0005462018983687285, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.5137955429784223, + "auprc": 0.0026475091692482996, + "brier": 0.0007276386074959084, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0013294480219914737, + "calibration_in_the_large": 0.0006224844306164295, + "expected_calibration_error_10bin": 0.0006224844306164295, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.51326494517156, + "auprc": 0.0026570764302321016, + "brier": 0.0007291095856373893, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0013888417968755116, + "calibration_in_the_large": 0.0006818782055004674, + "expected_calibration_error_10bin": 0.0006818782055004674, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.5100813583303856, + "auprc": 0.0024612164531707652, + "brier": 0.000731971922977393, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0014961521184652762, + "calibration_in_the_large": 0.0007891885270902319, + "expected_calibration_error_10bin": 0.0007891885270902319, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.514149274849664, + "auprc": 0.0025076354013979624, + "brier": 0.0007334194404449451, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0015983927405703957, + "calibration_in_the_large": 0.0008914291491953515, + "expected_calibration_error_10bin": 0.0008914291491953515, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.5134418111071808, + "auprc": 0.002464204874453861, + "brier": 0.000734268627122802, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.00162307977995649, + "calibration_in_the_large": 0.0009161161885814457, + "expected_calibration_error_10bin": 0.0009161161885814457, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + } + ], + "reason": null + }, + "J38": { + "time_averaged_auroc": 0.673182350754581, + "time_averaged_auprc": 0.002568199966247458, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2825, + "positives": 1, + "negatives": 2824, + "auroc": 0.5407223796033994, + "auprc": 0.0007704160246533128, + "brier": 0.00035431630800638166, + "calibration": { + "observed_rate": 0.00035398230088495576, + "mean_prediction": 0.0003522844296810591, + "calibration_in_the_large": -1.69787120389667e-06, + "expected_calibration_error_10bin": 1.69787120389667e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 1, + "negatives": 2824, + "auroc": 0.4978753541076487, + "auprc": 0.0007047216349541931, + "brier": 0.0003561560889606177, + "calibration": { + "observed_rate": 0.00035398230088495576, + "mean_prediction": 0.0007448127447726386, + "calibration_in_the_large": 0.00039083044388768285, + "expected_calibration_error_10bin": 0.00039083044388768285, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 1, + "negatives": 2824, + "auroc": 0.4978753541076487, + "auprc": 0.0007047216349541931, + "brier": 0.0003567566059205275, + "calibration": { + "observed_rate": 0.00035398230088495576, + "mean_prediction": 0.0008421821820751076, + "calibration_in_the_large": 0.00048819988119015186, + "expected_calibration_error_10bin": 0.00048819988119015186, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.6824300389656394, + "auprc": 0.0021237497599024165, + "brier": 0.0007107227062381372, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0009941246837038347, + "calibration_in_the_large": 0.0002861600819339232, + "expected_calibration_error_10bin": 0.0002861600819339232, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.6818986893375841, + "auprc": 0.0021637526376114278, + "brier": 0.0007117265009885534, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0011119299848109125, + "calibration_in_the_large": 0.000403965383041001, + "expected_calibration_error_10bin": 0.000403965383041001, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.6824300389656394, + "auprc": 0.0022671205205566586, + "brier": 0.000713456547592586, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.00126316475633862, + "calibration_in_the_large": 0.0005552001545687085, + "expected_calibration_error_10bin": 0.0005552001545687085, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.6792419411973079, + "auprc": 0.0021973377539966517, + "brier": 0.0007147292357661523, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0013814805324312476, + "calibration_in_the_large": 0.000673515930661336, + "expected_calibration_error_10bin": 0.000673515930661336, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 3, + "negatives": 2822, + "auroc": 0.7485235057878573, + "auprc": 0.0037296198049418714, + "brier": 0.0010671302145613812, + "calibration": { + "observed_rate": 0.0010619469026548673, + "mean_prediction": 0.0014312623712709133, + "calibration_in_the_large": 0.000369315468616046, + "expected_calibration_error_10bin": 0.000369315468616046, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 3, + "negatives": 2822, + "auroc": 0.7474604299551145, + "auprc": 0.003660520709682542, + "brier": 0.0010684823413960466, + "calibration": { + "observed_rate": 0.0010619469026548673, + "mean_prediction": 0.0015411258627986639, + "calibration_in_the_large": 0.0004791789601437965, + "expected_calibration_error_10bin": 0.0004791789601437965, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 3, + "negatives": 2822, + "auroc": 0.7500590597684857, + "auprc": 0.00371617192128328, + "brier": 0.0010695073547105252, + "calibration": { + "observed_rate": 0.0010619469026548673, + "mean_prediction": 0.001630224783803631, + "calibration_in_the_large": 0.0005682778811487636, + "expected_calibration_error_10bin": 0.0005682778811487636, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 3, + "negatives": 2822, + "auroc": 0.7454523978266006, + "auprc": 0.0037182299840527685, + "brier": 0.0010709633274987606, + "calibration": { + "observed_rate": 0.0010619469026548673, + "mean_prediction": 0.0017743927979634753, + "calibration_in_the_large": 0.000712445895308608, + "expected_calibration_error_10bin": 0.000712445895308608, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 3, + "negatives": 2822, + "auroc": 0.7482872667139144, + "auprc": 0.0038166243740526268, + "brier": 0.0010732538876745028, + "calibration": { + "observed_rate": 0.0010619469026548673, + "mean_prediction": 0.0019177673189809126, + "calibration_in_the_large": 0.0008558204163260452, + "expected_calibration_error_10bin": 0.0008558204163260452, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 3, + "negatives": 2822, + "auroc": 0.7491141034727143, + "auprc": 0.003813612800575015, + "brier": 0.001073431919944177, + "calibration": { + "observed_rate": 0.0010619469026548673, + "mean_prediction": 0.0019344494742443332, + "calibration_in_the_large": 0.0008725025715894659, + "expected_calibration_error_10bin": 0.0008725025715894659, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + } + ], + "reason": null + }, + "J43": { + "time_averaged_auroc": 0.5429540152834939, + "time_averaged_auprc": 0.0037330588405471116, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2804, + "positives": 1, + "negatives": 2803, + "auroc": 0.1608990367463432, + "auprc": 0.00042498937526561835, + "brier": 0.00035722058801396076, + "calibration": { + "observed_rate": 0.0003566333808844508, + "mean_prediction": 0.0004361788664739337, + "calibration_in_the_large": 7.954548558948289e-05, + "expected_calibration_error_10bin": 7.954548558948289e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 2, + "negatives": 2802, + "auroc": 0.24428979300499643, + "auprc": 0.0006898575257441107, + "brier": 0.0007160330871537143, + "calibration": { + "observed_rate": 0.0007132667617689016, + "mean_prediction": 0.0007137153687340994, + "calibration_in_the_large": 4.4860696519783555e-07, + "expected_calibration_error_10bin": 4.4860696519783555e-07, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 4, + "negatives": 2800, + "auroc": 0.5120535714285714, + "auprc": 0.0019785175529342643, + "brier": 0.0014297717827533778, + "calibration": { + "observed_rate": 0.0014265335235378032, + "mean_prediction": 0.0009202420085417808, + "calibration_in_the_large": -0.0005062915149960224, + "expected_calibration_error_10bin": 0.0005062915149960224, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 5, + "negatives": 2799, + "auroc": 0.5691318327974276, + "auprc": 0.002684614071607653, + "brier": 0.0017867186884919584, + "calibration": { + "observed_rate": 0.001783166904422254, + "mean_prediction": 0.0010624328829050998, + "calibration_in_the_large": -0.0007207340215171542, + "expected_calibration_error_10bin": 0.0007207340215171542, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 5, + "negatives": 2799, + "auroc": 0.5707038227938549, + "auprc": 0.0026546619033872244, + "brier": 0.0017885573225225548, + "calibration": { + "observed_rate": 0.001783166904422254, + "mean_prediction": 0.0012412302740078833, + "calibration_in_the_large": -0.0005419366304143707, + "expected_calibration_error_10bin": 0.0005419366304143707, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 5, + "negatives": 2799, + "auroc": 0.5754912468738835, + "auprc": 0.0026635997314512065, + "brier": 0.0017922525497815016, + "calibration": { + "observed_rate": 0.001783166904422254, + "mean_prediction": 0.00146871779998945, + "calibration_in_the_large": -0.00031444910443280405, + "expected_calibration_error_10bin": 0.00031444910443280405, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 7, + "negatives": 2797, + "auroc": 0.6738852852546096, + "auprc": 0.005351397022152473, + "brier": 0.0025022720214942194, + "calibration": { + "observed_rate": 0.0024964336661911554, + "mean_prediction": 0.0016452842793262448, + "calibration_in_the_large": -0.0008511493868649106, + "expected_calibration_error_10bin": 0.0009225555174787631, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 8, + "negatives": 2796, + "auroc": 0.6266541487839771, + "auprc": 0.005165769791548473, + "brier": 0.002860493380979503, + "calibration": { + "observed_rate": 0.0028530670470756064, + "mean_prediction": 0.0017675133214857298, + "calibration_in_the_large": -0.0010855537255898765, + "expected_calibration_error_10bin": 0.0011626149478475723, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 8, + "negatives": 2796, + "auroc": 0.626788268955651, + "auprc": 0.005135400978822044, + "brier": 0.002863123010794333, + "calibration": { + "observed_rate": 0.0028530670470756064, + "mean_prediction": 0.001894427805135782, + "calibration_in_the_large": -0.0009586392419398244, + "expected_calibration_error_10bin": 0.0010440240700301518, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 8, + "negatives": 2796, + "auroc": 0.6282188841201717, + "auprc": 0.0051624498493672115, + "brier": 0.002863524361264115, + "calibration": { + "observed_rate": 0.0028530670470756064, + "mean_prediction": 0.0019189040264639603, + "calibration_in_the_large": -0.0009341630206116461, + "expected_calibration_error_10bin": 0.00102069626907869, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 9, + "negatives": 2795, + "auroc": 0.6311667660504869, + "auprc": 0.005467868922932896, + "brier": 0.003219589233772714, + "calibration": { + "observed_rate": 0.003209700427960057, + "mean_prediction": 0.001974347851456967, + "calibration_in_the_large": -0.00123535257650309, + "expected_calibration_error_10bin": 0.0013229692467368074, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 10, + "negatives": 2794, + "auroc": 0.6195060844667144, + "auprc": 0.005572578929721302, + "brier": 0.0035774700209121727, + "calibration": { + "observed_rate": 0.003566333808844508, + "mean_prediction": 0.0020763655919072126, + "calibration_in_the_large": -0.0014899682169372953, + "expected_calibration_error_10bin": 0.0015829936685722832, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 10, + "negatives": 2794, + "auroc": 0.619613457408733, + "auprc": 0.005578059272177968, + "brier": 0.0035775660251663077, + "calibration": { + "observed_rate": 0.003566333808844508, + "mean_prediction": 0.002081927771423748, + "calibration_in_the_large": -0.0014844060374207598, + "expected_calibration_error_10bin": 0.0015776807805934095, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + } + ], + "reason": null + }, + "J44": { + "time_averaged_auroc": 0.8062427607559208, + "time_averaged_auprc": 0.030379976663596157, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2570, + "positives": 6, + "negatives": 2564, + "auroc": 0.8323582943317732, + "auprc": 0.008762859009966302, + "brier": 0.002329352189593122, + "calibration": { + "observed_rate": 0.0023346303501945525, + "mean_prediction": 0.001527165466347968, + "calibration_in_the_large": -0.0008074648838465844, + "expected_calibration_error_10bin": 0.0008074648838465844, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + { + "valid": 2570, + "positives": 10, + "negatives": 2560, + "auroc": 0.8425390625, + "auprc": 0.017134400877871336, + "brier": 0.003860152938522804, + "calibration": { + "observed_rate": 0.0038910505836575876, + "mean_prediction": 0.0030790088714695465, + "calibration_in_the_large": -0.0008120417121880411, + "expected_calibration_error_10bin": 0.0008120417121880411, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + { + "valid": 2570, + "positives": 14, + "negatives": 2556, + "auroc": 0.8163145539906104, + "auprc": 0.029621561625791097, + "brier": 0.005379400562306925, + "calibration": { + "observed_rate": 0.005447470817120622, + "mean_prediction": 0.003694948200993684, + "calibration_in_the_large": -0.0017525226161269384, + "expected_calibration_error_10bin": 0.0017525226161269384, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + { + "valid": 2570, + "positives": 16, + "negatives": 2554, + "auroc": 0.8258858653093187, + "auprc": 0.03238467187142304, + "brier": 0.006129587078211112, + "calibration": { + "observed_rate": 0.0062256809338521405, + "mean_prediction": 0.004344050397490358, + "calibration_in_the_large": -0.0018816305363617827, + "expected_calibration_error_10bin": 0.0018816305363617827, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + { + "valid": 2570, + "positives": 17, + "negatives": 2553, + "auroc": 0.8312942098108339, + "auprc": 0.0321639477368064, + "brier": 0.006510059641486062, + "calibration": { + "observed_rate": 0.006614785992217899, + "mean_prediction": 0.005665369826068154, + "calibration_in_the_large": -0.0009494161661497448, + "expected_calibration_error_10bin": 0.0009494161661497448, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + { + "valid": 2570, + "positives": 20, + "negatives": 2550, + "auroc": 0.7957647058823529, + "auprc": 0.030695881291536203, + "brier": 0.00766411052825037, + "calibration": { + "observed_rate": 0.007782101167315175, + "mean_prediction": 0.0062183039432417795, + "calibration_in_the_large": -0.0015637972240733957, + "expected_calibration_error_10bin": 0.0016460806534400007, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + { + "valid": 2570, + "positives": 22, + "negatives": 2548, + "auroc": 0.7759918652775796, + "auprc": 0.028696544064833206, + "brier": 0.008445593816488786, + "calibration": { + "observed_rate": 0.008560311284046693, + "mean_prediction": 0.0066968570832111685, + "calibration_in_the_large": -0.001863454200835525, + "expected_calibration_error_10bin": 0.002116705923418108, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + { + "valid": 2570, + "positives": 24, + "negatives": 2546, + "auroc": 0.7934832416863054, + "auprc": 0.03504198209516665, + "brier": 0.00917519437287514, + "calibration": { + "observed_rate": 0.00933852140077821, + "mean_prediction": 0.007306849174664092, + "calibration_in_the_large": -0.002031672226114118, + "expected_calibration_error_10bin": 0.0025587643505836674, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + { + "valid": 2570, + "positives": 24, + "negatives": 2546, + "auroc": 0.7938760146635245, + "auprc": 0.03488091725955844, + "brier": 0.00918489096052214, + "calibration": { + "observed_rate": 0.00933852140077821, + "mean_prediction": 0.007757156609969439, + "calibration_in_the_large": -0.001581364790808771, + "expected_calibration_error_10bin": 0.00223545918743892, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + { + "valid": 2570, + "positives": 27, + "negatives": 2543, + "auroc": 0.7973085157512999, + "auprc": 0.03647294847524801, + "brier": 0.010323844547604693, + "calibration": { + "observed_rate": 0.010505836575875487, + "mean_prediction": 0.008164501890897069, + "calibration_in_the_large": -0.002341334684978418, + "expected_calibration_error_10bin": 0.003277469406960758, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + { + "valid": 2570, + "positives": 28, + "negatives": 2542, + "auroc": 0.7916151511745532, + "auprc": 0.035944754496495715, + "brier": 0.010717447839911697, + "calibration": { + "observed_rate": 0.010894941634241245, + "mean_prediction": 0.008856066294447728, + "calibration_in_the_large": -0.002038875339793517, + "expected_calibration_error_10bin": 0.0032130395756173303, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + { + "valid": 2570, + "positives": 30, + "negatives": 2540, + "auroc": 0.7924015748031497, + "auprc": 0.03661729859829622, + "brier": 0.011488697176339734, + "calibration": { + "observed_rate": 0.011673151750972763, + "mean_prediction": 0.00916805176365829, + "calibration_in_the_large": -0.0025050999873144734, + "expected_calibration_error_10bin": 0.0038382501041644415, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + { + "valid": 2570, + "positives": 30, + "negatives": 2540, + "auroc": 0.7923228346456693, + "auprc": 0.03652192922375747, + "brier": 0.011490670404547149, + "calibration": { + "observed_rate": 0.011673151750972763, + "mean_prediction": 0.009261248287060144, + "calibration_in_the_large": -0.0024119034639126184, + "expected_calibration_error_10bin": 0.003758380877832268, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + } + ], + "reason": null + }, + "J45": { + "time_averaged_auroc": 0.6817179655682085, + "time_averaged_auprc": 0.01895826892436197, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2518, + "positives": 9, + "negatives": 2509, + "auroc": 0.6520526106018334, + "auprc": 0.006868554882223054, + "brier": 0.0035657385035523913, + "calibration": { + "observed_rate": 0.003574265289912629, + "mean_prediction": 0.0023772414633604316, + "calibration_in_the_large": -0.0011970238265521975, + "expected_calibration_error_10bin": 0.0011970238265521975, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + { + "valid": 2518, + "positives": 13, + "negatives": 2505, + "auroc": 0.6336557653922923, + "auprc": 0.009118336644850842, + "brier": 0.005145487332010995, + "calibration": { + "observed_rate": 0.005162827640984908, + "mean_prediction": 0.003576152313900468, + "calibration_in_the_large": -0.0015866753270844403, + "expected_calibration_error_10bin": 0.0015866753270844403, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + { + "valid": 2518, + "positives": 17, + "negatives": 2501, + "auroc": 0.6828092292494767, + "auprc": 0.012861255876031612, + "brier": 0.006714573983382315, + "calibration": { + "observed_rate": 0.006751389992057188, + "mean_prediction": 0.004146687910905754, + "calibration_in_the_large": -0.002604702081151434, + "expected_calibration_error_10bin": 0.002604702081151434, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + { + "valid": 2518, + "positives": 19, + "negatives": 2499, + "auroc": 0.6801457425075293, + "auprc": 0.017765799151194653, + "brier": 0.007483607690952645, + "calibration": { + "observed_rate": 0.007545671167593328, + "mean_prediction": 0.004786240078779873, + "calibration_in_the_large": -0.0027594310888134554, + "expected_calibration_error_10bin": 0.0027594310888134554, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + { + "valid": 2518, + "positives": 20, + "negatives": 2498, + "auroc": 0.6843274619695756, + "auprc": 0.017434403933179327, + "brier": 0.007875187583181464, + "calibration": { + "observed_rate": 0.007942811755361398, + "mean_prediction": 0.00553554067098017, + "calibration_in_the_large": -0.0024072710843812276, + "expected_calibration_error_10bin": 0.0024072710843812276, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + { + "valid": 2518, + "positives": 20, + "negatives": 2498, + "auroc": 0.6811649319455565, + "auprc": 0.01743363333400719, + "brier": 0.007878633115497684, + "calibration": { + "observed_rate": 0.007942811755361398, + "mean_prediction": 0.006147123139951344, + "calibration_in_the_large": -0.0017956886154100538, + "expected_calibration_error_10bin": 0.0017956886154100538, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + { + "valid": 2518, + "positives": 21, + "negatives": 2497, + "auroc": 0.6943761084730248, + "auprc": 0.023232001539362307, + "brier": 0.008249830579939962, + "calibration": { + "observed_rate": 0.008339952343129467, + "mean_prediction": 0.006572644471890286, + "calibration_in_the_large": -0.0017673078712391807, + "expected_calibration_error_10bin": 0.0018590014269135341, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + { + "valid": 2518, + "positives": 22, + "negatives": 2496, + "auroc": 0.6917249417249417, + "auprc": 0.023478235649538947, + "brier": 0.008643515982040358, + "calibration": { + "observed_rate": 0.008737092930897538, + "mean_prediction": 0.007132444012404521, + "calibration_in_the_large": -0.001604648918493017, + "expected_calibration_error_10bin": 0.0018670596217021276, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + { + "valid": 2518, + "positives": 22, + "negatives": 2496, + "auroc": 0.6912514568764568, + "auprc": 0.022966651691779874, + "brier": 0.00864755083081394, + "calibration": { + "observed_rate": 0.008737092930897538, + "mean_prediction": 0.007701084149680178, + "calibration_in_the_large": -0.0010360087812173596, + "expected_calibration_error_10bin": 0.0013241037010757817, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + { + "valid": 2518, + "positives": 23, + "negatives": 2495, + "auroc": 0.6987366036420667, + "auprc": 0.023780664992074475, + "brier": 0.009037362678969926, + "calibration": { + "observed_rate": 0.009134233518665607, + "mean_prediction": 0.00803976786549712, + "calibration_in_the_large": -0.0010944656531684874, + "expected_calibration_error_10bin": 0.0014001750829934735, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + { + "valid": 2518, + "positives": 24, + "negatives": 2494, + "auroc": 0.6962042234696605, + "auprc": 0.02403228861007843, + "brier": 0.009435185997131003, + "calibration": { + "observed_rate": 0.009531374106433678, + "mean_prediction": 0.008729050049855655, + "calibration_in_the_large": -0.0008023240565780236, + "expected_calibration_error_10bin": 0.0012190427521659422, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + { + "valid": 2518, + "positives": 25, + "negatives": 2493, + "auroc": 0.6879422382671481, + "auprc": 0.02374104768193798, + "brier": 0.009835653007236418, + "calibration": { + "observed_rate": 0.009928514694201748, + "mean_prediction": 0.009115208959066574, + "calibration_in_the_large": -0.0008133057351351735, + "expected_calibration_error_10bin": 0.0012604080226723208, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + { + "valid": 2518, + "positives": 25, + "negatives": 2493, + "auroc": 0.6879422382671481, + "auprc": 0.0237446220304469, + "brier": 0.009835811447897589, + "calibration": { + "observed_rate": 0.009928514694201748, + "mean_prediction": 0.009127708061388712, + "calibration_in_the_large": -0.0008008066328130357, + "expected_calibration_error_10bin": 0.0012485358343343905, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + } + ], + "reason": null + }, + "J47": { + "time_averaged_auroc": 0.8723297490938635, + "time_averaged_auprc": 0.011193669446032449, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2825, + "positives": 0, + "negatives": 2825, + "auroc": null, + "auprc": null, + "brier": 1.8542608349368428e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00016043897682807375, + "calibration_in_the_large": 0.00016043897682807375, + "expected_calibration_error_10bin": 0.00016043897682807375, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 1, + "negatives": 2824, + "auroc": 0.9213881019830028, + "auprc": 0.004484304932735426, + "brier": 0.000353944180088887, + "calibration": { + "observed_rate": 0.00035398230088495576, + "mean_prediction": 0.0003224839628405105, + "calibration_in_the_large": -3.1498338044445276e-05, + "expected_calibration_error_10bin": 3.1498338044445276e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.9114417286574567, + "auprc": 0.005799135372306104, + "brier": 0.000707484243319017, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.000404832402819695, + "calibration_in_the_large": -0.0003031321989502165, + "expected_calibration_error_10bin": 0.0003031321989502165, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 3, + "negatives": 2822, + "auroc": 0.876210725253957, + "auprc": 0.00562815184968394, + "brier": 0.0010612298321759557, + "calibration": { + "observed_rate": 0.0010619469026548673, + "mean_prediction": 0.0004759683769691391, + "calibration_in_the_large": -0.0005859785256857283, + "expected_calibration_error_10bin": 0.0005859785256857283, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 4, + "negatives": 2821, + "auroc": 0.8995037220843672, + "auprc": 0.009320624694311889, + "brier": 0.0014135723958731054, + "calibration": { + "observed_rate": 0.001415929203539823, + "mean_prediction": 0.0005561778182563851, + "calibration_in_the_large": -0.0008597513852834379, + "expected_calibration_error_10bin": 0.0008597513852834379, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 4, + "negatives": 2821, + "auroc": 0.8996809641970932, + "auprc": 0.009480205412830324, + "brier": 0.0014138312922257665, + "calibration": { + "observed_rate": 0.001415929203539823, + "mean_prediction": 0.0006708736083830638, + "calibration_in_the_large": -0.0007450555951567593, + "expected_calibration_error_10bin": 0.0007450555951567593, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 6, + "negatives": 2819, + "auroc": 0.8605888612983328, + "auprc": 0.01417429515692223, + "brier": 0.0021178665993310435, + "calibration": { + "observed_rate": 0.0021238938053097347, + "mean_prediction": 0.0007375162189939662, + "calibration_in_the_large": -0.0013863775863157683, + "expected_calibration_error_10bin": 0.0013863775863157683, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 6, + "negatives": 2819, + "auroc": 0.8615348232233653, + "auprc": 0.014295607721652143, + "brier": 0.0021180094269450853, + "calibration": { + "observed_rate": 0.0021238938053097347, + "mean_prediction": 0.0007610729045260022, + "calibration_in_the_large": -0.0013628209007837326, + "expected_calibration_error_10bin": 0.0013628209007837326, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 6, + "negatives": 2819, + "auroc": 0.8627763982499704, + "auprc": 0.014501453738115762, + "brier": 0.002117851070135851, + "calibration": { + "observed_rate": 0.0021238938053097347, + "mean_prediction": 0.000828699459593937, + "calibration_in_the_large": -0.0012951943457157975, + "expected_calibration_error_10bin": 0.0012951943457157975, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 6, + "negatives": 2819, + "auroc": 0.8622442946671397, + "auprc": 0.014794569377046861, + "brier": 0.0021180328845870253, + "calibration": { + "observed_rate": 0.0021238938053097347, + "mean_prediction": 0.00090759813658932, + "calibration_in_the_large": -0.0012162956687204146, + "expected_calibration_error_10bin": 0.0012162956687204146, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 6, + "negatives": 2819, + "auroc": 0.8621260494265106, + "auprc": 0.014756255710427615, + "brier": 0.0021181440060076594, + "calibration": { + "observed_rate": 0.0021238938053097347, + "mean_prediction": 0.0009579446697914772, + "calibration_in_the_large": -0.0011659491355182575, + "expected_calibration_error_10bin": 0.0011659491355182575, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 7, + "negatives": 2818, + "auroc": 0.8252053127851566, + "auprc": 0.013542985773891411, + "brier": 0.002471995786305676, + "calibration": { + "observed_rate": 0.00247787610619469, + "mean_prediction": 0.0010165410236965397, + "calibration_in_the_large": -0.0014613350824981505, + "expected_calibration_error_10bin": 0.0014613350824981505, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 7, + "negatives": 2818, + "auroc": 0.8252560073000101, + "auprc": 0.013546443612465675, + "brier": 0.0024720124822556057, + "calibration": { + "observed_rate": 0.00247787610619469, + "mean_prediction": 0.0010186658702721904, + "calibration_in_the_large": -0.0014592102359224997, + "expected_calibration_error_10bin": 0.0014592102359224997, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + } + ], + "reason": null + }, + "J69": { + "time_averaged_auroc": 0.7853179800350674, + "time_averaged_auprc": 0.032971167349483396, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2777, + "positives": 6, + "negatives": 2771, + "auroc": 0.8791651629977144, + "auprc": 0.011862198289037626, + "brier": 0.0021495043612537587, + "calibration": { + "observed_rate": 0.0021606049693914295, + "mean_prediction": 0.0022474080704922763, + "calibration_in_the_large": 8.680310110084676e-05, + "expected_calibration_error_10bin": 8.680310110084676e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 14, + "negatives": 2763, + "auroc": 0.800992709787498, + "auprc": 0.038205248660027454, + "brier": 0.004960390573555418, + "calibration": { + "observed_rate": 0.005041411595246669, + "mean_prediction": 0.004440742220697331, + "calibration_in_the_large": -0.0006006693745493376, + "expected_calibration_error_10bin": 0.0006754833828936181, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 19, + "negatives": 2758, + "auroc": 0.7806190603412083, + "auprc": 0.03446358494092872, + "brier": 0.006746988855930392, + "calibration": { + "observed_rate": 0.0068419157364061935, + "mean_prediction": 0.005885203005039477, + "calibration_in_the_large": -0.0009567127313667165, + "expected_calibration_error_10bin": 0.001231551733816623, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 21, + "negatives": 2756, + "auroc": 0.7893600110581243, + "auprc": 0.03575410241315741, + "brier": 0.007442994915101671, + "calibration": { + "observed_rate": 0.007562117392870004, + "mean_prediction": 0.006887975899730487, + "calibration_in_the_large": -0.0006741414931395167, + "expected_calibration_error_10bin": 0.000674141493139516, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 22, + "negatives": 2755, + "auroc": 0.7808282461639994, + "auprc": 0.0345030734674621, + "brier": 0.0078109801054828286, + "calibration": { + "observed_rate": 0.00792221822110191, + "mean_prediction": 0.007873428564613306, + "calibration_in_the_large": -4.878965648860353e-05, + "expected_calibration_error_10bin": 6.151690559924037e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 22, + "negatives": 2755, + "auroc": 0.7791618544794588, + "auprc": 0.03252692293936496, + "brier": 0.007830053934463833, + "calibration": { + "observed_rate": 0.00792221822110191, + "mean_prediction": 0.008636481879348356, + "calibration_in_the_large": 0.0007142636582464466, + "expected_calibration_error_10bin": 0.0007757481781417532, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 24, + "negatives": 2753, + "auroc": 0.7775154377043225, + "auprc": 0.032445637149609984, + "brier": 0.008557414094277417, + "calibration": { + "observed_rate": 0.008642419877565718, + "mean_prediction": 0.009418196986518435, + "calibration_in_the_large": 0.0007757771089527167, + "expected_calibration_error_10bin": 0.0007757771089527154, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 25, + "negatives": 2752, + "auroc": 0.7645058139534884, + "auprc": 0.03178589051426553, + "brier": 0.008927339580455301, + "calibration": { + "observed_rate": 0.009002520705797623, + "mean_prediction": 0.009835408375768732, + "calibration_in_the_large": 0.000832887669971109, + "expected_calibration_error_10bin": 0.0008328876699711092, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 26, + "negatives": 2751, + "auroc": 0.7615692195844868, + "auprc": 0.03266330013620269, + "brier": 0.009299339339999659, + "calibration": { + "observed_rate": 0.009362621534029529, + "mean_prediction": 0.01036888674636186, + "calibration_in_the_large": 0.0010062652123323315, + "expected_calibration_error_10bin": 0.0010062652123323317, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 27, + "negatives": 2750, + "auroc": 0.7628552188552189, + "auprc": 0.03287896342372157, + "brier": 0.009660759566611467, + "calibration": { + "observed_rate": 0.009722722362261434, + "mean_prediction": 0.010775505630553807, + "calibration_in_the_large": 0.0010527832682923725, + "expected_calibration_error_10bin": 0.0010527832682923725, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 30, + "negatives": 2747, + "auroc": 0.7767261254702099, + "auprc": 0.036950236733088865, + "brier": 0.010684005350186272, + "calibration": { + "observed_rate": 0.010803024846957148, + "mean_prediction": 0.011561378385923275, + "calibration_in_the_large": 0.0007583535389661267, + "expected_calibration_error_10bin": 0.0007583535389661266, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 31, + "negatives": 2746, + "auroc": 0.777917440030073, + "auprc": 0.037288341549313764, + "brier": 0.011047209798587613, + "calibration": { + "observed_rate": 0.011163125675189053, + "mean_prediction": 0.012014274059195872, + "calibration_in_the_large": 0.0008511483840068189, + "expected_calibration_error_10bin": 0.0008511483840068192, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + { + "valid": 2777, + "positives": 31, + "negatives": 2746, + "auroc": 0.777917440030073, + "auprc": 0.03729767532710347, + "brier": 0.011051023092279535, + "calibration": { + "observed_rate": 0.011163125675189053, + "mean_prediction": 0.012126218804424386, + "calibration_in_the_large": 0.0009630931292353324, + "expected_calibration_error_10bin": 0.0009630931292353327, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + } + ], + "reason": null + }, + "J81": { + "time_averaged_auroc": 0.7558084632673795, + "time_averaged_auprc": 0.021869078548879702, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2781, + "positives": 5, + "negatives": 2776, + "auroc": 0.6859510086455332, + "auprc": 0.004948250364141151, + "brier": 0.0017962076821236104, + "calibration": { + "observed_rate": 0.0017979144192736426, + "mean_prediction": 0.0006559638823578806, + "calibration_in_the_large": -0.001141950536915762, + "expected_calibration_error_10bin": 0.001141950536915762, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 7, + "negatives": 2774, + "auroc": 0.7561540838397364, + "auprc": 0.009919422208455148, + "brier": 0.0025101391044161443, + "calibration": { + "observed_rate": 0.0025170801869830997, + "mean_prediction": 0.0013703308074710836, + "calibration_in_the_large": -0.001146749379512016, + "expected_calibration_error_10bin": 0.001146749379512016, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 11, + "negatives": 2770, + "auroc": 0.7482441745979652, + "auprc": 0.022011449449897427, + "brier": 0.003924501199894256, + "calibration": { + "observed_rate": 0.003955411722402014, + "mean_prediction": 0.0018028007267473357, + "calibration_in_the_large": -0.002152610995654678, + "expected_calibration_error_10bin": 0.002152610995654678, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 12, + "negatives": 2769, + "auroc": 0.7193932827735645, + "auprc": 0.01924033763935933, + "brier": 0.004283556402101984, + "calibration": { + "observed_rate": 0.004314994606256742, + "mean_prediction": 0.0021812347456375432, + "calibration_in_the_large": -0.0021337598606191986, + "expected_calibration_error_10bin": 0.0021337598606191986, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 14, + "negatives": 2767, + "auroc": 0.7447983891785843, + "auprc": 0.02084421092059149, + "brier": 0.004992366436363736, + "calibration": { + "observed_rate": 0.005034160373966199, + "mean_prediction": 0.002491991441705914, + "calibration_in_the_large": -0.0025421689322602855, + "expected_calibration_error_10bin": 0.0025421689322602855, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 16, + "negatives": 2765, + "auroc": 0.764760397830018, + "auprc": 0.02310582575781284, + "brier": 0.005700134508020424, + "calibration": { + "observed_rate": 0.005753326141675656, + "mean_prediction": 0.0026868220878387737, + "calibration_in_the_large": -0.0030665040538368823, + "expected_calibration_error_10bin": 0.0030665040538368823, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 17, + "negatives": 2764, + "auroc": 0.773176130075764, + "auprc": 0.024654093695816635, + "brier": 0.006053293049134276, + "calibration": { + "observed_rate": 0.006112909025530385, + "mean_prediction": 0.0028410635608490074, + "calibration_in_the_large": -0.0032718454646813774, + "expected_calibration_error_10bin": 0.0032718454646813774, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 17, + "negatives": 2764, + "auroc": 0.7702604920405209, + "auprc": 0.024565425142950417, + "brier": 0.00605251400560623, + "calibration": { + "observed_rate": 0.006112909025530385, + "mean_prediction": 0.0031027662764352448, + "calibration_in_the_large": -0.00301014274909514, + "expected_calibration_error_10bin": 0.00301014274909514, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 19, + "negatives": 2762, + "auroc": 0.7753915926674034, + "auprc": 0.027314084628411825, + "brier": 0.0067565079757971125, + "calibration": { + "observed_rate": 0.0068320747932398415, + "mean_prediction": 0.0032715741802485307, + "calibration_in_the_large": -0.003560500612991311, + "expected_calibration_error_10bin": 0.003560500612991311, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 20, + "negatives": 2761, + "auroc": 0.7781238681637088, + "auprc": 0.027523417328503837, + "brier": 0.007111484953057985, + "calibration": { + "observed_rate": 0.00719165767709457, + "mean_prediction": 0.0034542228356288836, + "calibration_in_the_large": -0.0037374348414656866, + "expected_calibration_error_10bin": 0.0037374348414656866, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 21, + "negatives": 2760, + "auroc": 0.7711697722567288, + "auprc": 0.02693005135137388, + "brier": 0.007468208665202657, + "calibration": { + "observed_rate": 0.007551240560949299, + "mean_prediction": 0.0036206478692965595, + "calibration_in_the_large": -0.0039305926916527395, + "expected_calibration_error_10bin": 0.0039305926916527395, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 23, + "negatives": 2758, + "auroc": 0.7691301194942776, + "auprc": 0.026667129823993885, + "brier": 0.008180524007242453, + "calibration": { + "observed_rate": 0.008270406328658756, + "mean_prediction": 0.0038940691607207657, + "calibration_in_the_large": -0.00437633716793799, + "expected_calibration_error_10bin": 0.00437633716793799, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 23, + "negatives": 2758, + "auroc": 0.7689567109121291, + "auprc": 0.026574322824128256, + "brier": 0.008180670904959391, + "calibration": { + "observed_rate": 0.008270406328658756, + "mean_prediction": 0.003925230056627632, + "calibration_in_the_large": -0.004345176272031123, + "expected_calibration_error_10bin": 0.004345176272031123, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + } + ], + "reason": null + }, + "J84": { + "time_averaged_auroc": 0.9242759243361662, + "time_averaged_auprc": 0.03310046737299775, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2817, + "positives": 4, + "negatives": 2813, + "auroc": 0.9249022396018486, + "auprc": 0.012608241207344165, + "brier": 0.0014176510947206487, + "calibration": { + "observed_rate": 0.0014199503017394391, + "mean_prediction": 0.00022390711926942344, + "calibration_in_the_large": -0.0011960431824700156, + "expected_calibration_error_10bin": 0.0011960431824700156, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 5, + "negatives": 2812, + "auroc": 0.9576102418207681, + "auprc": 0.03338922593157122, + "brier": 0.0017669149208748393, + "calibration": { + "observed_rate": 0.001774937877174299, + "mean_prediction": 0.0004909966506530684, + "calibration_in_the_large": -0.0012839412265212306, + "expected_calibration_error_10bin": 0.0012839412265212306, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 5, + "negatives": 2812, + "auroc": 0.9519203413940256, + "auprc": 0.04195687017738805, + "brier": 0.001763835077110327, + "calibration": { + "observed_rate": 0.001774937877174299, + "mean_prediction": 0.0006532706453177921, + "calibration_in_the_large": -0.0011216672318565069, + "expected_calibration_error_10bin": 0.0011216672318565069, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 5, + "negatives": 2812, + "auroc": 0.9497866287339971, + "auprc": 0.04201741680439204, + "brier": 0.0017615192568090471, + "calibration": { + "observed_rate": 0.001774937877174299, + "mean_prediction": 0.0008334341924711168, + "calibration_in_the_large": -0.0009415036847031822, + "expected_calibration_error_10bin": 0.0009415036847031822, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.9161159125571937, + "auprc": 0.0368478594620983, + "brier": 0.002463620384063141, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.0011208873704064975, + "calibration_in_the_large": -0.001364025657637521, + "expected_calibration_error_10bin": 0.001364025657637521, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.9148957803762074, + "auprc": 0.03320140791536672, + "brier": 0.002461801142848668, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.0012511568052784468, + "calibration_in_the_large": -0.0012337562227655717, + "expected_calibration_error_10bin": 0.0012337562227655717, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.9150991357397051, + "auprc": 0.03386769967511249, + "brier": 0.0024589311240470787, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.0014696852769036292, + "calibration_in_the_large": -0.0010152277511403893, + "expected_calibration_error_10bin": 0.0010152277511403893, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.9138790035587189, + "auprc": 0.03314486552266009, + "brier": 0.002457892930841726, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.0015894267964452168, + "calibration_in_the_large": -0.0008954862315988018, + "expected_calibration_error_10bin": 0.0008954862315988018, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.9141840366039654, + "auprc": 0.03337374025239157, + "brier": 0.002456058496758332, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.001759003630838534, + "calibration_in_the_large": -0.0007259093972054845, + "expected_calibration_error_10bin": 0.0007259093972054845, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.9141840366039654, + "auprc": 0.032337751452599074, + "brier": 0.0024554229026758413, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.0018780908019474585, + "calibration_in_the_large": -0.00060682222609656, + "expected_calibration_error_10bin": 0.00060682222609656, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.9142857142857143, + "auprc": 0.032356236390147716, + "brier": 0.002455318878534323, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.001903852246762198, + "calibration_in_the_large": -0.0005810607812818205, + "expected_calibration_error_10bin": 0.0005810607812818205, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.9143873919674631, + "auprc": 0.03259898351756601, + "brier": 0.002455218965839343, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.001929736834438499, + "calibration_in_the_large": -0.0005551761936055195, + "expected_calibration_error_10bin": 0.0005551761936055195, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.9143365531265887, + "auprc": 0.0326057775403333, + "brier": 0.0024551944472128895, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.001935254032819637, + "calibration_in_the_large": -0.0005496589952243816, + "expected_calibration_error_10bin": 0.0005496589952243816, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + } + ], + "reason": null + }, + "J90": { + "time_averaged_auroc": 0.685697348131115, + "time_averaged_auprc": 0.019596306959182814, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2754, + "positives": 11, + "negatives": 2743, + "auroc": 0.6662910549166473, + "auprc": 0.00783264507215396, + "brier": 0.00398648201922016, + "calibration": { + "observed_rate": 0.0039941902687000725, + "mean_prediction": 0.00319202317367627, + "calibration_in_the_large": -0.0008021670950238025, + "expected_calibration_error_10bin": 0.0008021670950238025, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + { + "valid": 2754, + "positives": 13, + "negatives": 2741, + "auroc": 0.6426907641792721, + "auprc": 0.007744606986050294, + "brier": 0.004748114881631549, + "calibration": { + "observed_rate": 0.004720406681190995, + "mean_prediction": 0.005155681078648884, + "calibration_in_the_large": 0.0004352743974578889, + "expected_calibration_error_10bin": 0.0004352743974578889, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + { + "valid": 2754, + "positives": 20, + "negatives": 2734, + "auroc": 0.6648134601316752, + "auprc": 0.013498277073773494, + "brier": 0.007258392380559504, + "calibration": { + "observed_rate": 0.007262164124909223, + "mean_prediction": 0.0061338846923811065, + "calibration_in_the_large": -0.0011282794325281169, + "expected_calibration_error_10bin": 0.0012938415975539948, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + { + "valid": 2754, + "positives": 22, + "negatives": 2732, + "auroc": 0.6772427791827499, + "auprc": 0.014806870195506555, + "brier": 0.0080015272846681, + "calibration": { + "observed_rate": 0.007988380537400145, + "mean_prediction": 0.007025234004192307, + "calibration_in_the_large": -0.0009631465332078379, + "expected_calibration_error_10bin": 0.0016440255892286846, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + { + "valid": 2754, + "positives": 25, + "negatives": 2729, + "auroc": 0.6666617808721144, + "auprc": 0.015890230072349007, + "brier": 0.009108544792777775, + "calibration": { + "observed_rate": 0.00907770515613653, + "mean_prediction": 0.007867426807146648, + "calibration_in_the_large": -0.0012102783489898808, + "expected_calibration_error_10bin": 0.002161635848653054, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + { + "valid": 2754, + "positives": 25, + "negatives": 2729, + "auroc": 0.6662074019787468, + "auprc": 0.015829919625294078, + "brier": 0.00912825379643671, + "calibration": { + "observed_rate": 0.00907770515613653, + "mean_prediction": 0.00825046920139583, + "calibration_in_the_large": -0.0008272359547406988, + "expected_calibration_error_10bin": 0.0019976289936794664, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + { + "valid": 2754, + "positives": 28, + "negatives": 2726, + "auroc": 0.6859212870768263, + "auprc": 0.020148341801461273, + "brier": 0.01017950231915649, + "calibration": { + "observed_rate": 0.010167029774872912, + "mean_prediction": 0.008866892604965091, + "calibration_in_the_large": -0.0013001371699078203, + "expected_calibration_error_10bin": 0.002608703601328728, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + { + "valid": 2754, + "positives": 29, + "negatives": 2725, + "auroc": 0.6941474217019931, + "auprc": 0.02157413421294873, + "brier": 0.010561483121245212, + "calibration": { + "observed_rate": 0.010530137981118372, + "mean_prediction": 0.0095040182415724, + "calibration_in_the_large": -0.001026119739545972, + "expected_calibration_error_10bin": 0.0028640901457742205, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + { + "valid": 2754, + "positives": 31, + "negatives": 2723, + "auroc": 0.7049032731925178, + "auprc": 0.024322227864769855, + "brier": 0.011262450851574348, + "calibration": { + "observed_rate": 0.011256354393609296, + "mean_prediction": 0.010018664266390684, + "calibration_in_the_large": -0.001237690127218612, + "expected_calibration_error_10bin": 0.003386653270278851, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + { + "valid": 2754, + "positives": 36, + "negatives": 2718, + "auroc": 0.7106430381816695, + "auprc": 0.02714512590129732, + "brier": 0.013040238216988098, + "calibration": { + "observed_rate": 0.013071895424836602, + "mean_prediction": 0.010403423092641497, + "calibration_in_the_large": -0.0026684723321951046, + "expected_calibration_error_10bin": 0.004320477171959632, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + { + "valid": 2754, + "positives": 37, + "negatives": 2717, + "auroc": 0.7151070835281361, + "auprc": 0.028159210991267013, + "brier": 0.013396442535134064, + "calibration": { + "observed_rate": 0.013435003631082063, + "mean_prediction": 0.010641207905140573, + "calibration_in_the_large": -0.002793795725941489, + "expected_calibration_error_10bin": 0.004497159809305003, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + { + "valid": 2754, + "positives": 39, + "negatives": 2715, + "auroc": 0.7097228124852434, + "auprc": 0.02890232760217863, + "brier": 0.01413339459043829, + "calibration": { + "observed_rate": 0.014161220043572984, + "mean_prediction": 0.011180166867123918, + "calibration_in_the_large": -0.0029810531764490663, + "expected_calibration_error_10bin": 0.005260688605961249, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + { + "valid": 2754, + "positives": 39, + "negatives": 2715, + "auroc": 0.7097133682769042, + "auprc": 0.02889807307032642, + "brier": 0.014135657564925037, + "calibration": { + "observed_rate": 0.014161220043572984, + "mean_prediction": 0.011235919813139605, + "calibration_in_the_large": -0.0029253002304333794, + "expected_calibration_error_10bin": 0.00521886314333973, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + } + ], + "reason": null + }, + "J91": { + "time_averaged_auroc": 0.8363319618203017, + "time_averaged_auprc": 0.054485270419366606, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2807, + "positives": 1, + "negatives": 2806, + "auroc": 0.8781183178902352, + "auprc": 0.0029154518950437317, + "brier": 0.0003614453661886305, + "calibration": { + "observed_rate": 0.0003562522265764161, + "mean_prediction": 0.0007128598549914857, + "calibration_in_the_large": 0.00035660762841506965, + "expected_calibration_error_10bin": 0.00035660762841506965, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 3, + "negatives": 2804, + "auroc": 0.9309320019020447, + "auprc": 0.01381799668213377, + "brier": 0.001086406083715097, + "calibration": { + "observed_rate": 0.0010687566797292483, + "mean_prediction": 0.0016462583230435854, + "calibration_in_the_large": 0.0005775016433143371, + "expected_calibration_error_10bin": 0.0005775016433143371, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 5, + "negatives": 2802, + "auroc": 0.7919343326195575, + "auprc": 0.014620378439359852, + "brier": 0.0018070451788437978, + "calibration": { + "observed_rate": 0.0017812611328820805, + "mean_prediction": 0.0021177275622410044, + "calibration_in_the_large": 0.00033646642935892396, + "expected_calibration_error_10bin": 0.00033646642935892396, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 7, + "negatives": 2800, + "auroc": 0.8266836734693878, + "auprc": 0.08928221409707725, + "brier": 0.0024270969174221774, + "calibration": { + "observed_rate": 0.0024937655860349127, + "mean_prediction": 0.0024745083290185605, + "calibration_in_the_large": -1.9257257016352166e-05, + "expected_calibration_error_10bin": 0.00021301417636985777, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 9, + "negatives": 2798, + "auroc": 0.8335318878564054, + "auprc": 0.0802306428835185, + "brier": 0.0031229250446408365, + "calibration": { + "observed_rate": 0.003206270039187745, + "mean_prediction": 0.0027254079705428414, + "calibration_in_the_large": -0.00048086206864490343, + "expected_calibration_error_10bin": 0.0004808620686449038, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.8239899892742224, + "auprc": 0.07436305731452462, + "brier": 0.0034775406320100644, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.002915846984686223, + "calibration_in_the_large": -0.000646675281077938, + "expected_calibration_error_10bin": 0.000646675281077938, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.8223096174472649, + "auprc": 0.07475535845826425, + "brier": 0.003476264655510439, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.0032436679361687337, + "calibration_in_the_large": -0.00031885432959542727, + "expected_calibration_error_10bin": 0.00036351315216196336, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.8236682159456561, + "auprc": 0.058306186185242456, + "brier": 0.0034868239457007976, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.003484066177828143, + "calibration_in_the_large": -7.845608793601803e-05, + "expected_calibration_error_10bin": 0.00026921133613318725, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.8220951018948873, + "auprc": 0.058351345756558294, + "brier": 0.0034945441063739214, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.003853804072593931, + "calibration_in_the_large": 0.0002912818068297701, + "expected_calibration_error_10bin": 0.0005528281559899918, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.8211297819091884, + "auprc": 0.057420386737955895, + "brier": 0.0035044253928727446, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.004047857637773179, + "calibration_in_the_large": 0.00048533537200901814, + "expected_calibration_error_10bin": 0.0007316778015054214, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 11, + "negatives": 2796, + "auroc": 0.835381714137079, + "auprc": 0.06271733679120152, + "brier": 0.0038368296815115056, + "calibration": { + "observed_rate": 0.003918774492340577, + "mean_prediction": 0.00425596884923046, + "calibration_in_the_large": 0.00033719435688988296, + "expected_calibration_error_10bin": 0.0005653293723218347, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 11, + "negatives": 2796, + "auroc": 0.8346338925738067, + "auprc": 0.06271839701293841, + "brier": 0.00384337387179132, + "calibration": { + "observed_rate": 0.003918774492340577, + "mean_prediction": 0.004457462992792802, + "calibration_in_the_large": 0.0005386885004522246, + "expected_calibration_error_10bin": 0.0007493850484527596, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 12, + "negatives": 2795, + "auroc": 0.827906976744186, + "auprc": 0.0588097631979474, + "brier": 0.004198161710500988, + "calibration": { + "observed_rate": 0.004275026718916993, + "mean_prediction": 0.004475225263832627, + "calibration_in_the_large": 0.00020019854491563384, + "expected_calibration_error_10bin": 0.0006390211043207646, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + } + ], + "reason": null + }, + "J94": { + "time_averaged_auroc": 0.7040174357878455, + "time_averaged_auprc": 0.08027187524476301, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2829, + "positives": 4, + "negatives": 2825, + "auroc": 0.7850442477876106, + "auprc": 0.008750719945388917, + "brier": 0.0014125109832975402, + "calibration": { + "observed_rate": 0.0014139271827500884, + "mean_prediction": 0.00024067819091171835, + "calibration_in_the_large": -0.0011732489918383701, + "expected_calibration_error_10bin": 0.0011732489918383701, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 4, + "negatives": 2825, + "auroc": 0.7456637168141593, + "auprc": 0.006673355675304402, + "brier": 0.0014145931851027502, + "calibration": { + "observed_rate": 0.0014139271827500884, + "mean_prediction": 0.0005782838252408233, + "calibration_in_the_large": -0.0008356433575092651, + "expected_calibration_error_10bin": 0.0008356433575092651, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 5, + "negatives": 2824, + "auroc": 0.6229461756373937, + "auprc": 0.005374572585098901, + "brier": 0.0017687020669474884, + "calibration": { + "observed_rate": 0.0017674089784376105, + "mean_prediction": 0.0006723376709240091, + "calibration_in_the_large": -0.0010950713075136014, + "expected_calibration_error_10bin": 0.0010950713075136014, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 5, + "negatives": 2824, + "auroc": 0.6208923512747876, + "auprc": 0.005281533629606827, + "brier": 0.001769896222424762, + "calibration": { + "observed_rate": 0.0017674089784376105, + "mean_prediction": 0.0007703073036183451, + "calibration_in_the_large": -0.0009971016748192654, + "expected_calibration_error_10bin": 0.0009971016748192654, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 8, + "negatives": 2821, + "auroc": 0.6693991492378589, + "auprc": 0.07000026029751459, + "brier": 0.0027947778655806, + "calibration": { + "observed_rate": 0.002827854365500177, + "mean_prediction": 0.0009065090070935483, + "calibration_in_the_large": -0.0019213453584066287, + "expected_calibration_error_10bin": 0.0019213453584066287, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 9, + "negatives": 2820, + "auroc": 0.6955870764381402, + "auprc": 0.12015984366499405, + "brier": 0.0031432087516096237, + "calibration": { + "observed_rate": 0.003181336161187699, + "mean_prediction": 0.0010199369456942655, + "calibration_in_the_large": -0.0021613992154934335, + "expected_calibration_error_10bin": 0.0021613992154934335, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 9, + "negatives": 2820, + "auroc": 0.6969267139479906, + "auprc": 0.12036641699690184, + "brier": 0.003139779268625396, + "calibration": { + "observed_rate": 0.003181336161187699, + "mean_prediction": 0.001216854802907025, + "calibration_in_the_large": -0.001964481358280674, + "expected_calibration_error_10bin": 0.001964481358280674, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 9, + "negatives": 2820, + "auroc": 0.6966115051221434, + "auprc": 0.1203918818790442, + "brier": 0.0031387537053849356, + "calibration": { + "observed_rate": 0.003181336161187699, + "mean_prediction": 0.0013333219531045171, + "calibration_in_the_large": -0.0018480142080831818, + "expected_calibration_error_10bin": 0.0018480142080831818, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 10, + "negatives": 2819, + "auroc": 0.72603760198652, + "auprc": 0.11759595484043965, + "brier": 0.003476364389289524, + "calibration": { + "observed_rate": 0.003534817956875221, + "mean_prediction": 0.001404369950246338, + "calibration_in_the_large": -0.0021304480066288833, + "expected_calibration_error_10bin": 0.0021304480066288833, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 10, + "negatives": 2819, + "auroc": 0.7241220290883292, + "auprc": 0.11740746972597542, + "brier": 0.0034752250812540813, + "calibration": { + "observed_rate": 0.003534817956875221, + "mean_prediction": 0.001496502869800411, + "calibration_in_the_large": -0.0020383150870748098, + "expected_calibration_error_10bin": 0.0020383150870748098, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 10, + "negatives": 2819, + "auroc": 0.7232351897836112, + "auprc": 0.11708284617170046, + "brier": 0.003474271236529347, + "calibration": { + "observed_rate": 0.003534817956875221, + "mean_prediction": 0.0015593460412298354, + "calibration_in_the_large": -0.0019754719156453854, + "expected_calibration_error_10bin": 0.0019754719156453854, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 10, + "negatives": 2819, + "auroc": 0.722880454061724, + "auprc": 0.11722127716077602, + "brier": 0.00347199259815047, + "calibration": { + "observed_rate": 0.003534817956875221, + "mean_prediction": 0.0016493899966850334, + "calibration_in_the_large": -0.0018854279601901876, + "expected_calibration_error_10bin": 0.0018854279601901876, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 10, + "negatives": 2819, + "auroc": 0.722880454061724, + "auprc": 0.11722824560917369, + "brier": 0.003471961755101846, + "calibration": { + "observed_rate": 0.003534817956875221, + "mean_prediction": 0.0016551150209159619, + "calibration_in_the_large": -0.0018797029359592591, + "expected_calibration_error_10bin": 0.0018797029359592591, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + } + ], + "reason": null + }, + "J95": { + "time_averaged_auroc": 0.8074823370176124, + "time_averaged_auprc": 0.029087457846768996, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2770, + "positives": 5, + "negatives": 2765, + "auroc": 0.8047739602169982, + "auprc": 0.01655526111459939, + "brier": 0.001798065598638669, + "calibration": { + "observed_rate": 0.0018050541516245488, + "mean_prediction": 0.0008469943413735764, + "calibration_in_the_large": -0.0009580598102509724, + "expected_calibration_error_10bin": 0.0009580598102509724, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + { + "valid": 2770, + "positives": 8, + "negatives": 2762, + "auroc": 0.7938540912382331, + "auprc": 0.01851749822788574, + "brier": 0.00286947871558962, + "calibration": { + "observed_rate": 0.002888086642599278, + "mean_prediction": 0.0017464350276931973, + "calibration_in_the_large": -0.0011416516149060805, + "expected_calibration_error_10bin": 0.0011416516149060805, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + { + "valid": 2770, + "positives": 11, + "negatives": 2759, + "auroc": 0.8045734620580579, + "auprc": 0.027085370462709243, + "brier": 0.003927838433476303, + "calibration": { + "observed_rate": 0.003971119133574007, + "mean_prediction": 0.002723783270155087, + "calibration_in_the_large": -0.0012473358634189202, + "expected_calibration_error_10bin": 0.0012473358634189202, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + { + "valid": 2770, + "positives": 11, + "negatives": 2759, + "auroc": 0.8017068107680648, + "auprc": 0.02626401419197867, + "brier": 0.003924741998768582, + "calibration": { + "observed_rate": 0.003971119133574007, + "mean_prediction": 0.0032203967618347914, + "calibration_in_the_large": -0.0007507223717392159, + "expected_calibration_error_10bin": 0.0007507223717392159, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + { + "valid": 2770, + "positives": 12, + "negatives": 2758, + "auroc": 0.8138747884940778, + "auprc": 0.031077866245722795, + "brier": 0.004273746348616705, + "calibration": { + "observed_rate": 0.004332129963898917, + "mean_prediction": 0.0036262792583798952, + "calibration_in_the_large": -0.0007058507055190217, + "expected_calibration_error_10bin": 0.0007058507055190217, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + { + "valid": 2770, + "positives": 12, + "negatives": 2758, + "auroc": 0.8113971476915639, + "auprc": 0.029982176305126864, + "brier": 0.004274534688101109, + "calibration": { + "observed_rate": 0.004332129963898917, + "mean_prediction": 0.003817796184098649, + "calibration_in_the_large": -0.0005143337798002678, + "expected_calibration_error_10bin": 0.0005143337798002678, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + { + "valid": 2770, + "positives": 12, + "negatives": 2758, + "auroc": 0.8106417693981146, + "auprc": 0.029742099256945, + "brier": 0.00427301965303762, + "calibration": { + "observed_rate": 0.004332129963898917, + "mean_prediction": 0.0043422060850353125, + "calibration_in_the_large": 1.0076121136395541e-05, + "expected_calibration_error_10bin": 1.0076121136395541e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + { + "valid": 2770, + "positives": 12, + "negatives": 2758, + "auroc": 0.8082547739908146, + "auprc": 0.02822692054321066, + "brier": 0.0042768017083546625, + "calibration": { + "observed_rate": 0.004332129963898917, + "mean_prediction": 0.004573165674560761, + "calibration_in_the_large": 0.00024103571066184416, + "expected_calibration_error_10bin": 0.00024103571066184422, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + { + "valid": 2770, + "positives": 13, + "negatives": 2757, + "auroc": 0.8194525822382188, + "auprc": 0.03162089058675103, + "brier": 0.004624596680602043, + "calibration": { + "observed_rate": 0.004693140794223827, + "mean_prediction": 0.005063009932870465, + "calibration_in_the_large": 0.00036986913864663854, + "expected_calibration_error_10bin": 0.00036986913864663887, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + { + "valid": 2770, + "positives": 14, + "negatives": 2756, + "auroc": 0.8182925565001037, + "auprc": 0.03046701671754601, + "brier": 0.004981434357132112, + "calibration": { + "observed_rate": 0.005054151624548736, + "mean_prediction": 0.0053539471150599064, + "calibration_in_the_large": 0.00029979549051117015, + "expected_calibration_error_10bin": 0.0002997954905111707, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + { + "valid": 2770, + "positives": 16, + "negatives": 2754, + "auroc": 0.804261982570806, + "auprc": 0.03621905844806106, + "brier": 0.005676253431151207, + "calibration": { + "observed_rate": 0.005776173285198556, + "mean_prediction": 0.00565015847339452, + "calibration_in_the_large": -0.00012601481180403527, + "expected_calibration_error_10bin": 0.00021777814208460175, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + { + "valid": 2770, + "positives": 16, + "negatives": 2754, + "auroc": 0.8031499636891793, + "auprc": 0.036217227770250236, + "brier": 0.005678450628374284, + "calibration": { + "observed_rate": 0.005776173285198556, + "mean_prediction": 0.005922658534973544, + "calibration_in_the_large": 0.00014648524977498804, + "expected_calibration_error_10bin": 0.00014648524977498755, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + { + "valid": 2770, + "positives": 16, + "negatives": 2754, + "auroc": 0.8030364923747276, + "auprc": 0.0361615521372103, + "brier": 0.005678576081296595, + "calibration": { + "observed_rate": 0.005776173285198556, + "mean_prediction": 0.005931148665587523, + "calibration_in_the_large": 0.00015497538038896762, + "expected_calibration_error_10bin": 0.00015497538038896752, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + } + ], + "reason": null + }, + "J96": { + "time_averaged_auroc": 0.8332432270559846, + "time_averaged_auprc": 0.08179304632708985, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2605, + "positives": 10, + "negatives": 2595, + "auroc": 0.8851252408477842, + "auprc": 0.020903133321551626, + "brier": 0.0038341780309674826, + "calibration": { + "observed_rate": 0.003838771593090211, + "mean_prediction": 0.00519884529300748, + "calibration_in_the_large": 0.001360073699917269, + "expected_calibration_error_10bin": 0.0013600736999172683, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + { + "valid": 2605, + "positives": 20, + "negatives": 2585, + "auroc": 0.8746615087040619, + "auprc": 0.036712310383738886, + "brier": 0.007647053238570983, + "calibration": { + "observed_rate": 0.007677543186180422, + "mean_prediction": 0.010456726225946011, + "calibration_in_the_large": 0.0027791830397655894, + "expected_calibration_error_10bin": 0.0027791830397655886, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + { + "valid": 2605, + "positives": 36, + "negatives": 2569, + "auroc": 0.842718740538904, + "auprc": 0.06048964892301082, + "brier": 0.01341505432649741, + "calibration": { + "observed_rate": 0.01381957773512476, + "mean_prediction": 0.013617421488949963, + "calibration_in_the_large": -0.00020215624617479604, + "expected_calibration_error_10bin": 0.002549847537528093, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + { + "valid": 2605, + "positives": 42, + "negatives": 2563, + "auroc": 0.8413317726622448, + "auprc": 0.06895860378272528, + "brier": 0.015600320637220404, + "calibration": { + "observed_rate": 0.016122840690978888, + "mean_prediction": 0.015762069597414646, + "calibration_in_the_large": -0.0003607710935642425, + "expected_calibration_error_10bin": 0.0025945926018583463, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + { + "valid": 2605, + "positives": 49, + "negatives": 2556, + "auroc": 0.8285426846795056, + "auprc": 0.07410829775850446, + "brier": 0.018135628059787714, + "calibration": { + "observed_rate": 0.018809980806142036, + "mean_prediction": 0.018199337860672144, + "calibration_in_the_large": -0.0006106429454698914, + "expected_calibration_error_10bin": 0.004114541681166094, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + { + "valid": 2605, + "positives": 54, + "negatives": 2551, + "auroc": 0.8233082160953584, + "auprc": 0.0806856281296844, + "brier": 0.019962288930254878, + "calibration": { + "observed_rate": 0.02072936660268714, + "mean_prediction": 0.02046476263509779, + "calibration_in_the_large": -0.0002646039675893476, + "expected_calibration_error_10bin": 0.004735424540967782, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + { + "valid": 2605, + "positives": 59, + "negatives": 2546, + "auroc": 0.8249830242187812, + "auprc": 0.08865538639804385, + "brier": 0.02173823414476131, + "calibration": { + "observed_rate": 0.022648752399232246, + "mean_prediction": 0.02231257174470401, + "calibration_in_the_large": -0.0003361806545282356, + "expected_calibration_error_10bin": 0.0050583058392701385, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + { + "valid": 2605, + "positives": 64, + "negatives": 2541, + "auroc": 0.819577676111767, + "auprc": 0.09485727999979543, + "brier": 0.02353520698302065, + "calibration": { + "observed_rate": 0.024568138195777352, + "mean_prediction": 0.023501503680570805, + "calibration_in_the_large": -0.001066634515206548, + "expected_calibration_error_10bin": 0.006541434752745035, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + { + "valid": 2605, + "positives": 68, + "negatives": 2537, + "auroc": 0.8227062997055345, + "auprc": 0.10298738314923334, + "brier": 0.0247904973850216, + "calibration": { + "observed_rate": 0.026103646833013437, + "mean_prediction": 0.02482847825492439, + "calibration_in_the_large": -0.0012751685780890455, + "expected_calibration_error_10bin": 0.005838507114994053, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + { + "valid": 2605, + "positives": 70, + "negatives": 2535, + "auroc": 0.8224852071005917, + "auprc": 0.10443593985930233, + "brier": 0.02560116429771178, + "calibration": { + "observed_rate": 0.026871401151631478, + "mean_prediction": 0.02617222282183294, + "calibration_in_the_large": -0.0006991783297985374, + "expected_calibration_error_10bin": 0.006515509440879124, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + { + "valid": 2605, + "positives": 76, + "negatives": 2529, + "auroc": 0.8170381469688456, + "auprc": 0.10758109355235716, + "brier": 0.027727546845185608, + "calibration": { + "observed_rate": 0.029174664107485603, + "mean_prediction": 0.02743360533165851, + "calibration_in_the_large": -0.0017410587758270937, + "expected_calibration_error_10bin": 0.008304437483288166, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + { + "valid": 2605, + "positives": 81, + "negatives": 2524, + "auroc": 0.8148735105945882, + "auprc": 0.11149129746758932, + "brier": 0.02949491833753483, + "calibration": { + "observed_rate": 0.03109404990403071, + "mean_prediction": 0.028515530975009074, + "calibration_in_the_large": -0.002578518929021636, + "expected_calibration_error_10bin": 0.008744434336304929, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + { + "valid": 2605, + "positives": 81, + "negatives": 2524, + "auroc": 0.8148099234998337, + "auprc": 0.11144359952663123, + "brier": 0.02951289698504888, + "calibration": { + "observed_rate": 0.03109404990403071, + "mean_prediction": 0.028774752290834513, + "calibration_in_the_large": -0.0023192976131961966, + "expected_calibration_error_10bin": 0.008890683787107119, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + } + ], + "reason": null + }, + "J98": { + "time_averaged_auroc": 0.7543216299986246, + "time_averaged_auprc": 0.04219518938655156, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2692, + "positives": 6, + "negatives": 2686, + "auroc": 0.7181062298337056, + "auprc": 0.00933788399912411, + "brier": 0.002219940363838606, + "calibration": { + "observed_rate": 0.002228826151560178, + "mean_prediction": 0.002577235236709725, + "calibration_in_the_large": 0.00034840908514954675, + "expected_calibration_error_10bin": 0.00034840908514954675, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + { + "valid": 2692, + "positives": 9, + "negatives": 2683, + "auroc": 0.7409201971259369, + "auprc": 0.01599445854177181, + "brier": 0.0033207658453438815, + "calibration": { + "observed_rate": 0.0033432392273402673, + "mean_prediction": 0.0043587552887567, + "calibration_in_the_large": 0.0010155160614164324, + "expected_calibration_error_10bin": 0.0010155160614164324, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + { + "valid": 2692, + "positives": 16, + "negatives": 2676, + "auroc": 0.7404007847533632, + "auprc": 0.0350235346299887, + "brier": 0.005882260948752032, + "calibration": { + "observed_rate": 0.005943536404160475, + "mean_prediction": 0.005928350381528437, + "calibration_in_the_large": -1.5186022632038103e-05, + "expected_calibration_error_10bin": 1.5186022632038103e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + { + "valid": 2692, + "positives": 20, + "negatives": 2672, + "auroc": 0.7220059880239521, + "auprc": 0.030373536756634352, + "brier": 0.007339500579860035, + "calibration": { + "observed_rate": 0.007429420505200594, + "mean_prediction": 0.006940311790336882, + "calibration_in_the_large": -0.0004891087148637119, + "expected_calibration_error_10bin": 0.0004891087148637119, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + { + "valid": 2692, + "positives": 20, + "negatives": 2672, + "auroc": 0.7199476047904192, + "auprc": 0.030101250344385676, + "brier": 0.007346294569315276, + "calibration": { + "observed_rate": 0.007429420505200594, + "mean_prediction": 0.007670334248220528, + "calibration_in_the_large": 0.00024091374301993436, + "expected_calibration_error_10bin": 0.00024091374301993436, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + { + "valid": 2692, + "positives": 27, + "negatives": 2665, + "auroc": 0.7387255923841289, + "auprc": 0.03672098025601927, + "brier": 0.009828886976024943, + "calibration": { + "observed_rate": 0.010029717682020803, + "mean_prediction": 0.0083130485072075, + "calibration_in_the_large": -0.0017166691748133033, + "expected_calibration_error_10bin": 0.0017962099735500195, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + { + "valid": 2692, + "positives": 29, + "negatives": 2663, + "auroc": 0.7559532287930387, + "auprc": 0.04730645415948463, + "brier": 0.010493664028045316, + "calibration": { + "observed_rate": 0.010772659732540862, + "mean_prediction": 0.008983340718519039, + "calibration_in_the_large": -0.001789319014021823, + "expected_calibration_error_10bin": 0.001873558283945491, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + { + "valid": 2692, + "positives": 31, + "negatives": 2661, + "auroc": 0.7687262852917288, + "auprc": 0.05400850868738112, + "brier": 0.011177173238832173, + "calibration": { + "observed_rate": 0.011515601783060922, + "mean_prediction": 0.009437201638354188, + "calibration_in_the_large": -0.002078400144706734, + "expected_calibration_error_10bin": 0.0022447861341934605, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + { + "valid": 2692, + "positives": 34, + "negatives": 2658, + "auroc": 0.7767782056389148, + "auprc": 0.057248139718523, + "brier": 0.012235291115021665, + "calibration": { + "observed_rate": 0.01263001485884101, + "mean_prediction": 0.01002518643787595, + "calibration_in_the_large": -0.0026048284209650614, + "expected_calibration_error_10bin": 0.0028641221264557467, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + { + "valid": 2692, + "positives": 35, + "negatives": 2657, + "auroc": 0.7792461960320447, + "auprc": 0.057207046499284556, + "brier": 0.012587786715271774, + "calibration": { + "observed_rate": 0.01300148588410104, + "mean_prediction": 0.01035688534942011, + "calibration_in_the_large": -0.00264460053468093, + "expected_calibration_error_10bin": 0.0029996111184341476, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + { + "valid": 2692, + "positives": 37, + "negatives": 2655, + "auroc": 0.780292156563343, + "auprc": 0.057457673456197275, + "brier": 0.013299717233133926, + "calibration": { + "observed_rate": 0.0137444279346211, + "mean_prediction": 0.010861823440407542, + "calibration_in_the_large": -0.0028826044942135576, + "expected_calibration_error_10bin": 0.002882604494213557, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + { + "valid": 2692, + "positives": 39, + "negatives": 2653, + "auroc": 0.7825973498796718, + "auprc": 0.05878670235200578, + "brier": 0.013995123590774788, + "calibration": { + "observed_rate": 0.01448736998514116, + "mean_prediction": 0.011430741027422664, + "calibration_in_the_large": -0.0030566289577184953, + "expected_calibration_error_10bin": 0.0033047725316895592, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + { + "valid": 2692, + "positives": 39, + "negatives": 2653, + "auroc": 0.7824813708718722, + "auprc": 0.058971292624369995, + "brier": 0.013994878983931912, + "calibration": { + "observed_rate": 0.01448736998514116, + "mean_prediction": 0.011502184138206396, + "calibration_in_the_large": -0.002985185846934763, + "expected_calibration_error_10bin": 0.003315820057276515, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + } + ], + "reason": null + }, + "K04": { + "time_averaged_auroc": 0.9459158940504506, + "time_averaged_auprc": 0.008971930649455857, + "valid_timepoint_cells": 10, + "timepoints": [ + { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 2.2863701698968914e-08, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 9.785956019137668e-05, + "calibration_in_the_large": 9.785956019137668e-05, + "expected_calibration_error_10bin": 9.785956019137668e-05, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 1.7756071751008106e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00019682331626520188, + "calibration_in_the_large": 0.00019682331626520188, + "expected_calibration_error_10bin": 0.00019682331626520188, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 4.1649769807934234e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0002960087323704031, + "calibration_in_the_large": 0.0002960087323704031, + "expected_calibration_error_10bin": 0.0002960087323704031, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 1, + "negatives": 2835, + "auroc": 0.9322751322751323, + "auprc": 0.0051813471502590676, + "brier": 0.0003526697654475311, + "calibration": { + "observed_rate": 0.0003526093088857546, + "mean_prediction": 0.0004319392043250839, + "calibration_in_the_large": 7.932989543932935e-05, + "expected_calibration_error_10bin": 7.932989543932935e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 1, + "negatives": 2835, + "auroc": 0.9361552028218695, + "auprc": 0.005494505494505495, + "brier": 0.00035285377177682526, + "calibration": { + "observed_rate": 0.0003526093088857546, + "mean_prediction": 0.0005583743598423644, + "calibration_in_the_large": 0.00020576505095660981, + "expected_calibration_error_10bin": 0.00020576505095660981, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 1, + "negatives": 2835, + "auroc": 0.9361552028218695, + "auprc": 0.005494505494505495, + "brier": 0.00035290363090598425, + "calibration": { + "observed_rate": 0.0003526093088857546, + "mean_prediction": 0.0005724466713893521, + "calibration_in_the_large": 0.00021983736250359752, + "expected_calibration_error_10bin": 0.00021983736250359752, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 1, + "negatives": 2835, + "auroc": 0.9389770723104056, + "auprc": 0.005747126436781609, + "brier": 0.0003532416931076946, + "calibration": { + "observed_rate": 0.0003526093088857546, + "mean_prediction": 0.0006491008662034137, + "calibration_in_the_large": 0.0002964915573176591, + "expected_calibration_error_10bin": 0.0002964915573176591, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9541284403669725, + "auprc": 0.011622422854062795, + "brier": 0.0007039222935082774, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.000739330471498712, + "calibration_in_the_large": 3.4111853727202836e-05, + "expected_calibration_error_10bin": 3.4111853727202836e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9527170077628794, + "auprc": 0.01134324532171238, + "brier": 0.0007040579685864985, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0008026264028567196, + "calibration_in_the_large": 9.740778508521048e-05, + "expected_calibration_error_10bin": 9.740778508521048e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9530698659139026, + "auprc": 0.011317135549872123, + "brier": 0.0007042634444175491, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0008916379267539168, + "calibration_in_the_large": 0.00018641930898240764, + "expected_calibration_error_10bin": 0.00018641930898240764, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.952364149611856, + "auprc": 0.011161547071259794, + "brier": 0.0007044640628635538, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0009225483453896839, + "calibration_in_the_large": 0.00021732972761817474, + "expected_calibration_error_10bin": 0.00021732972761817474, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9516584333098095, + "auprc": 0.011178735560799902, + "brier": 0.0007049587153110945, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0009933861085085524, + "calibration_in_the_large": 0.0002881674907370432, + "expected_calibration_error_10bin": 0.0002881674907370432, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9516584333098095, + "auprc": 0.011178735560799902, + "brier": 0.0007049726689106508, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0009965819422581524, + "calibration_in_the_large": 0.0002913633244866433, + "expected_calibration_error_10bin": 0.0002913633244866433, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + } + ], + "reason": null + }, + "K12": { + "time_averaged_auroc": 0.8837899706157094, + "time_averaged_auprc": 0.0824851273230367, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9950389794472005, + "auprc": 0.09583333333333333, + "brier": 0.0006838949497492594, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0003824403953416725, + "calibration_in_the_large": -0.0003257749021087525, + "expected_calibration_error_10bin": 0.0003257749021087525, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9953933380581148, + "auprc": 0.10101010101010101, + "brier": 0.0006990796813981522, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0014221554757683464, + "calibration_in_the_large": 0.0007139401783179214, + "expected_calibration_error_10bin": 0.0007139401783179213, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 5, + "negatives": 2819, + "auroc": 0.812273855977297, + "auprc": 0.06676756868066205, + "brier": 0.0018370774947265673, + "calibration": { + "observed_rate": 0.0017705382436260624, + "mean_prediction": 0.002340649365050252, + "calibration_in_the_large": 0.0005701111214241896, + "expected_calibration_error_10bin": 0.0011003149265554138, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 9, + "negatives": 2815, + "auroc": 0.8602723505032563, + "auprc": 0.07041282542644937, + "brier": 0.0033461185366774593, + "calibration": { + "observed_rate": 0.003186968838526912, + "mean_prediction": 0.003297151030337979, + "calibration_in_the_large": 0.00011018219181106693, + "expected_calibration_error_10bin": 0.002707124697373069, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 9, + "negatives": 2815, + "auroc": 0.8656798894809552, + "auprc": 0.07254891577648495, + "brier": 0.0033848531123592054, + "calibration": { + "observed_rate": 0.003186968838526912, + "mean_prediction": 0.0035503989995897436, + "calibration_in_the_large": 0.00036343016106283156, + "expected_calibration_error_10bin": 0.0026551876905598877, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 9, + "negatives": 2815, + "auroc": 0.8661930136175252, + "auprc": 0.07490499829972758, + "brier": 0.0034752109824254186, + "calibration": { + "observed_rate": 0.003186968838526912, + "mean_prediction": 0.0038769972464498966, + "calibration_in_the_large": 0.0006900284079229845, + "expected_calibration_error_10bin": 0.002570136190222514, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 10, + "negatives": 2814, + "auroc": 0.8520255863539445, + "auprc": 0.06858405654243291, + "brier": 0.003856846199950191, + "calibration": { + "observed_rate": 0.0035410764872521247, + "mean_prediction": 0.00398194920506532, + "calibration_in_the_large": 0.0004408727178131953, + "expected_calibration_error_10bin": 0.002902261229262737, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 13, + "negatives": 2811, + "auroc": 0.8822756752319185, + "auprc": 0.09119655345007954, + "brier": 0.0048477261906219255, + "calibration": { + "observed_rate": 0.004603399433427762, + "mean_prediction": 0.004258686043855313, + "calibration_in_the_large": -0.0003447133895724489, + "expected_calibration_error_10bin": 0.003534846360929464, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 14, + "negatives": 2810, + "auroc": 0.8729791560752415, + "auprc": 0.08634178169733649, + "brier": 0.005270315836221928, + "calibration": { + "observed_rate": 0.004957507082152974, + "mean_prediction": 0.004448951599597396, + "calibration_in_the_large": -0.0005085554825555788, + "expected_calibration_error_10bin": 0.0038197899798703885, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 14, + "negatives": 2810, + "auroc": 0.8723945094051856, + "auprc": 0.08626774680926723, + "brier": 0.005301952861970861, + "calibration": { + "observed_rate": 0.004957507082152974, + "mean_prediction": 0.004544501541366545, + "calibration_in_the_large": -0.00041300554078642967, + "expected_calibration_error_10bin": 0.003965320490142894, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 14, + "negatives": 2810, + "auroc": 0.8718861209964412, + "auprc": 0.08613995221588645, + "brier": 0.005334982503514403, + "calibration": { + "observed_rate": 0.004957507082152974, + "mean_prediction": 0.004682080911126533, + "calibration_in_the_large": -0.00027542617102644176, + "expected_calibration_error_10bin": 0.0039467663088309755, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 14, + "negatives": 2810, + "auroc": 0.8715048296898831, + "auprc": 0.0861278079270942, + "brier": 0.005371049335135227, + "calibration": { + "observed_rate": 0.004957507082152974, + "mean_prediction": 0.0048006081370741095, + "calibration_in_the_large": -0.00015689894507886493, + "expected_calibration_error_10bin": 0.004706195375414706, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 14, + "negatives": 2810, + "auroc": 0.8713523131672598, + "auprc": 0.08617101403062198, + "brier": 0.005376133565189349, + "calibration": { + "observed_rate": 0.004957507082152974, + "mean_prediction": 0.004824767729822079, + "calibration_in_the_large": -0.00013273935233089514, + "expected_calibration_error_10bin": 0.004695750380857759, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + } + ], + "reason": null + }, + "K20": { + "time_averaged_auroc": 0.7153056350875228, + "time_averaged_auprc": 0.04279969253141279, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2813, + "positives": 1, + "negatives": 2812, + "auroc": 0.802275960170697, + "auprc": 0.0017953321364452424, + "brier": 0.0003642167755053111, + "calibration": { + "observed_rate": 0.00035549235691432633, + "mean_prediction": 0.001473669762924314, + "calibration_in_the_large": 0.0011181774060099875, + "expected_calibration_error_10bin": 0.0011181774060099875, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 3, + "negatives": 2810, + "auroc": 0.7492289442467378, + "auprc": 0.0492972764821211, + "brier": 0.0010738410314242814, + "calibration": { + "observed_rate": 0.001066477070742979, + "mean_prediction": 0.0027562582179076556, + "calibration_in_the_large": 0.0016897811471646765, + "expected_calibration_error_10bin": 0.0016897811471646765, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 4, + "negatives": 2809, + "auroc": 0.6218405126379495, + "auprc": 0.04336019938801849, + "brier": 0.0014385937625744376, + "calibration": { + "observed_rate": 0.0014219694276573053, + "mean_prediction": 0.0033005222097693453, + "calibration_in_the_large": 0.00187855278211204, + "expected_calibration_error_10bin": 0.00187855278211204, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 4, + "negatives": 2809, + "auroc": 0.6266464934140263, + "auprc": 0.04335591984849321, + "brier": 0.0014539435049404014, + "calibration": { + "observed_rate": 0.0014219694276573053, + "mean_prediction": 0.004020892347001942, + "calibration_in_the_large": 0.0025989229193446365, + "expected_calibration_error_10bin": 0.0025989229193446365, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 5, + "negatives": 2808, + "auroc": 0.6876780626780626, + "auprc": 0.03800248299353189, + "brier": 0.0018134371357680932, + "calibration": { + "observed_rate": 0.0017774617845716318, + "mean_prediction": 0.004674344661515664, + "calibration_in_the_large": 0.002896882876944032, + "expected_calibration_error_10bin": 0.002896882876944032, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 5, + "negatives": 2808, + "auroc": 0.6873931623931624, + "auprc": 0.05458391308954291, + "brier": 0.0018236294430134638, + "calibration": { + "observed_rate": 0.0017774617845716318, + "mean_prediction": 0.0050301203488416464, + "calibration_in_the_large": 0.0032526585642700147, + "expected_calibration_error_10bin": 0.0032526585642700147, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 6, + "negatives": 2807, + "auroc": 0.730376439852749, + "auprc": 0.04944684858505657, + "brier": 0.002171206671238807, + "calibration": { + "observed_rate": 0.002132954141485958, + "mean_prediction": 0.00539228780779894, + "calibration_in_the_large": 0.0032593336663129815, + "expected_calibration_error_10bin": 0.0032593336663129815, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 7, + "negatives": 2806, + "auroc": 0.7665716322166786, + "auprc": 0.05132264052605618, + "brier": 0.0024977154969246587, + "calibration": { + "observed_rate": 0.002488446498400284, + "mean_prediction": 0.005650869177946686, + "calibration_in_the_large": 0.003162422679546402, + "expected_calibration_error_10bin": 0.003162422679546402, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 10, + "negatives": 2803, + "auroc": 0.7533357117374242, + "auprc": 0.041268318032276034, + "brier": 0.0035450631967282632, + "calibration": { + "observed_rate": 0.0035549235691432635, + "mean_prediction": 0.005878902803096479, + "calibration_in_the_large": 0.0023239792339532156, + "expected_calibration_error_10bin": 0.002323979233953215, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 10, + "negatives": 2803, + "auroc": 0.7535497681056011, + "auprc": 0.04918539186452875, + "brier": 0.00355469980769498, + "calibration": { + "observed_rate": 0.0035549235691432635, + "mean_prediction": 0.006202844197102564, + "calibration_in_the_large": 0.0026479206279593007, + "expected_calibration_error_10bin": 0.0026479206279593002, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 11, + "negatives": 2802, + "auroc": 0.7071896697164363, + "auprc": 0.045015759039742496, + "brier": 0.003917535257800752, + "calibration": { + "observed_rate": 0.0039104159260575895, + "mean_prediction": 0.006439674459399862, + "calibration_in_the_large": 0.0025292585333422726, + "expected_calibration_error_10bin": 0.002529258533342272, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 11, + "negatives": 2802, + "auroc": 0.7064434494841347, + "auprc": 0.044881016929356025, + "brier": 0.00392629795948282, + "calibration": { + "observed_rate": 0.0039104159260575895, + "mean_prediction": 0.006811870749006397, + "calibration_in_the_large": 0.0029014548229488075, + "expected_calibration_error_10bin": 0.0029014548229488075, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 11, + "negatives": 2802, + "auroc": 0.7064434494841347, + "auprc": 0.044880903993197344, + "brier": 0.003926514486215693, + "calibration": { + "observed_rate": 0.0039104159260575895, + "mean_prediction": 0.006820600808198241, + "calibration_in_the_large": 0.002910184882140652, + "expected_calibration_error_10bin": 0.0029101848821406514, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + } + ], + "reason": null + }, + "K21": { + "time_averaged_auroc": 0.7629747361040718, + "time_averaged_auprc": 0.1188690705738685, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2043, + "positives": 16, + "negatives": 2027, + "auroc": 0.7927972372964973, + "auprc": 0.04175925910499976, + "brier": 0.00768170515880947, + "calibration": { + "observed_rate": 0.00783162016642193, + "mean_prediction": 0.010125577836880954, + "calibration_in_the_large": 0.0022939576704590244, + "expected_calibration_error_10bin": 0.0022939576704590244, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + { + "valid": 2043, + "positives": 33, + "negatives": 2010, + "auroc": 0.8081863410221619, + "auprc": 0.09860084212793754, + "brier": 0.015412136591631515, + "calibration": { + "observed_rate": 0.016152716593245228, + "mean_prediction": 0.017306982326023627, + "calibration_in_the_large": 0.0011542657327783985, + "expected_calibration_error_10bin": 0.0016077719904606387, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + { + "valid": 2043, + "positives": 44, + "negatives": 1999, + "auroc": 0.7896561917322298, + "auprc": 0.09508610810461518, + "brier": 0.020368595504455363, + "calibration": { + "observed_rate": 0.021536955457660302, + "mean_prediction": 0.0226193384331894, + "calibration_in_the_large": 0.0010823829755290983, + "expected_calibration_error_10bin": 0.0022458544237346804, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + { + "valid": 2043, + "positives": 52, + "negatives": 1991, + "auroc": 0.7601514507591856, + "auprc": 0.1019000726797951, + "brier": 0.02399563065474201, + "calibration": { + "observed_rate": 0.025452765540871267, + "mean_prediction": 0.026387370266617475, + "calibration_in_the_large": 0.0009346047257462083, + "expected_calibration_error_10bin": 0.0021277081942285116, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + { + "valid": 2043, + "positives": 56, + "negatives": 1987, + "auroc": 0.760685527356388, + "auprc": 0.11007588932190503, + "brier": 0.025669691473959644, + "calibration": { + "observed_rate": 0.02741067058247675, + "mean_prediction": 0.029553299405469823, + "calibration_in_the_large": 0.0021426288229930736, + "expected_calibration_error_10bin": 0.002668491523606659, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + { + "valid": 2043, + "positives": 59, + "negatives": 1984, + "auroc": 0.7508201202843083, + "auprc": 0.10889413141641255, + "brier": 0.027048062385215094, + "calibration": { + "observed_rate": 0.02887909936368086, + "mean_prediction": 0.032516826895109825, + "calibration_in_the_large": 0.0036377275314289637, + "expected_calibration_error_10bin": 0.004170095205226774, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + { + "valid": 2043, + "positives": 67, + "negatives": 1976, + "auroc": 0.7655220859266421, + "auprc": 0.13507066860350334, + "brier": 0.03021225224884908, + "calibration": { + "observed_rate": 0.032794909446891826, + "mean_prediction": 0.03586417433157986, + "calibration_in_the_large": 0.0030692648846880333, + "expected_calibration_error_10bin": 0.003909823210062973, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + { + "valid": 2043, + "positives": 73, + "negatives": 1970, + "auroc": 0.7399485432167443, + "auprc": 0.13168563947577613, + "brier": 0.03302435427203448, + "calibration": { + "observed_rate": 0.03573176700930005, + "mean_prediction": 0.03810668238213015, + "calibration_in_the_large": 0.0023749153728300984, + "expected_calibration_error_10bin": 0.003975545097191688, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + { + "valid": 2043, + "positives": 76, + "negatives": 1967, + "auroc": 0.7451970674016001, + "auprc": 0.13420221853877914, + "brier": 0.034243365657562995, + "calibration": { + "observed_rate": 0.03720019579050416, + "mean_prediction": 0.04096981749083068, + "calibration_in_the_large": 0.0037696217003265198, + "expected_calibration_error_10bin": 0.004444495859709526, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + { + "valid": 2043, + "positives": 85, + "negatives": 1958, + "auroc": 0.7522201526167157, + "auprc": 0.1430975854141309, + "brier": 0.03792915248230752, + "calibration": { + "observed_rate": 0.041605482134116495, + "mean_prediction": 0.04294750801327707, + "calibration_in_the_large": 0.0013420258791605744, + "expected_calibration_error_10bin": 0.0021894533699765833, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + { + "valid": 2043, + "positives": 88, + "negatives": 1955, + "auroc": 0.7558939781446176, + "auprc": 0.14842433074202827, + "brier": 0.039106265259700825, + "calibration": { + "observed_rate": 0.043073910915320604, + "mean_prediction": 0.044745535061754396, + "calibration_in_the_large": 0.0016716241464337922, + "expected_calibration_error_10bin": 0.0026269056001195796, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + { + "valid": 2043, + "positives": 94, + "negatives": 1949, + "auroc": 0.7488073534709562, + "auprc": 0.1483026702754492, + "brier": 0.04171078252409507, + "calibration": { + "observed_rate": 0.04601076847772883, + "mean_prediction": 0.04696102359510386, + "calibration_in_the_large": 0.0009502551173750304, + "expected_calibration_error_10bin": 0.004037184525660471, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + { + "valid": 2043, + "positives": 94, + "negatives": 1949, + "auroc": 0.7487855201248867, + "auprc": 0.14819850165495818, + "brier": 0.04171568596034544, + "calibration": { + "observed_rate": 0.04601076847772883, + "mean_prediction": 0.04727210400672105, + "calibration_in_the_large": 0.0012613355289922204, + "expected_calibration_error_10bin": 0.00439026161065992, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + } + ], + "reason": null + }, + "K22": { + "time_averaged_auroc": 0.786278900619928, + "time_averaged_auprc": 0.026490505848937577, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2764, + "positives": 1, + "negatives": 2763, + "auroc": 0.9866087585957293, + "auprc": 0.02631578947368421, + "brier": 0.0003611573164167546, + "calibration": { + "observed_rate": 0.000361794500723589, + "mean_prediction": 0.0012797018795584884, + "calibration_in_the_large": 0.0009179073788348994, + "expected_calibration_error_10bin": 0.0009179073788348994, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + { + "valid": 2764, + "positives": 4, + "negatives": 2760, + "auroc": 0.7861413043478261, + "auprc": 0.038569890431295606, + "brier": 0.0014309263072730084, + "calibration": { + "observed_rate": 0.001447178002894356, + "mean_prediction": 0.0020830279143400207, + "calibration_in_the_large": 0.0006358499114456648, + "expected_calibration_error_10bin": 0.0006358499114456648, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + { + "valid": 2764, + "positives": 8, + "negatives": 2756, + "auroc": 0.8105043541364296, + "auprc": 0.02653839438286812, + "brier": 0.0028644428645763446, + "calibration": { + "observed_rate": 0.002894356005788712, + "mean_prediction": 0.0026733113151582266, + "calibration_in_the_large": -0.0002210446906304852, + "expected_calibration_error_10bin": 0.0002210446906304852, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + { + "valid": 2764, + "positives": 9, + "negatives": 2755, + "auroc": 0.7635813672111312, + "auprc": 0.022508690047564405, + "brier": 0.0032257065710135967, + "calibration": { + "observed_rate": 0.003256150506512301, + "mean_prediction": 0.0032571524071182676, + "calibration_in_the_large": 1.001900605966579e-06, + "expected_calibration_error_10bin": 1.001900605966579e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + { + "valid": 2764, + "positives": 13, + "negatives": 2751, + "auroc": 0.8160668847691749, + "auprc": 0.027039113511108083, + "brier": 0.004639159024013293, + "calibration": { + "observed_rate": 0.004703328509406657, + "mean_prediction": 0.003747112546781269, + "calibration_in_the_large": -0.0009562159626253881, + "expected_calibration_error_10bin": 0.0009562159626253881, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + { + "valid": 2764, + "positives": 14, + "negatives": 2750, + "auroc": 0.7938181818181819, + "auprc": 0.025616419891278434, + "brier": 0.004999553702427287, + "calibration": { + "observed_rate": 0.005065123010130246, + "mean_prediction": 0.003997822480892251, + "calibration_in_the_large": -0.0010673005292379948, + "expected_calibration_error_10bin": 0.0010673005292379948, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + { + "valid": 2764, + "positives": 14, + "negatives": 2750, + "auroc": 0.7937922077922078, + "auprc": 0.025417178390840494, + "brier": 0.004999430639860872, + "calibration": { + "observed_rate": 0.005065123010130246, + "mean_prediction": 0.004451875898682707, + "calibration_in_the_large": -0.0006132471114475386, + "expected_calibration_error_10bin": 0.0006132471114475386, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + { + "valid": 2764, + "positives": 15, + "negatives": 2749, + "auroc": 0.7739541651509639, + "auprc": 0.023909342863739066, + "brier": 0.005360191024507653, + "calibration": { + "observed_rate": 0.005426917510853835, + "mean_prediction": 0.004760597325021318, + "calibration_in_the_large": -0.0006663201858325167, + "expected_calibration_error_10bin": 0.0006663201858325167, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + { + "valid": 2764, + "positives": 17, + "negatives": 2747, + "auroc": 0.7356260305359857, + "auprc": 0.022708597144556968, + "brier": 0.006080040524177435, + "calibration": { + "observed_rate": 0.006150506512301013, + "mean_prediction": 0.005116872715328201, + "calibration_in_the_large": -0.0010336337969728123, + "expected_calibration_error_10bin": 0.0010336337969728123, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + { + "valid": 2764, + "positives": 18, + "negatives": 2746, + "auroc": 0.7487456502387311, + "auprc": 0.0261497469154495, + "brier": 0.00642343601198233, + "calibration": { + "observed_rate": 0.006512301013024602, + "mean_prediction": 0.00545575798331799, + "calibration_in_the_large": -0.0010565430297066122, + "expected_calibration_error_10bin": 0.0010565430297066122, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + { + "valid": 2764, + "positives": 19, + "negatives": 2745, + "auroc": 0.7593902789761289, + "auprc": 0.027404052354385266, + "brier": 0.00677490880604348, + "calibration": { + "observed_rate": 0.006874095513748191, + "mean_prediction": 0.005681514687552797, + "calibration_in_the_large": -0.0011925808261953937, + "expected_calibration_error_10bin": 0.0011925808261953937, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + { + "valid": 2764, + "positives": 21, + "negatives": 2743, + "auroc": 0.726646181622485, + "auprc": 0.026087079323537467, + "brier": 0.007493899384890816, + "calibration": { + "observed_rate": 0.007597684515195369, + "mean_prediction": 0.005988098066665321, + "calibration_in_the_large": -0.0016095864485300487, + "expected_calibration_error_10bin": 0.0016095864485300487, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + { + "valid": 2764, + "positives": 21, + "negatives": 2743, + "auroc": 0.7267503428640869, + "auprc": 0.02611228130588082, + "brier": 0.007493926002830866, + "calibration": { + "observed_rate": 0.007597684515195369, + "mean_prediction": 0.006011762121304305, + "calibration_in_the_large": -0.0015859223938910648, + "expected_calibration_error_10bin": 0.0015859223938910648, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + } + ], + "reason": null + }, + "K25": { + "time_averaged_auroc": 0.829352429042394, + "time_averaged_auprc": 0.010088103862517125, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2817, + "positives": 2, + "negatives": 2815, + "auroc": 0.9564831261101243, + "auprc": 0.011754911754911754, + "brier": 0.000708197752798189, + "calibration": { + "observed_rate": 0.0007099751508697196, + "mean_prediction": 0.000590478050238638, + "calibration_in_the_large": -0.00011949710063108158, + "expected_calibration_error_10bin": 0.00011949710063108158, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 2, + "negatives": 2815, + "auroc": 0.9360568383658969, + "auprc": 0.008149473265752336, + "brier": 0.0007124659223129658, + "calibration": { + "observed_rate": 0.0007099751508697196, + "mean_prediction": 0.001130671953462735, + "calibration_in_the_large": 0.0004206968025930154, + "expected_calibration_error_10bin": 0.0004206968025930154, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.9366263918502724, + "auprc": 0.010610947659002579, + "brier": 0.0010694971811733716, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.0017414585869988497, + "calibration_in_the_large": 0.0006764958606942702, + "expected_calibration_error_10bin": 0.0006764958606942702, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 5, + "negatives": 2812, + "auroc": 0.8810810810810811, + "auprc": 0.01191661193007099, + "brier": 0.0017941289836131918, + "calibration": { + "observed_rate": 0.001774937877174299, + "mean_prediction": 0.0023376981636747435, + "calibration_in_the_large": 0.0005627602865004445, + "expected_calibration_error_10bin": 0.0005627602865004448, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 5, + "negatives": 2812, + "auroc": 0.8812233285917497, + "auprc": 0.011794469393016201, + "brier": 0.001800569247378932, + "calibration": { + "observed_rate": 0.001774937877174299, + "mean_prediction": 0.0025468181132074228, + "calibration_in_the_large": 0.0007718802360331238, + "expected_calibration_error_10bin": 0.0007718802360331238, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 6, + "negatives": 2811, + "auroc": 0.791414680422151, + "auprc": 0.010232390975018367, + "brier": 0.002159138165928971, + "calibration": { + "observed_rate": 0.002129925452609159, + "mean_prediction": 0.0026995424761547043, + "calibration_in_the_large": 0.0005696170235455454, + "expected_calibration_error_10bin": 0.0005696170235455456, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 6, + "negatives": 2811, + "auroc": 0.791889007470651, + "auprc": 0.010084659192917048, + "brier": 0.002171341040085834, + "calibration": { + "observed_rate": 0.002129925452609159, + "mean_prediction": 0.0029407851609790123, + "calibration_in_the_large": 0.0008108597083698534, + "expected_calibration_error_10bin": 0.0008108597083698534, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 6, + "negatives": 2811, + "auroc": 0.7929562433297759, + "auprc": 0.010060322691845069, + "brier": 0.002175012880046203, + "calibration": { + "observed_rate": 0.002129925452609159, + "mean_prediction": 0.0030990634596412127, + "calibration_in_the_large": 0.0009691380070320538, + "expected_calibration_error_10bin": 0.0009691380070320539, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 6, + "negatives": 2811, + "auroc": 0.7933119886161508, + "auprc": 0.009912089158740455, + "brier": 0.0021888579794211837, + "calibration": { + "observed_rate": 0.002129925452609159, + "mean_prediction": 0.0033574815196657374, + "calibration_in_the_large": 0.0012275560670565785, + "expected_calibration_error_10bin": 0.0012275560670565785, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.7556176919166243, + "auprc": 0.009183124438044052, + "brier": 0.002547853224340045, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.0034647220575755398, + "calibration_in_the_large": 0.0009798090295315212, + "expected_calibration_error_10bin": 0.0009798090295315214, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.7542958820538892, + "auprc": 0.009117407579750799, + "brier": 0.002560340503299614, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.0037622479346967274, + "calibration_in_the_large": 0.0012773349066527088, + "expected_calibration_error_10bin": 0.0012773349066527088, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.7552618200305034, + "auprc": 0.009163676972608642, + "brier": 0.0025730088077824177, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.003979780186162986, + "calibration_in_the_large": 0.0014948671581189671, + "expected_calibration_error_10bin": 0.0014948671581189671, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.7553634977122522, + "auprc": 0.00916526520104434, + "brier": 0.002573392990927845, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.003989733859910835, + "calibration_in_the_large": 0.0015048208318668163, + "expected_calibration_error_10bin": 0.0015048208318668166, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + } + ], + "reason": null + }, + "K26": { + "time_averaged_auroc": 0.9158577688069592, + "time_averaged_auprc": 0.03685061923383815, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2814, + "positives": 0, + "negatives": 2814, + "auroc": null, + "auprc": null, + "brier": 4.199816556021665e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0003953584358154403, + "calibration_in_the_large": 0.0003953584358154403, + "expected_calibration_error_10bin": 0.0003953584358154403, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 2, + "negatives": 2812, + "auroc": 0.8902916073968705, + "auprc": 0.00985663082437276, + "brier": 0.0007090343308361954, + "calibration": { + "observed_rate": 0.0007107320540156361, + "mean_prediction": 0.0007714844240973811, + "calibration_in_the_large": 6.075237008174505e-05, + "expected_calibration_error_10bin": 6.075237008174505e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 3, + "negatives": 2811, + "auroc": 0.8910233606071386, + "auprc": 0.011381465745190758, + "brier": 0.0010623328908008938, + "calibration": { + "observed_rate": 0.0010660980810234541, + "mean_prediction": 0.0011256204177771928, + "calibration_in_the_large": 5.9522336753738614e-05, + "expected_calibration_error_10bin": 5.9522336753738614e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 3, + "negatives": 2811, + "auroc": 0.8948179769951381, + "auprc": 0.01072960111703089, + "brier": 0.0010624793687590978, + "calibration": { + "observed_rate": 0.0010660980810234541, + "mean_prediction": 0.0011862154240998828, + "calibration_in_the_large": 0.00012011734307642869, + "expected_calibration_error_10bin": 0.00012011734307642869, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 4, + "negatives": 2810, + "auroc": 0.9247330960854092, + "auprc": 0.06324857882253526, + "brier": 0.00140398476980456, + "calibration": { + "observed_rate": 0.0014214641080312722, + "mean_prediction": 0.001270989981697415, + "calibration_in_the_large": -0.00015047412633385727, + "expected_calibration_error_10bin": 0.00015047412633385727, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 5, + "negatives": 2809, + "auroc": 0.9285154859380562, + "auprc": 0.054207576154977274, + "brier": 0.001755381721647424, + "calibration": { + "observed_rate": 0.0017768301350390902, + "mean_prediction": 0.0013957871248219736, + "calibration_in_the_large": -0.0003810430102171166, + "expected_calibration_error_10bin": 0.0003810430102171166, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 5, + "negatives": 2809, + "auroc": 0.9298682805268779, + "auprc": 0.0536253842775582, + "brier": 0.0017543380932462302, + "calibration": { + "observed_rate": 0.0017768301350390902, + "mean_prediction": 0.0014882621293439335, + "calibration_in_the_large": -0.0002885680056951567, + "expected_calibration_error_10bin": 0.0002885680056951567, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 5, + "negatives": 2809, + "auroc": 0.9300818796724813, + "auprc": 0.053308597430788564, + "brier": 0.0017535374393633613, + "calibration": { + "observed_rate": 0.0017768301350390902, + "mean_prediction": 0.0016084895393954804, + "calibration_in_the_large": -0.00016834059564360985, + "expected_calibration_error_10bin": 0.00016834059564360985, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 6, + "negatives": 2808, + "auroc": 0.9200498575498576, + "auprc": 0.03753792841040996, + "brier": 0.0021064452645577986, + "calibration": { + "observed_rate": 0.0021321961620469083, + "mean_prediction": 0.0016890979215322408, + "calibration_in_the_large": -0.0004430982405146675, + "expected_calibration_error_10bin": 0.0004430982405146675, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 6, + "negatives": 2808, + "auroc": 0.9201092117758785, + "auprc": 0.03719763696428747, + "brier": 0.002106433499318009, + "calibration": { + "observed_rate": 0.0021321961620469083, + "mean_prediction": 0.0018049019505649913, + "calibration_in_the_large": -0.00032729421148191694, + "expected_calibration_error_10bin": 0.00032729421148191694, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 6, + "negatives": 2808, + "auroc": 0.9199905033238367, + "auprc": 0.037094977103786564, + "brier": 0.002106660082608574, + "calibration": { + "observed_rate": 0.0021321961620469083, + "mean_prediction": 0.0018650332908649763, + "calibration_in_the_large": -0.000267162871181932, + "expected_calibration_error_10bin": 0.000267162871181932, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 6, + "negatives": 2808, + "auroc": 0.920346628679962, + "auprc": 0.036997476164369096, + "brier": 0.0021070127934158856, + "calibration": { + "observed_rate": 0.0021321961620469083, + "mean_prediction": 0.0019211000295915404, + "calibration_in_the_large": -0.00021109613245536788, + "expected_calibration_error_10bin": 0.00021109613245536788, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 6, + "negatives": 2808, + "auroc": 0.9204653371320038, + "auprc": 0.03702157779075102, + "brier": 0.002106866394731074, + "calibration": { + "observed_rate": 0.0021321961620469083, + "mean_prediction": 0.0019435084384846035, + "calibration_in_the_large": -0.0001886877235623048, + "expected_calibration_error_10bin": 0.0001886877235623048, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + } + ], + "reason": null + }, + "K29": { + "time_averaged_auroc": 0.7801878449470521, + "time_averaged_auprc": 0.02197227988148828, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2785, + "positives": 0, + "negatives": 2785, + "auroc": null, + "auprc": null, + "brier": 1.5236636433029142e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.002333131529709752, + "calibration_in_the_large": 0.002333131529709752, + "expected_calibration_error_10bin": 0.002333131529709752, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 3, + "negatives": 2782, + "auroc": 0.8572969086987778, + "auprc": 0.011015061819651733, + "brier": 0.001091625260385584, + "calibration": { + "observed_rate": 0.0010771992818671453, + "mean_prediction": 0.0037108451539326183, + "calibration_in_the_large": 0.002633645872065473, + "expected_calibration_error_10bin": 0.002633645872065473, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.8869111830276879, + "auprc": 0.02650644180704915, + "brier": 0.0014460302983158532, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.004937586931263463, + "calibration_in_the_large": 0.003501321222107269, + "expected_calibration_error_10bin": 0.003501321222107269, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.8884394102840705, + "auprc": 0.030739645386085198, + "brier": 0.0014575889646033327, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.005518757849958887, + "calibration_in_the_large": 0.004082492140802693, + "expected_calibration_error_10bin": 0.004082492140802693, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.8183399304306105, + "auprc": 0.026164782785127766, + "brier": 0.0021742805662602273, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.006103644994912247, + "calibration_in_the_large": 0.003949246431177956, + "expected_calibration_error_10bin": 0.003949246431177956, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.8365730741540677, + "auprc": 0.02573619236464928, + "brier": 0.0025334074862622584, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.006512233343142999, + "calibration_in_the_large": 0.00399876835211966, + "expected_calibration_error_10bin": 0.00399876835211966, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 10, + "negatives": 2775, + "auroc": 0.7555315315315315, + "auprc": 0.021176225223876723, + "brier": 0.0036097896539523575, + "calibration": { + "observed_rate": 0.003590664272890485, + "mean_prediction": 0.006964831418797534, + "calibration_in_the_large": 0.0033741671459070494, + "expected_calibration_error_10bin": 0.00337416714590705, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 10, + "negatives": 2775, + "auroc": 0.7567927927927928, + "auprc": 0.021080669050627686, + "brier": 0.003626136996266434, + "calibration": { + "observed_rate": 0.003590664272890485, + "mean_prediction": 0.00744025448771508, + "calibration_in_the_large": 0.0038495902148245947, + "expected_calibration_error_10bin": 0.0038495902148245947, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 12, + "negatives": 2773, + "auroc": 0.7106623392234643, + "auprc": 0.0187090479537781, + "brier": 0.00435394937119264, + "calibration": { + "observed_rate": 0.004308797127468581, + "mean_prediction": 0.007903086188474179, + "calibration_in_the_large": 0.003594289061005598, + "expected_calibration_error_10bin": 0.0035942890610055974, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 13, + "negatives": 2772, + "auroc": 0.7019369519369519, + "auprc": 0.017807977592288856, + "brier": 0.004725357591468592, + "calibration": { + "observed_rate": 0.00466786355475763, + "mean_prediction": 0.008403049459529596, + "calibration_in_the_large": 0.003735185904771966, + "expected_calibration_error_10bin": 0.0037351859047719646, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 14, + "negatives": 2771, + "auroc": 0.7227664071763675, + "auprc": 0.022098295497092826, + "brier": 0.00505511636246869, + "calibration": { + "observed_rate": 0.005026929982046679, + "mean_prediction": 0.00872787151266645, + "calibration_in_the_large": 0.003700941530619772, + "expected_calibration_error_10bin": 0.003700941530619772, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 15, + "negatives": 2770, + "auroc": 0.7132851985559566, + "auprc": 0.0213085379209229, + "brier": 0.005422967309488124, + "calibration": { + "observed_rate": 0.005385996409335727, + "mean_prediction": 0.009037070378913633, + "calibration_in_the_large": 0.0036510739695779053, + "expected_calibration_error_10bin": 0.0036510739695779057, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 15, + "negatives": 2770, + "auroc": 0.7137184115523466, + "auprc": 0.021324481176709098, + "brier": 0.0054252228976037625, + "calibration": { + "observed_rate": 0.005385996409335727, + "mean_prediction": 0.00910687771934307, + "calibration_in_the_large": 0.0037208813100073432, + "expected_calibration_error_10bin": 0.003720881310007343, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + } + ], + "reason": null + }, + "K30": { + "time_averaged_auroc": 0.9345983272588778, + "time_averaged_auprc": 0.01034310603792288, + "valid_timepoint_cells": 11, + "timepoints": [ + { + "valid": 2837, + "positives": 0, + "negatives": 2837, + "auroc": null, + "auprc": null, + "brier": 7.299708055071312e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0003320003680728841, + "calibration_in_the_large": 0.0003320003680728841, + "expected_calibration_error_10bin": 0.0003320003680728841, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 0, + "negatives": 2837, + "auroc": null, + "auprc": null, + "brier": 2.907285881666394e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0006632802717037745, + "calibration_in_the_large": 0.0006632802717037745, + "expected_calibration_error_10bin": 0.0006632802717037745, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.9324514991181658, + "auprc": 0.00754994043166265, + "brier": 0.0007051743072273349, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0007900428245436968, + "calibration_in_the_large": 8.507278577034468e-05, + "expected_calibration_error_10bin": 8.507278577034468e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.9298059964726632, + "auprc": 0.007270520171496461, + "brier": 0.0007059466564950993, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0009136722731759171, + "calibration_in_the_large": 0.00020870223440256502, + "expected_calibration_error_10bin": 0.00020870223440256502, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.9291005291005291, + "auprc": 0.007195692648316812, + "brier": 0.0007066296871692661, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.001041750328339278, + "calibration_in_the_large": 0.0003367802895659259, + "expected_calibration_error_10bin": 0.0003367802895659259, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.928395061728395, + "auprc": 0.0071272745302196445, + "brier": 0.0007073065774854538, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0011225305002374052, + "calibration_in_the_large": 0.00041756046146405304, + "expected_calibration_error_10bin": 0.00041756046146405304, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.92663139329806, + "auprc": 0.006956234672703263, + "brier": 0.0007081267167487664, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0012100931130216263, + "calibration_in_the_large": 0.0005051230742482742, + "expected_calibration_error_10bin": 0.0005051230742482742, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.9261022927689594, + "auprc": 0.006913198350206224, + "brier": 0.0007088167128113148, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0012869245318503266, + "calibration_in_the_large": 0.0005819544930769745, + "expected_calibration_error_10bin": 0.0005819544930769745, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.9259259259259259, + "auprc": 0.006890173410404625, + "brier": 0.0007107457425982817, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0014015530567263797, + "calibration_in_the_large": 0.0006965830179530276, + "expected_calibration_error_10bin": 0.0006965830179530276, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 3, + "negatives": 2834, + "auroc": 0.9460127028934369, + "auprc": 0.01616897668493193, + "brier": 0.0010543326117371074, + "calibration": { + "observed_rate": 0.0010574550581600281, + "mean_prediction": 0.0015405193575913695, + "calibration_in_the_large": 0.00048306429943134133, + "expected_calibration_error_10bin": 0.00048306429943134133, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 3, + "negatives": 2834, + "auroc": 0.9460127028934369, + "auprc": 0.016176470588235296, + "brier": 0.001054938185163591, + "calibration": { + "observed_rate": 0.0010574550581600281, + "mean_prediction": 0.0016176130378493506, + "calibration_in_the_large": 0.0005601579796893224, + "expected_calibration_error_10bin": 0.0005601579796893224, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 3, + "negatives": 2834, + "auroc": 0.9451893672077158, + "auprc": 0.01586705415406493, + "brier": 0.0010552937741743723, + "calibration": { + "observed_rate": 0.0010574550581600281, + "mean_prediction": 0.0016566013770020203, + "calibration_in_the_large": 0.0005991463188419921, + "expected_calibration_error_10bin": 0.0005991463188419921, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + { + "valid": 2837, + "positives": 3, + "negatives": 2834, + "auroc": 0.944954128440367, + "auprc": 0.015658630774909844, + "brier": 0.0010554075536275374, + "calibration": { + "observed_rate": 0.0010574550581600281, + "mean_prediction": 0.001665229845892072, + "calibration_in_the_large": 0.0006077747877320438, + "expected_calibration_error_10bin": 0.0006077747877320438, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + } + ], + "reason": null + }, + "K31": { + "time_averaged_auroc": 0.9114288458146801, + "time_averaged_auprc": 0.06036554953820624, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2756, + "positives": 3, + "negatives": 2753, + "auroc": 0.8844896476571014, + "auprc": 0.059015344545311925, + "brier": 0.0010702556004241286, + "calibration": { + "observed_rate": 0.0010885341074020319, + "mean_prediction": 0.0011825737534290675, + "calibration_in_the_large": 9.403964602703566e-05, + "expected_calibration_error_10bin": 9.403964602703566e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 5, + "negatives": 2751, + "auroc": 0.9336241366775718, + "auprc": 0.06364568668906527, + "brier": 0.0017651686949308046, + "calibration": { + "observed_rate": 0.00181422351233672, + "mean_prediction": 0.002420759305980413, + "calibration_in_the_large": 0.0006065357936436931, + "expected_calibration_error_10bin": 0.0006065357936436928, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 7, + "negatives": 2749, + "auroc": 0.934521644234267, + "auprc": 0.06233819927598507, + "brier": 0.002465195995479605, + "calibration": { + "observed_rate": 0.0025399129172714078, + "mean_prediction": 0.0031584007997183506, + "calibration_in_the_large": 0.0006184878824469428, + "expected_calibration_error_10bin": 0.0006184878824469425, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 8, + "negatives": 2748, + "auroc": 0.9299945414847162, + "auprc": 0.05455057823405132, + "brier": 0.0028347448224550834, + "calibration": { + "observed_rate": 0.002902757619738752, + "mean_prediction": 0.0037892296655173347, + "calibration_in_the_large": 0.0008864720457785829, + "expected_calibration_error_10bin": 0.000978724302081354, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 10, + "negatives": 2746, + "auroc": 0.9290968681718864, + "auprc": 0.05201894740430309, + "brier": 0.003558908686868974, + "calibration": { + "observed_rate": 0.00362844702467344, + "mean_prediction": 0.004254850893287441, + "calibration_in_the_large": 0.0006264038686140008, + "expected_calibration_error_10bin": 0.0006264038686140008, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 11, + "negatives": 2745, + "auroc": 0.9194237456532538, + "auprc": 0.049058325610002236, + "brier": 0.003932178795951949, + "calibration": { + "observed_rate": 0.0039912917271407835, + "mean_prediction": 0.004740144712354546, + "calibration_in_the_large": 0.0007488529852137625, + "expected_calibration_error_10bin": 0.0007488529852137623, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 15, + "negatives": 2741, + "auroc": 0.9137297823178888, + "auprc": 0.05675444739755837, + "brier": 0.005323739725912118, + "calibration": { + "observed_rate": 0.00544267053701016, + "mean_prediction": 0.0051091960231450075, + "calibration_in_the_large": -0.0003334745138651521, + "expected_calibration_error_10bin": 0.0011336981159147347, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 17, + "negatives": 2739, + "auroc": 0.9180035650623886, + "auprc": 0.06271827673061463, + "brier": 0.00602406107615895, + "calibration": { + "observed_rate": 0.006168359941944848, + "mean_prediction": 0.005487078886693891, + "calibration_in_the_large": -0.0006812810552509563, + "expected_calibration_error_10bin": 0.0018741944554089183, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 18, + "negatives": 2738, + "auroc": 0.8960514568622677, + "auprc": 0.05991275006455261, + "brier": 0.006389579902461277, + "calibration": { + "observed_rate": 0.006531204644412192, + "mean_prediction": 0.005797389461170804, + "calibration_in_the_large": -0.0007338151832413879, + "expected_calibration_error_10bin": 0.0022241178915495203, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 18, + "negatives": 2738, + "auroc": 0.896112328544761, + "auprc": 0.058924020100211444, + "brier": 0.006398483918892318, + "calibration": { + "observed_rate": 0.006531204644412192, + "mean_prediction": 0.00608054211886495, + "calibration_in_the_large": -0.00045066252554724125, + "expected_calibration_error_10bin": 0.002116103798935806, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 19, + "negatives": 2737, + "auroc": 0.9021979501182624, + "auprc": 0.06967949936488975, + "brier": 0.0066892006087969245, + "calibration": { + "observed_rate": 0.006894049346879536, + "mean_prediction": 0.006515654185504676, + "calibration_in_the_large": -0.0003783951613748598, + "expected_calibration_error_10bin": 0.0015267586745358922, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 21, + "negatives": 2735, + "auroc": 0.8956211369374075, + "auprc": 0.06793857266686468, + "brier": 0.0074145947699873595, + "calibration": { + "observed_rate": 0.007619738751814224, + "mean_prediction": 0.006932111936200228, + "calibration_in_the_large": -0.0006876268156139958, + "expected_calibration_error_10bin": 0.001556802626818919, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 21, + "negatives": 2735, + "auroc": 0.8957081918690694, + "auprc": 0.06819749591327078, + "brier": 0.0074156139247549355, + "calibration": { + "observed_rate": 0.007619738751814224, + "mean_prediction": 0.006985107837492398, + "calibration_in_the_large": -0.0006346309143218255, + "expected_calibration_error_10bin": 0.0015144100155184959, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + } + ], + "reason": null + }, + "K40": { + "time_averaged_auroc": 0.8884975441490861, + "time_averaged_auprc": 0.05547025843523158, + "valid_timepoint_cells": 10, + "timepoints": [ + { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 1.8540080423035835e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.000318167915720924, + "calibration_in_the_large": 0.000318167915720924, + "expected_calibration_error_10bin": 0.000318167915720924, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 7.182831846685405e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0005747561755418452, + "calibration_in_the_large": 0.0005747561755418452, + "expected_calibration_error_10bin": 0.0005747561755418452, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 1.2205328875769027e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0007289577471919131, + "calibration_in_the_large": 0.0007289577471919131, + "expected_calibration_error_10bin": 0.0007289577471919131, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 1, + "negatives": 2826, + "auroc": 0.8789808917197452, + "auprc": 0.0029154518950437317, + "brier": 0.0003542124941861684, + "calibration": { + "observed_rate": 0.00035373187124159886, + "mean_prediction": 0.0008825609289600014, + "calibration_in_the_large": 0.0005288290577184025, + "expected_calibration_error_10bin": 0.0005288290577184025, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 2, + "negatives": 2825, + "auroc": 0.8585840707964602, + "auprc": 0.003661979333120273, + "brier": 0.0007070692264099782, + "calibration": { + "observed_rate": 0.0007074637424831977, + "mean_prediction": 0.0009959822997172164, + "calibration_in_the_large": 0.00028851855723401867, + "expected_calibration_error_10bin": 0.00028851855723401867, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 2, + "negatives": 2825, + "auroc": 0.8723893805309735, + "auprc": 0.004042190616948934, + "brier": 0.0007073743127097289, + "calibration": { + "observed_rate": 0.0007074637424831977, + "mean_prediction": 0.0011433124063343454, + "calibration_in_the_large": 0.00043584866385114763, + "expected_calibration_error_10bin": 0.00043584866385114763, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 3, + "negatives": 2824, + "auroc": 0.8916430594900849, + "auprc": 0.006225408547919034, + "brier": 0.0010594810119567478, + "calibration": { + "observed_rate": 0.0010611956137247967, + "mean_prediction": 0.0013506305846986367, + "calibration_in_the_large": 0.00028943497097384005, + "expected_calibration_error_10bin": 0.00028943497097384005, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 3, + "negatives": 2824, + "auroc": 0.8911709159584513, + "auprc": 0.006225767482391076, + "brier": 0.0010598656083307529, + "calibration": { + "observed_rate": 0.0010611956137247967, + "mean_prediction": 0.0014919375865594408, + "calibration_in_the_large": 0.0004307419728346441, + "expected_calibration_error_10bin": 0.0004307419728346441, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 3, + "negatives": 2824, + "auroc": 0.8914069877242682, + "auprc": 0.006236446156764882, + "brier": 0.001060222804616401, + "calibration": { + "observed_rate": 0.0010611956137247967, + "mean_prediction": 0.0015651838817925508, + "calibration_in_the_large": 0.0005039882680677541, + "expected_calibration_error_10bin": 0.0005039882680677541, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 3, + "negatives": 2824, + "auroc": 0.8868035882908404, + "auprc": 0.005980040858781065, + "brier": 0.001060710997133131, + "calibration": { + "observed_rate": 0.0010611956137247967, + "mean_prediction": 0.0016723098652243783, + "calibration_in_the_large": 0.0006111142514995816, + "expected_calibration_error_10bin": 0.0006111142514995816, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 3, + "negatives": 2824, + "auroc": 0.8877478753541076, + "auprc": 0.006036655320520722, + "brier": 0.0010610451417786978, + "calibration": { + "observed_rate": 0.0010611956137247967, + "mean_prediction": 0.0017481612477717667, + "calibration_in_the_large": 0.00068696563404697, + "expected_calibration_error_10bin": 0.00068696563404697, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 4, + "negatives": 2823, + "auroc": 0.9131243358129649, + "auprc": 0.2566890894709268, + "brier": 0.0013885808584222028, + "calibration": { + "observed_rate": 0.0014149274849663955, + "mean_prediction": 0.0019465838131268085, + "calibration_in_the_large": 0.000531656328160413, + "expected_calibration_error_10bin": 0.000531656328160413, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + { + "valid": 2827, + "positives": 4, + "negatives": 2823, + "auroc": 0.9131243358129649, + "auprc": 0.2566895546698993, + "brier": 0.0013884023395708564, + "calibration": { + "observed_rate": 0.0014149274849663955, + "mean_prediction": 0.001967511917709558, + "calibration_in_the_large": 0.0005525844327431625, + "expected_calibration_error_10bin": 0.0005525844327431625, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + } + ], + "reason": null + }, + "K42": { + "time_averaged_auroc": 0.7411362435369484, + "time_averaged_auprc": 0.01410617097598307, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2820, + "positives": 2, + "negatives": 2818, + "auroc": 0.6394606103619588, + "auprc": 0.008980649145680367, + "brier": 0.0007088685101876923, + "calibration": { + "observed_rate": 0.0007092198581560284, + "mean_prediction": 0.0002517920787427779, + "calibration_in_the_large": -0.0004574277794132505, + "expected_calibration_error_10bin": 0.0004574277794132505, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 2, + "negatives": 2818, + "auroc": 0.6910929737402413, + "auprc": 0.007949599887687772, + "brier": 0.0007091981395539393, + "calibration": { + "observed_rate": 0.0007092198581560284, + "mean_prediction": 0.0004480956660196906, + "calibration_in_the_large": -0.0002611241921363378, + "expected_calibration_error_10bin": 0.0002611241921363378, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 3, + "negatives": 2817, + "auroc": 0.6924624304815998, + "auprc": 0.006018801157690046, + "brier": 0.0010647138189448567, + "calibration": { + "observed_rate": 0.0010638297872340426, + "mean_prediction": 0.0005863534538696622, + "calibration_in_the_large": -0.0004774763333643804, + "expected_calibration_error_10bin": 0.0004774763333643804, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 3, + "negatives": 2817, + "auroc": 0.6846527038220329, + "auprc": 0.005508177841501218, + "brier": 0.0010674037300246676, + "calibration": { + "observed_rate": 0.0010638297872340426, + "mean_prediction": 0.0007120439127979904, + "calibration_in_the_large": -0.0003517858744360522, + "expected_calibration_error_10bin": 0.0003517858744360522, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 3, + "negatives": 2817, + "auroc": 0.665956691515797, + "auprc": 0.005313519139631718, + "brier": 0.0010683903258438807, + "calibration": { + "observed_rate": 0.0010638297872340426, + "mean_prediction": 0.0007875736251959317, + "calibration_in_the_large": -0.0002762561620381109, + "expected_calibration_error_10bin": 0.0002762561620381109, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 3, + "negatives": 2817, + "auroc": 0.6702165424210152, + "auprc": 0.005613337888199032, + "brier": 0.0010716030079502023, + "calibration": { + "observed_rate": 0.0010638297872340426, + "mean_prediction": 0.0009205560672053768, + "calibration_in_the_large": -0.00014327372002866578, + "expected_calibration_error_10bin": 0.00014327372002866578, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 5, + "negatives": 2815, + "auroc": 0.7763410301953819, + "auprc": 0.015442860091072073, + "brier": 0.001773640611479707, + "calibration": { + "observed_rate": 0.0017730496453900709, + "mean_prediction": 0.0010740647172239107, + "calibration_in_the_large": -0.0006989849281661602, + "expected_calibration_error_10bin": 0.0006989849281661602, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 5, + "negatives": 2815, + "auroc": 0.7732859680284192, + "auprc": 0.015279051286753467, + "brier": 0.0017760442172537211, + "calibration": { + "observed_rate": 0.0017730496453900709, + "mean_prediction": 0.0011599441163145058, + "calibration_in_the_large": -0.0006131055290755651, + "expected_calibration_error_10bin": 0.0006904997877556384, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 6, + "negatives": 2814, + "auroc": 0.8117744610281924, + "auprc": 0.024196694886350057, + "brier": 0.002122967700526854, + "calibration": { + "observed_rate": 0.002127659574468085, + "mean_prediction": 0.001262993104156773, + "calibration_in_the_large": -0.0008646664703113121, + "expected_calibration_error_10bin": 0.0009477550967755201, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 6, + "negatives": 2814, + "auroc": 0.8146173892442549, + "auprc": 0.023933317771240786, + "brier": 0.002123908354154119, + "calibration": { + "observed_rate": 0.002127659574468085, + "mean_prediction": 0.0013833628356404535, + "calibration_in_the_large": -0.0007442967388276316, + "expected_calibration_error_10bin": 0.0008321447221997584, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 7, + "negatives": 2813, + "auroc": 0.8057996038799452, + "auprc": 0.02166671055159793, + "brier": 0.0024789491164987623, + "calibration": { + "observed_rate": 0.0024822695035460994, + "mean_prediction": 0.001458735539287276, + "calibration_in_the_large": -0.0010235339642588235, + "expected_calibration_error_10bin": 0.0011151420759988274, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 7, + "negatives": 2813, + "auroc": 0.8046315575643695, + "auprc": 0.021739185329805448, + "brier": 0.0024795627903397306, + "calibration": { + "observed_rate": 0.0024822695035460994, + "mean_prediction": 0.0015385429857821774, + "calibration_in_the_large": -0.000943726517763922, + "expected_calibration_error_10bin": 0.0010374705577221722, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + { + "valid": 2820, + "positives": 7, + "negatives": 2813, + "auroc": 0.8044792036971206, + "auprc": 0.02173831771056998, + "brier": 0.002479593243966887, + "calibration": { + "observed_rate": 0.0024822695035460994, + "mean_prediction": 0.0015410450682593493, + "calibration_in_the_large": -0.0009412244352867501, + "expected_calibration_error_10bin": 0.0010350482017414872, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + } + ], + "reason": null + }, + "K43": { + "time_averaged_auroc": 0.8231524046398939, + "time_averaged_auprc": 0.01231713320738363, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2813, + "positives": 1, + "negatives": 2812, + "auroc": 0.9182076813655761, + "auprc": 0.004329004329004329, + "brier": 0.0003553120144970101, + "calibration": { + "observed_rate": 0.00035549235691432633, + "mean_prediction": 0.000197042225569235, + "calibration_in_the_large": -0.00015845013134509133, + "expected_calibration_error_10bin": 0.00015845013134509133, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 1, + "negatives": 2812, + "auroc": 0.9068278805120911, + "auprc": 0.0038022813688212928, + "brier": 0.0003554439765327709, + "calibration": { + "observed_rate": 0.00035549235691432633, + "mean_prediction": 0.00037840785305945764, + "calibration_in_the_large": 2.2915496145131306e-05, + "expected_calibration_error_10bin": 2.2915496145131306e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 2, + "negatives": 2811, + "auroc": 0.9308075418000712, + "auprc": 0.007530163035800062, + "brier": 0.0007101464966825509, + "calibration": { + "observed_rate": 0.0007109847138286527, + "mean_prediction": 0.0006486711643717346, + "calibration_in_the_large": -6.231354945691805e-05, + "expected_calibration_error_10bin": 6.231354945691805e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 4, + "negatives": 2809, + "auroc": 0.7733179067283731, + "auprc": 0.009462191840125372, + "brier": 0.0014199582139567924, + "calibration": { + "observed_rate": 0.0014219694276573053, + "mean_prediction": 0.0010541670204000308, + "calibration_in_the_large": -0.00036780240725727453, + "expected_calibration_error_10bin": 0.00036780240725727453, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 4, + "negatives": 2809, + "auroc": 0.7713599145603418, + "auprc": 0.009223143944350089, + "brier": 0.0014217137284241307, + "calibration": { + "observed_rate": 0.0014219694276573053, + "mean_prediction": 0.0012561596174508174, + "calibration_in_the_large": -0.0001658098102064879, + "expected_calibration_error_10bin": 0.0001658098102064879, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 4, + "negatives": 2809, + "auroc": 0.7657529369882521, + "auprc": 0.008458546248477323, + "brier": 0.0014248838265982805, + "calibration": { + "observed_rate": 0.0014219694276573053, + "mean_prediction": 0.001501657619042562, + "calibration_in_the_large": 7.968819138525667e-05, + "expected_calibration_error_10bin": 7.968819138525667e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 5, + "negatives": 2808, + "auroc": 0.8077635327635327, + "auprc": 0.014059077465391118, + "brier": 0.0017772604152047386, + "calibration": { + "observed_rate": 0.0017774617845716318, + "mean_prediction": 0.001929827385420686, + "calibration_in_the_large": 0.00015236560084905433, + "expected_calibration_error_10bin": 0.00015236560084905433, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 5, + "negatives": 2808, + "auroc": 0.805982905982906, + "auprc": 0.013937618762956336, + "brier": 0.001782822621681498, + "calibration": { + "observed_rate": 0.0017774617845716318, + "mean_prediction": 0.002242916531688999, + "calibration_in_the_large": 0.00046545474711736723, + "expected_calibration_error_10bin": 0.00046545474711736723, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 7, + "negatives": 2806, + "auroc": 0.7794012829650748, + "auprc": 0.014270908498874491, + "brier": 0.0024897638183009737, + "calibration": { + "observed_rate": 0.002488446498400284, + "mean_prediction": 0.0024166863034538605, + "calibration_in_the_large": -7.176019494642373e-05, + "expected_calibration_error_10bin": 7.176019494642373e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 9, + "negatives": 2804, + "auroc": 0.8113805674433349, + "auprc": 0.018666388477538116, + "brier": 0.003190954385191273, + "calibration": { + "observed_rate": 0.003199431212228937, + "mean_prediction": 0.002605680388185513, + "calibration_in_the_large": -0.0005937508240434243, + "expected_calibration_error_10bin": 0.0005937508240434243, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 9, + "negatives": 2804, + "auroc": 0.8120542082738944, + "auprc": 0.01884958679771539, + "brier": 0.0031928632924176953, + "calibration": { + "observed_rate": 0.003199431212228937, + "mean_prediction": 0.0028049236723925474, + "calibration_in_the_large": -0.00039450753983638967, + "expected_calibration_error_10bin": 0.00039450753983638967, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 9, + "negatives": 2804, + "auroc": 0.8091218893644001, + "auprc": 0.018794273101627026, + "brier": 0.0031997670387647237, + "calibration": { + "observed_rate": 0.003199431212228937, + "mean_prediction": 0.003174474389526527, + "calibration_in_the_large": -2.4956822702410127e-05, + "expected_calibration_error_10bin": 0.00010153039919055898, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 9, + "negatives": 2804, + "auroc": 0.8090030115707719, + "auprc": 0.018739547825306263, + "brier": 0.0032001128938522, + "calibration": { + "observed_rate": 0.003199431212228937, + "mean_prediction": 0.003192776111449441, + "calibration_in_the_large": -6.6551007794962355e-06, + "expected_calibration_error_10bin": 8.35550725567029e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + } + ], + "reason": null + }, + "K44": { + "time_averaged_auroc": 0.6006022801205106, + "time_averaged_auprc": 0.004815583650166559, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2785, + "positives": 1, + "negatives": 2784, + "auroc": 0.4353448275862069, + "auprc": 0.0006357279084551812, + "brier": 0.0003599576186545528, + "calibration": { + "observed_rate": 0.0003590664272890485, + "mean_prediction": 0.0006090467393350894, + "calibration_in_the_large": 0.0002499803120460409, + "expected_calibration_error_10bin": 0.0002499803120460409, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 2, + "negatives": 2783, + "auroc": 0.36543298598634566, + "auprc": 0.0008252252840538069, + "brier": 0.0007215485681440702, + "calibration": { + "observed_rate": 0.000718132854578097, + "mean_prediction": 0.0011515047818793196, + "calibration_in_the_large": 0.00043337192730122257, + "expected_calibration_error_10bin": 0.00043337192730122257, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.5469255663430421, + "auprc": 0.002431724236963865, + "brier": 0.0014381210092505319, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.0015261316732108456, + "calibration_in_the_large": 8.98659640546516e-05, + "expected_calibration_error_10bin": 8.98659640546516e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.5479144192736426, + "auprc": 0.0024031724056359244, + "brier": 0.001439754530853117, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.0017398178852812212, + "calibration_in_the_large": 0.0003035521761250272, + "expected_calibration_error_10bin": 0.0003035521761250272, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 5, + "negatives": 2780, + "auroc": 0.6303597122302158, + "auprc": 0.00531946210459588, + "brier": 0.001794899364484201, + "calibration": { + "observed_rate": 0.0017953321364452424, + "mean_prediction": 0.002012280769298646, + "calibration_in_the_large": 0.0002169486328534036, + "expected_calibration_error_10bin": 0.0002169486328534036, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 5, + "negatives": 2780, + "auroc": 0.6313669064748202, + "auprc": 0.005923533926876022, + "brier": 0.001795355840961527, + "calibration": { + "observed_rate": 0.0017953321364452424, + "mean_prediction": 0.0022352632828471896, + "calibration_in_the_large": 0.00043993114640194717, + "expected_calibration_error_10bin": 0.00043993114640194717, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 5, + "negatives": 2780, + "auroc": 0.6284172661870504, + "auprc": 0.005135569170644934, + "brier": 0.0017984439613030964, + "calibration": { + "observed_rate": 0.0017953321364452424, + "mean_prediction": 0.0025754255794860877, + "calibration_in_the_large": 0.0007800934430408453, + "expected_calibration_error_10bin": 0.0007800934430408453, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.6762624445244093, + "auprc": 0.00667417049024611, + "brier": 0.002153727035850765, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.0027547469018282173, + "calibration_in_the_large": 0.0006003483380939267, + "expected_calibration_error_10bin": 0.0006003483380939267, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.6763224181360201, + "auprc": 0.0066811668398478845, + "brier": 0.002155587509284849, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.0029850615453993093, + "calibration_in_the_large": 0.0008306629816650186, + "expected_calibration_error_10bin": 0.0008306629816650186, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.6759625764663548, + "auprc": 0.0068307762428136696, + "brier": 0.0021576175013005862, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.0031884728158097647, + "calibration_in_the_large": 0.001034074252075474, + "expected_calibration_error_10bin": 0.001034074252075474, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.663992594878124, + "auprc": 0.006584770940260538, + "brier": 0.0025163948582160346, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.0033139384118866222, + "calibration_in_the_large": 0.0008004734208632829, + "expected_calibration_error_10bin": 0.0008004734208632829, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.6646611128252597, + "auprc": 0.006582532766196143, + "brier": 0.0025192343482327087, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.0035205080730226507, + "calibration_in_the_large": 0.0010070430819993114, + "expected_calibration_error_10bin": 0.0010070430819993114, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.6648668106551476, + "auprc": 0.0065747551355753, + "brier": 0.002519535590788532, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.0035486195590706537, + "calibration_in_the_large": 0.0010351545680473144, + "expected_calibration_error_10bin": 0.0010351545680473144, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + } + ], + "reason": null + }, + "K52": { + "time_averaged_auroc": 0.8100106628389073, + "time_averaged_auprc": 0.10537255327830769, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2749, + "positives": 4, + "negatives": 2745, + "auroc": 0.8827868852459017, + "auprc": 0.021356367682728614, + "brier": 0.0014487190764558662, + "calibration": { + "observed_rate": 0.0014550745725718443, + "mean_prediction": 0.002101788894014085, + "calibration_in_the_large": 0.0006467143214422405, + "expected_calibration_error_10bin": 0.0006467143214422405, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + { + "valid": 2749, + "positives": 10, + "negatives": 2739, + "auroc": 0.8258853596202994, + "auprc": 0.12605558809349698, + "brier": 0.0036147135475836987, + "calibration": { + "observed_rate": 0.0036376864314296106, + "mean_prediction": 0.005128906768235192, + "calibration_in_the_large": 0.0014912203368055818, + "expected_calibration_error_10bin": 0.0014912203368055814, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + { + "valid": 2749, + "positives": 17, + "negatives": 2732, + "auroc": 0.8300964602532082, + "auprc": 0.10502195123862984, + "brier": 0.006033268430856109, + "calibration": { + "observed_rate": 0.0061840669334303384, + "mean_prediction": 0.006103209135097061, + "calibration_in_the_large": -8.085779833327724e-05, + "expected_calibration_error_10bin": 0.001518803261158924, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + { + "valid": 2749, + "positives": 23, + "negatives": 2726, + "auroc": 0.7892117770901783, + "auprc": 0.10714863654646878, + "brier": 0.008105243812675713, + "calibration": { + "observed_rate": 0.008366678792288106, + "mean_prediction": 0.007324037536524198, + "calibration_in_the_large": -0.0010426412557639078, + "expected_calibration_error_10bin": 0.0034441185677995347, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + { + "valid": 2749, + "positives": 26, + "negatives": 2723, + "auroc": 0.7973247831859657, + "auprc": 0.10410382727942488, + "brier": 0.00918765946335039, + "calibration": { + "observed_rate": 0.009457984721716987, + "mean_prediction": 0.00854268096253333, + "calibration_in_the_large": -0.0009153037591836579, + "expected_calibration_error_10bin": 0.0034137355659665473, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + { + "valid": 2749, + "positives": 28, + "negatives": 2721, + "auroc": 0.8010185331023258, + "auprc": 0.12413754274003108, + "brier": 0.00994632080176468, + "calibration": { + "observed_rate": 0.01018552200800291, + "mean_prediction": 0.009731361370281267, + "calibration_in_the_large": -0.0004541606377216432, + "expected_calibration_error_10bin": 0.003574668038986454, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + { + "valid": 2749, + "positives": 31, + "negatives": 2718, + "auroc": 0.8067839255619644, + "auprc": 0.11894719494800668, + "brier": 0.011025840425448089, + "calibration": { + "observed_rate": 0.011276827937431793, + "mean_prediction": 0.01039164440708532, + "calibration_in_the_large": -0.0008851835303464728, + "expected_calibration_error_10bin": 0.004301073766210926, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + { + "valid": 2749, + "positives": 33, + "negatives": 2716, + "auroc": 0.8033650198598652, + "auprc": 0.11654424593047814, + "brier": 0.011779197797122052, + "calibration": { + "observed_rate": 0.012004365223717716, + "mean_prediction": 0.011198070909072964, + "calibration_in_the_large": -0.000806294314644752, + "expected_calibration_error_10bin": 0.004187574963912499, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + { + "valid": 2749, + "positives": 35, + "negatives": 2714, + "auroc": 0.8024949994736288, + "auprc": 0.1149194736449171, + "brier": 0.01254322787899586, + "calibration": { + "observed_rate": 0.012731902510003638, + "mean_prediction": 0.012127430363710348, + "calibration_in_the_large": -0.00060447214629329, + "expected_calibration_error_10bin": 0.004689914176580027, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + { + "valid": 2749, + "positives": 35, + "negatives": 2714, + "auroc": 0.8028739867354459, + "auprc": 0.11323388970531509, + "brier": 0.012588303424713246, + "calibration": { + "observed_rate": 0.012731902510003638, + "mean_prediction": 0.01270429724298691, + "calibration_in_the_large": -2.7605267016728163e-05, + "expected_calibration_error_10bin": 0.004690589375759464, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + { + "valid": 2749, + "positives": 38, + "negatives": 2711, + "auroc": 0.7948513851948203, + "auprc": 0.10634832528428413, + "brier": 0.013688216742221159, + "calibration": { + "observed_rate": 0.013823208439432522, + "mean_prediction": 0.013232275487842119, + "calibration_in_the_large": -0.0005909329515904026, + "expected_calibration_error_10bin": 0.0059327921194068265, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + { + "valid": 2749, + "positives": 38, + "negatives": 2711, + "auroc": 0.7957541400531946, + "auprc": 0.10640428941232628, + "brier": 0.013784496291359817, + "calibration": { + "observed_rate": 0.013823208439432522, + "mean_prediction": 0.014125016528344265, + "calibration_in_the_large": 0.0003018080889117432, + "expected_calibration_error_10bin": 0.006279528393173758, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + { + "valid": 2749, + "positives": 39, + "negatives": 2710, + "auroc": 0.7976913615289999, + "auprc": 0.10562186011189227, + "brier": 0.014134752650054686, + "calibration": { + "observed_rate": 0.014186977082575483, + "mean_prediction": 0.014144667775349683, + "calibration_in_the_large": -4.230930722579941e-05, + "expected_calibration_error_10bin": 0.006631872222255562, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + } + ], + "reason": null + }, + "K55": { + "time_averaged_auroc": 0.7968279031327098, + "time_averaged_auprc": 0.009893522731904636, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2815, + "positives": 2, + "negatives": 2813, + "auroc": 0.9182367579097049, + "auprc": 0.00633844927247359, + "brier": 0.0007107915679473227, + "calibration": { + "observed_rate": 0.0007104795737122557, + "mean_prediction": 0.0007028865594834339, + "calibration_in_the_large": -7.593014228821863e-06, + "expected_calibration_error_10bin": 7.593014228821863e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 5, + "negatives": 2810, + "auroc": 0.8471174377224199, + "auprc": 0.01005675426406309, + "brier": 0.001772874950044458, + "calibration": { + "observed_rate": 0.0017761989342806395, + "mean_prediction": 0.0010444309221462522, + "calibration_in_the_large": -0.0007317680121343873, + "expected_calibration_error_10bin": 0.0007317680121343873, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 6, + "negatives": 2809, + "auroc": 0.7864008543965824, + "auprc": 0.008215198989473857, + "brier": 0.0021343205534114697, + "calibration": { + "observed_rate": 0.0021314387211367673, + "mean_prediction": 0.0015032544066338842, + "calibration_in_the_large": -0.0006281843145028831, + "expected_calibration_error_10bin": 0.0006281843145028831, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 7, + "negatives": 2808, + "auroc": 0.7956857956857957, + "auprc": 0.008983171579173539, + "brier": 0.0024911076206729976, + "calibration": { + "observed_rate": 0.002486678507992895, + "mean_prediction": 0.0017422896426927002, + "calibration_in_the_large": -0.0007443888653001949, + "expected_calibration_error_10bin": 0.0007443888653001949, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 8, + "negatives": 2807, + "auroc": 0.8072230138938369, + "auprc": 0.01024047571824811, + "brier": 0.00284885422000391, + "calibration": { + "observed_rate": 0.002841918294849023, + "mean_prediction": 0.0020155089601321765, + "calibration_in_the_large": -0.0008264093347168464, + "expected_calibration_error_10bin": 0.0009075530071873592, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 8, + "negatives": 2807, + "auroc": 0.8071784823655148, + "auprc": 0.010188349697808918, + "brier": 0.0028515320370524067, + "calibration": { + "observed_rate": 0.002841918294849023, + "mean_prediction": 0.002328197937565696, + "calibration_in_the_large": -0.0005137203572833271, + "expected_calibration_error_10bin": 0.0005987688115527499, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 8, + "negatives": 2807, + "auroc": 0.807401140007125, + "auprc": 0.01024695269674314, + "brier": 0.00285618193705437, + "calibration": { + "observed_rate": 0.002841918294849023, + "mean_prediction": 0.002578918693960442, + "calibration_in_the_large": -0.00026299960088858095, + "expected_calibration_error_10bin": 0.00035565601636716737, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 8, + "negatives": 2807, + "auroc": 0.8078909868186677, + "auprc": 0.01031657224481832, + "brier": 0.002859580594389408, + "calibration": { + "observed_rate": 0.002841918294849023, + "mean_prediction": 0.002727134977204816, + "calibration_in_the_large": -0.00011478331764420676, + "expected_calibration_error_10bin": 0.00028436918252266997, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 8, + "negatives": 2807, + "auroc": 0.809093338083363, + "auprc": 0.010425444405385086, + "brier": 0.002865043213782668, + "calibration": { + "observed_rate": 0.002841918294849023, + "mean_prediction": 0.0029349752406460945, + "calibration_in_the_large": 9.305694579707152e-05, + "expected_calibration_error_10bin": 9.305694579707119e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 9, + "negatives": 2806, + "auroc": 0.7283994614714501, + "auprc": 0.009660906286394877, + "brier": 0.0032236002293400496, + "calibration": { + "observed_rate": 0.003197158081705151, + "mean_prediction": 0.0030714097234777584, + "calibration_in_the_large": -0.0001257483582273928, + "expected_calibration_error_10bin": 0.0003831312084678258, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 10, + "negatives": 2805, + "auroc": 0.7479857397504456, + "auprc": 0.011345931619085647, + "brier": 0.0035783633909417406, + "calibration": { + "observed_rate": 0.003552397868561279, + "mean_prediction": 0.0032210247922374886, + "calibration_in_the_large": -0.00033137307632379043, + "expected_calibration_error_10bin": 0.0006814826554084, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 10, + "negatives": 2805, + "auroc": 0.7480213903743316, + "auprc": 0.011292913386803622, + "brier": 0.0035867586261568644, + "calibration": { + "observed_rate": 0.003552397868561279, + "mean_prediction": 0.003416906343841502, + "calibration_in_the_large": -0.00013549152471977691, + "expected_calibration_error_10bin": 0.0005144359464659443, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + { + "valid": 2815, + "positives": 10, + "negatives": 2805, + "auroc": 0.7481283422459893, + "auprc": 0.011304675354288446, + "brier": 0.0035869071457723155, + "calibration": { + "observed_rate": 0.003552397868561279, + "mean_prediction": 0.00342189567870957, + "calibration_in_the_large": -0.0001305021898517088, + "expected_calibration_error_10bin": 0.0005098648286995747, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + } + ], + "reason": null + }, + "K56": { + "time_averaged_auroc": 0.7432620943346463, + "time_averaged_auprc": 0.03862792134705103, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2745, + "positives": 7, + "negatives": 2738, + "auroc": 0.7765835333402901, + "auprc": 0.026069019567502648, + "brier": 0.002525634049738755, + "calibration": { + "observed_rate": 0.0025500910746812386, + "mean_prediction": 0.0026776129013075423, + "calibration_in_the_large": 0.00012752182662630366, + "expected_calibration_error_10bin": 0.00012752182662630366, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + { + "valid": 2745, + "positives": 10, + "negatives": 2735, + "auroc": 0.6761243144424132, + "auprc": 0.024210505281608636, + "brier": 0.0036208146046667654, + "calibration": { + "observed_rate": 0.0036429872495446266, + "mean_prediction": 0.004910225607778152, + "calibration_in_the_large": 0.0012672383582335257, + "expected_calibration_error_10bin": 0.0012672383582335257, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + { + "valid": 2745, + "positives": 15, + "negatives": 2730, + "auroc": 0.7506471306471306, + "auprc": 0.028006046590561117, + "brier": 0.005391834777907758, + "calibration": { + "observed_rate": 0.00546448087431694, + "mean_prediction": 0.005993409300344286, + "calibration_in_the_large": 0.0005289284260273459, + "expected_calibration_error_10bin": 0.0005289284260273459, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + { + "valid": 2745, + "positives": 19, + "negatives": 2726, + "auroc": 0.7141753871104761, + "auprc": 0.026459129396209254, + "brier": 0.0068448773205373485, + "calibration": { + "observed_rate": 0.0069216757741347905, + "mean_prediction": 0.007965601940078658, + "calibration_in_the_large": 0.0010439261659438677, + "expected_calibration_error_10bin": 0.0010439261659438664, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + { + "valid": 2745, + "positives": 21, + "negatives": 2724, + "auroc": 0.7350534927627439, + "auprc": 0.03178256036869932, + "brier": 0.0075358319261249335, + "calibration": { + "observed_rate": 0.007650273224043716, + "mean_prediction": 0.009019041017348028, + "calibration_in_the_large": 0.001368767793304312, + "expected_calibration_error_10bin": 0.0013687677933043128, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + { + "valid": 2745, + "positives": 23, + "negatives": 2722, + "auroc": 0.7405360508577452, + "auprc": 0.03255326889022824, + "brier": 0.008246425345938125, + "calibration": { + "observed_rate": 0.008378870673952642, + "mean_prediction": 0.009642642713681997, + "calibration_in_the_large": 0.001263772039729355, + "expected_calibration_error_10bin": 0.0012637720397293553, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + { + "valid": 2745, + "positives": 26, + "negatives": 2719, + "auroc": 0.7467394686960704, + "auprc": 0.03725709088757194, + "brier": 0.009298544396123114, + "calibration": { + "observed_rate": 0.00947176684881603, + "mean_prediction": 0.010685084555306573, + "calibration_in_the_large": 0.0012133177064905434, + "expected_calibration_error_10bin": 0.0012133177064905431, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + { + "valid": 2745, + "positives": 27, + "negatives": 2718, + "auroc": 0.756820101926798, + "auprc": 0.048017893524370234, + "brier": 0.009589061067113809, + "calibration": { + "observed_rate": 0.009836065573770493, + "mean_prediction": 0.011314757976902373, + "calibration_in_the_large": 0.0014786924031318805, + "expected_calibration_error_10bin": 0.0017189719988404686, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + { + "valid": 2745, + "positives": 27, + "negatives": 2718, + "auroc": 0.7561660262175347, + "auprc": 0.04853721857153285, + "brier": 0.009606295268192856, + "calibration": { + "observed_rate": 0.009836065573770493, + "mean_prediction": 0.012240535178296404, + "calibration_in_the_large": 0.0024044696045259113, + "expected_calibration_error_10bin": 0.0024044696045259118, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + { + "valid": 2745, + "positives": 30, + "negatives": 2715, + "auroc": 0.7515899324739104, + "auprc": 0.049259652885994196, + "brier": 0.010656257476600168, + "calibration": { + "observed_rate": 0.01092896174863388, + "mean_prediction": 0.01268146505709975, + "calibration_in_the_large": 0.00175250330846587, + "expected_calibration_error_10bin": 0.0017525033084658701, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + { + "valid": 2745, + "positives": 30, + "negatives": 2715, + "auroc": 0.7510374462860651, + "auprc": 0.04902077661465708, + "brier": 0.010669892952898734, + "calibration": { + "observed_rate": 0.01092896174863388, + "mean_prediction": 0.01335294423385257, + "calibration_in_the_large": 0.0024239824852186898, + "expected_calibration_error_10bin": 0.0024239824852186898, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + { + "valid": 2745, + "positives": 32, + "negatives": 2713, + "auroc": 0.7565656100258017, + "auprc": 0.05106484711294311, + "brier": 0.011355414770723809, + "calibration": { + "observed_rate": 0.011657559198542805, + "mean_prediction": 0.013971161173647252, + "calibration_in_the_large": 0.002313601975104447, + "expected_calibration_error_10bin": 0.002313601975104447, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + { + "valid": 2745, + "positives": 33, + "negatives": 2712, + "auroc": 0.7503687315634219, + "auprc": 0.04992496781978464, + "brier": 0.011715800343467978, + "calibration": { + "observed_rate": 0.012021857923497269, + "mean_prediction": 0.01403243223784953, + "calibration_in_the_large": 0.0020105743143522606, + "expected_calibration_error_10bin": 0.002010574314352261, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + } + ], + "reason": null + }, + "K57": { + "time_averaged_auroc": 0.6820480147352256, + "time_averaged_auprc": 0.016164474411138025, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2741, + "positives": 3, + "negatives": 2738, + "auroc": 0.7303384465546627, + "auprc": 0.0034441643519407573, + "brier": 0.0010954755080191264, + "calibration": { + "observed_rate": 0.0010944910616563297, + "mean_prediction": 0.0012257789708541122, + "calibration_in_the_large": 0.0001312879091977825, + "expected_calibration_error_10bin": 0.0001312879091977825, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 4, + "negatives": 2737, + "auroc": 0.5902447935696018, + "auprc": 0.0029133926817601166, + "brier": 0.0014681357766741844, + "calibration": { + "observed_rate": 0.001459321415541773, + "mean_prediction": 0.0020160737859703523, + "calibration_in_the_large": 0.0005567523704285793, + "expected_calibration_error_10bin": 0.0005567523704285793, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 10, + "negatives": 2731, + "auroc": 0.6845477846942511, + "auprc": 0.0070905514112245965, + "brier": 0.003647781686924249, + "calibration": { + "observed_rate": 0.0036483035388544327, + "mean_prediction": 0.002467992241929049, + "calibration_in_the_large": -0.0011803112969253839, + "expected_calibration_error_10bin": 0.0011803112969253839, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 12, + "negatives": 2729, + "auroc": 0.6262367167460609, + "auprc": 0.0069704861427945354, + "brier": 0.004384325407091556, + "calibration": { + "observed_rate": 0.004377964246625319, + "mean_prediction": 0.002925200283559828, + "calibration_in_the_large": -0.0014527639630654908, + "expected_calibration_error_10bin": 0.0014527639630654908, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 16, + "negatives": 2725, + "auroc": 0.7044724770642202, + "auprc": 0.017148775176867942, + "brier": 0.005798902434073038, + "calibration": { + "observed_rate": 0.005837285662167092, + "mean_prediction": 0.003398398444387494, + "calibration_in_the_large": -0.002438887217779598, + "expected_calibration_error_10bin": 0.002438887217779598, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 18, + "negatives": 2723, + "auroc": 0.6652997102868569, + "auprc": 0.016359479183249835, + "brier": 0.00652994289609877, + "calibration": { + "observed_rate": 0.006566946369937978, + "mean_prediction": 0.003813381185479704, + "calibration_in_the_large": -0.0027535651844582745, + "expected_calibration_error_10bin": 0.002831323950339983, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 20, + "negatives": 2721, + "auroc": 0.6835170893054024, + "auprc": 0.018616139214743716, + "brier": 0.007248640019702274, + "calibration": { + "observed_rate": 0.0072966070777088655, + "mean_prediction": 0.004288508504286674, + "calibration_in_the_large": -0.0030080985734221915, + "expected_calibration_error_10bin": 0.003099781781299071, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 22, + "negatives": 2719, + "auroc": 0.6868501120064194, + "auprc": 0.02098649403721724, + "brier": 0.00796266480925514, + "calibration": { + "observed_rate": 0.008026267785479753, + "mean_prediction": 0.004336817700752428, + "calibration_in_the_large": -0.0036894500847273245, + "expected_calibration_error_10bin": 0.0037828038644494794, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 22, + "negatives": 2719, + "auroc": 0.6879868935771841, + "auprc": 0.021150096212292645, + "brier": 0.007962985947881883, + "calibration": { + "observed_rate": 0.008026267785479753, + "mean_prediction": 0.004648650798964606, + "calibration_in_the_large": -0.0033776169865151464, + "expected_calibration_error_10bin": 0.0034803158655726876, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 23, + "negatives": 2718, + "auroc": 0.6833509293918162, + "auprc": 0.020998958180358265, + "brier": 0.008327306286098849, + "calibration": { + "observed_rate": 0.008391098139365194, + "mean_prediction": 0.00498983090033288, + "calibration_in_the_large": -0.0034012672390323143, + "expected_calibration_error_10bin": 0.003510370072873077, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 25, + "negatives": 2716, + "auroc": 0.7024447717231223, + "auprc": 0.02400730783798135, + "brier": 0.009037522015303662, + "calibration": { + "observed_rate": 0.009120758847136081, + "mean_prediction": 0.005266601364932761, + "calibration_in_the_large": -0.0038541574822033202, + "expected_calibration_error_10bin": 0.0040496417059900985, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 26, + "negatives": 2715, + "auroc": 0.7106105680691316, + "auprc": 0.02521007971965393, + "brier": 0.009392613190457743, + "calibration": { + "observed_rate": 0.009485589201021525, + "mean_prediction": 0.0056967457813256635, + "calibration_in_the_large": -0.0037888434196958615, + "expected_calibration_error_10bin": 0.004071154953803311, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + { + "valid": 2741, + "positives": 26, + "negatives": 2715, + "auroc": 0.7107238985692025, + "auprc": 0.02524224319470938, + "brier": 0.00939255430745904, + "calibration": { + "observed_rate": 0.009485589201021525, + "mean_prediction": 0.005759473609774546, + "calibration_in_the_large": -0.003726115591246979, + "expected_calibration_error_10bin": 0.004010089075075789, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + } + ], + "reason": null + }, + "K58": { + "time_averaged_auroc": 0.7048096947536192, + "time_averaged_auprc": 0.012002349429752503, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2792, + "positives": 3, + "negatives": 2789, + "auroc": 0.4854786661885981, + "auprc": 0.0013812894988785823, + "brier": 0.001075242244250214, + "calibration": { + "observed_rate": 0.0010744985673352436, + "mean_prediction": 0.0005976543336301336, + "calibration_in_the_large": -0.00047684423370511, + "expected_calibration_error_10bin": 0.00047684423370511, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 5, + "negatives": 2787, + "auroc": 0.6731969860064586, + "auprc": 0.016613181143052387, + "brier": 0.00178540965262568, + "calibration": { + "observed_rate": 0.0017908309455587394, + "mean_prediction": 0.0007355427372107427, + "calibration_in_the_large": -0.0010552882083479966, + "expected_calibration_error_10bin": 0.0010552882083479966, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 5, + "negatives": 2787, + "auroc": 0.6805166846071045, + "auprc": 0.01229950865908061, + "brier": 0.0017857959557282534, + "calibration": { + "observed_rate": 0.0017908309455587394, + "mean_prediction": 0.0009529751689328766, + "calibration_in_the_large": -0.0008378557766258628, + "expected_calibration_error_10bin": 0.0008378557766258628, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 5, + "negatives": 2787, + "auroc": 0.6864011481880158, + "auprc": 0.010310126471674614, + "brier": 0.0017868324413175191, + "calibration": { + "observed_rate": 0.0017908309455587394, + "mean_prediction": 0.001261087132846513, + "calibration_in_the_large": -0.0005297438127122263, + "expected_calibration_error_10bin": 0.0005297438127122263, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 7, + "negatives": 2785, + "auroc": 0.7312644267760965, + "auprc": 0.014680350175043494, + "brier": 0.0024967826368966564, + "calibration": { + "observed_rate": 0.002507163323782235, + "mean_prediction": 0.0014421068911642083, + "calibration_in_the_large": -0.001065056432618027, + "expected_calibration_error_10bin": 0.001065056432618027, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 7, + "negatives": 2785, + "auroc": 0.7349576814567838, + "auprc": 0.01463027778813542, + "brier": 0.0024969976631384625, + "calibration": { + "observed_rate": 0.002507163323782235, + "mean_prediction": 0.001647465321366847, + "calibration_in_the_large": -0.0008596980024153881, + "expected_calibration_error_10bin": 0.0008596980024153881, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 7, + "negatives": 2785, + "auroc": 0.7357271095152603, + "auprc": 0.014345855754022826, + "brier": 0.002498210018267487, + "calibration": { + "observed_rate": 0.002507163323782235, + "mean_prediction": 0.0017684339731553296, + "calibration_in_the_large": -0.0007387293506269056, + "expected_calibration_error_10bin": 0.0007387293506269056, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 7, + "negatives": 2785, + "auroc": 0.7358809951269556, + "auprc": 0.012852462950230516, + "brier": 0.002501031075184058, + "calibration": { + "observed_rate": 0.002507163323782235, + "mean_prediction": 0.0019336624782435345, + "calibration_in_the_large": -0.0005735008455387007, + "expected_calibration_error_10bin": 0.0005735008455387007, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 7, + "negatives": 2785, + "auroc": 0.7378815080789947, + "auprc": 0.01187325559578021, + "brier": 0.0025040968186626857, + "calibration": { + "observed_rate": 0.002507163323782235, + "mean_prediction": 0.002147309207703856, + "calibration_in_the_large": -0.0003598541160783793, + "expected_calibration_error_10bin": 0.0003598541160783793, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 7, + "negatives": 2785, + "auroc": 0.7379840984867915, + "auprc": 0.011403902360004738, + "brier": 0.0025071063973130655, + "calibration": { + "observed_rate": 0.002507163323782235, + "mean_prediction": 0.0023098101741077875, + "calibration_in_the_large": -0.0001973531496744477, + "expected_calibration_error_10bin": 0.0001973531496744477, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 7, + "negatives": 2785, + "auroc": 0.7406514490895101, + "auprc": 0.011881162281440002, + "brier": 0.002509031929412164, + "calibration": { + "observed_rate": 0.002507163323782235, + "mean_prediction": 0.0024823973818042227, + "calibration_in_the_large": -2.4765941978012462e-05, + "expected_calibration_error_10bin": 2.4765941978012462e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 7, + "negatives": 2785, + "auroc": 0.7412156963323929, + "auprc": 0.011876488844786981, + "brier": 0.002510290571037697, + "calibration": { + "observed_rate": 0.002507163323782235, + "mean_prediction": 0.002569326155591422, + "calibration_in_the_large": 6.216283180918679e-05, + "expected_calibration_error_10bin": 6.216283180918679e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + { + "valid": 2792, + "positives": 7, + "negatives": 2785, + "auroc": 0.7413695819440882, + "auprc": 0.011882681064652147, + "brier": 0.002510473973891236, + "calibration": { + "observed_rate": 0.002507163323782235, + "mean_prediction": 0.002577637060242192, + "calibration_in_the_large": 7.047373645995697e-05, + "expected_calibration_error_10bin": 7.047373645995697e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + } + ], + "reason": null + }, + "K59": { + "time_averaged_auroc": 0.7503220458859622, + "time_averaged_auprc": 0.11520986637875501, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2560, + "positives": 29, + "negatives": 2531, + "auroc": 0.6886061117998883, + "auprc": 0.04264071865407622, + "brier": 0.011101490057082377, + "calibration": { + "observed_rate": 0.011328125, + "mean_prediction": 0.00783786393092214, + "calibration_in_the_large": -0.0034902610690778595, + "expected_calibration_error_10bin": 0.0034902610690778595, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 40, + "negatives": 2520, + "auroc": 0.728343253968254, + "auprc": 0.061047820671245, + "brier": 0.01510994370295778, + "calibration": { + "observed_rate": 0.015625, + "mean_prediction": 0.012685073766306232, + "calibration_in_the_large": -0.002939926233693768, + "expected_calibration_error_10bin": 0.0035343011320492232, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 52, + "negatives": 2508, + "auroc": 0.7413967611336032, + "auprc": 0.0911122010379918, + "brier": 0.0193439414482164, + "calibration": { + "observed_rate": 0.0203125, + "mean_prediction": 0.01670969176173003, + "calibration_in_the_large": -0.003602808238269972, + "expected_calibration_error_10bin": 0.0039902213511823015, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 67, + "negatives": 2493, + "auroc": 0.7548479024851674, + "auprc": 0.11195943577546588, + "brier": 0.024601580515367177, + "calibration": { + "observed_rate": 0.026171875, + "mean_prediction": 0.019334283456737468, + "calibration_in_the_large": -0.006837591543262533, + "expected_calibration_error_10bin": 0.006989016916304537, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 69, + "negatives": 2491, + "auroc": 0.7510981562610907, + "auprc": 0.11640530189492058, + "brier": 0.025191140714311482, + "calibration": { + "observed_rate": 0.026953125, + "mean_prediction": 0.02157221752795522, + "calibration_in_the_large": -0.0053809074720447825, + "expected_calibration_error_10bin": 0.005813968272468627, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 72, + "negatives": 2488, + "auroc": 0.7586135673454806, + "auprc": 0.12904949063238622, + "brier": 0.026092268488037983, + "calibration": { + "observed_rate": 0.028125, + "mean_prediction": 0.023371545357395006, + "calibration_in_the_large": -0.004753454642604994, + "expected_calibration_error_10bin": 0.005261862029556143, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 78, + "negatives": 2482, + "auroc": 0.7586985268290667, + "auprc": 0.1316035247791112, + "brier": 0.02821370976795239, + "calibration": { + "observed_rate": 0.03046875, + "mean_prediction": 0.024984288238056252, + "calibration_in_the_large": -0.005484461761943747, + "expected_calibration_error_10bin": 0.006423713960384701, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 78, + "negatives": 2482, + "auroc": 0.758460918614021, + "auprc": 0.12831599151556952, + "brier": 0.028202619373250703, + "calibration": { + "observed_rate": 0.03046875, + "mean_prediction": 0.026408544154537594, + "calibration_in_the_large": -0.004060205845462406, + "expected_calibration_error_10bin": 0.005230179556247095, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 83, + "negatives": 2477, + "auroc": 0.7615897583065406, + "auprc": 0.13898335320426572, + "brier": 0.029809002224749814, + "calibration": { + "observed_rate": 0.032421875, + "mean_prediction": 0.027868605789763023, + "calibration_in_the_large": -0.004553269210236979, + "expected_calibration_error_10bin": 0.005372932517866503, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 85, + "negatives": 2475, + "auroc": 0.7621010101010101, + "auprc": 0.1364106095430854, + "brier": 0.03051885362538777, + "calibration": { + "observed_rate": 0.033203125, + "mean_prediction": 0.029281093020426852, + "calibration_in_the_large": -0.003922031979573148, + "expected_calibration_error_10bin": 0.004474267779414732, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 87, + "negatives": 2473, + "auroc": 0.7623064731281751, + "auprc": 0.1337662809891269, + "brier": 0.03125222146557443, + "calibration": { + "observed_rate": 0.033984375, + "mean_prediction": 0.03051826218270435, + "calibration_in_the_large": -0.003466112817295648, + "expected_calibration_error_10bin": 0.004082936955273909, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 90, + "negatives": 2470, + "auroc": 0.7640305892937472, + "auprc": 0.13822037763695, + "brier": 0.03221471667632461, + "calibration": { + "observed_rate": 0.03515625, + "mean_prediction": 0.0319199663762447, + "calibration_in_the_large": -0.003236283623755297, + "expected_calibration_error_10bin": 0.004113045969188535, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + { + "valid": 2560, + "positives": 90, + "negatives": 2470, + "auroc": 0.7640935672514619, + "auprc": 0.13821315658962083, + "brier": 0.0322120171611344, + "calibration": { + "observed_rate": 0.03515625, + "mean_prediction": 0.03208880374268119, + "calibration_in_the_large": -0.0030674462573188066, + "expected_calibration_error_10bin": 0.003950787931080413, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + } + ], + "reason": null + }, + "K62": { + "time_averaged_auroc": 0.8603232670025, + "time_averaged_auprc": 0.02332523872397724, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2813, + "positives": 1, + "negatives": 2812, + "auroc": 0.7958748221906117, + "auprc": 0.0017391304347826088, + "brier": 0.0003563213555514959, + "calibration": { + "observed_rate": 0.00035549235691432633, + "mean_prediction": 0.000882650500325064, + "calibration_in_the_large": 0.0005271581434107377, + "expected_calibration_error_10bin": 0.0005271581434107377, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 2, + "negatives": 2811, + "auroc": 0.9107079331198862, + "auprc": 0.012006564740433618, + "brier": 0.0007089818337758047, + "calibration": { + "observed_rate": 0.0007109847138286527, + "mean_prediction": 0.0013475493306090347, + "calibration_in_the_large": 0.000636564616780382, + "expected_calibration_error_10bin": 0.000636564616780382, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 5, + "negatives": 2808, + "auroc": 0.871937321937322, + "auprc": 0.011325538204341212, + "brier": 0.0017686601001256, + "calibration": { + "observed_rate": 0.0017774617845716318, + "mean_prediction": 0.0017120798744982891, + "calibration_in_the_large": -6.538191007334263e-05, + "expected_calibration_error_10bin": 6.538191007334263e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 8, + "negatives": 2805, + "auroc": 0.8479946524064171, + "auprc": 0.01194627001244646, + "brier": 0.0028286327408591698, + "calibration": { + "observed_rate": 0.0028439388553146107, + "mean_prediction": 0.0020011620497721034, + "calibration_in_the_large": -0.0008427768055425072, + "expected_calibration_error_10bin": 0.0008427768055425072, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 10, + "negatives": 2803, + "auroc": 0.8791651801641098, + "auprc": 0.030041479228603295, + "brier": 0.00351612784923358, + "calibration": { + "observed_rate": 0.0035549235691432635, + "mean_prediction": 0.002328052486806003, + "calibration_in_the_large": -0.0012268710823372607, + "expected_calibration_error_10bin": 0.0012268710823372607, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 11, + "negatives": 2802, + "auroc": 0.8793069885146972, + "auprc": 0.02864363649054781, + "brier": 0.003866830620072813, + "calibration": { + "observed_rate": 0.0039104159260575895, + "mean_prediction": 0.002508925522762729, + "calibration_in_the_large": -0.0014014904032948606, + "expected_calibration_error_10bin": 0.0014014904032948606, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 12, + "negatives": 2801, + "auroc": 0.8635903843865286, + "auprc": 0.02628080278459326, + "brier": 0.004217594236223014, + "calibration": { + "observed_rate": 0.004265908282971916, + "mean_prediction": 0.0027909819222074164, + "calibration_in_the_large": -0.0014749263607645, + "expected_calibration_error_10bin": 0.0014749263607645, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 14, + "negatives": 2799, + "auroc": 0.8701321900678813, + "auprc": 0.03232471647326763, + "brier": 0.004909881867783546, + "calibration": { + "observed_rate": 0.004976892996800568, + "mean_prediction": 0.0030770489184093657, + "calibration_in_the_large": -0.0018998440783912027, + "expected_calibration_error_10bin": 0.0018998440783912027, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 14, + "negatives": 2799, + "auroc": 0.8711784821109579, + "auprc": 0.03144845028059086, + "brier": 0.004907424340143991, + "calibration": { + "observed_rate": 0.004976892996800568, + "mean_prediction": 0.003308820950239086, + "calibration_in_the_large": -0.0016680720465614826, + "expected_calibration_error_10bin": 0.0016680720465614826, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 14, + "negatives": 2799, + "auroc": 0.8706170571122339, + "auprc": 0.030781462719436502, + "brier": 0.004906283772280542, + "calibration": { + "observed_rate": 0.004976892996800568, + "mean_prediction": 0.003466672521504437, + "calibration_in_the_large": -0.0015102204752961315, + "expected_calibration_error_10bin": 0.0015102204752961315, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 16, + "negatives": 2797, + "auroc": 0.8550232391848409, + "auprc": 0.029623114535103877, + "brier": 0.0056096527546446034, + "calibration": { + "observed_rate": 0.005687877710629221, + "mean_prediction": 0.0035763345432921834, + "calibration_in_the_large": -0.002111543167337038, + "expected_calibration_error_10bin": 0.002111543167337038, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 18, + "negatives": 2795, + "auroc": 0.8343072947724111, + "auprc": 0.028521392665468562, + "brier": 0.006313474070885171, + "calibration": { + "observed_rate": 0.006398862424457874, + "mean_prediction": 0.0037169554438463925, + "calibration_in_the_large": -0.0026819069806114817, + "expected_calibration_error_10bin": 0.0026819069806114817, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 18, + "negatives": 2795, + "auroc": 0.8343669250645995, + "auprc": 0.02854554484208841, + "brier": 0.006313289152505852, + "calibration": { + "observed_rate": 0.006398862424457874, + "mean_prediction": 0.0037395180197857822, + "calibration_in_the_large": -0.002659344404672092, + "expected_calibration_error_10bin": 0.002659344404672092, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + } + ], + "reason": null + }, + "K63": { + "time_averaged_auroc": 0.7176575260161099, + "time_averaged_auprc": 0.01205149389514591, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2810, + "positives": 2, + "negatives": 2808, + "auroc": 0.6620370370370371, + "auprc": 0.007041752107541582, + "brier": 0.00071079366042649, + "calibration": { + "observed_rate": 0.0007117437722419929, + "mean_prediction": 0.00092182567978817, + "calibration_in_the_large": 0.00021008190754617708, + "expected_calibration_error_10bin": 0.00021008190754617708, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 6, + "negatives": 2804, + "auroc": 0.6817047075606276, + "auprc": 0.006002337556696962, + "brier": 0.0021312547085187063, + "calibration": { + "observed_rate": 0.002135231316725979, + "mean_prediction": 0.0014209827073629958, + "calibration_in_the_large": -0.000714248609362983, + "expected_calibration_error_10bin": 0.000714248609362983, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 10, + "negatives": 2800, + "auroc": 0.7238214285714286, + "auprc": 0.00969666046010515, + "brier": 0.0035469943124109915, + "calibration": { + "observed_rate": 0.0035587188612099642, + "mean_prediction": 0.002074810756194404, + "calibration_in_the_large": -0.0014839081050155604, + "expected_calibration_error_10bin": 0.0014839081050155604, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 13, + "negatives": 2797, + "auroc": 0.7100739803635764, + "auprc": 0.010760975298711823, + "brier": 0.004610834139528854, + "calibration": { + "observed_rate": 0.004626334519572953, + "mean_prediction": 0.002466162239028194, + "calibration_in_the_large": -0.0021601722805447594, + "expected_calibration_error_10bin": 0.0021601722805447594, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 13, + "negatives": 2797, + "auroc": 0.7099914743818927, + "auprc": 0.010740755894055185, + "brier": 0.0046142645546914, + "calibration": { + "observed_rate": 0.004626334519572953, + "mean_prediction": 0.0028436531696214426, + "calibration_in_the_large": -0.0017826813499515108, + "expected_calibration_error_10bin": 0.0017826813499515108, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 14, + "negatives": 2796, + "auroc": 0.72652258328224, + "auprc": 0.01209448595140146, + "brier": 0.00496590904205348, + "calibration": { + "observed_rate": 0.00498220640569395, + "mean_prediction": 0.0032415006383284066, + "calibration_in_the_large": -0.0017407057673655434, + "expected_calibration_error_10bin": 0.0017407057673655434, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 15, + "negatives": 2795, + "auroc": 0.7225760286225402, + "auprc": 0.012304006116957733, + "brier": 0.005320905335302665, + "calibration": { + "observed_rate": 0.005338078291814947, + "mean_prediction": 0.003472031313616611, + "calibration_in_the_large": -0.0018660469781983358, + "expected_calibration_error_10bin": 0.0018660469781983358, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 15, + "negatives": 2795, + "auroc": 0.7248419797257006, + "auprc": 0.012750223975251019, + "brier": 0.005323560539704522, + "calibration": { + "observed_rate": 0.005338078291814947, + "mean_prediction": 0.003766529310100154, + "calibration_in_the_large": -0.0015715489817147927, + "expected_calibration_error_10bin": 0.0015715489817147927, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 15, + "negatives": 2795, + "auroc": 0.7251997614788313, + "auprc": 0.01269546244980326, + "brier": 0.0053257745653806764, + "calibration": { + "observed_rate": 0.005338078291814947, + "mean_prediction": 0.003949889859770946, + "calibration_in_the_large": -0.0013881884320440007, + "expected_calibration_error_10bin": 0.0013881884320440007, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 15, + "negatives": 2795, + "auroc": 0.7267978533094812, + "auprc": 0.012825951549084428, + "brier": 0.005327680771905423, + "calibration": { + "observed_rate": 0.005338078291814947, + "mean_prediction": 0.004141022145686099, + "calibration_in_the_large": -0.001197056146128848, + "expected_calibration_error_10bin": 0.001197056146128848, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 19, + "negatives": 2791, + "auroc": 0.7380489920609478, + "auprc": 0.01610251472769446, + "brier": 0.006733821111831152, + "calibration": { + "observed_rate": 0.006761565836298933, + "mean_prediction": 0.004469106310276415, + "calibration_in_the_large": -0.0022924595260225174, + "expected_calibration_error_10bin": 0.0022924595260225174, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 21, + "negatives": 2789, + "auroc": 0.7388379518175144, + "auprc": 0.01680950996180653, + "brier": 0.007442212892625003, + "calibration": { + "observed_rate": 0.007473309608540925, + "mean_prediction": 0.004784570645048569, + "calibration_in_the_large": -0.0026887389634923558, + "expected_calibration_error_10bin": 0.0026887389634923558, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 21, + "negatives": 2789, + "auroc": 0.7390940599976097, + "auprc": 0.016844784587787258, + "brier": 0.007442510962491028, + "calibration": { + "observed_rate": 0.007473309608540925, + "mean_prediction": 0.004806977405512765, + "calibration_in_the_large": -0.00266633220302816, + "expected_calibration_error_10bin": 0.00266633220302816, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + } + ], + "reason": null + }, + "K64": { + "time_averaged_auroc": 0.797587810427522, + "time_averaged_auprc": 0.020682852835740093, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2801, + "positives": 2, + "negatives": 2799, + "auroc": 0.8210075026795284, + "auprc": 0.002917082917082917, + "brier": 0.0007207295124926025, + "calibration": { + "observed_rate": 0.0007140307033202428, + "mean_prediction": 0.0013156789465106455, + "calibration_in_the_large": 0.0006016482431904027, + "expected_calibration_error_10bin": 0.0006016482431904027, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 5, + "negatives": 2796, + "auroc": 0.7741773962804006, + "auprc": 0.007401656111602215, + "brier": 0.0018018275617393712, + "calibration": { + "observed_rate": 0.001785076758300607, + "mean_prediction": 0.002312823764295302, + "calibration_in_the_large": 0.0005277470059946948, + "expected_calibration_error_10bin": 0.0005277470059946948, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 9, + "negatives": 2792, + "auroc": 0.8218322190385228, + "auprc": 0.01224161640122436, + "brier": 0.0032571481995373984, + "calibration": { + "observed_rate": 0.0032131381649410924, + "mean_prediction": 0.00318207328116027, + "calibration_in_the_large": -3.1064883780822315e-05, + "expected_calibration_error_10bin": 0.0002915865026436483, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 11, + "negatives": 2790, + "auroc": 0.7955685891169763, + "auprc": 0.01270886237769951, + "brier": 0.003990156571366137, + "calibration": { + "observed_rate": 0.003927168868261335, + "mean_prediction": 0.0038540625690436175, + "calibration_in_the_large": -7.310629921771774e-05, + "expected_calibration_error_10bin": 0.0006859823716532568, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 13, + "negatives": 2788, + "auroc": 0.8023948791524115, + "auprc": 0.016134849200024153, + "brier": 0.004696249352586278, + "calibration": { + "observed_rate": 0.0046411995715815784, + "mean_prediction": 0.0043333154272051635, + "calibration_in_the_large": -0.0003078841443764149, + "expected_calibration_error_10bin": 0.0012157585102864983, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 16, + "negatives": 2785, + "auroc": 0.775516157989228, + "auprc": 0.02020224259355619, + "brier": 0.005755960109086282, + "calibration": { + "observed_rate": 0.005712245626561942, + "mean_prediction": 0.004929131458340998, + "calibration_in_the_large": -0.0007831141682209447, + "expected_calibration_error_10bin": 0.0019981074087128993, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 17, + "negatives": 2784, + "auroc": 0.7802358012170385, + "auprc": 0.02067165693321929, + "brier": 0.006127062931809164, + "calibration": { + "observed_rate": 0.006069260978222063, + "mean_prediction": 0.005504906465314619, + "calibration_in_the_large": -0.0005643545129074444, + "expected_calibration_error_10bin": 0.0020125277470901416, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 18, + "negatives": 2783, + "auroc": 0.7925899309298519, + "auprc": 0.027487325589311103, + "brier": 0.006429828581409208, + "calibration": { + "observed_rate": 0.006426276329882185, + "mean_prediction": 0.005994055356476831, + "calibration_in_the_large": -0.00043222097340535337, + "expected_calibration_error_10bin": 0.0020322808020069747, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 20, + "negatives": 2781, + "auroc": 0.8027687882056814, + "auprc": 0.02883349500796068, + "brier": 0.0071385220987755646, + "calibration": { + "observed_rate": 0.007140307033202428, + "mean_prediction": 0.0064929299562672725, + "calibration_in_the_large": -0.0006473770769351555, + "expected_calibration_error_10bin": 0.002175722675976869, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 21, + "negatives": 2780, + "auroc": 0.7967797190818774, + "auprc": 0.029361146969368403, + "brier": 0.007513164569779462, + "calibration": { + "observed_rate": 0.007497322384862549, + "mean_prediction": 0.006828202511348004, + "calibration_in_the_large": -0.0006691198735145447, + "expected_calibration_error_10bin": 0.002588337815872247, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 22, + "negatives": 2779, + "auroc": 0.8009748437960025, + "auprc": 0.03051278689765174, + "brier": 0.007869459190406148, + "calibration": { + "observed_rate": 0.00785433773652267, + "mean_prediction": 0.007129699773313629, + "calibration_in_the_large": -0.0007246379632090414, + "expected_calibration_error_10bin": 0.002706801522616389, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 22, + "negatives": 2779, + "auroc": 0.8023978540351336, + "auprc": 0.030203978298068614, + "brier": 0.007876148388744963, + "calibration": { + "observed_rate": 0.00785433773652267, + "mean_prediction": 0.007522114626257386, + "calibration_in_the_large": -0.0003322231102652843, + "expected_calibration_error_10bin": 0.0023716962430272875, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + { + "valid": 2801, + "positives": 22, + "negatives": 2779, + "auroc": 0.8023978540351336, + "auprc": 0.030200387567851986, + "brier": 0.007876755708831446, + "calibration": { + "observed_rate": 0.00785433773652267, + "mean_prediction": 0.007537026157298766, + "calibration_in_the_large": -0.00031731157922390476, + "expected_calibration_error_10bin": 0.0023614806844595177, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + } + ], + "reason": null + }, + "K65": { + "time_averaged_auroc": 0.8387727582995883, + "time_averaged_auprc": 0.02985684873376374, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2813, + "positives": 5, + "negatives": 2808, + "auroc": 0.8474358974358974, + "auprc": 0.018567129748864354, + "brier": 0.0017741307209860513, + "calibration": { + "observed_rate": 0.0017774617845716318, + "mean_prediction": 0.0021955946060842977, + "calibration_in_the_large": 0.00041813282151266593, + "expected_calibration_error_10bin": 0.00041813282151266593, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 7, + "negatives": 2806, + "auroc": 0.8170756542103655, + "auprc": 0.019407447827352476, + "brier": 0.0025308803227438786, + "calibration": { + "observed_rate": 0.002488446498400284, + "mean_prediction": 0.004103820467166959, + "calibration_in_the_large": 0.0016153739687666748, + "expected_calibration_error_10bin": 0.0016153739687666741, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 9, + "negatives": 2804, + "auroc": 0.8588128071009669, + "auprc": 0.02776585504065347, + "brier": 0.0032436955484661015, + "calibration": { + "observed_rate": 0.003199431212228937, + "mean_prediction": 0.005068938714876116, + "calibration_in_the_large": 0.001869507502647179, + "expected_calibration_error_10bin": 0.0018695075026471785, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 9, + "negatives": 2804, + "auroc": 0.8594864479315264, + "auprc": 0.02720891191025377, + "brier": 0.0032903962398114746, + "calibration": { + "observed_rate": 0.003199431212228937, + "mean_prediction": 0.005840303183337315, + "calibration_in_the_large": 0.0026408719711083777, + "expected_calibration_error_10bin": 0.002640871971108378, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 9, + "negatives": 2804, + "auroc": 0.8589713108258044, + "auprc": 0.026718494548254847, + "brier": 0.003322062553927448, + "calibration": { + "observed_rate": 0.003199431212228937, + "mean_prediction": 0.006289250449546627, + "calibration_in_the_large": 0.00308981923731769, + "expected_calibration_error_10bin": 0.00308981923731769, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 10, + "negatives": 2803, + "auroc": 0.8729575454869782, + "auprc": 0.034528084022304284, + "brier": 0.003652405657499423, + "calibration": { + "observed_rate": 0.0035549235691432635, + "mean_prediction": 0.006891045962264527, + "calibration_in_the_large": 0.0033361223931212634, + "expected_calibration_error_10bin": 0.003336122393121264, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 11, + "negatives": 2802, + "auroc": 0.8809292064110051, + "auprc": 0.03646928991793443, + "brier": 0.00401849178578809, + "calibration": { + "observed_rate": 0.0039104159260575895, + "mean_prediction": 0.007346472529202746, + "calibration_in_the_large": 0.003436056603145156, + "expected_calibration_error_10bin": 0.003436056603145156, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 12, + "negatives": 2801, + "auroc": 0.8700761632750208, + "auprc": 0.034643019509126884, + "brier": 0.004389304826905788, + "calibration": { + "observed_rate": 0.004265908282971916, + "mean_prediction": 0.007631713348443661, + "calibration_in_the_large": 0.0033658050654717447, + "expected_calibration_error_10bin": 0.0033658050654717447, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 12, + "negatives": 2801, + "auroc": 0.8701059145543258, + "auprc": 0.03494565992285719, + "brier": 0.004410752504410782, + "calibration": { + "observed_rate": 0.004265908282971916, + "mean_prediction": 0.00788009792055177, + "calibration_in_the_large": 0.003614189637579853, + "expected_calibration_error_10bin": 0.0036141896375798542, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 13, + "negatives": 2800, + "auroc": 0.8087912087912088, + "auprc": 0.03281055159608727, + "brier": 0.004775015488306531, + "calibration": { + "observed_rate": 0.004621400639886242, + "mean_prediction": 0.008086885465157453, + "calibration_in_the_large": 0.0034654848252712103, + "expected_calibration_error_10bin": 0.0034654848252712103, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 13, + "negatives": 2800, + "auroc": 0.8092582417582418, + "auprc": 0.03286898875060228, + "brier": 0.00479690865168526, + "calibration": { + "observed_rate": 0.004621400639886242, + "mean_prediction": 0.008375093591973146, + "calibration_in_the_large": 0.0037536929520869036, + "expected_calibration_error_10bin": 0.0037536929520869036, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 14, + "negatives": 2799, + "auroc": 0.7750216914204052, + "auprc": 0.03109221917828615, + "brier": 0.005171419319131576, + "calibration": { + "observed_rate": 0.004976892996800568, + "mean_prediction": 0.008651325688729988, + "calibration_in_the_large": 0.003674432691929419, + "expected_calibration_error_10bin": 0.0036744326919294188, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + { + "valid": 2813, + "positives": 14, + "negatives": 2799, + "auroc": 0.7751237686929006, + "auprc": 0.03111338156635119, + "brier": 0.005179262839998131, + "calibration": { + "observed_rate": 0.004976892996800568, + "mean_prediction": 0.008715440982885795, + "calibration_in_the_large": 0.0037385479860852265, + "expected_calibration_error_10bin": 0.0037385479860852257, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + } + ], + "reason": null + }, + "K66": { + "time_averaged_auroc": 0.7725929824691767, + "time_averaged_auprc": 0.018926230428461782, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2796, + "positives": 1, + "negatives": 2795, + "auroc": 0.9073345259391771, + "auprc": 0.0038461538461538464, + "brier": 0.00035782038920053125, + "calibration": { + "observed_rate": 0.000357653791130186, + "mean_prediction": 0.0005211664440571407, + "calibration_in_the_large": 0.00016351265292695468, + "expected_calibration_error_10bin": 0.00016351265292695468, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 1, + "negatives": 2795, + "auroc": 0.91520572450805, + "auprc": 0.004201680672268907, + "brier": 0.0003613679152521979, + "calibration": { + "observed_rate": 0.000357653791130186, + "mean_prediction": 0.0012150248888771365, + "calibration_in_the_large": 0.0008573710977469505, + "expected_calibration_error_10bin": 0.0008573710977469505, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 4, + "negatives": 2792, + "auroc": 0.9058918338108882, + "auprc": 0.03423235033334283, + "brier": 0.0014202247744516693, + "calibration": { + "observed_rate": 0.001430615164520744, + "mean_prediction": 0.002018822694134957, + "calibration_in_the_large": 0.000588207529614213, + "expected_calibration_error_10bin": 0.000588207529614213, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 6, + "negatives": 2790, + "auroc": 0.7298685782556751, + "auprc": 0.0258215474281077, + "brier": 0.0021371459848367486, + "calibration": { + "observed_rate": 0.002145922746781116, + "mean_prediction": 0.0025309316585658695, + "calibration_in_the_large": 0.00038500891178475365, + "expected_calibration_error_10bin": 0.00038500891178475365, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 6, + "negatives": 2790, + "auroc": 0.7306451612903225, + "auprc": 0.023442264431148763, + "brier": 0.0021438301465474163, + "calibration": { + "observed_rate": 0.002145922746781116, + "mean_prediction": 0.003027869380284769, + "calibration_in_the_large": 0.000881946633503653, + "expected_calibration_error_10bin": 0.000881946633503653, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 6, + "negatives": 2790, + "auroc": 0.7300477897252091, + "auprc": 0.021609775481233006, + "brier": 0.0021506767811608415, + "calibration": { + "observed_rate": 0.002145922746781116, + "mean_prediction": 0.003401065209671623, + "calibration_in_the_large": 0.001255142462890507, + "expected_calibration_error_10bin": 0.001255142462890507, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 7, + "negatives": 2789, + "auroc": 0.7229933924089536, + "auprc": 0.019431962719180688, + "brier": 0.0025137408024493357, + "calibration": { + "observed_rate": 0.002503576537911302, + "mean_prediction": 0.003848122933190558, + "calibration_in_the_large": 0.0013445463952792562, + "expected_calibration_error_10bin": 0.0013445463952792562, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 8, + "negatives": 2788, + "auroc": 0.7233231707317073, + "auprc": 0.01806578584622324, + "brier": 0.0028741646370465624, + "calibration": { + "observed_rate": 0.002861230329041488, + "mean_prediction": 0.004121532915197117, + "calibration_in_the_large": 0.0012603025861556288, + "expected_calibration_error_10bin": 0.0012603025861556288, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 8, + "negatives": 2788, + "auroc": 0.7197812051649928, + "auprc": 0.01935171777644511, + "brier": 0.0028784329994838063, + "calibration": { + "observed_rate": 0.002861230329041488, + "mean_prediction": 0.004404814426041449, + "calibration_in_the_large": 0.0015435840969999608, + "expected_calibration_error_10bin": 0.0015435840969999608, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 9, + "negatives": 2787, + "auroc": 0.7421759757604752, + "auprc": 0.019438085281945114, + "brier": 0.0032319981058439697, + "calibration": { + "observed_rate": 0.003218884120171674, + "mean_prediction": 0.004595296359850613, + "calibration_in_the_large": 0.0013764122396789395, + "expected_calibration_error_10bin": 0.0013764122396789395, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 9, + "negatives": 2787, + "auroc": 0.7398237850336882, + "auprc": 0.01808024425855018, + "brier": 0.003237593133196821, + "calibration": { + "observed_rate": 0.003218884120171674, + "mean_prediction": 0.004824254995680618, + "calibration_in_the_large": 0.001605370875508944, + "expected_calibration_error_10bin": 0.001605370875508944, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 9, + "negatives": 2787, + "auroc": 0.7382290794562054, + "auprc": 0.019257921395249542, + "brier": 0.0032422927864327548, + "calibration": { + "observed_rate": 0.003218884120171674, + "mean_prediction": 0.0050552911832109255, + "calibration_in_the_large": 0.0018364070630392517, + "expected_calibration_error_10bin": 0.0018364070630392517, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + { + "valid": 2796, + "positives": 9, + "negatives": 2787, + "auroc": 0.7383885500139536, + "auprc": 0.01926150610015424, + "brier": 0.0032424991474192697, + "calibration": { + "observed_rate": 0.003218884120171674, + "mean_prediction": 0.0050636760690514725, + "calibration_in_the_large": 0.0018447919488797987, + "expected_calibration_error_10bin": 0.0018447919488797987, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + } + ], + "reason": null + }, + "K70": { + "time_averaged_auroc": 0.9282465218029832, + "time_averaged_auprc": 0.011217117429055021, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2774, + "positives": 0, + "negatives": 2774, + "auroc": null, + "auprc": null, + "brier": 1.393709785564573e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00021949276676395293, + "calibration_in_the_large": 0.00021949276676395293, + "expected_calibration_error_10bin": 0.00021949276676395293, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 1, + "negatives": 2773, + "auroc": 0.9552830869094843, + "auprc": 0.008, + "brier": 0.0003639009501470907, + "calibration": { + "observed_rate": 0.0003604902667627974, + "mean_prediction": 0.000444189007710916, + "calibration_in_the_large": 8.369874094811861e-05, + "expected_calibration_error_10bin": 8.369874094811861e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 1, + "negatives": 2773, + "auroc": 0.9509556437071763, + "auprc": 0.0072992700729927005, + "brier": 0.0003662815704525454, + "calibration": { + "observed_rate": 0.0003604902667627974, + "mean_prediction": 0.0005497198832050716, + "calibration_in_the_large": 0.00018922961644227425, + "expected_calibration_error_10bin": 0.00018922961644227425, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 1, + "negatives": 2773, + "auroc": 0.9487919221060224, + "auprc": 0.006993006993006993, + "brier": 0.0003680467396047394, + "calibration": { + "observed_rate": 0.0003604902667627974, + "mean_prediction": 0.0006240629107671329, + "calibration_in_the_large": 0.00026357264400433554, + "expected_calibration_error_10bin": 0.00026357264400433554, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 1, + "negatives": 2773, + "auroc": 0.9498737829065993, + "auprc": 0.007142857142857143, + "brier": 0.0003720138603104363, + "calibration": { + "observed_rate": 0.0003604902667627974, + "mean_prediction": 0.0007529576815164171, + "calibration_in_the_large": 0.00039246741475361976, + "expected_calibration_error_10bin": 0.00039246741475361976, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 1, + "negatives": 2773, + "auroc": 0.9491525423728814, + "auprc": 0.007042253521126761, + "brier": 0.00037354438392599794, + "calibration": { + "observed_rate": 0.0003604902667627974, + "mean_prediction": 0.0008050195439592711, + "calibration_in_the_large": 0.0004445292771964737, + "expected_calibration_error_10bin": 0.0004445292771964737, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 1, + "negatives": 2773, + "auroc": 0.9484313018391634, + "auprc": 0.006944444444444444, + "brier": 0.0003751447572460951, + "calibration": { + "observed_rate": 0.0003604902667627974, + "mean_prediction": 0.0008570157369767644, + "calibration_in_the_large": 0.000496525470213967, + "expected_calibration_error_10bin": 0.000496525470213967, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 1, + "negatives": 2773, + "auroc": 0.9516768842408944, + "auprc": 0.007407407407407408, + "brier": 0.00037902262080753214, + "calibration": { + "observed_rate": 0.0003604902667627974, + "mean_prediction": 0.0009792144493071604, + "calibration_in_the_large": 0.0006187241825443631, + "expected_calibration_error_10bin": 0.000618724182544363, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 2, + "negatives": 2772, + "auroc": 0.8547979797979798, + "auprc": 0.0052408799777220825, + "brier": 0.0007408100687202106, + "calibration": { + "observed_rate": 0.0007209805335255948, + "mean_prediction": 0.0010400082265219857, + "calibration_in_the_large": 0.0003190276929963909, + "expected_calibration_error_10bin": 0.0003190276929963908, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 3, + "negatives": 2771, + "auroc": 0.8899314326957777, + "auprc": 0.010037161704769863, + "brier": 0.001098269816236143, + "calibration": { + "observed_rate": 0.0010814708002883922, + "mean_prediction": 0.0010829182192891795, + "calibration_in_the_large": 1.4474190007873148e-06, + "expected_calibration_error_10bin": 8.322109708057391e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 5, + "negatives": 2769, + "auroc": 0.9037197544239798, + "auprc": 0.01506720925490112, + "brier": 0.0018143840579088733, + "calibration": { + "observed_rate": 0.001802451333813987, + "mean_prediction": 0.001119567234459115, + "calibration_in_the_large": -0.0006828840993548719, + "expected_calibration_error_10bin": 0.000842603785641306, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.9182321772639692, + "auprc": 0.02673436573206002, + "brier": 0.0021622879177010316, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.001167540433796245, + "calibration_in_the_large": -0.0009954011667805394, + "expected_calibration_error_10bin": 0.0011589370221848578, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.918111753371869, + "auprc": 0.026696552897371714, + "brier": 0.0021622677748288385, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.001171083837306631, + "calibration_in_the_large": -0.0009918577632701533, + "expected_calibration_error_10bin": 0.0011556245168405698, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + } + ], + "reason": null + }, + "K72": { + "time_averaged_auroc": 0.9419979855729128, + "time_averaged_auprc": 0.272113647641618, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2787, + "positives": 4, + "negatives": 2783, + "auroc": 0.9878727991376213, + "auprc": 0.33751536918397723, + "brier": 0.0013466901134463088, + "calibration": { + "observed_rate": 0.0014352350197344816, + "mean_prediction": 0.0006813753486773093, + "calibration_in_the_large": -0.0007538596710571723, + "expected_calibration_error_10bin": 0.0007538596710571723, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 6, + "negatives": 2781, + "auroc": 0.9727915617883255, + "auprc": 0.2667591348625832, + "brier": 0.0019670511521187543, + "calibration": { + "observed_rate": 0.002152852529601722, + "mean_prediction": 0.0016301186927180687, + "calibration_in_the_large": -0.0005227338368836534, + "expected_calibration_error_10bin": 0.0007130093786881039, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 10, + "negatives": 2777, + "auroc": 0.9348577601728484, + "auprc": 0.26432500046272117, + "brier": 0.0031803151608312172, + "calibration": { + "observed_rate": 0.003588087549336204, + "mean_prediction": 0.002095378568430848, + "calibration_in_the_large": -0.0014927089809053558, + "expected_calibration_error_10bin": 0.0014927089809053558, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 13, + "negatives": 2774, + "auroc": 0.9458432699240198, + "auprc": 0.2408346819957726, + "brier": 0.004203761503143878, + "calibration": { + "observed_rate": 0.0046645138141370645, + "mean_prediction": 0.002448712766797046, + "calibration_in_the_large": -0.0022158010473400185, + "expected_calibration_error_10bin": 0.003089754653945891, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 15, + "negatives": 2772, + "auroc": 0.9526695526695527, + "auprc": 0.2552278624888064, + "brier": 0.004819622781897199, + "calibration": { + "observed_rate": 0.005382131324004306, + "mean_prediction": 0.0027931222107765823, + "calibration_in_the_large": -0.002589009113227724, + "expected_calibration_error_10bin": 0.003972494950496177, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 15, + "negatives": 2772, + "auroc": 0.9525974025974026, + "auprc": 0.2532655548392671, + "brier": 0.004818890259308495, + "calibration": { + "observed_rate": 0.005382131324004306, + "mean_prediction": 0.003079071702661238, + "calibration_in_the_large": -0.0023030596213430682, + "expected_calibration_error_10bin": 0.0032860062236412147, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 18, + "negatives": 2769, + "auroc": 0.9556197584366598, + "auprc": 0.2890625339864446, + "brier": 0.005615123870211976, + "calibration": { + "observed_rate": 0.006458557588805167, + "mean_prediction": 0.0034036242333477596, + "calibration_in_the_large": -0.0030549333554574076, + "expected_calibration_error_10bin": 0.003314727781284888, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 18, + "negatives": 2769, + "auroc": 0.9551583002287227, + "auprc": 0.2851901730855593, + "brier": 0.005607892131661886, + "calibration": { + "observed_rate": 0.006458557588805167, + "mean_prediction": 0.003715401176677566, + "calibration_in_the_large": -0.002743156412127601, + "expected_calibration_error_10bin": 0.0036194296167859803, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 18, + "negatives": 2769, + "auroc": 0.9548573492235464, + "auprc": 0.2812905017266262, + "brier": 0.0056008851563843255, + "calibration": { + "observed_rate": 0.006458557588805167, + "mean_prediction": 0.003981388256330985, + "calibration_in_the_large": -0.0024771693324741823, + "expected_calibration_error_10bin": 0.003655620934035751, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 20, + "negatives": 2767, + "auroc": 0.9225334297072642, + "auprc": 0.2776409399790933, + "brier": 0.006272368712012159, + "calibration": { + "observed_rate": 0.007176175098672408, + "mean_prediction": 0.004112986779501482, + "calibration_in_the_large": -0.0030631883191709255, + "expected_calibration_error_10bin": 0.003980784716153359, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 21, + "negatives": 2766, + "auroc": 0.92369934235444, + "auprc": 0.27018733583550647, + "brier": 0.006629028715656333, + "calibration": { + "observed_rate": 0.007534983853606028, + "mean_prediction": 0.004237215856132868, + "calibration_in_the_large": -0.0032977679974731606, + "expected_calibration_error_10bin": 0.004278026070995909, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 22, + "negatives": 2765, + "auroc": 0.8937202038467861, + "auprc": 0.25808868179573, + "brier": 0.006981712508051468, + "calibration": { + "observed_rate": 0.007893792608539648, + "mean_prediction": 0.004402156435338862, + "calibration_in_the_large": -0.0034916361732007855, + "expected_calibration_error_10bin": 0.004604663903067408, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + { + "valid": 2787, + "positives": 22, + "negatives": 2765, + "auroc": 0.8937530823606773, + "auprc": 0.25808964909894666, + "brier": 0.0069816852847103825, + "calibration": { + "observed_rate": 0.007893792608539648, + "mean_prediction": 0.004409029721652773, + "calibration_in_the_large": -0.0034847628868868745, + "expected_calibration_error_10bin": 0.004598975716208445, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + } + ], + "reason": null + }, + "K74": { + "time_averaged_auroc": 0.9592808531592854, + "time_averaged_auprc": 0.043922748192558744, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2763, + "positives": 1, + "negatives": 2762, + "auroc": 0.9822592324402607, + "auprc": 0.02, + "brier": 0.00036863564724511213, + "calibration": { + "observed_rate": 0.0003619254433586681, + "mean_prediction": 0.0009287814591122328, + "calibration_in_the_large": 0.0005668560157535646, + "expected_calibration_error_10bin": 0.0005668560157535646, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 3, + "negatives": 2760, + "auroc": 0.9318840579710145, + "auprc": 0.01931765253842571, + "brier": 0.0011009710228221984, + "calibration": { + "observed_rate": 0.0010857763300760044, + "mean_prediction": 0.0014979695074535768, + "calibration_in_the_large": 0.0004121931773775724, + "expected_calibration_error_10bin": 0.0004121931773775725, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 5, + "negatives": 2758, + "auroc": 0.9562726613488035, + "auprc": 0.029291931076687566, + "brier": 0.0018288102915981247, + "calibration": { + "observed_rate": 0.0018096272167933405, + "mean_prediction": 0.001952493103291708, + "calibration_in_the_large": 0.00014286588649836738, + "expected_calibration_error_10bin": 0.00014286588649836733, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 6, + "negatives": 2757, + "auroc": 0.9653004473461492, + "auprc": 0.053560890922718485, + "brier": 0.002140675210180198, + "calibration": { + "observed_rate": 0.002171552660152009, + "mean_prediction": 0.0021813873641169457, + "calibration_in_the_large": 9.834703964936922e-06, + "expected_calibration_error_10bin": 0.0003649576682705799, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 6, + "negatives": 2757, + "auroc": 0.9642727602466449, + "auprc": 0.053551078551078546, + "brier": 0.002149434650269027, + "calibration": { + "observed_rate": 0.002171552660152009, + "mean_prediction": 0.00256597322787574, + "calibration_in_the_large": 0.00039442056772373123, + "expected_calibration_error_10bin": 0.00039442056772373167, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 6, + "negatives": 2757, + "auroc": 0.9652399951638254, + "auprc": 0.05402270570011943, + "brier": 0.002151326604904314, + "calibration": { + "observed_rate": 0.002171552660152009, + "mean_prediction": 0.002689983918087462, + "calibration_in_the_large": 0.0005184312579354531, + "expected_calibration_error_10bin": 0.0005184312579354536, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 7, + "negatives": 2756, + "auroc": 0.9557329462989841, + "auprc": 0.0487282417958607, + "brier": 0.002513211288322681, + "calibration": { + "observed_rate": 0.0025334781035106766, + "mean_prediction": 0.0028401743918578357, + "calibration_in_the_large": 0.00030669628834715905, + "expected_calibration_error_10bin": 0.0004851740955188133, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 7, + "negatives": 2756, + "auroc": 0.9564586357039188, + "auprc": 0.04904158855397245, + "brier": 0.002516182025973436, + "calibration": { + "observed_rate": 0.0025334781035106766, + "mean_prediction": 0.0029764198646134183, + "calibration_in_the_large": 0.0004429417611027417, + "expected_calibration_error_10bin": 0.00044515900044130274, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 7, + "negatives": 2756, + "auroc": 0.9573916649388348, + "auprc": 0.04948627151834322, + "brier": 0.0025222934887772705, + "calibration": { + "observed_rate": 0.0025334781035106766, + "mean_prediction": 0.0030852800304776813, + "calibration_in_the_large": 0.0005518019269670047, + "expected_calibration_error_10bin": 0.0005518019269670046, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 7, + "negatives": 2756, + "auroc": 0.9584283640887414, + "auprc": 0.04878097000559707, + "brier": 0.002538712363052634, + "calibration": { + "observed_rate": 0.0025334781035106766, + "mean_prediction": 0.0033831513126825695, + "calibration_in_the_large": 0.0008496732091718929, + "expected_calibration_error_10bin": 0.0008496732091718926, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 7, + "negatives": 2756, + "auroc": 0.9586357039187228, + "auprc": 0.04818185917544136, + "brier": 0.002547021471463748, + "calibration": { + "observed_rate": 0.0025334781035106766, + "mean_prediction": 0.0035164067817719832, + "calibration_in_the_large": 0.0009829286782613066, + "expected_calibration_error_10bin": 0.0009829286782613062, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 7, + "negatives": 2756, + "auroc": 0.9593613933236574, + "auprc": 0.048508733937998656, + "brier": 0.002549622213262191, + "calibration": { + "observed_rate": 0.0025334781035106766, + "mean_prediction": 0.0036302577422622443, + "calibration_in_the_large": 0.0010967796387515677, + "expected_calibration_error_10bin": 0.0010967796387515675, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + { + "valid": 2763, + "positives": 7, + "negatives": 2756, + "auroc": 0.9594132282811528, + "auprc": 0.048523802727020546, + "brier": 0.002549852469826135, + "calibration": { + "observed_rate": 0.0025334781035106766, + "mean_prediction": 0.0036380183385241564, + "calibration_in_the_large": 0.0011045402350134798, + "expected_calibration_error_10bin": 0.0011045402350134798, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + } + ], + "reason": null + }, + "K75": { + "time_averaged_auroc": 0.8255272041941365, + "time_averaged_auprc": 0.02201739564539862, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2798, + "positives": 2, + "negatives": 2796, + "auroc": 0.9386623748211731, + "auprc": 0.009000321440051431, + "brier": 0.0007146498401891222, + "calibration": { + "observed_rate": 0.0007147962830593281, + "mean_prediction": 0.0004684053144828054, + "calibration_in_the_large": -0.00024639096857652273, + "expected_calibration_error_10bin": 0.00024639096857652273, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 4, + "negatives": 2794, + "auroc": 0.8517358625626342, + "auprc": 0.022038246146339174, + "brier": 0.001422217059274201, + "calibration": { + "observed_rate": 0.0014295925661186562, + "mean_prediction": 0.0010956803430147702, + "calibration_in_the_large": -0.00033391222310388607, + "expected_calibration_error_10bin": 0.00033391222310388607, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 5, + "negatives": 2793, + "auroc": 0.7593268886501969, + "auprc": 0.01804701226805023, + "brier": 0.0017836433223743964, + "calibration": { + "observed_rate": 0.0017869907076483202, + "mean_prediction": 0.001391193649117338, + "calibration_in_the_large": -0.0003957970585309822, + "expected_calibration_error_10bin": 0.0003957970585309822, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 9, + "negatives": 2789, + "auroc": 0.8373371578821561, + "auprc": 0.023798246177834142, + "brier": 0.0031956809426660236, + "calibration": { + "observed_rate": 0.0032165832737669764, + "mean_prediction": 0.001766872650011261, + "calibration_in_the_large": -0.0014497106237557154, + "expected_calibration_error_10bin": 0.0014497106237557154, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 10, + "negatives": 2788, + "auroc": 0.8107245337159253, + "auprc": 0.02219037483155002, + "brier": 0.003555357229694564, + "calibration": { + "observed_rate": 0.0035739814152966403, + "mean_prediction": 0.0019436964087502456, + "calibration_in_the_large": -0.0016302850065463947, + "expected_calibration_error_10bin": 0.0017848002968663568, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 10, + "negatives": 2788, + "auroc": 0.8148852223816356, + "auprc": 0.02258219406481831, + "brier": 0.003557597279282272, + "calibration": { + "observed_rate": 0.0035739814152966403, + "mean_prediction": 0.002116962510613761, + "calibration_in_the_large": -0.0014570189046828794, + "expected_calibration_error_10bin": 0.0016232116779677508, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 10, + "negatives": 2788, + "auroc": 0.8181850789096127, + "auprc": 0.022852343431972174, + "brier": 0.00356041892953612, + "calibration": { + "observed_rate": 0.0035739814152966403, + "mean_prediction": 0.0022596329552774957, + "calibration_in_the_large": -0.0013143484600191446, + "expected_calibration_error_10bin": 0.0015664599600563815, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 10, + "negatives": 2788, + "auroc": 0.8188665710186513, + "auprc": 0.023051644789940973, + "brier": 0.003562897720330521, + "calibration": { + "observed_rate": 0.0035739814152966403, + "mean_prediction": 0.002411296007241079, + "calibration_in_the_large": -0.0011626854080555612, + "expected_calibration_error_10bin": 0.001430362667466668, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 10, + "negatives": 2788, + "auroc": 0.8187589670014347, + "auprc": 0.022785458512936927, + "brier": 0.003566891798523336, + "calibration": { + "observed_rate": 0.0035739814152966403, + "mean_prediction": 0.002591722115924458, + "calibration_in_the_large": -0.0009822592993721825, + "expected_calibration_error_10bin": 0.0012742199128560508, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 10, + "negatives": 2788, + "auroc": 0.8194763271162123, + "auprc": 0.02324651867272775, + "brier": 0.0035697209568388865, + "calibration": { + "observed_rate": 0.0035739814152966403, + "mean_prediction": 0.002725841400646384, + "calibration_in_the_large": -0.0008481400146502565, + "expected_calibration_error_10bin": 0.0011552783874726918, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 11, + "negatives": 2787, + "auroc": 0.8321753596242294, + "auprc": 0.02645898072987326, + "brier": 0.003919118790535475, + "calibration": { + "observed_rate": 0.003931379556826304, + "mean_prediction": 0.002841004779686716, + "calibration_in_the_large": -0.0010903747771395882, + "expected_calibration_error_10bin": 0.001553455926788919, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 12, + "negatives": 2786, + "auroc": 0.8055156736061259, + "auprc": 0.025058962159389176, + "brier": 0.004277484197423144, + "calibration": { + "observed_rate": 0.004288777698355968, + "mean_prediction": 0.0029313102522473627, + "calibration_in_the_large": -0.0013574674461086056, + "expected_calibration_error_10bin": 0.0018301785377500517, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 12, + "negatives": 2786, + "auroc": 0.806203637233788, + "auprc": 0.025115840164698477, + "brier": 0.004278048525515481, + "calibration": { + "observed_rate": 0.004288777698355968, + "mean_prediction": 0.0029609774259951364, + "calibration_in_the_large": -0.0013278002723608319, + "expected_calibration_error_10bin": 0.0018042514276463985, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + } + ], + "reason": null + }, + "K76": { + "time_averaged_auroc": 0.8266959225692901, + "time_averaged_auprc": 0.17194880439150304, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2681, + "positives": 10, + "negatives": 2671, + "auroc": 0.8922500935979034, + "auprc": 0.15954419543465592, + "brier": 0.0034886015674888576, + "calibration": { + "observed_rate": 0.003729951510630362, + "mean_prediction": 0.0012361450442619232, + "calibration_in_the_large": -0.0024938064663684385, + "expected_calibration_error_10bin": 0.0024938064663684385, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + { + "valid": 2681, + "positives": 14, + "negatives": 2667, + "auroc": 0.8445819272590926, + "auprc": 0.14768579231228016, + "brier": 0.004858946602795243, + "calibration": { + "observed_rate": 0.005221932114882507, + "mean_prediction": 0.002142196715541782, + "calibration_in_the_large": -0.0030797353993407247, + "expected_calibration_error_10bin": 0.0035858856427395396, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + { + "valid": 2681, + "positives": 17, + "negatives": 2664, + "auroc": 0.8390522875816994, + "auprc": 0.18855339458370207, + "brier": 0.005751877320650227, + "calibration": { + "observed_rate": 0.006340917568071615, + "mean_prediction": 0.0031835345488311468, + "calibration_in_the_large": -0.003157383019240468, + "expected_calibration_error_10bin": 0.0035352724208481314, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + { + "valid": 2681, + "positives": 18, + "negatives": 2663, + "auroc": 0.8480619184712312, + "auprc": 0.1826313983416804, + "brier": 0.0060576452925484164, + "calibration": { + "observed_rate": 0.006713912719134651, + "mean_prediction": 0.003861079550005913, + "calibration_in_the_large": -0.002852833169128738, + "expected_calibration_error_10bin": 0.0032209635496020053, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + { + "valid": 2681, + "positives": 21, + "negatives": 2660, + "auroc": 0.8621911922663802, + "auprc": 0.17806712738520608, + "brier": 0.007117212130333847, + "calibration": { + "observed_rate": 0.007832898172323759, + "mean_prediction": 0.004226765007546421, + "calibration_in_the_large": -0.0036061331647773377, + "expected_calibration_error_10bin": 0.004113938659842062, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + { + "valid": 2681, + "positives": 21, + "negatives": 2660, + "auroc": 0.8624955245255997, + "auprc": 0.17786838275825603, + "brier": 0.007106967279767045, + "calibration": { + "observed_rate": 0.007832898172323759, + "mean_prediction": 0.004508461789802066, + "calibration_in_the_large": -0.003324436382521693, + "expected_calibration_error_10bin": 0.0037999463647179145, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + { + "valid": 2681, + "positives": 26, + "negatives": 2655, + "auroc": 0.8062146892655367, + "auprc": 0.15429914310758838, + "brier": 0.008934419190168203, + "calibration": { + "observed_rate": 0.00969787392763894, + "mean_prediction": 0.004953165553676584, + "calibration_in_the_large": -0.004744708373962357, + "expected_calibration_error_10bin": 0.005306232460643866, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + { + "valid": 2681, + "positives": 29, + "negatives": 2652, + "auroc": 0.7899568315389817, + "auprc": 0.1702687101532421, + "brier": 0.009876591524080663, + "calibration": { + "observed_rate": 0.01081685938082805, + "mean_prediction": 0.00530301180066298, + "calibration_in_the_large": -0.005513847580165069, + "expected_calibration_error_10bin": 0.006114060083560591, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + { + "valid": 2681, + "positives": 30, + "negatives": 2651, + "auroc": 0.7983402489626557, + "auprc": 0.1786986194652996, + "brier": 0.010185714216914043, + "calibration": { + "observed_rate": 0.011189854531891086, + "mean_prediction": 0.005668676793492567, + "calibration_in_the_large": -0.005521177738398519, + "expected_calibration_error_10bin": 0.006106783391039406, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + { + "valid": 2681, + "positives": 31, + "negatives": 2650, + "auroc": 0.8059281801582471, + "auprc": 0.1790982073969422, + "brier": 0.010534019083633933, + "calibration": { + "observed_rate": 0.011562849682954122, + "mean_prediction": 0.005920454783532784, + "calibration_in_the_large": -0.005642394899421338, + "expected_calibration_error_10bin": 0.006247624953383837, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + { + "valid": 2681, + "positives": 32, + "negatives": 2649, + "auroc": 0.8043011513778785, + "auprc": 0.1753504498622474, + "brier": 0.010894233366679319, + "calibration": { + "observed_rate": 0.011935844834017158, + "mean_prediction": 0.00614718606141887, + "calibration_in_the_large": -0.005788658772598289, + "expected_calibration_error_10bin": 0.00642833377496138, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + { + "valid": 2681, + "positives": 33, + "negatives": 2648, + "auroc": 0.7954774329396685, + "auprc": 0.17302283789290254, + "brier": 0.011255812226717845, + "calibration": { + "observed_rate": 0.012308839985080195, + "mean_prediction": 0.006450119844694542, + "calibration_in_the_large": -0.005858720140385652, + "expected_calibration_error_10bin": 0.006531756180350613, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + { + "valid": 2681, + "positives": 34, + "negatives": 2647, + "auroc": 0.7981955154558991, + "auprc": 0.17024619839553634, + "brier": 0.011621271833632138, + "calibration": { + "observed_rate": 0.01268183513614323, + "mean_prediction": 0.0064716962166640754, + "calibration_in_the_large": -0.006210138919479154, + "expected_calibration_error_10bin": 0.006884613830242273, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + } + ], + "reason": null + }, + "K80": { + "time_averaged_auroc": 0.6865113929500197, + "time_averaged_auprc": 0.010781765463756502, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2731, + "positives": 2, + "negatives": 2729, + "auroc": 0.6132282887504581, + "auprc": 0.006175401597415418, + "brier": 0.0007316156621076993, + "calibration": { + "observed_rate": 0.0007323324789454412, + "mean_prediction": 0.0005682551413502315, + "calibration_in_the_large": -0.0001640773375952097, + "expected_calibration_error_10bin": 0.0001640773375952097, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + { + "valid": 2731, + "positives": 3, + "negatives": 2728, + "auroc": 0.7130987292277615, + "auprc": 0.004653053064247719, + "brier": 0.0010993491221072097, + "calibration": { + "observed_rate": 0.0010984987184181618, + "mean_prediction": 0.0011823582181252873, + "calibration_in_the_large": 8.385949970712544e-05, + "expected_calibration_error_10bin": 8.385949970712544e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + { + "valid": 2731, + "positives": 5, + "negatives": 2726, + "auroc": 0.6955245781364637, + "auprc": 0.0052401892568742, + "brier": 0.0018302532892815941, + "calibration": { + "observed_rate": 0.001830831197363603, + "mean_prediction": 0.001464898611634235, + "calibration_in_the_large": -0.000365932585729368, + "expected_calibration_error_10bin": 0.000365932585729368, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + { + "valid": 2731, + "positives": 6, + "negatives": 2725, + "auroc": 0.6890519877675841, + "auprc": 0.005084613573785016, + "brier": 0.002196809120045588, + "calibration": { + "observed_rate": 0.0021969974368363236, + "mean_prediction": 0.0018110023135442885, + "calibration_in_the_large": -0.0003859951232920351, + "expected_calibration_error_10bin": 0.0003859951232920351, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + { + "valid": 2731, + "positives": 7, + "negatives": 2724, + "auroc": 0.7153870358716173, + "auprc": 0.006021895576449763, + "brier": 0.0025622938886572587, + "calibration": { + "observed_rate": 0.002563163676309044, + "mean_prediction": 0.0020961606400960483, + "calibration_in_the_large": -0.00046700303621299583, + "expected_calibration_error_10bin": 0.00046700303621299583, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + { + "valid": 2731, + "positives": 10, + "negatives": 2721, + "auroc": 0.7132304299889747, + "auprc": 0.010618796479780864, + "brier": 0.003648256248366877, + "calibration": { + "observed_rate": 0.003661662394727206, + "mean_prediction": 0.0022825193319240184, + "calibration_in_the_large": -0.0013791430628031878, + "expected_calibration_error_10bin": 0.0013791430628031878, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + { + "valid": 2731, + "positives": 12, + "negatives": 2719, + "auroc": 0.6901127865636877, + "auprc": 0.014495729650959818, + "brier": 0.004370007363710782, + "calibration": { + "observed_rate": 0.004393994873672647, + "mean_prediction": 0.002585469999030732, + "calibration_in_the_large": -0.0018085248746419155, + "expected_calibration_error_10bin": 0.0018085248746419155, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + { + "valid": 2731, + "positives": 12, + "negatives": 2719, + "auroc": 0.6903579747456172, + "auprc": 0.014190237835022525, + "brier": 0.004370131331214902, + "calibration": { + "observed_rate": 0.004393994873672647, + "mean_prediction": 0.0027642068653481702, + "calibration_in_the_large": -0.001629788008324477, + "expected_calibration_error_10bin": 0.001629788008324477, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + { + "valid": 2731, + "positives": 13, + "negatives": 2718, + "auroc": 0.6878077772117507, + "auprc": 0.014358894540457868, + "brier": 0.004734186634731841, + "calibration": { + "observed_rate": 0.004760161113145368, + "mean_prediction": 0.002987366262986393, + "calibration_in_the_large": -0.0017727948501589747, + "expected_calibration_error_10bin": 0.0017727948501589747, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + { + "valid": 2731, + "positives": 14, + "negatives": 2717, + "auroc": 0.6883642673116357, + "auprc": 0.014318085023026204, + "brier": 0.0050986438672005864, + "calibration": { + "observed_rate": 0.005126327352618088, + "mean_prediction": 0.0031672093363534024, + "calibration_in_the_large": -0.001959118016264686, + "expected_calibration_error_10bin": 0.001959118016264686, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + { + "valid": 2731, + "positives": 18, + "negatives": 2713, + "auroc": 0.6763115861899496, + "auprc": 0.014955723336619507, + "brier": 0.006554153228414496, + "calibration": { + "observed_rate": 0.006590992310508971, + "mean_prediction": 0.003372291821841248, + "calibration_in_the_large": -0.003218700488667723, + "expected_calibration_error_10bin": 0.003218700488667723, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + { + "valid": 2731, + "positives": 18, + "negatives": 2713, + "auroc": 0.6760863332923782, + "auprc": 0.015022321490829691, + "brier": 0.006553887663549649, + "calibration": { + "observed_rate": 0.006590992310508971, + "mean_prediction": 0.0035666364487623764, + "calibration_in_the_large": -0.003024355861746595, + "expected_calibration_error_10bin": 0.003024355861746595, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + { + "valid": 2731, + "positives": 18, + "negatives": 2713, + "auroc": 0.6760863332923782, + "auprc": 0.015028009603365942, + "brier": 0.006553906039747152, + "calibration": { + "observed_rate": 0.006590992310508971, + "mean_prediction": 0.0036053995061680268, + "calibration_in_the_large": -0.0029855928043409446, + "expected_calibration_error_10bin": 0.0029855928043409446, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + } + ], + "reason": null + }, + "K81": { + "time_averaged_auroc": 0.8460447435826107, + "time_averaged_auprc": 0.03067478054808342, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2825, + "positives": 0, + "negatives": 2825, + "auroc": null, + "auprc": null, + "brier": 1.9423178522604825e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00046250857307796625, + "calibration_in_the_large": 0.00046250857307796625, + "expected_calibration_error_10bin": 0.00046250857307796625, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.7631951824300389, + "auprc": 0.04241967871485944, + "brier": 0.0006995710191396406, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0007780912214810537, + "calibration_in_the_large": 7.012661971114221e-05, + "expected_calibration_error_10bin": 7.012661971114221e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 4, + "negatives": 2821, + "auroc": 0.8569656150301311, + "auprc": 0.0325250793217785, + "brier": 0.0014035965214484565, + "calibration": { + "observed_rate": 0.001415929203539823, + "mean_prediction": 0.0008747753546989432, + "calibration_in_the_large": -0.0005411538488408798, + "expected_calibration_error_10bin": 0.0005411538488408798, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 5, + "negatives": 2820, + "auroc": 0.8525531914893617, + "auprc": 0.027417605902849595, + "brier": 0.0017565820397842425, + "calibration": { + "observed_rate": 0.0017699115044247787, + "mean_prediction": 0.0010198453074657004, + "calibration_in_the_large": -0.0007500661969590784, + "expected_calibration_error_10bin": 0.0007500661969590784, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 5, + "negatives": 2820, + "auroc": 0.8500709219858156, + "auprc": 0.027010753908186146, + "brier": 0.001756249943315903, + "calibration": { + "observed_rate": 0.0017699115044247787, + "mean_prediction": 0.0010904379462023817, + "calibration_in_the_large": -0.000679473558222397, + "expected_calibration_error_10bin": 0.000679473558222397, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 5, + "negatives": 2820, + "auroc": 0.847304964539007, + "auprc": 0.02658562979739761, + "brier": 0.0017560914607213237, + "calibration": { + "observed_rate": 0.0017699115044247787, + "mean_prediction": 0.0011849574383723744, + "calibration_in_the_large": -0.0005849540660524044, + "expected_calibration_error_10bin": 0.0005849540660524044, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 5, + "negatives": 2820, + "auroc": 0.8497872340425532, + "auprc": 0.026504115056541506, + "brier": 0.00175582466507064, + "calibration": { + "observed_rate": 0.0017699115044247787, + "mean_prediction": 0.0012699013933231869, + "calibration_in_the_large": -0.0005000101111015919, + "expected_calibration_error_10bin": 0.0005000101111015919, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 5, + "negatives": 2820, + "auroc": 0.8497163120567376, + "auprc": 0.028265266039935972, + "brier": 0.0017556707968574285, + "calibration": { + "observed_rate": 0.0017699115044247787, + "mean_prediction": 0.0013492626886927126, + "calibration_in_the_large": -0.0004206488157320661, + "expected_calibration_error_10bin": 0.0004206488157320661, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 5, + "negatives": 2820, + "auroc": 0.8495744680851064, + "auprc": 0.0333009367995895, + "brier": 0.0017553291218800294, + "calibration": { + "observed_rate": 0.0017699115044247787, + "mean_prediction": 0.0014892111633352078, + "calibration_in_the_large": -0.0002807003410895709, + "expected_calibration_error_10bin": 0.0002807003410895709, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 5, + "negatives": 2820, + "auroc": 0.8499290780141844, + "auprc": 0.0304465214382325, + "brier": 0.0017554050697959269, + "calibration": { + "observed_rate": 0.0017699115044247787, + "mean_prediction": 0.0015651968646273264, + "calibration_in_the_large": -0.00020471463979745237, + "expected_calibration_error_10bin": 0.00020471463979745237, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 5, + "negatives": 2820, + "auroc": 0.8494326241134752, + "auprc": 0.033133616621618935, + "brier": 0.0017554310997371153, + "calibration": { + "observed_rate": 0.0017699115044247787, + "mean_prediction": 0.0016048830283591441, + "calibration_in_the_large": -0.00016502847606563462, + "expected_calibration_error_10bin": 0.00016502847606563462, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 6, + "negatives": 2819, + "auroc": 0.8669741042923023, + "auprc": 0.030258398173331837, + "brier": 0.002105812321268226, + "calibration": { + "observed_rate": 0.0021238938053097347, + "mean_prediction": 0.001637778293680857, + "calibration_in_the_large": -0.0004861155116288776, + "expected_calibration_error_10bin": 0.0004861155116288776, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + { + "valid": 2825, + "positives": 6, + "negatives": 2819, + "auroc": 0.8670332269126168, + "auprc": 0.030229764802679467, + "brier": 0.0021058641158858285, + "calibration": { + "observed_rate": 0.0021238938053097347, + "mean_prediction": 0.00165218098983591, + "calibration_in_the_large": -0.00047171281547382475, + "expected_calibration_error_10bin": 0.00047171281547382475, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + } + ], + "reason": null + }, + "K82": { + "time_averaged_auroc": 0.6652580202045837, + "time_averaged_auprc": 0.004272219099953244, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2824, + "positives": 1, + "negatives": 2823, + "auroc": 0.9185263903648601, + "auprc": 0.004329004329004329, + "brier": 0.00035415123114598303, + "calibration": { + "observed_rate": 0.0003541076487252125, + "mean_prediction": 0.000324562396863109, + "calibration_in_the_large": -2.9545251862103455e-05, + "expected_calibration_error_10bin": 2.9545251862103455e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 1, + "negatives": 2823, + "auroc": 0.9567835635848388, + "auprc": 0.008130081300813009, + "brier": 0.00035451964112316923, + "calibration": { + "observed_rate": 0.0003541076487252125, + "mean_prediction": 0.0005930908405183228, + "calibration_in_the_large": 0.00023898319179311032, + "expected_calibration_error_10bin": 0.00023898319179311032, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.8977675407512402, + "auprc": 0.0060439653853346705, + "brier": 0.0007083100342227224, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0006832523701720053, + "calibration_in_the_large": -2.496292727841964e-05, + "expected_calibration_error_10bin": 2.496292727841964e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.6361810232777975, + "auprc": 0.0042872486379622755, + "brier": 0.001062756008880451, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0007754687203165206, + "calibration_in_the_large": -0.0002868542258591169, + "expected_calibration_error_10bin": 0.0002868542258591169, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 4, + "negatives": 2820, + "auroc": 0.5855496453900709, + "auprc": 0.003738424037779566, + "brier": 0.001416991751410708, + "calibration": { + "observed_rate": 0.00141643059490085, + "mean_prediction": 0.0008182743621998422, + "calibration_in_the_large": -0.0005981562327010077, + "expected_calibration_error_10bin": 0.0005981562327010077, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 4, + "negatives": 2820, + "auroc": 0.5867021276595744, + "auprc": 0.0037810806580055078, + "brier": 0.001417325944559713, + "calibration": { + "observed_rate": 0.00141643059490085, + "mean_prediction": 0.0009210230304711782, + "calibration_in_the_large": -0.0004954075644296717, + "expected_calibration_error_10bin": 0.0004954075644296717, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 4, + "negatives": 2820, + "auroc": 0.587145390070922, + "auprc": 0.0036249336673070784, + "brier": 0.0014180428182462704, + "calibration": { + "observed_rate": 0.00141643059490085, + "mean_prediction": 0.0010193539987801647, + "calibration_in_the_large": -0.00039707659612068526, + "expected_calibration_error_10bin": 0.00039707659612068526, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 4, + "negatives": 2820, + "auroc": 0.5837765957446809, + "auprc": 0.0036431545841511207, + "brier": 0.0014183661515589142, + "calibration": { + "observed_rate": 0.00141643059490085, + "mean_prediction": 0.0011100624174182473, + "calibration_in_the_large": -0.0003063681774826026, + "expected_calibration_error_10bin": 0.0003063681774826026, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 4, + "negatives": 2820, + "auroc": 0.5793439716312057, + "auprc": 0.0036583038637621303, + "brier": 0.0014185127962409638, + "calibration": { + "observed_rate": 0.00141643059490085, + "mean_prediction": 0.001162150905968498, + "calibration_in_the_large": -0.00025427968893235197, + "expected_calibration_error_10bin": 0.00025427968893235197, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 4, + "negatives": 2820, + "auroc": 0.5795212765957447, + "auprc": 0.0036437964066561744, + "brier": 0.0014185661066124563, + "calibration": { + "observed_rate": 0.00141643059490085, + "mean_prediction": 0.0011728118281366384, + "calibration_in_the_large": -0.0002436187667642115, + "expected_calibration_error_10bin": 0.0002436187667642115, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 4, + "negatives": 2820, + "auroc": 0.5787234042553191, + "auprc": 0.003569489319500279, + "brier": 0.0014192858289220319, + "calibration": { + "observed_rate": 0.00141643059490085, + "mean_prediction": 0.0012496292167113274, + "calibration_in_the_large": -0.0001668013781895225, + "expected_calibration_error_10bin": 0.0001668013781895225, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 4, + "negatives": 2820, + "auroc": 0.5792553191489361, + "auprc": 0.003544935395015762, + "brier": 0.0014198867677872532, + "calibration": { + "observed_rate": 0.00141643059490085, + "mean_prediction": 0.0013193499632852402, + "calibration_in_the_large": -9.708063161560968e-05, + "expected_calibration_error_10bin": 9.708063161560968e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 4, + "negatives": 2820, + "auroc": 0.5790780141843972, + "auprc": 0.0035444307141002706, + "brier": 0.0014199006357559416, + "calibration": { + "observed_rate": 0.00141643059490085, + "mean_prediction": 0.001321556837888689, + "calibration_in_the_large": -9.487375701216095e-05, + "expected_calibration_error_10bin": 9.487375701216095e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + } + ], + "reason": null + }, + "K83": { + "time_averaged_auroc": 0.8999207705603737, + "time_averaged_auprc": 0.12609990870331592, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2757, + "positives": 1, + "negatives": 2756, + "auroc": 0.9071117561683599, + "auprc": 0.0038910505836575876, + "brier": 0.00039062749399422687, + "calibration": { + "observed_rate": 0.0003627130939426913, + "mean_prediction": 0.0012063124984241875, + "calibration_in_the_large": 0.0008435994044814963, + "expected_calibration_error_10bin": 0.0008435994044814961, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + { + "valid": 2757, + "positives": 4, + "negatives": 2753, + "auroc": 0.9305303305484925, + "auprc": 0.2585927960927961, + "brier": 0.0013904744920042512, + "calibration": { + "observed_rate": 0.0014508523757707653, + "mean_prediction": 0.001950629621404986, + "calibration_in_the_large": 0.0004997772456342207, + "expected_calibration_error_10bin": 0.0011004990043269097, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + { + "valid": 2757, + "positives": 5, + "negatives": 2752, + "auroc": 0.9193313953488372, + "auprc": 0.20972173338673908, + "brier": 0.0017573154895781271, + "calibration": { + "observed_rate": 0.0018135654697134566, + "mean_prediction": 0.0023460467262269476, + "calibration_in_the_large": 0.000532481256513491, + "expected_calibration_error_10bin": 0.0011069919213098182, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + { + "valid": 2757, + "positives": 7, + "negatives": 2750, + "auroc": 0.8701818181818182, + "auprc": 0.15396629855716273, + "brier": 0.0024998623310854844, + "calibration": { + "observed_rate": 0.0025389916575988395, + "mean_prediction": 0.002832692132554151, + "calibration_in_the_large": 0.00029370047495531166, + "expected_calibration_error_10bin": 0.0008503839136884401, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + { + "valid": 2757, + "positives": 8, + "negatives": 2749, + "auroc": 0.8815933066569662, + "auprc": 0.13958808255702257, + "brier": 0.0028680618390124037, + "calibration": { + "observed_rate": 0.0029017047515415306, + "mean_prediction": 0.0032250240461718397, + "calibration_in_the_large": 0.00032331929463030916, + "expected_calibration_error_10bin": 0.0008600699089058763, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + { + "valid": 2757, + "positives": 9, + "negatives": 2748, + "auroc": 0.8908296943231441, + "auprc": 0.13009275852402843, + "brier": 0.0032317865104526567, + "calibration": { + "observed_rate": 0.003264417845484222, + "mean_prediction": 0.0035603837269944302, + "calibration_in_the_large": 0.0002959658815102082, + "expected_calibration_error_10bin": 0.0010047688940326585, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + { + "valid": 2757, + "positives": 10, + "negatives": 2747, + "auroc": 0.8880232981434292, + "auprc": 0.11950345466068543, + "brier": 0.003605566109204643, + "calibration": { + "observed_rate": 0.003627130939426913, + "mean_prediction": 0.003796158232069249, + "calibration_in_the_large": 0.0001690272926423357, + "expected_calibration_error_10bin": 0.0015719597609047016, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + { + "valid": 2757, + "positives": 11, + "negatives": 2746, + "auroc": 0.8912798781699001, + "auprc": 0.11245701491196387, + "brier": 0.003972811736719489, + "calibration": { + "observed_rate": 0.003989844033369605, + "mean_prediction": 0.004030101797261532, + "calibration_in_the_large": 4.0257763891927284e-05, + "expected_calibration_error_10bin": 0.0022997798212344178, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + { + "valid": 2757, + "positives": 12, + "negatives": 2745, + "auroc": 0.8990892531876138, + "auprc": 0.10926683175716628, + "brier": 0.004333803867363942, + "calibration": { + "observed_rate": 0.004352557127312296, + "mean_prediction": 0.004335118952170911, + "calibration_in_the_large": -1.743817514138473e-05, + "expected_calibration_error_10bin": 0.0028247015505942054, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + { + "valid": 2757, + "positives": 14, + "negatives": 2743, + "auroc": 0.8981563460236446, + "auprc": 0.10096551781883374, + "brier": 0.0050447477263043106, + "calibration": { + "observed_rate": 0.005077983315197679, + "mean_prediction": 0.004519022244961526, + "calibration_in_the_large": -0.000558961070236153, + "expected_calibration_error_10bin": 0.0035224966470679413, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + { + "valid": 2757, + "positives": 16, + "negatives": 2741, + "auroc": 0.9074927033929223, + "auprc": 0.10039269118501654, + "brier": 0.005718210331874127, + "calibration": { + "observed_rate": 0.005803409503083061, + "mean_prediction": 0.004723360474062704, + "calibration_in_the_large": -0.0010800490290203569, + "expected_calibration_error_10bin": 0.004130774975292819, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + { + "valid": 2757, + "positives": 16, + "negatives": 2741, + "auroc": 0.907675118569865, + "auprc": 0.1004228553283207, + "brier": 0.005722888316688453, + "calibration": { + "observed_rate": 0.005803409503083061, + "mean_prediction": 0.004866402761758033, + "calibration_in_the_large": -0.000937006741325028, + "expected_calibration_error_10bin": 0.004037996763509396, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + { + "valid": 2757, + "positives": 16, + "negatives": 2741, + "auroc": 0.907675118569865, + "auprc": 0.10043772777971373, + "brier": 0.005724339337418961, + "calibration": { + "observed_rate": 0.005803409503083061, + "mean_prediction": 0.004909558302878704, + "calibration_in_the_large": -0.0008938512002043568, + "expected_calibration_error_10bin": 0.004015213385180998, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + } + ], + "reason": null + }, + "K85": { + "time_averaged_auroc": 0.7353420589347058, + "time_averaged_auprc": 0.017385901887732418, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2779, + "positives": 1, + "negatives": 2778, + "auroc": 0.44096472282217425, + "auprc": 0.0006435006435006435, + "brier": 0.0003599600802928169, + "calibration": { + "observed_rate": 0.0003598416696653472, + "mean_prediction": 0.00023547870796506636, + "calibration_in_the_large": -0.00012436296170028087, + "expected_calibration_error_10bin": 0.00012436296170028087, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + { + "valid": 2779, + "positives": 2, + "negatives": 2777, + "auroc": 0.6404393230104429, + "auprc": 0.002676919615825537, + "brier": 0.0007198360220028482, + "calibration": { + "observed_rate": 0.0007196833393306944, + "mean_prediction": 0.0006816806931810275, + "calibration_in_the_large": -3.8002646149666954e-05, + "expected_calibration_error_10bin": 3.8002646149666954e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + { + "valid": 2779, + "positives": 2, + "negatives": 2777, + "auroc": 0.6371984155563558, + "auprc": 0.0024640648215334647, + "brier": 0.0007213598693229723, + "calibration": { + "observed_rate": 0.0007196833393306944, + "mean_prediction": 0.0009656998890909391, + "calibration_in_the_large": 0.00024601654976024465, + "expected_calibration_error_10bin": 0.00024601654976024465, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + { + "valid": 2779, + "positives": 3, + "negatives": 2776, + "auroc": 0.7536023054755043, + "auprc": 0.020833203150348128, + "brier": 0.0010740285773062155, + "calibration": { + "observed_rate": 0.0010795250089960418, + "mean_prediction": 0.0013340704483349552, + "calibration_in_the_large": 0.00025454543933891346, + "expected_calibration_error_10bin": 0.00025454543933891346, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + { + "valid": 2779, + "positives": 3, + "negatives": 2776, + "auroc": 0.7501200768491835, + "auprc": 0.022158668038099058, + "brier": 0.0010738826310949512, + "calibration": { + "observed_rate": 0.0010795250089960418, + "mean_prediction": 0.0015912647452490279, + "calibration_in_the_large": 0.0005117397362529861, + "expected_calibration_error_10bin": 0.0005117397362529861, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + { + "valid": 2779, + "positives": 4, + "negatives": 2775, + "auroc": 0.809099099099099, + "auprc": 0.027511409614568567, + "brier": 0.0014266807724018695, + "calibration": { + "observed_rate": 0.0014393666786613889, + "mean_prediction": 0.0016606872430757914, + "calibration_in_the_large": 0.00022132056441440248, + "expected_calibration_error_10bin": 0.00022132056441440248, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + { + "valid": 2779, + "positives": 4, + "negatives": 2775, + "auroc": 0.8015315315315316, + "auprc": 0.02433958421581326, + "brier": 0.0014273417814045042, + "calibration": { + "observed_rate": 0.0014393666786613889, + "mean_prediction": 0.0018912756086815418, + "calibration_in_the_large": 0.0004519089300201529, + "expected_calibration_error_10bin": 0.0004519089300201529, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + { + "valid": 2779, + "positives": 5, + "negatives": 2774, + "auroc": 0.7719538572458544, + "auprc": 0.02026827530612036, + "brier": 0.001786400242316119, + "calibration": { + "observed_rate": 0.0017992083483267362, + "mean_prediction": 0.001974706257241339, + "calibration_in_the_large": 0.0001754979089146028, + "expected_calibration_error_10bin": 0.0001754979089146028, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + { + "valid": 2779, + "positives": 8, + "negatives": 2771, + "auroc": 0.773141465175027, + "auprc": 0.019841494634382905, + "brier": 0.002854818559782817, + "calibration": { + "observed_rate": 0.0028787333573227778, + "mean_prediction": 0.0022018265313561536, + "calibration_in_the_large": -0.0006769068259666242, + "expected_calibration_error_10bin": 0.0006769068259666242, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + { + "valid": 2779, + "positives": 9, + "negatives": 2770, + "auroc": 0.7923385479342158, + "auprc": 0.02275487476662246, + "brier": 0.003205665649365059, + "calibration": { + "observed_rate": 0.0032385750269881253, + "mean_prediction": 0.0025120372079823787, + "calibration_in_the_large": -0.0007265378190057467, + "expected_calibration_error_10bin": 0.0007265378190057467, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + { + "valid": 2779, + "positives": 10, + "negatives": 2769, + "auroc": 0.797797038642109, + "auprc": 0.02174299667259509, + "brier": 0.003562335299095503, + "calibration": { + "observed_rate": 0.0035984166966534724, + "mean_prediction": 0.0026423772148828693, + "calibration_in_the_large": -0.0009560394817706031, + "expected_calibration_error_10bin": 0.0009560394817706031, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + { + "valid": 2779, + "positives": 10, + "negatives": 2769, + "auroc": 0.7955940772842182, + "auprc": 0.020389232836848972, + "brier": 0.0035626503268564543, + "calibration": { + "observed_rate": 0.0035984166966534724, + "mean_prediction": 0.002864666697904739, + "calibration_in_the_large": -0.0007337499987487336, + "expected_calibration_error_10bin": 0.0007337499987487336, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + { + "valid": 2779, + "positives": 10, + "negatives": 2769, + "auroc": 0.7956663055254605, + "auprc": 0.020392500224262984, + "brier": 0.0035626613657680334, + "calibration": { + "observed_rate": 0.0035984166966534724, + "mean_prediction": 0.0028724145924676004, + "calibration_in_the_large": -0.0007260021041858721, + "expected_calibration_error_10bin": 0.0007260021041858721, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + } + ], + "reason": null + }, + "K86": { + "time_averaged_auroc": 0.7142988571499606, + "time_averaged_auprc": 0.013583772821543494, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2785, + "positives": 1, + "negatives": 2784, + "auroc": 0.6246408045977011, + "auprc": 0.0009560229445506692, + "brier": 0.0003617049803429946, + "calibration": { + "observed_rate": 0.0003590664272890485, + "mean_prediction": 0.0006818134750296662, + "calibration_in_the_large": 0.0003227470477406177, + "expected_calibration_error_10bin": 0.0003227470477406177, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.813915857605178, + "auprc": 0.014812419828167507, + "brier": 0.0014307801365062223, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.0012603010987264985, + "calibration_in_the_large": -0.00017596461042969553, + "expected_calibration_error_10bin": 0.00017596461042969553, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.811938151743977, + "auprc": 0.01474170306139909, + "brier": 0.0014320014732834372, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.0015854916503797456, + "calibration_in_the_large": 0.00014922594122355158, + "expected_calibration_error_10bin": 0.00014922594122355158, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 5, + "negatives": 2780, + "auroc": 0.683884892086331, + "auprc": 0.011439099685691876, + "brier": 0.001793231766226248, + "calibration": { + "observed_rate": 0.0017953321364452424, + "mean_prediction": 0.0019812431388583824, + "calibration_in_the_large": 0.00018591100241313998, + "expected_calibration_error_10bin": 0.00018591100241313998, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 5, + "negatives": 2780, + "auroc": 0.6831654676258992, + "auprc": 0.011920029131230983, + "brier": 0.0017957501715316986, + "calibration": { + "observed_rate": 0.0017953321364452424, + "mean_prediction": 0.0022555353135657744, + "calibration_in_the_large": 0.00046020317712053196, + "expected_calibration_error_10bin": 0.00046020317712053196, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.7325176922154252, + "auprc": 0.018184598314592165, + "brier": 0.00214660819592492, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.002614887393954067, + "calibration_in_the_large": 0.0004604888302197764, + "expected_calibration_error_10bin": 0.0004604888302197764, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.7053892831430628, + "auprc": 0.015984500997818486, + "brier": 0.0025074141831203122, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.0028725348955487015, + "calibration_in_the_large": 0.0003590699045253622, + "expected_calibration_error_10bin": 0.0003590699045253622, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.7046179162809832, + "auprc": 0.0156728402031456, + "brier": 0.002509725624924042, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.003068742713330525, + "calibration_in_the_large": 0.0005552777223071857, + "expected_calibration_error_10bin": 0.0005552777223071857, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.7041550961637355, + "auprc": 0.014978234550342051, + "brier": 0.0025135640844099146, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.0032620530769600334, + "calibration_in_the_large": 0.0007485880859366941, + "expected_calibration_error_10bin": 0.0007485880859366941, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.7038465494189037, + "auprc": 0.014959799517951775, + "brier": 0.002518274675926362, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.003506037492526689, + "calibration_in_the_large": 0.0009925725015033499, + "expected_calibration_error_10bin": 0.0009925725015033499, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.7064177722925024, + "auprc": 0.014540010839195844, + "brier": 0.0025232370647852984, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.0038053298880770608, + "calibration_in_the_large": 0.0012918648970537214, + "expected_calibration_error_10bin": 0.0012918648970537217, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.7059549521752545, + "auprc": 0.014208917672481768, + "brier": 0.0025266629222221847, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.003965556342476085, + "calibration_in_the_large": 0.0014520913514527458, + "expected_calibration_error_10bin": 0.0014520913514527458, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.7054407076005348, + "auprc": 0.014190869933497583, + "brier": 0.002528038097000442, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.0040343405863131595, + "calibration_in_the_large": 0.0015208755952898201, + "expected_calibration_error_10bin": 0.00152087559528982, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + } + ], + "reason": null + }, + "K90": { + "time_averaged_auroc": 0.6045020701299885, + "time_averaged_auprc": 0.0015387253398419045, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.6791519434628975, + "auprc": 0.0011001100110011, + "brier": 0.00035341424046234744, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0002877452642977786, + "calibration_in_the_large": -6.548680917449267e-05, + "expected_calibration_error_10bin": 6.548680917449267e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.6279151943462897, + "auprc": 0.0009487666034155598, + "brier": 0.00035387420468255656, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.000406175223038834, + "calibration_in_the_large": 5.2943149566562705e-05, + "expected_calibration_error_10bin": 5.2943149566562705e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.6286219081272085, + "auprc": 0.0009505703422053232, + "brier": 0.0003540827248481139, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.00046510655516119584, + "calibration_in_the_large": 0.00011187448168892457, + "expected_calibration_error_10bin": 0.00011187448168892457, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.6091872791519435, + "auprc": 0.0009033423667570009, + "brier": 0.0003542608146191811, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0005080944745155723, + "calibration_in_the_large": 0.00015486240104330102, + "expected_calibration_error_10bin": 0.00015486240104330102, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.6024734982332155, + "auprc": 0.0008880994671403197, + "brier": 0.000354492750984855, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0005514646811749349, + "calibration_in_the_large": 0.00019823260770266364, + "expected_calibration_error_10bin": 0.00019823260770266364, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.6222614840989399, + "auprc": 0.0009345794392523365, + "brier": 0.00035497412467378554, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0006303632892144486, + "calibration_in_the_large": 0.00027713121574217734, + "expected_calibration_error_10bin": 0.00027713121574217734, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.6176678445229682, + "auprc": 0.0009233610341643582, + "brier": 0.00035531536720983766, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0006904732207626721, + "calibration_in_the_large": 0.0003372411472904008, + "expected_calibration_error_10bin": 0.0003372411472904008, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 2, + "negatives": 2829, + "auroc": 0.4602332979851538, + "auprc": 0.0009680969845684265, + "brier": 0.0007094868981192162, + "calibration": { + "observed_rate": 0.0007064641469445425, + "mean_prediction": 0.0007996218005649376, + "calibration_in_the_large": 9.315765362039507e-05, + "expected_calibration_error_10bin": 9.315765362039507e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 2, + "negatives": 2829, + "auroc": 0.46712619300106045, + "auprc": 0.0009770862574600891, + "brier": 0.000709892646353587, + "calibration": { + "observed_rate": 0.0007064641469445425, + "mean_prediction": 0.0008459003217285242, + "calibration_in_the_large": 0.0001394361747839816, + "expected_calibration_error_10bin": 0.0001394361747839816, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 3, + "negatives": 2828, + "auroc": 0.5884016973125884, + "auprc": 0.0017891166271136816, + "brier": 0.001062821095253854, + "calibration": { + "observed_rate": 0.0010596962204168139, + "mean_prediction": 0.0009052206883382142, + "calibration_in_the_large": -0.00015447553207859966, + "expected_calibration_error_10bin": 0.00015447553207859966, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 3, + "negatives": 2828, + "auroc": 0.5894625176803394, + "auprc": 0.001792517160361164, + "brier": 0.001062872511704949, + "calibration": { + "observed_rate": 0.0010596962204168139, + "mean_prediction": 0.0009151146842633162, + "calibration_in_the_large": -0.00014458153615349765, + "expected_calibration_error_10bin": 0.00014458153615349765, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.6828793774319066, + "auprc": 0.0039084582878374675, + "brier": 0.0014137672597438302, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0009722776404711939, + "calibration_in_the_large": -0.0004406506534178912, + "expected_calibration_error_10bin": 0.0004406506534178912, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.6831446763353378, + "auprc": 0.003919324836667932, + "brier": 0.0014138271185148807, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0009823020174632127, + "calibration_in_the_large": -0.00043062627642587235, + "expected_calibration_error_10bin": 0.00043062627642587235, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + } + ], + "reason": null + }, + "K91": { + "time_averaged_auroc": 0.8700134879623624, + "time_averaged_auprc": 0.056247967455091974, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2768, + "positives": 8, + "negatives": 2760, + "auroc": 0.8395380434782609, + "auprc": 0.03255883113163166, + "brier": 0.0028516185033926446, + "calibration": { + "observed_rate": 0.002890173410404624, + "mean_prediction": 0.0020607667188638212, + "calibration_in_the_large": -0.0008294066915408029, + "expected_calibration_error_10bin": 0.0008294066915408029, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 13, + "negatives": 2755, + "auroc": 0.8627669970682675, + "auprc": 0.034413500724918264, + "brier": 0.004622851933015879, + "calibration": { + "observed_rate": 0.004696531791907515, + "mean_prediction": 0.0034157783901235424, + "calibration_in_the_large": -0.0012807534017839723, + "expected_calibration_error_10bin": 0.0013582734897913116, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 14, + "negatives": 2754, + "auroc": 0.867050523913269, + "auprc": 0.03836541058918131, + "brier": 0.004966632556014997, + "calibration": { + "observed_rate": 0.0050578034682080926, + "mean_prediction": 0.004099888949805731, + "calibration_in_the_large": -0.0009579145184023617, + "expected_calibration_error_10bin": 0.0012717955009581123, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 15, + "negatives": 2753, + "auroc": 0.8718246761109093, + "auprc": 0.04044280498090688, + "brier": 0.0053187584670092766, + "calibration": { + "observed_rate": 0.00541907514450867, + "mean_prediction": 0.004950300409935237, + "calibration_in_the_large": -0.00046877473457343326, + "expected_calibration_error_10bin": 0.0009353656163948259, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 17, + "negatives": 2751, + "auroc": 0.8866508435435243, + "auprc": 0.059485487760460004, + "brier": 0.005950326801881608, + "calibration": { + "observed_rate": 0.006141618497109827, + "mean_prediction": 0.005578327461345823, + "calibration_in_the_large": -0.0005632910357640042, + "expected_calibration_error_10bin": 0.0010761533500133977, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 17, + "negatives": 2751, + "auroc": 0.8860948959736566, + "auprc": 0.05889079011792146, + "brier": 0.005949306905040381, + "calibration": { + "observed_rate": 0.006141618497109827, + "mean_prediction": 0.005994678736697412, + "calibration_in_the_large": -0.0001469397604124149, + "expected_calibration_error_10bin": 0.0008300005914851165, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 20, + "negatives": 2748, + "auroc": 0.8703966521106259, + "auprc": 0.06075879160452082, + "brier": 0.0069859351493600395, + "calibration": { + "observed_rate": 0.0072254335260115606, + "mean_prediction": 0.006637898663287376, + "calibration_in_the_large": -0.0005875348627241844, + "expected_calibration_error_10bin": 0.0009064581279828852, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 22, + "negatives": 2746, + "auroc": 0.8620803813811826, + "auprc": 0.0599961203105432, + "brier": 0.007682467034681423, + "calibration": { + "observed_rate": 0.007947976878612716, + "mean_prediction": 0.007028507391560775, + "calibration_in_the_large": -0.0009194694870519413, + "expected_calibration_error_10bin": 0.0013546141383239906, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 22, + "negatives": 2746, + "auroc": 0.8626928424816261, + "auprc": 0.061482536497008515, + "brier": 0.00768375945645228, + "calibration": { + "observed_rate": 0.007947976878612716, + "mean_prediction": 0.00743911766116954, + "calibration_in_the_large": -0.0005088592174431758, + "expected_calibration_error_10bin": 0.0006717238596932317, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 24, + "negatives": 2744, + "auroc": 0.8693816812439261, + "auprc": 0.06716072407284862, + "brier": 0.00835108481628282, + "calibration": { + "observed_rate": 0.008670520231213872, + "mean_prediction": 0.007706600364512837, + "calibration_in_the_large": -0.0009639198667010353, + "expected_calibration_error_10bin": 0.001130719933615898, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 26, + "negatives": 2742, + "auroc": 0.8770689558435729, + "auprc": 0.07219914368577171, + "brier": 0.00900487432959727, + "calibration": { + "observed_rate": 0.00939306358381503, + "mean_prediction": 0.008045759465684794, + "calibration_in_the_large": -0.0013473041181302353, + "expected_calibration_error_10bin": 0.0018251657419321706, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 26, + "negatives": 2742, + "auroc": 0.8773074117713068, + "auprc": 0.07276671989608784, + "brier": 0.00900290489215732, + "calibration": { + "observed_rate": 0.00939306358381503, + "mean_prediction": 0.008397454275647677, + "calibration_in_the_large": -0.0009956093081673525, + "expected_calibration_error_10bin": 0.0015307254353696285, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 26, + "negatives": 2742, + "auroc": 0.8773214385905852, + "auprc": 0.07270271554439539, + "brier": 0.009002347403942058, + "calibration": { + "observed_rate": 0.00939306358381503, + "mean_prediction": 0.008453219244679294, + "calibration_in_the_large": -0.0009398443391357356, + "expected_calibration_error_10bin": 0.0015549945062095535, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + } + ], + "reason": null + }, + "K92": { + "time_averaged_auroc": 0.8469383159707518, + "time_averaged_auprc": 0.07542172545632264, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2751, + "positives": 7, + "negatives": 2744, + "auroc": 0.8197625989171179, + "auprc": 0.03221576085527368, + "brier": 0.0025147223297918415, + "calibration": { + "observed_rate": 0.002544529262086514, + "mean_prediction": 0.0031550485149649, + "calibration_in_the_large": 0.0006105192528783857, + "expected_calibration_error_10bin": 0.0006105192528783857, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 11, + "negatives": 2740, + "auroc": 0.8752488387524884, + "auprc": 0.03423840198752282, + "brier": 0.0039271834120101455, + "calibration": { + "observed_rate": 0.003998545983278807, + "mean_prediction": 0.0048845236097718155, + "calibration_in_the_large": 0.0008859776264930081, + "expected_calibration_error_10bin": 0.0008859776264930081, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 17, + "negatives": 2734, + "auroc": 0.8827617367356598, + "auprc": 0.07027462462755274, + "brier": 0.005975284077976552, + "calibration": { + "observed_rate": 0.0061795710650672485, + "mean_prediction": 0.006162624280207323, + "calibration_in_the_large": -1.6946784859925637e-05, + "expected_calibration_error_10bin": 9.296671347214363e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 19, + "negatives": 2732, + "auroc": 0.8317022424289127, + "auprc": 0.06121305331402543, + "brier": 0.006694160883707989, + "calibration": { + "observed_rate": 0.0069065794256633955, + "mean_prediction": 0.007205667703496516, + "calibration_in_the_large": 0.00029908827783312053, + "expected_calibration_error_10bin": 0.0002990882778331199, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 23, + "negatives": 2728, + "auroc": 0.8466626290960092, + "auprc": 0.08225866449957144, + "brier": 0.008019646561389608, + "calibration": { + "observed_rate": 0.008360596146855689, + "mean_prediction": 0.00806886959576264, + "calibration_in_the_large": -0.00029172655109304876, + "expected_calibration_error_10bin": 0.0008100261659432016, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 26, + "negatives": 2725, + "auroc": 0.8592237120677487, + "auprc": 0.09014472256469198, + "brier": 0.009022500898435044, + "calibration": { + "observed_rate": 0.009451108687749909, + "mean_prediction": 0.008753936154810528, + "calibration_in_the_large": -0.0006971725329393812, + "expected_calibration_error_10bin": 0.0006971725329393832, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 29, + "negatives": 2722, + "auroc": 0.8671489016696649, + "auprc": 0.09080724707866174, + "brier": 0.010047747567520379, + "calibration": { + "observed_rate": 0.010541621228644129, + "mean_prediction": 0.009367133283406876, + "calibration_in_the_large": -0.0011744879452372532, + "expected_calibration_error_10bin": 0.0011744879452372516, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 30, + "negatives": 2721, + "auroc": 0.8710278084037731, + "auprc": 0.09204359659276898, + "brier": 0.01036685807477627, + "calibration": { + "observed_rate": 0.010905125408942203, + "mean_prediction": 0.010054936185990782, + "calibration_in_the_large": -0.0008501892229514207, + "expected_calibration_error_10bin": 0.0009977612234695196, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 33, + "negatives": 2718, + "auroc": 0.8596561642919259, + "auprc": 0.09317872230898237, + "brier": 0.011389229801194169, + "calibration": { + "observed_rate": 0.011995637949836423, + "mean_prediction": 0.010652524358953473, + "calibration_in_the_large": -0.0013431135908829502, + "expected_calibration_error_10bin": 0.0014974884616914537, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 35, + "negatives": 2716, + "auroc": 0.8372080791079318, + "auprc": 0.08647585724576086, + "brier": 0.012102790559803909, + "calibration": { + "observed_rate": 0.01272264631043257, + "mean_prediction": 0.011158543734511892, + "calibration_in_the_large": -0.001564102575920677, + "expected_calibration_error_10bin": 0.0017255012723694269, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 36, + "negatives": 2715, + "auroc": 0.8277573153263761, + "auprc": 0.08419283163914028, + "brier": 0.012460554153589288, + "calibration": { + "observed_rate": 0.013086150490730643, + "mean_prediction": 0.011620085662662826, + "calibration_in_the_large": -0.001466064828067817, + "expected_calibration_error_10bin": 0.0016323063423215895, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 37, + "negatives": 2714, + "auroc": 0.8159592901671016, + "auprc": 0.08175943737037895, + "brier": 0.012821964339986584, + "calibration": { + "observed_rate": 0.013449654671028717, + "mean_prediction": 0.012041352653465637, + "calibration_in_the_large": -0.0014083020175630796, + "expected_calibration_error_10bin": 0.0015784773950389519, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + { + "valid": 2751, + "positives": 37, + "negatives": 2714, + "auroc": 0.8160787906550618, + "auprc": 0.08167951084786298, + "brier": 0.01282097956955817, + "calibration": { + "observed_rate": 0.013449654671028717, + "mean_prediction": 0.012142109837962272, + "calibration_in_the_large": -0.0013075448330664447, + "expected_calibration_error_10bin": 0.0014789051859802412, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + } + ], + "reason": null + }, + "K94": { + "time_averaged_auroc": 0.9080560045693471, + "time_averaged_auprc": 0.07481900769782371, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2823, + "positives": 5, + "negatives": 2818, + "auroc": 0.8772178850248403, + "auprc": 0.011669132219471712, + "brier": 0.0017850396813429033, + "calibration": { + "observed_rate": 0.001771165426850868, + "mean_prediction": 0.0018685014364434754, + "calibration_in_the_large": 9.733600959260747e-05, + "expected_calibration_error_10bin": 9.733600959260747e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 8, + "negatives": 2815, + "auroc": 0.9157637655417407, + "auprc": 0.07505536458523408, + "brier": 0.0027411602177574903, + "calibration": { + "observed_rate": 0.0028338646829613886, + "mean_prediction": 0.002534860658660864, + "calibration_in_the_large": -0.00029900402430052455, + "expected_calibration_error_10bin": 0.0002990040243005248, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 11, + "negatives": 2812, + "auroc": 0.9201474201474201, + "auprc": 0.09677263945413396, + "brier": 0.003745505245277006, + "calibration": { + "observed_rate": 0.0038965639390719092, + "mean_prediction": 0.0030088416199425365, + "calibration_in_the_large": -0.0008877223191293727, + "expected_calibration_error_10bin": 0.0008877223191293725, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 12, + "negatives": 2811, + "auroc": 0.9252934898612594, + "auprc": 0.09606195216387554, + "brier": 0.004082154608151865, + "calibration": { + "observed_rate": 0.004250797024442083, + "mean_prediction": 0.0035368094936731173, + "calibration_in_the_large": -0.0007139875307689654, + "expected_calibration_error_10bin": 0.0007139875307689657, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 13, + "negatives": 2810, + "auroc": 0.9264166438543663, + "auprc": 0.07867865932148604, + "brier": 0.004429121530629129, + "calibration": { + "observed_rate": 0.004605030109812256, + "mean_prediction": 0.003920479696697609, + "calibration_in_the_large": -0.0006845504131146474, + "expected_calibration_error_10bin": 0.0008717705448363746, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 13, + "negatives": 2810, + "auroc": 0.9275116342732002, + "auprc": 0.08124361307299952, + "brier": 0.004425078530151302, + "calibration": { + "observed_rate": 0.004605030109812256, + "mean_prediction": 0.00444005718529553, + "calibration_in_the_large": -0.0001649729245167264, + "expected_calibration_error_10bin": 0.0006120847628612027, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 14, + "negatives": 2809, + "auroc": 0.900244113309261, + "auprc": 0.07614860117030935, + "brier": 0.004782548594550405, + "calibration": { + "observed_rate": 0.00495926319518243, + "mean_prediction": 0.004725418185362309, + "calibration_in_the_large": -0.00023384500982012116, + "expected_calibration_error_10bin": 0.0009788222981456645, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 14, + "negatives": 2809, + "auroc": 0.899252402990388, + "auprc": 0.07538267808372323, + "brier": 0.0047889240041410226, + "calibration": { + "observed_rate": 0.00495926319518243, + "mean_prediction": 0.004954087627049464, + "calibration_in_the_large": -5.175568132966511e-06, + "expected_calibration_error_10bin": 0.0008503027426772922, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 14, + "negatives": 2809, + "auroc": 0.8994558307481055, + "auprc": 0.0759305474090421, + "brier": 0.0047905823317679905, + "calibration": { + "observed_rate": 0.00495926319518243, + "mean_prediction": 0.005216265792988805, + "calibration_in_the_large": 0.0002570025978063748, + "expected_calibration_error_10bin": 0.0006236831601593505, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 14, + "negatives": 2809, + "auroc": 0.9013629659767075, + "auprc": 0.0764549509616441, + "brier": 0.004794550096870914, + "calibration": { + "observed_rate": 0.00495926319518243, + "mean_prediction": 0.005520479929521926, + "calibration_in_the_large": 0.0005612167343394953, + "expected_calibration_error_10bin": 0.0007164457673714922, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 14, + "negatives": 2809, + "auroc": 0.9015918222041398, + "auprc": 0.07667480190182988, + "brier": 0.004796474940434995, + "calibration": { + "observed_rate": 0.00495926319518243, + "mean_prediction": 0.005703005759569299, + "calibration_in_the_large": 0.0007437425643868683, + "expected_calibration_error_10bin": 0.0008850520653943055, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 15, + "negatives": 2808, + "auroc": 0.9052469135802469, + "auprc": 0.07628789100394383, + "brier": 0.005147222463602729, + "calibration": { + "observed_rate": 0.005313496280552604, + "mean_prediction": 0.006024579206079236, + "calibration_in_the_large": 0.0007110829255266319, + "expected_calibration_error_10bin": 0.0012482626606110279, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + { + "valid": 2823, + "positives": 15, + "negatives": 2808, + "auroc": 0.9052231718898386, + "auprc": 0.0762862687240148, + "brier": 0.005147454555979954, + "calibration": { + "observed_rate": 0.005313496280552604, + "mean_prediction": 0.0060323824991637826, + "calibration_in_the_large": 0.0007188862186111788, + "expected_calibration_error_10bin": 0.001114248324674972, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + } + ], + "reason": null + }, + "L02": { + "time_averaged_auroc": 0.7288976740780697, + "time_averaged_auprc": 0.02133574122052054, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2807, + "positives": 3, + "negatives": 2804, + "auroc": 0.4431764146457442, + "auprc": 0.0012417677109620238, + "brier": 0.0010749921306152956, + "calibration": { + "observed_rate": 0.0010687566797292483, + "mean_prediction": 0.0017732214736943714, + "calibration_in_the_large": 0.0007044647939651232, + "expected_calibration_error_10bin": 0.0007044647939651232, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 9, + "negatives": 2798, + "auroc": 0.703081566198078, + "auprc": 0.019544023506255972, + "brier": 0.003191117486810378, + "calibration": { + "observed_rate": 0.003206270039187745, + "mean_prediction": 0.0025958968061487375, + "calibration_in_the_large": -0.0006103732330390074, + "expected_calibration_error_10bin": 0.0006103732330390074, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.7219520915266356, + "auprc": 0.01879257446792263, + "brier": 0.0035387239315249086, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.003457544419542801, + "calibration_in_the_large": -0.00010497784622135993, + "expected_calibration_error_10bin": 0.00010497784622135993, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 11, + "negatives": 2796, + "auroc": 0.7259396540512421, + "auprc": 0.016950626043169822, + "brier": 0.0038928362307698804, + "calibration": { + "observed_rate": 0.003918774492340577, + "mean_prediction": 0.004382587387682727, + "calibration_in_the_large": 0.0004638128953421503, + "expected_calibration_error_10bin": 0.0004638128953421503, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 13, + "negatives": 2794, + "auroc": 0.7604482132041187, + "auprc": 0.022786330499090107, + "brier": 0.004584742622765637, + "calibration": { + "observed_rate": 0.004631278945493409, + "mean_prediction": 0.004775958947603775, + "calibration_in_the_large": 0.00014468000211036603, + "expected_calibration_error_10bin": 0.00014468000211036603, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 15, + "negatives": 2792, + "auroc": 0.7770296084049666, + "auprc": 0.023213117312396715, + "brier": 0.0052813645525287296, + "calibration": { + "observed_rate": 0.005343783398646241, + "mean_prediction": 0.005245694366459063, + "calibration_in_the_large": -9.808903218717826e-05, + "expected_calibration_error_10bin": 9.808903218717826e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 15, + "negatives": 2792, + "auroc": 0.776647564469914, + "auprc": 0.02291895307240848, + "brier": 0.0052814619308491845, + "calibration": { + "observed_rate": 0.005343783398646241, + "mean_prediction": 0.005726327517527409, + "calibration_in_the_large": 0.00038254411888116735, + "expected_calibration_error_10bin": 0.00038254411888116735, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 16, + "negatives": 2791, + "auroc": 0.7644437477606593, + "auprc": 0.022537957437215317, + "brier": 0.005635945227127494, + "calibration": { + "observed_rate": 0.0057000356252226575, + "mean_prediction": 0.006165697652412599, + "calibration_in_the_large": 0.00046566202718994164, + "expected_calibration_error_10bin": 0.00046566202718994164, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 17, + "negatives": 2790, + "auroc": 0.76314568838288, + "auprc": 0.02213946797971205, + "brier": 0.00598949587363489, + "calibration": { + "observed_rate": 0.006056287851799074, + "mean_prediction": 0.006582502602483187, + "calibration_in_the_large": 0.0005262147506841135, + "expected_calibration_error_10bin": 0.0005262147506841135, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 17, + "negatives": 2790, + "auroc": 0.7640522875816993, + "auprc": 0.022221637787055916, + "brier": 0.005993779148310266, + "calibration": { + "observed_rate": 0.006056287851799074, + "mean_prediction": 0.007520851908990862, + "calibration_in_the_large": 0.0014645640571917884, + "expected_calibration_error_10bin": 0.0014645640571917884, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 19, + "negatives": 2788, + "auroc": 0.762157366155705, + "auprc": 0.028470760568647845, + "brier": 0.006675804440505985, + "calibration": { + "observed_rate": 0.006768792304951906, + "mean_prediction": 0.007746406839639585, + "calibration_in_the_large": 0.0009776145346876795, + "expected_calibration_error_10bin": 0.0009776145346876795, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 22, + "negatives": 2785, + "auroc": 0.75674881671291, + "auprc": 0.02827347871669278, + "brier": 0.007723557473967863, + "calibration": { + "observed_rate": 0.007837548984681154, + "mean_prediction": 0.008021735299832682, + "calibration_in_the_large": 0.00018418631515152752, + "expected_calibration_error_10bin": 0.00018418631515152752, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 22, + "negatives": 2785, + "auroc": 0.7568467439203526, + "auprc": 0.02827394076523736, + "brier": 0.0077235910515775445, + "calibration": { + "observed_rate": 0.007837548984681154, + "mean_prediction": 0.00803615101599833, + "calibration_in_the_large": 0.0001986020313171754, + "expected_calibration_error_10bin": 0.0001986020313171754, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + } + ], + "reason": null + }, + "L03": { + "time_averaged_auroc": 0.7196706077083377, + "time_averaged_auprc": 0.04694980330222612, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2701, + "positives": 7, + "negatives": 2694, + "auroc": 0.5287411178279775, + "auprc": 0.004468392559434761, + "brier": 0.0025896938838065138, + "calibration": { + "observed_rate": 0.00259163272861903, + "mean_prediction": 0.0019186745277123523, + "calibration_in_the_large": -0.0006729582009066778, + "expected_calibration_error_10bin": 0.0006729582009066778, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + { + "valid": 2701, + "positives": 11, + "negatives": 2690, + "auroc": 0.6786414329165259, + "auprc": 0.011320226102780922, + "brier": 0.004058183732989258, + "calibration": { + "observed_rate": 0.004072565716401333, + "mean_prediction": 0.0035769257204415674, + "calibration_in_the_large": -0.0004956399959597652, + "expected_calibration_error_10bin": 0.0004956399959597652, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + { + "valid": 2701, + "positives": 21, + "negatives": 2680, + "auroc": 0.7133262260127932, + "auprc": 0.019050692146202884, + "brier": 0.00770863091766619, + "calibration": { + "observed_rate": 0.00777489818585709, + "mean_prediction": 0.004550103366532115, + "calibration_in_the_large": -0.0032247948193249746, + "expected_calibration_error_10bin": 0.0032247948193249746, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + { + "valid": 2701, + "positives": 25, + "negatives": 2676, + "auroc": 0.7473841554559043, + "auprc": 0.04496642718275097, + "brier": 0.009069317522019138, + "calibration": { + "observed_rate": 0.009255831173639394, + "mean_prediction": 0.005874465834348101, + "calibration_in_the_large": -0.003381365339291293, + "expected_calibration_error_10bin": 0.0033813653392912924, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + { + "valid": 2701, + "positives": 27, + "negatives": 2674, + "auroc": 0.7281226626776365, + "auprc": 0.04266472054997929, + "brier": 0.009796749641879751, + "calibration": { + "observed_rate": 0.009996297667530544, + "mean_prediction": 0.006782070056158861, + "calibration_in_the_large": -0.0032142276113716834, + "expected_calibration_error_10bin": 0.0032142276113716834, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + { + "valid": 2701, + "positives": 31, + "negatives": 2670, + "auroc": 0.7372598767669446, + "auprc": 0.045623522808591895, + "brier": 0.011222585130567635, + "calibration": { + "observed_rate": 0.011477230655312847, + "mean_prediction": 0.007465877219177238, + "calibration_in_the_large": -0.004011353436135609, + "expected_calibration_error_10bin": 0.00401135343613561, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + { + "valid": 2701, + "positives": 35, + "negatives": 2666, + "auroc": 0.7408637873754153, + "auprc": 0.054525865808157534, + "brier": 0.012605361070988247, + "calibration": { + "observed_rate": 0.01295816364309515, + "mean_prediction": 0.008178856681606252, + "calibration_in_the_large": -0.004779306961488898, + "expected_calibration_error_10bin": 0.004781258522600721, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + { + "valid": 2701, + "positives": 36, + "negatives": 2665, + "auroc": 0.7394830102147175, + "auprc": 0.05362667072944911, + "brier": 0.012963652481229108, + "calibration": { + "observed_rate": 0.013328396890040726, + "mean_prediction": 0.00888982301669558, + "calibration_in_the_large": -0.004438573873345146, + "expected_calibration_error_10bin": 0.004975216342719848, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + { + "valid": 2701, + "positives": 41, + "negatives": 2660, + "auroc": 0.7474692829635063, + "auprc": 0.06317075646254863, + "brier": 0.0146820237258111, + "calibration": { + "observed_rate": 0.015179563124768604, + "mean_prediction": 0.009602632534154285, + "calibration_in_the_large": -0.005576930590614319, + "expected_calibration_error_10bin": 0.005892339260205756, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + { + "valid": 2701, + "positives": 43, + "negatives": 2658, + "auroc": 0.7515880098692844, + "auprc": 0.06548225920008091, + "brier": 0.01537765007520586, + "calibration": { + "observed_rate": 0.015920029618659754, + "mean_prediction": 0.010042924987490475, + "calibration_in_the_large": -0.005877104631169279, + "expected_calibration_error_10bin": 0.006207241253196016, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + { + "valid": 2701, + "positives": 46, + "negatives": 2655, + "auroc": 0.7420944894784246, + "auprc": 0.06359309912222154, + "brier": 0.016466237621557977, + "calibration": { + "observed_rate": 0.017030729359496483, + "mean_prediction": 0.010597329816439367, + "calibration_in_the_large": -0.006433399543057116, + "expected_calibration_error_10bin": 0.007188714506179669, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + { + "valid": 2701, + "positives": 48, + "negatives": 2653, + "auroc": 0.7469452820706118, + "auprc": 0.06949945978783414, + "brier": 0.017130414712581525, + "calibration": { + "observed_rate": 0.017771195853387635, + "mean_prediction": 0.010932833335687528, + "calibration_in_the_large": -0.006838362517700107, + "expected_calibration_error_10bin": 0.007719619143688729, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + { + "valid": 2701, + "positives": 50, + "negatives": 2651, + "auroc": 0.7537985665786495, + "auprc": 0.0723553504689069, + "brier": 0.017818096681529647, + "calibration": { + "observed_rate": 0.018511662347278787, + "mean_prediction": 0.011001203618253215, + "calibration_in_the_large": -0.007510458729025572, + "expected_calibration_error_10bin": 0.008401743373077607, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + } + ], + "reason": null + }, + "L08": { + "time_averaged_auroc": 0.6938358832825805, + "time_averaged_auprc": 0.006500210990971848, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2830, + "positives": 3, + "negatives": 2827, + "auroc": 0.7647683056243367, + "auprc": 0.004515490857269144, + "brier": 0.001059197067774615, + "calibration": { + "observed_rate": 0.0010600706713780918, + "mean_prediction": 0.0004057884014114745, + "calibration_in_the_large": -0.0006542822699666173, + "expected_calibration_error_10bin": 0.0006542822699666173, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + { + "valid": 2830, + "positives": 3, + "negatives": 2827, + "auroc": 0.7707817474354439, + "auprc": 0.0054457722409498276, + "brier": 0.0010590952707770032, + "calibration": { + "observed_rate": 0.0010600706713780918, + "mean_prediction": 0.000654352718886626, + "calibration_in_the_large": -0.0004057179524914658, + "expected_calibration_error_10bin": 0.0004057179524914658, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + { + "valid": 2830, + "positives": 4, + "negatives": 2826, + "auroc": 0.8060863411181882, + "auprc": 0.0077251723963105605, + "brier": 0.0014112683844067103, + "calibration": { + "observed_rate": 0.0014134275618374558, + "mean_prediction": 0.000763732487128552, + "calibration_in_the_large": -0.0006496950747089037, + "expected_calibration_error_10bin": 0.0006496950747089037, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.6732035398230088, + "auprc": 0.006945504454163814, + "brier": 0.0017642869403887013, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.0009916871882723246, + "calibration_in_the_large": -0.0007750972640244952, + "expected_calibration_error_10bin": 0.0007750972640244952, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.6696637168141593, + "auprc": 0.0071099816114909425, + "brier": 0.001764584977554842, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.0011477243743468763, + "calibration_in_the_large": -0.0006190600779499434, + "expected_calibration_error_10bin": 0.0006190600779499434, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.6681061946902654, + "auprc": 0.007008367395822767, + "brier": 0.001765388063413262, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.0013292215338274844, + "calibration_in_the_large": -0.0004375629184693354, + "expected_calibration_error_10bin": 0.0004375629184693354, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.6664070796460178, + "auprc": 0.006754753539051013, + "brier": 0.001766228143686742, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.0014794669982797447, + "calibration_in_the_large": -0.00028731745401707506, + "expected_calibration_error_10bin": 0.00028731745401707506, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.664283185840708, + "auprc": 0.006575477634189986, + "brier": 0.001768348590714543, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.001707024713017385, + "calibration_in_the_large": -5.97597392794347e-05, + "expected_calibration_error_10bin": 5.97597392794347e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.6632212389380531, + "auprc": 0.006551660273699312, + "brier": 0.0017692090825272642, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.0017850829285046854, + "calibration_in_the_large": 1.82984762078656e-05, + "expected_calibration_error_10bin": 1.82984762078656e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.6696637168141593, + "auprc": 0.006512988953866377, + "brier": 0.001770060321667941, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.0018994082606493417, + "calibration_in_the_large": 0.00013262380835252197, + "expected_calibration_error_10bin": 0.00013262380835252197, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.6690265486725664, + "auprc": 0.00649115948554298, + "brier": 0.001770288014232642, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.0019213527875628269, + "calibration_in_the_large": 0.00015456833526600712, + "expected_calibration_error_10bin": 0.00015456833526600712, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.6673982300884955, + "auprc": 0.006433447988928616, + "brier": 0.0017706475086424172, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.001978545265651535, + "calibration_in_the_large": 0.00021176081335471525, + "expected_calibration_error_10bin": 0.00021176081335471525, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.6672566371681415, + "auprc": 0.0064329660513486875, + "brier": 0.001770699666046615, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.0019832865875782017, + "calibration_in_the_large": 0.00021650213528138194, + "expected_calibration_error_10bin": 0.00021650213528138194, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + } + ], + "reason": null + }, + "L27": { + "time_averaged_auroc": 0.7840924878913884, + "time_averaged_auprc": 0.014640214772497837, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2818, + "positives": 3, + "negatives": 2815, + "auroc": 0.7475429248075784, + "auprc": 0.005017589525741747, + "brier": 0.0010756906962142271, + "calibration": { + "observed_rate": 0.0010645848119233499, + "mean_prediction": 0.0013085809528573685, + "calibration_in_the_large": 0.0002439961409340186, + "expected_calibration_error_10bin": 0.0002439961409340186, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.8177746178457164, + "auprc": 0.008852961486882973, + "brier": 0.0017948092210922563, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.002172023769228319, + "calibration_in_the_large": 0.00039771574935606926, + "expected_calibration_error_10bin": 0.00039771574935606926, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.8189121933878422, + "auprc": 0.008470848221857775, + "brier": 0.001875698535071134, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.003205914428047541, + "calibration_in_the_large": 0.001431606408175291, + "expected_calibration_error_10bin": 0.001431606408175291, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 7, + "negatives": 2811, + "auroc": 0.7475733089393708, + "auprc": 0.010519051394680111, + "brier": 0.0027022723819490812, + "calibration": { + "observed_rate": 0.00248403122782115, + "mean_prediction": 0.004037642863041655, + "calibration_in_the_large": 0.001553611635220505, + "expected_calibration_error_10bin": 0.0015536116352205052, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 7, + "negatives": 2811, + "auroc": 0.7475224881841744, + "auprc": 0.010105616218748642, + "brier": 0.002721527980550885, + "calibration": { + "observed_rate": 0.00248403122782115, + "mean_prediction": 0.004349235103316813, + "calibration_in_the_large": 0.0018652038754956636, + "expected_calibration_error_10bin": 0.0018652038754956631, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 7, + "negatives": 2811, + "auroc": 0.7451339126899426, + "auprc": 0.00986848240702154, + "brier": 0.0027496979686662698, + "calibration": { + "observed_rate": 0.00248403122782115, + "mean_prediction": 0.004601359778046515, + "calibration_in_the_large": 0.0021173285502253656, + "expected_calibration_error_10bin": 0.0021173285502253656, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 8, + "negatives": 2810, + "auroc": 0.7711743772241992, + "auprc": 0.012965771072999191, + "brier": 0.003104182479214283, + "calibration": { + "observed_rate": 0.0028388928317956, + "mean_prediction": 0.0047469837979533455, + "calibration_in_the_large": 0.0019080909661577457, + "expected_calibration_error_10bin": 0.0019080909661577455, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 9, + "negatives": 2809, + "auroc": 0.7934021597246944, + "auprc": 0.021368694788755516, + "brier": 0.003385365443843775, + "calibration": { + "observed_rate": 0.00319375443577005, + "mean_prediction": 0.00501396915869034, + "calibration_in_the_large": 0.0018202147229202897, + "expected_calibration_error_10bin": 0.0018202147229202902, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 10, + "negatives": 2808, + "auroc": 0.7918091168091168, + "auprc": 0.020237156874096777, + "brier": 0.003791014505138145, + "calibration": { + "observed_rate": 0.0035486160397444995, + "mean_prediction": 0.0054136609505416496, + "calibration_in_the_large": 0.00186504491079715, + "expected_calibration_error_10bin": 0.00186504491079715, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 11, + "negatives": 2807, + "auroc": 0.7998186352301065, + "auprc": 0.02066612748542132, + "brier": 0.004145959981821802, + "calibration": { + "observed_rate": 0.0039034776437189495, + "mean_prediction": 0.005472445155243279, + "calibration_in_the_large": 0.00156896751152433, + "expected_calibration_error_10bin": 0.0015689675115243295, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 12, + "negatives": 2806, + "auroc": 0.8044369208838203, + "auprc": 0.02069856393371217, + "brier": 0.004556909732512666, + "calibration": { + "observed_rate": 0.0042583392476933995, + "mean_prediction": 0.005792442757846459, + "calibration_in_the_large": 0.0015341035101530598, + "expected_calibration_error_10bin": 0.0017388586666213326, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 12, + "negatives": 2806, + "auroc": 0.8040508434307436, + "auprc": 0.0207734652780364, + "brier": 0.00456794588589511, + "calibration": { + "observed_rate": 0.0042583392476933995, + "mean_prediction": 0.0059310185580823465, + "calibration_in_the_large": 0.001672679310388947, + "expected_calibration_error_10bin": 0.001672679310388947, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 12, + "negatives": 2806, + "auroc": 0.8040508434307436, + "auprc": 0.020778463354517735, + "brier": 0.004569226576524132, + "calibration": { + "observed_rate": 0.0042583392476933995, + "mean_prediction": 0.005944822602491806, + "calibration_in_the_large": 0.0016864833547984067, + "expected_calibration_error_10bin": 0.0016864833547984071, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + } + ], + "reason": null + }, + "L29": { + "time_averaged_auroc": 0.4926012146247257, + "time_averaged_auprc": 0.002348845195138764, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2817, + "positives": 2, + "negatives": 2815, + "auroc": 0.21296625222024868, + "auprc": 0.000657938301517418, + "brier": 0.0007144821601346231, + "calibration": { + "observed_rate": 0.0007099751508697196, + "mean_prediction": 0.0010509899089400693, + "calibration_in_the_large": 0.0003410147580703497, + "expected_calibration_error_10bin": 0.0003410147580703497, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 2, + "negatives": 2815, + "auroc": 0.25737122557726466, + "auprc": 0.0007007489337884125, + "brier": 0.0007210634513661779, + "calibration": { + "observed_rate": 0.0007099751508697196, + "mean_prediction": 0.0014541043755126424, + "calibration_in_the_large": 0.0007441292246429228, + "expected_calibration_error_10bin": 0.0007441292246429228, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 2, + "negatives": 2815, + "auroc": 0.327708703374778, + "auprc": 0.0007873610730668597, + "brier": 0.0007337799358521033, + "calibration": { + "observed_rate": 0.0007099751508697196, + "mean_prediction": 0.0020405160659719133, + "calibration_in_the_large": 0.0013305409151021937, + "expected_calibration_error_10bin": 0.0013305409151021937, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.5619521440416962, + "auprc": 0.0029896814290712036, + "brier": 0.0010952858232280848, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.0025181529522201873, + "calibration_in_the_large": 0.0014531902259156079, + "expected_calibration_error_10bin": 0.0014531902259156079, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.5694148306088604, + "auprc": 0.002889072459688942, + "brier": 0.001104712314291977, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.0029924262467910046, + "calibration_in_the_large": 0.0019274635204864251, + "expected_calibration_error_10bin": 0.0019274635204864251, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.5695332859511963, + "auprc": 0.002956383966510873, + "brier": 0.0011145432401958183, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.0033445549085036625, + "calibration_in_the_large": 0.002279592182199083, + "expected_calibration_error_10bin": 0.002279592182199083, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.5670457237621417, + "auprc": 0.0028951089684812067, + "brier": 0.0011265903746145018, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.0037338600907248125, + "calibration_in_the_large": 0.002668897364420233, + "expected_calibration_error_10bin": 0.002668897364420233, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.5643212508884151, + "auprc": 0.002868240519896321, + "brier": 0.0011389974738909372, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.0040550065425486274, + "calibration_in_the_large": 0.002990043816244048, + "expected_calibration_error_10bin": 0.002990043816244048, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.5720208481402511, + "auprc": 0.0028634490566326848, + "brier": 0.0011455987295243067, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.004226445653403914, + "calibration_in_the_large": 0.0031614829270993345, + "expected_calibration_error_10bin": 0.0031614829270993345, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.5739161336176262, + "auprc": 0.00284795765727903, + "brier": 0.0011579783186675653, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.004457068005715999, + "calibration_in_the_large": 0.003392105279411419, + "expected_calibration_error_10bin": 0.003392105279411419, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.5752191423833215, + "auprc": 0.0028378344894883674, + "brier": 0.0011661836348567348, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.004696355859575368, + "calibration_in_the_large": 0.003631393133270788, + "expected_calibration_error_10bin": 0.0036313931332707878, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 4, + "negatives": 2813, + "auroc": 0.5260398151439744, + "auprc": 0.0026218263888579205, + "brier": 0.0015299339150858387, + "calibration": { + "observed_rate": 0.0014199503017394391, + "mean_prediction": 0.004930606152838176, + "calibration_in_the_large": 0.0035106558510987367, + "expected_calibration_error_10bin": 0.0035106558510987363, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + { + "valid": 2817, + "positives": 4, + "negatives": 2813, + "auroc": 0.5263064344116601, + "auprc": 0.0026193842925246917, + "brier": 0.001532463166840436, + "calibration": { + "observed_rate": 0.0014199503017394391, + "mean_prediction": 0.004991605387646691, + "calibration_in_the_large": 0.003571655085907252, + "expected_calibration_error_10bin": 0.0035716550859072526, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + } + ], + "reason": null + }, + "L30": { + "time_averaged_auroc": 0.7592646539450174, + "time_averaged_auprc": 0.04027577307824022, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2816, + "positives": 1, + "negatives": 2815, + "auroc": 0.9982238010657194, + "auprc": 0.16666666666666666, + "brier": 0.00035181400368677646, + "calibration": { + "observed_rate": 0.0003551136363636364, + "mean_prediction": 0.0003968297213151314, + "calibration_in_the_large": 4.171608495149502e-05, + "expected_calibration_error_10bin": 4.171608495149502e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 2, + "negatives": 2814, + "auroc": 0.8303127221037668, + "auprc": 0.08438375350140055, + "brier": 0.0007039335857950084, + "calibration": { + "observed_rate": 0.0007102272727272727, + "mean_prediction": 0.0006982948439984552, + "calibration_in_the_large": -1.193242872881751e-05, + "expected_calibration_error_10bin": 1.193242872881751e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 3, + "negatives": 2813, + "auroc": 0.810048583955445, + "auprc": 0.029844985931942455, + "brier": 0.0010570356232121427, + "calibration": { + "observed_rate": 0.001065340909090909, + "mean_prediction": 0.0010342781283725344, + "calibration_in_the_large": -3.10627807183746e-05, + "expected_calibration_error_10bin": 3.10627807183746e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 5, + "negatives": 2811, + "auroc": 0.6986837424404126, + "auprc": 0.029173921563214012, + "brier": 0.0017635562337389226, + "calibration": { + "observed_rate": 0.0017755681818181818, + "mean_prediction": 0.0012891355855541324, + "calibration_in_the_large": -0.0004864325962640494, + "expected_calibration_error_10bin": 0.0004864325962640494, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 6, + "negatives": 2810, + "auroc": 0.7149466192170818, + "auprc": 0.023494887872473832, + "brier": 0.002117656900684508, + "calibration": { + "observed_rate": 0.002130681818181818, + "mean_prediction": 0.001527467978093, + "calibration_in_the_large": -0.000603213840088818, + "expected_calibration_error_10bin": 0.000603213840088818, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 7, + "negatives": 2809, + "auroc": 0.6999949143060571, + "auprc": 0.021094212071680735, + "brier": 0.0024737503119048056, + "calibration": { + "observed_rate": 0.0024857954545454545, + "mean_prediction": 0.001881559966710194, + "calibration_in_the_large": -0.0006042354878352605, + "expected_calibration_error_10bin": 0.0006042354878352605, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 7, + "negatives": 2809, + "auroc": 0.700249199003204, + "auprc": 0.021108418266427276, + "brier": 0.002475485756776563, + "calibration": { + "observed_rate": 0.0024857954545454545, + "mean_prediction": 0.0020989374000738403, + "calibration_in_the_large": -0.0003868580544716142, + "expected_calibration_error_10bin": 0.0004608078291141735, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 7, + "negatives": 2809, + "auroc": 0.7024360473986675, + "auprc": 0.02125349408315901, + "brier": 0.0024776294583847874, + "calibration": { + "observed_rate": 0.0024857954545454545, + "mean_prediction": 0.002267085490364645, + "calibration_in_the_large": -0.0002187099641808095, + "expected_calibration_error_10bin": 0.0003010433776415247, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 8, + "negatives": 2808, + "auroc": 0.7407407407407407, + "auprc": 0.02533665035956778, + "brier": 0.0028225055995683367, + "calibration": { + "observed_rate": 0.002840909090909091, + "mean_prediction": 0.0025266915961853183, + "calibration_in_the_large": -0.0003142174947237727, + "expected_calibration_error_10bin": 0.0004849307059218558, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 8, + "negatives": 2808, + "auroc": 0.7426549145299145, + "auprc": 0.025343316702592922, + "brier": 0.002824654857541244, + "calibration": { + "observed_rate": 0.002840909090909091, + "mean_prediction": 0.0027249083986553365, + "calibration_in_the_large": -0.00011600069225375454, + "expected_calibration_error_10bin": 0.0002947414489669467, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 8, + "negatives": 2808, + "auroc": 0.7431000712250713, + "auprc": 0.02536355446637353, + "brier": 0.002825220634313226, + "calibration": { + "observed_rate": 0.002840909090909091, + "mean_prediction": 0.0027597400214512454, + "calibration_in_the_large": -8.116906945784558e-05, + "expected_calibration_error_10bin": 0.00026150760529669055, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 8, + "negatives": 2808, + "auroc": 0.7444355413105413, + "auprc": 0.0252597991407148, + "brier": 0.002826977949005803, + "calibration": { + "observed_rate": 0.002840909090909091, + "mean_prediction": 0.0029380251878282334, + "calibration_in_the_large": 9.711609691914237e-05, + "expected_calibration_error_10bin": 9.711609691914266e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + { + "valid": 2816, + "positives": 8, + "negatives": 2808, + "auroc": 0.744613603988604, + "auprc": 0.02526138939090923, + "brier": 0.002827116200059973, + "calibration": { + "observed_rate": 0.002840909090909091, + "mean_prediction": 0.002945834924239741, + "calibration_in_the_large": 0.00010492583333065022, + "expected_calibration_error_10bin": 0.00010492583333065005, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + } + ], + "reason": null + }, + "L50": { + "time_averaged_auroc": 0.7616803288011803, + "time_averaged_auprc": 0.01195249873904374, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2835, + "positives": 1, + "negatives": 2834, + "auroc": 0.7251235003528581, + "auprc": 0.001282051282051282, + "brier": 0.0003527275382472936, + "calibration": { + "observed_rate": 0.0003527336860670194, + "mean_prediction": 0.00021844668916802946, + "calibration_in_the_large": -0.00013428699689898996, + "expected_calibration_error_10bin": 0.00013428699689898996, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + { + "valid": 2835, + "positives": 2, + "negatives": 2833, + "auroc": 0.8233321567243205, + "auprc": 0.01954205997194738, + "brier": 0.0007034084139042858, + "calibration": { + "observed_rate": 0.0007054673721340388, + "mean_prediction": 0.0004548739389581807, + "calibration_in_the_large": -0.00025059343317585816, + "expected_calibration_error_10bin": 0.00025059343317585816, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + { + "valid": 2835, + "positives": 2, + "negatives": 2833, + "auroc": 0.7979174020472997, + "auprc": 0.01875, + "brier": 0.0007031743245697834, + "calibration": { + "observed_rate": 0.0007054673721340388, + "mean_prediction": 0.0006811115321676769, + "calibration_in_the_large": -2.4355839966361975e-05, + "expected_calibration_error_10bin": 2.4355839966361975e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + { + "valid": 2835, + "positives": 2, + "negatives": 2833, + "auroc": 0.7892693258030357, + "auprc": 0.01809754369390647, + "brier": 0.0007033075391555873, + "calibration": { + "observed_rate": 0.0007054673721340388, + "mean_prediction": 0.0008178591636369129, + "calibration_in_the_large": 0.00011239179150287408, + "expected_calibration_error_10bin": 0.00011239179150287408, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + { + "valid": 2835, + "positives": 2, + "negatives": 2833, + "auroc": 0.7829156371337804, + "auprc": 0.015539910709905312, + "brier": 0.0007038223738098903, + "calibration": { + "observed_rate": 0.0007054673721340388, + "mean_prediction": 0.0009260064736101038, + "calibration_in_the_large": 0.00022053910147606492, + "expected_calibration_error_10bin": 0.00022053910147606492, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + { + "valid": 2835, + "positives": 3, + "negatives": 2832, + "auroc": 0.7556497175141242, + "auprc": 0.010634693368617524, + "brier": 0.001056313322064426, + "calibration": { + "observed_rate": 0.0010582010582010583, + "mean_prediction": 0.000964603616980872, + "calibration_in_the_large": -9.359744122018631e-05, + "expected_calibration_error_10bin": 9.359744122018631e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + { + "valid": 2835, + "positives": 3, + "negatives": 2832, + "auroc": 0.7543549905838042, + "auprc": 0.010624761371227219, + "brier": 0.0010566702912991892, + "calibration": { + "observed_rate": 0.0010582010582010583, + "mean_prediction": 0.0010509087914316398, + "calibration_in_the_large": -7.29226676941851e-06, + "expected_calibration_error_10bin": 7.29226676941851e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + { + "valid": 2835, + "positives": 3, + "negatives": 2832, + "auroc": 0.7521186440677966, + "auprc": 0.010375383773621053, + "brier": 0.0010567979665842104, + "calibration": { + "observed_rate": 0.0010582010582010583, + "mean_prediction": 0.0010776763263708137, + "calibration_in_the_large": 1.9475268169755417e-05, + "expected_calibration_error_10bin": 1.9475268169755417e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + { + "valid": 2835, + "positives": 3, + "negatives": 2832, + "auroc": 0.7521186440677966, + "auprc": 0.010375103922972716, + "brier": 0.0010570534900129435, + "calibration": { + "observed_rate": 0.0010582010582010583, + "mean_prediction": 0.0011208916388594132, + "calibration_in_the_large": 6.269058065835496e-05, + "expected_calibration_error_10bin": 6.269058065835496e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + { + "valid": 2835, + "positives": 3, + "negatives": 2832, + "auroc": 0.7448210922787194, + "auprc": 0.010107985642525116, + "brier": 0.00105750421658799, + "calibration": { + "observed_rate": 0.0010582010582010583, + "mean_prediction": 0.0011968871083295769, + "calibration_in_the_large": 0.00013868605012851858, + "expected_calibration_error_10bin": 0.00013868605012851858, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + { + "valid": 2835, + "positives": 3, + "negatives": 2832, + "auroc": 0.7421139359698682, + "auprc": 0.010093240093240093, + "brier": 0.0010578727300112288, + "calibration": { + "observed_rate": 0.0010582010582010583, + "mean_prediction": 0.0012633533611274826, + "calibration_in_the_large": 0.0002051523029264243, + "expected_calibration_error_10bin": 0.0002051523029264243, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + { + "valid": 2835, + "positives": 3, + "negatives": 2832, + "auroc": 0.7410546139359698, + "auprc": 0.010087951264421852, + "brier": 0.0010579561441714453, + "calibration": { + "observed_rate": 0.0010582010582010583, + "mean_prediction": 0.001276600446169736, + "calibration_in_the_large": 0.00021839938796867778, + "expected_calibration_error_10bin": 0.00021839938796867778, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + { + "valid": 2835, + "positives": 3, + "negatives": 2832, + "auroc": 0.7410546139359698, + "auprc": 0.009871798513132576, + "brier": 0.0010580716141111357, + "calibration": { + "observed_rate": 0.0010582010582010583, + "mean_prediction": 0.001307329801376293, + "calibration_in_the_large": 0.00024912874317523483, + "expected_calibration_error_10bin": 0.00024912874317523483, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + } + ], + "reason": null + }, + "L53": { + "time_averaged_auroc": null, + "time_averaged_auprc": null, + "valid_timepoint_cells": 0, + "timepoints": [ + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 4.0173553077312046e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00030242648950017266, + "calibration_in_the_large": 0.00030242648950017266, + "expected_calibration_error_10bin": 0.00030242648950017266, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 1.7986162570243918e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.000589659493540077, + "calibration_in_the_large": 0.000589659493540077, + "expected_calibration_error_10bin": 0.000589659493540077, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 2.806583917422636e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0008048813835886229, + "calibration_in_the_large": 0.0008048813835886229, + "expected_calibration_error_10bin": 0.0008048813835886229, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 4.04848928871679e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0010194108696631313, + "calibration_in_the_large": 0.0010194108696631313, + "expected_calibration_error_10bin": 0.0010194108696631313, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 5.165391560243218e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0011394980755677938, + "calibration_in_the_large": 0.0011394980755677938, + "expected_calibration_error_10bin": 0.0011394980755677938, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 6.005969695635811e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0012168651415965669, + "calibration_in_the_large": 0.0012168651415965669, + "expected_calibration_error_10bin": 0.0012168651415965669, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 6.531562936809537e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001267790095363672, + "calibration_in_the_large": 0.001267790095363672, + "expected_calibration_error_10bin": 0.001267790095363672, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 6.813719173698966e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0013058170114555233, + "calibration_in_the_large": 0.0013058170114555233, + "expected_calibration_error_10bin": 0.0013058170114555233, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 8.614201090959664e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001429730304968995, + "calibration_in_the_large": 0.001429730304968995, + "expected_calibration_error_10bin": 0.001429730304968995, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 9.304496879146182e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0014917131175700262, + "calibration_in_the_large": 0.0014917131175700262, + "expected_calibration_error_10bin": 0.0014917131175700262, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 9.707916955677141e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0015371182772385918, + "calibration_in_the_large": 0.0015371182772385918, + "expected_calibration_error_10bin": 0.0015371182772385918, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 1.07128954044678e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0016259517591990567, + "calibration_in_the_large": 0.0016259517591990567, + "expected_calibration_error_10bin": 0.0016259517591990567, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 1.0755037155608527e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001629317722645183, + "calibration_in_the_large": 0.001629317722645183, + "expected_calibration_error_10bin": 0.001629317722645183, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + } + ], + "reason": "no_two_class_timepoint" + }, + "L76": { + "time_averaged_auroc": 0.6395629026491245, + "time_averaged_auprc": 0.007237127492714255, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2793, + "positives": 6, + "negatives": 2787, + "auroc": 0.6366463341705537, + "auprc": 0.003562570770011667, + "brier": 0.002159120137487786, + "calibration": { + "observed_rate": 0.0021482277121374865, + "mean_prediction": 0.0026744246823425417, + "calibration_in_the_large": 0.0005261969702050552, + "expected_calibration_error_10bin": 0.0005261969702050552, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 8, + "negatives": 2785, + "auroc": 0.5565978456014362, + "auprc": 0.003719458611884151, + "brier": 0.002883616909108177, + "calibration": { + "observed_rate": 0.0028643036161833156, + "mean_prediction": 0.003625925309673101, + "calibration_in_the_large": 0.0007616216934897852, + "expected_calibration_error_10bin": 0.0007616216934897852, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 8, + "negatives": 2785, + "auroc": 0.5603231597845602, + "auprc": 0.0037679803321776155, + "brier": 0.0028883594623175936, + "calibration": { + "observed_rate": 0.0028643036161833156, + "mean_prediction": 0.003900872004126743, + "calibration_in_the_large": 0.0010365683879434272, + "expected_calibration_error_10bin": 0.0010365683879434272, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 10, + "negatives": 2783, + "auroc": 0.583794466403162, + "auprc": 0.004666288263715087, + "brier": 0.003605558117691466, + "calibration": { + "observed_rate": 0.0035803795202291443, + "mean_prediction": 0.004292754148075329, + "calibration_in_the_large": 0.0007123746278461848, + "expected_calibration_error_10bin": 0.0007123746278461848, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 10, + "negatives": 2783, + "auroc": 0.5904060366510959, + "auprc": 0.004707106435741041, + "brier": 0.003609180749808833, + "calibration": { + "observed_rate": 0.0035803795202291443, + "mean_prediction": 0.004543196420011916, + "calibration_in_the_large": 0.0009628168997827717, + "expected_calibration_error_10bin": 0.0009628168997827717, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 11, + "negatives": 2782, + "auroc": 0.6190771844977453, + "auprc": 0.005691400528457884, + "brier": 0.003962684793098518, + "calibration": { + "observed_rate": 0.003938417472252059, + "mean_prediction": 0.0047078120058582145, + "calibration_in_the_large": 0.0007693945336061554, + "expected_calibration_error_10bin": 0.0007693945336061554, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 13, + "negatives": 2780, + "auroc": 0.6715273934698395, + "auprc": 0.008813044700681007, + "brier": 0.004660595730946544, + "calibration": { + "observed_rate": 0.004654493376297888, + "mean_prediction": 0.0050189586773114105, + "calibration_in_the_large": 0.0003644653010135227, + "expected_calibration_error_10bin": 0.0003644653010135227, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 13, + "negatives": 2780, + "auroc": 0.6719977863862756, + "auprc": 0.008831261531783522, + "brier": 0.004665971578894082, + "calibration": { + "observed_rate": 0.004654493376297888, + "mean_prediction": 0.0053355278999294925, + "calibration_in_the_large": 0.0006810345236316047, + "expected_calibration_error_10bin": 0.0006810345236316047, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 13, + "negatives": 2780, + "auroc": 0.6719977863862756, + "auprc": 0.008898719165647377, + "brier": 0.004670256709039089, + "calibration": { + "observed_rate": 0.004654493376297888, + "mean_prediction": 0.005539417492897957, + "calibration_in_the_large": 0.0008849241166000695, + "expected_calibration_error_10bin": 0.0008849241166000695, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 13, + "negatives": 2780, + "auroc": 0.6747371333702269, + "auprc": 0.009143495500996648, + "brier": 0.00467614669155206, + "calibration": { + "observed_rate": 0.004654493376297888, + "mean_prediction": 0.005862420137823755, + "calibration_in_the_large": 0.0012079267615258673, + "expected_calibration_error_10bin": 0.0012079267615258673, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 13, + "negatives": 2780, + "auroc": 0.6747648035417819, + "auprc": 0.009186484123127512, + "brier": 0.004678417751666033, + "calibration": { + "observed_rate": 0.004654493376297888, + "mean_prediction": 0.005982711292299613, + "calibration_in_the_large": 0.0013282179160017255, + "expected_calibration_error_10bin": 0.0013282179160017255, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 15, + "negatives": 2778, + "auroc": 0.7011999040076794, + "auprc": 0.01154635556637857, + "brier": 0.005380882050632226, + "calibration": { + "observed_rate": 0.0053705692803437165, + "mean_prediction": 0.006236734617821358, + "calibration_in_the_large": 0.0008661653374776417, + "expected_calibration_error_10bin": 0.0008661653374776419, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + { + "valid": 2793, + "positives": 15, + "negatives": 2778, + "auroc": 0.7012479001679865, + "auprc": 0.011548491874683235, + "brier": 0.00538114195777582, + "calibration": { + "observed_rate": 0.0053705692803437165, + "mean_prediction": 0.006249682795524136, + "calibration_in_the_large": 0.0008791135151804191, + "expected_calibration_error_10bin": 0.00087911351518042, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + } + ], + "reason": null + }, + "L89": { + "time_averaged_auroc": 0.8522489657204292, + "time_averaged_auprc": 0.03007443424769056, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2798, + "positives": 8, + "negatives": 2790, + "auroc": 0.8666218637992832, + "auprc": 0.017588297013280105, + "brier": 0.0028444278829086785, + "calibration": { + "observed_rate": 0.0028591851322373124, + "mean_prediction": 0.001024228521547906, + "calibration_in_the_large": -0.0018349566106894064, + "expected_calibration_error_10bin": 0.0018349566106894064, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 10, + "negatives": 2788, + "auroc": 0.857819225251076, + "auprc": 0.018251626700766993, + "brier": 0.0035508243129443256, + "calibration": { + "observed_rate": 0.0035739814152966403, + "mean_prediction": 0.002323245981444404, + "calibration_in_the_large": -0.0012507354338522365, + "expected_calibration_error_10bin": 0.0012507354338522365, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 11, + "negatives": 2787, + "auroc": 0.8459079492448707, + "auprc": 0.017235525453385858, + "brier": 0.003913285147122346, + "calibration": { + "observed_rate": 0.003931379556826304, + "mean_prediction": 0.002959743655933338, + "calibration_in_the_large": -0.0009716359008929663, + "expected_calibration_error_10bin": 0.001049825329296056, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 14, + "negatives": 2784, + "auroc": 0.8518575533661741, + "auprc": 0.022779276420210628, + "brier": 0.0049700637679488185, + "calibration": { + "observed_rate": 0.005003573981415297, + "mean_prediction": 0.0039800479604281055, + "calibration_in_the_large": -0.0010235260209871914, + "expected_calibration_error_10bin": 0.0013556934343684642, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 15, + "negatives": 2783, + "auroc": 0.8590729428674093, + "auprc": 0.025685819952697773, + "brier": 0.005321998441324884, + "calibration": { + "observed_rate": 0.005360972122944961, + "mean_prediction": 0.004321109337828755, + "calibration_in_the_large": -0.0010398627851162063, + "expected_calibration_error_10bin": 0.0014180224514502816, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 17, + "negatives": 2781, + "auroc": 0.8548977303974449, + "auprc": 0.028389267134713684, + "brier": 0.006024080713190215, + "calibration": { + "observed_rate": 0.006075768406004289, + "mean_prediction": 0.004630265135551277, + "calibration_in_the_large": -0.0014455032704530114, + "expected_calibration_error_10bin": 0.001856425680005531, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 19, + "negatives": 2779, + "auroc": 0.8343402587072215, + "auprc": 0.02900226944851772, + "brier": 0.0067327081783548565, + "calibration": { + "observed_rate": 0.006790564689063617, + "mean_prediction": 0.005000976730664273, + "calibration_in_the_large": -0.0017895879583993439, + "expected_calibration_error_10bin": 0.0022390712712202043, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 20, + "negatives": 2778, + "auroc": 0.8402627789776818, + "auprc": 0.030941601302051654, + "brier": 0.00709035650632395, + "calibration": { + "observed_rate": 0.007147962830593281, + "mean_prediction": 0.005434083784873095, + "calibration_in_the_large": -0.001713879045720186, + "expected_calibration_error_10bin": 0.002383489410784438, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 21, + "negatives": 2777, + "auroc": 0.8454138587375893, + "auprc": 0.03427285801102456, + "brier": 0.007443369019288246, + "calibration": { + "observed_rate": 0.007505360972122945, + "mean_prediction": 0.005729715282445727, + "calibration_in_the_large": -0.0017756456896772174, + "expected_calibration_error_10bin": 0.0025212504590206063, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 22, + "negatives": 2776, + "auroc": 0.8506025674613571, + "auprc": 0.0376526666481677, + "brier": 0.007792916213310184, + "calibration": { + "observed_rate": 0.007862759113652609, + "mean_prediction": 0.005986741921470477, + "calibration_in_the_large": -0.001876017192182132, + "expected_calibration_error_10bin": 0.002898350637860663, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 24, + "negatives": 2774, + "auroc": 0.8593637346791637, + "auprc": 0.043215198042499396, + "brier": 0.008472819276359718, + "calibration": { + "observed_rate": 0.008577555396711936, + "mean_prediction": 0.00634298103462524, + "calibration_in_the_large": -0.002234574362086696, + "expected_calibration_error_10bin": 0.0033813901645173595, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 25, + "negatives": 2773, + "auroc": 0.8566173818968627, + "auprc": 0.042945981253753096, + "brier": 0.00882832623139987, + "calibration": { + "observed_rate": 0.008934953538241601, + "mean_prediction": 0.00651965347167085, + "calibration_in_the_large": -0.002415300066570751, + "expected_calibration_error_10bin": 0.0035977917732563135, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + { + "valid": 2798, + "positives": 25, + "negatives": 2773, + "auroc": 0.8564587089794446, + "auprc": 0.04300725783890814, + "brier": 0.00882934270227861, + "calibration": { + "observed_rate": 0.008934953538241601, + "mean_prediction": 0.006567974087705003, + "calibration_in_the_large": -0.0023669794505365984, + "expected_calibration_error_10bin": 0.0036309517238287577, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + } + ], + "reason": null + }, + "L97": { + "time_averaged_auroc": 0.9127920174798347, + "time_averaged_auprc": 0.06504661084461155, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2789, + "positives": 2, + "negatives": 2787, + "auroc": 0.9156799425905993, + "auprc": 0.016568819308545334, + "brier": 0.0007156698250962747, + "calibration": { + "observed_rate": 0.0007171029042667623, + "mean_prediction": 0.0006439100992786253, + "calibration_in_the_large": -7.319280498813705e-05, + "expected_calibration_error_10bin": 7.319280498813705e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 3, + "negatives": 2786, + "auroc": 0.9392199090691553, + "auprc": 0.021892612816167705, + "brier": 0.0010839010774662842, + "calibration": { + "observed_rate": 0.0010756543564001434, + "mean_prediction": 0.0015493935734248883, + "calibration_in_the_large": 0.0004737392170247449, + "expected_calibration_error_10bin": 0.0004737392170247451, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 4, + "negatives": 2785, + "auroc": 0.958527827648115, + "auprc": 0.03178052155910788, + "brier": 0.0014413318482054433, + "calibration": { + "observed_rate": 0.0014342058085335247, + "mean_prediction": 0.002162248415866491, + "calibration_in_the_large": 0.0007280426073329662, + "expected_calibration_error_10bin": 0.0007280426073329664, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 5, + "negatives": 2784, + "auroc": 0.9636494252873563, + "auprc": 0.09185640771753774, + "brier": 0.0017461674335612206, + "calibration": { + "observed_rate": 0.0017927572606669057, + "mean_prediction": 0.002896218061619878, + "calibration_in_the_large": 0.0011034608009529723, + "expected_calibration_error_10bin": 0.001103460800952972, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 5, + "negatives": 2784, + "auroc": 0.960632183908046, + "auprc": 0.08953395556157226, + "brier": 0.0017707151020797832, + "calibration": { + "observed_rate": 0.0017927572606669057, + "mean_prediction": 0.003675807759791157, + "calibration_in_the_large": 0.0018830504991242515, + "expected_calibration_error_10bin": 0.0022037455699445785, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 8, + "negatives": 2781, + "auroc": 0.8845738942826321, + "auprc": 0.06195323399652756, + "brier": 0.002854651691712061, + "calibration": { + "observed_rate": 0.0028684116170670493, + "mean_prediction": 0.004278860772039418, + "calibration_in_the_large": 0.001410449154972369, + "expected_calibration_error_10bin": 0.0014577403542246402, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 8, + "negatives": 2781, + "auroc": 0.8874056094929881, + "auprc": 0.05689693202021247, + "brier": 0.002890478760243847, + "calibration": { + "observed_rate": 0.0028684116170670493, + "mean_prediction": 0.004834943988437727, + "calibration_in_the_large": 0.0019665323713706777, + "expected_calibration_error_10bin": 0.001995892601043068, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 11, + "negatives": 2778, + "auroc": 0.898455396295569, + "auprc": 0.08389830710331753, + "brier": 0.003866873717648669, + "calibration": { + "observed_rate": 0.003944065973467192, + "mean_prediction": 0.005313221801026037, + "calibration_in_the_large": 0.0013691558275588447, + "expected_calibration_error_10bin": 0.0015346678762312605, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 11, + "negatives": 2778, + "auroc": 0.8986844688788533, + "auprc": 0.08474700687454581, + "brier": 0.0038701159033678796, + "calibration": { + "observed_rate": 0.003944065973467192, + "mean_prediction": 0.0054364605404041465, + "calibration_in_the_large": 0.0014923945669369542, + "expected_calibration_error_10bin": 0.0016334516035002439, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 12, + "negatives": 2777, + "auroc": 0.8961409194574481, + "auprc": 0.0803243084885537, + "brier": 0.004241529997362859, + "calibration": { + "observed_rate": 0.004302617425600574, + "mean_prediction": 0.005808192331768405, + "calibration_in_the_large": 0.0015055749061678309, + "expected_calibration_error_10bin": 0.0015055749061678313, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 12, + "negatives": 2777, + "auroc": 0.89368023046453, + "auprc": 0.07879262217959712, + "brier": 0.004270692162075132, + "calibration": { + "observed_rate": 0.004302617425600574, + "mean_prediction": 0.006250544642754728, + "calibration_in_the_large": 0.0019479272171541544, + "expected_calibration_error_10bin": 0.00217182628430762, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 13, + "negatives": 2776, + "auroc": 0.8847816448681002, + "auprc": 0.07356283879895609, + "brier": 0.004652241490491037, + "calibration": { + "observed_rate": 0.004661168877733955, + "mean_prediction": 0.0066691991123909704, + "calibration_in_the_large": 0.0020080302346570152, + "expected_calibration_error_10bin": 0.002783265747726603, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 13, + "negatives": 2776, + "auroc": 0.884864774994458, + "auprc": 0.07379837455530905, + "brier": 0.004652712218383152, + "calibration": { + "observed_rate": 0.004661168877733955, + "mean_prediction": 0.0066809587305091, + "calibration_in_the_large": 0.002019789852775145, + "expected_calibration_error_10bin": 0.0027943264271193635, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + } + ], + "reason": null + }, + "L98": { + "time_averaged_auroc": 0.6358358374500247, + "time_averaged_auprc": 0.004985217424587628, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2824, + "positives": 0, + "negatives": 2824, + "auroc": null, + "auprc": null, + "brier": 2.7849010587766407e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0010032802250347999, + "calibration_in_the_large": 0.0010032802250347999, + "expected_calibration_error_10bin": 0.0010032802250347999, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 1, + "negatives": 2823, + "auroc": 0.4406659582004959, + "auprc": 0.0006329113924050633, + "brier": 0.00036496365712950933, + "calibration": { + "observed_rate": 0.0003541076487252125, + "mean_prediction": 0.001665950700121344, + "calibration_in_the_large": 0.0013118430513961315, + "expected_calibration_error_10bin": 0.0013118430513961315, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 1, + "negatives": 2823, + "auroc": 0.4665249734325186, + "auprc": 0.0006635700066357001, + "brier": 0.0003700714461531762, + "calibration": { + "observed_rate": 0.0003541076487252125, + "mean_prediction": 0.0021146538114286935, + "calibration_in_the_large": 0.001760546162703481, + "expected_calibration_error_10bin": 0.001760546162703481, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.7762022923313245, + "auprc": 0.007346247675588994, + "brier": 0.0010732056895471217, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0026257384039647365, + "calibration_in_the_large": 0.001563415457789099, + "expected_calibration_error_10bin": 0.001563415457789099, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 5, + "negatives": 2819, + "auroc": 0.6526427811280596, + "auprc": 0.005562335060209188, + "brier": 0.0017818825072115454, + "calibration": { + "observed_rate": 0.0017705382436260624, + "mean_prediction": 0.0028596383874518873, + "calibration_in_the_large": 0.001089100143825825, + "expected_calibration_error_10bin": 0.001089100143825825, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 5, + "negatives": 2819, + "auroc": 0.6522880454061724, + "auprc": 0.005515344072185053, + "brier": 0.0017834593784061925, + "calibration": { + "observed_rate": 0.0017705382436260624, + "mean_prediction": 0.0029950949840717414, + "calibration_in_the_large": 0.001224556740445679, + "expected_calibration_error_10bin": 0.001224556740445679, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 5, + "negatives": 2819, + "auroc": 0.6542036183043632, + "auprc": 0.005474825659549564, + "brier": 0.0017896215296713523, + "calibration": { + "observed_rate": 0.0017705382436260624, + "mean_prediction": 0.003284492983060587, + "calibration_in_the_large": 0.0015139547394345245, + "expected_calibration_error_10bin": 0.0015139547394345245, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 5, + "negatives": 2819, + "auroc": 0.656261085491309, + "auprc": 0.0053503436141321345, + "brier": 0.0017971498864341677, + "calibration": { + "observed_rate": 0.0017705382436260624, + "mean_prediction": 0.0035722025503501023, + "calibration_in_the_large": 0.00180166430672404, + "expected_calibration_error_10bin": 0.00180166430672404, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 5, + "negatives": 2819, + "auroc": 0.6578219226676126, + "auprc": 0.005312670561328826, + "brier": 0.0018053069621843316, + "calibration": { + "observed_rate": 0.0017705382436260624, + "mean_prediction": 0.003881590659318107, + "calibration_in_the_large": 0.0021110524156920446, + "expected_calibration_error_10bin": 0.0021110524156920446, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 7, + "negatives": 2817, + "auroc": 0.6510472133475328, + "auprc": 0.005502973680144882, + "brier": 0.0025146901071740283, + "calibration": { + "observed_rate": 0.002478753541076487, + "mean_prediction": 0.004201213287181111, + "calibration_in_the_large": 0.0017224597461046238, + "expected_calibration_error_10bin": 0.0017224597461046234, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 8, + "negatives": 2816, + "auroc": 0.6753817471590909, + "auprc": 0.006203837145639945, + "brier": 0.002873213009720409, + "calibration": { + "observed_rate": 0.0028328611898017, + "mean_prediction": 0.004431927516814813, + "calibration_in_the_large": 0.0015990663270131129, + "expected_calibration_error_10bin": 0.0015990663270131129, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 8, + "negatives": 2816, + "auroc": 0.6736061789772727, + "auprc": 0.006139681065952641, + "brier": 0.0028871559590310275, + "calibration": { + "observed_rate": 0.0028328611898017, + "mean_prediction": 0.0049644378391362045, + "calibration_in_the_large": 0.0021315766493345046, + "expected_calibration_error_10bin": 0.002131576649334505, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + { + "valid": 2824, + "positives": 8, + "negatives": 2816, + "auroc": 0.6733842329545454, + "auprc": 0.00611786916127955, + "brier": 0.002888597419506845, + "calibration": { + "observed_rate": 0.0028328611898017, + "mean_prediction": 0.005015608557395773, + "calibration_in_the_large": 0.0021827473675940733, + "expected_calibration_error_10bin": 0.0021827473675940737, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + } + ], + "reason": null + }, + "M10": { + "time_averaged_auroc": 0.8155232244094044, + "time_averaged_auprc": 0.0402725661722952, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2713, + "positives": 4, + "negatives": 2709, + "auroc": 0.8302879291251384, + "auprc": 0.011951690659240058, + "brier": 0.0014680623746248646, + "calibration": { + "observed_rate": 0.001474382602285293, + "mean_prediction": 0.0014168722878624307, + "calibration_in_the_large": -5.7510314422862295e-05, + "expected_calibration_error_10bin": 5.7510314422862295e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + { + "valid": 2713, + "positives": 8, + "negatives": 2705, + "auroc": 0.8886321626617375, + "auprc": 0.03457375864948539, + "brier": 0.0029088366278169765, + "calibration": { + "observed_rate": 0.002948765204570586, + "mean_prediction": 0.0021454547319356594, + "calibration_in_the_large": -0.0008033104726349266, + "expected_calibration_error_10bin": 0.0008033104726349266, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + { + "valid": 2713, + "positives": 10, + "negatives": 2703, + "auroc": 0.8231964483906771, + "auprc": 0.035591921801978135, + "brier": 0.0036326010763871068, + "calibration": { + "observed_rate": 0.003685956505713233, + "mean_prediction": 0.0027942006802504442, + "calibration_in_the_large": -0.0008917558254627886, + "expected_calibration_error_10bin": 0.0009712389982534927, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + { + "valid": 2713, + "positives": 10, + "negatives": 2703, + "auroc": 0.8219755826859045, + "auprc": 0.03531997615171606, + "brier": 0.0036327693460406164, + "calibration": { + "observed_rate": 0.003685956505713233, + "mean_prediction": 0.003077670196285979, + "calibration_in_the_large": -0.0006082863094272538, + "expected_calibration_error_10bin": 0.0006975916982360751, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + { + "valid": 2713, + "positives": 10, + "negatives": 2703, + "auroc": 0.8211986681465039, + "auprc": 0.035987116436239884, + "brier": 0.003633012338248071, + "calibration": { + "observed_rate": 0.003685956505713233, + "mean_prediction": 0.003625024233347694, + "calibration_in_the_large": -6.093227236553863e-05, + "expected_calibration_error_10bin": 0.0002569557955798738, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + { + "valid": 2713, + "positives": 10, + "negatives": 2703, + "auroc": 0.8178320384757677, + "auprc": 0.03543405777292928, + "brier": 0.003638952993403377, + "calibration": { + "observed_rate": 0.003685956505713233, + "mean_prediction": 0.004440144326225805, + "calibration_in_the_large": 0.0007541878205125723, + "expected_calibration_error_10bin": 0.0007541878205125725, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + { + "valid": 2713, + "positives": 12, + "negatives": 2701, + "auroc": 0.783290139454523, + "auprc": 0.03949239500097829, + "brier": 0.004359130511528372, + "calibration": { + "observed_rate": 0.0044231478068558795, + "mean_prediction": 0.004867113577177182, + "calibration_in_the_large": 0.00044396577032130256, + "expected_calibration_error_10bin": 0.00044396577032130267, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + { + "valid": 2713, + "positives": 13, + "negatives": 2700, + "auroc": 0.7972649572649573, + "auprc": 0.04657634635601216, + "brier": 0.0047072468839173065, + "calibration": { + "observed_rate": 0.004791743457427202, + "mean_prediction": 0.005166126892833751, + "calibration_in_the_large": 0.0003743834354065492, + "expected_calibration_error_10bin": 0.00037438343540654865, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + { + "valid": 2713, + "positives": 13, + "negatives": 2700, + "auroc": 0.7978917378917378, + "auprc": 0.047121203221126444, + "brier": 0.004714158749578849, + "calibration": { + "observed_rate": 0.004791743457427202, + "mean_prediction": 0.005645411019867342, + "calibration_in_the_large": 0.0008536675624401394, + "expected_calibration_error_10bin": 0.000853667562440139, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + { + "valid": 2713, + "positives": 13, + "negatives": 2700, + "auroc": 0.7982905982905983, + "auprc": 0.04686536046259478, + "brier": 0.004723080623928351, + "calibration": { + "observed_rate": 0.004791743457427202, + "mean_prediction": 0.005894672238410248, + "calibration_in_the_large": 0.001102928780983046, + "expected_calibration_error_10bin": 0.0011029287809830451, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + { + "valid": 2713, + "positives": 14, + "negatives": 2699, + "auroc": 0.8038691578891654, + "auprc": 0.046743936371545766, + "brier": 0.005093925918159296, + "calibration": { + "observed_rate": 0.005160339107998526, + "mean_prediction": 0.00639135795326164, + "calibration_in_the_large": 0.0012310188452631142, + "expected_calibration_error_10bin": 0.0012310188452631147, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + { + "valid": 2713, + "positives": 14, + "negatives": 2699, + "auroc": 0.8023077330228127, + "auprc": 0.046256733993038965, + "brier": 0.005107744698515716, + "calibration": { + "observed_rate": 0.005160339107998526, + "mean_prediction": 0.006886930551323041, + "calibration_in_the_large": 0.0017265914433245155, + "expected_calibration_error_10bin": 0.0017265914433245162, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + { + "valid": 2713, + "positives": 15, + "negatives": 2698, + "auroc": 0.8157647640227329, + "auprc": 0.06162886336295241, + "brier": 0.005398205509601921, + "calibration": { + "observed_rate": 0.0055289347585698485, + "mean_prediction": 0.007002988470701916, + "calibration_in_the_large": 0.0014740537121320672, + "expected_calibration_error_10bin": 0.001474053712132067, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + } + ], + "reason": null + }, + "M16": { + "time_averaged_auroc": 0.866353279645909, + "time_averaged_auprc": 0.01173841721339741, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2790, + "positives": 1, + "negatives": 2789, + "auroc": 0.6392972391538185, + "auprc": 0.0009930486593843098, + "brier": 0.00035850699438351956, + "calibration": { + "observed_rate": 0.00035842293906810036, + "mean_prediction": 0.0003264371771686498, + "calibration_in_the_large": -3.198576189945054e-05, + "expected_calibration_error_10bin": 3.198576189945054e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 1, + "negatives": 2789, + "auroc": 0.7314449623520975, + "auprc": 0.0013333333333333333, + "brier": 0.0003588866641305319, + "calibration": { + "observed_rate": 0.00035842293906810036, + "mean_prediction": 0.0005702617557179234, + "calibration_in_the_large": 0.00021183881664982307, + "expected_calibration_error_10bin": 0.00021183881664982307, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 2, + "negatives": 2788, + "auroc": 0.8764347202295553, + "auprc": 0.01218868546923965, + "brier": 0.000715145259034743, + "calibration": { + "observed_rate": 0.0007168458781362007, + "mean_prediction": 0.0006224664889839093, + "calibration_in_the_large": -9.437938915229146e-05, + "expected_calibration_error_10bin": 9.437938915229146e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 2, + "negatives": 2788, + "auroc": 0.8678263988522238, + "auprc": 0.014247046344050624, + "brier": 0.0007149100803688147, + "calibration": { + "observed_rate": 0.0007168458781362007, + "mean_prediction": 0.0007821352940348376, + "calibration_in_the_large": 6.528941589863688e-05, + "expected_calibration_error_10bin": 6.528941589863688e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 2, + "negatives": 2788, + "auroc": 0.8671090387374462, + "auprc": 0.01611433305716653, + "brier": 0.0007145951624621604, + "calibration": { + "observed_rate": 0.0007168458781362007, + "mean_prediction": 0.0009180322386244917, + "calibration_in_the_large": 0.00020118636048829103, + "expected_calibration_error_10bin": 0.00020118636048829103, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 2, + "negatives": 2788, + "auroc": 0.898493543758967, + "auprc": 0.011926782273603083, + "brier": 0.0007155106616908202, + "calibration": { + "observed_rate": 0.0007168458781362007, + "mean_prediction": 0.0011336355643635544, + "calibration_in_the_large": 0.0004167896862273537, + "expected_calibration_error_10bin": 0.0004167896862273537, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 2, + "negatives": 2788, + "auroc": 0.9029770444763271, + "auprc": 0.01243279569892473, + "brier": 0.0007155508127535429, + "calibration": { + "observed_rate": 0.0007168458781362007, + "mean_prediction": 0.0012304203219427627, + "calibration_in_the_large": 0.000513574443806562, + "expected_calibration_error_10bin": 0.000513574443806562, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 3, + "negatives": 2787, + "auroc": 0.910895825858151, + "auprc": 0.014094009075338565, + "brier": 0.0010710220936101585, + "calibration": { + "observed_rate": 0.001075268817204301, + "mean_prediction": 0.0013670697095769493, + "calibration_in_the_large": 0.00029180089237264826, + "expected_calibration_error_10bin": 0.00029180089237264826, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 3, + "negatives": 2787, + "auroc": 0.9124506637961967, + "auprc": 0.014547339524880814, + "brier": 0.0010709726895556286, + "calibration": { + "observed_rate": 0.001075268817204301, + "mean_prediction": 0.001394982049719163, + "calibration_in_the_large": 0.00031971323251486186, + "expected_calibration_error_10bin": 0.00031971323251486186, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 3, + "negatives": 2787, + "auroc": 0.9111350316947734, + "auprc": 0.013744168624646712, + "brier": 0.0010714465461691826, + "calibration": { + "observed_rate": 0.001075268817204301, + "mean_prediction": 0.0015349796564672075, + "calibration_in_the_large": 0.00045971083926290646, + "expected_calibration_error_10bin": 0.00045971083926290646, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 3, + "negatives": 2787, + "auroc": 0.9150819279990432, + "auprc": 0.01332073661888005, + "brier": 0.001071991490252198, + "calibration": { + "observed_rate": 0.001075268817204301, + "mean_prediction": 0.0016431137086028913, + "calibration_in_the_large": 0.0005678448913985902, + "expected_calibration_error_10bin": 0.0005678448913985902, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 3, + "negatives": 2787, + "auroc": 0.9149623250807319, + "auprc": 0.013827436635251267, + "brier": 0.001072199517836448, + "calibration": { + "observed_rate": 0.001075268817204301, + "mean_prediction": 0.0017175904227743856, + "calibration_in_the_large": 0.0006423216055700845, + "expected_calibration_error_10bin": 0.0006423216055700845, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + { + "valid": 2790, + "positives": 3, + "negatives": 2787, + "auroc": 0.9144839134074871, + "auprc": 0.013829708459466662, + "brier": 0.0010722724935383061, + "calibration": { + "observed_rate": 0.001075268817204301, + "mean_prediction": 0.0017545234615134041, + "calibration_in_the_large": 0.000679254644309103, + "expected_calibration_error_10bin": 0.000679254644309103, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + } + ], + "reason": null + }, + "M17": { + "time_averaged_auroc": 0.7651503902170792, + "time_averaged_auprc": 0.00897220064564327, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2733, + "positives": 2, + "negatives": 2731, + "auroc": 0.8581105822043208, + "auprc": 0.010992795083704175, + "brier": 0.0007304419812442107, + "calibration": { + "observed_rate": 0.0007317965605561653, + "mean_prediction": 0.0003148437601008086, + "calibration_in_the_large": -0.00041695280045535673, + "expected_calibration_error_10bin": 0.00041695280045535673, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 4, + "negatives": 2729, + "auroc": 0.7945218028581899, + "auprc": 0.006737891566058897, + "brier": 0.0014612578691539442, + "calibration": { + "observed_rate": 0.0014635931211123307, + "mean_prediction": 0.0006960790932788027, + "calibration_in_the_large": -0.000767514027833528, + "expected_calibration_error_10bin": 0.000767514027833528, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 5, + "negatives": 2728, + "auroc": 0.7450146627565982, + "auprc": 0.005817537734382849, + "brier": 0.001828937746824027, + "calibration": { + "observed_rate": 0.0018294914013904135, + "mean_prediction": 0.0012184872641908347, + "calibration_in_the_large": -0.0006110041371995788, + "expected_calibration_error_10bin": 0.0006110041371995788, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 6, + "negatives": 2727, + "auroc": 0.7690991321354358, + "auprc": 0.006412047667337544, + "brier": 0.002198134129027915, + "calibration": { + "observed_rate": 0.0021953896816684962, + "mean_prediction": 0.0014898241489130215, + "calibration_in_the_large": -0.0007055655327554747, + "expected_calibration_error_10bin": 0.0007055655327554747, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 7, + "negatives": 2726, + "auroc": 0.7216748768472906, + "auprc": 0.00624573195328213, + "brier": 0.0025669475641782965, + "calibration": { + "observed_rate": 0.002561287961946579, + "mean_prediction": 0.0018168494984342884, + "calibration_in_the_large": -0.0007444384635122907, + "expected_calibration_error_10bin": 0.0007444384635122907, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 8, + "negatives": 2725, + "auroc": 0.7242201834862385, + "auprc": 0.0065757110064452355, + "brier": 0.002938837801201857, + "calibration": { + "observed_rate": 0.0029271862422246614, + "mean_prediction": 0.0021224920141074567, + "calibration_in_the_large": -0.0008046942281172047, + "expected_calibration_error_10bin": 0.0008046942281172047, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 9, + "negatives": 2724, + "auroc": 0.7538750203948442, + "auprc": 0.008680624810548343, + "brier": 0.0033023370644669568, + "calibration": { + "observed_rate": 0.003293084522502744, + "mean_prediction": 0.00238455730021605, + "calibration_in_the_large": -0.0009085272222866939, + "expected_calibration_error_10bin": 0.0009085272222866939, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 9, + "negatives": 2724, + "auroc": 0.7541605482134116, + "auprc": 0.008666152604229064, + "brier": 0.0033066833981609234, + "calibration": { + "observed_rate": 0.003293084522502744, + "mean_prediction": 0.0026029459006039145, + "calibration_in_the_large": -0.0006901386218988296, + "expected_calibration_error_10bin": 0.0006901386218988296, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 10, + "negatives": 2723, + "auroc": 0.7487330150569225, + "auprc": 0.008813759732153972, + "brier": 0.0036753719288170885, + "calibration": { + "observed_rate": 0.003658982802780827, + "mean_prediction": 0.0028333396259652907, + "calibration_in_the_large": -0.0008256431768155362, + "expected_calibration_error_10bin": 0.0008256431768155362, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 13, + "negatives": 2720, + "auroc": 0.7682975113122172, + "auprc": 0.011877386724582568, + "brier": 0.0047648913594878235, + "calibration": { + "observed_rate": 0.004756677643615075, + "mean_prediction": 0.0030378770537493097, + "calibration_in_the_large": -0.0017188005898657655, + "expected_calibration_error_10bin": 0.001794990385166877, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 13, + "negatives": 2720, + "auroc": 0.7688914027149322, + "auprc": 0.011866475127953595, + "brier": 0.004769806075196383, + "calibration": { + "observed_rate": 0.004756677643615075, + "mean_prediction": 0.0032583627562809635, + "calibration_in_the_large": -0.0014983148873341117, + "expected_calibration_error_10bin": 0.0016578744386156964, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 13, + "negatives": 2720, + "auroc": 0.770079185520362, + "auprc": 0.011972633899014236, + "brier": 0.004775750452760731, + "calibration": { + "observed_rate": 0.004756677643615075, + "mean_prediction": 0.003571998744031219, + "calibration_in_the_large": -0.0011846788995838564, + "expected_calibration_error_10bin": 0.0013582636167928383, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + { + "valid": 2733, + "positives": 13, + "negatives": 2720, + "auroc": 0.770277149321267, + "auprc": 0.011979860483669906, + "brier": 0.0047774792280857875, + "calibration": { + "observed_rate": 0.004756677643615075, + "mean_prediction": 0.003630588538028265, + "calibration_in_the_large": -0.0011260891055868104, + "expected_calibration_error_10bin": 0.0013771600245730783, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + } + ], + "reason": null + }, + "M19": { + "time_averaged_auroc": 0.7059750012613423, + "time_averaged_auprc": 0.026640454921054442, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2674, + "positives": 8, + "negatives": 2666, + "auroc": 0.7036290322580645, + "auprc": 0.008003556823007098, + "brier": 0.0029819411952275716, + "calibration": { + "observed_rate": 0.0029917726252804786, + "mean_prediction": 0.0030944803457335543, + "calibration_in_the_large": 0.00010270772045307573, + "expected_calibration_error_10bin": 0.00010270772045307573, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + { + "valid": 2674, + "positives": 15, + "negatives": 2659, + "auroc": 0.6812586185282687, + "auprc": 0.017101849380956373, + "brier": 0.005564402411892922, + "calibration": { + "observed_rate": 0.005609573672400898, + "mean_prediction": 0.005137622098659779, + "calibration_in_the_large": -0.0004719515737411188, + "expected_calibration_error_10bin": 0.0004719515737411188, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + { + "valid": 2674, + "positives": 17, + "negatives": 2657, + "auroc": 0.6881268126369855, + "auprc": 0.019446300769939025, + "brier": 0.0062984282937861395, + "calibration": { + "observed_rate": 0.006357516828721017, + "mean_prediction": 0.0057485692725085325, + "calibration_in_the_large": -0.0006089475562124844, + "expected_calibration_error_10bin": 0.0006089475562124844, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + { + "valid": 2674, + "positives": 24, + "negatives": 2650, + "auroc": 0.6832389937106919, + "auprc": 0.021145983159249714, + "brier": 0.00887442745754252, + "calibration": { + "observed_rate": 0.008975317875841436, + "mean_prediction": 0.007412165385091844, + "calibration_in_the_large": -0.001563152490749592, + "expected_calibration_error_10bin": 0.001641487036963592, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + { + "valid": 2674, + "positives": 25, + "negatives": 2649, + "auroc": 0.7004907512268781, + "auprc": 0.023875460323747533, + "brier": 0.009230523952694726, + "calibration": { + "observed_rate": 0.009349289454001496, + "mean_prediction": 0.008409271026871733, + "calibration_in_the_large": -0.0009400184271297629, + "expected_calibration_error_10bin": 0.0010258797315298848, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + { + "valid": 2674, + "positives": 27, + "negatives": 2647, + "auroc": 0.7127985560172942, + "auprc": 0.0272938499400914, + "brier": 0.009954375356617808, + "calibration": { + "observed_rate": 0.010097232610321616, + "mean_prediction": 0.009365133164218827, + "calibration_in_the_large": -0.0007320994461027883, + "expected_calibration_error_10bin": 0.0010728431901729587, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + { + "valid": 2674, + "positives": 30, + "negatives": 2644, + "auroc": 0.7257690368129097, + "auprc": 0.03264504983860337, + "brier": 0.011024405794396546, + "calibration": { + "observed_rate": 0.011219147344801795, + "mean_prediction": 0.010352444389045954, + "calibration_in_the_large": -0.0008667029557558412, + "expected_calibration_error_10bin": 0.001349762095487241, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + { + "valid": 2674, + "positives": 32, + "negatives": 2642, + "auroc": 0.717129542013626, + "auprc": 0.032535100375989764, + "brier": 0.011766220304863382, + "calibration": { + "observed_rate": 0.011967090501121914, + "mean_prediction": 0.010930550653107288, + "calibration_in_the_large": -0.0010365398480146268, + "expected_calibration_error_10bin": 0.0016407949854795683, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + { + "valid": 2674, + "positives": 33, + "negatives": 2641, + "auroc": 0.7091207416841646, + "auprc": 0.031045690278339096, + "brier": 0.012164165084554755, + "calibration": { + "observed_rate": 0.012341062079281975, + "mean_prediction": 0.01208858649319448, + "calibration_in_the_large": -0.0002524755860874948, + "expected_calibration_error_10bin": 0.0013679730747580858, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + { + "valid": 2674, + "positives": 34, + "negatives": 2640, + "auroc": 0.7158979500891266, + "auprc": 0.032898759006086686, + "brier": 0.012521428249151548, + "calibration": { + "observed_rate": 0.012715033657442034, + "mean_prediction": 0.012539236069039655, + "calibration_in_the_large": -0.000175797588402379, + "expected_calibration_error_10bin": 0.001588871048782289, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + { + "valid": 2674, + "positives": 35, + "negatives": 2639, + "auroc": 0.7134195853407677, + "auprc": 0.03299508268016678, + "brier": 0.012894025175825972, + "calibration": { + "observed_rate": 0.013089005235602094, + "mean_prediction": 0.012930989028279417, + "calibration_in_the_large": -0.0001580162073226768, + "expected_calibration_error_10bin": 0.0009494500019263322, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + { + "valid": 2674, + "positives": 37, + "negatives": 2637, + "auroc": 0.7133003310477714, + "auprc": 0.03362162135260575, + "brier": 0.013636424212673994, + "calibration": { + "observed_rate": 0.013836948391922213, + "mean_prediction": 0.013570714688483032, + "calibration_in_the_large": -0.0002662337034391813, + "expected_calibration_error_10bin": 0.001325350965804399, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + { + "valid": 2674, + "positives": 37, + "negatives": 2637, + "auroc": 0.7134950650309012, + "auprc": 0.033717610044925204, + "brier": 0.013639046594287933, + "calibration": { + "observed_rate": 0.013836948391922213, + "mean_prediction": 0.013641345500602111, + "calibration_in_the_large": -0.00019560289132010238, + "expected_calibration_error_10bin": 0.0012725060938680922, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + } + ], + "reason": null + }, + "M21": { + "time_averaged_auroc": 0.9382270860133334, + "time_averaged_auprc": 0.01168959643874545, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.9397163120567376, + "auprc": 0.005847953216374269, + "brier": 0.00035418918254939317, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.00019327119408608663, + "calibration_in_the_large": -0.00016121303136588076, + "expected_calibration_error_10bin": 0.00016121303136588076, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.9652482269503546, + "auprc": 0.010101010101010102, + "brier": 0.00035378074480719757, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.00044974201194293296, + "calibration_in_the_large": 9.525778649096557e-05, + "expected_calibration_error_10bin": 9.525778649096557e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.9776595744680852, + "auprc": 0.015625, + "brier": 0.00035386236866848835, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0008025829289559774, + "calibration_in_the_large": 0.00044809870350401, + "expected_calibration_error_10bin": 0.00044809870350401, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.9773049645390071, + "auprc": 0.015384615384615385, + "brier": 0.0003543335680309581, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0009833402060798583, + "calibration_in_the_large": 0.000628855980627891, + "expected_calibration_error_10bin": 0.000628855980627891, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.9765957446808511, + "auprc": 0.014925373134328358, + "brier": 0.00035487475765968264, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0011304617084749039, + "calibration_in_the_large": 0.0007759774830229365, + "expected_calibration_error_10bin": 0.0007759774830229365, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.9783687943262411, + "auprc": 0.016129032258064516, + "brier": 0.00035545399952369654, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0012539239609126852, + "calibration_in_the_large": 0.0008994397354607179, + "expected_calibration_error_10bin": 0.0008994397354607179, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.9765957446808511, + "auprc": 0.014925373134328358, + "brier": 0.0003564651285277428, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0014179199004096571, + "calibration_in_the_large": 0.0010634356749576897, + "expected_calibration_error_10bin": 0.0010634356749576897, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.9769503546099291, + "auprc": 0.015151515151515152, + "brier": 0.0003577341625936809, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0015760025592095035, + "calibration_in_the_large": 0.0012215183337575361, + "expected_calibration_error_10bin": 0.0012215183337575361, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 2, + "negatives": 2819, + "auroc": 0.8914508691025186, + "auprc": 0.00939725120052989, + "brier": 0.0007112651977891253, + "calibration": { + "observed_rate": 0.0007089684509039348, + "mean_prediction": 0.001675253050540032, + "calibration_in_the_large": 0.0009662845996360973, + "expected_calibration_error_10bin": 0.0009662845996360973, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 2, + "negatives": 2819, + "auroc": 0.893934019155729, + "auprc": 0.009335345743194142, + "brier": 0.0007121544723924403, + "calibration": { + "observed_rate": 0.0007089684509039348, + "mean_prediction": 0.0017526902321163857, + "calibration_in_the_large": 0.001043721781212451, + "expected_calibration_error_10bin": 0.001043721781212451, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 3, + "negatives": 2818, + "auroc": 0.8812396498698841, + "auprc": 0.008273351404447453, + "brier": 0.0010654697760273297, + "calibration": { + "observed_rate": 0.0010634526763559022, + "mean_prediction": 0.0018759289569831906, + "calibration_in_the_large": 0.0008124762806272885, + "expected_calibration_error_10bin": 0.0008124762806272885, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 3, + "negatives": 2818, + "auroc": 0.8807665010645848, + "auprc": 0.008394150027278125, + "brier": 0.0010662630240107838, + "calibration": { + "observed_rate": 0.0010634526763559022, + "mean_prediction": 0.0020094334242280023, + "calibration_in_the_large": 0.0009459807478721001, + "expected_calibration_error_10bin": 0.0009459807478721001, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + { + "valid": 2821, + "positives": 3, + "negatives": 2818, + "auroc": 0.8811213626685592, + "auprc": 0.008474782948005072, + "brier": 0.0010663277112942836, + "calibration": { + "observed_rate": 0.0010634526763559022, + "mean_prediction": 0.0020162274558364122, + "calibration_in_the_large": 0.0009527747794805101, + "expected_calibration_error_10bin": 0.0009527747794805101, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + } + ], + "reason": null + }, + "M25": { + "time_averaged_auroc": 0.6368676779696388, + "time_averaged_auprc": 0.01762420933787713, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2717, + "positives": 5, + "negatives": 2712, + "auroc": 0.810693215339233, + "auprc": 0.018258925876946146, + "brier": 0.0018310229076472808, + "calibration": { + "observed_rate": 0.001840264998159735, + "mean_prediction": 0.002911884238087203, + "calibration_in_the_large": 0.001071619239927468, + "expected_calibration_error_10bin": 0.001071619239927468, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + { + "valid": 2717, + "positives": 8, + "negatives": 2709, + "auroc": 0.6410575858250277, + "auprc": 0.010266083596834143, + "brier": 0.0029423673467278027, + "calibration": { + "observed_rate": 0.002944423997055576, + "mean_prediction": 0.004497711141980877, + "calibration_in_the_large": 0.0015532871449253013, + "expected_calibration_error_10bin": 0.0015532871449253013, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + { + "valid": 2717, + "positives": 13, + "negatives": 2704, + "auroc": 0.6568616294947656, + "auprc": 0.012043111518805893, + "brier": 0.004769937993080124, + "calibration": { + "observed_rate": 0.004784688995215311, + "mean_prediction": 0.0059272899006684145, + "calibration_in_the_large": 0.0011426009054531037, + "expected_calibration_error_10bin": 0.0011426009054531037, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + { + "valid": 2717, + "positives": 20, + "negatives": 2697, + "auroc": 0.6471820541342233, + "auprc": 0.01514770112447027, + "brier": 0.00731969318489811, + "calibration": { + "observed_rate": 0.00736105999263894, + "mean_prediction": 0.0073053282935161695, + "calibration_in_the_large": -5.5731699122770796e-05, + "expected_calibration_error_10bin": 0.0002905859445982005, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + { + "valid": 2717, + "positives": 22, + "negatives": 2695, + "auroc": 0.6377635351661326, + "auprc": 0.015678463044623177, + "brier": 0.008053941202466204, + "calibration": { + "observed_rate": 0.008097165991902834, + "mean_prediction": 0.00852460970265402, + "calibration_in_the_large": 0.00042744371075118665, + "expected_calibration_error_10bin": 0.00042744371075118827, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + { + "valid": 2717, + "positives": 26, + "negatives": 2691, + "auroc": 0.6281193722665295, + "auprc": 0.016172050114161684, + "brier": 0.00952637409403698, + "calibration": { + "observed_rate": 0.009569377990430622, + "mean_prediction": 0.009463902603325674, + "calibration_in_the_large": -0.00010547538710494776, + "expected_calibration_error_10bin": 0.0005060018505858256, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + { + "valid": 2717, + "positives": 28, + "negatives": 2689, + "auroc": 0.6185650533921266, + "auprc": 0.01650379762057335, + "brier": 0.010264077076901853, + "calibration": { + "observed_rate": 0.010305483989694516, + "mean_prediction": 0.010671942695226509, + "calibration_in_the_large": 0.00036645870553199227, + "expected_calibration_error_10bin": 0.00036645870553199465, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + { + "valid": 2717, + "positives": 31, + "negatives": 2686, + "auroc": 0.6093363437657627, + "auprc": 0.017380799333803643, + "brier": 0.011373137950058287, + "calibration": { + "observed_rate": 0.011409642988590356, + "mean_prediction": 0.011548137811207435, + "calibration_in_the_large": 0.00013849482261707804, + "expected_calibration_error_10bin": 0.0009243495194925237, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + { + "valid": 2717, + "positives": 34, + "negatives": 2683, + "auroc": 0.602069676174607, + "auprc": 0.017844555940459993, + "brier": 0.012466358583605256, + "calibration": { + "observed_rate": 0.012513801987486198, + "mean_prediction": 0.012591529075508093, + "calibration_in_the_large": 7.772708802189499e-05, + "expected_calibration_error_10bin": 0.0010929639777014382, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + { + "valid": 2717, + "positives": 37, + "negatives": 2680, + "auroc": 0.6030556676079064, + "auprc": 0.018984276019259862, + "brier": 0.013572183063290161, + "calibration": { + "observed_rate": 0.013617960986382039, + "mean_prediction": 0.013984247722682181, + "calibration_in_the_large": 0.0003662867363001428, + "expected_calibration_error_10bin": 0.0011467853485890081, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + { + "valid": 2717, + "positives": 41, + "negatives": 2676, + "auroc": 0.61794997994823, + "auprc": 0.021920421155241024, + "brier": 0.014998530314670699, + "calibration": { + "observed_rate": 0.015090172984909826, + "mean_prediction": 0.014610457816418298, + "calibration_in_the_large": -0.00047971516849152837, + "expected_calibration_error_10bin": 0.002278840901523098, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + { + "valid": 2717, + "positives": 48, + "negatives": 2669, + "auroc": 0.6006072811290121, + "auprc": 0.024027935325881544, + "brier": 0.017534513511714627, + "calibration": { + "observed_rate": 0.017666543982333457, + "mean_prediction": 0.015474528824772725, + "calibration_in_the_large": -0.002192015157560732, + "expected_calibration_error_10bin": 0.0043464191527032865, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + { + "valid": 2717, + "positives": 49, + "negatives": 2668, + "auroc": 0.6060184193617477, + "auprc": 0.024886600721341957, + "brier": 0.01788949184892047, + "calibration": { + "observed_rate": 0.0180345969819654, + "mean_prediction": 0.015661497574925482, + "calibration_in_the_large": -0.002373099407039919, + "expected_calibration_error_10bin": 0.00455075974921008, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + } + ], + "reason": null + }, + "M35": { + "time_averaged_auroc": 0.8796465080051553, + "time_averaged_auprc": 0.0036268638552760437, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2806, + "positives": 1, + "negatives": 2805, + "auroc": 0.857397504456328, + "auprc": 0.0024937655860349127, + "brier": 0.0003564702728863711, + "calibration": { + "observed_rate": 0.0003563791874554526, + "mean_prediction": 0.00014208846230211232, + "calibration_in_the_large": -0.0002142907251533403, + "expected_calibration_error_10bin": 0.0002142907251533403, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 1, + "negatives": 2805, + "auroc": 0.879144385026738, + "auprc": 0.0029411764705882353, + "brier": 0.00035674893565410654, + "calibration": { + "observed_rate": 0.0003563791874554526, + "mean_prediction": 0.00030090468209335175, + "calibration_in_the_large": -5.547450536210087e-05, + "expected_calibration_error_10bin": 5.547450536210087e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 1, + "negatives": 2805, + "auroc": 0.8677361853832442, + "auprc": 0.002688172043010753, + "brier": 0.0003570569524970084, + "calibration": { + "observed_rate": 0.0003563791874554526, + "mean_prediction": 0.0003696892236077697, + "calibration_in_the_large": 1.3310036152317081e-05, + "expected_calibration_error_10bin": 1.3310036152317081e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 1, + "negatives": 2805, + "auroc": 0.8816399286987522, + "auprc": 0.003003003003003003, + "brier": 0.0003578246661313354, + "calibration": { + "observed_rate": 0.0003563791874554526, + "mean_prediction": 0.0005018268007471674, + "calibration_in_the_large": 0.00014544761329171477, + "expected_calibration_error_10bin": 0.00014544761329171477, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 1, + "negatives": 2805, + "auroc": 0.877361853832442, + "auprc": 0.002898550724637681, + "brier": 0.00035886978628487987, + "calibration": { + "observed_rate": 0.0003563791874554526, + "mean_prediction": 0.0006839848434715943, + "calibration_in_the_large": 0.0003276056560161417, + "expected_calibration_error_10bin": 0.0003276056560161417, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 1, + "negatives": 2805, + "auroc": 0.881283422459893, + "auprc": 0.0029940119760479044, + "brier": 0.00035989249398849193, + "calibration": { + "observed_rate": 0.0003563791874554526, + "mean_prediction": 0.0007875470197841625, + "calibration_in_the_large": 0.00043116783232870985, + "expected_calibration_error_10bin": 0.00043116783232870985, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 1, + "negatives": 2805, + "auroc": 0.8809269162210339, + "auprc": 0.0029850746268656717, + "brier": 0.000360466960433347, + "calibration": { + "observed_rate": 0.0003563791874554526, + "mean_prediction": 0.0008490360654150371, + "calibration_in_the_large": 0.0004926568779595844, + "expected_calibration_error_10bin": 0.0004926568779595844, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.8846291012838802, + "auprc": 0.004526459081000295, + "brier": 0.0007166089815749642, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0009562706926936087, + "calibration_in_the_large": 0.00024351231778270345, + "expected_calibration_error_10bin": 0.00024351231778270345, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.8851640513552068, + "auprc": 0.004525258379213755, + "brier": 0.0007169290442376586, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0009931614604215756, + "calibration_in_the_large": 0.0002804030855106704, + "expected_calibration_error_10bin": 0.0002804030855106704, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.8855206847360912, + "auprc": 0.004554518702083172, + "brier": 0.0007178324655715538, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0010625005888314802, + "calibration_in_the_large": 0.00034974221392057494, + "expected_calibration_error_10bin": 0.00034974221392057494, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.8862339514978602, + "auprc": 0.0045753559155621015, + "brier": 0.0007183620920436621, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0011004160109653238, + "calibration_in_the_large": 0.00038765763605441857, + "expected_calibration_error_10bin": 0.00038765763605441857, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.8840941512125535, + "auprc": 0.004478958867673601, + "brier": 0.0007196738612726834, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0011889916755786396, + "calibration_in_the_large": 0.00047623330066773437, + "expected_calibration_error_10bin": 0.00047623330066773437, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.8842724679029957, + "auprc": 0.004484924742867493, + "brier": 0.000719711230656461, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0011922213534551439, + "calibration_in_the_large": 0.00047946297854423864, + "expected_calibration_error_10bin": 0.00047946297854423864, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + } + ], + "reason": null + }, + "M46": { + "time_averaged_auroc": 0.5430404479964045, + "time_averaged_auprc": 0.0023443868555073064, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2814, + "positives": 0, + "negatives": 2814, + "auroc": null, + "auprc": null, + "brier": 3.5485282111036526e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00034794317049070063, + "calibration_in_the_large": 0.00034794317049070063, + "expected_calibration_error_10bin": 0.00034794317049070063, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 1, + "negatives": 2813, + "auroc": 0.1702808389619623, + "auprc": 0.00042826552462526765, + "brier": 0.00035684104004644624, + "calibration": { + "observed_rate": 0.00035536602700781805, + "mean_prediction": 0.0007722912810130847, + "calibration_in_the_large": 0.00041692525400526665, + "expected_calibration_error_10bin": 0.00041692525400526665, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 2, + "negatives": 2812, + "auroc": 0.47670697012802277, + "auprc": 0.0012500844176309036, + "brier": 0.0007126580532559534, + "calibration": { + "observed_rate": 0.0007107320540156361, + "mean_prediction": 0.0010730188023780629, + "calibration_in_the_large": 0.0003622867483624268, + "expected_calibration_error_10bin": 0.0003622867483624268, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 3, + "negatives": 2811, + "auroc": 0.5385983635716827, + "auprc": 0.0015742803365758956, + "brier": 0.0010690170597634587, + "calibration": { + "observed_rate": 0.0010660980810234541, + "mean_prediction": 0.0013597301571534087, + "calibration_in_the_large": 0.0002936320761299546, + "expected_calibration_error_10bin": 0.0002936320761299546, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 3, + "negatives": 2811, + "auroc": 0.5576900272738052, + "auprc": 0.0016444852642380431, + "brier": 0.001070583390859156, + "calibration": { + "observed_rate": 0.0010660980810234541, + "mean_prediction": 0.0016025866260258124, + "calibration_in_the_large": 0.0005364885450023582, + "expected_calibration_error_10bin": 0.0005364885450023582, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 4, + "negatives": 2810, + "auroc": 0.6035587188612099, + "auprc": 0.0022976233469601064, + "brier": 0.0014254694470165355, + "calibration": { + "observed_rate": 0.0014214641080312722, + "mean_prediction": 0.0017410364327488921, + "calibration_in_the_large": 0.00031957232471761994, + "expected_calibration_error_10bin": 0.00031957232471761994, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 4, + "negatives": 2810, + "auroc": 0.6194839857651245, + "auprc": 0.002378685375760999, + "brier": 0.001426579172208385, + "calibration": { + "observed_rate": 0.0014214641080312722, + "mean_prediction": 0.0019045823105498505, + "calibration_in_the_large": 0.00048311820251857834, + "expected_calibration_error_10bin": 0.00048311820251857834, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 4, + "negatives": 2810, + "auroc": 0.6146797153024911, + "auprc": 0.002336428323456023, + "brier": 0.0014278969676082228, + "calibration": { + "observed_rate": 0.0014214641080312722, + "mean_prediction": 0.002068118333275656, + "calibration_in_the_large": 0.0006466542252443839, + "expected_calibration_error_10bin": 0.0006466542252443839, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 4, + "negatives": 2810, + "auroc": 0.6157473309608541, + "auprc": 0.002336027847777431, + "brier": 0.0014287416320238181, + "calibration": { + "observed_rate": 0.0014214641080312722, + "mean_prediction": 0.0021433993543699854, + "calibration_in_the_large": 0.0007219352463387133, + "expected_calibration_error_10bin": 0.0007219352463387133, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 4, + "negatives": 2810, + "auroc": 0.6161921708185053, + "auprc": 0.0023332912032473373, + "brier": 0.0014290719665746643, + "calibration": { + "observed_rate": 0.0014214641080312722, + "mean_prediction": 0.0021789142501608496, + "calibration_in_the_large": 0.0007574501421295774, + "expected_calibration_error_10bin": 0.0007574501421295774, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 7, + "negatives": 2807, + "auroc": 0.570308921573617, + "auprc": 0.0038671187624885616, + "brier": 0.00248974321155119, + "calibration": { + "observed_rate": 0.0024875621890547263, + "mean_prediction": 0.002325725391967887, + "calibration_in_the_large": -0.0001618367970868395, + "expected_calibration_error_10bin": 0.0001618367970868395, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 7, + "negatives": 2807, + "auroc": 0.5666955061326276, + "auprc": 0.003844024940635058, + "brier": 0.0024903794538120474, + "calibration": { + "observed_rate": 0.0024875621890547263, + "mean_prediction": 0.0024292637881379894, + "calibration_in_the_large": -5.8298400916736905e-05, + "expected_calibration_error_10bin": 5.8298400916736905e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + { + "valid": 2814, + "positives": 7, + "negatives": 2807, + "auroc": 0.566542826606952, + "auprc": 0.0038423269226920556, + "brier": 0.0024904481181740133, + "calibration": { + "observed_rate": 0.0024875621890547263, + "mean_prediction": 0.0024372450018518553, + "calibration_in_the_large": -5.031718720287107e-05, + "expected_calibration_error_10bin": 5.031718720287107e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + } + ], + "reason": null + }, + "M47": { + "time_averaged_auroc": 0.7107914799750932, + "time_averaged_auprc": 0.012312216023149278, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2743, + "positives": 1, + "negatives": 2742, + "auroc": 0.5525164113785558, + "auprc": 0.0008143322475570033, + "brier": 0.00036476468797047487, + "calibration": { + "observed_rate": 0.0003645643456069996, + "mean_prediction": 0.0005650906861387664, + "calibration_in_the_large": 0.00020052634053176682, + "expected_calibration_error_10bin": 0.00020052634053176682, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 2, + "negatives": 2741, + "auroc": 0.6900766143743159, + "auprc": 0.004798777918246944, + "brier": 0.0007284503048648989, + "calibration": { + "observed_rate": 0.0007291286912139992, + "mean_prediction": 0.0010258644520863152, + "calibration_in_the_large": 0.000296735760872316, + "expected_calibration_error_10bin": 0.000296735760872316, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 3, + "negatives": 2740, + "auroc": 0.6885644768856448, + "auprc": 0.004265663199040737, + "brier": 0.0010923539882611339, + "calibration": { + "observed_rate": 0.001093693036820999, + "mean_prediction": 0.0011891708135127568, + "calibration_in_the_large": 9.547777669175785e-05, + "expected_calibration_error_10bin": 9.547777669175785e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 3, + "negatives": 2740, + "auroc": 0.6717761557177615, + "auprc": 0.003678135971167252, + "brier": 0.001094011982233147, + "calibration": { + "observed_rate": 0.001093693036820999, + "mean_prediction": 0.0015939506936796589, + "calibration_in_the_large": 0.00050025765685866, + "expected_calibration_error_10bin": 0.00050025765685866, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 4, + "negatives": 2739, + "auroc": 0.7495436290617014, + "auprc": 0.00839621359032706, + "brier": 0.001454267852233176, + "calibration": { + "observed_rate": 0.0014582573824279985, + "mean_prediction": 0.0016951954949851668, + "calibration_in_the_large": 0.00023693811255716835, + "expected_calibration_error_10bin": 0.00023693811255716835, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 5, + "negatives": 2738, + "auroc": 0.7715850986121257, + "auprc": 0.009203908121315925, + "brier": 0.001816431285832069, + "calibration": { + "observed_rate": 0.0018228217280349982, + "mean_prediction": 0.0019022539651499118, + "calibration_in_the_large": 7.943223711491358e-05, + "expected_calibration_error_10bin": 7.943223711491358e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 7, + "negatives": 2736, + "auroc": 0.7799707602339181, + "auprc": 0.020072611299073444, + "brier": 0.0025341656008012817, + "calibration": { + "observed_rate": 0.0025519504192489974, + "mean_prediction": 0.0022056704686266313, + "calibration_in_the_large": -0.0003462799506223661, + "expected_calibration_error_10bin": 0.0003462799506223661, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 9, + "negatives": 2734, + "auroc": 0.7678208567016175, + "auprc": 0.019739209865872208, + "brier": 0.0032564817631568405, + "calibration": { + "observed_rate": 0.0032810791104629965, + "mean_prediction": 0.0024423414299727495, + "calibration_in_the_large": -0.000838737680490247, + "expected_calibration_error_10bin": 0.000838737680490247, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 10, + "negatives": 2733, + "auroc": 0.741017197219173, + "auprc": 0.018413701207011374, + "brier": 0.003619394058697418, + "calibration": { + "observed_rate": 0.0036456434560699965, + "mean_prediction": 0.0025423516239119984, + "calibration_in_the_large": -0.001103291832157998, + "expected_calibration_error_10bin": 0.001103291832157998, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 10, + "negatives": 2733, + "auroc": 0.7393706549579216, + "auprc": 0.018895545791303574, + "brier": 0.0036186241526766283, + "calibration": { + "observed_rate": 0.0036456434560699965, + "mean_prediction": 0.002716849137980919, + "calibration_in_the_large": -0.0009287943180890774, + "expected_calibration_error_10bin": 0.0009287943180890774, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 11, + "negatives": 2732, + "auroc": 0.6956275788633036, + "auprc": 0.017347187390062982, + "brier": 0.003981837690557673, + "calibration": { + "observed_rate": 0.004010207801676996, + "mean_prediction": 0.002946532716589847, + "calibration_in_the_large": -0.0010636750850871487, + "expected_calibration_error_10bin": 0.0010636750850871487, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 11, + "negatives": 2732, + "auroc": 0.6960934380407294, + "auprc": 0.017214842932163184, + "brier": 0.003981251020831697, + "calibration": { + "observed_rate": 0.004010207801676996, + "mean_prediction": 0.0031379262173317547, + "calibration_in_the_large": -0.000872281584345241, + "expected_calibration_error_10bin": 0.000872281584345241, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 11, + "negatives": 2732, + "auroc": 0.6963263676294423, + "auprc": 0.017218678767798947, + "brier": 0.003981267491985895, + "calibration": { + "observed_rate": 0.004010207801676996, + "mean_prediction": 0.0031449293583395376, + "calibration_in_the_large": -0.000865278443337458, + "expected_calibration_error_10bin": 0.000865278443337458, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + } + ], + "reason": null + }, + "M48": { + "time_averaged_auroc": 0.769703365907856, + "time_averaged_auprc": 0.013382337023110622, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2690, + "positives": 2, + "negatives": 2688, + "auroc": 0.8612351190476191, + "auprc": 0.00978471214320271, + "brier": 0.0007419673129477118, + "calibration": { + "observed_rate": 0.0007434944237918215, + "mean_prediction": 0.001232265169856505, + "calibration_in_the_large": 0.0004887707460646834, + "expected_calibration_error_10bin": 0.0004887707460646834, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + { + "valid": 2690, + "positives": 3, + "negatives": 2687, + "auroc": 0.8970351073067857, + "auprc": 0.01786201603274774, + "brier": 0.0011099026343264792, + "calibration": { + "observed_rate": 0.0011152416356877324, + "mean_prediction": 0.002104884296288395, + "calibration_in_the_large": 0.0009896426606006625, + "expected_calibration_error_10bin": 0.0009896426606006625, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + { + "valid": 2690, + "positives": 4, + "negatives": 2686, + "auroc": 0.7006701414743113, + "auprc": 0.011938445043283754, + "brier": 0.001491330492765365, + "calibration": { + "observed_rate": 0.001486988847583643, + "mean_prediction": 0.003083990229063578, + "calibration_in_the_large": 0.001597001381479935, + "expected_calibration_error_10bin": 0.001597001381479935, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + { + "valid": 2690, + "positives": 5, + "negatives": 2685, + "auroc": 0.717243947858473, + "auprc": 0.010319547852924443, + "brier": 0.0018673093013488406, + "calibration": { + "observed_rate": 0.0018587360594795538, + "mean_prediction": 0.0036563380870216814, + "calibration_in_the_large": 0.0017976020275421276, + "expected_calibration_error_10bin": 0.0017976020275421276, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + { + "valid": 2690, + "positives": 7, + "negatives": 2683, + "auroc": 0.7396304776103508, + "auprc": 0.011055065458285504, + "brier": 0.002605186072040574, + "calibration": { + "observed_rate": 0.0026022304832713753, + "mean_prediction": 0.004127727458626227, + "calibration_in_the_large": 0.0015254969753548515, + "expected_calibration_error_10bin": 0.0015254969753548515, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + { + "valid": 2690, + "positives": 8, + "negatives": 2682, + "auroc": 0.7208240119313944, + "auprc": 0.010385574778186087, + "brier": 0.0029832868607764214, + "calibration": { + "observed_rate": 0.002973977695167286, + "mean_prediction": 0.0045956005997519565, + "calibration_in_the_large": 0.0016216229045846703, + "expected_calibration_error_10bin": 0.0016216229045846703, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + { + "valid": 2690, + "positives": 10, + "negatives": 2680, + "auroc": 0.7644029850746269, + "auprc": 0.014551133851867631, + "brier": 0.0037103467012400363, + "calibration": { + "observed_rate": 0.0037174721189591076, + "mean_prediction": 0.004981480412059472, + "calibration_in_the_large": 0.0012640082931003648, + "expected_calibration_error_10bin": 0.0012640082931003648, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + { + "valid": 2690, + "positives": 10, + "negatives": 2680, + "auroc": 0.7646641791044776, + "auprc": 0.014565066736689374, + "brier": 0.00371722489110939, + "calibration": { + "observed_rate": 0.0037174721189591076, + "mean_prediction": 0.005382344965319033, + "calibration_in_the_large": 0.0016648728463599253, + "expected_calibration_error_10bin": 0.0016648728463599253, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + { + "valid": 2690, + "positives": 10, + "negatives": 2680, + "auroc": 0.7628358208955224, + "auprc": 0.014337802665450042, + "brier": 0.003725391117814756, + "calibration": { + "observed_rate": 0.0037174721189591076, + "mean_prediction": 0.0058336247901322295, + "calibration_in_the_large": 0.002116152671173122, + "expected_calibration_error_10bin": 0.002116152671173122, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + { + "valid": 2690, + "positives": 10, + "negatives": 2680, + "auroc": 0.7663805970149253, + "auprc": 0.014359270687350581, + "brier": 0.003733133438561543, + "calibration": { + "observed_rate": 0.0037174721189591076, + "mean_prediction": 0.00619045493660255, + "calibration_in_the_large": 0.002472982817643442, + "expected_calibration_error_10bin": 0.002472982817643442, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + { + "valid": 2690, + "positives": 10, + "negatives": 2680, + "auroc": 0.765223880597015, + "auprc": 0.014482050337633477, + "brier": 0.003742688942962526, + "calibration": { + "observed_rate": 0.0037174721189591076, + "mean_prediction": 0.006619722700708539, + "calibration_in_the_large": 0.002902250581749431, + "expected_calibration_error_10bin": 0.002902250581749431, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + { + "valid": 2690, + "positives": 11, + "negatives": 2679, + "auroc": 0.7731175133190811, + "auprc": 0.01516900663038862, + "brier": 0.004117519645131466, + "calibration": { + "observed_rate": 0.004089219330855019, + "mean_prediction": 0.0070669964248378115, + "calibration_in_the_large": 0.002977777093982793, + "expected_calibration_error_10bin": 0.0029777770939827925, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + { + "valid": 2690, + "positives": 11, + "negatives": 2679, + "auroc": 0.7728799755675455, + "auprc": 0.015160689082428147, + "brier": 0.004119223703036232, + "calibration": { + "observed_rate": 0.004089219330855019, + "mean_prediction": 0.00712306530101352, + "calibration_in_the_large": 0.0030338459701585016, + "expected_calibration_error_10bin": 0.0030338459701585016, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + } + ], + "reason": null + }, + "M51": { + "time_averaged_auroc": 0.9182938177062677, + "time_averaged_auprc": 0.012942196154989778, + "valid_timepoint_cells": 11, + "timepoints": [ + { + "valid": 2785, + "positives": 0, + "negatives": 2785, + "auroc": null, + "auprc": null, + "brier": 7.922405904762153e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0007152995332921696, + "calibration_in_the_large": 0.0007152995332921696, + "expected_calibration_error_10bin": 0.0007152995332921696, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 0, + "negatives": 2785, + "auroc": null, + "auprc": null, + "brier": 2.3521538110529908e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0012469913005799388, + "calibration_in_the_large": 0.0012469913005799388, + "expected_calibration_error_10bin": 0.0012469913005799388, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 1, + "negatives": 2784, + "auroc": 0.959051724137931, + "auprc": 0.008695652173913044, + "brier": 0.00035982708873701064, + "calibration": { + "observed_rate": 0.0003590664272890485, + "mean_prediction": 0.0015091534874229976, + "calibration_in_the_large": 0.0011500870601339492, + "expected_calibration_error_10bin": 0.0011500870601339492, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 1, + "negatives": 2784, + "auroc": 0.9701867816091954, + "auprc": 0.011904761904761904, + "brier": 0.00036081942592940044, + "calibration": { + "observed_rate": 0.0003590664272890485, + "mean_prediction": 0.0018815871747848085, + "calibration_in_the_large": 0.00152252074749576, + "expected_calibration_error_10bin": 0.00152252074749576, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 1, + "negatives": 2784, + "auroc": 0.9730603448275862, + "auprc": 0.013157894736842105, + "brier": 0.00036120903047007403, + "calibration": { + "observed_rate": 0.0003590664272890485, + "mean_prediction": 0.0019894942343322798, + "calibration_in_the_large": 0.0016304278070432313, + "expected_calibration_error_10bin": 0.0016304278070432313, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 2, + "negatives": 2783, + "auroc": 0.94699964067553, + "auprc": 0.011984153185869924, + "brier": 0.0007179639926574884, + "calibration": { + "observed_rate": 0.000718132854578097, + "mean_prediction": 0.002219196065713374, + "calibration_in_the_large": 0.0015010632111352772, + "expected_calibration_error_10bin": 0.0015010632111352772, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 2, + "negatives": 2783, + "auroc": 0.948796263025512, + "auprc": 0.012489294890094205, + "brier": 0.000718663881521959, + "calibration": { + "observed_rate": 0.000718132854578097, + "mean_prediction": 0.002426440435963519, + "calibration_in_the_large": 0.001708307581385422, + "expected_calibration_error_10bin": 0.001708307581385422, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 3, + "negatives": 2782, + "auroc": 0.9279894560268392, + "auprc": 0.011112690515675592, + "brier": 0.0010753257828384148, + "calibration": { + "observed_rate": 0.0010771992818671453, + "mean_prediction": 0.002584113442838314, + "calibration_in_the_large": 0.0015069141609711687, + "expected_calibration_error_10bin": 0.0015069141609711687, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 3, + "negatives": 2782, + "auroc": 0.9241552839683681, + "auprc": 0.010568500459068464, + "brier": 0.0010764635565570734, + "calibration": { + "observed_rate": 0.0010771992818671453, + "mean_prediction": 0.002853829254757001, + "calibration_in_the_large": 0.0017766299728898558, + "expected_calibration_error_10bin": 0.0017766299728898558, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.9408486156058972, + "auprc": 0.01801823276487064, + "brier": 0.0014298859175313455, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.0030505251939992855, + "calibration_in_the_large": 0.0016142594848430915, + "expected_calibration_error_10bin": 0.0016142594848430915, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 5, + "negatives": 2780, + "auroc": 0.837841726618705, + "auprc": 0.014933734670506627, + "brier": 0.0017876217744670598, + "calibration": { + "observed_rate": 0.0017953321364452424, + "mean_prediction": 0.003225418173633198, + "calibration_in_the_large": 0.0014300860371879555, + "expected_calibration_error_10bin": 0.0014300860371879555, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 5, + "negatives": 2780, + "auroc": 0.8361870503597122, + "auprc": 0.014792530847104607, + "brier": 0.0017882446472915633, + "calibration": { + "observed_rate": 0.0017953321364452424, + "mean_prediction": 0.0034227807750809216, + "calibration_in_the_large": 0.0016274486386356792, + "expected_calibration_error_10bin": 0.0016274486386356792, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + { + "valid": 2785, + "positives": 5, + "negatives": 2780, + "auroc": 0.836115107913669, + "auprc": 0.014706711556180455, + "brier": 0.0017882792672758124, + "calibration": { + "observed_rate": 0.0017953321364452424, + "mean_prediction": 0.0034326542625843282, + "calibration_in_the_large": 0.0016373221261390858, + "expected_calibration_error_10bin": 0.0016373221261390858, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + } + ], + "reason": null + }, + "M54": { + "time_averaged_auroc": 0.7009964283027613, + "time_averaged_auprc": 0.03801274907763824, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2567, + "positives": 10, + "negatives": 2557, + "auroc": 0.6544387954634338, + "auprc": 0.012803722814750104, + "brier": 0.003877460387996052, + "calibration": { + "observed_rate": 0.0038955979742890533, + "mean_prediction": 0.004659706217290875, + "calibration_in_the_large": 0.0007641082430018217, + "expected_calibration_error_10bin": 0.0007641082430018217, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + { + "valid": 2567, + "positives": 13, + "negatives": 2554, + "auroc": 0.6854707547738088, + "auprc": 0.017061149228888045, + "brier": 0.005037523751448775, + "calibration": { + "observed_rate": 0.00506427736657577, + "mean_prediction": 0.006815344598725235, + "calibration_in_the_large": 0.0017510672321494657, + "expected_calibration_error_10bin": 0.0017510672321494657, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + { + "valid": 2567, + "positives": 22, + "negatives": 2545, + "auroc": 0.6758706911948562, + "auprc": 0.023638972214693254, + "brier": 0.00847701234399687, + "calibration": { + "observed_rate": 0.008570315543435918, + "mean_prediction": 0.008782715462301475, + "calibration_in_the_large": 0.00021239991886555683, + "expected_calibration_error_10bin": 0.00021239991886555658, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + { + "valid": 2567, + "positives": 27, + "negatives": 2540, + "auroc": 0.6849664625255176, + "auprc": 0.026840475544057146, + "brier": 0.010388486318525389, + "calibration": { + "observed_rate": 0.010518114530580444, + "mean_prediction": 0.010179937064606315, + "calibration_in_the_large": -0.00033817746597412934, + "expected_calibration_error_10bin": 0.000885318476836627, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + { + "valid": 2567, + "positives": 29, + "negatives": 2538, + "auroc": 0.7010135594141463, + "auprc": 0.0304718681220128, + "brier": 0.011144467600435392, + "calibration": { + "observed_rate": 0.011297234125438255, + "mean_prediction": 0.011469263779155454, + "calibration_in_the_large": 0.00017202965371719905, + "expected_calibration_error_10bin": 0.00017202965371719857, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + { + "valid": 2567, + "positives": 32, + "negatives": 2535, + "auroc": 0.7013683431952663, + "auprc": 0.03863790383180582, + "brier": 0.01223444851951437, + "calibration": { + "observed_rate": 0.012465913517724971, + "mean_prediction": 0.012598729016877716, + "calibration_in_the_large": 0.00013281549915274485, + "expected_calibration_error_10bin": 0.00019243693748455658, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + { + "valid": 2567, + "positives": 35, + "negatives": 2532, + "auroc": 0.6988038817422704, + "auprc": 0.038569033510933486, + "brier": 0.013390878568806363, + "calibration": { + "observed_rate": 0.013634592910011687, + "mean_prediction": 0.013555466098611848, + "calibration_in_the_large": -7.912681139983849e-05, + "expected_calibration_error_10bin": 0.00037723597672263226, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + { + "valid": 2567, + "positives": 39, + "negatives": 2528, + "auroc": 0.7207379909120415, + "auprc": 0.04415535674705508, + "brier": 0.014844893820803133, + "calibration": { + "observed_rate": 0.015192832099727308, + "mean_prediction": 0.014367515794063196, + "calibration_in_the_large": -0.0008253163056641116, + "expected_calibration_error_10bin": 0.001689841264463746, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + { + "valid": 2567, + "positives": 40, + "negatives": 2527, + "auroc": 0.7281163434903047, + "auprc": 0.04951489888933107, + "brier": 0.01516425605326574, + "calibration": { + "observed_rate": 0.015582391897156213, + "mean_prediction": 0.015252581308976783, + "calibration_in_the_large": -0.00032981058817943033, + "expected_calibration_error_10bin": 0.0005927292188269608, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + { + "valid": 2567, + "positives": 43, + "negatives": 2524, + "auroc": 0.7265230531087605, + "auprc": 0.05033832219653228, + "brier": 0.016301806458005216, + "calibration": { + "observed_rate": 0.01675107128944293, + "mean_prediction": 0.01660316486670235, + "calibration_in_the_large": -0.00014790642274058186, + "expected_calibration_error_10bin": 0.0014966490843021667, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + { + "valid": 2567, + "positives": 46, + "negatives": 2521, + "auroc": 0.7084231585119777, + "auprc": 0.05301815130944, + "brier": 0.017404951567809374, + "calibration": { + "observed_rate": 0.017919750681729647, + "mean_prediction": 0.017463740953614332, + "calibration_in_the_large": -0.00045600972811531484, + "expected_calibration_error_10bin": 0.0022233438518541935, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + { + "valid": 2567, + "positives": 47, + "negatives": 2520, + "auroc": 0.7134245187436676, + "auprc": 0.05454842696448162, + "brier": 0.017768868694359417, + "calibration": { + "observed_rate": 0.018309310479158552, + "mean_prediction": 0.018037483988579742, + "calibration_in_the_large": -0.00027182649057880953, + "expected_calibration_error_10bin": 0.0023313090133084916, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + { + "valid": 2567, + "positives": 47, + "negatives": 2520, + "auroc": 0.7137960148598447, + "auprc": 0.054567456635316446, + "brier": 0.01777054358930818, + "calibration": { + "observed_rate": 0.018309310479158552, + "mean_prediction": 0.018218188424649846, + "calibration_in_the_large": -9.112205450870561e-05, + "expected_calibration_error_10bin": 0.002261758590453418, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + } + ], + "reason": null + }, + "M62": { + "time_averaged_auroc": 0.73698185948262, + "time_averaged_auprc": 0.013330379676443913, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2781, + "positives": 0, + "negatives": 2781, + "auroc": null, + "auprc": null, + "brier": 1.0528708127915547e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0008765209657010726, + "calibration_in_the_large": 0.0008765209657010726, + "expected_calibration_error_10bin": 0.0008765209657010726, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 2, + "negatives": 2779, + "auroc": 0.5575746671464555, + "auprc": 0.003722374117110959, + "brier": 0.0007197150141120437, + "calibration": { + "observed_rate": 0.000719165767709457, + "mean_prediction": 0.0015021556041693882, + "calibration_in_the_large": 0.0007829898364599312, + "expected_calibration_error_10bin": 0.0007829898364599312, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 5, + "negatives": 2776, + "auroc": 0.7963976945244957, + "auprc": 0.015036894144650365, + "brier": 0.0017891589164767835, + "calibration": { + "observed_rate": 0.0017979144192736426, + "mean_prediction": 0.001897996618007514, + "calibration_in_the_large": 0.00010008219873387141, + "expected_calibration_error_10bin": 0.00010008219873387141, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 5, + "negatives": 2776, + "auroc": 0.7961815561959654, + "auprc": 0.014053071445119258, + "brier": 0.0017889539906113011, + "calibration": { + "observed_rate": 0.0017979144192736426, + "mean_prediction": 0.0021288016811819043, + "calibration_in_the_large": 0.00033088726190826177, + "expected_calibration_error_10bin": 0.00033088726190826177, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 6, + "negatives": 2775, + "auroc": 0.8174774774774775, + "auprc": 0.015110735686700886, + "brier": 0.0021449770985028736, + "calibration": { + "observed_rate": 0.002157497303128371, + "mean_prediction": 0.0024059923750236454, + "calibration_in_the_large": 0.0002484950718952745, + "expected_calibration_error_10bin": 0.0002484950718952745, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 7, + "negatives": 2774, + "auroc": 0.830930064888248, + "auprc": 0.01686423275131691, + "brier": 0.0024996869264346123, + "calibration": { + "observed_rate": 0.0025170801869830997, + "mean_prediction": 0.002741004345002427, + "calibration_in_the_large": 0.00022392415801932714, + "expected_calibration_error_10bin": 0.00022392415801932714, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 8, + "negatives": 2773, + "auroc": 0.758294266137757, + "auprc": 0.014755110723462299, + "brier": 0.002858605489292015, + "calibration": { + "observed_rate": 0.002876663070837828, + "mean_prediction": 0.003060683144633389, + "calibration_in_the_large": 0.00018402007379556082, + "expected_calibration_error_10bin": 0.00018402007379556082, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 9, + "negatives": 2772, + "auroc": 0.7479156645823313, + "auprc": 0.014307502274759486, + "brier": 0.0032159072058453105, + "calibration": { + "observed_rate": 0.003236245954692557, + "mean_prediction": 0.0032535716691402686, + "calibration_in_the_large": 1.732571444771182e-05, + "expected_calibration_error_10bin": 1.732571444771182e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 10, + "negatives": 2771, + "auroc": 0.6950198484301696, + "auprc": 0.012972560446332567, + "brier": 0.003575179202759254, + "calibration": { + "observed_rate": 0.003595828838547285, + "mean_prediction": 0.0035115436566713963, + "calibration_in_the_large": -8.428518187588883e-05, + "expected_calibration_error_10bin": 8.428518187588883e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 10, + "negatives": 2771, + "auroc": 0.6962468422952003, + "auprc": 0.01255931415094734, + "brier": 0.0035759735432185627, + "calibration": { + "observed_rate": 0.003595828838547285, + "mean_prediction": 0.003758203644812906, + "calibration_in_the_large": 0.00016237480626562096, + "expected_calibration_error_10bin": 0.00016237480626562096, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 11, + "negatives": 2770, + "auroc": 0.7115851657367903, + "auprc": 0.013171252780094287, + "brier": 0.0039313297071257676, + "calibration": { + "observed_rate": 0.003955411722402014, + "mean_prediction": 0.00391825708198632, + "calibration_in_the_large": -3.7154640415693746e-05, + "expected_calibration_error_10bin": 3.7154640415693746e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 13, + "negatives": 2768, + "auroc": 0.7192919075144508, + "auprc": 0.013697877842498617, + "brier": 0.004642637676366486, + "calibration": { + "observed_rate": 0.004674577490111471, + "mean_prediction": 0.004185579345004897, + "calibration_in_the_large": -0.0004889981451065735, + "expected_calibration_error_10bin": 0.0004889981451065735, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + { + "valid": 2781, + "positives": 14, + "negatives": 2767, + "auroc": 0.7168671588620993, + "auprc": 0.013713629754333986, + "brier": 0.004999062013451568, + "calibration": { + "observed_rate": 0.005034160373966199, + "mean_prediction": 0.004199365922528229, + "calibration_in_the_large": -0.0008347944514379702, + "expected_calibration_error_10bin": 0.0008347944514379702, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + } + ], + "reason": null + }, + "M79": { + "time_averaged_auroc": 0.7699467365508149, + "time_averaged_auprc": 0.03648910585470001, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2697, + "positives": 7, + "negatives": 2690, + "auroc": 0.8951672862453531, + "auprc": 0.03547601210930499, + "brier": 0.0025701908782408433, + "calibration": { + "observed_rate": 0.0025954764553207266, + "mean_prediction": 0.003987214394850162, + "calibration_in_the_large": 0.0013917379395294357, + "expected_calibration_error_10bin": 0.0013917379395294357, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + { + "valid": 2697, + "positives": 15, + "negatives": 2682, + "auroc": 0.7732289336316182, + "auprc": 0.02155512067433006, + "brier": 0.005502299590456802, + "calibration": { + "observed_rate": 0.0055617352614015575, + "mean_prediction": 0.006302512956044713, + "calibration_in_the_large": 0.0007407776946431553, + "expected_calibration_error_10bin": 0.0007407776946431553, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + { + "valid": 2697, + "positives": 19, + "negatives": 2678, + "auroc": 0.7629024016351559, + "auprc": 0.02556782944279267, + "brier": 0.006963185271020144, + "calibration": { + "observed_rate": 0.0070448646644419724, + "mean_prediction": 0.007988906553591621, + "calibration_in_the_large": 0.0009440418891496485, + "expected_calibration_error_10bin": 0.0009440418891496486, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + { + "valid": 2697, + "positives": 19, + "negatives": 2678, + "auroc": 0.7649070398176172, + "auprc": 0.025135960051641783, + "brier": 0.006978250849654003, + "calibration": { + "observed_rate": 0.0070448646644419724, + "mean_prediction": 0.009121491917774003, + "calibration_in_the_large": 0.002076627253332031, + "expected_calibration_error_10bin": 0.002076627253332032, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + { + "valid": 2697, + "positives": 23, + "negatives": 2674, + "auroc": 0.7904458391597021, + "auprc": 0.03283026817446329, + "brier": 0.008399433507901186, + "calibration": { + "observed_rate": 0.008527994067482388, + "mean_prediction": 0.010345344211126466, + "calibration_in_the_large": 0.001817350143644078, + "expected_calibration_error_10bin": 0.001817350143644079, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + { + "valid": 2697, + "positives": 24, + "negatives": 2673, + "auroc": 0.7947063224841002, + "auprc": 0.034746695427896296, + "brier": 0.00879318601471213, + "calibration": { + "observed_rate": 0.008898776418242492, + "mean_prediction": 0.011720875178987431, + "calibration_in_the_large": 0.0028220987607449396, + "expected_calibration_error_10bin": 0.002822098760744941, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + { + "valid": 2697, + "positives": 29, + "negatives": 2668, + "auroc": 0.7751641420668975, + "auprc": 0.036355069999908084, + "brier": 0.01062373417451454, + "calibration": { + "observed_rate": 0.010752688172043012, + "mean_prediction": 0.012712463679729311, + "calibration_in_the_large": 0.0019597755076862997, + "expected_calibration_error_10bin": 0.0019597755076863023, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + { + "valid": 2697, + "positives": 31, + "negatives": 2666, + "auroc": 0.7729956682719067, + "auprc": 0.039257865620926174, + "brier": 0.011334406183518303, + "calibration": { + "observed_rate": 0.011494252873563218, + "mean_prediction": 0.01392939102466981, + "calibration_in_the_large": 0.0024351381511065924, + "expected_calibration_error_10bin": 0.0024351381511065915, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + { + "valid": 2697, + "positives": 33, + "negatives": 2664, + "auroc": 0.7446764946764947, + "auprc": 0.03817208755287777, + "brier": 0.012116863175431716, + "calibration": { + "observed_rate": 0.012235817575083427, + "mean_prediction": 0.014998820930411006, + "calibration_in_the_large": 0.00276300335532758, + "expected_calibration_error_10bin": 0.0027630033553275794, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + { + "valid": 2697, + "positives": 39, + "negatives": 2658, + "auroc": 0.7418436842816075, + "auprc": 0.04490702158249528, + "brier": 0.01421689783824527, + "calibration": { + "observed_rate": 0.014460511679644048, + "mean_prediction": 0.01565369878527213, + "calibration_in_the_large": 0.001193187105628081, + "expected_calibration_error_10bin": 0.0018242273481556175, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + { + "valid": 2697, + "positives": 42, + "negatives": 2655, + "auroc": 0.7397901533494754, + "auprc": 0.04732592220203856, + "brier": 0.015288983494128872, + "calibration": { + "observed_rate": 0.01557285873192436, + "mean_prediction": 0.016465362494759272, + "calibration_in_the_large": 0.0008925037628349126, + "expected_calibration_error_10bin": 0.0026654323235704583, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + { + "valid": 2697, + "positives": 43, + "negatives": 2654, + "auroc": 0.726687229456196, + "auprc": 0.04653789070096456, + "brier": 0.015699667738840656, + "calibration": { + "observed_rate": 0.015943641082684465, + "mean_prediction": 0.017441681044531553, + "calibration_in_the_large": 0.0014980399618470877, + "expected_calibration_error_10bin": 0.003042677232177572, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + { + "valid": 2697, + "positives": 43, + "negatives": 2654, + "auroc": 0.726792380084471, + "auprc": 0.04649063257146071, + "brier": 0.015705449295807174, + "calibration": { + "observed_rate": 0.015943641082684465, + "mean_prediction": 0.017563545008262148, + "calibration_in_the_large": 0.0016199039255776829, + "expected_calibration_error_10bin": 0.002959641898782979, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + } + ], + "reason": null + }, + "M81": { + "time_averaged_auroc": 0.7588322178994732, + "time_averaged_auprc": 0.03734805415571847, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2705, + "positives": 2, + "negatives": 2703, + "auroc": 0.4328523862375139, + "auprc": 0.0015927677360179709, + "brier": 0.0007433788784374257, + "calibration": { + "observed_rate": 0.0007393715341959334, + "mean_prediction": 0.0008625910500864686, + "calibration_in_the_large": 0.0001232195158905352, + "expected_calibration_error_10bin": 0.0001232195158905352, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + { + "valid": 2705, + "positives": 5, + "negatives": 2700, + "auroc": 0.7559259259259259, + "auprc": 0.02800194048736514, + "brier": 0.001831808632400622, + "calibration": { + "observed_rate": 0.0018484288354898336, + "mean_prediction": 0.0016072510103728784, + "calibration_in_the_large": -0.0002411778251169552, + "expected_calibration_error_10bin": 0.0002411778251169552, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + { + "valid": 2705, + "positives": 6, + "negatives": 2699, + "auroc": 0.7956650611337532, + "auprc": 0.033568916988167205, + "brier": 0.002194049818297401, + "calibration": { + "observed_rate": 0.0022181146025878, + "mean_prediction": 0.002314474538768843, + "calibration_in_the_large": 9.63599361810427e-05, + "expected_calibration_error_10bin": 9.63599361810427e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + { + "valid": 2705, + "positives": 8, + "negatives": 2697, + "auroc": 0.7829532814238043, + "auprc": 0.027841449387260915, + "brier": 0.0029377171409471444, + "calibration": { + "observed_rate": 0.0029574861367837337, + "mean_prediction": 0.0030394508797986475, + "calibration_in_the_large": 8.196474301491383e-05, + "expected_calibration_error_10bin": 0.00023960599539145288, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + { + "valid": 2705, + "positives": 8, + "negatives": 2697, + "auroc": 0.7794308490915832, + "auprc": 0.02704421379207761, + "brier": 0.0029556802099622165, + "calibration": { + "observed_rate": 0.0029574861367837337, + "mean_prediction": 0.0036338229021136434, + "calibration_in_the_large": 0.0006763367653299097, + "expected_calibration_error_10bin": 0.0006763367653299093, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + { + "valid": 2705, + "positives": 9, + "negatives": 2696, + "auroc": 0.8035361028684471, + "auprc": 0.0474874679574553, + "brier": 0.0032663891159710264, + "calibration": { + "observed_rate": 0.0033271719038817007, + "mean_prediction": 0.003868986201198246, + "calibration_in_the_large": 0.0005418142973165454, + "expected_calibration_error_10bin": 0.0005418142973165452, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + { + "valid": 2705, + "positives": 11, + "negatives": 2694, + "auroc": 0.8339407437402983, + "auprc": 0.05498921819505516, + "brier": 0.003971407463864611, + "calibration": { + "observed_rate": 0.004066543438077634, + "mean_prediction": 0.004259567634020869, + "calibration_in_the_large": 0.00019302419594323557, + "expected_calibration_error_10bin": 0.000610021316624591, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + { + "valid": 2705, + "positives": 13, + "negatives": 2692, + "auroc": 0.8059492513430107, + "auprc": 0.04826336190658909, + "brier": 0.004714366469686095, + "calibration": { + "observed_rate": 0.004805914972273568, + "mean_prediction": 0.004718625085295373, + "calibration_in_the_large": -8.728988697819483e-05, + "expected_calibration_error_10bin": 0.0003839442092092975, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + { + "valid": 2705, + "positives": 13, + "negatives": 2692, + "auroc": 0.8065493199222769, + "auprc": 0.048527560716942614, + "brier": 0.004717184923577016, + "calibration": { + "observed_rate": 0.004805914972273568, + "mean_prediction": 0.004908425946939272, + "calibration_in_the_large": 0.00010251097466570415, + "expected_calibration_error_10bin": 0.0003021016544526307, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + { + "valid": 2705, + "positives": 13, + "negatives": 2692, + "auroc": 0.8062064235912676, + "auprc": 0.04792009821106084, + "brier": 0.004731739093828291, + "calibration": { + "observed_rate": 0.004805914972273568, + "mean_prediction": 0.005454263320321026, + "calibration_in_the_large": 0.000648348348047458, + "expected_calibration_error_10bin": 0.0006483483480474586, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + { + "valid": 2705, + "positives": 16, + "negatives": 2689, + "auroc": 0.7487448865749349, + "auprc": 0.04033985241865585, + "brier": 0.005856503343755883, + "calibration": { + "observed_rate": 0.005914972273567467, + "mean_prediction": 0.005891037132870239, + "calibration_in_the_large": -2.3935140697228276e-05, + "expected_calibration_error_10bin": 0.001242045667473146, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + { + "valid": 2705, + "positives": 17, + "negatives": 2688, + "auroc": 0.7565213585434174, + "auprc": 0.03997672070596418, + "brier": 0.006228046983525486, + "calibration": { + "observed_rate": 0.006284658040665434, + "mean_prediction": 0.006161918198023712, + "calibration_in_the_large": -0.0001227398426417222, + "expected_calibration_error_10bin": 0.00148504788717227, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + { + "valid": 2705, + "positives": 17, + "negatives": 2688, + "auroc": 0.7565432422969187, + "auprc": 0.03997113552172828, + "brier": 0.006230469905409763, + "calibration": { + "observed_rate": 0.006284658040665434, + "mean_prediction": 0.006221997390815964, + "calibration_in_the_large": -6.266064984947022e-05, + "expected_calibration_error_10bin": 0.001520874903532437, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + } + ], + "reason": null + }, + "M84": { + "time_averaged_auroc": 0.7610311202680925, + "time_averaged_auprc": 0.02302619580703549, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2818, + "positives": 0, + "negatives": 2818, + "auroc": null, + "auprc": null, + "brier": 6.67357336714957e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004557385963712293, + "calibration_in_the_large": 0.0004557385963712293, + "expected_calibration_error_10bin": 0.0004557385963712293, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 1, + "negatives": 2817, + "auroc": 0.9737309194178204, + "auprc": 0.013333333333333334, + "brier": 0.00035608631849184133, + "calibration": { + "observed_rate": 0.00035486160397445, + "mean_prediction": 0.0009143512469065902, + "calibration_in_the_large": 0.0005594896429321403, + "expected_calibration_error_10bin": 0.0005594896429321403, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 3, + "negatives": 2815, + "auroc": 0.6909413854351687, + "auprc": 0.0240840505902902, + "brier": 0.0010599378226253757, + "calibration": { + "observed_rate": 0.0010645848119233499, + "mean_prediction": 0.0013960078711778147, + "calibration_in_the_large": 0.0003314230592544648, + "expected_calibration_error_10bin": 0.0003314230592544648, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 3, + "negatives": 2815, + "auroc": 0.6931912374185909, + "auprc": 0.0254581804013042, + "brier": 0.0010613810317071906, + "calibration": { + "observed_rate": 0.0010645848119233499, + "mean_prediction": 0.001612756185870247, + "calibration_in_the_large": 0.0005481713739468972, + "expected_calibration_error_10bin": 0.0005481713739468972, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 3, + "negatives": 2815, + "auroc": 0.6955595026642984, + "auprc": 0.02448697348531961, + "brier": 0.0010630718502938796, + "calibration": { + "observed_rate": 0.0010645848119233499, + "mean_prediction": 0.001769370370170946, + "calibration_in_the_large": 0.000704785558247596, + "expected_calibration_error_10bin": 0.000704785558247596, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.7411304656949875, + "auprc": 0.024325015908742306, + "brier": 0.0017670715936657542, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0021982484058469458, + "calibration_in_the_large": 0.00042394038597469604, + "expected_calibration_error_10bin": 0.00042394038597469576, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.7416281549946676, + "auprc": 0.02379354699255837, + "brier": 0.0017739218908973408, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0024851092548952695, + "calibration_in_the_large": 0.0007108012350230198, + "expected_calibration_error_10bin": 0.0007108012350230197, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.7420547458229648, + "auprc": 0.024959542819912754, + "brier": 0.0017781303716541436, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0026263735602002577, + "calibration_in_the_large": 0.000852065540328008, + "expected_calibration_error_10bin": 0.000852065540328008, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.772226173541963, + "auprc": 0.023429602990632705, + "brier": 0.0021312836121225335, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0027324600881120094, + "calibration_in_the_large": 0.0006032904642653096, + "expected_calibration_error_10bin": 0.0006032904642653098, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.7708629682313893, + "auprc": 0.0232232738090066, + "brier": 0.002146350340152745, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0031566645069225924, + "calibration_in_the_large": 0.0010274948830758927, + "expected_calibration_error_10bin": 0.0010274948830758922, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.7705666192508298, + "auprc": 0.023081835781954177, + "brier": 0.0021511937316090668, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0032537704478792263, + "calibration_in_the_large": 0.0011246008240325266, + "expected_calibration_error_10bin": 0.0011246008240325266, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.7700924608819346, + "auprc": 0.022797097784263642, + "brier": 0.0021531911198361415, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.003372616691977041, + "calibration_in_the_large": 0.0012434470681303412, + "expected_calibration_error_10bin": 0.0012434470681303412, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.770388809862494, + "auprc": 0.023341895787107946, + "brier": 0.00215428595875974, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.003408825342193403, + "calibration_in_the_large": 0.001279655718346703, + "expected_calibration_error_10bin": 0.001279655718346703, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + } + ], + "reason": null + }, + "M85": { + "time_averaged_auroc": 0.7312372897006656, + "time_averaged_auprc": 0.005650485026335745, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2768, + "positives": 2, + "negatives": 2766, + "auroc": 0.7575921908893709, + "auprc": 0.002788968617619089, + "brier": 0.0007222441015951578, + "calibration": { + "observed_rate": 0.000722543352601156, + "mean_prediction": 0.0006107040558011991, + "calibration_in_the_large": -0.00011183929679995698, + "expected_calibration_error_10bin": 0.00011183929679995698, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 2, + "negatives": 2766, + "auroc": 0.7640997830802603, + "auprc": 0.0028093386044757266, + "brier": 0.0007228389560549529, + "calibration": { + "observed_rate": 0.000722543352601156, + "mean_prediction": 0.0009021812705705508, + "calibration_in_the_large": 0.0001796379179693948, + "expected_calibration_error_10bin": 0.0001796379179693948, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 3, + "negatives": 2765, + "auroc": 0.772875226039783, + "auprc": 0.003405569717288705, + "brier": 0.0010862637969444534, + "calibration": { + "observed_rate": 0.001083815028901734, + "mean_prediction": 0.0015414421424683143, + "calibration_in_the_large": 0.00045762711356658035, + "expected_calibration_error_10bin": 0.00045762711356658035, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.7249961194184302, + "auprc": 0.006337131155358192, + "brier": 0.0025255512420061695, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.0019023901229002938, + "calibration_in_the_large": -0.0006265116112037525, + "expected_calibration_error_10bin": 0.0006265116112037525, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.7241165209292699, + "auprc": 0.006481758423708646, + "brier": 0.0025276558542333496, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.0022048826971371393, + "calibration_in_the_large": -0.000324019036966907, + "expected_calibration_error_10bin": 0.000324019036966907, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.7261344233455788, + "auprc": 0.006536404651771418, + "brier": 0.002529437696521024, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.0025341782013938584, + "calibration_in_the_large": 5.276467289812119e-06, + "expected_calibration_error_10bin": 5.276467289812119e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.7224090650385471, + "auprc": 0.0065093691530870535, + "brier": 0.002532814930987721, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.002794829646000504, + "calibration_in_the_large": 0.00026592791189645765, + "expected_calibration_error_10bin": 0.00026592791189645765, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.7192528586950898, + "auprc": 0.00647689615976506, + "brier": 0.002537031803974035, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.003140454917321364, + "calibration_in_the_large": 0.0006115531832173175, + "expected_calibration_error_10bin": 0.0006115531832173175, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.7186837067315155, + "auprc": 0.006481118370313743, + "brier": 0.002538321621038747, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.0032364887147195986, + "calibration_in_the_large": 0.0007075869806155524, + "expected_calibration_error_10bin": 0.0007075869806155524, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.7183732602059295, + "auprc": 0.0064096189980558755, + "brier": 0.0025441107461209953, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.003514898251807734, + "calibration_in_the_large": 0.000985996517703688, + "expected_calibration_error_10bin": 0.000985996517703688, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.7189424121695038, + "auprc": 0.006436268711544386, + "brier": 0.0025469645950195216, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.0037370747822039756, + "calibration_in_the_large": 0.0012081730480999293, + "expected_calibration_error_10bin": 0.0012081730480999293, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.7190976354322968, + "auprc": 0.006385322201635281, + "brier": 0.0025497824315806293, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.003858960502802381, + "calibration_in_the_large": 0.0013300587686983349, + "expected_calibration_error_10bin": 0.0013300587686983349, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.719511564133078, + "auprc": 0.006398540577741503, + "brier": 0.0025505990339772756, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.003913545543545786, + "calibration_in_the_large": 0.0013846438094417394, + "expected_calibration_error_10bin": 0.0013846438094417394, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + } + ], + "reason": null + }, + "M86": { + "time_averaged_auroc": 0.8210734538690407, + "time_averaged_auprc": 0.04991650006513252, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2803, + "positives": 3, + "negatives": 2800, + "auroc": 0.9597619047619048, + "auprc": 0.03262138188608777, + "brier": 0.0010635680899799664, + "calibration": { + "observed_rate": 0.0010702818408847663, + "mean_prediction": 0.00047200541216880137, + "calibration_in_the_large": -0.0005982764287159649, + "expected_calibration_error_10bin": 0.0005982764287159649, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + { + "valid": 2803, + "positives": 4, + "negatives": 2799, + "auroc": 0.9439085387638443, + "auprc": 0.03813222376329172, + "brier": 0.0014157175104582331, + "calibration": { + "observed_rate": 0.0014270424545130217, + "mean_prediction": 0.0014073790492592814, + "calibration_in_the_large": -1.9663405253740347e-05, + "expected_calibration_error_10bin": 1.9663405253740347e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + { + "valid": 2803, + "positives": 8, + "negatives": 2795, + "auroc": 0.8227638640429338, + "auprc": 0.03627466265073721, + "brier": 0.0028280429315525784, + "calibration": { + "observed_rate": 0.0028540849090260435, + "mean_prediction": 0.0016918757736790154, + "calibration_in_the_large": -0.001162209135347028, + "expected_calibration_error_10bin": 0.001162209135347028, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + { + "valid": 2803, + "positives": 9, + "negatives": 2794, + "auroc": 0.7835838701980434, + "auprc": 0.03361890976590344, + "brier": 0.003185492215501639, + "calibration": { + "observed_rate": 0.003210845522654299, + "mean_prediction": 0.002054460943353243, + "calibration_in_the_large": -0.0011563845793010562, + "expected_calibration_error_10bin": 0.001230840222103321, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + { + "valid": 2803, + "positives": 11, + "negatives": 2792, + "auroc": 0.8181166970565251, + "auprc": 0.06030678055885777, + "brier": 0.003830669276190159, + "calibration": { + "observed_rate": 0.00392436674991081, + "mean_prediction": 0.002527253513232605, + "calibration_in_the_large": -0.001397113236678205, + "expected_calibration_error_10bin": 0.001634816597255495, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + { + "valid": 2803, + "positives": 13, + "negatives": 2790, + "auroc": 0.783677970774745, + "auprc": 0.05409444358244824, + "brier": 0.00453712698083698, + "calibration": { + "observed_rate": 0.00463788797716732, + "mean_prediction": 0.0029392459686231943, + "calibration_in_the_large": -0.0016986420085441261, + "expected_calibration_error_10bin": 0.002226714079670601, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + { + "valid": 2803, + "positives": 14, + "negatives": 2789, + "auroc": 0.7891205245095528, + "auprc": 0.05140183237955642, + "brier": 0.004891697633229847, + "calibration": { + "observed_rate": 0.0049946485907955765, + "mean_prediction": 0.0033390657207585436, + "calibration_in_the_large": -0.001655582870037033, + "expected_calibration_error_10bin": 0.0019604187687184394, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + { + "valid": 2803, + "positives": 14, + "negatives": 2789, + "auroc": 0.7885570865133432, + "auprc": 0.050967366769070835, + "brier": 0.004897914849097708, + "calibration": { + "observed_rate": 0.0049946485907955765, + "mean_prediction": 0.0036374568971808026, + "calibration_in_the_large": -0.001357191693614774, + "expected_calibration_error_10bin": 0.0020630852594040903, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + { + "valid": 2803, + "positives": 14, + "negatives": 2789, + "auroc": 0.7878399836090765, + "auprc": 0.050436544348598046, + "brier": 0.004900369007611243, + "calibration": { + "observed_rate": 0.0049946485907955765, + "mean_prediction": 0.003827370052302505, + "calibration_in_the_large": -0.0011672785384930716, + "expected_calibration_error_10bin": 0.001920827389346345, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + { + "valid": 2803, + "positives": 15, + "negatives": 2788, + "auroc": 0.7899091343854615, + "auprc": 0.04806766452496141, + "brier": 0.005264210826356061, + "calibration": { + "observed_rate": 0.005351409204423832, + "mean_prediction": 0.0041863581092056465, + "calibration_in_the_large": -0.0011650510952181852, + "expected_calibration_error_10bin": 0.002118616340227998, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + { + "valid": 2803, + "positives": 15, + "negatives": 2788, + "auroc": 0.7901243424198948, + "auprc": 0.048951365016810085, + "brier": 0.005272935101562325, + "calibration": { + "observed_rate": 0.005351409204423832, + "mean_prediction": 0.004493434616467321, + "calibration_in_the_large": -0.0008579745879565108, + "expected_calibration_error_10bin": 0.002075990607769852, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + { + "valid": 2803, + "positives": 16, + "negatives": 2787, + "auroc": 0.8025206315034087, + "auprc": 0.06430294668655025, + "brier": 0.005540497827460906, + "calibration": { + "observed_rate": 0.005708169818052087, + "mean_prediction": 0.004669051742609339, + "calibration_in_the_large": -0.0010391180754427479, + "expected_calibration_error_10bin": 0.0016755865517698607, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + { + "valid": 2803, + "positives": 17, + "negatives": 2786, + "auroc": 0.8140703517587939, + "auprc": 0.07973837891384948, + "brier": 0.005817711300418144, + "calibration": { + "observed_rate": 0.006064930431680342, + "mean_prediction": 0.004677488501220186, + "calibration_in_the_large": -0.0013874419304601565, + "expected_calibration_error_10bin": 0.0016990017561811328, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + } + ], + "reason": null + }, + "M94": { + "time_averaged_auroc": 0.7784117072050114, + "time_averaged_auprc": 0.002732319110011698, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2819, + "positives": 1, + "negatives": 2818, + "auroc": 0.8364088005677786, + "auprc": 0.0021645021645021645, + "brier": 0.00035467340276031746, + "calibration": { + "observed_rate": 0.000354735721887194, + "mean_prediction": 7.18088283057072e-05, + "calibration_in_the_large": -0.0002829268935814868, + "expected_calibration_error_10bin": 0.0002829268935814868, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 1, + "negatives": 2818, + "auroc": 0.8474095102909865, + "auprc": 0.002320185614849188, + "brier": 0.00035464283486693466, + "calibration": { + "observed_rate": 0.000354735721887194, + "mean_prediction": 0.00011303410282673626, + "calibration_in_the_large": -0.00024170161906045777, + "expected_calibration_error_10bin": 0.00024170161906045777, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 1, + "negatives": 2818, + "auroc": 0.865152590489709, + "auprc": 0.0026246719160104987, + "brier": 0.00035462831849553085, + "calibration": { + "observed_rate": 0.000354735721887194, + "mean_prediction": 0.000149714504016904, + "calibration_in_the_large": -0.00020502121787029003, + "expected_calibration_error_10bin": 0.00020502121787029003, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 1, + "negatives": 2818, + "auroc": 0.8534421575585521, + "auprc": 0.0024154589371980675, + "brier": 0.0003546852666385869, + "calibration": { + "observed_rate": 0.000354735721887194, + "mean_prediction": 0.0002062690820451065, + "calibration_in_the_large": -0.00014846663984208753, + "expected_calibration_error_10bin": 0.00014846663984208753, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 2, + "negatives": 2817, + "auroc": 0.7204472843450479, + "auprc": 0.0020668359978086555, + "brier": 0.0007093668628729898, + "calibration": { + "observed_rate": 0.000709471443774388, + "mean_prediction": 0.00022697764812624587, + "calibration_in_the_large": -0.00048249379564814217, + "expected_calibration_error_10bin": 0.00048249379564814217, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 2, + "negatives": 2817, + "auroc": 0.7122825701100461, + "auprc": 0.002027541181636298, + "brier": 0.0007093748715980428, + "calibration": { + "observed_rate": 0.000709471443774388, + "mean_prediction": 0.000264600770331958, + "calibration_in_the_large": -0.00044487067344243006, + "expected_calibration_error_10bin": 0.00044487067344243006, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7505918560606061, + "auprc": 0.003019398264928181, + "brier": 0.0010638034579157562, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0003301835473108816, + "calibration_in_the_large": -0.0007340236183507004, + "expected_calibration_error_10bin": 0.0007340236183507004, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7636126893939394, + "auprc": 0.003357757144261845, + "brier": 0.0010637336633478357, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.00035809125479429335, + "calibration_in_the_large": -0.0007061159108672887, + "expected_calibration_error_10bin": 0.0007061159108672887, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7608901515151515, + "auprc": 0.0032705876492990504, + "brier": 0.0010637836492385852, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0003822016268891048, + "calibration_in_the_large": -0.0006820055387724772, + "expected_calibration_error_10bin": 0.0006820055387724772, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7574573863636364, + "auprc": 0.0031550844240025334, + "brier": 0.0010638637927322466, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.00041799894649836964, + "calibration_in_the_large": -0.0006462082191632124, + "expected_calibration_error_10bin": 0.0006462082191632124, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7503551136363636, + "auprc": 0.0030316756542565805, + "brier": 0.0010639806029513828, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.00046316613417979037, + "calibration_in_the_large": -0.0006010410314817916, + "expected_calibration_error_10bin": 0.0006010410314817916, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7507102272727273, + "auprc": 0.003031250665880293, + "brier": 0.00106402468890516, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.00047865824162740127, + "calibration_in_the_large": -0.0005855489240341807, + "expected_calibration_error_10bin": 0.0005855489240341807, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7505918560606061, + "auprc": 0.003035198815518718, + "brier": 0.0010640340447987603, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.00048553010886013577, + "calibration_in_the_large": -0.0005786770568014462, + "expected_calibration_error_10bin": 0.0005786770568014462, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + } + ], + "reason": null + }, + "M96": { + "time_averaged_auroc": 0.8687743604276115, + "time_averaged_auprc": 0.005109970219795799, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2804, + "positives": 0, + "negatives": 2804, + "auroc": null, + "auprc": null, + "brier": 6.220703746054536e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0014244659842369792, + "calibration_in_the_large": 0.0014244659842369792, + "expected_calibration_error_10bin": 0.0014244659842369792, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 1, + "negatives": 2803, + "auroc": 0.8983232251159472, + "auprc": 0.0034965034965034965, + "brier": 0.0003655242413088071, + "calibration": { + "observed_rate": 0.0003566333808844508, + "mean_prediction": 0.0019997825682071153, + "calibration_in_the_large": 0.0016431491873226645, + "expected_calibration_error_10bin": 0.0016431491873226645, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 1, + "negatives": 2803, + "auroc": 0.8933285765251516, + "auprc": 0.0033333333333333335, + "brier": 0.0003668025095667644, + "calibration": { + "observed_rate": 0.0003566333808844508, + "mean_prediction": 0.002137096225280698, + "calibration_in_the_large": 0.0017804628443962472, + "expected_calibration_error_10bin": 0.0017804628443962472, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 1, + "negatives": 2803, + "auroc": 0.8904744916161256, + "auprc": 0.003246753246753247, + "brier": 0.0003703641842339886, + "calibration": { + "observed_rate": 0.0003566333808844508, + "mean_prediction": 0.002476820121473183, + "calibration_in_the_large": 0.0021201867405887323, + "expected_calibration_error_10bin": 0.0021201867405887323, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 2, + "negatives": 2802, + "auroc": 0.8276231263383298, + "auprc": 0.0031110293975344003, + "brier": 0.00072745149895155, + "calibration": { + "observed_rate": 0.0007132667617689016, + "mean_prediction": 0.002681832621981529, + "calibration_in_the_large": 0.0019685658602126275, + "expected_calibration_error_10bin": 0.0019685658602126275, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 2, + "negatives": 2802, + "auroc": 0.8267309064953604, + "auprc": 0.003089025966900908, + "brier": 0.0007279458612816805, + "calibration": { + "observed_rate": 0.0007132667617689016, + "mean_prediction": 0.0027283465698277613, + "calibration_in_the_large": 0.0020150798080588598, + "expected_calibration_error_10bin": 0.0020150798080588598, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 2, + "negatives": 2802, + "auroc": 0.8313704496788008, + "auprc": 0.0031294007197621657, + "brier": 0.0007293787152951534, + "calibration": { + "observed_rate": 0.0007132667617689016, + "mean_prediction": 0.0028586021128878913, + "calibration_in_the_large": 0.0021453353511189897, + "expected_calibration_error_10bin": 0.0021453353511189897, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 3, + "negatives": 2801, + "auroc": 0.8732595501606569, + "auprc": 0.0062684788545713105, + "brier": 0.0010801478745724412, + "calibration": { + "observed_rate": 0.0010699001426533524, + "mean_prediction": 0.002987466586230438, + "calibration_in_the_large": 0.0019175664435770858, + "expected_calibration_error_10bin": 0.0019175664435770858, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 3, + "negatives": 2801, + "auroc": 0.8737355706295371, + "auprc": 0.006234400062195162, + "brier": 0.0010812700701141157, + "calibration": { + "observed_rate": 0.0010699001426533524, + "mean_prediction": 0.0031024157237458327, + "calibration_in_the_large": 0.00203251558109248, + "expected_calibration_error_10bin": 0.00203251558109248, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 4, + "negatives": 2800, + "auroc": 0.8795535714285714, + "auprc": 0.00743166622668732, + "brier": 0.0014350290721747618, + "calibration": { + "observed_rate": 0.0014265335235378032, + "mean_prediction": 0.003284106122772575, + "calibration_in_the_large": 0.0018575725992347717, + "expected_calibration_error_10bin": 0.0018575725992347717, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 4, + "negatives": 2800, + "auroc": 0.8804464285714285, + "auprc": 0.007499132903471997, + "brier": 0.0014353790192326442, + "calibration": { + "observed_rate": 0.0014265335235378032, + "mean_prediction": 0.0033345897682737686, + "calibration_in_the_large": 0.0019080562447359654, + "expected_calibration_error_10bin": 0.0019080562447359654, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 4, + "negatives": 2800, + "auroc": 0.8751785714285715, + "auprc": 0.007237057636459446, + "brier": 0.0014413321808212861, + "calibration": { + "observed_rate": 0.0014265335235378032, + "mean_prediction": 0.0037242373686715026, + "calibration_in_the_large": 0.0022977038451336995, + "expected_calibration_error_10bin": 0.0022977038451336995, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + { + "valid": 2804, + "positives": 4, + "negatives": 2800, + "auroc": 0.8752678571428572, + "auprc": 0.007242860793376809, + "brier": 0.0014420845454015127, + "calibration": { + "observed_rate": 0.0014265335235378032, + "mean_prediction": 0.003778223608670784, + "calibration_in_the_large": 0.002351690085132981, + "expected_calibration_error_10bin": 0.002351690085132981, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + } + ], + "reason": null + }, + "N12": { + "time_averaged_auroc": 0.6479009775333225, + "time_averaged_auprc": 0.00495419234073736, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2831, + "positives": 3, + "negatives": 2828, + "auroc": 0.6450966525223951, + "auprc": 0.0028625187581426542, + "brier": 0.0010594416472099859, + "calibration": { + "observed_rate": 0.0010596962204168139, + "mean_prediction": 0.0002631377828809591, + "calibration_in_the_large": -0.0007965584375358547, + "expected_calibration_error_10bin": 0.0007965584375358547, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.6374248319773611, + "auprc": 0.0025801707334136537, + "brier": 0.0014148586968604857, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0006635899820742467, + "calibration_in_the_large": -0.0007493383118148384, + "expected_calibration_error_10bin": 0.0007493383118148384, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.5777325787053413, + "auprc": 0.0025245864468641487, + "brier": 0.0014151542819529597, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0008335265603988325, + "calibration_in_the_large": -0.0005794017334902526, + "expected_calibration_error_10bin": 0.0005794017334902526, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.5948885744605589, + "auprc": 0.0024069020843287456, + "brier": 0.001418198280766013, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0011294272278743283, + "calibration_in_the_large": -0.00028350106601475683, + "expected_calibration_error_10bin": 0.00028350106601475683, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.5925008843296781, + "auprc": 0.002334982068087375, + "brier": 0.0014212013303869153, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.001342790899893368, + "calibration_in_the_large": -7.013739399571719e-05, + "expected_calibration_error_10bin": 7.013739399571719e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.664897381457891, + "auprc": 0.005780090793922668, + "brier": 0.0017690204299085678, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0014668545770758325, + "calibration_in_the_large": -0.0002993057902855238, + "expected_calibration_error_10bin": 0.0002993057902855238, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.6695669769324161, + "auprc": 0.006113077693427961, + "brier": 0.0024748311718258463, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.0016197120779478417, + "calibration_in_the_large": -0.0008529124363580575, + "expected_calibration_error_10bin": 0.0008529124363580575, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.6701740186159449, + "auprc": 0.0064582214294965365, + "brier": 0.0024762095816399086, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.0018516473862706998, + "calibration_in_the_large": -0.0006209771280351994, + "expected_calibration_error_10bin": 0.0006209771280351994, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.6684034803723189, + "auprc": 0.006496504883791888, + "brier": 0.0024781256363438724, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.002004454814881383, + "calibration_in_the_large": -0.0004681696994245162, + "expected_calibration_error_10bin": 0.0004681696994245162, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.6694152165115338, + "auprc": 0.0063972906706349555, + "brier": 0.00248021509397475, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.0021476214405074423, + "calibration_in_the_large": -0.00032500307379845685, + "expected_calibration_error_10bin": 0.00032500307379845685, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.6681505463375151, + "auprc": 0.0063929829060205634, + "brier": 0.0024806459566818324, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.002186805134867081, + "calibration_in_the_large": -0.00028581937943881813, + "expected_calibration_error_10bin": 0.00028581937943881813, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 8, + "negatives": 2823, + "auroc": 0.6824300389656394, + "auprc": 0.007030187730378749, + "brier": 0.0028337256370824684, + "calibration": { + "observed_rate": 0.00282585658777817, + "mean_prediction": 0.00243083830511194, + "calibration_in_the_large": -0.0003950182826662303, + "expected_calibration_error_10bin": 0.0003950182826662303, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 8, + "negatives": 2823, + "auroc": 0.682031526744598, + "auprc": 0.007026984231075779, + "brier": 0.0028338296143363122, + "calibration": { + "observed_rate": 0.00282585658777817, + "mean_prediction": 0.002439515355738439, + "calibration_in_the_large": -0.0003863412320397313, + "expected_calibration_error_10bin": 0.0003863412320397313, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + } + ], + "reason": null + }, + "N13": { + "time_averaged_auroc": 0.6840123866710512, + "time_averaged_auprc": 0.02351881703437754, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2756, + "positives": 2, + "negatives": 2754, + "auroc": 0.6218228031953522, + "auprc": 0.0015688984530625447, + "brier": 0.0007274715844096815, + "calibration": { + "observed_rate": 0.000725689404934688, + "mean_prediction": 0.0009119194996110283, + "calibration_in_the_large": 0.00018623009467634035, + "expected_calibration_error_10bin": 0.00018623009467634035, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 2, + "negatives": 2754, + "auroc": 0.6568627450980392, + "auprc": 0.0018142032404246074, + "brier": 0.0007352316363156649, + "calibration": { + "observed_rate": 0.000725689404934688, + "mean_prediction": 0.001787242200556653, + "calibration_in_the_large": 0.001061552795621965, + "expected_calibration_error_10bin": 0.001061552795621965, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 4, + "negatives": 2752, + "auroc": 0.7791606104651163, + "auprc": 0.005997253944229185, + "brier": 0.001458230939238228, + "calibration": { + "observed_rate": 0.001451378809869376, + "mean_prediction": 0.0024909309741935498, + "calibration_in_the_large": 0.0010395521643241739, + "expected_calibration_error_10bin": 0.0010395521643241739, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 5, + "negatives": 2751, + "auroc": 0.648854961832061, + "auprc": 0.0047953501773396415, + "brier": 0.0018288276981090722, + "calibration": { + "observed_rate": 0.00181422351233672, + "mean_prediction": 0.0030390051636978014, + "calibration_in_the_large": 0.0012247816513610815, + "expected_calibration_error_10bin": 0.0012247816513610815, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 7, + "negatives": 2749, + "auroc": 0.5855116146131061, + "auprc": 0.004638117567970723, + "brier": 0.0025583251678348703, + "calibration": { + "observed_rate": 0.0025399129172714078, + "mean_prediction": 0.003362765904531484, + "calibration_in_the_large": 0.0008228529872600764, + "expected_calibration_error_10bin": 0.0008228529872600764, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 8, + "negatives": 2748, + "auroc": 0.636098981077147, + "auprc": 0.012480767982611036, + "brier": 0.002906735475660336, + "calibration": { + "observed_rate": 0.002902757619738752, + "mean_prediction": 0.004001179271471946, + "calibration_in_the_large": 0.0010984216517331944, + "expected_calibration_error_10bin": 0.0010984216517331944, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 11, + "negatives": 2745, + "auroc": 0.6451730418943533, + "auprc": 0.012390827381300023, + "brier": 0.003986379906938797, + "calibration": { + "observed_rate": 0.0039912917271407835, + "mean_prediction": 0.004326352771341274, + "calibration_in_the_large": 0.0003350610442004907, + "expected_calibration_error_10bin": 0.0003350610442004907, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 15, + "negatives": 2741, + "auroc": 0.6783169159674085, + "auprc": 0.03790687838198017, + "brier": 0.00536940295354665, + "calibration": { + "observed_rate": 0.00544267053701016, + "mean_prediction": 0.004630450986088179, + "calibration_in_the_large": -0.0008122195509219802, + "expected_calibration_error_10bin": 0.0008122195509219802, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 19, + "negatives": 2737, + "auroc": 0.7245928119531565, + "auprc": 0.037980746985488624, + "brier": 0.006777146418909092, + "calibration": { + "observed_rate": 0.006894049346879536, + "mean_prediction": 0.0049492452505555925, + "calibration_in_the_large": -0.0019448040963239432, + "expected_calibration_error_10bin": 0.0019448040963239432, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 20, + "negatives": 2736, + "auroc": 0.7189875730994152, + "auprc": 0.03888290112374652, + "brier": 0.007136884015718948, + "calibration": { + "observed_rate": 0.00725689404934688, + "mean_prediction": 0.005345505869474109, + "calibration_in_the_large": -0.0019113881798727703, + "expected_calibration_error_10bin": 0.00206369107227292, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 21, + "negatives": 2735, + "auroc": 0.7317489335770871, + "auprc": 0.04872947904577459, + "brier": 0.007456263785655346, + "calibration": { + "observed_rate": 0.007619738751814224, + "mean_prediction": 0.00579307761616474, + "calibration_in_the_large": -0.001826661135649484, + "expected_calibration_error_10bin": 0.0020021378100238555, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 21, + "negatives": 2735, + "auroc": 0.7325498389483764, + "auprc": 0.0492829077367069, + "brier": 0.007453050874367208, + "calibration": { + "observed_rate": 0.007619738751814224, + "mean_prediction": 0.006083744922979783, + "calibration_in_the_large": -0.0015359938288344406, + "expected_calibration_error_10bin": 0.001723184870493988, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + { + "valid": 2756, + "positives": 21, + "negatives": 2735, + "auroc": 0.732480195003047, + "auprc": 0.049276289426273455, + "brier": 0.007453005961940135, + "calibration": { + "observed_rate": 0.007619738751814224, + "mean_prediction": 0.006094653535417078, + "calibration_in_the_large": -0.0015250852163971457, + "expected_calibration_error_10bin": 0.001712577811925803, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + } + ], + "reason": null + }, + "N14": { + "time_averaged_auroc": 0.8553856367938006, + "time_averaged_auprc": 0.016195584275025158, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2826, + "positives": 3, + "negatives": 2823, + "auroc": 0.7360963513992207, + "auprc": 0.003429612282071299, + "brier": 0.0010610682506917307, + "calibration": { + "observed_rate": 0.0010615711252653928, + "mean_prediction": 0.0003200336384283423, + "calibration_in_the_large": -0.0007415374868370505, + "expected_calibration_error_10bin": 0.0007415374868370505, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 3, + "negatives": 2823, + "auroc": 0.7948990435706695, + "auprc": 0.003384613274215251, + "brier": 0.0010609995496630468, + "calibration": { + "observed_rate": 0.0010615711252653928, + "mean_prediction": 0.0005891584736195796, + "calibration_in_the_large": -0.0004724126516458131, + "expected_calibration_error_10bin": 0.0004724126516458131, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8460829493087557, + "auprc": 0.009607862622641974, + "brier": 0.0017646989607192673, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0007372204970748293, + "calibration_in_the_large": -0.001032064711700825, + "expected_calibration_error_10bin": 0.001032064711700825, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 6, + "negatives": 2820, + "auroc": 0.8611111111111112, + "auprc": 0.01367403982573599, + "brier": 0.0021157442415217103, + "calibration": { + "observed_rate": 0.0021231422505307855, + "mean_prediction": 0.000823659935792819, + "calibration_in_the_large": -0.0012994823147379664, + "expected_calibration_error_10bin": 0.0012994823147379664, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 7, + "negatives": 2819, + "auroc": 0.875791820807784, + "auprc": 0.0177181986129834, + "brier": 0.0024645557524285203, + "calibration": { + "observed_rate": 0.0024769992922859165, + "mean_prediction": 0.0010145932440543933, + "calibration_in_the_large": -0.0014624060482315232, + "expected_calibration_error_10bin": 0.0014624060482315232, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 7, + "negatives": 2819, + "auroc": 0.8760958799979729, + "auprc": 0.01810513411991474, + "brier": 0.0024637178149787544, + "calibration": { + "observed_rate": 0.0024769992922859165, + "mean_prediction": 0.0011700523088407633, + "calibration_in_the_large": -0.0013069469834451532, + "expected_calibration_error_10bin": 0.0013069469834451532, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 7, + "negatives": 2819, + "auroc": 0.874018142198348, + "auprc": 0.018023562455436796, + "brier": 0.002463537751002852, + "calibration": { + "observed_rate": 0.0024769992922859165, + "mean_prediction": 0.001275928724620992, + "calibration_in_the_large": -0.0012010705676649244, + "expected_calibration_error_10bin": 0.0012010705676649244, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 7, + "negatives": 2819, + "auroc": 0.876703998378351, + "auprc": 0.019500498155803535, + "brier": 0.002461951244578017, + "calibration": { + "observed_rate": 0.0024769992922859165, + "mean_prediction": 0.0015275205611587853, + "calibration_in_the_large": -0.0009494787311271312, + "expected_calibration_error_10bin": 0.0009494787311271312, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 8, + "negatives": 2818, + "auroc": 0.877306600425834, + "auprc": 0.020610592268456258, + "brier": 0.0028133571206270047, + "calibration": { + "observed_rate": 0.0028308563340410475, + "mean_prediction": 0.0016310255772956767, + "calibration_in_the_large": -0.0011998307567453708, + "expected_calibration_error_10bin": 0.0011998307567453708, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 8, + "negatives": 2818, + "auroc": 0.8760645848119234, + "auprc": 0.022025687179219402, + "brier": 0.0028128255873428585, + "calibration": { + "observed_rate": 0.0028308563340410475, + "mean_prediction": 0.0017823637272023352, + "calibration_in_the_large": -0.0010484926068387124, + "expected_calibration_error_10bin": 0.0010484926068387124, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 8, + "negatives": 2818, + "auroc": 0.876375088715401, + "auprc": 0.021762694579304655, + "brier": 0.0028127935001751848, + "calibration": { + "observed_rate": 0.0028308563340410475, + "mean_prediction": 0.0018526072933133372, + "calibration_in_the_large": -0.0009782490407277103, + "expected_calibration_error_10bin": 0.0009782490407277103, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 8, + "negatives": 2818, + "auroc": 0.8748669268985095, + "auprc": 0.021356737272289962, + "brier": 0.002813908057255706, + "calibration": { + "observed_rate": 0.0028308563340410475, + "mean_prediction": 0.0019816689895396683, + "calibration_in_the_large": -0.0008491873445013792, + "expected_calibration_error_10bin": 0.000922181267899213, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + { + "valid": 2826, + "positives": 8, + "negatives": 2818, + "auroc": 0.8746007806955287, + "auprc": 0.021343362927253775, + "brier": 0.0028141327715432733, + "calibration": { + "observed_rate": 0.0028308563340410475, + "mean_prediction": 0.0020069580504706824, + "calibration_in_the_large": -0.0008238982835703651, + "expected_calibration_error_10bin": 0.000897858910573108, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + } + ], + "reason": null + }, + "N17": { + "time_averaged_auroc": 0.7884932278342052, + "time_averaged_auprc": 0.12786585363191996, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2292, + "positives": 25, + "negatives": 2267, + "auroc": 0.7440317600352889, + "auprc": 0.05030711755818493, + "brier": 0.010721801479610136, + "calibration": { + "observed_rate": 0.010907504363001745, + "mean_prediction": 0.011417155819139222, + "calibration_in_the_large": 0.0005096514561374766, + "expected_calibration_error_10bin": 0.0005096514561374767, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + { + "valid": 2292, + "positives": 41, + "negatives": 2251, + "auroc": 0.7881591921205752, + "auprc": 0.08262652805010731, + "brier": 0.01715752718813378, + "calibration": { + "observed_rate": 0.01788830715532286, + "mean_prediction": 0.01939725881097499, + "calibration_in_the_large": 0.0015089516556521278, + "expected_calibration_error_10bin": 0.002376193294035378, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + { + "valid": 2292, + "positives": 53, + "negatives": 2239, + "auroc": 0.7901101401400558, + "auprc": 0.09289873779928359, + "brier": 0.021994609431371704, + "calibration": { + "observed_rate": 0.0231239092495637, + "mean_prediction": 0.024278130745716362, + "calibration_in_the_large": 0.001154221496152661, + "expected_calibration_error_10bin": 0.0021524922197451416, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + { + "valid": 2292, + "positives": 61, + "negatives": 2231, + "auroc": 0.777553254807445, + "auprc": 0.09747555742294833, + "brier": 0.025322756580258645, + "calibration": { + "observed_rate": 0.026614310645724257, + "mean_prediction": 0.028087085440360135, + "calibration_in_the_large": 0.0014727747946358775, + "expected_calibration_error_10bin": 0.006803308788399101, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + { + "valid": 2292, + "positives": 64, + "negatives": 2228, + "auroc": 0.7852614452423698, + "auprc": 0.0998243798454646, + "brier": 0.026577238263258793, + "calibration": { + "observed_rate": 0.027923211169284468, + "mean_prediction": 0.031173427978050644, + "calibration_in_the_large": 0.0032502168087661758, + "expected_calibration_error_10bin": 0.005992594325842247, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + { + "valid": 2292, + "positives": 69, + "negatives": 2223, + "auroc": 0.7906015503269508, + "auprc": 0.10630342977808087, + "brier": 0.028583218277901046, + "calibration": { + "observed_rate": 0.030104712041884817, + "mean_prediction": 0.03412152111258465, + "calibration_in_the_large": 0.0040168090706998345, + "expected_calibration_error_10bin": 0.005623851209268607, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + { + "valid": 2292, + "positives": 77, + "negatives": 2215, + "auroc": 0.7937791328310516, + "auprc": 0.1352482134178894, + "brier": 0.03121057686318479, + "calibration": { + "observed_rate": 0.033595113438045374, + "mean_prediction": 0.036707868010919444, + "calibration_in_the_large": 0.00311275457287407, + "expected_calibration_error_10bin": 0.006820258746574995, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + { + "valid": 2292, + "positives": 83, + "negatives": 2209, + "auroc": 0.7991676984079369, + "auprc": 0.141418398860244, + "brier": 0.033344495806511464, + "calibration": { + "observed_rate": 0.036212914485165795, + "mean_prediction": 0.038828220667599306, + "calibration_in_the_large": 0.0026153061824335105, + "expected_calibration_error_10bin": 0.0064505665487316, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + { + "valid": 2292, + "positives": 89, + "negatives": 2203, + "auroc": 0.8049595291405489, + "auprc": 0.14996120913954228, + "brier": 0.035433486277240044, + "calibration": { + "observed_rate": 0.03883071553228621, + "mean_prediction": 0.04090060895191726, + "calibration_in_the_large": 0.0020698934196310484, + "expected_calibration_error_10bin": 0.0050460960227440635, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + { + "valid": 2292, + "positives": 93, + "negatives": 2199, + "auroc": 0.7973321206609064, + "auprc": 0.15391797985921735, + "brier": 0.03695661855049787, + "calibration": { + "observed_rate": 0.04057591623036649, + "mean_prediction": 0.0430331929975082, + "calibration_in_the_large": 0.0024572767671417056, + "expected_calibration_error_10bin": 0.0052360308663976455, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + { + "valid": 2292, + "positives": 101, + "negatives": 2191, + "auroc": 0.798794347714096, + "auprc": 0.18607575161509365, + "brier": 0.03933189460886828, + "calibration": { + "observed_rate": 0.04406631762652705, + "mean_prediction": 0.04515384230567171, + "calibration_in_the_large": 0.0010875246791446566, + "expected_calibration_error_10bin": 0.006902422119151638, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + { + "valid": 2292, + "positives": 103, + "negatives": 2189, + "auroc": 0.7902886009926064, + "auprc": 0.18327434903545134, + "brier": 0.04028448857764456, + "calibration": { + "observed_rate": 0.04493891797556719, + "mean_prediction": 0.0471148689753493, + "calibration_in_the_large": 0.002175950999782107, + "expected_calibration_error_10bin": 0.008987315593674996, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + { + "valid": 2292, + "positives": 104, + "negatives": 2188, + "auroc": 0.7903731894248348, + "auprc": 0.18292444483345172, + "brier": 0.04068261329652987, + "calibration": { + "observed_rate": 0.04537521815008726, + "mean_prediction": 0.0474192372273453, + "calibration_in_the_large": 0.0020440190772580413, + "expected_calibration_error_10bin": 0.009619443219780425, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + } + ], + "reason": null + }, + "N18": { + "time_averaged_auroc": 0.8656391436149005, + "time_averaged_auprc": 0.15760134679138135, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2440, + "positives": 11, + "negatives": 2429, + "auroc": 0.8649650061753809, + "auprc": 0.03835167426098818, + "brier": 0.0044338139079796775, + "calibration": { + "observed_rate": 0.004508196721311476, + "mean_prediction": 0.0025943855984439964, + "calibration_in_the_large": -0.0019138111228674793, + "expected_calibration_error_10bin": 0.0019138111228674793, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + { + "valid": 2440, + "positives": 15, + "negatives": 2425, + "auroc": 0.8980068728522337, + "auprc": 0.10024813837901024, + "brier": 0.005887831522071861, + "calibration": { + "observed_rate": 0.006147540983606557, + "mean_prediction": 0.004222169329860945, + "calibration_in_the_large": -0.0019253716537456118, + "expected_calibration_error_10bin": 0.0021242607744259984, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + { + "valid": 2440, + "positives": 21, + "negatives": 2419, + "auroc": 0.8864347723380381, + "auprc": 0.12570900425077916, + "brier": 0.008127815992728486, + "calibration": { + "observed_rate": 0.00860655737704918, + "mean_prediction": 0.005694065055014689, + "calibration_in_the_large": -0.002912492322034492, + "expected_calibration_error_10bin": 0.002912492322034491, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + { + "valid": 2440, + "positives": 30, + "negatives": 2410, + "auroc": 0.8585892116182573, + "auprc": 0.12450953363777681, + "brier": 0.011600705773375125, + "calibration": { + "observed_rate": 0.012295081967213115, + "mean_prediction": 0.006812550460935959, + "calibration_in_the_large": -0.005482531506277155, + "expected_calibration_error_10bin": 0.0054825315062771544, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + { + "valid": 2440, + "positives": 32, + "negatives": 2408, + "auroc": 0.8597383720930233, + "auprc": 0.12022374629674779, + "brier": 0.012335253720574308, + "calibration": { + "observed_rate": 0.013114754098360656, + "mean_prediction": 0.007908700371322606, + "calibration_in_the_large": -0.00520605372703805, + "expected_calibration_error_10bin": 0.005390310286062142, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + { + "valid": 2440, + "positives": 34, + "negatives": 2406, + "auroc": 0.861229279741822, + "auprc": 0.12566804694235256, + "brier": 0.013019505582680627, + "calibration": { + "observed_rate": 0.013934426229508197, + "mean_prediction": 0.009053297389395174, + "calibration_in_the_large": -0.004881128840113023, + "expected_calibration_error_10bin": 0.005424012256292774, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + { + "valid": 2440, + "positives": 37, + "negatives": 2403, + "auroc": 0.8542137643261238, + "auprc": 0.1534789970771147, + "brier": 0.01401930240272255, + "calibration": { + "observed_rate": 0.015163934426229509, + "mean_prediction": 0.01003506200569794, + "calibration_in_the_large": -0.005128872420531569, + "expected_calibration_error_10bin": 0.005128872420531569, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + { + "valid": 2440, + "positives": 41, + "negatives": 2399, + "auroc": 0.8571355951158511, + "auprc": 0.16051332521869816, + "brier": 0.015468031455305033, + "calibration": { + "observed_rate": 0.01680327868852459, + "mean_prediction": 0.010624468845159501, + "calibration_in_the_large": -0.006178809843365088, + "expected_calibration_error_10bin": 0.00617880984336509, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + { + "valid": 2440, + "positives": 45, + "negatives": 2395, + "auroc": 0.8666295523080492, + "auprc": 0.1970817580828227, + "brier": 0.016765677709284183, + "calibration": { + "observed_rate": 0.018442622950819672, + "mean_prediction": 0.011389131452024678, + "calibration_in_the_large": -0.007053491498794993, + "expected_calibration_error_10bin": 0.007305223044016606, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + { + "valid": 2440, + "positives": 46, + "negatives": 2394, + "auroc": 0.8655606407322655, + "auprc": 0.19150606736998546, + "brier": 0.017120201347028616, + "calibration": { + "observed_rate": 0.018852459016393444, + "mean_prediction": 0.012150414086130188, + "calibration_in_the_large": -0.006702044930263256, + "expected_calibration_error_10bin": 0.006968995910824933, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + { + "valid": 2440, + "positives": 49, + "negatives": 2391, + "auroc": 0.8655673059688116, + "auprc": 0.24037813256383858, + "brier": 0.01800728225538921, + "calibration": { + "observed_rate": 0.020081967213114754, + "mean_prediction": 0.012804598190304517, + "calibration_in_the_large": -0.007277369022810237, + "expected_calibration_error_10bin": 0.007277369022810236, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + { + "valid": 2440, + "positives": 50, + "negatives": 2390, + "auroc": 0.857581589958159, + "auprc": 0.23552674003035295, + "brier": 0.018379268977976298, + "calibration": { + "observed_rate": 0.020491803278688523, + "mean_prediction": 0.013348485875973043, + "calibration_in_the_large": -0.0071433174027154805, + "expected_calibration_error_10bin": 0.0071433174027154805, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + { + "valid": 2440, + "positives": 50, + "negatives": 2390, + "auroc": 0.8576569037656904, + "auprc": 0.23562234417749042, + "brier": 0.018372866949994075, + "calibration": { + "observed_rate": 0.020491803278688523, + "mean_prediction": 0.013449408864232923, + "calibration_in_the_large": -0.0070423944144556005, + "expected_calibration_error_10bin": 0.007042394414455601, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + } + ], + "reason": null + }, + "N20": { + "time_averaged_auroc": 0.7320159902915011, + "time_averaged_auprc": 0.00606260481457179, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2806, + "positives": 6, + "negatives": 2800, + "auroc": 0.6923214285714285, + "auprc": 0.0045234537302422445, + "brier": 0.002136902724591552, + "calibration": { + "observed_rate": 0.0021382751247327157, + "mean_prediction": 0.00028730315475315916, + "calibration_in_the_large": -0.0018509719699795566, + "expected_calibration_error_10bin": 0.0018509719699795566, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 7, + "negatives": 2799, + "auroc": 0.725361098351452, + "auprc": 0.005271627272225692, + "brier": 0.002492095413142029, + "calibration": { + "observed_rate": 0.0024946543121881683, + "mean_prediction": 0.0005075760515294005, + "calibration_in_the_large": -0.0019870782606587678, + "expected_calibration_error_10bin": 0.0019870782606587678, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 7, + "negatives": 2799, + "auroc": 0.7367937528709233, + "auprc": 0.0058447010787516145, + "brier": 0.0024910395590383425, + "calibration": { + "observed_rate": 0.0024946543121881683, + "mean_prediction": 0.0007252393871870352, + "calibration_in_the_large": -0.0017694149250011332, + "expected_calibration_error_10bin": 0.0017694149250011332, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7363741958541815, + "auprc": 0.006272785044047667, + "brier": 0.002846745039277724, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.0008080714958323201, + "calibration_in_the_large": -0.002042962003811301, + "expected_calibration_error_10bin": 0.002042962003811301, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7370889921372409, + "auprc": 0.006302429771726917, + "brier": 0.0028466972925128837, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.000833791882509433, + "calibration_in_the_large": -0.002017241617134188, + "expected_calibration_error_10bin": 0.002017241617134188, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7395907791279486, + "auprc": 0.006350004967349501, + "brier": 0.0028464105085962894, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.0009294650473349012, + "calibration_in_the_large": -0.0019215684523087198, + "expected_calibration_error_10bin": 0.0019215684523087198, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7401715511079342, + "auprc": 0.006334972688749638, + "brier": 0.00284629626960655, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.001000026361283393, + "calibration_in_the_large": -0.001851007138360228, + "expected_calibration_error_10bin": 0.001851007138360228, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7393674052894925, + "auprc": 0.006322511123399417, + "brier": 0.0028464016250954152, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.001112454216208614, + "calibration_in_the_large": -0.0017385792834350069, + "expected_calibration_error_10bin": 0.0017385792834350069, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7344085060757684, + "auprc": 0.0063281277636879334, + "brier": 0.0028463897231746646, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.001297301844276683, + "calibration_in_the_large": -0.001553731655366938, + "expected_calibration_error_10bin": 0.001553731655366938, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7387419585418156, + "auprc": 0.006398012694110576, + "brier": 0.002846684620159452, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.001412216356006804, + "calibration_in_the_large": -0.0014388171436368169, + "expected_calibration_error_10bin": 0.0014388171436368169, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7361954967834168, + "auprc": 0.00636279543426349, + "brier": 0.002846814287176071, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.0015243526065444719, + "calibration_in_the_large": -0.0013266808930991491, + "expected_calibration_error_10bin": 0.0013266808930991491, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7298963545389564, + "auprc": 0.0062508280038997945, + "brier": 0.002847086142547151, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.0016568694937306174, + "calibration_in_the_large": -0.0011941640059130035, + "expected_calibration_error_10bin": 0.0011941640059130035, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7298963545389564, + "auprc": 0.0062516130169787965, + "brier": 0.002847108433121212, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.0016629954013335057, + "calibration_in_the_large": -0.0011880380983101152, + "expected_calibration_error_10bin": 0.0011880380983101152, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + } + ], + "reason": null + }, + "N25": { + "time_averaged_auroc": 0.9523516732503013, + "time_averaged_auprc": 0.07942719102205907, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2831, + "positives": 2, + "negatives": 2829, + "auroc": 0.9261223047013079, + "auprc": 0.021762414800389485, + "brier": 0.0007050447850513891, + "calibration": { + "observed_rate": 0.0007064641469445425, + "mean_prediction": 0.00017209731228218868, + "calibration_in_the_large": -0.0005343668346623539, + "expected_calibration_error_10bin": 0.0005343668346623539, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.9352670675627874, + "auprc": 0.04578647871147106, + "brier": 0.0014041738208733854, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0003779325476470599, + "calibration_in_the_large": -0.0010349957462420251, + "expected_calibration_error_10bin": 0.0010349957462420251, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.945859872611465, + "auprc": 0.06993052265632693, + "brier": 0.001747042604499059, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0005662639046827141, + "calibration_in_the_large": -0.0011998964626786421, + "expected_calibration_error_10bin": 0.0011998964626786421, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.9496815286624204, + "auprc": 0.07559772222889696, + "brier": 0.0017413110459944695, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0007280598686358939, + "calibration_in_the_large": -0.0010381004987254625, + "expected_calibration_error_10bin": 0.0010381004987254625, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 6, + "negatives": 2825, + "auroc": 0.9589380530973451, + "auprc": 0.09240040424694641, + "brier": 0.002081831531260574, + "calibration": { + "observed_rate": 0.0021193924408336277, + "mean_prediction": 0.0008618835232779372, + "calibration_in_the_large": -0.0012575089175556906, + "expected_calibration_error_10bin": 0.0013284409134518278, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 6, + "negatives": 2825, + "auroc": 0.96, + "auprc": 0.09449924775251291, + "brier": 0.0020771082269316877, + "calibration": { + "observed_rate": 0.0021193924408336277, + "mean_prediction": 0.0009651834779723285, + "calibration_in_the_large": -0.0011542089628612993, + "expected_calibration_error_10bin": 0.0012307764242247624, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 6, + "negatives": 2825, + "auroc": 0.9596460176991151, + "auprc": 0.09735366702023245, + "brier": 0.0020721999756335417, + "calibration": { + "observed_rate": 0.0021193924408336277, + "mean_prediction": 0.0010794925622103337, + "calibration_in_the_large": -0.001039899878623294, + "expected_calibration_error_10bin": 0.0011227345862654344, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 6, + "negatives": 2825, + "auroc": 0.95929203539823, + "auprc": 0.09729302832244009, + "brier": 0.002070626076000068, + "calibration": { + "observed_rate": 0.0021193924408336277, + "mean_prediction": 0.0011727308594042603, + "calibration_in_the_large": -0.0009466615814293674, + "expected_calibration_error_10bin": 0.0010364113753077052, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.957001214083367, + "auprc": 0.08568709368363238, + "brier": 0.0024197883306582495, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.0012500718941058926, + "calibration_in_the_large": -0.0012225526202000066, + "expected_calibration_error_10bin": 0.0013164556219334071, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.9567482800485634, + "auprc": 0.08897019119285336, + "brier": 0.002415726464659996, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.0013580729060791365, + "calibration_in_the_large": -0.0011145516082267627, + "expected_calibration_error_10bin": 0.0012872584561233588, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.9573047349251316, + "auprc": 0.0868137176314362, + "brier": 0.0024140153352838613, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.0014449382393766951, + "calibration_in_the_large": -0.001027686274929204, + "expected_calibration_error_10bin": 0.0012072568682190848, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.9573553217320923, + "auprc": 0.08822931285846061, + "brier": 0.0024119684227205933, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.0015317251392326025, + "calibration_in_the_large": -0.0009408993750732967, + "expected_calibration_error_10bin": 0.0012024610207886201, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.9573553217320923, + "auprc": 0.08822968218116911, + "brier": 0.002411784709033137, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.0015420466965701874, + "calibration_in_the_large": -0.0009305778177357118, + "expected_calibration_error_10bin": 0.0011938252474496922, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + } + ], + "reason": null + }, + "N28": { + "time_averaged_auroc": 0.8465258669525932, + "time_averaged_auprc": 0.013264827151876641, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2789, + "positives": 3, + "negatives": 2786, + "auroc": 0.9206748025843503, + "auprc": 0.01439933290482364, + "brier": 0.0010704967484219056, + "calibration": { + "observed_rate": 0.0010756543564001434, + "mean_prediction": 0.001134036669864549, + "calibration_in_the_large": 5.8382313464405526e-05, + "expected_calibration_error_10bin": 5.8382313464405526e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 3, + "negatives": 2786, + "auroc": 0.9218712610672409, + "auprc": 0.013620737551218835, + "brier": 0.0010710316606804193, + "calibration": { + "observed_rate": 0.0010756543564001434, + "mean_prediction": 0.001753799973365662, + "calibration_in_the_large": 0.0006781456169655186, + "expected_calibration_error_10bin": 0.0006781456169655186, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 3, + "negatives": 2786, + "auroc": 0.914692510169897, + "auprc": 0.0122442425910634, + "brier": 0.0010733372036807326, + "calibration": { + "observed_rate": 0.0010756543564001434, + "mean_prediction": 0.0023120133404418344, + "calibration_in_the_large": 0.001236358984041691, + "expected_calibration_error_10bin": 0.001236358984041691, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 3, + "negatives": 2786, + "auroc": 0.9186408231634362, + "auprc": 0.012618860637708356, + "brier": 0.0010768407122779947, + "calibration": { + "observed_rate": 0.0010756543564001434, + "mean_prediction": 0.0028256996872479813, + "calibration_in_the_large": 0.0017500453308478378, + "expected_calibration_error_10bin": 0.0017500453308478378, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 4, + "negatives": 2785, + "auroc": 0.7959605026929982, + "auprc": 0.00995501674479044, + "brier": 0.0014377298060336123, + "calibration": { + "observed_rate": 0.0014342058085335247, + "mean_prediction": 0.003271339188211582, + "calibration_in_the_large": 0.0018371333796780573, + "expected_calibration_error_10bin": 0.0018371333796780573, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 4, + "negatives": 2785, + "auroc": 0.7909335727109515, + "auprc": 0.0092377884694711, + "brier": 0.0014440750276750237, + "calibration": { + "observed_rate": 0.0014342058085335247, + "mean_prediction": 0.003672484955217062, + "calibration_in_the_large": 0.002238279146683537, + "expected_calibration_error_10bin": 0.002238279146683537, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 5, + "negatives": 2784, + "auroc": 0.816235632183908, + "auprc": 0.010471497429726005, + "brier": 0.0018009781345909137, + "calibration": { + "observed_rate": 0.0017927572606669057, + "mean_prediction": 0.0039818026103464925, + "calibration_in_the_large": 0.002189045349679587, + "expected_calibration_error_10bin": 0.002189045349679587, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 6, + "negatives": 2783, + "auroc": 0.8036890645586298, + "auprc": 0.009878470589506907, + "brier": 0.002159116883574498, + "calibration": { + "observed_rate": 0.002151308712800287, + "mean_prediction": 0.00423665032368615, + "calibration_in_the_large": 0.002085341610885863, + "expected_calibration_error_10bin": 0.002085341610885863, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 7, + "negatives": 2782, + "auroc": 0.818321865050837, + "auprc": 0.011066762145945836, + "brier": 0.0025118912899330277, + "calibration": { + "observed_rate": 0.002509860164933668, + "mean_prediction": 0.004366990904838297, + "calibration_in_the_large": 0.0018571307399046287, + "expected_calibration_error_10bin": 0.0018571307399046287, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 8, + "negatives": 2781, + "auroc": 0.8398058252427184, + "auprc": 0.017921757162122836, + "brier": 0.0028540263685595067, + "calibration": { + "observed_rate": 0.0028684116170670493, + "mean_prediction": 0.004621602460514634, + "calibration_in_the_large": 0.0017531908434475847, + "expected_calibration_error_10bin": 0.0017531908434475847, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 9, + "negatives": 2780, + "auroc": 0.8295363709032774, + "auprc": 0.01740162625113607, + "brier": 0.0032106293133804327, + "calibration": { + "observed_rate": 0.0032269630692004303, + "mean_prediction": 0.004917675385173127, + "calibration_in_the_large": 0.0016907123159726964, + "expected_calibration_error_10bin": 0.0016907123159726964, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 9, + "negatives": 2780, + "auroc": 0.8299760191846522, + "auprc": 0.01726619246956161, + "brier": 0.003213590539375041, + "calibration": { + "observed_rate": 0.0032269630692004303, + "mean_prediction": 0.0051806703095486125, + "calibration_in_the_large": 0.001953707240348182, + "expected_calibration_error_10bin": 0.001953707240348182, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + { + "valid": 2789, + "positives": 10, + "negatives": 2779, + "auroc": 0.8044980208708168, + "auprc": 0.016360468027321294, + "brier": 0.003570412613363011, + "calibration": { + "observed_rate": 0.0035855145213338113, + "mean_prediction": 0.005248986677389877, + "calibration_in_the_large": 0.0016634721560560652, + "expected_calibration_error_10bin": 0.0016634721560560652, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + } + ], + "reason": null + }, + "N30": { + "time_averaged_auroc": 0.7068411313982634, + "time_averaged_auprc": 0.010972020821426644, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2829, + "positives": 4, + "negatives": 2825, + "auroc": 0.6314159292035398, + "auprc": 0.00855232244204915, + "brier": 0.0014115788416686032, + "calibration": { + "observed_rate": 0.0014139271827500884, + "mean_prediction": 0.0007141632075670443, + "calibration_in_the_large": -0.0006997639751830442, + "expected_calibration_error_10bin": 0.0006997639751830442, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 6, + "negatives": 2823, + "auroc": 0.7438304404298028, + "auprc": 0.0077046745122602255, + "brier": 0.002118119003507264, + "calibration": { + "observed_rate": 0.0021208907741251328, + "mean_prediction": 0.001638801949879983, + "calibration_in_the_large": -0.00048208882424514965, + "expected_calibration_error_10bin": 0.00048208882424514965, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 7, + "negatives": 2822, + "auroc": 0.7740204515541156, + "auprc": 0.01147141822572811, + "brier": 0.002470166261044304, + "calibration": { + "observed_rate": 0.002474372569812655, + "mean_prediction": 0.0020576333512236445, + "calibration_in_the_large": -0.00041673921858901035, + "expected_calibration_error_10bin": 0.00041673921858901035, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 8, + "negatives": 2821, + "auroc": 0.733826657213754, + "auprc": 0.010670910209310599, + "brier": 0.002831147640312654, + "calibration": { + "observed_rate": 0.002827854365500177, + "mean_prediction": 0.002471594067891254, + "calibration_in_the_large": -0.0003562602976089229, + "expected_calibration_error_10bin": 0.00044120988447990617, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 9, + "negatives": 2820, + "auroc": 0.6773049645390071, + "auprc": 0.009914816273942664, + "brier": 0.003188148184838638, + "calibration": { + "observed_rate": 0.003181336161187699, + "mean_prediction": 0.00273112460875553, + "calibration_in_the_large": -0.00045021155243216886, + "expected_calibration_error_10bin": 0.0005413368146835042, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 9, + "negatives": 2820, + "auroc": 0.6778171788810087, + "auprc": 0.009725193463376358, + "brier": 0.003192264200724082, + "calibration": { + "observed_rate": 0.003181336161187699, + "mean_prediction": 0.0028996652461992308, + "calibration_in_the_large": -0.00028167091498846816, + "expected_calibration_error_10bin": 0.0003803848450908306, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 9, + "negatives": 2820, + "auroc": 0.6765169424743893, + "auprc": 0.009475739921232407, + "brier": 0.003198671780612835, + "calibration": { + "observed_rate": 0.003181336161187699, + "mean_prediction": 0.003134515740616929, + "calibration_in_the_large": -4.6820420570769985e-05, + "expected_calibration_error_10bin": 0.00015417245215852387, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 10, + "negatives": 2819, + "auroc": 0.7033699893579284, + "auprc": 0.01230264442079076, + "brier": 0.0035663059715493905, + "calibration": { + "observed_rate": 0.003534817956875221, + "mean_prediction": 0.003713088547981585, + "calibration_in_the_large": 0.00017827059110636385, + "expected_calibration_error_10bin": 0.00017827059110636406, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 10, + "negatives": 2819, + "auroc": 0.7010287335934728, + "auprc": 0.012007814041172177, + "brier": 0.0035797165880338544, + "calibration": { + "observed_rate": 0.003534817956875221, + "mean_prediction": 0.004113148564485901, + "calibration_in_the_large": 0.0005783306076106802, + "expected_calibration_error_10bin": 0.0005783306076106807, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 10, + "negatives": 2819, + "auroc": 0.7030507272082299, + "auprc": 0.011895675187709055, + "brier": 0.003588495408738712, + "calibration": { + "observed_rate": 0.003534817956875221, + "mean_prediction": 0.004457689312885325, + "calibration_in_the_large": 0.0009228713560101042, + "expected_calibration_error_10bin": 0.0009228713560101038, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 11, + "negatives": 2818, + "auroc": 0.7222401445254533, + "auprc": 0.013007656855991817, + "brier": 0.0039428087448402606, + "calibration": { + "observed_rate": 0.003888299752562743, + "mean_prediction": 0.004670265385956454, + "calibration_in_the_large": 0.0007819656333937111, + "expected_calibration_error_10bin": 0.0007819656333937114, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 11, + "negatives": 2818, + "auroc": 0.7222078843796373, + "auprc": 0.012953102253868932, + "brier": 0.003953082308442308, + "calibration": { + "observed_rate": 0.003888299752562743, + "mean_prediction": 0.00490202946582425, + "calibration_in_the_large": 0.0010137297132615073, + "expected_calibration_error_10bin": 0.0010137297132615077, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 11, + "negatives": 2818, + "auroc": 0.722304664817085, + "auprc": 0.012954302871114126, + "brier": 0.003953564152898916, + "calibration": { + "observed_rate": 0.003888299752562743, + "mean_prediction": 0.004913635745286311, + "calibration_in_the_large": 0.0010253359927235683, + "expected_calibration_error_10bin": 0.0010253359927235683, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + } + ], + "reason": null + }, + "N32": { + "time_averaged_auroc": 0.7941564250800954, + "time_averaged_auprc": 0.11903610918098789, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2807, + "positives": 5, + "negatives": 2802, + "auroc": 0.7690221270521056, + "auprc": 0.020875505257566113, + "brier": 0.0017700553624181948, + "calibration": { + "observed_rate": 0.0017812611328820805, + "mean_prediction": 0.0013319759679621295, + "calibration_in_the_large": -0.00044928516491995097, + "expected_calibration_error_10bin": 0.00044928516491995097, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 7, + "negatives": 2800, + "auroc": 0.7895408163265306, + "auprc": 0.02637465483674539, + "brier": 0.002471297758047159, + "calibration": { + "observed_rate": 0.0024937655860349127, + "mean_prediction": 0.0020772052784291924, + "calibration_in_the_large": -0.00041656030760572026, + "expected_calibration_error_10bin": 0.00041656030760572026, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 9, + "negatives": 2798, + "auroc": 0.7773012469224049, + "auprc": 0.023761358148371173, + "brier": 0.00317644563864916, + "calibration": { + "observed_rate": 0.003206270039187745, + "mean_prediction": 0.0025839978162250934, + "calibration_in_the_large": -0.0006222722229626515, + "expected_calibration_error_10bin": 0.0006222722229626515, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.7994637111190561, + "auprc": 0.13133308666889282, + "brier": 0.003474645220963474, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.0030915677412651325, + "calibration_in_the_large": -0.0004709545244990284, + "expected_calibration_error_10bin": 0.0004709545244990284, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.8005720414730068, + "auprc": 0.13201176854640834, + "brier": 0.003468266093418486, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.003315499549301162, + "calibration_in_the_large": -0.0002470227164629991, + "expected_calibration_error_10bin": 0.0002470227164629991, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.800965319985699, + "auprc": 0.13195669604733665, + "brier": 0.0034626518170720157, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.003561544030116613, + "calibration_in_the_large": -9.78235647547919e-07, + "expected_calibration_error_10bin": 9.78235647547919e-07, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.8003575259206293, + "auprc": 0.13097391427202176, + "brier": 0.0034572685368070765, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.003820866062293633, + "calibration_in_the_large": 0.000258343796529472, + "expected_calibration_error_10bin": 0.0008963858041279681, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 11, + "negatives": 2796, + "auroc": 0.8174014826375341, + "auprc": 0.13084322358970088, + "brier": 0.003793039621547043, + "calibration": { + "observed_rate": 0.003918774492340577, + "mean_prediction": 0.0040371778936740465, + "calibration_in_the_large": 0.0001184034013334695, + "expected_calibration_error_10bin": 0.0007539705686594015, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 12, + "negatives": 2795, + "auroc": 0.8333631484794275, + "auprc": 0.18250702757868176, + "brier": 0.004106403449440503, + "calibration": { + "observed_rate": 0.004275026718916993, + "mean_prediction": 0.004232891997313358, + "calibration_in_the_large": -4.213472160363545e-05, + "expected_calibration_error_10bin": 0.0005898366208742063, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 13, + "negatives": 2794, + "auroc": 0.7847585485380761, + "auprc": 0.16813725450306286, + "brier": 0.004455782948828884, + "calibration": { + "observed_rate": 0.004631278945493409, + "mean_prediction": 0.0045814028610750325, + "calibration_in_the_large": -4.9876084418376716e-05, + "expected_calibration_error_10bin": 0.0005777608463007739, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 13, + "negatives": 2794, + "auroc": 0.7846208909201036, + "auprc": 0.16822865038398463, + "brier": 0.004453871293523828, + "calibration": { + "observed_rate": 0.004631278945493409, + "mean_prediction": 0.0046910091357846954, + "calibration_in_the_large": 5.973019029128623e-05, + "expected_calibration_error_10bin": 0.0006854977021235204, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 15, + "negatives": 2792, + "auroc": 0.7833094555873925, + "auprc": 0.1503388262831196, + "brier": 0.005141829020620743, + "calibration": { + "observed_rate": 0.005343783398646241, + "mean_prediction": 0.005108811922533465, + "calibration_in_the_large": -0.00023497147611277643, + "expected_calibration_error_10bin": 0.00038036440005512656, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + { + "valid": 2807, + "positives": 15, + "negatives": 2792, + "auroc": 0.7833572110792741, + "auprc": 0.15012745323695065, + "brier": 0.0051405819570795154, + "calibration": { + "observed_rate": 0.005343783398646241, + "mean_prediction": 0.005202542027272085, + "calibration_in_the_large": -0.00014124137137415654, + "expected_calibration_error_10bin": 0.00047308468702141396, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + } + ], + "reason": null + }, + "N39": { + "time_averaged_auroc": 0.7603372078146582, + "time_averaged_auprc": 0.07259304617004184, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2520, + "positives": 16, + "negatives": 2504, + "auroc": 0.7672474041533547, + "auprc": 0.015560022380180456, + "brier": 0.006327246016758949, + "calibration": { + "observed_rate": 0.006349206349206349, + "mean_prediction": 0.009932518933598498, + "calibration_in_the_large": 0.003583312584392149, + "expected_calibration_error_10bin": 0.003583312584392149, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + { + "valid": 2520, + "positives": 31, + "negatives": 2489, + "auroc": 0.7727420002851255, + "auprc": 0.04213332439071456, + "brier": 0.012050241293883013, + "calibration": { + "observed_rate": 0.012301587301587301, + "mean_prediction": 0.016705271495794434, + "calibration_in_the_large": 0.004403684194207133, + "expected_calibration_error_10bin": 0.00441749705027582, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + { + "valid": 2520, + "positives": 44, + "negatives": 2476, + "auroc": 0.7492381406961375, + "auprc": 0.05132199266812414, + "brier": 0.01700730971893, + "calibration": { + "observed_rate": 0.01746031746031746, + "mean_prediction": 0.020933372652368797, + "calibration_in_the_large": 0.003473055192051336, + "expected_calibration_error_10bin": 0.0036741792217880064, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + { + "valid": 2520, + "positives": 54, + "negatives": 2466, + "auroc": 0.7686837283349854, + "auprc": 0.07197422811987915, + "brier": 0.02053134088080042, + "calibration": { + "observed_rate": 0.02142857142857143, + "mean_prediction": 0.023868580726538934, + "calibration_in_the_large": 0.0024400092979675048, + "expected_calibration_error_10bin": 0.002671743452683874, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + { + "valid": 2520, + "positives": 61, + "negatives": 2459, + "auroc": 0.7720851472343149, + "auprc": 0.0819303822214136, + "brier": 0.02304162560767732, + "calibration": { + "observed_rate": 0.024206349206349207, + "mean_prediction": 0.026769220118645565, + "calibration_in_the_large": 0.0025628709122963583, + "expected_calibration_error_10bin": 0.002697960582205154, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + { + "valid": 2520, + "positives": 65, + "negatives": 2455, + "auroc": 0.7641986526711577, + "auprc": 0.08149934140944236, + "brier": 0.024573430873664807, + "calibration": { + "observed_rate": 0.025793650793650792, + "mean_prediction": 0.029302385462714093, + "calibration_in_the_large": 0.0035087346690633008, + "expected_calibration_error_10bin": 0.0035087346690633003, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + { + "valid": 2520, + "positives": 71, + "negatives": 2449, + "auroc": 0.7595914400243847, + "auprc": 0.08334993816833387, + "brier": 0.026826193374325808, + "calibration": { + "observed_rate": 0.028174603174603175, + "mean_prediction": 0.03148060376808557, + "calibration_in_the_large": 0.003306000593482395, + "expected_calibration_error_10bin": 0.003306000593482398, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + { + "valid": 2520, + "positives": 74, + "negatives": 2446, + "auroc": 0.7590439990276457, + "auprc": 0.08314661449392141, + "brier": 0.02798870092766588, + "calibration": { + "observed_rate": 0.029365079365079365, + "mean_prediction": 0.03326933259280243, + "calibration_in_the_large": 0.003904253227723066, + "expected_calibration_error_10bin": 0.0039042532277230673, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + { + "valid": 2520, + "positives": 78, + "negatives": 2442, + "auroc": 0.751034251034251, + "auprc": 0.08374629149451547, + "brier": 0.02949075374784741, + "calibration": { + "observed_rate": 0.030952380952380953, + "mean_prediction": 0.035024652649031304, + "calibration_in_the_large": 0.004072271696650351, + "expected_calibration_error_10bin": 0.005320133486418938, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + { + "valid": 2520, + "positives": 81, + "negatives": 2439, + "auroc": 0.7531117286481507, + "auprc": 0.08732174964073018, + "brier": 0.03055091655783622, + "calibration": { + "observed_rate": 0.03214285714285714, + "mean_prediction": 0.03659501154694544, + "calibration_in_the_large": 0.004452154404088297, + "expected_calibration_error_10bin": 0.00580168132557504, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + { + "valid": 2520, + "positives": 82, + "negatives": 2438, + "auroc": 0.7548720462594289, + "auprc": 0.08783704630290247, + "brier": 0.030952424669865454, + "calibration": { + "observed_rate": 0.03253968253968254, + "mean_prediction": 0.03806831875228368, + "calibration_in_the_large": 0.005528636212601135, + "expected_calibration_error_10bin": 0.00572331385217637, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + { + "valid": 2520, + "positives": 83, + "negatives": 2437, + "auroc": 0.7563219640976709, + "auprc": 0.08700065876906564, + "brier": 0.03137525555326953, + "calibration": { + "observed_rate": 0.03293650793650794, + "mean_prediction": 0.039713626467652384, + "calibration_in_the_large": 0.0067771185311444465, + "expected_calibration_error_10bin": 0.006777118531144449, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + { + "valid": 2520, + "positives": 83, + "negatives": 2437, + "auroc": 0.7562131991239476, + "auprc": 0.08688801015132078, + "brier": 0.03139661722228004, + "calibration": { + "observed_rate": 0.03293650793650794, + "mean_prediction": 0.039964391160774826, + "calibration_in_the_large": 0.0070278832242668884, + "expected_calibration_error_10bin": 0.007027883224266891, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + } + ], + "reason": null + }, + "N40": { + "time_averaged_auroc": 0.821071742137043, + "time_averaged_auprc": 0.037988823224275464, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2606, + "positives": 5, + "negatives": 2601, + "auroc": 0.8897347174163783, + "auprc": 0.019023755676509446, + "brier": 0.001910596228827165, + "calibration": { + "observed_rate": 0.001918649270913277, + "mean_prediction": 0.003364909804689732, + "calibration_in_the_large": 0.001446260533776455, + "expected_calibration_error_10bin": 0.001446260533776455, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + { + "valid": 2606, + "positives": 7, + "negatives": 2599, + "auroc": 0.8656076512944539, + "auprc": 0.019624425762286096, + "brier": 0.002684607822571381, + "calibration": { + "observed_rate": 0.002686108979278588, + "mean_prediction": 0.0049921092090220815, + "calibration_in_the_large": 0.0023060002297434937, + "expected_calibration_error_10bin": 0.0023060002297434937, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + { + "valid": 2606, + "positives": 11, + "negatives": 2595, + "auroc": 0.8127167630057803, + "auprc": 0.018620528822298563, + "brier": 0.004218003239863486, + "calibration": { + "observed_rate": 0.00422102839600921, + "mean_prediction": 0.006009321121457911, + "calibration_in_the_large": 0.0017882927254487015, + "expected_calibration_error_10bin": 0.0017882927254487015, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + { + "valid": 2606, + "positives": 13, + "negatives": 2593, + "auroc": 0.8169628289180931, + "auprc": 0.028391470011062438, + "brier": 0.004949357709176634, + "calibration": { + "observed_rate": 0.0049884881043745204, + "mean_prediction": 0.006633295289705244, + "calibration_in_the_large": 0.0016448071853307237, + "expected_calibration_error_10bin": 0.001644807185330723, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + { + "valid": 2606, + "positives": 13, + "negatives": 2593, + "auroc": 0.8150345605031297, + "auprc": 0.026751029744850687, + "brier": 0.004978770352583539, + "calibration": { + "observed_rate": 0.0049884881043745204, + "mean_prediction": 0.007598480298241206, + "calibration_in_the_large": 0.002609992193866686, + "expected_calibration_error_10bin": 0.002609992193866685, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + { + "valid": 2606, + "positives": 16, + "negatives": 2590, + "auroc": 0.7710666023166023, + "auprc": 0.03129817359783805, + "brier": 0.006106665648714379, + "calibration": { + "observed_rate": 0.0061396776669224865, + "mean_prediction": 0.008364081425251321, + "calibration_in_the_large": 0.0022244037583288344, + "expected_calibration_error_10bin": 0.002224403758328836, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + { + "valid": 2606, + "positives": 16, + "negatives": 2590, + "auroc": 0.7714527027027027, + "auprc": 0.03108244035599339, + "brier": 0.006117764327407734, + "calibration": { + "observed_rate": 0.0061396776669224865, + "mean_prediction": 0.008714471731099011, + "calibration_in_the_large": 0.0025747940641765244, + "expected_calibration_error_10bin": 0.002574794064176526, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + { + "valid": 2606, + "positives": 19, + "negatives": 2587, + "auroc": 0.7996460032958314, + "auprc": 0.03799924809257864, + "brier": 0.00720276969263034, + "calibration": { + "observed_rate": 0.0072908672294704525, + "mean_prediction": 0.009201647412665763, + "calibration_in_the_large": 0.0019107801831953104, + "expected_calibration_error_10bin": 0.0019107801831953093, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + { + "valid": 2606, + "positives": 21, + "negatives": 2585, + "auroc": 0.8186607718522612, + "auprc": 0.05082564232588963, + "brier": 0.007880065913487864, + "calibration": { + "observed_rate": 0.008058326937835763, + "mean_prediction": 0.009911791125046157, + "calibration_in_the_large": 0.0018534641872103939, + "expected_calibration_error_10bin": 0.0018534641872103937, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + { + "valid": 2606, + "positives": 22, + "negatives": 2584, + "auroc": 0.8220869687587954, + "auprc": 0.051854024837334395, + "brier": 0.00826240845163704, + "calibration": { + "observed_rate": 0.00844205679201842, + "mean_prediction": 0.010566335411132154, + "calibration_in_the_large": 0.0021242786191137345, + "expected_calibration_error_10bin": 0.0021242786191137345, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + { + "valid": 2606, + "positives": 24, + "negatives": 2582, + "auroc": 0.8294280919184095, + "auprc": 0.058749479751883965, + "brier": 0.008980146913358694, + "calibration": { + "observed_rate": 0.00920951650038373, + "mean_prediction": 0.011192354221975096, + "calibration_in_the_large": 0.001982837721591366, + "expected_calibration_error_10bin": 0.0019828377215913673, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + { + "valid": 2606, + "positives": 24, + "negatives": 2582, + "auroc": 0.8307997676219985, + "auprc": 0.059837879854606056, + "brier": 0.008983913394994564, + "calibration": { + "observed_rate": 0.00920951650038373, + "mean_prediction": 0.01164414844906794, + "calibration_in_the_large": 0.0024346319486842107, + "expected_calibration_error_10bin": 0.002434631948684211, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + { + "valid": 2606, + "positives": 24, + "negatives": 2582, + "auroc": 0.8307352181771237, + "auprc": 0.05979660308244971, + "brier": 0.00898453193724761, + "calibration": { + "observed_rate": 0.00920951650038373, + "mean_prediction": 0.01166106298951239, + "calibration_in_the_large": 0.00245154648912866, + "expected_calibration_error_10bin": 0.0024515464891286614, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + } + ], + "reason": null + }, + "N73": { + "time_averaged_auroc": 0.9500746368564036, + "time_averaged_auprc": 0.05509186132455372, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.9550919377652051, + "auprc": 0.0078125, + "brier": 0.0003531121258215183, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.00019685896815246405, + "calibration_in_the_large": -0.00015662282753505806, + "expected_calibration_error_10bin": 0.00015662282753505806, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.9671145685997171, + "auprc": 0.010638297872340425, + "brier": 0.0003529423533409641, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.00031759916097338036, + "calibration_in_the_large": -3.588263471414175e-05, + "expected_calibration_error_10bin": 3.588263471414175e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9782454899186417, + "auprc": 0.0541501976284585, + "brier": 0.0006982342639536214, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0005736028806418841, + "calibration_in_the_large": -0.00013336071073316016, + "expected_calibration_error_10bin": 0.00013336071073316016, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9785992217898832, + "auprc": 0.050595238095238096, + "brier": 0.0006976888481561338, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0007014895088446244, + "calibration_in_the_large": -5.474082530419777e-06, + "expected_calibration_error_10bin": 5.474082530419777e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9785992217898832, + "auprc": 0.050595238095238096, + "brier": 0.0006976733965996816, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0007136173994150202, + "calibration_in_the_large": 6.653808039975987e-06, + "expected_calibration_error_10bin": 6.653808039975987e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9784223558542625, + "auprc": 0.05051622418879056, + "brier": 0.0006973163662355394, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0008364962065691782, + "calibration_in_the_large": 0.00012953261519413394, + "expected_calibration_error_10bin": 0.00012953261519413394, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 3, + "negatives": 2826, + "auroc": 0.9608398207124321, + "auprc": 0.038342712126227516, + "brier": 0.0010489008611219786, + "calibration": { + "observed_rate": 0.0010604453870625664, + "mean_prediction": 0.0009488924912202897, + "calibration_in_the_large": -0.00011155289584227667, + "expected_calibration_error_10bin": 0.00011155289584227667, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 4, + "negatives": 2825, + "auroc": 0.9685840707964601, + "auprc": 0.048579707232103975, + "brier": 0.001391497086021536, + "calibration": { + "observed_rate": 0.0014139271827500884, + "mean_prediction": 0.0009776462672064382, + "calibration_in_the_large": -0.00043628091554365027, + "expected_calibration_error_10bin": 0.00043628091554365027, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 5, + "negatives": 2824, + "auroc": 0.9747167138810199, + "auprc": 0.0954916880342771, + "brier": 0.0017224094076063227, + "calibration": { + "observed_rate": 0.0017674089784376105, + "mean_prediction": 0.0010665762304416916, + "calibration_in_the_large": -0.0007008327479959189, + "expected_calibration_error_10bin": 0.0007008327479959189, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 6, + "negatives": 2823, + "auroc": 0.9040028338646829, + "auprc": 0.08154976667271571, + "brier": 0.0020746525631174313, + "calibration": { + "observed_rate": 0.0021208907741251328, + "mean_prediction": 0.0010988791920434346, + "calibration_in_the_large": -0.0010220115820816981, + "expected_calibration_error_10bin": 0.0010220115820816981, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 6, + "negatives": 2823, + "auroc": 0.9017593576573385, + "auprc": 0.07737727709042654, + "brier": 0.0020723720931541917, + "calibration": { + "observed_rate": 0.0021208907741251328, + "mean_prediction": 0.0012035334445982635, + "calibration_in_the_large": -0.0009173573295268693, + "expected_calibration_error_10bin": 0.0009173573295268693, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 6, + "negatives": 2823, + "auroc": 0.9023497461329555, + "auprc": 0.07494081107546688, + "brier": 0.002070902752269372, + "calibration": { + "observed_rate": 0.0021208907741251328, + "mean_prediction": 0.0012501196850508009, + "calibration_in_the_large": -0.0008707710890743319, + "expected_calibration_error_10bin": 0.0008707710890743319, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + { + "valid": 2829, + "positives": 6, + "negatives": 2823, + "auroc": 0.9026449403707639, + "auprc": 0.07560453910791495, + "brier": 0.002070821225244139, + "calibration": { + "observed_rate": 0.0021208907741251328, + "mean_prediction": 0.0012528199949298744, + "calibration_in_the_large": -0.0008680707791952583, + "expected_calibration_error_10bin": 0.0008680707791952583, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + } + ], + "reason": null + }, + "N99": { + "time_averaged_auroc": 0.7434765738257371, + "time_averaged_auprc": 0.00802431092530334, + "valid_timepoint_cells": 13, + "timepoints": [ + { + "valid": 2799, + "positives": 2, + "negatives": 2797, + "auroc": 0.657311405076868, + "auprc": 0.004158604615465404, + "brier": 0.0007139218589935349, + "calibration": { + "observed_rate": 0.0007145409074669524, + "mean_prediction": 0.0003545232729366395, + "calibration_in_the_large": -0.0003600176345303129, + "expected_calibration_error_10bin": 0.0003600176345303129, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + { + "valid": 2799, + "positives": 3, + "negatives": 2796, + "auroc": 0.7290176442536958, + "auprc": 0.006100789214773393, + "brier": 0.0010701668713202445, + "calibration": { + "observed_rate": 0.0010718113612004287, + "mean_prediction": 0.0006132275774724752, + "calibration_in_the_large": -0.00045858378372795356, + "expected_calibration_error_10bin": 0.00045858378372795356, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + { + "valid": 2799, + "positives": 3, + "negatives": 2796, + "auroc": 0.7265140677157844, + "auprc": 0.005686470156591118, + "brier": 0.0010707269270512636, + "calibration": { + "observed_rate": 0.0010718113612004287, + "mean_prediction": 0.0008668250053813685, + "calibration_in_the_large": -0.0002049863558190602, + "expected_calibration_error_10bin": 0.0002049863558190602, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + { + "valid": 2799, + "positives": 3, + "negatives": 2796, + "auroc": 0.7285407725321889, + "auprc": 0.006775533423322048, + "brier": 0.0010703709893121875, + "calibration": { + "observed_rate": 0.0010718113612004287, + "mean_prediction": 0.0010672641792621132, + "calibration_in_the_large": -4.5471819383154696e-06, + "expected_calibration_error_10bin": 4.5471819383154696e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + { + "valid": 2799, + "positives": 3, + "negatives": 2796, + "auroc": 0.7308059132093467, + "auprc": 0.007163375773063949, + "brier": 0.0010706967899283353, + "calibration": { + "observed_rate": 0.0010718113612004287, + "mean_prediction": 0.0012524831685587561, + "calibration_in_the_large": 0.00018067180735832741, + "expected_calibration_error_10bin": 0.00018067180735832741, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + { + "valid": 2799, + "positives": 3, + "negatives": 2796, + "auroc": 0.73068669527897, + "auprc": 0.008183735288934221, + "brier": 0.0010706514757435565, + "calibration": { + "observed_rate": 0.0010718113612004287, + "mean_prediction": 0.0014223101160648693, + "calibration_in_the_large": 0.00035049875486444057, + "expected_calibration_error_10bin": 0.00035049875486444057, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + { + "valid": 2799, + "positives": 5, + "negatives": 2794, + "auroc": 0.7690050107372942, + "auprc": 0.00959871479742686, + "brier": 0.0017811875691056138, + "calibration": { + "observed_rate": 0.0017863522686673813, + "mean_prediction": 0.0015660061798773912, + "calibration_in_the_large": -0.00022034608878999007, + "expected_calibration_error_10bin": 0.00022034608878999007, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + { + "valid": 2799, + "positives": 5, + "negatives": 2794, + "auroc": 0.7705082319255547, + "auprc": 0.009767069933369184, + "brier": 0.001781893052052315, + "calibration": { + "observed_rate": 0.0017863522686673813, + "mean_prediction": 0.0017337133081067719, + "calibration_in_the_large": -5.2638960560609386e-05, + "expected_calibration_error_10bin": 5.2638960560609386e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + { + "valid": 2799, + "positives": 5, + "negatives": 2794, + "auroc": 0.7702934860415175, + "auprc": 0.009805806109561652, + "brier": 0.0017820059674507245, + "calibration": { + "observed_rate": 0.0017863522686673813, + "mean_prediction": 0.0017671212099886985, + "calibration_in_the_large": -1.923105867868277e-05, + "expected_calibration_error_10bin": 1.923105867868277e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + { + "valid": 2799, + "positives": 6, + "negatives": 2793, + "auroc": 0.7637546246568803, + "auprc": 0.009091095479821213, + "brier": 0.0021393010960330415, + "calibration": { + "observed_rate": 0.0021436227224008574, + "mean_prediction": 0.0019673471705254557, + "calibration_in_the_large": -0.00017627555187540176, + "expected_calibration_error_10bin": 0.00017627555187540176, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + { + "valid": 2799, + "positives": 6, + "negatives": 2793, + "auroc": 0.7626805108008116, + "auprc": 0.009314033697433622, + "brier": 0.0021406740050317623, + "calibration": { + "observed_rate": 0.0021436227224008574, + "mean_prediction": 0.002249867950991846, + "calibration_in_the_large": 0.00010624522859098862, + "expected_calibration_error_10bin": 0.00010624522859098862, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + { + "valid": 2799, + "positives": 6, + "negatives": 2793, + "auroc": 0.7630982217448383, + "auprc": 0.009335651117338273, + "brier": 0.0021421753320813625, + "calibration": { + "observed_rate": 0.0021436227224008574, + "mean_prediction": 0.002459453963916045, + "calibration_in_the_large": 0.00031583124151518755, + "expected_calibration_error_10bin": 0.00031583124151518755, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + { + "valid": 2799, + "positives": 6, + "negatives": 2793, + "auroc": 0.7629788757608307, + "auprc": 0.00933516242184248, + "brier": 0.0021422336179610954, + "calibration": { + "observed_rate": 0.0021436227224008574, + "mean_prediction": 0.0024670457684743312, + "calibration_in_the_large": 0.0003234230460734738, + "expected_calibration_error_10bin": 0.0003234230460734738, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + } + ], + "reason": null + }, + "O69": { + "time_averaged_auroc": 0.9971434936500093, + "time_averaged_auprc": 0.35778180192530723, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2743, + "positives": 0, + "negatives": 2743, + "auroc": null, + "auprc": null, + "brier": 1.3828333092611101e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 9.263697317293441e-05, + "calibration_in_the_large": 9.263697317293441e-05, + "expected_calibration_error_10bin": 9.263697317293441e-05, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 3, + "negatives": 2740, + "auroc": 0.9987834549878345, + "auprc": 0.38888888888888884, + "brier": 0.0010262209169478345, + "calibration": { + "observed_rate": 0.001093693036820999, + "mean_prediction": 0.0002104014422112798, + "calibration_in_the_large": -0.0008832915946097191, + "expected_calibration_error_10bin": 0.0008832915946097191, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 4, + "negatives": 2739, + "auroc": 0.9982657904344652, + "auprc": 0.36858974358974356, + "brier": 0.0013679758626648788, + "calibration": { + "observed_rate": 0.0014582573824279985, + "mean_prediction": 0.0002682190431160065, + "calibration_in_the_large": -0.001190038339311992, + "expected_calibration_error_10bin": 0.0012662205449290504, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 4, + "negatives": 2739, + "auroc": 0.9982657904344652, + "auprc": 0.36858974358974356, + "brier": 0.0013649946764622992, + "calibration": { + "observed_rate": 0.0014582573824279985, + "mean_prediction": 0.00028364207115685083, + "calibration_in_the_large": -0.0011746153112711477, + "expected_calibration_error_10bin": 0.0012537105064826964, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 5, + "negatives": 2738, + "auroc": 0.9981738495252008, + "auprc": 0.38298368298368296, + "brier": 0.0016948854857289266, + "calibration": { + "observed_rate": 0.0018228217280349982, + "mean_prediction": 0.00036534076522938265, + "calibration_in_the_large": -0.0014574809628056155, + "expected_calibration_error_10bin": 0.0015552562113168016, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 5, + "negatives": 2738, + "auroc": 0.9981738495252008, + "auprc": 0.38298368298368296, + "brier": 0.0016887899283581152, + "calibration": { + "observed_rate": 0.0018228217280349982, + "mean_prediction": 0.0003945459167226949, + "calibration_in_the_large": -0.0014282758113123035, + "expected_calibration_error_10bin": 0.0015330803335829259, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 6, + "negatives": 2737, + "auroc": 0.9963463646328097, + "auprc": 0.34354331305550817, + "brier": 0.0020456422513317183, + "calibration": { + "observed_rate": 0.002187386073641998, + "mean_prediction": 0.00042781450472833974, + "calibration_in_the_large": -0.001759571568913658, + "expected_calibration_error_10bin": 0.001952528394699168, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 6, + "negatives": 2737, + "auroc": 0.9962854707100232, + "auprc": 0.34296259296259296, + "brier": 0.002045309920998532, + "calibration": { + "observed_rate": 0.002187386073641998, + "mean_prediction": 0.0004334055363667238, + "calibration_in_the_large": -0.001753980537275274, + "expected_calibration_error_10bin": 0.0019476824971745253, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 6, + "negatives": 2737, + "auroc": 0.9963463646328097, + "auprc": 0.34354331305550817, + "brier": 0.002039015718685359, + "calibration": { + "observed_rate": 0.002187386073641998, + "mean_prediction": 0.0004653434305526099, + "calibration_in_the_large": -0.001722042643089388, + "expected_calibration_error_10bin": 0.0019234202764087738, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 6, + "negatives": 2737, + "auroc": 0.9962854707100232, + "auprc": 0.34296259296259296, + "brier": 0.0020386722016643086, + "calibration": { + "observed_rate": 0.002187386073641998, + "mean_prediction": 0.00047115851499118083, + "calibration_in_the_large": -0.0017162275586508169, + "expected_calibration_error_10bin": 0.0019183761192714576, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 6, + "negatives": 2737, + "auroc": 0.9962854707100232, + "auprc": 0.34296259296259296, + "brier": 0.0020383184334528486, + "calibration": { + "observed_rate": 0.002187386073641998, + "mean_prediction": 0.0004770692509474173, + "calibration_in_the_large": -0.0017103168226945806, + "expected_calibration_error_10bin": 0.0019132536563721053, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 6, + "negatives": 2737, + "auroc": 0.9962854707100232, + "auprc": 0.34296259296259296, + "brier": 0.0020379538779446075, + "calibration": { + "observed_rate": 0.002187386073641998, + "mean_prediction": 0.00048306265176023284, + "calibration_in_the_large": -0.001704323421881765, + "expected_calibration_error_10bin": 0.001908066330696098, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + { + "valid": 2743, + "positives": 6, + "negatives": 2737, + "auroc": 0.9962245767872366, + "auprc": 0.34240888310655754, + "brier": 0.0020378482125342637, + "calibration": { + "observed_rate": 0.002187386073641998, + "mean_prediction": 0.00048423580082640694, + "calibration_in_the_large": -0.001703150272815591, + "expected_calibration_error_10bin": 0.0019071348270736806, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + } + ], + "reason": null + }, + "O99": { + "time_averaged_auroc": 0.936362647766238, + "time_averaged_auprc": 0.35626835588375294, + "valid_timepoint_cells": 11, + "timepoints": [ + { + "valid": 2652, + "positives": 0, + "negatives": 2652, + "auroc": null, + "auprc": null, + "brier": 6.315517477042484e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00014308598497410737, + "calibration_in_the_large": 0.00014308598497410737, + "expected_calibration_error_10bin": 0.00014308598497410737, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9328174463594794 + }, + { + "valid": 2652, + "positives": 0, + "negatives": 2652, + "auroc": null, + "auprc": null, + "brier": 1.7670989060159306e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00024023827903174705, + "calibration_in_the_large": 0.00024023827903174705, + "expected_calibration_error_10bin": 0.00024023827903174705, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9328174463594794 + }, + { + "valid": 2652, + "positives": 1, + "negatives": 2651, + "auroc": 0.999622783855149, + "auprc": 0.5, + "brier": 0.0002829014096896651, + "calibration": { + "observed_rate": 0.0003770739064856712, + "mean_prediction": 0.0002687998676402517, + "calibration_in_the_large": -0.0001082740388454195, + "expected_calibration_error_10bin": 0.00040130751082925764, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + { + "valid": 2652, + "positives": 1, + "negatives": 2651, + "auroc": 0.999622783855149, + "auprc": 0.5, + "brier": 0.00026688643454425126, + "calibration": { + "observed_rate": 0.0003770739064856712, + "mean_prediction": 0.0003163249822059584, + "calibration_in_the_large": -6.074892427971283e-05, + "expected_calibration_error_10bin": 0.0005533827459126432, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + { + "valid": 2652, + "positives": 1, + "negatives": 2651, + "auroc": 0.999622783855149, + "auprc": 0.5, + "brier": 0.00026387063020177545, + "calibration": { + "observed_rate": 0.0003770739064856712, + "mean_prediction": 0.0003344823055253996, + "calibration_in_the_large": -4.259160096027159e-05, + "expected_calibration_error_10bin": 0.0005660747930411268, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + { + "valid": 2652, + "positives": 1, + "negatives": 2651, + "auroc": 0.999622783855149, + "auprc": 0.5, + "brier": 0.0002567424305723304, + "calibration": { + "observed_rate": 0.0003770739064856712, + "mean_prediction": 0.0003776028962322673, + "calibration_in_the_large": 5.289897465961149e-07, + "expected_calibration_error_10bin": 0.0004184995713982291, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + { + "valid": 2652, + "positives": 1, + "negatives": 2651, + "auroc": 0.999622783855149, + "auprc": 0.5, + "brier": 0.0002424942508792222, + "calibration": { + "observed_rate": 0.0003770739064856712, + "mean_prediction": 0.0004393379524449908, + "calibration_in_the_large": 6.22640459593196e-05, + "expected_calibration_error_10bin": 0.00042846209384251016, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + { + "valid": 2652, + "positives": 1, + "negatives": 2651, + "auroc": 0.999622783855149, + "auprc": 0.5, + "brier": 0.00023903423186864804, + "calibration": { + "observed_rate": 0.0003770739064856712, + "mean_prediction": 0.00045970783163862104, + "calibration_in_the_large": 8.263392515294983e-05, + "expected_calibration_error_10bin": 0.0004356429058176821, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + { + "valid": 2652, + "positives": 3, + "negatives": 2649, + "auroc": 0.8637221593053983, + "auprc": 0.18428844317096468, + "brier": 0.0009887009877288765, + "calibration": { + "observed_rate": 0.0011312217194570137, + "mean_prediction": 0.0004820192536152344, + "calibration_in_the_large": -0.0006492024658417792, + "expected_calibration_error_10bin": 0.0006492024658417791, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + { + "valid": 2652, + "positives": 3, + "negatives": 2649, + "auroc": 0.8622121555303889, + "auprc": 0.1842776203966006, + "brier": 0.0009862376103759079, + "calibration": { + "observed_rate": 0.0011312217194570137, + "mean_prediction": 0.0005023423529503365, + "calibration_in_the_large": -0.0006288793665066772, + "expected_calibration_error_10bin": 0.000628879366506677, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + { + "valid": 2652, + "positives": 3, + "negatives": 2649, + "auroc": 0.8600729835157921, + "auprc": 0.18347078123614438, + "brier": 0.000981288629002661, + "calibration": { + "observed_rate": 0.0011312217194570137, + "mean_prediction": 0.0005344280612631587, + "calibration_in_the_large": -0.000596793658193855, + "expected_calibration_error_10bin": 0.0005967936581938549, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + { + "valid": 2652, + "positives": 3, + "negatives": 2649, + "auroc": 0.8580596451491129, + "auprc": 0.1834571137323431, + "brier": 0.0009810042209374274, + "calibration": { + "observed_rate": 0.0011312217194570137, + "mean_prediction": 0.0005410853327331841, + "calibration_in_the_large": -0.0005901363867238296, + "expected_calibration_error_10bin": 0.0005901363867238295, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + { + "valid": 2652, + "positives": 3, + "negatives": 2649, + "auroc": 0.8581854787970303, + "auprc": 0.18345795618522895, + "brier": 0.0009809223674354828, + "calibration": { + "observed_rate": 0.0011312217194570137, + "mean_prediction": 0.0005424401060934324, + "calibration_in_the_large": -0.0005887816133635813, + "expected_calibration_error_10bin": 0.0005887816133635811, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + } + ], + "reason": null + }, + "Q21": { + "time_averaged_auroc": 0.6980775396710523, + "time_averaged_auprc": 0.003622525532216117, + "valid_timepoint_cells": 12, + "timepoints": [ + { + "valid": 2810, + "positives": 0, + "negatives": 2810, + "auroc": null, + "auprc": null, + "brier": 2.3838998734910094e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0003163449374139719, + "calibration_in_the_large": 0.0003163449374139719, + "expected_calibration_error_10bin": 0.0003163449374139719, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 1, + "negatives": 2809, + "auroc": 0.838376646493414, + "auprc": 0.002197802197802198, + "brier": 0.00035577081781528515, + "calibration": { + "observed_rate": 0.00035587188612099647, + "mean_prediction": 0.0004565203989096967, + "calibration_in_the_large": 0.00010064851278870023, + "expected_calibration_error_10bin": 0.00010064851278870023, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 1, + "negatives": 2809, + "auroc": 0.813812744749021, + "auprc": 0.0019083969465648854, + "brier": 0.0003561447133669706, + "calibration": { + "observed_rate": 0.00035587188612099647, + "mean_prediction": 0.0006683292802038157, + "calibration_in_the_large": 0.00031245739408281925, + "expected_calibration_error_10bin": 0.00031245739408281925, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 1, + "negatives": 2809, + "auroc": 0.7924528301886793, + "auprc": 0.0017123287671232876, + "brier": 0.0003565817157898271, + "calibration": { + "observed_rate": 0.00035587188612099647, + "mean_prediction": 0.0008038818718916471, + "calibration_in_the_large": 0.0004480099857706506, + "expected_calibration_error_10bin": 0.0004480099857706506, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 2, + "negatives": 2808, + "auroc": 0.8529202279202279, + "auprc": 0.00413079923912693, + "brier": 0.0007109724445345698, + "calibration": { + "observed_rate": 0.0007117437722419929, + "mean_prediction": 0.0009673448586125951, + "calibration_in_the_large": 0.0002556010863706021, + "expected_calibration_error_10bin": 0.0002556010863706021, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 2, + "negatives": 2808, + "auroc": 0.8495370370370371, + "auprc": 0.003975521339694168, + "brier": 0.0007111054238928131, + "calibration": { + "observed_rate": 0.0007117437722419929, + "mean_prediction": 0.001021421872853265, + "calibration_in_the_large": 0.000309678100611272, + "expected_calibration_error_10bin": 0.000309678100611272, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 3, + "negatives": 2807, + "auroc": 0.5824723904524404, + "auprc": 0.0030388561298494154, + "brier": 0.001066915397400567, + "calibration": { + "observed_rate": 0.0010676156583629894, + "mean_prediction": 0.0010593660122305204, + "calibration_in_the_large": -8.24964613246903e-06, + "expected_calibration_error_10bin": 8.24964613246903e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 3, + "negatives": 2807, + "auroc": 0.5810473815461347, + "auprc": 0.0029225081715307673, + "brier": 0.0010670953038127036, + "calibration": { + "observed_rate": 0.0010676156583629894, + "mean_prediction": 0.0011296221338153662, + "calibration_in_the_large": 6.200647545237677e-05, + "expected_calibration_error_10bin": 6.200647545237677e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 3, + "negatives": 2807, + "auroc": 0.5805723785773661, + "auprc": 0.0028869419843655653, + "brier": 0.0010672408381544303, + "calibration": { + "observed_rate": 0.0010676156583629894, + "mean_prediction": 0.0011721854502901939, + "calibration_in_the_large": 0.00010456979192720447, + "expected_calibration_error_10bin": 0.00010456979192720447, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 3, + "negatives": 2807, + "auroc": 0.5800973756085975, + "auprc": 0.0028687724836871545, + "brier": 0.0010674937422478921, + "calibration": { + "observed_rate": 0.0010676156583629894, + "mean_prediction": 0.0012589480048113874, + "calibration_in_the_large": 0.00019133234644839797, + "expected_calibration_error_10bin": 0.00019133234644839797, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 4, + "negatives": 2806, + "auroc": 0.6756949394155382, + "auprc": 0.0062850526825415035, + "brier": 0.0014200436278738128, + "calibration": { + "observed_rate": 0.0014234875444839859, + "mean_prediction": 0.0013235679572428248, + "calibration_in_the_large": -9.991958724116104e-05, + "expected_calibration_error_10bin": 9.991958724116104e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 5, + "negatives": 2805, + "auroc": 0.6149019607843137, + "auprc": 0.005759013416460531, + "brier": 0.0017754769215450712, + "calibration": { + "observed_rate": 0.0017793594306049821, + "mean_prediction": 0.0014119021758997275, + "calibration_in_the_large": -0.00036745725470525457, + "expected_calibration_error_10bin": 0.00036745725470525457, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + { + "valid": 2810, + "positives": 5, + "negatives": 2805, + "auroc": 0.6150445632798573, + "auprc": 0.005784313027846994, + "brier": 0.0017754720760044726, + "calibration": { + "observed_rate": 0.0017793594306049821, + "mean_prediction": 0.001414553793624675, + "calibration_in_the_large": -0.0003648056369803072, + "expected_calibration_error_10bin": 0.0003648056369803072, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + } + ], + "reason": null + }, + "U07": { + "time_averaged_auroc": 0.8819100597499121, + "time_averaged_auprc": 0.013698525265478986, + "valid_timepoint_cells": 4, + "timepoints": [ + { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 7.319186265848692e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00048246617316464086, + "calibration_in_the_large": 0.00048246617316464086, + "expected_calibration_error_10bin": 0.00048246617316464086, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 3.945989798552895e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0008845819560432409, + "calibration_in_the_large": 0.0008845819560432409, + "expected_calibration_error_10bin": 0.0008845819560432409, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 1.0537843973456643e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001707559332915215, + "calibration_in_the_large": 0.001707559332915215, + "expected_calibration_error_10bin": 0.001707559332915215, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 1.2260576377502347e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0018328600842826782, + "calibration_in_the_large": 0.0018328600842826782, + "expected_calibration_error_10bin": 0.0018328600842826782, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 2.0299019864786516e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0023119786086015053, + "calibration_in_the_large": 0.0023119786086015053, + "expected_calibration_error_10bin": 0.0023119786086015053, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 2.5017879649588177e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0025435694796597168, + "calibration_in_the_large": 0.0025435694796597168, + "expected_calibration_error_10bin": 0.0025435694796597168, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 3.422549987073976e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0028817143641582106, + "calibration_in_the_large": 0.0028817143641582106, + "expected_calibration_error_10bin": 0.002881714364158211, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 3.966669333941653e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0030796757905893527, + "calibration_in_the_large": 0.0030796757905893527, + "expected_calibration_error_10bin": 0.003079675790589353, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 4.549322225192573e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0033061415140859633, + "calibration_in_the_large": 0.0033061415140859633, + "expected_calibration_error_10bin": 0.0033061415140859633, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.9830208701804033, + "auprc": 0.02040816326530612, + "brier": 0.00039037990369899915, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0035200370230356413, + "calibration_in_the_large": 0.0031664302337852876, + "expected_calibration_error_10bin": 0.003166430233785288, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.9502830856334041, + "auprc": 0.014273504273504274, + "brier": 0.0007422680336904923, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.003686443329326047, + "calibration_in_the_large": 0.0029792297508253397, + "expected_calibration_error_10bin": 0.0029792297508253397, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 3, + "negatives": 2825, + "auroc": 0.7971681415929204, + "auprc": 0.01005621676155277, + "brier": 0.0010989678729766766, + "calibration": { + "observed_rate": 0.0010608203677510608, + "mean_prediction": 0.0038420085001526854, + "calibration_in_the_large": 0.002781188132401625, + "expected_calibration_error_10bin": 0.002781188132401625, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + { + "valid": 2828, + "positives": 3, + "negatives": 2825, + "auroc": 0.7971681415929204, + "auprc": 0.01005621676155277, + "brier": 0.0010992755012293393, + "calibration": { + "observed_rate": 0.0010608203677510608, + "mean_prediction": 0.0038521469430909464, + "calibration_in_the_large": 0.0027913265753398853, + "expected_calibration_error_10bin": 0.0027913265753398853, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + } + ], + "reason": null + } + }, + "30": { + "A04": { + "valid": 2782, + "positives": 3, + "negatives": 2779, + "auroc": 0.815881012354564, + "auprc": 0.020274151758257402, + "brier": 0.0010793648855543794, + "calibration": { + "observed_rate": 0.0010783608914450035, + "mean_prediction": 0.002781798076584872, + "calibration_in_the_large": 0.0017034371851398684, + "expected_calibration_error_10bin": 0.0017034371851398684, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "A08": { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.6975471027372911, + "auprc": 0.014463583260444671, + "brier": 0.0017680112453248645, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0006777897598999338, + "calibration_in_the_large": -0.001096518259972316, + "expected_calibration_error_10bin": 0.001096518259972316, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "A41": { + "valid": 2664, + "positives": 5, + "negatives": 2659, + "auroc": 0.7462203836028583, + "auprc": 0.008083531699572263, + "brier": 0.0019171454312153485, + "calibration": { + "observed_rate": 0.0018768768768768769, + "mean_prediction": 0.005080742696752002, + "calibration_in_the_large": 0.0032038658198751246, + "expected_calibration_error_10bin": 0.0032038658198751246, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + "B00": { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 8.428952619159184e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00016096267806259675, + "calibration_in_the_large": 0.00016096267806259675, + "expected_calibration_error_10bin": 0.00016096267806259675, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "B02": { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 1.8999213602812124e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00014674968090446248, + "calibration_in_the_large": 0.00014674968090446248, + "expected_calibration_error_10bin": 0.00014674968090446248, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "B18": { + "valid": 2782, + "positives": 1, + "negatives": 2781, + "auroc": 0.9938870909744696, + "auprc": 0.05555555555555555, + "brier": 0.00035615960067015765, + "calibration": { + "observed_rate": 0.0003594536304816679, + "mean_prediction": 0.0002320223765636659, + "calibration_in_the_large": -0.00012743125391800197, + "expected_calibration_error_10bin": 0.00012743125391800197, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "B19": { + "valid": 2763, + "positives": 7, + "negatives": 2756, + "auroc": 0.8084698320547378, + "auprc": 0.011870507138740724, + "brier": 0.002529944852090597, + "calibration": { + "observed_rate": 0.0025334781035106766, + "mean_prediction": 0.0004342344789001747, + "calibration_in_the_large": -0.002099243624610502, + "expected_calibration_error_10bin": 0.002099243624610502, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "B20": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 5.234367019896663e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 8.015299245050204e-05, + "calibration_in_the_large": 8.015299245050204e-05, + "expected_calibration_error_10bin": 8.015299245050204e-05, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "B34": { + "valid": 2831, + "positives": 0, + "negatives": 2831, + "auroc": null, + "auprc": null, + "brier": 2.2374879145328458e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00017572632694629826, + "calibration_in_the_large": 0.00017572632694629826, + "expected_calibration_error_10bin": 0.00017572632694629826, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.995779106577559 + }, + "B35": { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 2.9273903497076196e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0002618243110999216, + "calibration_in_the_large": 0.0002618243110999216, + "expected_calibration_error_10bin": 0.0002618243110999216, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "B37": { + "valid": 2768, + "positives": 8, + "negatives": 2760, + "auroc": 0.8608242753623189, + "auprc": 0.016128633062346964, + "brier": 0.0028723088174688063, + "calibration": { + "observed_rate": 0.002890173410404624, + "mean_prediction": 0.0018573069000895974, + "calibration_in_the_large": -0.0010328665103150267, + "expected_calibration_error_10bin": 0.0010328665103150267, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "B95": { + "valid": 2678, + "positives": 15, + "negatives": 2663, + "auroc": 0.6624608837151083, + "auprc": 0.017574134887788855, + "brier": 0.005568539745483353, + "calibration": { + "observed_rate": 0.005601194921583271, + "mean_prediction": 0.006088700011777107, + "calibration_in_the_large": 0.00048750509019383596, + "expected_calibration_error_10bin": 0.00048750509019383596, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + "B96": { + "valid": 2630, + "positives": 15, + "negatives": 2615, + "auroc": 0.790031867431485, + "auprc": 0.019596165838812574, + "brier": 0.005658063159457557, + "calibration": { + "observed_rate": 0.005703422053231939, + "mean_prediction": 0.008594121435500448, + "calibration_in_the_large": 0.0028906993822685086, + "expected_calibration_error_10bin": 0.0028906993822685086, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + "B97": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.6215068977714893, + "auprc": 0.0009337068160597573, + "brier": 0.0003536997697645465, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 7.740961095289513e-05, + "calibration_in_the_large": -0.0002761971782974585, + "expected_calibration_error_10bin": 0.0002761971782974585, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "C18": { + "valid": 2824, + "positives": 1, + "negatives": 2823, + "auroc": 0.9943322706340773, + "auprc": 0.058823529411764705, + "brier": 0.0003528838931479987, + "calibration": { + "observed_rate": 0.0003541076487252125, + "mean_prediction": 0.0001547864331755465, + "calibration_in_the_large": -0.00019932121554966598, + "expected_calibration_error_10bin": 0.00019932121554966598, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "C22": { + "valid": 2812, + "positives": 2, + "negatives": 2810, + "auroc": 0.9208185053380783, + "auprc": 0.04396024464831804, + "brier": 0.0007060678283516284, + "calibration": { + "observed_rate": 0.0007112375533428165, + "mean_prediction": 0.00027875212895846153, + "calibration_in_the_large": -0.000432485424384355, + "expected_calibration_error_10bin": 0.000432485424384355, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + "C25": { + "valid": 2809, + "positives": 0, + "negatives": 2809, + "auroc": null, + "auprc": null, + "brier": 1.2233215113879197e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00012656371625303182, + "calibration_in_the_large": 0.00012656371625303182, + "expected_calibration_error_10bin": 0.00012656371625303182, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "C61": { + "valid": 2805, + "positives": 1, + "negatives": 2804, + "auroc": 0.9860912981455064, + "auprc": 0.025, + "brier": 0.00035549043991589166, + "calibration": { + "observed_rate": 0.00035650623885918, + "mean_prediction": 0.00020481075376906663, + "calibration_in_the_large": -0.0001516954850901134, + "expected_calibration_error_10bin": 0.0001516954850901134, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "C67": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9419879731163778, + "auprc": 0.018507219849501728, + "brier": 0.0007059142735014069, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.00014203626397502598, + "calibration_in_the_large": -0.0005649273274000182, + "expected_calibration_error_10bin": 0.0005649273274000182, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "C77": { + "valid": 2762, + "positives": 4, + "negatives": 2758, + "auroc": 0.7873459028281363, + "auprc": 0.1472339260792146, + "brier": 0.0013895700102996686, + "calibration": { + "observed_rate": 0.001448225923244026, + "mean_prediction": 0.0011123982056656023, + "calibration_in_the_large": -0.0003358277175784237, + "expected_calibration_error_10bin": 0.0003358277175784237, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C78": { + "valid": 2762, + "positives": 7, + "negatives": 2755, + "auroc": 0.947005444646098, + "auprc": 0.12373446943095467, + "brier": 0.002405684190859022, + "calibration": { + "observed_rate": 0.0025343953656770456, + "mean_prediction": 0.0015402597410777582, + "calibration_in_the_large": -0.0009941356245992874, + "expected_calibration_error_10bin": 0.0014139004182694389, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C79": { + "valid": 2751, + "positives": 4, + "negatives": 2747, + "auroc": 0.9277393520203858, + "auprc": 0.0955394434072852, + "brier": 0.0014052405723874984, + "calibration": { + "observed_rate": 0.0014540167211922936, + "mean_prediction": 0.0016964700996565058, + "calibration_in_the_large": 0.00024245337846421212, + "expected_calibration_error_10bin": 0.00024245337846421207, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "C83": { + "valid": 2820, + "positives": 0, + "negatives": 2820, + "auroc": null, + "auprc": null, + "brier": 1.2255049540225954e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00012363318808071095, + "calibration_in_the_large": 0.00012363318808071095, + "expected_calibration_error_10bin": 0.00012363318808071095, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "D25": { + "valid": 2792, + "positives": 2, + "negatives": 2790, + "auroc": 0.932258064516129, + "auprc": 0.1276525198938992, + "brier": 0.0007145557782585815, + "calibration": { + "observed_rate": 0.0007163323782234957, + "mean_prediction": 0.0001263426421963363, + "calibration_in_the_large": -0.0005899897360271593, + "expected_calibration_error_10bin": 0.0005899897360271593, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "D47": { + "valid": 2796, + "positives": 4, + "negatives": 2792, + "auroc": 0.7215257879656161, + "auprc": 0.0038288518198131573, + "brier": 0.0014310353570118443, + "calibration": { + "observed_rate": 0.001430615164520744, + "mean_prediction": 0.0012580696375595298, + "calibration_in_the_large": -0.0001725455269612141, + "expected_calibration_error_10bin": 0.0001725455269612141, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "D50": { + "valid": 2663, + "positives": 15, + "negatives": 2648, + "auroc": 0.7870090634441088, + "auprc": 0.04176393411798029, + "brier": 0.005524448847326335, + "calibration": { + "observed_rate": 0.005632745024408562, + "mean_prediction": 0.003945808796176623, + "calibration_in_the_large": -0.0016869362282319385, + "expected_calibration_error_10bin": 0.0016869362282319385, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + "D53": { + "valid": 2805, + "positives": 5, + "negatives": 2800, + "auroc": 0.7966428571428571, + "auprc": 0.016301319484265397, + "brier": 0.0017734044510107694, + "calibration": { + "observed_rate": 0.0017825311942959, + "mean_prediction": 0.0012750843343574468, + "calibration_in_the_large": -0.0005074468599384533, + "expected_calibration_error_10bin": 0.0005074468599384533, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "D59": { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 2.5143563119556716e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00022820042579560796, + "calibration_in_the_large": 0.00022820042579560796, + "expected_calibration_error_10bin": 0.00022820042579560796, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "D61": { + "valid": 2773, + "positives": 4, + "negatives": 2769, + "auroc": 0.9665944384254244, + "auprc": 0.02536786786786787, + "brier": 0.0014428662002351907, + "calibration": { + "observed_rate": 0.00144248106743599, + "mean_prediction": 0.001512894662284949, + "calibration_in_the_large": 7.041359484895901e-05, + "expected_calibration_error_10bin": 7.041359484895912e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "D62": { + "valid": 2499, + "positives": 10, + "negatives": 2489, + "auroc": 0.8008437123342708, + "auprc": 0.01887950441253526, + "brier": 0.003972297655459969, + "calibration": { + "observed_rate": 0.004001600640256103, + "mean_prediction": 0.006544245297289813, + "calibration_in_the_large": 0.0025426446570337106, + "expected_calibration_error_10bin": 0.0025426446570337106, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + "D63": { + "valid": 2686, + "positives": 20, + "negatives": 2666, + "auroc": 0.9210240060015004, + "auprc": 0.06691482178737743, + "brier": 0.007169995681982845, + "calibration": { + "observed_rate": 0.007446016381236039, + "mean_prediction": 0.005643855671737045, + "calibration_in_the_large": -0.001802160709498994, + "expected_calibration_error_10bin": 0.0030322709996950725, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + "D64": { + "valid": 2434, + "positives": 37, + "negatives": 2397, + "auroc": 0.8465875136713685, + "auprc": 0.0840596593616801, + "brier": 0.014506551242183441, + "calibration": { + "observed_rate": 0.015201314708299097, + "mean_prediction": 0.013306173589979754, + "calibration_in_the_large": -0.0018951411183193434, + "expected_calibration_error_10bin": 0.0018951411183193434, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + "D65": { + "valid": 2833, + "positives": 1, + "negatives": 2832, + "auroc": 0.9477401129943502, + "auprc": 0.006711409395973154, + "brier": 0.00035313974160504173, + "calibration": { + "observed_rate": 0.00035298270384751147, + "mean_prediction": 0.0002695634925698071, + "calibration_in_the_large": -8.341921127770437e-05, + "expected_calibration_error_10bin": 8.341921127770437e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + "D68": { + "valid": 2682, + "positives": 10, + "negatives": 2672, + "auroc": 0.8525823353293414, + "auprc": 0.03561724006498467, + "brier": 0.0036721880820170705, + "calibration": { + "observed_rate": 0.0037285607755406414, + "mean_prediction": 0.0028985177241928587, + "calibration_in_the_large": -0.0008300430513477827, + "expected_calibration_error_10bin": 0.0008300430513477827, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + "D69": { + "valid": 2586, + "positives": 13, + "negatives": 2573, + "auroc": 0.8973063469759933, + "auprc": 0.1758423646888154, + "brier": 0.004737900005876372, + "calibration": { + "observed_rate": 0.005027068832173241, + "mean_prediction": 0.0044167870241663435, + "calibration_in_the_large": -0.0006102818080068973, + "expected_calibration_error_10bin": 0.0006102818080068967, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + "D70": { + "valid": 2787, + "positives": 5, + "negatives": 2782, + "auroc": 0.9329259525521207, + "auprc": 0.2549895858589483, + "brier": 0.0016835945166211543, + "calibration": { + "observed_rate": 0.001794043774668102, + "mean_prediction": 0.0016390292514826643, + "calibration_in_the_large": -0.00015501452318543766, + "expected_calibration_error_10bin": 0.00018578889638434494, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "D72": { + "valid": 2595, + "positives": 16, + "negatives": 2579, + "auroc": 0.7388037999224506, + "auprc": 0.06220558143263286, + "brier": 0.006061457512180186, + "calibration": { + "observed_rate": 0.006165703275529865, + "mean_prediction": 0.006790034401343565, + "calibration_in_the_large": 0.0006243311258136994, + "expected_calibration_error_10bin": 0.0006243311258136994, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + "D73": { + "valid": 2824, + "positives": 0, + "negatives": 2824, + "auroc": null, + "auprc": null, + "brier": 3.2270743261077267e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00030420228418787505, + "calibration_in_the_large": 0.00030420228418787505, + "expected_calibration_error_10bin": 0.00030420228418787505, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "D75": { + "valid": 2831, + "positives": 0, + "negatives": 2831, + "auroc": null, + "auprc": null, + "brier": 2.0832965407355065e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0003042988700803543, + "calibration_in_the_large": 0.0003042988700803543, + "expected_calibration_error_10bin": 0.0003042988700803543, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.995779106577559 + }, + "D80": { + "valid": 2832, + "positives": 1, + "negatives": 2831, + "auroc": 0.986930413281526, + "auprc": 0.02631578947368421, + "brier": 0.00035243942525111055, + "calibration": { + "observed_rate": 0.00035310734463276836, + "mean_prediction": 0.00023331761971031602, + "calibration_in_the_large": -0.00011978972492245234, + "expected_calibration_error_10bin": 0.00011978972492245234, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "D89": { + "valid": 2837, + "positives": 1, + "negatives": 2836, + "auroc": 0.9601551480959097, + "auprc": 0.008771929824561403, + "brier": 0.0003529288559432424, + "calibration": { + "observed_rate": 0.00035248501938667606, + "mean_prediction": 6.148695924008289e-05, + "calibration_in_the_large": -0.00029099806014659316, + "expected_calibration_error_10bin": 0.00029099806014659316, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "E03": { + "valid": 2480, + "positives": 7, + "negatives": 2473, + "auroc": 0.7517185604528912, + "auprc": 0.007217916326414894, + "brier": 0.0028135872878334352, + "calibration": { + "observed_rate": 0.00282258064516129, + "mean_prediction": 0.0014328864125702475, + "calibration_in_the_large": -0.0013896942325910427, + "expected_calibration_error_10bin": 0.0013896942325910427, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + "E04": { + "valid": 2775, + "positives": 3, + "negatives": 2772, + "auroc": 0.7146464646464646, + "auprc": 0.004262913629629096, + "brier": 0.0010799370709230424, + "calibration": { + "observed_rate": 0.001081081081081081, + "mean_prediction": 0.0004726489342145804, + "calibration_in_the_large": -0.0006084321468665006, + "expected_calibration_error_10bin": 0.0006084321468665006, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "E05": { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.10823823109843081, + "auprc": 0.0005870878624710697, + "brier": 0.000712894068375789, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0003069746433614164, + "calibration_in_the_large": -0.00040578373154948885, + "expected_calibration_error_10bin": 0.00040578373154948885, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "E11": { + "valid": 2194, + "positives": 6, + "negatives": 2188, + "auroc": 0.6793113954905545, + "auprc": 0.05963132271760544, + "brier": 0.0027070375469001053, + "calibration": { + "observed_rate": 0.0027347310847766638, + "mean_prediction": 0.00206814515841027, + "calibration_in_the_large": -0.0006665859263663937, + "expected_calibration_error_10bin": 0.0006665859263663937, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + "E16": { + "valid": 2816, + "positives": 1, + "negatives": 2815, + "auroc": 0.7904085257548845, + "auprc": 0.001692047377326565, + "brier": 0.00035586365100828324, + "calibration": { + "observed_rate": 0.0003551136363636364, + "mean_prediction": 0.0005583668758882125, + "calibration_in_the_large": 0.0002032532395245761, + "expected_calibration_error_10bin": 0.0002032532395245761, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "E21": { + "valid": 2814, + "positives": 1, + "negatives": 2813, + "auroc": 0.9786704585851405, + "auprc": 0.01639344262295082, + "brier": 0.000354782801311867, + "calibration": { + "observed_rate": 0.00035536602700781805, + "mean_prediction": 0.000441302159830506, + "calibration_in_the_large": 8.593613282268796e-05, + "expected_calibration_error_10bin": 8.593613282268796e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "E22": { + "valid": 2802, + "positives": 3, + "negatives": 2799, + "auroc": 0.834702870072645, + "auprc": 0.004710651087333477, + "brier": 0.0010762156512438897, + "calibration": { + "observed_rate": 0.0010706638115631692, + "mean_prediction": 0.0015715481970286396, + "calibration_in_the_large": 0.0005008843854654704, + "expected_calibration_error_10bin": 0.0005008843854654704, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "E27": { + "valid": 2811, + "positives": 0, + "negatives": 2811, + "auroc": null, + "auprc": null, + "brier": 1.7228816111291856e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0006511066311737025, + "calibration_in_the_large": 0.0006511066311737025, + "expected_calibration_error_10bin": 0.0006511066311737025, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9887442842068238 + }, + "E43": { + "valid": 2748, + "positives": 14, + "negatives": 2734, + "auroc": 0.8604347371721183, + "auprc": 0.04382073656929226, + "brier": 0.005001817429788346, + "calibration": { + "observed_rate": 0.005094614264919942, + "mean_prediction": 0.002650999514367058, + "calibration_in_the_large": -0.002443614750552884, + "expected_calibration_error_10bin": 0.002443614750552884, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + "E44": { + "valid": 2800, + "positives": 5, + "negatives": 2795, + "auroc": 0.7128443649373882, + "auprc": 0.011685079989700609, + "brier": 0.0017833739369731523, + "calibration": { + "observed_rate": 0.0017857142857142857, + "mean_prediction": 0.00226576967780602, + "calibration_in_the_large": 0.00048005539209173436, + "expected_calibration_error_10bin": 0.00048005539209173436, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "E46": { + "valid": 2772, + "positives": 10, + "negatives": 2762, + "auroc": 0.7712889210716872, + "auprc": 0.018472652040638995, + "brier": 0.003611060565307189, + "calibration": { + "observed_rate": 0.0036075036075036075, + "mean_prediction": 0.0035804447792911346, + "calibration_in_the_large": -2.705882821247294e-05, + "expected_calibration_error_10bin": 0.00035088865390586787, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + "E53": { + "valid": 2804, + "positives": 1, + "negatives": 2803, + "auroc": 0.8965394220478059, + "auprc": 0.003436426116838488, + "brier": 0.0003577204554555446, + "calibration": { + "observed_rate": 0.0003566333808844508, + "mean_prediction": 0.000617346578059782, + "calibration_in_the_large": 0.00026071319717533117, + "expected_calibration_error_10bin": 0.00026071319717533117, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "E55": { + "valid": 2737, + "positives": 9, + "negatives": 2728, + "auroc": 0.4906321277289019, + "auprc": 0.004237323538564416, + "brier": 0.003290274412954896, + "calibration": { + "observed_rate": 0.003288271830471319, + "mean_prediction": 0.002197186647103909, + "calibration_in_the_large": -0.0010910851833674101, + "expected_calibration_error_10bin": 0.0010910851833674101, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + "E66": { + "valid": 2371, + "positives": 9, + "negatives": 2362, + "auroc": 0.7173299463731301, + "auprc": 0.009509562193279949, + "brier": 0.0037813850079391675, + "calibration": { + "observed_rate": 0.003795866722901729, + "mean_prediction": 0.004001063903538522, + "calibration_in_the_large": 0.0002051971806367927, + "expected_calibration_error_10bin": 0.0002051971806367927, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + "E78": { + "valid": 1572, + "positives": 13, + "negatives": 1559, + "auroc": 0.6244140721369714, + "auprc": 0.02169925070159869, + "brier": 0.00819463471532225, + "calibration": { + "observed_rate": 0.00826972010178117, + "mean_prediction": 0.0058900309239976875, + "calibration_in_the_large": -0.0023796891777834823, + "expected_calibration_error_10bin": 0.0023796891777834823, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + "E80": { + "valid": 2823, + "positives": 2, + "negatives": 2821, + "auroc": 0.9608294930875576, + "auprc": 0.013578201233545062, + "brier": 0.0007106666727370216, + "calibration": { + "observed_rate": 0.0007084661707403471, + "mean_prediction": 0.0005722033171757001, + "calibration_in_the_large": -0.00013626285356464708, + "expected_calibration_error_10bin": 0.00013626285356464708, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "E83": { + "valid": 2653, + "positives": 14, + "negatives": 2639, + "auroc": 0.8879987008065826, + "auprc": 0.0816843950853339, + "brier": 0.005104346467039365, + "calibration": { + "observed_rate": 0.005277044854881266, + "mean_prediction": 0.0050266449560034425, + "calibration_in_the_large": -0.00025039989887782384, + "expected_calibration_error_10bin": 0.00025039989887782384, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + "E86": { + "valid": 2587, + "positives": 26, + "negatives": 2561, + "auroc": 0.8274111675126904, + "auprc": 0.05702337047035667, + "brier": 0.009759506050931377, + "calibration": { + "observed_rate": 0.010050251256281407, + "mean_prediction": 0.01208489161818337, + "calibration_in_the_large": 0.0020346403619019623, + "expected_calibration_error_10bin": 0.0020346403619019623, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + "E87": { + "valid": 2185, + "positives": 31, + "negatives": 2154, + "auroc": 0.7842423697846467, + "auprc": 0.054975322393395795, + "brier": 0.013730941003144509, + "calibration": { + "observed_rate": 0.014187643020594966, + "mean_prediction": 0.014368746417107857, + "calibration_in_the_large": 0.0001811033965128904, + "expected_calibration_error_10bin": 0.0010862337342235386, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + "E88": { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.9419568822553898, + "auprc": 0.06510474498482494, + "brier": 0.0010565891342337065, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.0008872731105711018, + "calibration_in_the_large": -0.00017768961573347763, + "expected_calibration_error_10bin": 0.00017768961573347763, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "E89": { + "valid": 2780, + "positives": 3, + "negatives": 2777, + "auroc": 0.8560797023166486, + "auprc": 0.004771341730135063, + "brier": 0.0010770286333699475, + "calibration": { + "observed_rate": 0.001079136690647482, + "mean_prediction": 0.0011284554683913858, + "calibration_in_the_large": 4.93187777439038e-05, + "expected_calibration_error_10bin": 4.93187777439038e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "F02": { + "valid": 2802, + "positives": 0, + "negatives": 2802, + "auroc": null, + "auprc": null, + "brier": 2.0103656679519883e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0005346107848933377, + "calibration_in_the_large": 0.0005346107848933377, + "expected_calibration_error_10bin": 0.0005346107848933377, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "F03": { + "valid": 2739, + "positives": 5, + "negatives": 2734, + "auroc": 0.8440380395025604, + "auprc": 0.007271384500148167, + "brier": 0.0018254557877024683, + "calibration": { + "observed_rate": 0.0018254837531945967, + "mean_prediction": 0.0014793293101128565, + "calibration_in_the_large": -0.00034615444308174013, + "expected_calibration_error_10bin": 0.00034615444308174013, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "F05": { + "valid": 2750, + "positives": 1, + "negatives": 2749, + "auroc": 0.9970898508548564, + "auprc": 0.1111111111111111, + "brier": 0.0003691368736340336, + "calibration": { + "observed_rate": 0.0003636363636363636, + "mean_prediction": 0.002552933731197382, + "calibration_in_the_large": 0.0021892973675610183, + "expected_calibration_error_10bin": 0.0021892973675610183, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "F06": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.6636009904492395, + "auprc": 0.0010504201680672268, + "brier": 0.00035475720640890156, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0006378291176861111, + "calibration_in_the_large": 0.0002842223284357575, + "expected_calibration_error_10bin": 0.0002842223284357575, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "F10": { + "valid": 2560, + "positives": 5, + "negatives": 2555, + "auroc": 0.8631702544031311, + "auprc": 0.11417058066958186, + "brier": 0.0018999677205351368, + "calibration": { + "observed_rate": 0.001953125, + "mean_prediction": 0.002374229365869951, + "calibration_in_the_large": 0.0004211043658699509, + "expected_calibration_error_10bin": 0.00042110436586995114, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "F11": { + "valid": 2741, + "positives": 4, + "negatives": 2737, + "auroc": 0.9763427109974424, + "auprc": 0.084816859969299, + "brier": 0.0014290816759318463, + "calibration": { + "observed_rate": 0.001459321415541773, + "mean_prediction": 0.0012393619503265206, + "calibration_in_the_large": -0.00021995946521525243, + "expected_calibration_error_10bin": 0.0003130613332236541, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "F12": { + "valid": 2777, + "positives": 5, + "negatives": 2772, + "auroc": 0.9434343434343434, + "auprc": 0.0208145202691981, + "brier": 0.0017867499208269937, + "calibration": { + "observed_rate": 0.0018005041411595247, + "mean_prediction": 0.0011196377654663298, + "calibration_in_the_large": -0.0006808663756931949, + "expected_calibration_error_10bin": 0.0006808663756931949, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "F14": { + "valid": 2787, + "positives": 4, + "negatives": 2783, + "auroc": 0.9771828961552281, + "auprc": 0.04084889511360099, + "brier": 0.001426023161772527, + "calibration": { + "observed_rate": 0.0014352350197344816, + "mean_prediction": 0.00033946911981366616, + "calibration_in_the_large": -0.0010957658999208154, + "expected_calibration_error_10bin": 0.0010957658999208154, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "F15": { + "valid": 2823, + "positives": 4, + "negatives": 2819, + "auroc": 0.9852784675416815, + "auprc": 0.07059576023391813, + "brier": 0.0014073477231448417, + "calibration": { + "observed_rate": 0.0014169323414806943, + "mean_prediction": 0.00018654697625461084, + "calibration_in_the_large": -0.0012303853652260834, + "expected_calibration_error_10bin": 0.0012303853652260834, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "F17": { + "valid": 2426, + "positives": 13, + "negatives": 2413, + "auroc": 0.8745576843380407, + "auprc": 0.0938430876064622, + "brier": 0.005168942846855446, + "calibration": { + "observed_rate": 0.0053586150041220115, + "mean_prediction": 0.004880520753296521, + "calibration_in_the_large": -0.0004780942508254907, + "expected_calibration_error_10bin": 0.000478094250825491, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + "F19": { + "valid": 2801, + "positives": 6, + "negatives": 2795, + "auroc": 0.9768634466308885, + "auprc": 0.19239426612307967, + "brier": 0.0020892739854102174, + "calibration": { + "observed_rate": 0.0021420921099607284, + "mean_prediction": 0.0005222175708940907, + "calibration_in_the_large": -0.0016198745390666376, + "expected_calibration_error_10bin": 0.0016198745390666376, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F20": { + "valid": 2808, + "positives": 0, + "negatives": 2808, + "auroc": null, + "auprc": null, + "brier": 1.9633565381693165e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00015679541127844247, + "calibration_in_the_large": 0.00015679541127844247, + "expected_calibration_error_10bin": 0.00015679541127844247, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9876890608512136 + }, + "F22": { + "valid": 2821, + "positives": 0, + "negatives": 2821, + "auroc": null, + "auprc": null, + "brier": 7.186541796773733e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.000358207472912005, + "calibration_in_the_large": 0.000358207472912005, + "expected_calibration_error_10bin": 0.000358207472912005, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "F25": { + "valid": 2819, + "positives": 1, + "negatives": 2818, + "auroc": 0.9779985805535841, + "auprc": 0.015873015873015872, + "brier": 0.00035396205286104343, + "calibration": { + "observed_rate": 0.000354735721887194, + "mean_prediction": 0.000226588722552583, + "calibration_in_the_large": -0.000128146999334611, + "expected_calibration_error_10bin": 0.000128146999334611, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "F29": { + "valid": 2806, + "positives": 3, + "negatives": 2803, + "auroc": 0.7734570103460578, + "auprc": 0.0035550749228473455, + "brier": 0.0010686678872460107, + "calibration": { + "observed_rate": 0.0010691375623663579, + "mean_prediction": 0.00018687211599953326, + "calibration_in_the_large": -0.0008822654463668246, + "expected_calibration_error_10bin": 0.0008822654463668246, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "F31": { + "valid": 2724, + "positives": 5, + "negatives": 2719, + "auroc": 0.8931224714968738, + "auprc": 0.016052859015979, + "brier": 0.0018256131926110075, + "calibration": { + "observed_rate": 0.0018355359765051395, + "mean_prediction": 0.0011247984468118455, + "calibration_in_the_large": -0.0007107375296932939, + "expected_calibration_error_10bin": 0.0007107375296932939, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + "F32": { + "valid": 2200, + "positives": 16, + "negatives": 2184, + "auroc": 0.6871565934065934, + "auprc": 0.02537710550005707, + "brier": 0.007344154136464515, + "calibration": { + "observed_rate": 0.007272727272727273, + "mean_prediction": 0.012888302964645184, + "calibration_in_the_large": 0.005615575691917911, + "expected_calibration_error_10bin": 0.005615575691917911, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + "F33": { + "valid": 2800, + "positives": 6, + "negatives": 2794, + "auroc": 0.7987950369840133, + "auprc": 0.011287032342103648, + "brier": 0.0021454553209119885, + "calibration": { + "observed_rate": 0.002142857142857143, + "mean_prediction": 0.0013980702991193538, + "calibration_in_the_large": -0.0007447868437377892, + "expected_calibration_error_10bin": 0.0007447868437377892, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "F39": { + "valid": 2801, + "positives": 5, + "negatives": 2796, + "auroc": 0.8170243204577968, + "auprc": 0.012407380316201868, + "brier": 0.0017802378735668988, + "calibration": { + "observed_rate": 0.001785076758300607, + "mean_prediction": 0.0005902562642060657, + "calibration_in_the_large": -0.0011948204940945414, + "expected_calibration_error_10bin": 0.0011948204940945414, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F41": { + "valid": 2247, + "positives": 16, + "negatives": 2231, + "auroc": 0.757675930076199, + "auprc": 0.0364091799320598, + "brier": 0.007004170316305385, + "calibration": { + "observed_rate": 0.007120605251446373, + "mean_prediction": 0.010912821266214099, + "calibration_in_the_large": 0.0037922160147677263, + "expected_calibration_error_10bin": 0.0037922160147677263, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + "F43": { + "valid": 2734, + "positives": 6, + "negatives": 2728, + "auroc": 0.9218597262952102, + "auprc": 0.0423821355998247, + "brier": 0.0021531603788734924, + "calibration": { + "observed_rate": 0.0021945866861741038, + "mean_prediction": 0.0024455146227927915, + "calibration_in_the_large": 0.00025092793661868774, + "expected_calibration_error_10bin": 0.00025092793661868774, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "F60": { + "valid": 2818, + "positives": 2, + "negatives": 2816, + "auroc": 0.9541903409090909, + "auprc": 0.016740576496674056, + "brier": 0.000707398398652512, + "calibration": { + "observed_rate": 0.0007097232079489, + "mean_prediction": 0.00046576865804960984, + "calibration_in_the_large": -0.00024395454989929011, + "expected_calibration_error_10bin": 0.00024395454989929011, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "F90": { + "valid": 2775, + "positives": 3, + "negatives": 2772, + "auroc": 0.7824675324675324, + "auprc": 0.010930268952502443, + "brier": 0.0010798180563237993, + "calibration": { + "observed_rate": 0.001081081081081081, + "mean_prediction": 0.0001998405405513925, + "calibration_in_the_large": -0.0008812405405296886, + "expected_calibration_error_10bin": 0.0008812405405296886, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "G25": { + "valid": 2774, + "positives": 1, + "negatives": 2773, + "auroc": 0.985935809592499, + "auprc": 0.025, + "brier": 0.00035912982666402236, + "calibration": { + "observed_rate": 0.0003604902667627974, + "mean_prediction": 0.0007825514503585172, + "calibration_in_the_large": 0.00042206118359571984, + "expected_calibration_error_10bin": 0.00042206118359571984, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "G31": { + "valid": 2802, + "positives": 0, + "negatives": 2802, + "auroc": null, + "auprc": null, + "brier": 3.1134672150705148e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0007885831621152945, + "calibration_in_the_large": 0.0007885831621152945, + "expected_calibration_error_10bin": 0.0007885831621152945, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "G40": { + "valid": 2723, + "positives": 6, + "negatives": 2717, + "auroc": 0.7615016562384983, + "auprc": 0.027198741548825258, + "brier": 0.0021834221778918943, + "calibration": { + "observed_rate": 0.0022034520749173708, + "mean_prediction": 0.0021622767884910766, + "calibration_in_the_large": -4.117528642629421e-05, + "expected_calibration_error_10bin": 4.117528642629421e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "G43": { + "valid": 2725, + "positives": 3, + "negatives": 2722, + "auroc": 0.8196179279941219, + "auprc": 0.005464489347010837, + "brier": 0.001099284253773928, + "calibration": { + "observed_rate": 0.0011009174311926607, + "mean_prediction": 0.0009006818050346145, + "calibration_in_the_large": -0.0002002356261580462, + "expected_calibration_error_10bin": 0.0002002356261580462, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + "G44": { + "valid": 2805, + "positives": 1, + "negatives": 2804, + "auroc": 0.7129101283880172, + "auprc": 0.0012406947890818859, + "brier": 0.00035722476851447754, + "calibration": { + "observed_rate": 0.00035650623885918, + "mean_prediction": 0.0005698580778238248, + "calibration_in_the_large": 0.00021335183896464474, + "expected_calibration_error_10bin": 0.00021335183896464474, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "G47": { + "valid": 2315, + "positives": 23, + "negatives": 2292, + "auroc": 0.6951969041657182, + "auprc": 0.0295123114066248, + "brier": 0.009779726991732789, + "calibration": { + "observed_rate": 0.009935205183585313, + "mean_prediction": 0.007993078958376393, + "calibration_in_the_large": -0.0019421262252089198, + "expected_calibration_error_10bin": 0.0019421262252089198, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + "G51": { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 4.6965958738453605e-08, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00014442844577666232, + "calibration_in_the_large": 0.00014442844577666232, + "expected_calibration_error_10bin": 0.00014442844577666232, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + "G62": { + "valid": 2751, + "positives": 7, + "negatives": 2744, + "auroc": 0.8212203248646397, + "auprc": 0.15891577142697472, + "brier": 0.0025072441806071144, + "calibration": { + "observed_rate": 0.002544529262086514, + "mean_prediction": 0.0013403629474295108, + "calibration_in_the_large": -0.0012041663146570034, + "expected_calibration_error_10bin": 0.0012041663146570034, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "G81": { + "valid": 2789, + "positives": 8, + "negatives": 2781, + "auroc": 0.7559780654440849, + "auprc": 0.027142790622865426, + "brier": 0.002858145089443252, + "calibration": { + "observed_rate": 0.0028684116170670493, + "mean_prediction": 0.0006486478635684441, + "calibration_in_the_large": -0.002219763753498605, + "expected_calibration_error_10bin": 0.002219763753498605, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "G83": { + "valid": 2824, + "positives": 1, + "negatives": 2823, + "auroc": 0.5614594403117251, + "auprc": 0.0008071025020177562, + "brier": 0.0003548358611778002, + "calibration": { + "observed_rate": 0.0003541076487252125, + "mean_prediction": 0.00036944198777813986, + "calibration_in_the_large": 1.5334339052927375e-05, + "expected_calibration_error_10bin": 1.5334339052927375e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "G89": { + "valid": 2537, + "positives": 15, + "negatives": 2522, + "auroc": 0.7335976738038593, + "auprc": 0.023349194964273495, + "brier": 0.005879625836268523, + "calibration": { + "observed_rate": 0.005912495072920773, + "mean_prediction": 0.008229355443351427, + "calibration_in_the_large": 0.0023168603704306545, + "expected_calibration_error_10bin": 0.002316860370430655, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + "G90": { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 5.657795265382998e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004053380320493589, + "calibration_in_the_large": 0.0004053380320493589, + "expected_calibration_error_10bin": 0.0004053380320493589, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "G92": { + "valid": 2733, + "positives": 4, + "negatives": 2729, + "auroc": 0.7985525833638696, + "auprc": 0.008749497647491439, + "brier": 0.0014908306039815302, + "calibration": { + "observed_rate": 0.0014635931211123307, + "mean_prediction": 0.004330471010374695, + "calibration_in_the_large": 0.002866877889262364, + "expected_calibration_error_10bin": 0.002866877889262364, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "G93": { + "valid": 2656, + "positives": 9, + "negatives": 2647, + "auroc": 0.8665575284389035, + "auprc": 0.01787758493188527, + "brier": 0.0033552857955534802, + "calibration": { + "observed_rate": 0.00338855421686747, + "mean_prediction": 0.002916224158651452, + "calibration_in_the_large": -0.0004723300582160179, + "expected_calibration_error_10bin": 0.0004723300582160179, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + "G99": { + "valid": 2841, + "positives": 0, + "negatives": 2841, + "auroc": null, + "auprc": null, + "brier": 5.0961670790987256e-08, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 8.244744241384828e-05, + "calibration_in_the_large": 8.244744241384828e-05, + "expected_calibration_error_10bin": 8.244744241384828e-05, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9992965177629265 + }, + "H10": { + "valid": 2832, + "positives": 0, + "negatives": 2832, + "auroc": null, + "auprc": null, + "brier": 2.2130132886131183e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0001922652487036556, + "calibration_in_the_large": 0.0001922652487036556, + "expected_calibration_error_10bin": 0.0001922652487036556, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "H26": { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 2.385338219387749e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0003167813403671688, + "calibration_in_the_large": 0.0003167813403671688, + "expected_calibration_error_10bin": 0.0003167813403671688, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "H35": { + "valid": 2806, + "positives": 3, + "negatives": 2803, + "auroc": 0.802116779640861, + "auprc": 0.0044781207636564535, + "brier": 0.0010685368264986026, + "calibration": { + "observed_rate": 0.0010691375623663579, + "mean_prediction": 0.00017667701051727602, + "calibration_in_the_large": -0.0008924605518490818, + "expected_calibration_error_10bin": 0.0008924605518490818, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "H40": { + "valid": 2750, + "positives": 3, + "negatives": 2747, + "auroc": 0.7880111636937265, + "auprc": 0.02639583416406947, + "brier": 0.0010835816961773956, + "calibration": { + "observed_rate": 0.001090909090909091, + "mean_prediction": 0.0011025187454599126, + "calibration_in_the_large": 1.1609654550821628e-05, + "expected_calibration_error_10bin": 1.1609654550821628e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "H53": { + "valid": 2790, + "positives": 3, + "negatives": 2787, + "auroc": 0.6724076067456046, + "auprc": 0.005329941823378308, + "brier": 0.0010735415911514682, + "calibration": { + "observed_rate": 0.001075268817204301, + "mean_prediction": 0.0014087620562845406, + "calibration_in_the_large": 0.0003334932390802396, + "expected_calibration_error_10bin": 0.0003334932390802396, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "H54": { + "valid": 2809, + "positives": 1, + "negatives": 2808, + "auroc": 0.5847578347578347, + "auprc": 0.000856898029134533, + "brier": 0.0003568808447539952, + "calibration": { + "observed_rate": 0.000355998576005696, + "mean_prediction": 0.0006171053800956398, + "calibration_in_the_large": 0.0002611068040899438, + "expected_calibration_error_10bin": 0.0002611068040899438, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "H91": { + "valid": 2791, + "positives": 1, + "negatives": 2790, + "auroc": 0.4505376344086022, + "auprc": 0.000651890482398957, + "brier": 0.0003586494895495738, + "calibration": { + "observed_rate": 0.00035829451809387314, + "mean_prediction": 0.00045910300356448143, + "calibration_in_the_large": 0.0001008084854706083, + "expected_calibration_error_10bin": 0.0001008084854706083, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + "I07": { + "valid": 2823, + "positives": 0, + "negatives": 2823, + "auroc": null, + "auprc": null, + "brier": 5.524535308363646e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0002233209153057736, + "calibration_in_the_large": 0.0002233209153057736, + "expected_calibration_error_10bin": 0.0002233209153057736, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "I08": { + "valid": 2767, + "positives": 1, + "negatives": 2766, + "auroc": 0.9125090383224873, + "auprc": 0.00411522633744856, + "brier": 0.0004002196543146946, + "calibration": { + "observed_rate": 0.0003614022406938923, + "mean_prediction": 0.0020016824274590103, + "calibration_in_the_large": 0.001640280186765118, + "expected_calibration_error_10bin": 0.001640280186765118, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + "I10": { + "valid": 1498, + "positives": 14, + "negatives": 1484, + "auroc": 0.6330381209087409, + "auprc": 0.022605333733593098, + "brier": 0.00926443382894454, + "calibration": { + "observed_rate": 0.009345794392523364, + "mean_prediction": 0.006038658783437084, + "calibration_in_the_large": -0.00330713560908628, + "expected_calibration_error_10bin": 0.00330713560908628, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + "I11": { + "valid": 2676, + "positives": 8, + "negatives": 2668, + "auroc": 0.8320839580209896, + "auprc": 0.013217271252680332, + "brier": 0.0029782956036406134, + "calibration": { + "observed_rate": 0.0029895366218236174, + "mean_prediction": 0.0024656688166425048, + "calibration_in_the_large": -0.0005238678051811127, + "expected_calibration_error_10bin": 0.0005238678051811127, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + "I12": { + "valid": 2552, + "positives": 8, + "negatives": 2544, + "auroc": 0.7987421383647799, + "auprc": 0.023198438160260976, + "brier": 0.003118513158422045, + "calibration": { + "observed_rate": 0.003134796238244514, + "mean_prediction": 0.0015934728022546773, + "calibration_in_the_large": -0.0015413234359898367, + "expected_calibration_error_10bin": 0.0016484496822284137, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + "I13": { + "valid": 2727, + "positives": 4, + "negatives": 2723, + "auroc": 0.8412596401028277, + "auprc": 0.011664587918641249, + "brier": 0.0014761125119752566, + "calibration": { + "observed_rate": 0.0014668133480014668, + "mean_prediction": 0.002128738211377313, + "calibration_in_the_large": 0.0006619248633758462, + "expected_calibration_error_10bin": 0.0006619248633758462, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + "I16": { + "valid": 2390, + "positives": 1, + "negatives": 2389, + "auroc": 0.9363750523231478, + "auprc": 0.006535947712418301, + "brier": 0.00041781660935433565, + "calibration": { + "observed_rate": 0.00041841004184100416, + "mean_prediction": 0.0004256600298994953, + "calibration_in_the_large": 7.249988058491115e-06, + "expected_calibration_error_10bin": 7.249988058491115e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + "I21": { + "valid": 2671, + "positives": 3, + "negatives": 2668, + "auroc": 0.9307846076961519, + "auprc": 0.17286062412756997, + "brier": 0.0011021076263909879, + "calibration": { + "observed_rate": 0.0011231748408835642, + "mean_prediction": 0.00217127827451877, + "calibration_in_the_large": 0.001048103433635206, + "expected_calibration_error_10bin": 0.001048103433635206, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "I24": { + "valid": 2809, + "positives": 1, + "negatives": 2808, + "auroc": 0.9704415954415955, + "auprc": 0.011904761904761904, + "brier": 0.0003549982548715471, + "calibration": { + "observed_rate": 0.000355998576005696, + "mean_prediction": 0.0004698240958920762, + "calibration_in_the_large": 0.00011382551988638022, + "expected_calibration_error_10bin": 0.00011382551988638022, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "I25": { + "valid": 2243, + "positives": 13, + "negatives": 2230, + "auroc": 0.8619868920317351, + "auprc": 0.04693255565738252, + "brier": 0.0056871009338909755, + "calibration": { + "observed_rate": 0.0057958091841284, + "mean_prediction": 0.004012276194129931, + "calibration_in_the_large": -0.0017835329899984686, + "expected_calibration_error_10bin": 0.0017835329899984686, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + "I26": { + "valid": 2760, + "positives": 3, + "negatives": 2757, + "auroc": 0.9173014145810664, + "auprc": 0.04474983051706551, + "brier": 0.0010748326075399313, + "calibration": { + "observed_rate": 0.0010869565217391304, + "mean_prediction": 0.00171454091101702, + "calibration_in_the_large": 0.0006275843892778895, + "expected_calibration_error_10bin": 0.0006275843892778895, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + "I27": { + "valid": 2716, + "positives": 6, + "negatives": 2710, + "auroc": 0.8813038130381304, + "auprc": 0.014774382932086105, + "brier": 0.002199282268660442, + "calibration": { + "observed_rate": 0.0022091310751104565, + "mean_prediction": 0.00209227676414491, + "calibration_in_the_large": -0.00011685431096554672, + "expected_calibration_error_10bin": 0.00011685431096554672, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I31": { + "valid": 2793, + "positives": 4, + "negatives": 2789, + "auroc": 0.8545177482968807, + "auprc": 0.009278308071179285, + "brier": 0.0014271054515872976, + "calibration": { + "observed_rate": 0.0014321518080916578, + "mean_prediction": 0.001338110823479995, + "calibration_in_the_large": -9.404098461166291e-05, + "expected_calibration_error_10bin": 9.404098461166291e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I34": { + "valid": 2753, + "positives": 4, + "negatives": 2749, + "auroc": 0.6507821025827574, + "auprc": 0.003693931840755174, + "brier": 0.001455023903738475, + "calibration": { + "observed_rate": 0.001452960406828914, + "mean_prediction": 0.0009448559904879665, + "calibration_in_the_large": -0.0005081044163409475, + "expected_calibration_error_10bin": 0.0005081044163409475, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + "I35": { + "valid": 2723, + "positives": 2, + "negatives": 2721, + "auroc": 0.45387725101065785, + "auprc": 0.0009815463597000098, + "brier": 0.0007408594631488309, + "calibration": { + "observed_rate": 0.0007344840249724568, + "mean_prediction": 0.0009783556634242257, + "calibration_in_the_large": 0.00024387163845176888, + "expected_calibration_error_10bin": 0.00024387163845176888, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "I42": { + "valid": 2740, + "positives": 1, + "negatives": 2739, + "auroc": 0.940854326396495, + "auprc": 0.006134969325153374, + "brier": 0.0003681475583026647, + "calibration": { + "observed_rate": 0.000364963503649635, + "mean_prediction": 0.0009840416869384258, + "calibration_in_the_large": 0.0006190781832887907, + "expected_calibration_error_10bin": 0.0006190781832887907, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "I44": { + "valid": 2722, + "positives": 4, + "negatives": 2718, + "auroc": 0.9120676968359087, + "auprc": 0.029988709286666165, + "brier": 0.0014672556374443558, + "calibration": { + "observed_rate": 0.0014695077149155032, + "mean_prediction": 0.002583431948492345, + "calibration_in_the_large": 0.001113924233576842, + "expected_calibration_error_10bin": 0.001113924233576842, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + "I45": { + "valid": 2766, + "positives": 2, + "negatives": 2764, + "auroc": 0.8751808972503617, + "auprc": 0.021497005988023954, + "brier": 0.0007209879197984392, + "calibration": { + "observed_rate": 0.0007230657989877079, + "mean_prediction": 0.001538933754930763, + "calibration_in_the_large": 0.0008158679559430551, + "expected_calibration_error_10bin": 0.0008158679559430551, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + "I46": { + "valid": 2831, + "positives": 0, + "negatives": 2831, + "auroc": null, + "auprc": null, + "brier": 7.63874230268552e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004001331148308807, + "calibration_in_the_large": 0.0004001331148308807, + "expected_calibration_error_10bin": 0.0004001331148308807, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I47": { + "valid": 2716, + "positives": 3, + "negatives": 2713, + "auroc": 0.8562476962771839, + "auprc": 0.004875786672176971, + "brier": 0.001105588057767497, + "calibration": { + "observed_rate": 0.0011045655375552283, + "mean_prediction": 0.0021181099864366676, + "calibration_in_the_large": 0.0010135444488814393, + "expected_calibration_error_10bin": 0.0010135444488814393, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I48": { + "valid": 2385, + "positives": 7, + "negatives": 2378, + "auroc": 0.8196563739036405, + "auprc": 0.00921437443285648, + "brier": 0.0029299433827854973, + "calibration": { + "observed_rate": 0.0029350104821802936, + "mean_prediction": 0.002501695460065871, + "calibration_in_the_large": -0.00043331502211442236, + "expected_calibration_error_10bin": 0.00043331502211442236, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + "I49": { + "valid": 2734, + "positives": 4, + "negatives": 2730, + "auroc": 0.6945054945054945, + "auprc": 0.004529369854230053, + "brier": 0.0014611386690294422, + "calibration": { + "observed_rate": 0.001463057790782736, + "mean_prediction": 0.0005453167267358928, + "calibration_in_the_large": -0.0009177410640468432, + "expected_calibration_error_10bin": 0.0009177410640468432, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I50": { + "valid": 2415, + "positives": 7, + "negatives": 2408, + "auroc": 0.8633720930232558, + "auprc": 0.03130887244090785, + "brier": 0.0028755859871143256, + "calibration": { + "observed_rate": 0.002898550724637681, + "mean_prediction": 0.0034708689884898167, + "calibration_in_the_large": 0.0005723182638521355, + "expected_calibration_error_10bin": 0.0005723182638521357, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + "I51": { + "valid": 2807, + "positives": 2, + "negatives": 2805, + "auroc": 0.7607843137254902, + "auprc": 0.002554095779360569, + "brier": 0.0007118781445066031, + "calibration": { + "observed_rate": 0.0007125044531528322, + "mean_prediction": 0.0005559915936026875, + "calibration_in_the_large": -0.00015651285955014464, + "expected_calibration_error_10bin": 0.00015651285955014464, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "I61": { + "valid": 2802, + "positives": 2, + "negatives": 2800, + "auroc": 0.6894642857142858, + "auprc": 0.0035113183204316207, + "brier": 0.0007133244435423889, + "calibration": { + "observed_rate": 0.0007137758743754461, + "mean_prediction": 0.00023264917996255894, + "calibration_in_the_large": -0.0004811266944128872, + "expected_calibration_error_10bin": 0.0004811266944128872, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "I63": { + "valid": 2735, + "positives": 4, + "negatives": 2731, + "auroc": 0.8916147931160747, + "auprc": 0.008058063180484847, + "brier": 0.0014589829604016679, + "calibration": { + "observed_rate": 0.0014625228519195613, + "mean_prediction": 0.0013114562630767775, + "calibration_in_the_large": -0.00015106658884278383, + "expected_calibration_error_10bin": 0.00015106658884278383, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + "I65": { + "valid": 2774, + "positives": 0, + "negatives": 2774, + "auroc": null, + "auprc": null, + "brier": 1.0514555419810433e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.000649111463539086, + "calibration_in_the_large": 0.000649111463539086, + "expected_calibration_error_10bin": 0.000649111463539086, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "I67": { + "valid": 2773, + "positives": 2, + "negatives": 2771, + "auroc": 0.8863226272103933, + "auprc": 0.0046940347787805415, + "brier": 0.0007209203123300066, + "calibration": { + "observed_rate": 0.000721240533717995, + "mean_prediction": 0.0006673485415089178, + "calibration_in_the_large": -5.389199220907719e-05, + "expected_calibration_error_10bin": 5.389199220907719e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "I69": { + "valid": 2752, + "positives": 4, + "negatives": 2748, + "auroc": 0.8861899563318777, + "auprc": 0.014989697907927953, + "brier": 0.0014495096783940099, + "calibration": { + "observed_rate": 0.0014534883720930232, + "mean_prediction": 0.002255195992356173, + "calibration_in_the_large": 0.0008017076202631499, + "expected_calibration_error_10bin": 0.0008017076202631499, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + "I70": { + "valid": 2771, + "positives": 2, + "negatives": 2769, + "auroc": 0.887143373058866, + "auprc": 0.02165837479270315, + "brier": 0.0007188631010385373, + "calibration": { + "observed_rate": 0.0007217610970768675, + "mean_prediction": 0.0005136062085292516, + "calibration_in_the_large": -0.0002081548885476159, + "expected_calibration_error_10bin": 0.0002081548885476159, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + "I71": { + "valid": 2769, + "positives": 1, + "negatives": 2768, + "auroc": 0.9483381502890174, + "auprc": 0.006944444444444444, + "brier": 0.0003607164397228949, + "calibration": { + "observed_rate": 0.00036114120621162876, + "mean_prediction": 0.0005622275501518375, + "calibration_in_the_large": 0.00020108634394020873, + "expected_calibration_error_10bin": 0.00020108634394020873, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + "I72": { + "valid": 2818, + "positives": 2, + "negatives": 2816, + "auroc": 0.5790127840909091, + "auprc": 0.004291786644727821, + "brier": 0.0007094120477151682, + "calibration": { + "observed_rate": 0.0007097232079489, + "mean_prediction": 0.00043893463099960774, + "calibration_in_the_large": -0.0002707885769492922, + "expected_calibration_error_10bin": 0.0002707885769492922, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "I73": { + "valid": 2734, + "positives": 1, + "negatives": 2733, + "auroc": 0.867178924259056, + "auprc": 0.0027472527472527475, + "brier": 0.00036792212505661704, + "calibration": { + "observed_rate": 0.000365764447695684, + "mean_prediction": 0.0005941106603228767, + "calibration_in_the_large": 0.0002283462126271927, + "expected_calibration_error_10bin": 0.0002283462126271927, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I74": { + "valid": 2821, + "positives": 2, + "negatives": 2819, + "auroc": 0.7726144022703086, + "auprc": 0.006392375639237564, + "brier": 0.0007084259690322508, + "calibration": { + "observed_rate": 0.0007089684509039348, + "mean_prediction": 0.00021701206534688924, + "calibration_in_the_large": -0.0004919563855570455, + "expected_calibration_error_10bin": 0.0004919563855570455, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "I77": { + "valid": 2785, + "positives": 2, + "negatives": 2783, + "auroc": 0.7080488681279196, + "auprc": 0.00269630597485358, + "brier": 0.0007177358766566988, + "calibration": { + "observed_rate": 0.000718132854578097, + "mean_prediction": 0.0004323310653244971, + "calibration_in_the_large": -0.0002858017892535999, + "expected_calibration_error_10bin": 0.0002858017892535999, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "I80": { + "valid": 2827, + "positives": 2, + "negatives": 2825, + "auroc": 0.8210619469026549, + "auprc": 0.003389500129948887, + "brier": 0.000708133039942745, + "calibration": { + "observed_rate": 0.0007074637424831977, + "mean_prediction": 0.00026784584265566254, + "calibration_in_the_large": -0.0004396178998275352, + "expected_calibration_error_10bin": 0.0004396178998275352, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "I81": { + "valid": 2826, + "positives": 4, + "negatives": 2822, + "auroc": 0.8152019844082211, + "auprc": 0.01389447853711575, + "brier": 0.0014127975906011389, + "calibration": { + "observed_rate": 0.0014154281670205238, + "mean_prediction": 0.0004858501672987041, + "calibration_in_the_large": -0.0009295779997218197, + "expected_calibration_error_10bin": 0.0009295779997218197, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I82": { + "valid": 2739, + "positives": 6, + "negatives": 2733, + "auroc": 0.6666666666666666, + "auprc": 0.014161721695405092, + "brier": 0.002183161295911753, + "calibration": { + "observed_rate": 0.002190580503833516, + "mean_prediction": 0.002201432176802701, + "calibration_in_the_large": 1.0851672969185242e-05, + "expected_calibration_error_10bin": 1.0851672969185242e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "I85": { + "valid": 2793, + "positives": 1, + "negatives": 2792, + "auroc": 0.9799426934097422, + "auprc": 0.017543859649122806, + "brier": 0.0004002239454427516, + "calibration": { + "observed_rate": 0.00035803795202291446, + "mean_prediction": 0.0005356639829542629, + "calibration_in_the_large": 0.00017762603093134848, + "expected_calibration_error_10bin": 0.00022689099033492089, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I87": { + "valid": 2780, + "positives": 4, + "negatives": 2776, + "auroc": 0.8870677233429395, + "auprc": 0.00785725254577881, + "brier": 0.0014344535002786861, + "calibration": { + "observed_rate": 0.0014388489208633094, + "mean_prediction": 0.0010292978841403547, + "calibration_in_the_large": -0.0004095510367229547, + "expected_calibration_error_10bin": 0.0004095510367229547, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "I89": { + "valid": 2826, + "positives": 1, + "negatives": 2825, + "auroc": 0.9097345132743363, + "auprc": 0.00390625, + "brier": 0.00035367117325577085, + "calibration": { + "observed_rate": 0.00035385704175513094, + "mean_prediction": 0.00015009281984961303, + "calibration_in_the_large": -0.0002037642219055179, + "expected_calibration_error_10bin": 0.0002037642219055179, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I95": { + "valid": 2485, + "positives": 19, + "negatives": 2466, + "auroc": 0.7142826653007214, + "auprc": 0.019482177942996587, + "brier": 0.007571922367072781, + "calibration": { + "observed_rate": 0.007645875251509054, + "mean_prediction": 0.009300192276491846, + "calibration_in_the_large": 0.0016543170249827916, + "expected_calibration_error_10bin": 0.0016543170249827916, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + "I96": { + "valid": 2831, + "positives": 0, + "negatives": 2831, + "auroc": null, + "auprc": null, + "brier": 7.034941337223455e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00039700280679932844, + "calibration_in_the_large": 0.00039700280679932844, + "expected_calibration_error_10bin": 0.00039700280679932844, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I97": { + "valid": 2740, + "positives": 4, + "negatives": 2736, + "auroc": 0.9042397660818714, + "auprc": 0.019492094971115013, + "brier": 0.0014511495109964, + "calibration": { + "observed_rate": 0.00145985401459854, + "mean_prediction": 0.0009661986620885993, + "calibration_in_the_large": -0.0004936553525099408, + "expected_calibration_error_10bin": 0.0004936553525099408, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "J02": { + "valid": 2825, + "positives": 0, + "negatives": 2825, + "auroc": null, + "auprc": null, + "brier": 5.35729054310034e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0003408214956186135, + "calibration_in_the_large": 0.0003408214956186135, + "expected_calibration_error_10bin": 0.0003408214956186135, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J06": { + "valid": 2816, + "positives": 1, + "negatives": 2815, + "auroc": 0.38579040852575486, + "auprc": 0.0005780346820809249, + "brier": 0.0003595034729756781, + "calibration": { + "observed_rate": 0.0003551136363636364, + "mean_prediction": 0.0005329218399607265, + "calibration_in_the_large": 0.00017780820359709014, + "expected_calibration_error_10bin": 0.00017780820359709014, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "J12": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 2.2606136755695523e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004881461609972542, + "calibration_in_the_large": 0.0004881461609972542, + "expected_calibration_error_10bin": 0.0004881461609972542, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J15": { + "valid": 2795, + "positives": 1, + "negatives": 2794, + "auroc": 0.9180386542591267, + "auprc": 0.004347826086956522, + "brier": 0.0003659155883992793, + "calibration": { + "observed_rate": 0.00035778175313059033, + "mean_prediction": 0.00134643378212555, + "calibration_in_the_large": 0.0009886520289949597, + "expected_calibration_error_10bin": 0.0009886520289949597, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + "J18": { + "valid": 2671, + "positives": 9, + "negatives": 2662, + "auroc": 0.792720594373487, + "auprc": 0.013044545914880261, + "brier": 0.00338150366204229, + "calibration": { + "observed_rate": 0.0033695245226506927, + "mean_prediction": 0.004571223750148885, + "calibration_in_the_large": 0.0012016992274981922, + "expected_calibration_error_10bin": 0.0012016992274981922, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "J30": { + "valid": 2815, + "positives": 0, + "negatives": 2815, + "auroc": null, + "auprc": null, + "brier": 1.2643794933292211e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0007086977894785694, + "calibration_in_the_large": 0.0007086977894785694, + "expected_calibration_error_10bin": 0.0007086977894785694, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "J32": { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.8967468175388967, + "auprc": 0.0034129692832764505, + "brier": 0.0003537602488802286, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.00024367937541172678, + "calibration_in_the_large": -0.00010980242027579533, + "expected_calibration_error_10bin": 0.00010980242027579533, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J38": { + "valid": 2825, + "positives": 1, + "negatives": 2824, + "auroc": 0.5407223796033994, + "auprc": 0.0007704160246533128, + "brier": 0.00035431630800638166, + "calibration": { + "observed_rate": 0.00035398230088495576, + "mean_prediction": 0.0003522844296810591, + "calibration_in_the_large": -1.69787120389667e-06, + "expected_calibration_error_10bin": 1.69787120389667e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J43": { + "valid": 2804, + "positives": 1, + "negatives": 2803, + "auroc": 0.1608990367463432, + "auprc": 0.00042498937526561835, + "brier": 0.00035722058801396076, + "calibration": { + "observed_rate": 0.0003566333808844508, + "mean_prediction": 0.0004361788664739337, + "calibration_in_the_large": 7.954548558948289e-05, + "expected_calibration_error_10bin": 7.954548558948289e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "J44": { + "valid": 2570, + "positives": 6, + "negatives": 2564, + "auroc": 0.8323582943317732, + "auprc": 0.008762859009966302, + "brier": 0.002329352189593122, + "calibration": { + "observed_rate": 0.0023346303501945525, + "mean_prediction": 0.001527165466347968, + "calibration_in_the_large": -0.0008074648838465844, + "expected_calibration_error_10bin": 0.0008074648838465844, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + "J45": { + "valid": 2518, + "positives": 9, + "negatives": 2509, + "auroc": 0.6520526106018334, + "auprc": 0.006868554882223054, + "brier": 0.0035657385035523913, + "calibration": { + "observed_rate": 0.003574265289912629, + "mean_prediction": 0.0023772414633604316, + "calibration_in_the_large": -0.0011970238265521975, + "expected_calibration_error_10bin": 0.0011970238265521975, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + "J47": { + "valid": 2825, + "positives": 0, + "negatives": 2825, + "auroc": null, + "auprc": null, + "brier": 1.8542608349368428e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00016043897682807375, + "calibration_in_the_large": 0.00016043897682807375, + "expected_calibration_error_10bin": 0.00016043897682807375, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J69": { + "valid": 2777, + "positives": 6, + "negatives": 2771, + "auroc": 0.8791651629977144, + "auprc": 0.011862198289037626, + "brier": 0.0021495043612537587, + "calibration": { + "observed_rate": 0.0021606049693914295, + "mean_prediction": 0.0022474080704922763, + "calibration_in_the_large": 8.680310110084676e-05, + "expected_calibration_error_10bin": 8.680310110084676e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "J81": { + "valid": 2781, + "positives": 5, + "negatives": 2776, + "auroc": 0.6859510086455332, + "auprc": 0.004948250364141151, + "brier": 0.0017962076821236104, + "calibration": { + "observed_rate": 0.0017979144192736426, + "mean_prediction": 0.0006559638823578806, + "calibration_in_the_large": -0.001141950536915762, + "expected_calibration_error_10bin": 0.001141950536915762, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "J84": { + "valid": 2817, + "positives": 4, + "negatives": 2813, + "auroc": 0.9249022396018486, + "auprc": 0.012608241207344165, + "brier": 0.0014176510947206487, + "calibration": { + "observed_rate": 0.0014199503017394391, + "mean_prediction": 0.00022390711926942344, + "calibration_in_the_large": -0.0011960431824700156, + "expected_calibration_error_10bin": 0.0011960431824700156, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "J90": { + "valid": 2754, + "positives": 11, + "negatives": 2743, + "auroc": 0.6662910549166473, + "auprc": 0.00783264507215396, + "brier": 0.00398648201922016, + "calibration": { + "observed_rate": 0.0039941902687000725, + "mean_prediction": 0.00319202317367627, + "calibration_in_the_large": -0.0008021670950238025, + "expected_calibration_error_10bin": 0.0008021670950238025, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + "J91": { + "valid": 2807, + "positives": 1, + "negatives": 2806, + "auroc": 0.8781183178902352, + "auprc": 0.0029154518950437317, + "brier": 0.0003614453661886305, + "calibration": { + "observed_rate": 0.0003562522265764161, + "mean_prediction": 0.0007128598549914857, + "calibration_in_the_large": 0.00035660762841506965, + "expected_calibration_error_10bin": 0.00035660762841506965, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "J94": { + "valid": 2829, + "positives": 4, + "negatives": 2825, + "auroc": 0.7850442477876106, + "auprc": 0.008750719945388917, + "brier": 0.0014125109832975402, + "calibration": { + "observed_rate": 0.0014139271827500884, + "mean_prediction": 0.00024067819091171835, + "calibration_in_the_large": -0.0011732489918383701, + "expected_calibration_error_10bin": 0.0011732489918383701, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J95": { + "valid": 2770, + "positives": 5, + "negatives": 2765, + "auroc": 0.8047739602169982, + "auprc": 0.01655526111459939, + "brier": 0.001798065598638669, + "calibration": { + "observed_rate": 0.0018050541516245488, + "mean_prediction": 0.0008469943413735764, + "calibration_in_the_large": -0.0009580598102509724, + "expected_calibration_error_10bin": 0.0009580598102509724, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + "J96": { + "valid": 2605, + "positives": 10, + "negatives": 2595, + "auroc": 0.8851252408477842, + "auprc": 0.020903133321551626, + "brier": 0.0038341780309674826, + "calibration": { + "observed_rate": 0.003838771593090211, + "mean_prediction": 0.00519884529300748, + "calibration_in_the_large": 0.001360073699917269, + "expected_calibration_error_10bin": 0.0013600736999172683, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + "J98": { + "valid": 2692, + "positives": 6, + "negatives": 2686, + "auroc": 0.7181062298337056, + "auprc": 0.00933788399912411, + "brier": 0.002219940363838606, + "calibration": { + "observed_rate": 0.002228826151560178, + "mean_prediction": 0.002577235236709725, + "calibration_in_the_large": 0.00034840908514954675, + "expected_calibration_error_10bin": 0.00034840908514954675, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + "K04": { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 2.2863701698968914e-08, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 9.785956019137668e-05, + "calibration_in_the_large": 9.785956019137668e-05, + "expected_calibration_error_10bin": 9.785956019137668e-05, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "K12": { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9950389794472005, + "auprc": 0.09583333333333333, + "brier": 0.0006838949497492594, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0003824403953416725, + "calibration_in_the_large": -0.0003257749021087525, + "expected_calibration_error_10bin": 0.0003257749021087525, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K20": { + "valid": 2813, + "positives": 1, + "negatives": 2812, + "auroc": 0.802275960170697, + "auprc": 0.0017953321364452424, + "brier": 0.0003642167755053111, + "calibration": { + "observed_rate": 0.00035549235691432633, + "mean_prediction": 0.001473669762924314, + "calibration_in_the_large": 0.0011181774060099875, + "expected_calibration_error_10bin": 0.0011181774060099875, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K21": { + "valid": 2043, + "positives": 16, + "negatives": 2027, + "auroc": 0.7927972372964973, + "auprc": 0.04175925910499976, + "brier": 0.00768170515880947, + "calibration": { + "observed_rate": 0.00783162016642193, + "mean_prediction": 0.010125577836880954, + "calibration_in_the_large": 0.0022939576704590244, + "expected_calibration_error_10bin": 0.0022939576704590244, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + "K22": { + "valid": 2764, + "positives": 1, + "negatives": 2763, + "auroc": 0.9866087585957293, + "auprc": 0.02631578947368421, + "brier": 0.0003611573164167546, + "calibration": { + "observed_rate": 0.000361794500723589, + "mean_prediction": 0.0012797018795584884, + "calibration_in_the_large": 0.0009179073788348994, + "expected_calibration_error_10bin": 0.0009179073788348994, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + "K25": { + "valid": 2817, + "positives": 2, + "negatives": 2815, + "auroc": 0.9564831261101243, + "auprc": 0.011754911754911754, + "brier": 0.000708197752798189, + "calibration": { + "observed_rate": 0.0007099751508697196, + "mean_prediction": 0.000590478050238638, + "calibration_in_the_large": -0.00011949710063108158, + "expected_calibration_error_10bin": 0.00011949710063108158, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "K26": { + "valid": 2814, + "positives": 0, + "negatives": 2814, + "auroc": null, + "auprc": null, + "brier": 4.199816556021665e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0003953584358154403, + "calibration_in_the_large": 0.0003953584358154403, + "expected_calibration_error_10bin": 0.0003953584358154403, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "K29": { + "valid": 2785, + "positives": 0, + "negatives": 2785, + "auroc": null, + "auprc": null, + "brier": 1.5236636433029142e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.002333131529709752, + "calibration_in_the_large": 0.002333131529709752, + "expected_calibration_error_10bin": 0.002333131529709752, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K30": { + "valid": 2837, + "positives": 0, + "negatives": 2837, + "auroc": null, + "auprc": null, + "brier": 7.299708055071312e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0003320003680728841, + "calibration_in_the_large": 0.0003320003680728841, + "expected_calibration_error_10bin": 0.0003320003680728841, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "K31": { + "valid": 2756, + "positives": 3, + "negatives": 2753, + "auroc": 0.8844896476571014, + "auprc": 0.059015344545311925, + "brier": 0.0010702556004241286, + "calibration": { + "observed_rate": 0.0010885341074020319, + "mean_prediction": 0.0011825737534290675, + "calibration_in_the_large": 9.403964602703566e-05, + "expected_calibration_error_10bin": 9.403964602703566e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "K40": { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 1.8540080423035835e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.000318167915720924, + "calibration_in_the_large": 0.000318167915720924, + "expected_calibration_error_10bin": 0.000318167915720924, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "K42": { + "valid": 2820, + "positives": 2, + "negatives": 2818, + "auroc": 0.6394606103619588, + "auprc": 0.008980649145680367, + "brier": 0.0007088685101876923, + "calibration": { + "observed_rate": 0.0007092198581560284, + "mean_prediction": 0.0002517920787427779, + "calibration_in_the_large": -0.0004574277794132505, + "expected_calibration_error_10bin": 0.0004574277794132505, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "K43": { + "valid": 2813, + "positives": 1, + "negatives": 2812, + "auroc": 0.9182076813655761, + "auprc": 0.004329004329004329, + "brier": 0.0003553120144970101, + "calibration": { + "observed_rate": 0.00035549235691432633, + "mean_prediction": 0.000197042225569235, + "calibration_in_the_large": -0.00015845013134509133, + "expected_calibration_error_10bin": 0.00015845013134509133, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K44": { + "valid": 2785, + "positives": 1, + "negatives": 2784, + "auroc": 0.4353448275862069, + "auprc": 0.0006357279084551812, + "brier": 0.0003599576186545528, + "calibration": { + "observed_rate": 0.0003590664272890485, + "mean_prediction": 0.0006090467393350894, + "calibration_in_the_large": 0.0002499803120460409, + "expected_calibration_error_10bin": 0.0002499803120460409, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K52": { + "valid": 2749, + "positives": 4, + "negatives": 2745, + "auroc": 0.8827868852459017, + "auprc": 0.021356367682728614, + "brier": 0.0014487190764558662, + "calibration": { + "observed_rate": 0.0014550745725718443, + "mean_prediction": 0.002101788894014085, + "calibration_in_the_large": 0.0006467143214422405, + "expected_calibration_error_10bin": 0.0006467143214422405, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + "K55": { + "valid": 2815, + "positives": 2, + "negatives": 2813, + "auroc": 0.9182367579097049, + "auprc": 0.00633844927247359, + "brier": 0.0007107915679473227, + "calibration": { + "observed_rate": 0.0007104795737122557, + "mean_prediction": 0.0007028865594834339, + "calibration_in_the_large": -7.593014228821863e-06, + "expected_calibration_error_10bin": 7.593014228821863e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "K56": { + "valid": 2745, + "positives": 7, + "negatives": 2738, + "auroc": 0.7765835333402901, + "auprc": 0.026069019567502648, + "brier": 0.002525634049738755, + "calibration": { + "observed_rate": 0.0025500910746812386, + "mean_prediction": 0.0026776129013075423, + "calibration_in_the_large": 0.00012752182662630366, + "expected_calibration_error_10bin": 0.00012752182662630366, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + "K57": { + "valid": 2741, + "positives": 3, + "negatives": 2738, + "auroc": 0.7303384465546627, + "auprc": 0.0034441643519407573, + "brier": 0.0010954755080191264, + "calibration": { + "observed_rate": 0.0010944910616563297, + "mean_prediction": 0.0012257789708541122, + "calibration_in_the_large": 0.0001312879091977825, + "expected_calibration_error_10bin": 0.0001312879091977825, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "K58": { + "valid": 2792, + "positives": 3, + "negatives": 2789, + "auroc": 0.4854786661885981, + "auprc": 0.0013812894988785823, + "brier": 0.001075242244250214, + "calibration": { + "observed_rate": 0.0010744985673352436, + "mean_prediction": 0.0005976543336301336, + "calibration_in_the_large": -0.00047684423370511, + "expected_calibration_error_10bin": 0.00047684423370511, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "K59": { + "valid": 2560, + "positives": 29, + "negatives": 2531, + "auroc": 0.6886061117998883, + "auprc": 0.04264071865407622, + "brier": 0.011101490057082377, + "calibration": { + "observed_rate": 0.011328125, + "mean_prediction": 0.00783786393092214, + "calibration_in_the_large": -0.0034902610690778595, + "expected_calibration_error_10bin": 0.0034902610690778595, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "K62": { + "valid": 2813, + "positives": 1, + "negatives": 2812, + "auroc": 0.7958748221906117, + "auprc": 0.0017391304347826088, + "brier": 0.0003563213555514959, + "calibration": { + "observed_rate": 0.00035549235691432633, + "mean_prediction": 0.000882650500325064, + "calibration_in_the_large": 0.0005271581434107377, + "expected_calibration_error_10bin": 0.0005271581434107377, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K63": { + "valid": 2810, + "positives": 2, + "negatives": 2808, + "auroc": 0.6620370370370371, + "auprc": 0.007041752107541582, + "brier": 0.00071079366042649, + "calibration": { + "observed_rate": 0.0007117437722419929, + "mean_prediction": 0.00092182567978817, + "calibration_in_the_large": 0.00021008190754617708, + "expected_calibration_error_10bin": 0.00021008190754617708, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "K64": { + "valid": 2801, + "positives": 2, + "negatives": 2799, + "auroc": 0.8210075026795284, + "auprc": 0.002917082917082917, + "brier": 0.0007207295124926025, + "calibration": { + "observed_rate": 0.0007140307033202428, + "mean_prediction": 0.0013156789465106455, + "calibration_in_the_large": 0.0006016482431904027, + "expected_calibration_error_10bin": 0.0006016482431904027, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "K65": { + "valid": 2813, + "positives": 5, + "negatives": 2808, + "auroc": 0.8474358974358974, + "auprc": 0.018567129748864354, + "brier": 0.0017741307209860513, + "calibration": { + "observed_rate": 0.0017774617845716318, + "mean_prediction": 0.0021955946060842977, + "calibration_in_the_large": 0.00041813282151266593, + "expected_calibration_error_10bin": 0.00041813282151266593, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K66": { + "valid": 2796, + "positives": 1, + "negatives": 2795, + "auroc": 0.9073345259391771, + "auprc": 0.0038461538461538464, + "brier": 0.00035782038920053125, + "calibration": { + "observed_rate": 0.000357653791130186, + "mean_prediction": 0.0005211664440571407, + "calibration_in_the_large": 0.00016351265292695468, + "expected_calibration_error_10bin": 0.00016351265292695468, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "K70": { + "valid": 2774, + "positives": 0, + "negatives": 2774, + "auroc": null, + "auprc": null, + "brier": 1.393709785564573e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00021949276676395293, + "calibration_in_the_large": 0.00021949276676395293, + "expected_calibration_error_10bin": 0.00021949276676395293, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "K72": { + "valid": 2787, + "positives": 4, + "negatives": 2783, + "auroc": 0.9878727991376213, + "auprc": 0.33751536918397723, + "brier": 0.0013466901134463088, + "calibration": { + "observed_rate": 0.0014352350197344816, + "mean_prediction": 0.0006813753486773093, + "calibration_in_the_large": -0.0007538596710571723, + "expected_calibration_error_10bin": 0.0007538596710571723, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "K74": { + "valid": 2763, + "positives": 1, + "negatives": 2762, + "auroc": 0.9822592324402607, + "auprc": 0.02, + "brier": 0.00036863564724511213, + "calibration": { + "observed_rate": 0.0003619254433586681, + "mean_prediction": 0.0009287814591122328, + "calibration_in_the_large": 0.0005668560157535646, + "expected_calibration_error_10bin": 0.0005668560157535646, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "K75": { + "valid": 2798, + "positives": 2, + "negatives": 2796, + "auroc": 0.9386623748211731, + "auprc": 0.009000321440051431, + "brier": 0.0007146498401891222, + "calibration": { + "observed_rate": 0.0007147962830593281, + "mean_prediction": 0.0004684053144828054, + "calibration_in_the_large": -0.00024639096857652273, + "expected_calibration_error_10bin": 0.00024639096857652273, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "K76": { + "valid": 2681, + "positives": 10, + "negatives": 2671, + "auroc": 0.8922500935979034, + "auprc": 0.15954419543465592, + "brier": 0.0034886015674888576, + "calibration": { + "observed_rate": 0.003729951510630362, + "mean_prediction": 0.0012361450442619232, + "calibration_in_the_large": -0.0024938064663684385, + "expected_calibration_error_10bin": 0.0024938064663684385, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + "K80": { + "valid": 2731, + "positives": 2, + "negatives": 2729, + "auroc": 0.6132282887504581, + "auprc": 0.006175401597415418, + "brier": 0.0007316156621076993, + "calibration": { + "observed_rate": 0.0007323324789454412, + "mean_prediction": 0.0005682551413502315, + "calibration_in_the_large": -0.0001640773375952097, + "expected_calibration_error_10bin": 0.0001640773375952097, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + "K81": { + "valid": 2825, + "positives": 0, + "negatives": 2825, + "auroc": null, + "auprc": null, + "brier": 1.9423178522604825e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00046250857307796625, + "calibration_in_the_large": 0.00046250857307796625, + "expected_calibration_error_10bin": 0.00046250857307796625, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "K82": { + "valid": 2824, + "positives": 1, + "negatives": 2823, + "auroc": 0.9185263903648601, + "auprc": 0.004329004329004329, + "brier": 0.00035415123114598303, + "calibration": { + "observed_rate": 0.0003541076487252125, + "mean_prediction": 0.000324562396863109, + "calibration_in_the_large": -2.9545251862103455e-05, + "expected_calibration_error_10bin": 2.9545251862103455e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K83": { + "valid": 2757, + "positives": 1, + "negatives": 2756, + "auroc": 0.9071117561683599, + "auprc": 0.0038910505836575876, + "brier": 0.00039062749399422687, + "calibration": { + "observed_rate": 0.0003627130939426913, + "mean_prediction": 0.0012063124984241875, + "calibration_in_the_large": 0.0008435994044814963, + "expected_calibration_error_10bin": 0.0008435994044814961, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + "K85": { + "valid": 2779, + "positives": 1, + "negatives": 2778, + "auroc": 0.44096472282217425, + "auprc": 0.0006435006435006435, + "brier": 0.0003599600802928169, + "calibration": { + "observed_rate": 0.0003598416696653472, + "mean_prediction": 0.00023547870796506636, + "calibration_in_the_large": -0.00012436296170028087, + "expected_calibration_error_10bin": 0.00012436296170028087, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + "K86": { + "valid": 2785, + "positives": 1, + "negatives": 2784, + "auroc": 0.6246408045977011, + "auprc": 0.0009560229445506692, + "brier": 0.0003617049803429946, + "calibration": { + "observed_rate": 0.0003590664272890485, + "mean_prediction": 0.0006818134750296662, + "calibration_in_the_large": 0.0003227470477406177, + "expected_calibration_error_10bin": 0.0003227470477406177, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K90": { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.6791519434628975, + "auprc": 0.0011001100110011, + "brier": 0.00035341424046234744, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0002877452642977786, + "calibration_in_the_large": -6.548680917449267e-05, + "expected_calibration_error_10bin": 6.548680917449267e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "K91": { + "valid": 2768, + "positives": 8, + "negatives": 2760, + "auroc": 0.8395380434782609, + "auprc": 0.03255883113163166, + "brier": 0.0028516185033926446, + "calibration": { + "observed_rate": 0.002890173410404624, + "mean_prediction": 0.0020607667188638212, + "calibration_in_the_large": -0.0008294066915408029, + "expected_calibration_error_10bin": 0.0008294066915408029, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "K92": { + "valid": 2751, + "positives": 7, + "negatives": 2744, + "auroc": 0.8197625989171179, + "auprc": 0.03221576085527368, + "brier": 0.0025147223297918415, + "calibration": { + "observed_rate": 0.002544529262086514, + "mean_prediction": 0.0031550485149649, + "calibration_in_the_large": 0.0006105192528783857, + "expected_calibration_error_10bin": 0.0006105192528783857, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "K94": { + "valid": 2823, + "positives": 5, + "negatives": 2818, + "auroc": 0.8772178850248403, + "auprc": 0.011669132219471712, + "brier": 0.0017850396813429033, + "calibration": { + "observed_rate": 0.001771165426850868, + "mean_prediction": 0.0018685014364434754, + "calibration_in_the_large": 9.733600959260747e-05, + "expected_calibration_error_10bin": 9.733600959260747e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "L02": { + "valid": 2807, + "positives": 3, + "negatives": 2804, + "auroc": 0.4431764146457442, + "auprc": 0.0012417677109620238, + "brier": 0.0010749921306152956, + "calibration": { + "observed_rate": 0.0010687566797292483, + "mean_prediction": 0.0017732214736943714, + "calibration_in_the_large": 0.0007044647939651232, + "expected_calibration_error_10bin": 0.0007044647939651232, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "L03": { + "valid": 2701, + "positives": 7, + "negatives": 2694, + "auroc": 0.5287411178279775, + "auprc": 0.004468392559434761, + "brier": 0.0025896938838065138, + "calibration": { + "observed_rate": 0.00259163272861903, + "mean_prediction": 0.0019186745277123523, + "calibration_in_the_large": -0.0006729582009066778, + "expected_calibration_error_10bin": 0.0006729582009066778, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + "L08": { + "valid": 2830, + "positives": 3, + "negatives": 2827, + "auroc": 0.7647683056243367, + "auprc": 0.004515490857269144, + "brier": 0.001059197067774615, + "calibration": { + "observed_rate": 0.0010600706713780918, + "mean_prediction": 0.0004057884014114745, + "calibration_in_the_large": -0.0006542822699666173, + "expected_calibration_error_10bin": 0.0006542822699666173, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + "L27": { + "valid": 2818, + "positives": 3, + "negatives": 2815, + "auroc": 0.7475429248075784, + "auprc": 0.005017589525741747, + "brier": 0.0010756906962142271, + "calibration": { + "observed_rate": 0.0010645848119233499, + "mean_prediction": 0.0013085809528573685, + "calibration_in_the_large": 0.0002439961409340186, + "expected_calibration_error_10bin": 0.0002439961409340186, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "L29": { + "valid": 2817, + "positives": 2, + "negatives": 2815, + "auroc": 0.21296625222024868, + "auprc": 0.000657938301517418, + "brier": 0.0007144821601346231, + "calibration": { + "observed_rate": 0.0007099751508697196, + "mean_prediction": 0.0010509899089400693, + "calibration_in_the_large": 0.0003410147580703497, + "expected_calibration_error_10bin": 0.0003410147580703497, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "L30": { + "valid": 2816, + "positives": 1, + "negatives": 2815, + "auroc": 0.9982238010657194, + "auprc": 0.16666666666666666, + "brier": 0.00035181400368677646, + "calibration": { + "observed_rate": 0.0003551136363636364, + "mean_prediction": 0.0003968297213151314, + "calibration_in_the_large": 4.171608495149502e-05, + "expected_calibration_error_10bin": 4.171608495149502e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "L50": { + "valid": 2835, + "positives": 1, + "negatives": 2834, + "auroc": 0.7251235003528581, + "auprc": 0.001282051282051282, + "brier": 0.0003527275382472936, + "calibration": { + "observed_rate": 0.0003527336860670194, + "mean_prediction": 0.00021844668916802946, + "calibration_in_the_large": -0.00013428699689898996, + "expected_calibration_error_10bin": 0.00013428699689898996, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + "L53": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 4.0173553077312046e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00030242648950017266, + "calibration_in_the_large": 0.00030242648950017266, + "expected_calibration_error_10bin": 0.00030242648950017266, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "L76": { + "valid": 2793, + "positives": 6, + "negatives": 2787, + "auroc": 0.6366463341705537, + "auprc": 0.003562570770011667, + "brier": 0.002159120137487786, + "calibration": { + "observed_rate": 0.0021482277121374865, + "mean_prediction": 0.0026744246823425417, + "calibration_in_the_large": 0.0005261969702050552, + "expected_calibration_error_10bin": 0.0005261969702050552, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "L89": { + "valid": 2798, + "positives": 8, + "negatives": 2790, + "auroc": 0.8666218637992832, + "auprc": 0.017588297013280105, + "brier": 0.0028444278829086785, + "calibration": { + "observed_rate": 0.0028591851322373124, + "mean_prediction": 0.001024228521547906, + "calibration_in_the_large": -0.0018349566106894064, + "expected_calibration_error_10bin": 0.0018349566106894064, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "L97": { + "valid": 2789, + "positives": 2, + "negatives": 2787, + "auroc": 0.9156799425905993, + "auprc": 0.016568819308545334, + "brier": 0.0007156698250962747, + "calibration": { + "observed_rate": 0.0007171029042667623, + "mean_prediction": 0.0006439100992786253, + "calibration_in_the_large": -7.319280498813705e-05, + "expected_calibration_error_10bin": 7.319280498813705e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "L98": { + "valid": 2824, + "positives": 0, + "negatives": 2824, + "auroc": null, + "auprc": null, + "brier": 2.7849010587766407e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0010032802250347999, + "calibration_in_the_large": 0.0010032802250347999, + "expected_calibration_error_10bin": 0.0010032802250347999, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "M10": { + "valid": 2713, + "positives": 4, + "negatives": 2709, + "auroc": 0.8302879291251384, + "auprc": 0.011951690659240058, + "brier": 0.0014680623746248646, + "calibration": { + "observed_rate": 0.001474382602285293, + "mean_prediction": 0.0014168722878624307, + "calibration_in_the_large": -5.7510314422862295e-05, + "expected_calibration_error_10bin": 5.7510314422862295e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + "M16": { + "valid": 2790, + "positives": 1, + "negatives": 2789, + "auroc": 0.6392972391538185, + "auprc": 0.0009930486593843098, + "brier": 0.00035850699438351956, + "calibration": { + "observed_rate": 0.00035842293906810036, + "mean_prediction": 0.0003264371771686498, + "calibration_in_the_large": -3.198576189945054e-05, + "expected_calibration_error_10bin": 3.198576189945054e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "M17": { + "valid": 2733, + "positives": 2, + "negatives": 2731, + "auroc": 0.8581105822043208, + "auprc": 0.010992795083704175, + "brier": 0.0007304419812442107, + "calibration": { + "observed_rate": 0.0007317965605561653, + "mean_prediction": 0.0003148437601008086, + "calibration_in_the_large": -0.00041695280045535673, + "expected_calibration_error_10bin": 0.00041695280045535673, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "M19": { + "valid": 2674, + "positives": 8, + "negatives": 2666, + "auroc": 0.7036290322580645, + "auprc": 0.008003556823007098, + "brier": 0.0029819411952275716, + "calibration": { + "observed_rate": 0.0029917726252804786, + "mean_prediction": 0.0030944803457335543, + "calibration_in_the_large": 0.00010270772045307573, + "expected_calibration_error_10bin": 0.00010270772045307573, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + "M21": { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.9397163120567376, + "auprc": 0.005847953216374269, + "brier": 0.00035418918254939317, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.00019327119408608663, + "calibration_in_the_large": -0.00016121303136588076, + "expected_calibration_error_10bin": 0.00016121303136588076, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "M25": { + "valid": 2717, + "positives": 5, + "negatives": 2712, + "auroc": 0.810693215339233, + "auprc": 0.018258925876946146, + "brier": 0.0018310229076472808, + "calibration": { + "observed_rate": 0.001840264998159735, + "mean_prediction": 0.002911884238087203, + "calibration_in_the_large": 0.001071619239927468, + "expected_calibration_error_10bin": 0.001071619239927468, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + "M35": { + "valid": 2806, + "positives": 1, + "negatives": 2805, + "auroc": 0.857397504456328, + "auprc": 0.0024937655860349127, + "brier": 0.0003564702728863711, + "calibration": { + "observed_rate": 0.0003563791874554526, + "mean_prediction": 0.00014208846230211232, + "calibration_in_the_large": -0.0002142907251533403, + "expected_calibration_error_10bin": 0.0002142907251533403, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "M46": { + "valid": 2814, + "positives": 0, + "negatives": 2814, + "auroc": null, + "auprc": null, + "brier": 3.5485282111036526e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00034794317049070063, + "calibration_in_the_large": 0.00034794317049070063, + "expected_calibration_error_10bin": 0.00034794317049070063, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "M47": { + "valid": 2743, + "positives": 1, + "negatives": 2742, + "auroc": 0.5525164113785558, + "auprc": 0.0008143322475570033, + "brier": 0.00036476468797047487, + "calibration": { + "observed_rate": 0.0003645643456069996, + "mean_prediction": 0.0005650906861387664, + "calibration_in_the_large": 0.00020052634053176682, + "expected_calibration_error_10bin": 0.00020052634053176682, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "M48": { + "valid": 2690, + "positives": 2, + "negatives": 2688, + "auroc": 0.8612351190476191, + "auprc": 0.00978471214320271, + "brier": 0.0007419673129477118, + "calibration": { + "observed_rate": 0.0007434944237918215, + "mean_prediction": 0.001232265169856505, + "calibration_in_the_large": 0.0004887707460646834, + "expected_calibration_error_10bin": 0.0004887707460646834, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + "M51": { + "valid": 2785, + "positives": 0, + "negatives": 2785, + "auroc": null, + "auprc": null, + "brier": 7.922405904762153e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0007152995332921696, + "calibration_in_the_large": 0.0007152995332921696, + "expected_calibration_error_10bin": 0.0007152995332921696, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "M54": { + "valid": 2567, + "positives": 10, + "negatives": 2557, + "auroc": 0.6544387954634338, + "auprc": 0.012803722814750104, + "brier": 0.003877460387996052, + "calibration": { + "observed_rate": 0.0038955979742890533, + "mean_prediction": 0.004659706217290875, + "calibration_in_the_large": 0.0007641082430018217, + "expected_calibration_error_10bin": 0.0007641082430018217, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + "M62": { + "valid": 2781, + "positives": 0, + "negatives": 2781, + "auroc": null, + "auprc": null, + "brier": 1.0528708127915547e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0008765209657010726, + "calibration_in_the_large": 0.0008765209657010726, + "expected_calibration_error_10bin": 0.0008765209657010726, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "M79": { + "valid": 2697, + "positives": 7, + "negatives": 2690, + "auroc": 0.8951672862453531, + "auprc": 0.03547601210930499, + "brier": 0.0025701908782408433, + "calibration": { + "observed_rate": 0.0025954764553207266, + "mean_prediction": 0.003987214394850162, + "calibration_in_the_large": 0.0013917379395294357, + "expected_calibration_error_10bin": 0.0013917379395294357, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + "M81": { + "valid": 2705, + "positives": 2, + "negatives": 2703, + "auroc": 0.4328523862375139, + "auprc": 0.0015927677360179709, + "brier": 0.0007433788784374257, + "calibration": { + "observed_rate": 0.0007393715341959334, + "mean_prediction": 0.0008625910500864686, + "calibration_in_the_large": 0.0001232195158905352, + "expected_calibration_error_10bin": 0.0001232195158905352, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + "M84": { + "valid": 2818, + "positives": 0, + "negatives": 2818, + "auroc": null, + "auprc": null, + "brier": 6.67357336714957e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004557385963712293, + "calibration_in_the_large": 0.0004557385963712293, + "expected_calibration_error_10bin": 0.0004557385963712293, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "M85": { + "valid": 2768, + "positives": 2, + "negatives": 2766, + "auroc": 0.7575921908893709, + "auprc": 0.002788968617619089, + "brier": 0.0007222441015951578, + "calibration": { + "observed_rate": 0.000722543352601156, + "mean_prediction": 0.0006107040558011991, + "calibration_in_the_large": -0.00011183929679995698, + "expected_calibration_error_10bin": 0.00011183929679995698, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "M86": { + "valid": 2803, + "positives": 3, + "negatives": 2800, + "auroc": 0.9597619047619048, + "auprc": 0.03262138188608777, + "brier": 0.0010635680899799664, + "calibration": { + "observed_rate": 0.0010702818408847663, + "mean_prediction": 0.00047200541216880137, + "calibration_in_the_large": -0.0005982764287159649, + "expected_calibration_error_10bin": 0.0005982764287159649, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + "M94": { + "valid": 2819, + "positives": 1, + "negatives": 2818, + "auroc": 0.8364088005677786, + "auprc": 0.0021645021645021645, + "brier": 0.00035467340276031746, + "calibration": { + "observed_rate": 0.000354735721887194, + "mean_prediction": 7.18088283057072e-05, + "calibration_in_the_large": -0.0002829268935814868, + "expected_calibration_error_10bin": 0.0002829268935814868, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "M96": { + "valid": 2804, + "positives": 0, + "negatives": 2804, + "auroc": null, + "auprc": null, + "brier": 6.220703746054536e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0014244659842369792, + "calibration_in_the_large": 0.0014244659842369792, + "expected_calibration_error_10bin": 0.0014244659842369792, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "N12": { + "valid": 2831, + "positives": 3, + "negatives": 2828, + "auroc": 0.6450966525223951, + "auprc": 0.0028625187581426542, + "brier": 0.0010594416472099859, + "calibration": { + "observed_rate": 0.0010596962204168139, + "mean_prediction": 0.0002631377828809591, + "calibration_in_the_large": -0.0007965584375358547, + "expected_calibration_error_10bin": 0.0007965584375358547, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N13": { + "valid": 2756, + "positives": 2, + "negatives": 2754, + "auroc": 0.6218228031953522, + "auprc": 0.0015688984530625447, + "brier": 0.0007274715844096815, + "calibration": { + "observed_rate": 0.000725689404934688, + "mean_prediction": 0.0009119194996110283, + "calibration_in_the_large": 0.00018623009467634035, + "expected_calibration_error_10bin": 0.00018623009467634035, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "N14": { + "valid": 2826, + "positives": 3, + "negatives": 2823, + "auroc": 0.7360963513992207, + "auprc": 0.003429612282071299, + "brier": 0.0010610682506917307, + "calibration": { + "observed_rate": 0.0010615711252653928, + "mean_prediction": 0.0003200336384283423, + "calibration_in_the_large": -0.0007415374868370505, + "expected_calibration_error_10bin": 0.0007415374868370505, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "N17": { + "valid": 2292, + "positives": 25, + "negatives": 2267, + "auroc": 0.7440317600352889, + "auprc": 0.05030711755818493, + "brier": 0.010721801479610136, + "calibration": { + "observed_rate": 0.010907504363001745, + "mean_prediction": 0.011417155819139222, + "calibration_in_the_large": 0.0005096514561374766, + "expected_calibration_error_10bin": 0.0005096514561374767, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + "N18": { + "valid": 2440, + "positives": 11, + "negatives": 2429, + "auroc": 0.8649650061753809, + "auprc": 0.03835167426098818, + "brier": 0.0044338139079796775, + "calibration": { + "observed_rate": 0.004508196721311476, + "mean_prediction": 0.0025943855984439964, + "calibration_in_the_large": -0.0019138111228674793, + "expected_calibration_error_10bin": 0.0019138111228674793, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + "N20": { + "valid": 2806, + "positives": 6, + "negatives": 2800, + "auroc": 0.6923214285714285, + "auprc": 0.0045234537302422445, + "brier": 0.002136902724591552, + "calibration": { + "observed_rate": 0.0021382751247327157, + "mean_prediction": 0.00028730315475315916, + "calibration_in_the_large": -0.0018509719699795566, + "expected_calibration_error_10bin": 0.0018509719699795566, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "N25": { + "valid": 2831, + "positives": 2, + "negatives": 2829, + "auroc": 0.9261223047013079, + "auprc": 0.021762414800389485, + "brier": 0.0007050447850513891, + "calibration": { + "observed_rate": 0.0007064641469445425, + "mean_prediction": 0.00017209731228218868, + "calibration_in_the_large": -0.0005343668346623539, + "expected_calibration_error_10bin": 0.0005343668346623539, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N28": { + "valid": 2789, + "positives": 3, + "negatives": 2786, + "auroc": 0.9206748025843503, + "auprc": 0.01439933290482364, + "brier": 0.0010704967484219056, + "calibration": { + "observed_rate": 0.0010756543564001434, + "mean_prediction": 0.001134036669864549, + "calibration_in_the_large": 5.8382313464405526e-05, + "expected_calibration_error_10bin": 5.8382313464405526e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "N30": { + "valid": 2829, + "positives": 4, + "negatives": 2825, + "auroc": 0.6314159292035398, + "auprc": 0.00855232244204915, + "brier": 0.0014115788416686032, + "calibration": { + "observed_rate": 0.0014139271827500884, + "mean_prediction": 0.0007141632075670443, + "calibration_in_the_large": -0.0006997639751830442, + "expected_calibration_error_10bin": 0.0006997639751830442, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N32": { + "valid": 2807, + "positives": 5, + "negatives": 2802, + "auroc": 0.7690221270521056, + "auprc": 0.020875505257566113, + "brier": 0.0017700553624181948, + "calibration": { + "observed_rate": 0.0017812611328820805, + "mean_prediction": 0.0013319759679621295, + "calibration_in_the_large": -0.00044928516491995097, + "expected_calibration_error_10bin": 0.00044928516491995097, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "N39": { + "valid": 2520, + "positives": 16, + "negatives": 2504, + "auroc": 0.7672474041533547, + "auprc": 0.015560022380180456, + "brier": 0.006327246016758949, + "calibration": { + "observed_rate": 0.006349206349206349, + "mean_prediction": 0.009932518933598498, + "calibration_in_the_large": 0.003583312584392149, + "expected_calibration_error_10bin": 0.003583312584392149, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + "N40": { + "valid": 2606, + "positives": 5, + "negatives": 2601, + "auroc": 0.8897347174163783, + "auprc": 0.019023755676509446, + "brier": 0.001910596228827165, + "calibration": { + "observed_rate": 0.001918649270913277, + "mean_prediction": 0.003364909804689732, + "calibration_in_the_large": 0.001446260533776455, + "expected_calibration_error_10bin": 0.001446260533776455, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + "N73": { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.9550919377652051, + "auprc": 0.0078125, + "brier": 0.0003531121258215183, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.00019685896815246405, + "calibration_in_the_large": -0.00015662282753505806, + "expected_calibration_error_10bin": 0.00015662282753505806, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N99": { + "valid": 2799, + "positives": 2, + "negatives": 2797, + "auroc": 0.657311405076868, + "auprc": 0.004158604615465404, + "brier": 0.0007139218589935349, + "calibration": { + "observed_rate": 0.0007145409074669524, + "mean_prediction": 0.0003545232729366395, + "calibration_in_the_large": -0.0003600176345303129, + "expected_calibration_error_10bin": 0.0003600176345303129, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + "O69": { + "valid": 2743, + "positives": 0, + "negatives": 2743, + "auroc": null, + "auprc": null, + "brier": 1.3828333092611101e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 9.263697317293441e-05, + "calibration_in_the_large": 9.263697317293441e-05, + "expected_calibration_error_10bin": 9.263697317293441e-05, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "O99": { + "valid": 2652, + "positives": 0, + "negatives": 2652, + "auroc": null, + "auprc": null, + "brier": 6.315517477042484e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00014308598497410737, + "calibration_in_the_large": 0.00014308598497410737, + "expected_calibration_error_10bin": 0.00014308598497410737, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9328174463594794 + }, + "Q21": { + "valid": 2810, + "positives": 0, + "negatives": 2810, + "auroc": null, + "auprc": null, + "brier": 2.3838998734910094e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0003163449374139719, + "calibration_in_the_large": 0.0003163449374139719, + "expected_calibration_error_10bin": 0.0003163449374139719, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "U07": { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 7.319186265848692e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00048246617316464086, + "calibration_in_the_large": 0.00048246617316464086, + "expected_calibration_error_10bin": 0.00048246617316464086, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + } + }, + "60": { + "A04": { + "valid": 2782, + "positives": 7, + "negatives": 2775, + "auroc": 0.7689060489060489, + "auprc": 0.05015998942363244, + "brier": 0.00249135353683862, + "calibration": { + "observed_rate": 0.0025161754133716753, + "mean_prediction": 0.0041906232880550625, + "calibration_in_the_large": 0.0016744478746833873, + "expected_calibration_error_10bin": 0.0016744478746833873, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "A08": { + "valid": 2818, + "positives": 7, + "negatives": 2811, + "auroc": 0.7897037149972048, + "auprc": 0.02308984784957232, + "brier": 0.002465076737147334, + "calibration": { + "observed_rate": 0.00248403122782115, + "mean_prediction": 0.0013261277750344278, + "calibration_in_the_large": -0.001157903452786722, + "expected_calibration_error_10bin": 0.001157903452786722, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "A41": { + "valid": 2664, + "positives": 19, + "negatives": 2645, + "auroc": 0.8166749577156501, + "auprc": 0.04621478637790553, + "brier": 0.0070684810886954596, + "calibration": { + "observed_rate": 0.007132132132132132, + "mean_prediction": 0.01130297018877806, + "calibration_in_the_large": 0.004170838056645928, + "expected_calibration_error_10bin": 0.004170838056645927, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + "B00": { + "valid": 2819, + "positives": 1, + "negatives": 2818, + "auroc": 0.9932576295244855, + "auprc": 0.05, + "brier": 0.00034993020414633843, + "calibration": { + "observed_rate": 0.000354735721887194, + "mean_prediction": 0.0003805702174321253, + "calibration_in_the_large": 2.5834495544931285e-05, + "expected_calibration_error_10bin": 2.5834495544931285e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "B02": { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 5.244220705278826e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0002742087241697896, + "calibration_in_the_large": 0.0002742087241697896, + "expected_calibration_error_10bin": 0.0002742087241697896, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "B18": { + "valid": 2782, + "positives": 3, + "negatives": 2779, + "auroc": 0.9716924553196593, + "auprc": 0.09351851851851851, + "brier": 0.0010579054796425614, + "calibration": { + "observed_rate": 0.0010783608914450035, + "mean_prediction": 0.0004622741473576164, + "calibration_in_the_large": -0.0006160867440873871, + "expected_calibration_error_10bin": 0.0006160867440873871, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "B19": { + "valid": 2763, + "positives": 12, + "negatives": 2751, + "auroc": 0.8521749666787835, + "auprc": 0.047469525591229245, + "brier": 0.004299772648089387, + "calibration": { + "observed_rate": 0.004343105320304018, + "mean_prediction": 0.000851976718816865, + "calibration_in_the_large": -0.0034911286014871526, + "expected_calibration_error_10bin": 0.0034911286014871526, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "B20": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 9.082456975099996e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00011453496810207256, + "calibration_in_the_large": 0.00011453496810207256, + "expected_calibration_error_10bin": 0.00011453496810207256, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "B34": { + "valid": 2831, + "positives": 2, + "negatives": 2829, + "auroc": 0.9747260516083421, + "auprc": 0.034189805221715705, + "brier": 0.0007023831824509456, + "calibration": { + "observed_rate": 0.0007064641469445425, + "mean_prediction": 0.00038118560151317193, + "calibration_in_the_large": -0.0003252785454313706, + "expected_calibration_error_10bin": 0.0003252785454313706, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "B35": { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 1.7958840945157558e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0006073141128965356, + "calibration_in_the_large": 0.0006073141128965356, + "expected_calibration_error_10bin": 0.0006073141128965356, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "B37": { + "valid": 2768, + "positives": 15, + "negatives": 2753, + "auroc": 0.7480324494490859, + "auprc": 0.02290404258509681, + "brier": 0.005360638068162199, + "calibration": { + "observed_rate": 0.00541907514450867, + "mean_prediction": 0.003718300593916897, + "calibration_in_the_large": -0.0017007745505917735, + "expected_calibration_error_10bin": 0.0017007745505917735, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "B95": { + "valid": 2678, + "positives": 27, + "negatives": 2651, + "auroc": 0.7413973762521481, + "auprc": 0.030614511687450878, + "brier": 0.009949490896696292, + "calibration": { + "observed_rate": 0.010082150858849889, + "mean_prediction": 0.011393045489711942, + "calibration_in_the_large": 0.0013108946308620535, + "expected_calibration_error_10bin": 0.0013108946308620553, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + "B96": { + "valid": 2630, + "positives": 30, + "negatives": 2600, + "auroc": 0.7968846153846154, + "auprc": 0.0711855869121642, + "brier": 0.011053380665508155, + "calibration": { + "observed_rate": 0.011406844106463879, + "mean_prediction": 0.01582336810387816, + "calibration_in_the_large": 0.004416523997414282, + "expected_calibration_error_10bin": 0.0044165239974142834, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + "B97": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7856384860275911, + "auprc": 0.0016474464579901153, + "brier": 0.0003553440566083058, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0002574908743595426, + "calibration_in_the_large": -9.611591489081103e-05, + "expected_calibration_error_10bin": 9.611591489081103e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "C18": { + "valid": 2824, + "positives": 1, + "negatives": 2823, + "auroc": 0.9953949698901877, + "auprc": 0.07142857142857142, + "brier": 0.0003516113777640893, + "calibration": { + "observed_rate": 0.0003541076487252125, + "mean_prediction": 0.0002840751526779901, + "calibration_in_the_large": -7.003249604722238e-05, + "expected_calibration_error_10bin": 7.003249604722238e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "C22": { + "valid": 2812, + "positives": 3, + "negatives": 2809, + "auroc": 0.9428028954550849, + "auprc": 0.05011043887448382, + "brier": 0.0010560458742047232, + "calibration": { + "observed_rate": 0.0010668563300142249, + "mean_prediction": 0.000415735159615938, + "calibration_in_the_large": -0.0006511211703982868, + "expected_calibration_error_10bin": 0.0006511211703982868, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + "C25": { + "valid": 2809, + "positives": 1, + "negatives": 2808, + "auroc": 0.9989316239316239, + "auprc": 0.25, + "brier": 0.00033294007716267246, + "calibration": { + "observed_rate": 0.000355998576005696, + "mean_prediction": 0.00031430111194878706, + "calibration_in_the_large": -4.169746405690894e-05, + "expected_calibration_error_10bin": 0.00011631139230007141, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "C61": { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9628968961826614, + "auprc": 0.017821921668075513, + "brier": 0.0007102068953846075, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0004568420150857534, + "calibration_in_the_large": -0.00025617046263260666, + "expected_calibration_error_10bin": 0.00025617046263260666, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "C67": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9361513972408914, + "auprc": 0.01622537939941879, + "brier": 0.0007055528363628442, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.00022349752249434905, + "calibration_in_the_large": -0.0004834660688806952, + "expected_calibration_error_10bin": 0.0004834660688806952, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "C77": { + "valid": 2762, + "positives": 8, + "negatives": 2754, + "auroc": 0.8671023965141612, + "auprc": 0.11788895498609095, + "brier": 0.002749709324197718, + "calibration": { + "observed_rate": 0.002896451846488052, + "mean_prediction": 0.001945778652245556, + "calibration_in_the_large": -0.000950673194242496, + "expected_calibration_error_10bin": 0.0009506731942424963, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C78": { + "valid": 2762, + "positives": 14, + "negatives": 2748, + "auroc": 0.9048918694115201, + "auprc": 0.14757751797946872, + "brier": 0.004731140202662636, + "calibration": { + "observed_rate": 0.005068790731354091, + "mean_prediction": 0.0029291022250806324, + "calibration_in_the_large": -0.0021396885062734588, + "expected_calibration_error_10bin": 0.0023829781141964435, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C79": { + "valid": 2751, + "positives": 8, + "negatives": 2743, + "auroc": 0.9150109369303682, + "auprc": 0.06008515514365798, + "brier": 0.0030018531042520034, + "calibration": { + "observed_rate": 0.0029080334423845873, + "mean_prediction": 0.003366127608687143, + "calibration_in_the_large": 0.00045809416630255553, + "expected_calibration_error_10bin": 0.0017932711237807525, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "C83": { + "valid": 2820, + "positives": 0, + "negatives": 2820, + "auroc": null, + "auprc": null, + "brier": 3.482500131865699e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00020263903368675153, + "calibration_in_the_large": 0.00020263903368675153, + "expected_calibration_error_10bin": 0.00020263903368675153, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "D25": { + "valid": 2792, + "positives": 2, + "negatives": 2790, + "auroc": 0.9424731182795699, + "auprc": 0.16978193146417445, + "brier": 0.0007133443686460268, + "calibration": { + "observed_rate": 0.0007163323782234957, + "mean_prediction": 0.0001973243105945757, + "calibration_in_the_large": -0.00051900806762892, + "expected_calibration_error_10bin": 0.00051900806762892, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "D47": { + "valid": 2796, + "positives": 5, + "negatives": 2791, + "auroc": 0.6940164815478324, + "auprc": 0.00447593168959943, + "brier": 0.0017980334487064438, + "calibration": { + "observed_rate": 0.00178826895565093, + "mean_prediction": 0.0020966306777626697, + "calibration_in_the_large": 0.0003083617221117398, + "expected_calibration_error_10bin": 0.0003083617221117398, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "D50": { + "valid": 2663, + "positives": 19, + "negatives": 2644, + "auroc": 0.81732223903177, + "auprc": 0.08503271551231087, + "brier": 0.006863608332510444, + "calibration": { + "observed_rate": 0.007134810364250845, + "mean_prediction": 0.0067258274604841285, + "calibration_in_the_large": -0.0004089829037667164, + "expected_calibration_error_10bin": 0.0004866687227325562, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + "D53": { + "valid": 2805, + "positives": 7, + "negatives": 2798, + "auroc": 0.8347799448585724, + "auprc": 0.024014583763546975, + "brier": 0.0024871716837666304, + "calibration": { + "observed_rate": 0.0024955436720142605, + "mean_prediction": 0.0028371372387229646, + "calibration_in_the_large": 0.0003415935667087041, + "expected_calibration_error_10bin": 0.00034159356670870444, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "D59": { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 7.210002290779953e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0003676219773716378, + "calibration_in_the_large": 0.0003676219773716378, + "expected_calibration_error_10bin": 0.0003676219773716378, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "D61": { + "valid": 2773, + "positives": 9, + "negatives": 2764, + "auroc": 0.9701720533847885, + "auprc": 0.06969347321496379, + "brier": 0.003203527554108105, + "calibration": { + "observed_rate": 0.0032455824017309774, + "mean_prediction": 0.003915203729148939, + "calibration_in_the_large": 0.0006696213274179617, + "expected_calibration_error_10bin": 0.0006696213274179618, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "D62": { + "valid": 2499, + "positives": 21, + "negatives": 2478, + "auroc": 0.7783927130174103, + "auprc": 0.021987589421410894, + "brier": 0.008306915721903306, + "calibration": { + "observed_rate": 0.008403361344537815, + "mean_prediction": 0.01084326511652277, + "calibration_in_the_large": 0.0024399037719849553, + "expected_calibration_error_10bin": 0.0024399037719849553, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + "D63": { + "valid": 2686, + "positives": 31, + "negatives": 2655, + "auroc": 0.9180851710102667, + "auprc": 0.09078382473138455, + "brier": 0.01095332041957463, + "calibration": { + "observed_rate": 0.01154132539091586, + "mean_prediction": 0.010590559852044535, + "calibration_in_the_large": -0.0009507655388713253, + "expected_calibration_error_10bin": 0.001747169377380127, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + "D64": { + "valid": 2434, + "positives": 51, + "negatives": 2383, + "auroc": 0.8476051771946714, + "auprc": 0.10531875171185595, + "brier": 0.01957611979108239, + "calibration": { + "observed_rate": 0.0209531635168447, + "mean_prediction": 0.022967793545421694, + "calibration_in_the_large": 0.002014630028576995, + "expected_calibration_error_10bin": 0.0031496735162276947, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + "D65": { + "valid": 2833, + "positives": 1, + "negatives": 2832, + "auroc": 0.9456214689265536, + "auprc": 0.0064516129032258064, + "brier": 0.00035407439404620226, + "calibration": { + "observed_rate": 0.00035298270384751147, + "mean_prediction": 0.00042813982265550764, + "calibration_in_the_large": 7.515711880799617e-05, + "expected_calibration_error_10bin": 7.515711880799617e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + "D68": { + "valid": 2682, + "positives": 21, + "negatives": 2661, + "auroc": 0.859558705105492, + "auprc": 0.062245849596423396, + "brier": 0.007601331549262677, + "calibration": { + "observed_rate": 0.007829977628635347, + "mean_prediction": 0.00522837045628848, + "calibration_in_the_large": -0.0026016071723468674, + "expected_calibration_error_10bin": 0.0032319369194526507, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + "D69": { + "valid": 2586, + "positives": 30, + "negatives": 2556, + "auroc": 0.8857459572248305, + "auprc": 0.1842340462521022, + "brier": 0.010510188720934826, + "calibration": { + "observed_rate": 0.01160092807424594, + "mean_prediction": 0.008714577081691663, + "calibration_in_the_large": -0.002886350992554276, + "expected_calibration_error_10bin": 0.003597411252031076, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + "D70": { + "valid": 2787, + "positives": 8, + "negatives": 2779, + "auroc": 0.9433249370277078, + "auprc": 0.1809153328056664, + "brier": 0.002994690090135352, + "calibration": { + "observed_rate": 0.0028704700394689632, + "mean_prediction": 0.003757206464241417, + "calibration_in_the_large": 0.0008867364247724537, + "expected_calibration_error_10bin": 0.002238806099399012, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "D72": { + "valid": 2595, + "positives": 26, + "negatives": 2569, + "auroc": 0.7342725394496512, + "auprc": 0.057374394306040216, + "brier": 0.009780046214573379, + "calibration": { + "observed_rate": 0.01001926782273603, + "mean_prediction": 0.011398342410654282, + "calibration_in_the_large": 0.0013790745879182515, + "expected_calibration_error_10bin": 0.0013790745879182515, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + "D73": { + "valid": 2824, + "positives": 1, + "negatives": 2823, + "auroc": 0.9943322706340773, + "auprc": 0.058823529411764705, + "brier": 0.00034779960870819467, + "calibration": { + "observed_rate": 0.0003541076487252125, + "mean_prediction": 0.0005543361497176849, + "calibration_in_the_large": 0.00020022850099247238, + "expected_calibration_error_10bin": 0.00020022850099247238, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "D75": { + "valid": 2831, + "positives": 0, + "negatives": 2831, + "auroc": null, + "auprc": null, + "brier": 7.328078131572421e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00048004396094002865, + "calibration_in_the_large": 0.00048004396094002865, + "expected_calibration_error_10bin": 0.00048004396094002865, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.995779106577559 + }, + "D80": { + "valid": 2832, + "positives": 3, + "negatives": 2829, + "auroc": 0.9903381642512077, + "auprc": 0.07913105413105413, + "brier": 0.0010391906703815922, + "calibration": { + "observed_rate": 0.001059322033898305, + "mean_prediction": 0.0005255873743918929, + "calibration_in_the_large": -0.0005337346595064122, + "expected_calibration_error_10bin": 0.0005337346595064122, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "D89": { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.8343915343915344, + "auprc": 0.007188240739442053, + "brier": 0.0007107065478269824, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.00020157833322300038, + "calibration_in_the_large": -0.0005033917055503517, + "expected_calibration_error_10bin": 0.0005033917055503517, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "E03": { + "valid": 2480, + "positives": 11, + "negatives": 2469, + "auroc": 0.7031923119407931, + "auprc": 0.010339792587287443, + "brier": 0.004413620405155744, + "calibration": { + "observed_rate": 0.004435483870967742, + "mean_prediction": 0.002328693321138534, + "calibration_in_the_large": -0.002106790549829208, + "expected_calibration_error_10bin": 0.002106790549829208, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + "E04": { + "valid": 2775, + "positives": 4, + "negatives": 2771, + "auroc": 0.6196319018404908, + "auprc": 0.0038315779271375474, + "brier": 0.0014398729508369491, + "calibration": { + "observed_rate": 0.0014414414414414415, + "mean_prediction": 0.0010155878484543824, + "calibration_in_the_large": -0.0004258535929870591, + "expected_calibration_error_10bin": 0.0004258535929870591, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "E05": { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.11911554921540657, + "auprc": 0.0005939560457683415, + "brier": 0.0007132342765646067, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0004951043785467684, + "calibration_in_the_large": -0.00021765399636413686, + "expected_calibration_error_10bin": 0.00021765399636413686, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "E11": { + "valid": 2194, + "positives": 9, + "negatives": 2185, + "auroc": 0.7042461225527588, + "auprc": 0.054312580053143655, + "brier": 0.004058415632710041, + "calibration": { + "observed_rate": 0.004102096627164996, + "mean_prediction": 0.0030988525374820745, + "calibration_in_the_large": -0.0010032440896829212, + "expected_calibration_error_10bin": 0.0010032440896829212, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + "E16": { + "valid": 2816, + "positives": 3, + "negatives": 2813, + "auroc": 0.665481692143619, + "auprc": 0.0022666803116541466, + "brier": 0.0010690762989067236, + "calibration": { + "observed_rate": 0.001065340909090909, + "mean_prediction": 0.0012029257794853006, + "calibration_in_the_large": 0.0001375848703943916, + "expected_calibration_error_10bin": 0.0001375848703943916, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "E21": { + "valid": 2814, + "positives": 1, + "negatives": 2813, + "auroc": 0.9729825808745112, + "auprc": 0.012987012987012988, + "brier": 0.00035644358698635407, + "calibration": { + "observed_rate": 0.00035536602700781805, + "mean_prediction": 0.0006524489211051364, + "calibration_in_the_large": 0.00029708289409731837, + "expected_calibration_error_10bin": 0.00029708289409731837, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "E22": { + "valid": 2802, + "positives": 3, + "negatives": 2799, + "auroc": 0.8513754912468738, + "auprc": 0.005398984763719929, + "brier": 0.001097014482228127, + "calibration": { + "observed_rate": 0.0010706638115631692, + "mean_prediction": 0.002643877428817827, + "calibration_in_the_large": 0.0015732136172546577, + "expected_calibration_error_10bin": 0.0015732136172546577, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "E27": { + "valid": 2811, + "positives": 0, + "negatives": 2811, + "auroc": null, + "auprc": null, + "brier": 5.519984459682209e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0010473434329777472, + "calibration_in_the_large": 0.0010473434329777472, + "expected_calibration_error_10bin": 0.0010473434329777472, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9887442842068238 + }, + "E43": { + "valid": 2748, + "positives": 19, + "negatives": 2729, + "auroc": 0.8602341324178897, + "auprc": 0.05961218678680008, + "brier": 0.006712470838939421, + "calibration": { + "observed_rate": 0.006914119359534207, + "mean_prediction": 0.006062887500278656, + "calibration_in_the_large": -0.0008512318592555513, + "expected_calibration_error_10bin": 0.0010089041583900562, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + "E44": { + "valid": 2800, + "positives": 8, + "negatives": 2792, + "auroc": 0.7776235673352435, + "auprc": 0.01811978563657555, + "brier": 0.002851862069348053, + "calibration": { + "observed_rate": 0.002857142857142857, + "mean_prediction": 0.004224369546487391, + "calibration_in_the_large": 0.0013672266893445342, + "expected_calibration_error_10bin": 0.0013672266893445342, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "E46": { + "valid": 2772, + "positives": 16, + "negatives": 2756, + "auroc": 0.8190312046444121, + "auprc": 0.061224530814539116, + "brier": 0.005633615689558362, + "calibration": { + "observed_rate": 0.005772005772005772, + "mean_prediction": 0.006710335259308778, + "calibration_in_the_large": 0.000938329487303006, + "expected_calibration_error_10bin": 0.0010715681018546109, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + "E53": { + "valid": 2804, + "positives": 2, + "negatives": 2802, + "auroc": 0.8734832262669522, + "auprc": 0.004189809330771188, + "brier": 0.0007159109881170214, + "calibration": { + "observed_rate": 0.0007132667617689016, + "mean_prediction": 0.0010479716124399123, + "calibration_in_the_large": 0.00033470485067101075, + "expected_calibration_error_10bin": 0.00033470485067101075, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "E55": { + "valid": 2737, + "positives": 11, + "negatives": 2726, + "auroc": 0.5051023811111852, + "auprc": 0.005331974251045097, + "brier": 0.004038217183637117, + "calibration": { + "observed_rate": 0.00401899890390939, + "mean_prediction": 0.004384270758639186, + "calibration_in_the_large": 0.00036527185472979597, + "expected_calibration_error_10bin": 0.0003652718547297963, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + "E66": { + "valid": 2371, + "positives": 16, + "negatives": 2355, + "auroc": 0.7208067940552016, + "auprc": 0.018856646074745645, + "brier": 0.006679851416787735, + "calibration": { + "observed_rate": 0.006748207507380852, + "mean_prediction": 0.006379357560598443, + "calibration_in_the_large": -0.00036884994678240864, + "expected_calibration_error_10bin": 0.00036884994678240864, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + "E78": { + "valid": 1572, + "positives": 19, + "negatives": 1553, + "auroc": 0.6419832582099163, + "auprc": 0.027437567890324616, + "brier": 0.01204588462257119, + "calibration": { + "observed_rate": 0.012086513994910942, + "mean_prediction": 0.010664035943334564, + "calibration_in_the_large": -0.0014224780515763782, + "expected_calibration_error_10bin": 0.002676676010499553, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + "E80": { + "valid": 2823, + "positives": 3, + "negatives": 2820, + "auroc": 0.9654846335697399, + "auprc": 0.019604902860553202, + "brier": 0.0010628065362542445, + "calibration": { + "observed_rate": 0.0010626992561105207, + "mean_prediction": 0.0008841774622576381, + "calibration_in_the_large": -0.00017852179385288258, + "expected_calibration_error_10bin": 0.00017852179385288258, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "E83": { + "valid": 2653, + "positives": 26, + "negatives": 2627, + "auroc": 0.8332113261690727, + "auprc": 0.07934295526556828, + "brier": 0.00937412009947449, + "calibration": { + "observed_rate": 0.00980022615906521, + "mean_prediction": 0.009006512709169695, + "calibration_in_the_large": -0.0007937134498955146, + "expected_calibration_error_10bin": 0.0009989080562559402, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + "E86": { + "valid": 2587, + "positives": 38, + "negatives": 2549, + "auroc": 0.8071999339266173, + "auprc": 0.05861058470420746, + "brier": 0.014241676697520906, + "calibration": { + "observed_rate": 0.014688828759180518, + "mean_prediction": 0.019829094044204115, + "calibration_in_the_large": 0.0051402652850235965, + "expected_calibration_error_10bin": 0.005140265285023597, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + "E87": { + "valid": 2185, + "positives": 52, + "negatives": 2133, + "auroc": 0.801642684554077, + "auprc": 0.09449888223882265, + "brier": 0.022416086622184347, + "calibration": { + "observed_rate": 0.02379862700228833, + "mean_prediction": 0.02468723384072062, + "calibration_in_the_large": 0.0008886068384322925, + "expected_calibration_error_10bin": 0.0008886068384322909, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + "E88": { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.9483534707415304, + "auprc": 0.05732924482924482, + "brier": 0.001051315228456849, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.0016408090831128862, + "calibration_in_the_large": 0.0005758463568083067, + "expected_calibration_error_10bin": 0.0005758463568083067, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "E89": { + "valid": 2780, + "positives": 4, + "negatives": 2776, + "auroc": 0.7287463976945245, + "auprc": 0.0032868646927853946, + "brier": 0.0014372516853695765, + "calibration": { + "observed_rate": 0.0014388489208633094, + "mean_prediction": 0.001707503472415273, + "calibration_in_the_large": 0.0002686545515519637, + "expected_calibration_error_10bin": 0.0002686545515519637, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "F02": { + "valid": 2802, + "positives": 1, + "negatives": 2801, + "auroc": 0.7115315958586219, + "auprc": 0.0012360939431396785, + "brier": 0.00036620725747898135, + "calibration": { + "observed_rate": 0.00035688793718772306, + "mean_prediction": 0.001072210505915708, + "calibration_in_the_large": 0.0007153225687279851, + "expected_calibration_error_10bin": 0.0007153225687279851, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "F03": { + "valid": 2739, + "positives": 7, + "negatives": 2732, + "auroc": 0.8708952102070696, + "auprc": 0.0130871741684604, + "brier": 0.0025568266052817834, + "calibration": { + "observed_rate": 0.002555677254472435, + "mean_prediction": 0.0026799884185707457, + "calibration_in_the_large": 0.00012431116409831067, + "expected_calibration_error_10bin": 0.00012431116409831067, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "F05": { + "valid": 2750, + "positives": 9, + "negatives": 2741, + "auroc": 0.7483481292310187, + "auprc": 0.016246519600453882, + "brier": 0.003273860132201981, + "calibration": { + "observed_rate": 0.0032727272727272726, + "mean_prediction": 0.004301069324133674, + "calibration_in_the_large": 0.0010283420514064015, + "expected_calibration_error_10bin": 0.0010283420514064022, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "F06": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.6752741422002122, + "auprc": 0.001088139281828074, + "brier": 0.0003557653712779867, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0008955991180401111, + "calibration_in_the_large": 0.0005419923287897574, + "expected_calibration_error_10bin": 0.0005419923287897574, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "F10": { + "valid": 2560, + "positives": 9, + "negatives": 2551, + "auroc": 0.8520405941025306, + "auprc": 0.10954843591297114, + "brier": 0.003346479107819785, + "calibration": { + "observed_rate": 0.003515625, + "mean_prediction": 0.003685563259983837, + "calibration_in_the_large": 0.0001699382599838371, + "expected_calibration_error_10bin": 0.0005396081877336198, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "F11": { + "valid": 2741, + "positives": 6, + "negatives": 2735, + "auroc": 0.8694698354661792, + "auprc": 0.04456617196286522, + "brier": 0.002165926386928108, + "calibration": { + "observed_rate": 0.0021889821233126595, + "mean_prediction": 0.002133875032864605, + "calibration_in_the_large": -5.5107090448054414e-05, + "expected_calibration_error_10bin": 0.0002693026387401153, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "F12": { + "valid": 2777, + "positives": 8, + "negatives": 2769, + "auroc": 0.9087667027807873, + "auprc": 0.019871207080874267, + "brier": 0.002859912160194408, + "calibration": { + "observed_rate": 0.0028808066258552397, + "mean_prediction": 0.0014398199381053546, + "calibration_in_the_large": -0.001440986687749885, + "expected_calibration_error_10bin": 0.001440986687749885, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "F14": { + "valid": 2787, + "positives": 4, + "negatives": 2783, + "auroc": 0.9771828961552281, + "auprc": 0.040399263998006245, + "brier": 0.0014208742570854152, + "calibration": { + "observed_rate": 0.0014352350197344816, + "mean_prediction": 0.0006108810772703796, + "calibration_in_the_large": -0.000824353942464102, + "expected_calibration_error_10bin": 0.000824353942464102, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "F15": { + "valid": 2823, + "positives": 5, + "negatives": 2818, + "auroc": 0.9801277501774308, + "auprc": 0.06034802270422732, + "brier": 0.0017600593200430112, + "calibration": { + "observed_rate": 0.001771165426850868, + "mean_prediction": 0.00021450131379724605, + "calibration_in_the_large": -0.001556664113053622, + "expected_calibration_error_10bin": 0.001556664113053622, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "F17": { + "valid": 2426, + "positives": 19, + "negatives": 2407, + "auroc": 0.8820763999737607, + "auprc": 0.08585445582502872, + "brier": 0.007515357092282297, + "calibration": { + "observed_rate": 0.007831821929101401, + "mean_prediction": 0.006578561823556532, + "calibration_in_the_large": -0.0012532601055448688, + "expected_calibration_error_10bin": 0.0018472140519029672, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + "F19": { + "valid": 2801, + "positives": 8, + "negatives": 2793, + "auroc": 0.9652703186537773, + "auprc": 0.16071445966270065, + "brier": 0.0027841195372997713, + "calibration": { + "observed_rate": 0.002856122813280971, + "mean_prediction": 0.0006877157105065095, + "calibration_in_the_large": -0.0021684071027744615, + "expected_calibration_error_10bin": 0.0021684071027744615, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F20": { + "valid": 2808, + "positives": 1, + "negatives": 2807, + "auroc": 0.9921624510153189, + "auprc": 0.043478260869565216, + "brier": 0.00035336449244524875, + "calibration": { + "observed_rate": 0.00035612535612535614, + "mean_prediction": 0.0003154247069514416, + "calibration_in_the_large": -4.070064917391456e-05, + "expected_calibration_error_10bin": 4.070064917391456e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + "F22": { + "valid": 2821, + "positives": 0, + "negatives": 2821, + "auroc": null, + "auprc": null, + "brier": 1.2570001338045597e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0005181075270389396, + "calibration_in_the_large": 0.0005181075270389396, + "expected_calibration_error_10bin": 0.0005181075270389396, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "F25": { + "valid": 2819, + "positives": 2, + "negatives": 2817, + "auroc": 0.8127440539581114, + "auprc": 0.009068532193289286, + "brier": 0.0007084943694291216, + "calibration": { + "observed_rate": 0.000709471443774388, + "mean_prediction": 0.00031319331564271424, + "calibration_in_the_large": -0.0003962781281316738, + "expected_calibration_error_10bin": 0.0003962781281316738, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "F29": { + "valid": 2806, + "positives": 5, + "negatives": 2801, + "auroc": 0.8197786504819707, + "auprc": 0.006895779540274946, + "brier": 0.0017800368490208179, + "calibration": { + "observed_rate": 0.001781895937277263, + "mean_prediction": 0.0003721550521196388, + "calibration_in_the_large": -0.0014097408851576243, + "expected_calibration_error_10bin": 0.0014097408851576243, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "F31": { + "valid": 2724, + "positives": 7, + "negatives": 2717, + "auroc": 0.8365318891634681, + "auprc": 0.03376255683167551, + "brier": 0.0025426060754416163, + "calibration": { + "observed_rate": 0.0025697503671071953, + "mean_prediction": 0.001374021576877364, + "calibration_in_the_large": -0.0011957287902298313, + "expected_calibration_error_10bin": 0.0011957287902298313, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + "F32": { + "valid": 2200, + "positives": 29, + "negatives": 2171, + "auroc": 0.7245032481456186, + "auprc": 0.046910741543430085, + "brier": 0.0129859596996316, + "calibration": { + "observed_rate": 0.013181818181818182, + "mean_prediction": 0.019723094734257426, + "calibration_in_the_large": 0.006541276552439244, + "expected_calibration_error_10bin": 0.006541276552439244, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + "F33": { + "valid": 2800, + "positives": 7, + "negatives": 2793, + "auroc": 0.7940258810291033, + "auprc": 0.01089298198199697, + "brier": 0.0025057501577909124, + "calibration": { + "observed_rate": 0.0025, + "mean_prediction": 0.0017289169844785387, + "calibration_in_the_large": -0.0007710830155214614, + "expected_calibration_error_10bin": 0.0007710830155214614, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "F39": { + "valid": 2801, + "positives": 6, + "negatives": 2795, + "auroc": 0.8403697078115683, + "auprc": 0.019562510430772045, + "brier": 0.0021323504373585564, + "calibration": { + "observed_rate": 0.0021420921099607284, + "mean_prediction": 0.000808368301869375, + "calibration_in_the_large": -0.0013337238080913534, + "expected_calibration_error_10bin": 0.0013337238080913534, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F41": { + "valid": 2247, + "positives": 34, + "negatives": 2213, + "auroc": 0.7514685946678716, + "auprc": 0.09728731914635558, + "brier": 0.014447652517404404, + "calibration": { + "observed_rate": 0.015131286159323543, + "mean_prediction": 0.016586377436652013, + "calibration_in_the_large": 0.0014550912773284696, + "expected_calibration_error_10bin": 0.002133615831342997, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + "F43": { + "valid": 2734, + "positives": 9, + "negatives": 2725, + "auroc": 0.7976350662589194, + "auprc": 0.07157894308020538, + "brier": 0.003214880937467188, + "calibration": { + "observed_rate": 0.0032918800292611556, + "mean_prediction": 0.004019450856590173, + "calibration_in_the_large": 0.0007275708273290172, + "expected_calibration_error_10bin": 0.0007275708273290172, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "F60": { + "valid": 2818, + "positives": 4, + "negatives": 2814, + "auroc": 0.9582444918265813, + "auprc": 0.030328702883843508, + "brier": 0.0014075567778315513, + "calibration": { + "observed_rate": 0.0014194464158978, + "mean_prediction": 0.0006841929447971513, + "calibration_in_the_large": -0.0007352534711006486, + "expected_calibration_error_10bin": 0.0007352534711006486, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "F90": { + "valid": 2775, + "positives": 5, + "negatives": 2770, + "auroc": 0.8688086642599278, + "auprc": 0.025258052730721108, + "brier": 0.0017957348802108857, + "calibration": { + "observed_rate": 0.0018018018018018018, + "mean_prediction": 0.0003825929787057543, + "calibration_in_the_large": -0.0014192088230960474, + "expected_calibration_error_10bin": 0.0014192088230960474, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "G25": { + "valid": 2774, + "positives": 3, + "negatives": 2771, + "auroc": 0.73042223024179, + "auprc": 0.004500581101898671, + "brier": 0.0010812666562834195, + "calibration": { + "observed_rate": 0.0010814708002883922, + "mean_prediction": 0.0013868475362484591, + "calibration_in_the_large": 0.000305376735960067, + "expected_calibration_error_10bin": 0.000305376735960067, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "G31": { + "valid": 2802, + "positives": 1, + "negatives": 2801, + "auroc": 0.6404855408782578, + "auprc": 0.000992063492063492, + "brier": 0.00038233948463298266, + "calibration": { + "observed_rate": 0.00035688793718772306, + "mean_prediction": 0.0019307026534934955, + "calibration_in_the_large": 0.0015738147163057725, + "expected_calibration_error_10bin": 0.0015738147163057725, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "G40": { + "valid": 2723, + "positives": 8, + "negatives": 2715, + "auroc": 0.6589318600368325, + "auprc": 0.019752324779219642, + "brier": 0.0029282725332343868, + "calibration": { + "observed_rate": 0.0029379360998898272, + "mean_prediction": 0.003086811894693884, + "calibration_in_the_large": 0.0001488757948040569, + "expected_calibration_error_10bin": 0.000148875794804057, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "G43": { + "valid": 2725, + "positives": 7, + "negatives": 2718, + "auroc": 0.7881320298538842, + "auprc": 0.010977534502314092, + "brier": 0.002557731577837054, + "calibration": { + "observed_rate": 0.002568807339449541, + "mean_prediction": 0.0015279355733238862, + "calibration_in_the_large": -0.001040871766125655, + "expected_calibration_error_10bin": 0.001040871766125655, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + "G44": { + "valid": 2805, + "positives": 3, + "negatives": 2802, + "auroc": 0.7831310968355937, + "auprc": 0.0067086841879770605, + "brier": 0.0010695459692888368, + "calibration": { + "observed_rate": 0.0010695187165775401, + "mean_prediction": 0.0008457085308843996, + "calibration_in_the_large": -0.0002238101856931405, + "expected_calibration_error_10bin": 0.0002238101856931405, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "G47": { + "valid": 2315, + "positives": 36, + "negatives": 2279, + "auroc": 0.6887279996099653, + "auprc": 0.04553322773211858, + "brier": 0.015146479204913937, + "calibration": { + "observed_rate": 0.015550755939524838, + "mean_prediction": 0.013624608770820472, + "calibration_in_the_large": -0.001926147168704366, + "expected_calibration_error_10bin": 0.0022097956124928486, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + "G51": { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 1.3917799617747335e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00024578010085277586, + "calibration_in_the_large": 0.00024578010085277586, + "expected_calibration_error_10bin": 0.00024578010085277586, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + "G62": { + "valid": 2751, + "positives": 13, + "negatives": 2738, + "auroc": 0.8807383266842727, + "auprc": 0.09142689098391338, + "brier": 0.004540088818875144, + "calibration": { + "observed_rate": 0.004725554343874954, + "mean_prediction": 0.0030008423804530285, + "calibration_in_the_large": -0.0017247119634219259, + "expected_calibration_error_10bin": 0.001724711963421926, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "G81": { + "valid": 2789, + "positives": 9, + "negatives": 2780, + "auroc": 0.7690647482014389, + "auprc": 0.025980812689512585, + "brier": 0.0032102059118072363, + "calibration": { + "observed_rate": 0.0032269630692004303, + "mean_prediction": 0.0011189220683895213, + "calibration_in_the_large": -0.0021080410008109092, + "expected_calibration_error_10bin": 0.0021080410008109092, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "G83": { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.6371367824238129, + "auprc": 0.0014208910121793453, + "brier": 0.0007098905725789219, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0006118989192999919, + "calibration_in_the_large": -9.63163781504331e-05, + "expected_calibration_error_10bin": 9.63163781504331e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "G89": { + "valid": 2537, + "positives": 21, + "negatives": 2516, + "auroc": 0.7550722991899462, + "auprc": 0.036079760744903204, + "brier": 0.008210836929718506, + "calibration": { + "observed_rate": 0.008277493102089082, + "mean_prediction": 0.012647368609139389, + "calibration_in_the_large": 0.004369875507050307, + "expected_calibration_error_10bin": 0.004369875507050308, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + "G90": { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 2.828913399461543e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0008624720113275151, + "calibration_in_the_large": 0.0008624720113275151, + "expected_calibration_error_10bin": 0.0008624720113275151, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "G92": { + "valid": 2733, + "positives": 12, + "negatives": 2721, + "auroc": 0.7601678304544898, + "auprc": 0.024283382973763673, + "brier": 0.004403280127795962, + "calibration": { + "observed_rate": 0.0043907793633369925, + "mean_prediction": 0.007753619698712842, + "calibration_in_the_large": 0.0033628403353758492, + "expected_calibration_error_10bin": 0.0033628403353758492, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "G93": { + "valid": 2656, + "positives": 17, + "negatives": 2639, + "auroc": 0.7938836011858325, + "auprc": 0.022054761347434497, + "brier": 0.006328147354311844, + "calibration": { + "observed_rate": 0.006400602409638554, + "mean_prediction": 0.006515280162972546, + "calibration_in_the_large": 0.00011467775333399207, + "expected_calibration_error_10bin": 0.00011467775333399207, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + "G99": { + "valid": 2841, + "positives": 0, + "negatives": 2841, + "auroc": null, + "auprc": null, + "brier": 1.708446517372246e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00015271966601764647, + "calibration_in_the_large": 0.00015271966601764647, + "expected_calibration_error_10bin": 0.00015271966601764647, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9992965177629265 + }, + "H10": { + "valid": 2832, + "positives": 1, + "negatives": 2831, + "auroc": 0.990815966089721, + "auprc": 0.037037037037037035, + "brier": 0.00035151647130424245, + "calibration": { + "observed_rate": 0.00035310734463276836, + "mean_prediction": 0.00029284351064933037, + "calibration_in_the_large": -6.026383398343799e-05, + "expected_calibration_error_10bin": 6.026383398343799e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "H26": { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 1.2118746702977596e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0006145537647907537, + "calibration_in_the_large": 0.0006145537647907537, + "expected_calibration_error_10bin": 0.0006145537647907537, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "H35": { + "valid": 2806, + "positives": 3, + "negatives": 2803, + "auroc": 0.7990248543227494, + "auprc": 0.004329142990257661, + "brier": 0.0010685026007141536, + "calibration": { + "observed_rate": 0.0010691375623663579, + "mean_prediction": 0.0003191064777287503, + "calibration_in_the_large": -0.0007500310846376075, + "expected_calibration_error_10bin": 0.0007500310846376075, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "H40": { + "valid": 2750, + "positives": 4, + "negatives": 2746, + "auroc": 0.7738528769118718, + "auprc": 0.016330581696959962, + "brier": 0.001452588239762425, + "calibration": { + "observed_rate": 0.0014545454545454545, + "mean_prediction": 0.0019150828036052355, + "calibration_in_the_large": 0.0004605373490597811, + "expected_calibration_error_10bin": 0.0004605373490597811, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "H53": { + "valid": 2790, + "positives": 3, + "negatives": 2787, + "auroc": 0.6856835306781486, + "auprc": 0.007929716296955264, + "brier": 0.0010738007848296429, + "calibration": { + "observed_rate": 0.001075268817204301, + "mean_prediction": 0.00200619443339975, + "calibration_in_the_large": 0.0009309256161954488, + "expected_calibration_error_10bin": 0.0009309256161954488, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "H54": { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.4271464196651229, + "auprc": 0.0009117591982293598, + "brier": 0.0007157239255891897, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0011308062391097969, + "calibration_in_the_large": 0.0004188090870984049, + "expected_calibration_error_10bin": 0.0004188090870984049, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "H91": { + "valid": 2791, + "positives": 2, + "negatives": 2789, + "auroc": 0.7592326998924346, + "auprc": 0.010033253067308795, + "brier": 0.0007152055986076118, + "calibration": { + "observed_rate": 0.0007165890361877463, + "mean_prediction": 0.0011021939787436168, + "calibration_in_the_large": 0.0003856049425558705, + "expected_calibration_error_10bin": 0.0003856049425558705, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + "I07": { + "valid": 2823, + "positives": 2, + "negatives": 2821, + "auroc": 0.858738036157391, + "auprc": 0.003891693713186681, + "brier": 0.0007101555005144452, + "calibration": { + "observed_rate": 0.0007084661707403471, + "mean_prediction": 0.0004211151089943853, + "calibration_in_the_large": -0.00028735106174596184, + "expected_calibration_error_10bin": 0.00028735106174596184, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "I08": { + "valid": 2767, + "positives": 4, + "negatives": 2763, + "auroc": 0.8906080347448425, + "auprc": 0.008467823966521355, + "brier": 0.001501019911987942, + "calibration": { + "observed_rate": 0.0014456089627755693, + "mean_prediction": 0.0028612748829397387, + "calibration_in_the_large": 0.0014156659201641694, + "expected_calibration_error_10bin": 0.0014156659201641697, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + "I10": { + "valid": 1498, + "positives": 22, + "negatives": 1476, + "auroc": 0.6431079083518108, + "auprc": 0.03559381453860556, + "brier": 0.014434632128636436, + "calibration": { + "observed_rate": 0.014686248331108143, + "mean_prediction": 0.009048042952649429, + "calibration_in_the_large": -0.005638205378458714, + "expected_calibration_error_10bin": 0.006234045159640549, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + "I11": { + "valid": 2676, + "positives": 17, + "negatives": 2659, + "auroc": 0.8297458133309736, + "auprc": 0.025596620307771333, + "brier": 0.00630238073036184, + "calibration": { + "observed_rate": 0.006352765321375187, + "mean_prediction": 0.005015048052506538, + "calibration_in_the_large": -0.0013377172688686483, + "expected_calibration_error_10bin": 0.001627923753420926, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + "I12": { + "valid": 2552, + "positives": 10, + "negatives": 2542, + "auroc": 0.8302911093627066, + "auprc": 0.03385608858021495, + "brier": 0.003886745251749079, + "calibration": { + "observed_rate": 0.003918495297805642, + "mean_prediction": 0.0028913911533053004, + "calibration_in_the_large": -0.0010271041445003419, + "expected_calibration_error_10bin": 0.0012774333758940903, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + "I13": { + "valid": 2727, + "positives": 7, + "negatives": 2720, + "auroc": 0.8848214285714285, + "auprc": 0.04876815185303688, + "brier": 0.002560738217404051, + "calibration": { + "observed_rate": 0.002566923359002567, + "mean_prediction": 0.004272747338710311, + "calibration_in_the_large": 0.0017058239797077442, + "expected_calibration_error_10bin": 0.001705823979707744, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + "I16": { + "valid": 2390, + "positives": 2, + "negatives": 2388, + "auroc": 0.8990787269681743, + "auprc": 0.009105691056910569, + "brier": 0.0008349846961243634, + "calibration": { + "observed_rate": 0.0008368200836820083, + "mean_prediction": 0.0008361778862095607, + "calibration_in_the_large": -6.42197472447599e-07, + "expected_calibration_error_10bin": 6.42197472447599e-07, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + "I21": { + "valid": 2671, + "positives": 5, + "negatives": 2666, + "auroc": 0.9304576144036009, + "auprc": 0.04532753089546006, + "brier": 0.0018740980462777627, + "calibration": { + "observed_rate": 0.0018719580681392737, + "mean_prediction": 0.004885202565031725, + "calibration_in_the_large": 0.0030132444968924517, + "expected_calibration_error_10bin": 0.0030132444968924512, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "I24": { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.9218026362664766, + "auprc": 0.010026737967914439, + "brier": 0.0007101072548618018, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0007647342867936532, + "calibration_in_the_large": 5.2737134782261164e-05, + "expected_calibration_error_10bin": 5.2737134782261164e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "I25": { + "valid": 2243, + "positives": 19, + "negatives": 2224, + "auroc": 0.8326154865581219, + "auprc": 0.04553449224465551, + "brier": 0.008280641666621144, + "calibration": { + "observed_rate": 0.008470798038341507, + "mean_prediction": 0.007513321586255251, + "calibration_in_the_large": -0.0009574764520862561, + "expected_calibration_error_10bin": 0.0009574764520862561, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + "I26": { + "valid": 2760, + "positives": 6, + "negatives": 2754, + "auroc": 0.6539578794480755, + "auprc": 0.0280067197170315, + "brier": 0.002160134899369591, + "calibration": { + "observed_rate": 0.002173913043478261, + "mean_prediction": 0.0031351070762036175, + "calibration_in_the_large": 0.0009611940327253566, + "expected_calibration_error_10bin": 0.0009611940327253566, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + "I27": { + "valid": 2716, + "positives": 13, + "negatives": 2703, + "auroc": 0.8501664816870145, + "auprc": 0.022147069512979956, + "brier": 0.004759702205142101, + "calibration": { + "observed_rate": 0.004786450662739323, + "mean_prediction": 0.004039260899212965, + "calibration_in_the_large": -0.0007471897635263581, + "expected_calibration_error_10bin": 0.0009016455662795088, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I31": { + "valid": 2793, + "positives": 7, + "negatives": 2786, + "auroc": 0.8966772638703723, + "auprc": 0.03980328270432922, + "brier": 0.002475717128169302, + "calibration": { + "observed_rate": 0.002506265664160401, + "mean_prediction": 0.001956308807227245, + "calibration_in_the_large": -0.0005499568569331558, + "expected_calibration_error_10bin": 0.0005499568569331558, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I34": { + "valid": 2753, + "positives": 10, + "negatives": 2743, + "auroc": 0.7385344513306599, + "auprc": 0.009328419108966484, + "brier": 0.0036336272293574024, + "calibration": { + "observed_rate": 0.003632401017072285, + "mean_prediction": 0.001709283124914108, + "calibration_in_the_large": -0.001923117892158177, + "expected_calibration_error_10bin": 0.001923117892158177, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + "I35": { + "valid": 2723, + "positives": 4, + "negatives": 2719, + "auroc": 0.65529606472968, + "auprc": 0.0032816811905479926, + "brier": 0.0014945861901700754, + "calibration": { + "observed_rate": 0.0014689680499449136, + "mean_prediction": 0.0021119985906056238, + "calibration_in_the_large": 0.0006430305406607102, + "expected_calibration_error_10bin": 0.0006430305406607102, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "I42": { + "valid": 2740, + "positives": 4, + "negatives": 2736, + "auroc": 0.9088084795321637, + "auprc": 0.06988473303045296, + "brier": 0.0014384527939526606, + "calibration": { + "observed_rate": 0.00145985401459854, + "mean_prediction": 0.0018443789624774064, + "calibration_in_the_large": 0.00038452494787886635, + "expected_calibration_error_10bin": 0.00038452494787886635, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "I44": { + "valid": 2722, + "positives": 8, + "negatives": 2714, + "auroc": 0.8570836403831983, + "auprc": 0.054281259293413736, + "brier": 0.0028828023507603737, + "calibration": { + "observed_rate": 0.0029390154298310064, + "mean_prediction": 0.003984975844332272, + "calibration_in_the_large": 0.0010459604145012652, + "expected_calibration_error_10bin": 0.0010459604145012654, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + "I45": { + "valid": 2766, + "positives": 5, + "negatives": 2761, + "auroc": 0.7512495472654835, + "auprc": 0.22334751015811083, + "brier": 0.0017935103522235072, + "calibration": { + "observed_rate": 0.0018076644974692696, + "mean_prediction": 0.003119712606121374, + "calibration_in_the_large": 0.0013120481086521046, + "expected_calibration_error_10bin": 0.0013120481086521046, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + "I46": { + "valid": 2831, + "positives": 0, + "negatives": 2831, + "auroc": null, + "auprc": null, + "brier": 4.593599574781127e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0010944896083000448, + "calibration_in_the_large": 0.0010944896083000448, + "expected_calibration_error_10bin": 0.0010944896083000448, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I47": { + "valid": 2716, + "positives": 5, + "negatives": 2711, + "auroc": 0.6536333456289192, + "auprc": 0.004311462349972715, + "brier": 0.001852704297208304, + "calibration": { + "observed_rate": 0.001840942562592047, + "mean_prediction": 0.0034940356694578346, + "calibration_in_the_large": 0.0016530931068657875, + "expected_calibration_error_10bin": 0.0016530931068657875, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I48": { + "valid": 2385, + "positives": 12, + "negatives": 2373, + "auroc": 0.8002879617923866, + "auprc": 0.01823246674196644, + "brier": 0.0049968370175210485, + "calibration": { + "observed_rate": 0.005031446540880503, + "mean_prediction": 0.004351234489410483, + "calibration_in_the_large": -0.0006802120514700196, + "expected_calibration_error_10bin": 0.0007941174273285422, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + "I49": { + "valid": 2734, + "positives": 5, + "negatives": 2729, + "auroc": 0.7865884939538292, + "auprc": 0.009660403678429002, + "brier": 0.001821392011204752, + "calibration": { + "observed_rate": 0.0018288222384784199, + "mean_prediction": 0.0016616519860557395, + "calibration_in_the_large": -0.00016717025242268032, + "expected_calibration_error_10bin": 0.00016717025242268032, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I50": { + "valid": 2415, + "positives": 17, + "negatives": 2398, + "auroc": 0.8623607908551244, + "auprc": 0.038781407881893756, + "brier": 0.007023614009370407, + "calibration": { + "observed_rate": 0.007039337474120083, + "mean_prediction": 0.007766375255460028, + "calibration_in_the_large": 0.0007270377813399448, + "expected_calibration_error_10bin": 0.0009904718719173414, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + "I51": { + "valid": 2807, + "positives": 3, + "negatives": 2804, + "auroc": 0.8509272467902995, + "auprc": 0.008090314608382663, + "brier": 0.0010657155284766692, + "calibration": { + "observed_rate": 0.0010687566797292483, + "mean_prediction": 0.0010408690772866832, + "calibration_in_the_large": -2.7887602442565112e-05, + "expected_calibration_error_10bin": 2.7887602442565112e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "I61": { + "valid": 2802, + "positives": 2, + "negatives": 2800, + "auroc": 0.7575, + "auprc": 0.004573730743797605, + "brier": 0.0007131316456381397, + "calibration": { + "observed_rate": 0.0007137758743754461, + "mean_prediction": 0.00037659534923026447, + "calibration_in_the_large": -0.00033718052514518165, + "expected_calibration_error_10bin": 0.00033718052514518165, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "I63": { + "valid": 2735, + "positives": 6, + "negatives": 2729, + "auroc": 0.8031635519726396, + "auprc": 0.007058373459693505, + "brier": 0.002198597403518905, + "calibration": { + "observed_rate": 0.0021937842778793418, + "mean_prediction": 0.0020588753497424303, + "calibration_in_the_large": -0.0001349089281369115, + "expected_calibration_error_10bin": 0.0001349089281369115, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + "I65": { + "valid": 2774, + "positives": 2, + "negatives": 2772, + "auroc": 0.6329365079365079, + "auprc": 0.001430266168193714, + "brier": 0.0007224622207142649, + "calibration": { + "observed_rate": 0.0007209805335255948, + "mean_prediction": 0.0009486909151052898, + "calibration_in_the_large": 0.00022771038157969503, + "expected_calibration_error_10bin": 0.00022771038157969503, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "I67": { + "valid": 2773, + "positives": 2, + "negatives": 2771, + "auroc": 0.8720678455431252, + "auprc": 0.004436031838477966, + "brier": 0.0007239461932990495, + "calibration": { + "observed_rate": 0.000721240533717995, + "mean_prediction": 0.001090352988034397, + "calibration_in_the_large": 0.0003691124543164021, + "expected_calibration_error_10bin": 0.0003691124543164021, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "I69": { + "valid": 2752, + "positives": 9, + "negatives": 2743, + "auroc": 0.7885931866974522, + "auprc": 0.01777807856058182, + "brier": 0.003256060165885707, + "calibration": { + "observed_rate": 0.0032703488372093025, + "mean_prediction": 0.0037566928376862917, + "calibration_in_the_large": 0.0004863440004769892, + "expected_calibration_error_10bin": 0.0004863440004769892, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + "I70": { + "valid": 2771, + "positives": 2, + "negatives": 2769, + "auroc": 0.8979776092452149, + "auprc": 0.02267156862745098, + "brier": 0.000718214287244949, + "calibration": { + "observed_rate": 0.0007217610970768675, + "mean_prediction": 0.0011397330046491144, + "calibration_in_the_large": 0.0004179719075722469, + "expected_calibration_error_10bin": 0.0004179719075722469, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + "I71": { + "valid": 2769, + "positives": 3, + "negatives": 2766, + "auroc": 0.6726922149915643, + "auprc": 0.00416526981209159, + "brier": 0.0010834740760150802, + "calibration": { + "observed_rate": 0.0010834236186348862, + "mean_prediction": 0.001070565852714988, + "calibration_in_the_large": -1.2857765919898267e-05, + "expected_calibration_error_10bin": 1.2857765919898267e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + "I72": { + "valid": 2818, + "positives": 2, + "negatives": 2816, + "auroc": 0.5662286931818182, + "auprc": 0.003088568662339154, + "brier": 0.0007103248536633564, + "calibration": { + "observed_rate": 0.0007097232079489, + "mean_prediction": 0.0006466560525046941, + "calibration_in_the_large": -6.306715544420589e-05, + "expected_calibration_error_10bin": 6.306715544420589e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "I73": { + "valid": 2734, + "positives": 1, + "negatives": 2733, + "auroc": 0.8902305159165752, + "auprc": 0.0033222591362126247, + "brier": 0.00037406614577033633, + "calibration": { + "observed_rate": 0.000365764447695684, + "mean_prediction": 0.0010669539041158456, + "calibration_in_the_large": 0.0007011894564201616, + "expected_calibration_error_10bin": 0.0007011894564201616, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I74": { + "valid": 2821, + "positives": 3, + "negatives": 2818, + "auroc": 0.6854743316773125, + "auprc": 0.0029754819169500444, + "brier": 0.0010627915037559337, + "calibration": { + "observed_rate": 0.0010634526763559022, + "mean_prediction": 0.0003990629839838965, + "calibration_in_the_large": -0.0006643896923720057, + "expected_calibration_error_10bin": 0.0006643896923720057, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "I77": { + "valid": 2785, + "positives": 3, + "negatives": 2782, + "auroc": 0.633477114785526, + "auprc": 0.0028935420796598146, + "brier": 0.0010770016988850208, + "calibration": { + "observed_rate": 0.0010771992818671453, + "mean_prediction": 0.0008429097630585902, + "calibration_in_the_large": -0.00023428951880855508, + "expected_calibration_error_10bin": 0.00023428951880855508, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "I80": { + "valid": 2827, + "positives": 2, + "negatives": 2825, + "auroc": 0.8191150442477876, + "auprc": 0.0032535151170351106, + "brier": 0.000709024372515875, + "calibration": { + "observed_rate": 0.0007074637424831977, + "mean_prediction": 0.00047655875771092577, + "calibration_in_the_large": -0.00023090498477227196, + "expected_calibration_error_10bin": 0.00023090498477227196, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "I81": { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8417582417582418, + "auprc": 0.01584256031760872, + "brier": 0.0017758050788682655, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0009256142958665915, + "calibration_in_the_large": -0.000843670912909063, + "expected_calibration_error_10bin": 0.0009437287196786481, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I82": { + "valid": 2739, + "positives": 13, + "negatives": 2726, + "auroc": 0.6318076640893956, + "auprc": 0.012867092498719777, + "brier": 0.004741919814594892, + "calibration": { + "observed_rate": 0.004746257758305951, + "mean_prediction": 0.004563584656975028, + "calibration_in_the_large": -0.0001826731013309232, + "expected_calibration_error_10bin": 0.0001826731013309232, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "I85": { + "valid": 2793, + "positives": 2, + "negatives": 2791, + "auroc": 0.9874596918667145, + "auprc": 0.06587301587301587, + "brier": 0.0007895968771241309, + "calibration": { + "observed_rate": 0.0007160759040458289, + "mean_prediction": 0.0009345053570344405, + "calibration_in_the_large": 0.0002184294529886116, + "expected_calibration_error_10bin": 0.0009684159609917595, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I87": { + "valid": 2780, + "positives": 7, + "negatives": 2773, + "auroc": 0.7586935242903509, + "auprc": 0.006735993524110663, + "brier": 0.0025122753552136406, + "calibration": { + "observed_rate": 0.002517985611510791, + "mean_prediction": 0.0017990648179319114, + "calibration_in_the_large": -0.0007189207935788798, + "expected_calibration_error_10bin": 0.0007189207935788798, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "I89": { + "valid": 2826, + "positives": 3, + "negatives": 2823, + "auroc": 0.8193411264612115, + "auprc": 0.008023390546320862, + "brier": 0.0010600521915389285, + "calibration": { + "observed_rate": 0.0010615711252653928, + "mean_prediction": 0.00028101651920836725, + "calibration_in_the_large": -0.0007805546060570255, + "expected_calibration_error_10bin": 0.0007805546060570255, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I95": { + "valid": 2485, + "positives": 33, + "negatives": 2452, + "auroc": 0.7332913144495526, + "auprc": 0.030144563266190517, + "brier": 0.01304269930300032, + "calibration": { + "observed_rate": 0.013279678068410463, + "mean_prediction": 0.015006125316265558, + "calibration_in_the_large": 0.0017264472478550948, + "expected_calibration_error_10bin": 0.0017264472478550968, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + "I96": { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.9975265017667845, + "auprc": 0.125, + "brier": 0.0003482859469648408, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0006795005582730012, + "calibration_in_the_large": 0.0003262684848007299, + "expected_calibration_error_10bin": 0.0003262684848007299, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I97": { + "valid": 2740, + "positives": 4, + "negatives": 2736, + "auroc": 0.8940972222222222, + "auprc": 0.017157291262334805, + "brier": 0.001450698556558343, + "calibration": { + "observed_rate": 0.00145985401459854, + "mean_prediction": 0.0014561668292814305, + "calibration_in_the_large": -3.687185317109579e-06, + "expected_calibration_error_10bin": 3.687185317109579e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "J02": { + "valid": 2825, + "positives": 1, + "negatives": 2824, + "auroc": 0.5230169971671388, + "auprc": 0.000741839762611276, + "brier": 0.00035604942665863875, + "calibration": { + "observed_rate": 0.00035398230088495576, + "mean_prediction": 0.0007695842929755181, + "calibration_in_the_large": 0.00041560199209056235, + "expected_calibration_error_10bin": 0.00041560199209056235, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J06": { + "valid": 2816, + "positives": 2, + "negatives": 2814, + "auroc": 0.6018123667377399, + "auprc": 0.001815467007537356, + "brier": 0.0007259057695983748, + "calibration": { + "observed_rate": 0.0007102272727272727, + "mean_prediction": 0.0012495049965508542, + "calibration_in_the_large": 0.0005392777238235815, + "expected_calibration_error_10bin": 0.0005392777238235815, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "J12": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 6.104695056599535e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0007464090063695617, + "calibration_in_the_large": 0.0007464090063695617, + "expected_calibration_error_10bin": 0.0007464090063695617, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J15": { + "valid": 2795, + "positives": 3, + "negatives": 2792, + "auroc": 0.8689111747851003, + "auprc": 0.005213208768659675, + "brier": 0.001098341807432863, + "calibration": { + "observed_rate": 0.001073345259391771, + "mean_prediction": 0.002477863284109906, + "calibration_in_the_large": 0.001404518024718135, + "expected_calibration_error_10bin": 0.001404518024718135, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + "J18": { + "valid": 2671, + "positives": 14, + "negatives": 2657, + "auroc": 0.7801494704016345, + "auprc": 0.018485435538503136, + "brier": 0.005338846219070355, + "calibration": { + "observed_rate": 0.005241482590789966, + "mean_prediction": 0.008829338510156125, + "calibration_in_the_large": 0.0035878559193661588, + "expected_calibration_error_10bin": 0.0035878559193661596, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "J30": { + "valid": 2815, + "positives": 1, + "negatives": 2814, + "auroc": 0.9989339019189766, + "auprc": 0.25, + "brier": 0.0003405134492985159, + "calibration": { + "observed_rate": 0.00035523978685612787, + "mean_prediction": 0.001226856934556367, + "calibration_in_the_large": 0.0008716171477002393, + "expected_calibration_error_10bin": 0.0008716171477002393, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "J32": { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.9066478076379066, + "auprc": 0.0037735849056603774, + "brier": 0.0003544563973835663, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.0003754012691418739, + "calibration_in_the_large": 2.1919473454351805e-05, + "expected_calibration_error_10bin": 2.1919473454351805e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J38": { + "valid": 2825, + "positives": 1, + "negatives": 2824, + "auroc": 0.4978753541076487, + "auprc": 0.0007047216349541931, + "brier": 0.0003561560889606177, + "calibration": { + "observed_rate": 0.00035398230088495576, + "mean_prediction": 0.0007448127447726386, + "calibration_in_the_large": 0.00039083044388768285, + "expected_calibration_error_10bin": 0.00039083044388768285, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J43": { + "valid": 2804, + "positives": 2, + "negatives": 2802, + "auroc": 0.24428979300499643, + "auprc": 0.0006898575257441107, + "brier": 0.0007160330871537143, + "calibration": { + "observed_rate": 0.0007132667617689016, + "mean_prediction": 0.0007137153687340994, + "calibration_in_the_large": 4.4860696519783555e-07, + "expected_calibration_error_10bin": 4.4860696519783555e-07, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "J44": { + "valid": 2570, + "positives": 10, + "negatives": 2560, + "auroc": 0.8425390625, + "auprc": 0.017134400877871336, + "brier": 0.003860152938522804, + "calibration": { + "observed_rate": 0.0038910505836575876, + "mean_prediction": 0.0030790088714695465, + "calibration_in_the_large": -0.0008120417121880411, + "expected_calibration_error_10bin": 0.0008120417121880411, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + "J45": { + "valid": 2518, + "positives": 13, + "negatives": 2505, + "auroc": 0.6336557653922923, + "auprc": 0.009118336644850842, + "brier": 0.005145487332010995, + "calibration": { + "observed_rate": 0.005162827640984908, + "mean_prediction": 0.003576152313900468, + "calibration_in_the_large": -0.0015866753270844403, + "expected_calibration_error_10bin": 0.0015866753270844403, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + "J47": { + "valid": 2825, + "positives": 1, + "negatives": 2824, + "auroc": 0.9213881019830028, + "auprc": 0.004484304932735426, + "brier": 0.000353944180088887, + "calibration": { + "observed_rate": 0.00035398230088495576, + "mean_prediction": 0.0003224839628405105, + "calibration_in_the_large": -3.1498338044445276e-05, + "expected_calibration_error_10bin": 3.1498338044445276e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J69": { + "valid": 2777, + "positives": 14, + "negatives": 2763, + "auroc": 0.800992709787498, + "auprc": 0.038205248660027454, + "brier": 0.004960390573555418, + "calibration": { + "observed_rate": 0.005041411595246669, + "mean_prediction": 0.004440742220697331, + "calibration_in_the_large": -0.0006006693745493376, + "expected_calibration_error_10bin": 0.0006754833828936181, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "J81": { + "valid": 2781, + "positives": 7, + "negatives": 2774, + "auroc": 0.7561540838397364, + "auprc": 0.009919422208455148, + "brier": 0.0025101391044161443, + "calibration": { + "observed_rate": 0.0025170801869830997, + "mean_prediction": 0.0013703308074710836, + "calibration_in_the_large": -0.001146749379512016, + "expected_calibration_error_10bin": 0.001146749379512016, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "J84": { + "valid": 2817, + "positives": 5, + "negatives": 2812, + "auroc": 0.9576102418207681, + "auprc": 0.03338922593157122, + "brier": 0.0017669149208748393, + "calibration": { + "observed_rate": 0.001774937877174299, + "mean_prediction": 0.0004909966506530684, + "calibration_in_the_large": -0.0012839412265212306, + "expected_calibration_error_10bin": 0.0012839412265212306, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "J90": { + "valid": 2754, + "positives": 13, + "negatives": 2741, + "auroc": 0.6426907641792721, + "auprc": 0.007744606986050294, + "brier": 0.004748114881631549, + "calibration": { + "observed_rate": 0.004720406681190995, + "mean_prediction": 0.005155681078648884, + "calibration_in_the_large": 0.0004352743974578889, + "expected_calibration_error_10bin": 0.0004352743974578889, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + "J91": { + "valid": 2807, + "positives": 3, + "negatives": 2804, + "auroc": 0.9309320019020447, + "auprc": 0.01381799668213377, + "brier": 0.001086406083715097, + "calibration": { + "observed_rate": 0.0010687566797292483, + "mean_prediction": 0.0016462583230435854, + "calibration_in_the_large": 0.0005775016433143371, + "expected_calibration_error_10bin": 0.0005775016433143371, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "J94": { + "valid": 2829, + "positives": 4, + "negatives": 2825, + "auroc": 0.7456637168141593, + "auprc": 0.006673355675304402, + "brier": 0.0014145931851027502, + "calibration": { + "observed_rate": 0.0014139271827500884, + "mean_prediction": 0.0005782838252408233, + "calibration_in_the_large": -0.0008356433575092651, + "expected_calibration_error_10bin": 0.0008356433575092651, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J95": { + "valid": 2770, + "positives": 8, + "negatives": 2762, + "auroc": 0.7938540912382331, + "auprc": 0.01851749822788574, + "brier": 0.00286947871558962, + "calibration": { + "observed_rate": 0.002888086642599278, + "mean_prediction": 0.0017464350276931973, + "calibration_in_the_large": -0.0011416516149060805, + "expected_calibration_error_10bin": 0.0011416516149060805, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + "J96": { + "valid": 2605, + "positives": 20, + "negatives": 2585, + "auroc": 0.8746615087040619, + "auprc": 0.036712310383738886, + "brier": 0.007647053238570983, + "calibration": { + "observed_rate": 0.007677543186180422, + "mean_prediction": 0.010456726225946011, + "calibration_in_the_large": 0.0027791830397655894, + "expected_calibration_error_10bin": 0.0027791830397655886, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + "J98": { + "valid": 2692, + "positives": 9, + "negatives": 2683, + "auroc": 0.7409201971259369, + "auprc": 0.01599445854177181, + "brier": 0.0033207658453438815, + "calibration": { + "observed_rate": 0.0033432392273402673, + "mean_prediction": 0.0043587552887567, + "calibration_in_the_large": 0.0010155160614164324, + "expected_calibration_error_10bin": 0.0010155160614164324, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + "K04": { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 1.7756071751008106e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00019682331626520188, + "calibration_in_the_large": 0.00019682331626520188, + "expected_calibration_error_10bin": 0.00019682331626520188, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "K12": { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9953933380581148, + "auprc": 0.10101010101010101, + "brier": 0.0006990796813981522, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0014221554757683464, + "calibration_in_the_large": 0.0007139401783179214, + "expected_calibration_error_10bin": 0.0007139401783179213, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K20": { + "valid": 2813, + "positives": 3, + "negatives": 2810, + "auroc": 0.7492289442467378, + "auprc": 0.0492972764821211, + "brier": 0.0010738410314242814, + "calibration": { + "observed_rate": 0.001066477070742979, + "mean_prediction": 0.0027562582179076556, + "calibration_in_the_large": 0.0016897811471646765, + "expected_calibration_error_10bin": 0.0016897811471646765, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K21": { + "valid": 2043, + "positives": 33, + "negatives": 2010, + "auroc": 0.8081863410221619, + "auprc": 0.09860084212793754, + "brier": 0.015412136591631515, + "calibration": { + "observed_rate": 0.016152716593245228, + "mean_prediction": 0.017306982326023627, + "calibration_in_the_large": 0.0011542657327783985, + "expected_calibration_error_10bin": 0.0016077719904606387, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + "K22": { + "valid": 2764, + "positives": 4, + "negatives": 2760, + "auroc": 0.7861413043478261, + "auprc": 0.038569890431295606, + "brier": 0.0014309263072730084, + "calibration": { + "observed_rate": 0.001447178002894356, + "mean_prediction": 0.0020830279143400207, + "calibration_in_the_large": 0.0006358499114456648, + "expected_calibration_error_10bin": 0.0006358499114456648, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + "K25": { + "valid": 2817, + "positives": 2, + "negatives": 2815, + "auroc": 0.9360568383658969, + "auprc": 0.008149473265752336, + "brier": 0.0007124659223129658, + "calibration": { + "observed_rate": 0.0007099751508697196, + "mean_prediction": 0.001130671953462735, + "calibration_in_the_large": 0.0004206968025930154, + "expected_calibration_error_10bin": 0.0004206968025930154, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "K26": { + "valid": 2814, + "positives": 2, + "negatives": 2812, + "auroc": 0.8902916073968705, + "auprc": 0.00985663082437276, + "brier": 0.0007090343308361954, + "calibration": { + "observed_rate": 0.0007107320540156361, + "mean_prediction": 0.0007714844240973811, + "calibration_in_the_large": 6.075237008174505e-05, + "expected_calibration_error_10bin": 6.075237008174505e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "K29": { + "valid": 2785, + "positives": 3, + "negatives": 2782, + "auroc": 0.8572969086987778, + "auprc": 0.011015061819651733, + "brier": 0.001091625260385584, + "calibration": { + "observed_rate": 0.0010771992818671453, + "mean_prediction": 0.0037108451539326183, + "calibration_in_the_large": 0.002633645872065473, + "expected_calibration_error_10bin": 0.002633645872065473, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K30": { + "valid": 2837, + "positives": 0, + "negatives": 2837, + "auroc": null, + "auprc": null, + "brier": 2.907285881666394e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0006632802717037745, + "calibration_in_the_large": 0.0006632802717037745, + "expected_calibration_error_10bin": 0.0006632802717037745, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "K31": { + "valid": 2756, + "positives": 5, + "negatives": 2751, + "auroc": 0.9336241366775718, + "auprc": 0.06364568668906527, + "brier": 0.0017651686949308046, + "calibration": { + "observed_rate": 0.00181422351233672, + "mean_prediction": 0.002420759305980413, + "calibration_in_the_large": 0.0006065357936436931, + "expected_calibration_error_10bin": 0.0006065357936436928, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "K40": { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 7.182831846685405e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0005747561755418452, + "calibration_in_the_large": 0.0005747561755418452, + "expected_calibration_error_10bin": 0.0005747561755418452, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "K42": { + "valid": 2820, + "positives": 2, + "negatives": 2818, + "auroc": 0.6910929737402413, + "auprc": 0.007949599887687772, + "brier": 0.0007091981395539393, + "calibration": { + "observed_rate": 0.0007092198581560284, + "mean_prediction": 0.0004480956660196906, + "calibration_in_the_large": -0.0002611241921363378, + "expected_calibration_error_10bin": 0.0002611241921363378, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "K43": { + "valid": 2813, + "positives": 1, + "negatives": 2812, + "auroc": 0.9068278805120911, + "auprc": 0.0038022813688212928, + "brier": 0.0003554439765327709, + "calibration": { + "observed_rate": 0.00035549235691432633, + "mean_prediction": 0.00037840785305945764, + "calibration_in_the_large": 2.2915496145131306e-05, + "expected_calibration_error_10bin": 2.2915496145131306e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K44": { + "valid": 2785, + "positives": 2, + "negatives": 2783, + "auroc": 0.36543298598634566, + "auprc": 0.0008252252840538069, + "brier": 0.0007215485681440702, + "calibration": { + "observed_rate": 0.000718132854578097, + "mean_prediction": 0.0011515047818793196, + "calibration_in_the_large": 0.00043337192730122257, + "expected_calibration_error_10bin": 0.00043337192730122257, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K52": { + "valid": 2749, + "positives": 10, + "negatives": 2739, + "auroc": 0.8258853596202994, + "auprc": 0.12605558809349698, + "brier": 0.0036147135475836987, + "calibration": { + "observed_rate": 0.0036376864314296106, + "mean_prediction": 0.005128906768235192, + "calibration_in_the_large": 0.0014912203368055818, + "expected_calibration_error_10bin": 0.0014912203368055814, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + "K55": { + "valid": 2815, + "positives": 5, + "negatives": 2810, + "auroc": 0.8471174377224199, + "auprc": 0.01005675426406309, + "brier": 0.001772874950044458, + "calibration": { + "observed_rate": 0.0017761989342806395, + "mean_prediction": 0.0010444309221462522, + "calibration_in_the_large": -0.0007317680121343873, + "expected_calibration_error_10bin": 0.0007317680121343873, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "K56": { + "valid": 2745, + "positives": 10, + "negatives": 2735, + "auroc": 0.6761243144424132, + "auprc": 0.024210505281608636, + "brier": 0.0036208146046667654, + "calibration": { + "observed_rate": 0.0036429872495446266, + "mean_prediction": 0.004910225607778152, + "calibration_in_the_large": 0.0012672383582335257, + "expected_calibration_error_10bin": 0.0012672383582335257, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + "K57": { + "valid": 2741, + "positives": 4, + "negatives": 2737, + "auroc": 0.5902447935696018, + "auprc": 0.0029133926817601166, + "brier": 0.0014681357766741844, + "calibration": { + "observed_rate": 0.001459321415541773, + "mean_prediction": 0.0020160737859703523, + "calibration_in_the_large": 0.0005567523704285793, + "expected_calibration_error_10bin": 0.0005567523704285793, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "K58": { + "valid": 2792, + "positives": 5, + "negatives": 2787, + "auroc": 0.6731969860064586, + "auprc": 0.016613181143052387, + "brier": 0.00178540965262568, + "calibration": { + "observed_rate": 0.0017908309455587394, + "mean_prediction": 0.0007355427372107427, + "calibration_in_the_large": -0.0010552882083479966, + "expected_calibration_error_10bin": 0.0010552882083479966, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "K59": { + "valid": 2560, + "positives": 40, + "negatives": 2520, + "auroc": 0.728343253968254, + "auprc": 0.061047820671245, + "brier": 0.01510994370295778, + "calibration": { + "observed_rate": 0.015625, + "mean_prediction": 0.012685073766306232, + "calibration_in_the_large": -0.002939926233693768, + "expected_calibration_error_10bin": 0.0035343011320492232, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "K62": { + "valid": 2813, + "positives": 2, + "negatives": 2811, + "auroc": 0.9107079331198862, + "auprc": 0.012006564740433618, + "brier": 0.0007089818337758047, + "calibration": { + "observed_rate": 0.0007109847138286527, + "mean_prediction": 0.0013475493306090347, + "calibration_in_the_large": 0.000636564616780382, + "expected_calibration_error_10bin": 0.000636564616780382, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K63": { + "valid": 2810, + "positives": 6, + "negatives": 2804, + "auroc": 0.6817047075606276, + "auprc": 0.006002337556696962, + "brier": 0.0021312547085187063, + "calibration": { + "observed_rate": 0.002135231316725979, + "mean_prediction": 0.0014209827073629958, + "calibration_in_the_large": -0.000714248609362983, + "expected_calibration_error_10bin": 0.000714248609362983, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "K64": { + "valid": 2801, + "positives": 5, + "negatives": 2796, + "auroc": 0.7741773962804006, + "auprc": 0.007401656111602215, + "brier": 0.0018018275617393712, + "calibration": { + "observed_rate": 0.001785076758300607, + "mean_prediction": 0.002312823764295302, + "calibration_in_the_large": 0.0005277470059946948, + "expected_calibration_error_10bin": 0.0005277470059946948, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "K65": { + "valid": 2813, + "positives": 7, + "negatives": 2806, + "auroc": 0.8170756542103655, + "auprc": 0.019407447827352476, + "brier": 0.0025308803227438786, + "calibration": { + "observed_rate": 0.002488446498400284, + "mean_prediction": 0.004103820467166959, + "calibration_in_the_large": 0.0016153739687666748, + "expected_calibration_error_10bin": 0.0016153739687666741, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K66": { + "valid": 2796, + "positives": 1, + "negatives": 2795, + "auroc": 0.91520572450805, + "auprc": 0.004201680672268907, + "brier": 0.0003613679152521979, + "calibration": { + "observed_rate": 0.000357653791130186, + "mean_prediction": 0.0012150248888771365, + "calibration_in_the_large": 0.0008573710977469505, + "expected_calibration_error_10bin": 0.0008573710977469505, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "K70": { + "valid": 2774, + "positives": 1, + "negatives": 2773, + "auroc": 0.9552830869094843, + "auprc": 0.008, + "brier": 0.0003639009501470907, + "calibration": { + "observed_rate": 0.0003604902667627974, + "mean_prediction": 0.000444189007710916, + "calibration_in_the_large": 8.369874094811861e-05, + "expected_calibration_error_10bin": 8.369874094811861e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "K72": { + "valid": 2787, + "positives": 6, + "negatives": 2781, + "auroc": 0.9727915617883255, + "auprc": 0.2667591348625832, + "brier": 0.0019670511521187543, + "calibration": { + "observed_rate": 0.002152852529601722, + "mean_prediction": 0.0016301186927180687, + "calibration_in_the_large": -0.0005227338368836534, + "expected_calibration_error_10bin": 0.0007130093786881039, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "K74": { + "valid": 2763, + "positives": 3, + "negatives": 2760, + "auroc": 0.9318840579710145, + "auprc": 0.01931765253842571, + "brier": 0.0011009710228221984, + "calibration": { + "observed_rate": 0.0010857763300760044, + "mean_prediction": 0.0014979695074535768, + "calibration_in_the_large": 0.0004121931773775724, + "expected_calibration_error_10bin": 0.0004121931773775725, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "K75": { + "valid": 2798, + "positives": 4, + "negatives": 2794, + "auroc": 0.8517358625626342, + "auprc": 0.022038246146339174, + "brier": 0.001422217059274201, + "calibration": { + "observed_rate": 0.0014295925661186562, + "mean_prediction": 0.0010956803430147702, + "calibration_in_the_large": -0.00033391222310388607, + "expected_calibration_error_10bin": 0.00033391222310388607, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "K76": { + "valid": 2681, + "positives": 14, + "negatives": 2667, + "auroc": 0.8445819272590926, + "auprc": 0.14768579231228016, + "brier": 0.004858946602795243, + "calibration": { + "observed_rate": 0.005221932114882507, + "mean_prediction": 0.002142196715541782, + "calibration_in_the_large": -0.0030797353993407247, + "expected_calibration_error_10bin": 0.0035858856427395396, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + "K80": { + "valid": 2731, + "positives": 3, + "negatives": 2728, + "auroc": 0.7130987292277615, + "auprc": 0.004653053064247719, + "brier": 0.0010993491221072097, + "calibration": { + "observed_rate": 0.0010984987184181618, + "mean_prediction": 0.0011823582181252873, + "calibration_in_the_large": 8.385949970712544e-05, + "expected_calibration_error_10bin": 8.385949970712544e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + "K81": { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.7631951824300389, + "auprc": 0.04241967871485944, + "brier": 0.0006995710191396406, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0007780912214810537, + "calibration_in_the_large": 7.012661971114221e-05, + "expected_calibration_error_10bin": 7.012661971114221e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "K82": { + "valid": 2824, + "positives": 1, + "negatives": 2823, + "auroc": 0.9567835635848388, + "auprc": 0.008130081300813009, + "brier": 0.00035451964112316923, + "calibration": { + "observed_rate": 0.0003541076487252125, + "mean_prediction": 0.0005930908405183228, + "calibration_in_the_large": 0.00023898319179311032, + "expected_calibration_error_10bin": 0.00023898319179311032, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K83": { + "valid": 2757, + "positives": 4, + "negatives": 2753, + "auroc": 0.9305303305484925, + "auprc": 0.2585927960927961, + "brier": 0.0013904744920042512, + "calibration": { + "observed_rate": 0.0014508523757707653, + "mean_prediction": 0.001950629621404986, + "calibration_in_the_large": 0.0004997772456342207, + "expected_calibration_error_10bin": 0.0011004990043269097, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + "K85": { + "valid": 2779, + "positives": 2, + "negatives": 2777, + "auroc": 0.6404393230104429, + "auprc": 0.002676919615825537, + "brier": 0.0007198360220028482, + "calibration": { + "observed_rate": 0.0007196833393306944, + "mean_prediction": 0.0006816806931810275, + "calibration_in_the_large": -3.8002646149666954e-05, + "expected_calibration_error_10bin": 3.8002646149666954e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + "K86": { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.813915857605178, + "auprc": 0.014812419828167507, + "brier": 0.0014307801365062223, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.0012603010987264985, + "calibration_in_the_large": -0.00017596461042969553, + "expected_calibration_error_10bin": 0.00017596461042969553, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K90": { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.6279151943462897, + "auprc": 0.0009487666034155598, + "brier": 0.00035387420468255656, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.000406175223038834, + "calibration_in_the_large": 5.2943149566562705e-05, + "expected_calibration_error_10bin": 5.2943149566562705e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "K91": { + "valid": 2768, + "positives": 13, + "negatives": 2755, + "auroc": 0.8627669970682675, + "auprc": 0.034413500724918264, + "brier": 0.004622851933015879, + "calibration": { + "observed_rate": 0.004696531791907515, + "mean_prediction": 0.0034157783901235424, + "calibration_in_the_large": -0.0012807534017839723, + "expected_calibration_error_10bin": 0.0013582734897913116, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "K92": { + "valid": 2751, + "positives": 11, + "negatives": 2740, + "auroc": 0.8752488387524884, + "auprc": 0.03423840198752282, + "brier": 0.0039271834120101455, + "calibration": { + "observed_rate": 0.003998545983278807, + "mean_prediction": 0.0048845236097718155, + "calibration_in_the_large": 0.0008859776264930081, + "expected_calibration_error_10bin": 0.0008859776264930081, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "K94": { + "valid": 2823, + "positives": 8, + "negatives": 2815, + "auroc": 0.9157637655417407, + "auprc": 0.07505536458523408, + "brier": 0.0027411602177574903, + "calibration": { + "observed_rate": 0.0028338646829613886, + "mean_prediction": 0.002534860658660864, + "calibration_in_the_large": -0.00029900402430052455, + "expected_calibration_error_10bin": 0.0002990040243005248, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "L02": { + "valid": 2807, + "positives": 9, + "negatives": 2798, + "auroc": 0.703081566198078, + "auprc": 0.019544023506255972, + "brier": 0.003191117486810378, + "calibration": { + "observed_rate": 0.003206270039187745, + "mean_prediction": 0.0025958968061487375, + "calibration_in_the_large": -0.0006103732330390074, + "expected_calibration_error_10bin": 0.0006103732330390074, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "L03": { + "valid": 2701, + "positives": 11, + "negatives": 2690, + "auroc": 0.6786414329165259, + "auprc": 0.011320226102780922, + "brier": 0.004058183732989258, + "calibration": { + "observed_rate": 0.004072565716401333, + "mean_prediction": 0.0035769257204415674, + "calibration_in_the_large": -0.0004956399959597652, + "expected_calibration_error_10bin": 0.0004956399959597652, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + "L08": { + "valid": 2830, + "positives": 3, + "negatives": 2827, + "auroc": 0.7707817474354439, + "auprc": 0.0054457722409498276, + "brier": 0.0010590952707770032, + "calibration": { + "observed_rate": 0.0010600706713780918, + "mean_prediction": 0.000654352718886626, + "calibration_in_the_large": -0.0004057179524914658, + "expected_calibration_error_10bin": 0.0004057179524914658, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + "L27": { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.8177746178457164, + "auprc": 0.008852961486882973, + "brier": 0.0017948092210922563, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.002172023769228319, + "calibration_in_the_large": 0.00039771574935606926, + "expected_calibration_error_10bin": 0.00039771574935606926, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "L29": { + "valid": 2817, + "positives": 2, + "negatives": 2815, + "auroc": 0.25737122557726466, + "auprc": 0.0007007489337884125, + "brier": 0.0007210634513661779, + "calibration": { + "observed_rate": 0.0007099751508697196, + "mean_prediction": 0.0014541043755126424, + "calibration_in_the_large": 0.0007441292246429228, + "expected_calibration_error_10bin": 0.0007441292246429228, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "L30": { + "valid": 2816, + "positives": 2, + "negatives": 2814, + "auroc": 0.8303127221037668, + "auprc": 0.08438375350140055, + "brier": 0.0007039335857950084, + "calibration": { + "observed_rate": 0.0007102272727272727, + "mean_prediction": 0.0006982948439984552, + "calibration_in_the_large": -1.193242872881751e-05, + "expected_calibration_error_10bin": 1.193242872881751e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "L50": { + "valid": 2835, + "positives": 2, + "negatives": 2833, + "auroc": 0.8233321567243205, + "auprc": 0.01954205997194738, + "brier": 0.0007034084139042858, + "calibration": { + "observed_rate": 0.0007054673721340388, + "mean_prediction": 0.0004548739389581807, + "calibration_in_the_large": -0.00025059343317585816, + "expected_calibration_error_10bin": 0.00025059343317585816, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + "L53": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 1.7986162570243918e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.000589659493540077, + "calibration_in_the_large": 0.000589659493540077, + "expected_calibration_error_10bin": 0.000589659493540077, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "L76": { + "valid": 2793, + "positives": 8, + "negatives": 2785, + "auroc": 0.5565978456014362, + "auprc": 0.003719458611884151, + "brier": 0.002883616909108177, + "calibration": { + "observed_rate": 0.0028643036161833156, + "mean_prediction": 0.003625925309673101, + "calibration_in_the_large": 0.0007616216934897852, + "expected_calibration_error_10bin": 0.0007616216934897852, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "L89": { + "valid": 2798, + "positives": 10, + "negatives": 2788, + "auroc": 0.857819225251076, + "auprc": 0.018251626700766993, + "brier": 0.0035508243129443256, + "calibration": { + "observed_rate": 0.0035739814152966403, + "mean_prediction": 0.002323245981444404, + "calibration_in_the_large": -0.0012507354338522365, + "expected_calibration_error_10bin": 0.0012507354338522365, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "L97": { + "valid": 2789, + "positives": 3, + "negatives": 2786, + "auroc": 0.9392199090691553, + "auprc": 0.021892612816167705, + "brier": 0.0010839010774662842, + "calibration": { + "observed_rate": 0.0010756543564001434, + "mean_prediction": 0.0015493935734248883, + "calibration_in_the_large": 0.0004737392170247449, + "expected_calibration_error_10bin": 0.0004737392170247451, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "L98": { + "valid": 2824, + "positives": 1, + "negatives": 2823, + "auroc": 0.4406659582004959, + "auprc": 0.0006329113924050633, + "brier": 0.00036496365712950933, + "calibration": { + "observed_rate": 0.0003541076487252125, + "mean_prediction": 0.001665950700121344, + "calibration_in_the_large": 0.0013118430513961315, + "expected_calibration_error_10bin": 0.0013118430513961315, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "M10": { + "valid": 2713, + "positives": 8, + "negatives": 2705, + "auroc": 0.8886321626617375, + "auprc": 0.03457375864948539, + "brier": 0.0029088366278169765, + "calibration": { + "observed_rate": 0.002948765204570586, + "mean_prediction": 0.0021454547319356594, + "calibration_in_the_large": -0.0008033104726349266, + "expected_calibration_error_10bin": 0.0008033104726349266, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + "M16": { + "valid": 2790, + "positives": 1, + "negatives": 2789, + "auroc": 0.7314449623520975, + "auprc": 0.0013333333333333333, + "brier": 0.0003588866641305319, + "calibration": { + "observed_rate": 0.00035842293906810036, + "mean_prediction": 0.0005702617557179234, + "calibration_in_the_large": 0.00021183881664982307, + "expected_calibration_error_10bin": 0.00021183881664982307, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "M17": { + "valid": 2733, + "positives": 4, + "negatives": 2729, + "auroc": 0.7945218028581899, + "auprc": 0.006737891566058897, + "brier": 0.0014612578691539442, + "calibration": { + "observed_rate": 0.0014635931211123307, + "mean_prediction": 0.0006960790932788027, + "calibration_in_the_large": -0.000767514027833528, + "expected_calibration_error_10bin": 0.000767514027833528, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "M19": { + "valid": 2674, + "positives": 15, + "negatives": 2659, + "auroc": 0.6812586185282687, + "auprc": 0.017101849380956373, + "brier": 0.005564402411892922, + "calibration": { + "observed_rate": 0.005609573672400898, + "mean_prediction": 0.005137622098659779, + "calibration_in_the_large": -0.0004719515737411188, + "expected_calibration_error_10bin": 0.0004719515737411188, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + "M21": { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.9652482269503546, + "auprc": 0.010101010101010102, + "brier": 0.00035378074480719757, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.00044974201194293296, + "calibration_in_the_large": 9.525778649096557e-05, + "expected_calibration_error_10bin": 9.525778649096557e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "M25": { + "valid": 2717, + "positives": 8, + "negatives": 2709, + "auroc": 0.6410575858250277, + "auprc": 0.010266083596834143, + "brier": 0.0029423673467278027, + "calibration": { + "observed_rate": 0.002944423997055576, + "mean_prediction": 0.004497711141980877, + "calibration_in_the_large": 0.0015532871449253013, + "expected_calibration_error_10bin": 0.0015532871449253013, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + "M35": { + "valid": 2806, + "positives": 1, + "negatives": 2805, + "auroc": 0.879144385026738, + "auprc": 0.0029411764705882353, + "brier": 0.00035674893565410654, + "calibration": { + "observed_rate": 0.0003563791874554526, + "mean_prediction": 0.00030090468209335175, + "calibration_in_the_large": -5.547450536210087e-05, + "expected_calibration_error_10bin": 5.547450536210087e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "M46": { + "valid": 2814, + "positives": 1, + "negatives": 2813, + "auroc": 0.1702808389619623, + "auprc": 0.00042826552462526765, + "brier": 0.00035684104004644624, + "calibration": { + "observed_rate": 0.00035536602700781805, + "mean_prediction": 0.0007722912810130847, + "calibration_in_the_large": 0.00041692525400526665, + "expected_calibration_error_10bin": 0.00041692525400526665, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "M47": { + "valid": 2743, + "positives": 2, + "negatives": 2741, + "auroc": 0.6900766143743159, + "auprc": 0.004798777918246944, + "brier": 0.0007284503048648989, + "calibration": { + "observed_rate": 0.0007291286912139992, + "mean_prediction": 0.0010258644520863152, + "calibration_in_the_large": 0.000296735760872316, + "expected_calibration_error_10bin": 0.000296735760872316, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "M48": { + "valid": 2690, + "positives": 3, + "negatives": 2687, + "auroc": 0.8970351073067857, + "auprc": 0.01786201603274774, + "brier": 0.0011099026343264792, + "calibration": { + "observed_rate": 0.0011152416356877324, + "mean_prediction": 0.002104884296288395, + "calibration_in_the_large": 0.0009896426606006625, + "expected_calibration_error_10bin": 0.0009896426606006625, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + "M51": { + "valid": 2785, + "positives": 0, + "negatives": 2785, + "auroc": null, + "auprc": null, + "brier": 2.3521538110529908e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0012469913005799388, + "calibration_in_the_large": 0.0012469913005799388, + "expected_calibration_error_10bin": 0.0012469913005799388, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "M54": { + "valid": 2567, + "positives": 13, + "negatives": 2554, + "auroc": 0.6854707547738088, + "auprc": 0.017061149228888045, + "brier": 0.005037523751448775, + "calibration": { + "observed_rate": 0.00506427736657577, + "mean_prediction": 0.006815344598725235, + "calibration_in_the_large": 0.0017510672321494657, + "expected_calibration_error_10bin": 0.0017510672321494657, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + "M62": { + "valid": 2781, + "positives": 2, + "negatives": 2779, + "auroc": 0.5575746671464555, + "auprc": 0.003722374117110959, + "brier": 0.0007197150141120437, + "calibration": { + "observed_rate": 0.000719165767709457, + "mean_prediction": 0.0015021556041693882, + "calibration_in_the_large": 0.0007829898364599312, + "expected_calibration_error_10bin": 0.0007829898364599312, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "M79": { + "valid": 2697, + "positives": 15, + "negatives": 2682, + "auroc": 0.7732289336316182, + "auprc": 0.02155512067433006, + "brier": 0.005502299590456802, + "calibration": { + "observed_rate": 0.0055617352614015575, + "mean_prediction": 0.006302512956044713, + "calibration_in_the_large": 0.0007407776946431553, + "expected_calibration_error_10bin": 0.0007407776946431553, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + "M81": { + "valid": 2705, + "positives": 5, + "negatives": 2700, + "auroc": 0.7559259259259259, + "auprc": 0.02800194048736514, + "brier": 0.001831808632400622, + "calibration": { + "observed_rate": 0.0018484288354898336, + "mean_prediction": 0.0016072510103728784, + "calibration_in_the_large": -0.0002411778251169552, + "expected_calibration_error_10bin": 0.0002411778251169552, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + "M84": { + "valid": 2818, + "positives": 1, + "negatives": 2817, + "auroc": 0.9737309194178204, + "auprc": 0.013333333333333334, + "brier": 0.00035608631849184133, + "calibration": { + "observed_rate": 0.00035486160397445, + "mean_prediction": 0.0009143512469065902, + "calibration_in_the_large": 0.0005594896429321403, + "expected_calibration_error_10bin": 0.0005594896429321403, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "M85": { + "valid": 2768, + "positives": 2, + "negatives": 2766, + "auroc": 0.7640997830802603, + "auprc": 0.0028093386044757266, + "brier": 0.0007228389560549529, + "calibration": { + "observed_rate": 0.000722543352601156, + "mean_prediction": 0.0009021812705705508, + "calibration_in_the_large": 0.0001796379179693948, + "expected_calibration_error_10bin": 0.0001796379179693948, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "M86": { + "valid": 2803, + "positives": 4, + "negatives": 2799, + "auroc": 0.9439085387638443, + "auprc": 0.03813222376329172, + "brier": 0.0014157175104582331, + "calibration": { + "observed_rate": 0.0014270424545130217, + "mean_prediction": 0.0014073790492592814, + "calibration_in_the_large": -1.9663405253740347e-05, + "expected_calibration_error_10bin": 1.9663405253740347e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + "M94": { + "valid": 2819, + "positives": 1, + "negatives": 2818, + "auroc": 0.8474095102909865, + "auprc": 0.002320185614849188, + "brier": 0.00035464283486693466, + "calibration": { + "observed_rate": 0.000354735721887194, + "mean_prediction": 0.00011303410282673626, + "calibration_in_the_large": -0.00024170161906045777, + "expected_calibration_error_10bin": 0.00024170161906045777, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "M96": { + "valid": 2804, + "positives": 1, + "negatives": 2803, + "auroc": 0.8983232251159472, + "auprc": 0.0034965034965034965, + "brier": 0.0003655242413088071, + "calibration": { + "observed_rate": 0.0003566333808844508, + "mean_prediction": 0.0019997825682071153, + "calibration_in_the_large": 0.0016431491873226645, + "expected_calibration_error_10bin": 0.0016431491873226645, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "N12": { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.6374248319773611, + "auprc": 0.0025801707334136537, + "brier": 0.0014148586968604857, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0006635899820742467, + "calibration_in_the_large": -0.0007493383118148384, + "expected_calibration_error_10bin": 0.0007493383118148384, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N13": { + "valid": 2756, + "positives": 2, + "negatives": 2754, + "auroc": 0.6568627450980392, + "auprc": 0.0018142032404246074, + "brier": 0.0007352316363156649, + "calibration": { + "observed_rate": 0.000725689404934688, + "mean_prediction": 0.001787242200556653, + "calibration_in_the_large": 0.001061552795621965, + "expected_calibration_error_10bin": 0.001061552795621965, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "N14": { + "valid": 2826, + "positives": 3, + "negatives": 2823, + "auroc": 0.7948990435706695, + "auprc": 0.003384613274215251, + "brier": 0.0010609995496630468, + "calibration": { + "observed_rate": 0.0010615711252653928, + "mean_prediction": 0.0005891584736195796, + "calibration_in_the_large": -0.0004724126516458131, + "expected_calibration_error_10bin": 0.0004724126516458131, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "N17": { + "valid": 2292, + "positives": 41, + "negatives": 2251, + "auroc": 0.7881591921205752, + "auprc": 0.08262652805010731, + "brier": 0.01715752718813378, + "calibration": { + "observed_rate": 0.01788830715532286, + "mean_prediction": 0.01939725881097499, + "calibration_in_the_large": 0.0015089516556521278, + "expected_calibration_error_10bin": 0.002376193294035378, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + "N18": { + "valid": 2440, + "positives": 15, + "negatives": 2425, + "auroc": 0.8980068728522337, + "auprc": 0.10024813837901024, + "brier": 0.005887831522071861, + "calibration": { + "observed_rate": 0.006147540983606557, + "mean_prediction": 0.004222169329860945, + "calibration_in_the_large": -0.0019253716537456118, + "expected_calibration_error_10bin": 0.0021242607744259984, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + "N20": { + "valid": 2806, + "positives": 7, + "negatives": 2799, + "auroc": 0.725361098351452, + "auprc": 0.005271627272225692, + "brier": 0.002492095413142029, + "calibration": { + "observed_rate": 0.0024946543121881683, + "mean_prediction": 0.0005075760515294005, + "calibration_in_the_large": -0.0019870782606587678, + "expected_calibration_error_10bin": 0.0019870782606587678, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "N25": { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.9352670675627874, + "auprc": 0.04578647871147106, + "brier": 0.0014041738208733854, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0003779325476470599, + "calibration_in_the_large": -0.0010349957462420251, + "expected_calibration_error_10bin": 0.0010349957462420251, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N28": { + "valid": 2789, + "positives": 3, + "negatives": 2786, + "auroc": 0.9218712610672409, + "auprc": 0.013620737551218835, + "brier": 0.0010710316606804193, + "calibration": { + "observed_rate": 0.0010756543564001434, + "mean_prediction": 0.001753799973365662, + "calibration_in_the_large": 0.0006781456169655186, + "expected_calibration_error_10bin": 0.0006781456169655186, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "N30": { + "valid": 2829, + "positives": 6, + "negatives": 2823, + "auroc": 0.7438304404298028, + "auprc": 0.0077046745122602255, + "brier": 0.002118119003507264, + "calibration": { + "observed_rate": 0.0021208907741251328, + "mean_prediction": 0.001638801949879983, + "calibration_in_the_large": -0.00048208882424514965, + "expected_calibration_error_10bin": 0.00048208882424514965, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N32": { + "valid": 2807, + "positives": 7, + "negatives": 2800, + "auroc": 0.7895408163265306, + "auprc": 0.02637465483674539, + "brier": 0.002471297758047159, + "calibration": { + "observed_rate": 0.0024937655860349127, + "mean_prediction": 0.0020772052784291924, + "calibration_in_the_large": -0.00041656030760572026, + "expected_calibration_error_10bin": 0.00041656030760572026, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "N39": { + "valid": 2520, + "positives": 31, + "negatives": 2489, + "auroc": 0.7727420002851255, + "auprc": 0.04213332439071456, + "brier": 0.012050241293883013, + "calibration": { + "observed_rate": 0.012301587301587301, + "mean_prediction": 0.016705271495794434, + "calibration_in_the_large": 0.004403684194207133, + "expected_calibration_error_10bin": 0.00441749705027582, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + "N40": { + "valid": 2606, + "positives": 7, + "negatives": 2599, + "auroc": 0.8656076512944539, + "auprc": 0.019624425762286096, + "brier": 0.002684607822571381, + "calibration": { + "observed_rate": 0.002686108979278588, + "mean_prediction": 0.0049921092090220815, + "calibration_in_the_large": 0.0023060002297434937, + "expected_calibration_error_10bin": 0.0023060002297434937, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + "N73": { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.9671145685997171, + "auprc": 0.010638297872340425, + "brier": 0.0003529423533409641, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.00031759916097338036, + "calibration_in_the_large": -3.588263471414175e-05, + "expected_calibration_error_10bin": 3.588263471414175e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N99": { + "valid": 2799, + "positives": 3, + "negatives": 2796, + "auroc": 0.7290176442536958, + "auprc": 0.006100789214773393, + "brier": 0.0010701668713202445, + "calibration": { + "observed_rate": 0.0010718113612004287, + "mean_prediction": 0.0006132275774724752, + "calibration_in_the_large": -0.00045858378372795356, + "expected_calibration_error_10bin": 0.00045858378372795356, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + "O69": { + "valid": 2743, + "positives": 3, + "negatives": 2740, + "auroc": 0.9987834549878345, + "auprc": 0.38888888888888884, + "brier": 0.0010262209169478345, + "calibration": { + "observed_rate": 0.001093693036820999, + "mean_prediction": 0.0002104014422112798, + "calibration_in_the_large": -0.0008832915946097191, + "expected_calibration_error_10bin": 0.0008832915946097191, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "O99": { + "valid": 2652, + "positives": 0, + "negatives": 2652, + "auroc": null, + "auprc": null, + "brier": 1.7670989060159306e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00024023827903174705, + "calibration_in_the_large": 0.00024023827903174705, + "expected_calibration_error_10bin": 0.00024023827903174705, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9328174463594794 + }, + "Q21": { + "valid": 2810, + "positives": 1, + "negatives": 2809, + "auroc": 0.838376646493414, + "auprc": 0.002197802197802198, + "brier": 0.00035577081781528515, + "calibration": { + "observed_rate": 0.00035587188612099647, + "mean_prediction": 0.0004565203989096967, + "calibration_in_the_large": 0.00010064851278870023, + "expected_calibration_error_10bin": 0.00010064851278870023, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "U07": { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 3.945989798552895e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0008845819560432409, + "calibration_in_the_large": 0.0008845819560432409, + "expected_calibration_error_10bin": 0.0008845819560432409, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + } + }, + "90": { + "A04": { + "valid": 2782, + "positives": 14, + "negatives": 2768, + "auroc": 0.7242981007431875, + "auprc": 0.0862556807831821, + "brier": 0.004978782181682981, + "calibration": { + "observed_rate": 0.0050323508267433505, + "mean_prediction": 0.005623828742002762, + "calibration_in_the_large": 0.0005914779152594116, + "expected_calibration_error_10bin": 0.0005914779152594116, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "A08": { + "valid": 2818, + "positives": 7, + "negatives": 2811, + "auroc": 0.785993799867866, + "auprc": 0.02257485648693185, + "brier": 0.0024617597720808133, + "calibration": { + "observed_rate": 0.00248403122782115, + "mean_prediction": 0.0019389119130297807, + "calibration_in_the_large": -0.0005451193147913691, + "expected_calibration_error_10bin": 0.0005451193147913691, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "A41": { + "valid": 2664, + "positives": 27, + "negatives": 2637, + "auroc": 0.78537619910392, + "auprc": 0.044400570196306, + "brier": 0.010072639508335281, + "calibration": { + "observed_rate": 0.010135135135135136, + "mean_prediction": 0.015118735175607842, + "calibration_in_the_large": 0.004983600040472706, + "expected_calibration_error_10bin": 0.005048433605631952, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + "B00": { + "valid": 2819, + "positives": 1, + "negatives": 2818, + "auroc": 0.9932576295244855, + "auprc": 0.05, + "brier": 0.0003570603288321953, + "calibration": { + "observed_rate": 0.000354735721887194, + "mean_prediction": 0.0008557984868408771, + "calibration_in_the_large": 0.0005010627649536831, + "expected_calibration_error_10bin": 0.0005010627649536831, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "B02": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.798019101521047, + "auprc": 0.0017482517482517483, + "brier": 0.00035410456892655034, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0003444244007510485, + "calibration_in_the_large": -9.182388499305095e-06, + "expected_calibration_error_10bin": 9.182388499305095e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "B18": { + "valid": 2782, + "positives": 3, + "negatives": 2779, + "auroc": 0.9710927192035504, + "auprc": 0.06670022483975972, + "brier": 0.0010551157369714998, + "calibration": { + "observed_rate": 0.0010783608914450035, + "mean_prediction": 0.0006650988765299049, + "calibration_in_the_large": -0.00041326201491509863, + "expected_calibration_error_10bin": 0.00041326201491509863, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "B19": { + "valid": 2763, + "positives": 12, + "negatives": 2751, + "auroc": 0.8620804555919059, + "auprc": 0.04843594122182119, + "brier": 0.0042923268838261286, + "calibration": { + "observed_rate": 0.004343105320304018, + "mean_prediction": 0.0011686871420566911, + "calibration_in_the_large": -0.0031744181782473267, + "expected_calibration_error_10bin": 0.0032498774374154866, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "B20": { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.9791371994342292, + "auprc": 0.016666666666666666, + "brier": 0.0003543564339330188, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.000142903783835134, + "calibration_in_the_large": -0.0002105780118523881, + "expected_calibration_error_10bin": 0.0002105780118523881, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "B34": { + "valid": 2831, + "positives": 3, + "negatives": 2828, + "auroc": 0.9754832626119755, + "auprc": 0.034995112414467254, + "brier": 0.0010518051614735592, + "calibration": { + "observed_rate": 0.0010596962204168139, + "mean_prediction": 0.0005931656146922633, + "calibration_in_the_large": -0.00046653060572455054, + "expected_calibration_error_10bin": 0.00046653060572455054, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "B35": { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 4.468652274849919e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0008636864438935569, + "calibration_in_the_large": 0.0008636864438935569, + "expected_calibration_error_10bin": 0.0008636864438935569, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "B37": { + "valid": 2768, + "positives": 18, + "negatives": 2750, + "auroc": 0.7480404040404041, + "auprc": 0.022878973022695346, + "brier": 0.006440716789790314, + "calibration": { + "observed_rate": 0.006502890173410405, + "mean_prediction": 0.005182209680757727, + "calibration_in_the_large": -0.0013206804926526776, + "expected_calibration_error_10bin": 0.001472809645000953, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "B95": { + "valid": 2678, + "positives": 34, + "negatives": 2644, + "auroc": 0.7055486339770402, + "auprc": 0.029085085602904306, + "brier": 0.012568407453497495, + "calibration": { + "observed_rate": 0.012696041822255415, + "mean_prediction": 0.013914825682462415, + "calibration_in_the_large": 0.0012187838602070004, + "expected_calibration_error_10bin": 0.0012187838602069991, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + "B96": { + "valid": 2630, + "positives": 44, + "negatives": 2586, + "auroc": 0.7772533923926035, + "auprc": 0.09153216062312329, + "brier": 0.01603912335180003, + "calibration": { + "observed_rate": 0.016730038022813688, + "mean_prediction": 0.019063226651920877, + "calibration_in_the_large": 0.00233318862910719, + "expected_calibration_error_10bin": 0.0028366496296911114, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + "B97": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7693668199504775, + "auprc": 0.0015313935681470138, + "brier": 0.00035860008756675814, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.00042483629806659376, + "calibration_in_the_large": 7.122950881624014e-05, + "expected_calibration_error_10bin": 7.122950881624014e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "C18": { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9785613040396882, + "auprc": 0.04050925925925926, + "brier": 0.000704367998987495, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.00035938681878762186, + "calibration_in_the_large": -0.0003488284786628031, + "expected_calibration_error_10bin": 0.0003488284786628031, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "C22": { + "valid": 2812, + "positives": 5, + "negatives": 2807, + "auroc": 0.9182757392233701, + "auprc": 0.06204375620050009, + "brier": 0.001754232834736266, + "calibration": { + "observed_rate": 0.0017780938833570413, + "mean_prediction": 0.0004923491451986203, + "calibration_in_the_large": -0.001285744738158421, + "expected_calibration_error_10bin": 0.001285744738158421, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + "C25": { + "valid": 2809, + "positives": 1, + "negatives": 2808, + "auroc": 0.9992877492877493, + "auprc": 0.3333333333333333, + "brier": 0.00032982695302178255, + "calibration": { + "observed_rate": 0.000355998576005696, + "mean_prediction": 0.0003772138722228268, + "calibration_in_the_large": 2.1215296217130786e-05, + "expected_calibration_error_10bin": 6.438180634599325e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "C61": { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9662861220121298, + "auprc": 0.018571428571428572, + "brier": 0.0007100663180742796, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0005462121118349864, + "calibration_in_the_large": -0.00016680036588337366, + "expected_calibration_error_10bin": 0.00016680036588337366, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "C67": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9478245489918642, + "auprc": 0.020958851429303933, + "brier": 0.000705050062848144, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0002963797546735551, + "calibration_in_the_large": -0.00041058383670148914, + "expected_calibration_error_10bin": 0.00041058383670148914, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "C77": { + "valid": 2762, + "positives": 11, + "negatives": 2751, + "auroc": 0.8414791315554674, + "auprc": 0.09196641283536766, + "brier": 0.0038186965691718814, + "calibration": { + "observed_rate": 0.0039826212889210715, + "mean_prediction": 0.0025033350080765023, + "calibration_in_the_large": -0.0014792862808445692, + "expected_calibration_error_10bin": 0.0019706848462132352, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C78": { + "valid": 2762, + "positives": 16, + "negatives": 2746, + "auroc": 0.9068417698470502, + "auprc": 0.14979721047648617, + "brier": 0.005395391894854472, + "calibration": { + "observed_rate": 0.005792903692976104, + "mean_prediction": 0.0037771367022275595, + "calibration_in_the_large": -0.0020157669907485444, + "expected_calibration_error_10bin": 0.0023085162825752714, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C79": { + "valid": 2751, + "positives": 9, + "negatives": 2742, + "auroc": 0.9209417294756463, + "auprc": 0.06498286916079948, + "brier": 0.0036442276842902754, + "calibration": { + "observed_rate": 0.003271537622682661, + "mean_prediction": 0.004927303007315006, + "calibration_in_the_large": 0.0016557653846323455, + "expected_calibration_error_10bin": 0.0019406252924467312, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "C83": { + "valid": 2820, + "positives": 0, + "negatives": 2820, + "auroc": null, + "auprc": null, + "brier": 8.6204665346556e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0003089594705795581, + "calibration_in_the_large": 0.0003089594705795581, + "expected_calibration_error_10bin": 0.0003089594705795581, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "D25": { + "valid": 2792, + "positives": 2, + "negatives": 2790, + "auroc": 0.9410394265232975, + "auprc": 0.25303030303030305, + "brier": 0.0007109832724271869, + "calibration": { + "observed_rate": 0.0007163323782234957, + "mean_prediction": 0.0002706365691185113, + "calibration_in_the_large": -0.00044569580910498437, + "expected_calibration_error_10bin": 0.00044569580910498437, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "D47": { + "valid": 2796, + "positives": 6, + "negatives": 2790, + "auroc": 0.5994623655913979, + "auprc": 0.00383263802726138, + "brier": 0.0021685922808060434, + "calibration": { + "observed_rate": 0.002145922746781116, + "mean_prediction": 0.002832822037987544, + "calibration_in_the_large": 0.0006868992912064283, + "expected_calibration_error_10bin": 0.0006868992912064283, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "D50": { + "valid": 2663, + "positives": 28, + "negatives": 2635, + "auroc": 0.8306993765248035, + "auprc": 0.09873950624761132, + "brier": 0.010011445959010445, + "calibration": { + "observed_rate": 0.010514457378895982, + "mean_prediction": 0.008509544617330923, + "calibration_in_the_large": -0.0020049127615650586, + "expected_calibration_error_10bin": 0.0020049127615650586, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + "D53": { + "valid": 2805, + "positives": 9, + "negatives": 2796, + "auroc": 0.8280082657765061, + "auprc": 0.027725152323451716, + "brier": 0.003198331001208034, + "calibration": { + "observed_rate": 0.0032085561497326204, + "mean_prediction": 0.0037775179067216858, + "calibration_in_the_large": 0.0005689617569890654, + "expected_calibration_error_10bin": 0.0005689617569890656, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "D59": { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 2.0329733639102867e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0005229880152461508, + "calibration_in_the_large": 0.0005229880152461508, + "expected_calibration_error_10bin": 0.0005229880152461508, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "D61": { + "valid": 2773, + "positives": 15, + "negatives": 2758, + "auroc": 0.9404399323181049, + "auprc": 0.14782762754196435, + "brier": 0.0049683297513795875, + "calibration": { + "observed_rate": 0.005409304002884962, + "mean_prediction": 0.005824868733144596, + "calibration_in_the_large": 0.00041556473025963336, + "expected_calibration_error_10bin": 0.0008559120882905508, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "D62": { + "valid": 2499, + "positives": 30, + "negatives": 2469, + "auroc": 0.7908329958147698, + "auprc": 0.03258371834487977, + "brier": 0.011777888801700078, + "calibration": { + "observed_rate": 0.012004801920768308, + "mean_prediction": 0.01398957171044139, + "calibration_in_the_large": 0.001984769789673083, + "expected_calibration_error_10bin": 0.001984769789673084, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + "D63": { + "valid": 2686, + "positives": 43, + "negatives": 2643, + "auroc": 0.8986792668655246, + "auprc": 0.11713107233493347, + "brier": 0.01495676048428244, + "calibration": { + "observed_rate": 0.01600893521965748, + "mean_prediction": 0.013468455732372611, + "calibration_in_the_large": -0.0025404794872848704, + "expected_calibration_error_10bin": 0.004837578742593194, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + "D64": { + "valid": 2434, + "positives": 66, + "negatives": 2368, + "auroc": 0.8312730343980343, + "auprc": 0.12751706842416097, + "brier": 0.024938037465014332, + "calibration": { + "observed_rate": 0.027115858668857847, + "mean_prediction": 0.027886486189740642, + "calibration_in_the_large": 0.0007706275208827947, + "expected_calibration_error_10bin": 0.0021891341878150184, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + "D65": { + "valid": 2833, + "positives": 2, + "negatives": 2831, + "auroc": 0.9533733663016601, + "auprc": 0.011302681992337166, + "brier": 0.0007053666417099417, + "calibration": { + "observed_rate": 0.0007059654076950229, + "mean_prediction": 0.0005288345609153321, + "calibration_in_the_large": -0.0001771308467796908, + "expected_calibration_error_10bin": 0.0001771308467796908, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + "D68": { + "valid": 2682, + "positives": 29, + "negatives": 2653, + "auroc": 0.8277291810182357, + "auprc": 0.06158357457216069, + "brier": 0.010483497276894235, + "calibration": { + "observed_rate": 0.01081282624906786, + "mean_prediction": 0.006726104818559663, + "calibration_in_the_large": -0.0040867214305081966, + "expected_calibration_error_10bin": 0.0042492221491597535, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + "D69": { + "valid": 2586, + "positives": 40, + "negatives": 2546, + "auroc": 0.8793499607227023, + "auprc": 0.22352782653283598, + "brier": 0.013536723592942284, + "calibration": { + "observed_rate": 0.015467904098994586, + "mean_prediction": 0.011718464468070377, + "calibration_in_the_large": -0.003749439630924209, + "expected_calibration_error_10bin": 0.004745096568769, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + "D70": { + "valid": 2787, + "positives": 17, + "negatives": 2770, + "auroc": 0.902951794436186, + "auprc": 0.2846495567104899, + "brier": 0.005346787623792651, + "calibration": { + "observed_rate": 0.006099748833871547, + "mean_prediction": 0.005148950806453757, + "calibration_in_the_large": -0.0009507980274177895, + "expected_calibration_error_10bin": 0.004130656465754257, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "D72": { + "valid": 2595, + "positives": 34, + "negatives": 2561, + "auroc": 0.709672232813469, + "auprc": 0.05157529701806407, + "brier": 0.012766077053201725, + "calibration": { + "observed_rate": 0.013102119460500963, + "mean_prediction": 0.013764015933555265, + "calibration_in_the_large": 0.0006618964730543027, + "expected_calibration_error_10bin": 0.000901083481208259, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + "D73": { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.7629340892983699, + "auprc": 0.030167051714945797, + "brier": 0.0007061661210853564, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0008527993405774814, + "calibration_in_the_large": 0.0001445840431270564, + "expected_calibration_error_10bin": 0.00014458404312705643, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "D75": { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.9321554770318021, + "auprc": 0.0051813471502590676, + "brier": 0.0003544573909263853, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0007624157497902704, + "calibration_in_the_large": 0.0004091836763179991, + "expected_calibration_error_10bin": 0.0004091836763179991, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "D80": { + "valid": 2832, + "positives": 4, + "negatives": 2828, + "auroc": 0.9907178217821783, + "auprc": 0.08641774891774892, + "brier": 0.001376069339307882, + "calibration": { + "observed_rate": 0.0014124293785310734, + "mean_prediction": 0.0008402862824741494, + "calibration_in_the_large": -0.000572143096056924, + "expected_calibration_error_10bin": 0.0007626599246215247, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "D89": { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.8222222222222222, + "auprc": 0.006581462016244625, + "brier": 0.0007280025613646637, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.00037250139139643535, + "calibration_in_the_large": -0.00033246864737691677, + "expected_calibration_error_10bin": 0.0006047650768557071, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "E03": { + "valid": 2480, + "positives": 14, + "negatives": 2466, + "auroc": 0.7038002548951454, + "auprc": 0.012113944011970941, + "brier": 0.005610609269926346, + "calibration": { + "observed_rate": 0.00564516129032258, + "mean_prediction": 0.0029770003928499666, + "calibration_in_the_large": -0.0026681608974726137, + "expected_calibration_error_10bin": 0.0026681608974726137, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + "E04": { + "valid": 2775, + "positives": 6, + "negatives": 2769, + "auroc": 0.7096424702058505, + "auprc": 0.0054376677498259, + "brier": 0.0021584585112332266, + "calibration": { + "observed_rate": 0.002162162162162162, + "mean_prediction": 0.001504587216521949, + "calibration_in_the_large": -0.0006575749456402132, + "expected_calibration_error_10bin": 0.0006575749456402132, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "E05": { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.1144793152639087, + "auprc": 0.000591926725564978, + "brier": 0.0007136184889920264, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0006201494786836678, + "calibration_in_the_large": -9.260889622723749e-05, + "expected_calibration_error_10bin": 9.260889622723749e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "E11": { + "valid": 2194, + "positives": 11, + "negatives": 2183, + "auroc": 0.7716653479365344, + "auprc": 0.09053401244077744, + "brier": 0.004917814581008486, + "calibration": { + "observed_rate": 0.005013673655423883, + "mean_prediction": 0.003662995449120482, + "calibration_in_the_large": -0.0013506782063034011, + "expected_calibration_error_10bin": 0.0013506782063034011, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + "E16": { + "valid": 2816, + "positives": 4, + "negatives": 2812, + "auroc": 0.6985241820768137, + "auprc": 0.0031198556247761305, + "brier": 0.0014245808423998091, + "calibration": { + "observed_rate": 0.0014204545454545455, + "mean_prediction": 0.0015276190730149478, + "calibration_in_the_large": 0.00010716452756040235, + "expected_calibration_error_10bin": 0.00010716452756040235, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "E21": { + "valid": 2814, + "positives": 1, + "negatives": 2813, + "auroc": 0.9704941343761109, + "auprc": 0.011904761904761904, + "brier": 0.0003587744386924874, + "calibration": { + "observed_rate": 0.00035536602700781805, + "mean_prediction": 0.0008480758540723011, + "calibration_in_the_large": 0.000492709827064483, + "expected_calibration_error_10bin": 0.000492709827064483, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "E22": { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8132594710507506, + "auprc": 0.005786226842285457, + "brier": 0.0014688621883062584, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.0032973859610336527, + "calibration_in_the_large": 0.0018698342122827605, + "expected_calibration_error_10bin": 0.0018698342122827605, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "E27": { + "valid": 2811, + "positives": 0, + "negatives": 2811, + "auroc": null, + "auprc": null, + "brier": 8.988482086415122e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0013219003751498396, + "calibration_in_the_large": 0.0013219003751498396, + "expected_calibration_error_10bin": 0.0013219003751498396, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9887442842068238 + }, + "E43": { + "valid": 2748, + "positives": 25, + "negatives": 2723, + "auroc": 0.8066838046272493, + "auprc": 0.06565976789027038, + "brier": 0.008819533146898017, + "calibration": { + "observed_rate": 0.009097525473071324, + "mean_prediction": 0.007761421241177557, + "calibration_in_the_large": -0.0013361042318937666, + "expected_calibration_error_10bin": 0.0016910887061279526, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + "E44": { + "valid": 2800, + "positives": 11, + "negatives": 2789, + "auroc": 0.7535773656246945, + "auprc": 0.018656591111139768, + "brier": 0.003931026341575784, + "calibration": { + "observed_rate": 0.003928571428571429, + "mean_prediction": 0.005219285058345641, + "calibration_in_the_large": 0.0012907136297742126, + "expected_calibration_error_10bin": 0.0012907136297742126, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "E46": { + "valid": 2772, + "positives": 23, + "negatives": 2749, + "auroc": 0.8179100700650038, + "auprc": 0.05979506658432233, + "brier": 0.008079411349253267, + "calibration": { + "observed_rate": 0.008297258297258298, + "mean_prediction": 0.008499669854895078, + "calibration_in_the_large": 0.00020241155763678007, + "expected_calibration_error_10bin": 0.0004135129907693239, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + "E53": { + "valid": 2804, + "positives": 3, + "negatives": 2801, + "auroc": 0.7318814709032488, + "auprc": 0.003960097174943993, + "brier": 0.0010762872178110901, + "calibration": { + "observed_rate": 0.0010699001426533524, + "mean_prediction": 0.0015346988090158746, + "calibration_in_the_large": 0.0004647986663625222, + "expected_calibration_error_10bin": 0.0004647986663625222, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "E55": { + "valid": 2737, + "positives": 11, + "negatives": 2726, + "auroc": 0.5054692189688521, + "auprc": 0.005318941129121924, + "brier": 0.004063395181571917, + "calibration": { + "observed_rate": 0.00401899890390939, + "mean_prediction": 0.005813236261359754, + "calibration_in_the_large": 0.0017942373574503642, + "expected_calibration_error_10bin": 0.0017942373574503655, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + "E66": { + "valid": 2371, + "positives": 21, + "negatives": 2350, + "auroc": 0.707517730496454, + "auprc": 0.024681776173927233, + "brier": 0.008741602167468308, + "calibration": { + "observed_rate": 0.008857022353437369, + "mean_prediction": 0.008077342443023614, + "calibration_in_the_large": -0.0007796799104137549, + "expected_calibration_error_10bin": 0.0007796799104137549, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + "E78": { + "valid": 1572, + "positives": 26, + "negatives": 1546, + "auroc": 0.69907453477958, + "auprc": 0.04038673076294167, + "brier": 0.016460938949106618, + "calibration": { + "observed_rate": 0.01653944020356234, + "mean_prediction": 0.014672821172452416, + "calibration_in_the_large": -0.0018666190311099236, + "expected_calibration_error_10bin": 0.006829431723188546, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + "E80": { + "valid": 2823, + "positives": 4, + "negatives": 2819, + "auroc": 0.9703795672224192, + "auprc": 0.032896441990644884, + "brier": 0.0014072870949756043, + "calibration": { + "observed_rate": 0.0014169323414806943, + "mean_prediction": 0.0012719866593695916, + "calibration_in_the_large": -0.00014494568211110268, + "expected_calibration_error_10bin": 0.00014494568211110268, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "E83": { + "valid": 2653, + "positives": 40, + "negatives": 2613, + "auroc": 0.7906620742441638, + "auprc": 0.09365055298925837, + "brier": 0.014303505477043345, + "calibration": { + "observed_rate": 0.015077271013946476, + "mean_prediction": 0.012306588981236965, + "calibration_in_the_large": -0.0027706820327095105, + "expected_calibration_error_10bin": 0.0033096943730531432, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + "E86": { + "valid": 2587, + "positives": 42, + "negatives": 2545, + "auroc": 0.8029843764617831, + "auprc": 0.05873259109283963, + "brier": 0.015866784164652335, + "calibration": { + "observed_rate": 0.01623502126014689, + "mean_prediction": 0.02457196911993848, + "calibration_in_the_large": 0.00833694785979159, + "expected_calibration_error_10bin": 0.008336947859791591, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + "E87": { + "valid": 2185, + "positives": 74, + "negatives": 2111, + "auroc": 0.8017463223526701, + "auprc": 0.12865189196894916, + "brier": 0.031159748906545392, + "calibration": { + "observed_rate": 0.033867276887871854, + "mean_prediction": 0.031063788309874486, + "calibration_in_the_large": -0.0028034885779973685, + "expected_calibration_error_10bin": 0.006194102724223425, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + "E88": { + "valid": 2817, + "positives": 8, + "negatives": 2809, + "auroc": 0.7908508365966536, + "auprc": 0.08767680443540055, + "brier": 0.0027833025183718373, + "calibration": { + "observed_rate": 0.0028399006034788782, + "mean_prediction": 0.0020301176623074013, + "calibration_in_the_large": -0.0008097829411714769, + "expected_calibration_error_10bin": 0.0008097829411714769, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "E89": { + "valid": 2780, + "positives": 4, + "negatives": 2776, + "auroc": 0.7112752161383286, + "auprc": 0.0030286298966701354, + "brier": 0.0014384328144095245, + "calibration": { + "observed_rate": 0.0014388489208633094, + "mean_prediction": 0.0019810289140276046, + "calibration_in_the_large": 0.0005421799931642952, + "expected_calibration_error_10bin": 0.0005421799931642952, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "F02": { + "valid": 2802, + "positives": 1, + "negatives": 2801, + "auroc": 0.682256337022492, + "auprc": 0.001122334455667789, + "brier": 0.0003787464187045151, + "calibration": { + "observed_rate": 0.00035688793718772306, + "mean_prediction": 0.001531085545730158, + "calibration_in_the_large": 0.001174197608542435, + "expected_calibration_error_10bin": 0.001174197608542435, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "F03": { + "valid": 2739, + "positives": 10, + "negatives": 2729, + "auroc": 0.8359105899596921, + "auprc": 0.013737675308486874, + "brier": 0.0036578860804645985, + "calibration": { + "observed_rate": 0.0036509675063891934, + "mean_prediction": 0.0032813537556745914, + "calibration_in_the_large": -0.000369613750714602, + "expected_calibration_error_10bin": 0.00045554490642145564, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "F05": { + "valid": 2750, + "positives": 14, + "negatives": 2736, + "auroc": 0.7391917293233082, + "auprc": 0.016441017767335024, + "brier": 0.005110190490043966, + "calibration": { + "observed_rate": 0.005090909090909091, + "mean_prediction": 0.006598435252875788, + "calibration_in_the_large": 0.0015075261619666965, + "expected_calibration_error_10bin": 0.0015075261619666974, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "F06": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.672798019101521, + "auprc": 0.0010799136069114472, + "brier": 0.00036189331728836844, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0015843878935164451, + "calibration_in_the_large": 0.0012307811042660914, + "expected_calibration_error_10bin": 0.0012307811042660914, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "F10": { + "valid": 2560, + "positives": 9, + "negatives": 2551, + "auroc": 0.8443747549980399, + "auprc": 0.1645988826687351, + "brier": 0.0033314116088599645, + "calibration": { + "observed_rate": 0.003515625, + "mean_prediction": 0.004515074702084121, + "calibration_in_the_large": 0.0009994497020841208, + "expected_calibration_error_10bin": 0.0017085382212997046, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "F11": { + "valid": 2741, + "positives": 6, + "negatives": 2735, + "auroc": 0.8599024984765387, + "auprc": 0.03586521561483196, + "brier": 0.0021824812468110256, + "calibration": { + "observed_rate": 0.0021889821233126595, + "mean_prediction": 0.002649979504721999, + "calibration_in_the_large": 0.0004609973814093393, + "expected_calibration_error_10bin": 0.00046099738140933916, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "F12": { + "valid": 2777, + "positives": 10, + "negatives": 2767, + "auroc": 0.9000361402240694, + "auprc": 0.0246638239645944, + "brier": 0.003567648159949805, + "calibration": { + "observed_rate": 0.0036010082823190494, + "mean_prediction": 0.001797859459289909, + "calibration_in_the_large": -0.0018031488230291404, + "expected_calibration_error_10bin": 0.0018031488230291404, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "F14": { + "valid": 2787, + "positives": 8, + "negatives": 2779, + "auroc": 0.948452680820439, + "auprc": 0.04227602908796281, + "brier": 0.0028439753887716094, + "calibration": { + "observed_rate": 0.0028704700394689632, + "mean_prediction": 0.0007846000699405181, + "calibration_in_the_large": -0.002085869969528445, + "expected_calibration_error_10bin": 0.002085869969528445, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "F15": { + "valid": 2823, + "positives": 5, + "negatives": 2818, + "auroc": 0.979985805535841, + "auprc": 0.05755768361081455, + "brier": 0.0017568203989402024, + "calibration": { + "observed_rate": 0.001771165426850868, + "mean_prediction": 0.0002942619104538982, + "calibration_in_the_large": -0.0014769035163969698, + "expected_calibration_error_10bin": 0.0014769035163969698, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "F17": { + "valid": 2426, + "positives": 22, + "negatives": 2404, + "auroc": 0.8830736651036152, + "auprc": 0.09289347691980812, + "brier": 0.008633237534261482, + "calibration": { + "observed_rate": 0.009068425391591096, + "mean_prediction": 0.008528141960199619, + "calibration_in_the_large": -0.0005402834313914771, + "expected_calibration_error_10bin": 0.0013684301693479273, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + "F19": { + "valid": 2801, + "positives": 8, + "negatives": 2793, + "auroc": 0.9640171858216972, + "auprc": 0.1490612467666717, + "brier": 0.002777747884576193, + "calibration": { + "observed_rate": 0.002856122813280971, + "mean_prediction": 0.0007748727412935234, + "calibration_in_the_large": -0.002081250071987448, + "expected_calibration_error_10bin": 0.002081250071987448, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F20": { + "valid": 2808, + "positives": 2, + "negatives": 2806, + "auroc": 0.7576621525302922, + "auprc": 0.019267021512530492, + "brier": 0.0007094383580664572, + "calibration": { + "observed_rate": 0.0007122507122507123, + "mean_prediction": 0.000412424799550467, + "calibration_in_the_large": -0.0002998259127002453, + "expected_calibration_error_10bin": 0.0002998259127002453, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + "F22": { + "valid": 2821, + "positives": 0, + "negatives": 2821, + "auroc": null, + "auprc": null, + "brier": 1.6312538174357724e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0005997795582930727, + "calibration_in_the_large": 0.0005997795582930727, + "expected_calibration_error_10bin": 0.0005997795582930727, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "F25": { + "valid": 2819, + "positives": 2, + "negatives": 2817, + "auroc": 0.806354277600284, + "auprc": 0.008906440041260604, + "brier": 0.0007091109033616983, + "calibration": { + "observed_rate": 0.000709471443774388, + "mean_prediction": 0.0004812019670206513, + "calibration_in_the_large": -0.00022826947675373677, + "expected_calibration_error_10bin": 0.00022826947675373677, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "F29": { + "valid": 2806, + "positives": 6, + "negatives": 2800, + "auroc": 0.7242857142857143, + "auprc": 0.006163112255292743, + "brier": 0.002136251278939009, + "calibration": { + "observed_rate": 0.0021382751247327157, + "mean_prediction": 0.00043347784429147705, + "calibration_in_the_large": -0.0017047972804412387, + "expected_calibration_error_10bin": 0.0017047972804412387, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "F31": { + "valid": 2724, + "positives": 7, + "negatives": 2717, + "auroc": 0.8469951101530049, + "auprc": 0.031351311772159586, + "brier": 0.0025414906547455377, + "calibration": { + "observed_rate": 0.0025697503671071953, + "mean_prediction": 0.0016927425128512546, + "calibration_in_the_large": -0.0008770078542559407, + "expected_calibration_error_10bin": 0.0008770078542559407, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + "F32": { + "valid": 2200, + "positives": 36, + "negatives": 2164, + "auroc": 0.7090521667693571, + "auprc": 0.05153386644176028, + "brier": 0.016087157025959732, + "calibration": { + "observed_rate": 0.016363636363636365, + "mean_prediction": 0.02333804415687072, + "calibration_in_the_large": 0.006974407793234355, + "expected_calibration_error_10bin": 0.006974407793234354, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + "F33": { + "valid": 2800, + "positives": 7, + "negatives": 2793, + "auroc": 0.7792440284384431, + "auprc": 0.010011575579401761, + "brier": 0.0025092012373483788, + "calibration": { + "observed_rate": 0.0025, + "mean_prediction": 0.0020195366195626513, + "calibration_in_the_large": -0.0004804633804373487, + "expected_calibration_error_10bin": 0.0004804633804373487, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "F39": { + "valid": 2801, + "positives": 7, + "negatives": 2794, + "auroc": 0.7324879844564884, + "auprc": 0.01754211139146753, + "brier": 0.0024855151297189697, + "calibration": { + "observed_rate": 0.0024991074616208496, + "mean_prediction": 0.0013536860039293716, + "calibration_in_the_large": -0.001145421457691478, + "expected_calibration_error_10bin": 0.001145421457691478, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F41": { + "valid": 2247, + "positives": 43, + "negatives": 2204, + "auroc": 0.7191997636432702, + "auprc": 0.08127448445302451, + "brier": 0.018264123770466743, + "calibration": { + "observed_rate": 0.01913662661326213, + "mean_prediction": 0.020986191337657938, + "calibration_in_the_large": 0.0018495647243958087, + "expected_calibration_error_10bin": 0.0035472951615357737, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + "F43": { + "valid": 2734, + "positives": 13, + "negatives": 2721, + "auroc": 0.7761004155711984, + "auprc": 0.07583180947674197, + "brier": 0.00465858764705935, + "calibration": { + "observed_rate": 0.004754937820043892, + "mean_prediction": 0.005003201749342532, + "calibration_in_the_large": 0.0002482639292986401, + "expected_calibration_error_10bin": 0.00024826392929864095, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "F60": { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.9442587984358336, + "auprc": 0.026757579878754913, + "brier": 0.0017608073878784911, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.000968161668704063, + "calibration_in_the_large": -0.0008061463511681867, + "expected_calibration_error_10bin": 0.0008061463511681867, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "F90": { + "valid": 2775, + "positives": 5, + "negatives": 2770, + "auroc": 0.875956678700361, + "auprc": 0.02587721015509417, + "brier": 0.001793720800913963, + "calibration": { + "observed_rate": 0.0018018018018018018, + "mean_prediction": 0.0005162521991351732, + "calibration_in_the_large": -0.0012855496026666286, + "expected_calibration_error_10bin": 0.0012855496026666286, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "G25": { + "valid": 2774, + "positives": 4, + "negatives": 2770, + "auroc": 0.6845667870036101, + "auprc": 0.00379359477710247, + "brier": 0.0014451861585640146, + "calibration": { + "observed_rate": 0.0014419610670511895, + "mean_prediction": 0.0018391469400801518, + "calibration_in_the_large": 0.00039718587302896226, + "expected_calibration_error_10bin": 0.00039718587302896226, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "G31": { + "valid": 2802, + "positives": 1, + "negatives": 2801, + "auroc": 0.6197786504819707, + "auprc": 0.0009380863039399625, + "brier": 0.0004006247460592733, + "calibration": { + "observed_rate": 0.00035688793718772306, + "mean_prediction": 0.0025017041484670733, + "calibration_in_the_large": 0.0021448162112793503, + "expected_calibration_error_10bin": 0.00214481621127935, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "G40": { + "valid": 2723, + "positives": 11, + "negatives": 2712, + "auroc": 0.7375972110485385, + "auprc": 0.04032463721521418, + "brier": 0.003979856778925553, + "calibration": { + "observed_rate": 0.004039662137348513, + "mean_prediction": 0.003744128791260435, + "calibration_in_the_large": -0.00029553334608807807, + "expected_calibration_error_10bin": 0.0004553306516200225, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "G43": { + "valid": 2725, + "positives": 8, + "negatives": 2717, + "auroc": 0.8150073610599926, + "auprc": 0.015398309046025384, + "brier": 0.0029177074304990052, + "calibration": { + "observed_rate": 0.0029357798165137615, + "mean_prediction": 0.0018099905335111543, + "calibration_in_the_large": -0.0011257892830026071, + "expected_calibration_error_10bin": 0.0011257892830026071, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + "G44": { + "valid": 2805, + "positives": 3, + "negatives": 2802, + "auroc": 0.7750416369260053, + "auprc": 0.006199877663481359, + "brier": 0.001070418534595204, + "calibration": { + "observed_rate": 0.0010695187165775401, + "mean_prediction": 0.000952438487706178, + "calibration_in_the_large": -0.00011708022887136217, + "expected_calibration_error_10bin": 0.00011708022887136217, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "G47": { + "valid": 2315, + "positives": 47, + "negatives": 2268, + "auroc": 0.7175972832001201, + "auprc": 0.0596759189128188, + "brier": 0.019582274546423282, + "calibration": { + "observed_rate": 0.020302375809935207, + "mean_prediction": 0.017486073515055094, + "calibration_in_the_large": -0.002816302294880113, + "expected_calibration_error_10bin": 0.003869477715157173, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + "G51": { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 2.004267137712584e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.000287026985138277, + "calibration_in_the_large": 0.000287026985138277, + "expected_calibration_error_10bin": 0.000287026985138277, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + "G62": { + "valid": 2751, + "positives": 20, + "negatives": 2731, + "auroc": 0.8701025265470523, + "auprc": 0.11622898533869955, + "brier": 0.0068690021140475005, + "calibration": { + "observed_rate": 0.007270083605961469, + "mean_prediction": 0.004341701514869475, + "calibration_in_the_large": -0.0029283820910919935, + "expected_calibration_error_10bin": 0.002928382091091993, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "G81": { + "valid": 2789, + "positives": 10, + "negatives": 2779, + "auroc": 0.7813961856783016, + "auprc": 0.026234954352391447, + "brier": 0.0035649381822054427, + "calibration": { + "observed_rate": 0.0035855145213338113, + "mean_prediction": 0.001531335567776024, + "calibration_in_the_large": -0.0020541789535577872, + "expected_calibration_error_10bin": 0.0020541789535577872, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "G83": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.7359092520382843, + "auprc": 0.004965419101983338, + "brier": 0.001062076582348748, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0007483006996626345, + "calibration_in_the_large": -0.000314022246513003, + "expected_calibration_error_10bin": 0.000314022246513003, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "G89": { + "valid": 2537, + "positives": 29, + "negatives": 2508, + "auroc": 0.7999230050046747, + "auprc": 0.053191970010511555, + "brier": 0.011217188360877468, + "calibration": { + "observed_rate": 0.011430823807646828, + "mean_prediction": 0.01684684684444988, + "calibration_in_the_large": 0.005416023036803053, + "expected_calibration_error_10bin": 0.0054160230368030535, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + "G90": { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 4.066742082029411e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0010641545609615802, + "calibration_in_the_large": 0.0010641545609615802, + "expected_calibration_error_10bin": 0.0010641545609615802, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "G92": { + "valid": 2733, + "positives": 19, + "negatives": 2714, + "auroc": 0.7675600201683279, + "auprc": 0.024404118862562166, + "brier": 0.006959062139358657, + "calibration": { + "observed_rate": 0.006952067325283571, + "mean_prediction": 0.01014009571965317, + "calibration_in_the_large": 0.0031880283943695993, + "expected_calibration_error_10bin": 0.003188028394369598, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "G93": { + "valid": 2656, + "positives": 26, + "negatives": 2630, + "auroc": 0.8057180462123428, + "auprc": 0.03498572135809531, + "brier": 0.009587585468006414, + "calibration": { + "observed_rate": 0.009789156626506024, + "mean_prediction": 0.008908400973657728, + "calibration_in_the_large": -0.0008807556528482967, + "expected_calibration_error_10bin": 0.00104366410118106, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + "G99": { + "valid": 2841, + "positives": 0, + "negatives": 2841, + "auroc": null, + "auprc": null, + "brier": 3.663634531861243e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0002335644414178045, + "calibration_in_the_large": 0.0002335644414178045, + "expected_calibration_error_10bin": 0.0002335644414178045, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9992965177629265 + }, + "H10": { + "valid": 2832, + "positives": 3, + "negatives": 2829, + "auroc": 0.9214092140921409, + "auprc": 0.020264279127452125, + "brier": 0.001055349664472037, + "calibration": { + "observed_rate": 0.001059322033898305, + "mean_prediction": 0.0004743514444365986, + "calibration_in_the_large": -0.0005849705894617064, + "expected_calibration_error_10bin": 0.0005849705894617064, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "H26": { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 2.063383800127631e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0007830347154113064, + "calibration_in_the_large": 0.0007830347154113064, + "expected_calibration_error_10bin": 0.0007830347154113064, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "H35": { + "valid": 2806, + "positives": 4, + "negatives": 2802, + "auroc": 0.6586366880799429, + "auprc": 0.003822649122629984, + "brier": 0.0014250474356757607, + "calibration": { + "observed_rate": 0.0014255167498218105, + "mean_prediction": 0.00043146555865345424, + "calibration_in_the_large": -0.0009940511911683562, + "expected_calibration_error_10bin": 0.0009940511911683562, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "H40": { + "valid": 2750, + "positives": 5, + "negatives": 2745, + "auroc": 0.7643715846994535, + "auprc": 0.01328370901053374, + "brier": 0.0018199432997654268, + "calibration": { + "observed_rate": 0.0018181818181818182, + "mean_prediction": 0.0023787783924966457, + "calibration_in_the_large": 0.0005605965743148275, + "expected_calibration_error_10bin": 0.0005605965743148275, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "H53": { + "valid": 2790, + "positives": 7, + "negatives": 2783, + "auroc": 0.6506852830963503, + "auprc": 0.012668230961322855, + "brier": 0.0025002432384965113, + "calibration": { + "observed_rate": 0.0025089605734767025, + "mean_prediction": 0.002577637066780072, + "calibration_in_the_large": 6.867649330336966e-05, + "expected_calibration_error_10bin": 6.867649330336966e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "H54": { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.4178838617741361, + "auprc": 0.0008938907868131591, + "brier": 0.000719156630976581, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0014684850960990357, + "calibration_in_the_large": 0.0007564879440876437, + "expected_calibration_error_10bin": 0.0007564879440876437, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "H91": { + "valid": 2791, + "positives": 5, + "negatives": 2786, + "auroc": 0.7376884422110552, + "auprc": 0.007347911583322176, + "brier": 0.0017864402257653355, + "calibration": { + "observed_rate": 0.0017914725904693658, + "mean_prediction": 0.0015613176076705736, + "calibration_in_the_large": -0.0002301549827987922, + "expected_calibration_error_10bin": 0.0002301549827987922, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + "I07": { + "valid": 2823, + "positives": 2, + "negatives": 2821, + "auroc": 0.8566111308046792, + "auprc": 0.0038430006148800983, + "brier": 0.0007109179702082878, + "calibration": { + "observed_rate": 0.0007084661707403471, + "mean_prediction": 0.0004980391821325694, + "calibration_in_the_large": -0.00021042698860777777, + "expected_calibration_error_10bin": 0.00021042698860777777, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "I08": { + "valid": 2767, + "positives": 5, + "negatives": 2762, + "auroc": 0.8640839971035481, + "auprc": 0.008064686825399996, + "brier": 0.001937585341133701, + "calibration": { + "observed_rate": 0.0018070112034694614, + "mean_prediction": 0.004058139441917553, + "calibration_in_the_large": 0.002251128238448091, + "expected_calibration_error_10bin": 0.0022511282384480905, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + "I10": { + "valid": 1498, + "positives": 24, + "negatives": 1474, + "auroc": 0.6571687019448214, + "auprc": 0.04669732838715448, + "brier": 0.015655223652629915, + "calibration": { + "observed_rate": 0.01602136181575434, + "mean_prediction": 0.011173576176828967, + "calibration_in_the_large": -0.004847785638925373, + "expected_calibration_error_10bin": 0.006455592939840598, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + "I11": { + "valid": 2676, + "positives": 22, + "negatives": 2654, + "auroc": 0.8385798451736658, + "auprc": 0.03141619292907201, + "brier": 0.008135844979783011, + "calibration": { + "observed_rate": 0.008221225710014948, + "mean_prediction": 0.006376483280450103, + "calibration_in_the_large": -0.0018447424295648454, + "expected_calibration_error_10bin": 0.0021200351125511127, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + "I12": { + "valid": 2552, + "positives": 11, + "negatives": 2541, + "auroc": 0.8351400665450253, + "auprc": 0.03224784275869246, + "brier": 0.004290844733131521, + "calibration": { + "observed_rate": 0.004310344827586207, + "mean_prediction": 0.003454862139485406, + "calibration_in_the_large": -0.000855482688100801, + "expected_calibration_error_10bin": 0.001341636750628275, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + "I13": { + "valid": 2727, + "positives": 11, + "negatives": 2716, + "auroc": 0.8772258669165885, + "auprc": 0.048652927953894975, + "brier": 0.004017550046712887, + "calibration": { + "observed_rate": 0.004033736707004034, + "mean_prediction": 0.0056849794681377, + "calibration_in_the_large": 0.0016512427611336663, + "expected_calibration_error_10bin": 0.0016512427611336668, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + "I16": { + "valid": 2390, + "positives": 4, + "negatives": 2386, + "auroc": 0.9255029337803856, + "auprc": 0.025252007753769557, + "brier": 0.0016604340876432634, + "calibration": { + "observed_rate": 0.0016736401673640166, + "mean_prediction": 0.001104604264618802, + "calibration_in_the_large": -0.0005690359027452146, + "expected_calibration_error_10bin": 0.0005690359027452146, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + "I21": { + "valid": 2671, + "positives": 8, + "negatives": 2663, + "auroc": 0.8910063837776944, + "auprc": 0.03171787843929604, + "brier": 0.0030220356733604496, + "calibration": { + "observed_rate": 0.002995132909022838, + "mean_prediction": 0.006567004809474405, + "calibration_in_the_large": 0.0035718719004515665, + "expected_calibration_error_10bin": 0.0035791172176925165, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "I24": { + "valid": 2809, + "positives": 3, + "negatives": 2806, + "auroc": 0.9390591589451176, + "auprc": 0.017580567580567582, + "brier": 0.0010616714049727746, + "calibration": { + "observed_rate": 0.001067995728017088, + "mean_prediction": 0.00095366647639906, + "calibration_in_the_large": -0.00011432925161802799, + "expected_calibration_error_10bin": 0.00011432925161802799, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "I25": { + "valid": 2243, + "positives": 24, + "negatives": 2219, + "auroc": 0.8314556106354214, + "auprc": 0.05060922240200046, + "brier": 0.010402648282947699, + "calibration": { + "observed_rate": 0.01069995541685243, + "mean_prediction": 0.008813060011851821, + "calibration_in_the_large": -0.001886895405000609, + "expected_calibration_error_10bin": 0.001886895405000609, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + "I26": { + "valid": 2760, + "positives": 11, + "negatives": 2749, + "auroc": 0.7865008763517312, + "auprc": 0.04426607403263464, + "brier": 0.003908257677899776, + "calibration": { + "observed_rate": 0.003985507246376811, + "mean_prediction": 0.0038098159742968045, + "calibration_in_the_large": -0.00017569127208000692, + "expected_calibration_error_10bin": 0.00017569127208000692, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + "I27": { + "valid": 2716, + "positives": 15, + "negatives": 2701, + "auroc": 0.8222139948167345, + "auprc": 0.02129534946712478, + "brier": 0.005522062320015331, + "calibration": { + "observed_rate": 0.005522827687776142, + "mean_prediction": 0.005183296608336656, + "calibration_in_the_large": -0.0003395310794394859, + "expected_calibration_error_10bin": 0.0007911867730221384, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I31": { + "valid": 2793, + "positives": 9, + "negatives": 2784, + "auroc": 0.8753192848020435, + "auprc": 0.052167584214911626, + "brier": 0.003181242482718533, + "calibration": { + "observed_rate": 0.00322234156820623, + "mean_prediction": 0.002223345971820012, + "calibration_in_the_large": -0.000998995596386218, + "expected_calibration_error_10bin": 0.000998995596386218, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I34": { + "valid": 2753, + "positives": 10, + "negatives": 2743, + "auroc": 0.7424352898286548, + "auprc": 0.009400584227895832, + "brier": 0.003642590554086001, + "calibration": { + "observed_rate": 0.003632401017072285, + "mean_prediction": 0.0022935693400641674, + "calibration_in_the_large": -0.0013388316770081175, + "expected_calibration_error_10bin": 0.0014204805897774114, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + "I35": { + "valid": 2723, + "positives": 5, + "negatives": 2718, + "auroc": 0.7280353200883002, + "auprc": 0.008618913192552438, + "brier": 0.00185986776061973, + "calibration": { + "observed_rate": 0.001836210062431142, + "mean_prediction": 0.0025162238400208005, + "calibration_in_the_large": 0.0006800137775896584, + "expected_calibration_error_10bin": 0.0006800137775896584, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "I42": { + "valid": 2740, + "positives": 4, + "negatives": 2736, + "auroc": 0.9182200292397661, + "auprc": 0.07048289063092092, + "brier": 0.0014409328498328961, + "calibration": { + "observed_rate": 0.00145985401459854, + "mean_prediction": 0.0025011505719537597, + "calibration_in_the_large": 0.0010412965573552196, + "expected_calibration_error_10bin": 0.0010412965573552196, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "I44": { + "valid": 2722, + "positives": 10, + "negatives": 2712, + "auroc": 0.8792035398230088, + "auprc": 0.07301591466554402, + "brier": 0.00356498776381805, + "calibration": { + "observed_rate": 0.0036737692872887582, + "mean_prediction": 0.005071379765234789, + "calibration_in_the_large": 0.0013976104779460305, + "expected_calibration_error_10bin": 0.0013976104779460303, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + "I45": { + "valid": 2766, + "positives": 7, + "negatives": 2759, + "auroc": 0.7460777714492829, + "auprc": 0.15822429388493467, + "brier": 0.002512070783267869, + "calibration": { + "observed_rate": 0.0025307302964569776, + "mean_prediction": 0.0041400884501005975, + "calibration_in_the_large": 0.00160935815364362, + "expected_calibration_error_10bin": 0.00160935815364362, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + "I46": { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.496113074204947, + "auprc": 0.000700770847932726, + "brier": 0.0003590597275026914, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0012570495035397818, + "calibration_in_the_large": 0.0009038174300675106, + "expected_calibration_error_10bin": 0.0009038174300675106, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I47": { + "valid": 2716, + "positives": 7, + "negatives": 2709, + "auroc": 0.6839107736117703, + "auprc": 0.006207822188155553, + "brier": 0.002592249076428243, + "calibration": { + "observed_rate": 0.002577319587628866, + "mean_prediction": 0.004544449258571788, + "calibration_in_the_large": 0.001967129670942922, + "expected_calibration_error_10bin": 0.001967129670942922, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I48": { + "valid": 2385, + "positives": 15, + "negatives": 2370, + "auroc": 0.7971870604781998, + "auprc": 0.020068143173952516, + "brier": 0.006244805920748971, + "calibration": { + "observed_rate": 0.006289308176100629, + "mean_prediction": 0.0058628701315023716, + "calibration_in_the_large": -0.0004264380445982577, + "expected_calibration_error_10bin": 0.0005664459688321001, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + "I49": { + "valid": 2734, + "positives": 6, + "negatives": 2728, + "auroc": 0.8004032258064516, + "auprc": 0.010080398108154254, + "brier": 0.002184297987376007, + "calibration": { + "observed_rate": 0.0021945866861741038, + "mean_prediction": 0.0021658682581038135, + "calibration_in_the_large": -2.8718428070290212e-05, + "expected_calibration_error_10bin": 2.8718428070290212e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I50": { + "valid": 2415, + "positives": 25, + "negatives": 2390, + "auroc": 0.8371213389121339, + "auprc": 0.049783339543293906, + "brier": 0.010265563066295329, + "calibration": { + "observed_rate": 0.010351966873706004, + "mean_prediction": 0.010199243543707482, + "calibration_in_the_large": -0.000152723329998522, + "expected_calibration_error_10bin": 0.0027744515303482695, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + "I51": { + "valid": 2807, + "positives": 5, + "negatives": 2802, + "auroc": 0.8553176302640971, + "auprc": 0.008486872049025079, + "brier": 0.0017749666441074796, + "calibration": { + "observed_rate": 0.0017812611328820805, + "mean_prediction": 0.0012657378071083067, + "calibration_in_the_large": -0.0005155233257737738, + "expected_calibration_error_10bin": 0.0005155233257737738, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "I61": { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.7949428162973553, + "auprc": 0.005576811420412093, + "brier": 0.001425657026994077, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.0005023815933431761, + "calibration_in_the_large": -0.0009251701554077161, + "expected_calibration_error_10bin": 0.0009251701554077161, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "I63": { + "valid": 2735, + "positives": 8, + "negatives": 2727, + "auroc": 0.8472222222222222, + "auprc": 0.021578478367237947, + "brier": 0.00291426069143416, + "calibration": { + "observed_rate": 0.0029250457038391227, + "mean_prediction": 0.002753018578397536, + "calibration_in_the_large": -0.00017202712544158675, + "expected_calibration_error_10bin": 0.00035175045556971364, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + "I65": { + "valid": 2774, + "positives": 2, + "negatives": 2772, + "auroc": 0.6165223665223665, + "auprc": 0.001368830272312751, + "brier": 0.0007247125705687501, + "calibration": { + "observed_rate": 0.0007209805335255948, + "mean_prediction": 0.0013050807804633375, + "calibration_in_the_large": 0.0005841002469377428, + "expected_calibration_error_10bin": 0.0005841002469377428, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "I67": { + "valid": 2773, + "positives": 2, + "negatives": 2771, + "auroc": 0.8702634428004331, + "auprc": 0.004185932464620989, + "brier": 0.0007275118501637599, + "calibration": { + "observed_rate": 0.000721240533717995, + "mean_prediction": 0.0014841124780172255, + "calibration_in_the_large": 0.0007628719442992305, + "expected_calibration_error_10bin": 0.0007628719442992305, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "I69": { + "valid": 2752, + "positives": 12, + "negatives": 2740, + "auroc": 0.7702250608272506, + "auprc": 0.0169679465883848, + "brier": 0.004348267673119302, + "calibration": { + "observed_rate": 0.00436046511627907, + "mean_prediction": 0.004459142059859851, + "calibration_in_the_large": 9.867694358078102e-05, + "expected_calibration_error_10bin": 9.867694358078102e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + "I70": { + "valid": 2771, + "positives": 5, + "negatives": 2766, + "auroc": 0.83470715835141, + "auprc": 0.017642714802032076, + "brier": 0.001792704673137112, + "calibration": { + "observed_rate": 0.001804402742692169, + "mean_prediction": 0.0014310709930335657, + "calibration_in_the_large": -0.0003733317496586032, + "expected_calibration_error_10bin": 0.0003733317496586032, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + "I71": { + "valid": 2769, + "positives": 3, + "negatives": 2766, + "auroc": 0.6751024343215233, + "auprc": 0.0040457681090019975, + "brier": 0.0010853614639309355, + "calibration": { + "observed_rate": 0.0010834236186348862, + "mean_prediction": 0.001329415102839679, + "calibration_in_the_large": 0.0002459914842047929, + "expected_calibration_error_10bin": 0.0002459914842047929, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + "I72": { + "valid": 2818, + "positives": 3, + "negatives": 2815, + "auroc": 0.6859680284191829, + "auprc": 0.005326856840318777, + "brier": 0.001064690860830933, + "calibration": { + "observed_rate": 0.0010645848119233499, + "mean_prediction": 0.0008264337107697063, + "calibration_in_the_large": -0.00023815110115364354, + "expected_calibration_error_10bin": 0.00023815110115364354, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "I73": { + "valid": 2734, + "positives": 3, + "negatives": 2731, + "auroc": 0.6620285609666788, + "auprc": 0.003240933280962393, + "brier": 0.0011092655166921284, + "calibration": { + "observed_rate": 0.0010972933430870519, + "mean_prediction": 0.0013467619526951915, + "calibration_in_the_large": 0.00024946860960813966, + "expected_calibration_error_10bin": 0.00024946860960813966, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I74": { + "valid": 2821, + "positives": 4, + "negatives": 2817, + "auroc": 0.5484558040468583, + "auprc": 0.003036785542057107, + "brier": 0.0014171595985770758, + "calibration": { + "observed_rate": 0.0014179369018078695, + "mean_prediction": 0.0005052152712941936, + "calibration_in_the_large": -0.0009127216305136759, + "expected_calibration_error_10bin": 0.0009127216305136759, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "I77": { + "valid": 2785, + "positives": 3, + "negatives": 2782, + "auroc": 0.6519290678169183, + "auprc": 0.003919883999883148, + "brier": 0.0010775415278532193, + "calibration": { + "observed_rate": 0.0010771992818671453, + "mean_prediction": 0.0011434769765430535, + "calibration_in_the_large": 6.627769467590816e-05, + "expected_calibration_error_10bin": 6.627769467590816e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "I80": { + "valid": 2827, + "positives": 2, + "negatives": 2825, + "auroc": 0.8207079646017699, + "auprc": 0.0034782121653411, + "brier": 0.0007110644105469841, + "calibration": { + "observed_rate": 0.0007074637424831977, + "mean_prediction": 0.0006057843863069269, + "calibration_in_the_large": -0.0001016793561762708, + "expected_calibration_error_10bin": 0.0001016793561762708, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "I81": { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.833888691953208, + "auprc": 0.014251118610517921, + "brier": 0.001793993212687795, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0012608882598699488, + "calibration_in_the_large": -0.0005083969489057057, + "expected_calibration_error_10bin": 0.0007984459634831464, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I82": { + "valid": 2739, + "positives": 18, + "negatives": 2721, + "auroc": 0.695353015639675, + "auprc": 0.0238204625209752, + "brier": 0.006522003310911197, + "calibration": { + "observed_rate": 0.0065717415115005475, + "mean_prediction": 0.0058996893355771265, + "calibration_in_the_large": -0.000672052175923421, + "expected_calibration_error_10bin": 0.0011018168977774787, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "I85": { + "valid": 2793, + "positives": 4, + "negatives": 2789, + "auroc": 0.9932771602724991, + "auprc": 0.16414141414141414, + "brier": 0.0013881438599294268, + "calibration": { + "observed_rate": 0.0014321518080916578, + "mean_prediction": 0.0011138465249485004, + "calibration_in_the_large": -0.0003183052831431574, + "expected_calibration_error_10bin": 0.0010147246082331499, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I87": { + "valid": 2780, + "positives": 10, + "negatives": 2770, + "auroc": 0.7163898916967509, + "auprc": 0.010021574499978711, + "brier": 0.003585023346032475, + "calibration": { + "observed_rate": 0.0035971223021582736, + "mean_prediction": 0.002606444574318872, + "calibration_in_the_large": -0.0009906777278394017, + "expected_calibration_error_10bin": 0.0009906777278394017, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "I89": { + "valid": 2826, + "positives": 4, + "negatives": 2822, + "auroc": 0.8247696669029058, + "auprc": 0.007681802502971984, + "brier": 0.0014132715892377892, + "calibration": { + "observed_rate": 0.0014154281670205238, + "mean_prediction": 0.0003565868217499205, + "calibration_in_the_large": -0.0010588413452706034, + "expected_calibration_error_10bin": 0.0010588413452706034, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I95": { + "valid": 2485, + "positives": 41, + "negatives": 2444, + "auroc": 0.707037643207856, + "auprc": 0.033058786426090586, + "brier": 0.01623301974174861, + "calibration": { + "observed_rate": 0.016498993963782696, + "mean_prediction": 0.019215517329455915, + "calibration_in_the_large": 0.0027165233656732193, + "expected_calibration_error_10bin": 0.002716523365673219, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + "I96": { + "valid": 2831, + "positives": 3, + "negatives": 2828, + "auroc": 0.9744224422442245, + "auprc": 0.06428070577123968, + "brier": 0.0010462126627224634, + "calibration": { + "observed_rate": 0.0010596962204168139, + "mean_prediction": 0.0009189413998881347, + "calibration_in_the_large": -0.00014075482052867917, + "expected_calibration_error_10bin": 0.00014075482052867917, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I97": { + "valid": 2740, + "positives": 7, + "negatives": 2733, + "auroc": 0.8037739794051539, + "auprc": 0.012587306537037737, + "brier": 0.002542379885228703, + "calibration": { + "observed_rate": 0.0025547445255474453, + "mean_prediction": 0.001808572855926107, + "calibration_in_the_large": -0.0007461716696213383, + "expected_calibration_error_10bin": 0.0007461716696213383, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "J02": { + "valid": 2825, + "positives": 1, + "negatives": 2824, + "auroc": 0.5630311614730878, + "auprc": 0.0008097165991902834, + "brier": 0.0003572162565671642, + "calibration": { + "observed_rate": 0.00035398230088495576, + "mean_prediction": 0.0009165675456370886, + "calibration_in_the_large": 0.0005625852447521328, + "expected_calibration_error_10bin": 0.0005625852447521328, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J06": { + "valid": 2816, + "positives": 3, + "negatives": 2813, + "auroc": 0.6326578978551961, + "auprc": 0.0021174580456835203, + "brier": 0.0010922272760215852, + "calibration": { + "observed_rate": 0.001065340909090909, + "mean_prediction": 0.0016709426129582735, + "calibration_in_the_large": 0.0006056017038673644, + "expected_calibration_error_10bin": 0.0006056017038673643, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "J12": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 1.898950797897923e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001475394029935647, + "calibration_in_the_large": 0.001475394029935647, + "expected_calibration_error_10bin": 0.001475394029935647, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J15": { + "valid": 2795, + "positives": 7, + "negatives": 2788, + "auroc": 0.7661406025824964, + "auprc": 0.01146083681544636, + "brier": 0.002535407881552367, + "calibration": { + "observed_rate": 0.0025044722719141325, + "mean_prediction": 0.0034763014071131286, + "calibration_in_the_large": 0.0009718291351989961, + "expected_calibration_error_10bin": 0.0009718291351989964, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + "J18": { + "valid": 2671, + "positives": 22, + "negatives": 2649, + "auroc": 0.7979340402896462, + "auprc": 0.035627274684151736, + "brier": 0.008218370285433534, + "calibration": { + "observed_rate": 0.008236615499812805, + "mean_prediction": 0.010900019349556752, + "calibration_in_the_large": 0.002663403849743947, + "expected_calibration_error_10bin": 0.002663403849743948, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "J30": { + "valid": 2815, + "positives": 3, + "negatives": 2812, + "auroc": 0.809506875296349, + "auprc": 0.08549916672137398, + "brier": 0.0010479080253278906, + "calibration": { + "observed_rate": 0.0010657193605683837, + "mean_prediction": 0.0016985932108398187, + "calibration_in_the_large": 0.000632873850271435, + "expected_calibration_error_10bin": 0.000632873850271435, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "J32": { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.9218528995756718, + "auprc": 0.0045045045045045045, + "brier": 0.00035863280536683963, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.0006272841662946056, + "calibration_in_the_large": 0.00027380237060708345, + "expected_calibration_error_10bin": 0.00027380237060708345, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J38": { + "valid": 2825, + "positives": 1, + "negatives": 2824, + "auroc": 0.4978753541076487, + "auprc": 0.0007047216349541931, + "brier": 0.0003567566059205275, + "calibration": { + "observed_rate": 0.00035398230088495576, + "mean_prediction": 0.0008421821820751076, + "calibration_in_the_large": 0.00048819988119015186, + "expected_calibration_error_10bin": 0.00048819988119015186, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J43": { + "valid": 2804, + "positives": 4, + "negatives": 2800, + "auroc": 0.5120535714285714, + "auprc": 0.0019785175529342643, + "brier": 0.0014297717827533778, + "calibration": { + "observed_rate": 0.0014265335235378032, + "mean_prediction": 0.0009202420085417808, + "calibration_in_the_large": -0.0005062915149960224, + "expected_calibration_error_10bin": 0.0005062915149960224, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "J44": { + "valid": 2570, + "positives": 14, + "negatives": 2556, + "auroc": 0.8163145539906104, + "auprc": 0.029621561625791097, + "brier": 0.005379400562306925, + "calibration": { + "observed_rate": 0.005447470817120622, + "mean_prediction": 0.003694948200993684, + "calibration_in_the_large": -0.0017525226161269384, + "expected_calibration_error_10bin": 0.0017525226161269384, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + "J45": { + "valid": 2518, + "positives": 17, + "negatives": 2501, + "auroc": 0.6828092292494767, + "auprc": 0.012861255876031612, + "brier": 0.006714573983382315, + "calibration": { + "observed_rate": 0.006751389992057188, + "mean_prediction": 0.004146687910905754, + "calibration_in_the_large": -0.002604702081151434, + "expected_calibration_error_10bin": 0.002604702081151434, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + "J47": { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.9114417286574567, + "auprc": 0.005799135372306104, + "brier": 0.000707484243319017, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.000404832402819695, + "calibration_in_the_large": -0.0003031321989502165, + "expected_calibration_error_10bin": 0.0003031321989502165, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J69": { + "valid": 2777, + "positives": 19, + "negatives": 2758, + "auroc": 0.7806190603412083, + "auprc": 0.03446358494092872, + "brier": 0.006746988855930392, + "calibration": { + "observed_rate": 0.0068419157364061935, + "mean_prediction": 0.005885203005039477, + "calibration_in_the_large": -0.0009567127313667165, + "expected_calibration_error_10bin": 0.001231551733816623, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "J81": { + "valid": 2781, + "positives": 11, + "negatives": 2770, + "auroc": 0.7482441745979652, + "auprc": 0.022011449449897427, + "brier": 0.003924501199894256, + "calibration": { + "observed_rate": 0.003955411722402014, + "mean_prediction": 0.0018028007267473357, + "calibration_in_the_large": -0.002152610995654678, + "expected_calibration_error_10bin": 0.002152610995654678, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "J84": { + "valid": 2817, + "positives": 5, + "negatives": 2812, + "auroc": 0.9519203413940256, + "auprc": 0.04195687017738805, + "brier": 0.001763835077110327, + "calibration": { + "observed_rate": 0.001774937877174299, + "mean_prediction": 0.0006532706453177921, + "calibration_in_the_large": -0.0011216672318565069, + "expected_calibration_error_10bin": 0.0011216672318565069, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "J90": { + "valid": 2754, + "positives": 20, + "negatives": 2734, + "auroc": 0.6648134601316752, + "auprc": 0.013498277073773494, + "brier": 0.007258392380559504, + "calibration": { + "observed_rate": 0.007262164124909223, + "mean_prediction": 0.0061338846923811065, + "calibration_in_the_large": -0.0011282794325281169, + "expected_calibration_error_10bin": 0.0012938415975539948, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + "J91": { + "valid": 2807, + "positives": 5, + "negatives": 2802, + "auroc": 0.7919343326195575, + "auprc": 0.014620378439359852, + "brier": 0.0018070451788437978, + "calibration": { + "observed_rate": 0.0017812611328820805, + "mean_prediction": 0.0021177275622410044, + "calibration_in_the_large": 0.00033646642935892396, + "expected_calibration_error_10bin": 0.00033646642935892396, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "J94": { + "valid": 2829, + "positives": 5, + "negatives": 2824, + "auroc": 0.6229461756373937, + "auprc": 0.005374572585098901, + "brier": 0.0017687020669474884, + "calibration": { + "observed_rate": 0.0017674089784376105, + "mean_prediction": 0.0006723376709240091, + "calibration_in_the_large": -0.0010950713075136014, + "expected_calibration_error_10bin": 0.0010950713075136014, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J95": { + "valid": 2770, + "positives": 11, + "negatives": 2759, + "auroc": 0.8045734620580579, + "auprc": 0.027085370462709243, + "brier": 0.003927838433476303, + "calibration": { + "observed_rate": 0.003971119133574007, + "mean_prediction": 0.002723783270155087, + "calibration_in_the_large": -0.0012473358634189202, + "expected_calibration_error_10bin": 0.0012473358634189202, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + "J96": { + "valid": 2605, + "positives": 36, + "negatives": 2569, + "auroc": 0.842718740538904, + "auprc": 0.06048964892301082, + "brier": 0.01341505432649741, + "calibration": { + "observed_rate": 0.01381957773512476, + "mean_prediction": 0.013617421488949963, + "calibration_in_the_large": -0.00020215624617479604, + "expected_calibration_error_10bin": 0.002549847537528093, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + "J98": { + "valid": 2692, + "positives": 16, + "negatives": 2676, + "auroc": 0.7404007847533632, + "auprc": 0.0350235346299887, + "brier": 0.005882260948752032, + "calibration": { + "observed_rate": 0.005943536404160475, + "mean_prediction": 0.005928350381528437, + "calibration_in_the_large": -1.5186022632038103e-05, + "expected_calibration_error_10bin": 1.5186022632038103e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + "K04": { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 4.1649769807934234e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0002960087323704031, + "calibration_in_the_large": 0.0002960087323704031, + "expected_calibration_error_10bin": 0.0002960087323704031, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "K12": { + "valid": 2824, + "positives": 5, + "negatives": 2819, + "auroc": 0.812273855977297, + "auprc": 0.06676756868066205, + "brier": 0.0018370774947265673, + "calibration": { + "observed_rate": 0.0017705382436260624, + "mean_prediction": 0.002340649365050252, + "calibration_in_the_large": 0.0005701111214241896, + "expected_calibration_error_10bin": 0.0011003149265554138, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K20": { + "valid": 2813, + "positives": 4, + "negatives": 2809, + "auroc": 0.6218405126379495, + "auprc": 0.04336019938801849, + "brier": 0.0014385937625744376, + "calibration": { + "observed_rate": 0.0014219694276573053, + "mean_prediction": 0.0033005222097693453, + "calibration_in_the_large": 0.00187855278211204, + "expected_calibration_error_10bin": 0.00187855278211204, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K21": { + "valid": 2043, + "positives": 44, + "negatives": 1999, + "auroc": 0.7896561917322298, + "auprc": 0.09508610810461518, + "brier": 0.020368595504455363, + "calibration": { + "observed_rate": 0.021536955457660302, + "mean_prediction": 0.0226193384331894, + "calibration_in_the_large": 0.0010823829755290983, + "expected_calibration_error_10bin": 0.0022458544237346804, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + "K22": { + "valid": 2764, + "positives": 8, + "negatives": 2756, + "auroc": 0.8105043541364296, + "auprc": 0.02653839438286812, + "brier": 0.0028644428645763446, + "calibration": { + "observed_rate": 0.002894356005788712, + "mean_prediction": 0.0026733113151582266, + "calibration_in_the_large": -0.0002210446906304852, + "expected_calibration_error_10bin": 0.0002210446906304852, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + "K25": { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.9366263918502724, + "auprc": 0.010610947659002579, + "brier": 0.0010694971811733716, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.0017414585869988497, + "calibration_in_the_large": 0.0006764958606942702, + "expected_calibration_error_10bin": 0.0006764958606942702, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "K26": { + "valid": 2814, + "positives": 3, + "negatives": 2811, + "auroc": 0.8910233606071386, + "auprc": 0.011381465745190758, + "brier": 0.0010623328908008938, + "calibration": { + "observed_rate": 0.0010660980810234541, + "mean_prediction": 0.0011256204177771928, + "calibration_in_the_large": 5.9522336753738614e-05, + "expected_calibration_error_10bin": 5.9522336753738614e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "K29": { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.8869111830276879, + "auprc": 0.02650644180704915, + "brier": 0.0014460302983158532, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.004937586931263463, + "calibration_in_the_large": 0.003501321222107269, + "expected_calibration_error_10bin": 0.003501321222107269, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K30": { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.9324514991181658, + "auprc": 0.00754994043166265, + "brier": 0.0007051743072273349, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0007900428245436968, + "calibration_in_the_large": 8.507278577034468e-05, + "expected_calibration_error_10bin": 8.507278577034468e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "K31": { + "valid": 2756, + "positives": 7, + "negatives": 2749, + "auroc": 0.934521644234267, + "auprc": 0.06233819927598507, + "brier": 0.002465195995479605, + "calibration": { + "observed_rate": 0.0025399129172714078, + "mean_prediction": 0.0031584007997183506, + "calibration_in_the_large": 0.0006184878824469428, + "expected_calibration_error_10bin": 0.0006184878824469425, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "K40": { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 1.2205328875769027e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0007289577471919131, + "calibration_in_the_large": 0.0007289577471919131, + "expected_calibration_error_10bin": 0.0007289577471919131, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "K42": { + "valid": 2820, + "positives": 3, + "negatives": 2817, + "auroc": 0.6924624304815998, + "auprc": 0.006018801157690046, + "brier": 0.0010647138189448567, + "calibration": { + "observed_rate": 0.0010638297872340426, + "mean_prediction": 0.0005863534538696622, + "calibration_in_the_large": -0.0004774763333643804, + "expected_calibration_error_10bin": 0.0004774763333643804, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "K43": { + "valid": 2813, + "positives": 2, + "negatives": 2811, + "auroc": 0.9308075418000712, + "auprc": 0.007530163035800062, + "brier": 0.0007101464966825509, + "calibration": { + "observed_rate": 0.0007109847138286527, + "mean_prediction": 0.0006486711643717346, + "calibration_in_the_large": -6.231354945691805e-05, + "expected_calibration_error_10bin": 6.231354945691805e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K44": { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.5469255663430421, + "auprc": 0.002431724236963865, + "brier": 0.0014381210092505319, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.0015261316732108456, + "calibration_in_the_large": 8.98659640546516e-05, + "expected_calibration_error_10bin": 8.98659640546516e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K52": { + "valid": 2749, + "positives": 17, + "negatives": 2732, + "auroc": 0.8300964602532082, + "auprc": 0.10502195123862984, + "brier": 0.006033268430856109, + "calibration": { + "observed_rate": 0.0061840669334303384, + "mean_prediction": 0.006103209135097061, + "calibration_in_the_large": -8.085779833327724e-05, + "expected_calibration_error_10bin": 0.001518803261158924, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + "K55": { + "valid": 2815, + "positives": 6, + "negatives": 2809, + "auroc": 0.7864008543965824, + "auprc": 0.008215198989473857, + "brier": 0.0021343205534114697, + "calibration": { + "observed_rate": 0.0021314387211367673, + "mean_prediction": 0.0015032544066338842, + "calibration_in_the_large": -0.0006281843145028831, + "expected_calibration_error_10bin": 0.0006281843145028831, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "K56": { + "valid": 2745, + "positives": 15, + "negatives": 2730, + "auroc": 0.7506471306471306, + "auprc": 0.028006046590561117, + "brier": 0.005391834777907758, + "calibration": { + "observed_rate": 0.00546448087431694, + "mean_prediction": 0.005993409300344286, + "calibration_in_the_large": 0.0005289284260273459, + "expected_calibration_error_10bin": 0.0005289284260273459, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + "K57": { + "valid": 2741, + "positives": 10, + "negatives": 2731, + "auroc": 0.6845477846942511, + "auprc": 0.0070905514112245965, + "brier": 0.003647781686924249, + "calibration": { + "observed_rate": 0.0036483035388544327, + "mean_prediction": 0.002467992241929049, + "calibration_in_the_large": -0.0011803112969253839, + "expected_calibration_error_10bin": 0.0011803112969253839, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "K58": { + "valid": 2792, + "positives": 5, + "negatives": 2787, + "auroc": 0.6805166846071045, + "auprc": 0.01229950865908061, + "brier": 0.0017857959557282534, + "calibration": { + "observed_rate": 0.0017908309455587394, + "mean_prediction": 0.0009529751689328766, + "calibration_in_the_large": -0.0008378557766258628, + "expected_calibration_error_10bin": 0.0008378557766258628, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "K59": { + "valid": 2560, + "positives": 52, + "negatives": 2508, + "auroc": 0.7413967611336032, + "auprc": 0.0911122010379918, + "brier": 0.0193439414482164, + "calibration": { + "observed_rate": 0.0203125, + "mean_prediction": 0.01670969176173003, + "calibration_in_the_large": -0.003602808238269972, + "expected_calibration_error_10bin": 0.0039902213511823015, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "K62": { + "valid": 2813, + "positives": 5, + "negatives": 2808, + "auroc": 0.871937321937322, + "auprc": 0.011325538204341212, + "brier": 0.0017686601001256, + "calibration": { + "observed_rate": 0.0017774617845716318, + "mean_prediction": 0.0017120798744982891, + "calibration_in_the_large": -6.538191007334263e-05, + "expected_calibration_error_10bin": 6.538191007334263e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K63": { + "valid": 2810, + "positives": 10, + "negatives": 2800, + "auroc": 0.7238214285714286, + "auprc": 0.00969666046010515, + "brier": 0.0035469943124109915, + "calibration": { + "observed_rate": 0.0035587188612099642, + "mean_prediction": 0.002074810756194404, + "calibration_in_the_large": -0.0014839081050155604, + "expected_calibration_error_10bin": 0.0014839081050155604, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "K64": { + "valid": 2801, + "positives": 9, + "negatives": 2792, + "auroc": 0.8218322190385228, + "auprc": 0.01224161640122436, + "brier": 0.0032571481995373984, + "calibration": { + "observed_rate": 0.0032131381649410924, + "mean_prediction": 0.00318207328116027, + "calibration_in_the_large": -3.1064883780822315e-05, + "expected_calibration_error_10bin": 0.0002915865026436483, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "K65": { + "valid": 2813, + "positives": 9, + "negatives": 2804, + "auroc": 0.8588128071009669, + "auprc": 0.02776585504065347, + "brier": 0.0032436955484661015, + "calibration": { + "observed_rate": 0.003199431212228937, + "mean_prediction": 0.005068938714876116, + "calibration_in_the_large": 0.001869507502647179, + "expected_calibration_error_10bin": 0.0018695075026471785, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K66": { + "valid": 2796, + "positives": 4, + "negatives": 2792, + "auroc": 0.9058918338108882, + "auprc": 0.03423235033334283, + "brier": 0.0014202247744516693, + "calibration": { + "observed_rate": 0.001430615164520744, + "mean_prediction": 0.002018822694134957, + "calibration_in_the_large": 0.000588207529614213, + "expected_calibration_error_10bin": 0.000588207529614213, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "K70": { + "valid": 2774, + "positives": 1, + "negatives": 2773, + "auroc": 0.9509556437071763, + "auprc": 0.0072992700729927005, + "brier": 0.0003662815704525454, + "calibration": { + "observed_rate": 0.0003604902667627974, + "mean_prediction": 0.0005497198832050716, + "calibration_in_the_large": 0.00018922961644227425, + "expected_calibration_error_10bin": 0.00018922961644227425, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "K72": { + "valid": 2787, + "positives": 10, + "negatives": 2777, + "auroc": 0.9348577601728484, + "auprc": 0.26432500046272117, + "brier": 0.0031803151608312172, + "calibration": { + "observed_rate": 0.003588087549336204, + "mean_prediction": 0.002095378568430848, + "calibration_in_the_large": -0.0014927089809053558, + "expected_calibration_error_10bin": 0.0014927089809053558, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "K74": { + "valid": 2763, + "positives": 5, + "negatives": 2758, + "auroc": 0.9562726613488035, + "auprc": 0.029291931076687566, + "brier": 0.0018288102915981247, + "calibration": { + "observed_rate": 0.0018096272167933405, + "mean_prediction": 0.001952493103291708, + "calibration_in_the_large": 0.00014286588649836738, + "expected_calibration_error_10bin": 0.00014286588649836733, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "K75": { + "valid": 2798, + "positives": 5, + "negatives": 2793, + "auroc": 0.7593268886501969, + "auprc": 0.01804701226805023, + "brier": 0.0017836433223743964, + "calibration": { + "observed_rate": 0.0017869907076483202, + "mean_prediction": 0.001391193649117338, + "calibration_in_the_large": -0.0003957970585309822, + "expected_calibration_error_10bin": 0.0003957970585309822, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "K76": { + "valid": 2681, + "positives": 17, + "negatives": 2664, + "auroc": 0.8390522875816994, + "auprc": 0.18855339458370207, + "brier": 0.005751877320650227, + "calibration": { + "observed_rate": 0.006340917568071615, + "mean_prediction": 0.0031835345488311468, + "calibration_in_the_large": -0.003157383019240468, + "expected_calibration_error_10bin": 0.0035352724208481314, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + "K80": { + "valid": 2731, + "positives": 5, + "negatives": 2726, + "auroc": 0.6955245781364637, + "auprc": 0.0052401892568742, + "brier": 0.0018302532892815941, + "calibration": { + "observed_rate": 0.001830831197363603, + "mean_prediction": 0.001464898611634235, + "calibration_in_the_large": -0.000365932585729368, + "expected_calibration_error_10bin": 0.000365932585729368, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + "K81": { + "valid": 2825, + "positives": 4, + "negatives": 2821, + "auroc": 0.8569656150301311, + "auprc": 0.0325250793217785, + "brier": 0.0014035965214484565, + "calibration": { + "observed_rate": 0.001415929203539823, + "mean_prediction": 0.0008747753546989432, + "calibration_in_the_large": -0.0005411538488408798, + "expected_calibration_error_10bin": 0.0005411538488408798, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "K82": { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.8977675407512402, + "auprc": 0.0060439653853346705, + "brier": 0.0007083100342227224, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0006832523701720053, + "calibration_in_the_large": -2.496292727841964e-05, + "expected_calibration_error_10bin": 2.496292727841964e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K83": { + "valid": 2757, + "positives": 5, + "negatives": 2752, + "auroc": 0.9193313953488372, + "auprc": 0.20972173338673908, + "brier": 0.0017573154895781271, + "calibration": { + "observed_rate": 0.0018135654697134566, + "mean_prediction": 0.0023460467262269476, + "calibration_in_the_large": 0.000532481256513491, + "expected_calibration_error_10bin": 0.0011069919213098182, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + "K85": { + "valid": 2779, + "positives": 2, + "negatives": 2777, + "auroc": 0.6371984155563558, + "auprc": 0.0024640648215334647, + "brier": 0.0007213598693229723, + "calibration": { + "observed_rate": 0.0007196833393306944, + "mean_prediction": 0.0009656998890909391, + "calibration_in_the_large": 0.00024601654976024465, + "expected_calibration_error_10bin": 0.00024601654976024465, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + "K86": { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.811938151743977, + "auprc": 0.01474170306139909, + "brier": 0.0014320014732834372, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.0015854916503797456, + "calibration_in_the_large": 0.00014922594122355158, + "expected_calibration_error_10bin": 0.00014922594122355158, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K90": { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.6286219081272085, + "auprc": 0.0009505703422053232, + "brier": 0.0003540827248481139, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.00046510655516119584, + "calibration_in_the_large": 0.00011187448168892457, + "expected_calibration_error_10bin": 0.00011187448168892457, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "K91": { + "valid": 2768, + "positives": 14, + "negatives": 2754, + "auroc": 0.867050523913269, + "auprc": 0.03836541058918131, + "brier": 0.004966632556014997, + "calibration": { + "observed_rate": 0.0050578034682080926, + "mean_prediction": 0.004099888949805731, + "calibration_in_the_large": -0.0009579145184023617, + "expected_calibration_error_10bin": 0.0012717955009581123, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "K92": { + "valid": 2751, + "positives": 17, + "negatives": 2734, + "auroc": 0.8827617367356598, + "auprc": 0.07027462462755274, + "brier": 0.005975284077976552, + "calibration": { + "observed_rate": 0.0061795710650672485, + "mean_prediction": 0.006162624280207323, + "calibration_in_the_large": -1.6946784859925637e-05, + "expected_calibration_error_10bin": 9.296671347214363e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "K94": { + "valid": 2823, + "positives": 11, + "negatives": 2812, + "auroc": 0.9201474201474201, + "auprc": 0.09677263945413396, + "brier": 0.003745505245277006, + "calibration": { + "observed_rate": 0.0038965639390719092, + "mean_prediction": 0.0030088416199425365, + "calibration_in_the_large": -0.0008877223191293727, + "expected_calibration_error_10bin": 0.0008877223191293725, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "L02": { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.7219520915266356, + "auprc": 0.01879257446792263, + "brier": 0.0035387239315249086, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.003457544419542801, + "calibration_in_the_large": -0.00010497784622135993, + "expected_calibration_error_10bin": 0.00010497784622135993, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "L03": { + "valid": 2701, + "positives": 21, + "negatives": 2680, + "auroc": 0.7133262260127932, + "auprc": 0.019050692146202884, + "brier": 0.00770863091766619, + "calibration": { + "observed_rate": 0.00777489818585709, + "mean_prediction": 0.004550103366532115, + "calibration_in_the_large": -0.0032247948193249746, + "expected_calibration_error_10bin": 0.0032247948193249746, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + "L08": { + "valid": 2830, + "positives": 4, + "negatives": 2826, + "auroc": 0.8060863411181882, + "auprc": 0.0077251723963105605, + "brier": 0.0014112683844067103, + "calibration": { + "observed_rate": 0.0014134275618374558, + "mean_prediction": 0.000763732487128552, + "calibration_in_the_large": -0.0006496950747089037, + "expected_calibration_error_10bin": 0.0006496950747089037, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + "L27": { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.8189121933878422, + "auprc": 0.008470848221857775, + "brier": 0.001875698535071134, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.003205914428047541, + "calibration_in_the_large": 0.001431606408175291, + "expected_calibration_error_10bin": 0.001431606408175291, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "L29": { + "valid": 2817, + "positives": 2, + "negatives": 2815, + "auroc": 0.327708703374778, + "auprc": 0.0007873610730668597, + "brier": 0.0007337799358521033, + "calibration": { + "observed_rate": 0.0007099751508697196, + "mean_prediction": 0.0020405160659719133, + "calibration_in_the_large": 0.0013305409151021937, + "expected_calibration_error_10bin": 0.0013305409151021937, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "L30": { + "valid": 2816, + "positives": 3, + "negatives": 2813, + "auroc": 0.810048583955445, + "auprc": 0.029844985931942455, + "brier": 0.0010570356232121427, + "calibration": { + "observed_rate": 0.001065340909090909, + "mean_prediction": 0.0010342781283725344, + "calibration_in_the_large": -3.10627807183746e-05, + "expected_calibration_error_10bin": 3.10627807183746e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "L50": { + "valid": 2835, + "positives": 2, + "negatives": 2833, + "auroc": 0.7979174020472997, + "auprc": 0.01875, + "brier": 0.0007031743245697834, + "calibration": { + "observed_rate": 0.0007054673721340388, + "mean_prediction": 0.0006811115321676769, + "calibration_in_the_large": -2.4355839966361975e-05, + "expected_calibration_error_10bin": 2.4355839966361975e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + "L53": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 2.806583917422636e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0008048813835886229, + "calibration_in_the_large": 0.0008048813835886229, + "expected_calibration_error_10bin": 0.0008048813835886229, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "L76": { + "valid": 2793, + "positives": 8, + "negatives": 2785, + "auroc": 0.5603231597845602, + "auprc": 0.0037679803321776155, + "brier": 0.0028883594623175936, + "calibration": { + "observed_rate": 0.0028643036161833156, + "mean_prediction": 0.003900872004126743, + "calibration_in_the_large": 0.0010365683879434272, + "expected_calibration_error_10bin": 0.0010365683879434272, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "L89": { + "valid": 2798, + "positives": 11, + "negatives": 2787, + "auroc": 0.8459079492448707, + "auprc": 0.017235525453385858, + "brier": 0.003913285147122346, + "calibration": { + "observed_rate": 0.003931379556826304, + "mean_prediction": 0.002959743655933338, + "calibration_in_the_large": -0.0009716359008929663, + "expected_calibration_error_10bin": 0.001049825329296056, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "L97": { + "valid": 2789, + "positives": 4, + "negatives": 2785, + "auroc": 0.958527827648115, + "auprc": 0.03178052155910788, + "brier": 0.0014413318482054433, + "calibration": { + "observed_rate": 0.0014342058085335247, + "mean_prediction": 0.002162248415866491, + "calibration_in_the_large": 0.0007280426073329662, + "expected_calibration_error_10bin": 0.0007280426073329664, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "L98": { + "valid": 2824, + "positives": 1, + "negatives": 2823, + "auroc": 0.4665249734325186, + "auprc": 0.0006635700066357001, + "brier": 0.0003700714461531762, + "calibration": { + "observed_rate": 0.0003541076487252125, + "mean_prediction": 0.0021146538114286935, + "calibration_in_the_large": 0.001760546162703481, + "expected_calibration_error_10bin": 0.001760546162703481, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "M10": { + "valid": 2713, + "positives": 10, + "negatives": 2703, + "auroc": 0.8231964483906771, + "auprc": 0.035591921801978135, + "brier": 0.0036326010763871068, + "calibration": { + "observed_rate": 0.003685956505713233, + "mean_prediction": 0.0027942006802504442, + "calibration_in_the_large": -0.0008917558254627886, + "expected_calibration_error_10bin": 0.0009712389982534927, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + "M16": { + "valid": 2790, + "positives": 2, + "negatives": 2788, + "auroc": 0.8764347202295553, + "auprc": 0.01218868546923965, + "brier": 0.000715145259034743, + "calibration": { + "observed_rate": 0.0007168458781362007, + "mean_prediction": 0.0006224664889839093, + "calibration_in_the_large": -9.437938915229146e-05, + "expected_calibration_error_10bin": 9.437938915229146e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "M17": { + "valid": 2733, + "positives": 5, + "negatives": 2728, + "auroc": 0.7450146627565982, + "auprc": 0.005817537734382849, + "brier": 0.001828937746824027, + "calibration": { + "observed_rate": 0.0018294914013904135, + "mean_prediction": 0.0012184872641908347, + "calibration_in_the_large": -0.0006110041371995788, + "expected_calibration_error_10bin": 0.0006110041371995788, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "M19": { + "valid": 2674, + "positives": 17, + "negatives": 2657, + "auroc": 0.6881268126369855, + "auprc": 0.019446300769939025, + "brier": 0.0062984282937861395, + "calibration": { + "observed_rate": 0.006357516828721017, + "mean_prediction": 0.0057485692725085325, + "calibration_in_the_large": -0.0006089475562124844, + "expected_calibration_error_10bin": 0.0006089475562124844, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + "M21": { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.9776595744680852, + "auprc": 0.015625, + "brier": 0.00035386236866848835, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0008025829289559774, + "calibration_in_the_large": 0.00044809870350401, + "expected_calibration_error_10bin": 0.00044809870350401, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "M25": { + "valid": 2717, + "positives": 13, + "negatives": 2704, + "auroc": 0.6568616294947656, + "auprc": 0.012043111518805893, + "brier": 0.004769937993080124, + "calibration": { + "observed_rate": 0.004784688995215311, + "mean_prediction": 0.0059272899006684145, + "calibration_in_the_large": 0.0011426009054531037, + "expected_calibration_error_10bin": 0.0011426009054531037, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + "M35": { + "valid": 2806, + "positives": 1, + "negatives": 2805, + "auroc": 0.8677361853832442, + "auprc": 0.002688172043010753, + "brier": 0.0003570569524970084, + "calibration": { + "observed_rate": 0.0003563791874554526, + "mean_prediction": 0.0003696892236077697, + "calibration_in_the_large": 1.3310036152317081e-05, + "expected_calibration_error_10bin": 1.3310036152317081e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "M46": { + "valid": 2814, + "positives": 2, + "negatives": 2812, + "auroc": 0.47670697012802277, + "auprc": 0.0012500844176309036, + "brier": 0.0007126580532559534, + "calibration": { + "observed_rate": 0.0007107320540156361, + "mean_prediction": 0.0010730188023780629, + "calibration_in_the_large": 0.0003622867483624268, + "expected_calibration_error_10bin": 0.0003622867483624268, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "M47": { + "valid": 2743, + "positives": 3, + "negatives": 2740, + "auroc": 0.6885644768856448, + "auprc": 0.004265663199040737, + "brier": 0.0010923539882611339, + "calibration": { + "observed_rate": 0.001093693036820999, + "mean_prediction": 0.0011891708135127568, + "calibration_in_the_large": 9.547777669175785e-05, + "expected_calibration_error_10bin": 9.547777669175785e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "M48": { + "valid": 2690, + "positives": 4, + "negatives": 2686, + "auroc": 0.7006701414743113, + "auprc": 0.011938445043283754, + "brier": 0.001491330492765365, + "calibration": { + "observed_rate": 0.001486988847583643, + "mean_prediction": 0.003083990229063578, + "calibration_in_the_large": 0.001597001381479935, + "expected_calibration_error_10bin": 0.001597001381479935, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + "M51": { + "valid": 2785, + "positives": 1, + "negatives": 2784, + "auroc": 0.959051724137931, + "auprc": 0.008695652173913044, + "brier": 0.00035982708873701064, + "calibration": { + "observed_rate": 0.0003590664272890485, + "mean_prediction": 0.0015091534874229976, + "calibration_in_the_large": 0.0011500870601339492, + "expected_calibration_error_10bin": 0.0011500870601339492, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "M54": { + "valid": 2567, + "positives": 22, + "negatives": 2545, + "auroc": 0.6758706911948562, + "auprc": 0.023638972214693254, + "brier": 0.00847701234399687, + "calibration": { + "observed_rate": 0.008570315543435918, + "mean_prediction": 0.008782715462301475, + "calibration_in_the_large": 0.00021239991886555683, + "expected_calibration_error_10bin": 0.00021239991886555658, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + "M62": { + "valid": 2781, + "positives": 5, + "negatives": 2776, + "auroc": 0.7963976945244957, + "auprc": 0.015036894144650365, + "brier": 0.0017891589164767835, + "calibration": { + "observed_rate": 0.0017979144192736426, + "mean_prediction": 0.001897996618007514, + "calibration_in_the_large": 0.00010008219873387141, + "expected_calibration_error_10bin": 0.00010008219873387141, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "M79": { + "valid": 2697, + "positives": 19, + "negatives": 2678, + "auroc": 0.7629024016351559, + "auprc": 0.02556782944279267, + "brier": 0.006963185271020144, + "calibration": { + "observed_rate": 0.0070448646644419724, + "mean_prediction": 0.007988906553591621, + "calibration_in_the_large": 0.0009440418891496485, + "expected_calibration_error_10bin": 0.0009440418891496486, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + "M81": { + "valid": 2705, + "positives": 6, + "negatives": 2699, + "auroc": 0.7956650611337532, + "auprc": 0.033568916988167205, + "brier": 0.002194049818297401, + "calibration": { + "observed_rate": 0.0022181146025878, + "mean_prediction": 0.002314474538768843, + "calibration_in_the_large": 9.63599361810427e-05, + "expected_calibration_error_10bin": 9.63599361810427e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + "M84": { + "valid": 2818, + "positives": 3, + "negatives": 2815, + "auroc": 0.6909413854351687, + "auprc": 0.0240840505902902, + "brier": 0.0010599378226253757, + "calibration": { + "observed_rate": 0.0010645848119233499, + "mean_prediction": 0.0013960078711778147, + "calibration_in_the_large": 0.0003314230592544648, + "expected_calibration_error_10bin": 0.0003314230592544648, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "M85": { + "valid": 2768, + "positives": 3, + "negatives": 2765, + "auroc": 0.772875226039783, + "auprc": 0.003405569717288705, + "brier": 0.0010862637969444534, + "calibration": { + "observed_rate": 0.001083815028901734, + "mean_prediction": 0.0015414421424683143, + "calibration_in_the_large": 0.00045762711356658035, + "expected_calibration_error_10bin": 0.00045762711356658035, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "M86": { + "valid": 2803, + "positives": 8, + "negatives": 2795, + "auroc": 0.8227638640429338, + "auprc": 0.03627466265073721, + "brier": 0.0028280429315525784, + "calibration": { + "observed_rate": 0.0028540849090260435, + "mean_prediction": 0.0016918757736790154, + "calibration_in_the_large": -0.001162209135347028, + "expected_calibration_error_10bin": 0.001162209135347028, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + "M94": { + "valid": 2819, + "positives": 1, + "negatives": 2818, + "auroc": 0.865152590489709, + "auprc": 0.0026246719160104987, + "brier": 0.00035462831849553085, + "calibration": { + "observed_rate": 0.000354735721887194, + "mean_prediction": 0.000149714504016904, + "calibration_in_the_large": -0.00020502121787029003, + "expected_calibration_error_10bin": 0.00020502121787029003, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "M96": { + "valid": 2804, + "positives": 1, + "negatives": 2803, + "auroc": 0.8933285765251516, + "auprc": 0.0033333333333333335, + "brier": 0.0003668025095667644, + "calibration": { + "observed_rate": 0.0003566333808844508, + "mean_prediction": 0.002137096225280698, + "calibration_in_the_large": 0.0017804628443962472, + "expected_calibration_error_10bin": 0.0017804628443962472, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "N12": { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.5777325787053413, + "auprc": 0.0025245864468641487, + "brier": 0.0014151542819529597, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0008335265603988325, + "calibration_in_the_large": -0.0005794017334902526, + "expected_calibration_error_10bin": 0.0005794017334902526, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N13": { + "valid": 2756, + "positives": 4, + "negatives": 2752, + "auroc": 0.7791606104651163, + "auprc": 0.005997253944229185, + "brier": 0.001458230939238228, + "calibration": { + "observed_rate": 0.001451378809869376, + "mean_prediction": 0.0024909309741935498, + "calibration_in_the_large": 0.0010395521643241739, + "expected_calibration_error_10bin": 0.0010395521643241739, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "N14": { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8460829493087557, + "auprc": 0.009607862622641974, + "brier": 0.0017646989607192673, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0007372204970748293, + "calibration_in_the_large": -0.001032064711700825, + "expected_calibration_error_10bin": 0.001032064711700825, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "N17": { + "valid": 2292, + "positives": 53, + "negatives": 2239, + "auroc": 0.7901101401400558, + "auprc": 0.09289873779928359, + "brier": 0.021994609431371704, + "calibration": { + "observed_rate": 0.0231239092495637, + "mean_prediction": 0.024278130745716362, + "calibration_in_the_large": 0.001154221496152661, + "expected_calibration_error_10bin": 0.0021524922197451416, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + "N18": { + "valid": 2440, + "positives": 21, + "negatives": 2419, + "auroc": 0.8864347723380381, + "auprc": 0.12570900425077916, + "brier": 0.008127815992728486, + "calibration": { + "observed_rate": 0.00860655737704918, + "mean_prediction": 0.005694065055014689, + "calibration_in_the_large": -0.002912492322034492, + "expected_calibration_error_10bin": 0.002912492322034491, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + "N20": { + "valid": 2806, + "positives": 7, + "negatives": 2799, + "auroc": 0.7367937528709233, + "auprc": 0.0058447010787516145, + "brier": 0.0024910395590383425, + "calibration": { + "observed_rate": 0.0024946543121881683, + "mean_prediction": 0.0007252393871870352, + "calibration_in_the_large": -0.0017694149250011332, + "expected_calibration_error_10bin": 0.0017694149250011332, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "N25": { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.945859872611465, + "auprc": 0.06993052265632693, + "brier": 0.001747042604499059, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0005662639046827141, + "calibration_in_the_large": -0.0011998964626786421, + "expected_calibration_error_10bin": 0.0011998964626786421, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N28": { + "valid": 2789, + "positives": 3, + "negatives": 2786, + "auroc": 0.914692510169897, + "auprc": 0.0122442425910634, + "brier": 0.0010733372036807326, + "calibration": { + "observed_rate": 0.0010756543564001434, + "mean_prediction": 0.0023120133404418344, + "calibration_in_the_large": 0.001236358984041691, + "expected_calibration_error_10bin": 0.001236358984041691, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "N30": { + "valid": 2829, + "positives": 7, + "negatives": 2822, + "auroc": 0.7740204515541156, + "auprc": 0.01147141822572811, + "brier": 0.002470166261044304, + "calibration": { + "observed_rate": 0.002474372569812655, + "mean_prediction": 0.0020576333512236445, + "calibration_in_the_large": -0.00041673921858901035, + "expected_calibration_error_10bin": 0.00041673921858901035, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N32": { + "valid": 2807, + "positives": 9, + "negatives": 2798, + "auroc": 0.7773012469224049, + "auprc": 0.023761358148371173, + "brier": 0.00317644563864916, + "calibration": { + "observed_rate": 0.003206270039187745, + "mean_prediction": 0.0025839978162250934, + "calibration_in_the_large": -0.0006222722229626515, + "expected_calibration_error_10bin": 0.0006222722229626515, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "N39": { + "valid": 2520, + "positives": 44, + "negatives": 2476, + "auroc": 0.7492381406961375, + "auprc": 0.05132199266812414, + "brier": 0.01700730971893, + "calibration": { + "observed_rate": 0.01746031746031746, + "mean_prediction": 0.020933372652368797, + "calibration_in_the_large": 0.003473055192051336, + "expected_calibration_error_10bin": 0.0036741792217880064, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + "N40": { + "valid": 2606, + "positives": 11, + "negatives": 2595, + "auroc": 0.8127167630057803, + "auprc": 0.018620528822298563, + "brier": 0.004218003239863486, + "calibration": { + "observed_rate": 0.00422102839600921, + "mean_prediction": 0.006009321121457911, + "calibration_in_the_large": 0.0017882927254487015, + "expected_calibration_error_10bin": 0.0017882927254487015, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + "N73": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9782454899186417, + "auprc": 0.0541501976284585, + "brier": 0.0006982342639536214, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0005736028806418841, + "calibration_in_the_large": -0.00013336071073316016, + "expected_calibration_error_10bin": 0.00013336071073316016, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N99": { + "valid": 2799, + "positives": 3, + "negatives": 2796, + "auroc": 0.7265140677157844, + "auprc": 0.005686470156591118, + "brier": 0.0010707269270512636, + "calibration": { + "observed_rate": 0.0010718113612004287, + "mean_prediction": 0.0008668250053813685, + "calibration_in_the_large": -0.0002049863558190602, + "expected_calibration_error_10bin": 0.0002049863558190602, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + "O69": { + "valid": 2743, + "positives": 4, + "negatives": 2739, + "auroc": 0.9982657904344652, + "auprc": 0.36858974358974356, + "brier": 0.0013679758626648788, + "calibration": { + "observed_rate": 0.0014582573824279985, + "mean_prediction": 0.0002682190431160065, + "calibration_in_the_large": -0.001190038339311992, + "expected_calibration_error_10bin": 0.0012662205449290504, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "O99": { + "valid": 2652, + "positives": 1, + "negatives": 2651, + "auroc": 0.999622783855149, + "auprc": 0.5, + "brier": 0.0002829014096896651, + "calibration": { + "observed_rate": 0.0003770739064856712, + "mean_prediction": 0.0002687998676402517, + "calibration_in_the_large": -0.0001082740388454195, + "expected_calibration_error_10bin": 0.00040130751082925764, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + "Q21": { + "valid": 2810, + "positives": 1, + "negatives": 2809, + "auroc": 0.813812744749021, + "auprc": 0.0019083969465648854, + "brier": 0.0003561447133669706, + "calibration": { + "observed_rate": 0.00035587188612099647, + "mean_prediction": 0.0006683292802038157, + "calibration_in_the_large": 0.00031245739408281925, + "expected_calibration_error_10bin": 0.00031245739408281925, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "U07": { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 1.0537843973456643e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001707559332915215, + "calibration_in_the_large": 0.001707559332915215, + "expected_calibration_error_10bin": 0.001707559332915215, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + } + }, + "120": { + "A04": { + "valid": 2782, + "positives": 18, + "negatives": 2764, + "auroc": 0.7053384788551214, + "auprc": 0.07583365441111248, + "brier": 0.006382584068076843, + "calibration": { + "observed_rate": 0.006470165348670022, + "mean_prediction": 0.0065892746400799534, + "calibration_in_the_large": 0.00011910929140993183, + "expected_calibration_error_10bin": 0.000762309879927632, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "A08": { + "valid": 2818, + "positives": 7, + "negatives": 2811, + "auroc": 0.7871118564821873, + "auprc": 0.019844103519310135, + "brier": 0.002463580063905062, + "calibration": { + "observed_rate": 0.00248403122782115, + "mean_prediction": 0.0027230848936157953, + "calibration_in_the_large": 0.00023905366579464547, + "expected_calibration_error_10bin": 0.00023905366579464547, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "A41": { + "valid": 2664, + "positives": 33, + "negatives": 2631, + "auroc": 0.7637492369533418, + "auprc": 0.056810786303751776, + "brier": 0.012176824385489957, + "calibration": { + "observed_rate": 0.012387387387387387, + "mean_prediction": 0.017432221600767673, + "calibration_in_the_large": 0.0050448342133802854, + "expected_calibration_error_10bin": 0.0050448342133802854, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + "B00": { + "valid": 2819, + "positives": 1, + "negatives": 2818, + "auroc": 0.9932576295244855, + "auprc": 0.05, + "brier": 0.0003622282898106182, + "calibration": { + "observed_rate": 0.000354735721887194, + "mean_prediction": 0.0010488824266010922, + "calibration_in_the_large": 0.0006941467047138982, + "expected_calibration_error_10bin": 0.000694146704713898, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "B02": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7962504421648391, + "auprc": 0.0017331022530329288, + "brier": 0.00035432336349102306, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.000405015802714552, + "calibration_in_the_large": 5.140901346419838e-05, + "expected_calibration_error_10bin": 5.140901346419838e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "B18": { + "valid": 2782, + "positives": 3, + "negatives": 2779, + "auroc": 0.9702530886409979, + "auprc": 0.10007695267410543, + "brier": 0.0010489918776416622, + "calibration": { + "observed_rate": 0.0010783608914450035, + "mean_prediction": 0.0007496750396228068, + "calibration_in_the_large": -0.00032868585182219676, + "expected_calibration_error_10bin": 0.00032868585182219676, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "B19": { + "valid": 2763, + "positives": 14, + "negatives": 2749, + "auroc": 0.83414748220132, + "auprc": 0.06782213804152169, + "brier": 0.004966661507933206, + "calibration": { + "observed_rate": 0.005066956207021353, + "mean_prediction": 0.0013252574538024637, + "calibration_in_the_large": -0.0037416987532188895, + "expected_calibration_error_10bin": 0.0038254369637972397, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "B20": { + "valid": 2829, + "positives": 3, + "negatives": 2826, + "auroc": 0.9880868129275773, + "auprc": 0.11872759856630825, + "brier": 0.001053486491783324, + "calibration": { + "observed_rate": 0.0010604453870625664, + "mean_prediction": 0.00016777084854888874, + "calibration_in_the_large": -0.0008926745385136776, + "expected_calibration_error_10bin": 0.0008926745385136776, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "B34": { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.9733816766890697, + "auprc": 0.035600455132844974, + "brier": 0.0014021372985689522, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0007981952802505689, + "calibration_in_the_large": -0.0006147330136385162, + "expected_calibration_error_10bin": 0.0006147330136385162, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "B35": { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 6.008408421178278e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0010619743561138498, + "calibration_in_the_large": 0.0010619743561138498, + "expected_calibration_error_10bin": 0.0010619743561138498, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "B37": { + "valid": 2768, + "positives": 22, + "negatives": 2746, + "auroc": 0.770343640336357, + "auprc": 0.02701812149777749, + "brier": 0.007865085981645455, + "calibration": { + "observed_rate": 0.007947976878612716, + "mean_prediction": 0.006439647744123328, + "calibration_in_the_large": -0.0015083291344893885, + "expected_calibration_error_10bin": 0.0017682411043533444, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "B95": { + "valid": 2678, + "positives": 39, + "negatives": 2639, + "auroc": 0.68725527346217, + "auprc": 0.029604462768836503, + "brier": 0.014486322422999624, + "calibration": { + "observed_rate": 0.014563106796116505, + "mean_prediction": 0.016153852224400054, + "calibration_in_the_large": 0.0015907454282835486, + "expected_calibration_error_10bin": 0.0015907454282835496, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + "B96": { + "valid": 2630, + "positives": 52, + "negatives": 2578, + "auroc": 0.7796890851584413, + "auprc": 0.07882778197404422, + "brier": 0.018857111967610606, + "calibration": { + "observed_rate": 0.01977186311787072, + "mean_prediction": 0.022154236024094234, + "calibration_in_the_large": 0.0023823729062235136, + "expected_calibration_error_10bin": 0.00432586968806041, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + "B97": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7789175804740007, + "auprc": 0.001597444089456869, + "brier": 0.00035970886813903015, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0005010145245864516, + "calibration_in_the_large": 0.00014740773533609795, + "expected_calibration_error_10bin": 0.00014740773533609795, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "C18": { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9803330970942594, + "auprc": 0.05961538461538462, + "brier": 0.0007031692222511959, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0004795187164982298, + "calibration_in_the_large": -0.00022869658095219517, + "expected_calibration_error_10bin": 0.00022869658095219517, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "C22": { + "valid": 2812, + "positives": 5, + "negatives": 2807, + "auroc": 0.9182757392233701, + "auprc": 0.06287053720387054, + "brier": 0.0017524865257811276, + "calibration": { + "observed_rate": 0.0017780938833570413, + "mean_prediction": 0.000537025693932429, + "calibration_in_the_large": -0.0012410681894246124, + "expected_calibration_error_10bin": 0.0012410681894246124, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + "C25": { + "valid": 2809, + "positives": 1, + "negatives": 2808, + "auroc": 0.9992877492877493, + "auprc": 0.3333333333333333, + "brier": 0.0003291317094461688, + "calibration": { + "observed_rate": 0.000355998576005696, + "mean_prediction": 0.0004055828513691973, + "calibration_in_the_large": 4.958427536350129e-05, + "expected_calibration_error_10bin": 4.95842753635013e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "C61": { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9641455583303603, + "auprc": 0.015802318486882246, + "brier": 0.0007107883890998077, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0006970757841032236, + "calibration_in_the_large": -1.5936693615136496e-05, + "expected_calibration_error_10bin": 1.5936693615136496e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "C67": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9511850017686594, + "auprc": 0.03505228136882129, + "brier": 0.000703061332616117, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.000496910078489676, + "calibration_in_the_large": -0.00021005351288536827, + "expected_calibration_error_10bin": 0.00021005351288536827, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "C77": { + "valid": 2762, + "positives": 13, + "negatives": 2749, + "auroc": 0.8649299045806866, + "auprc": 0.12421080261327702, + "brier": 0.004434640464886088, + "calibration": { + "observed_rate": 0.004706734250543085, + "mean_prediction": 0.0029136339734242415, + "calibration_in_the_large": -0.0017931002771188437, + "expected_calibration_error_10bin": 0.0021207810630803946, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C78": { + "valid": 2762, + "positives": 18, + "negatives": 2744, + "auroc": 0.8586613216715258, + "auprc": 0.1442203083638084, + "brier": 0.006101351567799488, + "calibration": { + "observed_rate": 0.0065170166545981175, + "mean_prediction": 0.004492413596781499, + "calibration_in_the_large": -0.0020246030578166185, + "expected_calibration_error_10bin": 0.0033100981796875505, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C79": { + "valid": 2751, + "positives": 14, + "negatives": 2737, + "auroc": 0.8635628164309201, + "auprc": 0.13633507790755187, + "brier": 0.005236652874855836, + "calibration": { + "observed_rate": 0.005089058524173028, + "mean_prediction": 0.005926548452542474, + "calibration_in_the_large": 0.0008374899283694458, + "expected_calibration_error_10bin": 0.0036764565028709535, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "C83": { + "valid": 2820, + "positives": 0, + "negatives": 2820, + "auroc": null, + "auprc": null, + "brier": 1.3140757307764607e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00038348435296674526, + "calibration_in_the_large": 0.00038348435296674526, + "expected_calibration_error_10bin": 0.00038348435296674526, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "D25": { + "valid": 2792, + "positives": 2, + "negatives": 2790, + "auroc": 0.9419354838709677, + "auprc": 0.2530769230769231, + "brier": 0.0007105554704747896, + "calibration": { + "observed_rate": 0.0007163323782234957, + "mean_prediction": 0.00029768954705450284, + "calibration_in_the_large": -0.00041864283116899284, + "expected_calibration_error_10bin": 0.00041864283116899284, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "D47": { + "valid": 2796, + "positives": 6, + "negatives": 2790, + "auroc": 0.5981481481481481, + "auprc": 0.0038289343090854174, + "brier": 0.002180221844325743, + "calibration": { + "observed_rate": 0.002145922746781116, + "mean_prediction": 0.0031853273274240505, + "calibration_in_the_large": 0.0010394045806429346, + "expected_calibration_error_10bin": 0.0010394045806429346, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "D50": { + "valid": 2663, + "positives": 36, + "negatives": 2627, + "auroc": 0.7989785560208096, + "auprc": 0.09735943577147979, + "brier": 0.012839010332726249, + "calibration": { + "observed_rate": 0.013518588058580548, + "mean_prediction": 0.010474213828299104, + "calibration_in_the_large": -0.003044374230281444, + "expected_calibration_error_10bin": 0.0030443742302814453, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + "D53": { + "valid": 2805, + "positives": 11, + "negatives": 2794, + "auroc": 0.8307737359276371, + "auprc": 0.02565251923915747, + "brier": 0.003915965486304453, + "calibration": { + "observed_rate": 0.00392156862745098, + "mean_prediction": 0.0040776602752223634, + "calibration_in_the_large": 0.0001560916477713831, + "expected_calibration_error_10bin": 0.0006508872921298908, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "D59": { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 2.476769123016642e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0005668691258285803, + "calibration_in_the_large": 0.0005668691258285803, + "expected_calibration_error_10bin": 0.0005668691258285803, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "D61": { + "valid": 2773, + "positives": 17, + "negatives": 2756, + "auroc": 0.8928540937419961, + "auprc": 0.12981210099733986, + "brier": 0.005726806178122827, + "calibration": { + "observed_rate": 0.006130544536602957, + "mean_prediction": 0.006902876924752144, + "calibration_in_the_large": 0.000772332388149187, + "expected_calibration_error_10bin": 0.0012915170451143305, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "D62": { + "valid": 2499, + "positives": 36, + "negatives": 2463, + "auroc": 0.7758492353498444, + "auprc": 0.03590656915887488, + "brier": 0.014137779359188375, + "calibration": { + "observed_rate": 0.014405762304921969, + "mean_prediction": 0.016489135343259072, + "calibration_in_the_large": 0.002083373038337104, + "expected_calibration_error_10bin": 0.002083373038337103, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + "D63": { + "valid": 2686, + "positives": 52, + "negatives": 2634, + "auroc": 0.8916170200338766, + "auprc": 0.1326258187951842, + "brier": 0.017912844011366478, + "calibration": { + "observed_rate": 0.0193596425912137, + "mean_prediction": 0.016071345991246242, + "calibration_in_the_large": -0.0032882965999674572, + "expected_calibration_error_10bin": 0.007052837966133454, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + "D64": { + "valid": 2434, + "positives": 77, + "negatives": 2357, + "auroc": 0.8364639179234004, + "auprc": 0.15164954842145, + "brier": 0.02856860121744379, + "calibration": { + "observed_rate": 0.031635168447000823, + "mean_prediction": 0.032421906931115727, + "calibration_in_the_large": 0.000786738484114903, + "expected_calibration_error_10bin": 0.0038020569088734117, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + "D65": { + "valid": 2833, + "positives": 3, + "negatives": 2830, + "auroc": 0.9555948174322733, + "auprc": 0.015202351582033119, + "brier": 0.0010570415290933042, + "calibration": { + "observed_rate": 0.0010589481115425344, + "mean_prediction": 0.0006373076399403475, + "calibration_in_the_large": -0.0004216404716021869, + "expected_calibration_error_10bin": 0.0004216404716021869, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + "D68": { + "valid": 2682, + "positives": 32, + "negatives": 2650, + "auroc": 0.8205542452830189, + "auprc": 0.06297396418321248, + "brier": 0.011575473347757317, + "calibration": { + "observed_rate": 0.011931394481730051, + "mean_prediction": 0.008041642674254142, + "calibration_in_the_large": -0.0038897518074759094, + "expected_calibration_error_10bin": 0.0051029432415613234, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + "D69": { + "valid": 2586, + "positives": 47, + "negatives": 2539, + "auroc": 0.868661644306269, + "auprc": 0.21854805607795344, + "brier": 0.015830351527155943, + "calibration": { + "observed_rate": 0.01817478731631864, + "mean_prediction": 0.014149275043638415, + "calibration_in_the_large": -0.004025512272680224, + "expected_calibration_error_10bin": 0.004344442206020205, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + "D70": { + "valid": 2787, + "positives": 20, + "negatives": 2767, + "auroc": 0.8860679436212504, + "auprc": 0.24892540411850708, + "brier": 0.006576779898289773, + "calibration": { + "observed_rate": 0.007176175098672408, + "mean_prediction": 0.006144997797958654, + "calibration_in_the_large": -0.0010311773007137537, + "expected_calibration_error_10bin": 0.004312955858749167, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "D72": { + "valid": 2595, + "positives": 39, + "negatives": 2556, + "auroc": 0.7026704385859316, + "auprc": 0.050463891273248684, + "brier": 0.01465168442683102, + "calibration": { + "observed_rate": 0.015028901734104046, + "mean_prediction": 0.01629299984207226, + "calibration_in_the_large": 0.001264098107968216, + "expected_calibration_error_10bin": 0.0013115824583104984, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + "D73": { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.7604535790219702, + "auprc": 0.025749063670411985, + "brier": 0.0007106305484891897, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0009919093235103713, + "calibration_in_the_large": 0.0002836940260599463, + "expected_calibration_error_10bin": 0.0002836940260599463, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "D75": { + "valid": 2831, + "positives": 2, + "negatives": 2829, + "auroc": 0.8923647932131495, + "auprc": 0.004985119047619047, + "brier": 0.0007074343896524882, + "calibration": { + "observed_rate": 0.0007064641469445425, + "mean_prediction": 0.0009098821169095982, + "calibration_in_the_large": 0.00020341796996505566, + "expected_calibration_error_10bin": 0.00020341796996505566, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "D80": { + "valid": 2832, + "positives": 5, + "negatives": 2827, + "auroc": 0.9912274495932083, + "auprc": 0.10348499992428029, + "brier": 0.0017044730436385769, + "calibration": { + "observed_rate": 0.0017655367231638418, + "mean_prediction": 0.0009790182633349176, + "calibration_in_the_large": -0.0007865184598289242, + "expected_calibration_error_10bin": 0.0009995301013262532, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "D89": { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.82663139329806, + "auprc": 0.006925064599483204, + "brier": 0.0007708394246915555, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0006263494167406404, + "calibration_in_the_large": -7.862062203271175e-05, + "expected_calibration_error_10bin": 0.0006783740605977343, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "E03": { + "valid": 2480, + "positives": 17, + "negatives": 2463, + "auroc": 0.7418738506364787, + "auprc": 0.01894127489247665, + "brier": 0.00679272636534709, + "calibration": { + "observed_rate": 0.0068548387096774195, + "mean_prediction": 0.0035408270038861963, + "calibration_in_the_large": -0.003314011705791223, + "expected_calibration_error_10bin": 0.003314011705791223, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + "E04": { + "valid": 2775, + "positives": 8, + "negatives": 2767, + "auroc": 0.7534784965666788, + "auprc": 0.00808064907648098, + "brier": 0.0028757708578128474, + "calibration": { + "observed_rate": 0.002882882882882883, + "mean_prediction": 0.002027297062977104, + "calibration_in_the_large": -0.000855585819905779, + "expected_calibration_error_10bin": 0.000855585819905779, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "E05": { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.10627674750356633, + "auprc": 0.0005873625026883498, + "brier": 0.0007141677025772864, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0007590326729636761, + "calibration_in_the_large": 4.6274298052770843e-05, + "expected_calibration_error_10bin": 4.6274298052770843e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "E11": { + "valid": 2194, + "positives": 13, + "negatives": 2181, + "auroc": 0.7747328325044969, + "auprc": 0.09108966538847466, + "brier": 0.005809382283337496, + "calibration": { + "observed_rate": 0.005925250683682771, + "mean_prediction": 0.0045075746989855035, + "calibration_in_the_large": -0.0014176759846972675, + "expected_calibration_error_10bin": 0.0014176759846972675, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + "E16": { + "valid": 2816, + "positives": 4, + "negatives": 2812, + "auroc": 0.6904338549075392, + "auprc": 0.0030973809921938087, + "brier": 0.001426719399623738, + "calibration": { + "observed_rate": 0.0014204545454545455, + "mean_prediction": 0.0018243282409687563, + "calibration_in_the_large": 0.0004038736955142108, + "expected_calibration_error_10bin": 0.0004038736955142108, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "E21": { + "valid": 2814, + "positives": 1, + "negatives": 2813, + "auroc": 0.9832918592250267, + "auprc": 0.020833333333333332, + "brier": 0.00036031687576104133, + "calibration": { + "observed_rate": 0.00035536602700781805, + "mean_prediction": 0.0010424987693503937, + "calibration_in_the_large": 0.0006871327423425757, + "expected_calibration_error_10bin": 0.0006871327423425757, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "E22": { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8177269478198713, + "auprc": 0.005881969104643357, + "brier": 0.0014838153882638517, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.0038799363583860887, + "calibration_in_the_large": 0.0024523846096351967, + "expected_calibration_error_10bin": 0.0024523846096351967, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "E27": { + "valid": 2811, + "positives": 4, + "negatives": 2807, + "auroc": 0.7250623441396509, + "auprc": 0.0034237944934689046, + "brier": 0.001429665917376868, + "calibration": { + "observed_rate": 0.001422981145499822, + "mean_prediction": 0.0015061655334792396, + "calibration_in_the_large": 8.318438797941751e-05, + "expected_calibration_error_10bin": 8.318438797941751e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + }, + "E43": { + "valid": 2748, + "positives": 29, + "negatives": 2719, + "auroc": 0.8280934927901993, + "auprc": 0.0728582187037735, + "brier": 0.010178100518447189, + "calibration": { + "observed_rate": 0.010553129548762736, + "mean_prediction": 0.009654361670458075, + "calibration_in_the_large": -0.0008987678783046616, + "expected_calibration_error_10bin": 0.0016354791024417495, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + "E44": { + "valid": 2800, + "positives": 12, + "negatives": 2788, + "auroc": 0.74925274988044, + "auprc": 0.017561269160776268, + "brier": 0.0043112193926992635, + "calibration": { + "observed_rate": 0.004285714285714286, + "mean_prediction": 0.006107852925997577, + "calibration_in_the_large": 0.0018221386402832909, + "expected_calibration_error_10bin": 0.0018221386402832913, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "E46": { + "valid": 2772, + "positives": 27, + "negatives": 2745, + "auroc": 0.815408486811037, + "auprc": 0.07175490874324718, + "brier": 0.009394196913671545, + "calibration": { + "observed_rate": 0.00974025974025974, + "mean_prediction": 0.009492539104521422, + "calibration_in_the_large": -0.0002477206357383178, + "expected_calibration_error_10bin": 0.0008871700240666667, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + "E53": { + "valid": 2804, + "positives": 4, + "negatives": 2800, + "auroc": 0.7470535714285714, + "auprc": 0.004449873617421847, + "brier": 0.0014345847169078365, + "calibration": { + "observed_rate": 0.0014265335235378032, + "mean_prediction": 0.0017889361353975433, + "calibration_in_the_large": 0.0003624026118597401, + "expected_calibration_error_10bin": 0.0003624026118597401, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "E55": { + "valid": 2737, + "positives": 14, + "negatives": 2723, + "auroc": 0.5496301348302818, + "auprc": 0.006859008535724606, + "brier": 0.00517002682796103, + "calibration": { + "observed_rate": 0.005115089514066497, + "mean_prediction": 0.00661063312930698, + "calibration_in_the_large": 0.0014955436152404838, + "expected_calibration_error_10bin": 0.0014955436152404844, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + "E66": { + "valid": 2371, + "positives": 27, + "negatives": 2344, + "auroc": 0.6888667677916824, + "auprc": 0.024774387724164067, + "brier": 0.011234954750317827, + "calibration": { + "observed_rate": 0.011387600168705188, + "mean_prediction": 0.009715378884894233, + "calibration_in_the_large": -0.0016722212838109554, + "expected_calibration_error_10bin": 0.0019313805384163912, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + "E78": { + "valid": 1572, + "positives": 30, + "negatives": 1542, + "auroc": 0.6901426718547341, + "auprc": 0.04952360615199737, + "brier": 0.018877860052491112, + "calibration": { + "observed_rate": 0.019083969465648856, + "mean_prediction": 0.01741407643569849, + "calibration_in_the_large": -0.0016698930299503638, + "expected_calibration_error_10bin": 0.008049242912316458, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + "E80": { + "valid": 2823, + "positives": 4, + "negatives": 2819, + "auroc": 0.9699361475700603, + "auprc": 0.03161251626392304, + "brier": 0.0014107276613592199, + "calibration": { + "observed_rate": 0.0014169323414806943, + "mean_prediction": 0.001461270616449895, + "calibration_in_the_large": 4.4338274969200724e-05, + "expected_calibration_error_10bin": 4.4338274969200724e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "E83": { + "valid": 2653, + "positives": 47, + "negatives": 2606, + "auroc": 0.7915612089939746, + "auprc": 0.1024372475160379, + "brier": 0.0167204272853866, + "calibration": { + "observed_rate": 0.017715793441387108, + "mean_prediction": 0.014336487634740757, + "calibration_in_the_large": -0.0033793058066463513, + "expected_calibration_error_10bin": 0.003844318025658744, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + "E86": { + "valid": 2587, + "positives": 52, + "negatives": 2535, + "auroc": 0.7828629949931725, + "auprc": 0.06622008077613686, + "brier": 0.019598615192182266, + "calibration": { + "observed_rate": 0.020100502512562814, + "mean_prediction": 0.02866305298712659, + "calibration_in_the_large": 0.008562550474563776, + "expected_calibration_error_10bin": 0.008562550474563776, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + "E87": { + "valid": 2185, + "positives": 88, + "negatives": 2097, + "auroc": 0.7814085056574327, + "auprc": 0.1351738539855921, + "brier": 0.03693894427493211, + "calibration": { + "observed_rate": 0.040274599542334096, + "mean_prediction": 0.036070576244304535, + "calibration_in_the_large": -0.0042040232980295605, + "expected_calibration_error_10bin": 0.007256778526744322, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + "E88": { + "valid": 2817, + "positives": 9, + "negatives": 2808, + "auroc": 0.8068217790440013, + "auprc": 0.08419242928073277, + "brier": 0.003113827464177075, + "calibration": { + "observed_rate": 0.003194888178913738, + "mean_prediction": 0.0024963165573044462, + "calibration_in_the_large": -0.0006985716216092916, + "expected_calibration_error_10bin": 0.0006985716216092916, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "E89": { + "valid": 2780, + "positives": 4, + "negatives": 2776, + "auroc": 0.694614553314121, + "auprc": 0.0028264090038692745, + "brier": 0.001440278553926299, + "calibration": { + "observed_rate": 0.0014388489208633094, + "mean_prediction": 0.0022319450462477785, + "calibration_in_the_large": 0.0007930961253844692, + "expected_calibration_error_10bin": 0.0007930961253844692, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "F02": { + "valid": 2802, + "positives": 1, + "negatives": 2801, + "auroc": 0.6644055694394859, + "auprc": 0.0010626992561105207, + "brier": 0.0003857761929882231, + "calibration": { + "observed_rate": 0.00035688793718772306, + "mean_prediction": 0.0017668499214794975, + "calibration_in_the_large": 0.0014099619842917745, + "expected_calibration_error_10bin": 0.0014099619842917745, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "F03": { + "valid": 2739, + "positives": 11, + "negatives": 2728, + "auroc": 0.8519394828045854, + "auprc": 0.026605220895301963, + "brier": 0.00400432455245496, + "calibration": { + "observed_rate": 0.004016064257028112, + "mean_prediction": 0.00438885354836595, + "calibration_in_the_large": 0.00037278929133783764, + "expected_calibration_error_10bin": 0.0003727892913378371, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "F05": { + "valid": 2750, + "positives": 15, + "negatives": 2735, + "auroc": 0.7352102376599634, + "auprc": 0.015293950849351597, + "brier": 0.005522863972649958, + "calibration": { + "observed_rate": 0.005454545454545455, + "mean_prediction": 0.007986498047339741, + "calibration_in_the_large": 0.0025319525927942864, + "expected_calibration_error_10bin": 0.002531952592794286, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "F06": { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7153220099079972, + "auprc": 0.0018085378323108386, + "brier": 0.0007156043526741042, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0017384454642043242, + "calibration_in_the_large": 0.0010312318857036169, + "expected_calibration_error_10bin": 0.0010312318857036169, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "F10": { + "valid": 2560, + "positives": 9, + "negatives": 2551, + "auroc": 0.8420662920858922, + "auprc": 0.1645405147999129, + "brier": 0.0033360419591764072, + "calibration": { + "observed_rate": 0.003515625, + "mean_prediction": 0.005579643940058077, + "calibration_in_the_large": 0.002064018940058077, + "expected_calibration_error_10bin": 0.0024100664178547506, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "F11": { + "valid": 2741, + "positives": 7, + "negatives": 2734, + "auroc": 0.8598077124046399, + "auprc": 0.03458384981261382, + "brier": 0.0025589678936977895, + "calibration": { + "observed_rate": 0.002553812477198103, + "mean_prediction": 0.003118550318263713, + "calibration_in_the_large": 0.00056473784106561, + "expected_calibration_error_10bin": 0.0005647378410656103, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "F12": { + "valid": 2777, + "positives": 10, + "negatives": 2767, + "auroc": 0.8968196602818937, + "auprc": 0.023728474189544456, + "brier": 0.0035665604066273593, + "calibration": { + "observed_rate": 0.0036010082823190494, + "mean_prediction": 0.002077336412103227, + "calibration_in_the_large": -0.0015236718702158225, + "expected_calibration_error_10bin": 0.0015236718702158225, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "F14": { + "valid": 2787, + "positives": 8, + "negatives": 2779, + "auroc": 0.9483177401943145, + "auprc": 0.041753151398341036, + "brier": 0.0028421473358636526, + "calibration": { + "observed_rate": 0.0028704700394689632, + "mean_prediction": 0.0008869216925774526, + "calibration_in_the_large": -0.0019835483468915107, + "expected_calibration_error_10bin": 0.0019835483468915107, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "F15": { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.9643829132647024, + "auprc": 0.050293739575308465, + "brier": 0.002110663156190062, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0003077409971369417, + "calibration_in_the_large": -0.0018176575150840996, + "expected_calibration_error_10bin": 0.0018176575150840996, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "F17": { + "valid": 2426, + "positives": 25, + "negatives": 2401, + "auroc": 0.8894793835901708, + "auprc": 0.09839658771315112, + "brier": 0.009782769387737563, + "calibration": { + "observed_rate": 0.010305028854080791, + "mean_prediction": 0.009344634922879054, + "calibration_in_the_large": -0.0009603939312017376, + "expected_calibration_error_10bin": 0.002313529916283716, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + "F19": { + "valid": 2801, + "positives": 9, + "negatives": 2792, + "auroc": 0.964541547277937, + "auprc": 0.13861940876708806, + "brier": 0.0031161813012768494, + "calibration": { + "observed_rate": 0.0032131381649410924, + "mean_prediction": 0.0009442429278560592, + "calibration_in_the_large": -0.002268895237085033, + "expected_calibration_error_10bin": 0.002268895237085033, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F20": { + "valid": 2808, + "positives": 2, + "negatives": 2806, + "auroc": 0.7549893086243763, + "auprc": 0.019258710968555526, + "brier": 0.0007091194537879653, + "calibration": { + "observed_rate": 0.0007122507122507123, + "mean_prediction": 0.0005391206868911432, + "calibration_in_the_large": -0.00017313002535956912, + "expected_calibration_error_10bin": 0.00017313002535956912, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + "F22": { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.7354609929078014, + "auprc": 0.0013386880856760374, + "brier": 0.00035590647435943706, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0006546607128618254, + "calibration_in_the_large": 0.000300176487409858, + "expected_calibration_error_10bin": 0.000300176487409858, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "F25": { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7765151515151515, + "auprc": 0.006712159693949494, + "brier": 0.001063830796452406, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0005415552756447525, + "calibration_in_the_large": -0.0005226518900168296, + "expected_calibration_error_10bin": 0.0005226518900168296, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "F29": { + "valid": 2806, + "positives": 7, + "negatives": 2799, + "auroc": 0.7262797938039096, + "auprc": 0.006465350381960069, + "brier": 0.0024920781894529806, + "calibration": { + "observed_rate": 0.0024946543121881683, + "mean_prediction": 0.0005216427713319106, + "calibration_in_the_large": -0.0019730115408562576, + "expected_calibration_error_10bin": 0.0019730115408562576, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "F31": { + "valid": 2724, + "positives": 8, + "negatives": 2716, + "auroc": 0.8587536818851251, + "auprc": 0.03780911544442593, + "brier": 0.0028945655037213003, + "calibration": { + "observed_rate": 0.002936857562408223, + "mean_prediction": 0.0019823898601503587, + "calibration_in_the_large": -0.0009544677022578643, + "expected_calibration_error_10bin": 0.0009544677022578643, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + "F32": { + "valid": 2200, + "positives": 40, + "negatives": 2160, + "auroc": 0.7005208333333334, + "auprc": 0.05273132352007076, + "brier": 0.017897576520676875, + "calibration": { + "observed_rate": 0.01818181818181818, + "mean_prediction": 0.02597279036475811, + "calibration_in_the_large": 0.007790972182939931, + "expected_calibration_error_10bin": 0.00779097218293993, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + "F33": { + "valid": 2800, + "positives": 7, + "negatives": 2793, + "auroc": 0.7777095800726306, + "auprc": 0.009952290449986852, + "brier": 0.002512120152828131, + "calibration": { + "observed_rate": 0.0025, + "mean_prediction": 0.002221230707303091, + "calibration_in_the_large": -0.00027876929269690914, + "expected_calibration_error_10bin": 0.00027876929269690914, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "F39": { + "valid": 2801, + "positives": 8, + "negatives": 2793, + "auroc": 0.7575187969924813, + "auprc": 0.024584042764136026, + "brier": 0.002833038154684806, + "calibration": { + "observed_rate": 0.002856122813280971, + "mean_prediction": 0.001838842182109123, + "calibration_in_the_large": -0.0010172806311718483, + "expected_calibration_error_10bin": 0.0010172806311718483, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F41": { + "valid": 2247, + "positives": 51, + "negatives": 2196, + "auroc": 0.7269545340905033, + "auprc": 0.09312184936871, + "brier": 0.021499658906481124, + "calibration": { + "observed_rate": 0.022696929238985315, + "mean_prediction": 0.024329338092597314, + "calibration_in_the_large": 0.001632408853611999, + "expected_calibration_error_10bin": 0.0046132473448315435, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + "F43": { + "valid": 2734, + "positives": 15, + "negatives": 2719, + "auroc": 0.7730292999877406, + "auprc": 0.0698825910469436, + "brier": 0.0053747299142471805, + "calibration": { + "observed_rate": 0.005486466715435259, + "mean_prediction": 0.005623955463291992, + "calibration_in_the_large": 0.00013748874785673298, + "expected_calibration_error_10bin": 0.00013748874785673174, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "F60": { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.9414859580519019, + "auprc": 0.025639665802675203, + "brier": 0.001761134928090409, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.001168628119544747, + "calibration_in_the_large": -0.0006056799003275027, + "expected_calibration_error_10bin": 0.0006056799003275027, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "F90": { + "valid": 2775, + "positives": 6, + "negatives": 2769, + "auroc": 0.8919585891416877, + "auprc": 0.03504862685543015, + "brier": 0.002149310792954949, + "calibration": { + "observed_rate": 0.002162162162162162, + "mean_prediction": 0.0006156787537900954, + "calibration_in_the_large": -0.0015464834083720668, + "expected_calibration_error_10bin": 0.0015464834083720668, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "G25": { + "valid": 2774, + "positives": 4, + "negatives": 2770, + "auroc": 0.6879061371841155, + "auprc": 0.003857315249546797, + "brier": 0.0014477667914224864, + "calibration": { + "observed_rate": 0.0014419610670511895, + "mean_prediction": 0.002165596042979412, + "calibration_in_the_large": 0.0007236349759282223, + "expected_calibration_error_10bin": 0.0007236349759282223, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "G31": { + "valid": 2802, + "positives": 1, + "negatives": 2801, + "auroc": 0.6133523741520885, + "auprc": 0.0009225092250922509, + "brier": 0.00042154790164437416, + "calibration": { + "observed_rate": 0.00035688793718772306, + "mean_prediction": 0.0029445555888439577, + "calibration_in_the_large": 0.0025876676516562347, + "expected_calibration_error_10bin": 0.0025876676516562347, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "G40": { + "valid": 2723, + "positives": 17, + "negatives": 2706, + "auroc": 0.7555975827137951, + "auprc": 0.05132940346591923, + "brier": 0.006114599620689003, + "calibration": { + "observed_rate": 0.006243114212265883, + "mean_prediction": 0.004454409440079975, + "calibration_in_the_large": -0.0017887047721859076, + "expected_calibration_error_10bin": 0.002046255101538927, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "G43": { + "valid": 2725, + "positives": 11, + "negatives": 2714, + "auroc": 0.7597306893548603, + "auprc": 0.013080706309705347, + "brier": 0.004015267453316172, + "calibration": { + "observed_rate": 0.004036697247706422, + "mean_prediction": 0.002119679084948025, + "calibration_in_the_large": -0.001917018162758397, + "expected_calibration_error_10bin": 0.001917018162758397, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + "G44": { + "valid": 2805, + "positives": 3, + "negatives": 2802, + "auroc": 0.7532714727575541, + "auprc": 0.006211561030576389, + "brier": 0.0010720111703934009, + "calibration": { + "observed_rate": 0.0010695187165775401, + "mean_prediction": 0.0011507437460364378, + "calibration_in_the_large": 8.122502945889765e-05, + "expected_calibration_error_10bin": 8.122502945889765e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "G47": { + "valid": 2315, + "positives": 59, + "negatives": 2256, + "auroc": 0.7060343791321072, + "auprc": 0.06439835680330692, + "brier": 0.02449867511984189, + "calibration": { + "observed_rate": 0.025485961123110152, + "mean_prediction": 0.01972227887477782, + "calibration_in_the_large": -0.005763682248332333, + "expected_calibration_error_10bin": 0.006801482154857005, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + "G51": { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 2.9814054497279024e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0003550959981283473, + "calibration_in_the_large": 0.0003550959981283473, + "expected_calibration_error_10bin": 0.0003550959981283473, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + "G62": { + "valid": 2751, + "positives": 23, + "negatives": 2728, + "auroc": 0.8722427642483743, + "auprc": 0.129766039221253, + "brier": 0.007846906491515024, + "calibration": { + "observed_rate": 0.008360596146855689, + "mean_prediction": 0.005407722733927505, + "calibration_in_the_large": -0.002952873412928184, + "expected_calibration_error_10bin": 0.003099137729572994, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "G81": { + "valid": 2789, + "positives": 10, + "negatives": 2779, + "auroc": 0.780820439006837, + "auprc": 0.02632436111162509, + "brier": 0.003563538344847712, + "calibration": { + "observed_rate": 0.0035855145213338113, + "mean_prediction": 0.0018583895414626993, + "calibration_in_the_large": -0.001727124979871112, + "expected_calibration_error_10bin": 0.001727124979871112, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "G83": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.7455984875339714, + "auprc": 0.004832919736278336, + "brier": 0.0010631760391573443, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0009325635064747062, + "calibration_in_the_large": -0.00012975943970093128, + "expected_calibration_error_10bin": 0.00012975943970093128, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "G89": { + "valid": 2537, + "positives": 37, + "negatives": 2500, + "auroc": 0.7708324324324324, + "auprc": 0.07384557315717628, + "brier": 0.014161670030902348, + "calibration": { + "observed_rate": 0.014584154513204573, + "mean_prediction": 0.019852161642251544, + "calibration_in_the_large": 0.005268007129046971, + "expected_calibration_error_10bin": 0.005308688826225573, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + "G90": { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 6.027206851415448e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0012819829474779681, + "calibration_in_the_large": 0.0012819829474779681, + "expected_calibration_error_10bin": 0.0012819829474779681, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "G92": { + "valid": 2733, + "positives": 24, + "negatives": 2709, + "auroc": 0.7621354743447767, + "auprc": 0.025695796035518387, + "brier": 0.008866170508387563, + "calibration": { + "observed_rate": 0.008781558726673985, + "mean_prediction": 0.013162796799003352, + "calibration_in_the_large": 0.004381238072329367, + "expected_calibration_error_10bin": 0.004381238072329366, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "G93": { + "valid": 2656, + "positives": 31, + "negatives": 2625, + "auroc": 0.7873794162826421, + "auprc": 0.04070643066905817, + "brier": 0.011391147110152725, + "calibration": { + "observed_rate": 0.011671686746987951, + "mean_prediction": 0.010742368983345107, + "calibration_in_the_large": -0.0009293177636428441, + "expected_calibration_error_10bin": 0.0016489448598146833, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + "G99": { + "valid": 2841, + "positives": 0, + "negatives": 2841, + "auroc": null, + "auprc": null, + "brier": 5.744917787986795e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0002935493583768152, + "calibration_in_the_large": 0.0002935493583768152, + "expected_calibration_error_10bin": 0.0002935493583768152, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9992965177629265 + }, + "H10": { + "valid": 2832, + "positives": 4, + "negatives": 2828, + "auroc": 0.9077086280056577, + "auprc": 0.01649921056365993, + "brier": 0.001407675347484286, + "calibration": { + "observed_rate": 0.0014124293785310734, + "mean_prediction": 0.0006358431691338965, + "calibration_in_the_large": -0.0007765862093971769, + "expected_calibration_error_10bin": 0.0007765862093971769, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "H26": { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 3.263242337200269e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00100104767202033, + "calibration_in_the_large": 0.00100104767202033, + "expected_calibration_error_10bin": 0.00100104767202033, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "H35": { + "valid": 2806, + "positives": 4, + "negatives": 2802, + "auroc": 0.6557815845824411, + "auprc": 0.004026200553694501, + "brier": 0.001425194703652775, + "calibration": { + "observed_rate": 0.0014255167498218105, + "mean_prediction": 0.0005499791525019316, + "calibration_in_the_large": -0.0008755375973198789, + "expected_calibration_error_10bin": 0.0008755375973198789, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "H40": { + "valid": 2750, + "positives": 5, + "negatives": 2745, + "auroc": 0.7596357012750455, + "auprc": 0.013634728226702022, + "brier": 0.0018326951876388084, + "calibration": { + "observed_rate": 0.0018181818181818182, + "mean_prediction": 0.002967355977544106, + "calibration_in_the_large": 0.0011491741593622879, + "expected_calibration_error_10bin": 0.0011491741593622879, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "H53": { + "valid": 2790, + "positives": 8, + "negatives": 2782, + "auroc": 0.6062185478073329, + "auprc": 0.009255757211928199, + "brier": 0.002860818474494734, + "calibration": { + "observed_rate": 0.002867383512544803, + "mean_prediction": 0.003285573033877151, + "calibration_in_the_large": 0.0004181895213323482, + "expected_calibration_error_10bin": 0.0004181895213323482, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "H54": { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.41913074456715355, + "auprc": 0.0008971363312738618, + "brier": 0.0007232072410049116, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0017832213711011266, + "calibration_in_the_large": 0.0010712242190897346, + "expected_calibration_error_10bin": 0.0010712242190897346, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "H91": { + "valid": 2791, + "positives": 5, + "negatives": 2786, + "auroc": 0.7382627422828428, + "auprc": 0.007855239912526854, + "brier": 0.001786595691533572, + "calibration": { + "observed_rate": 0.0017914725904693658, + "mean_prediction": 0.0016990428792087251, + "calibration_in_the_large": -9.242971126064065e-05, + "expected_calibration_error_10bin": 9.242971126064065e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + "I07": { + "valid": 2823, + "positives": 4, + "negatives": 2819, + "auroc": 0.882493792124867, + "auprc": 0.008207574006945627, + "brier": 0.0014180819487550167, + "calibration": { + "observed_rate": 0.0014169323414806943, + "mean_prediction": 0.0007190732099971347, + "calibration_in_the_large": -0.0006978591314835596, + "expected_calibration_error_10bin": 0.0006978591314835596, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "I08": { + "valid": 2767, + "positives": 8, + "negatives": 2759, + "auroc": 0.8631750634287786, + "auprc": 0.018927897684757684, + "brier": 0.0030052481328057172, + "calibration": { + "observed_rate": 0.0028912179255511385, + "mean_prediction": 0.005107413086438693, + "calibration_in_the_large": 0.0022161951608875544, + "expected_calibration_error_10bin": 0.002216195160887554, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + "I10": { + "valid": 1498, + "positives": 27, + "negatives": 1471, + "auroc": 0.6692096583327038, + "auprc": 0.05059163307629828, + "brier": 0.017586066612314998, + "calibration": { + "observed_rate": 0.018024032042723633, + "mean_prediction": 0.013015500295320365, + "calibration_in_the_large": -0.005008531747403268, + "expected_calibration_error_10bin": 0.006373425869169199, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + "I11": { + "valid": 2676, + "positives": 27, + "negatives": 2649, + "auroc": 0.8160451882611188, + "auprc": 0.03694384925802748, + "brier": 0.009956141070086102, + "calibration": { + "observed_rate": 0.010089686098654708, + "mean_prediction": 0.00797280529756623, + "calibration_in_the_large": -0.0021168808010884783, + "expected_calibration_error_10bin": 0.002994037515553174, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + "I12": { + "valid": 2552, + "positives": 16, + "negatives": 2536, + "auroc": 0.797910094637224, + "auprc": 0.03215454936693705, + "brier": 0.006235166169214403, + "calibration": { + "observed_rate": 0.006269592476489028, + "mean_prediction": 0.004271152281023625, + "calibration_in_the_large": -0.001998440195465403, + "expected_calibration_error_10bin": 0.0029788021470680674, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + "I13": { + "valid": 2727, + "positives": 16, + "negatives": 2711, + "auroc": 0.8551733677609739, + "auprc": 0.05262847562697052, + "brier": 0.005799247135756655, + "calibration": { + "observed_rate": 0.005867253392005867, + "mean_prediction": 0.006565176132503507, + "calibration_in_the_large": 0.0006979227404976399, + "expected_calibration_error_10bin": 0.0014655693452812965, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + "I16": { + "valid": 2390, + "positives": 7, + "negatives": 2383, + "auroc": 0.8790839877705173, + "auprc": 0.02483530084204844, + "brier": 0.00290390055630264, + "calibration": { + "observed_rate": 0.0029288702928870294, + "mean_prediction": 0.001493726641998958, + "calibration_in_the_large": -0.0014351436508880714, + "expected_calibration_error_10bin": 0.0014351436508880714, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + "I21": { + "valid": 2671, + "positives": 9, + "negatives": 2662, + "auroc": 0.8408882210535104, + "auprc": 0.026475284515623202, + "brier": 0.003454927632779338, + "calibration": { + "observed_rate": 0.0033695245226506927, + "mean_prediction": 0.008350546298066879, + "calibration_in_the_large": 0.0049810217754161865, + "expected_calibration_error_10bin": 0.0049810217754161865, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "I24": { + "valid": 2809, + "positives": 3, + "negatives": 2806, + "auroc": 0.9419101924447613, + "auprc": 0.019091183868216805, + "brier": 0.0010610262373717564, + "calibration": { + "observed_rate": 0.001067995728017088, + "mean_prediction": 0.0011977989143543998, + "calibration_in_the_large": 0.00012980318633731185, + "expected_calibration_error_10bin": 0.00012980318633731185, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "I25": { + "valid": 2243, + "positives": 28, + "negatives": 2215, + "auroc": 0.8196549500161239, + "auprc": 0.05146088034407916, + "brier": 0.012112560535699647, + "calibration": { + "observed_rate": 0.012483281319661168, + "mean_prediction": 0.00997222979837257, + "calibration_in_the_large": -0.0025110515212885976, + "expected_calibration_error_10bin": 0.0031015428055199863, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + "I26": { + "valid": 2760, + "positives": 13, + "negatives": 2747, + "auroc": 0.7675786172327854, + "auprc": 0.13135844504242072, + "brier": 0.004559626615036148, + "calibration": { + "observed_rate": 0.004710144927536232, + "mean_prediction": 0.004311854818893218, + "calibration_in_the_large": -0.0003982901086430138, + "expected_calibration_error_10bin": 0.0003982901086430138, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + "I27": { + "valid": 2716, + "positives": 19, + "negatives": 2697, + "auroc": 0.8233319672930937, + "auprc": 0.026851829787877087, + "brier": 0.006962260386466818, + "calibration": { + "observed_rate": 0.006995581737849779, + "mean_prediction": 0.00619928954086354, + "calibration_in_the_large": -0.0007962921969862395, + "expected_calibration_error_10bin": 0.0016220598450921832, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I31": { + "valid": 2793, + "positives": 9, + "negatives": 2784, + "auroc": 0.874161877394636, + "auprc": 0.12603926686125766, + "brier": 0.003178185318852675, + "calibration": { + "observed_rate": 0.00322234156820623, + "mean_prediction": 0.0024079226976228304, + "calibration_in_the_large": -0.0008144188705833996, + "expected_calibration_error_10bin": 0.0008144188705833996, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I34": { + "valid": 2753, + "positives": 13, + "negatives": 2740, + "auroc": 0.7258001122964627, + "auprc": 0.011800478757468435, + "brier": 0.00474106004707155, + "calibration": { + "observed_rate": 0.00472212132219397, + "mean_prediction": 0.0032350854622643877, + "calibration_in_the_large": -0.0014870358599295827, + "expected_calibration_error_10bin": 0.00168797690902526, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + "I35": { + "valid": 2723, + "positives": 5, + "negatives": 2718, + "auroc": 0.7306107431935247, + "auprc": 0.008908991768241288, + "brier": 0.0018741286373060912, + "calibration": { + "observed_rate": 0.001836210062431142, + "mean_prediction": 0.0029561896073865656, + "calibration_in_the_large": 0.0011199795449554236, + "expected_calibration_error_10bin": 0.0011199795449554231, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "I42": { + "valid": 2740, + "positives": 8, + "negatives": 2732, + "auroc": 0.9199304538799414, + "auprc": 0.07496824959535464, + "brier": 0.002852275611349781, + "calibration": { + "observed_rate": 0.00291970802919708, + "mean_prediction": 0.0028461902925626115, + "calibration_in_the_large": -7.351773663446864e-05, + "expected_calibration_error_10bin": 0.00014720327174864612, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "I44": { + "valid": 2722, + "positives": 13, + "negatives": 2709, + "auroc": 0.8834085810829997, + "auprc": 0.06956921890573158, + "brier": 0.004641626157184625, + "calibration": { + "observed_rate": 0.004775900073475386, + "mean_prediction": 0.005763175328552643, + "calibration_in_the_large": 0.0009872752550772572, + "expected_calibration_error_10bin": 0.0009872752550772578, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + "I45": { + "valid": 2766, + "positives": 7, + "negatives": 2759, + "auroc": 0.7407445761922021, + "auprc": 0.15512797341486148, + "brier": 0.0025152734312416727, + "calibration": { + "observed_rate": 0.0025307302964569776, + "mean_prediction": 0.004612468342832854, + "calibration_in_the_large": 0.0020817380463758763, + "expected_calibration_error_10bin": 0.0020817380463758763, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + "I46": { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.4901060070671378, + "auprc": 0.0006925207756232687, + "brier": 0.0003603029450206072, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.001383196666110451, + "calibration_in_the_large": 0.0010299645926381798, + "expected_calibration_error_10bin": 0.0010299645926381798, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I47": { + "valid": 2716, + "positives": 8, + "negatives": 2708, + "auroc": 0.6870845642540621, + "auprc": 0.0067603256692587745, + "brier": 0.002967279668585019, + "calibration": { + "observed_rate": 0.0029455081001472753, + "mean_prediction": 0.005449357258505016, + "calibration_in_the_large": 0.002503849158357741, + "expected_calibration_error_10bin": 0.002503849158357741, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I48": { + "valid": 2385, + "positives": 17, + "negatives": 2368, + "auroc": 0.7792378775834659, + "auprc": 0.021071838006305785, + "brier": 0.007088996792272469, + "calibration": { + "observed_rate": 0.007127882599580713, + "mean_prediction": 0.007381354279638477, + "calibration_in_the_large": 0.00025347168005776435, + "expected_calibration_error_10bin": 0.00025347168005776435, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + "I49": { + "valid": 2734, + "positives": 10, + "negatives": 2724, + "auroc": 0.786784140969163, + "auprc": 0.010864949128329388, + "brier": 0.0036370775485256475, + "calibration": { + "observed_rate": 0.0036576444769568397, + "mean_prediction": 0.002676194169716218, + "calibration_in_the_large": -0.0009814503072406219, + "expected_calibration_error_10bin": 0.0009814503072406219, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I50": { + "valid": 2415, + "positives": 31, + "negatives": 2384, + "auroc": 0.7973587356570686, + "auprc": 0.05232169277523121, + "brier": 0.012722882566080469, + "calibration": { + "observed_rate": 0.012836438923395446, + "mean_prediction": 0.012080321235148506, + "calibration_in_the_large": -0.0007561176882469392, + "expected_calibration_error_10bin": 0.004474259156168666, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + "I51": { + "valid": 2807, + "positives": 5, + "negatives": 2802, + "auroc": 0.8460385438972162, + "auprc": 0.007788677051687622, + "brier": 0.0017754800813692916, + "calibration": { + "observed_rate": 0.0017812611328820805, + "mean_prediction": 0.0014693090818070017, + "calibration_in_the_large": -0.00031195205107507873, + "expected_calibration_error_10bin": 0.00031195205107507873, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "I61": { + "valid": 2802, + "positives": 5, + "negatives": 2797, + "auroc": 0.8119413657490168, + "auprc": 0.006603733046504875, + "brier": 0.0017817040692911358, + "calibration": { + "observed_rate": 0.0017844396859386152, + "mean_prediction": 0.0005609203055634663, + "calibration_in_the_large": -0.001223519380375149, + "expected_calibration_error_10bin": 0.001223519380375149, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "I63": { + "valid": 2735, + "positives": 9, + "negatives": 2726, + "auroc": 0.7954267547077525, + "auprc": 0.019795064536387245, + "brier": 0.0032868251425216366, + "calibration": { + "observed_rate": 0.0032906764168190127, + "mean_prediction": 0.0033159192267487323, + "calibration_in_the_large": 2.524280992971962e-05, + "expected_calibration_error_10bin": 0.0001858646703129382, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + "I65": { + "valid": 2774, + "positives": 3, + "negatives": 2771, + "auroc": 0.735474557921328, + "auprc": 0.025316194152646552, + "brier": 0.0010794404993334018, + "calibration": { + "observed_rate": 0.0010814708002883922, + "mean_prediction": 0.0017468872121272215, + "calibration_in_the_large": 0.0006654164118388294, + "expected_calibration_error_10bin": 0.0006654164118388294, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "I67": { + "valid": 2773, + "positives": 2, + "negatives": 2771, + "auroc": 0.865211115120895, + "auprc": 0.004044117647058823, + "brier": 0.0007367179629506115, + "calibration": { + "observed_rate": 0.000721240533717995, + "mean_prediction": 0.001948306488843885, + "calibration_in_the_large": 0.0012270659551258901, + "expected_calibration_error_10bin": 0.0012270659551258901, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "I69": { + "valid": 2752, + "positives": 14, + "negatives": 2738, + "auroc": 0.7587916101429615, + "auprc": 0.01592417414747963, + "brier": 0.005089311289338121, + "calibration": { + "observed_rate": 0.005087209302325582, + "mean_prediction": 0.005162467144841262, + "calibration_in_the_large": 7.525784251568007e-05, + "expected_calibration_error_10bin": 0.0001548050566424172, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + "I70": { + "valid": 2771, + "positives": 5, + "negatives": 2766, + "auroc": 0.840997830802603, + "auprc": 0.017879794259325277, + "brier": 0.0017924869233589735, + "calibration": { + "observed_rate": 0.001804402742692169, + "mean_prediction": 0.0016496977232988153, + "calibration_in_the_large": -0.00015470501939335367, + "expected_calibration_error_10bin": 0.00015470501939335367, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + "I71": { + "valid": 2769, + "positives": 3, + "negatives": 2766, + "auroc": 0.6763075439865027, + "auprc": 0.004215514087083791, + "brier": 0.0010869980200127, + "calibration": { + "observed_rate": 0.0010834236186348862, + "mean_prediction": 0.0015558687681111298, + "calibration_in_the_large": 0.0004724451494762436, + "expected_calibration_error_10bin": 0.0004724451494762436, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + "I72": { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.774120156416637, + "auprc": 0.010043003351960733, + "brier": 0.0017698684655364325, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0008790055528595603, + "calibration_in_the_large": -0.0008953024670126894, + "expected_calibration_error_10bin": 0.0008953024670126894, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "I73": { + "valid": 2734, + "positives": 6, + "negatives": 2728, + "auroc": 0.823069403714565, + "auprc": 0.05518709411105036, + "brier": 0.0021530496429321105, + "calibration": { + "observed_rate": 0.0021945866861741038, + "mean_prediction": 0.0015471687700419146, + "calibration_in_the_large": -0.0006474179161321892, + "expected_calibration_error_10bin": 0.0006474179161321892, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I74": { + "valid": 2821, + "positives": 4, + "negatives": 2817, + "auroc": 0.5457933972310969, + "auprc": 0.003089319518566047, + "brier": 0.0014171270095652494, + "calibration": { + "observed_rate": 0.0014179369018078695, + "mean_prediction": 0.0005397213958684351, + "calibration_in_the_large": -0.0008782155059394345, + "expected_calibration_error_10bin": 0.0008782155059394345, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "I77": { + "valid": 2785, + "positives": 3, + "negatives": 2782, + "auroc": 0.6506110711718188, + "auprc": 0.004447328097298134, + "brier": 0.001078691241716167, + "calibration": { + "observed_rate": 0.0010771992818671453, + "mean_prediction": 0.0014235096124682828, + "calibration_in_the_large": 0.00034631033060113746, + "expected_calibration_error_10bin": 0.00034631033060113746, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "I80": { + "valid": 2827, + "positives": 4, + "negatives": 2823, + "auroc": 0.8844314558979809, + "auprc": 0.08937766507315904, + "brier": 0.0013904054541916766, + "calibration": { + "observed_rate": 0.0014149274849663955, + "mean_prediction": 0.0008147075568127547, + "calibration_in_the_large": -0.0006002199281536408, + "expected_calibration_error_10bin": 0.0006002199281536408, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "I81": { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8328961361219426, + "auprc": 0.014227364041754967, + "brier": 0.0018026584077234676, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.001393446456282838, + "calibration_in_the_large": -0.0003758387524928166, + "expected_calibration_error_10bin": 0.0007769261899585086, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I82": { + "valid": 2739, + "positives": 20, + "negatives": 2719, + "auroc": 0.6945384332475175, + "auprc": 0.026693749522900417, + "brier": 0.0072674044945979475, + "calibration": { + "observed_rate": 0.007301935012778387, + "mean_prediction": 0.007090782937393569, + "calibration_in_the_large": -0.00021115207538481735, + "expected_calibration_error_10bin": 0.000768139141338631, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "I85": { + "valid": 2793, + "positives": 4, + "negatives": 2789, + "auroc": 0.9931875224094657, + "auprc": 0.1638167388167388, + "brier": 0.0014181689372041587, + "calibration": { + "observed_rate": 0.0014321518080916578, + "mean_prediction": 0.0013087376664016343, + "calibration_in_the_large": -0.0001234141416900235, + "expected_calibration_error_10bin": 0.001523975069761476, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I87": { + "valid": 2780, + "positives": 11, + "negatives": 2769, + "auroc": 0.722183919367018, + "auprc": 0.010559629870039416, + "brier": 0.003945569951530942, + "calibration": { + "observed_rate": 0.003956834532374101, + "mean_prediction": 0.003180192808783739, + "calibration_in_the_large": -0.0007766417235903619, + "expected_calibration_error_10bin": 0.0007766417235903619, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "I89": { + "valid": 2826, + "positives": 4, + "negatives": 2822, + "auroc": 0.8229978738483346, + "auprc": 0.007437508683444479, + "brier": 0.0014130706928639602, + "calibration": { + "observed_rate": 0.0014154281670205238, + "mean_prediction": 0.00042488408557695247, + "calibration_in_the_large": -0.0009905440814435714, + "expected_calibration_error_10bin": 0.0009905440814435714, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I95": { + "valid": 2485, + "positives": 52, + "negatives": 2433, + "auroc": 0.7155774763666256, + "auprc": 0.04578349360518612, + "brier": 0.02036860822787765, + "calibration": { + "observed_rate": 0.020925553319919517, + "mean_prediction": 0.022242206085676616, + "calibration_in_the_large": 0.0013166527657570981, + "expected_calibration_error_10bin": 0.0013166527657570994, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + "I96": { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.864166961443226, + "auprc": 0.04877498340154199, + "brier": 0.001398463979374219, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0009950430244751833, + "calibration_in_the_large": -0.0004178852694139018, + "expected_calibration_error_10bin": 0.0004178852694139018, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I97": { + "valid": 2740, + "positives": 7, + "negatives": 2733, + "auroc": 0.802937640478804, + "auprc": 0.011988397634680476, + "brier": 0.0025425654541593548, + "calibration": { + "observed_rate": 0.0025547445255474453, + "mean_prediction": 0.0021283959890798627, + "calibration_in_the_large": -0.0004263485364675826, + "expected_calibration_error_10bin": 0.0004263485364675826, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "J02": { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.628409493446688, + "auprc": 0.0013932413363388128, + "brier": 0.0007123517137812846, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0010363124156694248, + "calibration_in_the_large": 0.0003283478138995133, + "expected_calibration_error_10bin": 0.0003283478138995133, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J06": { + "valid": 2816, + "positives": 6, + "negatives": 2810, + "auroc": 0.6797153024911032, + "auprc": 0.007657504339512056, + "brier": 0.0021515372541160583, + "calibration": { + "observed_rate": 0.002130681818181818, + "mean_prediction": 0.0020396966051547142, + "calibration_in_the_large": -9.09852130271038e-05, + "expected_calibration_error_10bin": 0.0002579961894520526, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "J12": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 2.3607274129797302e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0015830240183197326, + "calibration_in_the_large": 0.0015830240183197326, + "expected_calibration_error_10bin": 0.0015830240183197326, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J15": { + "valid": 2795, + "positives": 9, + "negatives": 2786, + "auroc": 0.7954454813751296, + "auprc": 0.01842319314497788, + "brier": 0.0032424073210247954, + "calibration": { + "observed_rate": 0.0032200357781753132, + "mean_prediction": 0.004066128657491626, + "calibration_in_the_large": 0.0008460928793163126, + "expected_calibration_error_10bin": 0.000846092879316313, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + "J18": { + "valid": 2671, + "positives": 27, + "negatives": 2644, + "auroc": 0.7770773799518126, + "auprc": 0.037987103453590666, + "brier": 0.010066221746932608, + "calibration": { + "observed_rate": 0.010108573567952079, + "mean_prediction": 0.012501942523547364, + "calibration_in_the_large": 0.002393368955595285, + "expected_calibration_error_10bin": 0.0023933689555952877, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "J30": { + "valid": 2815, + "positives": 3, + "negatives": 2812, + "auroc": 0.825154101469891, + "auprc": 0.08567614887939946, + "brier": 0.0010538644785540706, + "calibration": { + "observed_rate": 0.0010657193605683837, + "mean_prediction": 0.0020173101395445704, + "calibration_in_the_large": 0.0009515907789761867, + "expected_calibration_error_10bin": 0.0009515907789761867, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "J32": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.5173328616908384, + "auprc": 0.0025829266888467463, + "brier": 0.0007136869253332894, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0007516678281442242, + "calibration_in_the_large": 4.470423676918001e-05, + "expected_calibration_error_10bin": 4.470423676918001e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J38": { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.6824300389656394, + "auprc": 0.0021237497599024165, + "brier": 0.0007107227062381372, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0009941246837038347, + "calibration_in_the_large": 0.0002861600819339232, + "expected_calibration_error_10bin": 0.0002861600819339232, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J43": { + "valid": 2804, + "positives": 5, + "negatives": 2799, + "auroc": 0.5691318327974276, + "auprc": 0.002684614071607653, + "brier": 0.0017867186884919584, + "calibration": { + "observed_rate": 0.001783166904422254, + "mean_prediction": 0.0010624328829050998, + "calibration_in_the_large": -0.0007207340215171542, + "expected_calibration_error_10bin": 0.0007207340215171542, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "J44": { + "valid": 2570, + "positives": 16, + "negatives": 2554, + "auroc": 0.8258858653093187, + "auprc": 0.03238467187142304, + "brier": 0.006129587078211112, + "calibration": { + "observed_rate": 0.0062256809338521405, + "mean_prediction": 0.004344050397490358, + "calibration_in_the_large": -0.0018816305363617827, + "expected_calibration_error_10bin": 0.0018816305363617827, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + "J45": { + "valid": 2518, + "positives": 19, + "negatives": 2499, + "auroc": 0.6801457425075293, + "auprc": 0.017765799151194653, + "brier": 0.007483607690952645, + "calibration": { + "observed_rate": 0.007545671167593328, + "mean_prediction": 0.004786240078779873, + "calibration_in_the_large": -0.0027594310888134554, + "expected_calibration_error_10bin": 0.0027594310888134554, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + "J47": { + "valid": 2825, + "positives": 3, + "negatives": 2822, + "auroc": 0.876210725253957, + "auprc": 0.00562815184968394, + "brier": 0.0010612298321759557, + "calibration": { + "observed_rate": 0.0010619469026548673, + "mean_prediction": 0.0004759683769691391, + "calibration_in_the_large": -0.0005859785256857283, + "expected_calibration_error_10bin": 0.0005859785256857283, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J69": { + "valid": 2777, + "positives": 21, + "negatives": 2756, + "auroc": 0.7893600110581243, + "auprc": 0.03575410241315741, + "brier": 0.007442994915101671, + "calibration": { + "observed_rate": 0.007562117392870004, + "mean_prediction": 0.006887975899730487, + "calibration_in_the_large": -0.0006741414931395167, + "expected_calibration_error_10bin": 0.000674141493139516, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "J81": { + "valid": 2781, + "positives": 12, + "negatives": 2769, + "auroc": 0.7193932827735645, + "auprc": 0.01924033763935933, + "brier": 0.004283556402101984, + "calibration": { + "observed_rate": 0.004314994606256742, + "mean_prediction": 0.0021812347456375432, + "calibration_in_the_large": -0.0021337598606191986, + "expected_calibration_error_10bin": 0.0021337598606191986, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "J84": { + "valid": 2817, + "positives": 5, + "negatives": 2812, + "auroc": 0.9497866287339971, + "auprc": 0.04201741680439204, + "brier": 0.0017615192568090471, + "calibration": { + "observed_rate": 0.001774937877174299, + "mean_prediction": 0.0008334341924711168, + "calibration_in_the_large": -0.0009415036847031822, + "expected_calibration_error_10bin": 0.0009415036847031822, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "J90": { + "valid": 2754, + "positives": 22, + "negatives": 2732, + "auroc": 0.6772427791827499, + "auprc": 0.014806870195506555, + "brier": 0.0080015272846681, + "calibration": { + "observed_rate": 0.007988380537400145, + "mean_prediction": 0.007025234004192307, + "calibration_in_the_large": -0.0009631465332078379, + "expected_calibration_error_10bin": 0.0016440255892286846, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + "J91": { + "valid": 2807, + "positives": 7, + "negatives": 2800, + "auroc": 0.8266836734693878, + "auprc": 0.08928221409707725, + "brier": 0.0024270969174221774, + "calibration": { + "observed_rate": 0.0024937655860349127, + "mean_prediction": 0.0024745083290185605, + "calibration_in_the_large": -1.9257257016352166e-05, + "expected_calibration_error_10bin": 0.00021301417636985777, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "J94": { + "valid": 2829, + "positives": 5, + "negatives": 2824, + "auroc": 0.6208923512747876, + "auprc": 0.005281533629606827, + "brier": 0.001769896222424762, + "calibration": { + "observed_rate": 0.0017674089784376105, + "mean_prediction": 0.0007703073036183451, + "calibration_in_the_large": -0.0009971016748192654, + "expected_calibration_error_10bin": 0.0009971016748192654, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J95": { + "valid": 2770, + "positives": 11, + "negatives": 2759, + "auroc": 0.8017068107680648, + "auprc": 0.02626401419197867, + "brier": 0.003924741998768582, + "calibration": { + "observed_rate": 0.003971119133574007, + "mean_prediction": 0.0032203967618347914, + "calibration_in_the_large": -0.0007507223717392159, + "expected_calibration_error_10bin": 0.0007507223717392159, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + "J96": { + "valid": 2605, + "positives": 42, + "negatives": 2563, + "auroc": 0.8413317726622448, + "auprc": 0.06895860378272528, + "brier": 0.015600320637220404, + "calibration": { + "observed_rate": 0.016122840690978888, + "mean_prediction": 0.015762069597414646, + "calibration_in_the_large": -0.0003607710935642425, + "expected_calibration_error_10bin": 0.0025945926018583463, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + "J98": { + "valid": 2692, + "positives": 20, + "negatives": 2672, + "auroc": 0.7220059880239521, + "auprc": 0.030373536756634352, + "brier": 0.007339500579860035, + "calibration": { + "observed_rate": 0.007429420505200594, + "mean_prediction": 0.006940311790336882, + "calibration_in_the_large": -0.0004891087148637119, + "expected_calibration_error_10bin": 0.0004891087148637119, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + "K04": { + "valid": 2836, + "positives": 1, + "negatives": 2835, + "auroc": 0.9322751322751323, + "auprc": 0.0051813471502590676, + "brier": 0.0003526697654475311, + "calibration": { + "observed_rate": 0.0003526093088857546, + "mean_prediction": 0.0004319392043250839, + "calibration_in_the_large": 7.932989543932935e-05, + "expected_calibration_error_10bin": 7.932989543932935e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "K12": { + "valid": 2824, + "positives": 9, + "negatives": 2815, + "auroc": 0.8602723505032563, + "auprc": 0.07041282542644937, + "brier": 0.0033461185366774593, + "calibration": { + "observed_rate": 0.003186968838526912, + "mean_prediction": 0.003297151030337979, + "calibration_in_the_large": 0.00011018219181106693, + "expected_calibration_error_10bin": 0.002707124697373069, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K20": { + "valid": 2813, + "positives": 4, + "negatives": 2809, + "auroc": 0.6266464934140263, + "auprc": 0.04335591984849321, + "brier": 0.0014539435049404014, + "calibration": { + "observed_rate": 0.0014219694276573053, + "mean_prediction": 0.004020892347001942, + "calibration_in_the_large": 0.0025989229193446365, + "expected_calibration_error_10bin": 0.0025989229193446365, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K21": { + "valid": 2043, + "positives": 52, + "negatives": 1991, + "auroc": 0.7601514507591856, + "auprc": 0.1019000726797951, + "brier": 0.02399563065474201, + "calibration": { + "observed_rate": 0.025452765540871267, + "mean_prediction": 0.026387370266617475, + "calibration_in_the_large": 0.0009346047257462083, + "expected_calibration_error_10bin": 0.0021277081942285116, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + "K22": { + "valid": 2764, + "positives": 9, + "negatives": 2755, + "auroc": 0.7635813672111312, + "auprc": 0.022508690047564405, + "brier": 0.0032257065710135967, + "calibration": { + "observed_rate": 0.003256150506512301, + "mean_prediction": 0.0032571524071182676, + "calibration_in_the_large": 1.001900605966579e-06, + "expected_calibration_error_10bin": 1.001900605966579e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + "K25": { + "valid": 2817, + "positives": 5, + "negatives": 2812, + "auroc": 0.8810810810810811, + "auprc": 0.01191661193007099, + "brier": 0.0017941289836131918, + "calibration": { + "observed_rate": 0.001774937877174299, + "mean_prediction": 0.0023376981636747435, + "calibration_in_the_large": 0.0005627602865004445, + "expected_calibration_error_10bin": 0.0005627602865004448, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "K26": { + "valid": 2814, + "positives": 3, + "negatives": 2811, + "auroc": 0.8948179769951381, + "auprc": 0.01072960111703089, + "brier": 0.0010624793687590978, + "calibration": { + "observed_rate": 0.0010660980810234541, + "mean_prediction": 0.0011862154240998828, + "calibration_in_the_large": 0.00012011734307642869, + "expected_calibration_error_10bin": 0.00012011734307642869, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "K29": { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.8884394102840705, + "auprc": 0.030739645386085198, + "brier": 0.0014575889646033327, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.005518757849958887, + "calibration_in_the_large": 0.004082492140802693, + "expected_calibration_error_10bin": 0.004082492140802693, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K30": { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.9298059964726632, + "auprc": 0.007270520171496461, + "brier": 0.0007059466564950993, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0009136722731759171, + "calibration_in_the_large": 0.00020870223440256502, + "expected_calibration_error_10bin": 0.00020870223440256502, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "K31": { + "valid": 2756, + "positives": 8, + "negatives": 2748, + "auroc": 0.9299945414847162, + "auprc": 0.05455057823405132, + "brier": 0.0028347448224550834, + "calibration": { + "observed_rate": 0.002902757619738752, + "mean_prediction": 0.0037892296655173347, + "calibration_in_the_large": 0.0008864720457785829, + "expected_calibration_error_10bin": 0.000978724302081354, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "K40": { + "valid": 2827, + "positives": 1, + "negatives": 2826, + "auroc": 0.8789808917197452, + "auprc": 0.0029154518950437317, + "brier": 0.0003542124941861684, + "calibration": { + "observed_rate": 0.00035373187124159886, + "mean_prediction": 0.0008825609289600014, + "calibration_in_the_large": 0.0005288290577184025, + "expected_calibration_error_10bin": 0.0005288290577184025, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "K42": { + "valid": 2820, + "positives": 3, + "negatives": 2817, + "auroc": 0.6846527038220329, + "auprc": 0.005508177841501218, + "brier": 0.0010674037300246676, + "calibration": { + "observed_rate": 0.0010638297872340426, + "mean_prediction": 0.0007120439127979904, + "calibration_in_the_large": -0.0003517858744360522, + "expected_calibration_error_10bin": 0.0003517858744360522, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "K43": { + "valid": 2813, + "positives": 4, + "negatives": 2809, + "auroc": 0.7733179067283731, + "auprc": 0.009462191840125372, + "brier": 0.0014199582139567924, + "calibration": { + "observed_rate": 0.0014219694276573053, + "mean_prediction": 0.0010541670204000308, + "calibration_in_the_large": -0.00036780240725727453, + "expected_calibration_error_10bin": 0.00036780240725727453, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K44": { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.5479144192736426, + "auprc": 0.0024031724056359244, + "brier": 0.001439754530853117, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.0017398178852812212, + "calibration_in_the_large": 0.0003035521761250272, + "expected_calibration_error_10bin": 0.0003035521761250272, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K52": { + "valid": 2749, + "positives": 23, + "negatives": 2726, + "auroc": 0.7892117770901783, + "auprc": 0.10714863654646878, + "brier": 0.008105243812675713, + "calibration": { + "observed_rate": 0.008366678792288106, + "mean_prediction": 0.007324037536524198, + "calibration_in_the_large": -0.0010426412557639078, + "expected_calibration_error_10bin": 0.0034441185677995347, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + "K55": { + "valid": 2815, + "positives": 7, + "negatives": 2808, + "auroc": 0.7956857956857957, + "auprc": 0.008983171579173539, + "brier": 0.0024911076206729976, + "calibration": { + "observed_rate": 0.002486678507992895, + "mean_prediction": 0.0017422896426927002, + "calibration_in_the_large": -0.0007443888653001949, + "expected_calibration_error_10bin": 0.0007443888653001949, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "K56": { + "valid": 2745, + "positives": 19, + "negatives": 2726, + "auroc": 0.7141753871104761, + "auprc": 0.026459129396209254, + "brier": 0.0068448773205373485, + "calibration": { + "observed_rate": 0.0069216757741347905, + "mean_prediction": 0.007965601940078658, + "calibration_in_the_large": 0.0010439261659438677, + "expected_calibration_error_10bin": 0.0010439261659438664, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + "K57": { + "valid": 2741, + "positives": 12, + "negatives": 2729, + "auroc": 0.6262367167460609, + "auprc": 0.0069704861427945354, + "brier": 0.004384325407091556, + "calibration": { + "observed_rate": 0.004377964246625319, + "mean_prediction": 0.002925200283559828, + "calibration_in_the_large": -0.0014527639630654908, + "expected_calibration_error_10bin": 0.0014527639630654908, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "K58": { + "valid": 2792, + "positives": 5, + "negatives": 2787, + "auroc": 0.6864011481880158, + "auprc": 0.010310126471674614, + "brier": 0.0017868324413175191, + "calibration": { + "observed_rate": 0.0017908309455587394, + "mean_prediction": 0.001261087132846513, + "calibration_in_the_large": -0.0005297438127122263, + "expected_calibration_error_10bin": 0.0005297438127122263, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "K59": { + "valid": 2560, + "positives": 67, + "negatives": 2493, + "auroc": 0.7548479024851674, + "auprc": 0.11195943577546588, + "brier": 0.024601580515367177, + "calibration": { + "observed_rate": 0.026171875, + "mean_prediction": 0.019334283456737468, + "calibration_in_the_large": -0.006837591543262533, + "expected_calibration_error_10bin": 0.006989016916304537, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "K62": { + "valid": 2813, + "positives": 8, + "negatives": 2805, + "auroc": 0.8479946524064171, + "auprc": 0.01194627001244646, + "brier": 0.0028286327408591698, + "calibration": { + "observed_rate": 0.0028439388553146107, + "mean_prediction": 0.0020011620497721034, + "calibration_in_the_large": -0.0008427768055425072, + "expected_calibration_error_10bin": 0.0008427768055425072, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K63": { + "valid": 2810, + "positives": 13, + "negatives": 2797, + "auroc": 0.7100739803635764, + "auprc": 0.010760975298711823, + "brier": 0.004610834139528854, + "calibration": { + "observed_rate": 0.004626334519572953, + "mean_prediction": 0.002466162239028194, + "calibration_in_the_large": -0.0021601722805447594, + "expected_calibration_error_10bin": 0.0021601722805447594, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "K64": { + "valid": 2801, + "positives": 11, + "negatives": 2790, + "auroc": 0.7955685891169763, + "auprc": 0.01270886237769951, + "brier": 0.003990156571366137, + "calibration": { + "observed_rate": 0.003927168868261335, + "mean_prediction": 0.0038540625690436175, + "calibration_in_the_large": -7.310629921771774e-05, + "expected_calibration_error_10bin": 0.0006859823716532568, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "K65": { + "valid": 2813, + "positives": 9, + "negatives": 2804, + "auroc": 0.8594864479315264, + "auprc": 0.02720891191025377, + "brier": 0.0032903962398114746, + "calibration": { + "observed_rate": 0.003199431212228937, + "mean_prediction": 0.005840303183337315, + "calibration_in_the_large": 0.0026408719711083777, + "expected_calibration_error_10bin": 0.002640871971108378, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K66": { + "valid": 2796, + "positives": 6, + "negatives": 2790, + "auroc": 0.7298685782556751, + "auprc": 0.0258215474281077, + "brier": 0.0021371459848367486, + "calibration": { + "observed_rate": 0.002145922746781116, + "mean_prediction": 0.0025309316585658695, + "calibration_in_the_large": 0.00038500891178475365, + "expected_calibration_error_10bin": 0.00038500891178475365, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "K70": { + "valid": 2774, + "positives": 1, + "negatives": 2773, + "auroc": 0.9487919221060224, + "auprc": 0.006993006993006993, + "brier": 0.0003680467396047394, + "calibration": { + "observed_rate": 0.0003604902667627974, + "mean_prediction": 0.0006240629107671329, + "calibration_in_the_large": 0.00026357264400433554, + "expected_calibration_error_10bin": 0.00026357264400433554, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "K72": { + "valid": 2787, + "positives": 13, + "negatives": 2774, + "auroc": 0.9458432699240198, + "auprc": 0.2408346819957726, + "brier": 0.004203761503143878, + "calibration": { + "observed_rate": 0.0046645138141370645, + "mean_prediction": 0.002448712766797046, + "calibration_in_the_large": -0.0022158010473400185, + "expected_calibration_error_10bin": 0.003089754653945891, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "K74": { + "valid": 2763, + "positives": 6, + "negatives": 2757, + "auroc": 0.9653004473461492, + "auprc": 0.053560890922718485, + "brier": 0.002140675210180198, + "calibration": { + "observed_rate": 0.002171552660152009, + "mean_prediction": 0.0021813873641169457, + "calibration_in_the_large": 9.834703964936922e-06, + "expected_calibration_error_10bin": 0.0003649576682705799, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "K75": { + "valid": 2798, + "positives": 9, + "negatives": 2789, + "auroc": 0.8373371578821561, + "auprc": 0.023798246177834142, + "brier": 0.0031956809426660236, + "calibration": { + "observed_rate": 0.0032165832737669764, + "mean_prediction": 0.001766872650011261, + "calibration_in_the_large": -0.0014497106237557154, + "expected_calibration_error_10bin": 0.0014497106237557154, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "K76": { + "valid": 2681, + "positives": 18, + "negatives": 2663, + "auroc": 0.8480619184712312, + "auprc": 0.1826313983416804, + "brier": 0.0060576452925484164, + "calibration": { + "observed_rate": 0.006713912719134651, + "mean_prediction": 0.003861079550005913, + "calibration_in_the_large": -0.002852833169128738, + "expected_calibration_error_10bin": 0.0032209635496020053, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + "K80": { + "valid": 2731, + "positives": 6, + "negatives": 2725, + "auroc": 0.6890519877675841, + "auprc": 0.005084613573785016, + "brier": 0.002196809120045588, + "calibration": { + "observed_rate": 0.0021969974368363236, + "mean_prediction": 0.0018110023135442885, + "calibration_in_the_large": -0.0003859951232920351, + "expected_calibration_error_10bin": 0.0003859951232920351, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + "K81": { + "valid": 2825, + "positives": 5, + "negatives": 2820, + "auroc": 0.8525531914893617, + "auprc": 0.027417605902849595, + "brier": 0.0017565820397842425, + "calibration": { + "observed_rate": 0.0017699115044247787, + "mean_prediction": 0.0010198453074657004, + "calibration_in_the_large": -0.0007500661969590784, + "expected_calibration_error_10bin": 0.0007500661969590784, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "K82": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.6361810232777975, + "auprc": 0.0042872486379622755, + "brier": 0.001062756008880451, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0007754687203165206, + "calibration_in_the_large": -0.0002868542258591169, + "expected_calibration_error_10bin": 0.0002868542258591169, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K83": { + "valid": 2757, + "positives": 7, + "negatives": 2750, + "auroc": 0.8701818181818182, + "auprc": 0.15396629855716273, + "brier": 0.0024998623310854844, + "calibration": { + "observed_rate": 0.0025389916575988395, + "mean_prediction": 0.002832692132554151, + "calibration_in_the_large": 0.00029370047495531166, + "expected_calibration_error_10bin": 0.0008503839136884401, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + "K85": { + "valid": 2779, + "positives": 3, + "negatives": 2776, + "auroc": 0.7536023054755043, + "auprc": 0.020833203150348128, + "brier": 0.0010740285773062155, + "calibration": { + "observed_rate": 0.0010795250089960418, + "mean_prediction": 0.0013340704483349552, + "calibration_in_the_large": 0.00025454543933891346, + "expected_calibration_error_10bin": 0.00025454543933891346, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + "K86": { + "valid": 2785, + "positives": 5, + "negatives": 2780, + "auroc": 0.683884892086331, + "auprc": 0.011439099685691876, + "brier": 0.001793231766226248, + "calibration": { + "observed_rate": 0.0017953321364452424, + "mean_prediction": 0.0019812431388583824, + "calibration_in_the_large": 0.00018591100241313998, + "expected_calibration_error_10bin": 0.00018591100241313998, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K90": { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.6091872791519435, + "auprc": 0.0009033423667570009, + "brier": 0.0003542608146191811, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0005080944745155723, + "calibration_in_the_large": 0.00015486240104330102, + "expected_calibration_error_10bin": 0.00015486240104330102, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "K91": { + "valid": 2768, + "positives": 15, + "negatives": 2753, + "auroc": 0.8718246761109093, + "auprc": 0.04044280498090688, + "brier": 0.0053187584670092766, + "calibration": { + "observed_rate": 0.00541907514450867, + "mean_prediction": 0.004950300409935237, + "calibration_in_the_large": -0.00046877473457343326, + "expected_calibration_error_10bin": 0.0009353656163948259, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "K92": { + "valid": 2751, + "positives": 19, + "negatives": 2732, + "auroc": 0.8317022424289127, + "auprc": 0.06121305331402543, + "brier": 0.006694160883707989, + "calibration": { + "observed_rate": 0.0069065794256633955, + "mean_prediction": 0.007205667703496516, + "calibration_in_the_large": 0.00029908827783312053, + "expected_calibration_error_10bin": 0.0002990882778331199, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "K94": { + "valid": 2823, + "positives": 12, + "negatives": 2811, + "auroc": 0.9252934898612594, + "auprc": 0.09606195216387554, + "brier": 0.004082154608151865, + "calibration": { + "observed_rate": 0.004250797024442083, + "mean_prediction": 0.0035368094936731173, + "calibration_in_the_large": -0.0007139875307689654, + "expected_calibration_error_10bin": 0.0007139875307689657, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "L02": { + "valid": 2807, + "positives": 11, + "negatives": 2796, + "auroc": 0.7259396540512421, + "auprc": 0.016950626043169822, + "brier": 0.0038928362307698804, + "calibration": { + "observed_rate": 0.003918774492340577, + "mean_prediction": 0.004382587387682727, + "calibration_in_the_large": 0.0004638128953421503, + "expected_calibration_error_10bin": 0.0004638128953421503, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "L03": { + "valid": 2701, + "positives": 25, + "negatives": 2676, + "auroc": 0.7473841554559043, + "auprc": 0.04496642718275097, + "brier": 0.009069317522019138, + "calibration": { + "observed_rate": 0.009255831173639394, + "mean_prediction": 0.005874465834348101, + "calibration_in_the_large": -0.003381365339291293, + "expected_calibration_error_10bin": 0.0033813653392912924, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + "L08": { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.6732035398230088, + "auprc": 0.006945504454163814, + "brier": 0.0017642869403887013, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.0009916871882723246, + "calibration_in_the_large": -0.0007750972640244952, + "expected_calibration_error_10bin": 0.0007750972640244952, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + "L27": { + "valid": 2818, + "positives": 7, + "negatives": 2811, + "auroc": 0.7475733089393708, + "auprc": 0.010519051394680111, + "brier": 0.0027022723819490812, + "calibration": { + "observed_rate": 0.00248403122782115, + "mean_prediction": 0.004037642863041655, + "calibration_in_the_large": 0.001553611635220505, + "expected_calibration_error_10bin": 0.0015536116352205052, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "L29": { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.5619521440416962, + "auprc": 0.0029896814290712036, + "brier": 0.0010952858232280848, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.0025181529522201873, + "calibration_in_the_large": 0.0014531902259156079, + "expected_calibration_error_10bin": 0.0014531902259156079, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "L30": { + "valid": 2816, + "positives": 5, + "negatives": 2811, + "auroc": 0.6986837424404126, + "auprc": 0.029173921563214012, + "brier": 0.0017635562337389226, + "calibration": { + "observed_rate": 0.0017755681818181818, + "mean_prediction": 0.0012891355855541324, + "calibration_in_the_large": -0.0004864325962640494, + "expected_calibration_error_10bin": 0.0004864325962640494, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "L50": { + "valid": 2835, + "positives": 2, + "negatives": 2833, + "auroc": 0.7892693258030357, + "auprc": 0.01809754369390647, + "brier": 0.0007033075391555873, + "calibration": { + "observed_rate": 0.0007054673721340388, + "mean_prediction": 0.0008178591636369129, + "calibration_in_the_large": 0.00011239179150287408, + "expected_calibration_error_10bin": 0.00011239179150287408, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + "L53": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 4.04848928871679e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0010194108696631313, + "calibration_in_the_large": 0.0010194108696631313, + "expected_calibration_error_10bin": 0.0010194108696631313, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "L76": { + "valid": 2793, + "positives": 10, + "negatives": 2783, + "auroc": 0.583794466403162, + "auprc": 0.004666288263715087, + "brier": 0.003605558117691466, + "calibration": { + "observed_rate": 0.0035803795202291443, + "mean_prediction": 0.004292754148075329, + "calibration_in_the_large": 0.0007123746278461848, + "expected_calibration_error_10bin": 0.0007123746278461848, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "L89": { + "valid": 2798, + "positives": 14, + "negatives": 2784, + "auroc": 0.8518575533661741, + "auprc": 0.022779276420210628, + "brier": 0.0049700637679488185, + "calibration": { + "observed_rate": 0.005003573981415297, + "mean_prediction": 0.0039800479604281055, + "calibration_in_the_large": -0.0010235260209871914, + "expected_calibration_error_10bin": 0.0013556934343684642, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "L97": { + "valid": 2789, + "positives": 5, + "negatives": 2784, + "auroc": 0.9636494252873563, + "auprc": 0.09185640771753774, + "brier": 0.0017461674335612206, + "calibration": { + "observed_rate": 0.0017927572606669057, + "mean_prediction": 0.002896218061619878, + "calibration_in_the_large": 0.0011034608009529723, + "expected_calibration_error_10bin": 0.001103460800952972, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "L98": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.7762022923313245, + "auprc": 0.007346247675588994, + "brier": 0.0010732056895471217, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0026257384039647365, + "calibration_in_the_large": 0.001563415457789099, + "expected_calibration_error_10bin": 0.001563415457789099, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "M10": { + "valid": 2713, + "positives": 10, + "negatives": 2703, + "auroc": 0.8219755826859045, + "auprc": 0.03531997615171606, + "brier": 0.0036327693460406164, + "calibration": { + "observed_rate": 0.003685956505713233, + "mean_prediction": 0.003077670196285979, + "calibration_in_the_large": -0.0006082863094272538, + "expected_calibration_error_10bin": 0.0006975916982360751, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + "M16": { + "valid": 2790, + "positives": 2, + "negatives": 2788, + "auroc": 0.8678263988522238, + "auprc": 0.014247046344050624, + "brier": 0.0007149100803688147, + "calibration": { + "observed_rate": 0.0007168458781362007, + "mean_prediction": 0.0007821352940348376, + "calibration_in_the_large": 6.528941589863688e-05, + "expected_calibration_error_10bin": 6.528941589863688e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "M17": { + "valid": 2733, + "positives": 6, + "negatives": 2727, + "auroc": 0.7690991321354358, + "auprc": 0.006412047667337544, + "brier": 0.002198134129027915, + "calibration": { + "observed_rate": 0.0021953896816684962, + "mean_prediction": 0.0014898241489130215, + "calibration_in_the_large": -0.0007055655327554747, + "expected_calibration_error_10bin": 0.0007055655327554747, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "M19": { + "valid": 2674, + "positives": 24, + "negatives": 2650, + "auroc": 0.6832389937106919, + "auprc": 0.021145983159249714, + "brier": 0.00887442745754252, + "calibration": { + "observed_rate": 0.008975317875841436, + "mean_prediction": 0.007412165385091844, + "calibration_in_the_large": -0.001563152490749592, + "expected_calibration_error_10bin": 0.001641487036963592, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + "M21": { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.9773049645390071, + "auprc": 0.015384615384615385, + "brier": 0.0003543335680309581, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0009833402060798583, + "calibration_in_the_large": 0.000628855980627891, + "expected_calibration_error_10bin": 0.000628855980627891, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "M25": { + "valid": 2717, + "positives": 20, + "negatives": 2697, + "auroc": 0.6471820541342233, + "auprc": 0.01514770112447027, + "brier": 0.00731969318489811, + "calibration": { + "observed_rate": 0.00736105999263894, + "mean_prediction": 0.0073053282935161695, + "calibration_in_the_large": -5.5731699122770796e-05, + "expected_calibration_error_10bin": 0.0002905859445982005, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + "M35": { + "valid": 2806, + "positives": 1, + "negatives": 2805, + "auroc": 0.8816399286987522, + "auprc": 0.003003003003003003, + "brier": 0.0003578246661313354, + "calibration": { + "observed_rate": 0.0003563791874554526, + "mean_prediction": 0.0005018268007471674, + "calibration_in_the_large": 0.00014544761329171477, + "expected_calibration_error_10bin": 0.00014544761329171477, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "M46": { + "valid": 2814, + "positives": 3, + "negatives": 2811, + "auroc": 0.5385983635716827, + "auprc": 0.0015742803365758956, + "brier": 0.0010690170597634587, + "calibration": { + "observed_rate": 0.0010660980810234541, + "mean_prediction": 0.0013597301571534087, + "calibration_in_the_large": 0.0002936320761299546, + "expected_calibration_error_10bin": 0.0002936320761299546, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "M47": { + "valid": 2743, + "positives": 3, + "negatives": 2740, + "auroc": 0.6717761557177615, + "auprc": 0.003678135971167252, + "brier": 0.001094011982233147, + "calibration": { + "observed_rate": 0.001093693036820999, + "mean_prediction": 0.0015939506936796589, + "calibration_in_the_large": 0.00050025765685866, + "expected_calibration_error_10bin": 0.00050025765685866, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "M48": { + "valid": 2690, + "positives": 5, + "negatives": 2685, + "auroc": 0.717243947858473, + "auprc": 0.010319547852924443, + "brier": 0.0018673093013488406, + "calibration": { + "observed_rate": 0.0018587360594795538, + "mean_prediction": 0.0036563380870216814, + "calibration_in_the_large": 0.0017976020275421276, + "expected_calibration_error_10bin": 0.0017976020275421276, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + "M51": { + "valid": 2785, + "positives": 1, + "negatives": 2784, + "auroc": 0.9701867816091954, + "auprc": 0.011904761904761904, + "brier": 0.00036081942592940044, + "calibration": { + "observed_rate": 0.0003590664272890485, + "mean_prediction": 0.0018815871747848085, + "calibration_in_the_large": 0.00152252074749576, + "expected_calibration_error_10bin": 0.00152252074749576, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "M54": { + "valid": 2567, + "positives": 27, + "negatives": 2540, + "auroc": 0.6849664625255176, + "auprc": 0.026840475544057146, + "brier": 0.010388486318525389, + "calibration": { + "observed_rate": 0.010518114530580444, + "mean_prediction": 0.010179937064606315, + "calibration_in_the_large": -0.00033817746597412934, + "expected_calibration_error_10bin": 0.000885318476836627, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + "M62": { + "valid": 2781, + "positives": 5, + "negatives": 2776, + "auroc": 0.7961815561959654, + "auprc": 0.014053071445119258, + "brier": 0.0017889539906113011, + "calibration": { + "observed_rate": 0.0017979144192736426, + "mean_prediction": 0.0021288016811819043, + "calibration_in_the_large": 0.00033088726190826177, + "expected_calibration_error_10bin": 0.00033088726190826177, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "M79": { + "valid": 2697, + "positives": 19, + "negatives": 2678, + "auroc": 0.7649070398176172, + "auprc": 0.025135960051641783, + "brier": 0.006978250849654003, + "calibration": { + "observed_rate": 0.0070448646644419724, + "mean_prediction": 0.009121491917774003, + "calibration_in_the_large": 0.002076627253332031, + "expected_calibration_error_10bin": 0.002076627253332032, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + "M81": { + "valid": 2705, + "positives": 8, + "negatives": 2697, + "auroc": 0.7829532814238043, + "auprc": 0.027841449387260915, + "brier": 0.0029377171409471444, + "calibration": { + "observed_rate": 0.0029574861367837337, + "mean_prediction": 0.0030394508797986475, + "calibration_in_the_large": 8.196474301491383e-05, + "expected_calibration_error_10bin": 0.00023960599539145288, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + "M84": { + "valid": 2818, + "positives": 3, + "negatives": 2815, + "auroc": 0.6931912374185909, + "auprc": 0.0254581804013042, + "brier": 0.0010613810317071906, + "calibration": { + "observed_rate": 0.0010645848119233499, + "mean_prediction": 0.001612756185870247, + "calibration_in_the_large": 0.0005481713739468972, + "expected_calibration_error_10bin": 0.0005481713739468972, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "M85": { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.7249961194184302, + "auprc": 0.006337131155358192, + "brier": 0.0025255512420061695, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.0019023901229002938, + "calibration_in_the_large": -0.0006265116112037525, + "expected_calibration_error_10bin": 0.0006265116112037525, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "M86": { + "valid": 2803, + "positives": 9, + "negatives": 2794, + "auroc": 0.7835838701980434, + "auprc": 0.03361890976590344, + "brier": 0.003185492215501639, + "calibration": { + "observed_rate": 0.003210845522654299, + "mean_prediction": 0.002054460943353243, + "calibration_in_the_large": -0.0011563845793010562, + "expected_calibration_error_10bin": 0.001230840222103321, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + "M94": { + "valid": 2819, + "positives": 1, + "negatives": 2818, + "auroc": 0.8534421575585521, + "auprc": 0.0024154589371980675, + "brier": 0.0003546852666385869, + "calibration": { + "observed_rate": 0.000354735721887194, + "mean_prediction": 0.0002062690820451065, + "calibration_in_the_large": -0.00014846663984208753, + "expected_calibration_error_10bin": 0.00014846663984208753, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "M96": { + "valid": 2804, + "positives": 1, + "negatives": 2803, + "auroc": 0.8904744916161256, + "auprc": 0.003246753246753247, + "brier": 0.0003703641842339886, + "calibration": { + "observed_rate": 0.0003566333808844508, + "mean_prediction": 0.002476820121473183, + "calibration_in_the_large": 0.0021201867405887323, + "expected_calibration_error_10bin": 0.0021201867405887323, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "N12": { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.5948885744605589, + "auprc": 0.0024069020843287456, + "brier": 0.001418198280766013, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0011294272278743283, + "calibration_in_the_large": -0.00028350106601475683, + "expected_calibration_error_10bin": 0.00028350106601475683, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N13": { + "valid": 2756, + "positives": 5, + "negatives": 2751, + "auroc": 0.648854961832061, + "auprc": 0.0047953501773396415, + "brier": 0.0018288276981090722, + "calibration": { + "observed_rate": 0.00181422351233672, + "mean_prediction": 0.0030390051636978014, + "calibration_in_the_large": 0.0012247816513610815, + "expected_calibration_error_10bin": 0.0012247816513610815, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "N14": { + "valid": 2826, + "positives": 6, + "negatives": 2820, + "auroc": 0.8611111111111112, + "auprc": 0.01367403982573599, + "brier": 0.0021157442415217103, + "calibration": { + "observed_rate": 0.0021231422505307855, + "mean_prediction": 0.000823659935792819, + "calibration_in_the_large": -0.0012994823147379664, + "expected_calibration_error_10bin": 0.0012994823147379664, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "N17": { + "valid": 2292, + "positives": 61, + "negatives": 2231, + "auroc": 0.777553254807445, + "auprc": 0.09747555742294833, + "brier": 0.025322756580258645, + "calibration": { + "observed_rate": 0.026614310645724257, + "mean_prediction": 0.028087085440360135, + "calibration_in_the_large": 0.0014727747946358775, + "expected_calibration_error_10bin": 0.006803308788399101, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + "N18": { + "valid": 2440, + "positives": 30, + "negatives": 2410, + "auroc": 0.8585892116182573, + "auprc": 0.12450953363777681, + "brier": 0.011600705773375125, + "calibration": { + "observed_rate": 0.012295081967213115, + "mean_prediction": 0.006812550460935959, + "calibration_in_the_large": -0.005482531506277155, + "expected_calibration_error_10bin": 0.0054825315062771544, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + "N20": { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7363741958541815, + "auprc": 0.006272785044047667, + "brier": 0.002846745039277724, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.0008080714958323201, + "calibration_in_the_large": -0.002042962003811301, + "expected_calibration_error_10bin": 0.002042962003811301, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "N25": { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.9496815286624204, + "auprc": 0.07559772222889696, + "brier": 0.0017413110459944695, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0007280598686358939, + "calibration_in_the_large": -0.0010381004987254625, + "expected_calibration_error_10bin": 0.0010381004987254625, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N28": { + "valid": 2789, + "positives": 3, + "negatives": 2786, + "auroc": 0.9186408231634362, + "auprc": 0.012618860637708356, + "brier": 0.0010768407122779947, + "calibration": { + "observed_rate": 0.0010756543564001434, + "mean_prediction": 0.0028256996872479813, + "calibration_in_the_large": 0.0017500453308478378, + "expected_calibration_error_10bin": 0.0017500453308478378, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "N30": { + "valid": 2829, + "positives": 8, + "negatives": 2821, + "auroc": 0.733826657213754, + "auprc": 0.010670910209310599, + "brier": 0.002831147640312654, + "calibration": { + "observed_rate": 0.002827854365500177, + "mean_prediction": 0.002471594067891254, + "calibration_in_the_large": -0.0003562602976089229, + "expected_calibration_error_10bin": 0.00044120988447990617, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N32": { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.7994637111190561, + "auprc": 0.13133308666889282, + "brier": 0.003474645220963474, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.0030915677412651325, + "calibration_in_the_large": -0.0004709545244990284, + "expected_calibration_error_10bin": 0.0004709545244990284, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "N39": { + "valid": 2520, + "positives": 54, + "negatives": 2466, + "auroc": 0.7686837283349854, + "auprc": 0.07197422811987915, + "brier": 0.02053134088080042, + "calibration": { + "observed_rate": 0.02142857142857143, + "mean_prediction": 0.023868580726538934, + "calibration_in_the_large": 0.0024400092979675048, + "expected_calibration_error_10bin": 0.002671743452683874, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + "N40": { + "valid": 2606, + "positives": 13, + "negatives": 2593, + "auroc": 0.8169628289180931, + "auprc": 0.028391470011062438, + "brier": 0.004949357709176634, + "calibration": { + "observed_rate": 0.0049884881043745204, + "mean_prediction": 0.006633295289705244, + "calibration_in_the_large": 0.0016448071853307237, + "expected_calibration_error_10bin": 0.001644807185330723, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + "N73": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9785992217898832, + "auprc": 0.050595238095238096, + "brier": 0.0006976888481561338, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0007014895088446244, + "calibration_in_the_large": -5.474082530419777e-06, + "expected_calibration_error_10bin": 5.474082530419777e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N99": { + "valid": 2799, + "positives": 3, + "negatives": 2796, + "auroc": 0.7285407725321889, + "auprc": 0.006775533423322048, + "brier": 0.0010703709893121875, + "calibration": { + "observed_rate": 0.0010718113612004287, + "mean_prediction": 0.0010672641792621132, + "calibration_in_the_large": -4.5471819383154696e-06, + "expected_calibration_error_10bin": 4.5471819383154696e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + "O69": { + "valid": 2743, + "positives": 4, + "negatives": 2739, + "auroc": 0.9982657904344652, + "auprc": 0.36858974358974356, + "brier": 0.0013649946764622992, + "calibration": { + "observed_rate": 0.0014582573824279985, + "mean_prediction": 0.00028364207115685083, + "calibration_in_the_large": -0.0011746153112711477, + "expected_calibration_error_10bin": 0.0012537105064826964, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "O99": { + "valid": 2652, + "positives": 1, + "negatives": 2651, + "auroc": 0.999622783855149, + "auprc": 0.5, + "brier": 0.00026688643454425126, + "calibration": { + "observed_rate": 0.0003770739064856712, + "mean_prediction": 0.0003163249822059584, + "calibration_in_the_large": -6.074892427971283e-05, + "expected_calibration_error_10bin": 0.0005533827459126432, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + "Q21": { + "valid": 2810, + "positives": 1, + "negatives": 2809, + "auroc": 0.7924528301886793, + "auprc": 0.0017123287671232876, + "brier": 0.0003565817157898271, + "calibration": { + "observed_rate": 0.00035587188612099647, + "mean_prediction": 0.0008038818718916471, + "calibration_in_the_large": 0.0004480099857706506, + "expected_calibration_error_10bin": 0.0004480099857706506, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "U07": { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 1.2260576377502347e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0018328600842826782, + "calibration_in_the_large": 0.0018328600842826782, + "expected_calibration_error_10bin": 0.0018328600842826782, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + } + }, + "150": { + "A04": { + "valid": 2782, + "positives": 20, + "negatives": 2762, + "auroc": 0.7297610427226647, + "auprc": 0.07373571461269256, + "brier": 0.0070739953954285445, + "calibration": { + "observed_rate": 0.007189072609633357, + "mean_prediction": 0.00705605490449898, + "calibration_in_the_large": -0.00013301770513437713, + "expected_calibration_error_10bin": 0.00019498468395484956, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "A08": { + "valid": 2818, + "positives": 10, + "negatives": 2808, + "auroc": 0.8403133903133904, + "auprc": 0.03138506894393284, + "brier": 0.0034956928244408007, + "calibration": { + "observed_rate": 0.0035486160397444995, + "mean_prediction": 0.0030016612794945604, + "calibration_in_the_large": -0.0005469547602499391, + "expected_calibration_error_10bin": 0.0005469547602499391, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "A41": { + "valid": 2664, + "positives": 40, + "negatives": 2624, + "auroc": 0.7438262195121951, + "auprc": 0.0597752504745417, + "brier": 0.014745589081547232, + "calibration": { + "observed_rate": 0.015015015015015015, + "mean_prediction": 0.019676424841067103, + "calibration_in_the_large": 0.004661409826052088, + "expected_calibration_error_10bin": 0.004769821624568641, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + "B00": { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.6956676136363636, + "auprc": 0.02091772340155283, + "brier": 0.001081712881821528, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0012979181931469757, + "calibration_in_the_large": 0.00023371102748539368, + "expected_calibration_error_10bin": 0.00023371102748539363, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "B02": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7856384860275911, + "auprc": 0.0016474464579901153, + "brier": 0.00035459823759919924, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0004921666503333838, + "calibration_in_the_large": 0.00013855986108303014, + "expected_calibration_error_10bin": 0.00013855986108303014, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "B18": { + "valid": 2782, + "positives": 4, + "negatives": 2778, + "auroc": 0.9642728581713463, + "auprc": 0.09137188845218043, + "brier": 0.001390163137155126, + "calibration": { + "observed_rate": 0.0014378145219266715, + "mean_prediction": 0.0009288055600497855, + "calibration_in_the_large": -0.000509008961876886, + "expected_calibration_error_10bin": 0.000509008961876886, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "B19": { + "valid": 2763, + "positives": 15, + "negatives": 2748, + "auroc": 0.844517224648229, + "auprc": 0.0722432830069903, + "brier": 0.005313515936672734, + "calibration": { + "observed_rate": 0.0054288816503800215, + "mean_prediction": 0.001430823097251763, + "calibration_in_the_large": -0.003998058553128259, + "expected_calibration_error_10bin": 0.004086451702019225, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "B20": { + "valid": 2829, + "positives": 3, + "negatives": 2826, + "auroc": 0.9885586223165841, + "auprc": 0.11709401709401708, + "brier": 0.0010530536122878194, + "calibration": { + "observed_rate": 0.0010604453870625664, + "mean_prediction": 0.00020558540925039615, + "calibration_in_the_large": -0.0008548599778121702, + "expected_calibration_error_10bin": 0.0008548599778121702, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "B34": { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.9731163777856385, + "auprc": 0.03496025959622928, + "brier": 0.0014022322372510253, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0008623988849572862, + "calibration_in_the_large": -0.0005505294089317989, + "expected_calibration_error_10bin": 0.0005505294089317989, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "B35": { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 7.0098792824643575e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001149105197575604, + "calibration_in_the_large": 0.001149105197575604, + "expected_calibration_error_10bin": 0.001149105197575604, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "B37": { + "valid": 2768, + "positives": 23, + "negatives": 2745, + "auroc": 0.767767482379029, + "auprc": 0.026794597819706525, + "brier": 0.008246814560483979, + "calibration": { + "observed_rate": 0.008309248554913294, + "mean_prediction": 0.007352137680623393, + "calibration_in_the_large": -0.0009571108742899015, + "expected_calibration_error_10bin": 0.0018025770063987783, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "B95": { + "valid": 2678, + "positives": 42, + "negatives": 2636, + "auroc": 0.7003486523592745, + "auprc": 0.033179135081324064, + "brier": 0.015589822303590612, + "calibration": { + "observed_rate": 0.01568334578043316, + "mean_prediction": 0.018185598616705805, + "calibration_in_the_large": 0.002502252836272645, + "expected_calibration_error_10bin": 0.0025022528362726474, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + "B96": { + "valid": 2630, + "positives": 57, + "negatives": 2573, + "auroc": 0.7756254218913003, + "auprc": 0.07749876216998988, + "brier": 0.02070890949649418, + "calibration": { + "observed_rate": 0.02167300380228137, + "mean_prediction": 0.024459386284696825, + "calibration_in_the_large": 0.0027863824824154552, + "expected_calibration_error_10bin": 0.0034803628063665095, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + "B97": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7661832331093031, + "auprc": 0.0015105740181268882, + "brier": 0.0003607148681856676, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0006283767476039144, + "calibration_in_the_large": 0.00027476995835356075, + "expected_calibration_error_10bin": 0.00027476995835356075, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "C18": { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9803330970942594, + "auprc": 0.05961538461538462, + "brier": 0.0007031559423504111, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0004899668464230267, + "calibration_in_the_large": -0.00021824845102739825, + "expected_calibration_error_10bin": 0.00021824845102739825, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "C22": { + "valid": 2812, + "positives": 5, + "negatives": 2807, + "auroc": 0.9168507303170644, + "auprc": 0.06114408333288619, + "brier": 0.0017506946693485242, + "calibration": { + "observed_rate": 0.0017780938833570413, + "mean_prediction": 0.0005878883908441022, + "calibration_in_the_large": -0.001190205492512939, + "expected_calibration_error_10bin": 0.001190205492512939, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + "C25": { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.9360527253295333, + "auprc": 0.16945218198700093, + "brier": 0.0006842406525092006, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0004400499553069006, + "calibration_in_the_large": -0.0002719471967044914, + "expected_calibration_error_10bin": 0.0003655499998407337, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "C61": { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9668212629325722, + "auprc": 0.017346938775510204, + "brier": 0.0007105213183741003, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0007613328664100178, + "calibration_in_the_large": 4.832038869165777e-05, + "expected_calibration_error_10bin": 4.832038869165777e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "C67": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9517155995755218, + "auprc": 0.03327276856688621, + "brier": 0.0007030681030809465, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0005386514939887332, + "calibration_in_the_large": -0.00016831209738631104, + "expected_calibration_error_10bin": 0.00016831209738631104, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "C77": { + "valid": 2762, + "positives": 14, + "negatives": 2748, + "auroc": 0.8648627573300063, + "auprc": 0.12118901577974514, + "brier": 0.004789876268333504, + "calibration": { + "observed_rate": 0.005068790731354091, + "mean_prediction": 0.0033614876988622036, + "calibration_in_the_large": -0.0017073030324918875, + "expected_calibration_error_10bin": 0.002013334038967249, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C78": { + "valid": 2762, + "positives": 21, + "negatives": 2741, + "auroc": 0.8568996369069335, + "auprc": 0.13918249625526805, + "brier": 0.0071191449179617275, + "calibration": { + "observed_rate": 0.007603186097031137, + "mean_prediction": 0.004830477924838586, + "calibration_in_the_large": -0.0027727081721925515, + "expected_calibration_error_10bin": 0.004631701371597628, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C79": { + "valid": 2751, + "positives": 14, + "negatives": 2737, + "auroc": 0.8665640169111123, + "auprc": 0.13670696655779718, + "brier": 0.005330238985050127, + "calibration": { + "observed_rate": 0.005089058524173028, + "mean_prediction": 0.006524582754563602, + "calibration_in_the_large": 0.0014355242303905735, + "expected_calibration_error_10bin": 0.0029258361789636883, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "C83": { + "valid": 2820, + "positives": 0, + "negatives": 2820, + "auroc": null, + "auprc": null, + "brier": 1.4168374985006761e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004227784032575576, + "calibration_in_the_large": 0.0004227784032575576, + "expected_calibration_error_10bin": 0.0004227784032575576, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "D25": { + "valid": 2792, + "positives": 2, + "negatives": 2790, + "auroc": 0.9378136200716846, + "auprc": 0.25287356321839083, + "brier": 0.0007088786588731285, + "calibration": { + "observed_rate": 0.0007163323782234957, + "mean_prediction": 0.00037173822934366454, + "calibration_in_the_large": -0.00034459414887983114, + "expected_calibration_error_10bin": 0.00034459414887983114, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "D47": { + "valid": 2796, + "positives": 6, + "negatives": 2790, + "auroc": 0.5942652329749104, + "auprc": 0.0036808065329270658, + "brier": 0.002204935459720973, + "calibration": { + "observed_rate": 0.002145922746781116, + "mean_prediction": 0.0038454722764257117, + "calibration_in_the_large": 0.0016995495296445958, + "expected_calibration_error_10bin": 0.0016995495296445958, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "D50": { + "valid": 2663, + "positives": 39, + "negatives": 2624, + "auroc": 0.8057575046904315, + "auprc": 0.1018646498967127, + "brier": 0.013830433096580287, + "calibration": { + "observed_rate": 0.01464513706346226, + "mean_prediction": 0.011397788674350774, + "calibration_in_the_large": -0.0032473483891114867, + "expected_calibration_error_10bin": 0.0032473483891114876, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + "D53": { + "valid": 2805, + "positives": 12, + "negatives": 2793, + "auroc": 0.8306182121971596, + "auprc": 0.02587077562317473, + "brier": 0.004287418340397021, + "calibration": { + "observed_rate": 0.0042780748663101605, + "mean_prediction": 0.004582510386121701, + "calibration_in_the_large": 0.00030443551981154063, + "expected_calibration_error_10bin": 0.0003044355198115407, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "D59": { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 3.144055767215128e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0006189368050201103, + "calibration_in_the_large": 0.0006189368050201103, + "expected_calibration_error_10bin": 0.0006189368050201103, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "D61": { + "valid": 2773, + "positives": 21, + "negatives": 2752, + "auroc": 0.8942933277962348, + "auprc": 0.14089104376665976, + "brier": 0.007041637024380965, + "calibration": { + "observed_rate": 0.007573025604038947, + "mean_prediction": 0.007895347568472402, + "calibration_in_the_large": 0.0003223219644334545, + "expected_calibration_error_10bin": 0.0025868887941255117, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "D62": { + "valid": 2499, + "positives": 45, + "negatives": 2454, + "auroc": 0.7987775061124694, + "auprc": 0.05561464430801152, + "brier": 0.017368577867522255, + "calibration": { + "observed_rate": 0.01800720288115246, + "mean_prediction": 0.0184002954326216, + "calibration_in_the_large": 0.00039309255146913885, + "expected_calibration_error_10bin": 0.001532819278926932, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + "D63": { + "valid": 2686, + "positives": 55, + "negatives": 2631, + "auroc": 0.8869216682215542, + "auprc": 0.1310738408708993, + "brier": 0.01898298378464056, + "calibration": { + "observed_rate": 0.020476545048399106, + "mean_prediction": 0.017983054373348226, + "calibration_in_the_large": -0.0024934906750508808, + "expected_calibration_error_10bin": 0.0060489990512838905, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + "D64": { + "valid": 2434, + "positives": 85, + "negatives": 2349, + "auroc": 0.81139408509253, + "auprc": 0.1503863822435443, + "brier": 0.03157738422804296, + "calibration": { + "observed_rate": 0.03492193919474117, + "mean_prediction": 0.03644012509835249, + "calibration_in_the_large": 0.001518185903611323, + "expected_calibration_error_10bin": 0.0019277056641631802, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + "D65": { + "valid": 2833, + "positives": 3, + "negatives": 2830, + "auroc": 0.9619552414605418, + "auprc": 0.017680372962838115, + "brier": 0.001058123748963202, + "calibration": { + "observed_rate": 0.0010589481115425344, + "mean_prediction": 0.0008378243724098543, + "calibration_in_the_large": -0.00022112373913268013, + "expected_calibration_error_10bin": 0.00022112373913268013, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + "D68": { + "valid": 2682, + "positives": 39, + "negatives": 2643, + "auroc": 0.8004307459472045, + "auprc": 0.07294312993002008, + "brier": 0.0140208672966509, + "calibration": { + "observed_rate": 0.0145413870246085, + "mean_prediction": 0.009357959766968415, + "calibration_in_the_large": -0.0051834272576400855, + "expected_calibration_error_10bin": 0.006262297807915912, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + "D69": { + "valid": 2586, + "positives": 52, + "negatives": 2534, + "auroc": 0.849364033756299, + "auprc": 0.2111454328325288, + "brier": 0.017528789025392476, + "calibration": { + "observed_rate": 0.020108275328692964, + "mean_prediction": 0.015957231449085913, + "calibration_in_the_large": -0.0041510438796070505, + "expected_calibration_error_10bin": 0.004839772553620169, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + "D70": { + "valid": 2787, + "positives": 20, + "negatives": 2767, + "auroc": 0.8873147813516444, + "auprc": 0.2435798241838924, + "brier": 0.006751311893805725, + "calibration": { + "observed_rate": 0.007176175098672408, + "mean_prediction": 0.0069680535182036285, + "calibration_in_the_large": -0.0002081215804687793, + "expected_calibration_error_10bin": 0.004538764660576868, + "nonempty_bins": 8 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "D72": { + "valid": 2595, + "positives": 45, + "negatives": 2550, + "auroc": 0.713359477124183, + "auprc": 0.06053065510015915, + "brier": 0.01678010126396935, + "calibration": { + "observed_rate": 0.017341040462427744, + "mean_prediction": 0.018065390557630314, + "calibration_in_the_large": 0.0007243500952025701, + "expected_calibration_error_10bin": 0.0014746701827107681, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + "D73": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.8219307574146284, + "auprc": 0.02171512609093978, + "brier": 0.0010665967965201657, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0010901334976342542, + "calibration_in_the_large": 2.7810551458616693e-05, + "expected_calibration_error_10bin": 6.809055703864623e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "D75": { + "valid": 2831, + "positives": 2, + "negatives": 2829, + "auroc": 0.8911276069282432, + "auprc": 0.00486061894637373, + "brier": 0.0007081266225107403, + "calibration": { + "observed_rate": 0.0007064641469445425, + "mean_prediction": 0.0010160640316969457, + "calibration_in_the_large": 0.0003095998847524032, + "expected_calibration_error_10bin": 0.0003095998847524032, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "D80": { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.9884996461429583, + "auprc": 0.0987650749129878, + "brier": 0.0020565514648307284, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.001091056390711758, + "calibration_in_the_large": -0.001027587677084852, + "expected_calibration_error_10bin": 0.0012734884175635238, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "D89": { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.82663139329806, + "auprc": 0.007061028402491816, + "brier": 0.0007896930711807005, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0007200642272205647, + "calibration_in_the_large": 1.5094188447212589e-05, + "expected_calibration_error_10bin": 0.0006640664088460644, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "E03": { + "valid": 2480, + "positives": 18, + "negatives": 2462, + "auroc": 0.748894304540121, + "auprc": 0.020761503059650643, + "brier": 0.007184057090844736, + "calibration": { + "observed_rate": 0.007258064516129033, + "mean_prediction": 0.004008693053953222, + "calibration_in_the_large": -0.0032493714621758107, + "expected_calibration_error_10bin": 0.0032493714621758107, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + "E04": { + "valid": 2775, + "positives": 9, + "negatives": 2766, + "auroc": 0.7718325700972122, + "auprc": 0.010198522628465594, + "brier": 0.0032320255476822606, + "calibration": { + "observed_rate": 0.003243243243243243, + "mean_prediction": 0.002362933934357873, + "calibration_in_the_large": -0.0008803093088853701, + "expected_calibration_error_10bin": 0.0008803093088853701, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "E05": { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.10431526390870186, + "auprc": 0.000585834967194674, + "brier": 0.0007148778127345639, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0009138006688080611, + "calibration_in_the_large": 0.00020104229389715587, + "expected_calibration_error_10bin": 0.00020104229389715587, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "E11": { + "valid": 2194, + "positives": 13, + "negatives": 2181, + "auroc": 0.7723697668677036, + "auprc": 0.07572578371338722, + "brier": 0.005804458034148376, + "calibration": { + "observed_rate": 0.005925250683682771, + "mean_prediction": 0.005302662221216109, + "calibration_in_the_large": -0.0006225884624666616, + "expected_calibration_error_10bin": 0.0006225884624666616, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + "E16": { + "valid": 2816, + "positives": 5, + "negatives": 2811, + "auroc": 0.6258271077908217, + "auprc": 0.0030332161310819396, + "brier": 0.0017854192997023503, + "calibration": { + "observed_rate": 0.0017755681818181818, + "mean_prediction": 0.0021166625373738993, + "calibration_in_the_large": 0.0003410943555557176, + "expected_calibration_error_10bin": 0.0003410943555557176, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "E21": { + "valid": 2814, + "positives": 1, + "negatives": 2813, + "auroc": 0.9808034127266264, + "auprc": 0.01818181818181818, + "brier": 0.000363201719838301, + "calibration": { + "observed_rate": 0.00035536602700781805, + "mean_prediction": 0.0011819252308659395, + "calibration_in_the_large": 0.0008265592038581215, + "expected_calibration_error_10bin": 0.0008265592038581215, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "E22": { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8243388134381702, + "auprc": 0.0062101587080295294, + "brier": 0.0015023431116899706, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.0043706135527724855, + "calibration_in_the_large": 0.0029430618040215935, + "expected_calibration_error_10bin": 0.0029430618040215935, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "E27": { + "valid": 2811, + "positives": 5, + "negatives": 2806, + "auroc": 0.7715609408410549, + "auprc": 0.005565091631796452, + "brier": 0.0017829590468811463, + "calibration": { + "observed_rate": 0.0017787264318747777, + "mean_prediction": 0.0016831482702781028, + "calibration_in_the_large": -9.557816159667487e-05, + "expected_calibration_error_10bin": 9.557816159667487e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + }, + "E43": { + "valid": 2748, + "positives": 32, + "negatives": 2716, + "auroc": 0.8331300625920471, + "auprc": 0.07582502163421574, + "brier": 0.01121434776045596, + "calibration": { + "observed_rate": 0.011644832605531296, + "mean_prediction": 0.011096994163047555, + "calibration_in_the_large": -0.0005478384424837408, + "expected_calibration_error_10bin": 0.0016209177102309326, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + "E44": { + "valid": 2800, + "positives": 15, + "negatives": 2785, + "auroc": 0.7673249551166966, + "auprc": 0.01899919176480263, + "brier": 0.005386904075590773, + "calibration": { + "observed_rate": 0.005357142857142857, + "mean_prediction": 0.006910364539346899, + "calibration_in_the_large": 0.001553221682204042, + "expected_calibration_error_10bin": 0.0015532216822040411, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "E46": { + "valid": 2772, + "positives": 28, + "negatives": 2744, + "auroc": 0.8196454602249063, + "auprc": 0.0763286340597834, + "brier": 0.009743273163555664, + "calibration": { + "observed_rate": 0.010101010101010102, + "mean_prediction": 0.010564319327957225, + "calibration_in_the_large": 0.00046330922694712284, + "expected_calibration_error_10bin": 0.001084661560947282, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + "E53": { + "valid": 2804, + "positives": 4, + "negatives": 2800, + "auroc": 0.7458928571428571, + "auprc": 0.004426291201221916, + "brier": 0.0014365286484885416, + "calibration": { + "observed_rate": 0.0014265335235378032, + "mean_prediction": 0.0019748320522092805, + "calibration_in_the_large": 0.0005482985286714773, + "expected_calibration_error_10bin": 0.0005482985286714773, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "E55": { + "valid": 2737, + "positives": 19, + "negatives": 2718, + "auroc": 0.5736028813756245, + "auprc": 0.010090948886197996, + "brier": 0.006985985135893551, + "calibration": { + "observed_rate": 0.006941907197661673, + "mean_prediction": 0.0076994266771492955, + "calibration_in_the_large": 0.0007575194794876223, + "expected_calibration_error_10bin": 0.0007575194794876217, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + "E66": { + "valid": 2371, + "positives": 27, + "negatives": 2344, + "auroc": 0.6905100492984452, + "auprc": 0.02574953857361139, + "brier": 0.011244762684150813, + "calibration": { + "observed_rate": 0.011387600168705188, + "mean_prediction": 0.010901368701803403, + "calibration_in_the_large": -0.00048623146690178476, + "expected_calibration_error_10bin": 0.0009670028396132275, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + "E78": { + "valid": 1572, + "positives": 31, + "negatives": 1541, + "auroc": 0.7013041384940655, + "auprc": 0.057504898165867846, + "brier": 0.019725257440506294, + "calibration": { + "observed_rate": 0.019720101781170483, + "mean_prediction": 0.021291269551840127, + "calibration_in_the_large": 0.0015711677706696445, + "expected_calibration_error_10bin": 0.006838072481595243, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + "E80": { + "valid": 2823, + "positives": 4, + "negatives": 2819, + "auroc": 0.9698474636395885, + "auprc": 0.031539051673855456, + "brier": 0.0014114473735108626, + "calibration": { + "observed_rate": 0.0014169323414806943, + "mean_prediction": 0.0015233290343619102, + "calibration_in_the_large": 0.00010639669288121587, + "expected_calibration_error_10bin": 0.00010639669288121587, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "E83": { + "valid": 2653, + "positives": 53, + "negatives": 2600, + "auroc": 0.7928374455732946, + "auprc": 0.11582995076557548, + "brier": 0.01867370684595696, + "calibration": { + "observed_rate": 0.01997738409347908, + "mean_prediction": 0.015885192463142867, + "calibration_in_the_large": -0.004092191630336212, + "expected_calibration_error_10bin": 0.005089344210007191, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + "E86": { + "valid": 2587, + "positives": 58, + "negatives": 2529, + "auroc": 0.7767483399462783, + "auprc": 0.07114089518996192, + "brier": 0.02182452833425412, + "calibration": { + "observed_rate": 0.02241979126401237, + "mean_prediction": 0.03163570249696638, + "calibration_in_the_large": 0.00921591123295401, + "expected_calibration_error_10bin": 0.009215911232954007, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + "E87": { + "valid": 2185, + "positives": 97, + "negatives": 2088, + "auroc": 0.779036813208516, + "auprc": 0.14352907092588185, + "brier": 0.040456349395075634, + "calibration": { + "observed_rate": 0.044393592677345536, + "mean_prediction": 0.03976580442112681, + "calibration_in_the_large": -0.0046277882562187275, + "expected_calibration_error_10bin": 0.008236779690372762, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + "E88": { + "valid": 2817, + "positives": 9, + "negatives": 2808, + "auroc": 0.8045267489711934, + "auprc": 0.0852721163770955, + "brier": 0.0031019353602032944, + "calibration": { + "observed_rate": 0.003194888178913738, + "mean_prediction": 0.002818275734867123, + "calibration_in_the_large": -0.0003766124440466147, + "expected_calibration_error_10bin": 0.0003766124440466147, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "E89": { + "valid": 2780, + "positives": 4, + "negatives": 2776, + "auroc": 0.6924531700288185, + "auprc": 0.002799488084918845, + "brier": 0.0014407243602705697, + "calibration": { + "observed_rate": 0.0014388489208633094, + "mean_prediction": 0.0023139964510153197, + "calibration_in_the_large": 0.0008751475301520103, + "expected_calibration_error_10bin": 0.0008751475301520103, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "F02": { + "valid": 2802, + "positives": 1, + "negatives": 2801, + "auroc": 0.6465548018564798, + "auprc": 0.0010090817356205853, + "brier": 0.0003967812412472316, + "calibration": { + "observed_rate": 0.00035688793718772306, + "mean_prediction": 0.0020419196466571173, + "calibration_in_the_large": 0.0016850317094693943, + "expected_calibration_error_10bin": 0.001685031709469394, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "F03": { + "valid": 2739, + "positives": 11, + "negatives": 2728, + "auroc": 0.8508731005065316, + "auprc": 0.027687557341375235, + "brier": 0.004023819622627906, + "calibration": { + "observed_rate": 0.004016064257028112, + "mean_prediction": 0.005045035115240832, + "calibration_in_the_large": 0.0010289708582127202, + "expected_calibration_error_10bin": 0.0010289708582127198, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "F05": { + "valid": 2750, + "positives": 16, + "negatives": 2734, + "auroc": 0.7273454645208486, + "auprc": 0.014314381584063254, + "brier": 0.0059583118304043755, + "calibration": { + "observed_rate": 0.005818181818181818, + "mean_prediction": 0.00939188958354035, + "calibration_in_the_large": 0.0035737077653585324, + "expected_calibration_error_10bin": 0.0035737077653585324, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "F06": { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7096602972399151, + "auprc": 0.0017798440875363953, + "brier": 0.0007174059580060421, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0019159244906021286, + "calibration_in_the_large": 0.0012087109121014213, + "expected_calibration_error_10bin": 0.0012087109121014213, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "F10": { + "valid": 2560, + "positives": 9, + "negatives": 2551, + "auroc": 0.8446360904220567, + "auprc": 0.10926462479217855, + "brier": 0.0033533193560994594, + "calibration": { + "observed_rate": 0.003515625, + "mean_prediction": 0.006601019810386788, + "calibration_in_the_large": 0.0030853948103867876, + "expected_calibration_error_10bin": 0.00336513868669499, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "F11": { + "valid": 2741, + "positives": 8, + "negatives": 2733, + "auroc": 0.8570252469813392, + "auprc": 0.03191779721470629, + "brier": 0.002922974565039722, + "calibration": { + "observed_rate": 0.002918642831083546, + "mean_prediction": 0.003285606426645752, + "calibration_in_the_large": 0.000366963595562206, + "expected_calibration_error_10bin": 0.0003669635955622059, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "F12": { + "valid": 2777, + "positives": 10, + "negatives": 2767, + "auroc": 0.9007950849295265, + "auprc": 0.024981610711261905, + "brier": 0.003562789288644232, + "calibration": { + "observed_rate": 0.0036010082823190494, + "mean_prediction": 0.0025144426478592823, + "calibration_in_the_large": -0.0010865656344597671, + "expected_calibration_error_10bin": 0.0010865656344597671, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "F14": { + "valid": 2787, + "positives": 9, + "negatives": 2778, + "auroc": 0.9474842012638989, + "auprc": 0.041284751801929004, + "brier": 0.003197565637233751, + "calibration": { + "observed_rate": 0.0032292787944025836, + "mean_prediction": 0.0010240873385982305, + "calibration_in_the_large": -0.002205191455804353, + "expected_calibration_error_10bin": 0.002205191455804353, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "F15": { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.9631996213465862, + "auprc": 0.04978348203228184, + "brier": 0.0021081952059674772, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.00038090552316717697, + "calibration_in_the_large": -0.0017444929890538642, + "expected_calibration_error_10bin": 0.0017444929890538642, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "F17": { + "valid": 2426, + "positives": 25, + "negatives": 2401, + "auroc": 0.8911453561016244, + "auprc": 0.09731770607063968, + "brier": 0.009781504744288239, + "calibration": { + "observed_rate": 0.010305028854080791, + "mean_prediction": 0.009874704150600915, + "calibration_in_the_large": -0.00043032470347987607, + "expected_calibration_error_10bin": 0.001942168632275335, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + "F19": { + "valid": 2801, + "positives": 10, + "negatives": 2791, + "auroc": 0.9653529201003225, + "auprc": 0.13130458111649865, + "brier": 0.0034524764870177715, + "calibration": { + "observed_rate": 0.003570153516601214, + "mean_prediction": 0.0011558255334266235, + "calibration_in_the_large": -0.0024143279831745903, + "expected_calibration_error_10bin": 0.0024143279831745903, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F20": { + "valid": 2808, + "positives": 3, + "negatives": 2805, + "auroc": 0.806060606060606, + "auprc": 0.015369066763589482, + "brier": 0.0010641977709638735, + "calibration": { + "observed_rate": 0.0010683760683760685, + "mean_prediction": 0.0006095642219124291, + "calibration_in_the_large": -0.00045881184646363936, + "expected_calibration_error_10bin": 0.00045881184646363936, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + "F22": { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.7439716312056738, + "auprc": 0.0013831258644536654, + "brier": 0.00035608692636843046, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0007013884547575445, + "calibration_in_the_large": 0.0003469042293055771, + "expected_calibration_error_10bin": 0.0003469042293055771, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "F25": { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7971117424242424, + "auprc": 0.005895363254745083, + "brier": 0.0010644579656421778, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0006845738962117341, + "calibration_in_the_large": -0.00037963326944984795, + "expected_calibration_error_10bin": 0.00037963326944984795, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "F29": { + "valid": 2806, + "positives": 7, + "negatives": 2799, + "auroc": 0.7210738529066504, + "auprc": 0.006231725882978329, + "brier": 0.002492088636713055, + "calibration": { + "observed_rate": 0.0024946543121881683, + "mean_prediction": 0.0005402019282033767, + "calibration_in_the_large": -0.0019544523839847916, + "expected_calibration_error_10bin": 0.0019544523839847916, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "F31": { + "valid": 2724, + "positives": 8, + "negatives": 2716, + "auroc": 0.8587997054491899, + "auprc": 0.036986590004020985, + "brier": 0.0028933200186461983, + "calibration": { + "observed_rate": 0.002936857562408223, + "mean_prediction": 0.002176701651756442, + "calibration_in_the_large": -0.0007601559106517812, + "expected_calibration_error_10bin": 0.0007601559106517812, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + "F32": { + "valid": 2200, + "positives": 45, + "negatives": 2155, + "auroc": 0.6978499613302398, + "auprc": 0.05655804065333569, + "brier": 0.02008690535657108, + "calibration": { + "observed_rate": 0.020454545454545454, + "mean_prediction": 0.028577385467784055, + "calibration_in_the_large": 0.0081228400132386, + "expected_calibration_error_10bin": 0.008122840013238602, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + "F33": { + "valid": 2800, + "positives": 7, + "negatives": 2793, + "auroc": 0.7678891105314306, + "auprc": 0.00932421444659277, + "brier": 0.002515565394990297, + "calibration": { + "observed_rate": 0.0025, + "mean_prediction": 0.002418472089363734, + "calibration_in_the_large": -8.152791063626612e-05, + "expected_calibration_error_10bin": 8.152791063626612e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "F39": { + "valid": 2801, + "positives": 8, + "negatives": 2793, + "auroc": 0.74968671679198, + "auprc": 0.02256364892180552, + "brier": 0.0028338670793212764, + "calibration": { + "observed_rate": 0.002856122813280971, + "mean_prediction": 0.002144499025001699, + "calibration_in_the_large": -0.0007116237882792724, + "expected_calibration_error_10bin": 0.0007116237882792724, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F41": { + "valid": 2247, + "positives": 61, + "negatives": 2186, + "auroc": 0.7218589234022768, + "auprc": 0.09948883076451906, + "brier": 0.02558335706919687, + "calibration": { + "observed_rate": 0.027147307521139297, + "mean_prediction": 0.02724200656262865, + "calibration_in_the_large": 9.469904148935379e-05, + "expected_calibration_error_10bin": 0.0033722289362909863, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + "F43": { + "valid": 2734, + "positives": 15, + "negatives": 2719, + "auroc": 0.78146377344612, + "auprc": 0.0705921331907037, + "brier": 0.005373313746450066, + "calibration": { + "observed_rate": 0.005486466715435259, + "mean_prediction": 0.00615014643510445, + "calibration_in_the_large": 0.0006636797196691909, + "expected_calibration_error_10bin": 0.0006636797196691905, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "F60": { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.9412015641663705, + "auprc": 0.02597870645606264, + "brier": 0.0017618499848083848, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0013757513417530821, + "calibration_in_the_large": -0.0003985566781191676, + "expected_calibration_error_10bin": 0.0003985566781191676, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "F90": { + "valid": 2775, + "positives": 7, + "negatives": 2768, + "auroc": 0.8948183319570603, + "auprc": 0.03364919146735235, + "brier": 0.002507757184335655, + "calibration": { + "observed_rate": 0.0025225225225225223, + "mean_prediction": 0.0006612352647442111, + "calibration_in_the_large": -0.0018612872577783114, + "expected_calibration_error_10bin": 0.0018612872577783114, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "G25": { + "valid": 2774, + "positives": 4, + "negatives": 2770, + "auroc": 0.6843862815884476, + "auprc": 0.004017993763354365, + "brier": 0.0014506569086058648, + "calibration": { + "observed_rate": 0.0014419610670511895, + "mean_prediction": 0.0024574540432937323, + "calibration_in_the_large": 0.0010154929762425428, + "expected_calibration_error_10bin": 0.0010154929762425428, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "G31": { + "valid": 2802, + "positives": 2, + "negatives": 2800, + "auroc": 0.7069642857142857, + "auprc": 0.0018231676915406348, + "brier": 0.000789360661767265, + "calibration": { + "observed_rate": 0.0007137758743754461, + "mean_prediction": 0.003256330423895274, + "calibration_in_the_large": 0.002542554549519828, + "expected_calibration_error_10bin": 0.002542554549519828, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "G40": { + "valid": 2723, + "positives": 18, + "negatives": 2705, + "auroc": 0.7218525364551243, + "auprc": 0.04532160801705817, + "brier": 0.006507301961345982, + "calibration": { + "observed_rate": 0.006610356224752111, + "mean_prediction": 0.005460994574194312, + "calibration_in_the_large": -0.0011493616505577993, + "expected_calibration_error_10bin": 0.0014162242972497899, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "G43": { + "valid": 2725, + "positives": 11, + "negatives": 2714, + "auroc": 0.7592952368191868, + "auprc": 0.013072391006007805, + "brier": 0.004014852716633668, + "calibration": { + "observed_rate": 0.004036697247706422, + "mean_prediction": 0.002315814600891109, + "calibration_in_the_large": -0.001720882646815313, + "expected_calibration_error_10bin": 0.001720882646815313, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + "G44": { + "valid": 2805, + "positives": 4, + "negatives": 2801, + "auroc": 0.7228668332738307, + "auprc": 0.005523900037566922, + "brier": 0.001429143297902415, + "calibration": { + "observed_rate": 0.00142602495543672, + "mean_prediction": 0.001248902391467813, + "calibration_in_the_large": -0.0001771225639689072, + "expected_calibration_error_10bin": 0.0001771225639689072, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "G47": { + "valid": 2315, + "positives": 66, + "negatives": 2249, + "auroc": 0.7114070900198067, + "auprc": 0.07312557661687288, + "brier": 0.027236298320137044, + "calibration": { + "observed_rate": 0.028509719222462204, + "mean_prediction": 0.0215837511746414, + "calibration_in_the_large": -0.006925968047820804, + "expected_calibration_error_10bin": 0.007588626065424223, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + "G51": { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 5.026460847142919e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004339487593698941, + "calibration_in_the_large": 0.0004339487593698941, + "expected_calibration_error_10bin": 0.0004339487593698941, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + "G62": { + "valid": 2751, + "positives": 27, + "negatives": 2724, + "auroc": 0.8602681242181976, + "auprc": 0.1257723407419296, + "brier": 0.009219995333476767, + "calibration": { + "observed_rate": 0.009814612868047983, + "mean_prediction": 0.0063791764861875645, + "calibration_in_the_large": -0.0034354363818604183, + "expected_calibration_error_10bin": 0.0034354363818604183, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "G81": { + "valid": 2789, + "positives": 11, + "negatives": 2778, + "auroc": 0.7934092545323647, + "auprc": 0.027452544643030964, + "brier": 0.003916028767020749, + "calibration": { + "observed_rate": 0.003944065973467192, + "mean_prediction": 0.0023254910408770572, + "calibration_in_the_large": -0.0016185749325901351, + "expected_calibration_error_10bin": 0.0017759074405617168, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "G83": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.7424081295049036, + "auprc": 0.004723352704296443, + "brier": 0.0010648054589612876, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0010751586712049639, + "calibration_in_the_large": 1.2835725029326393e-05, + "expected_calibration_error_10bin": 1.2835725029326393e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "G89": { + "valid": 2537, + "positives": 41, + "negatives": 2496, + "auroc": 0.7876700281425891, + "auprc": 0.09616312528736559, + "brier": 0.015492234937794589, + "calibration": { + "observed_rate": 0.016160819865983445, + "mean_prediction": 0.02183410815291098, + "calibration_in_the_large": 0.005673288286927536, + "expected_calibration_error_10bin": 0.006138988045897008, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + "G90": { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 1.253817350461917e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0016118020053863592, + "calibration_in_the_large": 0.0016118020053863592, + "expected_calibration_error_10bin": 0.0016118020053863592, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "G92": { + "valid": 2733, + "positives": 29, + "negatives": 2704, + "auroc": 0.7977198530912059, + "auprc": 0.08292678748516061, + "brier": 0.010325673939821556, + "calibration": { + "observed_rate": 0.010611050128064398, + "mean_prediction": 0.015023137850309102, + "calibration_in_the_large": 0.004412087722244704, + "expected_calibration_error_10bin": 0.00486976695965858, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "G93": { + "valid": 2656, + "positives": 35, + "negatives": 2621, + "auroc": 0.7991824276448466, + "auprc": 0.05732337478969548, + "brier": 0.01272743540531303, + "calibration": { + "observed_rate": 0.013177710843373495, + "mean_prediction": 0.012018580596918307, + "calibration_in_the_large": -0.0011591302464551874, + "expected_calibration_error_10bin": 0.0013568333998887569, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + "G99": { + "valid": 2841, + "positives": 0, + "negatives": 2841, + "auroc": null, + "auprc": null, + "brier": 7.186259657454076e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00033533374064597516, + "calibration_in_the_large": 0.00033533374064597516, + "expected_calibration_error_10bin": 0.00033533374064597516, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9992965177629265 + }, + "H10": { + "valid": 2832, + "positives": 4, + "negatives": 2828, + "auroc": 0.9054101838755304, + "auprc": 0.01595892331358522, + "brier": 0.001407628024255339, + "calibration": { + "observed_rate": 0.0014124293785310734, + "mean_prediction": 0.0007301702681429098, + "calibration_in_the_large": -0.0006822591103881636, + "expected_calibration_error_10bin": 0.0006822591103881636, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "H26": { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 5.4058159868140446e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0012125756380405985, + "calibration_in_the_large": 0.0012125756380405985, + "expected_calibration_error_10bin": 0.0012125756380405985, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "H35": { + "valid": 2806, + "positives": 4, + "negatives": 2802, + "auroc": 0.654621698786581, + "auprc": 0.003903621753260462, + "brier": 0.001425510791942011, + "calibration": { + "observed_rate": 0.0014255167498218105, + "mean_prediction": 0.000615076894867441, + "calibration_in_the_large": -0.0008104398549543695, + "expected_calibration_error_10bin": 0.0008104398549543695, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "H40": { + "valid": 2750, + "positives": 5, + "negatives": 2745, + "auroc": 0.7548998178506375, + "auprc": 0.01155932449811003, + "brier": 0.0018477758272290184, + "calibration": { + "observed_rate": 0.0018181818181818182, + "mean_prediction": 0.003517057608109264, + "calibration_in_the_large": 0.0016988757899274458, + "expected_calibration_error_10bin": 0.0016988757899274458, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "H53": { + "valid": 2790, + "positives": 9, + "negatives": 2781, + "auroc": 0.5754125214750889, + "auprc": 0.009402812097437239, + "brier": 0.0032221329443476044, + "calibration": { + "observed_rate": 0.0032258064516129032, + "mean_prediction": 0.00365118721540096, + "calibration_in_the_large": 0.0004253807637880566, + "expected_calibration_error_10bin": 0.0004253807637880566, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "H54": { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.420377627360171, + "auprc": 0.0008991719216714236, + "brier": 0.0007258267131919758, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.00193558661323473, + "calibration_in_the_large": 0.001223589461223338, + "expected_calibration_error_10bin": 0.001223589461223338, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "H91": { + "valid": 2791, + "positives": 5, + "negatives": 2786, + "auroc": 0.7379038047379756, + "auprc": 0.007876635574969617, + "brier": 0.0017878537772437826, + "calibration": { + "observed_rate": 0.0017914725904693658, + "mean_prediction": 0.0019449292168630954, + "calibration_in_the_large": 0.00015345662639372959, + "expected_calibration_error_10bin": 0.00015345662639372959, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + "I07": { + "valid": 2823, + "positives": 5, + "negatives": 2818, + "auroc": 0.8964513839602555, + "auprc": 0.01084502237808183, + "brier": 0.0017715538963612566, + "calibration": { + "observed_rate": 0.001771165426850868, + "mean_prediction": 0.0008243848880683278, + "calibration_in_the_large": -0.0009467805387825401, + "expected_calibration_error_10bin": 0.0009467805387825401, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "I08": { + "valid": 2767, + "positives": 8, + "negatives": 2759, + "auroc": 0.8621330192098586, + "auprc": 0.018806813535392906, + "brier": 0.003041049374229686, + "calibration": { + "observed_rate": 0.0028912179255511385, + "mean_prediction": 0.0055966981708137735, + "calibration_in_the_large": 0.002705480245262635, + "expected_calibration_error_10bin": 0.0027054802452626354, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + "I10": { + "valid": 1498, + "positives": 31, + "negatives": 1467, + "auroc": 0.6859511401367724, + "auprc": 0.05974013604072841, + "brier": 0.020101754055532425, + "calibration": { + "observed_rate": 0.02069425901201602, + "mean_prediction": 0.014475272037399727, + "calibration_in_the_large": -0.006218986974616293, + "expected_calibration_error_10bin": 0.00757366404259386, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + "I11": { + "valid": 2676, + "positives": 28, + "negatives": 2648, + "auroc": 0.8187446050927925, + "auprc": 0.03909675108448839, + "brier": 0.010317833397945536, + "calibration": { + "observed_rate": 0.01046337817638266, + "mean_prediction": 0.008668181158022707, + "calibration_in_the_large": -0.0017951970183599543, + "expected_calibration_error_10bin": 0.0030804891931440113, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + "I12": { + "valid": 2552, + "positives": 17, + "negatives": 2535, + "auroc": 0.8044320686854624, + "auprc": 0.03277080225882184, + "brier": 0.006658052597712876, + "calibration": { + "observed_rate": 0.0066614420062695925, + "mean_prediction": 0.00500266629015416, + "calibration_in_the_large": -0.001658775716115433, + "expected_calibration_error_10bin": 0.003295870863654888, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + "I13": { + "valid": 2727, + "positives": 18, + "negatives": 2709, + "auroc": 0.869385997292974, + "auprc": 0.06387249527158653, + "brier": 0.006484067245604567, + "calibration": { + "observed_rate": 0.006600660066006601, + "mean_prediction": 0.00755321446500378, + "calibration_in_the_large": 0.0009525543989971795, + "expected_calibration_error_10bin": 0.0019820280313653463, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + "I16": { + "valid": 2390, + "positives": 8, + "negatives": 2382, + "auroc": 0.87053946263644, + "auprc": 0.02336135939183502, + "brier": 0.003318115247654445, + "calibration": { + "observed_rate": 0.0033472803347280333, + "mean_prediction": 0.0017313951050203754, + "calibration_in_the_large": -0.001615885229707658, + "expected_calibration_error_10bin": 0.001615885229707658, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + "I21": { + "valid": 2671, + "positives": 11, + "negatives": 2660, + "auroc": 0.8411825017088175, + "auprc": 0.02832454375024657, + "brier": 0.004217192896280929, + "calibration": { + "observed_rate": 0.0041183077499064025, + "mean_prediction": 0.009724824872303613, + "calibration_in_the_large": 0.0056065171223972105, + "expected_calibration_error_10bin": 0.005606517122397211, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "I24": { + "valid": 2809, + "positives": 5, + "negatives": 2804, + "auroc": 0.8703994293865905, + "auprc": 0.029554895415088316, + "brier": 0.001762226960122071, + "calibration": { + "observed_rate": 0.00177999288002848, + "mean_prediction": 0.001319118841025254, + "calibration_in_the_large": -0.000460874039003226, + "expected_calibration_error_10bin": 0.000460874039003226, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "I25": { + "valid": 2243, + "positives": 30, + "negatives": 2213, + "auroc": 0.830607019129387, + "auprc": 0.06500631317192186, + "brier": 0.012879409809477558, + "calibration": { + "observed_rate": 0.013374944271065538, + "mean_prediction": 0.011155479994069057, + "calibration_in_the_large": -0.0022194642769964804, + "expected_calibration_error_10bin": 0.0032033847086437783, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + "I26": { + "valid": 2760, + "positives": 13, + "negatives": 2747, + "auroc": 0.7679706533001036, + "auprc": 0.1325207957479437, + "brier": 0.004550226911435542, + "calibration": { + "observed_rate": 0.004710144927536232, + "mean_prediction": 0.004695729541698171, + "calibration_in_the_large": -1.4415385838061415e-05, + "expected_calibration_error_10bin": 0.0005572406307138681, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + "I27": { + "valid": 2716, + "positives": 22, + "negatives": 2694, + "auroc": 0.8217250455557805, + "auprc": 0.03624658634498529, + "brier": 0.00799386939193585, + "calibration": { + "observed_rate": 0.008100147275405008, + "mean_prediction": 0.006992391692328001, + "calibration_in_the_large": -0.001107755583077007, + "expected_calibration_error_10bin": 0.0023221994248423155, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I31": { + "valid": 2793, + "positives": 9, + "negatives": 2784, + "auroc": 0.8751596424010217, + "auprc": 0.12586604548206168, + "brier": 0.003176671937327711, + "calibration": { + "observed_rate": 0.00322234156820623, + "mean_prediction": 0.002701678727038942, + "calibration_in_the_large": -0.000520662841167288, + "expected_calibration_error_10bin": 0.000520662841167288, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I34": { + "valid": 2753, + "positives": 14, + "negatives": 2739, + "auroc": 0.7463881500026078, + "auprc": 0.015297809721128194, + "brier": 0.005096953874564262, + "calibration": { + "observed_rate": 0.005085361423901199, + "mean_prediction": 0.003805901036159159, + "calibration_in_the_large": -0.00127946038774204, + "expected_calibration_error_10bin": 0.001591895042604887, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + "I35": { + "valid": 2723, + "positives": 5, + "negatives": 2718, + "auroc": 0.7306107431935247, + "auprc": 0.008750312924807577, + "brier": 0.001888697895956404, + "calibration": { + "observed_rate": 0.001836210062431142, + "mean_prediction": 0.0033158741018788256, + "calibration_in_the_large": 0.0014796640394476835, + "expected_calibration_error_10bin": 0.0014796640394476833, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "I42": { + "valid": 2740, + "positives": 10, + "negatives": 2730, + "auroc": 0.923040293040293, + "auprc": 0.07665753941939193, + "brier": 0.003558563721159224, + "calibration": { + "observed_rate": 0.0036496350364963502, + "mean_prediction": 0.003133865586595589, + "calibration_in_the_large": -0.0005157694499007613, + "expected_calibration_error_10bin": 0.0006003243270601309, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "I44": { + "valid": 2722, + "positives": 14, + "negatives": 2708, + "auroc": 0.8884258282338046, + "auprc": 0.06904046831748567, + "brier": 0.00500350294805011, + "calibration": { + "observed_rate": 0.005143277002204262, + "mean_prediction": 0.006626352454003102, + "calibration_in_the_large": 0.00148307545179884, + "expected_calibration_error_10bin": 0.002137746669806927, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + "I45": { + "valid": 2766, + "positives": 8, + "negatives": 2758, + "auroc": 0.7319162436548223, + "auprc": 0.07347006728419266, + "brier": 0.002876177752367166, + "calibration": { + "observed_rate": 0.0028922631959508315, + "mean_prediction": 0.005060977607482131, + "calibration_in_the_large": 0.0021687144115312995, + "expected_calibration_error_10bin": 0.0021687144115312995, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + "I46": { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.4851590106007067, + "auprc": 0.0006858710562414266, + "brier": 0.00036212112908619125, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.001565822501887906, + "calibration_in_the_large": 0.0012125904284156347, + "expected_calibration_error_10bin": 0.0012125904284156347, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I47": { + "valid": 2716, + "positives": 9, + "negatives": 2707, + "auroc": 0.6649837868899561, + "auprc": 0.00666858489202847, + "brier": 0.003346823346972993, + "calibration": { + "observed_rate": 0.0033136966126656848, + "mean_prediction": 0.00611560153006816, + "calibration_in_the_large": 0.0028019049174024756, + "expected_calibration_error_10bin": 0.0028019049174024756, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I48": { + "valid": 2385, + "positives": 19, + "negatives": 2366, + "auroc": 0.8015971882368643, + "auprc": 0.029234438391274997, + "brier": 0.007864714107101583, + "calibration": { + "observed_rate": 0.007966457023060796, + "mean_prediction": 0.00794879253232506, + "calibration_in_the_large": -1.7664490735735602e-05, + "expected_calibration_error_10bin": 0.00038386986138683665, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + "I49": { + "valid": 2734, + "positives": 12, + "negatives": 2722, + "auroc": 0.7365601273573353, + "auprc": 0.011006411716885644, + "brier": 0.004364428874884036, + "calibration": { + "observed_rate": 0.0043891733723482075, + "mean_prediction": 0.0030933010241730565, + "calibration_in_the_large": -0.001295872348175151, + "expected_calibration_error_10bin": 0.001295872348175151, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I50": { + "valid": 2415, + "positives": 33, + "negatives": 2382, + "auroc": 0.8089077169681703, + "auprc": 0.07212112642458933, + "brier": 0.013343073016680106, + "calibration": { + "observed_rate": 0.013664596273291925, + "mean_prediction": 0.013511850846669584, + "calibration_in_the_large": -0.0001527454266223409, + "expected_calibration_error_10bin": 0.002940497126449074, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + "I51": { + "valid": 2807, + "positives": 5, + "negatives": 2802, + "auroc": 0.8413276231263384, + "auprc": 0.007511945307796593, + "brier": 0.0017758035957628898, + "calibration": { + "observed_rate": 0.0017812611328820805, + "mean_prediction": 0.0015356693152587272, + "calibration_in_the_large": -0.0002455918176233532, + "expected_calibration_error_10bin": 0.0002455918176233532, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "I61": { + "valid": 2802, + "positives": 5, + "negatives": 2797, + "auroc": 0.8150875938505542, + "auprc": 0.006682754731813791, + "brier": 0.0017815140021945695, + "calibration": { + "observed_rate": 0.0017844396859386152, + "mean_prediction": 0.0006287215529845526, + "calibration_in_the_large": -0.0011557181329540627, + "expected_calibration_error_10bin": 0.0011557181329540627, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "I63": { + "valid": 2735, + "positives": 10, + "negatives": 2725, + "auroc": 0.7950091743119266, + "auprc": 0.018509409315296873, + "brier": 0.003655432795411994, + "calibration": { + "observed_rate": 0.003656307129798903, + "mean_prediction": 0.003669255420972926, + "calibration_in_the_large": 1.2948291174022866e-05, + "expected_calibration_error_10bin": 0.0002960854524681256, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + "I65": { + "valid": 2774, + "positives": 3, + "negatives": 2771, + "auroc": 0.7325875135330205, + "auprc": 0.02232500616233866, + "brier": 0.0010820744406278176, + "calibration": { + "observed_rate": 0.0010814708002883922, + "mean_prediction": 0.002166087873785305, + "calibration_in_the_large": 0.001084617073496913, + "expected_calibration_error_10bin": 0.001084617073496913, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "I67": { + "valid": 2773, + "positives": 2, + "negatives": 2771, + "auroc": 0.856910862504511, + "auprc": 0.0037562692663106736, + "brier": 0.0007455973260415573, + "calibration": { + "observed_rate": 0.000721240533717995, + "mean_prediction": 0.0023714074379934586, + "calibration_in_the_large": 0.0016501669042754638, + "expected_calibration_error_10bin": 0.0016501669042754638, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "I69": { + "valid": 2752, + "positives": 14, + "negatives": 2738, + "auroc": 0.7583220285922989, + "auprc": 0.015857550646791077, + "brier": 0.005097237235608872, + "calibration": { + "observed_rate": 0.005087209302325582, + "mean_prediction": 0.005486926458214057, + "calibration_in_the_large": 0.0003997171558884748, + "expected_calibration_error_10bin": 0.0003997171558884746, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + "I70": { + "valid": 2771, + "positives": 5, + "negatives": 2766, + "auroc": 0.8452639190166306, + "auprc": 0.02046931898894722, + "brier": 0.0017925087844507942, + "calibration": { + "observed_rate": 0.001804402742692169, + "mean_prediction": 0.0019269452441005178, + "calibration_in_the_large": 0.00012254250140834888, + "expected_calibration_error_10bin": 0.00012254250140834888, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + "I71": { + "valid": 2769, + "positives": 3, + "negatives": 2766, + "auroc": 0.6753434562545192, + "auprc": 0.0038973925582791846, + "brier": 0.0010888478191413361, + "calibration": { + "observed_rate": 0.0010834236186348862, + "mean_prediction": 0.0017463611024779364, + "calibration_in_the_large": 0.0006629374838430502, + "expected_calibration_error_10bin": 0.0006629374838430502, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + "I72": { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.7728403839317455, + "auprc": 0.009886506773998775, + "brier": 0.0017703795245876577, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0010063237310058925, + "calibration_in_the_large": -0.0007679842888663573, + "expected_calibration_error_10bin": 0.0007679842888663573, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "I73": { + "valid": 2734, + "positives": 6, + "negatives": 2728, + "auroc": 0.822702834799609, + "auprc": 0.05540985197230419, + "brier": 0.0021497378408166087, + "calibration": { + "observed_rate": 0.0021945866861741038, + "mean_prediction": 0.0018399517586090292, + "calibration_in_the_large": -0.0003546349275650746, + "expected_calibration_error_10bin": 0.0003546349275650746, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I74": { + "valid": 2821, + "positives": 4, + "negatives": 2817, + "auroc": 0.5469471068512602, + "auprc": 0.0030713898919901323, + "brier": 0.0014171280085743495, + "calibration": { + "observed_rate": 0.0014179369018078695, + "mean_prediction": 0.0006024081387433143, + "calibration_in_the_large": -0.0008155287630645553, + "expected_calibration_error_10bin": 0.0008155287630645553, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "I77": { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.7155699388709097, + "auprc": 0.006112821476764386, + "brier": 0.0014355375373278619, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.001559311523855893, + "calibration_in_the_large": 0.000123045814699699, + "expected_calibration_error_10bin": 0.000123045814699699, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "I80": { + "valid": 2827, + "positives": 4, + "negatives": 2823, + "auroc": 0.889656393907191, + "auprc": 0.08946448624830129, + "brier": 0.0013876542027213854, + "calibration": { + "observed_rate": 0.0014149274849663955, + "mean_prediction": 0.000935697279620281, + "calibration_in_the_large": -0.00047923020534611444, + "expected_calibration_error_10bin": 0.00047923020534611444, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "I81": { + "valid": 2826, + "positives": 6, + "negatives": 2820, + "auroc": 0.8490543735224586, + "auprc": 0.015546110781377654, + "brier": 0.002170505611954952, + "calibration": { + "observed_rate": 0.0021231422505307855, + "mean_prediction": 0.0016642971378594148, + "calibration_in_the_large": -0.00045884511267137076, + "expected_calibration_error_10bin": 0.0009216756328200292, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I82": { + "valid": 2739, + "positives": 22, + "negatives": 2717, + "auroc": 0.6963562753036437, + "auprc": 0.028467083273206326, + "brier": 0.008011677945486871, + "calibration": { + "observed_rate": 0.008032128514056224, + "mean_prediction": 0.00805867951623634, + "calibration_in_the_large": 2.655100218011512e-05, + "expected_calibration_error_10bin": 0.001050723316064406, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "I85": { + "valid": 2793, + "positives": 4, + "negatives": 2789, + "auroc": 0.9931875224094657, + "auprc": 0.1638167388167388, + "brier": 0.001439580398083525, + "calibration": { + "observed_rate": 0.0014321518080916578, + "mean_prediction": 0.0014811482823725859, + "calibration_in_the_large": 4.899647428092805e-05, + "expected_calibration_error_10bin": 0.0016267682075601444, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I87": { + "valid": 2780, + "positives": 11, + "negatives": 2769, + "auroc": 0.7239567943793296, + "auprc": 0.010722656735612991, + "brier": 0.003952246767011924, + "calibration": { + "observed_rate": 0.003956834532374101, + "mean_prediction": 0.003740446416565038, + "calibration_in_the_large": -0.00021638811580906294, + "expected_calibration_error_10bin": 0.00021638811580906294, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "I89": { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8548032612548742, + "auprc": 0.013245826101434077, + "brier": 0.0017641020379076367, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0004993973515448531, + "calibration_in_the_large": -0.0012698878572308015, + "expected_calibration_error_10bin": 0.0012698878572308015, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I95": { + "valid": 2485, + "positives": 58, + "negatives": 2427, + "auroc": 0.7157694329596636, + "auprc": 0.04974202635189756, + "brier": 0.02267509213123756, + "calibration": { + "observed_rate": 0.023340040241448694, + "mean_prediction": 0.024646177920709614, + "calibration_in_the_large": 0.0013061376792609207, + "expected_calibration_error_10bin": 0.002284372737537508, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + "I96": { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.873452423063318, + "auprc": 0.04470045421749967, + "brier": 0.0013955529997326766, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0012349551519215993, + "calibration_in_the_large": -0.00017797314196748583, + "expected_calibration_error_10bin": 0.00017797314196748583, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I97": { + "valid": 2740, + "positives": 7, + "negatives": 2733, + "auroc": 0.8010558778945167, + "auprc": 0.01152747194698862, + "brier": 0.0025432490819410334, + "calibration": { + "observed_rate": 0.0025547445255474453, + "mean_prediction": 0.002402543053473898, + "calibration_in_the_large": -0.00015220147207354717, + "expected_calibration_error_10bin": 0.00015220147207354717, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "J02": { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.648955012398158, + "auprc": 0.0014794230352403268, + "brier": 0.0007160515308344697, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0012293694964048568, + "calibration_in_the_large": 0.0005214048946349453, + "expected_calibration_error_10bin": 0.0005214048946349453, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J06": { + "valid": 2816, + "positives": 6, + "negatives": 2810, + "auroc": 0.674673784104389, + "auprc": 0.007595194048907297, + "brier": 0.002159315549309715, + "calibration": { + "observed_rate": 0.002130681818181818, + "mean_prediction": 0.002367312231973012, + "calibration_in_the_large": 0.00023663041379119384, + "expected_calibration_error_10bin": 0.00023663041379119368, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "J12": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 3.3802585370223186e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0019177683536681376, + "calibration_in_the_large": 0.0019177683536681376, + "expected_calibration_error_10bin": 0.0019177683536681378, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J15": { + "valid": 2795, + "positives": 9, + "negatives": 2786, + "auroc": 0.7959639467177155, + "auprc": 0.01814628853814872, + "brier": 0.0032576413599870566, + "calibration": { + "observed_rate": 0.0032200357781753132, + "mean_prediction": 0.004541196441581135, + "calibration_in_the_large": 0.001321160663405822, + "expected_calibration_error_10bin": 0.0013211606634058219, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + "J18": { + "valid": 2671, + "positives": 31, + "negatives": 2640, + "auroc": 0.78069403714565, + "auprc": 0.045402940211138096, + "brier": 0.011462236534623938, + "calibration": { + "observed_rate": 0.011606140022463497, + "mean_prediction": 0.01393826454003213, + "calibration_in_the_large": 0.0023321245175686334, + "expected_calibration_error_10bin": 0.002332124517568633, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "J30": { + "valid": 2815, + "positives": 6, + "negatives": 2809, + "auroc": 0.7111664886673786, + "auprc": 0.046531885980045186, + "brier": 0.002116229611564819, + "calibration": { + "observed_rate": 0.0021314387211367673, + "mean_prediction": 0.0022397126105841874, + "calibration_in_the_large": 0.0001082738894474201, + "expected_calibration_error_10bin": 0.00010827388944742036, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "J32": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.5139724089140432, + "auprc": 0.0024987710961822053, + "brier": 0.0007169628077060396, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0008971474526037852, + "calibration_in_the_large": 0.000190183861228741, + "expected_calibration_error_10bin": 0.000190183861228741, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J38": { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.6818986893375841, + "auprc": 0.0021637526376114278, + "brier": 0.0007117265009885534, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0011119299848109125, + "calibration_in_the_large": 0.000403965383041001, + "expected_calibration_error_10bin": 0.000403965383041001, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J43": { + "valid": 2804, + "positives": 5, + "negatives": 2799, + "auroc": 0.5707038227938549, + "auprc": 0.0026546619033872244, + "brier": 0.0017885573225225548, + "calibration": { + "observed_rate": 0.001783166904422254, + "mean_prediction": 0.0012412302740078833, + "calibration_in_the_large": -0.0005419366304143707, + "expected_calibration_error_10bin": 0.0005419366304143707, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "J44": { + "valid": 2570, + "positives": 17, + "negatives": 2553, + "auroc": 0.8312942098108339, + "auprc": 0.0321639477368064, + "brier": 0.006510059641486062, + "calibration": { + "observed_rate": 0.006614785992217899, + "mean_prediction": 0.005665369826068154, + "calibration_in_the_large": -0.0009494161661497448, + "expected_calibration_error_10bin": 0.0009494161661497448, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + "J45": { + "valid": 2518, + "positives": 20, + "negatives": 2498, + "auroc": 0.6843274619695756, + "auprc": 0.017434403933179327, + "brier": 0.007875187583181464, + "calibration": { + "observed_rate": 0.007942811755361398, + "mean_prediction": 0.00553554067098017, + "calibration_in_the_large": -0.0024072710843812276, + "expected_calibration_error_10bin": 0.0024072710843812276, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + "J47": { + "valid": 2825, + "positives": 4, + "negatives": 2821, + "auroc": 0.8995037220843672, + "auprc": 0.009320624694311889, + "brier": 0.0014135723958731054, + "calibration": { + "observed_rate": 0.001415929203539823, + "mean_prediction": 0.0005561778182563851, + "calibration_in_the_large": -0.0008597513852834379, + "expected_calibration_error_10bin": 0.0008597513852834379, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J69": { + "valid": 2777, + "positives": 22, + "negatives": 2755, + "auroc": 0.7808282461639994, + "auprc": 0.0345030734674621, + "brier": 0.0078109801054828286, + "calibration": { + "observed_rate": 0.00792221822110191, + "mean_prediction": 0.007873428564613306, + "calibration_in_the_large": -4.878965648860353e-05, + "expected_calibration_error_10bin": 6.151690559924037e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "J81": { + "valid": 2781, + "positives": 14, + "negatives": 2767, + "auroc": 0.7447983891785843, + "auprc": 0.02084421092059149, + "brier": 0.004992366436363736, + "calibration": { + "observed_rate": 0.005034160373966199, + "mean_prediction": 0.002491991441705914, + "calibration_in_the_large": -0.0025421689322602855, + "expected_calibration_error_10bin": 0.0025421689322602855, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "J84": { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.9161159125571937, + "auprc": 0.0368478594620983, + "brier": 0.002463620384063141, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.0011208873704064975, + "calibration_in_the_large": -0.001364025657637521, + "expected_calibration_error_10bin": 0.001364025657637521, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "J90": { + "valid": 2754, + "positives": 25, + "negatives": 2729, + "auroc": 0.6666617808721144, + "auprc": 0.015890230072349007, + "brier": 0.009108544792777775, + "calibration": { + "observed_rate": 0.00907770515613653, + "mean_prediction": 0.007867426807146648, + "calibration_in_the_large": -0.0012102783489898808, + "expected_calibration_error_10bin": 0.002161635848653054, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + "J91": { + "valid": 2807, + "positives": 9, + "negatives": 2798, + "auroc": 0.8335318878564054, + "auprc": 0.0802306428835185, + "brier": 0.0031229250446408365, + "calibration": { + "observed_rate": 0.003206270039187745, + "mean_prediction": 0.0027254079705428414, + "calibration_in_the_large": -0.00048086206864490343, + "expected_calibration_error_10bin": 0.0004808620686449038, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "J94": { + "valid": 2829, + "positives": 8, + "negatives": 2821, + "auroc": 0.6693991492378589, + "auprc": 0.07000026029751459, + "brier": 0.0027947778655806, + "calibration": { + "observed_rate": 0.002827854365500177, + "mean_prediction": 0.0009065090070935483, + "calibration_in_the_large": -0.0019213453584066287, + "expected_calibration_error_10bin": 0.0019213453584066287, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J95": { + "valid": 2770, + "positives": 12, + "negatives": 2758, + "auroc": 0.8138747884940778, + "auprc": 0.031077866245722795, + "brier": 0.004273746348616705, + "calibration": { + "observed_rate": 0.004332129963898917, + "mean_prediction": 0.0036262792583798952, + "calibration_in_the_large": -0.0007058507055190217, + "expected_calibration_error_10bin": 0.0007058507055190217, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + "J96": { + "valid": 2605, + "positives": 49, + "negatives": 2556, + "auroc": 0.8285426846795056, + "auprc": 0.07410829775850446, + "brier": 0.018135628059787714, + "calibration": { + "observed_rate": 0.018809980806142036, + "mean_prediction": 0.018199337860672144, + "calibration_in_the_large": -0.0006106429454698914, + "expected_calibration_error_10bin": 0.004114541681166094, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + "J98": { + "valid": 2692, + "positives": 20, + "negatives": 2672, + "auroc": 0.7199476047904192, + "auprc": 0.030101250344385676, + "brier": 0.007346294569315276, + "calibration": { + "observed_rate": 0.007429420505200594, + "mean_prediction": 0.007670334248220528, + "calibration_in_the_large": 0.00024091374301993436, + "expected_calibration_error_10bin": 0.00024091374301993436, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + "K04": { + "valid": 2836, + "positives": 1, + "negatives": 2835, + "auroc": 0.9361552028218695, + "auprc": 0.005494505494505495, + "brier": 0.00035285377177682526, + "calibration": { + "observed_rate": 0.0003526093088857546, + "mean_prediction": 0.0005583743598423644, + "calibration_in_the_large": 0.00020576505095660981, + "expected_calibration_error_10bin": 0.00020576505095660981, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "K12": { + "valid": 2824, + "positives": 9, + "negatives": 2815, + "auroc": 0.8656798894809552, + "auprc": 0.07254891577648495, + "brier": 0.0033848531123592054, + "calibration": { + "observed_rate": 0.003186968838526912, + "mean_prediction": 0.0035503989995897436, + "calibration_in_the_large": 0.00036343016106283156, + "expected_calibration_error_10bin": 0.0026551876905598877, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K20": { + "valid": 2813, + "positives": 5, + "negatives": 2808, + "auroc": 0.6876780626780626, + "auprc": 0.03800248299353189, + "brier": 0.0018134371357680932, + "calibration": { + "observed_rate": 0.0017774617845716318, + "mean_prediction": 0.004674344661515664, + "calibration_in_the_large": 0.002896882876944032, + "expected_calibration_error_10bin": 0.002896882876944032, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K21": { + "valid": 2043, + "positives": 56, + "negatives": 1987, + "auroc": 0.760685527356388, + "auprc": 0.11007588932190503, + "brier": 0.025669691473959644, + "calibration": { + "observed_rate": 0.02741067058247675, + "mean_prediction": 0.029553299405469823, + "calibration_in_the_large": 0.0021426288229930736, + "expected_calibration_error_10bin": 0.002668491523606659, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + "K22": { + "valid": 2764, + "positives": 13, + "negatives": 2751, + "auroc": 0.8160668847691749, + "auprc": 0.027039113511108083, + "brier": 0.004639159024013293, + "calibration": { + "observed_rate": 0.004703328509406657, + "mean_prediction": 0.003747112546781269, + "calibration_in_the_large": -0.0009562159626253881, + "expected_calibration_error_10bin": 0.0009562159626253881, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + "K25": { + "valid": 2817, + "positives": 5, + "negatives": 2812, + "auroc": 0.8812233285917497, + "auprc": 0.011794469393016201, + "brier": 0.001800569247378932, + "calibration": { + "observed_rate": 0.001774937877174299, + "mean_prediction": 0.0025468181132074228, + "calibration_in_the_large": 0.0007718802360331238, + "expected_calibration_error_10bin": 0.0007718802360331238, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "K26": { + "valid": 2814, + "positives": 4, + "negatives": 2810, + "auroc": 0.9247330960854092, + "auprc": 0.06324857882253526, + "brier": 0.00140398476980456, + "calibration": { + "observed_rate": 0.0014214641080312722, + "mean_prediction": 0.001270989981697415, + "calibration_in_the_large": -0.00015047412633385727, + "expected_calibration_error_10bin": 0.00015047412633385727, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "K29": { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.8183399304306105, + "auprc": 0.026164782785127766, + "brier": 0.0021742805662602273, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.006103644994912247, + "calibration_in_the_large": 0.003949246431177956, + "expected_calibration_error_10bin": 0.003949246431177956, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K30": { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.9291005291005291, + "auprc": 0.007195692648316812, + "brier": 0.0007066296871692661, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.001041750328339278, + "calibration_in_the_large": 0.0003367802895659259, + "expected_calibration_error_10bin": 0.0003367802895659259, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "K31": { + "valid": 2756, + "positives": 10, + "negatives": 2746, + "auroc": 0.9290968681718864, + "auprc": 0.05201894740430309, + "brier": 0.003558908686868974, + "calibration": { + "observed_rate": 0.00362844702467344, + "mean_prediction": 0.004254850893287441, + "calibration_in_the_large": 0.0006264038686140008, + "expected_calibration_error_10bin": 0.0006264038686140008, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "K40": { + "valid": 2827, + "positives": 2, + "negatives": 2825, + "auroc": 0.8585840707964602, + "auprc": 0.003661979333120273, + "brier": 0.0007070692264099782, + "calibration": { + "observed_rate": 0.0007074637424831977, + "mean_prediction": 0.0009959822997172164, + "calibration_in_the_large": 0.00028851855723401867, + "expected_calibration_error_10bin": 0.00028851855723401867, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "K42": { + "valid": 2820, + "positives": 3, + "negatives": 2817, + "auroc": 0.665956691515797, + "auprc": 0.005313519139631718, + "brier": 0.0010683903258438807, + "calibration": { + "observed_rate": 0.0010638297872340426, + "mean_prediction": 0.0007875736251959317, + "calibration_in_the_large": -0.0002762561620381109, + "expected_calibration_error_10bin": 0.0002762561620381109, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "K43": { + "valid": 2813, + "positives": 4, + "negatives": 2809, + "auroc": 0.7713599145603418, + "auprc": 0.009223143944350089, + "brier": 0.0014217137284241307, + "calibration": { + "observed_rate": 0.0014219694276573053, + "mean_prediction": 0.0012561596174508174, + "calibration_in_the_large": -0.0001658098102064879, + "expected_calibration_error_10bin": 0.0001658098102064879, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K44": { + "valid": 2785, + "positives": 5, + "negatives": 2780, + "auroc": 0.6303597122302158, + "auprc": 0.00531946210459588, + "brier": 0.001794899364484201, + "calibration": { + "observed_rate": 0.0017953321364452424, + "mean_prediction": 0.002012280769298646, + "calibration_in_the_large": 0.0002169486328534036, + "expected_calibration_error_10bin": 0.0002169486328534036, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K52": { + "valid": 2749, + "positives": 26, + "negatives": 2723, + "auroc": 0.7973247831859657, + "auprc": 0.10410382727942488, + "brier": 0.00918765946335039, + "calibration": { + "observed_rate": 0.009457984721716987, + "mean_prediction": 0.00854268096253333, + "calibration_in_the_large": -0.0009153037591836579, + "expected_calibration_error_10bin": 0.0034137355659665473, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + "K55": { + "valid": 2815, + "positives": 8, + "negatives": 2807, + "auroc": 0.8072230138938369, + "auprc": 0.01024047571824811, + "brier": 0.00284885422000391, + "calibration": { + "observed_rate": 0.002841918294849023, + "mean_prediction": 0.0020155089601321765, + "calibration_in_the_large": -0.0008264093347168464, + "expected_calibration_error_10bin": 0.0009075530071873592, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "K56": { + "valid": 2745, + "positives": 21, + "negatives": 2724, + "auroc": 0.7350534927627439, + "auprc": 0.03178256036869932, + "brier": 0.0075358319261249335, + "calibration": { + "observed_rate": 0.007650273224043716, + "mean_prediction": 0.009019041017348028, + "calibration_in_the_large": 0.001368767793304312, + "expected_calibration_error_10bin": 0.0013687677933043128, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + "K57": { + "valid": 2741, + "positives": 16, + "negatives": 2725, + "auroc": 0.7044724770642202, + "auprc": 0.017148775176867942, + "brier": 0.005798902434073038, + "calibration": { + "observed_rate": 0.005837285662167092, + "mean_prediction": 0.003398398444387494, + "calibration_in_the_large": -0.002438887217779598, + "expected_calibration_error_10bin": 0.002438887217779598, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "K58": { + "valid": 2792, + "positives": 7, + "negatives": 2785, + "auroc": 0.7312644267760965, + "auprc": 0.014680350175043494, + "brier": 0.0024967826368966564, + "calibration": { + "observed_rate": 0.002507163323782235, + "mean_prediction": 0.0014421068911642083, + "calibration_in_the_large": -0.001065056432618027, + "expected_calibration_error_10bin": 0.001065056432618027, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "K59": { + "valid": 2560, + "positives": 69, + "negatives": 2491, + "auroc": 0.7510981562610907, + "auprc": 0.11640530189492058, + "brier": 0.025191140714311482, + "calibration": { + "observed_rate": 0.026953125, + "mean_prediction": 0.02157221752795522, + "calibration_in_the_large": -0.0053809074720447825, + "expected_calibration_error_10bin": 0.005813968272468627, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "K62": { + "valid": 2813, + "positives": 10, + "negatives": 2803, + "auroc": 0.8791651801641098, + "auprc": 0.030041479228603295, + "brier": 0.00351612784923358, + "calibration": { + "observed_rate": 0.0035549235691432635, + "mean_prediction": 0.002328052486806003, + "calibration_in_the_large": -0.0012268710823372607, + "expected_calibration_error_10bin": 0.0012268710823372607, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K63": { + "valid": 2810, + "positives": 13, + "negatives": 2797, + "auroc": 0.7099914743818927, + "auprc": 0.010740755894055185, + "brier": 0.0046142645546914, + "calibration": { + "observed_rate": 0.004626334519572953, + "mean_prediction": 0.0028436531696214426, + "calibration_in_the_large": -0.0017826813499515108, + "expected_calibration_error_10bin": 0.0017826813499515108, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "K64": { + "valid": 2801, + "positives": 13, + "negatives": 2788, + "auroc": 0.8023948791524115, + "auprc": 0.016134849200024153, + "brier": 0.004696249352586278, + "calibration": { + "observed_rate": 0.0046411995715815784, + "mean_prediction": 0.0043333154272051635, + "calibration_in_the_large": -0.0003078841443764149, + "expected_calibration_error_10bin": 0.0012157585102864983, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "K65": { + "valid": 2813, + "positives": 9, + "negatives": 2804, + "auroc": 0.8589713108258044, + "auprc": 0.026718494548254847, + "brier": 0.003322062553927448, + "calibration": { + "observed_rate": 0.003199431212228937, + "mean_prediction": 0.006289250449546627, + "calibration_in_the_large": 0.00308981923731769, + "expected_calibration_error_10bin": 0.00308981923731769, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K66": { + "valid": 2796, + "positives": 6, + "negatives": 2790, + "auroc": 0.7306451612903225, + "auprc": 0.023442264431148763, + "brier": 0.0021438301465474163, + "calibration": { + "observed_rate": 0.002145922746781116, + "mean_prediction": 0.003027869380284769, + "calibration_in_the_large": 0.000881946633503653, + "expected_calibration_error_10bin": 0.000881946633503653, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "K70": { + "valid": 2774, + "positives": 1, + "negatives": 2773, + "auroc": 0.9498737829065993, + "auprc": 0.007142857142857143, + "brier": 0.0003720138603104363, + "calibration": { + "observed_rate": 0.0003604902667627974, + "mean_prediction": 0.0007529576815164171, + "calibration_in_the_large": 0.00039246741475361976, + "expected_calibration_error_10bin": 0.00039246741475361976, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "K72": { + "valid": 2787, + "positives": 15, + "negatives": 2772, + "auroc": 0.9526695526695527, + "auprc": 0.2552278624888064, + "brier": 0.004819622781897199, + "calibration": { + "observed_rate": 0.005382131324004306, + "mean_prediction": 0.0027931222107765823, + "calibration_in_the_large": -0.002589009113227724, + "expected_calibration_error_10bin": 0.003972494950496177, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "K74": { + "valid": 2763, + "positives": 6, + "negatives": 2757, + "auroc": 0.9642727602466449, + "auprc": 0.053551078551078546, + "brier": 0.002149434650269027, + "calibration": { + "observed_rate": 0.002171552660152009, + "mean_prediction": 0.00256597322787574, + "calibration_in_the_large": 0.00039442056772373123, + "expected_calibration_error_10bin": 0.00039442056772373167, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "K75": { + "valid": 2798, + "positives": 10, + "negatives": 2788, + "auroc": 0.8107245337159253, + "auprc": 0.02219037483155002, + "brier": 0.003555357229694564, + "calibration": { + "observed_rate": 0.0035739814152966403, + "mean_prediction": 0.0019436964087502456, + "calibration_in_the_large": -0.0016302850065463947, + "expected_calibration_error_10bin": 0.0017848002968663568, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "K76": { + "valid": 2681, + "positives": 21, + "negatives": 2660, + "auroc": 0.8621911922663802, + "auprc": 0.17806712738520608, + "brier": 0.007117212130333847, + "calibration": { + "observed_rate": 0.007832898172323759, + "mean_prediction": 0.004226765007546421, + "calibration_in_the_large": -0.0036061331647773377, + "expected_calibration_error_10bin": 0.004113938659842062, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + "K80": { + "valid": 2731, + "positives": 7, + "negatives": 2724, + "auroc": 0.7153870358716173, + "auprc": 0.006021895576449763, + "brier": 0.0025622938886572587, + "calibration": { + "observed_rate": 0.002563163676309044, + "mean_prediction": 0.0020961606400960483, + "calibration_in_the_large": -0.00046700303621299583, + "expected_calibration_error_10bin": 0.00046700303621299583, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + "K81": { + "valid": 2825, + "positives": 5, + "negatives": 2820, + "auroc": 0.8500709219858156, + "auprc": 0.027010753908186146, + "brier": 0.001756249943315903, + "calibration": { + "observed_rate": 0.0017699115044247787, + "mean_prediction": 0.0010904379462023817, + "calibration_in_the_large": -0.000679473558222397, + "expected_calibration_error_10bin": 0.000679473558222397, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "K82": { + "valid": 2824, + "positives": 4, + "negatives": 2820, + "auroc": 0.5855496453900709, + "auprc": 0.003738424037779566, + "brier": 0.001416991751410708, + "calibration": { + "observed_rate": 0.00141643059490085, + "mean_prediction": 0.0008182743621998422, + "calibration_in_the_large": -0.0005981562327010077, + "expected_calibration_error_10bin": 0.0005981562327010077, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K83": { + "valid": 2757, + "positives": 8, + "negatives": 2749, + "auroc": 0.8815933066569662, + "auprc": 0.13958808255702257, + "brier": 0.0028680618390124037, + "calibration": { + "observed_rate": 0.0029017047515415306, + "mean_prediction": 0.0032250240461718397, + "calibration_in_the_large": 0.00032331929463030916, + "expected_calibration_error_10bin": 0.0008600699089058763, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + "K85": { + "valid": 2779, + "positives": 3, + "negatives": 2776, + "auroc": 0.7501200768491835, + "auprc": 0.022158668038099058, + "brier": 0.0010738826310949512, + "calibration": { + "observed_rate": 0.0010795250089960418, + "mean_prediction": 0.0015912647452490279, + "calibration_in_the_large": 0.0005117397362529861, + "expected_calibration_error_10bin": 0.0005117397362529861, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + "K86": { + "valid": 2785, + "positives": 5, + "negatives": 2780, + "auroc": 0.6831654676258992, + "auprc": 0.011920029131230983, + "brier": 0.0017957501715316986, + "calibration": { + "observed_rate": 0.0017953321364452424, + "mean_prediction": 0.0022555353135657744, + "calibration_in_the_large": 0.00046020317712053196, + "expected_calibration_error_10bin": 0.00046020317712053196, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K90": { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.6024734982332155, + "auprc": 0.0008880994671403197, + "brier": 0.000354492750984855, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0005514646811749349, + "calibration_in_the_large": 0.00019823260770266364, + "expected_calibration_error_10bin": 0.00019823260770266364, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "K91": { + "valid": 2768, + "positives": 17, + "negatives": 2751, + "auroc": 0.8866508435435243, + "auprc": 0.059485487760460004, + "brier": 0.005950326801881608, + "calibration": { + "observed_rate": 0.006141618497109827, + "mean_prediction": 0.005578327461345823, + "calibration_in_the_large": -0.0005632910357640042, + "expected_calibration_error_10bin": 0.0010761533500133977, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "K92": { + "valid": 2751, + "positives": 23, + "negatives": 2728, + "auroc": 0.8466626290960092, + "auprc": 0.08225866449957144, + "brier": 0.008019646561389608, + "calibration": { + "observed_rate": 0.008360596146855689, + "mean_prediction": 0.00806886959576264, + "calibration_in_the_large": -0.00029172655109304876, + "expected_calibration_error_10bin": 0.0008100261659432016, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "K94": { + "valid": 2823, + "positives": 13, + "negatives": 2810, + "auroc": 0.9264166438543663, + "auprc": 0.07867865932148604, + "brier": 0.004429121530629129, + "calibration": { + "observed_rate": 0.004605030109812256, + "mean_prediction": 0.003920479696697609, + "calibration_in_the_large": -0.0006845504131146474, + "expected_calibration_error_10bin": 0.0008717705448363746, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "L02": { + "valid": 2807, + "positives": 13, + "negatives": 2794, + "auroc": 0.7604482132041187, + "auprc": 0.022786330499090107, + "brier": 0.004584742622765637, + "calibration": { + "observed_rate": 0.004631278945493409, + "mean_prediction": 0.004775958947603775, + "calibration_in_the_large": 0.00014468000211036603, + "expected_calibration_error_10bin": 0.00014468000211036603, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "L03": { + "valid": 2701, + "positives": 27, + "negatives": 2674, + "auroc": 0.7281226626776365, + "auprc": 0.04266472054997929, + "brier": 0.009796749641879751, + "calibration": { + "observed_rate": 0.009996297667530544, + "mean_prediction": 0.006782070056158861, + "calibration_in_the_large": -0.0032142276113716834, + "expected_calibration_error_10bin": 0.0032142276113716834, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + "L08": { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.6696637168141593, + "auprc": 0.0071099816114909425, + "brier": 0.001764584977554842, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.0011477243743468763, + "calibration_in_the_large": -0.0006190600779499434, + "expected_calibration_error_10bin": 0.0006190600779499434, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + "L27": { + "valid": 2818, + "positives": 7, + "negatives": 2811, + "auroc": 0.7475224881841744, + "auprc": 0.010105616218748642, + "brier": 0.002721527980550885, + "calibration": { + "observed_rate": 0.00248403122782115, + "mean_prediction": 0.004349235103316813, + "calibration_in_the_large": 0.0018652038754956636, + "expected_calibration_error_10bin": 0.0018652038754956631, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "L29": { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.5694148306088604, + "auprc": 0.002889072459688942, + "brier": 0.001104712314291977, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.0029924262467910046, + "calibration_in_the_large": 0.0019274635204864251, + "expected_calibration_error_10bin": 0.0019274635204864251, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "L30": { + "valid": 2816, + "positives": 6, + "negatives": 2810, + "auroc": 0.7149466192170818, + "auprc": 0.023494887872473832, + "brier": 0.002117656900684508, + "calibration": { + "observed_rate": 0.002130681818181818, + "mean_prediction": 0.001527467978093, + "calibration_in_the_large": -0.000603213840088818, + "expected_calibration_error_10bin": 0.000603213840088818, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "L50": { + "valid": 2835, + "positives": 2, + "negatives": 2833, + "auroc": 0.7829156371337804, + "auprc": 0.015539910709905312, + "brier": 0.0007038223738098903, + "calibration": { + "observed_rate": 0.0007054673721340388, + "mean_prediction": 0.0009260064736101038, + "calibration_in_the_large": 0.00022053910147606492, + "expected_calibration_error_10bin": 0.00022053910147606492, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + "L53": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 5.165391560243218e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0011394980755677938, + "calibration_in_the_large": 0.0011394980755677938, + "expected_calibration_error_10bin": 0.0011394980755677938, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "L76": { + "valid": 2793, + "positives": 10, + "negatives": 2783, + "auroc": 0.5904060366510959, + "auprc": 0.004707106435741041, + "brier": 0.003609180749808833, + "calibration": { + "observed_rate": 0.0035803795202291443, + "mean_prediction": 0.004543196420011916, + "calibration_in_the_large": 0.0009628168997827717, + "expected_calibration_error_10bin": 0.0009628168997827717, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "L89": { + "valid": 2798, + "positives": 15, + "negatives": 2783, + "auroc": 0.8590729428674093, + "auprc": 0.025685819952697773, + "brier": 0.005321998441324884, + "calibration": { + "observed_rate": 0.005360972122944961, + "mean_prediction": 0.004321109337828755, + "calibration_in_the_large": -0.0010398627851162063, + "expected_calibration_error_10bin": 0.0014180224514502816, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "L97": { + "valid": 2789, + "positives": 5, + "negatives": 2784, + "auroc": 0.960632183908046, + "auprc": 0.08953395556157226, + "brier": 0.0017707151020797832, + "calibration": { + "observed_rate": 0.0017927572606669057, + "mean_prediction": 0.003675807759791157, + "calibration_in_the_large": 0.0018830504991242515, + "expected_calibration_error_10bin": 0.0022037455699445785, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "L98": { + "valid": 2824, + "positives": 5, + "negatives": 2819, + "auroc": 0.6526427811280596, + "auprc": 0.005562335060209188, + "brier": 0.0017818825072115454, + "calibration": { + "observed_rate": 0.0017705382436260624, + "mean_prediction": 0.0028596383874518873, + "calibration_in_the_large": 0.001089100143825825, + "expected_calibration_error_10bin": 0.001089100143825825, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "M10": { + "valid": 2713, + "positives": 10, + "negatives": 2703, + "auroc": 0.8211986681465039, + "auprc": 0.035987116436239884, + "brier": 0.003633012338248071, + "calibration": { + "observed_rate": 0.003685956505713233, + "mean_prediction": 0.003625024233347694, + "calibration_in_the_large": -6.093227236553863e-05, + "expected_calibration_error_10bin": 0.0002569557955798738, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + "M16": { + "valid": 2790, + "positives": 2, + "negatives": 2788, + "auroc": 0.8671090387374462, + "auprc": 0.01611433305716653, + "brier": 0.0007145951624621604, + "calibration": { + "observed_rate": 0.0007168458781362007, + "mean_prediction": 0.0009180322386244917, + "calibration_in_the_large": 0.00020118636048829103, + "expected_calibration_error_10bin": 0.00020118636048829103, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "M17": { + "valid": 2733, + "positives": 7, + "negatives": 2726, + "auroc": 0.7216748768472906, + "auprc": 0.00624573195328213, + "brier": 0.0025669475641782965, + "calibration": { + "observed_rate": 0.002561287961946579, + "mean_prediction": 0.0018168494984342884, + "calibration_in_the_large": -0.0007444384635122907, + "expected_calibration_error_10bin": 0.0007444384635122907, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "M19": { + "valid": 2674, + "positives": 25, + "negatives": 2649, + "auroc": 0.7004907512268781, + "auprc": 0.023875460323747533, + "brier": 0.009230523952694726, + "calibration": { + "observed_rate": 0.009349289454001496, + "mean_prediction": 0.008409271026871733, + "calibration_in_the_large": -0.0009400184271297629, + "expected_calibration_error_10bin": 0.0010258797315298848, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + "M21": { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.9765957446808511, + "auprc": 0.014925373134328358, + "brier": 0.00035487475765968264, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0011304617084749039, + "calibration_in_the_large": 0.0007759774830229365, + "expected_calibration_error_10bin": 0.0007759774830229365, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "M25": { + "valid": 2717, + "positives": 22, + "negatives": 2695, + "auroc": 0.6377635351661326, + "auprc": 0.015678463044623177, + "brier": 0.008053941202466204, + "calibration": { + "observed_rate": 0.008097165991902834, + "mean_prediction": 0.00852460970265402, + "calibration_in_the_large": 0.00042744371075118665, + "expected_calibration_error_10bin": 0.00042744371075118827, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + "M35": { + "valid": 2806, + "positives": 1, + "negatives": 2805, + "auroc": 0.877361853832442, + "auprc": 0.002898550724637681, + "brier": 0.00035886978628487987, + "calibration": { + "observed_rate": 0.0003563791874554526, + "mean_prediction": 0.0006839848434715943, + "calibration_in_the_large": 0.0003276056560161417, + "expected_calibration_error_10bin": 0.0003276056560161417, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "M46": { + "valid": 2814, + "positives": 3, + "negatives": 2811, + "auroc": 0.5576900272738052, + "auprc": 0.0016444852642380431, + "brier": 0.001070583390859156, + "calibration": { + "observed_rate": 0.0010660980810234541, + "mean_prediction": 0.0016025866260258124, + "calibration_in_the_large": 0.0005364885450023582, + "expected_calibration_error_10bin": 0.0005364885450023582, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "M47": { + "valid": 2743, + "positives": 4, + "negatives": 2739, + "auroc": 0.7495436290617014, + "auprc": 0.00839621359032706, + "brier": 0.001454267852233176, + "calibration": { + "observed_rate": 0.0014582573824279985, + "mean_prediction": 0.0016951954949851668, + "calibration_in_the_large": 0.00023693811255716835, + "expected_calibration_error_10bin": 0.00023693811255716835, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "M48": { + "valid": 2690, + "positives": 7, + "negatives": 2683, + "auroc": 0.7396304776103508, + "auprc": 0.011055065458285504, + "brier": 0.002605186072040574, + "calibration": { + "observed_rate": 0.0026022304832713753, + "mean_prediction": 0.004127727458626227, + "calibration_in_the_large": 0.0015254969753548515, + "expected_calibration_error_10bin": 0.0015254969753548515, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + "M51": { + "valid": 2785, + "positives": 1, + "negatives": 2784, + "auroc": 0.9730603448275862, + "auprc": 0.013157894736842105, + "brier": 0.00036120903047007403, + "calibration": { + "observed_rate": 0.0003590664272890485, + "mean_prediction": 0.0019894942343322798, + "calibration_in_the_large": 0.0016304278070432313, + "expected_calibration_error_10bin": 0.0016304278070432313, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "M54": { + "valid": 2567, + "positives": 29, + "negatives": 2538, + "auroc": 0.7010135594141463, + "auprc": 0.0304718681220128, + "brier": 0.011144467600435392, + "calibration": { + "observed_rate": 0.011297234125438255, + "mean_prediction": 0.011469263779155454, + "calibration_in_the_large": 0.00017202965371719905, + "expected_calibration_error_10bin": 0.00017202965371719857, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + "M62": { + "valid": 2781, + "positives": 6, + "negatives": 2775, + "auroc": 0.8174774774774775, + "auprc": 0.015110735686700886, + "brier": 0.0021449770985028736, + "calibration": { + "observed_rate": 0.002157497303128371, + "mean_prediction": 0.0024059923750236454, + "calibration_in_the_large": 0.0002484950718952745, + "expected_calibration_error_10bin": 0.0002484950718952745, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "M79": { + "valid": 2697, + "positives": 23, + "negatives": 2674, + "auroc": 0.7904458391597021, + "auprc": 0.03283026817446329, + "brier": 0.008399433507901186, + "calibration": { + "observed_rate": 0.008527994067482388, + "mean_prediction": 0.010345344211126466, + "calibration_in_the_large": 0.001817350143644078, + "expected_calibration_error_10bin": 0.001817350143644079, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + "M81": { + "valid": 2705, + "positives": 8, + "negatives": 2697, + "auroc": 0.7794308490915832, + "auprc": 0.02704421379207761, + "brier": 0.0029556802099622165, + "calibration": { + "observed_rate": 0.0029574861367837337, + "mean_prediction": 0.0036338229021136434, + "calibration_in_the_large": 0.0006763367653299097, + "expected_calibration_error_10bin": 0.0006763367653299093, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + "M84": { + "valid": 2818, + "positives": 3, + "negatives": 2815, + "auroc": 0.6955595026642984, + "auprc": 0.02448697348531961, + "brier": 0.0010630718502938796, + "calibration": { + "observed_rate": 0.0010645848119233499, + "mean_prediction": 0.001769370370170946, + "calibration_in_the_large": 0.000704785558247596, + "expected_calibration_error_10bin": 0.000704785558247596, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "M85": { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.7241165209292699, + "auprc": 0.006481758423708646, + "brier": 0.0025276558542333496, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.0022048826971371393, + "calibration_in_the_large": -0.000324019036966907, + "expected_calibration_error_10bin": 0.000324019036966907, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "M86": { + "valid": 2803, + "positives": 11, + "negatives": 2792, + "auroc": 0.8181166970565251, + "auprc": 0.06030678055885777, + "brier": 0.003830669276190159, + "calibration": { + "observed_rate": 0.00392436674991081, + "mean_prediction": 0.002527253513232605, + "calibration_in_the_large": -0.001397113236678205, + "expected_calibration_error_10bin": 0.001634816597255495, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + "M94": { + "valid": 2819, + "positives": 2, + "negatives": 2817, + "auroc": 0.7204472843450479, + "auprc": 0.0020668359978086555, + "brier": 0.0007093668628729898, + "calibration": { + "observed_rate": 0.000709471443774388, + "mean_prediction": 0.00022697764812624587, + "calibration_in_the_large": -0.00048249379564814217, + "expected_calibration_error_10bin": 0.00048249379564814217, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "M96": { + "valid": 2804, + "positives": 2, + "negatives": 2802, + "auroc": 0.8276231263383298, + "auprc": 0.0031110293975344003, + "brier": 0.00072745149895155, + "calibration": { + "observed_rate": 0.0007132667617689016, + "mean_prediction": 0.002681832621981529, + "calibration_in_the_large": 0.0019685658602126275, + "expected_calibration_error_10bin": 0.0019685658602126275, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "N12": { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.5925008843296781, + "auprc": 0.002334982068087375, + "brier": 0.0014212013303869153, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.001342790899893368, + "calibration_in_the_large": -7.013739399571719e-05, + "expected_calibration_error_10bin": 7.013739399571719e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N13": { + "valid": 2756, + "positives": 7, + "negatives": 2749, + "auroc": 0.5855116146131061, + "auprc": 0.004638117567970723, + "brier": 0.0025583251678348703, + "calibration": { + "observed_rate": 0.0025399129172714078, + "mean_prediction": 0.003362765904531484, + "calibration_in_the_large": 0.0008228529872600764, + "expected_calibration_error_10bin": 0.0008228529872600764, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "N14": { + "valid": 2826, + "positives": 7, + "negatives": 2819, + "auroc": 0.875791820807784, + "auprc": 0.0177181986129834, + "brier": 0.0024645557524285203, + "calibration": { + "observed_rate": 0.0024769992922859165, + "mean_prediction": 0.0010145932440543933, + "calibration_in_the_large": -0.0014624060482315232, + "expected_calibration_error_10bin": 0.0014624060482315232, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "N17": { + "valid": 2292, + "positives": 64, + "negatives": 2228, + "auroc": 0.7852614452423698, + "auprc": 0.0998243798454646, + "brier": 0.026577238263258793, + "calibration": { + "observed_rate": 0.027923211169284468, + "mean_prediction": 0.031173427978050644, + "calibration_in_the_large": 0.0032502168087661758, + "expected_calibration_error_10bin": 0.005992594325842247, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + "N18": { + "valid": 2440, + "positives": 32, + "negatives": 2408, + "auroc": 0.8597383720930233, + "auprc": 0.12022374629674779, + "brier": 0.012335253720574308, + "calibration": { + "observed_rate": 0.013114754098360656, + "mean_prediction": 0.007908700371322606, + "calibration_in_the_large": -0.00520605372703805, + "expected_calibration_error_10bin": 0.005390310286062142, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + "N20": { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7370889921372409, + "auprc": 0.006302429771726917, + "brier": 0.0028466972925128837, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.000833791882509433, + "calibration_in_the_large": -0.002017241617134188, + "expected_calibration_error_10bin": 0.002017241617134188, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "N25": { + "valid": 2831, + "positives": 6, + "negatives": 2825, + "auroc": 0.9589380530973451, + "auprc": 0.09240040424694641, + "brier": 0.002081831531260574, + "calibration": { + "observed_rate": 0.0021193924408336277, + "mean_prediction": 0.0008618835232779372, + "calibration_in_the_large": -0.0012575089175556906, + "expected_calibration_error_10bin": 0.0013284409134518278, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N28": { + "valid": 2789, + "positives": 4, + "negatives": 2785, + "auroc": 0.7959605026929982, + "auprc": 0.00995501674479044, + "brier": 0.0014377298060336123, + "calibration": { + "observed_rate": 0.0014342058085335247, + "mean_prediction": 0.003271339188211582, + "calibration_in_the_large": 0.0018371333796780573, + "expected_calibration_error_10bin": 0.0018371333796780573, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "N30": { + "valid": 2829, + "positives": 9, + "negatives": 2820, + "auroc": 0.6773049645390071, + "auprc": 0.009914816273942664, + "brier": 0.003188148184838638, + "calibration": { + "observed_rate": 0.003181336161187699, + "mean_prediction": 0.00273112460875553, + "calibration_in_the_large": -0.00045021155243216886, + "expected_calibration_error_10bin": 0.0005413368146835042, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N32": { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.8005720414730068, + "auprc": 0.13201176854640834, + "brier": 0.003468266093418486, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.003315499549301162, + "calibration_in_the_large": -0.0002470227164629991, + "expected_calibration_error_10bin": 0.0002470227164629991, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "N39": { + "valid": 2520, + "positives": 61, + "negatives": 2459, + "auroc": 0.7720851472343149, + "auprc": 0.0819303822214136, + "brier": 0.02304162560767732, + "calibration": { + "observed_rate": 0.024206349206349207, + "mean_prediction": 0.026769220118645565, + "calibration_in_the_large": 0.0025628709122963583, + "expected_calibration_error_10bin": 0.002697960582205154, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + "N40": { + "valid": 2606, + "positives": 13, + "negatives": 2593, + "auroc": 0.8150345605031297, + "auprc": 0.026751029744850687, + "brier": 0.004978770352583539, + "calibration": { + "observed_rate": 0.0049884881043745204, + "mean_prediction": 0.007598480298241206, + "calibration_in_the_large": 0.002609992193866686, + "expected_calibration_error_10bin": 0.002609992193866685, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + "N73": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9785992217898832, + "auprc": 0.050595238095238096, + "brier": 0.0006976733965996816, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0007136173994150202, + "calibration_in_the_large": 6.653808039975987e-06, + "expected_calibration_error_10bin": 6.653808039975987e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N99": { + "valid": 2799, + "positives": 3, + "negatives": 2796, + "auroc": 0.7308059132093467, + "auprc": 0.007163375773063949, + "brier": 0.0010706967899283353, + "calibration": { + "observed_rate": 0.0010718113612004287, + "mean_prediction": 0.0012524831685587561, + "calibration_in_the_large": 0.00018067180735832741, + "expected_calibration_error_10bin": 0.00018067180735832741, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + "O69": { + "valid": 2743, + "positives": 5, + "negatives": 2738, + "auroc": 0.9981738495252008, + "auprc": 0.38298368298368296, + "brier": 0.0016948854857289266, + "calibration": { + "observed_rate": 0.0018228217280349982, + "mean_prediction": 0.00036534076522938265, + "calibration_in_the_large": -0.0014574809628056155, + "expected_calibration_error_10bin": 0.0015552562113168016, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "O99": { + "valid": 2652, + "positives": 1, + "negatives": 2651, + "auroc": 0.999622783855149, + "auprc": 0.5, + "brier": 0.00026387063020177545, + "calibration": { + "observed_rate": 0.0003770739064856712, + "mean_prediction": 0.0003344823055253996, + "calibration_in_the_large": -4.259160096027159e-05, + "expected_calibration_error_10bin": 0.0005660747930411268, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + "Q21": { + "valid": 2810, + "positives": 2, + "negatives": 2808, + "auroc": 0.8529202279202279, + "auprc": 0.00413079923912693, + "brier": 0.0007109724445345698, + "calibration": { + "observed_rate": 0.0007117437722419929, + "mean_prediction": 0.0009673448586125951, + "calibration_in_the_large": 0.0002556010863706021, + "expected_calibration_error_10bin": 0.0002556010863706021, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "U07": { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 2.0299019864786516e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0023119786086015053, + "calibration_in_the_large": 0.0023119786086015053, + "expected_calibration_error_10bin": 0.0023119786086015053, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + } + }, + "180": { + "A04": { + "valid": 2782, + "positives": 21, + "negatives": 2761, + "auroc": 0.7360342181059313, + "auprc": 0.04756087487764919, + "brier": 0.007431035710147347, + "calibration": { + "observed_rate": 0.007548526240115025, + "mean_prediction": 0.007429221620015588, + "calibration_in_the_large": -0.00011930462009943684, + "expected_calibration_error_10bin": 0.00017952413419877506, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "A08": { + "valid": 2818, + "positives": 11, + "negatives": 2807, + "auroc": 0.8127084885189624, + "auprc": 0.029260888597767667, + "brier": 0.003847630327043297, + "calibration": { + "observed_rate": 0.0039034776437189495, + "mean_prediction": 0.003375941500622481, + "calibration_in_the_large": -0.0005275361430964686, + "expected_calibration_error_10bin": 0.0005275361430964686, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "A41": { + "valid": 2664, + "positives": 49, + "negatives": 2615, + "auroc": 0.7495219885277247, + "auprc": 0.06219035182383311, + "brier": 0.017940245044447342, + "calibration": { + "observed_rate": 0.01839339339339339, + "mean_prediction": 0.021253452548443783, + "calibration_in_the_large": 0.002860059155050391, + "expected_calibration_error_10bin": 0.002971455668538492, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + "B00": { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.6959043560606061, + "auprc": 0.01949272288933122, + "brier": 0.001087818648353656, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0014263986384737018, + "calibration_in_the_large": 0.00036219147281211974, + "expected_calibration_error_10bin": 0.0003621914728121196, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "B02": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7824548991864166, + "auprc": 0.0016233766233766235, + "brier": 0.0003549963880356371, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0005707628735976682, + "calibration_in_the_large": 0.0002171560843473146, + "expected_calibration_error_10bin": 0.0002171560843473146, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "B18": { + "valid": 2782, + "positives": 5, + "negatives": 2777, + "auroc": 0.9680950666186532, + "auprc": 0.08994597397823204, + "brier": 0.0017351546425813185, + "calibration": { + "observed_rate": 0.0017972681524083393, + "mean_prediction": 0.001002815331405376, + "calibration_in_the_large": -0.0007944528210029633, + "expected_calibration_error_10bin": 0.0007944528210029633, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "B19": { + "valid": 2763, + "positives": 15, + "negatives": 2748, + "auroc": 0.84463852498787, + "auprc": 0.07306564879754131, + "brier": 0.005308785778168112, + "calibration": { + "observed_rate": 0.0054288816503800215, + "mean_prediction": 0.00154467507664963, + "calibration_in_the_large": -0.0038842065737303916, + "expected_calibration_error_10bin": 0.004059731191326597, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "B20": { + "valid": 2829, + "positives": 3, + "negatives": 2826, + "auroc": 0.9877329558858221, + "auprc": 0.11646545942320591, + "brier": 0.0010526403126242324, + "calibration": { + "observed_rate": 0.0010604453870625664, + "mean_prediction": 0.00023379547146029574, + "calibration_in_the_large": -0.0008266499156022707, + "expected_calibration_error_10bin": 0.0008266499156022707, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "B34": { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.9736469755925009, + "auprc": 0.036195856603018425, + "brier": 0.0014014423241147113, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0010032004338086675, + "calibration_in_the_large": -0.0004097278600804176, + "expected_calibration_error_10bin": 0.0004097278600804176, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "B35": { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 8.527163344004138e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0012929379103290136, + "calibration_in_the_large": 0.0012929379103290136, + "expected_calibration_error_10bin": 0.0012929379103290136, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "B37": { + "valid": 2768, + "positives": 26, + "negatives": 2742, + "auroc": 0.7523144251809459, + "auprc": 0.028802334450055162, + "brier": 0.009318449550101075, + "calibration": { + "observed_rate": 0.00939306358381503, + "mean_prediction": 0.008214623548424059, + "calibration_in_the_large": -0.0011784400353909708, + "expected_calibration_error_10bin": 0.0024908302313181494, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "B95": { + "valid": 2678, + "positives": 42, + "negatives": 2636, + "auroc": 0.7007370474745285, + "auprc": 0.03318868631030191, + "brier": 0.015641621382594947, + "calibration": { + "observed_rate": 0.01568334578043316, + "mean_prediction": 0.019489696587200636, + "calibration_in_the_large": 0.0038063508067674758, + "expected_calibration_error_10bin": 0.0038063508067674775, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + "B96": { + "valid": 2630, + "positives": 61, + "negatives": 2569, + "auroc": 0.7701791218117657, + "auprc": 0.08243834503811502, + "brier": 0.02211030049523188, + "calibration": { + "observed_rate": 0.023193916349809884, + "mean_prediction": 0.026337286727277195, + "calibration_in_the_large": 0.0031433703774673104, + "expected_calibration_error_10bin": 0.003143370377467308, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + "B97": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7633533781393703, + "auprc": 0.0014925373134328358, + "brier": 0.0003628513678285792, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0006936673131694139, + "calibration_in_the_large": 0.0003400605239190603, + "expected_calibration_error_10bin": 0.00034006052391906036, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "C18": { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9780297661233168, + "auprc": 0.042261904761904764, + "brier": 0.0007030991331385299, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0005347387465061531, + "calibration_in_the_large": -0.00017347655094427186, + "expected_calibration_error_10bin": 0.00017347655094427186, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "C22": { + "valid": 2812, + "positives": 5, + "negatives": 2807, + "auroc": 0.9153544709654435, + "auprc": 0.060322515870585326, + "brier": 0.001747218117061817, + "calibration": { + "observed_rate": 0.0017780938833570413, + "mean_prediction": 0.0006611074772143033, + "calibration_in_the_large": -0.0011169864061427379, + "expected_calibration_error_10bin": 0.0011169864061427379, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + "C25": { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.9428215176344852, + "auprc": 0.16978193146417445, + "brier": 0.000683416122738082, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0004786934134901102, + "calibration_in_the_large": -0.0002333037385212818, + "expected_calibration_error_10bin": 0.00033199446331004127, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "C61": { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9661077417053158, + "auprc": 0.016993006993006994, + "brier": 0.0007109523360756232, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0008626853959295447, + "calibration_in_the_large": 0.0001496729182111846, + "expected_calibration_error_10bin": 0.0001496729182111846, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "C67": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9522461973823841, + "auprc": 0.03331801470588235, + "brier": 0.0007031322150965236, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.000599776793303456, + "calibration_in_the_large": -0.0001071867980715882, + "expected_calibration_error_10bin": 0.0001071867980715882, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "C77": { + "valid": 2762, + "positives": 16, + "negatives": 2746, + "auroc": 0.8404042243262928, + "auprc": 0.11543122699415845, + "brier": 0.005501438471005535, + "calibration": { + "observed_rate": 0.005792903692976104, + "mean_prediction": 0.0035446311117575046, + "calibration_in_the_large": -0.0022482725812185992, + "expected_calibration_error_10bin": 0.0028904365367192417, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C78": { + "valid": 2762, + "positives": 23, + "negatives": 2739, + "auroc": 0.8639617759575853, + "auprc": 0.1422446438347636, + "brier": 0.00777035313508506, + "calibration": { + "observed_rate": 0.00832729905865315, + "mean_prediction": 0.00512411198707698, + "calibration_in_the_large": -0.00320318707157617, + "expected_calibration_error_10bin": 0.0046862986525084225, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C79": { + "valid": 2751, + "positives": 16, + "negatives": 2735, + "auroc": 0.8785420475319927, + "auprc": 0.141265414158312, + "brier": 0.006082428121369399, + "calibration": { + "observed_rate": 0.0058160668847691745, + "mean_prediction": 0.007142389420115161, + "calibration_in_the_large": 0.0013263225353459867, + "expected_calibration_error_10bin": 0.0035116790583793423, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "C83": { + "valid": 2820, + "positives": 0, + "negatives": 2820, + "auroc": null, + "auprc": null, + "brier": 1.53415125825947e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00044731414271603087, + "calibration_in_the_large": 0.00044731414271603087, + "expected_calibration_error_10bin": 0.00044731414271603087, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "D25": { + "valid": 2792, + "positives": 2, + "negatives": 2790, + "auroc": 0.9372759856630825, + "auprc": 0.25284900284900286, + "brier": 0.0007085688401575147, + "calibration": { + "observed_rate": 0.0007163323782234957, + "mean_prediction": 0.00038763569158029384, + "calibration_in_the_large": -0.00032869668664320184, + "expected_calibration_error_10bin": 0.00032869668664320184, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "D47": { + "valid": 2796, + "positives": 6, + "negatives": 2790, + "auroc": 0.5955794504181601, + "auprc": 0.003716315913289718, + "brier": 0.002213492914552572, + "calibration": { + "observed_rate": 0.002145922746781116, + "mean_prediction": 0.00401428055664862, + "calibration_in_the_large": 0.001868357809867504, + "expected_calibration_error_10bin": 0.001868357809867504, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "D50": { + "valid": 2663, + "positives": 42, + "negatives": 2621, + "auroc": 0.7998582874584401, + "auprc": 0.09475295452465307, + "brier": 0.014907514260547164, + "calibration": { + "observed_rate": 0.015771686068343973, + "mean_prediction": 0.012514289277707133, + "calibration_in_the_large": -0.00325739679063684, + "expected_calibration_error_10bin": 0.0032573967906368386, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + "D53": { + "valid": 2805, + "positives": 12, + "negatives": 2793, + "auroc": 0.8306480486931614, + "auprc": 0.025538576371290186, + "brier": 0.0043222209034165585, + "calibration": { + "observed_rate": 0.0042780748663101605, + "mean_prediction": 0.0051810200217122055, + "calibration_in_the_large": 0.000902945155402045, + "expected_calibration_error_10bin": 0.0009029451554020461, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "D59": { + "valid": 2836, + "positives": 1, + "negatives": 2835, + "auroc": 0.9767195767195768, + "auprc": 0.014925373134328358, + "brier": 0.00035272854822490163, + "calibration": { + "observed_rate": 0.0003526093088857546, + "mean_prediction": 0.0006596067518386971, + "calibration_in_the_large": 0.0003069974429529425, + "expected_calibration_error_10bin": 0.0003069974429529425, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "D61": { + "valid": 2773, + "positives": 24, + "negatives": 2749, + "auroc": 0.8979022674912089, + "auprc": 0.14102718757106544, + "brier": 0.00807614897988707, + "calibration": { + "observed_rate": 0.00865488640461594, + "mean_prediction": 0.00852368378368821, + "calibration_in_the_large": -0.00013120262092772977, + "expected_calibration_error_10bin": 0.002990374408510219, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "D62": { + "valid": 2499, + "positives": 49, + "negatives": 2450, + "auroc": 0.7996917950853811, + "auprc": 0.05935058108085419, + "brier": 0.018863334791027305, + "calibration": { + "observed_rate": 0.0196078431372549, + "mean_prediction": 0.019933864094491, + "calibration_in_the_large": 0.0003260209572360992, + "expected_calibration_error_10bin": 0.0018318281447956134, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + "D63": { + "valid": 2686, + "positives": 62, + "negatives": 2624, + "auroc": 0.8785958398898505, + "auprc": 0.1367386937140342, + "brier": 0.021370685475674778, + "calibration": { + "observed_rate": 0.02308265078183172, + "mean_prediction": 0.019857998818401338, + "calibration_in_the_large": -0.0032246519634303826, + "expected_calibration_error_10bin": 0.007867729256337823, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + "D64": { + "valid": 2434, + "positives": 89, + "negatives": 2345, + "auroc": 0.8133106537936322, + "auprc": 0.1513736405781658, + "brier": 0.03300169856269511, + "calibration": { + "observed_rate": 0.03656532456861134, + "mean_prediction": 0.03905833399678208, + "calibration_in_the_large": 0.0024930094281707393, + "expected_calibration_error_10bin": 0.0030091552741270036, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + "D65": { + "valid": 2833, + "positives": 3, + "negatives": 2830, + "auroc": 0.9617196702002355, + "auprc": 0.01766148991127106, + "brier": 0.0010586512179167691, + "calibration": { + "observed_rate": 0.0010589481115425344, + "mean_prediction": 0.0008759226374661254, + "calibration_in_the_large": -0.00018302547407640906, + "expected_calibration_error_10bin": 0.00018302547407640906, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + "D68": { + "valid": 2682, + "positives": 44, + "negatives": 2638, + "auroc": 0.8057068026742022, + "auprc": 0.08573959847259821, + "brier": 0.015691434787907334, + "calibration": { + "observed_rate": 0.01640566741237882, + "mean_prediction": 0.010190081000763861, + "calibration_in_the_large": -0.0062155864116149595, + "expected_calibration_error_10bin": 0.007043702310372399, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + "D69": { + "valid": 2586, + "positives": 60, + "negatives": 2526, + "auroc": 0.8515373449458961, + "auprc": 0.21620584896760234, + "brier": 0.02020673610845373, + "calibration": { + "observed_rate": 0.02320185614849188, + "mean_prediction": 0.017257487924064726, + "calibration_in_the_large": -0.005944368224427152, + "expected_calibration_error_10bin": 0.006886767513255181, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + "D70": { + "valid": 2787, + "positives": 22, + "negatives": 2765, + "auroc": 0.8923886240341936, + "auprc": 0.23739689617693954, + "brier": 0.00746744933321381, + "calibration": { + "observed_rate": 0.007893792608539648, + "mean_prediction": 0.007307758041519235, + "calibration_in_the_large": -0.0005860345670204124, + "expected_calibration_error_10bin": 0.0052684772316072305, + "nonempty_bins": 8 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "D72": { + "valid": 2595, + "positives": 46, + "negatives": 2549, + "auroc": 0.7195745987343716, + "auprc": 0.05896415087303386, + "brier": 0.01715693344039814, + "calibration": { + "observed_rate": 0.017726396917148363, + "mean_prediction": 0.019494765087009293, + "calibration_in_the_large": 0.0017683681698609302, + "expected_calibration_error_10bin": 0.0017683681698609332, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + "D73": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.8244121469927922, + "auprc": 0.02135302795997085, + "brier": 0.001070486929185017, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0012110697438802627, + "calibration_in_the_large": 0.00014874679770462518, + "expected_calibration_error_10bin": 0.00014874679770462534, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "D75": { + "valid": 2831, + "positives": 3, + "negatives": 2828, + "auroc": 0.8730551626591231, + "auprc": 0.005394681196860044, + "brier": 0.001060690038738493, + "calibration": { + "observed_rate": 0.0010596962204168139, + "mean_prediction": 0.001108622061750143, + "calibration_in_the_large": 4.8925841333329187e-05, + "expected_calibration_error_10bin": 4.8925841333329187e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "D80": { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.9882637414484549, + "auprc": 0.09622775372775372, + "brier": 0.002064391867014502, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.0012921444211258725, + "calibration_in_the_large": -0.0008264996466707376, + "expected_calibration_error_10bin": 0.001284557542815384, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "D89": { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.828395061728395, + "auprc": 0.006937548993990071, + "brier": 0.0008208879656628991, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0008304606452263318, + "calibration_in_the_large": 0.00012549060645297965, + "expected_calibration_error_10bin": 0.0007383671315615266, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "E03": { + "valid": 2480, + "positives": 18, + "negatives": 2462, + "auroc": 0.7489168697535878, + "auprc": 0.0206364891868379, + "brier": 0.007180034096980154, + "calibration": { + "observed_rate": 0.007258064516129033, + "mean_prediction": 0.004476648749386508, + "calibration_in_the_large": -0.0027814157667425243, + "expected_calibration_error_10bin": 0.0027814157667425243, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + "E04": { + "valid": 2775, + "positives": 9, + "negatives": 2766, + "auroc": 0.7683779223909376, + "auprc": 0.009948291807011825, + "brier": 0.003234023250061297, + "calibration": { + "observed_rate": 0.003243243243243243, + "mean_prediction": 0.0026689508190978453, + "calibration_in_the_large": -0.0005742924241453977, + "expected_calibration_error_10bin": 0.0005742924241453977, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "E05": { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.10859486447931527, + "auprc": 0.0005892333736645114, + "brier": 0.0007151831386979978, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0009740935658733448, + "calibration_in_the_large": 0.00026133519096243956, + "expected_calibration_error_10bin": 0.00026133519096243956, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "E11": { + "valid": 2194, + "positives": 15, + "negatives": 2179, + "auroc": 0.7940339605323543, + "auprc": 0.0734259662933246, + "brier": 0.006677848711683165, + "calibration": { + "observed_rate": 0.0068368277119416595, + "mean_prediction": 0.005676156037881782, + "calibration_in_the_large": -0.0011606716740598776, + "expected_calibration_error_10bin": 0.0012570914441776477, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + "E16": { + "valid": 2816, + "positives": 5, + "negatives": 2811, + "auroc": 0.624404126645322, + "auprc": 0.0030308161374016295, + "brier": 0.0017878397073544912, + "calibration": { + "observed_rate": 0.0017755681818181818, + "mean_prediction": 0.0023107748992352776, + "calibration_in_the_large": 0.0005352067174170959, + "expected_calibration_error_10bin": 0.0005352067174170959, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "E21": { + "valid": 2814, + "positives": 1, + "negatives": 2813, + "auroc": 0.9811589050835408, + "auprc": 0.018518518518518517, + "brier": 0.0003692901830526412, + "calibration": { + "observed_rate": 0.00035536602700781805, + "mean_prediction": 0.0013991962200760638, + "calibration_in_the_large": 0.0010438301930682458, + "expected_calibration_error_10bin": 0.0010438301930682458, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "E22": { + "valid": 2802, + "positives": 6, + "negatives": 2796, + "auroc": 0.8491297091082499, + "auprc": 0.011900414652370043, + "brier": 0.00219279234206114, + "calibration": { + "observed_rate": 0.0021413276231263384, + "mean_prediction": 0.004715528055673455, + "calibration_in_the_large": 0.002574200432547116, + "expected_calibration_error_10bin": 0.002574200432547116, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "E27": { + "valid": 2811, + "positives": 5, + "negatives": 2806, + "auroc": 0.7812544547398432, + "auprc": 0.005653244005247849, + "brier": 0.0017855600794792323, + "calibration": { + "observed_rate": 0.0017787264318747777, + "mean_prediction": 0.0018853845173827841, + "calibration_in_the_large": 0.00010665808550800642, + "expected_calibration_error_10bin": 0.00010665808550800642, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + }, + "E43": { + "valid": 2748, + "positives": 32, + "negatives": 2716, + "auroc": 0.8334177098674521, + "auprc": 0.07526547495090878, + "brier": 0.011243739521222394, + "calibration": { + "observed_rate": 0.011644832605531296, + "mean_prediction": 0.012162243176558871, + "calibration_in_the_large": 0.0005174105710275753, + "expected_calibration_error_10bin": 0.001264678488675813, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + "E44": { + "valid": 2800, + "positives": 15, + "negatives": 2785, + "auroc": 0.7679712746858168, + "auprc": 0.01882735732930482, + "brier": 0.005424499828094548, + "calibration": { + "observed_rate": 0.005357142857142857, + "mean_prediction": 0.00771549717916579, + "calibration_in_the_large": 0.0023583543220229326, + "expected_calibration_error_10bin": 0.002358354322022933, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "E46": { + "valid": 2772, + "positives": 30, + "negatives": 2742, + "auroc": 0.8199367858011184, + "auprc": 0.07533912027068576, + "brier": 0.010454537804116032, + "calibration": { + "observed_rate": 0.010822510822510822, + "mean_prediction": 0.01108059980471301, + "calibration_in_the_large": 0.0002580889822021877, + "expected_calibration_error_10bin": 0.0005275520459632854, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + "E53": { + "valid": 2804, + "positives": 4, + "negatives": 2800, + "auroc": 0.7416071428571429, + "auprc": 0.0043742920507181425, + "brier": 0.0014402850392695537, + "calibration": { + "observed_rate": 0.0014265335235378032, + "mean_prediction": 0.0022241811638923797, + "calibration_in_the_large": 0.0007976476403545765, + "expected_calibration_error_10bin": 0.0007976476403545765, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "E55": { + "valid": 2737, + "positives": 21, + "negatives": 2716, + "auroc": 0.5843502349393366, + "auprc": 0.011098687065932972, + "brier": 0.007733672082418567, + "calibration": { + "observed_rate": 0.0076726342710997444, + "mean_prediction": 0.0084528515172716, + "calibration_in_the_large": 0.0007802172461718552, + "expected_calibration_error_10bin": 0.0007802172461718571, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + "E66": { + "valid": 2371, + "positives": 29, + "negatives": 2342, + "auroc": 0.7121970611619894, + "auprc": 0.032934504465434486, + "brier": 0.012020938746309238, + "calibration": { + "observed_rate": 0.012231126107127795, + "mean_prediction": 0.01204351952173486, + "calibration_in_the_large": -0.0001876065853929354, + "expected_calibration_error_10bin": 0.0009757303584432635, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + "E78": { + "valid": 1572, + "positives": 31, + "negatives": 1541, + "auroc": 0.7010110736639383, + "auprc": 0.05716035658040881, + "brier": 0.019969352155540986, + "calibration": { + "observed_rate": 0.019720101781170483, + "mean_prediction": 0.023380317527346244, + "calibration_in_the_large": 0.0036602157461757615, + "expected_calibration_error_10bin": 0.00687393052837087, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + "E80": { + "valid": 2823, + "positives": 4, + "negatives": 2819, + "auroc": 0.9701135154310039, + "auprc": 0.0316027133270714, + "brier": 0.0014129596587814913, + "calibration": { + "observed_rate": 0.0014169323414806943, + "mean_prediction": 0.001639817930825594, + "calibration_in_the_large": 0.00022288558934489963, + "expected_calibration_error_10bin": 0.00022288558934489963, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "E83": { + "valid": 2653, + "positives": 58, + "negatives": 2595, + "auroc": 0.7963789781409873, + "auprc": 0.11766813332112755, + "brier": 0.020409300083120908, + "calibration": { + "observed_rate": 0.02186204297022239, + "mean_prediction": 0.01778420864476633, + "calibration_in_the_large": -0.00407783432545606, + "expected_calibration_error_10bin": 0.005807619946375152, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + "E86": { + "valid": 2587, + "positives": 71, + "negatives": 2516, + "auroc": 0.7919960142412503, + "auprc": 0.09053125463579527, + "brier": 0.026064234383803165, + "calibration": { + "observed_rate": 0.027444916892153073, + "mean_prediction": 0.033898246326536166, + "calibration_in_the_large": 0.006453329434383093, + "expected_calibration_error_10bin": 0.006453329434383093, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + "E87": { + "valid": 2185, + "positives": 107, + "negatives": 2078, + "auroc": 0.781606145377025, + "auprc": 0.1560872840089439, + "brier": 0.04422703793309166, + "calibration": { + "observed_rate": 0.04897025171624714, + "mean_prediction": 0.04344874293369175, + "calibration_in_the_large": -0.00552150878255539, + "expected_calibration_error_10bin": 0.010188543411835952, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + "E88": { + "valid": 2817, + "positives": 10, + "negatives": 2807, + "auroc": 0.8156394727467047, + "auprc": 0.07996371773482376, + "brier": 0.0034498077262182483, + "calibration": { + "observed_rate": 0.003549875754348598, + "mean_prediction": 0.002937515275853102, + "calibration_in_the_large": -0.000612360478495496, + "expected_calibration_error_10bin": 0.0006842794492291542, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "E89": { + "valid": 2780, + "positives": 5, + "negatives": 2775, + "auroc": 0.6926126126126126, + "auprc": 0.0033173642844381707, + "brier": 0.0018004402597659372, + "calibration": { + "observed_rate": 0.0017985611510791368, + "mean_prediction": 0.0025379194855952147, + "calibration_in_the_large": 0.0007393583345160779, + "expected_calibration_error_10bin": 0.0007393583345160779, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "F02": { + "valid": 2802, + "positives": 3, + "negatives": 2799, + "auroc": 0.8376801238537573, + "auprc": 0.0067320145207121805, + "brier": 0.0011044224289963988, + "calibration": { + "observed_rate": 0.0010706638115631692, + "mean_prediction": 0.0022130275786319447, + "calibration_in_the_large": 0.0011423637670687754, + "expected_calibration_error_10bin": 0.0011423637670687757, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "F03": { + "valid": 2739, + "positives": 12, + "negatives": 2727, + "auroc": 0.8590636841461924, + "auprc": 0.027683525453171015, + "brier": 0.0044047520594994016, + "calibration": { + "observed_rate": 0.004381161007667032, + "mean_prediction": 0.005647545209832014, + "calibration_in_the_large": 0.0012663842021649824, + "expected_calibration_error_10bin": 0.0012663842021649826, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "F05": { + "valid": 2750, + "positives": 19, + "negatives": 2731, + "auroc": 0.7207500626336989, + "auprc": 0.015615620180567063, + "brier": 0.007080370007413691, + "calibration": { + "observed_rate": 0.006909090909090909, + "mean_prediction": 0.010448716089681098, + "calibration_in_the_large": 0.003539625180590189, + "expected_calibration_error_10bin": 0.0035396251805901876, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "F06": { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7172682236376504, + "auprc": 0.001831946755407654, + "brier": 0.000720084753059133, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.002180147043195208, + "calibration_in_the_large": 0.0014729334646945008, + "expected_calibration_error_10bin": 0.0014729334646945008, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "F10": { + "valid": 2560, + "positives": 10, + "negatives": 2550, + "auroc": 0.8270196078431372, + "auprc": 0.15606579920853206, + "brier": 0.0037416570320296743, + "calibration": { + "observed_rate": 0.00390625, + "mean_prediction": 0.007068332020548951, + "calibration_in_the_large": 0.0031620820205489506, + "expected_calibration_error_10bin": 0.003396452466381561, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "F11": { + "valid": 2741, + "positives": 8, + "negatives": 2733, + "auroc": 0.8562019758507134, + "auprc": 0.033931140313108864, + "brier": 0.0029372754012955316, + "calibration": { + "observed_rate": 0.002918642831083546, + "mean_prediction": 0.0036486667900853587, + "calibration_in_the_large": 0.0007300239590018126, + "expected_calibration_error_10bin": 0.0007300239590018129, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "F12": { + "valid": 2777, + "positives": 11, + "negatives": 2766, + "auroc": 0.8969959902714784, + "auprc": 0.02468955805660947, + "brier": 0.003919010806228045, + "calibration": { + "observed_rate": 0.003961109110550955, + "mean_prediction": 0.002812901922371678, + "calibration_in_the_large": -0.0011482071881792765, + "expected_calibration_error_10bin": 0.0011482071881792765, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "F14": { + "valid": 2787, + "positives": 9, + "negatives": 2778, + "auroc": 0.947244220462363, + "auprc": 0.04055648450899321, + "brier": 0.003197043762941404, + "calibration": { + "observed_rate": 0.0032292787944025836, + "mean_prediction": 0.0011055177718553371, + "calibration_in_the_large": -0.0021237610225472462, + "expected_calibration_error_10bin": 0.0021237610225472462, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "F15": { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.962312152407999, + "auprc": 0.049083945200244006, + "brier": 0.002107428741446621, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.00041918159348651695, + "calibration_in_the_large": -0.0017062169187345244, + "expected_calibration_error_10bin": 0.0017062169187345244, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "F17": { + "valid": 2426, + "positives": 25, + "negatives": 2401, + "auroc": 0.8919283631820075, + "auprc": 0.09725459618677533, + "brier": 0.009778214723433381, + "calibration": { + "observed_rate": 0.010305028854080791, + "mean_prediction": 0.010493403668507706, + "calibration_in_the_large": 0.00018837481442691463, + "expected_calibration_error_10bin": 0.0014494406012357552, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + "F19": { + "valid": 2801, + "positives": 10, + "negatives": 2791, + "auroc": 0.9655678968111788, + "auprc": 0.13730662252290943, + "brier": 0.0034404110521934657, + "calibration": { + "observed_rate": 0.003570153516601214, + "mean_prediction": 0.001315942234483017, + "calibration_in_the_large": -0.0022542112821181967, + "expected_calibration_error_10bin": 0.0022542112821181967, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F20": { + "valid": 2808, + "positives": 3, + "negatives": 2805, + "auroc": 0.8030897207367795, + "auprc": 0.015263397019516062, + "brier": 0.0010642062477158388, + "calibration": { + "observed_rate": 0.0010683760683760685, + "mean_prediction": 0.000678865195416353, + "calibration_in_the_large": -0.0003895108729597155, + "expected_calibration_error_10bin": 0.0003895108729597155, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + "F22": { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.7400709219858156, + "auprc": 0.0013623978201634877, + "brier": 0.0003564692729831947, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.000784976552647705, + "calibration_in_the_large": 0.0004304923271957376, + "expected_calibration_error_10bin": 0.0004304923271957376, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "F25": { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7926136363636364, + "auprc": 0.006082863877901634, + "brier": 0.0010651140465036512, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0007854460855524378, + "calibration_in_the_large": -0.00027876108010914424, + "expected_calibration_error_10bin": 0.00027876108010914424, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "F29": { + "valid": 2806, + "positives": 7, + "negatives": 2799, + "auroc": 0.7258204460776808, + "auprc": 0.006302579458523601, + "brier": 0.002491989357346362, + "calibration": { + "observed_rate": 0.0024946543121881683, + "mean_prediction": 0.0005751231002497911, + "calibration_in_the_large": -0.0019195312119383774, + "expected_calibration_error_10bin": 0.0019195312119383774, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "F31": { + "valid": 2724, + "positives": 8, + "negatives": 2716, + "auroc": 0.8552558910162003, + "auprc": 0.036920600116885235, + "brier": 0.0028934109338826547, + "calibration": { + "observed_rate": 0.002936857562408223, + "mean_prediction": 0.0022913713854559024, + "calibration_in_the_large": -0.0006454861769523207, + "expected_calibration_error_10bin": 0.0006454861769523207, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + "F32": { + "valid": 2200, + "positives": 47, + "negatives": 2153, + "auroc": 0.6928481781976658, + "auprc": 0.05595672375785261, + "brier": 0.02110048533942111, + "calibration": { + "observed_rate": 0.021363636363636362, + "mean_prediction": 0.031176308580748314, + "calibration_in_the_large": 0.009812672217111951, + "expected_calibration_error_10bin": 0.00981267221711195, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + "F33": { + "valid": 2800, + "positives": 9, + "negatives": 2791, + "auroc": 0.7915522114733867, + "auprc": 0.012731127806678406, + "brier": 0.003216652344591163, + "calibration": { + "observed_rate": 0.0032142857142857142, + "mean_prediction": 0.0025908967643226786, + "calibration_in_the_large": -0.0006233889499630356, + "expected_calibration_error_10bin": 0.0006233889499630356, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "F39": { + "valid": 2801, + "positives": 9, + "negatives": 2792, + "auroc": 0.7690226042661573, + "auprc": 0.02334627690220218, + "brier": 0.0031859445033756892, + "calibration": { + "observed_rate": 0.0032131381649410924, + "mean_prediction": 0.002232776119759788, + "calibration_in_the_large": -0.0009803620451813043, + "expected_calibration_error_10bin": 0.0009803620451813043, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F41": { + "valid": 2247, + "positives": 66, + "negatives": 2181, + "auroc": 0.7258902644047073, + "auprc": 0.10344624270186306, + "brier": 0.027582935366087115, + "calibration": { + "observed_rate": 0.029372496662216287, + "mean_prediction": 0.029352690991280333, + "calibration_in_the_large": -1.980567093595384e-05, + "expected_calibration_error_10bin": 0.00263244738111386, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + "F43": { + "valid": 2734, + "positives": 16, + "negatives": 2718, + "auroc": 0.7940351361295069, + "auprc": 0.08208001257881274, + "brier": 0.005715728246747531, + "calibration": { + "observed_rate": 0.005852231163130944, + "mean_prediction": 0.006727002451085433, + "calibration_in_the_large": 0.0008747712879544891, + "expected_calibration_error_10bin": 0.00087477128795449, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "F60": { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.9375044436544614, + "auprc": 0.024893751408401305, + "brier": 0.0017640170882302023, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0015476129466539118, + "calibration_in_the_large": -0.00022669507321833792, + "expected_calibration_error_10bin": 0.00022669507321833792, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "F90": { + "valid": 2775, + "positives": 7, + "negatives": 2768, + "auroc": 0.8921345995045417, + "auprc": 0.03284284931943995, + "brier": 0.002507656548537169, + "calibration": { + "observed_rate": 0.0025225225225225223, + "mean_prediction": 0.0006807762795676706, + "calibration_in_the_large": -0.0018417462429548518, + "expected_calibration_error_10bin": 0.0018417462429548518, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "G25": { + "valid": 2774, + "positives": 4, + "negatives": 2770, + "auroc": 0.6765342960288808, + "auprc": 0.003950726967118256, + "brier": 0.001454675638781966, + "calibration": { + "observed_rate": 0.0014419610670511895, + "mean_prediction": 0.002738832771785157, + "calibration_in_the_large": 0.0012968717047339676, + "expected_calibration_error_10bin": 0.0012968717047339676, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "G31": { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8120085775553967, + "auprc": 0.005434880160489917, + "brier": 0.001514208153904758, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.0037343433156809503, + "calibration_in_the_large": 0.0023067915669300583, + "expected_calibration_error_10bin": 0.002306791566930058, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "G40": { + "valid": 2723, + "positives": 20, + "negatives": 2703, + "auroc": 0.7418793932667407, + "auprc": 0.04783283705959561, + "brier": 0.007218647425134686, + "calibration": { + "observed_rate": 0.007344840249724568, + "mean_prediction": 0.006163734201905731, + "calibration_in_the_large": -0.001181106047818837, + "expected_calibration_error_10bin": 0.0014900585264581018, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "G43": { + "valid": 2725, + "positives": 11, + "negatives": 2714, + "auroc": 0.7592952368191868, + "auprc": 0.013754693122425297, + "brier": 0.004012587121587464, + "calibration": { + "observed_rate": 0.004036697247706422, + "mean_prediction": 0.0026759861798000034, + "calibration_in_the_large": -0.0013607110679064185, + "expected_calibration_error_10bin": 0.0013607110679064185, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + "G44": { + "valid": 2805, + "positives": 4, + "negatives": 2801, + "auroc": 0.7172438414851838, + "auprc": 0.0053077722896870735, + "brier": 0.0014319475568216893, + "calibration": { + "observed_rate": 0.00142602495543672, + "mean_prediction": 0.0013828625962349426, + "calibration_in_the_large": -4.31623592017775e-05, + "expected_calibration_error_10bin": 4.31623592017775e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "G47": { + "valid": 2315, + "positives": 70, + "negatives": 2245, + "auroc": 0.6999045497931912, + "auprc": 0.07709936314393791, + "brier": 0.028819487022349762, + "calibration": { + "observed_rate": 0.03023758099352052, + "mean_prediction": 0.023503610634694548, + "calibration_in_the_large": -0.006733970358825971, + "expected_calibration_error_10bin": 0.007286135017440392, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + "G51": { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 5.384535159495669e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004529534658922592, + "calibration_in_the_large": 0.0004529534658922592, + "expected_calibration_error_10bin": 0.0004529534658922592, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + "G62": { + "valid": 2751, + "positives": 28, + "negatives": 2723, + "auroc": 0.8591364566392109, + "auprc": 0.12407453503496643, + "brier": 0.009562949207510463, + "calibration": { + "observed_rate": 0.010178117048346057, + "mean_prediction": 0.006903236277206956, + "calibration_in_the_large": -0.0032748807711391005, + "expected_calibration_error_10bin": 0.003274880771139099, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "G81": { + "valid": 2789, + "positives": 12, + "negatives": 2777, + "auroc": 0.7425579162165407, + "auprc": 0.025481990524437472, + "brier": 0.004275889294725581, + "calibration": { + "observed_rate": 0.004302617425600574, + "mean_prediction": 0.0024051924008868385, + "calibration_in_the_large": -0.0018974250247137353, + "expected_calibration_error_10bin": 0.0020648167728582684, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "G83": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.7383906416164481, + "auprc": 0.004733533692863606, + "brier": 0.0010653671330907541, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0011293177431070944, + "calibration_in_the_large": 6.699479693145693e-05, + "expected_calibration_error_10bin": 6.699479693145693e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "G89": { + "valid": 2537, + "positives": 45, + "negatives": 2492, + "auroc": 0.7567415730337078, + "auprc": 0.08948661763879182, + "brier": 0.017127180061815385, + "calibration": { + "observed_rate": 0.017737485218762318, + "mean_prediction": 0.023736585800390606, + "calibration_in_the_large": 0.0059991005816282875, + "expected_calibration_error_10bin": 0.006272368612724906, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + "G90": { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 1.540678624379365e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001774123925815134, + "calibration_in_the_large": 0.001774123925815134, + "expected_calibration_error_10bin": 0.001774123925815134, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "G92": { + "valid": 2733, + "positives": 32, + "negatives": 2701, + "auroc": 0.7797343576453165, + "auprc": 0.07783195431743, + "brier": 0.011450710201198658, + "calibration": { + "observed_rate": 0.011708744968898645, + "mean_prediction": 0.016211635648165527, + "calibration_in_the_large": 0.004502890679266881, + "expected_calibration_error_10bin": 0.004858444947472609, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "G93": { + "valid": 2656, + "positives": 37, + "negatives": 2619, + "auroc": 0.7956306822286203, + "auprc": 0.05859272208002482, + "brier": 0.013462333336069344, + "calibration": { + "observed_rate": 0.013930722891566265, + "mean_prediction": 0.013095156145597236, + "calibration_in_the_large": -0.000835566745969029, + "expected_calibration_error_10bin": 0.0018609427851110215, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + "G99": { + "valid": 2841, + "positives": 0, + "negatives": 2841, + "auroc": null, + "auprc": null, + "brier": 8.219112726136195e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00036455545543247084, + "calibration_in_the_large": 0.00036455545543247084, + "expected_calibration_error_10bin": 0.00036455545543247084, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9992965177629265 + }, + "H10": { + "valid": 2832, + "positives": 4, + "negatives": 2828, + "auroc": 0.9061173974540311, + "auprc": 0.015007420997154882, + "brier": 0.0014077102411443978, + "calibration": { + "observed_rate": 0.0014124293785310734, + "mean_prediction": 0.0007938634842950916, + "calibration_in_the_large": -0.0006185658942359819, + "expected_calibration_error_10bin": 0.0006185658942359819, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "H26": { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 6.451940407148011e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0013357899371466571, + "calibration_in_the_large": 0.0013357899371466571, + "expected_calibration_error_10bin": 0.0013357899371466571, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "H35": { + "valid": 2806, + "positives": 4, + "negatives": 2802, + "auroc": 0.6531049250535332, + "auprc": 0.003989381655586642, + "brier": 0.0014258988498746018, + "calibration": { + "observed_rate": 0.0014255167498218105, + "mean_prediction": 0.0007032909153308236, + "calibration_in_the_large": -0.0007222258344909869, + "expected_calibration_error_10bin": 0.0007222258344909869, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "H40": { + "valid": 2750, + "positives": 5, + "negatives": 2745, + "auroc": 0.7535154826958106, + "auprc": 0.010940046807945305, + "brier": 0.0018605002717161994, + "calibration": { + "observed_rate": 0.0018181818181818182, + "mean_prediction": 0.003801313070122639, + "calibration_in_the_large": 0.001983131251940821, + "expected_calibration_error_10bin": 0.0019831312519408215, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "H53": { + "valid": 2790, + "positives": 9, + "negatives": 2781, + "auroc": 0.5877182468336729, + "auprc": 0.009623857642685418, + "brier": 0.00322426057822827, + "calibration": { + "observed_rate": 0.0032258064516129032, + "mean_prediction": 0.004233168740704652, + "calibration_in_the_large": 0.0010073622890917487, + "expected_calibration_error_10bin": 0.0010073622890917487, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "H54": { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.4228713929462059, + "auprc": 0.000902179385512692, + "brier": 0.0007286819508887798, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0021077715362897405, + "calibration_in_the_large": 0.0013957743842783485, + "expected_calibration_error_10bin": 0.0013957743842783485, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "H91": { + "valid": 2791, + "positives": 5, + "negatives": 2786, + "auroc": 0.7407753050969131, + "auprc": 0.008021930125326574, + "brier": 0.0017893782235624811, + "calibration": { + "observed_rate": 0.0017914725904693658, + "mean_prediction": 0.002148221372313942, + "calibration_in_the_large": 0.0003567487818445761, + "expected_calibration_error_10bin": 0.0003567487818445761, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + "I07": { + "valid": 2823, + "positives": 5, + "negatives": 2818, + "auroc": 0.8920511000709723, + "auprc": 0.010423905317559903, + "brier": 0.00177333247552087, + "calibration": { + "observed_rate": 0.001771165426850868, + "mean_prediction": 0.0009715672193839739, + "calibration_in_the_large": -0.000799598207466894, + "expected_calibration_error_10bin": 0.000799598207466894, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "I08": { + "valid": 2767, + "positives": 8, + "negatives": 2759, + "auroc": 0.8616346502355926, + "auprc": 0.01876560348219335, + "brier": 0.003100487393562853, + "calibration": { + "observed_rate": 0.0028912179255511385, + "mean_prediction": 0.006221516622913026, + "calibration_in_the_large": 0.003330298697361887, + "expected_calibration_error_10bin": 0.0033302986973618868, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + "I10": { + "valid": 1498, + "positives": 33, + "negatives": 1465, + "auroc": 0.6753335401799566, + "auprc": 0.058294681966327144, + "brier": 0.021447771582769545, + "calibration": { + "observed_rate": 0.022029372496662217, + "mean_prediction": 0.015671013848693204, + "calibration_in_the_large": -0.006358358647969013, + "expected_calibration_error_10bin": 0.008496324475313748, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + "I11": { + "valid": 2676, + "positives": 32, + "negatives": 2644, + "auroc": 0.8128072995461422, + "auprc": 0.041556459541285645, + "brier": 0.011775235345142422, + "calibration": { + "observed_rate": 0.01195814648729447, + "mean_prediction": 0.00952615682031606, + "calibration_in_the_large": -0.002431989666978409, + "expected_calibration_error_10bin": 0.004324260680115345, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + "I12": { + "valid": 2552, + "positives": 19, + "negatives": 2533, + "auroc": 0.8098572526856027, + "auprc": 0.04014991081501453, + "brier": 0.0073969991224258754, + "calibration": { + "observed_rate": 0.007445141065830721, + "mean_prediction": 0.005668381020791529, + "calibration_in_the_large": -0.0017767600450391916, + "expected_calibration_error_10bin": 0.003063817865665005, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + "I13": { + "valid": 2727, + "positives": 20, + "negatives": 2707, + "auroc": 0.8782046545991873, + "auprc": 0.07165306863159264, + "brier": 0.007187922293697547, + "calibration": { + "observed_rate": 0.007334066740007334, + "mean_prediction": 0.008618144137104105, + "calibration_in_the_large": 0.001284077397096771, + "expected_calibration_error_10bin": 0.0012840773970967715, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + "I16": { + "valid": 2390, + "positives": 8, + "negatives": 2382, + "auroc": 0.869857262804366, + "auprc": 0.022485753313367832, + "brier": 0.0033171917360568775, + "calibration": { + "observed_rate": 0.0033472803347280333, + "mean_prediction": 0.0019568879341015084, + "calibration_in_the_large": -0.0013903924006265249, + "expected_calibration_error_10bin": 0.0013903924006265249, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + "I21": { + "valid": 2671, + "positives": 14, + "negatives": 2657, + "auroc": 0.8442658207430507, + "auprc": 0.03184339493439445, + "brier": 0.005311459765051809, + "calibration": { + "observed_rate": 0.005241482590789966, + "mean_prediction": 0.010571934886839447, + "calibration_in_the_large": 0.005330452296049481, + "expected_calibration_error_10bin": 0.0053304522960494795, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "I24": { + "valid": 2809, + "positives": 6, + "negatives": 2803, + "auroc": 0.885955523843501, + "auprc": 0.029174564423153606, + "brier": 0.0021136645261847524, + "calibration": { + "observed_rate": 0.002135991456034176, + "mean_prediction": 0.001378275343631232, + "calibration_in_the_large": -0.000757716112402944, + "expected_calibration_error_10bin": 0.000757716112402944, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "I25": { + "valid": 2243, + "positives": 32, + "negatives": 2211, + "auroc": 0.8378561736770692, + "auprc": 0.06789878177769929, + "brier": 0.013692212992283837, + "calibration": { + "observed_rate": 0.014266607222469906, + "mean_prediction": 0.012447374563983808, + "calibration_in_the_large": -0.0018192326584860977, + "expected_calibration_error_10bin": 0.0018192326584860977, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + "I26": { + "valid": 2760, + "positives": 14, + "negatives": 2746, + "auroc": 0.77671418166684, + "auprc": 0.12683151733402812, + "brier": 0.004898535346105042, + "calibration": { + "observed_rate": 0.005072463768115942, + "mean_prediction": 0.00495450839575758, + "calibration_in_the_large": -0.00011795537235836148, + "expected_calibration_error_10bin": 0.00036529205483047027, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + "I27": { + "valid": 2716, + "positives": 26, + "negatives": 2690, + "auroc": 0.8290105804975694, + "auprc": 0.04083307628108601, + "brier": 0.009418676854431967, + "calibration": { + "observed_rate": 0.009572901325478646, + "mean_prediction": 0.0076078540312367335, + "calibration_in_the_large": -0.0019650472942419122, + "expected_calibration_error_10bin": 0.0035177386125670724, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I31": { + "valid": 2793, + "positives": 11, + "negatives": 2782, + "auroc": 0.8547153780798641, + "auprc": 0.10530890954364726, + "brier": 0.003875194114723819, + "calibration": { + "observed_rate": 0.003938417472252059, + "mean_prediction": 0.0029899289920177438, + "calibration_in_the_large": -0.0009484884802343154, + "expected_calibration_error_10bin": 0.0009484884802343154, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I34": { + "valid": 2753, + "positives": 15, + "negatives": 2738, + "auroc": 0.7619673727781836, + "auprc": 0.018289792354364835, + "brier": 0.0054526996381433586, + "calibration": { + "observed_rate": 0.005448601525608427, + "mean_prediction": 0.004219158975808317, + "calibration_in_the_large": -0.0012294425498001107, + "expected_calibration_error_10bin": 0.00171966579512119, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + "I35": { + "valid": 2723, + "positives": 5, + "negatives": 2718, + "auroc": 0.7295805739514348, + "auprc": 0.00876652671824647, + "brier": 0.0019101962448523082, + "calibration": { + "observed_rate": 0.001836210062431142, + "mean_prediction": 0.003784145153102397, + "calibration_in_the_large": 0.001947935090671255, + "expected_calibration_error_10bin": 0.001947935090671255, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "I42": { + "valid": 2740, + "positives": 11, + "negatives": 2729, + "auroc": 0.9228155501515707, + "auprc": 0.0658828428448376, + "brier": 0.003913281488172818, + "calibration": { + "observed_rate": 0.0040145985401459855, + "mean_prediction": 0.0034711979606576954, + "calibration_in_the_large": -0.0005434005794882901, + "expected_calibration_error_10bin": 0.0006346111364322107, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "I44": { + "valid": 2722, + "positives": 14, + "negatives": 2708, + "auroc": 0.8895336568896391, + "auprc": 0.06937274583833615, + "brier": 0.0050142889109707975, + "calibration": { + "observed_rate": 0.005143277002204262, + "mean_prediction": 0.007274182990543554, + "calibration_in_the_large": 0.002130905988339292, + "expected_calibration_error_10bin": 0.0032402596717300393, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + "I45": { + "valid": 2766, + "positives": 10, + "negatives": 2756, + "auroc": 0.7384615384615385, + "auprc": 0.06176307696895215, + "brier": 0.003589380949858408, + "calibration": { + "observed_rate": 0.0036153289949385392, + "mean_prediction": 0.0055115840492515195, + "calibration_in_the_large": 0.0018962550543129802, + "expected_calibration_error_10bin": 0.0018962550543129802, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + "I46": { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.4872791519434629, + "auprc": 0.0006887052341597796, + "brier": 0.00036338862032832996, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.001712846512257169, + "calibration_in_the_large": 0.0013596144387848978, + "expected_calibration_error_10bin": 0.0013596144387848978, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I47": { + "valid": 2716, + "positives": 11, + "negatives": 2705, + "auroc": 0.7013947235758696, + "auprc": 0.008806921911435606, + "brier": 0.004083306986047605, + "calibration": { + "observed_rate": 0.004050073637702504, + "mean_prediction": 0.006813640463241292, + "calibration_in_the_large": 0.002763566825538788, + "expected_calibration_error_10bin": 0.002763566825538788, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I48": { + "valid": 2385, + "positives": 21, + "negatives": 2364, + "auroc": 0.781101442268955, + "auprc": 0.028278314173502128, + "brier": 0.008707352062765685, + "calibration": { + "observed_rate": 0.00880503144654088, + "mean_prediction": 0.008863626251305186, + "calibration_in_the_large": 5.85948047643059e-05, + "expected_calibration_error_10bin": 0.00034509871978228765, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + "I49": { + "valid": 2734, + "positives": 14, + "negatives": 2720, + "auroc": 0.7498424369747899, + "auprc": 0.01262638851870401, + "brier": 0.005086323521987567, + "calibration": { + "observed_rate": 0.005120702267739576, + "mean_prediction": 0.0035064022684651724, + "calibration_in_the_large": -0.0016142999992744033, + "expected_calibration_error_10bin": 0.0016142999992744033, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I50": { + "valid": 2415, + "positives": 35, + "negatives": 2380, + "auroc": 0.8149819927971188, + "auprc": 0.0815215731498301, + "brier": 0.014098790310629853, + "calibration": { + "observed_rate": 0.014492753623188406, + "mean_prediction": 0.014984326210711368, + "calibration_in_the_large": 0.0004915725875229617, + "expected_calibration_error_10bin": 0.002232430099810817, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + "I51": { + "valid": 2807, + "positives": 6, + "negatives": 2801, + "auroc": 0.838034035463525, + "auprc": 0.008093764717757013, + "brier": 0.0021304912905243025, + "calibration": { + "observed_rate": 0.0021375133594584966, + "mean_prediction": 0.0017488280186319881, + "calibration_in_the_large": -0.00038868534082650845, + "expected_calibration_error_10bin": 0.00038868534082650845, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "I61": { + "valid": 2802, + "positives": 6, + "negatives": 2796, + "auroc": 0.8145565092989986, + "auprc": 0.00727812239436196, + "brier": 0.002137402261524719, + "calibration": { + "observed_rate": 0.0021413276231263384, + "mean_prediction": 0.0007188776819097462, + "calibration_in_the_large": -0.0014224499412165922, + "expected_calibration_error_10bin": 0.0014224499412165922, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "I63": { + "valid": 2735, + "positives": 11, + "negatives": 2724, + "auroc": 0.8039981310906421, + "auprc": 0.018352494626899536, + "brier": 0.004020755322070144, + "calibration": { + "observed_rate": 0.0040219378427787935, + "mean_prediction": 0.0038908434724279316, + "calibration_in_the_large": -0.00013109437035086196, + "expected_calibration_error_10bin": 0.00046382120546572636, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + "I65": { + "valid": 2774, + "positives": 5, + "negatives": 2769, + "auroc": 0.6711448176236908, + "auprc": 0.012412259871892357, + "brier": 0.0018028478255897957, + "calibration": { + "observed_rate": 0.001802451333813987, + "mean_prediction": 0.0023435966122345026, + "calibration_in_the_large": 0.0005411452784205156, + "expected_calibration_error_10bin": 0.0005411452784205156, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "I67": { + "valid": 2773, + "positives": 3, + "negatives": 2770, + "auroc": 0.6316486161251504, + "auprc": 0.0029445141652110784, + "brier": 0.0011075104305872064, + "calibration": { + "observed_rate": 0.0010818608005769925, + "mean_prediction": 0.0024438875443192993, + "calibration_in_the_large": 0.0013620267437423068, + "expected_calibration_error_10bin": 0.0013620267437423068, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "I69": { + "valid": 2752, + "positives": 14, + "negatives": 2738, + "auroc": 0.7563654387978712, + "auprc": 0.015318668977112824, + "brier": 0.00511573082539502, + "calibration": { + "observed_rate": 0.005087209302325582, + "mean_prediction": 0.005979603595839106, + "calibration_in_the_large": 0.0008923942935135246, + "expected_calibration_error_10bin": 0.0008923942935135249, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + "I70": { + "valid": 2771, + "positives": 7, + "negatives": 2764, + "auroc": 0.8032354765350423, + "auprc": 0.01685840161215032, + "brier": 0.002512729054746906, + "calibration": { + "observed_rate": 0.0025261638397690365, + "mean_prediction": 0.0020789158724886193, + "calibration_in_the_large": -0.00044724796728041723, + "expected_calibration_error_10bin": 0.00044724796728041723, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + "I71": { + "valid": 2769, + "positives": 4, + "negatives": 2765, + "auroc": 0.7255877034358047, + "auprc": 0.004824371404673907, + "brier": 0.001449049942434521, + "calibration": { + "observed_rate": 0.001444564824846515, + "mean_prediction": 0.0019690740758988193, + "calibration_in_the_large": 0.0005245092510523042, + "expected_calibration_error_10bin": 0.0005245092510523042, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + "I72": { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.7776039815143975, + "auprc": 0.010393936551355582, + "brier": 0.0017705269641352225, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0011912781078919838, + "calibration_in_the_large": -0.0005830299119802659, + "expected_calibration_error_10bin": 0.0005830299119802659, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "I73": { + "valid": 2734, + "positives": 6, + "negatives": 2728, + "auroc": 0.8218475073313783, + "auprc": 0.05572274485841517, + "brier": 0.0021482161418398134, + "calibration": { + "observed_rate": 0.0021945866861741038, + "mean_prediction": 0.0020932883593281276, + "calibration_in_the_large": -0.00010129832684597617, + "expected_calibration_error_10bin": 0.00010129832684597617, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I74": { + "valid": 2821, + "positives": 4, + "negatives": 2817, + "auroc": 0.5498757543485978, + "auprc": 0.0031318337729706776, + "brier": 0.0014170906745821605, + "calibration": { + "observed_rate": 0.0014179369018078695, + "mean_prediction": 0.0006258023723960944, + "calibration_in_the_large": -0.0007921345294117752, + "expected_calibration_error_10bin": 0.0007921345294117752, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "I77": { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.7163790003595829, + "auprc": 0.006295783515780854, + "brier": 0.001436697075250459, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.0017879070225856233, + "calibration_in_the_large": 0.0003516413134294293, + "expected_calibration_error_10bin": 0.0003516413134294293, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "I80": { + "valid": 2827, + "positives": 4, + "negatives": 2823, + "auroc": 0.887708111937655, + "auprc": 0.08952491614610081, + "brier": 0.0013874026660502215, + "calibration": { + "observed_rate": 0.0014149274849663955, + "mean_prediction": 0.0010720720040518507, + "calibration_in_the_large": -0.0003428554809145447, + "expected_calibration_error_10bin": 0.0003428554809145447, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "I81": { + "valid": 2826, + "positives": 6, + "negatives": 2820, + "auroc": 0.8469858156028369, + "auprc": 0.015494824018017106, + "brier": 0.0021964312927838948, + "calibration": { + "observed_rate": 0.0021231422505307855, + "mean_prediction": 0.0019153767893009945, + "calibration_in_the_large": -0.00020776546122979107, + "expected_calibration_error_10bin": 0.0007553682550340219, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I82": { + "valid": 2739, + "positives": 23, + "negatives": 2716, + "auroc": 0.7043766408401101, + "auprc": 0.029126747065806303, + "brier": 0.00838704308250095, + "calibration": { + "observed_rate": 0.008397225264695144, + "mean_prediction": 0.008655766312775846, + "calibration_in_the_large": 0.0002585410480807019, + "expected_calibration_error_10bin": 0.0014359052067578091, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "I85": { + "valid": 2793, + "positives": 7, + "negatives": 2786, + "auroc": 0.9913854989231874, + "auprc": 0.20534702053689394, + "brier": 0.002336766659098227, + "calibration": { + "observed_rate": 0.002506265664160401, + "mean_prediction": 0.001594685379156085, + "calibration_in_the_large": -0.0009115802850043159, + "expected_calibration_error_10bin": 0.002008811534723096, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I87": { + "valid": 2780, + "positives": 11, + "negatives": 2769, + "auroc": 0.7194589448110574, + "auprc": 0.010417572044431582, + "brier": 0.003958370004113057, + "calibration": { + "observed_rate": 0.003956834532374101, + "mean_prediction": 0.004070783106436079, + "calibration_in_the_large": 0.00011394857406197851, + "expected_calibration_error_10bin": 0.00011394857406197851, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "I89": { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8501240694789082, + "auprc": 0.012847455872070668, + "brier": 0.001763558635255779, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0005829852618461413, + "calibration_in_the_large": -0.0011862999469295131, + "expected_calibration_error_10bin": 0.0011862999469295131, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I95": { + "valid": 2485, + "positives": 66, + "negatives": 2419, + "auroc": 0.7293710148195472, + "auprc": 0.057788173429150144, + "brier": 0.02565291322039268, + "calibration": { + "observed_rate": 0.026559356136820925, + "mean_prediction": 0.027304377971110225, + "calibration_in_the_large": 0.0007450218342892993, + "expected_calibration_error_10bin": 0.004424799185094444, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + "I96": { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.87168376370711, + "auprc": 0.04355456353945582, + "brier": 0.001394651471760122, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0013026520236805404, + "calibration_in_the_large": -0.00011027627020854464, + "expected_calibration_error_10bin": 0.00011027627020854464, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I97": { + "valid": 2740, + "positives": 7, + "negatives": 2733, + "auroc": 0.7938947258376458, + "auprc": 0.010915221017265943, + "brier": 0.0025448173567556402, + "calibration": { + "observed_rate": 0.0025547445255474453, + "mean_prediction": 0.0027153562822319266, + "calibration_in_the_large": 0.0001606117566844813, + "expected_calibration_error_10bin": 0.0001606117566844813, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "J02": { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.6833156216790648, + "auprc": 0.0016653194419495839, + "brier": 0.0007190681032418003, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0013618082619520457, + "calibration_in_the_large": 0.0006538436601821342, + "expected_calibration_error_10bin": 0.0006538436601821342, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J06": { + "valid": 2816, + "positives": 7, + "negatives": 2809, + "auroc": 0.6882978182372985, + "auprc": 0.007837038106626944, + "brier": 0.002528619275656096, + "calibration": { + "observed_rate": 0.0024857954545454545, + "mean_prediction": 0.002712096852181131, + "calibration_in_the_large": 0.0002263013976356765, + "expected_calibration_error_10bin": 0.0002263013976356765, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "J12": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 4.44369773330671e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.002139609428978934, + "calibration_in_the_large": 0.002139609428978934, + "expected_calibration_error_10bin": 0.002139609428978934, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J15": { + "valid": 2795, + "positives": 10, + "negatives": 2785, + "auroc": 0.8115978456014362, + "auprc": 0.019930142565963215, + "brier": 0.0036139412472509544, + "calibration": { + "observed_rate": 0.0035778175313059034, + "mean_prediction": 0.004946512929062608, + "calibration_in_the_large": 0.0013686953977567048, + "expected_calibration_error_10bin": 0.001368695397756705, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + "J18": { + "valid": 2671, + "positives": 37, + "negatives": 2634, + "auroc": 0.7782121529274149, + "auprc": 0.048309027201076216, + "brier": 0.013661787918653254, + "calibration": { + "observed_rate": 0.013852489704230626, + "mean_prediction": 0.0152158254793492, + "calibration_in_the_large": 0.0013633357751185737, + "expected_calibration_error_10bin": 0.0021789005921924076, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "J30": { + "valid": 2815, + "positives": 6, + "negatives": 2809, + "auroc": 0.7141331434674262, + "auprc": 0.033289385146513514, + "brier": 0.0021209270966186656, + "calibration": { + "observed_rate": 0.0021314387211367673, + "mean_prediction": 0.0024533151436889077, + "calibration_in_the_large": 0.00032187642255214043, + "expected_calibration_error_10bin": 0.0003218764225521403, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "J32": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.5169791298195967, + "auprc": 0.0026503414242267744, + "brier": 0.0007180291616202527, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0009887152219993384, + "calibration_in_the_large": 0.0002817516306242942, + "expected_calibration_error_10bin": 0.0002817516306242942, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J38": { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.6824300389656394, + "auprc": 0.0022671205205566586, + "brier": 0.000713456547592586, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.00126316475633862, + "calibration_in_the_large": 0.0005552001545687085, + "expected_calibration_error_10bin": 0.0005552001545687085, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J43": { + "valid": 2804, + "positives": 5, + "negatives": 2799, + "auroc": 0.5754912468738835, + "auprc": 0.0026635997314512065, + "brier": 0.0017922525497815016, + "calibration": { + "observed_rate": 0.001783166904422254, + "mean_prediction": 0.00146871779998945, + "calibration_in_the_large": -0.00031444910443280405, + "expected_calibration_error_10bin": 0.00031444910443280405, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "J44": { + "valid": 2570, + "positives": 20, + "negatives": 2550, + "auroc": 0.7957647058823529, + "auprc": 0.030695881291536203, + "brier": 0.00766411052825037, + "calibration": { + "observed_rate": 0.007782101167315175, + "mean_prediction": 0.0062183039432417795, + "calibration_in_the_large": -0.0015637972240733957, + "expected_calibration_error_10bin": 0.0016460806534400007, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + "J45": { + "valid": 2518, + "positives": 20, + "negatives": 2498, + "auroc": 0.6811649319455565, + "auprc": 0.01743363333400719, + "brier": 0.007878633115497684, + "calibration": { + "observed_rate": 0.007942811755361398, + "mean_prediction": 0.006147123139951344, + "calibration_in_the_large": -0.0017956886154100538, + "expected_calibration_error_10bin": 0.0017956886154100538, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + "J47": { + "valid": 2825, + "positives": 4, + "negatives": 2821, + "auroc": 0.8996809641970932, + "auprc": 0.009480205412830324, + "brier": 0.0014138312922257665, + "calibration": { + "observed_rate": 0.001415929203539823, + "mean_prediction": 0.0006708736083830638, + "calibration_in_the_large": -0.0007450555951567593, + "expected_calibration_error_10bin": 0.0007450555951567593, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J69": { + "valid": 2777, + "positives": 22, + "negatives": 2755, + "auroc": 0.7791618544794588, + "auprc": 0.03252692293936496, + "brier": 0.007830053934463833, + "calibration": { + "observed_rate": 0.00792221822110191, + "mean_prediction": 0.008636481879348356, + "calibration_in_the_large": 0.0007142636582464466, + "expected_calibration_error_10bin": 0.0007757481781417532, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "J81": { + "valid": 2781, + "positives": 16, + "negatives": 2765, + "auroc": 0.764760397830018, + "auprc": 0.02310582575781284, + "brier": 0.005700134508020424, + "calibration": { + "observed_rate": 0.005753326141675656, + "mean_prediction": 0.0026868220878387737, + "calibration_in_the_large": -0.0030665040538368823, + "expected_calibration_error_10bin": 0.0030665040538368823, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "J84": { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.9148957803762074, + "auprc": 0.03320140791536672, + "brier": 0.002461801142848668, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.0012511568052784468, + "calibration_in_the_large": -0.0012337562227655717, + "expected_calibration_error_10bin": 0.0012337562227655717, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "J90": { + "valid": 2754, + "positives": 25, + "negatives": 2729, + "auroc": 0.6662074019787468, + "auprc": 0.015829919625294078, + "brier": 0.00912825379643671, + "calibration": { + "observed_rate": 0.00907770515613653, + "mean_prediction": 0.00825046920139583, + "calibration_in_the_large": -0.0008272359547406988, + "expected_calibration_error_10bin": 0.0019976289936794664, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + "J91": { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.8239899892742224, + "auprc": 0.07436305731452462, + "brier": 0.0034775406320100644, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.002915846984686223, + "calibration_in_the_large": -0.000646675281077938, + "expected_calibration_error_10bin": 0.000646675281077938, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "J94": { + "valid": 2829, + "positives": 9, + "negatives": 2820, + "auroc": 0.6955870764381402, + "auprc": 0.12015984366499405, + "brier": 0.0031432087516096237, + "calibration": { + "observed_rate": 0.003181336161187699, + "mean_prediction": 0.0010199369456942655, + "calibration_in_the_large": -0.0021613992154934335, + "expected_calibration_error_10bin": 0.0021613992154934335, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J95": { + "valid": 2770, + "positives": 12, + "negatives": 2758, + "auroc": 0.8113971476915639, + "auprc": 0.029982176305126864, + "brier": 0.004274534688101109, + "calibration": { + "observed_rate": 0.004332129963898917, + "mean_prediction": 0.003817796184098649, + "calibration_in_the_large": -0.0005143337798002678, + "expected_calibration_error_10bin": 0.0005143337798002678, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + "J96": { + "valid": 2605, + "positives": 54, + "negatives": 2551, + "auroc": 0.8233082160953584, + "auprc": 0.0806856281296844, + "brier": 0.019962288930254878, + "calibration": { + "observed_rate": 0.02072936660268714, + "mean_prediction": 0.02046476263509779, + "calibration_in_the_large": -0.0002646039675893476, + "expected_calibration_error_10bin": 0.004735424540967782, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + "J98": { + "valid": 2692, + "positives": 27, + "negatives": 2665, + "auroc": 0.7387255923841289, + "auprc": 0.03672098025601927, + "brier": 0.009828886976024943, + "calibration": { + "observed_rate": 0.010029717682020803, + "mean_prediction": 0.0083130485072075, + "calibration_in_the_large": -0.0017166691748133033, + "expected_calibration_error_10bin": 0.0017962099735500195, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + "K04": { + "valid": 2836, + "positives": 1, + "negatives": 2835, + "auroc": 0.9361552028218695, + "auprc": 0.005494505494505495, + "brier": 0.00035290363090598425, + "calibration": { + "observed_rate": 0.0003526093088857546, + "mean_prediction": 0.0005724466713893521, + "calibration_in_the_large": 0.00021983736250359752, + "expected_calibration_error_10bin": 0.00021983736250359752, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "K12": { + "valid": 2824, + "positives": 9, + "negatives": 2815, + "auroc": 0.8661930136175252, + "auprc": 0.07490499829972758, + "brier": 0.0034752109824254186, + "calibration": { + "observed_rate": 0.003186968838526912, + "mean_prediction": 0.0038769972464498966, + "calibration_in_the_large": 0.0006900284079229845, + "expected_calibration_error_10bin": 0.002570136190222514, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K20": { + "valid": 2813, + "positives": 5, + "negatives": 2808, + "auroc": 0.6873931623931624, + "auprc": 0.05458391308954291, + "brier": 0.0018236294430134638, + "calibration": { + "observed_rate": 0.0017774617845716318, + "mean_prediction": 0.0050301203488416464, + "calibration_in_the_large": 0.0032526585642700147, + "expected_calibration_error_10bin": 0.0032526585642700147, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K21": { + "valid": 2043, + "positives": 59, + "negatives": 1984, + "auroc": 0.7508201202843083, + "auprc": 0.10889413141641255, + "brier": 0.027048062385215094, + "calibration": { + "observed_rate": 0.02887909936368086, + "mean_prediction": 0.032516826895109825, + "calibration_in_the_large": 0.0036377275314289637, + "expected_calibration_error_10bin": 0.004170095205226774, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + "K22": { + "valid": 2764, + "positives": 14, + "negatives": 2750, + "auroc": 0.7938181818181819, + "auprc": 0.025616419891278434, + "brier": 0.004999553702427287, + "calibration": { + "observed_rate": 0.005065123010130246, + "mean_prediction": 0.003997822480892251, + "calibration_in_the_large": -0.0010673005292379948, + "expected_calibration_error_10bin": 0.0010673005292379948, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + "K25": { + "valid": 2817, + "positives": 6, + "negatives": 2811, + "auroc": 0.791414680422151, + "auprc": 0.010232390975018367, + "brier": 0.002159138165928971, + "calibration": { + "observed_rate": 0.002129925452609159, + "mean_prediction": 0.0026995424761547043, + "calibration_in_the_large": 0.0005696170235455454, + "expected_calibration_error_10bin": 0.0005696170235455456, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "K26": { + "valid": 2814, + "positives": 5, + "negatives": 2809, + "auroc": 0.9285154859380562, + "auprc": 0.054207576154977274, + "brier": 0.001755381721647424, + "calibration": { + "observed_rate": 0.0017768301350390902, + "mean_prediction": 0.0013957871248219736, + "calibration_in_the_large": -0.0003810430102171166, + "expected_calibration_error_10bin": 0.0003810430102171166, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "K29": { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.8365730741540677, + "auprc": 0.02573619236464928, + "brier": 0.0025334074862622584, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.006512233343142999, + "calibration_in_the_large": 0.00399876835211966, + "expected_calibration_error_10bin": 0.00399876835211966, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K30": { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.928395061728395, + "auprc": 0.0071272745302196445, + "brier": 0.0007073065774854538, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0011225305002374052, + "calibration_in_the_large": 0.00041756046146405304, + "expected_calibration_error_10bin": 0.00041756046146405304, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "K31": { + "valid": 2756, + "positives": 11, + "negatives": 2745, + "auroc": 0.9194237456532538, + "auprc": 0.049058325610002236, + "brier": 0.003932178795951949, + "calibration": { + "observed_rate": 0.0039912917271407835, + "mean_prediction": 0.004740144712354546, + "calibration_in_the_large": 0.0007488529852137625, + "expected_calibration_error_10bin": 0.0007488529852137623, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "K40": { + "valid": 2827, + "positives": 2, + "negatives": 2825, + "auroc": 0.8723893805309735, + "auprc": 0.004042190616948934, + "brier": 0.0007073743127097289, + "calibration": { + "observed_rate": 0.0007074637424831977, + "mean_prediction": 0.0011433124063343454, + "calibration_in_the_large": 0.00043584866385114763, + "expected_calibration_error_10bin": 0.00043584866385114763, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "K42": { + "valid": 2820, + "positives": 3, + "negatives": 2817, + "auroc": 0.6702165424210152, + "auprc": 0.005613337888199032, + "brier": 0.0010716030079502023, + "calibration": { + "observed_rate": 0.0010638297872340426, + "mean_prediction": 0.0009205560672053768, + "calibration_in_the_large": -0.00014327372002866578, + "expected_calibration_error_10bin": 0.00014327372002866578, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "K43": { + "valid": 2813, + "positives": 4, + "negatives": 2809, + "auroc": 0.7657529369882521, + "auprc": 0.008458546248477323, + "brier": 0.0014248838265982805, + "calibration": { + "observed_rate": 0.0014219694276573053, + "mean_prediction": 0.001501657619042562, + "calibration_in_the_large": 7.968819138525667e-05, + "expected_calibration_error_10bin": 7.968819138525667e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K44": { + "valid": 2785, + "positives": 5, + "negatives": 2780, + "auroc": 0.6313669064748202, + "auprc": 0.005923533926876022, + "brier": 0.001795355840961527, + "calibration": { + "observed_rate": 0.0017953321364452424, + "mean_prediction": 0.0022352632828471896, + "calibration_in_the_large": 0.00043993114640194717, + "expected_calibration_error_10bin": 0.00043993114640194717, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K52": { + "valid": 2749, + "positives": 28, + "negatives": 2721, + "auroc": 0.8010185331023258, + "auprc": 0.12413754274003108, + "brier": 0.00994632080176468, + "calibration": { + "observed_rate": 0.01018552200800291, + "mean_prediction": 0.009731361370281267, + "calibration_in_the_large": -0.0004541606377216432, + "expected_calibration_error_10bin": 0.003574668038986454, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + "K55": { + "valid": 2815, + "positives": 8, + "negatives": 2807, + "auroc": 0.8071784823655148, + "auprc": 0.010188349697808918, + "brier": 0.0028515320370524067, + "calibration": { + "observed_rate": 0.002841918294849023, + "mean_prediction": 0.002328197937565696, + "calibration_in_the_large": -0.0005137203572833271, + "expected_calibration_error_10bin": 0.0005987688115527499, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "K56": { + "valid": 2745, + "positives": 23, + "negatives": 2722, + "auroc": 0.7405360508577452, + "auprc": 0.03255326889022824, + "brier": 0.008246425345938125, + "calibration": { + "observed_rate": 0.008378870673952642, + "mean_prediction": 0.009642642713681997, + "calibration_in_the_large": 0.001263772039729355, + "expected_calibration_error_10bin": 0.0012637720397293553, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + "K57": { + "valid": 2741, + "positives": 18, + "negatives": 2723, + "auroc": 0.6652997102868569, + "auprc": 0.016359479183249835, + "brier": 0.00652994289609877, + "calibration": { + "observed_rate": 0.006566946369937978, + "mean_prediction": 0.003813381185479704, + "calibration_in_the_large": -0.0027535651844582745, + "expected_calibration_error_10bin": 0.002831323950339983, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "K58": { + "valid": 2792, + "positives": 7, + "negatives": 2785, + "auroc": 0.7349576814567838, + "auprc": 0.01463027778813542, + "brier": 0.0024969976631384625, + "calibration": { + "observed_rate": 0.002507163323782235, + "mean_prediction": 0.001647465321366847, + "calibration_in_the_large": -0.0008596980024153881, + "expected_calibration_error_10bin": 0.0008596980024153881, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "K59": { + "valid": 2560, + "positives": 72, + "negatives": 2488, + "auroc": 0.7586135673454806, + "auprc": 0.12904949063238622, + "brier": 0.026092268488037983, + "calibration": { + "observed_rate": 0.028125, + "mean_prediction": 0.023371545357395006, + "calibration_in_the_large": -0.004753454642604994, + "expected_calibration_error_10bin": 0.005261862029556143, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "K62": { + "valid": 2813, + "positives": 11, + "negatives": 2802, + "auroc": 0.8793069885146972, + "auprc": 0.02864363649054781, + "brier": 0.003866830620072813, + "calibration": { + "observed_rate": 0.0039104159260575895, + "mean_prediction": 0.002508925522762729, + "calibration_in_the_large": -0.0014014904032948606, + "expected_calibration_error_10bin": 0.0014014904032948606, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K63": { + "valid": 2810, + "positives": 14, + "negatives": 2796, + "auroc": 0.72652258328224, + "auprc": 0.01209448595140146, + "brier": 0.00496590904205348, + "calibration": { + "observed_rate": 0.00498220640569395, + "mean_prediction": 0.0032415006383284066, + "calibration_in_the_large": -0.0017407057673655434, + "expected_calibration_error_10bin": 0.0017407057673655434, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "K64": { + "valid": 2801, + "positives": 16, + "negatives": 2785, + "auroc": 0.775516157989228, + "auprc": 0.02020224259355619, + "brier": 0.005755960109086282, + "calibration": { + "observed_rate": 0.005712245626561942, + "mean_prediction": 0.004929131458340998, + "calibration_in_the_large": -0.0007831141682209447, + "expected_calibration_error_10bin": 0.0019981074087128993, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "K65": { + "valid": 2813, + "positives": 10, + "negatives": 2803, + "auroc": 0.8729575454869782, + "auprc": 0.034528084022304284, + "brier": 0.003652405657499423, + "calibration": { + "observed_rate": 0.0035549235691432635, + "mean_prediction": 0.006891045962264527, + "calibration_in_the_large": 0.0033361223931212634, + "expected_calibration_error_10bin": 0.003336122393121264, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K66": { + "valid": 2796, + "positives": 6, + "negatives": 2790, + "auroc": 0.7300477897252091, + "auprc": 0.021609775481233006, + "brier": 0.0021506767811608415, + "calibration": { + "observed_rate": 0.002145922746781116, + "mean_prediction": 0.003401065209671623, + "calibration_in_the_large": 0.001255142462890507, + "expected_calibration_error_10bin": 0.001255142462890507, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "K70": { + "valid": 2774, + "positives": 1, + "negatives": 2773, + "auroc": 0.9491525423728814, + "auprc": 0.007042253521126761, + "brier": 0.00037354438392599794, + "calibration": { + "observed_rate": 0.0003604902667627974, + "mean_prediction": 0.0008050195439592711, + "calibration_in_the_large": 0.0004445292771964737, + "expected_calibration_error_10bin": 0.0004445292771964737, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "K72": { + "valid": 2787, + "positives": 15, + "negatives": 2772, + "auroc": 0.9525974025974026, + "auprc": 0.2532655548392671, + "brier": 0.004818890259308495, + "calibration": { + "observed_rate": 0.005382131324004306, + "mean_prediction": 0.003079071702661238, + "calibration_in_the_large": -0.0023030596213430682, + "expected_calibration_error_10bin": 0.0032860062236412147, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "K74": { + "valid": 2763, + "positives": 6, + "negatives": 2757, + "auroc": 0.9652399951638254, + "auprc": 0.05402270570011943, + "brier": 0.002151326604904314, + "calibration": { + "observed_rate": 0.002171552660152009, + "mean_prediction": 0.002689983918087462, + "calibration_in_the_large": 0.0005184312579354531, + "expected_calibration_error_10bin": 0.0005184312579354536, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "K75": { + "valid": 2798, + "positives": 10, + "negatives": 2788, + "auroc": 0.8148852223816356, + "auprc": 0.02258219406481831, + "brier": 0.003557597279282272, + "calibration": { + "observed_rate": 0.0035739814152966403, + "mean_prediction": 0.002116962510613761, + "calibration_in_the_large": -0.0014570189046828794, + "expected_calibration_error_10bin": 0.0016232116779677508, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "K76": { + "valid": 2681, + "positives": 21, + "negatives": 2660, + "auroc": 0.8624955245255997, + "auprc": 0.17786838275825603, + "brier": 0.007106967279767045, + "calibration": { + "observed_rate": 0.007832898172323759, + "mean_prediction": 0.004508461789802066, + "calibration_in_the_large": -0.003324436382521693, + "expected_calibration_error_10bin": 0.0037999463647179145, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + "K80": { + "valid": 2731, + "positives": 10, + "negatives": 2721, + "auroc": 0.7132304299889747, + "auprc": 0.010618796479780864, + "brier": 0.003648256248366877, + "calibration": { + "observed_rate": 0.003661662394727206, + "mean_prediction": 0.0022825193319240184, + "calibration_in_the_large": -0.0013791430628031878, + "expected_calibration_error_10bin": 0.0013791430628031878, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + "K81": { + "valid": 2825, + "positives": 5, + "negatives": 2820, + "auroc": 0.847304964539007, + "auprc": 0.02658562979739761, + "brier": 0.0017560914607213237, + "calibration": { + "observed_rate": 0.0017699115044247787, + "mean_prediction": 0.0011849574383723744, + "calibration_in_the_large": -0.0005849540660524044, + "expected_calibration_error_10bin": 0.0005849540660524044, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "K82": { + "valid": 2824, + "positives": 4, + "negatives": 2820, + "auroc": 0.5867021276595744, + "auprc": 0.0037810806580055078, + "brier": 0.001417325944559713, + "calibration": { + "observed_rate": 0.00141643059490085, + "mean_prediction": 0.0009210230304711782, + "calibration_in_the_large": -0.0004954075644296717, + "expected_calibration_error_10bin": 0.0004954075644296717, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K83": { + "valid": 2757, + "positives": 9, + "negatives": 2748, + "auroc": 0.8908296943231441, + "auprc": 0.13009275852402843, + "brier": 0.0032317865104526567, + "calibration": { + "observed_rate": 0.003264417845484222, + "mean_prediction": 0.0035603837269944302, + "calibration_in_the_large": 0.0002959658815102082, + "expected_calibration_error_10bin": 0.0010047688940326585, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + "K85": { + "valid": 2779, + "positives": 4, + "negatives": 2775, + "auroc": 0.809099099099099, + "auprc": 0.027511409614568567, + "brier": 0.0014266807724018695, + "calibration": { + "observed_rate": 0.0014393666786613889, + "mean_prediction": 0.0016606872430757914, + "calibration_in_the_large": 0.00022132056441440248, + "expected_calibration_error_10bin": 0.00022132056441440248, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + "K86": { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.7325176922154252, + "auprc": 0.018184598314592165, + "brier": 0.00214660819592492, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.002614887393954067, + "calibration_in_the_large": 0.0004604888302197764, + "expected_calibration_error_10bin": 0.0004604888302197764, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K90": { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.6222614840989399, + "auprc": 0.0009345794392523365, + "brier": 0.00035497412467378554, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0006303632892144486, + "calibration_in_the_large": 0.00027713121574217734, + "expected_calibration_error_10bin": 0.00027713121574217734, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "K91": { + "valid": 2768, + "positives": 17, + "negatives": 2751, + "auroc": 0.8860948959736566, + "auprc": 0.05889079011792146, + "brier": 0.005949306905040381, + "calibration": { + "observed_rate": 0.006141618497109827, + "mean_prediction": 0.005994678736697412, + "calibration_in_the_large": -0.0001469397604124149, + "expected_calibration_error_10bin": 0.0008300005914851165, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "K92": { + "valid": 2751, + "positives": 26, + "negatives": 2725, + "auroc": 0.8592237120677487, + "auprc": 0.09014472256469198, + "brier": 0.009022500898435044, + "calibration": { + "observed_rate": 0.009451108687749909, + "mean_prediction": 0.008753936154810528, + "calibration_in_the_large": -0.0006971725329393812, + "expected_calibration_error_10bin": 0.0006971725329393832, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "K94": { + "valid": 2823, + "positives": 13, + "negatives": 2810, + "auroc": 0.9275116342732002, + "auprc": 0.08124361307299952, + "brier": 0.004425078530151302, + "calibration": { + "observed_rate": 0.004605030109812256, + "mean_prediction": 0.00444005718529553, + "calibration_in_the_large": -0.0001649729245167264, + "expected_calibration_error_10bin": 0.0006120847628612027, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "L02": { + "valid": 2807, + "positives": 15, + "negatives": 2792, + "auroc": 0.7770296084049666, + "auprc": 0.023213117312396715, + "brier": 0.0052813645525287296, + "calibration": { + "observed_rate": 0.005343783398646241, + "mean_prediction": 0.005245694366459063, + "calibration_in_the_large": -9.808903218717826e-05, + "expected_calibration_error_10bin": 9.808903218717826e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "L03": { + "valid": 2701, + "positives": 31, + "negatives": 2670, + "auroc": 0.7372598767669446, + "auprc": 0.045623522808591895, + "brier": 0.011222585130567635, + "calibration": { + "observed_rate": 0.011477230655312847, + "mean_prediction": 0.007465877219177238, + "calibration_in_the_large": -0.004011353436135609, + "expected_calibration_error_10bin": 0.00401135343613561, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + "L08": { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.6681061946902654, + "auprc": 0.007008367395822767, + "brier": 0.001765388063413262, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.0013292215338274844, + "calibration_in_the_large": -0.0004375629184693354, + "expected_calibration_error_10bin": 0.0004375629184693354, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + "L27": { + "valid": 2818, + "positives": 7, + "negatives": 2811, + "auroc": 0.7451339126899426, + "auprc": 0.00986848240702154, + "brier": 0.0027496979686662698, + "calibration": { + "observed_rate": 0.00248403122782115, + "mean_prediction": 0.004601359778046515, + "calibration_in_the_large": 0.0021173285502253656, + "expected_calibration_error_10bin": 0.0021173285502253656, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "L29": { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.5695332859511963, + "auprc": 0.002956383966510873, + "brier": 0.0011145432401958183, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.0033445549085036625, + "calibration_in_the_large": 0.002279592182199083, + "expected_calibration_error_10bin": 0.002279592182199083, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "L30": { + "valid": 2816, + "positives": 7, + "negatives": 2809, + "auroc": 0.6999949143060571, + "auprc": 0.021094212071680735, + "brier": 0.0024737503119048056, + "calibration": { + "observed_rate": 0.0024857954545454545, + "mean_prediction": 0.001881559966710194, + "calibration_in_the_large": -0.0006042354878352605, + "expected_calibration_error_10bin": 0.0006042354878352605, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "L50": { + "valid": 2835, + "positives": 3, + "negatives": 2832, + "auroc": 0.7556497175141242, + "auprc": 0.010634693368617524, + "brier": 0.001056313322064426, + "calibration": { + "observed_rate": 0.0010582010582010583, + "mean_prediction": 0.000964603616980872, + "calibration_in_the_large": -9.359744122018631e-05, + "expected_calibration_error_10bin": 9.359744122018631e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + "L53": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 6.005969695635811e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0012168651415965669, + "calibration_in_the_large": 0.0012168651415965669, + "expected_calibration_error_10bin": 0.0012168651415965669, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "L76": { + "valid": 2793, + "positives": 11, + "negatives": 2782, + "auroc": 0.6190771844977453, + "auprc": 0.005691400528457884, + "brier": 0.003962684793098518, + "calibration": { + "observed_rate": 0.003938417472252059, + "mean_prediction": 0.0047078120058582145, + "calibration_in_the_large": 0.0007693945336061554, + "expected_calibration_error_10bin": 0.0007693945336061554, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "L89": { + "valid": 2798, + "positives": 17, + "negatives": 2781, + "auroc": 0.8548977303974449, + "auprc": 0.028389267134713684, + "brier": 0.006024080713190215, + "calibration": { + "observed_rate": 0.006075768406004289, + "mean_prediction": 0.004630265135551277, + "calibration_in_the_large": -0.0014455032704530114, + "expected_calibration_error_10bin": 0.001856425680005531, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "L97": { + "valid": 2789, + "positives": 8, + "negatives": 2781, + "auroc": 0.8845738942826321, + "auprc": 0.06195323399652756, + "brier": 0.002854651691712061, + "calibration": { + "observed_rate": 0.0028684116170670493, + "mean_prediction": 0.004278860772039418, + "calibration_in_the_large": 0.001410449154972369, + "expected_calibration_error_10bin": 0.0014577403542246402, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "L98": { + "valid": 2824, + "positives": 5, + "negatives": 2819, + "auroc": 0.6522880454061724, + "auprc": 0.005515344072185053, + "brier": 0.0017834593784061925, + "calibration": { + "observed_rate": 0.0017705382436260624, + "mean_prediction": 0.0029950949840717414, + "calibration_in_the_large": 0.001224556740445679, + "expected_calibration_error_10bin": 0.001224556740445679, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "M10": { + "valid": 2713, + "positives": 10, + "negatives": 2703, + "auroc": 0.8178320384757677, + "auprc": 0.03543405777292928, + "brier": 0.003638952993403377, + "calibration": { + "observed_rate": 0.003685956505713233, + "mean_prediction": 0.004440144326225805, + "calibration_in_the_large": 0.0007541878205125723, + "expected_calibration_error_10bin": 0.0007541878205125725, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + "M16": { + "valid": 2790, + "positives": 2, + "negatives": 2788, + "auroc": 0.898493543758967, + "auprc": 0.011926782273603083, + "brier": 0.0007155106616908202, + "calibration": { + "observed_rate": 0.0007168458781362007, + "mean_prediction": 0.0011336355643635544, + "calibration_in_the_large": 0.0004167896862273537, + "expected_calibration_error_10bin": 0.0004167896862273537, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "M17": { + "valid": 2733, + "positives": 8, + "negatives": 2725, + "auroc": 0.7242201834862385, + "auprc": 0.0065757110064452355, + "brier": 0.002938837801201857, + "calibration": { + "observed_rate": 0.0029271862422246614, + "mean_prediction": 0.0021224920141074567, + "calibration_in_the_large": -0.0008046942281172047, + "expected_calibration_error_10bin": 0.0008046942281172047, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "M19": { + "valid": 2674, + "positives": 27, + "negatives": 2647, + "auroc": 0.7127985560172942, + "auprc": 0.0272938499400914, + "brier": 0.009954375356617808, + "calibration": { + "observed_rate": 0.010097232610321616, + "mean_prediction": 0.009365133164218827, + "calibration_in_the_large": -0.0007320994461027883, + "expected_calibration_error_10bin": 0.0010728431901729587, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + "M21": { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.9783687943262411, + "auprc": 0.016129032258064516, + "brier": 0.00035545399952369654, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0012539239609126852, + "calibration_in_the_large": 0.0008994397354607179, + "expected_calibration_error_10bin": 0.0008994397354607179, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "M25": { + "valid": 2717, + "positives": 26, + "negatives": 2691, + "auroc": 0.6281193722665295, + "auprc": 0.016172050114161684, + "brier": 0.00952637409403698, + "calibration": { + "observed_rate": 0.009569377990430622, + "mean_prediction": 0.009463902603325674, + "calibration_in_the_large": -0.00010547538710494776, + "expected_calibration_error_10bin": 0.0005060018505858256, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + "M35": { + "valid": 2806, + "positives": 1, + "negatives": 2805, + "auroc": 0.881283422459893, + "auprc": 0.0029940119760479044, + "brier": 0.00035989249398849193, + "calibration": { + "observed_rate": 0.0003563791874554526, + "mean_prediction": 0.0007875470197841625, + "calibration_in_the_large": 0.00043116783232870985, + "expected_calibration_error_10bin": 0.00043116783232870985, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "M46": { + "valid": 2814, + "positives": 4, + "negatives": 2810, + "auroc": 0.6035587188612099, + "auprc": 0.0022976233469601064, + "brier": 0.0014254694470165355, + "calibration": { + "observed_rate": 0.0014214641080312722, + "mean_prediction": 0.0017410364327488921, + "calibration_in_the_large": 0.00031957232471761994, + "expected_calibration_error_10bin": 0.00031957232471761994, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "M47": { + "valid": 2743, + "positives": 5, + "negatives": 2738, + "auroc": 0.7715850986121257, + "auprc": 0.009203908121315925, + "brier": 0.001816431285832069, + "calibration": { + "observed_rate": 0.0018228217280349982, + "mean_prediction": 0.0019022539651499118, + "calibration_in_the_large": 7.943223711491358e-05, + "expected_calibration_error_10bin": 7.943223711491358e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "M48": { + "valid": 2690, + "positives": 8, + "negatives": 2682, + "auroc": 0.7208240119313944, + "auprc": 0.010385574778186087, + "brier": 0.0029832868607764214, + "calibration": { + "observed_rate": 0.002973977695167286, + "mean_prediction": 0.0045956005997519565, + "calibration_in_the_large": 0.0016216229045846703, + "expected_calibration_error_10bin": 0.0016216229045846703, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + "M51": { + "valid": 2785, + "positives": 2, + "negatives": 2783, + "auroc": 0.94699964067553, + "auprc": 0.011984153185869924, + "brier": 0.0007179639926574884, + "calibration": { + "observed_rate": 0.000718132854578097, + "mean_prediction": 0.002219196065713374, + "calibration_in_the_large": 0.0015010632111352772, + "expected_calibration_error_10bin": 0.0015010632111352772, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "M54": { + "valid": 2567, + "positives": 32, + "negatives": 2535, + "auroc": 0.7013683431952663, + "auprc": 0.03863790383180582, + "brier": 0.01223444851951437, + "calibration": { + "observed_rate": 0.012465913517724971, + "mean_prediction": 0.012598729016877716, + "calibration_in_the_large": 0.00013281549915274485, + "expected_calibration_error_10bin": 0.00019243693748455658, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + "M62": { + "valid": 2781, + "positives": 7, + "negatives": 2774, + "auroc": 0.830930064888248, + "auprc": 0.01686423275131691, + "brier": 0.0024996869264346123, + "calibration": { + "observed_rate": 0.0025170801869830997, + "mean_prediction": 0.002741004345002427, + "calibration_in_the_large": 0.00022392415801932714, + "expected_calibration_error_10bin": 0.00022392415801932714, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "M79": { + "valid": 2697, + "positives": 24, + "negatives": 2673, + "auroc": 0.7947063224841002, + "auprc": 0.034746695427896296, + "brier": 0.00879318601471213, + "calibration": { + "observed_rate": 0.008898776418242492, + "mean_prediction": 0.011720875178987431, + "calibration_in_the_large": 0.0028220987607449396, + "expected_calibration_error_10bin": 0.002822098760744941, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + "M81": { + "valid": 2705, + "positives": 9, + "negatives": 2696, + "auroc": 0.8035361028684471, + "auprc": 0.0474874679574553, + "brier": 0.0032663891159710264, + "calibration": { + "observed_rate": 0.0033271719038817007, + "mean_prediction": 0.003868986201198246, + "calibration_in_the_large": 0.0005418142973165454, + "expected_calibration_error_10bin": 0.0005418142973165452, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + "M84": { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.7411304656949875, + "auprc": 0.024325015908742306, + "brier": 0.0017670715936657542, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0021982484058469458, + "calibration_in_the_large": 0.00042394038597469604, + "expected_calibration_error_10bin": 0.00042394038597469576, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "M85": { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.7261344233455788, + "auprc": 0.006536404651771418, + "brier": 0.002529437696521024, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.0025341782013938584, + "calibration_in_the_large": 5.276467289812119e-06, + "expected_calibration_error_10bin": 5.276467289812119e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "M86": { + "valid": 2803, + "positives": 13, + "negatives": 2790, + "auroc": 0.783677970774745, + "auprc": 0.05409444358244824, + "brier": 0.00453712698083698, + "calibration": { + "observed_rate": 0.00463788797716732, + "mean_prediction": 0.0029392459686231943, + "calibration_in_the_large": -0.0016986420085441261, + "expected_calibration_error_10bin": 0.002226714079670601, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + "M94": { + "valid": 2819, + "positives": 2, + "negatives": 2817, + "auroc": 0.7122825701100461, + "auprc": 0.002027541181636298, + "brier": 0.0007093748715980428, + "calibration": { + "observed_rate": 0.000709471443774388, + "mean_prediction": 0.000264600770331958, + "calibration_in_the_large": -0.00044487067344243006, + "expected_calibration_error_10bin": 0.00044487067344243006, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "M96": { + "valid": 2804, + "positives": 2, + "negatives": 2802, + "auroc": 0.8267309064953604, + "auprc": 0.003089025966900908, + "brier": 0.0007279458612816805, + "calibration": { + "observed_rate": 0.0007132667617689016, + "mean_prediction": 0.0027283465698277613, + "calibration_in_the_large": 0.0020150798080588598, + "expected_calibration_error_10bin": 0.0020150798080588598, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "N12": { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.664897381457891, + "auprc": 0.005780090793922668, + "brier": 0.0017690204299085678, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0014668545770758325, + "calibration_in_the_large": -0.0002993057902855238, + "expected_calibration_error_10bin": 0.0002993057902855238, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N13": { + "valid": 2756, + "positives": 8, + "negatives": 2748, + "auroc": 0.636098981077147, + "auprc": 0.012480767982611036, + "brier": 0.002906735475660336, + "calibration": { + "observed_rate": 0.002902757619738752, + "mean_prediction": 0.004001179271471946, + "calibration_in_the_large": 0.0010984216517331944, + "expected_calibration_error_10bin": 0.0010984216517331944, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "N14": { + "valid": 2826, + "positives": 7, + "negatives": 2819, + "auroc": 0.8760958799979729, + "auprc": 0.01810513411991474, + "brier": 0.0024637178149787544, + "calibration": { + "observed_rate": 0.0024769992922859165, + "mean_prediction": 0.0011700523088407633, + "calibration_in_the_large": -0.0013069469834451532, + "expected_calibration_error_10bin": 0.0013069469834451532, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "N17": { + "valid": 2292, + "positives": 69, + "negatives": 2223, + "auroc": 0.7906015503269508, + "auprc": 0.10630342977808087, + "brier": 0.028583218277901046, + "calibration": { + "observed_rate": 0.030104712041884817, + "mean_prediction": 0.03412152111258465, + "calibration_in_the_large": 0.0040168090706998345, + "expected_calibration_error_10bin": 0.005623851209268607, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + "N18": { + "valid": 2440, + "positives": 34, + "negatives": 2406, + "auroc": 0.861229279741822, + "auprc": 0.12566804694235256, + "brier": 0.013019505582680627, + "calibration": { + "observed_rate": 0.013934426229508197, + "mean_prediction": 0.009053297389395174, + "calibration_in_the_large": -0.004881128840113023, + "expected_calibration_error_10bin": 0.005424012256292774, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + "N20": { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7395907791279486, + "auprc": 0.006350004967349501, + "brier": 0.0028464105085962894, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.0009294650473349012, + "calibration_in_the_large": -0.0019215684523087198, + "expected_calibration_error_10bin": 0.0019215684523087198, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "N25": { + "valid": 2831, + "positives": 6, + "negatives": 2825, + "auroc": 0.96, + "auprc": 0.09449924775251291, + "brier": 0.0020771082269316877, + "calibration": { + "observed_rate": 0.0021193924408336277, + "mean_prediction": 0.0009651834779723285, + "calibration_in_the_large": -0.0011542089628612993, + "expected_calibration_error_10bin": 0.0012307764242247624, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N28": { + "valid": 2789, + "positives": 4, + "negatives": 2785, + "auroc": 0.7909335727109515, + "auprc": 0.0092377884694711, + "brier": 0.0014440750276750237, + "calibration": { + "observed_rate": 0.0014342058085335247, + "mean_prediction": 0.003672484955217062, + "calibration_in_the_large": 0.002238279146683537, + "expected_calibration_error_10bin": 0.002238279146683537, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "N30": { + "valid": 2829, + "positives": 9, + "negatives": 2820, + "auroc": 0.6778171788810087, + "auprc": 0.009725193463376358, + "brier": 0.003192264200724082, + "calibration": { + "observed_rate": 0.003181336161187699, + "mean_prediction": 0.0028996652461992308, + "calibration_in_the_large": -0.00028167091498846816, + "expected_calibration_error_10bin": 0.0003803848450908306, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N32": { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.800965319985699, + "auprc": 0.13195669604733665, + "brier": 0.0034626518170720157, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.003561544030116613, + "calibration_in_the_large": -9.78235647547919e-07, + "expected_calibration_error_10bin": 9.78235647547919e-07, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "N39": { + "valid": 2520, + "positives": 65, + "negatives": 2455, + "auroc": 0.7641986526711577, + "auprc": 0.08149934140944236, + "brier": 0.024573430873664807, + "calibration": { + "observed_rate": 0.025793650793650792, + "mean_prediction": 0.029302385462714093, + "calibration_in_the_large": 0.0035087346690633008, + "expected_calibration_error_10bin": 0.0035087346690633003, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + "N40": { + "valid": 2606, + "positives": 16, + "negatives": 2590, + "auroc": 0.7710666023166023, + "auprc": 0.03129817359783805, + "brier": 0.006106665648714379, + "calibration": { + "observed_rate": 0.0061396776669224865, + "mean_prediction": 0.008364081425251321, + "calibration_in_the_large": 0.0022244037583288344, + "expected_calibration_error_10bin": 0.002224403758328836, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + "N73": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9784223558542625, + "auprc": 0.05051622418879056, + "brier": 0.0006973163662355394, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0008364962065691782, + "calibration_in_the_large": 0.00012953261519413394, + "expected_calibration_error_10bin": 0.00012953261519413394, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N99": { + "valid": 2799, + "positives": 3, + "negatives": 2796, + "auroc": 0.73068669527897, + "auprc": 0.008183735288934221, + "brier": 0.0010706514757435565, + "calibration": { + "observed_rate": 0.0010718113612004287, + "mean_prediction": 0.0014223101160648693, + "calibration_in_the_large": 0.00035049875486444057, + "expected_calibration_error_10bin": 0.00035049875486444057, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + "O69": { + "valid": 2743, + "positives": 5, + "negatives": 2738, + "auroc": 0.9981738495252008, + "auprc": 0.38298368298368296, + "brier": 0.0016887899283581152, + "calibration": { + "observed_rate": 0.0018228217280349982, + "mean_prediction": 0.0003945459167226949, + "calibration_in_the_large": -0.0014282758113123035, + "expected_calibration_error_10bin": 0.0015330803335829259, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "O99": { + "valid": 2652, + "positives": 1, + "negatives": 2651, + "auroc": 0.999622783855149, + "auprc": 0.5, + "brier": 0.0002567424305723304, + "calibration": { + "observed_rate": 0.0003770739064856712, + "mean_prediction": 0.0003776028962322673, + "calibration_in_the_large": 5.289897465961149e-07, + "expected_calibration_error_10bin": 0.0004184995713982291, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + "Q21": { + "valid": 2810, + "positives": 2, + "negatives": 2808, + "auroc": 0.8495370370370371, + "auprc": 0.003975521339694168, + "brier": 0.0007111054238928131, + "calibration": { + "observed_rate": 0.0007117437722419929, + "mean_prediction": 0.001021421872853265, + "calibration_in_the_large": 0.000309678100611272, + "expected_calibration_error_10bin": 0.000309678100611272, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "U07": { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 2.5017879649588177e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0025435694796597168, + "calibration_in_the_large": 0.0025435694796597168, + "expected_calibration_error_10bin": 0.0025435694796597168, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + } + }, + "210": { + "A04": { + "valid": 2782, + "positives": 22, + "negatives": 2760, + "auroc": 0.748534255599473, + "auprc": 0.05091500654639323, + "brier": 0.007762775045758519, + "calibration": { + "observed_rate": 0.007907979870596693, + "mean_prediction": 0.008035421419132913, + "calibration_in_the_large": 0.00012744154853622063, + "expected_calibration_error_10bin": 0.0003250322636106571, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "A08": { + "valid": 2818, + "positives": 11, + "negatives": 2807, + "auroc": 0.8124170094244907, + "auprc": 0.02885599960688705, + "brier": 0.003848171391788484, + "calibration": { + "observed_rate": 0.0039034776437189495, + "mean_prediction": 0.003781046456569109, + "calibration_in_the_large": -0.00012243118714984043, + "expected_calibration_error_10bin": 0.00019559005611312412, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "A41": { + "valid": 2664, + "positives": 54, + "negatives": 2610, + "auroc": 0.7438697318007663, + "auprc": 0.06537338680233297, + "brier": 0.01975723865752423, + "calibration": { + "observed_rate": 0.02027027027027027, + "mean_prediction": 0.02352960275304934, + "calibration_in_the_large": 0.003259332482779067, + "expected_calibration_error_10bin": 0.003259332482779068, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + "B00": { + "valid": 2819, + "positives": 4, + "negatives": 2815, + "auroc": 0.6559502664298401, + "auprc": 0.015301151565231666, + "brier": 0.0014496460825571562, + "calibration": { + "observed_rate": 0.001418942887548776, + "mean_prediction": 0.0015567596789022797, + "calibration_in_the_large": 0.00013781679135350358, + "expected_calibration_error_10bin": 0.00036936793747326764, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "B02": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7725504067916519, + "auprc": 0.0015527950310559005, + "brier": 0.0003558502391010236, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.000694394699048528, + "calibration_in_the_large": 0.0003407879097981744, + "expected_calibration_error_10bin": 0.0003407879097981744, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "B18": { + "valid": 2782, + "positives": 5, + "negatives": 2777, + "auroc": 0.9675189052934822, + "auprc": 0.0895331291883016, + "brier": 0.0017328673829779754, + "calibration": { + "observed_rate": 0.0017972681524083393, + "mean_prediction": 0.0010788608820881155, + "calibration_in_the_large": -0.0007184072703202238, + "expected_calibration_error_10bin": 0.0007184072703202238, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "B19": { + "valid": 2763, + "positives": 16, + "negatives": 2747, + "auroc": 0.852156898434656, + "auprc": 0.07497429500919428, + "brier": 0.005656520829499682, + "calibration": { + "observed_rate": 0.00579080709373869, + "mean_prediction": 0.001690609544136765, + "calibration_in_the_large": -0.004100197549601925, + "expected_calibration_error_10bin": 0.004296082778402, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "B20": { + "valid": 2829, + "positives": 4, + "negatives": 2825, + "auroc": 0.9898230088495575, + "auprc": 0.2828815261044177, + "brier": 0.001386601412380034, + "calibration": { + "observed_rate": 0.0014139271827500884, + "mean_prediction": 0.00025152592319710655, + "calibration_in_the_large": -0.001162401259552982, + "expected_calibration_error_10bin": 0.001162401259552982, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "B34": { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.9794055201698514, + "auprc": 0.11466735019366599, + "brier": 0.0017168634356865432, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0011454546613598603, + "calibration_in_the_large": -0.000620705706001496, + "expected_calibration_error_10bin": 0.000620705706001496, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "B35": { + "valid": 2836, + "positives": 0, + "negatives": 2836, + "auroc": null, + "auprc": null, + "brier": 1.1562294894725849e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001482568335733435, + "calibration_in_the_large": 0.001482568335733435, + "expected_calibration_error_10bin": 0.001482568335733435, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "B37": { + "valid": 2768, + "positives": 30, + "negatives": 2738, + "auroc": 0.7542731921110299, + "auprc": 0.033324402087502425, + "brier": 0.010710336970106312, + "calibration": { + "observed_rate": 0.01083815028901734, + "mean_prediction": 0.008759001367741414, + "calibration_in_the_large": -0.0020791489212759265, + "expected_calibration_error_10bin": 0.003748626048940622, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "B95": { + "valid": 2678, + "positives": 51, + "negatives": 2627, + "auroc": 0.7082782865715758, + "auprc": 0.040946201514074305, + "brier": 0.01879326695709092, + "calibration": { + "observed_rate": 0.019044062733383122, + "mean_prediction": 0.020522890690730815, + "calibration_in_the_large": 0.0014788279573476927, + "expected_calibration_error_10bin": 0.003679375445555069, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + "B96": { + "valid": 2630, + "positives": 70, + "negatives": 2560, + "auroc": 0.7651785714285714, + "auprc": 0.08751906249908288, + "brier": 0.02524158355700214, + "calibration": { + "observed_rate": 0.026615969581749048, + "mean_prediction": 0.028057191672689767, + "calibration_in_the_large": 0.0014412220909407192, + "expected_calibration_error_10bin": 0.001441222090940717, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + "B97": { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.8788039631988677, + "auprc": 0.04693165032899154, + "brier": 0.0007035246322477768, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0007442137376764404, + "calibration_in_the_large": 3.700015917573317e-05, + "expected_calibration_error_10bin": 5.827571568380824e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "C18": { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9776754075124026, + "auprc": 0.03678678678678678, + "brier": 0.0007030523314844014, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0005607191947892677, + "calibration_in_the_large": -0.00014749610266115724, + "expected_calibration_error_10bin": 0.00014749610266115724, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "C22": { + "valid": 2812, + "positives": 5, + "negatives": 2807, + "auroc": 0.9147844674029213, + "auprc": 0.060303719668144753, + "brier": 0.001746106064042926, + "calibration": { + "observed_rate": 0.0017780938833570413, + "mean_prediction": 0.0006931453586421115, + "calibration_in_the_large": -0.0010849485247149298, + "expected_calibration_error_10bin": 0.0010849485247149298, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + "C25": { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.9413965087281796, + "auprc": 0.1697061803444782, + "brier": 0.0006826048870902903, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0005143310983835701, + "calibration_in_the_large": -0.0001976660536278219, + "expected_calibration_error_10bin": 0.00029946232045589236, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "C61": { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9662861220121298, + "auprc": 0.01704225352112676, + "brier": 0.0007113251602768912, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0009252220495666388, + "calibration_in_the_large": 0.00021220957184827879, + "expected_calibration_error_10bin": 0.00021220957184827879, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "C67": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.949770074283693, + "auprc": 0.0300471327572663, + "brier": 0.0007033382026973343, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0006667940544772014, + "calibration_in_the_large": -4.016953689784286e-05, + "expected_calibration_error_10bin": 4.016953689784286e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "C77": { + "valid": 2762, + "positives": 17, + "negatives": 2745, + "auroc": 0.8436087003107254, + "auprc": 0.1112248781711873, + "brier": 0.00585921730998317, + "calibration": { + "observed_rate": 0.006154960173787111, + "mean_prediction": 0.003740950765523578, + "calibration_in_the_large": -0.0024140094082635327, + "expected_calibration_error_10bin": 0.003088698412082246, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C78": { + "valid": 2762, + "positives": 25, + "negatives": 2737, + "auroc": 0.8640555352575813, + "auprc": 0.13411050406476316, + "brier": 0.00848759718506765, + "calibration": { + "observed_rate": 0.009051412020275163, + "mean_prediction": 0.005515646435585115, + "calibration_in_the_large": -0.0035357655846900487, + "expected_calibration_error_10bin": 0.004943215548549383, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C79": { + "valid": 2751, + "positives": 19, + "negatives": 2732, + "auroc": 0.8690953224936426, + "auprc": 0.13388323585604597, + "brier": 0.007293239323071102, + "calibration": { + "observed_rate": 0.0069065794256633955, + "mean_prediction": 0.007707556936019121, + "calibration_in_the_large": 0.0008009775103557252, + "expected_calibration_error_10bin": 0.004600170782195486, + "nonempty_bins": 8 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "C83": { + "valid": 2820, + "positives": 0, + "negatives": 2820, + "auroc": null, + "auprc": null, + "brier": 1.6643622567202448e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00047259045290554, + "calibration_in_the_large": 0.00047259045290554, + "expected_calibration_error_10bin": 0.00047259045290554006, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "D25": { + "valid": 2792, + "positives": 2, + "negatives": 2790, + "auroc": 0.9408602150537635, + "auprc": 0.25302114803625375, + "brier": 0.0007075706171173061, + "calibration": { + "observed_rate": 0.0007163323782234957, + "mean_prediction": 0.000426448805266687, + "calibration_in_the_large": -0.0002898835729568087, + "expected_calibration_error_10bin": 0.0002898835729568087, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "D47": { + "valid": 2796, + "positives": 7, + "negatives": 2789, + "auroc": 0.6375557035291707, + "auprc": 0.004732363423732723, + "brier": 0.0025827764248854148, + "calibration": { + "observed_rate": 0.002503576537911302, + "mean_prediction": 0.004461054875188265, + "calibration_in_the_large": 0.0019574783372769628, + "expected_calibration_error_10bin": 0.001957478337276962, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "D50": { + "valid": 2663, + "positives": 44, + "negatives": 2619, + "auroc": 0.8062671387413656, + "auprc": 0.0995722899509554, + "brier": 0.01555406709182243, + "calibration": { + "observed_rate": 0.016522718738265114, + "mean_prediction": 0.01384489681742039, + "calibration_in_the_large": -0.0026778219208447238, + "expected_calibration_error_10bin": 0.0026778219208447238, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + "D53": { + "valid": 2805, + "positives": 14, + "negatives": 2791, + "auroc": 0.8200337820545631, + "auprc": 0.025760537692481437, + "brier": 0.005026216893262058, + "calibration": { + "observed_rate": 0.004991087344028521, + "mean_prediction": 0.005335085885171258, + "calibration_in_the_large": 0.00034399854114273726, + "expected_calibration_error_10bin": 0.000874404954851531, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "D59": { + "valid": 2836, + "positives": 1, + "negatives": 2835, + "auroc": 0.9760141093474427, + "auprc": 0.014492753623188406, + "brier": 0.00035314486405050926, + "calibration": { + "observed_rate": 0.0003526093088857546, + "mean_prediction": 0.0007322453062681545, + "calibration_in_the_large": 0.0003796359973823999, + "expected_calibration_error_10bin": 0.0003796359973823999, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "D61": { + "valid": 2773, + "positives": 30, + "negatives": 2743, + "auroc": 0.8940089925871917, + "auprc": 0.19193002671051837, + "brier": 0.00961095835702231, + "calibration": { + "observed_rate": 0.010818608005769925, + "mean_prediction": 0.009090105273165639, + "calibration_in_the_large": -0.001728502732604286, + "expected_calibration_error_10bin": 0.00373060130970336, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "D62": { + "valid": 2499, + "positives": 55, + "negatives": 2444, + "auroc": 0.7892426722213957, + "auprc": 0.06265389068846255, + "brier": 0.02113755331218561, + "calibration": { + "observed_rate": 0.022008803521408563, + "mean_prediction": 0.020951024989052273, + "calibration_in_the_large": -0.0010577785323562898, + "expected_calibration_error_10bin": 0.004129942027194536, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + "D63": { + "valid": 2686, + "positives": 66, + "negatives": 2620, + "auroc": 0.8607506361323155, + "auprc": 0.13358932581019206, + "brier": 0.022846329844923664, + "calibration": { + "observed_rate": 0.024571854058078928, + "mean_prediction": 0.02140502333014117, + "calibration_in_the_large": -0.0031668307279377576, + "expected_calibration_error_10bin": 0.008616152356531036, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + "D64": { + "valid": 2434, + "positives": 97, + "negatives": 2337, + "auroc": 0.8023591793161556, + "auprc": 0.17506238320595208, + "brier": 0.035725979525062, + "calibration": { + "observed_rate": 0.039852095316351685, + "mean_prediction": 0.04194230788682749, + "calibration_in_the_large": 0.0020902125704758065, + "expected_calibration_error_10bin": 0.0025659426838242224, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + "D65": { + "valid": 2833, + "positives": 3, + "negatives": 2830, + "auroc": 0.9613663133097762, + "auprc": 0.01747214374411414, + "brier": 0.0010593409937053307, + "calibration": { + "observed_rate": 0.0010589481115425344, + "mean_prediction": 0.0009284818749921625, + "calibration_in_the_large": -0.00013046623655037194, + "expected_calibration_error_10bin": 0.00013046623655037194, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + "D68": { + "valid": 2682, + "positives": 49, + "negatives": 2633, + "auroc": 0.8192563770665882, + "auprc": 0.12257755359811114, + "brier": 0.017216694766276557, + "calibration": { + "observed_rate": 0.018269947800149143, + "mean_prediction": 0.010765310513601106, + "calibration_in_the_large": -0.007504637286548037, + "expected_calibration_error_10bin": 0.008132528826986484, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + "D69": { + "valid": 2586, + "positives": 65, + "negatives": 2521, + "auroc": 0.8361150947426235, + "auprc": 0.21737576833903116, + "brier": 0.021858803516267282, + "calibration": { + "observed_rate": 0.025135344160866203, + "mean_prediction": 0.01867977067434185, + "calibration_in_the_large": -0.006455573486524351, + "expected_calibration_error_10bin": 0.006866847287196513, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + "D70": { + "valid": 2787, + "positives": 24, + "negatives": 2763, + "auroc": 0.8972734949933647, + "auprc": 0.24565658674062182, + "brier": 0.007969973461832923, + "calibration": { + "observed_rate": 0.008611410118406888, + "mean_prediction": 0.007688641087227304, + "calibration_in_the_large": -0.0009227690311795845, + "expected_calibration_error_10bin": 0.005367074383434043, + "nonempty_bins": 8 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "D72": { + "valid": 2595, + "positives": 50, + "negatives": 2545, + "auroc": 0.7259882121807466, + "auprc": 0.05806604163665836, + "brier": 0.018630015188409493, + "calibration": { + "observed_rate": 0.019267822736030827, + "mean_prediction": 0.020734403851201583, + "calibration_in_the_large": 0.0014665811151707564, + "expected_calibration_error_10bin": 0.0014665811151707549, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + "D73": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.8278388278388278, + "auprc": 0.02140296979006656, + "brier": 0.0010712997621199042, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.001252263205425015, + "calibration_in_the_large": 0.0001899402592493776, + "expected_calibration_error_10bin": 0.0001899402592493778, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "D75": { + "valid": 2831, + "positives": 3, + "negatives": 2828, + "auroc": 0.874941065535125, + "auprc": 0.005447163124396189, + "brier": 0.0010613595620154288, + "calibration": { + "observed_rate": 0.0010596962204168139, + "mean_prediction": 0.0012009370490203468, + "calibration_in_the_large": 0.00014124082860353295, + "expected_calibration_error_10bin": 0.00014124082860353295, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "D80": { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.9881457891012031, + "auprc": 0.0959860617085899, + "brier": 0.00207428415581379, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.0014696605214682143, + "calibration_in_the_large": -0.0006489835463283958, + "expected_calibration_error_10bin": 0.001316790229531317, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "D89": { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.8271604938271605, + "auprc": 0.007064728004661264, + "brier": 0.0008326201648533166, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0008828796616819509, + "calibration_in_the_large": 0.0001779096229085988, + "expected_calibration_error_10bin": 0.0007281040358717838, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "E03": { + "valid": 2480, + "positives": 20, + "negatives": 2460, + "auroc": 0.7470121951219513, + "auprc": 0.025254195982144907, + "brier": 0.007959563360072112, + "calibration": { + "observed_rate": 0.008064516129032258, + "mean_prediction": 0.004977666514112629, + "calibration_in_the_large": -0.003086849614919629, + "expected_calibration_error_10bin": 0.003086849614919629, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + "E04": { + "valid": 2775, + "positives": 9, + "negatives": 2766, + "auroc": 0.7664497469269703, + "auprc": 0.009953323408954566, + "brier": 0.003235858078355121, + "calibration": { + "observed_rate": 0.003243243243243243, + "mean_prediction": 0.003027762308027721, + "calibration_in_the_large": -0.00021548093521552188, + "expected_calibration_error_10bin": 0.00021548093521552188, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "E05": { + "valid": 2806, + "positives": 3, + "negatives": 2803, + "auroc": 0.29670591033416577, + "auprc": 0.0009967076719535855, + "brier": 0.001071303905447406, + "calibration": { + "observed_rate": 0.0010691375623663579, + "mean_prediction": 0.0010655901403714741, + "calibration_in_the_large": -3.5474219948837104e-06, + "expected_calibration_error_10bin": 3.5474219948837104e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "E11": { + "valid": 2194, + "positives": 17, + "negatives": 2177, + "auroc": 0.8022372936312788, + "auprc": 0.0730342919036633, + "brier": 0.007549646376192538, + "calibration": { + "observed_rate": 0.007748404740200547, + "mean_prediction": 0.006101906146669936, + "calibration_in_the_large": -0.0016464985935306115, + "expected_calibration_error_10bin": 0.001747617920934509, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + "E16": { + "valid": 2816, + "positives": 6, + "negatives": 2810, + "auroc": 0.6331553973902728, + "auprc": 0.0034507210289810293, + "brier": 0.0021427204321191463, + "calibration": { + "observed_rate": 0.002130681818181818, + "mean_prediction": 0.002448280424762185, + "calibration_in_the_large": 0.00031759860658036676, + "expected_calibration_error_10bin": 0.00031759860658036676, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "E21": { + "valid": 2814, + "positives": 2, + "negatives": 2812, + "auroc": 0.9139402560455192, + "auprc": 0.011248757043420616, + "brier": 0.0007257260696557346, + "calibration": { + "observed_rate": 0.0007107320540156361, + "mean_prediction": 0.0015185619292845047, + "calibration_in_the_large": 0.0008078298752688686, + "expected_calibration_error_10bin": 0.0008078298752688686, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "E22": { + "valid": 2802, + "positives": 7, + "negatives": 2795, + "auroc": 0.8125223613595707, + "auprc": 0.01138511128370947, + "brier": 0.0025587361019576167, + "calibration": { + "observed_rate": 0.0024982155603140615, + "mean_prediction": 0.004990278493638473, + "calibration_in_the_large": 0.0024920629333244114, + "expected_calibration_error_10bin": 0.0024920629333244114, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "E27": { + "valid": 2811, + "positives": 6, + "negatives": 2805, + "auroc": 0.7944741532976827, + "auprc": 0.006601819344947034, + "brier": 0.0021423038380747393, + "calibration": { + "observed_rate": 0.0021344717182497333, + "mean_prediction": 0.0020803369066483405, + "calibration_in_the_large": -5.4134811601392815e-05, + "expected_calibration_error_10bin": 5.4134811601392815e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + }, + "E43": { + "valid": 2748, + "positives": 33, + "negatives": 2715, + "auroc": 0.8222222222222222, + "auprc": 0.07322207829561461, + "brier": 0.011623620546017354, + "calibration": { + "observed_rate": 0.012008733624454149, + "mean_prediction": 0.012806490572073512, + "calibration_in_the_large": 0.0007977569476193633, + "expected_calibration_error_10bin": 0.001734827176030261, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + "E44": { + "valid": 2800, + "positives": 17, + "negatives": 2783, + "auroc": 0.7790788611527975, + "auprc": 0.022481604931619034, + "brier": 0.0061105613822227, + "calibration": { + "observed_rate": 0.006071428571428571, + "mean_prediction": 0.008355092843407224, + "calibration_in_the_large": 0.0022836642719786526, + "expected_calibration_error_10bin": 0.0022836642719786535, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "E46": { + "valid": 2772, + "positives": 33, + "negatives": 2739, + "auroc": 0.8181154369544293, + "auprc": 0.07924851361489613, + "brier": 0.011456572525066468, + "calibration": { + "observed_rate": 0.011904761904761904, + "mean_prediction": 0.012035177358801963, + "calibration_in_the_large": 0.00013041545404005907, + "expected_calibration_error_10bin": 0.0012444856825825719, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + "E53": { + "valid": 2804, + "positives": 6, + "negatives": 2798, + "auroc": 0.6386704789135097, + "auprc": 0.004095556040109908, + "brier": 0.002158328100757741, + "calibration": { + "observed_rate": 0.0021398002853067048, + "mean_prediction": 0.0025031956387317564, + "calibration_in_the_large": 0.0003633953534250517, + "expected_calibration_error_10bin": 0.0003633953534250517, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "E55": { + "valid": 2737, + "positives": 25, + "negatives": 2712, + "auroc": 0.5949262536873157, + "auprc": 0.01318937204349199, + "brier": 0.00920678389364504, + "calibration": { + "observed_rate": 0.009134088417975887, + "mean_prediction": 0.009672490697763084, + "calibration_in_the_large": 0.0005384022797871972, + "expected_calibration_error_10bin": 0.0005384022797871981, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + "E66": { + "valid": 2371, + "positives": 32, + "negatives": 2339, + "auroc": 0.7361853356135101, + "auprc": 0.04270867785034602, + "brier": 0.01318530348827966, + "calibration": { + "observed_rate": 0.013496415014761703, + "mean_prediction": 0.012940180384453217, + "calibration_in_the_large": -0.0005562346303084869, + "expected_calibration_error_10bin": 0.0015239551042926184, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + "E78": { + "valid": 1572, + "positives": 35, + "negatives": 1537, + "auroc": 0.717836230132912, + "auprc": 0.09857162192026903, + "brier": 0.021947614224180404, + "calibration": { + "observed_rate": 0.022264631043257, + "mean_prediction": 0.02521666142243152, + "calibration_in_the_large": 0.002952030379174523, + "expected_calibration_error_10bin": 0.009465105783875764, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + "E80": { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.8765234883445746, + "auprc": 0.02394400892276015, + "brier": 0.0021241092967916545, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0018133407258807406, + "calibration_in_the_large": -0.00031205778634030073, + "expected_calibration_error_10bin": 0.0003893229410940692, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "E83": { + "valid": 2653, + "positives": 65, + "negatives": 2588, + "auroc": 0.7982166210914279, + "auprc": 0.14252718012747373, + "brier": 0.02249389971129007, + "calibration": { + "observed_rate": 0.024500565397663022, + "mean_prediction": 0.019244538422146847, + "calibration_in_the_large": -0.005256026975516175, + "expected_calibration_error_10bin": 0.00613962043997106, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + "E86": { + "valid": 2587, + "positives": 79, + "negatives": 2508, + "auroc": 0.7840076312761189, + "auprc": 0.10230192792496914, + "brier": 0.028755900409375635, + "calibration": { + "observed_rate": 0.030537301894085815, + "mean_prediction": 0.03617938333358378, + "calibration_in_the_large": 0.005642081439497966, + "expected_calibration_error_10bin": 0.005642081439497968, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + "E87": { + "valid": 2185, + "positives": 121, + "negatives": 2064, + "auroc": 0.7940691267858286, + "auprc": 0.19032274566685783, + "brier": 0.04865170462655584, + "calibration": { + "observed_rate": 0.05537757437070938, + "mean_prediction": 0.04651057348928672, + "calibration_in_the_large": -0.008867000881422657, + "expected_calibration_error_10bin": 0.012128372325932764, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + "E88": { + "valid": 2817, + "positives": 10, + "negatives": 2807, + "auroc": 0.8128607053794086, + "auprc": 0.08459254722723095, + "brier": 0.003442300827027644, + "calibration": { + "observed_rate": 0.003549875754348598, + "mean_prediction": 0.0031955930403631525, + "calibration_in_the_large": -0.00035428271398544545, + "expected_calibration_error_10bin": 0.00043068456444071853, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "E89": { + "valid": 2780, + "positives": 5, + "negatives": 2775, + "auroc": 0.6883603603603604, + "auprc": 0.0032690909196582026, + "brier": 0.0018037495740747763, + "calibration": { + "observed_rate": 0.0017985611510791368, + "mean_prediction": 0.002856493875528384, + "calibration_in_the_large": 0.0010579327244492473, + "expected_calibration_error_10bin": 0.0010579327244492473, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "F02": { + "valid": 2802, + "positives": 3, + "negatives": 2799, + "auroc": 0.8350601405263784, + "auprc": 0.00663332394101625, + "brier": 0.0011141333087891895, + "calibration": { + "observed_rate": 0.0010706638115631692, + "mean_prediction": 0.002425544194939305, + "calibration_in_the_large": 0.0013548803833761359, + "expected_calibration_error_10bin": 0.0013548803833761359, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "F03": { + "valid": 2739, + "positives": 14, + "negatives": 2725, + "auroc": 0.8479423328964614, + "auprc": 0.026672828881050856, + "brier": 0.0051629710194328726, + "calibration": { + "observed_rate": 0.00511135450894487, + "mean_prediction": 0.006251871420310607, + "calibration_in_the_large": 0.0011405169113657366, + "expected_calibration_error_10bin": 0.0011405169113657358, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "F05": { + "valid": 2750, + "positives": 20, + "negatives": 2730, + "auroc": 0.717014652014652, + "auprc": 0.01574123140243029, + "brier": 0.007534353249752751, + "calibration": { + "observed_rate": 0.007272727272727273, + "mean_prediction": 0.01146553733851893, + "calibration_in_the_large": 0.004192810065791657, + "expected_calibration_error_10bin": 0.004192810065791656, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "F06": { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7154989384288747, + "auprc": 0.0018212508884150676, + "brier": 0.0007205103455473895, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0022164642621574594, + "calibration_in_the_large": 0.001509250683656752, + "expected_calibration_error_10bin": 0.001509250683656752, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "F10": { + "valid": 2560, + "positives": 15, + "negatives": 2545, + "auroc": 0.7944990176817289, + "auprc": 0.1098669315117465, + "brier": 0.005623919548968938, + "calibration": { + "observed_rate": 0.005859375, + "mean_prediction": 0.007520395845313032, + "calibration_in_the_large": 0.0016610208453130323, + "expected_calibration_error_10bin": 0.0018508142811697324, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "F11": { + "valid": 2741, + "positives": 9, + "negatives": 2732, + "auroc": 0.8639580283064909, + "auprc": 0.0323421346118985, + "brier": 0.0033048617142284885, + "calibration": { + "observed_rate": 0.003283473184968989, + "mean_prediction": 0.0039530036386050795, + "calibration_in_the_large": 0.0006695304536360903, + "expected_calibration_error_10bin": 0.0006695304536360901, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "F12": { + "valid": 2777, + "positives": 12, + "negatives": 2765, + "auroc": 0.8947257383966245, + "auprc": 0.02462017341005383, + "brier": 0.004275140740568771, + "calibration": { + "observed_rate": 0.004321209938782859, + "mean_prediction": 0.003056400612340908, + "calibration_in_the_large": -0.0012648093264419511, + "expected_calibration_error_10bin": 0.0012648093264419511, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "F14": { + "valid": 2787, + "positives": 9, + "negatives": 2778, + "auroc": 0.9461643068554516, + "auprc": 0.0393738384758511, + "brier": 0.003196911620703519, + "calibration": { + "observed_rate": 0.0032292787944025836, + "mean_prediction": 0.001208536595433522, + "calibration_in_the_large": -0.0020207421989690616, + "expected_calibration_error_10bin": 0.0020207421989690616, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "F15": { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.9598864039758609, + "auprc": 0.045207026560794235, + "brier": 0.0021071388682831122, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.00047940023690268177, + "calibration_in_the_large": -0.0016459982753183596, + "expected_calibration_error_10bin": 0.0016459982753183596, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "F17": { + "valid": 2426, + "positives": 27, + "negatives": 2399, + "auroc": 0.8882404705664397, + "auprc": 0.0940820126347879, + "brier": 0.010581446685759383, + "calibration": { + "observed_rate": 0.011129431162407255, + "mean_prediction": 0.011194337326676261, + "calibration_in_the_large": 6.490616426900638e-05, + "expected_calibration_error_10bin": 0.00093375738667553, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + "F19": { + "valid": 2801, + "positives": 10, + "negatives": 2791, + "auroc": 0.9648871372268004, + "auprc": 0.13691170507944855, + "brier": 0.0034321135115382, + "calibration": { + "observed_rate": 0.003570153516601214, + "mean_prediction": 0.0014295244828349276, + "calibration_in_the_large": -0.0021406290337662864, + "expected_calibration_error_10bin": 0.0021406290337662864, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F20": { + "valid": 2808, + "positives": 3, + "negatives": 2805, + "auroc": 0.8009506833036245, + "auprc": 0.015234448571989597, + "brier": 0.0010642221834212349, + "calibration": { + "observed_rate": 0.0010683760683760685, + "mean_prediction": 0.0008274507320051494, + "calibration_in_the_large": -0.0002409253363709191, + "expected_calibration_error_10bin": 0.0002409253363709191, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + "F22": { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.7585106382978724, + "auprc": 0.001466275659824047, + "brier": 0.00035685936075563875, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0008689882750800016, + "calibration_in_the_large": 0.0005145040496280343, + "expected_calibration_error_10bin": 0.0005145040496280343, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "F25": { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7901278409090909, + "auprc": 0.006009457016636274, + "brier": 0.0010652014843384686, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.000804698287945645, + "calibration_in_the_large": -0.000259508877715937, + "expected_calibration_error_10bin": 0.000259508877715937, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "F29": { + "valid": 2806, + "positives": 7, + "negatives": 2799, + "auroc": 0.7257183688051855, + "auprc": 0.006182053731198724, + "brier": 0.002491862446089049, + "calibration": { + "observed_rate": 0.0024946543121881683, + "mean_prediction": 0.000647613452361561, + "calibration_in_the_large": -0.0018470408598266074, + "expected_calibration_error_10bin": 0.0018470408598266074, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "F31": { + "valid": 2724, + "positives": 8, + "negatives": 2716, + "auroc": 0.854611561119293, + "auprc": 0.03594622934849237, + "brier": 0.0028930784411328263, + "calibration": { + "observed_rate": 0.002936857562408223, + "mean_prediction": 0.0025629943952808175, + "calibration_in_the_large": -0.00037386316712740555, + "expected_calibration_error_10bin": 0.00037386316712740555, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + "F32": { + "valid": 2200, + "positives": 53, + "negatives": 2147, + "auroc": 0.7065233630076192, + "auprc": 0.06386784720278224, + "brier": 0.023612409327876928, + "calibration": { + "observed_rate": 0.02409090909090909, + "mean_prediction": 0.03405258944469758, + "calibration_in_the_large": 0.009961680353788489, + "expected_calibration_error_10bin": 0.00996168035378849, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + "F33": { + "valid": 2800, + "positives": 11, + "negatives": 2789, + "auroc": 0.7881938785488445, + "auprc": 0.014589965890413763, + "brier": 0.003923999734581666, + "calibration": { + "observed_rate": 0.003928571428571429, + "mean_prediction": 0.002721103754586563, + "calibration_in_the_large": -0.001207467673984866, + "expected_calibration_error_10bin": 0.001207467673984866, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "F39": { + "valid": 2801, + "positives": 9, + "negatives": 2792, + "auroc": 0.7677093282394142, + "auprc": 0.022550293104149504, + "brier": 0.0031859941048225527, + "calibration": { + "observed_rate": 0.0032131381649410924, + "mean_prediction": 0.0024258716138894918, + "calibration_in_the_large": -0.0007872665510516006, + "expected_calibration_error_10bin": 0.0007872665510516006, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F41": { + "valid": 2247, + "positives": 72, + "negatives": 2175, + "auroc": 0.7130651340996168, + "auprc": 0.10097900110060037, + "brier": 0.03012468277881355, + "calibration": { + "observed_rate": 0.03204272363150868, + "mean_prediction": 0.03163205364364244, + "calibration_in_the_large": -0.0004106699878662426, + "expected_calibration_error_10bin": 0.000491070910719603, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + "F43": { + "valid": 2734, + "positives": 16, + "negatives": 2718, + "auroc": 0.8000137969094923, + "auprc": 0.07734156976513407, + "brier": 0.005720736044455176, + "calibration": { + "observed_rate": 0.005852231163130944, + "mean_prediction": 0.007287719665019331, + "calibration_in_the_large": 0.0014354885018883871, + "expected_calibration_error_10bin": 0.0014354885018883884, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "F60": { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.9357980803412727, + "auprc": 0.024722981712310983, + "brier": 0.0017656348632863906, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0016609244222909867, + "calibration_in_the_large": -0.000113383597581263, + "expected_calibration_error_10bin": 0.000113383597581263, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "F90": { + "valid": 2775, + "positives": 7, + "negatives": 2768, + "auroc": 0.893270024772915, + "auprc": 0.03341037417532666, + "brier": 0.002505498434144635, + "calibration": { + "observed_rate": 0.0025225225225225223, + "mean_prediction": 0.0007964624550276402, + "calibration_in_the_large": -0.0017260600674948823, + "expected_calibration_error_10bin": 0.0017260600674948823, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "G25": { + "valid": 2774, + "positives": 5, + "negatives": 2769, + "auroc": 0.7160707836764175, + "auprc": 0.0048818393409717515, + "brier": 0.0018141385323288777, + "calibration": { + "observed_rate": 0.001802451333813987, + "mean_prediction": 0.0030181648847646173, + "calibration_in_the_large": 0.0012157135509506304, + "expected_calibration_error_10bin": 0.0012157135509506304, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "G31": { + "valid": 2802, + "positives": 6, + "negatives": 2796, + "auroc": 0.8437649022412971, + "auprc": 0.008685502441611667, + "brier": 0.0022380789129906042, + "calibration": { + "observed_rate": 0.0021413276231263384, + "mean_prediction": 0.004246810964027051, + "calibration_in_the_large": 0.0021054833409007126, + "expected_calibration_error_10bin": 0.002105483340900713, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "G40": { + "valid": 2723, + "positives": 21, + "negatives": 2702, + "auroc": 0.747400514609989, + "auprc": 0.047170337093324376, + "brier": 0.007596223451665602, + "calibration": { + "observed_rate": 0.007712082262210797, + "mean_prediction": 0.0069430325401868154, + "calibration_in_the_large": -0.0007690497220239813, + "expected_calibration_error_10bin": 0.0014960730261675307, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "G43": { + "valid": 2725, + "positives": 13, + "negatives": 2712, + "auroc": 0.7513898343544361, + "auprc": 0.014493811259822374, + "brier": 0.004741260265441664, + "calibration": { + "observed_rate": 0.0047706422018348625, + "mean_prediction": 0.002917577705913172, + "calibration_in_the_large": -0.0018530644959216906, + "expected_calibration_error_10bin": 0.0018530644959216906, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + "G44": { + "valid": 2805, + "positives": 5, + "negatives": 2800, + "auroc": 0.7598571428571429, + "auprc": 0.007168686418716856, + "brier": 0.0017872253317007007, + "calibration": { + "observed_rate": 0.0017825311942959, + "mean_prediction": 0.0014621401483571961, + "calibration_in_the_large": -0.00032039104593870396, + "expected_calibration_error_10bin": 0.00032039104593870396, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "G47": { + "valid": 2315, + "positives": 76, + "negatives": 2239, + "auroc": 0.7103676453303872, + "auprc": 0.08710083976385483, + "brier": 0.031069281367550623, + "calibration": { + "observed_rate": 0.03282937365010799, + "mean_prediction": 0.025830761800906328, + "calibration_in_the_large": -0.006998611849201662, + "expected_calibration_error_10bin": 0.007944617854264315, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + "G51": { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 6.102524525270023e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004944891165741904, + "calibration_in_the_large": 0.0004944891165741904, + "expected_calibration_error_10bin": 0.0004944891165741904, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + "G62": { + "valid": 2751, + "positives": 32, + "negatives": 2719, + "auroc": 0.8244644170650974, + "auprc": 0.10705116347512672, + "brier": 0.010990054301670112, + "calibration": { + "observed_rate": 0.011632133769538349, + "mean_prediction": 0.0075077718620367795, + "calibration_in_the_large": -0.0041243619075015696, + "expected_calibration_error_10bin": 0.0041610554346532234, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "G81": { + "valid": 2789, + "positives": 12, + "negatives": 2777, + "auroc": 0.7419577481694875, + "auprc": 0.023645349483604777, + "brier": 0.004275427934347806, + "calibration": { + "observed_rate": 0.004302617425600574, + "mean_prediction": 0.0025777061383480604, + "calibration_in_the_large": -0.0017249112872525134, + "expected_calibration_error_10bin": 0.0018977576511332766, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "G83": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.7409901926030958, + "auprc": 0.004670650267103433, + "brier": 0.0010668476687213217, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0012399802920237573, + "calibration_in_the_large": 0.0001776573458481198, + "expected_calibration_error_10bin": 0.0001776573458481198, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "G89": { + "valid": 2537, + "positives": 50, + "negatives": 2487, + "auroc": 0.7591395255327704, + "auprc": 0.09214800876106917, + "brier": 0.018920603192333324, + "calibration": { + "observed_rate": 0.019708316909735908, + "mean_prediction": 0.025189148182047375, + "calibration_in_the_large": 0.005480831272311467, + "expected_calibration_error_10bin": 0.005718400256157068, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + "G90": { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 1.7456102961493217e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0018557458949203826, + "calibration_in_the_large": 0.0018557458949203826, + "expected_calibration_error_10bin": 0.0018557458949203826, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "G92": { + "valid": 2733, + "positives": 37, + "negatives": 2696, + "auroc": 0.7652578394418157, + "auprc": 0.0681290830387156, + "brier": 0.013287982034653145, + "calibration": { + "observed_rate": 0.01353823637028906, + "mean_prediction": 0.01764231282021025, + "calibration_in_the_large": 0.0041040764499211905, + "expected_calibration_error_10bin": 0.004373143985991561, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "G93": { + "valid": 2656, + "positives": 41, + "negatives": 2615, + "auroc": 0.7934057734458798, + "auprc": 0.05963202858856042, + "brier": 0.01491355165025116, + "calibration": { + "observed_rate": 0.015436746987951807, + "mean_prediction": 0.014420157833140924, + "calibration_in_the_large": -0.001016589154810883, + "expected_calibration_error_10bin": 0.0023595120808048626, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + "G99": { + "valid": 2841, + "positives": 0, + "negatives": 2841, + "auroc": null, + "auprc": null, + "brier": 9.871598509042215e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00039933431803865666, + "calibration_in_the_large": 0.00039933431803865666, + "expected_calibration_error_10bin": 0.00039933431803865666, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9992965177629265 + }, + "H10": { + "valid": 2832, + "positives": 5, + "negatives": 2827, + "auroc": 0.8754156349487089, + "auprc": 0.013233655416524251, + "brier": 0.0017602361829113962, + "calibration": { + "observed_rate": 0.0017655367231638418, + "mean_prediction": 0.0008573743826393266, + "calibration_in_the_large": -0.0009081623405245152, + "expected_calibration_error_10bin": 0.0009081623405245152, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "H26": { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 7.2900927154443135e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0014238311651726667, + "calibration_in_the_large": 0.0014238311651726667, + "expected_calibration_error_10bin": 0.0014238311651726667, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "H35": { + "valid": 2806, + "positives": 5, + "negatives": 2801, + "auroc": 0.7107461620849697, + "auprc": 0.006656992656700236, + "brier": 0.0017803735861672053, + "calibration": { + "observed_rate": 0.001781895937277263, + "mean_prediction": 0.0007924761407409154, + "calibration_in_the_large": -0.0009894197965363478, + "expected_calibration_error_10bin": 0.0009894197965363478, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "H40": { + "valid": 2750, + "positives": 6, + "negatives": 2744, + "auroc": 0.7957361516034985, + "auprc": 0.03190184050599738, + "brier": 0.0021779350229136052, + "calibration": { + "observed_rate": 0.002181818181818182, + "mean_prediction": 0.003931253343993872, + "calibration_in_the_large": 0.0017494351621756897, + "expected_calibration_error_10bin": 0.0017494351621756903, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "H53": { + "valid": 2790, + "positives": 10, + "negatives": 2780, + "auroc": 0.6092446043165468, + "auprc": 0.009814532817903971, + "brier": 0.003582184989909509, + "calibration": { + "observed_rate": 0.0035842293906810036, + "mean_prediction": 0.00457911697860163, + "calibration_in_the_large": 0.000994887587920626, + "expected_calibration_error_10bin": 0.000994887587920626, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "H54": { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.4248307801923762, + "auprc": 0.0009056094262851767, + "brier": 0.0007324084257791153, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0022865918232690104, + "calibration_in_the_large": 0.0015745946712576184, + "expected_calibration_error_10bin": 0.0015745946712576184, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "H91": { + "valid": 2791, + "positives": 7, + "negatives": 2784, + "auroc": 0.7565168308702791, + "auprc": 0.00843653154053553, + "brier": 0.0025038775068960874, + "calibration": { + "observed_rate": 0.0025080616266571123, + "mean_prediction": 0.0024749242173237648, + "calibration_in_the_large": -3.313740933334752e-05, + "expected_calibration_error_10bin": 3.313740933334752e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + "I07": { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.8693645722399717, + "auprc": 0.010149021673809303, + "brier": 0.0021298034303848194, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.00113053111459477, + "calibration_in_the_large": -0.0009948673976262713, + "expected_calibration_error_10bin": 0.0009948673976262713, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "I08": { + "valid": 2767, + "positives": 9, + "negatives": 2758, + "auroc": 0.8734590282813633, + "auprc": 0.023470339906502092, + "brier": 0.0034811085086358198, + "calibration": { + "observed_rate": 0.0032526201662450307, + "mean_prediction": 0.00687343648466368, + "calibration_in_the_large": 0.0036208163184186493, + "expected_calibration_error_10bin": 0.0036208163184186493, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + "I10": { + "valid": 1498, + "positives": 34, + "negatives": 1464, + "auroc": 0.6776960784313726, + "auprc": 0.057802575051274736, + "brier": 0.022104469811172034, + "calibration": { + "observed_rate": 0.022696929238985315, + "mean_prediction": 0.01676216640619086, + "calibration_in_the_large": -0.005934762832794455, + "expected_calibration_error_10bin": 0.008467843294459505, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + "I11": { + "valid": 2676, + "positives": 38, + "negatives": 2638, + "auroc": 0.8055544471489565, + "auprc": 0.04705005692411059, + "brier": 0.01391404645953211, + "calibration": { + "observed_rate": 0.014200298953662182, + "mean_prediction": 0.010556690377558563, + "calibration_in_the_large": -0.0036436085761036192, + "expected_calibration_error_10bin": 0.005628110588166833, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + "I12": { + "valid": 2552, + "positives": 21, + "negatives": 2531, + "auroc": 0.817613967752253, + "auprc": 0.04970919447895047, + "brier": 0.00813243584048054, + "calibration": { + "observed_rate": 0.008228840125391849, + "mean_prediction": 0.006447038917991837, + "calibration_in_the_large": -0.0017818012074000125, + "expected_calibration_error_10bin": 0.0032414840932026637, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + "I13": { + "valid": 2727, + "positives": 23, + "negatives": 2704, + "auroc": 0.8936358374067405, + "auprc": 0.11257125699712466, + "brier": 0.007908548010688002, + "calibration": { + "observed_rate": 0.008434176751008434, + "mean_prediction": 0.009319941791559724, + "calibration_in_the_large": 0.0008857650405512899, + "expected_calibration_error_10bin": 0.0008857650405512895, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + "I16": { + "valid": 2390, + "positives": 8, + "negatives": 2382, + "auroc": 0.8705919395465995, + "auprc": 0.022087188875337997, + "brier": 0.00331687655251513, + "calibration": { + "observed_rate": 0.0033472803347280333, + "mean_prediction": 0.002112661163578595, + "calibration_in_the_large": -0.001234619171149438, + "expected_calibration_error_10bin": 0.001234619171149438, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + "I21": { + "valid": 2671, + "positives": 18, + "negatives": 2653, + "auroc": 0.8235121665200821, + "auprc": 0.0347474150333235, + "brier": 0.0067895582340114875, + "calibration": { + "observed_rate": 0.0067390490453013855, + "mean_prediction": 0.011532184178769882, + "calibration_in_the_large": 0.004793135133468496, + "expected_calibration_error_10bin": 0.004793135133468496, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "I24": { + "valid": 2809, + "positives": 6, + "negatives": 2803, + "auroc": 0.8889285289570698, + "auprc": 0.030230155070327305, + "brier": 0.002111589492420123, + "calibration": { + "observed_rate": 0.002135991456034176, + "mean_prediction": 0.001525029182178214, + "calibration_in_the_large": -0.000610962273855962, + "expected_calibration_error_10bin": 0.000610962273855962, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "I25": { + "valid": 2243, + "positives": 36, + "negatives": 2207, + "auroc": 0.8431379952675829, + "auprc": 0.07430579507024727, + "brier": 0.015332928358379195, + "calibration": { + "observed_rate": 0.016049933125278644, + "mean_prediction": 0.013511642701017125, + "calibration_in_the_large": -0.0025382904242615186, + "expected_calibration_error_10bin": 0.0027217330857612094, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + "I26": { + "valid": 2760, + "positives": 16, + "negatives": 2744, + "auroc": 0.7116891399416909, + "auprc": 0.11049252500283381, + "brier": 0.005622052739134974, + "calibration": { + "observed_rate": 0.005797101449275362, + "mean_prediction": 0.0053435009381760405, + "calibration_in_the_large": -0.0004536005110993219, + "expected_calibration_error_10bin": 0.0004536005110993217, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + "I27": { + "valid": 2716, + "positives": 31, + "negatives": 2685, + "auroc": 0.8322100078092148, + "auprc": 0.05220864370509203, + "brier": 0.01115002650898654, + "calibration": { + "observed_rate": 0.011413843888070692, + "mean_prediction": 0.008475329820669984, + "calibration_in_the_large": -0.002938514067400708, + "expected_calibration_error_10bin": 0.005074395692066691, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I31": { + "valid": 2793, + "positives": 15, + "negatives": 2778, + "auroc": 0.842668586513079, + "auprc": 0.08827675188840627, + "brier": 0.005272529860829195, + "calibration": { + "observed_rate": 0.0053705692803437165, + "mean_prediction": 0.0034140006381651283, + "calibration_in_the_large": -0.001956568642178588, + "expected_calibration_error_10bin": 0.001956568642178588, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I34": { + "valid": 2753, + "positives": 15, + "negatives": 2738, + "auroc": 0.7624299975651327, + "auprc": 0.018383895591224494, + "brier": 0.005460747329223236, + "calibration": { + "observed_rate": 0.005448601525608427, + "mean_prediction": 0.004601027060224281, + "calibration_in_the_large": -0.0008475744653841464, + "expected_calibration_error_10bin": 0.001369065700049534, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + "I35": { + "valid": 2723, + "positives": 6, + "negatives": 2717, + "auroc": 0.717764691448902, + "auprc": 0.008225890895908658, + "brier": 0.0022928408186000527, + "calibration": { + "observed_rate": 0.0022034520749173708, + "mean_prediction": 0.004149086841496751, + "calibration_in_the_large": 0.0019456347665793806, + "expected_calibration_error_10bin": 0.0019456347665793808, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "I42": { + "valid": 2740, + "positives": 11, + "negatives": 2729, + "auroc": 0.9225157400313135, + "auprc": 0.06562051795228276, + "brier": 0.003912726752291772, + "calibration": { + "observed_rate": 0.0040145985401459855, + "mean_prediction": 0.0037605116792391972, + "calibration_in_the_large": -0.0002540868609067883, + "expected_calibration_error_10bin": 0.0003566680534489544, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "I44": { + "valid": 2722, + "positives": 17, + "negatives": 2705, + "auroc": 0.8706752201804936, + "auprc": 0.06372147014081178, + "brier": 0.006089920708015001, + "calibration": { + "observed_rate": 0.006245407788390889, + "mean_prediction": 0.007890294257555793, + "calibration_in_the_large": 0.0016448864691649048, + "expected_calibration_error_10bin": 0.002168652020735837, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + "I45": { + "valid": 2766, + "positives": 12, + "negatives": 2754, + "auroc": 0.7051561365286856, + "auprc": 0.03885399322466187, + "brier": 0.00431136300717556, + "calibration": { + "observed_rate": 0.004338394793926247, + "mean_prediction": 0.0059550916132851675, + "calibration_in_the_large": 0.00161669681935892, + "expected_calibration_error_10bin": 0.00161669681935892, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + "I46": { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.4784452296819788, + "auprc": 0.0006770480704129993, + "brier": 0.00036451262307789196, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0018140891305089759, + "calibration_in_the_large": 0.0014608570570367047, + "expected_calibration_error_10bin": 0.0014608570570367047, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I47": { + "valid": 2716, + "positives": 12, + "negatives": 2704, + "auroc": 0.7251602564102564, + "auprc": 0.01121612256375021, + "brier": 0.004450926087478212, + "calibration": { + "observed_rate": 0.004418262150220913, + "mean_prediction": 0.007448006235485275, + "calibration_in_the_large": 0.0030297440852643616, + "expected_calibration_error_10bin": 0.0030297440852643616, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I48": { + "valid": 2385, + "positives": 22, + "negatives": 2363, + "auroc": 0.7825953141230331, + "auprc": 0.028019985030123387, + "brier": 0.009145879047720762, + "calibration": { + "observed_rate": 0.009224318658280923, + "mean_prediction": 0.009753608837088206, + "calibration_in_the_large": 0.0005292901788072832, + "expected_calibration_error_10bin": 0.0005292901788072837, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + "I49": { + "valid": 2734, + "positives": 15, + "negatives": 2719, + "auroc": 0.7340934166973152, + "auprc": 0.012681789397074043, + "brier": 0.005450150720257779, + "calibration": { + "observed_rate": 0.005486466715435259, + "mean_prediction": 0.00392619129676534, + "calibration_in_the_large": -0.0015602754186699198, + "expected_calibration_error_10bin": 0.0015602754186699198, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I50": { + "valid": 2415, + "positives": 38, + "negatives": 2377, + "auroc": 0.8000686402586188, + "auprc": 0.07953195748507892, + "brier": 0.015418391964628327, + "calibration": { + "observed_rate": 0.015734989648033125, + "mean_prediction": 0.016584733304411934, + "calibration_in_the_large": 0.000849743656378809, + "expected_calibration_error_10bin": 0.00410591606705114, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + "I51": { + "valid": 2807, + "positives": 6, + "negatives": 2801, + "auroc": 0.8385100559324051, + "auprc": 0.008068767466342481, + "brier": 0.0021309916118125694, + "calibration": { + "observed_rate": 0.0021375133594584966, + "mean_prediction": 0.0018945445583272158, + "calibration_in_the_large": -0.00024296880113128076, + "expected_calibration_error_10bin": 0.00024296880113128076, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "I61": { + "valid": 2802, + "positives": 7, + "negatives": 2795, + "auroc": 0.8335292614362382, + "auprc": 0.009593485076685672, + "brier": 0.002492473305602333, + "calibration": { + "observed_rate": 0.0024982155603140615, + "mean_prediction": 0.0007401938932854032, + "calibration_in_the_large": -0.0017580216670286582, + "expected_calibration_error_10bin": 0.0017580216670286582, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "I63": { + "valid": 2735, + "positives": 11, + "negatives": 2724, + "auroc": 0.8043318649045521, + "auprc": 0.018440968618051296, + "brier": 0.004028384268093244, + "calibration": { + "observed_rate": 0.0040219378427787935, + "mean_prediction": 0.00419224670005305, + "calibration_in_the_large": 0.00017030885727425688, + "expected_calibration_error_10bin": 0.00018845198997781605, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + "I65": { + "valid": 2774, + "positives": 5, + "negatives": 2769, + "auroc": 0.6776453593355002, + "auprc": 0.011548368165711467, + "brier": 0.0018061332067535693, + "calibration": { + "observed_rate": 0.001802451333813987, + "mean_prediction": 0.0027090210151335115, + "calibration_in_the_large": 0.0009065696813195245, + "expected_calibration_error_10bin": 0.0009065696813195245, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "I67": { + "valid": 2773, + "positives": 3, + "negatives": 2770, + "auroc": 0.6316486161251504, + "auprc": 0.0029747445536919223, + "brier": 0.001113193611674584, + "calibration": { + "observed_rate": 0.0010818608005769925, + "mean_prediction": 0.002689040780319759, + "calibration_in_the_large": 0.0016071799797427665, + "expected_calibration_error_10bin": 0.0016071799797427665, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "I69": { + "valid": 2752, + "positives": 15, + "negatives": 2737, + "auroc": 0.7387163561076605, + "auprc": 0.014630703476529276, + "brier": 0.0054939753157431616, + "calibration": { + "observed_rate": 0.005450581395348837, + "mean_prediction": 0.006313724375614626, + "calibration_in_the_large": 0.0008631429802657886, + "expected_calibration_error_10bin": 0.0008631429802657887, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + "I70": { + "valid": 2771, + "positives": 7, + "negatives": 2764, + "auroc": 0.8059747777548067, + "auprc": 0.015446238043286745, + "brier": 0.0025149190105239975, + "calibration": { + "observed_rate": 0.0025261638397690365, + "mean_prediction": 0.0023407933921885298, + "calibration_in_the_large": -0.00018537044758050675, + "expected_calibration_error_10bin": 0.00018537044758050675, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + "I71": { + "valid": 2769, + "positives": 4, + "negatives": 2765, + "auroc": 0.7282097649186257, + "auprc": 0.004886829623737581, + "brier": 0.0014521421418557392, + "calibration": { + "observed_rate": 0.001444564824846515, + "mean_prediction": 0.002210088632127946, + "calibration_in_the_large": 0.0007655238072814311, + "expected_calibration_error_10bin": 0.0007655238072814311, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + "I72": { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.7750444365446143, + "auprc": 0.01015133444786921, + "brier": 0.001771071942808015, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0012593444736174334, + "calibration_in_the_large": -0.0005149635462548163, + "expected_calibration_error_10bin": 0.0005149635462548163, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "I73": { + "valid": 2734, + "positives": 7, + "negatives": 2727, + "auroc": 0.7703913248467704, + "auprc": 0.04833042178649417, + "brier": 0.0025128065617076017, + "calibration": { + "observed_rate": 0.002560351133869788, + "mean_prediction": 0.002290803194276488, + "calibration_in_the_large": -0.00026954793959330006, + "expected_calibration_error_10bin": 0.0003455962501096464, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I74": { + "valid": 2821, + "positives": 5, + "negatives": 2816, + "auroc": 0.5803267045454545, + "auprc": 0.0034125908755918226, + "brier": 0.0017712425758297423, + "calibration": { + "observed_rate": 0.001772421127259837, + "mean_prediction": 0.0007038848885185929, + "calibration_in_the_large": -0.001068536238741244, + "expected_calibration_error_10bin": 0.001068536238741244, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "I77": { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.7180870190578929, + "auprc": 0.006746563407811952, + "brier": 0.0014373307837648982, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.0019369655372984574, + "calibration_in_the_large": 0.0005006998281422634, + "expected_calibration_error_10bin": 0.0005006998281422634, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "I80": { + "valid": 2827, + "positives": 4, + "negatives": 2823, + "auroc": 0.8905419766206164, + "auprc": 0.08953399586156613, + "brier": 0.0013872217746619209, + "calibration": { + "observed_rate": 0.0014149274849663955, + "mean_prediction": 0.0011373964713209466, + "calibration_in_the_large": -0.00027753101364544884, + "expected_calibration_error_10bin": 0.00027753101364544884, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "I81": { + "valid": 2826, + "positives": 7, + "negatives": 2819, + "auroc": 0.8664673389753206, + "auprc": 0.02494945478001397, + "brier": 0.0025372476747551106, + "calibration": { + "observed_rate": 0.0024769992922859165, + "mean_prediction": 0.0020820008045701215, + "calibration_in_the_large": -0.00039499848771579497, + "expected_calibration_error_10bin": 0.0009962271227383897, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I82": { + "valid": 2739, + "positives": 26, + "negatives": 2713, + "auroc": 0.7090220873855227, + "auprc": 0.029900263819503815, + "brier": 0.009476302654247093, + "calibration": { + "observed_rate": 0.009492515516611903, + "mean_prediction": 0.009134285454148457, + "calibration_in_the_large": -0.0003582300624634452, + "expected_calibration_error_10bin": 0.0022845930774729236, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "I85": { + "valid": 2793, + "positives": 8, + "negatives": 2785, + "auroc": 0.9904398563734291, + "auprc": 0.2074648730898731, + "brier": 0.0026922953131832458, + "calibration": { + "observed_rate": 0.0028643036161833156, + "mean_prediction": 0.001711258644654829, + "calibration_in_the_large": -0.0011530449715284866, + "expected_calibration_error_10bin": 0.002352362129245166, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I87": { + "valid": 2780, + "positives": 12, + "negatives": 2768, + "auroc": 0.725674373795761, + "auprc": 0.010802584670906404, + "brier": 0.004328092835128613, + "calibration": { + "observed_rate": 0.004316546762589928, + "mean_prediction": 0.00460050165334814, + "calibration_in_the_large": 0.0002839548907582123, + "expected_calibration_error_10bin": 0.00028395489075821204, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "I89": { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8470046082949308, + "auprc": 0.012516279669533392, + "brier": 0.001763334788533019, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0006402802820377792, + "calibration_in_the_large": -0.0011290049267378753, + "expected_calibration_error_10bin": 0.0011290049267378753, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I95": { + "valid": 2485, + "positives": 77, + "negatives": 2408, + "auroc": 0.743101997670104, + "auprc": 0.07421684690583036, + "brier": 0.02951059665065825, + "calibration": { + "observed_rate": 0.030985915492957747, + "mean_prediction": 0.029559115897180133, + "calibration_in_the_large": -0.0014267995957776142, + "expected_calibration_error_10bin": 0.007470443656328896, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + "I96": { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.8709837225760793, + "auprc": 0.03653186602549953, + "brier": 0.001744815968126745, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0015036643695423171, + "calibration_in_the_large": -0.00026249599781903916, + "expected_calibration_error_10bin": 0.00026249599781903916, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I97": { + "valid": 2740, + "positives": 9, + "negatives": 2731, + "auroc": 0.7793238130111071, + "auprc": 0.010827963371316343, + "brier": 0.003270889346809464, + "calibration": { + "observed_rate": 0.0032846715328467154, + "mean_prediction": 0.0029247561077622147, + "calibration_in_the_large": -0.00035991542508450073, + "expected_calibration_error_10bin": 0.00035991542508450073, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "J02": { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.6806588735387885, + "auprc": 0.001631918101112414, + "brier": 0.0007207962009052599, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0015107873686181332, + "calibration_in_the_large": 0.0008028227668482217, + "expected_calibration_error_10bin": 0.0008028227668482217, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J06": { + "valid": 2816, + "positives": 8, + "negatives": 2808, + "auroc": 0.7312589031339032, + "auprc": 0.012400963499288044, + "brier": 0.002878359820504345, + "calibration": { + "observed_rate": 0.002840909090909091, + "mean_prediction": 0.003024561603826793, + "calibration_in_the_large": 0.0001836525129177021, + "expected_calibration_error_10bin": 0.00022028838697255284, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "J12": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 5.458307939134798e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0023654505743166713, + "calibration_in_the_large": 0.0023654505743166713, + "expected_calibration_error_10bin": 0.0023654505743166713, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J15": { + "valid": 2795, + "positives": 12, + "negatives": 2783, + "auroc": 0.7925200622829082, + "auprc": 0.01870298472366771, + "brier": 0.004337201130078476, + "calibration": { + "observed_rate": 0.004293381037567084, + "mean_prediction": 0.005443593097989119, + "calibration_in_the_large": 0.0011502120604220348, + "expected_calibration_error_10bin": 0.0011502120604220344, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + "J18": { + "valid": 2671, + "positives": 44, + "negatives": 2627, + "auroc": 0.7801069315153822, + "auprc": 0.057487836258537504, + "brier": 0.01608762131246806, + "calibration": { + "observed_rate": 0.01647323099962561, + "mean_prediction": 0.017159552630129905, + "calibration_in_the_large": 0.0006863216305042948, + "expected_calibration_error_10bin": 0.0030560499287280323, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "J30": { + "valid": 2815, + "positives": 6, + "negatives": 2809, + "auroc": 0.7117004865313872, + "auprc": 0.0293586743508491, + "brier": 0.0021229017027134573, + "calibration": { + "observed_rate": 0.0021314387211367673, + "mean_prediction": 0.002588222442862915, + "calibration_in_the_large": 0.0004567837217261477, + "expected_calibration_error_10bin": 0.00045678372172614797, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "J32": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.5136186770428015, + "auprc": 0.0025702665908425098, + "brier": 0.0007198788365052696, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0011316420632363924, + "calibration_in_the_large": 0.00042467847186134823, + "expected_calibration_error_10bin": 0.00042467847186134823, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J38": { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.6792419411973079, + "auprc": 0.0021973377539966517, + "brier": 0.0007147292357661523, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0013814805324312476, + "calibration_in_the_large": 0.000673515930661336, + "expected_calibration_error_10bin": 0.000673515930661336, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J43": { + "valid": 2804, + "positives": 7, + "negatives": 2797, + "auroc": 0.6738852852546096, + "auprc": 0.005351397022152473, + "brier": 0.0025022720214942194, + "calibration": { + "observed_rate": 0.0024964336661911554, + "mean_prediction": 0.0016452842793262448, + "calibration_in_the_large": -0.0008511493868649106, + "expected_calibration_error_10bin": 0.0009225555174787631, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "J44": { + "valid": 2570, + "positives": 22, + "negatives": 2548, + "auroc": 0.7759918652775796, + "auprc": 0.028696544064833206, + "brier": 0.008445593816488786, + "calibration": { + "observed_rate": 0.008560311284046693, + "mean_prediction": 0.0066968570832111685, + "calibration_in_the_large": -0.001863454200835525, + "expected_calibration_error_10bin": 0.002116705923418108, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + "J45": { + "valid": 2518, + "positives": 21, + "negatives": 2497, + "auroc": 0.6943761084730248, + "auprc": 0.023232001539362307, + "brier": 0.008249830579939962, + "calibration": { + "observed_rate": 0.008339952343129467, + "mean_prediction": 0.006572644471890286, + "calibration_in_the_large": -0.0017673078712391807, + "expected_calibration_error_10bin": 0.0018590014269135341, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + "J47": { + "valid": 2825, + "positives": 6, + "negatives": 2819, + "auroc": 0.8605888612983328, + "auprc": 0.01417429515692223, + "brier": 0.0021178665993310435, + "calibration": { + "observed_rate": 0.0021238938053097347, + "mean_prediction": 0.0007375162189939662, + "calibration_in_the_large": -0.0013863775863157683, + "expected_calibration_error_10bin": 0.0013863775863157683, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J69": { + "valid": 2777, + "positives": 24, + "negatives": 2753, + "auroc": 0.7775154377043225, + "auprc": 0.032445637149609984, + "brier": 0.008557414094277417, + "calibration": { + "observed_rate": 0.008642419877565718, + "mean_prediction": 0.009418196986518435, + "calibration_in_the_large": 0.0007757771089527167, + "expected_calibration_error_10bin": 0.0007757771089527154, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "J81": { + "valid": 2781, + "positives": 17, + "negatives": 2764, + "auroc": 0.773176130075764, + "auprc": 0.024654093695816635, + "brier": 0.006053293049134276, + "calibration": { + "observed_rate": 0.006112909025530385, + "mean_prediction": 0.0028410635608490074, + "calibration_in_the_large": -0.0032718454646813774, + "expected_calibration_error_10bin": 0.0032718454646813774, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "J84": { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.9150991357397051, + "auprc": 0.03386769967511249, + "brier": 0.0024589311240470787, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.0014696852769036292, + "calibration_in_the_large": -0.0010152277511403893, + "expected_calibration_error_10bin": 0.0010152277511403893, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "J90": { + "valid": 2754, + "positives": 28, + "negatives": 2726, + "auroc": 0.6859212870768263, + "auprc": 0.020148341801461273, + "brier": 0.01017950231915649, + "calibration": { + "observed_rate": 0.010167029774872912, + "mean_prediction": 0.008866892604965091, + "calibration_in_the_large": -0.0013001371699078203, + "expected_calibration_error_10bin": 0.002608703601328728, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + "J91": { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.8223096174472649, + "auprc": 0.07475535845826425, + "brier": 0.003476264655510439, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.0032436679361687337, + "calibration_in_the_large": -0.00031885432959542727, + "expected_calibration_error_10bin": 0.00036351315216196336, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "J94": { + "valid": 2829, + "positives": 9, + "negatives": 2820, + "auroc": 0.6969267139479906, + "auprc": 0.12036641699690184, + "brier": 0.003139779268625396, + "calibration": { + "observed_rate": 0.003181336161187699, + "mean_prediction": 0.001216854802907025, + "calibration_in_the_large": -0.001964481358280674, + "expected_calibration_error_10bin": 0.001964481358280674, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J95": { + "valid": 2770, + "positives": 12, + "negatives": 2758, + "auroc": 0.8106417693981146, + "auprc": 0.029742099256945, + "brier": 0.00427301965303762, + "calibration": { + "observed_rate": 0.004332129963898917, + "mean_prediction": 0.0043422060850353125, + "calibration_in_the_large": 1.0076121136395541e-05, + "expected_calibration_error_10bin": 1.0076121136395541e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + "J96": { + "valid": 2605, + "positives": 59, + "negatives": 2546, + "auroc": 0.8249830242187812, + "auprc": 0.08865538639804385, + "brier": 0.02173823414476131, + "calibration": { + "observed_rate": 0.022648752399232246, + "mean_prediction": 0.02231257174470401, + "calibration_in_the_large": -0.0003361806545282356, + "expected_calibration_error_10bin": 0.0050583058392701385, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + "J98": { + "valid": 2692, + "positives": 29, + "negatives": 2663, + "auroc": 0.7559532287930387, + "auprc": 0.04730645415948463, + "brier": 0.010493664028045316, + "calibration": { + "observed_rate": 0.010772659732540862, + "mean_prediction": 0.008983340718519039, + "calibration_in_the_large": -0.001789319014021823, + "expected_calibration_error_10bin": 0.001873558283945491, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + "K04": { + "valid": 2836, + "positives": 1, + "negatives": 2835, + "auroc": 0.9389770723104056, + "auprc": 0.005747126436781609, + "brier": 0.0003532416931076946, + "calibration": { + "observed_rate": 0.0003526093088857546, + "mean_prediction": 0.0006491008662034137, + "calibration_in_the_large": 0.0002964915573176591, + "expected_calibration_error_10bin": 0.0002964915573176591, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "K12": { + "valid": 2824, + "positives": 10, + "negatives": 2814, + "auroc": 0.8520255863539445, + "auprc": 0.06858405654243291, + "brier": 0.003856846199950191, + "calibration": { + "observed_rate": 0.0035410764872521247, + "mean_prediction": 0.00398194920506532, + "calibration_in_the_large": 0.0004408727178131953, + "expected_calibration_error_10bin": 0.002902261229262737, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K20": { + "valid": 2813, + "positives": 6, + "negatives": 2807, + "auroc": 0.730376439852749, + "auprc": 0.04944684858505657, + "brier": 0.002171206671238807, + "calibration": { + "observed_rate": 0.002132954141485958, + "mean_prediction": 0.00539228780779894, + "calibration_in_the_large": 0.0032593336663129815, + "expected_calibration_error_10bin": 0.0032593336663129815, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K21": { + "valid": 2043, + "positives": 67, + "negatives": 1976, + "auroc": 0.7655220859266421, + "auprc": 0.13507066860350334, + "brier": 0.03021225224884908, + "calibration": { + "observed_rate": 0.032794909446891826, + "mean_prediction": 0.03586417433157986, + "calibration_in_the_large": 0.0030692648846880333, + "expected_calibration_error_10bin": 0.003909823210062973, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + "K22": { + "valid": 2764, + "positives": 14, + "negatives": 2750, + "auroc": 0.7937922077922078, + "auprc": 0.025417178390840494, + "brier": 0.004999430639860872, + "calibration": { + "observed_rate": 0.005065123010130246, + "mean_prediction": 0.004451875898682707, + "calibration_in_the_large": -0.0006132471114475386, + "expected_calibration_error_10bin": 0.0006132471114475386, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + "K25": { + "valid": 2817, + "positives": 6, + "negatives": 2811, + "auroc": 0.791889007470651, + "auprc": 0.010084659192917048, + "brier": 0.002171341040085834, + "calibration": { + "observed_rate": 0.002129925452609159, + "mean_prediction": 0.0029407851609790123, + "calibration_in_the_large": 0.0008108597083698534, + "expected_calibration_error_10bin": 0.0008108597083698534, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "K26": { + "valid": 2814, + "positives": 5, + "negatives": 2809, + "auroc": 0.9298682805268779, + "auprc": 0.0536253842775582, + "brier": 0.0017543380932462302, + "calibration": { + "observed_rate": 0.0017768301350390902, + "mean_prediction": 0.0014882621293439335, + "calibration_in_the_large": -0.0002885680056951567, + "expected_calibration_error_10bin": 0.0002885680056951567, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "K29": { + "valid": 2785, + "positives": 10, + "negatives": 2775, + "auroc": 0.7555315315315315, + "auprc": 0.021176225223876723, + "brier": 0.0036097896539523575, + "calibration": { + "observed_rate": 0.003590664272890485, + "mean_prediction": 0.006964831418797534, + "calibration_in_the_large": 0.0033741671459070494, + "expected_calibration_error_10bin": 0.00337416714590705, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K30": { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.92663139329806, + "auprc": 0.006956234672703263, + "brier": 0.0007081267167487664, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0012100931130216263, + "calibration_in_the_large": 0.0005051230742482742, + "expected_calibration_error_10bin": 0.0005051230742482742, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "K31": { + "valid": 2756, + "positives": 15, + "negatives": 2741, + "auroc": 0.9137297823178888, + "auprc": 0.05675444739755837, + "brier": 0.005323739725912118, + "calibration": { + "observed_rate": 0.00544267053701016, + "mean_prediction": 0.0051091960231450075, + "calibration_in_the_large": -0.0003334745138651521, + "expected_calibration_error_10bin": 0.0011336981159147347, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "K40": { + "valid": 2827, + "positives": 3, + "negatives": 2824, + "auroc": 0.8916430594900849, + "auprc": 0.006225408547919034, + "brier": 0.0010594810119567478, + "calibration": { + "observed_rate": 0.0010611956137247967, + "mean_prediction": 0.0013506305846986367, + "calibration_in_the_large": 0.00028943497097384005, + "expected_calibration_error_10bin": 0.00028943497097384005, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "K42": { + "valid": 2820, + "positives": 5, + "negatives": 2815, + "auroc": 0.7763410301953819, + "auprc": 0.015442860091072073, + "brier": 0.001773640611479707, + "calibration": { + "observed_rate": 0.0017730496453900709, + "mean_prediction": 0.0010740647172239107, + "calibration_in_the_large": -0.0006989849281661602, + "expected_calibration_error_10bin": 0.0006989849281661602, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "K43": { + "valid": 2813, + "positives": 5, + "negatives": 2808, + "auroc": 0.8077635327635327, + "auprc": 0.014059077465391118, + "brier": 0.0017772604152047386, + "calibration": { + "observed_rate": 0.0017774617845716318, + "mean_prediction": 0.001929827385420686, + "calibration_in_the_large": 0.00015236560084905433, + "expected_calibration_error_10bin": 0.00015236560084905433, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K44": { + "valid": 2785, + "positives": 5, + "negatives": 2780, + "auroc": 0.6284172661870504, + "auprc": 0.005135569170644934, + "brier": 0.0017984439613030964, + "calibration": { + "observed_rate": 0.0017953321364452424, + "mean_prediction": 0.0025754255794860877, + "calibration_in_the_large": 0.0007800934430408453, + "expected_calibration_error_10bin": 0.0007800934430408453, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K52": { + "valid": 2749, + "positives": 31, + "negatives": 2718, + "auroc": 0.8067839255619644, + "auprc": 0.11894719494800668, + "brier": 0.011025840425448089, + "calibration": { + "observed_rate": 0.011276827937431793, + "mean_prediction": 0.01039164440708532, + "calibration_in_the_large": -0.0008851835303464728, + "expected_calibration_error_10bin": 0.004301073766210926, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + "K55": { + "valid": 2815, + "positives": 8, + "negatives": 2807, + "auroc": 0.807401140007125, + "auprc": 0.01024695269674314, + "brier": 0.00285618193705437, + "calibration": { + "observed_rate": 0.002841918294849023, + "mean_prediction": 0.002578918693960442, + "calibration_in_the_large": -0.00026299960088858095, + "expected_calibration_error_10bin": 0.00035565601636716737, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "K56": { + "valid": 2745, + "positives": 26, + "negatives": 2719, + "auroc": 0.7467394686960704, + "auprc": 0.03725709088757194, + "brier": 0.009298544396123114, + "calibration": { + "observed_rate": 0.00947176684881603, + "mean_prediction": 0.010685084555306573, + "calibration_in_the_large": 0.0012133177064905434, + "expected_calibration_error_10bin": 0.0012133177064905431, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + "K57": { + "valid": 2741, + "positives": 20, + "negatives": 2721, + "auroc": 0.6835170893054024, + "auprc": 0.018616139214743716, + "brier": 0.007248640019702274, + "calibration": { + "observed_rate": 0.0072966070777088655, + "mean_prediction": 0.004288508504286674, + "calibration_in_the_large": -0.0030080985734221915, + "expected_calibration_error_10bin": 0.003099781781299071, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "K58": { + "valid": 2792, + "positives": 7, + "negatives": 2785, + "auroc": 0.7357271095152603, + "auprc": 0.014345855754022826, + "brier": 0.002498210018267487, + "calibration": { + "observed_rate": 0.002507163323782235, + "mean_prediction": 0.0017684339731553296, + "calibration_in_the_large": -0.0007387293506269056, + "expected_calibration_error_10bin": 0.0007387293506269056, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "K59": { + "valid": 2560, + "positives": 78, + "negatives": 2482, + "auroc": 0.7586985268290667, + "auprc": 0.1316035247791112, + "brier": 0.02821370976795239, + "calibration": { + "observed_rate": 0.03046875, + "mean_prediction": 0.024984288238056252, + "calibration_in_the_large": -0.005484461761943747, + "expected_calibration_error_10bin": 0.006423713960384701, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "K62": { + "valid": 2813, + "positives": 12, + "negatives": 2801, + "auroc": 0.8635903843865286, + "auprc": 0.02628080278459326, + "brier": 0.004217594236223014, + "calibration": { + "observed_rate": 0.004265908282971916, + "mean_prediction": 0.0027909819222074164, + "calibration_in_the_large": -0.0014749263607645, + "expected_calibration_error_10bin": 0.0014749263607645, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K63": { + "valid": 2810, + "positives": 15, + "negatives": 2795, + "auroc": 0.7225760286225402, + "auprc": 0.012304006116957733, + "brier": 0.005320905335302665, + "calibration": { + "observed_rate": 0.005338078291814947, + "mean_prediction": 0.003472031313616611, + "calibration_in_the_large": -0.0018660469781983358, + "expected_calibration_error_10bin": 0.0018660469781983358, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "K64": { + "valid": 2801, + "positives": 17, + "negatives": 2784, + "auroc": 0.7802358012170385, + "auprc": 0.02067165693321929, + "brier": 0.006127062931809164, + "calibration": { + "observed_rate": 0.006069260978222063, + "mean_prediction": 0.005504906465314619, + "calibration_in_the_large": -0.0005643545129074444, + "expected_calibration_error_10bin": 0.0020125277470901416, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "K65": { + "valid": 2813, + "positives": 11, + "negatives": 2802, + "auroc": 0.8809292064110051, + "auprc": 0.03646928991793443, + "brier": 0.00401849178578809, + "calibration": { + "observed_rate": 0.0039104159260575895, + "mean_prediction": 0.007346472529202746, + "calibration_in_the_large": 0.003436056603145156, + "expected_calibration_error_10bin": 0.003436056603145156, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K66": { + "valid": 2796, + "positives": 7, + "negatives": 2789, + "auroc": 0.7229933924089536, + "auprc": 0.019431962719180688, + "brier": 0.0025137408024493357, + "calibration": { + "observed_rate": 0.002503576537911302, + "mean_prediction": 0.003848122933190558, + "calibration_in_the_large": 0.0013445463952792562, + "expected_calibration_error_10bin": 0.0013445463952792562, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "K70": { + "valid": 2774, + "positives": 1, + "negatives": 2773, + "auroc": 0.9484313018391634, + "auprc": 0.006944444444444444, + "brier": 0.0003751447572460951, + "calibration": { + "observed_rate": 0.0003604902667627974, + "mean_prediction": 0.0008570157369767644, + "calibration_in_the_large": 0.000496525470213967, + "expected_calibration_error_10bin": 0.000496525470213967, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "K72": { + "valid": 2787, + "positives": 18, + "negatives": 2769, + "auroc": 0.9556197584366598, + "auprc": 0.2890625339864446, + "brier": 0.005615123870211976, + "calibration": { + "observed_rate": 0.006458557588805167, + "mean_prediction": 0.0034036242333477596, + "calibration_in_the_large": -0.0030549333554574076, + "expected_calibration_error_10bin": 0.003314727781284888, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "K74": { + "valid": 2763, + "positives": 7, + "negatives": 2756, + "auroc": 0.9557329462989841, + "auprc": 0.0487282417958607, + "brier": 0.002513211288322681, + "calibration": { + "observed_rate": 0.0025334781035106766, + "mean_prediction": 0.0028401743918578357, + "calibration_in_the_large": 0.00030669628834715905, + "expected_calibration_error_10bin": 0.0004851740955188133, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "K75": { + "valid": 2798, + "positives": 10, + "negatives": 2788, + "auroc": 0.8181850789096127, + "auprc": 0.022852343431972174, + "brier": 0.00356041892953612, + "calibration": { + "observed_rate": 0.0035739814152966403, + "mean_prediction": 0.0022596329552774957, + "calibration_in_the_large": -0.0013143484600191446, + "expected_calibration_error_10bin": 0.0015664599600563815, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "K76": { + "valid": 2681, + "positives": 26, + "negatives": 2655, + "auroc": 0.8062146892655367, + "auprc": 0.15429914310758838, + "brier": 0.008934419190168203, + "calibration": { + "observed_rate": 0.00969787392763894, + "mean_prediction": 0.004953165553676584, + "calibration_in_the_large": -0.004744708373962357, + "expected_calibration_error_10bin": 0.005306232460643866, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + "K80": { + "valid": 2731, + "positives": 12, + "negatives": 2719, + "auroc": 0.6901127865636877, + "auprc": 0.014495729650959818, + "brier": 0.004370007363710782, + "calibration": { + "observed_rate": 0.004393994873672647, + "mean_prediction": 0.002585469999030732, + "calibration_in_the_large": -0.0018085248746419155, + "expected_calibration_error_10bin": 0.0018085248746419155, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + "K81": { + "valid": 2825, + "positives": 5, + "negatives": 2820, + "auroc": 0.8497872340425532, + "auprc": 0.026504115056541506, + "brier": 0.00175582466507064, + "calibration": { + "observed_rate": 0.0017699115044247787, + "mean_prediction": 0.0012699013933231869, + "calibration_in_the_large": -0.0005000101111015919, + "expected_calibration_error_10bin": 0.0005000101111015919, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "K82": { + "valid": 2824, + "positives": 4, + "negatives": 2820, + "auroc": 0.587145390070922, + "auprc": 0.0036249336673070784, + "brier": 0.0014180428182462704, + "calibration": { + "observed_rate": 0.00141643059490085, + "mean_prediction": 0.0010193539987801647, + "calibration_in_the_large": -0.00039707659612068526, + "expected_calibration_error_10bin": 0.00039707659612068526, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K83": { + "valid": 2757, + "positives": 10, + "negatives": 2747, + "auroc": 0.8880232981434292, + "auprc": 0.11950345466068543, + "brier": 0.003605566109204643, + "calibration": { + "observed_rate": 0.003627130939426913, + "mean_prediction": 0.003796158232069249, + "calibration_in_the_large": 0.0001690272926423357, + "expected_calibration_error_10bin": 0.0015719597609047016, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + "K85": { + "valid": 2779, + "positives": 4, + "negatives": 2775, + "auroc": 0.8015315315315316, + "auprc": 0.02433958421581326, + "brier": 0.0014273417814045042, + "calibration": { + "observed_rate": 0.0014393666786613889, + "mean_prediction": 0.0018912756086815418, + "calibration_in_the_large": 0.0004519089300201529, + "expected_calibration_error_10bin": 0.0004519089300201529, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + "K86": { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.7053892831430628, + "auprc": 0.015984500997818486, + "brier": 0.0025074141831203122, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.0028725348955487015, + "calibration_in_the_large": 0.0003590699045253622, + "expected_calibration_error_10bin": 0.0003590699045253622, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K90": { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.6176678445229682, + "auprc": 0.0009233610341643582, + "brier": 0.00035531536720983766, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0006904732207626721, + "calibration_in_the_large": 0.0003372411472904008, + "expected_calibration_error_10bin": 0.0003372411472904008, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "K91": { + "valid": 2768, + "positives": 20, + "negatives": 2748, + "auroc": 0.8703966521106259, + "auprc": 0.06075879160452082, + "brier": 0.0069859351493600395, + "calibration": { + "observed_rate": 0.0072254335260115606, + "mean_prediction": 0.006637898663287376, + "calibration_in_the_large": -0.0005875348627241844, + "expected_calibration_error_10bin": 0.0009064581279828852, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "K92": { + "valid": 2751, + "positives": 29, + "negatives": 2722, + "auroc": 0.8671489016696649, + "auprc": 0.09080724707866174, + "brier": 0.010047747567520379, + "calibration": { + "observed_rate": 0.010541621228644129, + "mean_prediction": 0.009367133283406876, + "calibration_in_the_large": -0.0011744879452372532, + "expected_calibration_error_10bin": 0.0011744879452372516, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "K94": { + "valid": 2823, + "positives": 14, + "negatives": 2809, + "auroc": 0.900244113309261, + "auprc": 0.07614860117030935, + "brier": 0.004782548594550405, + "calibration": { + "observed_rate": 0.00495926319518243, + "mean_prediction": 0.004725418185362309, + "calibration_in_the_large": -0.00023384500982012116, + "expected_calibration_error_10bin": 0.0009788222981456645, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "L02": { + "valid": 2807, + "positives": 15, + "negatives": 2792, + "auroc": 0.776647564469914, + "auprc": 0.02291895307240848, + "brier": 0.0052814619308491845, + "calibration": { + "observed_rate": 0.005343783398646241, + "mean_prediction": 0.005726327517527409, + "calibration_in_the_large": 0.00038254411888116735, + "expected_calibration_error_10bin": 0.00038254411888116735, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "L03": { + "valid": 2701, + "positives": 35, + "negatives": 2666, + "auroc": 0.7408637873754153, + "auprc": 0.054525865808157534, + "brier": 0.012605361070988247, + "calibration": { + "observed_rate": 0.01295816364309515, + "mean_prediction": 0.008178856681606252, + "calibration_in_the_large": -0.004779306961488898, + "expected_calibration_error_10bin": 0.004781258522600721, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + "L08": { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.6664070796460178, + "auprc": 0.006754753539051013, + "brier": 0.001766228143686742, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.0014794669982797447, + "calibration_in_the_large": -0.00028731745401707506, + "expected_calibration_error_10bin": 0.00028731745401707506, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + "L27": { + "valid": 2818, + "positives": 8, + "negatives": 2810, + "auroc": 0.7711743772241992, + "auprc": 0.012965771072999191, + "brier": 0.003104182479214283, + "calibration": { + "observed_rate": 0.0028388928317956, + "mean_prediction": 0.0047469837979533455, + "calibration_in_the_large": 0.0019080909661577457, + "expected_calibration_error_10bin": 0.0019080909661577455, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "L29": { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.5670457237621417, + "auprc": 0.0028951089684812067, + "brier": 0.0011265903746145018, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.0037338600907248125, + "calibration_in_the_large": 0.002668897364420233, + "expected_calibration_error_10bin": 0.002668897364420233, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "L30": { + "valid": 2816, + "positives": 7, + "negatives": 2809, + "auroc": 0.700249199003204, + "auprc": 0.021108418266427276, + "brier": 0.002475485756776563, + "calibration": { + "observed_rate": 0.0024857954545454545, + "mean_prediction": 0.0020989374000738403, + "calibration_in_the_large": -0.0003868580544716142, + "expected_calibration_error_10bin": 0.0004608078291141735, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "L50": { + "valid": 2835, + "positives": 3, + "negatives": 2832, + "auroc": 0.7543549905838042, + "auprc": 0.010624761371227219, + "brier": 0.0010566702912991892, + "calibration": { + "observed_rate": 0.0010582010582010583, + "mean_prediction": 0.0010509087914316398, + "calibration_in_the_large": -7.29226676941851e-06, + "expected_calibration_error_10bin": 7.29226676941851e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + "L53": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 6.531562936809537e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001267790095363672, + "calibration_in_the_large": 0.001267790095363672, + "expected_calibration_error_10bin": 0.001267790095363672, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "L76": { + "valid": 2793, + "positives": 13, + "negatives": 2780, + "auroc": 0.6715273934698395, + "auprc": 0.008813044700681007, + "brier": 0.004660595730946544, + "calibration": { + "observed_rate": 0.004654493376297888, + "mean_prediction": 0.0050189586773114105, + "calibration_in_the_large": 0.0003644653010135227, + "expected_calibration_error_10bin": 0.0003644653010135227, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "L89": { + "valid": 2798, + "positives": 19, + "negatives": 2779, + "auroc": 0.8343402587072215, + "auprc": 0.02900226944851772, + "brier": 0.0067327081783548565, + "calibration": { + "observed_rate": 0.006790564689063617, + "mean_prediction": 0.005000976730664273, + "calibration_in_the_large": -0.0017895879583993439, + "expected_calibration_error_10bin": 0.0022390712712202043, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "L97": { + "valid": 2789, + "positives": 8, + "negatives": 2781, + "auroc": 0.8874056094929881, + "auprc": 0.05689693202021247, + "brier": 0.002890478760243847, + "calibration": { + "observed_rate": 0.0028684116170670493, + "mean_prediction": 0.004834943988437727, + "calibration_in_the_large": 0.0019665323713706777, + "expected_calibration_error_10bin": 0.001995892601043068, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "L98": { + "valid": 2824, + "positives": 5, + "negatives": 2819, + "auroc": 0.6542036183043632, + "auprc": 0.005474825659549564, + "brier": 0.0017896215296713523, + "calibration": { + "observed_rate": 0.0017705382436260624, + "mean_prediction": 0.003284492983060587, + "calibration_in_the_large": 0.0015139547394345245, + "expected_calibration_error_10bin": 0.0015139547394345245, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "M10": { + "valid": 2713, + "positives": 12, + "negatives": 2701, + "auroc": 0.783290139454523, + "auprc": 0.03949239500097829, + "brier": 0.004359130511528372, + "calibration": { + "observed_rate": 0.0044231478068558795, + "mean_prediction": 0.004867113577177182, + "calibration_in_the_large": 0.00044396577032130256, + "expected_calibration_error_10bin": 0.00044396577032130267, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + "M16": { + "valid": 2790, + "positives": 2, + "negatives": 2788, + "auroc": 0.9029770444763271, + "auprc": 0.01243279569892473, + "brier": 0.0007155508127535429, + "calibration": { + "observed_rate": 0.0007168458781362007, + "mean_prediction": 0.0012304203219427627, + "calibration_in_the_large": 0.000513574443806562, + "expected_calibration_error_10bin": 0.000513574443806562, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "M17": { + "valid": 2733, + "positives": 9, + "negatives": 2724, + "auroc": 0.7538750203948442, + "auprc": 0.008680624810548343, + "brier": 0.0033023370644669568, + "calibration": { + "observed_rate": 0.003293084522502744, + "mean_prediction": 0.00238455730021605, + "calibration_in_the_large": -0.0009085272222866939, + "expected_calibration_error_10bin": 0.0009085272222866939, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "M19": { + "valid": 2674, + "positives": 30, + "negatives": 2644, + "auroc": 0.7257690368129097, + "auprc": 0.03264504983860337, + "brier": 0.011024405794396546, + "calibration": { + "observed_rate": 0.011219147344801795, + "mean_prediction": 0.010352444389045954, + "calibration_in_the_large": -0.0008667029557558412, + "expected_calibration_error_10bin": 0.001349762095487241, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + "M21": { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.9765957446808511, + "auprc": 0.014925373134328358, + "brier": 0.0003564651285277428, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0014179199004096571, + "calibration_in_the_large": 0.0010634356749576897, + "expected_calibration_error_10bin": 0.0010634356749576897, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "M25": { + "valid": 2717, + "positives": 28, + "negatives": 2689, + "auroc": 0.6185650533921266, + "auprc": 0.01650379762057335, + "brier": 0.010264077076901853, + "calibration": { + "observed_rate": 0.010305483989694516, + "mean_prediction": 0.010671942695226509, + "calibration_in_the_large": 0.00036645870553199227, + "expected_calibration_error_10bin": 0.00036645870553199465, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + "M35": { + "valid": 2806, + "positives": 1, + "negatives": 2805, + "auroc": 0.8809269162210339, + "auprc": 0.0029850746268656717, + "brier": 0.000360466960433347, + "calibration": { + "observed_rate": 0.0003563791874554526, + "mean_prediction": 0.0008490360654150371, + "calibration_in_the_large": 0.0004926568779595844, + "expected_calibration_error_10bin": 0.0004926568779595844, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "M46": { + "valid": 2814, + "positives": 4, + "negatives": 2810, + "auroc": 0.6194839857651245, + "auprc": 0.002378685375760999, + "brier": 0.001426579172208385, + "calibration": { + "observed_rate": 0.0014214641080312722, + "mean_prediction": 0.0019045823105498505, + "calibration_in_the_large": 0.00048311820251857834, + "expected_calibration_error_10bin": 0.00048311820251857834, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "M47": { + "valid": 2743, + "positives": 7, + "negatives": 2736, + "auroc": 0.7799707602339181, + "auprc": 0.020072611299073444, + "brier": 0.0025341656008012817, + "calibration": { + "observed_rate": 0.0025519504192489974, + "mean_prediction": 0.0022056704686266313, + "calibration_in_the_large": -0.0003462799506223661, + "expected_calibration_error_10bin": 0.0003462799506223661, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "M48": { + "valid": 2690, + "positives": 10, + "negatives": 2680, + "auroc": 0.7644029850746269, + "auprc": 0.014551133851867631, + "brier": 0.0037103467012400363, + "calibration": { + "observed_rate": 0.0037174721189591076, + "mean_prediction": 0.004981480412059472, + "calibration_in_the_large": 0.0012640082931003648, + "expected_calibration_error_10bin": 0.0012640082931003648, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + "M51": { + "valid": 2785, + "positives": 2, + "negatives": 2783, + "auroc": 0.948796263025512, + "auprc": 0.012489294890094205, + "brier": 0.000718663881521959, + "calibration": { + "observed_rate": 0.000718132854578097, + "mean_prediction": 0.002426440435963519, + "calibration_in_the_large": 0.001708307581385422, + "expected_calibration_error_10bin": 0.001708307581385422, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "M54": { + "valid": 2567, + "positives": 35, + "negatives": 2532, + "auroc": 0.6988038817422704, + "auprc": 0.038569033510933486, + "brier": 0.013390878568806363, + "calibration": { + "observed_rate": 0.013634592910011687, + "mean_prediction": 0.013555466098611848, + "calibration_in_the_large": -7.912681139983849e-05, + "expected_calibration_error_10bin": 0.00037723597672263226, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + "M62": { + "valid": 2781, + "positives": 8, + "negatives": 2773, + "auroc": 0.758294266137757, + "auprc": 0.014755110723462299, + "brier": 0.002858605489292015, + "calibration": { + "observed_rate": 0.002876663070837828, + "mean_prediction": 0.003060683144633389, + "calibration_in_the_large": 0.00018402007379556082, + "expected_calibration_error_10bin": 0.00018402007379556082, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "M79": { + "valid": 2697, + "positives": 29, + "negatives": 2668, + "auroc": 0.7751641420668975, + "auprc": 0.036355069999908084, + "brier": 0.01062373417451454, + "calibration": { + "observed_rate": 0.010752688172043012, + "mean_prediction": 0.012712463679729311, + "calibration_in_the_large": 0.0019597755076862997, + "expected_calibration_error_10bin": 0.0019597755076863023, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + "M81": { + "valid": 2705, + "positives": 11, + "negatives": 2694, + "auroc": 0.8339407437402983, + "auprc": 0.05498921819505516, + "brier": 0.003971407463864611, + "calibration": { + "observed_rate": 0.004066543438077634, + "mean_prediction": 0.004259567634020869, + "calibration_in_the_large": 0.00019302419594323557, + "expected_calibration_error_10bin": 0.000610021316624591, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + "M84": { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.7416281549946676, + "auprc": 0.02379354699255837, + "brier": 0.0017739218908973408, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0024851092548952695, + "calibration_in_the_large": 0.0007108012350230198, + "expected_calibration_error_10bin": 0.0007108012350230197, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "M85": { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.7224090650385471, + "auprc": 0.0065093691530870535, + "brier": 0.002532814930987721, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.002794829646000504, + "calibration_in_the_large": 0.00026592791189645765, + "expected_calibration_error_10bin": 0.00026592791189645765, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "M86": { + "valid": 2803, + "positives": 14, + "negatives": 2789, + "auroc": 0.7891205245095528, + "auprc": 0.05140183237955642, + "brier": 0.004891697633229847, + "calibration": { + "observed_rate": 0.0049946485907955765, + "mean_prediction": 0.0033390657207585436, + "calibration_in_the_large": -0.001655582870037033, + "expected_calibration_error_10bin": 0.0019604187687184394, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + "M94": { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7505918560606061, + "auprc": 0.003019398264928181, + "brier": 0.0010638034579157562, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0003301835473108816, + "calibration_in_the_large": -0.0007340236183507004, + "expected_calibration_error_10bin": 0.0007340236183507004, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "M96": { + "valid": 2804, + "positives": 2, + "negatives": 2802, + "auroc": 0.8313704496788008, + "auprc": 0.0031294007197621657, + "brier": 0.0007293787152951534, + "calibration": { + "observed_rate": 0.0007132667617689016, + "mean_prediction": 0.0028586021128878913, + "calibration_in_the_large": 0.0021453353511189897, + "expected_calibration_error_10bin": 0.0021453353511189897, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "N12": { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.6695669769324161, + "auprc": 0.006113077693427961, + "brier": 0.0024748311718258463, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.0016197120779478417, + "calibration_in_the_large": -0.0008529124363580575, + "expected_calibration_error_10bin": 0.0008529124363580575, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N13": { + "valid": 2756, + "positives": 11, + "negatives": 2745, + "auroc": 0.6451730418943533, + "auprc": 0.012390827381300023, + "brier": 0.003986379906938797, + "calibration": { + "observed_rate": 0.0039912917271407835, + "mean_prediction": 0.004326352771341274, + "calibration_in_the_large": 0.0003350610442004907, + "expected_calibration_error_10bin": 0.0003350610442004907, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "N14": { + "valid": 2826, + "positives": 7, + "negatives": 2819, + "auroc": 0.874018142198348, + "auprc": 0.018023562455436796, + "brier": 0.002463537751002852, + "calibration": { + "observed_rate": 0.0024769992922859165, + "mean_prediction": 0.001275928724620992, + "calibration_in_the_large": -0.0012010705676649244, + "expected_calibration_error_10bin": 0.0012010705676649244, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "N17": { + "valid": 2292, + "positives": 77, + "negatives": 2215, + "auroc": 0.7937791328310516, + "auprc": 0.1352482134178894, + "brier": 0.03121057686318479, + "calibration": { + "observed_rate": 0.033595113438045374, + "mean_prediction": 0.036707868010919444, + "calibration_in_the_large": 0.00311275457287407, + "expected_calibration_error_10bin": 0.006820258746574995, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + "N18": { + "valid": 2440, + "positives": 37, + "negatives": 2403, + "auroc": 0.8542137643261238, + "auprc": 0.1534789970771147, + "brier": 0.01401930240272255, + "calibration": { + "observed_rate": 0.015163934426229509, + "mean_prediction": 0.01003506200569794, + "calibration_in_the_large": -0.005128872420531569, + "expected_calibration_error_10bin": 0.005128872420531569, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + "N20": { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7401715511079342, + "auprc": 0.006334972688749638, + "brier": 0.00284629626960655, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.001000026361283393, + "calibration_in_the_large": -0.001851007138360228, + "expected_calibration_error_10bin": 0.001851007138360228, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "N25": { + "valid": 2831, + "positives": 6, + "negatives": 2825, + "auroc": 0.9596460176991151, + "auprc": 0.09735366702023245, + "brier": 0.0020721999756335417, + "calibration": { + "observed_rate": 0.0021193924408336277, + "mean_prediction": 0.0010794925622103337, + "calibration_in_the_large": -0.001039899878623294, + "expected_calibration_error_10bin": 0.0011227345862654344, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N28": { + "valid": 2789, + "positives": 5, + "negatives": 2784, + "auroc": 0.816235632183908, + "auprc": 0.010471497429726005, + "brier": 0.0018009781345909137, + "calibration": { + "observed_rate": 0.0017927572606669057, + "mean_prediction": 0.0039818026103464925, + "calibration_in_the_large": 0.002189045349679587, + "expected_calibration_error_10bin": 0.002189045349679587, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "N30": { + "valid": 2829, + "positives": 9, + "negatives": 2820, + "auroc": 0.6765169424743893, + "auprc": 0.009475739921232407, + "brier": 0.003198671780612835, + "calibration": { + "observed_rate": 0.003181336161187699, + "mean_prediction": 0.003134515740616929, + "calibration_in_the_large": -4.6820420570769985e-05, + "expected_calibration_error_10bin": 0.00015417245215852387, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N32": { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.8003575259206293, + "auprc": 0.13097391427202176, + "brier": 0.0034572685368070765, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.003820866062293633, + "calibration_in_the_large": 0.000258343796529472, + "expected_calibration_error_10bin": 0.0008963858041279681, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "N39": { + "valid": 2520, + "positives": 71, + "negatives": 2449, + "auroc": 0.7595914400243847, + "auprc": 0.08334993816833387, + "brier": 0.026826193374325808, + "calibration": { + "observed_rate": 0.028174603174603175, + "mean_prediction": 0.03148060376808557, + "calibration_in_the_large": 0.003306000593482395, + "expected_calibration_error_10bin": 0.003306000593482398, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + "N40": { + "valid": 2606, + "positives": 16, + "negatives": 2590, + "auroc": 0.7714527027027027, + "auprc": 0.03108244035599339, + "brier": 0.006117764327407734, + "calibration": { + "observed_rate": 0.0061396776669224865, + "mean_prediction": 0.008714471731099011, + "calibration_in_the_large": 0.0025747940641765244, + "expected_calibration_error_10bin": 0.002574794064176526, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + "N73": { + "valid": 2829, + "positives": 3, + "negatives": 2826, + "auroc": 0.9608398207124321, + "auprc": 0.038342712126227516, + "brier": 0.0010489008611219786, + "calibration": { + "observed_rate": 0.0010604453870625664, + "mean_prediction": 0.0009488924912202897, + "calibration_in_the_large": -0.00011155289584227667, + "expected_calibration_error_10bin": 0.00011155289584227667, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N99": { + "valid": 2799, + "positives": 5, + "negatives": 2794, + "auroc": 0.7690050107372942, + "auprc": 0.00959871479742686, + "brier": 0.0017811875691056138, + "calibration": { + "observed_rate": 0.0017863522686673813, + "mean_prediction": 0.0015660061798773912, + "calibration_in_the_large": -0.00022034608878999007, + "expected_calibration_error_10bin": 0.00022034608878999007, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + "O69": { + "valid": 2743, + "positives": 6, + "negatives": 2737, + "auroc": 0.9963463646328097, + "auprc": 0.34354331305550817, + "brier": 0.0020456422513317183, + "calibration": { + "observed_rate": 0.002187386073641998, + "mean_prediction": 0.00042781450472833974, + "calibration_in_the_large": -0.001759571568913658, + "expected_calibration_error_10bin": 0.001952528394699168, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "O99": { + "valid": 2652, + "positives": 1, + "negatives": 2651, + "auroc": 0.999622783855149, + "auprc": 0.5, + "brier": 0.0002424942508792222, + "calibration": { + "observed_rate": 0.0003770739064856712, + "mean_prediction": 0.0004393379524449908, + "calibration_in_the_large": 6.22640459593196e-05, + "expected_calibration_error_10bin": 0.00042846209384251016, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + "Q21": { + "valid": 2810, + "positives": 3, + "negatives": 2807, + "auroc": 0.5824723904524404, + "auprc": 0.0030388561298494154, + "brier": 0.001066915397400567, + "calibration": { + "observed_rate": 0.0010676156583629894, + "mean_prediction": 0.0010593660122305204, + "calibration_in_the_large": -8.24964613246903e-06, + "expected_calibration_error_10bin": 8.24964613246903e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "U07": { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 3.422549987073976e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0028817143641582106, + "calibration_in_the_large": 0.0028817143641582106, + "expected_calibration_error_10bin": 0.002881714364158211, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + } + }, + "240": { + "A04": { + "valid": 2782, + "positives": 23, + "negatives": 2759, + "auroc": 0.7615865861922246, + "auprc": 0.053841441288056145, + "brier": 0.008098206422744636, + "calibration": { + "observed_rate": 0.00826743350107836, + "mean_prediction": 0.00862765540020697, + "calibration_in_the_large": 0.0003602218991286092, + "expected_calibration_error_10bin": 0.0003602218991286102, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "A08": { + "valid": 2818, + "positives": 11, + "negatives": 2807, + "auroc": 0.8119312109337047, + "auprc": 0.028482835344447566, + "brier": 0.003850775571252781, + "calibration": { + "observed_rate": 0.0039034776437189495, + "mean_prediction": 0.0040465304782673845, + "calibration_in_the_large": 0.00014305283454843498, + "expected_calibration_error_10bin": 0.00014305283454843536, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "A41": { + "valid": 2664, + "positives": 57, + "negatives": 2607, + "auroc": 0.7430736411415958, + "auprc": 0.06597026862528749, + "brier": 0.02090204554801041, + "calibration": { + "observed_rate": 0.021396396396396396, + "mean_prediction": 0.024816042912390514, + "calibration_in_the_large": 0.0034196465159941174, + "expected_calibration_error_10bin": 0.004283507107480851, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + "B00": { + "valid": 2819, + "positives": 4, + "negatives": 2815, + "auroc": 0.66651865008881, + "auprc": 0.01533317340590082, + "brier": 0.0014510275841539408, + "calibration": { + "observed_rate": 0.001418942887548776, + "mean_prediction": 0.0016043991954288036, + "calibration_in_the_large": 0.00018545630788002754, + "expected_calibration_error_10bin": 0.0004010138840528729, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "B02": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.8043862752033958, + "auprc": 0.0018050541516245488, + "brier": 0.00035670438074149167, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0008010678431167176, + "calibration_in_the_large": 0.000447461053866364, + "expected_calibration_error_10bin": 0.000447461053866364, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "B18": { + "valid": 2782, + "positives": 5, + "negatives": 2777, + "auroc": 0.9684551674468851, + "auprc": 0.09101977351405269, + "brier": 0.0017300554435452232, + "calibration": { + "observed_rate": 0.0017972681524083393, + "mean_prediction": 0.0011699593466286586, + "calibration_in_the_large": -0.0006273088057796806, + "expected_calibration_error_10bin": 0.0006992474180590858, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "B19": { + "valid": 2763, + "positives": 17, + "negatives": 2746, + "auroc": 0.8584250888993616, + "auprc": 0.07575733031784426, + "brier": 0.006010204540888551, + "calibration": { + "observed_rate": 0.006152732537097358, + "mean_prediction": 0.0017787006115917536, + "calibration_in_the_large": -0.004374031925505605, + "expected_calibration_error_10bin": 0.004582003295773247, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "B20": { + "valid": 2829, + "positives": 5, + "negatives": 2824, + "auroc": 0.988314447592068, + "auprc": 0.24384719405003383, + "brier": 0.0017379563017631793, + "calibration": { + "observed_rate": 0.0017674089784376105, + "mean_prediction": 0.0002621402547964798, + "calibration_in_the_large": -0.0015052687236411307, + "expected_calibration_error_10bin": 0.0015781491653057685, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "B34": { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.9787685774946921, + "auprc": 0.11288164162306039, + "brier": 0.0017143575684716345, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0012575582422926874, + "calibration_in_the_large": -0.0005086021250686689, + "expected_calibration_error_10bin": 0.0005086021250686689, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "B35": { + "valid": 2836, + "positives": 1, + "negatives": 2835, + "auroc": 0.7714285714285715, + "auprc": 0.0015408320493066256, + "brier": 0.00036417821407595363, + "calibration": { + "observed_rate": 0.0003526093088857546, + "mean_prediction": 0.0015947904666318824, + "calibration_in_the_large": 0.001242181157746128, + "expected_calibration_error_10bin": 0.001242181157746128, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "B37": { + "valid": 2768, + "positives": 31, + "negatives": 2737, + "auroc": 0.7617594022181102, + "auprc": 0.03774637866000645, + "brier": 0.011017785462714882, + "calibration": { + "observed_rate": 0.011199421965317919, + "mean_prediction": 0.009203197468369355, + "calibration_in_the_large": -0.0019962244969485635, + "expected_calibration_error_10bin": 0.003938571543044076, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "B95": { + "valid": 2678, + "positives": 54, + "negatives": 2624, + "auroc": 0.7133440605239386, + "auprc": 0.04365709260115959, + "brier": 0.019868342173302543, + "calibration": { + "observed_rate": 0.020164301717699777, + "mean_prediction": 0.02163987572206573, + "calibration_in_the_large": 0.0014755740043659524, + "expected_calibration_error_10bin": 0.0051362357700104125, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + "B96": { + "valid": 2630, + "positives": 72, + "negatives": 2558, + "auroc": 0.7645893058813309, + "auprc": 0.09077193630238753, + "brier": 0.025945022310605862, + "calibration": { + "observed_rate": 0.02737642585551331, + "mean_prediction": 0.029572645436349135, + "calibration_in_the_large": 0.0021962195808358266, + "expected_calibration_error_10bin": 0.002296437516086116, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + "B97": { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.8782731776362349, + "auprc": 0.05146842878120411, + "brier": 0.0007047998568648126, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0008226118942005703, + "calibration_in_the_large": 0.00011539831569986302, + "expected_calibration_error_10bin": 0.00011539831569986312, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "C18": { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9780297661233168, + "auprc": 0.03557504873294347, + "brier": 0.0007028030286083171, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0006083776093809804, + "calibration_in_the_large": -9.98376880694446e-05, + "expected_calibration_error_10bin": 9.98376880694446e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "C22": { + "valid": 2812, + "positives": 6, + "negatives": 2806, + "auroc": 0.909895462105013, + "auprc": 0.05428640511163848, + "brier": 0.0020981081792812435, + "calibration": { + "observed_rate": 0.0021337126600284497, + "mean_prediction": 0.0007656151551714498, + "calibration_in_the_large": -0.001368097504857, + "expected_calibration_error_10bin": 0.001368097504857, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + "C25": { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.9419308870680442, + "auprc": 0.16973415132924335, + "brier": 0.0006819223110387211, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0005407443724165018, + "calibration_in_the_large": -0.00017125277959489016, + "expected_calibration_error_10bin": 0.0002761262078241845, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "C61": { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9671780235462005, + "auprc": 0.017450458444247263, + "brier": 0.0007115598967927753, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0010146582764448174, + "calibration_in_the_large": 0.0003016457987264574, + "expected_calibration_error_10bin": 0.0003016457987264574, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "C67": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9517155995755218, + "auprc": 0.02890625, + "brier": 0.000703414552842913, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0007255357906926125, + "calibration_in_the_large": 1.857219931756832e-05, + "expected_calibration_error_10bin": 1.857219931756832e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "C77": { + "valid": 2762, + "positives": 20, + "negatives": 2742, + "auroc": 0.8652990517870168, + "auprc": 0.13727957784476147, + "brier": 0.00681339071200404, + "calibration": { + "observed_rate": 0.00724112961622013, + "mean_prediction": 0.003946618014080588, + "calibration_in_the_large": -0.003294511602139542, + "expected_calibration_error_10bin": 0.004003116425724378, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C78": { + "valid": 2762, + "positives": 25, + "negatives": 2737, + "auroc": 0.8639824625502375, + "auprc": 0.13397624192252688, + "brier": 0.008493397097069718, + "calibration": { + "observed_rate": 0.009051412020275163, + "mean_prediction": 0.006035030109147776, + "calibration_in_the_large": -0.0030163819111273873, + "expected_calibration_error_10bin": 0.004589912502714713, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C79": { + "valid": 2751, + "positives": 20, + "negatives": 2731, + "auroc": 0.8758879531307213, + "auprc": 0.13987392279243738, + "brier": 0.0076812530406336465, + "calibration": { + "observed_rate": 0.007270083605961469, + "mean_prediction": 0.008371310684169502, + "calibration_in_the_large": 0.0011012270782080336, + "expected_calibration_error_10bin": 0.004218063410522827, + "nonempty_bins": 8 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "C83": { + "valid": 2820, + "positives": 0, + "negatives": 2820, + "auroc": null, + "auprc": null, + "brier": 1.693479757208866e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004831406754132692, + "calibration_in_the_large": 0.0004831406754132692, + "expected_calibration_error_10bin": 0.0004831406754132692, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "D25": { + "valid": 2792, + "positives": 3, + "negatives": 2789, + "auroc": 0.9602007888131947, + "auprc": 0.6696428571428572, + "brier": 0.0010538583273237967, + "calibration": { + "observed_rate": 0.0010744985673352436, + "mean_prediction": 0.000459370656666094, + "calibration_in_the_large": -0.0006151279106691495, + "expected_calibration_error_10bin": 0.0006151279106691495, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "D47": { + "valid": 2796, + "positives": 9, + "negatives": 2787, + "auroc": 0.6797033847625882, + "auprc": 0.006649186974707509, + "brier": 0.003303255167097043, + "calibration": { + "observed_rate": 0.003218884120171674, + "mean_prediction": 0.0047922575759315215, + "calibration_in_the_large": 0.0015733734557598477, + "expected_calibration_error_10bin": 0.0015733734557598475, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "D50": { + "valid": 2663, + "positives": 46, + "negatives": 2617, + "auroc": 0.7925686564436544, + "auprc": 0.09492117530811735, + "brier": 0.016297046267587934, + "calibration": { + "observed_rate": 0.017273751408186256, + "mean_prediction": 0.014754110174038064, + "calibration_in_the_large": -0.0025196412341481917, + "expected_calibration_error_10bin": 0.0026777626762983764, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + "D53": { + "valid": 2805, + "positives": 14, + "negatives": 2791, + "auroc": 0.8205968162972821, + "auprc": 0.02630752220652523, + "brier": 0.005055602426654589, + "calibration": { + "observed_rate": 0.004991087344028521, + "mean_prediction": 0.005810619733955866, + "calibration_in_the_large": 0.0008195323899273452, + "expected_calibration_error_10bin": 0.0008957698383627842, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "D59": { + "valid": 2836, + "positives": 1, + "negatives": 2835, + "auroc": 0.9763668430335097, + "auprc": 0.014705882352941176, + "brier": 0.00035319185354031914, + "calibration": { + "observed_rate": 0.0003526093088857546, + "mean_prediction": 0.0007462576745990982, + "calibration_in_the_large": 0.00039364836571334364, + "expected_calibration_error_10bin": 0.00039364836571334364, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "D61": { + "valid": 2773, + "positives": 32, + "negatives": 2741, + "auroc": 0.8997400583728566, + "auprc": 0.21681384946879242, + "brier": 0.010031479641218987, + "calibration": { + "observed_rate": 0.01153984853948792, + "mean_prediction": 0.009703000189376577, + "calibration_in_the_large": -0.001836848350111343, + "expected_calibration_error_10bin": 0.003115621423877964, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "D62": { + "valid": 2499, + "positives": 60, + "negatives": 2439, + "auroc": 0.796972803061364, + "auprc": 0.07179254963386278, + "brier": 0.022908080816770617, + "calibration": { + "observed_rate": 0.024009603841536616, + "mean_prediction": 0.022244573790062384, + "calibration_in_the_large": -0.001765030051474232, + "expected_calibration_error_10bin": 0.005477185223802025, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + "D63": { + "valid": 2686, + "positives": 68, + "negatives": 2618, + "auroc": 0.8594290657439446, + "auprc": 0.1336740856417583, + "brier": 0.023579200903332646, + "calibration": { + "observed_rate": 0.02531645569620253, + "mean_prediction": 0.022333721347493504, + "calibration_in_the_large": -0.0029827343487090277, + "expected_calibration_error_10bin": 0.00930453148084604, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + "D64": { + "valid": 2434, + "positives": 103, + "negatives": 2331, + "auroc": 0.8044507753245618, + "auprc": 0.18420436149644753, + "brier": 0.037618141786084115, + "calibration": { + "observed_rate": 0.042317173377156944, + "mean_prediction": 0.044114195109511846, + "calibration_in_the_large": 0.0017970217323549018, + "expected_calibration_error_10bin": 0.004152815662620586, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + "D65": { + "valid": 2833, + "positives": 3, + "negatives": 2830, + "auroc": 0.9607773851590106, + "auprc": 0.01725537534066234, + "brier": 0.0010596643758331139, + "calibration": { + "observed_rate": 0.0010589481115425344, + "mean_prediction": 0.0009650031250349421, + "calibration_in_the_large": -9.39449865075923e-05, + "expected_calibration_error_10bin": 9.39449865075923e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + "D68": { + "valid": 2682, + "positives": 51, + "negatives": 2631, + "auroc": 0.818096451807633, + "auprc": 0.12077919920882345, + "brier": 0.017933951826780637, + "calibration": { + "observed_rate": 0.01901565995525727, + "mean_prediction": 0.011816600237909747, + "calibration_in_the_large": -0.007199059717347522, + "expected_calibration_error_10bin": 0.008752716977153501, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + "D69": { + "valid": 2586, + "positives": 71, + "negatives": 2515, + "auroc": 0.841351888667992, + "auprc": 0.2485969661107862, + "brier": 0.023379949743847668, + "calibration": { + "observed_rate": 0.02745552977571539, + "mean_prediction": 0.019952139989347778, + "calibration_in_the_large": -0.007503389786367613, + "expected_calibration_error_10bin": 0.008705697329915671, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + "D70": { + "valid": 2787, + "positives": 26, + "negatives": 2761, + "auroc": 0.9040481430919678, + "auprc": 0.24951643911625548, + "brier": 0.00869009780334189, + "calibration": { + "observed_rate": 0.009329027628274129, + "mean_prediction": 0.008131508944788321, + "calibration_in_the_large": -0.0011975186834858077, + "expected_calibration_error_10bin": 0.006475545052482791, + "nonempty_bins": 9 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "D72": { + "valid": 2595, + "positives": 54, + "negatives": 2541, + "auroc": 0.7086376025769965, + "auprc": 0.056907575329799454, + "brier": 0.020143279314557536, + "calibration": { + "observed_rate": 0.020809248554913295, + "mean_prediction": 0.022075911050057666, + "calibration_in_the_large": 0.0012666624951443717, + "expected_calibration_error_10bin": 0.0012666624951443728, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + "D73": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.8278388278388278, + "auprc": 0.02140296979006656, + "brier": 0.0010753914995077077, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.001372468764040821, + "calibration_in_the_large": 0.0003101458178651835, + "expected_calibration_error_10bin": 0.00031014581786518357, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "D75": { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.8775203395825963, + "auprc": 0.006783365410193484, + "brier": 0.001413920810620539, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0012903563768506025, + "calibration_in_the_large": -0.00012257191703848262, + "expected_calibration_error_10bin": 0.00012257191703848262, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "D80": { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.9882047652748289, + "auprc": 0.09534818055616018, + "brier": 0.002077267889207908, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.0016640906410812202, + "calibration_in_the_large": -0.0004545534267153899, + "expected_calibration_error_10bin": 0.0012653690216374047, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "D89": { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.845679012345679, + "auprc": 0.007353842382644932, + "brier": 0.0008583869392550051, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0009765297007024641, + "calibration_in_the_large": 0.000271559661929112, + "expected_calibration_error_10bin": 0.0008698598889114494, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "E03": { + "valid": 2480, + "positives": 21, + "negatives": 2459, + "auroc": 0.7313464629446736, + "auprc": 0.024426723819249714, + "brier": 0.00835623662781612, + "calibration": { + "observed_rate": 0.008467741935483872, + "mean_prediction": 0.005416642695044791, + "calibration_in_the_large": -0.003051099240439081, + "expected_calibration_error_10bin": 0.003051099240439081, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + "E04": { + "valid": 2775, + "positives": 9, + "negatives": 2766, + "auroc": 0.7660882140274765, + "auprc": 0.009864133739414742, + "brier": 0.0032370783254810523, + "calibration": { + "observed_rate": 0.003243243243243243, + "mean_prediction": 0.003148352715647192, + "calibration_in_the_large": -9.489052759605087e-05, + "expected_calibration_error_10bin": 9.489052759605087e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "E05": { + "valid": 2806, + "positives": 3, + "negatives": 2803, + "auroc": 0.2968248305387085, + "auprc": 0.0009990064494525871, + "brier": 0.0010718948190053797, + "calibration": { + "observed_rate": 0.0010691375623663579, + "mean_prediction": 0.0011724467880975383, + "calibration_in_the_large": 0.00010330922573118049, + "expected_calibration_error_10bin": 0.00010330922573118049, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "E11": { + "valid": 2194, + "positives": 19, + "negatives": 2175, + "auroc": 0.8050090744101633, + "auprc": 0.06156459630011027, + "brier": 0.008435705332759084, + "calibration": { + "observed_rate": 0.008659981768459436, + "mean_prediction": 0.006864799139701514, + "calibration_in_the_large": -0.0017951826287579218, + "expected_calibration_error_10bin": 0.0019116463691710684, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + "E16": { + "valid": 2816, + "positives": 7, + "negatives": 2809, + "auroc": 0.6833138381732188, + "auprc": 0.0076116853926925035, + "brier": 0.002486586329540309, + "calibration": { + "observed_rate": 0.0024857954545454545, + "mean_prediction": 0.0025853494831616012, + "calibration_in_the_large": 9.955402861614674e-05, + "expected_calibration_error_10bin": 9.955402861614674e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "E21": { + "valid": 2814, + "positives": 2, + "negatives": 2812, + "auroc": 0.9160739687055477, + "auprc": 0.0107429718875502, + "brier": 0.0007300006156526901, + "calibration": { + "observed_rate": 0.0007107320540156361, + "mean_prediction": 0.0016448928586360048, + "calibration_in_the_large": 0.0009341608046203687, + "expected_calibration_error_10bin": 0.0009341608046203687, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "E22": { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.8187930142817361, + "auprc": 0.018210086590356032, + "brier": 0.0032439172765495444, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.005409274334973339, + "calibration_in_the_large": 0.002197282900283832, + "expected_calibration_error_10bin": 0.0021972829002838315, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "E27": { + "valid": 2811, + "positives": 6, + "negatives": 2805, + "auroc": 0.7929887106357695, + "auprc": 0.006557955548116318, + "brier": 0.002146183964056934, + "calibration": { + "observed_rate": 0.0021344717182497333, + "mean_prediction": 0.0022338608694460658, + "calibration_in_the_large": 9.938915119633244e-05, + "expected_calibration_error_10bin": 9.938915119633244e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + }, + "E43": { + "valid": 2748, + "positives": 34, + "negatives": 2714, + "auroc": 0.8208526594130652, + "auprc": 0.07156333826529356, + "brier": 0.01202183691966258, + "calibration": { + "observed_rate": 0.012372634643377001, + "mean_prediction": 0.013609187422145116, + "calibration_in_the_large": 0.0012365527787681144, + "expected_calibration_error_10bin": 0.0014774441382412384, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + "E44": { + "valid": 2800, + "positives": 19, + "negatives": 2781, + "auroc": 0.790173924563296, + "auprc": 0.024139358681949635, + "brier": 0.006821435864817865, + "calibration": { + "observed_rate": 0.0067857142857142855, + "mean_prediction": 0.008855501115826232, + "calibration_in_the_large": 0.0020697868301119467, + "expected_calibration_error_10bin": 0.002069786830111947, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "E46": { + "valid": 2772, + "positives": 33, + "negatives": 2739, + "auroc": 0.816832066558244, + "auprc": 0.07831212013405782, + "brier": 0.011495305335927936, + "calibration": { + "observed_rate": 0.011904761904761904, + "mean_prediction": 0.013042954502216398, + "calibration_in_the_large": 0.0011381925974544935, + "expected_calibration_error_10bin": 0.0011381925974544929, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + "E53": { + "valid": 2804, + "positives": 6, + "negatives": 2798, + "auroc": 0.6374195854181558, + "auprc": 0.004070958237801782, + "brier": 0.00216115379241538, + "calibration": { + "observed_rate": 0.0021398002853067048, + "mean_prediction": 0.002668647942390117, + "calibration_in_the_large": 0.0005288476570834122, + "expected_calibration_error_10bin": 0.0005288476570834122, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "E55": { + "valid": 2737, + "positives": 25, + "negatives": 2712, + "auroc": 0.5960324483775811, + "auprc": 0.01321778195475651, + "brier": 0.009232652144228441, + "calibration": { + "observed_rate": 0.009134088417975887, + "mean_prediction": 0.010465952659033955, + "calibration_in_the_large": 0.001331864241058068, + "expected_calibration_error_10bin": 0.001331864241058068, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + "E66": { + "valid": 2371, + "positives": 34, + "negatives": 2337, + "auroc": 0.7460167635732085, + "auprc": 0.050252539979273654, + "brier": 0.01394500317707135, + "calibration": { + "observed_rate": 0.01433994095318431, + "mean_prediction": 0.01341995093812899, + "calibration_in_the_large": -0.0009199900150553206, + "expected_calibration_error_10bin": 0.0022294513693596665, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + "E78": { + "valid": 1572, + "positives": 38, + "negatives": 1534, + "auroc": 0.7345261785493721, + "auprc": 0.10496553493953245, + "brier": 0.023652899426652337, + "calibration": { + "observed_rate": 0.024173027989821884, + "mean_prediction": 0.027298656317938454, + "calibration_in_the_large": 0.0031256283281165705, + "expected_calibration_error_10bin": 0.009812374559380548, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + "E80": { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.8756951840018933, + "auprc": 0.02273343117038218, + "brier": 0.0021426056982918264, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0020838136058835078, + "calibration_in_the_large": -4.158490633753356e-05, + "expected_calibration_error_10bin": 0.0004806091196497321, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "E83": { + "valid": 2653, + "positives": 70, + "negatives": 2583, + "auroc": 0.812875394060063, + "auprc": 0.18937389549287464, + "brier": 0.023538920398255364, + "calibration": { + "observed_rate": 0.026385224274406333, + "mean_prediction": 0.020702527809592895, + "calibration_in_the_large": -0.005682696464813439, + "expected_calibration_error_10bin": 0.006069085225885923, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + "E86": { + "valid": 2587, + "positives": 82, + "negatives": 2505, + "auroc": 0.7808237184168249, + "auprc": 0.10490399460732781, + "brier": 0.029857369511412955, + "calibration": { + "observed_rate": 0.031696946269810594, + "mean_prediction": 0.0382368518707836, + "calibration_in_the_large": 0.006539905600973006, + "expected_calibration_error_10bin": 0.0065399056009730104, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + "E87": { + "valid": 2185, + "positives": 129, + "negatives": 2056, + "auroc": 0.788635266793352, + "auprc": 0.20524392878733444, + "brier": 0.05129531373364515, + "calibration": { + "observed_rate": 0.059038901601830666, + "mean_prediction": 0.04882184376991279, + "calibration_in_the_large": -0.010217057831917876, + "expected_calibration_error_10bin": 0.013079713675613329, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + "E88": { + "valid": 2817, + "positives": 11, + "negatives": 2806, + "auroc": 0.8242078662606104, + "auprc": 0.082229718722242, + "brier": 0.0037865124077872524, + "calibration": { + "observed_rate": 0.0039048633297834577, + "mean_prediction": 0.0033026007992496636, + "calibration_in_the_large": -0.0006022625305337941, + "expected_calibration_error_10bin": 0.0006796920744565515, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "E89": { + "valid": 2780, + "positives": 5, + "negatives": 2775, + "auroc": 0.6877117117117117, + "auprc": 0.0032689905069257603, + "brier": 0.001804654310721322, + "calibration": { + "observed_rate": 0.0017985611510791368, + "mean_prediction": 0.002933692820843396, + "calibration_in_the_large": 0.0011351316697642594, + "expected_calibration_error_10bin": 0.0011351316697642594, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "F02": { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8097748391708363, + "auprc": 0.006071563175786184, + "brier": 0.0014794661220913087, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.0026562550744667563, + "calibration_in_the_large": 0.001228703325715864, + "expected_calibration_error_10bin": 0.0012287033257158643, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "F03": { + "valid": 2739, + "positives": 14, + "negatives": 2725, + "auroc": 0.8473132372214941, + "auprc": 0.02572010319101865, + "brier": 0.00518483159057174, + "calibration": { + "observed_rate": 0.00511135450894487, + "mean_prediction": 0.00665706497945791, + "calibration_in_the_large": 0.0015457104705130396, + "expected_calibration_error_10bin": 0.00154571047051304, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "F05": { + "valid": 2750, + "positives": 23, + "negatives": 2727, + "auroc": 0.7106072926133193, + "auprc": 0.016767774646333753, + "brier": 0.008674268787659421, + "calibration": { + "observed_rate": 0.008363636363636363, + "mean_prediction": 0.012298044220118423, + "calibration_in_the_large": 0.00393440785648206, + "expected_calibration_error_10bin": 0.0039344078564820615, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "F06": { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7084217975937721, + "auprc": 0.0017760267654737894, + "brier": 0.0007231013149608555, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.002401681609250761, + "calibration_in_the_large": 0.0016944680307500537, + "expected_calibration_error_10bin": 0.0016944680307500537, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "F10": { + "valid": 2560, + "positives": 15, + "negatives": 2545, + "auroc": 0.7922986247544205, + "auprc": 0.11146819704952345, + "brier": 0.005626742105504454, + "calibration": { + "observed_rate": 0.005859375, + "mean_prediction": 0.007806336809107961, + "calibration_in_the_large": 0.0019469618091079608, + "expected_calibration_error_10bin": 0.002397980004707279, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "F11": { + "valid": 2741, + "positives": 9, + "negatives": 2732, + "auroc": 0.8617211647958354, + "auprc": 0.03242434561921866, + "brier": 0.003309681449265005, + "calibration": { + "observed_rate": 0.003283473184968989, + "mean_prediction": 0.0041357005592624705, + "calibration_in_the_large": 0.0008522273742934813, + "expected_calibration_error_10bin": 0.0008522273742934811, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "F12": { + "valid": 2777, + "positives": 12, + "negatives": 2765, + "auroc": 0.8949668474984931, + "auprc": 0.02505284553775028, + "brier": 0.0042752906967690706, + "calibration": { + "observed_rate": 0.004321209938782859, + "mean_prediction": 0.0032052260983836374, + "calibration_in_the_large": -0.0011159838403992216, + "expected_calibration_error_10bin": 0.0011159838403992216, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "F14": { + "valid": 2787, + "positives": 9, + "negatives": 2778, + "auroc": 0.9460843132549396, + "auprc": 0.03912304106733373, + "brier": 0.003196454785336325, + "calibration": { + "observed_rate": 0.0032292787944025836, + "mean_prediction": 0.0013267578188423804, + "calibration_in_the_large": -0.0019025209755602031, + "expected_calibration_error_10bin": 0.0019025209755602031, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "F15": { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.9578748077150633, + "auprc": 0.04167403606769058, + "brier": 0.0021066664536938872, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0005441197282664174, + "calibration_in_the_large": -0.001581278783954624, + "expected_calibration_error_10bin": 0.001581278783954624, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "F17": { + "valid": 2426, + "positives": 30, + "negatives": 2396, + "auroc": 0.8585002782415136, + "auprc": 0.08763241236741477, + "brier": 0.011799270967061518, + "calibration": { + "observed_rate": 0.01236603462489695, + "mean_prediction": 0.01177337785118612, + "calibration_in_the_large": -0.0005926567737108302, + "expected_calibration_error_10bin": 0.001756300588475459, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + "F19": { + "valid": 2801, + "positives": 11, + "negatives": 2790, + "auroc": 0.9660149885956337, + "auprc": 0.13660644756478366, + "brier": 0.0037695129573725836, + "calibration": { + "observed_rate": 0.003927168868261335, + "mean_prediction": 0.0015674477918228666, + "calibration_in_the_large": -0.002359721076438469, + "expected_calibration_error_10bin": 0.002359721076438469, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F20": { + "valid": 2808, + "positives": 3, + "negatives": 2805, + "auroc": 0.7984551396316102, + "auprc": 0.015185478259683206, + "brier": 0.0010643707891573402, + "calibration": { + "observed_rate": 0.0010683760683760685, + "mean_prediction": 0.0009082461501754663, + "calibration_in_the_large": -0.0001601299182006022, + "expected_calibration_error_10bin": 0.0001601299182006022, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + "F22": { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.7400709219858156, + "auprc": 0.0013623978201634877, + "brier": 0.0003575291276611991, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0009631272075162986, + "calibration_in_the_large": 0.0006086429820643312, + "expected_calibration_error_10bin": 0.0006086429820643312, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "F25": { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7885890151515151, + "auprc": 0.005854660324322205, + "brier": 0.0010654874370677777, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0008546609478624707, + "calibration_in_the_large": -0.00020954621779911134, + "expected_calibration_error_10bin": 0.00020954621779911134, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "F29": { + "valid": 2806, + "positives": 7, + "negatives": 2799, + "auroc": 0.7210738529066504, + "auprc": 0.006048873031160097, + "brier": 0.002491892167799549, + "calibration": { + "observed_rate": 0.0024946543121881683, + "mean_prediction": 0.0006672654630086112, + "calibration_in_the_large": -0.001827388849179557, + "expected_calibration_error_10bin": 0.001827388849179557, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "F31": { + "valid": 2724, + "positives": 8, + "negatives": 2716, + "auroc": 0.8493188512518409, + "auprc": 0.035493594412706546, + "brier": 0.002893636320290228, + "calibration": { + "observed_rate": 0.002936857562408223, + "mean_prediction": 0.002715530413942589, + "calibration_in_the_large": -0.0002213271484656342, + "expected_calibration_error_10bin": 0.0002213271484656342, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + "F32": { + "valid": 2200, + "positives": 56, + "negatives": 2144, + "auroc": 0.7064065831556503, + "auprc": 0.06861263576240247, + "brier": 0.02488740493999048, + "calibration": { + "observed_rate": 0.025454545454545455, + "mean_prediction": 0.0358809934776615, + "calibration_in_the_large": 0.010426448023116045, + "expected_calibration_error_10bin": 0.010426448023116045, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + "F33": { + "valid": 2800, + "positives": 11, + "negatives": 2789, + "auroc": 0.7858144007301412, + "auprc": 0.014312161256099288, + "brier": 0.003927164880250189, + "calibration": { + "observed_rate": 0.003928571428571429, + "mean_prediction": 0.0029433343712064793, + "calibration_in_the_large": -0.0009852370573649495, + "expected_calibration_error_10bin": 0.0009852370573649495, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "F39": { + "valid": 2801, + "positives": 10, + "negatives": 2791, + "auroc": 0.7744536008599069, + "auprc": 0.021603857487652634, + "brier": 0.003540394596909255, + "calibration": { + "observed_rate": 0.003570153516601214, + "mean_prediction": 0.0025466232698140223, + "calibration_in_the_large": -0.0010235302467871917, + "expected_calibration_error_10bin": 0.0010235302467871917, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F41": { + "valid": 2247, + "positives": 74, + "negatives": 2173, + "auroc": 0.7085484011392893, + "auprc": 0.1014658368158152, + "brier": 0.0309487975715953, + "calibration": { + "observed_rate": 0.032932799287939477, + "mean_prediction": 0.0330969305469853, + "calibration_in_the_large": 0.00016413125904582437, + "expected_calibration_error_10bin": 0.0005226491284807458, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + "F43": { + "valid": 2734, + "positives": 18, + "negatives": 2716, + "auroc": 0.7707412862052038, + "auprc": 0.0731684653212303, + "brier": 0.006434895720967603, + "calibration": { + "observed_rate": 0.006583760058522311, + "mean_prediction": 0.007901825011468454, + "calibration_in_the_large": 0.0013180649529461429, + "expected_calibration_error_10bin": 0.0017891717807720386, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "F60": { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.9349448986846782, + "auprc": 0.024419948859650365, + "brier": 0.0017676255294919907, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0017860558813787438, + "calibration_in_the_large": 1.1747861506494067e-05, + "expected_calibration_error_10bin": 5.9506530126506816e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "F90": { + "valid": 2775, + "positives": 7, + "negatives": 2768, + "auroc": 0.8887799339388934, + "auprc": 0.032136285860320704, + "brier": 0.0025048155305338322, + "calibration": { + "observed_rate": 0.0025225225225225223, + "mean_prediction": 0.0008735195399161852, + "calibration_in_the_large": -0.0016490029826063371, + "expected_calibration_error_10bin": 0.0016490029826063371, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "G25": { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.6990004816955684, + "auprc": 0.005024467947730488, + "brier": 0.002177331931611825, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.0033030383814392195, + "calibration_in_the_large": 0.0011400967808624352, + "expected_calibration_error_10bin": 0.0011400967808624352, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "G31": { + "valid": 2802, + "positives": 7, + "negatives": 2795, + "auroc": 0.8381293125479172, + "auprc": 0.009147373817991248, + "brier": 0.0026124422287101324, + "calibration": { + "observed_rate": 0.0024982155603140615, + "mean_prediction": 0.004606213637081451, + "calibration_in_the_large": 0.002107998076767389, + "expected_calibration_error_10bin": 0.002107998076767389, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "G40": { + "valid": 2723, + "positives": 21, + "negatives": 2702, + "auroc": 0.7475415036480914, + "auprc": 0.046895103905450965, + "brier": 0.007604588361590129, + "calibration": { + "observed_rate": 0.007712082262210797, + "mean_prediction": 0.007362112447827558, + "calibration_in_the_large": -0.0003499698143832391, + "expected_calibration_error_10bin": 0.0013505861923408778, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "G43": { + "valid": 2725, + "positives": 15, + "negatives": 2710, + "auroc": 0.7741697416974169, + "auprc": 0.01711243418808989, + "brier": 0.00546410721192882, + "calibration": { + "observed_rate": 0.005504587155963303, + "mean_prediction": 0.0032206061324467797, + "calibration_in_the_large": -0.0022839810235165234, + "expected_calibration_error_10bin": 0.0022839810235165234, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + "G44": { + "valid": 2805, + "positives": 5, + "negatives": 2800, + "auroc": 0.7604285714285715, + "auprc": 0.007204878410899828, + "brier": 0.0017875922450657168, + "calibration": { + "observed_rate": 0.0017825311942959, + "mean_prediction": 0.0015797059165877033, + "calibration_in_the_large": -0.00020282527770819673, + "expected_calibration_error_10bin": 0.00020282527770819673, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "G47": { + "valid": 2315, + "positives": 78, + "negatives": 2237, + "auroc": 0.7106186169664042, + "auprc": 0.0866251960452942, + "brier": 0.03186682799251734, + "calibration": { + "observed_rate": 0.033693304535637146, + "mean_prediction": 0.027719289031418817, + "calibration_in_the_large": -0.0059740155042183295, + "expected_calibration_error_10bin": 0.007162323968231551, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + "G51": { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 7.36849051037564e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0005616606787398506, + "calibration_in_the_large": 0.0005616606787398506, + "expected_calibration_error_10bin": 0.0005616606787398506, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + "G62": { + "valid": 2751, + "positives": 32, + "negatives": 2719, + "auroc": 0.8235794409709452, + "auprc": 0.10518562967508313, + "brier": 0.010976750018675345, + "calibration": { + "observed_rate": 0.011632133769538349, + "mean_prediction": 0.007961717618308401, + "calibration_in_the_large": -0.003670416151229948, + "expected_calibration_error_10bin": 0.00388957750093177, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "G81": { + "valid": 2789, + "positives": 14, + "negatives": 2775, + "auroc": 0.75006435006435, + "auprc": 0.030921967926476796, + "brier": 0.004973329660757567, + "calibration": { + "observed_rate": 0.005019720329867336, + "mean_prediction": 0.0027256671420495993, + "calibration_in_the_large": -0.0022940531878177365, + "expected_calibration_error_10bin": 0.0024849522684136, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "G83": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.73992673992674, + "auprc": 0.00466710540503027, + "brier": 0.0010671755739223286, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0012630485596766433, + "calibration_in_the_large": 0.00020072561350100576, + "expected_calibration_error_10bin": 0.00020072561350100576, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "G89": { + "valid": 2537, + "positives": 57, + "negatives": 2480, + "auroc": 0.7792586304470854, + "auprc": 0.12072919006193175, + "brier": 0.021131000482619157, + "calibration": { + "observed_rate": 0.022467481277098935, + "mean_prediction": 0.02698724439471265, + "calibration_in_the_large": 0.0045197631176137135, + "expected_calibration_error_10bin": 0.005564867740407604, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + "G90": { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 2.0426970332876522e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0019543444930631916, + "calibration_in_the_large": 0.0019543444930631916, + "expected_calibration_error_10bin": 0.0019543444930631916, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "G92": { + "valid": 2733, + "positives": 38, + "negatives": 2695, + "auroc": 0.7648178888780393, + "auprc": 0.0667723272273836, + "brier": 0.013715520884871291, + "calibration": { + "observed_rate": 0.013904134650567142, + "mean_prediction": 0.01864712505653346, + "calibration_in_the_large": 0.004742990405966317, + "expected_calibration_error_10bin": 0.0047528789757419814, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "G93": { + "valid": 2656, + "positives": 44, + "negatives": 2612, + "auroc": 0.7908777669497424, + "auprc": 0.05944222205789374, + "brier": 0.016009100979440614, + "calibration": { + "observed_rate": 0.016566265060240965, + "mean_prediction": 0.01524991596888648, + "calibration_in_the_large": -0.0013163490913544844, + "expected_calibration_error_10bin": 0.0035980394499763716, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + "G99": { + "valid": 2841, + "positives": 0, + "negatives": 2841, + "auroc": null, + "auprc": null, + "brier": 1.0637333888480857e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0004214299940746051, + "calibration_in_the_large": 0.0004214299940746051, + "expected_calibration_error_10bin": 0.0004214299940746051, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9992965177629265 + }, + "H10": { + "valid": 2832, + "positives": 5, + "negatives": 2827, + "auroc": 0.8757693668199504, + "auprc": 0.013256010914250119, + "brier": 0.0017603000627820994, + "calibration": { + "observed_rate": 0.0017655367231638418, + "mean_prediction": 0.0009139232123952958, + "calibration_in_the_large": -0.000851613510768546, + "expected_calibration_error_10bin": 0.000851613510768546, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "H26": { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 9.912884217888545e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001580757693475406, + "calibration_in_the_large": 0.001580757693475406, + "expected_calibration_error_10bin": 0.001580757693475406, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "H35": { + "valid": 2806, + "positives": 5, + "negatives": 2801, + "auroc": 0.7115315958586219, + "auprc": 0.006683892156154494, + "brier": 0.0017805304893753497, + "calibration": { + "observed_rate": 0.001781895937277263, + "mean_prediction": 0.000852779106053218, + "calibration_in_the_large": -0.0009291168312240451, + "expected_calibration_error_10bin": 0.0009291168312240451, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "H40": { + "valid": 2750, + "positives": 6, + "negatives": 2744, + "auroc": 0.7946428571428571, + "auprc": 0.0318682972745543, + "brier": 0.00218437147563276, + "calibration": { + "observed_rate": 0.002181818181818182, + "mean_prediction": 0.004207556445738936, + "calibration_in_the_large": 0.0020257382639207538, + "expected_calibration_error_10bin": 0.0020257382639207533, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "H53": { + "valid": 2790, + "positives": 10, + "negatives": 2780, + "auroc": 0.6152158273381295, + "auprc": 0.010412665110269483, + "brier": 0.0035839775772893968, + "calibration": { + "observed_rate": 0.0035842293906810036, + "mean_prediction": 0.004734564579081952, + "calibration_in_the_large": 0.0011503351884009482, + "expected_calibration_error_10bin": 0.0011503351884009482, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "H54": { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.41895261845386533, + "auprc": 0.0008959891252021378, + "brier": 0.0007380935320765841, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.0025323826771081097, + "calibration_in_the_large": 0.0018203855250967177, + "expected_calibration_error_10bin": 0.0018203855250967177, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "H91": { + "valid": 2791, + "positives": 7, + "negatives": 2784, + "auroc": 0.7563115763546798, + "auprc": 0.008483110742694604, + "brier": 0.002505649904385833, + "calibration": { + "observed_rate": 0.0025080616266571123, + "mean_prediction": 0.0026132100009391246, + "calibration_in_the_large": 0.00010514837428201229, + "expected_calibration_error_10bin": 0.00010514837428201229, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + "I07": { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.8697195598154065, + "auprc": 0.01010325210647089, + "brier": 0.002131473328994385, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0012205432135699104, + "calibration_in_the_large": -0.0009048552986511309, + "expected_calibration_error_10bin": 0.0009048552986511309, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "I08": { + "valid": 2767, + "positives": 12, + "negatives": 2755, + "auroc": 0.8712038717483364, + "auprc": 0.02670634920518837, + "brier": 0.004557341842827637, + "calibration": { + "observed_rate": 0.0043368268883267076, + "mean_prediction": 0.007356097833657, + "calibration_in_the_large": 0.0030192709453302925, + "expected_calibration_error_10bin": 0.003019270945330293, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + "I10": { + "valid": 1498, + "positives": 36, + "negatives": 1462, + "auroc": 0.6768315853473172, + "auprc": 0.058850558233233215, + "brier": 0.023410831572547076, + "calibration": { + "observed_rate": 0.02403204272363151, + "mean_prediction": 0.017907434710048423, + "calibration_in_the_large": -0.006124608013583086, + "expected_calibration_error_10bin": 0.008839228426809431, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + "I11": { + "valid": 2676, + "positives": 43, + "negatives": 2633, + "auroc": 0.8164354039516336, + "auprc": 0.06308384023091065, + "brier": 0.015562350911770587, + "calibration": { + "observed_rate": 0.016068759342301942, + "mean_prediction": 0.011156922532074766, + "calibration_in_the_large": -0.004911836810227176, + "expected_calibration_error_10bin": 0.005909477888118771, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + "I12": { + "valid": 2552, + "positives": 23, + "negatives": 2529, + "auroc": 0.8255540082864855, + "auprc": 0.05130945253318322, + "brier": 0.008916050848074007, + "calibration": { + "observed_rate": 0.009012539184952978, + "mean_prediction": 0.006974160792088585, + "calibration_in_the_large": -0.0020383783928643933, + "expected_calibration_error_10bin": 0.003944646376183637, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + "I13": { + "valid": 2727, + "positives": 24, + "negatives": 2703, + "auroc": 0.8902299913676163, + "auprc": 0.10918722778517444, + "brier": 0.008311723520116169, + "calibration": { + "observed_rate": 0.0088008800880088, + "mean_prediction": 0.009963564244720313, + "calibration_in_the_large": 0.0011626841567115125, + "expected_calibration_error_10bin": 0.0012517380313795388, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + "I16": { + "valid": 2390, + "positives": 9, + "negatives": 2381, + "auroc": 0.872789210882449, + "auprc": 0.022756021010146135, + "brier": 0.0037312383755873737, + "calibration": { + "observed_rate": 0.0037656903765690376, + "mean_prediction": 0.00226056850072051, + "calibration_in_the_large": -0.0015051218758485277, + "expected_calibration_error_10bin": 0.0015051218758485277, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + "I21": { + "valid": 2671, + "positives": 19, + "negatives": 2652, + "auroc": 0.8316861157418433, + "auprc": 0.03780246796485587, + "brier": 0.007140574985230976, + "calibration": { + "observed_rate": 0.00711344065892924, + "mean_prediction": 0.011961327710459413, + "calibration_in_the_large": 0.004847887051530173, + "expected_calibration_error_10bin": 0.004847887051530175, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "I24": { + "valid": 2809, + "positives": 7, + "negatives": 2802, + "auroc": 0.901040073416947, + "auprc": 0.03635642550388813, + "brier": 0.0024584593085436946, + "calibration": { + "observed_rate": 0.002491990032039872, + "mean_prediction": 0.0016474012706261686, + "calibration_in_the_large": -0.0008445887614137034, + "expected_calibration_error_10bin": 0.0008445887614137034, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "I25": { + "valid": 2243, + "positives": 39, + "negatives": 2204, + "auroc": 0.8396970543068547, + "auprc": 0.07504772624294856, + "brier": 0.01660551078582296, + "calibration": { + "observed_rate": 0.017387427552385197, + "mean_prediction": 0.014358807150750972, + "calibration_in_the_large": -0.003028620401634225, + "expected_calibration_error_10bin": 0.0036200961457285973, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + "I26": { + "valid": 2760, + "positives": 17, + "negatives": 2743, + "auroc": 0.7275203191010272, + "auprc": 0.14062094913968112, + "brier": 0.00590566496674521, + "calibration": { + "observed_rate": 0.006159420289855073, + "mean_prediction": 0.005631420708290323, + "calibration_in_the_large": -0.0005279995815647498, + "expected_calibration_error_10bin": 0.0010608960870213452, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + "I27": { + "valid": 2716, + "positives": 31, + "negatives": 2685, + "auroc": 0.8317054123866162, + "auprc": 0.05145588111094335, + "brier": 0.011174688059934827, + "calibration": { + "observed_rate": 0.011413843888070692, + "mean_prediction": 0.009037836580857444, + "calibration_in_the_large": -0.0023760073072132473, + "expected_calibration_error_10bin": 0.004850951226537281, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I31": { + "valid": 2793, + "positives": 15, + "negatives": 2778, + "auroc": 0.8436285097192224, + "auprc": 0.08856311116891437, + "brier": 0.005270829701301881, + "calibration": { + "observed_rate": 0.0053705692803437165, + "mean_prediction": 0.0036182312946530073, + "calibration_in_the_large": -0.0017523379856907093, + "expected_calibration_error_10bin": 0.0017523379856907093, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I34": { + "valid": 2753, + "positives": 16, + "negatives": 2737, + "auroc": 0.7572387650712459, + "auprc": 0.018579018837353953, + "brier": 0.005837668592822873, + "calibration": { + "observed_rate": 0.005811841627315656, + "mean_prediction": 0.004997986909819467, + "calibration_in_the_large": -0.0008138547174961885, + "expected_calibration_error_10bin": 0.001547911601163338, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + "I35": { + "valid": 2723, + "positives": 6, + "negatives": 2717, + "auroc": 0.7175193227824807, + "auprc": 0.008169950489502066, + "brier": 0.0023054781891316193, + "calibration": { + "observed_rate": 0.0022034520749173708, + "mean_prediction": 0.004323497578313005, + "calibration_in_the_large": 0.0021200455033956343, + "expected_calibration_error_10bin": 0.0021200455033956343, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "I42": { + "valid": 2740, + "positives": 12, + "negatives": 2728, + "auroc": 0.9225012218963832, + "auprc": 0.06387863925194781, + "brier": 0.00426711584969585, + "calibration": { + "observed_rate": 0.004379562043795621, + "mean_prediction": 0.004028193245590478, + "calibration_in_the_large": -0.00035136879820514295, + "expected_calibration_error_10bin": 0.00046095575536745737, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "I44": { + "valid": 2722, + "positives": 18, + "negatives": 2704, + "auroc": 0.8678911900065747, + "auprc": 0.0649472562244474, + "brier": 0.0064621164465726005, + "calibration": { + "observed_rate": 0.006612784717119765, + "mean_prediction": 0.008370299119420768, + "calibration_in_the_large": 0.0017575144023010032, + "expected_calibration_error_10bin": 0.0019048335773576403, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + "I45": { + "valid": 2766, + "positives": 14, + "negatives": 2752, + "auroc": 0.7352315199335548, + "auprc": 0.048516573295153013, + "brier": 0.0050163287617262685, + "calibration": { + "observed_rate": 0.005061460592913955, + "mean_prediction": 0.006357083136599817, + "calibration_in_the_large": 0.0012956225436858617, + "expected_calibration_error_10bin": 0.0012956225436858617, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + "I46": { + "valid": 2831, + "positives": 1, + "negatives": 2830, + "auroc": 0.4713780918727915, + "auprc": 0.0006680026720106881, + "brier": 0.0003666318705170449, + "calibration": { + "observed_rate": 0.00035323207347227127, + "mean_prediction": 0.0019637140051968487, + "calibration_in_the_large": 0.0016104819317245775, + "expected_calibration_error_10bin": 0.0016104819317245775, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I47": { + "valid": 2716, + "positives": 13, + "negatives": 2703, + "auroc": 0.7418822391075444, + "auprc": 0.013077455382048905, + "brier": 0.004820908711269073, + "calibration": { + "observed_rate": 0.004786450662739323, + "mean_prediction": 0.007887599703126974, + "calibration_in_the_large": 0.0031011490403876508, + "expected_calibration_error_10bin": 0.0031011490403876508, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I48": { + "valid": 2385, + "positives": 23, + "negatives": 2362, + "auroc": 0.7829768435003498, + "auprc": 0.028221976674965704, + "brier": 0.009569832286124156, + "calibration": { + "observed_rate": 0.009643605870020965, + "mean_prediction": 0.010219006336038342, + "calibration_in_the_large": 0.0005754004660173777, + "expected_calibration_error_10bin": 0.0005754004660173775, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + "I49": { + "valid": 2734, + "positives": 15, + "negatives": 2719, + "auroc": 0.7327448816967023, + "auprc": 0.012572240855128635, + "brier": 0.005451039323533301, + "calibration": { + "observed_rate": 0.005486466715435259, + "mean_prediction": 0.00413838663748118, + "calibration_in_the_large": -0.0013480800779540796, + "expected_calibration_error_10bin": 0.0013480800779540796, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I50": { + "valid": 2415, + "positives": 42, + "negatives": 2373, + "auroc": 0.8046876567736239, + "auprc": 0.0841426517468212, + "brier": 0.016982776978137538, + "calibration": { + "observed_rate": 0.017391304347826087, + "mean_prediction": 0.017286113381339285, + "calibration_in_the_large": -0.00010519096648680185, + "expected_calibration_error_10bin": 0.004044926029107704, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + "I51": { + "valid": 2807, + "positives": 7, + "negatives": 2800, + "auroc": 0.8545408163265306, + "auprc": 0.010466196777351605, + "brier": 0.002483268740310128, + "calibration": { + "observed_rate": 0.0024937655860349127, + "mean_prediction": 0.002050596143068419, + "calibration_in_the_large": -0.00044316944296649355, + "expected_calibration_error_10bin": 0.00044316944296649355, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "I61": { + "valid": 2802, + "positives": 8, + "negatives": 2794, + "auroc": 0.8447566213314245, + "auprc": 0.01195929430110062, + "brier": 0.0028468891177952592, + "calibration": { + "observed_rate": 0.0028551034975017845, + "mean_prediction": 0.0008640652344440837, + "calibration_in_the_large": -0.0019910382630577007, + "expected_calibration_error_10bin": 0.0019910382630577007, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "I63": { + "valid": 2735, + "positives": 12, + "negatives": 2723, + "auroc": 0.8021177622720039, + "auprc": 0.01831115853241926, + "brier": 0.004398933673563035, + "calibration": { + "observed_rate": 0.0043875685557586835, + "mean_prediction": 0.004425788392308621, + "calibration_in_the_large": 3.8219836549937755e-05, + "expected_calibration_error_10bin": 0.00034955317381903746, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + "I65": { + "valid": 2774, + "positives": 5, + "negatives": 2769, + "auroc": 0.6720115565185988, + "auprc": 0.01150755266137933, + "brier": 0.0018074591402872364, + "calibration": { + "observed_rate": 0.001802451333813987, + "mean_prediction": 0.0028339166381460687, + "calibration_in_the_large": 0.0010314653043320817, + "expected_calibration_error_10bin": 0.0010314653043320817, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "I67": { + "valid": 2773, + "positives": 3, + "negatives": 2770, + "auroc": 0.6320096269554754, + "auprc": 0.0030477296843850568, + "brier": 0.0011198131573045902, + "calibration": { + "observed_rate": 0.0010818608005769925, + "mean_prediction": 0.002918650402197857, + "calibration_in_the_large": 0.0018367896016208646, + "expected_calibration_error_10bin": 0.0018367896016208646, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "I69": { + "valid": 2752, + "positives": 15, + "negatives": 2737, + "auroc": 0.7373036170990135, + "auprc": 0.014419984144938048, + "brier": 0.0055043579053087295, + "calibration": { + "observed_rate": 0.005450581395348837, + "mean_prediction": 0.006563082961258451, + "calibration_in_the_large": 0.0011125015659096136, + "expected_calibration_error_10bin": 0.0011125015659096131, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + "I70": { + "valid": 2771, + "positives": 10, + "negatives": 2761, + "auroc": 0.7966678739587106, + "auprc": 0.01859126512261919, + "brier": 0.003591355583496644, + "calibration": { + "observed_rate": 0.003608805485384338, + "mean_prediction": 0.00250058725682502, + "calibration_in_the_large": -0.001108218228559318, + "expected_calibration_error_10bin": 0.001108218228559318, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + "I71": { + "valid": 2769, + "positives": 4, + "negatives": 2765, + "auroc": 0.7279385171790235, + "auprc": 0.004847096220566756, + "brier": 0.00145357527991531, + "calibration": { + "observed_rate": 0.001444564824846515, + "mean_prediction": 0.0023138490234645426, + "calibration_in_the_large": 0.0008692841986180275, + "expected_calibration_error_10bin": 0.0008692841986180275, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + "I72": { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.6952939781887151, + "auprc": 0.008621066432846478, + "brier": 0.0021280459599886236, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0013737487253537566, + "calibration_in_the_large": -0.0007554208984929432, + "expected_calibration_error_10bin": 0.0007554208984929432, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "I73": { + "valid": 2734, + "positives": 8, + "negatives": 2726, + "auroc": 0.7986977256052825, + "auprc": 0.06941114845079603, + "brier": 0.0028451958066154216, + "calibration": { + "observed_rate": 0.002926115581565472, + "mean_prediction": 0.002439791356538089, + "calibration_in_the_large": -0.0004863242250273828, + "expected_calibration_error_10bin": 0.0005657654765344811, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I74": { + "valid": 2821, + "positives": 5, + "negatives": 2816, + "auroc": 0.5753551136363636, + "auprc": 0.0034384917884819873, + "brier": 0.001771176669908409, + "calibration": { + "observed_rate": 0.001772421127259837, + "mean_prediction": 0.0007478915992747165, + "calibration_in_the_large": -0.0010245295279851204, + "expected_calibration_error_10bin": 0.0010245295279851204, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "I77": { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.7165647115269281, + "auprc": 0.008783970941914174, + "brier": 0.0021498874326882117, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.0020314754312967713, + "calibration_in_the_large": -0.00012292313243751933, + "expected_calibration_error_10bin": 0.00012292313243751933, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "I80": { + "valid": 2827, + "positives": 4, + "negatives": 2823, + "auroc": 0.8895678356358484, + "auprc": 0.08963505137746479, + "brier": 0.0013851460009365124, + "calibration": { + "observed_rate": 0.0014149274849663955, + "mean_prediction": 0.0012516616380380814, + "calibration_in_the_large": -0.00016326584692831405, + "expected_calibration_error_10bin": 0.00024251774389650395, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "I81": { + "valid": 2826, + "positives": 8, + "negatives": 2818, + "auroc": 0.7624201561391057, + "auprc": 0.021414803452554455, + "brier": 0.0029091611293486546, + "calibration": { + "observed_rate": 0.0028308563340410475, + "mean_prediction": 0.0022342710487837183, + "calibration_in_the_large": -0.0005965852852573292, + "expected_calibration_error_10bin": 0.0013251220120310847, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I82": { + "valid": 2739, + "positives": 28, + "negatives": 2711, + "auroc": 0.727881119249618, + "auprc": 0.03662279000119844, + "brier": 0.010137338080948797, + "calibration": { + "observed_rate": 0.01022270901788974, + "mean_prediction": 0.009773492749398571, + "calibration_in_the_large": -0.0004492162684911691, + "expected_calibration_error_10bin": 0.0029548260239393265, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "I85": { + "valid": 2793, + "positives": 9, + "negatives": 2784, + "auroc": 0.9911797573435505, + "auprc": 0.2240497944703311, + "brier": 0.003023909788959703, + "calibration": { + "observed_rate": 0.00322234156820623, + "mean_prediction": 0.0018408555151392806, + "calibration_in_the_large": -0.0013814860530669494, + "expected_calibration_error_10bin": 0.0031849425736146216, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I87": { + "valid": 2780, + "positives": 12, + "negatives": 2768, + "auroc": 0.724349710982659, + "auprc": 0.010926823694938997, + "brier": 0.0043378608359116895, + "calibration": { + "observed_rate": 0.004316546762589928, + "mean_prediction": 0.005008721764591709, + "calibration_in_the_large": 0.0006921750020017813, + "expected_calibration_error_10bin": 0.0006921750020017813, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "I89": { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8447359092520382, + "auprc": 0.012429039205438471, + "brier": 0.0017633034939404494, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0006693374544868637, + "calibration_in_the_large": -0.0010999477542887907, + "expected_calibration_error_10bin": 0.0010999477542887907, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I95": { + "valid": 2485, + "positives": 82, + "negatives": 2403, + "auroc": 0.7509921541162977, + "auprc": 0.08120551953458216, + "brier": 0.03126072742092773, + "calibration": { + "observed_rate": 0.03299798792756539, + "mean_prediction": 0.03123153258200315, + "calibration_in_the_large": -0.0017664553455622421, + "expected_calibration_error_10bin": 0.007419889815708238, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + "I96": { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.870417551309271, + "auprc": 0.036575871330586, + "brier": 0.0017446175141683587, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0015839096673996873, + "calibration_in_the_large": -0.00018225069996166904, + "expected_calibration_error_10bin": 0.00018225069996166904, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I97": { + "valid": 2740, + "positives": 10, + "negatives": 2730, + "auroc": 0.796923076923077, + "auprc": 0.014218261324769416, + "brier": 0.0036267647709101996, + "calibration": { + "observed_rate": 0.0036496350364963502, + "mean_prediction": 0.0031007884656071467, + "calibration_in_the_large": -0.0005488465708892035, + "expected_calibration_error_10bin": 0.0005488465708892035, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "J02": { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.6831385051363797, + "auprc": 0.0016489446754077391, + "brier": 0.000722298049732172, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0015808460485670238, + "calibration_in_the_large": 0.0008728814467971123, + "expected_calibration_error_10bin": 0.0008728814467971123, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J06": { + "valid": 2816, + "positives": 8, + "negatives": 2808, + "auroc": 0.7318376068376068, + "auprc": 0.012495004794626384, + "brier": 0.0028854369004969616, + "calibration": { + "observed_rate": 0.002840909090909091, + "mean_prediction": 0.003190457827269132, + "calibration_in_the_large": 0.00034954873636004096, + "expected_calibration_error_10bin": 0.0003495487363600409, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "J12": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 7.197539242568787e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00259203834380418, + "calibration_in_the_large": 0.00259203834380418, + "expected_calibration_error_10bin": 0.0025920383438041805, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J15": { + "valid": 2795, + "positives": 12, + "negatives": 2783, + "auroc": 0.7921607378129117, + "auprc": 0.018534395107060342, + "brier": 0.00434815844784424, + "calibration": { + "observed_rate": 0.004293381037567084, + "mean_prediction": 0.005731120268564202, + "calibration_in_the_large": 0.0014377392309971185, + "expected_calibration_error_10bin": 0.0014377392309971183, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + "J18": { + "valid": 2671, + "positives": 51, + "negatives": 2620, + "auroc": 0.7699221673402186, + "auprc": 0.06738566812662615, + "brier": 0.018473660246165025, + "calibration": { + "observed_rate": 0.019093972295020592, + "mean_prediction": 0.0183099166317149, + "calibration_in_the_large": -0.0007840556633056904, + "expected_calibration_error_10bin": 0.0029014176357189158, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "J30": { + "valid": 2815, + "positives": 7, + "negatives": 2808, + "auroc": 0.7498982498982499, + "auprc": 0.03004699711581325, + "brier": 0.0024729836093772967, + "calibration": { + "observed_rate": 0.002486678507992895, + "mean_prediction": 0.002718131034986528, + "calibration_in_the_large": 0.0002314525269936328, + "expected_calibration_error_10bin": 0.0002314525269936328, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "J32": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.5137955429784223, + "auprc": 0.0025986827757665636, + "brier": 0.00072599682994258, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0012531654897437728, + "calibration_in_the_large": 0.0005462018983687285, + "expected_calibration_error_10bin": 0.0005462018983687285, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J38": { + "valid": 2825, + "positives": 3, + "negatives": 2822, + "auroc": 0.7485235057878573, + "auprc": 0.0037296198049418714, + "brier": 0.0010671302145613812, + "calibration": { + "observed_rate": 0.0010619469026548673, + "mean_prediction": 0.0014312623712709133, + "calibration_in_the_large": 0.000369315468616046, + "expected_calibration_error_10bin": 0.000369315468616046, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J43": { + "valid": 2804, + "positives": 8, + "negatives": 2796, + "auroc": 0.6266541487839771, + "auprc": 0.005165769791548473, + "brier": 0.002860493380979503, + "calibration": { + "observed_rate": 0.0028530670470756064, + "mean_prediction": 0.0017675133214857298, + "calibration_in_the_large": -0.0010855537255898765, + "expected_calibration_error_10bin": 0.0011626149478475723, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "J44": { + "valid": 2570, + "positives": 24, + "negatives": 2546, + "auroc": 0.7934832416863054, + "auprc": 0.03504198209516665, + "brier": 0.00917519437287514, + "calibration": { + "observed_rate": 0.00933852140077821, + "mean_prediction": 0.007306849174664092, + "calibration_in_the_large": -0.002031672226114118, + "expected_calibration_error_10bin": 0.0025587643505836674, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + "J45": { + "valid": 2518, + "positives": 22, + "negatives": 2496, + "auroc": 0.6917249417249417, + "auprc": 0.023478235649538947, + "brier": 0.008643515982040358, + "calibration": { + "observed_rate": 0.008737092930897538, + "mean_prediction": 0.007132444012404521, + "calibration_in_the_large": -0.001604648918493017, + "expected_calibration_error_10bin": 0.0018670596217021276, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + "J47": { + "valid": 2825, + "positives": 6, + "negatives": 2819, + "auroc": 0.8615348232233653, + "auprc": 0.014295607721652143, + "brier": 0.0021180094269450853, + "calibration": { + "observed_rate": 0.0021238938053097347, + "mean_prediction": 0.0007610729045260022, + "calibration_in_the_large": -0.0013628209007837326, + "expected_calibration_error_10bin": 0.0013628209007837326, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J69": { + "valid": 2777, + "positives": 25, + "negatives": 2752, + "auroc": 0.7645058139534884, + "auprc": 0.03178589051426553, + "brier": 0.008927339580455301, + "calibration": { + "observed_rate": 0.009002520705797623, + "mean_prediction": 0.009835408375768732, + "calibration_in_the_large": 0.000832887669971109, + "expected_calibration_error_10bin": 0.0008328876699711092, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "J81": { + "valid": 2781, + "positives": 17, + "negatives": 2764, + "auroc": 0.7702604920405209, + "auprc": 0.024565425142950417, + "brier": 0.00605251400560623, + "calibration": { + "observed_rate": 0.006112909025530385, + "mean_prediction": 0.0031027662764352448, + "calibration_in_the_large": -0.00301014274909514, + "expected_calibration_error_10bin": 0.00301014274909514, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "J84": { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.9138790035587189, + "auprc": 0.03314486552266009, + "brier": 0.002457892930841726, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.0015894267964452168, + "calibration_in_the_large": -0.0008954862315988018, + "expected_calibration_error_10bin": 0.0008954862315988018, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "J90": { + "valid": 2754, + "positives": 29, + "negatives": 2725, + "auroc": 0.6941474217019931, + "auprc": 0.02157413421294873, + "brier": 0.010561483121245212, + "calibration": { + "observed_rate": 0.010530137981118372, + "mean_prediction": 0.0095040182415724, + "calibration_in_the_large": -0.001026119739545972, + "expected_calibration_error_10bin": 0.0028640901457742205, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + "J91": { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.8236682159456561, + "auprc": 0.058306186185242456, + "brier": 0.0034868239457007976, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.003484066177828143, + "calibration_in_the_large": -7.845608793601803e-05, + "expected_calibration_error_10bin": 0.00026921133613318725, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "J94": { + "valid": 2829, + "positives": 9, + "negatives": 2820, + "auroc": 0.6966115051221434, + "auprc": 0.1203918818790442, + "brier": 0.0031387537053849356, + "calibration": { + "observed_rate": 0.003181336161187699, + "mean_prediction": 0.0013333219531045171, + "calibration_in_the_large": -0.0018480142080831818, + "expected_calibration_error_10bin": 0.0018480142080831818, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J95": { + "valid": 2770, + "positives": 12, + "negatives": 2758, + "auroc": 0.8082547739908146, + "auprc": 0.02822692054321066, + "brier": 0.0042768017083546625, + "calibration": { + "observed_rate": 0.004332129963898917, + "mean_prediction": 0.004573165674560761, + "calibration_in_the_large": 0.00024103571066184416, + "expected_calibration_error_10bin": 0.00024103571066184422, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + "J96": { + "valid": 2605, + "positives": 64, + "negatives": 2541, + "auroc": 0.819577676111767, + "auprc": 0.09485727999979543, + "brier": 0.02353520698302065, + "calibration": { + "observed_rate": 0.024568138195777352, + "mean_prediction": 0.023501503680570805, + "calibration_in_the_large": -0.001066634515206548, + "expected_calibration_error_10bin": 0.006541434752745035, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + "J98": { + "valid": 2692, + "positives": 31, + "negatives": 2661, + "auroc": 0.7687262852917288, + "auprc": 0.05400850868738112, + "brier": 0.011177173238832173, + "calibration": { + "observed_rate": 0.011515601783060922, + "mean_prediction": 0.009437201638354188, + "calibration_in_the_large": -0.002078400144706734, + "expected_calibration_error_10bin": 0.0022447861341934605, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + "K04": { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9541284403669725, + "auprc": 0.011622422854062795, + "brier": 0.0007039222935082774, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.000739330471498712, + "calibration_in_the_large": 3.4111853727202836e-05, + "expected_calibration_error_10bin": 3.4111853727202836e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "K12": { + "valid": 2824, + "positives": 13, + "negatives": 2811, + "auroc": 0.8822756752319185, + "auprc": 0.09119655345007954, + "brier": 0.0048477261906219255, + "calibration": { + "observed_rate": 0.004603399433427762, + "mean_prediction": 0.004258686043855313, + "calibration_in_the_large": -0.0003447133895724489, + "expected_calibration_error_10bin": 0.003534846360929464, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K20": { + "valid": 2813, + "positives": 7, + "negatives": 2806, + "auroc": 0.7665716322166786, + "auprc": 0.05132264052605618, + "brier": 0.0024977154969246587, + "calibration": { + "observed_rate": 0.002488446498400284, + "mean_prediction": 0.005650869177946686, + "calibration_in_the_large": 0.003162422679546402, + "expected_calibration_error_10bin": 0.003162422679546402, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K21": { + "valid": 2043, + "positives": 73, + "negatives": 1970, + "auroc": 0.7399485432167443, + "auprc": 0.13168563947577613, + "brier": 0.03302435427203448, + "calibration": { + "observed_rate": 0.03573176700930005, + "mean_prediction": 0.03810668238213015, + "calibration_in_the_large": 0.0023749153728300984, + "expected_calibration_error_10bin": 0.003975545097191688, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + "K22": { + "valid": 2764, + "positives": 15, + "negatives": 2749, + "auroc": 0.7739541651509639, + "auprc": 0.023909342863739066, + "brier": 0.005360191024507653, + "calibration": { + "observed_rate": 0.005426917510853835, + "mean_prediction": 0.004760597325021318, + "calibration_in_the_large": -0.0006663201858325167, + "expected_calibration_error_10bin": 0.0006663201858325167, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + "K25": { + "valid": 2817, + "positives": 6, + "negatives": 2811, + "auroc": 0.7929562433297759, + "auprc": 0.010060322691845069, + "brier": 0.002175012880046203, + "calibration": { + "observed_rate": 0.002129925452609159, + "mean_prediction": 0.0030990634596412127, + "calibration_in_the_large": 0.0009691380070320538, + "expected_calibration_error_10bin": 0.0009691380070320539, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "K26": { + "valid": 2814, + "positives": 5, + "negatives": 2809, + "auroc": 0.9300818796724813, + "auprc": 0.053308597430788564, + "brier": 0.0017535374393633613, + "calibration": { + "observed_rate": 0.0017768301350390902, + "mean_prediction": 0.0016084895393954804, + "calibration_in_the_large": -0.00016834059564360985, + "expected_calibration_error_10bin": 0.00016834059564360985, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "K29": { + "valid": 2785, + "positives": 10, + "negatives": 2775, + "auroc": 0.7567927927927928, + "auprc": 0.021080669050627686, + "brier": 0.003626136996266434, + "calibration": { + "observed_rate": 0.003590664272890485, + "mean_prediction": 0.00744025448771508, + "calibration_in_the_large": 0.0038495902148245947, + "expected_calibration_error_10bin": 0.0038495902148245947, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K30": { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.9261022927689594, + "auprc": 0.006913198350206224, + "brier": 0.0007088167128113148, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0012869245318503266, + "calibration_in_the_large": 0.0005819544930769745, + "expected_calibration_error_10bin": 0.0005819544930769745, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "K31": { + "valid": 2756, + "positives": 17, + "negatives": 2739, + "auroc": 0.9180035650623886, + "auprc": 0.06271827673061463, + "brier": 0.00602406107615895, + "calibration": { + "observed_rate": 0.006168359941944848, + "mean_prediction": 0.005487078886693891, + "calibration_in_the_large": -0.0006812810552509563, + "expected_calibration_error_10bin": 0.0018741944554089183, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "K40": { + "valid": 2827, + "positives": 3, + "negatives": 2824, + "auroc": 0.8911709159584513, + "auprc": 0.006225767482391076, + "brier": 0.0010598656083307529, + "calibration": { + "observed_rate": 0.0010611956137247967, + "mean_prediction": 0.0014919375865594408, + "calibration_in_the_large": 0.0004307419728346441, + "expected_calibration_error_10bin": 0.0004307419728346441, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "K42": { + "valid": 2820, + "positives": 5, + "negatives": 2815, + "auroc": 0.7732859680284192, + "auprc": 0.015279051286753467, + "brier": 0.0017760442172537211, + "calibration": { + "observed_rate": 0.0017730496453900709, + "mean_prediction": 0.0011599441163145058, + "calibration_in_the_large": -0.0006131055290755651, + "expected_calibration_error_10bin": 0.0006904997877556384, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "K43": { + "valid": 2813, + "positives": 5, + "negatives": 2808, + "auroc": 0.805982905982906, + "auprc": 0.013937618762956336, + "brier": 0.001782822621681498, + "calibration": { + "observed_rate": 0.0017774617845716318, + "mean_prediction": 0.002242916531688999, + "calibration_in_the_large": 0.00046545474711736723, + "expected_calibration_error_10bin": 0.00046545474711736723, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K44": { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.6762624445244093, + "auprc": 0.00667417049024611, + "brier": 0.002153727035850765, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.0027547469018282173, + "calibration_in_the_large": 0.0006003483380939267, + "expected_calibration_error_10bin": 0.0006003483380939267, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K52": { + "valid": 2749, + "positives": 33, + "negatives": 2716, + "auroc": 0.8033650198598652, + "auprc": 0.11654424593047814, + "brier": 0.011779197797122052, + "calibration": { + "observed_rate": 0.012004365223717716, + "mean_prediction": 0.011198070909072964, + "calibration_in_the_large": -0.000806294314644752, + "expected_calibration_error_10bin": 0.004187574963912499, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + "K55": { + "valid": 2815, + "positives": 8, + "negatives": 2807, + "auroc": 0.8078909868186677, + "auprc": 0.01031657224481832, + "brier": 0.002859580594389408, + "calibration": { + "observed_rate": 0.002841918294849023, + "mean_prediction": 0.002727134977204816, + "calibration_in_the_large": -0.00011478331764420676, + "expected_calibration_error_10bin": 0.00028436918252266997, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "K56": { + "valid": 2745, + "positives": 27, + "negatives": 2718, + "auroc": 0.756820101926798, + "auprc": 0.048017893524370234, + "brier": 0.009589061067113809, + "calibration": { + "observed_rate": 0.009836065573770493, + "mean_prediction": 0.011314757976902373, + "calibration_in_the_large": 0.0014786924031318805, + "expected_calibration_error_10bin": 0.0017189719988404686, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + "K57": { + "valid": 2741, + "positives": 22, + "negatives": 2719, + "auroc": 0.6868501120064194, + "auprc": 0.02098649403721724, + "brier": 0.00796266480925514, + "calibration": { + "observed_rate": 0.008026267785479753, + "mean_prediction": 0.004336817700752428, + "calibration_in_the_large": -0.0036894500847273245, + "expected_calibration_error_10bin": 0.0037828038644494794, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "K58": { + "valid": 2792, + "positives": 7, + "negatives": 2785, + "auroc": 0.7358809951269556, + "auprc": 0.012852462950230516, + "brier": 0.002501031075184058, + "calibration": { + "observed_rate": 0.002507163323782235, + "mean_prediction": 0.0019336624782435345, + "calibration_in_the_large": -0.0005735008455387007, + "expected_calibration_error_10bin": 0.0005735008455387007, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "K59": { + "valid": 2560, + "positives": 78, + "negatives": 2482, + "auroc": 0.758460918614021, + "auprc": 0.12831599151556952, + "brier": 0.028202619373250703, + "calibration": { + "observed_rate": 0.03046875, + "mean_prediction": 0.026408544154537594, + "calibration_in_the_large": -0.004060205845462406, + "expected_calibration_error_10bin": 0.005230179556247095, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "K62": { + "valid": 2813, + "positives": 14, + "negatives": 2799, + "auroc": 0.8701321900678813, + "auprc": 0.03232471647326763, + "brier": 0.004909881867783546, + "calibration": { + "observed_rate": 0.004976892996800568, + "mean_prediction": 0.0030770489184093657, + "calibration_in_the_large": -0.0018998440783912027, + "expected_calibration_error_10bin": 0.0018998440783912027, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K63": { + "valid": 2810, + "positives": 15, + "negatives": 2795, + "auroc": 0.7248419797257006, + "auprc": 0.012750223975251019, + "brier": 0.005323560539704522, + "calibration": { + "observed_rate": 0.005338078291814947, + "mean_prediction": 0.003766529310100154, + "calibration_in_the_large": -0.0015715489817147927, + "expected_calibration_error_10bin": 0.0015715489817147927, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "K64": { + "valid": 2801, + "positives": 18, + "negatives": 2783, + "auroc": 0.7925899309298519, + "auprc": 0.027487325589311103, + "brier": 0.006429828581409208, + "calibration": { + "observed_rate": 0.006426276329882185, + "mean_prediction": 0.005994055356476831, + "calibration_in_the_large": -0.00043222097340535337, + "expected_calibration_error_10bin": 0.0020322808020069747, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "K65": { + "valid": 2813, + "positives": 12, + "negatives": 2801, + "auroc": 0.8700761632750208, + "auprc": 0.034643019509126884, + "brier": 0.004389304826905788, + "calibration": { + "observed_rate": 0.004265908282971916, + "mean_prediction": 0.007631713348443661, + "calibration_in_the_large": 0.0033658050654717447, + "expected_calibration_error_10bin": 0.0033658050654717447, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K66": { + "valid": 2796, + "positives": 8, + "negatives": 2788, + "auroc": 0.7233231707317073, + "auprc": 0.01806578584622324, + "brier": 0.0028741646370465624, + "calibration": { + "observed_rate": 0.002861230329041488, + "mean_prediction": 0.004121532915197117, + "calibration_in_the_large": 0.0012603025861556288, + "expected_calibration_error_10bin": 0.0012603025861556288, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "K70": { + "valid": 2774, + "positives": 1, + "negatives": 2773, + "auroc": 0.9516768842408944, + "auprc": 0.007407407407407408, + "brier": 0.00037902262080753214, + "calibration": { + "observed_rate": 0.0003604902667627974, + "mean_prediction": 0.0009792144493071604, + "calibration_in_the_large": 0.0006187241825443631, + "expected_calibration_error_10bin": 0.000618724182544363, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "K72": { + "valid": 2787, + "positives": 18, + "negatives": 2769, + "auroc": 0.9551583002287227, + "auprc": 0.2851901730855593, + "brier": 0.005607892131661886, + "calibration": { + "observed_rate": 0.006458557588805167, + "mean_prediction": 0.003715401176677566, + "calibration_in_the_large": -0.002743156412127601, + "expected_calibration_error_10bin": 0.0036194296167859803, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "K74": { + "valid": 2763, + "positives": 7, + "negatives": 2756, + "auroc": 0.9564586357039188, + "auprc": 0.04904158855397245, + "brier": 0.002516182025973436, + "calibration": { + "observed_rate": 0.0025334781035106766, + "mean_prediction": 0.0029764198646134183, + "calibration_in_the_large": 0.0004429417611027417, + "expected_calibration_error_10bin": 0.00044515900044130274, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "K75": { + "valid": 2798, + "positives": 10, + "negatives": 2788, + "auroc": 0.8188665710186513, + "auprc": 0.023051644789940973, + "brier": 0.003562897720330521, + "calibration": { + "observed_rate": 0.0035739814152966403, + "mean_prediction": 0.002411296007241079, + "calibration_in_the_large": -0.0011626854080555612, + "expected_calibration_error_10bin": 0.001430362667466668, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "K76": { + "valid": 2681, + "positives": 29, + "negatives": 2652, + "auroc": 0.7899568315389817, + "auprc": 0.1702687101532421, + "brier": 0.009876591524080663, + "calibration": { + "observed_rate": 0.01081685938082805, + "mean_prediction": 0.00530301180066298, + "calibration_in_the_large": -0.005513847580165069, + "expected_calibration_error_10bin": 0.006114060083560591, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + "K80": { + "valid": 2731, + "positives": 12, + "negatives": 2719, + "auroc": 0.6903579747456172, + "auprc": 0.014190237835022525, + "brier": 0.004370131331214902, + "calibration": { + "observed_rate": 0.004393994873672647, + "mean_prediction": 0.0027642068653481702, + "calibration_in_the_large": -0.001629788008324477, + "expected_calibration_error_10bin": 0.001629788008324477, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + "K81": { + "valid": 2825, + "positives": 5, + "negatives": 2820, + "auroc": 0.8497163120567376, + "auprc": 0.028265266039935972, + "brier": 0.0017556707968574285, + "calibration": { + "observed_rate": 0.0017699115044247787, + "mean_prediction": 0.0013492626886927126, + "calibration_in_the_large": -0.0004206488157320661, + "expected_calibration_error_10bin": 0.0004206488157320661, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "K82": { + "valid": 2824, + "positives": 4, + "negatives": 2820, + "auroc": 0.5837765957446809, + "auprc": 0.0036431545841511207, + "brier": 0.0014183661515589142, + "calibration": { + "observed_rate": 0.00141643059490085, + "mean_prediction": 0.0011100624174182473, + "calibration_in_the_large": -0.0003063681774826026, + "expected_calibration_error_10bin": 0.0003063681774826026, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K83": { + "valid": 2757, + "positives": 11, + "negatives": 2746, + "auroc": 0.8912798781699001, + "auprc": 0.11245701491196387, + "brier": 0.003972811736719489, + "calibration": { + "observed_rate": 0.003989844033369605, + "mean_prediction": 0.004030101797261532, + "calibration_in_the_large": 4.0257763891927284e-05, + "expected_calibration_error_10bin": 0.0022997798212344178, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + "K85": { + "valid": 2779, + "positives": 5, + "negatives": 2774, + "auroc": 0.7719538572458544, + "auprc": 0.02026827530612036, + "brier": 0.001786400242316119, + "calibration": { + "observed_rate": 0.0017992083483267362, + "mean_prediction": 0.001974706257241339, + "calibration_in_the_large": 0.0001754979089146028, + "expected_calibration_error_10bin": 0.0001754979089146028, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + "K86": { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.7046179162809832, + "auprc": 0.0156728402031456, + "brier": 0.002509725624924042, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.003068742713330525, + "calibration_in_the_large": 0.0005552777223071857, + "expected_calibration_error_10bin": 0.0005552777223071857, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K90": { + "valid": 2831, + "positives": 2, + "negatives": 2829, + "auroc": 0.4602332979851538, + "auprc": 0.0009680969845684265, + "brier": 0.0007094868981192162, + "calibration": { + "observed_rate": 0.0007064641469445425, + "mean_prediction": 0.0007996218005649376, + "calibration_in_the_large": 9.315765362039507e-05, + "expected_calibration_error_10bin": 9.315765362039507e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "K91": { + "valid": 2768, + "positives": 22, + "negatives": 2746, + "auroc": 0.8620803813811826, + "auprc": 0.0599961203105432, + "brier": 0.007682467034681423, + "calibration": { + "observed_rate": 0.007947976878612716, + "mean_prediction": 0.007028507391560775, + "calibration_in_the_large": -0.0009194694870519413, + "expected_calibration_error_10bin": 0.0013546141383239906, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "K92": { + "valid": 2751, + "positives": 30, + "negatives": 2721, + "auroc": 0.8710278084037731, + "auprc": 0.09204359659276898, + "brier": 0.01036685807477627, + "calibration": { + "observed_rate": 0.010905125408942203, + "mean_prediction": 0.010054936185990782, + "calibration_in_the_large": -0.0008501892229514207, + "expected_calibration_error_10bin": 0.0009977612234695196, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "K94": { + "valid": 2823, + "positives": 14, + "negatives": 2809, + "auroc": 0.899252402990388, + "auprc": 0.07538267808372323, + "brier": 0.0047889240041410226, + "calibration": { + "observed_rate": 0.00495926319518243, + "mean_prediction": 0.004954087627049464, + "calibration_in_the_large": -5.175568132966511e-06, + "expected_calibration_error_10bin": 0.0008503027426772922, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "L02": { + "valid": 2807, + "positives": 16, + "negatives": 2791, + "auroc": 0.7644437477606593, + "auprc": 0.022537957437215317, + "brier": 0.005635945227127494, + "calibration": { + "observed_rate": 0.0057000356252226575, + "mean_prediction": 0.006165697652412599, + "calibration_in_the_large": 0.00046566202718994164, + "expected_calibration_error_10bin": 0.00046566202718994164, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "L03": { + "valid": 2701, + "positives": 36, + "negatives": 2665, + "auroc": 0.7394830102147175, + "auprc": 0.05362667072944911, + "brier": 0.012963652481229108, + "calibration": { + "observed_rate": 0.013328396890040726, + "mean_prediction": 0.00888982301669558, + "calibration_in_the_large": -0.004438573873345146, + "expected_calibration_error_10bin": 0.004975216342719848, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + "L08": { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.664283185840708, + "auprc": 0.006575477634189986, + "brier": 0.001768348590714543, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.001707024713017385, + "calibration_in_the_large": -5.97597392794347e-05, + "expected_calibration_error_10bin": 5.97597392794347e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + "L27": { + "valid": 2818, + "positives": 9, + "negatives": 2809, + "auroc": 0.7934021597246944, + "auprc": 0.021368694788755516, + "brier": 0.003385365443843775, + "calibration": { + "observed_rate": 0.00319375443577005, + "mean_prediction": 0.00501396915869034, + "calibration_in_the_large": 0.0018202147229202897, + "expected_calibration_error_10bin": 0.0018202147229202902, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "L29": { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.5643212508884151, + "auprc": 0.002868240519896321, + "brier": 0.0011389974738909372, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.0040550065425486274, + "calibration_in_the_large": 0.002990043816244048, + "expected_calibration_error_10bin": 0.002990043816244048, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "L30": { + "valid": 2816, + "positives": 7, + "negatives": 2809, + "auroc": 0.7024360473986675, + "auprc": 0.02125349408315901, + "brier": 0.0024776294583847874, + "calibration": { + "observed_rate": 0.0024857954545454545, + "mean_prediction": 0.002267085490364645, + "calibration_in_the_large": -0.0002187099641808095, + "expected_calibration_error_10bin": 0.0003010433776415247, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "L50": { + "valid": 2835, + "positives": 3, + "negatives": 2832, + "auroc": 0.7521186440677966, + "auprc": 0.010375383773621053, + "brier": 0.0010567979665842104, + "calibration": { + "observed_rate": 0.0010582010582010583, + "mean_prediction": 0.0010776763263708137, + "calibration_in_the_large": 1.9475268169755417e-05, + "expected_calibration_error_10bin": 1.9475268169755417e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + "L53": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 6.813719173698966e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0013058170114555233, + "calibration_in_the_large": 0.0013058170114555233, + "expected_calibration_error_10bin": 0.0013058170114555233, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "L76": { + "valid": 2793, + "positives": 13, + "negatives": 2780, + "auroc": 0.6719977863862756, + "auprc": 0.008831261531783522, + "brier": 0.004665971578894082, + "calibration": { + "observed_rate": 0.004654493376297888, + "mean_prediction": 0.0053355278999294925, + "calibration_in_the_large": 0.0006810345236316047, + "expected_calibration_error_10bin": 0.0006810345236316047, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "L89": { + "valid": 2798, + "positives": 20, + "negatives": 2778, + "auroc": 0.8402627789776818, + "auprc": 0.030941601302051654, + "brier": 0.00709035650632395, + "calibration": { + "observed_rate": 0.007147962830593281, + "mean_prediction": 0.005434083784873095, + "calibration_in_the_large": -0.001713879045720186, + "expected_calibration_error_10bin": 0.002383489410784438, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "L97": { + "valid": 2789, + "positives": 11, + "negatives": 2778, + "auroc": 0.898455396295569, + "auprc": 0.08389830710331753, + "brier": 0.003866873717648669, + "calibration": { + "observed_rate": 0.003944065973467192, + "mean_prediction": 0.005313221801026037, + "calibration_in_the_large": 0.0013691558275588447, + "expected_calibration_error_10bin": 0.0015346678762312605, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "L98": { + "valid": 2824, + "positives": 5, + "negatives": 2819, + "auroc": 0.656261085491309, + "auprc": 0.0053503436141321345, + "brier": 0.0017971498864341677, + "calibration": { + "observed_rate": 0.0017705382436260624, + "mean_prediction": 0.0035722025503501023, + "calibration_in_the_large": 0.00180166430672404, + "expected_calibration_error_10bin": 0.00180166430672404, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "M10": { + "valid": 2713, + "positives": 13, + "negatives": 2700, + "auroc": 0.7972649572649573, + "auprc": 0.04657634635601216, + "brier": 0.0047072468839173065, + "calibration": { + "observed_rate": 0.004791743457427202, + "mean_prediction": 0.005166126892833751, + "calibration_in_the_large": 0.0003743834354065492, + "expected_calibration_error_10bin": 0.00037438343540654865, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + "M16": { + "valid": 2790, + "positives": 3, + "negatives": 2787, + "auroc": 0.910895825858151, + "auprc": 0.014094009075338565, + "brier": 0.0010710220936101585, + "calibration": { + "observed_rate": 0.001075268817204301, + "mean_prediction": 0.0013670697095769493, + "calibration_in_the_large": 0.00029180089237264826, + "expected_calibration_error_10bin": 0.00029180089237264826, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "M17": { + "valid": 2733, + "positives": 9, + "negatives": 2724, + "auroc": 0.7541605482134116, + "auprc": 0.008666152604229064, + "brier": 0.0033066833981609234, + "calibration": { + "observed_rate": 0.003293084522502744, + "mean_prediction": 0.0026029459006039145, + "calibration_in_the_large": -0.0006901386218988296, + "expected_calibration_error_10bin": 0.0006901386218988296, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "M19": { + "valid": 2674, + "positives": 32, + "negatives": 2642, + "auroc": 0.717129542013626, + "auprc": 0.032535100375989764, + "brier": 0.011766220304863382, + "calibration": { + "observed_rate": 0.011967090501121914, + "mean_prediction": 0.010930550653107288, + "calibration_in_the_large": -0.0010365398480146268, + "expected_calibration_error_10bin": 0.0016407949854795683, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + "M21": { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.9769503546099291, + "auprc": 0.015151515151515152, + "brier": 0.0003577341625936809, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0015760025592095035, + "calibration_in_the_large": 0.0012215183337575361, + "expected_calibration_error_10bin": 0.0012215183337575361, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "M25": { + "valid": 2717, + "positives": 31, + "negatives": 2686, + "auroc": 0.6093363437657627, + "auprc": 0.017380799333803643, + "brier": 0.011373137950058287, + "calibration": { + "observed_rate": 0.011409642988590356, + "mean_prediction": 0.011548137811207435, + "calibration_in_the_large": 0.00013849482261707804, + "expected_calibration_error_10bin": 0.0009243495194925237, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + "M35": { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.8846291012838802, + "auprc": 0.004526459081000295, + "brier": 0.0007166089815749642, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0009562706926936087, + "calibration_in_the_large": 0.00024351231778270345, + "expected_calibration_error_10bin": 0.00024351231778270345, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "M46": { + "valid": 2814, + "positives": 4, + "negatives": 2810, + "auroc": 0.6146797153024911, + "auprc": 0.002336428323456023, + "brier": 0.0014278969676082228, + "calibration": { + "observed_rate": 0.0014214641080312722, + "mean_prediction": 0.002068118333275656, + "calibration_in_the_large": 0.0006466542252443839, + "expected_calibration_error_10bin": 0.0006466542252443839, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "M47": { + "valid": 2743, + "positives": 9, + "negatives": 2734, + "auroc": 0.7678208567016175, + "auprc": 0.019739209865872208, + "brier": 0.0032564817631568405, + "calibration": { + "observed_rate": 0.0032810791104629965, + "mean_prediction": 0.0024423414299727495, + "calibration_in_the_large": -0.000838737680490247, + "expected_calibration_error_10bin": 0.000838737680490247, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "M48": { + "valid": 2690, + "positives": 10, + "negatives": 2680, + "auroc": 0.7646641791044776, + "auprc": 0.014565066736689374, + "brier": 0.00371722489110939, + "calibration": { + "observed_rate": 0.0037174721189591076, + "mean_prediction": 0.005382344965319033, + "calibration_in_the_large": 0.0016648728463599253, + "expected_calibration_error_10bin": 0.0016648728463599253, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + "M51": { + "valid": 2785, + "positives": 3, + "negatives": 2782, + "auroc": 0.9279894560268392, + "auprc": 0.011112690515675592, + "brier": 0.0010753257828384148, + "calibration": { + "observed_rate": 0.0010771992818671453, + "mean_prediction": 0.002584113442838314, + "calibration_in_the_large": 0.0015069141609711687, + "expected_calibration_error_10bin": 0.0015069141609711687, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "M54": { + "valid": 2567, + "positives": 39, + "negatives": 2528, + "auroc": 0.7207379909120415, + "auprc": 0.04415535674705508, + "brier": 0.014844893820803133, + "calibration": { + "observed_rate": 0.015192832099727308, + "mean_prediction": 0.014367515794063196, + "calibration_in_the_large": -0.0008253163056641116, + "expected_calibration_error_10bin": 0.001689841264463746, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + "M62": { + "valid": 2781, + "positives": 9, + "negatives": 2772, + "auroc": 0.7479156645823313, + "auprc": 0.014307502274759486, + "brier": 0.0032159072058453105, + "calibration": { + "observed_rate": 0.003236245954692557, + "mean_prediction": 0.0032535716691402686, + "calibration_in_the_large": 1.732571444771182e-05, + "expected_calibration_error_10bin": 1.732571444771182e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "M79": { + "valid": 2697, + "positives": 31, + "negatives": 2666, + "auroc": 0.7729956682719067, + "auprc": 0.039257865620926174, + "brier": 0.011334406183518303, + "calibration": { + "observed_rate": 0.011494252873563218, + "mean_prediction": 0.01392939102466981, + "calibration_in_the_large": 0.0024351381511065924, + "expected_calibration_error_10bin": 0.0024351381511065915, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + "M81": { + "valid": 2705, + "positives": 13, + "negatives": 2692, + "auroc": 0.8059492513430107, + "auprc": 0.04826336190658909, + "brier": 0.004714366469686095, + "calibration": { + "observed_rate": 0.004805914972273568, + "mean_prediction": 0.004718625085295373, + "calibration_in_the_large": -8.728988697819483e-05, + "expected_calibration_error_10bin": 0.0003839442092092975, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + "M84": { + "valid": 2818, + "positives": 5, + "negatives": 2813, + "auroc": 0.7420547458229648, + "auprc": 0.024959542819912754, + "brier": 0.0017781303716541436, + "calibration": { + "observed_rate": 0.0017743080198722497, + "mean_prediction": 0.0026263735602002577, + "calibration_in_the_large": 0.000852065540328008, + "expected_calibration_error_10bin": 0.000852065540328008, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "M85": { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.7192528586950898, + "auprc": 0.00647689615976506, + "brier": 0.002537031803974035, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.003140454917321364, + "calibration_in_the_large": 0.0006115531832173175, + "expected_calibration_error_10bin": 0.0006115531832173175, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "M86": { + "valid": 2803, + "positives": 14, + "negatives": 2789, + "auroc": 0.7885570865133432, + "auprc": 0.050967366769070835, + "brier": 0.004897914849097708, + "calibration": { + "observed_rate": 0.0049946485907955765, + "mean_prediction": 0.0036374568971808026, + "calibration_in_the_large": -0.001357191693614774, + "expected_calibration_error_10bin": 0.0020630852594040903, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + "M94": { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7636126893939394, + "auprc": 0.003357757144261845, + "brier": 0.0010637336633478357, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.00035809125479429335, + "calibration_in_the_large": -0.0007061159108672887, + "expected_calibration_error_10bin": 0.0007061159108672887, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "M96": { + "valid": 2804, + "positives": 3, + "negatives": 2801, + "auroc": 0.8732595501606569, + "auprc": 0.0062684788545713105, + "brier": 0.0010801478745724412, + "calibration": { + "observed_rate": 0.0010699001426533524, + "mean_prediction": 0.002987466586230438, + "calibration_in_the_large": 0.0019175664435770858, + "expected_calibration_error_10bin": 0.0019175664435770858, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "N12": { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.6701740186159449, + "auprc": 0.0064582214294965365, + "brier": 0.0024762095816399086, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.0018516473862706998, + "calibration_in_the_large": -0.0006209771280351994, + "expected_calibration_error_10bin": 0.0006209771280351994, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N13": { + "valid": 2756, + "positives": 15, + "negatives": 2741, + "auroc": 0.6783169159674085, + "auprc": 0.03790687838198017, + "brier": 0.00536940295354665, + "calibration": { + "observed_rate": 0.00544267053701016, + "mean_prediction": 0.004630450986088179, + "calibration_in_the_large": -0.0008122195509219802, + "expected_calibration_error_10bin": 0.0008122195509219802, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "N14": { + "valid": 2826, + "positives": 7, + "negatives": 2819, + "auroc": 0.876703998378351, + "auprc": 0.019500498155803535, + "brier": 0.002461951244578017, + "calibration": { + "observed_rate": 0.0024769992922859165, + "mean_prediction": 0.0015275205611587853, + "calibration_in_the_large": -0.0009494787311271312, + "expected_calibration_error_10bin": 0.0009494787311271312, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "N17": { + "valid": 2292, + "positives": 83, + "negatives": 2209, + "auroc": 0.7991676984079369, + "auprc": 0.141418398860244, + "brier": 0.033344495806511464, + "calibration": { + "observed_rate": 0.036212914485165795, + "mean_prediction": 0.038828220667599306, + "calibration_in_the_large": 0.0026153061824335105, + "expected_calibration_error_10bin": 0.0064505665487316, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + "N18": { + "valid": 2440, + "positives": 41, + "negatives": 2399, + "auroc": 0.8571355951158511, + "auprc": 0.16051332521869816, + "brier": 0.015468031455305033, + "calibration": { + "observed_rate": 0.01680327868852459, + "mean_prediction": 0.010624468845159501, + "calibration_in_the_large": -0.006178809843365088, + "expected_calibration_error_10bin": 0.00617880984336509, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + "N20": { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7393674052894925, + "auprc": 0.006322511123399417, + "brier": 0.0028464016250954152, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.001112454216208614, + "calibration_in_the_large": -0.0017385792834350069, + "expected_calibration_error_10bin": 0.0017385792834350069, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "N25": { + "valid": 2831, + "positives": 6, + "negatives": 2825, + "auroc": 0.95929203539823, + "auprc": 0.09729302832244009, + "brier": 0.002070626076000068, + "calibration": { + "observed_rate": 0.0021193924408336277, + "mean_prediction": 0.0011727308594042603, + "calibration_in_the_large": -0.0009466615814293674, + "expected_calibration_error_10bin": 0.0010364113753077052, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N28": { + "valid": 2789, + "positives": 6, + "negatives": 2783, + "auroc": 0.8036890645586298, + "auprc": 0.009878470589506907, + "brier": 0.002159116883574498, + "calibration": { + "observed_rate": 0.002151308712800287, + "mean_prediction": 0.00423665032368615, + "calibration_in_the_large": 0.002085341610885863, + "expected_calibration_error_10bin": 0.002085341610885863, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "N30": { + "valid": 2829, + "positives": 10, + "negatives": 2819, + "auroc": 0.7033699893579284, + "auprc": 0.01230264442079076, + "brier": 0.0035663059715493905, + "calibration": { + "observed_rate": 0.003534817956875221, + "mean_prediction": 0.003713088547981585, + "calibration_in_the_large": 0.00017827059110636385, + "expected_calibration_error_10bin": 0.00017827059110636406, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N32": { + "valid": 2807, + "positives": 11, + "negatives": 2796, + "auroc": 0.8174014826375341, + "auprc": 0.13084322358970088, + "brier": 0.003793039621547043, + "calibration": { + "observed_rate": 0.003918774492340577, + "mean_prediction": 0.0040371778936740465, + "calibration_in_the_large": 0.0001184034013334695, + "expected_calibration_error_10bin": 0.0007539705686594015, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "N39": { + "valid": 2520, + "positives": 74, + "negatives": 2446, + "auroc": 0.7590439990276457, + "auprc": 0.08314661449392141, + "brier": 0.02798870092766588, + "calibration": { + "observed_rate": 0.029365079365079365, + "mean_prediction": 0.03326933259280243, + "calibration_in_the_large": 0.003904253227723066, + "expected_calibration_error_10bin": 0.0039042532277230673, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + "N40": { + "valid": 2606, + "positives": 19, + "negatives": 2587, + "auroc": 0.7996460032958314, + "auprc": 0.03799924809257864, + "brier": 0.00720276969263034, + "calibration": { + "observed_rate": 0.0072908672294704525, + "mean_prediction": 0.009201647412665763, + "calibration_in_the_large": 0.0019107801831953104, + "expected_calibration_error_10bin": 0.0019107801831953093, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + "N73": { + "valid": 2829, + "positives": 4, + "negatives": 2825, + "auroc": 0.9685840707964601, + "auprc": 0.048579707232103975, + "brier": 0.001391497086021536, + "calibration": { + "observed_rate": 0.0014139271827500884, + "mean_prediction": 0.0009776462672064382, + "calibration_in_the_large": -0.00043628091554365027, + "expected_calibration_error_10bin": 0.00043628091554365027, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N99": { + "valid": 2799, + "positives": 5, + "negatives": 2794, + "auroc": 0.7705082319255547, + "auprc": 0.009767069933369184, + "brier": 0.001781893052052315, + "calibration": { + "observed_rate": 0.0017863522686673813, + "mean_prediction": 0.0017337133081067719, + "calibration_in_the_large": -5.2638960560609386e-05, + "expected_calibration_error_10bin": 5.2638960560609386e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + "O69": { + "valid": 2743, + "positives": 6, + "negatives": 2737, + "auroc": 0.9962854707100232, + "auprc": 0.34296259296259296, + "brier": 0.002045309920998532, + "calibration": { + "observed_rate": 0.002187386073641998, + "mean_prediction": 0.0004334055363667238, + "calibration_in_the_large": -0.001753980537275274, + "expected_calibration_error_10bin": 0.0019476824971745253, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "O99": { + "valid": 2652, + "positives": 1, + "negatives": 2651, + "auroc": 0.999622783855149, + "auprc": 0.5, + "brier": 0.00023903423186864804, + "calibration": { + "observed_rate": 0.0003770739064856712, + "mean_prediction": 0.00045970783163862104, + "calibration_in_the_large": 8.263392515294983e-05, + "expected_calibration_error_10bin": 0.0004356429058176821, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + "Q21": { + "valid": 2810, + "positives": 3, + "negatives": 2807, + "auroc": 0.5810473815461347, + "auprc": 0.0029225081715307673, + "brier": 0.0010670953038127036, + "calibration": { + "observed_rate": 0.0010676156583629894, + "mean_prediction": 0.0011296221338153662, + "calibration_in_the_large": 6.200647545237677e-05, + "expected_calibration_error_10bin": 6.200647545237677e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "U07": { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 3.966669333941653e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0030796757905893527, + "calibration_in_the_large": 0.0030796757905893527, + "expected_calibration_error_10bin": 0.003079675790589353, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + } + }, + "270": { + "A04": { + "valid": 2782, + "positives": 25, + "negatives": 2757, + "auroc": 0.7561697497279651, + "auprc": 0.05161498480224061, + "brier": 0.008808987677562746, + "calibration": { + "observed_rate": 0.008986340762041696, + "mean_prediction": 0.009168448508602043, + "calibration_in_the_large": 0.00018210774656034732, + "expected_calibration_error_10bin": 0.0003975560421291992, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "A08": { + "valid": 2818, + "positives": 11, + "negatives": 2807, + "auroc": 0.8115749587071283, + "auprc": 0.02866498317898546, + "brier": 0.0038529528236185243, + "calibration": { + "observed_rate": 0.0039034776437189495, + "mean_prediction": 0.0042841379618684845, + "calibration_in_the_large": 0.00038066031814953504, + "expected_calibration_error_10bin": 0.00038066031814953445, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "A41": { + "valid": 2664, + "positives": 63, + "negatives": 2601, + "auroc": 0.7540201265691462, + "auprc": 0.07632669273712227, + "brier": 0.02287543591017794, + "calibration": { + "observed_rate": 0.02364864864864865, + "mean_prediction": 0.026289502764435334, + "calibration_in_the_large": 0.002640854115786684, + "expected_calibration_error_10bin": 0.006513190882066516, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + "B00": { + "valid": 2819, + "positives": 4, + "negatives": 2815, + "auroc": 0.6680284191829485, + "auprc": 0.015232618046882265, + "brier": 0.0014569723465387924, + "calibration": { + "observed_rate": 0.001418942887548776, + "mean_prediction": 0.001776835146872302, + "calibration_in_the_large": 0.0003578922593235258, + "expected_calibration_error_10bin": 0.00035789225932352577, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "B02": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.8054474708171206, + "auprc": 0.0018148820326678765, + "brier": 0.0003571135151789423, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0009158834667239516, + "calibration_in_the_large": 0.0005622766774735981, + "expected_calibration_error_10bin": 0.0005622766774735981, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "B18": { + "valid": 2782, + "positives": 7, + "negatives": 2775, + "auroc": 0.940952380952381, + "auprc": 0.0777177750374691, + "brier": 0.00243796317659309, + "calibration": { + "observed_rate": 0.0025161754133716753, + "mean_prediction": 0.0012504372261618367, + "calibration_in_the_large": -0.0012657381872098385, + "expected_calibration_error_10bin": 0.001416256519724817, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "B19": { + "valid": 2763, + "positives": 17, + "negatives": 2746, + "auroc": 0.8573968553189666, + "auprc": 0.07562404485433917, + "brier": 0.006005503730698629, + "calibration": { + "observed_rate": 0.006152732537097358, + "mean_prediction": 0.0018813716797038936, + "calibration_in_the_large": -0.0042713608573934645, + "expected_calibration_error_10bin": 0.004491832441280013, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "B20": { + "valid": 2829, + "positives": 5, + "negatives": 2824, + "auroc": 0.9878895184135977, + "auprc": 0.2421253071253071, + "brier": 0.0017363294362197487, + "calibration": { + "observed_rate": 0.0017674089784376105, + "mean_prediction": 0.00028044855551106123, + "calibration_in_the_large": -0.0014869604229265493, + "expected_calibration_error_10bin": 0.0015650898973833928, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "B34": { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.9790516631280962, + "auprc": 0.11483153809597435, + "brier": 0.001706387100247172, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0014750985724869417, + "calibration_in_the_large": -0.00029106179487441456, + "expected_calibration_error_10bin": 0.00037097450113129574, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "B35": { + "valid": 2836, + "positives": 1, + "negatives": 2835, + "auroc": 0.7791887125220458, + "auprc": 0.001594896331738437, + "brier": 0.00036635700524052957, + "calibration": { + "observed_rate": 0.0003526093088857546, + "mean_prediction": 0.0017648920820121676, + "calibration_in_the_large": 0.001412282773126413, + "expected_calibration_error_10bin": 0.001412282773126413, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "B37": { + "valid": 2768, + "positives": 34, + "negatives": 2734, + "auroc": 0.7686109557209863, + "auprc": 0.03944031367290314, + "brier": 0.012083800221260309, + "calibration": { + "observed_rate": 0.012283236994219654, + "mean_prediction": 0.009781964186324878, + "calibration_in_the_large": -0.002501272807894776, + "expected_calibration_error_10bin": 0.0049533241018394686, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "B95": { + "valid": 2678, + "positives": 56, + "negatives": 2622, + "auroc": 0.7142652827721477, + "auprc": 0.04457989895293635, + "brier": 0.020613518025292498, + "calibration": { + "observed_rate": 0.020911127707244213, + "mean_prediction": 0.022481182807308077, + "calibration_in_the_large": 0.0015700551000638642, + "expected_calibration_error_10bin": 0.004488575907112493, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + "B96": { + "valid": 2630, + "positives": 74, + "negatives": 2556, + "auroc": 0.7578247261345853, + "auprc": 0.09035135164057617, + "brier": 0.02673514825753859, + "calibration": { + "observed_rate": 0.028136882129277566, + "mean_prediction": 0.03121341411084089, + "calibration_in_the_large": 0.003076531981563324, + "expected_calibration_error_10bin": 0.003640413349348265, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + "B97": { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.8830502476999292, + "auprc": 0.06402439024390244, + "brier": 0.0007066708712084695, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.001030474308866153, + "calibration_in_the_large": 0.00032326073036544566, + "expected_calibration_error_10bin": 0.0003232607303654456, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "C18": { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9780297661233168, + "auprc": 0.03434579439252337, + "brier": 0.0007026516398527892, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0006670086449082034, + "calibration_in_the_large": -4.120665254222155e-05, + "expected_calibration_error_10bin": 4.120665254222155e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "C22": { + "valid": 2812, + "positives": 6, + "negatives": 2806, + "auroc": 0.9106676170111665, + "auprc": 0.054608543603672094, + "brier": 0.002097318476371525, + "calibration": { + "observed_rate": 0.0021337126600284497, + "mean_prediction": 0.0007932402958315551, + "calibration_in_the_large": -0.0013404723641968945, + "expected_calibration_error_10bin": 0.0013404723641968945, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + "C25": { + "valid": 2809, + "positives": 3, + "negatives": 2806, + "auroc": 0.9542646709432169, + "auprc": 0.12404003267973857, + "brier": 0.0010352626635887136, + "calibration": { + "observed_rate": 0.001067995728017088, + "mean_prediction": 0.0005779991475532258, + "calibration_in_the_large": -0.0004899965804638622, + "expected_calibration_error_10bin": 0.0005976452425434693, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "C61": { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9675347841598287, + "auprc": 0.017884674683934627, + "brier": 0.0007118522832717488, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0011228692085208287, + "calibration_in_the_large": 0.00040985673080246867, + "expected_calibration_error_10bin": 0.00040985673080246867, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "C67": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9495932083480721, + "auprc": 0.02648667122351333, + "brier": 0.0007037393851275729, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0007659688516722687, + "calibration_in_the_large": 5.9005260297224525e-05, + "expected_calibration_error_10bin": 5.9005260297224525e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "C77": { + "valid": 2762, + "positives": 20, + "negatives": 2742, + "auroc": 0.8640773158278628, + "auprc": 0.1392395659858207, + "brier": 0.006805641422517435, + "calibration": { + "observed_rate": 0.00724112961622013, + "mean_prediction": 0.004179705685133631, + "calibration_in_the_large": -0.0030614239310864993, + "expected_calibration_error_10bin": 0.003798023310480279, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C78": { + "valid": 2762, + "positives": 28, + "negatives": 2734, + "auroc": 0.8685599331173581, + "auprc": 0.1486860494487457, + "brier": 0.009395423324219578, + "calibration": { + "observed_rate": 0.010137581462708182, + "mean_prediction": 0.006402739009950671, + "calibration_in_the_large": -0.0037348424527575115, + "expected_calibration_error_10bin": 0.005375638304875167, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C79": { + "valid": 2751, + "positives": 23, + "negatives": 2728, + "auroc": 0.8917187300777764, + "auprc": 0.16320547199553243, + "brier": 0.00836540918243974, + "calibration": { + "observed_rate": 0.008360596146855689, + "mean_prediction": 0.008887117064426426, + "calibration_in_the_large": 0.0005265209175707372, + "expected_calibration_error_10bin": 0.004453529724587719, + "nonempty_bins": 8 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "C83": { + "valid": 2820, + "positives": 1, + "negatives": 2819, + "auroc": 0.0358283079106066, + "auprc": 0.0003677822728944465, + "brier": 0.0003719726250668387, + "calibration": { + "observed_rate": 0.0003546099290780142, + "mean_prediction": 0.0005033430904082152, + "calibration_in_the_large": 0.00014873316133020095, + "expected_calibration_error_10bin": 0.00014873316133020103, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "D25": { + "valid": 2792, + "positives": 3, + "negatives": 2789, + "auroc": 0.9585275487032389, + "auprc": 0.6695238095238095, + "brier": 0.001053299506295539, + "calibration": { + "observed_rate": 0.0010744985673352436, + "mean_prediction": 0.0004860030475138724, + "calibration_in_the_large": -0.0005884955198213711, + "expected_calibration_error_10bin": 0.0005884955198213711, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "D47": { + "valid": 2796, + "positives": 9, + "negatives": 2787, + "auroc": 0.680181796435833, + "auprc": 0.006674493098108279, + "brier": 0.0033119965928128207, + "calibration": { + "observed_rate": 0.003218884120171674, + "mean_prediction": 0.005003167089034963, + "calibration_in_the_large": 0.001784282968863289, + "expected_calibration_error_10bin": 0.0017842829688632885, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "D50": { + "valid": 2663, + "positives": 50, + "negatives": 2613, + "auroc": 0.7835591274397244, + "auprc": 0.10032770063604297, + "brier": 0.017653545016981357, + "calibration": { + "observed_rate": 0.01877581674802854, + "mean_prediction": 0.015663025196568415, + "calibration_in_the_large": -0.0031127915514601243, + "expected_calibration_error_10bin": 0.003281482197553264, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + "D53": { + "valid": 2805, + "positives": 16, + "negatives": 2789, + "auroc": 0.8177438149874507, + "auprc": 0.025980368881329815, + "brier": 0.005791550154143512, + "calibration": { + "observed_rate": 0.00570409982174688, + "mean_prediction": 0.006301415642771325, + "calibration_in_the_large": 0.0005973158210244448, + "expected_calibration_error_10bin": 0.0013137139723374853, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "D59": { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9828863796753705, + "auprc": 0.029857397504456328, + "brier": 0.0006999202423084635, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0007895136208959442, + "calibration_in_the_large": 8.429500312443503e-05, + "expected_calibration_error_10bin": 8.429500312443503e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "D61": { + "valid": 2773, + "positives": 33, + "negatives": 2740, + "auroc": 0.903605397036054, + "auprc": 0.2592953964965838, + "brier": 0.010049025775629375, + "calibration": { + "observed_rate": 0.011900468806346917, + "mean_prediction": 0.010209851687153111, + "calibration_in_the_large": -0.001690617119193806, + "expected_calibration_error_10bin": 0.0027767549990472726, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "D62": { + "valid": 2499, + "positives": 64, + "negatives": 2435, + "auroc": 0.794276180698152, + "auprc": 0.07661247285438731, + "brier": 0.024370193941723437, + "calibration": { + "observed_rate": 0.025610244097639057, + "mean_prediction": 0.023553841725541872, + "calibration_in_the_large": -0.0020564023720971852, + "expected_calibration_error_10bin": 0.0045147047738875205, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + "D63": { + "valid": 2686, + "positives": 71, + "negatives": 2615, + "auroc": 0.8616648264347077, + "auprc": 0.13550112982161477, + "brier": 0.024617585670419075, + "calibration": { + "observed_rate": 0.02643335815338794, + "mean_prediction": 0.023394826129928794, + "calibration_in_the_large": -0.0030385320234591444, + "expected_calibration_error_10bin": 0.00948523963163879, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + "D64": { + "valid": 2434, + "positives": 107, + "negatives": 2327, + "auroc": 0.8038788862158569, + "auprc": 0.18715511106969346, + "brier": 0.03898023204564764, + "calibration": { + "observed_rate": 0.04396055875102712, + "mean_prediction": 0.04609457375661561, + "calibration_in_the_large": 0.002134015005588491, + "expected_calibration_error_10bin": 0.0061293578851698656, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + "D65": { + "valid": 2833, + "positives": 4, + "negatives": 2829, + "auroc": 0.9610286320254506, + "auprc": 0.021319861549424817, + "brier": 0.0014094756984508862, + "calibration": { + "observed_rate": 0.0014119308153900459, + "mean_prediction": 0.0009975111955010578, + "calibration_in_the_large": -0.0004144196198889881, + "expected_calibration_error_10bin": 0.0004144196198889881, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + "D68": { + "valid": 2682, + "positives": 54, + "negatives": 2628, + "auroc": 0.8100090196741643, + "auprc": 0.12608367153523842, + "brier": 0.018895403469514953, + "calibration": { + "observed_rate": 0.020134228187919462, + "mean_prediction": 0.012533582248744964, + "calibration_in_the_large": -0.007600645939174498, + "expected_calibration_error_10bin": 0.008991289729260967, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + "D69": { + "valid": 2586, + "positives": 75, + "negatives": 2511, + "auroc": 0.835433426257799, + "auprc": 0.24355631262200178, + "brier": 0.024759226518027217, + "calibration": { + "observed_rate": 0.029002320185614848, + "mean_prediction": 0.021374217220416405, + "calibration_in_the_large": -0.007628102965198443, + "expected_calibration_error_10bin": 0.008339417477898958, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + "D70": { + "valid": 2787, + "positives": 26, + "negatives": 2761, + "auroc": 0.9038809795781907, + "auprc": 0.24276565592644517, + "brier": 0.008773308400989183, + "calibration": { + "observed_rate": 0.009329027628274129, + "mean_prediction": 0.008444075931239263, + "calibration_in_the_large": -0.0008849516970348657, + "expected_calibration_error_10bin": 0.006595929930425649, + "nonempty_bins": 9 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "D72": { + "valid": 2595, + "positives": 58, + "negatives": 2537, + "auroc": 0.707195574463458, + "auprc": 0.058582896654353116, + "brier": 0.021590995008624304, + "calibration": { + "observed_rate": 0.022350674373795763, + "mean_prediction": 0.023394864228166466, + "calibration_in_the_large": 0.0010441898543707036, + "expected_calibration_error_10bin": 0.001044189854370708, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + "D73": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.82642089093702, + "auprc": 0.021297797041504137, + "brier": 0.0010811532089998043, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0014849677370424197, + "calibration_in_the_large": 0.00042264479086678223, + "expected_calibration_error_10bin": 0.00042264479086678256, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "D75": { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.8779625044216484, + "auprc": 0.00687611705553047, + "brier": 0.0014141955430232063, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.001376199860362065, + "calibration_in_the_large": -3.672843352702003e-05, + "expected_calibration_error_10bin": 3.672843352702003e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "D80": { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.9882637414484549, + "auprc": 0.09587728108526071, + "brier": 0.0021041472332200785, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.0019524769029983277, + "calibration_in_the_large": -0.0001661671647982825, + "expected_calibration_error_10bin": 0.0013810799048173642, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "D89": { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.8409171075837742, + "auprc": 0.0074621212121212125, + "brier": 0.0008869543775689438, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0010705465127618615, + "calibration_in_the_large": 0.0003655764739885094, + "expected_calibration_error_10bin": 0.0008790750861023955, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "E03": { + "valid": 2480, + "positives": 22, + "negatives": 2458, + "auroc": 0.7193024631999408, + "auprc": 0.023902159286498314, + "brier": 0.00875485414862613, + "calibration": { + "observed_rate": 0.008870967741935484, + "mean_prediction": 0.005766959152594697, + "calibration_in_the_large": -0.0031040085893407872, + "expected_calibration_error_10bin": 0.0031040085893407872, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + "E04": { + "valid": 2775, + "positives": 11, + "negatives": 2764, + "auroc": 0.68382449677674, + "auprc": 0.009220861353869882, + "brier": 0.003958883294681375, + "calibration": { + "observed_rate": 0.003963963963963964, + "mean_prediction": 0.00337470388868488, + "calibration_in_the_large": -0.000589260075279084, + "expected_calibration_error_10bin": 0.000589260075279084, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "E05": { + "valid": 2806, + "positives": 4, + "negatives": 2802, + "auroc": 0.4719842969307637, + "auprc": 0.03691281953734751, + "brier": 0.0014205780041212663, + "calibration": { + "observed_rate": 0.0014255167498218105, + "mean_prediction": 0.0012572742792547273, + "calibration_in_the_large": -0.00016824247056708322, + "expected_calibration_error_10bin": 0.00016824247056708322, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "E11": { + "valid": 2194, + "positives": 19, + "negatives": 2175, + "auroc": 0.8039685420447671, + "auprc": 0.060374989972309556, + "brier": 0.008438955524664914, + "calibration": { + "observed_rate": 0.008659981768459436, + "mean_prediction": 0.007413442606301558, + "calibration_in_the_large": -0.001246539162157878, + "expected_calibration_error_10bin": 0.0012465391621578764, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + "E16": { + "valid": 2816, + "positives": 8, + "negatives": 2808, + "auroc": 0.6957353988603988, + "auprc": 0.007873609072984379, + "brier": 0.002839975741098533, + "calibration": { + "observed_rate": 0.002840909090909091, + "mean_prediction": 0.002730697207919196, + "calibration_in_the_large": -0.00011021188298989499, + "expected_calibration_error_10bin": 0.00011021188298989499, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "E21": { + "valid": 2814, + "positives": 3, + "negatives": 2811, + "auroc": 0.9426064271315072, + "auprc": 0.02239881459830309, + "brier": 0.0010743243389627892, + "calibration": { + "observed_rate": 0.0010660980810234541, + "mean_prediction": 0.0017693632299211179, + "calibration_in_the_large": 0.0007032651488976637, + "expected_calibration_error_10bin": 0.0007032651488976637, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "E22": { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.8213390619405657, + "auprc": 0.017966985831840553, + "brier": 0.0032557172265707413, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.005747002785096762, + "calibration_in_the_large": 0.0025350113504072546, + "expected_calibration_error_10bin": 0.0025350113504072546, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "E27": { + "valid": 2811, + "positives": 7, + "negatives": 2804, + "auroc": 0.8155186468310577, + "auprc": 0.008637453660872662, + "brier": 0.002501039097724582, + "calibration": { + "observed_rate": 0.0024902170046246885, + "mean_prediction": 0.0024638778244443025, + "calibration_in_the_large": -2.6339180180386026e-05, + "expected_calibration_error_10bin": 2.6339180180386026e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + }, + "E43": { + "valid": 2748, + "positives": 36, + "negatives": 2712, + "auroc": 0.8163409537856441, + "auprc": 0.07293536797058767, + "brier": 0.012748013750575793, + "calibration": { + "observed_rate": 0.013100436681222707, + "mean_prediction": 0.014519421344626275, + "calibration_in_the_large": 0.001418984663403568, + "expected_calibration_error_10bin": 0.0022250619773222418, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + "E44": { + "valid": 2800, + "positives": 19, + "negatives": 2781, + "auroc": 0.7899657449989591, + "auprc": 0.024348116874906737, + "brier": 0.006853117478994971, + "calibration": { + "observed_rate": 0.0067857142857142855, + "mean_prediction": 0.009362609162729183, + "calibration_in_the_large": 0.002576894877014898, + "expected_calibration_error_10bin": 0.002576894877014898, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "E46": { + "valid": 2772, + "positives": 35, + "negatives": 2737, + "auroc": 0.8230700976042591, + "auprc": 0.0815468374941293, + "brier": 0.012164244877204114, + "calibration": { + "observed_rate": 0.012626262626262626, + "mean_prediction": 0.0137483059388457, + "calibration_in_the_large": 0.0011220433125830737, + "expected_calibration_error_10bin": 0.001266101978215881, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + "E53": { + "valid": 2804, + "positives": 7, + "negatives": 2797, + "auroc": 0.6379794677971296, + "auprc": 0.004339141242057012, + "brier": 0.002520536337384871, + "calibration": { + "observed_rate": 0.0024964336661911554, + "mean_prediction": 0.0028844796182415987, + "calibration_in_the_large": 0.0003880459520504433, + "expected_calibration_error_10bin": 0.0003880459520504433, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "E55": { + "valid": 2737, + "positives": 26, + "negatives": 2711, + "auroc": 0.6098516017365151, + "auprc": 0.014491627247545612, + "brier": 0.009613140568840222, + "calibration": { + "observed_rate": 0.009499451954694921, + "mean_prediction": 0.011269388629498207, + "calibration_in_the_large": 0.001769936674803286, + "expected_calibration_error_10bin": 0.0017699366748032874, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + "E66": { + "valid": 2371, + "positives": 36, + "negatives": 2335, + "auroc": 0.7368665239114918, + "auprc": 0.05033159350697519, + "brier": 0.014767002064757631, + "calibration": { + "observed_rate": 0.015183466891606916, + "mean_prediction": 0.014184976196498266, + "calibration_in_the_large": -0.0009984906951086506, + "expected_calibration_error_10bin": 0.0025006434584126016, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + "E78": { + "valid": 1572, + "positives": 39, + "negatives": 1533, + "auroc": 0.7355277903223109, + "auprc": 0.10543439239611627, + "brier": 0.024540842764663406, + "calibration": { + "observed_rate": 0.02480916030534351, + "mean_prediction": 0.02967148892747051, + "calibration_in_the_large": 0.004862328622126998, + "expected_calibration_error_10bin": 0.008524468736844518, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + "E80": { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.874866879659212, + "auprc": 0.02271378514775874, + "brier": 0.002149192247971112, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0022578353959297384, + "calibration_in_the_large": 0.00013243688370869703, + "expected_calibration_error_10bin": 0.00033894319795114774, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "E83": { + "valid": 2653, + "positives": 74, + "negatives": 2579, + "auroc": 0.8123198809511334, + "auprc": 0.18781569444796334, + "brier": 0.024891870809010726, + "calibration": { + "observed_rate": 0.02789295137580098, + "mean_prediction": 0.02183465907309198, + "calibration_in_the_large": -0.006058292302709, + "expected_calibration_error_10bin": 0.006462773915531715, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + "E86": { + "valid": 2587, + "positives": 85, + "negatives": 2502, + "auroc": 0.7831005783608408, + "auprc": 0.10654284920305492, + "brier": 0.030932539617374466, + "calibration": { + "observed_rate": 0.032856590645535366, + "mean_prediction": 0.040145927785581126, + "calibration_in_the_large": 0.00728933714004576, + "expected_calibration_error_10bin": 0.007289337140045757, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + "E87": { + "valid": 2185, + "positives": 138, + "negatives": 2047, + "auroc": 0.7919967715214206, + "auprc": 0.2179337536894848, + "brier": 0.05432084383368681, + "calibration": { + "observed_rate": 0.06315789473684211, + "mean_prediction": 0.05116627707846198, + "calibration_in_the_large": -0.011991617658380124, + "expected_calibration_error_10bin": 0.015319040596956126, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + "E88": { + "valid": 2817, + "positives": 12, + "negatives": 2805, + "auroc": 0.8049613784907903, + "auprc": 0.08369593698351369, + "brier": 0.004132108622222519, + "calibration": { + "observed_rate": 0.004259850905218318, + "mean_prediction": 0.003516079664968553, + "calibration_in_the_large": -0.0007437712402497648, + "expected_calibration_error_10bin": 0.0009038622014335367, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "E89": { + "valid": 2780, + "positives": 8, + "negatives": 2772, + "auroc": 0.5975378787878788, + "auprc": 0.004005576677629431, + "brier": 0.0028832509839809505, + "calibration": { + "observed_rate": 0.0028776978417266188, + "mean_prediction": 0.003259345164657369, + "calibration_in_the_large": 0.00038164732293075043, + "expected_calibration_error_10bin": 0.00038164732293075043, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "F02": { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8093280914939243, + "auprc": 0.006052226072247383, + "brier": 0.001487120503498938, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.0028324120990970507, + "calibration_in_the_large": 0.0014048603503461585, + "expected_calibration_error_10bin": 0.0014048603503461585, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "F03": { + "valid": 2739, + "positives": 14, + "negatives": 2725, + "auroc": 0.8484141546526868, + "auprc": 0.02529790598483476, + "brier": 0.005222637323653796, + "calibration": { + "observed_rate": 0.00511135450894487, + "mean_prediction": 0.0072568870560988435, + "calibration_in_the_large": 0.0021455325471539735, + "expected_calibration_error_10bin": 0.0021455325471539735, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "F05": { + "valid": 2750, + "positives": 28, + "negatives": 2722, + "auroc": 0.7088669045869633, + "auprc": 0.020531750577856372, + "brier": 0.010436707293725757, + "calibration": { + "observed_rate": 0.010181818181818183, + "mean_prediction": 0.012918316355504264, + "calibration_in_the_large": 0.0027364981736860815, + "expected_calibration_error_10bin": 0.0027364981736860824, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "F06": { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7070063694267515, + "auprc": 0.0017611606392440074, + "brier": 0.0007285593846643912, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.002651432421609372, + "calibration_in_the_large": 0.0019442188431086646, + "expected_calibration_error_10bin": 0.0019442188431086646, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "F10": { + "valid": 2560, + "positives": 16, + "negatives": 2544, + "auroc": 0.8013217374213837, + "auprc": 0.10771336861186917, + "brier": 0.006010184840041561, + "calibration": { + "observed_rate": 0.00625, + "mean_prediction": 0.008189301666595839, + "calibration_in_the_large": 0.0019393016665958385, + "expected_calibration_error_10bin": 0.0023802921723358856, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "F11": { + "valid": 2741, + "positives": 9, + "negatives": 2732, + "auroc": 0.8597689930047178, + "auprc": 0.03154416710840984, + "brier": 0.0033215670006712518, + "calibration": { + "observed_rate": 0.003283473184968989, + "mean_prediction": 0.004402013048827034, + "calibration_in_the_large": 0.001118539863858045, + "expected_calibration_error_10bin": 0.001118539863858045, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "F12": { + "valid": 2777, + "positives": 12, + "negatives": 2765, + "auroc": 0.8964737793851718, + "auprc": 0.02565779324845498, + "brier": 0.004273990059032741, + "calibration": { + "observed_rate": 0.004321209938782859, + "mean_prediction": 0.0035551182258492945, + "calibration_in_the_large": -0.0007660917129335646, + "expected_calibration_error_10bin": 0.0008416335600986932, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "F14": { + "valid": 2787, + "positives": 10, + "negatives": 2777, + "auroc": 0.9505221462009362, + "auprc": 0.04901292615797006, + "brier": 0.0035390569144883965, + "calibration": { + "observed_rate": 0.003588087549336204, + "mean_prediction": 0.0014322032450231547, + "calibration_in_the_large": -0.002155884304313049, + "expected_calibration_error_10bin": 0.002155884304313049, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "F15": { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.9593539226127086, + "auprc": 0.045026533411905774, + "brier": 0.00210426639111829, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0006022963206962164, + "calibration_in_the_large": -0.0015231021915248248, + "expected_calibration_error_10bin": 0.0015231021915248248, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "F17": { + "valid": 2426, + "positives": 32, + "negatives": 2394, + "auroc": 0.8562291144527987, + "auprc": 0.0887097818041189, + "brier": 0.01257475474006477, + "calibration": { + "observed_rate": 0.013190436933223413, + "mean_prediction": 0.012479642987894685, + "calibration_in_the_large": -0.000710793945328728, + "expected_calibration_error_10bin": 0.0020349988775667164, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + "F19": { + "valid": 2801, + "positives": 13, + "negatives": 2788, + "auroc": 0.966284074605452, + "auprc": 0.1384781517653411, + "brier": 0.00446385786571948, + "calibration": { + "observed_rate": 0.0046411995715815784, + "mean_prediction": 0.0016593975185778685, + "calibration_in_the_large": -0.00298180205300371, + "expected_calibration_error_10bin": 0.00298180205300371, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F20": { + "valid": 2808, + "positives": 3, + "negatives": 2805, + "auroc": 0.7947712418300653, + "auprc": 0.01514229185984911, + "brier": 0.001064538926339842, + "calibration": { + "observed_rate": 0.0010683760683760685, + "mean_prediction": 0.0009611722743564812, + "calibration_in_the_large": -0.00010720379401958733, + "expected_calibration_error_10bin": 0.00010720379401958733, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + "F22": { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.747872340425532, + "auprc": 0.0014044943820224719, + "brier": 0.00035824055113952644, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0010927195775374654, + "calibration_in_the_large": 0.000738235352085498, + "expected_calibration_error_10bin": 0.000738235352085498, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "F25": { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7889441287878788, + "auprc": 0.005352763644445852, + "brier": 0.0010661543713314683, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0009504074874665928, + "calibration_in_the_large": -0.00011379967819498925, + "expected_calibration_error_10bin": 0.00011379967819498925, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "F29": { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7573266619013581, + "auprc": 0.0096248210876531, + "brier": 0.002844834927268325, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.0007172954899849504, + "calibration_in_the_large": -0.0021337380096586706, + "expected_calibration_error_10bin": 0.0021337380096586706, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "F31": { + "valid": 2724, + "positives": 8, + "negatives": 2716, + "auroc": 0.8467875552282769, + "auprc": 0.03442130987455626, + "brier": 0.002893872857886495, + "calibration": { + "observed_rate": 0.002936857562408223, + "mean_prediction": 0.0029622335456283154, + "calibration_in_the_large": 2.5375983220092373e-05, + "expected_calibration_error_10bin": 2.5375983220092373e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + "F32": { + "valid": 2200, + "positives": 60, + "negatives": 2140, + "auroc": 0.7188395638629284, + "auprc": 0.07833237674085103, + "brier": 0.02641402903956916, + "calibration": { + "observed_rate": 0.02727272727272727, + "mean_prediction": 0.037635397435673935, + "calibration_in_the_large": 0.010362670162946664, + "expected_calibration_error_10bin": 0.010362670162946664, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + "F33": { + "valid": 2800, + "positives": 11, + "negatives": 2789, + "auroc": 0.7834023273248802, + "auprc": 0.014029437284194058, + "brier": 0.003929106138386079, + "calibration": { + "observed_rate": 0.003928571428571429, + "mean_prediction": 0.003052557144874299, + "calibration_in_the_large": -0.0008760142836971296, + "expected_calibration_error_10bin": 0.0008760142836971296, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "F39": { + "valid": 2801, + "positives": 10, + "negatives": 2791, + "auroc": 0.7723754926549624, + "auprc": 0.020603180389777584, + "brier": 0.003541588089299786, + "calibration": { + "observed_rate": 0.003570153516601214, + "mean_prediction": 0.0028393005182135683, + "calibration_in_the_large": -0.0007308529983876457, + "expected_calibration_error_10bin": 0.0007308529983876457, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F41": { + "valid": 2247, + "positives": 77, + "negatives": 2170, + "auroc": 0.7044586749655875, + "auprc": 0.10051556293849667, + "brier": 0.03221520836533166, + "calibration": { + "observed_rate": 0.03426791277258567, + "mean_prediction": 0.03466319298845416, + "calibration_in_the_large": 0.00039528021586849454, + "expected_calibration_error_10bin": 0.0028329421079112045, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + "F43": { + "valid": 2734, + "positives": 18, + "negatives": 2716, + "auroc": 0.7711708394698086, + "auprc": 0.06339630434385288, + "brier": 0.006440011631717963, + "calibration": { + "observed_rate": 0.006583760058522311, + "mean_prediction": 0.008286110449275503, + "calibration_in_the_large": 0.001702350390753192, + "expected_calibration_error_10bin": 0.002153211860024082, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "F60": { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.9464201043148411, + "auprc": 0.06497211725987322, + "brier": 0.0020702570624802252, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0019099970254097954, + "calibration_in_the_large": -0.00021917259843690431, + "expected_calibration_error_10bin": 0.00029426849673483917, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "F90": { + "valid": 2775, + "positives": 7, + "negatives": 2768, + "auroc": 0.8847027250206441, + "auprc": 0.031152693974488523, + "brier": 0.0025045871945018807, + "calibration": { + "observed_rate": 0.0025225225225225223, + "mean_prediction": 0.0009286266922657609, + "calibration_in_the_large": -0.0015938958302567615, + "expected_calibration_error_10bin": 0.0015938958302567615, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "G25": { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.6971339113680154, + "auprc": 0.004946636217088443, + "brier": 0.0021823176328670136, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.003630492251718414, + "calibration_in_the_large": 0.0014675506511416295, + "expected_calibration_error_10bin": 0.0014675506511416295, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "G31": { + "valid": 2802, + "positives": 8, + "negatives": 2794, + "auroc": 0.7973783106657122, + "auprc": 0.008736504904996254, + "brier": 0.0029787002418701935, + "calibration": { + "observed_rate": 0.0028551034975017845, + "mean_prediction": 0.004787926721762676, + "calibration_in_the_large": 0.0019328232242608917, + "expected_calibration_error_10bin": 0.0019328232242608917, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "G40": { + "valid": 2723, + "positives": 24, + "negatives": 2699, + "auroc": 0.7460170433493887, + "auprc": 0.0485556518192152, + "brier": 0.008676027243246525, + "calibration": { + "observed_rate": 0.008813808299669483, + "mean_prediction": 0.007824569405283125, + "calibration_in_the_large": -0.0009892388943863583, + "expected_calibration_error_10bin": 0.002059634630269913, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "G43": { + "valid": 2725, + "positives": 15, + "negatives": 2710, + "auroc": 0.7745879458794588, + "auprc": 0.01744684483317212, + "brier": 0.005462202711697819, + "calibration": { + "observed_rate": 0.005504587155963303, + "mean_prediction": 0.0034439935697319515, + "calibration_in_the_large": -0.0020605935862313515, + "expected_calibration_error_10bin": 0.0020605935862313515, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + "G44": { + "valid": 2805, + "positives": 6, + "negatives": 2799, + "auroc": 0.69989281886388, + "auprc": 0.006558336410503109, + "brier": 0.002144834993230762, + "calibration": { + "observed_rate": 0.0021390374331550803, + "mean_prediction": 0.0016641735286433614, + "calibration_in_the_large": -0.00047486390451171884, + "expected_calibration_error_10bin": 0.00047486390451171884, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "G47": { + "valid": 2315, + "positives": 82, + "negatives": 2233, + "auroc": 0.6996821513221849, + "auprc": 0.08591205231594834, + "brier": 0.03351843714120547, + "calibration": { + "observed_rate": 0.035421166306695465, + "mean_prediction": 0.029448493297481365, + "calibration_in_the_large": -0.0059726730092140995, + "expected_calibration_error_10bin": 0.007211880447678916, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + "G51": { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 8.499346412672081e-07, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.000595217910406587, + "calibration_in_the_large": 0.000595217910406587, + "expected_calibration_error_10bin": 0.000595217910406587, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + "G62": { + "valid": 2751, + "positives": 33, + "negatives": 2718, + "auroc": 0.8265547305282405, + "auprc": 0.10210304527547395, + "brier": 0.011315706491961782, + "calibration": { + "observed_rate": 0.011995637949836423, + "mean_prediction": 0.008563269660341384, + "calibration_in_the_large": -0.003432368289495039, + "expected_calibration_error_10bin": 0.003559706224768359, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "G81": { + "valid": 2789, + "positives": 14, + "negatives": 2775, + "auroc": 0.747979407979408, + "auprc": 0.030414915074993866, + "brier": 0.004974116517521534, + "calibration": { + "observed_rate": 0.005019720329867336, + "mean_prediction": 0.0029026310421711573, + "calibration_in_the_large": -0.0021170892876961785, + "expected_calibration_error_10bin": 0.002318035469548452, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "G83": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.7411083540115798, + "auprc": 0.00468750998597396, + "brier": 0.0010680454750260457, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0013684484224180233, + "calibration_in_the_large": 0.0003061254762423858, + "expected_calibration_error_10bin": 0.0003061254762423858, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "G89": { + "valid": 2537, + "positives": 59, + "negatives": 2478, + "auroc": 0.7850918592084923, + "auprc": 0.12385047919954599, + "brier": 0.021811571477377452, + "calibration": { + "observed_rate": 0.023255813953488372, + "mean_prediction": 0.028487987869516805, + "calibration_in_the_large": 0.005232173916028433, + "expected_calibration_error_10bin": 0.006309691554048839, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + "G90": { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 2.464957993369754e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0021091919028791385, + "calibration_in_the_large": 0.0021091919028791385, + "expected_calibration_error_10bin": 0.002109191902879139, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "G92": { + "valid": 2733, + "positives": 39, + "negatives": 2694, + "auroc": 0.7574952886756896, + "auprc": 0.06506336269905039, + "brier": 0.014172583522802812, + "calibration": { + "observed_rate": 0.014270032930845226, + "mean_prediction": 0.0198353404214533, + "calibration_in_the_large": 0.0055653074906080735, + "expected_calibration_error_10bin": 0.006028670684087933, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "G93": { + "valid": 2656, + "positives": 45, + "negatives": 2611, + "auroc": 0.7938635686624963, + "auprc": 0.060311232357086235, + "brier": 0.01636145214787706, + "calibration": { + "observed_rate": 0.01694277108433735, + "mean_prediction": 0.01605957586708614, + "calibration_in_the_large": -0.0008831952172512099, + "expected_calibration_error_10bin": 0.002294726865165354, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + "G99": { + "valid": 2841, + "positives": 1, + "negatives": 2840, + "auroc": 0.8647887323943662, + "auprc": 0.0025974025974025974, + "brier": 0.0003526661468908914, + "calibration": { + "observed_rate": 0.00035198873636043646, + "mean_prediction": 0.00044789497429690493, + "calibration_in_the_large": 9.590623793646847e-05, + "expected_calibration_error_10bin": 9.590623793646847e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9992965177629265 + }, + "H10": { + "valid": 2832, + "positives": 5, + "negatives": 2827, + "auroc": 0.8752741422002123, + "auprc": 0.012405100604767577, + "brier": 0.0017604371473012783, + "calibration": { + "observed_rate": 0.0017655367231638418, + "mean_prediction": 0.0010367609301557283, + "calibration_in_the_large": -0.0007287757930081135, + "expected_calibration_error_10bin": 0.0007287757930081135, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "H26": { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 1.1116036307788043e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0016919678975596008, + "calibration_in_the_large": 0.0016919678975596008, + "expected_calibration_error_10bin": 0.0016919678975596008, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "H35": { + "valid": 2806, + "positives": 5, + "negatives": 2801, + "auroc": 0.7125312388432703, + "auprc": 0.006712402928313358, + "brier": 0.0017806800321236438, + "calibration": { + "observed_rate": 0.001781895937277263, + "mean_prediction": 0.0008992015720137905, + "calibration_in_the_large": -0.0008826943652634726, + "expected_calibration_error_10bin": 0.0008826943652634726, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "H40": { + "valid": 2750, + "positives": 9, + "negatives": 2741, + "auroc": 0.7135676354939398, + "auprc": 0.0230648278419005, + "brier": 0.003280422408048609, + "calibration": { + "observed_rate": 0.0032727272727272726, + "mean_prediction": 0.004541531483269699, + "calibration_in_the_large": 0.0012688042105424265, + "expected_calibration_error_10bin": 0.0012688042105424256, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "H53": { + "valid": 2790, + "positives": 11, + "negatives": 2779, + "auroc": 0.5849717033596127, + "auprc": 0.010256737965451729, + "brier": 0.003946217577156892, + "calibration": { + "observed_rate": 0.003942652329749104, + "mean_prediction": 0.005120218684896827, + "calibration_in_the_large": 0.0011775663551477225, + "expected_calibration_error_10bin": 0.0011775663551477225, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "H54": { + "valid": 2809, + "positives": 2, + "negatives": 2807, + "auroc": 0.43231207695048096, + "auprc": 0.0009175289440946223, + "brier": 0.0007417105344267018, + "calibration": { + "observed_rate": 0.000711997152011392, + "mean_prediction": 0.00275727381769565, + "calibration_in_the_large": 0.002045276665684258, + "expected_calibration_error_10bin": 0.002045276665684258, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "H91": { + "valid": 2791, + "positives": 7, + "negatives": 2784, + "auroc": 0.7556444991789819, + "auprc": 0.00846365354786772, + "brier": 0.0025063107000505417, + "calibration": { + "observed_rate": 0.0025080616266571123, + "mean_prediction": 0.0026849557164381186, + "calibration_in_the_large": 0.00017689408978100634, + "expected_calibration_error_10bin": 0.00017689408978100634, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + "I07": { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.8710803455212401, + "auprc": 0.010182612839942094, + "brier": 0.0021360602577484376, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.001382243762183776, + "calibration_in_the_large": -0.0007431547500372654, + "expected_calibration_error_10bin": 0.0008955823119799764, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "I08": { + "valid": 2767, + "positives": 12, + "negatives": 2755, + "auroc": 0.869903206291591, + "auprc": 0.026574463208169617, + "brier": 0.004595003821531304, + "calibration": { + "observed_rate": 0.0043368268883267076, + "mean_prediction": 0.00772871604905852, + "calibration_in_the_large": 0.0033918891607318128, + "expected_calibration_error_10bin": 0.0033918891607318128, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + "I10": { + "valid": 1498, + "positives": 38, + "negatives": 1460, + "auroc": 0.6800829127613555, + "auprc": 0.06407893742838744, + "brier": 0.024654464969888063, + "calibration": { + "observed_rate": 0.025367156208277702, + "mean_prediction": 0.018848096422222536, + "calibration_in_the_large": -0.006519059786055166, + "expected_calibration_error_10bin": 0.009471526923940675, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + "I11": { + "valid": 2676, + "positives": 45, + "negatives": 2631, + "auroc": 0.8092824865914946, + "auprc": 0.0663650455282426, + "brier": 0.01625907913018351, + "calibration": { + "observed_rate": 0.016816143497757848, + "mean_prediction": 0.011760906495859813, + "calibration_in_the_large": -0.005055237001898034, + "expected_calibration_error_10bin": 0.006463183463239162, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + "I12": { + "valid": 2552, + "positives": 26, + "negatives": 2526, + "auroc": 0.8405505816432183, + "auprc": 0.06072213687100792, + "brier": 0.010017743188180672, + "calibration": { + "observed_rate": 0.01018808777429467, + "mean_prediction": 0.007378884786273052, + "calibration_in_the_large": -0.002809202988021618, + "expected_calibration_error_10bin": 0.00419214628336105, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + "I13": { + "valid": 2727, + "positives": 26, + "negatives": 2701, + "auroc": 0.89294563267166, + "auprc": 0.11601511090811562, + "brier": 0.008990003905651862, + "calibration": { + "observed_rate": 0.009534286762009535, + "mean_prediction": 0.010791431811178828, + "calibration_in_the_large": 0.001257145049169293, + "expected_calibration_error_10bin": 0.002201017330377759, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + "I16": { + "valid": 2390, + "positives": 10, + "negatives": 2380, + "auroc": 0.882563025210084, + "auprc": 0.027593113006813785, + "brier": 0.0041365161473644226, + "calibration": { + "observed_rate": 0.0041841004184100415, + "mean_prediction": 0.0025919454053159275, + "calibration_in_the_large": -0.001592155013094114, + "expected_calibration_error_10bin": 0.001592155013094114, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + "I21": { + "valid": 2671, + "positives": 19, + "negatives": 2652, + "auroc": 0.8312891958402794, + "auprc": 0.037862396388695305, + "brier": 0.007175663371790274, + "calibration": { + "observed_rate": 0.00711344065892924, + "mean_prediction": 0.012629725252282639, + "calibration_in_the_large": 0.005516284593353399, + "expected_calibration_error_10bin": 0.0055162845933533974, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "I24": { + "valid": 2809, + "positives": 8, + "negatives": 2801, + "auroc": 0.9072652624062835, + "auprc": 0.03652817240284092, + "brier": 0.002808562048724611, + "calibration": { + "observed_rate": 0.002847988608045568, + "mean_prediction": 0.0017854804473850633, + "calibration_in_the_large": -0.0010625081606605046, + "expected_calibration_error_10bin": 0.0010625081606605046, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "I25": { + "valid": 2243, + "positives": 40, + "negatives": 2203, + "auroc": 0.8404788924194281, + "auprc": 0.07491102706168917, + "brier": 0.01703155491354836, + "calibration": { + "observed_rate": 0.017833259028087384, + "mean_prediction": 0.015272406129165653, + "calibration_in_the_large": -0.002560852898921731, + "expected_calibration_error_10bin": 0.003648530620860698, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + "I26": { + "valid": 2760, + "positives": 17, + "negatives": 2743, + "auroc": 0.7279921082541657, + "auprc": 0.13956320007251202, + "brier": 0.0059036661401847415, + "calibration": { + "observed_rate": 0.006159420289855073, + "mean_prediction": 0.005977641518731379, + "calibration_in_the_large": -0.00018177877112369404, + "expected_calibration_error_10bin": 0.0013054694200273721, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + "I27": { + "valid": 2716, + "positives": 31, + "negatives": 2685, + "auroc": 0.8315131855589596, + "auprc": 0.05122994138971522, + "brier": 0.011191983102300363, + "calibration": { + "observed_rate": 0.011413843888070692, + "mean_prediction": 0.009704108715440416, + "calibration_in_the_large": -0.001709735172630275, + "expected_calibration_error_10bin": 0.005021811026153619, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I31": { + "valid": 2793, + "positives": 16, + "negatives": 2777, + "auroc": 0.825711199135758, + "auprc": 0.08387307196948321, + "brier": 0.005626694604810537, + "calibration": { + "observed_rate": 0.005728607232366631, + "mean_prediction": 0.0037681264674956747, + "calibration_in_the_large": -0.0019604807648709566, + "expected_calibration_error_10bin": 0.001960480764870956, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I34": { + "valid": 2753, + "positives": 16, + "negatives": 2737, + "auroc": 0.7569875776397516, + "auprc": 0.01840269915814579, + "brier": 0.005856296070333494, + "calibration": { + "observed_rate": 0.005811841627315656, + "mean_prediction": 0.005454145238286574, + "calibration_in_the_large": -0.00035769638902908175, + "expected_calibration_error_10bin": 0.0013089710501496944, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + "I35": { + "valid": 2723, + "positives": 6, + "negatives": 2717, + "auroc": 0.7195436142804564, + "auprc": 0.008211030325468856, + "brier": 0.0023263686255413575, + "calibration": { + "observed_rate": 0.0022034520749173708, + "mean_prediction": 0.004692399765620066, + "calibration_in_the_large": 0.0024889476907026956, + "expected_calibration_error_10bin": 0.002488947690702695, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "I42": { + "valid": 2740, + "positives": 12, + "negatives": 2728, + "auroc": 0.9227150537634409, + "auprc": 0.06389964650345252, + "brier": 0.0042679896825515195, + "calibration": { + "observed_rate": 0.004379562043795621, + "mean_prediction": 0.004203114538641738, + "calibration_in_the_large": -0.00017644750515388285, + "expected_calibration_error_10bin": 0.00029573991490454936, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "I44": { + "valid": 2722, + "positives": 21, + "negatives": 2701, + "auroc": 0.8696778970751573, + "auprc": 0.06893667484958446, + "brier": 0.007479593370174523, + "calibration": { + "observed_rate": 0.007714915503306392, + "mean_prediction": 0.00877674586666001, + "calibration_in_the_large": 0.0010618303633536177, + "expected_calibration_error_10bin": 0.001061830363353617, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + "I45": { + "valid": 2766, + "positives": 16, + "negatives": 2750, + "auroc": 0.6913181818181818, + "auprc": 0.03331787023544165, + "brier": 0.005739134697639883, + "calibration": { + "observed_rate": 0.005784526391901663, + "mean_prediction": 0.006899878712557778, + "calibration_in_the_large": 0.0011153523206561154, + "expected_calibration_error_10bin": 0.0011153523206561154, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + "I46": { + "valid": 2831, + "positives": 2, + "negatives": 2829, + "auroc": 0.5159066808059385, + "auprc": 0.0010662233909192814, + "brier": 0.0007212265399356907, + "calibration": { + "observed_rate": 0.0007064641469445425, + "mean_prediction": 0.0021193530716421675, + "calibration_in_the_large": 0.001412888924697625, + "expected_calibration_error_10bin": 0.001412888924697625, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I47": { + "valid": 2716, + "positives": 16, + "negatives": 2700, + "auroc": 0.6939120370370371, + "auprc": 0.014118797276130995, + "brier": 0.005918850030059002, + "calibration": { + "observed_rate": 0.005891016200294551, + "mean_prediction": 0.008310173861630122, + "calibration_in_the_large": 0.0024191576613355713, + "expected_calibration_error_10bin": 0.002419157661335572, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I48": { + "valid": 2385, + "positives": 25, + "negatives": 2360, + "auroc": 0.7533559322033898, + "auprc": 0.027211983210040095, + "brier": 0.010434141359388131, + "calibration": { + "observed_rate": 0.010482180293501049, + "mean_prediction": 0.01106703310074437, + "calibration_in_the_large": 0.0005848528072433211, + "expected_calibration_error_10bin": 0.0005848528072433213, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + "I49": { + "valid": 2734, + "positives": 17, + "negatives": 2717, + "auroc": 0.6964645261858884, + "auprc": 0.012353040338036587, + "brier": 0.006179579250978851, + "calibration": { + "observed_rate": 0.006217995610826628, + "mean_prediction": 0.004496957890638447, + "calibration_in_the_large": -0.0017210377201881807, + "expected_calibration_error_10bin": 0.0017210377201881807, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I50": { + "valid": 2415, + "positives": 44, + "negatives": 2371, + "auroc": 0.7979563667037307, + "auprc": 0.08403661924786425, + "brier": 0.017864538930759902, + "calibration": { + "observed_rate": 0.018219461697722567, + "mean_prediction": 0.018604880775920696, + "calibration_in_the_large": 0.00038541907819812996, + "expected_calibration_error_10bin": 0.005128383314684464, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + "I51": { + "valid": 2807, + "positives": 7, + "negatives": 2800, + "auroc": 0.8525510204081632, + "auprc": 0.010317645454144474, + "brier": 0.002483886774476622, + "calibration": { + "observed_rate": 0.0024937655860349127, + "mean_prediction": 0.0021350034030116318, + "calibration_in_the_large": -0.0003587621830232809, + "expected_calibration_error_10bin": 0.0003587621830232809, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "I61": { + "valid": 2802, + "positives": 8, + "negatives": 2794, + "auroc": 0.842474946313529, + "auprc": 0.011907457934129898, + "brier": 0.002846166974646197, + "calibration": { + "observed_rate": 0.0028551034975017845, + "mean_prediction": 0.0009888388534381115, + "calibration_in_the_large": -0.001866264644063673, + "expected_calibration_error_10bin": 0.001866264644063673, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "I63": { + "valid": 2735, + "positives": 14, + "negatives": 2721, + "auroc": 0.7779440331810784, + "auprc": 0.01776756387705962, + "brier": 0.0051309686778777674, + "calibration": { + "observed_rate": 0.005118829981718464, + "mean_prediction": 0.004697721161383131, + "calibration_in_the_large": -0.0004211088203353334, + "expected_calibration_error_10bin": 0.0008229154228656646, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + "I65": { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.6260236030828517, + "auprc": 0.01018640543104152, + "brier": 0.0021695105077093493, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.0030305655696332787, + "calibration_in_the_large": 0.0008676239690564944, + "expected_calibration_error_10bin": 0.0008676239690564944, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "I67": { + "valid": 2773, + "positives": 3, + "negatives": 2770, + "auroc": 0.6315282791817087, + "auprc": 0.0030343446133560483, + "brier": 0.001123031083839128, + "calibration": { + "observed_rate": 0.0010818608005769925, + "mean_prediction": 0.003031506388405263, + "calibration_in_the_large": 0.0019496455878282705, + "expected_calibration_error_10bin": 0.0019496455878282705, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "I69": { + "valid": 2752, + "positives": 16, + "negatives": 2736, + "auroc": 0.7522158260233918, + "auprc": 0.02729396098578216, + "brier": 0.005793321150306289, + "calibration": { + "observed_rate": 0.005813953488372093, + "mean_prediction": 0.006803343106615864, + "calibration_in_the_large": 0.0009893896182437707, + "expected_calibration_error_10bin": 0.000989389618243771, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + "I70": { + "valid": 2771, + "positives": 12, + "negatives": 2759, + "auroc": 0.813187145100882, + "auprc": 0.022132444863008183, + "brier": 0.004295626657244893, + "calibration": { + "observed_rate": 0.004330566582461205, + "mean_prediction": 0.0026277878843283917, + "calibration_in_the_large": -0.0017027786981328136, + "expected_calibration_error_10bin": 0.0017027786981328136, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + "I71": { + "valid": 2769, + "positives": 5, + "negatives": 2764, + "auroc": 0.7489146164978292, + "auprc": 0.005563123911126818, + "brier": 0.0018141572124830572, + "calibration": { + "observed_rate": 0.0018057060310581437, + "mean_prediction": 0.0025715071514527, + "calibration_in_the_large": 0.0007658011203945563, + "expected_calibration_error_10bin": 0.0007658011203945563, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + "I72": { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.6941678520625889, + "auprc": 0.008437089583943728, + "brier": 0.002129583689854608, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0014655419833827254, + "calibration_in_the_large": -0.0006636276404639744, + "expected_calibration_error_10bin": 0.0006636276404639744, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "I73": { + "valid": 2734, + "positives": 8, + "negatives": 2726, + "auroc": 0.800027512839325, + "auprc": 0.06957620914838773, + "brier": 0.002843997965271514, + "calibration": { + "observed_rate": 0.002926115581565472, + "mean_prediction": 0.002581535258313362, + "calibration_in_the_large": -0.0003445803232521101, + "expected_calibration_error_10bin": 0.000427620690265557, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I74": { + "valid": 2821, + "positives": 5, + "negatives": 2816, + "auroc": 0.5840909090909091, + "auprc": 0.00377572689154801, + "brier": 0.0017710346900582793, + "calibration": { + "observed_rate": 0.001772421127259837, + "mean_prediction": 0.0008222431971539211, + "calibration_in_the_large": -0.0009501779301059159, + "expected_calibration_error_10bin": 0.0009501779301059159, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "I77": { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.7147655031786014, + "auprc": 0.008922482194424819, + "brier": 0.002150710665761352, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.002163620815068233, + "calibration_in_the_large": 9.22225133394251e-06, + "expected_calibration_error_10bin": 9.22225133394251e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "I80": { + "valid": 2827, + "positives": 5, + "negatives": 2822, + "auroc": 0.8875265768958186, + "auprc": 0.07427414448661171, + "brier": 0.001737229545113088, + "calibration": { + "observed_rate": 0.0017686593562079944, + "mean_prediction": 0.0013811962489506159, + "calibration_in_the_large": -0.00038746310725737854, + "expected_calibration_error_10bin": 0.0004781644355612792, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "I81": { + "valid": 2826, + "positives": 8, + "negatives": 2818, + "auroc": 0.7616217175301633, + "auprc": 0.02063410226661368, + "brier": 0.0029268377404096796, + "calibration": { + "observed_rate": 0.0028308563340410475, + "mean_prediction": 0.002398246120966871, + "calibration_in_the_large": -0.0004326102130741763, + "expected_calibration_error_10bin": 0.0013536713661502643, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I82": { + "valid": 2739, + "positives": 32, + "negatives": 2707, + "auroc": 0.7339882711488733, + "auprc": 0.03921397343574224, + "brier": 0.011572204615713537, + "calibration": { + "observed_rate": 0.011683096020445418, + "mean_prediction": 0.010524856828405345, + "calibration_in_the_large": -0.0011582391920400732, + "expected_calibration_error_10bin": 0.002892938934509429, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "I85": { + "valid": 2793, + "positives": 9, + "negatives": 2784, + "auroc": 0.9912994891443168, + "auprc": 0.2261317429556033, + "brier": 0.0030490687229154084, + "calibration": { + "observed_rate": 0.00322234156820623, + "mean_prediction": 0.002006461324343259, + "calibration_in_the_large": -0.001215880243862971, + "expected_calibration_error_10bin": 0.0023516947453484436, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I87": { + "valid": 2780, + "positives": 12, + "negatives": 2768, + "auroc": 0.7221218689788054, + "auprc": 0.010771520664538535, + "brier": 0.004347405289183813, + "calibration": { + "observed_rate": 0.004316546762589928, + "mean_prediction": 0.005342192514560319, + "calibration_in_the_large": 0.0010256457519703908, + "expected_calibration_error_10bin": 0.0010256457519703908, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "I89": { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.842538107054236, + "auprc": 0.012255332934440418, + "brier": 0.0017632367235675048, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0007138008131604199, + "calibration_in_the_large": -0.0010554843956152348, + "expected_calibration_error_10bin": 0.0010554843956152348, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I95": { + "valid": 2485, + "positives": 87, + "negatives": 2398, + "auroc": 0.7495949689875663, + "auprc": 0.08506287445950403, + "brier": 0.03306435442245387, + "calibration": { + "observed_rate": 0.03501006036217304, + "mean_prediction": 0.03275672694386154, + "calibration_in_the_large": -0.0022533334183114997, + "expected_calibration_error_10bin": 0.008956793095153834, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + "I96": { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.8698513800424629, + "auprc": 0.036145526350284125, + "brier": 0.0017445225026520884, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0017023660406470895, + "calibration_in_the_large": -6.37943267142668e-05, + "expected_calibration_error_10bin": 6.37943267142668e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I97": { + "valid": 2740, + "positives": 10, + "negatives": 2730, + "auroc": 0.7939560439560439, + "auprc": 0.013978125842205053, + "brier": 0.003628064058497759, + "calibration": { + "observed_rate": 0.0036496350364963502, + "mean_prediction": 0.0033069040269287555, + "calibration_in_the_large": -0.00034273100956759475, + "expected_calibration_error_10bin": 0.00034273100956759475, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "J02": { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.6762309599716614, + "auprc": 0.0016148750325965518, + "brier": 0.0007238206266104697, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0016621176049677836, + "calibration_in_the_large": 0.0009541530031978721, + "expected_calibration_error_10bin": 0.0009541530031978721, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J06": { + "valid": 2816, + "positives": 8, + "negatives": 2808, + "auroc": 0.7324608262108262, + "auprc": 0.012464891979655833, + "brier": 0.0028923690226570513, + "calibration": { + "observed_rate": 0.002840909090909091, + "mean_prediction": 0.0034802130832981056, + "calibration_in_the_large": 0.0006393039923890146, + "expected_calibration_error_10bin": 0.0006393039923890142, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "J12": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 8.628451424460103e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.002792341317199824, + "calibration_in_the_large": 0.002792341317199824, + "expected_calibration_error_10bin": 0.002792341317199824, + "nonempty_bins": 3 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J15": { + "valid": 2795, + "positives": 14, + "negatives": 2781, + "auroc": 0.7982226331740895, + "auprc": 0.019370896332060687, + "brier": 0.0050604997750869785, + "calibration": { + "observed_rate": 0.005008944543828265, + "mean_prediction": 0.0061064562425221965, + "calibration_in_the_large": 0.0010975116986939315, + "expected_calibration_error_10bin": 0.0010975116986939324, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + "J18": { + "valid": 2671, + "positives": 52, + "negatives": 2619, + "auroc": 0.7729462213998296, + "auprc": 0.06822238670492324, + "brier": 0.01883406929060165, + "calibration": { + "observed_rate": 0.019468363908648447, + "mean_prediction": 0.018988304219817714, + "calibration_in_the_large": -0.00048005968883073347, + "expected_calibration_error_10bin": 0.0031039454862852828, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "J30": { + "valid": 2815, + "positives": 7, + "negatives": 2808, + "auroc": 0.749033374033374, + "auprc": 0.027376568719806517, + "brier": 0.002476143717236257, + "calibration": { + "observed_rate": 0.002486678507992895, + "mean_prediction": 0.00286688848616155, + "calibration_in_the_large": 0.00038020997816865486, + "expected_calibration_error_10bin": 0.0003802099781686551, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "J32": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.5137955429784223, + "auprc": 0.0026475091692482996, + "brier": 0.0007276386074959084, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0013294480219914737, + "calibration_in_the_large": 0.0006224844306164295, + "expected_calibration_error_10bin": 0.0006224844306164295, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J38": { + "valid": 2825, + "positives": 3, + "negatives": 2822, + "auroc": 0.7474604299551145, + "auprc": 0.003660520709682542, + "brier": 0.0010684823413960466, + "calibration": { + "observed_rate": 0.0010619469026548673, + "mean_prediction": 0.0015411258627986639, + "calibration_in_the_large": 0.0004791789601437965, + "expected_calibration_error_10bin": 0.0004791789601437965, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J43": { + "valid": 2804, + "positives": 8, + "negatives": 2796, + "auroc": 0.626788268955651, + "auprc": 0.005135400978822044, + "brier": 0.002863123010794333, + "calibration": { + "observed_rate": 0.0028530670470756064, + "mean_prediction": 0.001894427805135782, + "calibration_in_the_large": -0.0009586392419398244, + "expected_calibration_error_10bin": 0.0010440240700301518, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "J44": { + "valid": 2570, + "positives": 24, + "negatives": 2546, + "auroc": 0.7938760146635245, + "auprc": 0.03488091725955844, + "brier": 0.00918489096052214, + "calibration": { + "observed_rate": 0.00933852140077821, + "mean_prediction": 0.007757156609969439, + "calibration_in_the_large": -0.001581364790808771, + "expected_calibration_error_10bin": 0.00223545918743892, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + "J45": { + "valid": 2518, + "positives": 22, + "negatives": 2496, + "auroc": 0.6912514568764568, + "auprc": 0.022966651691779874, + "brier": 0.00864755083081394, + "calibration": { + "observed_rate": 0.008737092930897538, + "mean_prediction": 0.007701084149680178, + "calibration_in_the_large": -0.0010360087812173596, + "expected_calibration_error_10bin": 0.0013241037010757817, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + "J47": { + "valid": 2825, + "positives": 6, + "negatives": 2819, + "auroc": 0.8627763982499704, + "auprc": 0.014501453738115762, + "brier": 0.002117851070135851, + "calibration": { + "observed_rate": 0.0021238938053097347, + "mean_prediction": 0.000828699459593937, + "calibration_in_the_large": -0.0012951943457157975, + "expected_calibration_error_10bin": 0.0012951943457157975, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J69": { + "valid": 2777, + "positives": 26, + "negatives": 2751, + "auroc": 0.7615692195844868, + "auprc": 0.03266330013620269, + "brier": 0.009299339339999659, + "calibration": { + "observed_rate": 0.009362621534029529, + "mean_prediction": 0.01036888674636186, + "calibration_in_the_large": 0.0010062652123323315, + "expected_calibration_error_10bin": 0.0010062652123323317, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "J81": { + "valid": 2781, + "positives": 19, + "negatives": 2762, + "auroc": 0.7753915926674034, + "auprc": 0.027314084628411825, + "brier": 0.0067565079757971125, + "calibration": { + "observed_rate": 0.0068320747932398415, + "mean_prediction": 0.0032715741802485307, + "calibration_in_the_large": -0.003560500612991311, + "expected_calibration_error_10bin": 0.003560500612991311, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "J84": { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.9141840366039654, + "auprc": 0.03337374025239157, + "brier": 0.002456058496758332, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.001759003630838534, + "calibration_in_the_large": -0.0007259093972054845, + "expected_calibration_error_10bin": 0.0007259093972054845, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "J90": { + "valid": 2754, + "positives": 31, + "negatives": 2723, + "auroc": 0.7049032731925178, + "auprc": 0.024322227864769855, + "brier": 0.011262450851574348, + "calibration": { + "observed_rate": 0.011256354393609296, + "mean_prediction": 0.010018664266390684, + "calibration_in_the_large": -0.001237690127218612, + "expected_calibration_error_10bin": 0.003386653270278851, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + "J91": { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.8220951018948873, + "auprc": 0.058351345756558294, + "brier": 0.0034945441063739214, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.003853804072593931, + "calibration_in_the_large": 0.0002912818068297701, + "expected_calibration_error_10bin": 0.0005528281559899918, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "J94": { + "valid": 2829, + "positives": 10, + "negatives": 2819, + "auroc": 0.72603760198652, + "auprc": 0.11759595484043965, + "brier": 0.003476364389289524, + "calibration": { + "observed_rate": 0.003534817956875221, + "mean_prediction": 0.001404369950246338, + "calibration_in_the_large": -0.0021304480066288833, + "expected_calibration_error_10bin": 0.0021304480066288833, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J95": { + "valid": 2770, + "positives": 13, + "negatives": 2757, + "auroc": 0.8194525822382188, + "auprc": 0.03162089058675103, + "brier": 0.004624596680602043, + "calibration": { + "observed_rate": 0.004693140794223827, + "mean_prediction": 0.005063009932870465, + "calibration_in_the_large": 0.00036986913864663854, + "expected_calibration_error_10bin": 0.00036986913864663887, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + "J96": { + "valid": 2605, + "positives": 68, + "negatives": 2537, + "auroc": 0.8227062997055345, + "auprc": 0.10298738314923334, + "brier": 0.0247904973850216, + "calibration": { + "observed_rate": 0.026103646833013437, + "mean_prediction": 0.02482847825492439, + "calibration_in_the_large": -0.0012751685780890455, + "expected_calibration_error_10bin": 0.005838507114994053, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + "J98": { + "valid": 2692, + "positives": 34, + "negatives": 2658, + "auroc": 0.7767782056389148, + "auprc": 0.057248139718523, + "brier": 0.012235291115021665, + "calibration": { + "observed_rate": 0.01263001485884101, + "mean_prediction": 0.01002518643787595, + "calibration_in_the_large": -0.0026048284209650614, + "expected_calibration_error_10bin": 0.0028641221264557467, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + "K04": { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9527170077628794, + "auprc": 0.01134324532171238, + "brier": 0.0007040579685864985, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0008026264028567196, + "calibration_in_the_large": 9.740778508521048e-05, + "expected_calibration_error_10bin": 9.740778508521048e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "K12": { + "valid": 2824, + "positives": 14, + "negatives": 2810, + "auroc": 0.8729791560752415, + "auprc": 0.08634178169733649, + "brier": 0.005270315836221928, + "calibration": { + "observed_rate": 0.004957507082152974, + "mean_prediction": 0.004448951599597396, + "calibration_in_the_large": -0.0005085554825555788, + "expected_calibration_error_10bin": 0.0038197899798703885, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K20": { + "valid": 2813, + "positives": 10, + "negatives": 2803, + "auroc": 0.7533357117374242, + "auprc": 0.041268318032276034, + "brier": 0.0035450631967282632, + "calibration": { + "observed_rate": 0.0035549235691432635, + "mean_prediction": 0.005878902803096479, + "calibration_in_the_large": 0.0023239792339532156, + "expected_calibration_error_10bin": 0.002323979233953215, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K21": { + "valid": 2043, + "positives": 76, + "negatives": 1967, + "auroc": 0.7451970674016001, + "auprc": 0.13420221853877914, + "brier": 0.034243365657562995, + "calibration": { + "observed_rate": 0.03720019579050416, + "mean_prediction": 0.04096981749083068, + "calibration_in_the_large": 0.0037696217003265198, + "expected_calibration_error_10bin": 0.004444495859709526, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + "K22": { + "valid": 2764, + "positives": 17, + "negatives": 2747, + "auroc": 0.7356260305359857, + "auprc": 0.022708597144556968, + "brier": 0.006080040524177435, + "calibration": { + "observed_rate": 0.006150506512301013, + "mean_prediction": 0.005116872715328201, + "calibration_in_the_large": -0.0010336337969728123, + "expected_calibration_error_10bin": 0.0010336337969728123, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + "K25": { + "valid": 2817, + "positives": 6, + "negatives": 2811, + "auroc": 0.7933119886161508, + "auprc": 0.009912089158740455, + "brier": 0.0021888579794211837, + "calibration": { + "observed_rate": 0.002129925452609159, + "mean_prediction": 0.0033574815196657374, + "calibration_in_the_large": 0.0012275560670565785, + "expected_calibration_error_10bin": 0.0012275560670565785, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "K26": { + "valid": 2814, + "positives": 6, + "negatives": 2808, + "auroc": 0.9200498575498576, + "auprc": 0.03753792841040996, + "brier": 0.0021064452645577986, + "calibration": { + "observed_rate": 0.0021321961620469083, + "mean_prediction": 0.0016890979215322408, + "calibration_in_the_large": -0.0004430982405146675, + "expected_calibration_error_10bin": 0.0004430982405146675, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "K29": { + "valid": 2785, + "positives": 12, + "negatives": 2773, + "auroc": 0.7106623392234643, + "auprc": 0.0187090479537781, + "brier": 0.00435394937119264, + "calibration": { + "observed_rate": 0.004308797127468581, + "mean_prediction": 0.007903086188474179, + "calibration_in_the_large": 0.003594289061005598, + "expected_calibration_error_10bin": 0.0035942890610055974, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K30": { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.9259259259259259, + "auprc": 0.006890173410404625, + "brier": 0.0007107457425982817, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0014015530567263797, + "calibration_in_the_large": 0.0006965830179530276, + "expected_calibration_error_10bin": 0.0006965830179530276, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "K31": { + "valid": 2756, + "positives": 18, + "negatives": 2738, + "auroc": 0.8960514568622677, + "auprc": 0.05991275006455261, + "brier": 0.006389579902461277, + "calibration": { + "observed_rate": 0.006531204644412192, + "mean_prediction": 0.005797389461170804, + "calibration_in_the_large": -0.0007338151832413879, + "expected_calibration_error_10bin": 0.0022241178915495203, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "K40": { + "valid": 2827, + "positives": 3, + "negatives": 2824, + "auroc": 0.8914069877242682, + "auprc": 0.006236446156764882, + "brier": 0.001060222804616401, + "calibration": { + "observed_rate": 0.0010611956137247967, + "mean_prediction": 0.0015651838817925508, + "calibration_in_the_large": 0.0005039882680677541, + "expected_calibration_error_10bin": 0.0005039882680677541, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "K42": { + "valid": 2820, + "positives": 6, + "negatives": 2814, + "auroc": 0.8117744610281924, + "auprc": 0.024196694886350057, + "brier": 0.002122967700526854, + "calibration": { + "observed_rate": 0.002127659574468085, + "mean_prediction": 0.001262993104156773, + "calibration_in_the_large": -0.0008646664703113121, + "expected_calibration_error_10bin": 0.0009477550967755201, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "K43": { + "valid": 2813, + "positives": 7, + "negatives": 2806, + "auroc": 0.7794012829650748, + "auprc": 0.014270908498874491, + "brier": 0.0024897638183009737, + "calibration": { + "observed_rate": 0.002488446498400284, + "mean_prediction": 0.0024166863034538605, + "calibration_in_the_large": -7.176019494642373e-05, + "expected_calibration_error_10bin": 7.176019494642373e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K44": { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.6763224181360201, + "auprc": 0.0066811668398478845, + "brier": 0.002155587509284849, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.0029850615453993093, + "calibration_in_the_large": 0.0008306629816650186, + "expected_calibration_error_10bin": 0.0008306629816650186, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K52": { + "valid": 2749, + "positives": 35, + "negatives": 2714, + "auroc": 0.8024949994736288, + "auprc": 0.1149194736449171, + "brier": 0.01254322787899586, + "calibration": { + "observed_rate": 0.012731902510003638, + "mean_prediction": 0.012127430363710348, + "calibration_in_the_large": -0.00060447214629329, + "expected_calibration_error_10bin": 0.004689914176580027, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + "K55": { + "valid": 2815, + "positives": 8, + "negatives": 2807, + "auroc": 0.809093338083363, + "auprc": 0.010425444405385086, + "brier": 0.002865043213782668, + "calibration": { + "observed_rate": 0.002841918294849023, + "mean_prediction": 0.0029349752406460945, + "calibration_in_the_large": 9.305694579707152e-05, + "expected_calibration_error_10bin": 9.305694579707119e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "K56": { + "valid": 2745, + "positives": 27, + "negatives": 2718, + "auroc": 0.7561660262175347, + "auprc": 0.04853721857153285, + "brier": 0.009606295268192856, + "calibration": { + "observed_rate": 0.009836065573770493, + "mean_prediction": 0.012240535178296404, + "calibration_in_the_large": 0.0024044696045259113, + "expected_calibration_error_10bin": 0.0024044696045259118, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + "K57": { + "valid": 2741, + "positives": 22, + "negatives": 2719, + "auroc": 0.6879868935771841, + "auprc": 0.021150096212292645, + "brier": 0.007962985947881883, + "calibration": { + "observed_rate": 0.008026267785479753, + "mean_prediction": 0.004648650798964606, + "calibration_in_the_large": -0.0033776169865151464, + "expected_calibration_error_10bin": 0.0034803158655726876, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "K58": { + "valid": 2792, + "positives": 7, + "negatives": 2785, + "auroc": 0.7378815080789947, + "auprc": 0.01187325559578021, + "brier": 0.0025040968186626857, + "calibration": { + "observed_rate": 0.002507163323782235, + "mean_prediction": 0.002147309207703856, + "calibration_in_the_large": -0.0003598541160783793, + "expected_calibration_error_10bin": 0.0003598541160783793, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "K59": { + "valid": 2560, + "positives": 83, + "negatives": 2477, + "auroc": 0.7615897583065406, + "auprc": 0.13898335320426572, + "brier": 0.029809002224749814, + "calibration": { + "observed_rate": 0.032421875, + "mean_prediction": 0.027868605789763023, + "calibration_in_the_large": -0.004553269210236979, + "expected_calibration_error_10bin": 0.005372932517866503, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "K62": { + "valid": 2813, + "positives": 14, + "negatives": 2799, + "auroc": 0.8711784821109579, + "auprc": 0.03144845028059086, + "brier": 0.004907424340143991, + "calibration": { + "observed_rate": 0.004976892996800568, + "mean_prediction": 0.003308820950239086, + "calibration_in_the_large": -0.0016680720465614826, + "expected_calibration_error_10bin": 0.0016680720465614826, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K63": { + "valid": 2810, + "positives": 15, + "negatives": 2795, + "auroc": 0.7251997614788313, + "auprc": 0.01269546244980326, + "brier": 0.0053257745653806764, + "calibration": { + "observed_rate": 0.005338078291814947, + "mean_prediction": 0.003949889859770946, + "calibration_in_the_large": -0.0013881884320440007, + "expected_calibration_error_10bin": 0.0013881884320440007, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "K64": { + "valid": 2801, + "positives": 20, + "negatives": 2781, + "auroc": 0.8027687882056814, + "auprc": 0.02883349500796068, + "brier": 0.0071385220987755646, + "calibration": { + "observed_rate": 0.007140307033202428, + "mean_prediction": 0.0064929299562672725, + "calibration_in_the_large": -0.0006473770769351555, + "expected_calibration_error_10bin": 0.002175722675976869, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "K65": { + "valid": 2813, + "positives": 12, + "negatives": 2801, + "auroc": 0.8701059145543258, + "auprc": 0.03494565992285719, + "brier": 0.004410752504410782, + "calibration": { + "observed_rate": 0.004265908282971916, + "mean_prediction": 0.00788009792055177, + "calibration_in_the_large": 0.003614189637579853, + "expected_calibration_error_10bin": 0.0036141896375798542, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K66": { + "valid": 2796, + "positives": 8, + "negatives": 2788, + "auroc": 0.7197812051649928, + "auprc": 0.01935171777644511, + "brier": 0.0028784329994838063, + "calibration": { + "observed_rate": 0.002861230329041488, + "mean_prediction": 0.004404814426041449, + "calibration_in_the_large": 0.0015435840969999608, + "expected_calibration_error_10bin": 0.0015435840969999608, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "K70": { + "valid": 2774, + "positives": 2, + "negatives": 2772, + "auroc": 0.8547979797979798, + "auprc": 0.0052408799777220825, + "brier": 0.0007408100687202106, + "calibration": { + "observed_rate": 0.0007209805335255948, + "mean_prediction": 0.0010400082265219857, + "calibration_in_the_large": 0.0003190276929963909, + "expected_calibration_error_10bin": 0.0003190276929963908, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "K72": { + "valid": 2787, + "positives": 18, + "negatives": 2769, + "auroc": 0.9548573492235464, + "auprc": 0.2812905017266262, + "brier": 0.0056008851563843255, + "calibration": { + "observed_rate": 0.006458557588805167, + "mean_prediction": 0.003981388256330985, + "calibration_in_the_large": -0.0024771693324741823, + "expected_calibration_error_10bin": 0.003655620934035751, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "K74": { + "valid": 2763, + "positives": 7, + "negatives": 2756, + "auroc": 0.9573916649388348, + "auprc": 0.04948627151834322, + "brier": 0.0025222934887772705, + "calibration": { + "observed_rate": 0.0025334781035106766, + "mean_prediction": 0.0030852800304776813, + "calibration_in_the_large": 0.0005518019269670047, + "expected_calibration_error_10bin": 0.0005518019269670046, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "K75": { + "valid": 2798, + "positives": 10, + "negatives": 2788, + "auroc": 0.8187589670014347, + "auprc": 0.022785458512936927, + "brier": 0.003566891798523336, + "calibration": { + "observed_rate": 0.0035739814152966403, + "mean_prediction": 0.002591722115924458, + "calibration_in_the_large": -0.0009822592993721825, + "expected_calibration_error_10bin": 0.0012742199128560508, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "K76": { + "valid": 2681, + "positives": 30, + "negatives": 2651, + "auroc": 0.7983402489626557, + "auprc": 0.1786986194652996, + "brier": 0.010185714216914043, + "calibration": { + "observed_rate": 0.011189854531891086, + "mean_prediction": 0.005668676793492567, + "calibration_in_the_large": -0.005521177738398519, + "expected_calibration_error_10bin": 0.006106783391039406, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + "K80": { + "valid": 2731, + "positives": 13, + "negatives": 2718, + "auroc": 0.6878077772117507, + "auprc": 0.014358894540457868, + "brier": 0.004734186634731841, + "calibration": { + "observed_rate": 0.004760161113145368, + "mean_prediction": 0.002987366262986393, + "calibration_in_the_large": -0.0017727948501589747, + "expected_calibration_error_10bin": 0.0017727948501589747, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + "K81": { + "valid": 2825, + "positives": 5, + "negatives": 2820, + "auroc": 0.8495744680851064, + "auprc": 0.0333009367995895, + "brier": 0.0017553291218800294, + "calibration": { + "observed_rate": 0.0017699115044247787, + "mean_prediction": 0.0014892111633352078, + "calibration_in_the_large": -0.0002807003410895709, + "expected_calibration_error_10bin": 0.0002807003410895709, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "K82": { + "valid": 2824, + "positives": 4, + "negatives": 2820, + "auroc": 0.5793439716312057, + "auprc": 0.0036583038637621303, + "brier": 0.0014185127962409638, + "calibration": { + "observed_rate": 0.00141643059490085, + "mean_prediction": 0.001162150905968498, + "calibration_in_the_large": -0.00025427968893235197, + "expected_calibration_error_10bin": 0.00025427968893235197, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K83": { + "valid": 2757, + "positives": 12, + "negatives": 2745, + "auroc": 0.8990892531876138, + "auprc": 0.10926683175716628, + "brier": 0.004333803867363942, + "calibration": { + "observed_rate": 0.004352557127312296, + "mean_prediction": 0.004335118952170911, + "calibration_in_the_large": -1.743817514138473e-05, + "expected_calibration_error_10bin": 0.0028247015505942054, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + "K85": { + "valid": 2779, + "positives": 8, + "negatives": 2771, + "auroc": 0.773141465175027, + "auprc": 0.019841494634382905, + "brier": 0.002854818559782817, + "calibration": { + "observed_rate": 0.0028787333573227778, + "mean_prediction": 0.0022018265313561536, + "calibration_in_the_large": -0.0006769068259666242, + "expected_calibration_error_10bin": 0.0006769068259666242, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + "K86": { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.7041550961637355, + "auprc": 0.014978234550342051, + "brier": 0.0025135640844099146, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.0032620530769600334, + "calibration_in_the_large": 0.0007485880859366941, + "expected_calibration_error_10bin": 0.0007485880859366941, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K90": { + "valid": 2831, + "positives": 2, + "negatives": 2829, + "auroc": 0.46712619300106045, + "auprc": 0.0009770862574600891, + "brier": 0.000709892646353587, + "calibration": { + "observed_rate": 0.0007064641469445425, + "mean_prediction": 0.0008459003217285242, + "calibration_in_the_large": 0.0001394361747839816, + "expected_calibration_error_10bin": 0.0001394361747839816, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "K91": { + "valid": 2768, + "positives": 22, + "negatives": 2746, + "auroc": 0.8626928424816261, + "auprc": 0.061482536497008515, + "brier": 0.00768375945645228, + "calibration": { + "observed_rate": 0.007947976878612716, + "mean_prediction": 0.00743911766116954, + "calibration_in_the_large": -0.0005088592174431758, + "expected_calibration_error_10bin": 0.0006717238596932317, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "K92": { + "valid": 2751, + "positives": 33, + "negatives": 2718, + "auroc": 0.8596561642919259, + "auprc": 0.09317872230898237, + "brier": 0.011389229801194169, + "calibration": { + "observed_rate": 0.011995637949836423, + "mean_prediction": 0.010652524358953473, + "calibration_in_the_large": -0.0013431135908829502, + "expected_calibration_error_10bin": 0.0014974884616914537, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "K94": { + "valid": 2823, + "positives": 14, + "negatives": 2809, + "auroc": 0.8994558307481055, + "auprc": 0.0759305474090421, + "brier": 0.0047905823317679905, + "calibration": { + "observed_rate": 0.00495926319518243, + "mean_prediction": 0.005216265792988805, + "calibration_in_the_large": 0.0002570025978063748, + "expected_calibration_error_10bin": 0.0006236831601593505, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "L02": { + "valid": 2807, + "positives": 17, + "negatives": 2790, + "auroc": 0.76314568838288, + "auprc": 0.02213946797971205, + "brier": 0.00598949587363489, + "calibration": { + "observed_rate": 0.006056287851799074, + "mean_prediction": 0.006582502602483187, + "calibration_in_the_large": 0.0005262147506841135, + "expected_calibration_error_10bin": 0.0005262147506841135, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "L03": { + "valid": 2701, + "positives": 41, + "negatives": 2660, + "auroc": 0.7474692829635063, + "auprc": 0.06317075646254863, + "brier": 0.0146820237258111, + "calibration": { + "observed_rate": 0.015179563124768604, + "mean_prediction": 0.009602632534154285, + "calibration_in_the_large": -0.005576930590614319, + "expected_calibration_error_10bin": 0.005892339260205756, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + "L08": { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.6632212389380531, + "auprc": 0.006551660273699312, + "brier": 0.0017692090825272642, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.0017850829285046854, + "calibration_in_the_large": 1.82984762078656e-05, + "expected_calibration_error_10bin": 1.82984762078656e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + "L27": { + "valid": 2818, + "positives": 10, + "negatives": 2808, + "auroc": 0.7918091168091168, + "auprc": 0.020237156874096777, + "brier": 0.003791014505138145, + "calibration": { + "observed_rate": 0.0035486160397444995, + "mean_prediction": 0.0054136609505416496, + "calibration_in_the_large": 0.00186504491079715, + "expected_calibration_error_10bin": 0.00186504491079715, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "L29": { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.5720208481402511, + "auprc": 0.0028634490566326848, + "brier": 0.0011455987295243067, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.004226445653403914, + "calibration_in_the_large": 0.0031614829270993345, + "expected_calibration_error_10bin": 0.0031614829270993345, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "L30": { + "valid": 2816, + "positives": 8, + "negatives": 2808, + "auroc": 0.7407407407407407, + "auprc": 0.02533665035956778, + "brier": 0.0028225055995683367, + "calibration": { + "observed_rate": 0.002840909090909091, + "mean_prediction": 0.0025266915961853183, + "calibration_in_the_large": -0.0003142174947237727, + "expected_calibration_error_10bin": 0.0004849307059218558, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "L50": { + "valid": 2835, + "positives": 3, + "negatives": 2832, + "auroc": 0.7521186440677966, + "auprc": 0.010375103922972716, + "brier": 0.0010570534900129435, + "calibration": { + "observed_rate": 0.0010582010582010583, + "mean_prediction": 0.0011208916388594132, + "calibration_in_the_large": 6.269058065835496e-05, + "expected_calibration_error_10bin": 6.269058065835496e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + "L53": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 8.614201090959664e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001429730304968995, + "calibration_in_the_large": 0.001429730304968995, + "expected_calibration_error_10bin": 0.001429730304968995, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "L76": { + "valid": 2793, + "positives": 13, + "negatives": 2780, + "auroc": 0.6719977863862756, + "auprc": 0.008898719165647377, + "brier": 0.004670256709039089, + "calibration": { + "observed_rate": 0.004654493376297888, + "mean_prediction": 0.005539417492897957, + "calibration_in_the_large": 0.0008849241166000695, + "expected_calibration_error_10bin": 0.0008849241166000695, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "L89": { + "valid": 2798, + "positives": 21, + "negatives": 2777, + "auroc": 0.8454138587375893, + "auprc": 0.03427285801102456, + "brier": 0.007443369019288246, + "calibration": { + "observed_rate": 0.007505360972122945, + "mean_prediction": 0.005729715282445727, + "calibration_in_the_large": -0.0017756456896772174, + "expected_calibration_error_10bin": 0.0025212504590206063, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "L97": { + "valid": 2789, + "positives": 11, + "negatives": 2778, + "auroc": 0.8986844688788533, + "auprc": 0.08474700687454581, + "brier": 0.0038701159033678796, + "calibration": { + "observed_rate": 0.003944065973467192, + "mean_prediction": 0.0054364605404041465, + "calibration_in_the_large": 0.0014923945669369542, + "expected_calibration_error_10bin": 0.0016334516035002439, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "L98": { + "valid": 2824, + "positives": 5, + "negatives": 2819, + "auroc": 0.6578219226676126, + "auprc": 0.005312670561328826, + "brier": 0.0018053069621843316, + "calibration": { + "observed_rate": 0.0017705382436260624, + "mean_prediction": 0.003881590659318107, + "calibration_in_the_large": 0.0021110524156920446, + "expected_calibration_error_10bin": 0.0021110524156920446, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "M10": { + "valid": 2713, + "positives": 13, + "negatives": 2700, + "auroc": 0.7978917378917378, + "auprc": 0.047121203221126444, + "brier": 0.004714158749578849, + "calibration": { + "observed_rate": 0.004791743457427202, + "mean_prediction": 0.005645411019867342, + "calibration_in_the_large": 0.0008536675624401394, + "expected_calibration_error_10bin": 0.000853667562440139, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + "M16": { + "valid": 2790, + "positives": 3, + "negatives": 2787, + "auroc": 0.9124506637961967, + "auprc": 0.014547339524880814, + "brier": 0.0010709726895556286, + "calibration": { + "observed_rate": 0.001075268817204301, + "mean_prediction": 0.001394982049719163, + "calibration_in_the_large": 0.00031971323251486186, + "expected_calibration_error_10bin": 0.00031971323251486186, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "M17": { + "valid": 2733, + "positives": 10, + "negatives": 2723, + "auroc": 0.7487330150569225, + "auprc": 0.008813759732153972, + "brier": 0.0036753719288170885, + "calibration": { + "observed_rate": 0.003658982802780827, + "mean_prediction": 0.0028333396259652907, + "calibration_in_the_large": -0.0008256431768155362, + "expected_calibration_error_10bin": 0.0008256431768155362, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "M19": { + "valid": 2674, + "positives": 33, + "negatives": 2641, + "auroc": 0.7091207416841646, + "auprc": 0.031045690278339096, + "brier": 0.012164165084554755, + "calibration": { + "observed_rate": 0.012341062079281975, + "mean_prediction": 0.01208858649319448, + "calibration_in_the_large": -0.0002524755860874948, + "expected_calibration_error_10bin": 0.0013679730747580858, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + "M21": { + "valid": 2821, + "positives": 2, + "negatives": 2819, + "auroc": 0.8914508691025186, + "auprc": 0.00939725120052989, + "brier": 0.0007112651977891253, + "calibration": { + "observed_rate": 0.0007089684509039348, + "mean_prediction": 0.001675253050540032, + "calibration_in_the_large": 0.0009662845996360973, + "expected_calibration_error_10bin": 0.0009662845996360973, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "M25": { + "valid": 2717, + "positives": 34, + "negatives": 2683, + "auroc": 0.602069676174607, + "auprc": 0.017844555940459993, + "brier": 0.012466358583605256, + "calibration": { + "observed_rate": 0.012513801987486198, + "mean_prediction": 0.012591529075508093, + "calibration_in_the_large": 7.772708802189499e-05, + "expected_calibration_error_10bin": 0.0010929639777014382, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + "M35": { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.8851640513552068, + "auprc": 0.004525258379213755, + "brier": 0.0007169290442376586, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0009931614604215756, + "calibration_in_the_large": 0.0002804030855106704, + "expected_calibration_error_10bin": 0.0002804030855106704, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "M46": { + "valid": 2814, + "positives": 4, + "negatives": 2810, + "auroc": 0.6157473309608541, + "auprc": 0.002336027847777431, + "brier": 0.0014287416320238181, + "calibration": { + "observed_rate": 0.0014214641080312722, + "mean_prediction": 0.0021433993543699854, + "calibration_in_the_large": 0.0007219352463387133, + "expected_calibration_error_10bin": 0.0007219352463387133, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "M47": { + "valid": 2743, + "positives": 10, + "negatives": 2733, + "auroc": 0.741017197219173, + "auprc": 0.018413701207011374, + "brier": 0.003619394058697418, + "calibration": { + "observed_rate": 0.0036456434560699965, + "mean_prediction": 0.0025423516239119984, + "calibration_in_the_large": -0.001103291832157998, + "expected_calibration_error_10bin": 0.001103291832157998, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "M48": { + "valid": 2690, + "positives": 10, + "negatives": 2680, + "auroc": 0.7628358208955224, + "auprc": 0.014337802665450042, + "brier": 0.003725391117814756, + "calibration": { + "observed_rate": 0.0037174721189591076, + "mean_prediction": 0.0058336247901322295, + "calibration_in_the_large": 0.002116152671173122, + "expected_calibration_error_10bin": 0.002116152671173122, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + "M51": { + "valid": 2785, + "positives": 3, + "negatives": 2782, + "auroc": 0.9241552839683681, + "auprc": 0.010568500459068464, + "brier": 0.0010764635565570734, + "calibration": { + "observed_rate": 0.0010771992818671453, + "mean_prediction": 0.002853829254757001, + "calibration_in_the_large": 0.0017766299728898558, + "expected_calibration_error_10bin": 0.0017766299728898558, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "M54": { + "valid": 2567, + "positives": 40, + "negatives": 2527, + "auroc": 0.7281163434903047, + "auprc": 0.04951489888933107, + "brier": 0.01516425605326574, + "calibration": { + "observed_rate": 0.015582391897156213, + "mean_prediction": 0.015252581308976783, + "calibration_in_the_large": -0.00032981058817943033, + "expected_calibration_error_10bin": 0.0005927292188269608, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + "M62": { + "valid": 2781, + "positives": 10, + "negatives": 2771, + "auroc": 0.6950198484301696, + "auprc": 0.012972560446332567, + "brier": 0.003575179202759254, + "calibration": { + "observed_rate": 0.003595828838547285, + "mean_prediction": 0.0035115436566713963, + "calibration_in_the_large": -8.428518187588883e-05, + "expected_calibration_error_10bin": 8.428518187588883e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "M79": { + "valid": 2697, + "positives": 33, + "negatives": 2664, + "auroc": 0.7446764946764947, + "auprc": 0.03817208755287777, + "brier": 0.012116863175431716, + "calibration": { + "observed_rate": 0.012235817575083427, + "mean_prediction": 0.014998820930411006, + "calibration_in_the_large": 0.00276300335532758, + "expected_calibration_error_10bin": 0.0027630033553275794, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + "M81": { + "valid": 2705, + "positives": 13, + "negatives": 2692, + "auroc": 0.8065493199222769, + "auprc": 0.048527560716942614, + "brier": 0.004717184923577016, + "calibration": { + "observed_rate": 0.004805914972273568, + "mean_prediction": 0.004908425946939272, + "calibration_in_the_large": 0.00010251097466570415, + "expected_calibration_error_10bin": 0.0003021016544526307, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + "M84": { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.772226173541963, + "auprc": 0.023429602990632705, + "brier": 0.0021312836121225335, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0027324600881120094, + "calibration_in_the_large": 0.0006032904642653096, + "expected_calibration_error_10bin": 0.0006032904642653098, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "M85": { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.7186837067315155, + "auprc": 0.006481118370313743, + "brier": 0.002538321621038747, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.0032364887147195986, + "calibration_in_the_large": 0.0007075869806155524, + "expected_calibration_error_10bin": 0.0007075869806155524, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "M86": { + "valid": 2803, + "positives": 14, + "negatives": 2789, + "auroc": 0.7878399836090765, + "auprc": 0.050436544348598046, + "brier": 0.004900369007611243, + "calibration": { + "observed_rate": 0.0049946485907955765, + "mean_prediction": 0.003827370052302505, + "calibration_in_the_large": -0.0011672785384930716, + "expected_calibration_error_10bin": 0.001920827389346345, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + "M94": { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7608901515151515, + "auprc": 0.0032705876492990504, + "brier": 0.0010637836492385852, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0003822016268891048, + "calibration_in_the_large": -0.0006820055387724772, + "expected_calibration_error_10bin": 0.0006820055387724772, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "M96": { + "valid": 2804, + "positives": 3, + "negatives": 2801, + "auroc": 0.8737355706295371, + "auprc": 0.006234400062195162, + "brier": 0.0010812700701141157, + "calibration": { + "observed_rate": 0.0010699001426533524, + "mean_prediction": 0.0031024157237458327, + "calibration_in_the_large": 0.00203251558109248, + "expected_calibration_error_10bin": 0.00203251558109248, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "N12": { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.6684034803723189, + "auprc": 0.006496504883791888, + "brier": 0.0024781256363438724, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.002004454814881383, + "calibration_in_the_large": -0.0004681696994245162, + "expected_calibration_error_10bin": 0.0004681696994245162, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N13": { + "valid": 2756, + "positives": 19, + "negatives": 2737, + "auroc": 0.7245928119531565, + "auprc": 0.037980746985488624, + "brier": 0.006777146418909092, + "calibration": { + "observed_rate": 0.006894049346879536, + "mean_prediction": 0.0049492452505555925, + "calibration_in_the_large": -0.0019448040963239432, + "expected_calibration_error_10bin": 0.0019448040963239432, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "N14": { + "valid": 2826, + "positives": 8, + "negatives": 2818, + "auroc": 0.877306600425834, + "auprc": 0.020610592268456258, + "brier": 0.0028133571206270047, + "calibration": { + "observed_rate": 0.0028308563340410475, + "mean_prediction": 0.0016310255772956767, + "calibration_in_the_large": -0.0011998307567453708, + "expected_calibration_error_10bin": 0.0011998307567453708, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "N17": { + "valid": 2292, + "positives": 89, + "negatives": 2203, + "auroc": 0.8049595291405489, + "auprc": 0.14996120913954228, + "brier": 0.035433486277240044, + "calibration": { + "observed_rate": 0.03883071553228621, + "mean_prediction": 0.04090060895191726, + "calibration_in_the_large": 0.0020698934196310484, + "expected_calibration_error_10bin": 0.0050460960227440635, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + "N18": { + "valid": 2440, + "positives": 45, + "negatives": 2395, + "auroc": 0.8666295523080492, + "auprc": 0.1970817580828227, + "brier": 0.016765677709284183, + "calibration": { + "observed_rate": 0.018442622950819672, + "mean_prediction": 0.011389131452024678, + "calibration_in_the_large": -0.007053491498794993, + "expected_calibration_error_10bin": 0.007305223044016606, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + "N20": { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7344085060757684, + "auprc": 0.0063281277636879334, + "brier": 0.0028463897231746646, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.001297301844276683, + "calibration_in_the_large": -0.001553731655366938, + "expected_calibration_error_10bin": 0.001553731655366938, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "N25": { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.957001214083367, + "auprc": 0.08568709368363238, + "brier": 0.0024197883306582495, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.0012500718941058926, + "calibration_in_the_large": -0.0012225526202000066, + "expected_calibration_error_10bin": 0.0013164556219334071, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N28": { + "valid": 2789, + "positives": 7, + "negatives": 2782, + "auroc": 0.818321865050837, + "auprc": 0.011066762145945836, + "brier": 0.0025118912899330277, + "calibration": { + "observed_rate": 0.002509860164933668, + "mean_prediction": 0.004366990904838297, + "calibration_in_the_large": 0.0018571307399046287, + "expected_calibration_error_10bin": 0.0018571307399046287, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "N30": { + "valid": 2829, + "positives": 10, + "negatives": 2819, + "auroc": 0.7010287335934728, + "auprc": 0.012007814041172177, + "brier": 0.0035797165880338544, + "calibration": { + "observed_rate": 0.003534817956875221, + "mean_prediction": 0.004113148564485901, + "calibration_in_the_large": 0.0005783306076106802, + "expected_calibration_error_10bin": 0.0005783306076106807, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N32": { + "valid": 2807, + "positives": 12, + "negatives": 2795, + "auroc": 0.8333631484794275, + "auprc": 0.18250702757868176, + "brier": 0.004106403449440503, + "calibration": { + "observed_rate": 0.004275026718916993, + "mean_prediction": 0.004232891997313358, + "calibration_in_the_large": -4.213472160363545e-05, + "expected_calibration_error_10bin": 0.0005898366208742063, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "N39": { + "valid": 2520, + "positives": 78, + "negatives": 2442, + "auroc": 0.751034251034251, + "auprc": 0.08374629149451547, + "brier": 0.02949075374784741, + "calibration": { + "observed_rate": 0.030952380952380953, + "mean_prediction": 0.035024652649031304, + "calibration_in_the_large": 0.004072271696650351, + "expected_calibration_error_10bin": 0.005320133486418938, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + "N40": { + "valid": 2606, + "positives": 21, + "negatives": 2585, + "auroc": 0.8186607718522612, + "auprc": 0.05082564232588963, + "brier": 0.007880065913487864, + "calibration": { + "observed_rate": 0.008058326937835763, + "mean_prediction": 0.009911791125046157, + "calibration_in_the_large": 0.0018534641872103939, + "expected_calibration_error_10bin": 0.0018534641872103937, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + "N73": { + "valid": 2829, + "positives": 5, + "negatives": 2824, + "auroc": 0.9747167138810199, + "auprc": 0.0954916880342771, + "brier": 0.0017224094076063227, + "calibration": { + "observed_rate": 0.0017674089784376105, + "mean_prediction": 0.0010665762304416916, + "calibration_in_the_large": -0.0007008327479959189, + "expected_calibration_error_10bin": 0.0007008327479959189, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N99": { + "valid": 2799, + "positives": 5, + "negatives": 2794, + "auroc": 0.7702934860415175, + "auprc": 0.009805806109561652, + "brier": 0.0017820059674507245, + "calibration": { + "observed_rate": 0.0017863522686673813, + "mean_prediction": 0.0017671212099886985, + "calibration_in_the_large": -1.923105867868277e-05, + "expected_calibration_error_10bin": 1.923105867868277e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + "O69": { + "valid": 2743, + "positives": 6, + "negatives": 2737, + "auroc": 0.9963463646328097, + "auprc": 0.34354331305550817, + "brier": 0.002039015718685359, + "calibration": { + "observed_rate": 0.002187386073641998, + "mean_prediction": 0.0004653434305526099, + "calibration_in_the_large": -0.001722042643089388, + "expected_calibration_error_10bin": 0.0019234202764087738, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "O99": { + "valid": 2652, + "positives": 3, + "negatives": 2649, + "auroc": 0.8637221593053983, + "auprc": 0.18428844317096468, + "brier": 0.0009887009877288765, + "calibration": { + "observed_rate": 0.0011312217194570137, + "mean_prediction": 0.0004820192536152344, + "calibration_in_the_large": -0.0006492024658417792, + "expected_calibration_error_10bin": 0.0006492024658417791, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + "Q21": { + "valid": 2810, + "positives": 3, + "negatives": 2807, + "auroc": 0.5805723785773661, + "auprc": 0.0028869419843655653, + "brier": 0.0010672408381544303, + "calibration": { + "observed_rate": 0.0010676156583629894, + "mean_prediction": 0.0011721854502901939, + "calibration_in_the_large": 0.00010456979192720447, + "expected_calibration_error_10bin": 0.00010456979192720447, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "U07": { + "valid": 2828, + "positives": 0, + "negatives": 2828, + "auroc": null, + "auprc": null, + "brier": 4.549322225192573e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0033061415140859633, + "calibration_in_the_large": 0.0033061415140859633, + "expected_calibration_error_10bin": 0.0033061415140859633, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9947238832219486 + } + }, + "300": { + "A04": { + "valid": 2782, + "positives": 26, + "negatives": 2756, + "auroc": 0.7634392095567712, + "auprc": 0.05173107759658407, + "brier": 0.009159966921777193, + "calibration": { + "observed_rate": 0.009345794392523364, + "mean_prediction": 0.009709339156549519, + "calibration_in_the_large": 0.0003635447640261552, + "expected_calibration_error_10bin": 0.0004806226542000916, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "A08": { + "valid": 2818, + "positives": 11, + "negatives": 2807, + "auroc": 0.8112510930466043, + "auprc": 0.028451182135252984, + "brier": 0.003855101829056001, + "calibration": { + "observed_rate": 0.0039034776437189495, + "mean_prediction": 0.0044947498281131424, + "calibration_in_the_large": 0.000591272184394193, + "expected_calibration_error_10bin": 0.0005912721843941928, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "A41": { + "valid": 2664, + "positives": 66, + "negatives": 2598, + "auroc": 0.7452935824760305, + "auprc": 0.07460836662895982, + "brier": 0.024093090837592517, + "calibration": { + "observed_rate": 0.024774774774774775, + "mean_prediction": 0.02781265195683393, + "calibration_in_the_large": 0.003037877182059154, + "expected_calibration_error_10bin": 0.00814373736702746, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + "B00": { + "valid": 2819, + "positives": 4, + "negatives": 2815, + "auroc": 0.672380106571936, + "auprc": 0.015185947160177123, + "brier": 0.0014616728105283025, + "calibration": { + "observed_rate": 0.001418942887548776, + "mean_prediction": 0.001978781267548776, + "calibration_in_the_large": 0.0005598383799999998, + "expected_calibration_error_10bin": 0.0005598383799999997, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "B02": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.803325079589671, + "auprc": 0.0017953321364452424, + "brier": 0.00035729790606744125, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0009489987563992514, + "calibration_in_the_large": 0.0005953919671488979, + "expected_calibration_error_10bin": 0.0005953919671488979, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "B18": { + "valid": 2782, + "positives": 7, + "negatives": 2775, + "auroc": 0.9417245817245817, + "auprc": 0.07848265957509656, + "brier": 0.002434967808272016, + "calibration": { + "observed_rate": 0.0025161754133716753, + "mean_prediction": 0.0013597690219618928, + "calibration_in_the_large": -0.0011564063914097824, + "expected_calibration_error_10bin": 0.0013173988743935311, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "B19": { + "valid": 2763, + "positives": 17, + "negatives": 2746, + "auroc": 0.8570326892592434, + "auprc": 0.0754107215561686, + "brier": 0.00600162340237811, + "calibration": { + "observed_rate": 0.006152732537097358, + "mean_prediction": 0.0020087861866660396, + "calibration_in_the_large": -0.004143946350431318, + "expected_calibration_error_10bin": 0.004376170576688112, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "B20": { + "valid": 2829, + "positives": 5, + "negatives": 2824, + "auroc": 0.988456090651558, + "auprc": 0.24381598793363501, + "brier": 0.0017358350591302675, + "calibration": { + "observed_rate": 0.0017674089784376105, + "mean_prediction": 0.00030837415171473066, + "calibration_in_the_large": -0.00145903482672288, + "expected_calibration_error_10bin": 0.0015457094824160445, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "B34": { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.9790516631280962, + "auprc": 0.11446172248803828, + "brier": 0.001703475754063011, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0016682383093889548, + "calibration_in_the_large": -9.792205797240147e-05, + "expected_calibration_error_10bin": 0.00018302271587609926, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "B35": { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.8600917431192661, + "auprc": 0.004842268715266426, + "brier": 0.0007157372623650274, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0018436707939307893, + "calibration_in_the_large": 0.0011384521761592802, + "expected_calibration_error_10bin": 0.0011384521761592802, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "B37": { + "valid": 2768, + "positives": 35, + "negatives": 2733, + "auroc": 0.7552035962573833, + "auprc": 0.03864745539355039, + "brier": 0.012463618280690508, + "calibration": { + "observed_rate": 0.012644508670520232, + "mean_prediction": 0.01020790426182272, + "calibration_in_the_large": -0.002436604408697512, + "expected_calibration_error_10bin": 0.0045708674342834835, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "B95": { + "valid": 2678, + "positives": 60, + "negatives": 2618, + "auroc": 0.7142284186401834, + "auprc": 0.04782118280397353, + "brier": 0.022015007692019608, + "calibration": { + "observed_rate": 0.022404779686333084, + "mean_prediction": 0.023381651270447078, + "calibration_in_the_large": 0.000976871584113994, + "expected_calibration_error_10bin": 0.0043239285364761685, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + "B96": { + "valid": 2630, + "positives": 77, + "negatives": 2553, + "auroc": 0.7575248879596705, + "auprc": 0.09441734476746036, + "brier": 0.027757063207416555, + "calibration": { + "observed_rate": 0.029277566539923954, + "mean_prediction": 0.03241278580551482, + "calibration_in_the_large": 0.003135219265590867, + "expected_calibration_error_10bin": 0.003417898758120669, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + "B97": { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.8819886765746638, + "auprc": 0.08483935742971888, + "brier": 0.0007104967834860068, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0011421155055781067, + "calibration_in_the_large": 0.00043490192707739946, + "expected_calibration_error_10bin": 0.00043490192707739935, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "C18": { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9773210489014883, + "auprc": 0.03400900900900901, + "brier": 0.0007026537389318854, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0006957783647497389, + "calibration_in_the_large": -1.2436932700686108e-05, + "expected_calibration_error_10bin": 1.2436932700686108e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "C22": { + "valid": 2812, + "positives": 6, + "negatives": 2806, + "auroc": 0.9115585649798051, + "auprc": 0.0537634691569606, + "brier": 0.0020963840916934473, + "calibration": { + "observed_rate": 0.0021337126600284497, + "mean_prediction": 0.0008539459480911996, + "calibration_in_the_large": -0.0012797667119372501, + "expected_calibration_error_10bin": 0.0012797667119372501, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + "C25": { + "valid": 2809, + "positives": 3, + "negatives": 2806, + "auroc": 0.953551912568306, + "auprc": 0.1235967577048116, + "brier": 0.0010347351140497776, + "calibration": { + "observed_rate": 0.001067995728017088, + "mean_prediction": 0.000616092120475062, + "calibration_in_the_large": -0.00045190360754202594, + "expected_calibration_error_10bin": 0.0006387574848747465, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "C61": { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9696753478415983, + "auprc": 0.018923611111111113, + "brier": 0.0007121644540295471, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0012037762028997733, + "calibration_in_the_large": 0.0004907637251814133, + "expected_calibration_error_10bin": 0.0004907637251814133, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "C67": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9564909798372834, + "auprc": 0.029366812227074237, + "brier": 0.0007034576136908611, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0008743940955873919, + "calibration_in_the_large": 0.00016743050421234764, + "expected_calibration_error_10bin": 0.00016743050421234764, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "C77": { + "valid": 2762, + "positives": 20, + "negatives": 2742, + "auroc": 0.8632385120350109, + "auprc": 0.13848106202711488, + "brier": 0.0068042239488553926, + "calibration": { + "observed_rate": 0.00724112961622013, + "mean_prediction": 0.004310204937242107, + "calibration_in_the_large": -0.0029309246789780237, + "expected_calibration_error_10bin": 0.003690731133289176, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C78": { + "valid": 2762, + "positives": 32, + "negatives": 2730, + "auroc": 0.8685668498168498, + "auprc": 0.1411932884997218, + "brier": 0.010817200380576724, + "calibration": { + "observed_rate": 0.011585807385952208, + "mean_prediction": 0.0068503778362160725, + "calibration_in_the_large": -0.004735429549736135, + "expected_calibration_error_10bin": 0.007075601189634701, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C79": { + "valid": 2751, + "positives": 25, + "negatives": 2726, + "auroc": 0.8990315480557594, + "auprc": 0.1776765151220698, + "brier": 0.008916908190391046, + "calibration": { + "observed_rate": 0.009087604507451835, + "mean_prediction": 0.009378586193809846, + "calibration_in_the_large": 0.0002909816863580113, + "expected_calibration_error_10bin": 0.004387251466202768, + "nonempty_bins": 8 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "C83": { + "valid": 2820, + "positives": 2, + "negatives": 2818, + "auroc": 0.40507452093683466, + "auprc": 0.0011707836920459129, + "brier": 0.0007267208043557104, + "calibration": { + "observed_rate": 0.0007092198581560284, + "mean_prediction": 0.0005141076521553298, + "calibration_in_the_large": -0.0001951122060006986, + "expected_calibration_error_10bin": 0.00029327329888738656, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "D25": { + "valid": 2792, + "positives": 3, + "negatives": 2789, + "auroc": 0.9581689972511055, + "auprc": 0.6694995278564684, + "brier": 0.001052896889070611, + "calibration": { + "observed_rate": 0.0010744985673352436, + "mean_prediction": 0.0005001326924392818, + "calibration_in_the_large": -0.0005743658748959617, + "expected_calibration_error_10bin": 0.0005743658748959617, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "D47": { + "valid": 2796, + "positives": 10, + "negatives": 2786, + "auroc": 0.6575017946877243, + "auprc": 0.006651497190603771, + "brier": 0.0036763238541857894, + "calibration": { + "observed_rate": 0.00357653791130186, + "mean_prediction": 0.0051690258220665995, + "calibration_in_the_large": 0.0015924879107647397, + "expected_calibration_error_10bin": 0.0015924879107647404, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "D50": { + "valid": 2663, + "positives": 52, + "negatives": 2611, + "auroc": 0.7897725598797984, + "auprc": 0.11062850612041206, + "brier": 0.01824706519114005, + "calibration": { + "observed_rate": 0.01952684941794968, + "mean_prediction": 0.016433086772623742, + "calibration_in_the_large": -0.0030937626453259384, + "expected_calibration_error_10bin": 0.003586509453825294, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + "D53": { + "valid": 2805, + "positives": 16, + "negatives": 2789, + "auroc": 0.8178558623162424, + "auprc": 0.025721368434203067, + "brier": 0.005810469514630808, + "calibration": { + "observed_rate": 0.00570409982174688, + "mean_prediction": 0.0065675625295025805, + "calibration_in_the_large": 0.0008634627077557001, + "expected_calibration_error_10bin": 0.001372746865624537, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "D59": { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9827099505998589, + "auprc": 0.029437229437229435, + "brier": 0.0006999277982162726, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0008039314902278072, + "calibration_in_the_large": 9.8712872456298e-05, + "expected_calibration_error_10bin": 9.8712872456298e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "D61": { + "valid": 2773, + "positives": 35, + "negatives": 2738, + "auroc": 0.9089533548993008, + "auprc": 0.27342836539662685, + "brier": 0.01056786670783074, + "calibration": { + "observed_rate": 0.012621709340064912, + "mean_prediction": 0.010794716479433785, + "calibration_in_the_large": -0.0018269928606311266, + "expected_calibration_error_10bin": 0.0029310741459619904, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "D62": { + "valid": 2499, + "positives": 69, + "negatives": 2430, + "auroc": 0.7768652710681696, + "auprc": 0.07571499190039206, + "brier": 0.026303619385163842, + "calibration": { + "observed_rate": 0.027611044417767107, + "mean_prediction": 0.024580467785593075, + "calibration_in_the_large": -0.003030576632174032, + "expected_calibration_error_10bin": 0.004971402235190887, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + "D63": { + "valid": 2686, + "positives": 74, + "negatives": 2612, + "auroc": 0.8586099499192914, + "auprc": 0.1382718158697274, + "brier": 0.025654170018568494, + "calibration": { + "observed_rate": 0.027550260610573342, + "mean_prediction": 0.024490287716345992, + "calibration_in_the_large": -0.0030599728942273495, + "expected_calibration_error_10bin": 0.009914561044850388, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + "D64": { + "valid": 2434, + "positives": 116, + "negatives": 2318, + "auroc": 0.8101105292910059, + "auprc": 0.19684046861443108, + "brier": 0.041847022678201916, + "calibration": { + "observed_rate": 0.047658175842235, + "mean_prediction": 0.0477665685825685, + "calibration_in_the_large": 0.00010839274033350166, + "expected_calibration_error_10bin": 0.007888773740414644, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + "D65": { + "valid": 2833, + "positives": 4, + "negatives": 2829, + "auroc": 0.9609402615765288, + "auprc": 0.021265036988021308, + "brier": 0.0014095510508728125, + "calibration": { + "observed_rate": 0.0014119308153900459, + "mean_prediction": 0.0010085415087500293, + "calibration_in_the_large": -0.00040338930664001664, + "expected_calibration_error_10bin": 0.00040338930664001664, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + "D68": { + "valid": 2682, + "positives": 57, + "negatives": 2625, + "auroc": 0.8193817878028404, + "auprc": 0.13624614423190842, + "brier": 0.019809753669639052, + "calibration": { + "observed_rate": 0.021252796420581657, + "mean_prediction": 0.01295238567749212, + "calibration_in_the_large": -0.008300410743089537, + "expected_calibration_error_10bin": 0.009552106816591773, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + "D69": { + "valid": 2586, + "positives": 81, + "negatives": 2505, + "auroc": 0.8304181759936916, + "auprc": 0.24097118715726062, + "brier": 0.02681627572843891, + "calibration": { + "observed_rate": 0.031322505800464036, + "mean_prediction": 0.02235813286409001, + "calibration_in_the_large": -0.008964372936374025, + "expected_calibration_error_10bin": 0.009912863135343593, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + "D70": { + "valid": 2787, + "positives": 26, + "negatives": 2761, + "auroc": 0.9041456551416711, + "auprc": 0.24220722368349604, + "brier": 0.008857031330627577, + "calibration": { + "observed_rate": 0.009329027628274129, + "mean_prediction": 0.008816111617042884, + "calibration_in_the_large": -0.0005129160112312455, + "expected_calibration_error_10bin": 0.006272434368190956, + "nonempty_bins": 9 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "D72": { + "valid": 2595, + "positives": 60, + "negatives": 2535, + "auroc": 0.713405654174885, + "auprc": 0.05940864667687797, + "brier": 0.022317136662694213, + "calibration": { + "observed_rate": 0.023121387283236993, + "mean_prediction": 0.024450828943864546, + "calibration_in_the_large": 0.0013294416606275533, + "expected_calibration_error_10bin": 0.0013294416606275492, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + "D73": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.8233486943164362, + "auprc": 0.020594293988586445, + "brier": 0.0010878175407725088, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.001604789875567811, + "calibration_in_the_large": 0.0005424669293921736, + "expected_calibration_error_10bin": 0.0005424669293921738, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "D75": { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.8737177219667492, + "auprc": 0.006742171204190739, + "brier": 0.0014157267465841033, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.001532043298656326, + "calibration_in_the_large": 0.000119115004767241, + "expected_calibration_error_10bin": 0.000119115004767241, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "D80": { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.9881457891012031, + "auprc": 0.09553989916893142, + "brier": 0.0021176404151380815, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.0020709912362274164, + "calibration_in_the_large": -4.765283156919374e-05, + "expected_calibration_error_10bin": 0.0013372805568171399, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "D89": { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.8430335097001763, + "auprc": 0.0074043665997688985, + "brier": 0.0009176499232852342, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0011609029883524863, + "calibration_in_the_large": 0.0004559329495791342, + "expected_calibration_error_10bin": 0.0008898351906210698, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "E03": { + "valid": 2480, + "positives": 23, + "negatives": 2457, + "auroc": 0.7063226628444019, + "auprc": 0.02333107723931554, + "brier": 0.009153267917109353, + "calibration": { + "observed_rate": 0.009274193548387096, + "mean_prediction": 0.006167060725537369, + "calibration_in_the_large": -0.003107132822849727, + "expected_calibration_error_10bin": 0.003107132822849727, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + "E04": { + "valid": 2775, + "positives": 11, + "negatives": 2764, + "auroc": 0.6840876200499935, + "auprc": 0.009265643566755395, + "brier": 0.0039606450987681625, + "calibration": { + "observed_rate": 0.003963963963963964, + "mean_prediction": 0.0034763139089556863, + "calibration_in_the_large": -0.00048765005500827794, + "expected_calibration_error_10bin": 0.00048765005500827794, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "E05": { + "valid": 2806, + "positives": 4, + "negatives": 2802, + "auroc": 0.4719842969307637, + "auprc": 0.032445158718276496, + "brier": 0.0014206080505966045, + "calibration": { + "observed_rate": 0.0014255167498218105, + "mean_prediction": 0.0013013754872327255, + "calibration_in_the_large": -0.00012414126258908495, + "expected_calibration_error_10bin": 0.00012414126258908495, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "E11": { + "valid": 2194, + "positives": 20, + "negatives": 2174, + "auroc": 0.8152023919043239, + "auprc": 0.15142462137349258, + "brier": 0.008755659481605579, + "calibration": { + "observed_rate": 0.009115770282588878, + "mean_prediction": 0.007945189809812894, + "calibration_in_the_large": -0.0011705804727759842, + "expected_calibration_error_10bin": 0.001170580472775985, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + "E16": { + "valid": 2816, + "positives": 10, + "negatives": 2806, + "auroc": 0.7040270848182466, + "auprc": 0.014845672956652206, + "brier": 0.003532704731675722, + "calibration": { + "observed_rate": 0.0035511363636363635, + "mean_prediction": 0.0029305264798102307, + "calibration_in_the_large": -0.0006206098838261328, + "expected_calibration_error_10bin": 0.0006206098838261328, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "E21": { + "valid": 2814, + "positives": 3, + "negatives": 2811, + "auroc": 0.9421321000830072, + "auprc": 0.021911289768432624, + "brier": 0.0010771533043189559, + "calibration": { + "observed_rate": 0.0010660980810234541, + "mean_prediction": 0.0019209125837431928, + "calibration_in_the_large": 0.0008548145027197386, + "expected_calibration_error_10bin": 0.0008548145027197387, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "E22": { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.8225325217806421, + "auprc": 0.017650262587823436, + "brier": 0.0032766113060274504, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.006058906827100659, + "calibration_in_the_large": 0.0028469153924111515, + "expected_calibration_error_10bin": 0.0028469153924111515, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "E27": { + "valid": 2811, + "positives": 8, + "negatives": 2803, + "auroc": 0.832991437745273, + "auprc": 0.010827994635731836, + "brier": 0.002857650320385664, + "calibration": { + "observed_rate": 0.002845962290999644, + "mean_prediction": 0.0026577847302770366, + "calibration_in_the_large": -0.00018817756072260754, + "expected_calibration_error_10bin": 0.00018817756072260754, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + }, + "E43": { + "valid": 2748, + "positives": 37, + "negatives": 2711, + "auroc": 0.8205010617404568, + "auprc": 0.07467809812494786, + "brier": 0.013117475904486548, + "calibration": { + "observed_rate": 0.013464337700145561, + "mean_prediction": 0.015355191126194585, + "calibration_in_the_large": 0.0018908534260490238, + "expected_calibration_error_10bin": 0.0018908534260490238, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + "E44": { + "valid": 2800, + "positives": 21, + "negatives": 2779, + "auroc": 0.7784574787093679, + "auprc": 0.02396795285690865, + "brier": 0.00758298462843279, + "calibration": { + "observed_rate": 0.0075, + "mean_prediction": 0.009791168485800361, + "calibration_in_the_large": 0.0022911684858003614, + "expected_calibration_error_10bin": 0.002291168485800361, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "E46": { + "valid": 2772, + "positives": 37, + "negatives": 2735, + "auroc": 0.8162853895943476, + "auprc": 0.07722667776756309, + "brier": 0.012928868598760794, + "calibration": { + "observed_rate": 0.013347763347763348, + "mean_prediction": 0.01451064172281818, + "calibration_in_the_large": 0.0011628783750548318, + "expected_calibration_error_10bin": 0.0019267891311493613, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + "E53": { + "valid": 2804, + "positives": 7, + "negatives": 2797, + "auroc": 0.6361407630624649, + "auprc": 0.004314923942502051, + "brier": 0.0025243193980988934, + "calibration": { + "observed_rate": 0.0024964336661911554, + "mean_prediction": 0.003049777263897104, + "calibration_in_the_large": 0.0005533435977059485, + "expected_calibration_error_10bin": 0.0005533435977059485, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "E55": { + "valid": 2737, + "positives": 27, + "negatives": 2710, + "auroc": 0.6200355336886703, + "auprc": 0.015510483973153475, + "brier": 0.009992191058133442, + "calibration": { + "observed_rate": 0.009864815491413957, + "mean_prediction": 0.011903862458690156, + "calibration_in_the_large": 0.0020390469672761993, + "expected_calibration_error_10bin": 0.0020390469672761998, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + "E66": { + "valid": 2371, + "positives": 39, + "negatives": 2332, + "auroc": 0.7392466024541496, + "auprc": 0.052518535972248745, + "brier": 0.015977453055890316, + "calibration": { + "observed_rate": 0.016448755799240825, + "mean_prediction": 0.015050178176455533, + "calibration_in_the_large": -0.001398577622785292, + "expected_calibration_error_10bin": 0.0025345080417534956, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + "E78": { + "valid": 1572, + "positives": 47, + "negatives": 1525, + "auroc": 0.7460481339379142, + "auprc": 0.12720512191703634, + "brier": 0.0286076646425152, + "calibration": { + "observed_rate": 0.02989821882951654, + "mean_prediction": 0.030779142719140288, + "calibration_in_the_large": 0.0008809238896237484, + "expected_calibration_error_10bin": 0.00998508144423242, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + "E80": { + "valid": 2823, + "positives": 7, + "negatives": 2816, + "auroc": 0.789163961038961, + "auprc": 0.019872317042868952, + "brier": 0.0025058450988324635, + "calibration": { + "observed_rate": 0.002479631597591215, + "mean_prediction": 0.0024000609264514887, + "calibration_in_the_large": -7.957067113972642e-05, + "expected_calibration_error_10bin": 0.0005646742102461271, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "E83": { + "valid": 2653, + "positives": 78, + "negatives": 2575, + "auroc": 0.80554642768235, + "auprc": 0.19411493833697266, + "brier": 0.026080578003398875, + "calibration": { + "observed_rate": 0.029400678477195626, + "mean_prediction": 0.023098410744276363, + "calibration_in_the_large": -0.006302267732919264, + "expected_calibration_error_10bin": 0.007272809557191068, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + "E86": { + "valid": 2587, + "positives": 87, + "negatives": 2500, + "auroc": 0.785448275862069, + "auprc": 0.10861071812469882, + "brier": 0.03164959015076291, + "calibration": { + "observed_rate": 0.03362968689601856, + "mean_prediction": 0.041750024874548125, + "calibration_in_the_large": 0.008120337978529568, + "expected_calibration_error_10bin": 0.008171232442425909, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + "E87": { + "valid": 2185, + "positives": 147, + "negatives": 2038, + "auroc": 0.7886717002797193, + "auprc": 0.22284552813830563, + "brier": 0.057655813589332125, + "calibration": { + "observed_rate": 0.06727688787185354, + "mean_prediction": 0.05333521825738797, + "calibration_in_the_large": -0.013941669614465572, + "expected_calibration_error_10bin": 0.017063279624163114, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + "E88": { + "valid": 2817, + "positives": 13, + "negatives": 2804, + "auroc": 0.807033907604521, + "auprc": 0.07612094615408672, + "brier": 0.004478816237494802, + "calibration": { + "observed_rate": 0.004614838480653177, + "mean_prediction": 0.003802324117049216, + "calibration_in_the_large": -0.0008125143636039615, + "expected_calibration_error_10bin": 0.0008125143636039611, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "E89": { + "valid": 2780, + "positives": 8, + "negatives": 2772, + "auroc": 0.597267316017316, + "auprc": 0.004008837821776511, + "brier": 0.0028836154727941298, + "calibration": { + "observed_rate": 0.0028776978417266188, + "mean_prediction": 0.003296239036351037, + "calibration_in_the_large": 0.0004185411946244183, + "expected_calibration_error_10bin": 0.0004185411946244183, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "F02": { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8106683345246605, + "auprc": 0.006095521127254679, + "brier": 0.0014978784702837562, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.0030485601661188527, + "calibration_in_the_large": 0.0016210084173679605, + "expected_calibration_error_10bin": 0.0016210084173679602, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "F03": { + "valid": 2739, + "positives": 14, + "negatives": 2725, + "auroc": 0.8481258191349934, + "auprc": 0.024756136350233583, + "brier": 0.005250951589904259, + "calibration": { + "observed_rate": 0.00511135450894487, + "mean_prediction": 0.00772071422335033, + "calibration_in_the_large": 0.0026093597144054596, + "expected_calibration_error_10bin": 0.0026093597144054587, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "F05": { + "valid": 2750, + "positives": 29, + "negatives": 2721, + "auroc": 0.7149374596053683, + "auprc": 0.021558984414295414, + "brier": 0.010800876313490035, + "calibration": { + "observed_rate": 0.010545454545454545, + "mean_prediction": 0.01323043720423117, + "calibration_in_the_large": 0.0026849826587766242, + "expected_calibration_error_10bin": 0.0026849826587766225, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "F06": { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7112526539278131, + "auprc": 0.0018082032753099545, + "brier": 0.0007326201857754716, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.00292062432838845, + "calibration_in_the_large": 0.0022134107498877425, + "expected_calibration_error_10bin": 0.0022134107498877425, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "F10": { + "valid": 2560, + "positives": 17, + "negatives": 2543, + "auroc": 0.8105526127084731, + "auprc": 0.10273260263313594, + "brier": 0.0063908589126583735, + "calibration": { + "observed_rate": 0.006640625, + "mean_prediction": 0.008519959579416536, + "calibration_in_the_large": 0.0018793345794165363, + "expected_calibration_error_10bin": 0.0023144828055137617, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "F11": { + "valid": 2741, + "positives": 10, + "negatives": 2731, + "auroc": 0.8682533870377152, + "auprc": 0.033934103611858814, + "brier": 0.0036805729474208883, + "calibration": { + "observed_rate": 0.0036483035388544327, + "mean_prediction": 0.004629662746835225, + "calibration_in_the_large": 0.0009813592079807925, + "expected_calibration_error_10bin": 0.0009813592079807923, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "F12": { + "valid": 2777, + "positives": 12, + "negatives": 2765, + "auroc": 0.8963833634719711, + "auprc": 0.02560245378641403, + "brier": 0.004274158382561639, + "calibration": { + "observed_rate": 0.004321209938782859, + "mean_prediction": 0.003664919623374639, + "calibration_in_the_large": -0.0006562903154082203, + "expected_calibration_error_10bin": 0.0007329114262587653, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "F14": { + "valid": 2787, + "positives": 10, + "negatives": 2777, + "auroc": 0.9504861361181131, + "auprc": 0.04887091669997306, + "brier": 0.0035382428243063983, + "calibration": { + "observed_rate": 0.003588087549336204, + "mean_prediction": 0.0014766176611323994, + "calibration_in_the_large": -0.0021114698882038043, + "expected_calibration_error_10bin": 0.0021114698882038043, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "F15": { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.9610696958939771, + "auprc": 0.045969096166763444, + "brier": 0.002100735368247352, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0006948468601482472, + "calibration_in_the_large": -0.0014305516520727942, + "expected_calibration_error_10bin": 0.0014305516520727942, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "F17": { + "valid": 2426, + "positives": 33, + "negatives": 2393, + "auroc": 0.8600336841038889, + "auprc": 0.0937398737403406, + "brier": 0.012929433844865732, + "calibration": { + "observed_rate": 0.013602638087386645, + "mean_prediction": 0.01302606839053114, + "calibration_in_the_large": -0.0005765696968555046, + "expected_calibration_error_10bin": 0.0017333739646240198, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + "F19": { + "valid": 2801, + "positives": 13, + "negatives": 2788, + "auroc": 0.9663392561527425, + "auprc": 0.13886371469662567, + "brier": 0.0044555326847396624, + "calibration": { + "observed_rate": 0.0046411995715815784, + "mean_prediction": 0.0017642450486251328, + "calibration_in_the_large": -0.0028769545229564457, + "expected_calibration_error_10bin": 0.0028769545229564457, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F20": { + "valid": 2808, + "positives": 4, + "negatives": 2804, + "auroc": 0.8246255349500713, + "auprc": 0.014692291234105415, + "brier": 0.001418597939562498, + "calibration": { + "observed_rate": 0.0014245014245014246, + "mean_prediction": 0.0010017881552772305, + "calibration_in_the_large": -0.00042271326922419406, + "expected_calibration_error_10bin": 0.00042271326922419406, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + "F22": { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.7464539007092199, + "auprc": 0.0013966480446927375, + "brier": 0.0003586416524580187, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0011473633375391624, + "calibration_in_the_large": 0.000792879112087195, + "expected_calibration_error_10bin": 0.000792879112087195, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "F25": { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7872869318181818, + "auprc": 0.0055141412784142745, + "brier": 0.0010668803285155406, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0010290198024410922, + "calibration_in_the_large": -3.518736322048982e-05, + "expected_calibration_error_10bin": 3.518736322048982e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "F29": { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7629110078627591, + "auprc": 0.010136458841637188, + "brier": 0.0028440113534710055, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.0008051672162091705, + "calibration_in_the_large": -0.0020458662834344503, + "expected_calibration_error_10bin": 0.0020458662834344503, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "F31": { + "valid": 2724, + "positives": 9, + "negatives": 2715, + "auroc": 0.8550439942705136, + "auprc": 0.03343233759421324, + "brier": 0.0032551493787464163, + "calibration": { + "observed_rate": 0.003303964757709251, + "mean_prediction": 0.0032119541733483642, + "calibration_in_the_large": -9.201058436088694e-05, + "expected_calibration_error_10bin": 9.201058436088694e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + "F32": { + "valid": 2200, + "positives": 66, + "negatives": 2134, + "auroc": 0.7159907415296356, + "auprc": 0.082116716450268, + "brier": 0.028924998189938263, + "calibration": { + "observed_rate": 0.03, + "mean_prediction": 0.03949591207222759, + "calibration_in_the_large": 0.009495912072227594, + "expected_calibration_error_10bin": 0.009495912072227589, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + "F33": { + "valid": 2800, + "positives": 12, + "negatives": 2788, + "auroc": 0.7924736967957915, + "auprc": 0.015211382646314253, + "brier": 0.004285103429936338, + "calibration": { + "observed_rate": 0.004285714285714286, + "mean_prediction": 0.00322703494356704, + "calibration_in_the_large": -0.0010586793421472457, + "expected_calibration_error_10bin": 0.0010586793421472457, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "F39": { + "valid": 2801, + "positives": 11, + "negatives": 2790, + "auroc": 0.7157706093189964, + "auprc": 0.01882071861352778, + "brier": 0.003898805181935963, + "calibration": { + "observed_rate": 0.003927168868261335, + "mean_prediction": 0.00295741195296276, + "calibration_in_the_large": -0.0009697569152985752, + "expected_calibration_error_10bin": 0.0009697569152985752, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F41": { + "valid": 2247, + "positives": 78, + "negatives": 2169, + "auroc": 0.7060561998321334, + "auprc": 0.10049530945317835, + "brier": 0.03263028525458922, + "calibration": { + "observed_rate": 0.03471295060080107, + "mean_prediction": 0.035790574983505075, + "calibration_in_the_large": 0.0010776243827040066, + "expected_calibration_error_10bin": 0.0033560369054330542, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + "F43": { + "valid": 2734, + "positives": 20, + "negatives": 2714, + "auroc": 0.7484893146647016, + "auprc": 0.05874346353143761, + "brier": 0.007168251039164135, + "calibration": { + "observed_rate": 0.0073152889539136795, + "mean_prediction": 0.00858051651955186, + "calibration_in_the_large": 0.0012652275656381802, + "expected_calibration_error_10bin": 0.0017040121233891782, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "F60": { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.9475462304409673, + "auprc": 0.06681427636817895, + "brier": 0.002068838558120871, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.002051100264755601, + "calibration_in_the_large": -7.806935909109892e-05, + "expected_calibration_error_10bin": 0.0001585791961337165, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "F90": { + "valid": 2775, + "positives": 8, + "negatives": 2767, + "auroc": 0.8955095771593784, + "auprc": 0.033193906341783874, + "brier": 0.002859458999806959, + "calibration": { + "observed_rate": 0.002882882882882883, + "mean_prediction": 0.0010474637065249022, + "calibration_in_the_large": -0.0018354191763579808, + "expected_calibration_error_10bin": 0.0018354191763579808, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "G25": { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.6980973025048169, + "auprc": 0.0049183250443565335, + "brier": 0.0021854300334644004, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.0038038373711375964, + "calibration_in_the_large": 0.001640895770560812, + "expected_calibration_error_10bin": 0.001640895770560812, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "G31": { + "valid": 2802, + "positives": 8, + "negatives": 2794, + "auroc": 0.7968861846814602, + "auprc": 0.008760687884495586, + "brier": 0.0030003131018974598, + "calibration": { + "observed_rate": 0.0028551034975017845, + "mean_prediction": 0.0051400842421117305, + "calibration_in_the_large": 0.002284980744609946, + "expected_calibration_error_10bin": 0.0022849807446099456, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "G40": { + "valid": 2723, + "positives": 24, + "negatives": 2699, + "auroc": 0.7451062121773496, + "auprc": 0.047952900807445985, + "brier": 0.008687412405814094, + "calibration": { + "observed_rate": 0.008813808299669483, + "mean_prediction": 0.008128900396315862, + "calibration_in_the_large": -0.0006849079033536213, + "expected_calibration_error_10bin": 0.0012253412365477476, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "G43": { + "valid": 2725, + "positives": 15, + "negatives": 2710, + "auroc": 0.7753013530135301, + "auprc": 0.017589184460402238, + "brier": 0.005461212531880303, + "calibration": { + "observed_rate": 0.005504587155963303, + "mean_prediction": 0.0036349745773616325, + "calibration_in_the_large": -0.0018696125786016706, + "expected_calibration_error_10bin": 0.0018696125786016706, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + "G44": { + "valid": 2805, + "positives": 7, + "negatives": 2798, + "auroc": 0.6822730521801287, + "auprc": 0.006380319356974281, + "brier": 0.0025023751206187336, + "calibration": { + "observed_rate": 0.0024955436720142605, + "mean_prediction": 0.0017245438425984722, + "calibration_in_the_large": -0.0007709998294157883, + "expected_calibration_error_10bin": 0.0007709998294157883, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "G47": { + "valid": 2315, + "positives": 84, + "negatives": 2231, + "auroc": 0.6916661330601268, + "auprc": 0.08369206045639098, + "brier": 0.034365234121902295, + "calibration": { + "observed_rate": 0.03628509719222462, + "mean_prediction": 0.03085062549837722, + "calibration_in_the_large": -0.005434471693847399, + "expected_calibration_error_10bin": 0.006873137592368197, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + "G51": { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 1.020872277188829e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0006535024206262207, + "calibration_in_the_large": 0.0006535024206262207, + "expected_calibration_error_10bin": 0.0006535024206262207, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + "G62": { + "valid": 2751, + "positives": 34, + "negatives": 2717, + "auroc": 0.8290177314945116, + "auprc": 0.10434080560660058, + "brier": 0.01164723741095772, + "calibration": { + "observed_rate": 0.012359142130134497, + "mean_prediction": 0.008890979629603592, + "calibration_in_the_large": -0.0034681625005309052, + "expected_calibration_error_10bin": 0.003763416058414182, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "G81": { + "valid": 2789, + "positives": 14, + "negatives": 2775, + "auroc": 0.7482368082368083, + "auprc": 0.03038392981854321, + "brier": 0.004975832710333216, + "calibration": { + "observed_rate": 0.005019720329867336, + "mean_prediction": 0.003237737936101043, + "calibration_in_the_large": -0.0017819823937662927, + "expected_calibration_error_10bin": 0.002077195095151397, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "G83": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.7411083540115798, + "auprc": 0.00455804422270818, + "brier": 0.0010690679225061426, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0014355498801177657, + "calibration_in_the_large": 0.0003732269339421282, + "expected_calibration_error_10bin": 0.0003732269339421282, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "G89": { + "valid": 2537, + "positives": 61, + "negatives": 2476, + "auroc": 0.7707831245530867, + "auprc": 0.12023882139716746, + "brier": 0.022637074956436062, + "calibration": { + "observed_rate": 0.02404414662987781, + "mean_prediction": 0.029621454600481906, + "calibration_in_the_large": 0.005577307970604097, + "expected_calibration_error_10bin": 0.0066274977130371185, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + "G90": { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 2.6113409406275343e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0021822143737850806, + "calibration_in_the_large": 0.0021822143737850806, + "expected_calibration_error_10bin": 0.0021822143737850806, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "G92": { + "valid": 2733, + "positives": 42, + "negatives": 2691, + "auroc": 0.745483180265789, + "auprc": 0.0647940678126089, + "brier": 0.015229755512988177, + "calibration": { + "observed_rate": 0.015367727771679473, + "mean_prediction": 0.02055706494723741, + "calibration_in_the_large": 0.005189337175557937, + "expected_calibration_error_10bin": 0.005922218483944998, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "G93": { + "valid": 2656, + "positives": 47, + "negatives": 2609, + "auroc": 0.7997276204300987, + "auprc": 0.06927075799454578, + "brier": 0.01702069836610844, + "calibration": { + "observed_rate": 0.017695783132530122, + "mean_prediction": 0.01711002977689455, + "calibration_in_the_large": -0.000585753355635571, + "expected_calibration_error_10bin": 0.0020655149464801075, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + "G99": { + "valid": 2841, + "positives": 1, + "negatives": 2840, + "auroc": 0.8718309859154929, + "auprc": 0.0027397260273972603, + "brier": 0.0003527546686154955, + "calibration": { + "observed_rate": 0.00035198873636043646, + "mean_prediction": 0.0004801167743329113, + "calibration_in_the_large": 0.00012812803797247486, + "expected_calibration_error_10bin": 0.00012812803797247486, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9992965177629265 + }, + "H10": { + "valid": 2832, + "positives": 5, + "negatives": 2827, + "auroc": 0.8759816059426955, + "auprc": 0.012791389377504472, + "brier": 0.0017604136020387474, + "calibration": { + "observed_rate": 0.0017655367231638418, + "mean_prediction": 0.0010971006794146384, + "calibration_in_the_large": -0.0006684360437492034, + "expected_calibration_error_10bin": 0.0006684360437492034, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "H26": { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 1.2240340944251123e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0017733755167821884, + "calibration_in_the_large": 0.0017733755167821884, + "expected_calibration_error_10bin": 0.0017733755167821884, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "H35": { + "valid": 2806, + "positives": 6, + "negatives": 2800, + "auroc": 0.7328571428571429, + "auprc": 0.007203475263272777, + "brier": 0.002136455791034304, + "calibration": { + "observed_rate": 0.0021382751247327157, + "mean_prediction": 0.0009433783757422374, + "calibration_in_the_large": -0.0011948967489904783, + "expected_calibration_error_10bin": 0.0011948967489904783, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "H40": { + "valid": 2750, + "positives": 9, + "negatives": 2741, + "auroc": 0.7137297823178889, + "auprc": 0.023525080738848198, + "brier": 0.003287176658187545, + "calibration": { + "observed_rate": 0.0032727272727272726, + "mean_prediction": 0.004810249031128478, + "calibration_in_the_large": 0.0015375217584012056, + "expected_calibration_error_10bin": 0.0015375217584012051, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "H53": { + "valid": 2790, + "positives": 12, + "negatives": 2778, + "auroc": 0.6025917926565875, + "auprc": 0.010471118628856649, + "brier": 0.004306544928865659, + "calibration": { + "observed_rate": 0.004301075268817204, + "mean_prediction": 0.005499711490797854, + "calibration_in_the_large": 0.0011986362219806495, + "expected_calibration_error_10bin": 0.0011986362219806495, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "H54": { + "valid": 2809, + "positives": 3, + "negatives": 2806, + "auroc": 0.4458303635067712, + "auprc": 0.0012290008387772805, + "brier": 0.0011008529439700016, + "calibration": { + "observed_rate": 0.001067995728017088, + "mean_prediction": 0.0029555653158543013, + "calibration_in_the_large": 0.0018875695878372133, + "expected_calibration_error_10bin": 0.0018875695878372133, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "H91": { + "valid": 2791, + "positives": 7, + "negatives": 2784, + "auroc": 0.7559523809523809, + "auprc": 0.00855697594632038, + "brier": 0.002510564756899044, + "calibration": { + "observed_rate": 0.0025080616266571123, + "mean_prediction": 0.0030777330689021115, + "calibration_in_the_large": 0.0005696714422449992, + "expected_calibration_error_10bin": 0.0005696714422449992, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + "I07": { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.8719678144598272, + "auprc": 0.010255338853631443, + "brier": 0.0021376818731943968, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0014448684310051565, + "calibration_in_the_large": -0.0006805300812158849, + "expected_calibration_error_10bin": 0.0008383542441071904, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "I08": { + "valid": 2767, + "positives": 12, + "negatives": 2755, + "auroc": 0.8698124621899577, + "auprc": 0.026677377392102204, + "brier": 0.004650145046721754, + "calibration": { + "observed_rate": 0.0043368268883267076, + "mean_prediction": 0.008179050983321447, + "calibration_in_the_large": 0.0038422240949947395, + "expected_calibration_error_10bin": 0.0038422240949947404, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + "I10": { + "valid": 1498, + "positives": 40, + "negatives": 1458, + "auroc": 0.6801097393689987, + "auprc": 0.06453995193046583, + "brier": 0.02598800014901961, + "calibration": { + "observed_rate": 0.0267022696929239, + "mean_prediction": 0.020202559426048265, + "calibration_in_the_large": -0.006499710266875635, + "expected_calibration_error_10bin": 0.00993243938298568, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + "I11": { + "valid": 2676, + "positives": 48, + "negatives": 2628, + "auroc": 0.80900399543379, + "auprc": 0.06784018604474637, + "brier": 0.01734301235471971, + "calibration": { + "observed_rate": 0.017937219730941704, + "mean_prediction": 0.012245317376936217, + "calibration_in_the_large": -0.005691902354005487, + "expected_calibration_error_10bin": 0.007471891029379573, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + "I12": { + "valid": 2552, + "positives": 28, + "negatives": 2524, + "auroc": 0.8443089200815033, + "auprc": 0.06287585682744874, + "brier": 0.010809658913405662, + "calibration": { + "observed_rate": 0.0109717868338558, + "mean_prediction": 0.008206241321090246, + "calibration_in_the_large": -0.0027655455127655534, + "expected_calibration_error_10bin": 0.004947691235466438, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + "I13": { + "valid": 2727, + "positives": 27, + "negatives": 2700, + "auroc": 0.8964471879286694, + "auprc": 0.12006044613738569, + "brier": 0.00930100286499386, + "calibration": { + "observed_rate": 0.009900990099009901, + "mean_prediction": 0.011180770982663938, + "calibration_in_the_large": 0.0012797808836540366, + "expected_calibration_error_10bin": 0.002289205695284091, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + "I16": { + "valid": 2390, + "positives": 11, + "negatives": 2379, + "auroc": 0.8951813214108296, + "auprc": 0.03301715663393849, + "brier": 0.00454108965940709, + "calibration": { + "observed_rate": 0.004602510460251046, + "mean_prediction": 0.002826799949289277, + "calibration_in_the_large": -0.0017757105109617692, + "expected_calibration_error_10bin": 0.0017757105109617692, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + "I21": { + "valid": 2671, + "positives": 20, + "negatives": 2651, + "auroc": 0.8352319879290834, + "auprc": 0.03854673305586736, + "brier": 0.0075600345209558065, + "calibration": { + "observed_rate": 0.007487832272557095, + "mean_prediction": 0.013149935357906001, + "calibration_in_the_large": 0.005662103085348907, + "expected_calibration_error_10bin": 0.005662103085348905, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "I24": { + "valid": 2809, + "positives": 8, + "negatives": 2801, + "auroc": 0.9074883970010711, + "auprc": 0.03575920329953816, + "brier": 0.002807285963763098, + "calibration": { + "observed_rate": 0.002847988608045568, + "mean_prediction": 0.001966583585826005, + "calibration_in_the_large": -0.000881405022219563, + "expected_calibration_error_10bin": 0.000881405022219563, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "I25": { + "valid": 2243, + "positives": 40, + "negatives": 2203, + "auroc": 0.8398433953699501, + "auprc": 0.07409980561728718, + "brier": 0.017040129058848823, + "calibration": { + "observed_rate": 0.017833259028087384, + "mean_prediction": 0.015985531567289057, + "calibration_in_the_large": -0.001847727460798327, + "expected_calibration_error_10bin": 0.0033400151968904176, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + "I26": { + "valid": 2760, + "positives": 18, + "negatives": 2742, + "auroc": 0.7336291433665613, + "auprc": 0.13324135094354114, + "brier": 0.0062550595160891275, + "calibration": { + "observed_rate": 0.006521739130434782, + "mean_prediction": 0.0062594271182404, + "calibration_in_the_large": -0.00026231201219438244, + "expected_calibration_error_10bin": 0.0011172780913973153, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + "I27": { + "valid": 2716, + "positives": 34, + "negatives": 2682, + "auroc": 0.8360529894284335, + "auprc": 0.05374651262328337, + "brier": 0.012256161567521694, + "calibration": { + "observed_rate": 0.012518409425625921, + "mean_prediction": 0.01006217455265408, + "calibration_in_the_large": -0.0024562348729718405, + "expected_calibration_error_10bin": 0.006051202792279021, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I31": { + "valid": 2793, + "positives": 16, + "negatives": 2777, + "auroc": 0.825846236946345, + "auprc": 0.0840704877654926, + "brier": 0.005625128492589412, + "calibration": { + "observed_rate": 0.005728607232366631, + "mean_prediction": 0.003981085743734074, + "calibration_in_the_large": -0.0017475214886325573, + "expected_calibration_error_10bin": 0.0017475214886325573, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I34": { + "valid": 2753, + "positives": 18, + "negatives": 2735, + "auroc": 0.7639244363193175, + "auprc": 0.019491422748964576, + "brier": 0.006588695877024296, + "calibration": { + "observed_rate": 0.006538321830730113, + "mean_prediction": 0.005775719914556745, + "calibration_in_the_large": -0.000762601916173368, + "expected_calibration_error_10bin": 0.0018573978231024827, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + "I35": { + "valid": 2723, + "positives": 7, + "negatives": 2716, + "auroc": 0.7059751735745845, + "auprc": 0.007942056403173286, + "brier": 0.002694791066069988, + "calibration": { + "observed_rate": 0.002570694087403599, + "mean_prediction": 0.004738830734551963, + "calibration_in_the_large": 0.002168136647148364, + "expected_calibration_error_10bin": 0.0021681366471483637, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "I42": { + "valid": 2740, + "positives": 13, + "negatives": 2727, + "auroc": 0.9209049110039209, + "auprc": 0.059602416864197524, + "brier": 0.00462722286498165, + "calibration": { + "observed_rate": 0.004744525547445255, + "mean_prediction": 0.0044754544763004125, + "calibration_in_the_large": -0.0002690710711448427, + "expected_calibration_error_10bin": 0.0003986336983698692, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "I44": { + "valid": 2722, + "positives": 23, + "negatives": 2699, + "auroc": 0.827730077162234, + "auprc": 0.06366206929705609, + "brier": 0.008223315195027947, + "calibration": { + "observed_rate": 0.008449669360764144, + "mean_prediction": 0.009362895868920683, + "calibration_in_the_large": 0.000913226508156539, + "expected_calibration_error_10bin": 0.0009132265081565385, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + "I45": { + "valid": 2766, + "positives": 18, + "negatives": 2748, + "auroc": 0.6908660844250364, + "auprc": 0.02766751856590062, + "brier": 0.006449547054728393, + "calibration": { + "observed_rate": 0.006507592190889371, + "mean_prediction": 0.007352094394939367, + "calibration_in_the_large": 0.0008445022040499961, + "expected_calibration_error_10bin": 0.0008445022040499961, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + "I46": { + "valid": 2831, + "positives": 3, + "negatives": 2828, + "auroc": 0.5759075907590759, + "auprc": 0.0015903188042999822, + "brier": 0.0010735298532562679, + "calibration": { + "observed_rate": 0.0010596962204168139, + "mean_prediction": 0.002155510641432701, + "calibration_in_the_large": 0.0010958144210158872, + "expected_calibration_error_10bin": 0.0010958144210158872, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I47": { + "valid": 2716, + "positives": 18, + "negatives": 2698, + "auroc": 0.6946709496746561, + "auprc": 0.014638246342350189, + "brier": 0.0066589096312734235, + "calibration": { + "observed_rate": 0.0066273932253313695, + "mean_prediction": 0.008705670738147656, + "calibration_in_the_large": 0.0020782775128162867, + "expected_calibration_error_10bin": 0.0020782775128162867, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I48": { + "valid": 2385, + "positives": 30, + "negatives": 2355, + "auroc": 0.7334041047416844, + "auprc": 0.029723846509149488, + "brier": 0.012485671105908331, + "calibration": { + "observed_rate": 0.012578616352201259, + "mean_prediction": 0.011730652529049755, + "calibration_in_the_large": -0.0008479638231515037, + "expected_calibration_error_10bin": 0.002338037700712021, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + "I49": { + "valid": 2734, + "positives": 17, + "negatives": 2717, + "auroc": 0.6956851198337266, + "auprc": 0.012294064371799706, + "brier": 0.006180882414585099, + "calibration": { + "observed_rate": 0.006217995610826628, + "mean_prediction": 0.00471988997295737, + "calibration_in_the_large": -0.0014981056378692579, + "expected_calibration_error_10bin": 0.0014981056378692579, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I50": { + "valid": 2415, + "positives": 46, + "negatives": 2369, + "auroc": 0.8024849964211647, + "auprc": 0.08866701759525573, + "brier": 0.018594755558792204, + "calibration": { + "observed_rate": 0.01904761904761905, + "mean_prediction": 0.01929733795927925, + "calibration_in_the_large": 0.00024971891166020166, + "expected_calibration_error_10bin": 0.004755147383072293, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + "I51": { + "valid": 2807, + "positives": 8, + "negatives": 2799, + "auroc": 0.8481153983565559, + "auprc": 0.010781259431152346, + "brier": 0.0028380879144994206, + "calibration": { + "observed_rate": 0.0028500178126113287, + "mean_prediction": 0.002259024218875516, + "calibration_in_the_large": -0.0005909935937358128, + "expected_calibration_error_10bin": 0.0005909935937358128, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "I61": { + "valid": 2802, + "positives": 8, + "negatives": 2794, + "auroc": 0.8465909090909091, + "auprc": 0.011839644905634376, + "brier": 0.002845874237579053, + "calibration": { + "observed_rate": 0.0028551034975017845, + "mean_prediction": 0.0011185886834702262, + "calibration_in_the_large": -0.0017365148140315583, + "expected_calibration_error_10bin": 0.0017365148140315583, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "I63": { + "valid": 2735, + "positives": 14, + "negatives": 2721, + "auroc": 0.7778127789153148, + "auprc": 0.01774408093906301, + "brier": 0.005142052251570009, + "calibration": { + "observed_rate": 0.005118829981718464, + "mean_prediction": 0.004945819203705562, + "calibration_in_the_large": -0.00017301077801290272, + "expected_calibration_error_10bin": 0.000684633343115, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + "I65": { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.6313222543352601, + "auprc": 0.00958587720825824, + "brier": 0.0021726491674021902, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.003325920083655041, + "calibration_in_the_large": 0.0011629784830782565, + "expected_calibration_error_10bin": 0.0011629784830782565, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "I67": { + "valid": 2773, + "positives": 3, + "negatives": 2770, + "auroc": 0.6303249097472924, + "auprc": 0.00310688138604324, + "brier": 0.0011278947474103109, + "calibration": { + "observed_rate": 0.0010818608005769925, + "mean_prediction": 0.0031819218038573547, + "calibration_in_the_large": 0.0021000610032803624, + "expected_calibration_error_10bin": 0.0021000610032803624, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "I69": { + "valid": 2752, + "positives": 17, + "negatives": 2735, + "auroc": 0.7628777287880417, + "auprc": 0.028100679242274978, + "brier": 0.006150419912210225, + "calibration": { + "observed_rate": 0.0061773255813953485, + "mean_prediction": 0.007119124487052283, + "calibration_in_the_large": 0.0009417989056569346, + "expected_calibration_error_10bin": 0.0009417989056569343, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + "I70": { + "valid": 2771, + "positives": 12, + "negatives": 2759, + "auroc": 0.8145161290322581, + "auprc": 0.024255680858652522, + "brier": 0.004294988634577167, + "calibration": { + "observed_rate": 0.004330566582461205, + "mean_prediction": 0.002844595395811002, + "calibration_in_the_large": -0.001485971186650203, + "expected_calibration_error_10bin": 0.001485971186650203, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + "I71": { + "valid": 2769, + "positives": 5, + "negatives": 2764, + "auroc": 0.7477568740955137, + "auprc": 0.005510206278485093, + "brier": 0.0018162203013981587, + "calibration": { + "observed_rate": 0.0018057060310581437, + "mean_prediction": 0.002710853444559751, + "calibration_in_the_large": 0.0009051474135016073, + "expected_calibration_error_10bin": 0.0009051474135016073, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + "I72": { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.6928046467520151, + "auprc": 0.008430655902349472, + "brier": 0.002130221179623407, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.001546987179352936, + "calibration_in_the_large": -0.0005821824444937637, + "expected_calibration_error_10bin": 0.0005821824444937637, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "I73": { + "valid": 2734, + "positives": 10, + "negatives": 2724, + "auroc": 0.8372613803230543, + "auprc": 0.11158030580391291, + "brier": 0.003505511437091176, + "calibration": { + "observed_rate": 0.0036576444769568397, + "mean_prediction": 0.0027477154351496593, + "calibration_in_the_large": -0.0009099290418071804, + "expected_calibration_error_10bin": 0.000996423894768293, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I74": { + "valid": 2821, + "positives": 5, + "negatives": 2816, + "auroc": 0.5866477272727273, + "auprc": 0.0038869186592101527, + "brier": 0.0017710131154186214, + "calibration": { + "observed_rate": 0.001772421127259837, + "mean_prediction": 0.0008928618679143121, + "calibration_in_the_large": -0.0008795592593455248, + "expected_calibration_error_10bin": 0.0008795592593455248, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "I77": { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.715005397625045, + "auprc": 0.008703428030520351, + "brier": 0.002151858314386399, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.0023143841375373605, + "calibration_in_the_large": 0.0001599855738030698, + "expected_calibration_error_10bin": 0.0001599855738030698, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "I80": { + "valid": 2827, + "positives": 5, + "negatives": 2822, + "auroc": 0.8874557051736357, + "auprc": 0.07428065160586249, + "brier": 0.0017373199578752455, + "calibration": { + "observed_rate": 0.0017686593562079944, + "mean_prediction": 0.0014079729755048986, + "calibration_in_the_large": -0.0003606863807030958, + "expected_calibration_error_10bin": 0.000453147015894747, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "I81": { + "valid": 2826, + "positives": 8, + "negatives": 2818, + "auroc": 0.7605571327182399, + "auprc": 0.020606903465845317, + "brier": 0.0029392732738220927, + "calibration": { + "observed_rate": 0.0028308563340410475, + "mean_prediction": 0.0024878134021490573, + "calibration_in_the_large": -0.0003430429318919902, + "expected_calibration_error_10bin": 0.0012991118954848, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I82": { + "valid": 2739, + "positives": 32, + "negatives": 2707, + "auroc": 0.7337458441078685, + "auprc": 0.039298446576952466, + "brier": 0.011608199082631047, + "calibration": { + "observed_rate": 0.011683096020445418, + "mean_prediction": 0.011146424289619535, + "calibration_in_the_large": -0.0005366717308258832, + "expected_calibration_error_10bin": 0.0028649126272810082, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "I85": { + "valid": 2793, + "positives": 9, + "negatives": 2784, + "auroc": 0.9912994891443168, + "auprc": 0.2255604918602432, + "brier": 0.003049804928259563, + "calibration": { + "observed_rate": 0.00322234156820623, + "mean_prediction": 0.0020654738168263236, + "calibration_in_the_large": -0.0011568677513799064, + "expected_calibration_error_10bin": 0.002310187644065165, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I87": { + "valid": 2780, + "positives": 13, + "negatives": 2767, + "auroc": 0.7424592032470602, + "auprc": 0.020059886488986187, + "brier": 0.004669867836515801, + "calibration": { + "observed_rate": 0.004676258992805755, + "mean_prediction": 0.005638248764533129, + "calibration_in_the_large": 0.0009619897717273737, + "expected_calibration_error_10bin": 0.0009619897717273737, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "I89": { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8416873449131513, + "auprc": 0.01220872877122877, + "brier": 0.0017631563445240418, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0007437053506092632, + "calibration_in_the_large": -0.0010255798581663912, + "expected_calibration_error_10bin": 0.0010255798581663912, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I95": { + "valid": 2485, + "positives": 93, + "negatives": 2392, + "auroc": 0.7532455856439026, + "auprc": 0.09199588240873419, + "brier": 0.035155916842679234, + "calibration": { + "observed_rate": 0.03742454728370221, + "mean_prediction": 0.033977597314954346, + "calibration_in_the_large": -0.0034469499687478644, + "expected_calibration_error_10bin": 0.009576357941384943, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + "I96": { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.8685774946921444, + "auprc": 0.03583936630395253, + "brier": 0.0017436557513310568, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0017741539145681303, + "calibration_in_the_large": 7.99354720677401e-06, + "expected_calibration_error_10bin": 7.99354720677401e-06, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I97": { + "valid": 2740, + "positives": 11, + "negatives": 2729, + "auroc": 0.7667144142043373, + "auprc": 0.01334897909784376, + "brier": 0.003992567292246592, + "calibration": { + "observed_rate": 0.0040145985401459855, + "mean_prediction": 0.003537432932225651, + "calibration_in_the_large": -0.0004771656079203346, + "expected_calibration_error_10bin": 0.0004771656079203346, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "J02": { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.6769394261424017, + "auprc": 0.0016260562467910731, + "brier": 0.0007291728536517379, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0018071582407095115, + "calibration_in_the_large": 0.0010991936389396, + "expected_calibration_error_10bin": 0.0010991936389396, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J06": { + "valid": 2816, + "positives": 9, + "negatives": 2807, + "auroc": 0.7473380041958596, + "auprc": 0.01278166251838033, + "brier": 0.003275360203764475, + "calibration": { + "observed_rate": 0.0031960227272727275, + "mean_prediction": 0.0038084013440311537, + "calibration_in_the_large": 0.0006123786167584262, + "expected_calibration_error_10bin": 0.0006123786167584266, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "J12": { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.9632248939179632, + "auprc": 0.009523809523809525, + "brier": 0.0004698001765422277, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.0031422907541622737, + "calibration_in_the_large": 0.0027888089584747516, + "expected_calibration_error_10bin": 0.002788808958474751, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J15": { + "valid": 2795, + "positives": 15, + "negatives": 2780, + "auroc": 0.8070023980815347, + "auprc": 0.02095564870878765, + "brier": 0.005413994320266226, + "calibration": { + "observed_rate": 0.005366726296958855, + "mean_prediction": 0.0063379339733464985, + "calibration_in_the_large": 0.0009712076763876438, + "expected_calibration_error_10bin": 0.0009712076763876427, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + "J18": { + "valid": 2671, + "positives": 55, + "negatives": 2616, + "auroc": 0.7733110925771476, + "auprc": 0.06850398399856275, + "brier": 0.01995043768479414, + "calibration": { + "observed_rate": 0.02059153874953201, + "mean_prediction": 0.020169520036045264, + "calibration_in_the_large": -0.0004220187134867451, + "expected_calibration_error_10bin": 0.004540684955986618, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "J30": { + "valid": 2815, + "positives": 7, + "negatives": 2808, + "auroc": 0.747914122914123, + "auprc": 0.029688402003588056, + "brier": 0.0024787338659917357, + "calibration": { + "observed_rate": 0.002486678507992895, + "mean_prediction": 0.003144536456431272, + "calibration_in_the_large": 0.0006578579484383769, + "expected_calibration_error_10bin": 0.000657857948438377, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "J32": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.51326494517156, + "auprc": 0.0026570764302321016, + "brier": 0.0007291095856373893, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0013888417968755116, + "calibration_in_the_large": 0.0006818782055004674, + "expected_calibration_error_10bin": 0.0006818782055004674, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J38": { + "valid": 2825, + "positives": 3, + "negatives": 2822, + "auroc": 0.7500590597684857, + "auprc": 0.00371617192128328, + "brier": 0.0010695073547105252, + "calibration": { + "observed_rate": 0.0010619469026548673, + "mean_prediction": 0.001630224783803631, + "calibration_in_the_large": 0.0005682778811487636, + "expected_calibration_error_10bin": 0.0005682778811487636, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J43": { + "valid": 2804, + "positives": 8, + "negatives": 2796, + "auroc": 0.6282188841201717, + "auprc": 0.0051624498493672115, + "brier": 0.002863524361264115, + "calibration": { + "observed_rate": 0.0028530670470756064, + "mean_prediction": 0.0019189040264639603, + "calibration_in_the_large": -0.0009341630206116461, + "expected_calibration_error_10bin": 0.00102069626907869, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "J44": { + "valid": 2570, + "positives": 27, + "negatives": 2543, + "auroc": 0.7973085157512999, + "auprc": 0.03647294847524801, + "brier": 0.010323844547604693, + "calibration": { + "observed_rate": 0.010505836575875487, + "mean_prediction": 0.008164501890897069, + "calibration_in_the_large": -0.002341334684978418, + "expected_calibration_error_10bin": 0.003277469406960758, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + "J45": { + "valid": 2518, + "positives": 23, + "negatives": 2495, + "auroc": 0.6987366036420667, + "auprc": 0.023780664992074475, + "brier": 0.009037362678969926, + "calibration": { + "observed_rate": 0.009134233518665607, + "mean_prediction": 0.00803976786549712, + "calibration_in_the_large": -0.0010944656531684874, + "expected_calibration_error_10bin": 0.0014001750829934735, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + "J47": { + "valid": 2825, + "positives": 6, + "negatives": 2819, + "auroc": 0.8622442946671397, + "auprc": 0.014794569377046861, + "brier": 0.0021180328845870253, + "calibration": { + "observed_rate": 0.0021238938053097347, + "mean_prediction": 0.00090759813658932, + "calibration_in_the_large": -0.0012162956687204146, + "expected_calibration_error_10bin": 0.0012162956687204146, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J69": { + "valid": 2777, + "positives": 27, + "negatives": 2750, + "auroc": 0.7628552188552189, + "auprc": 0.03287896342372157, + "brier": 0.009660759566611467, + "calibration": { + "observed_rate": 0.009722722362261434, + "mean_prediction": 0.010775505630553807, + "calibration_in_the_large": 0.0010527832682923725, + "expected_calibration_error_10bin": 0.0010527832682923725, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "J81": { + "valid": 2781, + "positives": 20, + "negatives": 2761, + "auroc": 0.7781238681637088, + "auprc": 0.027523417328503837, + "brier": 0.007111484953057985, + "calibration": { + "observed_rate": 0.00719165767709457, + "mean_prediction": 0.0034542228356288836, + "calibration_in_the_large": -0.0037374348414656866, + "expected_calibration_error_10bin": 0.0037374348414656866, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "J84": { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.9141840366039654, + "auprc": 0.032337751452599074, + "brier": 0.0024554229026758413, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.0018780908019474585, + "calibration_in_the_large": -0.00060682222609656, + "expected_calibration_error_10bin": 0.00060682222609656, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "J90": { + "valid": 2754, + "positives": 36, + "negatives": 2718, + "auroc": 0.7106430381816695, + "auprc": 0.02714512590129732, + "brier": 0.013040238216988098, + "calibration": { + "observed_rate": 0.013071895424836602, + "mean_prediction": 0.010403423092641497, + "calibration_in_the_large": -0.0026684723321951046, + "expected_calibration_error_10bin": 0.004320477171959632, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + "J91": { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.8211297819091884, + "auprc": 0.057420386737955895, + "brier": 0.0035044253928727446, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.004047857637773179, + "calibration_in_the_large": 0.00048533537200901814, + "expected_calibration_error_10bin": 0.0007316778015054214, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "J94": { + "valid": 2829, + "positives": 10, + "negatives": 2819, + "auroc": 0.7241220290883292, + "auprc": 0.11740746972597542, + "brier": 0.0034752250812540813, + "calibration": { + "observed_rate": 0.003534817956875221, + "mean_prediction": 0.001496502869800411, + "calibration_in_the_large": -0.0020383150870748098, + "expected_calibration_error_10bin": 0.0020383150870748098, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J95": { + "valid": 2770, + "positives": 14, + "negatives": 2756, + "auroc": 0.8182925565001037, + "auprc": 0.03046701671754601, + "brier": 0.004981434357132112, + "calibration": { + "observed_rate": 0.005054151624548736, + "mean_prediction": 0.0053539471150599064, + "calibration_in_the_large": 0.00029979549051117015, + "expected_calibration_error_10bin": 0.0002997954905111707, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + "J96": { + "valid": 2605, + "positives": 70, + "negatives": 2535, + "auroc": 0.8224852071005917, + "auprc": 0.10443593985930233, + "brier": 0.02560116429771178, + "calibration": { + "observed_rate": 0.026871401151631478, + "mean_prediction": 0.02617222282183294, + "calibration_in_the_large": -0.0006991783297985374, + "expected_calibration_error_10bin": 0.006515509440879124, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + "J98": { + "valid": 2692, + "positives": 35, + "negatives": 2657, + "auroc": 0.7792461960320447, + "auprc": 0.057207046499284556, + "brier": 0.012587786715271774, + "calibration": { + "observed_rate": 0.01300148588410104, + "mean_prediction": 0.01035688534942011, + "calibration_in_the_large": -0.00264460053468093, + "expected_calibration_error_10bin": 0.0029996111184341476, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + "K04": { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9530698659139026, + "auprc": 0.011317135549872123, + "brier": 0.0007042634444175491, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0008916379267539168, + "calibration_in_the_large": 0.00018641930898240764, + "expected_calibration_error_10bin": 0.00018641930898240764, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "K12": { + "valid": 2824, + "positives": 14, + "negatives": 2810, + "auroc": 0.8723945094051856, + "auprc": 0.08626774680926723, + "brier": 0.005301952861970861, + "calibration": { + "observed_rate": 0.004957507082152974, + "mean_prediction": 0.004544501541366545, + "calibration_in_the_large": -0.00041300554078642967, + "expected_calibration_error_10bin": 0.003965320490142894, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K20": { + "valid": 2813, + "positives": 10, + "negatives": 2803, + "auroc": 0.7535497681056011, + "auprc": 0.04918539186452875, + "brier": 0.00355469980769498, + "calibration": { + "observed_rate": 0.0035549235691432635, + "mean_prediction": 0.006202844197102564, + "calibration_in_the_large": 0.0026479206279593007, + "expected_calibration_error_10bin": 0.0026479206279593002, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K21": { + "valid": 2043, + "positives": 85, + "negatives": 1958, + "auroc": 0.7522201526167157, + "auprc": 0.1430975854141309, + "brier": 0.03792915248230752, + "calibration": { + "observed_rate": 0.041605482134116495, + "mean_prediction": 0.04294750801327707, + "calibration_in_the_large": 0.0013420258791605744, + "expected_calibration_error_10bin": 0.0021894533699765833, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + "K22": { + "valid": 2764, + "positives": 18, + "negatives": 2746, + "auroc": 0.7487456502387311, + "auprc": 0.0261497469154495, + "brier": 0.00642343601198233, + "calibration": { + "observed_rate": 0.006512301013024602, + "mean_prediction": 0.00545575798331799, + "calibration_in_the_large": -0.0010565430297066122, + "expected_calibration_error_10bin": 0.0010565430297066122, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + "K25": { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.7556176919166243, + "auprc": 0.009183124438044052, + "brier": 0.002547853224340045, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.0034647220575755398, + "calibration_in_the_large": 0.0009798090295315212, + "expected_calibration_error_10bin": 0.0009798090295315214, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "K26": { + "valid": 2814, + "positives": 6, + "negatives": 2808, + "auroc": 0.9201092117758785, + "auprc": 0.03719763696428747, + "brier": 0.002106433499318009, + "calibration": { + "observed_rate": 0.0021321961620469083, + "mean_prediction": 0.0018049019505649913, + "calibration_in_the_large": -0.00032729421148191694, + "expected_calibration_error_10bin": 0.00032729421148191694, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "K29": { + "valid": 2785, + "positives": 13, + "negatives": 2772, + "auroc": 0.7019369519369519, + "auprc": 0.017807977592288856, + "brier": 0.004725357591468592, + "calibration": { + "observed_rate": 0.00466786355475763, + "mean_prediction": 0.008403049459529596, + "calibration_in_the_large": 0.003735185904771966, + "expected_calibration_error_10bin": 0.0037351859047719646, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K30": { + "valid": 2837, + "positives": 3, + "negatives": 2834, + "auroc": 0.9460127028934369, + "auprc": 0.01616897668493193, + "brier": 0.0010543326117371074, + "calibration": { + "observed_rate": 0.0010574550581600281, + "mean_prediction": 0.0015405193575913695, + "calibration_in_the_large": 0.00048306429943134133, + "expected_calibration_error_10bin": 0.00048306429943134133, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "K31": { + "valid": 2756, + "positives": 18, + "negatives": 2738, + "auroc": 0.896112328544761, + "auprc": 0.058924020100211444, + "brier": 0.006398483918892318, + "calibration": { + "observed_rate": 0.006531204644412192, + "mean_prediction": 0.00608054211886495, + "calibration_in_the_large": -0.00045066252554724125, + "expected_calibration_error_10bin": 0.002116103798935806, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "K40": { + "valid": 2827, + "positives": 3, + "negatives": 2824, + "auroc": 0.8868035882908404, + "auprc": 0.005980040858781065, + "brier": 0.001060710997133131, + "calibration": { + "observed_rate": 0.0010611956137247967, + "mean_prediction": 0.0016723098652243783, + "calibration_in_the_large": 0.0006111142514995816, + "expected_calibration_error_10bin": 0.0006111142514995816, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "K42": { + "valid": 2820, + "positives": 6, + "negatives": 2814, + "auroc": 0.8146173892442549, + "auprc": 0.023933317771240786, + "brier": 0.002123908354154119, + "calibration": { + "observed_rate": 0.002127659574468085, + "mean_prediction": 0.0013833628356404535, + "calibration_in_the_large": -0.0007442967388276316, + "expected_calibration_error_10bin": 0.0008321447221997584, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "K43": { + "valid": 2813, + "positives": 9, + "negatives": 2804, + "auroc": 0.8113805674433349, + "auprc": 0.018666388477538116, + "brier": 0.003190954385191273, + "calibration": { + "observed_rate": 0.003199431212228937, + "mean_prediction": 0.002605680388185513, + "calibration_in_the_large": -0.0005937508240434243, + "expected_calibration_error_10bin": 0.0005937508240434243, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K44": { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.6759625764663548, + "auprc": 0.0068307762428136696, + "brier": 0.0021576175013005862, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.0031884728158097647, + "calibration_in_the_large": 0.001034074252075474, + "expected_calibration_error_10bin": 0.001034074252075474, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K52": { + "valid": 2749, + "positives": 35, + "negatives": 2714, + "auroc": 0.8028739867354459, + "auprc": 0.11323388970531509, + "brier": 0.012588303424713246, + "calibration": { + "observed_rate": 0.012731902510003638, + "mean_prediction": 0.01270429724298691, + "calibration_in_the_large": -2.7605267016728163e-05, + "expected_calibration_error_10bin": 0.004690589375759464, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + "K55": { + "valid": 2815, + "positives": 9, + "negatives": 2806, + "auroc": 0.7283994614714501, + "auprc": 0.009660906286394877, + "brier": 0.0032236002293400496, + "calibration": { + "observed_rate": 0.003197158081705151, + "mean_prediction": 0.0030714097234777584, + "calibration_in_the_large": -0.0001257483582273928, + "expected_calibration_error_10bin": 0.0003831312084678258, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "K56": { + "valid": 2745, + "positives": 30, + "negatives": 2715, + "auroc": 0.7515899324739104, + "auprc": 0.049259652885994196, + "brier": 0.010656257476600168, + "calibration": { + "observed_rate": 0.01092896174863388, + "mean_prediction": 0.01268146505709975, + "calibration_in_the_large": 0.00175250330846587, + "expected_calibration_error_10bin": 0.0017525033084658701, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + "K57": { + "valid": 2741, + "positives": 23, + "negatives": 2718, + "auroc": 0.6833509293918162, + "auprc": 0.020998958180358265, + "brier": 0.008327306286098849, + "calibration": { + "observed_rate": 0.008391098139365194, + "mean_prediction": 0.00498983090033288, + "calibration_in_the_large": -0.0034012672390323143, + "expected_calibration_error_10bin": 0.003510370072873077, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "K58": { + "valid": 2792, + "positives": 7, + "negatives": 2785, + "auroc": 0.7379840984867915, + "auprc": 0.011403902360004738, + "brier": 0.0025071063973130655, + "calibration": { + "observed_rate": 0.002507163323782235, + "mean_prediction": 0.0023098101741077875, + "calibration_in_the_large": -0.0001973531496744477, + "expected_calibration_error_10bin": 0.0001973531496744477, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "K59": { + "valid": 2560, + "positives": 85, + "negatives": 2475, + "auroc": 0.7621010101010101, + "auprc": 0.1364106095430854, + "brier": 0.03051885362538777, + "calibration": { + "observed_rate": 0.033203125, + "mean_prediction": 0.029281093020426852, + "calibration_in_the_large": -0.003922031979573148, + "expected_calibration_error_10bin": 0.004474267779414732, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "K62": { + "valid": 2813, + "positives": 14, + "negatives": 2799, + "auroc": 0.8706170571122339, + "auprc": 0.030781462719436502, + "brier": 0.004906283772280542, + "calibration": { + "observed_rate": 0.004976892996800568, + "mean_prediction": 0.003466672521504437, + "calibration_in_the_large": -0.0015102204752961315, + "expected_calibration_error_10bin": 0.0015102204752961315, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K63": { + "valid": 2810, + "positives": 15, + "negatives": 2795, + "auroc": 0.7267978533094812, + "auprc": 0.012825951549084428, + "brier": 0.005327680771905423, + "calibration": { + "observed_rate": 0.005338078291814947, + "mean_prediction": 0.004141022145686099, + "calibration_in_the_large": -0.001197056146128848, + "expected_calibration_error_10bin": 0.001197056146128848, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "K64": { + "valid": 2801, + "positives": 21, + "negatives": 2780, + "auroc": 0.7967797190818774, + "auprc": 0.029361146969368403, + "brier": 0.007513164569779462, + "calibration": { + "observed_rate": 0.007497322384862549, + "mean_prediction": 0.006828202511348004, + "calibration_in_the_large": -0.0006691198735145447, + "expected_calibration_error_10bin": 0.002588337815872247, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "K65": { + "valid": 2813, + "positives": 13, + "negatives": 2800, + "auroc": 0.8087912087912088, + "auprc": 0.03281055159608727, + "brier": 0.004775015488306531, + "calibration": { + "observed_rate": 0.004621400639886242, + "mean_prediction": 0.008086885465157453, + "calibration_in_the_large": 0.0034654848252712103, + "expected_calibration_error_10bin": 0.0034654848252712103, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K66": { + "valid": 2796, + "positives": 9, + "negatives": 2787, + "auroc": 0.7421759757604752, + "auprc": 0.019438085281945114, + "brier": 0.0032319981058439697, + "calibration": { + "observed_rate": 0.003218884120171674, + "mean_prediction": 0.004595296359850613, + "calibration_in_the_large": 0.0013764122396789395, + "expected_calibration_error_10bin": 0.0013764122396789395, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "K70": { + "valid": 2774, + "positives": 3, + "negatives": 2771, + "auroc": 0.8899314326957777, + "auprc": 0.010037161704769863, + "brier": 0.001098269816236143, + "calibration": { + "observed_rate": 0.0010814708002883922, + "mean_prediction": 0.0010829182192891795, + "calibration_in_the_large": 1.4474190007873148e-06, + "expected_calibration_error_10bin": 8.322109708057391e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "K72": { + "valid": 2787, + "positives": 20, + "negatives": 2767, + "auroc": 0.9225334297072642, + "auprc": 0.2776409399790933, + "brier": 0.006272368712012159, + "calibration": { + "observed_rate": 0.007176175098672408, + "mean_prediction": 0.004112986779501482, + "calibration_in_the_large": -0.0030631883191709255, + "expected_calibration_error_10bin": 0.003980784716153359, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "K74": { + "valid": 2763, + "positives": 7, + "negatives": 2756, + "auroc": 0.9584283640887414, + "auprc": 0.04878097000559707, + "brier": 0.002538712363052634, + "calibration": { + "observed_rate": 0.0025334781035106766, + "mean_prediction": 0.0033831513126825695, + "calibration_in_the_large": 0.0008496732091718929, + "expected_calibration_error_10bin": 0.0008496732091718926, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "K75": { + "valid": 2798, + "positives": 10, + "negatives": 2788, + "auroc": 0.8194763271162123, + "auprc": 0.02324651867272775, + "brier": 0.0035697209568388865, + "calibration": { + "observed_rate": 0.0035739814152966403, + "mean_prediction": 0.002725841400646384, + "calibration_in_the_large": -0.0008481400146502565, + "expected_calibration_error_10bin": 0.0011552783874726918, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "K76": { + "valid": 2681, + "positives": 31, + "negatives": 2650, + "auroc": 0.8059281801582471, + "auprc": 0.1790982073969422, + "brier": 0.010534019083633933, + "calibration": { + "observed_rate": 0.011562849682954122, + "mean_prediction": 0.005920454783532784, + "calibration_in_the_large": -0.005642394899421338, + "expected_calibration_error_10bin": 0.006247624953383837, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + "K80": { + "valid": 2731, + "positives": 14, + "negatives": 2717, + "auroc": 0.6883642673116357, + "auprc": 0.014318085023026204, + "brier": 0.0050986438672005864, + "calibration": { + "observed_rate": 0.005126327352618088, + "mean_prediction": 0.0031672093363534024, + "calibration_in_the_large": -0.001959118016264686, + "expected_calibration_error_10bin": 0.001959118016264686, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + "K81": { + "valid": 2825, + "positives": 5, + "negatives": 2820, + "auroc": 0.8499290780141844, + "auprc": 0.0304465214382325, + "brier": 0.0017554050697959269, + "calibration": { + "observed_rate": 0.0017699115044247787, + "mean_prediction": 0.0015651968646273264, + "calibration_in_the_large": -0.00020471463979745237, + "expected_calibration_error_10bin": 0.00020471463979745237, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "K82": { + "valid": 2824, + "positives": 4, + "negatives": 2820, + "auroc": 0.5795212765957447, + "auprc": 0.0036437964066561744, + "brier": 0.0014185661066124563, + "calibration": { + "observed_rate": 0.00141643059490085, + "mean_prediction": 0.0011728118281366384, + "calibration_in_the_large": -0.0002436187667642115, + "expected_calibration_error_10bin": 0.0002436187667642115, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K83": { + "valid": 2757, + "positives": 14, + "negatives": 2743, + "auroc": 0.8981563460236446, + "auprc": 0.10096551781883374, + "brier": 0.0050447477263043106, + "calibration": { + "observed_rate": 0.005077983315197679, + "mean_prediction": 0.004519022244961526, + "calibration_in_the_large": -0.000558961070236153, + "expected_calibration_error_10bin": 0.0035224966470679413, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + "K85": { + "valid": 2779, + "positives": 9, + "negatives": 2770, + "auroc": 0.7923385479342158, + "auprc": 0.02275487476662246, + "brier": 0.003205665649365059, + "calibration": { + "observed_rate": 0.0032385750269881253, + "mean_prediction": 0.0025120372079823787, + "calibration_in_the_large": -0.0007265378190057467, + "expected_calibration_error_10bin": 0.0007265378190057467, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + "K86": { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.7038465494189037, + "auprc": 0.014959799517951775, + "brier": 0.002518274675926362, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.003506037492526689, + "calibration_in_the_large": 0.0009925725015033499, + "expected_calibration_error_10bin": 0.0009925725015033499, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K90": { + "valid": 2831, + "positives": 3, + "negatives": 2828, + "auroc": 0.5884016973125884, + "auprc": 0.0017891166271136816, + "brier": 0.001062821095253854, + "calibration": { + "observed_rate": 0.0010596962204168139, + "mean_prediction": 0.0009052206883382142, + "calibration_in_the_large": -0.00015447553207859966, + "expected_calibration_error_10bin": 0.00015447553207859966, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "K91": { + "valid": 2768, + "positives": 24, + "negatives": 2744, + "auroc": 0.8693816812439261, + "auprc": 0.06716072407284862, + "brier": 0.00835108481628282, + "calibration": { + "observed_rate": 0.008670520231213872, + "mean_prediction": 0.007706600364512837, + "calibration_in_the_large": -0.0009639198667010353, + "expected_calibration_error_10bin": 0.001130719933615898, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "K92": { + "valid": 2751, + "positives": 35, + "negatives": 2716, + "auroc": 0.8372080791079318, + "auprc": 0.08647585724576086, + "brier": 0.012102790559803909, + "calibration": { + "observed_rate": 0.01272264631043257, + "mean_prediction": 0.011158543734511892, + "calibration_in_the_large": -0.001564102575920677, + "expected_calibration_error_10bin": 0.0017255012723694269, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "K94": { + "valid": 2823, + "positives": 14, + "negatives": 2809, + "auroc": 0.9013629659767075, + "auprc": 0.0764549509616441, + "brier": 0.004794550096870914, + "calibration": { + "observed_rate": 0.00495926319518243, + "mean_prediction": 0.005520479929521926, + "calibration_in_the_large": 0.0005612167343394953, + "expected_calibration_error_10bin": 0.0007164457673714922, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "L02": { + "valid": 2807, + "positives": 17, + "negatives": 2790, + "auroc": 0.7640522875816993, + "auprc": 0.022221637787055916, + "brier": 0.005993779148310266, + "calibration": { + "observed_rate": 0.006056287851799074, + "mean_prediction": 0.007520851908990862, + "calibration_in_the_large": 0.0014645640571917884, + "expected_calibration_error_10bin": 0.0014645640571917884, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "L03": { + "valid": 2701, + "positives": 43, + "negatives": 2658, + "auroc": 0.7515880098692844, + "auprc": 0.06548225920008091, + "brier": 0.01537765007520586, + "calibration": { + "observed_rate": 0.015920029618659754, + "mean_prediction": 0.010042924987490475, + "calibration_in_the_large": -0.005877104631169279, + "expected_calibration_error_10bin": 0.006207241253196016, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + "L08": { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.6696637168141593, + "auprc": 0.006512988953866377, + "brier": 0.001770060321667941, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.0018994082606493417, + "calibration_in_the_large": 0.00013262380835252197, + "expected_calibration_error_10bin": 0.00013262380835252197, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + "L27": { + "valid": 2818, + "positives": 11, + "negatives": 2807, + "auroc": 0.7998186352301065, + "auprc": 0.02066612748542132, + "brier": 0.004145959981821802, + "calibration": { + "observed_rate": 0.0039034776437189495, + "mean_prediction": 0.005472445155243279, + "calibration_in_the_large": 0.00156896751152433, + "expected_calibration_error_10bin": 0.0015689675115243295, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "L29": { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.5739161336176262, + "auprc": 0.00284795765727903, + "brier": 0.0011579783186675653, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.004457068005715999, + "calibration_in_the_large": 0.003392105279411419, + "expected_calibration_error_10bin": 0.003392105279411419, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "L30": { + "valid": 2816, + "positives": 8, + "negatives": 2808, + "auroc": 0.7426549145299145, + "auprc": 0.025343316702592922, + "brier": 0.002824654857541244, + "calibration": { + "observed_rate": 0.002840909090909091, + "mean_prediction": 0.0027249083986553365, + "calibration_in_the_large": -0.00011600069225375454, + "expected_calibration_error_10bin": 0.0002947414489669467, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "L50": { + "valid": 2835, + "positives": 3, + "negatives": 2832, + "auroc": 0.7448210922787194, + "auprc": 0.010107985642525116, + "brier": 0.00105750421658799, + "calibration": { + "observed_rate": 0.0010582010582010583, + "mean_prediction": 0.0011968871083295769, + "calibration_in_the_large": 0.00013868605012851858, + "expected_calibration_error_10bin": 0.00013868605012851858, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + "L53": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 9.304496879146182e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0014917131175700262, + "calibration_in_the_large": 0.0014917131175700262, + "expected_calibration_error_10bin": 0.0014917131175700262, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "L76": { + "valid": 2793, + "positives": 13, + "negatives": 2780, + "auroc": 0.6747371333702269, + "auprc": 0.009143495500996648, + "brier": 0.00467614669155206, + "calibration": { + "observed_rate": 0.004654493376297888, + "mean_prediction": 0.005862420137823755, + "calibration_in_the_large": 0.0012079267615258673, + "expected_calibration_error_10bin": 0.0012079267615258673, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "L89": { + "valid": 2798, + "positives": 22, + "negatives": 2776, + "auroc": 0.8506025674613571, + "auprc": 0.0376526666481677, + "brier": 0.007792916213310184, + "calibration": { + "observed_rate": 0.007862759113652609, + "mean_prediction": 0.005986741921470477, + "calibration_in_the_large": -0.001876017192182132, + "expected_calibration_error_10bin": 0.002898350637860663, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "L97": { + "valid": 2789, + "positives": 12, + "negatives": 2777, + "auroc": 0.8961409194574481, + "auprc": 0.0803243084885537, + "brier": 0.004241529997362859, + "calibration": { + "observed_rate": 0.004302617425600574, + "mean_prediction": 0.005808192331768405, + "calibration_in_the_large": 0.0015055749061678309, + "expected_calibration_error_10bin": 0.0015055749061678313, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "L98": { + "valid": 2824, + "positives": 7, + "negatives": 2817, + "auroc": 0.6510472133475328, + "auprc": 0.005502973680144882, + "brier": 0.0025146901071740283, + "calibration": { + "observed_rate": 0.002478753541076487, + "mean_prediction": 0.004201213287181111, + "calibration_in_the_large": 0.0017224597461046238, + "expected_calibration_error_10bin": 0.0017224597461046234, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "M10": { + "valid": 2713, + "positives": 13, + "negatives": 2700, + "auroc": 0.7982905982905983, + "auprc": 0.04686536046259478, + "brier": 0.004723080623928351, + "calibration": { + "observed_rate": 0.004791743457427202, + "mean_prediction": 0.005894672238410248, + "calibration_in_the_large": 0.001102928780983046, + "expected_calibration_error_10bin": 0.0011029287809830451, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + "M16": { + "valid": 2790, + "positives": 3, + "negatives": 2787, + "auroc": 0.9111350316947734, + "auprc": 0.013744168624646712, + "brier": 0.0010714465461691826, + "calibration": { + "observed_rate": 0.001075268817204301, + "mean_prediction": 0.0015349796564672075, + "calibration_in_the_large": 0.00045971083926290646, + "expected_calibration_error_10bin": 0.00045971083926290646, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "M17": { + "valid": 2733, + "positives": 13, + "negatives": 2720, + "auroc": 0.7682975113122172, + "auprc": 0.011877386724582568, + "brier": 0.0047648913594878235, + "calibration": { + "observed_rate": 0.004756677643615075, + "mean_prediction": 0.0030378770537493097, + "calibration_in_the_large": -0.0017188005898657655, + "expected_calibration_error_10bin": 0.001794990385166877, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "M19": { + "valid": 2674, + "positives": 34, + "negatives": 2640, + "auroc": 0.7158979500891266, + "auprc": 0.032898759006086686, + "brier": 0.012521428249151548, + "calibration": { + "observed_rate": 0.012715033657442034, + "mean_prediction": 0.012539236069039655, + "calibration_in_the_large": -0.000175797588402379, + "expected_calibration_error_10bin": 0.001588871048782289, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + "M21": { + "valid": 2821, + "positives": 2, + "negatives": 2819, + "auroc": 0.893934019155729, + "auprc": 0.009335345743194142, + "brier": 0.0007121544723924403, + "calibration": { + "observed_rate": 0.0007089684509039348, + "mean_prediction": 0.0017526902321163857, + "calibration_in_the_large": 0.001043721781212451, + "expected_calibration_error_10bin": 0.001043721781212451, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "M25": { + "valid": 2717, + "positives": 37, + "negatives": 2680, + "auroc": 0.6030556676079064, + "auprc": 0.018984276019259862, + "brier": 0.013572183063290161, + "calibration": { + "observed_rate": 0.013617960986382039, + "mean_prediction": 0.013984247722682181, + "calibration_in_the_large": 0.0003662867363001428, + "expected_calibration_error_10bin": 0.0011467853485890081, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + "M35": { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.8855206847360912, + "auprc": 0.004554518702083172, + "brier": 0.0007178324655715538, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0010625005888314802, + "calibration_in_the_large": 0.00034974221392057494, + "expected_calibration_error_10bin": 0.00034974221392057494, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "M46": { + "valid": 2814, + "positives": 4, + "negatives": 2810, + "auroc": 0.6161921708185053, + "auprc": 0.0023332912032473373, + "brier": 0.0014290719665746643, + "calibration": { + "observed_rate": 0.0014214641080312722, + "mean_prediction": 0.0021789142501608496, + "calibration_in_the_large": 0.0007574501421295774, + "expected_calibration_error_10bin": 0.0007574501421295774, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "M47": { + "valid": 2743, + "positives": 10, + "negatives": 2733, + "auroc": 0.7393706549579216, + "auprc": 0.018895545791303574, + "brier": 0.0036186241526766283, + "calibration": { + "observed_rate": 0.0036456434560699965, + "mean_prediction": 0.002716849137980919, + "calibration_in_the_large": -0.0009287943180890774, + "expected_calibration_error_10bin": 0.0009287943180890774, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "M48": { + "valid": 2690, + "positives": 10, + "negatives": 2680, + "auroc": 0.7663805970149253, + "auprc": 0.014359270687350581, + "brier": 0.003733133438561543, + "calibration": { + "observed_rate": 0.0037174721189591076, + "mean_prediction": 0.00619045493660255, + "calibration_in_the_large": 0.002472982817643442, + "expected_calibration_error_10bin": 0.002472982817643442, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + "M51": { + "valid": 2785, + "positives": 4, + "negatives": 2781, + "auroc": 0.9408486156058972, + "auprc": 0.01801823276487064, + "brier": 0.0014298859175313455, + "calibration": { + "observed_rate": 0.001436265709156194, + "mean_prediction": 0.0030505251939992855, + "calibration_in_the_large": 0.0016142594848430915, + "expected_calibration_error_10bin": 0.0016142594848430915, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "M54": { + "valid": 2567, + "positives": 43, + "negatives": 2524, + "auroc": 0.7265230531087605, + "auprc": 0.05033832219653228, + "brier": 0.016301806458005216, + "calibration": { + "observed_rate": 0.01675107128944293, + "mean_prediction": 0.01660316486670235, + "calibration_in_the_large": -0.00014790642274058186, + "expected_calibration_error_10bin": 0.0014966490843021667, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + "M62": { + "valid": 2781, + "positives": 10, + "negatives": 2771, + "auroc": 0.6962468422952003, + "auprc": 0.01255931415094734, + "brier": 0.0035759735432185627, + "calibration": { + "observed_rate": 0.003595828838547285, + "mean_prediction": 0.003758203644812906, + "calibration_in_the_large": 0.00016237480626562096, + "expected_calibration_error_10bin": 0.00016237480626562096, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "M79": { + "valid": 2697, + "positives": 39, + "negatives": 2658, + "auroc": 0.7418436842816075, + "auprc": 0.04490702158249528, + "brier": 0.01421689783824527, + "calibration": { + "observed_rate": 0.014460511679644048, + "mean_prediction": 0.01565369878527213, + "calibration_in_the_large": 0.001193187105628081, + "expected_calibration_error_10bin": 0.0018242273481556175, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + "M81": { + "valid": 2705, + "positives": 13, + "negatives": 2692, + "auroc": 0.8062064235912676, + "auprc": 0.04792009821106084, + "brier": 0.004731739093828291, + "calibration": { + "observed_rate": 0.004805914972273568, + "mean_prediction": 0.005454263320321026, + "calibration_in_the_large": 0.000648348348047458, + "expected_calibration_error_10bin": 0.0006483483480474586, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + "M84": { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.7708629682313893, + "auprc": 0.0232232738090066, + "brier": 0.002146350340152745, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0031566645069225924, + "calibration_in_the_large": 0.0010274948830758927, + "expected_calibration_error_10bin": 0.0010274948830758922, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "M85": { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.7183732602059295, + "auprc": 0.0064096189980558755, + "brier": 0.0025441107461209953, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.003514898251807734, + "calibration_in_the_large": 0.000985996517703688, + "expected_calibration_error_10bin": 0.000985996517703688, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "M86": { + "valid": 2803, + "positives": 15, + "negatives": 2788, + "auroc": 0.7899091343854615, + "auprc": 0.04806766452496141, + "brier": 0.005264210826356061, + "calibration": { + "observed_rate": 0.005351409204423832, + "mean_prediction": 0.0041863581092056465, + "calibration_in_the_large": -0.0011650510952181852, + "expected_calibration_error_10bin": 0.002118616340227998, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + "M94": { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7574573863636364, + "auprc": 0.0031550844240025334, + "brier": 0.0010638637927322466, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.00041799894649836964, + "calibration_in_the_large": -0.0006462082191632124, + "expected_calibration_error_10bin": 0.0006462082191632124, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "M96": { + "valid": 2804, + "positives": 4, + "negatives": 2800, + "auroc": 0.8795535714285714, + "auprc": 0.00743166622668732, + "brier": 0.0014350290721747618, + "calibration": { + "observed_rate": 0.0014265335235378032, + "mean_prediction": 0.003284106122772575, + "calibration_in_the_large": 0.0018575725992347717, + "expected_calibration_error_10bin": 0.0018575725992347717, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "N12": { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.6694152165115338, + "auprc": 0.0063972906706349555, + "brier": 0.00248021509397475, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.0021476214405074423, + "calibration_in_the_large": -0.00032500307379845685, + "expected_calibration_error_10bin": 0.00032500307379845685, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N13": { + "valid": 2756, + "positives": 20, + "negatives": 2736, + "auroc": 0.7189875730994152, + "auprc": 0.03888290112374652, + "brier": 0.007136884015718948, + "calibration": { + "observed_rate": 0.00725689404934688, + "mean_prediction": 0.005345505869474109, + "calibration_in_the_large": -0.0019113881798727703, + "expected_calibration_error_10bin": 0.00206369107227292, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "N14": { + "valid": 2826, + "positives": 8, + "negatives": 2818, + "auroc": 0.8760645848119234, + "auprc": 0.022025687179219402, + "brier": 0.0028128255873428585, + "calibration": { + "observed_rate": 0.0028308563340410475, + "mean_prediction": 0.0017823637272023352, + "calibration_in_the_large": -0.0010484926068387124, + "expected_calibration_error_10bin": 0.0010484926068387124, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "N17": { + "valid": 2292, + "positives": 93, + "negatives": 2199, + "auroc": 0.7973321206609064, + "auprc": 0.15391797985921735, + "brier": 0.03695661855049787, + "calibration": { + "observed_rate": 0.04057591623036649, + "mean_prediction": 0.0430331929975082, + "calibration_in_the_large": 0.0024572767671417056, + "expected_calibration_error_10bin": 0.0052360308663976455, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + "N18": { + "valid": 2440, + "positives": 46, + "negatives": 2394, + "auroc": 0.8655606407322655, + "auprc": 0.19150606736998546, + "brier": 0.017120201347028616, + "calibration": { + "observed_rate": 0.018852459016393444, + "mean_prediction": 0.012150414086130188, + "calibration_in_the_large": -0.006702044930263256, + "expected_calibration_error_10bin": 0.006968995910824933, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + "N20": { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7387419585418156, + "auprc": 0.006398012694110576, + "brier": 0.002846684620159452, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.001412216356006804, + "calibration_in_the_large": -0.0014388171436368169, + "expected_calibration_error_10bin": 0.0014388171436368169, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "N25": { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.9567482800485634, + "auprc": 0.08897019119285336, + "brier": 0.002415726464659996, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.0013580729060791365, + "calibration_in_the_large": -0.0011145516082267627, + "expected_calibration_error_10bin": 0.0012872584561233588, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N28": { + "valid": 2789, + "positives": 8, + "negatives": 2781, + "auroc": 0.8398058252427184, + "auprc": 0.017921757162122836, + "brier": 0.0028540263685595067, + "calibration": { + "observed_rate": 0.0028684116170670493, + "mean_prediction": 0.004621602460514634, + "calibration_in_the_large": 0.0017531908434475847, + "expected_calibration_error_10bin": 0.0017531908434475847, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "N30": { + "valid": 2829, + "positives": 10, + "negatives": 2819, + "auroc": 0.7030507272082299, + "auprc": 0.011895675187709055, + "brier": 0.003588495408738712, + "calibration": { + "observed_rate": 0.003534817956875221, + "mean_prediction": 0.004457689312885325, + "calibration_in_the_large": 0.0009228713560101042, + "expected_calibration_error_10bin": 0.0009228713560101038, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N32": { + "valid": 2807, + "positives": 13, + "negatives": 2794, + "auroc": 0.7847585485380761, + "auprc": 0.16813725450306286, + "brier": 0.004455782948828884, + "calibration": { + "observed_rate": 0.004631278945493409, + "mean_prediction": 0.0045814028610750325, + "calibration_in_the_large": -4.9876084418376716e-05, + "expected_calibration_error_10bin": 0.0005777608463007739, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "N39": { + "valid": 2520, + "positives": 81, + "negatives": 2439, + "auroc": 0.7531117286481507, + "auprc": 0.08732174964073018, + "brier": 0.03055091655783622, + "calibration": { + "observed_rate": 0.03214285714285714, + "mean_prediction": 0.03659501154694544, + "calibration_in_the_large": 0.004452154404088297, + "expected_calibration_error_10bin": 0.00580168132557504, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + "N40": { + "valid": 2606, + "positives": 22, + "negatives": 2584, + "auroc": 0.8220869687587954, + "auprc": 0.051854024837334395, + "brier": 0.00826240845163704, + "calibration": { + "observed_rate": 0.00844205679201842, + "mean_prediction": 0.010566335411132154, + "calibration_in_the_large": 0.0021242786191137345, + "expected_calibration_error_10bin": 0.0021242786191137345, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + "N73": { + "valid": 2829, + "positives": 6, + "negatives": 2823, + "auroc": 0.9040028338646829, + "auprc": 0.08154976667271571, + "brier": 0.0020746525631174313, + "calibration": { + "observed_rate": 0.0021208907741251328, + "mean_prediction": 0.0010988791920434346, + "calibration_in_the_large": -0.0010220115820816981, + "expected_calibration_error_10bin": 0.0010220115820816981, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N99": { + "valid": 2799, + "positives": 6, + "negatives": 2793, + "auroc": 0.7637546246568803, + "auprc": 0.009091095479821213, + "brier": 0.0021393010960330415, + "calibration": { + "observed_rate": 0.0021436227224008574, + "mean_prediction": 0.0019673471705254557, + "calibration_in_the_large": -0.00017627555187540176, + "expected_calibration_error_10bin": 0.00017627555187540176, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + "O69": { + "valid": 2743, + "positives": 6, + "negatives": 2737, + "auroc": 0.9962854707100232, + "auprc": 0.34296259296259296, + "brier": 0.0020386722016643086, + "calibration": { + "observed_rate": 0.002187386073641998, + "mean_prediction": 0.00047115851499118083, + "calibration_in_the_large": -0.0017162275586508169, + "expected_calibration_error_10bin": 0.0019183761192714576, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "O99": { + "valid": 2652, + "positives": 3, + "negatives": 2649, + "auroc": 0.8622121555303889, + "auprc": 0.1842776203966006, + "brier": 0.0009862376103759079, + "calibration": { + "observed_rate": 0.0011312217194570137, + "mean_prediction": 0.0005023423529503365, + "calibration_in_the_large": -0.0006288793665066772, + "expected_calibration_error_10bin": 0.000628879366506677, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + "Q21": { + "valid": 2810, + "positives": 3, + "negatives": 2807, + "auroc": 0.5800973756085975, + "auprc": 0.0028687724836871545, + "brier": 0.0010674937422478921, + "calibration": { + "observed_rate": 0.0010676156583629894, + "mean_prediction": 0.0012589480048113874, + "calibration_in_the_large": 0.00019133234644839797, + "expected_calibration_error_10bin": 0.00019133234644839797, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "U07": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.9830208701804033, + "auprc": 0.02040816326530612, + "brier": 0.00039037990369899915, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0035200370230356413, + "calibration_in_the_large": 0.0031664302337852876, + "expected_calibration_error_10bin": 0.003166430233785288, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + } + }, + "330": { + "A04": { + "valid": 2782, + "positives": 27, + "negatives": 2755, + "auroc": 0.7724675673858977, + "auprc": 0.05501206336903487, + "brier": 0.009495915501865446, + "calibration": { + "observed_rate": 0.009705248023005032, + "mean_prediction": 0.01009780703932914, + "calibration_in_the_large": 0.00039255901632410765, + "expected_calibration_error_10bin": 0.0005826620202979228, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "A08": { + "valid": 2818, + "positives": 11, + "negatives": 2807, + "auroc": 0.8116073452731807, + "auprc": 0.028213360303634093, + "brier": 0.0038596865137545742, + "calibration": { + "observed_rate": 0.0039034776437189495, + "mean_prediction": 0.004848472302488372, + "calibration_in_the_large": 0.0009449946587694229, + "expected_calibration_error_10bin": 0.0009449946587694229, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "A41": { + "valid": 2664, + "positives": 70, + "negatives": 2594, + "auroc": 0.7507765172375812, + "auprc": 0.07608926282887542, + "brier": 0.025470654593381784, + "calibration": { + "observed_rate": 0.026276276276276277, + "mean_prediction": 0.029202420597013425, + "calibration_in_the_large": 0.0029261443207371472, + "expected_calibration_error_10bin": 0.007999989383385689, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + "B00": { + "valid": 2819, + "positives": 4, + "negatives": 2815, + "auroc": 0.6705150976909414, + "auprc": 0.015024803324239817, + "brier": 0.0014678815935864071, + "calibration": { + "observed_rate": 0.001418942887548776, + "mean_prediction": 0.0021149128973550527, + "calibration_in_the_large": 0.0006959700098062766, + "expected_calibration_error_10bin": 0.0006959700098062764, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "B02": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7821011673151751, + "auprc": 0.0016207455429497568, + "brier": 0.0003580114619341099, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.001044692809474331, + "calibration_in_the_large": 0.0006910860202239773, + "expected_calibration_error_10bin": 0.0006910860202239773, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "B18": { + "valid": 2782, + "positives": 7, + "negatives": 2775, + "auroc": 0.9404375804375804, + "auprc": 0.09005232071424889, + "brier": 0.0024314442713906314, + "calibration": { + "observed_rate": 0.0025161754133716753, + "mean_prediction": 0.001509829278856768, + "calibration_in_the_large": -0.0010063461345149072, + "expected_calibration_error_10bin": 0.001006346134514907, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "B19": { + "valid": 2763, + "positives": 17, + "negatives": 2746, + "auroc": 0.8559401910800737, + "auprc": 0.07551593695631924, + "brier": 0.006000712654193283, + "calibration": { + "observed_rate": 0.006152732537097358, + "mean_prediction": 0.002117607892020464, + "calibration_in_the_large": -0.004035124645076894, + "expected_calibration_error_10bin": 0.004356433729646444, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "B20": { + "valid": 2829, + "positives": 5, + "negatives": 2824, + "auroc": 0.9881019830028328, + "auprc": 0.24256514276798252, + "brier": 0.0017333934194734594, + "calibration": { + "observed_rate": 0.0017674089784376105, + "mean_prediction": 0.00032356098258004996, + "calibration_in_the_large": -0.0014438479958575605, + "expected_calibration_error_10bin": 0.0015344489837440072, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "B34": { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.9793347487615004, + "auprc": 0.11519096827346384, + "brier": 0.0017008702306425339, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0017824051012507213, + "calibration_in_the_large": 1.624473388936497e-05, + "expected_calibration_error_10bin": 0.00015837887389974508, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "B35": { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.8602681721947777, + "auprc": 0.004734415674741172, + "brier": 0.0007163420985552769, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.001902432273736503, + "calibration_in_the_large": 0.0011972136559649938, + "expected_calibration_error_10bin": 0.0011972136559649938, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "B37": { + "valid": 2768, + "positives": 36, + "negatives": 2732, + "auroc": 0.7608182853424434, + "auprc": 0.04239042530592727, + "brier": 0.012780435228002736, + "calibration": { + "observed_rate": 0.01300578034682081, + "mean_prediction": 0.010682272004571574, + "calibration_in_the_large": -0.002323508342249236, + "expected_calibration_error_10bin": 0.004670922664834274, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "B95": { + "valid": 2678, + "positives": 60, + "negatives": 2618, + "auroc": 0.713878278584161, + "auprc": 0.04796019314472051, + "brier": 0.02204410883346001, + "calibration": { + "observed_rate": 0.022404779686333084, + "mean_prediction": 0.02425530897280413, + "calibration_in_the_large": 0.0018505292864710449, + "expected_calibration_error_10bin": 0.004001661300611533, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + "B96": { + "valid": 2630, + "positives": 83, + "negatives": 2547, + "auroc": 0.7632934565115586, + "auprc": 0.10566919399324594, + "brier": 0.029669016593834956, + "calibration": { + "observed_rate": 0.03155893536121673, + "mean_prediction": 0.03373707001873898, + "calibration_in_the_large": 0.0021781346575222432, + "expected_calibration_error_10bin": 0.00302443400768124, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + "B97": { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.8901273885350318, + "auprc": 0.0849514563106796, + "brier": 0.0007132996613775732, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0012472305460849067, + "calibration_in_the_large": 0.0005400169675841994, + "expected_calibration_error_10bin": 0.0005400169675841997, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "C18": { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9764351523742026, + "auprc": 0.03250517598343685, + "brier": 0.0007026347925452741, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0007513788382781966, + "calibration_in_the_large": 4.31635408277716e-05, + "expected_calibration_error_10bin": 4.31635408277716e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "C22": { + "valid": 2812, + "positives": 7, + "negatives": 2805, + "auroc": 0.8916221033868093, + "auprc": 0.04732860519736183, + "brier": 0.002451164683372533, + "calibration": { + "observed_rate": 0.0024893314366998577, + "mean_prediction": 0.0008726261746534039, + "calibration_in_the_large": -0.001616705262046454, + "expected_calibration_error_10bin": 0.001616705262046454, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + "C25": { + "valid": 2809, + "positives": 4, + "negatives": 2805, + "auroc": 0.9431372549019608, + "auprc": 0.09647012807695883, + "brier": 0.0013899476251098115, + "calibration": { + "observed_rate": 0.001423994304022784, + "mean_prediction": 0.0006296441577137857, + "calibration_in_the_large": -0.0007943501463089983, + "expected_calibration_error_10bin": 0.0009827610809334444, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "C61": { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9698537281484124, + "auprc": 0.01898512685914261, + "brier": 0.0007122097853511681, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0012166992593957923, + "calibration_in_the_large": 0.0005036867816774322, + "expected_calibration_error_10bin": 0.0005036867816774322, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "C67": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9552529182879378, + "auprc": 0.028064842958459978, + "brier": 0.0007039582101139526, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0009394549797428163, + "calibration_in_the_large": 0.0002324913883677721, + "expected_calibration_error_10bin": 0.0002324913883677721, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "C77": { + "valid": 2762, + "positives": 22, + "negatives": 2740, + "auroc": 0.860335102853351, + "auprc": 0.13034983274907289, + "brier": 0.007519270974178952, + "calibration": { + "observed_rate": 0.007965242577842143, + "mean_prediction": 0.004473566616705325, + "calibration_in_the_large": -0.003491675961136818, + "expected_calibration_error_10bin": 0.004430732605276119, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C78": { + "valid": 2762, + "positives": 35, + "negatives": 2727, + "auroc": 0.8779611294462779, + "auprc": 0.16983576841228193, + "brier": 0.011584723580146545, + "calibration": { + "observed_rate": 0.012671976828385228, + "mean_prediction": 0.007204741439392891, + "calibration_in_the_large": -0.0054672353889923374, + "expected_calibration_error_10bin": 0.00724036773612931, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C79": { + "valid": 2751, + "positives": 26, + "negatives": 2725, + "auroc": 0.8886520818630911, + "auprc": 0.17817740314178188, + "brier": 0.009369244329679538, + "calibration": { + "observed_rate": 0.009451108687749909, + "mean_prediction": 0.009979284598138693, + "calibration_in_the_large": 0.000528175910388784, + "expected_calibration_error_10bin": 0.004524451338402987, + "nonempty_bins": 9 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "C83": { + "valid": 2820, + "positives": 2, + "negatives": 2818, + "auroc": 0.4027679205110007, + "auprc": 0.001158747544289713, + "brier": 0.000727971317716531, + "calibration": { + "observed_rate": 0.0007092198581560284, + "mean_prediction": 0.0005347253911451896, + "calibration_in_the_large": -0.00017449446701083883, + "expected_calibration_error_10bin": 0.0002764304361877061, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "D25": { + "valid": 2792, + "positives": 3, + "negatives": 2789, + "auroc": 0.9580494801003944, + "auprc": 0.6694915254237288, + "brier": 0.0010518761951687993, + "calibration": { + "observed_rate": 0.0010744985673352436, + "mean_prediction": 0.0005174600949640679, + "calibration_in_the_large": -0.0005570384723711756, + "expected_calibration_error_10bin": 0.0005570384723711756, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "D47": { + "valid": 2796, + "positives": 10, + "negatives": 2786, + "auroc": 0.6573582196697775, + "auprc": 0.006642822525921055, + "brier": 0.0036809360600668973, + "calibration": { + "observed_rate": 0.00357653791130186, + "mean_prediction": 0.005276579111289256, + "calibration_in_the_large": 0.0017000411999873958, + "expected_calibration_error_10bin": 0.0017000411999873967, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "D50": { + "valid": 2663, + "positives": 57, + "negatives": 2606, + "auroc": 0.7894198273888866, + "auprc": 0.11438580278737526, + "brier": 0.019952327540032566, + "calibration": { + "observed_rate": 0.021404431092752536, + "mean_prediction": 0.016957075982735784, + "calibration_in_the_large": -0.004447355110016753, + "expected_calibration_error_10bin": 0.005260015311902733, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + "D53": { + "valid": 2805, + "positives": 17, + "negatives": 2788, + "auroc": 0.8141193349649759, + "auprc": 0.025486987492421672, + "brier": 0.006188324028026998, + "calibration": { + "observed_rate": 0.006060606060606061, + "mean_prediction": 0.006950223992432181, + "calibration_in_the_large": 0.0008896179318261203, + "expected_calibration_error_10bin": 0.00163027636252166, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "D59": { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9828863796753705, + "auprc": 0.02967032967032967, + "brier": 0.0006999359322433663, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0008614800720150525, + "calibration_in_the_large": 0.00015626145424354337, + "expected_calibration_error_10bin": 0.00015626145424354337, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "D61": { + "valid": 2773, + "positives": 36, + "negatives": 2737, + "auroc": 0.8934051881622214, + "auprc": 0.2657018723993211, + "brier": 0.010920263136781357, + "calibration": { + "observed_rate": 0.01298232960692391, + "mean_prediction": 0.0112785772854494, + "calibration_in_the_large": -0.0017037523214745096, + "expected_calibration_error_10bin": 0.002713555985801994, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "D62": { + "valid": 2499, + "positives": 71, + "negatives": 2428, + "auroc": 0.7823514397753903, + "auprc": 0.0814220289198379, + "brier": 0.026962663460537776, + "calibration": { + "observed_rate": 0.028411364545818326, + "mean_prediction": 0.025525717317320857, + "calibration_in_the_large": -0.002885647228497469, + "expected_calibration_error_10bin": 0.004850095506998246, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + "D63": { + "valid": 2686, + "positives": 76, + "negatives": 2610, + "auroc": 0.8594978826376286, + "auprc": 0.13947793358440727, + "brier": 0.026386816503963132, + "calibration": { + "observed_rate": 0.028294862248696945, + "mean_prediction": 0.02524494096504667, + "calibration_in_the_large": -0.003049921283650274, + "expected_calibration_error_10bin": 0.010541017150366991, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + "D64": { + "valid": 2434, + "positives": 119, + "negatives": 2315, + "auroc": 0.8077172985825, + "auprc": 0.1962026832191183, + "brier": 0.042916841243539824, + "calibration": { + "observed_rate": 0.04889071487263763, + "mean_prediction": 0.04948896347155187, + "calibration_in_the_large": 0.0005982485989142403, + "expected_calibration_error_10bin": 0.008048490258702821, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + "D65": { + "valid": 2833, + "positives": 4, + "negatives": 2829, + "auroc": 0.9604100388829975, + "auprc": 0.020983883013958204, + "brier": 0.0014102723433290644, + "calibration": { + "observed_rate": 0.0014119308153900459, + "mean_prediction": 0.0010493932148847708, + "calibration_in_the_large": -0.0003625376005052751, + "expected_calibration_error_10bin": 0.0003625376005052751, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + "D68": { + "valid": 2682, + "positives": 59, + "negatives": 2623, + "auroc": 0.82573970805844, + "auprc": 0.1629327227861043, + "brier": 0.020186610112914186, + "calibration": { + "observed_rate": 0.021998508575689784, + "mean_prediction": 0.013618158252697436, + "calibration_in_the_large": -0.008380350322992348, + "expected_calibration_error_10bin": 0.009691310148038727, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + "D69": { + "valid": 2586, + "positives": 85, + "negatives": 2501, + "auroc": 0.8285485805677729, + "auprc": 0.24434386150778425, + "brier": 0.028082423726446152, + "calibration": { + "observed_rate": 0.0328692962103635, + "mean_prediction": 0.023393930147574137, + "calibration_in_the_large": -0.00947536606278936, + "expected_calibration_error_10bin": 0.010311599015038567, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + "D70": { + "valid": 2787, + "positives": 26, + "negatives": 2761, + "auroc": 0.9038809795781907, + "auprc": 0.2421532551267808, + "brier": 0.008939625212918991, + "calibration": { + "observed_rate": 0.009329027628274129, + "mean_prediction": 0.009131208129566571, + "calibration_in_the_large": -0.000197819498707558, + "expected_calibration_error_10bin": 0.006283507603292592, + "nonempty_bins": 9 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "D72": { + "valid": 2595, + "positives": 65, + "negatives": 2530, + "auroc": 0.7129340224992399, + "auprc": 0.061121133467490894, + "brier": 0.024139673145018744, + "calibration": { + "observed_rate": 0.025048169556840076, + "mean_prediction": 0.02527522407965609, + "calibration_in_the_large": 0.00022705452281601354, + "expected_calibration_error_10bin": 0.0017629093977735728, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + "D73": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.8228760486825003, + "auprc": 0.020592062987374454, + "brier": 0.00109858158356754, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0017756171216692937, + "calibration_in_the_large": 0.0007132941754936562, + "expected_calibration_error_10bin": 0.0007132941754936566, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "D75": { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.8726565263530244, + "auprc": 0.00667333447344723, + "brier": 0.0014171689033767394, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0016540935808999223, + "calibration_in_the_large": 0.0002411652870108372, + "expected_calibration_error_10bin": 0.0002411652870108372, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "D80": { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.9880278367539514, + "auprc": 0.0952193863484186, + "brier": 0.002123098922901851, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.002219262741095404, + "calibration_in_the_large": 0.00010061867329879369, + "expected_calibration_error_10bin": 0.0006738000777210855, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "D89": { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.8447971781305115, + "auprc": 0.007419722299190296, + "brier": 0.0009406866557978677, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0012315638974733506, + "calibration_in_the_large": 0.0005265938586999985, + "expected_calibration_error_10bin": 0.0008884398422813164, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "E03": { + "valid": 2480, + "positives": 24, + "negatives": 2456, + "auroc": 0.7102334419109664, + "auprc": 0.023938440061548046, + "brier": 0.009546142466002269, + "calibration": { + "observed_rate": 0.00967741935483871, + "mean_prediction": 0.006443196581676603, + "calibration_in_the_large": -0.0032342227731621074, + "expected_calibration_error_10bin": 0.0032342227731621074, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + "E04": { + "valid": 2775, + "positives": 11, + "negatives": 2764, + "auroc": 0.6838902775950533, + "auprc": 0.009193544451932928, + "brier": 0.003963223608088505, + "calibration": { + "observed_rate": 0.003963963963963964, + "mean_prediction": 0.0036495854437397376, + "calibration_in_the_large": -0.0003143785202242267, + "expected_calibration_error_10bin": 0.0003143785202242267, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "E05": { + "valid": 2806, + "positives": 4, + "negatives": 2802, + "auroc": 0.4706459671663098, + "auprc": 0.028966536551879835, + "brier": 0.001420700820282628, + "calibration": { + "observed_rate": 0.0014255167498218105, + "mean_prediction": 0.0013818358889156877, + "calibration_in_the_large": -4.36808609061228e-05, + "expected_calibration_error_10bin": 4.36808609061228e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "E11": { + "valid": 2194, + "positives": 21, + "negatives": 2173, + "auroc": 0.7948633664234216, + "auprc": 0.14464398950071114, + "brier": 0.009202496407010327, + "calibration": { + "observed_rate": 0.009571558796718322, + "mean_prediction": 0.00868255130089917, + "calibration_in_the_large": -0.000889007495819152, + "expected_calibration_error_10bin": 0.0009665220297281719, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + "E16": { + "valid": 2816, + "positives": 12, + "negatives": 2804, + "auroc": 0.6857762719923918, + "auprc": 0.014656186341608438, + "brier": 0.0042364519208726616, + "calibration": { + "observed_rate": 0.004261363636363636, + "mean_prediction": 0.003088621707625159, + "calibration_in_the_large": -0.001172741928738477, + "expected_calibration_error_10bin": 0.001172741928738477, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "E21": { + "valid": 2814, + "positives": 4, + "negatives": 2810, + "auroc": 0.7555160142348755, + "auprc": 0.016810429003284177, + "brier": 0.0014350458409541366, + "calibration": { + "observed_rate": 0.0014214641080312722, + "mean_prediction": 0.002032058129754224, + "calibration_in_the_large": 0.0006105940217229519, + "expected_calibration_error_10bin": 0.0006105940217229516, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "E22": { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.8235668536420416, + "auprc": 0.017649648969642558, + "brier": 0.003287005961298312, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.006346147380803571, + "calibration_in_the_large": 0.0031341559461140634, + "expected_calibration_error_10bin": 0.0031341559461140625, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "E27": { + "valid": 2811, + "positives": 8, + "negatives": 2803, + "auroc": 0.832411701748127, + "auprc": 0.010742409568906968, + "brier": 0.0028635683890609175, + "calibration": { + "observed_rate": 0.002845962290999644, + "mean_prediction": 0.0028692728231067307, + "calibration_in_the_large": 2.3310532107086602e-05, + "expected_calibration_error_10bin": 2.3310532107086602e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + }, + "E43": { + "valid": 2748, + "positives": 39, + "negatives": 2709, + "auroc": 0.823588986379684, + "auprc": 0.07681152875947808, + "brier": 0.01381575596666898, + "calibration": { + "observed_rate": 0.014192139737991267, + "mean_prediction": 0.016010129134060313, + "calibration_in_the_large": 0.0018179893960690464, + "expected_calibration_error_10bin": 0.002586560878491152, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + "E44": { + "valid": 2800, + "positives": 23, + "negatives": 2777, + "auroc": 0.7478511374489205, + "auprc": 0.023021112539108327, + "brier": 0.008312654783974385, + "calibration": { + "observed_rate": 0.008214285714285714, + "mean_prediction": 0.010163447005054747, + "calibration_in_the_large": 0.0019491612907690335, + "expected_calibration_error_10bin": 0.0019491612907690332, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "E46": { + "valid": 2772, + "positives": 39, + "negatives": 2733, + "auroc": 0.8027995909444867, + "auprc": 0.07437537324449496, + "brier": 0.013676032241524074, + "calibration": { + "observed_rate": 0.01406926406926407, + "mean_prediction": 0.015181392044677973, + "calibration_in_the_large": 0.0011121279754139034, + "expected_calibration_error_10bin": 0.0025688002545277027, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + "E53": { + "valid": 2804, + "positives": 9, + "negatives": 2795, + "auroc": 0.6891671635857682, + "auprc": 0.0063957452816916895, + "brier": 0.0032411679233607933, + "calibration": { + "observed_rate": 0.003209700427960057, + "mean_prediction": 0.0034242718018584533, + "calibration_in_the_large": 0.0002145713738983964, + "expected_calibration_error_10bin": 0.0002145713738983964, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "E55": { + "valid": 2737, + "positives": 29, + "negatives": 2708, + "auroc": 0.6319334793459991, + "auprc": 0.018597393129062282, + "brier": 0.010682101012369959, + "calibration": { + "observed_rate": 0.010595542564852027, + "mean_prediction": 0.0125230190254068, + "calibration_in_the_large": 0.0019274764605547723, + "expected_calibration_error_10bin": 0.001927476460554772, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + "E66": { + "valid": 2371, + "positives": 42, + "negatives": 2329, + "auroc": 0.7380747919605799, + "auprc": 0.0540941257460959, + "brier": 0.017189822123337382, + "calibration": { + "observed_rate": 0.017714044706874738, + "mean_prediction": 0.01623210465177683, + "calibration_in_the_large": -0.0014819400550979064, + "expected_calibration_error_10bin": 0.0028845526342634142, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + "E78": { + "valid": 1572, + "positives": 50, + "negatives": 1522, + "auroc": 0.7433508541392904, + "auprc": 0.12657196450365477, + "brier": 0.03059390791018518, + "calibration": { + "observed_rate": 0.031806615776081425, + "mean_prediction": 0.0331079534454696, + "calibration_in_the_large": 0.0013013376693881765, + "expected_calibration_error_10bin": 0.013571840518208414, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + "E80": { + "valid": 2823, + "positives": 7, + "negatives": 2816, + "auroc": 0.7896712662337663, + "auprc": 0.01979630918683267, + "brier": 0.002508994605440931, + "calibration": { + "observed_rate": 0.002479631597591215, + "mean_prediction": 0.002507392511289672, + "calibration_in_the_large": 2.7760913698456676e-05, + "expected_calibration_error_10bin": 0.0004706858261236311, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "E83": { + "valid": 2653, + "positives": 82, + "negatives": 2571, + "auroc": 0.8095597233685289, + "auprc": 0.2046997732668237, + "brier": 0.02722324914693117, + "calibration": { + "observed_rate": 0.030908405578590276, + "mean_prediction": 0.02412800574347853, + "calibration_in_the_large": -0.006780399835111747, + "expected_calibration_error_10bin": 0.008731755298348914, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + "E86": { + "valid": 2587, + "positives": 92, + "negatives": 2495, + "auroc": 0.784612703668206, + "auprc": 0.11430183891244373, + "brier": 0.03323749842306599, + "calibration": { + "observed_rate": 0.03556242752222652, + "mean_prediction": 0.043220796591510825, + "calibration_in_the_large": 0.007658369069284306, + "expected_calibration_error_10bin": 0.0076583690692843065, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + "E87": { + "valid": 2185, + "positives": 153, + "negatives": 2032, + "auroc": 0.7885337862178993, + "auprc": 0.2330324117118477, + "brier": 0.05950791814126638, + "calibration": { + "observed_rate": 0.0700228832951945, + "mean_prediction": 0.05543689008187332, + "calibration_in_the_large": -0.014585993213321179, + "expected_calibration_error_10bin": 0.01862880975733676, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + "E88": { + "valid": 2817, + "positives": 15, + "negatives": 2802, + "auroc": 0.8287175826790388, + "auprc": 0.08274989250408528, + "brier": 0.005132597607335404, + "calibration": { + "observed_rate": 0.005324813631522897, + "mean_prediction": 0.00420420967972343, + "calibration_in_the_large": -0.001120603951799467, + "expected_calibration_error_10bin": 0.0011206039517994667, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "E89": { + "valid": 2780, + "positives": 8, + "negatives": 2772, + "auroc": 0.5994318181818182, + "auprc": 0.004021036022081377, + "brier": 0.0028850517239719675, + "calibration": { + "observed_rate": 0.0028776978417266188, + "mean_prediction": 0.0035014705351707124, + "calibration_in_the_large": 0.0006237726934440937, + "expected_calibration_error_10bin": 0.0006237726934440937, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "F02": { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8104896354538956, + "auprc": 0.006021752117115099, + "brier": 0.0015094387681890127, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.003241487260579045, + "calibration_in_the_large": 0.0018139355118281526, + "expected_calibration_error_10bin": 0.0018139355118281526, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "F03": { + "valid": 2739, + "positives": 16, + "negatives": 2723, + "auroc": 0.8623531031950055, + "auprc": 0.0335305125578859, + "brier": 0.005916408486686381, + "calibration": { + "observed_rate": 0.005841548010222709, + "mean_prediction": 0.00821437733157956, + "calibration_in_the_large": 0.0023728293213568516, + "expected_calibration_error_10bin": 0.002372829321356852, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "F05": { + "valid": 2750, + "positives": 31, + "negatives": 2719, + "auroc": 0.7303088184697885, + "auprc": 0.02521520047657075, + "brier": 0.011508721916523489, + "calibration": { + "observed_rate": 0.011272727272727273, + "mean_prediction": 0.013864467442083299, + "calibration_in_the_large": 0.002591740169356026, + "expected_calibration_error_10bin": 0.002591740169356028, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "F06": { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7119603680113235, + "auprc": 0.001809643162518684, + "brier": 0.0007371595795341821, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0031270084994025863, + "calibration_in_the_large": 0.002419794920901879, + "expected_calibration_error_10bin": 0.002419794920901879, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "F10": { + "valid": 2560, + "positives": 17, + "negatives": 2543, + "auroc": 0.8104369549628738, + "auprc": 0.1026760510033139, + "brier": 0.00639896183400219, + "calibration": { + "observed_rate": 0.006640625, + "mean_prediction": 0.008790335025980766, + "calibration_in_the_large": 0.002149710025980766, + "expected_calibration_error_10bin": 0.002574950726113911, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "F11": { + "valid": 2741, + "positives": 10, + "negatives": 2731, + "auroc": 0.8676675210545588, + "auprc": 0.033961397265925716, + "brier": 0.003684208647141529, + "calibration": { + "observed_rate": 0.0036483035388544327, + "mean_prediction": 0.004781719482962389, + "calibration_in_the_large": 0.0011334159441079563, + "expected_calibration_error_10bin": 0.0011334159441079566, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "F12": { + "valid": 2777, + "positives": 12, + "negatives": 2765, + "auroc": 0.8944243520192887, + "auprc": 0.025091053647632037, + "brier": 0.004276717248317689, + "calibration": { + "observed_rate": 0.004321209938782859, + "mean_prediction": 0.003864246879013099, + "calibration_in_the_large": -0.0004569630597697602, + "expected_calibration_error_10bin": 0.0005368471815028467, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "F14": { + "valid": 2787, + "positives": 10, + "negatives": 2777, + "auroc": 0.9504141159524667, + "auprc": 0.048870731331837135, + "brier": 0.003537670530347967, + "calibration": { + "observed_rate": 0.003588087549336204, + "mean_prediction": 0.0015172582665508457, + "calibration_in_the_large": -0.0020708292827853582, + "expected_calibration_error_10bin": 0.0020708292827853582, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "F15": { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.9605372145308247, + "auprc": 0.04571991567669157, + "brier": 0.002100719467735235, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.000710074540024372, + "calibration_in_the_large": -0.0014153239721966693, + "expected_calibration_error_10bin": 0.0014153239721966693, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "F17": { + "valid": 2426, + "positives": 33, + "negatives": 2393, + "auroc": 0.8596284618014663, + "auprc": 0.09340907139532803, + "brier": 0.012930450930284736, + "calibration": { + "observed_rate": 0.013602638087386645, + "mean_prediction": 0.013517138963278847, + "calibration_in_the_large": -8.549912410779799e-05, + "expected_calibration_error_10bin": 0.0013183566091139944, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + "F19": { + "valid": 2801, + "positives": 13, + "negatives": 2788, + "auroc": 0.9662564838318066, + "auprc": 0.14425151835426187, + "brier": 0.004449256034834294, + "calibration": { + "observed_rate": 0.0046411995715815784, + "mean_prediction": 0.0018483005202617887, + "calibration_in_the_large": -0.0027928990513197897, + "expected_calibration_error_10bin": 0.0027928990513197897, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F20": { + "valid": 2808, + "positives": 4, + "negatives": 2804, + "auroc": 0.821950784593438, + "auprc": 0.014536273693064365, + "brier": 0.001418730905736508, + "calibration": { + "observed_rate": 0.0014245014245014246, + "mean_prediction": 0.0010436272124223205, + "calibration_in_the_large": -0.0003808742120791041, + "expected_calibration_error_10bin": 0.0003808742120791041, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + "F22": { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.7450354609929078, + "auprc": 0.001388888888888889, + "brier": 0.0003591152494035595, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0012013625169700135, + "calibration_in_the_large": 0.0008468782915180462, + "expected_calibration_error_10bin": 0.0008468782915180462, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "F25": { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.78515625, + "auprc": 0.005385549705891911, + "brier": 0.001067014464395827, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0010493518526376697, + "calibration_in_the_large": -1.485531302391238e-05, + "expected_calibration_error_10bin": 1.485531302391238e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "F29": { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7680039313795568, + "auprc": 0.010231828331681197, + "brier": 0.0028437096311750205, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.0008426388603597555, + "calibration_in_the_large": -0.0020083946392838656, + "expected_calibration_error_10bin": 0.0020083946392838656, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "F31": { + "valid": 2724, + "positives": 9, + "negatives": 2715, + "auroc": 0.8527521997135257, + "auprc": 0.03279670142809012, + "brier": 0.003255790985271357, + "calibration": { + "observed_rate": 0.003303964757709251, + "mean_prediction": 0.0033293288695260474, + "calibration_in_the_large": 2.5364111816796216e-05, + "expected_calibration_error_10bin": 2.5364111816796216e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + "F32": { + "valid": 2200, + "positives": 68, + "negatives": 2132, + "auroc": 0.712166151638892, + "auprc": 0.08099173816812799, + "brier": 0.02989601156792764, + "calibration": { + "observed_rate": 0.03090909090909091, + "mean_prediction": 0.04105929955395616, + "calibration_in_the_large": 0.010150208644865249, + "expected_calibration_error_10bin": 0.01015020864486525, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + "F33": { + "valid": 2800, + "positives": 12, + "negatives": 2788, + "auroc": 0.7923840267814443, + "auprc": 0.015130864130146159, + "brier": 0.004286677401291494, + "calibration": { + "observed_rate": 0.004285714285714286, + "mean_prediction": 0.003345826927486217, + "calibration_in_the_large": -0.0009398873582280691, + "expected_calibration_error_10bin": 0.0009398873582280691, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "F39": { + "valid": 2801, + "positives": 11, + "negatives": 2790, + "auroc": 0.7147605083088954, + "auprc": 0.018629410789996328, + "brier": 0.003898880294023865, + "calibration": { + "observed_rate": 0.003927168868261335, + "mean_prediction": 0.00309591087969148, + "calibration_in_the_large": -0.0008312579885698551, + "expected_calibration_error_10bin": 0.0008312579885698551, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F41": { + "valid": 2247, + "positives": 78, + "negatives": 2169, + "auroc": 0.7062394344552021, + "auprc": 0.09969169517448344, + "brier": 0.03265341590153064, + "calibration": { + "observed_rate": 0.03471295060080107, + "mean_prediction": 0.03715412480745035, + "calibration_in_the_large": 0.0024411742066492853, + "expected_calibration_error_10bin": 0.00380737318470411, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + "F43": { + "valid": 2734, + "positives": 20, + "negatives": 2714, + "auroc": 0.7489314664701547, + "auprc": 0.05445547058035331, + "brier": 0.007173218105310361, + "calibration": { + "observed_rate": 0.0073152889539136795, + "mean_prediction": 0.008887207674351572, + "calibration_in_the_large": 0.0015719187204378928, + "expected_calibration_error_10bin": 0.0019943065560109785, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "F60": { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.9464201043148411, + "auprc": 0.06615853381862243, + "brier": 0.002069080678524142, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0021855872269536973, + "calibration_in_the_large": 5.6417603106997515e-05, + "expected_calibration_error_10bin": 5.641760310699727e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "F90": { + "valid": 2775, + "positives": 8, + "negatives": 2767, + "auroc": 0.8965034333212866, + "auprc": 0.03366064669553218, + "brier": 0.00285777289451496, + "calibration": { + "observed_rate": 0.002882882882882883, + "mean_prediction": 0.0011338851081617995, + "calibration_in_the_large": -0.0017489977747210835, + "expected_calibration_error_10bin": 0.0017489977747210835, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "G25": { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.698759633911368, + "auprc": 0.0048629233272086715, + "brier": 0.0021899328102330516, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.004027227830669429, + "calibration_in_the_large": 0.0018642862300926443, + "expected_calibration_error_10bin": 0.0018642862300926443, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "G31": { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.7712137486573577, + "auprc": 0.008574172495218545, + "brier": 0.0033757864097263383, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.005432635410974766, + "calibration_in_the_large": 0.002220643976285259, + "expected_calibration_error_10bin": 0.0022206439762852584, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "G40": { + "valid": 2723, + "positives": 24, + "negatives": 2699, + "auroc": 0.7462949240459429, + "auprc": 0.04819369558731573, + "brier": 0.008692197690658212, + "calibration": { + "observed_rate": 0.008813808299669483, + "mean_prediction": 0.008458695459421389, + "calibration_in_the_large": -0.0003551128402480945, + "expected_calibration_error_10bin": 0.0010980992554712615, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "G43": { + "valid": 2725, + "positives": 15, + "negatives": 2710, + "auroc": 0.7755965559655597, + "auprc": 0.01754857105065327, + "brier": 0.005462025228017344, + "calibration": { + "observed_rate": 0.005504587155963303, + "mean_prediction": 0.003795187045978126, + "calibration_in_the_large": -0.001709400109985177, + "expected_calibration_error_10bin": 0.001709400109985177, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + "G44": { + "valid": 2805, + "positives": 7, + "negatives": 2798, + "auroc": 0.6809455733687327, + "auprc": 0.006338895992797286, + "brier": 0.0025028825615955094, + "calibration": { + "observed_rate": 0.0024955436720142605, + "mean_prediction": 0.001788946519027474, + "calibration_in_the_large": -0.0007065971529867864, + "expected_calibration_error_10bin": 0.0007065971529867864, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "G47": { + "valid": 2315, + "positives": 88, + "negatives": 2227, + "auroc": 0.6938400620484141, + "auprc": 0.08704210728783761, + "brier": 0.03591006138994762, + "calibration": { + "observed_rate": 0.03801295896328294, + "mean_prediction": 0.03258719332274814, + "calibration_in_the_large": -0.005425765640534798, + "expected_calibration_error_10bin": 0.0063125958131147455, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + "G51": { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 1.1063769451396054e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0006793420999511783, + "calibration_in_the_large": 0.0006793420999511783, + "expected_calibration_error_10bin": 0.0006793420999511783, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + "G62": { + "valid": 2751, + "positives": 35, + "negatives": 2716, + "auroc": 0.814927414264675, + "auprc": 0.10200362710933249, + "brier": 0.01199918078937246, + "calibration": { + "observed_rate": 0.01272264631043257, + "mean_prediction": 0.009447717379447024, + "calibration_in_the_large": -0.0032749289309855455, + "expected_calibration_error_10bin": 0.003604403203257649, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "G81": { + "valid": 2789, + "positives": 14, + "negatives": 2775, + "auroc": 0.7473101673101673, + "auprc": 0.029980220904429113, + "brier": 0.004978655152506802, + "calibration": { + "observed_rate": 0.005019720329867336, + "mean_prediction": 0.003358106880747352, + "calibration_in_the_large": -0.001661613449119984, + "expected_calibration_error_10bin": 0.0019714249554375085, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "G83": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.739454094292804, + "auprc": 0.004543500475703865, + "brier": 0.0010698530747128654, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0015009064230563196, + "calibration_in_the_large": 0.00043858347688068206, + "expected_calibration_error_10bin": 0.00043858347688068206, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "G89": { + "valid": 2537, + "positives": 63, + "negatives": 2474, + "auroc": 0.768769809190181, + "auprc": 0.11792656063979966, + "brier": 0.023420952641165345, + "calibration": { + "observed_rate": 0.024832479306267245, + "mean_prediction": 0.03050637349511497, + "calibration_in_the_large": 0.005673894188847724, + "expected_calibration_error_10bin": 0.00701409602776547, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + "G90": { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 3.1907561350547254e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.00240540261618229, + "calibration_in_the_large": 0.00240540261618229, + "expected_calibration_error_10bin": 0.00240540261618229, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "G92": { + "valid": 2733, + "positives": 45, + "negatives": 2688, + "auroc": 0.7537946428571428, + "auprc": 0.06814121789270842, + "brier": 0.016265045321671348, + "calibration": { + "observed_rate": 0.01646542261251372, + "mean_prediction": 0.021539700315068955, + "calibration_in_the_large": 0.005074277702555235, + "expected_calibration_error_10bin": 0.005765926292958574, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "G93": { + "valid": 2656, + "positives": 50, + "negatives": 2606, + "auroc": 0.7977590176515733, + "auprc": 0.07032625171504071, + "brier": 0.01808483692779734, + "calibration": { + "observed_rate": 0.01882530120481928, + "mean_prediction": 0.01775624148594724, + "calibration_in_the_large": -0.001069059718872039, + "expected_calibration_error_10bin": 0.0019430964118974635, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + "G99": { + "valid": 2841, + "positives": 1, + "negatives": 2840, + "auroc": 0.8739436619718309, + "auprc": 0.002785515320334262, + "brier": 0.00035287749589179803, + "calibration": { + "observed_rate": 0.00035198873636043646, + "mean_prediction": 0.000512512089357897, + "calibration_in_the_large": 0.0001605233529974605, + "expected_calibration_error_10bin": 0.0001605233529974605, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9992965177629265 + }, + "H10": { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.7645671148855863, + "auprc": 0.01096380532704831, + "brier": 0.002113485135084528, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.0011542743698865156, + "calibration_in_the_large": -0.0009643696979100946, + "expected_calibration_error_10bin": 0.0009643696979100946, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "H26": { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 1.3957604879891647e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0018947462894274953, + "calibration_in_the_large": 0.0018947462894274953, + "expected_calibration_error_10bin": 0.0018947462894274953, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "H35": { + "valid": 2806, + "positives": 6, + "negatives": 2800, + "auroc": 0.7390476190476191, + "auprc": 0.007442547149185762, + "brier": 0.0021365316925432607, + "calibration": { + "observed_rate": 0.0021382751247327157, + "mean_prediction": 0.001022895766989921, + "calibration_in_the_large": -0.0011153793577427947, + "expected_calibration_error_10bin": 0.0011153793577427947, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "H40": { + "valid": 2750, + "positives": 12, + "negatives": 2738, + "auroc": 0.7510956902848794, + "auprc": 0.02346887212812024, + "brier": 0.004358836230861964, + "calibration": { + "observed_rate": 0.004363636363636364, + "mean_prediction": 0.005061294709898489, + "calibration_in_the_large": 0.0006976583462621252, + "expected_calibration_error_10bin": 0.0006976583462621256, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "H53": { + "valid": 2790, + "positives": 13, + "negatives": 2777, + "auroc": 0.6152738151297747, + "auprc": 0.011179957852460147, + "brier": 0.004665783167463408, + "calibration": { + "observed_rate": 0.004659498207885305, + "mean_prediction": 0.005884845098096704, + "calibration_in_the_large": 0.001225346890211399, + "expected_calibration_error_10bin": 0.0012253468902113985, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "H54": { + "valid": 2809, + "positives": 4, + "negatives": 2805, + "auroc": 0.43440285204991086, + "auprc": 0.001492028868850458, + "brier": 0.0014600421931414457, + "calibration": { + "observed_rate": 0.001423994304022784, + "mean_prediction": 0.003128538170946846, + "calibration_in_the_large": 0.0017045438669240618, + "expected_calibration_error_10bin": 0.0017045438669240618, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "H91": { + "valid": 2791, + "positives": 7, + "negatives": 2784, + "auroc": 0.7548747947454844, + "auprc": 0.008614417656133844, + "brier": 0.002511950939738713, + "calibration": { + "observed_rate": 0.0025080616266571123, + "mean_prediction": 0.0031829207510706723, + "calibration_in_the_large": 0.0006748591244135601, + "expected_calibration_error_10bin": 0.0006748591244135601, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + "I07": { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.8722636374393563, + "auprc": 0.010249400617757403, + "brier": 0.002141244306484354, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0015263072834073718, + "calibration_in_the_large": -0.0005990912288136696, + "expected_calibration_error_10bin": 0.0007710295836737464, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "I08": { + "valid": 2767, + "positives": 13, + "negatives": 2754, + "auroc": 0.8785542707111335, + "auprc": 0.032507693946604244, + "brier": 0.00499092983003986, + "calibration": { + "observed_rate": 0.0046982291290206, + "mean_prediction": 0.00852122968387192, + "calibration_in_the_large": 0.003823000554851321, + "expected_calibration_error_10bin": 0.0038230005548513194, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + "I10": { + "valid": 1498, + "positives": 40, + "negatives": 1458, + "auroc": 0.6815672153635116, + "auprc": 0.06445352074000801, + "brier": 0.0260146185118163, + "calibration": { + "observed_rate": 0.0267022696929239, + "mean_prediction": 0.021194234507258495, + "calibration_in_the_large": -0.005508035185665405, + "expected_calibration_error_10bin": 0.008013003423001161, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + "I11": { + "valid": 2676, + "positives": 53, + "negatives": 2623, + "auroc": 0.8097454304807257, + "auprc": 0.08254578060417839, + "brier": 0.018969142030296482, + "calibration": { + "observed_rate": 0.019805680119581465, + "mean_prediction": 0.013047144007011938, + "calibration_in_the_large": -0.006758536112569527, + "expected_calibration_error_10bin": 0.008773035415016282, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + "I12": { + "valid": 2552, + "positives": 29, + "negatives": 2523, + "auroc": 0.8476362294477018, + "auprc": 0.06461218629574332, + "brier": 0.011201492664383614, + "calibration": { + "observed_rate": 0.011363636363636364, + "mean_prediction": 0.008667555754352371, + "calibration_in_the_large": -0.002696080609283993, + "expected_calibration_error_10bin": 0.005033932220521534, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + "I13": { + "valid": 2727, + "positives": 30, + "negatives": 2697, + "auroc": 0.9017797552836485, + "auprc": 0.1786771175950128, + "brier": 0.009928218313239562, + "calibration": { + "observed_rate": 0.011001100110011002, + "mean_prediction": 0.012121835370735435, + "calibration_in_the_large": 0.0011207352607244328, + "expected_calibration_error_10bin": 0.004184259766691482, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + "I16": { + "valid": 2390, + "positives": 12, + "negatives": 2378, + "auroc": 0.8974278104850014, + "auprc": 0.03439535115442565, + "brier": 0.0049510216454872885, + "calibration": { + "observed_rate": 0.00502092050209205, + "mean_prediction": 0.0030630937024565446, + "calibration_in_the_large": -0.0019578267996355056, + "expected_calibration_error_10bin": 0.0019578267996355056, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + "I21": { + "valid": 2671, + "positives": 22, + "negatives": 2649, + "auroc": 0.814303853941453, + "auprc": 0.036585262132837006, + "brier": 0.008328917445592594, + "calibration": { + "observed_rate": 0.008236615499812805, + "mean_prediction": 0.013627470302291268, + "calibration_in_the_large": 0.005390854802478463, + "expected_calibration_error_10bin": 0.0053908548024784635, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "I24": { + "valid": 2809, + "positives": 8, + "negatives": 2801, + "auroc": 0.9080239200285612, + "auprc": 0.03525747693344345, + "brier": 0.0028060946329230303, + "calibration": { + "observed_rate": 0.002847988608045568, + "mean_prediction": 0.0021571994304690335, + "calibration_in_the_large": -0.0006907891775765345, + "expected_calibration_error_10bin": 0.0006907891775765345, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "I25": { + "valid": 2243, + "positives": 44, + "negatives": 2199, + "auroc": 0.8447538137169788, + "auprc": 0.08052411932698014, + "brier": 0.018655501160102065, + "calibration": { + "observed_rate": 0.01961658493089612, + "mean_prediction": 0.01705858754624193, + "calibration_in_the_large": -0.00255799738465419, + "expected_calibration_error_10bin": 0.004935197494029283, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + "I26": { + "valid": 2760, + "positives": 20, + "negatives": 2740, + "auroc": 0.7381934306569343, + "auprc": 0.12754359975631463, + "brier": 0.006951157246137131, + "calibration": { + "observed_rate": 0.007246376811594203, + "mean_prediction": 0.006455770496867827, + "calibration_in_the_large": -0.0007906063147263762, + "expected_calibration_error_10bin": 0.0007906063147263767, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + "I27": { + "valid": 2716, + "positives": 36, + "negatives": 2680, + "auroc": 0.8405161691542289, + "auprc": 0.057974586831909515, + "brier": 0.012950709185282697, + "calibration": { + "observed_rate": 0.013254786450662739, + "mean_prediction": 0.010825925892684352, + "calibration_in_the_large": -0.002428860557978387, + "expected_calibration_error_10bin": 0.005955488284622797, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I31": { + "valid": 2793, + "positives": 16, + "negatives": 2777, + "auroc": 0.8260487936622254, + "auprc": 0.05274045964206484, + "brier": 0.005623907098456486, + "calibration": { + "observed_rate": 0.005728607232366631, + "mean_prediction": 0.004073318465096775, + "calibration_in_the_large": -0.0016552887672698566, + "expected_calibration_error_10bin": 0.0016552887672698564, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I34": { + "valid": 2753, + "positives": 18, + "negatives": 2735, + "auroc": 0.7630509851716433, + "auprc": 0.019529254642348687, + "brier": 0.006601997731437411, + "calibration": { + "observed_rate": 0.006538321830730113, + "mean_prediction": 0.006197806877107799, + "calibration_in_the_large": -0.000340514953622314, + "expected_calibration_error_10bin": 0.0016444068718684255, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + "I35": { + "valid": 2723, + "positives": 7, + "negatives": 2716, + "auroc": 0.7061855670103093, + "auprc": 0.007903464937238461, + "brier": 0.0027098547276997414, + "calibration": { + "observed_rate": 0.002570694087403599, + "mean_prediction": 0.004976630016011463, + "calibration_in_the_large": 0.0024059359286078643, + "expected_calibration_error_10bin": 0.0024059359286078643, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "I42": { + "valid": 2740, + "positives": 13, + "negatives": 2727, + "auroc": 0.9198330089419199, + "auprc": 0.05926403190055751, + "brier": 0.004630058432968205, + "calibration": { + "observed_rate": 0.004744525547445255, + "mean_prediction": 0.005085904479766499, + "calibration_in_the_large": 0.00034137893232124347, + "expected_calibration_error_10bin": 0.00034137893232124347, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "I44": { + "valid": 2722, + "positives": 23, + "negatives": 2699, + "auroc": 0.8282616750165117, + "auprc": 0.0641090056849417, + "brier": 0.008247444997527628, + "calibration": { + "observed_rate": 0.008449669360764144, + "mean_prediction": 0.00994448265013994, + "calibration_in_the_large": 0.0014948132893757952, + "expected_calibration_error_10bin": 0.0014948132893757948, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + "I45": { + "valid": 2766, + "positives": 22, + "negatives": 2744, + "auroc": 0.6924695202756427, + "auprc": 0.026998528815807384, + "brier": 0.007855654183109415, + "calibration": { + "observed_rate": 0.007953723788864787, + "mean_prediction": 0.007756706226578125, + "calibration_in_the_large": -0.0001970175622866624, + "expected_calibration_error_10bin": 0.0001970175622866624, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + "I46": { + "valid": 2831, + "positives": 3, + "negatives": 2828, + "auroc": 0.572017916077322, + "auprc": 0.0015760722151560113, + "brier": 0.0010749161510747573, + "calibration": { + "observed_rate": 0.0010596962204168139, + "mean_prediction": 0.0022588501661475763, + "calibration_in_the_large": 0.0011991539457307625, + "expected_calibration_error_10bin": 0.0011991539457307625, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I47": { + "valid": 2716, + "positives": 18, + "negatives": 2698, + "auroc": 0.6947121324437855, + "auprc": 0.014827431214506411, + "brier": 0.0066729834206221035, + "calibration": { + "observed_rate": 0.0066273932253313695, + "mean_prediction": 0.009319496125610602, + "calibration_in_the_large": 0.0026921029002792323, + "expected_calibration_error_10bin": 0.0026921029002792323, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I48": { + "valid": 2385, + "positives": 32, + "negatives": 2353, + "auroc": 0.7454977688057799, + "auprc": 0.03350344086589373, + "brier": 0.013293779884847505, + "calibration": { + "observed_rate": 0.013417190775681341, + "mean_prediction": 0.012758192114177622, + "calibration_in_the_large": -0.000658998661503719, + "expected_calibration_error_10bin": 0.001869296196304395, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + "I49": { + "valid": 2734, + "positives": 19, + "negatives": 2715, + "auroc": 0.7046815934864786, + "auprc": 0.01529476328421725, + "brier": 0.00689234221812848, + "calibration": { + "observed_rate": 0.006949524506217996, + "mean_prediction": 0.004945464502114274, + "calibration_in_the_large": -0.002004060004103722, + "expected_calibration_error_10bin": 0.002004060004103722, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I50": { + "valid": 2415, + "positives": 50, + "negatives": 2365, + "auroc": 0.8115771670190275, + "auprc": 0.12177675413600504, + "brier": 0.01971408247374623, + "calibration": { + "observed_rate": 0.020703933747412008, + "mean_prediction": 0.020588968349856906, + "calibration_in_the_large": -0.00011496539755510155, + "expected_calibration_error_10bin": 0.004941379939476858, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + "I51": { + "valid": 2807, + "positives": 9, + "negatives": 2798, + "auroc": 0.8648637915971726, + "auprc": 0.02684196493495935, + "brier": 0.003175560854642843, + "calibration": { + "observed_rate": 0.003206270039187745, + "mean_prediction": 0.002405953226350836, + "calibration_in_the_large": -0.000800316812836909, + "expected_calibration_error_10bin": 0.000800316812836909, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "I61": { + "valid": 2802, + "positives": 8, + "negatives": 2794, + "auroc": 0.8463672154617037, + "auprc": 0.011825214868843937, + "brier": 0.002845301223251309, + "calibration": { + "observed_rate": 0.0028551034975017845, + "mean_prediction": 0.0012220946739851506, + "calibration_in_the_large": -0.0016330088235166338, + "expected_calibration_error_10bin": 0.0016330088235166338, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "I63": { + "valid": 2735, + "positives": 15, + "negatives": 2720, + "auroc": 0.7672549019607843, + "auprc": 0.017096457534607434, + "brier": 0.005511558894587352, + "calibration": { + "observed_rate": 0.005484460694698354, + "mean_prediction": 0.005196492079443956, + "calibration_in_the_large": -0.0002879686152543982, + "expected_calibration_error_10bin": 0.000815810132687132, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + "I65": { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.6349349710982659, + "auprc": 0.009609051986132962, + "brier": 0.0021747290094150467, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.003560512356155039, + "calibration_in_the_large": 0.0013975707555782548, + "expected_calibration_error_10bin": 0.0013975707555782548, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "I67": { + "valid": 2773, + "positives": 4, + "negatives": 2769, + "auroc": 0.7030516431924883, + "auprc": 0.005131468447242681, + "brier": 0.0014902808736468518, + "calibration": { + "observed_rate": 0.00144248106743599, + "mean_prediction": 0.00341642217011692, + "calibration_in_the_large": 0.0019739411026809296, + "expected_calibration_error_10bin": 0.0019739411026809296, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "I69": { + "valid": 2752, + "positives": 19, + "negatives": 2733, + "auroc": 0.7836385695303022, + "auprc": 0.033085307524862224, + "brier": 0.006831037577904721, + "calibration": { + "observed_rate": 0.006904069767441861, + "mean_prediction": 0.007476702379343552, + "calibration_in_the_large": 0.0005726326119016916, + "expected_calibration_error_10bin": 0.0005726326119016916, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + "I70": { + "valid": 2771, + "positives": 12, + "negatives": 2759, + "auroc": 0.8139724537876042, + "auprc": 0.02411009717131474, + "brier": 0.004295246710763247, + "calibration": { + "observed_rate": 0.004330566582461205, + "mean_prediction": 0.002988681388430126, + "calibration_in_the_large": -0.001341885194031079, + "expected_calibration_error_10bin": 0.001341885194031079, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + "I71": { + "valid": 2769, + "positives": 5, + "negatives": 2764, + "auroc": 0.7479739507959479, + "auprc": 0.005493514956782115, + "brier": 0.0018188323447793121, + "calibration": { + "observed_rate": 0.0018057060310581437, + "mean_prediction": 0.0028947572985011365, + "calibration_in_the_large": 0.0010890512674429928, + "expected_calibration_error_10bin": 0.0010890512674429928, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + "I72": { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.6926861071597914, + "auprc": 0.008649535756205534, + "brier": 0.002130581890827664, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0016315688990457173, + "calibration_in_the_large": -0.0004976007248009824, + "expected_calibration_error_10bin": 0.0004976007248009824, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "I73": { + "valid": 2734, + "positives": 10, + "negatives": 2724, + "auroc": 0.8380690161527166, + "auprc": 0.1090786907397167, + "brier": 0.0035007102581959453, + "calibration": { + "observed_rate": 0.0036576444769568397, + "mean_prediction": 0.002875365846088624, + "calibration_in_the_large": -0.0007822786308682157, + "expected_calibration_error_10bin": 0.00102170587251416, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I74": { + "valid": 2821, + "positives": 5, + "negatives": 2816, + "auroc": 0.5919744318181818, + "auprc": 0.003970996348006605, + "brier": 0.00177095359760074, + "calibration": { + "observed_rate": 0.001772421127259837, + "mean_prediction": 0.000984729905381205, + "calibration_in_the_large": -0.0007876912218786319, + "expected_calibration_error_10bin": 0.0007876912218786319, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "I77": { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.7152452920714886, + "auprc": 0.009018879410460248, + "brier": 0.0021526811763350213, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.002443284970553319, + "calibration_in_the_large": 0.00028888640681902847, + "expected_calibration_error_10bin": 0.00028888640681902847, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "I80": { + "valid": 2827, + "positives": 5, + "negatives": 2822, + "auroc": 0.8865343727852587, + "auprc": 0.07431279448599845, + "brier": 0.0017377183214661615, + "calibration": { + "observed_rate": 0.0017686593562079944, + "mean_prediction": 0.0014806119331943915, + "calibration_in_the_large": -0.0002880474230136029, + "expected_calibration_error_10bin": 0.00038435771284655565, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "I81": { + "valid": 2826, + "positives": 8, + "negatives": 2818, + "auroc": 0.7599361249112846, + "auprc": 0.020585974220867036, + "brier": 0.0029562752653467406, + "calibration": { + "observed_rate": 0.0028308563340410475, + "mean_prediction": 0.002598608684671317, + "calibration_in_the_large": -0.0002322476493697304, + "expected_calibration_error_10bin": 0.0013795771719156604, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I82": { + "valid": 2739, + "positives": 35, + "negatives": 2704, + "auroc": 0.7460059171597633, + "auprc": 0.05162141451669939, + "brier": 0.01254233738351754, + "calibration": { + "observed_rate": 0.012778386272362175, + "mean_prediction": 0.011662062894104201, + "calibration_in_the_large": -0.0011163233782579742, + "expected_calibration_error_10bin": 0.0024890045397875, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "I85": { + "valid": 2793, + "positives": 9, + "negatives": 2784, + "auroc": 0.9912196679438059, + "auprc": 0.2250916808923345, + "brier": 0.0030585108799289803, + "calibration": { + "observed_rate": 0.00322234156820623, + "mean_prediction": 0.002136961475657753, + "calibration_in_the_large": -0.001085380092548477, + "expected_calibration_error_10bin": 0.0022832452486805255, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I87": { + "valid": 2780, + "positives": 13, + "negatives": 2767, + "auroc": 0.7427372049706709, + "auprc": 0.01915921009127383, + "brier": 0.004681868053078438, + "calibration": { + "observed_rate": 0.004676258992805755, + "mean_prediction": 0.006032789006940547, + "calibration_in_the_large": 0.0013565300141347922, + "expected_calibration_error_10bin": 0.0013565300141347913, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "I89": { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8400567174760724, + "auprc": 0.01215040661722875, + "brier": 0.0017629470589529013, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0007962971928295962, + "calibration_in_the_large": -0.0009729880159460583, + "expected_calibration_error_10bin": 0.0009729880159460583, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I95": { + "valid": 2485, + "positives": 97, + "negatives": 2388, + "auroc": 0.7533069125697215, + "auprc": 0.09446790167179188, + "brier": 0.03660883831447198, + "calibration": { + "observed_rate": 0.03903420523138833, + "mean_prediction": 0.035445237676078975, + "calibration_in_the_large": -0.0035889675553093525, + "expected_calibration_error_10bin": 0.009664737601938773, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + "I96": { + "valid": 2831, + "positives": 6, + "negatives": 2825, + "auroc": 0.8789380530973452, + "auprc": 0.034795896601112264, + "brier": 0.0020919440944601993, + "calibration": { + "observed_rate": 0.0021193924408336277, + "mean_prediction": 0.00199045766897383, + "calibration_in_the_large": -0.00012893477185979768, + "expected_calibration_error_10bin": 0.00012893477185979768, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I97": { + "valid": 2740, + "positives": 11, + "negatives": 2729, + "auroc": 0.7655484859588927, + "auprc": 0.01315541130614384, + "brier": 0.003993762956987772, + "calibration": { + "observed_rate": 0.0040145985401459855, + "mean_prediction": 0.0036550124761853264, + "calibration_in_the_large": -0.0003595860639606591, + "expected_calibration_error_10bin": 0.0003595860639606591, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "J02": { + "valid": 2825, + "positives": 2, + "negatives": 2823, + "auroc": 0.675699610343606, + "auprc": 0.0016241337953091684, + "brier": 0.0007328937170320527, + "calibration": { + "observed_rate": 0.0007079646017699115, + "mean_prediction": 0.0019559870054275705, + "calibration_in_the_large": 0.001248022403657659, + "expected_calibration_error_10bin": 0.0012480224036576588, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J06": { + "valid": 2816, + "positives": 10, + "negatives": 2806, + "auroc": 0.7172843905915894, + "auprc": 0.012013143404357303, + "brier": 0.003640152029830292, + "calibration": { + "observed_rate": 0.0035511363636363635, + "mean_prediction": 0.004140573732503195, + "calibration_in_the_large": 0.0005894373688668316, + "expected_calibration_error_10bin": 0.0005894373688668316, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "J12": { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.9628712871287128, + "auprc": 0.009433962264150943, + "brier": 0.0004936095252706421, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.0034145212112999196, + "calibration_in_the_large": 0.0030610394156123976, + "expected_calibration_error_10bin": 0.003061039415612397, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J15": { + "valid": 2795, + "positives": 15, + "negatives": 2780, + "auroc": 0.8088489208633094, + "auprc": 0.02151248867079313, + "brier": 0.005426127483469391, + "calibration": { + "observed_rate": 0.005366726296958855, + "mean_prediction": 0.006658298332210421, + "calibration_in_the_large": 0.001291572035251566, + "expected_calibration_error_10bin": 0.0012915720352515646, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + "J18": { + "valid": 2671, + "positives": 62, + "negatives": 2609, + "auroc": 0.7745335624822265, + "auprc": 0.07495028489102401, + "brier": 0.022353980151989302, + "calibration": { + "observed_rate": 0.023212280044926994, + "mean_prediction": 0.02098446804175843, + "calibration_in_the_large": -0.0022278120031685653, + "expected_calibration_error_10bin": 0.0061789173882165925, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "J30": { + "valid": 2815, + "positives": 7, + "negatives": 2808, + "auroc": 0.7480667480667481, + "auprc": 0.029688703092922427, + "brier": 0.002481085699886181, + "calibration": { + "observed_rate": 0.002486678507992895, + "mean_prediction": 0.0032833420026275703, + "calibration_in_the_large": 0.0007966634946346752, + "expected_calibration_error_10bin": 0.0007966634946346755, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "J32": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.5100813583303856, + "auprc": 0.0024612164531707652, + "brier": 0.000731971922977393, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0014961521184652762, + "calibration_in_the_large": 0.0007891885270902319, + "expected_calibration_error_10bin": 0.0007891885270902319, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J38": { + "valid": 2825, + "positives": 3, + "negatives": 2822, + "auroc": 0.7454523978266006, + "auprc": 0.0037182299840527685, + "brier": 0.0010709633274987606, + "calibration": { + "observed_rate": 0.0010619469026548673, + "mean_prediction": 0.0017743927979634753, + "calibration_in_the_large": 0.000712445895308608, + "expected_calibration_error_10bin": 0.000712445895308608, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J43": { + "valid": 2804, + "positives": 9, + "negatives": 2795, + "auroc": 0.6311667660504869, + "auprc": 0.005467868922932896, + "brier": 0.003219589233772714, + "calibration": { + "observed_rate": 0.003209700427960057, + "mean_prediction": 0.001974347851456967, + "calibration_in_the_large": -0.00123535257650309, + "expected_calibration_error_10bin": 0.0013229692467368074, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "J44": { + "valid": 2570, + "positives": 28, + "negatives": 2542, + "auroc": 0.7916151511745532, + "auprc": 0.035944754496495715, + "brier": 0.010717447839911697, + "calibration": { + "observed_rate": 0.010894941634241245, + "mean_prediction": 0.008856066294447728, + "calibration_in_the_large": -0.002038875339793517, + "expected_calibration_error_10bin": 0.0032130395756173303, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + "J45": { + "valid": 2518, + "positives": 24, + "negatives": 2494, + "auroc": 0.6962042234696605, + "auprc": 0.02403228861007843, + "brier": 0.009435185997131003, + "calibration": { + "observed_rate": 0.009531374106433678, + "mean_prediction": 0.008729050049855655, + "calibration_in_the_large": -0.0008023240565780236, + "expected_calibration_error_10bin": 0.0012190427521659422, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + "J47": { + "valid": 2825, + "positives": 6, + "negatives": 2819, + "auroc": 0.8621260494265106, + "auprc": 0.014756255710427615, + "brier": 0.0021181440060076594, + "calibration": { + "observed_rate": 0.0021238938053097347, + "mean_prediction": 0.0009579446697914772, + "calibration_in_the_large": -0.0011659491355182575, + "expected_calibration_error_10bin": 0.0011659491355182575, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J69": { + "valid": 2777, + "positives": 30, + "negatives": 2747, + "auroc": 0.7767261254702099, + "auprc": 0.036950236733088865, + "brier": 0.010684005350186272, + "calibration": { + "observed_rate": 0.010803024846957148, + "mean_prediction": 0.011561378385923275, + "calibration_in_the_large": 0.0007583535389661267, + "expected_calibration_error_10bin": 0.0007583535389661266, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "J81": { + "valid": 2781, + "positives": 21, + "negatives": 2760, + "auroc": 0.7711697722567288, + "auprc": 0.02693005135137388, + "brier": 0.007468208665202657, + "calibration": { + "observed_rate": 0.007551240560949299, + "mean_prediction": 0.0036206478692965595, + "calibration_in_the_large": -0.0039305926916527395, + "expected_calibration_error_10bin": 0.0039305926916527395, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "J84": { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.9142857142857143, + "auprc": 0.032356236390147716, + "brier": 0.002455318878534323, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.001903852246762198, + "calibration_in_the_large": -0.0005810607812818205, + "expected_calibration_error_10bin": 0.0005810607812818205, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "J90": { + "valid": 2754, + "positives": 37, + "negatives": 2717, + "auroc": 0.7151070835281361, + "auprc": 0.028159210991267013, + "brier": 0.013396442535134064, + "calibration": { + "observed_rate": 0.013435003631082063, + "mean_prediction": 0.010641207905140573, + "calibration_in_the_large": -0.002793795725941489, + "expected_calibration_error_10bin": 0.004497159809305003, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + "J91": { + "valid": 2807, + "positives": 11, + "negatives": 2796, + "auroc": 0.835381714137079, + "auprc": 0.06271733679120152, + "brier": 0.0038368296815115056, + "calibration": { + "observed_rate": 0.003918774492340577, + "mean_prediction": 0.00425596884923046, + "calibration_in_the_large": 0.00033719435688988296, + "expected_calibration_error_10bin": 0.0005653293723218347, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "J94": { + "valid": 2829, + "positives": 10, + "negatives": 2819, + "auroc": 0.7232351897836112, + "auprc": 0.11708284617170046, + "brier": 0.003474271236529347, + "calibration": { + "observed_rate": 0.003534817956875221, + "mean_prediction": 0.0015593460412298354, + "calibration_in_the_large": -0.0019754719156453854, + "expected_calibration_error_10bin": 0.0019754719156453854, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J95": { + "valid": 2770, + "positives": 16, + "negatives": 2754, + "auroc": 0.804261982570806, + "auprc": 0.03621905844806106, + "brier": 0.005676253431151207, + "calibration": { + "observed_rate": 0.005776173285198556, + "mean_prediction": 0.00565015847339452, + "calibration_in_the_large": -0.00012601481180403527, + "expected_calibration_error_10bin": 0.00021777814208460175, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + "J96": { + "valid": 2605, + "positives": 76, + "negatives": 2529, + "auroc": 0.8170381469688456, + "auprc": 0.10758109355235716, + "brier": 0.027727546845185608, + "calibration": { + "observed_rate": 0.029174664107485603, + "mean_prediction": 0.02743360533165851, + "calibration_in_the_large": -0.0017410587758270937, + "expected_calibration_error_10bin": 0.008304437483288166, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + "J98": { + "valid": 2692, + "positives": 37, + "negatives": 2655, + "auroc": 0.780292156563343, + "auprc": 0.057457673456197275, + "brier": 0.013299717233133926, + "calibration": { + "observed_rate": 0.0137444279346211, + "mean_prediction": 0.010861823440407542, + "calibration_in_the_large": -0.0028826044942135576, + "expected_calibration_error_10bin": 0.002882604494213557, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + "K04": { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.952364149611856, + "auprc": 0.011161547071259794, + "brier": 0.0007044640628635538, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0009225483453896839, + "calibration_in_the_large": 0.00021732972761817474, + "expected_calibration_error_10bin": 0.00021732972761817474, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "K12": { + "valid": 2824, + "positives": 14, + "negatives": 2810, + "auroc": 0.8718861209964412, + "auprc": 0.08613995221588645, + "brier": 0.005334982503514403, + "calibration": { + "observed_rate": 0.004957507082152974, + "mean_prediction": 0.004682080911126533, + "calibration_in_the_large": -0.00027542617102644176, + "expected_calibration_error_10bin": 0.0039467663088309755, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K20": { + "valid": 2813, + "positives": 11, + "negatives": 2802, + "auroc": 0.7071896697164363, + "auprc": 0.045015759039742496, + "brier": 0.003917535257800752, + "calibration": { + "observed_rate": 0.0039104159260575895, + "mean_prediction": 0.006439674459399862, + "calibration_in_the_large": 0.0025292585333422726, + "expected_calibration_error_10bin": 0.002529258533342272, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K21": { + "valid": 2043, + "positives": 88, + "negatives": 1955, + "auroc": 0.7558939781446176, + "auprc": 0.14842433074202827, + "brier": 0.039106265259700825, + "calibration": { + "observed_rate": 0.043073910915320604, + "mean_prediction": 0.044745535061754396, + "calibration_in_the_large": 0.0016716241464337922, + "expected_calibration_error_10bin": 0.0026269056001195796, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + "K22": { + "valid": 2764, + "positives": 19, + "negatives": 2745, + "auroc": 0.7593902789761289, + "auprc": 0.027404052354385266, + "brier": 0.00677490880604348, + "calibration": { + "observed_rate": 0.006874095513748191, + "mean_prediction": 0.005681514687552797, + "calibration_in_the_large": -0.0011925808261953937, + "expected_calibration_error_10bin": 0.0011925808261953937, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + "K25": { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.7542958820538892, + "auprc": 0.009117407579750799, + "brier": 0.002560340503299614, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.0037622479346967274, + "calibration_in_the_large": 0.0012773349066527088, + "expected_calibration_error_10bin": 0.0012773349066527088, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "K26": { + "valid": 2814, + "positives": 6, + "negatives": 2808, + "auroc": 0.9199905033238367, + "auprc": 0.037094977103786564, + "brier": 0.002106660082608574, + "calibration": { + "observed_rate": 0.0021321961620469083, + "mean_prediction": 0.0018650332908649763, + "calibration_in_the_large": -0.000267162871181932, + "expected_calibration_error_10bin": 0.000267162871181932, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "K29": { + "valid": 2785, + "positives": 14, + "negatives": 2771, + "auroc": 0.7227664071763675, + "auprc": 0.022098295497092826, + "brier": 0.00505511636246869, + "calibration": { + "observed_rate": 0.005026929982046679, + "mean_prediction": 0.00872787151266645, + "calibration_in_the_large": 0.003700941530619772, + "expected_calibration_error_10bin": 0.003700941530619772, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K30": { + "valid": 2837, + "positives": 3, + "negatives": 2834, + "auroc": 0.9460127028934369, + "auprc": 0.016176470588235296, + "brier": 0.001054938185163591, + "calibration": { + "observed_rate": 0.0010574550581600281, + "mean_prediction": 0.0016176130378493506, + "calibration_in_the_large": 0.0005601579796893224, + "expected_calibration_error_10bin": 0.0005601579796893224, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "K31": { + "valid": 2756, + "positives": 19, + "negatives": 2737, + "auroc": 0.9021979501182624, + "auprc": 0.06967949936488975, + "brier": 0.0066892006087969245, + "calibration": { + "observed_rate": 0.006894049346879536, + "mean_prediction": 0.006515654185504676, + "calibration_in_the_large": -0.0003783951613748598, + "expected_calibration_error_10bin": 0.0015267586745358922, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "K40": { + "valid": 2827, + "positives": 3, + "negatives": 2824, + "auroc": 0.8877478753541076, + "auprc": 0.006036655320520722, + "brier": 0.0010610451417786978, + "calibration": { + "observed_rate": 0.0010611956137247967, + "mean_prediction": 0.0017481612477717667, + "calibration_in_the_large": 0.00068696563404697, + "expected_calibration_error_10bin": 0.00068696563404697, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "K42": { + "valid": 2820, + "positives": 7, + "negatives": 2813, + "auroc": 0.8057996038799452, + "auprc": 0.02166671055159793, + "brier": 0.0024789491164987623, + "calibration": { + "observed_rate": 0.0024822695035460994, + "mean_prediction": 0.001458735539287276, + "calibration_in_the_large": -0.0010235339642588235, + "expected_calibration_error_10bin": 0.0011151420759988274, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "K43": { + "valid": 2813, + "positives": 9, + "negatives": 2804, + "auroc": 0.8120542082738944, + "auprc": 0.01884958679771539, + "brier": 0.0031928632924176953, + "calibration": { + "observed_rate": 0.003199431212228937, + "mean_prediction": 0.0028049236723925474, + "calibration_in_the_large": -0.00039450753983638967, + "expected_calibration_error_10bin": 0.00039450753983638967, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K44": { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.663992594878124, + "auprc": 0.006584770940260538, + "brier": 0.0025163948582160346, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.0033139384118866222, + "calibration_in_the_large": 0.0008004734208632829, + "expected_calibration_error_10bin": 0.0008004734208632829, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K52": { + "valid": 2749, + "positives": 38, + "negatives": 2711, + "auroc": 0.7948513851948203, + "auprc": 0.10634832528428413, + "brier": 0.013688216742221159, + "calibration": { + "observed_rate": 0.013823208439432522, + "mean_prediction": 0.013232275487842119, + "calibration_in_the_large": -0.0005909329515904026, + "expected_calibration_error_10bin": 0.0059327921194068265, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + "K55": { + "valid": 2815, + "positives": 10, + "negatives": 2805, + "auroc": 0.7479857397504456, + "auprc": 0.011345931619085647, + "brier": 0.0035783633909417406, + "calibration": { + "observed_rate": 0.003552397868561279, + "mean_prediction": 0.0032210247922374886, + "calibration_in_the_large": -0.00033137307632379043, + "expected_calibration_error_10bin": 0.0006814826554084, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "K56": { + "valid": 2745, + "positives": 30, + "negatives": 2715, + "auroc": 0.7510374462860651, + "auprc": 0.04902077661465708, + "brier": 0.010669892952898734, + "calibration": { + "observed_rate": 0.01092896174863388, + "mean_prediction": 0.01335294423385257, + "calibration_in_the_large": 0.0024239824852186898, + "expected_calibration_error_10bin": 0.0024239824852186898, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + "K57": { + "valid": 2741, + "positives": 25, + "negatives": 2716, + "auroc": 0.7024447717231223, + "auprc": 0.02400730783798135, + "brier": 0.009037522015303662, + "calibration": { + "observed_rate": 0.009120758847136081, + "mean_prediction": 0.005266601364932761, + "calibration_in_the_large": -0.0038541574822033202, + "expected_calibration_error_10bin": 0.0040496417059900985, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "K58": { + "valid": 2792, + "positives": 7, + "negatives": 2785, + "auroc": 0.7406514490895101, + "auprc": 0.011881162281440002, + "brier": 0.002509031929412164, + "calibration": { + "observed_rate": 0.002507163323782235, + "mean_prediction": 0.0024823973818042227, + "calibration_in_the_large": -2.4765941978012462e-05, + "expected_calibration_error_10bin": 2.4765941978012462e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "K59": { + "valid": 2560, + "positives": 87, + "negatives": 2473, + "auroc": 0.7623064731281751, + "auprc": 0.1337662809891269, + "brier": 0.03125222146557443, + "calibration": { + "observed_rate": 0.033984375, + "mean_prediction": 0.03051826218270435, + "calibration_in_the_large": -0.003466112817295648, + "expected_calibration_error_10bin": 0.004082936955273909, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "K62": { + "valid": 2813, + "positives": 16, + "negatives": 2797, + "auroc": 0.8550232391848409, + "auprc": 0.029623114535103877, + "brier": 0.0056096527546446034, + "calibration": { + "observed_rate": 0.005687877710629221, + "mean_prediction": 0.0035763345432921834, + "calibration_in_the_large": -0.002111543167337038, + "expected_calibration_error_10bin": 0.002111543167337038, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K63": { + "valid": 2810, + "positives": 19, + "negatives": 2791, + "auroc": 0.7380489920609478, + "auprc": 0.01610251472769446, + "brier": 0.006733821111831152, + "calibration": { + "observed_rate": 0.006761565836298933, + "mean_prediction": 0.004469106310276415, + "calibration_in_the_large": -0.0022924595260225174, + "expected_calibration_error_10bin": 0.0022924595260225174, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "K64": { + "valid": 2801, + "positives": 22, + "negatives": 2779, + "auroc": 0.8009748437960025, + "auprc": 0.03051278689765174, + "brier": 0.007869459190406148, + "calibration": { + "observed_rate": 0.00785433773652267, + "mean_prediction": 0.007129699773313629, + "calibration_in_the_large": -0.0007246379632090414, + "expected_calibration_error_10bin": 0.002706801522616389, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "K65": { + "valid": 2813, + "positives": 13, + "negatives": 2800, + "auroc": 0.8092582417582418, + "auprc": 0.03286898875060228, + "brier": 0.00479690865168526, + "calibration": { + "observed_rate": 0.004621400639886242, + "mean_prediction": 0.008375093591973146, + "calibration_in_the_large": 0.0037536929520869036, + "expected_calibration_error_10bin": 0.0037536929520869036, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K66": { + "valid": 2796, + "positives": 9, + "negatives": 2787, + "auroc": 0.7398237850336882, + "auprc": 0.01808024425855018, + "brier": 0.003237593133196821, + "calibration": { + "observed_rate": 0.003218884120171674, + "mean_prediction": 0.004824254995680618, + "calibration_in_the_large": 0.001605370875508944, + "expected_calibration_error_10bin": 0.001605370875508944, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "K70": { + "valid": 2774, + "positives": 5, + "negatives": 2769, + "auroc": 0.9037197544239798, + "auprc": 0.01506720925490112, + "brier": 0.0018143840579088733, + "calibration": { + "observed_rate": 0.001802451333813987, + "mean_prediction": 0.001119567234459115, + "calibration_in_the_large": -0.0006828840993548719, + "expected_calibration_error_10bin": 0.000842603785641306, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "K72": { + "valid": 2787, + "positives": 21, + "negatives": 2766, + "auroc": 0.92369934235444, + "auprc": 0.27018733583550647, + "brier": 0.006629028715656333, + "calibration": { + "observed_rate": 0.007534983853606028, + "mean_prediction": 0.004237215856132868, + "calibration_in_the_large": -0.0032977679974731606, + "expected_calibration_error_10bin": 0.004278026070995909, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "K74": { + "valid": 2763, + "positives": 7, + "negatives": 2756, + "auroc": 0.9586357039187228, + "auprc": 0.04818185917544136, + "brier": 0.002547021471463748, + "calibration": { + "observed_rate": 0.0025334781035106766, + "mean_prediction": 0.0035164067817719832, + "calibration_in_the_large": 0.0009829286782613066, + "expected_calibration_error_10bin": 0.0009829286782613062, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "K75": { + "valid": 2798, + "positives": 11, + "negatives": 2787, + "auroc": 0.8321753596242294, + "auprc": 0.02645898072987326, + "brier": 0.003919118790535475, + "calibration": { + "observed_rate": 0.003931379556826304, + "mean_prediction": 0.002841004779686716, + "calibration_in_the_large": -0.0010903747771395882, + "expected_calibration_error_10bin": 0.001553455926788919, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "K76": { + "valid": 2681, + "positives": 32, + "negatives": 2649, + "auroc": 0.8043011513778785, + "auprc": 0.1753504498622474, + "brier": 0.010894233366679319, + "calibration": { + "observed_rate": 0.011935844834017158, + "mean_prediction": 0.00614718606141887, + "calibration_in_the_large": -0.005788658772598289, + "expected_calibration_error_10bin": 0.00642833377496138, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + "K80": { + "valid": 2731, + "positives": 18, + "negatives": 2713, + "auroc": 0.6763115861899496, + "auprc": 0.014955723336619507, + "brier": 0.006554153228414496, + "calibration": { + "observed_rate": 0.006590992310508971, + "mean_prediction": 0.003372291821841248, + "calibration_in_the_large": -0.003218700488667723, + "expected_calibration_error_10bin": 0.003218700488667723, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + "K81": { + "valid": 2825, + "positives": 5, + "negatives": 2820, + "auroc": 0.8494326241134752, + "auprc": 0.033133616621618935, + "brier": 0.0017554310997371153, + "calibration": { + "observed_rate": 0.0017699115044247787, + "mean_prediction": 0.0016048830283591441, + "calibration_in_the_large": -0.00016502847606563462, + "expected_calibration_error_10bin": 0.00016502847606563462, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "K82": { + "valid": 2824, + "positives": 4, + "negatives": 2820, + "auroc": 0.5787234042553191, + "auprc": 0.003569489319500279, + "brier": 0.0014192858289220319, + "calibration": { + "observed_rate": 0.00141643059490085, + "mean_prediction": 0.0012496292167113274, + "calibration_in_the_large": -0.0001668013781895225, + "expected_calibration_error_10bin": 0.0001668013781895225, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K83": { + "valid": 2757, + "positives": 16, + "negatives": 2741, + "auroc": 0.9074927033929223, + "auprc": 0.10039269118501654, + "brier": 0.005718210331874127, + "calibration": { + "observed_rate": 0.005803409503083061, + "mean_prediction": 0.004723360474062704, + "calibration_in_the_large": -0.0010800490290203569, + "expected_calibration_error_10bin": 0.004130774975292819, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + "K85": { + "valid": 2779, + "positives": 10, + "negatives": 2769, + "auroc": 0.797797038642109, + "auprc": 0.02174299667259509, + "brier": 0.003562335299095503, + "calibration": { + "observed_rate": 0.0035984166966534724, + "mean_prediction": 0.0026423772148828693, + "calibration_in_the_large": -0.0009560394817706031, + "expected_calibration_error_10bin": 0.0009560394817706031, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + "K86": { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.7064177722925024, + "auprc": 0.014540010839195844, + "brier": 0.0025232370647852984, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.0038053298880770608, + "calibration_in_the_large": 0.0012918648970537214, + "expected_calibration_error_10bin": 0.0012918648970537217, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K90": { + "valid": 2831, + "positives": 3, + "negatives": 2828, + "auroc": 0.5894625176803394, + "auprc": 0.001792517160361164, + "brier": 0.001062872511704949, + "calibration": { + "observed_rate": 0.0010596962204168139, + "mean_prediction": 0.0009151146842633162, + "calibration_in_the_large": -0.00014458153615349765, + "expected_calibration_error_10bin": 0.00014458153615349765, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "K91": { + "valid": 2768, + "positives": 26, + "negatives": 2742, + "auroc": 0.8770689558435729, + "auprc": 0.07219914368577171, + "brier": 0.00900487432959727, + "calibration": { + "observed_rate": 0.00939306358381503, + "mean_prediction": 0.008045759465684794, + "calibration_in_the_large": -0.0013473041181302353, + "expected_calibration_error_10bin": 0.0018251657419321706, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "K92": { + "valid": 2751, + "positives": 36, + "negatives": 2715, + "auroc": 0.8277573153263761, + "auprc": 0.08419283163914028, + "brier": 0.012460554153589288, + "calibration": { + "observed_rate": 0.013086150490730643, + "mean_prediction": 0.011620085662662826, + "calibration_in_the_large": -0.001466064828067817, + "expected_calibration_error_10bin": 0.0016323063423215895, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "K94": { + "valid": 2823, + "positives": 14, + "negatives": 2809, + "auroc": 0.9015918222041398, + "auprc": 0.07667480190182988, + "brier": 0.004796474940434995, + "calibration": { + "observed_rate": 0.00495926319518243, + "mean_prediction": 0.005703005759569299, + "calibration_in_the_large": 0.0007437425643868683, + "expected_calibration_error_10bin": 0.0008850520653943055, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "L02": { + "valid": 2807, + "positives": 19, + "negatives": 2788, + "auroc": 0.762157366155705, + "auprc": 0.028470760568647845, + "brier": 0.006675804440505985, + "calibration": { + "observed_rate": 0.006768792304951906, + "mean_prediction": 0.007746406839639585, + "calibration_in_the_large": 0.0009776145346876795, + "expected_calibration_error_10bin": 0.0009776145346876795, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "L03": { + "valid": 2701, + "positives": 46, + "negatives": 2655, + "auroc": 0.7420944894784246, + "auprc": 0.06359309912222154, + "brier": 0.016466237621557977, + "calibration": { + "observed_rate": 0.017030729359496483, + "mean_prediction": 0.010597329816439367, + "calibration_in_the_large": -0.006433399543057116, + "expected_calibration_error_10bin": 0.007188714506179669, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + "L08": { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.6690265486725664, + "auprc": 0.00649115948554298, + "brier": 0.001770288014232642, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.0019213527875628269, + "calibration_in_the_large": 0.00015456833526600712, + "expected_calibration_error_10bin": 0.00015456833526600712, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + "L27": { + "valid": 2818, + "positives": 12, + "negatives": 2806, + "auroc": 0.8044369208838203, + "auprc": 0.02069856393371217, + "brier": 0.004556909732512666, + "calibration": { + "observed_rate": 0.0042583392476933995, + "mean_prediction": 0.005792442757846459, + "calibration_in_the_large": 0.0015341035101530598, + "expected_calibration_error_10bin": 0.0017388586666213326, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "L29": { + "valid": 2817, + "positives": 3, + "negatives": 2814, + "auroc": 0.5752191423833215, + "auprc": 0.0028378344894883674, + "brier": 0.0011661836348567348, + "calibration": { + "observed_rate": 0.0010649627263045794, + "mean_prediction": 0.004696355859575368, + "calibration_in_the_large": 0.003631393133270788, + "expected_calibration_error_10bin": 0.0036313931332707878, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "L30": { + "valid": 2816, + "positives": 8, + "negatives": 2808, + "auroc": 0.7431000712250713, + "auprc": 0.02536355446637353, + "brier": 0.002825220634313226, + "calibration": { + "observed_rate": 0.002840909090909091, + "mean_prediction": 0.0027597400214512454, + "calibration_in_the_large": -8.116906945784558e-05, + "expected_calibration_error_10bin": 0.00026150760529669055, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "L50": { + "valid": 2835, + "positives": 3, + "negatives": 2832, + "auroc": 0.7421139359698682, + "auprc": 0.010093240093240093, + "brier": 0.0010578727300112288, + "calibration": { + "observed_rate": 0.0010582010582010583, + "mean_prediction": 0.0012633533611274826, + "calibration_in_the_large": 0.0002051523029264243, + "expected_calibration_error_10bin": 0.0002051523029264243, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + "L53": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 9.707916955677141e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0015371182772385918, + "calibration_in_the_large": 0.0015371182772385918, + "expected_calibration_error_10bin": 0.0015371182772385918, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "L76": { + "valid": 2793, + "positives": 13, + "negatives": 2780, + "auroc": 0.6747648035417819, + "auprc": 0.009186484123127512, + "brier": 0.004678417751666033, + "calibration": { + "observed_rate": 0.004654493376297888, + "mean_prediction": 0.005982711292299613, + "calibration_in_the_large": 0.0013282179160017255, + "expected_calibration_error_10bin": 0.0013282179160017255, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "L89": { + "valid": 2798, + "positives": 24, + "negatives": 2774, + "auroc": 0.8593637346791637, + "auprc": 0.043215198042499396, + "brier": 0.008472819276359718, + "calibration": { + "observed_rate": 0.008577555396711936, + "mean_prediction": 0.00634298103462524, + "calibration_in_the_large": -0.002234574362086696, + "expected_calibration_error_10bin": 0.0033813901645173595, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "L97": { + "valid": 2789, + "positives": 12, + "negatives": 2777, + "auroc": 0.89368023046453, + "auprc": 0.07879262217959712, + "brier": 0.004270692162075132, + "calibration": { + "observed_rate": 0.004302617425600574, + "mean_prediction": 0.006250544642754728, + "calibration_in_the_large": 0.0019479272171541544, + "expected_calibration_error_10bin": 0.00217182628430762, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "L98": { + "valid": 2824, + "positives": 8, + "negatives": 2816, + "auroc": 0.6753817471590909, + "auprc": 0.006203837145639945, + "brier": 0.002873213009720409, + "calibration": { + "observed_rate": 0.0028328611898017, + "mean_prediction": 0.004431927516814813, + "calibration_in_the_large": 0.0015990663270131129, + "expected_calibration_error_10bin": 0.0015990663270131129, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "M10": { + "valid": 2713, + "positives": 14, + "negatives": 2699, + "auroc": 0.8038691578891654, + "auprc": 0.046743936371545766, + "brier": 0.005093925918159296, + "calibration": { + "observed_rate": 0.005160339107998526, + "mean_prediction": 0.00639135795326164, + "calibration_in_the_large": 0.0012310188452631142, + "expected_calibration_error_10bin": 0.0012310188452631147, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + "M16": { + "valid": 2790, + "positives": 3, + "negatives": 2787, + "auroc": 0.9150819279990432, + "auprc": 0.01332073661888005, + "brier": 0.001071991490252198, + "calibration": { + "observed_rate": 0.001075268817204301, + "mean_prediction": 0.0016431137086028913, + "calibration_in_the_large": 0.0005678448913985902, + "expected_calibration_error_10bin": 0.0005678448913985902, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "M17": { + "valid": 2733, + "positives": 13, + "negatives": 2720, + "auroc": 0.7688914027149322, + "auprc": 0.011866475127953595, + "brier": 0.004769806075196383, + "calibration": { + "observed_rate": 0.004756677643615075, + "mean_prediction": 0.0032583627562809635, + "calibration_in_the_large": -0.0014983148873341117, + "expected_calibration_error_10bin": 0.0016578744386156964, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "M19": { + "valid": 2674, + "positives": 35, + "negatives": 2639, + "auroc": 0.7134195853407677, + "auprc": 0.03299508268016678, + "brier": 0.012894025175825972, + "calibration": { + "observed_rate": 0.013089005235602094, + "mean_prediction": 0.012930989028279417, + "calibration_in_the_large": -0.0001580162073226768, + "expected_calibration_error_10bin": 0.0009494500019263322, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + "M21": { + "valid": 2821, + "positives": 3, + "negatives": 2818, + "auroc": 0.8812396498698841, + "auprc": 0.008273351404447453, + "brier": 0.0010654697760273297, + "calibration": { + "observed_rate": 0.0010634526763559022, + "mean_prediction": 0.0018759289569831906, + "calibration_in_the_large": 0.0008124762806272885, + "expected_calibration_error_10bin": 0.0008124762806272885, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "M25": { + "valid": 2717, + "positives": 41, + "negatives": 2676, + "auroc": 0.61794997994823, + "auprc": 0.021920421155241024, + "brier": 0.014998530314670699, + "calibration": { + "observed_rate": 0.015090172984909826, + "mean_prediction": 0.014610457816418298, + "calibration_in_the_large": -0.00047971516849152837, + "expected_calibration_error_10bin": 0.002278840901523098, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + "M35": { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.8862339514978602, + "auprc": 0.0045753559155621015, + "brier": 0.0007183620920436621, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0011004160109653238, + "calibration_in_the_large": 0.00038765763605441857, + "expected_calibration_error_10bin": 0.00038765763605441857, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "M46": { + "valid": 2814, + "positives": 7, + "negatives": 2807, + "auroc": 0.570308921573617, + "auprc": 0.0038671187624885616, + "brier": 0.00248974321155119, + "calibration": { + "observed_rate": 0.0024875621890547263, + "mean_prediction": 0.002325725391967887, + "calibration_in_the_large": -0.0001618367970868395, + "expected_calibration_error_10bin": 0.0001618367970868395, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "M47": { + "valid": 2743, + "positives": 11, + "negatives": 2732, + "auroc": 0.6956275788633036, + "auprc": 0.017347187390062982, + "brier": 0.003981837690557673, + "calibration": { + "observed_rate": 0.004010207801676996, + "mean_prediction": 0.002946532716589847, + "calibration_in_the_large": -0.0010636750850871487, + "expected_calibration_error_10bin": 0.0010636750850871487, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "M48": { + "valid": 2690, + "positives": 10, + "negatives": 2680, + "auroc": 0.765223880597015, + "auprc": 0.014482050337633477, + "brier": 0.003742688942962526, + "calibration": { + "observed_rate": 0.0037174721189591076, + "mean_prediction": 0.006619722700708539, + "calibration_in_the_large": 0.002902250581749431, + "expected_calibration_error_10bin": 0.002902250581749431, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + "M51": { + "valid": 2785, + "positives": 5, + "negatives": 2780, + "auroc": 0.837841726618705, + "auprc": 0.014933734670506627, + "brier": 0.0017876217744670598, + "calibration": { + "observed_rate": 0.0017953321364452424, + "mean_prediction": 0.003225418173633198, + "calibration_in_the_large": 0.0014300860371879555, + "expected_calibration_error_10bin": 0.0014300860371879555, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "M54": { + "valid": 2567, + "positives": 46, + "negatives": 2521, + "auroc": 0.7084231585119777, + "auprc": 0.05301815130944, + "brier": 0.017404951567809374, + "calibration": { + "observed_rate": 0.017919750681729647, + "mean_prediction": 0.017463740953614332, + "calibration_in_the_large": -0.00045600972811531484, + "expected_calibration_error_10bin": 0.0022233438518541935, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + "M62": { + "valid": 2781, + "positives": 11, + "negatives": 2770, + "auroc": 0.7115851657367903, + "auprc": 0.013171252780094287, + "brier": 0.0039313297071257676, + "calibration": { + "observed_rate": 0.003955411722402014, + "mean_prediction": 0.00391825708198632, + "calibration_in_the_large": -3.7154640415693746e-05, + "expected_calibration_error_10bin": 3.7154640415693746e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "M79": { + "valid": 2697, + "positives": 42, + "negatives": 2655, + "auroc": 0.7397901533494754, + "auprc": 0.04732592220203856, + "brier": 0.015288983494128872, + "calibration": { + "observed_rate": 0.01557285873192436, + "mean_prediction": 0.016465362494759272, + "calibration_in_the_large": 0.0008925037628349126, + "expected_calibration_error_10bin": 0.0026654323235704583, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + "M81": { + "valid": 2705, + "positives": 16, + "negatives": 2689, + "auroc": 0.7487448865749349, + "auprc": 0.04033985241865585, + "brier": 0.005856503343755883, + "calibration": { + "observed_rate": 0.005914972273567467, + "mean_prediction": 0.005891037132870239, + "calibration_in_the_large": -2.3935140697228276e-05, + "expected_calibration_error_10bin": 0.001242045667473146, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + "M84": { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.7705666192508298, + "auprc": 0.023081835781954177, + "brier": 0.0021511937316090668, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0032537704478792263, + "calibration_in_the_large": 0.0011246008240325266, + "expected_calibration_error_10bin": 0.0011246008240325266, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "M85": { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.7189424121695038, + "auprc": 0.006436268711544386, + "brier": 0.0025469645950195216, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.0037370747822039756, + "calibration_in_the_large": 0.0012081730480999293, + "expected_calibration_error_10bin": 0.0012081730480999293, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "M86": { + "valid": 2803, + "positives": 15, + "negatives": 2788, + "auroc": 0.7901243424198948, + "auprc": 0.048951365016810085, + "brier": 0.005272935101562325, + "calibration": { + "observed_rate": 0.005351409204423832, + "mean_prediction": 0.004493434616467321, + "calibration_in_the_large": -0.0008579745879565108, + "expected_calibration_error_10bin": 0.002075990607769852, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + "M94": { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7503551136363636, + "auprc": 0.0030316756542565805, + "brier": 0.0010639806029513828, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.00046316613417979037, + "calibration_in_the_large": -0.0006010410314817916, + "expected_calibration_error_10bin": 0.0006010410314817916, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "M96": { + "valid": 2804, + "positives": 4, + "negatives": 2800, + "auroc": 0.8804464285714285, + "auprc": 0.007499132903471997, + "brier": 0.0014353790192326442, + "calibration": { + "observed_rate": 0.0014265335235378032, + "mean_prediction": 0.0033345897682737686, + "calibration_in_the_large": 0.0019080562447359654, + "expected_calibration_error_10bin": 0.0019080562447359654, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "N12": { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.6681505463375151, + "auprc": 0.0063929829060205634, + "brier": 0.0024806459566818324, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.002186805134867081, + "calibration_in_the_large": -0.00028581937943881813, + "expected_calibration_error_10bin": 0.00028581937943881813, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N13": { + "valid": 2756, + "positives": 21, + "negatives": 2735, + "auroc": 0.7317489335770871, + "auprc": 0.04872947904577459, + "brier": 0.007456263785655346, + "calibration": { + "observed_rate": 0.007619738751814224, + "mean_prediction": 0.00579307761616474, + "calibration_in_the_large": -0.001826661135649484, + "expected_calibration_error_10bin": 0.0020021378100238555, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "N14": { + "valid": 2826, + "positives": 8, + "negatives": 2818, + "auroc": 0.876375088715401, + "auprc": 0.021762694579304655, + "brier": 0.0028127935001751848, + "calibration": { + "observed_rate": 0.0028308563340410475, + "mean_prediction": 0.0018526072933133372, + "calibration_in_the_large": -0.0009782490407277103, + "expected_calibration_error_10bin": 0.0009782490407277103, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "N17": { + "valid": 2292, + "positives": 101, + "negatives": 2191, + "auroc": 0.798794347714096, + "auprc": 0.18607575161509365, + "brier": 0.03933189460886828, + "calibration": { + "observed_rate": 0.04406631762652705, + "mean_prediction": 0.04515384230567171, + "calibration_in_the_large": 0.0010875246791446566, + "expected_calibration_error_10bin": 0.006902422119151638, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + "N18": { + "valid": 2440, + "positives": 49, + "negatives": 2391, + "auroc": 0.8655673059688116, + "auprc": 0.24037813256383858, + "brier": 0.01800728225538921, + "calibration": { + "observed_rate": 0.020081967213114754, + "mean_prediction": 0.012804598190304517, + "calibration_in_the_large": -0.007277369022810237, + "expected_calibration_error_10bin": 0.007277369022810236, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + "N20": { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7361954967834168, + "auprc": 0.00636279543426349, + "brier": 0.002846814287176071, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.0015243526065444719, + "calibration_in_the_large": -0.0013266808930991491, + "expected_calibration_error_10bin": 0.0013266808930991491, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "N25": { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.9573047349251316, + "auprc": 0.0868137176314362, + "brier": 0.0024140153352838613, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.0014449382393766951, + "calibration_in_the_large": -0.001027686274929204, + "expected_calibration_error_10bin": 0.0012072568682190848, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N28": { + "valid": 2789, + "positives": 9, + "negatives": 2780, + "auroc": 0.8295363709032774, + "auprc": 0.01740162625113607, + "brier": 0.0032106293133804327, + "calibration": { + "observed_rate": 0.0032269630692004303, + "mean_prediction": 0.004917675385173127, + "calibration_in_the_large": 0.0016907123159726964, + "expected_calibration_error_10bin": 0.0016907123159726964, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "N30": { + "valid": 2829, + "positives": 11, + "negatives": 2818, + "auroc": 0.7222401445254533, + "auprc": 0.013007656855991817, + "brier": 0.0039428087448402606, + "calibration": { + "observed_rate": 0.003888299752562743, + "mean_prediction": 0.004670265385956454, + "calibration_in_the_large": 0.0007819656333937111, + "expected_calibration_error_10bin": 0.0007819656333937114, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N32": { + "valid": 2807, + "positives": 13, + "negatives": 2794, + "auroc": 0.7846208909201036, + "auprc": 0.16822865038398463, + "brier": 0.004453871293523828, + "calibration": { + "observed_rate": 0.004631278945493409, + "mean_prediction": 0.0046910091357846954, + "calibration_in_the_large": 5.973019029128623e-05, + "expected_calibration_error_10bin": 0.0006854977021235204, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "N39": { + "valid": 2520, + "positives": 82, + "negatives": 2438, + "auroc": 0.7548720462594289, + "auprc": 0.08783704630290247, + "brier": 0.030952424669865454, + "calibration": { + "observed_rate": 0.03253968253968254, + "mean_prediction": 0.03806831875228368, + "calibration_in_the_large": 0.005528636212601135, + "expected_calibration_error_10bin": 0.00572331385217637, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + "N40": { + "valid": 2606, + "positives": 24, + "negatives": 2582, + "auroc": 0.8294280919184095, + "auprc": 0.058749479751883965, + "brier": 0.008980146913358694, + "calibration": { + "observed_rate": 0.00920951650038373, + "mean_prediction": 0.011192354221975096, + "calibration_in_the_large": 0.001982837721591366, + "expected_calibration_error_10bin": 0.0019828377215913673, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + "N73": { + "valid": 2829, + "positives": 6, + "negatives": 2823, + "auroc": 0.9017593576573385, + "auprc": 0.07737727709042654, + "brier": 0.0020723720931541917, + "calibration": { + "observed_rate": 0.0021208907741251328, + "mean_prediction": 0.0012035334445982635, + "calibration_in_the_large": -0.0009173573295268693, + "expected_calibration_error_10bin": 0.0009173573295268693, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N99": { + "valid": 2799, + "positives": 6, + "negatives": 2793, + "auroc": 0.7626805108008116, + "auprc": 0.009314033697433622, + "brier": 0.0021406740050317623, + "calibration": { + "observed_rate": 0.0021436227224008574, + "mean_prediction": 0.002249867950991846, + "calibration_in_the_large": 0.00010624522859098862, + "expected_calibration_error_10bin": 0.00010624522859098862, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + "O69": { + "valid": 2743, + "positives": 6, + "negatives": 2737, + "auroc": 0.9962854707100232, + "auprc": 0.34296259296259296, + "brier": 0.0020383184334528486, + "calibration": { + "observed_rate": 0.002187386073641998, + "mean_prediction": 0.0004770692509474173, + "calibration_in_the_large": -0.0017103168226945806, + "expected_calibration_error_10bin": 0.0019132536563721053, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "O99": { + "valid": 2652, + "positives": 3, + "negatives": 2649, + "auroc": 0.8600729835157921, + "auprc": 0.18347078123614438, + "brier": 0.000981288629002661, + "calibration": { + "observed_rate": 0.0011312217194570137, + "mean_prediction": 0.0005344280612631587, + "calibration_in_the_large": -0.000596793658193855, + "expected_calibration_error_10bin": 0.0005967936581938549, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + "Q21": { + "valid": 2810, + "positives": 4, + "negatives": 2806, + "auroc": 0.6756949394155382, + "auprc": 0.0062850526825415035, + "brier": 0.0014200436278738128, + "calibration": { + "observed_rate": 0.0014234875444839859, + "mean_prediction": 0.0013235679572428248, + "calibration_in_the_large": -9.991958724116104e-05, + "expected_calibration_error_10bin": 9.991958724116104e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "U07": { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.9502830856334041, + "auprc": 0.014273504273504274, + "brier": 0.0007422680336904923, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.003686443329326047, + "calibration_in_the_large": 0.0029792297508253397, + "expected_calibration_error_10bin": 0.0029792297508253397, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + } + }, + "360": { + "A04": { + "valid": 2782, + "positives": 29, + "negatives": 2753, + "auroc": 0.7681776619862971, + "auprc": 0.057012585837588704, + "brier": 0.010180403322864979, + "calibration": { + "observed_rate": 0.010424155283968369, + "mean_prediction": 0.010558504197711533, + "calibration_in_the_large": 0.00013434891374316388, + "expected_calibration_error_10bin": 0.0009641898639667862, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "A08": { + "valid": 2818, + "positives": 11, + "negatives": 2807, + "auroc": 0.8111863199144995, + "auprc": 0.027627451023927083, + "brier": 0.003866098100729552, + "calibration": { + "observed_rate": 0.0039034776437189495, + "mean_prediction": 0.005268241101759093, + "calibration_in_the_large": 0.0013647634580401437, + "expected_calibration_error_10bin": 0.0013647634580401442, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "A41": { + "valid": 2664, + "positives": 76, + "negatives": 2588, + "auroc": 0.7436752623444236, + "auprc": 0.07654443661949686, + "brier": 0.027676756686905002, + "calibration": { + "observed_rate": 0.028528528528528527, + "mean_prediction": 0.03036026948889544, + "calibration_in_the_large": 0.0018317409603669128, + "expected_calibration_error_10bin": 0.00877800468333043, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + "B00": { + "valid": 2819, + "positives": 4, + "negatives": 2815, + "auroc": 0.669538188277087, + "auprc": 0.015048137938595706, + "brier": 0.0014756039438281216, + "calibration": { + "observed_rate": 0.001418942887548776, + "mean_prediction": 0.002216306739263463, + "calibration_in_the_large": 0.0007973638517146868, + "expected_calibration_error_10bin": 0.0007973638517146866, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "B02": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7789175804740007, + "auprc": 0.001597444089456869, + "brier": 0.00035858655392324385, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0011109679962545511, + "calibration_in_the_large": 0.0007573612070041974, + "expected_calibration_error_10bin": 0.0007573612070041974, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "B18": { + "valid": 2782, + "positives": 8, + "negatives": 2774, + "auroc": 0.9479542177361211, + "auprc": 0.10876294214155076, + "brier": 0.0027531111171952365, + "calibration": { + "observed_rate": 0.002875629043853343, + "mean_prediction": 0.001581338558431927, + "calibration_in_the_large": -0.001294290485421416, + "expected_calibration_error_10bin": 0.0012942904854214155, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "B19": { + "valid": 2763, + "positives": 17, + "negatives": 2746, + "auroc": 0.8551690158947775, + "auprc": 0.07536584665133617, + "brier": 0.005996837659045276, + "calibration": { + "observed_rate": 0.006152732537097358, + "mean_prediction": 0.0022290050484125253, + "calibration_in_the_large": -0.003923727488684832, + "expected_calibration_error_10bin": 0.003923727488684832, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "B20": { + "valid": 2829, + "positives": 5, + "negatives": 2824, + "auroc": 0.9875354107648725, + "auprc": 0.24159720568389295, + "brier": 0.001731770519175251, + "calibration": { + "observed_rate": 0.0017674089784376105, + "mean_prediction": 0.0003403443559914662, + "calibration_in_the_large": -0.0014270646224461443, + "expected_calibration_error_10bin": 0.0015207592578427732, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "B34": { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.9791224345364473, + "auprc": 0.11487813207603212, + "brier": 0.001700840923709183, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0018099942817259365, + "calibration_in_the_large": 4.383391436458021e-05, + "expected_calibration_error_10bin": 0.00013319357022367908, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "B35": { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.8607974594213126, + "auprc": 0.00472443291901398, + "brier": 0.0007173536605728163, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.002056878399109237, + "calibration_in_the_large": 0.0013516597813377277, + "expected_calibration_error_10bin": 0.0013516597813377277, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "B37": { + "valid": 2768, + "positives": 38, + "negatives": 2730, + "auroc": 0.7660401002506265, + "auprc": 0.04380228581229119, + "brier": 0.013478462113006438, + "calibration": { + "observed_rate": 0.013728323699421965, + "mean_prediction": 0.011078363918255028, + "calibration_in_the_large": -0.002649959781166937, + "expected_calibration_error_10bin": 0.0051582651119653974, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "B95": { + "valid": 2678, + "positives": 61, + "negatives": 2617, + "auroc": 0.7055193971322438, + "auprc": 0.04760180903211338, + "brier": 0.022456506170720886, + "calibration": { + "observed_rate": 0.022778192681105303, + "mean_prediction": 0.02539477717815436, + "calibration_in_the_large": 0.0026165844970490564, + "expected_calibration_error_10bin": 0.0037081541287134765, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + "B96": { + "valid": 2630, + "positives": 87, + "negatives": 2543, + "auroc": 0.7626705719102698, + "auprc": 0.10601427312785583, + "brier": 0.031065241482676545, + "calibration": { + "observed_rate": 0.03307984790874525, + "mean_prediction": 0.03549711726134034, + "calibration_in_the_large": 0.0024172693525950917, + "expected_calibration_error_10bin": 0.004240118796510458, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + "B97": { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.8883581033262562, + "auprc": 0.08492569002123142, + "brier": 0.0007140484048560611, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0013015516304818715, + "calibration_in_the_large": 0.0005943380519811643, + "expected_calibration_error_10bin": 0.0005943380519811643, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "C18": { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9764351523742026, + "auprc": 0.03250517598343685, + "brier": 0.0007026352527715723, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0007859895555258753, + "calibration_in_the_large": 7.77742580754503e-05, + "expected_calibration_error_10bin": 7.77742580754503e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "C22": { + "valid": 2812, + "positives": 7, + "negatives": 2805, + "auroc": 0.8918258212375859, + "auprc": 0.04575571821224432, + "brier": 0.0024500402961177676, + "calibration": { + "observed_rate": 0.0024893314366998577, + "mean_prediction": 0.0009127940972244547, + "calibration_in_the_large": -0.001576537339475403, + "expected_calibration_error_10bin": 0.001576537339475403, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + "C25": { + "valid": 2809, + "positives": 4, + "negatives": 2805, + "auroc": 0.941711229946524, + "auprc": 0.09630737278237556, + "brier": 0.0013896790502422008, + "calibration": { + "observed_rate": 0.001423994304022784, + "mean_prediction": 0.0006517281181991889, + "calibration_in_the_large": -0.0007722661858235951, + "expected_calibration_error_10bin": 0.0009621898084580915, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "C61": { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9700321084552266, + "auprc": 0.01923765211166786, + "brier": 0.0007127307679793439, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.0012971166741230192, + "calibration_in_the_large": 0.0005841041964046591, + "expected_calibration_error_10bin": 0.0005841041964046591, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "C67": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9548991864166961, + "auprc": 0.02802893309222423, + "brier": 0.0007041600505798942, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.000969298598436686, + "calibration_in_the_large": 0.0002623350070616418, + "expected_calibration_error_10bin": 0.0002623350070616418, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "C77": { + "valid": 2762, + "positives": 23, + "negatives": 2739, + "auroc": 0.8639141546422846, + "auprc": 0.12978120518211964, + "brier": 0.007868236126692664, + "calibration": { + "observed_rate": 0.00832729905865315, + "mean_prediction": 0.004653457129693804, + "calibration_in_the_large": -0.003673841928959346, + "expected_calibration_error_10bin": 0.004636287709777658, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C78": { + "valid": 2762, + "positives": 37, + "negatives": 2725, + "auroc": 0.8729580957103893, + "auprc": 0.16969526346581906, + "brier": 0.01224083826778906, + "calibration": { + "observed_rate": 0.013396089790007242, + "mean_prediction": 0.007497510477367754, + "calibration_in_the_large": -0.005898579312639488, + "expected_calibration_error_10bin": 0.0077733356045258176, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C79": { + "valid": 2751, + "positives": 29, + "negatives": 2722, + "auroc": 0.8922445463528339, + "auprc": 0.19499435827666262, + "brier": 0.010249528923911354, + "calibration": { + "observed_rate": 0.010541621228644129, + "mean_prediction": 0.010232432039499605, + "calibration_in_the_large": -0.00030918918914452434, + "expected_calibration_error_10bin": 0.0049989711262115755, + "nonempty_bins": 9 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "C83": { + "valid": 2820, + "positives": 2, + "negatives": 2818, + "auroc": 0.40454222853087296, + "auprc": 0.001163480376703772, + "brier": 0.0007320777528648113, + "calibration": { + "observed_rate": 0.0007092198581560284, + "mean_prediction": 0.0005839042221763753, + "calibration_in_the_large": -0.00012531563597965314, + "expected_calibration_error_10bin": 0.00031342458176026515, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "D25": { + "valid": 2792, + "positives": 3, + "negatives": 2789, + "auroc": 0.9593641687582168, + "auprc": 0.6695821185617103, + "brier": 0.0010508058013933153, + "calibration": { + "observed_rate": 0.0010744985673352436, + "mean_prediction": 0.0005604246216287533, + "calibration_in_the_large": -0.0005140739457064903, + "expected_calibration_error_10bin": 0.0005140739457064903, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "D47": { + "valid": 2796, + "positives": 11, + "negatives": 2785, + "auroc": 0.6346335890321527, + "auprc": 0.006646396105832743, + "brier": 0.004060132874808369, + "calibration": { + "observed_rate": 0.003934191702432046, + "mean_prediction": 0.005829872404534446, + "calibration_in_the_large": 0.0018956807021024, + "expected_calibration_error_10bin": 0.0018956807021024002, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "D50": { + "valid": 2663, + "positives": 59, + "negatives": 2604, + "auroc": 0.7823817334478899, + "auprc": 0.11220954986464683, + "brier": 0.020675982136810826, + "calibration": { + "observed_rate": 0.022155463762673678, + "mean_prediction": 0.017638277970766333, + "calibration_in_the_large": -0.004517185791907345, + "expected_calibration_error_10bin": 0.004517185791907342, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + "D53": { + "valid": 2805, + "positives": 18, + "negatives": 2787, + "auroc": 0.8045887652992066, + "auprc": 0.024538348520957837, + "brier": 0.0065723264562435775, + "calibration": { + "observed_rate": 0.006417112299465241, + "mean_prediction": 0.0072800606854535755, + "calibration_in_the_large": 0.0008629483859883347, + "expected_calibration_error_10bin": 0.0019623356341601614, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "D59": { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9827099505998589, + "auprc": 0.029437229437229435, + "brier": 0.0007000666594942501, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0008971488933127362, + "calibration_in_the_large": 0.00019193027554122708, + "expected_calibration_error_10bin": 0.00019193027554122708, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "D61": { + "valid": 2773, + "positives": 37, + "negatives": 2736, + "auroc": 0.8920993361782835, + "auprc": 0.25834005783254066, + "brier": 0.011271853677462758, + "calibration": { + "observed_rate": 0.013342949873782907, + "mean_prediction": 0.011695702326964043, + "calibration_in_the_large": -0.0016472475468188637, + "expected_calibration_error_10bin": 0.0030130527198852534, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "D62": { + "valid": 2499, + "positives": 73, + "negatives": 2426, + "auroc": 0.7817423121661453, + "auprc": 0.08164296763311665, + "brier": 0.02772323667268977, + "calibration": { + "observed_rate": 0.02921168467386955, + "mean_prediction": 0.02649538461332295, + "calibration_in_the_large": -0.0027163000605466003, + "expected_calibration_error_10bin": 0.004636458635489335, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + "D63": { + "valid": 2686, + "positives": 76, + "negatives": 2610, + "auroc": 0.8592458156886469, + "auprc": 0.13934470848643454, + "brier": 0.026445081522602335, + "calibration": { + "observed_rate": 0.028294862248696945, + "mean_prediction": 0.02635434233446204, + "calibration_in_the_large": -0.0019405199142349047, + "expected_calibration_error_10bin": 0.009349703870412748, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + "D64": { + "valid": 2434, + "positives": 121, + "negatives": 2313, + "auroc": 0.8086489229043173, + "auprc": 0.1966529054729099, + "brier": 0.043600683754049484, + "calibration": { + "observed_rate": 0.04971240755957272, + "mean_prediction": 0.051377558496060585, + "calibration_in_the_large": 0.0016651509364878636, + "expected_calibration_error_10bin": 0.007415950560028572, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + "D65": { + "valid": 2833, + "positives": 6, + "negatives": 2827, + "auroc": 0.871536375427426, + "auprc": 0.01660392712596543, + "brier": 0.0021162046322423032, + "calibration": { + "observed_rate": 0.002117896223085069, + "mean_prediction": 0.0011131163993914762, + "calibration_in_the_large": -0.0010047798236935926, + "expected_calibration_error_10bin": 0.0010047798236935926, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + "D68": { + "valid": 2682, + "positives": 63, + "negatives": 2619, + "auroc": 0.8188148875434099, + "auprc": 0.15243577957759719, + "brier": 0.021596428583141102, + "calibration": { + "observed_rate": 0.02348993288590604, + "mean_prediction": 0.014182759188145114, + "calibration_in_the_large": -0.009307173697760927, + "expected_calibration_error_10bin": 0.009699194935453594, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + "D69": { + "valid": 2586, + "positives": 86, + "negatives": 2500, + "auroc": 0.8297116279069767, + "auprc": 0.2463260942491276, + "brier": 0.028395751120489466, + "calibration": { + "observed_rate": 0.033255993812838364, + "mean_prediction": 0.024109908985595268, + "calibration_in_the_large": -0.009146084827243096, + "expected_calibration_error_10bin": 0.00964309086270266, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + "D70": { + "valid": 2787, + "positives": 26, + "negatives": 2761, + "auroc": 0.9035605828434514, + "auprc": 0.24129962189362886, + "brier": 0.008992500978608804, + "calibration": { + "observed_rate": 0.009329027628274129, + "mean_prediction": 0.009426659136453101, + "calibration_in_the_large": 9.763150817897193e-05, + "expected_calibration_error_10bin": 0.005557025981979522, + "nonempty_bins": 9 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "D72": { + "valid": 2595, + "positives": 67, + "negatives": 2528, + "auroc": 0.7112873134328358, + "auprc": 0.06420355574154434, + "brier": 0.024825981279309746, + "calibration": { + "observed_rate": 0.02581888246628131, + "mean_prediction": 0.026355730289205737, + "calibration_in_the_large": 0.0005368478229244265, + "expected_calibration_error_10bin": 0.001485794028339042, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + "D73": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.8228760486825003, + "auprc": 0.02055978847023623, + "brier": 0.0011046020614906965, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0018425339911559075, + "calibration_in_the_large": 0.00078021104498027, + "expected_calibration_error_10bin": 0.00078021104498027, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "D75": { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.8710647329324372, + "auprc": 0.006612102215716447, + "brier": 0.0014188777150490833, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0017407153333958449, + "calibration_in_the_large": 0.0003277870395067598, + "expected_calibration_error_10bin": 0.0003277870395067598, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "D80": { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.9879688605803255, + "auprc": 0.0950650653607643, + "brier": 0.0021239777188262953, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.002261054202265789, + "calibration_in_the_large": 0.00014241013446917878, + "expected_calibration_error_10bin": 0.0006402783611233668, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "D89": { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.8458553791887126, + "auprc": 0.007504705144291092, + "brier": 0.0009756931480413126, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0013232676661466918, + "calibration_in_the_large": 0.0006182976273733397, + "expected_calibration_error_10bin": 0.0008932740631561298, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "E03": { + "valid": 2480, + "positives": 26, + "negatives": 2454, + "auroc": 0.6864459908469689, + "auprc": 0.02327924991316751, + "brier": 0.010345423082331044, + "calibration": { + "observed_rate": 0.010483870967741936, + "mean_prediction": 0.006849041787814537, + "calibration_in_the_large": -0.0036348291799273994, + "expected_calibration_error_10bin": 0.0036348291799273994, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + "E04": { + "valid": 2775, + "positives": 11, + "negatives": 2764, + "auroc": 0.682114195500592, + "auprc": 0.009217268470031953, + "brier": 0.003968393553469026, + "calibration": { + "observed_rate": 0.003963963963963964, + "mean_prediction": 0.003950835459887654, + "calibration_in_the_large": -1.3128504076310478e-05, + "expected_calibration_error_10bin": 1.3128504076310478e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "E05": { + "valid": 2806, + "positives": 4, + "negatives": 2802, + "auroc": 0.47002141327623126, + "auprc": 0.02896262624831695, + "brier": 0.0014209965426962249, + "calibration": { + "observed_rate": 0.0014255167498218105, + "mean_prediction": 0.0014683815978796422, + "calibration_in_the_large": 4.286484805783174e-05, + "expected_calibration_error_10bin": 4.286484805783174e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "E11": { + "valid": 2194, + "positives": 24, + "negatives": 2170, + "auroc": 0.7639976958525345, + "auprc": 0.13466087591959905, + "brier": 0.010507747250060286, + "calibration": { + "observed_rate": 0.010938924339106655, + "mean_prediction": 0.009468789459847934, + "calibration_in_the_large": -0.001470134879258721, + "expected_calibration_error_10bin": 0.0014701348792587206, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + "E16": { + "valid": 2816, + "positives": 13, + "negatives": 2803, + "auroc": 0.6661543950163287, + "auprc": 0.013922534165817112, + "brier": 0.004592355923152228, + "calibration": { + "observed_rate": 0.004616477272727273, + "mean_prediction": 0.0033011956502946305, + "calibration_in_the_large": -0.0013152816224326425, + "expected_calibration_error_10bin": 0.0013152816224326425, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "E21": { + "valid": 2814, + "positives": 5, + "negatives": 2809, + "auroc": 0.7449626201495194, + "auprc": 0.014494245408754181, + "brier": 0.0017920417936068472, + "calibration": { + "observed_rate": 0.0017768301350390902, + "mean_prediction": 0.002126032032808662, + "calibration_in_the_large": 0.00034920189776957173, + "expected_calibration_error_10bin": 0.00034920189776957195, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "E22": { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.8233281616740263, + "auprc": 0.017742846101709196, + "brier": 0.003302278182343536, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.006606462744858721, + "calibration_in_the_large": 0.0033944713101692137, + "expected_calibration_error_10bin": 0.0033944713101692137, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "E27": { + "valid": 2811, + "positives": 9, + "negatives": 2802, + "auroc": 0.8202474423031169, + "auprc": 0.010640046579857973, + "brier": 0.0032279341607800304, + "calibration": { + "observed_rate": 0.0032017075773745998, + "mean_prediction": 0.0031317852687964103, + "calibration_in_the_large": -6.992230857818952e-05, + "expected_calibration_error_10bin": 0.00014476836567954768, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + }, + "E43": { + "valid": 2748, + "positives": 42, + "negatives": 2706, + "auroc": 0.8236810614859396, + "auprc": 0.08161940301509565, + "brier": 0.014797541269436925, + "calibration": { + "observed_rate": 0.015283842794759825, + "mean_prediction": 0.01670967592160091, + "calibration_in_the_large": 0.0014258331268410859, + "expected_calibration_error_10bin": 0.002963449129480356, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + "E44": { + "valid": 2800, + "positives": 24, + "negatives": 2776, + "auroc": 0.7552083333333334, + "auprc": 0.02457687184534345, + "brier": 0.008664295768724847, + "calibration": { + "observed_rate": 0.008571428571428572, + "mean_prediction": 0.010528540708260802, + "calibration_in_the_large": 0.00195711213683223, + "expected_calibration_error_10bin": 0.00195711213683223, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "E46": { + "valid": 2772, + "positives": 42, + "negatives": 2730, + "auroc": 0.7902494331065759, + "auprc": 0.07428960157322129, + "brier": 0.014743096807981313, + "calibration": { + "observed_rate": 0.015151515151515152, + "mean_prediction": 0.016010467536903224, + "calibration_in_the_large": 0.0008589523853880718, + "expected_calibration_error_10bin": 0.004107806483522981, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + "E53": { + "valid": 2804, + "positives": 11, + "negatives": 2793, + "auroc": 0.6805325000813722, + "auprc": 0.006935394366599222, + "brier": 0.003956127544964669, + "calibration": { + "observed_rate": 0.0039229671897289585, + "mean_prediction": 0.0036462895823296875, + "calibration_in_the_large": -0.000276677607399271, + "expected_calibration_error_10bin": 0.0003486495410556158, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "E55": { + "valid": 2737, + "positives": 30, + "negatives": 2707, + "auroc": 0.629245166851373, + "auprc": 0.01871138819985985, + "brier": 0.011070449079075296, + "calibration": { + "observed_rate": 0.010960906101571063, + "mean_prediction": 0.013312233946874641, + "calibration_in_the_large": 0.0023513278453035774, + "expected_calibration_error_10bin": 0.0023513278453035774, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + "E66": { + "valid": 2371, + "positives": 42, + "negatives": 2329, + "auroc": 0.7382281379705167, + "auprc": 0.05409561682980596, + "brier": 0.017201056817440313, + "calibration": { + "observed_rate": 0.017714044706874738, + "mean_prediction": 0.017258780142156864, + "calibration_in_the_large": -0.0004552645647178735, + "expected_calibration_error_10bin": 0.0016193399336899995, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + "E78": { + "valid": 1572, + "positives": 50, + "negatives": 1522, + "auroc": 0.743718791064389, + "auprc": 0.12489467776023179, + "brier": 0.03072025599616788, + "calibration": { + "observed_rate": 0.031806615776081425, + "mean_prediction": 0.03431782367399748, + "calibration_in_the_large": 0.0025112078979160554, + "expected_calibration_error_10bin": 0.010699719520329864, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + "E80": { + "valid": 2823, + "positives": 8, + "negatives": 2815, + "auroc": 0.8143872113676732, + "auprc": 0.02410157539381859, + "brier": 0.002853270250672069, + "calibration": { + "observed_rate": 0.0028338646829613886, + "mean_prediction": 0.002589242817508589, + "calibration_in_the_large": -0.0002446218654527997, + "expected_calibration_error_10bin": 0.0007542369437731696, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "E83": { + "valid": 2653, + "positives": 86, + "negatives": 2567, + "auroc": 0.8058859767532456, + "auprc": 0.19815973238226142, + "brier": 0.02861903800795415, + "calibration": { + "observed_rate": 0.03241613267998492, + "mean_prediction": 0.02528893528045413, + "calibration_in_the_large": -0.007127197399530792, + "expected_calibration_error_10bin": 0.00905131392204264, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + "E86": { + "valid": 2587, + "positives": 97, + "negatives": 2490, + "auroc": 0.7849542499896494, + "auprc": 0.1215053303266857, + "brier": 0.03481714788857436, + "calibration": { + "observed_rate": 0.03749516814843448, + "mean_prediction": 0.04487274307951117, + "calibration_in_the_large": 0.007377574931076686, + "expected_calibration_error_10bin": 0.007382508200394575, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + "E87": { + "valid": 2185, + "positives": 157, + "negatives": 2028, + "auroc": 0.7929528009145843, + "auprc": 0.24369398223327335, + "brier": 0.060490934411094724, + "calibration": { + "observed_rate": 0.07185354691075514, + "mean_prediction": 0.057572922979436766, + "calibration_in_the_large": -0.014280623931318376, + "expected_calibration_error_10bin": 0.0175077912845229, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + "E88": { + "valid": 2817, + "positives": 15, + "negatives": 2802, + "auroc": 0.8272424458719962, + "auprc": 0.08272770368483458, + "brier": 0.005128886678961526, + "calibration": { + "observed_rate": 0.005324813631522897, + "mean_prediction": 0.004425217107717646, + "calibration_in_the_large": -0.0008995965238052508, + "expected_calibration_error_10bin": 0.0008995965238052504, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "E89": { + "valid": 2780, + "positives": 8, + "negatives": 2772, + "auroc": 0.5997023809523809, + "auprc": 0.0040296106467358084, + "brier": 0.0028854619836774253, + "calibration": { + "observed_rate": 0.0028776978417266188, + "mean_prediction": 0.0035389511728124933, + "calibration_in_the_large": 0.0006612533310858745, + "expected_calibration_error_10bin": 0.0006612533310858745, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "F02": { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8085239456754825, + "auprc": 0.005916153742929268, + "brier": 0.001529166583769849, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.0035477965015148984, + "calibration_in_the_large": 0.002120244752764006, + "expected_calibration_error_10bin": 0.002120244752764006, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "F03": { + "valid": 2739, + "positives": 18, + "negatives": 2721, + "auroc": 0.8551390420188656, + "auprc": 0.03317756936038211, + "brier": 0.0066584133736979694, + "calibration": { + "observed_rate": 0.0065717415115005475, + "mean_prediction": 0.008611883335138418, + "calibration_in_the_large": 0.0020401418236378702, + "expected_calibration_error_10bin": 0.0020401418236378694, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "F05": { + "valid": 2750, + "positives": 32, + "negatives": 2718, + "auroc": 0.7278559602649006, + "auprc": 0.025379956952964845, + "brier": 0.011914197512029196, + "calibration": { + "observed_rate": 0.011636363636363636, + "mean_prediction": 0.014409895673097873, + "calibration_in_the_large": 0.0027735320367342376, + "expected_calibration_error_10bin": 0.0027735320367342376, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "F06": { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7163835810332626, + "auprc": 0.0018326584071742644, + "brier": 0.0007411085889747082, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0032832535497023057, + "calibration_in_the_large": 0.0025760399712015983, + "expected_calibration_error_10bin": 0.0025760399712015983, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "F10": { + "valid": 2560, + "positives": 17, + "negatives": 2543, + "auroc": 0.8099049293331174, + "auprc": 0.10248614295608836, + "brier": 0.006405678188100711, + "calibration": { + "observed_rate": 0.006640625, + "mean_prediction": 0.009089995549459218, + "calibration_in_the_large": 0.002449370549459218, + "expected_calibration_error_10bin": 0.002545665601667224, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "F11": { + "valid": 2741, + "positives": 11, + "negatives": 2730, + "auroc": 0.8783549783549783, + "auprc": 0.04397422344437113, + "brier": 0.004021371753335971, + "calibration": { + "observed_rate": 0.004013133892739876, + "mean_prediction": 0.004997133210235186, + "calibration_in_the_large": 0.0009839993174953097, + "expected_calibration_error_10bin": 0.0009839993174953097, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "F12": { + "valid": 2777, + "positives": 13, + "negatives": 2764, + "auroc": 0.8996159412223088, + "auprc": 0.028247657480170885, + "brier": 0.0046221772969836546, + "calibration": { + "observed_rate": 0.004681310767014764, + "mean_prediction": 0.003997738250832523, + "calibration_in_the_large": -0.0006835725161822414, + "expected_calibration_error_10bin": 0.0007654711439802754, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "F14": { + "valid": 2787, + "positives": 10, + "negatives": 2777, + "auroc": 0.9507742167806986, + "auprc": 0.04894086479608696, + "brier": 0.0035371822561759, + "calibration": { + "observed_rate": 0.003588087549336204, + "mean_prediction": 0.001586769635784324, + "calibration_in_the_large": -0.00200131791355188, + "expected_calibration_error_10bin": 0.00200131791355188, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "F15": { + "valid": 2823, + "positives": 8, + "negatives": 2815, + "auroc": 0.9625666074600355, + "auprc": 0.11708001957964861, + "brier": 0.002783111937523737, + "calibration": { + "observed_rate": 0.0028338646829613886, + "mean_prediction": 0.0007254460924495117, + "calibration_in_the_large": -0.0021084185905118767, + "expected_calibration_error_10bin": 0.0021084185905118767, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "F17": { + "valid": 2426, + "positives": 33, + "negatives": 2393, + "auroc": 0.8606288543605719, + "auprc": 0.09465675716890376, + "brier": 0.012925309472616383, + "calibration": { + "observed_rate": 0.013602638087386645, + "mean_prediction": 0.014217515756265335, + "calibration_in_the_large": 0.0006148776688786901, + "expected_calibration_error_10bin": 0.0010857589048652477, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + "F19": { + "valid": 2801, + "positives": 13, + "negatives": 2788, + "auroc": 0.9641319942611191, + "auprc": 0.1304629118270728, + "brier": 0.0044432773013112605, + "calibration": { + "observed_rate": 0.0046411995715815784, + "mean_prediction": 0.0020028431890727924, + "calibration_in_the_large": -0.002638356382508786, + "expected_calibration_error_10bin": 0.002638356382508786, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F20": { + "valid": 2808, + "positives": 4, + "negatives": 2804, + "auroc": 0.8223965763195435, + "auprc": 0.014529542580757865, + "brier": 0.0014188194032570157, + "calibration": { + "observed_rate": 0.0014245014245014246, + "mean_prediction": 0.0010891792858973741, + "calibration_in_the_large": -0.0003353221386040504, + "expected_calibration_error_10bin": 0.0003353221386040504, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + "F22": { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.7705673758865248, + "auprc": 0.0015432098765432098, + "brier": 0.0003602695960660801, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.0013223042336128691, + "calibration_in_the_large": 0.0009678200081609017, + "expected_calibration_error_10bin": 0.0009678200081609017, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "F25": { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7825520833333334, + "auprc": 0.005259741721190362, + "brier": 0.001068119224988776, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0011332723031841972, + "calibration_in_the_large": 6.906513752261514e-05, + "expected_calibration_error_10bin": 6.906513752261514e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "F29": { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7759560400285919, + "auprc": 0.011056957660844018, + "brier": 0.002842375198035855, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.0010014091169486179, + "calibration_in_the_large": -0.001849624382695003, + "expected_calibration_error_10bin": 0.001849624382695003, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "F31": { + "valid": 2724, + "positives": 9, + "negatives": 2715, + "auroc": 0.8513607530182116, + "auprc": 0.0327079019906461, + "brier": 0.003256800458807034, + "calibration": { + "observed_rate": 0.003303964757709251, + "mean_prediction": 0.0034991369746544564, + "calibration_in_the_large": 0.00019517221694520526, + "expected_calibration_error_10bin": 0.00019517221694520526, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + "F32": { + "valid": 2200, + "positives": 72, + "negatives": 2128, + "auroc": 0.7237168441938179, + "auprc": 0.08831650194277756, + "brier": 0.03143300419245595, + "calibration": { + "observed_rate": 0.03272727272727273, + "mean_prediction": 0.04254516236759214, + "calibration_in_the_large": 0.009817889640319412, + "expected_calibration_error_10bin": 0.009817889640319417, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + "F33": { + "valid": 2800, + "positives": 12, + "negatives": 2788, + "auroc": 0.7896341463414634, + "auprc": 0.014825971214755094, + "brier": 0.0042903017269537705, + "calibration": { + "observed_rate": 0.004285714285714286, + "mean_prediction": 0.0035179729539361556, + "calibration_in_the_large": -0.0007677413317781303, + "expected_calibration_error_10bin": 0.0007677413317781303, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "F39": { + "valid": 2801, + "positives": 11, + "negatives": 2790, + "auroc": 0.7123492994460736, + "auprc": 0.017666885940494738, + "brier": 0.0039004471620267015, + "calibration": { + "observed_rate": 0.003927168868261335, + "mean_prediction": 0.0032094439148649114, + "calibration_in_the_large": -0.0007177249533964238, + "expected_calibration_error_10bin": 0.0007177249533964238, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F41": { + "valid": 2247, + "positives": 80, + "negatives": 2167, + "auroc": 0.7052953391785879, + "auprc": 0.10043234735630857, + "brier": 0.03348895697816536, + "calibration": { + "observed_rate": 0.035603026257231864, + "mean_prediction": 0.03869997803018187, + "calibration_in_the_large": 0.003096951772950003, + "expected_calibration_error_10bin": 0.00413647238484285, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + "F43": { + "valid": 2734, + "positives": 20, + "negatives": 2714, + "auroc": 0.7498710390567428, + "auprc": 0.05644180452557973, + "brier": 0.007177611552156009, + "calibration": { + "observed_rate": 0.0073152889539136795, + "mean_prediction": 0.009270288938128961, + "calibration_in_the_large": 0.001954999984215282, + "expected_calibration_error_10bin": 0.0023604414060917262, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "F60": { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.9449976292081556, + "auprc": 0.06646192145434789, + "brier": 0.002070671809317029, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0023479263830398917, + "calibration_in_the_large": 0.0002187567591931919, + "expected_calibration_error_10bin": 0.00021875675919319184, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "F90": { + "valid": 2775, + "positives": 8, + "negatives": 2767, + "auroc": 0.8947867726779906, + "auprc": 0.033489179693629426, + "brier": 0.002857662508927493, + "calibration": { + "observed_rate": 0.002882882882882883, + "mean_prediction": 0.0011549855112651392, + "calibration_in_the_large": -0.0017278973716177437, + "expected_calibration_error_10bin": 0.0017278973716177437, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "G25": { + "valid": 2774, + "positives": 8, + "negatives": 2766, + "auroc": 0.6687002892263196, + "auprc": 0.005576367603927675, + "brier": 0.002908854464622225, + "calibration": { + "observed_rate": 0.002883922134102379, + "mean_prediction": 0.004252541026416903, + "calibration_in_the_large": 0.0013686188923145238, + "expected_calibration_error_10bin": 0.0013686188923145238, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "G31": { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.7718502605720651, + "auprc": 0.008638330802470022, + "brier": 0.0034131299857010204, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.005865169600329967, + "calibration_in_the_large": 0.0026531781656404596, + "expected_calibration_error_10bin": 0.0026531781656404596, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "G40": { + "valid": 2723, + "positives": 24, + "negatives": 2699, + "auroc": 0.745646535753983, + "auprc": 0.047630048667992884, + "brier": 0.008706738896969693, + "calibration": { + "observed_rate": 0.008813808299669483, + "mean_prediction": 0.00887014924127154, + "calibration_in_the_large": 5.634094160205695e-05, + "expected_calibration_error_10bin": 0.0009318968179334549, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "G43": { + "valid": 2725, + "positives": 15, + "negatives": 2710, + "auroc": 0.7754981549815498, + "auprc": 0.017464403809127768, + "brier": 0.005462242134602875, + "calibration": { + "observed_rate": 0.005504587155963303, + "mean_prediction": 0.003950528497946525, + "calibration_in_the_large": -0.0015540586580167779, + "expected_calibration_error_10bin": 0.0015540586580167779, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + "G44": { + "valid": 2805, + "positives": 7, + "negatives": 2798, + "auroc": 0.6772694781987134, + "auprc": 0.006330930149963001, + "brier": 0.002506016248946595, + "calibration": { + "observed_rate": 0.0024955436720142605, + "mean_prediction": 0.0019506475425747833, + "calibration_in_the_large": -0.0005448961294394772, + "expected_calibration_error_10bin": 0.0005448961294394772, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "G47": { + "valid": 2315, + "positives": 89, + "negatives": 2226, + "auroc": 0.6976084476614475, + "auprc": 0.09198821688758445, + "brier": 0.036211406227813825, + "calibration": { + "observed_rate": 0.03844492440604751, + "mean_prediction": 0.03365516820892322, + "calibration_in_the_large": -0.004789756197124295, + "expected_calibration_error_10bin": 0.0050479687964563825, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + "G51": { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 1.234070528121397e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0007192669908348551, + "calibration_in_the_large": 0.0007192669908348551, + "expected_calibration_error_10bin": 0.0007192669908348551, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + "G62": { + "valid": 2751, + "positives": 36, + "negatives": 2715, + "auroc": 0.8192960916717823, + "auprc": 0.10858421520132283, + "brier": 0.012292634209056599, + "calibration": { + "observed_rate": 0.013086150490730643, + "mean_prediction": 0.00977144375918599, + "calibration_in_the_large": -0.0033147067315446536, + "expected_calibration_error_10bin": 0.0038694326222225243, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "G81": { + "valid": 2789, + "positives": 15, + "negatives": 2774, + "auroc": 0.7507810622446527, + "auprc": 0.02911608612503125, + "brier": 0.005334921887056448, + "calibration": { + "observed_rate": 0.005378271782000717, + "mean_prediction": 0.00346296603887618, + "calibration_in_the_large": -0.0019153057431245371, + "expected_calibration_error_10bin": 0.002232354228919097, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "G83": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.738863287250384, + "auprc": 0.0045422112481802975, + "brier": 0.0010702711761306563, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0015250079584006604, + "calibration_in_the_large": 0.00046268501222502287, + "expected_calibration_error_10bin": 0.00046268501222502287, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "G89": { + "valid": 2537, + "positives": 70, + "negatives": 2467, + "auroc": 0.7679830910880769, + "auprc": 0.1335423895655335, + "brier": 0.02560020980132972, + "calibration": { + "observed_rate": 0.027591643673630272, + "mean_prediction": 0.03189305769255554, + "calibration_in_the_large": 0.004301414018925271, + "expected_calibration_error_10bin": 0.004782264000515185, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + "G90": { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 3.929002184534591e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0026631878422853274, + "calibration_in_the_large": 0.0026631878422853274, + "expected_calibration_error_10bin": 0.002663187842285327, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "G92": { + "valid": 2733, + "positives": 47, + "negatives": 2686, + "auroc": 0.7525150108521728, + "auprc": 0.06758793675143064, + "brier": 0.017052691547480188, + "calibration": { + "observed_rate": 0.017197219173069888, + "mean_prediction": 0.02297952036971623, + "calibration_in_the_large": 0.005782301196646342, + "expected_calibration_error_10bin": 0.005889589600860521, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "G93": { + "valid": 2656, + "positives": 56, + "negatives": 2600, + "auroc": 0.7974725274725275, + "auprc": 0.07328506868082561, + "brier": 0.02020250514843282, + "calibration": { + "observed_rate": 0.02108433734939759, + "mean_prediction": 0.018524468766602707, + "calibration_in_the_large": -0.0025598685827948817, + "expected_calibration_error_10bin": 0.004053752676225989, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + "G99": { + "valid": 2841, + "positives": 1, + "negatives": 2840, + "auroc": 0.8795774647887324, + "auprc": 0.0029154518950437317, + "brier": 0.0003529225769016019, + "calibration": { + "observed_rate": 0.00035198873636043646, + "mean_prediction": 0.0005269599859640602, + "calibration_in_the_large": 0.00017497124960362374, + "expected_calibration_error_10bin": 0.00017497124960362374, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9992965177629265 + }, + "H10": { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.7645671148855863, + "auprc": 0.010964110597097744, + "brier": 0.0021136230489956606, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.0011939783397308488, + "calibration_in_the_large": -0.0009246657280657614, + "expected_calibration_error_10bin": 0.0009246657280657614, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "H26": { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 1.5184406000931246e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0019617951233859635, + "calibration_in_the_large": 0.0019617951233859635, + "expected_calibration_error_10bin": 0.0019617951233859635, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "H35": { + "valid": 2806, + "positives": 6, + "negatives": 2800, + "auroc": 0.7370238095238095, + "auprc": 0.007376912122886662, + "brier": 0.002136638782148765, + "calibration": { + "observed_rate": 0.0021382751247327157, + "mean_prediction": 0.0010753882566446246, + "calibration_in_the_large": -0.001062886868088091, + "expected_calibration_error_10bin": 0.001062886868088091, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "H40": { + "valid": 2750, + "positives": 12, + "negatives": 2738, + "auroc": 0.7511261261261262, + "auprc": 0.023124330596188392, + "brier": 0.004367375611097658, + "calibration": { + "observed_rate": 0.004363636363636364, + "mean_prediction": 0.005303584634090922, + "calibration_in_the_large": 0.0009399482704545584, + "expected_calibration_error_10bin": 0.0009399482704545584, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "H53": { + "valid": 2790, + "positives": 14, + "negatives": 2776, + "auroc": 0.5902120214079868, + "auprc": 0.01097145087209744, + "brier": 0.005030342003962854, + "calibration": { + "observed_rate": 0.005017921146953405, + "mean_prediction": 0.006324078591759934, + "calibration_in_the_large": 0.001306157444806529, + "expected_calibration_error_10bin": 0.0013061574448065291, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "H54": { + "valid": 2809, + "positives": 4, + "negatives": 2805, + "auroc": 0.435204991087344, + "auprc": 0.0014943398335895016, + "brier": 0.0014658777985701239, + "calibration": { + "observed_rate": 0.001423994304022784, + "mean_prediction": 0.0033341239372329822, + "calibration_in_the_large": 0.0019101296332101982, + "expected_calibration_error_10bin": 0.0019101296332101982, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "H91": { + "valid": 2791, + "positives": 7, + "negatives": 2784, + "auroc": 0.7548747947454844, + "auprc": 0.008696656513582417, + "brier": 0.0025139774586269525, + "calibration": { + "observed_rate": 0.0025080616266571123, + "mean_prediction": 0.0033819004943330014, + "calibration_in_the_large": 0.0008738388676758891, + "expected_calibration_error_10bin": 0.0008738388676758891, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + "I07": { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.8722044728434505, + "auprc": 0.010271788655453385, + "brier": 0.0021467672065153633, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.00166289613058187, + "calibration_in_the_large": -0.00046250238163917127, + "expected_calibration_error_10bin": 0.000652308970670492, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "I08": { + "valid": 2767, + "positives": 13, + "negatives": 2754, + "auroc": 0.877129769286632, + "auprc": 0.03136804415341628, + "brier": 0.0050467218601213774, + "calibration": { + "observed_rate": 0.0046982291290206, + "mean_prediction": 0.009000315609503427, + "calibration_in_the_large": 0.004302086480482827, + "expected_calibration_error_10bin": 0.004302086480482827, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + "I10": { + "valid": 1498, + "positives": 43, + "negatives": 1455, + "auroc": 0.6813873571485655, + "auprc": 0.0671629940241298, + "brier": 0.028016143087438067, + "calibration": { + "observed_rate": 0.02870493991989319, + "mean_prediction": 0.022110243377963378, + "calibration_in_the_large": -0.006594696541929814, + "expected_calibration_error_10bin": 0.010096142153990502, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + "I11": { + "valid": 2676, + "positives": 57, + "negatives": 2619, + "auroc": 0.806535238439742, + "auprc": 0.08330995098537382, + "brier": 0.02039833352055531, + "calibration": { + "observed_rate": 0.021300448430493273, + "mean_prediction": 0.013520418447195145, + "calibration_in_the_large": -0.007780029983298128, + "expected_calibration_error_10bin": 0.010028593640858821, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + "I12": { + "valid": 2552, + "positives": 30, + "negatives": 2522, + "auroc": 0.8269627279936558, + "auprc": 0.06345675880070688, + "brier": 0.01161637782116618, + "calibration": { + "observed_rate": 0.011755485893416929, + "mean_prediction": 0.009094502037675787, + "calibration_in_the_large": -0.0026609838557411416, + "expected_calibration_error_10bin": 0.005109893751288272, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + "I13": { + "valid": 2727, + "positives": 31, + "negatives": 2696, + "auroc": 0.8992533741744041, + "auprc": 0.1744900330371831, + "brier": 0.010318610738986966, + "calibration": { + "observed_rate": 0.011367803447011368, + "mean_prediction": 0.012680112254506458, + "calibration_in_the_large": 0.0013123088074950898, + "expected_calibration_error_10bin": 0.0034637031557847526, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + "I16": { + "valid": 2390, + "positives": 13, + "negatives": 2377, + "auroc": 0.8936603993398272, + "auprc": 0.03420658035822067, + "brier": 0.005363099598947774, + "calibration": { + "observed_rate": 0.005439330543933054, + "mean_prediction": 0.0032832932961222067, + "calibration_in_the_large": -0.0021560372478108473, + "expected_calibration_error_10bin": 0.0021560372478108473, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + "I21": { + "valid": 2671, + "positives": 23, + "negatives": 2648, + "auroc": 0.8213253645080782, + "auprc": 0.03990737935644175, + "brier": 0.008705606506461211, + "calibration": { + "observed_rate": 0.008611007113440658, + "mean_prediction": 0.014226441256201287, + "calibration_in_the_large": 0.005615434142760629, + "expected_calibration_error_10bin": 0.005615434142760628, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "I24": { + "valid": 2809, + "positives": 10, + "negatives": 2799, + "auroc": 0.9100035727045374, + "auprc": 0.03549753779614028, + "brier": 0.0035069488709201942, + "calibration": { + "observed_rate": 0.00355998576005696, + "mean_prediction": 0.002340963706719239, + "calibration_in_the_large": -0.0012190220533377211, + "expected_calibration_error_10bin": 0.0012190220533377211, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "I25": { + "valid": 2243, + "positives": 46, + "negatives": 2197, + "auroc": 0.8294710177910589, + "auprc": 0.07850891124360082, + "brier": 0.019564924299888684, + "calibration": { + "observed_rate": 0.02050824788230049, + "mean_prediction": 0.018150545126791526, + "calibration_in_the_large": -0.002357702755508964, + "expected_calibration_error_10bin": 0.006271840591847064, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + "I26": { + "valid": 2760, + "positives": 20, + "negatives": 2740, + "auroc": 0.7397445255474453, + "auprc": 0.12740784094942934, + "brier": 0.006947138039796887, + "calibration": { + "observed_rate": 0.007246376811594203, + "mean_prediction": 0.006825961481703469, + "calibration_in_the_large": -0.000420415329890734, + "expected_calibration_error_10bin": 0.0005519826356907872, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + "I27": { + "valid": 2716, + "positives": 38, + "negatives": 2678, + "auroc": 0.8394520655634605, + "auprc": 0.06136969006738136, + "brier": 0.013633781543904547, + "calibration": { + "observed_rate": 0.013991163475699559, + "mean_prediction": 0.011179047001236264, + "calibration_in_the_large": -0.002812116474463295, + "expected_calibration_error_10bin": 0.006607110597403184, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I31": { + "valid": 2793, + "positives": 17, + "negatives": 2776, + "auroc": 0.8107730123749788, + "auprc": 0.050422363210839066, + "brier": 0.005980764084289489, + "calibration": { + "observed_rate": 0.006086645184389545, + "mean_prediction": 0.004170319692340627, + "calibration_in_the_large": -0.001916325492048918, + "expected_calibration_error_10bin": 0.001916325492048918, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I34": { + "valid": 2753, + "positives": 19, + "negatives": 2734, + "auroc": 0.7469872559966119, + "auprc": 0.019404464109696422, + "brier": 0.006994446306917576, + "calibration": { + "observed_rate": 0.006901561932437341, + "mean_prediction": 0.006697791615192818, + "calibration_in_the_large": -0.000203770317244523, + "expected_calibration_error_10bin": 0.0018455973562997699, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + "I35": { + "valid": 2723, + "positives": 7, + "negatives": 2716, + "auroc": 0.7051335998316852, + "auprc": 0.00777424657553699, + "brier": 0.0027319802239039086, + "calibration": { + "observed_rate": 0.002570694087403599, + "mean_prediction": 0.005355229608924063, + "calibration_in_the_large": 0.002784535521520464, + "expected_calibration_error_10bin": 0.0027845355215204643, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "I42": { + "valid": 2740, + "positives": 14, + "negatives": 2726, + "auroc": 0.9157059008489676, + "auprc": 0.05672765107191564, + "brier": 0.004992002256492261, + "calibration": { + "observed_rate": 0.0051094890510948905, + "mean_prediction": 0.005280322798762095, + "calibration_in_the_large": 0.00017083374766720463, + "expected_calibration_error_10bin": 0.0005308642545338965, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "I44": { + "valid": 2722, + "positives": 24, + "negatives": 2698, + "auroc": 0.8308314801087225, + "auprc": 0.06427034374029321, + "brier": 0.008612294625259254, + "calibration": { + "observed_rate": 0.00881704628949302, + "mean_prediction": 0.010293082637945938, + "calibration_in_the_large": 0.0014760363484529176, + "expected_calibration_error_10bin": 0.0014760363484529195, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + "I45": { + "valid": 2766, + "positives": 22, + "negatives": 2744, + "auroc": 0.6923204346673735, + "auprc": 0.02675515384920716, + "brier": 0.007858002540453926, + "calibration": { + "observed_rate": 0.007953723788864787, + "mean_prediction": 0.008075381826940353, + "calibration_in_the_large": 0.00012165803807556545, + "expected_calibration_error_10bin": 0.00012165803807556545, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + "I46": { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.7307855626326963, + "auprc": 0.008355073371232452, + "brier": 0.0017679508513969218, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.0024814488558561787, + "calibration_in_the_large": 0.0007152884884948224, + "expected_calibration_error_10bin": 0.0007152884884948224, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I47": { + "valid": 2716, + "positives": 19, + "negatives": 2697, + "auroc": 0.6736139570282771, + "auprc": 0.014577974975716338, + "brier": 0.007057956514311629, + "calibration": { + "observed_rate": 0.006995581737849779, + "mean_prediction": 0.009924057851418554, + "calibration_in_the_large": 0.0029284761135687743, + "expected_calibration_error_10bin": 0.0029284761135687743, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I48": { + "valid": 2385, + "positives": 32, + "negatives": 2353, + "auroc": 0.7462813429664258, + "auprc": 0.033707157386133245, + "brier": 0.013324635824565287, + "calibration": { + "observed_rate": 0.013417190775681341, + "mean_prediction": 0.01351303421322108, + "calibration_in_the_large": 9.584343753973878e-05, + "expected_calibration_error_10bin": 0.0019305109230906893, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + "I49": { + "valid": 2734, + "positives": 19, + "negatives": 2715, + "auroc": 0.7040418726373946, + "auprc": 0.015145295443721861, + "brier": 0.006893167915088271, + "calibration": { + "observed_rate": 0.006949524506217996, + "mean_prediction": 0.005212769411530158, + "calibration_in_the_large": -0.0017367550946878378, + "expected_calibration_error_10bin": 0.0017367550946878378, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I50": { + "valid": 2415, + "positives": 52, + "negatives": 2363, + "auroc": 0.8133728311468472, + "auprc": 0.11171997247451451, + "brier": 0.020570014972117343, + "calibration": { + "observed_rate": 0.021532091097308487, + "mean_prediction": 0.021711687116021307, + "calibration_in_the_large": 0.0001795960187128201, + "expected_calibration_error_10bin": 0.006150731192740242, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + "I51": { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.8179120486235252, + "auprc": 0.026412459597814585, + "brier": 0.0035301263249121794, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.002521667961950411, + "calibration_in_the_large": -0.0010408543038137501, + "expected_calibration_error_10bin": 0.0010408543038137501, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "I61": { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.8327564944106297, + "auprc": 0.011602763744248904, + "brier": 0.00320070710457863, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.0013463942866281035, + "calibration_in_the_large": -0.001865597148061404, + "expected_calibration_error_10bin": 0.001865597148061404, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "I63": { + "valid": 2735, + "positives": 16, + "negatives": 2719, + "auroc": 0.7320706141963957, + "auprc": 0.016188331450013086, + "brier": 0.005880360884746466, + "calibration": { + "observed_rate": 0.005850091407678245, + "mean_prediction": 0.00529488103047215, + "calibration_in_the_large": -0.0005552103772060949, + "expected_calibration_error_10bin": 0.0010920550999556405, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + "I65": { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.6345134874759152, + "auprc": 0.009605554531344726, + "brier": 0.002176857501518911, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.00369872869620135, + "calibration_in_the_large": 0.0015357870956245658, + "expected_calibration_error_10bin": 0.0015357870956245658, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "I67": { + "valid": 2773, + "positives": 5, + "negatives": 2768, + "auroc": 0.7226878612716763, + "auprc": 0.005616591561382759, + "brier": 0.0018537182609357095, + "calibration": { + "observed_rate": 0.0018031013342949874, + "mean_prediction": 0.003624360992031501, + "calibration_in_the_large": 0.0018212596577365135, + "expected_calibration_error_10bin": 0.0018212596577365137, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "I69": { + "valid": 2752, + "positives": 19, + "negatives": 2733, + "auroc": 0.783503764900726, + "auprc": 0.03294073859369359, + "brier": 0.006844443462012972, + "calibration": { + "observed_rate": 0.006904069767441861, + "mean_prediction": 0.007860770761659973, + "calibration_in_the_large": 0.0009567009942181119, + "expected_calibration_error_10bin": 0.000956700994218113, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + "I70": { + "valid": 2771, + "positives": 12, + "negatives": 2759, + "auroc": 0.8146671499335508, + "auprc": 0.02565256706375152, + "brier": 0.004294576814440683, + "calibration": { + "observed_rate": 0.004330566582461205, + "mean_prediction": 0.0030881712390559636, + "calibration_in_the_large": -0.0012423953434052416, + "expected_calibration_error_10bin": 0.0012423953434052416, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + "I71": { + "valid": 2769, + "positives": 5, + "negatives": 2764, + "auroc": 0.747178002894356, + "auprc": 0.005428573642435286, + "brier": 0.0018203701861878778, + "calibration": { + "observed_rate": 0.0018057060310581437, + "mean_prediction": 0.003011266873018628, + "calibration_in_the_large": 0.0012055608419604845, + "expected_calibration_error_10bin": 0.0012055608419604845, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + "I72": { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.6915599810336652, + "auprc": 0.008489641334406882, + "brier": 0.0021316924544331375, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0016859517152513878, + "calibration_in_the_large": -0.0004432179085953119, + "expected_calibration_error_10bin": 0.0004432179085953119, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "I73": { + "valid": 2734, + "positives": 10, + "negatives": 2724, + "auroc": 0.8388399412628488, + "auprc": 0.10995624499285213, + "brier": 0.003493585926450354, + "calibration": { + "observed_rate": 0.0036576444769568397, + "mean_prediction": 0.0030475412102788056, + "calibration_in_the_large": -0.0006101032666780341, + "expected_calibration_error_10bin": 0.0008657177421947768, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I74": { + "valid": 2821, + "positives": 5, + "negatives": 2816, + "auroc": 0.5935369318181818, + "auprc": 0.003932407740101063, + "brier": 0.0017712150859546076, + "calibration": { + "observed_rate": 0.001772421127259837, + "mean_prediction": 0.00106836148484543, + "calibration_in_the_large": -0.000704059642414407, + "expected_calibration_error_10bin": 0.000704059642414407, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "I77": { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.7154252129063212, + "auprc": 0.009041231979517781, + "brier": 0.0021529849055507626, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.0025331417953154936, + "calibration_in_the_large": 0.00037874323158120296, + "expected_calibration_error_10bin": 0.00037874323158120296, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "I80": { + "valid": 2827, + "positives": 5, + "negatives": 2822, + "auroc": 0.8873848334514529, + "auprc": 0.0744297485947111, + "brier": 0.0017368316406146662, + "calibration": { + "observed_rate": 0.0017686593562079944, + "mean_prediction": 0.001585566027487215, + "calibration_in_the_large": -0.0001830933287207794, + "expected_calibration_error_10bin": 0.00028945737455715056, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "I81": { + "valid": 2826, + "positives": 9, + "negatives": 2817, + "auroc": 0.7844436555831658, + "auprc": 0.03042115087777589, + "brier": 0.0032759131693487972, + "calibration": { + "observed_rate": 0.0031847133757961785, + "mean_prediction": 0.0026848756647400553, + "calibration_in_the_large": -0.0004998377110561232, + "expected_calibration_error_10bin": 0.0018912434503628515, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I82": { + "valid": 2739, + "positives": 35, + "negatives": 2704, + "auroc": 0.7461010143702451, + "auprc": 0.05133212043249687, + "brier": 0.012562483727025087, + "calibration": { + "observed_rate": 0.012778386272362175, + "mean_prediction": 0.012074473265077094, + "calibration_in_the_large": -0.000703913007285081, + "expected_calibration_error_10bin": 0.0024747338499743815, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "I85": { + "valid": 2793, + "positives": 9, + "negatives": 2784, + "auroc": 0.9916187739463601, + "auprc": 0.22724347007071513, + "brier": 0.003047785363107579, + "calibration": { + "observed_rate": 0.00322234156820623, + "mean_prediction": 0.0023189804430983267, + "calibration_in_the_large": -0.0009033611251079033, + "expected_calibration_error_10bin": 0.002196263294436232, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I87": { + "valid": 2780, + "positives": 13, + "negatives": 2767, + "auroc": 0.7418753996274777, + "auprc": 0.01873975704927164, + "brier": 0.004694385072927051, + "calibration": { + "observed_rate": 0.004676258992805755, + "mean_prediction": 0.006383956109048805, + "calibration_in_the_large": 0.0017076971162430501, + "expected_calibration_error_10bin": 0.00170769711624305, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "I89": { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.838567883729174, + "auprc": 0.012026849421898722, + "brier": 0.001762840647958712, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.0008595546796622119, + "calibration_in_the_large": -0.0009097305291134426, + "expected_calibration_error_10bin": 0.0009097305291134426, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I95": { + "valid": 2485, + "positives": 103, + "negatives": 2382, + "auroc": 0.7522437700227433, + "auprc": 0.10198580242173094, + "brier": 0.038651278713168126, + "calibration": { + "observed_rate": 0.04144869215291751, + "mean_prediction": 0.03696420152017648, + "calibration_in_the_large": -0.004484490632741027, + "expected_calibration_error_10bin": 0.007925466793613651, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + "I96": { + "valid": 2831, + "positives": 6, + "negatives": 2825, + "auroc": 0.8768731563421829, + "auprc": 0.03464778182124272, + "brier": 0.002091828403887865, + "calibration": { + "observed_rate": 0.0021193924408336277, + "mean_prediction": 0.0021019784848881, + "calibration_in_the_large": -1.7413955945527575e-05, + "expected_calibration_error_10bin": 1.7413955945527575e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I97": { + "valid": 2740, + "positives": 11, + "negatives": 2729, + "auroc": 0.7644824944202006, + "auprc": 0.01292239424635326, + "brier": 0.003995367504221956, + "calibration": { + "observed_rate": 0.0040145985401459855, + "mean_prediction": 0.0038125638412201206, + "calibration_in_the_large": -0.0002020346989258649, + "expected_calibration_error_10bin": 0.0002020346989258649, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "J02": { + "valid": 2825, + "positives": 3, + "negatives": 2822, + "auroc": 0.7523033309709426, + "auprc": 0.0028833541777633837, + "brier": 0.0010890479710077084, + "calibration": { + "observed_rate": 0.0010619469026548673, + "mean_prediction": 0.002074889934954514, + "calibration_in_the_large": 0.0010129430322996466, + "expected_calibration_error_10bin": 0.0010129430322996466, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J06": { + "valid": 2816, + "positives": 12, + "negatives": 2804, + "auroc": 0.7181407513076558, + "auprc": 0.012764523648746666, + "brier": 0.0043510473880921585, + "calibration": { + "observed_rate": 0.004261363636363636, + "mean_prediction": 0.004283192162864163, + "calibration_in_the_large": 2.1828526500526982e-05, + "expected_calibration_error_10bin": 0.0009425215987862016, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "J12": { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.9621640735502122, + "auprc": 0.009259259259259259, + "brier": 0.0005095769607520547, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.0036110474028038485, + "calibration_in_the_large": 0.0032575656071163264, + "expected_calibration_error_10bin": 0.0032575656071163264, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J15": { + "valid": 2795, + "positives": 15, + "negatives": 2780, + "auroc": 0.8091846522781775, + "auprc": 0.021284626586491953, + "brier": 0.0054419419001946944, + "calibration": { + "observed_rate": 0.005366726296958855, + "mean_prediction": 0.0070024926895848934, + "calibration_in_the_large": 0.0016357663926260388, + "expected_calibration_error_10bin": 0.001635766392626038, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + "J18": { + "valid": 2671, + "positives": 64, + "negatives": 2607, + "auroc": 0.7712049290372075, + "auprc": 0.07575161480474726, + "brier": 0.023125583102220005, + "calibration": { + "observed_rate": 0.023961063272182705, + "mean_prediction": 0.022086550448471118, + "calibration_in_the_large": -0.0018745128237115868, + "expected_calibration_error_10bin": 0.006567705207875153, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "J30": { + "valid": 2815, + "positives": 7, + "negatives": 2808, + "auroc": 0.7490842490842491, + "auprc": 0.025279606078928086, + "brier": 0.0024876631123642583, + "calibration": { + "observed_rate": 0.002486678507992895, + "mean_prediction": 0.003547520131639041, + "calibration_in_the_large": 0.0010608416236461459, + "expected_calibration_error_10bin": 0.001060841623646146, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "J32": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.514149274849664, + "auprc": 0.0025076354013979624, + "brier": 0.0007334194404449451, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0015983927405703957, + "calibration_in_the_large": 0.0008914291491953515, + "expected_calibration_error_10bin": 0.0008914291491953515, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J38": { + "valid": 2825, + "positives": 3, + "negatives": 2822, + "auroc": 0.7482872667139144, + "auprc": 0.0038166243740526268, + "brier": 0.0010732538876745028, + "calibration": { + "observed_rate": 0.0010619469026548673, + "mean_prediction": 0.0019177673189809126, + "calibration_in_the_large": 0.0008558204163260452, + "expected_calibration_error_10bin": 0.0008558204163260452, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J43": { + "valid": 2804, + "positives": 10, + "negatives": 2794, + "auroc": 0.6195060844667144, + "auprc": 0.005572578929721302, + "brier": 0.0035774700209121727, + "calibration": { + "observed_rate": 0.003566333808844508, + "mean_prediction": 0.0020763655919072126, + "calibration_in_the_large": -0.0014899682169372953, + "expected_calibration_error_10bin": 0.0015829936685722832, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "J44": { + "valid": 2570, + "positives": 30, + "negatives": 2540, + "auroc": 0.7924015748031497, + "auprc": 0.03661729859829622, + "brier": 0.011488697176339734, + "calibration": { + "observed_rate": 0.011673151750972763, + "mean_prediction": 0.00916805176365829, + "calibration_in_the_large": -0.0025050999873144734, + "expected_calibration_error_10bin": 0.0038382501041644415, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + "J45": { + "valid": 2518, + "positives": 25, + "negatives": 2493, + "auroc": 0.6879422382671481, + "auprc": 0.02374104768193798, + "brier": 0.009835653007236418, + "calibration": { + "observed_rate": 0.009928514694201748, + "mean_prediction": 0.009115208959066574, + "calibration_in_the_large": -0.0008133057351351735, + "expected_calibration_error_10bin": 0.0012604080226723208, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + "J47": { + "valid": 2825, + "positives": 7, + "negatives": 2818, + "auroc": 0.8252053127851566, + "auprc": 0.013542985773891411, + "brier": 0.002471995786305676, + "calibration": { + "observed_rate": 0.00247787610619469, + "mean_prediction": 0.0010165410236965397, + "calibration_in_the_large": -0.0014613350824981505, + "expected_calibration_error_10bin": 0.0014613350824981505, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J69": { + "valid": 2777, + "positives": 31, + "negatives": 2746, + "auroc": 0.777917440030073, + "auprc": 0.037288341549313764, + "brier": 0.011047209798587613, + "calibration": { + "observed_rate": 0.011163125675189053, + "mean_prediction": 0.012014274059195872, + "calibration_in_the_large": 0.0008511483840068189, + "expected_calibration_error_10bin": 0.0008511483840068192, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "J81": { + "valid": 2781, + "positives": 23, + "negatives": 2758, + "auroc": 0.7691301194942776, + "auprc": 0.026667129823993885, + "brier": 0.008180524007242453, + "calibration": { + "observed_rate": 0.008270406328658756, + "mean_prediction": 0.0038940691607207657, + "calibration_in_the_large": -0.00437633716793799, + "expected_calibration_error_10bin": 0.00437633716793799, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "J84": { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.9143873919674631, + "auprc": 0.03259898351756601, + "brier": 0.002455218965839343, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.001929736834438499, + "calibration_in_the_large": -0.0005551761936055195, + "expected_calibration_error_10bin": 0.0005551761936055195, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "J90": { + "valid": 2754, + "positives": 39, + "negatives": 2715, + "auroc": 0.7097228124852434, + "auprc": 0.02890232760217863, + "brier": 0.01413339459043829, + "calibration": { + "observed_rate": 0.014161220043572984, + "mean_prediction": 0.011180166867123918, + "calibration_in_the_large": -0.0029810531764490663, + "expected_calibration_error_10bin": 0.005260688605961249, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + "J91": { + "valid": 2807, + "positives": 11, + "negatives": 2796, + "auroc": 0.8346338925738067, + "auprc": 0.06271839701293841, + "brier": 0.00384337387179132, + "calibration": { + "observed_rate": 0.003918774492340577, + "mean_prediction": 0.004457462992792802, + "calibration_in_the_large": 0.0005386885004522246, + "expected_calibration_error_10bin": 0.0007493850484527596, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "J94": { + "valid": 2829, + "positives": 10, + "negatives": 2819, + "auroc": 0.722880454061724, + "auprc": 0.11722127716077602, + "brier": 0.00347199259815047, + "calibration": { + "observed_rate": 0.003534817956875221, + "mean_prediction": 0.0016493899966850334, + "calibration_in_the_large": -0.0018854279601901876, + "expected_calibration_error_10bin": 0.0018854279601901876, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J95": { + "valid": 2770, + "positives": 16, + "negatives": 2754, + "auroc": 0.8031499636891793, + "auprc": 0.036217227770250236, + "brier": 0.005678450628374284, + "calibration": { + "observed_rate": 0.005776173285198556, + "mean_prediction": 0.005922658534973544, + "calibration_in_the_large": 0.00014648524977498804, + "expected_calibration_error_10bin": 0.00014648524977498755, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + "J96": { + "valid": 2605, + "positives": 81, + "negatives": 2524, + "auroc": 0.8148735105945882, + "auprc": 0.11149129746758932, + "brier": 0.02949491833753483, + "calibration": { + "observed_rate": 0.03109404990403071, + "mean_prediction": 0.028515530975009074, + "calibration_in_the_large": -0.002578518929021636, + "expected_calibration_error_10bin": 0.008744434336304929, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + "J98": { + "valid": 2692, + "positives": 39, + "negatives": 2653, + "auroc": 0.7825973498796718, + "auprc": 0.05878670235200578, + "brier": 0.013995123590774788, + "calibration": { + "observed_rate": 0.01448736998514116, + "mean_prediction": 0.011430741027422664, + "calibration_in_the_large": -0.0030566289577184953, + "expected_calibration_error_10bin": 0.0033047725316895592, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + "K04": { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9516584333098095, + "auprc": 0.011178735560799902, + "brier": 0.0007049587153110945, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0009933861085085524, + "calibration_in_the_large": 0.0002881674907370432, + "expected_calibration_error_10bin": 0.0002881674907370432, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "K12": { + "valid": 2824, + "positives": 14, + "negatives": 2810, + "auroc": 0.8715048296898831, + "auprc": 0.0861278079270942, + "brier": 0.005371049335135227, + "calibration": { + "observed_rate": 0.004957507082152974, + "mean_prediction": 0.0048006081370741095, + "calibration_in_the_large": -0.00015689894507886493, + "expected_calibration_error_10bin": 0.004706195375414706, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K20": { + "valid": 2813, + "positives": 11, + "negatives": 2802, + "auroc": 0.7064434494841347, + "auprc": 0.044881016929356025, + "brier": 0.00392629795948282, + "calibration": { + "observed_rate": 0.0039104159260575895, + "mean_prediction": 0.006811870749006397, + "calibration_in_the_large": 0.0029014548229488075, + "expected_calibration_error_10bin": 0.0029014548229488075, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K21": { + "valid": 2043, + "positives": 94, + "negatives": 1949, + "auroc": 0.7488073534709562, + "auprc": 0.1483026702754492, + "brier": 0.04171078252409507, + "calibration": { + "observed_rate": 0.04601076847772883, + "mean_prediction": 0.04696102359510386, + "calibration_in_the_large": 0.0009502551173750304, + "expected_calibration_error_10bin": 0.004037184525660471, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + "K22": { + "valid": 2764, + "positives": 21, + "negatives": 2743, + "auroc": 0.726646181622485, + "auprc": 0.026087079323537467, + "brier": 0.007493899384890816, + "calibration": { + "observed_rate": 0.007597684515195369, + "mean_prediction": 0.005988098066665321, + "calibration_in_the_large": -0.0016095864485300487, + "expected_calibration_error_10bin": 0.0016095864485300487, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + "K25": { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.7552618200305034, + "auprc": 0.009163676972608642, + "brier": 0.0025730088077824177, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.003979780186162986, + "calibration_in_the_large": 0.0014948671581189671, + "expected_calibration_error_10bin": 0.0014948671581189671, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "K26": { + "valid": 2814, + "positives": 6, + "negatives": 2808, + "auroc": 0.920346628679962, + "auprc": 0.036997476164369096, + "brier": 0.0021070127934158856, + "calibration": { + "observed_rate": 0.0021321961620469083, + "mean_prediction": 0.0019211000295915404, + "calibration_in_the_large": -0.00021109613245536788, + "expected_calibration_error_10bin": 0.00021109613245536788, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "K29": { + "valid": 2785, + "positives": 15, + "negatives": 2770, + "auroc": 0.7132851985559566, + "auprc": 0.0213085379209229, + "brier": 0.005422967309488124, + "calibration": { + "observed_rate": 0.005385996409335727, + "mean_prediction": 0.009037070378913633, + "calibration_in_the_large": 0.0036510739695779053, + "expected_calibration_error_10bin": 0.0036510739695779057, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K30": { + "valid": 2837, + "positives": 3, + "negatives": 2834, + "auroc": 0.9451893672077158, + "auprc": 0.01586705415406493, + "brier": 0.0010552937741743723, + "calibration": { + "observed_rate": 0.0010574550581600281, + "mean_prediction": 0.0016566013770020203, + "calibration_in_the_large": 0.0005991463188419921, + "expected_calibration_error_10bin": 0.0005991463188419921, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "K31": { + "valid": 2756, + "positives": 21, + "negatives": 2735, + "auroc": 0.8956211369374075, + "auprc": 0.06793857266686468, + "brier": 0.0074145947699873595, + "calibration": { + "observed_rate": 0.007619738751814224, + "mean_prediction": 0.006932111936200228, + "calibration_in_the_large": -0.0006876268156139958, + "expected_calibration_error_10bin": 0.001556802626818919, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "K40": { + "valid": 2827, + "positives": 4, + "negatives": 2823, + "auroc": 0.9131243358129649, + "auprc": 0.2566890894709268, + "brier": 0.0013885808584222028, + "calibration": { + "observed_rate": 0.0014149274849663955, + "mean_prediction": 0.0019465838131268085, + "calibration_in_the_large": 0.000531656328160413, + "expected_calibration_error_10bin": 0.000531656328160413, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "K42": { + "valid": 2820, + "positives": 7, + "negatives": 2813, + "auroc": 0.8046315575643695, + "auprc": 0.021739185329805448, + "brier": 0.0024795627903397306, + "calibration": { + "observed_rate": 0.0024822695035460994, + "mean_prediction": 0.0015385429857821774, + "calibration_in_the_large": -0.000943726517763922, + "expected_calibration_error_10bin": 0.0010374705577221722, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "K43": { + "valid": 2813, + "positives": 9, + "negatives": 2804, + "auroc": 0.8091218893644001, + "auprc": 0.018794273101627026, + "brier": 0.0031997670387647237, + "calibration": { + "observed_rate": 0.003199431212228937, + "mean_prediction": 0.003174474389526527, + "calibration_in_the_large": -2.4956822702410127e-05, + "expected_calibration_error_10bin": 0.00010153039919055898, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K44": { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.6646611128252597, + "auprc": 0.006582532766196143, + "brier": 0.0025192343482327087, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.0035205080730226507, + "calibration_in_the_large": 0.0010070430819993114, + "expected_calibration_error_10bin": 0.0010070430819993114, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K52": { + "valid": 2749, + "positives": 38, + "negatives": 2711, + "auroc": 0.7957541400531946, + "auprc": 0.10640428941232628, + "brier": 0.013784496291359817, + "calibration": { + "observed_rate": 0.013823208439432522, + "mean_prediction": 0.014125016528344265, + "calibration_in_the_large": 0.0003018080889117432, + "expected_calibration_error_10bin": 0.006279528393173758, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + "K55": { + "valid": 2815, + "positives": 10, + "negatives": 2805, + "auroc": 0.7480213903743316, + "auprc": 0.011292913386803622, + "brier": 0.0035867586261568644, + "calibration": { + "observed_rate": 0.003552397868561279, + "mean_prediction": 0.003416906343841502, + "calibration_in_the_large": -0.00013549152471977691, + "expected_calibration_error_10bin": 0.0005144359464659443, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "K56": { + "valid": 2745, + "positives": 32, + "negatives": 2713, + "auroc": 0.7565656100258017, + "auprc": 0.05106484711294311, + "brier": 0.011355414770723809, + "calibration": { + "observed_rate": 0.011657559198542805, + "mean_prediction": 0.013971161173647252, + "calibration_in_the_large": 0.002313601975104447, + "expected_calibration_error_10bin": 0.002313601975104447, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + "K57": { + "valid": 2741, + "positives": 26, + "negatives": 2715, + "auroc": 0.7106105680691316, + "auprc": 0.02521007971965393, + "brier": 0.009392613190457743, + "calibration": { + "observed_rate": 0.009485589201021525, + "mean_prediction": 0.0056967457813256635, + "calibration_in_the_large": -0.0037888434196958615, + "expected_calibration_error_10bin": 0.004071154953803311, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "K58": { + "valid": 2792, + "positives": 7, + "negatives": 2785, + "auroc": 0.7412156963323929, + "auprc": 0.011876488844786981, + "brier": 0.002510290571037697, + "calibration": { + "observed_rate": 0.002507163323782235, + "mean_prediction": 0.002569326155591422, + "calibration_in_the_large": 6.216283180918679e-05, + "expected_calibration_error_10bin": 6.216283180918679e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "K59": { + "valid": 2560, + "positives": 90, + "negatives": 2470, + "auroc": 0.7640305892937472, + "auprc": 0.13822037763695, + "brier": 0.03221471667632461, + "calibration": { + "observed_rate": 0.03515625, + "mean_prediction": 0.0319199663762447, + "calibration_in_the_large": -0.003236283623755297, + "expected_calibration_error_10bin": 0.004113045969188535, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "K62": { + "valid": 2813, + "positives": 18, + "negatives": 2795, + "auroc": 0.8343072947724111, + "auprc": 0.028521392665468562, + "brier": 0.006313474070885171, + "calibration": { + "observed_rate": 0.006398862424457874, + "mean_prediction": 0.0037169554438463925, + "calibration_in_the_large": -0.0026819069806114817, + "expected_calibration_error_10bin": 0.0026819069806114817, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K63": { + "valid": 2810, + "positives": 21, + "negatives": 2789, + "auroc": 0.7388379518175144, + "auprc": 0.01680950996180653, + "brier": 0.007442212892625003, + "calibration": { + "observed_rate": 0.007473309608540925, + "mean_prediction": 0.004784570645048569, + "calibration_in_the_large": -0.0026887389634923558, + "expected_calibration_error_10bin": 0.0026887389634923558, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "K64": { + "valid": 2801, + "positives": 22, + "negatives": 2779, + "auroc": 0.8023978540351336, + "auprc": 0.030203978298068614, + "brier": 0.007876148388744963, + "calibration": { + "observed_rate": 0.00785433773652267, + "mean_prediction": 0.007522114626257386, + "calibration_in_the_large": -0.0003322231102652843, + "expected_calibration_error_10bin": 0.0023716962430272875, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "K65": { + "valid": 2813, + "positives": 14, + "negatives": 2799, + "auroc": 0.7750216914204052, + "auprc": 0.03109221917828615, + "brier": 0.005171419319131576, + "calibration": { + "observed_rate": 0.004976892996800568, + "mean_prediction": 0.008651325688729988, + "calibration_in_the_large": 0.003674432691929419, + "expected_calibration_error_10bin": 0.0036744326919294188, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K66": { + "valid": 2796, + "positives": 9, + "negatives": 2787, + "auroc": 0.7382290794562054, + "auprc": 0.019257921395249542, + "brier": 0.0032422927864327548, + "calibration": { + "observed_rate": 0.003218884120171674, + "mean_prediction": 0.0050552911832109255, + "calibration_in_the_large": 0.0018364070630392517, + "expected_calibration_error_10bin": 0.0018364070630392517, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "K70": { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.9182321772639692, + "auprc": 0.02673436573206002, + "brier": 0.0021622879177010316, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.001167540433796245, + "calibration_in_the_large": -0.0009954011667805394, + "expected_calibration_error_10bin": 0.0011589370221848578, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "K72": { + "valid": 2787, + "positives": 22, + "negatives": 2765, + "auroc": 0.8937202038467861, + "auprc": 0.25808868179573, + "brier": 0.006981712508051468, + "calibration": { + "observed_rate": 0.007893792608539648, + "mean_prediction": 0.004402156435338862, + "calibration_in_the_large": -0.0034916361732007855, + "expected_calibration_error_10bin": 0.004604663903067408, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "K74": { + "valid": 2763, + "positives": 7, + "negatives": 2756, + "auroc": 0.9593613933236574, + "auprc": 0.048508733937998656, + "brier": 0.002549622213262191, + "calibration": { + "observed_rate": 0.0025334781035106766, + "mean_prediction": 0.0036302577422622443, + "calibration_in_the_large": 0.0010967796387515677, + "expected_calibration_error_10bin": 0.0010967796387515675, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "K75": { + "valid": 2798, + "positives": 12, + "negatives": 2786, + "auroc": 0.8055156736061259, + "auprc": 0.025058962159389176, + "brier": 0.004277484197423144, + "calibration": { + "observed_rate": 0.004288777698355968, + "mean_prediction": 0.0029313102522473627, + "calibration_in_the_large": -0.0013574674461086056, + "expected_calibration_error_10bin": 0.0018301785377500517, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "K76": { + "valid": 2681, + "positives": 33, + "negatives": 2648, + "auroc": 0.7954774329396685, + "auprc": 0.17302283789290254, + "brier": 0.011255812226717845, + "calibration": { + "observed_rate": 0.012308839985080195, + "mean_prediction": 0.006450119844694542, + "calibration_in_the_large": -0.005858720140385652, + "expected_calibration_error_10bin": 0.006531756180350613, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + "K80": { + "valid": 2731, + "positives": 18, + "negatives": 2713, + "auroc": 0.6760863332923782, + "auprc": 0.015022321490829691, + "brier": 0.006553887663549649, + "calibration": { + "observed_rate": 0.006590992310508971, + "mean_prediction": 0.0035666364487623764, + "calibration_in_the_large": -0.003024355861746595, + "expected_calibration_error_10bin": 0.003024355861746595, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + "K81": { + "valid": 2825, + "positives": 6, + "negatives": 2819, + "auroc": 0.8669741042923023, + "auprc": 0.030258398173331837, + "brier": 0.002105812321268226, + "calibration": { + "observed_rate": 0.0021238938053097347, + "mean_prediction": 0.001637778293680857, + "calibration_in_the_large": -0.0004861155116288776, + "expected_calibration_error_10bin": 0.0004861155116288776, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "K82": { + "valid": 2824, + "positives": 4, + "negatives": 2820, + "auroc": 0.5792553191489361, + "auprc": 0.003544935395015762, + "brier": 0.0014198867677872532, + "calibration": { + "observed_rate": 0.00141643059490085, + "mean_prediction": 0.0013193499632852402, + "calibration_in_the_large": -9.708063161560968e-05, + "expected_calibration_error_10bin": 9.708063161560968e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K83": { + "valid": 2757, + "positives": 16, + "negatives": 2741, + "auroc": 0.907675118569865, + "auprc": 0.1004228553283207, + "brier": 0.005722888316688453, + "calibration": { + "observed_rate": 0.005803409503083061, + "mean_prediction": 0.004866402761758033, + "calibration_in_the_large": -0.000937006741325028, + "expected_calibration_error_10bin": 0.004037996763509396, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + "K85": { + "valid": 2779, + "positives": 10, + "negatives": 2769, + "auroc": 0.7955940772842182, + "auprc": 0.020389232836848972, + "brier": 0.0035626503268564543, + "calibration": { + "observed_rate": 0.0035984166966534724, + "mean_prediction": 0.002864666697904739, + "calibration_in_the_large": -0.0007337499987487336, + "expected_calibration_error_10bin": 0.0007337499987487336, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + "K86": { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.7059549521752545, + "auprc": 0.014208917672481768, + "brier": 0.0025266629222221847, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.003965556342476085, + "calibration_in_the_large": 0.0014520913514527458, + "expected_calibration_error_10bin": 0.0014520913514527458, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K90": { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.6828793774319066, + "auprc": 0.0039084582878374675, + "brier": 0.0014137672597438302, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0009722776404711939, + "calibration_in_the_large": -0.0004406506534178912, + "expected_calibration_error_10bin": 0.0004406506534178912, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "K91": { + "valid": 2768, + "positives": 26, + "negatives": 2742, + "auroc": 0.8773074117713068, + "auprc": 0.07276671989608784, + "brier": 0.00900290489215732, + "calibration": { + "observed_rate": 0.00939306358381503, + "mean_prediction": 0.008397454275647677, + "calibration_in_the_large": -0.0009956093081673525, + "expected_calibration_error_10bin": 0.0015307254353696285, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "K92": { + "valid": 2751, + "positives": 37, + "negatives": 2714, + "auroc": 0.8159592901671016, + "auprc": 0.08175943737037895, + "brier": 0.012821964339986584, + "calibration": { + "observed_rate": 0.013449654671028717, + "mean_prediction": 0.012041352653465637, + "calibration_in_the_large": -0.0014083020175630796, + "expected_calibration_error_10bin": 0.0015784773950389519, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "K94": { + "valid": 2823, + "positives": 15, + "negatives": 2808, + "auroc": 0.9052469135802469, + "auprc": 0.07628789100394383, + "brier": 0.005147222463602729, + "calibration": { + "observed_rate": 0.005313496280552604, + "mean_prediction": 0.006024579206079236, + "calibration_in_the_large": 0.0007110829255266319, + "expected_calibration_error_10bin": 0.0012482626606110279, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "L02": { + "valid": 2807, + "positives": 22, + "negatives": 2785, + "auroc": 0.75674881671291, + "auprc": 0.02827347871669278, + "brier": 0.007723557473967863, + "calibration": { + "observed_rate": 0.007837548984681154, + "mean_prediction": 0.008021735299832682, + "calibration_in_the_large": 0.00018418631515152752, + "expected_calibration_error_10bin": 0.00018418631515152752, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "L03": { + "valid": 2701, + "positives": 48, + "negatives": 2653, + "auroc": 0.7469452820706118, + "auprc": 0.06949945978783414, + "brier": 0.017130414712581525, + "calibration": { + "observed_rate": 0.017771195853387635, + "mean_prediction": 0.010932833335687528, + "calibration_in_the_large": -0.006838362517700107, + "expected_calibration_error_10bin": 0.007719619143688729, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + "L08": { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.6673982300884955, + "auprc": 0.006433447988928616, + "brier": 0.0017706475086424172, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.001978545265651535, + "calibration_in_the_large": 0.00021176081335471525, + "expected_calibration_error_10bin": 0.00021176081335471525, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + "L27": { + "valid": 2818, + "positives": 12, + "negatives": 2806, + "auroc": 0.8040508434307436, + "auprc": 0.0207734652780364, + "brier": 0.00456794588589511, + "calibration": { + "observed_rate": 0.0042583392476933995, + "mean_prediction": 0.0059310185580823465, + "calibration_in_the_large": 0.001672679310388947, + "expected_calibration_error_10bin": 0.001672679310388947, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "L29": { + "valid": 2817, + "positives": 4, + "negatives": 2813, + "auroc": 0.5260398151439744, + "auprc": 0.0026218263888579205, + "brier": 0.0015299339150858387, + "calibration": { + "observed_rate": 0.0014199503017394391, + "mean_prediction": 0.004930606152838176, + "calibration_in_the_large": 0.0035106558510987367, + "expected_calibration_error_10bin": 0.0035106558510987363, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "L30": { + "valid": 2816, + "positives": 8, + "negatives": 2808, + "auroc": 0.7444355413105413, + "auprc": 0.0252597991407148, + "brier": 0.002826977949005803, + "calibration": { + "observed_rate": 0.002840909090909091, + "mean_prediction": 0.0029380251878282334, + "calibration_in_the_large": 9.711609691914237e-05, + "expected_calibration_error_10bin": 9.711609691914266e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "L50": { + "valid": 2835, + "positives": 3, + "negatives": 2832, + "auroc": 0.7410546139359698, + "auprc": 0.010087951264421852, + "brier": 0.0010579561441714453, + "calibration": { + "observed_rate": 0.0010582010582010583, + "mean_prediction": 0.001276600446169736, + "calibration_in_the_large": 0.00021839938796867778, + "expected_calibration_error_10bin": 0.00021839938796867778, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + "L53": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 1.07128954044678e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0016259517591990567, + "calibration_in_the_large": 0.0016259517591990567, + "expected_calibration_error_10bin": 0.0016259517591990567, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "L76": { + "valid": 2793, + "positives": 15, + "negatives": 2778, + "auroc": 0.7011999040076794, + "auprc": 0.01154635556637857, + "brier": 0.005380882050632226, + "calibration": { + "observed_rate": 0.0053705692803437165, + "mean_prediction": 0.006236734617821358, + "calibration_in_the_large": 0.0008661653374776417, + "expected_calibration_error_10bin": 0.0008661653374776419, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "L89": { + "valid": 2798, + "positives": 25, + "negatives": 2773, + "auroc": 0.8566173818968627, + "auprc": 0.042945981253753096, + "brier": 0.00882832623139987, + "calibration": { + "observed_rate": 0.008934953538241601, + "mean_prediction": 0.00651965347167085, + "calibration_in_the_large": -0.002415300066570751, + "expected_calibration_error_10bin": 0.0035977917732563135, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "L97": { + "valid": 2789, + "positives": 13, + "negatives": 2776, + "auroc": 0.8847816448681002, + "auprc": 0.07356283879895609, + "brier": 0.004652241490491037, + "calibration": { + "observed_rate": 0.004661168877733955, + "mean_prediction": 0.0066691991123909704, + "calibration_in_the_large": 0.0020080302346570152, + "expected_calibration_error_10bin": 0.002783265747726603, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "L98": { + "valid": 2824, + "positives": 8, + "negatives": 2816, + "auroc": 0.6736061789772727, + "auprc": 0.006139681065952641, + "brier": 0.0028871559590310275, + "calibration": { + "observed_rate": 0.0028328611898017, + "mean_prediction": 0.0049644378391362045, + "calibration_in_the_large": 0.0021315766493345046, + "expected_calibration_error_10bin": 0.002131576649334505, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "M10": { + "valid": 2713, + "positives": 14, + "negatives": 2699, + "auroc": 0.8023077330228127, + "auprc": 0.046256733993038965, + "brier": 0.005107744698515716, + "calibration": { + "observed_rate": 0.005160339107998526, + "mean_prediction": 0.006886930551323041, + "calibration_in_the_large": 0.0017265914433245155, + "expected_calibration_error_10bin": 0.0017265914433245162, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + "M16": { + "valid": 2790, + "positives": 3, + "negatives": 2787, + "auroc": 0.9149623250807319, + "auprc": 0.013827436635251267, + "brier": 0.001072199517836448, + "calibration": { + "observed_rate": 0.001075268817204301, + "mean_prediction": 0.0017175904227743856, + "calibration_in_the_large": 0.0006423216055700845, + "expected_calibration_error_10bin": 0.0006423216055700845, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "M17": { + "valid": 2733, + "positives": 13, + "negatives": 2720, + "auroc": 0.770079185520362, + "auprc": 0.011972633899014236, + "brier": 0.004775750452760731, + "calibration": { + "observed_rate": 0.004756677643615075, + "mean_prediction": 0.003571998744031219, + "calibration_in_the_large": -0.0011846788995838564, + "expected_calibration_error_10bin": 0.0013582636167928383, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "M19": { + "valid": 2674, + "positives": 37, + "negatives": 2637, + "auroc": 0.7133003310477714, + "auprc": 0.03362162135260575, + "brier": 0.013636424212673994, + "calibration": { + "observed_rate": 0.013836948391922213, + "mean_prediction": 0.013570714688483032, + "calibration_in_the_large": -0.0002662337034391813, + "expected_calibration_error_10bin": 0.001325350965804399, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + "M21": { + "valid": 2821, + "positives": 3, + "negatives": 2818, + "auroc": 0.8807665010645848, + "auprc": 0.008394150027278125, + "brier": 0.0010662630240107838, + "calibration": { + "observed_rate": 0.0010634526763559022, + "mean_prediction": 0.0020094334242280023, + "calibration_in_the_large": 0.0009459807478721001, + "expected_calibration_error_10bin": 0.0009459807478721001, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "M25": { + "valid": 2717, + "positives": 48, + "negatives": 2669, + "auroc": 0.6006072811290121, + "auprc": 0.024027935325881544, + "brier": 0.017534513511714627, + "calibration": { + "observed_rate": 0.017666543982333457, + "mean_prediction": 0.015474528824772725, + "calibration_in_the_large": -0.002192015157560732, + "expected_calibration_error_10bin": 0.0043464191527032865, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + "M35": { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.8840941512125535, + "auprc": 0.004478958867673601, + "brier": 0.0007196738612726834, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0011889916755786396, + "calibration_in_the_large": 0.00047623330066773437, + "expected_calibration_error_10bin": 0.00047623330066773437, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "M46": { + "valid": 2814, + "positives": 7, + "negatives": 2807, + "auroc": 0.5666955061326276, + "auprc": 0.003844024940635058, + "brier": 0.0024903794538120474, + "calibration": { + "observed_rate": 0.0024875621890547263, + "mean_prediction": 0.0024292637881379894, + "calibration_in_the_large": -5.8298400916736905e-05, + "expected_calibration_error_10bin": 5.8298400916736905e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "M47": { + "valid": 2743, + "positives": 11, + "negatives": 2732, + "auroc": 0.6960934380407294, + "auprc": 0.017214842932163184, + "brier": 0.003981251020831697, + "calibration": { + "observed_rate": 0.004010207801676996, + "mean_prediction": 0.0031379262173317547, + "calibration_in_the_large": -0.000872281584345241, + "expected_calibration_error_10bin": 0.000872281584345241, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "M48": { + "valid": 2690, + "positives": 11, + "negatives": 2679, + "auroc": 0.7731175133190811, + "auprc": 0.01516900663038862, + "brier": 0.004117519645131466, + "calibration": { + "observed_rate": 0.004089219330855019, + "mean_prediction": 0.0070669964248378115, + "calibration_in_the_large": 0.002977777093982793, + "expected_calibration_error_10bin": 0.0029777770939827925, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + "M51": { + "valid": 2785, + "positives": 5, + "negatives": 2780, + "auroc": 0.8361870503597122, + "auprc": 0.014792530847104607, + "brier": 0.0017882446472915633, + "calibration": { + "observed_rate": 0.0017953321364452424, + "mean_prediction": 0.0034227807750809216, + "calibration_in_the_large": 0.0016274486386356792, + "expected_calibration_error_10bin": 0.0016274486386356792, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "M54": { + "valid": 2567, + "positives": 47, + "negatives": 2520, + "auroc": 0.7134245187436676, + "auprc": 0.05454842696448162, + "brier": 0.017768868694359417, + "calibration": { + "observed_rate": 0.018309310479158552, + "mean_prediction": 0.018037483988579742, + "calibration_in_the_large": -0.00027182649057880953, + "expected_calibration_error_10bin": 0.0023313090133084916, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + "M62": { + "valid": 2781, + "positives": 13, + "negatives": 2768, + "auroc": 0.7192919075144508, + "auprc": 0.013697877842498617, + "brier": 0.004642637676366486, + "calibration": { + "observed_rate": 0.004674577490111471, + "mean_prediction": 0.004185579345004897, + "calibration_in_the_large": -0.0004889981451065735, + "expected_calibration_error_10bin": 0.0004889981451065735, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "M79": { + "valid": 2697, + "positives": 43, + "negatives": 2654, + "auroc": 0.726687229456196, + "auprc": 0.04653789070096456, + "brier": 0.015699667738840656, + "calibration": { + "observed_rate": 0.015943641082684465, + "mean_prediction": 0.017441681044531553, + "calibration_in_the_large": 0.0014980399618470877, + "expected_calibration_error_10bin": 0.003042677232177572, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + "M81": { + "valid": 2705, + "positives": 17, + "negatives": 2688, + "auroc": 0.7565213585434174, + "auprc": 0.03997672070596418, + "brier": 0.006228046983525486, + "calibration": { + "observed_rate": 0.006284658040665434, + "mean_prediction": 0.006161918198023712, + "calibration_in_the_large": -0.0001227398426417222, + "expected_calibration_error_10bin": 0.00148504788717227, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + "M84": { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.7700924608819346, + "auprc": 0.022797097784263642, + "brier": 0.0021531911198361415, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.003372616691977041, + "calibration_in_the_large": 0.0012434470681303412, + "expected_calibration_error_10bin": 0.0012434470681303412, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "M85": { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.7190976354322968, + "auprc": 0.006385322201635281, + "brier": 0.0025497824315806293, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.003858960502802381, + "calibration_in_the_large": 0.0013300587686983349, + "expected_calibration_error_10bin": 0.0013300587686983349, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "M86": { + "valid": 2803, + "positives": 16, + "negatives": 2787, + "auroc": 0.8025206315034087, + "auprc": 0.06430294668655025, + "brier": 0.005540497827460906, + "calibration": { + "observed_rate": 0.005708169818052087, + "mean_prediction": 0.004669051742609339, + "calibration_in_the_large": -0.0010391180754427479, + "expected_calibration_error_10bin": 0.0016755865517698607, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + "M94": { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7507102272727273, + "auprc": 0.003031250665880293, + "brier": 0.00106402468890516, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.00047865824162740127, + "calibration_in_the_large": -0.0005855489240341807, + "expected_calibration_error_10bin": 0.0005855489240341807, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "M96": { + "valid": 2804, + "positives": 4, + "negatives": 2800, + "auroc": 0.8751785714285715, + "auprc": 0.007237057636459446, + "brier": 0.0014413321808212861, + "calibration": { + "observed_rate": 0.0014265335235378032, + "mean_prediction": 0.0037242373686715026, + "calibration_in_the_large": 0.0022977038451336995, + "expected_calibration_error_10bin": 0.0022977038451336995, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "N12": { + "valid": 2831, + "positives": 8, + "negatives": 2823, + "auroc": 0.6824300389656394, + "auprc": 0.007030187730378749, + "brier": 0.0028337256370824684, + "calibration": { + "observed_rate": 0.00282585658777817, + "mean_prediction": 0.00243083830511194, + "calibration_in_the_large": -0.0003950182826662303, + "expected_calibration_error_10bin": 0.0003950182826662303, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N13": { + "valid": 2756, + "positives": 21, + "negatives": 2735, + "auroc": 0.7325498389483764, + "auprc": 0.0492829077367069, + "brier": 0.007453050874367208, + "calibration": { + "observed_rate": 0.007619738751814224, + "mean_prediction": 0.006083744922979783, + "calibration_in_the_large": -0.0015359938288344406, + "expected_calibration_error_10bin": 0.001723184870493988, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "N14": { + "valid": 2826, + "positives": 8, + "negatives": 2818, + "auroc": 0.8748669268985095, + "auprc": 0.021356737272289962, + "brier": 0.002813908057255706, + "calibration": { + "observed_rate": 0.0028308563340410475, + "mean_prediction": 0.0019816689895396683, + "calibration_in_the_large": -0.0008491873445013792, + "expected_calibration_error_10bin": 0.000922181267899213, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "N17": { + "valid": 2292, + "positives": 103, + "negatives": 2189, + "auroc": 0.7902886009926064, + "auprc": 0.18327434903545134, + "brier": 0.04028448857764456, + "calibration": { + "observed_rate": 0.04493891797556719, + "mean_prediction": 0.0471148689753493, + "calibration_in_the_large": 0.002175950999782107, + "expected_calibration_error_10bin": 0.008987315593674996, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + "N18": { + "valid": 2440, + "positives": 50, + "negatives": 2390, + "auroc": 0.857581589958159, + "auprc": 0.23552674003035295, + "brier": 0.018379268977976298, + "calibration": { + "observed_rate": 0.020491803278688523, + "mean_prediction": 0.013348485875973043, + "calibration_in_the_large": -0.0071433174027154805, + "expected_calibration_error_10bin": 0.0071433174027154805, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + "N20": { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7298963545389564, + "auprc": 0.0062508280038997945, + "brier": 0.002847086142547151, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.0016568694937306174, + "calibration_in_the_large": -0.0011941640059130035, + "expected_calibration_error_10bin": 0.0011941640059130035, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "N25": { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.9573553217320923, + "auprc": 0.08822931285846061, + "brier": 0.0024119684227205933, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.0015317251392326025, + "calibration_in_the_large": -0.0009408993750732967, + "expected_calibration_error_10bin": 0.0012024610207886201, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N28": { + "valid": 2789, + "positives": 9, + "negatives": 2780, + "auroc": 0.8299760191846522, + "auprc": 0.01726619246956161, + "brier": 0.003213590539375041, + "calibration": { + "observed_rate": 0.0032269630692004303, + "mean_prediction": 0.0051806703095486125, + "calibration_in_the_large": 0.001953707240348182, + "expected_calibration_error_10bin": 0.001953707240348182, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "N30": { + "valid": 2829, + "positives": 11, + "negatives": 2818, + "auroc": 0.7222078843796373, + "auprc": 0.012953102253868932, + "brier": 0.003953082308442308, + "calibration": { + "observed_rate": 0.003888299752562743, + "mean_prediction": 0.00490202946582425, + "calibration_in_the_large": 0.0010137297132615073, + "expected_calibration_error_10bin": 0.0010137297132615077, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N32": { + "valid": 2807, + "positives": 15, + "negatives": 2792, + "auroc": 0.7833094555873925, + "auprc": 0.1503388262831196, + "brier": 0.005141829020620743, + "calibration": { + "observed_rate": 0.005343783398646241, + "mean_prediction": 0.005108811922533465, + "calibration_in_the_large": -0.00023497147611277643, + "expected_calibration_error_10bin": 0.00038036440005512656, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "N39": { + "valid": 2520, + "positives": 83, + "negatives": 2437, + "auroc": 0.7563219640976709, + "auprc": 0.08700065876906564, + "brier": 0.03137525555326953, + "calibration": { + "observed_rate": 0.03293650793650794, + "mean_prediction": 0.039713626467652384, + "calibration_in_the_large": 0.0067771185311444465, + "expected_calibration_error_10bin": 0.006777118531144449, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + "N40": { + "valid": 2606, + "positives": 24, + "negatives": 2582, + "auroc": 0.8307997676219985, + "auprc": 0.059837879854606056, + "brier": 0.008983913394994564, + "calibration": { + "observed_rate": 0.00920951650038373, + "mean_prediction": 0.01164414844906794, + "calibration_in_the_large": 0.0024346319486842107, + "expected_calibration_error_10bin": 0.002434631948684211, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + "N73": { + "valid": 2829, + "positives": 6, + "negatives": 2823, + "auroc": 0.9023497461329555, + "auprc": 0.07494081107546688, + "brier": 0.002070902752269372, + "calibration": { + "observed_rate": 0.0021208907741251328, + "mean_prediction": 0.0012501196850508009, + "calibration_in_the_large": -0.0008707710890743319, + "expected_calibration_error_10bin": 0.0008707710890743319, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N99": { + "valid": 2799, + "positives": 6, + "negatives": 2793, + "auroc": 0.7630982217448383, + "auprc": 0.009335651117338273, + "brier": 0.0021421753320813625, + "calibration": { + "observed_rate": 0.0021436227224008574, + "mean_prediction": 0.002459453963916045, + "calibration_in_the_large": 0.00031583124151518755, + "expected_calibration_error_10bin": 0.00031583124151518755, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + "O69": { + "valid": 2743, + "positives": 6, + "negatives": 2737, + "auroc": 0.9962854707100232, + "auprc": 0.34296259296259296, + "brier": 0.0020379538779446075, + "calibration": { + "observed_rate": 0.002187386073641998, + "mean_prediction": 0.00048306265176023284, + "calibration_in_the_large": -0.001704323421881765, + "expected_calibration_error_10bin": 0.001908066330696098, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "O99": { + "valid": 2652, + "positives": 3, + "negatives": 2649, + "auroc": 0.8580596451491129, + "auprc": 0.1834571137323431, + "brier": 0.0009810042209374274, + "calibration": { + "observed_rate": 0.0011312217194570137, + "mean_prediction": 0.0005410853327331841, + "calibration_in_the_large": -0.0005901363867238296, + "expected_calibration_error_10bin": 0.0005901363867238295, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + "Q21": { + "valid": 2810, + "positives": 5, + "negatives": 2805, + "auroc": 0.6149019607843137, + "auprc": 0.005759013416460531, + "brier": 0.0017754769215450712, + "calibration": { + "observed_rate": 0.0017793594306049821, + "mean_prediction": 0.0014119021758997275, + "calibration_in_the_large": -0.00036745725470525457, + "expected_calibration_error_10bin": 0.00036745725470525457, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "U07": { + "valid": 2828, + "positives": 3, + "negatives": 2825, + "auroc": 0.7971681415929204, + "auprc": 0.01005621676155277, + "brier": 0.0010989678729766766, + "calibration": { + "observed_rate": 0.0010608203677510608, + "mean_prediction": 0.0038420085001526854, + "calibration_in_the_large": 0.002781188132401625, + "expected_calibration_error_10bin": 0.002781188132401625, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + } + }, + "365": { + "A04": { + "valid": 2782, + "positives": 29, + "negatives": 2753, + "auroc": 0.7682528151107882, + "auprc": 0.05699637509126913, + "brier": 0.010180752626566645, + "calibration": { + "observed_rate": 0.010424155283968369, + "mean_prediction": 0.010574865206936474, + "calibration_in_the_large": 0.00015070992296810533, + "expected_calibration_error_10bin": 0.001022233486004471, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "A08": { + "valid": 2818, + "positives": 11, + "negatives": 2807, + "auroc": 0.8114130258768663, + "auprc": 0.02770096795926597, + "brier": 0.003867058292455252, + "calibration": { + "observed_rate": 0.0039034776437189495, + "mean_prediction": 0.005348854656993978, + "calibration_in_the_large": 0.001445377013275029, + "expected_calibration_error_10bin": 0.0014453770132750285, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "A41": { + "valid": 2664, + "positives": 76, + "negatives": 2588, + "auroc": 0.7438277881721305, + "auprc": 0.07658717118532606, + "brier": 0.027690425614143914, + "calibration": { + "observed_rate": 0.028528528528528527, + "mean_prediction": 0.030525308143424936, + "calibration_in_the_large": 0.0019967796148964087, + "expected_calibration_error_10bin": 0.008822462667821027, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9370383397819205 + }, + "B00": { + "valid": 2819, + "positives": 4, + "negatives": 2815, + "auroc": 0.6698046181172291, + "auprc": 0.015049351801415334, + "brier": 0.0014759454453550035, + "calibration": { + "observed_rate": 0.001418942887548776, + "mean_prediction": 0.0022223307763766242, + "calibration_in_the_large": 0.0008033878888278482, + "expected_calibration_error_10bin": 0.0008033878888278482, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "B02": { + "valid": 2828, + "positives": 1, + "negatives": 2827, + "auroc": 0.7789175804740007, + "auprc": 0.001597444089456869, + "brier": 0.00035860455717643276, + "calibration": { + "observed_rate": 0.0003536067892503536, + "mean_prediction": 0.0011130530170880947, + "calibration_in_the_large": 0.0007594462278377411, + "expected_calibration_error_10bin": 0.0007594462278377411, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "B18": { + "valid": 2782, + "positives": 8, + "negatives": 2774, + "auroc": 0.9479542177361211, + "auprc": 0.10877499545907768, + "brier": 0.0027529261843463712, + "calibration": { + "observed_rate": 0.002875629043853343, + "mean_prediction": 0.0015862949148547829, + "calibration_in_the_large": -0.0012893341289985602, + "expected_calibration_error_10bin": 0.0012893341289985597, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9785437917692579 + }, + "B19": { + "valid": 2763, + "positives": 17, + "negatives": 2746, + "auroc": 0.8551690158947775, + "auprc": 0.07537545254382277, + "brier": 0.005996914810027664, + "calibration": { + "observed_rate": 0.006152732537097358, + "mean_prediction": 0.002236160843292433, + "calibration_in_the_large": -0.003916571693804926, + "expected_calibration_error_10bin": 0.003916571693804925, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "B20": { + "valid": 2829, + "positives": 5, + "negatives": 2824, + "auroc": 0.9874645892351275, + "auprc": 0.24148755656108595, + "brier": 0.0017316720629385798, + "calibration": { + "observed_rate": 0.0017674089784376105, + "mean_prediction": 0.0003413447957368231, + "calibration_in_the_large": -0.0014260641827007873, + "expected_calibration_error_10bin": 0.0015198634159266802, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "B34": { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.9791224345364473, + "auprc": 0.11487813207603212, + "brier": 0.0017008219339496402, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.001816128175309773, + "calibration_in_the_large": 4.996780794841666e-05, + "expected_calibration_error_10bin": 0.00012759522363625013, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "B35": { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.8604446012702893, + "auprc": 0.004719457237656614, + "brier": 0.0007175636806720772, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0020742700964331605, + "calibration_in_the_large": 0.0013690514786616514, + "expected_calibration_error_10bin": 0.0013690514786616514, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "B37": { + "valid": 2768, + "positives": 38, + "negatives": 2730, + "auroc": 0.7661557740505109, + "auprc": 0.0438036103889249, + "brier": 0.013479419400671818, + "calibration": { + "observed_rate": 0.013728323699421965, + "mean_prediction": 0.011128713382266541, + "calibration_in_the_large": -0.002599610317155424, + "expected_calibration_error_10bin": 0.005120467378377189, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "B95": { + "valid": 2678, + "positives": 61, + "negatives": 2617, + "auroc": 0.7056321529469985, + "auprc": 0.047602282963111885, + "brier": 0.022463358369237574, + "calibration": { + "observed_rate": 0.022778192681105303, + "mean_prediction": 0.025544772664578167, + "calibration_in_the_large": 0.002766579983472864, + "expected_calibration_error_10bin": 0.003763363634819016, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9419627154414351 + }, + "B96": { + "valid": 2630, + "positives": 88, + "negatives": 2542, + "auroc": 0.7621548887776268, + "auprc": 0.10567821203606868, + "brier": 0.03142048388325736, + "calibration": { + "observed_rate": 0.033460076045627375, + "mean_prediction": 0.035680025221670165, + "calibration_in_the_large": 0.0022199491760427903, + "expected_calibration_error_10bin": 0.0044681394955199995, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9250791417516707 + }, + "B97": { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.8881811748053786, + "auprc": 0.08492315845257022, + "brier": 0.000714164524613754, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0013065406630265264, + "calibration_in_the_large": 0.0005993270845258192, + "expected_calibration_error_10bin": 0.0005993270845258193, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "C18": { + "valid": 2824, + "positives": 2, + "negatives": 2822, + "auroc": 0.9764351523742026, + "auprc": 0.03250517598343685, + "brier": 0.0007026359978206454, + "calibration": { + "observed_rate": 0.000708215297450425, + "mean_prediction": 0.0007881878527218284, + "calibration_in_the_large": 7.997255527140339e-05, + "expected_calibration_error_10bin": 7.997255527140339e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "C22": { + "valid": 2812, + "positives": 7, + "negatives": 2805, + "auroc": 0.8918258212375859, + "auprc": 0.04575571821224432, + "brier": 0.0024500006845028987, + "calibration": { + "observed_rate": 0.0024893314366998577, + "mean_prediction": 0.0009145903809097075, + "calibration_in_the_large": -0.0015747410557901502, + "expected_calibration_error_10bin": 0.0015747410557901502, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9890960253253606 + }, + "C25": { + "valid": 2809, + "positives": 4, + "negatives": 2805, + "auroc": 0.941711229946524, + "auprc": 0.09630737278237556, + "brier": 0.0013896663473735756, + "calibration": { + "observed_rate": 0.001423994304022784, + "mean_prediction": 0.0006531163991040444, + "calibration_in_the_large": -0.0007708779049187395, + "expected_calibration_error_10bin": 0.0009609629629884268, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "C61": { + "valid": 2805, + "positives": 2, + "negatives": 2803, + "auroc": 0.9703888690688548, + "auprc": 0.019363636363636364, + "brier": 0.0007129310103150307, + "calibration": { + "observed_rate": 0.00071301247771836, + "mean_prediction": 0.001323420144907688, + "calibration_in_the_large": 0.0006104076671893279, + "expected_calibration_error_10bin": 0.0006104076671893279, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "C67": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.9548991864166961, + "auprc": 0.026964560862865947, + "brier": 0.0007042191567337818, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.0009803426773045236, + "calibration_in_the_large": 0.0002733790859294794, + "expected_calibration_error_10bin": 0.0002733790859294794, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "C77": { + "valid": 2762, + "positives": 23, + "negatives": 2739, + "auroc": 0.8638982808705177, + "auprc": 0.13028113749941547, + "brier": 0.007866708246759288, + "calibration": { + "observed_rate": 0.00832729905865315, + "mean_prediction": 0.004697787376122541, + "calibration_in_the_large": -0.0036295116825306086, + "expected_calibration_error_10bin": 0.004598797225818384, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C78": { + "valid": 2762, + "positives": 37, + "negatives": 2725, + "auroc": 0.8729779320605009, + "auprc": 0.1697948378549138, + "brier": 0.012238772332080825, + "calibration": { + "observed_rate": 0.013396089790007242, + "mean_prediction": 0.007541309982074069, + "calibration_in_the_large": -0.005854779807933173, + "expected_calibration_error_10bin": 0.007745569139622077, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9715089693985227 + }, + "C79": { + "valid": 2751, + "positives": 29, + "negatives": 2722, + "auroc": 0.8920798601434037, + "auprc": 0.19522194588837513, + "brier": 0.010258074021073097, + "calibration": { + "observed_rate": 0.010541621228644129, + "mean_prediction": 0.010322328570563082, + "calibration_in_the_large": -0.0002192926580810474, + "expected_calibration_error_10bin": 0.0049489966747252815, + "nonempty_bins": 9 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "C83": { + "valid": 2820, + "positives": 2, + "negatives": 2818, + "auroc": 0.40365507452093685, + "auprc": 0.0011605432725983324, + "brier": 0.0007321592730996599, + "calibration": { + "observed_rate": 0.0007092198581560284, + "mean_prediction": 0.0005861399417029889, + "calibration_in_the_large": -0.00012307991645303955, + "expected_calibration_error_10bin": 0.0003115736133861367, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "D25": { + "valid": 2792, + "positives": 3, + "negatives": 2789, + "auroc": 0.9596032030596391, + "auprc": 0.6695992179863147, + "brier": 0.0010504402542301564, + "calibration": { + "observed_rate": 0.0010744985673352436, + "mean_prediction": 0.000565826335988592, + "calibration_in_the_large": -0.0005086722313466515, + "expected_calibration_error_10bin": 0.0005086722313466515, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "D47": { + "valid": 2796, + "positives": 12, + "negatives": 2784, + "auroc": 0.6447258141762452, + "auprc": 0.007138671439805591, + "brier": 0.0044150693908399565, + "calibration": { + "observed_rate": 0.004291845493562232, + "mean_prediction": 0.005877777165810305, + "calibration_in_the_large": 0.0015859316722480737, + "expected_calibration_error_10bin": 0.0015859316722480737, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "D50": { + "valid": 2663, + "positives": 59, + "negatives": 2604, + "auroc": 0.7823296623187274, + "auprc": 0.11212591341312216, + "brier": 0.020675959723059505, + "calibration": { + "observed_rate": 0.022155463762673678, + "mean_prediction": 0.017772140193531162, + "calibration_in_the_large": -0.004383323569142516, + "expected_calibration_error_10bin": 0.004383323569142514, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9366865986633838 + }, + "D53": { + "valid": 2805, + "positives": 18, + "negatives": 2787, + "auroc": 0.8045688314794881, + "auprc": 0.02454326818291331, + "brier": 0.006573146111847409, + "calibration": { + "observed_rate": 0.006417112299465241, + "mean_prediction": 0.007292897156188629, + "calibration_in_the_large": 0.0008757848567233885, + "expected_calibration_error_10bin": 0.0019543443941872287, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "D59": { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9825335215243473, + "auprc": 0.02904040404040404, + "brier": 0.000700070951584648, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0009001136916072894, + "calibration_in_the_large": 0.0001948950738357802, + "expected_calibration_error_10bin": 0.0001948950738357802, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "D61": { + "valid": 2773, + "positives": 37, + "negatives": 2736, + "auroc": 0.8919906748854117, + "auprc": 0.2581429434883987, + "brier": 0.011271607153864814, + "calibration": { + "observed_rate": 0.013342949873782907, + "mean_prediction": 0.011810959145599128, + "calibration_in_the_large": -0.0015319907281837793, + "expected_calibration_error_10bin": 0.0029523300564901793, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "D62": { + "valid": 2499, + "positives": 73, + "negatives": 2426, + "auroc": 0.7817874848953686, + "auprc": 0.08167010341612777, + "brier": 0.02772538124317179, + "calibration": { + "observed_rate": 0.02921168467386955, + "mean_prediction": 0.02665757790243081, + "calibration_in_the_large": -0.0025541067714387397, + "expected_calibration_error_10bin": 0.004487403543383141, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8790010552233556 + }, + "D63": { + "valid": 2686, + "positives": 76, + "negatives": 2610, + "auroc": 0.8591903609598709, + "auprc": 0.13875089345926161, + "brier": 0.026447078824828645, + "calibration": { + "observed_rate": 0.028294862248696945, + "mean_prediction": 0.026452136908627338, + "calibration_in_the_large": -0.0018427253400696078, + "expected_calibration_error_10bin": 0.009304330738074799, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9447766443897292 + }, + "D64": { + "valid": 2434, + "positives": 122, + "negatives": 2312, + "auroc": 0.8085647228997674, + "auprc": 0.19712301381483513, + "brier": 0.04395264275157496, + "calibration": { + "observed_rate": 0.05012325390304026, + "mean_prediction": 0.05169912035151897, + "calibration_in_the_large": 0.0015758664484787077, + "expected_calibration_error_10bin": 0.006847425902605931, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8561378825184665 + }, + "D65": { + "valid": 2833, + "positives": 6, + "negatives": 2827, + "auroc": 0.8720080179224148, + "auprc": 0.016613395899569287, + "brier": 0.002116486976906138, + "calibration": { + "observed_rate": 0.002117896223085069, + "mean_prediction": 0.0011255209813293226, + "calibration_in_the_large": -0.0009923752417557463, + "expected_calibration_error_10bin": 0.0009923752417557463, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9964825888146325 + }, + "D68": { + "valid": 2682, + "positives": 63, + "negatives": 2619, + "auroc": 0.8186876125020455, + "auprc": 0.15232336467871913, + "brier": 0.02159280144415217, + "calibration": { + "observed_rate": 0.02348993288590604, + "mean_prediction": 0.014316451436140116, + "calibration_in_the_large": -0.009173481449765925, + "expected_calibration_error_10bin": 0.009584187976869262, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9433696799155822 + }, + "D69": { + "valid": 2586, + "positives": 87, + "negatives": 2499, + "auroc": 0.8312060456366455, + "auprc": 0.2469245583364275, + "brier": 0.028723672375776273, + "calibration": { + "observed_rate": 0.033642691415313224, + "mean_prediction": 0.024295917812045893, + "calibration_in_the_large": -0.009346773603267331, + "expected_calibration_error_10bin": 0.00987154338315269, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9096025325360535 + }, + "D70": { + "valid": 2787, + "positives": 26, + "negatives": 2761, + "auroc": 0.9035884434290808, + "auprc": 0.24129973088355408, + "brier": 0.008993532722659757, + "calibration": { + "observed_rate": 0.009329027628274129, + "mean_prediction": 0.009433900804943527, + "calibration_in_the_large": 0.00010487317666939798, + "expected_calibration_error_10bin": 0.005552994174386262, + "nonempty_bins": 9 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "D72": { + "valid": 2595, + "positives": 67, + "negatives": 2528, + "auroc": 0.7116946911014548, + "auprc": 0.0640646934798381, + "brier": 0.024829920074924464, + "calibration": { + "observed_rate": 0.02581888246628131, + "mean_prediction": 0.026548389451100933, + "calibration_in_the_large": 0.000729506984819623, + "expected_calibration_error_10bin": 0.0013444128801583227, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9127682026028843 + }, + "D73": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.8229942100909843, + "auprc": 0.02056034580306425, + "brier": 0.0011047367996780532, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0018462793918559677, + "calibration_in_the_large": 0.0007839564456803302, + "expected_calibration_error_10bin": 0.0007839564456803306, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "D75": { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.8707994340290061, + "auprc": 0.006597926064238405, + "brier": 0.0014190664255818524, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0017575355472081563, + "calibration_in_the_large": 0.00034460725331907126, + "expected_calibration_error_10bin": 0.00034460725331907126, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "D80": { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.9879688605803255, + "auprc": 0.0950650653607643, + "brier": 0.0021242357644532138, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.0022653633488393466, + "calibration_in_the_large": 0.0001467192810427364, + "expected_calibration_error_10bin": 0.0006374094391400837, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "D89": { + "valid": 2837, + "positives": 2, + "negatives": 2835, + "auroc": 0.8467372134038801, + "auprc": 0.007512626262626263, + "brier": 0.0009759221096618955, + "calibration": { + "observed_rate": 0.0007049700387733521, + "mean_prediction": 0.0013248749098726084, + "calibration_in_the_large": 0.0006199048710992563, + "expected_calibration_error_10bin": 0.0008922929308221593, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "E03": { + "valid": 2480, + "positives": 26, + "negatives": 2454, + "auroc": 0.6863989718512946, + "auprc": 0.023326847323297057, + "brier": 0.010344841328738467, + "calibration": { + "observed_rate": 0.010483870967741936, + "mean_prediction": 0.006922524662161689, + "calibration_in_the_large": -0.003561346305580247, + "expected_calibration_error_10bin": 0.003561346305580247, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8723179739711572 + }, + "E04": { + "valid": 2775, + "positives": 11, + "negatives": 2764, + "auroc": 0.6820484146822786, + "auprc": 0.00918781001481832, + "brier": 0.00396934606104984, + "calibration": { + "observed_rate": 0.003963963963963964, + "mean_prediction": 0.004005405154825935, + "calibration_in_the_large": 4.144119086197089e-05, + "expected_calibration_error_10bin": 4.144119086197089e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "E05": { + "valid": 2806, + "positives": 4, + "negatives": 2802, + "auroc": 0.46975374732334046, + "auprc": 0.028961587777446417, + "brier": 0.0014209878060548163, + "calibration": { + "observed_rate": 0.0014255167498218105, + "mean_prediction": 0.0014801860165753896, + "calibration_in_the_large": 5.4669266753579106e-05, + "expected_calibration_error_10bin": 5.4669266753579106e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "E11": { + "valid": 2194, + "positives": 24, + "negatives": 2170, + "auroc": 0.7640360983102918, + "auprc": 0.13474926937620238, + "brier": 0.010507659815283638, + "calibration": { + "observed_rate": 0.010938924339106655, + "mean_prediction": 0.009484219990050188, + "calibration_in_the_large": -0.0014547043490564671, + "expected_calibration_error_10bin": 0.0014547043490564671, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7717200140696447 + }, + "E16": { + "valid": 2816, + "positives": 13, + "negatives": 2803, + "auroc": 0.6661269518922034, + "auprc": 0.013920842890880794, + "brier": 0.004592374358633789, + "calibration": { + "observed_rate": 0.004616477272727273, + "mean_prediction": 0.0033064718758272315, + "calibration_in_the_large": -0.0013100053969000414, + "expected_calibration_error_10bin": 0.0013100053969000414, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "E21": { + "valid": 2814, + "positives": 5, + "negatives": 2809, + "auroc": 0.7446778212887148, + "auprc": 0.014502403662728234, + "brier": 0.001792237912637659, + "calibration": { + "observed_rate": 0.0017768301350390902, + "mean_prediction": 0.002144912776303385, + "calibration_in_the_large": 0.00036808264126429475, + "expected_calibration_error_10bin": 0.00036808264126429475, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "E22": { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.8241238015674106, + "auprc": 0.01773542862446578, + "brier": 0.0033054661471720987, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.0067011243349890896, + "calibration_in_the_large": 0.003489132900299582, + "expected_calibration_error_10bin": 0.0034891329002995812, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "E27": { + "valid": 2811, + "positives": 9, + "negatives": 2802, + "auroc": 0.820326750733603, + "auprc": 0.01063800367428301, + "brier": 0.0032281758644304524, + "calibration": { + "observed_rate": 0.0032017075773745998, + "mean_prediction": 0.0031397467430352307, + "calibration_in_the_large": -6.196083433936909e-05, + "expected_calibration_error_10bin": 0.00013699456867690885, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9887442842068238 + }, + "E43": { + "valid": 2748, + "positives": 43, + "negatives": 2705, + "auroc": 0.8202553410996002, + "auprc": 0.08089803882470598, + "brier": 0.015156667708778153, + "calibration": { + "observed_rate": 0.01564774381368268, + "mean_prediction": 0.016783158215202286, + "calibration_in_the_large": 0.001135414401519607, + "expected_calibration_error_10bin": 0.0033609976167211907, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9665845937390081 + }, + "E44": { + "valid": 2800, + "positives": 24, + "negatives": 2776, + "auroc": 0.7551633045148896, + "auprc": 0.02445485940519163, + "brier": 0.008667290904579532, + "calibration": { + "observed_rate": 0.008571428571428572, + "mean_prediction": 0.010592874129813155, + "calibration_in_the_large": 0.0020214455583845835, + "expected_calibration_error_10bin": 0.0020214455583845853, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "E46": { + "valid": 2772, + "positives": 42, + "negatives": 2730, + "auroc": 0.7901360544217687, + "auprc": 0.07418103614936548, + "brier": 0.014747222708386071, + "calibration": { + "observed_rate": 0.015151515151515152, + "mean_prediction": 0.016069583953074333, + "calibration_in_the_large": 0.0009180688015591812, + "expected_calibration_error_10bin": 0.004080124572196621, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9750263805838902 + }, + "E53": { + "valid": 2804, + "positives": 11, + "negatives": 2793, + "auroc": 0.6804674022719136, + "auprc": 0.006936462798012199, + "brier": 0.0039563885392666295, + "calibration": { + "observed_rate": 0.0039229671897289585, + "mean_prediction": 0.0036558126229466713, + "calibration_in_the_large": -0.00026715456678228725, + "expected_calibration_error_10bin": 0.0003393002126915219, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "E55": { + "valid": 2737, + "positives": 30, + "negatives": 2707, + "auroc": 0.6292821081147641, + "auprc": 0.018750828450568243, + "brier": 0.011075360957049462, + "calibration": { + "observed_rate": 0.010960906101571063, + "mean_prediction": 0.013425875729123272, + "calibration_in_the_large": 0.002464969627552209, + "expected_calibration_error_10bin": 0.0024649696275522077, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9627154414351038 + }, + "E66": { + "valid": 2371, + "positives": 42, + "negatives": 2329, + "auroc": 0.7383099225091496, + "auprc": 0.054283731136546554, + "brier": 0.017201606535688405, + "calibration": { + "observed_rate": 0.017714044706874738, + "mean_prediction": 0.017376977632610573, + "calibration_in_the_large": -0.0003370670742641642, + "expected_calibration_error_10bin": 0.0015243461091116134, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8339781920506507 + }, + "E78": { + "valid": 1572, + "positives": 50, + "negatives": 1522, + "auroc": 0.7436399474375821, + "auprc": 0.12481560899451585, + "brier": 0.030760190644500238, + "calibration": { + "observed_rate": 0.031806615776081425, + "mean_prediction": 0.03470083468665639, + "calibration_in_the_large": 0.0028942189105749666, + "expected_calibration_error_10bin": 0.00965881197508626, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5529370383397819 + }, + "E80": { + "valid": 2823, + "positives": 8, + "negatives": 2815, + "auroc": 0.8144316163410302, + "auprc": 0.0241015902654498, + "brier": 0.002853524645984802, + "calibration": { + "observed_rate": 0.0028338646829613886, + "mean_prediction": 0.0025969592825328324, + "calibration_in_the_large": -0.00023690540042855613, + "expected_calibration_error_10bin": 0.0007477268129950896, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "E83": { + "valid": 2653, + "positives": 86, + "negatives": 2567, + "auroc": 0.8059040958135911, + "auprc": 0.19823373921581178, + "brier": 0.028610251107303294, + "calibration": { + "observed_rate": 0.03241613267998492, + "mean_prediction": 0.025576548804355243, + "calibration_in_the_large": -0.00683958387562968, + "expected_calibration_error_10bin": 0.008483701546950623, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9331691874780161 + }, + "E86": { + "valid": 2587, + "positives": 98, + "negatives": 2489, + "auroc": 0.7866449110781315, + "auprc": 0.12319725390123934, + "brier": 0.03511161400001131, + "calibration": { + "observed_rate": 0.03788171627367607, + "mean_prediction": 0.045103692129543425, + "calibration_in_the_large": 0.007221975855867355, + "expected_calibration_error_10bin": 0.007711485250702519, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9099542736545903 + }, + "E87": { + "valid": 2185, + "positives": 158, + "negatives": 2027, + "auroc": 0.793918180512449, + "auprc": 0.24492143766184282, + "brier": 0.060809680630384305, + "calibration": { + "observed_rate": 0.07231121281464531, + "mean_prediction": 0.05780810533001916, + "calibration_in_the_large": -0.014503107484626146, + "expected_calibration_error_10bin": 0.017206157174907637, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.768554344002814 + }, + "E88": { + "valid": 2817, + "positives": 15, + "negatives": 2802, + "auroc": 0.8271948608137045, + "auprc": 0.08272616915935735, + "brier": 0.005128787031150934, + "calibration": { + "observed_rate": 0.005324813631522897, + "mean_prediction": 0.0044333255576985775, + "calibration_in_the_large": -0.0008914880738243192, + "expected_calibration_error_10bin": 0.0008914880738243199, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "E89": { + "valid": 2780, + "positives": 8, + "negatives": 2772, + "auroc": 0.5993867243867244, + "auprc": 0.00402826136267526, + "brier": 0.0028859282596409882, + "calibration": { + "observed_rate": 0.0028776978417266188, + "mean_prediction": 0.003570607627991992, + "calibration_in_the_large": 0.0006929097862653734, + "expected_calibration_error_10bin": 0.0006929097862653734, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "F02": { + "valid": 2802, + "positives": 4, + "negatives": 2798, + "auroc": 0.8083452466047176, + "auprc": 0.0059137113078098205, + "brier": 0.0015299019286715376, + "calibration": { + "observed_rate": 0.0014275517487508922, + "mean_prediction": 0.003563101181759789, + "calibration_in_the_large": 0.0021355494330088966, + "expected_calibration_error_10bin": 0.0021355494330088966, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "F03": { + "valid": 2739, + "positives": 18, + "negatives": 2721, + "auroc": 0.8550982073584058, + "auprc": 0.03314685670651997, + "brier": 0.006663850197362196, + "calibration": { + "observed_rate": 0.0065717415115005475, + "mean_prediction": 0.008692472288812453, + "calibration_in_the_large": 0.0021207307773119053, + "expected_calibration_error_10bin": 0.0021207307773119053, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "F05": { + "valid": 2750, + "positives": 33, + "negatives": 2717, + "auroc": 0.7348903090529885, + "auprc": 0.027335993665296557, + "brier": 0.012246679927856666, + "calibration": { + "observed_rate": 0.012, + "mean_prediction": 0.014578682034003908, + "calibration_in_the_large": 0.002578682034003908, + "expected_calibration_error_10bin": 0.0025786820340039083, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "F06": { + "valid": 2828, + "positives": 2, + "negatives": 2826, + "auroc": 0.7160297239915074, + "auprc": 0.0018297758982384867, + "brier": 0.0007412921513026699, + "calibration": { + "observed_rate": 0.0007072135785007072, + "mean_prediction": 0.0032919887290920736, + "calibration_in_the_large": 0.0025847751505913663, + "expected_calibration_error_10bin": 0.0025847751505913663, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + }, + "F10": { + "valid": 2560, + "positives": 17, + "negatives": 2543, + "auroc": 0.8101362448243159, + "auprc": 0.10249445855385765, + "brier": 0.006408360836741856, + "calibration": { + "observed_rate": 0.006640625, + "mean_prediction": 0.009181668244286812, + "calibration_in_the_large": 0.002541043244286812, + "expected_calibration_error_10bin": 0.002634124395422077, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "F11": { + "valid": 2741, + "positives": 11, + "negatives": 2730, + "auroc": 0.8782883782883782, + "auprc": 0.04376555064719024, + "brier": 0.004023238870790232, + "calibration": { + "observed_rate": 0.004013133892739876, + "mean_prediction": 0.0050504681899623685, + "calibration_in_the_large": 0.0010373342972224923, + "expected_calibration_error_10bin": 0.0010373342972224925, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "F12": { + "valid": 2777, + "positives": 13, + "negatives": 2764, + "auroc": 0.8997272626071469, + "auprc": 0.028261687564704936, + "brier": 0.0046222096144222045, + "calibration": { + "observed_rate": 0.004681310767014764, + "mean_prediction": 0.004022491788642208, + "calibration_in_the_large": -0.000658818978372556, + "expected_calibration_error_10bin": 0.0007409635316724532, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "F14": { + "valid": 2787, + "positives": 10, + "negatives": 2777, + "auroc": 0.9507021966150522, + "auprc": 0.04892167196132146, + "brier": 0.0035369275512002534, + "calibration": { + "observed_rate": 0.003588087549336204, + "mean_prediction": 0.0016005843752221391, + "calibration_in_the_large": -0.001987503174114065, + "expected_calibration_error_10bin": 0.001987503174114065, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "F15": { + "valid": 2823, + "positives": 8, + "negatives": 2815, + "auroc": 0.9627442273534635, + "auprc": 0.11732030918873412, + "brier": 0.002781694080467573, + "calibration": { + "observed_rate": 0.0028338646829613886, + "mean_prediction": 0.0007407961948973407, + "calibration_in_the_large": -0.002093068488064048, + "expected_calibration_error_10bin": 0.002093068488064048, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "F17": { + "valid": 2426, + "positives": 33, + "negatives": 2393, + "auroc": 0.8605022223910649, + "auprc": 0.0944361243957464, + "brier": 0.012926164303176575, + "calibration": { + "observed_rate": 0.013602638087386645, + "mean_prediction": 0.01428535861368268, + "calibration_in_the_large": 0.0006827205262960358, + "expected_calibration_error_10bin": 0.0010288931850084046, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8533239535701723 + }, + "F19": { + "valid": 2801, + "positives": 13, + "negatives": 2788, + "auroc": 0.9641319942611191, + "auprc": 0.13038082347379917, + "brier": 0.004443154307569562, + "calibration": { + "observed_rate": 0.0046411995715815784, + "mean_prediction": 0.0020077210350274, + "calibration_in_the_large": -0.0026334785365541786, + "expected_calibration_error_10bin": 0.0026334785365541786, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F20": { + "valid": 2808, + "positives": 4, + "negatives": 2804, + "auroc": 0.8223074179743224, + "auprc": 0.01452021097273517, + "brier": 0.001418832156763306, + "calibration": { + "observed_rate": 0.0014245014245014246, + "mean_prediction": 0.0010929920802377287, + "calibration_in_the_large": -0.0003315093442636959, + "expected_calibration_error_10bin": 0.0003315093442636959, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9876890608512136 + }, + "F22": { + "valid": 2821, + "positives": 1, + "negatives": 2820, + "auroc": 0.7698581560283688, + "auprc": 0.0015384615384615385, + "brier": 0.000360310652673649, + "calibration": { + "observed_rate": 0.0003544842254519674, + "mean_prediction": 0.001327071938779342, + "calibration_in_the_large": 0.0009725877133273746, + "expected_calibration_error_10bin": 0.0009725877133273746, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "F25": { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7821969696969697, + "auprc": 0.005256459620549397, + "brier": 0.0010681543382391279, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.0011375861841593404, + "calibration_in_the_large": 7.337901849775838e-05, + "expected_calibration_error_10bin": 7.337901849775838e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "F29": { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7753305932809149, + "auprc": 0.01100068346800245, + "brier": 0.0028423754493362525, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.001020150101752434, + "calibration_in_the_large": -0.001830883397891187, + "expected_calibration_error_10bin": 0.001830883397891187, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "F31": { + "valid": 2724, + "positives": 9, + "negatives": 2715, + "auroc": 0.8507878043789646, + "auprc": 0.032740474195448815, + "brier": 0.003256908592866931, + "calibration": { + "observed_rate": 0.003303964757709251, + "mean_prediction": 0.0035253251844658256, + "calibration_in_the_large": 0.0002213604267565744, + "expected_calibration_error_10bin": 0.0002213604267565744, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9581428068941259 + }, + "F32": { + "valid": 2200, + "positives": 72, + "negatives": 2128, + "auroc": 0.7240692878028404, + "auprc": 0.08815721651054101, + "brier": 0.031454709405306175, + "calibration": { + "observed_rate": 0.03272727272727273, + "mean_prediction": 0.042916376883248716, + "calibration_in_the_large": 0.010189104155975987, + "expected_calibration_error_10bin": 0.010189104155975987, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7738304607808653 + }, + "F33": { + "valid": 2800, + "positives": 12, + "negatives": 2788, + "auroc": 0.7889167862266858, + "auprc": 0.014735762837170154, + "brier": 0.004291410450640203, + "calibration": { + "observed_rate": 0.004285714285714286, + "mean_prediction": 0.0035552100694517972, + "calibration_in_the_large": -0.0007305042162624887, + "expected_calibration_error_10bin": 0.0008020527164938229, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9848751319029194 + }, + "F39": { + "valid": 2801, + "positives": 11, + "negatives": 2790, + "auroc": 0.7124144672531769, + "auprc": 0.0177216423257434, + "brier": 0.0039004971984916443, + "calibration": { + "observed_rate": 0.003927168868261335, + "mean_prediction": 0.0032421668715484826, + "calibration_in_the_large": -0.0006850019967128526, + "expected_calibration_error_10bin": 0.0006850019967128526, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "F41": { + "valid": 2247, + "positives": 80, + "negatives": 2167, + "auroc": 0.705404937701892, + "auprc": 0.10037689419006797, + "brier": 0.03349468273243087, + "calibration": { + "observed_rate": 0.035603026257231864, + "mean_prediction": 0.03900153339957768, + "calibration_in_the_large": 0.0033985071423458177, + "expected_calibration_error_10bin": 0.004124039932662677, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7903622933520928 + }, + "F43": { + "valid": 2734, + "positives": 21, + "negatives": 2713, + "auroc": 0.7357871272357082, + "auprc": 0.052706496130910274, + "brier": 0.007541917292666264, + "calibration": { + "observed_rate": 0.007681053401609363, + "mean_prediction": 0.009316836910295653, + "calibration_in_the_large": 0.0016357835086862902, + "expected_calibration_error_10bin": 0.002039534417261647, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "F60": { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.9448198198198198, + "auprc": 0.06595490047871, + "brier": 0.002070854810746044, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.002366461607356305, + "calibration_in_the_large": 0.00023729198350960507, + "expected_calibration_error_10bin": 0.00023729198350960534, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "F90": { + "valid": 2775, + "positives": 8, + "negatives": 2767, + "auroc": 0.8946964221178171, + "auprc": 0.03346936887219412, + "brier": 0.002857633256758364, + "calibration": { + "observed_rate": 0.002882882882882883, + "mean_prediction": 0.0011594824791966668, + "calibration_in_the_large": -0.0017234004036862161, + "expected_calibration_error_10bin": 0.0017234004036862161, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9760816039395005 + }, + "G25": { + "valid": 2774, + "positives": 9, + "negatives": 2765, + "auroc": 0.68583484026522, + "auprc": 0.0063232044808048, + "brier": 0.0032654789922131303, + "calibration": { + "observed_rate": 0.0032444124008651765, + "mean_prediction": 0.004292635060270814, + "calibration_in_the_large": 0.0010482226594056374, + "expected_calibration_error_10bin": 0.0010482226594056374, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "G31": { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.771651350598719, + "auprc": 0.008632428663597999, + "brier": 0.0034155297001949468, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.0058956933841223325, + "calibration_in_the_large": 0.002683701949432825, + "expected_calibration_error_10bin": 0.002683701949432825, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "G40": { + "valid": 2723, + "positives": 25, + "negatives": 2698, + "auroc": 0.7473239436619719, + "auprc": 0.047034891869723816, + "brier": 0.00906708974686086, + "calibration": { + "observed_rate": 0.00918105031215571, + "mean_prediction": 0.008884623772311211, + "calibration_in_the_large": -0.00029642653984449964, + "expected_calibration_error_10bin": 0.0012873068941804794, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "G43": { + "valid": 2725, + "positives": 15, + "negatives": 2710, + "auroc": 0.7755965559655597, + "auprc": 0.017485694328380697, + "brier": 0.005462315344600671, + "calibration": { + "observed_rate": 0.005504587155963303, + "mean_prediction": 0.003978578481094809, + "calibration_in_the_large": -0.0015260086748684941, + "expected_calibration_error_10bin": 0.0015260086748684941, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9584945480126627 + }, + "G44": { + "valid": 2805, + "positives": 7, + "negatives": 2798, + "auroc": 0.677218421321352, + "auprc": 0.006330547810161909, + "brier": 0.002506109206825157, + "calibration": { + "observed_rate": 0.0024955436720142605, + "mean_prediction": 0.0019566997965389395, + "calibration_in_the_large": -0.0005388438754753209, + "expected_calibration_error_10bin": 0.0005388438754753209, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9866338374956032 + }, + "G47": { + "valid": 2315, + "positives": 89, + "negatives": 2226, + "auroc": 0.6975630192717325, + "auprc": 0.09157983453575547, + "brier": 0.03621535914673906, + "calibration": { + "observed_rate": 0.03844492440604751, + "mean_prediction": 0.033936147940029304, + "calibration_in_the_large": -0.004508776466018209, + "expected_calibration_error_10bin": 0.004802614684291104, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8142806894125924 + }, + "G51": { + "valid": 2834, + "positives": 0, + "negatives": 2834, + "auroc": null, + "auprc": null, + "brier": 1.2410691300132462e-06, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.0007211612069084588, + "calibration_in_the_large": 0.0007211612069084588, + "expected_calibration_error_10bin": 0.0007211612069084588, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9968343299331692 + }, + "G62": { + "valid": 2751, + "positives": 36, + "negatives": 2715, + "auroc": 0.8192551667689789, + "auprc": 0.10836343147765697, + "brier": 0.012291228229877356, + "calibration": { + "observed_rate": 0.013086150490730643, + "mean_prediction": 0.009843890261075482, + "calibration_in_the_large": -0.0032422602296551615, + "expected_calibration_error_10bin": 0.0038035316354905232, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "G81": { + "valid": 2789, + "positives": 15, + "negatives": 2774, + "auroc": 0.7512857486181207, + "auprc": 0.029194693586727202, + "brier": 0.005334626785010273, + "calibration": { + "observed_rate": 0.005378271782000717, + "mean_prediction": 0.003503818986652835, + "calibration_in_the_large": -0.0018744527953478821, + "expected_calibration_error_10bin": 0.0021926880739476288, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "G83": { + "valid": 2824, + "positives": 3, + "negatives": 2821, + "auroc": 0.7387451258419, + "auprc": 0.004518472939297423, + "brier": 0.0010703611023380618, + "calibration": { + "observed_rate": 0.0010623229461756375, + "mean_prediction": 0.0015302497466008862, + "calibration_in_the_large": 0.00046792680042524867, + "expected_calibration_error_10bin": 0.00046792680042524867, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "G89": { + "valid": 2537, + "positives": 71, + "negatives": 2466, + "auroc": 0.770832619398467, + "auprc": 0.13568304023154135, + "brier": 0.025901223460243632, + "calibration": { + "observed_rate": 0.02798581001182499, + "mean_prediction": 0.03206710614507947, + "calibration_in_the_large": 0.0040812961332544785, + "expected_calibration_error_10bin": 0.004552397219554856, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8923672177277524 + }, + "G90": { + "valid": 2827, + "positives": 0, + "negatives": 2827, + "auroc": null, + "auprc": null, + "brier": 4.067800872838146e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.002700966778626388, + "calibration_in_the_large": 0.002700966778626388, + "expected_calibration_error_10bin": 0.0027009667786263877, + "nonempty_bins": 2 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "G92": { + "valid": 2733, + "positives": 48, + "negatives": 2685, + "auroc": 0.7550589695841092, + "auprc": 0.06771283108900593, + "brier": 0.017402055325562396, + "calibration": { + "observed_rate": 0.01756311745334797, + "mean_prediction": 0.023185631790390453, + "calibration_in_the_large": 0.005622514337042483, + "expected_calibration_error_10bin": 0.005723105909700379, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "G93": { + "valid": 2656, + "positives": 56, + "negatives": 2600, + "auroc": 0.7974107142857143, + "auprc": 0.07318198210835514, + "brier": 0.020205612910027104, + "calibration": { + "observed_rate": 0.02108433734939759, + "mean_prediction": 0.018675899764297444, + "calibration_in_the_large": -0.002408437585100145, + "expected_calibration_error_10bin": 0.004050013011681543, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9342244108336265 + }, + "G99": { + "valid": 2841, + "positives": 1, + "negatives": 2840, + "auroc": 0.8799295774647887, + "auprc": 0.0029239766081871343, + "brier": 0.0003529269468714582, + "calibration": { + "observed_rate": 0.00035198873636043646, + "mean_prediction": 0.0005284171427682511, + "calibration_in_the_large": 0.00017642840640781464, + "expected_calibration_error_10bin": 0.00017642840640781464, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9992965177629265 + }, + "H10": { + "valid": 2832, + "positives": 6, + "negatives": 2826, + "auroc": 0.7646850672328379, + "auprc": 0.01097464192948381, + "brier": 0.00211363236034263, + "calibration": { + "observed_rate": 0.00211864406779661, + "mean_prediction": 0.001196619135788299, + "calibration_in_the_large": -0.0009220249320083113, + "expected_calibration_error_10bin": 0.0009220249320083113, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9961308476960957 + }, + "H26": { + "valid": 2819, + "positives": 0, + "negatives": 2819, + "auroc": null, + "auprc": null, + "brier": 1.55149132172556e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001981149350226018, + "calibration_in_the_large": 0.001981149350226018, + "expected_calibration_error_10bin": 0.001981149350226018, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "H35": { + "valid": 2806, + "positives": 6, + "negatives": 2800, + "auroc": 0.7370238095238095, + "auprc": 0.007374236957938107, + "brier": 0.002136723278225813, + "calibration": { + "observed_rate": 0.0021382751247327157, + "mean_prediction": 0.001088642002056311, + "calibration_in_the_large": -0.0010496331226764047, + "expected_calibration_error_10bin": 0.0010496331226764047, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "H40": { + "valid": 2750, + "positives": 12, + "negatives": 2738, + "auroc": 0.7512783053323594, + "auprc": 0.02313373038516452, + "brier": 0.0043682171167759316, + "calibration": { + "observed_rate": 0.004363636363636364, + "mean_prediction": 0.005330056761798914, + "calibration_in_the_large": 0.0009664203981625506, + "expected_calibration_error_10bin": 0.0009664203981625508, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9672880759760816 + }, + "H53": { + "valid": 2790, + "positives": 15, + "negatives": 2775, + "auroc": 0.611027027027027, + "auprc": 0.01190514284042224, + "brier": 0.005379824649114014, + "calibration": { + "observed_rate": 0.005376344086021506, + "mean_prediction": 0.006333698792045929, + "calibration_in_the_large": 0.0009573547060244235, + "expected_calibration_error_10bin": 0.0009573547060244238, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "H54": { + "valid": 2809, + "positives": 4, + "negatives": 2805, + "auroc": 0.43529411764705883, + "auprc": 0.001494523559582026, + "brier": 0.0014660168616114691, + "calibration": { + "observed_rate": 0.001423994304022784, + "mean_prediction": 0.003340074726906722, + "calibration_in_the_large": 0.001916080422883938, + "expected_calibration_error_10bin": 0.001916080422883938, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "H91": { + "valid": 2791, + "positives": 7, + "negatives": 2784, + "auroc": 0.7549774220032841, + "auprc": 0.00870044587797338, + "brier": 0.002514134485278175, + "calibration": { + "observed_rate": 0.0025080616266571123, + "mean_prediction": 0.0033905448696826073, + "calibration_in_the_large": 0.000882483243025495, + "expected_calibration_error_10bin": 0.000882483243025495, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9817094618360886 + }, + "I07": { + "valid": 2823, + "positives": 6, + "negatives": 2817, + "auroc": 0.8723228020352621, + "auprc": 0.01027651935857695, + "brier": 0.0021469501845024783, + "calibration": { + "observed_rate": 0.0021253985122210413, + "mean_prediction": 0.0016688780469343194, + "calibration_in_the_large": -0.0004565204652867219, + "expected_calibration_error_10bin": 0.0006468738525072282, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "I08": { + "valid": 2767, + "positives": 14, + "negatives": 2753, + "auroc": 0.8861501738363344, + "auprc": 0.11053986087502306, + "brier": 0.005162504591412194, + "calibration": { + "observed_rate": 0.005059631369714492, + "mean_prediction": 0.009012682176821905, + "calibration_in_the_large": 0.0039530508071074135, + "expected_calibration_error_10bin": 0.00420741187307434, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9732676749912065 + }, + "I10": { + "valid": 1498, + "positives": 43, + "negatives": 1455, + "auroc": 0.6818668584671941, + "auprc": 0.0671710838999236, + "brier": 0.02802141604050129, + "calibration": { + "observed_rate": 0.02870493991989319, + "mean_prediction": 0.022362400157947854, + "calibration_in_the_large": -0.006342539761945338, + "expected_calibration_error_10bin": 0.009877612599661604, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.5269081955680619 + }, + "I11": { + "valid": 2676, + "positives": 57, + "negatives": 2619, + "auroc": 0.8064481555167031, + "auprc": 0.08328395166922202, + "brier": 0.02039901609388742, + "calibration": { + "observed_rate": 0.021300448430493273, + "mean_prediction": 0.013595073624503908, + "calibration_in_the_large": -0.007705374805989365, + "expected_calibration_error_10bin": 0.010583686059037747, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9412592332043616 + }, + "I12": { + "valid": 2552, + "positives": 30, + "negatives": 2522, + "auroc": 0.8269495109701295, + "auprc": 0.06363895316300708, + "brier": 0.011619465386968609, + "calibration": { + "observed_rate": 0.011755485893416929, + "mean_prediction": 0.009151173116416918, + "calibration_in_the_large": -0.0026043127770000105, + "expected_calibration_error_10bin": 0.005066130324632245, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8976433345058037 + }, + "I13": { + "valid": 2727, + "positives": 31, + "negatives": 2696, + "auroc": 0.8992653393318656, + "auprc": 0.1744788404989531, + "brier": 0.010320894304744869, + "calibration": { + "observed_rate": 0.011367803447011368, + "mean_prediction": 0.012743645713856675, + "calibration_in_the_large": 0.0013758422668453067, + "expected_calibration_error_10bin": 0.0035005412750172328, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9591980302497362 + }, + "I16": { + "valid": 2390, + "positives": 13, + "negatives": 2377, + "auroc": 0.8939192906378435, + "auprc": 0.03433344539848596, + "brier": 0.005362988506048239, + "calibration": { + "observed_rate": 0.005439330543933054, + "mean_prediction": 0.0033214858617615557, + "calibration_in_the_large": -0.0021178446821714983, + "expected_calibration_error_10bin": 0.0021178446821714983, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8406612733028491 + }, + "I21": { + "valid": 2671, + "positives": 23, + "negatives": 2648, + "auroc": 0.8213746223564955, + "auprc": 0.03985769575234076, + "brier": 0.008720571176127867, + "calibration": { + "observed_rate": 0.008611007113440658, + "mean_prediction": 0.014428555449024001, + "calibration_in_the_large": 0.005817548335583343, + "expected_calibration_error_10bin": 0.005817548335583342, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "I24": { + "valid": 2809, + "positives": 10, + "negatives": 2799, + "auroc": 0.9100750267952841, + "auprc": 0.03550196574117374, + "brier": 0.003506882586594799, + "calibration": { + "observed_rate": 0.00355998576005696, + "mean_prediction": 0.002347107131289833, + "calibration_in_the_large": -0.001212878628767127, + "expected_calibration_error_10bin": 0.001212878628767127, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9880408019697503 + }, + "I25": { + "valid": 2243, + "positives": 46, + "negatives": 2197, + "auroc": 0.8296293364469336, + "auprc": 0.07863923816713173, + "brier": 0.019565659386021946, + "calibration": { + "observed_rate": 0.02050824788230049, + "mean_prediction": 0.0182950015851835, + "calibration_in_the_large": -0.0022132462971169893, + "expected_calibration_error_10bin": 0.006271116083946265, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7889553288779458 + }, + "I26": { + "valid": 2760, + "positives": 20, + "negatives": 2740, + "auroc": 0.7397080291970803, + "auprc": 0.12739613771228214, + "brier": 0.006946970831503576, + "calibration": { + "observed_rate": 0.007246376811594203, + "mean_prediction": 0.006837631840323371, + "calibration_in_the_large": -0.00040874497127083194, + "expected_calibration_error_10bin": 0.0005616769545641562, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9708054871614492 + }, + "I27": { + "valid": 2716, + "positives": 40, + "negatives": 2676, + "auroc": 0.844973841554559, + "auprc": 0.07967923144720804, + "brier": 0.01415021234909028, + "calibration": { + "observed_rate": 0.014727540500736377, + "mean_prediction": 0.011190611508735935, + "calibration_in_the_large": -0.003536928992000442, + "expected_calibration_error_10bin": 0.0065999475999444735, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I31": { + "valid": 2793, + "positives": 17, + "negatives": 2776, + "auroc": 0.8108365824716054, + "auprc": 0.05042925917802046, + "brier": 0.00598078392912838, + "calibration": { + "observed_rate": 0.006086645184389545, + "mean_prediction": 0.004176824382314515, + "calibration_in_the_large": -0.00190982080207503, + "expected_calibration_error_10bin": 0.001909820802075031, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I34": { + "valid": 2753, + "positives": 19, + "negatives": 2734, + "auroc": 0.747025757517422, + "auprc": 0.019479818437195196, + "brier": 0.006996924606742085, + "calibration": { + "observed_rate": 0.006901561932437341, + "mean_prediction": 0.006742135306024205, + "calibration_in_the_large": -0.00015942662641313648, + "expected_calibration_error_10bin": 0.0018123403404918799, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9683432993316918 + }, + "I35": { + "valid": 2723, + "positives": 7, + "negatives": 2716, + "auroc": 0.7051861981906165, + "auprc": 0.007775646637229443, + "brier": 0.0027326181490632323, + "calibration": { + "observed_rate": 0.002570694087403599, + "mean_prediction": 0.00536599058826589, + "calibration_in_the_large": 0.0027952965008622914, + "expected_calibration_error_10bin": 0.002795296500862292, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9577910657755891 + }, + "I42": { + "valid": 2740, + "positives": 14, + "negatives": 2726, + "auroc": 0.915863117073682, + "auprc": 0.05676121616791553, + "brier": 0.004992068471445141, + "calibration": { + "observed_rate": 0.0051094890510948905, + "mean_prediction": 0.005289427707750133, + "calibration_in_the_large": 0.00017993865665524248, + "expected_calibration_error_10bin": 0.0005395221504396384, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "I44": { + "valid": 2722, + "positives": 24, + "negatives": 2698, + "auroc": 0.8308623671855696, + "auprc": 0.06429566212428466, + "brier": 0.008618438293139224, + "calibration": { + "observed_rate": 0.00881704628949302, + "mean_prediction": 0.010503280850313894, + "calibration_in_the_large": 0.0016862345608208741, + "expected_calibration_error_10bin": 0.0016862345608208748, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9574393246570524 + }, + "I45": { + "valid": 2766, + "positives": 22, + "negatives": 2744, + "auroc": 0.6926683010866684, + "auprc": 0.02676957278010291, + "brier": 0.007858388643875044, + "calibration": { + "observed_rate": 0.007953723788864787, + "mean_prediction": 0.008168731385858212, + "calibration_in_the_large": 0.00021500759699342488, + "expected_calibration_error_10bin": 0.00021500759699342488, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9729159338726697 + }, + "I46": { + "valid": 2831, + "positives": 5, + "negatives": 2826, + "auroc": 0.7305732484076433, + "auprc": 0.008353197057517175, + "brier": 0.001768023319183648, + "calibration": { + "observed_rate": 0.0017661603673613563, + "mean_prediction": 0.002489504774362982, + "calibration_in_the_large": 0.0007233444070016259, + "expected_calibration_error_10bin": 0.0007233444070016259, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I47": { + "valid": 2716, + "positives": 19, + "negatives": 2697, + "auroc": 0.6738091056339403, + "auprc": 0.014635520116087536, + "brier": 0.007062724299726049, + "calibration": { + "observed_rate": 0.006995581737849779, + "mean_prediction": 0.010050935623112899, + "calibration_in_the_large": 0.003055353885263119, + "expected_calibration_error_10bin": 0.0030553538852631204, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9553288779458319 + }, + "I48": { + "valid": 2385, + "positives": 32, + "negatives": 2353, + "auroc": 0.7460821291967701, + "auprc": 0.033660714983181676, + "brier": 0.013332462387984075, + "calibration": { + "observed_rate": 0.013417190775681341, + "mean_prediction": 0.013643976428206283, + "calibration_in_the_large": 0.00022678565252494225, + "expected_calibration_error_10bin": 0.0019241983778247574, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8389025677101654 + }, + "I49": { + "valid": 2734, + "positives": 19, + "negatives": 2715, + "auroc": 0.7039449452360182, + "auprc": 0.015123318654506408, + "brier": 0.006893299236140528, + "calibration": { + "observed_rate": 0.006949524506217996, + "mean_prediction": 0.005250787538143819, + "calibration_in_the_large": -0.0016987369680741765, + "expected_calibration_error_10bin": 0.0016987369680741765, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I50": { + "valid": 2415, + "positives": 52, + "negatives": 2363, + "auroc": 0.8133321397180898, + "auprc": 0.11142726960377672, + "brier": 0.020584443745622724, + "calibration": { + "observed_rate": 0.021532091097308487, + "mean_prediction": 0.021873207109730584, + "calibration_in_the_large": 0.000341116012422097, + "expected_calibration_error_10bin": 0.006390360663967944, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.849454801266268 + }, + "I51": { + "valid": 2807, + "positives": 10, + "negatives": 2797, + "auroc": 0.8179120486235252, + "auprc": 0.026408229951313877, + "brier": 0.003530091433600938, + "calibration": { + "observed_rate": 0.003562522265764161, + "mean_prediction": 0.002526566964426887, + "calibration_in_the_large": -0.001035955301337274, + "expected_calibration_error_10bin": 0.001035955301337274, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "I61": { + "valid": 2802, + "positives": 9, + "negatives": 2793, + "auroc": 0.8328360583999682, + "auprc": 0.011615595373315732, + "brier": 0.0032006984201617475, + "calibration": { + "observed_rate": 0.0032119914346895075, + "mean_prediction": 0.0013513174892716368, + "calibration_in_the_large": -0.0018606739454178707, + "expected_calibration_error_10bin": 0.0018606739454178707, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9855786141399929 + }, + "I63": { + "valid": 2735, + "positives": 16, + "negatives": 2719, + "auroc": 0.7314269952188305, + "auprc": 0.016151624174376097, + "brier": 0.005884592765603617, + "calibration": { + "observed_rate": 0.005850091407678245, + "mean_prediction": 0.00541068374499765, + "calibration_in_the_large": -0.00043940766268059546, + "expected_calibration_error_10bin": 0.0011330855051886629, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9620119591980303 + }, + "I65": { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.6344532755298651, + "auprc": 0.009605278749297378, + "brier": 0.0021769710630753325, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.0037068830327062112, + "calibration_in_the_large": 0.001543941432129427, + "expected_calibration_error_10bin": 0.001543941432129427, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "I67": { + "valid": 2773, + "positives": 5, + "negatives": 2768, + "auroc": 0.7227601156069364, + "auprc": 0.005615929130683641, + "brier": 0.001854471894133874, + "calibration": { + "observed_rate": 0.0018031013342949874, + "mean_prediction": 0.00364332704863292, + "calibration_in_the_large": 0.0018402257143379328, + "expected_calibration_error_10bin": 0.0018402257143379328, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.975378121702427 + }, + "I69": { + "valid": 2752, + "positives": 19, + "negatives": 2733, + "auroc": 0.7834459914880505, + "auprc": 0.0329378532179984, + "brier": 0.006844959589994862, + "calibration": { + "observed_rate": 0.006904069767441861, + "mean_prediction": 0.007872904461818993, + "calibration_in_the_large": 0.0009688346943771322, + "expected_calibration_error_10bin": 0.0009688346943771335, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9679915582131551 + }, + "I70": { + "valid": 2771, + "positives": 12, + "negatives": 2759, + "auroc": 0.8145765373927751, + "auprc": 0.02564615885272996, + "brier": 0.004294506435339851, + "calibration": { + "observed_rate": 0.004330566582461205, + "mean_prediction": 0.003095767179255315, + "calibration_in_the_large": -0.00123479940320589, + "expected_calibration_error_10bin": 0.00123479940320589, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9746746394653535 + }, + "I71": { + "valid": 2769, + "positives": 5, + "negatives": 2764, + "auroc": 0.7470332850940665, + "auprc": 0.005420311783930538, + "brier": 0.0018207652511710878, + "calibration": { + "observed_rate": 0.0018057060310581437, + "mean_prediction": 0.003027730002209298, + "calibration_in_the_large": 0.0012220239711511543, + "expected_calibration_error_10bin": 0.0012220239711511543, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.97397115722828 + }, + "I72": { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.6913229018492176, + "auprc": 0.008485558459825827, + "brier": 0.00213174842509492, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.0016891650711905615, + "calibration_in_the_large": -0.0004400045526561382, + "expected_calibration_error_10bin": 0.0004400045526561382, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "I73": { + "valid": 2734, + "positives": 10, + "negatives": 2724, + "auroc": 0.838913362701909, + "auprc": 0.10995669764508868, + "brier": 0.0034933066118359823, + "calibration": { + "observed_rate": 0.0036576444769568397, + "mean_prediction": 0.003056488432717402, + "calibration_in_the_large": -0.0006011560442394379, + "expected_calibration_error_10bin": 0.0008574964036077238, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9616602180794935 + }, + "I74": { + "valid": 2821, + "positives": 5, + "negatives": 2816, + "auroc": 0.5936079545454546, + "auprc": 0.003933733917233029, + "brier": 0.0017712341045527347, + "calibration": { + "observed_rate": 0.001772421127259837, + "mean_prediction": 0.001073345406437073, + "calibration_in_the_large": -0.0006990757208227638, + "expected_calibration_error_10bin": 0.0006990757208227638, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "I77": { + "valid": 2785, + "positives": 6, + "negatives": 2779, + "auroc": 0.7153652392947103, + "auprc": 0.009040780033982643, + "brier": 0.002153009037582867, + "calibration": { + "observed_rate": 0.0021543985637342907, + "mean_prediction": 0.0025368732854326196, + "calibration_in_the_large": 0.00038247472169832897, + "expected_calibration_error_10bin": 0.00038247472169832897, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "I80": { + "valid": 2827, + "positives": 5, + "negatives": 2822, + "auroc": 0.88731396172927, + "auprc": 0.07442300232202675, + "brier": 0.0017368714599444116, + "calibration": { + "observed_rate": 0.0017686593562079944, + "mean_prediction": 0.0015915169134947066, + "calibration_in_the_large": -0.00017714244271328783, + "expected_calibration_error_10bin": 0.00028387445815098296, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "I81": { + "valid": 2826, + "positives": 9, + "negatives": 2817, + "auroc": 0.7844436555831658, + "auprc": 0.030383643803088414, + "brier": 0.003276790091765058, + "calibration": { + "observed_rate": 0.0031847133757961785, + "mean_prediction": 0.0026959404165419923, + "calibration_in_the_large": -0.0004887729592541862, + "expected_calibration_error_10bin": 0.0018837705269729727, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I82": { + "valid": 2739, + "positives": 35, + "negatives": 2704, + "auroc": 0.7461644125105663, + "auprc": 0.051564845826953996, + "brier": 0.012566560294860725, + "calibration": { + "observed_rate": 0.012778386272362175, + "mean_prediction": 0.012205258748976835, + "calibration_in_the_large": -0.0005731275233853399, + "expected_calibration_error_10bin": 0.002472551785047411, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9634189236721773 + }, + "I85": { + "valid": 2793, + "positives": 9, + "negatives": 2784, + "auroc": 0.9916187739463601, + "auprc": 0.22724347007071513, + "brier": 0.0030478511790546165, + "calibration": { + "observed_rate": 0.00322234156820623, + "mean_prediction": 0.002321324909488665, + "calibration_in_the_large": -0.000901016658717565, + "expected_calibration_error_10bin": 0.002194510243556334, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "I87": { + "valid": 2780, + "positives": 14, + "negatives": 2766, + "auroc": 0.7540285094515029, + "auprc": 0.019689394263280872, + "brier": 0.0050432310048982125, + "calibration": { + "observed_rate": 0.005035971223021582, + "mean_prediction": 0.00646043668245426, + "calibration_in_the_large": 0.0014244654594326774, + "expected_calibration_error_10bin": 0.0014244654594326774, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9778403095321843 + }, + "I89": { + "valid": 2826, + "positives": 5, + "negatives": 2821, + "auroc": 0.8384969868840837, + "auprc": 0.012026366833681596, + "brier": 0.0017628431172594498, + "calibration": { + "observed_rate": 0.0017692852087756545, + "mean_prediction": 0.000861342228195012, + "calibration_in_the_large": -0.0009079429805806425, + "expected_calibration_error_10bin": 0.0009079429805806425, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "I95": { + "valid": 2485, + "positives": 104, + "negatives": 2381, + "auroc": 0.7532912803282396, + "auprc": 0.10272954031410479, + "brier": 0.039001206092873886, + "calibration": { + "observed_rate": 0.041851106639839035, + "mean_prediction": 0.03720096656837139, + "calibration_in_the_large": -0.004650140071467648, + "expected_calibration_error_10bin": 0.007744879968618031, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.874076679563841 + }, + "I96": { + "valid": 2831, + "positives": 6, + "negatives": 2825, + "auroc": 0.8768141592920354, + "auprc": 0.03464418741930807, + "brier": 0.002091837392707981, + "calibration": { + "observed_rate": 0.0021193924408336277, + "mean_prediction": 0.00210891569547892, + "calibration_in_the_large": -1.047674535470779e-05, + "expected_calibration_error_10bin": 1.047674535470779e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "I97": { + "valid": 2740, + "positives": 12, + "negatives": 2728, + "auroc": 0.7836632453567938, + "auprc": 0.0198518139665706, + "brier": 0.004338498157352252, + "calibration": { + "observed_rate": 0.004379562043795621, + "mean_prediction": 0.003850682678491805, + "calibration_in_the_large": -0.0005288793653038157, + "expected_calibration_error_10bin": 0.0005288793653038157, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.963770664790714 + }, + "J02": { + "valid": 2825, + "positives": 3, + "negatives": 2822, + "auroc": 0.7527758091188282, + "auprc": 0.002891718154565051, + "brier": 0.0010892380697913769, + "calibration": { + "observed_rate": 0.0010619469026548673, + "mean_prediction": 0.0020825391673107954, + "calibration_in_the_large": 0.001020592264655928, + "expected_calibration_error_10bin": 0.001020592264655928, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J06": { + "valid": 2816, + "positives": 12, + "negatives": 2804, + "auroc": 0.7181407513076558, + "auprc": 0.012771749341787153, + "brier": 0.004353638292236914, + "calibration": { + "observed_rate": 0.004261363636363636, + "mean_prediction": 0.004335177641104854, + "calibration_in_the_large": 7.3814004741218e-05, + "expected_calibration_error_10bin": 0.0008996063081409291, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "J12": { + "valid": 2829, + "positives": 1, + "negatives": 2828, + "auroc": 0.9618104667609618, + "auprc": 0.009174311926605505, + "brier": 0.000511425727478625, + "calibration": { + "observed_rate": 0.0003534817956875221, + "mean_prediction": 0.003646117845796281, + "calibration_in_the_large": 0.003292636050108759, + "expected_calibration_error_10bin": 0.003292636050108759, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J15": { + "valid": 2795, + "positives": 15, + "negatives": 2780, + "auroc": 0.8092086330935252, + "auprc": 0.021292433911518072, + "brier": 0.005443614414151968, + "calibration": { + "observed_rate": 0.005366726296958855, + "mean_prediction": 0.007043134374022082, + "calibration_in_the_large": 0.0016764080770632272, + "expected_calibration_error_10bin": 0.0016764080770632261, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9831164263102357 + }, + "J18": { + "valid": 2671, + "positives": 64, + "negatives": 2607, + "auroc": 0.7712229094744918, + "auprc": 0.07567395429830687, + "brier": 0.023133746237566, + "calibration": { + "observed_rate": 0.023961063272182705, + "mean_prediction": 0.022199512766121067, + "calibration_in_the_large": -0.0017615505060616377, + "expected_calibration_error_10bin": 0.006604034555847986, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9395005276116778 + }, + "J30": { + "valid": 2815, + "positives": 7, + "negatives": 2808, + "auroc": 0.7511192511192512, + "auprc": 0.027246951481589777, + "brier": 0.002488448280821636, + "calibration": { + "observed_rate": 0.002486678507992895, + "mean_prediction": 0.003655819918031492, + "calibration_in_the_large": 0.0011691414100385967, + "expected_calibration_error_10bin": 0.0011691414100385965, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "J32": { + "valid": 2829, + "positives": 2, + "negatives": 2827, + "auroc": 0.5134418111071808, + "auprc": 0.002464204874453861, + "brier": 0.000734268627122802, + "calibration": { + "observed_rate": 0.0007069635913750442, + "mean_prediction": 0.00162307977995649, + "calibration_in_the_large": 0.0009161161885814457, + "expected_calibration_error_10bin": 0.0009161161885814457, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J38": { + "valid": 2825, + "positives": 3, + "negatives": 2822, + "auroc": 0.7491141034727143, + "auprc": 0.003813612800575015, + "brier": 0.001073431919944177, + "calibration": { + "observed_rate": 0.0010619469026548673, + "mean_prediction": 0.0019344494742443332, + "calibration_in_the_large": 0.0008725025715894659, + "expected_calibration_error_10bin": 0.0008725025715894659, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J43": { + "valid": 2804, + "positives": 10, + "negatives": 2794, + "auroc": 0.619613457408733, + "auprc": 0.005578059272177968, + "brier": 0.0035775660251663077, + "calibration": { + "observed_rate": 0.003566333808844508, + "mean_prediction": 0.002081927771423748, + "calibration_in_the_large": -0.0014844060374207598, + "expected_calibration_error_10bin": 0.0015776807805934095, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "J44": { + "valid": 2570, + "positives": 30, + "negatives": 2540, + "auroc": 0.7923228346456693, + "auprc": 0.03652192922375747, + "brier": 0.011490670404547149, + "calibration": { + "observed_rate": 0.011673151750972763, + "mean_prediction": 0.009261248287060144, + "calibration_in_the_large": -0.0024119034639126184, + "expected_calibration_error_10bin": 0.003758380877832268, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9039746746394653 + }, + "J45": { + "valid": 2518, + "positives": 25, + "negatives": 2493, + "auroc": 0.6879422382671481, + "auprc": 0.0237446220304469, + "brier": 0.009835811447897589, + "calibration": { + "observed_rate": 0.009928514694201748, + "mean_prediction": 0.009127708061388712, + "calibration_in_the_large": -0.0008008066328130357, + "expected_calibration_error_10bin": 0.0012485358343343905, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.885684136475554 + }, + "J47": { + "valid": 2825, + "positives": 7, + "negatives": 2818, + "auroc": 0.8252560073000101, + "auprc": 0.013546443612465675, + "brier": 0.0024720124822556057, + "calibration": { + "observed_rate": 0.00247787610619469, + "mean_prediction": 0.0010186658702721904, + "calibration_in_the_large": -0.0014592102359224997, + "expected_calibration_error_10bin": 0.0014592102359224997, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "J69": { + "valid": 2777, + "positives": 31, + "negatives": 2746, + "auroc": 0.777917440030073, + "auprc": 0.03729767532710347, + "brier": 0.011051023092279535, + "calibration": { + "observed_rate": 0.011163125675189053, + "mean_prediction": 0.012126218804424386, + "calibration_in_the_large": 0.0009630931292353324, + "expected_calibration_error_10bin": 0.0009630931292353327, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.976785086176574 + }, + "J81": { + "valid": 2781, + "positives": 23, + "negatives": 2758, + "auroc": 0.7689567109121291, + "auprc": 0.026574322824128256, + "brier": 0.008180670904959391, + "calibration": { + "observed_rate": 0.008270406328658756, + "mean_prediction": 0.003925230056627632, + "calibration_in_the_large": -0.004345176272031123, + "expected_calibration_error_10bin": 0.004345176272031123, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "J84": { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.9143365531265887, + "auprc": 0.0326057775403333, + "brier": 0.0024551944472128895, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.001935254032819637, + "calibration_in_the_large": -0.0005496589952243816, + "expected_calibration_error_10bin": 0.0005496589952243816, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "J90": { + "valid": 2754, + "positives": 39, + "negatives": 2715, + "auroc": 0.7097133682769042, + "auprc": 0.02889807307032642, + "brier": 0.014135657564925037, + "calibration": { + "observed_rate": 0.014161220043572984, + "mean_prediction": 0.011235919813139605, + "calibration_in_the_large": -0.0029253002304333794, + "expected_calibration_error_10bin": 0.00521886314333973, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9686950404502286 + }, + "J91": { + "valid": 2807, + "positives": 12, + "negatives": 2795, + "auroc": 0.827906976744186, + "auprc": 0.0588097631979474, + "brier": 0.004198161710500988, + "calibration": { + "observed_rate": 0.004275026718916993, + "mean_prediction": 0.004475225263832627, + "calibration_in_the_large": 0.00020019854491563384, + "expected_calibration_error_10bin": 0.0006390211043207646, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "J94": { + "valid": 2829, + "positives": 10, + "negatives": 2819, + "auroc": 0.722880454061724, + "auprc": 0.11722824560917369, + "brier": 0.003471961755101846, + "calibration": { + "observed_rate": 0.003534817956875221, + "mean_prediction": 0.0016551150209159619, + "calibration_in_the_large": -0.0018797029359592591, + "expected_calibration_error_10bin": 0.0018797029359592591, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "J95": { + "valid": 2770, + "positives": 16, + "negatives": 2754, + "auroc": 0.8030364923747276, + "auprc": 0.0361615521372103, + "brier": 0.005678576081296595, + "calibration": { + "observed_rate": 0.005776173285198556, + "mean_prediction": 0.005931148665587523, + "calibration_in_the_large": 0.00015497538038896762, + "expected_calibration_error_10bin": 0.00015497538038896752, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9743228983468167 + }, + "J96": { + "valid": 2605, + "positives": 81, + "negatives": 2524, + "auroc": 0.8148099234998337, + "auprc": 0.11144359952663123, + "brier": 0.02951289698504888, + "calibration": { + "observed_rate": 0.03109404990403071, + "mean_prediction": 0.028774752290834513, + "calibration_in_the_large": -0.0023192976131961966, + "expected_calibration_error_10bin": 0.008890683787107119, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9162856137882518 + }, + "J98": { + "valid": 2692, + "positives": 39, + "negatives": 2653, + "auroc": 0.7824813708718722, + "auprc": 0.058971292624369995, + "brier": 0.013994878983931912, + "calibration": { + "observed_rate": 0.01448736998514116, + "mean_prediction": 0.011502184138206396, + "calibration_in_the_large": -0.002985185846934763, + "expected_calibration_error_10bin": 0.003315820057276515, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9468870911009497 + }, + "K04": { + "valid": 2836, + "positives": 2, + "negatives": 2834, + "auroc": 0.9516584333098095, + "auprc": 0.011178735560799902, + "brier": 0.0007049726689106508, + "calibration": { + "observed_rate": 0.0007052186177715092, + "mean_prediction": 0.0009965819422581524, + "calibration_in_the_large": 0.0002913633244866433, + "expected_calibration_error_10bin": 0.0002913633244866433, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9975378121702427 + }, + "K12": { + "valid": 2824, + "positives": 14, + "negatives": 2810, + "auroc": 0.8713523131672598, + "auprc": 0.08617101403062198, + "brier": 0.005376133565189349, + "calibration": { + "observed_rate": 0.004957507082152974, + "mean_prediction": 0.004824767729822079, + "calibration_in_the_large": -0.00013273935233089514, + "expected_calibration_error_10bin": 0.004695750380857759, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K20": { + "valid": 2813, + "positives": 11, + "negatives": 2802, + "auroc": 0.7064434494841347, + "auprc": 0.044880903993197344, + "brier": 0.003926514486215693, + "calibration": { + "observed_rate": 0.0039104159260575895, + "mean_prediction": 0.006820600808198241, + "calibration_in_the_large": 0.002910184882140652, + "expected_calibration_error_10bin": 0.0029101848821406514, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K21": { + "valid": 2043, + "positives": 94, + "negatives": 1949, + "auroc": 0.7487855201248867, + "auprc": 0.14819850165495818, + "brier": 0.04171568596034544, + "calibration": { + "observed_rate": 0.04601076847772883, + "mean_prediction": 0.04727210400672105, + "calibration_in_the_large": 0.0012613355289922204, + "expected_calibration_error_10bin": 0.00439026161065992, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.7186071051705945 + }, + "K22": { + "valid": 2764, + "positives": 21, + "negatives": 2743, + "auroc": 0.7267503428640869, + "auprc": 0.02611228130588082, + "brier": 0.007493926002830866, + "calibration": { + "observed_rate": 0.007597684515195369, + "mean_prediction": 0.006011762121304305, + "calibration_in_the_large": -0.0015859223938910648, + "expected_calibration_error_10bin": 0.0015859223938910648, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9722124516355962 + }, + "K25": { + "valid": 2817, + "positives": 7, + "negatives": 2810, + "auroc": 0.7553634977122522, + "auprc": 0.00916526520104434, + "brier": 0.002573392990927845, + "calibration": { + "observed_rate": 0.0024849130280440185, + "mean_prediction": 0.003989733859910835, + "calibration_in_the_large": 0.0015048208318668163, + "expected_calibration_error_10bin": 0.0015048208318668166, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "K26": { + "valid": 2814, + "positives": 6, + "negatives": 2808, + "auroc": 0.9204653371320038, + "auprc": 0.03702157779075102, + "brier": 0.002106866394731074, + "calibration": { + "observed_rate": 0.0021321961620469083, + "mean_prediction": 0.0019435084384846035, + "calibration_in_the_large": -0.0001886877235623048, + "expected_calibration_error_10bin": 0.0001886877235623048, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "K29": { + "valid": 2785, + "positives": 15, + "negatives": 2770, + "auroc": 0.7137184115523466, + "auprc": 0.021324481176709098, + "brier": 0.0054252228976037625, + "calibration": { + "observed_rate": 0.005385996409335727, + "mean_prediction": 0.00910687771934307, + "calibration_in_the_large": 0.0037208813100073432, + "expected_calibration_error_10bin": 0.003720881310007343, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K30": { + "valid": 2837, + "positives": 3, + "negatives": 2834, + "auroc": 0.944954128440367, + "auprc": 0.015658630774909844, + "brier": 0.0010554075536275374, + "calibration": { + "observed_rate": 0.0010574550581600281, + "mean_prediction": 0.001665229845892072, + "calibration_in_the_large": 0.0006077747877320438, + "expected_calibration_error_10bin": 0.0006077747877320438, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9978895532887795 + }, + "K31": { + "valid": 2756, + "positives": 21, + "negatives": 2735, + "auroc": 0.8957081918690694, + "auprc": 0.06819749591327078, + "brier": 0.0074156139247549355, + "calibration": { + "observed_rate": 0.007619738751814224, + "mean_prediction": 0.006985107837492398, + "calibration_in_the_large": -0.0006346309143218255, + "expected_calibration_error_10bin": 0.0015144100155184959, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "K40": { + "valid": 2827, + "positives": 4, + "negatives": 2823, + "auroc": 0.9131243358129649, + "auprc": 0.2566895546698993, + "brier": 0.0013884023395708564, + "calibration": { + "observed_rate": 0.0014149274849663955, + "mean_prediction": 0.001967511917709558, + "calibration_in_the_large": 0.0005525844327431625, + "expected_calibration_error_10bin": 0.0005525844327431625, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9943721421034118 + }, + "K42": { + "valid": 2820, + "positives": 7, + "negatives": 2813, + "auroc": 0.8044792036971206, + "auprc": 0.02173831771056998, + "brier": 0.002479593243966887, + "calibration": { + "observed_rate": 0.0024822695035460994, + "mean_prediction": 0.0015410450682593493, + "calibration_in_the_large": -0.0009412244352867501, + "expected_calibration_error_10bin": 0.0010350482017414872, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9919099542736546 + }, + "K43": { + "valid": 2813, + "positives": 9, + "negatives": 2804, + "auroc": 0.8090030115707719, + "auprc": 0.018739547825306263, + "brier": 0.0032001128938522, + "calibration": { + "observed_rate": 0.003199431212228937, + "mean_prediction": 0.003192776111449441, + "calibration_in_the_large": -6.6551007794962355e-06, + "expected_calibration_error_10bin": 8.35550725567029e-05, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K44": { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.6648668106551476, + "auprc": 0.0065747551355753, + "brier": 0.002519535590788532, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.0035486195590706537, + "calibration_in_the_large": 0.0010351545680473144, + "expected_calibration_error_10bin": 0.0010351545680473144, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K52": { + "valid": 2749, + "positives": 39, + "negatives": 2710, + "auroc": 0.7976913615289999, + "auprc": 0.10562186011189227, + "brier": 0.014134752650054686, + "calibration": { + "observed_rate": 0.014186977082575483, + "mean_prediction": 0.014144667775349683, + "calibration_in_the_large": -4.230930722579941e-05, + "expected_calibration_error_10bin": 0.006631872222255562, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9669363348575448 + }, + "K55": { + "valid": 2815, + "positives": 10, + "negatives": 2805, + "auroc": 0.7481283422459893, + "auprc": 0.011304675354288446, + "brier": 0.0035869071457723155, + "calibration": { + "observed_rate": 0.003552397868561279, + "mean_prediction": 0.00342189567870957, + "calibration_in_the_large": -0.0001305021898517088, + "expected_calibration_error_10bin": 0.0005098648286995747, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9901512486809708 + }, + "K56": { + "valid": 2745, + "positives": 33, + "negatives": 2712, + "auroc": 0.7503687315634219, + "auprc": 0.04992496781978464, + "brier": 0.011715800343467978, + "calibration": { + "observed_rate": 0.012021857923497269, + "mean_prediction": 0.01403243223784953, + "calibration_in_the_large": 0.0020105743143522606, + "expected_calibration_error_10bin": 0.002010574314352261, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9655293703833978 + }, + "K57": { + "valid": 2741, + "positives": 26, + "negatives": 2715, + "auroc": 0.7107238985692025, + "auprc": 0.02524224319470938, + "brier": 0.00939255430745904, + "calibration": { + "observed_rate": 0.009485589201021525, + "mean_prediction": 0.005759473609774546, + "calibration_in_the_large": -0.003726115591246979, + "expected_calibration_error_10bin": 0.004010089075075789, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9641224059092508 + }, + "K58": { + "valid": 2792, + "positives": 7, + "negatives": 2785, + "auroc": 0.7413695819440882, + "auprc": 0.011882681064652147, + "brier": 0.002510473973891236, + "calibration": { + "observed_rate": 0.002507163323782235, + "mean_prediction": 0.002577637060242192, + "calibration_in_the_large": 7.047373645995697e-05, + "expected_calibration_error_10bin": 7.047373645995697e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9820612029546254 + }, + "K59": { + "valid": 2560, + "positives": 90, + "negatives": 2470, + "auroc": 0.7640935672514619, + "auprc": 0.13821315658962083, + "brier": 0.0322120171611344, + "calibration": { + "observed_rate": 0.03515625, + "mean_prediction": 0.03208880374268119, + "calibration_in_the_large": -0.0030674462573188066, + "expected_calibration_error_10bin": 0.003950787931080413, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9004572634540978 + }, + "K62": { + "valid": 2813, + "positives": 18, + "negatives": 2795, + "auroc": 0.8343669250645995, + "auprc": 0.02854554484208841, + "brier": 0.006313289152505852, + "calibration": { + "observed_rate": 0.006398862424457874, + "mean_prediction": 0.0037395180197857822, + "calibration_in_the_large": -0.002659344404672092, + "expected_calibration_error_10bin": 0.002659344404672092, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K63": { + "valid": 2810, + "positives": 21, + "negatives": 2789, + "auroc": 0.7390940599976097, + "auprc": 0.016844784587787258, + "brier": 0.007442510962491028, + "calibration": { + "observed_rate": 0.007473309608540925, + "mean_prediction": 0.004806977405512765, + "calibration_in_the_large": -0.00266633220302816, + "expected_calibration_error_10bin": 0.00266633220302816, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "K64": { + "valid": 2801, + "positives": 22, + "negatives": 2779, + "auroc": 0.8023978540351336, + "auprc": 0.030200387567851986, + "brier": 0.007876755708831446, + "calibration": { + "observed_rate": 0.00785433773652267, + "mean_prediction": 0.007537026157298766, + "calibration_in_the_large": -0.00031731157922390476, + "expected_calibration_error_10bin": 0.0023614806844595177, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9852268730214562 + }, + "K65": { + "valid": 2813, + "positives": 14, + "negatives": 2799, + "auroc": 0.7751237686929006, + "auprc": 0.03111338156635119, + "brier": 0.005179262839998131, + "calibration": { + "observed_rate": 0.004976892996800568, + "mean_prediction": 0.008715440982885795, + "calibration_in_the_large": 0.0037385479860852265, + "expected_calibration_error_10bin": 0.0037385479860852257, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9894477664438973 + }, + "K66": { + "valid": 2796, + "positives": 9, + "negatives": 2787, + "auroc": 0.7383885500139536, + "auprc": 0.01926150610015424, + "brier": 0.0032424991474192697, + "calibration": { + "observed_rate": 0.003218884120171674, + "mean_prediction": 0.0050636760690514725, + "calibration_in_the_large": 0.0018447919488797987, + "expected_calibration_error_10bin": 0.0018447919488797987, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9834681674287724 + }, + "K70": { + "valid": 2774, + "positives": 6, + "negatives": 2768, + "auroc": 0.918111753371869, + "auprc": 0.026696552897371714, + "brier": 0.0021622677748288385, + "calibration": { + "observed_rate": 0.0021629416005767843, + "mean_prediction": 0.001171083837306631, + "calibration_in_the_large": -0.0009918577632701533, + "expected_calibration_error_10bin": 0.0011556245168405698, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9757298628209637 + }, + "K72": { + "valid": 2787, + "positives": 22, + "negatives": 2765, + "auroc": 0.8937530823606773, + "auprc": 0.25808964909894666, + "brier": 0.0069816852847103825, + "calibration": { + "observed_rate": 0.007893792608539648, + "mean_prediction": 0.004409029721652773, + "calibration_in_the_large": -0.0034847628868868745, + "expected_calibration_error_10bin": 0.004598975716208445, + "nonempty_bins": 6 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9803024973619416 + }, + "K74": { + "valid": 2763, + "positives": 7, + "negatives": 2756, + "auroc": 0.9594132282811528, + "auprc": 0.048523802727020546, + "brier": 0.002549852469826135, + "calibration": { + "observed_rate": 0.0025334781035106766, + "mean_prediction": 0.0036380183385241564, + "calibration_in_the_large": 0.0011045402350134798, + "expected_calibration_error_10bin": 0.0011045402350134798, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9718607105170595 + }, + "K75": { + "valid": 2798, + "positives": 12, + "negatives": 2786, + "auroc": 0.806203637233788, + "auprc": 0.025115840164698477, + "brier": 0.004278048525515481, + "calibration": { + "observed_rate": 0.004288777698355968, + "mean_prediction": 0.0029609774259951364, + "calibration_in_the_large": -0.0013278002723608319, + "expected_calibration_error_10bin": 0.0018042514276463985, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "K76": { + "valid": 2681, + "positives": 34, + "negatives": 2647, + "auroc": 0.7981955154558991, + "auprc": 0.17024619839553634, + "brier": 0.011621271833632138, + "calibration": { + "observed_rate": 0.01268183513614323, + "mean_prediction": 0.0064716962166640754, + "calibration_in_the_large": -0.006210138919479154, + "expected_calibration_error_10bin": 0.006884613830242273, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9430179387970454 + }, + "K80": { + "valid": 2731, + "positives": 18, + "negatives": 2713, + "auroc": 0.6760863332923782, + "auprc": 0.015028009603365942, + "brier": 0.006553906039747152, + "calibration": { + "observed_rate": 0.006590992310508971, + "mean_prediction": 0.0036053995061680268, + "calibration_in_the_large": -0.0029855928043409446, + "expected_calibration_error_10bin": 0.0029855928043409446, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9606049947238833 + }, + "K81": { + "valid": 2825, + "positives": 6, + "negatives": 2819, + "auroc": 0.8670332269126168, + "auprc": 0.030229764802679467, + "brier": 0.0021058641158858285, + "calibration": { + "observed_rate": 0.0021238938053097347, + "mean_prediction": 0.00165218098983591, + "calibration_in_the_large": -0.00047171281547382475, + "expected_calibration_error_10bin": 0.00047171281547382475, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9936686598663383 + }, + "K82": { + "valid": 2824, + "positives": 4, + "negatives": 2820, + "auroc": 0.5790780141843972, + "auprc": 0.0035444307141002706, + "brier": 0.0014199006357559416, + "calibration": { + "observed_rate": 0.00141643059490085, + "mean_prediction": 0.001321556837888689, + "calibration_in_the_large": -9.487375701216095e-05, + "expected_calibration_error_10bin": 9.487375701216095e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "K83": { + "valid": 2757, + "positives": 16, + "negatives": 2741, + "auroc": 0.907675118569865, + "auprc": 0.10043772777971373, + "brier": 0.005724339337418961, + "calibration": { + "observed_rate": 0.005803409503083061, + "mean_prediction": 0.004909558302878704, + "calibration_in_the_large": -0.0008938512002043568, + "expected_calibration_error_10bin": 0.004015213385180998, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.969750263805839 + }, + "K85": { + "valid": 2779, + "positives": 10, + "negatives": 2769, + "auroc": 0.7956663055254605, + "auprc": 0.020392500224262984, + "brier": 0.0035626613657680334, + "calibration": { + "observed_rate": 0.0035984166966534724, + "mean_prediction": 0.0028724145924676004, + "calibration_in_the_large": -0.0007260021041858721, + "expected_calibration_error_10bin": 0.0007260021041858721, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9774885684136475 + }, + "K86": { + "valid": 2785, + "positives": 7, + "negatives": 2778, + "auroc": 0.7054407076005348, + "auprc": 0.014190869933497583, + "brier": 0.002528038097000442, + "calibration": { + "observed_rate": 0.0025134649910233393, + "mean_prediction": 0.0040343405863131595, + "calibration_in_the_large": 0.0015208755952898201, + "expected_calibration_error_10bin": 0.00152087559528982, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "K90": { + "valid": 2831, + "positives": 4, + "negatives": 2827, + "auroc": 0.6831446763353378, + "auprc": 0.003919324836667932, + "brier": 0.0014138271185148807, + "calibration": { + "observed_rate": 0.001412928293889085, + "mean_prediction": 0.0009823020174632127, + "calibration_in_the_large": -0.00043062627642587235, + "expected_calibration_error_10bin": 0.00043062627642587235, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "K91": { + "valid": 2768, + "positives": 26, + "negatives": 2742, + "auroc": 0.8773214385905852, + "auprc": 0.07270271554439539, + "brier": 0.009002347403942058, + "calibration": { + "observed_rate": 0.00939306358381503, + "mean_prediction": 0.008453219244679294, + "calibration_in_the_large": -0.0009398443391357356, + "expected_calibration_error_10bin": 0.0015549945062095535, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "K92": { + "valid": 2751, + "positives": 37, + "negatives": 2714, + "auroc": 0.8160787906550618, + "auprc": 0.08167951084786298, + "brier": 0.01282097956955817, + "calibration": { + "observed_rate": 0.013449654671028717, + "mean_prediction": 0.012142109837962272, + "calibration_in_the_large": -0.0013075448330664447, + "expected_calibration_error_10bin": 0.0014789051859802412, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9676398170946183 + }, + "K94": { + "valid": 2823, + "positives": 15, + "negatives": 2808, + "auroc": 0.9052231718898386, + "auprc": 0.0762862687240148, + "brier": 0.005147454555979954, + "calibration": { + "observed_rate": 0.005313496280552604, + "mean_prediction": 0.0060323824991637826, + "calibration_in_the_large": 0.0007188862186111788, + "expected_calibration_error_10bin": 0.001114248324674972, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9929651776292648 + }, + "L02": { + "valid": 2807, + "positives": 22, + "negatives": 2785, + "auroc": 0.7568467439203526, + "auprc": 0.02827394076523736, + "brier": 0.0077235910515775445, + "calibration": { + "observed_rate": 0.007837548984681154, + "mean_prediction": 0.00803615101599833, + "calibration_in_the_large": 0.0001986020313171754, + "expected_calibration_error_10bin": 0.0001986020313171754, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "L03": { + "valid": 2701, + "positives": 50, + "negatives": 2651, + "auroc": 0.7537985665786495, + "auprc": 0.0723553504689069, + "brier": 0.017818096681529647, + "calibration": { + "observed_rate": 0.018511662347278787, + "mean_prediction": 0.011001203618253215, + "calibration_in_the_large": -0.007510458729025572, + "expected_calibration_error_10bin": 0.008401743373077607, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9500527611677805 + }, + "L08": { + "valid": 2830, + "positives": 5, + "negatives": 2825, + "auroc": 0.6672566371681415, + "auprc": 0.0064329660513486875, + "brier": 0.001770699666046615, + "calibration": { + "observed_rate": 0.0017667844522968198, + "mean_prediction": 0.0019832865875782017, + "calibration_in_the_large": 0.00021650213528138194, + "expected_calibration_error_10bin": 0.00021650213528138194, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9954273654590221 + }, + "L27": { + "valid": 2818, + "positives": 12, + "negatives": 2806, + "auroc": 0.8040508434307436, + "auprc": 0.020778463354517735, + "brier": 0.004569226576524132, + "calibration": { + "observed_rate": 0.0042583392476933995, + "mean_prediction": 0.005944822602491806, + "calibration_in_the_large": 0.0016864833547984067, + "expected_calibration_error_10bin": 0.0016864833547984071, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "L29": { + "valid": 2817, + "positives": 4, + "negatives": 2813, + "auroc": 0.5263064344116601, + "auprc": 0.0026193842925246917, + "brier": 0.001532463166840436, + "calibration": { + "observed_rate": 0.0014199503017394391, + "mean_prediction": 0.004991605387646691, + "calibration_in_the_large": 0.003571655085907252, + "expected_calibration_error_10bin": 0.0035716550859072526, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9908547309180443 + }, + "L30": { + "valid": 2816, + "positives": 8, + "negatives": 2808, + "auroc": 0.744613603988604, + "auprc": 0.02526138939090923, + "brier": 0.002827116200059973, + "calibration": { + "observed_rate": 0.002840909090909091, + "mean_prediction": 0.002945834924239741, + "calibration_in_the_large": 0.00010492583333065022, + "expected_calibration_error_10bin": 0.00010492583333065005, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9905029897995076 + }, + "L50": { + "valid": 2835, + "positives": 3, + "negatives": 2832, + "auroc": 0.7410546139359698, + "auprc": 0.009871798513132576, + "brier": 0.0010580716141111357, + "calibration": { + "observed_rate": 0.0010582010582010583, + "mean_prediction": 0.001307329801376293, + "calibration_in_the_large": 0.00024912874317523483, + "expected_calibration_error_10bin": 0.00024912874317523483, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.997186071051706 + }, + "L53": { + "valid": 2829, + "positives": 0, + "negatives": 2829, + "auroc": null, + "auprc": null, + "brier": 1.0755037155608527e-05, + "calibration": { + "observed_rate": 0.0, + "mean_prediction": 0.001629317722645183, + "calibration_in_the_large": 0.001629317722645183, + "expected_calibration_error_10bin": 0.001629317722645183, + "nonempty_bins": 1 + }, + "reason": "single_class", + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "L76": { + "valid": 2793, + "positives": 15, + "negatives": 2778, + "auroc": 0.7012479001679865, + "auprc": 0.011548491874683235, + "brier": 0.00538114195777582, + "calibration": { + "observed_rate": 0.0053705692803437165, + "mean_prediction": 0.006249682795524136, + "calibration_in_the_large": 0.0008791135151804191, + "expected_calibration_error_10bin": 0.00087911351518042, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9824129440731622 + }, + "L89": { + "valid": 2798, + "positives": 25, + "negatives": 2773, + "auroc": 0.8564587089794446, + "auprc": 0.04300725783890814, + "brier": 0.00882934270227861, + "calibration": { + "observed_rate": 0.008934953538241601, + "mean_prediction": 0.006567974087705003, + "calibration_in_the_large": -0.0023669794505365984, + "expected_calibration_error_10bin": 0.0036309517238287577, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9841716496658459 + }, + "L97": { + "valid": 2789, + "positives": 13, + "negatives": 2776, + "auroc": 0.884864774994458, + "auprc": 0.07379837455530905, + "brier": 0.004652712218383152, + "calibration": { + "observed_rate": 0.004661168877733955, + "mean_prediction": 0.0066809587305091, + "calibration_in_the_large": 0.002019789852775145, + "expected_calibration_error_10bin": 0.0027943264271193635, + "nonempty_bins": 5 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "L98": { + "valid": 2824, + "positives": 8, + "negatives": 2816, + "auroc": 0.6733842329545454, + "auprc": 0.00611786916127955, + "brier": 0.002888597419506845, + "calibration": { + "observed_rate": 0.0028328611898017, + "mean_prediction": 0.005015608557395773, + "calibration_in_the_large": 0.0021827473675940733, + "expected_calibration_error_10bin": 0.0021827473675940737, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9933169187478016 + }, + "M10": { + "valid": 2713, + "positives": 15, + "negatives": 2698, + "auroc": 0.8157647640227329, + "auprc": 0.06162886336295241, + "brier": 0.005398205509601921, + "calibration": { + "observed_rate": 0.0055289347585698485, + "mean_prediction": 0.007002988470701916, + "calibration_in_the_large": 0.0014740537121320672, + "expected_calibration_error_10bin": 0.001474053712132067, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9542736545902216 + }, + "M16": { + "valid": 2790, + "positives": 3, + "negatives": 2787, + "auroc": 0.9144839134074871, + "auprc": 0.013829708459466662, + "brier": 0.0010722724935383061, + "calibration": { + "observed_rate": 0.001075268817204301, + "mean_prediction": 0.0017545234615134041, + "calibration_in_the_large": 0.000679254644309103, + "expected_calibration_error_10bin": 0.000679254644309103, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9813577207175519 + }, + "M17": { + "valid": 2733, + "positives": 13, + "negatives": 2720, + "auroc": 0.770277149321267, + "auprc": 0.011979860483669906, + "brier": 0.0047774792280857875, + "calibration": { + "observed_rate": 0.004756677643615075, + "mean_prediction": 0.003630588538028265, + "calibration_in_the_large": -0.0011260891055868104, + "expected_calibration_error_10bin": 0.0013771600245730783, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9613084769609568 + }, + "M19": { + "valid": 2674, + "positives": 37, + "negatives": 2637, + "auroc": 0.7134950650309012, + "auprc": 0.033717610044925204, + "brier": 0.013639046594287933, + "calibration": { + "observed_rate": 0.013836948391922213, + "mean_prediction": 0.013641345500602111, + "calibration_in_the_large": -0.00019560289132010238, + "expected_calibration_error_10bin": 0.0012725060938680922, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.940555750967288 + }, + "M21": { + "valid": 2821, + "positives": 3, + "negatives": 2818, + "auroc": 0.8811213626685592, + "auprc": 0.008474782948005072, + "brier": 0.0010663277112942836, + "calibration": { + "observed_rate": 0.0010634526763559022, + "mean_prediction": 0.0020162274558364122, + "calibration_in_the_large": 0.0009527747794805101, + "expected_calibration_error_10bin": 0.0009527747794805101, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9922616953921913 + }, + "M25": { + "valid": 2717, + "positives": 49, + "negatives": 2668, + "auroc": 0.6060184193617477, + "auprc": 0.024886600721341957, + "brier": 0.01788949184892047, + "calibration": { + "observed_rate": 0.0180345969819654, + "mean_prediction": 0.015661497574925482, + "calibration_in_the_large": -0.002373099407039919, + "expected_calibration_error_10bin": 0.00455075974921008, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9556806190643686 + }, + "M35": { + "valid": 2806, + "positives": 2, + "negatives": 2804, + "auroc": 0.8842724679029957, + "auprc": 0.004484924742867493, + "brier": 0.000719711230656461, + "calibration": { + "observed_rate": 0.0007127583749109052, + "mean_prediction": 0.0011922213534551439, + "calibration_in_the_large": 0.00047946297854423864, + "expected_calibration_error_10bin": 0.00047946297854423864, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "M46": { + "valid": 2814, + "positives": 7, + "negatives": 2807, + "auroc": 0.566542826606952, + "auprc": 0.0038423269226920556, + "brier": 0.0024904481181740133, + "calibration": { + "observed_rate": 0.0024875621890547263, + "mean_prediction": 0.0024372450018518553, + "calibration_in_the_large": -5.031718720287107e-05, + "expected_calibration_error_10bin": 5.031718720287107e-05, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9897995075624341 + }, + "M47": { + "valid": 2743, + "positives": 11, + "negatives": 2732, + "auroc": 0.6963263676294423, + "auprc": 0.017218678767798947, + "brier": 0.003981267491985895, + "calibration": { + "observed_rate": 0.004010207801676996, + "mean_prediction": 0.0031449293583395376, + "calibration_in_the_large": -0.000865278443337458, + "expected_calibration_error_10bin": 0.000865278443337458, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "M48": { + "valid": 2690, + "positives": 11, + "negatives": 2679, + "auroc": 0.7728799755675455, + "auprc": 0.015160689082428147, + "brier": 0.004119223703036232, + "calibration": { + "observed_rate": 0.004089219330855019, + "mean_prediction": 0.00712306530101352, + "calibration_in_the_large": 0.0030338459701585016, + "expected_calibration_error_10bin": 0.0030338459701585016, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9461836088638762 + }, + "M51": { + "valid": 2785, + "positives": 5, + "negatives": 2780, + "auroc": 0.836115107913669, + "auprc": 0.014706711556180455, + "brier": 0.0017882792672758124, + "calibration": { + "observed_rate": 0.0017953321364452424, + "mean_prediction": 0.0034326542625843282, + "calibration_in_the_large": 0.0016373221261390858, + "expected_calibration_error_10bin": 0.0016373221261390858, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9795990151248681 + }, + "M54": { + "valid": 2567, + "positives": 47, + "negatives": 2520, + "auroc": 0.7137960148598447, + "auprc": 0.054567456635316446, + "brier": 0.01777054358930818, + "calibration": { + "observed_rate": 0.018309310479158552, + "mean_prediction": 0.018218188424649846, + "calibration_in_the_large": -9.112205450870561e-05, + "expected_calibration_error_10bin": 0.002261758590453418, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9029194512838551 + }, + "M62": { + "valid": 2781, + "positives": 14, + "negatives": 2767, + "auroc": 0.7168671588620993, + "auprc": 0.013713629754333986, + "brier": 0.004999062013451568, + "calibration": { + "observed_rate": 0.005034160373966199, + "mean_prediction": 0.004199365922528229, + "calibration_in_the_large": -0.0008347944514379702, + "expected_calibration_error_10bin": 0.0008347944514379702, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9781920506507211 + }, + "M79": { + "valid": 2697, + "positives": 43, + "negatives": 2654, + "auroc": 0.726792380084471, + "auprc": 0.04649063257146071, + "brier": 0.015705449295807174, + "calibration": { + "observed_rate": 0.015943641082684465, + "mean_prediction": 0.017563545008262148, + "calibration_in_the_large": 0.0016199039255776829, + "expected_calibration_error_10bin": 0.002959641898782979, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9486457966936335 + }, + "M81": { + "valid": 2705, + "positives": 17, + "negatives": 2688, + "auroc": 0.7565432422969187, + "auprc": 0.03997113552172828, + "brier": 0.006230469905409763, + "calibration": { + "observed_rate": 0.006284658040665434, + "mean_prediction": 0.006221997390815964, + "calibration_in_the_large": -6.266064984947022e-05, + "expected_calibration_error_10bin": 0.001520874903532437, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9514597256419275 + }, + "M84": { + "valid": 2818, + "positives": 6, + "negatives": 2812, + "auroc": 0.770388809862494, + "auprc": 0.023341895787107946, + "brier": 0.00215428595875974, + "calibration": { + "observed_rate": 0.0021291696238466998, + "mean_prediction": 0.003408825342193403, + "calibration_in_the_large": 0.001279655718346703, + "expected_calibration_error_10bin": 0.001279655718346703, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9912064720365811 + }, + "M85": { + "valid": 2768, + "positives": 7, + "negatives": 2761, + "auroc": 0.719511564133078, + "auprc": 0.006398540577741503, + "brier": 0.0025505990339772756, + "calibration": { + "observed_rate": 0.0025289017341040463, + "mean_prediction": 0.003913545543545786, + "calibration_in_the_large": 0.0013846438094417394, + "expected_calibration_error_10bin": 0.0013846438094417394, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9736194161097432 + }, + "M86": { + "valid": 2803, + "positives": 17, + "negatives": 2786, + "auroc": 0.8140703517587939, + "auprc": 0.07973837891384948, + "brier": 0.005817711300418144, + "calibration": { + "observed_rate": 0.006064930431680342, + "mean_prediction": 0.004677488501220186, + "calibration_in_the_large": -0.0013874419304601565, + "expected_calibration_error_10bin": 0.0016990017561811328, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9859303552585297 + }, + "M94": { + "valid": 2819, + "positives": 3, + "negatives": 2816, + "auroc": 0.7505918560606061, + "auprc": 0.003035198815518718, + "brier": 0.0010640340447987603, + "calibration": { + "observed_rate": 0.001064207165661582, + "mean_prediction": 0.00048553010886013577, + "calibration_in_the_large": -0.0005786770568014462, + "expected_calibration_error_10bin": 0.0005786770568014462, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9915582131551178 + }, + "M96": { + "valid": 2804, + "positives": 4, + "negatives": 2800, + "auroc": 0.8752678571428572, + "auprc": 0.007242860793376809, + "brier": 0.0014420845454015127, + "calibration": { + "observed_rate": 0.0014265335235378032, + "mean_prediction": 0.003778223608670784, + "calibration_in_the_large": 0.002351690085132981, + "expected_calibration_error_10bin": 0.002351690085132981, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9862820963770664 + }, + "N12": { + "valid": 2831, + "positives": 8, + "negatives": 2823, + "auroc": 0.682031526744598, + "auprc": 0.007026984231075779, + "brier": 0.0028338296143363122, + "calibration": { + "observed_rate": 0.00282585658777817, + "mean_prediction": 0.002439515355738439, + "calibration_in_the_large": -0.0003863412320397313, + "expected_calibration_error_10bin": 0.0003863412320397313, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N13": { + "valid": 2756, + "positives": 21, + "negatives": 2735, + "auroc": 0.732480195003047, + "auprc": 0.049276289426273455, + "brier": 0.007453005961940135, + "calibration": { + "observed_rate": 0.007619738751814224, + "mean_prediction": 0.006094653535417078, + "calibration_in_the_large": -0.0015250852163971457, + "expected_calibration_error_10bin": 0.001712577811925803, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9693985226873022 + }, + "N14": { + "valid": 2826, + "positives": 8, + "negatives": 2818, + "auroc": 0.8746007806955287, + "auprc": 0.021343362927253775, + "brier": 0.0028141327715432733, + "calibration": { + "observed_rate": 0.0028308563340410475, + "mean_prediction": 0.0020069580504706824, + "calibration_in_the_large": -0.0008238982835703651, + "expected_calibration_error_10bin": 0.000897858910573108, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9940204009848751 + }, + "N17": { + "valid": 2292, + "positives": 104, + "negatives": 2188, + "auroc": 0.7903731894248348, + "auprc": 0.18292444483345172, + "brier": 0.04068261329652987, + "calibration": { + "observed_rate": 0.04537521815008726, + "mean_prediction": 0.0474192372273453, + "calibration_in_the_large": 0.0020440190772580413, + "expected_calibration_error_10bin": 0.009619443219780425, + "nonempty_bins": 7 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8061906436862469 + }, + "N18": { + "valid": 2440, + "positives": 50, + "negatives": 2390, + "auroc": 0.8576569037656904, + "auprc": 0.23562234417749042, + "brier": 0.018372866949994075, + "calibration": { + "observed_rate": 0.020491803278688523, + "mean_prediction": 0.013449408864232923, + "calibration_in_the_large": -0.0070423944144556005, + "expected_calibration_error_10bin": 0.007042394414455601, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.858248329229687 + }, + "N20": { + "valid": 2806, + "positives": 8, + "negatives": 2798, + "auroc": 0.7298963545389564, + "auprc": 0.0062516130169787965, + "brier": 0.002847108433121212, + "calibration": { + "observed_rate": 0.002851033499643621, + "mean_prediction": 0.0016629954013335057, + "calibration_in_the_large": -0.0011880380983101152, + "expected_calibration_error_10bin": 0.0011880380983101152, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.98698557861414 + }, + "N25": { + "valid": 2831, + "positives": 7, + "negatives": 2824, + "auroc": 0.9573553217320923, + "auprc": 0.08822968218116911, + "brier": 0.002411784709033137, + "calibration": { + "observed_rate": 0.002472624514305899, + "mean_prediction": 0.0015420466965701874, + "calibration_in_the_large": -0.0009305778177357118, + "expected_calibration_error_10bin": 0.0011938252474496922, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.995779106577559 + }, + "N28": { + "valid": 2789, + "positives": 10, + "negatives": 2779, + "auroc": 0.8044980208708168, + "auprc": 0.016360468027321294, + "brier": 0.003570412613363011, + "calibration": { + "observed_rate": 0.0035855145213338113, + "mean_prediction": 0.005248986677389877, + "calibration_in_the_large": 0.0016634721560560652, + "expected_calibration_error_10bin": 0.0016634721560560652, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9810059795990151 + }, + "N30": { + "valid": 2829, + "positives": 11, + "negatives": 2818, + "auroc": 0.722304664817085, + "auprc": 0.012954302871114126, + "brier": 0.003953564152898916, + "calibration": { + "observed_rate": 0.003888299752562743, + "mean_prediction": 0.004913635745286311, + "calibration_in_the_large": 0.0010253359927235683, + "expected_calibration_error_10bin": 0.0010253359927235683, + "nonempty_bins": 3 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N32": { + "valid": 2807, + "positives": 15, + "negatives": 2792, + "auroc": 0.7833572110792741, + "auprc": 0.15012745323695065, + "brier": 0.0051405819570795154, + "calibration": { + "observed_rate": 0.005343783398646241, + "mean_prediction": 0.005202542027272085, + "calibration_in_the_large": -0.00014124137137415654, + "expected_calibration_error_10bin": 0.00047308468702141396, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9873373197326768 + }, + "N39": { + "valid": 2520, + "positives": 83, + "negatives": 2437, + "auroc": 0.7562131991239476, + "auprc": 0.08688801015132078, + "brier": 0.03139661722228004, + "calibration": { + "observed_rate": 0.03293650793650794, + "mean_prediction": 0.039964391160774826, + "calibration_in_the_large": 0.0070278832242668884, + "expected_calibration_error_10bin": 0.007027883224266891, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.8863876187126275 + }, + "N40": { + "valid": 2606, + "positives": 24, + "negatives": 2582, + "auroc": 0.8307352181771237, + "auprc": 0.05979660308244971, + "brier": 0.00898453193724761, + "calibration": { + "observed_rate": 0.00920951650038373, + "mean_prediction": 0.01166106298951239, + "calibration_in_the_large": 0.00245154648912866, + "expected_calibration_error_10bin": 0.0024515464891286614, + "nonempty_bins": 4 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9166373549067885 + }, + "N73": { + "valid": 2829, + "positives": 6, + "negatives": 2823, + "auroc": 0.9026449403707639, + "auprc": 0.07560453910791495, + "brier": 0.002070821225244139, + "calibration": { + "observed_rate": 0.0021208907741251328, + "mean_prediction": 0.0012528199949298744, + "calibration_in_the_large": -0.0008680707791952583, + "expected_calibration_error_10bin": 0.0008680707791952583, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9950756243404854 + }, + "N99": { + "valid": 2799, + "positives": 6, + "negatives": 2793, + "auroc": 0.7629788757608307, + "auprc": 0.00933516242184248, + "brier": 0.0021422336179610954, + "calibration": { + "observed_rate": 0.0021436227224008574, + "mean_prediction": 0.0024670457684743312, + "calibration_in_the_large": 0.0003234230460734738, + "expected_calibration_error_10bin": 0.0003234230460734738, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9845233907843827 + }, + "O69": { + "valid": 2743, + "positives": 6, + "negatives": 2737, + "auroc": 0.9962245767872366, + "auprc": 0.34240888310655754, + "brier": 0.0020378482125342637, + "calibration": { + "observed_rate": 0.002187386073641998, + "mean_prediction": 0.00048423580082640694, + "calibration_in_the_large": -0.001703150272815591, + "expected_calibration_error_10bin": 0.0019071348270736806, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9648258881463243 + }, + "O99": { + "valid": 2652, + "positives": 3, + "negatives": 2649, + "auroc": 0.8581854787970303, + "auprc": 0.18345795618522895, + "brier": 0.0009809223674354828, + "calibration": { + "observed_rate": 0.0011312217194570137, + "mean_prediction": 0.0005424401060934324, + "calibration_in_the_large": -0.0005887816133635813, + "expected_calibration_error_10bin": 0.0005887816133635811, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9328174463594794 + }, + "Q21": { + "valid": 2810, + "positives": 5, + "negatives": 2805, + "auroc": 0.6150445632798573, + "auprc": 0.005784313027846994, + "brier": 0.0017754720760044726, + "calibration": { + "observed_rate": 0.0017793594306049821, + "mean_prediction": 0.001414553793624675, + "calibration_in_the_large": -0.0003648056369803072, + "expected_calibration_error_10bin": 0.0003648056369803072, + "nonempty_bins": 1 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9883925430882871 + }, + "U07": { + "valid": 2828, + "positives": 3, + "negatives": 2825, + "auroc": 0.7971681415929204, + "auprc": 0.01005621676155277, + "brier": 0.0010992755012293393, + "calibration": { + "observed_rate": 0.0010608203677510608, + "mean_prediction": 0.0038521469430909464, + "calibration_in_the_large": 0.0027913265753398853, + "expected_calibration_error_10bin": 0.0027913265753398853, + "nonempty_bins": 2 + }, + "reason": null, + "coverage_in_primary_cohort": 0.9947238832219486 + } + } + }, + "strata": { + "age_18_64": { + "n": 1531, + "age_sex_normalized_disease_time_brier": 1.254056155666805, + "raw_disease_time_brier_macro": 0.00442018663021282, + "macro_auroc_365d": 0.81431857678745, + "macro_auprc_365d": 0.06968212763502543, + "macro_brier_365d": 0.006274626209841673, + "scorable_auroc_diseases": 244, + "death_time_brier": 0.02052169609672598 + }, + "age_65_plus": { + "n": 1312, + "age_sex_normalized_disease_time_brier": 1.848981053944924, + "raw_disease_time_brier_macro": 0.007161734211845977, + "macro_auroc_365d": 0.7323366849318622, + "macro_auprc_365d": 0.06110560847099258, + "macro_brier_365d": 0.010010998836867147, + "scorable_auroc_diseases": 239, + "death_time_brier": 0.07777569209131263 + }, + "sex_F": { + "n": 1552, + "age_sex_normalized_disease_time_brier": 1.3648374874686984, + "raw_disease_time_brier_macro": 0.0050510019596982664, + "macro_auroc_365d": 0.79477308326915, + "macro_auprc_365d": 0.0669715675284219, + "macro_brier_365d": 0.007002153777105294, + "scorable_auroc_diseases": 244, + "death_time_brier": 0.03964140055880926 + }, + "sex_M": { + "n": 1291, + "age_sex_normalized_disease_time_brier": 1.704640016693379, + "raw_disease_time_brier_macro": 0.006301502616864501, + "macro_auroc_365d": 0.7736332949204072, + "macro_auprc_365d": 0.063393058196883, + "macro_brier_365d": 0.008995650707352715, + "scorable_auroc_diseases": 250, + "death_time_brier": 0.05572189859071855 + }, + "no_future_disease_record": { + "n": 1949, + "age_sex_normalized_disease_time_brier": 0.030203976801175435, + "raw_disease_time_brier_macro": 0.0002083792838038807, + "macro_auroc_365d": null, + "macro_auprc_365d": null, + "macro_brier_365d": 0.00035768862632149, + "scorable_auroc_diseases": 0, + "death_time_brier": 0.032940783344718 + }, + "future_disease_record": { + "n": 894, + "age_sex_normalized_disease_time_brier": 4.7855252912471515, + "raw_disease_time_brier_macro": 0.017635137173568058, + "macro_auroc_365d": 0.7194450912610031, + "macro_auprc_365d": 0.09381849695851215, + "macro_brier_365d": 0.024667820278107974, + "scorable_auroc_diseases": 258, + "death_time_brier": 0.0774707360280025 + } + }, + "confidence_intervals": null +} diff --git a/shared/package-files/31/3167b2233f402fa8bd9aca82276e3575df68cf93fe73149445ce1e5da09c7697/blob b/shared/package-files/31/3167b2233f402fa8bd9aca82276e3575df68cf93fe73149445ce1e5da09c7697/blob new file mode 100644 index 0000000000000000000000000000000000000000..25d80bcc7baaf7d16f4854e219df4da41ec5a482 --- /dev/null +++ b/shared/package-files/31/3167b2233f402fa8bd9aca82276e3575df68cf93fe73149445ce1e5da09c7697/blob @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace compositeexplicitautograd { + +TORCH_API at::Tensor & __rshift___out(at::Tensor & out, const at::Tensor & self, const at::Scalar & other); +TORCH_API at::Tensor & __rshift___outf(const at::Tensor & self, const at::Scalar & other, at::Tensor & out); +TORCH_API at::Tensor & __rshift___out(at::Tensor & out, const at::Tensor & self, const at::Tensor & other); +TORCH_API at::Tensor & __rshift___outf(const at::Tensor & self, const at::Tensor & other, at::Tensor & out); + +} // namespace compositeexplicitautograd +} // namespace at diff --git a/shared/package-files/31/316814b3ea6d990795f430f7f635b8776c7fd89f3424da0c20c7aa0f3167dd41/blob b/shared/package-files/31/316814b3ea6d990795f430f7f635b8776c7fd89f3424da0c20c7aa0f3167dd41/blob new file mode 100644 index 0000000000000000000000000000000000000000..4669ada7aefc150b780daa6de1da1d058ea84d15 Binary files /dev/null and b/shared/package-files/31/316814b3ea6d990795f430f7f635b8776c7fd89f3424da0c20c7aa0f3167dd41/blob differ diff --git a/shared/package-files/31/3169bc8e38d9d1777bbf6134a59be42e5ee7b58d7daf6b42e3ff9205c54e223c/blob b/shared/package-files/31/3169bc8e38d9d1777bbf6134a59be42e5ee7b58d7daf6b42e3ff9205c54e223c/blob new file mode 100644 index 0000000000000000000000000000000000000000..49c0081a46724c4fdf5bf7fb5c5e23de6db66f91 --- /dev/null +++ b/shared/package-files/31/3169bc8e38d9d1777bbf6134a59be42e5ee7b58d7daf6b42e3ff9205c54e223c/blob @@ -0,0 +1,29 @@ +*** Sat, 3 Sep 2016 22:21:22 *** +VAR Forecast Error Impulse Responses + + Selected Impulse Responses: "impulse variable -> response variable" + +time realcons realgdp realinv realcons realgdp realinv realcons realgdp realinv + ->realcons ->realcons ->realcons ->realgdp ->realgdp ->realgdp ->realinv ->realinv ->realinv + + point estimate 1.0000 0.0000 0.0000 0.0000 1.0000 0.0000 0.0000 0.0000 1.0000 + 1 point estimate 1.4360 -0.2650 0.3074 1.3001 0.5527 0.3346 0.9598 -0.1772 1.1834 + 2 point estimate 1.8741 -0.5225 0.5624 2.2115 0.3085 0.5053 1.6460 -0.3637 1.3083 + 3 point estimate 2.5015 -0.8588 0.8298 3.1824 -0.3207 0.9375 2.2355 -0.8614 1.7242 + 4 point estimate 2.7548 -1.0752 1.0997 3.8888 -0.8320 1.3233 2.8363 -1.2466 1.9585 + 5 point estimate 3.0072 -1.2706 1.3250 4.3222 -1.2160 1.6296 3.1346 -1.5279 2.1452 + 6 point estimate 3.2472 -1.4151 1.4988 4.5619 -1.4822 1.8703 3.2373 -1.7302 2.3021 + 7 point estimate 3.3696 -1.5065 1.6435 4.6751 -1.6282 2.0166 3.2992 -1.8363 2.3591 + 8 point estimate 3.4944 -1.5813 1.7545 4.6941 -1.6841 2.0851 3.2358 -1.8549 2.3572 + 9 point estimate 3.6060 -1.6339 1.8355 4.6646 -1.6858 2.0988 3.1209 -1.8287 2.3154 + 10 point estimate 3.6776 -1.6685 1.8981 4.6128 -1.6529 2.0699 3.0070 -1.7719 2.2340 + 11 point estimate 3.7428 -1.6947 1.9422 4.5425 -1.5992 2.0128 2.8656 -1.6926 2.1326 + 12 point estimate 3.7920 -1.7089 1.9698 4.4608 -1.5342 1.9379 2.7197 -1.6062 2.0209 + 13 point estimate 3.8190 -1.7123 1.9846 4.3707 -1.4615 1.8501 2.5797 -1.5161 1.9016 + 14 point estimate 3.8341 -1.7071 1.9866 4.2707 -1.3823 1.7538 2.4347 -1.4232 1.7808 + 15 point estimate 3.8349 -1.6925 1.9771 4.1629 -1.2980 1.6512 2.2919 -1.3309 1.6611 + 16 point estimate 3.8213 -1.6694 1.9575 4.0489 -1.2093 1.5439 2.1536 -1.2397 1.5432 + 17 point estimate 3.7978 -1.6392 1.9288 3.9300 -1.1169 1.4333 2.0175 -1.1498 1.4288 + 18 point estimate 3.7644 -1.6023 1.8919 3.8082 -1.0219 1.3205 1.8864 -1.0624 1.3185 + 19 point estimate 3.7223 -1.5598 1.8481 3.6851 -0.9254 1.2066 1.7616 -0.9780 1.2128 + 20 point estimate 3.6733 -1.5126 1.7982 3.5620 -0.8283 1.0924 1.6424 -0.8970 1.1122 diff --git a/shared/package-files/31/316e07b48299a5fed970e510e14e852f6e01889a4049723e98dd033800ed975d/blob b/shared/package-files/31/316e07b48299a5fed970e510e14e852f6e01889a4049723e98dd033800ed975d/blob new file mode 100644 index 0000000000000000000000000000000000000000..2108fa0f35547191c3db683f8cc1015e5bda4abb --- /dev/null +++ b/shared/package-files/31/316e07b48299a5fed970e510e14e852f6e01889a4049723e98dd033800ed975d/blob @@ -0,0 +1,21 @@ +from datetime import ( + timedelta, + tzinfo, +) +from typing import Iterable + +import numpy as np + +from pandas._typing import npt + +# tz_convert_from_utc_single exposed for testing +def tz_convert_from_utc_single( + utc_val: np.int64, tz: tzinfo, creso: int = ... +) -> np.int64: ... +def tz_localize_to_utc( + vals: npt.NDArray[np.int64], + tz: tzinfo | None, + ambiguous: str | bool | Iterable[bool] | None = ..., + nonexistent: str | timedelta | np.timedelta64 | None = ..., + creso: int = ..., # NPY_DATETIMEUNIT +) -> npt.NDArray[np.int64]: ... diff --git a/shared/package-files/31/31717129ac76a2fa88f59009466588c8dccec4bd6c610daf18133a246925ff8e/blob b/shared/package-files/31/31717129ac76a2fa88f59009466588c8dccec4bd6c610daf18133a246925ff8e/blob new file mode 100644 index 0000000000000000000000000000000000000000..0d6238e7574fcec014422d58333e9a0edb602695 --- /dev/null +++ b/shared/package-files/31/31717129ac76a2fa88f59009466588c8dccec4bd6c610daf18133a246925ff8e/blob @@ -0,0 +1,81 @@ +import sys +from typing import Any, Callable, Dict, Iterator, List, NamedTuple, Optional, Pattern, Text, Tuple, TypeVar + +_C = TypeVar("_C", bound=Callable[..., Any]) +_Func = TypeVar("_Func", bound=Callable[..., Any]) +_T = TypeVar("_T") + +def get_init(cls): ... + +if sys.version_info >= (3,): + from inspect import getfullargspec as getfullargspec, iscoroutinefunction as iscoroutinefunction +else: + class FullArgSpec(NamedTuple): + args: List[str] + varargs: Optional[str] + varkw: Optional[str] + defaults: Tuple[Any, ...] + kwonlyargs: List[str] + kwonlydefaults: Dict[str, Any] + annotations: Dict[str, Any] + def iscoroutinefunction(f: Callable[..., Any]) -> bool: ... + def getfullargspec(func: Any) -> FullArgSpec: ... + +if sys.version_info >= (3, 2): + from contextlib import _GeneratorContextManager +else: + from contextlib import GeneratorContextManager as _GeneratorContextManager + +DEF: Pattern[str] + +class FunctionMaker(object): + args: List[Text] + varargs: Optional[Text] + varkw: Optional[Text] + defaults: Tuple[Any, ...] + kwonlyargs: List[Text] + kwonlydefaults: Optional[Text] + shortsignature: Optional[Text] + name: Text + doc: Optional[Text] + module: Optional[Text] + annotations: Dict[Text, Any] + signature: Text + dict: Dict[Text, Any] + def __init__( + self, + func: Optional[Callable[..., Any]] = ..., + name: Optional[Text] = ..., + signature: Optional[Text] = ..., + defaults: Optional[Tuple[Any, ...]] = ..., + doc: Optional[Text] = ..., + module: Optional[Text] = ..., + funcdict: Optional[Dict[Text, Any]] = ..., + ) -> None: ... + def update(self, func: Any, **kw: Any) -> None: ... + def make( + self, src_templ: Text, evaldict: Optional[Dict[Text, Any]] = ..., addsource: bool = ..., **attrs: Any + ) -> Callable[..., Any]: ... + @classmethod + def create( + cls, + obj: Any, + body: Text, + evaldict: Dict[Text, Any], + defaults: Optional[Tuple[Any, ...]] = ..., + doc: Optional[Text] = ..., + module: Optional[Text] = ..., + addsource: bool = ..., + **attrs: Any, + ) -> Callable[..., Any]: ... + +def decorate(func: _Func, caller: Callable[..., Any], extras: Any = ...) -> _Func: ... +def decorator( + caller: Callable[..., Any], _func: Optional[Callable[..., Any]] = ... +) -> Callable[[Callable[..., Any]], Callable[..., Any]]: ... + +class ContextManager(_GeneratorContextManager[_T]): + def __call__(self, func: _C) -> _C: ... + +def contextmanager(func: Callable[..., Iterator[_T]]) -> Callable[..., ContextManager[_T]]: ... +def dispatch_on(*dispatch_args: Any) -> Callable[[Callable[..., Any]], Callable[..., Any]]: ... diff --git a/shared/package-files/31/3172875ce2f77a1ffeb6b4a893e2544e3011ff38e698a177ae34445400633fcb/blob b/shared/package-files/31/3172875ce2f77a1ffeb6b4a893e2544e3011ff38e698a177ae34445400633fcb/blob new file mode 100644 index 0000000000000000000000000000000000000000..6f6e2c2c69d25dba4d1038a2d548fbf68017f91b --- /dev/null +++ b/shared/package-files/31/3172875ce2f77a1ffeb6b4a893e2544e3011ff38e698a177ae34445400633fcb/blob @@ -0,0 +1,156 @@ +from __future__ import annotations + +import os +import sys +from abc import ABC, abstractmethod +from pathlib import Path + +if sys.version_info >= (3, 8): # pragma: no branch + from typing import Literal # pragma: no cover + + +class PlatformDirsABC(ABC): + """ + Abstract base class for platform directories. + """ + + def __init__( + self, + appname: str | None = None, + appauthor: str | None | Literal[False] = None, + version: str | None = None, + roaming: bool = False, + multipath: bool = False, + opinion: bool = True, + ): + """ + Create a new platform directory. + + :param appname: See `appname`. + :param appauthor: See `appauthor`. + :param version: See `version`. + :param roaming: See `roaming`. + :param multipath: See `multipath`. + :param opinion: See `opinion`. + """ + self.appname = appname #: The name of application. + self.appauthor = appauthor + """ + The name of the app author or distributing body for this application. Typically, it is the owning company name. + Defaults to `appname`. You may pass ``False`` to disable it. + """ + self.version = version + """ + An optional version path element to append to the path. You might want to use this if you want multiple versions + of your app to be able to run independently. If used, this would typically be ``.``. + """ + self.roaming = roaming + """ + Whether to use the roaming appdata directory on Windows. That means that for users on a Windows network setup + for roaming profiles, this user data will be synced on login (see + `here `_). + """ + self.multipath = multipath + """ + An optional parameter only applicable to Unix/Linux which indicates that the entire list of data dirs should be + returned. By default, the first item would only be returned. + """ + self.opinion = opinion #: A flag to indicating to use opinionated values. + + def _append_app_name_and_version(self, *base: str) -> str: + params = list(base[1:]) + if self.appname: + params.append(self.appname) + if self.version: + params.append(self.version) + return os.path.join(base[0], *params) + + @property + @abstractmethod + def user_data_dir(self) -> str: + """:return: data directory tied to the user""" + + @property + @abstractmethod + def site_data_dir(self) -> str: + """:return: data directory shared by users""" + + @property + @abstractmethod + def user_config_dir(self) -> str: + """:return: config directory tied to the user""" + + @property + @abstractmethod + def site_config_dir(self) -> str: + """:return: config directory shared by the users""" + + @property + @abstractmethod + def user_cache_dir(self) -> str: + """:return: cache directory tied to the user""" + + @property + @abstractmethod + def user_state_dir(self) -> str: + """:return: state directory tied to the user""" + + @property + @abstractmethod + def user_log_dir(self) -> str: + """:return: log directory tied to the user""" + + @property + @abstractmethod + def user_documents_dir(self) -> str: + """:return: documents directory tied to the user""" + + @property + @abstractmethod + def user_runtime_dir(self) -> str: + """:return: runtime directory tied to the user""" + + @property + def user_data_path(self) -> Path: + """:return: data path tied to the user""" + return Path(self.user_data_dir) + + @property + def site_data_path(self) -> Path: + """:return: data path shared by users""" + return Path(self.site_data_dir) + + @property + def user_config_path(self) -> Path: + """:return: config path tied to the user""" + return Path(self.user_config_dir) + + @property + def site_config_path(self) -> Path: + """:return: config path shared by the users""" + return Path(self.site_config_dir) + + @property + def user_cache_path(self) -> Path: + """:return: cache path tied to the user""" + return Path(self.user_cache_dir) + + @property + def user_state_path(self) -> Path: + """:return: state path tied to the user""" + return Path(self.user_state_dir) + + @property + def user_log_path(self) -> Path: + """:return: log path tied to the user""" + return Path(self.user_log_dir) + + @property + def user_documents_path(self) -> Path: + """:return: documents path tied to the user""" + return Path(self.user_documents_dir) + + @property + def user_runtime_path(self) -> Path: + """:return: runtime path tied to the user""" + return Path(self.user_runtime_dir) diff --git a/shared/package-files/31/3173897e18eb2c0bbe502c9783a61131801cee7930e9201f918ebafd1286f44b/blob b/shared/package-files/31/3173897e18eb2c0bbe502c9783a61131801cee7930e9201f918ebafd1286f44b/blob new file mode 100644 index 0000000000000000000000000000000000000000..90c21da16dd4225229a2785e1ccd69b383e491de --- /dev/null +++ b/shared/package-files/31/3173897e18eb2c0bbe502c9783a61131801cee7930e9201f918ebafd1286f44b/blob @@ -0,0 +1,771 @@ +"""Tools for polynomial factorization routines in characteristic zero. """ + +from sympy.polys.rings import ring, xring +from sympy.polys.domains import FF, ZZ, QQ, ZZ_I, QQ_I, RR, EX + +from sympy.polys import polyconfig as config +from sympy.polys.polyerrors import DomainError +from sympy.polys.polyclasses import ANP +from sympy.polys.specialpolys import f_polys, w_polys + +from sympy.core.numbers import I +from sympy.functions.elementary.miscellaneous import sqrt +from sympy.functions.elementary.trigonometric import sin +from sympy.ntheory.generate import nextprime +from sympy.testing.pytest import raises, XFAIL + + +f_0, f_1, f_2, f_3, f_4, f_5, f_6 = f_polys() +w_1, w_2 = w_polys() + +def test_dup_trial_division(): + R, x = ring("x", ZZ) + assert R.dup_trial_division(x**5 + 8*x**4 + 25*x**3 + 38*x**2 + 28*x + 8, (x + 1, x + 2)) == [(x + 1, 2), (x + 2, 3)] + + +def test_dmp_trial_division(): + R, x, y = ring("x,y", ZZ) + assert R.dmp_trial_division(x**5 + 8*x**4 + 25*x**3 + 38*x**2 + 28*x + 8, (x + 1, x + 2)) == [(x + 1, 2), (x + 2, 3)] + + +def test_dup_zz_mignotte_bound(): + R, x = ring("x", ZZ) + assert R.dup_zz_mignotte_bound(2*x**2 + 3*x + 4) == 6 + assert R.dup_zz_mignotte_bound(x**3 + 14*x**2 + 56*x + 64) == 152 + + +def test_dmp_zz_mignotte_bound(): + R, x, y = ring("x,y", ZZ) + assert R.dmp_zz_mignotte_bound(2*x**2 + 3*x + 4) == 32 + + +def test_dup_zz_hensel_step(): + R, x = ring("x", ZZ) + + f = x**4 - 1 + g = x**3 + 2*x**2 - x - 2 + h = x - 2 + s = -2 + t = 2*x**2 - 2*x - 1 + + G, H, S, T = R.dup_zz_hensel_step(5, f, g, h, s, t) + + assert G == x**3 + 7*x**2 - x - 7 + assert H == x - 7 + assert S == 8 + assert T == -8*x**2 - 12*x - 1 + + +def test_dup_zz_hensel_lift(): + R, x = ring("x", ZZ) + + f = x**4 - 1 + F = [x - 1, x - 2, x + 2, x + 1] + + assert R.dup_zz_hensel_lift(ZZ(5), f, F, 4) == \ + [x - 1, x - 182, x + 182, x + 1] + + +def test_dup_zz_irreducible_p(): + R, x = ring("x", ZZ) + + assert R.dup_zz_irreducible_p(3*x**4 + 2*x**3 + 6*x**2 + 8*x + 7) is None + assert R.dup_zz_irreducible_p(3*x**4 + 2*x**3 + 6*x**2 + 8*x + 4) is None + + assert R.dup_zz_irreducible_p(3*x**4 + 2*x**3 + 6*x**2 + 8*x + 10) is True + assert R.dup_zz_irreducible_p(3*x**4 + 2*x**3 + 6*x**2 + 8*x + 14) is True + + +def test_dup_cyclotomic_p(): + R, x = ring("x", ZZ) + + assert R.dup_cyclotomic_p(x - 1) is True + assert R.dup_cyclotomic_p(x + 1) is True + assert R.dup_cyclotomic_p(x**2 + x + 1) is True + assert R.dup_cyclotomic_p(x**2 + 1) is True + assert R.dup_cyclotomic_p(x**4 + x**3 + x**2 + x + 1) is True + assert R.dup_cyclotomic_p(x**2 - x + 1) is True + assert R.dup_cyclotomic_p(x**6 + x**5 + x**4 + x**3 + x**2 + x + 1) is True + assert R.dup_cyclotomic_p(x**4 + 1) is True + assert R.dup_cyclotomic_p(x**6 + x**3 + 1) is True + + assert R.dup_cyclotomic_p(0) is False + assert R.dup_cyclotomic_p(1) is False + assert R.dup_cyclotomic_p(x) is False + assert R.dup_cyclotomic_p(x + 2) is False + assert R.dup_cyclotomic_p(3*x + 1) is False + assert R.dup_cyclotomic_p(x**2 - 1) is False + + f = x**16 + x**14 - x**10 + x**8 - x**6 + x**2 + 1 + assert R.dup_cyclotomic_p(f) is False + + g = x**16 + x**14 - x**10 - x**8 - x**6 + x**2 + 1 + assert R.dup_cyclotomic_p(g) is True + + R, x = ring("x", QQ) + assert R.dup_cyclotomic_p(x**2 + x + 1) is True + assert R.dup_cyclotomic_p(QQ(1,2)*x**2 + x + 1) is False + + R, x = ring("x", ZZ["y"]) + assert R.dup_cyclotomic_p(x**2 + x + 1) is False + + +def test_dup_zz_cyclotomic_poly(): + R, x = ring("x", ZZ) + + assert R.dup_zz_cyclotomic_poly(1) == x - 1 + assert R.dup_zz_cyclotomic_poly(2) == x + 1 + assert R.dup_zz_cyclotomic_poly(3) == x**2 + x + 1 + assert R.dup_zz_cyclotomic_poly(4) == x**2 + 1 + assert R.dup_zz_cyclotomic_poly(5) == x**4 + x**3 + x**2 + x + 1 + assert R.dup_zz_cyclotomic_poly(6) == x**2 - x + 1 + assert R.dup_zz_cyclotomic_poly(7) == x**6 + x**5 + x**4 + x**3 + x**2 + x + 1 + assert R.dup_zz_cyclotomic_poly(8) == x**4 + 1 + assert R.dup_zz_cyclotomic_poly(9) == x**6 + x**3 + 1 + + +def test_dup_zz_cyclotomic_factor(): + R, x = ring("x", ZZ) + + assert R.dup_zz_cyclotomic_factor(0) is None + assert R.dup_zz_cyclotomic_factor(1) is None + + assert R.dup_zz_cyclotomic_factor(2*x**10 - 1) is None + assert R.dup_zz_cyclotomic_factor(x**10 - 3) is None + assert R.dup_zz_cyclotomic_factor(x**10 + x**5 - 1) is None + + assert R.dup_zz_cyclotomic_factor(x + 1) == [x + 1] + assert R.dup_zz_cyclotomic_factor(x - 1) == [x - 1] + + assert R.dup_zz_cyclotomic_factor(x**2 + 1) == [x**2 + 1] + assert R.dup_zz_cyclotomic_factor(x**2 - 1) == [x - 1, x + 1] + + assert R.dup_zz_cyclotomic_factor(x**27 + 1) == \ + [x + 1, x**2 - x + 1, x**6 - x**3 + 1, x**18 - x**9 + 1] + assert R.dup_zz_cyclotomic_factor(x**27 - 1) == \ + [x - 1, x**2 + x + 1, x**6 + x**3 + 1, x**18 + x**9 + 1] + + +def test_dup_zz_factor(): + R, x = ring("x", ZZ) + + assert R.dup_zz_factor(0) == (0, []) + assert R.dup_zz_factor(7) == (7, []) + assert R.dup_zz_factor(-7) == (-7, []) + + assert R.dup_zz_factor_sqf(0) == (0, []) + assert R.dup_zz_factor_sqf(7) == (7, []) + assert R.dup_zz_factor_sqf(-7) == (-7, []) + + assert R.dup_zz_factor(2*x + 4) == (2, [(x + 2, 1)]) + assert R.dup_zz_factor_sqf(2*x + 4) == (2, [x + 2]) + + f = x**4 + x + 1 + + for i in range(0, 20): + assert R.dup_zz_factor(f) == (1, [(f, 1)]) + + assert R.dup_zz_factor(x**2 + 2*x + 2) == \ + (1, [(x**2 + 2*x + 2, 1)]) + + assert R.dup_zz_factor(18*x**2 + 12*x + 2) == \ + (2, [(3*x + 1, 2)]) + + assert R.dup_zz_factor(-9*x**2 + 1) == \ + (-1, [(3*x - 1, 1), + (3*x + 1, 1)]) + + assert R.dup_zz_factor_sqf(-9*x**2 + 1) == \ + (-1, [3*x - 1, + 3*x + 1]) + + assert R.dup_zz_factor(x**3 - 6*x**2 + 11*x - 6) == \ + (1, [(x - 3, 1), + (x - 2, 1), + (x - 1, 1)]) + + assert R.dup_zz_factor_sqf(x**3 - 6*x**2 + 11*x - 6) == \ + (1, [x - 3, + x - 2, + x - 1]) + + assert R.dup_zz_factor(3*x**3 + 10*x**2 + 13*x + 10) == \ + (1, [(x + 2, 1), + (3*x**2 + 4*x + 5, 1)]) + + assert R.dup_zz_factor_sqf(3*x**3 + 10*x**2 + 13*x + 10) == \ + (1, [x + 2, + 3*x**2 + 4*x + 5]) + + assert R.dup_zz_factor(-x**6 + x**2) == \ + (-1, [(x - 1, 1), + (x + 1, 1), + (x, 2), + (x**2 + 1, 1)]) + + f = 1080*x**8 + 5184*x**7 + 2099*x**6 + 744*x**5 + 2736*x**4 - 648*x**3 + 129*x**2 - 324 + + assert R.dup_zz_factor(f) == \ + (1, [(5*x**4 + 24*x**3 + 9*x**2 + 12, 1), + (216*x**4 + 31*x**2 - 27, 1)]) + + f = -29802322387695312500000000000000000000*x**25 \ + + 2980232238769531250000000000000000*x**20 \ + + 1743435859680175781250000000000*x**15 \ + + 114142894744873046875000000*x**10 \ + - 210106372833251953125*x**5 \ + + 95367431640625 + + assert R.dup_zz_factor(f) == \ + (-95367431640625, [(5*x - 1, 1), + (100*x**2 + 10*x - 1, 2), + (625*x**4 + 125*x**3 + 25*x**2 + 5*x + 1, 1), + (10000*x**4 - 3000*x**3 + 400*x**2 - 20*x + 1, 2), + (10000*x**4 + 2000*x**3 + 400*x**2 + 30*x + 1, 2)]) + + f = x**10 - 1 + + config.setup('USE_CYCLOTOMIC_FACTOR', True) + F_0 = R.dup_zz_factor(f) + + config.setup('USE_CYCLOTOMIC_FACTOR', False) + F_1 = R.dup_zz_factor(f) + + assert F_0 == F_1 == \ + (1, [(x - 1, 1), + (x + 1, 1), + (x**4 - x**3 + x**2 - x + 1, 1), + (x**4 + x**3 + x**2 + x + 1, 1)]) + + config.setup('USE_CYCLOTOMIC_FACTOR') + + f = x**10 + 1 + + config.setup('USE_CYCLOTOMIC_FACTOR', True) + F_0 = R.dup_zz_factor(f) + + config.setup('USE_CYCLOTOMIC_FACTOR', False) + F_1 = R.dup_zz_factor(f) + + assert F_0 == F_1 == \ + (1, [(x**2 + 1, 1), + (x**8 - x**6 + x**4 - x**2 + 1, 1)]) + + config.setup('USE_CYCLOTOMIC_FACTOR') + +def test_dmp_zz_wang(): + R, x,y,z = ring("x,y,z", ZZ) + UV, _x = ring("x", ZZ) + + p = ZZ(nextprime(R.dmp_zz_mignotte_bound(w_1))) + assert p == 6291469 + + t_1, k_1, e_1 = y, 1, ZZ(-14) + t_2, k_2, e_2 = z, 2, ZZ(3) + t_3, k_3, e_3 = y + z, 2, ZZ(-11) + t_4, k_4, e_4 = y - z, 1, ZZ(-17) + + T = [t_1, t_2, t_3, t_4] + K = [k_1, k_2, k_3, k_4] + E = [e_1, e_2, e_3, e_4] + + T = zip([ t.drop(x) for t in T ], K) + + A = [ZZ(-14), ZZ(3)] + + S = R.dmp_eval_tail(w_1, A) + cs, s = UV.dup_primitive(S) + + assert cs == 1 and s == S == \ + 1036728*_x**6 + 915552*_x**5 + 55748*_x**4 + 105621*_x**3 - 17304*_x**2 - 26841*_x - 644 + + assert R.dmp_zz_wang_non_divisors(E, cs, ZZ(4)) == [7, 3, 11, 17] + assert UV.dup_sqf_p(s) and UV.dup_degree(s) == R.dmp_degree(w_1) + + _, H = UV.dup_zz_factor_sqf(s) + + h_1 = 44*_x**2 + 42*_x + 1 + h_2 = 126*_x**2 - 9*_x + 28 + h_3 = 187*_x**2 - 23 + + assert H == [h_1, h_2, h_3] + + LC = [ lc.drop(x) for lc in [-4*y - 4*z, -y*z**2, y**2 - z**2] ] + + assert R.dmp_zz_wang_lead_coeffs(w_1, T, cs, E, H, A) == (w_1, H, LC) + + factors = R.dmp_zz_wang_hensel_lifting(w_1, H, LC, A, p) + assert R.dmp_expand(factors) == w_1 + + +@XFAIL +def test_dmp_zz_wang_fail(): + R, x,y,z = ring("x,y,z", ZZ) + UV, _x = ring("x", ZZ) + + p = ZZ(nextprime(R.dmp_zz_mignotte_bound(w_1))) + assert p == 6291469 + + H_1 = [44*x**2 + 42*x + 1, 126*x**2 - 9*x + 28, 187*x**2 - 23] + H_2 = [-4*x**2*y - 12*x**2 - 3*x*y + 1, -9*x**2*y - 9*x - 2*y, x**2*y**2 - 9*x**2 + y - 9] + H_3 = [-4*x**2*y - 12*x**2 - 3*x*y + 1, -9*x**2*y - 9*x - 2*y, x**2*y**2 - 9*x**2 + y - 9] + + c_1 = -70686*x**5 - 5863*x**4 - 17826*x**3 + 2009*x**2 + 5031*x + 74 + c_2 = 9*x**5*y**4 + 12*x**5*y**3 - 45*x**5*y**2 - 108*x**5*y - 324*x**5 + 18*x**4*y**3 - 216*x**4*y**2 - 810*x**4*y + 2*x**3*y**4 + 9*x**3*y**3 - 252*x**3*y**2 - 288*x**3*y - 945*x**3 - 30*x**2*y**2 - 414*x**2*y + 2*x*y**3 - 54*x*y**2 - 3*x*y + 81*x + 12*y + c_3 = -36*x**4*y**2 - 108*x**4*y - 27*x**3*y**2 - 36*x**3*y - 108*x**3 - 8*x**2*y**2 - 42*x**2*y - 6*x*y**2 + 9*x + 2*y + + assert R.dmp_zz_diophantine(H_1, c_1, [], 5, p) == [-3*x, -2, 1] + assert R.dmp_zz_diophantine(H_2, c_2, [ZZ(-14)], 5, p) == [-x*y, -3*x, -6] + assert R.dmp_zz_diophantine(H_3, c_3, [ZZ(-14)], 5, p) == [0, 0, -1] + + +def test_issue_6355(): + # This tests a bug in the Wang algorithm that occurred only with a very + # specific set of random numbers. + random_sequence = [-1, -1, 0, 0, 0, 0, -1, -1, 0, -1, 3, -1, 3, 3, 3, 3, -1, 3] + + R, x, y, z = ring("x,y,z", ZZ) + f = 2*x**2 + y*z - y - z**2 + z + + assert R.dmp_zz_wang(f, seed=random_sequence) == [f] + + +def test_dmp_zz_factor(): + R, x = ring("x", ZZ) + assert R.dmp_zz_factor(0) == (0, []) + assert R.dmp_zz_factor(7) == (7, []) + assert R.dmp_zz_factor(-7) == (-7, []) + + assert R.dmp_zz_factor(x**2 - 9) == (1, [(x - 3, 1), (x + 3, 1)]) + + R, x, y = ring("x,y", ZZ) + assert R.dmp_zz_factor(0) == (0, []) + assert R.dmp_zz_factor(7) == (7, []) + assert R.dmp_zz_factor(-7) == (-7, []) + + assert R.dmp_zz_factor(x) == (1, [(x, 1)]) + assert R.dmp_zz_factor(4*x) == (4, [(x, 1)]) + assert R.dmp_zz_factor(4*x + 2) == (2, [(2*x + 1, 1)]) + assert R.dmp_zz_factor(x*y + 1) == (1, [(x*y + 1, 1)]) + assert R.dmp_zz_factor(y**2 + 1) == (1, [(y**2 + 1, 1)]) + assert R.dmp_zz_factor(y**2 - 1) == (1, [(y - 1, 1), (y + 1, 1)]) + + assert R.dmp_zz_factor(x**2*y**2 + 6*x**2*y + 9*x**2 - 1) == (1, [(x*y + 3*x - 1, 1), (x*y + 3*x + 1, 1)]) + assert R.dmp_zz_factor(x**2*y**2 - 9) == (1, [(x*y - 3, 1), (x*y + 3, 1)]) + + R, x, y, z = ring("x,y,z", ZZ) + assert R.dmp_zz_factor(x**2*y**2*z**2 - 9) == \ + (1, [(x*y*z - 3, 1), + (x*y*z + 3, 1)]) + + R, x, y, z, u = ring("x,y,z,u", ZZ) + assert R.dmp_zz_factor(x**2*y**2*z**2*u**2 - 9) == \ + (1, [(x*y*z*u - 3, 1), + (x*y*z*u + 3, 1)]) + + R, x, y, z = ring("x,y,z", ZZ) + assert R.dmp_zz_factor(f_1) == \ + (1, [(x + y*z + 20, 1), + (x*y + z + 10, 1), + (x*z + y + 30, 1)]) + + assert R.dmp_zz_factor(f_2) == \ + (1, [(x**2*y**2 + x**2*z**2 + y + 90, 1), + (x**3*y + x**3*z + z - 11, 1)]) + + assert R.dmp_zz_factor(f_3) == \ + (1, [(x**2*y**2 + x*z**4 + x + z, 1), + (x**3 + x*y*z + y**2 + y*z**3, 1)]) + + assert R.dmp_zz_factor(f_4) == \ + (-1, [(x*y**3 + z**2, 1), + (x**2*z + y**4*z**2 + 5, 1), + (x**3*y - z**2 - 3, 1), + (x**3*y**4 + z**2, 1)]) + + assert R.dmp_zz_factor(f_5) == \ + (-1, [(x + y - z, 3)]) + + R, x, y, z, t = ring("x,y,z,t", ZZ) + assert R.dmp_zz_factor(f_6) == \ + (1, [(47*x*y + z**3*t**2 - t**2, 1), + (45*x**3 - 9*y**3 - y**2 + 3*z**3 + 2*z*t, 1)]) + + R, x, y, z = ring("x,y,z", ZZ) + assert R.dmp_zz_factor(w_1) == \ + (1, [(x**2*y**2 - x**2*z**2 + y - z**2, 1), + (x**2*y*z**2 + 3*x*z + 2*y, 1), + (4*x**2*y + 4*x**2*z + x*y*z - 1, 1)]) + + R, x, y = ring("x,y", ZZ) + f = -12*x**16*y + 240*x**12*y**3 - 768*x**10*y**4 + 1080*x**8*y**5 - 768*x**6*y**6 + 240*x**4*y**7 - 12*y**9 + + assert R.dmp_zz_factor(f) == \ + (-12, [(y, 1), + (x**2 - y, 6), + (x**4 + 6*x**2*y + y**2, 1)]) + + +def test_dup_qq_i_factor(): + R, x = ring("x", QQ_I) + i = QQ_I(0, 1) + + assert R.dup_qq_i_factor(x**2 - 2) == (QQ_I(1, 0), [(x**2 - 2, 1)]) + + assert R.dup_qq_i_factor(x**2 - 1) == (QQ_I(1, 0), [(x - 1, 1), (x + 1, 1)]) + + assert R.dup_qq_i_factor(x**2 + 1) == (QQ_I(1, 0), [(x - i, 1), (x + i, 1)]) + + assert R.dup_qq_i_factor(x**2/4 + 1) == \ + (QQ_I(QQ(1, 4), 0), [(x - 2*i, 1), (x + 2*i, 1)]) + + assert R.dup_qq_i_factor(x**2 + 4) == \ + (QQ_I(1, 0), [(x - 2*i, 1), (x + 2*i, 1)]) + + assert R.dup_qq_i_factor(x**2 + 2*x + 1) == \ + (QQ_I(1, 0), [(x + 1, 2)]) + + assert R.dup_qq_i_factor(x**2 + 2*i*x - 1) == \ + (QQ_I(1, 0), [(x + i, 2)]) + + f = 8192*x**2 + x*(22656 + 175232*i) - 921416 + 242313*i + + assert R.dup_qq_i_factor(f) == \ + (QQ_I(8192, 0), [(x + QQ_I(QQ(177, 128), QQ(1369, 128)), 2)]) + + +def test_dmp_qq_i_factor(): + R, x, y = ring("x, y", QQ_I) + i = QQ_I(0, 1) + + assert R.dmp_qq_i_factor(x**2 + 2*y**2) == \ + (QQ_I(1, 0), [(x**2 + 2*y**2, 1)]) + + assert R.dmp_qq_i_factor(x**2 + y**2) == \ + (QQ_I(1, 0), [(x - i*y, 1), (x + i*y, 1)]) + + assert R.dmp_qq_i_factor(x**2 + y**2/4) == \ + (QQ_I(1, 0), [(x - i*y/2, 1), (x + i*y/2, 1)]) + + assert R.dmp_qq_i_factor(4*x**2 + y**2) == \ + (QQ_I(4, 0), [(x - i*y/2, 1), (x + i*y/2, 1)]) + + +def test_dup_zz_i_factor(): + R, x = ring("x", ZZ_I) + i = ZZ_I(0, 1) + + assert R.dup_zz_i_factor(x**2 - 2) == (ZZ_I(1, 0), [(x**2 - 2, 1)]) + + assert R.dup_zz_i_factor(x**2 - 1) == (ZZ_I(1, 0), [(x - 1, 1), (x + 1, 1)]) + + assert R.dup_zz_i_factor(x**2 + 1) == (ZZ_I(1, 0), [(x - i, 1), (x + i, 1)]) + + assert R.dup_zz_i_factor(x**2 + 4) == \ + (ZZ_I(1, 0), [(x - 2*i, 1), (x + 2*i, 1)]) + + assert R.dup_zz_i_factor(x**2 + 2*x + 1) == \ + (ZZ_I(1, 0), [(x + 1, 2)]) + + assert R.dup_zz_i_factor(x**2 + 2*i*x - 1) == \ + (ZZ_I(1, 0), [(x + i, 2)]) + + f = 8192*x**2 + x*(22656 + 175232*i) - 921416 + 242313*i + + assert R.dup_zz_i_factor(f) == \ + (ZZ_I(0, 1), [((64 - 64*i)*x + (773 + 596*i), 2)]) + + +def test_dmp_zz_i_factor(): + R, x, y = ring("x, y", ZZ_I) + i = ZZ_I(0, 1) + + assert R.dmp_zz_i_factor(x**2 + 2*y**2) == \ + (ZZ_I(1, 0), [(x**2 + 2*y**2, 1)]) + + assert R.dmp_zz_i_factor(x**2 + y**2) == \ + (ZZ_I(1, 0), [(x - i*y, 1), (x + i*y, 1)]) + + assert R.dmp_zz_i_factor(4*x**2 + y**2) == \ + (ZZ_I(1, 0), [(2*x - i*y, 1), (2*x + i*y, 1)]) + + +def test_dup_ext_factor(): + R, x = ring("x", QQ.algebraic_field(I)) + def anp(element): + return ANP(element, [QQ(1), QQ(0), QQ(1)], QQ) + + assert R.dup_ext_factor(0) == (anp([]), []) + + f = anp([QQ(1)])*x + anp([QQ(1)]) + + assert R.dup_ext_factor(f) == (anp([QQ(1)]), [(f, 1)]) + + g = anp([QQ(2)])*x + anp([QQ(2)]) + + assert R.dup_ext_factor(g) == (anp([QQ(2)]), [(f, 1)]) + + f = anp([QQ(7)])*x**4 + anp([QQ(1, 1)]) + g = anp([QQ(1)])*x**4 + anp([QQ(1, 7)]) + + assert R.dup_ext_factor(f) == (anp([QQ(7)]), [(g, 1)]) + + f = anp([QQ(1)])*x**4 + anp([QQ(1)]) + + assert R.dup_ext_factor(f) == \ + (anp([QQ(1, 1)]), [(anp([QQ(1)])*x**2 + anp([QQ(-1), QQ(0)]), 1), + (anp([QQ(1)])*x**2 + anp([QQ( 1), QQ(0)]), 1)]) + + f = anp([QQ(4, 1)])*x**2 + anp([QQ(9, 1)]) + + assert R.dup_ext_factor(f) == \ + (anp([QQ(4, 1)]), [(anp([QQ(1, 1)])*x + anp([-QQ(3, 2), QQ(0, 1)]), 1), + (anp([QQ(1, 1)])*x + anp([ QQ(3, 2), QQ(0, 1)]), 1)]) + + f = anp([QQ(4, 1)])*x**4 + anp([QQ(8, 1)])*x**3 + anp([QQ(77, 1)])*x**2 + anp([QQ(18, 1)])*x + anp([QQ(153, 1)]) + + assert R.dup_ext_factor(f) == \ + (anp([QQ(4, 1)]), [(anp([QQ(1, 1)])*x + anp([-QQ(4, 1), QQ(1, 1)]), 1), + (anp([QQ(1, 1)])*x + anp([-QQ(3, 2), QQ(0, 1)]), 1), + (anp([QQ(1, 1)])*x + anp([ QQ(3, 2), QQ(0, 1)]), 1), + (anp([QQ(1, 1)])*x + anp([ QQ(4, 1), QQ(1, 1)]), 1)]) + + R, x = ring("x", QQ.algebraic_field(sqrt(2))) + def anp(element): + return ANP(element, [QQ(1), QQ(0), QQ(-2)], QQ) + + f = anp([QQ(1)])*x**4 + anp([QQ(1, 1)]) + + assert R.dup_ext_factor(f) == \ + (anp([QQ(1)]), [(anp([QQ(1)])*x**2 + anp([QQ(-1), QQ(0)])*x + anp([QQ(1)]), 1), + (anp([QQ(1)])*x**2 + anp([QQ( 1), QQ(0)])*x + anp([QQ(1)]), 1)]) + + f = anp([QQ(1, 1)])*x**2 + anp([QQ(2), QQ(0)])*x + anp([QQ(2, 1)]) + + assert R.dup_ext_factor(f) == \ + (anp([QQ(1, 1)]), [(anp([1])*x + anp([1, 0]), 2)]) + + assert R.dup_ext_factor(f**3) == \ + (anp([QQ(1, 1)]), [(anp([1])*x + anp([1, 0]), 6)]) + + f *= anp([QQ(2, 1)]) + + assert R.dup_ext_factor(f) == \ + (anp([QQ(2, 1)]), [(anp([1])*x + anp([1, 0]), 2)]) + + assert R.dup_ext_factor(f**3) == \ + (anp([QQ(8, 1)]), [(anp([1])*x + anp([1, 0]), 6)]) + + +def test_dmp_ext_factor(): + R, x,y = ring("x,y", QQ.algebraic_field(sqrt(2))) + def anp(x): + return ANP(x, [QQ(1), QQ(0), QQ(-2)], QQ) + + assert R.dmp_ext_factor(0) == (anp([]), []) + + f = anp([QQ(1)])*x + anp([QQ(1)]) + + assert R.dmp_ext_factor(f) == (anp([QQ(1)]), [(f, 1)]) + + g = anp([QQ(2)])*x + anp([QQ(2)]) + + assert R.dmp_ext_factor(g) == (anp([QQ(2)]), [(f, 1)]) + + f = anp([QQ(1)])*x**2 + anp([QQ(-2)])*y**2 + + assert R.dmp_ext_factor(f) == \ + (anp([QQ(1)]), [(anp([QQ(1)])*x + anp([QQ(-1), QQ(0)])*y, 1), + (anp([QQ(1)])*x + anp([QQ( 1), QQ(0)])*y, 1)]) + + f = anp([QQ(2)])*x**2 + anp([QQ(-4)])*y**2 + + assert R.dmp_ext_factor(f) == \ + (anp([QQ(2)]), [(anp([QQ(1)])*x + anp([QQ(-1), QQ(0)])*y, 1), + (anp([QQ(1)])*x + anp([QQ( 1), QQ(0)])*y, 1)]) + + +def test_dup_factor_list(): + R, x = ring("x", ZZ) + assert R.dup_factor_list(0) == (0, []) + assert R.dup_factor_list(7) == (7, []) + + R, x = ring("x", QQ) + assert R.dup_factor_list(0) == (0, []) + assert R.dup_factor_list(QQ(1, 7)) == (QQ(1, 7), []) + + R, x = ring("x", ZZ['t']) + assert R.dup_factor_list(0) == (0, []) + assert R.dup_factor_list(7) == (7, []) + + R, x = ring("x", QQ['t']) + assert R.dup_factor_list(0) == (0, []) + assert R.dup_factor_list(QQ(1, 7)) == (QQ(1, 7), []) + + R, x = ring("x", ZZ) + assert R.dup_factor_list_include(0) == [(0, 1)] + assert R.dup_factor_list_include(7) == [(7, 1)] + + assert R.dup_factor_list(x**2 + 2*x + 1) == (1, [(x + 1, 2)]) + assert R.dup_factor_list_include(x**2 + 2*x + 1) == [(x + 1, 2)] + # issue 8037 + assert R.dup_factor_list(6*x**2 - 5*x - 6) == (1, [(2*x - 3, 1), (3*x + 2, 1)]) + + R, x = ring("x", QQ) + assert R.dup_factor_list(QQ(1,2)*x**2 + x + QQ(1,2)) == (QQ(1, 2), [(x + 1, 2)]) + + R, x = ring("x", FF(2)) + assert R.dup_factor_list(x**2 + 1) == (1, [(x + 1, 2)]) + + R, x = ring("x", RR) + assert R.dup_factor_list(1.0*x**2 + 2.0*x + 1.0) == (1.0, [(1.0*x + 1.0, 2)]) + assert R.dup_factor_list(2.0*x**2 + 4.0*x + 2.0) == (2.0, [(1.0*x + 1.0, 2)]) + + f = 6.7225336055071*x**2 - 10.6463972754741*x - 0.33469524022264 + coeff, factors = R.dup_factor_list(f) + assert coeff == RR(10.6463972754741) + assert len(factors) == 1 + assert factors[0][0].max_norm() == RR(1.0) + assert factors[0][1] == 1 + + Rt, t = ring("t", ZZ) + R, x = ring("x", Rt) + + f = 4*t*x**2 + 4*t**2*x + + assert R.dup_factor_list(f) == \ + (4*t, [(x, 1), + (x + t, 1)]) + + Rt, t = ring("t", QQ) + R, x = ring("x", Rt) + + f = QQ(1, 2)*t*x**2 + QQ(1, 2)*t**2*x + + assert R.dup_factor_list(f) == \ + (QQ(1, 2)*t, [(x, 1), + (x + t, 1)]) + + R, x = ring("x", QQ.algebraic_field(I)) + def anp(element): + return ANP(element, [QQ(1), QQ(0), QQ(1)], QQ) + + f = anp([QQ(1, 1)])*x**4 + anp([QQ(2, 1)])*x**2 + + assert R.dup_factor_list(f) == \ + (anp([QQ(1, 1)]), [(anp([QQ(1, 1)])*x, 2), + (anp([QQ(1, 1)])*x**2 + anp([])*x + anp([QQ(2, 1)]), 1)]) + + R, x = ring("x", EX) + raises(DomainError, lambda: R.dup_factor_list(EX(sin(1)))) + + +def test_dmp_factor_list(): + R, x, y = ring("x,y", ZZ) + assert R.dmp_factor_list(0) == (ZZ(0), []) + assert R.dmp_factor_list(7) == (7, []) + + R, x, y = ring("x,y", QQ) + assert R.dmp_factor_list(0) == (QQ(0), []) + assert R.dmp_factor_list(QQ(1, 7)) == (QQ(1, 7), []) + + Rt, t = ring("t", ZZ) + R, x, y = ring("x,y", Rt) + assert R.dmp_factor_list(0) == (0, []) + assert R.dmp_factor_list(7) == (ZZ(7), []) + + Rt, t = ring("t", QQ) + R, x, y = ring("x,y", Rt) + assert R.dmp_factor_list(0) == (0, []) + assert R.dmp_factor_list(QQ(1, 7)) == (QQ(1, 7), []) + + R, x, y = ring("x,y", ZZ) + assert R.dmp_factor_list_include(0) == [(0, 1)] + assert R.dmp_factor_list_include(7) == [(7, 1)] + + R, X = xring("x:200", ZZ) + + f, g = X[0]**2 + 2*X[0] + 1, X[0] + 1 + assert R.dmp_factor_list(f) == (1, [(g, 2)]) + + f, g = X[-1]**2 + 2*X[-1] + 1, X[-1] + 1 + assert R.dmp_factor_list(f) == (1, [(g, 2)]) + + R, x = ring("x", ZZ) + assert R.dmp_factor_list(x**2 + 2*x + 1) == (1, [(x + 1, 2)]) + R, x = ring("x", QQ) + assert R.dmp_factor_list(QQ(1,2)*x**2 + x + QQ(1,2)) == (QQ(1,2), [(x + 1, 2)]) + + R, x, y = ring("x,y", ZZ) + assert R.dmp_factor_list(x**2 + 2*x + 1) == (1, [(x + 1, 2)]) + R, x, y = ring("x,y", QQ) + assert R.dmp_factor_list(QQ(1,2)*x**2 + x + QQ(1,2)) == (QQ(1,2), [(x + 1, 2)]) + + R, x, y = ring("x,y", ZZ) + f = 4*x**2*y + 4*x*y**2 + + assert R.dmp_factor_list(f) == \ + (4, [(y, 1), + (x, 1), + (x + y, 1)]) + + assert R.dmp_factor_list_include(f) == \ + [(4*y, 1), + (x, 1), + (x + y, 1)] + + R, x, y = ring("x,y", QQ) + f = QQ(1,2)*x**2*y + QQ(1,2)*x*y**2 + + assert R.dmp_factor_list(f) == \ + (QQ(1,2), [(y, 1), + (x, 1), + (x + y, 1)]) + + R, x, y = ring("x,y", RR) + f = 2.0*x**2 - 8.0*y**2 + + assert R.dmp_factor_list(f) == \ + (RR(8.0), [(0.5*x - y, 1), + (0.5*x + y, 1)]) + + f = 6.7225336055071*x**2*y**2 - 10.6463972754741*x*y - 0.33469524022264 + coeff, factors = R.dmp_factor_list(f) + assert coeff == RR(10.6463972754741) + assert len(factors) == 1 + assert factors[0][0].max_norm() == RR(1.0) + assert factors[0][1] == 1 + + Rt, t = ring("t", ZZ) + R, x, y = ring("x,y", Rt) + f = 4*t*x**2 + 4*t**2*x + + assert R.dmp_factor_list(f) == \ + (4*t, [(x, 1), + (x + t, 1)]) + + Rt, t = ring("t", QQ) + R, x, y = ring("x,y", Rt) + f = QQ(1, 2)*t*x**2 + QQ(1, 2)*t**2*x + + assert R.dmp_factor_list(f) == \ + (QQ(1, 2)*t, [(x, 1), + (x + t, 1)]) + + R, x, y = ring("x,y", FF(2)) + raises(NotImplementedError, lambda: R.dmp_factor_list(x**2 + y**2)) + + R, x, y = ring("x,y", EX) + raises(DomainError, lambda: R.dmp_factor_list(EX(sin(1)))) + + +def test_dup_irreducible_p(): + R, x = ring("x", ZZ) + assert R.dup_irreducible_p(x**2 + x + 1) is True + assert R.dup_irreducible_p(x**2 + 2*x + 1) is False + + +def test_dmp_irreducible_p(): + R, x, y = ring("x,y", ZZ) + assert R.dmp_irreducible_p(x**2 + x + 1) is True + assert R.dmp_irreducible_p(x**2 + 2*x + 1) is False diff --git a/shared/package-files/31/3177cbed88d6c3d5c03d1e7c542efd774e9b0561e4262d485115189afc2ba125/blob b/shared/package-files/31/3177cbed88d6c3d5c03d1e7c542efd774e9b0561e4262d485115189afc2ba125/blob new file mode 100644 index 0000000000000000000000000000000000000000..554de348c4ef3122b05d241635f4e6ec461a0b1d --- /dev/null +++ b/shared/package-files/31/3177cbed88d6c3d5c03d1e7c542efd774e9b0561e4262d485115189afc2ba125/blob @@ -0,0 +1,229 @@ +"""Print the metadata for one or more Python package distributions. + +Usage: %prog [options] path+ + +Each 'path' entry can be one of the following: + +o a source distribution: in this case, 'path' should point to an existing + archive file (.tar.gz, .tar.bz2, or .zip) as generated by 'setup.py sdist'. + +o a binary distribution: in this case, 'path' should point to an existing + archive file (.egg) + +o a "develop" checkout: in this case, 'path' should point to a directory + initialized via 'setup.py develop' (under setuptools). + +o an installed package: in this case, 'path' should be the importable name + of the package. +""" +from configparser import ConfigParser +from collections import OrderedDict +from csv import writer +import json +import optparse +import os +import sys + +from .utils import get_metadata + + +def _parse_options(args=None): + parser = optparse.OptionParser(usage=__doc__) + + parser.add_option("-m", "--metadata-version", default=None, + help="Override metadata version") + + parser.add_option("-f", "--field", dest="fields", action="append", + help="Specify an output field (repeatable)", + ) + + parser.add_option("-d", "--download-url-prefix", + dest="download_url_prefix", + help="Download URL prefix", + ) + + parser.add_option("--simple", dest="output", action="store_const", + const='simple', default='simple', + help="Output as simple key-value pairs", + ) + + parser.add_option("-s", "--skip", dest="skip", action="store_true", + default=True, + help="Skip missing values in simple output", + ) + + parser.add_option("-S", "--no-skip", dest="skip", action="store_false", + help="Don't skip missing values in simple output", + ) + + parser.add_option("--single", dest="output", action="store_const", + const='single', + help="Output delimited values", + ) + + parser.add_option("--item-delim", dest="item_delim", action="store", + default=';', + help="Delimiter for fields in single-line output", + ) + + parser.add_option("--sequence-delim", dest="sequence_delim", + action="store", default=',', + help="Delimiter for multi-valued fields", + ) + + parser.add_option("--csv", dest="output", action="store_const", + const='csv', + help="Output as CSV", + ) + + parser.add_option("--ini", dest="output", action="store_const", + const='ini', + help="Output as INI", + ) + + parser.add_option("--json", dest="output", action="store_const", + const='json', + help="Output as JSON", + ) + + options, args = parser.parse_args(args) + + if len(args)==0: + parser.error("Pass one or more files or directories as arguments.") + else: + return options, args + +class Base(object): + _fields = None + def __init__(self, options): + if options.fields: + self._fields = options.fields + + def finish(self): # pragma: NO COVER + pass + +class Simple(Base): + def __init__(self, options): + super(Simple, self).__init__(options) + self._skip = options.skip + + def __call__(self, meta): + for field in self._fields or list(meta): + value = getattr(meta, field) + if (not self._skip) or (value is not None and value!=()): + print("%s: %s" % (field, value)) + +class SingleLine(Base): + _fields = None + def __init__(self, options): + super(SingleLine, self).__init__(options) + self._item_delim = options.item_delim + self._sequence_delim = options.sequence_delim + + def __call__(self, meta): + if self._fields is None: + self._fields = list(meta) + values = [] + for field in self._fields: + value = getattr(meta, field) + if isinstance(value, (tuple, list)): + value = self._sequence_delim.join(value) + else: + value = str(value) + values.append(value) + print(self._item_delim.join(values)) + +class CSV(Base): + _writer = None + def __init__(self, options): + super(CSV, self).__init__(options) + self._sequence_delim = options.sequence_delim + + def __call__(self, meta): + if self._fields is None: + self._fields = list(meta) # first dist wins + fields = self._fields + if self._writer is None: + self._writer = writer(sys.stdout) + self._writer.writerow(fields) + values = [] + for field in fields: + value = getattr(meta, field) + if isinstance(value, (tuple, list)): + value = self._sequence_delim.join(value) + else: + value = str(value) + values.append(value) + self._writer.writerow(values) + +class INI(Base): + _fields = None + def __init__(self, options): + super(INI, self).__init__(options) + self._parser = ConfigParser() + + def __call__(self, meta): + name = meta.name + version = meta.version + section = '%s-%s' % (name, version) + if self._parser.has_section(section): + raise ValueError('Duplicate distribution: %s' % section) + self._parser.add_section(section) + for field in self._fields or list(meta): + value = getattr(meta, field) + if isinstance(value, (tuple, list)): + value = '\n\t'.join(value) + self._parser.set(section, field, value) + + def finish(self): + self._parser.write(sys.stdout) # pragma: NO COVER + +class JSON(Base): + _fields = None + def __init__(self, options): + super(JSON, self).__init__(options) + self._mapping = OrderedDict() + + def __call__(self, meta): + if self._fields is None: + self._fields = list(meta) + for field in self._fields: + value = getattr(meta, field) + if value and not isinstance(value, (tuple, list)): + value = str(value) + if field in self._mapping: + raise ValueError('Duplicate field: %(field)r' % locals()) + self._mapping[field] = value + + def finish(self): + json.dump(self._mapping, sys.stdout, indent=2) + +_FORMATTERS = { + 'simple': Simple, + 'single': SingleLine, + 'csv': CSV, + 'ini': INI, + 'json': JSON, +} + +def main(args=None): + """Entry point for pkginfo tool + """ + options, paths = _parse_options(args) + format = getattr(options, 'output', 'simple') + formatter = _FORMATTERS[format](options) + + for path in paths: + meta = get_metadata(path, options.metadata_version) + if meta is None: + continue + + if options.download_url_prefix: + if meta.download_url is None: + filename = os.path.basename(path) + meta.download_url = '%s/%s' % (options.download_url_prefix, + filename) + + formatter(meta) + + formatter.finish() diff --git a/shared/package-files/31/3179f1d0fc8af7cb9bc6cafa19043b0f79097b2dc24097aa70996beafa66a630/blob b/shared/package-files/31/3179f1d0fc8af7cb9bc6cafa19043b0f79097b2dc24097aa70996beafa66a630/blob new file mode 100644 index 0000000000000000000000000000000000000000..6f4918c9de736cb19af10a2110e8070c5ccb95f7 --- /dev/null +++ b/shared/package-files/31/3179f1d0fc8af7cb9bc6cafa19043b0f79097b2dc24097aa70996beafa66a630/blob @@ -0,0 +1,943 @@ +""" + pygments.lexer + ~~~~~~~~~~~~~~ + + Base lexer classes. + + :copyright: Copyright 2006-2023 by the Pygments team, see AUTHORS. + :license: BSD, see LICENSE for details. +""" + +import re +import sys +import time + +from pygments.filter import apply_filters, Filter +from pygments.filters import get_filter_by_name +from pygments.token import Error, Text, Other, Whitespace, _TokenType +from pygments.util import get_bool_opt, get_int_opt, get_list_opt, \ + make_analysator, Future, guess_decode +from pygments.regexopt import regex_opt + +__all__ = ['Lexer', 'RegexLexer', 'ExtendedRegexLexer', 'DelegatingLexer', + 'LexerContext', 'include', 'inherit', 'bygroups', 'using', 'this', + 'default', 'words', 'line_re'] + +line_re = re.compile('.*?\n') + +_encoding_map = [(b'\xef\xbb\xbf', 'utf-8'), + (b'\xff\xfe\0\0', 'utf-32'), + (b'\0\0\xfe\xff', 'utf-32be'), + (b'\xff\xfe', 'utf-16'), + (b'\xfe\xff', 'utf-16be')] + +_default_analyse = staticmethod(lambda x: 0.0) + + +class LexerMeta(type): + """ + This metaclass automagically converts ``analyse_text`` methods into + static methods which always return float values. + """ + + def __new__(mcs, name, bases, d): + if 'analyse_text' in d: + d['analyse_text'] = make_analysator(d['analyse_text']) + return type.__new__(mcs, name, bases, d) + + +class Lexer(metaclass=LexerMeta): + """ + Lexer for a specific language. + + See also :doc:`lexerdevelopment`, a high-level guide to writing + lexers. + + Lexer classes have attributes used for choosing the most appropriate + lexer based on various criteria. + + .. autoattribute:: name + :no-value: + .. autoattribute:: aliases + :no-value: + .. autoattribute:: filenames + :no-value: + .. autoattribute:: alias_filenames + .. autoattribute:: mimetypes + :no-value: + .. autoattribute:: priority + + Lexers included in Pygments should have an additional attribute: + + .. autoattribute:: url + :no-value: + + You can pass options to the constructor. The basic options recognized + by all lexers and processed by the base `Lexer` class are: + + ``stripnl`` + Strip leading and trailing newlines from the input (default: True). + ``stripall`` + Strip all leading and trailing whitespace from the input + (default: False). + ``ensurenl`` + Make sure that the input ends with a newline (default: True). This + is required for some lexers that consume input linewise. + + .. versionadded:: 1.3 + + ``tabsize`` + If given and greater than 0, expand tabs in the input (default: 0). + ``encoding`` + If given, must be an encoding name. This encoding will be used to + convert the input string to Unicode, if it is not already a Unicode + string (default: ``'guess'``, which uses a simple UTF-8 / Locale / + Latin1 detection. Can also be ``'chardet'`` to use the chardet + library, if it is installed. + ``inencoding`` + Overrides the ``encoding`` if given. + """ + + #: Full name of the lexer, in human-readable form + name = None + + #: A list of short, unique identifiers that can be used to look + #: up the lexer from a list, e.g., using `get_lexer_by_name()`. + aliases = [] + + #: A list of `fnmatch` patterns that match filenames which contain + #: content for this lexer. The patterns in this list should be unique among + #: all lexers. + filenames = [] + + #: A list of `fnmatch` patterns that match filenames which may or may not + #: contain content for this lexer. This list is used by the + #: :func:`.guess_lexer_for_filename()` function, to determine which lexers + #: are then included in guessing the correct one. That means that + #: e.g. every lexer for HTML and a template language should include + #: ``\*.html`` in this list. + alias_filenames = [] + + #: A list of MIME types for content that can be lexed with this lexer. + mimetypes = [] + + #: Priority, should multiple lexers match and no content is provided + priority = 0 + + #: URL of the language specification/definition. Used in the Pygments + #: documentation. + url = None + + def __init__(self, **options): + """ + This constructor takes arbitrary options as keyword arguments. + Every subclass must first process its own options and then call + the `Lexer` constructor, since it processes the basic + options like `stripnl`. + + An example looks like this: + + .. sourcecode:: python + + def __init__(self, **options): + self.compress = options.get('compress', '') + Lexer.__init__(self, **options) + + As these options must all be specifiable as strings (due to the + command line usage), there are various utility functions + available to help with that, see `Utilities`_. + """ + self.options = options + self.stripnl = get_bool_opt(options, 'stripnl', True) + self.stripall = get_bool_opt(options, 'stripall', False) + self.ensurenl = get_bool_opt(options, 'ensurenl', True) + self.tabsize = get_int_opt(options, 'tabsize', 0) + self.encoding = options.get('encoding', 'guess') + self.encoding = options.get('inencoding') or self.encoding + self.filters = [] + for filter_ in get_list_opt(options, 'filters', ()): + self.add_filter(filter_) + + def __repr__(self): + if self.options: + return '' % (self.__class__.__name__, + self.options) + else: + return '' % self.__class__.__name__ + + def add_filter(self, filter_, **options): + """ + Add a new stream filter to this lexer. + """ + if not isinstance(filter_, Filter): + filter_ = get_filter_by_name(filter_, **options) + self.filters.append(filter_) + + def analyse_text(text): + """ + A static method which is called for lexer guessing. + + It should analyse the text and return a float in the range + from ``0.0`` to ``1.0``. If it returns ``0.0``, the lexer + will not be selected as the most probable one, if it returns + ``1.0``, it will be selected immediately. This is used by + `guess_lexer`. + + The `LexerMeta` metaclass automatically wraps this function so + that it works like a static method (no ``self`` or ``cls`` + parameter) and the return value is automatically converted to + `float`. If the return value is an object that is boolean `False` + it's the same as if the return values was ``0.0``. + """ + + def get_tokens(self, text, unfiltered=False): + """ + This method is the basic interface of a lexer. It is called by + the `highlight()` function. It must process the text and return an + iterable of ``(tokentype, value)`` pairs from `text`. + + Normally, you don't need to override this method. The default + implementation processes the options recognized by all lexers + (`stripnl`, `stripall` and so on), and then yields all tokens + from `get_tokens_unprocessed()`, with the ``index`` dropped. + + If `unfiltered` is set to `True`, the filtering mechanism is + bypassed even if filters are defined. + """ + if not isinstance(text, str): + if self.encoding == 'guess': + text, _ = guess_decode(text) + elif self.encoding == 'chardet': + try: + import chardet + except ImportError as e: + raise ImportError('To enable chardet encoding guessing, ' + 'please install the chardet library ' + 'from http://chardet.feedparser.org/') from e + # check for BOM first + decoded = None + for bom, encoding in _encoding_map: + if text.startswith(bom): + decoded = text[len(bom):].decode(encoding, 'replace') + break + # no BOM found, so use chardet + if decoded is None: + enc = chardet.detect(text[:1024]) # Guess using first 1KB + decoded = text.decode(enc.get('encoding') or 'utf-8', + 'replace') + text = decoded + else: + text = text.decode(self.encoding) + if text.startswith('\ufeff'): + text = text[len('\ufeff'):] + else: + if text.startswith('\ufeff'): + text = text[len('\ufeff'):] + + # text now *is* a unicode string + text = text.replace('\r\n', '\n') + text = text.replace('\r', '\n') + if self.stripall: + text = text.strip() + elif self.stripnl: + text = text.strip('\n') + if self.tabsize > 0: + text = text.expandtabs(self.tabsize) + if self.ensurenl and not text.endswith('\n'): + text += '\n' + + def streamer(): + for _, t, v in self.get_tokens_unprocessed(text): + yield t, v + stream = streamer() + if not unfiltered: + stream = apply_filters(stream, self.filters, self) + return stream + + def get_tokens_unprocessed(self, text): + """ + This method should process the text and return an iterable of + ``(index, tokentype, value)`` tuples where ``index`` is the starting + position of the token within the input text. + + It must be overridden by subclasses. It is recommended to + implement it as a generator to maximize effectiveness. + """ + raise NotImplementedError + + +class DelegatingLexer(Lexer): + """ + This lexer takes two lexer as arguments. A root lexer and + a language lexer. First everything is scanned using the language + lexer, afterwards all ``Other`` tokens are lexed using the root + lexer. + + The lexers from the ``template`` lexer package use this base lexer. + """ + + def __init__(self, _root_lexer, _language_lexer, _needle=Other, **options): + self.root_lexer = _root_lexer(**options) + self.language_lexer = _language_lexer(**options) + self.needle = _needle + Lexer.__init__(self, **options) + + def get_tokens_unprocessed(self, text): + buffered = '' + insertions = [] + lng_buffer = [] + for i, t, v in self.language_lexer.get_tokens_unprocessed(text): + if t is self.needle: + if lng_buffer: + insertions.append((len(buffered), lng_buffer)) + lng_buffer = [] + buffered += v + else: + lng_buffer.append((i, t, v)) + if lng_buffer: + insertions.append((len(buffered), lng_buffer)) + return do_insertions(insertions, + self.root_lexer.get_tokens_unprocessed(buffered)) + + +# ------------------------------------------------------------------------------ +# RegexLexer and ExtendedRegexLexer +# + + +class include(str): # pylint: disable=invalid-name + """ + Indicates that a state should include rules from another state. + """ + pass + + +class _inherit: + """ + Indicates the a state should inherit from its superclass. + """ + def __repr__(self): + return 'inherit' + +inherit = _inherit() # pylint: disable=invalid-name + + +class combined(tuple): # pylint: disable=invalid-name + """ + Indicates a state combined from multiple states. + """ + + def __new__(cls, *args): + return tuple.__new__(cls, args) + + def __init__(self, *args): + # tuple.__init__ doesn't do anything + pass + + +class _PseudoMatch: + """ + A pseudo match object constructed from a string. + """ + + def __init__(self, start, text): + self._text = text + self._start = start + + def start(self, arg=None): + return self._start + + def end(self, arg=None): + return self._start + len(self._text) + + def group(self, arg=None): + if arg: + raise IndexError('No such group') + return self._text + + def groups(self): + return (self._text,) + + def groupdict(self): + return {} + + +def bygroups(*args): + """ + Callback that yields multiple actions for each group in the match. + """ + def callback(lexer, match, ctx=None): + for i, action in enumerate(args): + if action is None: + continue + elif type(action) is _TokenType: + data = match.group(i + 1) + if data: + yield match.start(i + 1), action, data + else: + data = match.group(i + 1) + if data is not None: + if ctx: + ctx.pos = match.start(i + 1) + for item in action(lexer, + _PseudoMatch(match.start(i + 1), data), ctx): + if item: + yield item + if ctx: + ctx.pos = match.end() + return callback + + +class _This: + """ + Special singleton used for indicating the caller class. + Used by ``using``. + """ + +this = _This() + + +def using(_other, **kwargs): + """ + Callback that processes the match with a different lexer. + + The keyword arguments are forwarded to the lexer, except `state` which + is handled separately. + + `state` specifies the state that the new lexer will start in, and can + be an enumerable such as ('root', 'inline', 'string') or a simple + string which is assumed to be on top of the root state. + + Note: For that to work, `_other` must not be an `ExtendedRegexLexer`. + """ + gt_kwargs = {} + if 'state' in kwargs: + s = kwargs.pop('state') + if isinstance(s, (list, tuple)): + gt_kwargs['stack'] = s + else: + gt_kwargs['stack'] = ('root', s) + + if _other is this: + def callback(lexer, match, ctx=None): + # if keyword arguments are given the callback + # function has to create a new lexer instance + if kwargs: + # XXX: cache that somehow + kwargs.update(lexer.options) + lx = lexer.__class__(**kwargs) + else: + lx = lexer + s = match.start() + for i, t, v in lx.get_tokens_unprocessed(match.group(), **gt_kwargs): + yield i + s, t, v + if ctx: + ctx.pos = match.end() + else: + def callback(lexer, match, ctx=None): + # XXX: cache that somehow + kwargs.update(lexer.options) + lx = _other(**kwargs) + + s = match.start() + for i, t, v in lx.get_tokens_unprocessed(match.group(), **gt_kwargs): + yield i + s, t, v + if ctx: + ctx.pos = match.end() + return callback + + +class default: + """ + Indicates a state or state action (e.g. #pop) to apply. + For example default('#pop') is equivalent to ('', Token, '#pop') + Note that state tuples may be used as well. + + .. versionadded:: 2.0 + """ + def __init__(self, state): + self.state = state + + +class words(Future): + """ + Indicates a list of literal words that is transformed into an optimized + regex that matches any of the words. + + .. versionadded:: 2.0 + """ + def __init__(self, words, prefix='', suffix=''): + self.words = words + self.prefix = prefix + self.suffix = suffix + + def get(self): + return regex_opt(self.words, prefix=self.prefix, suffix=self.suffix) + + +class RegexLexerMeta(LexerMeta): + """ + Metaclass for RegexLexer, creates the self._tokens attribute from + self.tokens on the first instantiation. + """ + + def _process_regex(cls, regex, rflags, state): + """Preprocess the regular expression component of a token definition.""" + if isinstance(regex, Future): + regex = regex.get() + return re.compile(regex, rflags).match + + def _process_token(cls, token): + """Preprocess the token component of a token definition.""" + assert type(token) is _TokenType or callable(token), \ + 'token type must be simple type or callable, not %r' % (token,) + return token + + def _process_new_state(cls, new_state, unprocessed, processed): + """Preprocess the state transition action of a token definition.""" + if isinstance(new_state, str): + # an existing state + if new_state == '#pop': + return -1 + elif new_state in unprocessed: + return (new_state,) + elif new_state == '#push': + return new_state + elif new_state[:5] == '#pop:': + return -int(new_state[5:]) + else: + assert False, 'unknown new state %r' % new_state + elif isinstance(new_state, combined): + # combine a new state from existing ones + tmp_state = '_tmp_%d' % cls._tmpname + cls._tmpname += 1 + itokens = [] + for istate in new_state: + assert istate != new_state, 'circular state ref %r' % istate + itokens.extend(cls._process_state(unprocessed, + processed, istate)) + processed[tmp_state] = itokens + return (tmp_state,) + elif isinstance(new_state, tuple): + # push more than one state + for istate in new_state: + assert (istate in unprocessed or + istate in ('#pop', '#push')), \ + 'unknown new state ' + istate + return new_state + else: + assert False, 'unknown new state def %r' % new_state + + def _process_state(cls, unprocessed, processed, state): + """Preprocess a single state definition.""" + assert type(state) is str, "wrong state name %r" % state + assert state[0] != '#', "invalid state name %r" % state + if state in processed: + return processed[state] + tokens = processed[state] = [] + rflags = cls.flags + for tdef in unprocessed[state]: + if isinstance(tdef, include): + # it's a state reference + assert tdef != state, "circular state reference %r" % state + tokens.extend(cls._process_state(unprocessed, processed, + str(tdef))) + continue + if isinstance(tdef, _inherit): + # should be processed already, but may not in the case of: + # 1. the state has no counterpart in any parent + # 2. the state includes more than one 'inherit' + continue + if isinstance(tdef, default): + new_state = cls._process_new_state(tdef.state, unprocessed, processed) + tokens.append((re.compile('').match, None, new_state)) + continue + + assert type(tdef) is tuple, "wrong rule def %r" % tdef + + try: + rex = cls._process_regex(tdef[0], rflags, state) + except Exception as err: + raise ValueError("uncompilable regex %r in state %r of %r: %s" % + (tdef[0], state, cls, err)) from err + + token = cls._process_token(tdef[1]) + + if len(tdef) == 2: + new_state = None + else: + new_state = cls._process_new_state(tdef[2], + unprocessed, processed) + + tokens.append((rex, token, new_state)) + return tokens + + def process_tokendef(cls, name, tokendefs=None): + """Preprocess a dictionary of token definitions.""" + processed = cls._all_tokens[name] = {} + tokendefs = tokendefs or cls.tokens[name] + for state in list(tokendefs): + cls._process_state(tokendefs, processed, state) + return processed + + def get_tokendefs(cls): + """ + Merge tokens from superclasses in MRO order, returning a single tokendef + dictionary. + + Any state that is not defined by a subclass will be inherited + automatically. States that *are* defined by subclasses will, by + default, override that state in the superclass. If a subclass wishes to + inherit definitions from a superclass, it can use the special value + "inherit", which will cause the superclass' state definition to be + included at that point in the state. + """ + tokens = {} + inheritable = {} + for c in cls.__mro__: + toks = c.__dict__.get('tokens', {}) + + for state, items in toks.items(): + curitems = tokens.get(state) + if curitems is None: + # N.b. because this is assigned by reference, sufficiently + # deep hierarchies are processed incrementally (e.g. for + # A(B), B(C), C(RegexLexer), B will be premodified so X(B) + # will not see any inherits in B). + tokens[state] = items + try: + inherit_ndx = items.index(inherit) + except ValueError: + continue + inheritable[state] = inherit_ndx + continue + + inherit_ndx = inheritable.pop(state, None) + if inherit_ndx is None: + continue + + # Replace the "inherit" value with the items + curitems[inherit_ndx:inherit_ndx+1] = items + try: + # N.b. this is the index in items (that is, the superclass + # copy), so offset required when storing below. + new_inh_ndx = items.index(inherit) + except ValueError: + pass + else: + inheritable[state] = inherit_ndx + new_inh_ndx + + return tokens + + def __call__(cls, *args, **kwds): + """Instantiate cls after preprocessing its token definitions.""" + if '_tokens' not in cls.__dict__: + cls._all_tokens = {} + cls._tmpname = 0 + if hasattr(cls, 'token_variants') and cls.token_variants: + # don't process yet + pass + else: + cls._tokens = cls.process_tokendef('', cls.get_tokendefs()) + + return type.__call__(cls, *args, **kwds) + + +class RegexLexer(Lexer, metaclass=RegexLexerMeta): + """ + Base for simple stateful regular expression-based lexers. + Simplifies the lexing process so that you need only + provide a list of states and regular expressions. + """ + + #: Flags for compiling the regular expressions. + #: Defaults to MULTILINE. + flags = re.MULTILINE + + #: At all time there is a stack of states. Initially, the stack contains + #: a single state 'root'. The top of the stack is called "the current state". + #: + #: Dict of ``{'state': [(regex, tokentype, new_state), ...], ...}`` + #: + #: ``new_state`` can be omitted to signify no state transition. + #: If ``new_state`` is a string, it is pushed on the stack. This ensure + #: the new current state is ``new_state``. + #: If ``new_state`` is a tuple of strings, all of those strings are pushed + #: on the stack and the current state will be the last element of the list. + #: ``new_state`` can also be ``combined('state1', 'state2', ...)`` + #: to signify a new, anonymous state combined from the rules of two + #: or more existing ones. + #: Furthermore, it can be '#pop' to signify going back one step in + #: the state stack, or '#push' to push the current state on the stack + #: again. Note that if you push while in a combined state, the combined + #: state itself is pushed, and not only the state in which the rule is + #: defined. + #: + #: The tuple can also be replaced with ``include('state')``, in which + #: case the rules from the state named by the string are included in the + #: current one. + tokens = {} + + def get_tokens_unprocessed(self, text, stack=('root',)): + """ + Split ``text`` into (tokentype, text) pairs. + + ``stack`` is the initial stack (default: ``['root']``) + """ + pos = 0 + tokendefs = self._tokens + statestack = list(stack) + statetokens = tokendefs[statestack[-1]] + while 1: + for rexmatch, action, new_state in statetokens: + m = rexmatch(text, pos) + if m: + if action is not None: + if type(action) is _TokenType: + yield pos, action, m.group() + else: + yield from action(self, m) + pos = m.end() + if new_state is not None: + # state transition + if isinstance(new_state, tuple): + for state in new_state: + if state == '#pop': + if len(statestack) > 1: + statestack.pop() + elif state == '#push': + statestack.append(statestack[-1]) + else: + statestack.append(state) + elif isinstance(new_state, int): + # pop, but keep at least one state on the stack + # (random code leading to unexpected pops should + # not allow exceptions) + if abs(new_state) >= len(statestack): + del statestack[1:] + else: + del statestack[new_state:] + elif new_state == '#push': + statestack.append(statestack[-1]) + else: + assert False, "wrong state def: %r" % new_state + statetokens = tokendefs[statestack[-1]] + break + else: + # We are here only if all state tokens have been considered + # and there was not a match on any of them. + try: + if text[pos] == '\n': + # at EOL, reset state to "root" + statestack = ['root'] + statetokens = tokendefs['root'] + yield pos, Whitespace, '\n' + pos += 1 + continue + yield pos, Error, text[pos] + pos += 1 + except IndexError: + break + + +class LexerContext: + """ + A helper object that holds lexer position data. + """ + + def __init__(self, text, pos, stack=None, end=None): + self.text = text + self.pos = pos + self.end = end or len(text) # end=0 not supported ;-) + self.stack = stack or ['root'] + + def __repr__(self): + return 'LexerContext(%r, %r, %r)' % ( + self.text, self.pos, self.stack) + + +class ExtendedRegexLexer(RegexLexer): + """ + A RegexLexer that uses a context object to store its state. + """ + + def get_tokens_unprocessed(self, text=None, context=None): + """ + Split ``text`` into (tokentype, text) pairs. + If ``context`` is given, use this lexer context instead. + """ + tokendefs = self._tokens + if not context: + ctx = LexerContext(text, 0) + statetokens = tokendefs['root'] + else: + ctx = context + statetokens = tokendefs[ctx.stack[-1]] + text = ctx.text + while 1: + for rexmatch, action, new_state in statetokens: + m = rexmatch(text, ctx.pos, ctx.end) + if m: + if action is not None: + if type(action) is _TokenType: + yield ctx.pos, action, m.group() + ctx.pos = m.end() + else: + yield from action(self, m, ctx) + if not new_state: + # altered the state stack? + statetokens = tokendefs[ctx.stack[-1]] + # CAUTION: callback must set ctx.pos! + if new_state is not None: + # state transition + if isinstance(new_state, tuple): + for state in new_state: + if state == '#pop': + if len(ctx.stack) > 1: + ctx.stack.pop() + elif state == '#push': + ctx.stack.append(ctx.stack[-1]) + else: + ctx.stack.append(state) + elif isinstance(new_state, int): + # see RegexLexer for why this check is made + if abs(new_state) >= len(ctx.stack): + del ctx.stack[1:] + else: + del ctx.stack[new_state:] + elif new_state == '#push': + ctx.stack.append(ctx.stack[-1]) + else: + assert False, "wrong state def: %r" % new_state + statetokens = tokendefs[ctx.stack[-1]] + break + else: + try: + if ctx.pos >= ctx.end: + break + if text[ctx.pos] == '\n': + # at EOL, reset state to "root" + ctx.stack = ['root'] + statetokens = tokendefs['root'] + yield ctx.pos, Text, '\n' + ctx.pos += 1 + continue + yield ctx.pos, Error, text[ctx.pos] + ctx.pos += 1 + except IndexError: + break + + +def do_insertions(insertions, tokens): + """ + Helper for lexers which must combine the results of several + sublexers. + + ``insertions`` is a list of ``(index, itokens)`` pairs. + Each ``itokens`` iterable should be inserted at position + ``index`` into the token stream given by the ``tokens`` + argument. + + The result is a combined token stream. + + TODO: clean up the code here. + """ + insertions = iter(insertions) + try: + index, itokens = next(insertions) + except StopIteration: + # no insertions + yield from tokens + return + + realpos = None + insleft = True + + # iterate over the token stream where we want to insert + # the tokens from the insertion list. + for i, t, v in tokens: + # first iteration. store the position of first item + if realpos is None: + realpos = i + oldi = 0 + while insleft and i + len(v) >= index: + tmpval = v[oldi:index - i] + if tmpval: + yield realpos, t, tmpval + realpos += len(tmpval) + for it_index, it_token, it_value in itokens: + yield realpos, it_token, it_value + realpos += len(it_value) + oldi = index - i + try: + index, itokens = next(insertions) + except StopIteration: + insleft = False + break # not strictly necessary + if oldi < len(v): + yield realpos, t, v[oldi:] + realpos += len(v) - oldi + + # leftover tokens + while insleft: + # no normal tokens, set realpos to zero + realpos = realpos or 0 + for p, t, v in itokens: + yield realpos, t, v + realpos += len(v) + try: + index, itokens = next(insertions) + except StopIteration: + insleft = False + break # not strictly necessary + + +class ProfilingRegexLexerMeta(RegexLexerMeta): + """Metaclass for ProfilingRegexLexer, collects regex timing info.""" + + def _process_regex(cls, regex, rflags, state): + if isinstance(regex, words): + rex = regex_opt(regex.words, prefix=regex.prefix, + suffix=regex.suffix) + else: + rex = regex + compiled = re.compile(rex, rflags) + + def match_func(text, pos, endpos=sys.maxsize): + info = cls._prof_data[-1].setdefault((state, rex), [0, 0.0]) + t0 = time.time() + res = compiled.match(text, pos, endpos) + t1 = time.time() + info[0] += 1 + info[1] += t1 - t0 + return res + return match_func + + +class ProfilingRegexLexer(RegexLexer, metaclass=ProfilingRegexLexerMeta): + """Drop-in replacement for RegexLexer that does profiling of its regexes.""" + + _prof_data = [] + _prof_sort_index = 4 # defaults to time per call + + def get_tokens_unprocessed(self, text, stack=('root',)): + # this needs to be a stack, since using(this) will produce nested calls + self.__class__._prof_data.append({}) + yield from RegexLexer.get_tokens_unprocessed(self, text, stack) + rawdata = self.__class__._prof_data.pop() + data = sorted(((s, repr(r).strip('u\'').replace('\\\\', '\\')[:65], + n, 1000 * t, 1000 * t / n) + for ((s, r), (n, t)) in rawdata.items()), + key=lambda x: x[self._prof_sort_index], + reverse=True) + sum_total = sum(x[3] for x in data) + + print() + print('Profiling result for %s lexing %d chars in %.3f ms' % + (self.__class__.__name__, len(text), sum_total)) + print('=' * 110) + print('%-20s %-64s ncalls tottime percall' % ('state', 'regex')) + print('-' * 110) + for d in data: + print('%-20s %-65s %5d %8.4f %8.4f' % d) + print('=' * 110) diff --git a/shared/package-files/31/317b54a99723c2d0da6c14984e879b69a2046d8d69b3080cf2557c5af8db230f/blob b/shared/package-files/31/317b54a99723c2d0da6c14984e879b69a2046d8d69b3080cf2557c5af8db230f/blob new file mode 100644 index 0000000000000000000000000000000000000000..36e356bfb0924747deeb2ff34e128cbdb2f9fff9 --- /dev/null +++ b/shared/package-files/31/317b54a99723c2d0da6c14984e879b69a2046d8d69b3080cf2557c5af8db230f/blob @@ -0,0 +1,83 @@ +#pragma once + +// @generated by torchgen/gen.py from Operator.h + +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { +namespace _ops { + + +struct TORCH_API cumsum { + using schema = at::Tensor (const at::Tensor &, int64_t, c10::optional); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::cumsum") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "cumsum(Tensor self, int dim, *, ScalarType? dtype=None) -> Tensor") + static at::Tensor call(const at::Tensor & self, int64_t dim, c10::optional dtype); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, int64_t dim, c10::optional dtype); +}; + +struct TORCH_API cumsum_ { + using schema = at::Tensor & (at::Tensor &, int64_t, c10::optional); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::cumsum_") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "cumsum_(Tensor(a!) self, int dim, *, ScalarType? dtype=None) -> Tensor(a!)") + static at::Tensor & call(at::Tensor & self, int64_t dim, c10::optional dtype); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, int64_t dim, c10::optional dtype); +}; + +struct TORCH_API cumsum_out { + using schema = at::Tensor & (const at::Tensor &, int64_t, c10::optional, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::cumsum") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "cumsum.out(Tensor self, int dim, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, int64_t dim, c10::optional dtype, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, int64_t dim, c10::optional dtype, at::Tensor & out); +}; + +struct TORCH_API cumsum_dimname { + using schema = at::Tensor (const at::Tensor &, at::Dimname, c10::optional); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::cumsum") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "dimname") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "cumsum.dimname(Tensor self, Dimname dim, *, ScalarType? dtype=None) -> Tensor") + static at::Tensor call(const at::Tensor & self, at::Dimname dim, c10::optional dtype); + static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Dimname dim, c10::optional dtype); +}; + +struct TORCH_API cumsum__dimname { + using schema = at::Tensor & (at::Tensor &, at::Dimname, c10::optional); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::cumsum_") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "dimname") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "cumsum_.dimname(Tensor(a!) self, Dimname dim, *, ScalarType? dtype=None) -> Tensor(a!)") + static at::Tensor & call(at::Tensor & self, at::Dimname dim, c10::optional dtype); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, at::Dimname dim, c10::optional dtype); +}; + +struct TORCH_API cumsum_dimname_out { + using schema = at::Tensor & (const at::Tensor &, at::Dimname, c10::optional, at::Tensor &); + using ptr_schema = schema*; + // See Note [static constexpr char* members for windows NVCC] + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::cumsum") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "dimname_out") + STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "cumsum.dimname_out(Tensor self, Dimname dim, *, ScalarType? dtype=None, Tensor(a!) out) -> Tensor(a!)") + static at::Tensor & call(const at::Tensor & self, at::Dimname dim, c10::optional dtype, at::Tensor & out); + static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, at::Dimname dim, c10::optional dtype, at::Tensor & out); +}; + +}} // namespace at::_ops diff --git a/shared/package-files/31/317ba565fdf7729f28b6a1a8700c0acd204833a3147ab62d13c7f1a99b007c90/blob b/shared/package-files/31/317ba565fdf7729f28b6a1a8700c0acd204833a3147ab62d13c7f1a99b007c90/blob new file mode 100644 index 0000000000000000000000000000000000000000..922a14917bf3fd2d395a4f5002a39c4d9d9c7ee2 --- /dev/null +++ b/shared/package-files/31/317ba565fdf7729f28b6a1a8700c0acd204833a3147ab62d13c7f1a99b007c90/blob @@ -0,0 +1,16 @@ +#!/usr/bin/env python3 +"""Extract version number from __init__.py""" + +# Authors: The scikit-learn developers +# SPDX-License-Identifier: BSD-3-Clause + +import os + +sklearn_init = os.path.join(os.path.dirname(__file__), "../__init__.py") + +data = open(sklearn_init).readlines() +version_line = next(line for line in data if line.startswith("__version__")) + +version = version_line.strip().split(" = ")[1].replace('"', "").replace("'", "") + +print(version) diff --git a/shared/package-files/31/317ca02998a11c0ed8763ca313104b3a2b196e97c1b3d945c13c2acedaf750aa/blob b/shared/package-files/31/317ca02998a11c0ed8763ca313104b3a2b196e97c1b3d945c13c2acedaf750aa/blob new file mode 100644 index 0000000000000000000000000000000000000000..63e75e62de8f6a356aeaa1876a0de82da7a0c1c3 --- /dev/null +++ b/shared/package-files/31/317ca02998a11c0ed8763ca313104b3a2b196e97c1b3d945c13c2acedaf750aa/blob @@ -0,0 +1,23 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cpu { + +TORCH_API at::Tensor _sample_dirichlet(const at::Tensor & self, c10::optional generator=c10::nullopt); + +} // namespace cpu +} // namespace at diff --git a/shared/package-files/31/317d2dfb65571c4b8f9dd4994462b57733fcd70d49d7b6747efdd7c2210661ab/blob b/shared/package-files/31/317d2dfb65571c4b8f9dd4994462b57733fcd70d49d7b6747efdd7c2210661ab/blob new file mode 100644 index 0000000000000000000000000000000000000000..33e32b516b1215a8e55b4261101f3ac67ce4171e --- /dev/null +++ b/shared/package-files/31/317d2dfb65571c4b8f9dd4994462b57733fcd70d49d7b6747efdd7c2210661ab/blob @@ -0,0 +1,9 @@ +#pragma once + +namespace torch { +namespace utils { + +void initializeLayouts(); + +} +} // namespace torch diff --git a/shared/package-files/31/317d3f6ff59ddfbbbfbdabe571fe874d8799ea38bf44a42798f79285d9784440/blob b/shared/package-files/31/317d3f6ff59ddfbbbfbdabe571fe874d8799ea38bf44a42798f79285d9784440/blob new file mode 100644 index 0000000000000000000000000000000000000000..5771c30bc5cacfe6cc716e2865503baf75b1e6d4 --- /dev/null +++ b/shared/package-files/31/317d3f6ff59ddfbbbfbdabe571fe874d8799ea38bf44a42798f79285d9784440/blob @@ -0,0 +1,1305 @@ +import numpy as np + +from statsmodels.tools.tools import Bunch + +llf = np.array([-240.21658671417]) + +nobs = np.array([202]) + +k = np.array([4]) + +k_exog = np.array([1]) + +sigma = np.array([.79473430527544]) + +chi2 = np.array([54633.096432541]) + +df_model = np.array([3]) + +k_ar = np.array([2]) + +k_ma = np.array([1]) + +params = np.array([ + 1.1970355174119, + -.19724105359909, + -.91770441432171, + .63160261598163]) + +cov_params = np.array([ + .00182362158934, + -.00163271308366, + -.00140915922719, + -.00044400541718, + -.00163271308366, + .00148731108625, + .00117094734518, + .00044939207189, + -.00140915922719, + .00117094734518, + .00181742086472, + .00032737864417, + -.00044400541718, + .00044939207189, + .00032737864417, + .00071193796554]).reshape(4, 4) + +xb = np.array([ + 0, + 0, + .04999904707074, + .06866559386253, + .02903163060546, + .07047952711582, + .03383458778262, + .08519082516432, + .06387747824192, + .0323903337121, + .0664371997118, + .056028008461, + .05634552612901, + .08741936087608, + .04945361241698, + .0881454795599, + .06608437746763, + .05997726693749, + .1058451384306, + .07246486097574, + .10775856673717, + .06419499218464, + .07649331539869, + .08432687073946, + .10236189514399, + .09031195193529, + .11902847886086, + .08933536708355, + .13242828845978, + .18790599703789, + .1410321444273, + .2076324224472, + .12561346590519, + .16128000617027, + .19236192107201, + .20115886628628, + .23716603219509, + .22255305945873, + .28473255038261, + .27441227436066, + .28466689586639, + .34994292259216, + .3424659371376, + .35532799363136, + .39506548643112, + .41180691123009, + .37130555510521, + .40151777863503, + .40951976180077, + .33306270837784, + .40587121248245, + .35764938592911, + .35284259915352, + .34843212366104, + .34438464045525, + .36860400438309, + .3990384042263, + .54691004753113, + .44432625174522, + .70020270347595, + .70163971185684, + .77033877372742, + .78572767972946, + .95923948287964, + .90811860561371, + .77250319719315, + .85019183158875, + .83438217639923, + .83959633111954, + .67678385972977, + .81331378221512, + .8202628493309, + .79870623350143, + .93831378221512, + .8281461596489, + .8256653547287, + .9071888923645, + .95076316595078, + 1.0827594995499, + 1.1249971389771, + 1.1078934669495, + 1.3271758556366, + 1.4741442203522, + 1.4939774274826, + 1.7192279100418, + 1.8355281352997, + 1.5873348712921, + 1.7079899311066, + 1.8515517711639, + 1.7368041276932, + 1.8895095586777, + 1.7913619279861, + 1.5485136508942, + 1.3914349079132, + 1.8569093942642, + 1.378589630127, + 1.0909280776978, + 1.2919955253601, + 1.2874838113785, + 1.2636196613312, + 1.3255174160004, + 1.2952193021774, + 1.1754019260406, + 1.2002106904984, + 1.0717958211899, + 1.2283787727356, + 1.0664055347443, + 1.0640426874161, + 1.2097471952438, + .49885395169258, + .91795635223389, + .88015007972717, + 1.0048481225967, + 1.0485925674438, + 1.0131514072418, + 1.0480036735535, + 1.0044000148773, + 1.0596977472305, + 1.0989319086075, + 1.1431447267532, + 1.1360602378845, + 1.316884636879, + 1.2248164415359, + 1.0992801189423, + 1.4178918600082, + 1.2780615091324, + 1.3436778783798, + 1.727570772171, + 1.376532793045, + 1.1185711622238, + 1.2548811435699, + 1.2139776945114, + 1.22409760952, + 1.2136551141739, + 1.2040791511536, + 1.2232189178467, + 1.1931306123734, + 1.1573059558868, + 1.0603547096252, + 1.1422899961472, + 1.0268490314484, + 1.0556720495224, + 1.1264756917953, + 1.0764141082764, + 1.0978548526764, + 1.1536711454391, + 1.025780916214, + 1.034966468811, + 1.1074740886688, + 1.1707112789154, + 1.0496238470078, + 1.1209251880646, + 1.1271858215332, + .93740028142929, + .90130144357681, + 1.0357736349106, + .87323325872421, + .75861483812332, + .93606770038605, + .85732334852219, + .87216699123383, + .97779452800751, + .88410341739655, + 1.0446182489395, + 1.0177079439163, + 1.144193649292, + 1.2372444868088, + 1.1155867576599, + 1.2619564533234, + 1.0462523698807, + 1.0816910266876, + .85130125284195, + .76972281932831, + 1.1335872411728, + .92024201154709, + 1.0416384935379, + 1.1102936267853, + .91037821769714, + .85678082704544, + 1.022847533226, + 1.0930491685867, + 1.0342184305191, + 1.2070096731186, + 1.2472279071808, + 1.0886085033417, + 1.3604420423508, + 1.1053978204727, + 2.0939025878906, + 1.0898643732071, + 1.3238569498062, + 1.5171576738358, + .77435439825058, + 1.3360253572464, + 1.5512014627457, + 1.3569095134735, + 1.4669530391693, + 1.9312930107117, + 1.52878677845, + 2.3952746391296, + .80755305290222, + -.2365039139986, + .85178333520889, + 1.1858888864517]) + +y = np.array([ + np.nan, + 28.979999542236, + 29.199998855591, + 29.4186668396, + 29.399032592773, + 29.610481262207, + 29.583833694458, + 29.835191726685, + 29.903877258301, + 29.842390060425, + 29.986436843872, + 30.036027908325, + 30.096345901489, + 30.29741859436, + 30.269453048706, + 30.468145370483, + 30.506084442139, + 30.539976119995, + 30.795845031738, + 30.822463989258, + 31.047760009766, + 31.014196395874, + 31.096494674683, + 31.204328536987, + 31.382362365723, + 31.470310211182, + 31.699028015137, + 31.739334106445, + 32.012428283691, + 32.467903137207, + 32.591033935547, + 33.057632446289, + 33.025615692139, + 33.261280059814, + 33.592365264893, + 33.901161193848, + 34.33716583252, + 34.622554779053, + 35.184734344482, + 35.574413299561, + 35.984668731689, + 36.649940490723, + 37.142463684082, + 37.655326843262, + 38.295066833496, + 38.911808013916, + 39.271308898926, + 39.801517486572, + 40.309520721436, + 40.433059692383, + 41.005870819092, + 41.257652282715, + 41.552845001221, + 41.848430633545, + 42.144382476807, + 42.568603515625, + 43.099040985107, + 44.246910095215, + 44.644325256348, + 46.300201416016, + 47.501640319824, + 48.870338439941, + 50.08572769165, + 51.959239959717, + 53.208118438721, + 53.77250289917, + 54.850193023682, + 55.734382629395, + 56.639595031738, + 56.776782989502, + 57.813312530518, + 58.720264434814, + 59.498706817627, + 60.938312530518, + 61.628147125244, + 62.425662994385, + 63.607189178467, + 64.850761413574, + 66.58275604248, + 68.224998474121, + 69.607894897461, + 71.927177429199, + 74.474143981934, + 76.693977355957, + 79.719230651855, + 82.735527038574, + 84.18733215332, + 86.407989501953, + 89.051551818848, + 90.836799621582, + 93.389511108398, + 95.191360473633, + 95.948516845703, + 96.39143371582, + 99.356910705566, + 99.478584289551, + 98.990928649902, + 100.09199523926, + 101.08748626709, + 102.063621521, + 103.42551422119, + 104.59522247314, + 105.27539825439, + 106.30020904541, + 106.77178955078, + 108.2283782959, + 108.76640319824, + 109.5640411377, + 111.10974884033, + 109.19885253906, + 110.41795349121, + 111.08014678955, + 112.40484619141, + 113.74858856201, + 114.81315612793, + 116.04800415039, + 117.00440216064, + 118.25969696045, + 119.59893035889, + 121.04314422607, + 122.33605957031, + 124.41688537598, + 125.72481536865, + 126.49928283691, + 128.91789245605, + 130.17805480957, + 131.84367370605, + 135.12756347656, + 136.07652282715, + 136.21858215332, + 137.45487976074, + 138.41397094727, + 139.52409362793, + 140.61364746094, + 141.70408630371, + 142.92321777344, + 143.99313354492, + 144.9573059082, + 145.56034851074, + 146.74229431152, + 147.32685852051, + 148.25567626953, + 149.52647399902, + 150.47640991211, + 151.59785461426, + 152.95367431641, + 153.62579345703, + 154.53497314453, + 155.80746459961, + 157.27072143555, + 158.04962158203, + 159.32092285156, + 160.52717590332, + 160.83738708496, + 161.30130004883, + 162.53576660156, + 162.87322998047, + 162.95861816406, + 164.13606262207, + 164.75732421875, + 165.57215881348, + 166.8777923584, + 167.58410644531, + 169.14462280273, + 170.31771850586, + 172.04418945313, + 173.93724060059, + 175.01557922363, + 176.86196899414, + 177.44624328613, + 178.48168945313, + 178.4513092041, + 178.4697265625, + 180.43359375, + 180.92024230957, + 182.24163818359, + 183.71029663086, + 184.11038208008, + 184.5567779541, + 185.92283630371, + 187.39305114746, + 188.43421936035, + 190.30702209473, + 192.04722595215, + 192.88861083984, + 195.16044616699, + 195.8053894043, + 201.29389953613, + 200.48985290527, + 202.0238494873, + 204.21714782715, + 202.67434692383, + 204.91003417969, + 207.47120666504, + 208.6949005127, + 210.59994506836, + 214.42628479004, + 215.52578735352, + 221.00527954102, + 217.6965637207, + 211.93748474121, + 213.52278137207, + 215.65487670898]) + +resid = np.array([ + np.nan, + .17000007629395, + .150001719594, + -.04866513609886, + .1409684419632, + -.06048120185733, + .16616617143154, + .00480932369828, + -.09387816488743, + .07761027663946, + -.00643773004413, + .00397336483002, + .1136526465416, + -.07741913199425, + .11054623872042, + -.02814410813153, + -.02608536928892, + .15002372860909, + -.04584567248821, + .11753567308187, + -.09775833785534, + .00580469891429, + .02350706420839, + .07567297667265, + -.00236342288554, + .10968881100416, + -.04902878031135, + .14066417515278, + .2675713300705, + -.01790400780737, + .25896555185318, + -.15762937068939, + .074383482337, + .13872304558754, + .10763731598854, + .19883884489536, + .06283701956272, + .27744692564011, + .11526516824961, + .12558923661709, + .3153315782547, + .15005706250668, + .1575340628624, + .24467428028584, + .20493300259113, + -.01180539745837, + .12869445979595, + .09848223626614, + -.20952282845974, + .166937276721, + -.1058681756258, + -.05765015259385, + -.05284334719181, + -.04843288660049, + .05561690032482, + .13139598071575, + .60096162557602, + -.04691004380584, + .95567148923874, + .49979802966118, + .5983595252037, + .42966198921204, + .91427308320999, + .34075975418091, + -.20811785757542, + .22749677300453, + .049809679389, + .06561553478241, + -.53959709405899, + .2232176810503, + .08668774366379, + -.02026358619332, + .50129300355911, + -.13831453025341, + -.02814690209925, + .27433693408966, + .29281187057495, + .64923530817032, + .51723897457123, + .27500438690186, + .99210506677628, + 1.0728256702423, + .72585266828537, + 1.3060256242752, + 1.1807736158371, + -.13553117215633, + .51266354322433, + .79201000928879, + .0484497398138, + .66319739818573, + .0104919327423, + -.79136198759079, + -.94851511716843, + 1.1085650920868, + -1.2569109201431, + -1.5785865783691, + -.19092650711536, + -.29199549555779, + -.2874838411808, + .03637577593327, + -.12551285326481, + -.49522390961647, + -.17540194094181, + -.60021221637726, + .22820720076561, + -.52838176488876, + -.26640248298645, + .33595886826515, + -2.4097516536713, + .30114910006523, + -.21795941889286, + .31985449790955, + .29514732956886, + .05141358822584, + .18684551119804, + -.04800364747643, + .19559693336487, + .24030530452728, + .30106961727142, + .15685074031353, + .76394122838974, + .08311692625284, + -.32481494545937, + 1.0007183551788, + -.01789797656238, + .32194453477859, + 1.5563160181046, + -.42756772041321, + -.97652357816696, + -.01858037337661, + -.25488117337227, + -.11397163569927, + -.12410674989223, + -.1136489585042, + -.00408222479746, + -.12321277707815, + -.19313062727451, + -.45730903744698, + .03965143114328, + -.44229298830032, + -.12685517966747, + .1443248540163, + -.12647566199303, + .02359197475016, + .20214818418026, + -.35366812348366, + -.12578700482845, + .16503044962883, + .29253509640694, + -.27071738243103, + .15037304162979, + .07907173037529, + -.6271858215332, + -.43740031123161, + .19870468974113, + -.53577369451523, + -.67323631048203, + .24138513207436, + -.23607075214386, + -.05732027813792, + .32782995700836, + -.17779149115086, + .51590573787689, + .15537866950035, + .5822828412056, + .65580940246582, + -.03724759072065, + .58442544937134, + -.46196871995926, + -.04625232890248, + -.88167881965637, + -.75131040811539, + .83028328418732, + -.43359026312828, + .2797549366951, + .35837066173553, + -.51030284166336, + -.41037824749947, + .34321609139442, + .37716165184975, + .00694172456861, + .66579383611679, + .49298724532127, + -.24722795188427, + .91139149665833, + -.46044808626175, + 3.3946022987366, + -1.8939057588577, + .21013870835304, + .67614299058914, + -2.3171606063843, + .89965683221817, + 1.0099676847458, + -.13320215046406, + .43808862566948, + 1.8950464725494, + -.42929407954216, + 3.0842199325562, + -4.1162676811218, + -5.5225644111633, + .73351317644119, + .94620555639267, + .73011147975922]) + +yr = np.array([ + np.nan, + .17000007629395, + .150001719594, + -.04866513609886, + .1409684419632, + -.06048120185733, + .16616617143154, + .00480932369828, + -.09387816488743, + .07761027663946, + -.00643773004413, + .00397336483002, + .1136526465416, + -.07741913199425, + .11054623872042, + -.02814410813153, + -.02608536928892, + .15002372860909, + -.04584567248821, + .11753567308187, + -.09775833785534, + .00580469891429, + .02350706420839, + .07567297667265, + -.00236342288554, + .10968881100416, + -.04902878031135, + .14066417515278, + .2675713300705, + -.01790400780737, + .25896555185318, + -.15762937068939, + .074383482337, + .13872304558754, + .10763731598854, + .19883884489536, + .06283701956272, + .27744692564011, + .11526516824961, + .12558923661709, + .3153315782547, + .15005706250668, + .1575340628624, + .24467428028584, + .20493300259113, + -.01180539745837, + .12869445979595, + .09848223626614, + -.20952282845974, + .166937276721, + -.1058681756258, + -.05765015259385, + -.05284334719181, + -.04843288660049, + .05561690032482, + .13139598071575, + .60096162557602, + -.04691004380584, + .95567148923874, + .49979802966118, + .5983595252037, + .42966198921204, + .91427308320999, + .34075975418091, + -.20811785757542, + .22749677300453, + .049809679389, + .06561553478241, + -.53959709405899, + .2232176810503, + .08668774366379, + -.02026358619332, + .50129300355911, + -.13831453025341, + -.02814690209925, + .27433693408966, + .29281187057495, + .64923530817032, + .51723897457123, + .27500438690186, + .99210506677628, + 1.0728256702423, + .72585266828537, + 1.3060256242752, + 1.1807736158371, + -.13553117215633, + .51266354322433, + .79201000928879, + .0484497398138, + .66319739818573, + .0104919327423, + -.79136198759079, + -.94851511716843, + 1.1085650920868, + -1.2569109201431, + -1.5785865783691, + -.19092650711536, + -.29199549555779, + -.2874838411808, + .03637577593327, + -.12551285326481, + -.49522390961647, + -.17540194094181, + -.60021221637726, + .22820720076561, + -.52838176488876, + -.26640248298645, + .33595886826515, + -2.4097516536713, + .30114910006523, + -.21795941889286, + .31985449790955, + .29514732956886, + .05141358822584, + .18684551119804, + -.04800364747643, + .19559693336487, + .24030530452728, + .30106961727142, + .15685074031353, + .76394122838974, + .08311692625284, + -.32481494545937, + 1.0007183551788, + -.01789797656238, + .32194453477859, + 1.5563160181046, + -.42756772041321, + -.97652357816696, + -.01858037337661, + -.25488117337227, + -.11397163569927, + -.12410674989223, + -.1136489585042, + -.00408222479746, + -.12321277707815, + -.19313062727451, + -.45730903744698, + .03965143114328, + -.44229298830032, + -.12685517966747, + .1443248540163, + -.12647566199303, + .02359197475016, + .20214818418026, + -.35366812348366, + -.12578700482845, + .16503044962883, + .29253509640694, + -.27071738243103, + .15037304162979, + .07907173037529, + -.6271858215332, + -.43740031123161, + .19870468974113, + -.53577369451523, + -.67323631048203, + .24138513207436, + -.23607075214386, + -.05732027813792, + .32782995700836, + -.17779149115086, + .51590573787689, + .15537866950035, + .5822828412056, + .65580940246582, + -.03724759072065, + .58442544937134, + -.46196871995926, + -.04625232890248, + -.88167881965637, + -.75131040811539, + .83028328418732, + -.43359026312828, + .2797549366951, + .35837066173553, + -.51030284166336, + -.41037824749947, + .34321609139442, + .37716165184975, + .00694172456861, + .66579383611679, + .49298724532127, + -.24722795188427, + .91139149665833, + -.46044808626175, + 3.3946022987366, + -1.8939057588577, + .21013870835304, + .67614299058914, + -2.3171606063843, + .89965683221817, + 1.0099676847458, + -.13320215046406, + .43808862566948, + 1.8950464725494, + -.42929407954216, + 3.0842199325562, + -4.1162676811218, + -5.5225644111633, + .73351317644119, + .94620555639267, + .73011147975922]) + +mse = np.array([ + 1.1635265350342, + .70545583963394, + .63365471363068, + .633325278759, + .63304948806763, + .63281834125519, + .63262450695038, + .63246184587479, + .63232523202896, + .63221049308777, + .63211411237717, + .63203299045563, + .63196486234665, + .63190752267838, + .63185924291611, + .63181865215302, + .63178449869156, + .63175576925278, + .631731569767, + .63171118497849, + .63169401884079, + .63167959451675, + .63166743516922, + .63165718317032, + .63164860010147, + .63164132833481, + .6316351890564, + .63163006305695, + .63162571191788, + .63162207603455, + .63161903619766, + .63161641359329, + .63161426782608, + .63161242008209, + .63161087036133, + .63160955905914, + .63160848617554, + .63160753250122, + .63160675764084, + .63160610198975, + .63160556554794, + .63160508871078, + .63160473108292, + .63160437345505, + .63160407543182, + .63160383701324, + .63160365819931, + .63160347938538, + .63160336017609, + .6316032409668, + .63160312175751, + .63160306215286, + .63160300254822, + .63160294294357, + .63160288333893, + .63160282373428, + .63160282373428, + .63160276412964, + .63160276412964, + .63160270452499, + .63160270452499, + .63160270452499, + .63160270452499, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035, + .63160264492035]) + +stdp = np.array([ + 0, + 0, + .04999904707074, + .06866559386253, + .02903163060546, + .07047952711582, + .03383458778262, + .08519082516432, + .06387747824192, + .0323903337121, + .0664371997118, + .056028008461, + .05634552612901, + .08741936087608, + .04945361241698, + .0881454795599, + .06608437746763, + .05997726693749, + .1058451384306, + .07246486097574, + .10775856673717, + .06419499218464, + .07649331539869, + .08432687073946, + .10236189514399, + .09031195193529, + .11902847886086, + .08933536708355, + .13242828845978, + .18790599703789, + .1410321444273, + .2076324224472, + .12561346590519, + .16128000617027, + .19236192107201, + .20115886628628, + .23716603219509, + .22255305945873, + .28473255038261, + .27441227436066, + .28466689586639, + .34994292259216, + .3424659371376, + .35532799363136, + .39506548643112, + .41180691123009, + .37130555510521, + .40151777863503, + .40951976180077, + .33306270837784, + .40587121248245, + .35764938592911, + .35284259915352, + .34843212366104, + .34438464045525, + .36860400438309, + .3990384042263, + .54691004753113, + .44432625174522, + .70020270347595, + .70163971185684, + .77033877372742, + .78572767972946, + .95923948287964, + .90811860561371, + .77250319719315, + .85019183158875, + .83438217639923, + .83959633111954, + .67678385972977, + .81331378221512, + .8202628493309, + .79870623350143, + .93831378221512, + .8281461596489, + .8256653547287, + .9071888923645, + .95076316595078, + 1.0827594995499, + 1.1249971389771, + 1.1078934669495, + 1.3271758556366, + 1.4741442203522, + 1.4939774274826, + 1.7192279100418, + 1.8355281352997, + 1.5873348712921, + 1.7079899311066, + 1.8515517711639, + 1.7368041276932, + 1.8895095586777, + 1.7913619279861, + 1.5485136508942, + 1.3914349079132, + 1.8569093942642, + 1.378589630127, + 1.0909280776978, + 1.2919955253601, + 1.2874838113785, + 1.2636196613312, + 1.3255174160004, + 1.2952193021774, + 1.1754019260406, + 1.2002106904984, + 1.0717958211899, + 1.2283787727356, + 1.0664055347443, + 1.0640426874161, + 1.2097471952438, + .49885395169258, + .91795635223389, + .88015007972717, + 1.0048481225967, + 1.0485925674438, + 1.0131514072418, + 1.0480036735535, + 1.0044000148773, + 1.0596977472305, + 1.0989319086075, + 1.1431447267532, + 1.1360602378845, + 1.316884636879, + 1.2248164415359, + 1.0992801189423, + 1.4178918600082, + 1.2780615091324, + 1.3436778783798, + 1.727570772171, + 1.376532793045, + 1.1185711622238, + 1.2548811435699, + 1.2139776945114, + 1.22409760952, + 1.2136551141739, + 1.2040791511536, + 1.2232189178467, + 1.1931306123734, + 1.1573059558868, + 1.0603547096252, + 1.1422899961472, + 1.0268490314484, + 1.0556720495224, + 1.1264756917953, + 1.0764141082764, + 1.0978548526764, + 1.1536711454391, + 1.025780916214, + 1.034966468811, + 1.1074740886688, + 1.1707112789154, + 1.0496238470078, + 1.1209251880646, + 1.1271858215332, + .93740028142929, + .90130144357681, + 1.0357736349106, + .87323325872421, + .75861483812332, + .93606770038605, + .85732334852219, + .87216699123383, + .97779452800751, + .88410341739655, + 1.0446182489395, + 1.0177079439163, + 1.144193649292, + 1.2372444868088, + 1.1155867576599, + 1.2619564533234, + 1.0462523698807, + 1.0816910266876, + .85130125284195, + .76972281932831, + 1.1335872411728, + .92024201154709, + 1.0416384935379, + 1.1102936267853, + .91037821769714, + .85678082704544, + 1.022847533226, + 1.0930491685867, + 1.0342184305191, + 1.2070096731186, + 1.2472279071808, + 1.0886085033417, + 1.3604420423508, + 1.1053978204727, + 2.0939025878906, + 1.0898643732071, + 1.3238569498062, + 1.5171576738358, + .77435439825058, + 1.3360253572464, + 1.5512014627457, + 1.3569095134735, + 1.4669530391693, + 1.9312930107117, + 1.52878677845, + 2.3952746391296, + .80755305290222, + -.2365039139986, + .85178333520889, + 1.1858888864517]) + +icstats = np.array([ + 202, + np.nan, + -240.21658671417, + 4, + 488.43317342834, + 501.66624421795]) + + +results = Bunch( + llf=llf, + nobs=nobs, + k=k, + k_exog=k_exog, + sigma=sigma, + chi2=chi2, + df_model=df_model, + k_ar=k_ar, + k_ma=k_ma, + params=params, + cov_params=cov_params, + xb=xb, + y=y, + resid=resid, + yr=yr, + mse=mse, + stdp=stdp, + icstats=icstats +) diff --git a/shared/package-files/31/317e6eba1a47125300f9432cf1921ea417182ea6ffd3fac1ce659592fd3415cd/blob b/shared/package-files/31/317e6eba1a47125300f9432cf1921ea417182ea6ffd3fac1ce659592fd3415cd/blob new file mode 100644 index 0000000000000000000000000000000000000000..f83f37cab419eb7d357dafff1f577fffd7a23145 --- /dev/null +++ b/shared/package-files/31/317e6eba1a47125300f9432cf1921ea417182ea6ffd3fac1ce659592fd3415cd/blob @@ -0,0 +1,23 @@ +import numpy as np + +from .._serializable import Serializable + + +class Masker(Serializable): + """This is the superclass of all maskers.""" + + def __call__(self, mask, *args): + """Maskers are callable objects that accept the same inputs as the model plus a binary mask.""" + + def _standardize_mask(self, mask, *args): + """This allows users to pass True/False as short hand masks.""" + if mask is True or mask is False: + if callable(self.shape): + shape = self.shape(*args) + else: + shape = self.shape + + if mask is True: + return np.ones(shape[1], dtype=bool) + return np.zeros(shape[1], dtype=bool) + return mask diff --git a/shared/package-files/31/3182ebf90b79c194c306b9d598102e74e3394182209175ad2c30347282d6939d/blob b/shared/package-files/31/3182ebf90b79c194c306b9d598102e74e3394182209175ad2c30347282d6939d/blob new file mode 100644 index 0000000000000000000000000000000000000000..0adfe14b9564b3ef8fce4d2088ac625621931c3a --- /dev/null +++ b/shared/package-files/31/3182ebf90b79c194c306b9d598102e74e3394182209175ad2c30347282d6939d/blob @@ -0,0 +1,1629 @@ +import copy + +from sympy.core import S +from sympy.core.function import expand_mul +from sympy.functions.elementary.miscellaneous import Min, sqrt +from sympy.functions.elementary.complexes import sign + +from .common import NonSquareMatrixError, NonPositiveDefiniteMatrixError +from .utilities import _get_intermediate_simp, _iszero +from .determinant import _find_reasonable_pivot_naive + + +def _rank_decomposition(M, iszerofunc=_iszero, simplify=False): + r"""Returns a pair of matrices (`C`, `F`) with matching rank + such that `A = C F`. + + Parameters + ========== + + iszerofunc : Function, optional + A function used for detecting whether an element can + act as a pivot. ``lambda x: x.is_zero`` is used by default. + + simplify : Bool or Function, optional + A function used to simplify elements when looking for a + pivot. By default SymPy's ``simplify`` is used. + + Returns + ======= + + (C, F) : Matrices + `C` and `F` are full-rank matrices with rank as same as `A`, + whose product gives `A`. + + See Notes for additional mathematical details. + + Examples + ======== + + >>> from sympy import Matrix + >>> A = Matrix([ + ... [1, 3, 1, 4], + ... [2, 7, 3, 9], + ... [1, 5, 3, 1], + ... [1, 2, 0, 8] + ... ]) + >>> C, F = A.rank_decomposition() + >>> C + Matrix([ + [1, 3, 4], + [2, 7, 9], + [1, 5, 1], + [1, 2, 8]]) + >>> F + Matrix([ + [1, 0, -2, 0], + [0, 1, 1, 0], + [0, 0, 0, 1]]) + >>> C * F == A + True + + Notes + ===== + + Obtaining `F`, an RREF of `A`, is equivalent to creating a + product + + .. math:: + E_n E_{n-1} ... E_1 A = F + + where `E_n, E_{n-1}, \dots, E_1` are the elimination matrices or + permutation matrices equivalent to each row-reduction step. + + The inverse of the same product of elimination matrices gives + `C`: + + .. math:: + C = \left(E_n E_{n-1} \dots E_1\right)^{-1} + + It is not necessary, however, to actually compute the inverse: + the columns of `C` are those from the original matrix with the + same column indices as the indices of the pivot columns of `F`. + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Rank_factorization + + .. [2] Piziak, R.; Odell, P. L. (1 June 1999). + "Full Rank Factorization of Matrices". + Mathematics Magazine. 72 (3): 193. doi:10.2307/2690882 + + See Also + ======== + + sympy.matrices.matrices.MatrixReductions.rref + """ + + F, pivot_cols = M.rref(simplify=simplify, iszerofunc=iszerofunc, + pivots=True) + rank = len(pivot_cols) + + C = M.extract(range(M.rows), pivot_cols) + F = F[:rank, :] + + return C, F + + +def _liupc(M): + """Liu's algorithm, for pre-determination of the Elimination Tree of + the given matrix, used in row-based symbolic Cholesky factorization. + + Examples + ======== + + >>> from sympy import SparseMatrix + >>> S = SparseMatrix([ + ... [1, 0, 3, 2], + ... [0, 0, 1, 0], + ... [4, 0, 0, 5], + ... [0, 6, 7, 0]]) + >>> S.liupc() + ([[0], [], [0], [1, 2]], [4, 3, 4, 4]) + + References + ========== + + .. [1] Symbolic Sparse Cholesky Factorization using Elimination Trees, + Jeroen Van Grondelle (1999) + https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.39.7582 + """ + # Algorithm 2.4, p 17 of reference + + # get the indices of the elements that are non-zero on or below diag + R = [[] for r in range(M.rows)] + + for r, c, _ in M.row_list(): + if c <= r: + R[r].append(c) + + inf = len(R) # nothing will be this large + parent = [inf]*M.rows + virtual = [inf]*M.rows + + for r in range(M.rows): + for c in R[r][:-1]: + while virtual[c] < r: + t = virtual[c] + virtual[c] = r + c = t + + if virtual[c] == inf: + parent[c] = virtual[c] = r + + return R, parent + +def _row_structure_symbolic_cholesky(M): + """Symbolic cholesky factorization, for pre-determination of the + non-zero structure of the Cholesky factororization. + + Examples + ======== + + >>> from sympy import SparseMatrix + >>> S = SparseMatrix([ + ... [1, 0, 3, 2], + ... [0, 0, 1, 0], + ... [4, 0, 0, 5], + ... [0, 6, 7, 0]]) + >>> S.row_structure_symbolic_cholesky() + [[0], [], [0], [1, 2]] + + References + ========== + + .. [1] Symbolic Sparse Cholesky Factorization using Elimination Trees, + Jeroen Van Grondelle (1999) + https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.39.7582 + """ + + R, parent = M.liupc() + inf = len(R) # this acts as infinity + Lrow = copy.deepcopy(R) + + for k in range(M.rows): + for j in R[k]: + while j != inf and j != k: + Lrow[k].append(j) + j = parent[j] + + Lrow[k] = sorted(set(Lrow[k])) + + return Lrow + + +def _cholesky(M, hermitian=True): + """Returns the Cholesky-type decomposition L of a matrix A + such that L * L.H == A if hermitian flag is True, + or L * L.T == A if hermitian is False. + + A must be a Hermitian positive-definite matrix if hermitian is True, + or a symmetric matrix if it is False. + + Examples + ======== + + >>> from sympy import Matrix + >>> A = Matrix(((25, 15, -5), (15, 18, 0), (-5, 0, 11))) + >>> A.cholesky() + Matrix([ + [ 5, 0, 0], + [ 3, 3, 0], + [-1, 1, 3]]) + >>> A.cholesky() * A.cholesky().T + Matrix([ + [25, 15, -5], + [15, 18, 0], + [-5, 0, 11]]) + + The matrix can have complex entries: + + >>> from sympy import I + >>> A = Matrix(((9, 3*I), (-3*I, 5))) + >>> A.cholesky() + Matrix([ + [ 3, 0], + [-I, 2]]) + >>> A.cholesky() * A.cholesky().H + Matrix([ + [ 9, 3*I], + [-3*I, 5]]) + + Non-hermitian Cholesky-type decomposition may be useful when the + matrix is not positive-definite. + + >>> A = Matrix([[1, 2], [2, 1]]) + >>> L = A.cholesky(hermitian=False) + >>> L + Matrix([ + [1, 0], + [2, sqrt(3)*I]]) + >>> L*L.T == A + True + + See Also + ======== + + sympy.matrices.dense.DenseMatrix.LDLdecomposition + sympy.matrices.matrices.MatrixBase.LUdecomposition + QRdecomposition + """ + + from .dense import MutableDenseMatrix + + if not M.is_square: + raise NonSquareMatrixError("Matrix must be square.") + if hermitian and not M.is_hermitian: + raise ValueError("Matrix must be Hermitian.") + if not hermitian and not M.is_symmetric(): + raise ValueError("Matrix must be symmetric.") + + L = MutableDenseMatrix.zeros(M.rows, M.rows) + + if hermitian: + for i in range(M.rows): + for j in range(i): + L[i, j] = ((1 / L[j, j])*(M[i, j] - + sum(L[i, k]*L[j, k].conjugate() for k in range(j)))) + + Lii2 = (M[i, i] - + sum(L[i, k]*L[i, k].conjugate() for k in range(i))) + + if Lii2.is_positive is False: + raise NonPositiveDefiniteMatrixError( + "Matrix must be positive-definite") + + L[i, i] = sqrt(Lii2) + + else: + for i in range(M.rows): + for j in range(i): + L[i, j] = ((1 / L[j, j])*(M[i, j] - + sum(L[i, k]*L[j, k] for k in range(j)))) + + L[i, i] = sqrt(M[i, i] - + sum(L[i, k]**2 for k in range(i))) + + return M._new(L) + +def _cholesky_sparse(M, hermitian=True): + """ + Returns the Cholesky decomposition L of a matrix A + such that L * L.T = A + + A must be a square, symmetric, positive-definite + and non-singular matrix + + Examples + ======== + + >>> from sympy import SparseMatrix + >>> A = SparseMatrix(((25,15,-5),(15,18,0),(-5,0,11))) + >>> A.cholesky() + Matrix([ + [ 5, 0, 0], + [ 3, 3, 0], + [-1, 1, 3]]) + >>> A.cholesky() * A.cholesky().T == A + True + + The matrix can have complex entries: + + >>> from sympy import I + >>> A = SparseMatrix(((9, 3*I), (-3*I, 5))) + >>> A.cholesky() + Matrix([ + [ 3, 0], + [-I, 2]]) + >>> A.cholesky() * A.cholesky().H + Matrix([ + [ 9, 3*I], + [-3*I, 5]]) + + Non-hermitian Cholesky-type decomposition may be useful when the + matrix is not positive-definite. + + >>> A = SparseMatrix([[1, 2], [2, 1]]) + >>> L = A.cholesky(hermitian=False) + >>> L + Matrix([ + [1, 0], + [2, sqrt(3)*I]]) + >>> L*L.T == A + True + + See Also + ======== + + sympy.matrices.sparse.SparseMatrix.LDLdecomposition + sympy.matrices.matrices.MatrixBase.LUdecomposition + QRdecomposition + """ + + from .dense import MutableDenseMatrix + + if not M.is_square: + raise NonSquareMatrixError("Matrix must be square.") + if hermitian and not M.is_hermitian: + raise ValueError("Matrix must be Hermitian.") + if not hermitian and not M.is_symmetric(): + raise ValueError("Matrix must be symmetric.") + + dps = _get_intermediate_simp(expand_mul, expand_mul) + Crowstruc = M.row_structure_symbolic_cholesky() + C = MutableDenseMatrix.zeros(M.rows) + + for i in range(len(Crowstruc)): + for j in Crowstruc[i]: + if i != j: + C[i, j] = M[i, j] + summ = 0 + + for p1 in Crowstruc[i]: + if p1 < j: + for p2 in Crowstruc[j]: + if p2 < j: + if p1 == p2: + if hermitian: + summ += C[i, p1]*C[j, p1].conjugate() + else: + summ += C[i, p1]*C[j, p1] + else: + break + else: + break + + C[i, j] = dps((C[i, j] - summ) / C[j, j]) + + else: # i == j + C[j, j] = M[j, j] + summ = 0 + + for k in Crowstruc[j]: + if k < j: + if hermitian: + summ += C[j, k]*C[j, k].conjugate() + else: + summ += C[j, k]**2 + else: + break + + Cjj2 = dps(C[j, j] - summ) + + if hermitian and Cjj2.is_positive is False: + raise NonPositiveDefiniteMatrixError( + "Matrix must be positive-definite") + + C[j, j] = sqrt(Cjj2) + + return M._new(C) + + +def _LDLdecomposition(M, hermitian=True): + """Returns the LDL Decomposition (L, D) of matrix A, + such that L * D * L.H == A if hermitian flag is True, or + L * D * L.T == A if hermitian is False. + This method eliminates the use of square root. + Further this ensures that all the diagonal entries of L are 1. + A must be a Hermitian positive-definite matrix if hermitian is True, + or a symmetric matrix otherwise. + + Examples + ======== + + >>> from sympy import Matrix, eye + >>> A = Matrix(((25, 15, -5), (15, 18, 0), (-5, 0, 11))) + >>> L, D = A.LDLdecomposition() + >>> L + Matrix([ + [ 1, 0, 0], + [ 3/5, 1, 0], + [-1/5, 1/3, 1]]) + >>> D + Matrix([ + [25, 0, 0], + [ 0, 9, 0], + [ 0, 0, 9]]) + >>> L * D * L.T * A.inv() == eye(A.rows) + True + + The matrix can have complex entries: + + >>> from sympy import I + >>> A = Matrix(((9, 3*I), (-3*I, 5))) + >>> L, D = A.LDLdecomposition() + >>> L + Matrix([ + [ 1, 0], + [-I/3, 1]]) + >>> D + Matrix([ + [9, 0], + [0, 4]]) + >>> L*D*L.H == A + True + + See Also + ======== + + sympy.matrices.dense.DenseMatrix.cholesky + sympy.matrices.matrices.MatrixBase.LUdecomposition + QRdecomposition + """ + + from .dense import MutableDenseMatrix + + if not M.is_square: + raise NonSquareMatrixError("Matrix must be square.") + if hermitian and not M.is_hermitian: + raise ValueError("Matrix must be Hermitian.") + if not hermitian and not M.is_symmetric(): + raise ValueError("Matrix must be symmetric.") + + D = MutableDenseMatrix.zeros(M.rows, M.rows) + L = MutableDenseMatrix.eye(M.rows) + + if hermitian: + for i in range(M.rows): + for j in range(i): + L[i, j] = (1 / D[j, j])*(M[i, j] - sum( + L[i, k]*L[j, k].conjugate()*D[k, k] for k in range(j))) + + D[i, i] = (M[i, i] - + sum(L[i, k]*L[i, k].conjugate()*D[k, k] for k in range(i))) + + if D[i, i].is_positive is False: + raise NonPositiveDefiniteMatrixError( + "Matrix must be positive-definite") + + else: + for i in range(M.rows): + for j in range(i): + L[i, j] = (1 / D[j, j])*(M[i, j] - sum( + L[i, k]*L[j, k]*D[k, k] for k in range(j))) + + D[i, i] = M[i, i] - sum(L[i, k]**2*D[k, k] for k in range(i)) + + return M._new(L), M._new(D) + +def _LDLdecomposition_sparse(M, hermitian=True): + """ + Returns the LDL Decomposition (matrices ``L`` and ``D``) of matrix + ``A``, such that ``L * D * L.T == A``. ``A`` must be a square, + symmetric, positive-definite and non-singular. + + This method eliminates the use of square root and ensures that all + the diagonal entries of L are 1. + + Examples + ======== + + >>> from sympy import SparseMatrix + >>> A = SparseMatrix(((25, 15, -5), (15, 18, 0), (-5, 0, 11))) + >>> L, D = A.LDLdecomposition() + >>> L + Matrix([ + [ 1, 0, 0], + [ 3/5, 1, 0], + [-1/5, 1/3, 1]]) + >>> D + Matrix([ + [25, 0, 0], + [ 0, 9, 0], + [ 0, 0, 9]]) + >>> L * D * L.T == A + True + + """ + + from .dense import MutableDenseMatrix + + if not M.is_square: + raise NonSquareMatrixError("Matrix must be square.") + if hermitian and not M.is_hermitian: + raise ValueError("Matrix must be Hermitian.") + if not hermitian and not M.is_symmetric(): + raise ValueError("Matrix must be symmetric.") + + dps = _get_intermediate_simp(expand_mul, expand_mul) + Lrowstruc = M.row_structure_symbolic_cholesky() + L = MutableDenseMatrix.eye(M.rows) + D = MutableDenseMatrix.zeros(M.rows, M.cols) + + for i in range(len(Lrowstruc)): + for j in Lrowstruc[i]: + if i != j: + L[i, j] = M[i, j] + summ = 0 + + for p1 in Lrowstruc[i]: + if p1 < j: + for p2 in Lrowstruc[j]: + if p2 < j: + if p1 == p2: + if hermitian: + summ += L[i, p1]*L[j, p1].conjugate()*D[p1, p1] + else: + summ += L[i, p1]*L[j, p1]*D[p1, p1] + else: + break + else: + break + + L[i, j] = dps((L[i, j] - summ) / D[j, j]) + + else: # i == j + D[i, i] = M[i, i] + summ = 0 + + for k in Lrowstruc[i]: + if k < i: + if hermitian: + summ += L[i, k]*L[i, k].conjugate()*D[k, k] + else: + summ += L[i, k]**2*D[k, k] + else: + break + + D[i, i] = dps(D[i, i] - summ) + + if hermitian and D[i, i].is_positive is False: + raise NonPositiveDefiniteMatrixError( + "Matrix must be positive-definite") + + return M._new(L), M._new(D) + + +def _LUdecomposition(M, iszerofunc=_iszero, simpfunc=None, rankcheck=False): + """Returns (L, U, perm) where L is a lower triangular matrix with unit + diagonal, U is an upper triangular matrix, and perm is a list of row + swap index pairs. If A is the original matrix, then + ``A = (L*U).permuteBkwd(perm)``, and the row permutation matrix P such + that $P A = L U$ can be computed by ``P = eye(A.rows).permuteFwd(perm)``. + + See documentation for LUCombined for details about the keyword argument + rankcheck, iszerofunc, and simpfunc. + + Parameters + ========== + + rankcheck : bool, optional + Determines if this function should detect the rank + deficiency of the matrixis and should raise a + ``ValueError``. + + iszerofunc : function, optional + A function which determines if a given expression is zero. + + The function should be a callable that takes a single + SymPy expression and returns a 3-valued boolean value + ``True``, ``False``, or ``None``. + + It is internally used by the pivot searching algorithm. + See the notes section for a more information about the + pivot searching algorithm. + + simpfunc : function or None, optional + A function that simplifies the input. + + If this is specified as a function, this function should be + a callable that takes a single SymPy expression and returns + an another SymPy expression that is algebraically + equivalent. + + If ``None``, it indicates that the pivot search algorithm + should not attempt to simplify any candidate pivots. + + It is internally used by the pivot searching algorithm. + See the notes section for a more information about the + pivot searching algorithm. + + Examples + ======== + + >>> from sympy import Matrix + >>> a = Matrix([[4, 3], [6, 3]]) + >>> L, U, _ = a.LUdecomposition() + >>> L + Matrix([ + [ 1, 0], + [3/2, 1]]) + >>> U + Matrix([ + [4, 3], + [0, -3/2]]) + + See Also + ======== + + sympy.matrices.dense.DenseMatrix.cholesky + sympy.matrices.dense.DenseMatrix.LDLdecomposition + QRdecomposition + LUdecomposition_Simple + LUdecompositionFF + LUsolve + """ + + combined, p = M.LUdecomposition_Simple(iszerofunc=iszerofunc, + simpfunc=simpfunc, rankcheck=rankcheck) + + # L is lower triangular ``M.rows x M.rows`` + # U is upper triangular ``M.rows x M.cols`` + # L has unit diagonal. For each column in combined, the subcolumn + # below the diagonal of combined is shared by L. + # If L has more columns than combined, then the remaining subcolumns + # below the diagonal of L are zero. + # The upper triangular portion of L and combined are equal. + def entry_L(i, j): + if i < j: + # Super diagonal entry + return M.zero + elif i == j: + return M.one + elif j < combined.cols: + return combined[i, j] + + # Subdiagonal entry of L with no corresponding + # entry in combined + return M.zero + + def entry_U(i, j): + return M.zero if i > j else combined[i, j] + + L = M._new(combined.rows, combined.rows, entry_L) + U = M._new(combined.rows, combined.cols, entry_U) + + return L, U, p + +def _LUdecomposition_Simple(M, iszerofunc=_iszero, simpfunc=None, + rankcheck=False): + r"""Compute the PLU decomposition of the matrix. + + Parameters + ========== + + rankcheck : bool, optional + Determines if this function should detect the rank + deficiency of the matrixis and should raise a + ``ValueError``. + + iszerofunc : function, optional + A function which determines if a given expression is zero. + + The function should be a callable that takes a single + SymPy expression and returns a 3-valued boolean value + ``True``, ``False``, or ``None``. + + It is internally used by the pivot searching algorithm. + See the notes section for a more information about the + pivot searching algorithm. + + simpfunc : function or None, optional + A function that simplifies the input. + + If this is specified as a function, this function should be + a callable that takes a single SymPy expression and returns + an another SymPy expression that is algebraically + equivalent. + + If ``None``, it indicates that the pivot search algorithm + should not attempt to simplify any candidate pivots. + + It is internally used by the pivot searching algorithm. + See the notes section for a more information about the + pivot searching algorithm. + + Returns + ======= + + (lu, row_swaps) : (Matrix, list) + If the original matrix is a $m, n$ matrix: + + *lu* is a $m, n$ matrix, which contains result of the + decomposition in a compressed form. See the notes section + to see how the matrix is compressed. + + *row_swaps* is a $m$-element list where each element is a + pair of row exchange indices. + + ``A = (L*U).permute_backward(perm)``, and the row + permutation matrix $P$ from the formula $P A = L U$ can be + computed by ``P=eye(A.row).permute_forward(perm)``. + + Raises + ====== + + ValueError + Raised if ``rankcheck=True`` and the matrix is found to + be rank deficient during the computation. + + Notes + ===== + + About the PLU decomposition: + + PLU decomposition is a generalization of a LU decomposition + which can be extended for rank-deficient matrices. + + It can further be generalized for non-square matrices, and this + is the notation that SymPy is using. + + PLU decomposition is a decomposition of a $m, n$ matrix $A$ in + the form of $P A = L U$ where + + * $L$ is a $m, m$ lower triangular matrix with unit diagonal + entries. + * $U$ is a $m, n$ upper triangular matrix. + * $P$ is a $m, m$ permutation matrix. + + So, for a square matrix, the decomposition would look like: + + .. math:: + L = \begin{bmatrix} + 1 & 0 & 0 & \cdots & 0 \\ + L_{1, 0} & 1 & 0 & \cdots & 0 \\ + L_{2, 0} & L_{2, 1} & 1 & \cdots & 0 \\ + \vdots & \vdots & \vdots & \ddots & \vdots \\ + L_{n-1, 0} & L_{n-1, 1} & L_{n-1, 2} & \cdots & 1 + \end{bmatrix} + + .. math:: + U = \begin{bmatrix} + U_{0, 0} & U_{0, 1} & U_{0, 2} & \cdots & U_{0, n-1} \\ + 0 & U_{1, 1} & U_{1, 2} & \cdots & U_{1, n-1} \\ + 0 & 0 & U_{2, 2} & \cdots & U_{2, n-1} \\ + \vdots & \vdots & \vdots & \ddots & \vdots \\ + 0 & 0 & 0 & \cdots & U_{n-1, n-1} + \end{bmatrix} + + And for a matrix with more rows than the columns, + the decomposition would look like: + + .. math:: + L = \begin{bmatrix} + 1 & 0 & 0 & \cdots & 0 & 0 & \cdots & 0 \\ + L_{1, 0} & 1 & 0 & \cdots & 0 & 0 & \cdots & 0 \\ + L_{2, 0} & L_{2, 1} & 1 & \cdots & 0 & 0 & \cdots & 0 \\ + \vdots & \vdots & \vdots & \ddots & \vdots & \vdots & \ddots + & \vdots \\ + L_{n-1, 0} & L_{n-1, 1} & L_{n-1, 2} & \cdots & 1 & 0 + & \cdots & 0 \\ + L_{n, 0} & L_{n, 1} & L_{n, 2} & \cdots & L_{n, n-1} & 1 + & \cdots & 0 \\ + \vdots & \vdots & \vdots & \ddots & \vdots & \vdots + & \ddots & \vdots \\ + L_{m-1, 0} & L_{m-1, 1} & L_{m-1, 2} & \cdots & L_{m-1, n-1} + & 0 & \cdots & 1 \\ + \end{bmatrix} + + .. math:: + U = \begin{bmatrix} + U_{0, 0} & U_{0, 1} & U_{0, 2} & \cdots & U_{0, n-1} \\ + 0 & U_{1, 1} & U_{1, 2} & \cdots & U_{1, n-1} \\ + 0 & 0 & U_{2, 2} & \cdots & U_{2, n-1} \\ + \vdots & \vdots & \vdots & \ddots & \vdots \\ + 0 & 0 & 0 & \cdots & U_{n-1, n-1} \\ + 0 & 0 & 0 & \cdots & 0 \\ + \vdots & \vdots & \vdots & \ddots & \vdots \\ + 0 & 0 & 0 & \cdots & 0 + \end{bmatrix} + + Finally, for a matrix with more columns than the rows, the + decomposition would look like: + + .. math:: + L = \begin{bmatrix} + 1 & 0 & 0 & \cdots & 0 \\ + L_{1, 0} & 1 & 0 & \cdots & 0 \\ + L_{2, 0} & L_{2, 1} & 1 & \cdots & 0 \\ + \vdots & \vdots & \vdots & \ddots & \vdots \\ + L_{m-1, 0} & L_{m-1, 1} & L_{m-1, 2} & \cdots & 1 + \end{bmatrix} + + .. math:: + U = \begin{bmatrix} + U_{0, 0} & U_{0, 1} & U_{0, 2} & \cdots & U_{0, m-1} + & \cdots & U_{0, n-1} \\ + 0 & U_{1, 1} & U_{1, 2} & \cdots & U_{1, m-1} + & \cdots & U_{1, n-1} \\ + 0 & 0 & U_{2, 2} & \cdots & U_{2, m-1} + & \cdots & U_{2, n-1} \\ + \vdots & \vdots & \vdots & \ddots & \vdots + & \cdots & \vdots \\ + 0 & 0 & 0 & \cdots & U_{m-1, m-1} + & \cdots & U_{m-1, n-1} \\ + \end{bmatrix} + + About the compressed LU storage: + + The results of the decomposition are often stored in compressed + forms rather than returning $L$ and $U$ matrices individually. + + It may be less intiuitive, but it is commonly used for a lot of + numeric libraries because of the efficiency. + + The storage matrix is defined as following for this specific + method: + + * The subdiagonal elements of $L$ are stored in the subdiagonal + portion of $LU$, that is $LU_{i, j} = L_{i, j}$ whenever + $i > j$. + * The elements on the diagonal of $L$ are all 1, and are not + explicitly stored. + * $U$ is stored in the upper triangular portion of $LU$, that is + $LU_{i, j} = U_{i, j}$ whenever $i <= j$. + * For a case of $m > n$, the right side of the $L$ matrix is + trivial to store. + * For a case of $m < n$, the below side of the $U$ matrix is + trivial to store. + + So, for a square matrix, the compressed output matrix would be: + + .. math:: + LU = \begin{bmatrix} + U_{0, 0} & U_{0, 1} & U_{0, 2} & \cdots & U_{0, n-1} \\ + L_{1, 0} & U_{1, 1} & U_{1, 2} & \cdots & U_{1, n-1} \\ + L_{2, 0} & L_{2, 1} & U_{2, 2} & \cdots & U_{2, n-1} \\ + \vdots & \vdots & \vdots & \ddots & \vdots \\ + L_{n-1, 0} & L_{n-1, 1} & L_{n-1, 2} & \cdots & U_{n-1, n-1} + \end{bmatrix} + + For a matrix with more rows than the columns, the compressed + output matrix would be: + + .. math:: + LU = \begin{bmatrix} + U_{0, 0} & U_{0, 1} & U_{0, 2} & \cdots & U_{0, n-1} \\ + L_{1, 0} & U_{1, 1} & U_{1, 2} & \cdots & U_{1, n-1} \\ + L_{2, 0} & L_{2, 1} & U_{2, 2} & \cdots & U_{2, n-1} \\ + \vdots & \vdots & \vdots & \ddots & \vdots \\ + L_{n-1, 0} & L_{n-1, 1} & L_{n-1, 2} & \cdots + & U_{n-1, n-1} \\ + \vdots & \vdots & \vdots & \ddots & \vdots \\ + L_{m-1, 0} & L_{m-1, 1} & L_{m-1, 2} & \cdots + & L_{m-1, n-1} \\ + \end{bmatrix} + + For a matrix with more columns than the rows, the compressed + output matrix would be: + + .. math:: + LU = \begin{bmatrix} + U_{0, 0} & U_{0, 1} & U_{0, 2} & \cdots & U_{0, m-1} + & \cdots & U_{0, n-1} \\ + L_{1, 0} & U_{1, 1} & U_{1, 2} & \cdots & U_{1, m-1} + & \cdots & U_{1, n-1} \\ + L_{2, 0} & L_{2, 1} & U_{2, 2} & \cdots & U_{2, m-1} + & \cdots & U_{2, n-1} \\ + \vdots & \vdots & \vdots & \ddots & \vdots + & \cdots & \vdots \\ + L_{m-1, 0} & L_{m-1, 1} & L_{m-1, 2} & \cdots & U_{m-1, m-1} + & \cdots & U_{m-1, n-1} \\ + \end{bmatrix} + + About the pivot searching algorithm: + + When a matrix contains symbolic entries, the pivot search algorithm + differs from the case where every entry can be categorized as zero or + nonzero. + The algorithm searches column by column through the submatrix whose + top left entry coincides with the pivot position. + If it exists, the pivot is the first entry in the current search + column that iszerofunc guarantees is nonzero. + If no such candidate exists, then each candidate pivot is simplified + if simpfunc is not None. + The search is repeated, with the difference that a candidate may be + the pivot if ``iszerofunc()`` cannot guarantee that it is nonzero. + In the second search the pivot is the first candidate that + iszerofunc can guarantee is nonzero. + If no such candidate exists, then the pivot is the first candidate + for which iszerofunc returns None. + If no such candidate exists, then the search is repeated in the next + column to the right. + The pivot search algorithm differs from the one in ``rref()``, which + relies on ``_find_reasonable_pivot()``. + Future versions of ``LUdecomposition_simple()`` may use + ``_find_reasonable_pivot()``. + + See Also + ======== + + sympy.matrices.matrices.MatrixBase.LUdecomposition + LUdecompositionFF + LUsolve + """ + + if rankcheck: + # https://github.com/sympy/sympy/issues/9796 + pass + + if S.Zero in M.shape: + # Define LU decomposition of a matrix with no entries as a matrix + # of the same dimensions with all zero entries. + return M.zeros(M.rows, M.cols), [] + + dps = _get_intermediate_simp() + lu = M.as_mutable() + row_swaps = [] + + pivot_col = 0 + + for pivot_row in range(0, lu.rows - 1): + # Search for pivot. Prefer entry that iszeropivot determines + # is nonzero, over entry that iszeropivot cannot guarantee + # is zero. + # XXX ``_find_reasonable_pivot`` uses slow zero testing. Blocked by bug #10279 + # Future versions of LUdecomposition_simple can pass iszerofunc and simpfunc + # to _find_reasonable_pivot(). + # In pass 3 of _find_reasonable_pivot(), the predicate in ``if x.equals(S.Zero):`` + # calls sympy.simplify(), and not the simplification function passed in via + # the keyword argument simpfunc. + iszeropivot = True + + while pivot_col != M.cols and iszeropivot: + sub_col = (lu[r, pivot_col] for r in range(pivot_row, M.rows)) + + pivot_row_offset, pivot_value, is_assumed_non_zero, ind_simplified_pairs =\ + _find_reasonable_pivot_naive(sub_col, iszerofunc, simpfunc) + + iszeropivot = pivot_value is None + + if iszeropivot: + # All candidate pivots in this column are zero. + # Proceed to next column. + pivot_col += 1 + + if rankcheck and pivot_col != pivot_row: + # All entries including and below the pivot position are + # zero, which indicates that the rank of the matrix is + # strictly less than min(num rows, num cols) + # Mimic behavior of previous implementation, by throwing a + # ValueError. + raise ValueError("Rank of matrix is strictly less than" + " number of rows or columns." + " Pass keyword argument" + " rankcheck=False to compute" + " the LU decomposition of this matrix.") + + candidate_pivot_row = None if pivot_row_offset is None else pivot_row + pivot_row_offset + + if candidate_pivot_row is None and iszeropivot: + # If candidate_pivot_row is None and iszeropivot is True + # after pivot search has completed, then the submatrix + # below and to the right of (pivot_row, pivot_col) is + # all zeros, indicating that Gaussian elimination is + # complete. + return lu, row_swaps + + # Update entries simplified during pivot search. + for offset, val in ind_simplified_pairs: + lu[pivot_row + offset, pivot_col] = val + + if pivot_row != candidate_pivot_row: + # Row swap book keeping: + # Record which rows were swapped. + # Update stored portion of L factor by multiplying L on the + # left and right with the current permutation. + # Swap rows of U. + row_swaps.append([pivot_row, candidate_pivot_row]) + + # Update L. + lu[pivot_row, 0:pivot_row], lu[candidate_pivot_row, 0:pivot_row] = \ + lu[candidate_pivot_row, 0:pivot_row], lu[pivot_row, 0:pivot_row] + + # Swap pivot row of U with candidate pivot row. + lu[pivot_row, pivot_col:lu.cols], lu[candidate_pivot_row, pivot_col:lu.cols] = \ + lu[candidate_pivot_row, pivot_col:lu.cols], lu[pivot_row, pivot_col:lu.cols] + + # Introduce zeros below the pivot by adding a multiple of the + # pivot row to a row under it, and store the result in the + # row under it. + # Only entries in the target row whose index is greater than + # start_col may be nonzero. + start_col = pivot_col + 1 + + for row in range(pivot_row + 1, lu.rows): + # Store factors of L in the subcolumn below + # (pivot_row, pivot_row). + lu[row, pivot_row] = \ + dps(lu[row, pivot_col]/lu[pivot_row, pivot_col]) + + # Form the linear combination of the pivot row and the current + # row below the pivot row that zeros the entries below the pivot. + # Employing slicing instead of a loop here raises + # NotImplementedError: Cannot add Zero to MutableSparseMatrix + # in sympy/matrices/tests/test_sparse.py. + # c = pivot_row + 1 if pivot_row == pivot_col else pivot_col + for c in range(start_col, lu.cols): + lu[row, c] = dps(lu[row, c] - lu[row, pivot_row]*lu[pivot_row, c]) + + if pivot_row != pivot_col: + # matrix rank < min(num rows, num cols), + # so factors of L are not stored directly below the pivot. + # These entries are zero by construction, so don't bother + # computing them. + for row in range(pivot_row + 1, lu.rows): + lu[row, pivot_col] = M.zero + + pivot_col += 1 + + if pivot_col == lu.cols: + # All candidate pivots are zero implies that Gaussian + # elimination is complete. + return lu, row_swaps + + if rankcheck: + if iszerofunc( + lu[Min(lu.rows, lu.cols) - 1, Min(lu.rows, lu.cols) - 1]): + raise ValueError("Rank of matrix is strictly less than" + " number of rows or columns." + " Pass keyword argument" + " rankcheck=False to compute" + " the LU decomposition of this matrix.") + + return lu, row_swaps + +def _LUdecompositionFF(M): + """Compute a fraction-free LU decomposition. + + Returns 4 matrices P, L, D, U such that PA = L D**-1 U. + If the elements of the matrix belong to some integral domain I, then all + elements of L, D and U are guaranteed to belong to I. + + See Also + ======== + + sympy.matrices.matrices.MatrixBase.LUdecomposition + LUdecomposition_Simple + LUsolve + + References + ========== + + .. [1] W. Zhou & D.J. Jeffrey, "Fraction-free matrix factors: new forms + for LU and QR factors". Frontiers in Computer Science in China, + Vol 2, no. 1, pp. 67-80, 2008. + """ + + from sympy.matrices import SparseMatrix + + zeros = SparseMatrix.zeros + eye = SparseMatrix.eye + n, m = M.rows, M.cols + U, L, P = M.as_mutable(), eye(n), eye(n) + DD = zeros(n, n) + oldpivot = 1 + + for k in range(n - 1): + if U[k, k] == 0: + for kpivot in range(k + 1, n): + if U[kpivot, k]: + break + else: + raise ValueError("Matrix is not full rank") + + U[k, k:], U[kpivot, k:] = U[kpivot, k:], U[k, k:] + L[k, :k], L[kpivot, :k] = L[kpivot, :k], L[k, :k] + P[k, :], P[kpivot, :] = P[kpivot, :], P[k, :] + + L [k, k] = Ukk = U[k, k] + DD[k, k] = oldpivot * Ukk + + for i in range(k + 1, n): + L[i, k] = Uik = U[i, k] + + for j in range(k + 1, m): + U[i, j] = (Ukk * U[i, j] - U[k, j] * Uik) / oldpivot + + U[i, k] = 0 + + oldpivot = Ukk + + DD[n - 1, n - 1] = oldpivot + + return P, L, DD, U + +def _singular_value_decomposition(A): + r"""Returns a Condensed Singular Value decomposition. + + Explanation + =========== + + A Singular Value decomposition is a decomposition in the form $A = U \Sigma V$ + where + + - $U, V$ are column orthogonal matrix. + - $\Sigma$ is a diagonal matrix, where the main diagonal contains singular + values of matrix A. + + A column orthogonal matrix satisfies + $\mathbb{I} = U^H U$ while a full orthogonal matrix satisfies + relation $\mathbb{I} = U U^H = U^H U$ where $\mathbb{I}$ is an identity + matrix with matching dimensions. + + For matrices which are not square or are rank-deficient, it is + sufficient to return a column orthogonal matrix because augmenting + them may introduce redundant computations. + In condensed Singular Value Decomposition we only return column orthogonal + matrices because of this reason + + If you want to augment the results to return a full orthogonal + decomposition, you should use the following procedures. + + - Augment the $U, V$ matrices with columns that are orthogonal to every + other columns and make it square. + - Augment the $\Sigma$ matrix with zero rows to make it have the same + shape as the original matrix. + + The procedure will be illustrated in the examples section. + + Examples + ======== + + we take a full rank matrix first: + + >>> from sympy import Matrix + >>> A = Matrix([[1, 2],[2,1]]) + >>> U, S, V = A.singular_value_decomposition() + >>> U + Matrix([ + [ sqrt(2)/2, sqrt(2)/2], + [-sqrt(2)/2, sqrt(2)/2]]) + >>> S + Matrix([ + [1, 0], + [0, 3]]) + >>> V + Matrix([ + [-sqrt(2)/2, sqrt(2)/2], + [ sqrt(2)/2, sqrt(2)/2]]) + + If a matrix if square and full rank both U, V + are orthogonal in both directions + + >>> U * U.H + Matrix([ + [1, 0], + [0, 1]]) + >>> U.H * U + Matrix([ + [1, 0], + [0, 1]]) + + >>> V * V.H + Matrix([ + [1, 0], + [0, 1]]) + >>> V.H * V + Matrix([ + [1, 0], + [0, 1]]) + >>> A == U * S * V.H + True + + >>> C = Matrix([ + ... [1, 0, 0, 0, 2], + ... [0, 0, 3, 0, 0], + ... [0, 0, 0, 0, 0], + ... [0, 2, 0, 0, 0], + ... ]) + >>> U, S, V = C.singular_value_decomposition() + + >>> V.H * V + Matrix([ + [1, 0, 0], + [0, 1, 0], + [0, 0, 1]]) + >>> V * V.H + Matrix([ + [1/5, 0, 0, 0, 2/5], + [ 0, 1, 0, 0, 0], + [ 0, 0, 1, 0, 0], + [ 0, 0, 0, 0, 0], + [2/5, 0, 0, 0, 4/5]]) + + If you want to augment the results to be a full orthogonal + decomposition, you should augment $V$ with an another orthogonal + column. + + You are able to append an arbitrary standard basis that are linearly + independent to every other columns and you can run the Gram-Schmidt + process to make them augmented as orthogonal basis. + + >>> V_aug = V.row_join(Matrix([[0,0,0,0,1], + ... [0,0,0,1,0]]).H) + >>> V_aug = V_aug.QRdecomposition()[0] + >>> V_aug + Matrix([ + [0, sqrt(5)/5, 0, -2*sqrt(5)/5, 0], + [1, 0, 0, 0, 0], + [0, 0, 1, 0, 0], + [0, 0, 0, 0, 1], + [0, 2*sqrt(5)/5, 0, sqrt(5)/5, 0]]) + >>> V_aug.H * V_aug + Matrix([ + [1, 0, 0, 0, 0], + [0, 1, 0, 0, 0], + [0, 0, 1, 0, 0], + [0, 0, 0, 1, 0], + [0, 0, 0, 0, 1]]) + >>> V_aug * V_aug.H + Matrix([ + [1, 0, 0, 0, 0], + [0, 1, 0, 0, 0], + [0, 0, 1, 0, 0], + [0, 0, 0, 1, 0], + [0, 0, 0, 0, 1]]) + + Similarly we augment U + + >>> U_aug = U.row_join(Matrix([0,0,1,0])) + >>> U_aug = U_aug.QRdecomposition()[0] + >>> U_aug + Matrix([ + [0, 1, 0, 0], + [0, 0, 1, 0], + [0, 0, 0, 1], + [1, 0, 0, 0]]) + + >>> U_aug.H * U_aug + Matrix([ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, 0], + [0, 0, 0, 1]]) + >>> U_aug * U_aug.H + Matrix([ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, 0], + [0, 0, 0, 1]]) + + We add 2 zero columns and one row to S + + >>> S_aug = S.col_join(Matrix([[0,0,0]])) + >>> S_aug = S_aug.row_join(Matrix([[0,0,0,0], + ... [0,0,0,0]]).H) + >>> S_aug + Matrix([ + [2, 0, 0, 0, 0], + [0, sqrt(5), 0, 0, 0], + [0, 0, 3, 0, 0], + [0, 0, 0, 0, 0]]) + + + + >>> U_aug * S_aug * V_aug.H == C + True + + """ + + AH = A.H + m, n = A.shape + if m >= n: + V, S = (AH * A).diagonalize() + + ranked = [] + for i, x in enumerate(S.diagonal()): + if not x.is_zero: + ranked.append(i) + + V = V[:, ranked] + + Singular_vals = [sqrt(S[i, i]) for i in range(S.rows) if i in ranked] + + S = S.zeros(len(Singular_vals)) + + for i, sv in enumerate(Singular_vals): + S[i, i] = sv + + V, _ = V.QRdecomposition() + U = A * V * S.inv() + else: + U, S = (A * AH).diagonalize() + + ranked = [] + for i, x in enumerate(S.diagonal()): + if not x.is_zero: + ranked.append(i) + + U = U[:, ranked] + Singular_vals = [sqrt(S[i, i]) for i in range(S.rows) if i in ranked] + + S = S.zeros(len(Singular_vals)) + + for i, sv in enumerate(Singular_vals): + S[i, i] = sv + + U, _ = U.QRdecomposition() + V = AH * U * S.inv() + + return U, S, V + +def _QRdecomposition_optional(M, normalize=True): + def dot(u, v): + return u.dot(v, hermitian=True) + + dps = _get_intermediate_simp(expand_mul, expand_mul) + + A = M.as_mutable() + ranked = [] + + Q = A + R = A.zeros(A.cols) + + for j in range(A.cols): + for i in range(j): + if Q[:, i].is_zero_matrix: + continue + + R[i, j] = dot(Q[:, i], Q[:, j]) / dot(Q[:, i], Q[:, i]) + R[i, j] = dps(R[i, j]) + Q[:, j] -= Q[:, i] * R[i, j] + + Q[:, j] = dps(Q[:, j]) + if Q[:, j].is_zero_matrix is not True: + ranked.append(j) + R[j, j] = M.one + + Q = Q.extract(range(Q.rows), ranked) + R = R.extract(ranked, range(R.cols)) + + if normalize: + # Normalization + for i in range(Q.cols): + norm = Q[:, i].norm() + Q[:, i] /= norm + R[i, :] *= norm + + return M.__class__(Q), M.__class__(R) + + +def _QRdecomposition(M): + r"""Returns a QR decomposition. + + Explanation + =========== + + A QR decomposition is a decomposition in the form $A = Q R$ + where + + - $Q$ is a column orthogonal matrix. + - $R$ is a upper triangular (trapezoidal) matrix. + + A column orthogonal matrix satisfies + $\mathbb{I} = Q^H Q$ while a full orthogonal matrix satisfies + relation $\mathbb{I} = Q Q^H = Q^H Q$ where $I$ is an identity + matrix with matching dimensions. + + For matrices which are not square or are rank-deficient, it is + sufficient to return a column orthogonal matrix because augmenting + them may introduce redundant computations. + And an another advantage of this is that you can easily inspect the + matrix rank by counting the number of columns of $Q$. + + If you want to augment the results to return a full orthogonal + decomposition, you should use the following procedures. + + - Augment the $Q$ matrix with columns that are orthogonal to every + other columns and make it square. + - Augment the $R$ matrix with zero rows to make it have the same + shape as the original matrix. + + The procedure will be illustrated in the examples section. + + Examples + ======== + + A full rank matrix example: + + >>> from sympy import Matrix + >>> A = Matrix([[12, -51, 4], [6, 167, -68], [-4, 24, -41]]) + >>> Q, R = A.QRdecomposition() + >>> Q + Matrix([ + [ 6/7, -69/175, -58/175], + [ 3/7, 158/175, 6/175], + [-2/7, 6/35, -33/35]]) + >>> R + Matrix([ + [14, 21, -14], + [ 0, 175, -70], + [ 0, 0, 35]]) + + If the matrix is square and full rank, the $Q$ matrix becomes + orthogonal in both directions, and needs no augmentation. + + >>> Q * Q.H + Matrix([ + [1, 0, 0], + [0, 1, 0], + [0, 0, 1]]) + >>> Q.H * Q + Matrix([ + [1, 0, 0], + [0, 1, 0], + [0, 0, 1]]) + + >>> A == Q*R + True + + A rank deficient matrix example: + + >>> A = Matrix([[12, -51, 0], [6, 167, 0], [-4, 24, 0]]) + >>> Q, R = A.QRdecomposition() + >>> Q + Matrix([ + [ 6/7, -69/175], + [ 3/7, 158/175], + [-2/7, 6/35]]) + >>> R + Matrix([ + [14, 21, 0], + [ 0, 175, 0]]) + + QRdecomposition might return a matrix Q that is rectangular. + In this case the orthogonality condition might be satisfied as + $\mathbb{I} = Q.H*Q$ but not in the reversed product + $\mathbb{I} = Q * Q.H$. + + >>> Q.H * Q + Matrix([ + [1, 0], + [0, 1]]) + >>> Q * Q.H + Matrix([ + [27261/30625, 348/30625, -1914/6125], + [ 348/30625, 30589/30625, 198/6125], + [ -1914/6125, 198/6125, 136/1225]]) + + If you want to augment the results to be a full orthogonal + decomposition, you should augment $Q$ with an another orthogonal + column. + + You are able to append an arbitrary standard basis that are linearly + independent to every other columns and you can run the Gram-Schmidt + process to make them augmented as orthogonal basis. + + >>> Q_aug = Q.row_join(Matrix([0, 0, 1])) + >>> Q_aug = Q_aug.QRdecomposition()[0] + >>> Q_aug + Matrix([ + [ 6/7, -69/175, 58/175], + [ 3/7, 158/175, -6/175], + [-2/7, 6/35, 33/35]]) + >>> Q_aug.H * Q_aug + Matrix([ + [1, 0, 0], + [0, 1, 0], + [0, 0, 1]]) + >>> Q_aug * Q_aug.H + Matrix([ + [1, 0, 0], + [0, 1, 0], + [0, 0, 1]]) + + Augmenting the $R$ matrix with zero row is straightforward. + + >>> R_aug = R.col_join(Matrix([[0, 0, 0]])) + >>> R_aug + Matrix([ + [14, 21, 0], + [ 0, 175, 0], + [ 0, 0, 0]]) + >>> Q_aug * R_aug == A + True + + A zero matrix example: + + >>> from sympy import Matrix + >>> A = Matrix.zeros(3, 4) + >>> Q, R = A.QRdecomposition() + + They may return matrices with zero rows and columns. + + >>> Q + Matrix(3, 0, []) + >>> R + Matrix(0, 4, []) + >>> Q*R + Matrix([ + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0]]) + + As the same augmentation rule described above, $Q$ can be augmented + with columns of an identity matrix and $R$ can be augmented with + rows of a zero matrix. + + >>> Q_aug = Q.row_join(Matrix.eye(3)) + >>> R_aug = R.col_join(Matrix.zeros(3, 4)) + >>> Q_aug * Q_aug.T + Matrix([ + [1, 0, 0], + [0, 1, 0], + [0, 0, 1]]) + >>> R_aug + Matrix([ + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0]]) + >>> Q_aug * R_aug == A + True + + See Also + ======== + + sympy.matrices.dense.DenseMatrix.cholesky + sympy.matrices.dense.DenseMatrix.LDLdecomposition + sympy.matrices.matrices.MatrixBase.LUdecomposition + QRsolve + """ + return _QRdecomposition_optional(M, normalize=True) + +def _upper_hessenberg_decomposition(A): + """Converts a matrix into Hessenberg matrix H. + + Returns 2 matrices H, P s.t. + $P H P^{T} = A$, where H is an upper hessenberg matrix + and P is an orthogonal matrix + + Examples + ======== + + >>> from sympy import Matrix + >>> A = Matrix([ + ... [1,2,3], + ... [-3,5,6], + ... [4,-8,9], + ... ]) + >>> H, P = A.upper_hessenberg_decomposition() + >>> H + Matrix([ + [1, 6/5, 17/5], + [5, 213/25, -134/25], + [0, 216/25, 137/25]]) + >>> P + Matrix([ + [1, 0, 0], + [0, -3/5, 4/5], + [0, 4/5, 3/5]]) + >>> P * H * P.H == A + True + + + References + ========== + + .. [#] https://mathworld.wolfram.com/HessenbergDecomposition.html + """ + + M = A.as_mutable() + + if not M.is_square: + raise NonSquareMatrixError("Matrix must be square.") + + n = M.cols + P = M.eye(n) + H = M + + for j in range(n - 2): + + u = H[j + 1:, j] + + if u[1:, :].is_zero_matrix: + continue + + if sign(u[0]) != 0: + u[0] = u[0] + sign(u[0]) * u.norm() + else: + u[0] = u[0] + u.norm() + + v = u / u.norm() + + H[j + 1:, :] = H[j + 1:, :] - 2 * v * (v.H * H[j + 1:, :]) + H[:, j + 1:] = H[:, j + 1:] - (H[:, j + 1:] * (2 * v)) * v.H + P[:, j + 1:] = P[:, j + 1:] - (P[:, j + 1:] * (2 * v)) * v.H + + return H, P diff --git a/shared/package-files/31/318583a09dc070222d65d029a1e3a0b565830f1aaec13a27e6fe533863fbd3ea/blob b/shared/package-files/31/318583a09dc070222d65d029a1e3a0b565830f1aaec13a27e6fe533863fbd3ea/blob new file mode 100644 index 0000000000000000000000000000000000000000..8ee8cb92e72d9c507ad0ee06dc6a38406ab06f34 Binary files /dev/null and b/shared/package-files/31/318583a09dc070222d65d029a1e3a0b565830f1aaec13a27e6fe533863fbd3ea/blob differ diff --git a/shared/package-files/31/318ccdeebeaa8227898f0ebc83823e1ca5ee9b4aff7e195fd6f0257d12f8ef29/blob b/shared/package-files/31/318ccdeebeaa8227898f0ebc83823e1ca5ee9b4aff7e195fd6f0257d12f8ef29/blob new file mode 100644 index 0000000000000000000000000000000000000000..a97ce01c2dcce2108fb2d92736a8d509bcab44b0 --- /dev/null +++ b/shared/package-files/31/318ccdeebeaa8227898f0ebc83823e1ca5ee9b4aff7e195fd6f0257d12f8ef29/blob @@ -0,0 +1,38 @@ +"""Public protocols for plugin authors.""" + +from __future__ import annotations + +from narwhals._compliant import ( + CompliantDataFrame, + CompliantExpr, + CompliantGroupBy, + CompliantLazyFrame, + CompliantNamespace, + CompliantSeries, +) +from narwhals._compliant.any_namespace import ( + CatNamespace, + DateTimeNamespace, + ListNamespace, + StringNamespace, + StructNamespace, +) +from narwhals._compliant.expr import CompliantExprNameNamespace +from narwhals._compliant.selectors import CompliantSelector, CompliantSelectorNamespace + +__all__ = [ + "CatNamespace", + "CompliantDataFrame", + "CompliantExpr", + "CompliantExprNameNamespace", + "CompliantGroupBy", + "CompliantLazyFrame", + "CompliantNamespace", + "CompliantSelector", + "CompliantSelectorNamespace", + "CompliantSeries", + "DateTimeNamespace", + "ListNamespace", + "StringNamespace", + "StructNamespace", +] diff --git a/shared/package-files/31/318f1a75814d596bef021c1b983b833285a2b2c98343b18c64365387ccf04748/blob b/shared/package-files/31/318f1a75814d596bef021c1b983b833285a2b2c98343b18c64365387ccf04748/blob new file mode 100644 index 0000000000000000000000000000000000000000..e2b2486ea9e43183bed1c07c0bb2a654c8334832 --- /dev/null +++ b/shared/package-files/31/318f1a75814d596bef021c1b983b833285a2b2c98343b18c64365387ccf04748/blob @@ -0,0 +1,26 @@ +#pragma once +// @generated by torchgen/gen.py from DispatchKeyFunction.h + +// NB: The implementing C++ file is RegisterDispatchKey.cpp + +// The only #includes we need are for custom classes that have defaults in the C++ API +#include +#include +#include + +// Forward declarations of any types needed in the operator signatures. +// We can't directly include these classes because it will cause circular include dependencies. +// This file is included by TensorBody.h, which defines the Tensor class. +#include + +namespace at { + +namespace cuda { + +TORCH_API at::Tensor exp(const at::Tensor & self); +TORCH_API at::Tensor & exp_out(at::Tensor & out, const at::Tensor & self); +TORCH_API at::Tensor & exp_outf(const at::Tensor & self, at::Tensor & out); +TORCH_API at::Tensor & exp_(at::Tensor & self); + +} // namespace cuda +} // namespace at diff --git a/shared/package-files/31/31904578d8a984e755730eb6125e5c3a6cbbea84b92d2fc0c02451fb6796463c/blob b/shared/package-files/31/31904578d8a984e755730eb6125e5c3a6cbbea84b92d2fc0c02451fb6796463c/blob new file mode 100644 index 0000000000000000000000000000000000000000..606cce9d898d64cd3e4f78792b89e4ee10575f00 --- /dev/null +++ b/shared/package-files/31/31904578d8a984e755730eb6125e5c3a6cbbea84b92d2fc0c02451fb6796463c/blob @@ -0,0 +1,147 @@ +from distutils.errors import DistutilsArgError +import inspect +import glob +import platform +import distutils.command.install as orig + +import setuptools +from ..warnings import SetuptoolsDeprecationWarning, SetuptoolsWarning + +# Prior to numpy 1.9, NumPy relies on the '_install' name, so provide it for +# now. See https://github.com/pypa/setuptools/issues/199/ +_install = orig.install + + +class install(orig.install): + """Use easy_install to install the package, w/dependencies""" + + user_options = orig.install.user_options + [ + ('old-and-unmanageable', None, "Try not to use this!"), + ( + 'single-version-externally-managed', + None, + "used by system package builders to create 'flat' eggs", + ), + ] + boolean_options = orig.install.boolean_options + [ + 'old-and-unmanageable', + 'single-version-externally-managed', + ] + new_commands = [ + ('install_egg_info', lambda self: True), + ('install_scripts', lambda self: True), + ] + _nc = dict(new_commands) + + def initialize_options(self): + SetuptoolsDeprecationWarning.emit( + "setup.py install is deprecated.", + """ + Please avoid running ``setup.py`` directly. + Instead, use pypa/build, pypa/installer or other + standards-based tools. + """, + see_url="https://blog.ganssle.io/articles/2021/10/setup-py-deprecated.html", + # TODO: Document how to bootstrap setuptools without install + # (e.g. by unziping the wheel file) + # and then add a due_date to this warning. + ) + + orig.install.initialize_options(self) + self.old_and_unmanageable = None + self.single_version_externally_managed = None + + def finalize_options(self): + orig.install.finalize_options(self) + if self.root: + self.single_version_externally_managed = True + elif self.single_version_externally_managed: + if not self.root and not self.record: + raise DistutilsArgError( + "You must specify --record or --root when building system" + " packages" + ) + + def handle_extra_path(self): + if self.root or self.single_version_externally_managed: + # explicit backward-compatibility mode, allow extra_path to work + return orig.install.handle_extra_path(self) + + # Ignore extra_path when installing an egg (or being run by another + # command without --root or --single-version-externally-managed + self.path_file = None + self.extra_dirs = '' + + def run(self): + # Explicit request for old-style install? Just do it + if self.old_and_unmanageable or self.single_version_externally_managed: + return orig.install.run(self) + + if not self._called_from_setup(inspect.currentframe()): + # Run in backward-compatibility mode to support bdist_* commands. + orig.install.run(self) + else: + self.do_egg_install() + + @staticmethod + def _called_from_setup(run_frame): + """ + Attempt to detect whether run() was called from setup() or by another + command. If called by setup(), the parent caller will be the + 'run_command' method in 'distutils.dist', and *its* caller will be + the 'run_commands' method. If called any other way, the + immediate caller *might* be 'run_command', but it won't have been + called by 'run_commands'. Return True in that case or if a call stack + is unavailable. Return False otherwise. + """ + if run_frame is None: + msg = "Call stack not available. bdist_* commands may fail." + SetuptoolsWarning.emit(msg) + if platform.python_implementation() == 'IronPython': + msg = "For best results, pass -X:Frames to enable call stack." + SetuptoolsWarning.emit(msg) + return True + + frames = inspect.getouterframes(run_frame) + for frame in frames[2:4]: + (caller,) = frame[:1] + info = inspect.getframeinfo(caller) + caller_module = caller.f_globals.get('__name__', '') + + if caller_module == "setuptools.dist" and info.function == "run_command": + # Starting from v61.0.0 setuptools overwrites dist.run_command + continue + + return caller_module == 'distutils.dist' and info.function == 'run_commands' + + def do_egg_install(self): + easy_install = self.distribution.get_command_class('easy_install') + + cmd = easy_install( + self.distribution, + args="x", + root=self.root, + record=self.record, + ) + cmd.ensure_finalized() # finalize before bdist_egg munges install cmd + cmd.always_copy_from = '.' # make sure local-dir eggs get installed + + # pick up setup-dir .egg files only: no .egg-info + cmd.package_index.scan(glob.glob('*.egg')) + + self.run_command('bdist_egg') + args = [self.distribution.get_command_obj('bdist_egg').egg_output] + + if setuptools.bootstrap_install_from: + # Bootstrap self-installation of setuptools + args.insert(0, setuptools.bootstrap_install_from) + + cmd.args = args + cmd.run(show_deprecation=False) + setuptools.bootstrap_install_from = None + + +# XXX Python 3.1 doesn't see _nc if this is inside the class +install.sub_commands = [ + cmd for cmd in orig.install.sub_commands if cmd[0] not in install._nc +] + install.new_commands diff --git a/shared/package-files/31/3190eedf52cf2df82eea33fd21992b97035eb377ffb0bf1614fe410a191429d6/blob b/shared/package-files/31/3190eedf52cf2df82eea33fd21992b97035eb377ffb0bf1614fe410a191429d6/blob new file mode 100644 index 0000000000000000000000000000000000000000..b8536ef0387195baad9fe9c0b29f26f7db569c2f --- /dev/null +++ b/shared/package-files/31/3190eedf52cf2df82eea33fd21992b97035eb377ffb0bf1614fe410a191429d6/blob @@ -0,0 +1 @@ +-