def init_data(self):
# Set up the model if it is new.
try:
name_model = DatumModel.load('name_datum')
except NotFound:
name_model = DatumModel('0', 'name_datum', key='name_datum')
name_model.save()
self.name_model = name_model
try:
app_model = ApplicationModel.load('main_app')
except NotFound:
app_model = ApplicationModel(key='main_app')
app_model.save()
self.app_model = app_model
try:
main_grid_model = GridModel.load('main_grid')
except NotFound:
main_grid_model = GridModel('main_grid')
main_grid_model.save()
if 'main_grid' not in self.app_model.grids:
self.app_model.grids.add('main_grid')
self.app_model.save()
if self.app_model.current_grid is None:
self.app_model.current_grid = 'main_grid'
self.app_model.save()
def test_clip_grid_init_save_and_load(self):
from model import GridModel
grid_model = GridModel()
self.assertIsNotNone(grid_model.key)
self.assertEqual(0, len(grid_model.clip_models))
key = grid_model.key
grid_model.save()
grid_model_2 = GridModel.load(key)
self.assertEqual(key, grid_model_2.key)
self.assertEqual(0, len(grid_model_2.clip_models))
def test_evaluator_errors(self):
from app import get_application
get_application().init_ui()
from controllers import BlankClip, get, Text, TextClip
from model import GridModel
grid_model = GridModel(key='test_grid')
grid_model.save()
grid = get('test_grid')
self.assertIsNotNone(grid)
grid.eval_declarations()
for y in range(2):
for x in range(5):
text = Text.create('')
# This is a hack to avoid some UI stuff during tests.
clip = TextClip.create(grid.model.key, text.model.key, x, y)
grid.coordinates_to_clip[(x, y)] = clip
#grid.add_text(text, x, y)
grid.eval_declarations()
# Declare an attribute on all Datums
cmd = '#*foo:22'
star_declaration = grid.coordinates_to_clip[(1, 0)]
star_declaration.datum.model.data = cmd
star_declaration.datum.model.save()
grid.eval_declarations()
self.assertEqual({'foo': '22'}, grid.grid_declarations)
self.assertEqual({}, grid.declarations_by_clip)
# Test error handling
def _check_subcommands(cmd, clip):
for i in range(len(cmd)):
subcmd = cmd[:i+1]
clip.datum.model.data = subcmd
clip.datum.model.save()
#log.info('---check subcommand {0}'.format(subcmd))
grid.eval_declarations()
clip = grid.coordinates_to_clip[(4, 0)]
cmd = '#*bar:22'
_check_subcommands(cmd, clip)
cmd = '#*bar:22\n#bar+bar'
_check_subcommands(cmd, clip)
self.assertEqual({'foo': '22', 'bar': '22'}, grid.grid_declarations)
self.assertEqual({}, grid.declarations_by_clip)
def test_create_save_and_load_of_application(self):
from controllers import get, get_controller_id_map, Grid
from model import NotFound, get_model_id_map, GridModel
# Note: Don't use 'get' or Model.create (which calls get) unless you
# create a PyQt5 Application, which we are avoiding in tests at the
# moment.
model = GridModel.load('main_grid')
self.assertIsInstance(model, GridModel)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("-d", "--device", default="cpu")
parser.add_argument("-b", "--batch-size", type=int, default=16)
parser.add_argument("-e", "--max-epoch", type=int, default=2)
parser.add_argument("-v", "--eval-per", type=int, default=2)
parser.add_argument("-c", "--checkpoint", type=int, default=100)
args = parser.parse_args()
args.device = torch.device(args.device)
model = GridModel()
train_grid(model, args)
class GridModelAPI(ModelAPI):
def _set_model(self):
self.model = GridModel(argv=self.argv,
emb=self.emb,
n_vocab=self.vocab_word.size(),
n_labels=self.vocab_label.size())
self.model.compile(self._get_input_tensor_variables())
def _get_input_tensor_variables(self):
# x_w: 1D: batch, 2D: n_prds, 3D: n_words, 4D: 5 + window; elem=word id
# x_p: 1D: batch, 2D: n_prds, 3D: n_words; elem=posit id
# y: 1D: batch, 2D: n_prds, 3D: n_words; elem=label id
if self.argv.mark_phi:
return [T.itensor4('x_w'), T.itensor3('x_p'), T.itensor3('y')]
return [T.itensor4('x_w'), T.itensor3('y')]
def _format_inputs(self, sample):
inputs = []
for x in sample.x:
inputs.append([x])
return inputs
def main():
parser = argparse.ArgumentParser()
parser.add_argument("-d", "--device", default="cpu")
parser.add_argument("-m", "--model")
args = parser.parse_args()
args.device = torch.device(args.device)
model = GridModel()
model.load_state_dict(torch.load(args.model, map_location=args.device))
model.eval()
with torch.no_grad():
data, truth, images = get_all_eval_grid()
f1 = 0
ap = 0
ar = 0
for i, (d, t, im) in enumerate(zip(data, truth, images)):
pred = model(d).squeeze()
conf, coor = transform_pred(
pred, (RESO_W / im.width, RESO_H / im.height), conf_thresh=0.5)
coor_nms = nms_filter(conf, coor, iou_thresh=0.1)
f1_0, ap_0, ar_0 = calc_f1(coor_nms, t, iou_thresh=0.5)
print("F1: ", f1_0)
print("AP: ", ap_0)
print("AR: ", ar_0)
f1 += f1_0
ap += ap_0
ar += ar_0
# pyplot.plot(recall, precision)
# draw = ImageDraw.Draw(im)
# for c in coor_nms:
# draw.rectangle(tuple(c), outline="magenta", width=2)
# for c in t:
# draw.rectangle(tuple(c), outline="lime", width=2)
# im.save(f"{i}.png")
# break
print("Final F1: ", f1 / len(images))
print("Final AP: ", ap / len(images))
print("Final AR: ", ar / len(images))
def _set_model(self):
self.model = GridModel(argv=self.argv,
emb=self.emb,
n_vocab=self.vocab_word.size(),
n_labels=self.vocab_label.size())
self.model.compile(self._get_input_tensor_variables())
def test_clip_grid_add(self):
from model import ClipModel, GridModel, TextModel
grid_model = GridModel()
self.assertIsNotNone(grid_model.key)
self.assertEqual(0, len(grid_model.clip_models))
key = grid_model.key
grid_model.save()
# temp
grid_model.load(key)
x = 1
y = 2
datum_model = TextModel('testtext1')
datum_model.save()
datum_key = datum_model.key
clip_model = ClipModel(key, datum_key, x, y)
# This is how the Clip controller saves.
# Normally you call clip_model.save(), this is clearbox.
grid_model.save_clip(clip_model)
self.assertEqual(1, len(grid_model.clip_models))
clip_model_1 = grid_model.clip_models[0]
self.assertEqual(datum_key, clip_model_1.datum_key)
self.assertEqual(x, clip_model_1.x)
self.assertEqual(y, clip_model_1.y)
grid_model_2 = GridModel.load(key)
self.assertEqual(1, len(grid_model_2.clip_models))
clip_model_1 = grid_model_2.clip_models[0]
self.assertEqual(datum_key, clip_model_1.datum_key)
self.assertEqual(x, clip_model_1.x)
self.assertEqual(y, clip_model_1.y)
x_2 = 3
y_2 = 12
datum_2_model = TextModel('testtext1')
datum_2_model.save()
datum_2_key = datum_2_model.key
clip_2_model = ClipModel(key, datum_2_key, x, y)
# with self.assertRaises(ValueError):
# grid_model.save_clip(clip_2_model)
clip_2_model = ClipModel(key, datum_2_key, x_2, y_2)
grid_model.save_clip(clip_2_model)
self.assertEqual(2, len(grid_model.clip_models))
clip_model_2 = grid_model.clip_models[1]
self.assertEqual(datum_2_key, clip_model_2.datum_key)
grid_model_2 = GridModel.load(key)
self.assertEqual(2, len(grid_model_2.clip_models))
clip_model_2 = grid_model_2.clip_models[1]
self.assertEqual(datum_2_key, clip_model_2.datum_key)
self.assertDictEqual({}, grid_model_2.relationships)
datum_a = TextModel('a')
datum_a.save()
datum_b = TextModel('b')
datum_b.save()
datum_c = TextModel('c')
datum_c.save()
grid_model_2.relationships[datum_a.key] = {
datum_b.key: 42
}
grid_model_2.save()
grid_model_3 = GridModel.load(key)
self.assertDictEqual(
{datum_a.key: {datum_b.key: 42}},
grid_model_3.relationships
)
def test_evaluator(self):
from app import get_application
get_application().init_ui()
from controllers import BlankClip, get, Text, TextClip
from model import GridModel
grid_model = GridModel(key='test_grid')
grid_model.save()
grid = get('test_grid')
self.assertIsNotNone(grid)
grid.eval_declarations()
for y in range(2):
for x in range(5):
text = Text.create('')
# This is a hack to avoid some UI stuff during tests.
clip = TextClip.create(grid.model.key, text.model.key, x, y)
grid.coordinates_to_clip[(x, y)] = clip
# grid.add_text(text, x, y)
grid.eval_declarations()
cmd1 = '#*foo:22\n#*bar:foo+&foo'
cmd2 = '#foo\n#bar\n#foo:42'
cursor_clip = grid.get_cursor_clip()
self.assertIsInstance(cursor_clip, BlankClip)
secondary_cursor_clip = grid.get_secondary_cursor_clip()
self.assertIsInstance(secondary_cursor_clip, BlankClip)
cmd1_x = 2
cmd1_y = 0
cmd2_x = 4
cmd2_y = 1
grid.main_cursor.model.x = cmd2_x
grid.main_cursor.model.y = cmd2_y
grid.main_cursor.model.save()
grid.secondary_cursor.model.x = cmd1_x
grid.secondary_cursor.model.y = cmd1_y
grid.secondary_cursor.model.save()
cmd1_clip = grid.coordinates_to_clip[(cmd1_x, cmd1_y)]
cmd1_clip.datum.model.data = cmd1
cmd1_clip.datum.model.save()
cmd2_clip = grid.coordinates_to_clip[(cmd2_x, cmd2_y)]
cmd2_clip.datum.model.data = cmd2
cmd2_clip.datum.model.save()
self.assertIs(cmd2_clip, grid.get_cursor_clip())
self.assertIs(cmd1_clip, grid.get_secondary_cursor_clip())
grid.eval_declarations()
self.assertEqual({'foo': '22', 'bar': 'foo+&foo'},
grid.grid_declarations)
self.assertEqual({cmd2_clip.datum.model.name: {'foo': '42'}},
grid.declarations_by_clip)
# This simulates what the inspector does, which is request a parse
# of the text of a datum into 'text' and various code snippets,
# and then evaluating the code one-by-one.
from parse import get_text_and_commands
tac = get_text_and_commands(cmd2)
self.assertEqual(
[('evaluation', 'foo'),
('evaluation', 'bar'),
('declaration', ('foo', '42'))], tac)
from parse import evaluate
result = evaluate(tac[0][1], grid, clip=cmd2_clip)
self.assertEqual([('value', 42)], result)
result = evaluate(tac[1][1], grid, clip=cmd2_clip)
self.assertEqual([('value', 64)], result)
def test_failed_load(self):
from model import GridModel, NotFound
with self.assertRaises(NotFound):
GridModel.load('key_that_does_not_exist')
def set_model(self):
self.model = GridModel(argv=self.argv,
emb=self.emb,
n_vocab=self.vocab_word.size(),
n_labels=self.vocab_label.size())
self.compile_model()