Question

我正在使用Spark创建一个应用程序来运行一些主题提取算法。为此，首先我需要进行一些预处理，最后提取文档术语矩阵。香港专业教育学院可以做到这一点，但对于一个（不是那么多）大型文件集（只有2千，5MB），这个过程是永远的。

所以，调试，我发现程序有点卡住，并且它处于减少操作中。我在这部分代码中所做的是计算每个术语在集合中出现的次数，所以首先我做了一个＆＃34; map＆＃34;，为每个rdd进行couting，然后我们＃＆＃ 34;降低＆＃34;它，将结果保存在hashmap中。地图操作非常快，但在reduce中，它将操作分成40个块，每个块需要5~10分钟才能完成。

所以我试图弄清楚我做错了什么，或者减少操作的成本是多少。

SparkConf：独立模式，使用local [2]。我已经尝试使用它作为＆＃34; spark：// master：7077＆＃34;，它有效，但仍然是相同的缓慢。

代码：

＆＃34; filesIn＆＃34;是一个JavaPairRDD，其中键是文件路径，值是文件的内容。所以，首先是地图，我拿这个＆＃34; filesIn＆＃34;，拆分单词，并计算它们的频率（在这种情况下，不管文件是什么）然后是reduce，我创建了一个HashMap（term，freq）。

JavaRDD<HashMap<String, Integer>> termDF_ = filesIn.map(new Function<Tuple2<String, String>, HashMap<String, Integer>>() {

        @Override
        public HashMap<String, Integer> call(Tuple2<String, String> t) throws Exception {
            String[] allWords = t._2.split(" ");

            HashMap<String, Double> hashTermFreq = new HashMap<String, Double>();
            ArrayList<String> words = new ArrayList<String>();
            ArrayList<String> terms = new ArrayList<String>();
            HashMap<String, Integer> termDF = new HashMap<String, Integer>();

            for (String term : allWords) {

                if (hashTermFreq.containsKey(term)) {
                    Double freq = hashTermFreq.get(term);
                    hashTermFreq.put(term, freq + 1);
                } else {
                    if (term.length() > 1) {
                        hashTermFreq.put(term, 1.0);
                        if (!terms.contains(term)) {
                            terms.add(term);
                        }
                        if (!words.contains(term)) {
                            words.add(term);
                            if (termDF.containsKey(term)) {
                                int value = termDF.get(term);
                                value++;
                                termDF.put(term, value);
                            } else {
                                termDF.put(term, 1);
                            }
                        }
                    }
                }
            }
            return termDF;
        }
    });

 HashMap<String, Integer> termDF = termDF_.reduce(new Function2<HashMap<String, Integer>, HashMap<String, Integer>, HashMap<String, Integer>>() {

        @Override
        public HashMap<String, Integer> call(HashMap<String, Integer> t1, HashMap<String, Integer> t2) throws Exception {
            HashMap<String, Integer> result = new HashMap<String, Integer>();

            Iterator iterator = t1.keySet().iterator();

            while (iterator.hasNext()) {
                String key = (String) iterator.next();
                if (result.containsKey(key) == false) {
                    result.put(key, t1.get(key));
                } else {
                    result.put(key, result.get(key) + 1);
                }

            }

            iterator = t2.keySet().iterator();

            while (iterator.hasNext()) {
                String key = (String) iterator.next();
                if (result.containsKey(key) == false) {
                    result.put(key, t2.get(key));
                } else {
                    result.put(key, result.get(key) + 1);
                }

            }

            return result;
        }
    });

谢谢！

Answer 1

好的，所以就在我头顶：

Spark变换是懒惰的。这意味着在您调用后续map操作之前，reduce不会被执行，因此您描述为慢reduce的内容很可能很慢map + reduce
ArrayList.contains为O（N），因此所有这些words.contains和terms.contains都效率极低
map逻辑闻起来很腥。特别是：
- 如果已经看到术语，则永远不会进入else分支
- 乍一看words和terms应该具有完全相同的内容，并且应该等同于hashTermFreq键或termDF键。
- 看起来termDF中的值只能取值1.如果这是您想要的而忽略了频率创建hashTermFreq的重点是什么？
reduce阶段意味着一个低效的线性扫描，在数据上增长的对象，而你真正想要的是reduceByKey。

使用Scala作为伪代码，您的整个代码可以有效地表达如下：

val termDF = filesIn.flatMap{
  case (_, text) => 
    text.split(" ") // Split
    .toSet // Take unique terms 
    .filter(_.size > 1) // Remove single characters
    .map(term => (term, 1))} // map to pairs
  .reduceByKey(_ + _) // Reduce by key

termDF.collectAsMap // Optionally

最后看起来你正在重新发明轮子。至少您需要的一些工具已在mllib.feature或ml.feature

中实施

Spark - 减少操作耗时太长

1 个答案: