Datasets:

Fsoft-AIC

/

RepoExec-Instruct

like 1

from bisect import bisect_left, bisect_right import itertools import logging from typing import Any, Callable, Dict, Iterable, Mapping, Sequence, Tuple, Union import warnings import numpy as np import pandas as pd from merlion.utils.misc import ValIterOrderedDict from merlion.utils.resample import ( AggregationPolicy, AlignPolicy, MissingValuePolicy, get_date_offset, infer_granularity, reindex_df, to_pd_datetime, to_timestamp, to_offset, ) class UnivariateTimeSeries(pd.Series): """ Please read the `tutorial <tutorials/TimeSeries>` before reading this API doc. This class is a time-indexed ``pd.Series`` which represents a univariate time series. For the most part, it supports all the same features as ``pd.Series``, with the following key differences to iteration and indexing: 1. Iterating over a `UnivariateTimeSeries` is implemented as .. code-block:: python for timestamp, value in univariate: # do stuff... where ``timestamp`` is a Unix timestamp, and ``value`` is the corresponding time series value. 2. Integer index: ``u[i]`` yields the tuple ``(u.time_stamps[i], u.values[i])`` 3. Slice index: ``u[i:j:k]`` yields a new ``UnivariateTimeSeries(u.time_stamps[i:j:k], u.values[i:j:k])`` The class also supports the following additional features: 1. ``univariate.time_stamps`` returns the list of Unix timestamps, and ``univariate.values`` returns the list of the time series values. You may access the ``pd.DatetimeIndex`` directly with ``univariate.index`` (or its ``np.ndarray`` representation with ``univariate.np_time_stamps``), and the ``np.ndarray`` of values with ``univariate.np_values``. 2. ``univariate.concat(other)`` will concatenate the UnivariateTimeSeries ``other`` to the right end of ``univariate``. 3. ``left, right = univariate.bisect(t)`` will split the univariate at the given timestamp ``t``. 4. ``window = univariate.window(t0, tf)`` will return the subset of the time series occurring between timestamps ``t0`` (inclusive) and ``tf`` (non-inclusive) 5. ``series = univariate.to_pd()`` will convert the `UnivariateTimeSeries` into a regular ``pd.Series`` (for compatibility). 6. ``univariate = UnivariateTimeSeries.from_pd(series)`` uses a time-indexed ``pd.Series`` to create a `UnivariateTimeSeries` object directly. .. document special functions .. automethod:: __getitem__ .. automethod:: __iter__ """ def __init__( self, time_stamps: Union[None, Sequence[Union[int, float]]], values: Sequence[float], name: str = None, freq="1h", ): """ :param time_stamps: a sequence of Unix timestamps. You may specify ``None`` if you only have ``values`` with no specific time stamps. :param values: a sequence of univariate values, where ``values[i]`` occurs at time ``time_stamps[i]`` :param name: the name of the univariate time series :param freq: if ``time_stamps`` is not provided, the univariate is assumed to be sampled at frequency ``freq``. ``freq`` may be a string (e.g. ``"1h"``), timedelta, or ``int``/``float`` (in units of seconds). """ is_pd = isinstance(values, pd.Series) if name is None and is_pd: name = values.name if is_pd and isinstance(values.index, pd.DatetimeIndex): super().__init__(values, name=name) elif is_pd and values.index.dtype == "O": super().__init__(values.values, name=name, index=pd.to_datetime(values.index)) else: if time_stamps is None: freq = to_offset(freq) if is_pd and values.index.dtype in ("int64", "float64"): index = pd.to_datetime(0) + freq * values.index else: index = pd.date_range(start=0, periods=len(values), freq=freq) else: index = to_pd_datetime(time_stamps) super().__init__(np.asarray(values), index=index, name=name, dtype=float) if len(self) >= 3 and self.index.freq is None: self.index.freq = pd.infer_freq(self.index) self.index.name = _time_col_name def np_time_stamps(self): """ :rtype: np.ndarray :return: the ``numpy`` representation of this time series's Unix timestamps """ return to_timestamp(self.index.values) def np_values(self): """ :rtype: np.ndarray :return: the ``numpy`` representation of this time series's values """ return super().values def time_stamps(self): """ :rtype: List[float] :return: the list of Unix timestamps for the time series """ return self.np_time_stamps.tolist() def values(self): """ :rtype: List[float] :return: the list of values for the time series. """ return self.np_values.tolist() def t0(self): """ :rtype: float :return: the first timestamp in the univariate time series. """ return self.np_time_stamps[0] def tf(self): """ :rtype: float :return: the final timestamp in the univariate time series. """ return self.np_time_stamps[-1] def is_empty(self): """ :rtype: bool :return: True if the univariate is empty, False if not. """ return len(self) == 0 def __iter__(self): """ The i'th item in the iterator is the tuple ``(self.time_stamps[i], self.values[i])``. """ return itertools.starmap(lambda t, x: (t.item(), x.item()), zip(self.np_time_stamps, self.np_values)) def __getitem__(self, i: Union[int, slice]): """ :param i: integer index or slice :rtype: Union[Tuple[float, float], UnivariateTimeSeries] :return: ``(self.time_stamps[i], self.values[i])`` if ``i`` is an integer. ``UnivariateTimeSeries(self.time_series[i], self.values[i])`` if ``i`` is a slice. """ if isinstance(i, int): return self.np_time_stamps[i].item(), self.np_values[i].item() elif isinstance(i, slice): return UnivariateTimeSeries.from_pd(self.iloc[i]) else: raise KeyError( f"Indexing a `UnivariateTimeSeries` with key {i} of " f"type {type(i).__name__} is not supported. Try " f"using loc[] or iloc[] for more complicated " f"indexing." ) def __eq__(self, other): return self.time_stamps == other.time_stamps and (self.np_values == other.np_values).all() def copy(self, deep=True): """ Copies the `UnivariateTimeSeries`. Simply a wrapper around the ``pd.Series.copy()`` method. """ return UnivariateTimeSeries.from_pd(super().copy(deep=deep)) def concat(self, other): """ Concatenates the `UnivariateTimeSeries` ``other`` to the right of this one. :param UnivariateTimeSeries other: another `UnivariateTimeSeries` :rtype: UnivariateTimeSeries :return: concatenated univariate time series """ return UnivariateTimeSeries.from_pd(pd.concat((self, other)), name=self.name) def bisect(self, t: float, t_in_left: bool = False): """ Splits the time series at the point where the given timestamp occurs. :param t: a Unix timestamp or datetime object. Everything before time ``t`` is in the left split, and everything after time ``t`` is in the right split. :param t_in_left: if ``True``, ``t`` is in the left split. Otherwise, ``t`` is in the right split. :rtype: Tuple[UnivariateTimeSeries, UnivariateTimeSeries] :return: the left and right splits of the time series. """ t = to_pd_datetime(t) if t_in_left: i = bisect_right(self.index, t) else: i = bisect_left(self.index, t) return self[:i], self[i:] def window(self, t0: float, tf: float, include_tf: bool = False): """ :param t0: The timestamp/datetime at the start of the window (inclusive) :param tf: The timestamp/datetime at the end of the window (inclusive if ``include_tf`` is ``True``, non-inclusive otherwise) :param include_tf: Whether to include ``tf`` in the window. :rtype: UnivariateTimeSeries :return: The subset of the time series occurring between timestamps ``t0`` (inclusive) and ``tf`` (included if ``include_tf`` is ``True``, excluded otherwise). """ times = self.index t0, tf = to_pd_datetime(t0), to_pd_datetime(tf) i_0 = bisect_left(times, t0) i_f = bisect_right(times, tf) if include_tf else bisect_left(times, tf) return self[i_0:i_f] def to_dict(self) -> Dict[float, float]: """ :return: A dictionary representing the data points in the time series. """ return dict(zip(self.time_stamps, self.values)) def from_dict(cls, obj: Dict[float, float], name=None): """ :param obj: A dictionary of timestamp - value pairs :param name: the name to assign the output :rtype: UnivariateTimeSeries :return: the `UnivariateTimeSeries` represented by series. """ time_stamps, values = [], [] for point in sorted(obj.items(), key=lambda p: p[0]): time_stamps.append(point[0]) values.append(point[1]) return cls(time_stamps, values, name) def to_pd(self) -> pd.Series: """ :return: A pandas Series representing the time series, indexed by time. """ return pd.Series(self.np_values, index=self.index, name=self.name) def from_pd(cls, series: Union[pd.Series, pd.DataFrame], name=None, freq="1h"): """ :param series: a ``pd.Series``. If it has a``pd.DatetimeIndex``, we will use that index for the timestamps. Otherwise, we will create one at the specified frequency. :param name: the name to assign the output :param freq: if ``series`` is not indexed by time, this is the frequency at which we will assume it is sampled. :rtype: UnivariateTimeSeries :return: the `UnivariateTimeSeries` represented by series. """ if series is None: return None if isinstance(series, TimeSeries) and series.dim == 1: series = list(series.univariates)[0] if isinstance(series, UnivariateTimeSeries): if name is not None: series.name = name return series if isinstance(series, pd.DataFrame) and series.shape[1] == 1: series = series.iloc[:, 0] return cls(time_stamps=None, values=series.astype(float), name=name, freq=freq) def to_ts(self, name=None): """ :name: a name to assign the univariate when converting it to a time series. Can override the existing name. :rtype: TimeSeries :return: A `TimeSeries` representing this univariate time series. """ if self.name is None and name is None: return TimeSeries([self]) else: name = name if self.name is None else self.name return TimeSeries({name: self}) def empty(cls, name=None): """ :rtype: `UnivariateTimeSeries` :return: A Merlion `UnivariateTimeSeries` that has empty timestamps and values. """ return cls([], [], name) The provided code snippet includes necessary dependencies for implementing the `assert_equal_timedeltas` function. Write a Python function `def assert_equal_timedeltas(time_series: UnivariateTimeSeries, granularity, offset=None)` to solve the following problem: Checks that all time deltas in the time series are equal, either to each other, or a pre-specified timedelta (in seconds). Here is the function: def assert_equal_timedeltas(time_series: UnivariateTimeSeries, granularity, offset=None): """ Checks that all time deltas in the time series are equal, either to each other, or a pre-specified timedelta (in seconds). """ if len(time_series) <= 2: return index = time_series.index offset = pd.to_timedelta(0) if offset is None else offset expected = pd.date_range(start=index[0], end=index[-1], freq=granularity) + offset deviation = expected - time_series.index[-len(expected) :] max_deviation = np.abs(deviation.total_seconds().values).max() assert max_deviation < 2e-3, f"Data must have the same time difference between each element of the time series"

Checks that all time deltas in the time series are equal, either to each other, or a pre-specified timedelta (in seconds).

from abc import ABC, abstractmethod import copy import logging from typing import Tuple import numpy as np import pandas as pd from scipy.special import gammaln, multigammaln from scipy.linalg import pinv, pinvh from scipy.stats import ( bernoulli, beta, norm, t as student_t, invgamma, multivariate_normal as mvnorm, invwishart, multivariate_t as mvt, ) from merlion.utils import TimeSeries, UnivariateTimeSeries, to_timestamp, to_pd_datetime The provided code snippet includes necessary dependencies for implementing the `_log_pdet` function. Write a Python function `def _log_pdet(a)` to solve the following problem: Log pseudo-determinant of a (possibly singular) matrix A. Here is the function: def _log_pdet(a): """ Log pseudo-determinant of a (possibly singular) matrix A. """ eigval, eigvec = np.linalg.eigh(a) return np.sum(np.log(eigval[eigval > 0]))

Log pseudo-determinant of a (possibly singular) matrix A.

from collections import OrderedDict import inspect from typing import List, Union import pandas as pd from merlion.utils.misc import combine_signatures, parse_basic_docstring from merlion.utils.time_series import TimeSeries def df_to_time_series( df: pd.DataFrame, time_col: str = None, timestamp_unit="s", data_cols: Union[str, List[str]] = None ) -> TimeSeries: """ Converts a general ``pandas.DataFrame`` to a `TimeSeries` object. :param df: the dataframe to process :param time_col: the name of the column specifying time. If ``None`` is specified, the existing index is used if it is a ``DatetimeIndex``. Otherwise, the first column is used. :param timestamp_unit: if the time column is in Unix timestamps, this is the unit of the timestamp. :param data_cols: the columns representing the actual data values of interest. """ # Set up the time index if not isinstance(df.index, pd.DatetimeIndex): if time_col is None: time_col = df.columns[0] elif time_col not in df.columns: raise KeyError(f"Expected `time_col` to be in {df.columns}. Got {time_col}.") df[time_col] = pd.to_datetime(df[time_col], unit=None if df[time_col].dtype == "O" else timestamp_unit) df = df.set_index(time_col) df = df.sort_index() # Get only the desired columns from the dataframe if data_cols is not None: data_cols = [data_cols] if not isinstance(data_cols, (list, tuple)) else data_cols if not all(c in df.columns for c in data_cols): raise KeyError(f"Expected each of `data_cols` to be in {df.colums}. Got {data_cols}.") df = df[data_cols] # Convert the dataframe to a time series & return it return TimeSeries.from_pd(df) def combine_signatures(sig1: Union[inspect.Signature, None], sig2: Union[inspect.Signature, None]): """ Utility function which combines the signatures of two functions. """ if sig1 is None: return sig2 if sig2 is None: return sig1 # Get all params from sig1 sig1 = deepcopy(sig1) params = list(sig1.parameters.values()) for n, param in enumerate(params): if param.kind in {inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD}: break else: n = len(params) # Add non-overlapping params from sig2 for param in sig2.parameters.values(): if param.kind in {inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD}: break if param.name not in sig1.parameters: params.insert(n, param) n += 1 return sig1.replace(parameters=params) def parse_basic_docstring(docstring): """ Parse the docstring of a model config's ``__init__``, or other basic docstring. """ docstring_lines = [""] if docstring is None else docstring.split("\n") prefix, suffix, param_dict = [], [], OrderedDict() non_empty_lines = [line for line in docstring_lines if len(line) > 0] indent = 0 if len(non_empty_lines) == 0 else len(re.search(r"^\s*", non_empty_lines[0]).group(0)) for line in docstring_lines: line = line[indent:] match = re.search(r":param\s*(\w+):", line) if match is not None: param = match.group(1) param_dict[param] = [line] elif len(param_dict) == 0: prefix.append(line) elif len(suffix) > 0 or re.match(r"^[^\s]", line): # not starting a param doc, but un-indented --> suffix suffix.append(line) else: param_dict[list(param_dict.keys())[-1]].append(line) return prefix, suffix, param_dict The provided code snippet includes necessary dependencies for implementing the `data_io_decorator` function. Write a Python function `def data_io_decorator(func)` to solve the following problem: Decorator to standardize docstrings for data I/O functions. Here is the function: def data_io_decorator(func): """ Decorator to standardize docstrings for data I/O functions. """ def wrapper(*args, **kwargs): return func(*args, **kwargs) # Parse the docstrings of the base df_to_time_series function & decorated function. prefix, suffix, params = parse_basic_docstring(func.__doc__) base_prefix, base_suffix, base_params = parse_basic_docstring(df_to_time_series.__doc__) # Combine the prefixes. Base prefix starts after the first line break. i_lb = [i for i, line in enumerate(base_prefix) if line == ""][1] prefix = ("\n".join(prefix) if any([line != "" for line in prefix]) else "") + "\n".join(base_prefix[i_lb:]) # The base docstring has no suffix, so just use the function's suffix = "\n".join(suffix) if any([line != "" for line in suffix]) else "" # Combine the parameter lists for param, docstring_lines in base_params.items(): if param not in params: params[param] = "\n".join(docstring_lines).rstrip("\n") # Combine the signatures, but remove some parameters that are specific to the original (as well as kwargs). new_sig_params = [] sig = combine_signatures(inspect.signature(func), inspect.signature(df_to_time_series)) for param in sig.parameters.values(): if param.kind in {inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD}: break if param.name not in ["df"]: new_sig_params.append(param) sig = sig.replace(parameters=new_sig_params) # Update the signature and docstring of the wrapper we are returning. Use only the params in the new signature. wrapper.__signature__ = sig params = OrderedDict((p, params[p]) for p in sig.parameters if p in params) wrapper.__doc__ = (prefix or "") + "\n" + "\n".join(params.values()) + "\n\n" + (suffix or "") return wrapper

Decorator to standardize docstrings for data I/O functions.

from collections import OrderedDict import inspect from typing import List, Union import pandas as pd from merlion.utils.misc import combine_signatures, parse_basic_docstring from merlion.utils.time_series import TimeSeries def df_to_time_series( df: pd.DataFrame, time_col: str = None, timestamp_unit="s", data_cols: Union[str, List[str]] = None ) -> TimeSeries: """ Converts a general ``pandas.DataFrame`` to a `TimeSeries` object. :param df: the dataframe to process :param time_col: the name of the column specifying time. If ``None`` is specified, the existing index is used if it is a ``DatetimeIndex``. Otherwise, the first column is used. :param timestamp_unit: if the time column is in Unix timestamps, this is the unit of the timestamp. :param data_cols: the columns representing the actual data values of interest. """ # Set up the time index if not isinstance(df.index, pd.DatetimeIndex): if time_col is None: time_col = df.columns[0] elif time_col not in df.columns: raise KeyError(f"Expected `time_col` to be in {df.columns}. Got {time_col}.") df[time_col] = pd.to_datetime(df[time_col], unit=None if df[time_col].dtype == "O" else timestamp_unit) df = df.set_index(time_col) df = df.sort_index() # Get only the desired columns from the dataframe if data_cols is not None: data_cols = [data_cols] if not isinstance(data_cols, (list, tuple)) else data_cols if not all(c in df.columns for c in data_cols): raise KeyError(f"Expected each of `data_cols` to be in {df.colums}. Got {data_cols}.") df = df[data_cols] # Convert the dataframe to a time series & return it return TimeSeries.from_pd(df) class TimeSeries: """ Please read the `tutorial <tutorials/TimeSeries>` before reading this API doc. This class represents a general multivariate time series as a wrapper around a number of (optionally named) `UnivariateTimeSeries`. A `TimeSeries` object is initialized as ``time_series = TimeSeries(univariates)``, where ``univariates`` is either a list of `UnivariateTimeSeries`, or a dictionary mapping string names to their corresponding `UnivariateTimeSeries` objects. Because the individual ``univariates`` need not be sampled at the same times, an important concept for `TimeSeries` is *alignment*. We say that a `TimeSeries` is *aligned* if all of its univariates have observations sampled at the exact set set of times. One may access the `UnivariateTimeSeries` comprising this `TimeSeries` in four ways: 1. Iterate over the individual univariates using .. code-block:: python for var in time_series.univariates: # do stuff with each UnivariateTimeSeries var 2. Access an individual `UnivariateTimeSeries` by name as ``time_series.univariates[name]``. If you supplied unnamed univariates to the constructor (i.e. using a list), the name of a univariate will just be its index in that list. 3. Get the list of each univariate's name with ``time_series.names``. 4. Iterate over named univariates as .. code-block:: python for name, var in time_series.items(): # do stuff Note that this is equivalent to iterating over ``zip(time_series.names, time_series.univariates)``. This class supports the following additional features as well: 1. Interoperability with ``pandas`` - ``df = time_series.to_pd()`` yields a time-indexed ``pd.DataFrame``, where each column (with the appropriate name) corresponds to a variable. Missing values are ``NaN``. - ``time_series = TimeSeries.from_pd(df)`` takes a time-indexed ``pd.DataFrame`` and returns a corresponding `TimeSeries` object (missing values are handled appropriately). The order of ``time_series.univariates`` is the order of ``df.keys()``. 2. Automated alignment: ``aligned = time_series.align()`` resamples each of ``time_series.univariates`` so that they all have the same timestamps. By default, this is done by taking the union of all timestamps present in any individual univariate time series, and imputing missing values via interpolation. See the method documentation for details on how you may configure the alignment policy. 3. Transparent indexing and iteration for `TimeSeries` which have all univariates aligned (i.e. they all have the same timestamps) - Get the length and shape of the time series (equal to the number of observations in each individual univariate). Note that if the time series is not aligned, we will return the length/shape of an equivalent ``pandas`` dataframe and emit a warning. - Index ``time_series[i] = (times[i], (x1[i], ..., xn[i]))`` (assuming ``time_series`` has ``n`` aligned univariates with timestamps ``times``, and ``xk = time_series.univariates[k-1].values``). Slice returns a `TimeSeries` object and works as one would expect. - Assuming ``time_series`` has ``n`` variables, you may iterate with .. code-block:: python for t_i, (x1_i, ..., xn_i) in time_series: # do stuff Notably, this lets you call ``times, val_vectors = zip(*time_series)`` 4. Time-based queries for any time series - Get the two sub `TimeSeries` before and after a timestamp ``t`` via ``left, right = time_series.bisect(t)`` - Get the sub `TimeSeries` between timestamps ``t0`` (inclusive) and ``tf`` (non-inclusive) via ``window = time_series.window(t0, tf)`` 5. Concatenation: two `TimeSeries` may be concatenated (in time) as ``time_series = time_series_1 + time_series_2``. .. document special functions .. automethod:: __getitem__ .. automethod:: __iter__ """ def __init__( self, univariates: Union[Mapping[Any, UnivariateTimeSeries], Iterable[UnivariateTimeSeries]], *, freq: str = "1h", check_aligned=True, ): # Type/length checking of univariates if isinstance(univariates, Mapping): univariates = ValIterOrderedDict((str(k), v) for k, v in univariates.items()) assert all(isinstance(var, UnivariateTimeSeries) for var in univariates.values()) elif isinstance(univariates, Iterable): univariates = list(univariates) assert all(isinstance(var, UnivariateTimeSeries) for var in univariates) names = [str(var.name) for var in univariates] if len(set(names)) == len(names): names = [str(i) if name is None else name for i, name in enumerate(names)] univariates = ValIterOrderedDict(zip(names, univariates)) else: univariates = ValIterOrderedDict((str(i), v) for i, v in enumerate(univariates)) else: raise TypeError( "Expected univariates to be either a `Sequence[UnivariateTimeSeries]` or a " "`Mapping[Hashable, UnivariateTimeSeries]`." ) assert len(univariates) > 0 # Assign all the individual univariate series the appropriate names for name, var in univariates.items(): var.name = name # Set self.univariates and check if they are perfectly aligned self.univariates = univariates if check_aligned and self.dim > 1: t = self.univariates[self.names[0]].time_stamps self._is_aligned = all(self.univariates[name].time_stamps == t for name in self.names[1:]) else: self._is_aligned = len(univariates) <= 1 # Raise a warning if the univariates are too mis-aligned if check_aligned and not self.is_aligned: all_t0 = [var.index[0] for var in univariates if len(var) > 0] all_tf = [var.index[-1] for var in univariates if len(var) > 0] min_elapsed = min(tf - t0 for t0, tf in zip(all_t0, all_tf)) min_t0, max_t0 = min(all_t0), max(all_t0) min_tf, max_tf = min(all_tf), max(all_tf) if max_t0 - min_t0 > 0.1 * min_elapsed: logger.warning( f"The earliest univariate starts at {min_t0}, but the " f"latest univariate starts at {max_t0}, a difference of " f"{max_t0 - min_t0}. This is more than 10% of the length " f"of the shortest univariate ({min_elapsed}). You may " f"want to check that the univariates cover the same " f"window of time.", stack_info=True, ) if max_tf - min_tf > 0.1 * min_elapsed: logger.warning( f"The earliest univariate ends at {min_tf}, but the " f"latest univariate ends at {max_tf}, a difference of " f"{max_tf - min_tf}. This is more than 10% of the length " f"of the shortest univariate ({min_elapsed}). You may " f"want to check that the univariates cover the same " f"window of time.", stack_info=True, ) def names(self): """:return: The list of the names of the univariates.""" return list(self.univariates.keys()) def items(self): """:return: Iterator over ``(name, univariate)`` tuples.""" return self.univariates.items() def dim(self) -> int: """ :return: The dimension of the time series (the number of variables). """ return len(self.univariates) def rename(self, mapper: Union[Iterable[str], Mapping[str, str], Callable[[str], str]]): """ :param mapper: Dict-like or function transformations to apply to the univariate names. Can also be an iterable of new univariate names. :return: the time series with renamed univariates. """ if isinstance(mapper, Callable): mapper = [mapper(old) for old in self.names] elif isinstance(mapper, Mapping): mapper = [mapper.get(old, old) for old in self.names] univariates = ValIterOrderedDict((new_name, var) for new_name, var in zip(mapper, self.univariates)) return self.__class__(univariates) def is_aligned(self) -> bool: """ :return: Whether all individual variable time series are sampled at the same time stamps, i.e. they are aligned. """ return self._is_aligned def index(self): return to_pd_datetime(self.np_time_stamps) def np_time_stamps(self): """ :rtype: np.ndarray :return: the ``numpy`` representation of this time series's Unix timestamps """ return np.unique(np.concatenate([var.np_time_stamps for var in self.univariates])) def time_stamps(self): """ :rtype: List[float] :return: the list of Unix timestamps for the time series """ return self.np_time_stamps.tolist() def t0(self) -> float: """ :rtype: float :return: the first timestamp in the time series. """ return min(var.t0 for var in self.univariates) def tf(self) -> float: """ :rtype: float :return: the final timestamp in the time series. """ return max(var.tf for var in self.univariates) def _txs_to_vec(txs): """ Helper function that converts [(t_1[i], x_1[i]), ..., (t_k[i], x_k[i])], i.e. [var[i] for var in self.univariates], into the desired output form (t_1[i], (x_1[i], ..., x_k[i])). """ return txs[0][0], tuple(tx[1] for tx in txs) def __iter__(self): """ Only supported if all individual variable time series are sampled at the same time stamps. The i'th item of the iterator is the tuple ``(time_stamps[i], tuple(var.values[i] for var in self.univariates))``. """ if not self.is_aligned: raise RuntimeError( "The univariates comprising this time series are not aligned " "(they have different time stamps), but alignment is required " "to iterate over the time series." ) return map(self._txs_to_vec, zip(*self.univariates)) def __getitem__(self, i: Union[int, slice]): """ Only supported if all individual variable time series are sampled at the same time stamps. :param i: integer index or slice. :rtype: Union[Tuple[float, Tuple[float]], TimeSeries] :return: If ``i`` is an integer, returns the tuple ``(time_stamps[i], tuple(var.values[i] for var in self.univariates))``. If ``i`` is a slice, returns the time series ``TimeSeries([var[i] for var in self.univariates])`` """ if not self.is_aligned: raise RuntimeError( "The univariates comprising this time series are not aligned " "(they have different time stamps), but alignment is required " "to index into the time series." ) if isinstance(i, int): return self._txs_to_vec([var[i] for var in self.univariates]) elif isinstance(i, slice): # ret must be aligned, so bypass the (potentially) expensive check univariates = ValIterOrderedDict([(k, v[i]) for k, v in self.items()]) ret = TimeSeries(univariates, check_aligned=False) ret._is_aligned = True return ret else: raise KeyError( f"Indexing a `TimeSeries` with key {i} of type " f"{type(i).__name__} not supported. Perhaps you " f"meant to index into `time_series.univariates`, " f"rather than `time_series`?" ) def is_empty(self) -> bool: """ :return: whether the time series is empty """ return all(len(var) == 0 for var in self.univariates) def squeeze(self) -> UnivariateTimeSeries: """ :return: `UnivariateTimeSeries` if the time series is univariate; otherwise returns itself, a `TimeSeries` """ if self.dim == 1: return self.univariates[self.names[0]] return self def __len__(self): """ :return: the number of observations in the time series """ if not self.is_aligned: warning = ( "The univariates comprising this time series are not aligned " "(they have different time stamps). The length returned is " "equal to the length of the _union_ of all time stamps present " "in any of the univariates." ) warnings.warn(warning) logger.warning(warning) return len(self.to_pd()) return len(self.univariates[self.names[0]]) def shape(self) -> Tuple[int, int]: """ :return: the shape of this time series, i.e. ``(self.dim, len(self))`` """ return self.dim, len(self) def __add__(self, other): """ Concatenates the `TimeSeries` ``other`` to the right of this one. :param TimeSeries other: :rtype: TimeSeries :return: concatenated time series """ return self.concat(other, axis=0) def concat(self, other, axis=0): """ Concatenates the `TimeSeries` ``other`` on the time axis if ``axis = 0`` or the variable axis if ``axis = 1``. :rtype: TimeSeries :return: concatenated time series """ assert axis in [0, 1] if axis == 0: assert self.dim == other.dim, ( f"Cannot concatenate a {self.dim}-dimensional time series with a {other.dim}-dimensional " f"time series on the time axis." ) assert self.names == other.names, ( f"Cannot concatenate time series on the time axis if they have two different sets of " f"variable names, {self.names} and {other.names}." ) univariates = ValIterOrderedDict( [(name, ts0.concat(ts1)) for (name, ts0), ts1 in zip(self.items(), other.univariates)] ) ret = TimeSeries(univariates, check_aligned=False) ret._is_aligned = self.is_aligned and other.is_aligned return ret else: univariates = ValIterOrderedDict([(name, var.copy()) for name, var in [*self.items(), other.items()]]) ret = TimeSeries(univariates, check_aligned=False) ret._is_aligned = self.is_aligned and other.is_aligned and self.time_stamps == other.time_stamps return ret def __eq__(self, other): if self.dim != other.dim: return False return all(u == v for u, v in zip(self.univariates, other.univariates)) def __repr__(self): return repr(self.to_pd()) def bisect(self, t: float, t_in_left: bool = False): """ Splits the time series at the point where the given timestamp ``t`` occurs. :param t: a Unix timestamp or datetime object. Everything before time ``t`` is in the left split, and everything after time ``t`` is in the right split. :param t_in_left: if ``True``, ``t`` is in the left split. Otherwise, ``t`` is in the right split. :rtype: Tuple[TimeSeries, TimeSeries] :return: the left and right splits of the time series. """ left, right = ValIterOrderedDict(), ValIterOrderedDict() for name, var in self.items(): left[name], right[name] = var.bisect(t, t_in_left) if self.is_aligned: left = TimeSeries(left, check_aligned=False) right = TimeSeries(right, check_aligned=False) left._is_aligned = True right._is_aligned = True return left, right else: return TimeSeries(left), TimeSeries(right) def window(self, t0: float, tf: float, include_tf: bool = False): """ :param t0: The timestamp/datetime at the start of the window (inclusive) :param tf: The timestamp/datetime at the end of the window (inclusive if ``include_tf`` is ``True``, non-inclusive otherwise) :param include_tf: Whether to include ``tf`` in the window. :return: The subset of the time series occurring between timestamps ``t0`` (inclusive) and ``tf`` (included if ``include_tf`` is ``True``, excluded otherwise). :rtype: `TimeSeries` """ return TimeSeries(ValIterOrderedDict([(k, var.window(t0, tf, include_tf)) for k, var in self.items()])) def to_pd(self) -> pd.DataFrame: """ :return: A pandas DataFrame (indexed by time) which represents this time series. Each variable corresponds to a column of the DataFrame. Timestamps which are present for one variable but not another, are represented with NaN. """ t = pd.DatetimeIndex([]) univariates = [(name, var.to_pd()[~var.index.duplicated()]) for name, var in self.items()] for _, var in univariates: t = t.union(var.index) t = t.sort_values() t.name = _time_col_name if len(t) >= 3: t.freq = pd.infer_freq(t) df = pd.DataFrame(np.full((len(t), len(univariates)), np.nan), index=t, columns=self.names) for name, var in univariates: df.loc[var.index, name] = var[~var.index.duplicated()] return df def to_csv(self, file_name, **kwargs): self.to_pd().to_csv(file_name, **kwargs) def from_pd(cls, df: Union[pd.Series, pd.DataFrame, np.ndarray], check_times=True, drop_nan=True, freq="1h"): """ :param df: A ``pandas.DataFrame`` with a ``DatetimeIndex``. Each column corresponds to a different variable of the time series, and the key of column (in sorted order) give the relative order of those variables in ``self.univariates``. Missing values should be represented with ``NaN``. May also be a ``pandas.Series`` for single-variable time series. :param check_times: whether to check that all times in the index are unique (up to the millisecond) and sorted. :param drop_nan: whether to drop all ``NaN`` entries before creating the time series. Specifying ``False`` is useful if you wish to impute the values on your own. :param freq: if ``df`` is not indexed by time, this is the frequency at which we will assume it is sampled. :rtype: TimeSeries :return: the `TimeSeries` object corresponding to ``df``. """ if df is None: return None elif isinstance(df, TimeSeries): return df elif isinstance(df, UnivariateTimeSeries): return cls([df]) elif isinstance(df, pd.Series): if drop_nan: df = df[~df.isna()] return cls({df.name: UnivariateTimeSeries.from_pd(df)}) elif isinstance(df, np.ndarray): arr = df.reshape(len(df), -1).T ret = cls([UnivariateTimeSeries(time_stamps=None, values=v, freq=freq) for v in arr], check_aligned=False) ret._is_aligned = True return ret elif not isinstance(df, pd.DataFrame): df = pd.DataFrame(df) # Time series is not aligned iff there are missing values aligned = df.shape[1] == 1 or not df.isna().any().any() # Check for a string-type index if df.index.dtype == "O": df = df.copy() df.index = pd.to_datetime(df.index) # Make sure there are no time duplicates (by milliseconds) if desired dt_index = isinstance(df.index, pd.DatetimeIndex) if check_times: if not df.index.is_unique: df = df[~df.index.duplicated()] if not df.index.is_monotonic_increasing: df = df.sort_index() if dt_index: times = df.index.values.astype("datetime64[ms]").astype(np.int64) df = df.reindex(pd.to_datetime(np.unique(times), unit="ms"), method="bfill") elif not aligned and not dt_index and df.index.dtype not in ("int64", "float64"): raise RuntimeError( f"We only support instantiating time series from a " f"``pd.DataFrame`` with missing values when the data frame is " f"indexed by time, int, or float. This dataframe's index is of " f"type {type(df.index).__name__}" ) if drop_nan and not aligned: ret = cls( ValIterOrderedDict( [(k, UnivariateTimeSeries.from_pd(ser[~ser.isna()], freq=freq)) for k, ser in df.items()] ), check_aligned=False, ) else: ret = cls( ValIterOrderedDict([(k, UnivariateTimeSeries.from_pd(ser, freq=freq)) for k, ser in df.items()]), check_aligned=False, ) ret._is_aligned = aligned return ret def from_ts_list(cls, ts_list, *, check_aligned=True): """ :param Iterable[TimeSeries] ts_list: iterable of time series we wish to form a multivariate time series with :param bool check_aligned: whether to check if the output time series is aligned :rtype: TimeSeries :return: A multivariate `TimeSeries` created from all the time series in the inputs. """ ts_list = list(ts_list) all_names = [set(ts.names) for ts in ts_list] if all( len(names_i.intersection(names_j)) == 0 for i, names_i in enumerate(all_names) for names_j in all_names[i + 1 :] ): univariates = ValIterOrderedDict(itertools.chain.from_iterable(ts.items() for ts in ts_list)) else: univariates = list(itertools.chain.from_iterable(ts.univariates for ts in ts_list)) return cls(univariates, check_aligned=check_aligned) def align( self, *, reference: Sequence[Union[int, float]] = None, granularity: Union[str, int, float] = None, origin: int = None, remove_non_overlapping=True, alignment_policy: AlignPolicy = None, aggregation_policy: AggregationPolicy = AggregationPolicy.Mean, missing_value_policy: MissingValuePolicy = MissingValuePolicy.Interpolate, ): """ Aligns all the univariates comprising this multivariate time series so that they all have the same time stamps. :param reference: A specific set of timestamps we want the resampled time series to contain. Required if ``alignment_policy`` is `AlignPolicy.FixedReference`. Overrides other alignment policies if specified. :param granularity: The granularity (in seconds) of the resampled time time series. Defaults to the GCD time difference between adjacent elements of ``time_series`` (otherwise). Ignored if ``reference`` is given or ``alignment_policy`` is `AlignPolicy.FixedReference`. Overrides other alignment policies if specified. :param origin: The first timestamp of the resampled time series. Only used if the alignment policy is `AlignPolicy.FixedGranularity`. :param remove_non_overlapping: If ``True``, we will only keep the portions of the univariates that overlap with each other. For example, if we have 3 univariates which span timestamps [0, 3600], [60, 3660], and [30, 3540], we will only keep timestamps in the range [60, 3540]. If ``False``, we will keep all timestamps produced by the resampling. :param alignment_policy: The policy we want to use to align the time series. - `AlignPolicy.FixedReference` aligns each single-variable time series to ``reference``, a user-specified sequence of timestamps. - `AlignPolicy.FixedGranularity` resamples each single-variable time series at the same granularity, aggregating windows and imputing missing values as desired. - `AlignPolicy.OuterJoin` returns a time series with the union of all timestamps present in any single-variable time series. - `AlignPolicy.InnerJoin` returns a time series with the intersection of all timestamps present in all single-variable time series. :param aggregation_policy: The policy used to aggregate windows of adjacent observations when downsampling. :param missing_value_policy: The policy used to impute missing values created when upsampling. :rtype: TimeSeries :return: The resampled multivariate time series. """ if self.is_empty(): if reference is not None or granularity is not None: logger.warning( "Attempting to align an empty time series to a set of reference time stamps or a " "fixed granularity. Doing nothing." ) return TimeSeries.from_pd(self.to_pd()) if reference is not None or alignment_policy is AlignPolicy.FixedReference: if reference is None: raise RuntimeError("`reference` is required when using `alignment_policy` FixedReference.") if alignment_policy not in [None, AlignPolicy.FixedReference]: logger.warning( f"TimeSeries.align() received alignment policy " f"{alignment_policy.name}, but a reference sequence of " f"timestamps was also provided. `reference` is higher " f"priority than `alignment_policy`, so we are using " f"alignment policy FixedReference." ) if granularity is not None: logger.warning( "TimeSeries.align() received a granularity at which to " "resample the time series, but a reference sequence of " "timestamps was also provided. `reference` is higher " "priority than `granularity`, so we are using alignment " "policy FixedReference, not FixedGranularity." ) # Align each univariate time series to the reference timestamps df = reindex_df(self.to_pd(), reference, missing_value_policy) return TimeSeries.from_pd(df, check_times=False) elif granularity is not None or alignment_policy is AlignPolicy.FixedGranularity: if alignment_policy not in [None, AlignPolicy.FixedGranularity]: logger.warning( f"TimeSeries.align() received alignment policy " f"{alignment_policy.name}, but a desired granularity at " f"which to resample the time series was also received. " f"`granularity` is higher priority than `alignment_policy`, " f"so we are using alignment policy FixedGranularity." ) # Get the granularity in seconds, if one is specified and the granularity is a fixed number of seconds. # Otherwise, infer the granularity. If we have a non-fixed granularity, record that fact. fixed_granularity = True if granularity is None: granularity = infer_granularity(self.time_stamps) granularity = to_offset(granularity) if isinstance(granularity, pd.DateOffset): try: granularity.nanos except ValueError: fixed_granularity = False # Remove non-overlapping portions of univariates if desired df = self.to_pd() if remove_non_overlapping: t0 = max(v.index[0] for v in self.univariates if len(v) > 0) tf = min(v.index[-1] for v in self.univariates if len(v) > 0) df = df[t0:tf] # Resample at the desired granularity, setting the origin as needed if origin is None and isinstance(granularity, pd.Timedelta): elapsed = df.index[-1] - df.index[0] origin = df.index[0] + elapsed % granularity direction = None if not fixed_granularity else "right" new_df = df.resample(granularity, origin=to_pd_datetime(origin), label=direction, closed=direction) # Apply aggregation & missing value imputation policies new_df = aggregation_policy.value(new_df) if missing_value_policy is MissingValuePolicy.Interpolate and not fixed_granularity: new_df = new_df.interpolate() else: new_df = missing_value_policy.value(new_df) # Add the date offset only if we're resampling to a non-fixed granularity if not fixed_granularity: new_df.index += get_date_offset(time_stamps=new_df.index, reference=df.index) # Do any forward-filling/back-filling to cover all the indices return TimeSeries.from_pd(new_df[df.index[0] : df.index[-1]].ffill().bfill(), check_times=False) elif alignment_policy in [None, AlignPolicy.OuterJoin]: # Outer join is the union of all timestamps appearing in any of the # univariate time series. We just need to apply the missing value # policy to self.to_pd() (and bfill()/ffill() to take care of any # additional missing values at the start/end), and then return # from_pd(). df = missing_value_policy.value(self.to_pd()) if remove_non_overlapping: t0 = max(v.index[0] for v in self.univariates if len(v) > 0) tf = min(v.index[-1] for v in self.univariates if len(v) > 0) df = df[t0:tf] else: df = df.ffill().bfill() return TimeSeries.from_pd(df, check_times=False) elif alignment_policy is AlignPolicy.InnerJoin: # Inner join is the intersection of all the timestamps appearing in # all of the univariate time series. Just get the indexes of the # univariate sub time series where all variables are present. # TODO: add a resampling step instead of just indexing? ts = [set(var.np_time_stamps) for var in self.univariates] t = ts[0] for tprime in ts[1:]: t = t.intersection(tprime) if len(t) == 0: raise RuntimeError( "No time stamps are shared between all variables! Try again with a different alignment policy." ) t = to_pd_datetime(sorted(t)) return TimeSeries.from_pd(self.to_pd().loc[t], check_times=False) else: raise RuntimeError(f"Alignment policy {alignment_policy.name} not supported") The provided code snippet includes necessary dependencies for implementing the `csv_to_time_series` function. Write a Python function `def csv_to_time_series(file_name: str, **kwargs) -> TimeSeries` to solve the following problem: Reads a CSV file and converts it to a `TimeSeries` object. Here is the function: def csv_to_time_series(file_name: str, **kwargs) -> TimeSeries: """ Reads a CSV file and converts it to a `TimeSeries` object. """ return df_to_time_series(pd.read_csv(file_name), **kwargs)

Reads a CSV file and converts it to a `TimeSeries` object.

from abc import ABCMeta from collections import OrderedDict from copy import deepcopy from functools import wraps import importlib import inspect import re from typing import Callable, Union The provided code snippet includes necessary dependencies for implementing the `dynamic_import` function. Write a Python function `def dynamic_import(import_path: str, alias: dict = None)` to solve the following problem: Dynamically import a member from the specified module. :param import_path: syntax 'module_name:member_name', e.g. 'merlion.transform.normalize:BoxCoxTransform' :param alias: dict which maps shortcuts for the registered classes, to their full import paths. :return: imported class Here is the function: def dynamic_import(import_path: str, alias: dict = None): """ Dynamically import a member from the specified module. :param import_path: syntax 'module_name:member_name', e.g. 'merlion.transform.normalize:BoxCoxTransform' :param alias: dict which maps shortcuts for the registered classes, to their full import paths. :return: imported class """ alias = dict() if alias is None else alias if import_path not in alias and ":" not in import_path: raise ValueError( "import_path should be one of {} or " 'include ":", e.g. "merlion.transform.normalize:MeanVarNormalize" : ' "got {}".format(set(alias), import_path) ) if ":" not in import_path: import_path = alias[import_path] module_name, objname = import_path.split(":") m = importlib.import_module(module_name) return getattr(m, objname)

Dynamically import a member from the specified module. :param import_path: syntax 'module_name:member_name', e.g. 'merlion.transform.normalize:BoxCoxTransform' :param alias: dict which maps shortcuts for the registered classes, to their full import paths. :return: imported class

from abc import ABCMeta from collections import OrderedDict from copy import deepcopy from functools import wraps import importlib import inspect import re from typing import Callable, Union The provided code snippet includes necessary dependencies for implementing the `call_with_accepted_kwargs` function. Write a Python function `def call_with_accepted_kwargs(fn: Callable, **kwargs)` to solve the following problem: Given a function and a list of keyword arguments, call the function with only the keyword arguments that are accepted by the function. Here is the function: def call_with_accepted_kwargs(fn: Callable, **kwargs): """ Given a function and a list of keyword arguments, call the function with only the keyword arguments that are accepted by the function. """ params = inspect.signature(fn).parameters if not any(v.kind.name == "VAR_KEYWORD" for v in params.values()): kwargs = {k: v for k, v in kwargs.items() if k in params} return fn(**kwargs)

Given a function and a list of keyword arguments, call the function with only the keyword arguments that are accepted by the function.

from abc import ABCMeta from collections import OrderedDict from copy import deepcopy from functools import wraps import importlib import inspect import re from typing import Callable, Union The provided code snippet includes necessary dependencies for implementing the `initializer` function. Write a Python function `def initializer(func)` to solve the following problem: Decorator for the __init__ method. Automatically assigns the parameters. Here is the function: def initializer(func): """ Decorator for the __init__ method. Automatically assigns the parameters. """ argspec = inspect.getfullargspec(func) @wraps(func) def wrapper(self, *args, **kargs): for name, arg in list(zip(argspec.args[1:], args)) + list(kargs.items()): setattr(self, name, arg) for name, default in zip(reversed(argspec.args), reversed(argspec.defaults)): if not hasattr(self, name): setattr(self, name, default) func(self, *args, **kargs) return wrapper

Decorator for the __init__ method. Automatically assigns the parameters.

from enum import Enum from functools import partial import logging import math import re from typing import Iterable, Sequence, Union import numpy as np import pandas as pd from pandas.tseries.frequencies import to_offset as pd_to_offset import scipy.stats The provided code snippet includes necessary dependencies for implementing the `to_offset` function. Write a Python function `def to_offset(dt)` to solve the following problem: Converts a time gap to a ``pd.Timedelta`` if possible, otherwise a ``pd.DateOffset``. Here is the function: def to_offset(dt): """ Converts a time gap to a ``pd.Timedelta`` if possible, otherwise a ``pd.DateOffset``. """ if dt is None: return None if isinstance(dt, (int, float)): dt = pd.to_timedelta(dt, unit="s") elif isinstance(dt, str) and not any(re.match(r"\d+" + suf, dt) for suf in ("M", "m", "MS", "Q", "Y", "y")): try: dt = pd.to_timedelta(dt) except ValueError: pass return dt if isinstance(dt, pd.Timedelta) else pd_to_offset(dt)

Converts a time gap to a ``pd.Timedelta`` if possible, otherwise a ``pd.DateOffset``.

from enum import Enum from functools import partial import logging import math import re from typing import Iterable, Sequence, Union import numpy as np import pandas as pd from pandas.tseries.frequencies import to_offset as pd_to_offset import scipy.stats The provided code snippet includes necessary dependencies for implementing the `to_timestamp` function. Write a Python function `def to_timestamp(t)` to solve the following problem: Converts a datetime to a Unix timestamp. Here is the function: def to_timestamp(t): """ Converts a datetime to a Unix timestamp. """ if isinstance(t, (int, float)) or isinstance(t, Iterable) and all(isinstance(ti, (int, float)) for ti in t): return np.asarray(t) elif isinstance(t, np.ndarray) and t.dtype in [int, np.float32, np.float64]: return t return np.asarray(t).astype("datetime64[ms]").astype(float) / 1000

Converts a datetime to a Unix timestamp.

from enum import Enum from functools import partial import logging import math import re from typing import Iterable, Sequence, Union import numpy as np import pandas as pd from pandas.tseries.frequencies import to_offset as pd_to_offset import scipy.stats class MissingValuePolicy(Enum): """ Missing value imputation policies. Values are partial functions for ``pd.Series`` methods. """ FFill = partial(lambda df, *args, **kwargs: getattr(df, "ffill")(*args, **kwargs)) """Fill gap with the first value before the gap.""" BFill = partial(lambda df, *args, **kwargs: getattr(df, "bfill")(*args, **kwargs)) """Fill gap with the first value after the gap.""" Nearest = partial(lambda df, *args, **kwargs: getattr(df, "interpolate")(*args, **kwargs), method="nearest") """Replace missing value with the value closest to it.""" Interpolate = partial(lambda df, *args, **kwargs: getattr(df, "interpolate")(*args, **kwargs), method="time") """Fill in missing values by linear interpolation.""" ZFill = partial(lambda df, *args, **kwargs: getattr(df, "replace")(*args, **kwargs), to_replace=np.nan, value=0) """Replace missing values with zeros.""" def to_pd_datetime(timestamp): """ Converts a timestamp (or list/iterable of timestamps) to pandas Datetime, truncated at the millisecond. """ if isinstance(timestamp, pd.DatetimeIndex): return timestamp elif isinstance(timestamp, (int, float)): return pd.to_datetime(int(timestamp * 1000), unit="ms") elif isinstance(timestamp, Iterable) and all(isinstance(t, (int, float)) for t in timestamp): timestamp = pd.to_datetime(np.asarray(timestamp).astype(float) * 1000, unit="ms") elif isinstance(timestamp, np.ndarray) and timestamp.dtype in [int, np.float32, np.float64]: timestamp = pd.to_datetime(np.asarray(timestamp).astype(float) * 1000, unit="ms") return pd.to_datetime(timestamp) The provided code snippet includes necessary dependencies for implementing the `reindex_df` function. Write a Python function `def reindex_df( df: Union[pd.Series, pd.DataFrame], reference: Sequence[Union[int, float]], missing_value_policy: MissingValuePolicy )` to solve the following problem: Reindexes a Datetime-indexed dataframe ``df`` to have the same time stamps as a reference sequence of timestamps. Imputes missing values with the given `MissingValuePolicy`. Here is the function: def reindex_df( df: Union[pd.Series, pd.DataFrame], reference: Sequence[Union[int, float]], missing_value_policy: MissingValuePolicy ): """ Reindexes a Datetime-indexed dataframe ``df`` to have the same time stamps as a reference sequence of timestamps. Imputes missing values with the given `MissingValuePolicy`. """ reference = to_pd_datetime(reference) all_times = np.unique(np.concatenate((reference.values, df.index.values))) df = df.reindex(index=all_times) df = missing_value_policy.value(df).ffill().bfill() return df.loc[reference]

Reindexes a Datetime-indexed dataframe ``df`` to have the same time stamps as a reference sequence of timestamps. Imputes missing values with the given `MissingValuePolicy`.

from collections import OrderedDict from typing import List import numpy as np import pandas as pd from merlion.utils.time_series import TimeSeries, to_pd_datetime class TimeSeries: """ Please read the `tutorial <tutorials/TimeSeries>` before reading this API doc. This class represents a general multivariate time series as a wrapper around a number of (optionally named) `UnivariateTimeSeries`. A `TimeSeries` object is initialized as ``time_series = TimeSeries(univariates)``, where ``univariates`` is either a list of `UnivariateTimeSeries`, or a dictionary mapping string names to their corresponding `UnivariateTimeSeries` objects. Because the individual ``univariates`` need not be sampled at the same times, an important concept for `TimeSeries` is *alignment*. We say that a `TimeSeries` is *aligned* if all of its univariates have observations sampled at the exact set set of times. One may access the `UnivariateTimeSeries` comprising this `TimeSeries` in four ways: 1. Iterate over the individual univariates using .. code-block:: python for var in time_series.univariates: # do stuff with each UnivariateTimeSeries var 2. Access an individual `UnivariateTimeSeries` by name as ``time_series.univariates[name]``. If you supplied unnamed univariates to the constructor (i.e. using a list), the name of a univariate will just be its index in that list. 3. Get the list of each univariate's name with ``time_series.names``. 4. Iterate over named univariates as .. code-block:: python for name, var in time_series.items(): # do stuff Note that this is equivalent to iterating over ``zip(time_series.names, time_series.univariates)``. This class supports the following additional features as well: 1. Interoperability with ``pandas`` - ``df = time_series.to_pd()`` yields a time-indexed ``pd.DataFrame``, where each column (with the appropriate name) corresponds to a variable. Missing values are ``NaN``. - ``time_series = TimeSeries.from_pd(df)`` takes a time-indexed ``pd.DataFrame`` and returns a corresponding `TimeSeries` object (missing values are handled appropriately). The order of ``time_series.univariates`` is the order of ``df.keys()``. 2. Automated alignment: ``aligned = time_series.align()`` resamples each of ``time_series.univariates`` so that they all have the same timestamps. By default, this is done by taking the union of all timestamps present in any individual univariate time series, and imputing missing values via interpolation. See the method documentation for details on how you may configure the alignment policy. 3. Transparent indexing and iteration for `TimeSeries` which have all univariates aligned (i.e. they all have the same timestamps) - Get the length and shape of the time series (equal to the number of observations in each individual univariate). Note that if the time series is not aligned, we will return the length/shape of an equivalent ``pandas`` dataframe and emit a warning. - Index ``time_series[i] = (times[i], (x1[i], ..., xn[i]))`` (assuming ``time_series`` has ``n`` aligned univariates with timestamps ``times``, and ``xk = time_series.univariates[k-1].values``). Slice returns a `TimeSeries` object and works as one would expect. - Assuming ``time_series`` has ``n`` variables, you may iterate with .. code-block:: python for t_i, (x1_i, ..., xn_i) in time_series: # do stuff Notably, this lets you call ``times, val_vectors = zip(*time_series)`` 4. Time-based queries for any time series - Get the two sub `TimeSeries` before and after a timestamp ``t`` via ``left, right = time_series.bisect(t)`` - Get the sub `TimeSeries` between timestamps ``t0`` (inclusive) and ``tf`` (non-inclusive) via ``window = time_series.window(t0, tf)`` 5. Concatenation: two `TimeSeries` may be concatenated (in time) as ``time_series = time_series_1 + time_series_2``. .. document special functions .. automethod:: __getitem__ .. automethod:: __iter__ """ def __init__( self, univariates: Union[Mapping[Any, UnivariateTimeSeries], Iterable[UnivariateTimeSeries]], *, freq: str = "1h", check_aligned=True, ): # Type/length checking of univariates if isinstance(univariates, Mapping): univariates = ValIterOrderedDict((str(k), v) for k, v in univariates.items()) assert all(isinstance(var, UnivariateTimeSeries) for var in univariates.values()) elif isinstance(univariates, Iterable): univariates = list(univariates) assert all(isinstance(var, UnivariateTimeSeries) for var in univariates) names = [str(var.name) for var in univariates] if len(set(names)) == len(names): names = [str(i) if name is None else name for i, name in enumerate(names)] univariates = ValIterOrderedDict(zip(names, univariates)) else: univariates = ValIterOrderedDict((str(i), v) for i, v in enumerate(univariates)) else: raise TypeError( "Expected univariates to be either a `Sequence[UnivariateTimeSeries]` or a " "`Mapping[Hashable, UnivariateTimeSeries]`." ) assert len(univariates) > 0 # Assign all the individual univariate series the appropriate names for name, var in univariates.items(): var.name = name # Set self.univariates and check if they are perfectly aligned self.univariates = univariates if check_aligned and self.dim > 1: t = self.univariates[self.names[0]].time_stamps self._is_aligned = all(self.univariates[name].time_stamps == t for name in self.names[1:]) else: self._is_aligned = len(univariates) <= 1 # Raise a warning if the univariates are too mis-aligned if check_aligned and not self.is_aligned: all_t0 = [var.index[0] for var in univariates if len(var) > 0] all_tf = [var.index[-1] for var in univariates if len(var) > 0] min_elapsed = min(tf - t0 for t0, tf in zip(all_t0, all_tf)) min_t0, max_t0 = min(all_t0), max(all_t0) min_tf, max_tf = min(all_tf), max(all_tf) if max_t0 - min_t0 > 0.1 * min_elapsed: logger.warning( f"The earliest univariate starts at {min_t0}, but the " f"latest univariate starts at {max_t0}, a difference of " f"{max_t0 - min_t0}. This is more than 10% of the length " f"of the shortest univariate ({min_elapsed}). You may " f"want to check that the univariates cover the same " f"window of time.", stack_info=True, ) if max_tf - min_tf > 0.1 * min_elapsed: logger.warning( f"The earliest univariate ends at {min_tf}, but the " f"latest univariate ends at {max_tf}, a difference of " f"{max_tf - min_tf}. This is more than 10% of the length " f"of the shortest univariate ({min_elapsed}). You may " f"want to check that the univariates cover the same " f"window of time.", stack_info=True, ) def names(self): """:return: The list of the names of the univariates.""" return list(self.univariates.keys()) def items(self): """:return: Iterator over ``(name, univariate)`` tuples.""" return self.univariates.items() def dim(self) -> int: """ :return: The dimension of the time series (the number of variables). """ return len(self.univariates) def rename(self, mapper: Union[Iterable[str], Mapping[str, str], Callable[[str], str]]): """ :param mapper: Dict-like or function transformations to apply to the univariate names. Can also be an iterable of new univariate names. :return: the time series with renamed univariates. """ if isinstance(mapper, Callable): mapper = [mapper(old) for old in self.names] elif isinstance(mapper, Mapping): mapper = [mapper.get(old, old) for old in self.names] univariates = ValIterOrderedDict((new_name, var) for new_name, var in zip(mapper, self.univariates)) return self.__class__(univariates) def is_aligned(self) -> bool: """ :return: Whether all individual variable time series are sampled at the same time stamps, i.e. they are aligned. """ return self._is_aligned def index(self): return to_pd_datetime(self.np_time_stamps) def np_time_stamps(self): """ :rtype: np.ndarray :return: the ``numpy`` representation of this time series's Unix timestamps """ return np.unique(np.concatenate([var.np_time_stamps for var in self.univariates])) def time_stamps(self): """ :rtype: List[float] :return: the list of Unix timestamps for the time series """ return self.np_time_stamps.tolist() def t0(self) -> float: """ :rtype: float :return: the first timestamp in the time series. """ return min(var.t0 for var in self.univariates) def tf(self) -> float: """ :rtype: float :return: the final timestamp in the time series. """ return max(var.tf for var in self.univariates) def _txs_to_vec(txs): """ Helper function that converts [(t_1[i], x_1[i]), ..., (t_k[i], x_k[i])], i.e. [var[i] for var in self.univariates], into the desired output form (t_1[i], (x_1[i], ..., x_k[i])). """ return txs[0][0], tuple(tx[1] for tx in txs) def __iter__(self): """ Only supported if all individual variable time series are sampled at the same time stamps. The i'th item of the iterator is the tuple ``(time_stamps[i], tuple(var.values[i] for var in self.univariates))``. """ if not self.is_aligned: raise RuntimeError( "The univariates comprising this time series are not aligned " "(they have different time stamps), but alignment is required " "to iterate over the time series." ) return map(self._txs_to_vec, zip(*self.univariates)) def __getitem__(self, i: Union[int, slice]): """ Only supported if all individual variable time series are sampled at the same time stamps. :param i: integer index or slice. :rtype: Union[Tuple[float, Tuple[float]], TimeSeries] :return: If ``i`` is an integer, returns the tuple ``(time_stamps[i], tuple(var.values[i] for var in self.univariates))``. If ``i`` is a slice, returns the time series ``TimeSeries([var[i] for var in self.univariates])`` """ if not self.is_aligned: raise RuntimeError( "The univariates comprising this time series are not aligned " "(they have different time stamps), but alignment is required " "to index into the time series." ) if isinstance(i, int): return self._txs_to_vec([var[i] for var in self.univariates]) elif isinstance(i, slice): # ret must be aligned, so bypass the (potentially) expensive check univariates = ValIterOrderedDict([(k, v[i]) for k, v in self.items()]) ret = TimeSeries(univariates, check_aligned=False) ret._is_aligned = True return ret else: raise KeyError( f"Indexing a `TimeSeries` with key {i} of type " f"{type(i).__name__} not supported. Perhaps you " f"meant to index into `time_series.univariates`, " f"rather than `time_series`?" ) def is_empty(self) -> bool: """ :return: whether the time series is empty """ return all(len(var) == 0 for var in self.univariates) def squeeze(self) -> UnivariateTimeSeries: """ :return: `UnivariateTimeSeries` if the time series is univariate; otherwise returns itself, a `TimeSeries` """ if self.dim == 1: return self.univariates[self.names[0]] return self def __len__(self): """ :return: the number of observations in the time series """ if not self.is_aligned: warning = ( "The univariates comprising this time series are not aligned " "(they have different time stamps). The length returned is " "equal to the length of the _union_ of all time stamps present " "in any of the univariates." ) warnings.warn(warning) logger.warning(warning) return len(self.to_pd()) return len(self.univariates[self.names[0]]) def shape(self) -> Tuple[int, int]: """ :return: the shape of this time series, i.e. ``(self.dim, len(self))`` """ return self.dim, len(self) def __add__(self, other): """ Concatenates the `TimeSeries` ``other`` to the right of this one. :param TimeSeries other: :rtype: TimeSeries :return: concatenated time series """ return self.concat(other, axis=0) def concat(self, other, axis=0): """ Concatenates the `TimeSeries` ``other`` on the time axis if ``axis = 0`` or the variable axis if ``axis = 1``. :rtype: TimeSeries :return: concatenated time series """ assert axis in [0, 1] if axis == 0: assert self.dim == other.dim, ( f"Cannot concatenate a {self.dim}-dimensional time series with a {other.dim}-dimensional " f"time series on the time axis." ) assert self.names == other.names, ( f"Cannot concatenate time series on the time axis if they have two different sets of " f"variable names, {self.names} and {other.names}." ) univariates = ValIterOrderedDict( [(name, ts0.concat(ts1)) for (name, ts0), ts1 in zip(self.items(), other.univariates)] ) ret = TimeSeries(univariates, check_aligned=False) ret._is_aligned = self.is_aligned and other.is_aligned return ret else: univariates = ValIterOrderedDict([(name, var.copy()) for name, var in [*self.items(), other.items()]]) ret = TimeSeries(univariates, check_aligned=False) ret._is_aligned = self.is_aligned and other.is_aligned and self.time_stamps == other.time_stamps return ret def __eq__(self, other): if self.dim != other.dim: return False return all(u == v for u, v in zip(self.univariates, other.univariates)) def __repr__(self): return repr(self.to_pd()) def bisect(self, t: float, t_in_left: bool = False): """ Splits the time series at the point where the given timestamp ``t`` occurs. :param t: a Unix timestamp or datetime object. Everything before time ``t`` is in the left split, and everything after time ``t`` is in the right split. :param t_in_left: if ``True``, ``t`` is in the left split. Otherwise, ``t`` is in the right split. :rtype: Tuple[TimeSeries, TimeSeries] :return: the left and right splits of the time series. """ left, right = ValIterOrderedDict(), ValIterOrderedDict() for name, var in self.items(): left[name], right[name] = var.bisect(t, t_in_left) if self.is_aligned: left = TimeSeries(left, check_aligned=False) right = TimeSeries(right, check_aligned=False) left._is_aligned = True right._is_aligned = True return left, right else: return TimeSeries(left), TimeSeries(right) def window(self, t0: float, tf: float, include_tf: bool = False): """ :param t0: The timestamp/datetime at the start of the window (inclusive) :param tf: The timestamp/datetime at the end of the window (inclusive if ``include_tf`` is ``True``, non-inclusive otherwise) :param include_tf: Whether to include ``tf`` in the window. :return: The subset of the time series occurring between timestamps ``t0`` (inclusive) and ``tf`` (included if ``include_tf`` is ``True``, excluded otherwise). :rtype: `TimeSeries` """ return TimeSeries(ValIterOrderedDict([(k, var.window(t0, tf, include_tf)) for k, var in self.items()])) def to_pd(self) -> pd.DataFrame: """ :return: A pandas DataFrame (indexed by time) which represents this time series. Each variable corresponds to a column of the DataFrame. Timestamps which are present for one variable but not another, are represented with NaN. """ t = pd.DatetimeIndex([]) univariates = [(name, var.to_pd()[~var.index.duplicated()]) for name, var in self.items()] for _, var in univariates: t = t.union(var.index) t = t.sort_values() t.name = _time_col_name if len(t) >= 3: t.freq = pd.infer_freq(t) df = pd.DataFrame(np.full((len(t), len(univariates)), np.nan), index=t, columns=self.names) for name, var in univariates: df.loc[var.index, name] = var[~var.index.duplicated()] return df def to_csv(self, file_name, **kwargs): self.to_pd().to_csv(file_name, **kwargs) def from_pd(cls, df: Union[pd.Series, pd.DataFrame, np.ndarray], check_times=True, drop_nan=True, freq="1h"): """ :param df: A ``pandas.DataFrame`` with a ``DatetimeIndex``. Each column corresponds to a different variable of the time series, and the key of column (in sorted order) give the relative order of those variables in ``self.univariates``. Missing values should be represented with ``NaN``. May also be a ``pandas.Series`` for single-variable time series. :param check_times: whether to check that all times in the index are unique (up to the millisecond) and sorted. :param drop_nan: whether to drop all ``NaN`` entries before creating the time series. Specifying ``False`` is useful if you wish to impute the values on your own. :param freq: if ``df`` is not indexed by time, this is the frequency at which we will assume it is sampled. :rtype: TimeSeries :return: the `TimeSeries` object corresponding to ``df``. """ if df is None: return None elif isinstance(df, TimeSeries): return df elif isinstance(df, UnivariateTimeSeries): return cls([df]) elif isinstance(df, pd.Series): if drop_nan: df = df[~df.isna()] return cls({df.name: UnivariateTimeSeries.from_pd(df)}) elif isinstance(df, np.ndarray): arr = df.reshape(len(df), -1).T ret = cls([UnivariateTimeSeries(time_stamps=None, values=v, freq=freq) for v in arr], check_aligned=False) ret._is_aligned = True return ret elif not isinstance(df, pd.DataFrame): df = pd.DataFrame(df) # Time series is not aligned iff there are missing values aligned = df.shape[1] == 1 or not df.isna().any().any() # Check for a string-type index if df.index.dtype == "O": df = df.copy() df.index = pd.to_datetime(df.index) # Make sure there are no time duplicates (by milliseconds) if desired dt_index = isinstance(df.index, pd.DatetimeIndex) if check_times: if not df.index.is_unique: df = df[~df.index.duplicated()] if not df.index.is_monotonic_increasing: df = df.sort_index() if dt_index: times = df.index.values.astype("datetime64[ms]").astype(np.int64) df = df.reindex(pd.to_datetime(np.unique(times), unit="ms"), method="bfill") elif not aligned and not dt_index and df.index.dtype not in ("int64", "float64"): raise RuntimeError( f"We only support instantiating time series from a " f"``pd.DataFrame`` with missing values when the data frame is " f"indexed by time, int, or float. This dataframe's index is of " f"type {type(df.index).__name__}" ) if drop_nan and not aligned: ret = cls( ValIterOrderedDict( [(k, UnivariateTimeSeries.from_pd(ser[~ser.isna()], freq=freq)) for k, ser in df.items()] ), check_aligned=False, ) else: ret = cls( ValIterOrderedDict([(k, UnivariateTimeSeries.from_pd(ser, freq=freq)) for k, ser in df.items()]), check_aligned=False, ) ret._is_aligned = aligned return ret def from_ts_list(cls, ts_list, *, check_aligned=True): """ :param Iterable[TimeSeries] ts_list: iterable of time series we wish to form a multivariate time series with :param bool check_aligned: whether to check if the output time series is aligned :rtype: TimeSeries :return: A multivariate `TimeSeries` created from all the time series in the inputs. """ ts_list = list(ts_list) all_names = [set(ts.names) for ts in ts_list] if all( len(names_i.intersection(names_j)) == 0 for i, names_i in enumerate(all_names) for names_j in all_names[i + 1 :] ): univariates = ValIterOrderedDict(itertools.chain.from_iterable(ts.items() for ts in ts_list)) else: univariates = list(itertools.chain.from_iterable(ts.univariates for ts in ts_list)) return cls(univariates, check_aligned=check_aligned) def align( self, *, reference: Sequence[Union[int, float]] = None, granularity: Union[str, int, float] = None, origin: int = None, remove_non_overlapping=True, alignment_policy: AlignPolicy = None, aggregation_policy: AggregationPolicy = AggregationPolicy.Mean, missing_value_policy: MissingValuePolicy = MissingValuePolicy.Interpolate, ): """ Aligns all the univariates comprising this multivariate time series so that they all have the same time stamps. :param reference: A specific set of timestamps we want the resampled time series to contain. Required if ``alignment_policy`` is `AlignPolicy.FixedReference`. Overrides other alignment policies if specified. :param granularity: The granularity (in seconds) of the resampled time time series. Defaults to the GCD time difference between adjacent elements of ``time_series`` (otherwise). Ignored if ``reference`` is given or ``alignment_policy`` is `AlignPolicy.FixedReference`. Overrides other alignment policies if specified. :param origin: The first timestamp of the resampled time series. Only used if the alignment policy is `AlignPolicy.FixedGranularity`. :param remove_non_overlapping: If ``True``, we will only keep the portions of the univariates that overlap with each other. For example, if we have 3 univariates which span timestamps [0, 3600], [60, 3660], and [30, 3540], we will only keep timestamps in the range [60, 3540]. If ``False``, we will keep all timestamps produced by the resampling. :param alignment_policy: The policy we want to use to align the time series. - `AlignPolicy.FixedReference` aligns each single-variable time series to ``reference``, a user-specified sequence of timestamps. - `AlignPolicy.FixedGranularity` resamples each single-variable time series at the same granularity, aggregating windows and imputing missing values as desired. - `AlignPolicy.OuterJoin` returns a time series with the union of all timestamps present in any single-variable time series. - `AlignPolicy.InnerJoin` returns a time series with the intersection of all timestamps present in all single-variable time series. :param aggregation_policy: The policy used to aggregate windows of adjacent observations when downsampling. :param missing_value_policy: The policy used to impute missing values created when upsampling. :rtype: TimeSeries :return: The resampled multivariate time series. """ if self.is_empty(): if reference is not None or granularity is not None: logger.warning( "Attempting to align an empty time series to a set of reference time stamps or a " "fixed granularity. Doing nothing." ) return TimeSeries.from_pd(self.to_pd()) if reference is not None or alignment_policy is AlignPolicy.FixedReference: if reference is None: raise RuntimeError("`reference` is required when using `alignment_policy` FixedReference.") if alignment_policy not in [None, AlignPolicy.FixedReference]: logger.warning( f"TimeSeries.align() received alignment policy " f"{alignment_policy.name}, but a reference sequence of " f"timestamps was also provided. `reference` is higher " f"priority than `alignment_policy`, so we are using " f"alignment policy FixedReference." ) if granularity is not None: logger.warning( "TimeSeries.align() received a granularity at which to " "resample the time series, but a reference sequence of " "timestamps was also provided. `reference` is higher " "priority than `granularity`, so we are using alignment " "policy FixedReference, not FixedGranularity." ) # Align each univariate time series to the reference timestamps df = reindex_df(self.to_pd(), reference, missing_value_policy) return TimeSeries.from_pd(df, check_times=False) elif granularity is not None or alignment_policy is AlignPolicy.FixedGranularity: if alignment_policy not in [None, AlignPolicy.FixedGranularity]: logger.warning( f"TimeSeries.align() received alignment policy " f"{alignment_policy.name}, but a desired granularity at " f"which to resample the time series was also received. " f"`granularity` is higher priority than `alignment_policy`, " f"so we are using alignment policy FixedGranularity." ) # Get the granularity in seconds, if one is specified and the granularity is a fixed number of seconds. # Otherwise, infer the granularity. If we have a non-fixed granularity, record that fact. fixed_granularity = True if granularity is None: granularity = infer_granularity(self.time_stamps) granularity = to_offset(granularity) if isinstance(granularity, pd.DateOffset): try: granularity.nanos except ValueError: fixed_granularity = False # Remove non-overlapping portions of univariates if desired df = self.to_pd() if remove_non_overlapping: t0 = max(v.index[0] for v in self.univariates if len(v) > 0) tf = min(v.index[-1] for v in self.univariates if len(v) > 0) df = df[t0:tf] # Resample at the desired granularity, setting the origin as needed if origin is None and isinstance(granularity, pd.Timedelta): elapsed = df.index[-1] - df.index[0] origin = df.index[0] + elapsed % granularity direction = None if not fixed_granularity else "right" new_df = df.resample(granularity, origin=to_pd_datetime(origin), label=direction, closed=direction) # Apply aggregation & missing value imputation policies new_df = aggregation_policy.value(new_df) if missing_value_policy is MissingValuePolicy.Interpolate and not fixed_granularity: new_df = new_df.interpolate() else: new_df = missing_value_policy.value(new_df) # Add the date offset only if we're resampling to a non-fixed granularity if not fixed_granularity: new_df.index += get_date_offset(time_stamps=new_df.index, reference=df.index) # Do any forward-filling/back-filling to cover all the indices return TimeSeries.from_pd(new_df[df.index[0] : df.index[-1]].ffill().bfill(), check_times=False) elif alignment_policy in [None, AlignPolicy.OuterJoin]: # Outer join is the union of all timestamps appearing in any of the # univariate time series. We just need to apply the missing value # policy to self.to_pd() (and bfill()/ffill() to take care of any # additional missing values at the start/end), and then return # from_pd(). df = missing_value_policy.value(self.to_pd()) if remove_non_overlapping: t0 = max(v.index[0] for v in self.univariates if len(v) > 0) tf = min(v.index[-1] for v in self.univariates if len(v) > 0) df = df[t0:tf] else: df = df.ffill().bfill() return TimeSeries.from_pd(df, check_times=False) elif alignment_policy is AlignPolicy.InnerJoin: # Inner join is the intersection of all the timestamps appearing in # all of the univariate time series. Just get the indexes of the # univariate sub time series where all variables are present. # TODO: add a resampling step instead of just indexing? ts = [set(var.np_time_stamps) for var in self.univariates] t = ts[0] for tprime in ts[1:]: t = t.intersection(tprime) if len(t) == 0: raise RuntimeError( "No time stamps are shared between all variables! Try again with a different alignment policy." ) t = to_pd_datetime(sorted(t)) return TimeSeries.from_pd(self.to_pd().loc[t], check_times=False) else: raise RuntimeError(f"Alignment policy {alignment_policy.name} not supported") The provided code snippet includes necessary dependencies for implementing the `minT_reconciliation` function. Write a Python function `def minT_reconciliation( forecasts: List[TimeSeries], errs: List[TimeSeries], sum_matrix: np.ndarray, n_leaves: int ) -> List[TimeSeries]` to solve the following problem: Computes the minimum trace reconciliation for hierarchical time series, as described by `Wickramasuriya et al. 2018 <https://robjhyndman.com/papers/mint.pdf>`__. This algorithm assumes that we have a number of time series aggregated at various levels (the aggregation tree is described by ``sum_matrix``), and we obtain independent forecasts at each level of the hierarchy. Minimum trace reconciliation finds the optimal way to adjust (reconcile) the forecasts to reduce the variance of the estimation. :param forecasts: forecast for each aggregation level of the hierarchy :param errs: standard errors of forecasts for each level of the hierarchy. While not strictly necessary, reconciliation performs better if all forecasts are accompanied by uncertainty estimates. :param sum_matrix: matrix describing how the hierarchy is aggregated :param n_leaves: the number of leaf forecasts (i.e. the number of forecasts at the most dis-aggregated level of the hierarchy). We assume that the leaf forecasts are last in the lists ``forecasts`` & ``errs``, and that ``sum_matrix`` reflects this fact. :return: reconciled forecasts for each aggregation level of the hierarchy Here is the function: def minT_reconciliation( forecasts: List[TimeSeries], errs: List[TimeSeries], sum_matrix: np.ndarray, n_leaves: int ) -> List[TimeSeries]: """ Computes the minimum trace reconciliation for hierarchical time series, as described by `Wickramasuriya et al. 2018 <https://robjhyndman.com/papers/mint.pdf>`__. This algorithm assumes that we have a number of time series aggregated at various levels (the aggregation tree is described by ``sum_matrix``), and we obtain independent forecasts at each level of the hierarchy. Minimum trace reconciliation finds the optimal way to adjust (reconcile) the forecasts to reduce the variance of the estimation. :param forecasts: forecast for each aggregation level of the hierarchy :param errs: standard errors of forecasts for each level of the hierarchy. While not strictly necessary, reconciliation performs better if all forecasts are accompanied by uncertainty estimates. :param sum_matrix: matrix describing how the hierarchy is aggregated :param n_leaves: the number of leaf forecasts (i.e. the number of forecasts at the most dis-aggregated level of the hierarchy). We assume that the leaf forecasts are last in the lists ``forecasts`` & ``errs``, and that ``sum_matrix`` reflects this fact. :return: reconciled forecasts for each aggregation level of the hierarchy """ m = len(forecasts) n = n_leaves assert len(errs) == m > n assert all(yhat.dim == 1 for yhat in forecasts) assert sum_matrix.shape == (m, n), f"Expected sum_matrix to have shape ({m}, {n}) got {sum_matrix.shape}" assert (sum_matrix[-n:] == np.eye(n)).all() # Convert forecasts to a single aligned multivariate time series names = [yhat.names[0] for yhat in forecasts] forecasts = OrderedDict((i, yhat.univariates[yhat.names[0]]) for i, yhat in enumerate(forecasts)) forecasts = TimeSeries(univariates=forecasts).align() t_ref = forecasts.time_stamps H = len(forecasts) # Matrix of stderrs (if any) at each prediction horizon. shape is [m, H]. # If no stderrs are given, we the estimation error is proportional to the number of leaf nodes being combined. coefs = sum_matrix.sum(axis=1) if all(e is None for e in errs): # FIXME: This heuristic can be improved if training errors are given. # However, the model code should probably be responsible for this, not the reconciliation code. Wh = [np.diag(coefs) for _ in range(H)] else: coefs = coefs.reshape(-1, 1) errs = np.asarray( [np.full(H, np.nan) if e is None else e.align(reference=t_ref).to_pd().values.flatten() ** 2 for e in errs] ) # [m, H] # Replace NaN's w/ the mean of non-NaN stderrs & create diagonal error matrices nan_errs = np.isnan(errs[:, 0]) if nan_errs.any(): errs[nan_errs] = np.nanmean(errs / coefs, axis=0) * coefs[nan_errs] Wh = [np.diag(errs[:, h]) for h in range(H)] # Create other supplementary matrices J = np.zeros((n, m)) J[:, -n:] = np.eye(n) U = np.zeros((m - n, m)) U[:, : m - n] = np.eye(m - n) U[:, m - n :] = -sum_matrix[:-n] # Compute projection matrices to compute coherent leaf forecasts Ph = [] for W in Wh: inv = np.linalg.inv(U @ W @ U.T) P = J - ((J @ W) @ U.T) @ (inv @ U) Ph.append(P) # Compute reconciled forecasts reconciled = [] for (t, yhat_h), P in zip(forecasts, Ph): reconciled.append(sum_matrix @ (P @ yhat_h)) reconciled = pd.DataFrame(np.asarray(reconciled), index=to_pd_datetime(t_ref)) return [u.to_ts(name=name) for u, name in zip(TimeSeries.from_pd(reconciled).univariates, names)]

Computes the minimum trace reconciliation for hierarchical time series, as described by `Wickramasuriya et al. 2018 <https://robjhyndman.com/papers/mint.pdf>`__. This algorithm assumes that we have a number of time series aggregated at various levels (the aggregation tree is described by ``sum_matrix``), and we obtain independent forecasts at each level of the hierarchy. Minimum trace reconciliation finds the optimal way to adjust (reconcile) the forecasts to reduce the variance of the estimation. :param forecasts: forecast for each aggregation level of the hierarchy :param errs: standard errors of forecasts for each level of the hierarchy. While not strictly necessary, reconciliation performs better if all forecasts are accompanied by uncertainty estimates. :param sum_matrix: matrix describing how the hierarchy is aggregated :param n_leaves: the number of leaf forecasts (i.e. the number of forecasts at the most dis-aggregated level of the hierarchy). We assume that the leaf forecasts are last in the lists ``forecasts`` & ``errs``, and that ``sum_matrix`` reflects this fact. :return: reconciled forecasts for each aggregation level of the hierarchy

import argparse import copy import json import logging import os import sys import time import git from typing import Tuple import matplotlib.pyplot as plt import numpy as np import pandas as pd from tqdm import tqdm from merlion.evaluate.anomaly import ( TSADEvaluatorConfig, accumulate_tsad_score, TSADScoreAccumulator as ScoreAcc, TSADEvaluator, ) from merlion.models.anomaly.base import DetectorBase from merlion.models.ensemble.anomaly import DetectorEnsemble from merlion.evaluate.anomaly import TSADMetric, ScoreType from merlion.models.factory import ModelFactory from merlion.transform.resample import TemporalResample from merlion.utils import TimeSeries from merlion.utils.resample import to_pd_datetime from ts_datasets.anomaly import * CONFIG_JSON = os.path.join(MERLION_ROOT, "conf", "benchmark_anomaly.json") class TSADMetric(Enum): def parse_args(): with open(CONFIG_JSON, "r") as f: valid_models = list(json.load(f).keys()) parser = argparse.ArgumentParser( description="Script to benchmark Merlion time series anomaly detection " "models. This script assumes that you have pip installed " "both merlion (this repo's main package) and ts_datasets " "(a sub-repo)." ) parser.add_argument( "--dataset", default="NAB_all", help="Name of dataset to run benchmark on. See get_dataset() " "in ts_datasets/ts_datasets/anomaly/__init__.py for " "valid options.", ) parser.add_argument("--data_root", default=None, help="Root directory/file of dataset.") parser.add_argument("--data_kwargs", default="{}", help="JSON of keyword arguemtns for the data loader.") parser.add_argument( "--models", type=str, nargs="+", default=["DefaultDetector"], help="Name of model (or models in ensemble) to benchmark.", choices=valid_models, ) parser.add_argument( "--retrain_freq", type=str, default="default", help="String (e.g. 1d, 2w, etc.) specifying how often " "to re-train the model before evaluating it on " "the next window of data. Note that re-training " "is unsupervised, i.e. does not use ground truth " "anomaly labels in any way. Default retrain_freq is " "1d for univariate data and None for multivariate.", ) parser.add_argument( "--train_window", type=str, default=None, help="String (e.g. 30d, 6m, etc.) specifying how much " "data (in terms of a time window) the model " "should train on at any point.", ) parser.add_argument( "--metric", type=str, default="F1", choices=list(TSADMetric.__members__.keys()), help="Metric to optimize for (where relevant)", ) parser.add_argument( "--point_adj_metric", type=str, default="PointAdjustedF1", choices=list(TSADMetric.__members__.keys()), help="Final metric to optimize for when evaluating point-adjusted performance", ) parser.add_argument( "--pointwise_metric", type=str, default="PointwiseF1", choices=list(TSADMetric.__members__.keys()), help="Final metric to optimize for when evaluating pointwise performance", ) parser.add_argument("--unsupervised", action="store_true") parser.add_argument( "--tune_on_test", action="store_true", default=False, help="Whether to tune the threshold on both train and " "test splits of the time series. Useful for " "metrics like Best F1, or NAB score with " "threshold optimization.", ) parser.add_argument( "--load_checkpoint", action="store_true", default=False, help="Specify this option if you would like continue " "training your model on a dataset from a " "checkpoint, instead of restarting from scratch.", ) parser.add_argument( "--eval_only", action="store_true", default=False, help="Specify this option if you would like to skip " "the model training phase, and simply evaluate " "on partial saved results.", ) parser.add_argument("--debug", action="store_true", default=False, help="Whether to enable INFO-level logs.") parser.add_argument( "--visualize", action="store_true", default=False, help="Whether to plot the model's predictions after " "training on each example. Mutually exclusive " "with running any sort of evaluation.", ) args = parser.parse_args() args.metric = TSADMetric[args.metric] args.pointwise_metric = TSADMetric[args.pointwise_metric] args.visualize = args.visualize and not args.eval_only args.data_kwargs = json.loads(args.data_kwargs) assert isinstance(args.data_kwargs, dict) if args.retrain_freq.lower() in ["", "none", "null"]: args.retrain_freq = None elif args.retrain_freq != "default": rf = pd.to_timedelta(args.retrain_freq).total_seconds() if rf % (3600 * 24) == 0: args.retrain_freq = f"{int(rf/3600/24)}d" elif rf % 3600 == 0: args.retrain_freq = f"{int(rf/3600)}h" elif rf % 60 == 0: args.retrain_freq = f"{int(rf//60)}min" else: args.retrain_freq = f"{int(rf)}s" return args

import argparse import copy import json import logging import os import sys import time import git from typing import Tuple import matplotlib.pyplot as plt import numpy as np import pandas as pd from tqdm import tqdm from merlion.evaluate.anomaly import ( TSADEvaluatorConfig, accumulate_tsad_score, TSADScoreAccumulator as ScoreAcc, TSADEvaluator, ) from merlion.models.anomaly.base import DetectorBase from merlion.models.ensemble.anomaly import DetectorEnsemble from merlion.evaluate.anomaly import TSADMetric, ScoreType from merlion.models.factory import ModelFactory from merlion.transform.resample import TemporalResample from merlion.utils import TimeSeries from merlion.utils.resample import to_pd_datetime from ts_datasets.anomaly import * logger = logging.getLogger(__name__) def get_dataset_name(dataset: TSADBaseDataset): name = type(dataset).__name__ if hasattr(dataset, "subset") and dataset.subset is not None: name += "_" + dataset.subset if isinstance(dataset, CustomAnomalyDataset): root = dataset.rootdir name = os.path.join(name, os.path.basename(os.path.dirname(root) if os.path.isfile(root) else root)) return name def resolve_model_name(model_name: str): with open(CONFIG_JSON, "r") as f: config_dict = json.load(f) if model_name not in config_dict: raise NotImplementedError( f"Benchmarking not implemented for model {model_name}. Valid model names are {list(config_dict.keys())}" ) while "alias" in config_dict[model_name]: assert model_name != config_dict[model_name]["alias"], "Alias name cannot be the same as the model name" model_name = config_dict[model_name]["alias"] return model_name def get_model( model_name: str, dataset: TSADBaseDataset, metric: TSADMetric, tune_on_test=False, unsupervised=False ) -> Tuple[DetectorBase, dict]: with open(CONFIG_JSON, "r") as f: config_dict = json.load(f) if model_name not in config_dict: raise NotImplementedError( f"Benchmarking not implemented for model {model_name}. Valid model names are {list(config_dict.keys())}" ) while "alias" in config_dict[model_name]: model_name = config_dict[model_name]["alias"] # Load the model with default kwargs, but override with dataset-specific # kwargs where relevant model_configs = config_dict[model_name]["config"] model_type = config_dict[model_name].get("model_type", model_name) model_kwargs = model_configs["default"] model_kwargs.update(model_configs.get(type(dataset).__name__, {})) model = ModelFactory.create(name=model_type, **model_kwargs) # The post-rule train configs are fully specified for each dataset (where # relevant), with a default option if there is no dataset-specific option. post_rule_train_configs = config_dict[model_name].get("post_rule_train_config", {}) d = post_rule_train_configs.get("default", {}) d.update(post_rule_train_configs.get(type(dataset).__name__, {})) if len(d) == 0: d = copy.copy(model._default_post_rule_train_config) d["metric"] = None if unsupervised else metric d.update({"max_early_sec": dataset.max_lead_sec, "max_delay_sec": dataset.max_lag_sec}) t = dataset_to_threshold(dataset, tune_on_test) model.threshold.alm_threshold = t d["unsup_quantile"] = None return model, d def df_to_merlion(df: pd.DataFrame, md: pd.DataFrame, get_ground_truth=False, transform=None) -> TimeSeries: """Converts a pandas dataframe time series to the Merlion format.""" if get_ground_truth: if False and "changepoint" in md.keys(): series = md["anomaly"] | md["changepoint"] else: series = md["anomaly"] else: series = df time_series = TimeSeries.from_pd(series) if transform is not None: time_series = transform(time_series) return time_series def get_code_version_info(): return dict(time=str(pd.Timestamp.now()), commit=git.Repo(search_parent_directories=True).head.object.hexsha) class ScoreType(Enum): """ The algorithm to use to compute true/false positives/negatives. See the technical report for more details on each score type. Merlion's preferred default is revised point-adjusted. """ Pointwise = 0 PointAdjusted = 1 RevisedPointAdjusted = 2 class TSADEvaluatorConfig(EvaluatorConfig): """ Configuration class for a `TSADEvaluator`. """ def __init__(self, max_early_sec: float = None, max_delay_sec: float = None, **kwargs): """ :param max_early_sec: the maximum number of seconds we allow an anomaly to be detected early. :param max_delay_sec: if an anomaly is detected more than this many seconds after its start, it is not counted as being detected. """ super().__init__(**kwargs) self.max_early_sec = max_early_sec self.max_delay_sec = max_delay_sec class TemporalResample(TransformBase): """ Defines a policy to temporally resample a time series at a specified granularity. Note that while this transform does support inversion, the recovered time series may differ from the input due to information loss when resampling. """ def __init__( self, granularity: Union[str, int, float] = None, origin: int = None, trainable_granularity: bool = None, remove_non_overlapping=True, aggregation_policy: Union[str, AggregationPolicy] = "Mean", missing_value_policy: Union[str, MissingValuePolicy] = "Interpolate", ): """ Defines a policy to temporally resample a time series. :param granularity: The granularity at which we want to resample. :param origin: The time stamp defining the offset to start at. :param trainable_granularity: Whether we will automatically infer the granularity of the time series. If ``None`` (default), it will be trainable only if no granularity is explicitly given. :param remove_non_overlapping: If ``True``, we will only keep the portions of the univariates that overlap with each other. For example, if we have 3 univariates which span timestamps [0, 3600], [60, 3660], and [30, 3540], we will only keep timestamps in the range [60, 3540]. If ``False``, we will keep all timestamps produced by the resampling. :param aggregation_policy: The policy we will use to aggregate multiple values in a window (downsampling). :param missing_value_policy: The policy we will use to impute missing values (upsampling). """ super().__init__() self.granularity = granularity self.origin = origin self.trainable_granularity = (granularity is None) if trainable_granularity is None else trainable_granularity self.remove_non_overlapping = remove_non_overlapping self.aggregation_policy = aggregation_policy self.missing_value_policy = missing_value_policy def requires_inversion_state(self): return False def proper_inversion(self): """ We treat resampling as a proper inversion to avoid emitting warnings. """ return True def granularity(self): return self._granularity def granularity(self, granularity): if not isinstance(granularity, (int, float)): try: granularity = granularity_str_to_seconds(granularity) except: granularity = getattr(granularity, "freqstr", granularity) self._granularity = granularity def aggregation_policy(self) -> AggregationPolicy: return self._aggregation_policy def aggregation_policy(self, agg: Union[str, AggregationPolicy]): if isinstance(agg, str): valid = set(AggregationPolicy.__members__.keys()) if agg not in valid: raise KeyError(f"{agg} is not a valid aggregation policy. Valid aggregation policies are: {valid}") agg = AggregationPolicy[agg] self._aggregation_policy = agg def missing_value_policy(self) -> MissingValuePolicy: return self._missing_value_policy def missing_value_policy(self, mv: Union[str, MissingValuePolicy]): if isinstance(mv, str): valid = set(MissingValuePolicy.__members__.keys()) if mv not in valid: raise KeyError(f"{mv} is not a valid missing value policy. Valid aggregation policies are: {valid}") mv = MissingValuePolicy[mv] self._missing_value_policy = mv def train(self, time_series: TimeSeries): if self.trainable_granularity: granularity = infer_granularity(time_series.np_time_stamps) logger.warning(f"Inferred granularity {granularity}") self.granularity = granularity if self.trainable_granularity or self.origin is None: t0, tf = time_series.t0, time_series.tf if isinstance(self.granularity, (int, float)): offset = (tf - t0) % self.granularity else: offset = 0 self.origin = t0 + offset def __call__(self, time_series: TimeSeries) -> TimeSeries: if self.granularity is None: logger.warning( f"Skipping resampling step because granularity is " f"None. Please either specify a granularity or train " f"this transformation on a time series." ) return time_series return time_series.align( alignment_policy=AlignPolicy.FixedGranularity, granularity=self.granularity, origin=self.origin, remove_non_overlapping=self.remove_non_overlapping, aggregation_policy=self.aggregation_policy, missing_value_policy=self.missing_value_policy, ) def to_pd_datetime(timestamp): """ Converts a timestamp (or list/iterable of timestamps) to pandas Datetime, truncated at the millisecond. """ if isinstance(timestamp, pd.DatetimeIndex): return timestamp elif isinstance(timestamp, (int, float)): return pd.to_datetime(int(timestamp * 1000), unit="ms") elif isinstance(timestamp, Iterable) and all(isinstance(t, (int, float)) for t in timestamp): timestamp = pd.to_datetime(np.asarray(timestamp).astype(float) * 1000, unit="ms") elif isinstance(timestamp, np.ndarray) and timestamp.dtype in [int, np.float32, np.float64]: timestamp = pd.to_datetime(np.asarray(timestamp).astype(float) * 1000, unit="ms") return pd.to_datetime(timestamp) The provided code snippet includes necessary dependencies for implementing the `train_model` function. Write a Python function `def train_model( model_name, metric, dataset, retrain_freq=None, train_window=None, load_checkpoint=False, visualize=False, debug=False, unsupervised=False, tune_on_test=False, )` to solve the following problem: Trains a model on the time series dataset given, and save their predictions to a dataset. Here is the function: def train_model( model_name, metric, dataset, retrain_freq=None, train_window=None, load_checkpoint=False, visualize=False, debug=False, unsupervised=False, tune_on_test=False, ): """Trains a model on the time series dataset given, and save their predictions to a dataset.""" resampler = None if isinstance(dataset, IOpsCompetition): resampler = TemporalResample("5min") model_name = resolve_model_name(model_name) dataset_name = get_dataset_name(dataset) model_dir = model_name if retrain_freq is None else f"{model_name}_{retrain_freq}" dirname = os.path.join("results", "anomaly", model_dir) csv = os.path.join(dirname, f"pred_{dataset_name}.csv.gz") config_fname = os.path.join(dirname, f"{dataset_name}_config.json") checkpoint = os.path.join(dirname, f"ckpt_{dataset_name}.txt") # Determine where to start within the dataset if there is a checkpoint i0 = 0 if os.path.isfile(checkpoint) and os.path.isfile(csv) and load_checkpoint: with open(checkpoint, "r") as f: i0 = int(f.read().rstrip("\n")) # Validate & sanitize the existing CSV checkpoint df = pd.read_csv(csv, dtype={"trainval": bool, "idx": int}) df = df[df["idx"] < i0] if set(df["idx"]) == set(range(i0)): df.to_csv(csv, index=False) else: i0 = 0 model = None for i, (df, md) in enumerate(tqdm(dataset)): if i < i0: continue # Reload model & get the train / test split for this time series model, post_rule_train_config = get_model( model_name=model_name, dataset=dataset, metric=metric, tune_on_test=tune_on_test, unsupervised=unsupervised ) delay = post_rule_train_config["max_delay_sec"] train_vals = df_to_merlion(df[md.trainval], md[md.trainval], get_ground_truth=False, transform=resampler) test_vals = df_to_merlion(df[~md.trainval], md[~md.trainval], get_ground_truth=False, transform=resampler) train_anom = df_to_merlion(df[md.trainval], md[md.trainval], get_ground_truth=True) test_anom = df_to_merlion(df[~md.trainval], md[~md.trainval], get_ground_truth=True) # Set up an evaluator & get predictions evaluator = TSADEvaluator( model=model, config=TSADEvaluatorConfig( train_window=train_window, retrain_freq=retrain_freq, max_delay_sec=delay, max_early_sec=getattr(model.threshold, "suppress_secs", delay), ), ) train_scores, test_scores = evaluator.get_predict( train_vals=train_vals, test_vals=test_vals, post_process=False, train_kwargs={"anomaly_labels": train_anom, "post_rule_train_config": post_rule_train_config}, ) # Write the model's predictions to the csv file, starting a new one # if we aren't loading an existing checkpoint. Scores from all time # series in the dataset are combined together in a single csv. Each # line in the csv corresponds to a point in a time series, and contains # the timestamp, raw anomaly score, and index of the time series. if not visualize: if i == i0 == 0: os.makedirs(os.path.dirname(csv), exist_ok=True) os.makedirs(os.path.dirname(checkpoint), exist_ok=True) df = pd.DataFrame({"timestamp": [], "y": [], "trainval": [], "idx": []}) df.to_csv(csv, index=False) df = pd.read_csv(csv) ts_df = pd.concat((train_scores.to_pd(), test_scores.to_pd())) ts_df.columns = ["y"] ts_df.loc[:, "timestamp"] = ts_df.index.view(int) // 1e9 ts_df.loc[:, "trainval"] = [j < len(train_scores) for j in range(len(ts_df))] ts_df.loc[:, "idx"] = i df = pd.concat((df, ts_df), ignore_index=True) df.to_csv(csv, index=False) # Start from time series i+1 if loading a checkpoint. with open(checkpoint, "w") as f: f.write(str(i + 1)) if visualize or debug: # Train the post-rule on the appropriate labels score = test_scores if tune_on_test else train_scores label = test_anom if tune_on_test else train_anom model.train_post_process( train_result=score, anomaly_labels=label, post_rule_train_config=post_rule_train_config ) # Log (many) evaluation metrics for the time series score_acc = evaluator.evaluate(ground_truth=test_anom, predict=model.threshold(test_scores)) mttd = score_acc.mean_time_to_detect() if mttd < pd.to_timedelta(0): mttd = f"-{-mttd}" logger.info(f"\nPerformance on time series {i+1}/{len(dataset)}") logger.info("Revised Point-Adjusted Metrics") logger.info(f"F1 Score: {score_acc.f1(score_type=ScoreType.RevisedPointAdjusted):.4f}") logger.info(f"Precision: {score_acc.precision(score_type=ScoreType.RevisedPointAdjusted):.4f}") logger.info(f"Recall: {score_acc.recall(score_type=ScoreType.RevisedPointAdjusted):.4f}\n") logger.info(f"Mean Time To Detect Anomalies: {mttd}") logger.info(f"Mean Detected Anomaly Duration: {score_acc.mean_detected_anomaly_duration()}") logger.info(f"Mean Anomaly Duration: {score_acc.mean_anomaly_duration()}\n") if debug: logger.info(f"Pointwise metrics") logger.info(f"F1 Score: {score_acc.f1(score_type=ScoreType.Pointwise):.4f}") logger.info(f"Precision: {score_acc.precision(score_type=ScoreType.Pointwise):.4f}") logger.info(f"Recall: {score_acc.recall(score_type=ScoreType.Pointwise):.4f}\n") logger.info("Point-Adjusted Metrics") logger.info(f"F1 Score: {score_acc.f1(score_type=ScoreType.PointAdjusted):.4f}") logger.info(f"Precision: {score_acc.precision(score_type=ScoreType.PointAdjusted):.4f}") logger.info(f"Recall: {score_acc.recall(score_type=ScoreType.PointAdjusted):.4f}\n") logger.info(f"NAB Scores") logger.info(f"NAB score (balanced): {score_acc.nab_score():.4f}") logger.info(f"NAB score (low FP): {score_acc.nab_score(fp_weight=0.22):.4f}") logger.info(f"NAB score (low FN): {score_acc.nab_score(fn_weight=2.0):.4f}\n") if visualize: # Make a plot alarms = model.threshold(test_scores) fig = model.get_figure(time_series=test_vals, time_series_prev=train_vals, plot_time_series_prev=True) fig.anom = alarms.univariates[alarms.names[0]] fig, ax = fig.plot(figsize=(1800, 600)) # Overlay windows indicating the true anomalies all_anom = train_anom + test_anom t, y = zip(*all_anom) y = np.asarray(y).flatten() splits = np.where(y[1:] != y[:-1])[0] + 1 splits = np.concatenate(([0], splits, [len(y) - 1])) anom_windows = [(splits[k], splits[k + 1]) for k in range(len(splits) - 1) if y[splits[k]]] for i_0, i_f in anom_windows: t_0 = to_pd_datetime(t[i_0]) t_f = to_pd_datetime(t[i_f]) ax.axvspan(t_0, t_f, color="#d07070", zorder=-1, alpha=0.5) time.sleep(2) plt.show() # Save full experimental config if model is not None and not visualize: full_config = dict( model_config=model.config.to_dict(), evaluator_config=evaluator.config.to_dict(), code_version_info=get_code_version_info(), ) os.makedirs(os.path.dirname(config_fname), exist_ok=True) with open(config_fname, "w") as f: json.dump(full_config, f, indent=2, sort_keys=True)

Trains a model on the time series dataset given, and save their predictions to a dataset.

import argparse import copy import json import logging import os import sys import time import git from typing import Tuple import matplotlib.pyplot as plt import numpy as np import pandas as pd from tqdm import tqdm from merlion.evaluate.anomaly import ( TSADEvaluatorConfig, accumulate_tsad_score, TSADScoreAccumulator as ScoreAcc, TSADEvaluator, ) from merlion.models.anomaly.base import DetectorBase from merlion.models.ensemble.anomaly import DetectorEnsemble from merlion.evaluate.anomaly import TSADMetric, ScoreType from merlion.models.factory import ModelFactory from merlion.transform.resample import TemporalResample from merlion.utils import TimeSeries from merlion.utils.resample import to_pd_datetime from ts_datasets.anomaly import * def get_dataset_name(dataset: TSADBaseDataset): name = type(dataset).__name__ if hasattr(dataset, "subset") and dataset.subset is not None: name += "_" + dataset.subset if isinstance(dataset, CustomAnomalyDataset): root = dataset.rootdir name = os.path.join(name, os.path.basename(os.path.dirname(root) if os.path.isfile(root) else root)) return name def to_pd_datetime(timestamp): """ Converts a timestamp (or list/iterable of timestamps) to pandas Datetime, truncated at the millisecond. """ if isinstance(timestamp, pd.DatetimeIndex): return timestamp elif isinstance(timestamp, (int, float)): return pd.to_datetime(int(timestamp * 1000), unit="ms") elif isinstance(timestamp, Iterable) and all(isinstance(t, (int, float)) for t in timestamp): timestamp = pd.to_datetime(np.asarray(timestamp).astype(float) * 1000, unit="ms") elif isinstance(timestamp, np.ndarray) and timestamp.dtype in [int, np.float32, np.float64]: timestamp = pd.to_datetime(np.asarray(timestamp).astype(float) * 1000, unit="ms") return pd.to_datetime(timestamp) The provided code snippet includes necessary dependencies for implementing the `read_model_predictions` function. Write a Python function `def read_model_predictions(dataset: TSADBaseDataset, model_dir: str)` to solve the following problem: Returns a list of lists all_preds, where all_preds[i] is the model's raw anomaly scores for time series i in the dataset. Here is the function: def read_model_predictions(dataset: TSADBaseDataset, model_dir: str): """ Returns a list of lists all_preds, where all_preds[i] is the model's raw anomaly scores for time series i in the dataset. """ csv = os.path.join("results", "anomaly", model_dir, f"pred_{get_dataset_name(dataset)}.csv.gz") preds = pd.read_csv(csv, dtype={"trainval": bool, "idx": int}) preds["timestamp"] = to_pd_datetime(preds["timestamp"]) return [preds[preds["idx"] == i].set_index("timestamp") for i in sorted(preds["idx"].unique())]

Returns a list of lists all_preds, where all_preds[i] is the model's raw anomaly scores for time series i in the dataset.

import argparse import copy import json import logging import os import sys import time import git from typing import Tuple import matplotlib.pyplot as plt import numpy as np import pandas as pd from tqdm import tqdm from merlion.evaluate.anomaly import ( TSADEvaluatorConfig, accumulate_tsad_score, TSADScoreAccumulator as ScoreAcc, TSADEvaluator, ) from merlion.models.anomaly.base import DetectorBase from merlion.models.ensemble.anomaly import DetectorEnsemble from merlion.evaluate.anomaly import TSADMetric, ScoreType from merlion.models.factory import ModelFactory from merlion.transform.resample import TemporalResample from merlion.utils import TimeSeries from merlion.utils.resample import to_pd_datetime from ts_datasets.anomaly import * def dataset_to_threshold(dataset: TSADBaseDataset, tune_on_test=False): if isinstance(dataset, IOpsCompetition): return 2.25 elif isinstance(dataset, NAB): return 3.5 elif isinstance(dataset, Synthetic): return 2 elif isinstance(dataset, MSL): return 3.0 elif isinstance(dataset, SMAP): return 3.5 elif isinstance(dataset, SMD): return 3 if not tune_on_test else 2.5 elif hasattr(dataset, "default_threshold"): return dataset.default_threshold return 3 def get_model( model_name: str, dataset: TSADBaseDataset, metric: TSADMetric, tune_on_test=False, unsupervised=False ) -> Tuple[DetectorBase, dict]: with open(CONFIG_JSON, "r") as f: config_dict = json.load(f) if model_name not in config_dict: raise NotImplementedError( f"Benchmarking not implemented for model {model_name}. Valid model names are {list(config_dict.keys())}" ) while "alias" in config_dict[model_name]: model_name = config_dict[model_name]["alias"] # Load the model with default kwargs, but override with dataset-specific # kwargs where relevant model_configs = config_dict[model_name]["config"] model_type = config_dict[model_name].get("model_type", model_name) model_kwargs = model_configs["default"] model_kwargs.update(model_configs.get(type(dataset).__name__, {})) model = ModelFactory.create(name=model_type, **model_kwargs) # The post-rule train configs are fully specified for each dataset (where # relevant), with a default option if there is no dataset-specific option. post_rule_train_configs = config_dict[model_name].get("post_rule_train_config", {}) d = post_rule_train_configs.get("default", {}) d.update(post_rule_train_configs.get(type(dataset).__name__, {})) if len(d) == 0: d = copy.copy(model._default_post_rule_train_config) d["metric"] = None if unsupervised else metric d.update({"max_early_sec": dataset.max_lead_sec, "max_delay_sec": dataset.max_lag_sec}) t = dataset_to_threshold(dataset, tune_on_test) model.threshold.alm_threshold = t d["unsup_quantile"] = None return model, d def df_to_merlion(df: pd.DataFrame, md: pd.DataFrame, get_ground_truth=False, transform=None) -> TimeSeries: """Converts a pandas dataframe time series to the Merlion format.""" if get_ground_truth: if False and "changepoint" in md.keys(): series = md["anomaly"] | md["changepoint"] else: series = md["anomaly"] else: series = df time_series = TimeSeries.from_pd(series) if transform is not None: time_series = transform(time_series) return time_series class ScoreType(Enum): """ The algorithm to use to compute true/false positives/negatives. See the technical report for more details on each score type. Merlion's preferred default is revised point-adjusted. """ Pointwise = 0 PointAdjusted = 1 RevisedPointAdjusted = 2 def accumulate_tsad_score( ground_truth: Union[TimeSeries, UnivariateTimeSeries], predict: Union[TimeSeries, UnivariateTimeSeries], max_early_sec=None, max_delay_sec=None, metric=None, ) -> Union[TSADScoreAccumulator, float]: """ Computes the components required to compute multiple different types of performance metrics for time series anomaly detection. :param ground_truth: A time series indicating whether each time step corresponds to an anomaly. :param predict: A time series with the anomaly score predicted for each time step. Detections correspond to nonzero scores. :param max_early_sec: The maximum amount of time (in seconds) the anomaly detection is allowed to occur before the actual incidence. If None, no early detections are allowed. Note that None is the same as 0. :param max_delay_sec: The maximum amount of time (in seconds) the anomaly detection is allowed to occur after the start of the actual incident (but before the end of the actual incident). If None, we allow any detection during the duration of the incident. Note that None differs from 0 because 0 means that we only permit detections that are early or exactly on time! :param metric: A function which takes a `TSADScoreAccumulator` as input and returns a ``float``. The `TSADScoreAccumulator` object is returned if ``metric`` is ``None``. """ ground_truth = ground_truth.to_ts() if isinstance(ground_truth, UnivariateTimeSeries) else ground_truth predict = predict.to_ts() if isinstance(predict, UnivariateTimeSeries) else predict assert ( ground_truth.dim == 1 and predict.dim == 1 ), "Can only evaluate anomaly scores when ground truth and prediction are single-variable time series." ground_truth = ground_truth.univariates[ground_truth.names[0]] ts = ground_truth.np_time_stamps ys = ground_truth.np_values.astype(bool) i_split = np.where(ys[1:] != ys[:-1])[0] + 1 predict = predict.univariates[predict.names[0]] ts_pred = predict.np_time_stamps ys_pred = predict.np_values.astype(bool) t = t_prev = ts[0] window_is_anomaly = ys[0] t0_anomaly, tf_anomaly = None, None num_tp_pointwise, num_tp_point_adj, num_tp_anom = 0, 0, 0 num_fn_pointwise, num_fn_point_adj, num_fn_anom = 0, 0, 0 num_tn, num_fp = 0, 0 tp_score, fp_score = 0.0, 0.0 tp_detection_delays, anom_durations, tp_anom_durations = [], [], [] for i in [*i_split, -1]: t_next = ts[i] + int(i == -1) # Determine the boundaries of the window # Add buffer if it's anomalous, remove buffer if it's not t0, tf = t, t_next if window_is_anomaly: t0_anomaly, tf_anomaly = t0, tf if max_early_sec is not None and max_early_sec > 0: t0 = max(t_prev, t - max_early_sec) if max_delay_sec is not None and max_delay_sec > 0 and i != -1: tf = min(t_next, t + max_delay_sec) else: if max_delay_sec is not None and max_delay_sec > 0: t0 = min(t, t_prev + max_delay_sec) if max_early_sec is not None and max_early_sec > 0: tf = max(t, t_next - max_early_sec) j0 = bisect_left(ts_pred, t0) jf = max(bisect_left(ts_pred, tf), j0 + 1) window = ys_pred[j0:jf] if window_is_anomaly: anom_durations.append(tf_anomaly - t0_anomaly) num_tp_pointwise += sum(y != 0 for y in window) num_fn_pointwise += sum(y == 0 for y in window) if not any(window): num_fn_anom += 1 num_fn_point_adj += len(window) # true positives are more beneficial if they occur earlier else: num_tp_anom += 1 num_tp_point_adj += len(window) t_detect = ts_pred[np.where(window)[0][0] + j0] tp_detection_delays.append(t_detect - t0_anomaly) tp_anom_durations.append(tf_anomaly - t0_anomaly) delay = 0 if tf - t0 == 0 else (t_detect - t0) / (tf - t0) tp_score += sum(scaled_sigmoid(delay)) else: # false positives are more severe if they occur later # FIXME: false positives can be fired in data spans that are # not present in the original data. Should we still # count these, or should we remove them from the window? if any(window): t_fp = ts_pred[np.where(window)[0] + j0] num_fp += len(t_fp) if tf != t0: delays = (t_fp - t0) / (tf - t0) else: delays = np.infty * np.ones(len(t_fp)) fp_score += sum(scaled_sigmoid(delays)) # do nothing for true negatives, except count them num_tn += sum(window == 0) # Advance to the next window t_prev = t t = t_next window_is_anomaly = not window_is_anomaly score_components = TSADScoreAccumulator( num_tp_anom=num_tp_anom, num_tp_pointwise=num_tp_pointwise, num_tp_point_adj=num_tp_point_adj, num_fp=num_fp, num_fn_anom=num_fn_anom, num_fn_pointwise=num_fn_pointwise, num_fn_point_adj=num_fn_point_adj, num_tn=num_tn, tp_score=tp_score, fp_score=fp_score, tp_detection_delays=tp_detection_delays, tp_anom_durations=tp_anom_durations, anom_durations=anom_durations, ) if metric is not None: return metric(score_components) return score_components class TSADMetric(Enum): """ Enumeration of evaluation metrics for time series anomaly detection. For each value, the name is the metric, and the value is a partial function of form ``f(ground_truth, predicted, **kwargs)`` """ MeanTimeToDetect = partial(accumulate_tsad_score, metric=TSADScoreAccumulator.mean_time_to_detect) # Revised point-adjusted metrics (default) F1 = partial( accumulate_tsad_score, metric=partial(TSADScoreAccumulator.f1, score_type=ScoreType.RevisedPointAdjusted) ) Precision = partial( accumulate_tsad_score, metric=partial(TSADScoreAccumulator.precision, score_type=ScoreType.RevisedPointAdjusted) ) Recall = partial( accumulate_tsad_score, metric=partial(TSADScoreAccumulator.recall, score_type=ScoreType.RevisedPointAdjusted) ) # Pointwise metrics PointwiseF1 = partial( accumulate_tsad_score, metric=partial(TSADScoreAccumulator.f1, score_type=ScoreType.Pointwise) ) PointwisePrecision = partial( accumulate_tsad_score, metric=partial(TSADScoreAccumulator.precision, score_type=ScoreType.Pointwise) ) PointwiseRecall = partial( accumulate_tsad_score, metric=partial(TSADScoreAccumulator.recall, score_type=ScoreType.Pointwise) ) # Point-adjusted metrics PointAdjustedF1 = partial( accumulate_tsad_score, metric=partial(TSADScoreAccumulator.f1, score_type=ScoreType.PointAdjusted) ) PointAdjustedPrecision = partial( accumulate_tsad_score, metric=partial(TSADScoreAccumulator.precision, score_type=ScoreType.PointAdjusted) ) PointAdjustedRecall = partial( accumulate_tsad_score, metric=partial(TSADScoreAccumulator.recall, score_type=ScoreType.PointAdjusted) ) # NAB scores NABScore = partial(accumulate_tsad_score, metric=TSADScoreAccumulator.nab_score) NABScoreLowFN = partial(accumulate_tsad_score, metric=partial(TSADScoreAccumulator.nab_score, fn_weight=2.0)) NABScoreLowFP = partial(accumulate_tsad_score, metric=partial(TSADScoreAccumulator.nab_score, fp_weight=0.22)) # Argus metrics F2 = partial( accumulate_tsad_score, metric=partial(TSADScoreAccumulator.f_beta, score_type=ScoreType.RevisedPointAdjusted, beta=2.0), ) F5 = partial( accumulate_tsad_score, metric=partial(TSADScoreAccumulator.f_beta, score_type=ScoreType.RevisedPointAdjusted, beta=5.0), ) class DetectorEnsemble(EnsembleBase, DetectorBase): """ Class representing an ensemble of multiple anomaly detection models. """ models: List[DetectorBase] config_class = DetectorEnsembleConfig def __init__(self, config: DetectorEnsembleConfig = None, models: List[DetectorBase] = None): super().__init__(config=config, models=models) for model in self.models: assert isinstance(model, DetectorBase), ( f"Expected all models in {type(self).__name__} to be anomaly " f"detectors, but got a {type(model).__name__}." ) model.config.enable_threshold = self.per_model_threshold def require_even_sampling(self) -> bool: return False def require_univariate(self) -> bool: return False def _default_post_rule_train_config(self): return dict(metric=TSADMetric.F1, unsup_quantile=None) def _default_train_config(self): return DetectorEnsembleTrainConfig() def per_model_threshold(self): """ :return: whether to apply the threshold rule of each individual model before aggregating their anomaly scores. """ return self.config.per_model_threshold def _train( self, train_data: TimeSeries, train_config: DetectorEnsembleTrainConfig = None, anomaly_labels: TimeSeries = None, ) -> TimeSeries: """ Trains each anomaly detector in the ensemble unsupervised, and each of their post-rules supervised (if labels are given). :param train_data: a `TimeSeries` of metric values to train the model. :param train_config: `DetectorEnsembleTrainConfig` for ensemble training. :param anomaly_labels: a `TimeSeries` indicating which timestamps are anomalous. Optional. :return: A `TimeSeries` of the ensemble's anomaly scores on the training data. """ train, valid = self.train_valid_split(train_data, train_config) if valid is not None: logger.warning("Using a train/validation split to train a DetectorEnsemble is not recommended!") train_cfgs = train_config.per_model_train_configs if train_cfgs is None: train_cfgs = [None] * len(self.models) assert len(train_cfgs) == len(self.models), ( f"You must provide the same number of per-model train configs as models, but received received" f"{len(train_cfgs)} train configs for an ensemble with {len(self.models)} models." ) pr_cfgs = train_config.per_model_post_rule_train_configs if pr_cfgs is None: pr_cfgs = [None] * len(self.models) assert len(pr_cfgs) == len(self.models), ( f"You must provide the same number of per-model post-rule train configs as models, but received " f"{len(pr_cfgs)} post-rule train configs for an ensemble with {len(self.models)} models." ) # Train each model individually, with its own train config & post-rule train config all_scores = [] eval_cfg = TSADEvaluatorConfig(retrain_freq=None, cadence=self.get_max_common_horizon(train)) # TODO: parallelize me for i, (model, cfg, pr_cfg) in enumerate(zip(self.models, train_cfgs, pr_cfgs)): try: train_kwargs = dict(train_config=cfg, anomaly_labels=anomaly_labels, post_rule_train_config=pr_cfg) train_scores, valid_scores = TSADEvaluator(model=model, config=eval_cfg).get_predict( train_vals=train, test_vals=valid, train_kwargs=train_kwargs, post_process=True ) scores = train_scores if valid is None else valid_scores except Exception: logger.warning( f"Caught an exception while training model {i + 1}/{len(self.models)} ({type(model).__name__}). " f"Model will not be used. {traceback.format_exc()}" ) self.combiner.set_model_used(i, False) scores = None all_scores.append(scores) # Train combiner on train data if there is no validation data if valid is None: return self.train_combiner(all_scores, anomaly_labels) # Otherwise, train the combiner on the validation data, and re-train the models on the full data self.train_combiner(all_scores, anomaly_labels.bisect(t=valid.time_stamps[0], t_in_left=False)[1]) all_scores = [] # TODO: parallelize me for i, (model, cfg, pr_cfg, used) in enumerate(zip(self.models, train_cfgs, pr_cfgs, self.models_used)): model.reset() if used: logger.info(f"Re-training model {i+1}/{len(self.models)} ({type(model).__name__}) on full data...") train_kwargs = dict(train_config=cfg, anomaly_labels=anomaly_labels, post_rule_train_config=pr_cfg) train_scores = model.train(train_data, **train_kwargs) train_scores = model.post_rule(train_scores) else: train_scores = None all_scores.append(train_scores) return self.combiner(all_scores, anomaly_labels) def _get_anomaly_score(self, time_series: pd.DataFrame, time_series_prev: pd.DataFrame = None) -> pd.DataFrame: time_series, time_series_prev = TimeSeries.from_pd(time_series), TimeSeries.from_pd(time_series_prev) y = [ model.get_anomaly_label(time_series, time_series_prev) for model, used in zip(self.models, self.models_used) if used ] return self.combiner(y, time_series).to_pd() class TemporalResample(TransformBase): """ Defines a policy to temporally resample a time series at a specified granularity. Note that while this transform does support inversion, the recovered time series may differ from the input due to information loss when resampling. """ def __init__( self, granularity: Union[str, int, float] = None, origin: int = None, trainable_granularity: bool = None, remove_non_overlapping=True, aggregation_policy: Union[str, AggregationPolicy] = "Mean", missing_value_policy: Union[str, MissingValuePolicy] = "Interpolate", ): """ Defines a policy to temporally resample a time series. :param granularity: The granularity at which we want to resample. :param origin: The time stamp defining the offset to start at. :param trainable_granularity: Whether we will automatically infer the granularity of the time series. If ``None`` (default), it will be trainable only if no granularity is explicitly given. :param remove_non_overlapping: If ``True``, we will only keep the portions of the univariates that overlap with each other. For example, if we have 3 univariates which span timestamps [0, 3600], [60, 3660], and [30, 3540], we will only keep timestamps in the range [60, 3540]. If ``False``, we will keep all timestamps produced by the resampling. :param aggregation_policy: The policy we will use to aggregate multiple values in a window (downsampling). :param missing_value_policy: The policy we will use to impute missing values (upsampling). """ super().__init__() self.granularity = granularity self.origin = origin self.trainable_granularity = (granularity is None) if trainable_granularity is None else trainable_granularity self.remove_non_overlapping = remove_non_overlapping self.aggregation_policy = aggregation_policy self.missing_value_policy = missing_value_policy def requires_inversion_state(self): return False def proper_inversion(self): """ We treat resampling as a proper inversion to avoid emitting warnings. """ return True def granularity(self): return self._granularity def granularity(self, granularity): if not isinstance(granularity, (int, float)): try: granularity = granularity_str_to_seconds(granularity) except: granularity = getattr(granularity, "freqstr", granularity) self._granularity = granularity def aggregation_policy(self) -> AggregationPolicy: return self._aggregation_policy def aggregation_policy(self, agg: Union[str, AggregationPolicy]): if isinstance(agg, str): valid = set(AggregationPolicy.__members__.keys()) if agg not in valid: raise KeyError(f"{agg} is not a valid aggregation policy. Valid aggregation policies are: {valid}") agg = AggregationPolicy[agg] self._aggregation_policy = agg def missing_value_policy(self) -> MissingValuePolicy: return self._missing_value_policy def missing_value_policy(self, mv: Union[str, MissingValuePolicy]): if isinstance(mv, str): valid = set(MissingValuePolicy.__members__.keys()) if mv not in valid: raise KeyError(f"{mv} is not a valid missing value policy. Valid aggregation policies are: {valid}") mv = MissingValuePolicy[mv] self._missing_value_policy = mv def train(self, time_series: TimeSeries): if self.trainable_granularity: granularity = infer_granularity(time_series.np_time_stamps) logger.warning(f"Inferred granularity {granularity}") self.granularity = granularity if self.trainable_granularity or self.origin is None: t0, tf = time_series.t0, time_series.tf if isinstance(self.granularity, (int, float)): offset = (tf - t0) % self.granularity else: offset = 0 self.origin = t0 + offset def __call__(self, time_series: TimeSeries) -> TimeSeries: if self.granularity is None: logger.warning( f"Skipping resampling step because granularity is " f"None. Please either specify a granularity or train " f"this transformation on a time series." ) return time_series return time_series.align( alignment_policy=AlignPolicy.FixedGranularity, granularity=self.granularity, origin=self.origin, remove_non_overlapping=self.remove_non_overlapping, aggregation_policy=self.aggregation_policy, missing_value_policy=self.missing_value_policy, ) def evaluate_predictions( model_names, dataset, all_model_preds, metric: TSADMetric, pointwise_metric: TSADMetric, point_adj_metric: TSADMetric, tune_on_test=False, unsupervised=False, debug=False, ): scores_rpa, scores_pw, scores_pa = [], [], [] use_ucr_eval = isinstance(dataset, UCR) and (unsupervised or not tune_on_test) resampler = None if isinstance(dataset, IOpsCompetition): resampler = TemporalResample("5min") for i, (true, md) in enumerate(tqdm(dataset)): # Get time series for the train & test splits of the ground truth idx = ~md.trainval if tune_on_test else md.trainval true_train = df_to_merlion(true[idx], md[idx], get_ground_truth=True) true_test = df_to_merlion(true[~md.trainval], md[~md.trainval], get_ground_truth=True) for acc_id, (simple_threshold, opt_metric, scores) in enumerate( [ (use_ucr_eval and not tune_on_test, metric, scores_rpa), (True, pointwise_metric, scores_pw), (True, point_adj_metric, scores_pa), ] ): if acc_id > 0 and use_ucr_eval: scores_pw = scores_rpa scores_pa = scores_rpa continue # For each model, load its raw anomaly scores for the i'th time series # as a UnivariateTimeSeries, and collect all the models' scores as a # TimeSeries. Do this for both the train and test splits. if i >= min(len(p) for p in all_model_preds): break pred = [model_preds[i] for model_preds in all_model_preds] pred_train = [p[~p["trainval"]] if tune_on_test else p[p["trainval"]] for p in pred] pred_train = [TimeSeries.from_pd(p["y"]) for p in pred_train] pred_test = [p[~p["trainval"]] for p in pred] pred_test = [TimeSeries.from_pd(p["y"]) for p in pred_test] # Train each model's post rule on the train split models = [] for name, train, og_pred in zip(model_names, pred_train, pred): m, prtc = get_model( model_name=name, dataset=dataset, metric=opt_metric, tune_on_test=tune_on_test, unsupervised=unsupervised, ) m.config.enable_threshold = len(model_names) == 1 if simple_threshold: m.threshold = m.threshold.to_simple_threshold() if tune_on_test and not unsupervised: m.calibrator.train(TimeSeries.from_pd(og_pred["y"][og_pred["trainval"]])) m.train_post_process(train_result=train, anomaly_labels=true_train, post_rule_train_config=prtc) models.append(m) # Get the lead & lag time for the dataset early, delay = dataset.max_lead_sec, dataset.max_lag_sec if early is None: leads = [getattr(m.threshold, "suppress_secs", delay) for m in models] leads = [dt for dt in leads if dt is not None] early = None if len(leads) == 0 else max(leads) # No further training if we only have 1 model if len(models) == 1: model = models[0] pred_test_raw = pred_test[0] # If we have multiple models, train an ensemble model else: threshold = dataset_to_threshold(dataset, tune_on_test) ensemble_threshold_train_config = dict( metric=opt_metric if tune_on_test else None, max_early_sec=early, max_delay_sec=delay, unsup_quantile=None, ) # Train the ensemble and its post-rule on the current time series model = DetectorEnsemble(models=models) use_m = [len(p) > 1 for p in zip(models, pred_train)] pred_train = [m.post_rule(p) for m, p, use in zip(models, pred_train, use_m) if use] pred_test = [m.post_rule(p) for m, p, use in zip(models, pred_test, use_m) if use] pred_train = model.train_combiner(pred_train, true_train) if simple_threshold: model.threshold = model.threshold.to_simple_threshold() model.threshold.alm_threshold = threshold model.train_post_process( train_result=pred_train, anomaly_labels=true_train, post_rule_train_config=ensemble_threshold_train_config, ) pred_test_raw = model.combiner(pred_test, true_test) # For UCR dataset, the evaluation just checks whether the point with the highest # anomaly score is anomalous or not. if acc_id == 0 and use_ucr_eval and not unsupervised: df = pred_test_raw.to_pd() df[np.abs(df) < df.max()] = 0 pred_test = TimeSeries.from_pd(df) else: pred_test = model.post_rule(pred_test_raw) # Compute the individual components comprising various scores. score = accumulate_tsad_score(true_test, pred_test, max_early_sec=early, max_delay_sec=delay) # Make sure all time series have exactly one detection for UCR dataset (either 1 TP, or 1 FN & 1 FP). if acc_id == 0 and use_ucr_eval: n_anom = score.num_tp_anom + score.num_fn_anom if n_anom == 0: score.num_tp_anom, score.num_fn_anom, score.num_fp = 0, 0, 0 elif score.num_tp_anom > 0: score.num_tp_anom, score.num_fn_anom, score.num_fp = 1, 0, 0 else: score.num_tp_anom, score.num_fn_anom, score.num_fp = 0, 1, 1 scores.append(score) # Aggregate statistics from full dataset score_rpa = sum(scores_rpa, ScoreAcc()) score_pw = sum(scores_pw, ScoreAcc()) score_pa = sum(scores_pa, ScoreAcc()) # Determine if it's better to have all negatives for each time series if # using the test data in a supervised way. if tune_on_test and not unsupervised: # Convert true positives to false negatives, and remove all false positives. # Keep the updated version if it improves F1 score. for s in sorted(scores_rpa, key=lambda x: x.num_fp, reverse=True): stype = ScoreType.RevisedPointAdjusted sprime = copy.deepcopy(score_rpa) sprime.num_tp_anom -= s.num_tp_anom sprime.num_fn_anom += s.num_tp_anom sprime.num_fp -= s.num_fp sprime.tp_score -= s.tp_score sprime.fp_score -= s.fp_score if score_rpa.f1(stype) < sprime.f1(stype): # Update anomaly durations for duration, delay in zip(s.tp_anom_durations, s.tp_detection_delays): sprime.tp_anom_durations.remove(duration) sprime.tp_detection_delays.remove(delay) score_rpa = sprime # Repeat for pointwise scores for s in sorted(scores_pw, key=lambda x: x.num_fp, reverse=True): stype = ScoreType.Pointwise sprime = copy.deepcopy(score_pw) sprime.num_tp_pointwise -= s.num_tp_pointwise sprime.num_fn_pointwise += s.num_tp_pointwise sprime.num_fp -= s.num_fp if score_pw.f1(stype) < sprime.f1(stype): score_pw = sprime # Repeat for point-adjusted scores for s in sorted(scores_pa, key=lambda x: x.num_fp, reverse=True): stype = ScoreType.PointAdjusted sprime = copy.deepcopy(score_pa) sprime.num_tp_point_adj -= s.num_tp_point_adj sprime.num_fn_point_adj += s.num_tp_point_adj sprime.num_fp -= s.num_fp if score_pa.f1(stype) < sprime.f1(stype): score_pa = sprime # Compute MTTD & report F1, precision, and recall mttd = score_rpa.mean_time_to_detect() if mttd < pd.to_timedelta(0): mttd = f"-{-mttd}" print() print("Revised point-adjusted metrics") print(f"F1 score: {score_rpa.f1(ScoreType.RevisedPointAdjusted):.4f}") print(f"Precision: {score_rpa.precision(ScoreType.RevisedPointAdjusted):.4f}") print(f"Recall: {score_rpa.recall(ScoreType.RevisedPointAdjusted):.4f}") print() print(f"Mean Time To Detect Anomalies: {mttd}") print(f"Mean Detected Anomaly Duration: {score_rpa.mean_detected_anomaly_duration()}") print(f"Mean Anomaly Duration: {score_rpa.mean_anomaly_duration()}") print() if debug: print("Pointwise metrics") print(f"F1 score: {score_pw.f1(ScoreType.Pointwise):.4f}") print(f"Precision: {score_pw.precision(ScoreType.Pointwise):.4f}") print(f"Recall: {score_pw.recall(ScoreType.Pointwise):.4f}") print() print("Point-adjusted metrics") print(f"F1 score: {score_pa.f1(ScoreType.PointAdjusted):.4f}") print(f"Precision: {score_pa.precision(ScoreType.PointAdjusted):.4f}") print(f"Recall: {score_pa.recall(ScoreType.PointAdjusted):.4f}") print() print("NAB Scores") print(f"NAB Score (balanced): {score_rpa.nab_score():.4f}") print(f"NAB Score (high precision): {score_rpa.nab_score(fp_weight=0.22):.4f}") print(f"NAB Score (high recall): {score_rpa.nab_score(fn_weight=2.0):.4f}") print() return score_rpa, score_pw, score_pa

import logging import os import requests from tqdm import tqdm import pandas as pd from ts_datasets.base import BaseDataset logger = logging.getLogger(__name__) def download(datapath, url, name, split=None): os.makedirs(datapath, exist_ok=True) if split is not None: namesplit = split + "/" + name else: namesplit = name url = url.format(namesplit) file_path = os.path.join(datapath, name) + ".csv" if os.path.isfile(file_path): logger.info(name + " already exists") return logger.info("Downloading " + url) r = requests.get(url, stream=True) with open(file_path, "wb") as f: for chunk in r.iter_content(chunk_size=16 * 1024**2): if chunk: # filter out keep-alive new chunks f.write(chunk) f.flush()

import os import sys import logging import requests import tarfile import numpy as np import pandas as pd from pathlib import Path from ts_datasets.anomaly.base import TSADBaseDataset def combine_train_test_datasets(train_df, test_df, test_labels): train_df.columns = [str(c) for c in train_df.columns] test_df.columns = [str(c) for c in test_df.columns] df = pd.concat([train_df, test_df]).reset_index() if "index" in df: df.drop(columns=["index"], inplace=True) df.index = pd.to_datetime(df.index * 60, unit="s") df.index.rename("timestamp", inplace=True) # There are no labels for training examples, so the training labels are set to 0 by default # The dataset is only for unsupervised time series anomaly detection metadata = pd.DataFrame( { "trainval": df.index < df.index[train_df.shape[0]], "anomaly": np.concatenate([np.zeros(train_df.shape[0], dtype=int), test_labels]), }, index=df.index, ) return df, metadata

import os import sys import logging import requests import tarfile import numpy as np import pandas as pd from pathlib import Path from ts_datasets.anomaly.base import TSADBaseDataset def download(logger, datapath, url, filename): os.makedirs(datapath, exist_ok=True) compressed_file = os.path.join(datapath, f"{filename}.tar.gz") # Download the compressed dataset if not os.path.exists(compressed_file): logger.info("Downloading " + url) with requests.get(url, stream=True) as r: with open(compressed_file, "wb") as f: for chunk in r.iter_content(chunk_size=16 * 1024**2): if chunk: # filter out keep-alive new chunks f.write(chunk) f.flush() # Uncompress the downloaded tar file if not os.path.exists(os.path.join(datapath, "_SUCCESS")): logger.info(f"Uncompressing {compressed_file}") tar = tarfile.open(compressed_file, "r:gz") tar.extractall(path=datapath) tar.close() Path(os.path.join(datapath, "_SUCCESS")).touch()

import os import sys import csv import ast import logging import pickle import numpy as np import pandas as pd from ts_datasets.anomaly.base import TSADBaseDataset from ts_datasets.anomaly.smd import download, combine_train_test_datasets def preprocess(logger, data_folder, dataset): if ( os.path.exists(os.path.join(data_folder, f"{dataset}_test_label.pkl")) and os.path.exists(os.path.join(data_folder, f"{dataset}_train.pkl")) and os.path.exists(os.path.join(data_folder, f"{dataset}_test.pkl")) ): return logger.info(f"Preprocessing {dataset}") with open(os.path.join(data_folder, "labeled_anomalies.csv"), "r") as f: csv_reader = csv.reader(f, delimiter=",") res = [row for row in csv_reader][1:] res = sorted(res, key=lambda k: k[0]) labels = [] data_info = [row for row in res if row[1] == dataset and row[0] != "P-2"] for row in data_info: anomalies = ast.literal_eval(row[2]) length = int(row[-1]) label = np.zeros([length], dtype=bool) for anomaly in anomalies: label[anomaly[0] : anomaly[1] + 1] = True labels.extend(label) labels = np.asarray(labels) with open(os.path.join(data_folder, f"{dataset}_test_label.pkl"), "wb") as f: pickle.dump(labels, f) for category in ["train", "test"]: data = [] for row in data_info: data.extend(np.load(os.path.join(data_folder, category, row[0] + ".npy"))) data = np.asarray(data) with open(os.path.join(data_folder, f"{dataset}_{category}.pkl"), "wb") as f: pickle.dump(data, f)

import os import sys import csv import ast import logging import pickle import numpy as np import pandas as pd from ts_datasets.anomaly.base import TSADBaseDataset from ts_datasets.anomaly.smd import download, combine_train_test_datasets def load_data(directory, dataset): with open(os.path.join(directory, f"{dataset}_test.pkl"), "rb") as f: test_data = pickle.load(f) with open(os.path.join(directory, f"{dataset}_test_label.pkl"), "rb") as f: test_labels = pickle.load(f) with open(os.path.join(directory, f"{dataset}_train.pkl"), "rb") as f: train_data = pickle.load(f) train_df, test_df = pd.DataFrame(train_data), pd.DataFrame(test_data) return train_df, test_df, test_labels.astype(int)

from __future__ import print_function from __future__ import absolute_import from __future__ import division import numpy as np import torch def to_tensor(array, dtype=torch.float32): if 'torch.tensor' not in str(type(array)): return torch.tensor(array, dtype=dtype)

from __future__ import print_function from __future__ import absolute_import from __future__ import division import numpy as np import torch def to_np(array, dtype=np.float32): if 'scipy.sparse' in str(type(array)): array = array.todense() return np.array(array, dtype=dtype)

from __future__ import absolute_import from __future__ import print_function from __future__ import division import numpy as np import torch import torch.nn.functional as F from .utils import rot_mat_to_euler def batch_rodrigues(rot_vecs, epsilon=1e-8, dtype=torch.float32): ''' Calculates the rotation matrices for a batch of rotation vectors Parameters ---------- rot_vecs: torch.tensor Nx3 array of N axis-angle vectors Returns ------- R: torch.tensor Nx3x3 The rotation matrices for the given axis-angle parameters ''' batch_size = rot_vecs.shape[0] device = rot_vecs.device angle = torch.norm(rot_vecs + 1e-8, dim=1, keepdim=True) rot_dir = rot_vecs / angle cos = torch.unsqueeze(torch.cos(angle), dim=1) sin = torch.unsqueeze(torch.sin(angle), dim=1) # Bx1 arrays rx, ry, rz = torch.split(rot_dir, 1, dim=1) K = torch.zeros((batch_size, 3, 3), dtype=dtype, device=device) zeros = torch.zeros((batch_size, 1), dtype=dtype, device=device) K = torch.cat([zeros, -rz, ry, rz, zeros, -rx, -ry, rx, zeros], dim=1) \ .view((batch_size, 3, 3)) ident = torch.eye(3, dtype=dtype, device=device).unsqueeze(dim=0) rot_mat = ident + sin * K + (1 - cos) * torch.bmm(K, K) return rot_mat def rot_mat_to_euler(rot_mats): # Calculates rotation matrix to euler angles # Careful for extreme cases of eular angles like [0.0, pi, 0.0] sy = torch.sqrt(rot_mats[:, 0, 0] * rot_mats[:, 0, 0] + rot_mats[:, 1, 0] * rot_mats[:, 1, 0]) return torch.atan2(-rot_mats[:, 2, 0], sy) The provided code snippet includes necessary dependencies for implementing the `find_dynamic_lmk_idx_and_bcoords` function. Write a Python function `def find_dynamic_lmk_idx_and_bcoords(vertices, pose, dynamic_lmk_faces_idx, dynamic_lmk_b_coords, neck_kin_chain, dtype=torch.float32)` to solve the following problem: Compute the faces, barycentric coordinates for the dynamic landmarks To do so, we first compute the rotation of the neck around the y-axis and then use a pre-computed look-up table to find the faces and the barycentric coordinates that will be used. Special thanks to Soubhik Sanyal (soubhik.sanyal@tuebingen.mpg.de) for providing the original TensorFlow implementation and for the LUT. Parameters ---------- vertices: torch.tensor BxVx3, dtype = torch.float32 The tensor of input vertices pose: torch.tensor Bx(Jx3), dtype = torch.float32 The current pose of the body model dynamic_lmk_faces_idx: torch.tensor L, dtype = torch.long The look-up table from neck rotation to faces dynamic_lmk_b_coords: torch.tensor Lx3, dtype = torch.float32 The look-up table from neck rotation to barycentric coordinates neck_kin_chain: list A python list that contains the indices of the joints that form the kinematic chain of the neck. dtype: torch.dtype, optional Returns ------- dyn_lmk_faces_idx: torch.tensor, dtype = torch.long A tensor of size BxL that contains the indices of the faces that will be used to compute the current dynamic landmarks. dyn_lmk_b_coords: torch.tensor, dtype = torch.float32 A tensor of size BxL that contains the indices of the faces that will be used to compute the current dynamic landmarks. Here is the function: def find_dynamic_lmk_idx_and_bcoords(vertices, pose, dynamic_lmk_faces_idx, dynamic_lmk_b_coords, neck_kin_chain, dtype=torch.float32): ''' Compute the faces, barycentric coordinates for the dynamic landmarks To do so, we first compute the rotation of the neck around the y-axis and then use a pre-computed look-up table to find the faces and the barycentric coordinates that will be used. Special thanks to Soubhik Sanyal (soubhik.sanyal@tuebingen.mpg.de) for providing the original TensorFlow implementation and for the LUT. Parameters ---------- vertices: torch.tensor BxVx3, dtype = torch.float32 The tensor of input vertices pose: torch.tensor Bx(Jx3), dtype = torch.float32 The current pose of the body model dynamic_lmk_faces_idx: torch.tensor L, dtype = torch.long The look-up table from neck rotation to faces dynamic_lmk_b_coords: torch.tensor Lx3, dtype = torch.float32 The look-up table from neck rotation to barycentric coordinates neck_kin_chain: list A python list that contains the indices of the joints that form the kinematic chain of the neck. dtype: torch.dtype, optional Returns ------- dyn_lmk_faces_idx: torch.tensor, dtype = torch.long A tensor of size BxL that contains the indices of the faces that will be used to compute the current dynamic landmarks. dyn_lmk_b_coords: torch.tensor, dtype = torch.float32 A tensor of size BxL that contains the indices of the faces that will be used to compute the current dynamic landmarks. ''' batch_size = vertices.shape[0] aa_pose = torch.index_select(pose.view(batch_size, -1, 3), 1, neck_kin_chain) rot_mats = batch_rodrigues( aa_pose.view(-1, 3), dtype=dtype).view(batch_size, -1, 3, 3) rel_rot_mat = torch.eye(3, device=vertices.device, dtype=dtype).unsqueeze_(dim=0) for idx in range(len(neck_kin_chain)): rel_rot_mat = torch.bmm(rot_mats[:, idx], rel_rot_mat) y_rot_angle = torch.round( torch.clamp(-rot_mat_to_euler(rel_rot_mat) * 180.0 / np.pi, max=39)).to(dtype=torch.long) neg_mask = y_rot_angle.lt(0).to(dtype=torch.long) mask = y_rot_angle.lt(-39).to(dtype=torch.long) neg_vals = mask * 78 + (1 - mask) * (39 - y_rot_angle) y_rot_angle = (neg_mask * neg_vals + (1 - neg_mask) * y_rot_angle) dyn_lmk_faces_idx = torch.index_select(dynamic_lmk_faces_idx, 0, y_rot_angle) dyn_lmk_b_coords = torch.index_select(dynamic_lmk_b_coords, 0, y_rot_angle) return dyn_lmk_faces_idx, dyn_lmk_b_coords

Compute the faces, barycentric coordinates for the dynamic landmarks To do so, we first compute the rotation of the neck around the y-axis and then use a pre-computed look-up table to find the faces and the barycentric coordinates that will be used. Special thanks to Soubhik Sanyal (soubhik.sanyal@tuebingen.mpg.de) for providing the original TensorFlow implementation and for the LUT. Parameters ---------- vertices: torch.tensor BxVx3, dtype = torch.float32 The tensor of input vertices pose: torch.tensor Bx(Jx3), dtype = torch.float32 The current pose of the body model dynamic_lmk_faces_idx: torch.tensor L, dtype = torch.long The look-up table from neck rotation to faces dynamic_lmk_b_coords: torch.tensor Lx3, dtype = torch.float32 The look-up table from neck rotation to barycentric coordinates neck_kin_chain: list A python list that contains the indices of the joints that form the kinematic chain of the neck. dtype: torch.dtype, optional Returns ------- dyn_lmk_faces_idx: torch.tensor, dtype = torch.long A tensor of size BxL that contains the indices of the faces that will be used to compute the current dynamic landmarks. dyn_lmk_b_coords: torch.tensor, dtype = torch.float32 A tensor of size BxL that contains the indices of the faces that will be used to compute the current dynamic landmarks.

from __future__ import absolute_import from __future__ import print_function from __future__ import division import numpy as np import torch import torch.nn.functional as F from .utils import rot_mat_to_euler The provided code snippet includes necessary dependencies for implementing the `vertices2landmarks` function. Write a Python function `def vertices2landmarks(vertices, faces, lmk_faces_idx, lmk_bary_coords)` to solve the following problem: Calculates landmarks by barycentric interpolation Parameters ---------- vertices: torch.tensor BxVx3, dtype = torch.float32 The tensor of input vertices faces: torch.tensor Fx3, dtype = torch.long The faces of the mesh lmk_faces_idx: torch.tensor L, dtype = torch.long The tensor with the indices of the faces used to calculate the landmarks. lmk_bary_coords: torch.tensor Lx3, dtype = torch.float32 The tensor of barycentric coordinates that are used to interpolate the landmarks Returns ------- landmarks: torch.tensor BxLx3, dtype = torch.float32 The coordinates of the landmarks for each mesh in the batch Here is the function: def vertices2landmarks(vertices, faces, lmk_faces_idx, lmk_bary_coords): ''' Calculates landmarks by barycentric interpolation Parameters ---------- vertices: torch.tensor BxVx3, dtype = torch.float32 The tensor of input vertices faces: torch.tensor Fx3, dtype = torch.long The faces of the mesh lmk_faces_idx: torch.tensor L, dtype = torch.long The tensor with the indices of the faces used to calculate the landmarks. lmk_bary_coords: torch.tensor Lx3, dtype = torch.float32 The tensor of barycentric coordinates that are used to interpolate the landmarks Returns ------- landmarks: torch.tensor BxLx3, dtype = torch.float32 The coordinates of the landmarks for each mesh in the batch ''' # Extract the indices of the vertices for each face # BxLx3 batch_size, num_verts = vertices.shape[:2] device = vertices.device lmk_faces = torch.index_select(faces, 0, lmk_faces_idx.view(-1)).expand( batch_size, -1, -1).long() lmk_faces = lmk_faces + torch.arange( batch_size, dtype=torch.long, device=device).view(-1, 1, 1) * num_verts lmk_vertices = vertices.view(-1, 3)[lmk_faces].view( batch_size, -1, 3, 3) landmarks = torch.einsum('blfi,blf->bli', [lmk_vertices, lmk_bary_coords]) return landmarks

Calculates landmarks by barycentric interpolation Parameters ---------- vertices: torch.tensor BxVx3, dtype = torch.float32 The tensor of input vertices faces: torch.tensor Fx3, dtype = torch.long The faces of the mesh lmk_faces_idx: torch.tensor L, dtype = torch.long The tensor with the indices of the faces used to calculate the landmarks. lmk_bary_coords: torch.tensor Lx3, dtype = torch.float32 The tensor of barycentric coordinates that are used to interpolate the landmarks Returns ------- landmarks: torch.tensor BxLx3, dtype = torch.float32 The coordinates of the landmarks for each mesh in the batch

from __future__ import absolute_import from __future__ import print_function from __future__ import division import numpy as np import torch import torch.nn.functional as F from .utils import rot_mat_to_euler def vertices2joints(J_regressor, vertices): ''' Calculates the 3D joint locations from the vertices Parameters ---------- J_regressor : torch.tensor JxV The regressor array that is used to calculate the joints from the position of the vertices vertices : torch.tensor BxVx3 The tensor of mesh vertices Returns ------- torch.tensor BxJx3 The location of the joints ''' return torch.einsum('bik,ji->bjk', [vertices, J_regressor]) def blend_shapes(betas, shape_disps): ''' Calculates the per vertex displacement due to the blend shapes Parameters ---------- betas : torch.tensor Bx(num_betas) Blend shape coefficients shape_disps: torch.tensor Vx3x(num_betas) Blend shapes Returns ------- torch.tensor BxVx3 The per-vertex displacement due to shape deformation ''' # Displacement[b, m, k] = sum_{l} betas[b, l] * shape_disps[m, k, l] # i.e. Multiply each shape displacement by its corresponding beta and # then sum them. blend_shape = torch.einsum('bl,mkl->bmk', [betas, shape_disps]) return blend_shape def batch_rodrigues(rot_vecs, epsilon=1e-8, dtype=torch.float32): ''' Calculates the rotation matrices for a batch of rotation vectors Parameters ---------- rot_vecs: torch.tensor Nx3 array of N axis-angle vectors Returns ------- R: torch.tensor Nx3x3 The rotation matrices for the given axis-angle parameters ''' batch_size = rot_vecs.shape[0] device = rot_vecs.device angle = torch.norm(rot_vecs + 1e-8, dim=1, keepdim=True) rot_dir = rot_vecs / angle cos = torch.unsqueeze(torch.cos(angle), dim=1) sin = torch.unsqueeze(torch.sin(angle), dim=1) # Bx1 arrays rx, ry, rz = torch.split(rot_dir, 1, dim=1) K = torch.zeros((batch_size, 3, 3), dtype=dtype, device=device) zeros = torch.zeros((batch_size, 1), dtype=dtype, device=device) K = torch.cat([zeros, -rz, ry, rz, zeros, -rx, -ry, rx, zeros], dim=1) \ .view((batch_size, 3, 3)) ident = torch.eye(3, dtype=dtype, device=device).unsqueeze(dim=0) rot_mat = ident + sin * K + (1 - cos) * torch.bmm(K, K) return rot_mat def batch_rigid_transform(rot_mats, joints, parents, dtype=torch.float32): """ Applies a batch of rigid transformations to the joints Parameters ---------- rot_mats : torch.tensor BxNx3x3 Tensor of rotation matrices joints : torch.tensor BxNx3 Locations of joints parents : torch.tensor BxN The kinematic tree of each object dtype : torch.dtype, optional: The data type of the created tensors, the default is torch.float32 Returns ------- posed_joints : torch.tensor BxNx3 The locations of the joints after applying the pose rotations rel_transforms : torch.tensor BxNx4x4 The relative (with respect to the root joint) rigid transformations for all the joints """ joints = torch.unsqueeze(joints, dim=-1) rel_joints = joints.clone() rel_joints[:, 1:] = rel_joints[:, 1:] - joints[:, parents[1:]] transforms_mat = transform_mat( rot_mats.reshape(-1, 3, 3), rel_joints.reshape(-1, 3, 1)).reshape(-1, joints.shape[1], 4, 4) transform_chain = [transforms_mat[:, 0]] for i in range(1, parents.shape[0]): # Subtract the joint location at the rest pose # No need for rotation, since it's identity when at rest curr_res = torch.matmul(transform_chain[parents[i]], transforms_mat[:, i]) transform_chain.append(curr_res) transforms = torch.stack(transform_chain, dim=1) # The last column of the transformations contains the posed joints posed_joints = transforms[:, :, :3, 3] # The last column of the transformations contains the posed joints posed_joints = transforms[:, :, :3, 3] joints_homogen = F.pad(joints, [0, 0, 0, 1]) rel_transforms = transforms - F.pad( torch.matmul(transforms, joints_homogen), [3, 0, 0, 0, 0, 0, 0, 0]) return posed_joints, rel_transforms The provided code snippet includes necessary dependencies for implementing the `lbs` function. Write a Python function `def lbs(betas, pose, v_template, shapedirs, posedirs, J_regressor, parents, lbs_weights, pose2rot=True, dtype=torch.float32, pose_blend=True)` to solve the following problem: Performs Linear Blend Skinning with the given shape and pose parameters Parameters ---------- betas : torch.tensor BxNB The tensor of shape parameters pose : torch.tensor Bx(J + 1) * 3 The pose parameters in axis-angle format v_template torch.tensor BxVx3 The template mesh that will be deformed shapedirs : torch.tensor 1xNB The tensor of PCA shape displacements posedirs : torch.tensor Px(V * 3) The pose PCA coefficients J_regressor : torch.tensor JxV The regressor array that is used to calculate the joints from the position of the vertices parents: torch.tensor J The array that describes the kinematic tree for the model lbs_weights: torch.tensor N x V x (J + 1) The linear blend skinning weights that represent how much the rotation matrix of each part affects each vertex pose2rot: bool, optional Flag on whether to convert the input pose tensor to rotation matrices. The default value is True. If False, then the pose tensor should already contain rotation matrices and have a size of Bx(J + 1)x9 dtype: torch.dtype, optional Returns ------- verts: torch.tensor BxVx3 The vertices of the mesh after applying the shape and pose displacements. joints: torch.tensor BxJx3 The joints of the model Here is the function: def lbs(betas, pose, v_template, shapedirs, posedirs, J_regressor, parents, lbs_weights, pose2rot=True, dtype=torch.float32, pose_blend=True): ''' Performs Linear Blend Skinning with the given shape and pose parameters Parameters ---------- betas : torch.tensor BxNB The tensor of shape parameters pose : torch.tensor Bx(J + 1) * 3 The pose parameters in axis-angle format v_template torch.tensor BxVx3 The template mesh that will be deformed shapedirs : torch.tensor 1xNB The tensor of PCA shape displacements posedirs : torch.tensor Px(V * 3) The pose PCA coefficients J_regressor : torch.tensor JxV The regressor array that is used to calculate the joints from the position of the vertices parents: torch.tensor J The array that describes the kinematic tree for the model lbs_weights: torch.tensor N x V x (J + 1) The linear blend skinning weights that represent how much the rotation matrix of each part affects each vertex pose2rot: bool, optional Flag on whether to convert the input pose tensor to rotation matrices. The default value is True. If False, then the pose tensor should already contain rotation matrices and have a size of Bx(J + 1)x9 dtype: torch.dtype, optional Returns ------- verts: torch.tensor BxVx3 The vertices of the mesh after applying the shape and pose displacements. joints: torch.tensor BxJx3 The joints of the model ''' batch_size = max(betas.shape[0], pose.shape[0]) device = betas.device # Add shape contribution v_shaped = v_template + blend_shapes(betas, shapedirs) # Get the joints # NxJx3 array J = vertices2joints(J_regressor, v_shaped) # 3. Add pose blend shapes # N x J x 3 x 3 ident = torch.eye(3, dtype=dtype, device=device) if pose2rot: rot_mats = batch_rodrigues( pose.view(-1, 3), dtype=dtype).view([batch_size, -1, 3, 3]) pose_feature = (rot_mats[:, 1:, :, :] - ident).view([batch_size, -1]) # (N x P) x (P, V * 3) -> N x V x 3 pose_offsets = torch.matmul(pose_feature, posedirs) \ .view(batch_size, -1, 3) else: pose_feature = pose[:, 1:].view(batch_size, -1, 3, 3) - ident rot_mats = pose.view(batch_size, -1, 3, 3) pose_offsets = torch.matmul(pose_feature.view(batch_size, -1), posedirs).view(batch_size, -1, 3) if pose_blend: v_posed = pose_offsets + v_shaped else: v_posed = v_shaped # 4. Get the global joint location J_transformed, A = batch_rigid_transform(rot_mats, J, parents, dtype=dtype) # 5. Do skinning: # W is N x V x (J + 1) W = lbs_weights.unsqueeze(dim=0).expand([batch_size, -1, -1]) # (N x V x (J + 1)) x (N x (J + 1) x 16) num_joints = J_regressor.shape[0] T = torch.matmul(W, A.view(batch_size, num_joints, 16)) \ .view(batch_size, -1, 4, 4) homogen_coord = torch.ones([batch_size, v_posed.shape[1], 1], dtype=dtype, device=device) v_posed_homo = torch.cat([v_posed, homogen_coord], dim=2) v_homo = torch.matmul(T, torch.unsqueeze(v_posed_homo, dim=-1)) verts = v_homo[:, :, :3, 0] return verts, J_transformed, T, W, A.view(batch_size, num_joints, 4,4)

Performs Linear Blend Skinning with the given shape and pose parameters Parameters ---------- betas : torch.tensor BxNB The tensor of shape parameters pose : torch.tensor Bx(J + 1) * 3 The pose parameters in axis-angle format v_template torch.tensor BxVx3 The template mesh that will be deformed shapedirs : torch.tensor 1xNB The tensor of PCA shape displacements posedirs : torch.tensor Px(V * 3) The pose PCA coefficients J_regressor : torch.tensor JxV The regressor array that is used to calculate the joints from the position of the vertices parents: torch.tensor J The array that describes the kinematic tree for the model lbs_weights: torch.tensor N x V x (J + 1) The linear blend skinning weights that represent how much the rotation matrix of each part affects each vertex pose2rot: bool, optional Flag on whether to convert the input pose tensor to rotation matrices. The default value is True. If False, then the pose tensor should already contain rotation matrices and have a size of Bx(J + 1)x9 dtype: torch.dtype, optional Returns ------- verts: torch.tensor BxVx3 The vertices of the mesh after applying the shape and pose displacements. joints: torch.tensor BxJx3 The joints of the model

import torch import torch.nn.functional as F from .smpl import SMPLServer from pytorch3d import ops The provided code snippet includes necessary dependencies for implementing the `skinning` function. Write a Python function `def skinning(x, w, tfs, inverse=False)` to solve the following problem: Linear blend skinning Args: x (tensor): canonical points. shape: [B, N, D] w (tensor): conditional input. [B, N, J] tfs (tensor): bone transformation matrices. shape: [B, J, D+1, D+1] Returns: x (tensor): skinned points. shape: [B, N, D] Here is the function: def skinning(x, w, tfs, inverse=False): """Linear blend skinning Args: x (tensor): canonical points. shape: [B, N, D] w (tensor): conditional input. [B, N, J] tfs (tensor): bone transformation matrices. shape: [B, J, D+1, D+1] Returns: x (tensor): skinned points. shape: [B, N, D] """ x_h = F.pad(x, (0, 1), value=1.0) if inverse: # p:n_point, n:n_bone, i,k: n_dim+1 w_tf = torch.einsum("bpn,bnij->bpij", w, tfs) x_h = torch.einsum("bpij,bpj->bpi", w_tf.inverse(), x_h) else: x_h = torch.einsum("bpn,bnij,bpj->bpi", w, tfs, x_h) return x_h[:, :, :3]

Linear blend skinning Args: x (tensor): canonical points. shape: [B, N, D] w (tensor): conditional input. [B, N, J] tfs (tensor): bone transformation matrices. shape: [B, J, D+1, D+1] Returns: x (tensor): skinned points. shape: [B, N, D]

from .networks import ImplicitNet, RenderingNet from .density import LaplaceDensity, AbsDensity from .ray_sampler import ErrorBoundSampler from .deformer import SMPLDeformer from .smpl import SMPLServer from .sampler import PointInSpace from ..utils import utils import numpy as np import torch import torch.nn as nn from torch.autograd import grad import hydra import kaolin from kaolin.ops.mesh import index_vertices_by_faces def gradient(inputs, outputs): d_points = torch.ones_like(outputs, requires_grad=False, device=outputs.device) points_grad = grad( outputs=outputs, inputs=inputs, grad_outputs=d_points, create_graph=True, retain_graph=True, only_inputs=True)[0][:, :, -3:] return points_grad

import torch class Embedder: def __init__(self, **kwargs): self.kwargs = kwargs self.create_embedding_fn() def create_embedding_fn(self): embed_fns = [] d = self.kwargs['input_dims'] out_dim = 0 if self.kwargs['include_input']: embed_fns.append(lambda x: x) out_dim += d max_freq = self.kwargs['max_freq_log2'] N_freqs = self.kwargs['num_freqs'] if self.kwargs['log_sampling']: freq_bands = 2. ** torch.linspace(0., max_freq, N_freqs) else: freq_bands = torch.linspace(2.**0., 2.**max_freq, N_freqs) for freq in freq_bands: for p_fn in self.kwargs['periodic_fns']: embed_fns.append(lambda x, p_fn=p_fn, freq=freq: p_fn(x * freq)) out_dim += d self.embed_fns = embed_fns self.out_dim = out_dim def embed(self, inputs): return torch.cat([fn(inputs) for fn in self.embed_fns], -1) def get_embedder(multires, input_dims=3, mode='fourier'): embed_kwargs = { 'include_input': True, 'input_dims': input_dims, 'max_freq_log2': multires-1, 'num_freqs': multires, 'log_sampling': True, 'periodic_fns': [torch.sin, torch.cos], } if mode == 'fourier': embedder_obj = Embedder(**embed_kwargs) def embed(x, eo=embedder_obj): return eo.embed(x) return embed, embedder_obj.out_dim

import numpy as np import cv2 import torch from torch.nn import functional as F The provided code snippet includes necessary dependencies for implementing the `split_input` function. Write a Python function `def split_input(model_input, total_pixels, n_pixels = 10000)` to solve the following problem: Split the input to fit Cuda memory for large resolution. Can decrease the value of n_pixels in case of cuda out of memory error. Here is the function: def split_input(model_input, total_pixels, n_pixels = 10000): ''' Split the input to fit Cuda memory for large resolution. Can decrease the value of n_pixels in case of cuda out of memory error. ''' split = [] for i, indx in enumerate(torch.split(torch.arange(total_pixels).cuda(), n_pixels, dim=0)): data = model_input.copy() data['uv'] = torch.index_select(model_input['uv'], 1, indx) split.append(data) return split

Split the input to fit Cuda memory for large resolution. Can decrease the value of n_pixels in case of cuda out of memory error.

import numpy as np import cv2 import torch from torch.nn import functional as F The provided code snippet includes necessary dependencies for implementing the `merge_output` function. Write a Python function `def merge_output(res, total_pixels, batch_size)` to solve the following problem: Merge the split output. Here is the function: def merge_output(res, total_pixels, batch_size): ''' Merge the split output. ''' model_outputs = {} for entry in res[0]: if res[0][entry] is None: continue if len(res[0][entry].shape) == 1: model_outputs[entry] = torch.cat([r[entry].reshape(batch_size, -1, 1) for r in res], 1).reshape(batch_size * total_pixels) else: model_outputs[entry] = torch.cat([r[entry].reshape(batch_size, -1, r[entry].shape[-1]) for r in res], 1).reshape(batch_size * total_pixels, -1) return model_outputs

Merge the split output.

import numpy as np import cv2 import torch from torch.nn import functional as F def get_psnr(img1, img2, normalize_rgb=False): if normalize_rgb: # [-1,1] --> [0,1] img1 = (img1 + 1.) / 2. img2 = (img2 + 1. ) / 2. mse = torch.mean((img1 - img2) ** 2) psnr = -10. * torch.log(mse) / torch.log(torch.Tensor([10.]).cuda()) return psnr

import numpy as np import cv2 import torch from torch.nn import functional as F def load_K_Rt_from_P(filename, P=None): if P is None: lines = open(filename).read().splitlines() if len(lines) == 4: lines = lines[1:] lines = [[x[0], x[1], x[2], x[3]] for x in (x.split(" ") for x in lines)] P = np.asarray(lines).astype(np.float32).squeeze() out = cv2.decomposeProjectionMatrix(P) K = out[0] R = out[1] t = out[2] K = K/K[2,2] intrinsics = np.eye(4) intrinsics[:3, :3] = K pose = np.eye(4, dtype=np.float32) pose[:3, :3] = R.transpose() pose[:3,3] = (t[:3] / t[3])[:,0] return intrinsics, pose

import numpy as np import cv2 import torch from torch.nn import functional as F def lift(x, y, z, intrinsics): # parse intrinsics intrinsics = intrinsics.cuda() fx = intrinsics[:, 0, 0] fy = intrinsics[:, 1, 1] cx = intrinsics[:, 0, 2] cy = intrinsics[:, 1, 2] sk = intrinsics[:, 0, 1] x_lift = (x - cx.unsqueeze(-1) + cy.unsqueeze(-1)*sk.unsqueeze(-1)/fy.unsqueeze(-1) - sk.unsqueeze(-1)*y/fy.unsqueeze(-1)) / fx.unsqueeze(-1) * z y_lift = (y - cy.unsqueeze(-1)) / fy.unsqueeze(-1) * z # homogeneous return torch.stack((x_lift, y_lift, z, torch.ones_like(z).cuda()), dim=-1) def quat_to_rot(q): batch_size, _ = q.shape q = F.normalize(q, dim=1) R = torch.ones((batch_size, 3,3)).cuda() qr=q[:,0] qi = q[:, 1] qj = q[:, 2] qk = q[:, 3] R[:, 0, 0]=1-2 * (qj**2 + qk**2) R[:, 0, 1] = 2 * (qj *qi -qk*qr) R[:, 0, 2] = 2 * (qi * qk + qr * qj) R[:, 1, 0] = 2 * (qj * qi + qk * qr) R[:, 1, 1] = 1-2 * (qi**2 + qk**2) R[:, 1, 2] = 2*(qj*qk - qi*qr) R[:, 2, 0] = 2 * (qk * qi-qj * qr) R[:, 2, 1] = 2 * (qj*qk + qi*qr) R[:, 2, 2] = 1-2 * (qi**2 + qj**2) return R def get_camera_params(uv, pose, intrinsics): if pose.shape[1] == 7: #In case of quaternion vector representation cam_loc = pose[:, 4:] R = quat_to_rot(pose[:,:4]) p = torch.eye(4).repeat(pose.shape[0],1,1).cuda().float() p[:, :3, :3] = R p[:, :3, 3] = cam_loc else: # In case of pose matrix representation cam_loc = pose[:, :3, 3] p = pose batch_size, num_samples, _ = uv.shape depth = torch.ones((batch_size, num_samples)).cuda() x_cam = uv[:, :, 0].view(batch_size, -1) y_cam = uv[:, :, 1].view(batch_size, -1) z_cam = depth.view(batch_size, -1) pixel_points_cam = lift(x_cam, y_cam, z_cam, intrinsics=intrinsics) # permute for batch matrix product pixel_points_cam = pixel_points_cam.permute(0, 2, 1) world_coords = torch.bmm(p, pixel_points_cam).permute(0, 2, 1)[:, :, :3] ray_dirs = world_coords - cam_loc[:, None, :] ray_dirs = F.normalize(ray_dirs, dim=2) return ray_dirs, cam_loc

import numpy as np import cv2 import torch from torch.nn import functional as F def rot_to_quat(R): batch_size, _,_ = R.shape q = torch.ones((batch_size, 4)).cuda() R00 = R[:, 0,0] R01 = R[:, 0, 1] R02 = R[:, 0, 2] R10 = R[:, 1, 0] R11 = R[:, 1, 1] R12 = R[:, 1, 2] R20 = R[:, 2, 0] R21 = R[:, 2, 1] R22 = R[:, 2, 2] q[:,0]=torch.sqrt(1.0+R00+R11+R22)/2 q[:, 1]=(R21-R12)/(4*q[:,0]) q[:, 2] = (R02 - R20) / (4 * q[:, 0]) q[:, 3] = (R10 - R01) / (4 * q[:, 0]) return q

import numpy as np import cv2 import torch from torch.nn import functional as F def get_sphere_intersections(cam_loc, ray_directions, r = 1.0): # Input: n_rays x 3 ; n_rays x 3 # Output: n_rays x 1, n_rays x 1 (close and far) ray_cam_dot = torch.bmm(ray_directions.view(-1, 1, 3), cam_loc.view(-1, 3, 1)).squeeze(-1) under_sqrt = ray_cam_dot ** 2 - (cam_loc.norm(2, 1, keepdim=True) ** 2 - r ** 2) # sanity check if (under_sqrt <= 0).sum() > 0: print('BOUNDING SPHERE PROBLEM!') exit() sphere_intersections = torch.sqrt(under_sqrt) * torch.Tensor([-1, 1]).cuda().float() - ray_cam_dot sphere_intersections = sphere_intersections.clamp_min(0.0) return sphere_intersections

import numpy as np import cv2 import torch from torch.nn import functional as F def bilinear_interpolation(xs, ys, dist_map): x1 = np.floor(xs).astype(np.int32) y1 = np.floor(ys).astype(np.int32) x2 = x1 + 1 y2 = y1 + 1 dx = np.expand_dims(np.stack([x2 - xs, xs - x1], axis=1), axis=1) dy = np.expand_dims(np.stack([y2 - ys, ys - y1], axis=1), axis=2) Q = np.stack([ dist_map[x1, y1], dist_map[x1, y2], dist_map[x2, y1], dist_map[x2, y2] ], axis=1).reshape(-1, 2, 2) return np.squeeze(dx @ Q @ dy) # ((x2 - x1) * (y2 - y1)) = 1 def get_index_outside_of_bbox(samples_uniform, bbox_min, bbox_max): samples_uniform_row = samples_uniform[:, 0] samples_uniform_col = samples_uniform[:, 1] index_outside = np.where((samples_uniform_row < bbox_min[0]) | (samples_uniform_row > bbox_max[0]) | (samples_uniform_col < bbox_min[1]) | (samples_uniform_col > bbox_max[1]))[0] return index_outside The provided code snippet includes necessary dependencies for implementing the `weighted_sampling` function. Write a Python function `def weighted_sampling(data, img_size, num_sample, bbox_ratio=0.9)` to solve the following problem: More sampling within the bounding box Here is the function: def weighted_sampling(data, img_size, num_sample, bbox_ratio=0.9): """ More sampling within the bounding box """ # calculate bounding box mask = data["object_mask"] where = np.asarray(np.where(mask)) bbox_min = where.min(axis=1) bbox_max = where.max(axis=1) num_sample_bbox = int(num_sample * bbox_ratio) samples_bbox = np.random.rand(num_sample_bbox, 2) samples_bbox = samples_bbox * (bbox_max - bbox_min) + bbox_min num_sample_uniform = num_sample - num_sample_bbox samples_uniform = np.random.rand(num_sample_uniform, 2) samples_uniform *= (img_size[0] - 1, img_size[1] - 1) # get indices for uniform samples outside of bbox index_outside = get_index_outside_of_bbox(samples_uniform, bbox_min, bbox_max) + num_sample_bbox indices = np.concatenate([samples_bbox, samples_uniform], axis=0) output = {} for key, val in data.items(): if len(val.shape) == 3: new_val = np.stack([ bilinear_interpolation(indices[:, 0], indices[:, 1], val[:, :, i]) for i in range(val.shape[2]) ], axis=-1) else: new_val = bilinear_interpolation(indices[:, 0], indices[:, 1], val) new_val = new_val.reshape(-1, *val.shape[2:]) output[key] = new_val return output, index_outside

More sampling within the bounding box

import numpy as np import torch from skimage import measure from lib.libmise import mise import trimesh def generate_mesh(func, verts, level_set=0, res_init=32, res_up=3, point_batch=5000): scale = 1.1 # Scale of the padded bbox regarding the tight one. verts = verts.data.cpu().numpy() gt_bbox = np.stack([verts.min(axis=0), verts.max(axis=0)], axis=0) gt_center = (gt_bbox[0] + gt_bbox[1]) * 0.5 gt_scale = (gt_bbox[1] - gt_bbox[0]).max() mesh_extractor = mise.MISE(res_init, res_up, level_set) points = mesh_extractor.query() # query occupancy grid while points.shape[0] != 0: orig_points = points points = points.astype(np.float32) points = (points / mesh_extractor.resolution - 0.5) * scale points = points * gt_scale + gt_center points = torch.tensor(points).float().cuda() values = [] for _, pnts in enumerate((torch.split(points,point_batch,dim=0))): out = func(pnts) values.append(out['sdf'].data.cpu().numpy()) values = np.concatenate(values, axis=0).astype(np.float64)[:,0] mesh_extractor.update(orig_points, values) points = mesh_extractor.query() value_grid = mesh_extractor.to_dense() # marching cube verts, faces, normals, values = measure.marching_cubes_lewiner( volume=value_grid, gradient_direction='ascent', level=level_set) verts = (verts / mesh_extractor.resolution - 0.5) * scale verts = verts * gt_scale + gt_center faces = faces[:, [0,2,1]] meshexport = trimesh.Trimesh(verts, faces, normals, vertex_colors=values) #remove disconnect part connected_comp = meshexport.split(only_watertight=False) max_area = 0 max_comp = None for comp in connected_comp: if comp.area > max_area: max_area = comp.area max_comp = comp meshexport = max_comp return meshexport

import trimesh from aitviewer.viewer import Viewer from aitviewer.renderables.meshes import Meshes, VariableTopologyMeshes import glob import argparse def vis_dynamic(args): vertices = [] faces = [] vertex_normals = [] deformed_mesh_paths = sorted(glob.glob(f'{args.path}/*_deformed.ply')) for deformed_mesh_path in deformed_mesh_paths: mesh = trimesh.load(deformed_mesh_path, process=False) # center the human mesh.vertices = mesh.vertices - mesh.vertices.mean(axis=0) vertices.append(mesh.vertices) faces.append(mesh.faces) vertex_normals.append(mesh.vertex_normals) meshes = VariableTopologyMeshes(vertices, faces, vertex_normals, preload=True ) meshes.norm_coloring = True meshes.flat_shading = True viewer = Viewer() viewer.scene.add(meshes) viewer.scene.origin.enabled = False viewer.scene.floor.enabled = True viewer.run()

import trimesh from aitviewer.viewer import Viewer from aitviewer.renderables.meshes import Meshes, VariableTopologyMeshes import glob import argparse def vis_static(args): mesh = trimesh.load(args.path, process=False) mesh = Meshes(mesh.vertices, mesh.faces, mesh.vertex_normals, name='mesh', flat_shading=True) mesh.norm_coloring = True viewer = Viewer() viewer.scene.add(mesh) viewer.scene.origin.enabled = False viewer.scene.floor.enabled = True viewer.run()

import sys import cv2 import os import numpy as np import argparse import time import glob from sklearn.neighbors import NearestNeighbors def get_bbox_center(img_path, mask_path): _img = cv2.imread(img_path) W, H = _img.shape[1], _img.shape[0] mask = cv2.imread(mask_path)[:, :, 0] where = np.asarray(np.where(mask)) bbox_min = where.min(axis=1) bbox_max = where.max(axis=1) left, top, right, bottom = bbox_min[1], bbox_min[0], bbox_max[1], bbox_max[ 0] left = max(left, 0) top = max(top, 0) right = min(right, W) bottom = min(bottom, H) bbox_center = np.array([left + (right - left) / 2, top + (bottom - top) / 2]) return bbox_center

import numpy as np import cv2 import torch import torch.nn as nn import torch.nn.functional as F from pytorch3d.renderer import ( SfMPerspectiveCameras, RasterizationSettings, MeshRenderer, MeshRasterizer, SoftPhongShader, PointLights, ) from pytorch3d.structures import Meshes from pytorch3d.renderer.mesh import Textures The provided code snippet includes necessary dependencies for implementing the `smpl_to_pose` function. Write a Python function `def smpl_to_pose(model_type='smplx', use_hands=True, use_face=True, use_face_contour=False, openpose_format='coco25')` to solve the following problem: Returns the indices of the permutation that maps OpenPose to SMPL Parameters ---------- model_type: str, optional The type of SMPL-like model that is used. The default mapping returned is for the SMPLX model use_hands: bool, optional Flag for adding to the returned permutation the mapping for the hand keypoints. Defaults to True use_face: bool, optional Flag for adding to the returned permutation the mapping for the face keypoints. Defaults to True use_face_contour: bool, optional Flag for appending the facial contour keypoints. Defaults to False openpose_format: bool, optional The output format of OpenPose. For now only COCO-25 and COCO-19 is supported. Defaults to 'coco25' Here is the function: def smpl_to_pose(model_type='smplx', use_hands=True, use_face=True, use_face_contour=False, openpose_format='coco25'): ''' Returns the indices of the permutation that maps OpenPose to SMPL Parameters ---------- model_type: str, optional The type of SMPL-like model that is used. The default mapping returned is for the SMPLX model use_hands: bool, optional Flag for adding to the returned permutation the mapping for the hand keypoints. Defaults to True use_face: bool, optional Flag for adding to the returned permutation the mapping for the face keypoints. Defaults to True use_face_contour: bool, optional Flag for appending the facial contour keypoints. Defaults to False openpose_format: bool, optional The output format of OpenPose. For now only COCO-25 and COCO-19 is supported. Defaults to 'coco25' ''' if openpose_format.lower() == 'coco25': if model_type == 'smpl': return np.array([24, 12, 17, 19, 21, 16, 18, 20, 0, 2, 5, 8, 1, 4, 7, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34], dtype=np.int32) elif model_type == 'smplh': body_mapping = np.array([52, 12, 17, 19, 21, 16, 18, 20, 0, 2, 5, 8, 1, 4, 7, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62], dtype=np.int32) mapping = [body_mapping] if use_hands: lhand_mapping = np.array([20, 34, 35, 36, 63, 22, 23, 24, 64, 25, 26, 27, 65, 31, 32, 33, 66, 28, 29, 30, 67], dtype=np.int32) rhand_mapping = np.array([21, 49, 50, 51, 68, 37, 38, 39, 69, 40, 41, 42, 70, 46, 47, 48, 71, 43, 44, 45, 72], dtype=np.int32) mapping += [lhand_mapping, rhand_mapping] return np.concatenate(mapping) # SMPLX elif model_type == 'smplx': body_mapping = np.array([55, 12, 17, 19, 21, 16, 18, 20, 0, 2, 5, 8, 1, 4, 7, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65], dtype=np.int32) mapping = [body_mapping] if use_hands: lhand_mapping = np.array([20, 37, 38, 39, 66, 25, 26, 27, 67, 28, 29, 30, 68, 34, 35, 36, 69, 31, 32, 33, 70], dtype=np.int32) rhand_mapping = np.array([21, 52, 53, 54, 71, 40, 41, 42, 72, 43, 44, 45, 73, 49, 50, 51, 74, 46, 47, 48, 75], dtype=np.int32) mapping += [lhand_mapping, rhand_mapping] if use_face: # end_idx = 127 + 17 * use_face_contour face_mapping = np.arange(76, 127 + 17 * use_face_contour, dtype=np.int32) mapping += [face_mapping] return np.concatenate(mapping) else: raise ValueError('Unknown model type: {}'.format(model_type)) elif openpose_format == 'coco19': if model_type == 'smpl': return np.array([24, 12, 17, 19, 21, 16, 18, 20, 2, 5, 8, 1, 4, 7, 25, 26, 27, 28], dtype=np.int32) elif model_type == 'smpl_neutral': return np.array([14, 12, 8, 7, 6, 9, 10, 11, 2, 1, 0, 3, 4, 5, 16, 15,18, 17,], dtype=np.int32) elif model_type == 'smplh': body_mapping = np.array([52, 12, 17, 19, 21, 16, 18, 20, 0, 2, 5, 8, 1, 4, 7, 53, 54, 55, 56], dtype=np.int32) mapping = [body_mapping] if use_hands: lhand_mapping = np.array([20, 34, 35, 36, 57, 22, 23, 24, 58, 25, 26, 27, 59, 31, 32, 33, 60, 28, 29, 30, 61], dtype=np.int32) rhand_mapping = np.array([21, 49, 50, 51, 62, 37, 38, 39, 63, 40, 41, 42, 64, 46, 47, 48, 65, 43, 44, 45, 66], dtype=np.int32) mapping += [lhand_mapping, rhand_mapping] return np.concatenate(mapping) # SMPLX elif model_type == 'smplx': body_mapping = np.array([55, 12, 17, 19, 21, 16, 18, 20, 0, 2, 5, 8, 1, 4, 7, 56, 57, 58, 59], dtype=np.int32) mapping = [body_mapping] if use_hands: lhand_mapping = np.array([20, 37, 38, 39, 60, 25, 26, 27, 61, 28, 29, 30, 62, 34, 35, 36, 63, 31, 32, 33, 64], dtype=np.int32) rhand_mapping = np.array([21, 52, 53, 54, 65, 40, 41, 42, 66, 43, 44, 45, 67, 49, 50, 51, 68, 46, 47, 48, 69], dtype=np.int32) mapping += [lhand_mapping, rhand_mapping] if use_face: face_mapping = np.arange(70, 70 + 51 + 17 * use_face_contour, dtype=np.int32) mapping += [face_mapping] return np.concatenate(mapping) else: raise ValueError('Unknown model type: {}'.format(model_type)) elif openpose_format == 'h36': if model_type == 'smpl': return np.array([2,5,8,1,4,7,12,24,16,18,20,17,19,21],dtype=np.int32) elif model_type == 'smpl_neutral': #return np.array([2,1,0,3,4,5,12,13,9,10,11,8,7,6], dtype=np.int32) return [6, 5, 4, 1, 2, 3, 16, 15, 14, 11, 12, 13, 8, 10] else: raise ValueError('Unknown joint format: {}'.format(openpose_format))

Returns the indices of the permutation that maps OpenPose to SMPL Parameters ---------- model_type: str, optional The type of SMPL-like model that is used. The default mapping returned is for the SMPLX model use_hands: bool, optional Flag for adding to the returned permutation the mapping for the hand keypoints. Defaults to True use_face: bool, optional Flag for adding to the returned permutation the mapping for the face keypoints. Defaults to True use_face_contour: bool, optional Flag for appending the facial contour keypoints. Defaults to False openpose_format: bool, optional The output format of OpenPose. For now only COCO-25 and COCO-19 is supported. Defaults to 'coco25'

import numpy as np import cv2 import torch import torch.nn as nn import torch.nn.functional as F from pytorch3d.renderer import ( SfMPerspectiveCameras, RasterizationSettings, MeshRenderer, MeshRasterizer, SoftPhongShader, PointLights, ) from pytorch3d.structures import Meshes from pytorch3d.renderer.mesh import Textures def render_trimesh(renderer,mesh,R,T, mode='np'): verts = torch.tensor(mesh.vertices).cuda().float()[None] faces = torch.tensor(mesh.faces).cuda()[None] colors = torch.tensor(mesh.visual.vertex_colors).float().cuda()[None,...,:3]/255 renderer.set_camera(R,T) image = renderer.render_mesh_recon(verts, faces, colors=colors, mode=mode)[0] image = (255*image).data.cpu().numpy().astype(np.uint8) return image

import numpy as np import cv2 import torch import torch.nn as nn import torch.nn.functional as F from pytorch3d.renderer import ( SfMPerspectiveCameras, RasterizationSettings, MeshRenderer, MeshRasterizer, SoftPhongShader, PointLights, ) from pytorch3d.structures import Meshes from pytorch3d.renderer.mesh import Textures INVALID_TRANS=np.ones(3)*-1 def estimate_translation_cv2(joints_3d, joints_2d, focal_length=600, img_size=np.array([512.,512.]), proj_mat=None, cam_dist=None): if proj_mat is None: camK = np.eye(3) camK[0,0], camK[1,1] = focal_length, focal_length camK[:2,2] = img_size//2 else: camK = proj_mat _, _, tvec,inliers = cv2.solvePnPRansac(joints_3d, joints_2d, camK, cam_dist,\ flags=cv2.SOLVEPNP_EPNP,reprojectionError=20,iterationsCount=100) if inliers is None: return INVALID_TRANS else: tra_pred = tvec[:,0] return tra_pred

import numpy as np import cv2 import torch import torch.nn as nn import torch.nn.functional as F from pytorch3d.renderer import ( SfMPerspectiveCameras, RasterizationSettings, MeshRenderer, MeshRasterizer, SoftPhongShader, PointLights, ) from pytorch3d.structures import Meshes from pytorch3d.renderer.mesh import Textures The provided code snippet includes necessary dependencies for implementing the `transform_mat` function. Write a Python function `def transform_mat(R, t)` to solve the following problem: Creates a batch of transformation matrices Args: - R: Bx3x3 array of a batch of rotation matrices - t: Bx3x1 array of a batch of translation vectors Returns: - T: Bx4x4 Transformation matrix Here is the function: def transform_mat(R, t): ''' Creates a batch of transformation matrices Args: - R: Bx3x3 array of a batch of rotation matrices - t: Bx3x1 array of a batch of translation vectors Returns: - T: Bx4x4 Transformation matrix ''' # No padding left or right, only add an extra row return torch.cat([F.pad(R, [0, 0, 0, 1]), F.pad(t, [0, 0, 0, 1], value=1)], dim=2)

Creates a batch of transformation matrices Args: - R: Bx3x3 array of a batch of rotation matrices - t: Bx3x1 array of a batch of translation vectors Returns: - T: Bx4x4 Transformation matrix

import numpy as np import cv2 import torch import torch.nn as nn import torch.nn.functional as F from pytorch3d.renderer import ( SfMPerspectiveCameras, RasterizationSettings, MeshRenderer, MeshRasterizer, SoftPhongShader, PointLights, ) from pytorch3d.structures import Meshes from pytorch3d.renderer.mesh import Textures def transform_smpl(curr_extrinsic, target_extrinsic, smpl_pose, smpl_trans, T_hip): R_root = cv2.Rodrigues(smpl_pose[:3])[0] transf_global_ori = np.linalg.inv(target_extrinsic[:3,:3]) @ curr_extrinsic[:3,:3] @ R_root target_extrinsic[:3, -1] = curr_extrinsic[:3,:3] @ (smpl_trans + T_hip) + curr_extrinsic[:3, -1] - smpl_trans - target_extrinsic[:3,:3] @ T_hip smpl_pose[:3] = cv2.Rodrigues(transf_global_ori)[0].reshape(3) smpl_trans = np.linalg.inv(target_extrinsic[:3,:3]) @ smpl_trans # we assume return target_extrinsic, smpl_pose, smpl_trans

from preprocessing_utils import GMoF import torch def get_loss_weights(): loss_weight = {'J2D_Loss': lambda cst, it: 1e-2 * cst, 'Temporal_Loss': lambda cst, it: 6e0 * cst, } return loss_weight

from preprocessing_utils import GMoF import torch joint_weights = torch.ones(num_joints) joint_weights[joints_to_ign] = 0 joint_weights = joint_weights.reshape((-1,1)).cuda() robustifier = GMoF(rho=100) def joints_2d_loss(gt_joints_2d=None, joints_2d=None, joint_confidence=None): joint_diff = robustifier(gt_joints_2d - joints_2d) joints_2dloss = torch.mean((joint_confidence*joint_weights[:, 0]).unsqueeze(-1) ** 2 * joint_diff) return joints_2dloss

from preprocessing_utils import GMoF import torch def pose_temporal_loss(last_pose, param_pose): temporal_loss = torch.mean(torch.square(last_pose - param_pose)) return temporal_loss

import cv2 import numpy as np import argparse def get_center_point(num_cams,cameras): def normalize_cameras(original_cameras_filename,output_cameras_filename,num_of_cameras, scene_bounding_sphere=3.0): cameras = np.load(original_cameras_filename) if num_of_cameras==-1: all_files=cameras.files maximal_ind=0 for field in all_files: maximal_ind=np.maximum(maximal_ind,int(field.split('_')[-1])) num_of_cameras=maximal_ind+1 camera_centers = get_center_point(num_of_cameras, cameras) center = np.array([0, 0, 0]) max_radius = np.linalg.norm((center[:, np.newaxis] - camera_centers), axis=0).max() * 1.1 normalization = np.eye(4).astype(np.float32) normalization[0, 0] = max_radius / scene_bounding_sphere normalization[1, 1] = max_radius / scene_bounding_sphere normalization[2, 2] = max_radius / scene_bounding_sphere cameras_new = {} for i in range(num_of_cameras): cameras_new['scale_mat_%d' % i] = normalization cameras_new['world_mat_%d' % i] = cameras['cam_%d' % i].copy() np.savez(output_cameras_filename, **cameras_new)

from typing import Optional, Dict, Union import os import os.path as osp import pickle import numpy as np import torch import torch.nn as nn from .lbs import ( lbs, vertices2landmarks, find_dynamic_lmk_idx_and_bcoords, vertices2joints, blend_shapes) from .vertex_ids import vertex_ids as VERTEX_IDS from .utils import ( Struct, to_np, to_tensor, Tensor, Array, SMPLOutput, SMPLHOutput, SMPLXOutput, MANOOutput, FLAMEOutput, find_joint_kin_chain) from .vertex_joint_selector import VertexJointSelector class SMPLLayer(SMPL): def __init__( self, *args ) -> None: # Just create a SMPL module without any member variables super(SMPLLayer, self).__init__( create_body_pose=False, create_betas=False, create_global_orient=False, create_transl=False, *args, ) def forward( self, betas: Optional[Tensor] = None, body_pose: Optional[Tensor] = None, global_orient: Optional[Tensor] = None, transl: Optional[Tensor] = None, return_verts=True, return_full_pose: bool = False, pose2rot: bool = True ) -> SMPLOutput: ''' Forward pass for the SMPL model Parameters ---------- global_orient: torch.tensor, optional, shape Bx3x3 Global rotation of the body. Useful if someone wishes to predicts this with an external model. It is expected to be in rotation matrix format. (default=None) betas: torch.tensor, optional, shape BxN_b Shape parameters. For example, it can used if shape parameters `betas` are predicted from some external model. (default=None) body_pose: torch.tensor, optional, shape BxJx3x3 Body pose. For example, it can used if someone predicts the pose of the body joints are predicted from some external model. It should be a tensor that contains joint rotations in rotation matrix format. (default=None) transl: torch.tensor, optional, shape Bx3 Translation vector of the body. For example, it can used if the translation `transl` is predicted from some external model. (default=None) return_verts: bool, optional Return the vertices. (default=True) return_full_pose: bool, optional Returns the full axis-angle pose vector (default=False) Returns ------- ''' model_vars = [betas, global_orient, body_pose, transl] batch_size = 1 for var in model_vars: if var is None: continue batch_size = max(batch_size, len(var)) device, dtype = self.shapedirs.device, self.shapedirs.dtype if global_orient is None: global_orient = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand(batch_size, -1, -1, -1).contiguous() if body_pose is None: body_pose = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand( batch_size, self.NUM_BODY_JOINTS, -1, -1).contiguous() if betas is None: betas = torch.zeros([batch_size, self.num_betas], dtype=dtype, device=device) if transl is None: transl = torch.zeros([batch_size, 3], dtype=dtype, device=device) full_pose = torch.cat( [global_orient.reshape(-1, 1, 3, 3), body_pose.reshape(-1, self.NUM_BODY_JOINTS, 3, 3)], dim=1) vertices, joints = lbs(betas, full_pose, self.v_template, self.shapedirs, self.posedirs, self.J_regressor, self.parents, self.lbs_weights, pose2rot=False) joints = self.vertex_joint_selector(vertices, joints) # Map the joints to the current dataset if self.joint_mapper is not None: joints = self.joint_mapper(joints) if transl is not None: joints += transl.unsqueeze(dim=1) vertices += transl.unsqueeze(dim=1) output = SMPLOutput(vertices=vertices if return_verts else None, global_orient=global_orient, body_pose=body_pose, joints=joints, betas=betas, full_pose=full_pose if return_full_pose else None) return output class SMPLHLayer(SMPLH): def __init__( self, *args ) -> None: ''' SMPL+H as a layer model constructor ''' super(SMPLHLayer, self).__init__( create_global_orient=False, create_body_pose=False, create_left_hand_pose=False, create_right_hand_pose=False, create_betas=False, create_transl=False, *args) def forward( self, betas: Optional[Tensor] = None, global_orient: Optional[Tensor] = None, body_pose: Optional[Tensor] = None, left_hand_pose: Optional[Tensor] = None, right_hand_pose: Optional[Tensor] = None, transl: Optional[Tensor] = None, return_verts: bool = True, return_full_pose: bool = False, pose2rot: bool = True ) -> SMPLHOutput: ''' Forward pass for the SMPL+H model Parameters ---------- global_orient: torch.tensor, optional, shape Bx3x3 Global rotation of the body. Useful if someone wishes to predicts this with an external model. It is expected to be in rotation matrix format. (default=None) betas: torch.tensor, optional, shape BxN_b Shape parameters. For example, it can used if shape parameters `betas` are predicted from some external model. (default=None) body_pose: torch.tensor, optional, shape BxJx3x3 If given, ignore the member variable `body_pose` and use it instead. For example, it can used if someone predicts the pose of the body joints are predicted from some external model. It should be a tensor that contains joint rotations in rotation matrix format. (default=None) left_hand_pose: torch.tensor, optional, shape Bx15x3x3 If given, contains the pose of the left hand. It should be a tensor that contains joint rotations in rotation matrix format. (default=None) right_hand_pose: torch.tensor, optional, shape Bx15x3x3 If given, contains the pose of the right hand. It should be a tensor that contains joint rotations in rotation matrix format. (default=None) transl: torch.tensor, optional, shape Bx3 Translation vector of the body. For example, it can used if the translation `transl` is predicted from some external model. (default=None) return_verts: bool, optional Return the vertices. (default=True) return_full_pose: bool, optional Returns the full axis-angle pose vector (default=False) Returns ------- ''' model_vars = [betas, global_orient, body_pose, transl, left_hand_pose, right_hand_pose] batch_size = 1 for var in model_vars: if var is None: continue batch_size = max(batch_size, len(var)) device, dtype = self.shapedirs.device, self.shapedirs.dtype if global_orient is None: global_orient = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand(batch_size, -1, -1, -1).contiguous() if body_pose is None: body_pose = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand(batch_size, 21, -1, -1).contiguous() if left_hand_pose is None: left_hand_pose = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand(batch_size, 15, -1, -1).contiguous() if right_hand_pose is None: right_hand_pose = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand(batch_size, 15, -1, -1).contiguous() if betas is None: betas = torch.zeros([batch_size, self.num_betas], dtype=dtype, device=device) if transl is None: transl = torch.zeros([batch_size, 3], dtype=dtype, device=device) # Concatenate all pose vectors full_pose = torch.cat( [global_orient.reshape(-1, 1, 3, 3), body_pose.reshape(-1, self.NUM_BODY_JOINTS, 3, 3), left_hand_pose.reshape(-1, self.NUM_HAND_JOINTS, 3, 3), right_hand_pose.reshape(-1, self.NUM_HAND_JOINTS, 3, 3)], dim=1) vertices, joints = lbs(betas, full_pose, self.v_template, self.shapedirs, self.posedirs, self.J_regressor, self.parents, self.lbs_weights, pose2rot=False) # Add any extra joints that might be needed joints = self.vertex_joint_selector(vertices, joints) if self.joint_mapper is not None: joints = self.joint_mapper(joints) if transl is not None: joints += transl.unsqueeze(dim=1) vertices += transl.unsqueeze(dim=1) output = SMPLHOutput(vertices=vertices if return_verts else None, joints=joints, betas=betas, global_orient=global_orient, body_pose=body_pose, left_hand_pose=left_hand_pose, right_hand_pose=right_hand_pose, full_pose=full_pose if return_full_pose else None) return output class SMPLXLayer(SMPLX): def __init__( self, *args ) -> None: # Just create a SMPLX module without any member variables super(SMPLXLayer, self).__init__( create_global_orient=False, create_body_pose=False, create_left_hand_pose=False, create_right_hand_pose=False, create_jaw_pose=False, create_leye_pose=False, create_reye_pose=False, create_betas=False, create_expression=False, create_transl=False, *args, ) def forward( self, betas: Optional[Tensor] = None, global_orient: Optional[Tensor] = None, body_pose: Optional[Tensor] = None, left_hand_pose: Optional[Tensor] = None, right_hand_pose: Optional[Tensor] = None, transl: Optional[Tensor] = None, expression: Optional[Tensor] = None, jaw_pose: Optional[Tensor] = None, leye_pose: Optional[Tensor] = None, reye_pose: Optional[Tensor] = None, return_verts: bool = True, return_full_pose: bool = False ) -> SMPLXOutput: ''' Forward pass for the SMPLX model Parameters ---------- global_orient: torch.tensor, optional, shape Bx3x3 If given, ignore the member variable and use it as the global rotation of the body. Useful if someone wishes to predicts this with an external model. It is expected to be in rotation matrix format. (default=None) betas: torch.tensor, optional, shape BxN_b If given, ignore the member variable `betas` and use it instead. For example, it can used if shape parameters `betas` are predicted from some external model. (default=None) expression: torch.tensor, optional, shape BxN_e Expression coefficients. For example, it can used if expression parameters `expression` are predicted from some external model. body_pose: torch.tensor, optional, shape BxJx3x3 If given, ignore the member variable `body_pose` and use it instead. For example, it can used if someone predicts the pose of the body joints are predicted from some external model. It should be a tensor that contains joint rotations in rotation matrix format. (default=None) left_hand_pose: torch.tensor, optional, shape Bx15x3x3 If given, contains the pose of the left hand. It should be a tensor that contains joint rotations in rotation matrix format. (default=None) right_hand_pose: torch.tensor, optional, shape Bx15x3x3 If given, contains the pose of the right hand. It should be a tensor that contains joint rotations in rotation matrix format. (default=None) jaw_pose: torch.tensor, optional, shape Bx3x3 Jaw pose. It should either joint rotations in rotation matrix format. transl: torch.tensor, optional, shape Bx3 Translation vector of the body. For example, it can used if the translation `transl` is predicted from some external model. (default=None) return_verts: bool, optional Return the vertices. (default=True) return_full_pose: bool, optional Returns the full pose vector (default=False) Returns ------- output: ModelOutput A data class that contains the posed vertices and joints ''' device, dtype = self.shapedirs.device, self.shapedirs.dtype model_vars = [betas, global_orient, body_pose, transl, expression, left_hand_pose, right_hand_pose, jaw_pose] batch_size = 1 for var in model_vars: if var is None: continue batch_size = max(batch_size, len(var)) if global_orient is None: global_orient = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand(batch_size, -1, -1, -1).contiguous() if body_pose is None: body_pose = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand( batch_size, self.NUM_BODY_JOINTS, -1, -1).contiguous() if left_hand_pose is None: left_hand_pose = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand(batch_size, 15, -1, -1).contiguous() if right_hand_pose is None: right_hand_pose = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand(batch_size, 15, -1, -1).contiguous() if jaw_pose is None: jaw_pose = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand(batch_size, -1, -1, -1).contiguous() if leye_pose is None: leye_pose = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand(batch_size, -1, -1, -1).contiguous() if reye_pose is None: reye_pose = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand(batch_size, -1, -1, -1).contiguous() if expression is None: expression = torch.zeros([batch_size, self.num_expression_coeffs], dtype=dtype, device=device) if betas is None: betas = torch.zeros([batch_size, self.num_betas], dtype=dtype, device=device) if transl is None: transl = torch.zeros([batch_size, 3], dtype=dtype, device=device) # Concatenate all pose vectors full_pose = torch.cat( [global_orient.reshape(-1, 1, 3, 3), body_pose.reshape(-1, self.NUM_BODY_JOINTS, 3, 3), jaw_pose.reshape(-1, 1, 3, 3), leye_pose.reshape(-1, 1, 3, 3), reye_pose.reshape(-1, 1, 3, 3), left_hand_pose.reshape(-1, self.NUM_HAND_JOINTS, 3, 3), right_hand_pose.reshape(-1, self.NUM_HAND_JOINTS, 3, 3)], dim=1) shape_components = torch.cat([betas, expression], dim=-1) shapedirs = torch.cat([self.shapedirs, self.expr_dirs], dim=-1) vertices, joints = lbs(shape_components, full_pose, self.v_template, shapedirs, self.posedirs, self.J_regressor, self.parents, self.lbs_weights, pose2rot=False) lmk_faces_idx = self.lmk_faces_idx.unsqueeze( dim=0).expand(batch_size, -1).contiguous() lmk_bary_coords = self.lmk_bary_coords.unsqueeze(dim=0).repeat( batch_size, 1, 1) if self.use_face_contour: lmk_idx_and_bcoords = find_dynamic_lmk_idx_and_bcoords( vertices, full_pose, self.dynamic_lmk_faces_idx, self.dynamic_lmk_bary_coords, self.neck_kin_chain, pose2rot=False, ) dyn_lmk_faces_idx, dyn_lmk_bary_coords = lmk_idx_and_bcoords lmk_faces_idx = torch.cat([lmk_faces_idx, dyn_lmk_faces_idx], 1) lmk_bary_coords = torch.cat( [lmk_bary_coords.expand(batch_size, -1, -1), dyn_lmk_bary_coords], 1) landmarks = vertices2landmarks(vertices, self.faces_tensor, lmk_faces_idx, lmk_bary_coords) # Add any extra joints that might be needed joints = self.vertex_joint_selector(vertices, joints) # Add the landmarks to the joints joints = torch.cat([joints, landmarks], dim=1) # Map the joints to the current dataset if self.joint_mapper is not None: joints = self.joint_mapper(joints=joints, vertices=vertices) if transl is not None: joints += transl.unsqueeze(dim=1) vertices += transl.unsqueeze(dim=1) output = SMPLXOutput(vertices=vertices if return_verts else None, joints=joints, betas=betas, expression=expression, global_orient=global_orient, body_pose=body_pose, left_hand_pose=left_hand_pose, right_hand_pose=right_hand_pose, jaw_pose=jaw_pose, transl=transl, full_pose=full_pose if return_full_pose else None) return output class MANOLayer(MANO): def __init__(self, *args) -> None: ''' MANO as a layer model constructor ''' super(MANOLayer, self).__init__( create_global_orient=False, create_hand_pose=False, create_betas=False, create_transl=False, *args) def name(self) -> str: return 'MANO' def forward( self, betas: Optional[Tensor] = None, global_orient: Optional[Tensor] = None, hand_pose: Optional[Tensor] = None, transl: Optional[Tensor] = None, return_verts: bool = True, return_full_pose: bool = False ) -> MANOOutput: ''' Forward pass for the MANO model ''' device, dtype = self.shapedirs.device, self.shapedirs.dtype if global_orient is None: batch_size = 1 global_orient = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand(batch_size, -1, -1, -1).contiguous() else: batch_size = global_orient.shape[0] if hand_pose is None: hand_pose = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand(batch_size, 15, -1, -1).contiguous() if betas is None: betas = torch.zeros( [batch_size, self.num_betas], dtype=dtype, device=device) if transl is None: transl = torch.zeros([batch_size, 3], dtype=dtype, device=device) full_pose = torch.cat([global_orient, hand_pose], dim=1) vertices, joints = lbs(betas, full_pose, self.v_template, self.shapedirs, self.posedirs, self.J_regressor, self.parents, self.lbs_weights, pose2rot=False) if self.joint_mapper is not None: joints = self.joint_mapper(joints) if transl is not None: joints = joints + transl.unsqueeze(dim=1) vertices = vertices + transl.unsqueeze(dim=1) output = MANOOutput( vertices=vertices if return_verts else None, joints=joints if return_verts else None, betas=betas, global_orient=global_orient, hand_pose=hand_pose, full_pose=full_pose if return_full_pose else None) return output class FLAMELayer(FLAME): def __init__(self, *args) -> None: ''' FLAME as a layer model constructor ''' super(FLAMELayer, self).__init__( create_betas=False, create_expression=False, create_global_orient=False, create_neck_pose=False, create_jaw_pose=False, create_leye_pose=False, create_reye_pose=False, *args) def forward( self, betas: Optional[Tensor] = None, global_orient: Optional[Tensor] = None, neck_pose: Optional[Tensor] = None, transl: Optional[Tensor] = None, expression: Optional[Tensor] = None, jaw_pose: Optional[Tensor] = None, leye_pose: Optional[Tensor] = None, reye_pose: Optional[Tensor] = None, return_verts: bool = True, return_full_pose: bool = False, pose2rot: bool = True ) -> FLAMEOutput: ''' Forward pass for the SMPLX model Parameters ---------- global_orient: torch.tensor, optional, shape Bx3x3 Global rotation of the body. Useful if someone wishes to predicts this with an external model. It is expected to be in rotation matrix format. (default=None) betas: torch.tensor, optional, shape BxN_b Shape parameters. For example, it can used if shape parameters `betas` are predicted from some external model. (default=None) expression: torch.tensor, optional, shape BxN_e If given, ignore the member variable `expression` and use it instead. For example, it can used if expression parameters `expression` are predicted from some external model. jaw_pose: torch.tensor, optional, shape Bx3x3 Jaw pose. It should either joint rotations in rotation matrix format. transl: torch.tensor, optional, shape Bx3 Translation vector of the body. For example, it can used if the translation `transl` is predicted from some external model. (default=None) return_verts: bool, optional Return the vertices. (default=True) return_full_pose: bool, optional Returns the full axis-angle pose vector (default=False) Returns ------- output: ModelOutput A named tuple of type `ModelOutput` ''' device, dtype = self.shapedirs.device, self.shapedirs.dtype if global_orient is None: batch_size = 1 global_orient = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand(batch_size, -1, -1, -1).contiguous() else: batch_size = global_orient.shape[0] if neck_pose is None: neck_pose = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand(batch_size, 1, -1, -1).contiguous() if jaw_pose is None: jaw_pose = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand(batch_size, -1, -1, -1).contiguous() if leye_pose is None: leye_pose = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand(batch_size, -1, -1, -1).contiguous() if reye_pose is None: reye_pose = torch.eye(3, device=device, dtype=dtype).view( 1, 1, 3, 3).expand(batch_size, -1, -1, -1).contiguous() if betas is None: betas = torch.zeros([batch_size, self.num_betas], dtype=dtype, device=device) if expression is None: expression = torch.zeros([batch_size, self.num_expression_coeffs], dtype=dtype, device=device) if transl is None: transl = torch.zeros([batch_size, 3], dtype=dtype, device=device) full_pose = torch.cat( [global_orient, neck_pose, jaw_pose, leye_pose, reye_pose], dim=1) shape_components = torch.cat([betas, expression], dim=-1) shapedirs = torch.cat([self.shapedirs, self.expr_dirs], dim=-1) vertices, joints = lbs(shape_components, full_pose, self.v_template, shapedirs, self.posedirs, self.J_regressor, self.parents, self.lbs_weights, pose2rot=False, ) lmk_faces_idx = self.lmk_faces_idx.unsqueeze( dim=0).expand(batch_size, -1).contiguous() lmk_bary_coords = self.lmk_bary_coords.unsqueeze(dim=0).repeat( self.batch_size, 1, 1) if self.use_face_contour: lmk_idx_and_bcoords = find_dynamic_lmk_idx_and_bcoords( vertices, full_pose, self.dynamic_lmk_faces_idx, self.dynamic_lmk_bary_coords, self.neck_kin_chain, pose2rot=False, ) dyn_lmk_faces_idx, dyn_lmk_bary_coords = lmk_idx_and_bcoords lmk_faces_idx = torch.cat([lmk_faces_idx, dyn_lmk_faces_idx], 1) lmk_bary_coords = torch.cat( [lmk_bary_coords.expand(batch_size, -1, -1), dyn_lmk_bary_coords], 1) landmarks = vertices2landmarks(vertices, self.faces_tensor, lmk_faces_idx, lmk_bary_coords) # Add any extra joints that might be needed joints = self.vertex_joint_selector(vertices, joints) # Add the landmarks to the joints joints = torch.cat([joints, landmarks], dim=1) # Map the joints to the current dataset if self.joint_mapper is not None: joints = self.joint_mapper(joints=joints, vertices=vertices) joints += transl.unsqueeze(dim=1) vertices += transl.unsqueeze(dim=1) output = FLAMEOutput(vertices=vertices if return_verts else None, joints=joints, betas=betas, expression=expression, global_orient=global_orient, neck_pose=neck_pose, jaw_pose=jaw_pose, full_pose=full_pose if return_full_pose else None) return output The provided code snippet includes necessary dependencies for implementing the `build_layer` function. Write a Python function `def build_layer( model_path: str, model_type: str = 'smpl' ) -> Union[SMPLLayer, SMPLHLayer, SMPLXLayer, MANOLayer, FLAMELayer]` to solve the following problem: Method for creating a model from a path and a model type Parameters ---------- model_path: str Either the path to the model you wish to load or a folder, where each subfolder contains the differents types, i.e.: model_path: | |-- smpl |-- SMPL_FEMALE |-- SMPL_NEUTRAL |-- SMPL_MALE |-- smplh |-- SMPLH_FEMALE |-- SMPLH_MALE |-- smplx |-- SMPLX_FEMALE |-- SMPLX_NEUTRAL |-- SMPLX_MALE |-- mano |-- MANO RIGHT |-- MANO LEFT |-- flame |-- FLAME_FEMALE |-- FLAME_MALE |-- FLAME_NEUTRAL model_type: str, optional When model_path is a folder, then this parameter specifies the type of model to be loaded **kwargs: dict Keyword arguments Returns ------- body_model: nn.Module The PyTorch module that implements the corresponding body model Raises ------ ValueError: In case the model type is not one of SMPL, SMPLH, SMPLX, MANO or FLAME Here is the function: def build_layer( model_path: str, model_type: str = 'smpl' ) -> Union[SMPLLayer, SMPLHLayer, SMPLXLayer, MANOLayer, FLAMELayer]: ''' Method for creating a model from a path and a model type Parameters ---------- model_path: str Either the path to the model you wish to load or a folder, where each subfolder contains the differents types, i.e.: model_path: | |-- smpl |-- SMPL_FEMALE |-- SMPL_NEUTRAL |-- SMPL_MALE |-- smplh |-- SMPLH_FEMALE |-- SMPLH_MALE |-- smplx |-- SMPLX_FEMALE |-- SMPLX_NEUTRAL |-- SMPLX_MALE |-- mano |-- MANO RIGHT |-- MANO LEFT |-- flame |-- FLAME_FEMALE |-- FLAME_MALE |-- FLAME_NEUTRAL model_type: str, optional When model_path is a folder, then this parameter specifies the type of model to be loaded **kwargs: dict Keyword arguments Returns ------- body_model: nn.Module The PyTorch module that implements the corresponding body model Raises ------ ValueError: In case the model type is not one of SMPL, SMPLH, SMPLX, MANO or FLAME ''' if osp.isdir(model_path): model_path = os.path.join(model_path, model_type) else: model_type = osp.basename(model_path).split('_')[0].lower() if model_type.lower() == 'smpl': return SMPLLayer(model_path) elif model_type.lower() == 'smplh': return SMPLHLayer(model_path) elif model_type.lower() == 'smplx': return SMPLXLayer(model_path) elif 'mano' in model_type.lower(): return MANOLayer(model_path) elif 'flame' in model_type.lower(): return FLAMELayer(model_path) else: raise ValueError(f'Unknown model type {model_type}, exiting!')

Method for creating a model from a path and a model type Parameters ---------- model_path: str Either the path to the model you wish to load or a folder, where each subfolder contains the differents types, i.e.: model_path: | |-- smpl |-- SMPL_FEMALE |-- SMPL_NEUTRAL |-- SMPL_MALE |-- smplh |-- SMPLH_FEMALE |-- SMPLH_MALE |-- smplx |-- SMPLX_FEMALE |-- SMPLX_NEUTRAL |-- SMPLX_MALE |-- mano |-- MANO RIGHT |-- MANO LEFT |-- flame |-- FLAME_FEMALE |-- FLAME_MALE |-- FLAME_NEUTRAL model_type: str, optional When model_path is a folder, then this parameter specifies the type of model to be loaded **kwargs: dict Keyword arguments Returns ------- body_model: nn.Module The PyTorch module that implements the corresponding body model Raises ------ ValueError: In case the model type is not one of SMPL, SMPLH, SMPLX, MANO or FLAME

from typing import Optional, Dict, Union import os import os.path as osp import pickle import numpy as np import torch import torch.nn as nn from .lbs import ( lbs, vertices2landmarks, find_dynamic_lmk_idx_and_bcoords, vertices2joints, blend_shapes) from .vertex_ids import vertex_ids as VERTEX_IDS from .utils import ( Struct, to_np, to_tensor, Tensor, Array, SMPLOutput, SMPLHOutput, SMPLXOutput, MANOOutput, FLAMEOutput, find_joint_kin_chain) from .vertex_joint_selector import VertexJointSelector class SMPL(nn.Module): NUM_JOINTS = 23 NUM_BODY_JOINTS = 23 SHAPE_SPACE_DIM = 300 def __init__( self, model_path: str, data_struct: Optional[Struct] = None, create_betas: bool = True, betas: Optional[Tensor] = None, num_betas: int = 10, create_global_orient: bool = True, global_orient: Optional[Tensor] = None, create_body_pose: bool = True, body_pose: Optional[Tensor] = None, create_transl: bool = True, transl: Optional[Tensor] = None, dtype=torch.float32, batch_size: int = 1, joint_mapper=None, gender: str = 'neutral', vertex_ids: Dict[str, int] = None, v_template: Optional[Union[Tensor, Array]] = None ) -> None: ''' SMPL model constructor Parameters ---------- model_path: str The path to the folder or to the file where the model parameters are stored data_struct: Strct A struct object. If given, then the parameters of the model are read from the object. Otherwise, the model tries to read the parameters from the given `model_path`. (default = None) create_global_orient: bool, optional Flag for creating a member variable for the global orientation of the body. (default = True) global_orient: torch.tensor, optional, Bx3 The default value for the global orientation variable. (default = None) create_body_pose: bool, optional Flag for creating a member variable for the pose of the body. (default = True) body_pose: torch.tensor, optional, Bx(Body Joints * 3) The default value for the body pose variable. (default = None) num_betas: int, optional Number of shape components to use (default = 10). create_betas: bool, optional Flag for creating a member variable for the shape space (default = True). betas: torch.tensor, optional, Bx10 The default value for the shape member variable. (default = None) create_transl: bool, optional Flag for creating a member variable for the translation of the body. (default = True) transl: torch.tensor, optional, Bx3 The default value for the transl variable. (default = None) dtype: torch.dtype, optional The data type for the created variables batch_size: int, optional The batch size used for creating the member variables joint_mapper: object, optional An object that re-maps the joints. Useful if one wants to re-order the SMPL joints to some other convention (e.g. MSCOCO) (default = None) gender: str, optional Which gender to load vertex_ids: dict, optional A dictionary containing the indices of the extra vertices that will be selected ''' self.gender = gender if data_struct is None: if osp.isdir(model_path): model_fn = 'SMPL_{}.{ext}'.format(gender.upper(), ext='pkl') smpl_path = os.path.join(model_path, model_fn) else: smpl_path = model_path assert osp.exists(smpl_path), 'Path {} does not exist!'.format( smpl_path) with open(smpl_path, 'rb') as smpl_file: data_struct = Struct(**pickle.load(smpl_file, encoding='latin1')) super(SMPL, self).__init__() self.batch_size = batch_size shapedirs = data_struct.shapedirs if (shapedirs.shape[-1] < self.SHAPE_SPACE_DIM): print(f'WARNING: You are using a {self.name()} model, with only' ' 10 shape coefficients.') num_betas = min(num_betas, 10) else: num_betas = min(num_betas, self.SHAPE_SPACE_DIM) self._num_betas = num_betas shapedirs = shapedirs[:, :, :num_betas] # The shape components self.register_buffer( 'shapedirs', to_tensor(to_np(shapedirs), dtype=dtype)) if vertex_ids is None: # SMPL and SMPL-H share the same topology, so any extra joints can # be drawn from the same place vertex_ids = VERTEX_IDS['smplh'] self.dtype = dtype self.joint_mapper = joint_mapper self.vertex_joint_selector = VertexJointSelector( vertex_ids=vertex_ids) self.faces = data_struct.f self.register_buffer('faces_tensor', to_tensor(to_np(self.faces, dtype=np.int64), dtype=torch.long)) if create_betas: if betas is None: default_betas = torch.zeros( [batch_size, self.num_betas], dtype=dtype) else: if torch.is_tensor(betas): default_betas = betas.clone().detach() else: default_betas = torch.tensor(betas, dtype=dtype) self.register_parameter( 'betas', nn.Parameter(default_betas, requires_grad=True)) # The tensor that contains the global rotation of the model # It is separated from the pose of the joints in case we wish to # optimize only over one of them if create_global_orient: if global_orient is None: default_global_orient = torch.zeros( [batch_size, 3], dtype=dtype) else: if torch.is_tensor(global_orient): default_global_orient = global_orient.clone().detach() else: default_global_orient = torch.tensor( global_orient, dtype=dtype) global_orient = nn.Parameter(default_global_orient, requires_grad=True) self.register_parameter('global_orient', global_orient) if create_body_pose: if body_pose is None: default_body_pose = torch.zeros( [batch_size, self.NUM_BODY_JOINTS * 3], dtype=dtype) else: if torch.is_tensor(body_pose): default_body_pose = body_pose.clone().detach() else: default_body_pose = torch.tensor(body_pose, dtype=dtype) self.register_parameter( 'body_pose', nn.Parameter(default_body_pose, requires_grad=True)) if create_transl: if transl is None: default_transl = torch.zeros([batch_size, 3], dtype=dtype, requires_grad=True) else: default_transl = torch.tensor(transl, dtype=dtype) self.register_parameter( 'transl', nn.Parameter(default_transl, requires_grad=True)) if v_template is None: v_template = data_struct.v_template if not torch.is_tensor(v_template): v_template = to_tensor(to_np(v_template), dtype=dtype) # The vertices of the template model self.register_buffer('v_template', v_template) j_regressor = to_tensor(to_np( data_struct.J_regressor), dtype=dtype) self.register_buffer('J_regressor', j_regressor) # Pose blend shape basis: 6890 x 3 x 207, reshaped to 6890*3 x 207 num_pose_basis = data_struct.posedirs.shape[-1] # 207 x 20670 posedirs = np.reshape(data_struct.posedirs, [-1, num_pose_basis]).T self.register_buffer('posedirs', to_tensor(to_np(posedirs), dtype=dtype)) # indices of parents for each joints parents = to_tensor(to_np(data_struct.kintree_table[0])).long() parents[0] = -1 self.register_buffer('parents', parents) self.register_buffer( 'lbs_weights', to_tensor(to_np(data_struct.weights), dtype=dtype)) def num_betas(self): return self._num_betas def num_expression_coeffs(self): return 0 def create_mean_pose(self, data_struct) -> Tensor: pass def name(self) -> str: return 'SMPL' def reset_params(self, **params_dict) -> None: for param_name, param in self.named_parameters(): if param_name in params_dict: param[:] = torch.tensor(params_dict[param_name]) else: param.fill_(0) def get_num_verts(self) -> int: return self.v_template.shape[0] def get_num_faces(self) -> int: return self.faces.shape[0] def get_T_hip(self, betas=None, displacement=None): if displacement is not None: v_shaped = self.v_template+displacement + blend_shapes(betas, self.shapedirs) else: v_shaped = self.v_template + blend_shapes(betas, self.shapedirs) J = vertices2joints(self.J_regressor, v_shaped) T_hip = J[0,0] return T_hip def extra_repr(self) -> str: msg = [ f'Gender: {self.gender.upper()}', f'Number of joints: {self.J_regressor.shape[0]}', f'Betas: {self.num_betas}', ] return '\n'.join(msg) def forward( self, betas: Optional[Tensor] = None, body_pose: Optional[Tensor] = None, global_orient: Optional[Tensor] = None, transl: Optional[Tensor] = None, return_verts=True, return_full_pose: bool = False, pose2rot: bool = True, displacement=None, absolute_displacement=True, ) -> SMPLOutput: ''' Forward pass for the SMPL model Parameters ---------- global_orient: torch.tensor, optional, shape Bx3 If given, ignore the member variable and use it as the global rotation of the body. Useful if someone wishes to predicts this with an external model. (default=None) betas: torch.tensor, optional, shape BxN_b If given, ignore the member variable `betas` and use it instead. For example, it can used if shape parameters `betas` are predicted from some external model. (default=None) body_pose: torch.tensor, optional, shape Bx(J*3) If given, ignore the member variable `body_pose` and use it instead. For example, it can used if someone predicts the pose of the body joints are predicted from some external model. It should be a tensor that contains joint rotations in axis-angle format. (default=None) transl: torch.tensor, optional, shape Bx3 If given, ignore the member variable `transl` and use it instead. For example, it can used if the translation `transl` is predicted from some external model. (default=None) return_verts: bool, optional Return the vertices. (default=True) return_full_pose: bool, optional Returns the full axis-angle pose vector (default=False) Returns ------- ''' # If no shape and pose parameters are passed along, then use the # ones from the module global_orient = (global_orient if global_orient is not None else self.global_orient) body_pose = body_pose if body_pose is not None else self.body_pose betas = betas if betas is not None else self.betas apply_trans = transl is not None or hasattr(self, 'transl') if transl is None and hasattr(self, 'transl'): transl = self.transl full_pose = torch.cat([global_orient, body_pose], dim=1) batch_size = max(betas.shape[0], global_orient.shape[0], body_pose.shape[0]) if betas.shape[0] != batch_size: num_repeats = int(batch_size / betas.shape[0]) betas = betas.expand(num_repeats, -1) if displacement is not None: if absolute_displacement: vertices, joints = lbs(betas, full_pose, displacement, self.shapedirs, self.posedirs, self.J_regressor, self.parents, self.lbs_weights, pose2rot=pose2rot) else: vertices, joints = lbs(betas, full_pose, self.v_template+displacement, self.shapedirs, self.posedirs, self.J_regressor, self.parents, self.lbs_weights, pose2rot=pose2rot) else: vertices, joints = lbs(betas, full_pose, self.v_template, self.shapedirs, self.posedirs, self.J_regressor, self.parents, self.lbs_weights, pose2rot=pose2rot) joints = self.vertex_joint_selector(vertices, joints) # Map the joints to the current dataset if self.joint_mapper is not None: joints = self.joint_mapper(joints) if apply_trans: joints += transl.unsqueeze(dim=1) vertices += transl.unsqueeze(dim=1) output = SMPLOutput(vertices=vertices if return_verts else None, faces=self.faces, global_orient=global_orient, body_pose=body_pose, joints=joints, betas=betas, full_pose=full_pose if return_full_pose else None) return output class SMPLH(SMPL): # The hand joints are replaced by MANO NUM_BODY_JOINTS = SMPL.NUM_JOINTS - 2 NUM_HAND_JOINTS = 15 NUM_JOINTS = NUM_BODY_JOINTS + 2 * NUM_HAND_JOINTS def __init__( self, model_path, data_struct: Optional[Struct] = None, create_left_hand_pose: bool = True, left_hand_pose: Optional[Tensor] = None, create_right_hand_pose: bool = True, right_hand_pose: Optional[Tensor] = None, use_pca: bool = True, num_pca_comps: int = 6, flat_hand_mean: bool = False, batch_size: int = 1, gender: str = 'neutral', dtype=torch.float32, vertex_ids=None, use_compressed: bool = True, ext: str = 'pkl' ) -> None: ''' SMPLH model constructor Parameters ---------- model_path: str The path to the folder or to the file where the model parameters are stored data_struct: Strct A struct object. If given, then the parameters of the model are read from the object. Otherwise, the model tries to read the parameters from the given `model_path`. (default = None) create_left_hand_pose: bool, optional Flag for creating a member variable for the pose of the left hand. (default = True) left_hand_pose: torch.tensor, optional, BxP The default value for the left hand pose member variable. (default = None) create_right_hand_pose: bool, optional Flag for creating a member variable for the pose of the right hand. (default = True) right_hand_pose: torch.tensor, optional, BxP The default value for the right hand pose member variable. (default = None) num_pca_comps: int, optional The number of PCA components to use for each hand. (default = 6) flat_hand_mean: bool, optional If False, then the pose of the hand is initialized to False. batch_size: int, optional The batch size used for creating the member variables gender: str, optional Which gender to load dtype: torch.dtype, optional The data type for the created variables vertex_ids: dict, optional A dictionary containing the indices of the extra vertices that will be selected ''' self.num_pca_comps = num_pca_comps # If no data structure is passed, then load the data from the given # model folder if data_struct is None: # Load the model if osp.isdir(model_path): model_fn = 'SMPLH_{}.{ext}'.format(gender.upper(), ext=ext) smplh_path = os.path.join(model_path, model_fn) else: smplh_path = model_path assert osp.exists(smplh_path), 'Path {} does not exist!'.format( smplh_path) if ext == 'pkl': with open(smplh_path, 'rb') as smplh_file: model_data = pickle.load(smplh_file, encoding='latin1') elif ext == 'npz': model_data = np.load(smplh_path, allow_pickle=True) else: raise ValueError('Unknown extension: {}'.format(ext)) data_struct = Struct(**model_data) if vertex_ids is None: vertex_ids = VERTEX_IDS['smplh'] super(SMPLH, self).__init__( model_path=model_path, data_struct=data_struct, batch_size=batch_size, vertex_ids=vertex_ids, gender=gender, use_compressed=use_compressed, dtype=dtype, ext=ext) self.use_pca = use_pca self.num_pca_comps = num_pca_comps self.flat_hand_mean = flat_hand_mean left_hand_components = data_struct.hands_componentsl[:num_pca_comps] right_hand_components = data_struct.hands_componentsr[:num_pca_comps] self.np_left_hand_components = left_hand_components self.np_right_hand_components = right_hand_components if self.use_pca: self.register_buffer( 'left_hand_components', torch.tensor(left_hand_components, dtype=dtype)) self.register_buffer( 'right_hand_components', torch.tensor(right_hand_components, dtype=dtype)) if self.flat_hand_mean: left_hand_mean = np.zeros_like(data_struct.hands_meanl) else: left_hand_mean = data_struct.hands_meanl if self.flat_hand_mean: right_hand_mean = np.zeros_like(data_struct.hands_meanr) else: right_hand_mean = data_struct.hands_meanr self.register_buffer('left_hand_mean', to_tensor(left_hand_mean, dtype=self.dtype)) self.register_buffer('right_hand_mean', to_tensor(right_hand_mean, dtype=self.dtype)) # Create the buffers for the pose of the left hand hand_pose_dim = num_pca_comps if use_pca else 3 * self.NUM_HAND_JOINTS if create_left_hand_pose: if left_hand_pose is None: default_lhand_pose = torch.zeros([batch_size, hand_pose_dim], dtype=dtype) else: default_lhand_pose = torch.tensor(left_hand_pose, dtype=dtype) left_hand_pose_param = nn.Parameter(default_lhand_pose, requires_grad=True) self.register_parameter('left_hand_pose', left_hand_pose_param) if create_right_hand_pose: if right_hand_pose is None: default_rhand_pose = torch.zeros([batch_size, hand_pose_dim], dtype=dtype) else: default_rhand_pose = torch.tensor(right_hand_pose, dtype=dtype) right_hand_pose_param = nn.Parameter(default_rhand_pose, requires_grad=True) self.register_parameter('right_hand_pose', right_hand_pose_param) # Create the buffer for the mean pose. pose_mean_tensor = self.create_mean_pose( data_struct, flat_hand_mean=flat_hand_mean) if not torch.is_tensor(pose_mean_tensor): pose_mean_tensor = torch.tensor(pose_mean_tensor, dtype=dtype) self.register_buffer('pose_mean', pose_mean_tensor) def create_mean_pose(self, data_struct, flat_hand_mean=False): # Create the array for the mean pose. If flat_hand is false, then use # the mean that is given by the data, rather than the flat open hand global_orient_mean = torch.zeros([3], dtype=self.dtype) body_pose_mean = torch.zeros([self.NUM_BODY_JOINTS * 3], dtype=self.dtype) pose_mean = torch.cat([global_orient_mean, body_pose_mean, self.left_hand_mean, self.right_hand_mean], dim=0) return pose_mean def name(self) -> str: return 'SMPL+H' def extra_repr(self): msg = super(SMPLH, self).extra_repr() msg = [msg] if self.use_pca: msg.append(f'Number of PCA components: {self.num_pca_comps}') msg.append(f'Flat hand mean: {self.flat_hand_mean}') return '\n'.join(msg) def forward( self, betas: Optional[Tensor] = None, global_orient: Optional[Tensor] = None, body_pose: Optional[Tensor] = None, left_hand_pose: Optional[Tensor] = None, right_hand_pose: Optional[Tensor] = None, transl: Optional[Tensor] = None, return_verts: bool = True, return_full_pose: bool = False, pose2rot: bool = True ) -> SMPLHOutput: ''' ''' # If no shape and pose parameters are passed along, then use the # ones from the module global_orient = (global_orient if global_orient is not None else self.global_orient) body_pose = body_pose if body_pose is not None else self.body_pose betas = betas if betas is not None else self.betas left_hand_pose = (left_hand_pose if left_hand_pose is not None else self.left_hand_pose) right_hand_pose = (right_hand_pose if right_hand_pose is not None else self.right_hand_pose) apply_trans = transl is not None or hasattr(self, 'transl') if transl is None: if hasattr(self, 'transl'): transl = self.transl if self.use_pca: left_hand_pose = torch.einsum( 'bi,ij->bj', [left_hand_pose, self.left_hand_components]) right_hand_pose = torch.einsum( 'bi,ij->bj', [right_hand_pose, self.right_hand_components]) full_pose = torch.cat([global_orient, body_pose, left_hand_pose, right_hand_pose], dim=1) full_pose += self.pose_mean vertices, joints = lbs(betas, full_pose, self.v_template, self.shapedirs, self.posedirs, self.J_regressor, self.parents, self.lbs_weights, pose2rot=pose2rot) # Add any extra joints that might be needed joints = self.vertex_joint_selector(vertices, joints) if self.joint_mapper is not None: joints = self.joint_mapper(joints) if apply_trans: joints += transl.unsqueeze(dim=1) vertices += transl.unsqueeze(dim=1) output = SMPLHOutput(vertices=vertices if return_verts else None, faces=self.faces, joints=joints, betas=betas, global_orient=global_orient, body_pose=body_pose, left_hand_pose=left_hand_pose, right_hand_pose=right_hand_pose, full_pose=full_pose if return_full_pose else None) return output class SMPLX(SMPLH): ''' SMPL-X (SMPL eXpressive) is a unified body model, with shape parameters trained jointly for the face, hands and body. SMPL-X uses standard vertex based linear blend skinning with learned corrective blend shapes, has N=10475 vertices and K=54 joints, which includes joints for the neck, jaw, eyeballs and fingers. ''' NUM_BODY_JOINTS = SMPLH.NUM_BODY_JOINTS NUM_HAND_JOINTS = 15 NUM_FACE_JOINTS = 3 NUM_JOINTS = NUM_BODY_JOINTS + 2 * NUM_HAND_JOINTS + NUM_FACE_JOINTS EXPRESSION_SPACE_DIM = 100 NECK_IDX = 12 def __init__( self, model_path: str, num_expression_coeffs: int = 10, create_expression: bool = True, expression: Optional[Tensor] = None, create_jaw_pose: bool = True, jaw_pose: Optional[Tensor] = None, create_leye_pose: bool = True, leye_pose: Optional[Tensor] = None, create_reye_pose=True, reye_pose: Optional[Tensor] = None, use_face_contour: bool = False, batch_size: int = 1, gender: str = 'neutral', dtype=torch.float32, ext: str = 'npz' ) -> None: ''' SMPLX model constructor Parameters ---------- model_path: str The path to the folder or to the file where the model parameters are stored num_expression_coeffs: int, optional Number of expression components to use (default = 10). create_expression: bool, optional Flag for creating a member variable for the expression space (default = True). expression: torch.tensor, optional, Bx10 The default value for the expression member variable. (default = None) create_jaw_pose: bool, optional Flag for creating a member variable for the jaw pose. (default = False) jaw_pose: torch.tensor, optional, Bx3 The default value for the jaw pose variable. (default = None) create_leye_pose: bool, optional Flag for creating a member variable for the left eye pose. (default = False) leye_pose: torch.tensor, optional, Bx10 The default value for the left eye pose variable. (default = None) create_reye_pose: bool, optional Flag for creating a member variable for the right eye pose. (default = False) reye_pose: torch.tensor, optional, Bx10 The default value for the right eye pose variable. (default = None) use_face_contour: bool, optional Whether to compute the keypoints that form the facial contour batch_size: int, optional The batch size used for creating the member variables gender: str, optional Which gender to load dtype: torch.dtype The data type for the created variables ''' # Load the model if osp.isdir(model_path): model_fn = 'SMPLX_{}.{ext}'.format(gender.upper(), ext=ext) smplx_path = os.path.join(model_path, model_fn) else: smplx_path = model_path assert osp.exists(smplx_path), 'Path {} does not exist!'.format( smplx_path) if ext == 'pkl': with open(smplx_path, 'rb') as smplx_file: model_data = pickle.load(smplx_file, encoding='latin1') elif ext == 'npz': model_data = np.load(smplx_path, allow_pickle=True) else: raise ValueError('Unknown extension: {}'.format(ext)) data_struct = Struct(**model_data) super(SMPLX, self).__init__( model_path=model_path, data_struct=data_struct, dtype=dtype, batch_size=batch_size, vertex_ids=VERTEX_IDS['smplx'], gender=gender, ext=ext ) lmk_faces_idx = data_struct.lmk_faces_idx self.register_buffer('lmk_faces_idx', torch.tensor(lmk_faces_idx, dtype=torch.long)) lmk_bary_coords = data_struct.lmk_bary_coords self.register_buffer('lmk_bary_coords', torch.tensor(lmk_bary_coords, dtype=dtype)) self.use_face_contour = use_face_contour if self.use_face_contour: dynamic_lmk_faces_idx = data_struct.dynamic_lmk_faces_idx dynamic_lmk_faces_idx = torch.tensor( dynamic_lmk_faces_idx, dtype=torch.long) self.register_buffer('dynamic_lmk_faces_idx', dynamic_lmk_faces_idx) dynamic_lmk_bary_coords = data_struct.dynamic_lmk_bary_coords dynamic_lmk_bary_coords = torch.tensor( dynamic_lmk_bary_coords, dtype=dtype) self.register_buffer('dynamic_lmk_bary_coords', dynamic_lmk_bary_coords) neck_kin_chain = find_joint_kin_chain(self.NECK_IDX, self.parents) self.register_buffer( 'neck_kin_chain', torch.tensor(neck_kin_chain, dtype=torch.long)) if create_jaw_pose: if jaw_pose is None: default_jaw_pose = torch.zeros([batch_size, 3], dtype=dtype) else: default_jaw_pose = torch.tensor(jaw_pose, dtype=dtype) jaw_pose_param = nn.Parameter(default_jaw_pose, requires_grad=True) self.register_parameter('jaw_pose', jaw_pose_param) if create_leye_pose: if leye_pose is None: default_leye_pose = torch.zeros([batch_size, 3], dtype=dtype) else: default_leye_pose = torch.tensor(leye_pose, dtype=dtype) leye_pose_param = nn.Parameter(default_leye_pose, requires_grad=True) self.register_parameter('leye_pose', leye_pose_param) if create_reye_pose: if reye_pose is None: default_reye_pose = torch.zeros([batch_size, 3], dtype=dtype) else: default_reye_pose = torch.tensor(reye_pose, dtype=dtype) reye_pose_param = nn.Parameter(default_reye_pose, requires_grad=True) self.register_parameter('reye_pose', reye_pose_param) shapedirs = data_struct.shapedirs if len(shapedirs.shape) < 3: shapedirs = shapedirs[:, :, None] if (shapedirs.shape[-1] < self.SHAPE_SPACE_DIM + self.EXPRESSION_SPACE_DIM): print(f'WARNING: You are using a {self.name()} model, with only' ' 10 shape and 10 expression coefficients.') expr_start_idx = 10 expr_end_idx = 20 num_expression_coeffs = min(num_expression_coeffs, 10) else: expr_start_idx = self.SHAPE_SPACE_DIM expr_end_idx = self.SHAPE_SPACE_DIM + num_expression_coeffs num_expression_coeffs = min( num_expression_coeffs, self.EXPRESSION_SPACE_DIM) self._num_expression_coeffs = num_expression_coeffs expr_dirs = shapedirs[:, :, expr_start_idx:expr_end_idx] self.register_buffer( 'expr_dirs', to_tensor(to_np(expr_dirs), dtype=dtype)) if create_expression: if expression is None: default_expression = torch.zeros( [batch_size, self.num_expression_coeffs], dtype=dtype) else: default_expression = torch.tensor(expression, dtype=dtype) expression_param = nn.Parameter(default_expression, requires_grad=True) self.register_parameter('expression', expression_param) def name(self) -> str: return 'SMPL-X' def num_expression_coeffs(self): return self._num_expression_coeffs def create_mean_pose(self, data_struct, flat_hand_mean=False): # Create the array for the mean pose. If flat_hand is false, then use # the mean that is given by the data, rather than the flat open hand global_orient_mean = torch.zeros([3], dtype=self.dtype) body_pose_mean = torch.zeros([self.NUM_BODY_JOINTS * 3], dtype=self.dtype) jaw_pose_mean = torch.zeros([3], dtype=self.dtype) leye_pose_mean = torch.zeros([3], dtype=self.dtype) reye_pose_mean = torch.zeros([3], dtype=self.dtype) pose_mean = np.concatenate([global_orient_mean, body_pose_mean, jaw_pose_mean, leye_pose_mean, reye_pose_mean, self.left_hand_mean, self.right_hand_mean], axis=0) return pose_mean def extra_repr(self): msg = super(SMPLX, self).extra_repr() msg = [ msg, f'Number of Expression Coefficients: {self.num_expression_coeffs}' ] return '\n'.join(msg) def forward( self, betas: Optional[Tensor] = None, global_orient: Optional[Tensor] = None, body_pose: Optional[Tensor] = None, left_hand_pose: Optional[Tensor] = None, right_hand_pose: Optional[Tensor] = None, transl: Optional[Tensor] = None, expression: Optional[Tensor] = None, jaw_pose: Optional[Tensor] = None, leye_pose: Optional[Tensor] = None, reye_pose: Optional[Tensor] = None, return_verts: bool = True, return_full_pose: bool = False, pose2rot: bool = True ) -> SMPLXOutput: ''' Forward pass for the SMPLX model Parameters ---------- global_orient: torch.tensor, optional, shape Bx3 If given, ignore the member variable and use it as the global rotation of the body. Useful if someone wishes to predicts this with an external model. (default=None) betas: torch.tensor, optional, shape BxN_b If given, ignore the member variable `betas` and use it instead. For example, it can used if shape parameters `betas` are predicted from some external model. (default=None) expression: torch.tensor, optional, shape BxN_e If given, ignore the member variable `expression` and use it instead. For example, it can used if expression parameters `expression` are predicted from some external model. body_pose: torch.tensor, optional, shape Bx(J*3) If given, ignore the member variable `body_pose` and use it instead. For example, it can used if someone predicts the pose of the body joints are predicted from some external model. It should be a tensor that contains joint rotations in axis-angle format. (default=None) left_hand_pose: torch.tensor, optional, shape BxP If given, ignore the member variable `left_hand_pose` and use this instead. It should either contain PCA coefficients or joint rotations in axis-angle format. right_hand_pose: torch.tensor, optional, shape BxP If given, ignore the member variable `right_hand_pose` and use this instead. It should either contain PCA coefficients or joint rotations in axis-angle format. jaw_pose: torch.tensor, optional, shape Bx3 If given, ignore the member variable `jaw_pose` and use this instead. It should either joint rotations in axis-angle format. transl: torch.tensor, optional, shape Bx3 If given, ignore the member variable `transl` and use it instead. For example, it can used if the translation `transl` is predicted from some external model. (default=None) return_verts: bool, optional Return the vertices. (default=True) return_full_pose: bool, optional Returns the full axis-angle pose vector (default=False) Returns ------- output: ModelOutput A named tuple of type `ModelOutput` ''' # If no shape and pose parameters are passed along, then use the # ones from the module global_orient = (global_orient if global_orient is not None else self.global_orient) body_pose = body_pose if body_pose is not None else self.body_pose betas = betas if betas is not None else self.betas left_hand_pose = (left_hand_pose if left_hand_pose is not None else self.left_hand_pose) right_hand_pose = (right_hand_pose if right_hand_pose is not None else self.right_hand_pose) jaw_pose = jaw_pose if jaw_pose is not None else self.jaw_pose leye_pose = leye_pose if leye_pose is not None else self.leye_pose reye_pose = reye_pose if reye_pose is not None else self.reye_pose expression = expression if expression is not None else self.expression apply_trans = transl is not None or hasattr(self, 'transl') if transl is None: if hasattr(self, 'transl'): transl = self.transl if self.use_pca: left_hand_pose = torch.einsum( 'bi,ij->bj', [left_hand_pose, self.left_hand_components]) right_hand_pose = torch.einsum( 'bi,ij->bj', [right_hand_pose, self.right_hand_components]) full_pose = torch.cat([global_orient, body_pose, jaw_pose, leye_pose, reye_pose, left_hand_pose, right_hand_pose], dim=1) # Add the mean pose of the model. Does not affect the body, only the # hands when flat_hand_mean == False full_pose += self.pose_mean batch_size = max(betas.shape[0], global_orient.shape[0], body_pose.shape[0]) # Concatenate the shape and expression coefficients scale = int(batch_size / betas.shape[0]) if scale > 1: betas = betas.expand(scale, -1) shape_components = torch.cat([betas, expression], dim=-1) shapedirs = torch.cat([self.shapedirs, self.expr_dirs], dim=-1) vertices, joints = lbs(shape_components, full_pose, self.v_template, shapedirs, self.posedirs, self.J_regressor, self.parents, self.lbs_weights, pose2rot=pose2rot, ) lmk_faces_idx = self.lmk_faces_idx.unsqueeze( dim=0).expand(batch_size, -1).contiguous() lmk_bary_coords = self.lmk_bary_coords.unsqueeze(dim=0).repeat( self.batch_size, 1, 1) if self.use_face_contour: lmk_idx_and_bcoords = find_dynamic_lmk_idx_and_bcoords( vertices, full_pose, self.dynamic_lmk_faces_idx, self.dynamic_lmk_bary_coords, self.neck_kin_chain, pose2rot=True, ) dyn_lmk_faces_idx, dyn_lmk_bary_coords = lmk_idx_and_bcoords lmk_faces_idx = torch.cat([lmk_faces_idx, dyn_lmk_faces_idx], 1) lmk_bary_coords = torch.cat( [lmk_bary_coords.expand(batch_size, -1, -1), dyn_lmk_bary_coords], 1) landmarks = vertices2landmarks(vertices, self.faces_tensor, lmk_faces_idx, lmk_bary_coords) # Add any extra joints that might be needed joints = self.vertex_joint_selector(vertices, joints) # Add the landmarks to the joints joints = torch.cat([joints, landmarks], dim=1) # Map the joints to the current dataset if self.joint_mapper is not None: joints = self.joint_mapper(joints=joints, vertices=vertices) if apply_trans: joints += transl.unsqueeze(dim=1) vertices += transl.unsqueeze(dim=1) output = SMPLXOutput(vertices=vertices if return_verts else None, faces=self.faces, joints=joints, betas=betas, expression=expression, global_orient=global_orient, body_pose=body_pose, left_hand_pose=left_hand_pose, right_hand_pose=right_hand_pose, jaw_pose=jaw_pose, full_pose=full_pose if return_full_pose else None) return output class MANO(SMPL): # The hand joints are replaced by MANO NUM_BODY_JOINTS = 1 NUM_HAND_JOINTS = 15 NUM_JOINTS = NUM_BODY_JOINTS + NUM_HAND_JOINTS def __init__( self, model_path: str, is_rhand: bool = True, data_struct: Optional[Struct] = None, create_hand_pose: bool = True, hand_pose: Optional[Tensor] = None, use_pca: bool = True, num_pca_comps: int = 6, flat_hand_mean: bool = False, batch_size: int = 1, dtype=torch.float32, vertex_ids=None, use_compressed: bool = True, ext: str = 'pkl' ) -> None: ''' MANO model constructor Parameters ---------- model_path: str The path to the folder or to the file where the model parameters are stored data_struct: Strct A struct object. If given, then the parameters of the model are read from the object. Otherwise, the model tries to read the parameters from the given `model_path`. (default = None) create_hand_pose: bool, optional Flag for creating a member variable for the pose of the right hand. (default = True) hand_pose: torch.tensor, optional, BxP The default value for the right hand pose member variable. (default = None) num_pca_comps: int, optional The number of PCA components to use for each hand. (default = 6) flat_hand_mean: bool, optional If False, then the pose of the hand is initialized to False. batch_size: int, optional The batch size used for creating the member variables dtype: torch.dtype, optional The data type for the created variables vertex_ids: dict, optional A dictionary containing the indices of the extra vertices that will be selected ''' self.num_pca_comps = num_pca_comps self.is_rhand = is_rhand # If no data structure is passed, then load the data from the given # model folder if data_struct is None: # Load the model if osp.isdir(model_path): model_fn = 'MANO_{}.{ext}'.format( 'RIGHT' if is_rhand else 'LEFT', ext=ext) mano_path = os.path.join(model_path, model_fn) else: mano_path = model_path self.is_rhand = True if 'RIGHT' in os.path.basename( model_path) else False assert osp.exists(mano_path), 'Path {} does not exist!'.format( mano_path) if ext == 'pkl': with open(mano_path, 'rb') as mano_file: model_data = pickle.load(mano_file, encoding='latin1') elif ext == 'npz': model_data = np.load(mano_path, allow_pickle=True) else: raise ValueError('Unknown extension: {}'.format(ext)) data_struct = Struct(**model_data) if vertex_ids is None: vertex_ids = VERTEX_IDS['smplh'] super(MANO, self).__init__( model_path=model_path, data_struct=data_struct, batch_size=batch_size, vertex_ids=vertex_ids, use_compressed=use_compressed, dtype=dtype, ext=ext) # add only MANO tips to the extra joints self.vertex_joint_selector.extra_joints_idxs = to_tensor( list(VERTEX_IDS['mano'].values()), dtype=torch.long) self.use_pca = use_pca self.num_pca_comps = num_pca_comps if self.num_pca_comps == 45: self.use_pca = False self.flat_hand_mean = flat_hand_mean hand_components = data_struct.hands_components[:num_pca_comps] self.np_hand_components = hand_components if self.use_pca: self.register_buffer( 'hand_components', torch.tensor(hand_components, dtype=dtype)) if self.flat_hand_mean: hand_mean = np.zeros_like(data_struct.hands_mean) else: hand_mean = data_struct.hands_mean self.register_buffer('hand_mean', to_tensor(hand_mean, dtype=self.dtype)) # Create the buffers for the pose of the left hand hand_pose_dim = num_pca_comps if use_pca else 3 * self.NUM_HAND_JOINTS if create_hand_pose: if hand_pose is None: default_hand_pose = torch.zeros([batch_size, hand_pose_dim], dtype=dtype) else: default_hand_pose = torch.tensor(hand_pose, dtype=dtype) hand_pose_param = nn.Parameter(default_hand_pose, requires_grad=True) self.register_parameter('hand_pose', hand_pose_param) # Create the buffer for the mean pose. pose_mean = self.create_mean_pose( data_struct, flat_hand_mean=flat_hand_mean) pose_mean_tensor = pose_mean.clone().to(dtype) # pose_mean_tensor = torch.tensor(pose_mean, dtype=dtype) self.register_buffer('pose_mean', pose_mean_tensor) def name(self) -> str: return 'MANO' def create_mean_pose(self, data_struct, flat_hand_mean=False): # Create the array for the mean pose. If flat_hand is false, then use # the mean that is given by the data, rather than the flat open hand global_orient_mean = torch.zeros([3], dtype=self.dtype) pose_mean = torch.cat([global_orient_mean, self.hand_mean], dim=0) return pose_mean def extra_repr(self): msg = [super(MANO, self).extra_repr()] if self.use_pca: msg.append(f'Number of PCA components: {self.num_pca_comps}') msg.append(f'Flat hand mean: {self.flat_hand_mean}') return '\n'.join(msg) def forward( self, betas: Optional[Tensor] = None, global_orient: Optional[Tensor] = None, hand_pose: Optional[Tensor] = None, transl: Optional[Tensor] = None, return_verts: bool = True, return_full_pose: bool = False ) -> MANOOutput: ''' Forward pass for the MANO model ''' # If no shape and pose parameters are passed along, then use the # ones from the module global_orient = (global_orient if global_orient is not None else self.global_orient) betas = betas if betas is not None else self.betas hand_pose = (hand_pose if hand_pose is not None else self.hand_pose) apply_trans = transl is not None or hasattr(self, 'transl') if transl is None: if hasattr(self, 'transl'): transl = self.transl if self.use_pca: hand_pose = torch.einsum( 'bi,ij->bj', [hand_pose, self.hand_components]) full_pose = torch.cat([global_orient, hand_pose], dim=1) full_pose += self.pose_mean vertices, joints = lbs(betas, full_pose, self.v_template, self.shapedirs, self.posedirs, self.J_regressor, self.parents, self.lbs_weights, pose2rot=True, ) # # Add pre-selected extra joints that might be needed # joints = self.vertex_joint_selector(vertices, joints) if self.joint_mapper is not None: joints = self.joint_mapper(joints) if apply_trans: joints = joints + transl.unsqueeze(dim=1) vertices = vertices + transl.unsqueeze(dim=1) output = MANOOutput(vertices=vertices if return_verts else None, joints=joints if return_verts else None, betas=betas, global_orient=global_orient, hand_pose=hand_pose, full_pose=full_pose if return_full_pose else None) return output class FLAME(SMPL): NUM_JOINTS = 5 SHAPE_SPACE_DIM = 300 EXPRESSION_SPACE_DIM = 100 NECK_IDX = 0 def __init__( self, model_path: str, data_struct=None, num_expression_coeffs=10, create_expression: bool = True, expression: Optional[Tensor] = None, create_neck_pose: bool = True, neck_pose: Optional[Tensor] = None, create_jaw_pose: bool = True, jaw_pose: Optional[Tensor] = None, create_leye_pose: bool = True, leye_pose: Optional[Tensor] = None, create_reye_pose=True, reye_pose: Optional[Tensor] = None, use_face_contour=False, batch_size: int = 1, gender: str = 'neutral', dtype: torch.dtype = torch.float32, ext='pkl' ) -> None: ''' FLAME model constructor Parameters ---------- model_path: str The path to the folder or to the file where the model parameters are stored num_expression_coeffs: int, optional Number of expression components to use (default = 10). create_expression: bool, optional Flag for creating a member variable for the expression space (default = True). expression: torch.tensor, optional, Bx10 The default value for the expression member variable. (default = None) create_neck_pose: bool, optional Flag for creating a member variable for the neck pose. (default = False) neck_pose: torch.tensor, optional, Bx3 The default value for the neck pose variable. (default = None) create_jaw_pose: bool, optional Flag for creating a member variable for the jaw pose. (default = False) jaw_pose: torch.tensor, optional, Bx3 The default value for the jaw pose variable. (default = None) create_leye_pose: bool, optional Flag for creating a member variable for the left eye pose. (default = False) leye_pose: torch.tensor, optional, Bx10 The default value for the left eye pose variable. (default = None) create_reye_pose: bool, optional Flag for creating a member variable for the right eye pose. (default = False) reye_pose: torch.tensor, optional, Bx10 The default value for the right eye pose variable. (default = None) use_face_contour: bool, optional Whether to compute the keypoints that form the facial contour batch_size: int, optional The batch size used for creating the member variables gender: str, optional Which gender to load dtype: torch.dtype The data type for the created variables ''' model_fn = f'FLAME_{gender.upper()}.{ext}' flame_path = os.path.join(model_path, model_fn) assert osp.exists(flame_path), 'Path {} does not exist!'.format( flame_path) if ext == 'npz': file_data = np.load(flame_path, allow_pickle=True) elif ext == 'pkl': with open(flame_path, 'rb') as smpl_file: file_data = pickle.load(smpl_file, encoding='latin1') else: raise ValueError('Unknown extension: {}'.format(ext)) data_struct = Struct(**file_data) super(FLAME, self).__init__( model_path=model_path, data_struct=data_struct, dtype=dtype, batch_size=batch_size, gender=gender, ext=ext) self.use_face_contour = use_face_contour self.vertex_joint_selector.extra_joints_idxs = to_tensor( [], dtype=torch.long) if create_neck_pose: if neck_pose is None: default_neck_pose = torch.zeros([batch_size, 3], dtype=dtype) else: default_neck_pose = torch.tensor(neck_pose, dtype=dtype) neck_pose_param = nn.Parameter( default_neck_pose, requires_grad=True) self.register_parameter('neck_pose', neck_pose_param) if create_jaw_pose: if jaw_pose is None: default_jaw_pose = torch.zeros([batch_size, 3], dtype=dtype) else: default_jaw_pose = torch.tensor(jaw_pose, dtype=dtype) jaw_pose_param = nn.Parameter(default_jaw_pose, requires_grad=True) self.register_parameter('jaw_pose', jaw_pose_param) if create_leye_pose: if leye_pose is None: default_leye_pose = torch.zeros([batch_size, 3], dtype=dtype) else: default_leye_pose = torch.tensor(leye_pose, dtype=dtype) leye_pose_param = nn.Parameter(default_leye_pose, requires_grad=True) self.register_parameter('leye_pose', leye_pose_param) if create_reye_pose: if reye_pose is None: default_reye_pose = torch.zeros([batch_size, 3], dtype=dtype) else: default_reye_pose = torch.tensor(reye_pose, dtype=dtype) reye_pose_param = nn.Parameter(default_reye_pose, requires_grad=True) self.register_parameter('reye_pose', reye_pose_param) shapedirs = data_struct.shapedirs if len(shapedirs.shape) < 3: shapedirs = shapedirs[:, :, None] if (shapedirs.shape[-1] < self.SHAPE_SPACE_DIM + self.EXPRESSION_SPACE_DIM): print(f'WARNING: You are using a {self.name()} model, with only' ' 10 shape and 10 expression coefficients.') expr_start_idx = 10 expr_end_idx = 20 num_expression_coeffs = min(num_expression_coeffs, 10) else: expr_start_idx = self.SHAPE_SPACE_DIM expr_end_idx = self.SHAPE_SPACE_DIM + num_expression_coeffs num_expression_coeffs = min( num_expression_coeffs, self.EXPRESSION_SPACE_DIM) self._num_expression_coeffs = num_expression_coeffs expr_dirs = shapedirs[:, :, expr_start_idx:expr_end_idx] self.register_buffer( 'expr_dirs', to_tensor(to_np(expr_dirs), dtype=dtype)) if create_expression: if expression is None: default_expression = torch.zeros( [batch_size, self.num_expression_coeffs], dtype=dtype) else: default_expression = torch.tensor(expression, dtype=dtype) expression_param = nn.Parameter(default_expression, requires_grad=True) self.register_parameter('expression', expression_param) # The pickle file that contains the barycentric coordinates for # regressing the landmarks landmark_bcoord_filename = osp.join( model_path, 'flame_static_embedding.pkl') with open(landmark_bcoord_filename, 'rb') as fp: landmarks_data = pickle.load(fp, encoding='latin1') lmk_faces_idx = landmarks_data['lmk_face_idx'].astype(np.int64) self.register_buffer('lmk_faces_idx', torch.tensor(lmk_faces_idx, dtype=torch.long)) lmk_bary_coords = landmarks_data['lmk_b_coords'] self.register_buffer('lmk_bary_coords', torch.tensor(lmk_bary_coords, dtype=dtype)) if self.use_face_contour: face_contour_path = os.path.join( model_path, 'flame_dynamic_embedding.npy') contour_embeddings = np.load(face_contour_path, allow_pickle=True, encoding='latin1')[()] dynamic_lmk_faces_idx = np.array( contour_embeddings['lmk_face_idx'], dtype=np.int64) dynamic_lmk_faces_idx = torch.tensor( dynamic_lmk_faces_idx, dtype=torch.long) self.register_buffer('dynamic_lmk_faces_idx', dynamic_lmk_faces_idx) dynamic_lmk_b_coords = torch.tensor( contour_embeddings['lmk_b_coords'], dtype=dtype) self.register_buffer( 'dynamic_lmk_bary_coords', dynamic_lmk_b_coords) neck_kin_chain = find_joint_kin_chain(self.NECK_IDX, self.parents) self.register_buffer( 'neck_kin_chain', torch.tensor(neck_kin_chain, dtype=torch.long)) def num_expression_coeffs(self): return self._num_expression_coeffs def name(self) -> str: return 'FLAME' def extra_repr(self): msg = [ super(FLAME, self).extra_repr(), f'Number of Expression Coefficients: {self.num_expression_coeffs}', f'Use face contour: {self.use_face_contour}', ] return '\n'.join(msg) def forward( self, betas: Optional[Tensor] = None, global_orient: Optional[Tensor] = None, neck_pose: Optional[Tensor] = None, transl: Optional[Tensor] = None, expression: Optional[Tensor] = None, jaw_pose: Optional[Tensor] = None, leye_pose: Optional[Tensor] = None, reye_pose: Optional[Tensor] = None, return_verts: bool = True, return_full_pose: bool = False, pose2rot: bool = True ) -> FLAMEOutput: ''' Forward pass for the SMPLX model Parameters ---------- global_orient: torch.tensor, optional, shape Bx3 If given, ignore the member variable and use it as the global rotation of the body. Useful if someone wishes to predicts this with an external model. (default=None) betas: torch.tensor, optional, shape Bx10 If given, ignore the member variable `betas` and use it instead. For example, it can used if shape parameters `betas` are predicted from some external model. (default=None) expression: torch.tensor, optional, shape Bx10 If given, ignore the member variable `expression` and use it instead. For example, it can used if expression parameters `expression` are predicted from some external model. jaw_pose: torch.tensor, optional, shape Bx3 If given, ignore the member variable `jaw_pose` and use this instead. It should either joint rotations in axis-angle format. jaw_pose: torch.tensor, optional, shape Bx3 If given, ignore the member variable `jaw_pose` and use this instead. It should either joint rotations in axis-angle format. transl: torch.tensor, optional, shape Bx3 If given, ignore the member variable `transl` and use it instead. For example, it can used if the translation `transl` is predicted from some external model. (default=None) return_verts: bool, optional Return the vertices. (default=True) return_full_pose: bool, optional Returns the full axis-angle pose vector (default=False) Returns ------- output: ModelOutput A named tuple of type `ModelOutput` ''' # If no shape and pose parameters are passed along, then use the # ones from the module global_orient = (global_orient if global_orient is not None else self.global_orient) jaw_pose = jaw_pose if jaw_pose is not None else self.jaw_pose neck_pose = neck_pose if neck_pose is not None else self.neck_pose leye_pose = leye_pose if leye_pose is not None else self.leye_pose reye_pose = reye_pose if reye_pose is not None else self.reye_pose betas = betas if betas is not None else self.betas expression = expression if expression is not None else self.expression apply_trans = transl is not None or hasattr(self, 'transl') if transl is None: if hasattr(self, 'transl'): transl = self.transl full_pose = torch.cat( [global_orient, neck_pose, jaw_pose, leye_pose, reye_pose], dim=1) batch_size = max(betas.shape[0], global_orient.shape[0], jaw_pose.shape[0]) # Concatenate the shape and expression coefficients scale = int(batch_size / betas.shape[0]) if scale > 1: betas = betas.expand(scale, -1) shape_components = torch.cat([betas, expression], dim=-1) shapedirs = torch.cat([self.shapedirs, self.expr_dirs], dim=-1) vertices, joints = lbs(shape_components, full_pose, self.v_template, shapedirs, self.posedirs, self.J_regressor, self.parents, self.lbs_weights, pose2rot=pose2rot, ) lmk_faces_idx = self.lmk_faces_idx.unsqueeze( dim=0).expand(batch_size, -1).contiguous() lmk_bary_coords = self.lmk_bary_coords.unsqueeze(dim=0).repeat( self.batch_size, 1, 1) if self.use_face_contour: lmk_idx_and_bcoords = find_dynamic_lmk_idx_and_bcoords( vertices, full_pose, self.dynamic_lmk_faces_idx, self.dynamic_lmk_bary_coords, self.neck_kin_chain, pose2rot=True, ) dyn_lmk_faces_idx, dyn_lmk_bary_coords = lmk_idx_and_bcoords lmk_faces_idx = torch.cat([lmk_faces_idx, dyn_lmk_faces_idx], 1) lmk_bary_coords = torch.cat( [lmk_bary_coords.expand(batch_size, -1, -1), dyn_lmk_bary_coords], 1) landmarks = vertices2landmarks(vertices, self.faces_tensor, lmk_faces_idx, lmk_bary_coords) # Add any extra joints that might be needed joints = self.vertex_joint_selector(vertices, joints) # Add the landmarks to the joints joints = torch.cat([joints, landmarks], dim=1) # Map the joints to the current dataset if self.joint_mapper is not None: joints = self.joint_mapper(joints=joints, vertices=vertices) if apply_trans: joints += transl.unsqueeze(dim=1) vertices += transl.unsqueeze(dim=1) output = FLAMEOutput(vertices=vertices if return_verts else None, joints=joints, betas=betas, expression=expression, global_orient=global_orient, neck_pose=neck_pose, jaw_pose=jaw_pose, full_pose=full_pose if return_full_pose else None) return output The provided code snippet includes necessary dependencies for implementing the `create` function. Write a Python function `def create( model_path: str, model_type: str = 'smpl' ) -> Union[SMPL, SMPLH, SMPLX, MANO, FLAME]` to solve the following problem: Method for creating a model from a path and a model type Parameters ---------- model_path: str Either the path to the model you wish to load or a folder, where each subfolder contains the differents types, i.e.: model_path: | |-- smpl |-- SMPL_FEMALE |-- SMPL_NEUTRAL |-- SMPL_MALE |-- smplh |-- SMPLH_FEMALE |-- SMPLH_MALE |-- smplx |-- SMPLX_FEMALE |-- SMPLX_NEUTRAL |-- SMPLX_MALE |-- mano |-- MANO RIGHT |-- MANO LEFT model_type: str, optional When model_path is a folder, then this parameter specifies the type of model to be loaded **kwargs: dict Keyword arguments Returns ------- body_model: nn.Module The PyTorch module that implements the corresponding body model Raises ------ ValueError: In case the model type is not one of SMPL, SMPLH, SMPLX, MANO or FLAME Here is the function: def create( model_path: str, model_type: str = 'smpl' ) -> Union[SMPL, SMPLH, SMPLX, MANO, FLAME]: ''' Method for creating a model from a path and a model type Parameters ---------- model_path: str Either the path to the model you wish to load or a folder, where each subfolder contains the differents types, i.e.: model_path: | |-- smpl |-- SMPL_FEMALE |-- SMPL_NEUTRAL |-- SMPL_MALE |-- smplh |-- SMPLH_FEMALE |-- SMPLH_MALE |-- smplx |-- SMPLX_FEMALE |-- SMPLX_NEUTRAL |-- SMPLX_MALE |-- mano |-- MANO RIGHT |-- MANO LEFT model_type: str, optional When model_path is a folder, then this parameter specifies the type of model to be loaded **kwargs: dict Keyword arguments Returns ------- body_model: nn.Module The PyTorch module that implements the corresponding body model Raises ------ ValueError: In case the model type is not one of SMPL, SMPLH, SMPLX, MANO or FLAME ''' # If it's a folder, assume if osp.isdir(model_path): model_path = os.path.join(model_path, model_type) else: model_type = osp.basename(model_path).split('_')[0].lower() if model_type.lower() == 'smpl': return SMPL(model_path) elif model_type.lower() == 'smplh': return SMPLH(model_path) elif model_type.lower() == 'smplx': return SMPLX(model_path) elif 'mano' in model_type.lower(): return MANO(model_path) elif 'flame' in model_type.lower(): return FLAME(model_path) else: raise ValueError(f'Unknown model type {model_type}, exiting!')

Method for creating a model from a path and a model type Parameters ---------- model_path: str Either the path to the model you wish to load or a folder, where each subfolder contains the differents types, i.e.: model_path: | |-- smpl |-- SMPL_FEMALE |-- SMPL_NEUTRAL |-- SMPL_MALE |-- smplh |-- SMPLH_FEMALE |-- SMPLH_MALE |-- smplx |-- SMPLX_FEMALE |-- SMPLX_NEUTRAL |-- SMPLX_MALE |-- mano |-- MANO RIGHT |-- MANO LEFT model_type: str, optional When model_path is a folder, then this parameter specifies the type of model to be loaded **kwargs: dict Keyword arguments Returns ------- body_model: nn.Module The PyTorch module that implements the corresponding body model Raises ------ ValueError: In case the model type is not one of SMPL, SMPLH, SMPLX, MANO or FLAME

from typing import NewType, Union, Optional from dataclasses import dataclass, asdict, fields import numpy as np import torch def find_joint_kin_chain(joint_id, kinematic_tree): kin_chain = [] curr_idx = joint_id while curr_idx != -1: kin_chain.append(curr_idx) curr_idx = kinematic_tree[curr_idx] return kin_chain

from typing import NewType, Union, Optional from dataclasses import dataclass, asdict, fields import numpy as np import torch Tensor = NewType('Tensor', torch.Tensor) Array = NewType('Array', np.ndarray) def to_tensor( array: Union[Array, Tensor], dtype=torch.float32 ) -> Tensor: if torch.is_tensor(array): return array else: return torch.tensor(array, dtype=dtype)

from typing import NewType, Union, Optional from dataclasses import dataclass, asdict, fields import numpy as np import torch def to_np(array, dtype=np.float32): if 'scipy.sparse' in str(type(array)): array = array.todense() return np.array(array, dtype=dtype)

from __future__ import absolute_import from __future__ import print_function from __future__ import division from typing import Tuple, List import numpy as np import torch import torch.nn.functional as F from .utils import rot_mat_to_euler, Tensor def batch_rodrigues( rot_vecs: Tensor, epsilon: float = 1e-8, ) -> Tensor: ''' Calculates the rotation matrices for a batch of rotation vectors Parameters ---------- rot_vecs: torch.tensor Nx3 array of N axis-angle vectors Returns ------- R: torch.tensor Nx3x3 The rotation matrices for the given axis-angle parameters ''' batch_size = rot_vecs.shape[0] device, dtype = rot_vecs.device, rot_vecs.dtype angle = torch.norm(rot_vecs + 1e-8, dim=1, keepdim=True) rot_dir = rot_vecs / angle cos = torch.unsqueeze(torch.cos(angle), dim=1) sin = torch.unsqueeze(torch.sin(angle), dim=1) # Bx1 arrays rx, ry, rz = torch.split(rot_dir, 1, dim=1) K = torch.zeros((batch_size, 3, 3), dtype=dtype, device=device) zeros = torch.zeros((batch_size, 1), dtype=dtype, device=device) K = torch.cat([zeros, -rz, ry, rz, zeros, -rx, -ry, rx, zeros], dim=1) \ .view((batch_size, 3, 3)) ident = torch.eye(3, dtype=dtype, device=device).unsqueeze(dim=0) rot_mat = ident + sin * K + (1 - cos) * torch.bmm(K, K) return rot_mat Tensor = NewType('Tensor', torch.Tensor) def rot_mat_to_euler(rot_mats): # Calculates rotation matrix to euler angles # Careful for extreme cases of eular angles like [0.0, pi, 0.0] sy = torch.sqrt(rot_mats[:, 0, 0] * rot_mats[:, 0, 0] + rot_mats[:, 1, 0] * rot_mats[:, 1, 0]) return torch.atan2(-rot_mats[:, 2, 0], sy) The provided code snippet includes necessary dependencies for implementing the `find_dynamic_lmk_idx_and_bcoords` function. Write a Python function `def find_dynamic_lmk_idx_and_bcoords( vertices: Tensor, pose: Tensor, dynamic_lmk_faces_idx: Tensor, dynamic_lmk_b_coords: Tensor, neck_kin_chain: List[int], pose2rot: bool = True, ) -> Tuple[Tensor, Tensor]` to solve the following problem: Compute the faces, barycentric coordinates for the dynamic landmarks To do so, we first compute the rotation of the neck around the y-axis and then use a pre-computed look-up table to find the faces and the barycentric coordinates that will be used. Special thanks to Soubhik Sanyal (soubhik.sanyal@tuebingen.mpg.de) for providing the original TensorFlow implementation and for the LUT. Parameters ---------- vertices: torch.tensor BxVx3, dtype = torch.float32 The tensor of input vertices pose: torch.tensor Bx(Jx3), dtype = torch.float32 The current pose of the body model dynamic_lmk_faces_idx: torch.tensor L, dtype = torch.long The look-up table from neck rotation to faces dynamic_lmk_b_coords: torch.tensor Lx3, dtype = torch.float32 The look-up table from neck rotation to barycentric coordinates neck_kin_chain: list A python list that contains the indices of the joints that form the kinematic chain of the neck. dtype: torch.dtype, optional Returns ------- dyn_lmk_faces_idx: torch.tensor, dtype = torch.long A tensor of size BxL that contains the indices of the faces that will be used to compute the current dynamic landmarks. dyn_lmk_b_coords: torch.tensor, dtype = torch.float32 A tensor of size BxL that contains the indices of the faces that will be used to compute the current dynamic landmarks. Here is the function: def find_dynamic_lmk_idx_and_bcoords( vertices: Tensor, pose: Tensor, dynamic_lmk_faces_idx: Tensor, dynamic_lmk_b_coords: Tensor, neck_kin_chain: List[int], pose2rot: bool = True, ) -> Tuple[Tensor, Tensor]: ''' Compute the faces, barycentric coordinates for the dynamic landmarks To do so, we first compute the rotation of the neck around the y-axis and then use a pre-computed look-up table to find the faces and the barycentric coordinates that will be used. Special thanks to Soubhik Sanyal (soubhik.sanyal@tuebingen.mpg.de) for providing the original TensorFlow implementation and for the LUT. Parameters ---------- vertices: torch.tensor BxVx3, dtype = torch.float32 The tensor of input vertices pose: torch.tensor Bx(Jx3), dtype = torch.float32 The current pose of the body model dynamic_lmk_faces_idx: torch.tensor L, dtype = torch.long The look-up table from neck rotation to faces dynamic_lmk_b_coords: torch.tensor Lx3, dtype = torch.float32 The look-up table from neck rotation to barycentric coordinates neck_kin_chain: list A python list that contains the indices of the joints that form the kinematic chain of the neck. dtype: torch.dtype, optional Returns ------- dyn_lmk_faces_idx: torch.tensor, dtype = torch.long A tensor of size BxL that contains the indices of the faces that will be used to compute the current dynamic landmarks. dyn_lmk_b_coords: torch.tensor, dtype = torch.float32 A tensor of size BxL that contains the indices of the faces that will be used to compute the current dynamic landmarks. ''' dtype = vertices.dtype batch_size = vertices.shape[0] if pose2rot: aa_pose = torch.index_select(pose.view(batch_size, -1, 3), 1, neck_kin_chain) rot_mats = batch_rodrigues( aa_pose.view(-1, 3)).view(batch_size, -1, 3, 3) else: rot_mats = torch.index_select( pose.view(batch_size, -1, 3, 3), 1, neck_kin_chain) rel_rot_mat = torch.eye( 3, device=vertices.device, dtype=dtype).unsqueeze_(dim=0).repeat( batch_size, 1, 1) for idx in range(len(neck_kin_chain)): rel_rot_mat = torch.bmm(rot_mats[:, idx], rel_rot_mat) y_rot_angle = torch.round( torch.clamp(-rot_mat_to_euler(rel_rot_mat) * 180.0 / np.pi, max=39)).to(dtype=torch.long) neg_mask = y_rot_angle.lt(0).to(dtype=torch.long) mask = y_rot_angle.lt(-39).to(dtype=torch.long) neg_vals = mask * 78 + (1 - mask) * (39 - y_rot_angle) y_rot_angle = (neg_mask * neg_vals + (1 - neg_mask) * y_rot_angle) dyn_lmk_faces_idx = torch.index_select(dynamic_lmk_faces_idx, 0, y_rot_angle) dyn_lmk_b_coords = torch.index_select(dynamic_lmk_b_coords, 0, y_rot_angle) return dyn_lmk_faces_idx, dyn_lmk_b_coords

Compute the faces, barycentric coordinates for the dynamic landmarks To do so, we first compute the rotation of the neck around the y-axis and then use a pre-computed look-up table to find the faces and the barycentric coordinates that will be used. Special thanks to Soubhik Sanyal (soubhik.sanyal@tuebingen.mpg.de) for providing the original TensorFlow implementation and for the LUT. Parameters ---------- vertices: torch.tensor BxVx3, dtype = torch.float32 The tensor of input vertices pose: torch.tensor Bx(Jx3), dtype = torch.float32 The current pose of the body model dynamic_lmk_faces_idx: torch.tensor L, dtype = torch.long The look-up table from neck rotation to faces dynamic_lmk_b_coords: torch.tensor Lx3, dtype = torch.float32 The look-up table from neck rotation to barycentric coordinates neck_kin_chain: list A python list that contains the indices of the joints that form the kinematic chain of the neck. dtype: torch.dtype, optional Returns ------- dyn_lmk_faces_idx: torch.tensor, dtype = torch.long A tensor of size BxL that contains the indices of the faces that will be used to compute the current dynamic landmarks. dyn_lmk_b_coords: torch.tensor, dtype = torch.float32 A tensor of size BxL that contains the indices of the faces that will be used to compute the current dynamic landmarks.

from __future__ import absolute_import from __future__ import print_function from __future__ import division from typing import Tuple, List import numpy as np import torch import torch.nn.functional as F from .utils import rot_mat_to_euler, Tensor Tensor = NewType('Tensor', torch.Tensor) The provided code snippet includes necessary dependencies for implementing the `vertices2landmarks` function. Write a Python function `def vertices2landmarks( vertices: Tensor, faces: Tensor, lmk_faces_idx: Tensor, lmk_bary_coords: Tensor ) -> Tensor` to solve the following problem: Calculates landmarks by barycentric interpolation Parameters ---------- vertices: torch.tensor BxVx3, dtype = torch.float32 The tensor of input vertices faces: torch.tensor Fx3, dtype = torch.long The faces of the mesh lmk_faces_idx: torch.tensor L, dtype = torch.long The tensor with the indices of the faces used to calculate the landmarks. lmk_bary_coords: torch.tensor Lx3, dtype = torch.float32 The tensor of barycentric coordinates that are used to interpolate the landmarks Returns ------- landmarks: torch.tensor BxLx3, dtype = torch.float32 The coordinates of the landmarks for each mesh in the batch Here is the function: def vertices2landmarks( vertices: Tensor, faces: Tensor, lmk_faces_idx: Tensor, lmk_bary_coords: Tensor ) -> Tensor: ''' Calculates landmarks by barycentric interpolation Parameters ---------- vertices: torch.tensor BxVx3, dtype = torch.float32 The tensor of input vertices faces: torch.tensor Fx3, dtype = torch.long The faces of the mesh lmk_faces_idx: torch.tensor L, dtype = torch.long The tensor with the indices of the faces used to calculate the landmarks. lmk_bary_coords: torch.tensor Lx3, dtype = torch.float32 The tensor of barycentric coordinates that are used to interpolate the landmarks Returns ------- landmarks: torch.tensor BxLx3, dtype = torch.float32 The coordinates of the landmarks for each mesh in the batch ''' # Extract the indices of the vertices for each face # BxLx3 batch_size, num_verts = vertices.shape[:2] device = vertices.device lmk_faces = torch.index_select(faces, 0, lmk_faces_idx.view(-1)).view( batch_size, -1, 3) lmk_faces += torch.arange( batch_size, dtype=torch.long, device=device).view(-1, 1, 1) * num_verts lmk_vertices = vertices.view(-1, 3)[lmk_faces].view( batch_size, -1, 3, 3) landmarks = torch.einsum('blfi,blf->bli', [lmk_vertices, lmk_bary_coords]) return landmarks

Calculates landmarks by barycentric interpolation Parameters ---------- vertices: torch.tensor BxVx3, dtype = torch.float32 The tensor of input vertices faces: torch.tensor Fx3, dtype = torch.long The faces of the mesh lmk_faces_idx: torch.tensor L, dtype = torch.long The tensor with the indices of the faces used to calculate the landmarks. lmk_bary_coords: torch.tensor Lx3, dtype = torch.float32 The tensor of barycentric coordinates that are used to interpolate the landmarks Returns ------- landmarks: torch.tensor BxLx3, dtype = torch.float32 The coordinates of the landmarks for each mesh in the batch

from __future__ import absolute_import from __future__ import print_function from __future__ import division from typing import Tuple, List import numpy as np import torch import torch.nn.functional as F from .utils import rot_mat_to_euler, Tensor def vertices2joints(J_regressor: Tensor, vertices: Tensor) -> Tensor: ''' Calculates the 3D joint locations from the vertices Parameters ---------- J_regressor : torch.tensor JxV The regressor array that is used to calculate the joints from the position of the vertices vertices : torch.tensor BxVx3 The tensor of mesh vertices Returns ------- torch.tensor BxJx3 The location of the joints ''' return torch.einsum('bik,ji->bjk', [vertices, J_regressor]) def blend_shapes(betas: Tensor, shape_disps: Tensor) -> Tensor: ''' Calculates the per vertex displacement due to the blend shapes Parameters ---------- betas : torch.tensor Bx(num_betas) Blend shape coefficients shape_disps: torch.tensor Vx3x(num_betas) Blend shapes Returns ------- torch.tensor BxVx3 The per-vertex displacement due to shape deformation ''' # Displacement[b, m, k] = sum_{l} betas[b, l] * shape_disps[m, k, l] # i.e. Multiply each shape displacement by its corresponding beta and # then sum them. blend_shape = torch.einsum('bl,mkl->bmk', [betas, shape_disps]) return blend_shape def batch_rodrigues( rot_vecs: Tensor, epsilon: float = 1e-8, ) -> Tensor: ''' Calculates the rotation matrices for a batch of rotation vectors Parameters ---------- rot_vecs: torch.tensor Nx3 array of N axis-angle vectors Returns ------- R: torch.tensor Nx3x3 The rotation matrices for the given axis-angle parameters ''' batch_size = rot_vecs.shape[0] device, dtype = rot_vecs.device, rot_vecs.dtype angle = torch.norm(rot_vecs + 1e-8, dim=1, keepdim=True) rot_dir = rot_vecs / angle cos = torch.unsqueeze(torch.cos(angle), dim=1) sin = torch.unsqueeze(torch.sin(angle), dim=1) # Bx1 arrays rx, ry, rz = torch.split(rot_dir, 1, dim=1) K = torch.zeros((batch_size, 3, 3), dtype=dtype, device=device) zeros = torch.zeros((batch_size, 1), dtype=dtype, device=device) K = torch.cat([zeros, -rz, ry, rz, zeros, -rx, -ry, rx, zeros], dim=1) \ .view((batch_size, 3, 3)) ident = torch.eye(3, dtype=dtype, device=device).unsqueeze(dim=0) rot_mat = ident + sin * K + (1 - cos) * torch.bmm(K, K) return rot_mat def batch_rigid_transform( rot_mats: Tensor, joints: Tensor, parents: Tensor, dtype=torch.float32 ) -> Tensor: """ Applies a batch of rigid transformations to the joints Parameters ---------- rot_mats : torch.tensor BxNx3x3 Tensor of rotation matrices joints : torch.tensor BxNx3 Locations of joints parents : torch.tensor BxN The kinematic tree of each object dtype : torch.dtype, optional: The data type of the created tensors, the default is torch.float32 Returns ------- posed_joints : torch.tensor BxNx3 The locations of the joints after applying the pose rotations rel_transforms : torch.tensor BxNx4x4 The relative (with respect to the root joint) rigid transformations for all the joints """ joints = torch.unsqueeze(joints, dim=-1) rel_joints = joints.clone() rel_joints[:, 1:] -= joints[:, parents[1:]] transforms_mat = transform_mat( rot_mats.reshape(-1, 3, 3), rel_joints.reshape(-1, 3, 1)).reshape(-1, joints.shape[1], 4, 4) transform_chain = [transforms_mat[:, 0]] for i in range(1, parents.shape[0]): # Subtract the joint location at the rest pose # No need for rotation, since it's identity when at rest curr_res = torch.matmul(transform_chain[parents[i]], transforms_mat[:, i]) transform_chain.append(curr_res) transforms = torch.stack(transform_chain, dim=1) # The last column of the transformations contains the posed joints posed_joints = transforms[:, :, :3, 3] joints_homogen = F.pad(joints, [0, 0, 0, 1]) rel_transforms = transforms - F.pad( torch.matmul(transforms, joints_homogen), [3, 0, 0, 0, 0, 0, 0, 0]) return posed_joints, rel_transforms Tensor = NewType('Tensor', torch.Tensor) The provided code snippet includes necessary dependencies for implementing the `lbs` function. Write a Python function `def lbs( betas: Tensor, pose: Tensor, v_template: Tensor, shapedirs: Tensor, posedirs: Tensor, J_regressor: Tensor, parents: Tensor, lbs_weights: Tensor, pose2rot: bool = True, ) -> Tuple[Tensor, Tensor]` to solve the following problem: Performs Linear Blend Skinning with the given shape and pose parameters Parameters ---------- betas : torch.tensor BxNB The tensor of shape parameters pose : torch.tensor Bx(J + 1) * 3 The pose parameters in axis-angle format v_template torch.tensor BxVx3 The template mesh that will be deformed shapedirs : torch.tensor 1xNB The tensor of PCA shape displacements posedirs : torch.tensor Px(V * 3) The pose PCA coefficients J_regressor : torch.tensor JxV The regressor array that is used to calculate the joints from the position of the vertices parents: torch.tensor J The array that describes the kinematic tree for the model lbs_weights: torch.tensor N x V x (J + 1) The linear blend skinning weights that represent how much the rotation matrix of each part affects each vertex pose2rot: bool, optional Flag on whether to convert the input pose tensor to rotation matrices. The default value is True. If False, then the pose tensor should already contain rotation matrices and have a size of Bx(J + 1)x9 dtype: torch.dtype, optional Returns ------- verts: torch.tensor BxVx3 The vertices of the mesh after applying the shape and pose displacements. joints: torch.tensor BxJx3 The joints of the model Here is the function: def lbs( betas: Tensor, pose: Tensor, v_template: Tensor, shapedirs: Tensor, posedirs: Tensor, J_regressor: Tensor, parents: Tensor, lbs_weights: Tensor, pose2rot: bool = True, ) -> Tuple[Tensor, Tensor]: ''' Performs Linear Blend Skinning with the given shape and pose parameters Parameters ---------- betas : torch.tensor BxNB The tensor of shape parameters pose : torch.tensor Bx(J + 1) * 3 The pose parameters in axis-angle format v_template torch.tensor BxVx3 The template mesh that will be deformed shapedirs : torch.tensor 1xNB The tensor of PCA shape displacements posedirs : torch.tensor Px(V * 3) The pose PCA coefficients J_regressor : torch.tensor JxV The regressor array that is used to calculate the joints from the position of the vertices parents: torch.tensor J The array that describes the kinematic tree for the model lbs_weights: torch.tensor N x V x (J + 1) The linear blend skinning weights that represent how much the rotation matrix of each part affects each vertex pose2rot: bool, optional Flag on whether to convert the input pose tensor to rotation matrices. The default value is True. If False, then the pose tensor should already contain rotation matrices and have a size of Bx(J + 1)x9 dtype: torch.dtype, optional Returns ------- verts: torch.tensor BxVx3 The vertices of the mesh after applying the shape and pose displacements. joints: torch.tensor BxJx3 The joints of the model ''' batch_size = max(betas.shape[0], pose.shape[0]) device, dtype = betas.device, betas.dtype # Add shape contribution v_shaped = v_template + blend_shapes(betas, shapedirs) # Get the joints # NxJx3 array J = vertices2joints(J_regressor, v_shaped) # 3. Add pose blend shapes # N x J x 3 x 3 ident = torch.eye(3, dtype=dtype, device=device) if pose2rot: rot_mats = batch_rodrigues(pose.view(-1, 3)).view( [batch_size, -1, 3, 3]) pose_feature = (rot_mats[:, 1:, :, :] - ident).view([batch_size, -1]) # (N x P) x (P, V * 3) -> N x V x 3 pose_offsets = torch.matmul( pose_feature, posedirs).view(batch_size, -1, 3) else: pose_feature = pose[:, 1:].view(batch_size, -1, 3, 3) - ident rot_mats = pose.view(batch_size, -1, 3, 3) pose_offsets = torch.matmul(pose_feature.view(batch_size, -1), posedirs).view(batch_size, -1, 3) v_posed = pose_offsets + v_shaped # 4. Get the global joint location J_transformed, A = batch_rigid_transform(rot_mats, J, parents, dtype=dtype) # 5. Do skinning: # W is N x V x (J + 1) W = lbs_weights.unsqueeze(dim=0).expand([batch_size, -1, -1]) # (N x V x (J + 1)) x (N x (J + 1) x 16) num_joints = J_regressor.shape[0] T = torch.matmul(W, A.view(batch_size, num_joints, 16)) \ .view(batch_size, -1, 4, 4) homogen_coord = torch.ones([batch_size, v_posed.shape[1], 1], dtype=dtype, device=device) v_posed_homo = torch.cat([v_posed, homogen_coord], dim=2) v_homo = torch.matmul(T, torch.unsqueeze(v_posed_homo, dim=-1)) verts = v_homo[:, :, :3, 0] return verts, J_transformed

Performs Linear Blend Skinning with the given shape and pose parameters Parameters ---------- betas : torch.tensor BxNB The tensor of shape parameters pose : torch.tensor Bx(J + 1) * 3 The pose parameters in axis-angle format v_template torch.tensor BxVx3 The template mesh that will be deformed shapedirs : torch.tensor 1xNB The tensor of PCA shape displacements posedirs : torch.tensor Px(V * 3) The pose PCA coefficients J_regressor : torch.tensor JxV The regressor array that is used to calculate the joints from the position of the vertices parents: torch.tensor J The array that describes the kinematic tree for the model lbs_weights: torch.tensor N x V x (J + 1) The linear blend skinning weights that represent how much the rotation matrix of each part affects each vertex pose2rot: bool, optional Flag on whether to convert the input pose tensor to rotation matrices. The default value is True. If False, then the pose tensor should already contain rotation matrices and have a size of Bx(J + 1)x9 dtype: torch.dtype, optional Returns ------- verts: torch.tensor BxVx3 The vertices of the mesh after applying the shape and pose displacements. joints: torch.tensor BxJx3 The joints of the model

import os import io import ntpath import hashlib import fnmatch import shlex import speakeasy.winenv.defs.windows.windows as windefs import speakeasy.winenv.arch as _arch from speakeasy.errors import FileSystemEmuError def normalize_response_path(path): def _get_speakeasy_root(): return os.path.join(os.path.dirname(__file__), os.pardir) root_var = '$ROOT$' if root_var in path: root = _get_speakeasy_root() return path.replace(root_var, root) return path

import collections import speakeasy.winenv.arch as e_arch def _lowercase_set(tt): return set([bb.lower() for bb in tt])

import io import os from urllib.parse import urlparse from io import BytesIO from speakeasy.errors import NetworkEmuError def is_empty(bio): if len(bio.getbuffer()) == bio.tell(): return True return False

import io import os from urllib.parse import urlparse from io import BytesIO from speakeasy.errors import NetworkEmuError def normalize_response_path(path): def _get_speakeasy_root(): return os.path.join(os.path.dirname(__file__), os.pardir) root_var = '$ROOT$' if root_var in path: root = _get_speakeasy_root() return path.replace(root_var, root) return path

import os import ntpath import hashlib from collections import namedtuple import pefile import speakeasy.winenv.arch as _arch import speakeasy.winenv.defs.nt.ddk as ddk from speakeasy.struct import Enum def normalize_dll_name(name): ret = name # Funnel CRTs into a single handler if name.lower().startswith(('api-ms-win-crt', 'vcruntime', 'ucrtbased', 'ucrtbase', 'msvcr', 'msvcp')): ret = 'msvcrt' # Redirect windows sockets 1.0 to windows sockets 2.0 elif name.lower().startswith(('winsock', 'wsock32')): ret = 'ws2_32' elif name.lower().startswith('api-ms-win-core'): ret = 'kernel32' return ret

import os import json import time import logging import argparse import multiprocessing as mp import speakeasy from speakeasy import Speakeasy import speakeasy.winenv.arch as e_arch def get_logger(): """ Get the default logger for speakeasy """ logger = logging.getLogger('speakeasy') if not logger.handlers: sh = logging.StreamHandler() logger.addHandler(sh) logger.setLevel(logging.INFO) return logger The provided code snippet includes necessary dependencies for implementing the `emulate_binary` function. Write a Python function `def emulate_binary(q, exit_event, fpath, cfg, argv, do_raw, arch='', drop_path='', dump_path='', raw_offset=0x0, emulate_children=False)` to solve the following problem: Setup the binary for emulation Here is the function: def emulate_binary(q, exit_event, fpath, cfg, argv, do_raw, arch='', drop_path='', dump_path='', raw_offset=0x0, emulate_children=False): """ Setup the binary for emulation """ logger = get_logger() try: report = None se = Speakeasy(config=cfg, logger=logger, argv=argv, exit_event=exit_event) if do_raw: arch = arch.lower() if arch == 'x86': arch = e_arch.ARCH_X86 elif arch in ('x64', 'amd64'): arch = e_arch.ARCH_AMD64 else: raise Exception('Unsupported architecture: %s' % arch) sc_addr = se.load_shellcode(fpath, arch) se.run_shellcode(sc_addr, offset=raw_offset or 0) else: module = se.load_module(fpath) se.run_module(module, all_entrypoints=True, emulate_children=emulate_children) finally: report = se.get_json_report() q.put(report) # If a memory dump was requested, do it now if dump_path: data = se.create_memdump_archive() logger.info('* Saving memory dump archive to %s' % (dump_path)) with open(dump_path, 'wb') as f: f.write(data) if drop_path: data = se.create_file_archive() if data: logger.info('* Saving dropped files archive to %s' % (drop_path)) with open(drop_path, 'wb') as f: f.write(data) else: logger.info('* No dropped files found')

Setup the binary for emulation

import os import json import ntpath import hashlib import zipfile from io import BytesIO from typing import Callable from pefile import MACHINE_TYPE import jsonschema import jsonschema.exceptions import speakeasy import speakeasy.winenv.arch as _arch from speakeasy import PeFile from speakeasy import Win32Emulator from speakeasy import WinKernelEmulator from speakeasy.errors import SpeakeasyError, ConfigError, NotSupportedError import speakeasy import speakeasy.winenv.arch as _arch from speakeasy import PeFile from speakeasy import Win32Emulator from speakeasy import WinKernelEmulator from speakeasy.errors import SpeakeasyError, ConfigError, NotSupportedError The provided code snippet includes necessary dependencies for implementing the `validate_config` function. Write a Python function `def validate_config(config) -> None` to solve the following problem: Validates the given configuration objects against the built-in schemas. Raises jsonschema.exceptions.ValidationError on invalid configuration. Expose the underlying jsonschema exception due to it having lots of information about failures. On success, returns without exception. Here is the function: def validate_config(config) -> None: """ Validates the given configuration objects against the built-in schemas. Raises jsonschema.exceptions.ValidationError on invalid configuration. Expose the underlying jsonschema exception due to it having lots of information about failures. On success, returns without exception. """ schema_path = os.path.join(os.path.dirname(speakeasy.__file__), 'config_schema.json') with open(schema_path, 'r') as ff: schema = json.load(ff) validator = jsonschema.Draft7Validator(schema) validator.validate(config)

Validates the given configuration objects against the built-in schemas. Raises jsonschema.exceptions.ValidationError on invalid configuration. Expose the underlying jsonschema exception due to it having lots of information about failures. On success, returns without exception.

import platform import ctypes as ct import unicorn as uc import unicorn.unicorn import unicorn.x86_const as u import speakeasy.winenv.arch as arch import speakeasy.common as common from speakeasy.errors import EmuEngineError def is_platform_intel(): mach = platform.machine() if mach in ('x86_64', 'i386', 'x86'): return True return False

import os The provided code snippet includes necessary dependencies for implementing the `normalize_package_path` function. Write a Python function `def normalize_package_path(path)` to solve the following problem: Get the supplied path in relation to the package root Here is the function: def normalize_package_path(path): """ Get the supplied path in relation to the package root """ def _get_speakeasy_root(): return os.path.join(os.path.dirname(__file__)) root_var = '$ROOT$' if root_var in path: root = _get_speakeasy_root() return path.replace(root_var, root) return path

Get the supplied path in relation to the package root

from socket import inet_aton from urllib.parse import urlparse import speakeasy.winenv.arch as _arch import speakeasy.windows.netman as netman import speakeasy.winenv.defs.wininet as windefs from .. import api def is_ip_address(ip): try: inet_aton(ip) return True except Exception: return False

import sys import inspect import speakeasy.winenv.arch as _arch from speakeasy.errors import ApiEmuError from speakeasy.winenv.api import api from speakeasy.winenv.api.kernelmode import * from speakeasy.winenv.api.usermode import * def autoload_api_handlers(): api_handlers = [] for modname, modobj in sys.modules.items(): if not modname.startswith(('speakeasy.winenv.api.kernelmode.', 'speakeasy.winenv.api.usermode.')): continue for clsname, clsobj in inspect.getmembers(modobj, inspect.isclass): if clsobj is not api.ApiHandler and issubclass(clsobj, api.ApiHandler): api_handlers.append((clsobj.name, clsobj)) return tuple(api_handlers)

def get_define_int(define, prefix=''): for k, v in globals().items(): if not isinstance(v, int) or v != define: continue if prefix: if k.startswith(prefix): return k else: return k

from speakeasy.struct import EmuStruct, Ptr import ctypes as ct def get_create_disposition(flags): disp = None dispostions = ('CREATE_ALWAYS', 'CREATE_NEW', 'OPEN_ALWAYS', 'OPEN_EXISTING', 'TRUNCATE_EXISTING') for k, v in [(k, v) for k, v in globals().items() if k in dispostions]: if isinstance(v, int): if v == flags: disp = k break return disp

from speakeasy.struct import EmuStruct, Ptr import ctypes as ct def get_define(define, prefix=''): for k, v in globals().items(): if not isinstance(v, int) or v != define: continue if prefix: if k.startswith(prefix): return k else: return k

from speakeasy.struct import EmuStruct, Ptr import ctypes as ct def get_flag_defines(flags, prefix=''): def get_page_rights(define): return get_flag_defines(define, prefix='PAGE_')

from speakeasy.struct import EmuStruct, Ptr import ctypes as ct def get_flag_defines(flags, prefix=''): def get_creation_flags(flags): return get_flag_defines(flags, prefix='CREATE_')

from speakeasy.struct import EmuStruct, Ptr import ctypes as ct class SID(EmuStruct): def __init__(self, ptr_size, sub_authority_count): super().__init__(ptr_size) self.Revision = ct.c_uint8 self.SubAuthorityCount = ct.c_uint8 self.IdentifierAuthority = ct.c_uint8 * 6 self.SubAuthority = ct.c_uint32 * sub_authority_count def convert_sid_str_to_struct(ptr_size, sid_str): sid_elements = sid_str.split('-') sid_elements.remove('S') sub_authority_count = len(sid_elements) - 2 sid_struct = SID(ptr_size, sub_authority_count) sid_struct.Revision = int(sid_elements[0]) sid_struct.SubAuthorityCount = sub_authority_count sid_struct.IdentifierAuthority = int(sid_elements[1]).to_bytes(6, 'big') sub_authorities = sid_elements[2:] for i in range(len(sub_authorities)): sid_struct.SubAuthority[i] = int(sub_authorities[i]) return sid_struct

from speakeasy.struct import EmuStruct, Ptr import ctypes as ct def get_define_value(define, prefix=''): for k, v in globals().items(): if not isinstance(v, int) or k != define: continue if prefix: if k.startswith(prefix): return v else: return v

from speakeasy.struct import EmuStruct, Ptr import ctypes as ct def get_flag_defines(flags, prefix=''): defs = [] for k, v in globals().items(): if not isinstance(v, int): continue if v & flags: if prefix and k.startswith(prefix): defs.append(k) return defs

from speakeasy.struct import EmuStruct, Ptr import ctypes as ct def get_define_int(define, prefix=''): for k, v in globals().items(): if not isinstance(v, int) or v != define: continue if prefix: if k.startswith(prefix): return k else: return k

from speakeasy.struct import EmuStruct, Ptr import ctypes as ct def get_flag_defines(flags, prefix=''): defs = [] for k, v in globals().items(): if not isinstance(v, int): continue if v == flags: if prefix and k.startswith(prefix): defs.append(k) return defs def get_windowhook_flags(flags): return get_flag_defines(flags, prefix='WH_')

import uuid from speakeasy.struct import EmuStruct, Ptr def get_define_str(define, prefix=''): for k, v in globals().items(): if not isinstance(v, str) or v != define: continue if prefix: if k.startswith(prefix): return k else: return k def get_clsid(define): return get_define_str(define, prefix='CLSID_')

import uuid from speakeasy.struct import EmuStruct, Ptr def get_define_str(define, prefix=''): for k, v in globals().items(): if not isinstance(v, str) or v != define: continue if prefix: if k.startswith(prefix): return k else: return k def get_iid(define): return get_define_str(define, prefix='IID_')

import uuid from speakeasy.struct import EmuStruct, Ptr def get_define_int(define, prefix=''): for k, v in globals().items(): if not isinstance(v, int) or v != define: continue if prefix: if k.startswith(prefix): return k else: return k def get_rpc_authlevel(define): return get_define_int(define, prefix='RPC_C_AUTHN_LEVEL_')

import uuid from speakeasy.struct import EmuStruct, Ptr def get_define_int(define, prefix=''): for k, v in globals().items(): if not isinstance(v, int) or v != define: continue if prefix: if k.startswith(prefix): return k else: return k def get_rcp_implevel(define): return get_define_int(define, prefix='RPC_C_IMP_LEVEL_')

import uuid from speakeasy.struct import EmuStruct, Ptr def convert_guid_bytes_to_str(guid_bytes): u = uuid.UUID(bytes_le=guid_bytes) return ('{%s}' % u).upper()

def get_define(define, prefix=''): for k, v in globals().items(): if not isinstance(v, int) or v != define: continue if prefix: if k.startswith(prefix): return k else: return k

from speakeasy.struct import EmuStruct, Ptr import ctypes as ct MIB_IF_TYPE_ETHERNET = 6 def get_adapter_type(type_str): if type_str == 'ethernet': return MIB_IF_TYPE_ETHERNET

from speakeasy.struct import Enum def get_access_defines(flags): defs = [] accesses = ('DELETE', 'READ_CONTROL', 'WRITE_DAC', 'WRITE_OWNER', 'SYNCHRONIZE', 'GENERIC_READ', 'GENERIC_WRITE', 'GENERIC_EXECUTE', 'GENERIC_ALL') for k, v in [(k, v) for k, v in globals().items() if k in accesses]: if isinstance(v, int): if v & flags: defs.append(k) return defs

from speakeasy.struct import Enum def get_flag_defines(flags, prefix=''): defs = [] for k, v in globals().items(): if isinstance(v, int): if v & flags: if prefix: if k.startswith(prefix): defs.append(k) else: defs.append(k) return defs def get_file_access_defines(flags): defs = get_flag_defines(flags, 'FILE_') defs = [d for d in defs if d.startswith(('FILE_READ', 'FILE_WRITE', 'FILE_DELETE', 'FILE_APPEND', 'FILE_EXECUTE'))] return defs

from speakeasy.struct import Enum def get_const_defines(const, prefix=''): defs = [] for k, v in globals().items(): if isinstance(v, int): if v == const: if prefix: if k.startswith(prefix): defs.append(k) else: defs.append(k) return defs def get_create_disposition(disp): defs = get_const_defines(disp, 'FILE_') defs = [d for d in defs if not d.startswith('FILE_SHARE')] ret = 0 if len(defs): ret = defs[0] return ret

import ctypes as ct from speakeasy.struct import EmuStruct, Ptr def get_const_defines(flags, prefix=''): def get_flag_defines(flags): return get_const_defines(flags, prefix='INTERNET_FLAG')

import ctypes as ct from speakeasy.struct import EmuStruct, Ptr def get_option_define(opt): for k, v in globals().items(): if k.startswith('INTERNET_OPTION_') and v == opt: return k

import ctypes as ct from speakeasy.struct import EmuStruct, Ptr def get_const_defines(flags, prefix=''): defs = [] for k, v in globals().items(): if isinstance(v, int): if v & flags: if prefix: if k.startswith(prefix): defs.append(k) else: defs.append(k) return defs def get_header_info_winhttp(flags): return get_const_defines(flags, prefix='WINHTTP_ADDREQ_')

import ctypes as ct from speakeasy.struct import EmuStruct, Ptr def get_header_query(opt): for k, v in globals().items(): if k.startswith('WINHTTP_QUERY_') and v == opt: return k

from speakeasy.struct import EmuStruct, Enum import ctypes as ct def get_flag_value(flag): return globals().get(flag)

from speakeasy.struct import EmuStruct, Enum import ctypes as ct def get_defines(define, prefix=''): for k, v in globals().items(): if not isinstance(v, int) or v != define: continue if prefix: if k.startswith(prefix): return k else: return k def get_value_type(define): return get_defines(define, prefix='REG_')

from speakeasy.struct import EmuStruct, Enum import ctypes as ct def get_defines(define, prefix=''): for k, v in globals().items(): if not isinstance(v, int) or v != define: continue if prefix: if k.startswith(prefix): return k else: return k def get_hkey_type(define): return get_defines(define, prefix='HKEY_')

def get_flag_defines(flags, prefix=''): defs = [] for k, v in globals().items(): if not isinstance(v, int): continue if v & flags: if prefix and k.startswith(prefix): defs.append(k) return defs

def get_define(define, prefix=''): def get_addr_family(define): return get_define(define, prefix='AF_')

def get_define(define, prefix=''): for k, v in globals().items(): if not isinstance(v, int) or v != define: continue if prefix: if k.startswith(prefix): return k else: return k def get_sock_type(define): return get_define(define, prefix='SOCK_')

def get_define(define, prefix=''): for k, v in globals().items(): if not isinstance(v, int) or v != define: continue if prefix: if k.startswith(prefix): return k else: return k def get_proto_type(define): return get_define(define, prefix='IPPROTO_')

import os import sys import cmd import shlex import fnmatch import logging import binascii import argparse import traceback import hexdump import speakeasy import speakeasy.winenv.arch as e_arch from speakeasy.errors import SpeakeasyError The provided code snippet includes necessary dependencies for implementing the `get_logger` function. Write a Python function `def get_logger()` to solve the following problem: Get the default logger for speakeasy Here is the function: def get_logger(): """ Get the default logger for speakeasy """ logger = logging.getLogger('sedbg') if not logger.handlers: sh = logging.StreamHandler() logger.addHandler(sh) logger.setLevel(logging.INFO) return logger

Get the default logger for speakeasy