मुझे कोई सुराग नहीं है कि पाइस्पार्क का उपयोग करके कॉलम के भीतर सकारात्मक या नकारात्मक मानों को कैसे फ़िल्टर किया जाए, क्या आप मदद कर सकते हैं?

मेरे पास 10 एमएम + पंक्तियों और 50+ कॉलम के साथ एक स्पार्क डेटाफ्रेम है और एक विशिष्ट कॉलम में मान 0 के बराबर या उससे कम समय की गणना करने की आवश्यकता है।

अग्रिम में धन्यवाद।

2
Giordan Pretelin 14 सितंबर 2018, 17:55

3 जवाब

सबसे बढ़िया उत्तर

जिस कॉलम को आप लक्षित करना चाहते हैं, उसके लिए आप केवल डेटाफ़्रेम को फ़िल्टर कर सकते हैं जब मान <= 0 हो और मानदंड को पूरा करने वाली पंक्तियों की संख्या गिनें।

import pyspark.sql.functions as func

df.filter(func.col("colname") <= 0).count()
6
vielkind 14 सितंबर 2018, 18:53

आप pyspark का उपयोग करके स्पार्क डेटाफ़्रेम से नकारात्मक और सकारात्मक मानों को फ़िल्टर और गिनने के लिए निम्नलिखित समाधानों का उपयोग कर सकते हैं:

df.filter(col("colname") <= 0).count() //or
df.filter("colname <= 0").count()

दोनों काम करना चाहिए।

2
Grant Miller 15 सितंबर 2018, 02:25

मुझे एक बड़ी तालिका (60 मीटर + रिकॉर्ड, 3000+ कॉलम) के लिए कुछ ऐसा ही करना था, और प्रति कॉलम गिनती की गणना करने में बहुत समय लगता था। इसके बजाय मैंने प्रत्येक पंक्ति को 0 या 1 पर मैप किया; 1 यदि मान ऋणात्मक था, 0 अन्यथा। फिर बस इस रूपांतरित डेटाफ़्रेम को जोड़ दें, और परिणाम प्रत्येक कॉलम की गणना का प्रतिनिधित्व करता है जहाँ मान नकारात्मक है।

यह स्कैला में नमूना है

import org.apache.spark.sql.catalyst.encoders.RowEncoder
import org.apache.spark.sql._
import org.apache.spark.sql.types._

val df = spark.createDataFrame(
      spark.sparkContext.parallelize(Seq(
        Row(-4.0, 5.0, -2.0), 
        Row(4.0, -5.0, -2.0), 
        Row(-4.0, 5.0, -2.0))),
      StructType(List(
        StructField("col1", DoubleType, true),
        StructField("col2", DoubleType, true),
        StructField("col3", DoubleType, true)
      ))
    )

val columns = df.columns
val transformedSchema = StructType(columns.map(col => StructField(col, LongType)))
val transformedDf = df.map(row => {
      val transformed = columns.map(col => 
        if (row.getDouble(row.fieldIndex(col)) < 0.0) 1L else 0L)
      Row.fromSeq(transformed)
    })(RowEncoder.apply(transformedSchema))

आउटपुट:

scala> df.show
+----+----+----+
|col1|col2|col3|
+----+----+----+
|-4.0| 5.0|-2.0|
| 4.0|-5.0|-2.0|
|-4.0| 5.0|-2.0|
+----+----+----+

scala> transformedDf.show
+----+----+----+
|col1|col2|col3|
+----+----+----+
|   1|   0|   1|
|   0|   1|   1|
|   1|   0|   1|
+----+----+----+

scala> transformedDf.groupBy().sum().show()
+---------+---------+---------+                                                 
|sum(col1)|sum(col2)|sum(col3)|
+---------+---------+---------+
|        2|        1|        3|
+---------+---------+---------+
1
twang 27 अप्रैल 2019, 00:16