基本統計量 - RDDベースのAPI
\[
\newcommand{\R}{\mathbb{R}}
\newcommand{\E}{\mathbb{E}}
\newcommand{\x}{\mathbf{x}}
\newcommand{\y}{\mathbf{y}}
\newcommand{\wv}{\mathbf{w}}
\newcommand{\av}{\mathbf{\alpha}}
\newcommand{\bv}{\mathbf{b}}
\newcommand{\N}{\mathbb{N}}
\newcommand{\id}{\mathbf{I}}
\newcommand{\ind}{\mathbf{1}}
\newcommand{\0}{\mathbf{0}}
\newcommand{\unit}{\mathbf{e}}
\newcommand{\one}{\mathbf{1}}
\newcommand{\zero}{\mathbf{0}}
\]
統計の概要
Statistics
で利用可能なcolStats
を使って、RDD[Vector]
のためのカラムの統計の概要を提供します。
colStats()
はMultivariateStatisticalSummary
のインスタンスを返し、これは列方向の 最大、最小、平均、分散、および非ゼロの数と総数を含みます。
APIの詳細はMultivariateStatisticalSummary
Scala ドキュメント を参照してください。
import org.apache.spark.mllib.linalg.Vectors
import org.apache.spark.mllib.stat.{MultivariateStatisticalSummary, Statistics}
val observations = sc.parallelize(
Seq(
Vectors.dense(1.0, 10.0, 100.0),
Vectors.dense(2.0, 20.0, 200.0),
Vectors.dense(3.0, 30.0, 300.0)
)
)
// Compute column summary statistics.
val summary: MultivariateStatisticalSummary = Statistics.colStats(observations)
println(summary.mean) // a dense vector containing the mean value for each column
println(summary.variance) // column-wise variance
println(summary.numNonzeros) // number of nonzeros in each column
colStats()
はMultivariateStatisticalSummary
のインスタンスを返し、これは列方向の 最大、最小、平均、分散、および非ゼロの数と総数を含みます。
APIの詳細はMultivariateStatisticalSummary
Java ドキュメント を参照してください。
import java.util.Arrays;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.mllib.linalg.Vector;
import org.apache.spark.mllib.linalg.Vectors;
import org.apache.spark.mllib.stat.MultivariateStatisticalSummary;
import org.apache.spark.mllib.stat.Statistics;
JavaRDD<Vector> mat = jsc.parallelize(
Arrays.asList(
Vectors.dense(1.0, 10.0, 100.0),
Vectors.dense(2.0, 20.0, 200.0),
Vectors.dense(3.0, 30.0, 300.0)
)
); // an RDD of Vectors
// Compute column summary statistics.
MultivariateStatisticalSummary summary = Statistics.colStats(mat.rdd());
System.out.println(summary.mean()); // a dense vector containing the mean value for each column
System.out.println(summary.variance()); // column-wise variance
System.out.println(summary.numNonzeros()); // number of nonzeros in each column
colStats()
はMultivariateStatisticalSummary
のインスタンスを返し、これは列方向の 最大、最小、平均、分散、および非ゼロの数と総数を含みます。
APIの詳細はMultivariateStatisticalSummary
Python ドキュメント を参照してください。
import numpy as np
from pyspark.mllib.stat import Statistics
mat = sc.parallelize(
[np.array([1.0, 10.0, 100.0]), np.array([2.0, 20.0, 200.0]), np.array([3.0, 30.0, 300.0])]
) # an RDD of Vectors
# Compute column summary statistics.
summary = Statistics.colStats(mat)
print(summary.mean()) # a dense vector containing the mean value for each column
print(summary.variance()) # column-wise variance
print(summary.numNonzeros()) # number of nonzeros in each column
相関関係
データの2つの系列間の相関関係の計算は、統計では一般的な操作です。spark.mllib
では、多くの系列間でペア方向の相関関係を計算するための柔軟性を提供します。サポートされる相関関係メソッドは現ジアのところピアソンおよびスピアマンの相関関係です。
Statistics
は系列間の相関関係を計算するためのメソッドを提供します。入力のタイプ、2つのRDD[Double]
、あるいはRDD[Vector]
に依存して、出力はそれぞれDouble
あるいは 相関関係マトリックス
です。
APIの詳細はStatistics
Scala ドキュメント を参照してください。
import org.apache.spark.mllib.linalg._
import org.apache.spark.mllib.stat.Statistics
import org.apache.spark.rdd.RDD
val seriesX: RDD[Double] = sc.parallelize(Array(1, 2, 3, 3, 5)) // a series
// must have the same number of partitions and cardinality as seriesX
val seriesY: RDD[Double] = sc.parallelize(Array(11, 22, 33, 33, 555))
// compute the correlation using Pearson's method. スピアマンのメソッドのために"spearman"を入力します。If a
// method is not specified, Pearson's method will be used by default.
val correlation: Double = Statistics.corr(seriesX, seriesY, "pearson")
println(s"Correlation is: $correlation")
val data: RDD[Vector] = sc.parallelize(
Seq(
Vectors.dense(1.0, 10.0, 100.0),
Vectors.dense(2.0, 20.0, 200.0),
Vectors.dense(5.0, 33.0, 366.0))
) // note that each Vector is a row and not a column
// calculate the correlation matrix using Pearson's method. Use "spearman" for Spearman's method
// If a method is not specified, Pearson's method will be used by default.
val correlMatrix: Matrix = Statistics.corr(data, "pearson")
println(correlMatrix.toString)
Statistics
は系列間の相関関係を計算するためのメソッドを提供します。入力のタイプ、2つのJavaDoubleRDD
、あるいはJavaRDD[Vector]
に依存して、出力はそれぞれDouble
あるいは 相関関係マトリックス
です。
APIの詳細はStatistics
Java ドキュメント を参照してください。
import java.util.Arrays;
import org.apache.spark.api.java.JavaDoubleRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.mllib.linalg.Matrix;
import org.apache.spark.mllib.linalg.Vector;
import org.apache.spark.mllib.linalg.Vectors;
import org.apache.spark.mllib.stat.Statistics;
JavaDoubleRDD seriesX = jsc.parallelizeDoubles(
Arrays.asList(1.0, 2.0, 3.0, 3.0, 5.0)); // a series
// must have the same number of partitions and cardinality as seriesX
JavaDoubleRDD seriesY = jsc.parallelizeDoubles(
Arrays.asList(11.0, 22.0, 33.0, 33.0, 555.0));
// compute the correlation using Pearson's method. Enter "spearman" for Spearman's method.
// If a method is not specified, Pearson's method will be used by default.
Double correlation = Statistics.corr(seriesX.srdd(), seriesY.srdd(), "pearson");
System.out.println("Correlation is: " + correlation);
// note that each Vector is a row and not a column
JavaRDD<Vector> data = jsc.parallelize(
Arrays.asList(
Vectors.dense(1.0, 10.0, 100.0),
Vectors.dense(2.0, 20.0, 200.0),
Vectors.dense(5.0, 33.0, 366.0)
)
);
// calculate the correlation matrix using Pearson's method.
// Use "spearman" for Spearman's method.
// If a method is not specified, Pearson's method will be used by default.
Matrix correlMatrix = Statistics.corr(data.rdd(), "pearson");
System.out.println(correlMatrix.toString());
Statistics
は系列間の相関関係を計算するためのメソッドを提供します。入力のタイプ、2つのRDD[Double]
、あるいはRDD[Vector]
に依存して、出力はそれぞれDouble
あるいは 相関関係マトリックス
です。
APIの詳細はStatistics
Python ドキュメント を参照してください。
from pyspark.mllib.stat import Statistics
seriesX = sc.parallelize([1.0, 2.0, 3.0, 3.0, 5.0]) # a series
# seriesY must have the same number of partitions and cardinality as seriesX
seriesY = sc.parallelize([11.0, 22.0, 33.0, 33.0, 555.0])
# Compute the correlation using Pearson's method. Enter "spearman" for Spearman's method.
# If a method is not specified, Pearson's method will be used by default.
print("Correlation is: " + str(Statistics.corr(seriesX, seriesY, method="pearson")))
data = sc.parallelize(
[np.array([1.0, 10.0, 100.0]), np.array([2.0, 20.0, 200.0]), np.array([5.0, 33.0, 366.0])]
) # an RDD of Vectors
# calculate the correlation matrix using Pearson's method. Use "spearman" for Spearman's method.
# If a method is not specified, Pearson's method will be used by default.
print(Statistics.corr(data, method="pearson"))
階層化されたサンプリング
統計学の関数と違い、spark.mllib
にある層別抽出法メソッド sampleByKey
と sampleByKeyExact
はRDDのキー-値ペアに実施することができます。送別抽出法のために、キーはラベルで、値は特定の属性と考えることができます。例えば、キーは男と女、あるいはドキュメントのidかも知れません。そしてそれぞれの値は人口の中の人々の年齢のリスト、あるいはドキュメントの中の単語のリストかも知れません。sampleByKey
メソッドは観察が評価される、あるいはされないかを決めるためにコインを投げるでしょう。従って、データ上を1回通過する必要があり、期待される 標本化のサイズを提供します。sampleByKeyExact
はsampleByKey
で使われる層の単純なランダム標本化よりもとても多くのリソースを必要としますが、99.99%の信頼性のある精巧な標本化を提供するでしょう。sampleByKeyExact
は現在のところpythonではサポートされません。
sampleByKeyExact()
は正確に $\lceil f_k \cdot n_k \rceil \, \forall k \in K$ 項目を標本化することができます。ここで、$f_k$ は $k$ の望ましい一部分、$n_k$ は $k$ のためのキー-値ペアの数、$K$ はキーのセットです。置換無しの標本化は、置換無しの標本化が2つの追加のRDD上の追加を必要とするのに対し、標本のサイズを保証するためにRDD上に更に追加の1回の通過を必要とします。
// an RDD[(K, V)] of any key value pairs
val data = sc.parallelize(
Seq((1, 'a'), (1, 'b'), (2, 'c'), (2, 'd'), (2, 'e'), (3, 'f')))
// specify the exact fraction desired from each key
val fractions = Map(1 -> 0.1, 2 -> 0.6, 3 -> 0.3)
// Get an approximate sample from each stratum
val approxSample = data.sampleByKey(withReplacement = false, fractions = fractions)
// Get an exact sample from each stratum
val exactSample = data.sampleByKeyExact(withReplacement = false, fractions = fractions)
sampleByKeyExact()
は正確に $\lceil f_k \cdot n_k \rceil \, \forall k \in K$ 項目を標本化することができます。ここで、$f_k$ は $k$ の望ましい一部分、$n_k$ は $k$ のためのキー-値ペアの数、$K$ はキーのセットです。置換無しの標本化は、置換無しの標本化が2つの追加のRDD上の追加を必要とするのに対し、標本のサイズを保証するためにRDD上に更に追加の1回の通過を必要とします。
import java.util.*;
import scala.Tuple2;
import org.apache.spark.api.java.JavaPairRDD;
List<Tuple2<Integer, Character>> list = Arrays.asList(
new Tuple2<>(1, 'a'),
new Tuple2<>(1, 'b'),
new Tuple2<>(2, 'c'),
new Tuple2<>(2, 'd'),
new Tuple2<>(2, 'e'),
new Tuple2<>(3, 'f')
);
JavaPairRDD<Integer, Character> data = jsc.parallelizePairs(list);
// specify the exact fraction desired from each key Map<K, Double>
ImmutableMap<Integer, Double> fractions = ImmutableMap.of(1, 0.1, 2, 0.6, 3, 0.3);
// Get an approximate sample from each stratum
JavaPairRDD<Integer, Character> approxSample = data.sampleByKey(false, fractions);
// Get an exact sample from each stratum
JavaPairRDD<Integer, Character> exactSample = data.sampleByKeyExact(false, fractions);
sampleByKey()
は大まかに $\lceil f_k \cdot n_k \rceil \, \forall k \in K$ 項目を標本化することができます。ここで、$f_k$ は $k$ の望ましい一部分、$n_k$ は $k$ のためのキー-値ペアの数、$K$ はキーのセットです。
注意: sampleByKeyExact()
は現在のところPythonでサポートされません。
# an RDD of any key value pairs
data = sc.parallelize([(1, 'a'), (1, 'b'), (2, 'c'), (2, 'd'), (2, 'e'), (3, 'f')])
# specify the exact fraction desired from each key as a dictionary
fractions = {1: 0.1, 2: 0.6, 3: 0.3}
approxSample = data.sampleByKey(False, fractions)
仮説テスト
仮説テストは統計学において結果が統計学的に重要などうか、この結果が偶然によっておきたかどううかを決定する強力なツールです。spark.mllib
は現在のところピアソンのカイ二乗 ( $\chi^2$) テストを適合度と独立のためにサポートします。入力データタイプは適合度と独立のテストを行うかどうかを決定します。独立テストがMatrix
を入力として必要とするのに対し、適合度テストはVector
の入力タイプを必要とします。
spark.mllib
はカイ二乗独立テストを使って特徴の選択を可能にするために入力タイプRDD[LabeledPoint]
もサポートします。
Statistics
はピアソンのカイ二乗テストを実行するためのメソッドを提供します。以下の例は仮説テストをどうやって実行および解釈するかを実演します。
import org.apache.spark.mllib.linalg._
import org.apache.spark.mllib.regression.LabeledPoint
import org.apache.spark.mllib.stat.Statistics
import org.apache.spark.mllib.stat.test.ChiSqTestResult
import org.apache.spark.rdd.RDD
// a vector composed of the frequencies of events
val vec: Vector = Vectors.dense(0.1, 0.15, 0.2, 0.3, 0.25)
// compute the goodness of fit. If a second vector to test against is not supplied
// as a parameter, the test runs against a uniform distribution.
val goodnessOfFitTestResult = Statistics.chiSqTest(vec)
// summary of the test including the p-value, degrees of freedom, test statistic, the method
// used, and the null hypothesis.
println(s"$goodnessOfFitTestResult\n")
// a contingency matrix. Create a dense matrix ((1.0, 2.0), (3.0, 4.0), (5.0, 6.0))
val mat: Matrix = Matrices.dense(3, 2, Array(1.0, 3.0, 5.0, 2.0, 4.0, 6.0))
// conduct Pearson's independence test on the input contingency matrix
val independenceTestResult = Statistics.chiSqTest(mat)
// summary of the test including the p-value, degrees of freedom
println(s"$independenceTestResult\n")
val obs: RDD[LabeledPoint] =
sc.parallelize(
Seq(
LabeledPoint(1.0, Vectors.dense(1.0, 0.0, 3.0)),
LabeledPoint(1.0, Vectors.dense(1.0, 2.0, 0.0)),
LabeledPoint(-1.0, Vectors.dense(-1.0, 0.0, -0.5)
)
)
) // (feature, label) pairs.
// The contingency table is constructed from the raw (feature, label) pairs and used to conduct
// the independence test. Returns an array containing the ChiSquaredTestResult for every feature
// against the label.
val featureTestResults: Array[ChiSqTestResult] = Statistics.chiSqTest(obs)
featureTestResults.zipWithIndex.foreach { case (k, v) =>
println("Column " + (v + 1).toString + ":")
println(k)
} // summary of the test
Statistics
はピアソンのカイ二乗テストを実行するためのメソッドを提供します。以下の例は仮説テストをどうやって実行および解釈するかを実演します。
APIの詳細はChiSqTestResult
Java ドキュメント を参照してください。
import java.util.Arrays;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.mllib.linalg.Matrices;
import org.apache.spark.mllib.linalg.Matrix;
import org.apache.spark.mllib.linalg.Vector;
import org.apache.spark.mllib.linalg.Vectors;
import org.apache.spark.mllib.regression.LabeledPoint;
import org.apache.spark.mllib.stat.Statistics;
import org.apache.spark.mllib.stat.test.ChiSqTestResult;
// a vector composed of the frequencies of events
Vector vec = Vectors.dense(0.1, 0.15, 0.2, 0.3, 0.25);
// compute the goodness of fit. If a second vector to test against is not supplied
// as a parameter, the test runs against a uniform distribution.
ChiSqTestResult goodnessOfFitTestResult = Statistics.chiSqTest(vec);
// summary of the test including the p-value, degrees of freedom, test statistic,
// the method used, and the null hypothesis.
System.out.println(goodnessOfFitTestResult + "\n");
// Create a contingency matrix ((1.0, 2.0), (3.0, 4.0), (5.0, 6.0))
Matrix mat = Matrices.dense(3, 2, new double[]{1.0, 3.0, 5.0, 2.0, 4.0, 6.0});
// conduct Pearson's independence test on the input contingency matrix
ChiSqTestResult independenceTestResult = Statistics.chiSqTest(mat);
// summary of the test including the p-value, degrees of freedom...
System.out.println(independenceTestResult + "\n");
// an RDD of labeled points
JavaRDD<LabeledPoint> obs = jsc.parallelize(
Arrays.asList(
new LabeledPoint(1.0, Vectors.dense(1.0, 0.0, 3.0)),
new LabeledPoint(1.0, Vectors.dense(1.0, 2.0, 0.0)),
new LabeledPoint(-1.0, Vectors.dense(-1.0, 0.0, -0.5))
)
);
// The contingency table is constructed from the raw (feature, label) pairs and used to conduct
// the independence test. Returns an array containing the ChiSquaredTestResult for every feature
// against the label.
ChiSqTestResult[] featureTestResults = Statistics.chiSqTest(obs.rdd());
int i = 1;
for (ChiSqTestResult result : featureTestResults) {
System.out.println("Column " + i + ":");
System.out.println(result + "\n"); // summary of the test
i++;
}
Statistics
はピアソンのカイ二乗テストを実行するためのメソッドを提供します。以下の例は仮説テストをどうやって実行および解釈するかを実演します。
APIの詳細はStatistics
Python ドキュメント を参照してください。
from pyspark.mllib.linalg import Matrices, Vectors
from pyspark.mllib.regression import LabeledPoint
from pyspark.mllib.stat import Statistics
vec = Vectors.dense(0.1, 0.15, 0.2, 0.3, 0.25) # a vector composed of the frequencies of events
# compute the goodness of fit. If a second vector to test against
# is not supplied as a parameter, the test runs against a uniform distribution.
goodnessOfFitTestResult = Statistics.chiSqTest(vec)
# summary of the test including the p-value, degrees of freedom,
# test statistic, the method used, and the null hypothesis.
print("%s\n" % goodnessOfFitTestResult)
mat = Matrices.dense(3, 2, [1.0, 3.0, 5.0, 2.0, 4.0, 6.0]) # a contingency matrix
# conduct Pearson's independence test on the input contingency matrix
independenceTestResult = Statistics.chiSqTest(mat)
# summary of the test including the p-value, degrees of freedom,
# test statistic, the method used, and the null hypothesis.
print("%s\n" % independenceTestResult)
obs = sc.parallelize(
[LabeledPoint(1.0, [1.0, 0.0, 3.0]),
LabeledPoint(1.0, [1.0, 2.0, 0.0]),
LabeledPoint(1.0, [-1.0, 0.0, -0.5])]
) # LabeledPoint(feature, label)
# The contingency table is constructed from an RDD of LabeledPoint and used to conduct
# the independence test. Returns an array containing the ChiSquaredTestResult for every feature
# against the label.
featureTestResults = Statistics.chiSqTest(obs)
for i, result in enumerate(featureTestResults):
print("Column %d:\n%s" % (i + 1, result))
更に、spark.mllib
は可能性の分散の平等のためにコルモゴロフ-スミルノフ(KS)検定の1-サンプル 2-サイド実装を提供します。理論的な分散の名前(現在は通常の分散に対してのみサポートされます)とパラメータ、あるいは指定された理論的な分散の累積に応じて関数を計算するための関数を提供することで、分散から取り出された分散のゼロ仮説をユーザがテストすることができます。ユーザが通常の分散 (distName="norm"
)をテストしますが、分散パラメータが提供されない場合は、テストは標準の通常の分散に初期化され、適切なメッセージが記録されます。
Statistics
は、1-サンプル 2-サイドのコルモゴロフ-スミルノフ検定を実行するメソッドを提供します。以下の例は仮説テストをどうやって実行および解釈するかを実演します。
APIの詳細はStatistics
Scala ドキュメント を参照してください。
import org.apache.spark.mllib.stat.Statistics
import org.apache.spark.rdd.RDD
val data: RDD[Double] = sc.parallelize(Seq(0.1, 0.15, 0.2, 0.3, 0.25)) // an RDD of sample data
// run a KS test for the sample versus a standard normal distribution
val testResult = Statistics.kolmogorovSmirnovTest(data, "norm", 0, 1)
// summary of the test including the p-value, test statistic, and null hypothesis if our p-value
// indicates significance, we can reject the null hypothesis.
println(testResult)
println()
// perform a KS test using a cumulative distribution function of our making
val myCDF = Map(0.1 -> 0.2, 0.15 -> 0.6, 0.2 -> 0.05, 0.3 -> 0.05, 0.25 -> 0.1)
val testResult2 = Statistics.kolmogorovSmirnovTest(data, myCDF)
println(testResult2)
Statistics
は、1-サンプル 2-サイドのコルモゴロフ-スミルノフ検定を実行するメソッドを提供します。以下の例は仮説テストをどうやって実行および解釈するかを実演します。
APIの詳細はStatistics
Java ドキュメント を参照してください。
import java.util.Arrays;
import org.apache.spark.api.java.JavaDoubleRDD;
import org.apache.spark.mllib.stat.Statistics;
import org.apache.spark.mllib.stat.test.KolmogorovSmirnovTestResult;
JavaDoubleRDD data = jsc.parallelizeDoubles(Arrays.asList(0.1, 0.15, 0.2, 0.3, 0.25));
KolmogorovSmirnovTestResult testResult =
Statistics.kolmogorovSmirnovTest(data, "norm", 0.0, 1.0);
// summary of the test including the p-value, test statistic, and null hypothesis
// if our p-value indicates significance, we can reject the null hypothesis
System.out.println(testResult);
Statistics
は、1-サンプル 2-サイドのコルモゴロフ-スミルノフ検定を実行するメソッドを提供します。以下の例は仮説テストをどうやって実行および解釈するかを実演します。
APIの詳細はStatistics
Python ドキュメント を参照してください。
from pyspark.mllib.stat import Statistics
parallelData = sc.parallelize([0.1, 0.15, 0.2, 0.3, 0.25])
# run a KS test for the sample versus a standard normal distribution
testResult = Statistics.kolmogorovSmirnovTest(parallelData, "norm", 0, 1)
# summary of the test including the p-value, test statistic, and null hypothesis
# if our p-value indicates significance, we can reject the null hypothesis
# Note that the Scala functionality of calling Statistics.kolmogorovSmirnovTest with
# a lambda to calculate the CDF is not made available in the Python API
print(testResult)
ストリーミングの有意テスト
spark.mllib
はA/Bテストのようなユースケースをサポートするために、幾つかのテストのオンライン実装を提供します。これらのテストは、各タプルの最初の要素がグループ(false
)あるいは投与群 (true
) を示し、二つ目の要素が観察の値である、Spark ストリーミングDStream[(Boolean,Double)]
上で実施されるかも知れません。
ストリーミングの有意テストは以下のパラメータをサポートします:
peacePeriod
- ストリームからの初期データで無視をする数。新しさの効果を緩和するために使われます。windowSize
- 仮説テストを実施する過去のバッチの数。0
に設定すると、全ての以前のバッチを使って累積処理を実施するでしょう。
StreamingTest
provides streaming hypothesis testing.
val data = ssc.textFileStream(dataDir).map(line => line.split(",") match {
case Array(label, value) => BinarySample(label.toBoolean, value.toDouble)
})
val streamingTest = new StreamingTest()
.setPeacePeriod(0)
.setWindowSize(0)
.setTestMethod("welch")
val out = streamingTest.registerStream(data)
out.print()
StreamingTest
provides streaming hypothesis testing.
import org.apache.spark.mllib.stat.test.BinarySample;
import org.apache.spark.mllib.stat.test.StreamingTest;
import org.apache.spark.mllib.stat.test.StreamingTestResult;
JavaDStream<BinarySample> data = ssc.textFileStream(dataDir).map(
new Function<String, BinarySample>() {
@Override
public BinarySample call(String line) {
String[] ts = line.split(",");
boolean label = Boolean.parseBoolean(ts[0]);
double value = Double.parseDouble(ts[1]);
return new BinarySample(label, value);
}
});
StreamingTest streamingTest = new StreamingTest()
.setPeacePeriod(0)
.setWindowSize(0)
.setTestMethod("welch");
JavaDStream<StreamingTestResult> out = streamingTest.registerStream(data);
out.print();
ランダムデータ生成
ランダムデータ生成はランダム化アルゴリズム、プロトタイピングおよびテストを実施するのに便利です。spark.mllib
は i.i.dを使ったランダムなRDDの生成をサポートします。指定された分散から取り出される値: uniform, standard normal, あるいは Poisson。
RandomRDDs
はランダムなdouble RDDあるいはベクトルRDDを生成するファクトリーメソッドを提供します。以下の例はランダムなdouble RDDを生成します。値は標準の通常の分散N(0, 1)
に従い、それをN(1, 4)
にマップします。
APIの詳細はRandomRDD
Scala ドキュメント を参照してください。
import org.apache.spark.SparkContext
import org.apache.spark.mllib.random.RandomRDDs._
val sc: SparkContext = ...
// Generate a random double RDD that contains 1 million i.i.d. values drawn from the
// standard normal distribution `N(0, 1)`, evenly distributed in 10 partitions.
val u = normalRDD(sc, 1000000L, 10)
// Apply a transform to get a random double RDD following `N(1, 4)`.
val v = u.map(x => 1.0 + 2.0 * x)
RandomRDDs
はランダムなdouble RDDあるいはベクトルRDDを生成するファクトリーメソッドを提供します。以下の例はランダムなdouble RDDを生成します。値は標準の通常の分散N(0, 1)
に従い、それをN(1, 4)
にマップします。
APIの詳細はRandomRDD
Java ドキュメント を参照してください。
import org.apache.spark.SparkContext;
import org.apache.spark.api.JavaDoubleRDD;
import static org.apache.spark.mllib.random.RandomRDDs.*;
JavaSparkContext jsc = ...
// Generate a random double RDD that contains 1 million i.i.d. values drawn from the
// standard normal distribution `N(0, 1)`, evenly distributed in 10 partitions.
JavaDoubleRDD u = normalJavaRDD(jsc, 1000000L, 10);
// Apply a transform to get a random double RDD following `N(1, 4)`.
JavaDoubleRDD v = u.map(
new Function<Double, Double>() {
public Double call(Double x) {
return 1.0 + 2.0 * x;
}
});
RandomRDDs
はランダムなdouble RDDあるいはベクトルRDDを生成するファクトリーメソッドを提供します。以下の例はランダムなdouble RDDを生成します。値は標準の通常の分散N(0, 1)
に従い、それをN(1, 4)
にマップします。
APIの詳細はRandomRDD
Python ドキュメント を参照してください。
from pyspark.mllib.random import RandomRDDs
sc = ... # SparkContext
# Generate a random double RDD that contains 1 million i.i.d. values drawn from the
# standard normal distribution `N(0, 1)`, evenly distributed in 10 partitions.
u = RandomRDDs.normalRDD(sc, 1000000L, 10)
# Apply a transform to get a random double RDD following `N(1, 4)`.
v = u.map(lambda x: 1.0 + 2.0 * x)
カーネル密度推定
Kernel density estimation は、観察される標本が取り出された特定の分散に関する仮定を必要とせずに経験的な確率分散を視覚化するのに便利な方法です。指定されたポイントのセットで評価されるランダムな値の可能性の濃度関数の推測を計算します。It achieves this estimate by expressing the PDF of the empirical distribution at a particular point as the the mean of PDFs of normal distributions centered around each of the samples.
KernelDensity
は標本のRDDからカーネル密度の推測を計算するメソッドを提供します。以下の例はどうやって行うかを実演します。
APIの詳細はKernelDensity
Scala ドキュメント を参照してください。
import org.apache.spark.mllib.stat.KernelDensity
import org.apache.spark.rdd.RDD
// an RDD of sample data
val data: RDD[Double] = sc.parallelize(Seq(1, 1, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9))
// Construct the density estimator with the sample data and a standard deviation
// for the Gaussian kernels
val kd = new KernelDensity()
.setSample(data)
.setBandwidth(3.0)
// Find density estimates for the given values
val densities = kd.estimate(Array(-1.0, 2.0, 5.0))
KernelDensity
は標本のRDDからカーネル密度の推測を計算するメソッドを提供します。以下の例はどうやって行うかを実演します。
APIの詳細はKernelDensity
Java ドキュメント を参照してください。
import java.util.Arrays;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.mllib.stat.KernelDensity;
// an RDD of sample data
JavaRDD<Double> data = jsc.parallelize(
Arrays.asList(1.0, 1.0, 1.0, 2.0, 3.0, 4.0, 5.0, 5.0, 6.0, 7.0, 8.0, 9.0, 9.0));
// Construct the density estimator with the sample data
// and a standard deviation for the Gaussian kernels
KernelDensity kd = new KernelDensity().setSample(data).setBandwidth(3.0);
// Find density estimates for the given values
double[] densities = kd.estimate(new double[]{-1.0, 2.0, 5.0});
System.out.println(Arrays.toString(densities));
KernelDensity
は標本のRDDからカーネル密度の推測を計算するメソッドを提供します。以下の例はどうやって行うかを実演します。
APIの詳細はKernelDensity
Python ドキュメント を参照してください。
from pyspark.mllib.stat import KernelDensity
# an RDD of sample data
data = sc.parallelize([1.0, 1.0, 1.0, 2.0, 3.0, 4.0, 5.0, 5.0, 6.0, 7.0, 8.0, 9.0, 9.0])
# Construct the density estimator with the sample data and a standard deviation for the Gaussian
# kernels
kd = KernelDensity()
kd.setSample(data)
kd.setBandwidth(3.0)
# Find density estimates for the given values
densities = kd.estimate([-1.0, 2.0, 5.0])