个人中心
文章发布
退出
作者热门文章
- ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机
- Ubuntu 通过无线网络安装Ubuntu Server启动系统后连接无线网络的方法
- 在Ubuntu上搭建网桥的方法
- ubuntu 虚拟机上网方式及相关配置详解
30
4
CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.
这篇CFSDN的博客文章基于tensorflow for循环 while循环案例由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.
我就废话不多说了，大家还是直接看代码吧~ 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
import
tensorflow as tf
n1
=
tf.constant(
2
)
n2
=
tf.constant(
3
)
n3
=
tf.constant(
4
)
def
cond1(i, a, b):
return
i < n1
def
cond2(i, a, b):
return
i < n2
def
cond3(i, a, b):
return
i < n3
def
body(i, a, b):
return
i
+
1
, b, a
+
b
i1, a1, b1
=
tf.while_loop(cond1, body, (
2
,
1
,
1
))
i2, a2, b2
=
tf.while_loop(cond2, body, (
2
,
1
,
1
))
i3, a3, b3
=
tf.while_loop(cond3, body, (
2
,
1
,
1
))
sess
=
tf.Session()
print
(sess.run(i1))
print
(sess.run(a1))
print
(sess.run(b1))
print
(
"-"
)
print
(sess.run(i2))
print
(sess.run(a2))
print
(sess.run(b2))
print
(
"-"
)
print
(sess.run(i3))
print
(sess.run(a3))
print
(sess.run(b3))
|
print结果:
|
1
2
3
4
5
6
7
8
9
10
11
|
2
1
1
-
3
1
2
-
4
2
3
|
可见body函数返回的三个变量又传给了body 。
补充知识：tensorflow在tf.while_loop循环(非一般循环)中使用操纵变量该怎么做 。
代码（操纵全局变量） 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
xiaojie
=
1
i
=
tf.constant(
0
,dtype
=
tf.int32)
batch_len
=
tf.constant(
10
,dtype
=
tf.int32)
loop_cond
=
lambda
a,b: tf.less(a,batch_len)
#yy=tf.Print(batch_len,[batch_len],"batch_len:")
yy
=
tf.constant(
0
)
loop_vars
=
[i,yy]
def
_recurrence(i,yy):
c
=
tf.constant(
2
,dtype
=
tf.int32)
x
=
tf.multiply(i,c)
global
xiaojie
xiaojie
=
xiaojie
+
1
print_info
=
tf.
Print
(x,[x],
"x:"
)
yy
=
yy
+
print_info
i
=
tf.add(i,
1
)
# print (xiaojie)
return
i,yy
i,yy
=
tf.while_loop(loop_cond,_recurrence,loop_vars,parallel_iterations
=
1
)
#可以批处理
sess
=
tf.Session()
print
(sess.run(i))
print
(xiaojie)
|
输出的是10和2.
也就是xiaojie只被修改了一次.
这个时候，在_recurrence循环体中添加语句 。
print (xiaojie) 。
会输出2。而且只输出一次。具体为什么，最后总结的时候再解释.
代码（操纵类成员变量）class RNN_Model()
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
def
__init__(
self
):
self
.xiaojie
=
1
def
test_RNN(
self
):
i
=
tf.constant(
0
,dtype
=
tf.int32)
batch_len
=
tf.constant(
10
,dtype
=
tf.int32)
loop_cond
=
lambda
a,b: tf.less(a,batch_len)
#yy=tf.Print(batch_len,[batch_len],"batch_len:")
yy
=
tf.constant(
0
)
loop_vars
=
[i,yy]
def
_recurrence(i,yy):
c
=
tf.constant(
2
,dtype
=
tf.int32)
x
=
tf.multiply(i,c)
self
.xiaojie
=
self
.xiaojie
+
1
print_info
=
tf.
Print
(x,[x],
"x:"
)
yy
=
yy
+
print_info
i
=
tf.add(i,
1
)
print
(
"_recurrence:"
,
self
.xiaojie)
return
i,yy
i,yy
=
tf.while_loop(loop_cond,_recurrence,loop_vars,parallel_iterations
=
1
)
#可以批处理
sess
=
tf.Session()
sess.run(yy)
print
(
self
.xiaojie)
if
__name__
=
=
"__main__"
:
model
=
RNN_Model()
#构建树，并且构建词典
model.test_RNN()
|
输出是:
|
1
2
3
|
_recurrence:
2
10
2
|
tf.while_loop操纵全局变量和类成员变量总结 。
为什么_recurrence中定义的print操作只执行一次呢，这是因为_recurrence中的print相当于一种对代码的定义，直接在定义的过程中就执行了。所以，可以看到输出是在sess.run之前的。但是，定义的其它操作就是数据流图中的操作，需要在sess.run中执行.
就必须在sess.run中执行。但是，全局变量xiaojie也好，还是类成员变量xiaojie也好。其都不是图中的内容。因此，tf.while_loop执行的是tensorflow计算图中的循环，对于不是在计算图中的，就不会参与循环。注意：而且必须是与loop_vars中指定的变量存在数据依赖关系的tensor才可以！此外，即使是依赖关系，也必须是_recurrence循环体中return出的变量，才会真正的变化。比如，见下面的self.L。总之，想操纵变量，就要传入loop_vars！ 。
如果对一个变量没有修改，就可以直接在循环中以操纵类成员变量或者全局变量的方式只读.
self.L与loop_vars中变量有依赖关系，但是并没有真正被修改.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
|
#IIII通过计算将非叶子节点的词向量也放入nodes_tensor中。
iiii
=
tf.constant(
0
,dtype
=
tf.int32)
loop____cond
=
lambda
a,b,c,d,e: tf.less(a,
self
.sentence_length
-
1
)
#iiii的范围是0到sl-2。注意，不包括sl-1。这是因为只需要计算sentence_length-1次，就能构建出一颗树
loop____vars
=
[iiii,columnLinesOfL,node_tensors_cost_tensor,nodes_tensor,tfPrint]
def
____recurrence(iiii,columnLinesOfL,node_tensors_cost_tensor,nodes_tensor,tfPrint):
#循环的目的是实现Greedy算法
###
#Greedy的主要目标就是确立树结构。
###
c1
=
self
.L[:,
0
:columnLinesOfL
-
1
]
#这段代码是从RvNN的matlab的源码中复制过来的，但是Matlab的下标是从1开始，并且Matlab中1:2就是1和2，而python中1:2表示的是1，不包括2,所以，有很大的不同。
c2
=
self
.L[:,
1
:columnLinesOfL]
c
=
tf.concat([c1,c2],axis
=
0
)
p
=
tf.tanh(tf.matmul(
self
.W1,c)
+
tf.tile(
self
.b1,[
1
,columnLinesOfL
-
1
]))
p_normalization
=
self
.normalization(p)
y
=
tf.tanh(tf.matmul(
self
.U,p_normalization)
+
tf.tile(
self
.bs,[
1
,columnLinesOfL
-
1
]))
#根据Matlab中的源码来的，即重构后，也有一个激活的过程。
#将Y矩阵拆分成上下部分之后，再分别进行标准化。
columnlines_y
=
columnLinesOfL
-
1
(y1,y2)
=
self
.split_by_row(y,columnlines_y)
y1_normalization
=
self
.normalization(y1)
y2_normalization
=
self
.normalization(y2)
#论文中提出一种计算重构误差时要考虑的权重信息。具体见论文，这里暂时不实现。
#这个权重是可以修改的。
alpha_cat
=
1
bcat
=
1
#计算重构误差矩阵
## constant1=tf.constant([[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0]])
## constant2=tf.constant([[1.0,2.0,3.0],[1.0,4.0,2.0],[1.0,6.0,1.0]])
## constructionErrorMatrix=self.constructionError(constant1,constant2,alpha_cat,bcat)
y1c1
=
tf.subtract(y1_normalization,c1)
y2c2
=
tf.subtract(y2_normalization,c2)
constructionErrorMatrix
=
self
.constructionError(y1c1,y2c2,alpha_cat,bcat)
################################################################################
print_info
=
tf.
Print
(iiii,[iiii],
"\niiii:"
)
#专门为了调试用，输出相关信息。
tfPrint
=
print_info
+
tfPrint
print_info
=
tf.
Print
(columnLinesOfL,[columnLinesOfL],
"\nbefore modify. columnLinesOfL:"
)
#专门为了调试用，输出相关信息。
tfPrint
=
print_info
+
tfPrint
print_info
=
tf.
Print
(constructionErrorMatrix,[constructionErrorMatrix],
"\nbefore modify. constructionErrorMatrix:"
,summarize
=
100
)
#专门为了调试用，输出相关信息。
tfPrint
=
tf.to_int32(print_info[
0
])
+
tfPrint
#一种不断输出tf.Print的方式，注意tf.Print的返回值。
################################################################################
J_minpos
=
tf.to_int32(tf.argmin(constructionErrorMatrix))
#如果不转换的话，下面调用delete_one_column中，会调用tf.slice，之后tf.slice的参数中的类型必须是一样的。
J_min
=
constructionErrorMatrix[J_minpos]
#一共要进行sl-1次循环。因为是从sl个叶子节点，两两结合sl-1次，才能形成一颗完整的树，而且是采用Greedy的方式。
#所以，需要为下次循环做准备。
#第一步，从该sentence的词向量矩阵中删除第J_minpos+1列，因为第J_minpos和第J_minpos+1列对应的单词要合并为一个新的节点,这里就是修改L
################################################################################
print_info
=
tf.
Print
(
self
.L,[
self
.L[
0
]],
"\nbefore modify. L row 0:"
,summarize
=
100
)
#专门为了调试用，输出相关信息。
tfPrint
=
tf.to_int32(print_info[
0
][
0
])
+
tfPrint
print_info
=
tf.
Print
(
self
.L,[tf.shape(
self
.L)],
"\nbefore modify. L shape:"
)
#专门为了调试用，输出相关信息。
tfPrint
=
tf.to_int32(print_info[
0
][
0
])
+
tfPrint
################################################################################
deleteColumnIndex
=
J_minpos
+
1
self
.L
=
self
.delete_one_column(
self
.L,deleteColumnIndex,
self
.numlinesOfL,columnLinesOfL)
columnLinesOfL
=
tf.subtract(columnLinesOfL,
1
)
#列数减去1.
################################################################################
print_info
=
tf.
Print
(deleteColumnIndex,[deleteColumnIndex],
"\nbefore modify. deleteColumnIndex:"
)
#专门为了调试用，输出相关信息。
tfPrint
=
print_info
+
tfPrint
print_info
=
tf.
Print
(
self
.L,[
self
.L[
0
]],
"\nafter modify. L row 0:"
,summarize
=
100
)
#专门为了调试用，输出相关信息。
tfPrint
=
tf.to_int32(print_info[
0
][
0
])
+
tfPrint
print_info
=
tf.
Print
(
self
.L,[tf.shape(
self
.L)],
"\nafter modify. L shape:"
)
#专门为了调试用，输出相关信息。
tfPrint
=
tf.to_int32(print_info[
0
][
0
])
+
tfPrint
print_info
=
tf.
Print
(columnLinesOfL,[columnLinesOfL],
"\nafter modify. columnLinesOfL:"
)
#专门为了调试用，输出相关信息。
tfPrint
=
print_info
+
tfPrint
################################################################################
#第二步，将新的词向量赋值给第J_minpos列
columnTensor
=
p_normalization[:,J_minpos]
new_column_tensor
=
tf.expand_dims(columnTensor,
1
)
self
.L
=
self
.modify_one_column(
self
.L,new_column_tensor,J_minpos,
self
.numlinesOfL,columnLinesOfL)
#第三步，同时将新的非叶子节点的词向量存入nodes_tensor
modified_index_tensor
=
tf.to_int32(tf.add(iiii,
self
.sentence_length))
nodes_tensor
=
self
.modify_one_column(nodes_tensor,new_column_tensor,modified_index_tensor,
self
.numlines_tensor,
self
.numcolunms_tensor)
#第四步：记录合并节点的最小损失，存入node_tensors_cost_tensor
J_min_tensor
=
tf.expand_dims(tf.expand_dims(J_min,
0
),
1
)
node_tensors_cost_tensor
=
self
.modify_one_column(node_tensors_cost_tensor,J_min_tensor,iiii,
self
.numlines_tensor2,
self
.numcolunms_tensor2)
####进入下一次循环
iiii
=
tf.add(iiii,
1
)
print_info
=
tf.
Print
(J_minpos,[J_minpos,J_minpos
+
1
],
"node:"
)
#专门为了调试用，输出相关信息。
tfPrint
=
tfPrint
+
print_info
# columnLinesOfL=tf.subtract(columnLinesOfL,1) #在上面的循环体中已经执行了，没有必要再执行。
return
iiii,columnLinesOfL,node_tensors_cost_tensor,nodes_tensor,tfPrint
iiii,columnLinesOfL,node_tensors_cost_tensor,nodes_tensor,tfPrint
=
tf.while_loop(loop____cond,____recurrence,loop____vars,parallel_iterations
=
1
)
pass
|
上述代码是Greedy算法，递归构建神经网络树结构.
但是程序出错了，后来不断的调试，才发现self.L虽然跟循环loop____vars中的变量有依赖关系，也就是在tf.while_loop进行循环的时候，也可以输出它的值.
但是，它每一次都无法真正意义上对self.L进行修改。会发现，每一次循环结束之后，进入下一次循环时，self.L仍然没有变化.
执行结果如下:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
before modify. columnLinesOfL:[
31
]
iiii:[
0
]
after modify. columnLinesOfL:[
30
]
before modify. L shape:[
300
31
]
before modify. L row
0
:[
0.126693
-
0.013654
-
0.166731
-
0.13703
-
0.261395
0.11459
0.016001
0.016001
0.144603
0.05588
0.171787
0.016001
1.064545
0.144603
0.130615
-
0.13703
-
0.261395
1.064545
-
0.261395
0.144603
0.036626
1.064545
0.188871
0.201198
0.05588
0.203795
0.201198
0.03536
0.089345
0.083778
0.103635
]
node:[
0
][
1
]
before modify. constructionErrorMatrix:[
3.0431733686706206
11.391056715427794
19.652819956115856
13.713453313903868
11.625973829805879
12.827533320819564
9.7513513723204746
13.009151292890811
13.896089243289065
10.649829109971648
9.45239374745086
15.704486086921641
18.274065790781862
12.447866299915024
15.302996103637689
13.713453313903868
14.295549844738751
13.779406175789358
11.625212314259059
16.340507223201449
19.095964364689717
15.10149194936319
11.989443162329437
13.436654650354058
11.120373311110505
12.39345317975002
13.568052800712424
10.998430341124633
8.3223909323599869
6.8896857405641851
]
after modify. L shape:[
300
30
]
after modify. L row
0
:[
0.126693
-
0.166731
-
0.13703
-
0.261395
0.11459
0.016001
0.016001
0.144603
0.05588
0.171787
0.016001
1.064545
0.144603
0.130615
-
0.13703
-
0.261395
1.064545
-
0.261395
0.144603
0.036626
1.064545
0.188871
0.201198
0.05588
0.203795
0.201198
0.03536
0.089345
0.083778
0.103635
]
before modify. deleteColumnIndex:[
1
]
before modify. columnLinesOfL:[
30
]
iiii:[
1
]
before modify. L shape:[
300
31
]
after modify. columnLinesOfL:[
29
]
before modify. L row
0
:[
0.126693
-
0.013654
-
0.166731
-
0.13703
-
0.261395
0.11459
0.016001
0.016001
0.144603
0.05588
0.171787
0.016001
1.064545
0.144603
0.130615
-
0.13703
-
0.261395
1.064545
-
0.261395
0.144603
0.036626
1.064545
0.188871
0.201198
0.05588
0.203795
0.201198
0.03536
0.089345
0.083778
0.103635
]
before modify. deleteColumnIndex:[
1
]
node:[
0
][
1
]
before modify. constructionErrorMatrix:[
3.0431733686706206
11.391056715427794
19.652819956115856
13.713453313903868
11.625973829805879
12.827533320819564
9.7513513723204746
13.009151292890811
13.896089243289065
10.649829109971648
9.45239374745086
15.704486086921641
18.274065790781862
12.447866299915024
15.302996103637689
13.713453313903868
14.295549844738751
13.779406175789358
11.625212314259059
16.340507223201449
19.095964364689717
15.10149194936319
11.989443162329437
13.436654650354058
11.120373311110505
12.39345317975002
13.568052800712424
10.998430341124633
8.3223909323599869
]
after modify. L shape:[
300
29
]
after modify. L row
0
:[
0.126693
-
0.166731
-
0.13703
-
0.261395
0.11459
0.016001
0.016001
0.144603
0.05588
0.171787
0.016001
1.064545
0.144603
0.130615
-
0.13703
-
0.261395
1.064545
-
0.261395
0.144603
0.036626
1.064545
0.188871
0.201198
0.05588
0.203795
0.201198
0.03536
0.089345
0.083778
]
before modify. columnLinesOfL:[
29
]
iiii:[
2
]
|
后面那个after modify时L shape为[300 29]的原因是：执行 。
self.L=self.modify_one_column(self.L,new_column_tensor,J_minpos,self.numlinesOfL,columnLinesOfL) 。
时，columnLinesOfL是循环loop____vars中的变量，因此会随着每次循环发生变化，我写的modify_one_column见我的博文“修改tensor张量矩阵的某一列”。它决定了 。
修改后tensor的维度.
但是，无论如何，每一次循环，都是 。
before modify. L shape:[300 31] 。
说明self.L在循环体中虽然被修改了。但是下次循环又会被重置为初始值.
以上这篇基于tensorflow for循环 while循环案例就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持我.
原文链接：https://blog.csdn.net/guotong1988/article/details/78212418 。
最后此篇关于基于tensorflow for循环 while循环案例的文章就讲到这里了,如果你想了解更多关于基于tensorflow for循环 while循环案例的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。
30
4
0
这个问题在这里已经有了答案: Oracle: merging two different queries into one, LIKE & IN (1 个回答) 8年前关闭。 我有以下代码: case
我查阅过此页面:http://dev.mysql.com/doc/refman/5.1/en/case.html以及这个，但无法获得一个简单的程序来工作...... 更新:为了明确我想要做什么:我想从
有什么办法可以优化下面的查询吗？ SELECT DATE_FORMAT(a.duedate,'%d-%b-%y') AS dte, duedate, SUM(CASE WHEN (typeofnoti
我进退两难，以下 SQL 查询的结果是什么以及它是如何工作的: SELECT ... CASE WHEN (a.FIELD=1 AND b.FIELD=2) THEN 1 WHEN
问题：输入年，月，打印对应年月的日历。 示例： 问题分析： 1，首先1970年是Unix系统诞生的时间，1970年成为Unix的元年，1970年1月1号是星期四，现在大多的手机的日历功能只能显
**摘要：**介绍了Angular中依赖注入是如何查找依赖，如何配置提供商，如何用限定和过滤作用的装饰器拿到想要的实例，进一步通过N个案例分析如何结合依赖注入的知识点来解决开发编程中会遇到的问题。 本
我想拥有自动伴侣类apply case 类的构造函数来为我执行隐式转换，但无法弄清楚如何这样做。我到处搜索，我能找到的最接近的答案是 this问题(我将解释为什么它不是我在下面寻找的)。 我有一个看起
您好，我已经浏览了“多列案例”问题，但没有看到与此相同的内容，所以我想我应该问一下。 基本上我有两个我想要连接的表(都是子查询的结果)。它们具有相同的列名称。如果我加入他们的 ID 和 SELECT
我发现了一些类型推断的非直觉行为。因此，语义等效代码的工作方式不同，具体取决于编译器推断出的有关函数返回类型的信息。当您在最小单元测试中重现此案例时，或多或少会清楚发生了什么。但我担心在编写框架代码时
CREATE TABLE test ( sts_id int , [status1] int , [status2] int , [status3] int , [status4] int ) INS
我有以下声明: SELECT Dag AS Dag, CASE Jaar WHEN 2013 THEN Levering END AS '2013', CASE
我想做的是为所有高于平均时间、平均时间和低于平均时间的游乐设施获取平均tip_portion。所以返回3行。当我运行它时，它显示: ERROR: missing FROM-clause entry
我正在尝试设置一个包含以下字段的报告: 非常需要报告来显示日期、该日期内的总记录(因此我按日期分组)，然后按小时计算 12 小时工作日(从上午 8 点到晚上 8 点)我需要计算记录在这些时间内出现的时
我有这个查询 SELECT users.name FROM users LEFT JOIN weapon_stats ON users.id = weapon_stats.zp_id WHERE we
我正在尝试按收视率等级获取不同视频的计数。我有下表: vid_id views 1 6 1 10 1 900 2 850 2 125000
假设我有一个如下所示的 SQL 语句: select supplier, case when platform in (5,6) then 'mobile' when p
我有一个表测试 TestNumber (int primary key) InactiveBitwise (int) 我执行以下命令: UPDATE tests SET CASE WH
我有一个像这样的表(name=expense): id amount date 1 -1687 2014-01-02 00:00:00.0 2 11000 2014-01-02 0
我有一个 multimap 定义 typedef std::pair au_pair; //vertices typedef std::pair acq_pair; //ch qlty specifi
我有一个有点像枚举的类，它的每个实例都有一个唯一的 int 值，该值从 0 开始并在每个新实例时递增。 class MyEnumLikeClass { static int NextId =
我是一名优秀的程序员,十分优秀！