torch-rechub 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

torch_rechub/utils/mtl.py

@@ -0,0 +1,126 @@
+import torch
+from torch.optim.optimizer import Optimizer
+from ..models.multi_task import MMOE, SharedBottom, PLE, AITM
+
+
+def shared_task_layers(model):
+    """get shared layers and task layers in multi-task model
+    Authors: Qida Dong, dongjidan@126.com
+
+    Args:
+        model (torch.nn.Module): only support `[MMOE, SharedBottom, PLE, AITM]`
+
+    Returns:
+        list[torch.nn.parameter]: parameters split to shared list and task list.
+    """
+    shared_layers = list(model.embedding.parameters())
+    task_layers = None
+    if isinstance(model, SharedBottom):
+        shared_layers += list(model.bottom_mlp.parameters())
+        task_layers = list(model.towers.parameters()) + list(model.predict_layers.parameters())
+    elif isinstance(model, MMOE):
+        shared_layers += list(model.experts.parameters())
+        task_layers = list(model.towers.parameters()) + list(model.predict_layers.parameters())
+        task_layers += list(model.gates.parameters())
+    elif isinstance(model, PLE):
+        shared_layers += list(model.cgc_layers.parameters())
+        task_layers = list(model.towers.parameters()) + list(model.predict_layers.parameters())
+    elif isinstance(model, AITM):
+        shared_layers += list(model.bottoms.parameters())
+        task_layers = list(model.info_gates.parameters()) + list(model.towers.parameters()) + list(
+            model.aits.parameters())
+    else:
+        raise ValueError(f'this model {model} is not suitable for MetaBalance Optimizer')
+    return shared_layers, task_layers
+
+
+class MetaBalance(Optimizer):
+    """MetaBalance Optimizer
+    This method is used to scale the gradient and balance the gradient of each task.
+    Authors: Qida Dong, dongjidan@126.com
+
+    Args:
+        parameters (list): the parameters of model
+        relax_factor (float, optional): the relax factor of gradient scaling (default: 0.7)
+        beta (float, optional): the coefficient of moving average (default: 0.9)
+    """
+
+    def __init__(self, parameters, relax_factor=0.7, beta=0.9):
+
+        if relax_factor < 0. or relax_factor >= 1.:
+            raise ValueError(f'Invalid relax_factor: {relax_factor}, it should be 0. <= relax_factor < 1.')
+        if beta < 0. or beta >= 1.:
+            raise ValueError(f'Invalid beta: {beta}, it should be 0. <= beta < 1.')
+        rel_beta_dict = {'relax_factor': relax_factor, 'beta': beta}
+        super(MetaBalance, self).__init__(parameters, rel_beta_dict)
+
+    @torch.no_grad()
+    def step(self, losses):
+        for idx, loss in enumerate(losses):
+            loss.backward(retain_graph=True)
+            for group in self.param_groups:
+                for gp in group['params']:
+                    if gp.grad is None:
+                        # print('breaking')
+                        break
+                    if gp.grad.is_sparse:
+                        raise RuntimeError('MetaBalance does not support sparse gradients')
+                    # store the result of moving average
+                    state = self.state[gp]
+                    if len(state) == 0:
+                        for i in range(len(losses)):
+                            if i == 0:
+                                gp.norms = [0]
+                            else:
+                                gp.norms.append(0)
+                    # calculate the moving average
+                    beta = group['beta']
+                    gp.norms[idx] = gp.norms[idx] * beta + (1 - beta) * torch.norm(gp.grad)
+                    # scale the auxiliary gradient
+                    relax_factor = group['relax_factor']
+                    gp.grad = gp.grad * gp.norms[0] / (gp.norms[idx] + 1e-5) * relax_factor + gp.grad * (1. -
+                                                                                                         relax_factor)
+                    # store the gradient of each auxiliary task in state
+                    if idx == 0:
+                        state['sum_gradient'] = torch.zeros_like(gp.data)
+                        state['sum_gradient'] += gp.grad
+                    else:
+                        state['sum_gradient'] += gp.grad
+
+                    if gp.grad is not None:
+                        gp.grad.detach_()
+                        gp.grad.zero_()
+                    if idx == len(losses) - 1:
+                        gp.grad = state['sum_gradient']
+
+
+def gradnorm(loss_list, loss_weight, share_layer, initial_task_loss, alpha):
+    loss = 0
+    for loss_i, w_i in zip(loss_list, loss_weight):
+        loss += loss_i * w_i
+    loss.backward(retain_graph=True)
+    # set the gradients of w_i(t) to zero because these gradients have to be updated using the GradNorm loss
+    for w_i in loss_weight:
+        w_i.grad.data = w_i.grad.data * 0.0
+    # get the gradient norms for each of the tasks
+    # G^{(i)}_w(t)
+    norms, loss_ratio = [], []
+    for i in range(len(loss_list)):
+        # get the gradient of this task loss with respect to the shared parameters
+        gygw = torch.autograd.grad(loss_list[i], share_layer, retain_graph=True)
+        # compute the norm
+        norms.append(torch.norm(torch.mul(loss_weight[i], gygw[0])))
+        # compute the inverse training rate r_i(t)
+        loss_ratio.append(loss_list[i].item() / initial_task_loss[i])
+    norms = torch.stack(norms)
+    mean_norm = torch.mean(norms.detach())
+    mean_loss_ratio = sum(loss_ratio) / len(loss_ratio)
+    # compute the GradNorm loss
+    # this term has to remain constant
+    constant_term = mean_norm * (mean_loss_ratio**alpha)
+    grad_norm_loss = torch.sum(torch.abs(norms - constant_term))
+    #print('GradNorm loss {}'.format(grad_norm_loss))
+
+    # compute the gradient for the weights
+    for w_i in loss_weight:
+        w_i.grad = torch.autograd.grad(grad_norm_loss, w_i, retain_graph=True)[0]

{torch_rechub-0.0.1.dist-info → torch_rechub-0.0.3.dist-info}/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2022 Mincai Lai
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2022 Datawhale
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

torch_rechub-0.0.3.dist-info/METADATA

@@ -0,0 +1,177 @@
+Metadata-Version: 2.1
+Name: torch-rechub
+Version: 0.0.3
+Summary: A Lighting Pytorch Framework for Recommendation System, Easy-to-use and Easy-to-extend.
+Home-page: https://github.com/datawhalechina/torch-rechub
+Author: Datawhale
+Author-email: laimc@shanghaitech.edu.cn
+Keywords: ctr,click through rate,deep learning,pytorch,recsys,recommendation
+Platform: all
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.19.0
+Requires-Dist: torch>=1.7.0
+Requires-Dist: pandas>=1.0.5
+Requires-Dist: tqdm>=4.64.0
+Requires-Dist: scikit-learn>=0.23.2
+Requires-Dist: annoy>=1.17.0
+
+# Torch-RecHub
+
+<p align="left">
+  <img src='https://img.shields.io/badge/python-3.8+-brightgreen'>
+  <img src='https://img.shields.io/badge/torch-1.7+-brightgreen'>
+  <img src='https://img.shields.io/badge/scikit_learn-0.23.2+-brightgreen'>
+  <img src='https://img.shields.io/badge/pandas-1.0.5+-brightgreen'>
+  <img src='https://img.shields.io/badge/annoy-1.17.0-brightgreen'>
+  <img src="https://img.shields.io/pypi/l/torch-rechub">
+ <a href="https://github.com/datawhalechina/torch-rechub"><img src="https://hits.seeyoufarm.com/api/count/incr/badge.svg?url=https%3A%2F%2Fgithub.com%2Fdatawhalechina%2Ftorch-rechub&count_bg=%2379C83D&title_bg=%23555555&icon=&icon_color=%23E7E7E7&title=hits&edge_flat=false"/></a>
+
+## 中文Wiki站
+
+查看最新研发进度，认领感兴趣的研发任务，学习rechub模型复现心得，加入rechub共建者团队等
+
+[点击链接](https://www.wolai.com/rechub/2qjdg3DPy1179e1vpcHZQC)
+
+## 安装
+
+```python
+#稳定版 
+pip install torch-rechub
+
+#最新版（推荐）
+1. git clone https://github.com/datawhalechina/torch-rechub.git
+2. cd torch-rechub
+3. python setup.py install
+```
+
+## 核心定位
+
+易用易拓展，聚焦复现业界实用的推荐模型，以及泛生态化的推荐场景
+
+## 主要特性
+
+*   scikit-learn风格易用的API（fit、predict），即插即用
+
+*   模型训练与模型定义解耦，易拓展，可针对不同类型的模型设置不同的训练机制
+
+*   接受pandas的DataFrame、Dict数据输入，上手成本低
+
+*   高度模块化，支持常见Layer，容易调用组装成新模型
+
+    *   LR、MLP、FM、FFM、CIN
+
+    *   target-attention、self-attention、transformer
+
+*   支持常见排序模型
+
+    *   WideDeep、DeepFM、DIN、DCN、xDeepFM等
+
+*   支持常见召回模型
+
+    *   DSSM、YoutubeDNN、YoutubeDSSM、FacebookEBR、MIND等
+
+*   丰富的多任务学习支持
+
+    *   SharedBottom、ESMM、MMOE、PLE、AITM等模型
+
+    *   GradNorm、UWL、MetaBanlance等动态loss加权机制
+
+*   聚焦更生态化的推荐场景
+
+    - [ ] 冷启动
+
+    - [ ] 延迟反馈
+
+    *   [ ] 去偏
+
+*   支持丰富的训练机制
+
+    *   [ ] 对比学习
+
+    *   [ ] 蒸馏学习
+
+*   [ ] 第三方高性能开源Trainer支持（Pytorch Lighting）
+
+*   [ ] 更多模型正在开发中
+
+## 快速使用
+
+### 使用案例
+
+- 所有模型使用案例参考 `/examples`
+
+- 202206 Datawhale-RecHub推荐课程 组队学习期间notebook教程参考 `/tutorials`
+
+### 精排（CTR预测）
+
+```python
+from torch_rechub.models.ranking import DeepFM
+from torch_rechub.trainers import CTRTrainer
+from torch_rechub.utils.data import DataGenerator
+
+dg = DataGenerator(x, y)
+train_dataloader, val_dataloader, test_dataloader = dg.generate_dataloader(split_ratio=[0.7, 0.1], batch_size=256)
+
+model = DeepFM(deep_features=deep_features, fm_features=fm_features, mlp_params={"dims": [256, 128], "dropout": 0.2, "activation": "relu"})
+
+ctr_trainer = CTRTrainer(model)
+ctr_trainer.fit(train_dataloader, val_dataloader)
+auc = ctr_trainer.evaluate(ctr_trainer.model, test_dataloader)
+```
+
+### 多任务排序
+
+```python
+from torch_rechub.models.multi_task import SharedBottom, ESMM, MMOE, PLE, AITM
+from torch_rechub.trainers import MTLTrainer
+
+task_types = ["classification", "classification"] 
+model = MMOE(features, task_types, 8, expert_params={"dims": [32,16]}, tower_params_list=[{"dims": [32, 16]}, {"dims": [32, 16]}])
+
+mtl_trainer = MTLTrainer(model)
+mtl_trainer.fit(train_dataloader, val_dataloader)
+auc = ctr_trainer.evaluate(ctr_trainer.model, test_dataloader)
+```
+
+### 召回模型
+
+```python
+from torch_rechub.models.matching import DSSM
+from torch_rechub.trainers import MatchTrainer
+from torch_rechub.utils.data import MatchDataGenerator
+
+dg = MatchDataGenerator(x y)
+train_dl, test_dl, item_dl = dg.generate_dataloader(test_user, all_item, batch_size=256)
+
+model = DSSM(user_features, item_features, temperature=0.02,
+             user_params={
+                 "dims": [256, 128, 64],
+                 "activation": 'prelu',  
+             },
+             item_params={
+                 "dims": [256, 128, 64],
+                 "activation": 'prelu', 
+             })
+
+match_trainer = MatchTrainer(model)
+match_trainer.fit(train_dl)
+
+```
+

torch_rechub-0.0.3.dist-info/RECORD

@@ -0,0 +1,55 @@
+torch_rechub/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+torch_rechub/basic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+torch_rechub/basic/activation.py,sha256=MjqWIXKhOygkwxVpuCNPaqgmP_gB13tHBgANyFoPh8k,1658
+torch_rechub/basic/callback.py,sha256=GzAOfW-xWOJNdZhxE21crFX6-GbKinYApdPtdz4WwNQ,985
+torch_rechub/basic/features.py,sha256=3SqSQ0uRj6lwr3j7OXIlLeS05jt5v9nlkkgilWfALL0,3777
+torch_rechub/basic/initializers.py,sha256=AfJd0mqQqGqzk12IC_N2qZgRzz4LyP8n9FcmWzWTmH4,3292
+torch_rechub/basic/layers.py,sha256=rOdbvpPxp3GbQ4lgZSZgWeOuhbDgjVOpHe-rbha_fyk,30484
+torch_rechub/basic/loss_func.py,sha256=EeqYUClS3CVv3EEx2XnzK0vWAULZAw_Lr0mjf9XN6U4,1170
+torch_rechub/basic/metaoptimizer.py,sha256=AmG-LrkDKhSnI2kK7qzVVJS0eQ3aMWHS1nEqeRXWFgU,3138
+torch_rechub/basic/metric.py,sha256=m8fKjRVja6PyllV5OrHXwbpNntK73jFv-QzA94pNAIU,7508
+torch_rechub/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+torch_rechub/models/matching/__init__.py,sha256=gR9csAI1ataaIVRqdlBSpsEYmLotq3UNc-YUV9PvAf4,336
+torch_rechub/models/matching/comirec.py,sha256=-i3bb9ovcyEtGl8wqpLVo0EIwADjd3Ui7jn3b3pX7ps,9620
+torch_rechub/models/matching/dssm.py,sha256=FuWhH-lGtqAfe6vm_Pi1K0l-wLkqTVYwtIxFrwISsXo,3042
+torch_rechub/models/matching/dssm_facebook.py,sha256=n8nqHk2RFm_qUuBEqiu5leMSFj6giGibanru0yPk7Rk,3679
+torch_rechub/models/matching/dssm_senet.py,sha256=AhY298J8kHjtubmJkHht8QpXnH5QC1ArPrDBYA2q4KE,3967
+torch_rechub/models/matching/gru4rec.py,sha256=RzbVrTV-LkLB8g7vwpsUXd7viyz6ZPf0BBv3IK1bs_I,4136
+torch_rechub/models/matching/mind.py,sha256=pnlvqYXU5sKYpzIs-ktmMBFTEUgNIfNjoXXgurFbwz4,5029
+torch_rechub/models/matching/narm.py,sha256=UTsIuCSoMPzVDlnB6eOF-vEF5SYV-VET9pMalFYDT4I,3244
+torch_rechub/models/matching/sasrec.py,sha256=9_4vO9Kz25Wj19i0SPsOfhbQWMJKtGQneNRMUQV0w6Y,5865
+torch_rechub/models/matching/sine.py,sha256=uglxLI4r5JU0CnFdKZdSPcnkvmeE6b9vr2N5sBoP_qw,7089
+torch_rechub/models/matching/stamp.py,sha256=8N7Zl527QvqARtrwf8niP86djnMy4YYqT_EPp-7UhTY,3556
+torch_rechub/models/matching/youtube_dnn.py,sha256=ZIQY4nQFRi73QWYVALgFaApaiJQCxLQoeHzk0O2BBxg,3453
+torch_rechub/models/matching/youtube_sbc.py,sha256=L5xfgxEvDTlBmK09GNRXiZVfFAf4v2WyKltRE18CVX8,4945
+torch_rechub/models/multi_task/__init__.py,sha256=1dAe4mo8kRjsCAUx6Cs3jzw-PrlI2y0B5q6BK-THgZM,133
+torch_rechub/models/multi_task/aitm.py,sha256=dcXDBXwYEHNlBlGv-gbY6lZ6Nba3Wi6iqYuYP1SGR40,3454
+torch_rechub/models/multi_task/esmm.py,sha256=WYUiuhLxeBx9QpgJS6RawPvz9n0WWff0q7jEX4xnbDI,2789
+torch_rechub/models/multi_task/mmoe.py,sha256=e3_0tO9dbH831y0kRdpy8hDQhFSpM7gI9GTspYCAZeA,2926
+torch_rechub/models/multi_task/ple.py,sha256=3S5ufr320BOl41hUYxez6tKPcKKQoHq7yW1j7q-tNQk,7005
+torch_rechub/models/multi_task/shared_bottom.py,sha256=EgLIF1Hb6u-S83pLeX-DlXAbZWu92KSS4kTl5CKQllw,1913
+torch_rechub/models/ranking/__init__.py,sha256=Hj9_4RghDB0yzc8EGP9wwBb7VMpgogQN71NCtcOj6MI,293
+torch_rechub/models/ranking/afm.py,sha256=HK1ww6g38vKEhEj9M0UPEVnTQ_OQKggv5qxxkrpjlLA,2323
+torch_rechub/models/ranking/bst.py,sha256=mSISHGSYsNwjdPDOsxyXPuDXsR1qxYrVNUZBx03XDw4,3815
+torch_rechub/models/ranking/dcn.py,sha256=OB0seU6YZRV9nGSSpV3aZWTWSXJlY0f45sfBtleaMV0,1339
+torch_rechub/models/ranking/dcn_v2.py,sha256=yUAncBAEAEjkzPbZFKDWoSQFa4Ogo48qkHVnpprB8JQ,3182
+torch_rechub/models/ranking/deepffm.py,sha256=mrA-tOHhNsqoaO1lgd6mg-nVMNScOt8fW1dKOjYyeT0,6429
+torch_rechub/models/ranking/deepfm.py,sha256=g_RbTY0oWz6Bu1XyU6B0BXLznXKroIVjFrOzw5InVXU,1815
+torch_rechub/models/ranking/dien.py,sha256=r0Wjm3MINAI3q0E82mQIGN1Q8Y6B4ZA9-uax6xfvjEg,9164
+torch_rechub/models/ranking/din.py,sha256=mSmohL7DHlqppo8aSNFYKA8FmpBww8Cxjn-U476Ag7I,4715
+torch_rechub/models/ranking/edcn.py,sha256=XJQ9vSYRgQMyJlGFAJH95OfIl5UAzvinmvtBYD-sHCU,5673
+torch_rechub/models/ranking/fibinet.py,sha256=dLfDGdBbhlgz5JmgzBCKRrvYHgkAjP3VfcMsa5Sv3Tg,2294
+torch_rechub/models/ranking/widedeep.py,sha256=tSFqeTsg-vjz-6_Av18GZqRVh3NBs7HlumE8-uV9-88,1675
+torch_rechub/trainers/__init__.py,sha256=TPdNJp7UjHrmJE5Jq3YfM0OZ71Kfd6tDmBS-HhTdtxU,113
+torch_rechub/trainers/ctr_trainer.py,sha256=Hd87UEV4cOOMTvXJnEp3ZXFXAqryTpjgp0TSSFpwcM8,6026
+torch_rechub/trainers/match_trainer.py,sha256=Q8OiwCQKm8-aBrCy7qbgII6zOk38qZaJetiis2oPr-0,7988
+torch_rechub/trainers/mtl_trainer.py,sha256=tOKO7iQ0CJ4M_AAwzjnH5m6dizWrhdED41oRub6ueBY,10006
+torch_rechub/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+torch_rechub/utils/data.py,sha256=vuRigwbrpXtEBn47zwzqWTtSC4FXihOTk-4hPEUp0OU,14787
+torch_rechub/utils/match.py,sha256=diXjN3mDaRSDc24oJpZxWPaXL6pkR6iAaiurfzmJdG8,11908
+torch_rechub/utils/mtl.py,sha256=JpRobRgNyCFtDkVVhbQkLdMT4pFrPihJ1cm4QJogddE,5911
+torch_rechub-0.0.3.dist-info/LICENSE,sha256=B_RpxT4MtHbioKj8jkv1yhBWs4Zlcd8I4vMS8GH5Gwg,1087
+torch_rechub-0.0.3.dist-info/METADATA,sha256=i8JZFLp3YQVZY-awer1MLWwSCJAmJAgJof-ylPptGpI,5833
+torch_rechub-0.0.3.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+torch_rechub-0.0.3.dist-info/top_level.txt,sha256=_RPvAnlLHdll9u2d74aFr_oOAj_NxgfLpH02Uifz_YY,13
+torch_rechub-0.0.3.dist-info/RECORD,,

{torch_rechub-0.0.1.dist-info → torch_rechub-0.0.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: setuptools (75.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

torch_rechub/basic/utils.py

@@ -1,168 +0,0 @@
-import random
-import torch
-import numpy as np
-import pandas as pd
-from torch.utils.data import Dataset, DataLoader, random_split
-from sklearn.metrics import roc_auc_score, mean_squared_error
-
-
-class TorchDataset(Dataset):
-
-    def __init__(self, x, y):
-        super(TorchDataset, self).__init__()
-        self.x = x
-        self.y = y
-
-    def __getitem__(self, index):
-        return {k: v[index] for k, v in self.x.items()}, self.y[index]
-
-    def __len__(self):
-        return len(self.y)
-
-
-class DataGenerator(object):
-
-    def __init__(self, x, y):
-        super(DataGenerator, self).__init__()
-        self.dataset = TorchDataset(x, y)
-        self.length = len(self.dataset)
-
-    def generate_dataloader(self, x_val=None, y_val=None, x_test=None, y_test=None, split_ratio=None, batch_size=16, num_workers=8):
-        if split_ratio != None:
-            train_length = int(self.length * split_ratio[0])
-            val_length = int(self.length * split_ratio[1])
-            test_length = self.length - train_length - val_length
-            print("the samples of train : val : test are  %d : %d : %d" % (train_length, val_length, test_length))
-            train_dataset, val_dataset, test_dataset = random_split(self.dataset, (train_length, val_length, test_length))
-        else:
-            train_dataset = self.dataset
-            val_dataset = TorchDataset(x_val, y_val)
-            test_dataset = TorchDataset(x_test, y_test)
-
-        train_dataloader = DataLoader(train_dataset, batch_size=batch_size, num_workers=num_workers)
-        val_dataloader = DataLoader(val_dataset, batch_size=batch_size, num_workers=num_workers)
-        test_dataloader = DataLoader(test_dataset, batch_size=batch_size, num_workers=num_workers)
-        return train_dataloader, val_dataloader, test_dataloader
-
-
-class PredictDataset(Dataset):
-
-    def __init__(self, x):
-        super(TorchDataset, self).__init__()
-        self.x = x
-
-    def __getitem__(self, index):
-        return {k: v[index] for k, v in self.x.items()}
-
-    def __len__(self):
-        return len(self.x[list(self.x.keys())[0]])
-
-
-def get_auto_embedding_dim(num_classes):
-    """ Calculate the dim of embedding vector according to number of classes in the category
-    emb_dim = [6 * (num_classes)^(1/4)]
-    reference: Deep & Cross Network for Ad Click Predictions.(ADKDD'17)
-    
-    Args:
-        num_classes: number of classes in the category
-    
-    Returns:
-        the dim of embedding vector
-    """
-    return np.floor(6 * np.pow(num_classes, 0.26))
-
-
-def get_loss_func(task_type="classification"):
-    if task_type == "classification":
-        return torch.nn.BCELoss()
-    elif task_type == "regression":
-        return torch.nn.MSELoss()
-    else:
-        raise ValueError("task_type must be classification or regression")
-
-
-def get_metric_func(task_type="classification"):
-    if task_type == "classification":
-        return roc_auc_score
-    elif task_type == "regression":
-        return mean_squared_error
-    else:
-        raise ValueError("task_type must be classification or regression")
-
-
-def create_seq_features(data, max_len=50, drop_short=3, shuffle=True):
-    """Build a sequence of user's history by time.
-    
-    Args:
-        data (pd.DataFrame): must contain keys: `user_id, item_id, cate_id, time`.
-        max_len (int): the max length of a user history sequence.
-        drop_short (int): remove some inactive user who's sequence length < drop_short.
-        shuffle (bool): shuffle data if true.
-    
-    Returns: 
-        train (pd.DataFrame): target item will be each item before last two items.
-        val (pd.DataFrame): target item is the second to last item of user's history sequence.
-        test (pd.DataFrame): target item is the last item of user's history sequence.
-    """
-    n_users, n_items, n_cates = data["user_id"].max(), data["item_id"].max(), data["cate_id"].max()
-    # 0 to be used as the symbol for padding
-    data = data.astype('int32')
-    data['item_id'] = data['item_id'].apply(lambda x: x + 1)
-    data['cate_id'] = data['cate_id'].apply(lambda x: x + 1)
-
-    item_cate_map = data[['item_id', 'cate_id']]
-    item2cate_dict = item_cate_map.set_index(['item_id'])['cate_id'].to_dict()
-
-    data = data.sort_values(['user_id', 'time']).groupby('user_id').agg(click_hist_list=('item_id', list), cate_hist_hist=('cate_id', list)).reset_index()
-
-    # Sliding window to construct negative samples
-    train_data, val_data, test_data = [], [], []
-    for item in data.itertuples():
-        if len(item[2]) < drop_short:
-            continue
-        click_hist_list = item[2][:max_len]
-        cate_hist_list = item[3][:max_len]
-
-        def neg_sample():
-            neg = click_hist_list[0]
-            while neg in click_hist_list:
-                neg = random.randint(1, n_items)
-            return neg
-
-        neg_list = [neg_sample() for _ in range(len(click_hist_list))]
-        hist_list = []
-        cate_list = []
-        for i in range(1, len(click_hist_list)):
-            hist_list.append(click_hist_list[i - 1])
-            cate_list.append(cate_hist_list[i - 1])
-            hist_list_pad = hist_list + [0] * (max_len - len(hist_list))
-            cate_list_pad = cate_list + [0] * (max_len - len(cate_list))
-            if i == len(click_hist_list) - 1:
-                test_data.append([hist_list_pad, cate_list_pad, click_hist_list[i], cate_hist_list[i], 1])
-                test_data.append([hist_list_pad, cate_list_pad, neg_list[i], item2cate_dict[neg_list[i]], 0])
-            if i == len(click_hist_list) - 2:
-                val_data.append([hist_list_pad, cate_list_pad, click_hist_list[i], cate_hist_list[i], 1])
-                val_data.append([hist_list_pad, cate_list_pad, neg_list[i], item2cate_dict[neg_list[i]], 0])
-            else:
-                train_data.append([hist_list_pad, cate_list_pad, click_hist_list[i], cate_hist_list[i], 1])
-                train_data.append([hist_list_pad, cate_list_pad, neg_list[i], item2cate_dict[neg_list[i]], 0])
-
-    # shuffle
-    if shuffle:
-        random.shuffle(train_data)
-        random.shuffle(val_data)
-        random.shuffle(test_data)
-
-    col_name = ['history_item', 'history_cate', 'target_item', 'target_cate', 'label']
-    train = pd.DataFrame(train_data, columns=col_name)
-    val = pd.DataFrame(val_data, columns=col_name)
-    test = pd.DataFrame(test_data, columns=col_name)
-
-    return train, val, test
-
-
-def df_to_input_dict(data):
-    data_dict = data.to_dict('list')
-    for key in data.keys():
-        data_dict[key] = np.array(data_dict[key])
-    return data_dict