飞桨常规赛：点击反欺诈预测 - 4月第8名方案

# 特征处理方式，1:嵌入，2:归一化class DealType(Enum):
    EMB = 1
    NORM = 2
    EMB_FILTER = 3# None为舍弃特征FEATURE_PATTERN = {    # 'sid': None,

    'android_id': DealType.EMB_FILTER,    'media_id': DealType.EMB,    'apptype': DealType.EMB,    'package': DealType.EMB_FILTER,    'version': DealType.EMB,    'ntt': DealType.EMB,    'carrier': DealType.EMB,    'os': DealType.EMB,    'osv': DealType.EMB,    'dev_height': DealType.EMB,    'dev_ppi': DealType.EMB,    'dev_width': DealType.EMB,    'lan': DealType.EMB,    'location': DealType.EMB,    'fea_hash': DealType.EMB_FILTER,    'fea1_hash': DealType.EMB_FILTER,    'cus_type': DealType.EMB,    'timestamp': DealType.NORM,
}

FEATURE_PATTERN_NEW = FEATURE_PATTERN.copy()
FEATURE_PATTERN_NEW.update({    'android_id': DealType.EMB,    'package': DealType.EMB,    'fea_hash': DealType.EMB,    'fea1_hash': DealType.EMB
})
FEATURE_LIST = [feat for feat in FEATURE_PATTERN_NEW if FEATURE_PATTERN_NEW[feat]]# 训练集，验证集比例TRAIN_RATIO = 0.9VAL_RATIO = 0.1# 转换大离散特征for feat in FEATURE_PATTERN:    if FEATURE_PATTERN[feat] == DealType.EMB_FILTER:
        trainPoint = int(len(trainData[feat]) * TRAIN_RATIO)
        trainValue = trainData[feat][:trainPoint]
        valueDict = {value: str(value) for value in set(trainValue) if value is not np.nan}
        data = trainData.iloc[:trainPoint].groupby(feat)[feat].count()
        removeValue = -1
        data[data <= 15] = removeValue
        valueDict.update(data.loc[data == removeValue].to_dict())
        trainData[feat] = trainData[feat].map(valueDict)
        trainData[feat] = trainData[feat].replace({np.nan: removeValue})
        testData[feat] = testData[feat].map(valueDict)
        testData[feat] = testData[feat].replace({np.nan: removeValue})

class ConNet(paddle.nn.Layer):
    def __init__(self, sizeDict: dict):
        super().__init__()        # 存储每个特征的隐藏层
        self.hidden_layers_list = nn.LayerList([])        # 统计隐藏层输出结点
        out_features = 1
        for feat in FEATURE_LIST:            if FEATURE_PATTERN_NEW[feat] == DealType.EMB:
                embedding_dim = int(np.power(sizeDict[feat], 0.25))
                hidden_layer = nn.LayerList([nn.Embedding(num_embeddings=sizeDict[feat], embedding_dim=embedding_dim),
                                             nn.Linear(in_features=embedding_dim, out_features=out_features)])            else:
                hidden_layer = nn.LayerList([nn.Linear(in_features=1, out_features=out_features)])
            self.hidden_layers_list.append(hidden_layer)
        feature_size, hidden_size = len(FEATURE_LIST), len(FEATURE_LIST)
        self.gru = nn.GRU(input_size=out_features, hidden_size=hidden_size, time_major=True, num_layers=2, direction="bidirect", dropout=0.2)
        out_layer1_in_features, out_layer1_out_features = feature_size+hidden_size*4, hidden_size
        self.out_layer1 = nn.Linear(in_features=out_layer1_in_features, out_features=out_layer1_out_features)
        self.out_layer2 = nn.Linear(in_features=out_layer1_out_features, out_features=2)
        self.softmax = nn.Softmax()    def forward(self, X):
        layerList = []        for x, hidden_layers in zip(X, self.hidden_layers_list):            for hidden_layer in hidden_layers:
                x = hidden_layer(x)            # 将[batch_size, 1, out_features] 转为 [batch_size, out_features]
            layerList.append(tensor.flatten(x, start_axis=1))        # 在0维扩展维度
        X = tensor.stack(layerList, 0)  # [time_step, batch_size, vector_size]
        # 送入GRU，将每个batch的输出拼成向量
        out, hc = self.gru(X)
        out = out[:, :, -1].transpose((1, 0)).unsqueeze(0)        # 合并
        y = tensor.concat(list(out)+list(hc), axis=1)        # 把特征放入用于输出层的网络
        y = self.out_layer1(y)
        y = self.out_layer2(y)
        y = self.softmax(y)        # 返回分类结果
        return y