spring boot项目基于mahout推荐算法实现商品推荐

已于 2022-12-07 17:57:20 修改
阅读量4.5k 收藏 93
点赞数 18
分类专栏： JAVA 文章标签： 推荐算法 java 算法
于 2022-12-07 17:54:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/listenFen/article/details/128224294
版权

项目需求

当前正在开发一款电商app，优化需求中有“猜你喜欢"这样的功能。其本质就是基于用户对商品的操作行为寻找到与这个用户类似的一些用户，并把这些用户的一些当前用户没有接触过或者说操作过的商品推荐给用户，经过寻找，我发现mahout推荐引擎比较符合我的开发需求。

代码

我在查询了多个博客以后，终于汇总出了适合我的使用场景的集成mahout的代码，并且做了组件化调整，相关的代码如下
依赖：

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.7.5</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3.4</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!-- 数据库驱动mariadb -->
        <dependency>
            <groupId>org.mariadb.jdbc</groupId>
            <artifactId>mariadb-java-client</artifactId>
            <version>2.7.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.mahout</groupId>
            <artifactId>mahout-mr</artifactId>
            <version>0.12.2</version>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-api</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-jcl</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.apache.lucene</groupId>
                    <artifactId>lucene-core</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.apache.lucene</groupId>
                    <artifactId>lucene-analyzers-common</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
                <exclusion>
                    <artifactId>jersey-client</artifactId>
                    <groupId>com.sun.jersey</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>jersey-core</artifactId>
                    <groupId>com.sun.jersey</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>jersey-apache-client4</artifactId>
                    <groupId>com.sun.jersey.contribs</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.7.18</version>
        </dependency>
        <!-- swagger3-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-boot-starter</artifactId>
            <version>3.0.0</version>
        </dependency>
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>knife4j-spring-boot-starter</artifactId>
            <version>3.0.3</version>
            <exclusions>
                <exclusion>
                    <artifactId>swagger-models</artifactId>
                    <groupId>io.swagger</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>swagger-annotations</artifactId>
                    <groupId>io.swagger</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>guava</artifactId>
                    <groupId>com.google.guava</groupId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

推荐组件代码：


import com.example.mahoutdemo.config.FilterRescorer;
import com.example.mahoutdemo.utils.RecommendPreference;
import lombok.extern.slf4j.Slf4j;
import org.apache.mahout.cf.taste.common.Refreshable;
import org.apache.mahout.cf.taste.common.TasteException;
import org.apache.mahout.cf.taste.eval.IRStatistics;
import org.apache.mahout.cf.taste.eval.RecommenderBuilder;
import org.apache.mahout.cf.taste.eval.RecommenderEvaluator;
import org.apache.mahout.cf.taste.eval.RecommenderIRStatsEvaluator;
import org.apache.mahout.cf.taste.impl.common.FastByIDMap;
import org.apache.mahout.cf.taste.impl.eval.AverageAbsoluteDifferenceRecommenderEvaluator;
import org.apache.mahout.cf.taste.impl.eval.GenericRecommenderIRStatsEvaluator;
import org.apache.mahout.cf.taste.impl.eval.RMSRecommenderEvaluator;
import org.apache.mahout.cf.taste.impl.model.GenericDataModel;
import org.apache.mahout.cf.taste.impl.model.GenericPreference;
import org.apache.mahout.cf.taste.impl.model.GenericUserPreferenceArray;
import org.apache.mahout.cf.taste.impl.neighborhood.NearestNUserNeighborhood;
import org.apache.mahout.cf.taste.impl.neighborhood.ThresholdUserNeighborhood;
import org.apache.mahout.cf.taste.impl.recommender.GenericBooleanPrefItemBasedRecommender;
import org.apache.mahout.cf.taste.impl.recommender.GenericBooleanPrefUserBasedRecommender;
import org.apache.mahout.cf.taste.impl.recommender.GenericItemBasedRecommender;
import org.apache.mahout.cf.taste.impl.recommender.GenericUserBasedRecommender;
import org.apache.mahout.cf.taste.impl.similarity.*;
import org.apache.mahout.cf.taste.model.DataModel;
import org.apache.mahout.cf.taste.model.PreferenceArray;
import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood;
import org.apache.mahout.cf.taste.recommender.RecommendedItem;
import org.apache.mahout.cf.taste.similarity.ItemSimilarity;
import org.apache.mahout.cf.taste.similarity.UserSimilarity;
import org.springframework.lang.NonNull;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Slf4j
public class Recommender {

    private final DataModel dataModel;

    private Recommender(DataModel dataModel) {
        this.dataModel = dataModel;
    }

    public static Recommender build(List<? extends RecommendPreference> preferenceList) {
        DataModel model = buildJdbcDataModel(preferenceList);
        return new Recommender(model);
    }

    /**
     * dataModel 有两种结构：
     * GenericDataModel: 用户ID，物品ID，用户对物品的打分(UserID,ItemID,PreferenceValue)
     * GenericBooleanPrefDataModel: 用户ID，物品ID (UserID,ItemID)，这种方式表达用户是否浏览过该物品，但并未对物品进行打分。
     * 因为系统需要根据用户行为或评分进行推荐所以使用GenericDataModel
     * @param preferenceList 用户行为或评分集合
     * @return DataModel
     */
    private static DataModel buildJdbcDataModel(List<? extends RecommendPreference> preferenceList) {
        FastByIDMap<PreferenceArray> fastByIdMap = new FastByIDMap<>();
        Map<Long, List<RecommendPreference>> map = preferenceList.stream().collect(Collectors.groupingBy(RecommendPreference::getUserId));
        Collection<List<RecommendPreference>> list = map.values();
        for (List<RecommendPreference> preferences : list) {
            GenericPreference[] array = new GenericPreference[preferences.size()];
            for (int i = 0; i < preferences.size(); i++) {
                RecommendPreference preference = preferences.get(i);
                GenericPreference item = new GenericPreference(preference.getUserId(), preference.getItemId(), preference.getValue());
                array[i] = item;
            }
            fastByIdMap.put(array[0].getUserID(), new GenericUserPreferenceArray(Arrays.asList(array)));
        }
        return new GenericDataModel(fastByIdMap);
    }

    /**
     * 创建基于用户的推荐器
     *
     * @param similarityType 相似度算法类型
     * @return UserBaseRecommender
     */
    public UserBaseRecommender userBaseRecommender(String similarityType) throws TasteException {

        return new UserBaseRecommender(similarityType);
    }

    /**
     * 创建基于物品的推荐器
     *
     * @param similarityType 相似度算法类型
     * @return UserBaseRecommender
     */
    public ItemBaseRecommender itemBaseRecommender(String similarityType) throws TasteException {

        return new ItemBaseRecommender(similarityType);
    }

    public class UserBaseRecommender {

        private final UserSimilarity similarity;

        private UserNeighborhood neighborhood;

        public UserBaseRecommender(String similarity) throws TasteException {
            this.similarity = userSimilarity(similarity, dataModel);
        }

        private UserSimilarity userSimilarity(String type, DataModel m) throws TasteException {
            return (UserSimilarity) getSimilarity(type, m);
        }

        /**
         * 计算最近邻域 基于固定数量的邻居,对每个用户取固定数量N个最近邻居
         *
         * @param num  固定邻居数量
         * @return UserNeighborhood
         */
        public UserRecommenderBuilder nearestUserNeighborhood(int num) throws TasteException {
            neighborhood = new NearestNUserNeighborhood(num, similarity, dataModel);
            return new UserRecommenderBuilder(similarity,neighborhood);
        }
        /**
         * 计算最近邻域 基于相似度,对每个用户基于一定的限制，取落在相似度限制以内的所有用户为邻居
         *
         * @param num  最低相似度
         * @return UserNeighborhood
         */
        public UserRecommenderBuilder thresholdUserNeighborhood(double num) throws TasteException {
                    neighborhood = new ThresholdUserNeighborhood(num, similarity, dataModel);
            return new UserRecommenderBuilder(similarity,neighborhood);
        }


    }

    public class UserRecommenderBuilder {

        private final UserSimilarity similarity;

        private final UserNeighborhood neighborhood;

        private UserRecommenderBuilder(@NonNull UserSimilarity similarity, @NonNull UserNeighborhood neighborhood) {
            this.similarity = similarity;
            this.neighborhood = neighborhood;
        }

        /**
         * 获取基于用户的推荐器
         *
         * @param pref 是否需要首选,即偏好
         * @return RecommenderBuilder
         */
        public SimpleRecommender recommender(boolean pref) throws TasteException {
            return  new SimpleRecommender(pref
                    //基于用户的推荐引擎
                    ? model -> new GenericUserBasedRecommender(model, neighborhood, similarity)
                    //基于用户的无偏好值推荐引擎
                    : model -> new GenericBooleanPrefUserBasedRecommender(model, neighborhood, similarity));
        }
    }

    class ItemBaseRecommender {
        private final ItemSimilarity similarity;

        public ItemBaseRecommender(String similarity) throws TasteException {
            this.similarity = itemSimilarity(similarity, dataModel);
        }

        public ItemSimilarity itemSimilarity(String type, DataModel m) throws TasteException {
            return (ItemSimilarity) getSimilarity(type, m);
        }

        /**
         * 获取基于用户的推荐器
         *
         * @param pref 是否需要首选
         * @return RecommenderBuilder
         */
        public SimpleRecommender recommender(boolean pref) throws TasteException {
            return new SimpleRecommender(pref
                    //基于物品的推荐引擎
                    ? model -> new GenericItemBasedRecommender(model, similarity)
                    //基于物品的无偏好值推荐引擎
                    : model -> new GenericBooleanPrefItemBasedRecommender(model, similarity));
        }
    }

    private static Refreshable getSimilarity(String type, DataModel m) throws TasteException {
        switch (type) {
            case RecommenderConstants.SIMILARITY_PEARSON:
                return new PearsonCorrelationSimilarity(m);
            case RecommenderConstants.SIMILARITY_COSINE:
                return new UncenteredCosineSimilarity(m);
            case RecommenderConstants.SIMILARITY_TANIMOTO:
                return new TanimotoCoefficientSimilarity(m);
            case RecommenderConstants.SIMILARITY_LOGLIKELIHOOD:
                return new LogLikelihoodSimilarity(m);
            case RecommenderConstants.SIMILARITY_CITY_BLOCK:
                return new CityBlockSimilarity(m);
            case RecommenderConstants.SIMILARITY_SPEARMAN:
                return new SpearmanCorrelationSimilarity(m);
            case RecommenderConstants.SIMILARITY_EUCLIDEAN:
            default:
                return new SpearmanCorrelationSimilarity(m);
        }
    }

    public class SimpleRecommender {
        private final RecommenderBuilder builder;
        private final org.apache.mahout.cf.taste.recommender.Recommender recommender;

        private SimpleRecommender(RecommenderBuilder builder) throws TasteException {
            this.builder = builder;
            this.recommender = builder.buildRecommender(dataModel);
        }

        public List<RecommendedItem> recommend(long userId, int howMany) throws TasteException {
            return recommender.recommend(userId, howMany);
        }

        public List<RecommendedItem> recommend(long userId, int howMany, FilterRescorer rescorer) throws TasteException {
            return recommender.recommend(userId, howMany, rescorer);
        }
        /**
         * 计算用户的预测评分和实际评分之间的“均方根”差异。这是这个差值的平均值的平方根
         */
        public Evaluator rmsEvaluator() {
            return new Evaluator(builder, new RMSRecommenderEvaluator());
        }
        /**
         * 计算平均差值的比较器
         */
        public Evaluator averageAbsoluteDifferenceEvaluator() {
            return new Evaluator(builder, new AverageAbsoluteDifferenceRecommenderEvaluator());
        }
    }

    public class Evaluator {
        private final RecommenderBuilder builder;
        private final RecommenderEvaluator recommenderEvaluator;

        private Evaluator(RecommenderBuilder builder, RecommenderEvaluator recommenderEvaluator) {
            this.builder = builder;
            this.recommenderEvaluator = recommenderEvaluator;
        }

        /**
         * 推荐器进度评估，数值越低精度越高
         * 返回值越小，推荐算法越好，0是最低/最好的评估值，意味着完美匹配。
         * @param trainPt 培训数据占比
         */
        public double evaluate(double trainPt) throws TasteException {
            return recommenderEvaluator.evaluate(builder, null, dataModel, trainPt, 1.0);
        }

        public IRStatistics statsEvaluator(int topn) throws TasteException {
            RecommenderIRStatsEvaluator evaluator = new GenericRecommenderIRStatsEvaluator();
            return evaluator.evaluate(builder, null, dataModel, null, topn, GenericRecommenderIRStatsEvaluator.CHOOSE_THRESHOLD, 1.0);
        }
    }
}

public interface RecommendPreference {


    long getUserId();

    long getItemId();
    float getValue();
}

推荐相关常量：


public interface RecommenderConstants {
    /**
     * 皮尔森相似度算法
     *-原理：用来反映两个变量线性相关程度的统计量
     *-范围：[-1,1]，绝对值越大，说明相关性越强，负相关对于推荐的意义小。
     *-说明：1、 不考虑重叠的数量；
     * 2、 如果只有一项重叠，无法计算相似性（计算过程被除数有n-1）；
     * 3、 如果重叠的值都相等，也无法计算相似性（标准差为0，做除数）。
     * 该相似度并不是最好的选择，也不是最坏的选择，只是因为其容易理解，在早期研究中经常被提起。
     * 使用Pearson线性相关系数必须假设数据是成对地从正态分布中取得的，并且数据至少在逻辑范畴内必须是等间距的数据。
     * Mahout中，为皮尔森相关计算提供了一个扩展，通过增加一个枚举类型（Weighting）的参数来使得重叠数也成为计算相似度的影响因子。
     */
    String SIMILARITY_PEARSON = "pearson";
    /**
     * 欧氏距离相似度算法
     *-原理：利用欧式距离d定义的相似度s，s=1 / (1+d)。
     *-范围：[0,1]，值越大，说明d越小，也就是距离越近，则相似度越大。
     *-说明：同皮尔森相似度一样，该相似度也没有考虑重叠数对结果的影响，同样地，
     * Mahout通过增加一个枚举类型（Weighting）的参数来使得重叠数也成为计算相似度的影响因子。
     */
    String SIMILARITY_EUCLIDEAN = "euclidean";
    /**
     * 余弦相似度算法
     * 原理：多维空间两点与所设定的点形成夹角的余弦值。
     * 范围：[-1,1]，值越大，说明夹角越大，两点相距就越远，相似度就越小。
     * 说明：在数学表达中，如果对两个项的属性进行了数据中心化，计算出来的余弦相似度和皮尔森相似度是一样的，
     * 在mahout中，实现了数据中心化的过程，所以皮尔森相似度值也是数据中心化后的余弦相似度。
     * 另外在新版本中，Mahout提供了UncenteredCosineSimilarity类作为计算非中心化数据的余弦相似度。
     */
    String SIMILARITY_COSINE = "cosine";
    /**
     * Spearman秩相关系数相似度算法
     * 原理：Spearman秩相关系数通常被认为是排列后的变量之间的Pearson线性相关系数。
     * 范围：{-1.0,1.0}，当一致时为1.0，不一致时为-1.0。
     * 说明：计算非常慢，有大量排序。针对推荐系统中的数据集来讲，用Spearman秩相关系数作为相似度量是不合适的。
     */
    String SIMILARITY_SPEARMAN = "spearman";

    /**
     * 基于Manhattan距离相似度
     * 原理：曼哈顿距离的实现，同欧式距离相似，都是用于多维数据空间距离的测度
     * 范围：[0,1]，同欧式距离一致，值越小，说明距离值越大，相似度越大。
     * 说明：比欧式距离计算量少，性能相对高。
     */
    String SIMILARITY_CITY_BLOCK = "cityBlock";


    /**
     * 相似性,基于对数似然比的相似度
     * 原理：重叠的个数，不重叠的个数，都没有的个数
     * 范围：具体可去百度文库中查找论文《Accurate Methods for the Statistics of Surprise and Coincidence》
     * 说明：处理无打分的偏好数据，比Tanimoto系数的计算方法更为智能。
     */
    String SIMILARITY_LOGLIKELIHOOD = "loglikelihood";
    /**
     * 基于谷本系数计算相似度
     * 原理：又名广义Jaccard系数，是对Jaccard系数的扩展，等式为
     * 范围：[0,1]，完全重叠时为1，无重叠项时为0，越接近1说明越相似。
     * 说明：处理无打分的偏好数据。
     */
    String SIMILARITY_TANIMOTO = "tanimoto";
}

基于组件我做了一个简单的demo 从数据库中取数据，然后通过推荐引擎获取推荐数据
源码地址：https://gitee.com/fenglifei/mahout-demo.git

本文参考博客如下：
https://blog.csdn.net/u013473512/article/details/78694958
https://blog.csdn.net/czp11210/article/details/49813833
https://blog.csdn.net/weixin_59823583/article/details/127078413

listenFeng.
关注
  • 18
    点赞
  • 踩
  • 93
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot项目：基于推荐算法的景点攻略网站1rf50（java+VUE+Mybatis+Maven+Mysql）
蒋道理吧
07-30 313
springboot项目基于推荐算法的景点攻略网站1rf50（java+VUE+Mybatis+Maven+Mysql）Springboot+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。2.前端vue+css+javascript+jQuery+easyUI+highcharts。2.使用IDEA/Eclipse/MyEclipse导入项目，修改配置，运行项目；4.运行成功后，在浏览器中输入http//localhost8080/......
RS:基于SpringBoot，Mahout的推荐系统
05-17
RS 基于SpringBoot，Mahout的推荐系统 src / main / python / spiderman中的文件是网络爬虫，用于获取movieLens中电影的摘要和图片。一万部电影可能要花费几个小时的时间。它使用来自的代理池文本数据都可以在sql / Dump20180509中找到，图片可以在我的云磁盘链接中找到： ：//pan.baidu.com/s/1rcCQtQ7IgDoSyZN4djAP0w密码：h09q。 在sql / Dump20180509中运行文件以创建mysql表并将数据导入MySQL。 运行util / ImportMovies util / ImportRatings将数据从.csv导入mysql表 从下载mahout 0.13并导入到项目中 通过导入jars解决一些依赖性或BaiduNetdisk链接： ://pan.baidu.com/s/
基于协同过滤算法的商品推荐系统的设计与实现 springboot
05-10
开发语言：Java 框架：springboot JDK版本：JDK1.8 服务器：tomcat7 数据库：mysql 5.7（一定要5.7版本） 数据库工具：Navicat11 开发软件：eclipse/myeclipse/idea Maven包：Maven3.3.9 浏览器：谷歌浏览器 Java配置环境链接：https://pan.baidu.com/s/1Dzpiqb46mrukQzXOEj3otw 后台路径地址：localhost:8080/项目名称/admin/dist/index.html 前台路径地址：localhost:8080/项目名称/front/index.html （无前台不需要输入） 管理员账号：abo 管理员密码：abo 如果您要学会调试运行，一定要去看运行教学 springboot程序运行教学地址： 链接：https://pan.baidu.com/s/1qVMYZiJKYsw5DLuA30YDnQ 如果您想对系统多一些了解，一定要去看系统讲解 springboot系统逻辑讲解地址： 链接：ht
基于SpringBoot协同过滤算法商品推荐系统(源码+lw+部署文档+讲解等)
最新发布
程序员阿龙的博客
07-14 302
本次分享的是基于协同过滤算法的商品推荐系统，可以作为毕设设计参考，提供一些思路，有疑惑可以来咨询我！
基于SpringBoot+大数据+协同过滤推荐算法的电商商品推荐系统设计和实现(源码+LW+部署讲解)设计和实现(源码+LW+部署讲解)
java李阳勇的博客
07-02 1419
在当今互联网时代，随着电子商务的快速发展，各行各业都面临着海量数据的挑战和机遇，电子商务极大地改变了商业运作的方式，为消费者和企业带来了前所未有的便利和机会。该毕业设计以京东商品数据为来源，设计与实现基于大数据的电商商品推荐系统。通过对电商商品数据进行深度挖掘，可以发现消费趋势、产品热门度、价格以及地区差异等信息，为市场营销和产品策略提供重要参考。
spring-boot-starter-recommender:Spring Boot Starter，用于将Mahout用作基于项目的协作过滤的推荐引擎
05-19
spring-boot-starter-recommender Spring Boot Starter，用于将Mahout用作基于项目的协作过滤的推荐引擎。
毕业设计-SpringBoot-基于推荐算法的商城管理系统
weixin_45783387的博客
09-22 1496
环境：开发工具：idea，数据库：MySQL5.7 jdk1.8 架构：SpringBoot，前端HTML 主要功能 前台商城系统包含首页门户、商品分类、新品上线、首页轮播、商品推荐、商品搜索、商品展示、购物车、订单结算、订单流程、个人订单管理、会员中心、帮助中心等模块。 后台管理系统包含数据面板、轮播图管理、商品管理、订单管理、会员管理、分类管理、设置等模块。
Springboot+爬虫+推荐算法+前后端分离实现小说推荐系统
热门推荐
qq_2934918046的博客
05-19 4万+
如何针对互联网各大小说阅读网站的小说数据进行实时采集更新，建立自己的小说资源库，针对海量的小说数据开展标签处理特征分析，利用推荐算法完成针对用户的个性化阅读推荐？ 基于以上问题，本次小说推荐系统，建设过程主要分为小说推荐网站前端系统，小说运维管理后台系统，小说数据实时采集爬虫三个部分。小说推荐网站前端系统主要采用开源前端框架搭建小说推荐网站，提供用户登录注册，小说阅读等功能，小说运维管理后台，提供管理员用户使用完成系统内部小说，用户等数据的管理，小说数据采集爬虫支持各大小说阅读网站的内容采集及更新。 一、程
springboot集成mahout实现简单基于协同过滤算法的文章推荐算法
hwp_ing的博客
03-12 6915
我这里只是简单的跑了一下，仅供参考。。这边只是跑了个文章推荐的demo，不过什么电影，商品啥的都一样，没啥区别温馨提醒这个mahout包有毒。。。。很多依赖冲突。。。。这是我的pom文件，仅仅供参考。。
基于spark、mahout和spring boot构建的智能推荐系统.zip
09-01
在本项目中，Mahout可能被用于实现推荐算法，通过分析用户的历史行为和其他信息，预测用户可能感兴趣的新项目。 3. **Spring Boot**: Spring Boot简化了Spring应用的初始搭建以及开发过程，它集成了许多默认配置，...
基于spark、mahout和spring boot构建的推荐系统+源代码+文档说明
12-28
1、资源内容：基于spark、mahout和spring boot构建的推荐系统+源代码+文档说明 2、代码特点：内含运行结果，不会运行可私信，参数化编程、参数可方便更改、代码编程思路清晰、注释明细，都经过测试运行成功，功能ok...
springboot基于知识图谱的短视频推荐系统设计与实现毕业设计源码231115
FYKJ_2010的博客
08-29 1863
信息介绍管理、公告管理、类别管理、友情链接管理、留言管理、轮播图管理、评论管理、视频管理（该功能需要使用热度推荐，必须设置一个“知识视频”字段，且在前台展示）、用户管理，推荐管理...
spring-mahout-demo
12-27
spring-mahout-demo-----一个简单的spring-mahout结合的例子，是很好的学习开发思路的例子。
recommender:SpringBoot + Apache Mahout 推荐引擎 基于用户评分数据推荐相关电影
05-14
recommender Apache Mahout 推荐引擎 基于用户评分数据推荐相关电影
基于协作过滤算法的个性化推荐视频系统：基于协同过滤算法的个性化推荐水平系统，使用Spring Boot，Hadoop等框架和工具整合
02-12
基于协作过滤算法的个性化推荐视频系统：基于协同过滤算法的个性化推荐水平系统，使用Spring Boot，Hadoop等框架和工具整合
springboot基于推荐算法的网络招聘平台
2301_79305643的博客
07-10 672
目 录。
基于SpringBoot的智能推荐Demo（入门到实战仅需一篇教程）【完整版前后端已开源】
newborne's blog
07-22 2575
SpringBoot+MySql+MongoDB+Spark+Redis+Neo4j+Swagger框架整合Demo【完整版前后端已开源】
基于Apriori算法，SpringBoot框架作为前端，java语言编写的购物推荐系统 0.0
tutouxiaoshuaige的博客
08-09 1521
1，简介 自己研究的一个小软件，已经申请专利，这里分享出我的思路以及代码作为纪念，也希望能帮到大家，可以根据已经购买的东西利用算法推荐出可能还会购买哪些，类似于淘宝的推荐系统啊之类的巴拉巴拉，不过是简易版，改一改就可以推荐电影啊，音乐啊都行，需要大量的数据集作为基础，废话不多说 ，上代码 1需求分析 1.1开发背景 关联规则挖掘是数据挖掘中最活跃的研究方法之一 。最早是由 Agrawal 等人提出的1993最初提出的动机是针对购物篮分析问题提出的，其目的是为了发现交易数据库中不同商品之间的联系规则。这些规则
基于SpringBoot的协同过滤商品推荐商城系统
XiaoLin
05-25 1566
简介 随着网络的普及，网络资源不断丰富，网络信息量不断膨胀。用户要在众多的选择中挑选出自己真正需要的信息好比大海捞针，出现了所谓的“信息过载”的现象。信息过载是指的是社会信息超过了个人或系统所能接受、处理或有效利用的范围，并导致故障的状况。个性化推荐系统的出现是为了解决信息过载的问题，帮助消费者在浩如烟海的产品中找到自己需要的产品，为消费者提供个性化的购物体验。个性化推荐系统日益受到用户的青睐，也受到越来越多的学者和电子商务网站的关注。 个性化推荐可以作为网络营销的一种手段，能为电子商务网站带来巨大的利益。
spring boot基于用户的协同过滤算法
05-13
Spring Boot是一个快速开发框架，它支持多种应用程序类型。在基于用户的协同过滤算法中，我们需要将用户看作是一个个个体，然后通过计算他们之间的相似度来推荐他们可能喜欢的物品。Spring Boot可以通过集成推荐系统框架，如Apache Mahout或Lenskit来实现协同过滤算法。 具体来说，Spring Boot可以通过以下步骤实现基于用户的协同过滤算法： 1. 收集用户数据：首先需要收集用户对物品的评价数据，例如电影评分、购买记录等。 2. 计算用户相似度：通过计算用户之间的相似度来确定他们之间的关系。一般来说，可以使用皮尔逊相关系数或余弦相似度等指标计算用户之间的相似度。 3. 为用户推荐物品：根据用户之间的相似度，将与目标用户最为相似的用户看过并喜欢的物品推荐给目标用户。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值