Add files via upload

Author: LogicJake

competitions/wsdm_iqiyi_torch/feature.py

@@ -0,0 +1,71 @@
+import os
+
+import numpy as np
+import pandas as pd
+
+np.random.seed(2021)
+
+launch = pd.read_csv('raw_data/wsdm_train_data/app_launch_logs.csv')
+test = pd.read_csv('raw_data/test-a.csv')
+
+launch.date.min(), launch.date.max()
+
+launch_grp = launch.groupby('user_id').agg(launch_date=('date', list),
+                                           launch_type=('launch_type',
+                                                        list)).reset_index()
+
+
+def choose_end_date(launch_date):
+    n1, n2 = min(launch_date), max(launch_date)
+    if n1 < n2 - 7:
+        end_date = np.random.randint(n1, n2 - 7)
+    else:
+        end_date = np.random.randint(100, 222 - 7)
+    return end_date
+
+
+def get_label(row):
+    launch_list = row.launch_date
+    end = row.end_date
+    label = sum([1 for x in set(launch_list) if end < x < end + 8])
+    return label
+
+
+launch_grp['end_date'] = launch_grp.launch_date.apply(choose_end_date)
+launch_grp['label'] = launch_grp.apply(get_label, axis=1)
+
+train = launch_grp[['user_id', 'end_date', 'label']]
+train
+
+test['label'] = -1
+test
+
+data = pd.concat([train, test], ignore_index=True)
+data
+
+data = data.merge(launch_grp[['user_id', 'launch_type', 'launch_date']],
+                  how='left',
+                  on='user_id')
+data
+
+
+# get latest 32 days([end_date-31, end_date]) launch type sequence
+# 0 for not launch, 1 for launch_type=0, and 2 for launch_type=1
+def gen_launch_seq(row):
+    seq_sort = sorted(zip(row.launch_type, row.launch_date),
+                      key=lambda x: x[1])
+    seq_map = {d: t + 1 for t, d in seq_sort}
+    end = row.end_date
+    seq = [seq_map.get(x, 0) for x in range(end - 31, end + 1)]
+    return seq
+
+
+data['launch_seq'] = data.apply(gen_launch_seq, axis=1)
+data
+
+data.head()
+
+data.drop(columns=['launch_date', 'launch_type'], inplace=True)
+
+os.makedirs('data', exist_ok=True)
+data.to_pickle('data/all_data.pkl')

competitions/wsdm_iqiyi_torch/model.py

@@ -0,0 +1,27 @@
+import torch
+import torch.nn as nn
+
+
+class AQYModel(nn.Module):
+    def __init__(self):
+        super(AQYModel, self).__init__()
+
+        self.user_id_embedding = nn.Embedding(600000 + 1, 16)
+        self.launch_seq_gru = nn.GRU(input_size=1,
+                                     hidden_size=16,
+                                     batch_first=True)
+
+        self.fc = nn.Linear(32, 1)
+
+    def forward(self, user_id, launch_seq):
+        user_id_emb = self.user_id_embedding(user_id)
+
+        launch_seq = launch_seq.reshape((-1, 32, 1))
+        launch_seq, _ = self.launch_seq_gru(launch_seq)
+        launch_seq = torch.mean(launch_seq, dim=1)
+
+        fc_input = torch.cat([user_id_emb, launch_seq], 1)
+
+        pred = self.fc(fc_input)
+
+        return pred

competitions/wsdm_iqiyi_torch/model_tools.py

@@ -0,0 +1,96 @@
+import numpy as np
+import torch
+from torch.utils.data import Dataset
+from tqdm import tqdm
+
+
+def cal_score(pred, label):
+    pred = np.array(pred)
+    label = np.array(label)
+
+    diff = (pred - label) / 7
+    diff = np.abs(diff)
+
+    score = 100 * (1 - np.mean(diff))
+    return score
+
+
+class AQYDataset(Dataset):
+    def __init__(self, df, device):
+        self.user_id_list = df['user_id'].values
+
+        self.launch_seq_list = df['launch_seq'].values
+
+        self.label_list = df['label'].values
+
+    def __getitem__(self, index):
+        user_id = self.user_id_list[index]
+
+        launch_seq = np.array(self.launch_seq_list[index])
+
+        label = self.label_list[index]
+
+        return user_id, launch_seq, label
+
+    def __len__(self):
+        return len(self.user_id_list)
+
+
+def fit(model, train_loader, optimizer, criterion, device):
+    model.train()
+
+    pred_list = []
+    label_list = []
+
+    for user_id, launch_seq, label in tqdm(train_loader):
+        user_id = user_id.long().to(device)
+        launch_seq = launch_seq.float().to(device)
+        label = torch.tensor(label).float().to(device)
+
+        pred = model(user_id, launch_seq)
+
+        loss = criterion(pred.squeeze(), label)
+        loss.backward()
+        optimizer.step()
+        model.zero_grad()
+
+        pred_list.extend(pred.squeeze().cpu().detach().numpy())
+        label_list.extend(label.squeeze().cpu().detach().numpy())
+
+    score = cal_score(pred_list, label_list)
+
+    return score
+
+
+def validate(model, val_loader, device):
+    model.eval()
+
+    pred_list = []
+    label_list = []
+
+    for user_id, launch_seq, label in tqdm(val_loader):
+        user_id = user_id.long().to(device)
+        launch_seq = launch_seq.float().to(device)
+        label = torch.tensor(label).float().to(device)
+
+        pred = model(user_id, launch_seq)
+
+        pred_list.extend(pred.squeeze().cpu().detach().numpy())
+        label_list.extend(label.squeeze().cpu().detach().numpy())
+
+    score = cal_score(pred_list, label_list)
+
+    return score
+
+
+def predict(model, test_loader, device):
+    model.eval()
+    test_pred = []
+    for user_id, launch_seq, _ in tqdm(test_loader):
+        user_id = user_id.long().to(device)
+        launch_seq = launch_seq.float().to(device)
+
+        pred = model(user_id, launch_seq).squeeze()
+        test_pred.extend(pred.cpu().detach().numpy())
+
+    return test_pred

competitions/wsdm_iqiyi_torch/train.py

@@ -0,0 +1,111 @@
+import copy
+import os
+import warnings
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+from sklearn.preprocessing import LabelEncoder
+from torch.utils.data import DataLoader
+
+from model import AQYModel
+from model_tools import AQYDataset, fit, predict, validate
+
+warnings.filterwarnings('ignore')
+
+
+def random_seed(seed):
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+
+random_seed(2021)
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+device
+
+data = pd.read_pickle('data/all_data.pkl')
+data.head()
+
+user_lbe = LabelEncoder()
+data['user_id'] = user_lbe.fit_transform(data['user_id'])
+data['user_id'] = data['user_id'] + 1
+
+train = data[data['label'] != -1]
+test = data[data['label'] == -1]
+
+train = train.sample(frac=1, random_state=2021).reset_index(drop=True)
+
+train_shape = int(train.shape[0] * 0.9)
+
+valid = train.iloc[train_shape:]
+train = train.iloc[:train_shape]
+
+print(train.shape, valid.shape, test.shape)
+
+train_dataset = AQYDataset(train, device)
+valid_dataset = AQYDataset(valid, device)
+test_dataset = AQYDataset(test, device)
+
+train_loader = DataLoader(train_dataset,
+                          batch_size=128,
+                          shuffle=True,
+                          num_workers=4)
+valid_loader = DataLoader(valid_dataset,
+                          batch_size=128,
+                          shuffle=False,
+                          num_workers=4)
+test_loader = DataLoader(test_dataset,
+                         batch_size=128,
+                         shuffle=False,
+                         num_workers=4)
+
+model = AQYModel().to(device)
+
+optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
+criterion = nn.MSELoss()
+
+best_val_score = float('-inf')
+last_improve = 0
+best_model = None
+
+for epoch in range(10):
+    train_score = fit(model, train_loader, optimizer, criterion, device)
+    val_score = validate(model, valid_loader, device)
+
+    if val_score > best_val_score:
+        best_val_score = val_score
+        best_model = copy.deepcopy(model)
+        last_improve = epoch
+        improve = '*'
+    else:
+        improve = ''
+
+    if epoch - last_improve > 3:
+        break
+
+    print(
+        f'Epoch: {epoch} Train Score: {train_score}, Valid Score: {val_score} {improve}'
+    )
+
+model = best_model
+
+valid['pred'] = predict(model, valid_loader, device)
+valid['diff'] = valid['label'] - valid['pred']
+valid['diff'] = abs(valid['diff']) / 7
+score = 100 * (1 - valid['diff'].mean())
+print(f'Valid Score: {score}')
+
+os.makedirs('sub', exist_ok=True)
+
+test['pred'] = predict(model, test_loader, device)
+test = test[['user_id', 'pred']]
+test['user_id'] = test['user_id'] - 1
+test['user_id'] = user_lbe.inverse_transform(test['user_id'])
+
+test.to_csv(f'sub/{score}.csv', index=False, header=False, float_format="%.2f")