dataeval 0.73.1__py3-none-any.whl → 0.74.1__py3-none-any.whl

dataeval/utils/tensorflow/_internal/trainer.py

@@ -1,114 +0,0 @@
-"""
-Source code derived from Alibi-Detect 0.11.4
-https://github.com/SeldonIO/alibi-detect/tree/v0.11.4
-
-Original code Copyright (c) 2023 Seldon Technologies Ltd
-Licensed under Apache Software License (Apache 2.0)
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Callable, Iterable, cast
-
-import numpy as np
-from numpy.typing import NDArray
-
-from dataeval.utils.lazy import lazyload
-
-if TYPE_CHECKING:
-    import tensorflow as tf
-    import tf_keras as keras
-else:
-    tf = lazyload("tensorflow")
-    keras = lazyload("tf_keras")
-
-
-def trainer(
-    model: keras.Model,
-    x_train: NDArray,
-    y_train: NDArray | None = None,
-    loss_fn: Callable[..., tf.Tensor] | None = None,
-    optimizer: keras.optimizers.Optimizer | None = None,
-    preprocess_fn: Callable[[tf.Tensor], tf.Tensor] | None = None,
-    epochs: int = 20,
-    reg_loss_fn: Callable[[keras.Model], tf.Tensor] = (lambda _: cast(tf.Tensor, tf.Variable(0, dtype=tf.float32))),
-    batch_size: int = 64,
-    buffer_size: int = 1024,
-    verbose: bool = True,
-) -> None:
-    """
-    Train TensorFlow model.
-
-    Parameters
-    ----------
-    model
-        Model to train.
-    loss_fn
-        Loss function used for training.
-    x_train
-        Training data.
-    y_train
-        Training labels.
-    optimizer
-        Optimizer used for training.
-    preprocess_fn
-        Preprocessing function applied to each training batch.
-    epochs
-        Number of training epochs.
-    reg_loss_fn
-        Allows an additional regularisation term to be defined as reg_loss_fn(model)
-    batch_size
-        Batch size used for training.
-    buffer_size
-        Maximum number of elements that will be buffered when prefetching.
-    verbose
-        Whether to print training progress.
-    """
-    loss_fn = loss_fn() if isinstance(loss_fn, type) else loss_fn
-    optimizer = keras.optimizers.Adam() if optimizer is None else optimizer
-
-    train_data = (
-        x_train.astype(np.float32) if y_train is None else (x_train.astype(np.float32), y_train.astype(np.float32))
-    )
-    dataset = tf.data.Dataset.from_tensor_slices(train_data)
-    dataset = dataset.shuffle(buffer_size=buffer_size).batch(batch_size)
-    n_minibatch = len(dataset)
-
-    # iterate over epochs
-    for epoch in range(epochs):
-        pbar = keras.utils.Progbar(n_minibatch, 1) if verbose else None
-        if hasattr(dataset, "on_epoch_end"):
-            dataset.on_epoch_end()  # type: ignore py39
-        loss_val_ma = 0.0
-        for step, data in enumerate(dataset):
-            x, y = data if isinstance(data, tuple) else (data, None)
-            if isinstance(preprocess_fn, Callable):
-                x = preprocess_fn(x)
-            with tf.GradientTape() as tape:
-                y_hat = model(x)
-                y = x if y is None else y
-                if isinstance(loss_fn, Callable):
-                    args = [y] + list(y_hat) if isinstance(y_hat, tuple) else [y, y_hat]
-                    loss = loss_fn(*args)
-                else:
-                    loss = cast(tf.Tensor, tf.constant(0.0, dtype=tf.float32))
-                if model.losses:  # additional model losses
-                    loss = cast(tf.Tensor, tf.add(sum(model.losses), loss))
-                loss = cast(tf.Tensor, tf.add(reg_loss_fn(model), loss))  # alternative way they might be specified
-
-            grads = cast(Iterable, tape.gradient(loss, model.trainable_weights))
-            optimizer.apply_gradients(zip(grads, model.trainable_weights))
-            if pbar is not None:
-                loss_val = getattr(loss, "numpy")() if hasattr(loss, "numpy") else np.float32(0.0)
-                if loss_val.shape and loss_val.shape[0] != batch_size:
-                    if len(loss_val.shape) == 1:
-                        shape = (batch_size - loss_val.shape[0],)
-                    elif len(loss_val.shape) == 2:
-                        shape = (batch_size - loss_val.shape[0], loss_val.shape[1])
-                    else:
-                        continue
-                    add_mean = np.ones(shape) * loss_val.mean()
-                    loss_val = np.r_[loss_val, add_mean]
-                loss_val_ma = loss_val_ma + (loss_val - loss_val_ma) / (step + 1)
-                pbar_values = [("loss_ma", loss_val_ma)]
-                pbar.add(1, values=pbar_values)

dataeval/utils/tensorflow/_internal/utils.py

@@ -1,256 +0,0 @@
-"""
-Source code derived from Alibi-Detect 0.11.4
-https://github.com/SeldonIO/alibi-detect/tree/v0.11.4
-
-Original code Copyright (c) 2023 Seldon Technologies Ltd
-Licensed under Apache Software License (Apache 2.0)
-"""
-
-from __future__ import annotations
-
-import math
-from typing import TYPE_CHECKING, Any, Callable, Literal, Union, cast
-
-import numpy as np
-from numpy.typing import NDArray
-
-from dataeval.utils.lazy import lazyload
-
-if TYPE_CHECKING:
-    import tensorflow as tf
-    import tensorflow._api.v2.nn as nn
-    import tf_keras as keras
-
-    import dataeval.utils.tensorflow._internal.models as tf_models
-else:
-    tf = lazyload("tensorflow")
-    nn = lazyload("tensorflow._api.v2.nn")
-    keras = lazyload("tf_keras")
-    tf_models = lazyload("dataeval.utils.tensorflow._internal.models")
-
-
-def predict_batch(
-    x: list | NDArray | tf.Tensor,
-    model: Callable | keras.Model,
-    batch_size: int = int(1e10),
-    preprocess_fn: Callable | None = None,
-    dtype: type[np.generic] | tf.DType = np.float32,
-) -> NDArray | tf.Tensor | tuple | list:
-    """
-    Make batch predictions on a model.
-
-    Parameters
-    ----------
-    x
-        Batch of instances.
-    model
-        tf.keras model or one of the other permitted types defined in Data.
-    batch_size
-        Batch size used during prediction.
-    preprocess_fn
-        Optional preprocessing function for each batch.
-    dtype
-        Model output type, e.g. np.float32 or tf.float32.
-
-    Returns
-    -------
-    :term:`NumPy` array, tensorflow tensor or tuples of those with model outputs.
-    """
-    n = len(x)
-    n_minibatch = int(np.ceil(n / batch_size))
-    return_np = not isinstance(dtype, tf.DType)
-    return_list = False
-    preds: list | tuple = []
-    for i in range(n_minibatch):
-        istart, istop = i * batch_size, min((i + 1) * batch_size, n)
-        x_batch = x[istart:istop]  # type: ignore
-        if isinstance(preprocess_fn, Callable):  # type: ignore
-            x_batch = preprocess_fn(x_batch)
-        preds_tmp = model(x_batch)
-        if isinstance(preds_tmp, (list, tuple)):
-            if len(preds) == 0:  # init tuple with lists to store predictions
-                preds = tuple([] for _ in range(len(preds_tmp)))
-                return_list = isinstance(preds_tmp, list)
-            for j, p in enumerate(preds_tmp):
-                preds[j].append(p if not return_np or isinstance(p, np.ndarray) else p.numpy())
-        elif isinstance(preds_tmp, (np.ndarray, tf.Tensor)):
-            preds.append(  # type: ignore
-                preds_tmp
-                if not return_np or isinstance(preds_tmp, np.ndarray)  # type: ignore
-                else preds_tmp.numpy()  # type: ignore
-            )
-        else:
-            raise TypeError(
-                f"Model output type {type(preds_tmp)} not supported. The model output "
-                f"type needs to be one of list, tuple, NDArray or tf.Tensor."
-            )
-    concat = np.concatenate if return_np else tf.concat
-    out = cast(
-        Union[tuple, tf.Tensor, np.ndarray],
-        tuple(concat(p, axis=0) for p in preds) if isinstance(preds, tuple) else concat(preds, axis=0),
-    )
-    if return_list:
-        out = list(out)
-    return out
-
-
-def get_default_encoder_net(input_shape: tuple[int, int, int], encoding_dim: int):
-    return keras.Sequential(
-        [
-            keras.layers.InputLayer(input_shape=input_shape),
-            keras.layers.Conv2D(64, 4, strides=2, padding="same", activation=nn.relu),
-            keras.layers.Conv2D(128, 4, strides=2, padding="same", activation=nn.relu),
-            keras.layers.Conv2D(512, 4, strides=2, padding="same", activation=nn.relu),
-            keras.layers.Flatten(),
-            keras.layers.Dense(encoding_dim),
-        ]
-    )
-
-
-def get_default_decoder_net(input_shape: tuple[int, int, int], encoding_dim: int):
-    return keras.Sequential(
-        [
-            keras.layers.InputLayer(input_shape=(encoding_dim,)),
-            keras.layers.Dense(4 * 4 * 128),
-            keras.layers.Reshape(target_shape=(4, 4, 128)),
-            keras.layers.Conv2DTranspose(256, 4, strides=2, padding="same", activation=nn.relu),
-            keras.layers.Conv2DTranspose(64, 4, strides=2, padding="same", activation=nn.relu),
-            keras.layers.Flatten(),
-            keras.layers.Dense(math.prod(input_shape)),
-            keras.layers.Reshape(target_shape=input_shape),
-        ]
-    )
-
-
-def create_model(
-    model_type: Literal["AE", "AEGMM", "PixelCNN", "VAE", "VAEGMM"],
-    input_shape: tuple[int, int, int],
-    encoding_dim: int | None = None,
-    n_gmm: int | None = None,
-    gmm_latent_dim: int | None = None,
-) -> Any:
-    """
-    Create a default model for the specified model type.
-
-    Parameters
-    ----------
-    model_type : Literal["AE", "AEGMM", "PixelCNN", "VAE", "VAEGMM"]
-        The model type to create.
-    input_shape : Tuple[int, int, int]
-        The input shape of the data used.
-    encoding_dim : int, optional - default None
-        The target encoding dimensionality.
-    n_gmm : int, optional - default None
-        Number of components used in the GMM layer.
-    gmm_latent_dim : int, optional - default None
-        Latent dimensionality of the GMM layer.
-    """
-    input_dim = math.prod(input_shape)
-    encoding_dim = int(math.pow(2, int(input_dim.bit_length() * 0.8)) if encoding_dim is None else encoding_dim)
-    if model_type == "AE":
-        return tf_models.AE(
-            get_default_encoder_net(input_shape, encoding_dim),
-            get_default_decoder_net(input_shape, encoding_dim),
-        )
-
-    if model_type == "VAE":
-        return tf_models.VAE(
-            get_default_encoder_net(input_shape, encoding_dim),
-            get_default_decoder_net(input_shape, encoding_dim),
-            encoding_dim,
-        )
-
-    if model_type == "AEGMM":
-        n_gmm = 2 if n_gmm is None else n_gmm
-        gmm_latent_dim = 1 if gmm_latent_dim is None else gmm_latent_dim
-        # The outlier detector is an encoder/decoder architecture
-        encoder_net = keras.Sequential(
-            [
-                keras.layers.Flatten(),
-                keras.layers.InputLayer(input_shape=(input_dim,)),
-                keras.layers.Dense(60, activation=nn.tanh),
-                keras.layers.Dense(30, activation=nn.tanh),
-                keras.layers.Dense(10, activation=nn.tanh),
-                keras.layers.Dense(gmm_latent_dim, activation=None),
-            ]
-        )
-        # Here we define the decoder
-        decoder_net = keras.Sequential(
-            [
-                keras.layers.InputLayer(input_shape=(gmm_latent_dim,)),
-                keras.layers.Dense(10, activation=nn.tanh),
-                keras.layers.Dense(30, activation=nn.tanh),
-                keras.layers.Dense(60, activation=nn.tanh),
-                keras.layers.Dense(input_dim, activation=None),
-                keras.layers.Reshape(target_shape=input_shape),
-            ]
-        )
-        # GMM autoencoders have a density network too
-        gmm_density_net = keras.Sequential(
-            [
-                keras.layers.InputLayer(input_shape=(gmm_latent_dim + 2,)),
-                keras.layers.Dense(10, activation=nn.tanh),
-                keras.layers.Dense(n_gmm, activation=nn.softmax),
-            ]
-        )
-        return tf_models.AEGMM(
-            encoder_net=encoder_net,
-            decoder_net=decoder_net,
-            gmm_density_net=gmm_density_net,
-            n_gmm=n_gmm,
-        )
-
-    if model_type == "VAEGMM":
-        n_gmm = 2 if n_gmm is None else n_gmm
-        gmm_latent_dim = 2 if gmm_latent_dim is None else gmm_latent_dim
-        # The outlier detector is an encoder/decoder architecture
-        # Here we define the encoder
-        encoder_net = keras.Sequential(
-            [
-                keras.layers.Flatten(),
-                keras.layers.InputLayer(input_shape=(input_dim,)),
-                keras.layers.Dense(20, activation=nn.relu),
-                keras.layers.Dense(15, activation=nn.relu),
-                keras.layers.Dense(7, activation=nn.relu),
-            ]
-        )
-        # Here we define the decoder
-        decoder_net = keras.Sequential(
-            [
-                keras.layers.InputLayer(input_shape=(gmm_latent_dim,)),
-                keras.layers.Dense(7, activation=nn.relu),
-                keras.layers.Dense(15, activation=nn.relu),
-                keras.layers.Dense(20, activation=nn.relu),
-                keras.layers.Dense(input_dim, activation=None),
-                keras.layers.Reshape(target_shape=input_shape),
-            ]
-        )
-        # GMM autoencoders have a density network too
-        gmm_density_net = keras.Sequential(
-            [
-                keras.layers.InputLayer(input_shape=(gmm_latent_dim + 2,)),
-                keras.layers.Dense(10, activation=nn.relu),
-                keras.layers.Dense(n_gmm, activation=nn.softmax),
-            ]
-        )
-        return tf_models.VAEGMM(
-            encoder_net=encoder_net,
-            decoder_net=decoder_net,
-            gmm_density_net=gmm_density_net,
-            n_gmm=n_gmm,
-            latent_dim=gmm_latent_dim,
-        )
-
-    if model_type == "PixelCNN":
-        return tf_models.PixelCNN(
-            image_shape=input_shape,
-            num_resnet=5,
-            num_hierarchies=2,
-            num_filters=32,
-            num_logistic_mix=1,
-            receptive_field_dims=(3, 3),
-            dropout_p=0.3,
-            l2_weight=0.0,
-        )
-
-    raise TypeError(f"Unknown model specified: {model_type}.")

dataeval/utils/tensorflow/loss/__init__.py

@@ -1,11 +0,0 @@
-from dataeval import _IS_TENSORFLOW_AVAILABLE
-
-__all__ = []
-
-
-if _IS_TENSORFLOW_AVAILABLE:
-    from dataeval.utils.tensorflow._internal.loss import Elbo, LossGMM
-
-    __all__ = ["Elbo", "LossGMM"]
-
-del _IS_TENSORFLOW_AVAILABLE

dataeval-0.73.1.dist-info/RECORD

@@ -1,73 +0,0 @@
-dataeval/__init__.py,sha256=SdXxst_wmjSoQkYzGdR-JXSV-iJmKynWsiwkpmGDDPE,601
-dataeval/detectors/__init__.py,sha256=mwAyY54Hvp6N4D57cde3_besOinK8jVF43k0Mw4XZi8,363
-dataeval/detectors/drift/__init__.py,sha256=BSXm21y7cAawHep-ZldCJ5HOvzYjPzYGKGrmoEs3i0E,737
-dataeval/detectors/drift/base.py,sha256=xwI6C-PEH0ZjpSqP6No6WDZp42DnE16OHi_mXe2JSvI,14499
-dataeval/detectors/drift/cvm.py,sha256=kc59w2_wtxFGNnLcaJRvX5v_38gPXiebSGNiFVdunEQ,4142
-dataeval/detectors/drift/ks.py,sha256=gcpe1WIQeNeZdLYkdMZCFLXUp1bHMQUxwJE6-RLVOXs,4229
-dataeval/detectors/drift/mmd.py,sha256=TqGOnUNYKwpS0GQPV3dSl-_qRa0g2flmoQ-dxzW_JfY,7586
-dataeval/detectors/drift/torch.py,sha256=D46J72OPW8-PpP3w9ODMBfcDSdailIgVjgHVFpbYfws,11649
-dataeval/detectors/drift/uncertainty.py,sha256=Xz2yzJjtJfw1vLag234jwRvaa_HK36nMajGx8bQaNRs,5322
-dataeval/detectors/drift/updates.py,sha256=UJ0z5hlunRi7twnkLABfdJG3tT2EqX4y9IGx8_USYvo,1780
-dataeval/detectors/linters/__init__.py,sha256=BvpaB1RUpkEhhXk3Mqi5NYoOcJKZRFSBOJCmQOIfYRU,483
-dataeval/detectors/linters/clusterer.py,sha256=sau5A9YcQ6VDjbZGOIaCaRHW_63opaA31pqHo5Rm-hQ,21018
-dataeval/detectors/linters/duplicates.py,sha256=tOD43rJkvheIA3mznbUqHhft2yD3xRZQdCt61daIca4,5665
-dataeval/detectors/linters/merged_stats.py,sha256=X-bDTwjyR8RuVmzxLaHZmQ5nI3oOWvsqVlitdSncapk,1355
-dataeval/detectors/linters/outliers.py,sha256=BUVvtbKHo04KnRmrgb84MBr0l1gtcY3-xNCHjetFrEQ,10117
-dataeval/detectors/ood/__init__.py,sha256=yzvCszJ0KrX9Eu4S_ykC_jwC0uYGPjxY3Vyx9fU3zQk,641
-dataeval/detectors/ood/ae.py,sha256=XQ_rCsf0VWg_2YXt33XGe6ZgxEud1PfIl7TmBVP1GkM,2347
-dataeval/detectors/ood/aegmm.py,sha256=6UKv0uJYWAzu1F-cITFGly4w9y_t7wqg3OmVyCN365o,2041
-dataeval/detectors/ood/base.py,sha256=a_d52pJMWVmduSt8OvUWYwHE8mpCaI6pIAE4_ib_GOs,8841
-dataeval/detectors/ood/llr.py,sha256=TwUk1RsZhnM5tUssGVMBhWggCW2izs_Asy9QPHkTJaU,10615
-dataeval/detectors/ood/metadata_ks_compare.py,sha256=jH7uDwyyBIIcTrRhQEdnLAdrwf7LfNczKBw0CpJyF5c,4282
-dataeval/detectors/ood/metadata_least_likely.py,sha256=nxMCXUOjOfWHDTGT2SLE7OYBCydRq8zHLd8t17k7hMM,5193
-dataeval/detectors/ood/metadata_ood_mi.py,sha256=KLay2BmgHrStBV92VpIs_B1yEfQKllsMTgzOQEng01I,4065
-dataeval/detectors/ood/vae.py,sha256=UKrQNFdHcnxAY0fAFbLrXasY8Z6qg138BXxqwc1hlts,3154
-dataeval/detectors/ood/vaegmm.py,sha256=_wwmT37URs0MyhbORk91XJExClv-4e15LH_Bj60Pw1w,2409
-dataeval/interop.py,sha256=TZCkZo844DvzHoxuRo-YsBhT6GvKmyQTHtUEQZPly1M,1728
-dataeval/metrics/__init__.py,sha256=fPBNLd-T6mCErZBBJrxWmXIL0jCk7fNUYIcNEBkMa80,238
-dataeval/metrics/bias/__init__.py,sha256=puf645-hAO5hFHNHlZ239TPopqWIoN-uLGXFB8-hA_o,599
-dataeval/metrics/bias/balance.py,sha256=n4SM2Z46dzps_SPgHV8Q69msZ507AP9neebsQ45cNxc,9170
-dataeval/metrics/bias/coverage.py,sha256=7nDufCmQwZ8QG3Me5UiY0N5YoTByjcwK2zOYuMOHkJ0,4540
-dataeval/metrics/bias/diversity.py,sha256=BKGpyJ1K3S5RS_VxXN5DusB2gfRidOksL7r0L3SFa0Y,11018
-dataeval/metrics/bias/metadata.py,sha256=tPvyfFkfqWBFMX6v8i1ZLAA3DZfF6M4O7qXDdKzhQ6g,15040
-dataeval/metrics/bias/parity.py,sha256=_-WdKRWPlKHLNbjq-4mIhVdR1MI3NEabbMWblAmmVRM,17145
-dataeval/metrics/estimators/__init__.py,sha256=O6ocxJq8XDkfJWwXeJnnnzbOyRnFPKF4kTIVTTZYOA8,380
-dataeval/metrics/estimators/ber.py,sha256=SVT-BIC_GLs0l2l2NhWu4OpRbgn96w-OwTSoPHTnQbE,5037
-dataeval/metrics/estimators/divergence.py,sha256=pImaa216-YYTgGWDCSTcpJrC-dfl7150yVrPfW_TyGc,4293
-dataeval/metrics/estimators/uap.py,sha256=Tz1VZOyUa68HlTh94Rl-wnXCWdTAVjTQc3LtSPEWVu4,2175
-dataeval/metrics/stats/__init__.py,sha256=igLRaAt1nX6yRwC4xI0zNPBADi3u7EsSxWP3OZ8AqcU,1086
-dataeval/metrics/stats/base.py,sha256=9M5g2FAWvd50HT-T2h-MCmYLpvk--em_yWro1qWGHFs,12177
-dataeval/metrics/stats/boxratiostats.py,sha256=iNr-FdppiJ7XAeeLY-o7gL_PSxvT8j86iwRijKca2Eg,6465
-dataeval/metrics/stats/datasetstats.py,sha256=LAMFCIS9v0RjLrdKUFuo8nY-3HLVvRlqQIXGMKtsHEw,6255
-dataeval/metrics/stats/dimensionstats.py,sha256=xdTp2AbGH3xefUUsB4sDjgSKiojJ73DCHyuCOPKsErc,4056
-dataeval/metrics/stats/hashstats.py,sha256=X6aSouaMhDcGZMLuCTje3G4QOr2i-Td6H3SyBFDF6mA,4960
-dataeval/metrics/stats/labelstats.py,sha256=BKwSmyxCr2wYq8IMraCUS-b5wqacfT_BukJUYNfqeCo,4114
-dataeval/metrics/stats/pixelstats.py,sha256=x90O10IqVjEORtYwueFLvJnVYTxhPBOOx5HMweBQnJY,4578
-dataeval/metrics/stats/visualstats.py,sha256=y0xIvst7epcajk8vz2jngiAiz0T7DZC-M97Rs1-vV9I,4950
-dataeval/output.py,sha256=jWXXNxFNBEaY1rN7Z-6LZl6bQT-I7z_wqr91Rhrdt_0,3061
-dataeval/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataeval/utils/__init__.py,sha256=FZLWDA7nMbHOcdg3701cVJpQmUp1Wxxk8h_qIrUQQjY,713
-dataeval/utils/image.py,sha256=KgC_1nW__nGN5q6bVZNvG4U_qIBdjcPATz9qe8f2XuA,1928
-dataeval/utils/lazy.py,sha256=M0iBHuJh4UPrSJPHZ0jhFwRSZhyjHJQx_KEf1OCkHD8,588
-dataeval/utils/metadata.py,sha256=A6VN7KbdiOA6rUQvUGKwDcvtOyjBer8bRW_wFxNhmW0,8556
-dataeval/utils/shared.py,sha256=xvF3VLfyheVwJtdtDrneOobkKf7t-JTmf_w91FWXmqo,3616
-dataeval/utils/split_dataset.py,sha256=Ot1ZJhbIhVfcShYXF9MkWXak5odBXyuBdRh-noXh-MI,19555
-dataeval/utils/tensorflow/__init__.py,sha256=l4OjIA75JJXeNWDCkST1xtDMVYsw97lZ-9JXFBlyuYg,539
-dataeval/utils/tensorflow/_internal/gmm.py,sha256=RIFx8asEpi2kMf8JVzq9M3aAvNe9fjpJPf3BzWE-aeE,3787
-dataeval/utils/tensorflow/_internal/loss.py,sha256=TFhoNPgqeJtdpIHYobZPyzMpeWjzlFqzu5LCtthEUi4,4463
-dataeval/utils/tensorflow/_internal/models.py,sha256=TzQYRrFe5XomhnPw05v-HBODQdFIqWg21WH1xS0XBlg,59868
-dataeval/utils/tensorflow/_internal/trainer.py,sha256=uBFTnAy9o2T_FoT3RSX-AA7T-2FScyOdYEg9_7Dpd28,4314
-dataeval/utils/tensorflow/_internal/utils.py,sha256=lr5hKkAPbjMCUNIzMUIqbEddwbWQfMdL6hcazTHU3Uc,9541
-dataeval/utils/tensorflow/loss/__init__.py,sha256=Q-66vt91Oe1ByYfo28tW32zXDq2MqQ2gngWgmIVmof8,227
-dataeval/utils/torch/__init__.py,sha256=lpkqfgyARUxgrV94cZESQv8PIP2p-UnwItZ_wIr0XzQ,675
-dataeval/utils/torch/blocks.py,sha256=HVhBTMMD5NA4qheMUgyol1KWiKZDIuc8k5j4RcMKmhk,1466
-dataeval/utils/torch/datasets.py,sha256=10elNgLuH_FDX_CHE3y2Z215JN4-PQovQm5brcIJOeM,15021
-dataeval/utils/torch/models.py,sha256=0BsXmLK8W1OZ8nnEGb1f9LzIeCgtevQC37dvKS1v1vA,3236
-dataeval/utils/torch/trainer.py,sha256=EraOKiXxiMNiycStZNMR5yRz3ehgp87d9ewR9a9dV4w,5559
-dataeval/utils/torch/utils.py,sha256=FI4LJ6DvXFQJVff8fxSCP7LRkp8H9BIUgYX0kk7_Cuo,1537
-dataeval/workflows/__init__.py,sha256=ef1MiVL5IuhlDXXbwsiAfafhnr7tD3TXF9GRusy9_O8,290
-dataeval/workflows/sufficiency.py,sha256=1jSYhH9i4oesmJYs5PZvWS1LGXf8ekOgNhpFtMPLPXk,18552
-dataeval-0.73.1.dist-info/LICENSE.txt,sha256=Kpzcfobf1HlqafF-EX6dQLw9TlJiaJzfgvLQFukyXYw,1060
-dataeval-0.73.1.dist-info/METADATA,sha256=C7xThIWgHNoZEdSiGEZr3VgDLRSzeT3TkFbn4nQgrK0,4714
-dataeval-0.73.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-dataeval-0.73.1.dist-info/RECORD,,