标签: sequential

说我有一个字符串:

teststring =  "1.3 Hello how are you 1.4 I am fine, thanks 1.2 Hi There 1.5 Great!" 

我希望如下:

testlist = ["1.3 Hello how are you", "1.4 I am fine, thanks 1.2 Hi There", "1.5 Great!"]

基本上,仅在增加的数字上进行分割,其中差值为.1(即1.2到1.3).

有没有办法用正则表达式分割它,但只捕获增加的序号？我在python中编写代码,以便为每个代码重复使用自定义re.compile()并且它很好但是非常笨拙.

像这样的东西(其中parts1_temp是字符串中xx数字的给定列表):

parts1_temp = ['1.3','1.4','1.2','1.5']
parts_num =  range(int(parts1_temp.split('.')[1]), int(parts1_temp.split('.')[1])+30)
parts_search = ['.'.join([parts1_temp.split('.')[0], str(parts_num_el)]) for parts_num_el in parts_num]
#parts_search should be ['1.3','1.4','1.5',...,'1.32']

for k in range(len(parts_search)-1):
    rxtemp = re.compile(r"(?:"+str(parts_search[k])+")([\s\S]*?)(?=(?:"+str(parts_search[k+1])+"))", re.MULTILINE)
    parts_fin = [match.group(0) for match in rxtemp.finditer(teststring)]

但是男人是丑陋的.有没有办法在正则表达式中更直接地执行此操作？我想这是有人在某些方面想要正则表达式的功能,但我找不到任何关于如何解决这个问题的想法(也许纯正的正则表达式是不可能的).

我想在Ruby witch net :: ssh中编写代码,在远程linux机器上逐个运行命令并记录所有内容(在linux机器上称为命令,stdout和stderr).

所以我写函数:

  def rs(ssh,cmds)
    cmds.each do |cmd|
      log.debug "[SSH>] #{cmd}"
      ssh.exec!(cmd) do |ch, stream, data|    
        log.debug "[SSH:#{stream}>] #{data}"            
      end  
    end
  end

例如,如果我想在远程linux上创建新的文件夹和文件:"./ everylongdirname/anotherlongdirname/a.txt",并在该目录中列出文件,并在那里找到firefox(这是愚蠢的一点:P)所以我打电话以上程序是这样的:

Net::SSH.start(host, user, :password => pass) do |ssh|  

  cmds=["mkdir verylongdirname", \                                 #1
        "cd verylongdirname; mkdir anotherlongdirname, \           #2
        "cd verylongdirname/anotherlongdirname; touch a.txt", \    #3
        "cd verylongdirname/anotherlongdirname; ls -la", \         #4
        "cd verylongdirname/anotherlongdirname; find ./ firefox"   #5 that command send error to stderr.
        ]

  rs(ssh,cmds)   # HERE we call our function

  ssh.loop
end

在运行上面的代码之后,我将获得有关第1行,第2行,第3行,第4行,第5行中执行命令的完整LOG巫婆信息.问题是linux上的状态,来自cmds数组的执行命令之间没有保存(所以我必须在运行正确的命令之前重复"cd"语句).而且我对此并不满意.

我的目的是拥有像这样的cmds表: …

我有一个顺序文件,它是hadoop map-reduce作业的输出.在此文件中,数据以键值对形式写入,值本身是映射.我想将值作为MAP对象读取,以便我可以进一步处理它.

    Configuration config = new Configuration();
    Path path = new Path("D:\\OSP\\sample_data\\data\\part-00000");
    SequenceFile.Reader reader = new SequenceFile.Reader(FileSystem.get(config), path, config);
    WritableComparable key = (WritableComparable) reader.getKeyClass().newInstance();
    Writable value = (Writable) reader.getValueClass().newInstance();
    long position = reader.getPosition();

    while(reader.next(key,value))
    {
           System.out.println("Key is: "+textKey +" value is: "+val+"\n");
    }

程序输出:键是:[这是键]值是:{abc = 839177,xyz = 548498,lmn = 2,pqr = 1}

在这里我获得了作为字符串的价值,但我希望它作为地图的对象.

我试图在完整的css3动画中按顺序动画元素.似乎非常直截了当的答案是使用动画延迟.但是我想循环,任何想法如何让动画无限循环？

我在类似的问题上找到了这个小提琴.基本上这是相同的逻辑,但我只是想它循环.

这是类似的[问题](/sf/answers/580614401/)

使用这个:

@-webkit-keyframes FadeIn { 
0% { opacity:0; -webkit-transform:scale(.1);}
85% {opacity:1; -webkit-transform:scale(1.05);}
100% {-webkit-transform:scale(1); }
}

.myClass img { float: left; margin: 20px; 
    -webkit-animation: FadeIn 1s linear; -webkit-animation-fill-mode:both; }
.myClass img:nth-child(1){ -webkit-animation-delay: .5s }
.myClass img:nth-child(2){ -webkit-animation-delay: 1s }
.myClass img:nth-child(3){ -webkit-animation-delay: 1.5s }
.myClass img:nth-child(4){ -webkit-animation-delay: 2s }

编辑

为了清楚起见,我想以顺序的方式想要动画,比如在第一个动画之后,动画第二个项目,然后是第三个......依此类推.我正在考虑制作大约10到12个元素的动画.所以他们会一个接一个地制作动画.

所以@Sonu Joshi的回答是不正确的.

我有一个很大的列表循环(1.500.000项),每个项目我都要做一个非常小的检查.完全在30秒内.

使用Sequential时的CPU利用率约为10%,因此没有使用大量资源.

第一个想法是使用Parallel,但由于每个项目的持续时间有限,Parallel比持续的Foreach持续时间更长,这是因为" 为什么并行版本比本例中的顺序版本慢？ ",这解释了每项任务的创建都会花费时间.

所以我有另一个想法,那就是将列表分成4个(或更多)相等的和平并创建一个线程来遍历项目以使其更快.

在创建自己的课程之前,这是一个好方法吗？或者关于如何加快速度的任何其他想法？或者你知道更好的处理方法吗？

码

我为另一个并行方法创建的代码:(在我自己的静态类中使用)

public static void ForEach<T>(IEnumerable<T> list, Action<T> body, int listDevide)
{
    // Number of items
    int items = list.Count();
    // Divided (in int, so floored)
    int listPart = items / listDevide;
    // Get numbers extra for last run
    int rest = items % listDevide;

    // List to save the actions
    var actions = new List<Action>();
    for(var x = 0; x < listDevide; x++)
    {
        // Create the actions
        actions.Add(delegate {
            foreach(var item …

到目前为止,我在Keras写了我的MLP,RNN和CNN,但现在PyTorch在深度学习社区中越来越受欢迎,所以我也开始学习这个框架.我是Keras顺序模型的忠实粉丝,它使我们能够非常快速地制作简单的模型.我还看到PyTorch具有此功能,但我不知道如何编写代码.我试过这种方式

import torch
import torch.nn as nn

net = nn.Sequential()
net.add(nn.Linear(3, 4))
net.add(nn.Sigmoid())
net.add(nn.Linear(4, 1))
net.add(nn.Sigmoid())
net.float()

print(net)

但它给出了这个错误

AttributeError:'Sequential'对象没有属性'add'

另外,如果可能的话,你能在PyTorch序列模型中给出RNN和CNN模型的简单例子吗？

我想为多任务深度学习任务设计一个神经网络。在 Keras API 中，我们可以使用“顺序”或“函数”方法来构建这样的神经网络。在下面，我提供了用于构建网络的代码，使用这两种方法构建具有两个输出的网络：

顺序的

seq_model = Sequential()
seq_model.add(LSTM(32, input_shape=(10,2)))
seq_model.add(Dense(8))
seq_model.add(Dense(2))
seq_model.summary()

功能性

input1 = Input(shape=(10,2))
lay1 = LSTM(32, input_shape=(10,2))(input1)
lay2 = Dense(8)(lay1)
out1 = Dense(1)(lay2)
out2 = Dense(1)(lay2)
func_model = Model(inputs=input1, outputs=[out1, out2])
func_model.summary()

当我查看模型的两个摘要输出时，每个输出都包含相同数量的可训练参数：

到目前为止，这看起来不错 - 但是当我绘制两个模型（使用keras.utils.plot_model）时，我开始怀疑自己，结果如下图：

我个人不知道如何解释这些。当使用多任务学习方法时，我希望输出层之前的层的所有神经元（在我的情况下为 8）连接到两个输出神经元。对我来说，这清楚地显示在 Functional API 中（我有两个Dense(1)实例），但这在 Sequential API 中不是很清楚。尽管如此，可训练参数的数量是相同的；这表明最后一层的 Sequential API 也完全连接到密集输出层中的两个神经元。

谁能向我解释这两个示例之间的差异，或者它们是否完全相同并导致相同的神经网络架构？另外，在这种情况下，哪个更受欢迎？

非常感谢您提前。

我尝试使用 google colab 资源来保存我的 CNN 模型权重，但出现此错误。我尝试使用谷歌搜索它，但没有任何帮助。

“顺序”对象没有属性“_in_multi_worker_mode”

我的代码：

checkpoint_path = "training_1/cp.ckpt"
checkpoint_dir = os.path.dirname(checkpoint_path)
cp_callback = tf.keras.callbacks.ModelCheckpoint(checkpoint_path, save_weights_only=True, verbose=1)


cnn_model = Sequential()
cnn_model.add(Conv2D(filters = 64, kernel_size = (3,3), activation = "relu", input_shape = Input_shape ))
cnn_model.add(Conv2D(filters = 64, kernel_size = (3,3), activation = "relu"))
cnn_model.add(MaxPooling2D(2,2))
cnn_model.add(Dropout(0.4))

cnn_model = Sequential()
cnn_model.add(Conv2D(filters = 128, kernel_size = (3,3), activation = "relu"))
cnn_model.add(Conv2D(filters = 128, kernel_size = (3,3), activation = "relu"))
cnn_model.add(MaxPooling2D(2,2))
cnn_model.add(Dropout(0.3))


cnn_model.add(Flatten())

cnn_model.add(Dense(units = 512, activation = "relu"))
cnn_model.add(Dense(units = 512, activation …

我正在 google colab 上运行带有 keras 顺序的 CNN。

我收到以下错误： ValueError：具有多个元素的数组的真值不明确。使用 a.any() 或 a.all()

当我从 model.fit 函数中删除 class_weight 参数时，错误消失并且网络成功训练。然而，我真的想考虑不平衡的数据

我检查了我的 class_weights 向量的形状，它很好（和 nd.array，就像你从 sklearn 计算类权重函数生成 class_Weights 时得到的一样）

不确定哪些细节是相关的，但我很乐意提供有关版本和所有这些混乱的更多细节。

ps

一个可能很重要的事实 - 我的数据是 FER2013 数据，我使用的是 FERplus 标签。这意味着，我的样本与一个独特的类别无关，而是每个样本都有自己的每个类别的概率分布。最重要的是，我的标签是大小为 class_names 的向量，所有元素加起来为 1。

只是为了超级清楚，一个例子：img1 label = [0,0,0,0,0.2,0,0.3,0,0,0.5]

无论如何，我将 class_weights 计算为大小为 10 的 nd.array，元素范围在 0 和 1 之间，应该平衡更多代表的类。

我不确定这是否与错误有关，但我提出它以防万一。

我的代码：

def create_model_plus():
  return tf.keras.models.Sequential([
    tf.keras.layers.Conv2D(filters=32,kernel_size=5,strides=1,input_shape=(48, 48, 1),padding='same',use_bias=True,kernel_initializer='normal',bias_initializer=tf.keras.initializers.Constant(0.1),activation=tf.nn.relu),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.MaxPooling2D((2, 2), strides=2),
    tf.keras.layers.Conv2D(filters=64,kernel_size=5,strides=1,padding='same',use_bias=True,kernel_initializer='normal',bias_initializer=tf.keras.initializers.Constant(0.1),activation=tf.nn.relu),
    tf.keras.layers.BatchNormalization(),
    tf.keras.layers.MaxPooling2D((2, 2), strides=1),
    tf.keras.layers.Conv2D(filters=128,kernel_size=5,strides=1,padding='same',use_bias=True,kernel_initializer='normal',bias_initializer=tf.keras.initializers.Constant(0.1),activation=tf.nn.relu),
    tf.keras.layers.BatchNormalization(),    
    tf.keras.layers.MaxPooling2D((2, 2), strides=1),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(1008, activation='relu'),
    tf.keras.layers.Dropout(0.2),
    tf.keras.layers.Dense(512, activation='relu'), …

我今天在开发Android应用程序时遇到了这种情况,我需要根据来自2个不同API的响应来呈现图形.我正在使用Volley而我所做的是我进行了顺序网络呼叫,即我发出了第一个请求,并且在该onResponse请求的方法中我发出了第二个请求.然后我在onResponse第二个请求的方法中渲染视图(图形).

现在我想优化这种情况.我想知道一种方法,我可以异步地进行这两个网络调用,我只在收到来自两个API的响应后呈现视图.所以,我说有3种模块化方法,即 -

1. getDataFromServer1(从一个服务器获取数据的网络调用)
2. getDataFromServer2(从另一台服务器获取数据的网络调用)
3. loadView (根据从2个网络呼叫收到的数据渲染图表)

我该怎么办呢？有人可以对它嗤之以鼻吗？