cifar10 and imagenet command line interfaces.
20 | Both include the train subcommands to learn a model from scratch.
21 | As an example, here is how to train ResNet164 with preactivation on CIFAR10:
22 |
23 | ```bash
24 | cifar10 train -c last --augmentation --tracking -b 128 --optimizer sgd --arch preact164 -e 5 -l 0.01
25 | cifar10 train -c last --augmentation --tracking -b 128 --optimizer sgd --arch preact164 -e 90 -l 0.1 --restore latest
26 | cifar10 train -c last --augmentation --tracking -b 128 --optimizer sgd --arch preact164 -e 45 -l 0.01 --restore latest
27 | cifar10 train -c last --augmentation --tracking -b 128 --optimizer sgd --arch preact164 -e 45 -l 0.001 --restore latest
28 | ```
29 |
30 | The first command creates a new run of ResNet164 with preactivation (`--arch preact164`) in the `./run/preact164/[TIMESTAMP]` directory and starts a warm up of 5 epochs (`-e 5`) with SGD (`--optimizer sgd`) and a learning rate of 0.01 (`-l 0.01`).
31 | `-c last` indicates that we only want to save a checkpoint after the last epoch of the warm up.
32 | `-b 128` sets the batch size to 128.
33 | `--augmentation` turns on standard data augmentation, i.e. random crop and flip.
34 | `--tracking` saves training and validation results to csv files at `./run/preact164/[TIMESTAMP]/[train|valid]_results.csv`
35 |
36 | The second command resumes the run from the first command (`--restore latest`) for another 90 epochs (`-e 90`) but with a new learning rate (`-l 0.1`). The third and fourth commands function similarly to the second command, changing the learning rate and running for more epochs.
37 |
--------------------------------------------------------------------------------
/tensorflow/SQuAD/tree/graph_handler.py:
--------------------------------------------------------------------------------
1 | import json
2 | from json import encoder
3 | import os
4 |
5 | import tensorflow as tf
6 |
7 | from tree.evaluator import Evaluation
8 | from my.utils import short_floats
9 |
10 |
11 | class GraphHandler(object):
12 | def __init__(self, config):
13 | self.config = config
14 | self.saver = tf.train.Saver()
15 | self.writer = None
16 | self.save_path = os.path.join(config.save_dir, config.model_name)
17 |
18 | def initialize(self, sess):
19 | if self.config.load:
20 | self._load(sess)
21 | else:
22 | sess.run(tf.global_variables_initializer())
23 |
24 | if self.config.mode == 'train':
25 | self.writer = tf.summary.FileWriter(self.config.log_dir, graph=tf.get_default_graph())
26 |
27 | def save(self, sess, global_step=None):
28 | self.saver.save(sess, self.save_path, global_step=global_step)
29 |
30 | def _load(self, sess):
31 | config = self.config
32 | if config.load_step > 0:
33 | save_path = os.path.join(config.save_dir, "{}-{}".format(config.model_name, config.load_step))
34 | else:
35 | save_dir = config.save_dir
36 | checkpoint = tf.train.get_checkpoint_state(save_dir)
37 | assert checkpoint is not None, "cannot load checkpoint at {}".format(save_dir)
38 | save_path = checkpoint.model_checkpoint_path
39 | print("Loading saved model from {}".format(save_path))
40 | self.saver.restore(sess, save_path)
41 |
42 | def add_summary(self, summary, global_step):
43 | self.writer.add_summary(summary, global_step)
44 |
45 | def add_summaries(self, summaries, global_step):
46 | for summary in summaries:
47 | self.add_summary(summary, global_step)
48 |
49 | def dump_eval(self, e, precision=2):
50 | assert isinstance(e, Evaluation)
51 | path = os.path.join(self.config.eval_dir, "{}-{}.json".format(e.data_type, str(e.global_step).zfill(6)))
52 | with open(path, 'w') as fh:
53 | json.dump(short_floats(e.dict, precision), fh)
54 |
55 |
--------------------------------------------------------------------------------
/tensorflow/CIFAR10/time_inference.py:
--------------------------------------------------------------------------------
1 | import argparse
2 | import os
3 | import subprocess
4 | import sys
5 |
6 | def main(checkpoint_path, model, use_bottleneck):
7 | print("Number of images\tInference time")
8 | num_trials = 10
9 | for batch_size in [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192]:
10 | command = ("python3 resnet/resnet_main.py --mode=eval --eval_data_path=cifar10/test_batch.bin "
11 | "--eval_dir=data/%(model)s/log_root/eval --dataset='cifar10' --model=%(model)s "
12 | "--use_bottleneck=%(use_bottleneck)s --eval_batch_count=%(num_trials)d --eval_once=True --num_gpus=1 "
13 | "--data_format=NHWC --time_inference=True --eval_batch_count=1 --batch_size=%(batch_size)d" %
14 | {"model": model, "use_bottleneck": "True" if use_bottleneck else "False", "batch_size": batch_size,
15 | "num_trials": num_trials})
16 | full_command = command + " --log_root=%s 2>/dev/null" % checkpoint_path
17 | try:
18 | output = subprocess.check_output(full_command, shell=True)
19 | output = output.decode('utf8').strip()
20 | for line in output.split('\n'):
21 | if "Time for inference" in line:
22 | line = line.strip()
23 | inference_time = float(line.split(": ")[1]) / num_trials
24 | stats = [batch_size, inference_time]
25 | print("\t".join([str(stat) for stat in stats]))
26 | sys.stdout.flush()
27 | except:
28 | stats = [batch_size, ""]
29 | print("\t".join([str(stat) for stat in stats]))
30 | sys.stdout.flush()
31 |
32 |
33 | if __name__ == '__main__':
34 | parser = argparse.ArgumentParser(
35 | description=("Backup model checkpoints periodically")
36 | )
37 | parser.add_argument('-i', "--checkpoint_path", type=str, required=True,
38 | help="Path to dumped model checkpoints")
39 | parser.add_argument('-m', "--model", type=str, required=True,
40 | help="Model name")
41 | parser.add_argument('-b', "--use_bottleneck", type=bool, default=False,
42 | help="Use bottleneck")
43 |
44 | cmdline_args = parser.parse_args()
45 | opt_dict = vars(cmdline_args)
46 |
47 | checkpoint_path = opt_dict["checkpoint_path"]
48 | model = opt_dict["model"]
49 | use_bottleneck = opt_dict["use_bottleneck"]
50 |
51 | main(checkpoint_path, model, use_bottleneck)
52 |
--------------------------------------------------------------------------------
/tensorflow/CIFAR10/eval_checkpoints.py:
--------------------------------------------------------------------------------
1 | import argparse
2 | import os
3 | import subprocess
4 | import sys
5 |
6 | def main(checkpoints_path, command, start_cnt):
7 | cnt = start_cnt
8 |
9 | times = {}
10 | cum_time = 0.0
11 | with open(os.path.join(checkpoints_path, "times.log"), 'r') as f:
12 | output = f.read().strip()
13 | output_lines = output.split('\n')
14 | for output_line in output_lines:
15 | [step, time] = output_line.split('\t')
16 | step = int(step.split(': ')[1])
17 | time = float(time.split(': ')[1])
18 | cum_time += time
19 | times[step] = cum_time
20 |
21 | print("Time (in secs)\tNumber of minibatches\tTop 1 accuracy\tTop 5 accuracy")
22 | while True:
23 | ckpt_path = ("%5d" % cnt).replace(' ', '0')
24 | full_ckpt_path = os.path.join(checkpoints_path, ckpt_path)
25 | if not os.path.exists(full_ckpt_path):
26 | break
27 | if len(os.listdir(full_ckpt_path)) <= 2:
28 | cnt += 1
29 | continue
30 | full_command = command + " --log_root=%s 2>/dev/null" % full_ckpt_path
31 | output = subprocess.check_output(full_command, shell=True)
32 | output = output.decode('utf8').strip()
33 | for line in output.split('\n'):
34 | if "Precision" in line and "Recall" in line:
35 | tokens = line.split(", ") # TODO: Nasty hack, make more robust.
36 | precision_at_1 = float(tokens[0].split()[-1])
37 | recall_at_5 = float(tokens[1].split()[-1])
38 | step = int(tokens[2].split()[3])
39 | stats = [times[step], step, precision_at_1, recall_at_5]
40 | print("\t".join([str(stat) for stat in stats]))
41 | sys.stdout.flush()
42 | cnt += 1
43 |
44 |
45 | if __name__ == '__main__':
46 | parser = argparse.ArgumentParser(
47 | description=("Backup model checkpoints periodically")
48 | )
49 | parser.add_argument('-i', "--checkpoints_path", type=str, required=True,
50 | help="Path to dumped model checkpoints")
51 | parser.add_argument('-c', "--command", type=str, required=True,
52 | help="Command to evaluate each individual checkpoint")
53 | parser.add_argument('-s', "--start_cnt", type=int, default=1,
54 | help="Count to start evaluating checkpoints from")
55 |
56 | cmdline_args = parser.parse_args()
57 | opt_dict = vars(cmdline_args)
58 |
59 | main(opt_dict["checkpoints_path"], opt_dict["command"], opt_dict["start_cnt"])
60 |
--------------------------------------------------------------------------------
/tensorflow/SQuAD/tree/templates/visualizer.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | | ID | 28 |Question | 29 |Answer | 30 |Paragraph | 31 |||
|---|---|---|---|---|---|
| {{ row.id }} | 35 |36 | {% for qj in row.ques %} 37 | {{ qj }} 38 | {% endfor %} 39 | | 40 |{{ row.a }} | 41 |
42 |
|
63 |
| ID | 28 |Question | 29 |Answers | 30 |Predicted | 31 |Score | 32 |Paragraph | 33 |||
|---|---|---|---|---|---|---|---|
| {{ row.id }} | 37 |38 | {% for qj in row.ques %} 39 | {{ qj }} 40 | {% endfor %} 41 | | 42 |
43 | {% for aa in row.a %}
44 | |
47 | {{ row.ap }} | 48 |{{ row.score }} | 49 |
50 |
|
72 |
| ID | 28 |Question | 29 |Answers | 30 |Predicted | 31 |Score | 32 |Paragraph | 33 |||
|---|---|---|---|---|---|---|---|
| {{ row.id }} | 37 |38 | {% for qj in row.ques %} 39 | {{ qj }} 40 | {% endfor %} 41 | | 42 |
43 | {% for aa in row.a %}
44 | |
47 | {{ row.ap }} | 48 |{{ row.score }} | 49 |
50 |
|
72 |