小编use*_*995的帖子

如何在猫库涉及到scalaz？Cats项目提到它是scalaz的后代.

我有一个具有以下架构的配置单元表:

COOKIE  | PRODUCT_ID | CAT_ID |    QTY    
1234123   [1,2,3]    [r,t,null]  [2,1,null]

我如何规范化数组,以便得到以下结果

COOKIE  | PRODUCT_ID | CAT_ID |    QTY

1234123   [1]          [r]         [2]

1234123   [2]          [t]         [1] 

1234123   [3]          null       null 

我尝试过以下方法:

select concat_ws('|',visid_high,visid_low) as cookie
,pid
,catid 
,qty
from table
lateral view explode(productid) ptable as pid
lateral view explode(catalogId) ptable2 as catid 
lateral view explode(qty) ptable3 as qty

然而结果是笛卡尔积.

我正在使用带有Hive的Spark 1.3.1,并且有一个行对象,它是一系列传递给Vecors.dense构造函数的双重对象,但是当我通过一个行转换为一个数组时

SparkDataFrame.map{r => r.toSeq.toArray} 

丢失所有类型信息,然后返回[Any]类型的数组.我无法将此对象强制转换为使用

SparkDataFrame.map{r => 
  val array = r.toSeq.toArray 
  array.map(_.toDouble) 
} // Fails with value toDouble is not a member of any

同样如此

SparkDataFrame.map{r => 
      val array = r.toSeq.toArray 
      array.map(_.asInstanceOf[Double]) 
    } // Fails with java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.Double 

我看到Row对象有一个API,支持通过以下方式将特定元素作为类型获取:

SparkDataFrame.map{r => 
  r.getDouble(5)}  

但是事件失败,java.lang.Integer无法转换为java.lang.Double

我发现的唯一工作如下:

 SparkDataFrame.map{r => 
  doubleArray = Array(r.getInt(5).toDouble, r.getInt(6).toDouble) 
  Vectors.dense(doubleArray) } 

然而,当索引5到1000需要转换为双精度数组时,这是非常繁琐的.

有没有明确索引行对象？

我已经在这里训练了recipie以下的烤宽面条一个简单的长短期记忆(LSTM)型号:https://github.com/Lasagne/Recipes/blob/master/examples/lstm_text_generation.py

这是架构:

l_in = lasagne.layers.InputLayer(shape=(None, None, vocab_size))

# We now build the LSTM layer which takes l_in as the input layer
# We clip the gradients at GRAD_CLIP to prevent the problem of exploding gradients. 

l_forward_1 = lasagne.layers.LSTMLayer(
    l_in, N_HIDDEN, grad_clipping=GRAD_CLIP,
    nonlinearity=lasagne.nonlinearities.tanh)

l_forward_2 = lasagne.layers.LSTMLayer(
    l_forward_1, N_HIDDEN, grad_clipping=GRAD_CLIP,
    nonlinearity=lasagne.nonlinearities.tanh)

# The l_forward layer creates an output of dimension (batch_size, SEQ_LENGTH, N_HIDDEN)
# Since we are only interested in the final prediction, we isolate that quantity and feed it to …

用于确定字符串是否是回文结构的函数可以通过无点的应用方式实现

pal1 = (==) <$> reverse <*> id 

这是一个monadic版本

reverse >>= (==)

modadic版本如何在没有显式调用id的情况下工作？我试图使用有点的方式查看指向的表示并返回相同的函数.

我有一个包含 150 个变量的列表，它们具有以下可能值：

   domain = ['val1', 'val2', 'val2'] 

我想将它们转换为用作 matplot 散点图的颜色。目前，我编写了一个函数来手动从数据域映射到颜色范围，例如：

  colors = ['aquamarine','purple','blue']
  color_map = dict(zip(domain, colors)) 
  colorize = lambda x : color_map[x]
  c = list(map(colorize, labels))

  #and then I explicitly pass the array to scatter: 
  scatter = ax.scatter(t_x,
                 t_y,
                 c=c,
                 alpha=0.3,
                 cmap=plt.cm.cool,
                 s = 500)

然而，这是有效的，我必须指定我的域的每个元素映射到的颜色。有没有办法让 matplotlib 为我做到这一点，这样我就可以利用 cmaps 了？D3 有一种从数据域映射到颜色范围的方法。

我正在编写一个小型库,用于与一些外部API进行交互.一组函数将构造对yahoo api的有效请求,并将结果解析为数据类型.另一组功能将基于IP查找用户当前位置并返回表示当前位置的数据类型.虽然代码有效,但似乎必须显式模式匹配才能对IO类型的多个函数进行排序(可能是a).

-- Yahoo API

constructQuery :: T.Text -> T.Text -> T.Text
constructQuery city state = "select astronomy,  item.condition from weather.forecast" <>
                            " where woeid in (select woeid from geo.places(1)" <>
                            " where text=\"" <> city <> "," <> state <> "\")"

buildRequest :: T.Text -> IO ByteString
buildRequest yql = do
    let root = "https://query.yahooapis.com/v1/public/yql"
        datatable = "store://datatables.org/alltableswithkeys"
        opts = defaults & param "q" .~ [yql]
                          & param "env" .~ [datatable]
                          & param "format" .~ ["json"]
    r <- getWith …

我需要使用流/列表上的scalas组合方法为30,000个项目列表生成组合

1 to 30000.toStream.combinations(2).size 

此功能永远不会完成.当我在python中尝试相同的操作时

r = list(range(1,30000))
z = itertools.combinations(r, 2)
%time sum(1 for _ in z)

操作在26.2秒内完成.

这里发生了什么？如何在scala中生成非常大的列表组合？

在haskell中,我可以对字符串执行以下操作

let f = sequence [id, reverse]
f "test" 

如果使用Cats更好的方法来解决这个问题,我有点不知所措.我现在有类似的东西

val f = List(fun1,fun2)
val data = "test"

f map {fun => fun(data)} 

是否可以使用Cats实现Sequence或SequenceU的实现？