小编Gio*_*oni的帖子

在seqR中的功能会给我一个序列来自x于y一个恒定的一步m:

seq(x, y, m)

例如seq(1,9,2) = c(1,3,5,7,9).

什么是最优雅的方式从中获取的顺序x,以y与交替的步骤m1和m2,这样类似"seq(x, y, c(m1, m2))"会给我c(x, x + m1, (x + m1) + m2, (x + m1 + m2) + m1, ..., y),每次加的步骤之一(不一定达到最高y,当然,如seq)？

例子:x = 1; y = 19; m1 = 2; m2 = 4我明白了c(1,3,7,9,13,15,19).

是否可以plt.show()在 plotly 的 Dash 框架中显示一个简单的 matplotlib 图（通常由 生成的那种）？或者只是带有 plotly 的散点和数据轨迹的类似情节的图形？

具体来说，我想我需要一个与Graph（见下文）不同的组件以及一种在update_figure函数中返回简单图的方法。

例子：

import dash
import dash_core_components as dcc
import dash_html_components as html
import numpy as np
import matplotlib.pyplot as plt

app = dash.Dash()

app.layout = html.Div(children=[
    html.H1(children='Hello Dash'),

    dcc.Slider(
        id='n_points',
        min=10,
        max=100,
        step=1,
        value=50,
    ),

    dcc.Graph(id='example') # or something other than Graph?...
])

@app.callback(
    dash.dependencies.Output('example', 'figure'),
    [dash.dependencies.Input('n_points', 'value')]
)

def update_figure(n_points):
    #create some matplotlib graph
    x = np.random.rand(n_points)
    y = np.random.rand(n_points)
    plt.scatter(x, y)
    # …

我使用的Dell Latitude E7440 笔记本电脑与Windows 7企业OS,8GB RAM,64位操作系统,英特尔(R)核心(TM)i7-4600U CPU @ 2.10GHz处理器,2701兆赫,2个核,4个逻辑处理器(那是4个核心).

我使用的是Dell Precision塔式7810 桌面与Windows 7企业版操作系统,32GB的RAM,64位操作系统,英特尔(R)至强(R)CPU E5-2620 V3 @ 2.40GHz的2个处理器,2401兆赫,6个核心,12逻辑处理器(24核).

我使用R的一个很好的演示是使用gbmRStudio在具有约300个特征的100K大小的数据上运行二进制分类.但无论我在我的笔记本电脑R版本(所有其他软件关闭,不使用并行化)上做什么,都比我的桌面R版本快得多.怎么可能？我需要做些什么才能找到答案？

笔记本电脑:

> sum <- 0; system.time(for (i in 1:1000000) sum <- sum + i)
   user  system elapsed 
   0.36    0.00    0.36 
> memory.limit()
[1] 8097
> sessionInfo()
R version 3.3.1 (2016-06-21)
Platform: x86_64-w64-mingw32/x64 (64-bit)
Running under: Windows 7 x64 (build 7601) Service Pack 1

locale:
[1] LC_COLLATE=English_United States.1252  LC_CTYPE=English_United States.1252    LC_MONETARY=English_United …

我有一个带有分类变量的数据框,其中包含可变长度的字符串列表(这很重要,因为否则此问题将与此或此重复),例如:

df <- data.frame(x = 1:5)
df$y <- list("A", c("A", "B"), "C", c("B", "D", "C"), "E")
df

  x       y
1 1       A
2 2    A, B
3 3       C
4 4 B, D, C
5 5       E

Run Code Online (Sandbox Code Playgroud)

并且所需的形式是在任何地方看到的每个唯一字符串的虚拟变量df$y,即:

data.frame(x = 1:5, A = c(1,1,0,0,0), B = c(0,1,0,1,0), C = c(0,0,1,1,0), D = c(0,0,0,1,0), E = c(0,0,0,0,1))

  x A B C D E
1 1 1 0 0 0 0
2 2 1 …

Run Code Online (Sandbox Code Playgroud)

我刚刚升级到 R 4.0.0，现在正在尝试重新安装我使用的软件包。但是当我尝试在 RStudio 中这样做时，我收到以下警告：

Warning in install.packages: converting NULL pointer to R NULL

后来我在运行一个闪亮的应用程序时也收到了这种警告：

Warning in .Call("rs_registerShinyFunction", params): converting NULL pointer to R NULL

这是从哪里来的？我该如何解决？

如果需要的话：

> sessionInfo()
R version 4.0.0 (2020-04-24)
Platform: x86_64-pc-linux-gnu (64-bit)
Running under: Ubuntu 18.04.4 LTS

Matrix products: default
BLAS:   /usr/lib/x86_64-linux-gnu/blas/libblas.so.3.7.1
LAPACK: /usr/lib/x86_64-linux-gnu/lapack/liblapack.so.3.7.1

locale:
 [1] LC_CTYPE=fr_FR.UTF-8       LC_NUMERIC=C              
 [3] LC_TIME=fr_FR.UTF-8        LC_COLLATE=fr_FR.UTF-8    
 [5] LC_MONETARY=fr_FR.UTF-8    LC_MESSAGES=fr_FR.UTF-8   
 [7] LC_PAPER=fr_FR.UTF-8       LC_NAME=C                 
 [9] LC_ADDRESS=C               LC_TELEPHONE=C            
[11] LC_MEASUREMENT=fr_FR.UTF-8 LC_IDENTIFICATION=C       

attached base packages:
[1] stats     graphics  grDevices utils     datasets  methods   base     

other attached …

简单字典：

d = {'a': set([1,2,3]), 'b': set([3, 4])}

（如果重要的话，这些集合可能会变成列表）

我如何将它转换成一个长/整齐DataFrame，其中每一列都是一个变量，每个观察都是一行，即：

  letter  value
0      a      1
1      a      2
2      a      3
3      b      3
4      b      4

以下工作，但有点麻烦：

id = 0
tidy_d = {}
for l, vs in d.items():
    for v in vs:
        tidy_d[id] = {'letter': l, 'value': v}
        id += 1
pd.DataFrame.from_dict(tidy_d, orient = 'index')

有什么pandas魔法可以做到这一点吗？就像是：

pd.DataFrame([d]).T.reset_index(level=0).unnest()

这里unnest显然不存在，来自R.

简单数据框：

df = pd.DataFrame({'A': [1,1,2,2], 'B': [0,1,2,3], 'C': ['a','b','c','d']})
df
   A  B  C
0  1  0  a
1  1  1  b
2  2  2  c
3  2  3  d

我希望groupbyA 列的每个值 ( ) 都得到 C 列的值，B 列的值最大。例如对于A列的第1组，B列的最大值为1，所以我想要C列的值“b”：

   A  C
0  1  b
1  2  d

无需假设 B 列已排序，性能是重中之重，其次是优雅。

我知道如何在 Keras 中使用附加输入（而不是标准y_true,y_pred对）编写自定义损失函数，请参见下文。我的问题是使用可训练变量（其中一些）输入损失函数，该变量是损失梯度的一部分，因此应该更新。

我的解决方法是：

• 在网络中输入NXV大小的虚拟输入，其中N是观测值的数量和V附加变量的数量
• 添加一个Dense()层dummy_output，以便 Keras 跟踪我的V“体重”
• V在我的自定义损失函数中使用该层的权重作为我的真实输出层
• dummy_output对于该层使用虚拟损失函数（仅返回 0.0 和/或权重 0.0），因此我的V“权重”仅通过我的自定义损失函数进行更新

我的问题是：是否有更自然的类似 Keras/TF 的方法来做到这一点？因为它感觉很做作，更不用说容易出现错误了。

我的解决方法的示例：

（是的，我知道这是一个非常愚蠢的自定义损失函数，实际上事情要复杂得多）

import numpy as np
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
from tensorflow.keras.layers import Dense
from tensorflow.keras.callbacks import EarlyStopping
import tensorflow.keras.backend as K
from tensorflow.keras.layers import Input
from tensorflow.keras import Model

n_col = 10
n_row = …

我希望能够：

(1) 编写一个简单的函数来计算字符串向量的平均字符串长度

(2) 在 data.frame 中选择一堆多个字符串列来计算每行的字符串长度平均值

(3) 使用我的函数purrr::pmap_dbl

我能够通过以下方式执行（1）、（2）和（3）：

library(tidyverse)

df <- tibble(q0 = c("a", "b", "c"),
             q1 = c("aa", "bb", "cc"),
             q2 = c("aaa", "b", NA),
             some_other_var = 1:3)

avg_str_len <- function(...) mean(str_length(c(...)), na.rm = TRUE)

df %>%
  mutate(avg_len = pmap_dbl(select(., q0:q2), avg_str_len))

## A tibble: 3 x 5
#  q0    q1    q2    some_other_var avg_len
#  <chr> <chr> <chr>          <int>   <dbl>
#1 a     aa    aaa                1    2   
#2 b     bb    b                  2    1.33
#3 c     cc    NA …

用于网络社区检测的 Girvan-Newman 算法：

通过逐步从原始图中移除边来检测社区。该算法会在每一步删除“最有价值”的边缘，传统上是具有最高中介中心性的边缘。当图表分解成碎片时，紧密结合的社区结构暴露出来，结果可以用树状图来描述。

在 NetworkX 中，实现返回集合元组上的迭代器。第一个元组是由 2 个社区组成的第一个切割，第二个元组是由 3 个社区组成的第二个切割，依此类推，直到最后一个元组具有 n 个单独节点（树状图的叶子）的 n 个集合。

import networkx as nx

G = nx.path_graph(10)
comp = nx.community.girvan_newman(G)
list(comp)

[({0, 1, 2, 3, 4}, {5, 6, 7, 8, 9}), ({0, 1}, {2, 3, 4}, {5, 6, 7, 8 , 9}), ({0, 1}, {2, 3, 4}, {5, 6}, {8, 9, 7}), ({0, 1}, {2}, {3, 4 }, {5, 6}, {8, 9, 7}), ({0, 1}, {2}, {3, 4}, {5, 6}, {7}, {8, 9}) , ({0}, …