用于构建深度学习模型的高级tensorflow库
tensorgraphx的Python项目详细描述
[！[构建状态]（https://travis-ci.org/hycis/tensorgraphx.svg？branch=master）（https://travis ci.org/hycis/tensorgraphx）
re
更复杂的是，我们似乎需要一些易于使用的框架来快速构建这些模型，这就是tensorgraphx的设计目的。这是一个非常简单的
框架，它在tensorflow之上添加了一个非常薄的层。它适用于更高级的
用户，他们希望对自己的模型构建有更多的控制和灵活性，同时也希望获得效率。
----
对模型的构建有太多的限制和太多的黑匣子，有些人不想不断地重写tensorflow中的标准层。也适用于希望在团队之间轻松共享深度学习模型的企业用户。
----
h
sudo pip install tensorgraphx
```
，或者对于边缘版本do
``bash
sudo pip install--升级git+https://github.com/hycis/tensorgraphx.git@master
````
，或者简单地克隆并添加到"pythonpath"。
``bash
git clone https://github.com/hycis/tensorgraphx.git
export pythonpath=/path/to/tensorgraphx:$pythonpath
```
，以便安装通过export`pythonpath`持久化。将"pythonpath=/path/to/tensorgraphx:$pythonpath"添加到Linux的".bashrc"或Mac的".bash配置文件"。此方法有效时，必须确保安装了[setup.py]（setup.py）中的所有依赖项。
----
vgg或resnet等模型可以是一个层。resnet的标识块或densenet的密集块也可以是层。在Tensorgraphx中建立模型就像用乐高玩具一样。例如，您可以通过将"basemodel"层子类化并在"model a"层内使用"denseblock"层来创建新模型（层）。从tensorgraphx导入denseblock、basemodel、flatten、linear、softmax
将tensorgraphx导入为tg
class modela（basemodel）：
@basemodel.init_name_scope
def_uu init_u（self）：
层=[]
层。附加（denseblock（））
层。附加（flatten（））
层。附加（linear（））
层。附加（softmax（））
self.startnode=tg.startnode（输入变量=[无]）
hn=tg.hiddenode（prev=[self.startnode]，layers=layers）
self.endnode=tg.endnode（prev=[hn]）
````
定义内部（self）：
层=[]
层.append（modela（））
层.append（linear（））
层.append（softmax（））
self.startnode=tg.startnode（输入变量=[none]）
hn=tg.hiddenode（prev=[self.startnode]，层=层）
self.endnode=tg.endnode（prev=[hn]）
```
创建一个层只创建了所有的"变量"。要将"variables"连接到图中，可以执行"train-fprop（x）"或"test-fprop（x）"来创建tensorflow图。通过将"variable"创建从链接到图形的"variable"节点中抽象出来，可以防止某些tensorflow层在调用时总是重新初始化其权重的问题，例如[`tf.nn.batch_normalization`]（https://wworg/api-docs/python/tf/nn/batch-normalization）层。另外，有一个单独的培训和测试渠道是为了满足具有不同培训和测试行为的层，例如batchnorm和dropout。
``python
modelb=modelb（）
x ph=tf.placeholder（）
y train=modelb.train fprop（xph）
y test=modelb.test\fprop（xph）
```
查看tensorgraphx中的一些著名模型
1。[vgg16代码]（tensorgraphx/layers/backbones.py l37）和[vgg19代码]（tensorgraphx/layers/backbones.py l125）—[用于大规模图像识别的非常深卷积网络]（https://arxiv.org/abs/1409.1556）
2。[Densenet代码]（tensorgraphx/layers/backbones.py l477）—[密集连接卷积网络]（https://arxiv.org/abs/1608.06993）
3。[resnet代码]（tensorgraphx/layers/backbones.py l225）-[图像识别的深度残差学习]（https://arxiv.org/abs/1512.03385）
4.[u net代码]（tensorgraphx/layers/backbones.py l531）—[u-net:生物医学图像分割的卷积网络]（https://arxiv.org/abs/1505.04597）
----
-
多个gpu上的tensorgraphx
要在多个gpu上使用tensorgraphx，可以很容易地将其与[horovod]集成（https:）//github.com/uber/horovod）。
`` python
将horovod.tensorflow导入为hvd
从tensorflow.python.framework导入ops
将tensorflow导入为tf
hvd.init（）
>Y=B.T.T.T.T.T.T.T.F.P（x_ph值）
>Y=B.T.T.T.P.P.T.T.P（x_ph值）
>T.T.T.T.T.P.P.P（x_ph值）
>opt=tf.train.rmspropoptoptimizer（0.001）
>opt=HVD.DistributedOptimizer（opt）
>
>
；对于batchnormalization层
更新是必需的_ ops=ops.get_collection（ops.graphkeys.update_ops）
具有ops.control_依赖项（update_ops）：
train_op=opt.minimize（train_cost）
init_op=tf.group（tf.global_variables_initializer（），
tf.local_variables_initializer（））
bcast=hvd.broadcast_global_variables（0）
运行（init-op）
bcast.run（）
/multi_gpus_horovod.py）
----
\tensorgraphx是如何工作的？在tensorgraphx中，我们定义了三种类型的节点。startnode：用于图形的输入
2。hiddendnode：用于将连续层放入
3。endnode：为了从模型中获取输出，我们将所有的序列层放在一个"hiddendnode"中，并将隐藏的节点连接在一起，以构建您想要的体系结构。图形总是以"startnode"开头，以"endnode"结尾。"startnode"是放置
起点的位置，它可以是"占位符"、另一个图形的符号输出、
或"tfrecords"的数据输出。` endnode`是从
图形中获取输出的地方，在这里，输出可用于计算损耗，或者只是查看特定层上的
输出。下面显示了构建张量图的
[示例]（examples/example.py）。
----
\graph example
<；img src="draw/graph.png"height="250">；
ize=32
学习率=0.01
y1=tf.placeholder（'float32'，[none，y1-dim]）
y2=tf.placeholder（'float32'，[none，y2 dim]）
s1=startnode（input_vars=[y1]）
s2=startnode（input_vars=[y2]）
`````
然后定义"hiddenode"，用于将序列层放入每个"hiddenode"
``python
h1=hiddenode（prev=[s1，s2]，
input_merge_mode=concat（），
layers=[线性（y1 dim+y2 dim，y2 dim，relu（））
h2=hiddendnode（prev=[s2]，
层=[线性（y2 dim，y2 dim），relu（））
h3=hiddendnode（prev=[h1，h2]，
输入合并模式=sum（），
层=[线性（y2 dim，y1 dim，relu（））
``````
然后定义在"endnode"中。` endnode`用于回溯图形以将节点连接在一起。
`` python
e1=endnode（prev=[h3]）
e2=endnode（prev=[h2]）
`````
最后通过将"start nodes"和"endnodes"放入"graph`
`` python
graph=graph（start=[s1，s2]，end=[e1，e2]）
```
运行列车正向传播以从列车模式获得符号输出。"graph.train-fprop"的输出数
与"graph`
``python
o1，o2=graph.train-fprop（）
````
``最终构建一个优化器来优化目标函数=tf.降低平均值（（y2-o2）**2）
mse=o1-mse+o2-mse
优化器=tf.train.adamoptimizer（学习速率）。最小化（mse）
`````
----
较低层级的SoftMax层可以在所有上层的SoftMax层上进行调节。
<；img src="draw/hsoftmax.png"height="250">；
``python
_ ph=tf.placeholder（'float32'，[none，x戥dim]）
三个层次
y1 ph=tf.placeholder（'float32'，[none，component戥dim]）
y2 ph=tf.placeholder（'float32'，[none，component戥dim]）
y3戥ph=tf.placeholder（'float32'，[none，component戥dim]）
结构
start=startnode（输入变量=[x_ph]）
h1=hiddenode（prev=[start]，层=[linear（x_dim，component_dim），softmax（）]）
h2=hiddenode（prev=[h1]，层=[linear（component_dim，component_dim），softmax（））
h3=hiddenode（prev=[h2]，层=[linear（component_dim，component_dim）_）
>e1=endnode（prev=[h1，h2]，inpu merge_mode=sum（））
>e2=endnode（prev=[h1，h22]，inpu merge_mode=sum（））
>e3=endnode（prev=[h1，h22，h3]，inpumerge_mode=sum（））
>graph=graph（start=[start]，end=[e1，e2，e3]）
>o1，o2，o3=graph.train.train.train.train.train.train.train 0（）
o1μmse=tf.减少平均值（（y1 ph-o1）**2）
o2μmse=tf.减少平均值（（y2 ph-o2）**2）
o3μmse=tf.减少平均值（（y3 ph-o3）**2）
减少平均值（（y3 ph-o3）**2）
mse=o1μmse+o2μmse+o3μmse
优化器=tf.火车。Adamoptimimizer（学习速率）。最小化（mse）
` `
` ` `>
----
转移学习示例下面是一个使用双模态输入的转移学习示例，并在中间层使用共享表示进行合并，事实上，tensorgraphx可以用来构建任何数量的转移学习模式。
<；img src="draw/transferlearn.png"height="250">；
``py
参数
x1u dim=50
x2 dim=100
共享共享共享dim=200
y_dim=100
batchsize=32
学习率=0.01
x1 ph=tf.placeholder（'float32'，[none，x1 dim]）
x2 ph=tf.placeholder（'float32'，[none，x2 dim]）
y ph=tf.placeholder（'float32'，[float32'，[none，x2 dim dim]）
y ph=tf'float32'，[无
定义图形模型结构
>s1=startnode（输入变量=[x1[x1[u-ph]）
>s2=startnode（输入变量=x2[x2[x2[ph]）
>h1=hiddendnoode（prev=[s1]，图层=[linear（x1[u-dim，shashared，shared dim），relu（）]
>h2=hiddendnoode（prev=[s2]，图层=线性（x2-dim，shared，shared dim，relu（））
h3=hiddenn（hiddenn=hiddenn=hiddenn（prev=[s1]，图层=是的ODE（上一个=[H1，H2]，输入_merge_mode=sum（），
层=[线性（共享_dim，y_dim，softmax（））
mse=tf.reduce_mean（（y_ph-o1）**2）
优化器=tf.train.adamoptimizer（learning_rate）.最小化（mse）
```
re
更复杂的是，我们似乎需要一些易于使用的框架来快速构建这些模型，这就是tensorgraphx的设计目的。这是一个非常简单的
框架，它在tensorflow之上添加了一个非常薄的层。它适用于更高级的
用户，他们希望对自己的模型构建有更多的控制和灵活性，同时也希望获得效率。
----
对模型的构建有太多的限制和太多的黑匣子，有些人不想不断地重写tensorflow中的标准层。也适用于希望在团队之间轻松共享深度学习模型的企业用户。
----
h
sudo pip install tensorgraphx
```
，或者对于边缘版本do
``bash
sudo pip install--升级git+https://github.com/hycis/tensorgraphx.git@master
````
，或者简单地克隆并添加到"pythonpath"。
``bash
git clone https://github.com/hycis/tensorgraphx.git
export pythonpath=/path/to/tensorgraphx:$pythonpath
```
，以便安装通过export`pythonpath`持久化。将"pythonpath=/path/to/tensorgraphx:$pythonpath"添加到Linux的".bashrc"或Mac的".bash配置文件"。此方法有效时，必须确保安装了[setup.py]（setup.py）中的所有依赖项。
----
vgg或resnet等模型可以是一个层。resnet的标识块或densenet的密集块也可以是层。在Tensorgraphx中建立模型就像用乐高玩具一样。例如，您可以通过将"basemodel"层子类化并在"model a"层内使用"denseblock"层来创建新模型（层）。从tensorgraphx导入denseblock、basemodel、flatten、linear、softmax
将tensorgraphx导入为tg
class modela（basemodel）：
@basemodel.init_name_scope
def_uu init_u（self）：
层=[]
层。附加（denseblock（））
层。附加（flatten（））
层。附加（linear（））
层。附加（softmax（））
self.startnode=tg.startnode（输入变量=[无]）
hn=tg.hiddenode（prev=[self.startnode]，layers=layers）
self.endnode=tg.endnode（prev=[hn]）
````
定义内部（self）：
层=[]
层.append（modela（））
层.append（linear（））
层.append（softmax（））
self.startnode=tg.startnode（输入变量=[none]）
hn=tg.hiddenode（prev=[self.startnode]，层=层）
self.endnode=tg.endnode（prev=[hn]）
```
创建一个层只创建了所有的"变量"。要将"variables"连接到图中，可以执行"train-fprop（x）"或"test-fprop（x）"来创建tensorflow图。通过将"variable"创建从链接到图形的"variable"节点中抽象出来，可以防止某些tensorflow层在调用时总是重新初始化其权重的问题，例如[`tf.nn.batch_normalization`]（https://wworg/api-docs/python/tf/nn/batch-normalization）层。另外，有一个单独的培训和测试渠道是为了满足具有不同培训和测试行为的层，例如batchnorm和dropout。
``python
modelb=modelb（）
x ph=tf.placeholder（）
y train=modelb.train fprop（xph）
y test=modelb.test\fprop（xph）
```
查看tensorgraphx中的一些著名模型
1。[vgg16代码]（tensorgraphx/layers/backbones.py l37）和[vgg19代码]（tensorgraphx/layers/backbones.py l125）—[用于大规模图像识别的非常深卷积网络]（https://arxiv.org/abs/1409.1556）
2。[Densenet代码]（tensorgraphx/layers/backbones.py l477）—[密集连接卷积网络]（https://arxiv.org/abs/1608.06993）
3。[resnet代码]（tensorgraphx/layers/backbones.py l225）-[图像识别的深度残差学习]（https://arxiv.org/abs/1512.03385）
4.[u net代码]（tensorgraphx/layers/backbones.py l531）—[u-net:生物医学图像分割的卷积网络]（https://arxiv.org/abs/1505.04597）
----
-
多个gpu上的tensorgraphx
要在多个gpu上使用tensorgraphx，可以很容易地将其与[horovod]集成（https:）//github.com/uber/horovod）。
`` python
将horovod.tensorflow导入为hvd
从tensorflow.python.framework导入ops
将tensorflow导入为tf
hvd.init（）
>Y=B.T.T.T.T.T.T.T.F.P（x_ph值）
>Y=B.T.T.T.P.P.T.T.P（x_ph值）
>T.T.T.T.T.P.P.P（x_ph值）
>opt=tf.train.rmspropoptoptimizer（0.001）
>opt=HVD.DistributedOptimizer（opt）
>
>
；对于batchnormalization层
更新是必需的_ ops=ops.get_collection（ops.graphkeys.update_ops）
具有ops.control_依赖项（update_ops）：
train_op=opt.minimize（train_cost）
init_op=tf.group（tf.global_variables_initializer（），
tf.local_variables_initializer（））
bcast=hvd.broadcast_global_variables（0）
运行（init-op）
bcast.run（）
/multi_gpus_horovod.py）
----
\tensorgraphx是如何工作的？在tensorgraphx中，我们定义了三种类型的节点。startnode：用于图形的输入
2。hiddendnode：用于将连续层放入
3。endnode：为了从模型中获取输出，我们将所有的序列层放在一个"hiddendnode"中，并将隐藏的节点连接在一起，以构建您想要的体系结构。图形总是以"startnode"开头，以"endnode"结尾。"startnode"是放置
起点的位置，它可以是"占位符"、另一个图形的符号输出、
或"tfrecords"的数据输出。` endnode`是从
图形中获取输出的地方，在这里，输出可用于计算损耗，或者只是查看特定层上的
输出。下面显示了构建张量图的
[示例]（examples/example.py）。
----
\graph example
<；img src="draw/graph.png"height="250">；
ize=32
学习率=0.01
y1=tf.placeholder（'float32'，[none，y1-dim]）
y2=tf.placeholder（'float32'，[none，y2 dim]）
s1=startnode（input_vars=[y1]）
s2=startnode（input_vars=[y2]）
`````
然后定义"hiddenode"，用于将序列层放入每个"hiddenode"
``python
h1=hiddenode（prev=[s1，s2]，
input_merge_mode=concat（），
layers=[线性（y1 dim+y2 dim，y2 dim，relu（））
h2=hiddendnode（prev=[s2]，
层=[线性（y2 dim，y2 dim），relu（））
h3=hiddendnode（prev=[h1，h2]，
输入合并模式=sum（），
层=[线性（y2 dim，y1 dim，relu（））
``````
然后定义在"endnode"中。` endnode`用于回溯图形以将节点连接在一起。
`` python
e1=endnode（prev=[h3]）
e2=endnode（prev=[h2]）
`````
最后通过将"start nodes"和"endnodes"放入"graph`
`` python
graph=graph（start=[s1，s2]，end=[e1，e2]）
```
运行列车正向传播以从列车模式获得符号输出。"graph.train-fprop"的输出数
与"graph`
``python
o1，o2=graph.train-fprop（）
````
``最终构建一个优化器来优化目标函数=tf.降低平均值（（y2-o2）**2）
mse=o1-mse+o2-mse
优化器=tf.train.adamoptimizer（学习速率）。最小化（mse）
`````
----
较低层级的SoftMax层可以在所有上层的SoftMax层上进行调节。
<；img src="draw/hsoftmax.png"height="250">；
``python
_ ph=tf.placeholder（'float32'，[none，x戥dim]）
三个层次
y1 ph=tf.placeholder（'float32'，[none，component戥dim]）
y2 ph=tf.placeholder（'float32'，[none，component戥dim]）
y3戥ph=tf.placeholder（'float32'，[none，component戥dim]）
结构
start=startnode（输入变量=[x_ph]）
h1=hiddenode（prev=[start]，层=[linear（x_dim，component_dim），softmax（）]）
h2=hiddenode（prev=[h1]，层=[linear（component_dim，component_dim），softmax（））
h3=hiddenode（prev=[h2]，层=[linear（component_dim，component_dim）_）
>e1=endnode（prev=[h1，h2]，inpu merge_mode=sum（））
>e2=endnode（prev=[h1，h22]，inpu merge_mode=sum（））
>e3=endnode（prev=[h1，h22，h3]，inpumerge_mode=sum（））
>graph=graph（start=[start]，end=[e1，e2，e3]）
>o1，o2，o3=graph.train.train.train.train.train.train.train 0（）
o1μmse=tf.减少平均值（（y1 ph-o1）**2）
o2μmse=tf.减少平均值（（y2 ph-o2）**2）
o3μmse=tf.减少平均值（（y3 ph-o3）**2）
减少平均值（（y3 ph-o3）**2）
mse=o1μmse+o2μmse+o3μmse
优化器=tf.火车。Adamoptimimizer（学习速率）。最小化（mse）
` `
` ` `>
----
转移学习示例下面是一个使用双模态输入的转移学习示例，并在中间层使用共享表示进行合并，事实上，tensorgraphx可以用来构建任何数量的转移学习模式。
<；img src="draw/transferlearn.png"height="250">；
``py
参数
x1u dim=50
x2 dim=100
共享共享共享dim=200
y_dim=100
batchsize=32
学习率=0.01
x1 ph=tf.placeholder（'float32'，[none，x1 dim]）
x2 ph=tf.placeholder（'float32'，[none，x2 dim]）
y ph=tf.placeholder（'float32'，[float32'，[none，x2 dim dim]）
y ph=tf'float32'，[无
定义图形模型结构
>s1=startnode（输入变量=[x1[x1[u-ph]）
>s2=startnode（输入变量=x2[x2[x2[ph]）
>h1=hiddendnoode（prev=[s1]，图层=[linear（x1[u-dim，shashared，shared dim），relu（）]
>h2=hiddendnoode（prev=[s2]，图层=线性（x2-dim，shared，shared dim，relu（））
h3=hiddenn（hiddenn=hiddenn=hiddenn（prev=[s1]，图层=是的ODE（上一个=[H1，H2]，输入_merge_mode=sum（），
层=[线性（共享_dim，y_dim，softmax（））
mse=tf.reduce_mean（（y_ph-o1）**2）
优化器=tf.train.adamoptimizer（learning_rate）.最小化（mse）
```
欢迎加入QQ群-->： 979659372
