web-dev-qa-db-ja.com

Spark RDD（Java）のインデックスで要素を取得する方法

RDDの最初の要素を提供するメソッドrdd.first（）を知っています。

また、最初の「num」要素を提供するrdd.take（num）メソッドもあります。

しかし、インデックスによって要素を取得する可能性はありませんか？

ありがとう。

javaapache-sparkrdd
27
progNewbie

これは、最初にRDDにインデックスを付けることで可能になります。変換zipWithIndexは、安定したインデックス付けを提供し、各要素に元の順序で番号を付けます。

指定：rdd = (a,b,c)

val withIndex = rdd.zipWithIndex // ((a,0),(b,1),(c,2))

インデックスで要素を検索するには、このフォームは役に立ちません。まず、インデックスをキーとして使用する必要があります。

val indexKey = withIndex.map{case (k,v) => (v,k)}  //((0,a),(1,b),(2,c))

現在、PairRDDでlookupアクションを使用して、キーで要素を見つけることができます。

val b = indexKey.lookup(1) // Array(b)

同じRDDでlookupを頻繁に使用する場合は、indexKey RDDをキャッシュしてパフォーマンスを向上させることをお勧めします。

Java API を使用してこれを行う方法は、読者に残された課題です。

57
maasg

私もしばらくこれに固執したので、Maasgの答えを拡張するために、Javaのインデックスで値の範囲を探すように答えます（4つの変数を定義する必要がありますトップ）：

DataFrame df;
SQLContext sqlContext;
Long start;
Long end;

JavaPairRDD<Row, Long> indexedRDD = df.toJavaRDD().zipWithIndex();
JavaRDD filteredRDD = indexedRDD.filter((Tuple2<Row,Long> v1) -> v1._2 >= start && v1._2 < end);
DataFrame filteredDataFrame = sqlContext.createDataFrame(filteredRDD, df.schema());

このコードを実行するとき、クラスターにはJava 8（ラムダ式が使用されているため）が必要です。

また、zipWithIndexはおそらく高価です！

2
Luke W

インデックスでアイテムを取得するためにこのクラスを試しました。最初に、new IndexedFetcher(rdd, itemClass)を作成すると、RDDの各パーティション内の要素の数がカウントされます。次に、indexedFetcher.get(n)を呼び出すと、そのインデックスを含むパーティションでのみジョブが実行されます。

1.8ではなくJava 1.7を使用してこれをコンパイルする必要があることに注意してください。 Spark 1.1.0の時点で、com.esotericsoftware.reflectasm内のバンドルされたorg.objectweb.asmはまだJava 1.8クラスを読み取ることができません（Java 1.8関数を実行しようとするとIllegalStateExceptionがスローされます） ）。

import Java.io.Serializable;

import org.Apache.spark.SparkContext;
import org.Apache.spark.TaskContext;
import org.Apache.spark.rdd.RDD;

import scala.reflect.ClassTag;

public static class IndexedFetcher<E> implements Serializable {
    private static final long serialVersionUID = 1L;
    public final RDD<E> rdd;
    public Integer[] elementsPerPartitions;
    private Class<?> clazz;
    public IndexedFetcher(RDD<E> rdd, Class<?> clazz){
        this.rdd = rdd;
        this.clazz = clazz;
        SparkContext context = this.rdd.context();
        ClassTag<Integer> intClassTag = scala.reflect.ClassTag$.MODULE$.<Integer>apply(Integer.class);
        elementsPerPartitions = (Integer[]) context.<E, Integer>runJob(rdd, IndexedFetcher.<E>countFunction(), intClassTag);
    }
    public static class IteratorCountFunction<E> extends scala.runtime.AbstractFunction2<TaskContext, scala.collection.Iterator<E>, Integer> implements Serializable {
        private static final long serialVersionUID = 1L;
        @Override public Integer apply(TaskContext taskContext, scala.collection.Iterator<E> iterator) {
            int count = 0;
            while (iterator.hasNext()) {
                count++;
                iterator.next();
            }
            return count;
        }
    }
    static <E> scala.Function2<TaskContext, scala.collection.Iterator<E>, Integer> countFunction() {
        scala.Function2<TaskContext, scala.collection.Iterator<E>, Integer> function = new IteratorCountFunction<E>();
        return function;
    }
    public E get(long index) {
        long remaining = index;
        long totalCount = 0;
        for (int partition = 0; partition < elementsPerPartitions.length; partition++) {
            if (remaining < elementsPerPartitions[partition]) {
                return getWithinPartition(partition, remaining);
            }
            remaining -= elementsPerPartitions[partition];
            totalCount += elementsPerPartitions[partition];
        }
        throw new IllegalArgumentException(String.format("Get %d within RDD that has only %d elements", index, totalCount));
    }
    public static class FetchWithinPartitionFunction<E> extends scala.runtime.AbstractFunction2<TaskContext, scala.collection.Iterator<E>, E> implements Serializable {
        private static final long serialVersionUID = 1L;
        private final long indexWithinPartition;
        public FetchWithinPartitionFunction(long indexWithinPartition) {
            this.indexWithinPartition = indexWithinPartition;
        }
        @Override public E apply(TaskContext taskContext, scala.collection.Iterator<E> iterator) {
            int count = 0;
            while (iterator.hasNext()) {
                E element = iterator.next();
                if (count == indexWithinPartition)
                    return element;
                count++;
            }
            throw new IllegalArgumentException(String.format("Fetch %d within partition that has only %d elements", indexWithinPartition, count));
        }
    }
    public E getWithinPartition(int partition, long indexWithinPartition) {
        System.out.format("getWithinPartition(%d, %d)%n", partition, indexWithinPartition);
        SparkContext context = rdd.context();
        scala.Function2<TaskContext, scala.collection.Iterator<E>, E> function = new FetchWithinPartitionFunction<E>(indexWithinPartition);
        scala.collection.Seq<Object> partitions = new scala.collection.mutable.WrappedArray.ofInt(new int[] {partition});
        ClassTag<E> classTag = scala.reflect.ClassTag$.MODULE$.<E>apply(this.clazz);
        E[] result = (E[]) context.<E, E>runJob(rdd, function, partitions, true, classTag);
        return result[0];
    }
}
2
yonran