From 59f24a40432a0872449ae0bdfefe7cf8ccd1d614 Mon Sep 17 00:00:00 2001 From: jbloom Date: Mon, 6 Nov 2023 15:25:59 -0800 Subject: [PATCH 1/4] update requirements to newer versions --- data/preprocess_data.py | 4 +- requirements.txt | 185 ++++++++++++++++++++-------------------- 2 files changed, 96 insertions(+), 93 deletions(-) diff --git a/data/preprocess_data.py b/data/preprocess_data.py index d1938b8..bf3fb16 100644 --- a/data/preprocess_data.py +++ b/data/preprocess_data.py @@ -179,6 +179,8 @@ def get_data_args(notebook=False): parser.add_argument('--L', type=int, default=200, help='training sequence length') + parser.add_argument('--dir', type=str, default='./data', + help='dataset directory (default: ./data/)') parser.add_argument('--input', type=str, default='macho_raw.pkl', help='dataset filename. file is expected in ./data/') parser.add_argument('--output', type=str, default='macho', @@ -210,7 +212,7 @@ def main(): args = get_data_args() np.random.seed(args.seed) - data = joblib.load('data/{}'.format(args.input)) + data = joblib.load(f'{args.dir}/{args.input}') data, all_labels, n_classes, n_inputs, label_to_num = sanitize_data(data, args) unique_label, count = np.unique([lc.label for lc in data], return_counts=True) diff --git a/requirements.txt b/requirements.txt index a12dd7b..caa3027 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,46 +1,46 @@ accelerate==0.23.0 aiohttp==3.8.6 aiosignal==1.3.1 -anyio @ file:///home/conda/feedstock_root/build_artifacts/anyio_1688651106312/work/dist +anyio appdirs==1.4.4 -argon2-cffi @ file:///home/conda/feedstock_root/build_artifacts/argon2-cffi_1640817743617/work -argon2-cffi-bindings @ file:///home/conda/feedstock_root/build_artifacts/argon2-cffi-bindings_1666850768662/work +argon2-cffi +argon2-cffi-bindings astrobase==0.5.3 astropy==5.3.1 -asttokens @ file:///home/conda/feedstock_root/build_artifacts/asttokens_1670263926556/work -async-lru @ file:///home/conda/feedstock_root/build_artifacts/async-lru_1688997201545/work +asttokens +async-lru async-timeout==4.0.3 -attrs @ file:///home/conda/feedstock_root/build_artifacts/attrs_1683424013410/work -Babel @ file:///home/conda/feedstock_root/build_artifacts/babel_1677767029043/work -backcall @ file:///home/conda/feedstock_root/build_artifacts/backcall_1592338393461/work +attrs +Babel +backcall backoff==2.2.1 -backports.functools-lru-cache @ file:///home/conda/feedstock_root/build_artifacts/backports.functools_lru_cache_1687772187254/work -beautifulsoup4 @ file:///home/conda/feedstock_root/build_artifacts/beautifulsoup4_1680888073205/work -bleach @ file:///home/conda/feedstock_root/build_artifacts/bleach_1674535352125/work -Brotli @ file:///home/conda/feedstock_root/build_artifacts/brotli-split_1687884021435/work +backports.functools-lru-cache +beautifulsoup4 +bleach +Brotli certifi==2022.12.7 -cffi @ file:///home/conda/feedstock_root/build_artifacts/cffi_1671179353105/work +cffi chardet==5.1.0 charset-normalizer==2.1.1 click==8.1.5 -comm @ file:///home/conda/feedstock_root/build_artifacts/comm_1679481329611/work +comm configparser==6.0.0 contourpy==1.1.0 cycler==0.11.0 Cython==3.0.0 datasets==2.14.5 -debugpy @ file:///home/conda/feedstock_root/build_artifacts/debugpy_1680755465990/work -decorator @ file:///home/conda/feedstock_root/build_artifacts/decorator_1641555617451/work -defusedxml @ file:///home/conda/feedstock_root/build_artifacts/defusedxml_1615232257335/work +debugpy +decorator +defusedxml dill==0.3.7 docker-pycreds==0.4.0 -entrypoints @ file:///home/conda/feedstock_root/build_artifacts/entrypoints_1643888246732/work +entrypoints evaluate==0.4.1 -exceptiongroup @ file:///home/conda/feedstock_root/build_artifacts/exceptiongroup_1688381075899/work -executing @ file:///home/conda/feedstock_root/build_artifacts/executing_1667317341051/work -fastjsonschema @ file:///home/conda/feedstock_root/build_artifacts/python-fastjsonschema_1684761244589/work/dist +exceptiongroup +executing +fastjsonschema filelock==3.12.4 -flit_core @ file:///home/conda/feedstock_root/build_artifacts/flit-core_1684084314667/work/source/flit_core +flit_core fonttools==4.41.0 frozenlist==1.4.0 fsspec==2023.6.0 @@ -50,117 +50,118 @@ gluonts==0.13.7 gql==3.4.1 graphql-core==3.2.3 huggingface-hub==0.17.3 -idna @ file:///home/conda/feedstock_root/build_artifacts/idna_1663625384323/work -importlib-metadata @ file:///home/conda/feedstock_root/build_artifacts/importlib-metadata_1688754491823/work -importlib-resources @ file:///home/conda/feedstock_root/build_artifacts/importlib_resources_1689017639396/work -ipykernel @ file:///home/conda/feedstock_root/build_artifacts/ipykernel_1688404758065/work -ipython @ file:///home/conda/feedstock_root/build_artifacts/ipython_1685727741709/work -jedi @ file:///home/conda/feedstock_root/build_artifacts/jedi_1669134318875/work -Jinja2 @ file:///home/conda/feedstock_root/build_artifacts/jinja2_1654302431367/work +idna +importlib-metadata +importlib-resources +ipykernel +ipython +jedi +Jinja2 joblib==1.3.1 jplephem==2.18 -json5 @ file:///home/conda/feedstock_root/build_artifacts/json5_1688248289187/work -jsonschema @ file:///home/conda/feedstock_root/build_artifacts/jsonschema-meta_1689687135513/work -jsonschema-specifications @ file:///home/conda/feedstock_root/build_artifacts/jsonschema-specifications_1689701150890/work -jupyter-events @ file:///home/conda/feedstock_root/build_artifacts/jupyter_events_1673559782596/work -jupyter-lsp @ file:///home/conda/feedstock_root/build_artifacts/jupyter-lsp-meta_1685453365113/work/jupyter-lsp -jupyter_client @ file:///home/conda/feedstock_root/build_artifacts/jupyter_client_1687700988094/work -jupyter_core @ file:///home/conda/feedstock_root/build_artifacts/jupyter_core_1686775611663/work -jupyter_server @ file:///home/conda/feedstock_root/build_artifacts/jupyter_server_1687869799272/work -jupyter_server_terminals @ file:///home/conda/feedstock_root/build_artifacts/jupyter_server_terminals_1673491454549/work -jupyterlab @ file:///home/conda/feedstock_root/build_artifacts/jupyterlab_1689253413907/work -jupyterlab-pygments @ file:///home/conda/feedstock_root/build_artifacts/jupyterlab_pygments_1649936611996/work -jupyterlab_server @ file:///home/conda/feedstock_root/build_artifacts/jupyterlab_server_1686659921555/work +json5 +jsonschema +jsonschema-specifications +jupyter-events +jupyter-lsp +jupyter_client +jupyter_core +jupyter_server +jupyter_server_terminals +jupyterlab +jupyterlab-pygments +jupyterlab_server kiwisolver==1.4.4 -MarkupSafe @ file:///home/conda/feedstock_root/build_artifacts/markupsafe_1685769049201/work +MarkupSafe matplotlib==3.7.2 -matplotlib-inline @ file:///home/conda/feedstock_root/build_artifacts/matplotlib-inline_1660814786464/work -mistune @ file:///home/conda/feedstock_root/build_artifacts/mistune_1686313613819/work/dist +matplotlib-inline +mistune multidict==6.0.4 multiprocess==0.70.15 -nbclient @ file:///home/conda/feedstock_root/build_artifacts/nbclient_1684790896106/work -nbconvert @ file:///home/conda/feedstock_root/build_artifacts/nbconvert-meta_1689603149170/work -nbformat @ file:///home/conda/feedstock_root/build_artifacts/nbformat_1688996247388/work -nest-asyncio @ file:///home/conda/feedstock_root/build_artifacts/nest-asyncio_1664684991461/work -notebook_shim @ file:///home/conda/feedstock_root/build_artifacts/notebook-shim_1682360583588/work -numpy==1.24.1 +nbclient +nbconvert +nbformat +nest-asyncio +notebook_shim +numpy==1.26.1 nvidia-ml-py3==7.352.0 -overrides @ file:///home/conda/feedstock_root/build_artifacts/overrides_1666057828264/work -packaging @ file:///home/conda/feedstock_root/build_artifacts/packaging_1681337016113/work +overrides +packaging pandas==2.0.3 -pandocfilters @ file:///home/conda/feedstock_root/build_artifacts/pandocfilters_1631603243851/work -parso @ file:///home/conda/feedstock_root/build_artifacts/parso_1638334955874/work +pandocfilters +parso pathtools==0.1.2 -pexpect @ file:///home/conda/feedstock_root/build_artifacts/pexpect_1667297516076/work -pickleshare @ file:///home/conda/feedstock_root/build_artifacts/pickleshare_1602536217715/work +pexpect +pickleshare Pillow==9.3.0 -pkgutil_resolve_name @ file:///home/conda/feedstock_root/build_artifacts/pkgutil-resolve-name_1633981968097/work -platformdirs @ file:///home/conda/feedstock_root/build_artifacts/platformdirs_1689538620473/work -prometheus-client @ file:///home/conda/feedstock_root/build_artifacts/prometheus_client_1689032443210/work +pkgutil_resolve_name +platformdirs +prometheus-client promise==2.3 -prompt-toolkit @ file:///home/conda/feedstock_root/build_artifacts/prompt-toolkit_1688565951714/work +prompt-toolkit protobuf==4.23.4 -psutil @ file:///home/conda/feedstock_root/build_artifacts/psutil_1681775027942/work -ptyprocess @ file:///home/conda/feedstock_root/build_artifacts/ptyprocess_1609419310487/work/dist/ptyprocess-0.7.0-py2.py3-none-any.whl -pure-eval @ file:///home/conda/feedstock_root/build_artifacts/pure_eval_1642875951954/work +psutil +ptyprocess +pure-eval Py-PDM==0.6.0 pyarrow==13.0.0 -pycparser @ file:///home/conda/feedstock_root/build_artifacts/pycparser_1636257122734/work +pycparser pydantic==1.10.13 pyeebls==0.1.6 pyerfa==2.0.0.3 -Pygments @ file:///home/conda/feedstock_root/build_artifacts/pygments_1681904169130/work +Pygments pyparsing==3.0.9 -PySocks @ file:///home/conda/feedstock_root/build_artifacts/pysocks_1661604839144/work -python-dateutil @ file:///home/conda/feedstock_root/build_artifacts/python-dateutil_1626286286081/work -python-json-logger @ file:///home/conda/feedstock_root/build_artifacts/python-json-logger_1677079630776/work -pytz @ file:///home/conda/feedstock_root/build_artifacts/pytz_1680088766131/work +PySocks +python-dateutil +python-json-logger +pytz PyYAML==6.0.1 -pyzmq @ file:///home/conda/feedstock_root/build_artifacts/pyzmq_1685519264162/work -referencing @ file:///home/conda/feedstock_root/build_artifacts/referencing_1689701127998/work +pyzmq +referencing regex==2023.10.3 requests==2.28.1 responses==0.18.0 -rfc3339-validator @ file:///home/conda/feedstock_root/build_artifacts/rfc3339-validator_1638811747357/work -rfc3986-validator @ file:///home/conda/feedstock_root/build_artifacts/rfc3986-validator_1598024191506/work -rpds-py @ file:///home/conda/feedstock_root/build_artifacts/rpds-py_1689600952871/work +rfc3339-validator +rfc3986-validator +rpds-py safetensors==0.4.0 scikit-learn==1.3.0 scipy==1.11.1 seaborn==0.13.0 -Send2Trash @ file:///home/conda/feedstock_root/build_artifacts/send2trash_1682601222253/work +Send2Trash sentry-sdk==1.28.1 setproctitle==1.3.2 shortuuid==1.0.11 -six @ file:///home/conda/feedstock_root/build_artifacts/six_1620240208055/work +six smmap==5.0.0 -sniffio @ file:///home/conda/feedstock_root/build_artifacts/sniffio_1662051266223/work -soupsieve @ file:///home/conda/feedstock_root/build_artifacts/soupsieve_1658207591808/work -stack-data @ file:///home/conda/feedstock_root/build_artifacts/stack_data_1669632077133/work +sniffio +soupsieve +stack-data subprocess32==3.5.4 -terminado @ file:///home/conda/feedstock_root/build_artifacts/terminado_1670253674810/work +terminado threadpoolctl==3.2.0 -tinycss2 @ file:///home/conda/feedstock_root/build_artifacts/tinycss2_1666100256010/work +tinycss2 tokenizers==0.14.1 -tomli @ file:///home/conda/feedstock_root/build_artifacts/tomli_1644342247877/work +tomli toolz==0.12.0 -torch==1.12.1+cu113 -torchaudio==0.12.1+cu113 -torchvision==0.13.1+cu113 -tornado @ file:///home/conda/feedstock_root/build_artifacts/tornado_1684150054582/work +torch==2.1.0 +torchaudio==2.1.0 +torchvision==0.16.0 +tornado tqdm==4.65.0 -traitlets @ file:///home/conda/feedstock_root/build_artifacts/traitlets_1675110562325/work -transformers @ git+https://github.com/huggingface/transformers@de55ead1f1acb218edf7994a4034fc6f77d636e2 -typing-utils @ file:///home/conda/feedstock_root/build_artifacts/typing_utils_1622899189314/work +traitlets +transformers +typing-utils typing_extensions==4.4.0 tzdata==2023.3 ujson==5.8.0 urllib3==1.26.13 wandb==0.15.5 watchdog==3.0.0 -wcwidth @ file:///home/conda/feedstock_root/build_artifacts/wcwidth_1673864653149/work +wcwidth webencodings==0.5.1 -websocket-client @ file:///home/conda/feedstock_root/build_artifacts/websocket-client_1687789148259/work +websocket-client xxhash==3.4.1 yarl==1.9.2 -zipp @ file:///home/conda/feedstock_root/build_artifacts/zipp_1689374466814/work +zipp + From 43a79257c564c1d2c0f3a172a5ed68e9049494f9 Mon Sep 17 00:00:00 2001 From: jbloom Date: Mon, 6 Nov 2023 15:26:32 -0800 Subject: [PATCH 2/4] add in light_curve and enviroment.yaml --- data/light_curve.py | 107 ++++++++++++++++++++ environment.yaml | 235 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 342 insertions(+) create mode 100644 data/light_curve.py create mode 100644 environment.yaml diff --git a/data/light_curve.py b/data/light_curve.py new file mode 100644 index 0000000..ce59357 --- /dev/null +++ b/data/light_curve.py @@ -0,0 +1,107 @@ +import numpy as np + + +class LightCurve: + def __init__(self, times, measurements, errors=None, survey=None, name=None, + best_period=None, best_score=None, label=None, p=None, + p_signif=None, p_class=None, ss_resid=None, metadata=None): + """ + + Parameters + ---------- + times: ndarray + 1D array of shape (L,) + measurements: ndarray + 1D array of shape (L,) + errors: ndarray + (optional) 1D array of shape (L,) + survey: string + survey name + name: string + object name + best_period: float + obsolete. load period into p instead + best_score: float + obsolete + label: string or int + class of light-curve. can be name or number. + p: float + period + p_signif: float + obsolete + p_class: float + obsolete + ss_resid: float + obsolete + metadata: ndarray + 1D array of features from external catelogs to be used as auxiliary network inputs + """ + self.times = times + self.measurements = measurements + self.errors = errors if errors is not None else np.zeros_like(times) + self.label = label + self.metadata = metadata + self.survey = survey + self.name = name + + # period + self.p = p + + # optional + self.best_period = best_period + self.best_score = best_score + self.class_prob = None + self.ss_resid = ss_resid + self.p_signif = p_signif + self.p_class = p_class + + + def __repr__(self): + return "LightCurve(" + ', '.join("{}={}".format(k, v) + for k, v in self.__dict__.items()) + ")" + + def __len__(self): + return len(self.times) + + def split(self, n_min=0, n_max=np.inf): + inds = np.arange(len(self.times)) + splits = [np.array(x) + for x in np.array_split(inds, np.arange(n_max, len(inds), step=n_max)) + if len(x) >= n_min] + return [LightCurve(survey=self.survey, name=self.name, + times=self.times[s], + measurements=self.measurements[s], + errors=self.errors[s], best_period=self.best_period, + best_score=self.best_score, label=self.label, + p=self.p, p_signif=self.p_signif, p_class=self.p_class, + ss_resid=self.ss_resid) + for s in splits] + + def fit_supersmoother(self, periodic=True, scale=True): + from supersmoother import SuperSmoother + model = SuperSmoother(period=self.p if periodic else None) + try: + model.fit(self.times, self.measurements, self.errors) + self.ss_resid = np.sqrt(np.mean((model.predict(self.times) - self.measurements) ** 2)) + if scale: + self.ss_resid /= np.std(self.measurements) + except ValueError: + self.ss_resid = np.inf + + def period_fold(self, p=None): + self.times_copy = np.copy(self.times) + self.measurements_copy = np.copy(self.measurements) + self.errors_copy = np.copy(self.errors) + if p is None: + p = self.p + self.times = self.times % p + inds = np.argsort(self.times) + self.times = self.times[inds] + self.measurements = self.measurements[inds] + self.errors = self.errors[inds] + self.inds = inds + + def period_unfold(self): + self.times = self.times_copy + self.measurements = self.measurements_copy + self.errors = self.errors_copy diff --git a/environment.yaml b/environment.yaml new file mode 100644 index 0000000..7ff1bea --- /dev/null +++ b/environment.yaml @@ -0,0 +1,235 @@ +name: multi_modal +channels: + - conda-forge + - defaults +dependencies: + - anyio=4.0.0=pyhd8ed1ab_0 + - appnope=0.1.3=pyhd8ed1ab_0 + - argon2-cffi=23.1.0=pyhd8ed1ab_0 + - argon2-cffi-bindings=21.2.0=py310h2aa6e3c_4 + - arrow=1.3.0=pyhd8ed1ab_0 + - asttokens=2.4.1=pyhd8ed1ab_0 + - async-lru=2.0.4=pyhd8ed1ab_0 + - attrs=23.1.0=pyh71513ae_1 + - babel=2.13.1=pyhd8ed1ab_0 + - backports=1.0=pyhd8ed1ab_3 + - backports.functools_lru_cache=1.6.5=pyhd8ed1ab_0 + - beautifulsoup4=4.12.2=pyha770c72_0 + - bleach=6.1.0=pyhd8ed1ab_0 + - brotli-python=1.1.0=py310h1253130_1 + - bzip2=1.0.8=h10d778d_5 + - ca-certificates=2023.7.22=h8857fd0_0 + - cached-property=1.5.2=hd8ed1ab_1 + - cached_property=1.5.2=pyha770c72_1 + - cffi=1.16.0=py310hdcd7c05_0 + - debugpy=1.8.0=py310h1253130_1 + - decorator=5.1.1=pyhd8ed1ab_0 + - defusedxml=0.7.1=pyhd8ed1ab_0 + - entrypoints=0.4=pyhd8ed1ab_0 + - exceptiongroup=1.1.3=pyhd8ed1ab_0 + - executing=2.0.1=pyhd8ed1ab_0 + - fqdn=1.5.1=pyhd8ed1ab_0 + - idna=3.4=pyhd8ed1ab_0 + - importlib-metadata=6.8.0=pyha770c72_0 + - importlib_metadata=6.8.0=hd8ed1ab_0 + - importlib_resources=6.1.0=pyhd8ed1ab_0 + - ipykernel=6.26.0=pyh3cd1d5f_0 + - ipython=8.17.2=pyh31c8845_0 + - ipywidgets=8.1.1=pyhd8ed1ab_0 + - isoduration=20.11.0=pyhd8ed1ab_0 + - jedi=0.19.1=pyhd8ed1ab_0 + - jinja2=3.1.2=pyhd8ed1ab_1 + - json5=0.9.14=pyhd8ed1ab_0 + - jsonpointer=2.4=py310hbe9552e_3 + - jsonschema=4.19.2=pyhd8ed1ab_0 + - jsonschema-specifications=2023.7.1=pyhd8ed1ab_0 + - jsonschema-with-format-nongpl=4.19.2=pyhd8ed1ab_0 + - jupyter=1.0.0=pyhd8ed1ab_10 + - jupyter-lsp=2.2.0=pyhd8ed1ab_0 + - jupyter_client=8.6.0=pyhd8ed1ab_0 + - jupyter_console=6.6.3=pyhd8ed1ab_0 + - jupyter_core=5.5.0=py310hbe9552e_0 + - jupyter_events=0.9.0=pyhd8ed1ab_0 + - jupyter_server=2.10.0=pyhd8ed1ab_0 + - jupyter_server_terminals=0.4.4=pyhd8ed1ab_1 + - jupyterlab=4.0.8=pyhd8ed1ab_0 + - jupyterlab_pygments=0.2.2=pyhd8ed1ab_0 + - jupyterlab_server=2.25.0=pyhd8ed1ab_0 + - jupyterlab_widgets=3.0.9=pyhd8ed1ab_0 + - libblas=3.9.0=19_osxarm64_openblas + - libcblas=3.9.0=19_osxarm64_openblas + - libcxx=16.0.6=h4653b0c_0 + - libffi=3.4.2=h0d85af4_5 + - libgfortran=5.0.0=13_2_0_hd922786_1 + - libgfortran5=13.2.0=hf226fd6_1 + - liblapack=3.9.0=19_osxarm64_openblas + - libopenblas=0.3.24=openmp_hd76b1f2_0 + - libsodium=1.0.18=h27ca646_1 + - libsqlite=3.44.0=h92b6c6a_0 + - libzlib=1.2.13=h8a1eda9_5 + - llvm-openmp=17.0.4=hcd81f8e_0 + - markupsafe=2.1.3=py310h2aa6e3c_1 + - matplotlib-inline=0.1.6=pyhd8ed1ab_0 + - mistune=3.0.2=pyhd8ed1ab_0 + - nbclient=0.8.0=pyhd8ed1ab_0 + - nbconvert=7.11.0=pyhd8ed1ab_0 + - nbconvert-core=7.11.0=pyhd8ed1ab_0 + - nbconvert-pandoc=7.11.0=pyhd8ed1ab_0 + - nbformat=5.9.2=pyhd8ed1ab_0 + - ncurses=6.4=h93d8f39_2 + - nest-asyncio=1.5.8=pyhd8ed1ab_0 + - notebook=7.0.6=pyhd8ed1ab_0 + - notebook-shim=0.2.3=pyhd8ed1ab_0 + - openssl=3.1.4=hd75f5a5_0 + - overrides=7.4.0=pyhd8ed1ab_0 + - packaging=23.2=pyhd8ed1ab_0 + - pandoc=3.1.3=hce30654_0 + - pandocfilters=1.5.0=pyhd8ed1ab_0 + - parso=0.8.3=pyhd8ed1ab_0 + - pexpect=4.8.0=pyh1a96a4e_2 + - pickleshare=0.7.5=py_1003 + - pip=23.3.1=pyhd8ed1ab_0 + - pkgutil-resolve-name=1.3.10=pyhd8ed1ab_1 + - platformdirs=3.11.0=pyhd8ed1ab_0 + - prometheus_client=0.18.0=pyhd8ed1ab_0 + - prompt-toolkit=3.0.39=pyha770c72_0 + - prompt_toolkit=3.0.39=hd8ed1ab_0 + - ptyprocess=0.7.0=pyhd3deb0d_0 + - pure_eval=0.2.2=pyhd8ed1ab_0 + - pycparser=2.21=pyhd8ed1ab_0 + - pygments=2.16.1=pyhd8ed1ab_0 + - pyobjc-core=10.0=py310hd07e440_0 + - pyobjc-framework-cocoa=10.0=py310hd07e440_1 + - pysocks=1.7.1=pyha2e5f31_6 + - python=3.10.13=h00d2728_0_cpython + - python-dateutil=2.8.2=pyhd8ed1ab_0 + - python-fastjsonschema=2.18.1=pyhd8ed1ab_0 + - python-json-logger=2.0.7=pyhd8ed1ab_0 + - python_abi=3.10=4_cp310 + - pytz=2023.3.post1=pyhd8ed1ab_0 + - pyyaml=6.0.1=py310h2aa6e3c_1 + - pyzmq=25.1.1=py310h7e65269_2 + - qtconsole-base=5.5.0=pyha770c72_0 + - qtpy=2.4.1=pyhd8ed1ab_0 + - readline=8.2=h9e318b2_1 + - referencing=0.30.2=pyhd8ed1ab_0 + - rfc3339-validator=0.1.4=pyhd8ed1ab_0 + - rfc3986-validator=0.1.1=pyh9f0ad1d_0 + - rpds-py=0.12.0=py310hd442715_0 + - send2trash=1.8.2=pyhd1c38e8_0 + - setuptools=68.2.2=pyhd8ed1ab_0 + - six=1.16.0=pyh6c4a22f_0 + - sniffio=1.3.0=pyhd8ed1ab_0 + - soupsieve=2.5=pyhd8ed1ab_1 + - stack_data=0.6.2=pyhd8ed1ab_0 + - terminado=0.17.1=pyhd1c38e8_0 + - tinycss2=1.2.1=pyhd8ed1ab_0 + - tk=8.6.13=h1abcd95_1 + - tomli=2.0.1=pyhd8ed1ab_0 + - tornado=6.3.3=py310h2aa6e3c_1 + - traitlets=5.13.0=pyhd8ed1ab_0 + - types-python-dateutil=2.8.19.14=pyhd8ed1ab_0 + - typing_extensions=4.8.0=pyha770c72_0 + - typing_utils=0.1.0=pyhd8ed1ab_0 + - uri-template=1.3.0=pyhd8ed1ab_0 + - wcwidth=0.2.9=pyhd8ed1ab_0 + - webcolors=1.13=pyhd8ed1ab_0 + - webencodings=0.5.1=pyhd8ed1ab_2 + - websocket-client=1.6.4=pyhd8ed1ab_0 + - wheel=0.41.3=pyhd8ed1ab_0 + - widgetsnbextension=4.0.9=pyhd8ed1ab_0 + - xz=5.2.6=h775f41a_0 + - yaml=0.2.5=h3422bc3_2 + - zeromq=4.3.5=h965bd2d_0 + - zipp=3.17.0=pyhd8ed1ab_0 + - pip: + - accelerate==0.23.0 + - aiohttp==3.8.6 + - aiosignal==1.3.1 + - appdirs==1.4.4 + - astrobase==0.5.3 + - astropy==5.3.1 + - async-timeout==4.0.3 + - backcall==0.2.0 + - backoff==2.2.1 + - backports-functools-lru-cache==1.6.6 + - certifi==2022.12.7 + - chardet==5.1.0 + - charset-normalizer==2.1.1 + - click==8.1.5 + - comm==0.2.0 + - configparser==6.0.0 + - contourpy==1.1.0 + - cycler==0.11.0 + - cython==3.0.0 + - datasets==2.14.5 + - dill==0.3.7 + - docker-pycreds==0.4.0 + - evaluate==0.4.1 + - filelock==3.12.4 + - flit-core==3.9.0 + - fonttools==4.41.0 + - frozenlist==1.4.0 + - fsspec==2023.6.0 + - gitdb==4.0.10 + - gitpython==3.1.32 + - gluonts==0.13.7 + - gql==3.4.1 + - graphql-core==3.2.3 + - huggingface-hub==0.17.3 + - joblib==1.3.1 + - jplephem==2.18 + - jupyterlab-server==2.24.0 + - kiwisolver==1.4.4 + - matplotlib==3.7.2 + - mpmath==1.3.0 + - multidict==6.0.4 + - multiprocess==0.70.15 + - networkx==3.2.1 + - numpy==1.26.1 + - nvidia-ml-py3==7.352.0 + - pandas==2.0.3 + - pathtools==0.1.2 + - pillow==9.3.0 + - promise==2.3 + - protobuf==4.23.4 + - psutil==5.9.6 + - py-pdm==0.6.0 + - pyarrow==13.0.0 + - pydantic==1.10.13 + - pyeebls==0.1.6 + - pyerfa==2.0.0.3 + - pyparsing==3.0.9 + - regex==2023.10.3 + - requests==2.28.1 + - responses==0.18.0 + - rpds==1.7.1 + - safetensors==0.4.0 + - scikit-learn==1.3.0 + - scipy==1.11.1 + - seaborn==0.13.0 + - sentry-sdk==1.28.1 + - setproctitle==1.3.2 + - shortuuid==1.0.11 + - smmap==5.0.0 + - stack-data==0.6.3 + - subprocess32==3.5.4 + - sympy==1.12 + - threadpoolctl==3.2.0 + - tokenizers==0.14.1 + - toolz==0.12.0 + - torch==2.1.0 + - torchaudio==2.1.0 + - torchvision==0.16.0 + - tqdm==4.65.0 + - transformers==4.35.0 + - typing-extensions==4.4.0 + - tzdata==2023.3 + - ujson==5.8.0 + - urllib3==1.26.13 + - wandb==0.15.5 + - watchdog==3.0.0 + - xxhash==3.4.1 + - yarl==1.9.2 + - zmq==0.0.0 +prefix: /Users/jbloom/miniforge3/envs/multi_modal From f4332ede9c3690289404a81d8a547d138a8c41b2 Mon Sep 17 00:00:00 2001 From: jbloom Date: Wed, 8 Nov 2023 21:09:12 -0800 Subject: [PATCH 3/4] Use flux instead of magnitudes; comments and add possibility of cleaning data, normalizing light curves --- .gitignore | 156 ++++++++++ data/light_curve.py | 13 +- data/preprocess_data.py | 267 +++++++++++++++-- examine_and_clean_macho.ipynb | 526 ++++++++++++++++++++++++++++++++++ requirements.txt | 1 + ts-hf-periodic-refactor.ipynb | 338 ++++++++++++++-------- 6 files changed, 1150 insertions(+), 151 deletions(-) create mode 100644 examine_and_clean_macho.ipynb diff --git a/.gitignore b/.gitignore index 8915a12..8899910 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,158 @@ /old_code/ .idea + + Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +*.pkl \ No newline at end of file diff --git a/data/light_curve.py b/data/light_curve.py index ce59357..b9d9fd0 100644 --- a/data/light_curve.py +++ b/data/light_curve.py @@ -88,13 +88,22 @@ def fit_supersmoother(self, periodic=True, scale=True): except ValueError: self.ss_resid = np.inf - def period_fold(self, p=None): + def period_fold(self, p=None, normalize=False): + """ + Fold light curve on period p. + If p is None, use self.p. + If normalize is True, phase ranges from 0 to 1, else 0 to p. + """ self.times_copy = np.copy(self.times) self.measurements_copy = np.copy(self.measurements) self.errors_copy = np.copy(self.errors) if p is None: p = self.p - self.times = self.times % p + + # source phase ranges from 0 to 1 + # if normalize is True, else 0 to p + norm = 1 if not normalize else p + self.times = (self.times % p) / norm inds = np.argsort(self.times) self.times = self.times[inds] self.measurements = self.measurements[inds] diff --git a/data/preprocess_data.py b/data/preprocess_data.py index bf3fb16..c43e9b4 100644 --- a/data/preprocess_data.py +++ b/data/preprocess_data.py @@ -1,18 +1,178 @@ -import joblib -import numpy as np -import argparse import os import json +import argparse + +import joblib +import numpy as np +from scipy import stats + +from cesium.features.lomb_scargle import lomb_scargle_model, get_lomb_signif + + +def clip_outliers(t, m, merr, max_sigma=5, max_iter=5, + measurements_in_flux_units=False, + sys_err=0.05, nharm=10, verbose=False, fixed_P=None, + max_frac_del=0.15, initial_clip=[100,10]): + + """ + Iteratively clips outliers from a light curve using a Lomb-Scargle + periodogram model. + + Args: + - t (np.array): The input time array. + - m (np.array): The input magnitude array. + - merr (np.array): The input magnitude error array. + - max_sigma (float): The maximum sigma deviation to clip. + - max_iter (int): The maximum number of iterations. + - measurements_in_flux_units (bool): Whether the input measurements are in flux units. + - sys_err (float): The systematic error to use for the model. + - nharm (int): The number of harmonics to use for the model. + - verbose (bool): Whether to print out progress. + - fixed_P (float): A fixed period to use for the model. + - max_frac_del (float): The maximum fraction of data to clip. + - initial_clip (list): The initial clipping to use (in units of sigma, above and below + the median). Set this to None to skip initial clipping. + + usage: + t, y, dy = d.times, d.measurements, d.errors + t, y, yerr, rez, P, _, _, mag0 = clip_outliers(t, y, dy, max_sigma=4, max_iter=5) + sign = get_lomb_signif(rez) + + """ + + t = t.copy() + if not measurements_in_flux_units: + mag0 = np.average(m, weights=1/merr) + f = 10**(-0.4*(m - mag0)) + ferr = 0.4*np.log(10)*f*merr + m = m.copy() + merr = merr.copy() + else: + f = m.copy() + ferr = merr.copy() + + # ensure merr is >= 0 and not nan + goods = np.squeeze(np.argwhere(~np.isnan(merr) & (merr >= 0))) + t = t[goods] + f = f[goods] + ferr = ferr[goods] + m = m[goods] + merr = merr[goods] + + initial_size = len(t) + max_removed = 0 + if initial_clip is not None: + med = np.nanmedian(f) + mad = stats.median_abs_deviation(f, nan_policy="omit") + if verbose: + print(f"initial median = {med:0.3f} mad = {mad:0.3f}") + bads = np.argwhere((f >= initial_clip[1]*mad + med) | + (f < med - initial_clip[0]*mad))[:int(max_frac_del * len(f))] + max_removed += len(bads) + goods = np.delete(np.arange(len(f)), bads) + t = t[goods[:]] + f = f[goods[:]] + ferr = ferr[goods[:]] + m = m[goods[:]] + merr = merr[goods[:]] + if verbose: + print(f"max_removed (initial cut): {max_removed}") + + rez = lomb_scargle_model(t, f, ferr, sys_err=sys_err, nharm=nharm, + nfreq=2, tone_control=5.0,default_order=1, + freq_grid=None, normalize=False) + + if not fixed_P: + P = 1 / rez["freq_fits"][0]["freq"] + else: + P = fixed_P + + if verbose: + print(f"iter: 0 ... P: {P} n: {len(t)}") + + iter = 0 + while iter < max_iter: + # run L-S with 1 freq + df = 1/5000.00 + f0 = max(1/P - 25*df, df) # periodogram starting (low) frequency + fe = 1/P + 25*df # periodogram ending (high) frequency + numf = int((fe-f0)/df) + 1 + freq_grid_param = {"f0": f0, "df": df, "fmax": fe, "numf": numf} + + rez = lomb_scargle_model(t, f, ferr, sys_err=sys_err, nharm=nharm, + nfreq=1, tone_control=10.0, default_order=1, + freq_grid=freq_grid_param, normalize=False) + + if not fixed_P: + P = 1 / rez["freq_fits"][0]["freq"] + else: + P = fixed_P + + if verbose: + print(f"iter: {iter+1} ... P: {P} n: {len(t)}") + resid = f - rez["freq_fits"][0]["model"] + resid_err = np.sqrt(ferr**2 + rez["freq_fits"][0]["model_error"]**2) + + # deviation from the model in sigma + scaled_resid = np.abs(resid)/resid_err + bads = np.argwhere(scaled_resid >= max_sigma)[:(int(max_frac_del * initial_size) - 1)] + goods = np.delete(np.arange(len(scaled_resid)), bads) + if (len(goods) == len(scaled_resid)) or (max_removed > int(max_frac_del * initial_size)): + # no more outliers to clip + break + + t = t[goods[:]] + f = f[goods[:]] + ferr = ferr[goods[:]] + m = m[goods[:]] + merr = merr[goods[:]] + max_removed += len(bads) + if verbose: + print(f"max_removed: {max_removed}") + + # run one last time to get the model + rez = lomb_scargle_model(t, f, ferr, sys_err=sys_err, nharm=nharm, + nfreq=1, tone_control=10.0, default_order=1, + freq_grid=freq_grid_param, normalize=False) + + if not fixed_P: + P = 1 / rez["freq_fits"][0]["freq"] + else: + P = fixed_P + iter += 1 + + if not measurements_in_flux_units: + y = m + yerr = merr + + mean_flux_mag = mag0 - 2.5*np.log10( + rez["freq_fits"][0]["trend_coef"][0]) + mean_flux_mag_err = 2.5/np.log(10) * \ + rez["freq_fits"][0]["trend_coef_error"][0] + rez["freq_fits"][0]["model"] = mag0 - 2.5*np.log10( + rez["freq_fits"][0]["model"]) + else: + y = f + yerr = ferr + mean_flux_mag = rez["freq_fits"][0]["trend_coef"][0] + mean_flux_mag_err = rez["freq_fits"][0]["trend_coef_error"][0] + return t, y, yerr, rez, P, mean_flux_mag, mean_flux_mag_err, mag0 -# TODO check why we normalize only 1 dim -def normalize(data, use_error=False): + +def normalize(data, use_error=False, measurements_in_flux_units=False): """ Standardizes the input data and optionally adds an error dimension. + data is a 3D array of shape (num_samples, time_steps, [time, mag, mag_err]) + so data[:, :, 0] is the time axis, data[:, :, 1] is the flux axis, and + data[:, :, 2] is the error axis. + Args: - data (np.array): The input data to be normalized. - use_error (bool): Whether to include an error dimension. + - measurements_in_flux_units (bool): Whether the input measurements are in flux units. + If not (ie. they are in mags), then convert to fluxes. Returns: - tuple: normalized_data, means, scales @@ -26,17 +186,45 @@ def normalize(data, use_error=False): # Initialize normalized data array standardized_data = np.zeros((num_samples, time_steps, out_dim)) + + # time axis standardized_data[:, :, 0] = data[:, :, 0] - standardized_data[:, :, 1:out_dim] = data[:, :, 1:out_dim] - # Calculate means and scales (standard deviation) for normalization - means = np.nanmean(data[:, :, 1], axis=1, keepdims=True) - scales = np.nanstd(data[:, :, 1], axis=1, keepdims=True) + # convert to fluxes if necessary + if not measurements_in_flux_units: + if not use_error: + weights = np.ones_like(data[:, :, 1]) + else: + weights = 1.0 / data[:, :, 2] + + mag0 = np.average(data[:, :, 1], weights=weights, keepdims=True) + f = 10**(-0.4*(data[:, :, 1] - mag0)) + if use_error: + ferr = 0.4*np.log(10)*f*data[:, :, 2] + else: + f = data[:, :, 1] + if use_error: + ferr = data[:, :, 2] + + # flux axis + standardized_data[:, :, 1] = f + + # error axis + if use_error: + standardized_data[:, :, 2] = ferr + + + # Calculate median and scales (mad) for normalization + med = np.nanmedian(standardized_data[:, :, 1], axis=1, keepdims=True) + mad = np.expand_dims(stats.median_abs_deviation(standardized_data[:, :, 1], + axis=1, nan_policy="omit"), axis=1) # Normalize the data - standardized_data[:, :, 1] = (data[:, :, 1] - means) / scales + standardized_data[:, :, 1] = (standardized_data[:, :, 1] - med) / mad + if use_error: + standardized_data[:, :, 2] = standardized_data[:, :, 2] / mad - return standardized_data, means, scales + return standardized_data, med, mad def train_test_split(y, train_size=0.33): @@ -75,7 +263,7 @@ def train_test_split(y, train_size=0.33): def filter_data_by_errors(light_curve): """Filter light curve data based on error values.""" - valid_data = (light_curve.errors > 0) & (light_curve.errors < 99) + valid_data = (light_curve.errors > 0) & (light_curve.errors < 99) & (light_curve.errors != np.nan) light_curve.times = light_curve.times[valid_data] light_curve.measurements = light_curve.measurements[valid_data] light_curve.errors = light_curve.errors[valid_data] @@ -106,6 +294,18 @@ def sanitize_data(data, args): for lc in data: filter_data_by_errors(lc) + if args.clip: + # Clip outliers whilst finding better periods + t, y, dy = lc.times, lc.measurements, lc.errors + t, y, yerr, rez, P, _, _, mag0 = clip_outliers(t, y, dy, max_sigma=4, max_iter=5) + print(f"{lc.name} {lc.p} {P}") + # make sure the new period is not too different from sidereal day + if np.abs((P - 0.997)/0.997) >= 0.005: + # make sure is not a multiple of the orginal period + if np.abs((0.5*P - lc.p)/lc.p) >= 0.005: + lc.p=P + lc.p_signif=get_lomb_signif(rez) + # Fix labels if this is macho dataset if 'macho' in args.input: for lc in data: @@ -131,23 +331,35 @@ def sanitize_data(data, args): def process_data(split, args, n_inputs, label_to_num, scales_all=None): - """Processes and normalizes light curve data.""" + """Processes and normalizes light curve data. + + scales_all is a tuple of (mean_x, std_x, aux_mean, aux_std) if it is not None. + n_inputs is 3 if use_error is True, otherwise 2. + args is the argument parser. + label_to_num is a dictionary of label to number. + """ + x_list = [np.c_[chunk.times, chunk.measurements, chunk.errors] for chunk in split] + periods = np.array([lc.p for lc in split]) label = np.array([label_to_num[chunk.label] for chunk in split]) - x, means, scales = normalize(np.array(x_list), use_error=args.use_error) print('Shape of the dataset array:', x.shape) + # Normalize the entire dataset, but leave the time axis alone + # save the mean and std for later use during testing if scales_all is not None: - mean_x = scales_all[0][:-1] - std_x = scales_all[1][:-1] + global_med = scales_all[0] + global_mad = scales_all[1] else: - mean_x = x.reshape(-1, n_inputs).mean(axis=0) - std_x = x.reshape(-1, n_inputs).std(axis=0) + global_med = np.nanmedian(x[:, :, 1]) + global_mad = np.nanmedian(stats.median_abs_deviation(x[:, :, 1], nan_policy="omit")) - x -= mean_x - x /= std_x + x[:,:,1] -= global_med + x[:,:,1] /= global_mad + + if args.use_error: + x[:,:,2] /= global_mad x = np.swapaxes(x, 2, 1) aux = np.c_[means, scales, np.log10(periods)] @@ -168,7 +380,7 @@ def process_data(split, args, n_inputs, label_to_num, scales_all=None): aux /= aux_std if scales_all is None: - scales_all = np.array([np.append(mean_x, 0), np.append(std_x, 0), aux_mean, aux_std]) + scales_all = [global_med, global_mad, aux_mean, aux_std] return x, label, aux, scales_all @@ -191,6 +403,10 @@ def get_data_args(notebook=False): help='training sequence length') parser.add_argument('--use-error', action='store_true', default=False, help='use error as additional dimension') + parser.add_argument('--clip', action='store_true', default=False, + help='sigma clip light curves based on folded period') + parser.add_argument('--phase_norm', action='store_true', default=False, + help='normalize phase in the folded light curves so they all go from [0,1]') parser.add_argument('--use-meta', action='store_true', default=False, help='use meta as auxiliary network input') parser.add_argument('--seed', type=int, default=0, @@ -227,11 +443,10 @@ def main(): train_split = [chunk for i in train_idxs for chunk in data[i].split(args.L, args.L) if data[i].label is not None] test_split = [chunk for i in test_idxs for chunk in data[i].split(args.L, args.L) if data[i].label is not None] - # TODO check what period_fold does and if it can be moved to preprocessing functions for lc in train_split: - lc.period_fold() + lc.period_fold(normalize=args.phase_norm) for lc in test_split: - lc.period_fold() + lc.period_fold(normalize=args.phase_norm) unique_label, count = np.unique([lc.label for lc in train_split], return_counts=True) print('------------after segmenting into L={}------------'.format(args.L)) @@ -248,7 +463,9 @@ def main(): joblib.dump((x_train[val_idx], aux_train[val_idx], label_train[val_idx]), f'data/{args.output}/val.pkl') joblib.dump((x_test, aux_test, label_test), f'data/{args.output}/test.pkl') - np.save(f'data/{args.output}/scales.npy', scales_all) + + # let's save the scales as a pickle file instead of numpy array + joblib.dump((scales_all), f'data/{args.output}/scales.pkl') with open(f'data/{args.output}/info.json', 'w') as f: f.write(json.dumps({ diff --git a/examine_and_clean_macho.ipynb b/examine_and_clean_macho.ipynb new file mode 100644 index 0000000..667f681 --- /dev/null +++ b/examine_and_clean_macho.ipynb @@ -0,0 +1,526 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 20, + "id": "8a582e45-8b7a-411c-87c7-95f0f59a5826", + "metadata": {}, + "outputs": [], + "source": [ + "#!pip install astroML" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "75623bfe-d3ce-4297-b102-03ac9ac2f0bf", + "metadata": {}, + "outputs": [], + "source": [ + "#!pip install -U ipympl ipywidgets --force-reinstall" + ] + }, + { + "cell_type": "code", + "execution_count": 428, + "id": "b4d86e4a-ab40-49e4-81da-b4ad3f6629d7", + "metadata": {}, + "outputs": [], + "source": [ + "#!pip install cesium==0.12.1" + ] + }, + { + "cell_type": "code", + "execution_count": 430, + "id": "ab63bcb7-f901-4038-9c2d-967eff4ea5c2", + "metadata": {}, + "outputs": [], + "source": [ + "import joblib\n", + "import numpy as np\n", + "from scipy import stats\n", + "\n", + "import matplotlib.pyplot as plt\n", + "from astroML.time_series import search_frequencies\n", + "from astropy.timeseries import LombScargle\n", + "\n", + "import cesium\n", + "from cesium.features.lomb_scargle import lomb_scargle_model, get_lomb_signif\n", + "from cesium.featurize import featurize_time_series\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "02190a25-c3de-4b59-b990-e7b9c423efaa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/Users/jbloom/Projects/AstroML/data\n" + ] + } + ], + "source": [ + "cd data/" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7a0342cd-a478-43eb-a341-98994fb5d577", + "metadata": {}, + "outputs": [], + "source": [ + "data = joblib.load(\"macho_raw.pkl\")" + ] + }, + { + "cell_type": "markdown", + "id": "69f01080-f8f0-448a-9552-e1367a0a4ff3", + "metadata": {}, + "source": [ + "Data from here:\n", + "\n", + " https://macho.nci.org.au/macho_photometry/READ_ME\n", + "\n", + "Identifier is field.tile.star number (eg. 17.2954.38)\n", + "\n", + "Position from here: https://macho.nci.org.au/macho_stars/\n", + "\n", + " 17;2954;38;04:58:33.2534;-69:36:13.4630;(1.30269,-1.21481);E;26;74;73;24;26" + ] + }, + { + "cell_type": "code", + "execution_count": 511, + "id": "7bd37ba5-7f56-4b02-a58e-0763c15aaa5c", + "metadata": {}, + "outputs": [], + "source": [ + "def clip_outliers(t, m, merr, max_sigma=5, max_iter=5,\n", + " measurements_in_flux_units=False,\n", + " sys_err=0.05, nharm=10, verbose=False, fixed_P=None,\n", + " max_frac_del=0.15, initial_clip=[100,10]):\n", + "\n", + " t = t.copy()\n", + " if not measurements_in_flux_units:\n", + " mag0 = np.average(m, weights=1/merr)\n", + " f = 10**(-0.4*(m - mag0))\n", + " ferr = 0.4*np.log(10)*f*merr\n", + " m = m.copy()\n", + " merr = merr.copy()\n", + " else:\n", + " f = m.copy()\n", + " ferr = merr.copy()\n", + "\n", + " # ensure merr is >= 0 and not nan\n", + " goods = np.squeeze(np.argwhere(~np.isnan(dy) & (dy >= 0)))\n", + " t = t[goods]\n", + " f = f[goods]\n", + " ferr = ferr[goods]\n", + " m = m[goods]\n", + " merr = merr[goods]\n", + "\n", + " initial_size = len(t)\n", + " max_removed = 0\n", + " if initial_clip is not None:\n", + " med = np.nanmedian(f)\n", + " mad = stats.median_abs_deviation(f, nan_policy=\"omit\")\n", + " if verbose:\n", + " print(f\"initial median = {median:0.3f} mad = {mad:0.3f}\")\n", + " bads = np.argwhere((f >= initial_clip[1]*mad + med) | (f < med - initial_clip[0]*mad))[:int(max_frac_del * len(f))]\n", + " max_removed += len(bads)\n", + " goods = np.delete(np.arange(len(f)), bads)\n", + " t = t[goods[:]]\n", + " f = f[goods[:]]\n", + " ferr = ferr[goods[:]]\n", + " m = m[goods[:]]\n", + " merr = merr[goods[:]]\n", + " print(f\"max_removed (initial cut): {max_removed}\")\n", + " \n", + " rez = lomb_scargle_model(t, f, ferr, sys_err=sys_err, nharm=nharm,\n", + " nfreq=2, tone_control=5.0,default_order=1,\n", + " freq_grid=None, normalize=False)\n", + "\n", + " if not fixed_P:\n", + " P = 1 / rez[\"freq_fits\"][0][\"freq\"]\n", + " else:\n", + " P = fixed_P\n", + "\n", + " if verbose:\n", + " print(f\"iter: 0 ... P: {P} n: {len(t)}\")\n", + "\n", + " iter = 0\n", + " while iter < max_iter:\n", + " # run L-S with 1 freq\n", + " df = 1/5000.00\n", + " f0 = max(1/P - 25*df, df) # periodogram starting (low) frequency\n", + " fe = 1/P + 25*df # periodogram ending (high) frequency\n", + " numf = int((fe-f0)/df) + 1\n", + " freq_grid_param = {\"f0\": f0, \"df\": df, \"fmax\": fe, \"numf\": numf}\n", + "\n", + " rez = lomb_scargle_model(t, f, ferr, sys_err=sys_err, nharm=nharm,\n", + " nfreq=1, tone_control=10.0, default_order=1,\n", + " freq_grid=freq_grid_param, normalize=False)\n", + "\n", + " if not fixed_P:\n", + " P = 1 / rez[\"freq_fits\"][0][\"freq\"]\n", + " else:\n", + " P = fixed_P\n", + "\n", + " if verbose:\n", + " print(f\"iter: {iter+1} ... P: {P} n: {len(t)}\")\n", + " resid = f - rez[\"freq_fits\"][0][\"model\"]\n", + " resid_err = np.sqrt(ferr**2 + rez[\"freq_fits\"][0][\"model_error\"]**2)\n", + "\n", + " # deviation from the model in sigma\n", + " scaled_resid = np.abs(resid)/resid_err\n", + " bads = np.argwhere(scaled_resid >= max_sigma)[:(int(max_frac_del * initial_size) - 1)]\n", + " goods = np.delete(np.arange(len(scaled_resid)), bads)\n", + " if (len(goods) == len(scaled_resid)) or (max_removed > int(max_frac_del * initial_size)):\n", + " # no more outliers to clip\n", + " break\n", + "\n", + " t = t[goods[:]]\n", + " f = f[goods[:]]\n", + " ferr = ferr[goods[:]]\n", + " m = m[goods[:]]\n", + " merr = merr[goods[:]]\n", + " max_removed += len(bads)\n", + " print(f\"max_removed: {max_removed}\")\n", + "\n", + " # run one last time to get the model\n", + " rez = lomb_scargle_model(t, f, ferr, sys_err=sys_err, nharm=nharm,\n", + " nfreq=1, tone_control=10.0, default_order=1,\n", + " freq_grid=freq_grid_param, normalize=False)\n", + "\n", + " if not fixed_P:\n", + " P = 1 / rez[\"freq_fits\"][0][\"freq\"]\n", + " else:\n", + " P = fixed_P\n", + " iter += 1\n", + "\n", + " if not measurements_in_flux_units:\n", + " y = m\n", + " yerr = merr\n", + "\n", + " mean_flux_mag = mag0 - 2.5*np.log10(\n", + " rez[\"freq_fits\"][0][\"trend_coef\"][0])\n", + " mean_flux_mag_err = 2.5/np.log(10) * \\\n", + " rez[\"freq_fits\"][0][\"trend_coef_error\"][0]\n", + " rez[\"freq_fits\"][0][\"model\"] = mag0 - 2.5*np.log10(\n", + " rez[\"freq_fits\"][0][\"model\"])\n", + " else:\n", + " y = f\n", + " yerr = ferr\n", + " mean_flux_mag = rez[\"freq_fits\"][0][\"trend_coef\"][0]\n", + " mean_flux_mag_err = rez[\"freq_fits\"][0][\"trend_coef_error\"][0]\n", + "\n", + " return t, y, yerr, rez, P, mean_flux_mag, mean_flux_mag_err, mag0" + ] + }, + { + "cell_type": "code", + "execution_count": 568, + "id": "f19ea2c2-2023-48b0-83b5-f1a10619ad15", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "LightCurve(times=[48825.6394 48828.8031 48829.8188 ... 51541.4653 51542.735 51544.7339], measurements=[-7.945 -7.838 -8.361 ... -7.846 -8.247 -7.844], errors=[0.022 0.024 0.014 ... 0.021 0.016 0.022], survey=MACHO, name=79.5384.71, best_period=None, best_score=None, label=Ceph Fund, p=2.77928, p_signif=None, p_class=None, ss_resid=0.32317767256024554)" + ] + }, + "execution_count": 568, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "d = data[4992]\n", + "d" + ] + }, + { + "cell_type": "code", + "execution_count": 566, + "id": "24f20943-bf28-4c53-ba38-daee896e6530", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "max_removed (initial cut): 1\n", + "max_removed: 26\n", + "max_removed: 28\n", + "max_removed: 29\n" + ] + } + ], + "source": [ + "t, y, dy = d.times, d.measurements, d.errors\n", + "t, y, yerr, rez, P, mean_flux_mag, mean_flux_mag_err, mag0 = clip_outliers(t, y, dy, max_sigma=4, max_iter=5)\n", + "sign = get_lomb_signif(rez)" + ] + }, + { + "cell_type": "code", + "execution_count": 567, + "id": "dd76b60a-f7e2-4741-ab62-07ec10da9039", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'MACHO 79.5384.71 (Ceph Fund) P=2.7792 d (σ=30.74)')" + ] + }, + "execution_count": 567, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.errorbar((t % P) / P, y, yerr, fmt='o', mec=\"None\", mfc=\"b\", ms=3, alpha=0.3)\n", + "#plt.scatter((t % P) / P, rez[\"freq_fits\"][0][\"model\"], c=\"r\", s=2)\n", + "plt.xlabel(\"phase\")\n", + "plt.ylim(max(y) + np.median(dy)*3,min(y) - np.median(dy)*3)\n", + "plt.title(f\"MACHO {d.name} ({d.label}) P={P:0.4f} d (σ={sign:0.2f})\")" + ] + }, + { + "cell_type": "code", + "execution_count": 543, + "id": "4ca0344e-b981-4746-80cb-23385bb24f40", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9962" + ] + }, + "execution_count": 543, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "P_min=15/(60*24)\n", + "P_max=400\n", + "frequency = np.logspace(np.log10(2*np.pi/P_max), np.log10(2*np.pi/P_min), 10000)\n", + "frequency = frequency[np.squeeze(np.argwhere(~((frequency > 2*np.pi/1.01) & ( frequency < 2*np.pi/0.99))))]\n", + "frequency = frequency[np.squeeze(np.argwhere(~((frequency < 1.01) & ( frequency > 0.99))))]\n", + "len(frequency)" + ] + }, + { + "cell_type": "code", + "execution_count": 466, + "id": "e3358b28-fa26-4b84-a4f2-f5b508db83c8", + "metadata": {}, + "outputs": [], + "source": [ + "power = LombScargle(t, y, yerr).power(frequency)" + ] + }, + { + "cell_type": "code", + "execution_count": 467, + "id": "b875a4ae-564b-41fc-95fa-d0410e36bed5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(9962,)" + ] + }, + "execution_count": 467, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "frequency.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 468, + "id": "d91f072f-edc6-45c4-b3f3-92e4f218b63d", + "metadata": {}, + "outputs": [], + "source": [ + "best_frequency = frequency[np.argmax(power)]" + ] + }, + { + "cell_type": "code", + "execution_count": 469, + "id": "86230438-8fbc-4d1d-bb44-c6477a2b9e98", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 469, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.semilogx(2*np.pi/frequency, power)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3ded7cce-53b7-4562-813d-9925a4ecc20e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------before segmenting into L=200------------\n", + "['Ceph 1st' 'Ceph Fund' 'EB' 'LPV' 'RRL + GB' 'RRL AB' 'RRL C' 'RRL E']\n", + "[ 683 1185 6833 3049 237 7403 1765 315]\n", + "------------after segmenting into L=200------------\n", + "['Ceph 1st' 'Ceph Fund' 'EB' 'LPV' 'RRL + GB' 'RRL AB' 'RRL C' 'RRL E']\n", + "[ 2092 3630 19897 8782 826 22772 5218 903]\n", + "Shape of the dataset array: (64120, 200, 3)\n", + "Shape of the dataset array: (16049, 200, 3)\n" + ] + } + ], + "source": [ + "%run preprocess_data.py --dir=. --L=200 --use-error" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "aa25a332-e719-4601-9931-7dd3a7d8c6a3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[0;32m/Users/jbloom/miniforge3/envs/multi_modal/lib/python3.10/site-packages/numpy/lib/npyio.py\u001b[0m(545)\u001b[0;36msave\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32m 543 \u001b[0;31m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 544 \u001b[0;31m \u001b[0;32mwith\u001b[0m \u001b[0mfile_ctx\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mfid\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m--> 545 \u001b[0;31m \u001b[0marr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masanyarray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 546 \u001b[0;31m format.write_array(fid, arr, allow_pickle=allow_pickle,\n", + "\u001b[0m\u001b[0;32m 547 \u001b[0;31m pickle_kwargs=dict(fix_imports=fix_imports))\n", + "\u001b[0m\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> up\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[0;32m/Users/jbloom/Projects/AstroML/data/preprocess_data.py\u001b[0m(464)\u001b[0;36mmain\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32m 462 \u001b[0;31m f'data/{args.output}/val.pkl')\n", + "\u001b[0m\u001b[0;32m 463 \u001b[0;31m \u001b[0mjoblib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdump\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maux_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34mf'data/{args.output}/test.pkl'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m--> 464 \u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msave\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf'data/{args.output}/scales.npy'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mscales_all\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 465 \u001b[0;31m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 466 \u001b[0;31m \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf'data/{args.output}/info.json'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'w'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> scales_all\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.0, 1.0, array([0.51444719, 0.05404538, 0.31473851]), array([0.91127568, 0.14973043, 0.98775118])]\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> q\n" + ] + } + ], + "source": [ + "%debug" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "66c6883a-689e-41c3-8977-a771538b67a9", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "multi_modal", + "language": "python", + "name": "multi_modal" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/requirements.txt b/requirements.txt index caa3027..6eccb73 100644 --- a/requirements.txt +++ b/requirements.txt @@ -19,6 +19,7 @@ beautifulsoup4 bleach Brotli certifi==2022.12.7 +cesium==0.12.1 cffi chardet==5.1.0 charset-normalizer==2.1.1 diff --git a/ts-hf-periodic-refactor.ipynb b/ts-hf-periodic-refactor.ipynb index 09f9ce8..cd50f58 100644 --- a/ts-hf-periodic-refactor.ipynb +++ b/ts-hf-periodic-refactor.ipynb @@ -10,7 +10,28 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, + "id": "160ea4e4-9095-423f-b096-1bd4b80c8ad5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "README.md requirements.txt\n", + "\u001b[34mdata\u001b[m\u001b[m ts-hf-periodic-refactor.ipynb\n", + "environment.yaml \u001b[34mweights\u001b[m\u001b[m\n", + "examine_and_clean_macho.ipynb\n" + ] + } + ], + "source": [ + "!ls" + ] + }, + { + "cell_type": "code", + "execution_count": 3, "id": "adb1b2f5-e7e4-4271-9986-d81ce724ce2a", "metadata": {}, "outputs": [ @@ -18,28 +39,28 @@ "name": "stdout", "output_type": "stream", "text": [ - "period\n" + "multi_modal\n" ] } ], "source": [ "import os\n", - "\n", - "print(os.environ.get('CONDA_DEFAULT_ENV'))" + "print(os.environ.get('CONDA_DEFAULT_ENV'))\n", + "os.environ.update({\"PYTORCH_ENABLE_MPS_FALLBACK\": \"1\"})" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "id": "d4a2d992-5147-49e1-9bc2-cb0c2d4b062f", "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "/home/mrizhko/anaconda3/envs/period/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" + "torch.__version__='2.1.0'\n", + "transformers.__version__='4.35.0'\n" ] } ], @@ -52,28 +73,42 @@ "import torch.nn as nn\n", "from torch.optim import AdamW\n", "from torch.utils.data import Dataset, DataLoader\n", + "import transformers\n", "from transformers import PretrainedConfig\n", "from transformers import TimeSeriesTransformerConfig, TimeSeriesTransformerForPrediction\n", "from tqdm import tqdm\n", "from sklearn.metrics import confusion_matrix\n", "import seaborn as sns\n", - "import matplotlib.pyplot as plt" + "import matplotlib.pyplot as plt\n", + "\n", + "print(f\"{torch.__version__=}\")\n", + "print(f\"{transformers.__version__=}\")" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 127, "id": "12e503c8-1000-4d90-9066-453bc5a2e200", "metadata": {}, "outputs": [], "source": [ "class MachoDataset(Dataset):\n", - " def __init__(self, data_root, prediction_length, mode='train'):\n", + " def __init__(self, data_root, prediction_length, mode='train', use_errors=True):\n", " data = joblib.load(data_root + f'{mode}.pkl')\n", + " self.data = data\n", " self.prediction_length = prediction_length\n", + " self.use_errors = use_errors\n", " \n", + " if use_errors and data[0][:, :, :].shape[1] != 3:\n", + " raise Exception(\"use_errors was True but dataset does not contain errors.\"\n", + " \" Try running preprocess_data.py with the flag --use-error\")\n", + "\n", " self.times = data[0][:, 0, :]\n", - " self.values = data[0][:, 1, :]\n", + " if use_errors:\n", + " self.values = data[0][:, 1:, :]\n", + " else:\n", + " self.values = data[0][:, 1, :]\n", + " \n", " self.aux = data[1]\n", " self.labels = data[2]\n", " \n", @@ -83,8 +118,13 @@ " def __getitem__(self, idx):\n", " past_times = torch.tensor(self.times[idx, :-self.prediction_length], dtype=torch.float)\n", " future_times = torch.tensor(self.times[idx, -self.prediction_length:], dtype=torch.float)\n", - " past_values = torch.tensor(self.values[idx, :-self.prediction_length], dtype=torch.float)\n", - " future_values = torch.tensor(self.values[idx, -self.prediction_length:], dtype=torch.float)\n", + " if use_errors:\n", + " past_values = torch.tensor(self.values[idx, :, :-self.prediction_length], dtype=torch.float)\n", + " future_values = torch.tensor(self.values[idx, :, -self.prediction_length:], dtype=torch.float) \n", + " else:\n", + " past_values = torch.tensor(self.values[idx, :-self.prediction_length], dtype=torch.float)\n", + " future_values = torch.tensor(self.values[idx, -self.prediction_length:], dtype=torch.float) \n", + " \n", " past_mask = torch.ones(past_times.shape, dtype=torch.float)\n", " future_mask = torch.ones(future_times.shape, dtype=torch.float)\n", " labels = torch.tensor(self.labels[idx], dtype=torch.long)\n", @@ -97,74 +137,67 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 128, "id": "3163fead-df60-4c55-83ee-46a70c680c75", "metadata": {}, "outputs": [], "source": [ - "data_root = '/home/mrizhko/AstroML/contra_periodic/data/macho/'\n", + "data_root = './data/data/macho/'\n", "window_length = 200\n", - "prediction_length = 1" + "prediction_length = 50" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 129, "id": "d7ef9300-7eba-440c-8379-ed7633f93130", "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "device(type='cuda')" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "device: mps\n" + ] } ], "source": [ - "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", - "device" + "if torch.backends.mps.is_available() and torch.backends.mps.is_built():\n", + " device = \"mps\"\n", + "elif torch.cuda.is_available():\n", + " device = \"cuda\"\n", + "else:\n", + " device = \"cpu\"\n", + "\n", + "print(f\"device: {device}\")" ] }, { "cell_type": "code", - "execution_count": 6, - "id": "94eb8230-7436-40db-8c1a-7894a708801a", + "execution_count": 130, + "id": "e3043265-1f6c-4316-8335-099516e80481", "metadata": {}, "outputs": [], "source": [ - "train_dataset = MachoDataset(data_root, prediction_length, mode='train')\n", - "val_dataset = MachoDataset(data_root, prediction_length, mode='val')\n", - "test_dataset = MachoDataset(data_root, prediction_length, mode='test')" + "data = joblib.load(data_root + f'train.pkl')" ] }, { "cell_type": "code", - "execution_count": 7, - "id": "f5ef610f-643f-46ba-a9e0-e1ad36759792", + "execution_count": 131, + "id": "94eb8230-7436-40db-8c1a-7894a708801a", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "48047" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "len(train_dataset)" + "use_errors = False\n", + "train_dataset = MachoDataset(data_root, prediction_length, mode='train', use_errors=use_errors)\n", + "val_dataset = MachoDataset(data_root, prediction_length, mode='val', use_errors=use_errors)\n", + "test_dataset = MachoDataset(data_root, prediction_length, mode='test', use_errors=use_errors)" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 132, "id": "4ca9ada3-2eea-4cd1-a413-0ad275b11ed7", "metadata": {}, "outputs": [], @@ -176,12 +209,59 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 133, "id": "5b0d37ca-db8b-41eb-a139-687af2493d95", "metadata": {}, "outputs": [], "source": [ - "past_times, future_times, past_values, future_values, past_mask, future_mask, labels = train_dataset[0]" + "past_times, future_times, past_values, future_values, past_mask, future_mask, labels = train_dataset[10]" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "id": "196d94d4-ed9b-4421-8110-06b7fa957ab4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(torch.Size([150, 1]), torch.Size([150]))" + ] + }, + "execution_count": 134, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "past_times.shape, past_values.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "id": "d184c406-7157-4eaf-a781-be2f86faf204", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if use_errors:\n", + " plt.errorbar(past_times, past_values[0,:], past_values[1,:], fmt=\"o\")\n", + " plt.errorbar(future_times, future_values[0,:], future_values[1,:], fmt=\"o\", c=\"r\")\n", + "else:\n", + " plt.scatter(past_times, past_values, c=\"b\")\n", + " plt.scatter(future_times, future_values, c=\"r\") \n" ] }, { @@ -194,7 +274,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 136, "id": "ee2adbed-07c2-4ad5-ba06-8fd6785be008", "metadata": {}, "outputs": [], @@ -227,7 +307,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 137, "id": "5def6e51-6f91-466d-96c0-8b4283d44b0c", "metadata": {}, "outputs": [], @@ -256,7 +336,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 138, "id": "9ed4a1bb-c98a-4c57-9400-c25eeb68b8e3", "metadata": {}, "outputs": [], @@ -268,6 +348,7 @@ " encoder_layers=2,\n", " decoder_layers=2,\n", " d_model=64,\n", + " input_size = 1 if not use_errors else 2\n", ")\n", "\n", "model = TimeSeriesTransformerForPrediction(config)" @@ -275,7 +356,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 139, "id": "3dc30511-7e88-4297-8367-82e84789f617", "metadata": {}, "outputs": [], @@ -286,24 +367,32 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 140, "id": "a96adee6-8fde-4b46-b6bb-b3c9d3e48be5", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jbloom/miniforge3/envs/multi_modal/lib/python3.10/site-packages/torch/distributions/studentT.py:98: UserWarning: The operator 'aten::lgamma.out' is not currently supported on the MPS backend and will fall back to run on the CPU. This may have performance implications. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/mps/MPSFallback.mm:13.)\n", + " + torch.lgamma(0.5 * self.df)\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 0: Train Loss 0.9926 Val Loss 0.8771\n", - "Epoch 1: Train Loss 0.8743 Val Loss 0.8446\n", - "Epoch 2: Train Loss 0.8315 Val Loss 0.8007\n", - "Epoch 3: Train Loss 0.8134 Val Loss 0.7903\n", - "Epoch 4: Train Loss 0.8058 Val Loss 0.7902\n", - "Epoch 5: Train Loss 0.7883 Val Loss 0.757\n", - "Epoch 6: Train Loss 0.7843 Val Loss 0.7542\n", - "Epoch 7: Train Loss 0.7755 Val Loss 0.7522\n", - "Epoch 8: Train Loss 0.7713 Val Loss 0.7471\n", - "Epoch 9: Train Loss 0.7697 Val Loss 0.7457\n" + "Epoch 0: Train Loss 1.6539 Val Loss 1.5214\n", + "Epoch 1: Train Loss 1.5073 Val Loss 1.4448\n", + "Epoch 2: Train Loss 1.4563 Val Loss 1.4038\n", + "Epoch 3: Train Loss 1.4325 Val Loss 1.3875\n", + "Epoch 4: Train Loss 1.4117 Val Loss 1.3757\n", + "Epoch 5: Train Loss 1.3961 Val Loss 1.3634\n", + "Epoch 6: Train Loss 1.3905 Val Loss 1.3443\n", + "Epoch 7: Train Loss 1.3798 Val Loss 1.3429\n", + "Epoch 8: Train Loss 1.3718 Val Loss 1.3379\n", + "Epoch 9: Train Loss 1.3746 Val Loss 1.3388\n" ] } ], @@ -324,13 +413,13 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 141, "id": "a7a8e896-db33-4012-98c8-dc5edce22917", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -355,7 +444,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 142, "id": "9bc2afe6-4c6a-45f1-a372-92b28a265e2f", "metadata": {}, "outputs": [], @@ -373,7 +462,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 143, "id": "9b37a0c2-677f-42b9-9d70-f8c0350fc55f", "metadata": {}, "outputs": [], @@ -402,7 +491,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 144, "id": "23c20108-72e7-4205-9778-c9ff822af3a6", "metadata": {}, "outputs": [], @@ -435,7 +524,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 145, "id": "1ec18103-4aec-462f-9e87-bc5ed72b747b", "metadata": {}, "outputs": [], @@ -446,29 +535,30 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 146, "id": "6ac87b5b-90fe-49ea-8b72-5c8519abb6dd", "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|████████████████████████████████████| 16014/16014 [06:20<00:00, 42.06it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "MASE: 0.7628355321707666 sMAPE: 0.8248582315575865\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[146], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m model\u001b[38;5;241m.\u001b[39meval()\n\u001b[0;32m----> 3\u001b[0m forecasts \u001b[38;5;241m=\u001b[39m \u001b[43mget_forecasts\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mval_dataloader\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 4\u001b[0m mase, smape \u001b[38;5;241m=\u001b[39m get_metrics(val_dataset, forecasts)\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mMASE: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmase\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m sMAPE: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00msmape\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n", + "Cell \u001b[0;32mIn[143], line 8\u001b[0m, in \u001b[0;36mget_forecasts\u001b[0;34m(model, val_dataloader)\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mno_grad():\n\u001b[1;32m 6\u001b[0m past_times, future_times, past_values, future_values, past_mask, future_mask, label \u001b[38;5;241m=\u001b[39m batch\n\u001b[0;32m----> 8\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 9\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_time_features\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_times\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 10\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_values\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_values\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 11\u001b[0m \u001b[43m \u001b[49m\u001b[43mfuture_time_features\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfuture_times\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 12\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_observed_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_mask\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 13\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 15\u001b[0m forecasts\u001b[38;5;241m.\u001b[39mappend(outputs\u001b[38;5;241m.\u001b[39msequences\u001b[38;5;241m.\u001b[39mcpu()\u001b[38;5;241m.\u001b[39mnumpy())\n\u001b[1;32m 17\u001b[0m forecasts \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mvstack(forecasts)\n", + "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/torch/utils/_contextlib.py:115\u001b[0m, in \u001b[0;36mcontext_decorator..decorate_context\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 112\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[1;32m 113\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mdecorate_context\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 114\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m ctx_factory():\n\u001b[0;32m--> 115\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/transformers/models/time_series_transformer/modeling_time_series_transformer.py:1765\u001b[0m, in \u001b[0;36mTimeSeriesTransformerForPrediction.generate\u001b[0;34m(self, past_values, past_time_features, future_time_features, past_observed_mask, static_categorical_features, static_real_features, output_attentions, output_hidden_states)\u001b[0m\n\u001b[1;32m 1762\u001b[0m dec_last_hidden \u001b[38;5;241m=\u001b[39m dec_output\u001b[38;5;241m.\u001b[39mlast_hidden_state\n\u001b[1;32m 1764\u001b[0m params \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparameter_projection(dec_last_hidden[:, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m:])\n\u001b[0;32m-> 1765\u001b[0m distr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moutput_distribution\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mloc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrepeated_loc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrepeated_scale\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1766\u001b[0m next_sample \u001b[38;5;241m=\u001b[39m distr\u001b[38;5;241m.\u001b[39msample()\n\u001b[1;32m 1768\u001b[0m repeated_past_values \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mcat(\n\u001b[1;32m 1769\u001b[0m (repeated_past_values, (next_sample \u001b[38;5;241m-\u001b[39m repeated_loc) \u001b[38;5;241m/\u001b[39m repeated_scale), dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 1770\u001b[0m )\n", + "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/transformers/models/time_series_transformer/modeling_time_series_transformer.py:1477\u001b[0m, in \u001b[0;36mTimeSeriesTransformerForPrediction.output_distribution\u001b[0;34m(self, params, loc, scale, trailing_n)\u001b[0m\n\u001b[1;32m 1475\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m trailing_n \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 1476\u001b[0m sliced_params \u001b[38;5;241m=\u001b[39m [p[:, \u001b[38;5;241m-\u001b[39mtrailing_n:] \u001b[38;5;28;01mfor\u001b[39;00m p \u001b[38;5;129;01min\u001b[39;00m params]\n\u001b[0;32m-> 1477\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdistribution_output\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdistribution\u001b[49m\u001b[43m(\u001b[49m\u001b[43msliced_params\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mloc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mloc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscale\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/transformers/time_series_utils.py:108\u001b[0m, in \u001b[0;36mDistributionOutput.distribution\u001b[0;34m(self, distr_args, loc, scale)\u001b[0m\n\u001b[1;32m 102\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mdistribution\u001b[39m(\n\u001b[1;32m 103\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 104\u001b[0m distr_args,\n\u001b[1;32m 105\u001b[0m loc: Optional[torch\u001b[38;5;241m.\u001b[39mTensor] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 106\u001b[0m scale: Optional[torch\u001b[38;5;241m.\u001b[39mTensor] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 107\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Distribution:\n\u001b[0;32m--> 108\u001b[0m distr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_base_distribution\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdistr_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 109\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m loc \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m scale \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 110\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m distr\n", + "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/transformers/time_series_utils.py:98\u001b[0m, in \u001b[0;36mDistributionOutput._base_distribution\u001b[0;34m(self, distr_args)\u001b[0m\n\u001b[1;32m 96\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_base_distribution\u001b[39m(\u001b[38;5;28mself\u001b[39m, distr_args):\n\u001b[1;32m 97\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdim \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m---> 98\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdistribution_class\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mdistr_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 99\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 100\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m Independent(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdistribution_class(\u001b[38;5;241m*\u001b[39mdistr_args), \u001b[38;5;241m1\u001b[39m)\n", + "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/torch/distributions/studentT.py:61\u001b[0m, in \u001b[0;36mStudentT.__init__\u001b[0;34m(self, df, loc, scale, validate_args)\u001b[0m\n\u001b[1;32m 59\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, df, loc\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.0\u001b[39m, scale\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1.0\u001b[39m, validate_args\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m 60\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdf, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloc, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mscale \u001b[38;5;241m=\u001b[39m broadcast_all(df, loc, scale)\n\u001b[0;32m---> 61\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_chi2 \u001b[38;5;241m=\u001b[39m \u001b[43mChi2\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 62\u001b[0m batch_shape \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdf\u001b[38;5;241m.\u001b[39msize()\n\u001b[1;32m 63\u001b[0m \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m(batch_shape, validate_args\u001b[38;5;241m=\u001b[39mvalidate_args)\n", + "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/torch/distributions/chi2.py:25\u001b[0m, in \u001b[0;36mChi2.__init__\u001b[0;34m(self, df, validate_args)\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, df, validate_args\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[0;32m---> 25\u001b[0m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__init__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0.5\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mdf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0.5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalidate_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvalidate_args\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/torch/distributions/gamma.py:53\u001b[0m, in \u001b[0;36mGamma.__init__\u001b[0;34m(self, concentration, rate, validate_args)\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, concentration, rate, validate_args\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[0;32m---> 53\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconcentration, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrate \u001b[38;5;241m=\u001b[39m \u001b[43mbroadcast_all\u001b[49m\u001b[43m(\u001b[49m\u001b[43mconcentration\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrate\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 54\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(concentration, Number) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(rate, Number):\n\u001b[1;32m 55\u001b[0m batch_shape \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mSize()\n", + "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/torch/distributions/utils.py:49\u001b[0m, in \u001b[0;36mbroadcast_all\u001b[0;34m(*values)\u001b[0m\n\u001b[1;32m 47\u001b[0m options \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mdict\u001b[39m(dtype\u001b[38;5;241m=\u001b[39mvalue\u001b[38;5;241m.\u001b[39mdtype, device\u001b[38;5;241m=\u001b[39mvalue\u001b[38;5;241m.\u001b[39mdevice)\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[0;32m---> 49\u001b[0m new_values \u001b[38;5;241m=\u001b[39m [\n\u001b[1;32m 50\u001b[0m v \u001b[38;5;28;01mif\u001b[39;00m is_tensor_like(v) \u001b[38;5;28;01melse\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mtensor(v, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39moptions) \u001b[38;5;28;01mfor\u001b[39;00m v \u001b[38;5;129;01min\u001b[39;00m values\n\u001b[1;32m 51\u001b[0m ]\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mbroadcast_tensors(\u001b[38;5;241m*\u001b[39mnew_values)\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mbroadcast_tensors(\u001b[38;5;241m*\u001b[39mvalues)\n", + "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/torch/distributions/utils.py:50\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 47\u001b[0m options \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mdict\u001b[39m(dtype\u001b[38;5;241m=\u001b[39mvalue\u001b[38;5;241m.\u001b[39mdtype, device\u001b[38;5;241m=\u001b[39mvalue\u001b[38;5;241m.\u001b[39mdevice)\n\u001b[1;32m 48\u001b[0m \u001b[38;5;28;01mbreak\u001b[39;00m\n\u001b[1;32m 49\u001b[0m new_values \u001b[38;5;241m=\u001b[39m [\n\u001b[0;32m---> 50\u001b[0m v \u001b[38;5;28;01mif\u001b[39;00m is_tensor_like(v) \u001b[38;5;28;01melse\u001b[39;00m \u001b[43mtorch\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtensor\u001b[49m\u001b[43m(\u001b[49m\u001b[43mv\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m v \u001b[38;5;129;01min\u001b[39;00m values\n\u001b[1;32m 51\u001b[0m ]\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mbroadcast_tensors(\u001b[38;5;241m*\u001b[39mnew_values)\n\u001b[1;32m 53\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mbroadcast_tensors(\u001b[38;5;241m*\u001b[39mvalues)\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } ], @@ -491,7 +581,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 148, "id": "4db1c2e4-f781-446b-a439-817f78c6cf23", "metadata": {}, "outputs": [], @@ -527,7 +617,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 149, "id": "1c2b8354-adde-4610-863a-c73f11796ef3", "metadata": {}, "outputs": [], @@ -562,7 +652,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 150, "id": "87e60ad2-24e8-4ac6-b2d5-66d775f31a10", "metadata": {}, "outputs": [], @@ -593,7 +683,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 151, "id": "08c38180-94ee-4b2f-959b-6a982692cbb4", "metadata": {}, "outputs": [], @@ -605,7 +695,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 152, "id": "4f7723e0-a252-47fa-8e11-7f84183002b7", "metadata": {}, "outputs": [ @@ -613,26 +703,26 @@ "name": "stdout", "output_type": "stream", "text": [ - "Epoch 0: Train Loss 1.1758 \t Val Loss 0.9141 \t Train Acc 0.5929 \t Val Acc 0.6844\n", - "Epoch 1: Train Loss 0.8182 \t Val Loss 0.8106 \t Train Acc 0.7105 \t Val Acc 0.7181\n", - "Epoch 2: Train Loss 0.7648 \t Val Loss 0.7802 \t Train Acc 0.7259 \t Val Acc 0.7274\n", - "Epoch 3: Train Loss 0.7411 \t Val Loss 0.7492 \t Train Acc 0.7358 \t Val Acc 0.7392\n", - "Epoch 4: Train Loss 0.7235 \t Val Loss 0.7607 \t Train Acc 0.7439 \t Val Acc 0.7327\n", - "Epoch 5: Train Loss 0.707 \t Val Loss 0.7247 \t Train Acc 0.7499 \t Val Acc 0.7492\n", - "Epoch 6: Train Loss 0.6967 \t Val Loss 0.7142 \t Train Acc 0.7542 \t Val Acc 0.7516\n", - "Epoch 7: Train Loss 0.6889 \t Val Loss 0.7122 \t Train Acc 0.758 \t Val Acc 0.7567\n", - "Epoch 8: Train Loss 0.6748 \t Val Loss 0.6952 \t Train Acc 0.7647 \t Val Acc 0.7651\n", - "Epoch 9: Train Loss 0.6703 \t Val Loss 0.6919 \t Train Acc 0.7662 \t Val Acc 0.7626\n", - "Epoch 10: Train Loss 0.6666 \t Val Loss 0.6977 \t Train Acc 0.7685 \t Val Acc 0.7621\n", - "Epoch 11: Train Loss 0.6624 \t Val Loss 0.6786 \t Train Acc 0.7706 \t Val Acc 0.7698\n", - "Epoch 12: Train Loss 0.6593 \t Val Loss 0.6827 \t Train Acc 0.771 \t Val Acc 0.7697\n", - "Epoch 13: Train Loss 0.6538 \t Val Loss 0.6741 \t Train Acc 0.7729 \t Val Acc 0.7714\n", - "Epoch 14: Train Loss 0.6506 \t Val Loss 0.6747 \t Train Acc 0.7745 \t Val Acc 0.7689\n", - "Epoch 15: Train Loss 0.6441 \t Val Loss 0.6805 \t Train Acc 0.7784 \t Val Acc 0.7703\n", - "Epoch 16: Train Loss 0.6427 \t Val Loss 0.6652 \t Train Acc 0.7783 \t Val Acc 0.7763\n", - "Epoch 17: Train Loss 0.6392 \t Val Loss 0.6579 \t Train Acc 0.7793 \t Val Acc 0.7788\n", - "Epoch 18: Train Loss 0.6386 \t Val Loss 0.6619 \t Train Acc 0.7799 \t Val Acc 0.7764\n", - "Epoch 19: Train Loss 0.6271 \t Val Loss 0.6582 \t Train Acc 0.7851 \t Val Acc 0.7764\n" + "Epoch 0: Train Loss 1.3076 \t Val Loss 1.1364 \t Train Acc 0.5407 \t Val Acc 0.5973\n", + "Epoch 1: Train Loss 1.0624 \t Val Loss 1.0364 \t Train Acc 0.6096 \t Val Acc 0.6202\n", + "Epoch 2: Train Loss 0.9901 \t Val Loss 0.9804 \t Train Acc 0.6324 \t Val Acc 0.637\n", + "Epoch 3: Train Loss 0.9529 \t Val Loss 0.9519 \t Train Acc 0.6425 \t Val Acc 0.6419\n", + "Epoch 4: Train Loss 0.9263 \t Val Loss 0.9287 \t Train Acc 0.6552 \t Val Acc 0.6588\n", + "Epoch 5: Train Loss 0.9057 \t Val Loss 0.9181 \t Train Acc 0.6648 \t Val Acc 0.6617\n", + "Epoch 6: Train Loss 0.8855 \t Val Loss 0.8984 \t Train Acc 0.6741 \t Val Acc 0.6719\n", + "Epoch 7: Train Loss 0.8727 \t Val Loss 0.8834 \t Train Acc 0.6824 \t Val Acc 0.6854\n", + "Epoch 8: Train Loss 0.8573 \t Val Loss 0.8882 \t Train Acc 0.6884 \t Val Acc 0.6804\n", + "Epoch 9: Train Loss 0.8467 \t Val Loss 0.8627 \t Train Acc 0.6944 \t Val Acc 0.6935\n", + "Epoch 10: Train Loss 0.8385 \t Val Loss 0.8508 \t Train Acc 0.697 \t Val Acc 0.6991\n", + "Epoch 11: Train Loss 0.828 \t Val Loss 0.8411 \t Train Acc 0.7028 \t Val Acc 0.7041\n", + "Epoch 12: Train Loss 0.8216 \t Val Loss 0.8458 \t Train Acc 0.7068 \t Val Acc 0.7069\n", + "Epoch 13: Train Loss 0.812 \t Val Loss 0.8461 \t Train Acc 0.7112 \t Val Acc 0.7038\n", + "Epoch 14: Train Loss 0.8039 \t Val Loss 0.8419 \t Train Acc 0.7162 \t Val Acc 0.7035\n", + "Epoch 15: Train Loss 0.8019 \t Val Loss 0.8273 \t Train Acc 0.7172 \t Val Acc 0.7115\n", + "Epoch 16: Train Loss 0.7945 \t Val Loss 0.8237 \t Train Acc 0.719 \t Val Acc 0.7149\n", + "Epoch 17: Train Loss 0.7904 \t Val Loss 0.8191 \t Train Acc 0.7206 \t Val Acc 0.7177\n", + "Epoch 18: Train Loss 0.7827 \t Val Loss 0.808 \t Train Acc 0.7251 \t Val Acc 0.7214\n", + "Epoch 19: Train Loss 0.7791 \t Val Loss 0.8052 \t Train Acc 0.7294 \t Val Acc 0.722\n" ] } ], @@ -657,13 +747,13 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 153, "id": "79e083fa-7fb5-4f19-92af-a52394642b68", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -725,7 +815,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 154, "id": "cd920b36-3594-4756-963d-e6e942d91c66", "metadata": {}, "outputs": [], @@ -750,13 +840,13 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 155, "id": "5de559f2-91d4-4738-812e-b41bfcaf2124", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -842,9 +932,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "multi_modal", "language": "python", - "name": "python3" + "name": "multi_modal" }, "language_info": { "codemirror_mode": { @@ -856,7 +946,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.10.13" } }, "nbformat": 4, From c2bd3a361e0f425d04e39bd5d0762e459e6a4ac2 Mon Sep 17 00:00:00 2001 From: jbloom Date: Fri, 10 Nov 2023 10:28:22 -0800 Subject: [PATCH 4/4] WIP --- ts-hf-periodic-refactor.ipynb | 5873 ++++++++++++++++++++++++++++++++- 1 file changed, 5783 insertions(+), 90 deletions(-) diff --git a/ts-hf-periodic-refactor.ipynb b/ts-hf-periodic-refactor.ipynb index cd50f58..da89435 100644 --- a/ts-hf-periodic-refactor.ipynb +++ b/ts-hf-periodic-refactor.ipynb @@ -31,7 +31,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 1, "id": "adb1b2f5-e7e4-4271-9986-d81ce724ce2a", "metadata": {}, "outputs": [ @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "id": "d4a2d992-5147-49e1-9bc2-cb0c2d4b062f", "metadata": {}, "outputs": [ @@ -87,7 +87,7 @@ }, { "cell_type": "code", - "execution_count": 127, + "execution_count": 3, "id": "12e503c8-1000-4d90-9066-453bc5a2e200", "metadata": {}, "outputs": [], @@ -119,8 +119,8 @@ " past_times = torch.tensor(self.times[idx, :-self.prediction_length], dtype=torch.float)\n", " future_times = torch.tensor(self.times[idx, -self.prediction_length:], dtype=torch.float)\n", " if use_errors:\n", - " past_values = torch.tensor(self.values[idx, :, :-self.prediction_length], dtype=torch.float)\n", - " future_values = torch.tensor(self.values[idx, :, -self.prediction_length:], dtype=torch.float) \n", + " past_values = torch.tensor(self.values[idx, :, :-self.prediction_length], dtype=torch.float).T\n", + " future_values = torch.tensor(self.values[idx, :, -self.prediction_length:], dtype=torch.float).T \n", " else:\n", " past_values = torch.tensor(self.values[idx, :-self.prediction_length], dtype=torch.float)\n", " future_values = torch.tensor(self.values[idx, -self.prediction_length:], dtype=torch.float) \n", @@ -137,19 +137,19 @@ }, { "cell_type": "code", - "execution_count": 128, + "execution_count": 4, "id": "3163fead-df60-4c55-83ee-46a70c680c75", "metadata": {}, "outputs": [], "source": [ "data_root = './data/data/macho/'\n", "window_length = 200\n", - "prediction_length = 50" + "prediction_length = 1" ] }, { "cell_type": "code", - "execution_count": 129, + "execution_count": 5, "id": "d7ef9300-7eba-440c-8379-ed7633f93130", "metadata": {}, "outputs": [ @@ -174,7 +174,7 @@ }, { "cell_type": "code", - "execution_count": 130, + "execution_count": 6, "id": "e3043265-1f6c-4316-8335-099516e80481", "metadata": {}, "outputs": [], @@ -184,12 +184,12 @@ }, { "cell_type": "code", - "execution_count": 131, + "execution_count": 7, "id": "94eb8230-7436-40db-8c1a-7894a708801a", "metadata": {}, "outputs": [], "source": [ - "use_errors = False\n", + "use_errors = True\n", "train_dataset = MachoDataset(data_root, prediction_length, mode='train', use_errors=use_errors)\n", "val_dataset = MachoDataset(data_root, prediction_length, mode='val', use_errors=use_errors)\n", "test_dataset = MachoDataset(data_root, prediction_length, mode='test', use_errors=use_errors)" @@ -197,7 +197,7 @@ }, { "cell_type": "code", - "execution_count": 132, + "execution_count": 8, "id": "4ca9ada3-2eea-4cd1-a413-0ad275b11ed7", "metadata": {}, "outputs": [], @@ -209,7 +209,7 @@ }, { "cell_type": "code", - "execution_count": 133, + "execution_count": 9, "id": "5b0d37ca-db8b-41eb-a139-687af2493d95", "metadata": {}, "outputs": [], @@ -219,34 +219,35 @@ }, { "cell_type": "code", - "execution_count": 134, + "execution_count": 10, "id": "196d94d4-ed9b-4421-8110-06b7fa957ab4", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(torch.Size([150, 1]), torch.Size([150]))" + "(torch.Size([199, 1]), torch.Size([199, 2]), torch.Size([1, 2]))" ] }, - "execution_count": 134, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "past_times.shape, past_values.shape" + "# (torch.Size([197, 1]), torch.Size([197]), torch.Size([3]))\n", + "past_times.shape, past_values.shape, future_values.shape" ] }, { "cell_type": "code", - "execution_count": 135, + "execution_count": 11, "id": "d184c406-7157-4eaf-a781-be2f86faf204", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -257,8 +258,8 @@ ], "source": [ "if use_errors:\n", - " plt.errorbar(past_times, past_values[0,:], past_values[1,:], fmt=\"o\")\n", - " plt.errorbar(future_times, future_values[0,:], future_values[1,:], fmt=\"o\", c=\"r\")\n", + " plt.errorbar(past_times, past_values[:,0], past_values[:,1], fmt=\"o\")\n", + " plt.errorbar(future_times, future_values[:,0], future_values[:,1], fmt=\"o\", c=\"r\")\n", "else:\n", " plt.scatter(past_times, past_values, c=\"b\")\n", " plt.scatter(future_times, future_values, c=\"r\") \n" @@ -274,7 +275,7 @@ }, { "cell_type": "code", - "execution_count": 136, + "execution_count": 12, "id": "ee2adbed-07c2-4ad5-ba06-8fd6785be008", "metadata": {}, "outputs": [], @@ -307,7 +308,7 @@ }, { "cell_type": "code", - "execution_count": 137, + "execution_count": 13, "id": "5def6e51-6f91-466d-96c0-8b4283d44b0c", "metadata": {}, "outputs": [], @@ -336,7 +337,7 @@ }, { "cell_type": "code", - "execution_count": 138, + "execution_count": 14, "id": "9ed4a1bb-c98a-4c57-9400-c25eeb68b8e3", "metadata": {}, "outputs": [], @@ -345,10 +346,13 @@ " prediction_length=prediction_length,\n", " context_length=window_length - prediction_length - 7, # 7 is max(lags) for default lags\n", " num_time_features=1,\n", + " distribution_output=\"normal\", # student_t\n", " encoder_layers=2,\n", " decoder_layers=2,\n", " d_model=64,\n", - " input_size = 1 if not use_errors else 2\n", + " input_size = 1 if not use_errors else 2,\n", + " scaling=None, # std None mean\n", + " loss=\"kl_ts_uncertainty\", # nll\n", ")\n", "\n", "model = TimeSeriesTransformerForPrediction(config)" @@ -356,7 +360,7 @@ }, { "cell_type": "code", - "execution_count": 139, + "execution_count": 15, "id": "3dc30511-7e88-4297-8367-82e84789f617", "metadata": {}, "outputs": [], @@ -367,32 +371,24 @@ }, { "cell_type": "code", - "execution_count": 140, + "execution_count": 16, "id": "a96adee6-8fde-4b46-b6bb-b3c9d3e48be5", "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/jbloom/miniforge3/envs/multi_modal/lib/python3.10/site-packages/torch/distributions/studentT.py:98: UserWarning: The operator 'aten::lgamma.out' is not currently supported on the MPS backend and will fall back to run on the CPU. This may have performance implications. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/mps/MPSFallback.mm:13.)\n", - " + torch.lgamma(0.5 * self.df)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: Train Loss 1.6539 Val Loss 1.5214\n", - "Epoch 1: Train Loss 1.5073 Val Loss 1.4448\n", - "Epoch 2: Train Loss 1.4563 Val Loss 1.4038\n", - "Epoch 3: Train Loss 1.4325 Val Loss 1.3875\n", - "Epoch 4: Train Loss 1.4117 Val Loss 1.3757\n", - "Epoch 5: Train Loss 1.3961 Val Loss 1.3634\n", - "Epoch 6: Train Loss 1.3905 Val Loss 1.3443\n", - "Epoch 7: Train Loss 1.3798 Val Loss 1.3429\n", - "Epoch 8: Train Loss 1.3718 Val Loss 1.3379\n", - "Epoch 9: Train Loss 1.3746 Val Loss 1.3388\n" + "ename": "ZeroDivisionError", + "evalue": "division by zero", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mZeroDivisionError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[16], line 5\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m epoch \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;241m10\u001b[39m):\n\u001b[1;32m 4\u001b[0m model\u001b[38;5;241m.\u001b[39mtrain()\n\u001b[0;32m----> 5\u001b[0m train_loss \u001b[38;5;241m=\u001b[39m \u001b[43mtrain_step\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtrain_dataloader\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptimizer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 6\u001b[0m train_losses\u001b[38;5;241m.\u001b[39mappend(train_loss)\n\u001b[1;32m 8\u001b[0m model\u001b[38;5;241m.\u001b[39meval()\n", + "Cell \u001b[0;32mIn[12], line 9\u001b[0m, in \u001b[0;36mtrain_step\u001b[0;34m(train_dataloader, model, optimizer)\u001b[0m\n\u001b[1;32m 5\u001b[0m optimizer\u001b[38;5;241m.\u001b[39mzero_grad()\n\u001b[1;32m 7\u001b[0m past_times, future_times, past_values, future_values, past_mask, future_mask, _ \u001b[38;5;241m=\u001b[39m batch\n\u001b[0;32m----> 9\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 10\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_time_features\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_times\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 11\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_values\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_values\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 12\u001b[0m \u001b[43m \u001b[49m\u001b[43mfuture_time_features\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfuture_times\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 13\u001b[0m \u001b[43m \u001b[49m\u001b[43mfuture_values\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfuture_values\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 14\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_observed_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_mask\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 15\u001b[0m \u001b[43m \u001b[49m\u001b[43mfuture_observed_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfuture_mask\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 16\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 18\u001b[0m loss \u001b[38;5;241m=\u001b[39m outputs\u001b[38;5;241m.\u001b[39mloss\n\u001b[1;32m 19\u001b[0m total_loss\u001b[38;5;241m.\u001b[39mappend(loss\u001b[38;5;241m.\u001b[39mitem())\n", + "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/torch/nn/modules/module.py:1518\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1516\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compiled_call_impl(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs) \u001b[38;5;66;03m# type: ignore[misc]\u001b[39;00m\n\u001b[1;32m 1517\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1518\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_call_impl\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/torch/nn/modules/module.py:1527\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1522\u001b[0m \u001b[38;5;66;03m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[1;32m 1523\u001b[0m \u001b[38;5;66;03m# this function, and just call forward.\u001b[39;00m\n\u001b[1;32m 1524\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_forward_pre_hooks\n\u001b[1;32m 1525\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_backward_pre_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_backward_hooks\n\u001b[1;32m 1526\u001b[0m \u001b[38;5;129;01mor\u001b[39;00m _global_forward_hooks \u001b[38;5;129;01mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[0;32m-> 1527\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mforward_call\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1529\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1530\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/transformers/models/time_series_transformer/modeling_time_series_transformer.py:1615\u001b[0m, in \u001b[0;36mTimeSeriesTransformerForPrediction.forward\u001b[0;34m(self, past_values, past_time_features, past_observed_mask, static_categorical_features, static_real_features, future_values, future_time_features, future_observed_mask, decoder_attention_mask, head_mask, decoder_head_mask, cross_attn_head_mask, encoder_outputs, past_key_values, output_hidden_states, output_attentions, use_cache, return_dict)\u001b[0m\n\u001b[1;32m 1613\u001b[0m \u001b[38;5;66;03m# loc is 3rd last and scale is 2nd last output\u001b[39;00m\n\u001b[1;32m 1614\u001b[0m distribution \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moutput_distribution(params, loc\u001b[38;5;241m=\u001b[39moutputs[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m3\u001b[39m], scale\u001b[38;5;241m=\u001b[39moutputs[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2\u001b[39m])\n\u001b[0;32m-> 1615\u001b[0m loss \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mloss\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdistribution\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfuture_values\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1617\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m future_observed_mask \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 1618\u001b[0m future_observed_mask \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mones_like(future_values)\n", + "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/transformers/models/time_series_transformer/modeling_time_series_transformer.py:228\u001b[0m, in \u001b[0;36mnll\u001b[0;34m(input, target)\u001b[0m\n\u001b[1;32m 224\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mnll\u001b[39m(\u001b[38;5;28minput\u001b[39m: torch\u001b[38;5;241m.\u001b[39mdistributions\u001b[38;5;241m.\u001b[39mDistribution, target: torch\u001b[38;5;241m.\u001b[39mTensor) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m torch\u001b[38;5;241m.\u001b[39mTensor:\n\u001b[1;32m 225\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 226\u001b[0m \u001b[38;5;124;03m Computes the negative log likelihood loss from input distribution with respect to target.\u001b[39;00m\n\u001b[1;32m 227\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 228\u001b[0m \u001b[38;5;241;43m1\u001b[39;49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[38;5;241;43m0\u001b[39;49m\n\u001b[1;32m 229\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;241m-\u001b[39m\u001b[38;5;28minput\u001b[39m\u001b[38;5;241m.\u001b[39mlog_prob(target)\n", + "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero" ] } ], @@ -413,13 +409,5702 @@ }, { "cell_type": "code", - "execution_count": 141, + "execution_count": 17, + "id": "b1c76533-d48f-480f-a612-392f56d8d8c5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "> \u001b[0;32m/Users/jbloom/miniforge3/envs/multi_modal/lib/python3.10/site-packages/transformers/models/time_series_transformer/modeling_time_series_transformer.py\u001b[0m(228)\u001b[0;36mnll\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32m 226 \u001b[0;31m \u001b[0mComputes\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mnegative\u001b[0m \u001b[0mlog\u001b[0m \u001b[0mlikelihood\u001b[0m \u001b[0mloss\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0minput\u001b[0m \u001b[0mdistribution\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mrespect\u001b[0m \u001b[0mto\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 227 \u001b[0;31m \"\"\"\n", + "\u001b[0m\u001b[0;32m--> 228 \u001b[0;31m \u001b[0;36m1\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 229 \u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog_prob\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtarget\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\u001b[0;32m 230 \u001b[0;31m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0m\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> target.shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([256, 1, 2])\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input.shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "*** AttributeError: 'AffineTransformed' object has no attribute 'shape'. Did you mean: 'scale'?\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> type(input)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> target.base_dist\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "*** AttributeError: 'Tensor' object has no attribute 'base_dist'\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AffineTransformed()\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input.scale\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]],\n", + "\n", + " [[1., 1.]]], device='mps:0')\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input.scale.shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([256, 1, 2])\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input.loc.shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([256, 1, 2])\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input.base_dist.mean\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[[-2.9107e-02, -3.1163e-01]],\n", + "\n", + " [[-7.0946e-02, -3.1517e-01]],\n", + "\n", + " [[-1.1454e-02, -2.3039e-01]],\n", + "\n", + " [[-9.2772e-02, -2.9468e-01]],\n", + "\n", + " [[-6.0582e-02, -4.0841e-01]],\n", + "\n", + " [[-5.6396e-02, -3.4926e-01]],\n", + "\n", + " [[-7.9465e-02, -3.1242e-01]],\n", + "\n", + " [[-3.0322e-02, -3.8905e-01]],\n", + "\n", + " [[-7.1906e-02, -3.1198e-01]],\n", + "\n", + " [[-1.0929e-01, -2.9603e-01]],\n", + "\n", + " [[-1.0034e-01, -2.5518e-01]],\n", + "\n", + " [[-1.0328e-01, -3.4481e-01]],\n", + "\n", + " [[-1.0366e-01, -3.3636e-01]],\n", + "\n", + " [[-3.6241e-02, -2.5984e-01]],\n", + "\n", + " [[-1.0993e-01, -3.9034e-01]],\n", + "\n", + " [[-6.4016e-03, -3.6285e-01]],\n", + "\n", + " [[-1.5141e-02, -3.1918e-01]],\n", + "\n", + " [[-9.6349e-02, -3.4014e-01]],\n", + "\n", + " [[-3.9460e-02, -2.5684e-01]],\n", + "\n", + " [[-1.1226e-01, -3.0082e-01]],\n", + "\n", + " [[-3.4455e-02, -3.8172e-01]],\n", + "\n", + " [[-1.3578e-01, -2.4145e-01]],\n", + "\n", + " [[-1.1799e-01, -3.0871e-01]],\n", + "\n", + " [[-8.4032e-02, -3.4267e-01]],\n", + "\n", + " [[-7.3733e-02, -3.8466e-01]],\n", + "\n", + " [[-1.2175e-01, -2.7085e-01]],\n", + "\n", + " [[-4.3141e-02, -3.0260e-01]],\n", + "\n", + " [[-1.5108e-02, -3.6757e-01]],\n", + "\n", + " [[-5.8124e-02, -3.5194e-01]],\n", + "\n", + " [[-2.0218e-02, -3.5210e-01]],\n", + "\n", + " [[-1.3150e-01, -2.8158e-01]],\n", + "\n", + " [[-4.8613e-02, -2.7229e-01]],\n", + "\n", + " [[-4.6247e-02, -2.6239e-01]],\n", + "\n", + " [[-1.3322e-01, -3.1150e-01]],\n", + "\n", + " [[ 2.1621e-02, -2.9885e-01]],\n", + "\n", + " [[-7.2050e-02, -3.2277e-01]],\n", + "\n", + " [[ 2.9504e-02, -3.8897e-01]],\n", + "\n", + " [[-6.5473e-02, -3.3878e-01]],\n", + "\n", + " [[-8.8042e-03, -3.0582e-01]],\n", + "\n", + " [[-9.2694e-02, -3.3211e-01]],\n", + "\n", + " [[-9.5644e-02, -1.5504e-01]],\n", + "\n", + " [[-6.5924e-02, -2.9637e-01]],\n", + "\n", + " [[-4.7834e-02, -3.7262e-01]],\n", + "\n", + " [[-5.4583e-02, -2.5157e-01]],\n", + "\n", + " [[-9.0357e-02, -3.2960e-01]],\n", + "\n", + " [[-5.7252e-02, -4.2397e-01]],\n", + "\n", + " [[-1.0771e-01, -3.0088e-01]],\n", + "\n", + " [[-7.3468e-02, -2.8103e-01]],\n", + "\n", + " [[-5.8320e-02, -3.7253e-01]],\n", + "\n", + " [[-1.1566e-01, -2.7411e-01]],\n", + "\n", + " [[ 1.4181e-02, -2.6593e-01]],\n", + "\n", + " [[-1.1402e-01, -2.7007e-01]],\n", + "\n", + " [[-5.6627e-02, -2.9242e-01]],\n", + "\n", + " [[ 9.1340e-04, -3.1409e-01]],\n", + "\n", + " [[-2.2924e-02, -2.8708e-01]],\n", + "\n", + " [[-5.6571e-02, -3.0713e-01]],\n", + "\n", + " [[-6.2042e-02, -2.6034e-01]],\n", + "\n", + " [[-9.3880e-02, -2.7998e-01]],\n", + "\n", + " [[-1.1439e-01, -2.9895e-01]],\n", + "\n", + " [[-1.4272e-01, -1.9406e-01]],\n", + "\n", + " [[-1.3992e-01, -3.3218e-01]],\n", + "\n", + " [[-2.3345e-02, -2.6468e-01]],\n", + "\n", + " [[-2.2919e-02, -2.9163e-01]],\n", + "\n", + " [[-1.1628e-01, -2.4352e-01]],\n", + "\n", + " [[-2.0474e-02, -3.0622e-01]],\n", + "\n", + " [[-1.0338e-01, -2.0858e-01]],\n", + "\n", + " [[-1.4680e-04, -2.1495e-01]],\n", + "\n", + " [[-1.2811e-01, -3.7804e-01]],\n", + "\n", + " [[-1.1637e-01, -2.4589e-01]],\n", + "\n", + " [[-7.6678e-02, -3.1219e-01]],\n", + "\n", + " [[ 9.1909e-03, -2.5748e-01]],\n", + "\n", + " [[-8.7011e-02, -1.3595e-01]],\n", + "\n", + " [[-1.3973e-01, -4.2323e-01]],\n", + "\n", + " [[-1.1562e-01, -2.2758e-01]],\n", + "\n", + " [[-9.0100e-02, -3.5532e-01]],\n", + "\n", + " [[-6.9077e-02, -2.6243e-01]],\n", + "\n", + " [[-9.5416e-02, -2.1337e-01]],\n", + "\n", + " [[-6.8385e-02, -2.5308e-01]],\n", + "\n", + " [[-1.2305e-01, -2.8014e-01]],\n", + "\n", + " [[-1.1320e-01, -3.0114e-01]],\n", + "\n", + " [[-6.8299e-02, -2.4836e-01]],\n", + "\n", + " [[-1.2166e-01, -2.8053e-01]],\n", + "\n", + " [[-1.5105e-01, -2.3735e-01]],\n", + "\n", + " [[-2.4781e-01, -2.7090e-01]],\n", + "\n", + " [[-6.5034e-02, -3.8128e-01]],\n", + "\n", + " [[-1.7487e-01, -1.9786e-01]],\n", + "\n", + " [[-5.1182e-02, -2.4882e-01]],\n", + "\n", + " [[-6.1977e-02, -2.2242e-01]],\n", + "\n", + " [[-9.4700e-02, -1.9586e-01]],\n", + "\n", + " [[ 1.7598e-02, -2.8913e-01]],\n", + "\n", + " [[ 1.7203e-03, -2.8857e-01]],\n", + "\n", + " [[-9.3339e-02, -3.0416e-01]],\n", + "\n", + " [[-7.4077e-02, -1.7114e-01]],\n", + "\n", + " [[-8.9866e-02, -3.5368e-01]],\n", + "\n", + " [[-7.4227e-02, -2.7512e-01]],\n", + "\n", + " [[-1.1151e-01, -3.3920e-01]],\n", + "\n", + " [[-5.4662e-02, -2.6635e-01]],\n", + "\n", + " [[-1.2500e-01, -3.4857e-01]],\n", + "\n", + " [[-8.5968e-02, -2.6636e-01]],\n", + "\n", + " [[-1.3641e-01, -2.8234e-01]],\n", + "\n", + " [[-1.2678e-01, -3.5729e-01]],\n", + "\n", + " [[-6.4884e-02, -2.8916e-01]],\n", + "\n", + " [[-7.3323e-02, -3.3806e-01]],\n", + "\n", + " [[-8.6431e-02, -3.3894e-01]],\n", + "\n", + " [[-1.0270e-01, -2.5767e-01]],\n", + "\n", + " [[-1.2195e-01, -4.0463e-01]],\n", + "\n", + " [[-7.8202e-02, -2.2697e-01]],\n", + "\n", + " [[-2.5018e-02, -2.5913e-01]],\n", + "\n", + " [[-9.3165e-02, -3.4718e-01]],\n", + "\n", + " [[-6.8638e-02, -3.3028e-01]],\n", + "\n", + " [[-1.0124e-01, -3.5572e-01]],\n", + "\n", + " [[-1.3196e-02, -3.3724e-01]],\n", + "\n", + " [[-7.9594e-02, -2.8136e-01]],\n", + "\n", + " [[-5.2644e-02, -3.1662e-01]],\n", + "\n", + " [[-1.2562e-01, -3.0977e-01]],\n", + "\n", + " [[-6.9994e-02, -2.7465e-01]],\n", + "\n", + " [[ 1.2932e-01, -2.3312e-01]],\n", + "\n", + " [[-1.1156e-01, -2.8252e-01]],\n", + "\n", + " [[-2.2002e-02, -2.0097e-01]],\n", + "\n", + " [[-1.4461e-01, -2.4826e-01]],\n", + "\n", + " [[-7.4229e-02, -3.1881e-01]],\n", + "\n", + " [[-6.1382e-02, -3.5513e-01]],\n", + "\n", + " [[-5.3390e-02, -3.0058e-01]],\n", + "\n", + " [[-1.4067e-01, -2.3999e-01]],\n", + "\n", + " [[-7.9103e-02, -2.6327e-01]],\n", + "\n", + " [[ 1.4345e-02, -3.0952e-01]],\n", + "\n", + " [[-5.2782e-02, -3.0540e-01]],\n", + "\n", + " [[-7.1327e-02, -3.3226e-01]],\n", + "\n", + " [[-7.3746e-02, -3.7320e-01]],\n", + "\n", + " [[-1.0123e-02, -3.4878e-01]],\n", + "\n", + " [[-1.3481e-01, -2.5856e-01]],\n", + "\n", + " [[-2.1071e-02, -2.6165e-01]],\n", + "\n", + " [[-8.5258e-02, -3.8573e-01]],\n", + "\n", + " [[-1.3076e-01, -3.2111e-01]],\n", + "\n", + " [[-1.3943e-01, -2.9997e-01]],\n", + "\n", + " [[-1.4993e-01, -2.9780e-01]],\n", + "\n", + " [[-1.2218e-01, -2.6881e-01]],\n", + "\n", + " [[-1.2825e-01, -3.4760e-01]],\n", + "\n", + " [[-1.3331e-01, -2.2697e-01]],\n", + "\n", + " [[-6.5502e-02, -2.1100e-01]],\n", + "\n", + " [[-9.3614e-02, -3.1290e-01]],\n", + "\n", + " [[-7.6481e-03, -2.8485e-01]],\n", + "\n", + " [[-4.5752e-02, -3.3307e-01]],\n", + "\n", + " [[-8.5938e-02, -3.2633e-01]],\n", + "\n", + " [[-1.0171e-01, -3.2055e-01]],\n", + "\n", + " [[-4.1602e-02, -3.1932e-01]],\n", + "\n", + " [[-3.3055e-02, -3.1713e-01]],\n", + "\n", + " [[-6.2341e-02, -3.3477e-01]],\n", + "\n", + " [[-4.0846e-02, -2.8358e-01]],\n", + "\n", + " [[-1.2666e-01, -2.6246e-01]],\n", + "\n", + " [[-9.5933e-02, -2.4638e-01]],\n", + "\n", + " [[-1.1358e-01, -3.0373e-01]],\n", + "\n", + " [[-5.1235e-02, -2.1065e-01]],\n", + "\n", + " [[-2.4973e-02, -3.4788e-01]],\n", + "\n", + " [[-6.2822e-02, -3.2584e-01]],\n", + "\n", + " [[-5.7696e-02, -3.1762e-01]],\n", + "\n", + " [[-1.1813e-01, -2.8321e-01]],\n", + "\n", + " [[-1.1620e-01, -2.8926e-01]],\n", + "\n", + " [[-3.3667e-02, -2.6987e-01]],\n", + "\n", + " [[-6.4696e-02, -2.7834e-01]],\n", + "\n", + " [[-1.0883e-01, -4.2295e-01]],\n", + "\n", + " [[-1.0120e-01, -2.8569e-01]],\n", + "\n", + " [[-6.9023e-02, -3.1127e-01]],\n", + "\n", + " [[-6.7462e-02, -3.4285e-01]],\n", + "\n", + " [[-2.7679e-03, -3.1818e-01]],\n", + "\n", + " [[-1.0432e-01, -3.2177e-01]],\n", + "\n", + " [[-2.1627e-03, -1.7642e-01]],\n", + "\n", + " [[-8.1565e-02, -3.2902e-01]],\n", + "\n", + " [[-4.8491e-02, -2.2836e-01]],\n", + "\n", + " [[-8.3132e-02, -3.3647e-01]],\n", + "\n", + " [[-1.2262e-01, -2.7520e-01]],\n", + "\n", + " [[-5.3419e-02, -3.4628e-01]],\n", + "\n", + " [[-4.0450e-02, -2.7195e-01]],\n", + "\n", + " [[-4.7749e-02, -3.0800e-01]],\n", + "\n", + " [[-4.6922e-02, -2.4536e-01]],\n", + "\n", + " [[ 5.3718e-02, -2.7799e-01]],\n", + "\n", + " [[ 1.9611e-03, -3.3886e-01]],\n", + "\n", + " [[-1.3509e-01, -3.8463e-01]],\n", + "\n", + " [[-7.2155e-02, -3.2677e-01]],\n", + "\n", + " [[-8.4486e-02, -3.3319e-01]],\n", + "\n", + " [[-3.8375e-02, -3.0836e-01]],\n", + "\n", + " [[-6.6206e-02, -3.1584e-01]],\n", + "\n", + " [[-3.4245e-02, -3.1079e-01]],\n", + "\n", + " [[-5.6720e-02, -3.0328e-01]],\n", + "\n", + " [[-1.0544e-01, -3.2795e-01]],\n", + "\n", + " [[-6.4407e-02, -2.8290e-01]],\n", + "\n", + " [[-1.8177e-02, -3.6534e-01]],\n", + "\n", + " [[-1.4791e-01, -2.9662e-01]],\n", + "\n", + " [[-1.4817e-01, -3.6275e-01]],\n", + "\n", + " [[-8.9813e-02, -3.2169e-01]],\n", + "\n", + " [[-9.6910e-02, -2.2746e-01]],\n", + "\n", + " [[-4.4059e-02, -2.8152e-01]],\n", + "\n", + " [[-8.2844e-02, -3.5518e-01]],\n", + "\n", + " [[ 1.2463e-02, -2.6077e-01]],\n", + "\n", + " [[-3.1037e-02, -3.7403e-01]],\n", + "\n", + " [[-9.2512e-02, -3.5687e-01]],\n", + "\n", + " [[-1.3719e-02, -3.7112e-01]],\n", + "\n", + " [[-1.4240e-01, -2.2673e-01]],\n", + "\n", + " [[-3.6920e-02, -1.8109e-01]],\n", + "\n", + " [[-1.0134e-01, -2.7147e-01]],\n", + "\n", + " [[-1.4219e-01, -3.3753e-01]],\n", + "\n", + " [[ 4.7860e-02, -2.5766e-01]],\n", + "\n", + " [[-1.5610e-02, -2.3426e-01]],\n", + "\n", + " [[ 4.2985e-02, -3.3512e-01]],\n", + "\n", + " [[-6.8411e-02, -2.4381e-01]],\n", + "\n", + " [[-9.8381e-02, -3.2888e-01]],\n", + "\n", + " [[-1.2002e-01, -3.3217e-01]],\n", + "\n", + " [[ 2.7037e-02, -2.1834e-01]],\n", + "\n", + " [[-1.4293e-01, -3.7177e-01]],\n", + "\n", + " [[-9.4465e-02, -2.8510e-01]],\n", + "\n", + " [[-1.3967e-01, -2.5808e-01]],\n", + "\n", + " [[-1.2958e-01, -3.1072e-01]],\n", + "\n", + " [[-6.9852e-02, -2.4676e-01]],\n", + "\n", + " [[-1.6340e-01, -2.7420e-01]],\n", + "\n", + " [[-8.2785e-02, -3.0715e-01]],\n", + "\n", + " [[-1.1548e-01, -2.7290e-01]],\n", + "\n", + " [[-7.3974e-02, -3.0556e-01]],\n", + "\n", + " [[-1.2227e-01, -2.0145e-01]],\n", + "\n", + " [[-1.3585e-01, -2.6353e-01]],\n", + "\n", + " [[-7.4032e-02, -2.4655e-01]],\n", + "\n", + " [[-1.2554e-02, -3.9700e-01]],\n", + "\n", + " [[-7.7950e-02, -1.9456e-01]],\n", + "\n", + " [[-1.8811e-01, -3.4652e-01]],\n", + "\n", + " [[-6.3570e-02, -1.8474e-01]],\n", + "\n", + " [[-1.6540e-02, -2.6995e-01]],\n", + "\n", + " [[-4.6240e-02, -3.3439e-01]],\n", + "\n", + " [[-7.9749e-02, -2.8781e-01]],\n", + "\n", + " [[-2.7793e-02, -3.3578e-01]],\n", + "\n", + " [[-5.1148e-02, -1.6991e-01]],\n", + "\n", + " [[ 2.0076e-02, -3.1048e-01]],\n", + "\n", + " [[-7.1666e-02, -2.8546e-01]],\n", + "\n", + " [[-6.1972e-02, -2.2547e-01]],\n", + "\n", + " [[-3.6906e-02, -3.4522e-01]],\n", + "\n", + " [[-3.3367e-02, -2.5442e-01]],\n", + "\n", + " [[ 1.5611e-02, -3.1693e-01]],\n", + "\n", + " [[-1.2778e-01, -3.1351e-01]],\n", + "\n", + " [[ 2.4982e-02, -2.2193e-01]],\n", + "\n", + " [[-7.7770e-02, -2.5857e-01]],\n", + "\n", + " [[-8.0308e-02, -3.0997e-01]],\n", + "\n", + " [[-9.1948e-02, -2.8636e-01]],\n", + "\n", + " [[-3.1095e-02, -2.7910e-01]],\n", + "\n", + " [[-8.9825e-02, -2.5609e-01]],\n", + "\n", + " [[-8.7702e-02, -1.8998e-01]],\n", + "\n", + " [[-3.1098e-02, -2.5408e-01]],\n", + "\n", + " [[-7.8323e-02, -3.0548e-01]],\n", + "\n", + " [[-1.2932e-01, -2.1771e-01]],\n", + "\n", + " [[-8.7044e-02, -3.4936e-01]],\n", + "\n", + " [[-7.9521e-02, -3.2194e-01]],\n", + "\n", + " [[-1.0176e-02, -3.1909e-01]],\n", + "\n", + " [[-7.8072e-02, -2.5259e-01]],\n", + "\n", + " [[-4.9209e-02, -2.9538e-01]],\n", + "\n", + " [[-1.0321e-01, -3.8769e-01]],\n", + "\n", + " [[ 2.9072e-02, -2.1321e-01]],\n", + "\n", + " [[-3.5288e-03, -2.7384e-01]],\n", + "\n", + " [[-9.3800e-02, -2.6892e-01]],\n", + "\n", + " [[-4.4673e-02, -3.0251e-01]]], device='mps:0',\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input.base_dist.mean.shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([256, 1, 2])\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input.variance\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[[3.6163, 2.6717]],\n", + "\n", + " [[3.6116, 2.6178]],\n", + "\n", + " [[3.5128, 2.6563]],\n", + "\n", + " [[3.8969, 2.6193]],\n", + "\n", + " [[3.6535, 2.7721]],\n", + "\n", + " [[3.6907, 2.8336]],\n", + "\n", + " [[3.5243, 2.6693]],\n", + "\n", + " [[3.5437, 2.6616]],\n", + "\n", + " [[3.3923, 2.6385]],\n", + "\n", + " [[3.8385, 2.5749]],\n", + "\n", + " [[3.5279, 2.6627]],\n", + "\n", + " [[3.1669, 2.7906]],\n", + "\n", + " [[3.6051, 2.9109]],\n", + "\n", + " [[3.4655, 2.7517]],\n", + "\n", + " [[3.6914, 2.4779]],\n", + "\n", + " [[3.4224, 2.7969]],\n", + "\n", + " [[3.4244, 2.5444]],\n", + "\n", + " [[3.5805, 2.7730]],\n", + "\n", + " [[3.5923, 2.4806]],\n", + "\n", + " [[3.9390, 2.5768]],\n", + "\n", + " [[3.3923, 2.8566]],\n", + "\n", + " [[3.5022, 2.6065]],\n", + "\n", + " [[3.6398, 2.6129]],\n", + "\n", + " [[3.6902, 2.6378]],\n", + "\n", + " [[3.5482, 2.9918]],\n", + "\n", + " [[3.0330, 2.7814]],\n", + "\n", + " [[3.7307, 2.6605]],\n", + "\n", + " [[3.5034, 2.7575]],\n", + "\n", + " [[3.5982, 3.0030]],\n", + "\n", + " [[3.8263, 2.6448]],\n", + "\n", + " [[3.5599, 2.7751]],\n", + "\n", + " [[3.3526, 2.6592]],\n", + "\n", + " [[3.2262, 2.7690]],\n", + "\n", + " [[3.1777, 2.7368]],\n", + "\n", + " [[3.4111, 2.6975]],\n", + "\n", + " [[3.6507, 2.5997]],\n", + "\n", + " [[3.5423, 3.1711]],\n", + "\n", + " [[3.6611, 2.7967]],\n", + "\n", + " [[3.6256, 2.9731]],\n", + "\n", + " [[3.3163, 2.6353]],\n", + "\n", + " [[3.2160, 2.8415]],\n", + "\n", + " [[3.4472, 2.7233]],\n", + "\n", + " [[3.8248, 2.8531]],\n", + "\n", + " [[3.6919, 2.5977]],\n", + "\n", + " [[3.5278, 2.7256]],\n", + "\n", + " [[3.7204, 2.5556]],\n", + "\n", + " [[3.5185, 2.7453]],\n", + "\n", + " [[3.5134, 2.6677]],\n", + "\n", + " [[3.5638, 2.6554]],\n", + "\n", + " [[3.3092, 2.5553]],\n", + "\n", + " [[3.6153, 2.6533]],\n", + "\n", + " [[3.5034, 2.5553]],\n", + "\n", + " [[3.5036, 2.8564]],\n", + "\n", + " [[3.4500, 2.8397]],\n", + "\n", + " [[3.4988, 2.5487]],\n", + "\n", + " [[4.0047, 2.9429]],\n", + "\n", + " [[3.6146, 2.5785]],\n", + "\n", + " [[3.5934, 2.6132]],\n", + "\n", + " [[3.5862, 2.5970]],\n", + "\n", + " [[3.5246, 2.5957]],\n", + "\n", + " [[3.8827, 2.8912]],\n", + "\n", + " [[3.8826, 2.8186]],\n", + "\n", + " [[3.6684, 2.5718]],\n", + "\n", + " [[3.2324, 2.5978]],\n", + "\n", + " [[3.6233, 2.4885]],\n", + "\n", + " [[3.3741, 2.6167]],\n", + "\n", + " [[3.3086, 2.7171]],\n", + "\n", + " [[3.4290, 2.7923]],\n", + "\n", + " [[3.7874, 2.4779]],\n", + "\n", + " [[3.5763, 2.7326]],\n", + "\n", + " [[3.7491, 2.7051]],\n", + "\n", + " [[3.8917, 2.8155]],\n", + "\n", + " [[3.7822, 2.9617]],\n", + "\n", + " [[3.3712, 2.6922]],\n", + "\n", + " [[3.5027, 2.5283]],\n", + "\n", + " [[3.2697, 2.4896]],\n", + "\n", + " [[3.6677, 2.6675]],\n", + "\n", + " [[3.4851, 2.5084]],\n", + "\n", + " [[3.4777, 2.6490]],\n", + "\n", + " [[3.4677, 2.5144]],\n", + "\n", + " [[3.1482, 2.5789]],\n", + "\n", + " [[3.5972, 2.5864]],\n", + "\n", + " [[3.7642, 2.5228]],\n", + "\n", + " [[3.4309, 2.5278]],\n", + "\n", + " [[3.3387, 2.9337]],\n", + "\n", + " [[3.5230, 2.6682]],\n", + "\n", + " [[3.5791, 2.5866]],\n", + "\n", + " [[3.5525, 2.8932]],\n", + "\n", + " [[3.3171, 2.3971]],\n", + "\n", + " [[3.5819, 2.6158]],\n", + "\n", + " [[3.4492, 2.5625]],\n", + "\n", + " [[3.7490, 2.6395]],\n", + "\n", + " [[4.1509, 2.7628]],\n", + "\n", + " [[3.7139, 2.7475]],\n", + "\n", + " [[3.5653, 2.5610]],\n", + "\n", + " [[3.5912, 2.5656]],\n", + "\n", + " [[3.8105, 2.5646]],\n", + "\n", + " [[3.6931, 2.5698]],\n", + "\n", + " [[3.6006, 2.5144]],\n", + "\n", + " [[3.6341, 2.4249]],\n", + "\n", + " [[3.6687, 2.4730]],\n", + "\n", + " [[3.1143, 2.5231]],\n", + "\n", + " [[3.5219, 2.7936]],\n", + "\n", + " [[3.5078, 2.7576]],\n", + "\n", + " [[3.3808, 2.6081]],\n", + "\n", + " [[3.3686, 3.1538]],\n", + "\n", + " [[4.0162, 2.2843]],\n", + "\n", + " [[3.8740, 2.2896]],\n", + "\n", + " [[3.6373, 2.4608]],\n", + "\n", + " [[3.5839, 2.6663]],\n", + "\n", + " [[3.5817, 2.9808]],\n", + "\n", + " [[3.6202, 2.7098]],\n", + "\n", + " [[3.4281, 2.8269]],\n", + "\n", + " [[3.5741, 2.6190]],\n", + "\n", + " [[3.6608, 2.4850]],\n", + "\n", + " [[3.6673, 2.5993]],\n", + "\n", + " [[4.1049, 2.4092]],\n", + "\n", + " [[3.8039, 2.4739]],\n", + "\n", + " [[3.4922, 2.6157]],\n", + "\n", + " [[3.3395, 3.0171]],\n", + "\n", + " [[3.6754, 2.8577]],\n", + "\n", + " [[3.6669, 2.9430]],\n", + "\n", + " [[3.5633, 2.6399]],\n", + "\n", + " [[3.6049, 2.5441]],\n", + "\n", + " [[4.0037, 2.6250]],\n", + "\n", + " [[3.7517, 2.5970]],\n", + "\n", + " [[3.7176, 2.4131]],\n", + "\n", + " [[3.5279, 2.8595]],\n", + "\n", + " [[3.7219, 2.7610]],\n", + "\n", + " [[3.8421, 2.5664]],\n", + "\n", + " [[3.2602, 2.5662]],\n", + "\n", + " [[3.6419, 2.6621]],\n", + "\n", + " [[3.4246, 2.9517]],\n", + "\n", + " [[3.6410, 2.7012]],\n", + "\n", + " [[3.4680, 2.6575]],\n", + "\n", + " [[3.6528, 2.7960]],\n", + "\n", + " [[3.4794, 2.5647]],\n", + "\n", + " [[3.0825, 2.4686]],\n", + "\n", + " [[3.2680, 2.6072]],\n", + "\n", + " [[3.4427, 2.5905]],\n", + "\n", + " [[3.8175, 2.5164]],\n", + "\n", + " [[3.2915, 2.4769]],\n", + "\n", + " [[3.3976, 2.6658]],\n", + "\n", + " [[3.8957, 2.5773]],\n", + "\n", + " [[3.7186, 2.6058]],\n", + "\n", + " [[3.6544, 2.9313]],\n", + "\n", + " [[3.6974, 2.5689]],\n", + "\n", + " [[3.3696, 2.6834]],\n", + "\n", + " [[3.5581, 2.5217]],\n", + "\n", + " [[3.6571, 2.5751]],\n", + "\n", + " [[3.5993, 2.6402]],\n", + "\n", + " [[3.4081, 2.6118]],\n", + "\n", + " [[3.3429, 2.7158]],\n", + "\n", + " [[3.4193, 2.7488]],\n", + "\n", + " [[3.3399, 2.6672]],\n", + "\n", + " [[3.5278, 2.5939]],\n", + "\n", + " [[3.4340, 2.6662]],\n", + "\n", + " [[3.7001, 2.5197]],\n", + "\n", + " [[3.8684, 2.6037]],\n", + "\n", + " [[3.7552, 2.4788]],\n", + "\n", + " [[3.4368, 2.9876]],\n", + "\n", + " [[3.6685, 2.5790]],\n", + "\n", + " [[3.7026, 2.9137]],\n", + "\n", + " [[3.5933, 2.7309]],\n", + "\n", + " [[3.6498, 2.9928]],\n", + "\n", + " [[3.6446, 2.6201]],\n", + "\n", + " [[3.6429, 2.5741]],\n", + "\n", + " [[3.4496, 2.6489]],\n", + "\n", + " [[3.3991, 2.7112]],\n", + "\n", + " [[3.7309, 2.6665]],\n", + "\n", + " [[3.7379, 2.5617]],\n", + "\n", + " [[3.4736, 2.7169]],\n", + "\n", + " [[3.7390, 2.5883]],\n", + "\n", + " [[3.6750, 2.6508]],\n", + "\n", + " [[3.3717, 2.6510]],\n", + "\n", + " [[3.8463, 2.4961]],\n", + "\n", + " [[3.5825, 2.9156]],\n", + "\n", + " [[3.4309, 2.9267]],\n", + "\n", + " [[3.6593, 2.5500]],\n", + "\n", + " [[3.6194, 2.6840]],\n", + "\n", + " [[3.5384, 2.7093]],\n", + "\n", + " [[3.6162, 2.6576]],\n", + "\n", + " [[3.9115, 2.8729]],\n", + "\n", + " [[3.6278, 2.6120]],\n", + "\n", + " [[3.7864, 2.6615]],\n", + "\n", + " [[3.4223, 2.5162]],\n", + "\n", + " [[3.9935, 2.8801]],\n", + "\n", + " [[3.6212, 2.8671]],\n", + "\n", + " [[3.9265, 2.7298]],\n", + "\n", + " [[3.6096, 2.7294]],\n", + "\n", + " [[3.5004, 2.7303]],\n", + "\n", + " [[3.5002, 2.6622]],\n", + "\n", + " [[3.4258, 2.6416]],\n", + "\n", + " [[3.7488, 2.7193]],\n", + "\n", + " [[3.6280, 2.7520]],\n", + "\n", + " [[3.6185, 3.2196]],\n", + "\n", + " [[3.5272, 2.6126]],\n", + "\n", + " [[3.3283, 2.7347]],\n", + "\n", + " [[3.6431, 2.6816]],\n", + "\n", + " [[3.6583, 2.5253]],\n", + "\n", + " [[4.0262, 2.9652]],\n", + "\n", + " [[3.2191, 2.6509]],\n", + "\n", + " [[3.6205, 2.4733]],\n", + "\n", + " [[3.7093, 2.7260]],\n", + "\n", + " [[3.7054, 2.6348]],\n", + "\n", + " [[3.5555, 2.6334]],\n", + "\n", + " [[3.4658, 2.7192]],\n", + "\n", + " [[3.2045, 2.8979]],\n", + "\n", + " [[3.5274, 2.9921]],\n", + "\n", + " [[3.6532, 2.6298]],\n", + "\n", + " [[3.6911, 2.6490]],\n", + "\n", + " [[3.3667, 2.9333]],\n", + "\n", + " [[3.5684, 2.5261]],\n", + "\n", + " [[3.5690, 2.6721]],\n", + "\n", + " [[3.4196, 2.5248]],\n", + "\n", + " [[3.5943, 2.6251]],\n", + "\n", + " [[3.6386, 2.4872]],\n", + "\n", + " [[3.4820, 2.6408]],\n", + "\n", + " [[3.7109, 2.5973]],\n", + "\n", + " [[3.2910, 2.5836]],\n", + "\n", + " [[3.5585, 3.2107]],\n", + "\n", + " [[3.3785, 2.7147]],\n", + "\n", + " [[3.8641, 2.8343]],\n", + "\n", + " [[3.4509, 2.6730]],\n", + "\n", + " [[3.6516, 2.4852]],\n", + "\n", + " [[3.6892, 2.9279]],\n", + "\n", + " [[3.5617, 2.9943]],\n", + "\n", + " [[3.4644, 2.5627]],\n", + "\n", + " [[3.2201, 2.4850]],\n", + "\n", + " [[3.4468, 2.6296]],\n", + "\n", + " [[3.5557, 2.6661]],\n", + "\n", + " [[3.5700, 2.4288]],\n", + "\n", + " [[3.6890, 2.7086]],\n", + "\n", + " [[3.8228, 2.7463]],\n", + "\n", + " [[3.6558, 2.6696]],\n", + "\n", + " [[3.4968, 2.5679]],\n", + "\n", + " [[3.5445, 2.5535]],\n", + "\n", + " [[3.6016, 2.5198]],\n", + "\n", + " [[3.5783, 2.5761]],\n", + "\n", + " [[3.5416, 2.5608]],\n", + "\n", + " [[3.6991, 2.5466]],\n", + "\n", + " [[3.6271, 2.5590]],\n", + "\n", + " [[3.5372, 2.5541]],\n", + "\n", + " [[3.6778, 2.5818]],\n", + "\n", + " [[3.5834, 2.6370]],\n", + "\n", + " [[3.7744, 2.5092]],\n", + "\n", + " [[3.8716, 2.5461]],\n", + "\n", + " [[3.4846, 2.4800]],\n", + "\n", + " [[3.7567, 2.8911]],\n", + "\n", + " [[3.1510, 2.6947]],\n", + "\n", + " [[3.3919, 2.7735]],\n", + "\n", + " [[3.5934, 3.0884]],\n", + "\n", + " [[3.6108, 2.4337]],\n", + "\n", + " [[3.9035, 2.7400]],\n", + "\n", + " [[3.2859, 2.5569]],\n", + "\n", + " [[3.7757, 2.3991]]], device='mps:0', grad_fn=)\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input.variance.shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([256, 1, 2])\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input.base_dist\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Independent(StudentT(df: torch.Size([256, 1, 2]), loc: torch.Size([256, 1, 2]), scale: torch.Size([256, 1, 2])), 1)\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input.base_dist.df\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "*** AttributeError: 'Independent' object has no attribute 'df'\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input.rsample()\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jbloom/miniforge3/envs/multi_modal/lib/python3.10/site-packages/torch/distributions/gamma.py:12: UserWarning: The operator 'aten::_standard_gamma' is not currently supported on the MPS backend and will fall back to run on the CPU. This may have performance implications. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/mps/MPSFallback.mm:13.)\n", + " return torch._standard_gamma(concentration)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[[ 3.6095e-01, -4.3494e-03]],\n", + "\n", + " [[ 2.0260e-01, 1.0884e-01]],\n", + "\n", + " [[-4.6401e-01, -2.7020e-01]],\n", + "\n", + " [[-7.6143e-01, -9.5355e-01]],\n", + "\n", + " [[-7.8649e-02, -6.7058e-01]],\n", + "\n", + " [[ 6.3132e-01, -1.1766e+00]],\n", + "\n", + " [[-1.9120e+00, -1.0884e+00]],\n", + "\n", + " [[-2.5539e+00, 1.1202e-01]],\n", + "\n", + " [[ 1.2694e+00, -5.8709e-01]],\n", + "\n", + " [[ 6.5056e-02, 1.0640e+01]],\n", + "\n", + " [[-7.1708e-01, -1.5661e+00]],\n", + "\n", + " [[ 8.2872e-01, -4.6947e-01]],\n", + "\n", + " [[-2.0152e+00, 3.3606e+00]],\n", + "\n", + " [[ 3.3094e-01, 1.1723e+00]],\n", + "\n", + " [[-1.4713e-01, -9.1752e-01]],\n", + "\n", + " [[ 1.7863e+00, -7.4051e-01]],\n", + "\n", + " [[ 6.6844e+00, -3.6576e-01]],\n", + "\n", + " [[ 1.0193e+00, -7.1851e-01]],\n", + "\n", + " [[ 1.3484e-01, -1.9467e+00]],\n", + "\n", + " [[-1.1017e+00, 3.4246e+00]],\n", + "\n", + " [[ 1.6617e-01, 7.6431e-01]],\n", + "\n", + " [[ 3.5350e+00, -7.8923e-01]],\n", + "\n", + " [[-4.5448e-01, -1.7938e+00]],\n", + "\n", + " [[ 6.8645e-01, -9.7927e-01]],\n", + "\n", + " [[ 8.9845e-01, -4.7588e-01]],\n", + "\n", + " [[ 1.8445e+00, -1.0073e-01]],\n", + "\n", + " [[-3.5142e-01, -1.4364e+00]],\n", + "\n", + " [[-2.2697e+00, -9.1937e-01]],\n", + "\n", + " [[ 6.2902e-01, -1.1685e+00]],\n", + "\n", + " [[ 1.2905e+00, -1.1682e+00]],\n", + "\n", + " [[ 8.9006e-01, -8.3013e-02]],\n", + "\n", + " [[ 3.7832e+00, -1.4733e+00]],\n", + "\n", + " [[ 1.6758e+00, 4.0835e+00]],\n", + "\n", + " [[ 8.1037e-01, 7.5581e-01]],\n", + "\n", + " [[-3.3240e-01, -3.5689e-01]],\n", + "\n", + " [[-2.2049e+00, -6.6580e-01]],\n", + "\n", + " [[-5.6800e-02, -1.9414e+00]],\n", + "\n", + " [[-1.3809e+00, -2.7143e-01]],\n", + "\n", + " [[ 3.1490e-01, 8.7568e-04]],\n", + "\n", + " [[-3.7353e-01, 1.0949e+00]],\n", + "\n", + " [[ 2.0414e+00, -4.3575e-01]],\n", + "\n", + " [[ 2.4097e-01, 1.9737e-01]],\n", + "\n", + " [[ 2.2404e-01, -6.4739e-01]],\n", + "\n", + " [[-3.4473e+00, 1.3661e-01]],\n", + "\n", + " [[-1.1518e+00, 1.0690e+00]],\n", + "\n", + " [[ 1.0450e+00, 1.0670e+00]],\n", + "\n", + " [[ 4.5318e-01, -7.0311e-01]],\n", + "\n", + " [[ 6.1564e-01, -1.1837e+00]],\n", + "\n", + " [[-7.3700e+00, 5.7618e-01]],\n", + "\n", + " [[-9.4166e-01, -1.2122e+00]],\n", + "\n", + " [[-1.7081e+00, 1.5766e+00]],\n", + "\n", + " [[-1.6369e+00, 7.1670e-02]],\n", + "\n", + " [[ 8.1111e-02, 7.8441e-02]],\n", + "\n", + " [[ 1.5707e+00, -8.5950e-01]],\n", + "\n", + " [[ 3.4735e-01, -2.0672e+00]],\n", + "\n", + " [[ 1.6489e+00, -1.5505e+00]],\n", + "\n", + " [[-3.6421e+00, 8.7550e-01]],\n", + "\n", + " [[-2.3298e+00, 9.3286e-01]],\n", + "\n", + " [[ 3.0564e-01, -1.4939e+00]],\n", + "\n", + " [[ 1.9751e-01, -1.7438e+00]],\n", + "\n", + " [[ 4.9644e-01, -6.0375e-01]],\n", + "\n", + " [[ 6.3590e-01, 2.1826e+00]],\n", + "\n", + " [[ 2.4449e-01, -1.4721e+00]],\n", + "\n", + " [[ 1.2312e+00, -1.2783e+00]],\n", + "\n", + " [[-3.2407e-01, -1.1108e+00]],\n", + "\n", + " [[-1.1821e-01, -2.1456e+00]],\n", + "\n", + " [[ 1.9443e-02, 1.5169e+00]],\n", + "\n", + " [[-1.1734e+00, -1.3734e+00]],\n", + "\n", + " [[ 3.1779e+00, 8.5254e-02]],\n", + "\n", + " [[-1.0814e+00, 9.8886e-02]],\n", + "\n", + " [[ 1.5410e+00, -7.6399e-02]],\n", + "\n", + " [[-2.0066e+00, 1.7668e+00]],\n", + "\n", + " [[-9.8603e-01, 1.5429e-01]],\n", + "\n", + " [[-4.3021e-01, -9.2935e-01]],\n", + "\n", + " [[ 8.1646e-01, -1.1042e+00]],\n", + "\n", + " [[-2.4029e+00, 8.1741e-02]],\n", + "\n", + " [[ 9.7986e-01, -9.2833e-01]],\n", + "\n", + " [[-7.4928e-01, 1.1231e+00]],\n", + "\n", + " [[ 1.1682e+00, 3.9702e-01]],\n", + "\n", + " [[-2.6224e+00, 4.6316e+00]],\n", + "\n", + " [[ 4.3394e-01, 1.5740e+00]],\n", + "\n", + " [[-1.5252e+00, 1.7030e+00]],\n", + "\n", + " [[-3.5677e-01, -9.4483e-01]],\n", + "\n", + " [[ 3.5692e-01, 1.2607e+00]],\n", + "\n", + " [[ 6.9493e-01, 4.3228e-01]],\n", + "\n", + " [[-2.8842e+00, -3.1490e-01]],\n", + "\n", + " [[ 3.3539e-01, -3.2490e-01]],\n", + "\n", + " [[ 5.3792e-01, -2.4775e-01]],\n", + "\n", + " [[ 2.2566e-01, -1.1801e+00]],\n", + "\n", + " [[ 8.8428e-02, -5.6949e-01]],\n", + "\n", + " [[ 7.2175e-01, -6.7327e-01]],\n", + "\n", + " [[-7.9615e-01, -2.7037e+00]],\n", + "\n", + " [[-2.8629e+00, 1.7987e+00]],\n", + "\n", + " [[ 1.1269e+00, 1.3378e+00]],\n", + "\n", + " [[-1.9465e+00, 1.1098e+00]],\n", + "\n", + " [[-4.1394e-01, 8.3769e-01]],\n", + "\n", + " [[-6.2618e-01, -9.4983e-01]],\n", + "\n", + " [[ 7.7616e-01, -7.2208e-01]],\n", + "\n", + " [[-3.8135e-01, 4.3179e-01]],\n", + "\n", + " [[ 7.7253e-01, 7.1517e-01]],\n", + "\n", + " [[ 3.7363e-01, -7.3493e-01]],\n", + "\n", + " [[ 2.8684e-01, -1.3043e+00]],\n", + "\n", + " [[-3.7548e+00, 1.1972e+00]],\n", + "\n", + " [[ 6.1736e-01, 4.1764e-01]],\n", + "\n", + " [[ 4.1238e+00, -2.5368e-01]],\n", + "\n", + " [[ 1.0092e+00, -1.7057e+00]],\n", + "\n", + " [[ 8.6300e-01, -3.3640e-01]],\n", + "\n", + " [[ 2.7984e-01, -2.2319e+00]],\n", + "\n", + " [[-2.4030e+00, -8.5868e-01]],\n", + "\n", + " [[ 2.6533e+00, -1.7943e+00]],\n", + "\n", + " [[-2.0384e-01, -6.3038e-01]],\n", + "\n", + " [[-1.2636e+00, 1.9081e-01]],\n", + "\n", + " [[-1.6814e+00, -9.4639e-02]],\n", + "\n", + " [[-8.5252e-01, -4.4603e-01]],\n", + "\n", + " [[-5.2608e-01, -4.4549e-01]],\n", + "\n", + " [[-6.0361e-02, -7.7900e-01]],\n", + "\n", + " [[ 1.8378e+00, -5.1485e-01]],\n", + "\n", + " [[-2.2967e+00, 3.6701e-01]],\n", + "\n", + " [[ 1.0020e+00, 5.9744e-01]],\n", + "\n", + " [[-9.5918e-01, 1.1361e+00]],\n", + "\n", + " [[-3.4237e-01, 1.3495e-01]],\n", + "\n", + " [[-3.7816e-01, -2.0001e-01]],\n", + "\n", + " [[ 1.0723e+00, -1.5622e+00]],\n", + "\n", + " [[ 3.4077e+00, 1.6040e-01]],\n", + "\n", + " [[-1.0706e+00, 1.5205e-01]],\n", + "\n", + " [[-6.7244e-01, 1.1499e+00]],\n", + "\n", + " [[ 8.7823e-01, -6.6254e-01]],\n", + "\n", + " [[ 1.5433e+00, 1.2459e+00]],\n", + "\n", + " [[ 9.4501e-01, 4.3963e-01]],\n", + "\n", + " [[ 6.6972e-02, 4.8971e-01]],\n", + "\n", + " [[ 2.2166e-01, 6.7771e-01]],\n", + "\n", + " [[ 1.3831e+00, 5.1419e-01]],\n", + "\n", + " [[ 1.8221e-01, 5.7158e-01]],\n", + "\n", + " [[-8.4644e-01, -8.4698e-01]],\n", + "\n", + " [[ 5.2858e-01, -7.8884e-01]],\n", + "\n", + " [[ 1.9799e+00, -2.9870e-02]],\n", + "\n", + " [[-2.2727e-01, 4.1446e-01]],\n", + "\n", + " [[-6.8495e-01, 1.9901e+00]],\n", + "\n", + " [[-8.2200e-01, 2.0269e-01]],\n", + "\n", + " [[ 4.4668e-01, -9.2793e-01]],\n", + "\n", + " [[-2.5275e+00, 8.6135e-02]],\n", + "\n", + " [[-7.6544e-01, -3.5840e-01]],\n", + "\n", + " [[-3.6752e-01, -4.1774e-01]],\n", + "\n", + " [[-1.2253e+00, -4.3118e-01]],\n", + "\n", + " [[ 1.1645e+00, 8.1353e-01]],\n", + "\n", + " [[-7.5962e-01, -5.8584e-01]],\n", + "\n", + " [[-1.6695e+00, 2.9370e-01]],\n", + "\n", + " [[-1.2556e+00, 1.2656e+00]],\n", + "\n", + " [[ 1.3237e+00, -1.4177e+00]],\n", + "\n", + " [[ 1.0652e+00, -5.8922e-01]],\n", + "\n", + " [[-1.9905e+00, -8.5976e-01]],\n", + "\n", + " [[ 1.0514e-01, 4.8458e-01]],\n", + "\n", + " [[-7.5095e-01, 4.6442e-01]],\n", + "\n", + " [[ 1.6289e+00, -1.9390e+00]],\n", + "\n", + " [[-3.7895e-01, -9.4894e-01]],\n", + "\n", + " [[ 2.1343e+00, 1.0131e+00]],\n", + "\n", + " [[-1.0544e+00, 3.7726e-01]],\n", + "\n", + " [[-1.0744e+00, 8.8526e-01]],\n", + "\n", + " [[-3.5785e-01, -3.0775e-01]],\n", + "\n", + " [[ 5.2560e-01, -1.1701e+00]],\n", + "\n", + " [[-1.1942e+00, 2.0149e-01]],\n", + "\n", + " [[ 1.2150e+00, 9.5106e-02]],\n", + "\n", + " [[ 3.1171e+00, -1.1542e+00]],\n", + "\n", + " [[ 8.6399e-01, 3.2448e+00]],\n", + "\n", + " [[-3.0528e+00, -5.0920e-01]],\n", + "\n", + " [[-2.3141e+00, -1.6512e+00]],\n", + "\n", + " [[ 6.2009e-01, -1.5661e+00]],\n", + "\n", + " [[-8.9898e-02, -7.6208e-02]],\n", + "\n", + " [[-4.5742e-01, -8.4481e-01]],\n", + "\n", + " [[ 4.2418e-01, -2.6386e+00]],\n", + "\n", + " [[ 1.9682e+00, -1.0543e+00]],\n", + "\n", + " [[ 4.5094e-01, -2.0582e+00]],\n", + "\n", + " [[-2.1667e+00, 1.8483e-01]],\n", + "\n", + " [[-6.8341e-01, 5.7461e-01]],\n", + "\n", + " [[-1.6789e+00, -3.1411e-01]],\n", + "\n", + " [[-7.6889e-01, -3.4755e-01]],\n", + "\n", + " [[ 7.4564e-01, 1.6218e-02]],\n", + "\n", + " [[ 1.5704e+00, 1.2844e-01]],\n", + "\n", + " [[-1.1102e+00, -1.4988e+00]],\n", + "\n", + " [[ 1.6674e-02, 1.5704e+00]],\n", + "\n", + " [[-1.8977e+00, 1.0096e+00]],\n", + "\n", + " [[ 1.1081e+00, -2.1957e+00]],\n", + "\n", + " [[ 2.2306e+00, -1.0261e+00]],\n", + "\n", + " [[ 3.4625e-01, -7.1483e-01]],\n", + "\n", + " [[ 1.0976e+00, 1.2693e+00]],\n", + "\n", + " [[-4.1693e-01, 1.3404e+00]],\n", + "\n", + " [[-7.8685e-01, 3.2401e+00]],\n", + "\n", + " [[-3.7042e-01, -6.9802e-01]],\n", + "\n", + " [[ 4.7240e-01, -4.2009e-01]],\n", + "\n", + " [[ 5.8776e-01, -1.9658e+00]],\n", + "\n", + " [[-2.6139e+00, -1.7350e+00]],\n", + "\n", + " [[ 1.5464e+00, -2.8724e-01]],\n", + "\n", + " [[ 1.7395e+00, -5.0152e-01]],\n", + "\n", + " [[ 8.1834e-02, -8.9371e-01]],\n", + "\n", + " [[-2.6180e+00, -9.3990e-01]],\n", + "\n", + " [[-3.7185e-01, -2.4519e-01]],\n", + "\n", + " [[ 3.6929e-01, -1.3249e+00]],\n", + "\n", + " [[-3.8913e+00, -6.1512e-01]],\n", + "\n", + " [[ 1.1795e+00, -1.6330e+00]],\n", + "\n", + " [[ 2.4734e+00, -2.9333e-01]],\n", + "\n", + " [[ 9.1194e-01, 2.6574e+00]],\n", + "\n", + " [[ 1.3264e+00, -6.5961e-01]],\n", + "\n", + " [[-1.5864e+00, -3.6464e-01]],\n", + "\n", + " [[ 1.7888e+00, 2.1579e+00]],\n", + "\n", + " [[ 2.8506e+00, -8.9147e-01]],\n", + "\n", + " [[-8.7887e-01, -5.5330e-01]],\n", + "\n", + " [[-1.5394e+00, -2.2705e-01]],\n", + "\n", + " [[-4.6678e-03, -1.0951e+00]],\n", + "\n", + " [[-1.1058e+00, -1.1681e+00]],\n", + "\n", + " [[-1.5284e-01, -4.0778e+00]],\n", + "\n", + " [[-2.2499e+00, -1.0610e+00]],\n", + "\n", + " [[-5.4043e-01, -5.2886e+00]],\n", + "\n", + " [[ 3.4816e-01, 6.1057e-01]],\n", + "\n", + " [[-6.6991e-01, -4.0808e+00]],\n", + "\n", + " [[ 1.2658e+00, 3.2402e-01]],\n", + "\n", + " [[ 2.7582e-02, 5.1031e-01]],\n", + "\n", + " [[-4.1169e-01, -5.3630e-02]],\n", + "\n", + " [[-1.6533e+00, -1.0738e+00]],\n", + "\n", + " [[-6.5974e-01, -7.7757e-01]],\n", + "\n", + " [[ 5.1800e-01, 2.7053e+00]],\n", + "\n", + " [[-6.9568e+00, -2.3587e-01]],\n", + "\n", + " [[ 3.8129e-01, -6.0357e-01]],\n", + "\n", + " [[ 1.0369e+00, -7.9706e-01]],\n", + "\n", + " [[-3.2913e-01, -2.3093e+00]],\n", + "\n", + " [[ 1.1647e+01, -2.9879e+00]],\n", + "\n", + " [[-7.6764e-01, -2.1009e+00]],\n", + "\n", + " [[ 1.1823e+00, -1.6213e+00]],\n", + "\n", + " [[-5.7423e-01, 2.1875e+00]],\n", + "\n", + " [[-8.7971e-01, 4.1767e+00]],\n", + "\n", + " [[ 2.8911e-01, -4.7967e+00]],\n", + "\n", + " [[ 1.5371e+00, 5.3105e-01]],\n", + "\n", + " [[-1.8403e+00, 2.0650e-02]],\n", + "\n", + " [[ 6.0544e-01, -2.7016e+00]],\n", + "\n", + " [[-8.3041e-01, -1.2856e+00]],\n", + "\n", + " [[ 9.7629e-01, -8.5089e-01]],\n", + "\n", + " [[-9.9056e-02, 1.9460e+00]],\n", + "\n", + " [[ 3.6980e-01, -5.0156e-01]],\n", + "\n", + " [[-1.4560e+00, -9.4878e-01]],\n", + "\n", + " [[ 1.1852e+00, 3.0638e+00]],\n", + "\n", + " [[ 3.5918e-01, -1.2894e-01]],\n", + "\n", + " [[-1.9437e+00, -1.0841e+00]],\n", + "\n", + " [[-2.2768e-01, -9.1962e-02]],\n", + "\n", + " [[ 3.5060e-01, 1.9578e+00]],\n", + "\n", + " [[ 5.6202e-01, -1.7396e-03]],\n", + "\n", + " [[ 2.6978e+00, 1.9789e+00]],\n", + "\n", + " [[-1.5673e-01, 5.9619e-03]],\n", + "\n", + " [[ 4.3158e-01, -6.2519e-01]],\n", + "\n", + " [[-1.7196e-01, -7.5470e-01]],\n", + "\n", + " [[ 1.6393e+00, -7.6932e-01]],\n", + "\n", + " [[-1.9173e+00, 2.6951e-02]],\n", + "\n", + " [[ 1.1774e+00, -1.7098e+00]],\n", + "\n", + " [[-5.8790e-01, -3.6443e-01]],\n", + "\n", + " [[ 1.3603e+00, -2.0053e+00]],\n", + "\n", + " [[ 1.4593e+00, -5.7730e+00]],\n", + "\n", + " [[-1.1544e+00, -7.0067e-01]],\n", + "\n", + " [[-3.3365e-01, -2.9912e-01]]], device='mps:0', grad_fn=)\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input.rsample().shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([256, 1, 2])\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input.rsample()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[[ 1.3434e+00, 5.5039e-01]],\n", + "\n", + " [[ 3.5696e+00, -8.9329e-01]],\n", + "\n", + " [[ 8.8599e-01, -8.6960e-01]],\n", + "\n", + " [[-1.0517e+00, 1.8553e-01]],\n", + "\n", + " [[ 4.7122e-01, -7.5611e-02]],\n", + "\n", + " [[ 2.2833e-01, -1.3002e+00]],\n", + "\n", + " [[-3.0051e-02, -2.4934e-01]],\n", + "\n", + " [[ 2.0598e+00, -4.0262e-01]],\n", + "\n", + " [[ 1.5094e+00, -1.3142e+00]],\n", + "\n", + " [[ 3.3976e-01, 5.8677e+00]],\n", + "\n", + " [[ 1.0277e+00, -1.0651e+00]],\n", + "\n", + " [[-4.1031e-02, -8.0998e-01]],\n", + "\n", + " [[ 1.1443e+00, -8.6426e-01]],\n", + "\n", + " [[-6.0604e-01, 1.2400e+00]],\n", + "\n", + " [[ 5.9270e-01, 4.6558e-01]],\n", + "\n", + " [[ 1.0585e+00, -1.0739e+00]],\n", + "\n", + " [[ 3.9874e-01, 2.3414e+00]],\n", + "\n", + " [[-8.6925e-01, 1.0366e+00]],\n", + "\n", + " [[-1.9364e+00, -7.2524e-01]],\n", + "\n", + " [[ 7.8139e-01, -8.7578e-01]],\n", + "\n", + " [[ 1.1435e+00, -4.8371e-01]],\n", + "\n", + " [[ 9.2432e-01, 7.4936e-01]],\n", + "\n", + " [[-8.4878e-01, -1.2647e+00]],\n", + "\n", + " [[ 9.4043e-01, -1.4704e+00]],\n", + "\n", + " [[-2.4022e-01, -3.3400e-01]],\n", + "\n", + " [[-3.5507e+00, -1.8459e-01]],\n", + "\n", + " [[-1.6435e+00, -6.5821e-01]],\n", + "\n", + " [[ 3.6990e+00, -2.6527e+00]],\n", + "\n", + " [[ 7.4854e-01, -1.2030e+00]],\n", + "\n", + " [[ 8.6827e-01, -5.0079e-01]],\n", + "\n", + " [[ 2.9361e+00, -1.9165e+00]],\n", + "\n", + " [[-1.9312e+00, 7.7366e-01]],\n", + "\n", + " [[ 8.4530e-01, -1.5197e-01]],\n", + "\n", + " [[-3.3378e-01, 1.6378e+00]],\n", + "\n", + " [[-1.7238e+00, -1.5712e-02]],\n", + "\n", + " [[-1.2215e+00, -1.8437e-01]],\n", + "\n", + " [[-6.1645e-02, -1.1424e+00]],\n", + "\n", + " [[-1.2522e+00, -6.5384e-01]],\n", + "\n", + " [[-7.1751e-01, 1.2399e-01]],\n", + "\n", + " [[ 1.3922e+00, 1.3857e-01]],\n", + "\n", + " [[-1.2440e+00, 3.6650e-01]],\n", + "\n", + " [[-5.1614e-01, -1.2868e+00]],\n", + "\n", + " [[ 3.4015e-01, 3.3997e-01]],\n", + "\n", + " [[ 1.4333e-02, 4.0369e-01]],\n", + "\n", + " [[-9.7730e-01, -2.8636e+00]],\n", + "\n", + " [[-8.9748e-01, -4.0702e+00]],\n", + "\n", + " [[-1.8631e+00, -1.7228e+00]],\n", + "\n", + " [[-5.3197e-01, -2.5103e+00]],\n", + "\n", + " [[-7.0806e-01, 1.8845e+00]],\n", + "\n", + " [[ 3.7042e+00, 1.1635e-01]],\n", + "\n", + " [[-1.0052e+00, 1.3066e+00]],\n", + "\n", + " [[ 1.1547e+00, -1.1295e+00]],\n", + "\n", + " [[ 1.2016e+00, 9.1286e-02]],\n", + "\n", + " [[-1.5894e+00, -4.7347e-01]],\n", + "\n", + " [[ 2.3297e-01, -4.9530e-01]],\n", + "\n", + " [[-6.6433e-01, -2.7168e+00]],\n", + "\n", + " [[-4.4600e-01, -6.7352e-01]],\n", + "\n", + " [[-1.4380e+00, -1.4002e-01]],\n", + "\n", + " [[ 5.7063e-01, -1.5536e+00]],\n", + "\n", + " [[-3.6119e-01, 2.1387e+00]],\n", + "\n", + " [[-9.2332e-01, -3.6960e-01]],\n", + "\n", + " [[ 5.3671e-01, 1.3132e-01]],\n", + "\n", + " [[-1.7180e-02, -8.1568e-01]],\n", + "\n", + " [[-7.1940e-01, -2.1866e+00]],\n", + "\n", + " [[ 2.4280e-01, 4.7621e-02]],\n", + "\n", + " [[ 5.8136e-01, -1.9462e-01]],\n", + "\n", + " [[-1.8737e+00, 2.7497e+00]],\n", + "\n", + " [[ 7.0936e-01, -2.6858e+00]],\n", + "\n", + " [[ 2.2183e-01, 8.6666e-01]],\n", + "\n", + " [[-1.2183e+00, 5.6949e+00]],\n", + "\n", + " [[-2.6416e-01, -1.5130e+00]],\n", + "\n", + " [[-1.6551e-02, 8.2296e-01]],\n", + "\n", + " [[-2.8446e+00, 1.7696e-01]],\n", + "\n", + " [[ 6.7145e-02, 7.5024e-01]],\n", + "\n", + " [[-8.1071e-01, -6.8592e-01]],\n", + "\n", + " [[ 2.1612e+00, 1.1554e+00]],\n", + "\n", + " [[ 2.7918e-01, 1.0133e+00]],\n", + "\n", + " [[ 1.2898e-01, -1.9364e+00]],\n", + "\n", + " [[-4.2211e-01, -6.6172e-01]],\n", + "\n", + " [[ 3.0252e-01, 2.2528e+00]],\n", + "\n", + " [[ 4.9534e-01, -9.6195e-01]],\n", + "\n", + " [[-4.9675e-02, -1.1039e+00]],\n", + "\n", + " [[ 4.6744e-01, 3.7554e-01]],\n", + "\n", + " [[-4.9334e-01, -4.5560e-01]],\n", + "\n", + " [[ 2.8498e+00, -6.9125e-01]],\n", + "\n", + " [[ 1.4445e+00, -1.2836e+00]],\n", + "\n", + " [[-1.2582e+00, 2.8420e-01]],\n", + "\n", + " [[ 2.0383e+00, 9.4751e-01]],\n", + "\n", + " [[-2.1035e-01, -7.0688e-01]],\n", + "\n", + " [[ 2.2579e-01, -2.3613e-01]],\n", + "\n", + " [[-2.5582e+00, 2.0203e+00]],\n", + "\n", + " [[-1.7238e+00, -8.8612e-01]],\n", + "\n", + " [[ 3.5925e+00, -1.7197e+00]],\n", + "\n", + " [[-5.2709e-01, 3.5928e-02]],\n", + "\n", + " [[-6.0578e-01, -9.1072e-01]],\n", + "\n", + " [[-7.3500e-01, -1.1602e+00]],\n", + "\n", + " [[ 1.4895e+00, 4.8529e-01]],\n", + "\n", + " [[ 1.0167e+00, 1.8726e+00]],\n", + "\n", + " [[ 4.4538e-01, -1.7235e-01]],\n", + "\n", + " [[ 1.4280e-01, -6.3956e-03]],\n", + "\n", + " [[ 5.7541e-01, 1.0983e-01]],\n", + "\n", + " [[ 2.9161e-01, -1.0711e+00]],\n", + "\n", + " [[-6.9515e-01, -2.6878e-01]],\n", + "\n", + " [[-7.5713e-01, 8.9308e-01]],\n", + "\n", + " [[-1.1987e+00, -8.4469e-01]],\n", + "\n", + " [[ 3.7081e+00, -2.1501e+00]],\n", + "\n", + " [[-5.0083e-01, -4.4043e-01]],\n", + "\n", + " [[ 1.9156e+00, 2.0663e-02]],\n", + "\n", + " [[-5.2017e-01, -3.3718e-04]],\n", + "\n", + " [[-1.7510e+00, -3.0573e-01]],\n", + "\n", + " [[ 1.3419e+00, 4.3139e-01]],\n", + "\n", + " [[-6.9727e-01, -1.4690e+00]],\n", + "\n", + " [[ 1.0316e-01, 2.9815e-01]],\n", + "\n", + " [[-2.6446e+00, -1.2127e+00]],\n", + "\n", + " [[-3.7200e+00, 8.9398e-02]],\n", + "\n", + " [[-1.2590e+00, -1.4401e+00]],\n", + "\n", + " [[-1.5913e+00, -1.8110e-01]],\n", + "\n", + " [[-3.9554e+00, -1.4168e+00]],\n", + "\n", + " [[-1.3941e-02, -1.2345e+00]],\n", + "\n", + " [[-3.9788e+00, -1.1835e+00]],\n", + "\n", + " [[-6.4244e-01, 1.9745e+00]],\n", + "\n", + " [[ 5.3589e-01, -1.7527e-01]],\n", + "\n", + " [[-6.0801e-02, -1.0383e+00]],\n", + "\n", + " [[-2.0743e-01, -1.4423e+00]],\n", + "\n", + " [[-1.9913e+00, 6.1317e-01]],\n", + "\n", + " [[-8.9457e-01, -1.0163e+00]],\n", + "\n", + " [[ 1.0670e+00, -2.1723e+00]],\n", + "\n", + " [[ 1.0694e+00, -9.3367e-01]],\n", + "\n", + " [[ 2.2151e-01, 6.2186e-01]],\n", + "\n", + " [[ 7.9411e-01, 4.6870e-01]],\n", + "\n", + " [[ 3.1993e-01, -3.1411e-02]],\n", + "\n", + " [[ 1.2780e+00, -5.9798e-01]],\n", + "\n", + " [[ 7.5206e-01, -6.2863e-01]],\n", + "\n", + " [[ 2.0944e-01, -5.2158e-01]],\n", + "\n", + " [[-1.4561e+00, 1.3330e-01]],\n", + "\n", + " [[ 4.2476e-01, -1.8350e+00]],\n", + "\n", + " [[ 4.1700e-01, -1.5379e+00]],\n", + "\n", + " [[-2.0677e-01, -5.5736e-01]],\n", + "\n", + " [[-4.6207e-02, 7.3862e-01]],\n", + "\n", + " [[ 7.4913e-01, -1.7521e+00]],\n", + "\n", + " [[-4.5532e-01, 1.1463e+00]],\n", + "\n", + " [[ 2.5363e-01, 2.0791e+00]],\n", + "\n", + " [[-2.2878e+00, 1.2153e+00]],\n", + "\n", + " [[-1.3677e+00, 3.5510e-01]],\n", + "\n", + " [[ 1.1365e+00, -1.8935e+00]],\n", + "\n", + " [[-7.2311e-01, 2.6107e+00]],\n", + "\n", + " [[-7.3951e-02, -7.6495e-01]],\n", + "\n", + " [[-2.0344e-01, -4.1814e-01]],\n", + "\n", + " [[ 5.5954e-01, -1.1926e+00]],\n", + "\n", + " [[-2.0177e+00, 9.0834e-02]],\n", + "\n", + " [[-1.7756e+00, -3.2735e-01]],\n", + "\n", + " [[ 3.7424e-01, 7.5244e-01]],\n", + "\n", + " [[ 2.8217e+00, 2.6010e-01]],\n", + "\n", + " [[ 6.0636e-01, 2.9528e-01]],\n", + "\n", + " [[-6.7637e-03, -2.5362e+00]],\n", + "\n", + " [[-8.1249e-01, -3.8742e-01]],\n", + "\n", + " [[ 6.0901e-01, -1.5616e+00]],\n", + "\n", + " [[ 1.6605e-01, -5.1596e-01]],\n", + "\n", + " [[-2.3499e+00, -1.3219e+00]],\n", + "\n", + " [[ 9.3544e-01, 1.6092e+00]],\n", + "\n", + " [[-2.2433e+00, 9.8495e-01]],\n", + "\n", + " [[ 1.4219e+00, -2.5006e-01]],\n", + "\n", + " [[-1.3213e+00, -1.1719e+00]],\n", + "\n", + " [[-2.0146e+00, -8.9535e-01]],\n", + "\n", + " [[ 2.3226e+00, -2.6240e+00]],\n", + "\n", + " [[ 1.1188e+00, -1.5585e+00]],\n", + "\n", + " [[-8.7332e-01, 1.6392e+00]],\n", + "\n", + " [[ 5.1671e-01, 1.0502e+00]],\n", + "\n", + " [[ 5.5641e-01, 4.4655e-01]],\n", + "\n", + " [[-3.0942e-01, -8.2496e-01]],\n", + "\n", + " [[ 5.0345e-01, 4.3136e-01]],\n", + "\n", + " [[-7.5265e-01, -1.4294e+00]],\n", + "\n", + " [[-6.9510e-02, 1.6665e-01]],\n", + "\n", + " [[-1.1425e+00, -1.9194e+00]],\n", + "\n", + " [[-5.4177e-01, -2.2018e+00]],\n", + "\n", + " [[-8.8126e+00, -6.3667e-01]],\n", + "\n", + " [[ 1.3946e+00, -2.6062e-01]],\n", + "\n", + " [[-6.8431e-01, -4.1084e-01]],\n", + "\n", + " [[-3.0517e+00, 4.0710e-02]],\n", + "\n", + " [[-2.2803e+00, -2.3253e-01]],\n", + "\n", + " [[ 1.2388e+00, 3.7406e-01]],\n", + "\n", + " [[ 5.5135e-01, 8.8625e-01]],\n", + "\n", + " [[-3.7761e-01, -3.1495e+00]],\n", + "\n", + " [[ 4.0836e-01, 3.1047e+00]],\n", + "\n", + " [[ 3.0630e-01, -6.2515e-01]],\n", + "\n", + " [[-9.8340e-01, -1.2893e+00]],\n", + "\n", + " [[-4.9141e-01, -1.7028e+00]],\n", + "\n", + " [[-8.8677e-01, -9.9775e-01]],\n", + "\n", + " [[-2.8243e-01, -5.0806e-01]],\n", + "\n", + " [[ 1.4133e+00, -2.4702e+00]],\n", + "\n", + " [[-1.2404e+00, 4.3421e-01]],\n", + "\n", + " [[-2.0948e+00, 2.9985e-01]],\n", + "\n", + " [[-4.1859e-01, 2.3052e+00]],\n", + "\n", + " [[-2.0476e+00, 9.2053e-02]],\n", + "\n", + " [[ 1.5403e+00, -3.8901e+00]],\n", + "\n", + " [[-1.6875e+00, -7.3995e-01]],\n", + "\n", + " [[-1.5240e+00, -3.3548e-01]],\n", + "\n", + " [[-1.2618e+00, -1.5900e-01]],\n", + "\n", + " [[-2.0772e+00, 8.4711e-01]],\n", + "\n", + " [[-1.7433e-01, -2.8608e-01]],\n", + "\n", + " [[-9.7435e-01, -1.3389e+00]],\n", + "\n", + " [[ 6.2959e-02, 8.8053e-01]],\n", + "\n", + " [[ 5.3889e-01, 2.6927e+00]],\n", + "\n", + " [[ 1.5789e+00, -1.3184e+00]],\n", + "\n", + " [[-1.8060e+00, -4.7516e-01]],\n", + "\n", + " [[ 1.5666e+00, 2.2638e-01]],\n", + "\n", + " [[ 3.9034e-01, -7.7389e-01]],\n", + "\n", + " [[ 2.5036e+00, 4.1303e-02]],\n", + "\n", + " [[-2.4269e-01, 1.8629e-01]],\n", + "\n", + " [[-3.0884e-01, -1.5593e-01]],\n", + "\n", + " [[-2.5942e-02, -8.1840e-01]],\n", + "\n", + " [[ 2.9920e-01, -1.1360e+00]],\n", + "\n", + " [[ 7.3664e-01, 3.6007e-01]],\n", + "\n", + " [[-9.7277e-02, 7.3860e-01]],\n", + "\n", + " [[ 5.1950e-01, 1.5440e+00]],\n", + "\n", + " [[ 2.5537e+00, -8.7277e-01]],\n", + "\n", + " [[-2.7940e-01, -8.3029e-01]],\n", + "\n", + " [[ 5.3157e-01, 4.2105e-01]],\n", + "\n", + " [[-1.5692e-02, -2.9133e+00]],\n", + "\n", + " [[-1.2875e+00, -2.6436e-01]],\n", + "\n", + " [[-7.7841e-01, 2.0984e+00]],\n", + "\n", + " [[-5.1726e-01, 4.0266e+00]],\n", + "\n", + " [[-1.0638e+00, -1.3889e+00]],\n", + "\n", + " [[ 1.7429e+00, -3.2767e+00]],\n", + "\n", + " [[-7.8639e-01, -1.4466e+00]],\n", + "\n", + " [[-4.3932e+00, 3.0463e-01]],\n", + "\n", + " [[-3.2076e+00, 1.1054e+00]],\n", + "\n", + " [[-2.1814e-01, -1.7660e-01]],\n", + "\n", + " [[ 3.7472e+00, -8.9654e-01]],\n", + "\n", + " [[-1.7118e-01, 1.0761e+00]],\n", + "\n", + " [[ 5.2318e-01, -1.1054e+00]],\n", + "\n", + " [[-5.5912e-01, -2.2446e-01]],\n", + "\n", + " [[ 1.3303e+00, -2.0153e+00]],\n", + "\n", + " [[-2.7586e+00, -3.3937e-01]],\n", + "\n", + " [[ 1.0953e+00, -3.0400e-02]],\n", + "\n", + " [[-1.0181e+00, -3.6561e-01]],\n", + "\n", + " [[ 1.0519e-01, -4.8782e-01]],\n", + "\n", + " [[-1.8006e+00, 5.5801e-01]],\n", + "\n", + " [[ 1.2718e-02, -1.3259e-01]],\n", + "\n", + " [[-1.7967e+00, 1.6581e+00]],\n", + "\n", + " [[-3.5892e-01, -8.3251e-01]],\n", + "\n", + " [[-1.9339e+00, -3.7147e+00]],\n", + "\n", + " [[ 2.9518e-01, 4.8450e-01]],\n", + "\n", + " [[-4.0760e+00, -1.2899e+00]],\n", + "\n", + " [[ 5.5425e-01, -1.9743e-01]],\n", + "\n", + " [[ 1.3674e+00, -8.8052e-02]],\n", + "\n", + " [[ 2.6418e-01, -5.5539e-01]],\n", + "\n", + " [[ 2.6829e+00, 1.9229e-01]],\n", + "\n", + " [[ 2.4742e+00, 6.6122e-01]],\n", + "\n", + " [[ 6.5936e-01, -2.7787e+00]],\n", + "\n", + " [[-1.9254e+00, -4.5873e-01]],\n", + "\n", + " [[-3.8729e-01, -1.7428e-01]],\n", + "\n", + " [[ 5.0204e-01, 1.7204e-01]],\n", + "\n", + " [[ 1.3461e+00, -2.0801e+00]],\n", + "\n", + " [[-1.2158e+00, 9.9410e-01]],\n", + "\n", + " [[-3.5859e-01, 2.3971e-01]]], device='mps:0', grad_fn=)\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input.rsample(sample_shape=[256,10,2])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[[[[[-9.8540e-01, 1.3596e+00]],\n", + "\n", + " [[-1.7868e+00, -2.2599e-01]],\n", + "\n", + " [[-2.2845e+00, -4.6738e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 3.8523e+00, -1.0253e+00]],\n", + "\n", + " [[-5.0934e-01, -1.1469e+00]],\n", + "\n", + " [[ 3.1186e-03, 4.8849e-01]]],\n", + "\n", + "\n", + " [[[ 2.0589e+00, -2.1198e-01]],\n", + "\n", + " [[-2.1896e+00, -1.0514e+00]],\n", + "\n", + " [[-1.0308e+00, 6.5735e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[-2.7744e-01, -2.4621e-01]],\n", + "\n", + " [[ 1.7615e+00, -1.0958e+00]],\n", + "\n", + " [[ 1.6858e+00, -5.9202e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-9.5450e-01, 1.0803e+00]],\n", + "\n", + " [[-2.3705e+00, -2.1939e-01]],\n", + "\n", + " [[-1.9538e+00, -4.6115e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 6.3271e+00, -4.5936e+00]],\n", + "\n", + " [[-6.9358e-01, -9.3238e-01]],\n", + "\n", + " [[ 4.8538e-02, 2.7032e+00]]],\n", + "\n", + "\n", + " [[[ 1.4315e+00, -1.7086e-01]],\n", + "\n", + " [[-3.5557e+00, -1.2181e+00]],\n", + "\n", + " [[-1.8953e+00, 1.3996e+00]],\n", + "\n", + " ...,\n", + "\n", + " [[-4.9508e-01, -2.4876e-01]],\n", + "\n", + " [[ 3.3820e+00, -1.3658e+00]],\n", + "\n", + " [[ 1.3829e+00, -6.5669e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-1.3268e+00, 7.3233e-01]],\n", + "\n", + " [[-2.5959e+00, -2.3936e-01]],\n", + "\n", + " [[-2.4506e+00, -3.5310e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 1.8635e+00, -8.0821e-01]],\n", + "\n", + " [[-9.8728e-01, -8.5979e-01]],\n", + "\n", + " [[ 2.9788e-02, 5.0707e-01]]],\n", + "\n", + "\n", + " [[[ 2.4298e+00, -2.0733e-01]],\n", + "\n", + " [[-1.4086e+00, -2.2530e+00]],\n", + "\n", + " [[-6.3736e-01, 8.7462e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[-6.5852e-01, -2.5899e-01]],\n", + "\n", + " [[ 3.9492e+00, -1.1398e+00]],\n", + "\n", + " [[ 8.3377e-01, -1.3812e+00]]]],\n", + "\n", + "\n", + "\n", + " ...,\n", + "\n", + "\n", + "\n", + " [[[[-1.6208e+00, 3.4351e+00]],\n", + "\n", + " [[-2.2734e+00, -1.9259e-01]],\n", + "\n", + " [[-2.6535e+00, -3.5608e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 3.7133e+00, -9.8756e-01]],\n", + "\n", + " [[-3.7640e-01, -1.0502e+00]],\n", + "\n", + " [[-4.5431e-03, 1.2877e+00]]],\n", + "\n", + "\n", + " [[[ 1.5186e+00, -2.3004e-01]],\n", + "\n", + " [[-3.8473e+00, -1.4477e+00]],\n", + "\n", + " [[-8.4829e-01, 1.5870e+00]],\n", + "\n", + " ...,\n", + "\n", + " [[-4.0652e-01, -2.6092e-01]],\n", + "\n", + " [[ 1.7922e+00, -8.4155e-01]],\n", + "\n", + " [[ 2.6134e+00, -9.9597e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-1.4899e+00, 8.3870e-01]],\n", + "\n", + " [[-3.0775e+00, -1.9042e-01]],\n", + "\n", + " [[-3.5915e+00, -4.0884e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 2.9386e+00, -1.1860e+00]],\n", + "\n", + " [[-3.1350e-01, -1.3201e+00]],\n", + "\n", + " [[ 4.0136e-02, 2.8309e-01]]],\n", + "\n", + "\n", + " [[[ 1.8397e+00, -1.4272e-01]],\n", + "\n", + " [[-1.7831e+00, -1.2044e+00]],\n", + "\n", + " [[-9.4216e-01, 5.4649e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[-2.2036e-01, -2.5020e-01]],\n", + "\n", + " [[ 3.7755e+00, -9.4550e-01]],\n", + "\n", + " [[ 1.4127e+00, -8.5857e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-7.8785e-01, 1.5627e+00]],\n", + "\n", + " [[-2.8206e+00, 5.4692e-03]],\n", + "\n", + " [[-2.7875e+00, -9.5148e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 3.3640e+00, -1.4367e+00]],\n", + "\n", + " [[-4.5576e-01, -1.2490e+00]],\n", + "\n", + " [[-4.2486e-03, 3.0509e+00]]],\n", + "\n", + "\n", + " [[[ 2.0912e+00, -3.3017e-02]],\n", + "\n", + " [[-2.5271e+00, -2.0129e+00]],\n", + "\n", + " [[-7.8159e-01, 1.7888e+00]],\n", + "\n", + " ...,\n", + "\n", + " [[-3.1767e-01, -2.5426e-01]],\n", + "\n", + " [[ 2.0678e+00, -1.3198e+00]],\n", + "\n", + " [[ 3.4233e+00, -8.0146e-01]]]]],\n", + "\n", + "\n", + "\n", + "\n", + " [[[[[-8.1758e-01, 6.4861e-01]],\n", + "\n", + " [[-3.0986e+00, -1.8652e-01]],\n", + "\n", + " [[-2.2645e+00, -3.5404e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 3.7298e+00, -1.3059e+00]],\n", + "\n", + " [[-3.8091e-01, -8.0719e-01]],\n", + "\n", + " [[ 4.0646e-02, 4.2652e-01]]],\n", + "\n", + "\n", + " [[[ 1.9513e+00, -1.9101e-01]],\n", + "\n", + " [[-3.5365e+00, -2.8885e+00]],\n", + "\n", + " [[-3.6930e-01, 7.5259e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[-1.3700e+00, -2.6159e-01]],\n", + "\n", + " [[ 2.5821e+00, -1.4403e+00]],\n", + "\n", + " [[ 1.6377e+00, -7.8018e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-6.1380e-01, 8.5512e-01]],\n", + "\n", + " [[-1.5626e+00, -2.5537e-01]],\n", + "\n", + " [[-3.0884e+00, -5.9428e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 1.4721e+00, -1.6078e+00]],\n", + "\n", + " [[-4.2144e-01, -1.2396e+00]],\n", + "\n", + " [[ 7.6309e-02, 6.8598e-01]]],\n", + "\n", + "\n", + " [[[ 2.2973e+00, -1.9036e-01]],\n", + "\n", + " [[-1.9866e+00, -9.2990e-01]],\n", + "\n", + " [[-2.2743e+00, 1.7836e+00]],\n", + "\n", + " ...,\n", + "\n", + " [[-5.4921e-01, -2.5695e-01]],\n", + "\n", + " [[ 3.5598e+00, -2.1185e+00]],\n", + "\n", + " [[ 1.8358e+00, -7.9619e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-1.8113e+00, 2.0670e+00]],\n", + "\n", + " [[-3.4255e+00, -2.1167e-01]],\n", + "\n", + " [[-2.8749e+00, -7.6046e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 2.6201e+00, -9.7332e-01]],\n", + "\n", + " [[-3.8500e-01, -6.3752e-01]],\n", + "\n", + " [[ 1.3336e-02, 8.0752e-01]]],\n", + "\n", + "\n", + " [[[ 1.1124e+00, -1.3043e-01]],\n", + "\n", + " [[-1.7529e+00, -1.2475e+00]],\n", + "\n", + " [[-6.9281e-01, 4.4272e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[-5.0386e-01, -2.5440e-01]],\n", + "\n", + " [[ 3.7110e+00, -8.8531e-01]],\n", + "\n", + " [[ 1.1826e+00, -1.2645e+00]]]],\n", + "\n", + "\n", + "\n", + " ...,\n", + "\n", + "\n", + "\n", + " [[[[-6.8613e-01, 5.6081e-01]],\n", + "\n", + " [[-4.8352e+00, -2.4184e-01]],\n", + "\n", + " [[-2.0849e+00, -4.3462e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 1.9256e+00, -1.6101e+00]],\n", + "\n", + " [[-3.4985e-01, -9.9393e-01]],\n", + "\n", + " [[ 3.2815e-02, 2.3962e-01]]],\n", + "\n", + "\n", + " [[[ 3.5924e+00, -2.3418e-01]],\n", + "\n", + " [[-1.8936e+00, -1.7976e+00]],\n", + "\n", + " [[-5.5185e-01, 1.4210e+00]],\n", + "\n", + " ...,\n", + "\n", + " [[-3.0431e-01, -1.5750e-01]],\n", + "\n", + " [[ 1.6834e+00, -9.6132e-01]],\n", + "\n", + " [[ 2.5239e+00, -1.1041e+00]]]],\n", + "\n", + "\n", + "\n", + " [[[[-1.1112e+00, 1.0134e+00]],\n", + "\n", + " [[-4.6419e+00, -2.5734e-01]],\n", + "\n", + " [[-1.4155e+00, -4.0455e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 3.0217e+00, -2.0083e+00]],\n", + "\n", + " [[-3.3268e-01, -3.1668e+00]],\n", + "\n", + " [[ 4.9581e-02, 1.5097e+00]]],\n", + "\n", + "\n", + " [[[ 3.7725e+00, 9.2051e-02]],\n", + "\n", + " [[-4.4394e+00, -1.4569e+00]],\n", + "\n", + " [[-6.1167e-01, 9.3719e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[-4.7947e-01, -2.5788e-01]],\n", + "\n", + " [[ 1.6892e+00, -9.2479e-01]],\n", + "\n", + " [[ 2.4125e+00, -5.6872e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-1.7365e+00, 1.9491e+00]],\n", + "\n", + " [[-1.3640e+00, -2.5167e-01]],\n", + "\n", + " [[-1.7952e+00, -5.4592e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 2.3505e+00, -1.9499e+00]],\n", + "\n", + " [[-8.6804e-01, -8.5269e-01]],\n", + "\n", + " [[-1.7250e-02, 6.4048e-01]]],\n", + "\n", + "\n", + " [[[ 1.2447e+00, -2.0002e-01]],\n", + "\n", + " [[-1.6634e+00, -9.6430e-01]],\n", + "\n", + " [[-3.1870e+00, 4.0513e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[-6.1154e-01, -2.5873e-01]],\n", + "\n", + " [[ 2.5211e+00, -9.7525e-01]],\n", + "\n", + " [[ 3.2703e+00, -9.2892e-01]]]]],\n", + "\n", + "\n", + "\n", + "\n", + " [[[[[-6.5339e-01, 1.3569e+00]],\n", + "\n", + " [[-1.1391e+00, -1.7943e-01]],\n", + "\n", + " [[-3.8209e+00, -3.7150e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 1.1889e+00, -1.3683e+00]],\n", + "\n", + " [[-4.7793e-01, -6.1812e-01]],\n", + "\n", + " [[ 9.2308e-03, 1.2719e+00]]],\n", + "\n", + "\n", + " [[[ 2.8536e+00, -1.9721e-01]],\n", + "\n", + " [[-1.7165e+00, -3.2340e+00]],\n", + "\n", + " [[-4.7245e-01, 7.3019e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[-9.2986e-01, -2.6032e-01]],\n", + "\n", + " [[ 1.3170e+01, -1.4402e+00]],\n", + "\n", + " [[ 3.0441e+00, -1.4504e+00]]]],\n", + "\n", + "\n", + "\n", + " [[[[-9.3006e-01, 1.0157e+00]],\n", + "\n", + " [[-3.6421e+00, -1.4275e-01]],\n", + "\n", + " [[-2.2181e+00, -4.4992e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 4.1015e+00, -2.2939e+00]],\n", + "\n", + " [[-4.2171e-01, -1.4955e+00]],\n", + "\n", + " [[ 5.9991e-02, 9.9622e-01]]],\n", + "\n", + "\n", + " [[[ 1.2433e+00, -1.7875e-01]],\n", + "\n", + " [[-3.1126e+00, -1.5590e+00]],\n", + "\n", + " [[-1.5259e+00, 1.5456e+00]],\n", + "\n", + " ...,\n", + "\n", + " [[-5.8906e-01, -2.5026e-01]],\n", + "\n", + " [[ 1.8066e+00, -1.8482e+00]],\n", + "\n", + " [[ 1.7504e+00, -7.5165e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-1.1280e+00, 2.2619e+00]],\n", + "\n", + " [[-2.4313e+00, -2.3489e-01]],\n", + "\n", + " [[-3.3124e+00, -4.2018e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 1.7706e+00, -1.4402e+00]],\n", + "\n", + " [[-4.0570e-01, -1.2655e+00]],\n", + "\n", + " [[ 3.1821e-02, 1.5086e+00]]],\n", + "\n", + "\n", + " [[[ 1.9479e+00, -1.2510e-01]],\n", + "\n", + " [[-2.6771e+00, -1.7264e+00]],\n", + "\n", + " [[-1.2649e+00, 1.0326e+00]],\n", + "\n", + " ...,\n", + "\n", + " [[-2.2712e-01, -2.5591e-01]],\n", + "\n", + " [[ 3.3248e+00, -1.0662e+00]],\n", + "\n", + " [[ 9.3451e-01, -1.1746e+00]]]],\n", + "\n", + "\n", + "\n", + " ...,\n", + "\n", + "\n", + "\n", + " [[[[-7.6494e-01, 7.1398e-01]],\n", + "\n", + " [[-2.5805e+00, -1.7909e-01]],\n", + "\n", + " [[-1.4819e+00, -3.5216e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 1.3250e+00, -1.2357e+00]],\n", + "\n", + " [[-8.6796e-01, -7.1043e-01]],\n", + "\n", + " [[ 3.8018e-02, 1.1340e+00]]],\n", + "\n", + "\n", + " [[[ 7.3460e+00, -1.5001e-01]],\n", + "\n", + " [[-2.0222e+00, -1.2443e+00]],\n", + "\n", + " [[-1.4418e+00, 6.1375e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[-3.9005e-01, -2.6022e-01]],\n", + "\n", + " [[ 1.7367e+00, -9.4733e-01]],\n", + "\n", + " [[ 1.8236e+00, -6.2310e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-1.9637e+00, 2.3445e+00]],\n", + "\n", + " [[-2.8254e+00, -2.0643e-01]],\n", + "\n", + " [[-1.9378e+00, -5.0446e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 2.1959e+00, -1.1455e+00]],\n", + "\n", + " [[-5.1043e-01, -7.0199e-01]],\n", + "\n", + " [[ 6.6181e-02, 4.1371e-01]]],\n", + "\n", + "\n", + " [[[ 1.1391e+00, -2.1441e-01]],\n", + "\n", + " [[-1.9845e+00, -1.7724e+00]],\n", + "\n", + " [[-1.1001e+00, 2.8347e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[-5.3135e-01, -2.4985e-01]],\n", + "\n", + " [[ 2.2752e+00, -1.4264e+00]],\n", + "\n", + " [[ 2.6399e+00, -9.5270e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-1.0399e+00, 1.1542e+00]],\n", + "\n", + " [[-3.1417e+00, -2.0379e-01]],\n", + "\n", + " [[-3.0086e+00, -3.8381e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 1.4166e+00, -1.0106e+00]],\n", + "\n", + " [[-8.7329e-01, -8.1911e-01]],\n", + "\n", + " [[ 7.3515e-02, 1.4633e+00]]],\n", + "\n", + "\n", + " [[[ 2.5670e+00, -1.2153e-01]],\n", + "\n", + " [[-2.9808e+00, -1.1215e+00]],\n", + "\n", + " [[-7.9011e-01, 4.6542e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[-3.0613e-01, -2.3816e-01]],\n", + "\n", + " [[ 3.5301e+00, -1.1073e+00]],\n", + "\n", + " [[ 1.7907e+00, -9.1653e-01]]]]],\n", + "\n", + "\n", + "\n", + "\n", + " ...,\n", + "\n", + "\n", + "\n", + "\n", + " [[[[[-6.3566e-01, 1.2523e+00]],\n", + "\n", + " [[-2.8059e+00, -2.3860e-01]],\n", + "\n", + " [[-5.0424e+00, -3.8217e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 3.6922e+00, -1.4357e+00]],\n", + "\n", + " [[-3.5185e-01, -1.6551e+00]],\n", + "\n", + " [[-4.6254e-04, 1.4010e+00]]],\n", + "\n", + "\n", + " [[[ 2.3837e+00, -1.6061e-01]],\n", + "\n", + " [[-5.4855e+00, -1.4095e+00]],\n", + "\n", + " [[-3.2301e+00, 1.9336e+00]],\n", + "\n", + " ...,\n", + "\n", + " [[-4.5507e-01, -2.6104e-01]],\n", + "\n", + " [[ 2.2739e+00, -3.5075e+00]],\n", + "\n", + " [[ 1.4354e+00, -8.0908e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-6.8742e-01, 9.8243e-01]],\n", + "\n", + " [[-4.6461e+00, -2.0896e-01]],\n", + "\n", + " [[-2.1139e+00, -3.3344e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 4.3749e+00, -6.3965e-01]],\n", + "\n", + " [[-3.6733e-01, -9.4365e-01]],\n", + "\n", + " [[ 3.0536e-02, 8.5112e-01]]],\n", + "\n", + "\n", + " [[[ 1.4386e+00, -1.4445e-01]],\n", + "\n", + " [[-3.6190e+00, -1.5283e+00]],\n", + "\n", + " [[-1.4458e+00, 5.8639e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[-3.6752e-01, -2.5808e-01]],\n", + "\n", + " [[ 3.5459e+00, -2.1399e+00]],\n", + "\n", + " [[ 1.8477e+00, -6.1892e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-1.0245e+00, 1.5808e+00]],\n", + "\n", + " [[-1.6246e+00, -2.5014e-01]],\n", + "\n", + " [[-1.9681e+00, -3.5969e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 2.1953e+00, -1.9691e+00]],\n", + "\n", + " [[-4.4374e-01, -1.4066e+00]],\n", + "\n", + " [[ 6.1000e-02, 1.4629e+00]]],\n", + "\n", + "\n", + " [[[ 6.8987e+00, -1.3582e-01]],\n", + "\n", + " [[-3.0004e+00, -1.4310e+00]],\n", + "\n", + " [[-9.3164e-01, 1.8034e+00]],\n", + "\n", + " ...,\n", + "\n", + " [[-2.8165e-01, -2.6008e-01]],\n", + "\n", + " [[ 3.8513e+00, -1.1580e+00]],\n", + "\n", + " [[ 2.4591e+00, -8.5180e-01]]]],\n", + "\n", + "\n", + "\n", + " ...,\n", + "\n", + "\n", + "\n", + " [[[[-1.6329e+00, 2.2507e+00]],\n", + "\n", + " [[-2.6450e+00, -2.2481e-01]],\n", + "\n", + " [[-1.4376e+00, -4.2172e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 2.6549e+00, -1.8144e+00]],\n", + "\n", + " [[-1.3410e+00, -1.2281e+00]],\n", + "\n", + " [[-7.4447e-03, 1.0440e+00]]],\n", + "\n", + "\n", + " [[[ 3.3613e+00, -1.5841e-01]],\n", + "\n", + " [[-9.8389e-01, -1.3300e+00]],\n", + "\n", + " [[-7.4755e-01, 5.4630e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[-2.1479e-01, -2.5322e-01]],\n", + "\n", + " [[ 7.9243e+00, -9.6863e-01]],\n", + "\n", + " [[ 1.3336e+00, -1.3641e+00]]]],\n", + "\n", + "\n", + "\n", + " [[[[-8.4272e-01, 1.0122e+00]],\n", + "\n", + " [[-3.3359e+00, -2.4041e-01]],\n", + "\n", + " [[-3.2855e+00, -5.2639e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 2.1874e+00, -9.3188e-01]],\n", + "\n", + " [[-3.3725e-01, -8.6989e-01]],\n", + "\n", + " [[-5.3516e-04, 9.1968e-01]]],\n", + "\n", + "\n", + " [[[ 2.3328e+00, -1.8405e-01]],\n", + "\n", + " [[-2.6232e+00, -1.8880e+00]],\n", + "\n", + " [[-8.3385e+00, 2.4232e+00]],\n", + "\n", + " ...,\n", + "\n", + " [[-5.4824e-01, -2.6281e-01]],\n", + "\n", + " [[ 1.2901e+00, -1.3227e+00]],\n", + "\n", + " [[ 1.3517e+00, -6.4370e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-1.0517e+00, 6.4303e-01]],\n", + "\n", + " [[-4.3576e+00, -2.2623e-01]],\n", + "\n", + " [[-2.0620e+00, -3.9243e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 3.2476e+00, -7.8384e-01]],\n", + "\n", + " [[-4.4585e-01, -9.8816e-01]],\n", + "\n", + " [[ 2.9368e-02, 1.5148e+00]]],\n", + "\n", + "\n", + " [[[ 3.2090e+00, -2.1207e-01]],\n", + "\n", + " [[-7.0627e-01, -1.2161e+00]],\n", + "\n", + " [[-8.3075e-01, 5.2726e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[-2.6351e-01, -2.5819e-01]],\n", + "\n", + " [[ 2.4227e+00, -4.0339e+00]],\n", + "\n", + " [[ 2.4072e+00, -1.0202e+00]]]]],\n", + "\n", + "\n", + "\n", + "\n", + " [[[[[-1.0264e+00, 2.3120e+00]],\n", + "\n", + " [[-4.9355e+00, -1.8340e-01]],\n", + "\n", + " [[-2.5199e+00, -4.4260e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 2.6763e+00, -1.6980e+00]],\n", + "\n", + " [[-7.1096e-01, -1.5344e+00]],\n", + "\n", + " [[ 1.1614e-01, 5.8770e-01]]],\n", + "\n", + "\n", + " [[[ 2.4749e+00, 2.1342e-01]],\n", + "\n", + " [[-1.1695e+00, -1.1234e+00]],\n", + "\n", + " [[-4.6824e+00, 2.2857e+00]],\n", + "\n", + " ...,\n", + "\n", + " [[-3.1462e-01, -2.5785e-01]],\n", + "\n", + " [[ 1.7983e+00, -3.6005e+00]],\n", + "\n", + " [[ 1.2772e+00, -7.3442e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-1.8800e+00, 1.1797e+00]],\n", + "\n", + " [[-1.8688e+00, -1.7683e-01]],\n", + "\n", + " [[-2.5198e+00, -4.2665e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 1.5527e+00, -1.1808e+00]],\n", + "\n", + " [[-6.7653e-01, -1.0123e+00]],\n", + "\n", + " [[ 1.1696e-02, 1.0809e+00]]],\n", + "\n", + "\n", + " [[[ 4.7067e+00, 4.5586e-02]],\n", + "\n", + " [[-2.1196e+00, -1.1739e+00]],\n", + "\n", + " [[-8.3235e-01, 7.5970e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[-3.3890e-01, -2.3500e-01]],\n", + "\n", + " [[ 7.7535e+00, -9.8050e-01]],\n", + "\n", + " [[ 1.3534e+00, -6.0459e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-1.1487e+00, 8.3609e-01]],\n", + "\n", + " [[-2.2743e+00, 1.1788e-01]],\n", + "\n", + " [[-1.3948e+00, -4.5373e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 1.5559e+00, -1.1665e+00]],\n", + "\n", + " [[-4.8330e-01, -7.2829e-01]],\n", + "\n", + " [[ 2.2729e-02, 1.0489e+00]]],\n", + "\n", + "\n", + " [[[ 2.4185e+00, 6.1084e-02]],\n", + "\n", + " [[-3.4838e+00, -1.0797e+00]],\n", + "\n", + " [[-2.2654e+00, 2.1278e+00]],\n", + "\n", + " ...,\n", + "\n", + " [[-6.5354e-01, -2.5757e-01]],\n", + "\n", + " [[ 2.3137e+00, -1.2694e+00]],\n", + "\n", + " [[ 2.2721e+00, -8.8413e-01]]]],\n", + "\n", + "\n", + "\n", + " ...,\n", + "\n", + "\n", + "\n", + " [[[[-8.8238e-01, 7.6405e-01]],\n", + "\n", + " [[-1.0774e+00, -2.0325e-01]],\n", + "\n", + " [[-2.3604e+00, -4.0855e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 2.0142e+00, -1.2813e+00]],\n", + "\n", + " [[-5.9044e-01, -1.1117e+00]],\n", + "\n", + " [[ 5.8066e-03, 4.7566e-01]]],\n", + "\n", + "\n", + " [[[ 1.6900e+00, -1.4878e-01]],\n", + "\n", + " [[-1.7590e+00, -8.5493e-01]],\n", + "\n", + " [[-7.0843e-01, 6.6483e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[-8.1754e-01, -2.5941e-01]],\n", + "\n", + " [[ 2.9393e+00, -1.3100e+00]],\n", + "\n", + " [[ 1.0524e+00, -1.3414e+00]]]],\n", + "\n", + "\n", + "\n", + " [[[[-7.4009e-01, 1.8990e+00]],\n", + "\n", + " [[-2.2506e+00, -1.3670e-01]],\n", + "\n", + " [[-2.5088e+00, -4.1474e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 1.3032e+00, -1.9163e+00]],\n", + "\n", + " [[-3.4262e-01, -1.1279e+00]],\n", + "\n", + " [[-1.0173e-02, 6.5105e-01]]],\n", + "\n", + "\n", + " [[[ 2.4173e+00, -6.4779e-02]],\n", + "\n", + " [[-2.1457e+00, -1.3608e+00]],\n", + "\n", + " [[-1.5818e+00, 1.3289e+00]],\n", + "\n", + " ...,\n", + "\n", + " [[-5.6676e-01, -2.3145e-01]],\n", + "\n", + " [[ 4.1956e+00, -1.6406e+00]],\n", + "\n", + " [[ 2.3037e+00, -5.9426e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-9.6625e-01, 4.8647e+00]],\n", + "\n", + " [[-1.9426e+00, -2.4634e-01]],\n", + "\n", + " [[-9.7682e-01, -3.5213e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 1.5529e+00, -1.5932e+00]],\n", + "\n", + " [[-9.9701e-01, -2.5409e+00]],\n", + "\n", + " [[ 8.9833e-02, 8.3086e-01]]],\n", + "\n", + "\n", + " [[[ 3.5257e+00, -1.5334e-01]],\n", + "\n", + " [[-3.4198e+00, -1.7060e+00]],\n", + "\n", + " [[-5.4043e-01, 5.1811e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[-6.6257e-01, -2.5153e-01]],\n", + "\n", + " [[ 6.7907e+00, -1.2231e+00]],\n", + "\n", + " [[ 2.9559e+00, -6.6349e-01]]]]],\n", + "\n", + "\n", + "\n", + "\n", + " [[[[[-2.4002e+00, 1.3444e+00]],\n", + "\n", + " [[-2.8116e+00, -2.0768e-01]],\n", + "\n", + " [[-2.9328e+00, -5.7480e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 2.6415e+00, -9.1270e-01]],\n", + "\n", + " [[-7.4589e-01, -7.4312e-01]],\n", + "\n", + " [[ 1.2138e-03, 1.0420e+00]]],\n", + "\n", + "\n", + " [[[ 2.7470e+00, -1.9885e-01]],\n", + "\n", + " [[-2.4689e+00, -1.8887e+00]],\n", + "\n", + " [[-7.1399e-01, 1.4542e+00]],\n", + "\n", + " ...,\n", + "\n", + " [[-6.1978e-01, -2.5093e-01]],\n", + "\n", + " [[ 1.8782e+00, -1.0841e+01]],\n", + "\n", + " [[ 1.4814e+00, -6.9173e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-6.7615e-01, 2.0840e+00]],\n", + "\n", + " [[-1.8665e+00, -2.2187e-01]],\n", + "\n", + " [[-1.0860e+00, -3.5229e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 2.0927e+00, -1.3692e+00]],\n", + "\n", + " [[-4.1413e-01, -1.4606e+00]],\n", + "\n", + " [[ 1.9261e-02, 1.9407e+00]]],\n", + "\n", + "\n", + " [[[ 1.7217e+00, -7.6315e-02]],\n", + "\n", + " [[-1.1692e+00, -2.3778e+00]],\n", + "\n", + " [[-9.7863e-01, 5.9041e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[-6.9002e-01, -2.5507e-01]],\n", + "\n", + " [[ 3.2221e+00, -1.2165e+00]],\n", + "\n", + " [[ 1.6525e+00, -5.9806e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-1.2195e+00, 2.0451e+00]],\n", + "\n", + " [[-1.5027e+00, -2.4045e-01]],\n", + "\n", + " [[-1.9493e+00, -5.2659e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 1.7297e+00, -9.7293e-01]],\n", + "\n", + " [[-2.0482e-01, -1.1193e+00]],\n", + "\n", + " [[ 3.9261e-02, 7.3982e-01]]],\n", + "\n", + "\n", + " [[[ 6.9390e+00, -2.2510e-01]],\n", + "\n", + " [[-2.4470e+00, -1.2550e+00]],\n", + "\n", + " [[-6.5648e-01, 1.0714e+00]],\n", + "\n", + " ...,\n", + "\n", + " [[-5.0733e-01, -2.4677e-01]],\n", + "\n", + " [[ 2.1924e+00, -1.2649e+00]],\n", + "\n", + " [[ 1.7871e+00, -9.0348e-01]]]],\n", + "\n", + "\n", + "\n", + " ...,\n", + "\n", + "\n", + "\n", + " [[[[-9.8265e-01, 1.2293e+00]],\n", + "\n", + " [[-2.2372e+00, 1.0048e-01]],\n", + "\n", + " [[-3.5810e+00, -3.7747e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 2.5454e+00, -8.9774e-01]],\n", + "\n", + " [[-4.2237e-01, -9.3975e-01]],\n", + "\n", + " [[ 2.7312e-02, 6.0485e-01]]],\n", + "\n", + "\n", + " [[[ 2.4743e+00, -1.9722e-01]],\n", + "\n", + " [[-1.2558e+00, -1.4166e+00]],\n", + "\n", + " [[-7.1013e-01, 4.4541e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[-4.1619e-01, -2.5667e-01]],\n", + "\n", + " [[ 6.2804e+00, -1.3550e+00]],\n", + "\n", + " [[ 1.4748e+00, -5.9044e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-1.3398e+00, 1.3177e+00]],\n", + "\n", + " [[-1.3579e+00, -1.9819e-01]],\n", + "\n", + " [[-1.4353e+00, -3.4826e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 1.5159e+00, -7.0983e-01]],\n", + "\n", + " [[-5.0731e-01, -8.3226e-01]],\n", + "\n", + " [[ 1.8922e-02, 2.7229e-01]]],\n", + "\n", + "\n", + " [[[ 1.2396e+00, -1.7121e-01]],\n", + "\n", + " [[-1.6702e+00, -1.3380e+00]],\n", + "\n", + " [[-2.1203e+00, 1.0083e+00]],\n", + "\n", + " ...,\n", + "\n", + " [[-2.0829e-01, -2.5192e-01]],\n", + "\n", + " [[ 2.1341e+00, -2.8099e+00]],\n", + "\n", + " [[ 1.4186e+00, -7.7924e-01]]]],\n", + "\n", + "\n", + "\n", + " [[[[-1.3246e+00, 1.1009e+00]],\n", + "\n", + " [[-1.3690e+00, -1.9193e-01]],\n", + "\n", + " [[-2.4617e+00, -5.7732e-01]],\n", + "\n", + " ...,\n", + "\n", + " [[ 2.5529e+00, -1.1443e+00]],\n", + "\n", + " [[-3.5017e-01, -9.0197e-01]],\n", + "\n", + " [[-6.5091e-03, 1.4455e+00]]],\n", + "\n", + "\n", + " [[[ 1.9147e+00, -1.6529e-01]],\n", + "\n", + " [[-1.5585e+00, -1.5891e+00]],\n", + "\n", + " [[-1.1624e+00, 1.4396e+00]],\n", + "\n", + " ...,\n", + "\n", + " [[-5.4949e-01, -2.6253e-01]],\n", + "\n", + " [[ 3.0204e+00, -1.2731e+00]],\n", + "\n", + " [[ 2.8026e+00, -8.4020e-01]]]]]], device='mps:0',\n", + " grad_fn=)\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input.rsample(sample_shape=[256,10,2]).shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([256, 10, 2, 256, 1, 2])\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input.sample(sample_shape=[256,10,2]).shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([256, 10, 2, 256, 1, 2])\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input.sample(sample_shape=[10]).shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([10, 256, 1, 2])\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input.sample(sample_shape=[100]).shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([100, 256, 1, 2])\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> import matplotlib.pyplot as plt\n", + "ipdb> a=input.sample(sample_shape=[100])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "input = AffineTransformed()\n", + "target = tensor([[[ 1.1024e+00, 2.1772e+00]],\n", + "\n", + " [[ 3.1114e+00, 1.4761e-01]],\n", + "\n", + " [[ 5.1210e-01, 5.9002e-02]],\n", + "\n", + " [[ 8.3943e-01, 5.8365e-01]],\n", + "\n", + " [[ 5.3114e+00, 4.1811e-01]],\n", + "\n", + " [[-1.6225e+00, 6.3479e-01]],\n", + "\n", + " [[ 1.1662e+00, 5.2098e-01]],\n", + "\n", + " [[-1.3431e+00, 9.0591e-02]],\n", + "\n", + " [[ 1.7831e+00, 4.8382e-01]],\n", + "\n", + " [[-7.7729e-01, 6.5439e-02]],\n", + "\n", + " [[-1.8917e-01, 2.5169e-01]],\n", + "\n", + " [[ 2.7472e-01, 6.9801e-03]],\n", + "\n", + " [[ 6.9222e-01, 3.7090e-01]],\n", + "\n", + " [[-1.3887e-01, 1.0465e-01]],\n", + "\n", + " [[ 4.6390e-02, 1.2863e+00]],\n", + "\n", + " [[ 5.9043e-01, 8.5441e-02]],\n", + "\n", + " [[-1.3656e-01, 8.3530e-02]],\n", + "\n", + " [[-8.7757e-01, 3.5164e-02]],\n", + "\n", + " [[ 1.3106e+00, 7.1244e-01]],\n", + "\n", + " [[-2.5985e+00, 1.0988e+00]],\n", + "\n", + " [[-1.2188e+00, 5.1509e-01]],\n", + "\n", + " [[-1.3239e+00, 2.3816e-01]],\n", + "\n", + " [[ 1.4020e+00, 1.0593e+00]],\n", + "\n", + " [[ 2.4453e+00, 1.3241e-01]],\n", + "\n", + " [[ 2.0195e+00, 7.1989e-01]],\n", + "\n", + " [[-3.4026e+00, 8.1526e-02]],\n", + "\n", + " [[ 1.6343e+00, 9.8419e-02]],\n", + "\n", + " [[ 5.6068e+00, 9.0171e-01]],\n", + "\n", + " [[-1.8071e-01, 2.7081e-01]],\n", + "\n", + " [[ 2.4005e-01, 2.9633e-01]],\n", + "\n", + " [[-3.8343e-01, 5.0071e-01]],\n", + "\n", + " [[-9.0314e-01, 1.1513e-02]],\n", + "\n", + " [[ 1.5037e+00, 2.7778e-02]],\n", + "\n", + " [[ 1.0208e+00, 6.7165e-01]],\n", + "\n", + " [[ 1.3749e+00, 1.1315e+00]],\n", + "\n", + " [[ 1.2911e+00, 5.3599e-01]],\n", + "\n", + " [[ 1.2694e+00, 5.7475e-01]],\n", + "\n", + " [[ 2.8926e+00, 2.3275e+00]],\n", + "\n", + " [[ 2.4626e+00, 8.1767e-02]],\n", + "\n", + " [[-1.5631e+00, 6.3914e-01]],\n", + "\n", + " [[ 3.9286e-01, 6.4463e-01]],\n", + "\n", + " [[-1.1152e+00, 2.1564e-01]],\n", + "\n", + " [[-1.7656e+00, 1.0368e+00]],\n", + "\n", + " [[ 1.0209e+00, 9.9602e-02]],\n", + "\n", + " [[ 9.5942e-01, 1.2126e-01]],\n", + "\n", + " [[-1.6891e+00, 1.9165e+00]],\n", + "\n", + " [[-1.5118e+00, 4.6190e-01]],\n", + "\n", + " [[-5.5326e-01, 1.4059e-01]],\n", + "\n", + " [[-4.1279e+00, 4.0986e+00]],\n", + "\n", + " [[-6.9195e-01, 3.0321e-02]],\n", + "\n", + " [[ 1.7902e+00, 4.2824e-01]],\n", + "\n", + " [[ 5.2053e-01, 4.3660e-01]],\n", + "\n", + " [[ 6.0946e-01, 4.1516e-02]],\n", + "\n", + " [[ 1.2655e+00, 4.1619e-02]],\n", + "\n", + " [[ 8.7225e-01, 1.2361e+00]],\n", + "\n", + " [[-1.0917e+00, 1.2601e-01]],\n", + "\n", + " [[-1.8421e+00, 6.1246e-01]],\n", + "\n", + " [[-1.4119e+00, 1.8471e-01]],\n", + "\n", + " [[ 7.5096e-01, 1.3828e-01]],\n", + "\n", + " [[ 7.5388e-01, 6.3323e-01]],\n", + "\n", + " [[-8.0983e-01, 4.6502e-01]],\n", + "\n", + " [[-9.5473e-01, 3.6264e-02]],\n", + "\n", + " [[ 2.0553e+00, 8.7919e-02]],\n", + "\n", + " [[ 1.9877e+00, 3.5492e-01]],\n", + "\n", + " [[ 8.6919e-01, 1.0212e+00]],\n", + "\n", + " [[-6.2295e-01, 2.3214e+00]],\n", + "\n", + " [[-2.6674e+00, 1.0343e+00]],\n", + "\n", + " [[-6.3484e-01, 3.3307e-01]],\n", + "\n", + " [[ 3.3079e-01, 7.9936e-01]],\n", + "\n", + " [[ 1.5918e+00, 3.4539e-01]],\n", + "\n", + " [[ 9.4901e-01, 4.6944e-01]],\n", + "\n", + " [[-6.0613e+00, 4.9916e-01]],\n", + "\n", + " [[ 3.2753e+00, 2.2067e-01]],\n", + "\n", + " [[-2.3711e-02, 2.3646e-02]],\n", + "\n", + " [[ 2.6951e+00, 1.0527e-01]],\n", + "\n", + " [[ 5.4559e-01, 9.4711e-01]],\n", + "\n", + " [[-1.7149e+00, 4.6982e-02]],\n", + "\n", + " [[-1.9816e+00, 2.8419e-01]],\n", + "\n", + " [[-4.7207e-01, 5.7125e-01]],\n", + "\n", + " [[-9.0168e-01, 4.4606e+00]],\n", + "\n", + " [[-1.2876e+00, 3.5587e-01]],\n", + "\n", + " [[-1.0693e+00, 8.3030e-01]],\n", + "\n", + " [[-6.3592e-01, 2.6855e-01]],\n", + "\n", + " [[ 1.2398e+00, 3.6354e-01]],\n", + "\n", + " [[ 4.1649e+00, 2.3013e-01]],\n", + "\n", + " [[-9.5462e-01, 8.9883e-01]],\n", + "\n", + " [[-1.1604e+00, 1.6950e+00]],\n", + "\n", + " [[ 5.4592e-01, 5.7514e-01]],\n", + "\n", + " [[-1.9890e+00, 2.5985e-02]],\n", + "\n", + " [[-8.1254e-02, 8.6954e-01]],\n", + "\n", + " [[ 1.5071e+00, 3.6005e-02]],\n", + "\n", + " [[-1.6764e+00, 1.5400e+00]],\n", + "\n", + " [[-1.2338e+00, 8.0539e-01]],\n", + "\n", + " [[ 1.4445e+00, 1.1139e+00]],\n", + "\n", + " [[-1.1509e+00, 3.3666e-02]],\n", + "\n", + " [[-1.8596e+00, 1.4816e+00]],\n", + "\n", + " [[-1.0785e+00, 2.5688e-01]],\n", + "\n", + " [[ 1.6757e+00, 9.5609e-01]],\n", + "\n", + " [[-2.2549e+00, 1.9800e-01]],\n", + "\n", + " [[-5.5405e-01, 5.3391e-02]],\n", + "\n", + " [[ 2.1346e+00, 1.1595e-01]],\n", + "\n", + " [[ 1.9951e+00, 5.7987e-01]],\n", + "\n", + " [[ 1.8418e+00, 4.3986e-02]],\n", + "\n", + " [[ 1.6234e+00, 9.6446e-02]],\n", + "\n", + " [[-1.6102e+00, 2.7045e-01]],\n", + "\n", + " [[ 1.4274e+00, 6.1829e-01]],\n", + "\n", + " [[-5.6748e+00, 6.3902e-01]],\n", + "\n", + " [[-6.2886e-01, 1.9538e-02]],\n", + "\n", + " [[ 7.9869e-01, 2.3074e-01]],\n", + "\n", + " [[ 9.2092e-01, 2.1942e-01]],\n", + "\n", + " [[-4.6721e-01, 8.3395e-01]],\n", + "\n", + " [[ 2.0355e+00, 8.5064e-01]],\n", + "\n", + " [[ 8.9913e-01, 7.5951e-01]],\n", + "\n", + " [[-2.7477e-01, 3.9971e-01]],\n", + "\n", + " [[-3.8438e-01, 4.3787e-01]],\n", + "\n", + " [[-9.7013e-01, 1.4910e-02]],\n", + "\n", + " [[ 0.0000e+00, 5.0362e-01]],\n", + "\n", + " [[-8.8448e-01, 2.0029e-02]],\n", + "\n", + " [[-1.5440e+00, 4.2479e-01]],\n", + "\n", + " [[-1.3420e+00, 5.0892e-01]],\n", + "\n", + " [[ 1.2490e+00, 1.2384e-01]],\n", + "\n", + " [[ 2.7104e-01, 7.2835e-01]],\n", + "\n", + " [[ 1.1307e+00, 2.1698e-01]],\n", + "\n", + " [[-2.7158e+00, 2.7090e-01]],\n", + "\n", + " [[ 1.3331e-01, 7.0168e-01]],\n", + "\n", + " [[-3.1136e-01, 1.2778e-01]],\n", + "\n", + " [[-2.4204e+00, 1.9048e+00]],\n", + "\n", + " [[ 1.2353e+00, 8.5247e-01]],\n", + "\n", + " [[ 1.6095e+00, 7.0575e-02]],\n", + "\n", + " [[ 1.8635e+00, 1.3286e-01]],\n", + "\n", + " [[-2.7786e+00, 1.5485e-01]],\n", + "\n", + " [[ 2.7737e+00, 4.8957e-01]],\n", + "\n", + " [[-1.0635e+00, 3.1708e-02]],\n", + "\n", + " [[ 1.0200e+00, 1.0079e+00]],\n", + "\n", + " [[ 1.9060e+00, 1.1648e+00]],\n", + "\n", + " [[ 1.5797e-01, 4.8752e-01]],\n", + "\n", + " [[-2.1180e+00, 4.8782e-02]],\n", + "\n", + " [[-1.1888e+00, 1.1213e-01]],\n", + "\n", + " [[ 1.4036e+00, 9.9856e-01]],\n", + "\n", + " [[-1.0528e+00, 3.1561e-01]],\n", + "\n", + " [[-8.6944e-01, 5.6845e-01]],\n", + "\n", + " [[-2.4489e-01, 1.3948e-01]],\n", + "\n", + " [[ 5.3694e-02, 2.6923e-02]],\n", + "\n", + " [[ 2.4262e-03, 9.9519e-01]],\n", + "\n", + " [[-4.3507e-01, 2.0629e-01]],\n", + "\n", + " [[ 2.0605e+00, 6.1358e-01]],\n", + "\n", + " [[-4.6746e-03, 3.7380e-02]],\n", + "\n", + " [[ 1.9408e+00, 5.9027e-01]],\n", + "\n", + " [[ 1.7764e+00, 1.0740e+00]],\n", + "\n", + " [[-7.0619e-01, 1.4737e-01]],\n", + "\n", + " [[ 1.1451e-02, 5.5008e-01]],\n", + "\n", + " [[-1.0181e+00, 1.0348e+00]],\n", + "\n", + " [[-1.6197e+00, 3.1487e-01]],\n", + "\n", + " [[ 4.8850e+00, 4.4070e-02]],\n", + "\n", + " [[-4.7306e-01, 4.9577e-01]],\n", + "\n", + " [[ 5.9147e-01, 2.3433e+00]],\n", + "\n", + " [[-9.7199e-01, 4.3866e-01]],\n", + "\n", + " [[-2.4535e-01, 8.0271e-01]],\n", + "\n", + " [[-2.1219e+00, 4.2241e-01]],\n", + "\n", + " [[-1.2498e+00, 4.4761e-01]],\n", + "\n", + " [[ 1.2211e+00, 7.1118e-01]],\n", + "\n", + " [[ 6.5318e-01, 4.5337e-01]],\n", + "\n", + " [[ 1.4503e+00, 1.9720e+00]],\n", + "\n", + " [[ 1.4902e+00, 5.0134e-01]],\n", + "\n", + " [[-1.1631e+00, 4.7067e-01]],\n", + "\n", + " [[ 1.3901e+00, 6.2422e-01]],\n", + "\n", + " [[ 1.5011e+00, 2.9010e-01]],\n", + "\n", + " [[-4.2914e-01, 1.7334e-01]],\n", + "\n", + " [[ 2.0530e+00, 3.9742e-01]],\n", + "\n", + " [[ 6.8354e-01, 3.1415e-01]],\n", + "\n", + " [[-5.0541e-01, 3.0867e-01]],\n", + "\n", + " [[ 1.7083e+00, 8.9153e-01]],\n", + "\n", + " [[-8.4340e-01, 7.5098e-01]],\n", + "\n", + " [[ 5.2955e-01, 3.8706e-01]],\n", + "\n", + " [[ 6.8385e-01, 4.3816e-02]],\n", + "\n", + " [[ 2.2052e+00, 3.8353e-01]],\n", + "\n", + " [[ 1.9340e+00, 2.1842e-01]],\n", + "\n", + " [[-2.1016e-01, 6.6106e-01]],\n", + "\n", + " [[-1.9102e+00, 2.2376e+00]],\n", + "\n", + " [[ 1.4902e+00, 5.7976e-01]],\n", + "\n", + " [[ 7.3127e-01, 2.0128e-01]],\n", + "\n", + " [[ 1.0625e+00, 2.0927e-01]],\n", + "\n", + " [[-1.8610e-01, 5.2047e-01]],\n", + "\n", + " [[-8.8571e-01, 7.6205e-01]],\n", + "\n", + " [[ 1.4154e+00, 7.4857e-01]],\n", + "\n", + " [[-4.7186e-01, 5.8333e-01]],\n", + "\n", + " [[-1.7148e+00, 3.3412e-01]],\n", + "\n", + " [[-1.4517e+00, 1.1454e-01]],\n", + "\n", + " [[ 3.4993e-01, 1.0099e+00]],\n", + "\n", + " [[ 3.4627e+00, 6.4614e-01]],\n", + "\n", + " [[-9.6401e-01, 3.9835e-01]],\n", + "\n", + " [[-1.5042e-01, 1.4647e+00]],\n", + "\n", + " [[-7.3808e-01, 9.0387e-01]],\n", + "\n", + " [[ 2.4873e+00, 1.2093e+00]],\n", + "\n", + " [[ 3.6428e-01, 8.9932e-01]],\n", + "\n", + " [[-1.6012e+00, 1.7323e+00]],\n", + "\n", + " [[-4.6459e+00, 8.4303e-01]],\n", + "\n", + " [[-9.6142e-01, 2.6542e-02]],\n", + "\n", + " [[-2.3127e-01, 3.1195e-02]],\n", + "\n", + " [[-3.9541e-01, 5.1762e-01]],\n", + "\n", + " [[-4.9313e-01, 2.9357e-01]],\n", + "\n", + " [[ 1.8106e+00, 1.2694e+00]],\n", + "\n", + " [[-1.4383e-01, 4.0224e-01]],\n", + "\n", + " [[-8.9369e-01, 4.5588e+00]],\n", + "\n", + " [[ 9.5816e-01, 1.5206e+00]],\n", + "\n", + " [[ 5.0591e-01, 1.2103e-02]],\n", + "\n", + " [[ 1.1310e+00, 4.2767e-02]],\n", + "\n", + " [[ 3.0488e+00, 1.3537e+00]],\n", + "\n", + " [[ 3.7698e-01, 2.0726e-02]],\n", + "\n", + " [[ 4.1209e-01, 1.3263e-01]],\n", + "\n", + " [[-9.1461e-01, 2.2087e-01]],\n", + "\n", + " [[-5.8652e-01, 6.0019e-01]],\n", + "\n", + " [[-1.7825e+00, 4.8262e-01]],\n", + "\n", + " [[-1.6641e-01, 7.2436e-03]],\n", + "\n", + " [[ 1.9753e+00, 3.7159e-01]],\n", + "\n", + " [[ 6.4060e+00, 6.3163e+00]],\n", + "\n", + " [[ 2.2828e+00, 4.9976e-01]],\n", + "\n", + " [[-1.4078e+00, 8.1820e-01]],\n", + "\n", + " [[ 4.4043e+00, 4.5792e+00]],\n", + "\n", + " [[-9.1315e-02, 3.6509e-01]],\n", + "\n", + " [[ 2.1703e+00, 1.7814e-01]],\n", + "\n", + " [[-1.0095e+00, 2.5133e-01]],\n", + "\n", + " [[-5.7946e-01, 3.7011e+00]],\n", + "\n", + " [[-7.2125e-01, 4.8824e-03]],\n", + "\n", + " [[ 1.0205e+00, 4.1178e-01]],\n", + "\n", + " [[ 6.0236e-01, 9.1298e-02]],\n", + "\n", + " [[ 1.5421e+00, 3.6420e-02]],\n", + "\n", + " [[ 3.6283e-01, 8.6650e-03]],\n", + "\n", + " [[-1.7234e+00, 7.3147e-01]],\n", + "\n", + " [[ 1.0088e+00, 8.0022e-03]],\n", + "\n", + " [[ 2.5040e-01, 6.2493e-01]],\n", + "\n", + " [[-2.4028e+00, 3.0449e+00]],\n", + "\n", + " [[ 1.6169e+00, 2.6508e-01]],\n", + "\n", + " [[ 4.7312e-01, 5.8411e-01]],\n", + "\n", + " [[-1.1232e+00, 1.7764e-01]],\n", + "\n", + " [[-7.4328e-01, 6.5708e-03]],\n", + "\n", + " [[-3.8824e+00, 1.4623e+00]],\n", + "\n", + " [[-5.4711e-01, 1.2372e+00]],\n", + "\n", + " [[-7.6820e-01, 7.2073e-01]],\n", + "\n", + " [[ 3.4654e-01, 2.3183e-01]],\n", + "\n", + " [[ 4.6706e-01, 5.3353e-01]],\n", + "\n", + " [[-1.0157e-01, 3.0430e-01]],\n", + "\n", + " [[-1.0344e+00, 3.3588e-02]],\n", + "\n", + " [[-2.1050e+00, 1.0501e+00]],\n", + "\n", + " [[ 1.3984e-01, 2.9698e-02]],\n", + "\n", + " [[-3.1081e+00, 2.2612e-02]],\n", + "\n", + " [[-7.1919e-01, 1.1718e-01]],\n", + "\n", + " [[ 1.8716e+00, 1.1983e+00]],\n", + "\n", + " [[ 1.1281e+01, 1.1809e+01]],\n", + "\n", + " [[ 2.4957e-01, 3.7781e-02]],\n", + "\n", + " [[-7.2574e-01, 6.0051e-01]],\n", + "\n", + " [[-1.2998e+00, 7.6289e-02]],\n", + "\n", + " [[ 7.3121e-01, 1.1117e+00]],\n", + "\n", + " [[-1.2996e+00, 7.7912e-01]],\n", + "\n", + " [[-1.1629e+00, 1.3672e-01]],\n", + "\n", + " [[-1.6305e+00, 8.3529e-01]]], device='mps:0')\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> a\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "input = AffineTransformed()\n", + "target = tensor([[[ 1.1024e+00, 2.1772e+00]],\n", + "\n", + " [[ 3.1114e+00, 1.4761e-01]],\n", + "\n", + " [[ 5.1210e-01, 5.9002e-02]],\n", + "\n", + " [[ 8.3943e-01, 5.8365e-01]],\n", + "\n", + " [[ 5.3114e+00, 4.1811e-01]],\n", + "\n", + " [[-1.6225e+00, 6.3479e-01]],\n", + "\n", + " [[ 1.1662e+00, 5.2098e-01]],\n", + "\n", + " [[-1.3431e+00, 9.0591e-02]],\n", + "\n", + " [[ 1.7831e+00, 4.8382e-01]],\n", + "\n", + " [[-7.7729e-01, 6.5439e-02]],\n", + "\n", + " [[-1.8917e-01, 2.5169e-01]],\n", + "\n", + " [[ 2.7472e-01, 6.9801e-03]],\n", + "\n", + " [[ 6.9222e-01, 3.7090e-01]],\n", + "\n", + " [[-1.3887e-01, 1.0465e-01]],\n", + "\n", + " [[ 4.6390e-02, 1.2863e+00]],\n", + "\n", + " [[ 5.9043e-01, 8.5441e-02]],\n", + "\n", + " [[-1.3656e-01, 8.3530e-02]],\n", + "\n", + " [[-8.7757e-01, 3.5164e-02]],\n", + "\n", + " [[ 1.3106e+00, 7.1244e-01]],\n", + "\n", + " [[-2.5985e+00, 1.0988e+00]],\n", + "\n", + " [[-1.2188e+00, 5.1509e-01]],\n", + "\n", + " [[-1.3239e+00, 2.3816e-01]],\n", + "\n", + " [[ 1.4020e+00, 1.0593e+00]],\n", + "\n", + " [[ 2.4453e+00, 1.3241e-01]],\n", + "\n", + " [[ 2.0195e+00, 7.1989e-01]],\n", + "\n", + " [[-3.4026e+00, 8.1526e-02]],\n", + "\n", + " [[ 1.6343e+00, 9.8419e-02]],\n", + "\n", + " [[ 5.6068e+00, 9.0171e-01]],\n", + "\n", + " [[-1.8071e-01, 2.7081e-01]],\n", + "\n", + " [[ 2.4005e-01, 2.9633e-01]],\n", + "\n", + " [[-3.8343e-01, 5.0071e-01]],\n", + "\n", + " [[-9.0314e-01, 1.1513e-02]],\n", + "\n", + " [[ 1.5037e+00, 2.7778e-02]],\n", + "\n", + " [[ 1.0208e+00, 6.7165e-01]],\n", + "\n", + " [[ 1.3749e+00, 1.1315e+00]],\n", + "\n", + " [[ 1.2911e+00, 5.3599e-01]],\n", + "\n", + " [[ 1.2694e+00, 5.7475e-01]],\n", + "\n", + " [[ 2.8926e+00, 2.3275e+00]],\n", + "\n", + " [[ 2.4626e+00, 8.1767e-02]],\n", + "\n", + " [[-1.5631e+00, 6.3914e-01]],\n", + "\n", + " [[ 3.9286e-01, 6.4463e-01]],\n", + "\n", + " [[-1.1152e+00, 2.1564e-01]],\n", + "\n", + " [[-1.7656e+00, 1.0368e+00]],\n", + "\n", + " [[ 1.0209e+00, 9.9602e-02]],\n", + "\n", + " [[ 9.5942e-01, 1.2126e-01]],\n", + "\n", + " [[-1.6891e+00, 1.9165e+00]],\n", + "\n", + " [[-1.5118e+00, 4.6190e-01]],\n", + "\n", + " [[-5.5326e-01, 1.4059e-01]],\n", + "\n", + " [[-4.1279e+00, 4.0986e+00]],\n", + "\n", + " [[-6.9195e-01, 3.0321e-02]],\n", + "\n", + " [[ 1.7902e+00, 4.2824e-01]],\n", + "\n", + " [[ 5.2053e-01, 4.3660e-01]],\n", + "\n", + " [[ 6.0946e-01, 4.1516e-02]],\n", + "\n", + " [[ 1.2655e+00, 4.1619e-02]],\n", + "\n", + " [[ 8.7225e-01, 1.2361e+00]],\n", + "\n", + " [[-1.0917e+00, 1.2601e-01]],\n", + "\n", + " [[-1.8421e+00, 6.1246e-01]],\n", + "\n", + " [[-1.4119e+00, 1.8471e-01]],\n", + "\n", + " [[ 7.5096e-01, 1.3828e-01]],\n", + "\n", + " [[ 7.5388e-01, 6.3323e-01]],\n", + "\n", + " [[-8.0983e-01, 4.6502e-01]],\n", + "\n", + " [[-9.5473e-01, 3.6264e-02]],\n", + "\n", + " [[ 2.0553e+00, 8.7919e-02]],\n", + "\n", + " [[ 1.9877e+00, 3.5492e-01]],\n", + "\n", + " [[ 8.6919e-01, 1.0212e+00]],\n", + "\n", + " [[-6.2295e-01, 2.3214e+00]],\n", + "\n", + " [[-2.6674e+00, 1.0343e+00]],\n", + "\n", + " [[-6.3484e-01, 3.3307e-01]],\n", + "\n", + " [[ 3.3079e-01, 7.9936e-01]],\n", + "\n", + " [[ 1.5918e+00, 3.4539e-01]],\n", + "\n", + " [[ 9.4901e-01, 4.6944e-01]],\n", + "\n", + " [[-6.0613e+00, 4.9916e-01]],\n", + "\n", + " [[ 3.2753e+00, 2.2067e-01]],\n", + "\n", + " [[-2.3711e-02, 2.3646e-02]],\n", + "\n", + " [[ 2.6951e+00, 1.0527e-01]],\n", + "\n", + " [[ 5.4559e-01, 9.4711e-01]],\n", + "\n", + " [[-1.7149e+00, 4.6982e-02]],\n", + "\n", + " [[-1.9816e+00, 2.8419e-01]],\n", + "\n", + " [[-4.7207e-01, 5.7125e-01]],\n", + "\n", + " [[-9.0168e-01, 4.4606e+00]],\n", + "\n", + " [[-1.2876e+00, 3.5587e-01]],\n", + "\n", + " [[-1.0693e+00, 8.3030e-01]],\n", + "\n", + " [[-6.3592e-01, 2.6855e-01]],\n", + "\n", + " [[ 1.2398e+00, 3.6354e-01]],\n", + "\n", + " [[ 4.1649e+00, 2.3013e-01]],\n", + "\n", + " [[-9.5462e-01, 8.9883e-01]],\n", + "\n", + " [[-1.1604e+00, 1.6950e+00]],\n", + "\n", + " [[ 5.4592e-01, 5.7514e-01]],\n", + "\n", + " [[-1.9890e+00, 2.5985e-02]],\n", + "\n", + " [[-8.1254e-02, 8.6954e-01]],\n", + "\n", + " [[ 1.5071e+00, 3.6005e-02]],\n", + "\n", + " [[-1.6764e+00, 1.5400e+00]],\n", + "\n", + " [[-1.2338e+00, 8.0539e-01]],\n", + "\n", + " [[ 1.4445e+00, 1.1139e+00]],\n", + "\n", + " [[-1.1509e+00, 3.3666e-02]],\n", + "\n", + " [[-1.8596e+00, 1.4816e+00]],\n", + "\n", + " [[-1.0785e+00, 2.5688e-01]],\n", + "\n", + " [[ 1.6757e+00, 9.5609e-01]],\n", + "\n", + " [[-2.2549e+00, 1.9800e-01]],\n", + "\n", + " [[-5.5405e-01, 5.3391e-02]],\n", + "\n", + " [[ 2.1346e+00, 1.1595e-01]],\n", + "\n", + " [[ 1.9951e+00, 5.7987e-01]],\n", + "\n", + " [[ 1.8418e+00, 4.3986e-02]],\n", + "\n", + " [[ 1.6234e+00, 9.6446e-02]],\n", + "\n", + " [[-1.6102e+00, 2.7045e-01]],\n", + "\n", + " [[ 1.4274e+00, 6.1829e-01]],\n", + "\n", + " [[-5.6748e+00, 6.3902e-01]],\n", + "\n", + " [[-6.2886e-01, 1.9538e-02]],\n", + "\n", + " [[ 7.9869e-01, 2.3074e-01]],\n", + "\n", + " [[ 9.2092e-01, 2.1942e-01]],\n", + "\n", + " [[-4.6721e-01, 8.3395e-01]],\n", + "\n", + " [[ 2.0355e+00, 8.5064e-01]],\n", + "\n", + " [[ 8.9913e-01, 7.5951e-01]],\n", + "\n", + " [[-2.7477e-01, 3.9971e-01]],\n", + "\n", + " [[-3.8438e-01, 4.3787e-01]],\n", + "\n", + " [[-9.7013e-01, 1.4910e-02]],\n", + "\n", + " [[ 0.0000e+00, 5.0362e-01]],\n", + "\n", + " [[-8.8448e-01, 2.0029e-02]],\n", + "\n", + " [[-1.5440e+00, 4.2479e-01]],\n", + "\n", + " [[-1.3420e+00, 5.0892e-01]],\n", + "\n", + " [[ 1.2490e+00, 1.2384e-01]],\n", + "\n", + " [[ 2.7104e-01, 7.2835e-01]],\n", + "\n", + " [[ 1.1307e+00, 2.1698e-01]],\n", + "\n", + " [[-2.7158e+00, 2.7090e-01]],\n", + "\n", + " [[ 1.3331e-01, 7.0168e-01]],\n", + "\n", + " [[-3.1136e-01, 1.2778e-01]],\n", + "\n", + " [[-2.4204e+00, 1.9048e+00]],\n", + "\n", + " [[ 1.2353e+00, 8.5247e-01]],\n", + "\n", + " [[ 1.6095e+00, 7.0575e-02]],\n", + "\n", + " [[ 1.8635e+00, 1.3286e-01]],\n", + "\n", + " [[-2.7786e+00, 1.5485e-01]],\n", + "\n", + " [[ 2.7737e+00, 4.8957e-01]],\n", + "\n", + " [[-1.0635e+00, 3.1708e-02]],\n", + "\n", + " [[ 1.0200e+00, 1.0079e+00]],\n", + "\n", + " [[ 1.9060e+00, 1.1648e+00]],\n", + "\n", + " [[ 1.5797e-01, 4.8752e-01]],\n", + "\n", + " [[-2.1180e+00, 4.8782e-02]],\n", + "\n", + " [[-1.1888e+00, 1.1213e-01]],\n", + "\n", + " [[ 1.4036e+00, 9.9856e-01]],\n", + "\n", + " [[-1.0528e+00, 3.1561e-01]],\n", + "\n", + " [[-8.6944e-01, 5.6845e-01]],\n", + "\n", + " [[-2.4489e-01, 1.3948e-01]],\n", + "\n", + " [[ 5.3694e-02, 2.6923e-02]],\n", + "\n", + " [[ 2.4262e-03, 9.9519e-01]],\n", + "\n", + " [[-4.3507e-01, 2.0629e-01]],\n", + "\n", + " [[ 2.0605e+00, 6.1358e-01]],\n", + "\n", + " [[-4.6746e-03, 3.7380e-02]],\n", + "\n", + " [[ 1.9408e+00, 5.9027e-01]],\n", + "\n", + " [[ 1.7764e+00, 1.0740e+00]],\n", + "\n", + " [[-7.0619e-01, 1.4737e-01]],\n", + "\n", + " [[ 1.1451e-02, 5.5008e-01]],\n", + "\n", + " [[-1.0181e+00, 1.0348e+00]],\n", + "\n", + " [[-1.6197e+00, 3.1487e-01]],\n", + "\n", + " [[ 4.8850e+00, 4.4070e-02]],\n", + "\n", + " [[-4.7306e-01, 4.9577e-01]],\n", + "\n", + " [[ 5.9147e-01, 2.3433e+00]],\n", + "\n", + " [[-9.7199e-01, 4.3866e-01]],\n", + "\n", + " [[-2.4535e-01, 8.0271e-01]],\n", + "\n", + " [[-2.1219e+00, 4.2241e-01]],\n", + "\n", + " [[-1.2498e+00, 4.4761e-01]],\n", + "\n", + " [[ 1.2211e+00, 7.1118e-01]],\n", + "\n", + " [[ 6.5318e-01, 4.5337e-01]],\n", + "\n", + " [[ 1.4503e+00, 1.9720e+00]],\n", + "\n", + " [[ 1.4902e+00, 5.0134e-01]],\n", + "\n", + " [[-1.1631e+00, 4.7067e-01]],\n", + "\n", + " [[ 1.3901e+00, 6.2422e-01]],\n", + "\n", + " [[ 1.5011e+00, 2.9010e-01]],\n", + "\n", + " [[-4.2914e-01, 1.7334e-01]],\n", + "\n", + " [[ 2.0530e+00, 3.9742e-01]],\n", + "\n", + " [[ 6.8354e-01, 3.1415e-01]],\n", + "\n", + " [[-5.0541e-01, 3.0867e-01]],\n", + "\n", + " [[ 1.7083e+00, 8.9153e-01]],\n", + "\n", + " [[-8.4340e-01, 7.5098e-01]],\n", + "\n", + " [[ 5.2955e-01, 3.8706e-01]],\n", + "\n", + " [[ 6.8385e-01, 4.3816e-02]],\n", + "\n", + " [[ 2.2052e+00, 3.8353e-01]],\n", + "\n", + " [[ 1.9340e+00, 2.1842e-01]],\n", + "\n", + " [[-2.1016e-01, 6.6106e-01]],\n", + "\n", + " [[-1.9102e+00, 2.2376e+00]],\n", + "\n", + " [[ 1.4902e+00, 5.7976e-01]],\n", + "\n", + " [[ 7.3127e-01, 2.0128e-01]],\n", + "\n", + " [[ 1.0625e+00, 2.0927e-01]],\n", + "\n", + " [[-1.8610e-01, 5.2047e-01]],\n", + "\n", + " [[-8.8571e-01, 7.6205e-01]],\n", + "\n", + " [[ 1.4154e+00, 7.4857e-01]],\n", + "\n", + " [[-4.7186e-01, 5.8333e-01]],\n", + "\n", + " [[-1.7148e+00, 3.3412e-01]],\n", + "\n", + " [[-1.4517e+00, 1.1454e-01]],\n", + "\n", + " [[ 3.4993e-01, 1.0099e+00]],\n", + "\n", + " [[ 3.4627e+00, 6.4614e-01]],\n", + "\n", + " [[-9.6401e-01, 3.9835e-01]],\n", + "\n", + " [[-1.5042e-01, 1.4647e+00]],\n", + "\n", + " [[-7.3808e-01, 9.0387e-01]],\n", + "\n", + " [[ 2.4873e+00, 1.2093e+00]],\n", + "\n", + " [[ 3.6428e-01, 8.9932e-01]],\n", + "\n", + " [[-1.6012e+00, 1.7323e+00]],\n", + "\n", + " [[-4.6459e+00, 8.4303e-01]],\n", + "\n", + " [[-9.6142e-01, 2.6542e-02]],\n", + "\n", + " [[-2.3127e-01, 3.1195e-02]],\n", + "\n", + " [[-3.9541e-01, 5.1762e-01]],\n", + "\n", + " [[-4.9313e-01, 2.9357e-01]],\n", + "\n", + " [[ 1.8106e+00, 1.2694e+00]],\n", + "\n", + " [[-1.4383e-01, 4.0224e-01]],\n", + "\n", + " [[-8.9369e-01, 4.5588e+00]],\n", + "\n", + " [[ 9.5816e-01, 1.5206e+00]],\n", + "\n", + " [[ 5.0591e-01, 1.2103e-02]],\n", + "\n", + " [[ 1.1310e+00, 4.2767e-02]],\n", + "\n", + " [[ 3.0488e+00, 1.3537e+00]],\n", + "\n", + " [[ 3.7698e-01, 2.0726e-02]],\n", + "\n", + " [[ 4.1209e-01, 1.3263e-01]],\n", + "\n", + " [[-9.1461e-01, 2.2087e-01]],\n", + "\n", + " [[-5.8652e-01, 6.0019e-01]],\n", + "\n", + " [[-1.7825e+00, 4.8262e-01]],\n", + "\n", + " [[-1.6641e-01, 7.2436e-03]],\n", + "\n", + " [[ 1.9753e+00, 3.7159e-01]],\n", + "\n", + " [[ 6.4060e+00, 6.3163e+00]],\n", + "\n", + " [[ 2.2828e+00, 4.9976e-01]],\n", + "\n", + " [[-1.4078e+00, 8.1820e-01]],\n", + "\n", + " [[ 4.4043e+00, 4.5792e+00]],\n", + "\n", + " [[-9.1315e-02, 3.6509e-01]],\n", + "\n", + " [[ 2.1703e+00, 1.7814e-01]],\n", + "\n", + " [[-1.0095e+00, 2.5133e-01]],\n", + "\n", + " [[-5.7946e-01, 3.7011e+00]],\n", + "\n", + " [[-7.2125e-01, 4.8824e-03]],\n", + "\n", + " [[ 1.0205e+00, 4.1178e-01]],\n", + "\n", + " [[ 6.0236e-01, 9.1298e-02]],\n", + "\n", + " [[ 1.5421e+00, 3.6420e-02]],\n", + "\n", + " [[ 3.6283e-01, 8.6650e-03]],\n", + "\n", + " [[-1.7234e+00, 7.3147e-01]],\n", + "\n", + " [[ 1.0088e+00, 8.0022e-03]],\n", + "\n", + " [[ 2.5040e-01, 6.2493e-01]],\n", + "\n", + " [[-2.4028e+00, 3.0449e+00]],\n", + "\n", + " [[ 1.6169e+00, 2.6508e-01]],\n", + "\n", + " [[ 4.7312e-01, 5.8411e-01]],\n", + "\n", + " [[-1.1232e+00, 1.7764e-01]],\n", + "\n", + " [[-7.4328e-01, 6.5708e-03]],\n", + "\n", + " [[-3.8824e+00, 1.4623e+00]],\n", + "\n", + " [[-5.4711e-01, 1.2372e+00]],\n", + "\n", + " [[-7.6820e-01, 7.2073e-01]],\n", + "\n", + " [[ 3.4654e-01, 2.3183e-01]],\n", + "\n", + " [[ 4.6706e-01, 5.3353e-01]],\n", + "\n", + " [[-1.0157e-01, 3.0430e-01]],\n", + "\n", + " [[-1.0344e+00, 3.3588e-02]],\n", + "\n", + " [[-2.1050e+00, 1.0501e+00]],\n", + "\n", + " [[ 1.3984e-01, 2.9698e-02]],\n", + "\n", + " [[-3.1081e+00, 2.2612e-02]],\n", + "\n", + " [[-7.1919e-01, 1.1718e-01]],\n", + "\n", + " [[ 1.8716e+00, 1.1983e+00]],\n", + "\n", + " [[ 1.1281e+01, 1.1809e+01]],\n", + "\n", + " [[ 2.4957e-01, 3.7781e-02]],\n", + "\n", + " [[-7.2574e-01, 6.0051e-01]],\n", + "\n", + " [[-1.2998e+00, 7.6289e-02]],\n", + "\n", + " [[ 7.3121e-01, 1.1117e+00]],\n", + "\n", + " [[-1.2996e+00, 7.7912e-01]],\n", + "\n", + " [[-1.1629e+00, 1.3672e-01]],\n", + "\n", + " [[-1.6305e+00, 8.3529e-01]]], device='mps:0')\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> a.shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "input = AffineTransformed()\n", + "target = tensor([[[ 1.1024e+00, 2.1772e+00]],\n", + "\n", + " [[ 3.1114e+00, 1.4761e-01]],\n", + "\n", + " [[ 5.1210e-01, 5.9002e-02]],\n", + "\n", + " [[ 8.3943e-01, 5.8365e-01]],\n", + "\n", + " [[ 5.3114e+00, 4.1811e-01]],\n", + "\n", + " [[-1.6225e+00, 6.3479e-01]],\n", + "\n", + " [[ 1.1662e+00, 5.2098e-01]],\n", + "\n", + " [[-1.3431e+00, 9.0591e-02]],\n", + "\n", + " [[ 1.7831e+00, 4.8382e-01]],\n", + "\n", + " [[-7.7729e-01, 6.5439e-02]],\n", + "\n", + " [[-1.8917e-01, 2.5169e-01]],\n", + "\n", + " [[ 2.7472e-01, 6.9801e-03]],\n", + "\n", + " [[ 6.9222e-01, 3.7090e-01]],\n", + "\n", + " [[-1.3887e-01, 1.0465e-01]],\n", + "\n", + " [[ 4.6390e-02, 1.2863e+00]],\n", + "\n", + " [[ 5.9043e-01, 8.5441e-02]],\n", + "\n", + " [[-1.3656e-01, 8.3530e-02]],\n", + "\n", + " [[-8.7757e-01, 3.5164e-02]],\n", + "\n", + " [[ 1.3106e+00, 7.1244e-01]],\n", + "\n", + " [[-2.5985e+00, 1.0988e+00]],\n", + "\n", + " [[-1.2188e+00, 5.1509e-01]],\n", + "\n", + " [[-1.3239e+00, 2.3816e-01]],\n", + "\n", + " [[ 1.4020e+00, 1.0593e+00]],\n", + "\n", + " [[ 2.4453e+00, 1.3241e-01]],\n", + "\n", + " [[ 2.0195e+00, 7.1989e-01]],\n", + "\n", + " [[-3.4026e+00, 8.1526e-02]],\n", + "\n", + " [[ 1.6343e+00, 9.8419e-02]],\n", + "\n", + " [[ 5.6068e+00, 9.0171e-01]],\n", + "\n", + " [[-1.8071e-01, 2.7081e-01]],\n", + "\n", + " [[ 2.4005e-01, 2.9633e-01]],\n", + "\n", + " [[-3.8343e-01, 5.0071e-01]],\n", + "\n", + " [[-9.0314e-01, 1.1513e-02]],\n", + "\n", + " [[ 1.5037e+00, 2.7778e-02]],\n", + "\n", + " [[ 1.0208e+00, 6.7165e-01]],\n", + "\n", + " [[ 1.3749e+00, 1.1315e+00]],\n", + "\n", + " [[ 1.2911e+00, 5.3599e-01]],\n", + "\n", + " [[ 1.2694e+00, 5.7475e-01]],\n", + "\n", + " [[ 2.8926e+00, 2.3275e+00]],\n", + "\n", + " [[ 2.4626e+00, 8.1767e-02]],\n", + "\n", + " [[-1.5631e+00, 6.3914e-01]],\n", + "\n", + " [[ 3.9286e-01, 6.4463e-01]],\n", + "\n", + " [[-1.1152e+00, 2.1564e-01]],\n", + "\n", + " [[-1.7656e+00, 1.0368e+00]],\n", + "\n", + " [[ 1.0209e+00, 9.9602e-02]],\n", + "\n", + " [[ 9.5942e-01, 1.2126e-01]],\n", + "\n", + " [[-1.6891e+00, 1.9165e+00]],\n", + "\n", + " [[-1.5118e+00, 4.6190e-01]],\n", + "\n", + " [[-5.5326e-01, 1.4059e-01]],\n", + "\n", + " [[-4.1279e+00, 4.0986e+00]],\n", + "\n", + " [[-6.9195e-01, 3.0321e-02]],\n", + "\n", + " [[ 1.7902e+00, 4.2824e-01]],\n", + "\n", + " [[ 5.2053e-01, 4.3660e-01]],\n", + "\n", + " [[ 6.0946e-01, 4.1516e-02]],\n", + "\n", + " [[ 1.2655e+00, 4.1619e-02]],\n", + "\n", + " [[ 8.7225e-01, 1.2361e+00]],\n", + "\n", + " [[-1.0917e+00, 1.2601e-01]],\n", + "\n", + " [[-1.8421e+00, 6.1246e-01]],\n", + "\n", + " [[-1.4119e+00, 1.8471e-01]],\n", + "\n", + " [[ 7.5096e-01, 1.3828e-01]],\n", + "\n", + " [[ 7.5388e-01, 6.3323e-01]],\n", + "\n", + " [[-8.0983e-01, 4.6502e-01]],\n", + "\n", + " [[-9.5473e-01, 3.6264e-02]],\n", + "\n", + " [[ 2.0553e+00, 8.7919e-02]],\n", + "\n", + " [[ 1.9877e+00, 3.5492e-01]],\n", + "\n", + " [[ 8.6919e-01, 1.0212e+00]],\n", + "\n", + " [[-6.2295e-01, 2.3214e+00]],\n", + "\n", + " [[-2.6674e+00, 1.0343e+00]],\n", + "\n", + " [[-6.3484e-01, 3.3307e-01]],\n", + "\n", + " [[ 3.3079e-01, 7.9936e-01]],\n", + "\n", + " [[ 1.5918e+00, 3.4539e-01]],\n", + "\n", + " [[ 9.4901e-01, 4.6944e-01]],\n", + "\n", + " [[-6.0613e+00, 4.9916e-01]],\n", + "\n", + " [[ 3.2753e+00, 2.2067e-01]],\n", + "\n", + " [[-2.3711e-02, 2.3646e-02]],\n", + "\n", + " [[ 2.6951e+00, 1.0527e-01]],\n", + "\n", + " [[ 5.4559e-01, 9.4711e-01]],\n", + "\n", + " [[-1.7149e+00, 4.6982e-02]],\n", + "\n", + " [[-1.9816e+00, 2.8419e-01]],\n", + "\n", + " [[-4.7207e-01, 5.7125e-01]],\n", + "\n", + " [[-9.0168e-01, 4.4606e+00]],\n", + "\n", + " [[-1.2876e+00, 3.5587e-01]],\n", + "\n", + " [[-1.0693e+00, 8.3030e-01]],\n", + "\n", + " [[-6.3592e-01, 2.6855e-01]],\n", + "\n", + " [[ 1.2398e+00, 3.6354e-01]],\n", + "\n", + " [[ 4.1649e+00, 2.3013e-01]],\n", + "\n", + " [[-9.5462e-01, 8.9883e-01]],\n", + "\n", + " [[-1.1604e+00, 1.6950e+00]],\n", + "\n", + " [[ 5.4592e-01, 5.7514e-01]],\n", + "\n", + " [[-1.9890e+00, 2.5985e-02]],\n", + "\n", + " [[-8.1254e-02, 8.6954e-01]],\n", + "\n", + " [[ 1.5071e+00, 3.6005e-02]],\n", + "\n", + " [[-1.6764e+00, 1.5400e+00]],\n", + "\n", + " [[-1.2338e+00, 8.0539e-01]],\n", + "\n", + " [[ 1.4445e+00, 1.1139e+00]],\n", + "\n", + " [[-1.1509e+00, 3.3666e-02]],\n", + "\n", + " [[-1.8596e+00, 1.4816e+00]],\n", + "\n", + " [[-1.0785e+00, 2.5688e-01]],\n", + "\n", + " [[ 1.6757e+00, 9.5609e-01]],\n", + "\n", + " [[-2.2549e+00, 1.9800e-01]],\n", + "\n", + " [[-5.5405e-01, 5.3391e-02]],\n", + "\n", + " [[ 2.1346e+00, 1.1595e-01]],\n", + "\n", + " [[ 1.9951e+00, 5.7987e-01]],\n", + "\n", + " [[ 1.8418e+00, 4.3986e-02]],\n", + "\n", + " [[ 1.6234e+00, 9.6446e-02]],\n", + "\n", + " [[-1.6102e+00, 2.7045e-01]],\n", + "\n", + " [[ 1.4274e+00, 6.1829e-01]],\n", + "\n", + " [[-5.6748e+00, 6.3902e-01]],\n", + "\n", + " [[-6.2886e-01, 1.9538e-02]],\n", + "\n", + " [[ 7.9869e-01, 2.3074e-01]],\n", + "\n", + " [[ 9.2092e-01, 2.1942e-01]],\n", + "\n", + " [[-4.6721e-01, 8.3395e-01]],\n", + "\n", + " [[ 2.0355e+00, 8.5064e-01]],\n", + "\n", + " [[ 8.9913e-01, 7.5951e-01]],\n", + "\n", + " [[-2.7477e-01, 3.9971e-01]],\n", + "\n", + " [[-3.8438e-01, 4.3787e-01]],\n", + "\n", + " [[-9.7013e-01, 1.4910e-02]],\n", + "\n", + " [[ 0.0000e+00, 5.0362e-01]],\n", + "\n", + " [[-8.8448e-01, 2.0029e-02]],\n", + "\n", + " [[-1.5440e+00, 4.2479e-01]],\n", + "\n", + " [[-1.3420e+00, 5.0892e-01]],\n", + "\n", + " [[ 1.2490e+00, 1.2384e-01]],\n", + "\n", + " [[ 2.7104e-01, 7.2835e-01]],\n", + "\n", + " [[ 1.1307e+00, 2.1698e-01]],\n", + "\n", + " [[-2.7158e+00, 2.7090e-01]],\n", + "\n", + " [[ 1.3331e-01, 7.0168e-01]],\n", + "\n", + " [[-3.1136e-01, 1.2778e-01]],\n", + "\n", + " [[-2.4204e+00, 1.9048e+00]],\n", + "\n", + " [[ 1.2353e+00, 8.5247e-01]],\n", + "\n", + " [[ 1.6095e+00, 7.0575e-02]],\n", + "\n", + " [[ 1.8635e+00, 1.3286e-01]],\n", + "\n", + " [[-2.7786e+00, 1.5485e-01]],\n", + "\n", + " [[ 2.7737e+00, 4.8957e-01]],\n", + "\n", + " [[-1.0635e+00, 3.1708e-02]],\n", + "\n", + " [[ 1.0200e+00, 1.0079e+00]],\n", + "\n", + " [[ 1.9060e+00, 1.1648e+00]],\n", + "\n", + " [[ 1.5797e-01, 4.8752e-01]],\n", + "\n", + " [[-2.1180e+00, 4.8782e-02]],\n", + "\n", + " [[-1.1888e+00, 1.1213e-01]],\n", + "\n", + " [[ 1.4036e+00, 9.9856e-01]],\n", + "\n", + " [[-1.0528e+00, 3.1561e-01]],\n", + "\n", + " [[-8.6944e-01, 5.6845e-01]],\n", + "\n", + " [[-2.4489e-01, 1.3948e-01]],\n", + "\n", + " [[ 5.3694e-02, 2.6923e-02]],\n", + "\n", + " [[ 2.4262e-03, 9.9519e-01]],\n", + "\n", + " [[-4.3507e-01, 2.0629e-01]],\n", + "\n", + " [[ 2.0605e+00, 6.1358e-01]],\n", + "\n", + " [[-4.6746e-03, 3.7380e-02]],\n", + "\n", + " [[ 1.9408e+00, 5.9027e-01]],\n", + "\n", + " [[ 1.7764e+00, 1.0740e+00]],\n", + "\n", + " [[-7.0619e-01, 1.4737e-01]],\n", + "\n", + " [[ 1.1451e-02, 5.5008e-01]],\n", + "\n", + " [[-1.0181e+00, 1.0348e+00]],\n", + "\n", + " [[-1.6197e+00, 3.1487e-01]],\n", + "\n", + " [[ 4.8850e+00, 4.4070e-02]],\n", + "\n", + " [[-4.7306e-01, 4.9577e-01]],\n", + "\n", + " [[ 5.9147e-01, 2.3433e+00]],\n", + "\n", + " [[-9.7199e-01, 4.3866e-01]],\n", + "\n", + " [[-2.4535e-01, 8.0271e-01]],\n", + "\n", + " [[-2.1219e+00, 4.2241e-01]],\n", + "\n", + " [[-1.2498e+00, 4.4761e-01]],\n", + "\n", + " [[ 1.2211e+00, 7.1118e-01]],\n", + "\n", + " [[ 6.5318e-01, 4.5337e-01]],\n", + "\n", + " [[ 1.4503e+00, 1.9720e+00]],\n", + "\n", + " [[ 1.4902e+00, 5.0134e-01]],\n", + "\n", + " [[-1.1631e+00, 4.7067e-01]],\n", + "\n", + " [[ 1.3901e+00, 6.2422e-01]],\n", + "\n", + " [[ 1.5011e+00, 2.9010e-01]],\n", + "\n", + " [[-4.2914e-01, 1.7334e-01]],\n", + "\n", + " [[ 2.0530e+00, 3.9742e-01]],\n", + "\n", + " [[ 6.8354e-01, 3.1415e-01]],\n", + "\n", + " [[-5.0541e-01, 3.0867e-01]],\n", + "\n", + " [[ 1.7083e+00, 8.9153e-01]],\n", + "\n", + " [[-8.4340e-01, 7.5098e-01]],\n", + "\n", + " [[ 5.2955e-01, 3.8706e-01]],\n", + "\n", + " [[ 6.8385e-01, 4.3816e-02]],\n", + "\n", + " [[ 2.2052e+00, 3.8353e-01]],\n", + "\n", + " [[ 1.9340e+00, 2.1842e-01]],\n", + "\n", + " [[-2.1016e-01, 6.6106e-01]],\n", + "\n", + " [[-1.9102e+00, 2.2376e+00]],\n", + "\n", + " [[ 1.4902e+00, 5.7976e-01]],\n", + "\n", + " [[ 7.3127e-01, 2.0128e-01]],\n", + "\n", + " [[ 1.0625e+00, 2.0927e-01]],\n", + "\n", + " [[-1.8610e-01, 5.2047e-01]],\n", + "\n", + " [[-8.8571e-01, 7.6205e-01]],\n", + "\n", + " [[ 1.4154e+00, 7.4857e-01]],\n", + "\n", + " [[-4.7186e-01, 5.8333e-01]],\n", + "\n", + " [[-1.7148e+00, 3.3412e-01]],\n", + "\n", + " [[-1.4517e+00, 1.1454e-01]],\n", + "\n", + " [[ 3.4993e-01, 1.0099e+00]],\n", + "\n", + " [[ 3.4627e+00, 6.4614e-01]],\n", + "\n", + " [[-9.6401e-01, 3.9835e-01]],\n", + "\n", + " [[-1.5042e-01, 1.4647e+00]],\n", + "\n", + " [[-7.3808e-01, 9.0387e-01]],\n", + "\n", + " [[ 2.4873e+00, 1.2093e+00]],\n", + "\n", + " [[ 3.6428e-01, 8.9932e-01]],\n", + "\n", + " [[-1.6012e+00, 1.7323e+00]],\n", + "\n", + " [[-4.6459e+00, 8.4303e-01]],\n", + "\n", + " [[-9.6142e-01, 2.6542e-02]],\n", + "\n", + " [[-2.3127e-01, 3.1195e-02]],\n", + "\n", + " [[-3.9541e-01, 5.1762e-01]],\n", + "\n", + " [[-4.9313e-01, 2.9357e-01]],\n", + "\n", + " [[ 1.8106e+00, 1.2694e+00]],\n", + "\n", + " [[-1.4383e-01, 4.0224e-01]],\n", + "\n", + " [[-8.9369e-01, 4.5588e+00]],\n", + "\n", + " [[ 9.5816e-01, 1.5206e+00]],\n", + "\n", + " [[ 5.0591e-01, 1.2103e-02]],\n", + "\n", + " [[ 1.1310e+00, 4.2767e-02]],\n", + "\n", + " [[ 3.0488e+00, 1.3537e+00]],\n", + "\n", + " [[ 3.7698e-01, 2.0726e-02]],\n", + "\n", + " [[ 4.1209e-01, 1.3263e-01]],\n", + "\n", + " [[-9.1461e-01, 2.2087e-01]],\n", + "\n", + " [[-5.8652e-01, 6.0019e-01]],\n", + "\n", + " [[-1.7825e+00, 4.8262e-01]],\n", + "\n", + " [[-1.6641e-01, 7.2436e-03]],\n", + "\n", + " [[ 1.9753e+00, 3.7159e-01]],\n", + "\n", + " [[ 6.4060e+00, 6.3163e+00]],\n", + "\n", + " [[ 2.2828e+00, 4.9976e-01]],\n", + "\n", + " [[-1.4078e+00, 8.1820e-01]],\n", + "\n", + " [[ 4.4043e+00, 4.5792e+00]],\n", + "\n", + " [[-9.1315e-02, 3.6509e-01]],\n", + "\n", + " [[ 2.1703e+00, 1.7814e-01]],\n", + "\n", + " [[-1.0095e+00, 2.5133e-01]],\n", + "\n", + " [[-5.7946e-01, 3.7011e+00]],\n", + "\n", + " [[-7.2125e-01, 4.8824e-03]],\n", + "\n", + " [[ 1.0205e+00, 4.1178e-01]],\n", + "\n", + " [[ 6.0236e-01, 9.1298e-02]],\n", + "\n", + " [[ 1.5421e+00, 3.6420e-02]],\n", + "\n", + " [[ 3.6283e-01, 8.6650e-03]],\n", + "\n", + " [[-1.7234e+00, 7.3147e-01]],\n", + "\n", + " [[ 1.0088e+00, 8.0022e-03]],\n", + "\n", + " [[ 2.5040e-01, 6.2493e-01]],\n", + "\n", + " [[-2.4028e+00, 3.0449e+00]],\n", + "\n", + " [[ 1.6169e+00, 2.6508e-01]],\n", + "\n", + " [[ 4.7312e-01, 5.8411e-01]],\n", + "\n", + " [[-1.1232e+00, 1.7764e-01]],\n", + "\n", + " [[-7.4328e-01, 6.5708e-03]],\n", + "\n", + " [[-3.8824e+00, 1.4623e+00]],\n", + "\n", + " [[-5.4711e-01, 1.2372e+00]],\n", + "\n", + " [[-7.6820e-01, 7.2073e-01]],\n", + "\n", + " [[ 3.4654e-01, 2.3183e-01]],\n", + "\n", + " [[ 4.6706e-01, 5.3353e-01]],\n", + "\n", + " [[-1.0157e-01, 3.0430e-01]],\n", + "\n", + " [[-1.0344e+00, 3.3588e-02]],\n", + "\n", + " [[-2.1050e+00, 1.0501e+00]],\n", + "\n", + " [[ 1.3984e-01, 2.9698e-02]],\n", + "\n", + " [[-3.1081e+00, 2.2612e-02]],\n", + "\n", + " [[-7.1919e-01, 1.1718e-01]],\n", + "\n", + " [[ 1.8716e+00, 1.1983e+00]],\n", + "\n", + " [[ 1.1281e+01, 1.1809e+01]],\n", + "\n", + " [[ 2.4957e-01, 3.7781e-02]],\n", + "\n", + " [[-7.2574e-01, 6.0051e-01]],\n", + "\n", + " [[-1.2998e+00, 7.6289e-02]],\n", + "\n", + " [[ 7.3121e-01, 1.1117e+00]],\n", + "\n", + " [[-1.2996e+00, 7.7912e-01]],\n", + "\n", + " [[-1.1629e+00, 1.3672e-01]],\n", + "\n", + " [[-1.6305e+00, 8.3529e-01]]], device='mps:0')\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> plt.hist(a[:,0,0,0])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "*** NameError: name 'a' is not defined\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> input.sample(sample_shape=[100]).shape\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([100, 256, 1, 2])\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> plt.hist(input.sample(sample_shape=[100])[:,0,0,0])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "*** TypeError: can't convert mps:0 device type tensor to numpy. Use Tensor.cpu() to copy the tensor to host memory first.\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> plt.hist(input.sample(sample_shape=[100])[:,0,0,0].cpu())\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(array([ 1., 1., 2., 3., 15., 25., 28., 17., 6., 2.]), array([-6.48046589, -5.47704315, -4.47361994, -3.4701972 , -2.46677446,\n", + " -1.46335149, -0.4599286 , 0.54349428, 1.5469172 , 2.55033994,\n", + " 3.55376291]), )\n" + ] + }, + { + "name": "stdin", + "output_type": "stream", + "text": [ + "ipdb> q\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%debug" + ] + }, + { + "cell_type": "code", + "execution_count": 17, "id": "a7a8e896-db33-4012-98c8-dc5edce22917", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -444,7 +6129,15 @@ }, { "cell_type": "code", - "execution_count": 142, + "execution_count": null, + "id": "45586f20-f829-4e0d-9d17-606c52f74051", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 18, "id": "9bc2afe6-4c6a-45f1-a372-92b28a265e2f", "metadata": {}, "outputs": [], @@ -462,7 +6155,7 @@ }, { "cell_type": "code", - "execution_count": 143, + "execution_count": 19, "id": "9b37a0c2-677f-42b9-9d70-f8c0350fc55f", "metadata": {}, "outputs": [], @@ -491,7 +6184,7 @@ }, { "cell_type": "code", - "execution_count": 144, + "execution_count": 20, "id": "23c20108-72e7-4205-9778-c9ff822af3a6", "metadata": {}, "outputs": [], @@ -524,7 +6217,7 @@ }, { "cell_type": "code", - "execution_count": 145, + "execution_count": 21, "id": "1ec18103-4aec-462f-9e87-bc5ed72b747b", "metadata": {}, "outputs": [], @@ -535,7 +6228,7 @@ }, { "cell_type": "code", - "execution_count": 146, + "execution_count": 22, "id": "6ac87b5b-90fe-49ea-8b72-5c8519abb6dd", "metadata": {}, "outputs": [ @@ -546,13 +6239,13 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[146], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m model\u001b[38;5;241m.\u001b[39meval()\n\u001b[0;32m----> 3\u001b[0m forecasts \u001b[38;5;241m=\u001b[39m \u001b[43mget_forecasts\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mval_dataloader\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 4\u001b[0m mase, smape \u001b[38;5;241m=\u001b[39m get_metrics(val_dataset, forecasts)\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mMASE: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmase\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m sMAPE: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00msmape\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n", - "Cell \u001b[0;32mIn[143], line 8\u001b[0m, in \u001b[0;36mget_forecasts\u001b[0;34m(model, val_dataloader)\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mno_grad():\n\u001b[1;32m 6\u001b[0m past_times, future_times, past_values, future_values, past_mask, future_mask, label \u001b[38;5;241m=\u001b[39m batch\n\u001b[0;32m----> 8\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 9\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_time_features\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_times\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 10\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_values\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_values\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 11\u001b[0m \u001b[43m \u001b[49m\u001b[43mfuture_time_features\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfuture_times\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 12\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_observed_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_mask\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 13\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 15\u001b[0m forecasts\u001b[38;5;241m.\u001b[39mappend(outputs\u001b[38;5;241m.\u001b[39msequences\u001b[38;5;241m.\u001b[39mcpu()\u001b[38;5;241m.\u001b[39mnumpy())\n\u001b[1;32m 17\u001b[0m forecasts \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mvstack(forecasts)\n", + "Cell \u001b[0;32mIn[22], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m model\u001b[38;5;241m.\u001b[39meval()\n\u001b[0;32m----> 3\u001b[0m forecasts \u001b[38;5;241m=\u001b[39m \u001b[43mget_forecasts\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mval_dataloader\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 4\u001b[0m mase, smape \u001b[38;5;241m=\u001b[39m get_metrics(val_dataset, forecasts)\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mMASE: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmase\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m sMAPE: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00msmape\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m)\n", + "Cell \u001b[0;32mIn[19], line 8\u001b[0m, in \u001b[0;36mget_forecasts\u001b[0;34m(model, val_dataloader)\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mno_grad():\n\u001b[1;32m 6\u001b[0m past_times, future_times, past_values, future_values, past_mask, future_mask, label \u001b[38;5;241m=\u001b[39m batch\n\u001b[0;32m----> 8\u001b[0m outputs \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgenerate\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 9\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_time_features\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_times\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 10\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_values\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_values\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 11\u001b[0m \u001b[43m \u001b[49m\u001b[43mfuture_time_features\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfuture_times\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 12\u001b[0m \u001b[43m \u001b[49m\u001b[43mpast_observed_mask\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpast_mask\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mto\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdevice\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 13\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 15\u001b[0m forecasts\u001b[38;5;241m.\u001b[39mappend(outputs\u001b[38;5;241m.\u001b[39msequences\u001b[38;5;241m.\u001b[39mcpu()\u001b[38;5;241m.\u001b[39mnumpy())\n\u001b[1;32m 17\u001b[0m forecasts \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mvstack(forecasts)\n", "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/torch/utils/_contextlib.py:115\u001b[0m, in \u001b[0;36mcontext_decorator..decorate_context\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 112\u001b[0m \u001b[38;5;129m@functools\u001b[39m\u001b[38;5;241m.\u001b[39mwraps(func)\n\u001b[1;32m 113\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mdecorate_context\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 114\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m ctx_factory():\n\u001b[0;32m--> 115\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/transformers/models/time_series_transformer/modeling_time_series_transformer.py:1765\u001b[0m, in \u001b[0;36mTimeSeriesTransformerForPrediction.generate\u001b[0;34m(self, past_values, past_time_features, future_time_features, past_observed_mask, static_categorical_features, static_real_features, output_attentions, output_hidden_states)\u001b[0m\n\u001b[1;32m 1762\u001b[0m dec_last_hidden \u001b[38;5;241m=\u001b[39m dec_output\u001b[38;5;241m.\u001b[39mlast_hidden_state\n\u001b[1;32m 1764\u001b[0m params \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparameter_projection(dec_last_hidden[:, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m:])\n\u001b[0;32m-> 1765\u001b[0m distr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moutput_distribution\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mloc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrepeated_loc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrepeated_scale\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1766\u001b[0m next_sample \u001b[38;5;241m=\u001b[39m distr\u001b[38;5;241m.\u001b[39msample()\n\u001b[1;32m 1768\u001b[0m repeated_past_values \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mcat(\n\u001b[1;32m 1769\u001b[0m (repeated_past_values, (next_sample \u001b[38;5;241m-\u001b[39m repeated_loc) \u001b[38;5;241m/\u001b[39m repeated_scale), dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 1770\u001b[0m )\n", - "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/transformers/models/time_series_transformer/modeling_time_series_transformer.py:1477\u001b[0m, in \u001b[0;36mTimeSeriesTransformerForPrediction.output_distribution\u001b[0;34m(self, params, loc, scale, trailing_n)\u001b[0m\n\u001b[1;32m 1475\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m trailing_n \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 1476\u001b[0m sliced_params \u001b[38;5;241m=\u001b[39m [p[:, \u001b[38;5;241m-\u001b[39mtrailing_n:] \u001b[38;5;28;01mfor\u001b[39;00m p \u001b[38;5;129;01min\u001b[39;00m params]\n\u001b[0;32m-> 1477\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdistribution_output\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdistribution\u001b[49m\u001b[43m(\u001b[49m\u001b[43msliced_params\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mloc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mloc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscale\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/transformers/models/time_series_transformer/modeling_time_series_transformer.py:1797\u001b[0m, in \u001b[0;36mTimeSeriesTransformerForPrediction.generate\u001b[0;34m(self, past_values, past_time_features, future_time_features, past_observed_mask, static_categorical_features, static_real_features, output_attentions, output_hidden_states)\u001b[0m\n\u001b[1;32m 1794\u001b[0m dec_last_hidden \u001b[38;5;241m=\u001b[39m dec_output\u001b[38;5;241m.\u001b[39mlast_hidden_state\n\u001b[1;32m 1796\u001b[0m params \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mparameter_projection(dec_last_hidden[:, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m:])\n\u001b[0;32m-> 1797\u001b[0m distr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moutput_distribution\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mloc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrepeated_loc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrepeated_scale\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1798\u001b[0m next_sample \u001b[38;5;241m=\u001b[39m distr\u001b[38;5;241m.\u001b[39msample()\n\u001b[1;32m 1800\u001b[0m repeated_past_values \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mcat(\n\u001b[1;32m 1801\u001b[0m (repeated_past_values, (next_sample \u001b[38;5;241m-\u001b[39m repeated_loc) \u001b[38;5;241m/\u001b[39m repeated_scale), dim\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m\n\u001b[1;32m 1802\u001b[0m )\n", + "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/transformers/models/time_series_transformer/modeling_time_series_transformer.py:1504\u001b[0m, in \u001b[0;36mTimeSeriesTransformerForPrediction.output_distribution\u001b[0;34m(self, params, loc, scale, trailing_n)\u001b[0m\n\u001b[1;32m 1502\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m trailing_n \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 1503\u001b[0m sliced_params \u001b[38;5;241m=\u001b[39m [p[:, \u001b[38;5;241m-\u001b[39mtrailing_n:] \u001b[38;5;28;01mfor\u001b[39;00m p \u001b[38;5;129;01min\u001b[39;00m params]\n\u001b[0;32m-> 1504\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdistribution_output\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdistribution\u001b[49m\u001b[43m(\u001b[49m\u001b[43msliced_params\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mloc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mloc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mscale\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mscale\u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/transformers/time_series_utils.py:108\u001b[0m, in \u001b[0;36mDistributionOutput.distribution\u001b[0;34m(self, distr_args, loc, scale)\u001b[0m\n\u001b[1;32m 102\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mdistribution\u001b[39m(\n\u001b[1;32m 103\u001b[0m \u001b[38;5;28mself\u001b[39m,\n\u001b[1;32m 104\u001b[0m distr_args,\n\u001b[1;32m 105\u001b[0m loc: Optional[torch\u001b[38;5;241m.\u001b[39mTensor] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 106\u001b[0m scale: Optional[torch\u001b[38;5;241m.\u001b[39mTensor] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 107\u001b[0m ) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m Distribution:\n\u001b[0;32m--> 108\u001b[0m distr \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_base_distribution\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdistr_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 109\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m loc \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m scale \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 110\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m distr\n", - "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/transformers/time_series_utils.py:98\u001b[0m, in \u001b[0;36mDistributionOutput._base_distribution\u001b[0;34m(self, distr_args)\u001b[0m\n\u001b[1;32m 96\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_base_distribution\u001b[39m(\u001b[38;5;28mself\u001b[39m, distr_args):\n\u001b[1;32m 97\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdim \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m---> 98\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdistribution_class\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mdistr_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 99\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 100\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m Independent(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdistribution_class(\u001b[38;5;241m*\u001b[39mdistr_args), \u001b[38;5;241m1\u001b[39m)\n", + "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/transformers/time_series_utils.py:100\u001b[0m, in \u001b[0;36mDistributionOutput._base_distribution\u001b[0;34m(self, distr_args)\u001b[0m\n\u001b[1;32m 98\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdistribution_class(\u001b[38;5;241m*\u001b[39mdistr_args)\n\u001b[1;32m 99\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 100\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m Independent(\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdistribution_class\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mdistr_args\u001b[49m\u001b[43m)\u001b[49m, \u001b[38;5;241m1\u001b[39m)\n", "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/torch/distributions/studentT.py:61\u001b[0m, in \u001b[0;36mStudentT.__init__\u001b[0;34m(self, df, loc, scale, validate_args)\u001b[0m\n\u001b[1;32m 59\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, df, loc\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.0\u001b[39m, scale\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1.0\u001b[39m, validate_args\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m 60\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdf, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mloc, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mscale \u001b[38;5;241m=\u001b[39m broadcast_all(df, loc, scale)\n\u001b[0;32m---> 61\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_chi2 \u001b[38;5;241m=\u001b[39m \u001b[43mChi2\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdf\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 62\u001b[0m batch_shape \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mdf\u001b[38;5;241m.\u001b[39msize()\n\u001b[1;32m 63\u001b[0m \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m(batch_shape, validate_args\u001b[38;5;241m=\u001b[39mvalidate_args)\n", "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/torch/distributions/chi2.py:25\u001b[0m, in \u001b[0;36mChi2.__init__\u001b[0;34m(self, df, validate_args)\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, df, validate_args\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[0;32m---> 25\u001b[0m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;21;43m__init__\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0.5\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mdf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0.5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalidate_args\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mvalidate_args\u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[0;32m~/miniforge3/envs/multi_modal/lib/python3.10/site-packages/torch/distributions/gamma.py:53\u001b[0m, in \u001b[0;36mGamma.__init__\u001b[0;34m(self, concentration, rate, validate_args)\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;28mself\u001b[39m, concentration, rate, validate_args\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[0;32m---> 53\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconcentration, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrate \u001b[38;5;241m=\u001b[39m \u001b[43mbroadcast_all\u001b[49m\u001b[43m(\u001b[49m\u001b[43mconcentration\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrate\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 54\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(concentration, Number) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(rate, Number):\n\u001b[1;32m 55\u001b[0m batch_shape \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mSize()\n", @@ -581,7 +6274,7 @@ }, { "cell_type": "code", - "execution_count": 148, + "execution_count": 23, "id": "4db1c2e4-f781-446b-a439-817f78c6cf23", "metadata": {}, "outputs": [], @@ -617,7 +6310,7 @@ }, { "cell_type": "code", - "execution_count": 149, + "execution_count": 24, "id": "1c2b8354-adde-4610-863a-c73f11796ef3", "metadata": {}, "outputs": [], @@ -652,7 +6345,7 @@ }, { "cell_type": "code", - "execution_count": 150, + "execution_count": 25, "id": "87e60ad2-24e8-4ac6-b2d5-66d775f31a10", "metadata": {}, "outputs": [], @@ -683,7 +6376,7 @@ }, { "cell_type": "code", - "execution_count": 151, + "execution_count": 26, "id": "08c38180-94ee-4b2f-959b-6a982692cbb4", "metadata": {}, "outputs": [], @@ -695,7 +6388,7 @@ }, { "cell_type": "code", - "execution_count": 152, + "execution_count": 27, "id": "4f7723e0-a252-47fa-8e11-7f84183002b7", "metadata": {}, "outputs": [ @@ -703,26 +6396,26 @@ "name": "stdout", "output_type": "stream", "text": [ - "Epoch 0: Train Loss 1.3076 \t Val Loss 1.1364 \t Train Acc 0.5407 \t Val Acc 0.5973\n", - "Epoch 1: Train Loss 1.0624 \t Val Loss 1.0364 \t Train Acc 0.6096 \t Val Acc 0.6202\n", - "Epoch 2: Train Loss 0.9901 \t Val Loss 0.9804 \t Train Acc 0.6324 \t Val Acc 0.637\n", - "Epoch 3: Train Loss 0.9529 \t Val Loss 0.9519 \t Train Acc 0.6425 \t Val Acc 0.6419\n", - "Epoch 4: Train Loss 0.9263 \t Val Loss 0.9287 \t Train Acc 0.6552 \t Val Acc 0.6588\n", - "Epoch 5: Train Loss 0.9057 \t Val Loss 0.9181 \t Train Acc 0.6648 \t Val Acc 0.6617\n", - "Epoch 6: Train Loss 0.8855 \t Val Loss 0.8984 \t Train Acc 0.6741 \t Val Acc 0.6719\n", - "Epoch 7: Train Loss 0.8727 \t Val Loss 0.8834 \t Train Acc 0.6824 \t Val Acc 0.6854\n", - "Epoch 8: Train Loss 0.8573 \t Val Loss 0.8882 \t Train Acc 0.6884 \t Val Acc 0.6804\n", - "Epoch 9: Train Loss 0.8467 \t Val Loss 0.8627 \t Train Acc 0.6944 \t Val Acc 0.6935\n", - "Epoch 10: Train Loss 0.8385 \t Val Loss 0.8508 \t Train Acc 0.697 \t Val Acc 0.6991\n", - "Epoch 11: Train Loss 0.828 \t Val Loss 0.8411 \t Train Acc 0.7028 \t Val Acc 0.7041\n", - "Epoch 12: Train Loss 0.8216 \t Val Loss 0.8458 \t Train Acc 0.7068 \t Val Acc 0.7069\n", - "Epoch 13: Train Loss 0.812 \t Val Loss 0.8461 \t Train Acc 0.7112 \t Val Acc 0.7038\n", - "Epoch 14: Train Loss 0.8039 \t Val Loss 0.8419 \t Train Acc 0.7162 \t Val Acc 0.7035\n", - "Epoch 15: Train Loss 0.8019 \t Val Loss 0.8273 \t Train Acc 0.7172 \t Val Acc 0.7115\n", - "Epoch 16: Train Loss 0.7945 \t Val Loss 0.8237 \t Train Acc 0.719 \t Val Acc 0.7149\n", - "Epoch 17: Train Loss 0.7904 \t Val Loss 0.8191 \t Train Acc 0.7206 \t Val Acc 0.7177\n", - "Epoch 18: Train Loss 0.7827 \t Val Loss 0.808 \t Train Acc 0.7251 \t Val Acc 0.7214\n", - "Epoch 19: Train Loss 0.7791 \t Val Loss 0.8052 \t Train Acc 0.7294 \t Val Acc 0.722\n" + "Epoch 0: Train Loss 1.1215 \t Val Loss 0.9165 \t Train Acc 0.5756 \t Val Acc 0.6696\n", + "Epoch 1: Train Loss 0.8469 \t Val Loss 0.8256 \t Train Acc 0.688 \t Val Acc 0.7032\n", + "Epoch 2: Train Loss 0.7902 \t Val Loss 0.7783 \t Train Acc 0.7126 \t Val Acc 0.7284\n", + "Epoch 3: Train Loss 0.7583 \t Val Loss 0.7573 \t Train Acc 0.7279 \t Val Acc 0.7352\n", + "Epoch 4: Train Loss 0.7336 \t Val Loss 0.7393 \t Train Acc 0.7394 \t Val Acc 0.7494\n", + "Epoch 5: Train Loss 0.7184 \t Val Loss 0.7273 \t Train Acc 0.7477 \t Val Acc 0.7529\n", + "Epoch 6: Train Loss 0.7014 \t Val Loss 0.7053 \t Train Acc 0.7549 \t Val Acc 0.7609\n", + "Epoch 7: Train Loss 0.6886 \t Val Loss 0.6961 \t Train Acc 0.7615 \t Val Acc 0.7654\n", + "Epoch 8: Train Loss 0.6798 \t Val Loss 0.6905 \t Train Acc 0.764 \t Val Acc 0.7661\n", + "Epoch 9: Train Loss 0.6714 \t Val Loss 0.6904 \t Train Acc 0.7689 \t Val Acc 0.7683\n", + "Epoch 10: Train Loss 0.6648 \t Val Loss 0.6794 \t Train Acc 0.771 \t Val Acc 0.7754\n", + "Epoch 11: Train Loss 0.6585 \t Val Loss 0.6693 \t Train Acc 0.7729 \t Val Acc 0.778\n", + "Epoch 12: Train Loss 0.6509 \t Val Loss 0.6676 \t Train Acc 0.7777 \t Val Acc 0.7765\n", + "Epoch 13: Train Loss 0.6462 \t Val Loss 0.672 \t Train Acc 0.7783 \t Val Acc 0.7739\n", + "Epoch 14: Train Loss 0.6424 \t Val Loss 0.6665 \t Train Acc 0.7784 \t Val Acc 0.7788\n", + "Epoch 15: Train Loss 0.6351 \t Val Loss 0.6479 \t Train Acc 0.782 \t Val Acc 0.7837\n", + "Epoch 16: Train Loss 0.6305 \t Val Loss 0.6444 \t Train Acc 0.7831 \t Val Acc 0.7869\n", + "Epoch 17: Train Loss 0.6283 \t Val Loss 0.6463 \t Train Acc 0.7857 \t Val Acc 0.7837\n", + "Epoch 18: Train Loss 0.6247 \t Val Loss 0.6604 \t Train Acc 0.7855 \t Val Acc 0.7805\n", + "Epoch 19: Train Loss 0.6209 \t Val Loss 0.6423 \t Train Acc 0.7876 \t Val Acc 0.7843\n" ] } ], @@ -747,13 +6440,13 @@ }, { "cell_type": "code", - "execution_count": 153, + "execution_count": 28, "id": "79e083fa-7fb5-4f19-92af-a52394642b68", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -815,7 +6508,7 @@ }, { "cell_type": "code", - "execution_count": 154, + "execution_count": 29, "id": "cd920b36-3594-4756-963d-e6e942d91c66", "metadata": {}, "outputs": [], @@ -840,13 +6533,13 @@ }, { "cell_type": "code", - "execution_count": 155, + "execution_count": 30, "id": "5de559f2-91d4-4738-812e-b41bfcaf2124", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ]