doctrees/

__pycache__/

- if [[ "$TRAVIS_PYTHON_VERSION" == "2.7" ]]; then

pip install --only-binary=numpy,scipy numpy nose scipy pytest sklearn;

pip install tensorflow;

pip install git+https://github.com/hycis/TensorGraph.git@master;

fi

- if [[ "$TRAVIS_PYTHON_VERSION" == "3.5" ]]; then

pip3 install --only-binary=numpy,scipy numpy nose scipy pytest sklearn;

pip3 install tensorflow;

pip3 install git+https://github.com/hycis/TensorGraph.git@master;

fi

script:

- echo "TensorGraph Testing.."

- if [[ "$TRAVIS_PYTHON_VERSION" == "2.7" ]]; then

python -m pytest test;

fi

Copyright 2015 The TensorGraph Authors. All rights reserved.

Apache License

Version 2.0, January 2004

same "printed page" as the copyright notice for easier

identification within third-party archives.

Copyright 2015, The TensorGraph Authors.

Licensed under the Apache License, Version 2.0 (the "License");

you may not use this file except in compliance with the License.

include README.md LICENCE

recursive-include tensorgraph *.py

`master` [](http://54.222.242.222:1010/job/TensorGraph/master)

`develop` [](http://54.222.242.222:1010/job/TensorGraph/develop)

As deep learning becomes more and more common and the architectures becoming more

and more complicated, it seems that we need some easy to use framework to quickly

build these models and that's what TensorGraph is designed for. It's a very simple

framework that adds a very thin layer above tensorflow. It is for more advanced

users who want to have more control and flexibility over his model building and

who wants efficiency at the same time.

TensorGraph is targeted more at intermediate to advance users who feel keras or

other packages is having too much restrictions and too much black box on model

building, and someone who don't want to rewrite the standard layers in tensorflow

constantly. Also for enterprise users who want to share deep learning models

easily between teams.

You can check out the documentation [https://skymed.ai/pages/AI-Platform/TensorGraph/](https://skymed.ai/pages/AI-Platform/TensorGraph/)

export PYTHONPATH=/path/to/TensorGraph:$PYTHONPATH

in order for the install to persist via export `PYTHONPATH`. Add `PYTHONPATH=/path/to/TensorGraph:$PYTHONPATH` to your `.bashrc` for linux or

`.bash_profile` for mac. While this method works, you will have to ensure that

all the dependencies in [setup.py](setup.py) are installed.

Everything in TensorGraph is about layers. A model such as VGG or Resnet can be a layer. An identity block from Resnet or a dense block from Densenet can be a layer as well. Building models in TensorGraph is same as building a toy with lego. For example you can create a new model (layer) by subclass the `BaseModel` layer and use `DenseBlock` layer inside your `ModelA` layer.

from tensorgraph.layers import DenseBlock, BaseModel, Flatten, Linear, Softmax

import tensorgraph as tg

class ModelA(BaseModel):

@BaseModel.init_name_scope

def __init__(self):

y_test = modelb.test_fprop(X_ph)

checkout some well known models in TensorGraph

1. [VGG16 code](tensorgraph/layers/backbones.py#L37) and [VGG19 code](tensorgraph/layers/backbones.py#L125) - [Very Deep Convolutional Networks for Large-Scale Image Recognition](https://arxiv.org/abs/1409.1556)

2. [DenseNet code](tensorgraph/layers/backbones.py#L477) - [Densely Connected Convolutional Networks](https://arxiv.org/abs/1608.06993)

the flexibility of building our computational graph without the worry of accidental

reinitialization of the `Variables`.

We defined three types of nodes

1. StartNode : for inputs to the graph

2. HiddenNode : for putting sequential layers inside

3. EndNode : for getting outputs from the model

We put all the sequential layers into a `HiddenNode`, `HiddenNode` can be connected

to another `HiddenNode` or `StartNode`, the nodes are connected together to form

an architecture. The graph always starts with `StartNode` and ends with `EndNode`.

Once we have defined an architecture, we can use the `Graph` object to connect the

path we want in the architecture, there can be multiple StartNodes (s1, s2, etc)

and multiple EndNodes (e1, e2, etc), we can define which path we want in the

entire architecture, example to link from `s2` to `e1`. The `StartNode` is where you place

your starting point, it can be a `placeholder`, a symbolic output from another graph,

or data output from `tfrecords`. `EndNode` is where you want to get an output from

the graph, where the output can be used to calculate loss or simply just a peek at the

outputs at that particular layer. Below shows an

[example](examples/example.py) of building a tensor graph.

<img src="draw/graph.png" height="250">

First define the `StartNode` for putting the input placeholder

h1 = HiddenNode(prev=[s1, s2],

input_merge_mode=Concat(),

layers=[Linear(y2_dim), RELU()])

h2 = HiddenNode(prev=[s2],

layers=[Linear(y2_dim), RELU()])

h3 = HiddenNode(prev=[h1, h2],

input_merge_mode=Sum(),

layers=[Linear(y1_dim), RELU()])

layers=[Linear(y1_dim+y2_dim, y2_dim), RELU()])

h2 = HiddenNode(prev=[s2],

layers=[Linear(y2_dim, y2_dim), RELU()])

h3 = HiddenNode(prev=[h1, h2],

input_merge_mode=Sum(),

layers=[Linear(y2_dim, y1_dim), RELU()])

Then define the `EndNode`. `EndNode` is used to back-trace the graph to connect

the nodes together.

e1 = EndNode(prev=[h3])

e2 = EndNode(prev=[h2])

Finally build the graph by putting `StartNodes` and `EndNodes` into `Graph`, we

can choose to use the entire architecture by using all the `StartNodes` and `EndNodes`

and run the forward propagation to get symbolic output from train mode. The number

graph = Graph(start=[s2], end=[e1])

o1, = graph.train_fprop()

Finally build an optimizer to optimize the objective function

o1_mse = tf.reduce_mean((y1 - o1)**2)

Below is another example for building a more powerful [hierachical softmax](examples/hierachical_softmax.py)

whereby the lower hierachical softmax layer can be conditioned on all the upper

hierachical softmax layers.

start = StartNode(input_vars=[x_ph])

h1 = HiddenNode(prev=[start], layers=[Linear(component_dim), Softmax()])

h2 = HiddenNode(prev=[h1], layers=[Linear(component_dim), Softmax()])

h3 = HiddenNode(prev=[h2], layers=[Linear(component_dim), Softmax()])

h1 = HiddenNode(prev=[start], layers=[Linear(x_dim, component_dim), Softmax()])

h2 = HiddenNode(prev=[h1], layers=[Linear(component_dim, component_dim), Softmax()])

h3 = HiddenNode(prev=[h2], layers=[Linear(component_dim, component_dim), Softmax()])

e1 = EndNode(prev=[h1], input_merge_mode=Sum())

Below is an example on transfer learning with bi-modality inputs and merge at

the middle layer with shared representation, in fact, TensorGraph can be used

to build any number of modalities for transfer learning.

<img src="draw/transferlearn.png" height="250">

s1 = StartNode(input_vars=[x1_ph])

s2 = StartNode(input_vars=[x2_ph])

h1 = HiddenNode(prev=[s1], layers=[Linear(shared_dim), RELU()])

h2 = HiddenNode(prev=[s2], layers=[Linear(shared_dim), RELU()])

h3 = HiddenNode(prev=[h1,h2], input_merge_mode=Sum(),

layers=[Linear(y_dim), Softmax()])

h1 = HiddenNode(prev=[s1], layers=[Linear(x1_dim, shared_dim), RELU()])

h2 = HiddenNode(prev=[s2], layers=[Linear(x2_dim, shared_dim), RELU()])

h3 = HiddenNode(prev=[h1,h2], input_merge_mode=Sum(),

layers=[Linear(shared_dim, y_dim), Softmax()])

e1 = EndNode(prev=[h3])

version=$1

git tag $version -m "update to version $version"

git push --tag