小编bri*_*tar的帖子

题

在R中进行探索性分析的重复试验中积累的分类标签构建多变量数据的正确方法是什么？我不想回到MATLAB.

说明

我喜欢R的分析函数和语法(以及令人惊叹的绘图)比MATLAB更好,并且一直在努力重构我的东西.但是,我一直对工作中数据的组织方式感到困惑.

MATLAB

我通常使用多个时间序列来重复多次试验,这些试验存储在SERIESxSAMPLESxTRIALS 的大矩阵 秩-3张量多维数组中.这偶尔适用于一些不错的线性代数东西,但是当涉及另一个变量,即CLASS时,它是笨拙的.通常,类标签存储在尺寸为1x的另一个矢量中TRIALS.

在分析方面,我基本上尽可能少地绘制,因为需要做很多工作来组合一个非常好的情节,教你很多关于MATLAB中的数据.(我不是唯一一个有这种感觉的人).

[R

在R中我一直坚持尽可能接近MATLAB结构,但是当试图保持类标签分离时,事情变得非常复杂; 即使我只使用它们的属性,我也必须继续将标签传递给函数.所以我所做的就是通过CLASS将数组分成一个数组列表.这增加了我所有apply()功能的复杂性,但在保持一致性(和错误)方面似乎是值得的.

另一方面,R对于张量/多维数组似乎并不友好.只是为了与他们合作,你需要抓住abind图书馆.关于多变量分析的文档,比如这个例子似乎是假设你有一个巨大的2-D数据点表,比如一些长期的中世纪滚动数据框,并且没有提到如何从我所在的位置获得'那里' .

一旦我对绘制的数据进行绘图和分类,它就不是一个大问题了,因为到那时我一直在使用像TRIALSxFEATURES这样的形状的数据框架友好结构(melt对此有很大帮助).另一方面,如果我想快速生成探索阶段的散点图矩阵或latticist直方图集(即统计矩,分离,类/方差,直方图等),我必须停下来弄清楚如何我将apply()这些巨大的多维数组转换为这些库所理解的东西.

如果我继续在丛林中捣乱,为此提出临时解决方案,我要么永远不会变得更好,要么我最终会以自己奇怪的巫术方式结束,这对任何人都没有意义.

那么,对于R中的探索性分析,在重复试验中积累的分类标签构建多变量数据的正确方法是什么？拜托,我不想回到MATLAB.

额外奖励:我倾向于在多个主题的相同数据结构上重复这些分析.有没有比将代码块包装到for循环更好的通用方法？

根据文档,microbenchmark:::autoplot"使用ggplot2生成更清晰的微基准时序图."

凉!我们来试试示例代码:

library("ggplot2")
tm <- microbenchmark(rchisq(100, 0),
                     rchisq(100, 1),
                     rchisq(100, 2),
                     rchisq(100, 3),
                     rchisq(100, 5), times=1000L)
autoplot(tm)

我没有看到任何关于...文档中的软弱起伏,但是我从功能创建者的这个答案中得到的最好的猜测是,这就像一个平滑的系列时间表的箱形图,上下都是四分相连接在形状的主体上.也许？这些情节看起来太有趣了,不知道这里发生了什么.

这是一个情节是什么？

许多的不同如何渡上药剂编程表达认为存储状态或运行的无限循环是基于旋转数据断开成代理或任务,或者由需要状态的功能的无限递归惯用任一完成.他们没有提到递归的深度或任何其他警告的任何限制.

由于搜索"Elixir堆栈溢出"只会导致对此网站的点击,让我删除歧义并在此处询问:Elixir中有哪些实现保证确保无限递归作为'循环'的方法不会导致堆栈溢出,特别是当沿途传输状态信息时？

我搜索了Elixir和Phoenix文档,以及其他一些网站,比如Learn Elixir,没有运气.这是它的样子:

defp update_positions(item_ids) do
  item_ids = String.split(item_ids, ",")
                    |> Enum.map fn item_id -> String.to_integer(item_id) end

  items = Repo.all(Item |> where([item], item.id in array(^item_ids, :integer)))
  item_hash = Enum.reduce items, %{}, fn item, map -> Map.put(map, item.id, item) end

  item_ids
    |> Stream.with_index
    |> Enum.each fn {item_id, index} ->
      item = item_hash[item_id]
      Repo.update(%{item | position: index + 1})
    end
end

起初我认为它只是一个行继续符号来保持代码可读,但Item |> where上面的行表示不然.它是列表理解还是指定输入类型的东西？

我正在尝试设置汇总以使用SCSS样式表和Lost网格系统,这需要通过PostCSS进行解析.我已经验证SCSS正在被正确解析,但PostCSS处理器似乎没有任何影响.

根据rollup-plugin-sass文档,我只需要将vanilla JS函数传递给该processor选项.这没有错误,但生成的CSS没有什么不同.

这是我的汇总配置,用rollup -c config/dev.js:

// Rollup plugins.
import babel from 'rollup-plugin-babel';
import cjs from 'rollup-plugin-commonjs';
import globals from 'rollup-plugin-node-globals';
import replace from 'rollup-plugin-replace';
import resolve from 'rollup-plugin-node-resolve';
import sass from 'rollup-plugin-sass';
import postcss from 'postcss';
const postcssProcessor = postcss([require('autoprefixer'), require('lost')]);

export default {
  dest: 'dist/app.js',
  entry: 'src/index.jsx',
  format: 'iife',
  plugins: [
    resolve({
      browser: false,
      main: true
    }),
    sass({
//      processor: postcssProcessor,
      output: 'dist/styles.css'
    }),
    babel({
      babelrc: false,
      exclude: 'node_modules/**',
      presets: [ …

我有一个如下所示的数据框:

er.frame <- structure(c(0.475, 0.525, 0.45, 0.475, 0.45, 0.55, 0.425, 0.5, 
0.5, 0.4, 0.45, 0.375, 0.55, 0.425, 0.5, 0.475, 0.4, 0.45, 0.375, 
0.55, 0.425), .Dim = c(7L, 3L), .Dimnames = list(NULL, c("CSP.LDA.error.rate", 
"CSP.SWLDA.error.rate", "CSP.SVM.error.rate")))

kable(er.frame)

|  CSP.LDA.error.rate|  CSP.SWLDA.error.rate|  CSP.SVM.error.rate|
|-------------------:|---------------------:|-------------------:|
|               0.475|                 0.500|               0.500|
|               0.525|                 0.500|               0.475|
|               0.450|                 0.400|               0.400|
|               0.475|                 0.450|               0.450|
|               0.450|                 0.375|               0.375|
|               0.550|                 0.550|               0.550|
|               0.425|                 0.425|               0.425|

我希望在HTML报告中kable处理输出knitr并创建一个很好的表.在文档中?kable,我做了这个片段:

``` {r snippet}
opts_chunk$set(results='asis')
kable(er.frame) …

我在这台机器上有32GB的ram,但我可以比任何人更快地杀死R;)

例

这里的目标是rbind()使用利用data.table效率的函数来实现两个data.tables.

输入:

rm(list=ls())
gc()

输出:

          used (Mb) gc trigger   (Mb)  max used   (Mb)
Ncells 1604987 85.8    2403845  128.4   2251281  120.3
Vcells 3019405 23.1  537019062 4097.2 468553954 3574.8

输入:

tmp.table <- data.table(X1=sample(1:7,4096000,replace=TRUE),
                           X2=as.factor(sample(1:2,4096000,replace=TRUE)),
                           X3=sample(1:1000,4096000,replace=TRUE),
                           X4=sample(1:256,4096000,replace=TRUE),
                           X5=sample(1:16,4096000,replace=TRUE),
                           X6=rnorm(4096000))

setkey(tmp.table,X1,X2,X3,X4,X5,X6)

join.table <- data.table(X1 = integer(), X2 = factor(), 
                         X3 = integer(), X4=integer(),
                         X5 = integer(), X6 = numeric())

setkey(join.table,X1,X2,X3,X4,X5,X6)

tables()

输出:

     NAME            NROW  MB COLS              KEY              
[1,] join.table         0   1 X1,X2,X3,X4,X5,X6 X1,X2,X3,X4,X5,X6
[2,] tmp.table  4,096,000 110 X1,X2,X3,X4,X5,X6 X1,X2,X3,X4,X5,X6
Total: …

Rust 正则表达式表明:

此crate提供了正则表达式的本机实现,它在语法和实现方面都基于RE2.值得注意的是,未提供反向引用和任意前瞻/后瞻断言.

在撰写本文时,"Rust regex lookbehind"回来后没有DuckDuckGo的结果.

我以前从来没有解决过这个问题,但我可以想到两种方法:

方法1(前进)

1. 迭代.captures()我想用作lookbehind的模式.
2. 匹配我想要在捕获之间匹配的东西.(向前)

方法2(反向)

1. 匹配我真正想要匹配的模式.
2. 对于每个匹配,查找lookbehind模式,直到上一次捕获的结束字节或字符串的开头.

这不仅是一个巨大的痛苦,似乎很多边缘案件都会让我感到震惊.有没有更好的方法来解决这个问题？

例

给出如下字符串:

"Fish33-Tiger2Hyena4-"

我想提取["33-", "2", "4-"]iff每个跟随一个字符串之类的"Fish".

例如,如果我有以下代码:

enum Foo {
    Bar,
    Baz,
    Bat,
    Quux
}

impl Foo {
    from(input: &str) -> Foo {
        Foo::input
    }
}

这显然会失败,因为input它不是Foo的方法.我可以手动输入:

from(input: &str) -> Foo {
    match(input) {
        "Bar" => Foo::Bar,
        // and so on...
    }
}

但我没有获得自动便利.

看起来Java 在枚举上有一个字符串查找功能,用于此特定目的.

是不是可以在不编写自己的宏或从箱子中导入宏的情况下获得这个？

我想R中使用随机梯度下降,以建立自己的回归函数,但我现在所拥有的使权重成长过程中没有约束,因此从来没有停止:

# Logistic regression
# Takes training example vector, output vector, learn rate scalar, and convergence delta limit scalar
my_logr <- function(training_examples,training_outputs,learn_rate,conv_lim) {
  # Initialize gradient vector
  gradient <- as.vector(rep(0,NCOL(training_examples)))
  # Difference between weights
  del_weights <- as.matrix(1)
  # Weights
  weights <- as.matrix(runif(NCOL(training_examples)))
  weights_old <- as.matrix(rep(0,NCOL(training_examples)))

  # Compute gradient
  while(norm(del_weights) > conv_lim) {

    for (k in 1:NROW(training_examples)) {
      gradient <- gradient + 1/NROW(training_examples)*
        ((t(training_outputs[k]*training_examples[k,]
            /(1+exp(training_outputs[k]*t(weights)%*%as.numeric(training_examples[k,]))))))
    }

    # Update weights
    weights <- weights_old - learn_rate*gradient
    del_weights <- as.matrix(weights_old - weights)
    weights_old <- …