10 import tensorflow
as tf
16 """ Using class to stop training early if it's not getting better"""
27 Check if validation result is better than the best validation result.
28 Decide if training should be continued.
42 def get_model(number_of_features, number_of_spectators, number_of_events, training_fraction, parameters):
43 """Building Graph inside tensorflow"""
44 tf.reset_default_graph()
45 x = tf.placeholder(tf.float32, [
None, number_of_features])
46 y = tf.placeholder(tf.float32, [
None, 1])
48 z = tf.placeholder(tf.float32, [
None, number_of_spectators])
50 def layer(x, shape, name, unit=tf.sigmoid):
51 """Build one hidden layer in feed forward net"""
52 with tf.name_scope(name)
as scope:
53 weights = tf.Variable(tf.truncated_normal(shape, stddev=1.0 / np.sqrt(float(shape[0]))), name=
'weights')
54 biases = tf.Variable(tf.constant(0.0, shape=[shape[1]]), name=
'biases')
55 layer = unit(tf.matmul(x, weights) + biases)
58 def build_relation_net_variables(shape, name):
59 """Build the variables(not the net itself), who will be shared between multiple relations"""
61 with tf.name_scope(name), tf.variable_scope(name):
62 for i
in range(len(shape) - 1):
63 weights = tf.get_variable(
'weights_{}'.format(i),
64 initializer=tf.truncated_normal(shape[i:i + 2],
65 stddev=1.0 / np.sqrt(float(shape[0]))))
66 biases = tf.get_variable(
'biases_{}'.format(i), initializer=tf.constant(0.0, shape=[shape[i + 1]]))
67 variables.append([weights, biases])
70 def relation_net(x, variables):
71 """Build one relation net between 2 object using pre-build variables"""
73 for layer
in variables:
74 if len(variables) != len(net):
75 net.append(tf.nn.tanh(tf.matmul(net[-1], layer[0]) + layer[1]))
77 return tf.nn.sigmoid(tf.matmul(net[-1], layer[0]) + layer[1])
79 if parameters[
'use_relations']:
82 [tracks.append(tf.slice(x, [0, i * 6], [-1, 6]))
for i
in range(int(number_of_features / 6))]
86 number_of_features_per_relation = 1
88 pre_training_relations = []
89 for feature_number
in range(number_of_features_per_relation):
91 relational_variables = build_relation_net_variables([12, 50, 50, 1],
92 'tracks_relational_{}'.format(feature_number))
94 for counter, track1
in enumerate(tracks):
95 for track2
in tracks[counter + 1:]:
97 relations.append(relation_net(tf.concat([track1, track2], 1), relational_variables))
99 if parameters[
'pre_training_epochs'] > 0:
101 pre_training_relations.append(relation_net(z, relational_variables))
103 new_x = tf.concat(relations, 1)
108 if parameters[
'use_feed_forward']:
109 print(
'Number of variables going into feed_forward:', int(new_x.get_shape()[1]))
110 inference_hidden1 = layer(new_x, [int(new_x.get_shape()[1]), 50],
'inference_hidden1')
111 inference_hidden2 = layer(inference_hidden1, [50, 50],
'inference_hidden2')
112 inference_activation = layer(inference_hidden2, [50, 1],
'inference_sigmoid', unit=tf.sigmoid)
114 print(
'Number of variables going into reduce_max:', int(new_x.get_shape()[1]))
115 inference_activation = layer(new_x, [int(new_x.get_shape()[1]), 1],
'inference_sigmoid', unit=tf.sigmoid)
116 print(inference_activation.get_shape())
119 inference_loss = -tf.reduce_sum(y * tf.log(inference_activation + epsilon) +
120 (1.0 - y) * tf.log(1 - inference_activation + epsilon))
122 inference_optimizer = tf.train.AdamOptimizer(learning_rate=0.01)
123 inference_minimize = inference_optimizer.minimize(inference_loss)
125 config = tf.ConfigProto()
126 config.gpu_options.allow_growth =
True
127 session = tf.Session(config=config)
129 state =
State(x, y, inference_activation, inference_loss, inference_minimize, session)
131 if parameters[
'pre_training_epochs'] > 0:
133 new_z = tf.concat(pre_training_relations, 1)
134 pre_activation = layer(new_z, [int(new_z.get_shape()[1]), 1],
'pre_output')
135 state.pre_loss = -tf.reduce_sum(y * tf.log(pre_activation + epsilon) +
136 (1.0 - y) * tf.log(1 - pre_activation + epsilon))
137 pre_optimizer = tf.train.AdamOptimizer(learning_rate=0.01)
138 state.pre_minimize = pre_optimizer.minimize(state.pre_loss)
140 state.pre_training_epochs = parameters[
'pre_training_epochs']
142 init = tf.global_variables_initializer()
148 def begin_fit(state, Xtest, Stest, ytest, wtest):
149 """Saves the training validation set for monitoring."""
157 def partial_fit(state, X, S, y, w, epoch):
158 """Pass received data to tensorflow session"""
159 feed_dict = {state.x: X, state.y: y, state.z: S}
163 if state.pre_training_epochs > epoch:
164 state.session.run(state.pre_minimize, feed_dict=feed_dict)
165 if epoch % 1000 == 0:
166 avg_cost = state.session.run(state.pre_loss, feed_dict={state.y: state.val_y, state.z: state.val_z})
167 print(
"Pre-Training: Epoch:",
'%04d' % (epoch),
"cost=",
"{:.9f}".format(avg_cost))
172 state.session.run(state.optimizer, feed_dict=feed_dict)
173 if epoch % 1000 == 0:
174 avg_cost = state.session.run(state.cost, feed_dict={state.y: state.val_y, state.x: state.val_x})
175 print(
"Epoch:",
'%04d' % (epoch),
"cost=",
"{:.9f}".format(avg_cost))
176 return EARLY_STOPPER.check(avg_cost)
181 if __name__ ==
"__main__":
184 from root_pandas
import to_root
190 import basf2_mva_util
201 number_total_lines = 5
203 for i
in range(number_total_lines):
204 variables += [
'px_' + str(i),
'py_' + str(i),
'pz_' + str(i),
'dx_' + str(i),
'dy_' + str(i),
208 spectators = [
'Spx1',
'Spy1',
'Spz1',
'Sdx1',
'Sdy1',
'Sdz1',
'Spx2',
'Spy2',
'Spz2',
'Sdx2',
'Sdy2',
'Sdz2']
210 number_of_events = 1000000
212 def build_signal_event():
213 """Building two lines which are hitting each other"""
214 p_vec1, p_vec2 = np.random.normal(size=3), np.random.normal(size=3)
215 v_cross = np.random.normal(size=3)
216 epsilon1, epsilon2 = np.random.rand() * 2 - 1, np.random.rand() * 2 - 1
217 v_vec1 = v_cross + (p_vec1 * epsilon1)
218 v_vec2 = v_cross + (p_vec2 * epsilon2)
219 return np.concatenate([p_vec1, v_vec1]), np.concatenate([p_vec2, v_vec2])
222 with tempfile.TemporaryDirectory()
as path:
223 for filename
in [
'train.root',
'test.root']:
224 print(
'Building ' + filename)
226 data = np.random.normal(size=[number_of_events, number_total_lines * 6 + 12])
227 target = np.zeros([number_of_events], dtype=bool)
231 for index, sample
in enumerate(data):
232 if np.random.rand() > 0.5:
234 i1, i2 = int(np.random.rand() * number_total_lines), int(np.random.rand() * (number_total_lines - 1))
235 i2 = (i1 + i2) % number_total_lines
236 track1, track2 = build_signal_event()
237 data[index, i1 * 6:(i1 + 1) * 6] = track1
238 data[index, i2 * 6:(i2 + 1) * 6] = track2
239 data[index, number_total_lines * 6:] = np.append(track1, track2)
243 for i, name
in enumerate(variables + spectators):
244 dic.update({name: data[:, i]})
245 dic.update({
'isSignal': target})
247 df = pandas.DataFrame(dic, dtype=np.float32)
248 to_root(df, os.path.join(path, filename), tree_key=
'variables')
253 general_options = basf2_mva.GeneralOptions()
254 general_options.m_datafiles = basf2_mva.vector(os.path.join(path,
'train.root'))
255 general_options.m_treename =
"variables"
256 general_options.m_variables = basf2_mva.vector(*variables)
257 general_options.m_target_variable =
"isSignal"
258 general_options.m_spectators = basf2_mva.vector(*spectators)
260 specific_options = basf2_mva.PythonOptions()
261 specific_options.m_framework =
"tensorflow"
262 specific_options.m_steering_file =
'toy_relations.py'
263 specific_options.m_nIterations = 100
264 specific_options.m_mini_batch_size = 100
265 specific_options.m_training_fraction = 0.999
267 print(
'Train relational net with pre-training')
268 general_options.m_identifier = os.path.join(path,
'relation_2.xml')
269 specific_options.m_config = json.dumps({
'use_relations':
True,
'use_feed_forward':
False,
'pre_training_epochs': 30000})
270 basf2_mva.teacher(general_options, specific_options)
273 print(
'Train feed forward net')
274 general_options.m_identifier = os.path.join(path,
'feed_forward.xml')
275 specific_options.m_config = json.dumps({
'use_relations':
False,
'use_feed_forward':
True,
'pre_training_epochs': 0})
276 basf2_mva.teacher(general_options, specific_options)
279 print(
'Train relational net')
280 general_options.m_identifier = os.path.join(path,
'relation.xml')
281 specific_options.m_config = json.dumps({
'use_relations':
True,
'use_feed_forward':
True,
'pre_training_epochs': 0})
282 basf2_mva.teacher(general_options, specific_options)
290 test_data = basf2_mva.vector(os.path.join(path,
'test.root'))
291 print(
'Apply feed forward net')
292 p1, t1 = method1.apply_expert(test_data, general_options.m_treename)
293 print(
'Apply relational net')
294 p2, t2 = method2.apply_expert(test_data, general_options.m_treename)
295 print(
'Aplly special relational net')
296 p3, t3 = method3.apply_expert(test_data, general_options.m_treename)