小编cwl*_*cwl的帖子

在Pandas DataFrame中,我可以使用DataFrame.isin()函数将列值与另一列匹配.

例如:假设我们有一个DataFrame:

df_A = pd.DataFrame({'col1': ['A', 'B', 'C', 'B', 'C', 'D'], 
                     'col2': [1, 2, 3, 4, 5, 6]})
df_A

    col1  col2
0    A     1
1    B     2
2    C     3
3    B     4
4    C     5
5    D     6         

和另一个DataFrame:

df_B = pd.DataFrame({'col1': ['C', 'E', 'D', 'C', 'F', 'G', 'H'], 
                     'col2': [10, 20, 30, 40, 50, 60, 70]})
df_B

    col1  col2
0    C    10
1    E    20
2    D    30
3    C    40
4    F    50
5 …

我的目标是将可配置的常量值添加到DataFrame的给定列.

val df = Seq(("A", 1), ("B", 2), ("C", 3)).toDF("col1", "col2")

+----+----+
|col1|col2|
+----+----+
|   A|   1|
|   B|   2|
|   C|   3|
+----+----+

为此,我可以使用硬编码定义UDF,如下所示:

val add100 = udf( (x: Int) => x + 100)
df.withColumn("col3", add100($"col2")).show()

+----+----+----+
|col1|col2|col3|
+----+----+----+
|   A|   1| 101|
|   B|   2| 102|
|   C|   3| 103|
+----+----+----+    

我的问题是,使数字(100以上)可配置的最佳方法是什么？

我尝试了以下方式,似乎工作.但我想知道是否还有其他更好的方法来实现相同的运营结果？

val addP = udf( (x: Int, p: Int) => x + p )
df.withColumn("col4", addP($"col2", lit(100)))

+----+----+----+
|col1|col2|col4|
+----+----+----+
|   A|   1| 101|
|   B| …

我正在使用 hmmlearn 的 GaussianHMM 来训练具有高斯观测的隐马尔可夫模型。每个隐藏状态k都有其对应的高斯参数：mu_k，Sigma_k。

训练模型后，我想计算以下数量：

P(z_{T+1} = j | x_{1:T}),

其中 j = 1, 2, ... K，K 是隐藏状态的数量。

上述概率基本上是一步前进的隐藏状态概率，给定完整的观察序列：x_1, x_2, ..., x_T，其中 x_i, i=1,...,T 用于训练 HMM模型。

我阅读了文档，但找不到计算此概率的函数。有什么解决方法吗？

我有一个 Spark DataFrame，如下所示

df.show()
+------+------+------+
|  col1|  col2|  col3|
+------+------+------+
|   5.0|   5.0|   0.0|
|   2.0|   3.0|   5.0|
|   4.0|   1.0|  10.0|
+------+------+------+

我想标准化每个单独的行，以便在操作后，新列看起来像：

+--------+--------+--------+
|new_col1|new_col2|new_col3|
+--------+--------+--------+
|     0.5|     0.5|     0.0|
|     0.2|     0.3|     0.5|
|0.266667|0.066667|0.666667|
+--------+--------+--------+

更正式地说，我想申请的操作是：

对于每一行，

    new_col_i = col_i / (col_1 + col_2 + col_3)

我需要以编程方式执行此操作，而不是列出所有列，因为我的 DataFrame 有很多列。

当前解决方案：

我想到的当前解决方案是创建一个列来表示每行所有条目的总和，然后将每列除以该总和列。

var newDF = df.withColumn("total", df.columns.map(c => col(c)).reduce((c1, c2) => c1 + c2))

for (c <- Array("col1", "col2", "col3")) {
    newDF = newDF.withColumn("normalized_" + c, col(c).divide(col("total")))
}
newDF.show() …

我正在阅读Chiusano和Bjarnason 在Scala中的函数式编程.

在第10章中,他们定义了Monoid特征:

trait Monoid[A] {
    def op(a1: A, a2: A): A
    def zero: A
}

特征的两个示例实例如下:

1)StringMonoid:

val stringMonoid = new Monoid[String] {
    def op(a1: String, a2: String) = a1 + a2
    val zero = ""
}

2)ListMonoid:

def listMonoid[A] = new Monoid[List[A]] {
    def op(a1: List[A], a2: List[A]) = a1 ++ a2
    val zero = Nil
}

我的问题是,为什么我们使用val中的情况下stringMonoid,和def在listMonoid？

假设我有以下字符串数组:

val lines: List[String] = List("GOOL,1182", "AMZN,1920", "MSFT,124", "APPL,192.2") 

实际上,通常通过读取csv文件来获得这种类型的数组.

从概念上讲,我想

1. 对于每一行,将其拆分为","
2. 拆分所有行后,将第一列分配给List,将第二列分配给另一个List.

我想出的方法如下:

var col1List = List[String]()
var col2List = List[String]()
lines.foreach{ x => 
  val cols = x split ","
  col1List = col1List ::: List(cols(0))
  col2List = col2List ::: List(cols(1))
}

之后,我得到以下列表:

List[String] = List(GOOL, AMZN, MSFT, APPL)
List[String] = List(1182, 1920, 124, 192.2)

在Scala中有更好的方法吗？