标签: multi-layer

我想知道如何在Tensorflow中使用多层双向LSTM.

我已经实现了双向LSTM的内容,但我想将此模型与添加的多层模型进行比较.

我该如何在这部分中添加一些代码？

x = tf.unstack(tf.transpose(x, perm=[1, 0, 2]))
#print(x[0].get_shape())

# Define lstm cells with tensorflow
# Forward direction cell
lstm_fw_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0)
# Backward direction cell
lstm_bw_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0)

# Get lstm cell output
try:
    outputs, _, _ = rnn.static_bidirectional_rnn(lstm_fw_cell, lstm_bw_cell, x,
                                          dtype=tf.float32)
except Exception: # Old TensorFlow version only returns outputs not states
    outputs = rnn.static_bidirectional_rnn(lstm_fw_cell, lstm_bw_cell, x,
                                    dtype=tf.float32)

# Linear activation, using rnn inner loop last output
outputs = tf.stack(outputs, axis=1)
outputs = tf.reshape(outputs, (batch_size*n_steps, …

我的项目有一个后端服务(Web API)和一个前端SPA应用程序.后端服务具有位于不同.net程序集中的表示,应用程序服务,域和基础结构层.域层具有业务域对象,基础架构 - 与外部数据和其他东西的通信,应用程序服务 - 表示层使用的服务集,表示 - Web API控制器.我认为这是非常常见的分层架构.

我们的新架构师宣布我们将向后端移动到微服务架构,制动我们的层并将域,应用服务和基础架构层划分为一些服务,并将表示层转换为后端以用于前端层(如此处所述).在功能方面,我们将有移动应用程序.Sql Server数据库将暂时保留原样.

我没有微服务架构的经验,所以我的问题是:多层架构已经过时了吗？哪些优点和问题可以为我的应用程序带来这样的架构设计？

我正在尝试建立一个多变量时间序列预测模型.我按照以下教程进行温度预测.http://nbviewer.jupyter.org/github/addfor/tutorials/blob/master/machine_learning/ml16v04_forecasting_with_LSTM.ipynb

我想通过使用以下代码将他的模型扩展到多层LSTM模型:

cell = tf.contrib.rnn.LSTMCell(hidden, state_is_tuple=True)  
cell = tf.contrib.rnn.MultiRNNCell([cell] * num_layers,state_is_tuple=True)  
output, _ = tf.nn.dynamic_rnn(cell=cell, inputs=features, dtype=tf.float32)

但我有一个错误说:

ValueError:尺寸必须相等,但对于输入形状为'rnn/while/rnn/multi_rnn_cell/cell_0/cell_0/lstm_cell/MatMul_1'(op:'MatMul')的值为256和142:[？,256],[142,512] .

当我尝试这个时:

cell = []
for i in range(num_layers):
    cell.append(tf.contrib.rnn.LSTMCell(hidden, state_is_tuple=True))
cell = tf.contrib.rnn.MultiRNNCell(cell,state_is_tuple=True)
output, _ = tf.nn.dynamic_rnn(cell=cell, inputs=features, dtype=tf.float32)

我没有这样的错误,但预测真的很糟糕.

我定义 hidden=128.

features = tf.reshape(features, [-1, n_steps, n_input])具有(?,1,14)单层表壳的形状.

我的数据看起来像这样 x.shape=(594,14), y.shape=(591,1)

我很困惑如何在张量流中堆叠LSTM单元.我的张量流版本是0.14.

我正在创建一个多层应用程序,将asp.net mvc应用程序作为最高层.

该体系结构如下(--->表示引用):

表示层--->服务层--->业务层---->数据访问层---->数据库

此外,还有一个名为"Infrastracture"的层,它被所有层引用.

每一层都有自己的实体.例如:在表示层中,我们可能在服务层UserDTO中具有UserViewModel,在业务层UserBDO中,最后在数据访问层中具有User.

automapper用于自动化不同类型之间的转换.

我读到一些开发人员建议将映射创建放在Global.asax中,但很明显,如果你有一个多层应用程序,你就无法在那里创建所有映射.您无法在表示层中将User与UserBDO映射.

所以,我要求用最干净的方法来管理多层应用程序中的映射集中化.您甚至可以建议更改体系结构.

我正在尝试使用 MLPClassifier 在 scikit learn 0.18dev 中编写多层感知器。我已经使用了求解器 lbgfs，但是它给了我警告：ConvergenceWarning：随机优化器：已达到最大迭代次数并且优化尚未收敛。% (), 收敛警告)

我怎样才能解决这个问题？

我想知道在Sklearn中安装MLP分类器后，是否有任何方法可以可视化或找到最重要/最重要的功能。

简单的例子：

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import LeaveOneOut
from sklearn.neural_network import MLPClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.pipeline import make_pipeline


data= pd.read_csv('All.csv', header=None)
X, y = data.iloc[0:, 0:249].values, data.iloc[0:,249].values

sc = StandardScaler()
mlc = MLPClassifier(activation = 'relu', random_state=1,nesterovs_momentum=True)
loo = LeaveOneOut()
pipe = make_pipeline(sc, mlc)

parameters = {"mlpclassifier__hidden_layer_sizes":[(168,),(126,),(498,),(166,)],"mlpclassifier__solver" : ('sgd','adam'), "mlpclassifier__alpha": [0.001,0.0001],"mlpclassifier__learning_rate_init":[0.005,0.001] }
clf = GridSearchCV(pipe, parameters,n_jobs= -1,cv = loo)
clf.fit(X, y)

model = clf.best_estimator_
print("the best model and parameters …

我有下面的代码来加载数据：

from pymnet import * 
import pandas as pd 

nodes_id = ['a',    'b',    'c',    'd',    'e',    'f',    'g',    1,  2,  3,  'aa',   'bb',   'cc']
layers = [1,    1,  1,  1,  1,  1,  1,  2,  2,  2,  3,  3,  3]
nodes = {'nodes': nodes_id, 'layers': layers}
df_nodes = pd.DataFrame(nodes)

to = ['b',  'c',    'd',    'f',    1,  2,  3,  'bb',    'cc',  2,  3,  'a',    'g']
from_edges = ['a',  'a',    'b',    'e',    'a',    'b',    'e',    'aa',   'aa',   'aa', 1, 2, 3]
edges = …

在Perl中,如果我想要一个多层哈希,我会写:

$hash_ref->{'key1'}->{'key2'}='value';

凡'key1'可能是一个人的名字,'key2'可能是"储蓄账户"(与"支票帐户"),并'value'可能是钱在帐户中的金额.

在Java中是否存在等价的东西,即通过哈希引用访问值？这个语法是什么样的？任何示例或其他资源参考将不胜感激.谢谢!

我正在尝试实现一个程序来测试GPU设备上的Tensorflow性能.数据测试是MNIST数据,使用多层感知器(神经网络)进行监督训练.我按照这个简单的例子,但我将性能批量渐变的数量更改为10000

for i in range(10000) :
batch_xs, batch_ys = mnist.train.next_batch(100)
sess.run(train_step,feed_dict={x : batch_xs, y_ : batch_ys})
if i % 500 == 0:
    print(i)

最终,当我使用此代码检查预测准确性时

correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction,"float"))
print(sess.run(accuracy,feed_dict={x:mnist.test.images,y_:mnist.test.labels}))
print(tf.convert_to_tensor(mnist.test.images).get_shape())

事实证明,从CPU到GPU的准确率不同:当GPU返回约0.9xx的准确率时,CPU只返回0.3xx.有谁知道原因？或者为什么会出现这个问题？

我想知道下面这段代码是否是内存泄漏,因为谷歌只是出现了奇怪的例子.基本上,如果我有一个班级Tree:

public class Tree{

     private Bird[] birds;

     public Tree(){
          birds = new Bird[100];
     }

}

我持有Tree类似这样的类引用:

Tree myTree = new Tree();

然后不久我将该引用设置为null:

myTree = null;

垃圾收集器是否会将所有100个已分配的鸟类与树类一起处理？或者我需要一个delete()方法？我知道Java没有析构函数,但这个多层类示例仍然让我困惑:

里面Tree.java:

public void deleteBirds{
     birds = null;
}