def setUp(self):
odx = ODX(0, 1)
odx.load_gtsf()
day = dt.datetime.strptime("01/30/18 00:00", "%m/%d/%y %H:%M")
megas = odx.preprocess_gtsf(day)
builder = NetworkBuilder(700)
self.net = builder.build(megas, 1)
def main():
sess = tf.Session()
image = read_image('../data/heart.jpg')
image = np.reshape(image, [1, 224, 224, 3]) # type numpy.ndarray
image.astype(np.float32)
parser = Parser('../data/alexnet.cfg')
network_builder = NetworkBuilder("test") # type: NetworkBuilder
network_builder.set_parser(parser)
network = network_builder.build() # type: Network
network.add_input_layer(InputLayer(tf.float32, [None, 224, 224, 3]))
network.add_output_layer(OutputLayer())
network.connect_each_layer()
sess.run(tf.global_variables_initializer())
fc_layer = sess.run(network.output, feed_dict={network.input: image})
def main():
parser = Parser('../data/alexnet.cfg')
network_builder = NetworkBuilder("test")
mnist = input_data.read_data_sets("F:/tf_net_parser/datasets/MNIST_data/",
one_hot=True) # 读取数据
network_builder.set_parser(parser)
network = network_builder.build() # type: Network
network.add_input_layer(InputLayer(tf.float32, [None, 28, 28, 1]))
network.add_output_layer(OutputLayer())
network.set_labels_placeholder(tf.placeholder(tf.float32, [None, 10]))
network.connect_each_layer()
network.set_accuracy()
network.init_optimizer()
train_tool = TrainTool()
train_tool.bind_network(network)
sess = tf.Session()
sess.run(tf.initialize_all_variables())
for i in range(300):
batch = mnist.train.next_batch(100)
feed_dict = {
network.input: np.reshape(batch[0], [-1, 28, 28, 1]),
network.labels: batch[1]
}
train_tool.train(sess, network.output, feed_dict=feed_dict)
if (i + 1) % 100 == 0:
train_tool.print_accuracy(sess, feed_dict)
train_tool.save_model_to_pb_file(
sess,
'../pb/alexnet-' + str(i + 1) + '/',
input_data={'input': network.input},
output={'predict-result': network.output})
# train_tool.save_ckpt_model('f:/tf_net_parser/save_model/model', sess, gloabl_step=(i+1))
batch_test = mnist.test.next_batch(100)
feed_dict = {
network.input: np.reshape(batch_test[0], [100, 28, 28, 1]),
network.labels: batch_test[1]
}
train_tool.print_test_accuracy(sess, feed_dict)
class Enterprise:
def __init__(self, path):
self.model = Model("ontology.graph")
self.nodes = dict()
self.actions = []
self.network = NetworkBuilder()
f = open(path)
for line in f:
if line[0] == '#':
continue
tokens = line.strip().split(' ')
if len(tokens) < 3:
continue
if tokens[1] == 'type':
class_name = self.model.get_class_info(tokens[-1])
if class_name == 'N/A':
print('UNKNOWN CLASS : ' + tokens[-1])
continue
else:
node = Node(tokens[-1], tokens[0])
self.nodes[tokens[0]] = node
elif tokens[1] == 'isGroupOf':
node_grp = NodeGroup(tokens[2], tokens[0], tokens[4])
self.nodes[tokens[0]] = node_grp
elif tokens[1] == 'uses':
action = Action(tokens[0], tokens[2], tokens[4])
self.actions.append(action)
elif tokens[1] == 'networkType':
self.network.build(tokens)
elif tokens[1] == 'attachTo':
attach_src = tokens[0]
if attach_src in self.nodes:
src = self.nodes[attach_src]
if src.get_entity_type() == 'NodeGroup':
members = src.get_members()
for member in members:
new_tokens = tokens
new_tokens[0] = member
self.network.build(new_tokens)
else:
self.network.build(tokens)
else:
self.network.build(tokens)
f.close()
def get_entity_type(self, entity_name):
return self.nodes[entity_name].get_entity_type()
def print_app_graph(self):
#for (k,node) in self.nodes.iteritems():
#qname = self.model.get_class_info(node.get_class_id())
#node_id = node.get_node_id()
#print('--- ' + node.get_entity_type())
#print(qname + ',' + node_id)
print('digraph dataflow {')
for a in self.actions:
src = self.nodes[a.get_src()]
target = self.nodes[a.get_target()]
relation = a.get_relation()
if src.get_entity_type() == 'NodeGroup':
src.expand_actions(True, target, relation)
elif target.get_entity_type() == 'NodeGroup':
target.expand_actions(False, src, relation)
else:
print_edge(a.get_src(), relation, a.get_target())
if a.get_src() == 'SalesTeam_0':
print(a.get_src() + '#############' + a.get_target())
print('}')
def print_topology(self):
print('graph topology {')
self.network.print_topology()
print('}')
def test_build(self):
builder = NetworkBuilder(700)
net = builder.build(self.megas, 1)
from network_builder import NetworkBuilder
nets_available = ["Net1","Net2","Net4","Net5","Net7","Net8","Net9","Net10","Net10v2","Net11","Net11v2","Net11v3"]
images_in = 10
for name in nets_available:
if name == "Net9":
bn = NetworkBuilder(name, depth=32,num_input_im = images_in, max_batch_size = 6, epochs = 500, steps_per_epoch = 50).build_net()
else:
bn = NetworkBuilder(name, depth=32,max_batch_size = 6, epochs = 500, steps_per_epoch = 5).build_net()
bn.build()
bn.fit()
bn.gen_raport()
del bn# = None
