召回集读取与推荐中心对接

最新推荐文章于 2023-01-30 07:41:48 发布
最新推荐文章于 2023-01-30 07:41:48 发布
阅读量1.2k 收藏
点赞数
分类专栏： 人工智能 个性化推荐系统 文章标签： 人工智能 推荐系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zimiao552147572/article/details/106857631
版权

日萌社

人工智能AI：Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战（不定时更新）

5.5 召回集读取与推荐中心对接

学习目标

  • 目标
    • 无
  • 应用
    • 无

5.5.1 召回集读取服务

  • 召回读取服务
    • 添加一个召回集的结果读取服务recall_service.py

5.5.2 多路召回结果读取

  • 目的：读取离线和在线存储的召回结果

    • hbase的存储：cb_recall, als, content, online

  • 步骤：

    • 1、初始化redis,hbase相关工具
    • 2、在线画像召回，离线画像召回，离线协同召回数据的读取
    • 3、redis新文章和热门文章结果读取
    • 4、相似文章读取接口

初始化redis,hbase相关工具

import os
import sys
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, os.path.join(BASE_DIR))

from server import redis_client
from server import pool
import logging
from datetime import datetime
from server.utils import HBaseUtils

logger = logging.getLogger('recommend')


class ReadRecall(object):
    """读取召回集的结果
    """
    def __init__(self):
        self.client = redis_client
        self.hbu = HBaseUtils(pool)

在init文件中添加相关初始化数据库变量

import redis
import happybase
from setting.default import DefaultConfig
from pyspark import SparkConf
from pyspark.sql import SparkSession


pool = happybase.ConnectionPool(size=10, host="hadoop-master", port=9090)

# 加上decode_responses=True，写入的键值对中的value为str类型，不加这个参数写入的则为字节类型。
redis_client = redis.StrictRedis(host=DefaultConfig.REDIS_HOST,
                                 port=DefaultConfig.REDIS_PORT,
                                 db=10,
                                 decode_responses=True)

2、在线画像召回，离线画像召回，离线协同召回数据的读取

  • 读取用户的指定列族的召回数据，并且读取之后要删除原来的推荐召回结果'cb_recall'
    def read_hbase_recall_data(self, table_name, key_format, column_format):
        """
        读取cb_recall当中的推荐数据
        读取的时候可以选择列族进行读取als, online, content

        :return:
        """
        recall_list = []
        try:
            data = self.hbu.get_table_cells(table_name, key_format, column_format)

            # data是多个版本的推荐结果[[],[],[],]
            for _ in data:
                recall_list = list(set(recall_list).union(set(eval(_))))

            # self.hbu.get_table_delete(table_name, key_format, column_format)
        except Exception as e:
            logger.warning("{} WARN read {} recall exception:{}".format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                                                                     table_name, e))
        return recall_list

测试：

if __name__ == '__main__':
    rr = ReadRecall()
    # 召回结果的读取封装
    print(rr.read_hbase_recall_data('cb_recall', b'recall:user:1114864874141253632', b'als:18'))

3、redis新文章和热门文章结果读取

    def read_redis_new_article(self, channel_id):
        """
        读取新闻章召回结果
        :param channel_id: 提供频道
        :return:
        """
        logger.warning("{} WARN read channel {} redis new article".format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                                                                 channel_id))
        _key = "ch:{}:new".format(channel_id)
        try:
            res = self.client.zrevrange(_key, 0, -1)
        except Exception as e:
            logger.warning("{} WARN read new article exception:{}".format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'), e))
            res = []

        return list(map(int, res))

热门文章读取:热门文章记录了很多，可以选取前K个

    def read_redis_hot_article(self, channel_id):
        """
        读取新闻章召回结果
        :param channel_id: 提供频道
        :return:
        """
        logger.warning("{} WARN read channel {} redis hot article".format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'), channel_id))
        _key = "ch:{}:hot".format(channel_id)
        try:
            res = self.client.zrevrange(_key, 0, -1)

        except Exception as e:
            logger.warning("{} WARN read new article exception:{}".format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'), e))
            res = []

        # 由于每个频道的热门文章有很多，因为保留文章点击次数
        res = list(map(int, res))
        if len(res) > self.hot_num:
            res = res[:self.hot_num]
        return res

测试：

print(rr.read_redis_new_article(18))
print(rr.read_redis_hot_article(18))

4、相似文章读取接口

最后相似文章读取接口代码

  • 会有接口获取固定的文章数量(用在头条APP中的猜你喜欢接口)
    def read_hbase_article_similar(self, table_name, key_format, article_num):
        """获取文章相似结果
        :param article_id: 文章id
        :param article_num: 文章数量
        :return:
        """
        # 第一种表结构方式测试：
        # create 'article_similar', 'similar'
        # put 'article_similar', '1', 'similar:1', 0.2
        # put 'article_similar', '1', 'similar:2', 0.34
        try:
            _dic = self.hbu.get_table_row(table_name, key_format)

            res = []
            _srt = sorted(_dic.items(), key=lambda obj: obj[1], reverse=True)
            if len(_srt) > article_num:
                _srt = _srt[:article_num]
            for _ in _srt:
                res.append(int(_[0].decode().split(':')[1]))
        except Exception as e:
            logger.error(
                "{} ERROR read similar article exception: {}".format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'), e))
            res = []
        return res

测试：

print(rr.read_hbase_article_similar('article_similar', b'116644', 10))

完整代码：

import os
import sys
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, os.path.join(BASE_DIR))

from server import redis_client
from server import pool
import logging
from datetime import datetime
from server.utils import HBaseUtils

logger = logging.getLogger('recommend')


class ReadRecall(object):
    """读取召回集的结果
    """
    def __init__(self):
        self.client = redis_client
        self.hbu = HBaseUtils(pool)

    def read_hbase_recall_data(self, table_name, key_format, column_format):
        """获取指定用户的对应频道的召回结果,在线画像召回，离线画像召回，离线协同召回
        :return:
        """
        # 获取family对应的值
        # 数据库中的键都是bytes类型，所以需要进行编码相加
        # 读取召回结果多个版本合并
        recall_list = []
        try:

            data = self.hbu.get_table_cells(table_name, key_format, column_format)
            for _ in data:
                recall_list = list(set(recall_list).union(set(eval(_))))

            # 读取所有这个用户的在线推荐的版本，清空该频道的数据
            # self.hbu.get_table_delete(table_name, key_format, column_format)
        except Exception as e:
            logger.warning(
                "{} WARN read recall data exception:{}".format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'), e))
        return recall_list

    def read_redis_new_data(self, channel_id):
        """获取redis新文章结果
        :param channel_id:
        :return:
        """
        # format结果
        logger.info("{} INFO read channel:{} new recommend data".format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'), channel_id))
        _key = "ch:{}:new".format(channel_id)
        try:
            res = self.client.zrevrange(_key, 0, -1)
        except redis.exceptions.ResponseError as e:
            logger.warning("{} WARN read new article exception:{}".format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'), e))
            res = []
        return list(map(int, res))

    def read_redis_hot_data(self, channel_id):
        """获取redis热门文章结果
        :param channel_id:
        :return:
        """
        # format结果
        logger.info("{} INFO read channel:{} hot recommend data".format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'), channel_id))
        _key = "ch:{}:hot".format(channel_id)
        try:
            _res = self.client.zrevrange(_key, 0, -1)
        except redis.exceptions.ResponseError as e:
            logger.warning("{} WARN read hot article exception:{}".format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'), e))
            _res = []
        # 每次返回前50热门文章
        res = list(map(int, _res))
        if len(res) > 50:
            res = res[:50]
        return res

    def read_hbase_article_similar(self, table_name, key_format, article_num):
        """获取文章相似结果
        :param article_id: 文章id
        :param article_num: 文章数量
        :return:
        """
        # 第一种表结构方式测试：
        # create 'article_similar', 'similar'
        # put 'article_similar', '1', 'similar:1', 0.2
        # put 'article_similar', '1', 'similar:2', 0.34
        try:
            _dic = self.hbu.get_table_row(table_name, key_format)

            res = []
            _srt = sorted(_dic.items(), key=lambda obj: obj[1], reverse=True)
            if len(_srt) > article_num:
                _srt = _srt[:article_num]
            for _ in _srt:
                res.append(int(_[0].decode().split(':')[1]))
        except Exception as e:
            logger.error("{} ERROR read similar article exception: {}".format(datetime.now().strftime('%Y-%m-%d %H:%M:%S'), e))
            res = []
        return res


if __name__ == '__main__':

    rr = ReadRecall()
    print(rr.read_hbase_article_similar('article_similar', b'13342', 10))
    print(rr.read_hbase_recall_data('cb_recall', b'recall:user:1115629498121846784', b'als:18'))

    # rr = ReadRecall()
    # print(rr.read_redis_new_data(18))

5.5.3 推荐中心---获取多路召回结果，过滤历史推荐记录逻辑

  • 目的：在推荐中加入召回文章结果以及过滤逻辑

  • 步骤：

    • 1、循环算法组合参数，遍历不同召回结果进行过滤

    • 2、过滤当前该请求频道推荐历史结果，需要过滤0频道推荐结果，防止出现推荐频道与25个频道有重复推荐

    • 3、过滤之后，推荐出去指定个数的文章列表，写入历史记录，剩下多的写入待推荐结果

      • wait_recommend: 经过各种多路召回，排序之后的待推荐结果缓存保存

        • 只要刷新一次，没有缓存，才主动收集各种召回集合一起给wait_recommend写入，所以不用设置多个版本
      • create 'wait_recommend', 'channel'

put 'wait_recommend', 'reco:1', 'channel:18', [17283, 140357, 14668, 15182, 17999, 13648, 12884, 17302, 13846, 18135]
put 'wait_recommend', 'reco:1', 'channel:0', [17283, 140357, 14668, 15182, 17999, 13648, 12884, 17302, 13846, 18135]

定义一个user_reco_list函数中实现读取用户的召回结果。

  • 1、循环算法组合参数，遍历不同召回结果进行过滤
# 所有合并的结果
        reco_set = []
        # -  1、循环算法组合参数，遍历不同召回结果合并，18
        for _num in RAParam.COMBINE[temp.algo][1]:
            if _num == 103:
                # 读取新文章的结果，temp.channel_id
                _res = self.recall_service.read_redis_new_article(temp.channel_id)
                reco_set = list(set(reco_set).union(set(_res)))
            elif _num == 104:
                # 读取热门文章的数据
                _res = self.recall_service.read_redis_hot_article(temp.channel_id)
                reco_set = list(set(reco_set).union(set(_res)))
            else:
                # 读取具体编号的对应表cb_recall,对应召回算法的召回结果als, content, online
                _res = self.recall_service.\
                    read_hbase_recall_data(RAParam.RECALL[_num][0],
                                           'recall:user:{}'.format(temp.user_id).encode(),
                                           '{}:{}'.format(RAParam.RECALL[_num][1], temp.channel_id).encode())
                reco_set = list(set(reco_set).union(set(_res)))
  • 2、过滤当前该请求频道推荐历史结果，如果不是0频道需要过滤0频道推荐结果，防止出现
    • 比如Python频道和0频道相同的推荐结果
# - 2、过滤，该请求频道(18)的历史推荐记录过滤），推荐频道0频道
        #   - 0：APP  推荐(循环所有的频道召回结果)，0 频道也有历史记录
        # temp.channel_id频道这个用户历史记录进行过滤
        history_list = []

        try:
            data = self.hbu.get_table_cells('history_recommend',
                                            'reco:his:{}'.format(temp.user_id).encode(),
                                            'channel:{}'.format(temp.channel_id).encode())
            for _ in data:
                history_list = list(set(history_list).union(set(eval(_))))

            logger.info("{} INFO read user_id:{} channel_id:{} history data".format(
                datetime.now().strftime('%Y-%m-%d %H:%M:%S'), temp.user_id, temp.channel_id))

        except Exception as e:
            # 打印日志
            logger.warning(
                "{} WARN filter history article exception:{}".format(datetime.now().
                                                                     strftime('%Y-%m-%d %H:%M:%S'), e))
        # 获取0频道的结果
        try:
            data = self.hbu.get_table_cells('history_recommend',
                                            'reco:his:{}'.format(temp.user_id).encode(),
                                            'channel:{}'.format(0).encode())
            for _ in data:
                history_list = list(set(history_list).union(set(eval(_))))
            logger.info("{} INFO filter user_id:{} channel:{} history data".format(
                datetime.now().strftime('%Y-%m-%d %H:%M:%S'), temp.user_id, 0))

        except Exception as e:
            logger.warning(
                "{} WARN filter history article exception:{}".format(datetime.now().
                                                                     strftime('%Y-%m-%d %H:%M:%S'), e))

        reco_set = list(set(reco_set).difference(set(history_list)))
  • 3、过滤之后，推荐出去指定个数的文章列表，写入历史记录，剩下多的写入待推荐结果
# - 4、返回结果：
        if not reco_set:
            return reco_set
        else:
            # - 如果有数据，小于需要推荐文章的数量N之后，放入历史推荐记录中history_recommend，返回结果给用
            if len(reco_set) <= temp.article_num:
                res = reco_set
            else:
                #   - 如果有，350篇，取出N个，进行返回推荐，放入历史记录history_recommend
                #     - (350- N)个文章，放入wait_recommend
                res = reco_set[:temp.article_num]

                logger.info(
                    "{} INFO put user_id:{} channel:{} wait data".format(
                        datetime.now().strftime('%Y-%m-%d %H:%M:%S'), temp.user_id, temp.channel_id))

                # 放入剩下多余的数据到wait_recommend当中
                self.hbu.get_table_put('wait_recommend',
                                       'reco:{}'.format(temp.user_id).encode(),
                                       'channel:{}'.format(temp.channel_id).encode(),
                                       str(reco_set[temp.article_num:]).encode(),
                                       timestamp=temp.time_stamp)

            # 放入历史记录
            self.hbu.get_table_put('history_recommend',
                                   'reco:his:{}'.format(temp.user_id).encode(),
                                   'channel:{}'.format(temp.channel_id).encode(),
                                   str(res).encode(),
                                   timestamp=temp.time_stamp)
            # 放入历史记录日志
            logger.info(
                "{} INFO store recall/sorted user_id:{} channel:{} history_recommend data".format(
                    datetime.now().strftime('%Y-%m-%d %H:%M:%S'), temp.user_id, temp.channel_id))

            return res

修改调用读取召回数据的部分

# 2、不开启缓存
res = self.user_reco_list(temp)
temp.time_stamp = int(last_stamp)
track = add_track(res, temp)

运行grpc服务之后，测试结果

hbase(main):007:0> get "history_recommend", 'reco:his:1115629498121846784', {COLUMN=>'channel:18',VERSIONS=>1000}
COLUMN                     CELL                                                                        
 channel:18                timestamp=1558189615378, value=[13890, 14915, 13891, 15429, 15944, 44371, 18
                           005, 15196, 13410, 13672]                                                   
 channel:18                timestamp=1558189317342, value=[17966, 17454, 14125, 16174, 14899, 44339, 16
                           437, 18743, 44090, 18238]                                                   
 channel:18                timestamp=1558143073173, value=[19200, 17665, 16151, 16411, 19233, 13090, 15
                           140, 16421, 19494, 14381]

待推荐表中有

hbase(main):008:0> scan 'wait_recommend'
ROW                        COLUMN+CELL                                                                 
 reco:1115629498121846784  column=channel:18, timestamp=1558189615378, value=[44137, 18795, 19052, 4465
                           2, 44654, 44657, 14961, 17522, 43894, 44412, 16000, 14208, 44419, 17802, 142
                           23, 18836, 140956, 18335, 13728, 14498, 44451, 44456, 18609, 18353, 44468, 1
                           8103, 135869, 16062, 14015, 13757, 13249, 44483, 17605, 14021, 15309, 18127,
                            43983, 44754, 43986, 19413, 14805, 18904, 44761, 17114, 13272, 14810, 18907
                           , 13022, 14300, 17120, 17632, 14299, 43997, 17889, 17385, 18156, 15085, 1329
                           5, 44020, 14839, 44024, 14585, 18172, 44541]

完整代码：

    def user_reco_list(self, temp):
        """
        获取用户的召回结果进行推荐
        :param temp:
        :return:
        """
        reco_set = []
        # 1、循环算法组合参数，遍历不同召回结果进行过滤
        for _num in RAParam.COMBINE[temp.algo][1]:
            # 进行每个召回结果的读取100,101,102,103,104
            if _num == 103:
                # 新文章召回读取
                _res = self.recall_service.read_redis_new_article(temp.channel_id)
                reco_set = list(set(reco_set).union(set(_res)))
            elif _num == 104:
                # 热门文章召回读取
                _res = self.recall_service.read_redis_hot_article(temp.channel_id)
                reco_set = list(set(reco_set).union(set(_res)))
            else:
                _res = self.recall_service.\
                    read_hbase_recall_data(RAParam.RECALL[_num][0],
                                           'recall:user:{}'.format(temp.user_id).encode(),
                                           '{}:{}'.format(RAParam.RECALL[_num][1], temp.channel_id).encode())
                # 进行合并某个协同过滤召回的结果
                reco_set = list(set(reco_set).union(set(_res)))

        # reco_set都是新推荐的结果，进行过滤
        history_list = []
        try:
            data = self.hbu.get_table_cells('history_recommend',
                                            'reco:his:{}'.format(temp.user_id).encode(),
                                            'channel:{}'.format(temp.channel_id).encode())
            for _ in data:
                history_list = list(set(history_list).union(set(eval(_))))

            logger.info("{} INFO filter user_id:{} channel:{} history data".format(
                datetime.now().strftime('%Y-%m-%d %H:%M:%S'), temp.user_id, temp.channel_id))
        except Exception as e:
            logger.warning(
                "{} WARN filter history article exception:{}".format(datetime.now().
                                                                     strftime('%Y-%m-%d %H:%M:%S'), e))

        # 如果0号频道有历史记录，也需要过滤

        try:
            data = self.hbu.get_table_cells('history_recommend',
                                            'reco:his:{}'.format(temp.user_id).encode(),
                                            'channel:{}'.format(0).encode())
            for _ in data:
                history_list = list(set(history_list).union(set(eval(_))))

            logger.info("{} INFO filter user_id:{} channel:{} history data".format(
                datetime.now().strftime('%Y-%m-%d %H:%M:%S'), temp.user_id, 0))
        except Exception as e:
            logger.warning(
                "{} WARN filter history article exception:{}".format(datetime.now().
                                                                     strftime('%Y-%m-%d %H:%M:%S'), e))

        # 过滤操作 reco_set 与history_list进行过滤
        reco_set = list(set(reco_set).difference(set(history_list)))

        # 排序代码逻辑
        # _sort_num = RAParam.COMBINE[temp.algo][2][0]
        # reco_set = sort_dict[RAParam.SORT[_sort_num]](reco_set, temp, self.hbu)

        # 如果没有内容，直接返回
        if not reco_set:
            return reco_set
        else:

            # 类型进行转换
            reco_set = list(map(int, reco_set))

            # 跟后端需要推荐的文章数量进行比对 article_num
            # article_num > reco_set
            if len(reco_set) <= temp.article_num:
                res = reco_set
            else:
                # 之取出推荐出去的内容
                res = reco_set[:temp.article_num]
                # 剩下的推荐结果放入wait_recommend等待下次帅新的时候直接推荐
                self.hbu.get_table_put('wait_recommend',
                                       'reco:{}'.format(temp.user_id).encode(),
                                       'channel:{}'.format(temp.channel_id).encode(),
                                       str(reco_set[temp.article_num:]).encode(),
                                       timestamp=temp.time_stamp)
                logger.info(
                    "{} INFO put user_id:{} channel:{} wait data".format(
                        datetime.now().strftime('%Y-%m-%d %H:%M:%S'), temp.user_id, temp.channel_id))

            # 放入历史记录表当中
            self.hbu.get_table_put('history_recommend',
                                   'reco:his:{}'.format(temp.user_id).encode(),
                                   'channel:{}'.format(temp.channel_id).encode(),
                                   str(res).encode(),
                                   timestamp=temp.time_stamp)
            # 放入历史记录日志
            logger.info(
                "{} INFO store recall/sorted user_id:{} channel:{} history_recommend data".format(
                    datetime.now().strftime('%Y-%m-%d %H:%M:%S'), temp.user_id, temp.channel_id))

            return res

あずにゃん
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
java代码-获取channelId前缀
07-14
java代码-获取channelId前缀
关于多参数查询使用@param注解的注意事项。
weixin_45341014的博客
05-28 3481
开发中突然遇到一个问题@Param注解 百思不得其解，找百度小哥，查了好久，实验了一波，终于解决了。 问题描述：在查询的时候，多参数查询，使用（String a,String b）的模式，去查询，查询的时候，报下面的错： “error”: “Internal Server Error”, “message”: “nested exception is org.apache.ibatis.binding.BindingException: Parameter ‘_acct_status’ n
channel_id以及type_id的内容
aoqiaotan2763的博客
03-13 2229
转载于:https://www.cnblogs.com/superAnny/p/6542724.html
友盟统计动态设置渠道参数channelId
热门推荐
BOBO_FAS的博客
03-29 2万+
String channelId = null; try { ApplicationInfo applicationInfo = getApplicationContext().getPackageManager().getApplicationInfo(getPackageName(), PackageManager.GET_META_DATA);
YSDK 系列问题之如何获取渠道号ChannelID
weixin_34220623的博客
08-28 3116
转载请标明出处： http://blog.csdn.net/DJY1992/article/details/77649400 本文出自:【奥特曼超人的博客】 不懂的可以点击加入 安卓移动技术精英群： 最近有个游戏不兼容YSDK1.2.2 ，而且由于业务需求也需要升级新的YSDK了，在新的版本上也需要channel的需求...
基于Python个性化礼物推荐系统的设计与实现.zip
10-16
《基于Python个性化礼物推荐系统的设计与实现》是一个深入探讨如何利用Python编程语言构建一个能够根据用户喜好进行个性化推荐的礼物系统的项目。在这个项目中，我们将深入理解推荐系统的基本原理，学习如何利用...
自动化药房系统开发与应用.rar
09-20
7. **集成能力**：自动化药房系统通常与医院的电子病历系统（EMR）、实验室信息系统（LIS）等其他医疗信息系统无缝对接，实现数据共享，提高整体医疗服务效率。 8. **培训与支持**：系统的用户界面设计简洁，易于...
医疗器械唯一标识UDI与自动化生产.rar
09-20
其次，工厂信息化系统需要升级，以处理和存储UDI数据，并与上下游供应链进行无缝对接。最后，企业需要培训员工，使他们熟悉UDI系统，确保其在日常操作中的正确使用。 总的来说，UDI与自动化生产的结合，不仅提高了...
电信设备-基于RFID的香精香料信息校验系统.zip
09-18
1. **自动识别与追踪**：RFID读取器可以无接触地批量读取多个标签，实时监控香精香料的库存状态，确保货物的准确出入库。 2. **信息校验**：系统对接后台数据库，对RFID标签上的信息进行比对校验，防止假冒伪劣产品...
libsvm分类训练和测试数据语料
11-02
这个压缩包包含了用于训练和测试SVM模型的数据集，这些数据按照libsvm所规定的特定格式组织，方便与libsvm工具进行无缝对接。 在机器学习领域，SVM是一种强大的监督学习算法，它被广泛应用于分类和回归问题。SVM...
seata clientID 及channel选择
weixin_40455124的博客
10-03 2372
seata TC 给每个客户端(TM及RM)都会编一个ID,这个ID是在TC端根据RPC context来设置的，无法自行设置，具体相关代码如下： private static String buildClientId(String applicationId, Channel channel) { return applicationId + Constants.CLIENT_I...
${param.id}的使用
F的博客
03-31 647
若有a.jsp页面携带参数id，经过控制器跳转到b.jsp，在b.jsp页面可以使用${param.id}取得该id 相当于request.getParameter("id");
Facebook Java爬虫获取视频数据
zzz_zjz的博客
06-14 4620
前言部分 前置说明 ​ 截止到本文发表前，该爬虫方法因为htmlunit的问题，已经无法正常运行，由于本人后续不再维护相关功能，所以不会修复此问题。如果是迫切需要解决方案的读者可以忽略本文，寻求其它解决方案。如果对此 方案略感兴趣，可以阅读源码和方法进行参考。 ​ 另笔者并不是专业爬虫开发，因此本文是以Java开发尝试实现的一个简单程序。使用到的工具为htmlunit + jsoup。该方案，主要实现的功能是：获取到指定频道下的所有视频的详细信息（并不下载视频文件）。获取到的数据结构如下所示（部分长数据
netty的channel配置参数详解
WillPan1234的博客
02-28 2万+
参考开源项目常用配置:http://www.programcreek.com/java-api-examples/index.php?api=io.netty.channel.ChannelOption (1).通用参数 CONNECT_TIMEOUT_MILLIS   Netty参数，连接超时毫秒数，默认值30000毫秒即30秒。 MAX_MESSAGES_PER_READ   N
WiFi无线通信
sqhone的博客
02-19 3751
本文基于平头哥RVB2601开发板，介绍WiFi无线网络环境中获取本机 IP，建立tcp连接，作为TCPClient和远端TCPServer互传数据
推荐系统之召回集读取服务
最新发布
weixin_43894652的博客
01-30 333
热门文章读取:热门文章记录了很多，可以选取前K个。在init文件中添加相关初始化数据库变量。初始化redis,hbase相关工具。目的：读取离线和在线存储的召回结果。并且添加了获取结果打印日志设置。最后相似文章读取接口代码。
Oracle分隔符x01,【学习笔记】Oracle优化之星形查询star transformation query教程
weixin_36399948的博客
04-09 727
【学习笔记】Oracle优化之星形查询star transformation query教程时间:2016-12-22 22:05来源:Oracle研究中心作者:网络点击:次天萃荷净Oracle研究中心学习笔记：分享一篇关于Oracle star transformation query星形查询的文章这里，我们介绍一下对于星型模式的一些调优思想。我们先来介绍一下关于星型模式的一些...
项目ITP(三) 玩玩 服务端 到 app端
weixin_34306446的博客
05-06 119
前言 　　系列文章：[传送门] 　　泡泡脚，写写博客，规律生活，睡个好觉，待会看会书。   正文  　　上面讲了二维码生成，及 手机端扫一扫，大家有兴趣去看看。 　　今天我们讲一下，百度云推送平台。 　　每天想着问题，问题只会慢慢的清晰。想着想着，慢慢模式就出来了。 模式 　　　　　　　　　　 　　　　　　　　　　　　　　　　　　　　推送交互模式 　　①② 所指的是学生群体 ...
采用Redis统计客户端在线用户——从redis-server获取数据展示到html页面
Poison_biting的专栏
04-08 2295
描述：在客户端对redis-server写数据，这边博客介绍把数据统计成曲线图，更直观的统计出来。 后端采用python读取redis-server数据（用hgetall（key）函数,这儿的key是按月获取，获取一整月的数据。例如“2018-04”） 采用python的flask框架，实现交互；html页面采用ajax接受后台json数据；曲线图利用echarts绘制。 需用的工具：安装fla...
飞猪旅行推荐系统的召回策略与实践
飞猪个性化推荐小组在此领域进行了深入研究，面对的挑战包括冷启动用户、行程表达与召回、基于用户行为的召回以及周期性复购的召回。 首先，对于**冷启动用户**，由于缺乏历史行为数据，推荐系统往往难以构建准确的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

あずにゃん

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值