机器学习(hadoop实战)01: 家电故障备件储备预测分析

最新推荐文章于 2023-08-17 15:55:31 发布

sxsAffable

最新推荐文章于 2023-08-17 15:55:31 发布

阅读量670

点赞数 1

分类专栏：机器学习文章标签：机器学习协同过滤推荐系统 hadoop java

本文链接：https://blog.csdn.net/sxsaffable/article/details/106129835

版权

机器学习专栏收录该内容

2 篇文章 0 订阅

订阅专栏

家电故障备件储备预测分析

本例来源于《Hadoop大数据分析与挖掘实战》第十二章家电故障备件储备预测分析。

数据集：请留言，我会私发。

问题：针对手机数据，要求从服务商代码中提取出地区编码，对每个地区进行故障率的预测，从而做到备件的提前储备。
问题分析：从问题描述可以看出，可以看作是对每个地区进行故障的推荐，地区编码作为用户id，故障代码作为项目id，现有数据集中故障率作为评分，使用协同过滤算法进行故障的推荐。
难点：

需要把故障描述转化为故障代码，故障描述是用户对故障的描述，所以各种各样，很难做到统一，需要提取其中的关键字。
现有数据集中故障率的计算。
在计算的时候，地区编码、故障代码都是字符串，但是协同过滤算法会把他们作为long类型处理，会出现数据失真的情况。

本次主要针对手机故障进行分析。
分析流程：

第一步：查看数据集。本次主要分析手机故障，所以只需要excel中Sheet2中的数据(见图1.1)，由于hadoop没有读取excel的InputFormat(我自己实现了一个，但是存在bug)，所以采用了先把excel导出为txt文件，然后再处理的办法。
图1.1
第二步：写mr程序计算故障率，map阶段读取文件。按照 \t 切分字符串，过滤掉不符合格式的数据(见代码2.1)，然后从中取出服务商代码、故障描述。从服务商代码中取出地区代码，根据手机故障原因标准准则(见图2.3)，把故障描述转化为故障代码(见代码2.2)，然后写出。

代码2.1

    /**
     * 产品大类 品牌 产品型号 序列号 内机编码 服务商代码 受理时间 派工时间 故障原因代码 故障原因描述 维修措施 反映问题描述
     */
    static class ParseMapper extends Mapper<LongWritable, Text, Text, IntWritable> {

        Text k = new Text();
        IntWritable v = new IntWritable();
        int sum = 0;

        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            // 删除空行
            if (!StringUtils.isBlank(value.toString())) {
                String[] fields = value.toString().split("\t");
                if (fields.length < 12) {
                    System.out.println(Arrays.toString(fields));
                    sum ++;
                }
                // 如果服务商代码或者反映问题描述为空，则删除行
                if (fields.length >=12 && !StringUtils.isBlank(fields[5]) && !StringUtils.isBlank(fields[11])) {
                    // 服务商代码
                    String districtCode = fields[5];
                    // 反映问题描述
                    String faultTxt = fields[11];

                    try {
                        if (districtCode.split("-").length >= 3) {
                            // 从服务商代码中取出地区编码
                            String district = districtCode.split("-")[2];
                            // 把反映问题描述转化为故障代码
                            int convertCode = convertCode(faultTxt);
                            k.set(district);
                            v.set(convertCode);

                            context.write(k, v);
                        }

                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                }

            }

        }

        @Override
        protected void cleanup(Context context) throws IOException, InterruptedException {
            System.out.println("sum: " + sum);
        }
    }

代码2.2

    /**
     * 把反映问题描述转化为故障类型代码
     * @param faultText 反映问题描述
     * @return 故障类型代码
     */
    public static int convertCode(String faultText) {
        int code = 0;
        String fault = faultText.toLowerCase();
        if (fault.contains("lcd")) {
            code = 2;
        } else if (fault.contains("键") && !fault.contains("印错")) {
            code = 3;
        } else if (fault.contains("网络") || fault.contains("服务")
                || fault.contains("信号") || fault.contains("连接")
                || fault.contains("功率低")) {
            code = 5;
        } else if (fault.contains("通话") || fault.contains("听筒")
                || fault.contains("送话")) {
            code = 4;
        } else if (fault.contains("灯")) {
            code = 6;
        } else if (fault.contains("蓝牙")) {
            code = 7;
        } else if (fault.contains("不吃卡") || fault.contains("不识卡")
                || fault.contains("不读卡")) {
            code = 8;
        } else if (fault.contains("电池") || fault.contains("耗电")) {
            code = 9;
        } else if (fault.contains("拍照") || fault.contains("照相")
                || fault.contains("摄像头")) {
            code = 10;
        } else if (fault.contains("触屏")) {
            code = 11;
        } else if (fault.contains("振动")) {
            code = 12;
        } else if (fault.contains("mp3") || fault.contains("音")
                && !fault.contains("键") && !fault.contains("喇叭")) {
            code = 13;
        } else if (fault.contains("喇叭") || fault.contains("耳机")) {
            code = 14;
        } else if (fault.contains("充电")) {
            code = 15;
        } else if (fault.contains("gps") || fault.contains("卫星")) {
            code = 16;
        } else if (fault.contains("壳") || fault.contains("螺丝")
                || fault.contains("缝隙") || fault.contains("印错")) {
            code = 17;
        } else if (fault.contains("开机") || fault.contains("死机")
                || fault.contains("开关机") || fault.contains("开(关)机")) {
            code = 1;
        } else {
            code = 18;
        }

        return code;
    }

手机故障原因标准准则

图2.3(部分)

第三步：reduce阶段计算故障率。map阶段写出的时候把地区编码作为key，所以在reduce阶段取数据的时候，会把相同地区编码的数据作为一组，一起拿过来。然后针对每个地区，用每种故障数量除以总故障数量，得到每个地区各种故障的故障率。应该除以该地区的总故障率，因为我们使用协同过滤算法，研究的是各个地区之间故障率的相似度。计算完写出到文件。

    static class RateReducer extends Reducer<Text, IntWritable, Text, DoubleWritable> {

        String districtCode = null;
        Map<Integer, Integer> map = new HashMap<>();
        double sum = 0D;

        @Override
        protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
            districtCode = key.toString();
            for (IntWritable value : values) {
                int faultCode = value.get();
                // 如果map中没有此值，则放入1，有，则在此基础加1
                map.merge(faultCode, 1, Integer::sum);
                sum++;
            }

            // 写出
            for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
                double rate = entry.getValue() / sum;
                Text outKey = new Text(districtCode + "\t" + entry.getKey());
                DoubleWritable value = new DoubleWritable(rate);
                context.write(outKey, value);
            }
            // 初始化值
            map.clear();
            sum = 0;
            districtCode = null;
        }

        @Override
        protected void cleanup(Context context) throws IOException, InterruptedException {

            map.clear();
            sum = 0;
            districtCode = null;
        }
    }

第四步：根据现有故障率，使用mahout协同过滤算法进行故障率预测。
在处理之前，先使用MemoryIDMigrator把地区编码转化成了long，防止模型把数据从string转为long，造成前面的0缺失的问题，预测的时候，再把地区编码从long映射回string。具体代码如下：

import org.apache.mahout.cf.taste.common.TasteException;
import org.apache.mahout.cf.taste.impl.common.LongPrimitiveIterator;
import org.apache.mahout.cf.taste.impl.model.MemoryIDMigrator;
import org.apache.mahout.cf.taste.impl.model.file.FileDataModel;
import org.apache.mahout.cf.taste.impl.neighborhood.ThresholdUserNeighborhood;
import org.apache.mahout.cf.taste.impl.recommender.GenericUserBasedRecommender;
import org.apache.mahout.cf.taste.impl.similarity.EuclideanDistanceSimilarity;
import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood;
import org.apache.mahout.cf.taste.recommender.RecommendedItem;
import org.apache.mahout.cf.taste.recommender.Recommender;
import org.apache.mahout.cf.taste.similarity.UserSimilarity;

import java.io.*;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author affable
 * @description 故障率预测的协同过滤算法
 * @date 2020-04-21 19:12
 */
public class FaultPredict {

    /**
     * 推荐的个数
     */
    private static final int RECOMMEND_NUM = 18;

    /**
     * 用户即地区代码
     * @param args 程序输入参数
     */
    public static void main(String[] args) throws IOException, TasteException {
        // *******************************处理开始******************************************
        Map<Long, String> faultMap = loadFault();
        // 使用推荐模型之前，对数据的districtCode映射成long类型
        // 防止模型把districtCode转为long，出现数据异常
        String filePath = "data/faultRate/part-r-00000";
        File dealFile = new File("data/faultRateDeal.csv");
        MemoryIDMigrator memoryIDMigrator = new MemoryIDMigrator();
        FileWriter dealWriter = new FileWriter(dealFile, true);

        FileReader reader = new FileReader(filePath);
        BufferedReader bufferedReader = new BufferedReader(reader);
        String line = null;
        while ((line = bufferedReader.readLine()) != null) {
            String[] fields = line.split("\t");
            long districtCodeLong = memoryIDMigrator.toLongID(fields[0]);
            memoryIDMigrator.storeMapping(districtCodeLong, fields[0]);
            dealWriter.write(districtCodeLong + "," + fields[1] + "," + fields[2] + "\n");
            dealWriter.flush();
        }
        dealWriter.close();
        bufferedReader.close();
        reader.close();
        // ***********************************处理完成**************************************

        // **********************************模型推荐开始************************************
        // 创建包含用户评分的协同过滤模型
        FileDataModel dataModel = new FileDataModel(dealFile);
        // 指定使用欧式距离
        UserSimilarity userSimilarity = new EuclideanDistanceSimilarity(dataModel);
        // 指定临近算法
        // 指定距离最近的一定百分比的用户作为邻居
        // 百分比: 20%
        UserNeighborhood userNeighborhood = new ThresholdUserNeighborhood(0.2, userSimilarity, dataModel);
        // 创建推荐器
        Recommender recommender = new GenericUserBasedRecommender(dataModel, userNeighborhood, userSimilarity);

        // 获取所有的用户
        LongPrimitiveIterator userIDIter = dataModel.getUserIDs();
        StringBuilder recommendedRecord = new StringBuilder();
        while (userIDIter.hasNext()) {
            // 获取针对每个用户的推荐
            long userId = userIDIter.nextLong();
            List<RecommendedItem> recommendList = recommender.recommend(userId, RECOMMEND_NUM);
            for (RecommendedItem recommendedItem : recommendList) {
                recommendedRecord.append(String.format("%s,%s,%f\n", memoryIDMigrator.toStringID(userId), faultMap.get(recommendedItem.getItemID()), recommendedItem.getValue()));
            }
        }
        // **********************************模型推荐结束************************************

        // 写出推荐结果到文件
        File recommendFile = new File("data/recommend.csv");
        FileWriter writer = new FileWriter(recommendFile, true);
        writer.write(recommendedRecord.toString());
        writer.flush();
        writer.close();


    }

    /**
     * 加载故障代码对应的故障类型map
     * @return map
     */
    private static Map<Long, String> loadFault() {
        Map<Long, String> faultMap = new HashMap<>(18);
        faultMap.put(1L, "开机故障");
        faultMap.put(2L, "LCD显示故障");
        faultMap.put(3L, "按键故障");
        faultMap.put(4L, "通话故障");
        faultMap.put(5L, "网络故障");
        faultMap.put(6L, "灯故障");
        faultMap.put(7L, "蓝牙机故障");
        faultMap.put(8L, "不读卡");
        faultMap.put(9L, "电池故障");
        faultMap.put(10L, "拍照故障");
        faultMap.put(11L, "触屏故障");
        faultMap.put(12L, "振动故障");
        faultMap.put(13L, "MP3、收音故障");
        faultMap.put(14L, "喇叭故障");
        faultMap.put(15L, "充电故障");
        faultMap.put(16L, "GPRS故障");
        faultMap.put(17L, "外观故障");
        faultMap.put(18L, "其他故障");

        return faultMap;
    }

}

如有需要完整代码，请留言。

sxsAffable

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
9
评论
机器学习(hadoop实战)01: 家电故障备件储备预测分析

家电故障备件储备预测分析本例来源于《Hadoop大数据分析与挖掘实战》第十二章家电故障备件储备预测分析。数据集：请留言，我会私发。问题：针对手机数据，要求从服务商代码中提取出地区编码，对每个地区进行故障率的预测，从而做到备件的提前储备。问题分析：从问题描述可以看出，可以看作是对每个地区进行故障的推荐，地区编码作为用户id，故障代码作为项目id，现有数据集中故障率作为评分，使用协同过滤算法进行故障的推荐。难点：需要把故障描述转化为故障代码，故障描述是用户对故障的描述，所以
复制链接

扫一扫