torch-rechub 0.0.6__py3-none-any.whl → 0.1.0__py3-none-any.whl

torch_rechub/utils/onnx_export.py

@@ -12,6 +12,7 @@ References:
 Authors: Torch-RecHub Contributors
 """
 
+import inspect
 import os
 import warnings
 from typing import Any, Dict, List, Optional, Tuple, Union
@@ -23,19 +24,24 @@ from ..basic.features import DenseFeature, SequenceFeature, SparseFeature
 
 
 class ONNXWrapper(nn.Module):
-    """Wraps a dict-input model to accept positional arguments for ONNX compatibility.
-
-    ONNX does not support dict as input, so this wrapper converts positional arguments
-    back to dict format before passing to the original model.
-
-    Args:
-        model: The original PyTorch model that accepts dict input.
-        input_names: Ordered list of feature names corresponding to input positions.
-        mode: Optional mode for dual-tower models ("user" or "item").
-
-    Example:
-        >>> wrapper = ONNXWrapper(dssm_model, ["user_id", "movie_id", "hist_movie_id"])
-        >>> # Now can call: wrapper(user_id_tensor, movie_id_tensor, hist_tensor)
+    """Wrap a dict-input model to accept positional args for ONNX.
+
+    ONNX disallows dict inputs; this wrapper maps positional args back to dict
+    before calling the original model.
+
+    Parameters
+    ----------
+    model : nn.Module
+        Original dict-input model.
+    input_names : list[str]
+        Ordered feature names matching positional inputs.
+    mode : {'user', 'item'}, optional
+        For dual-tower models, set tower mode.
+
+    Examples
+    --------
+    >>> wrapper = ONNXWrapper(dssm_model, ["user_id", "movie_id", "hist_movie_id"])
+    >>> wrapper(user_id_tensor, movie_id_tensor, hist_tensor)
     """
 
     def __init__(self, model: nn.Module, input_names: List[str], mode: Optional[str] = None):
@@ -102,27 +108,49 @@ class ONNXExporter:
         seq_length: int = 10,
         opset_version: int = 14,
         dynamic_batch: bool = True,
-        verbose: bool = False
+        verbose: bool = False,
+        onnx_export_kwargs: Optional[Dict[str,
+                                          Any]] = None,
     ) -> bool:
-        """Export the model to ONNX format.
-
-        Args:
-            output_path: Path to save the ONNX model.
-            mode: For dual-tower models, specify "user" or "item" to export
-                  only that tower. None exports the full model.
-            dummy_input: Optional dict of example inputs. If not provided,
-                         dummy inputs will be generated automatically.
-            batch_size: Batch size for generated dummy input (default: 2).
-            seq_length: Sequence length for SequenceFeature (default: 10).
-            opset_version: ONNX opset version (default: 14).
-            dynamic_batch: Whether to enable dynamic batch size (default: True).
-            verbose: Whether to print export details (default: False).
-
-        Returns:
-            True if export succeeded, False otherwise.
-
-        Raises:
-            RuntimeError: If ONNX export fails.
+        """Export model to ONNX format.
+
+        Parameters
+        ----------
+        output_path : str
+            Destination path.
+        mode : {'user', 'item'}, optional
+            For dual-tower, export specific tower; None exports full model.
+        dummy_input : dict[str, Tensor], optional
+            Example inputs; auto-generated if None.
+        batch_size : int, default=2
+            Batch size for dummy input generation.
+        seq_length : int, default=10
+            Sequence length for SequenceFeature.
+        opset_version : int, default=14
+            ONNX opset.
+        dynamic_batch : bool, default=True
+            Enable dynamic batch axes.
+        verbose : bool, default=False
+            Print export details.
+        onnx_export_kwargs : dict, optional
+            Extra keyword args forwarded to ``torch.onnx.export`` (e.g. ``operator_export_type``,
+            ``keep_initializers_as_inputs``, ``do_constant_folding``).
+            Notes:
+              - If you pass keys that overlap with the explicit parameters above
+                (like ``opset_version`` / ``dynamic_axes`` / ``input_names``), this function
+                will raise a ``ValueError`` to avoid ambiguous behavior.
+              - Some kwargs (like ``dynamo``) are only available in newer PyTorch; unsupported
+                keys will be ignored for compatibility.
+
+        Returns
+        -------
+        bool
+            True if export succeeds.
+
+        Raises
+        ------
+        RuntimeError
+            If ONNX export fails.
         """
         self.model.eval()
         self.model.to(self.device)
@@ -164,18 +192,43 @@ class ONNXExporter:
 
         try:
             with torch.no_grad():
-                torch.onnx.export(
-                    wrapper,
-                    dummy_tuple,
-                    output_path,
-                    input_names=input_names,
-                    output_names=["output"],
-                    dynamic_axes=dynamic_axes,
-                    opset_version=opset_version,
-                    do_constant_folding=True,
-                    verbose=verbose,
-                    dynamo=False  # Use legacy exporter for dynamic_axes support
-                )
+                export_kwargs: Dict[str,
+                                    Any] = {
+                                        "f": output_path,
+                                        "input_names": input_names,
+                                        "output_names": ["output"],
+                                        "dynamic_axes": dynamic_axes,
+                                        "opset_version": opset_version,
+                                        "do_constant_folding": True,
+                                        "verbose": verbose,
+                                    }
+
+                if onnx_export_kwargs:
+                    # Prevent silent conflicts with explicit arguments
+                    overlap = set(export_kwargs.keys()) & set(onnx_export_kwargs.keys())
+                    # allow user to set 'dynamo' even if we inject it later
+                    overlap.discard("dynamo")
+                    if overlap:
+                        raise ValueError("onnx_export_kwargs contains keys that overlap with explicit args: "
+                                         f"{sorted(overlap)}. Please set them via export() parameters instead.")
+                    export_kwargs.update(onnx_export_kwargs)
+
+                # Auto-pick exporter:
+                # - When dynamic axes are requested, prefer legacy exporter (dynamo=False),
+                #   because the dynamo exporter may not honor `dynamic_axes` consistently
+                #   across torch versions.
+                # - When no dynamic axes are requested, prefer dynamo exporter (dynamo=True)
+                #   for better operator coverage in newer torch.
+                #
+                # In older torch versions, 'dynamo' kwarg does not exist.
+                sig = inspect.signature(torch.onnx.export)
+                if "dynamo" in sig.parameters:
+                    if "dynamo" not in export_kwargs:
+                        export_kwargs["dynamo"] = False if dynamic_axes is not None else True
+                else:
+                    export_kwargs.pop("dynamo", None)
+
+                torch.onnx.export(wrapper, dummy_tuple, **export_kwargs)
 
             if verbose:
                 print(f"Successfully exported ONNX model to: {output_path}")

torch_rechub/utils/quantization.py

@@ -0,0 +1,128 @@
+"""
+ONNX Quantization Utilities.
+
+This module provides a lightweight API to quantize exported ONNX models:
+- INT8 dynamic quantization (recommended for MLP-heavy rec models on CPU)
+- FP16 conversion (recommended for GPU inference)
+
+The functions are optional-dependency friendly:
+- INT8 quantization requires: onnxruntime
+- FP16 conversion requires: onnx + onnxconverter-common
+"""
+
+from __future__ import annotations
+
+import inspect
+import os
+from typing import Any, Dict, Optional
+
+
+def _ensure_parent_dir(path: str) -> None:
+    parent = os.path.dirname(os.path.abspath(path))
+    if parent and not os.path.exists(parent):
+        os.makedirs(parent, exist_ok=True)
+
+
+def quantize_model(
+    input_path: str,
+    output_path: str,
+    mode: str = "int8",
+    *,
+    # INT8(dynamic) params
+    per_channel: bool = False,
+    reduce_range: bool = False,
+    weight_type: str = "qint8",
+    optimize_model: bool = False,
+    op_types_to_quantize: Optional[list[str]] = None,
+    nodes_to_quantize: Optional[list[str]] = None,
+    nodes_to_exclude: Optional[list[str]] = None,
+    extra_options: Optional[Dict[str,
+                                 Any]] = None,
+    # FP16 params
+    keep_io_types: bool = True,
+) -> str:
+    """Quantize an ONNX model.
+
+    Parameters
+    ----------
+    input_path : str
+        Input ONNX model path (FP32).
+    output_path : str
+        Output ONNX model path.
+    mode : str, default="int8"
+        Quantization mode:
+        - "int8" / "dynamic_int8": ONNX Runtime dynamic quantization (weights INT8).
+        - "fp16": convert float tensors to float16.
+    per_channel : bool, default=False
+        Enable per-channel quantization for weights (INT8).
+    reduce_range : bool, default=False
+        Use reduced quantization range (INT8), sometimes helpful on certain CPUs.
+    weight_type : {"qint8", "quint8"}, default="qint8"
+        Weight quant type for dynamic quantization.
+    optimize_model : bool, default=False
+        Run ORT graph optimization before quantization.
+    op_types_to_quantize / nodes_to_quantize / nodes_to_exclude / extra_options
+        Advanced options forwarded to ``onnxruntime.quantization.quantize_dynamic``.
+    keep_io_types : bool, default=True
+        For FP16 conversion, keep model input/output types as float32 for compatibility.
+
+    Returns
+    -------
+    str
+        The output_path.
+    """
+    mode_norm = (mode or "").strip().lower()
+    _ensure_parent_dir(output_path)
+
+    if mode_norm in ("int8", "dynamic_int8", "dynamic"):
+        try:
+            from onnxruntime.quantization import QuantType, quantize_dynamic
+        except Exception as e:  # pragma: no cover
+            raise ImportError("INT8 quantization requires onnxruntime. Install with: pip install -U \"torch-rechub[onnx]\"") from e
+
+        wt = (weight_type or "").strip().lower()
+        if wt in ("qint8", "int8", "signed"):
+            qt = QuantType.QInt8
+        elif wt in ("quint8", "uint8", "unsigned"):
+            qt = QuantType.QUInt8
+        else:
+            raise ValueError("weight_type must be one of {'qint8','quint8'}")
+
+        q_kwargs: Dict[str,
+                       Any] = {
+                           "model_input": input_path,
+                           "model_output": output_path,
+                           "per_channel": per_channel,
+                           "reduce_range": reduce_range,
+                           "weight_type": qt,
+                           "optimize_model": optimize_model,
+                           "op_types_to_quantize": op_types_to_quantize,
+                           "nodes_to_quantize": nodes_to_quantize,
+                           "nodes_to_exclude": nodes_to_exclude,
+                           "extra_options": extra_options,
+                       }
+
+        # Compatibility: different onnxruntime versions expose different kwargs.
+        sig = inspect.signature(quantize_dynamic)
+        q_kwargs = {k: v for k, v in q_kwargs.items() if k in sig.parameters and v is not None}
+
+        quantize_dynamic(**q_kwargs)
+        return output_path
+
+    if mode_norm in ("fp16", "float16"):
+        try:
+            import onnx
+        except Exception as e:  # pragma: no cover
+            raise ImportError("FP16 conversion requires onnx. Install with: pip install -U \"torch-rechub[onnx]\"") from e
+
+        try:
+            from onnxconverter_common import float16
+        except Exception as e:  # pragma: no cover
+            raise ImportError("FP16 conversion requires onnxconverter-common. Install with: pip install -U onnxconverter-common") from e
+
+        model = onnx.load(input_path)
+        model_fp16 = float16.convert_float_to_float16(model, keep_io_types=keep_io_types)
+        onnx.save(model_fp16, output_path)
+        return output_path
+
+    raise ValueError("mode must be one of {'int8','dynamic_int8','fp16'}")

torch_rechub/utils/visualization.py

@@ -44,27 +44,19 @@ def _is_jupyter_environment() -> bool:
 
 
 def display_graph(graph: Any, format: str = 'png') -> Any:
-    """Display a torchview ComputationGraph in Jupyter Notebook.
-
-    This function provides a reliable way to display visualization graphs
-    in Jupyter environments, especially VSCode Jupyter.
+    """Display a torchview ComputationGraph in Jupyter.
 
     Parameters
     ----------
     graph : ComputationGraph
-        A torchview ComputationGraph object returned by visualize_model().
+        Returned by :func:`visualize_model`.
     format : str, default='png'
-        Output format, 'png' recommended for VSCode.
+        Output format; 'png' recommended for VSCode.
 
     Returns
     -------
     graphviz.Digraph or None
-        The displayed graph object, or None if display fails.
-
-    Examples
-    --------
-    >>> graph = visualize_model(model, depth=4)
-    >>> display_graph(graph)  # Works in VSCode Jupyter
+        Displayed graph object, or None if display fails.
     """
     if not TORCHVIEW_AVAILABLE:
         raise ImportError(f"Visualization requires torchview. {TORCHVIEW_SKIP_REASON}\n"

{torch_rechub-0.0.6.dist-info → torch_rechub-0.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: torch-rechub
-Version: 0.0.6
+Version: 0.1.0
 Summary: A Pytorch Toolbox for Recommendation Models, Easy-to-use and Easy-to-extend.
 Project-URL: Homepage, https://github.com/datawhalechina/torch-rechub
 Project-URL: Documentation, https://www.torch-rechub.com
@@ -28,6 +28,8 @@ Requires-Dist: scikit-learn>=0.24.0
 Requires-Dist: torch>=1.10.0
 Requires-Dist: tqdm>=4.60.0
 Requires-Dist: transformers>=4.46.3
+Provides-Extra: annoy
+Requires-Dist: annoy>=1.17.2; extra == 'annoy'
 Provides-Extra: bigdata
 Requires-Dist: pyarrow~=21.0; extra == 'bigdata'
 Provides-Extra: dev
@@ -41,8 +43,13 @@ Requires-Dist: pytest-cov>=2.0; extra == 'dev'
 Requires-Dist: pytest>=6.0; extra == 'dev'
 Requires-Dist: toml>=0.10.2; extra == 'dev'
 Requires-Dist: yapf==0.43.0; extra == 'dev'
+Provides-Extra: faiss
+Requires-Dist: faiss-cpu==1.13.0; extra == 'faiss'
+Provides-Extra: milvus
+Requires-Dist: pymilvus>=2.6.5; extra == 'milvus'
 Provides-Extra: onnx
 Requires-Dist: onnx>=1.14.0; extra == 'onnx'
+Requires-Dist: onnxconverter-common>=1.14.0; extra == 'onnx'
 Requires-Dist: onnxruntime>=1.14.0; extra == 'onnx'
 Provides-Extra: tracking
 Requires-Dist: swanlab>=0.1.0; extra == 'tracking'

{torch_rechub-0.0.6.dist-info → torch_rechub-0.1.0.dist-info}/RECORD

@@ -1,21 +1,22 @@
 torch_rechub/__init__.py,sha256=XUwV85oz-uIokuE9qj3nmbUQg3EY8dZcDMohlob3suw,245
+torch_rechub/types.py,sha256=oWPz577qJO0PuSvmJsbST5lAFzuTjxWS9J7fj_IntNw,97
 torch_rechub/basic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 torch_rechub/basic/activation.py,sha256=hIZDCe7cAgV3bX2UnvUrkO8pQs4iXxkQGD0J4GejbVg,1600
 torch_rechub/basic/callback.py,sha256=ZeiDSDQAZUKmyK1AyGJCnqEJ66vwfwlX5lOyu6-h2G0,946
 torch_rechub/basic/features.py,sha256=TLHR5EaNvIbKyKd730Qt8OlLpV0Km91nv2TMnq0HObk,3562
 torch_rechub/basic/initializers.py,sha256=V6hprXvRexcw3vrYsf8Qp-F52fp8uzPMpa1CvkHofy8,3196
-torch_rechub/basic/layers.py,sha256=URWk78dlffMOAhDVDhOhugcr4nmwEa192AI1diktC-4,39653
-torch_rechub/basic/loss_func.py,sha256=6bjljqpiuUP6O8-wUbGd8FSvflY5Dp_DV_57OuQVMz4,7969
+torch_rechub/basic/layers.py,sha256=sLntNogvBu0QHm7riwyuJp_FbpbmPG26XeOyLs83Yu0,38813
+torch_rechub/basic/loss_func.py,sha256=a-j1gan4eYUk5zstWwKeaPZ99eJkZPGWS82LNhT6Jbc,7756
 torch_rechub/basic/metaoptimizer.py,sha256=y-oT4MV3vXnSQ5Zd_ZEHP1KClITEi3kbZa6RKjlkYw8,3093
 torch_rechub/basic/metric.py,sha256=9JsaJJGvT6VRvsLoM2Y171CZxESsjYTofD3qnMI-bPM,8443
 torch_rechub/basic/tracking.py,sha256=7-aoyKJxyqb8GobpjRjFsgPYWsBDOV44BYOC_vMoCto,6608
 torch_rechub/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 torch_rechub/data/convert.py,sha256=clGFEbDSDpdZBvscWatfjtuXMZUzgy1kiEAg4w_q7VM,2241
-torch_rechub/data/dataset.py,sha256=fDDQ5N3x99KPfy0Ux4LRQbFlWbLg_dvKTO1WUEbEN04,4111
+torch_rechub/data/dataset.py,sha256=2avvPcw2KQK5Xe6F_-kjGQMRiV957pGajU5klrs1NMA,3496
 torch_rechub/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 torch_rechub/models/generative/__init__.py,sha256=TsCdVIhOcalQwqKZKjEuNbHKyIjyclapKGNwYfFR7TM,135
 torch_rechub/models/generative/hllm.py,sha256=6Vrp5Bh0fTFHCn7C-3EqzOyc7UunOyEY9TzAKGHrW-8,9669
-torch_rechub/models/generative/hstu.py,sha256=M1ByAWHxrkvmwaXPNdGFrbAQYyYJswnABTY3jCEceyg,7846
+torch_rechub/models/generative/hstu.py,sha256=MkyodycbrZo15jr0m6mY1XrqYYhwT9ez3g-oZ3TlF5Q,7588
 torch_rechub/models/matching/__init__.py,sha256=fjWOzJB8loPGy8rJMG-6G-NUISp7k3sD_1FdsKGw1as,471
 torch_rechub/models/matching/comirec.py,sha256=8KB5rg2FWlZaG73CBI7_J8-J-XpjTPnblwh5OsbtAbc,9439
 torch_rechub/models/matching/dssm.py,sha256=1Q0JYpt1h_7NWlLN5a_RbCoUSubZwpYTVEXccSn44eg,3003
@@ -48,21 +49,26 @@ torch_rechub/models/ranking/din.py,sha256=HsOCEErea3KwEiyWw4M_aX_LMC_-Sqs1C_zeRL
 torch_rechub/models/ranking/edcn.py,sha256=6f_S8I6Ir16kCIU54R4EfumWfUFOND5KDKUPHMgsVU0,4997
 torch_rechub/models/ranking/fibinet.py,sha256=fmEJ9WkO8Mn0RtK_8aRHlnQFh_jMBPO0zODoHZPWmDA,2234
 torch_rechub/models/ranking/widedeep.py,sha256=eciRvWRBHLlctabLLS5NB7k3MnqrWXCBdpflOU6jMB0,1636
+torch_rechub/serving/__init__.py,sha256=F2UfH7yqwqbt0aOqVqxoPk96fxIt9s6ppZ-98Hq3qkY,1456
+torch_rechub/serving/annoy.py,sha256=G3ilENVAfKKnQUHUc53QOwqequxkf2oMnU-0Yo-WbHQ,3863
+torch_rechub/serving/base.py,sha256=27dG_zPBbwV0ojj0lDmOeIg-WHOwV-pjqKLimVI5vmg,2989
+torch_rechub/serving/faiss.py,sha256=kroqICeIxfZg8hPZiWZXmFtUpQSj9JLheFxorzdV3aw,4479
+torch_rechub/serving/milvus.py,sha256=EnhD-zbtmp3KAS-lkZYFCQjXeKe7J2-LM3-iIUhLg0Y,6529
 torch_rechub/trainers/__init__.py,sha256=NSa2DqgfE1HGDyj40YgrbtUrfBHBxNBpw57XtaAB_jE,148
-torch_rechub/trainers/ctr_trainer.py,sha256=e0xS-W48BOixN0ogksWOcVJNKFiO3g2oNA_hlHytRqk,14138
-torch_rechub/trainers/match_trainer.py,sha256=atkO-gfDuTk6lh-WvaJOh5kgn6HPzbQQN42Rvz8kyXY,16327
-torch_rechub/trainers/matching.md,sha256=vIBQ3UMmVpUpyk38rrkelFwm_wXVXqMOuqzYZ4M8bzw,30
-torch_rechub/trainers/mtl_trainer.py,sha256=n3T-ctWACSyl0awBQixOlZUQ8I5cfGyZzgKV09EF8hw,18293
-torch_rechub/trainers/seq_trainer.py,sha256=pyY70kAjTWdKrnAYZynql1PPNtveYDLMB_1hbpCHa48,19217
+torch_rechub/trainers/ctr_trainer.py,sha256=6vU2_-HCY1MBHwmT8p68rkoYFjbdFZgZ3zTyHxPIcGs,14407
+torch_rechub/trainers/match_trainer.py,sha256=oASggXTvFd-93ltvt2uhB1TFPSYP_H-EGdA8Zurw64A,16648
+torch_rechub/trainers/mtl_trainer.py,sha256=J8ztmZN-4f2ELruN2lAGLlC1quo9Y-yH9Yu30MXBqJE,18562
+torch_rechub/trainers/seq_trainer.py,sha256=48s8YfY0PN5HETm0Dj09xDKrCT9S8wqykK4q1OtMTRo,20358
 torch_rechub/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-torch_rechub/utils/data.py,sha256=vzLAAVt6dujg_vbGhQewiJc0l6JzwzdcM_9EjoOz898,19882
-torch_rechub/utils/hstu_utils.py,sha256=qLON_pJDC-kDyQn1PoN_HaHi5xTNCwZPgJeV51Z61Lc,6207
+torch_rechub/utils/data.py,sha256=TALy-nP9tqfz0DG2nMjBae5UZyBRvZIDX7zjGMnRqZ8,18542
+torch_rechub/utils/hstu_utils.py,sha256=QKX2V6dmbK6kwNEETSE0oEpbHz-FbIhB4PvbQC9Lx5w,5656
 torch_rechub/utils/match.py,sha256=l9qDwJGHPP9gOQTMYoqGVdWrlhDx1F1-8UnQwDWrEyk,18143
-torch_rechub/utils/model_utils.py,sha256=VLhSbTpupxrFyyY3NzMQ32PPmo5YHm1T96u9KDlwiWE,8450
+torch_rechub/utils/model_utils.py,sha256=f8dx9uVCN8kfwYSJm_Mg5jZ2_gNMItPzTyccpVf_zA4,8219
 torch_rechub/utils/mtl.py,sha256=AxU05ezizCuLdbPuCg1ZXE0WAStzuxaS5Sc3nwMCBpI,5737
-torch_rechub/utils/onnx_export.py,sha256=LRHyZaR9zZJyg6xtuqQHWmusWq-yEvw9EhlmoEwcqsg,8364
-torch_rechub/utils/visualization.py,sha256=Djv8W5SkCk3P2dol5VXf0_eanIhxDwRd7fzNOQY4uiU,9506
-torch_rechub-0.0.6.dist-info/METADATA,sha256=OihjWb0yCI1bmTEoCYAC6pI6cCgl5KS5uSrAGZwv7yY,18470
-torch_rechub-0.0.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-torch_rechub-0.0.6.dist-info/licenses/LICENSE,sha256=V7ietiX9G_84HtgEbxDgxClniqXGm2t5q8WM4AHGTu0,1066
-torch_rechub-0.0.6.dist-info/RECORD,,
+torch_rechub/utils/onnx_export.py,sha256=02-UI4C0ACccP4nP5moVn6tPr4SSFaKdym0aczJs_jI,10739
+torch_rechub/utils/quantization.py,sha256=ett0VpmQz6c14-zvRuoOwctQurmQFLfF7Dj565L7iqE,4847
+torch_rechub/utils/visualization.py,sha256=cfaq3_ZYcqxb4R7V_be-RebPAqKDedAJSwjYoUm55AU,9201
+torch_rechub-0.1.0.dist-info/METADATA,sha256=r7xaaxaN7MYx2BJu96WGU72nHvOpwFE9CQmZSKBnRrk,18746
+torch_rechub-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+torch_rechub-0.1.0.dist-info/licenses/LICENSE,sha256=V7ietiX9G_84HtgEbxDgxClniqXGm2t5q8WM4AHGTu0,1066
+torch_rechub-0.1.0.dist-info/RECORD,,

torch_rechub/trainers/matching.md

@@ -1,3 +0,0 @@
-# Matching
-
-召回使用文档