小编Chr*_*ris的帖子

我正在使用JRI作为Java内部统计数据的计算从属.R计算是不时需要的,但不是太频繁.因此,我决定为计算创建一个包装器方法,该方法创建一个新的REngine实例,并在结束时关闭它.第一次调用方法时,一切都像魅力一样.不幸的是,再次调用它会触发错误"R已经初始化".

初始化:

private static Rengine createEngineInstance(){

        //Initialise R Engine. 
        Rengine re=new Rengine (new String [] {"--vanilla"}, false, new CallbackListener());

        //Wait until REngine-thread is ready
        if (!re.waitForR())
        {
            System.err.println ("Cannot load R. Is the environment variable R_HOME set correctly?");
            System.exit(1);
        }
        return re;
}

包装方法:

public static void performR(){

    //Create instance of R engine
    Rengine re = createEngineInstance();

    //Perform some R operations
    re.eval("...");

    re.end();

}

显然,REngine实例未正确终止.因此,我需要知道:1)是否有机会终止REngine并再次创建新实例？这是如何正常工作的？我知道用JRI同时运行多个R线程是不可能的,但这不是我的目标.2)如果不是这种情况,我会使用Singleton模式创建一个实例.在这种情况下,如何确保在程序终止时R会话关闭？

非常感谢您的帮助!谢谢!

我正在尝试使用 imshow() 在 matplotlib 中绘制一个二维数组，并在第二个 y 轴上用散点图覆盖它。

oneDim = np.array([0.5,1,2.5,3.7])
twoDim = np.random.rand(8,4)

plt.figure()
ax1 = plt.gca()

ax1.imshow(twoDim, cmap='Purples', interpolation='nearest')
ax1.set_xticks(np.arange(0,twoDim.shape[1],1))
ax1.set_yticks(np.arange(0,twoDim.shape[0],1))
ax1.set_yticklabels(np.arange(0,twoDim.shape[0],1))
ax1.grid()

#This is the line that causes problems
ax2 = ax1.twinx()

#That's not really part of the problem (it seems)
oneDimX = oneDim.shape[0]
oneDimY = 4
ax2.plot(np.arange(0,oneDimX,1),oneDim)
ax2.set_yticks(np.arange(0,oneDimY+1,1))
ax2.set_yticklabels(np.arange(0,oneDimY+1,1))

如果我只将所有内容运行到最后一行，我就会完全可视化我的数组：

但是，如果我添加第二个 y 轴 (ax2=ax1.twinx()) 作为散点图的准备，它会更改为这种不完整的渲染：

有什么问题？我在上面的代码中留下了几行描述散点图的添加，尽管它似乎不是问题的一部分。

我想取一个 numpy 数组的自然对数，但根本不计算 0 条目的对数。即我想在 numpy 数组上实现约定 log(0)=0 。

import numpy as np
import timeit
foo = np.random.rand(500)
%timeit np.log(foo)
%timeit np.log(foo,where=foo>0)

对于第一次调用，这会产生

最慢的运行时间比最快的运行时间长 12.63 倍。这可能意味着正在缓存中间结果。100000 个循环，最好的 3 个：每个循环 2.06 µs

对于第二次调用，我们得到

最慢的运行时间比最快的运行时间长 8.35 倍。这可能意味着正在缓存中间结果。100000 个循环，最好的 3 个：每个循环 4.31 µs

因此，避免使用 0（即使在这种情况下数组中没有零）的成本要高得多。如果我们查看稀疏数组，这显然是不同的，但是即使在非稀疏情况下，是否有更有效的方法来避免零？

这个问题是关于语法和语义的,因此请在Cross-Validated上找到一个(但尚未答复的)副本:https://stats.stackexchange.com/questions/113324/repeated-measures-anova-ezanova-vs-aov-vs -lme语法

在机器学习领域,我在相同的5个数据集上评估了4个分类器,即每个分类器返回数据集1,2,3,...和5的性能度量.现在我想知道分类器是否在它们的显着不同性能.这是一些玩具数据:

Performance<-c(2,3,3,2,3,1,2,2,1,1,3,1,3,2,3,2,1,2,1,2)
Dataset<-factor(c(1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5))
Classifier<-factor(c(1,1,1,1,1,2,2,2,2,2,3,3,3,3,3,4,4,4,4,4))
data<-data.frame(Classifier,Dataset,Performance)

在教科书之后,我进行了重复测量的单因素方差分析.我将我的表现解释为因变量,将分类器解释为主体,将数据集解释为主体内因子.使用aov,我得到了:

model <- aov(Performance ~ Classifier + Error(factor(Dataset)), data=data)
summary(model)

产生以下输出:

Error: factor(Dataset)
           Df Sum Sq Mean Sq F value Pr(>F)
Residuals  4    2.5   0.625               

Error: Within
            Df Sum Sq Mean Sq F value Pr(>F)  
Classifier  3    5.2  1.7333   4.837 0.0197 *
Residuals  12    4.3  0.3583 

使用线性混合效果模型时,我得到类似的结果:

model <- lme(Performance ~ Classifier, random = ~1|Dataset/Classifier,data=data)
result<-anova(model)

然后,我尝试用ezANOVA重现结果,以便对Sphericity执行Mauchlys测试:

 ezANOVA(data=data, dv=.(Performance), wid=.(Classifier), within=.(Dataset), detailed=TRUE, type=3)

产生以下输出:

        Effect DFn DFd  SSn SSd         F …

我想通过 brewer 调色板使用scale_colour_brewer()和scale_fill_brewer()指定填充或颜色：

diagram <- diagram + scale_colour_brewer() + scale_fill_brewer()

尽管如此，我仍然想手动设置图例标签及其条目。我以前这样做过：

diagram + 
  scale_colour_manual(name="Cumulative Percentage", 
  values=c("#d7191c","#fdae61","#000000","#abdda4","#2b83ba"), 
  labels=c("GN","GN1","GN2","GN3","GN4"))

如何使用自动调色板功能，同时仍手动设置图例名称和条目标签？

谢谢！

我想创建一个带有线条和条形的 ggplot2 图表，可视化不同的 y 和 ybar 值。线条上覆盖有同样基于 y 值的点。最后应该有 2 个图例，一个用于线（+点）图，包括颜色、形状和线型，另一个用于条形图，包括填充颜色。线型、点形状和颜色根据变量类型（y1 或 y2）进行更改。这很有效，直到我想要手动设置图例名称和项目标签：

数据帧初始化的最少代码：

library(ggplot2)
library(reshape)
df = data.frame(c(10,20,40),c(0.1,0.2,0.3),c(0.1,0.4,0.5),c(0.05,0.1,0.2),c(0,0.2,0.4))
names(df)[1]="classes"
names(df)[2]="y1"
names(df)[3]="y2"
names(df)[4]="bary1"
names(df)[5]="bary2"
df$classes <- factor(df$classes,levels=c(10,20,40), labels=c("10m","20m","40m"))

创建点图、线图和条形图的最少代码：

dfMelted <- melt(df)
diagram <- ggplot()
diagram <- diagram + theme_bw(base_size=16)
diagram <- diagram + geom_bar(data=subset(dfMelted,variable=="bary1" | variable=="bary2"), aes(x=factor(classes),y=value, fill=variable),stat="identity",position="dodge")
diagram <- diagram + geom_point(data=subset(dfMelted,variable=="y1" | variable=="y2"), size=4, aes(x=factor(classes),y=value, colour=variable, shape=variable)) 
diagram <- diagram + geom_line(data=subset(dfMelted,variable=="y1" | variable=="y2"), aes(x=factor(classes),y=value, group=variable, colour=variable, linetype=variable))

初步结果：

通过以下代码设置图例名称/项目标签：

diagram + scale_colour_brewer(name="Line Legend",labels=c("Foo","Bar")) + scale_fill_brewer(name="Bar Legend",labels=c("Foo …

我想创建一个多面线图。在每个子图中，将一个 y 值（y1 或 y2）与基线进行比较。y 值和基线应使用不同的颜色进行可视化，但此配色方案应在每个子图中保持一致。作为图例，我只需要 2 个条目：“y 值”和“基线”，因为每个子图的标题都指定了要比较的 y 值。

然而，我只得到这个（示例代码）：

library(ggplot2)
library(reshape)

df = data.frame(c(10,20,40),c(0.1,0.2,0.3),c(0.1,0.4,0.5),c(0.05,0.1,0.2))
names(df)[1]="classes"
names(df)[2]="y1"
names(df)[3]="y2"
names(df)[4]="baseline"
df$classes <- factor(df$classes,levels=c(10,20,40), labels=c("10m","20m","40m"))

dfMelted <- melt(df)
diagram <- ggplot()
diagram <- diagram + theme_bw(base_size=16)
diagram <- diagram + geom_point(data=dfMelted, size=4, aes(x=factor(classes),y=value, colour=variable, shape=variable)) 
diagram <- diagram + geom_line(data=dfMelted, aes(x=factor(classes),y=value, group=variable, colour=variable))
diagram <- diagram + facet_wrap(~ variable, ncol=1)
diagram

到目前为止，情况是这样的：

我尝试创建组，每个组包含一个 y 数据集和重复的基线数据。然后，我在组列方面使用了分面。不幸的是，这导致使用许多不同的颜色和巨大的图例。有没有更好的方法来做到这一点？

我得到了一个抽象基类"Parent",它带有一个纯虚方法和一个实现这个方法的子类"Child"和一个成员"value".我将子类的对象实例化为shared_ptr,作为动态绑定的一种方式.我在这里使用shared_ptr而不是引用,因为我将这些对象存储在std :: vector中.

现在我想比较源代码底部定义的两个对象"someObject"和"anotherObject".因此,我在相应的Child类中覆盖了==运算符.然而,只调用shared_ptr的==运算符.我可以对后面的动态绑定对象进行比较吗？

/*
* Parent.h
*/
class Parent{
public:
    virtual ~Parent(){};
    virtual void someFunction() = 0;
};


/*
* Child.h
*/
class Child : public Base{
private:
    short value;

public:
    Child(short value);
    virtual ~Child();
    bool operator==(const Child &other) const;
    void someFunction();
};


/*
* Child.cpp
*/
#include "Child.h"

Child::Child(short value):value(value){}
Child::~Child() {}
void Child::someFunction(){...}

bool Child::operator==(const Child &other) const {
  if(this->value==other.value){
      return true;
  }
  return false;
}


/*
* Some Method
*/
std::shared_ptr<Parent> someObject(new Child(3));
std::shared_ptr<Parent> anotherObject(new Child(4)); …