def fill_form_if_cloned(form): # is there a request to clone a job. from digits.webapp import scheduler clone = get_request_arg('clone') if clone is not None: clone_job = scheduler.get_job(clone) fill_form_from_job(clone_job, form)
def load_dataset(self): from digits.webapp import scheduler job = scheduler.get_job(self.dataset_id) assert job is not None, 'Cannot find dataset' self.dataset = job for task in self.tasks: task.dataset = job
def visualize_network(): """ Returns a visualization of the custom network as a string of PNG data """ framework = flask.request.args.get('framework') if not framework: raise werkzeug.exceptions.BadRequest('framework not provided') dataset = None if 'dataset_id' in flask.request.form: dataset = scheduler.get_job(flask.request.form['dataset_id']) fw = frameworks.get_framework_by_id(framework) ret = fw.get_network_visualization( desc=flask.request.form['custom_network'], dataset=dataset, solver_type=flask.request.form['solver_type'] if 'solver_type' in flask.request.form else None, use_mean=flask.request.form['use_mean'] if 'use_mean' in flask.request.form else None, crop_size=flask.request.form['crop_size'] if 'crop_size' in flask.request.form else None, num_gpus=flask.request.form['num_gpus'] if 'num_gpus' in flask.request.form else None, ) return ret
def layer_visualizations(job_id): job = scheduler.get_job(job_id) if not job.has_deploy(): job.tasks[0].write_deploy() return flask.render_template("pretrained_models/layer_visualizations.html", job=format_job_name(job))
def models_customize(): """Returns a customized file for the Model based on completed form fields""" network = request.args.get('network') if not network: return 'args.network not found!', 400 networks_dir = os.path.join(os.path.dirname(digits.__file__), 'standard-networks') for filename in os.listdir(networks_dir): path = os.path.join(networks_dir, filename) if os.path.isfile(path): match = re.match(r'%s.prototxt' % network, filename) if match: with open(path) as infile: return json.dumps({'network': infile.read()}) job = scheduler.get_job(network) snapshot = None try: epoch = int(request.form['snapshot_epoch']) for filename, e in job.train_task().snapshots: if e == epoch: snapshot = job.path(filename) break except: pass if job: return json.dumps({ 'network': text_format.MessageToString(job.train_task().network), 'snapshot': snapshot }) return 'ERROR: Network not found!', 400
def download(job_id, extension): """ Return a tarball of all files required to run the model """ job = scheduler.get_job(job_id) if job is None: raise werkzeug.exceptions.NotFound('Job not found') epoch = -1 # GET ?epoch=n if 'epoch' in flask.request.args: epoch = float(flask.request.args['epoch']) # POST ?snapshot_epoch=n (from form) elif 'snapshot_epoch' in flask.request.form: epoch = float(flask.request.form['snapshot_epoch']) # Write the stats of the job to json, # and store in tempfile (for archive) info = json.dumps(job.json_dict(verbose=False, epoch=epoch), sort_keys=True, indent=4, separators=(',', ': ')) info_io = io.BytesIO() info_io.write(info) task = job.train_task() snapshot_filename = None snapshot_filename = task.get_snapshot(epoch) b = io.BytesIO() if extension in ['tar', 'tar.gz', 'tgz', 'tar.bz2']: # tar file mode = '' if extension in ['tar.gz', 'tgz']: mode = 'gz' elif extension in ['tar.bz2']: mode = 'bz2' with tarfile.open(fileobj=b, mode='w:%s' % mode) as tf: for path, name in job.download_files(epoch): tf.add(path, arcname=name) tf_info = tarfile.TarInfo("info.json") tf_info.size = len(info_io.getvalue()) info_io.seek(0) tf.addfile(tf_info, info_io) elif extension in ['zip']: with zipfile.ZipFile(b, 'w') as zf: for path, name in job.download_files(epoch): zf.write(path, arcname=name) zf.writestr("info.json", info_io.getvalue()) else: raise werkzeug.exceptions.BadRequest('Invalid extension') response = flask.make_response(b.getvalue()) response.headers[ 'Content-Disposition'] = 'attachment; filename=%s_epoch_%s.%s' % ( job.id(), epoch, extension) return response
def image_classification_model_test_one(): job = scheduler.get_job(request.args['job_id']) if not job: abort(404) image = None if request.form['image_url']: image = utils.image.load_image(request.form['image_url']) elif request.files['image_file']: with tempfile.NamedTemporaryFile() as outfile: request.files['image_file'].save(outfile.name) image = utils.image.load_image(outfile.name) if image is None: return 'There was a problem with the image.', 400 task = job.train_task().dataset.train_db_task() image = utils.image.resize_image(image, task.image_dims[0], task.image_dims[1], channels = task.image_dims[2], resize_mode = task.resize_mode, ) epoch = int(request.form['snapshot_epoch']) predictions, visualizations = job.train_task().infer_one(image, snapshot_epoch=epoch, layers='all') # take top 5 predictions = [(p[0], round(100.0*p[1],2)) for p in predictions[:5]] # embed as html visualizations = [( v[0], utils.image.embed_image_html(v[1]), utils.image.embed_image_html(v[2]), ) for v in visualizations] return render_template('models/images/classification/infer_one.html', image_src = utils.image.embed_image_html(image), predictions = predictions, visualizations = visualizations, )
def get_previous_network_snapshots(): prev_network_snapshots = [] for job_id, _ in get_previous_networks(): job = scheduler.get_job(job_id) e = [(0, "None")] + [(epoch, "Epoch #%s" % epoch) for _, epoch in reversed(job.train_task().snapshots)] prev_network_snapshots.append(e) return prev_network_snapshots
def image_classification_trial_show_examples(job_id, class_example): job = scheduler.get_job(job_id) hit_results = job.hit_miss_results[str(class_example)]['hit'] miss_results = job.hit_miss_results[str(class_example)]['miss'] return render_template("trials/images/classification/images.html", class_example=class_example, miss_results=miss_results, hit_results=hit_results, job_id=job_id, job=job)
def features_download(job_id, extension): """ Return a tarball of all features extracted from the model """ job = scheduler.get_job(job_id) if job is None: raise werkzeug.exceptions.NotFound('Job not found') b = io.BytesIO() if extension in ['tar', 'tar.gz', 'tgz', 'tar.bz2']: # tar file mode = '' if extension in ['tar.gz', 'tgz']: mode = 'gz' elif extension in ['tar.bz2']: mode = 'bz2' with tarfile.open(fileobj=b, mode='w:%s' % mode) as tf: tf.add(job.dir(), arcname='features') elif extension in ['zip']: with zipfile.ZipFile(b, 'w') as zf: zf.write(job.dir(), arcname='features') else: raise werkzeug.exceptions.BadRequest('Invalid extension') response = flask.make_response(b.getvalue()) response.headers['Content-Disposition'] = 'attachment; filename=%s.%s' % (job.id(), extension) return response
def models_customize(): """ Returns a customized file for the ModelJob based on completed form fields """ network = flask.request.args['network'] if not network: raise werkzeug.exceptions.BadRequest('network not provided') networks_dir = os.path.join(os.path.dirname(digits.__file__), 'standard-networks') for filename in os.listdir(networks_dir): path = os.path.join(networks_dir, filename) if os.path.isfile(path): match = re.match(r'%s.prototxt' % network, filename) if match: with open(path) as infile: return json.dumps({'network': infile.read()}) job = scheduler.get_job(network) if job is None: raise werkzeug.exceptions.NotFound('Job not found') snapshot = None try: epoch = int(flask.request.form['snapshot_epoch']) for filename, e in job.train_task().snapshots: if e == epoch: snapshot = job.path(filename) break except: pass return json.dumps({ 'network': text_format.MessageToString(job.train_task().network), 'snapshot': snapshot })
def models_customize(): """ Returns a customized file for the ModelJob based on completed form fields """ network = flask.request.args['network'] framework = flask.request.args.get('framework') if not network: raise werkzeug.exceptions.BadRequest('network not provided') fw = frameworks.get_framework_by_id(framework) # can we find it in standard networks? network_desc = fw.get_standard_network_desc(network) if network_desc: return json.dumps({'network': network_desc}) # not found in standard networks, looking for matching job job = scheduler.get_job(network) if job is None: raise werkzeug.exceptions.NotFound('Job not found') snapshot = None try: epoch = int(flask.request.form['snapshot_epoch']) for filename, e in job.train_task().snapshots: if e == epoch: snapshot = job.path(filename) break except: pass return json.dumps({ 'network': job.train_task().get_network_desc(), 'snapshot': snapshot })
def on_status_update(self): """ Called when StatusCls.status.setter is used """ from digits.webapp import app, socketio # Send socketio updates message = { 'task': self.html_id(), 'update': 'status', 'status': self.status.name, 'css': self.status.css, 'show': (self.status in [Status.RUN, Status.ERROR]), 'running': self.status.is_running(), } with app.app_context(): message['html'] = flask.render_template( 'status_updates.html', updates=self.status_history, exception=self.exception, traceback=self.traceback, ) socketio.emit( 'task update', message, namespace='/jobs', room=self.job_id, ) from digits.webapp import scheduler job = scheduler.get_job(self.job_id) if job: job.on_status_update()
def inference_form(extension_id, job_id): """ Returns a rendering of an inference form """ inference_form_html = "" if extension_id != "all-default": extension_class = extensions.data.get_extension(extension_id) if not extension_class: raise RuntimeError("Unable to find data extension with ID=%s" % job_id.dataset.extension_id) job = scheduler.get_job(job_id) if hasattr(job, 'extension_userdata'): extension_userdata = job.extension_userdata else: extension_userdata = {} extension_userdata.update({'is_inference_db': True}) extension = extension_class(**extension_userdata) form = extension.get_inference_form() if form: template, context = extension.get_inference_template(form) inference_form_html = flask.render_template_string(template, **context) return inference_form_html
def show(job_id): """ Show a DatasetJob Returns JSON when requested: {id, name, directory, status} """ job = scheduler.get_job(job_id) if job is None: raise werkzeug.exceptions.NotFound('Job not found') related_jobs = scheduler.get_related_jobs(job) if request_wants_json(): return flask.jsonify(job.json_dict(True)) else: if isinstance(job, dataset_images.ImageClassificationDatasetJob): return dataset_images.classification.views.show( job, related_jobs=related_jobs) elif isinstance(job, dataset_images.GenericImageDatasetJob): return dataset_images.generic.views.show(job, related_jobs=related_jobs) elif isinstance(job, generic.GenericDatasetJob): return generic.views.show(job, related_jobs=related_jobs) else: raise werkzeug.exceptions.BadRequest('Invalid job type')
def on_status_update(self): """ Called when StatusCls.status.setter is used """ from digits.webapp import app, socketio # Send socketio updates message = { 'task': self.html_id(), 'update': 'status', 'status': self.status.name, 'css': self.status.css, 'show': (self.status in [Status.RUN, Status.ERROR]), 'running': self.status.is_running(), } with app.app_context(): message['html'] = flask.render_template('status_updates.html', updates = self.status_history, exception = self.exception, traceback = self.traceback, ) socketio.emit('task update', message, namespace='/jobs', room=self.job_id, ) from digits.webapp import scheduler job = scheduler.get_job(self.job_id) if job: job.on_status_update()
def models_customize(): """Returns a customized file for the Model based on completed form fields""" network = request.args.get('network') if not network: return 'args.network not found!', 400 networks_dir = os.path.join(os.path.dirname(digits.__file__), 'standard-networks') for filename in os.listdir(networks_dir): path = os.path.join(networks_dir, filename) if os.path.isfile(path): match = re.match(r'%s.prototxt' % network, filename) if match: with open(path) as infile: return json.dumps({'network': infile.read()}) job = scheduler.get_job(network) try: epoch = int(request.form['snapshot_epoch']) for filename, e in job.train_task().snapshots: if e == epoch: snapshot = job.path(filename) break except Exception as e: snapshot = None if job: return json.dumps({ 'network': text_format.MessageToString(job.train_task().network), 'snapshot': snapshot }) return 'ERROR: Network not found!', 400
def get_outputs(): job = scheduler.get_job(flask.request.args["job_id"]) # If older job, then create weights db file: if not job.has_weights(): job.tasks[0].write_deploy() weights_job = run_weights_job(job, utils.auth.get_username()) weights_job.wait_completion() # If failed to create weights, recommend re-uploading: status = weights_job.status.name if status is "Error": return flask.jsonify({ "stats": status, "msg": "Could not generate weights, consider re-uploading job." }) layers_with_outputs = [] if os.path.isfile(job.get_filters_path()): f = h5py.File(job.get_filters_path(), 'r') layers_with_outputs = f.keys() return flask.jsonify({ "model_def": job.get_model_def(True), "framework": job.framework, "layers_with_outputs": layers_with_outputs })
def features_download(job_id, extension): """ Return a tarball of all features extracted from the model """ job = scheduler.get_job(job_id) if job is None: raise werkzeug.exceptions.NotFound('Job not found') b = io.BytesIO() if extension in ['tar', 'tar.gz', 'tgz', 'tar.bz2']: # tar file mode = '' if extension in ['tar.gz', 'tgz']: mode = 'gz' elif extension in ['tar.bz2']: mode = 'bz2' with tarfile.open(fileobj=b, mode='w:%s' % mode) as tf: tf.add(job.dir(), arcname='features') elif extension in ['zip']: with zipfile.ZipFile(b, 'w') as zf: zf.write(job.dir(), arcname='features') else: raise werkzeug.exceptions.BadRequest('Invalid extension') response = flask.make_response(b.getvalue()) response.headers['Content-Disposition'] = 'attachment; filename=%s.%s' % ( job.id(), extension) return response
def get_previous_network_snapshots(): prev_network_snapshots = [] for job_id, _ in get_previous_networks(): job = scheduler.get_job(job_id) e = [(0, 'None')] + [(epoch, 'Epoch #%s' % epoch) for _, epoch in reversed(job.train_task().snapshots)] prev_network_snapshots.append(e) return prev_network_snapshots
def dataset_summary(): job_id = request.args.get('job_id', '') if not job_id: return 'No job_id in request!' job = scheduler.get_job(job_id) return render_template('datasets/summary.html', dataset=job)
def set_previous_network_snapshots(form): while len(form.previous_network_snapshots): form.previous_network_snapshots.pop_entry() for job_id, _ in get_previous_networks(): job = scheduler.get_job(job_id) e = form.previous_network_snapshots.append_entry() e.choices = [('none', 'None')] + [(epoch, 'Epoch #%s' % epoch) for _, epoch in reversed(job.train_task().snapshots)]
def dataset_summary(): """ Return a short HTML summary of a DatasetJob """ job = scheduler.get_job(flask.request.args['job_id']) if job is None: raise werkzeug.exceptions.NotFound('Job not found') return flask.render_template('datasets/summary.html', dataset=job)
def image_classification_model_large_graph(): """ Show the loss/accuracy graph, but bigger """ job = scheduler.get_job(request.args['job_id']) if not job: abort(404) return render_template('models/images/classification/large_graph.html', job=job)
def image_classification_model_large_graph(): """ Show the loss/accuracy graph, but bigger """ job = scheduler.get_job(flask.request.args['job_id']) if job is None: raise werkzeug.exceptions.NotFound('Job not found') return flask.render_template('models/images/classification/large_graph.html', job=job)
def get_previous_network_snapshots(): prev_network_snapshots = [] for job_id, _ in get_previous_networks(): job = scheduler.get_job(job_id) e = [(0, "None")] + [(epoch, "Epoch #%s" % epoch) for _, epoch in reversed(job.train_task().snapshots)] if job.train_task().pretrained_model: e.insert(0, (-1, "Previous pretrained model")) prev_network_snapshots.append(e) return prev_network_snapshots
def download(job_id, extension): """ Return a tarball of all files required to run the model """ job = scheduler.get_job(job_id) if job is None: raise werkzeug.exceptions.NotFound('Job not found') epoch = -1 # GET ?epoch=n if 'epoch' in flask.request.args: epoch = float(flask.request.args['epoch']) # POST ?snapshot_epoch=n (from form) elif 'snapshot_epoch' in flask.request.form: epoch = float(flask.request.form['snapshot_epoch']) # Write the stats of the job to json, # and store in tempfile (for archive) info = json.dumps(job.json_dict(verbose=False,epoch=epoch), sort_keys=True, indent=4, separators=(',', ': ')) temp = tempfile.NamedTemporaryFile() temp.write(info) temp.seek(0) task = job.train_task() snapshot_filename = None snapshot_filename = task.get_snapshot(epoch) b = io.BytesIO() if extension in ['tar', 'tar.gz', 'tgz', 'tar.bz2']: # tar file mode = '' if extension in ['tar.gz', 'tgz']: mode = 'gz' elif extension in ['tar.bz2']: mode = 'bz2' with tarfile.open(fileobj=b, mode='w:%s' % mode) as tf: for path, name in job.download_files(epoch): tf.add(path, arcname=name) tf.add(temp.name,arcname="info.json") elif extension in ['zip']: with zipfile.ZipFile(b, 'w') as zf: for path, name in job.download_files(epoch): zf.write(path, arcname=name) zf.write(temp.name,arcname="info.json") else: raise werkzeug.exceptions.BadRequest('Invalid extension') # Close and delete temporary file temp.close() response = flask.make_response(b.getvalue()) response.headers['Content-Disposition'] = 'attachment; filename=%s_epoch_%s.%s' % (job.id(), epoch, extension) return response
def trials_show(job_id): job = scheduler.get_job(job_id) if job is None: abort(404) if isinstance(job, trial_images.ImageClassificationTrialJob): return trial_images.classification.views.show(job) else: abort(404)
def experiments_show(job_id): job = scheduler.get_job(job_id) if job is None: abort(404) if isinstance(job, experiment_images.ImageClassificationExperimentJob): return experiment_images.classification.views.show(job) else: abort(404)
def get_previous_network_snapshots(): prev_network_snapshots = [] for job_id, _ in get_previous_networks(): job = scheduler.get_job(job_id) e = [(0, 'None')] + [(epoch, 'Epoch #%s' % epoch) for _, epoch in reversed(job.train_task().snapshots)] if job.train_task().pretrained_model: e.insert(0, (-1, 'Previous pretrained model')) prev_network_snapshots.append(e) return prev_network_snapshots
def models_show(job_id): job = scheduler.get_job(job_id) if job is None: abort(404) if isinstance(job, model_images.ImageClassificationModelJob): return model_images.classification.views.show(job) else: abort(404)
def datasets_show(job_id): job = scheduler.get_job(job_id) if job is None: abort(404) if isinstance(job, dataset_images.ImageClassificationDatasetJob): return dataset_images.classification.views.show(job) else: abort(404)
def models_download(job_id, extension='tar.gz'): """ Return a tarball of all files required to run the model """ job = scheduler.get_job(job_id) if not job: return 'Job not found', 404 epoch = -1 # GET ?epoch=n if 'epoch' in request.args: epoch = float(request.args['epoch']) # POST ?snapshot_epoch=n (from form) elif 'snapshot_epoch' in request.form: epoch = float(request.form['snapshot_epoch']) task = job.train_task() snapshot_filename = None if epoch == -1 and len(task.snapshots): epoch = task.snapshots[-1][1] snapshot_filename = task.snapshots[-1][0] else: for f, e in task.snapshots: if e == epoch: snapshot_filename = f break if not snapshot_filename: return 'Invalid epoch', 400 b = io.BytesIO() if extension in ['tar', 'tar.gz', 'tgz', 'tar.bz2']: # tar file mode = '' if extension in ['tar.gz', 'tgz']: mode = 'gz' elif extension in ['tar.bz2']: mode = 'bz2' with tarfile.open(fileobj=b, mode='w:%s' % mode) as tf: for path, name in job.download_files(epoch): tf.add(path, arcname=name) elif extension in ['zip']: with zipfile.ZipFile(b, 'w') as zf: for path, name in job.download_files(epoch): zf.write(path, arcname=name) else: return 'Unrecognized extension "%s"' % extension, 400 response = make_response(b.getvalue()) response.headers[ 'Content-Disposition'] = 'attachment; filename=%s_epoch_%s.%s' % ( job.id(), epoch, extension) return response
def dataset_summary(): """ Return a short HTML summary of a DatasetJob """ job_id = request.args.get('job_id', '') if not job_id: return 'No job_id in request!' job = scheduler.get_job(job_id) return render_template('datasets/summary.html', dataset=job)
def image_classification_model_classify_one(): """ Classify one image and return the predictions, weights and activations """ job = scheduler.get_job(request.args['job_id']) if not job: abort(404) image = None if 'image_url' in request.form and request.form['image_url']: image = utils.image.load_image(request.form['image_url']) elif 'image_file' in request.files and request.files['image_file']: with tempfile.NamedTemporaryFile() as outfile: request.files['image_file'].save(outfile.name) image = utils.image.load_image(outfile.name) else: return 'You must select an image to classify', 400 # resize image db_task = job.train_task().dataset.train_db_task() height = db_task.image_dims[0] width = db_task.image_dims[1] if job.train_task().crop_size: height = job.train_task().crop_size width = job.train_task().crop_size image = utils.image.resize_image( image, height, width, channels=db_task.image_dims[2], resize_mode=db_task.resize_mode, ) epoch = None if 'snapshot_epoch' in request.form: epoch = float(request.form['snapshot_epoch']) layers = 'none' if 'show_visualizations' in request.form and request.form[ 'show_visualizations']: layers = 'all' predictions, visualizations = job.train_task().infer_one( image, snapshot_epoch=epoch, layers=layers) # take top 5 predictions = [(p[0], round(100.0 * p[1], 2)) for p in predictions[:5]] return render_template( 'models/images/classification/classify_one.html', image_src=utils.image.embed_image_html(image), predictions=predictions, visualizations=visualizations, )
def models_download(job_id, extension='tar.gz'): """ Return a tarball of all files required to run the model """ job = scheduler.get_job(job_id) if not job: return 'Job not found', 404 epoch = -1 # GET ?epoch=n if 'epoch' in request.args: epoch = float(request.args['epoch']) # POST ?snapshot_epoch=n (from form) elif 'snapshot_epoch' in request.form: epoch = float(request.form['snapshot_epoch']) task = job.train_task() snapshot_filename = None if epoch == -1 and len(task.snapshots): epoch = task.snapshots[-1][1] snapshot_filename = task.snapshots[-1][0] else: for f, e in task.snapshots: if e == epoch: snapshot_filename = f break if not snapshot_filename: return 'Invalid epoch', 400 b = io.BytesIO() if extension in ['tar', 'tar.gz', 'tgz', 'tar.bz2']: # tar file mode = '' if extension in ['tar.gz', 'tgz']: mode = 'gz' elif extension in ['tar.bz2']: mode = 'bz2' with tarfile.open(fileobj=b, mode='w:%s' % mode) as tf: for path, name in job.download_files(epoch): tf.add(path, arcname=name) elif extension in ['zip']: with zipfile.ZipFile(b, 'w') as zf: for path, name in job.download_files(epoch): zf.write(path, arcname=name) else: return 'Unrecognized extension "%s"' % extension, 400 response = make_response(b.getvalue()) response.headers['Content-Disposition'] = 'attachment; filename=%s_epoch_%s.%s' % (job.id(), epoch, extension) return response
def models_show_json(job_id): job = scheduler.get_job(job_id) if job is None: abort(404) return jsonify({ 'id': job.id(), 'name': job.name(), 'status': job.status.name, 'snapshots': [s[1] for s in job.train_task().snapshots], })
def run_max_activations(): """ Run Gradient Ascent on a given layer and units """ job = scheduler.get_job(flask.request.args["job_id"]) args = flask.request.args layer_name = args["layer_name"] units = eval(args["units"]) username = utils.auth.get_username() gradient_ascent_job = create_max_activation_job(job, username, layer_name, units) return flask.jsonify({"stats": units, "job_id": gradient_ascent_job.id()})
def models_download(job_id, extension): """ Return a tarball of all files required to run the model """ job = scheduler.get_job(job_id) if job is None: raise werkzeug.exceptions.NotFound("Job not found") epoch = -1 # GET ?epoch=n if "epoch" in flask.request.args: epoch = float(flask.request.args["epoch"]) # POST ?snapshot_epoch=n (from form) elif "snapshot_epoch" in flask.request.form: epoch = float(flask.request.form["snapshot_epoch"]) task = job.train_task() snapshot_filename = None if epoch == -1 and len(task.snapshots): epoch = task.snapshots[-1][1] snapshot_filename = task.snapshots[-1][0] else: for f, e in task.snapshots: if e == epoch: snapshot_filename = f break if not snapshot_filename: raise werkzeug.exceptions.BadRequest("Invalid epoch") b = io.BytesIO() if extension in ["tar", "tar.gz", "tgz", "tar.bz2"]: # tar file mode = "" if extension in ["tar.gz", "tgz"]: mode = "gz" elif extension in ["tar.bz2"]: mode = "bz2" with tarfile.open(fileobj=b, mode="w:%s" % mode) as tf: for path, name in job.download_files(epoch): tf.add(path, arcname=name) elif extension in ["zip"]: with zipfile.ZipFile(b, "w") as zf: for path, name in job.download_files(epoch): zf.write(path, arcname=name) else: raise werkzeug.exceptions.BadRequest("Invalid extension") response = flask.make_response(b.getvalue()) response.headers["Content-Disposition"] = "attachment; filename=%s_epoch_%s.%s" % (job.id(), epoch, extension) return response
def image_classification_model_classify_one(): """ Classify one image and return the top 5 classifications Returns JSON when requested: {predictions: {category: confidence,...}} """ job = scheduler.get_job(flask.request.args['job_id']) if job is None: raise werkzeug.exceptions.NotFound('Job not found') image = None if 'image_url' in flask.request.form and flask.request.form['image_url']: image = utils.image.load_image(flask.request.form['image_url']) elif 'image_file' in flask.request.files and flask.request.files['image_file']: with tempfile.NamedTemporaryFile() as outfile: flask.request.files['image_file'].save(outfile.name) image = utils.image.load_image(outfile.name) else: raise werkzeug.exceptions.BadRequest('No image given') # resize image db_task = job.train_task().dataset.train_db_task() height = db_task.image_dims[0] width = db_task.image_dims[1] if job.train_task().crop_size: height = job.train_task().crop_size width = job.train_task().crop_size image = utils.image.resize_image(image, height, width, channels = db_task.image_dims[2], resize_mode = db_task.resize_mode, ) epoch = None if 'snapshot_epoch' in flask.request.form: epoch = float(flask.request.form['snapshot_epoch']) layers = 'none' if 'show_visualizations' in flask.request.form and flask.request.form['show_visualizations']: layers = 'all' predictions, visualizations = job.train_task().infer_one(image, snapshot_epoch=epoch, layers=layers) # take top 5 predictions = [(p[0], round(100.0*p[1],2)) for p in predictions[:5]] if request_wants_json(): return flask.jsonify({'predictions': predictions}) else: return flask.render_template('models/images/classification/classify_one.html', image_src = utils.image.embed_image_html(image), predictions = predictions, visualizations = visualizations, )
def models_show(job_id): """ Show a ModelJob """ job = scheduler.get_job(job_id) if job is None: abort(404) if isinstance(job, model_images.ImageClassificationModelJob): return model_images.classification.views.show(job) else: abort(404)
def image_classification_model_classify_one(): """ Classify one image and return the predictions, weights and activations """ job = scheduler.get_job(request.args['job_id']) if not job: abort(404) image = None if 'image_url' in request.form and request.form['image_url']: image = utils.image.load_image(request.form['image_url']) elif 'image_file' in request.files and request.files['image_file']: with tempfile.NamedTemporaryFile() as outfile: request.files['image_file'].save(outfile.name) image = utils.image.load_image(outfile.name) if image is None: return 'There was a problem with the image.', 400 # resize image db_task = job.train_task().dataset.train_db_task() height = db_task.image_dims[0] width = db_task.image_dims[1] if job.train_task().crop_size: height = job.train_task().crop_size width = job.train_task().crop_size image = utils.image.resize_image(image, height, width, channels = db_task.image_dims[2], resize_mode = db_task.resize_mode, ) epoch = None if 'snapshot_epoch' in request.form: epoch = float(request.form['snapshot_epoch']) predictions, visualizations = job.train_task().infer_one(image, snapshot_epoch=epoch, layers='all') # take top 5 predictions = [(p[0], round(100.0*p[1],2)) for p in predictions[:5]] # embed as html visualizations = [( v[0], utils.image.embed_image_html(v[1]), utils.image.embed_image_html(v[2]), ) for v in visualizations] return render_template('models/images/classification/classify_one.html', image_src = utils.image.embed_image_html(image), predictions = predictions, visualizations = visualizations, )
def display_images(job_id, key): # Display the Images job = scheduler.get_job(job_id) test_db_dir = job.path(job.test_db_task().db_name) env = lmdb.open(test_db_dir, readonly=True) #env = lmdb.open('/home/david/.digits/jobs/' + job_id + '/test_db', readonly=True) with env.begin() as txn: raw_datum = txn.get(str(key)) datum = caffe.proto.caffe_pb2.Datum() datum.ParseFromString(raw_datum) stream = StringIO.StringIO(datum.data) return send_file(stream, mimetype='image/png')
def create_pretrained_model(job_id,username,epoch): job = scheduler.get_job(job_id) if job is None: raise werkzeug.exceptions.NotFound('Job not found') # Write the stats of the job to json, # and store in tempfile (for archive) info = job.json_dict(verbose=False,epoch=epoch) task = job.train_task() snapshot_filename = None snapshot_filename = task.get_snapshot(epoch) # Set defaults: labels_path = None mean_path = None resize_mode = None if "labels file" in info: labels_path = os.path.join(task.dataset.dir(), info["labels file"]) if "mean file" in info: mean_path = os.path.join(task.dataset.dir(),info["mean file"]) if "image resize mode" in info: resize_mode = info["image resize mode"] model_file = os.path.join(job.dir(),str(task.model_file)) # If jobs don't container model_file (too old), raise exception: if not os.path.isfile(model_file): raise werkzeug.exceptions.BadRequest('Model file not found in job dir. Job may be too old for conversion.') job = PretrainedModelJob( snapshot_filename, model_file, labels_path, mean_path, info["framework"], info["image dimensions"][2], resize_mode, info["image dimensions"][0], info["image dimensions"][1], username = username, name = info["name"] ) scheduler.add_job(job) return job
def to_pretrained(job_id): job = scheduler.get_job(job_id) if job is None: raise werkzeug.exceptions.NotFound('Job not found') epoch = -1 # GET ?epoch=n if 'epoch' in flask.request.args: epoch = float(flask.request.args['epoch']) # POST ?snapshot_epoch=n (from form) elif 'snapshot_epoch' in flask.request.form: epoch = float(flask.request.form['snapshot_epoch']) # Write the stats of the job to json, # and store in tempfile (for archive) info = job.json_dict(verbose=False,epoch=epoch) task = job.train_task() snapshot_filename = None snapshot_filename = task.get_snapshot(epoch) # Set defaults: labels_path = None resize_mode = None if "labels file" in info: labels_path = os.path.join(task.dataset.dir(), info["labels file"]) if "image resize mode" in info: resize_mode = info["image resize mode"] job = PretrainedModelJob( snapshot_filename, os.path.join(job.dir(), task.model_file) , labels_path, info["framework"], info["image dimensions"][2], resize_mode, info["image dimensions"][0], info["image dimensions"][1], username = auth.get_username(), name = info["name"] ) scheduler.add_job(job) return flask.redirect(flask.url_for('digits.views.home',tab=3)), 302
def customize(): """ Returns a customized file for the ModelJob based on completed form fields """ network = flask.request.args['network'] framework = flask.request.args.get('framework') if not network: raise werkzeug.exceptions.BadRequest('network not provided') fw = frameworks.get_framework_by_id(framework) # can we find it in standard networks? network_desc = fw.get_standard_network_desc(network) if network_desc: return json.dumps({'network': network_desc}) # not found in standard networks, looking for matching job job = scheduler.get_job(network) if job is None: raise werkzeug.exceptions.NotFound('Job not found') snapshot = None epoch = float(flask.request.form.get('snapshot_epoch', 0)) if epoch == 0: pass elif epoch == -1: snapshot = job.train_task().pretrained_model else: for filename, e in job.train_task().snapshots: if e == epoch: snapshot = job.path(filename) break if isinstance(job, PretrainedModelJob): model_def = open(job.get_model_def_path(), 'r') network = model_def.read() snapshot = job.get_weights_path() python_layer = job.get_python_layer_path() else: network = job.train_task().get_network_desc() python_layer = None return json.dumps({ 'network': network, 'snapshot': snapshot, 'python_layer': python_layer })