python_code
stringlengths
0
679k
repo_name
stringlengths
9
41
file_path
stringlengths
6
149
# Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from .images import ( ImageClassificationModelJob, GenericImageModelJob, ImageModelJob, ) from .job import ModelJob __all__ = [ 'ImageClassificationModelJob', 'GenericImageModelJob', 'ImageModelJob', 'ModelJob', ]
DIGITS-master
digits/model/__init__.py
# Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. import os import flask from flask_wtf import Form import wtforms from wtforms import validators from digits.config import config_value from digits.device_query import get_device, get_nvml_info from digits import utils from digits.utils import sizeof_fmt from digits.utils.forms import validate_required_iff from digits import frameworks class ModelForm(Form): # Methods def selection_exists_in_choices(form, field): found = False for choice in field.choices: if choice[0] == field.data: found = True if not found: raise validators.ValidationError("Selected job doesn't exist. Maybe it was deleted by another user.") def validate_NetParameter(form, field): fw = frameworks.get_framework_by_id(form['framework'].data) try: # below function raises a BadNetworkException in case of validation error fw.validate_network(field.data) except frameworks.errors.BadNetworkError as e: raise validators.ValidationError('Bad network: %s' % e.message) def validate_file_exists(form, field): from_client = bool(form.python_layer_from_client.data) filename = '' if not from_client and field.type == 'StringField': filename = field.data if filename == '': return if not os.path.isfile(filename): raise validators.ValidationError('Server side file, %s, does not exist.' % filename) def validate_py_ext(form, field): from_client = bool(form.python_layer_from_client.data) filename = '' if from_client and field.type == 'FileField': filename = flask.request.files[field.name].filename elif not from_client and field.type == 'StringField': filename = field.data if filename == '': return (root, ext) = os.path.splitext(filename) if ext != '.py' and ext != '.pyc': raise validators.ValidationError('Python file, %s, needs .py or .pyc extension.' % filename) # Fields # The options for this get set in the view (since they are dynamic) dataset = utils.forms.SelectField( 'Select Dataset', choices=[], tooltip="Choose the dataset to use for this model." ) python_layer_from_client = utils.forms.BooleanField( u'Use client-side file', default=False, ) python_layer_client_file = utils.forms.FileField( u'Client-side file', validators=[ validate_py_ext ], tooltip="Choose a Python file on the client containing layer definitions." ) python_layer_server_file = utils.forms.StringField( u'Server-side file', validators=[ validate_file_exists, validate_py_ext ], tooltip="Choose a Python file on the server containing layer definitions." ) train_epochs = utils.forms.IntegerField( 'Training epochs', validators=[ validators.NumberRange(min=1) ], default=30, tooltip="How many passes through the training data?" ) snapshot_interval = utils.forms.FloatField( 'Snapshot interval (in epochs)', default=1, validators=[ validators.NumberRange(min=0), ], tooltip="How many epochs of training between taking a snapshot?" ) val_interval = utils.forms.FloatField( 'Validation interval (in epochs)', default=1, validators=[ validators.NumberRange(min=0) ], tooltip="How many epochs of training between running through one pass of the validation data?" ) traces_interval = utils.forms.IntegerField( 'Tracing Interval (in steps)', validators=[ validators.NumberRange(min=0) ], default=0, tooltip="Generation of a timeline trace every few steps" ) random_seed = utils.forms.IntegerField( 'Random seed', validators=[ validators.NumberRange(min=0), validators.Optional(), ], tooltip=('If you provide a random seed, then back-to-back runs with ' 'the same model and dataset should give identical results.') ) batch_size = utils.forms.MultiIntegerField( 'Batch size', validators=[ utils.forms.MultiNumberRange(min=1), utils.forms.MultiOptional(), ], tooltip="How many images to process at once. If blank, values are used from the network definition." ) batch_accumulation = utils.forms.IntegerField( 'Batch Accumulation', validators=[ validators.NumberRange(min=1), validators.Optional(), ], tooltip=("Accumulate gradients over multiple batches (useful when you " "need a bigger batch size for training but it doesn't fit in memory).") ) # Solver types solver_type = utils.forms.SelectField( 'Solver type', choices=[ ('SGD', 'SGD (Stochastic Gradient Descent)'), ('MOMENTUM', 'Momentum'), ('NESTEROV', "NAG (Nesterov's accelerated gradient)"), ('ADAGRAD', 'AdaGrad (Adaptive Gradient)'), ('ADAGRADDA', 'AdaGradDA (AdaGrad Dual Averaging)'), ('ADADELTA', 'AdaDelta'), ('ADAM', 'Adam (Adaptive Moment Estimation)'), ('RMSPROP', 'RMSprop'), ('FTRL', 'FTRL (Follow-The-Regularized-Leader)'), ], default='SGD', tooltip="What type of solver will be used?", ) def validate_solver_type(form, field): fw = frameworks.get_framework_by_id(form.framework) if fw is not None: if not fw.supports_solver_type(field.data): raise validators.ValidationError( 'Solver type not supported by this framework') # Additional settings specific to selected solver rms_decay = utils.forms.FloatField( 'RMS decay value', default=0.99, validators=[ validators.NumberRange(min=0), ], tooltip=("If the gradient updates results in oscillations the gradient is reduced " "by times 1-rms_decay. Otherwise it will be increased by rms_decay.") ) # Learning rate learning_rate = utils.forms.MultiFloatField( 'Base Learning Rate', default=0.01, validators=[ utils.forms.MultiNumberRange(min=0), ], tooltip=("Affects how quickly the network learns. If you are getting " "NaN for your loss, you probably need to lower this value.") ) lr_policy = wtforms.SelectField( 'Policy', choices=[ ('fixed', 'Fixed'), ('step', 'Step Down'), ('multistep', 'Step Down (arbitrary steps)'), ('exp', 'Exponential Decay'), ('inv', 'Inverse Decay'), ('poly', 'Polynomial Decay'), ('sigmoid', 'Sigmoid Decay'), ], default='step' ) lr_step_size = wtforms.FloatField('Step Size', default=33) lr_step_gamma = wtforms.FloatField('Gamma', default=0.1) lr_multistep_values = wtforms.StringField('Step Values', default="50,85") def validate_lr_multistep_values(form, field): if form.lr_policy.data == 'multistep': for value in field.data.split(','): try: float(value) except ValueError: raise validators.ValidationError('invalid value') lr_multistep_gamma = wtforms.FloatField('Gamma', default=0.5) lr_exp_gamma = wtforms.FloatField('Gamma', default=0.95) lr_inv_gamma = wtforms.FloatField('Gamma', default=0.1) lr_inv_power = wtforms.FloatField('Power', default=0.5) lr_poly_power = wtforms.FloatField('Power', default=3) lr_sigmoid_step = wtforms.FloatField('Step', default=50) lr_sigmoid_gamma = wtforms.FloatField('Gamma', default=0.1) # Network # Use a SelectField instead of a HiddenField so that the default value # is used when nothing is provided (through the REST API) method = wtforms.SelectField( u'Network type', choices=[ ('standard', 'Standard network'), ('previous', 'Previous network'), ('pretrained', 'Pretrained network'), ('custom', 'Custom network'), ], default='standard', ) # framework - hidden field, set by Javascript to the selected framework ID framework = wtforms.HiddenField( 'framework', validators=[ validators.AnyOf( [fw.get_id() for fw in frameworks.get_frameworks()], message='The framework you choose is not currently supported.' ) ], default=frameworks.get_frameworks()[0].get_id() ) # The options for this get set in the view (since they are dependent on the data type) standard_networks = wtforms.RadioField( 'Standard Networks', validators=[ validate_required_iff(method='standard'), ], ) previous_networks = wtforms.RadioField( 'Previous Networks', choices=[], validators=[ validate_required_iff(method='previous'), selection_exists_in_choices, ], ) pretrained_networks = wtforms.RadioField( 'Pretrained Networks', choices=[], validators=[ validate_required_iff(method='pretrained'), selection_exists_in_choices, ], ) custom_network = utils.forms.TextAreaField( 'Custom Network', validators=[ validate_required_iff(method='custom'), validate_NetParameter, ], ) custom_network_snapshot = utils.forms.TextField( 'Pretrained model(s)', tooltip=("Paths to pretrained model files, separated by '%s'. " "Only edit this field if you understand how fine-tuning " "works in caffe or torch." % os.path.pathsep) ) def validate_custom_network_snapshot(form, field): pass # if form.method.data == 'custom': # for filename in field.data.strip().split(os.path.pathsep): # if filename and not os.path.lexists(filename): # raise validators.ValidationError('File "%s" does not exist' % filename) # Select one of several GPUs select_gpu = wtforms.RadioField( 'Select which GPU you would like to use', choices=[('next', 'Next available')] + [( index, '#%s - %s (%s memory)' % ( index, get_device(index).name, sizeof_fmt( get_nvml_info(index)['memory']['total'] if get_nvml_info(index) and 'memory' in get_nvml_info(index) else get_device(index).totalGlobalMem) ), ) for index in config_value('gpu_list').split(',') if index], default='next', ) # Select N of several GPUs select_gpus = utils.forms.SelectMultipleField( 'Select which GPU[s] you would like to use', choices=[( index, '#%s - %s (%s memory)' % ( index, get_device(index).name, sizeof_fmt( get_nvml_info(index)['memory']['total'] if get_nvml_info(index) and 'memory' in get_nvml_info(index) else get_device(index).totalGlobalMem) ), ) for index in config_value('gpu_list').split(',') if index], tooltip="The job won't start until all of the chosen GPUs are available." ) # XXX For testing # The Flask test framework can't handle SelectMultipleFields correctly select_gpus_list = wtforms.StringField('Select which GPU[s] you would like to use (comma separated)') def validate_select_gpus(form, field): if form.select_gpus_list.data: field.data = form.select_gpus_list.data.split(',') # Use next available N GPUs select_gpu_count = wtforms.IntegerField('Use this many GPUs (next available)', validators=[ validators.NumberRange(min=1, max=len( config_value('gpu_list').split(','))) ], default=1, ) def validate_select_gpu_count(form, field): if field.data is None: if form.select_gpus.data: # Make this field optional field.errors[:] = [] raise validators.StopValidation() model_name = utils.forms.StringField('Model Name', validators=[ validators.DataRequired() ], tooltip="An identifier, later used to refer to this model in the Application." ) group_name = utils.forms.StringField('Group Name', tooltip="An optional group name for organization on the main page." ) # allows shuffling data during training (for frameworks that support this, as indicated by # their Framework.can_shuffle_data() method) shuffle = utils.forms.BooleanField('Shuffle Train Data', default=True, tooltip='For every epoch, shuffle the data before training.' )
DIGITS-master
digits/model/forms.py
# Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import import io import json import math import os import tarfile import zipfile import flask from flask import flash import requests import werkzeug.exceptions from . import images as model_images from . import ModelJob from digits.pretrained_model.job import PretrainedModelJob from digits import frameworks, extensions from digits.utils import auth from digits.utils.routing import request_wants_json, job_from_request, get_request_arg from digits.webapp import scheduler blueprint = flask.Blueprint(__name__, __name__) @blueprint.route('/<job_id>/json', methods=['GET']) @blueprint.route('/<job_id>', methods=['GET']) def show(job_id): """ Show a ModelJob Returns JSON when requested: {id, name, directory, status, snapshots: [epoch,epoch,...]} """ 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, model_images.ImageClassificationModelJob): return model_images.classification.views.show(job, related_jobs=related_jobs) elif isinstance(job, model_images.GenericImageModelJob): return model_images.generic.views.show(job, related_jobs=related_jobs) else: raise werkzeug.exceptions.BadRequest( 'Invalid job type') @blueprint.route('/customize', methods=['POST']) 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 }) @blueprint.route('/timeline_trace_data', methods=['POST']) def timeline_trace_data(): """ Shows timeline trace of a model """ job = job_from_request() step = get_request_arg('step') if step is None: raise werkzeug.exceptions.BadRequest('step is a required field') return job.train_task().timeline_trace(int(step)) @blueprint.route('/view-config/<extension_id>', methods=['GET']) def view_config(extension_id): """ Returns a rendering of a view extension configuration template """ extension = extensions.view.get_extension(extension_id) if extension is None: raise ValueError("Unknown extension '%s'" % extension_id) config_form = extension.get_config_form() template, context = extension.get_config_template(config_form) return flask.render_template_string(template, **context) @blueprint.route('/visualize-network', methods=['POST']) 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 @blueprint.route('/visualize-lr', methods=['POST']) def visualize_lr(): """ Returns a JSON object of data used to create the learning rate graph """ policy = flask.request.form['lr_policy'] # There may be multiple lrs if the learning_rate is swept lrs = map(float, flask.request.form['learning_rate'].split(',')) if policy == 'fixed': pass elif policy == 'step': step = float(flask.request.form['lr_step_size']) gamma = float(flask.request.form['lr_step_gamma']) elif policy == 'multistep': steps = [float(s) for s in flask.request.form['lr_multistep_values'].split(',')] current_step = 0 gamma = float(flask.request.form['lr_multistep_gamma']) elif policy == 'exp': gamma = float(flask.request.form['lr_exp_gamma']) elif policy == 'inv': gamma = float(flask.request.form['lr_inv_gamma']) power = float(flask.request.form['lr_inv_power']) elif policy == 'poly': power = float(flask.request.form['lr_poly_power']) elif policy == 'sigmoid': step = float(flask.request.form['lr_sigmoid_step']) gamma = float(flask.request.form['lr_sigmoid_gamma']) else: raise werkzeug.exceptions.BadRequest('Invalid policy') datalist = [] for j, lr in enumerate(lrs): data = ['Learning Rate %d' % j] for i in xrange(101): if policy == 'fixed': data.append(lr) elif policy == 'step': data.append(lr * math.pow(gamma, math.floor(float(i) / step))) elif policy == 'multistep': if current_step < len(steps) and i >= steps[current_step]: current_step += 1 data.append(lr * math.pow(gamma, current_step)) elif policy == 'exp': data.append(lr * math.pow(gamma, i)) elif policy == 'inv': data.append(lr * math.pow(1.0 + gamma * i, -power)) elif policy == 'poly': data.append(lr * math.pow(1.0 - float(i) / 100, power)) elif policy == 'sigmoid': data.append(lr / (1.0 + math.exp(gamma * (i - step)))) datalist.append(data) return json.dumps({'data': {'columns': datalist}}) @auth.requires_login @blueprint.route('/<job_id>/to_pretrained', methods=['GET', 'POST']) 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 @blueprint.route('/<job_id>/publish_inference', methods=['POST']) def publish_inference(job_id): """ Publish model to inference server """ rie_url = os.environ.get('RIE_URL', "http://localhost:5055") publish_endpoint = rie_url+'/models' # Get data from the modal form description = flask.request.form.get('description') modality = flask.request.form.getlist('modality') output_layer = flask.request.form.get('output_layer') input_layer = flask.request.form.get('input_layer') input_shape = flask.request.form.get('input_shape') output_shape = flask.request.form.get('output_shape') 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) job_dict = job.json_dict(verbose=False, epoch=epoch) job_dict.update({"output_layer": output_layer, "description": description, "input_layer": input_layer, "input_shape": input_shape, "output_shape": output_shape, "modality": modality}) info = json.dumps(job_dict, sort_keys=True, indent=4, separators=(',', ': ')) info_io = io.BytesIO() info_io.write(info) b = io.BytesIO() mode = '' with tarfile.open(fileobj=b, mode='w:%s' % mode) as tar: for path, name in job.download_files(epoch, frozen_file=(job_dict['framework'] == 'tensorflow')): tar.add(path, arcname=name) tar_info = tarfile.TarInfo("info.json") tar_info.size = len(info_io.getvalue()) info_io.seek(0) tar.addfile(tar_info, info_io) temp_buffer = b.getvalue() files = {'model': ('tmp.tgz', temp_buffer)} try: r = requests.post(publish_endpoint, files=files) except Exception as e: return flask.make_response(e) if r.status_code != requests.codes.ok: raise werkzeug.exceptions.BadRequest("Bad Request") end_point = json.loads(r.text)["location"] flash('Model successfully published to RIE.<p>New endpoint at {}'.format(end_point)) return flask.redirect(flask.request.referrer), 302 @blueprint.route('/<job_id>/download', methods=['GET', 'POST'], defaults={'extension': 'tar.gz'}) @blueprint.route('/<job_id>/download.<extension>', methods=['GET', 'POST']) 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) 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 tar: for path, name in job.download_files(epoch): tar.add(path, arcname=name) tar_info = tarfile.TarInfo("info.json") tar_info.size = len(info_io.getvalue()) info_io.seek(0) tar.addfile(tar_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 class JobBasicInfo(object): def __init__(self, name, ID, status, time, framework_id): self.name = name self.id = ID self.status = status self.time = time self.framework_id = framework_id class ColumnType(object): def __init__(self, name, has_suffix, find_fn): self.name = name self.has_suffix = has_suffix self.find_from_list = find_fn def label(self, attr): if self.has_suffix: return '{} {}'.format(attr, self.name) else: return attr def get_column_attrs(): job_outs = [set(j.train_task().train_outputs.keys() + j.train_task().val_outputs.keys()) for j in scheduler.jobs.values() if isinstance(j, ModelJob)] return reduce(lambda acc, j: acc.union(j), job_outs, set())
DIGITS-master
digits/model/views.py
# Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from digits import test_utils def test_caffe_imports(): test_utils.skipIfNotFramework('caffe') import numpy # noqa import google.protobuf # noqa
DIGITS-master
digits/model/tasks/test_caffe_train.py
# Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from collections import OrderedDict import copy import math import operator import os import re import sys import time from google.protobuf import text_format import numpy as np import platform import scipy from .train import TrainTask import digits from digits import utils from digits.config import config_value from digits.status import Status from digits.utils import subclass, override, constants from digits.utils.filesystem import tail # Must import after importing digit.config import caffe import caffe_pb2 # NOTE: Increment this every time the pickled object changes PICKLE_VERSION = 5 # Constants CAFFE_SOLVER_FILE = 'solver.prototxt' CAFFE_ORIGINAL_FILE = 'original.prototxt' CAFFE_TRAIN_VAL_FILE = 'train_val.prototxt' CAFFE_SNAPSHOT_PREFIX = 'snapshot' CAFFE_DEPLOY_FILE = 'deploy.prototxt' CAFFE_PYTHON_LAYER_FILE = 'digits_python_layers.py' @subclass class DigitsTransformer(caffe.io.Transformer): """ A subclass of caffe.io.Transformer (an old-style class) Handles cases when we don't want to resize inputs """ def __init__(self, resize, **kwargs): """ Arguments: resize -- whether to resize inputs to the network default """ self.resize = resize caffe.io.Transformer.__init__(self, **kwargs) def preprocess(self, in_, data): """ Preprocess an image See parent class for details """ if not self.resize: # update target input dimension such that no resize occurs self.inputs[in_] = self.inputs[in_][:2] + data.shape[:2] # do we have a mean? if in_ in self.mean: # resize mean if necessary if self.mean[in_].size > 1: # we are doing mean image subtraction if self.mean[in_].size != data.size: # mean image size is different from data size # => we need to resize the mean image transpose = self.transpose.get(in_) if transpose is not None: # detranspose self.mean[in_] = self.mean[in_].transpose( np.argsort(transpose)) self.mean[in_] = caffe.io.resize_image( self.mean[in_], data.shape[:2]) if transpose is not None: # retranspose self.mean[in_] = self.mean[in_].transpose(transpose) return caffe.io.Transformer.preprocess(self, in_, data) @subclass class Error(Exception): pass @subclass class CaffeTrainSanityCheckError(Error): """A sanity check failed""" pass @subclass class CaffeTrainTask(TrainTask): """ Trains a caffe model """ CAFFE_LOG = 'caffe_output.log' @staticmethod def upgrade_network(network): # TODO pass @staticmethod def set_mode(gpu): if gpu is not None: caffe.set_device(gpu) caffe.set_mode_gpu() else: caffe.set_mode_cpu() def __init__(self, **kwargs): """ Arguments: network -- a caffe NetParameter defining the network """ super(CaffeTrainTask, self).__init__(**kwargs) self.pickver_task_caffe_train = PICKLE_VERSION self.current_iteration = 0 self.loaded_snapshot_file = None self.loaded_snapshot_epoch = None self.image_mean = None self.solver = None self.solver_file = CAFFE_SOLVER_FILE self.model_file = CAFFE_ORIGINAL_FILE self.train_val_file = CAFFE_TRAIN_VAL_FILE self.snapshot_prefix = CAFFE_SNAPSHOT_PREFIX self.deploy_file = CAFFE_DEPLOY_FILE self.log_file = self.CAFFE_LOG self.digits_version = digits.__version__ self.caffe_version = config_value('caffe')['version'] self.caffe_flavor = config_value('caffe')['flavor'] def __getstate__(self): state = super(CaffeTrainTask, self).__getstate__() # Don't pickle these things if 'caffe_log' in state: del state['caffe_log'] if '_transformer' in state: del state['_transformer'] if '_caffe_net' in state: del state['_caffe_net'] return state def __setstate__(self, state): super(CaffeTrainTask, self).__setstate__(state) # Upgrade pickle file if state['pickver_task_caffe_train'] <= 1: self.caffe_log_file = self.CAFFE_LOG if state['pickver_task_caffe_train'] <= 2: if hasattr(self, 'caffe_log_file'): self.log_file = self.caffe_log_file else: self.log_file = None self.framework_id = 'caffe' if state['pickver_task_caffe_train'] <= 3: try: import caffe.proto.caffe_pb2 if isinstance(self.network, caffe.proto.caffe_pb2.NetParameter): # Convert from NetParameter to string back to NetParameter # to avoid this error: # TypeError: Parameter to MergeFrom() must be instance of # same class: expected caffe_pb2.NetParameter got # caffe.proto.caffe_pb2.NetParameter. fixed = caffe_pb2.NetParameter() text_format.Merge( text_format.MessageToString(self.network), fixed, ) self.network = fixed except ImportError: # If caffe.proto.caffe_pb2 can't be imported, then you're # probably on a platform where that was never possible. # So you can't need this upgrade and we can ignore the error. pass if state['pickver_task_caffe_train'] <= 4: if hasattr(self, "original_file"): self.model_file = self.original_file del self.original_file else: self.model_file = None self.pickver_task_caffe_train = PICKLE_VERSION # Make changes to self self.loaded_snapshot_file = None self.loaded_snapshot_epoch = None # These things don't get pickled self.image_mean = None # Task overrides @override def name(self): return 'Train Caffe Model' @override def before_run(self): super(CaffeTrainTask, self).before_run() if isinstance(self.job, digits.model.images.classification.ImageClassificationModelJob): self.save_files_classification() elif isinstance(self.job, digits.model.images.generic.GenericImageModelJob): self.save_files_generic() else: raise NotImplementedError self.caffe_log = open(self.path(self.CAFFE_LOG), 'a') self.saving_snapshot = False self.receiving_train_output = False self.receiving_val_output = False self.last_train_update = None return True def get_mean_image(self, mean_file, resize=False): mean_image = None with open(self.dataset.path(mean_file), 'rb') as f: blob = caffe_pb2.BlobProto() blob.MergeFromString(f.read()) mean_image = np.reshape(blob.data, ( self.dataset.get_feature_dims()[2], self.dataset.get_feature_dims()[0], self.dataset.get_feature_dims()[1], ) ) # Resize the mean image if crop_size exists if mean_image is not None and resize: # Get the image size needed network = caffe_pb2.NetParameter() with open(self.path(self.deploy_file)) as infile: text_format.Merge(infile.read(), network) if network.input_shape: data_shape = network.input_shape[0].dim else: data_shape = network.input_dim[:4] assert len(data_shape) == 4, 'Bad data shape.' # Get the image mean_image = mean_image.astype('uint8') mean_image = mean_image.transpose(1, 2, 0) shape = list(mean_image.shape) # imresize will not resize if the depth is anything # other than 3 or 4. If it's 1, imresize expects an # array. if (len(shape) == 2 or (len(shape) == 3 and (shape[2] == 3 or shape[2] == 4))): mean_image = scipy.misc.imresize(mean_image, (data_shape[2], data_shape[3])) else: mean_image = scipy.misc.imresize(mean_image[:, :, 0], (data_shape[2], data_shape[3])) mean_image = np.expand_dims(mean_image, axis=2) mean_image = mean_image.transpose(2, 0, 1) mean_image = mean_image.astype('float') return mean_image def get_mean_pixel(self, mean_file): mean_image = self.get_mean_image(mean_file) mean_pixel = None if mean_image is not None: mean_pixel = mean_image.mean(1).mean(1) return mean_pixel def set_mean_value(self, layer, mean_pixel): # remove any values that may already be in the network if layer.transform_param.HasField('mean_file'): layer.transform_param.ClearField('mean_file') self.logger.warning('Ignoring mean_file from network ...') if len(layer.transform_param.mean_value) > 0: layer.transform_param.ClearField('mean_value') self.logger.warning('Ignoring mean_value from network ...') layer.transform_param.mean_value.extend(list(mean_pixel)) def set_mean_file(self, layer, mean_file): # remove any values that may already be in the network if layer.transform_param.HasField('mean_file'): layer.transform_param.ClearField('mean_file') self.logger.warning('Ignoring mean_file from network ...') if len(layer.transform_param.mean_value) > 0: layer.transform_param.ClearField('mean_value') self.logger.warning('Ignoring mean_value from network ...') layer.transform_param.mean_file = mean_file # TODO merge these monolithic save_files functions def save_files_classification(self): """ Save solver, train_val and deploy files to disk """ # Save the origin network to file: with open(self.path(self.model_file), 'w') as outfile: text_format.PrintMessage(self.network, outfile) network = cleanedUpClassificationNetwork(self.network, len(self.get_labels())) data_layers, train_val_layers, deploy_layers = filterLayersByState(network) # Write train_val file train_val_network = caffe_pb2.NetParameter() # Data layers # TODO clean this up train_data_layer = None val_data_layer = None for layer in data_layers.layer: for rule in layer.include: if rule.phase == caffe_pb2.TRAIN: assert train_data_layer is None, 'cannot specify two train data layers' train_data_layer = layer elif rule.phase == caffe_pb2.TEST: assert val_data_layer is None, 'cannot specify two test data layers' val_data_layer = layer if train_data_layer is None: assert val_data_layer is None, 'cannot specify a test data layer without a train data layer' dataset_backend = self.dataset.get_backend() has_val_set = self.dataset.get_entry_count(constants.VAL_DB) > 0 if train_data_layer is not None: if dataset_backend == 'lmdb': assert train_data_layer.type == 'Data', 'expecting a Data layer' elif dataset_backend == 'hdf5': assert train_data_layer.type == 'HDF5Data', 'expecting an HDF5Data layer' if dataset_backend == 'lmdb' and train_data_layer.HasField('data_param'): assert not train_data_layer.data_param.HasField('source'), "don't set the data_param.source" assert not train_data_layer.data_param.HasField('backend'), "don't set the data_param.backend" if dataset_backend == 'hdf5' and train_data_layer.HasField('hdf5_data_param'): assert not train_data_layer.hdf5_data_param.HasField('source'), "don't set the hdf5_data_param.source" max_crop_size = min(self.dataset.get_feature_dims()[0], self.dataset.get_feature_dims()[1]) if self.crop_size: assert dataset_backend != 'hdf5', 'HDF5Data layer does not support cropping' assert self.crop_size <= max_crop_size, 'crop_size is larger than the image size' train_data_layer.transform_param.crop_size = self.crop_size elif train_data_layer.transform_param.HasField('crop_size'): cs = train_data_layer.transform_param.crop_size if cs > max_crop_size: # don't throw an error here cs = max_crop_size train_data_layer.transform_param.crop_size = cs self.crop_size = cs train_val_network.layer.add().CopyFrom(train_data_layer) train_data_layer = train_val_network.layer[-1] if val_data_layer is not None and has_val_set: if dataset_backend == 'lmdb': assert val_data_layer.type == 'Data', 'expecting a Data layer' elif dataset_backend == 'hdf5': assert val_data_layer.type == 'HDF5Data', 'expecting an HDF5Data layer' if dataset_backend == 'lmdb' and val_data_layer.HasField('data_param'): assert not val_data_layer.data_param.HasField('source'), "don't set the data_param.source" assert not val_data_layer.data_param.HasField('backend'), "don't set the data_param.backend" if dataset_backend == 'hdf5' and val_data_layer.HasField('hdf5_data_param'): assert not val_data_layer.hdf5_data_param.HasField('source'), "don't set the hdf5_data_param.source" if self.crop_size: # use our error checking from the train layer val_data_layer.transform_param.crop_size = self.crop_size train_val_network.layer.add().CopyFrom(val_data_layer) val_data_layer = train_val_network.layer[-1] else: layer_type = 'Data' if dataset_backend == 'hdf5': layer_type = 'HDF5Data' train_data_layer = train_val_network.layer.add(type=layer_type, name='data') train_data_layer.top.append('data') train_data_layer.top.append('label') train_data_layer.include.add(phase=caffe_pb2.TRAIN) if dataset_backend == 'lmdb': train_data_layer.data_param.batch_size = constants.DEFAULT_BATCH_SIZE elif dataset_backend == 'hdf5': train_data_layer.hdf5_data_param.batch_size = constants.DEFAULT_BATCH_SIZE if self.crop_size: assert dataset_backend != 'hdf5', 'HDF5Data layer does not support cropping' train_data_layer.transform_param.crop_size = self.crop_size if has_val_set: val_data_layer = train_val_network.layer.add(type=layer_type, name='data') val_data_layer.top.append('data') val_data_layer.top.append('label') val_data_layer.include.add(phase=caffe_pb2.TEST) if dataset_backend == 'lmdb': val_data_layer.data_param.batch_size = constants.DEFAULT_BATCH_SIZE elif dataset_backend == 'hdf5': val_data_layer.hdf5_data_param.batch_size = constants.DEFAULT_BATCH_SIZE if self.crop_size: val_data_layer.transform_param.crop_size = self.crop_size if dataset_backend == 'lmdb': train_data_layer.data_param.source = self.dataset.get_feature_db_path(constants.TRAIN_DB) train_data_layer.data_param.backend = caffe_pb2.DataParameter.LMDB if val_data_layer is not None and has_val_set: val_data_layer.data_param.source = self.dataset.get_feature_db_path(constants.VAL_DB) val_data_layer.data_param.backend = caffe_pb2.DataParameter.LMDB elif dataset_backend == 'hdf5': train_data_layer.hdf5_data_param.source = os.path.join( self.dataset.get_feature_db_path(constants.TRAIN_DB), 'list.txt') if val_data_layer is not None and has_val_set: val_data_layer.hdf5_data_param.source = os.path.join( self.dataset.get_feature_db_path(constants.VAL_DB), 'list.txt') if self.use_mean == 'pixel': assert dataset_backend != 'hdf5', 'HDF5Data layer does not support mean subtraction' mean_pixel = self.get_mean_pixel(self.dataset.path(self.dataset.get_mean_file())) self.set_mean_value(train_data_layer, mean_pixel) if val_data_layer is not None and has_val_set: self.set_mean_value(val_data_layer, mean_pixel) elif self.use_mean == 'image': self.set_mean_file(train_data_layer, self.dataset.path(self.dataset.get_mean_file())) if val_data_layer is not None and has_val_set: self.set_mean_file(val_data_layer, self.dataset.path(self.dataset.get_mean_file())) if self.batch_size: if dataset_backend == 'lmdb': train_data_layer.data_param.batch_size = self.batch_size if val_data_layer is not None and has_val_set: val_data_layer.data_param.batch_size = self.batch_size elif dataset_backend == 'hdf5': train_data_layer.hdf5_data_param.batch_size = self.batch_size if val_data_layer is not None and has_val_set: val_data_layer.hdf5_data_param.batch_size = self.batch_size else: if dataset_backend == 'lmdb': if not train_data_layer.data_param.HasField('batch_size'): train_data_layer.data_param.batch_size = constants.DEFAULT_BATCH_SIZE if val_data_layer is not None and has_val_set and not val_data_layer.data_param.HasField('batch_size'): val_data_layer.data_param.batch_size = constants.DEFAULT_BATCH_SIZE elif dataset_backend == 'hdf5': if not train_data_layer.hdf5_data_param.HasField('batch_size'): train_data_layer.hdf5_data_param.batch_size = constants.DEFAULT_BATCH_SIZE if (val_data_layer is not None and has_val_set and not val_data_layer.hdf5_data_param.HasField('batch_size')): val_data_layer.hdf5_data_param.batch_size = constants.DEFAULT_BATCH_SIZE # Non-data layers train_val_network.MergeFrom(train_val_layers) # Write to file with open(self.path(self.train_val_file), 'w') as outfile: text_format.PrintMessage(train_val_network, outfile) # network sanity checks self.logger.debug("Network sanity check - train") CaffeTrainTask.net_sanity_check(train_val_network, caffe_pb2.TRAIN) if has_val_set: self.logger.debug("Network sanity check - val") CaffeTrainTask.net_sanity_check(train_val_network, caffe_pb2.TEST) # Write deploy file deploy_network = caffe_pb2.NetParameter() # Input deploy_network.input.append('data') shape = deploy_network.input_shape.add() shape.dim.append(1) shape.dim.append(self.dataset.get_feature_dims()[2]) if self.crop_size: shape.dim.append(self.crop_size) shape.dim.append(self.crop_size) else: shape.dim.append(self.dataset.get_feature_dims()[0]) shape.dim.append(self.dataset.get_feature_dims()[1]) # Layers deploy_network.MergeFrom(deploy_layers) # Write to file with open(self.path(self.deploy_file), 'w') as outfile: text_format.PrintMessage(deploy_network, outfile) # network sanity checks self.logger.debug("Network sanity check - deploy") CaffeTrainTask.net_sanity_check(deploy_network, caffe_pb2.TEST) found_softmax = False for layer in deploy_network.layer: if layer.type == 'Softmax': found_softmax = True break assert found_softmax, \ ('Your deploy network is missing a Softmax layer! ' 'Read the documentation for custom networks and/or look at the standard networks for examples.') # Write solver file solver = caffe_pb2.SolverParameter() # get enum value for solver type solver.solver_type = getattr(solver, self.solver_type) solver.net = self.train_val_file # Set CPU/GPU mode if config_value('caffe')['cuda_enabled'] and \ bool(config_value('gpu_list')): solver.solver_mode = caffe_pb2.SolverParameter.GPU else: solver.solver_mode = caffe_pb2.SolverParameter.CPU solver.snapshot_prefix = self.snapshot_prefix # Batch accumulation from digits.frameworks import CaffeFramework if self.batch_accumulation and CaffeFramework().can_accumulate_gradients(): solver.iter_size = self.batch_accumulation # Epochs -> Iterations train_iter = int(math.ceil( float(self.dataset.get_entry_count(constants.TRAIN_DB)) / (train_data_layer.data_param.batch_size * solver.iter_size) )) solver.max_iter = train_iter * self.train_epochs snapshot_interval = self.snapshot_interval * train_iter if 0 < snapshot_interval <= 1: solver.snapshot = 1 # don't round down elif 1 < snapshot_interval < solver.max_iter: solver.snapshot = int(snapshot_interval) else: solver.snapshot = 0 # only take one snapshot at the end if has_val_set and self.val_interval: solver.test_iter.append( int(math.ceil(float(self.dataset.get_entry_count(constants.VAL_DB)) / val_data_layer.data_param.batch_size))) val_interval = self.val_interval * train_iter if 0 < val_interval <= 1: solver.test_interval = 1 # don't round down elif 1 < val_interval < solver.max_iter: solver.test_interval = int(val_interval) else: solver.test_interval = solver.max_iter # only test once at the end # Learning rate solver.base_lr = self.learning_rate solver.lr_policy = self.lr_policy['policy'] scale = float(solver.max_iter) / 100.0 if solver.lr_policy == 'fixed': pass elif solver.lr_policy == 'step': # stepsize = stepsize * scale solver.stepsize = int(math.ceil(float(self.lr_policy['stepsize']) * scale)) solver.gamma = self.lr_policy['gamma'] elif solver.lr_policy == 'multistep': for value in self.lr_policy['stepvalue'].split(','): # stepvalue = stepvalue * scale solver.stepvalue.append(int(math.ceil(float(value) * scale))) solver.gamma = self.lr_policy['gamma'] elif solver.lr_policy == 'exp': # gamma = gamma^(1/scale) solver.gamma = math.pow(self.lr_policy['gamma'], 1.0 / scale) elif solver.lr_policy == 'inv': # gamma = gamma / scale solver.gamma = self.lr_policy['gamma'] / scale solver.power = self.lr_policy['power'] elif solver.lr_policy == 'poly': solver.power = self.lr_policy['power'] elif solver.lr_policy == 'sigmoid': # gamma = -gamma / scale solver.gamma = -1.0 * self.lr_policy['gamma'] / scale # stepsize = stepsize * scale solver.stepsize = int(math.ceil(float(self.lr_policy['stepsize']) * scale)) else: raise Exception('Unknown lr_policy: "%s"' % solver.lr_policy) # These solver types don't support momentum unsupported = [solver.ADAGRAD] try: unsupported.append(solver.RMSPROP) except AttributeError: pass if solver.solver_type not in unsupported: solver.momentum = 0.9 solver.weight_decay = solver.base_lr / 100.0 # solver specific values if solver.solver_type == solver.RMSPROP: solver.rms_decay = self.rms_decay # Display 8x per epoch, or once per 5000 images, whichever is more frequent solver.display = max(1, min( int(math.floor(float(solver.max_iter) / (self.train_epochs * 8))), int(math.ceil(5000.0 / (train_data_layer.data_param.batch_size * solver.iter_size))) )) if self.random_seed is not None: solver.random_seed = self.random_seed with open(self.path(self.solver_file), 'w') as outfile: text_format.PrintMessage(solver, outfile) self.solver = solver # save for later return True def save_files_generic(self): """ Save solver, train_val and deploy files to disk """ train_feature_db_path = self.dataset.get_feature_db_path(constants.TRAIN_DB) train_label_db_path = self.dataset.get_label_db_path(constants.TRAIN_DB) val_feature_db_path = self.dataset.get_feature_db_path(constants.VAL_DB) val_label_db_path = self.dataset.get_label_db_path(constants.VAL_DB) assert train_feature_db_path is not None, 'Training images are required' # Save the origin network to file: with open(self.path(self.model_file), 'w') as outfile: text_format.PrintMessage(self.network, outfile) # Split up train_val and deploy layers network = cleanedUpGenericNetwork(self.network) data_layers, train_val_layers, deploy_layers = filterLayersByState(network) # Write train_val file train_val_network = caffe_pb2.NetParameter() # Data layers # TODO clean this up train_image_data_layer = None train_label_data_layer = None val_image_data_layer = None val_label_data_layer = None # Find the existing Data layers for layer in data_layers.layer: for rule in layer.include: if rule.phase == caffe_pb2.TRAIN: for top_name in layer.top: if 'data' in top_name: assert train_image_data_layer is None, \ 'cannot specify two train image data layers' train_image_data_layer = layer elif 'label' in top_name: assert train_label_data_layer is None, \ 'cannot specify two train label data layers' train_label_data_layer = layer elif rule.phase == caffe_pb2.TEST: for top_name in layer.top: if 'data' in top_name: assert val_image_data_layer is None, \ 'cannot specify two val image data layers' val_image_data_layer = layer elif 'label' in top_name: assert val_label_data_layer is None, \ 'cannot specify two val label data layers' val_label_data_layer = layer # Create and add the Data layers # (uses info from existing data layers, where possible) train_image_data_layer = self.make_generic_data_layer( train_feature_db_path, train_image_data_layer, 'data', 'data', caffe_pb2.TRAIN) if train_image_data_layer is not None: train_val_network.layer.add().CopyFrom(train_image_data_layer) train_label_data_layer = self.make_generic_data_layer( train_label_db_path, train_label_data_layer, 'label', 'label', caffe_pb2.TRAIN) if train_label_data_layer is not None: train_val_network.layer.add().CopyFrom(train_label_data_layer) val_image_data_layer = self.make_generic_data_layer( val_feature_db_path, val_image_data_layer, 'data', 'data', caffe_pb2.TEST) if val_image_data_layer is not None: train_val_network.layer.add().CopyFrom(val_image_data_layer) val_label_data_layer = self.make_generic_data_layer( val_label_db_path, val_label_data_layer, 'label', 'label', caffe_pb2.TEST) if val_label_data_layer is not None: train_val_network.layer.add().CopyFrom(val_label_data_layer) # Add non-data layers train_val_network.MergeFrom(train_val_layers) # Write to file with open(self.path(self.train_val_file), 'w') as outfile: text_format.PrintMessage(train_val_network, outfile) # network sanity checks self.logger.debug("Network sanity check - train") CaffeTrainTask.net_sanity_check(train_val_network, caffe_pb2.TRAIN) if val_image_data_layer is not None: self.logger.debug("Network sanity check - val") CaffeTrainTask.net_sanity_check(train_val_network, caffe_pb2.TEST) # Write deploy file deploy_network = caffe_pb2.NetParameter() # Input deploy_network.input.append('data') shape = deploy_network.input_shape.add() shape.dim.append(1) shape.dim.append(self.dataset.get_feature_dims()[2]) # channels if train_image_data_layer.transform_param.HasField('crop_size'): shape.dim.append( train_image_data_layer.transform_param.crop_size) shape.dim.append( train_image_data_layer.transform_param.crop_size) else: shape.dim.append(self.dataset.get_feature_dims()[0]) # height shape.dim.append(self.dataset.get_feature_dims()[1]) # width # Layers deploy_network.MergeFrom(deploy_layers) # Write to file with open(self.path(self.deploy_file), 'w') as outfile: text_format.PrintMessage(deploy_network, outfile) # network sanity checks self.logger.debug("Network sanity check - deploy") CaffeTrainTask.net_sanity_check(deploy_network, caffe_pb2.TEST) # Write solver file solver = caffe_pb2.SolverParameter() # get enum value for solver type solver.solver_type = getattr(solver, self.solver_type) solver.net = self.train_val_file # Set CPU/GPU mode if config_value('caffe')['cuda_enabled'] and \ bool(config_value('gpu_list')): solver.solver_mode = caffe_pb2.SolverParameter.GPU else: solver.solver_mode = caffe_pb2.SolverParameter.CPU solver.snapshot_prefix = self.snapshot_prefix # Batch accumulation from digits.frameworks import CaffeFramework if self.batch_accumulation and CaffeFramework().can_accumulate_gradients(): solver.iter_size = self.batch_accumulation # Epochs -> Iterations train_iter = int(math.ceil( float(self.dataset.get_entry_count(constants.TRAIN_DB)) / (train_image_data_layer.data_param.batch_size * solver.iter_size) )) solver.max_iter = train_iter * self.train_epochs snapshot_interval = self.snapshot_interval * train_iter if 0 < snapshot_interval <= 1: solver.snapshot = 1 # don't round down elif 1 < snapshot_interval < solver.max_iter: solver.snapshot = int(snapshot_interval) else: solver.snapshot = 0 # only take one snapshot at the end if val_image_data_layer: solver.test_iter.append(int(math.ceil(float(self.dataset.get_entry_count( constants.VAL_DB)) / val_image_data_layer.data_param.batch_size))) val_interval = self.val_interval * train_iter if 0 < val_interval <= 1: solver.test_interval = 1 # don't round down elif 1 < val_interval < solver.max_iter: solver.test_interval = int(val_interval) else: solver.test_interval = solver.max_iter # only test once at the end # Learning rate solver.base_lr = self.learning_rate solver.lr_policy = self.lr_policy['policy'] scale = float(solver.max_iter) / 100.0 if solver.lr_policy == 'fixed': pass elif solver.lr_policy == 'step': # stepsize = stepsize * scale solver.stepsize = int(math.ceil(float(self.lr_policy['stepsize']) * scale)) solver.gamma = self.lr_policy['gamma'] elif solver.lr_policy == 'multistep': for value in self.lr_policy['stepvalue'].split(','): # stepvalue = stepvalue * scale solver.stepvalue.append(int(math.ceil(float(value) * scale))) solver.gamma = self.lr_policy['gamma'] elif solver.lr_policy == 'exp': # gamma = gamma^(1/scale) solver.gamma = math.pow(self.lr_policy['gamma'], 1.0 / scale) elif solver.lr_policy == 'inv': # gamma = gamma / scale solver.gamma = self.lr_policy['gamma'] / scale solver.power = self.lr_policy['power'] elif solver.lr_policy == 'poly': solver.power = self.lr_policy['power'] elif solver.lr_policy == 'sigmoid': # gamma = -gamma / scale solver.gamma = -1.0 * self.lr_policy['gamma'] / scale # stepsize = stepsize * scale solver.stepsize = int(math.ceil(float(self.lr_policy['stepsize']) * scale)) else: raise Exception('Unknown lr_policy: "%s"' % solver.lr_policy) # These solver types don't support momentum unsupported = [solver.ADAGRAD] try: unsupported.append(solver.RMSPROP) except AttributeError: pass if solver.solver_type not in unsupported: solver.momentum = 0.9 solver.weight_decay = solver.base_lr / 100.0 # Display 8x per epoch, or once per 5000 images, whichever is more frequent solver.display = max(1, min( int(math.floor(float(solver.max_iter) / (self.train_epochs * 8))), int(math.ceil(5000.0 / (train_image_data_layer.data_param.batch_size * solver.iter_size))) )) if self.random_seed is not None: solver.random_seed = self.random_seed with open(self.path(self.solver_file), 'w') as outfile: text_format.PrintMessage(solver, outfile) self.solver = solver # save for later return True def make_generic_data_layer(self, db_path, orig_layer, name, top, phase): """ Utility within save_files_generic for creating a Data layer Returns a LayerParameter (or None) Arguments: db_path -- path to database (or None) orig_layer -- a LayerParameter supplied by the user (or None) """ if db_path is None: # TODO allow user to specify a standard data layer even if it doesn't exist in the dataset return None layer = caffe_pb2.LayerParameter() if orig_layer is not None: layer.CopyFrom(orig_layer) layer.type = 'Data' if not layer.HasField('name'): layer.name = name if not len(layer.top): layer.top.append(top) layer.ClearField('include') layer.include.add(phase=phase) # source if layer.data_param.HasField('source'): self.logger.warning('Ignoring data_param.source ...') layer.data_param.source = db_path if layer.data_param.HasField('backend'): self.logger.warning('Ignoring data_param.backend ...') layer.data_param.backend = caffe_pb2.DataParameter.LMDB # batch size if not layer.data_param.HasField('batch_size'): layer.data_param.batch_size = constants.DEFAULT_BATCH_SIZE if self.batch_size: layer.data_param.batch_size = self.batch_size # mean if name == 'data' and self.dataset.get_mean_file(): if self.use_mean == 'pixel': mean_pixel = self.get_mean_pixel(self.dataset.path(self.dataset.get_mean_file())) # remove any values that may already be in the network self.set_mean_value(layer, mean_pixel) elif self.use_mean == 'image': self.set_mean_file(layer, self.dataset.path(self.dataset.get_mean_file())) # crop size if name == 'data' and self.crop_size: max_crop_size = min(self.dataset.get_feature_dims()[0], self.dataset.get_feature_dims()[1]) assert self.crop_size <= max_crop_size, 'crop_size is larger than the image size' layer.transform_param.crop_size = self.crop_size return layer def iteration_to_epoch(self, it): return float(it * self.train_epochs) / self.solver.max_iter @override def task_arguments(self, resources, env): """ Generate Caffe command line options or, in certain cases, pycaffe Python script Returns a list of strings Arguments: resources -- dict of available task resources env -- dict of environment variables """ if platform.system() == 'Windows': if any([layer.type == 'Python' for layer in self.network.layer]): # Arriving here because the network includes Python Layer and we are running inside Windows. # We can not invoke caffe.exe and need to fallback to pycaffe # https://github.com/Microsoft/caffe/issues/87 # TODO: Remove this once caffe.exe works fine with Python Layer win_python_layer_gpu_id = None if 'gpus' in resources: n_gpus = len(resources['gpus']) if n_gpus > 1: raise Exception('Please select single GPU when running in Windows with Python layer.') elif n_gpus == 1: win_python_layer_gpu_id = resources['gpus'][0][0] # We know which GPU to use, call helper to create the script return self._pycaffe_args(win_python_layer_gpu_id) # Not in Windows, or in Windows but no Python Layer # This is the normal path args = [config_value('caffe')['executable'], 'train', '--solver=%s' % self.path(self.solver_file), ] if 'gpus' in resources: identifiers = [] for identifier, value in resources['gpus']: identifiers.append(identifier) if len(identifiers) == 1: args.append('--gpu=%s' % identifiers[0]) elif len(identifiers) > 1: if config_value('caffe')['flavor'] == 'NVIDIA': if (utils.parse_version(config_value('caffe')['version']) < utils.parse_version('0.14.0-alpha')): # Prior to version 0.14, NVcaffe used the --gpus switch args.append('--gpus=%s' % ','.join(identifiers)) else: args.append('--gpu=%s' % ','.join(identifiers)) elif config_value('caffe')['flavor'] == 'BVLC': args.append('--gpu=%s' % ','.join(identifiers)) else: raise ValueError('Unknown flavor. Support NVIDIA and BVLC flavors only.') if self.pretrained_model: args.append('--weights=%s' % ','.join(map(lambda x: self.path(x), self.pretrained_model.split(os.path.pathsep)))) return args def _pycaffe_args(self, gpu_id): """ Helper to generate pycaffe Python script Returns a list of strings Throws ValueError if self.solver_type is not recognized Arguments: gpu_id -- the GPU device id to use """ # TODO: Remove this once caffe.exe works fine with Python Layer solver_type_mapping = { 'ADADELTA': 'AdaDeltaSolver', 'ADAGRAD': 'AdaGradSolver', 'ADAM': 'AdamSolver', 'NESTEROV': 'NesterovSolver', 'RMSPROP': 'RMSPropSolver', 'SGD': 'SGDSolver'} try: solver_type = solver_type_mapping[self.solver_type] except KeyError: raise ValueError("Unknown solver type {}.".format(self.solver_type)) if gpu_id is not None: gpu_script = "caffe.set_device({id});caffe.set_mode_gpu();".format(id=gpu_id) else: gpu_script = "caffe.set_mode_cpu();" loading_script = "" if self.pretrained_model: weight_files = map(lambda x: self.path(x), self.pretrained_model.split(os.path.pathsep)) for weight_file in weight_files: loading_script = loading_script + "solv.net.copy_from('{weight}');".format(weight=weight_file) command_script =\ "import caffe;" \ "{gpu_script}" \ "solv=caffe.{solver}('{solver_file}');" \ "{loading_script}" \ "solv.solve()" \ .format(gpu_script=gpu_script, solver=solver_type, solver_file=self.solver_file, loading_script=loading_script) args = [sys.executable + ' -c ' + '\"' + command_script + '\"'] return args @override def process_output(self, line): float_exp = '(NaN|[-+]?[0-9]*\.?[0-9]+(e[-+]?[0-9]+)?)' self.caffe_log.write('%s\n' % line) self.caffe_log.flush() # parse caffe output timestamp, level, message = self.preprocess_output_caffe(line) if not message: return True # iteration updates match = re.match(r'Iteration (\d+)', message) if match: i = int(match.group(1)) self.new_iteration(i) # net output leading_match = re.match(r'(\(\d\.\d\)?\s{0,7})(.*)', message) if leading_match: message = leading_match.group(2) match = re.match(r'(Train|Test) net output #(\d+): (\S*) = %s' % float_exp, message, flags=re.IGNORECASE) if match: phase = match.group(1) # index = int(match.group(2)) name = match.group(3) value = match.group(4) assert value.lower() != 'nan', \ 'Network outputted NaN for "%s" (%s phase). Try decreasing your learning rate.' % (name, phase) value = float(value) # Find the layer type kind = '?' for layer in self.network.layer: if name in layer.top: kind = layer.type break if phase.lower() == 'train': self.save_train_output(name, kind, value) elif phase.lower() == 'test': self.save_val_output(name, kind, value) return True # learning rate updates match = re.match(r'Iteration (\d+).*lr = %s' % float_exp, message, flags=re.IGNORECASE) if match: i = int(match.group(1)) lr = float(match.group(2)) self.save_train_output('learning_rate', 'LearningRate', lr) return True # snapshot saved if self.saving_snapshot: if not message.startswith('Snapshotting solver state'): self.logger.warning( 'caffe output format seems to have changed. ' 'Expected "Snapshotting solver state..." after "Snapshotting to..."') else: self.logger.debug('Snapshot saved.') self.detect_snapshots() self.send_snapshot_update() self.saving_snapshot = False return True # snapshot starting match = re.match(r'Snapshotting to (.*)\s*$', message) if match: self.saving_snapshot = True return True if level in ['error', 'critical']: self.logger.error('%s: %s' % (self.name(), message)) self.exception = message return True return True def preprocess_output_caffe(self, line): """ Takes line of output and parses it according to caffe's output format Returns (timestamp, level, message) or (None, None, None) """ # NOTE: This must change when the logging format changes # LMMDD HH:MM:SS.MICROS pid file:lineno] message match = re.match(r'(\w)(\d{4} \S{8}).*]\s+(\S.*)$', line) if match: level = match.group(1) # add the year because caffe omits it timestr = '%s%s' % (time.strftime('%Y'), match.group(2)) message = match.group(3) if level == 'I': level = 'info' elif level == 'W': level = 'warning' elif level == 'E': level = 'error' elif level == 'F': # FAIL level = 'critical' timestamp = time.mktime(time.strptime(timestr, '%Y%m%d %H:%M:%S')) return (timestamp, level, message) else: return (None, None, None) def new_iteration(self, it): """ Update current_iteration """ if self.current_iteration == it: return self.current_iteration = it self.send_progress_update(self.iteration_to_epoch(it)) def send_snapshot_update(self): """ Sends socketio message about the snapshot list """ from digits.webapp import socketio socketio.emit('task update', { 'task': self.html_id(), 'update': 'snapshots', 'data': self.snapshot_list(), }, namespace='/jobs', room=self.job_id, ) @override def after_run(self): super(CaffeTrainTask, self).after_run() self.caffe_log.close() @override def after_runtime_error(self): if os.path.exists(self.path(self.CAFFE_LOG)): output = tail(self.path(self.CAFFE_LOG), 40) lines = [] for line in output.split('\n'): # parse caffe header timestamp, level, message = self.preprocess_output_caffe(line) if message: lines.append(message) # return the last 20 lines self.traceback = '\n'.join(lines[len(lines) - 20:]) if 'DIGITS_MODE_TEST' in os.environ: print output # TrainTask overrides @override def get_task_stats(self, epoch=-1): """ return a dictionary of task statistics """ loc, mean_file = os.path.split(self.dataset.get_mean_file()) stats = { "image dimensions": self.dataset.get_feature_dims(), "mean file": mean_file, "snapshot file": self.get_snapshot_filename(epoch), "solver file": self.solver_file, "train_val file": self.train_val_file, "deploy file": self.deploy_file, "framework": "caffe", "mean subtraction": self.use_mean } # These attributes only available in more recent jobs: if hasattr(self, "model_file"): if self.model_file is not None: stats.update({ "caffe flavor": self.caffe_flavor, "caffe version": self.caffe_version, "model file": self.model_file, "digits version": self.digits_version }) if hasattr(self.dataset, "resize_mode"): stats.update({"image resize mode": self.dataset.resize_mode}) if hasattr(self.dataset, "labels_file"): stats.update({"labels file": self.dataset.labels_file}) # Add this if python layer file exists if os.path.exists(os.path.join(self.job_dir, CAFFE_PYTHON_LAYER_FILE)): stats.update({"python layer file": CAFFE_PYTHON_LAYER_FILE}) elif os.path.exists(os.path.join(self.job_dir, CAFFE_PYTHON_LAYER_FILE + 'c')): stats.update({"python layer file": CAFFE_PYTHON_LAYER_FILE + 'c'}) return stats @override def detect_snapshots(self): self.snapshots = [] snapshot_dir = os.path.join(self.job_dir, os.path.dirname(self.snapshot_prefix)) snapshots = [] solverstates = [] for filename in os.listdir(snapshot_dir): # find models match = re.match(r'%s_iter_(\d+)\.caffemodel' % os.path.basename(self.snapshot_prefix), filename) if match: iteration = int(match.group(1)) epoch = float(iteration) / (float(self.solver.max_iter) / self.train_epochs) # assert epoch.is_integer(), '%s is not an integer' % epoch epoch = round(epoch, 3) # if epoch is int if epoch == math.ceil(epoch): # print epoch,math.ceil(epoch),int(epoch) epoch = int(epoch) snapshots.append(( os.path.join(snapshot_dir, filename), epoch ) ) # find solverstates match = re.match(r'%s_iter_(\d+)\.solverstate' % os.path.basename(self.snapshot_prefix), filename) if match: solverstates.append(( os.path.join(snapshot_dir, filename), int(match.group(1)) ) ) # delete all but the most recent solverstate for filename, iteration in sorted(solverstates, key=lambda tup: tup[1])[:-1]: # print 'Removing "%s"' % filename os.remove(filename) self.snapshots = sorted(snapshots, key=lambda tup: tup[1]) return len(self.snapshots) > 0 @override def est_next_snapshot(self): if self.status != Status.RUN or self.current_iteration == 0: return None elapsed = time.time() - self.status_updates[-1][1] next_snapshot_iteration = (1 + self.current_iteration // self.snapshot_interval) * self.snapshot_interval return (next_snapshot_iteration - self.current_iteration) * elapsed // self.current_iteration @override def can_view_weights(self): return False @override def infer_one(self, data, snapshot_epoch=None, layers=None, gpu=None, resize=True): return self.infer_one_image(data, snapshot_epoch=snapshot_epoch, layers=layers, gpu=gpu, resize=resize ) def infer_one_image(self, image, snapshot_epoch=None, layers=None, gpu=None, resize=True): """ Run inference on one image for a generic model Returns (output, visualizations) output -- an OrderedDict of string -> np.ndarray visualizations -- a list of dicts for the specified layers Returns (None, None) if something goes wrong Arguments: image -- an np.ndarray Keyword arguments: snapshot_epoch -- which snapshot to use layers -- which layer activation[s] and weight[s] to visualize """ net = self.get_net(snapshot_epoch, gpu=gpu) # process image if image.ndim == 2: image = image[:, :, np.newaxis] preprocessed = self.get_transformer(resize).preprocess( 'data', image) # reshape net input (if necessary) test_shape = (1,) + preprocessed.shape if net.blobs['data'].data.shape != test_shape: net.blobs['data'].reshape(*test_shape) # run inference net.blobs['data'].data[...] = preprocessed o = net.forward() # order outputs in prototxt order output = OrderedDict() for blob in net.blobs.keys(): if blob in o: output[blob] = o[blob] visualizations = self.get_layer_visualizations(net, layers) return (output, visualizations) def get_layer_visualizations(self, net, layers='all'): """ Returns visualizations of various layers in the network """ # add visualizations visualizations = [] if layers and layers != 'none': if layers == 'all': added_activations = [] for layer in self.network.layer: for bottom in layer.bottom: if bottom in net.blobs and bottom not in added_activations: data = net.blobs[bottom].data[0] vis = utils.image.get_layer_vis_square(data, allow_heatmap=bool(bottom != 'data'), channel_order='BGR') mean, std, hist = self.get_layer_statistics(data) visualizations.append( { 'name': str(bottom), 'vis_type': 'Activation', 'vis': vis, 'data_stats': { 'shape': data.shape, 'mean': mean, 'stddev': std, 'histogram': hist, }, } ) added_activations.append(bottom) if layer.name in net.params: data = net.params[layer.name][0].data if layer.type not in ['InnerProduct']: vis = utils.image.get_layer_vis_square(data, channel_order='BGR') else: vis = None mean, std, hist = self.get_layer_statistics(data) params = net.params[layer.name] weight_count = reduce(operator.mul, params[0].data.shape, 1) if len(params) > 1: bias_count = reduce(operator.mul, params[1].data.shape, 1) else: bias_count = 0 parameter_count = weight_count + bias_count visualizations.append( { 'name': str(layer.name), 'vis_type': 'Weights', 'layer_type': layer.type, 'param_count': parameter_count, 'vis': vis, 'data_stats': { 'shape': data.shape, 'mean': mean, 'stddev': std, 'histogram': hist, }, } ) for top in layer.top: if top in net.blobs and top not in added_activations: data = net.blobs[top].data[0] normalize = True # don't normalize softmax layers but scale by 255 to fill image range if layer.type == 'Softmax': vis = utils.image.get_layer_vis_square(data * 255, normalize=False, allow_heatmap=bool(top != 'data'), channel_order='BGR') else: vis = utils.image.get_layer_vis_square(data, normalize=normalize, allow_heatmap=bool(top != 'data'), channel_order='BGR') mean, std, hist = self.get_layer_statistics(data) visualizations.append( { 'name': str(top), 'vis_type': 'Activation', 'vis': vis, 'data_stats': { 'shape': data.shape, 'mean': mean, 'stddev': std, 'histogram': hist, }, } ) added_activations.append(top) else: raise NotImplementedError return visualizations def get_layer_statistics(self, data): """ Returns statistics for the given layer data: (mean, standard deviation, histogram) histogram -- [y, x, ticks] Arguments: data -- a np.ndarray """ # XXX These calculations can be super slow mean = np.mean(data).astype(np.float32) std = np.std(data).astype(np.float32) y, x = np.histogram(data, bins=20) y = list(y.astype(np.float32)) ticks = x[[0, len(x) / 2, -1]] x = [((x[i] + x[i + 1]) / 2.0).astype(np.float32) for i in xrange(len(x) - 1)] ticks = list(ticks.astype(np.float32)) return (mean, std, [y, x, ticks]) @override def infer_many(self, data, snapshot_epoch=None, gpu=None, resize=True): return self.infer_many_images(data, snapshot_epoch=snapshot_epoch, gpu=gpu, resize=resize) def infer_many_images(self, images, snapshot_epoch=None, gpu=None, resize=True): """ Returns a list of OrderedDict, one for each image Arguments: images -- a list of np.arrays Keyword arguments: snapshot_epoch -- which snapshot to use """ net = self.get_net(snapshot_epoch, gpu=gpu) caffe_images = [] for image in images: if image.ndim == 2: caffe_images.append(image[:, :, np.newaxis]) else: caffe_images.append(image) data_shape = tuple(self.get_transformer(resize).inputs['data'])[1:] if self.batch_size: data_shape = (self.batch_size,) + data_shape # TODO: grab batch_size from the TEST phase in train_val network else: data_shape = (constants.DEFAULT_BATCH_SIZE,) + data_shape outputs = None for chunk in [caffe_images[x:x + data_shape[0]] for x in xrange(0, len(caffe_images), data_shape[0])]: new_shape = (len(chunk),) + data_shape[1:] if net.blobs['data'].data.shape != new_shape: net.blobs['data'].reshape(*new_shape) for index, image in enumerate(chunk): net.blobs['data'].data[index] = self.get_transformer(resize).preprocess( 'data', image) o = net.forward() # order output in prototxt order output = OrderedDict() for blob in net.blobs.keys(): if blob in o: output[blob] = o[blob] if outputs is None: outputs = copy.deepcopy(output) else: for name, blob in output.iteritems(): outputs[name] = np.vstack((outputs[name], blob)) print 'Processed %s/%s images' % (len(outputs[outputs.keys()[0]]), len(caffe_images)) return outputs def has_model(self): """ Returns True if there is a model that can be used """ return len(self.snapshots) > 0 def get_net(self, epoch=None, gpu=None): """ Returns an instance of caffe.Net Keyword Arguments: epoch -- which snapshot to load (default is -1 to load the most recently generated snapshot) """ if not self.has_model(): return False file_to_load = self.get_snapshot(epoch) # check if already loaded if self.loaded_snapshot_file and self.loaded_snapshot_file == file_to_load \ and hasattr(self, '_caffe_net') and self._caffe_net is not None: return self._caffe_net CaffeTrainTask.set_mode(gpu) # Add job_dir to PATH to pick up any python layers used by the model sys.path.append(self.job_dir) # Attempt to force a reload of the "digits_python_layers" module loaded_module = sys.modules.get('digits_python_layers', None) if loaded_module: try: reload(loaded_module) except ImportError: # Let Caffe throw the error if the file is missing pass # Load the model self._caffe_net = caffe.Net( self.path(self.deploy_file), file_to_load, caffe.TEST) # Remove job_dir from PATH sys.path.remove(self.job_dir) self.loaded_snapshot_epoch = epoch self.loaded_snapshot_file = file_to_load return self._caffe_net def get_transformer(self, resize=True): """ Returns an instance of DigitsTransformer Parameters: - resize_shape: specify shape of network (or None for network default) """ # check if already loaded if hasattr(self, '_transformer') and self._transformer is not None: return self._transformer data_shape = None channel_swap = None mean_pixel = None mean_image = None network = caffe_pb2.NetParameter() with open(self.path(self.deploy_file)) as infile: text_format.Merge(infile.read(), network) if network.input_shape: data_shape = network.input_shape[0].dim else: data_shape = network.input_dim[:4] if self.dataset.get_feature_dims()[2] == 3: # BGR when there are three channels # XXX see issue #59 channel_swap = (2, 1, 0) if self.dataset.get_mean_file(): if self.use_mean == 'pixel': mean_pixel = self.get_mean_pixel(self.dataset.path(self.dataset.get_mean_file())) elif self.use_mean == 'image': mean_image = self.get_mean_image(self.dataset.path(self.dataset.get_mean_file()), True) t = DigitsTransformer( inputs={'data': tuple(data_shape)}, resize=resize ) # transpose to (channels, height, width) t.set_transpose('data', (2, 0, 1)) if channel_swap is not None: # swap color channels t.set_channel_swap('data', channel_swap) # set mean if self.use_mean == 'pixel' and mean_pixel is not None: t.set_mean('data', mean_pixel) elif self.use_mean == 'image' and mean_image is not None: t.set_mean('data', mean_image) # t.set_raw_scale('data', 255) # [0,255] range instead of [0,1] self._transformer = t return self._transformer @override def get_model_files(self): """ return paths to model files """ model_files = { "Solver": self.solver_file, "Network (train/val)": self.train_val_file, "Network (deploy)": self.deploy_file } if os.path.exists(os.path.join(self.job_dir, CAFFE_PYTHON_LAYER_FILE)): model_files.update({"Python layer": os.path.join(self.job_dir, CAFFE_PYTHON_LAYER_FILE)}) elif os.path.exists(os.path.join(self.job_dir, CAFFE_PYTHON_LAYER_FILE + 'c')): model_files.update({"Python layer": os.path.join(self.job_dir, CAFFE_PYTHON_LAYER_FILE + 'c')}) if hasattr(self, "model_file"): if self.model_file is not None: model_files.update({"Network (original)": self.model_file}) return model_files @override def get_network_desc(self): """ return text description of model """ return text_format.MessageToString(self.network) @staticmethod def net_sanity_check(net, phase): """ Perform various sanity checks on the network, including: - check that all layer bottoms are included at the specified stage """ assert phase == caffe_pb2.TRAIN or phase == caffe_pb2.TEST, "Unknown phase: %s" % repr(phase) # work out which layers and tops are included at the specified phase layers = [] tops = [] for layer in net.layer: if len(layer.include) > 0: mask = 0 # include none by default for rule in layer.include: mask = mask | (1 << rule.phase) elif len(layer.exclude) > 0: # include and exclude rules are mutually exclusive as per Caffe spec mask = (1 << caffe_pb2.TRAIN) | (1 << caffe_pb2.TEST) # include all by default for rule in layer.exclude: mask = mask & ~(1 << rule.phase) else: mask = (1 << caffe_pb2.TRAIN) | (1 << caffe_pb2.TEST) if mask & (1 << phase): # layer will be included at this stage layers.append(layer) tops.extend(layer.top) # add inputs tops.extend(net.input) # now make sure all bottoms are present at this stage for layer in layers: for bottom in layer.bottom: if bottom not in tops: raise CaffeTrainSanityCheckError( "Layer '%s' references bottom '%s' at the %s stage however " "this blob is not included at that stage. Please consider " "using an include directive to limit the scope of this layer." % ( layer.name, bottom, "TRAIN" if phase == caffe_pb2.TRAIN else "TEST" ) ) def cleanedUpClassificationNetwork(original_network, num_categories): """ Perform a few cleanup routines on a classification network Returns a new NetParameter """ network = caffe_pb2.NetParameter() network.CopyFrom(original_network) for i, layer in enumerate(network.layer): if 'Data' in layer.type: assert layer.type in ['Data', 'HDF5Data'], \ 'Unsupported data layer type %s' % layer.type elif layer.type == 'Input': # DIGITS handles the deploy file for you del network.layer[i] elif layer.type == 'Accuracy': # Check to see if top_k > num_categories if (layer.accuracy_param.HasField('top_k') and layer.accuracy_param.top_k > num_categories): del network.layer[i] elif layer.type == 'InnerProduct': # Check to see if num_output is unset if not layer.inner_product_param.HasField('num_output'): layer.inner_product_param.num_output = num_categories return network def cleanedUpGenericNetwork(original_network): """ Perform a few cleanup routines on a generic network Returns a new NetParameter """ network = caffe_pb2.NetParameter() network.CopyFrom(original_network) for i, layer in enumerate(network.layer): if 'Data' in layer.type: assert layer.type in ['Data'], \ 'Unsupported data layer type %s' % layer.type elif layer.type == 'Input': # DIGITS handles the deploy file for you del network.layer[i] elif layer.type == 'InnerProduct': # Check to see if num_output is unset assert layer.inner_product_param.HasField('num_output'), \ "Don't leave inner_product_param.num_output unset for generic networks (layer %s)" % layer.name return network def filterLayersByState(network): """ Splits up a network into data, train_val and deploy layers """ # The net has a NetState when in use train_state = caffe_pb2.NetState() text_format.Merge('phase: TRAIN stage: "train"', train_state) val_state = caffe_pb2.NetState() text_format.Merge('phase: TEST stage: "val"', val_state) deploy_state = caffe_pb2.NetState() text_format.Merge('phase: TEST stage: "deploy"', deploy_state) # Each layer can have several NetStateRules train_rule = caffe_pb2.NetStateRule() text_format.Merge('phase: TRAIN', train_rule) val_rule = caffe_pb2.NetStateRule() text_format.Merge('phase: TEST', val_rule) # Return three NetParameters data_layers = caffe_pb2.NetParameter() train_val_layers = caffe_pb2.NetParameter() deploy_layers = caffe_pb2.NetParameter() for layer in network.layer: included_train = _layerIncludedInState(layer, train_state) included_val = _layerIncludedInState(layer, val_state) included_deploy = _layerIncludedInState(layer, deploy_state) # Treat data layers differently (more processing done later) if 'Data' in layer.type: data_layers.layer.add().CopyFrom(layer) rule = None if not included_train: # Exclude from train rule = val_rule elif not included_val: # Exclude from val rule = train_rule _setLayerRule(data_layers.layer[-1], rule) # Non-data layers else: if included_train or included_val: # Add to train_val train_val_layers.layer.add().CopyFrom(layer) rule = None if not included_train: # Exclude from train rule = val_rule elif not included_val: # Exclude from val rule = train_rule _setLayerRule(train_val_layers.layer[-1], rule) if included_deploy: # Add to deploy deploy_layers.layer.add().CopyFrom(layer) _setLayerRule(deploy_layers.layer[-1], None) return (data_layers, train_val_layers, deploy_layers) def _layerIncludedInState(layer, state): """ Returns True if this layer will be included in the given state Logic copied from Caffe's Net::FilterNet() """ # If no include rules are specified, the layer is included by default and # only excluded if it meets one of the exclude rules. layer_included = len(layer.include) == 0 for exclude_rule in layer.exclude: if _stateMeetsRule(state, exclude_rule): layer_included = False break for include_rule in layer.include: if _stateMeetsRule(state, include_rule): layer_included = True break return layer_included def _stateMeetsRule(state, rule): """ Returns True if the given state meets the given rule Logic copied from Caffe's Net::StateMeetsRule() """ if rule.HasField('phase'): if rule.phase != state.phase: return False if rule.HasField('min_level'): if state.level < rule.min_level: return False if rule.HasField('max_level'): if state.level > rule.max_level: return False # The state must contain ALL of the rule's stages for stage in rule.stage: if stage not in state.stage: return False # The state must contain NONE of the rule's not_stages for stage in rule.not_stage: if stage in state.stage: return False return True def _setLayerRule(layer, rule=None): """ Set a new include rule for this layer If rule is None, the layer will always be included """ layer.ClearField('include') layer.ClearField('exclude') if rule is not None: layer.include.add().CopyFrom(rule)
DIGITS-master
digits/model/tasks/caffe_train.py
# Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from .caffe_train import CaffeTrainTask from .torch_train import TorchTrainTask from .train import TrainTask __all__ = [ 'CaffeTrainTask', 'TorchTrainTask', 'TrainTask', ] from digits.config import config_value # noqa if config_value('tensorflow')['enabled']: from .tensorflow_train import TensorflowTrainTask # noqa __all__.append('TensorflowTrainTask')
DIGITS-master
digits/model/tasks/__init__.py
# Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from .caffe_train import CaffeTrainTask, CaffeTrainSanityCheckError from google.protobuf import text_format from digits import test_utils # Must import after importing digit.config import caffe_pb2 def check_positive(desc, stage): network = caffe_pb2.NetParameter() text_format.Merge(desc, network) CaffeTrainTask.net_sanity_check(network, stage) def check_negative(desc, stage): network = caffe_pb2.NetParameter() text_format.Merge(desc, network) try: CaffeTrainTask.net_sanity_check(network, stage) except CaffeTrainSanityCheckError: pass class TestCaffeNetSanityCheck(test_utils.CaffeMixin): # positive cases def test_std_net_train(self): desc = \ """ layer { name: "data" type: "Data" top: "data" top: "label" include { phase: TRAIN } } layer { name: "hidden" type: 'InnerProduct' bottom: "data" top: "output" } layer { name: "loss" type: "SoftmaxWithLoss" bottom: "output" bottom: "label" top: "loss" } layer { name: "accuracy" type: "Accuracy" bottom: "output" bottom: "label" top: "accuracy" include { phase: TEST } } """ check_positive(desc, caffe_pb2.TRAIN) def test_std_net_deploy(self): desc = \ """ input: "data" layer { name: "hidden" type: 'InnerProduct' bottom: "data" top: "output" } """ check_positive(desc, caffe_pb2.TEST) def test_ref_label_with_proper_include_directive(self): desc = \ """ input: "data" layer { name: "hidden" type: 'InnerProduct' bottom: "data" top: "output" } layer { name: "loss" type: "SoftmaxWithLoss" bottom: "output" bottom: "label" top: "loss" include { phase: TRAIN } } """ check_positive(desc, caffe_pb2.TEST) def test_ref_label_with_proper_exclude_directive(self): desc = \ """ input: "data" layer { name: "hidden" type: 'InnerProduct' bottom: "data" top: "output" } layer { name: "lossExcludedInTest" type: "SoftmaxWithLoss" bottom: "output" bottom: "label" top: "loss" exclude { phase: TEST } } """ check_positive(desc, caffe_pb2.TEST) # negative cases def test_error_ref_label_in_deploy(self): desc = \ """ input: "data" layer { name: "hidden" type: 'InnerProduct' bottom: "data" top: "output" } layer { name: "loss" type: "SoftmaxWithLoss" bottom: "output" bottom: "label" top: "loss" } """ check_negative(desc, caffe_pb2.TEST) def test_error_ref_unknown_blob(self): desc = \ """ input: "data" layer { name: "hidden" type: 'InnerProduct' bottom: "data" bottom: "bogusBlob" top: "output" } """ check_negative(desc, caffe_pb2.TRAIN) def test_error_ref_unincluded_blob(self): desc = \ """ input: "data" layer { name: "hidden" type: 'InnerProduct' bottom: "data" top: "output" include { phase: TRAIN } } layer { name: "hidden" type: 'InnerProduct2' bottom: "data" top: "output" } layer { name: "loss" type: "SoftmaxWithLoss" bottom: "output" bottom: "label" top: "loss" include { phase: TRAIN } } """ check_negative(desc, caffe_pb2.TEST) def test_error_ref_excluded_blob(self): desc = \ """ input: "data" layer { name: "hidden" type: 'InnerProduct' bottom: "data" top: "output" include { phase: TRAIN } } layer { name: "hidden" type: 'InnerProduct2' bottom: "data" top: "output" } layer { name: "loss" type: "SoftmaxWithLoss" bottom: "output" bottom: "label" top: "loss" exclude { phase: TEST } } """ check_negative(desc, caffe_pb2.TEST)
DIGITS-master
digits/model/tasks/test_caffe_sanity_checks.py
# Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from collections import OrderedDict, namedtuple import os.path import time import flask import gevent import psutil from digits import device_query from digits.task import Task from digits.utils import subclass, override # NOTE: Increment this every time the picked object changes PICKLE_VERSION = 2 # Used to store network outputs NetworkOutput = namedtuple('NetworkOutput', ['kind', 'data']) @subclass class TrainTask(Task): """ Defines required methods for child classes """ def __init__(self, job, dataset, train_epochs, snapshot_interval, learning_rate, lr_policy, **kwargs): """ Arguments: job -- model job dataset -- a DatasetJob containing the dataset for this model train_epochs -- how many epochs of training data to train on snapshot_interval -- how many epochs between taking a snapshot learning_rate -- the base learning rate lr_policy -- a hash of options to be used for the learning rate policy Keyword arguments: gpu_count -- how many GPUs to use for training (integer) selected_gpus -- a list of GPU indexes to be used for training batch_size -- if set, override any network specific batch_size with this value batch_accumulation -- accumulate gradients over multiple batches val_interval -- how many epochs between validating the model with an epoch of validation data traces_interval -- amount of steps in between timeline traces pretrained_model -- filename for a model to use for fine-tuning crop_size -- crop each image down to a square of this size use_mean -- subtract the dataset's mean file or mean pixel random_seed -- optional random seed data_aug -- data augmentation options """ self.gpu_count = kwargs.pop('gpu_count', None) self.selected_gpus = kwargs.pop('selected_gpus', None) self.batch_size = kwargs.pop('batch_size', None) self.batch_accumulation = kwargs.pop('batch_accumulation', None) self.val_interval = kwargs.pop('val_interval', None) self.traces_interval = kwargs.pop('traces_interval', None) self.pretrained_model = kwargs.pop('pretrained_model', None) self.crop_size = kwargs.pop('crop_size', None) self.use_mean = kwargs.pop('use_mean', None) self.random_seed = kwargs.pop('random_seed', None) self.solver_type = kwargs.pop('solver_type', None) self.rms_decay = kwargs.pop('rms_decay', None) self.shuffle = kwargs.pop('shuffle', None) self.network = kwargs.pop('network', None) self.framework_id = kwargs.pop('framework_id', None) self.data_aug = kwargs.pop('data_aug', None) super(TrainTask, self).__init__(job_dir=job.dir(), **kwargs) self.pickver_task_train = PICKLE_VERSION self.job = job self.dataset = dataset self.train_epochs = train_epochs self.snapshot_interval = snapshot_interval self.learning_rate = learning_rate self.lr_policy = lr_policy self.current_epoch = 0 self.snapshots = [] self.timeline_traces = [] # data gets stored as dicts of lists (for graphing) self.train_outputs = OrderedDict() self.val_outputs = OrderedDict() def __getstate__(self): state = super(TrainTask, self).__getstate__() if 'dataset' in state: del state['dataset'] if 'snapshots' in state: del state['snapshots'] if '_labels' in state: del state['_labels'] if '_hw_socketio_thread' in state: del state['_hw_socketio_thread'] return state def __setstate__(self, state): if state['pickver_task_train'] < 2: state['train_outputs'] = OrderedDict() state['val_outputs'] = OrderedDict() tl = state.pop('train_loss_updates', None) vl = state.pop('val_loss_updates', None) va = state.pop('val_accuracy_updates', None) lr = state.pop('lr_updates', None) if tl: state['train_outputs']['epoch'] = NetworkOutput('Epoch', [x[0] for x in tl]) state['train_outputs']['loss'] = NetworkOutput('SoftmaxWithLoss', [x[1] for x in tl]) state['train_outputs']['learning_rate'] = NetworkOutput('LearningRate', [x[1] for x in lr]) if vl: state['val_outputs']['epoch'] = NetworkOutput('Epoch', [x[0] for x in vl]) if va: state['val_outputs']['accuracy'] = NetworkOutput('Accuracy', [x[1] / 100 for x in va]) state['val_outputs']['loss'] = NetworkOutput('SoftmaxWithLoss', [x[1] for x in vl]) if state['use_mean'] is True: state['use_mean'] = 'pixel' elif state['use_mean'] is False: state['use_mean'] = 'none' state['pickver_task_train'] = PICKLE_VERSION super(TrainTask, self).__setstate__(state) self.snapshots = [] self.timeline_traces = [] self.dataset = None @override def offer_resources(self, resources): if 'gpus' not in resources: return None if not resources['gpus']: return {} # don't use a GPU at all if self.gpu_count is not None: identifiers = [] for resource in resources['gpus']: if resource.remaining() >= 1: identifiers.append(resource.identifier) if len(identifiers) == self.gpu_count: break if len(identifiers) == self.gpu_count: return {'gpus': [(i, 1) for i in identifiers]} else: return None elif self.selected_gpus is not None: all_available = True for i in self.selected_gpus: available = False for gpu in resources['gpus']: if i == gpu.identifier: if gpu.remaining() >= 1: available = True break if not available: all_available = False break if all_available: return {'gpus': [(i, 1) for i in self.selected_gpus]} else: return None return None @override def before_run(self): # start a thread which sends SocketIO updates about hardware utilization gpus = None if 'gpus' in self.current_resources: gpus = [identifier for (identifier, value) in self.current_resources['gpus']] self._hw_socketio_thread = gevent.spawn( self.hw_socketio_updater, gpus) def hw_socketio_updater(self, gpus): """ This thread sends SocketIO messages about hardware utilization to connected clients Arguments: gpus -- a list of identifiers for the GPUs currently being used """ from digits.webapp import app, socketio devices = [] if gpus is not None: for index in gpus: device = device_query.get_device(index) if device: devices.append((index, device)) else: raise RuntimeError('Failed to load gpu information for GPU #"%s"' % index) # this thread continues until killed in after_run() while True: # CPU (Non-GPU) Info data_cpu = {} if hasattr(self, 'p') and self.p is not None: data_cpu['pid'] = self.p.pid try: ps = psutil.Process(self.p.pid) # 'self.p' is the system call object if ps.is_running(): if psutil.version_info[0] >= 2: data_cpu['cpu_pct'] = ps.cpu_percent(interval=1) data_cpu['mem_pct'] = ps.memory_percent() data_cpu['mem_used'] = ps.memory_info().rss else: data_cpu['cpu_pct'] = ps.get_cpu_percent(interval=1) data_cpu['mem_pct'] = ps.get_memory_percent() data_cpu['mem_used'] = ps.get_memory_info().rss except (psutil.NoSuchProcess, psutil.AccessDenied): # In rare case of instant process crash or PID went zombie (report nothing) pass data_gpu = [] for index, device in devices: update = {'name': device.name, 'index': index} nvml_info = device_query.get_nvml_info(index) if nvml_info is not None: update.update(nvml_info) data_gpu.append(update) with app.app_context(): html = flask.render_template('models/gpu_utilization.html', data_gpu=data_gpu, data_cpu=data_cpu) socketio.emit('task update', { 'task': self.html_id(), 'update': 'gpu_utilization', 'html': html, }, namespace='/jobs', room=self.job_id, ) gevent.sleep(1) def send_progress_update(self, epoch): """ Sends socketio message about the current progress """ if self.current_epoch == epoch: return self.current_epoch = epoch self.progress = epoch / self.train_epochs self.emit_progress_update() def save_train_output(self, *args): """ Save output to self.train_outputs """ from digits.webapp import socketio if not self.save_output(self.train_outputs, *args): return if self.last_train_update and (time.time() - self.last_train_update) < 5: return self.last_train_update = time.time() self.logger.debug('Training %s%% complete.' % round(100 * self.current_epoch / self.train_epochs, 2)) # loss graph data data = self.combined_graph_data() if data: socketio.emit('task update', { 'task': self.html_id(), 'update': 'combined_graph', 'data': data, }, namespace='/jobs', room=self.job_id, ) if data['columns']: # isolate the Loss column data for the sparkline graph_data = data['columns'][0][1:] socketio.emit('task update', { 'task': self.html_id(), 'job_id': self.job_id, 'update': 'combined_graph', 'data': graph_data, }, namespace='/jobs', room='job_management', ) # lr graph data data = self.lr_graph_data() if data: socketio.emit('task update', { 'task': self.html_id(), 'update': 'lr_graph', 'data': data, }, namespace='/jobs', room=self.job_id, ) def save_val_output(self, *args): """ Save output to self.val_outputs """ from digits.webapp import socketio if not self.save_output(self.val_outputs, *args): return # loss graph data data = self.combined_graph_data() if data: socketio.emit('task update', { 'task': self.html_id(), 'update': 'combined_graph', 'data': data, }, namespace='/jobs', room=self.job_id, ) def save_output(self, d, name, kind, value): """ Save output to self.train_outputs or self.val_outputs Returns true if all outputs for this epoch have been added Arguments: d -- the dictionary where the output should be stored name -- name of the output (e.g. "accuracy") kind -- the type of outputs (e.g. "Accuracy") value -- value for this output (e.g. 0.95) """ # don't let them be unicode name = str(name) kind = str(kind) # update d['epoch'] if 'epoch' not in d: d['epoch'] = NetworkOutput('Epoch', [self.current_epoch]) elif d['epoch'].data[-1] != self.current_epoch: d['epoch'].data.append(self.current_epoch) if name not in d: d[name] = NetworkOutput(kind, []) epoch_len = len(d['epoch'].data) name_len = len(d[name].data) # save to back of d[name] if name_len > epoch_len: raise Exception('Received a new output without being told the new epoch') elif name_len == epoch_len: # already exists if isinstance(d[name].data[-1], list): d[name].data[-1].append(value) else: d[name].data[-1] = [d[name].data[-1], value] elif name_len == epoch_len - 1: # expected case d[name].data.append(value) else: # we might have missed one for _ in xrange(epoch_len - name_len - 1): d[name].data.append(None) d[name].data.append(value) for key in d: if key not in ['epoch', 'learning_rate']: if len(d[key].data) != epoch_len: return False return True @override def after_run(self): if hasattr(self, '_hw_socketio_thread'): self._hw_socketio_thread.kill() def detect_snapshots(self): """ Populate self.snapshots with snapshots that exist on disk Returns True if at least one usable snapshot is found """ return False def snapshot_list(self): """ Returns an array of arrays for creating an HTML select field """ return [[s[1], 'Epoch #%s' % s[1]] for s in reversed(self.snapshots)] def est_next_snapshot(self): """ Returns the estimated time in seconds until the next snapshot is taken """ return None def can_view_weights(self): """ Returns True if this Task can visualize the weights of each layer for a given model """ raise NotImplementedError() def view_weights(self, model_epoch=None, layers=None): """ View the weights for a specific model and layer[s] """ return None def can_view_activations(self): """ Returns True if this Task can visualize the activations of a model after inference """ raise NotImplementedError() def infer_one(self, data, model_epoch=None, layers=None): """ Run inference on one input """ return None def can_infer_many(self): """ Returns True if this Task can run inference on many inputs """ raise NotImplementedError() def infer_many(self, data, model_epoch=None): """ Run inference on many inputs """ return None def get_snapshot(self, epoch=-1, download=False): """ return snapshot file for specified epoch """ snapshot_filename = None if len(self.snapshots) == 0: return "no snapshots" if epoch == -1 or not epoch: epoch = self.snapshots[-1][1] snapshot_filename = self.snapshots[-1][0] else: for f, e in self.snapshots: if e == epoch: snapshot_filename = f break if not snapshot_filename: raise ValueError('Invalid epoch') return snapshot_filename def get_snapshot_filename(self, epoch=-1): """ Return the filename for the specified epoch """ path, name = os.path.split(self.get_snapshot(epoch)) return name def get_labels(self): """ Read labels from labels_file and return them in a list """ # The labels might be set already if hasattr(self, '_labels') and self._labels and len(self._labels) > 0: return self._labels assert hasattr(self.dataset, 'labels_file'), 'labels_file not set' assert self.dataset.labels_file, 'labels_file not set' assert os.path.exists(self.dataset.path(self.dataset.labels_file)), 'labels_file does not exist: {}'.format( self.dataset.path(self.dataset.labels_file) ) labels = [] with open(self.dataset.path(self.dataset.labels_file)) as infile: for line in infile: label = line.strip() if label: labels.append(label) assert len(labels) > 0, 'no labels in labels_file' self._labels = labels return self._labels def lr_graph_data(self): """ Returns learning rate data formatted for a C3.js graph Keyword arguments: """ if not self.train_outputs or 'epoch' not in self.train_outputs or 'learning_rate' not in self.train_outputs: return None # return 100-200 values or fewer stride = max(len(self.train_outputs['epoch'].data) / 100, 1) e = ['epoch'] + self.train_outputs['epoch'].data[::stride] lr = ['lr'] + self.train_outputs['learning_rate'].data[::stride] return { 'columns': [e, lr], 'xs': { 'lr': 'epoch' }, 'names': { 'lr': 'Learning Rate' }, } def detect_timeline_traces(self): """ Populate self.timeline_traces with snapshots that exist on disk Returns True if at least one usable snapshot is found """ return False def has_timeline_traces(self): """ Evaluates if there are timeline traces to be viewed at all """ return len(self.timeline_traces) > 0 def timeline_trace(self, tid): """ Returns the data of a selected timeline trace """ for item in self.timeline_traces: if item[1] == tid: fn = item[0] with open(fn, 'r') as file_data: return file_data.read() raise ValueError('Requested timeline not found in timeline list') def timeline_trace_list(self): """ Returns an array of timeline trace id's for creating an HTML select field """ return [[s[1], 'Trace #%s' % s[1]] for s in reversed(self.timeline_traces)] def combined_graph_data(self, cull=True): """ Returns all train/val outputs in data for one C3.js graph Keyword arguments: cull -- if True, cut down the number of data points returned to a reasonable size """ data = { 'columns': [], 'xs': {}, 'axes': {}, 'names': {}, } added_train_data = False added_val_data = False if self.train_outputs and 'epoch' in self.train_outputs: if cull: # max 200 data points stride = max(len(self.train_outputs['epoch'].data) / 100, 1) else: # return all data stride = 1 for name, output in self.train_outputs.iteritems(): if name not in ['epoch', 'learning_rate']: col_id = '%s-train' % name data['xs'][col_id] = 'train_epochs' data['names'][col_id] = '%s (train)' % name if 'accuracy' in output.kind.lower() or 'accuracy' in name.lower(): data['columns'].append([col_id] + [ (100 * x if x is not None else 'none') for x in output.data[::stride]]) data['axes'][col_id] = 'y2' else: data['columns'].append([col_id] + [ (x if x is not None else 'none') for x in output.data[::stride]]) added_train_data = True if added_train_data: data['columns'].append(['train_epochs'] + self.train_outputs['epoch'].data[::stride]) if self.val_outputs and 'epoch' in self.val_outputs: if cull: # max 200 data points stride = max(len(self.val_outputs['epoch'].data) / 100, 1) else: # return all data stride = 1 for name, output in self.val_outputs.iteritems(): if name not in ['epoch']: col_id = '%s-val' % name data['xs'][col_id] = 'val_epochs' data['names'][col_id] = '%s (val)' % name if 'accuracy' in output.kind.lower() or 'accuracy' in name.lower(): data['columns'].append([col_id] + [ (100 * x if x is not None else 'none') for x in output.data[::stride]]) data['axes'][col_id] = 'y2' else: data['columns'].append([col_id] + [ (x if x is not None else 'none') for x in output.data[::stride]]) added_val_data = True if added_val_data: data['columns'].append(['val_epochs'] + self.val_outputs['epoch'].data[::stride]) if added_train_data: return data else: # return None if only validation data exists # helps with ordering of columns in graph return None # return id of framework used for training def get_framework_id(self): """ Returns a string """ return self.framework_id def get_model_files(self): """ return path to model file """ raise NotImplementedError() def get_network_desc(self): """ return text description of model """ raise NotImplementedError() def get_task_stats(self, epoch=-1): """ return a dictionary of task statistics """ raise NotImplementedError()
DIGITS-master
digits/model/tasks/train.py
# Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import import operator import os import re import shutil import subprocess import tempfile import time import h5py import numpy as np import PIL.Image from .train import TrainTask import digits from digits import utils from digits.config import config_value from digits.utils import subclass, override, constants # Must import after importing digit.config import caffe_pb2 # NOTE: Increment this every time the pickled object changes PICKLE_VERSION = 1 # Constants TORCH_MODEL_FILE = 'model.lua' TORCH_SNAPSHOT_PREFIX = 'snapshot' def subprocess_visible_devices(gpus): """ Calculates CUDA_VISIBLE_DEVICES for a subprocess """ if not isinstance(gpus, list): raise ValueError('gpus should be a list') gpus = [int(g) for g in gpus] old_cvd = os.environ.get('CUDA_VISIBLE_DEVICES', None) if old_cvd is None: real_gpus = gpus else: map_visible_to_real = {} for visible, real in enumerate(old_cvd.split(',')): map_visible_to_real[visible] = int(real) real_gpus = [] for visible_gpu in gpus: real_gpus.append(map_visible_to_real[visible_gpu]) return ','.join(str(g) for g in real_gpus) @subclass class TorchTrainTask(TrainTask): """ Trains a torch model """ TORCH_LOG = 'torch_output.log' def __init__(self, **kwargs): """ Arguments: network -- a NetParameter defining the network """ super(TorchTrainTask, self).__init__(**kwargs) # save network description to file with open(os.path.join(self.job_dir, TORCH_MODEL_FILE), "w") as outfile: outfile.write(self.network) self.pickver_task_torch_train = PICKLE_VERSION self.current_epoch = 0 self.loaded_snapshot_file = None self.loaded_snapshot_epoch = None self.image_mean = None self.classifier = None self.solver = None self.model_file = TORCH_MODEL_FILE self.train_file = constants.TRAIN_DB self.val_file = constants.VAL_DB self.snapshot_prefix = TORCH_SNAPSHOT_PREFIX self.log_file = self.TORCH_LOG self.digits_version = digits.__version__ def __getstate__(self): state = super(TorchTrainTask, self).__getstate__() # Don't pickle these things if 'labels' in state: del state['labels'] if 'image_mean' in state: del state['image_mean'] if 'classifier' in state: del state['classifier'] if 'torch_log' in state: del state['torch_log'] return state def __setstate__(self, state): super(TorchTrainTask, self).__setstate__(state) # Make changes to self self.loaded_snapshot_file = None self.loaded_snapshot_epoch = None # These things don't get pickled self.image_mean = None self.classifier = None # Task overrides @override def name(self): return 'Train Torch Model' @override def before_run(self): super(TorchTrainTask, self).before_run() self.torch_log = open(self.path(self.TORCH_LOG), 'a') self.saving_snapshot = False self.receiving_train_output = False self.receiving_val_output = False self.last_train_update = None self.displaying_network = False self.temp_unrecognized_output = [] return True def create_mean_file(self): filename = os.path.join(self.job_dir, constants.MEAN_FILE_IMAGE) # don't recreate file if it already exists if not os.path.exists(filename): mean_file = self.dataset.get_mean_file() assert mean_file is not None and mean_file.endswith('.binaryproto'), \ 'Mean subtraction required but dataset has no mean file in .binaryproto format' blob = caffe_pb2.BlobProto() with open(self.dataset.path(mean_file), 'rb') as infile: blob.ParseFromString(infile.read()) data = np.array(blob.data, dtype=np.uint8).reshape(blob.channels, blob.height, blob.width) if blob.channels == 3: # converting from BGR to RGB data = data[[2, 1, 0], ...] # channel swap # convert to (height, width, channels) data = data.transpose((1, 2, 0)) else: assert blob.channels == 1 # convert to (height, width) data = data[0] # save to file image = PIL.Image.fromarray(data) image.save(filename) return filename @override def task_arguments(self, resources, env): dataset_backend = self.dataset.get_backend() assert dataset_backend == 'lmdb' or dataset_backend == 'hdf5' args = [config_value('torch')['executable'], os.path.join( os.path.dirname(os.path.abspath(digits.__file__)), 'tools', 'torch', 'wrapper.lua'), 'main.lua', '--network=%s' % self.model_file.split(".")[0], '--epoch=%d' % int(self.train_epochs), '--networkDirectory=%s' % self.job_dir, '--save=%s' % self.job_dir, '--snapshotPrefix=%s' % self.snapshot_prefix, '--snapshotInterval=%s' % self.snapshot_interval, '--learningRate=%s' % self.learning_rate, '--policy=%s' % str(self.lr_policy['policy']), '--dbbackend=%s' % dataset_backend ] if self.batch_size is not None: args.append('--batchSize=%d' % self.batch_size) if self.use_mean != 'none': filename = self.create_mean_file() args.append('--mean=%s' % filename) if hasattr(self.dataset, 'labels_file'): args.append('--labels=%s' % self.dataset.path(self.dataset.labels_file)) train_feature_db_path = self.dataset.get_feature_db_path(constants.TRAIN_DB) train_label_db_path = self.dataset.get_label_db_path(constants.TRAIN_DB) val_feature_db_path = self.dataset.get_feature_db_path(constants.VAL_DB) val_label_db_path = self.dataset.get_label_db_path(constants.VAL_DB) args.append('--train=%s' % train_feature_db_path) if train_label_db_path: args.append('--train_labels=%s' % train_label_db_path) if val_feature_db_path: args.append('--validation=%s' % val_feature_db_path) if val_label_db_path: args.append('--validation_labels=%s' % val_label_db_path) # learning rate policy input parameters if self.lr_policy['policy'] == 'fixed': pass elif self.lr_policy['policy'] == 'step': args.append('--gamma=%s' % self.lr_policy['gamma']) args.append('--stepvalues=%s' % self.lr_policy['stepsize']) elif self.lr_policy['policy'] == 'multistep': args.append('--stepvalues=%s' % self.lr_policy['stepvalue']) args.append('--gamma=%s' % self.lr_policy['gamma']) elif self.lr_policy['policy'] == 'exp': args.append('--gamma=%s' % self.lr_policy['gamma']) elif self.lr_policy['policy'] == 'inv': args.append('--gamma=%s' % self.lr_policy['gamma']) args.append('--power=%s' % self.lr_policy['power']) elif self.lr_policy['policy'] == 'poly': args.append('--power=%s' % self.lr_policy['power']) elif self.lr_policy['policy'] == 'sigmoid': args.append('--stepvalues=%s' % self.lr_policy['stepsize']) args.append('--gamma=%s' % self.lr_policy['gamma']) if self.shuffle: args.append('--shuffle=yes') if self.crop_size: args.append('--crop=yes') args.append('--croplen=%d' % self.crop_size) if self.use_mean == 'pixel': args.append('--subtractMean=pixel') elif self.use_mean == 'image': args.append('--subtractMean=image') else: args.append('--subtractMean=none') if self.random_seed is not None: args.append('--seed=%s' % self.random_seed) if self.solver_type == 'SGD': args.append('--optimization=sgd') elif self.solver_type == 'NESTEROV': args.append('--optimization=nag') elif self.solver_type == 'ADAGRAD': args.append('--optimization=adagrad') elif self.solver_type == 'RMSPROP': args.append('--optimization=rmsprop') elif self.solver_type == 'ADADELTA': args.append('--optimization=adadelta') elif self.solver_type == 'ADAM': args.append('--optimization=adam') else: raise ValueError('Unknown solver_type %s' % self.solver_type) if self.val_interval > 0: args.append('--interval=%s' % self.val_interval) if 'gpus' in resources: identifiers = [] for identifier, value in resources['gpus']: identifiers.append(identifier) # make all selected GPUs visible to the Torch 'th' process. # don't make other GPUs visible though since Torch will load # CUDA libraries and allocate memory on all visible GPUs by # default. env['CUDA_VISIBLE_DEVICES'] = subprocess_visible_devices(identifiers) # switch to GPU mode args.append('--type=cuda') else: # switch to CPU mode args.append('--type=float') if self.pretrained_model: filenames = self.pretrained_model.split(os.path.pathsep) if len(filenames) > 1: raise ValueError('Torch does not support multiple pretrained model files') args.append('--weights=%s' % self.path(filenames[0])) # Augmentations assert self.data_aug['flip'] in ['none', 'fliplr', 'flipud', 'fliplrud'], 'Bad or unknown flag "flip"' args.append('--augFlip=%s' % self.data_aug['flip']) assert self.data_aug['quad_rot'] in ['none', 'rot90', 'rot180', 'rotall'], 'Bad or unknown flag "quad_rot"' args.append('--augQuadRot=%s' % self.data_aug['quad_rot']) if self.data_aug['rot']: args.append('--augRot=%s' % self.data_aug['rot']) if self.data_aug['scale']: args.append('--augScale=%s' % self.data_aug['scale']) if self.data_aug['noise']: args.append('--augNoise=%s' % self.data_aug['noise']) if self.data_aug['hsv_use']: args.append('--augHSVh=%s' % self.data_aug['hsv_h']) args.append('--augHSVs=%s' % self.data_aug['hsv_s']) args.append('--augHSVv=%s' % self.data_aug['hsv_v']) else: args.append('--augHSVh=0') args.append('--augHSVs=0') args.append('--augHSVv=0') return args @override def process_output(self, line): regex = re.compile('\x1b\[[0-9;]*m', re.UNICODE) # TODO: need to include regular expression for MAC color codes line = regex.sub('', line).strip() self.torch_log.write('%s\n' % line) self.torch_log.flush() # parse torch output timestamp, level, message = self.preprocess_output_torch(line) # return false when unrecognized output is encountered if not level: # network display in progress if self.displaying_network: self.temp_unrecognized_output.append(line) return True return False if not message: return True # network display ends if self.displaying_network: if message.startswith('Network definition ends'): self.temp_unrecognized_output = [] self.displaying_network = False return True # by default Lua prints infinite numbers as 'inf' however Torch tensor may use 'nan' to represent infinity float_exp = '([-]?inf|nan|[-+]?[0-9]*\.?[0-9]+(e[-+]?[0-9]+)?)' # loss and learning rate updates match = re.match(r'Training \(epoch (\d+\.?\d*)\): \w*loss\w* = %s, lr = %s' % (float_exp, float_exp), message) if match: index = float(match.group(1)) l = match.group(2) assert not('inf' in l or 'nan' in l), \ 'Network reported %s for training loss. Try decreasing your learning rate.' % l l = float(l) lr = match.group(4) lr = float(lr) # epoch updates self.send_progress_update(index) self.save_train_output('loss', 'SoftmaxWithLoss', l) self.save_train_output('learning_rate', 'LearningRate', lr) self.logger.debug(message) return True # testing loss and accuracy updates match = re.match(r'Validation \(epoch (\d+\.?\d*)\): \w*loss\w* = %s(, accuracy = %s)?' % (float_exp, float_exp), message, flags=re.IGNORECASE) if match: index = float(match.group(1)) l = match.group(2) a = match.group(5) # note: validation loss could have diverged however # if the training loss is still finite, there is a slim possibility # that the network keeps learning something useful, so we don't treat # infinite validation loss as a fatal error if not('inf' in l or 'nan' in l): l = float(l) self.logger.debug('Network validation loss #%s: %s' % (index, l)) # epoch updates self.send_progress_update(index) self.save_val_output('loss', 'SoftmaxWithLoss', l) if a and a.lower() != 'inf' and a.lower() != '-inf': a = float(a) self.logger.debug('Network accuracy #%s: %s' % (index, a)) self.save_val_output('accuracy', 'Accuracy', a) return True # snapshot saved if self.saving_snapshot: if not message.startswith('Snapshot saved'): self.logger.warning( 'Torch output format seems to have changed. ' 'Expected "Snapshot saved..." after "Snapshotting to..."') else: self.logger.info('Snapshot saved.') # to print file name here, you can use "message" self.detect_snapshots() self.send_snapshot_update() self.saving_snapshot = False return True # snapshot starting match = re.match(r'Snapshotting to (.*)\s*$', message) if match: self.saving_snapshot = True return True # network display starting if message.startswith('Network definition:'): self.displaying_network = True return True if level in ['error', 'critical']: self.logger.error('%s: %s' % (self.name(), message)) self.exception = message return True # skip remaining info and warn messages return True @staticmethod def preprocess_output_torch(line): """ Takes line of output and parses it according to caffe's output format Returns (timestamp, level, message) or (None, None, None) """ # NOTE: This must change when the logging format changes # LMMDD HH:MM:SS.MICROS pid file:lineno] message match = re.match(r'(\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2})\s\[(\w+)\s*]\s+(\S.*)$', line) if match: timestamp = time.mktime(time.strptime(match.group(1), '%Y-%m-%d %H:%M:%S')) level = match.group(2) message = match.group(3) if level == 'INFO': level = 'info' elif level == 'WARNING': level = 'warning' elif level == 'ERROR': level = 'error' elif level == 'FAIL': # FAIL level = 'critical' return (timestamp, level, message) else: return (None, None, None) def send_snapshot_update(self): """ Sends socketio message about the snapshot list """ # TODO: move to TrainTask from digits.webapp import socketio socketio.emit('task update', { 'task': self.html_id(), 'update': 'snapshots', 'data': self.snapshot_list(), }, namespace='/jobs', room=self.job_id, ) # TrainTask overrides @override def after_run(self): if self.temp_unrecognized_output: if self.traceback: self.traceback = self.traceback + ('\n'.join(self.temp_unrecognized_output)) else: self.traceback = '\n'.join(self.temp_unrecognized_output) self.temp_unrecognized_output = [] self.torch_log.close() @override def after_runtime_error(self): if os.path.exists(self.path(self.TORCH_LOG)): output = subprocess.check_output(['tail', '-n40', self.path(self.TORCH_LOG)]) lines = [] for line in output.split('\n'): # parse torch header timestamp, level, message = self.preprocess_output_torch(line) if message: lines.append(message) # return the last 20 lines traceback = '\n\nLast output:\n' + '\n'.join(lines[len(lines) - 20:]) if len(lines) > 0 else '' if self.traceback: self.traceback = self.traceback + traceback else: self.traceback = traceback if 'DIGITS_MODE_TEST' in os.environ: print output @override def detect_snapshots(self): self.snapshots = [] snapshot_dir = os.path.join(self.job_dir, os.path.dirname(self.snapshot_prefix)) snapshots = [] for filename in os.listdir(snapshot_dir): # find models match = re.match(r'%s_(\d+)\.?(\d*)(_Weights|_Model)\.t7' % os.path.basename(self.snapshot_prefix), filename) if match: epoch = 0 if match.group(2) == '': epoch = int(match.group(1)) else: epoch = float(match.group(1) + '.' + match.group(2)) snapshots.append(( os.path.join(snapshot_dir, filename), epoch ) ) self.snapshots = sorted(snapshots, key=lambda tup: tup[1]) return len(self.snapshots) > 0 @override def est_next_snapshot(self): # TODO: Currently this function is not in use. Probably in future we may have to implement this return None @override def infer_one(self, data, snapshot_epoch=None, layers=None, gpu=None, resize=True): # resize parameter is unused return self.infer_one_image(data, snapshot_epoch=snapshot_epoch, layers=layers, gpu=gpu) def infer_one_image(self, image, snapshot_epoch=None, layers=None, gpu=None): """ Classify an image Returns (predictions, visualizations) predictions -- an array of [ (label, confidence), ...] for each label, sorted by confidence visualizations -- an array of (layer_name, activations, weights) for the specified layers Returns (None, None) if something goes wrong Arguments: image -- a np.array Keyword arguments: snapshot_epoch -- which snapshot to use layers -- which layer activation[s] and weight[s] to visualize """ temp_image_handle, temp_image_path = tempfile.mkstemp(suffix='.png') os.close(temp_image_handle) image = PIL.Image.fromarray(image) try: image.save(temp_image_path, format='png') except KeyError: error_message = 'Unable to save file to "%s"' % temp_image_path self.logger.error(error_message) raise digits.inference.errors.InferenceError(error_message) file_to_load = self.get_snapshot(snapshot_epoch) args = [config_value('torch')['executable'], os.path.join( os.path.dirname(os.path.abspath(digits.__file__)), 'tools', 'torch', 'wrapper.lua'), 'test.lua', '--image=%s' % temp_image_path, '--network=%s' % self.model_file.split(".")[0], '--networkDirectory=%s' % self.job_dir, '--snapshot=%s' % file_to_load, '--allPredictions=yes', ] if hasattr(self.dataset, 'labels_file'): args.append('--labels=%s' % self.dataset.path(self.dataset.labels_file)) if self.use_mean != 'none': filename = self.create_mean_file() args.append('--mean=%s' % filename) if self.use_mean == 'pixel': args.append('--subtractMean=pixel') elif self.use_mean == 'image': args.append('--subtractMean=image') else: args.append('--subtractMean=none') if self.crop_size: args.append('--crop=yes') args.append('--croplen=%d' % self.crop_size) if layers == 'all': args.append('--visualization=yes') args.append('--save=%s' % self.job_dir) # Convert them all to strings args = [str(x) for x in args] regex = re.compile('\x1b\[[0-9;]*m', re.UNICODE) # TODO: need to include regular expression for MAC color codes self.logger.info('%s classify one task started.' % self.get_framework_id()) unrecognized_output = [] predictions = [] self.visualization_file = None env = os.environ.copy() if gpu is not None: args.append('--type=cuda') # make only the selected GPU visible env['CUDA_VISIBLE_DEVICES'] = subprocess_visible_devices([gpu]) else: args.append('--type=float') p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=self.job_dir, close_fds=True, env=env, ) try: while p.poll() is None: for line in utils.nonblocking_readlines(p.stdout): if self.aborted.is_set(): p.terminate() raise digits.inference.errors.InferenceError( '%s classify one task got aborted. error code - %d' % (self.get_framework_id(), p.returncode)) if line is not None: # Remove color codes and whitespace line = regex.sub('', line).strip() if line: if not self.process_test_output(line, predictions, 'one'): self.logger.warning('%s classify one task unrecognized input: %s' % (self.get_framework_id(), line.strip())) unrecognized_output.append(line) else: time.sleep(0.05) except Exception as e: if p.poll() is None: p.terminate() error_message = '' if type(e) == digits.inference.errors.InferenceError: error_message = e.__str__() else: error_message = '%s classify one task failed with error code %d \n %s' % ( self.get_framework_id(), p.returncode, str(e)) self.logger.error(error_message) if unrecognized_output: unrecognized_output = '\n'.join(unrecognized_output) error_message = error_message + unrecognized_output raise digits.inference.errors.InferenceError(error_message) finally: self.after_test_run(temp_image_path) if p.returncode != 0: error_message = '%s classify one task failed with error code %d' % (self.get_framework_id(), p.returncode) self.logger.error(error_message) if unrecognized_output: unrecognized_output = '\n'.join(unrecognized_output) error_message = error_message + unrecognized_output raise digits.inference.errors.InferenceError(error_message) else: self.logger.info('%s classify one task completed.' % self.get_framework_id()) predictions = {'output': np.array(predictions)} visualizations = [] if layers == 'all' and self.visualization_file: vis_db = h5py.File(self.visualization_file, 'r') # the HDF5 database is organized as follows: # <root> # |- layers # |- 1 # | |- name # | |- activations # | |- weights # |- 2 for layer_id, layer in vis_db['layers'].items(): layer_desc = layer['name'][...].tostring() if 'Sequential' in layer_desc or 'Parallel' in layer_desc: # ignore containers continue idx = int(layer_id) # activations if 'activations' in layer: data = np.array(layer['activations'][...]) # skip batch dimension if len(data.shape) > 1 and data.shape[0] == 1: data = data[0] vis = utils.image.get_layer_vis_square(data) mean, std, hist = self.get_layer_statistics(data) visualizations.append( { 'id': idx, 'name': layer_desc, 'vis_type': 'Activations', 'vis': vis, 'data_stats': { 'shape': data.shape, 'mean': mean, 'stddev': std, 'histogram': hist, } } ) # weights if 'weights' in layer: data = np.array(layer['weights'][...]) if 'Linear' not in layer_desc: vis = utils.image.get_layer_vis_square(data) else: # Linear (inner product) layers have too many weights # to display vis = None mean, std, hist = self.get_layer_statistics(data) parameter_count = reduce(operator.mul, data.shape, 1) if 'bias' in layer: bias = np.array(layer['bias'][...]) parameter_count += reduce(operator.mul, bias.shape, 1) visualizations.append( { 'id': idx, 'name': layer_desc, 'vis_type': 'Weights', 'vis': vis, 'param_count': parameter_count, 'data_stats': { 'shape': data.shape, 'mean': mean, 'stddev': std, 'histogram': hist, } } ) # sort by layer ID visualizations = sorted(visualizations, key=lambda x: x['id']) return (predictions, visualizations) def get_layer_statistics(self, data): """ Returns statistics for the given layer data: (mean, standard deviation, histogram) histogram -- [y, x, ticks] Arguments: data -- a np.ndarray """ # XXX These calculations can be super slow mean = np.mean(data) std = np.std(data) y, x = np.histogram(data, bins=20) y = list(y) ticks = x[[0, len(x) / 2, -1]] x = [(x[i] + x[i + 1]) / 2.0 for i in xrange(len(x) - 1)] ticks = list(ticks) return (mean, std, [y, x, ticks]) def after_test_run(self, temp_image_path): try: os.remove(temp_image_path) except OSError: pass def process_test_output(self, line, predictions, test_category): # parse torch output timestamp, level, message = self.preprocess_output_torch(line) # return false when unrecognized output is encountered if not (level or message): return False if not message: return True float_exp = '([-]?inf|nan|[-+]?[0-9]*\.?[0-9]+(e[-+]?[0-9]+)?)' # format of output while testing single image match = re.match(r'For image \d+, predicted class \d+: \d+ \((.*?)\) %s' % (float_exp), message) if match: label = match.group(1) confidence = match.group(2) assert not('inf' in confidence or 'nan' in confidence), \ 'Network reported %s for confidence value. Please check image and network' % label confidence = float(confidence) predictions.append((label, confidence)) return True # format of output while testing multiple images match = re.match(r'Predictions for image \d+: (.*)', message) if match: values = match.group(1).strip() # 'values' should contain a JSON representation of # the prediction predictions.append(eval(values)) return True # path to visualization file match = re.match(r'Saving visualization to (.*)', message) if match: self.visualization_file = match.group(1).strip() return True # displaying info and warn messages as we aren't maintaining separate log file for model testing if level == 'info': self.logger.debug('%s classify %s task : %s' % (self.get_framework_id(), test_category, message)) return True if level == 'warning': self.logger.warning('%s classify %s task : %s' % (self.get_framework_id(), test_category, message)) return True if level in ['error', 'critical']: raise digits.inference.errors.InferenceError( '%s classify %s task failed with error message - %s' % (self.get_framework_id(), test_category, message)) return True # control never reach this line. It can be removed. @override def infer_many(self, data, snapshot_epoch=None, gpu=None, resize=True): # resize parameter is unused return self.infer_many_images(data, snapshot_epoch=snapshot_epoch, gpu=gpu) def infer_many_images(self, images, snapshot_epoch=None, gpu=None): """ Returns (labels, results): labels -- an array of strings results -- a 2D np array: [ [image0_label0_confidence, image0_label1_confidence, ...], [image1_label0_confidence, image1_label1_confidence, ...], ... ] Arguments: images -- a list of np.arrays Keyword arguments: snapshot_epoch -- which snapshot to use """ # create a temporary folder to store images and a temporary file # to store a list of paths to the images temp_dir_path = tempfile.mkdtemp() try: # this try...finally clause is used to clean up the temp directory in any case temp_imglist_handle, temp_imglist_path = tempfile.mkstemp(dir=temp_dir_path, suffix='.txt') for image in images: temp_image_handle, temp_image_path = tempfile.mkstemp( dir=temp_dir_path, suffix='.png') image = PIL.Image.fromarray(image) try: image.save(temp_image_path, format='png') except KeyError: error_message = 'Unable to save file to "%s"' % temp_image_path self.logger.error(error_message) raise digits.inference.errors.InferenceError(error_message) os.write(temp_imglist_handle, "%s\n" % temp_image_path) os.close(temp_image_handle) os.close(temp_imglist_handle) file_to_load = self.get_snapshot(snapshot_epoch) args = [config_value('torch')['executable'], os.path.join( os.path.dirname(os.path.abspath(digits.__file__)), 'tools', 'torch', 'wrapper.lua'), 'test.lua', '--testMany=yes', '--allPredictions=yes', # all predictions are grabbed and formatted as required by DIGITS '--image=%s' % str(temp_imglist_path), '--network=%s' % self.model_file.split(".")[0], '--networkDirectory=%s' % self.job_dir, '--snapshot=%s' % file_to_load, ] if hasattr(self.dataset, 'labels_file'): args.append('--labels=%s' % self.dataset.path(self.dataset.labels_file)) if self.use_mean != 'none': filename = self.create_mean_file() args.append('--mean=%s' % filename) if self.use_mean == 'pixel': args.append('--subtractMean=pixel') elif self.use_mean == 'image': args.append('--subtractMean=image') else: args.append('--subtractMean=none') if self.crop_size: args.append('--crop=yes') args.append('--croplen=%d' % self.crop_size) # Convert them all to strings args = [str(x) for x in args] # TODO: need to include regular expression for MAC color codes regex = re.compile('\x1b\[[0-9;]*m', re.UNICODE) self.logger.info('%s classify many task started.' % self.name()) env = os.environ.copy() if gpu is not None: args.append('--type=cuda') # make only the selected GPU visible env['CUDA_VISIBLE_DEVICES'] = subprocess_visible_devices([gpu]) else: args.append('--type=float') unrecognized_output = [] predictions = [] p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=self.job_dir, close_fds=True, env=env ) try: while p.poll() is None: for line in utils.nonblocking_readlines(p.stdout): if self.aborted.is_set(): p.terminate() raise digits.inference.errors.InferenceError( '%s classify many task got aborted. error code - %d' % (self.get_framework_id(), p.returncode)) if line is not None: # Remove whitespace and color codes. # Color codes are appended to beginning and end of line by torch binary # i.e., 'th'. Check the below link for more information # https://groups.google.com/forum/#!searchin/torch7/color$20codes/torch7/8O_0lSgSzuA/Ih6wYg9fgcwJ # noqa line = regex.sub('', line).strip() if line: if not self.process_test_output(line, predictions, 'many'): self.logger.warning('%s classify many task unrecognized input: %s' % (self.get_framework_id(), line.strip())) unrecognized_output.append(line) else: time.sleep(0.05) except Exception as e: if p.poll() is None: p.terminate() error_message = '' if type(e) == digits.inference.errors.InferenceError: error_message = e.__str__() else: error_message = '%s classify many task failed with error code %d \n %s' % ( self.get_framework_id(), p.returncode, str(e)) self.logger.error(error_message) if unrecognized_output: unrecognized_output = '\n'.join(unrecognized_output) error_message = error_message + unrecognized_output raise digits.inference.errors.InferenceError(error_message) if p.returncode != 0: error_message = '%s classify many task failed with error code %d' % ( self.get_framework_id(), p.returncode) self.logger.error(error_message) if unrecognized_output: unrecognized_output = '\n'.join(unrecognized_output) error_message = error_message + unrecognized_output raise digits.inference.errors.InferenceError(error_message) else: self.logger.info('%s classify many task completed.' % self.get_framework_id()) finally: shutil.rmtree(temp_dir_path) # task.infer_one() expects dictionary in return value return {'output': np.array(predictions)} def has_model(self): """ Returns True if there is a model that can be used """ return len(self.snapshots) != 0 @override def get_model_files(self): """ return paths to model files """ return { "Network": self.model_file } @override def get_network_desc(self): """ return text description of network """ with open(os.path.join(self.job_dir, TORCH_MODEL_FILE), "r") as infile: desc = infile.read() return desc @override def get_task_stats(self, epoch=-1): """ return a dictionary of task statistics """ loc, mean_file = os.path.split(self.dataset.get_mean_file()) stats = { "image dimensions": self.dataset.get_feature_dims(), "mean file": mean_file, "snapshot file": self.get_snapshot_filename(epoch), "model file": self.model_file, "framework": "torch" } if hasattr(self, "digits_version"): stats.update({"digits version": self.digits_version}) if hasattr(self.dataset, "resize_mode"): stats.update({"image resize mode": self.dataset.resize_mode}) if hasattr(self.dataset, "labels_file"): stats.update({"labels file": self.dataset.labels_file}) return stats
DIGITS-master
digits/model/tasks/torch_train.py
# Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import import operator import os import re import shutil import subprocess import tempfile import time import sys import h5py import numpy as np from .train import TrainTask import digits from digits import utils from digits.utils import subclass, override, constants import tensorflow as tf # NOTE: Increment this everytime the pickled object changes PICKLE_VERSION = 1 # Constants TENSORFLOW_MODEL_FILE = 'network.py' TENSORFLOW_SNAPSHOT_PREFIX = 'snapshot' TIMELINE_PREFIX = 'timeline' def _int64_feature(value): return tf.train.Feature(int64_list=tf.train.Int64List(value=[value])) def _bytes_feature(value): return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value])) def _float_array_feature(value): return tf.train.Feature(float_list=tf.train.FloatList(value=value)) def subprocess_visible_devices(gpus): """ Calculates CUDA_VISIBLE_DEVICES for a subprocess """ if not isinstance(gpus, list): raise ValueError('gpus should be a list') gpus = [int(g) for g in gpus] old_cvd = os.environ.get('CUDA_VISIBLE_DEVICES', None) if old_cvd is None: real_gpus = gpus else: map_visible_to_real = {} for visible, real in enumerate(old_cvd.split(',')): map_visible_to_real[visible] = int(real) real_gpus = [] for visible_gpu in gpus: real_gpus.append(map_visible_to_real[visible_gpu]) return ','.join(str(g) for g in real_gpus) @subclass class TensorflowTrainTask(TrainTask): """ Trains a tensorflow model """ TENSORFLOW_LOG = 'tensorflow_output.log' def __init__(self, **kwargs): """ Arguments: network -- a NetParameter defining the network """ super(TensorflowTrainTask, self).__init__(**kwargs) # save network description to file with open(os.path.join(self.job_dir, TENSORFLOW_MODEL_FILE), "w") as outfile: outfile.write(self.network) self.pickver_task_tensorflow_train = PICKLE_VERSION self.current_epoch = 0 self.loaded_snapshot_file = None self.loaded_snapshot_epoch = None self.image_mean = None self.classifier = None self.solver = None self.model_file = TENSORFLOW_MODEL_FILE self.train_file = constants.TRAIN_DB self.val_file = constants.VAL_DB self.snapshot_prefix = TENSORFLOW_SNAPSHOT_PREFIX self.log_file = self.TENSORFLOW_LOG def __getstate__(self): state = super(TensorflowTrainTask, self).__getstate__() # Don't pickle these things if 'labels' in state: del state['labels'] if 'image_mean' in state: del state['image_mean'] if 'classifier' in state: del state['classifier'] if 'tensorflow_log' in state: del state['tensorflow_log'] return state def __setstate__(self, state): super(TensorflowTrainTask, self).__setstate__(state) # Make changes to self self.loaded_snapshot_file = None self.loaded_snapshot_epoch = None # These things don't get pickled self.image_mean = None self.classifier = None # Task overrides @override def name(self): return 'Train Tensorflow Model' @override def before_run(self): super(TensorflowTrainTask, self).before_run() self.tensorflow_log = open(self.path(self.TENSORFLOW_LOG), 'a') self.saving_snapshot = False self.receiving_train_output = False self.receiving_val_output = False self.last_train_update = None self.displaying_network = False self.temp_unrecognized_output = [] return True @override def get_snapshot(self, epoch=-1, download=False, frozen_file=False): """ return snapshot file for specified epoch """ snapshot_pre = None if len(self.snapshots) == 0: return "no snapshots" if epoch == -1 or not epoch: epoch = self.snapshots[-1][1] snapshot_pre = self.snapshots[-1][0] else: for f, e in self.snapshots: if e == epoch: snapshot_pre = f break if not snapshot_pre: raise ValueError('Invalid epoch') if download: snapshot_file = snapshot_pre + ".data-00000-of-00001" meta_file = snapshot_pre + ".meta" index_file = snapshot_pre + ".index" snapshot_files = [snapshot_file, meta_file, index_file] elif frozen_file: snapshot_files = os.path.join(os.path.dirname(snapshot_pre), "frozen_model.pb") else: snapshot_files = snapshot_pre return snapshot_files @override def task_arguments(self, resources, env): args = [sys.executable, os.path.join(os.path.dirname(os.path.abspath(digits.__file__)), 'tools', 'tensorflow', 'main.py'), '--network=%s' % self.model_file, '--epoch=%d' % int(self.train_epochs), '--networkDirectory=%s' % self.job_dir, '--save=%s' % self.job_dir, '--snapshotPrefix=%s' % self.snapshot_prefix, '--snapshotInterval=%s' % self.snapshot_interval, '--lr_base_rate=%s' % self.learning_rate, '--lr_policy=%s' % str(self.lr_policy['policy']) ] if self.batch_size is not None: args.append('--batch_size=%d' % self.batch_size) if self.use_mean != 'none': mean_file = self.dataset.get_mean_file() assert mean_file is not None, 'Failed to retrieve mean file.' args.append('--mean=%s' % self.dataset.path(mean_file)) if hasattr(self.dataset, 'labels_file'): args.append('--labels_list=%s' % self.dataset.path(self.dataset.labels_file)) train_feature_db_path = self.dataset.get_feature_db_path(constants.TRAIN_DB) train_label_db_path = self.dataset.get_label_db_path(constants.TRAIN_DB) val_feature_db_path = self.dataset.get_feature_db_path(constants.VAL_DB) val_label_db_path = self.dataset.get_label_db_path(constants.VAL_DB) args.append('--train_db=%s' % train_feature_db_path) if train_label_db_path: args.append('--train_labels=%s' % train_label_db_path) if val_feature_db_path: args.append('--validation_db=%s' % val_feature_db_path) if val_label_db_path: args.append('--validation_labels=%s' % val_label_db_path) # learning rate policy input parameters if self.lr_policy['policy'] == 'fixed': pass elif self.lr_policy['policy'] == 'step': args.append('--lr_gamma=%s' % self.lr_policy['gamma']) args.append('--lr_stepvalues=%s' % self.lr_policy['stepsize']) elif self.lr_policy['policy'] == 'multistep': args.append('--lr_stepvalues=%s' % self.lr_policy['stepvalue']) args.append('--lr_gamma=%s' % self.lr_policy['gamma']) elif self.lr_policy['policy'] == 'exp': args.append('--lr_gamma=%s' % self.lr_policy['gamma']) elif self.lr_policy['policy'] == 'inv': args.append('--lr_gamma=%s' % self.lr_policy['gamma']) args.append('--lr_power=%s' % self.lr_policy['power']) elif self.lr_policy['policy'] == 'poly': args.append('--lr_power=%s' % self.lr_policy['power']) elif self.lr_policy['policy'] == 'sigmoid': args.append('--lr_stepvalues=%s' % self.lr_policy['stepsize']) args.append('--lr_gamma=%s' % self.lr_policy['gamma']) if self.shuffle: args.append('--shuffle=1') if self.crop_size: args.append('--croplen=%d' % self.crop_size) if self.use_mean == 'pixel': args.append('--subtractMean=pixel') elif self.use_mean == 'image': args.append('--subtractMean=image') else: args.append('--subtractMean=none') if self.random_seed is not None: args.append('--seed=%s' % self.random_seed) if self.solver_type == 'SGD': args.append('--optimization=sgd') elif self.solver_type == 'ADADELTA': args.append('--optimization=adadelta') elif self.solver_type == 'ADAGRAD': args.append('--optimization=adagrad') elif self.solver_type == 'ADAGRADDA': args.append('--optimization=adagradda') elif self.solver_type == 'MOMENTUM': args.append('--optimization=momentum') elif self.solver_type == 'ADAM': args.append('--optimization=adam') elif self.solver_type == 'FTRL': args.append('--optimization=ftrl') elif self.solver_type == 'RMSPROP': args.append('--optimization=rmsprop') else: raise ValueError('Unknown solver_type %s' % self.solver_type) if self.val_interval is not None: args.append('--validation_interval=%d' % self.val_interval) # if self.traces_interval is not None: args.append('--log_runtime_stats_per_step=%d' % self.traces_interval) if 'gpus' in resources: identifiers = [] for identifier, value in resources['gpus']: identifiers.append(identifier) # make all selected GPUs visible to the process. # don't make other GPUs visible though since the process will load # CUDA libraries and allocate memory on all visible GPUs by # default. env['CUDA_VISIBLE_DEVICES'] = subprocess_visible_devices(identifiers) if self.pretrained_model: args.append('--weights=%s' % self.path(self.pretrained_model)) # Augmentations assert self.data_aug['flip'] in ['none', 'fliplr', 'flipud', 'fliplrud'], 'Bad or unknown flag "flip"' args.append('--augFlip=%s' % self.data_aug['flip']) if self.data_aug['noise']: args.append('--augNoise=%s' % self.data_aug['noise']) if self.data_aug['contrast']: args.append('--augContrast=%s' % self.data_aug['contrast']) if self.data_aug['whitening']: args.append('--augWhitening=1') if self.data_aug['hsv_use']: args.append('--augHSVh=%s' % self.data_aug['hsv_h']) args.append('--augHSVs=%s' % self.data_aug['hsv_s']) args.append('--augHSVv=%s' % self.data_aug['hsv_v']) else: args.append('--augHSVh=0') args.append('--augHSVs=0') args.append('--augHSVv=0') return args @override def process_output(self, line): self.tensorflow_log.write('%s\n' % line) self.tensorflow_log.flush() # parse tensorflow output timestamp, level, message = self.preprocess_output_tensorflow(line) # return false when unrecognized output is encountered if not level: # network display in progress if self.displaying_network: self.temp_unrecognized_output.append(line) return True return False if not message: return True # network display ends if self.displaying_network: if message.startswith('Network definition ends'): self.temp_unrecognized_output = [] self.displaying_network = False return True # Distinguish between a Validation and Training stage epoch pattern_stage_epoch = re.compile(r'(Validation|Training)\ \(\w+\ ([^\ ]+)\)\:\ (.*)') for (stage, epoch, kvlist) in re.findall(pattern_stage_epoch, message): epoch = float(epoch) self.send_progress_update(epoch) pattern_key_val = re.compile(r'([\w\-_]+)\ =\ ([^,^\ ]+)') # Now iterate through the keys and values on this line dynamically for (key, value) in re.findall(pattern_key_val, kvlist): assert not('Inf' in value or 'NaN' in value), 'Network reported %s for %s.' % (value, key) value = float(value) if key == 'lr': key = 'learning_rate' # Convert to special DIGITS key for learning rate if stage == 'Training': self.save_train_output(key, key, value) elif stage == 'Validation': self.save_val_output(key, key, value) self.logger.debug('Network validation %s #%s: %s' % (key, epoch, value)) else: self.logger.error('Unknown stage found other than training or validation: %s' % (stage)) self.logger.debug(message) return True # timeline trace saved if message.startswith('Timeline trace written to'): self.logger.info(message) self.detect_timeline_traces() return True # snapshot saved if self.saving_snapshot: if message.startswith('Snapshot saved'): self.logger.info(message) self.detect_snapshots() self.send_snapshot_update() self.saving_snapshot = False return True # snapshot starting match = re.match(r'Snapshotting to (.*)\s*$', message) if match: self.saving_snapshot = True return True # network display starting if message.startswith('Network definition:'): self.displaying_network = True return True if level in ['error', 'critical']: self.logger.error('%s: %s' % (self.name(), message)) self.exception = message return True # skip remaining info and warn messages return True @staticmethod def preprocess_output_tensorflow(line): """ Takes line of output and parses it according to tensorflow's output format Returns (timestamp, level, message) or (None, None, None) """ # NOTE: This must change when the logging format changes # LMMDD HH:MM:SS.MICROS pid file:lineno] message match = re.match(r'(\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2})\s\[(\w+)\s*]\s+(\S.*)$', line) if match: timestamp = time.mktime(time.strptime(match.group(1), '%Y-%m-%d %H:%M:%S')) level = match.group(2) message = match.group(3) if level == 'INFO': level = 'info' elif level == 'WARNING': level = 'warning' elif level == 'ERROR': level = 'error' elif level == 'FAIL': # FAIL level = 'critical' return (timestamp, level, message) else: # self.logger.warning('Unrecognized task output "%s"' % line) return (None, None, None) def send_snapshot_update(self): """ Sends socketio message about the snapshot list """ # TODO: move to TrainTask from digits.webapp import socketio socketio.emit('task update', {'task': self.html_id(), 'update': 'snapshots', 'data': self.snapshot_list()}, namespace='/jobs', room=self.job_id) # TrainTask overrides @override def after_run(self): if self.temp_unrecognized_output: if self.traceback: self.traceback = self.traceback + ('\n'.join(self.temp_unrecognized_output)) else: self.traceback = '\n'.join(self.temp_unrecognized_output) self.temp_unrecognized_output = [] self.tensorflow_log.close() @override def after_runtime_error(self): if os.path.exists(self.path(self.TENSORFLOW_LOG)): output = subprocess.check_output(['tail', '-n40', self.path(self.TENSORFLOW_LOG)]) lines = [] for line in output.split('\n'): # parse tensorflow header timestamp, level, message = self.preprocess_output_tensorflow(line) if message: lines.append(message) # return the last 20 lines traceback = '\n\nLast output:\n' + '\n'.join(lines[len(lines)-20:]) if len(lines) > 0 else '' if self.traceback: self.traceback = self.traceback + traceback else: self.traceback = traceback if 'DIGITS_MODE_TEST' in os.environ: print output @override def detect_timeline_traces(self): timeline_traces = [] for filename in os.listdir(self.job_dir): # find timeline jsons match = re.match(r'%s_(.*)\.json$' % TIMELINE_PREFIX, filename) if match: step = int(match.group(1)) timeline_traces.append((os.path.join(self.job_dir, filename), step)) self.timeline_traces = sorted(timeline_traces, key=lambda tup: tup[1]) return len(self.timeline_traces) > 0 @override def detect_snapshots(self): self.snapshots = [] snapshots = [] for filename in os.listdir(self.job_dir): # find models match = re.match(r'%s_(\d+)\.?(\d*)\.ckpt\.index$' % self.snapshot_prefix, filename) if match: epoch = 0 # remove '.index' suffix from filename filename = filename[:-6] if match.group(2) == '': epoch = int(match.group(1)) else: epoch = float(match.group(1) + '.' + match.group(2)) snapshots.append((os.path.join(self.job_dir, filename), epoch)) self.snapshots = sorted(snapshots, key=lambda tup: tup[1]) return len(self.snapshots) > 0 @override def est_next_snapshot(self): # TODO: Currently this function is not in use. Probably in future we may have to implement this return None @override def infer_one(self, data, snapshot_epoch=None, layers=None, gpu=None, resize=True): # resize parameter is unused return self.infer_one_image(data, snapshot_epoch=snapshot_epoch, layers=layers, gpu=gpu) def infer_one_image(self, image, snapshot_epoch=None, layers=None, gpu=None): """ Classify an image Returns (predictions, visualizations) predictions -- an array of [ (label, confidence), ...] for each label, sorted by confidence visualizations -- an array of (layer_name, activations, weights) for the specified layers Returns (None, None) if something goes wrong Arguments: image -- a np.array Keyword arguments: snapshot_epoch -- which snapshot to use layers -- which layer activation[s] and weight[s] to visualize """ temp_image_handle, temp_image_path = tempfile.mkstemp(suffix='.tfrecords') os.close(temp_image_handle) if image.ndim < 3: image = image[..., np.newaxis] writer = tf.python_io.TFRecordWriter(temp_image_path) image = image.astype('float') record = tf.train.Example(features=tf.train.Features(feature={ 'height': _int64_feature(image.shape[0]), 'width': _int64_feature(image.shape[1]), 'depth': _int64_feature(image.shape[2]), 'image_raw': _float_array_feature(image.flatten()), 'label': _int64_feature(0), 'encoding': _int64_feature(0)})) writer.write(record.SerializeToString()) writer.close() file_to_load = self.get_snapshot(snapshot_epoch) args = [sys.executable, os.path.join(os.path.dirname(os.path.abspath(digits.__file__)), 'tools', 'tensorflow', 'main.py'), '--inference_db=%s' % temp_image_path, '--network=%s' % self.model_file, '--networkDirectory=%s' % self.job_dir, '--weights=%s' % file_to_load, '--allPredictions=1', '--batch_size=1', ] if hasattr(self.dataset, 'labels_file'): args.append('--labels_list=%s' % self.dataset.path(self.dataset.labels_file)) if self.use_mean != 'none': mean_file = self.dataset.get_mean_file() assert mean_file is not None, 'Failed to retrieve mean file.' args.append('--mean=%s' % self.dataset.path(mean_file)) if self.use_mean == 'pixel': args.append('--subtractMean=pixel') elif self.use_mean == 'image': args.append('--subtractMean=image') else: args.append('--subtractMean=none') if self.crop_size: args.append('--croplen=%d' % self.crop_size) if layers == 'all': args.append('--visualize_inf=1') args.append('--save=%s' % self.job_dir) # Convert them all to strings args = [str(x) for x in args] self.logger.info('%s classify one task started.' % self.get_framework_id()) unrecognized_output = [] predictions = [] self.visualization_file = None env = os.environ.copy() if gpu is not None: # make only the selected GPU visible env['CUDA_VISIBLE_DEVICES'] = subprocess_visible_devices([gpu]) p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=self.job_dir, close_fds=True, env=env) try: while p.poll() is None: for line in utils.nonblocking_readlines(p.stdout): if self.aborted.is_set(): p.terminate() raise digits.inference.errors.InferenceError('%s classify one task got aborted. error code - %d' % (self.get_framework_id(), p.returncode)) # noqa if line is not None and len(line) > 1: if not self.process_test_output(line, predictions, 'one'): self.logger.warning('%s classify one task unrecognized input: %s' % ( self.get_framework_id(), line.strip())) unrecognized_output.append(line) else: time.sleep(0.05) except Exception as e: if p.poll() is None: p.terminate() error_message = '' if type(e) == digits.inference.errors.InferenceError: error_message = e.__str__() else: error_message = '%s classify one task failed with error code %d \n %s' % ( self.get_framework_id(), p.returncode, str(e)) self.logger.error(error_message) if unrecognized_output: unrecognized_output = '\n'.join(unrecognized_output) error_message = error_message + unrecognized_output raise digits.inference.errors.InferenceError(error_message) finally: self.after_test_run(temp_image_path) if p.returncode != 0: error_message = '%s classify one task failed with error code %d' % (self.get_framework_id(), p.returncode) self.logger.error(error_message) if unrecognized_output: unrecognized_output = '\n'.join(unrecognized_output) error_message = error_message + unrecognized_output raise digits.inference.errors.InferenceError(error_message) else: self.logger.info('%s classify one task completed.' % self.get_framework_id()) predictions = {'output': np.array(predictions)} visualizations = [] if layers == 'all' and self.visualization_file: vis_db = h5py.File(self.visualization_file, 'r') # the HDF5 database is organized as follows: # <root> # |- layers # |- 1 # | [attrs] - op # | [attrs] - var # | |- activations # | |- weights # |- 2 for layer_id, layer in vis_db['layers'].items(): op_name = layer.attrs['op'] var_name = layer.attrs['var'] layer_desc = "%s\n%s" % (op_name, var_name) idx = int(layer_id) # activations (tf: operation outputs) if 'activations' in layer: data = np.array(layer['activations'][...]) if len(data.shape) > 1 and data.shape[0] == 1: # skip batch dimension data = data[0] if len(data.shape) == 3: data = data.transpose(2, 0, 1) elif len(data.shape) == 4: data = data.transpose(3, 2, 0, 1) vis = utils.image.get_layer_vis_square(data) mean, std, hist = self.get_layer_statistics(data) visualizations.append( { 'id': idx, 'name': layer_desc, 'vis_type': 'Activations', 'vis': vis, 'data_stats': { 'shape': data.shape, 'mean': mean, 'stddev': std, 'histogram': hist, } } ) # weights (tf: variables) if 'weights' in layer: data = np.array(layer['weights'][...]) if len(data.shape) == 3: data = data.transpose(2, 0, 1) elif len(data.shape) == 4: data = data.transpose(3, 2, 0, 1) if 'MatMul' in layer_desc: vis = None # too many layers to display? else: vis = utils.image.get_layer_vis_square(data) mean, std, hist = self.get_layer_statistics(data) parameter_count = reduce(operator.mul, data.shape, 1) visualizations.append( { 'id': idx, 'name': layer_desc, 'vis_type': 'Weights', 'vis': vis, 'param_count': parameter_count, 'data_stats': { 'shape': data.shape, 'mean': mean, 'stddev': std, 'histogram': hist, } } ) # sort by layer ID visualizations = sorted(visualizations, key=lambda x: x['id']) return (predictions, visualizations) def get_layer_statistics(self, data): """ Returns statistics for the given layer data: (mean, standard deviation, histogram) histogram -- [y, x, ticks] Arguments: data -- a np.ndarray """ # These calculations can be super slow mean = np.mean(data) std = np.std(data) y, x = np.histogram(data, bins=20) y = list(y) ticks = x[[0, len(x)/2, -1]] x = [(x[i]+x[i+1])/2.0 for i in xrange(len(x)-1)] ticks = list(ticks) return (mean, std, [y, x, ticks]) def after_test_run(self, temp_image_path): try: os.remove(temp_image_path) except OSError: pass def process_test_output(self, line, predictions, test_category): # parse torch output timestamp, level, message = self.preprocess_output_tensorflow(line) # return false when unrecognized output is encountered if not (level or message): return False if not message: return True float_exp = '([-]?inf|nan|[-+]?[0-9]*\.?[0-9]+(e[-+]?[0-9]+)?)' # format of output while testing single image match = re.match(r'For image \d+, predicted class \d+: \d+ \((.*?)\) %s' % (float_exp), message) if match: label = match.group(1) confidence = match.group(2) assert not('inf' in confidence or 'nan' in confidence), 'Network reported %s for confidence value. Please check image and network' % label # noqa confidence = float(confidence) predictions.append((label, confidence)) return True # format of output while testing multiple images match = re.match(r'Predictions for image \d+: (.*)', message) if match: values = match.group(1).strip() # 'values' should contain a JSON representation of # the prediction predictions.append(eval(values)) return True # path to visualization file match = re.match(r'Saving visualization to (.*)', message) if match: self.visualization_file = match.group(1).strip() return True # displaying info and warn messages as we aren't maintaining separate log file for model testing if level == 'info': self.logger.debug('%s classify %s task : %s' % (self.get_framework_id(), test_category, message)) return True if level == 'warning': self.logger.warning('%s classify %s task : %s' % (self.get_framework_id(), test_category, message)) return True if level in ['error', 'critical']: raise digits.inference.errors.InferenceError('%s classify %s task failed with error message - %s' % ( self.get_framework_id(), test_category, message)) return False # control should never reach this line. @override def infer_many(self, data, snapshot_epoch=None, gpu=None, resize=True): # resize parameter is unused return self.infer_many_images(data, snapshot_epoch=snapshot_epoch, gpu=gpu) def infer_many_images(self, images, snapshot_epoch=None, gpu=None): """ Returns (labels, results): labels -- an array of strings results -- a 2D np array: [ [image0_label0_confidence, image0_label1_confidence, ...], [image1_label0_confidence, image1_label1_confidence, ...], ... ] Arguments: images -- a list of np.arrays Keyword arguments: snapshot_epoch -- which snapshot to use """ # create a temporary folder to store images and a temporary file # to store a list of paths to the images temp_dir_path = tempfile.mkdtemp(suffix='.tfrecords') try: # this try...finally clause is used to clean up the temp directory in any case with open(os.path.join(temp_dir_path, 'list.txt'), 'w') as imglist_file: for image in images: if image.ndim < 3: image = image[..., np.newaxis] image = image.astype('float') temp_image_handle, temp_image_path = tempfile.mkstemp(dir=temp_dir_path, suffix='.tfrecords') writer = tf.python_io.TFRecordWriter(temp_image_path) record = tf.train.Example(features=tf.train.Features(feature={ 'height': _int64_feature(image.shape[0]), 'width': _int64_feature(image.shape[1]), 'depth': _int64_feature(image.shape[2]), 'image_raw': _float_array_feature(image.flatten()), 'label': _int64_feature(0), 'encoding': _int64_feature(0)})) writer.write(record.SerializeToString()) writer.close() imglist_file.write("%s\n" % temp_image_path) os.close(temp_image_handle) file_to_load = self.get_snapshot(snapshot_epoch) args = [sys.executable, os.path.join(os.path.dirname(os.path.abspath(digits.__file__)), 'tools', 'tensorflow', 'main.py'), '--testMany=1', '--allPredictions=1', # all predictions are grabbed and formatted as required by DIGITS '--inference_db=%s' % str(temp_dir_path), '--network=%s' % self.model_file, '--networkDirectory=%s' % self.job_dir, '--weights=%s' % file_to_load, ] if hasattr(self.dataset, 'labels_file'): args.append('--labels_list=%s' % self.dataset.path(self.dataset.labels_file)) if self.use_mean != 'none': mean_file = self.dataset.get_mean_file() assert mean_file is not None, 'Failed to retrieve mean file.' args.append('--mean=%s' % self.dataset.path(mean_file)) if self.use_mean == 'pixel': args.append('--subtractMean=pixel') elif self.use_mean == 'image': args.append('--subtractMean=image') else: args.append('--subtractMean=none') if self.crop_size: args.append('--croplen=%d' % self.crop_size) # Convert them all to strings args = [str(x) for x in args] self.logger.info('%s classify many task started.' % self.name()) env = os.environ.copy() if gpu is not None: # make only the selected GPU visible env['CUDA_VISIBLE_DEVICES'] = subprocess_visible_devices([gpu]) unrecognized_output = [] predictions = [] p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=self.job_dir, close_fds=True, env=env) try: while p.poll() is None: for line in utils.nonblocking_readlines(p.stdout): if self.aborted.is_set(): p.terminate() raise digits.inference.errors.InferenceError('%s classify many task got aborted.' 'error code - %d' % (self.get_framework_id(), p.returncode)) if line is not None and len(line) > 1: if not self.process_test_output(line, predictions, 'many'): self.logger.warning('%s classify many task unrecognized input: %s' % ( self.get_framework_id(), line.strip())) unrecognized_output.append(line) else: time.sleep(0.05) except Exception as e: if p.poll() is None: p.terminate() error_message = '' if type(e) == digits.inference.errors.InferenceError: error_message = e.__str__() else: error_message = '%s classify many task failed with error code %d \n %s' % ( self.get_framework_id(), p.returncode, str(e)) self.logger.error(error_message) if unrecognized_output: unrecognized_output = '\n'.join(unrecognized_output) error_message = error_message + unrecognized_output raise digits.inference.errors.InferenceError(error_message) if p.returncode != 0: error_message = '%s classify many task failed with error code %d' % (self.get_framework_id(), p.returncode) self.logger.error(error_message) if unrecognized_output: unrecognized_output = '\n'.join(unrecognized_output) error_message = error_message + unrecognized_output raise digits.inference.errors.InferenceError(error_message) else: self.logger.info('%s classify many task completed.' % self.get_framework_id()) finally: shutil.rmtree(temp_dir_path) # task.infer_one() expects dictionary in return value return {'output': np.array(predictions)} def has_model(self): """ Returns True if there is a model that can be used """ return len(self.snapshots) != 0 @override def get_model_files(self): """ return paths to model files """ return {"Network": self.model_file} @override def get_network_desc(self): """ return text description of network """ with open(os.path.join(self.job_dir, TENSORFLOW_MODEL_FILE), "r") as infile: desc = infile.read() return desc @override def get_task_stats(self, epoch=-1): """ return a dictionary of task statistics """ loc, mean_file = os.path.split(self.dataset.get_mean_file()) stats = { "image dimensions": self.dataset.get_feature_dims(), "mean file": mean_file, "snapshot file": self.get_snapshot_filename(epoch), "model file": self.model_file, "framework": "tensorflow", "mean subtraction": self.use_mean } if hasattr(self, "digits_version"): stats.update({"digits version": self.digits_version}) if hasattr(self.dataset, "resize_mode"): stats.update({"image resize mode": self.dataset.resize_mode}) if hasattr(self.dataset, "labels_file"): stats.update({"labels file": self.dataset.labels_file}) return stats
DIGITS-master
digits/model/tasks/tensorflow_train.py
# Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import import datetime from ..job import ModelJob from digits.utils import subclass, override # NOTE: Increment this every time the pickled object changes PICKLE_VERSION = 1 @subclass class ImageModelJob(ModelJob): """ A Job that creates an image model """ def __init__(self, **kwargs): """ """ super(ImageModelJob, self).__init__(**kwargs) self.pickver_job_model_image = PICKLE_VERSION @override def json_dict(self, verbose=False, epoch=-1): d = super(ImageModelJob, self).json_dict(verbose) task = self.train_task() creation_time = str(datetime.datetime.fromtimestamp(self.status_history[0][1])) d.update({ "job id": self.id(), "creation time": creation_time, "username": self.username, }) d.update(task.get_task_stats(epoch)) return d
DIGITS-master
digits/model/images/job.py
# Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from .classification import ImageClassificationModelJob from .generic import GenericImageModelJob from .job import ImageModelJob __all__ = [ 'ImageClassificationModelJob', 'GenericImageModelJob', 'ImageModelJob', ]
DIGITS-master
digits/model/images/__init__.py
# Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from wtforms import validators from ..forms import ModelForm from digits import utils class ImageModelForm(ModelForm): """ Defines the form used to create a new ImageModelJob """ crop_size = utils.forms.IntegerField( 'Crop Size', validators=[ validators.NumberRange(min=1), validators.Optional() ], tooltip=("If specified, during training a random square crop will be " "taken from the input image before using as input for the network.") ) use_mean = utils.forms.SelectField( 'Subtract Mean', choices=[ ('none', 'None'), ('image', 'Image'), ('pixel', 'Pixel'), ], default='image', tooltip="Subtract the mean file or mean pixel for this dataset from each image." ) aug_flip = utils.forms.SelectField( 'Flipping', choices=[ ('none', 'None'), ('fliplr', 'Horizontal'), ('flipud', 'Vertical'), ('fliplrud', 'Horizontal and/or Vertical'), ], default='none', tooltip="Randomly flips each image during batch preprocessing." ) aug_quad_rot = utils.forms.SelectField( 'Quadrilateral Rotation', choices=[ ('none', 'None'), ('rot90', '0, 90 or 270 degrees'), ('rot180', '0 or 180 degrees'), ('rotall', '0, 90, 180 or 270 degrees.'), ], default='none', tooltip="Randomly rotates (90 degree steps) each image during batch preprocessing." ) aug_rot = utils.forms.IntegerField( 'Rotation (+- deg)', default=0, validators=[ validators.NumberRange(min=0, max=180) ], tooltip="The uniform-random rotation angle that will be performed during batch preprocessing." ) aug_scale = utils.forms.FloatField( 'Rescale (stddev)', default=0, validators=[ validators.NumberRange(min=0, max=1) ], tooltip=("Retaining image size, the image is rescaled with a " "+-stddev of this parameter. Suggested value is 0.07.") ) aug_noise = utils.forms.FloatField( 'Noise (stddev)', default=0, validators=[ validators.NumberRange(min=0, max=1) ], tooltip=("Adds AWGN (Additive White Gaussian Noise) during batch " "preprocessing, assuming [0 1] pixel-value range. Suggested value is 0.03.") ) aug_contrast = utils.forms.FloatField( 'Contrast (factor)', default=0, validators=[ validators.NumberRange(min=0, max=5) ], tooltip="Per channel, the mean of the channel is computed and then adjusts each component x " "of each pixel to (x - mean) * contrast_factor + mean. The contrast_factor is picked " "form a random uniform distribution to yield a value between [1-contrast_factor, " "1+contrast_factor]. Suggested value is 0.8." ) aug_whitening = utils.forms.BooleanField( 'Whitening', default=False, validators=[], tooltip="Per-image whitening by subtracting its own mean, and dividing by its own standard deviation." ) aug_hsv_use = utils.forms.BooleanField( 'HSV Shifting', default=False, tooltip=("Augmentation by normal-distributed random shifts in HSV " "color space, assuming [0 1] pixel-value range."), ) aug_hsv_h = utils.forms.FloatField( 'Hue', default=0.02, validators=[ validators.NumberRange(min=0, max=0.5) ], tooltip=("Standard deviation of a shift that will be performed during " "preprocessing, assuming [0 1] pixel-value range.") ) aug_hsv_s = utils.forms.FloatField( 'Saturation', default=0.04, validators=[ validators.NumberRange(min=0, max=0.5) ], tooltip=("Standard deviation of a shift that will be performed during " "preprocessing, assuming [0 1] pixel-value range.") ) aug_hsv_v = utils.forms.FloatField( 'Value', default=0.06, validators=[ validators.NumberRange(min=0, max=0.5) ], tooltip=("Standard deviation of a shift that will be performed during " "preprocessing, assuming [0 1] pixel-value range.") )
DIGITS-master
digits/model/images/forms.py
# Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import import flask blueprint = flask.Blueprint(__name__, __name__)
DIGITS-master
digits/model/images/views.py
# Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import import os.path from ..job import ImageModelJob from digits.utils import subclass, override # NOTE: Increment this every time the pickled object changes PICKLE_VERSION = 1 @subclass class ImageClassificationModelJob(ImageModelJob): """ A Job that creates an image model for a classification network """ def __init__(self, **kwargs): super(ImageClassificationModelJob, self).__init__(**kwargs) self.pickver_job_model_image_classification = PICKLE_VERSION @override def job_type(self): return 'Image Classification Model' @override def download_files(self, epoch=-1, frozen_file=False): task = self.train_task() if frozen_file: snapshot_filenames = task.get_snapshot(epoch, frozen_file=True) else: snapshot_filenames = task.get_snapshot(epoch, download=True) # get model files model_files = task.get_model_files() download_files = [(self.path(filename), os.path.basename(filename)) for filename in model_files.values()] # add other files download_files.extend([ (task.dataset.path(task.dataset.labels_file), os.path.basename(task.dataset.labels_file)), (task.dataset.path(task.dataset.get_mean_file()), os.path.basename(task.dataset.get_mean_file())) ]) if not isinstance(snapshot_filenames, list): download_files.append((snapshot_filenames, os.path.basename(snapshot_filenames))) else: for snapshot_filename in snapshot_filenames: download_files.append((snapshot_filename, os.path.basename(snapshot_filename))) return download_files
DIGITS-master
digits/model/images/classification/job.py
# Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from .job import ImageClassificationModelJob __all__ = ['ImageClassificationModelJob']
DIGITS-master
digits/model/images/classification/__init__.py
# Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import import itertools import json import os import shutil import tempfile import time import unittest import caffe_pb2 import math # Find the best implementation available try: from cStringIO import StringIO except ImportError: from StringIO import StringIO from bs4 import BeautifulSoup from digits.config import config_value import digits.dataset.images.classification.test_views import digits.test_views from digits import test_utils import digits.webapp from digits.frameworks import CaffeFramework from google.protobuf import text_format # May be too short on a slow system TIMEOUT_DATASET = 45 TIMEOUT_MODEL = 60 ################################################################################ # Base classes (they don't start with "Test" so nose won't run them) ################################################################################ class BaseViewsTest(digits.test_views.BaseViewsTest): """ Provides some functions """ CAFFE_NETWORK = \ """ layer { name: "hidden" type: 'InnerProduct' bottom: "data" top: "output" } layer { name: "loss" type: "SoftmaxWithLoss" bottom: "output" bottom: "label" top: "loss" exclude { stage: "deploy" } } layer { name: "accuracy" type: "Accuracy" bottom: "output" bottom: "label" top: "accuracy" include { stage: "val" } } layer { name: "softmax" type: "Softmax" bottom: "output" top: "softmax" include { stage: "deploy" } } """ TORCH_NETWORK = \ """ return function(p) -- adjust to number of classes local nclasses = p.nclasses or 1 -- model should adjust to any 3D input local nDim = 1 if p.inputShape then p.inputShape:apply(function(x) nDim=nDim*x end) end local model = nn.Sequential() model:add(nn.View(-1):setNumInputDims(3)) -- c*h*w -> chw (flattened) -- set all weights and biases to zero as this speeds learning up -- for the type of problem we're trying to solve in this test local linearLayer = nn.Linear(nDim, nclasses) linearLayer.weight:fill(0) linearLayer.bias:fill(0) model:add(linearLayer) -- chw -> nclasses model:add(nn.LogSoftMax()) return { model = model } end """ TENSORFLOW_NETWORK = \ """ class UserModel(Tower): @model_property def inference(self): ninputs = self.input_shape[0] * self.input_shape[1] * self.input_shape[2] W = tf.get_variable('W', [ninputs, self.nclasses], initializer=tf.constant_initializer(0.0)) b = tf.get_variable('b', [self.nclasses], initializer=tf.constant_initializer(0.0)), model = tf.reshape(self.x, shape=[-1, ninputs]) model = tf.add(tf.matmul(model, W), b) return model @model_property def loss(self): loss = digits.classification_loss(self.inference, self.y) return loss """ @classmethod def model_exists(cls, job_id): return cls.job_exists(job_id, 'models') @classmethod def model_status(cls, job_id): return cls.job_status(job_id, 'models') @classmethod def model_info(cls, job_id): return cls.job_info(job_id, 'models') @classmethod def abort_model(cls, job_id): return cls.abort_job(job_id, job_type='models') @classmethod def model_wait_completion(cls, job_id, **kwargs): kwargs['job_type'] = 'models' if 'timeout' not in kwargs: kwargs['timeout'] = TIMEOUT_MODEL return cls.job_wait_completion(job_id, **kwargs) @classmethod def delete_model(cls, job_id): return cls.delete_job(job_id, job_type='models') @classmethod def network(cls): if cls.FRAMEWORK == 'torch': return cls.TORCH_NETWORK elif cls.FRAMEWORK == 'caffe': return cls.CAFFE_NETWORK elif cls.FRAMEWORK == 'tensorflow': return cls.TENSORFLOW_NETWORK else: raise Exception('Unknown cls.FRAMEWORK "%s"' % cls.FRAMEWORK) class BaseViewsTestWithDataset(BaseViewsTest, digits.dataset.images.classification.test_views.BaseViewsTestWithDataset): """ Provides a dataset """ # Inherited classes may want to override these attributes CROP_SIZE = None TRAIN_EPOCHS = 1 SHUFFLE = False LR_POLICY = None LR_MULTISTEP_VALUES = None LEARNING_RATE = None AUG_FLIP = None AUG_QUAD_ROT = None AUG_ROT = None AUG_SCALE = None AUG_NOISE = None AUG_CONTRAST = None AUG_WHITENING = None AUG_HSV_USE = None AUG_HSV_H = None AUG_HSV_S = None AUG_HSV_V = None OPTIMIZER = None @classmethod def setUpClass(cls): super(BaseViewsTestWithDataset, cls).setUpClass() cls.created_models = [] @classmethod def tearDownClass(cls): # delete any created datasets for job_id in cls.created_models: cls.delete_model(job_id) super(BaseViewsTestWithDataset, cls).tearDownClass() @classmethod def create_model(cls, network=None, **kwargs): """ Create a model Returns the job_id Raise RuntimeError if job fails to create Keyword arguments: **kwargs -- data to be sent with POST request """ if network is None: network = cls.network() data = { 'model_name': 'test_model', 'group_name': 'test_group', 'dataset': cls.dataset_id, 'method': 'custom', 'custom_network': network, 'batch_size': 10, 'train_epochs': cls.TRAIN_EPOCHS, 'framework': cls.FRAMEWORK, 'random_seed': 0xCAFEBABE, 'shuffle': 'true' if cls.SHUFFLE else 'false' } if cls.CROP_SIZE is not None: data['crop_size'] = cls.CROP_SIZE if cls.LR_POLICY is not None: data['lr_policy'] = cls.LR_POLICY if cls.LEARNING_RATE is not None: data['learning_rate'] = cls.LEARNING_RATE if cls.LR_MULTISTEP_VALUES is not None: data['lr_multistep_values'] = cls.LR_MULTISTEP_VALUES if cls.AUG_FLIP is not None: data['aug_flip'] = cls.AUG_FLIP if cls.AUG_QUAD_ROT is not None: data['aug_quad_rot'] = cls.AUG_QUAD_ROT if cls.AUG_ROT is not None: data['aug_rot'] = cls.AUG_ROT if cls.AUG_SCALE is not None: data['aug_scale'] = cls.AUG_SCALE if cls.AUG_NOISE is not None: data['aug_noise'] = cls.AUG_NOISE if cls.AUG_CONTRAST is not None: data['aug_contrast'] = cls.AUG_CONTRAST if cls.AUG_WHITENING is not None: data['aug_whitening'] = cls.AUG_WHITENING if cls.AUG_HSV_USE is not None: data['aug_hsv_use'] = cls.AUG_HSV_USE if cls.AUG_HSV_H is not None: data['aug_hsv_h'] = cls.AUG_HSV_H if cls.AUG_HSV_S is not None: data['aug_hsv_s'] = cls.AUG_HSV_S if cls.AUG_HSV_V is not None: data['aug_hsv_v'] = cls.AUG_HSV_V if cls.OPTIMIZER is not None: data['solver_type'] = cls.OPTIMIZER data.update(kwargs) request_json = data.pop('json', False) url = '/models/images/classification' if request_json: url += '/json' rv = cls.app.post(url, data=data) if request_json: if rv.status_code != 200: print json.loads(rv.data) raise RuntimeError('Model creation failed with %s' % rv.status_code) data = json.loads(rv.data) if 'jobs' in data.keys(): return [j['id'] for j in data['jobs']] else: return data['id'] # expect a redirect if not 300 <= rv.status_code <= 310: print 'Status code:', rv.status_code s = BeautifulSoup(rv.data, 'html.parser') div = s.select('div.alert-danger') if div: print div[0] else: print rv.data raise RuntimeError('Failed to create dataset - status %s' % rv.status_code) job_id = cls.job_id_from_response(rv) assert cls.model_exists(job_id), 'model not found after successful creation' cls.created_models.append(job_id) return job_id class BaseViewsTestWithModel(BaseViewsTestWithDataset): """ Provides a model """ @classmethod def setUpClass(cls): super(BaseViewsTestWithModel, cls).setUpClass() cls.model_id = cls.create_model(json=True) assert cls.model_wait_completion(cls.model_id) == 'Done', 'create failed' class BaseTestViews(BaseViewsTest): """ Tests which don't require a dataset or a model """ def test_page_model_new(self): rv = self.app.get('/models/images/classification/new') assert rv.status_code == 200, 'page load failed with %s' % rv.status_code assert 'New Image Classification Model' in rv.data, 'unexpected page format' def test_nonexistent_model(self): assert not self.model_exists('foo'), "model shouldn't exist" def test_visualize_network(self): rv = self.app.post('/models/visualize-network?framework=' + self.FRAMEWORK, data={'custom_network': self.network()} ) s = BeautifulSoup(rv.data, 'html.parser') if rv.status_code != 200: body = s.select('body')[0] if 'InvocationException' in str(body): raise unittest.SkipTest('GraphViz not installed') raise AssertionError('POST failed with %s\n\n%s' % (rv.status_code, body)) image = s.select('img') assert image is not None, "didn't return an image" def test_customize(self): rv = self.app.post('/models/customize?network=lenet&framework=' + self.FRAMEWORK) s = BeautifulSoup(rv.data, 'html.parser') body = s.select('body') assert rv.status_code == 200, 'POST failed with %s\n\n%s' % (rv.status_code, body) class BaseTestCreation(BaseViewsTestWithDataset): """ Model creation tests """ def test_create_json(self): job_id = self.create_model(json=True) self.abort_model(job_id) def test_create_delete(self): job_id = self.create_model() assert self.delete_model(job_id) == 200, 'delete failed' assert not self.model_exists(job_id), 'model exists after delete' def test_create_wait_delete(self): job_id = self.create_model() assert self.model_wait_completion(job_id) == 'Done', 'create failed' assert self.delete_model(job_id) == 200, 'delete failed' assert not self.model_exists(job_id), 'model exists after delete' def test_create_abort_delete(self): job_id = self.create_model() assert self.abort_model(job_id) == 200, 'abort failed' assert self.delete_model(job_id) == 200, 'delete failed' assert not self.model_exists(job_id), 'model exists after delete' def test_snapshot_interval_2(self): job_id = self.create_model(snapshot_interval=0.5) assert self.model_wait_completion(job_id) == 'Done', 'create failed' rv = self.app.get('/models/%s/json' % job_id) assert rv.status_code == 200, 'json load failed with %s' % rv.status_code content = json.loads(rv.data) assert len(content['snapshots']) > 1, 'should take >1 snapshot' def test_snapshot_interval_0_5(self): job_id = self.create_model(train_epochs=4, snapshot_interval=2) assert self.model_wait_completion(job_id) == 'Done', 'create failed' rv = self.app.get('/models/%s/json' % job_id) assert rv.status_code == 200, 'json load failed with %s' % rv.status_code content = json.loads(rv.data) assert len(content['snapshots']) == 2, 'should take 2 snapshots' @unittest.skipIf( not config_value('gpu_list'), 'no GPUs selected') @unittest.skipIf( not config_value('caffe')['cuda_enabled'], 'CUDA disabled') @unittest.skipIf( config_value('caffe')['multi_gpu'], 'multi-GPU enabled') def test_select_gpu(self): for index in config_value('gpu_list').split(','): yield self.check_select_gpu, index def check_select_gpu(self, gpu_index): job_id = self.create_model(select_gpu=gpu_index) assert self.model_wait_completion(job_id) == 'Done', 'create failed' @unittest.skipIf( not config_value('gpu_list'), 'no GPUs selected') @unittest.skipIf( not config_value('caffe')['cuda_enabled'], 'CUDA disabled') @unittest.skipIf( not config_value('caffe')['multi_gpu'], 'multi-GPU disabled') def test_select_gpus(self): # test all possible combinations gpu_list = config_value('gpu_list').split(',') for i in xrange(len(gpu_list)): for combination in itertools.combinations(gpu_list, i + 1): yield self.check_select_gpus, combination def check_select_gpus(self, gpu_list): job_id = self.create_model(select_gpus_list=','.join(gpu_list), batch_size=len(gpu_list)) assert self.model_wait_completion(job_id) == 'Done', 'create failed' def classify_one_for_job(self, job_id, test_misclassification=True): # carry out one inference test per category in dataset for category in self.imageset_paths.keys(): image_path = self.imageset_paths[category][0] image_path = os.path.join(self.imageset_folder, image_path) with open(image_path, 'rb') as infile: # StringIO wrapping is needed to simulate POST file upload. image_upload = (StringIO(infile.read()), 'image.png') rv = self.app.post( '/models/images/classification/classify_one?job_id=%s' % job_id, data={ 'image_file': image_upload, } ) s = BeautifulSoup(rv.data, 'html.parser') body = s.select('body') assert rv.status_code == 200, 'POST failed with %s\n\n%s' % (rv.status_code, body) # gets an array of arrays [[confidence, label],...] predictions = [p.get_text().split() for p in s.select('ul.list-group li')] if test_misclassification: assert predictions[0][1] == category, 'image misclassified' def test_classify_one_mean_image(self): # test the creation job_id = self.create_model(use_mean='image') assert self.model_wait_completion(job_id) == 'Done', 'job failed' self.classify_one_for_job(job_id) def test_classify_one_mean_pixel(self): # test the creation job_id = self.create_model(use_mean='pixel') assert self.model_wait_completion(job_id) == 'Done', 'job failed' self.classify_one_for_job(job_id) def test_classify_one_mean_none(self): # test the creation job_id = self.create_model(use_mean='none') assert self.model_wait_completion(job_id) == 'Done', 'job failed' self.classify_one_for_job(job_id, False) def test_retrain(self): job1_id = self.create_model() assert self.model_wait_completion(job1_id) == 'Done', 'first job failed' rv = self.app.get('/models/%s/json' % job1_id) assert rv.status_code == 200, 'json load failed with %s' % rv.status_code content = json.loads(rv.data) assert len(content['snapshots']), 'should have at least snapshot' options = { 'method': 'previous', 'previous_networks': job1_id, } options['%s-snapshot' % job1_id] = content['snapshots'][-1] job2_id = self.create_model(**options) assert self.model_wait_completion(job2_id) == 'Done', 'second job failed' def test_retrain_twice(self): # retrain from a job which already had a pretrained model job1_id = self.create_model() assert self.model_wait_completion(job1_id) == 'Done', 'first job failed' rv = self.app.get('/models/%s/json' % job1_id) assert rv.status_code == 200, 'json load failed with %s' % rv.status_code content = json.loads(rv.data) assert len(content['snapshots']), 'should have at least snapshot' options_2 = { 'method': 'previous', 'previous_networks': job1_id, } options_2['%s-snapshot' % job1_id] = content['snapshots'][-1] job2_id = self.create_model(**options_2) assert self.model_wait_completion(job2_id) == 'Done', 'second job failed' options_3 = { 'method': 'previous', 'previous_networks': job2_id, } options_3['%s-snapshot' % job2_id] = -1 job3_id = self.create_model(**options_3) assert self.model_wait_completion(job3_id) == 'Done', 'third job failed' def test_bad_network_definition(self): if self.FRAMEWORK == 'caffe': bogus_net = """ layer { name: "hidden" type: 'BogusCode' bottom: "data" top: "output" } layer { name: "loss" type: "SoftmaxWithLoss" bottom: "output" bottom: "label" top: "loss" exclude { stage: "deploy" } } layer { name: "softmax" type: "Softmax" bottom: "output" top: "softmax" include { stage: "deploy" } } """ elif self.FRAMEWORK == 'torch': bogus_net = """ local model = BogusCode(0) return function(params) return { model = model } end """ elif self.FRAMEWORK == 'tensorflow': bogus_net = """ class UserModel(Tower): @model_property def inference(self): model = BogusCode(0) return model @model_property def loss(y): return BogusCode(0) """ job_id = self.create_model(json=True, network=bogus_net) assert self.model_wait_completion(job_id) == 'Error', 'job should have failed' job_info = self.job_info_html(job_id=job_id, job_type='models') assert 'BogusCode' in job_info, "job_info: \n%s" % str(job_info) def test_clone(self): options_1 = { 'shuffle': True, 'snapshot_interval': 2.0, 'lr_step_size': 33.0, 'lr_inv_power': 0.5, 'lr_inv_gamma': 0.1, 'lr_poly_power': 3.0, 'lr_exp_gamma': 0.9, 'use_mean': 'image', 'lr_multistep_gamma': 0.5, 'lr_policy': 'exp', 'val_interval': 3.0, 'random_seed': 123, 'learning_rate': 0.0125, 'lr_step_gamma': 0.1, 'lr_sigmoid_step': 50.0, 'lr_sigmoid_gamma': 0.1, 'lr_multistep_values': '50,85', } job1_id = self.create_model(**options_1) assert self.model_wait_completion(job1_id) == 'Done', 'first job failed' rv = self.app.get('/models/%s/json' % job1_id) assert rv.status_code == 200, 'json load failed with %s' % rv.status_code content1 = json.loads(rv.data) # Clone job1 as job2 options_2 = { 'clone': job1_id, } job2_id = self.create_model(**options_2) assert self.model_wait_completion(job2_id) == 'Done', 'second job failed' rv = self.app.get('/models/%s/json' % job2_id) assert rv.status_code == 200, 'json load failed with %s' % rv.status_code content2 = json.loads(rv.data) # These will be different content1.pop('id') content2.pop('id') content1.pop('directory') content2.pop('directory') content1.pop('creation time') content2.pop('creation time') content1.pop('job id') content2.pop('job id') assert (content1 == content2), 'job content does not match' job1 = digits.webapp.scheduler.get_job(job1_id) job2 = digits.webapp.scheduler.get_job(job2_id) assert (job1.form_data == job2.form_data), 'form content does not match' class BaseTestCreated(BaseViewsTestWithModel): """ Tests on a model that has already been created """ def test_save(self): job = digits.webapp.scheduler.get_job(self.model_id) assert job.save(), 'Job failed to save' def test_get_snapshot(self): job = digits.webapp.scheduler.get_job(self.model_id) task = job.train_task() f = task.get_snapshot(-1) assert f, "Failed to load snapshot" filename = task.get_snapshot_filename(-1) assert filename, "Failed to get filename" def test_download(self): for extension in ['tar', 'zip', 'tar.gz', 'tar.bz2']: yield self.check_download, extension def check_download(self, extension): url = '/models/%s/download.%s' % (self.model_id, extension) rv = self.app.get(url) assert rv.status_code == 200, 'download "%s" failed with %s' % (url, rv.status_code) def test_index_json(self): rv = self.app.get('/index/json') assert rv.status_code == 200, 'page load failed with %s' % rv.status_code content = json.loads(rv.data) found = False for m in content['models']: if m['id'] == self.model_id: found = True break assert found, 'model not found in list' def test_model_json(self): rv = self.app.get('/models/%s/json' % self.model_id) assert rv.status_code == 200, 'page load failed with %s' % rv.status_code content = json.loads(rv.data) assert content['id'] == self.model_id, 'id %s != %s' % (content['id'], self.model_id) assert content['dataset_id'] == self.dataset_id, 'dataset_id %s != %s' % ( content['dataset_id'], self.dataset_id) assert len(content['snapshots']) > 0, 'no snapshots in list' def test_edit_name(self): status = self.edit_job( self.dataset_id, name='new name' ) assert status == 200, 'failed with %s' % status def test_edit_notes(self): status = self.edit_job( self.dataset_id, notes='new notes' ) assert status == 200, 'failed with %s' % status def test_classify_one(self): # test first image in first category category = self.imageset_paths.keys()[0] image_path = self.imageset_paths[category][0] image_path = os.path.join(self.imageset_folder, image_path) with open(image_path, 'rb') as infile: # StringIO wrapping is needed to simulate POST file upload. image_upload = (StringIO(infile.read()), 'image.png') rv = self.app.post( '/models/images/classification/classify_one?job_id=%s' % self.model_id, data={ 'image_file': image_upload, 'show_visualizations': 'y', } ) s = BeautifulSoup(rv.data, 'html.parser') body = s.select('body') assert rv.status_code == 200, 'POST failed with %s\n\n%s' % (rv.status_code, body) # gets an array of arrays [[confidence, label],...] predictions = [p.get_text().split() for p in s.select('ul.list-group li')] assert predictions[0][1] == category, 'image misclassified' def test_classify_one_json(self): # test last image in last category category = self.imageset_paths.keys()[-1] image_path = self.imageset_paths[category][-1] image_path = os.path.join(self.imageset_folder, image_path) with open(image_path, 'rb') as infile: # StringIO wrapping is needed to simulate POST file upload. image_upload = (StringIO(infile.read()), 'image.png') rv = self.app.post( '/models/images/classification/classify_one/json?job_id=%s' % self.model_id, data={ 'image_file': image_upload, 'show_visualizations': 'y', } ) assert rv.status_code == 200, 'POST failed with %s' % rv.status_code data = json.loads(rv.data) assert data['predictions'][0][0] == category, 'image misclassified' def test_classify_many(self): textfile_images = '' label_id = 0 for label, images in self.imageset_paths.iteritems(): for image in images: image_path = image image_path = os.path.join(self.imageset_folder, image_path) textfile_images += '%s %d\n' % (image_path, label_id) label_id += 1 # StringIO wrapping is needed to simulate POST file upload. file_upload = (StringIO(textfile_images), 'images.txt') rv = self.app.post( '/models/images/classification/classify_many?job_id=%s' % self.model_id, data={'image_list': file_upload} ) s = BeautifulSoup(rv.data, 'html.parser') body = s.select('body') assert rv.status_code == 200, 'POST failed with %s\n\n%s' % (rv.status_code, body) def test_classify_many_from_folder(self): textfile_images = '' label_id = 0 for label, images in self.imageset_paths.iteritems(): for image in images: image_path = image textfile_images += '%s %d\n' % (image_path, label_id) label_id += 1 # StringIO wrapping is needed to simulate POST file upload. file_upload = (StringIO(textfile_images), 'images.txt') rv = self.app.post( '/models/images/classification/classify_many?job_id=%s' % self.model_id, data={'image_list': file_upload, 'image_folder': self.imageset_folder} ) s = BeautifulSoup(rv.data, 'html.parser') body = s.select('body') assert rv.status_code == 200, 'POST failed with %s\n\n%s' % (rv.status_code, body) def test_classify_many_invalid_ground_truth(self): textfile_images = '' label_id = 0 for label, images in self.imageset_paths.iteritems(): for image in images: image_path = image image_path = os.path.join(self.imageset_folder, image_path) # test label_id with -1 and >len(labels) textfile_images += '%s %s\n' % (image_path, 3 * label_id - 1) label_id += 1 # StringIO wrapping is needed to simulate POST file upload. file_upload = (StringIO(textfile_images), 'images.txt') rv = self.app.post( '/models/images/classification/classify_many?job_id=%s' % self.model_id, data={'image_list': file_upload} ) s = BeautifulSoup(rv.data, 'html.parser') body = s.select('body') assert rv.status_code == 200, 'POST failed with %s\n\n%s' % (rv.status_code, body) def test_classify_many_json(self): textfile_images = '' label_id = 0 for label, images in self.imageset_paths.iteritems(): for image in images: image_path = image image_path = os.path.join(self.imageset_folder, image_path) textfile_images += '%s %d\n' % (image_path, label_id) label_id += 1 # StringIO wrapping is needed to simulate POST file upload. file_upload = (StringIO(textfile_images), 'images.txt') rv = self.app.post( '/models/images/classification/classify_many/json?job_id=%s' % self.model_id, data={'image_list': file_upload} ) assert rv.status_code == 200, 'POST failed with %s' % rv.status_code data = json.loads(rv.data) assert 'classifications' in data, 'invalid response' # verify classification of first image in each category for category in self.imageset_paths.keys(): image_path = self.imageset_paths[category][0] image_path = os.path.join(self.imageset_folder, image_path) prediction = data['classifications'][image_path][0][0] assert prediction == category, 'image misclassified- predicted %s - expected %s' % (prediction, category) def test_top_n(self): textfile_images = '' label_id = 0 for label, images in self.imageset_paths.iteritems(): for image in images: image_path = image image_path = os.path.join(self.imageset_folder, image_path) textfile_images += '%s %d\n' % (image_path, label_id) label_id += 1 # StringIO wrapping is needed to simulate POST file upload. file_upload = (StringIO(textfile_images), 'images.txt') rv = self.app.post( '/models/images/classification/top_n?job_id=%s' % self.model_id, data={'image_list': file_upload} ) s = BeautifulSoup(rv.data, 'html.parser') body = s.select('body') assert rv.status_code == 200, 'POST failed with %s\n\n%s' % (rv.status_code, body) keys = self.imageset_paths.keys() for key in keys: assert key in rv.data, '"%s" not found in the response' def test_top_n_from_folder(self): textfile_images = '' label_id = 0 for label, images in self.imageset_paths.iteritems(): for image in images: image_path = image textfile_images += '%s %d\n' % (image_path, label_id) label_id += 1 # StringIO wrapping is needed to simulate POST file upload. file_upload = (StringIO(textfile_images), 'images.txt') rv = self.app.post( '/models/images/classification/top_n?job_id=%s' % self.model_id, data={'image_list': file_upload, 'image_folder': self.imageset_folder} ) s = BeautifulSoup(rv.data, 'html.parser') body = s.select('body') assert rv.status_code == 200, 'POST failed with %s\n\n%s' % (rv.status_code, body) keys = self.imageset_paths.keys() for key in keys: assert key in rv.data, '"%s" not found in the response' def test_inference_while_training(self): # make sure we can do inference while all GPUs are in use for training # if no GPUs, just test inference during a normal training job # get number of GPUs if self.FRAMEWORK == 'tensorflow': raise unittest.SkipTest('Tensorflow CPU inference during training not supported') gpu_count = 1 if (config_value('gpu_list') and config_value('caffe')['cuda_enabled'] and config_value('caffe')['multi_gpu']): gpu_count = len(config_value('gpu_list').split(',')) # grab an image for testing category = self.imageset_paths.keys()[-1] image_path = self.imageset_paths[category][-1] image_path = os.path.join(self.imageset_folder, image_path) with open(image_path, 'rb') as infile: # StringIO wrapping is needed to simulate POST file upload. image_upload = (StringIO(infile.read()), 'image.png') # create a long-running training job job2_id = self.create_model( select_gpu_count=gpu_count, batch_size=10 * gpu_count, train_epochs=1000, ) try: while True: status = self.model_status(job2_id) if status in ['Initialized', 'Waiting']: time.sleep(0.01) elif status == 'Running': break else: raise RuntimeError('job status is %s' % status) rv = self.app.post( '/models/images/classification/classify_one/json?job_id=%s' % self.model_id, data={'image_file': image_upload} ) json.loads(rv.data) assert rv.status_code == 200, 'POST failed with %s' % rv.status_code finally: self.delete_model(job2_id) class BaseTestDatasetModelInteractions(BaseViewsTestWithDataset): """ Test the interactions between datasets and models """ # If you try to create a model using a deleted dataset, it should fail def test_create_model_deleted_dataset(self): dataset_id = self.create_dataset() assert self.delete_dataset(dataset_id) == 200, 'delete failed' assert not self.dataset_exists(dataset_id), 'dataset exists after delete' try: self.create_model(dataset=dataset_id) except RuntimeError: return assert False, 'Should have failed' # If you try to create a model using a running dataset, # it should wait to start until the dataset is completed def test_create_model_running_dataset(self): dataset_id = self.create_dataset() model_id = self.create_model(dataset=dataset_id) # Model should be in WAIT status while dataset is running # Copying functionality from job_wait_completion ... start_time = time.time() timeout = TIMEOUT_DATASET dataset_status = self.dataset_status(dataset_id) while dataset_status != 'Done': model_status = self.model_status(model_id) if model_status == 'Initialized': # give it some time ... pass elif model_status == 'Waiting': # That's what we were waiting for break else: raise Exception('Model not waiting - "%s"' % model_status) assert (time.time() - start_time) < timeout, 'Job took more than %s seconds' % timeout time.sleep(0.5) dataset_status = self.dataset_status(dataset_id) # Model should switch to RUN status after dataset is DONE assert self.dataset_wait_completion(dataset_id) == 'Done', 'dataset creation failed' time.sleep(1) assert self.model_status(model_id) in ['Running', 'Done'], "model didn't start" self.abort_model(model_id) # If you try to delete a completed dataset with a dependent model, it should fail def test_delete_dataset_dependent_model(self): dataset_id = self.create_dataset() model_id = self.create_model(dataset=dataset_id) assert self.dataset_wait_completion(dataset_id) == 'Done', 'dataset creation failed' assert self.delete_dataset(dataset_id) == 403, 'dataset deletion should not have succeeded' self.abort_model(model_id) # If you try to delete a running dataset with a dependent model, it should fail def test_delete_running_dataset_dependent_model(self): dataset_id = self.create_dataset() model_id = self.create_model(dataset=dataset_id) assert self.delete_dataset(dataset_id) == 403, 'dataset deletion should not have succeeded' self.abort_dataset(dataset_id) self.abort_model(model_id) class BaseTestCreatedWide(BaseTestCreated): IMAGE_WIDTH = 20 class BaseTestCreatedTall(BaseTestCreated): IMAGE_HEIGHT = 20 class BaseTestCreatedCropInForm(BaseTestCreated): CROP_SIZE = 8 class BaseTestCreatedDataAug(BaseTestCreatedTall): AUG_FLIP = 'fliplrud' AUG_QUAD_ROT = 'rotall' AUG_ROT = 45 AUG_SCALE = 0.07 AUG_NOISE = 0.03 AUG_HSV_USE = True AUG_HSV_H = 0.02 AUG_HSV_S = 0.04 AUG_HSV_V = 0.06 class BaseTestCreatedCropInNetwork(BaseTestCreated): CAFFE_NETWORK = \ """ layer { name: "data" type: "Data" top: "data" top: "label" include { phase: TRAIN } transform_param { crop_size: 8 } } layer { name: "data" type: "Data" top: "data" top: "label" include { phase: TEST } transform_param { crop_size: 8 } } layer { name: "hidden" type: 'InnerProduct' bottom: "data" top: "output" } layer { name: "loss" type: "SoftmaxWithLoss" bottom: "output" bottom: "label" top: "loss" exclude { stage: "deploy" } } layer { name: "accuracy" type: "Accuracy" bottom: "output" bottom: "label" top: "accuracy" include { stage: "val" } } layer { name: "softmax" type: "Softmax" bottom: "output" top: "softmax" include { stage: "deploy" } } """ TORCH_NETWORK = \ """ return function(p) local nclasses = p.nclasses or 1 local croplen = 8, channels if p.inputShape then channels=p.inputShape[1] else channels=1 end local model = nn.Sequential() model:add(nn.View(-1):setNumInputDims(3)) -- flatten local linLayer = nn.Linear(channels*croplen*croplen, nclasses) linLayer.weight:fill(0) linLayer.bias:fill(0) model:add(linLayer) -- chw -> nclasses model:add(nn.LogSoftMax()) return { model = model, croplen = croplen } end """ TENSORFLOW_NETWORK = \ """ @TODO(tzaman) """ ################################################################################ # Test classes ################################################################################ class TestCaffeViews(BaseTestViews, test_utils.CaffeMixin): pass class TestCaffeCreation(BaseTestCreation, test_utils.CaffeMixin): pass class TestCaffeCreatedWideMoreNumOutput(BaseTestCreatedWide, test_utils.CaffeMixin): CAFFE_NETWORK = \ """ layer { name: "hidden" type: 'InnerProduct' bottom: "data" top: "output" inner_product_param { num_output: 1000 } } layer { name: "loss" type: "SoftmaxWithLoss" bottom: "output" bottom: "label" top: "loss" exclude { stage: "deploy" } } layer { name: "accuracy" type: "Accuracy" bottom: "output" bottom: "label" top: "accuracy" include { stage: "val" } } layer { name: "softmax" type: "Softmax" bottom: "output" top: "softmax" include { stage: "deploy" } } """ class TestCaffeDatasetModelInteractions(BaseTestDatasetModelInteractions, test_utils.CaffeMixin): pass class TestCaffeCreatedCropInForm(BaseTestCreatedCropInForm, test_utils.CaffeMixin): pass class TestCaffeCreatedCropInNetwork(BaseTestCreatedCropInNetwork, test_utils.CaffeMixin): pass @unittest.skipIf( not CaffeFramework().can_accumulate_gradients(), 'This version of Caffe cannot accumulate gradients') class TestBatchAccumulationCaffe(BaseViewsTestWithDataset, test_utils.CaffeMixin): TRAIN_EPOCHS = 1 IMAGE_COUNT = 10 # per class def test_batch_accumulation_calculations(self): batch_size = 10 batch_accumulation = 2 job_id = self.create_model( batch_size=batch_size, batch_accumulation=batch_accumulation, ) assert self.model_wait_completion(job_id) == 'Done', 'create failed' info = self.model_info(job_id) solver = caffe_pb2.SolverParameter() with open(os.path.join(info['directory'], info['solver file']), 'r') as infile: text_format.Merge(infile.read(), solver) assert solver.iter_size == batch_accumulation, \ 'iter_size is %d instead of %d' % (solver.iter_size, batch_accumulation) max_iter = int(math.ceil( float(self.TRAIN_EPOCHS * self.IMAGE_COUNT * 3) / (batch_size * batch_accumulation) )) assert solver.max_iter == max_iter,\ 'max_iter is %d instead of %d' % (solver.max_iter, max_iter) class TestCaffeCreatedTallMultiStepLR(BaseTestCreatedTall, test_utils.CaffeMixin): LR_POLICY = 'multistep' LR_MULTISTEP_VALUES = '50,75,90' class TestTorchViews(BaseTestViews, test_utils.TorchMixin): pass class TestTorchCreation(BaseTestCreation, test_utils.TorchMixin): pass class TestTorchCreatedUnencodedShuffle(BaseTestCreated, test_utils.TorchMixin): ENCODING = 'none' SHUFFLE = True class TestTorchCreatedHdf5(BaseTestCreated, test_utils.TorchMixin): BACKEND = 'hdf5' class TestTorchCreatedTallHdf5Shuffle(BaseTestCreatedTall, test_utils.TorchMixin): BACKEND = 'hdf5' SHUFFLE = True class TestTorchDatasetModelInteractions(BaseTestDatasetModelInteractions, test_utils.TorchMixin): pass class TestCaffeLeNet(BaseTestCreated, test_utils.CaffeMixin): IMAGE_WIDTH = 28 IMAGE_HEIGHT = 28 CAFFE_NETWORK = open( os.path.join( os.path.dirname(digits.__file__), 'standard-networks', 'caffe', 'lenet.prototxt') ).read() class TestCaffeLeNetADAMOptimizer(TestCaffeLeNet): OPTIMIZER = 'ADAM' class TestTorchCreatedCropInForm(BaseTestCreatedCropInForm, test_utils.TorchMixin): pass class TestTorchCreatedDataAug(BaseTestCreatedDataAug, test_utils.TorchMixin): TRAIN_EPOCHS = 2 class TestTorchCreatedCropInNetwork(BaseTestCreatedCropInNetwork, test_utils.TorchMixin): pass class TestTorchCreatedWideMultiStepLR(BaseTestCreatedWide, test_utils.TorchMixin): LR_POLICY = 'multistep' LR_MULTISTEP_VALUES = '50,75,90' class TestTorchLeNet(BaseTestCreated, test_utils.TorchMixin): IMAGE_WIDTH = 28 IMAGE_HEIGHT = 28 TRAIN_EPOCHS = 20 # standard lenet model will adjust to color # or grayscale images TORCH_NETWORK = open( os.path.join( os.path.dirname(digits.__file__), 'standard-networks', 'torch', 'lenet.lua') ).read() def test_inference_while_training(self): # override parent method to skip this test as the reference # model for LeNet uses CuDNN by default and it difficult to # perform inference on a CuDNN-trained model without non-trivial # model tweaking raise unittest.SkipTest('Torch CPU inference on CuDNN-trained model not supported') class TestTorchLeNetADAMOptimizer(TestTorchLeNet): OPTIMIZER = 'ADAM' class TestTorchLeNetHdf5Shuffle(TestTorchLeNet): BACKEND = 'hdf5' SHUFFLE = True class TestCaffePythonLayer(BaseViewsTestWithDataset, test_utils.CaffeMixin): CAFFE_NETWORK = """\ layer { name: "hidden" type: 'InnerProduct' inner_product_param { num_output: 500 weight_filler { type: "xavier" } bias_filler { type: "constant" } } bottom: "data" top: "output" } layer { name: "loss" type: "SoftmaxWithLoss" bottom: "output" bottom: "label" top: "loss" exclude { stage: "deploy" } } layer { name: "accuracy" type: "Accuracy" bottom: "output" bottom: "label" top: "accuracy" include { stage: "val" } } layer { name: "py_test" type: "Python" bottom: "output" top: "py_test" python_param { module: "digits_python_layers" layer: "PythonLayer" } } layer { name: "softmax" type: "Softmax" bottom: "output" top: "softmax" include { stage: "deploy" } } """ def write_python_layer_script(self, filename): with open(filename, 'w') as f: f.write("""\ import caffe import numpy as np class PythonLayer(caffe.Layer): def setup(self, bottom, top): print 'PythonLayer::setup' if len(bottom) != 1: raise Exception("Need one input.") def reshape(self, bottom, top): print 'PythonLayer::reshape' top[0].reshape(1) def forward(self, bottom, top): print 'PythonLayer::forward' top[0].data[...] = np.sum(bottom[0].data) / 2. / bottom[0].num """) # This test makes a temporary python layer file whose path is set # as py_layer_server_file. The job creation process copies that # file to the job_dir. The CAFFE_NETWORK above, requires that # python script to be in the correct spot. If there is an error # in the script or if the script is named incorrectly, or does # not exist in the job_dir, then the test will fail. def test_python_layer(self): tmpdir = tempfile.mkdtemp() py_file = tmpdir + '/py_test.py' self.write_python_layer_script(py_file) job_id = self.create_model(python_layer_server_file=py_file) # remove the temporary python script. shutil.rmtree(tmpdir) assert self.model_wait_completion(job_id) == 'Done', 'first job failed' rv = self.app.get('/models/%s/json' % job_id) assert rv.status_code == 200, 'json load failed with %s' % rv.status_code content = json.loads(rv.data) assert len(content['snapshots']), 'should have at least snapshot' class TestSweepCreation(BaseViewsTestWithDataset, test_utils.CaffeMixin): """ Model creation tests """ def test_sweep(self): job_ids = self.create_model(json=True, learning_rate='[0.01, 0.02]', batch_size='[8, 10]') for job_id in job_ids: assert self.model_wait_completion(job_id) == 'Done', 'create failed' assert self.delete_model(job_id) == 200, 'delete failed' assert not self.model_exists(job_id), 'model exists after delete' # Tensorflow class TestTensorflowCreation(BaseTestCreation, test_utils.TensorflowMixin): pass class TestTensorflowCreatedWideUnencodedShuffle(BaseTestCreatedWide, test_utils.TensorflowMixin): ENCODING = 'none' SHUFFLE = True class TestTensorflowCreatedHdf5(BaseTestCreated, test_utils.TensorflowMixin): BACKEND = 'hdf5' class TestTensorflowCreatedTallHdf5Shuffle(BaseTestCreatedTall, test_utils.TensorflowMixin): BACKEND = 'hdf5' SHUFFLE = True class TestTensorflowDatasetModelInteractions(BaseTestDatasetModelInteractions, test_utils.TensorflowMixin): pass class TestTensorflowCreatedDataAug(BaseTestCreatedDataAug, test_utils.TensorflowMixin): AUG_FLIP = 'fliplrud' AUG_NOISE = 0.03 AUG_CONTRAST = 0.1 AUG_WHITENING = True AUG_HSV_USE = True AUG_HSV_H = 0.02 AUG_HSV_S = 0.04 AUG_HSV_V = 0.06 TRAIN_EPOCHS = 2 class TestTensorflowCreatedWideMultiStepLR(BaseTestCreatedWide, test_utils.TensorflowMixin): LR_POLICY = 'multistep' LR_MULTISTEP_VALUES = '50,75,90' class TestTensorflowLeNet(BaseTestCreated, test_utils.TensorflowMixin): IMAGE_WIDTH = 28 IMAGE_HEIGHT = 28 TRAIN_EPOCHS = 20 # standard lenet model will adjust to color # or grayscale images TENSORFLOW_NETWORK = open(os.path.join(os.path.dirname(digits.__file__), 'standard-networks', 'tensorflow', 'lenet.py')).read() class TestTensorflowLeNetADAMOptimizer(TestTensorflowLeNet): OPTIMIZER = 'ADAM'
DIGITS-master
digits/model/images/classification/test_views.py
# Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from ..forms import ImageModelForm class ImageClassificationModelForm(ImageModelForm): """ Defines the form used to create a new ImageClassificationModelJob """ pass
DIGITS-master
digits/model/images/classification/forms.py
# Copyright (c) 2014-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import import os import re import tempfile import flask import numpy as np import werkzeug.exceptions from .forms import ImageClassificationModelForm from .job import ImageClassificationModelJob from digits import frameworks from digits import utils from digits.config import config_value from digits.dataset import ImageClassificationDatasetJob from digits.inference import ImageInferenceJob from digits.pretrained_model.job import PretrainedModelJob from digits.status import Status from digits.utils import filesystem as fs from digits.utils.forms import fill_form_if_cloned, save_form_to_job from digits.utils.routing import request_wants_json, job_from_request from digits.webapp import scheduler blueprint = flask.Blueprint(__name__, __name__) """ Read image list """ def read_image_list(image_list, image_folder, num_test_images): paths = [] ground_truths = [] for line in image_list.readlines(): line = line.strip() if not line: continue # might contain a numerical label at the end match = re.match(r'(.*\S)\s+(\d+)$', line) if match: path = match.group(1) ground_truth = int(match.group(2)) else: path = line ground_truth = None if not utils.is_url(path) and image_folder and not os.path.isabs(path): path = os.path.join(image_folder, path) paths.append(path) ground_truths.append(ground_truth) if num_test_images is not None and len(paths) >= num_test_images: break return paths, ground_truths @blueprint.route('/new', methods=['GET']) @utils.auth.requires_login def new(): """ Return a form for a new ImageClassificationModelJob """ form = ImageClassificationModelForm() form.dataset.choices = get_datasets() form.standard_networks.choices = get_standard_networks() form.standard_networks.default = get_default_standard_network() form.previous_networks.choices = get_previous_networks() form.pretrained_networks.choices = get_pretrained_networks() prev_network_snapshots = get_previous_network_snapshots() # Is there a request to clone a job with ?clone=<job_id> fill_form_if_cloned(form) return flask.render_template('models/images/classification/new.html', form=form, frameworks=frameworks.get_frameworks(), previous_network_snapshots=prev_network_snapshots, previous_networks_fullinfo=get_previous_networks_fulldetails(), pretrained_networks_fullinfo=get_pretrained_networks_fulldetails(), multi_gpu=config_value('caffe')['multi_gpu'], ) @blueprint.route('/json', methods=['POST']) @blueprint.route('', methods=['POST'], strict_slashes=False) @utils.auth.requires_login(redirect=False) def create(): """ Create a new ImageClassificationModelJob Returns JSON when requested: {job_id,name,status} or {errors:[]} """ form = ImageClassificationModelForm() form.dataset.choices = get_datasets() form.standard_networks.choices = get_standard_networks() form.standard_networks.default = get_default_standard_network() form.previous_networks.choices = get_previous_networks() form.pretrained_networks.choices = get_pretrained_networks() prev_network_snapshots = get_previous_network_snapshots() # Is there a request to clone a job with ?clone=<job_id> fill_form_if_cloned(form) if not form.validate_on_submit(): if request_wants_json(): return flask.jsonify({'errors': form.errors}), 400 else: return flask.render_template('models/images/classification/new.html', form=form, frameworks=frameworks.get_frameworks(), previous_network_snapshots=prev_network_snapshots, previous_networks_fullinfo=get_previous_networks_fulldetails(), pretrained_networks_fullinfo=get_pretrained_networks_fulldetails(), multi_gpu=config_value('caffe')['multi_gpu'], ), 400 datasetJob = scheduler.get_job(form.dataset.data) if not datasetJob: raise werkzeug.exceptions.BadRequest( 'Unknown dataset job_id "%s"' % form.dataset.data) # sweeps will be a list of the the permutations of swept fields # Get swept learning_rate sweeps = [{'learning_rate': v} for v in form.learning_rate.data] add_learning_rate = len(form.learning_rate.data) > 1 # Add swept batch_size sweeps = [dict(s.items() + [('batch_size', bs)]) for bs in form.batch_size.data for s in sweeps[:]] add_batch_size = len(form.batch_size.data) > 1 n_jobs = len(sweeps) jobs = [] for sweep in sweeps: # Populate the form with swept data to be used in saving and # launching jobs. form.learning_rate.data = sweep['learning_rate'] form.batch_size.data = sweep['batch_size'] # Augment Job Name extra = '' if add_learning_rate: extra += ' learning_rate:%s' % str(form.learning_rate.data[0]) if add_batch_size: extra += ' batch_size:%d' % form.batch_size.data[0] job = None try: job = ImageClassificationModelJob( username=utils.auth.get_username(), name=form.model_name.data + extra, group=form.group_name.data, dataset_id=datasetJob.id(), ) # get handle to framework object fw = frameworks.get_framework_by_id(form.framework.data) pretrained_model = None if form.method.data == 'standard': found = False # can we find it in standard networks? network_desc = fw.get_standard_network_desc(form.standard_networks.data) if network_desc: found = True network = fw.get_network_from_desc(network_desc) if not found: raise werkzeug.exceptions.BadRequest( 'Unknown standard model "%s"' % form.standard_networks.data) elif form.method.data == 'previous': old_job = scheduler.get_job(form.previous_networks.data) if not old_job: raise werkzeug.exceptions.BadRequest( 'Job not found: %s' % form.previous_networks.data) use_same_dataset = (old_job.dataset_id == job.dataset_id) network = fw.get_network_from_previous(old_job.train_task().network, use_same_dataset) for choice in form.previous_networks.choices: if choice[0] == form.previous_networks.data: epoch = float(flask.request.form['%s-snapshot' % form.previous_networks.data]) if epoch == 0: pass elif epoch == -1: pretrained_model = old_job.train_task().pretrained_model else: # verify snapshot exists pretrained_model = old_job.train_task().get_snapshot(epoch, download=True) if pretrained_model is None: raise werkzeug.exceptions.BadRequest( "For the job %s, selected pretrained_model for epoch %d is invalid!" % (form.previous_networks.data, epoch)) # the first is the actual file if a list is returned, other should be meta data if isinstance(pretrained_model, list): pretrained_model = pretrained_model[0] if not (os.path.exists(pretrained_model)): raise werkzeug.exceptions.BadRequest( "Pretrained_model for the selected epoch doesn't exist. " "May be deleted by another user/process. " "Please restart the server to load the correct pretrained_model details.") # get logical path pretrained_model = old_job.train_task().get_snapshot(epoch) break elif form.method.data == 'pretrained': pretrained_job = scheduler.get_job(form.pretrained_networks.data) model_def_path = pretrained_job.get_model_def_path() weights_path = pretrained_job.get_weights_path() network = fw.get_network_from_path(model_def_path) pretrained_model = weights_path elif form.method.data == 'custom': network = fw.get_network_from_desc(form.custom_network.data) pretrained_model = form.custom_network_snapshot.data.strip() else: raise werkzeug.exceptions.BadRequest( 'Unrecognized method: "%s"' % form.method.data) policy = {'policy': form.lr_policy.data} if form.lr_policy.data == 'fixed': pass elif form.lr_policy.data == 'step': policy['stepsize'] = form.lr_step_size.data policy['gamma'] = form.lr_step_gamma.data elif form.lr_policy.data == 'multistep': policy['stepvalue'] = form.lr_multistep_values.data policy['gamma'] = form.lr_multistep_gamma.data elif form.lr_policy.data == 'exp': policy['gamma'] = form.lr_exp_gamma.data elif form.lr_policy.data == 'inv': policy['gamma'] = form.lr_inv_gamma.data policy['power'] = form.lr_inv_power.data elif form.lr_policy.data == 'poly': policy['power'] = form.lr_poly_power.data elif form.lr_policy.data == 'sigmoid': policy['stepsize'] = form.lr_sigmoid_step.data policy['gamma'] = form.lr_sigmoid_gamma.data else: raise werkzeug.exceptions.BadRequest( 'Invalid learning rate policy') if config_value('caffe')['multi_gpu']: if form.select_gpus.data: selected_gpus = [str(gpu) for gpu in form.select_gpus.data] gpu_count = None elif form.select_gpu_count.data: gpu_count = form.select_gpu_count.data selected_gpus = None else: gpu_count = 1 selected_gpus = None else: if form.select_gpu.data == 'next': gpu_count = 1 selected_gpus = None else: selected_gpus = [str(form.select_gpu.data)] gpu_count = None # Set up data augmentation structure data_aug = {} data_aug['flip'] = form.aug_flip.data data_aug['quad_rot'] = form.aug_quad_rot.data data_aug['rot'] = form.aug_rot.data data_aug['scale'] = form.aug_scale.data data_aug['noise'] = form.aug_noise.data data_aug['contrast'] = form.aug_contrast.data data_aug['whitening'] = form.aug_whitening.data data_aug['hsv_use'] = form.aug_hsv_use.data data_aug['hsv_h'] = form.aug_hsv_h.data data_aug['hsv_s'] = form.aug_hsv_s.data data_aug['hsv_v'] = form.aug_hsv_v.data # Python Layer File may be on the server or copied from the client. fs.copy_python_layer_file( bool(form.python_layer_from_client.data), job.dir(), (flask.request.files[form.python_layer_client_file.name] if form.python_layer_client_file.name in flask.request.files else ''), form.python_layer_server_file.data) job.tasks.append(fw.create_train_task( job=job, dataset=datasetJob, train_epochs=form.train_epochs.data, snapshot_interval=form.snapshot_interval.data, learning_rate=form.learning_rate.data[0], lr_policy=policy, gpu_count=gpu_count, selected_gpus=selected_gpus, batch_size=form.batch_size.data[0], batch_accumulation=form.batch_accumulation.data, val_interval=form.val_interval.data, traces_interval=form.traces_interval.data, pretrained_model=pretrained_model, crop_size=form.crop_size.data, use_mean=form.use_mean.data, network=network, random_seed=form.random_seed.data, solver_type=form.solver_type.data, rms_decay=form.rms_decay.data, shuffle=form.shuffle.data, data_aug=data_aug, ) ) # Save form data with the job so we can easily clone it later. save_form_to_job(job, form) jobs.append(job) scheduler.add_job(job) if n_jobs == 1: if request_wants_json(): return flask.jsonify(job.json_dict()) else: return flask.redirect(flask.url_for('digits.model.views.show', job_id=job.id())) except: if job: scheduler.delete_job(job) raise if request_wants_json(): return flask.jsonify(jobs=[j.json_dict() for j in jobs]) # If there are multiple jobs launched, go to the home page. return flask.redirect('/') def show(job, related_jobs=None): """ Called from digits.model.views.models_show() """ return flask.render_template( 'models/images/classification/show.html', job=job, framework_ids=[ fw.get_id() for fw in frameworks.get_frameworks() ], related_jobs=related_jobs ) @blueprint.route('/timeline_tracing', methods=['GET']) def timeline_tracing(): """ Shows timeline trace of a model """ job = job_from_request() return flask.render_template('models/timeline_tracing.html', job=job) @blueprint.route('/large_graph', methods=['GET']) def large_graph(): """ Show the loss/accuracy graph, but bigger """ job = job_from_request() return flask.render_template('models/large_graph.html', job=job) @blueprint.route('/classify_one/json', methods=['POST']) @blueprint.route('/classify_one', methods=['POST', 'GET']) def classify_one(): """ Classify one image and return the top 5 classifications Returns JSON when requested: {predictions: {category: confidence,...}} """ model_job = job_from_request() remove_image_path = False if 'image_path' in flask.request.form and flask.request.form['image_path']: image_path = flask.request.form['image_path'] elif 'image_file' in flask.request.files and flask.request.files['image_file']: outfile = tempfile.mkstemp(suffix='.png') flask.request.files['image_file'].save(outfile[1]) image_path = outfile[1] os.close(outfile[0]) remove_image_path = True else: raise werkzeug.exceptions.BadRequest('must provide image_path or image_file') 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' # create inference job inference_job = ImageInferenceJob( username=utils.auth.get_username(), name="Classify One Image", model=model_job, images=[image_path], epoch=epoch, layers=layers ) # schedule tasks scheduler.add_job(inference_job) # wait for job to complete inference_job.wait_completion() # retrieve inference data inputs, outputs, visualizations = inference_job.get_data() # set return status code status_code = 500 if inference_job.status == 'E' else 200 # delete job scheduler.delete_job(inference_job) if remove_image_path: os.remove(image_path) image = None predictions = [] if inputs is not None and len(inputs['data']) == 1: image = utils.image.embed_image_html(inputs['data'][0]) # convert to class probabilities for viewing last_output_name, last_output_data = outputs.items()[-1] if len(last_output_data) == 1: scores = last_output_data[0].flatten() indices = (-scores).argsort() labels = model_job.train_task().get_labels() predictions = [] for i in indices: # ignore prediction if we don't have a label for the corresponding class # the user might have set the final fully-connected layer's num_output to # too high a value if i < len(labels): predictions.append((labels[i], scores[i])) predictions = [(p[0], round(100.0 * p[1], 2)) for p in predictions[:5]] if request_wants_json(): return flask.jsonify({'predictions': predictions}), status_code else: return flask.render_template('models/images/classification/classify_one.html', model_job=model_job, job=inference_job, image_src=image, predictions=predictions, visualizations=visualizations, total_parameters=sum(v['param_count'] for v in visualizations if v['vis_type'] == 'Weights'), ), status_code @blueprint.route('/classify_many/json', methods=['POST']) @blueprint.route('/classify_many', methods=['POST', 'GET']) def classify_many(): """ Classify many images and return the top 5 classifications for each Returns JSON when requested: {classifications: {filename: [[category,confidence],...],...}} """ model_job = job_from_request() image_list = flask.request.files.get('image_list') if not image_list: raise werkzeug.exceptions.BadRequest('image_list is a required field') if 'image_folder' in flask.request.form and flask.request.form['image_folder'].strip(): image_folder = flask.request.form['image_folder'] if not os.path.exists(image_folder): raise werkzeug.exceptions.BadRequest('image_folder "%s" does not exit' % image_folder) else: image_folder = None if 'num_test_images' in flask.request.form and flask.request.form['num_test_images'].strip(): num_test_images = int(flask.request.form['num_test_images']) else: num_test_images = None epoch = None if 'snapshot_epoch' in flask.request.form: epoch = float(flask.request.form['snapshot_epoch']) paths, ground_truths = read_image_list(image_list, image_folder, num_test_images) # create inference job inference_job = ImageInferenceJob( username=utils.auth.get_username(), name="Classify Many Images", model=model_job, images=paths, epoch=epoch, layers='none' ) # schedule tasks scheduler.add_job(inference_job) # wait for job to complete inference_job.wait_completion() # retrieve inference data inputs, outputs, _ = inference_job.get_data() # set return status code status_code = 500 if inference_job.status == 'E' else 200 # delete job scheduler.delete_job(inference_job) if outputs is not None and len(outputs) < 1: # an error occurred outputs = None if inputs is not None: # retrieve path and ground truth of images that were successfully processed paths = [paths[idx] for idx in inputs['ids']] ground_truths = [ground_truths[idx] for idx in inputs['ids']] # defaults classifications = None show_ground_truth = None top1_accuracy = None top5_accuracy = None confusion_matrix = None per_class_accuracy = None labels = None if outputs is not None: # convert to class probabilities for viewing last_output_name, last_output_data = outputs.items()[-1] if len(last_output_data) < 1: raise werkzeug.exceptions.BadRequest( 'Unable to classify any image from the file') scores = last_output_data # take top 5 indices = (-scores).argsort()[:, :5] labels = model_job.train_task().get_labels() n_labels = len(labels) # remove invalid ground truth ground_truths = [x if x is not None and (0 <= x < n_labels) else None for x in ground_truths] # how many pieces of ground truth to we have? n_ground_truth = len([1 for x in ground_truths if x is not None]) show_ground_truth = n_ground_truth > 0 # compute classifications and statistics classifications = [] n_top1_accurate = 0 n_top5_accurate = 0 confusion_matrix = np.zeros((n_labels, n_labels), dtype=np.dtype(int)) for image_index, index_list in enumerate(indices): result = [] if ground_truths[image_index] is not None: if ground_truths[image_index] == index_list[0]: n_top1_accurate += 1 if ground_truths[image_index] in index_list: n_top5_accurate += 1 if (0 <= ground_truths[image_index] < n_labels) and (0 <= index_list[0] < n_labels): confusion_matrix[ground_truths[image_index], index_list[0]] += 1 for i in index_list: # `i` is a category in labels and also an index into scores # ignore prediction if we don't have a label for the corresponding class # the user might have set the final fully-connected layer's num_output to # too high a value if i < len(labels): result.append((labels[i], round(100.0 * scores[image_index, i], 2))) classifications.append(result) # accuracy if show_ground_truth: top1_accuracy = round(100.0 * n_top1_accurate / n_ground_truth, 2) top5_accuracy = round(100.0 * n_top5_accurate / n_ground_truth, 2) per_class_accuracy = [] for x in xrange(n_labels): n_examples = sum(confusion_matrix[x]) per_class_accuracy.append( round(100.0 * confusion_matrix[x, x] / n_examples, 2) if n_examples > 0 else None) else: top1_accuracy = None top5_accuracy = None per_class_accuracy = None # replace ground truth indices with labels ground_truths = [labels[x] if x is not None and (0 <= x < n_labels) else None for x in ground_truths] if request_wants_json(): joined = dict(zip(paths, classifications)) return flask.jsonify({'classifications': joined}), status_code else: return flask.render_template('models/images/classification/classify_many.html', model_job=model_job, job=inference_job, paths=paths, classifications=classifications, show_ground_truth=show_ground_truth, ground_truths=ground_truths, top1_accuracy=top1_accuracy, top5_accuracy=top5_accuracy, confusion_matrix=confusion_matrix, per_class_accuracy=per_class_accuracy, labels=labels, ), status_code @blueprint.route('/top_n', methods=['POST']) def top_n(): """ Classify many images and show the top N images per category by confidence """ model_job = job_from_request() image_list = flask.request.files['image_list'] if not image_list: raise werkzeug.exceptions.BadRequest('File upload not found') epoch = None if 'snapshot_epoch' in flask.request.form: epoch = float(flask.request.form['snapshot_epoch']) if 'top_n' in flask.request.form and flask.request.form['top_n'].strip(): top_n = int(flask.request.form['top_n']) else: top_n = 9 if 'image_folder' in flask.request.form and flask.request.form['image_folder'].strip(): image_folder = flask.request.form['image_folder'] if not os.path.exists(image_folder): raise werkzeug.exceptions.BadRequest('image_folder "%s" does not exit' % image_folder) else: image_folder = None if 'num_test_images' in flask.request.form and flask.request.form['num_test_images'].strip(): num_test_images = int(flask.request.form['num_test_images']) else: num_test_images = None paths, _ = read_image_list(image_list, image_folder, num_test_images) # create inference job inference_job = ImageInferenceJob( username=utils.auth.get_username(), name="TopN Image Classification", model=model_job, images=paths, epoch=epoch, layers='none' ) # schedule tasks scheduler.add_job(inference_job) # wait for job to complete inference_job.wait_completion() # retrieve inference data inputs, outputs, _ = inference_job.get_data() # delete job scheduler.delete_job(inference_job) results = None if outputs is not None and len(outputs) > 0: # convert to class probabilities for viewing last_output_name, last_output_data = outputs.items()[-1] scores = last_output_data if scores is None: raise RuntimeError('An error occurred while processing the images') labels = model_job.train_task().get_labels() images = inputs['data'] indices = (-scores).argsort(axis=0)[:top_n] results = [] # Can't have more images per category than the number of images images_per_category = min(top_n, len(images)) # Can't have more categories than the number of labels or the number of outputs n_categories = min(indices.shape[1], len(labels)) for i in xrange(n_categories): result_images = [] for j in xrange(images_per_category): result_images.append(images[indices[j][i]]) results.append(( labels[i], utils.image.embed_image_html( utils.image.vis_square(np.array(result_images), colormap='white') ) )) return flask.render_template('models/images/classification/top_n.html', model_job=model_job, job=inference_job, results=results, ) def get_datasets(): return [(j.id(), j.name()) for j in sorted( [j for j in scheduler.jobs.values() if isinstance(j, ImageClassificationDatasetJob) and (j.status.is_running() or j.status == Status.DONE)], cmp=lambda x, y: cmp(y.id(), x.id()) ) ] def get_standard_networks(): return [ ('lenet', 'LeNet'), ('alexnet', 'AlexNet'), ('googlenet', 'GoogLeNet'), ] def get_default_standard_network(): return 'alexnet' def get_previous_networks(): return [(j.id(), j.name()) for j in sorted( [j for j in scheduler.jobs.values() if isinstance(j, ImageClassificationModelJob)], cmp=lambda x, y: cmp(y.id(), x.id()) ) ] def get_previous_networks_fulldetails(): return [(j) for j in sorted( [j for j in scheduler.jobs.values() if isinstance(j, ImageClassificationModelJob)], cmp=lambda x, y: cmp(y.id(), x.id()) ) ] 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 get_pretrained_networks(): return [(j.id(), j.name()) for j in sorted( [j for j in scheduler.jobs.values() if isinstance(j, PretrainedModelJob)], cmp=lambda x, y: cmp(y.id(), x.id()) ) ] def get_pretrained_networks_fulldetails(): return [(j) for j in sorted( [j for j in scheduler.jobs.values() if isinstance(j, PretrainedModelJob)], cmp=lambda x, y: cmp(y.id(), x.id()) ) ]
DIGITS-master
digits/model/images/classification/views.py
# Copyright (c) 2015-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import import os.path from ..job import ImageModelJob from digits.utils import subclass, override # NOTE: Increment this every time the pickled object changes PICKLE_VERSION = 1 @subclass class GenericImageModelJob(ImageModelJob): """ A Job that creates an image model for a generic network """ def __init__(self, **kwargs): super(GenericImageModelJob, self).__init__(**kwargs) self.pickver_job_model_image_generic = PICKLE_VERSION @override def job_type(self): return 'Generic Image Model' @override def download_files(self, epoch=-1): task = self.train_task() snapshot_filenames = task.get_snapshot(epoch, download=True) # get model files model_files = task.get_model_files() download_files = [(self.path(filename), os.path.basename(filename)) for filename in model_files.values()] if task.dataset.get_mean_file(): download_files.append(( task.dataset.path(task.dataset.get_mean_file()), os.path.basename(task.dataset.get_mean_file()))) # add snapshot if not isinstance(snapshot_filenames, list): download_files.append((snapshot_filenames, os.path.basename(snapshot_filenames))) else: for snapshot_filename in snapshot_filenames: download_files.append((snapshot_filename, os.path.basename(snapshot_filename))) return download_files
DIGITS-master
digits/model/images/generic/job.py
# Copyright (c) 2015-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from .job import GenericImageModelJob __all__ = ['GenericImageModelJob']
DIGITS-master
digits/model/images/generic/__init__.py
# Copyright (c) 2015-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import import itertools import json import numpy as np import os import PIL.Image import tempfile import time import unittest # Find the best implementation available try: from cStringIO import StringIO except ImportError: from StringIO import StringIO from bs4 import BeautifulSoup from digits import extensions from digits.config import config_value import digits.dataset.images.generic.test_views import digits.dataset.generic.test_views import digits.test_views from digits import test_utils import digits.webapp # May be too short on a slow system TIMEOUT_DATASET = 45 TIMEOUT_MODEL = 60 ################################################################################ # Base classes (they don't start with "Test" so nose won't run them) ################################################################################ class BaseViewsTest(digits.test_views.BaseViewsTest): """ Provides some functions """ CAFFE_NETWORK = \ """ layer { name: "scale" type: "Power" bottom: "data" top: "scale" power_param { scale: 0.004 } } layer { name: "hidden" type: "InnerProduct" bottom: "scale" top: "output" inner_product_param { num_output: 2 } } layer { name: "loss" type: "EuclideanLoss" bottom: "output" bottom: "label" top: "loss" exclude { stage: "deploy" } } """ TORCH_NETWORK = \ """ return function(p) local nDim = 1 if p.inputShape then p.inputShape:apply(function(x) nDim=nDim*x end) end local net = nn.Sequential() net:add(nn.MulConstant(0.004)) net:add(nn.View(-1):setNumInputDims(3)) -- flatten -- set all weights and biases to zero as this speeds learning up -- for the type of problem we're trying to solve in this test local linearLayer = nn.Linear(nDim, 2) linearLayer.weight:fill(0) linearLayer.bias:fill(0) net:add(linearLayer) -- c*h*w -> 2 return { model = net, loss = nn.MSECriterion(), } end """ TENSORFLOW_NETWORK = \ """ class UserModel(Tower): @model_property def inference(self): ninputs = self.input_shape[0] * self.input_shape[1] * self.input_shape[2] W = tf.get_variable('W', [ninputs, 2], initializer=tf.constant_initializer(0.0)) b = tf.get_variable('b', [2], initializer=tf.constant_initializer(0.0)), model = tf.reshape(self.x, shape=[-1, ninputs]) * 0.004 model = tf.add(tf.matmul(model, W), b) return model @model_property def loss(self): y = tf.reshape(self.y, shape=[-1, 2]) return digits.mse_loss(self.inference, y) """ @classmethod def model_exists(cls, job_id): return cls.job_exists(job_id, 'models') @classmethod def model_status(cls, job_id): return cls.job_status(job_id, 'models') @classmethod def abort_model(cls, job_id): return cls.abort_job(job_id, job_type='models') @classmethod def model_wait_completion(cls, job_id, **kwargs): kwargs['job_type'] = 'models' if 'timeout' not in kwargs: kwargs['timeout'] = TIMEOUT_MODEL return cls.job_wait_completion(job_id, **kwargs) @classmethod def delete_model(cls, job_id): return cls.delete_job(job_id, job_type='models') @classmethod def network(cls): if cls.FRAMEWORK == 'torch': return cls.TORCH_NETWORK elif cls.FRAMEWORK == 'caffe': return cls.CAFFE_NETWORK elif cls.FRAMEWORK == 'tensorflow': return cls.TENSORFLOW_NETWORK else: raise ValueError('Unknown framework %s' % cls.FRAMEWORK) class BaseViewsTestWithAnyDataset(BaseViewsTest): """ Provides a dataset This is a common interface to work with either "images/generic" datasets or "generic" datasets. The dataset type to use is chosen further down in the class hierarchy, see e.g. BaseViewsTestWithDataset """ # Inherited classes may want to override these attributes CROP_SIZE = None TRAIN_EPOCHS = 3 LR_POLICY = None LEARNING_RATE = None BATCH_SIZE = 10 @classmethod def setUpClass(cls, **kwargs): super(BaseViewsTestWithAnyDataset, cls).setUpClass(**kwargs) cls.created_models = [] @classmethod def tearDownClass(cls): # delete any created datasets for job_id in cls.created_models: cls.delete_model(job_id) super(BaseViewsTestWithAnyDataset, cls).tearDownClass() @classmethod def create_model(cls, learning_rate=None, **kwargs): """ Create a model Returns the job_id Raise RuntimeError if job fails to create Keyword arguments: **kwargs -- data to be sent with POST request """ if learning_rate is None: learning_rate = cls.LEARNING_RATE data = { 'model_name': 'test_model', 'group_name': 'test_group', 'dataset': cls.dataset_id, 'method': 'custom', 'custom_network': cls.network(), 'batch_size': cls.BATCH_SIZE, 'train_epochs': cls.TRAIN_EPOCHS, 'random_seed': 0xCAFEBABE, 'framework': cls.FRAMEWORK, } if cls.CROP_SIZE is not None: data['crop_size'] = cls.CROP_SIZE if cls.LR_POLICY is not None: data['lr_policy'] = cls.LR_POLICY if learning_rate is not None: data['learning_rate'] = learning_rate data.update(kwargs) request_json = data.pop('json', False) url = '/models/images/generic' if request_json: url += '/json' rv = cls.app.post(url, data=data) if request_json: if rv.status_code != 200: print json.loads(rv.data) raise RuntimeError('Model creation failed with %s' % rv.status_code) data = json.loads(rv.data) if 'jobs' in data.keys(): return [j['id'] for j in data['jobs']] else: return data['id'] # expect a redirect if not 300 <= rv.status_code <= 310: print 'Status code:', rv.status_code s = BeautifulSoup(rv.data, 'html.parser') div = s.select('div.alert-danger') if div: print div[0] else: print rv.data raise RuntimeError('Failed to create dataset - status %s' % rv.status_code) job_id = cls.job_id_from_response(rv) assert cls.model_exists(job_id), 'model not found after successful creation' cls.created_models.append(job_id) return job_id class BaseViewsTestWithDataset(BaseViewsTestWithAnyDataset, digits.dataset.images.generic.test_views.BaseViewsTestWithDataset): """ This inherits from BaseViewsTestWithAnyDataset and digits.dataset.images.generic.test_views.BaseViewsTestWithDataset in order to provide an interface to test models on "images/generic" datasets """ pass class BaseViewsTestWithModelWithAnyDataset(BaseViewsTestWithAnyDataset): """ Provides a model """ @classmethod def setUpClass(cls, **kwargs): use_mean = kwargs.pop('use_mean', None) super(BaseViewsTestWithModelWithAnyDataset, cls).setUpClass(**kwargs) cls.model_id = cls.create_model(json=True, use_mean=use_mean) assert cls.model_wait_completion(cls.model_id) == 'Done', 'create failed' class BaseTestViews(BaseViewsTest): """ Tests which don't require a dataset or a model """ def test_page_model_new(self): rv = self.app.get('/models/images/generic/new') assert rv.status_code == 200, 'page load failed with %s' % rv.status_code assert 'New Image Model' in rv.data, 'unexpected page format' def test_nonexistent_model(self): assert not self.model_exists('foo'), "model shouldn't exist" def test_view_config(self): extension = extensions.view.get_default_extension() rv = self.app.get('/models/view-config/%s' % extension.get_id()) assert rv.status_code == 200, 'page load failed with %s' % rv.status_code def test_visualize_network(self): rv = self.app.post('/models/visualize-network?framework=' + self.FRAMEWORK, data={'custom_network': self.network()} ) s = BeautifulSoup(rv.data, 'html.parser') body = s.select('body') if rv.status_code != 200: body = s.select('body')[0] if 'InvocationException' in str(body): raise unittest.SkipTest('GraphViz not installed') raise AssertionError('POST failed with %s\n\n%s' % (rv.status_code, body)) image = s.select('img') assert image is not None, "didn't return an image" class BaseTestCreation(BaseViewsTestWithDataset): """ Model creation tests """ def test_create_json(self): job_id = self.create_model(json=True) self.abort_model(job_id) def test_create_delete(self): job_id = self.create_model() assert self.delete_model(job_id) == 200, 'delete failed' assert not self.model_exists(job_id), 'model exists after delete' def test_create_wait_delete(self): job_id = self.create_model() assert self.model_wait_completion(job_id) == 'Done', 'create failed' assert self.delete_model(job_id) == 200, 'delete failed' assert not self.model_exists(job_id), 'model exists after delete' def test_create_abort_delete(self): job_id = self.create_model() assert self.abort_model(job_id) == 200, 'abort failed' assert self.delete_model(job_id) == 200, 'delete failed' assert not self.model_exists(job_id), 'model exists after delete' def test_snapshot_interval_2(self): job_id = self.create_model(snapshot_interval=0.5) assert self.model_wait_completion(job_id) == 'Done', 'create failed' rv = self.app.get('/models/%s/json' % job_id) assert rv.status_code == 200, 'json load failed with %s' % rv.status_code content = json.loads(rv.data) assert len(content['snapshots']) > 1, 'should take >1 snapshot' def test_snapshot_interval_0_5(self): job_id = self.create_model(train_epochs=4, snapshot_interval=2) assert self.model_wait_completion(job_id) == 'Done', 'create failed' rv = self.app.get('/models/%s/json' % job_id) assert rv.status_code == 200, 'json load failed with %s' % rv.status_code content = json.loads(rv.data) assert len(content['snapshots']) == 2, 'should take 2 snapshots' @unittest.skipIf( not config_value('gpu_list'), 'no GPUs selected') @unittest.skipIf( not config_value('caffe')['cuda_enabled'], 'CUDA disabled') @unittest.skipIf( config_value('caffe')['multi_gpu'], 'multi-GPU enabled') def test_select_gpu(self): for index in config_value('gpu_list').split(','): yield self.check_select_gpu, index def check_select_gpu(self, gpu_index): job_id = self.create_model(select_gpu=gpu_index) assert self.model_wait_completion(job_id) == 'Done', 'create failed' @unittest.skipIf( not config_value('gpu_list'), 'no GPUs selected') @unittest.skipIf( not config_value('caffe')['cuda_enabled'], 'CUDA disabled') @unittest.skipIf( not config_value('caffe')['multi_gpu'], 'multi-GPU disabled') def test_select_gpus(self): # test all possible combinations gpu_list = config_value('gpu_list').split(',') for i in xrange(len(gpu_list)): for combination in itertools.combinations(gpu_list, i + 1): yield self.check_select_gpus, combination def check_select_gpus(self, gpu_list): job_id = self.create_model(select_gpus_list=','.join(gpu_list), batch_size=len(gpu_list)) assert self.model_wait_completion(job_id) == 'Done', 'create failed' def infer_one_for_job(self, job_id): # carry out one inference test per category in dataset image_path = os.path.join(self.imageset_folder, self.test_image) with open(image_path, 'rb') as infile: # StringIO wrapping is needed to simulate POST file upload. image_upload = (StringIO(infile.read()), 'image.png') rv = self.app.post( '/models/images/generic/infer_one?job_id=%s' % job_id, data={ 'image_file': image_upload, 'show_visualizations': 'y', } ) s = BeautifulSoup(rv.data, 'html.parser') body = s.select('body') assert rv.status_code == 200, 'POST failed with %s\n\n%s' % (rv.status_code, body) def test_infer_one_mean_image(self): # test the creation job_id = self.create_model(use_mean='image') assert self.model_wait_completion(job_id) == 'Done', 'job failed' self.infer_one_for_job(job_id) def test_infer_one_mean_pixel(self): # test the creation job_id = self.create_model(use_mean='pixel') assert self.model_wait_completion(job_id) == 'Done', 'job failed' self.infer_one_for_job(job_id) def test_infer_one_mean_none(self): # test the creation job_id = self.create_model(use_mean='none') assert self.model_wait_completion(job_id) == 'Done', 'job failed' self.infer_one_for_job(job_id) def test_retrain(self): job1_id = self.create_model() assert self.model_wait_completion(job1_id) == 'Done', 'first job failed' rv = self.app.get('/models/%s/json' % job1_id) assert rv.status_code == 200, 'json load failed with %s' % rv.status_code content = json.loads(rv.data) assert len(content['snapshots']), 'should have at least snapshot' options = { 'method': 'previous', 'previous_networks': job1_id, } options['%s-snapshot' % job1_id] = content['snapshots'][-1] job2_id = self.create_model(**options) assert self.model_wait_completion(job2_id) == 'Done', 'second job failed' def test_retrain_twice(self): # retrain from a job which already had a pretrained model job1_id = self.create_model() assert self.model_wait_completion(job1_id) == 'Done', 'first job failed' rv = self.app.get('/models/%s/json' % job1_id) assert rv.status_code == 200, 'json load failed with %s' % rv.status_code content = json.loads(rv.data) assert len(content['snapshots']), 'should have at least snapshot' options_2 = { 'method': 'previous', 'previous_networks': job1_id, } options_2['%s-snapshot' % job1_id] = content['snapshots'][-1] job2_id = self.create_model(**options_2) assert self.model_wait_completion(job2_id) == 'Done', 'second job failed' options_3 = { 'method': 'previous', 'previous_networks': job2_id, } options_3['%s-snapshot' % job2_id] = -1 job3_id = self.create_model(**options_3) assert self.model_wait_completion(job3_id) == 'Done', 'third job failed' def test_diverging_network(self): if self.FRAMEWORK == 'caffe': raise unittest.SkipTest('Test not implemented for Caffe') job_id = self.create_model(json=True, learning_rate=1e15) assert self.model_wait_completion(job_id) == 'Error', 'job should have failed' job_info = self.job_info_html(job_id=job_id, job_type='models') assert 'Try decreasing your learning rate' in job_info def test_clone(self): options_1 = { 'shuffle': True, 'lr_step_size': 33.0, 'previous_networks': 'None', 'lr_inv_power': 0.5, 'lr_inv_gamma': 0.1, 'lr_poly_power': 3.0, 'lr_exp_gamma': 0.95, 'use_mean': 'image', 'custom_network_snapshot': '', 'lr_multistep_gamma': 0.5, 'lr_policy': 'step', 'crop_size': None, 'val_interval': 3.0, 'random_seed': 123, 'learning_rate': 0.01, 'standard_networks': 'None', 'lr_step_gamma': 0.1, 'lr_sigmoid_step': 50.0, 'lr_sigmoid_gamma': 0.1, 'lr_multistep_values': '50,85', 'solver_type': 'SGD', } job1_id = self.create_model(**options_1) assert self.model_wait_completion(job1_id) == 'Done', 'first job failed' rv = self.app.get('/models/%s/json' % job1_id) assert rv.status_code == 200, 'json load failed with %s' % rv.status_code content1 = json.loads(rv.data) # Clone job1 as job2 options_2 = { 'clone': job1_id, } job2_id = self.create_model(**options_2) assert self.model_wait_completion(job2_id) == 'Done', 'second job failed' rv = self.app.get('/models/%s/json' % job2_id) assert rv.status_code == 200, 'json load failed with %s' % rv.status_code content2 = json.loads(rv.data) # These will be different content1.pop('id') content2.pop('id') content1.pop('directory') content2.pop('directory') content1.pop('creation time') content2.pop('creation time') content1.pop('job id') content2.pop('job id') assert (content1 == content2), 'job content does not match' job1 = digits.webapp.scheduler.get_job(job1_id) job2 = digits.webapp.scheduler.get_job(job2_id) assert (job1.form_data == job2.form_data), 'form content does not match' class BaseTestCreatedWithAnyDataset(BaseViewsTestWithModelWithAnyDataset): """ Tests on a model that has already been created """ def test_save(self): job = digits.webapp.scheduler.get_job(self.model_id) assert job.save(), 'Job failed to save' def test_get_snapshot(self): job = digits.webapp.scheduler.get_job(self.model_id) task = job.train_task() f = task.get_snapshot(-1) assert f, "Failed to load snapshot" filename = task.get_snapshot_filename(-1) assert filename, "Failed to get filename" def test_download(self): for extension in ['tar', 'zip', 'tar.gz', 'tar.bz2']: yield self.check_download, extension def check_download(self, extension): url = '/models/%s/download.%s' % (self.model_id, extension) rv = self.app.get(url) assert rv.status_code == 200, 'download "%s" failed with %s' % (url, rv.status_code) def test_index_json(self): rv = self.app.get('/index/json') assert rv.status_code == 200, 'page load failed with %s' % rv.status_code content = json.loads(rv.data) found = False for m in content['models']: if m['id'] == self.model_id: found = True break assert found, 'model not found in list' def test_model_json(self): rv = self.app.get('/models/%s/json' % self.model_id) assert rv.status_code == 200, 'page load failed with %s' % rv.status_code content = json.loads(rv.data) assert content['id'] == self.model_id, 'expected different job_id' assert len(content['snapshots']) > 0, 'no snapshots in list' def test_edit_name(self): status = self.edit_job( self.dataset_id, name='new name' ) assert status == 200, 'failed with %s' % status def test_edit_notes(self): status = self.edit_job( self.dataset_id, notes='new notes' ) assert status == 200, 'failed with %s' % status def test_infer_one(self): image_path = os.path.join(self.imageset_folder, self.test_image) with open(image_path, 'rb') as infile: # StringIO wrapping is needed to simulate POST file upload. image_upload = (StringIO(infile.read()), 'image.png') rv = self.app.post( '/models/images/generic/infer_one?job_id=%s' % self.model_id, data={ 'image_file': image_upload, 'show_visualizations': 'y', } ) s = BeautifulSoup(rv.data, 'html.parser') body = s.select('body') assert rv.status_code == 200, 'POST failed with %s\n\n%s' % (rv.status_code, body) def test_infer_one_json(self): image_path = os.path.join(self.imageset_folder, self.test_image) with open(image_path, 'rb') as infile: # StringIO wrapping is needed to simulate POST file upload. image_upload = (StringIO(infile.read()), 'image.png') rv = self.app.post( '/models/images/generic/infer_one/json?job_id=%s' % self.model_id, data={ 'image_file': image_upload, } ) assert rv.status_code == 200, 'POST failed with %s' % rv.status_code data = json.loads(rv.data) assert data['outputs']['output'][0][0] > 0 and \ data['outputs']['output'][0][1] > 0, \ 'image regression result is wrong: %s' % data['outputs']['output'] def test_infer_many(self): # use the same image twice to make a list of two images textfile_images = '%s\n%s\n' % (self.test_image, self.test_image) # StringIO wrapping is needed to simulate POST file upload. file_upload = (StringIO(textfile_images), 'images.txt') rv = self.app.post( '/models/images/generic/infer_many?job_id=%s' % self.model_id, data={'image_list': file_upload} ) s = BeautifulSoup(rv.data, 'html.parser') body = s.select('body') assert rv.status_code == 200, 'POST failed with %s\n\n%s' % (rv.status_code, body) headers = s.select('table.table th') assert headers is not None, 'unrecognized page format' def test_infer_db(self): if self.val_db_path is None: raise unittest.SkipTest('Class has no validation db') rv = self.app.post( '/models/images/generic/infer_db?job_id=%s' % self.model_id, data={'db_path': self.val_db_path} ) s = BeautifulSoup(rv.data, 'html.parser') body = s.select('body') assert rv.status_code == 200, 'POST failed with %s\n\n%s' % (rv.status_code, body) headers = s.select('table.table th') assert headers is not None, 'unrecognized page format' def test_infer_many_from_folder(self): textfile_images = '%s\n' % os.path.basename(self.test_image) # StringIO wrapping is needed to simulate POST file upload. file_upload = (StringIO(textfile_images), 'images.txt') # try selecting the extension explicitly extension = extensions.view.get_default_extension() extension_id = extension.get_id() rv = self.app.post( '/models/images/generic/infer_many?job_id=%s' % self.model_id, data={'image_list': file_upload, 'image_folder': os.path.dirname(self.test_image), 'view_extension_id': extension_id} ) s = BeautifulSoup(rv.data, 'html.parser') body = s.select('body') assert rv.status_code == 200, 'POST failed with %s\n\n%s' % (rv.status_code, body) headers = s.select('table.table th') assert headers is not None, 'unrecognized page format' def test_infer_many_json(self): textfile_images = '%s\n' % self.test_image # StringIO wrapping is needed to simulate POST file upload. file_upload = (StringIO(textfile_images), 'images.txt') rv = self.app.post( '/models/images/generic/infer_many/json?job_id=%s' % self.model_id, data={'image_list': file_upload} ) assert rv.status_code == 200, 'POST failed with %s' % rv.status_code data = json.loads(rv.data) assert 'outputs' in data, 'invalid response' def test_infer_db_json(self): if self.val_db_path is None: raise unittest.SkipTest('Class has no validation db') rv = self.app.post( '/models/images/generic/infer_db/json?job_id=%s' % self.model_id, data={'db_path': self.val_db_path} ) assert rv.status_code == 200, 'POST failed with %s\n\n%s' % (rv.status_code, rv.data) data = json.loads(rv.data) assert 'outputs' in data, 'invalid response' class BaseTestCreated(BaseTestCreatedWithAnyDataset, digits.dataset.images.generic.test_views.BaseViewsTestWithDataset): """ Tests on a model that has already been created with an "images/generic" dataset """ pass class BaseTestCreatedWithGradientDataExtension(BaseTestCreatedWithAnyDataset, digits.dataset.generic.test_views.BaseViewsTestWithDataset): """ Tests on a model that has already been created with a "generic" dataset, using the gradients extension in that instance """ EXTENSION_ID = "image-gradients" @classmethod def setUpClass(cls, **kwargs): if not hasattr(cls, 'imageset_folder'): # Create test image cls.imageset_folder = tempfile.mkdtemp() image_width = cls.IMAGE_WIDTH image_height = cls.IMAGE_HEIGHT yy, xx = np.mgrid[:image_height, :image_width].astype('float') xslope, yslope = 0.5, 0.5 a = xslope * 255 / image_width b = yslope * 255 / image_height test_image = a * (xx - image_width / 2) + b * (yy - image_height / 2) + 127.5 test_image = test_image.astype('uint8') pil_img = PIL.Image.fromarray(test_image) cls.test_image = os.path.join(cls.imageset_folder, 'test.png') pil_img.save(cls.test_image) # note: model created in BaseTestCreatedWithAnyDataset.setUpClass method super(BaseTestCreatedWithGradientDataExtension, cls).setUpClass() def test_infer_extension_json(self): rv = self.app.post( '/models/images/generic/infer_extension/json?job_id=%s' % self.model_id, data={ 'gradient_x': 0.5, 'gradient_y': -0.5, } ) assert rv.status_code == 200, 'POST failed with %s' % rv.status_code data = json.loads(rv.data) output = data['outputs'][data['outputs'].keys()[0]]['output'] assert output[0] > 0 and \ output[1] < 0, \ 'image regression result is wrong: %s' % data['outputs']['output'] class BaseTestCreatedWithImageProcessingExtension( BaseTestCreatedWithAnyDataset, digits.dataset.generic.test_views.BaseViewsTestWithDataset): """ Test Image processing extension with a dummy identity network """ CAFFE_NETWORK = \ """ layer { name: "identity" type: "Power" bottom: "data" top: "output" } layer { name: "loss" type: "EuclideanLoss" bottom: "output" bottom: "label" top: "loss" exclude { stage: "deploy" } } """ TORCH_NETWORK = \ """ return function(p) return { -- simple identity network model = nn.Sequential():add(nn.Identity()), loss = nn.MSECriterion(), } end """ TENSORFLOW_NETWORK = \ """ class UserModel(Tower): @model_property def inference(self): scale = tf.get_variable('scale', [1], initializer=tf.constant_initializer(1.0)) offset = tf.get_variable('offset', [1], initializer=tf.constant_initializer(0.)) offset = tf.Print(offset,[scale, offset], message='scale offset') model = self.x + offset self.model = model return tf.transpose(model, (0, 3, 1, 2)) # net output expected in NCHW format @model_property def loss(self): return digits.mse_loss(self.model, self.y) """ EXTENSION_ID = "image-processing" VARIABLE_SIZE_DATASET = False NUM_IMAGES = 100 MEAN = 'none' @classmethod def setUpClass(cls, **kwargs): if cls.VARIABLE_SIZE_DATASET: cls.BATCH_SIZE = 1 cls.create_variable_size_random_imageset( num_images=cls.NUM_IMAGES) else: cls.create_random_imageset( num_images=cls.NUM_IMAGES, image_width=cls.IMAGE_WIDTH, image_height=cls.IMAGE_HEIGHT) super(BaseTestCreatedWithImageProcessingExtension, cls).setUpClass( feature_folder=cls.imageset_folder, label_folder=cls.imageset_folder, channel_conversion='L', dsopts_force_same_shape='0' if cls.VARIABLE_SIZE_DATASET else '1', use_mean=cls.MEAN) def test_infer_one_json(self): image_path = os.path.join(self.imageset_folder, self.test_image) with open(image_path, 'rb') as infile: # StringIO wrapping is needed to simulate POST file upload. image_upload = (StringIO(infile.read()), 'image.png') rv = self.app.post( '/models/images/generic/infer_one/json?job_id=%s' % self.model_id, data={'image_file': image_upload} ) assert rv.status_code == 200, 'POST failed with %s' % rv.status_code data = json.loads(rv.data) data_shape = np.array(data['outputs']['output']).shape if not self.VARIABLE_SIZE_DATASET: if data_shape != (1, self.CHANNELS, self.IMAGE_WIDTH, self.IMAGE_HEIGHT): raise ValueError("Shapes differ: got %s expected %s" % (repr(data_shape), repr((1, self.CHANNELS, self.IMAGE_WIDTH, self.IMAGE_HEIGHT)))) def test_infer_one_noresize_json(self): if self.FRAMEWORK == 'tensorflow' and self.MEAN == 'image': raise unittest.SkipTest('Mean image subtraction not supported on ' 'variable-size input with Tensorflow') # create large random image shape = (self.CHANNELS, 10 * self.IMAGE_HEIGHT, 5 * self.IMAGE_WIDTH) x = np.random.randint( low=0, high=256, size=shape) if self.CHANNELS == 1: # drop channel dimension x = x[0] x = x.astype('uint8') pil_img = PIL.Image.fromarray(x) # create output stream s = StringIO() pil_img.save(s, format="png") # create input stream s = StringIO(s.getvalue()) image_upload = (s, 'image.png') # post request rv = self.app.post( '/models/images/generic/infer_one/json?job_id=%s' % self.model_id, data={'image_file': image_upload, 'dont_resize': 'y'} ) assert rv.status_code == 200, 'POST failed with %s' % rv.status_code data = json.loads(rv.data) data_shape = np.array(data['outputs']['output']).shape if data_shape != (1,) + shape: raise ValueError("Shapes differ: got %s expected %s" % (repr(data_shape), repr((1,) + shape))) def test_infer_db(self): if self.VARIABLE_SIZE_DATASET: raise unittest.SkipTest('Skip variable-size inference test') super(BaseTestCreatedWithImageProcessingExtension, self).test_infer_db() def test_infer_db_json(self): if self.VARIABLE_SIZE_DATASET: raise unittest.SkipTest('Skip variable-size inference test') super(BaseTestCreatedWithImageProcessingExtension, self).test_infer_db_json() class BaseTestDatasetModelInteractions(BaseViewsTestWithDataset): """ Test the interactions between datasets and models """ # If you try to create a model using a deleted dataset, it should fail def test_create_model_deleted_dataset(self): dataset_id = self.create_dataset() assert self.delete_dataset(dataset_id) == 200, 'delete failed' assert not self.dataset_exists(dataset_id), 'dataset exists after delete' try: self.create_model(dataset=dataset_id) except RuntimeError: return assert False, 'Should have failed' # If you try to create a model using a running dataset, # it should wait to start until the dataset is completed def test_create_model_running_dataset(self): dataset_id = self.create_dataset() model_id = self.create_model(dataset=dataset_id) # Model should be in WAIT status while dataset is running # Copying functionality from job_wait_completion ... start_time = time.time() timeout = TIMEOUT_DATASET dataset_status = self.dataset_status(dataset_id) while dataset_status != 'Done': model_status = self.model_status(model_id) if model_status == 'Initialized': # give it some time ... pass elif model_status == 'Waiting': # That's what we were waiting for break else: raise Exception('Model not waiting - "%s"' % model_status) assert (time.time() - start_time) < timeout, 'Job took more than %s seconds' % timeout time.sleep(0.5) dataset_status = self.dataset_status(dataset_id) # Model should switch to RUN status after dataset is DONE assert self.dataset_wait_completion(dataset_id) == 'Done', 'dataset creation failed' time.sleep(1) assert self.model_status(model_id) in ['Running', 'Done'], "model didn't start" self.abort_model(model_id) # If you try to delete a completed dataset with a dependent model, it should fail def test_delete_dataset_dependent_model(self): dataset_id = self.create_dataset() model_id = self.create_model(dataset=dataset_id) assert self.dataset_wait_completion(dataset_id) == 'Done', 'dataset creation failed' assert self.delete_dataset(dataset_id) == 403, 'dataset deletion should not have succeeded' self.abort_model(model_id) # If you try to delete a running dataset with a dependent model, it should fail def test_delete_running_dataset_dependent_model(self): dataset_id = self.create_dataset() model_id = self.create_model(dataset=dataset_id) assert self.delete_dataset(dataset_id) == 403, 'dataset deletion should not have succeeded' self.abort_dataset(dataset_id) self.abort_model(model_id) class BaseTestCreatedCropInNetwork(BaseTestCreated): CAFFE_NETWORK = \ """ layer { name: "data" type: "Data" top: "data" include { phase: TRAIN } transform_param { crop_size: 8 } } layer { name: "data" type: "Data" top: "data" include { phase: TEST } transform_param { crop_size: 8 } } layer { name: "scale" type: "Power" bottom: "data" top: "scale" power_param { scale: 0.004 } } layer { name: "hidden" type: "InnerProduct" bottom: "scale" top: "output" inner_product_param { num_output: 2 } } layer { name: "loss" type: "EuclideanLoss" bottom: "output" bottom: "label" top: "loss" exclude { stage: "deploy" } } """ TORCH_NETWORK = \ """ return function(p) local croplen = 8, channels if p.inputShape then channels=p.inputShape[1] else channels=1 end local net = nn.Sequential() net:add(nn.MulConstant(0.004)) net:add(nn.View(-1):setNumInputDims(3)) -- flatten -- set all weights and biases to zero as this speeds learning up -- for the type of problem we're trying to solve in this test local linearLayer = nn.Linear(channels*croplen*croplen, 2) linearLayer.weight:fill(0) linearLayer.bias:fill(0) net:add(linearLayer) -- c*croplen*croplen -> 2 return { model = net, loss = nn.MSECriterion(), croplen = croplen } end """ class BaseTestCreatedCropInForm(BaseTestCreated): CROP_SIZE = 8 ################################################################################ # Test classes ################################################################################ class TestCaffeViews(BaseTestViews, test_utils.CaffeMixin): pass class TestCaffeCreation(BaseTestCreation, test_utils.CaffeMixin): pass class TestCaffeCreated(BaseTestCreated, test_utils.CaffeMixin): pass class TestCaffeCreatedWithGradientDataExtension( BaseTestCreatedWithGradientDataExtension, test_utils.CaffeMixin): pass class TestCaffeCreatedWithGradientDataExtensionNoValSet( BaseTestCreatedWithGradientDataExtension, test_utils.CaffeMixin): @classmethod def setUpClass(cls): super(TestCaffeCreatedWithGradientDataExtensionNoValSet, cls).setUpClass(val_image_count=0) class TestCaffeCreatedWithImageProcessingExtensionMeanImage( BaseTestCreatedWithImageProcessingExtension, test_utils.CaffeMixin): MEAN = 'image' class TestCaffeCreatedWithImageProcessingExtensionMeanPixel( BaseTestCreatedWithImageProcessingExtension, test_utils.CaffeMixin): MEAN = 'pixel' class TestCaffeCreatedWithImageProcessingExtensionMeanNone( BaseTestCreatedWithImageProcessingExtension, test_utils.CaffeMixin): MEAN = 'none' class TestCaffeCreatedVariableSizeDataset( BaseTestCreatedWithImageProcessingExtension, test_utils.CaffeMixin): MEAN = 'none' VARIABLE_SIZE_DATASET = True class TestCaffeDatasetModelInteractions(BaseTestDatasetModelInteractions, test_utils.CaffeMixin): pass class TestCaffeCreatedCropInNetwork(BaseTestCreatedCropInNetwork, test_utils.CaffeMixin): pass class TestCaffeCreatedCropInForm(BaseTestCreatedCropInForm, test_utils.CaffeMixin): pass class TestTorchViews(BaseTestViews, test_utils.TorchMixin): pass class TestTorchCreation(BaseTestCreation, test_utils.TorchMixin): pass class TestTorchCreated(BaseTestCreated, test_utils.TorchMixin): pass class TestTorchCreatedWithGradientDataExtension( BaseTestCreatedWithGradientDataExtension, test_utils.TorchMixin): pass class TestTorchCreatedWithGradientDataExtensionNoValSet( BaseTestCreatedWithGradientDataExtension, test_utils.TorchMixin): @classmethod def setUpClass(cls): super(TestTorchCreatedWithGradientDataExtensionNoValSet, cls).setUpClass(val_image_count=0) class TestTorchCreatedWithImageProcessingExtensionMeanImage( BaseTestCreatedWithImageProcessingExtension, test_utils.TorchMixin): MEAN = 'image' class TestTorchCreatedWithImageProcessingExtensionMeanPixel( BaseTestCreatedWithImageProcessingExtension, test_utils.TorchMixin): MEAN = 'pixel' class TestTorchCreatedWithImageProcessingExtensionMeanNone( BaseTestCreatedWithImageProcessingExtension, test_utils.TorchMixin): MEAN = 'none' class TestTorchCreatedVariableSizeDataset( BaseTestCreatedWithImageProcessingExtension, test_utils.TorchMixin): MEAN = 'none' VARIABLE_SIZE_DATASET = True class TestTorchCreatedCropInNetwork(BaseTestCreatedCropInNetwork, test_utils.TorchMixin): pass class TestTorchCreatedCropInForm(BaseTestCreatedCropInForm, test_utils.TorchMixin): pass class TestTorchDatasetModelInteractions(BaseTestDatasetModelInteractions, test_utils.TorchMixin): pass class TestTorchTableOutput(BaseTestCreated, test_utils.TorchMixin): TORCH_NETWORK = \ """ return function(p) -- same network as in class BaseTestCreated except that each gradient -- is learnt separately: the input is fed into nn.ConcatTable and -- each branch outputs one of the gradients local nDim = 1 if p.inputShape then p.inputShape:apply(function(x) nDim=nDim*x end) end local net = nn.Sequential() net:add(nn.MulConstant(0.004)) net:add(nn.View(-1):setNumInputDims(3)) -- flatten -- set all weights and biases to zero as this speeds learning up -- for the type of problem we're trying to solve in this test local linearLayer1 = nn.Linear(nDim, 1) linearLayer1.weight:fill(0) linearLayer1.bias:fill(0) local linearLayer2 = nn.Linear(nDim, 1) linearLayer2.weight:fill(0) linearLayer2.bias:fill(0) -- create concat table local parallel = nn.ConcatTable() parallel:add(linearLayer1):add(linearLayer2) net:add(parallel) -- create two MSE criteria to optimize each gradient separately local mse1 = nn.MSECriterion() local mse2 = nn.MSECriterion() -- now create a criterion that takes as input each of the two criteria local finalCriterion = nn.ParallelCriterion(false):add(mse1):add(mse2) -- create label hook function labelHook(input, dblabel) -- split label alongside 2nd dimension local labelTable = dblabel:split(1,2) return labelTable end return { model = net, loss = finalCriterion, labelHook = labelHook, } end """ class TestTorchNDOutput(BaseTestCreated, test_utils.TorchMixin): CROP_SIZE = 8 TORCH_NETWORK = \ """ return function(p) -- this model just forwards the input as is local net = nn.Sequential():add(nn.Identity()) -- create label hook function labelHook(input, dblabel) return input end return { model = net, loss = nn.AbsCriterion(), labelHook = labelHook, } end """ def test_infer_one_json(self): image_path = os.path.join(self.imageset_folder, self.test_image) with open(image_path, 'rb') as infile: # StringIO wrapping is needed to simulate POST file upload. image_upload = (StringIO(infile.read()), 'image.png') rv = self.app.post( '/models/images/generic/infer_one/json?job_id=%s' % self.model_id, data={ 'image_file': image_upload, } ) assert rv.status_code == 200, 'POST failed with %s' % rv.status_code # make sure the shape of the output matches the shape of the input data = json.loads(rv.data) output = np.array(data['outputs']['output'][0]) assert output.shape == (1, self.CROP_SIZE, self.CROP_SIZE), \ 'shape mismatch: %s' % str(output.shape) class TestSweepCreation(BaseViewsTestWithDataset, test_utils.CaffeMixin): """ Model creation tests """ def test_sweep(self): job_ids = self.create_model(json=True, learning_rate='[0.01, 0.02]', batch_size='[8, 10]') for job_id in job_ids: assert self.model_wait_completion(job_id) == 'Done', 'create failed' assert self.delete_model(job_id) == 200, 'delete failed' assert not self.model_exists(job_id), 'model exists after delete' class TestAllInOneNetwork(BaseTestCreation, BaseTestCreated, test_utils.CaffeMixin): """ Test an all-in-one network """ CAFFE_NETWORK = \ """ layer { name: "train_data" type: "Data" top: "scaled_data" transform_param { scale: 0.004 } include { phase: TRAIN } } layer { name: "train_label" type: "Data" top: "label" include { phase: TRAIN } } layer { name: "val_data" type: "Data" top: "scaled_data" transform_param { scale: 0.004 } include { phase: TEST } } layer { name: "val_label" type: "Data" top: "label" include { phase: TEST } } layer { name: "scale" type: "Power" bottom: "data" top: "scaled_data" power_param { scale: 0.004 } include { stage: "deploy" } } layer { name: "hidden" type: "InnerProduct" bottom: "scaled_data" top: "output" inner_product_param { num_output: 2 } } layer { name: "loss" type: "EuclideanLoss" bottom: "output" bottom: "label" top: "loss" exclude { stage: "deploy" } } """ class TestTensorflowCreation(BaseTestCreation, test_utils.TensorflowMixin): pass class TestTensorflowCreated(BaseTestCreated, test_utils.TensorflowMixin): pass class TestTensorflowCreatedWithGradientDataExtension(BaseTestCreatedWithGradientDataExtension, test_utils.TensorflowMixin): pass class TestTensorflowCreatedWithGradientDataExtensionNoValSet(BaseTestCreatedWithGradientDataExtension, test_utils.TensorflowMixin): @classmethod def setUpClass(cls): super(TestTensorflowCreatedWithGradientDataExtensionNoValSet, cls).setUpClass(val_image_count=0) class TestTensorflowCreatedWithImageProcessingExtensionMeanImage(BaseTestCreatedWithImageProcessingExtension, test_utils.TensorflowMixin): MEAN = 'image' class TestTensorflowCreatedWithImageProcessingExtensionMeanPixel(BaseTestCreatedWithImageProcessingExtension, test_utils.TensorflowMixin): MEAN = 'pixel' class TestTensorflowCreatedWithImageProcessingExtensionMeanNone(BaseTestCreatedWithImageProcessingExtension, test_utils.TensorflowMixin): MEAN = 'none' class TestTensorflowCreatedVariableSizeDataset(BaseTestCreatedWithImageProcessingExtension, test_utils.TensorflowMixin): MEAN = 'none' VARIABLE_SIZE_DATASET = True @classmethod def setUpClass(cls): raise unittest.SkipTest('Variable-size dataset not supported in Tensorflow/DIGITS') class TestTensorflowCreatedCropInForm(BaseTestCreatedCropInForm, test_utils.TensorflowMixin): pass class TestTensorflowDatasetModelInteractions(BaseTestDatasetModelInteractions, test_utils.TensorflowMixin): pass
DIGITS-master
digits/model/images/generic/test_views.py
# Copyright (c) 2015-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from ..forms import ImageModelForm class GenericImageModelForm(ImageModelForm): """ Defines the form used to create a new GenericImageModelJob """ pass
DIGITS-master
digits/model/images/generic/forms.py
# Copyright (c) 2015-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import import os import re import tempfile import flask import werkzeug.exceptions from .forms import GenericImageModelForm from .job import GenericImageModelJob from digits.pretrained_model.job import PretrainedModelJob from digits import extensions, frameworks, utils from digits.config import config_value from digits.dataset import GenericDatasetJob, GenericImageDatasetJob from digits.inference import ImageInferenceJob from digits.status import Status from digits.utils import filesystem as fs from digits.utils import constants from digits.utils.forms import fill_form_if_cloned, save_form_to_job from digits.utils.routing import request_wants_json, job_from_request from digits.webapp import scheduler blueprint = flask.Blueprint(__name__, __name__) @blueprint.route('/new', methods=['GET']) @blueprint.route('/new/<extension_id>', methods=['GET']) @utils.auth.requires_login def new(extension_id=None): """ Return a form for a new GenericImageModelJob """ form = GenericImageModelForm() form.dataset.choices = get_datasets(extension_id) form.standard_networks.choices = [] form.previous_networks.choices = get_previous_networks() form.pretrained_networks.choices = get_pretrained_networks() prev_network_snapshots = get_previous_network_snapshots() # Is there a request to clone a job with ?clone=<job_id> fill_form_if_cloned(form) return flask.render_template( 'models/images/generic/new.html', extension_id=extension_id, extension_title=extensions.data.get_extension(extension_id).get_title() if extension_id else None, form=form, frameworks=frameworks.get_frameworks(), previous_network_snapshots=prev_network_snapshots, previous_networks_fullinfo=get_previous_networks_fulldetails(), pretrained_networks_fullinfo=get_pretrained_networks_fulldetails(), multi_gpu=config_value('caffe')['multi_gpu'], ) @blueprint.route('<extension_id>/json', methods=['POST']) @blueprint.route('<extension_id>', methods=['POST'], strict_slashes=False) @blueprint.route('/json', methods=['POST']) @blueprint.route('', methods=['POST'], strict_slashes=False) @utils.auth.requires_login(redirect=False) def create(extension_id=None): """ Create a new GenericImageModelJob Returns JSON when requested: {job_id,name,status} or {errors:[]} """ form = GenericImageModelForm() form.dataset.choices = get_datasets(extension_id) form.standard_networks.choices = [] form.previous_networks.choices = get_previous_networks() form.pretrained_networks.choices = get_pretrained_networks() prev_network_snapshots = get_previous_network_snapshots() # Is there a request to clone a job with ?clone=<job_id> fill_form_if_cloned(form) if not form.validate_on_submit(): if request_wants_json(): return flask.jsonify({'errors': form.errors}), 400 else: return flask.render_template( 'models/images/generic/new.html', extension_id=extension_id, extension_title=extensions.data.get_extension(extension_id).get_title() if extension_id else None, form=form, frameworks=frameworks.get_frameworks(), previous_network_snapshots=prev_network_snapshots, previous_networks_fullinfo=get_previous_networks_fulldetails(), pretrained_networks_fullinfo=get_pretrained_networks_fulldetails(), multi_gpu=config_value('caffe')['multi_gpu'], ), 400 datasetJob = scheduler.get_job(form.dataset.data) if not datasetJob: raise werkzeug.exceptions.BadRequest( 'Unknown dataset job_id "%s"' % form.dataset.data) # sweeps will be a list of the the permutations of swept fields # Get swept learning_rate sweeps = [{'learning_rate': v} for v in form.learning_rate.data] add_learning_rate = len(form.learning_rate.data) > 1 # Add swept batch_size sweeps = [dict(s.items() + [('batch_size', bs)]) for bs in form.batch_size.data for s in sweeps[:]] add_batch_size = len(form.batch_size.data) > 1 n_jobs = len(sweeps) jobs = [] for sweep in sweeps: # Populate the form with swept data to be used in saving and # launching jobs. form.learning_rate.data = sweep['learning_rate'] form.batch_size.data = sweep['batch_size'] # Augment Job Name extra = '' if add_learning_rate: extra += ' learning_rate:%s' % str(form.learning_rate.data[0]) if add_batch_size: extra += ' batch_size:%d' % form.batch_size.data[0] job = None try: job = GenericImageModelJob( username=utils.auth.get_username(), name=form.model_name.data + extra, group=form.group_name.data, dataset_id=datasetJob.id(), ) # get framework (hard-coded to caffe for now) fw = frameworks.get_framework_by_id(form.framework.data) pretrained_model = None # if form.method.data == 'standard': if form.method.data == 'previous': old_job = scheduler.get_job(form.previous_networks.data) if not old_job: raise werkzeug.exceptions.BadRequest( 'Job not found: %s' % form.previous_networks.data) use_same_dataset = (old_job.dataset_id == job.dataset_id) network = fw.get_network_from_previous(old_job.train_task().network, use_same_dataset) for choice in form.previous_networks.choices: if choice[0] == form.previous_networks.data: epoch = float(flask.request.form['%s-snapshot' % form.previous_networks.data]) if epoch == 0: pass elif epoch == -1: pretrained_model = old_job.train_task().pretrained_model else: # verify snapshot exists pretrained_model = old_job.train_task().get_snapshot(epoch, download=True) if pretrained_model is None: raise werkzeug.exceptions.BadRequest( "For the job %s, selected pretrained_model for epoch %d is invalid!" % (form.previous_networks.data, epoch)) # the first is the actual file if a list is returned, other should be meta data if isinstance(pretrained_model, list): pretrained_model = pretrained_model[0] if not (os.path.exists(pretrained_model)): raise werkzeug.exceptions.BadRequest( "Pretrained_model for the selected epoch doesn't exist. " "May be deleted by another user/process. " "Please restart the server to load the correct pretrained_model details.") # get logical path pretrained_model = old_job.train_task().get_snapshot(epoch) break elif form.method.data == 'pretrained': pretrained_job = scheduler.get_job(form.pretrained_networks.data) model_def_path = pretrained_job.get_model_def_path() weights_path = pretrained_job.get_weights_path() network = fw.get_network_from_path(model_def_path) pretrained_model = weights_path elif form.method.data == 'custom': network = fw.get_network_from_desc(form.custom_network.data) pretrained_model = form.custom_network_snapshot.data.strip() else: raise werkzeug.exceptions.BadRequest( 'Unrecognized method: "%s"' % form.method.data) policy = {'policy': form.lr_policy.data} if form.lr_policy.data == 'fixed': pass elif form.lr_policy.data == 'step': policy['stepsize'] = form.lr_step_size.data policy['gamma'] = form.lr_step_gamma.data elif form.lr_policy.data == 'multistep': policy['stepvalue'] = form.lr_multistep_values.data policy['gamma'] = form.lr_multistep_gamma.data elif form.lr_policy.data == 'exp': policy['gamma'] = form.lr_exp_gamma.data elif form.lr_policy.data == 'inv': policy['gamma'] = form.lr_inv_gamma.data policy['power'] = form.lr_inv_power.data elif form.lr_policy.data == 'poly': policy['power'] = form.lr_poly_power.data elif form.lr_policy.data == 'sigmoid': policy['stepsize'] = form.lr_sigmoid_step.data policy['gamma'] = form.lr_sigmoid_gamma.data else: raise werkzeug.exceptions.BadRequest( 'Invalid learning rate policy') if config_value('caffe')['multi_gpu']: if form.select_gpu_count.data: gpu_count = form.select_gpu_count.data selected_gpus = None else: selected_gpus = [str(gpu) for gpu in form.select_gpus.data] gpu_count = None else: if form.select_gpu.data == 'next': gpu_count = 1 selected_gpus = None else: selected_gpus = [str(form.select_gpu.data)] gpu_count = None # Set up data augmentation structure data_aug = {} data_aug['flip'] = form.aug_flip.data data_aug['quad_rot'] = form.aug_quad_rot.data data_aug['rot'] = form.aug_rot.data data_aug['scale'] = form.aug_scale.data data_aug['noise'] = form.aug_noise.data data_aug['contrast'] = form.aug_contrast.data data_aug['whitening'] = form.aug_whitening.data data_aug['hsv_use'] = form.aug_hsv_use.data data_aug['hsv_h'] = form.aug_hsv_h.data data_aug['hsv_s'] = form.aug_hsv_s.data data_aug['hsv_v'] = form.aug_hsv_v.data # Python Layer File may be on the server or copied from the client. fs.copy_python_layer_file( bool(form.python_layer_from_client.data), job.dir(), (flask.request.files[form.python_layer_client_file.name] if form.python_layer_client_file.name in flask.request.files else ''), form.python_layer_server_file.data) job.tasks.append(fw.create_train_task( job=job, dataset=datasetJob, train_epochs=form.train_epochs.data, snapshot_interval=form.snapshot_interval.data, learning_rate=form.learning_rate.data[0], lr_policy=policy, gpu_count=gpu_count, selected_gpus=selected_gpus, batch_size=form.batch_size.data[0], batch_accumulation=form.batch_accumulation.data, val_interval=form.val_interval.data, traces_interval=form.traces_interval.data, pretrained_model=pretrained_model, crop_size=form.crop_size.data, use_mean=form.use_mean.data, network=network, random_seed=form.random_seed.data, solver_type=form.solver_type.data, rms_decay=form.rms_decay.data, shuffle=form.shuffle.data, data_aug=data_aug, ) ) # Save form data with the job so we can easily clone it later. save_form_to_job(job, form) jobs.append(job) scheduler.add_job(job) if n_jobs == 1: if request_wants_json(): return flask.jsonify(job.json_dict()) else: return flask.redirect(flask.url_for('digits.model.views.show', job_id=job.id())) except: if job: scheduler.delete_job(job) raise if request_wants_json(): return flask.jsonify(jobs=[j.json_dict() for j in jobs]) # If there are multiple jobs launched, go to the home page. return flask.redirect('/') def show(job, related_jobs=None): """ Called from digits.model.views.models_show() """ data_extensions = get_data_extensions() view_extensions = get_view_extensions() return flask.render_template( 'models/images/generic/show.html', job=job, data_extensions=data_extensions, view_extensions=view_extensions, related_jobs=related_jobs, ) @blueprint.route('/timeline_tracing', methods=['GET']) def timeline_tracing(): """ Shows timeline trace of a model """ job = job_from_request() return flask.render_template('models/timeline_tracing.html', job=job) @blueprint.route('/large_graph', methods=['GET']) def large_graph(): """ Show the loss/accuracy graph, but bigger """ job = job_from_request() return flask.render_template('models/large_graph.html', job=job) @blueprint.route('/infer_one/json', methods=['POST']) @blueprint.route('/infer_one', methods=['POST', 'GET']) def infer_one(): """ Infer one image """ model_job = job_from_request() remove_image_path = False if 'image_path' in flask.request.form and flask.request.form['image_path']: image_path = flask.request.form['image_path'] elif 'image_file' in flask.request.files and flask.request.files['image_file']: outfile = tempfile.mkstemp(suffix='.bin') flask.request.files['image_file'].save(outfile[1]) image_path = outfile[1] os.close(outfile[0]) remove_image_path = True else: raise werkzeug.exceptions.BadRequest('must provide image_path or image_file') 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' if 'dont_resize' in flask.request.form and flask.request.form['dont_resize']: resize = False else: resize = True # create inference job inference_job = ImageInferenceJob( username=utils.auth.get_username(), name="Infer One Image", model=model_job, images=[image_path], epoch=epoch, layers=layers, resize=resize, ) # schedule tasks scheduler.add_job(inference_job) # wait for job to complete inference_job.wait_completion() # retrieve inference data inputs, outputs, model_visualization = inference_job.get_data() # set return status code status_code = 500 if inference_job.status == 'E' else 200 # delete job folder and remove from scheduler list scheduler.delete_job(inference_job) if remove_image_path: os.remove(image_path) if inputs is not None and len(inputs['data']) == 1: image = utils.image.embed_image_html(inputs['data'][0]) visualizations, header_html, app_begin_html, app_end_html = get_inference_visualizations( model_job.dataset, inputs, outputs) inference_view_html = visualizations[0] else: image = None inference_view_html = None header_html = None app_begin_html = None app_end_html = None if request_wants_json(): return flask.jsonify({'outputs': dict((name, blob.tolist()) for name, blob in outputs.iteritems())}), status_code else: return flask.render_template( 'models/images/generic/infer_one.html', model_job=model_job, job=inference_job, image_src=image, inference_view_html=inference_view_html, header_html=header_html, app_begin_html=app_begin_html, app_end_html=app_end_html, visualizations=model_visualization, total_parameters=sum(v['param_count'] for v in model_visualization if v['vis_type'] == 'Weights'), ), status_code @blueprint.route('/infer_extension/json', methods=['POST']) @blueprint.route('/infer_extension', methods=['POST', 'GET']) def infer_extension(): """ Perform inference using the data from an extension inference form """ model_job = job_from_request() inference_db_job = None try: if 'data_extension_id' in flask.request.form: data_extension_id = flask.request.form['data_extension_id'] else: data_extension_id = model_job.dataset.extension_id # create an inference database inference_db_job = create_inference_db(model_job, data_extension_id) db_path = inference_db_job.get_feature_db_path(constants.TEST_DB) # create database creation job 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' # create inference job inference_job = ImageInferenceJob( username=utils.auth.get_username(), name="Inference", model=model_job, images=db_path, epoch=epoch, layers=layers, resize=False, ) # schedule tasks scheduler.add_job(inference_job) # wait for job to complete inference_job.wait_completion() finally: if inference_db_job: scheduler.delete_job(inference_db_job) # retrieve inference data inputs, outputs, model_visualization = inference_job.get_data() # set return status code status_code = 500 if inference_job.status == 'E' else 200 # delete job folder and remove from scheduler list scheduler.delete_job(inference_job) if outputs is not None and len(outputs) < 1: # an error occurred outputs = None if inputs is not None: keys = [str(idx) for idx in inputs['ids']] inference_views_html, header_html, app_begin_html, app_end_html = get_inference_visualizations( model_job.dataset, inputs, outputs) else: inference_views_html = None header_html = None keys = None app_begin_html = None app_end_html = None if request_wants_json(): result = {} for i, key in enumerate(keys): result[key] = dict((name, blob[i].tolist()) for name, blob in outputs.iteritems()) return flask.jsonify({'outputs': result}), status_code else: return flask.render_template( 'models/images/generic/infer_extension.html', model_job=model_job, job=inference_job, keys=keys, inference_views_html=inference_views_html, header_html=header_html, app_begin_html=app_begin_html, app_end_html=app_end_html, visualizations=model_visualization, total_parameters=sum(v['param_count'] for v in model_visualization if v['vis_type'] == 'Weights'), ), status_code @blueprint.route('/infer_db/json', methods=['POST']) @blueprint.route('/infer_db', methods=['POST', 'GET']) def infer_db(): """ Infer a database """ model_job = job_from_request() if 'db_path' not in flask.request.form or flask.request.form['db_path'] is None: raise werkzeug.exceptions.BadRequest('db_path is a required field') db_path = flask.request.form['db_path'] if not os.path.exists(db_path): raise werkzeug.exceptions.BadRequest('DB "%s" does not exit' % db_path) epoch = None if 'snapshot_epoch' in flask.request.form: epoch = float(flask.request.form['snapshot_epoch']) if 'dont_resize' in flask.request.form and flask.request.form['dont_resize']: resize = False else: resize = True # create inference job inference_job = ImageInferenceJob( username=utils.auth.get_username(), name="Infer Many Images", model=model_job, images=db_path, epoch=epoch, layers='none', resize=resize, ) # schedule tasks scheduler.add_job(inference_job) # wait for job to complete inference_job.wait_completion() # retrieve inference data inputs, outputs, _ = inference_job.get_data() # set return status code status_code = 500 if inference_job.status == 'E' else 200 # delete job folder and remove from scheduler list scheduler.delete_job(inference_job) if outputs is not None and len(outputs) < 1: # an error occurred outputs = None if inputs is not None: keys = [str(idx) for idx in inputs['ids']] inference_views_html, header_html, app_begin_html, app_end_html = get_inference_visualizations( model_job.dataset, inputs, outputs) else: inference_views_html = None header_html = None keys = None app_begin_html = None app_end_html = None if request_wants_json(): result = {} for i, key in enumerate(keys): result[key] = dict((name, blob[i].tolist()) for name, blob in outputs.iteritems()) return flask.jsonify({'outputs': result}), status_code else: return flask.render_template( 'models/images/generic/infer_db.html', model_job=model_job, job=inference_job, keys=keys, inference_views_html=inference_views_html, header_html=header_html, app_begin_html=app_begin_html, app_end_html=app_end_html, ), status_code @blueprint.route('/infer_many/json', methods=['POST']) @blueprint.route('/infer_many', methods=['POST', 'GET']) def infer_many(): """ Infer many images """ model_job = job_from_request() image_list = flask.request.files.get('image_list') if not image_list: raise werkzeug.exceptions.BadRequest('image_list is a required field') if 'image_folder' in flask.request.form and flask.request.form['image_folder'].strip(): image_folder = flask.request.form['image_folder'] if not os.path.exists(image_folder): raise werkzeug.exceptions.BadRequest('image_folder "%s" does not exit' % image_folder) else: image_folder = None if 'num_test_images' in flask.request.form and flask.request.form['num_test_images'].strip(): num_test_images = int(flask.request.form['num_test_images']) else: num_test_images = None epoch = None if 'snapshot_epoch' in flask.request.form: epoch = float(flask.request.form['snapshot_epoch']) if 'dont_resize' in flask.request.form and flask.request.form['dont_resize']: resize = False else: resize = True paths = [] for line in image_list.readlines(): line = line.strip() if not line: continue path = None # might contain a numerical label at the end match = re.match(r'(.*\S)\s+\d+$', line) if match: path = match.group(1) else: path = line if not utils.is_url(path) and image_folder and not os.path.isabs(path): path = os.path.join(image_folder, path) paths.append(path) if num_test_images is not None and len(paths) >= num_test_images: break # create inference job inference_job = ImageInferenceJob( username=utils.auth.get_username(), name="Infer Many Images", model=model_job, images=paths, epoch=epoch, layers='none', resize=resize, ) # schedule tasks scheduler.add_job(inference_job) # wait for job to complete inference_job.wait_completion() # retrieve inference data inputs, outputs, _ = inference_job.get_data() # set return status code status_code = 500 if inference_job.status == 'E' else 200 # delete job folder and remove from scheduler list scheduler.delete_job(inference_job) if outputs is not None and len(outputs) < 1: # an error occurred outputs = None if inputs is not None: paths = [paths[idx] for idx in inputs['ids']] inference_views_html, header_html, app_begin_html, app_end_html = get_inference_visualizations( model_job.dataset, inputs, outputs) else: inference_views_html = None header_html = None app_begin_html = None app_end_html = None if request_wants_json(): result = {} for i, path in enumerate(paths): result[path] = dict((name, blob[i].tolist()) for name, blob in outputs.iteritems()) return flask.jsonify({'outputs': result}), status_code else: return flask.render_template( 'models/images/generic/infer_many.html', model_job=model_job, job=inference_job, paths=paths, inference_views_html=inference_views_html, header_html=header_html, app_begin_html=app_begin_html, app_end_html=app_end_html, ), status_code def create_inference_db(model_job, data_extension_id): # create instance of extension class extension_class = extensions.data.get_extension(data_extension_id) if hasattr(model_job.dataset, 'extension_userdata'): extension_userdata = model_job.dataset.extension_userdata else: extension_userdata = {} extension_userdata.update({'is_inference_db': True}) extension = extension_class(**extension_userdata) extension_form = extension.get_inference_form() extension_form_valid = extension_form.validate_on_submit() if not extension_form_valid: errors = extension_form.errors.copy() raise werkzeug.exceptions.BadRequest(repr(errors)) extension.userdata.update(extension_form.data) # create job job = GenericDatasetJob( username=utils.auth.get_username(), name='Inference dataset', group=None, backend='lmdb', feature_encoding='none', label_encoding='none', batch_size=1, num_threads=1, force_same_shape=0, extension_id=data_extension_id, extension_userdata=extension.get_user_data(), ) # schedule tasks and wait for job to complete scheduler.add_job(job) job.wait_completion() # check for errors if job.status != Status.DONE: msg = "" for task in job.tasks: if task.exception: msg = msg + task.exception if task.traceback: msg = msg + task.exception raise RuntimeError(msg) return job def get_datasets(extension_id): if extension_id: jobs = [j for j in scheduler.jobs.values() if isinstance(j, GenericDatasetJob) and j.extension_id == extension_id and (j.status.is_running() or j.status == Status.DONE)] else: jobs = [j for j in scheduler.jobs.values() if (isinstance(j, GenericImageDatasetJob) or isinstance(j, GenericDatasetJob)) and (j.status.is_running() or j.status == Status.DONE)] return [(j.id(), j.name()) for j in sorted(jobs, cmp=lambda x, y: cmp(y.id(), x.id()))] def get_inference_visualizations(dataset, inputs, outputs): # get extension ID from form and retrieve extension class if 'view_extension_id' in flask.request.form: view_extension_id = flask.request.form['view_extension_id'] extension_class = extensions.view.get_extension(view_extension_id) if extension_class is None: raise ValueError("Unknown extension '%s'" % view_extension_id) else: # no view extension specified, use default extension_class = extensions.view.get_default_extension() extension_form = extension_class.get_config_form() # validate form extension_form_valid = extension_form.validate_on_submit() if not extension_form_valid: raise ValueError("Extension form validation failed with %s" % repr(extension_form.errors)) # create instance of extension class extension = extension_class(dataset, **extension_form.data) visualizations = [] # process data n = len(inputs['ids']) for idx in xrange(n): input_id = inputs['ids'][idx] input_data = inputs['data'][idx] output_data = {key: outputs[key][idx] for key in outputs} data = extension.process_data( input_id, input_data, output_data) template, context = extension.get_view_template(data) visualizations.append( flask.render_template_string(template, **context)) # get header template, context = extension.get_header_template() header = flask.render_template_string(template, **context) if template else None app_begin, app_end = extension.get_ng_templates() return visualizations, header, app_begin, app_end def get_previous_networks(): return [(j.id(), j.name()) for j in sorted( [j for j in scheduler.jobs.values() if isinstance(j, GenericImageModelJob)], cmp=lambda x, y: cmp(y.id(), x.id()) ) ] def get_previous_networks_fulldetails(): return [(j) for j in sorted( [j for j in scheduler.jobs.values() if isinstance(j, GenericImageModelJob)], cmp=lambda x, y: cmp(y.id(), x.id()) ) ] 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 get_pretrained_networks(): return [(j.id(), j.name()) for j in sorted( [j for j in scheduler.jobs.values() if isinstance(j, PretrainedModelJob)], cmp=lambda x, y: cmp(y.id(), x.id()) ) ] def get_pretrained_networks_fulldetails(): return [(j) for j in sorted( [j for j in scheduler.jobs.values() if isinstance(j, PretrainedModelJob)], cmp=lambda x, y: cmp(y.id(), x.id()) ) ] def get_data_extensions(): """ return all enabled data extensions """ data_extensions = {"all-default": "Default"} all_extensions = extensions.data.get_extensions() for extension in all_extensions: data_extensions[extension.get_id()] = extension.get_title() return data_extensions def get_view_extensions(): """ return all enabled view extensions """ view_extensions = {} all_extensions = extensions.view.get_extensions() for extension in all_extensions: view_extensions[extension.get_id()] = extension.get_title() return view_extensions
DIGITS-master
digits/model/images/generic/views.py
# Copyright (c) 2016-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from . import tasks import digits.frameworks from digits.job import Job from digits.utils import subclass, override @subclass class InferenceJob(Job): """ A Job that exercises the forward pass of a neural network """ def __init__(self, model, images, epoch, layers, resize=True, **kwargs): """ Arguments: model -- job object associated with model to perform inference on images -- list of image paths to perform inference on epoch -- epoch of model snapshot to use layers -- layers to import ('all' or 'none') """ super(InferenceJob, self).__init__(persistent=False, **kwargs) # get handle to framework object fw_id = model.train_task().framework_id fw = digits.frameworks.get_framework_by_id(fw_id) if fw is None: raise RuntimeError( 'The "%s" framework cannot be found. Check your server configuration.' % fw_id) # create inference task self.tasks.append(fw.create_inference_task( job_dir=self.dir(), model=model, images=images, epoch=epoch, layers=layers, resize=resize, )) @override def __getstate__(self): fields_to_save = ['_id', '_name'] full_state = super(InferenceJob, self).__getstate__() state_to_save = {} for field in fields_to_save: state_to_save[field] = full_state[field] return state_to_save def inference_task(self): """Return the first and only InferenceTask for this job""" return [t for t in self.tasks if isinstance(t, tasks.InferenceTask)][0] @override def __setstate__(self, state): super(InferenceJob, self).__setstate__(state) def get_data(self): """Return inference data""" task = self.inference_task() return task.inference_inputs, task.inference_outputs, task.inference_layers
DIGITS-master
digits/inference/job.py
# Copyright (c) 2016-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from .images import ImageInferenceJob from .job import InferenceJob __all__ = [ 'InferenceJob', 'ImageInferenceJob', ]
DIGITS-master
digits/inference/__init__.py
# Copyright (c) 2016-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from digits.utils import subclass, override @subclass class Error(Exception): pass @subclass class InferenceError(Error): """ Errors that occur during inference """ def __init__(self, message): self.message = message @override def __str__(self): return repr(self.message)
DIGITS-master
digits/inference/errors.py
# Copyright (c) 2016-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from .inference import InferenceTask __all__ = ['InferenceTask']
DIGITS-master
digits/inference/tasks/__init__.py
# Copyright (c) 2016-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import import base64 from collections import OrderedDict import h5py import os.path import tempfile import re import sys import digits from digits.task import Task from digits.utils import subclass, override from digits.utils.image import embed_image_html @subclass class InferenceTask(Task): """ A task for inference jobs """ def __init__(self, model, images, epoch, layers, resize, **kwargs): """ Arguments: model -- trained model to perform inference on images -- list of images to perform inference on, or path to a database epoch -- model snapshot to use layers -- which layers to visualize (by default only the activations of the last layer) """ # memorize parameters self.model = model self.images = images self.epoch = epoch self.layers = layers self.resize = resize self.image_list_path = None self.inference_log_file = "inference.log" # resources self.gpu = None # generated data self.inference_data_filename = None self.inference_inputs = None self.inference_outputs = None self.inference_layers = [] super(InferenceTask, self).__init__(**kwargs) @override def name(self): return 'Infer Model' @override def __getstate__(self): state = super(InferenceTask, self).__getstate__() if 'inference_log' in state: # don't save file handle del state['inference_log'] return state @override def __setstate__(self, state): super(InferenceTask, self).__setstate__(state) @override def before_run(self): super(InferenceTask, self).before_run() # create log file self.inference_log = open(self.path(self.inference_log_file), 'a') if type(self.images) is list: # create a file to pass the list of images to perform inference on imglist_handle, self.image_list_path = tempfile.mkstemp(dir=self.job_dir, suffix='.txt') for image_path in self.images: os.write(imglist_handle, "%s\n" % image_path) os.close(imglist_handle) @override def process_output(self, line): self.inference_log.write('%s\n' % line) self.inference_log.flush() timestamp, level, message = self.preprocess_output_digits(line) if not message: return False # progress match = re.match(r'Processed (\d+)\/(\d+)', message) if match: self.progress = float(match.group(1)) / int(match.group(2)) return True # path to inference data match = re.match(r'Saved data to (.*)', message) if match: self.inference_data_filename = match.group(1).strip() return True return False @override def after_run(self): super(InferenceTask, self).after_run() # retrieve inference data visualizations = [] outputs = OrderedDict() if self.inference_data_filename is not None: # the HDF5 database contains: # - input images, in a dataset "/inputs" # - all network outputs, in a group "/outputs/" # - layer activations and weights, if requested, in a group "/layers/" db = h5py.File(self.inference_data_filename, 'r') # collect paths and data input_ids = db['input_ids'][...] input_data = db['input_data'][...] # collect outputs o = [] for output_key, output_data in db['outputs'].items(): output_name = base64.urlsafe_b64decode(str(output_key)) o.append({'id': output_data.attrs['id'], 'name': output_name, 'data': output_data[...]}) # sort outputs by ID o = sorted(o, key=lambda x: x['id']) # retain only data (using name as key) for output in o: outputs[output['name']] = output['data'] # collect layer data, if applicable if 'layers' in db.keys(): for layer_id, layer in db['layers'].items(): visualization = { 'id': int(layer_id), 'name': layer.attrs['name'], 'vis_type': layer.attrs['vis_type'], 'data_stats': { 'shape': layer.attrs['shape'], 'mean': layer.attrs['mean'], 'stddev': layer.attrs['stddev'], 'histogram': [ layer.attrs['histogram_y'].tolist(), layer.attrs['histogram_x'].tolist(), layer.attrs['histogram_ticks'].tolist(), ] } } if 'param_count' in layer.attrs: visualization['param_count'] = layer.attrs['param_count'] if 'layer_type' in layer.attrs: visualization['layer_type'] = layer.attrs['layer_type'] vis = layer[...] if vis.shape[0] > 0: visualization['image_html'] = embed_image_html(vis) visualizations.append(visualization) # sort by layer ID (as HDF5 ASCII sorts) visualizations = sorted(visualizations, key=lambda x: x['id']) db.close() # save inference data for further use self.inference_inputs = {'ids': input_ids, 'data': input_data} self.inference_outputs = outputs self.inference_layers = visualizations self.inference_log.close() @override def offer_resources(self, resources): reserved_resources = {} # we need one CPU resource from inference_task_pool cpu_key = 'inference_task_pool' if cpu_key not in resources: return None for resource in resources[cpu_key]: if resource.remaining() >= 1: reserved_resources[cpu_key] = [(resource.identifier, 1)] # we reserve the first available GPU, if there are any gpu_key = 'gpus' if resources[gpu_key]: for resource in resources[gpu_key]: if resource.remaining() >= 1: self.gpu = int(resource.identifier) reserved_resources[gpu_key] = [(resource.identifier, 1)] break return reserved_resources return None @override def task_arguments(self, resources, env): args = [sys.executable, os.path.join(os.path.dirname(os.path.abspath(digits.__file__)), 'tools', 'inference.py'), self.image_list_path if self.image_list_path is not None else self.images, self.job_dir, self.model.id(), '--jobs_dir=%s' % digits.config.config_value('jobs_dir'), ] if self.epoch is not None: args.append('--epoch=%s' % repr(self.epoch)) if self.layers == 'all': args.append('--layers=all') else: args.append('--layers=none') if self.gpu is not None: args.append('--gpu=%d' % self.gpu) if self.image_list_path is None: args.append('--db') if not self.resize: args.append('--no-resize') return args
DIGITS-master
digits/inference/tasks/inference.py
# Copyright (c) 2016-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from ..job import InferenceJob from digits.utils import subclass, override @subclass class ImageInferenceJob(InferenceJob): """ A Job that exercises the forward pass of an image neural network """ @override def job_type(self): return 'Image Inference'
DIGITS-master
digits/inference/images/job.py
# Copyright (c) 2016-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from .job import ImageInferenceJob __all__ = ['ImageInferenceJob']
DIGITS-master
digits/inference/images/__init__.py
# Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import import os import re import subprocess import tempfile import sys from .errors import NetworkVisualizationError from .framework import Framework import digits from digits import utils from digits.model.tasks import TensorflowTrainTask from digits.utils import subclass, override, constants @subclass class TensorflowFramework(Framework): """ Defines required methods to interact with the Tensorflow framework """ # short descriptive name NAME = 'Tensorflow' # identifier of framework class CLASS = 'tensorflow' # whether this framework can shuffle data during training CAN_SHUFFLE_DATA = True SUPPORTS_PYTHON_LAYERS_FILE = False SUPPORTS_TIMELINE_TRACING = True SUPPORTED_SOLVER_TYPES = ['SGD', 'ADADELTA', 'ADAGRAD', 'ADAGRADDA', 'MOMENTUM', 'ADAM', 'FTRL', 'RMSPROP'] SUPPORTED_DATA_TRANSFORMATION_TYPES = ['MEAN_SUBTRACTION', 'CROPPING'] SUPPORTED_DATA_AUGMENTATION_TYPES = ['FLIPPING', 'NOISE', 'CONTRAST', 'WHITENING', 'HSV_SHIFTING'] def __init__(self): super(TensorflowFramework, self).__init__() # id must be unique self.framework_id = self.CLASS @override def create_train_task(self, **kwargs): """ create train task """ return TensorflowTrainTask(framework_id=self.framework_id, **kwargs) @override def get_standard_network_desc(self, network): """ return description of standard network """ networks_dir = os.path.join(os.path.dirname(digits.__file__), 'standard-networks', self.CLASS) for filename in os.listdir(networks_dir): path = os.path.join(networks_dir, filename) if os.path.isfile(path): match = None match = re.match(r'%s.py$' % network, filename) if match: with open(path) as infile: return infile.read() # return None if not found return None @override def get_network_from_desc(self, network_desc): """ return network object from a string representation """ # return the same string return network_desc @override def get_network_from_previous(self, previous_network, use_same_dataset): """ return new instance of network from previous network """ # note: use_same_dataset is ignored here because for Tensorflow, DIGITS # does not change the number of outputs of the last linear layer # to match the number of classes in the case of a classification # network. In order to write a flexible network description that # accounts for the number of classes, the `nClasses` external # parameter must be used, see documentation. # return the same network description return previous_network @override def validate_network(self, data): """ validate a network """ return True @override def get_network_visualization(self, **kwargs): """ return visualization of network """ desc = kwargs['desc'] dataset = kwargs['dataset'] solver_type = kwargs['solver_type'].lower() if kwargs['solver_type'] else None use_mean = kwargs['use_mean'] crop_size = kwargs['crop_size'] num_gpus = kwargs['num_gpus'] if dataset is None: raise NetworkVisualizationError('Make sure a dataset is selected to visualize this network.') # save network description to temporary file temp_network_handle, temp_network_path = tempfile.mkstemp(suffix='.py') os.write(temp_network_handle, desc) os.close(temp_network_handle) # Generate a temporaty file to put the graph definition in _, temp_graphdef_path = tempfile.mkstemp(suffix='.pbtxt') # Another for the HTML _, temp_html_path = tempfile.mkstemp(suffix='.html') try: # do this in a try..finally clause to make sure we delete the temp file # build command line args = [sys.executable, os.path.join(os.path.dirname(digits.__file__), 'tools', 'tensorflow', 'main.py'), '--network=%s' % os.path.basename(temp_network_path), '--networkDirectory=%s' % os.path.dirname(temp_network_path), '--visualizeModelPath=%s' % temp_graphdef_path, '--optimization=%s' % solver_type, ] if crop_size: args.append('--croplen=%s' % crop_size) if use_mean and use_mean != 'none': mean_file = dataset.get_mean_file() assert mean_file is not None, 'Failed to retrieve mean file.' args.append('--subtractMean=%s' % use_mean) args.append('--mean=%s' % dataset.path(mean_file)) if hasattr(dataset, 'labels_file'): args.append('--labels_list=%s' % dataset.path(dataset.labels_file)) train_feature_db_path = dataset.get_feature_db_path(constants.TRAIN_DB) train_label_db_path = dataset.get_label_db_path(constants.TRAIN_DB) val_feature_db_path = dataset.get_feature_db_path(constants.VAL_DB) val_label_db_path = dataset.get_label_db_path(constants.VAL_DB) args.append('--train_db=%s' % train_feature_db_path) if train_label_db_path: args.append('--train_labels=%s' % train_label_db_path) if val_feature_db_path: args.append('--validation_db=%s' % val_feature_db_path) if val_label_db_path: args.append('--validation_labels=%s' % val_label_db_path) env = os.environ.copy() # make only a selected number of GPUs visible. The ID is not important for just the vis env['CUDA_VISIBLE_DEVICES'] = ",".join([str(i) for i in range(0, int(num_gpus))]) # execute command p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, close_fds=True, env=env) stdout_log = '' while p.poll() is None: for line in utils.nonblocking_readlines(p.stdout): timestamp, level, message = TensorflowTrainTask.preprocess_output_tensorflow(line.strip()) if line is not None: stdout_log += line if p.returncode: raise NetworkVisualizationError(stdout_log) else: # Success! return repr(str(open(temp_graphdef_path).read())) finally: os.remove(temp_network_path) os.remove(temp_graphdef_path)
DIGITS-master
digits/frameworks/tensorflow_framework.py
# Copyright (c) 2015-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import import os import re import caffe.draw import caffe_pb2 from google.protobuf import text_format from .errors import BadNetworkError from .framework import Framework import digits from digits.config import config_value from digits.model.tasks import CaffeTrainTask from digits.utils import subclass, override, parse_version @subclass class CaffeFramework(Framework): """ Defines required methods to interact with the Caffe framework This class can be instantiated as many times as there are compatible instances of Caffe """ # short descriptive name NAME = 'Caffe' # identifier of framework class (intended to be the same across # all instances of this class) CLASS = 'caffe' # whether this framework can shuffle data during training CAN_SHUFFLE_DATA = False SUPPORTS_PYTHON_LAYERS_FILE = True SUPPORTS_TIMELINE_TRACING = False if config_value('caffe')['flavor'] == 'NVIDIA': if parse_version(config_value('caffe')['version']) > parse_version('0.14.0-alpha'): SUPPORTED_SOLVER_TYPES = ['SGD', 'NESTEROV', 'ADAGRAD', 'RMSPROP', 'ADADELTA', 'ADAM'] else: SUPPORTED_SOLVER_TYPES = ['SGD', 'NESTEROV', 'ADAGRAD'] elif config_value('caffe')['flavor'] == 'BVLC': SUPPORTED_SOLVER_TYPES = ['SGD', 'NESTEROV', 'ADAGRAD', 'RMSPROP', 'ADADELTA', 'ADAM'] else: raise ValueError('Unknown flavor. Support NVIDIA and BVLC flavors only.') SUPPORTED_DATA_TRANSFORMATION_TYPES = ['MEAN_SUBTRACTION', 'CROPPING'] SUPPORTED_DATA_AUGMENTATION_TYPES = [] @override def __init__(self): super(CaffeFramework, self).__init__() self.framework_id = self.CLASS @override def create_train_task(self, **kwargs): """ create train task """ return CaffeTrainTask(framework_id=self.framework_id, **kwargs) @override def validate_network(self, data): """ validate a network (input data are expected to be a text description of the network) """ pb = caffe_pb2.NetParameter() try: text_format.Merge(data, pb) except text_format.ParseError as e: raise BadNetworkError('Not a valid NetParameter: %s' % e) @override def get_standard_network_desc(self, network): """ return description of standard network network is expected to be a instance of caffe_pb2.NetParameter """ networks_dir = os.path.join(os.path.dirname(digits.__file__), 'standard-networks', self.CLASS) for filename in os.listdir(networks_dir): path = os.path.join(networks_dir, filename) if os.path.isfile(path): match = None match = re.match(r'%s.prototxt' % network, filename) if match: with open(path) as infile: return infile.read() # return None if not found return None @override def get_network_from_desc(self, network_desc): """ return network object from a string representation """ network = caffe_pb2.NetParameter() text_format.Merge(network_desc, network) return network @override def get_network_from_previous(self, previous_network, use_same_dataset): """ return new instance of network from previous network """ network = caffe_pb2.NetParameter() network.CopyFrom(previous_network) if not use_same_dataset: # Rename the final layer # XXX making some assumptions about network architecture here ip_layers = [l for l in network.layer if l.type == 'InnerProduct'] if len(ip_layers) > 0: ip_layers[-1].name = '%s_retrain' % ip_layers[-1].name return network @override def get_network_from_path(self, path): """ return network object from a file path """ network = caffe_pb2.NetParameter() with open(path) as infile: text_format.Merge(infile.read(), network) return network @override def get_network_visualization(self, **kwargs): """ return visualization of network """ desc = kwargs['desc'] net = caffe_pb2.NetParameter() text_format.Merge(desc, net) # Throws an error if name is None if not net.name: net.name = 'Network' return ('<image src="data:image/png;base64,' + caffe.draw.draw_net(net, 'UD').encode('base64') + '" style="max-width:100%" />') @override def can_accumulate_gradients(self): if config_value('caffe')['flavor'] == 'BVLC': return True elif config_value('caffe')['flavor'] == 'NVIDIA': return (parse_version(config_value('caffe')['version']) > parse_version('0.14.0-alpha')) else: raise ValueError('Unknown flavor. Support NVIDIA and BVLC flavors only.')
DIGITS-master
digits/frameworks/caffe_framework.py
# Copyright (c) 2015-2017, NVIDIA CORPORATION. All rights reserved. from digits.inference.tasks import InferenceTask class Framework(object): """ Defines required methods to interact with a framework """ def get_name(self): """ return self-descriptive name """ return self.NAME def get_id(self): """ return unique id of framework instance """ return self.framework_id def can_shuffle_data(self): """ return whether framework can shuffle input data during training """ return self.CAN_SHUFFLE_DATA def supports_python_layers_file(self): """ return whether framework can shuffle input data during training """ return self.SUPPORTS_PYTHON_LAYERS_FILE def supports_timeline_traces(self): """ return whether framework supports creating timeline traces """ return self.SUPPORTS_TIMELINE_TRACING def supports_solver_type(self, solver_type): """ return whether framework supports this solver_type """ if not hasattr(self, 'SUPPORTED_SOLVER_TYPES'): raise NotImplementedError assert isinstance(self.SUPPORTED_SOLVER_TYPES, list) return solver_type in self.SUPPORTED_SOLVER_TYPES def validate_network(self, data): """ validate a network (must be implemented in child class) """ raise NotImplementedError('Please implement me') def create_inference_task(self, **kwargs): """ create inference task """ return InferenceTask(**kwargs) def create_train_task(self, **kwargs): """ create train task """ raise NotImplementedError('Please implement me') def get_standard_network_desc(self, network): """ return text description of network """ raise NotImplementedError('Please implement me') def get_network_from_desc(self, network_desc): """ return network object from a string representation """ raise NotImplementedError('Please implement me') def get_network_from_previous(self, previous_network, use_same_dataset): """ return new instance of network from previous network """ raise NotImplementedError('Please implement me') def get_network_from_path(self, path): """ return network object from a file path """ raise NotImplementedError('Please implement me') def get_network_visualization(self, **kwargs): """ return visualization of network """ raise NotImplementedError('Please implement me') def can_accumulate_gradients(self): return False
DIGITS-master
digits/frameworks/framework.py
# Copyright (c) 2015-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from .caffe_framework import CaffeFramework from .framework import Framework from .torch_framework import TorchFramework from digits.config import config_value __all__ = [ 'Framework', 'CaffeFramework', 'TorchFramework', ] if config_value('tensorflow')['enabled']: from .tensorflow_framework import TensorflowFramework __all__.append('TensorflowFramework') # # create framework instances # # torch is optional torch = TorchFramework() if config_value('torch')['enabled'] else None # tensorflow is optional tensorflow = TensorflowFramework() if config_value('tensorflow')['enabled'] else None # caffe is mandatory caffe = CaffeFramework() # # utility functions # def get_frameworks(): """ return list of all available framework instances there may be more than one instance per framework class """ frameworks = [caffe] if torch: frameworks.append(torch) if tensorflow: frameworks.append(tensorflow) return frameworks def get_framework_by_id(framework_id): """ return framework instance associated with given id """ for fw in get_frameworks(): if fw.get_id() == framework_id: return fw return None
DIGITS-master
digits/frameworks/__init__.py
# Copyright (c) 2015-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import from digits.utils import subclass @subclass class Error(Exception): pass @subclass class BadNetworkError(Error): """ Errors that occur when validating a network """ def __init__(self, message): self.message = message def __str__(self): return repr(self.message) @subclass class NetworkVisualizationError(Error): """ Errors that occur when validating a network """ def __init__(self, message): self.message = message def __str__(self): return repr(self.message)
DIGITS-master
digits/frameworks/errors.py
# Copyright (c) 2015-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import import os import re import subprocess import time import tempfile import flask from .errors import NetworkVisualizationError from .framework import Framework import digits from digits import utils from digits.config import config_value from digits.model.tasks import TorchTrainTask from digits.utils import subclass, override @subclass class TorchFramework(Framework): """ Defines required methods to interact with the Torch framework """ # short descriptive name NAME = 'Torch' # identifier of framework class CLASS = 'torch' # whether this framework can shuffle data during training CAN_SHUFFLE_DATA = True SUPPORTS_PYTHON_LAYERS_FILE = False SUPPORTS_TIMELINE_TRACING = False SUPPORTED_SOLVER_TYPES = ['SGD', 'NESTEROV', 'ADAGRAD', 'RMSPROP', 'ADADELTA', 'ADAM'] SUPPORTED_DATA_TRANSFORMATION_TYPES = ['MEAN_SUBTRACTION', 'CROPPING'] SUPPORTED_DATA_AUGMENTATION_TYPES = ['FLIPPING', 'QUAD_ROTATION', 'ARBITRARY_ROTATION', 'SCALING', 'NOISE', 'HSV_SHIFTING'] def __init__(self): super(TorchFramework, self).__init__() # id must be unique self.framework_id = self.CLASS @override def create_train_task(self, **kwargs): """ create train task """ return TorchTrainTask(framework_id=self.framework_id, **kwargs) @override def get_standard_network_desc(self, network): """ return description of standard network """ networks_dir = os.path.join(os.path.dirname(digits.__file__), 'standard-networks', self.CLASS) # Torch's GoogLeNet and AlexNet models are placed in sub folder if (network == "alexnet" or network == "googlenet"): networks_dir = os.path.join(networks_dir, 'ImageNet-Training') for filename in os.listdir(networks_dir): path = os.path.join(networks_dir, filename) if os.path.isfile(path): match = None match = re.match(r'%s.lua' % network, filename) if match: with open(path) as infile: return infile.read() # return None if not found return None @override def get_network_from_desc(self, network_desc): """ return network object from a string representation """ # return the same string return network_desc @override def get_network_from_previous(self, previous_network, use_same_dataset): """ return new instance of network from previous network """ # note: use_same_dataset is ignored here because for Torch, DIGITS # does not change the number of outputs of the last linear layer # to match the number of classes in the case of a classification # network. In order to write a flexible network description that # accounts for the number of classes, the `nClasses` external # parameter must be used, see documentation. # return the same network description return previous_network @override def get_network_from_path(self, path): """ return network object from a file path """ with open(path, 'r') as f: network = f.read() return network @override def validate_network(self, data): """ validate a network """ return True @override def get_network_visualization(self, **kwargs): """ return visualization of network """ desc = kwargs['desc'] # save network description to temporary file temp_network_handle, temp_network_path = tempfile.mkstemp(suffix='.lua') os.write(temp_network_handle, desc) os.close(temp_network_handle) try: # do this in a try..finally clause to make sure we delete the temp file # build command line torch_bin = config_value('torch')['executable'] args = [torch_bin, os.path.join(os.path.dirname(digits.__file__), 'tools', 'torch', 'main.lua'), '--network=%s' % os.path.splitext(os.path.basename(temp_network_path))[0], '--networkDirectory=%s' % os.path.dirname(temp_network_path), '--subtractMean=none', # we are not providing a mean image '--visualizeModel=yes', '--type=float' ] # execute command p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, close_fds=True, ) # TODO: need to include regular expression for MAC color codes regex = re.compile('\x1b\[[0-9;]*m', re.UNICODE) # the network description will be accumulated from the command output # when collecting_net_definition==True collecting_net_definition = False desc = [] unrecognized_output = [] while p.poll() is None: for line in utils.nonblocking_readlines(p.stdout): if line is not None: # Remove whitespace and color codes. # Color codes are appended to beginning and end of line by torch binary # i.e., 'th'. Check the below link for more information # https://groups.google.com/forum/#!searchin/torch7/color$20codes/torch7/8O_0lSgSzuA/Ih6wYg9fgcwJ # noqa line = regex.sub('', line) timestamp, level, message = TorchTrainTask.preprocess_output_torch(line.strip()) if message: if message.startswith('Network definition'): collecting_net_definition = not collecting_net_definition else: if collecting_net_definition: desc.append(line) elif len(line): unrecognized_output.append(line) else: time.sleep(0.05) if not len(desc): # we did not find a network description raise NetworkVisualizationError(''.join(unrecognized_output)) else: output = flask.Markup('<pre align="left">') for line in desc: output += flask.Markup.escape(line) output += flask.Markup('</pre>') return output finally: os.remove(temp_network_path)
DIGITS-master
digits/frameworks/torch_framework.py
DIGITS-master
digits/store/__init__.py
# Copyright (c) 2016-2017, NVIDIA CORPORATION. All rights reserved. from __future__ import absolute_import import json import os import tempfile import time import uuid import flask import requests from digits.log import logger from digits.pretrained_model import PretrainedModelJob from digits.utils import auth from digits.utils.store import StoreParser from digits.webapp import app, scheduler, socketio blueprint = flask.Blueprint(__name__, __name__) class Progress(object): """class to emit download progress""" def __init__(self, model_id): self._model_id = model_id self._file = 0 self._n_files = 0 self._n_chunks = 0 self._last_progress = -1 self.emit(0) def set_n_files(self, n_files): """ set the number of files file this Progress object will report """ self._n_files = n_files def set_n_chunks(self, n_chuncks): """ set the number of chunks expected """ self._n_chunks = n_chuncks self._file += 1 self._last_progress = -1 def emit(self, progress): """ emit the progress to the client """ socketio.emit('update', { 'model_id': self._model_id, 'update': 'progress', 'progress': progress, }, namespace='/jobs', room='job_management' ) # micro sleep so that emit is broadcast to the client time.sleep(0.001) def incr(self, itr): """ progress iterator that the request iterator is wrapped in """ for i, item in enumerate(itr): yield item progress = min(int(round(((self._file - 1.0) + (i + 1.0) / self._n_chunks) / self._n_files * 100)), 100) if progress != self._last_progress: self.emit(progress) self._last_progress = progress def save_binary(url, file_name, tmp_dir, progress): r = requests.get(os.path.join(url, file_name), stream=True) chunk_size = 1024 total_length = int(r.headers.get('content-length')) n_chunks = (total_length / chunk_size) + bool(total_length % chunk_size) progress.set_n_chunks(n_chunks) full_path = os.path.join(tmp_dir, file_name) with open(full_path, 'wb') as f: for chunk in progress.incr(r.iter_content(chunk_size=chunk_size)): if chunk: # filter out keep-alive new chunks f.write(chunk) return full_path def save_tensorflow_weights(url, file_name, tmp_dir, progress): full_path = os.path.join(tmp_dir, file_name) save_binary(url, file_name + ".index", tmp_dir, progress) save_binary(url, file_name + ".meta", tmp_dir, progress) save_binary(url, file_name + ".data-00000-of-00001", tmp_dir, progress) return full_path def retrieve_files(url, directory, progress): model_url = os.path.join(url, directory) tmp_dir = tempfile.mkdtemp() tmp = requests.get(os.path.join(model_url, 'info.json')).content info = json.loads(tmp) # How many files will we download? n_files = 1 + ("model file" in info or "network file" in info) + ("labels file" in info) progress.set_n_files(n_files) if (info["snapshot file"].endswith(".ckpt")): weights = save_tensorflow_weights(model_url, info["snapshot file"], tmp_dir, progress) else: weights = save_binary(model_url, info["snapshot file"], tmp_dir, progress) if "model file" in info: remote_model_file = info["model file"] elif "network file" in info: remote_model_file = info["network file"] else: return flask.jsonify({"status": "Missing model definition in info.json"}), 500 model = save_binary(model_url, remote_model_file, tmp_dir, progress) if "labels file" in info: label = save_binary(model_url, info["labels file"], tmp_dir, progress) else: label = None if "python layer file" in info: python_layer = save_binary(model_url, info["python layer file"], tmp_dir, progress) else: python_layer = None meta_data = info return weights, model, label, meta_data, python_layer @blueprint.route('/push', methods=['GET']) def push(): """ Create a pre-trained model from model store """ model_id = flask.request.args.get('id') model_grand_list = app.config['store_cache'].read() found = False if model_grand_list is not None: for store in model_grand_list: for model in model_grand_list[store]['model_list']: if model['id'] == model_id: url = model_grand_list[store]['base_url'] directory = model['dir_name'] found = True break if found: break if not found: return 'Unable to find requested model', 404 else: progress = Progress(model_id) weights, model, label, meta_data, python_layer = retrieve_files(url, directory, progress) job = PretrainedModelJob( weights, model, label, meta_data['framework'], username=auth.get_username(), name=meta_data['name'] ) scheduler.add_job(job) response = flask.make_response(job.id()) return response @blueprint.route('/models', methods=['GET']) def models(): """ perform server-to-server communication to retrieve info.json file in all subfolders of model store """ if flask.request.args.get('refresh') == '1': app.config['store_cache'].reset() cached_data = app.config['store_cache'].read() if cached_data is not None: return json.dumps(cached_data) store_urls = app.config['store_url_list'] aggregated_dict = dict() for i, store_url in enumerate(store_urls): if len(store_url) == 0: continue model_list = list() if store_url[-1] != '/': store_base_url = store_url + '/' else: store_base_url = store_url try: response = requests.get(os.path.join(store_base_url, 'master.json')) if response.status_code == 200: json_response = json.loads(response.content) dirs = json_response['children'] msg = json_response['msg'] else: # try to retrieve from directory listing page = requests.get(store_base_url) parser = StoreParser() parser.feed(page.content) if len(parser.get_child_dirs()) > 0: # we have list of subdirectories dirs = [d[:-1] for d in parser.get_child_dirs()] msg = 'Thanks for visiting {}'.format(store_base_url) else: # nothing found, try next URL continue except requests.exceptions.RequestException as e: logger.warning('Skip %s due to error %s' % (store_base_url, e)) continue for subdir in dirs: tmp_dict = {'dir_name': subdir} response = requests.get(os.path.join(store_base_url, subdir, 'info.json')) if response.status_code == 200: tmp_dict['info'] = json.loads(response.content) tmp_dict['id'] = str(uuid.uuid4()) response = requests.get(os.path.join(store_base_url, subdir, 'aux.json')) if response.status_code == 200: tmp_dict['aux'] = json.loads(response.content) model_list.append(tmp_dict) store_info = {'base_url': store_base_url, 'welcome_msg': msg, 'model_list': model_list} aggregated_dict[store_base_url] = store_info app.config['store_cache'].write(aggregated_dict) return json.dumps(aggregated_dict) @blueprint.route('/list', methods=['GET']) def store(): return flask.render_template( 'store.html' )
DIGITS-master
digits/store/views.py
#!/usr/bin/env python2 # Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. import argparse import logging import numpy as np import pickle import PIL.Image import os import sys try: from cStringIO import StringIO except ImportError: from StringIO import StringIO # Add path for DIGITS package sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))) import digits.config # noqa from digits import utils, log # noqa from digits.inference.errors import InferenceError # noqa from digits.job import Job # noqa from digits.utils.lmdbreader import DbReader # noqa # Import digits.config before caffe to set the path import caffe_pb2 # noqa logger = logging.getLogger('digits.tools.inference') # number of image embeddings to store N_EMBEDDINGS = 10000 def parse_datum(value): """ Parse a Caffe datum """ datum = caffe_pb2.Datum() datum.ParseFromString(value) if datum.encoded: s = StringIO() s.write(datum.data) s.seek(0) img = PIL.Image.open(s) img = np.array(img) else: import caffe.io arr = caffe.io.datum_to_array(datum) # CHW -> HWC arr = arr.transpose((1, 2, 0)) if arr.shape[2] == 1: # HWC -> HW arr = arr[:, :, 0] elif arr.shape[2] == 3: # BGR -> RGB # XXX see issue #59 arr = arr[:, :, [2, 1, 0]] img = arr return img def save_attributes(attributes): """ Save attribute vectors """ zs = np.zeros(attributes['positive_attribute_z'].shape) for i in xrange(attributes['n_attributes']): zs[i] = attributes['positive_attribute_z'][i] / attributes['positive_count'][i] \ - attributes['negative_attribute_z'][i] / attributes['negative_count'][i] output = open('attributes_z.pkl', 'wb') pickle.dump(zs, output) def save_embeddings(embeddings): filename = 'embeddings.pkl' logger.info('Saving embeddings to %s...' % filename) output = open(filename, 'wb') pickle.dump(embeddings, output) def infer(jobs_dir, model_id, epoch, batch_size, gpu): """ Perform inference on a list of images using the specified model """ # job directory defaults to that defined in DIGITS config if jobs_dir == 'none': jobs_dir = digits.config.config_value('jobs_dir') # load model job model_dir = os.path.join(jobs_dir, model_id) assert os.path.isdir(model_dir), "Model dir %s does not exist" % model_dir model = Job.load(model_dir) # load dataset job dataset_dir = os.path.join(jobs_dir, model.dataset_id) assert os.path.isdir(dataset_dir), "Dataset dir %s does not exist" % dataset_dir dataset = Job.load(dataset_dir) for task in model.tasks: task.dataset = dataset # retrieve snapshot file task = model.train_task() snapshot_filename = None epoch = float(epoch) if epoch == -1 and len(task.snapshots): # use last epoch 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 InferenceError("Unable to find snapshot for epoch=%s" % repr(epoch)) input_data = [] # sample data input_labels = [] # sample labels # load images from database feature_db_path = dataset.get_feature_db_path(utils.constants.TRAIN_DB) feature_reader = DbReader(feature_db_path) label_db_path = dataset.get_label_db_path(utils.constants.TRAIN_DB) label_reader = DbReader(label_db_path) embeddings = {'count': 0, 'images': None, 'zs': None} def aggregate(images, labels, attributes, embeddings): # perform inference outputs = model.train_task().infer_many( images, snapshot_epoch=epoch, gpu=gpu, resize=False) z_vectors = outputs['output'][:, :100] for image, label, z in zip(images, labels, z_vectors): if embeddings['images'] is None: embeddings['images'] = np.empty((N_EMBEDDINGS,) + image.shape) if embeddings['zs'] is None: embeddings['zs'] = np.empty((N_EMBEDDINGS,) + z.shape) if embeddings['count'] < N_EMBEDDINGS: embeddings['images'][embeddings['count']] = image embeddings['zs'][embeddings['count']] = z embeddings['count'] += 1 if embeddings['count'] == N_EMBEDDINGS: save_embeddings(embeddings) for attribute in range(attributes['n_attributes']): if label[attribute] > 0: attributes['positive_attribute_z'][attribute] += z attributes['positive_count'][attribute] += 1 else: attributes['negative_attribute_z'][attribute] += z attributes['negative_count'][attribute] += 1 # save save_attributes(attributes) n_input_samples = 0 label_len = None z_dim = 100 for key, value in feature_reader.entries(): img = parse_datum(value) label = parse_datum(label_reader.entry(key))[0] if label_len is None: label_len = len(label) attributes = { 'n_attributes': label_len, 'negative_count': np.zeros(label_len), 'positive_count': np.zeros(label_len), 'negative_attribute_z': np.zeros((label_len, z_dim)), 'positive_attribute_z': np.zeros((label_len, z_dim)), } elif label_len != len(label): raise ValueError("label len differs: %d vs %d" % (label_len, len(label))) input_data.append(img) input_labels.append(label) n_input_samples = n_input_samples + 1 if n_input_samples % batch_size == 0: aggregate(input_data, input_labels, attributes, embeddings) print("######## %d processed ########" % n_input_samples) input_data = [] # sample data input_labels = [] # sample labels if n_input_samples % batch_size != 0: aggregate(input_data, input_labels, attributes, embeddings) print("######## %d processed ########" % n_input_samples) if __name__ == '__main__': parser = argparse.ArgumentParser(description='Inference tool - DIGITS') # Positional arguments parser.add_argument( 'model', help='Model ID') # Optional arguments parser.add_argument( '-e', '--epoch', default='-1', help="Epoch (-1 for last)" ) parser.add_argument( '-j', '--jobs_dir', default='none', help='Jobs directory (default: from DIGITS config)', ) parser.add_argument( '-b', '--batch_size', type=int, default=1024, help='Batch size', ) parser.add_argument( '-g', '--gpu', type=int, default=None, help='GPU to use (as in nvidia-smi output, default: None)', ) parser.set_defaults(resize=True) args = vars(parser.parse_args()) try: infer( args['jobs_dir'], args['model'], args['epoch'], args['batch_size'], args['gpu'], ) except Exception as e: logger.error('%s: %s' % (type(e).__name__, e.message)) raise
DIGITS-master
examples/gan/gan_features.py
# The MIT License (MIT) # # Original work Copyright (c) 2016 Taehoon Kim # Modified work Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import tensorflow as tf from model import Tower from utils import model_property image_summary = tf.summary.image scalar_summary = tf.summary.scalar histogram_summary = tf.summary.histogram merge_summary = tf.summary.merge SummaryWriter = tf.summary.FileWriter class batch_norm(object): """ This class creates an op that composes the specified tensor with a batch normalization layer. """ def __init__(self, epsilon=1e-5, momentum=0.9, name="batch_norm"): """Instance initialization""" with tf.variable_scope(name): self.epsilon = epsilon self.momentum = momentum self.name = name def __call__(self, x, train=True): """ Functional interface Args: x: tensor to compose train: set to True during training and False otherwise """ return tf.contrib.layers.batch_norm(x, decay=self.momentum, updates_collections=None, epsilon=self.epsilon, scale=True, is_training=train, scope=self.name) def conv2d(input_, output_dim, k_h=5, k_w=5, d_h=2, d_w=2, stddev=0.02, name="conv2d"): """ Compose specified symbol with 2D convolution layer Args: input_: tensor to compose. Shape: [N, H, W, C] output_dim: number of output features maps k_h: kernel height k_w: kernel width d_h: horizontal stride d_w: vertical stride stddev: standard deviation of gaussian distribution to use for random weight initialization name: name scope Returns: Composed tensor. """ with tf.variable_scope(name): w = tf.get_variable('w', [k_h, k_w, input_.get_shape()[-1], output_dim], initializer=tf.truncated_normal_initializer(stddev=stddev)) conv = tf.nn.conv2d(input_, w, strides=[1, d_h, d_w, 1], padding='SAME') biases = tf.get_variable('biases', [output_dim], initializer=tf.constant_initializer(0.0)) conv = tf.nn.bias_add(conv, biases) return conv def deconv2d(input_, output_shape, k_h=5, k_w=5, d_h=2, d_w=2, stddev=0.02, name="deconv2d", with_w=False): """ Compose specified symbol with 2D *transpose* convolution layer Args: input_: tensor to compose. Shape: [N, H, W, C] output_shape: output shape k_h: kernel height k_w: kernel width d_h: horizontal stride d_w: vertical stride stddev: standard deviation of gaussian distribution to use for random weight initialization name: name scope Returns: Composed tensor. """ with tf.variable_scope(name): # filter : [height, width, output_channels, in_channels] w = tf.get_variable('w', [k_h, k_w, output_shape[-1], input_.get_shape()[-1]], initializer=tf.random_normal_initializer(stddev=stddev)) deconv = tf.nn.conv2d_transpose(input_, w, output_shape=output_shape, strides=[1, d_h, d_w, 1]) biases = tf.get_variable('biases', [output_shape[-1]], initializer=tf.constant_initializer(0.0)) deconv = tf.reshape(tf.nn.bias_add(deconv, biases), output_shape) if with_w: return deconv, w, biases else: return deconv def lrelu(x, leak=0.2, name="lrelu"): """Compose specified tensor with leaky Rectifier Linear Unit""" return tf.maximum(x, leak*x) def linear(input_, output_size, scope=None, stddev=0.02, bias_start=0.0, with_w=False): """ Compose specified tensor with linear (fully-connected) layer Args: input_: tensor to compose. Shape: [N, M] output_size: number of output neurons scope: name scope stddev: standard deviation of gaussian distribution to use for random weight initialization name: name scope with_w: whether to also return parameter variables Returns: Composed tensor. Shape: [N, output_size] """ shape = input_.get_shape().as_list() with tf.variable_scope(scope or "Linear"): matrix = tf.get_variable("Matrix", [shape[1], output_size], tf.float32, tf.random_normal_initializer(stddev=stddev)) bias = tf.get_variable("bias", [output_size], initializer=tf.constant_initializer(bias_start)) if with_w: return tf.matmul(input_, matrix) + bias, matrix, bias else: return tf.matmul(input_, matrix) + bias class UserModel(Tower): """ User Model definition DIGITS creates an instance of this class for every tower it needs to create. This includes: - one for training, - one for validation, - one for testing. In the case of multi-GPU training, one training instance is created for every GPU. DIGITS takes care of doing the gradient averaging across GPUs so this class only needs to define the inference op and desired loss/cost function. """ def __init__(self, *args, **kwargs): """ Identify the correct input nodes. In the parent class, DIGITS conveniently sets the following fields: - self.is_training: whether this is a training graph - self.is_inference: whether this graph is created for inference/testing - self.x: input node. Shape: [N, H, W, C] - self.y: label. Shape: [N] for scalar labels, [N, H, W, C] otherwise. Only defined if self._is_training is True """ super(UserModel, self).__init__(*args, **kwargs) image_size = 64 output_size = 64 c_dim = 3 z_dim = 100 self.dcgan_init(image_size=image_size, output_size=output_size, c_dim=c_dim, z_dim=z_dim) @model_property def inference(self): """op to use for inference""" # scale back to [0, 255] range return tf.to_int32((self.G+127) * 128) @model_property def loss(self): """ Loss function Returns either an op or a list of dicts. If the returned value is an op then DIGITS will optimize against this op with respect to all trainable variables. If the returned value is a list then DIGITS will optimize against each loss in the list with respect to the specified variables. """ # here we are returning a list because we want to alternately optimize the # discriminator and the generator. losses = [ {'loss': self.d_loss, 'vars': self.d_vars}, {'loss': self.g_loss, 'vars': self.g_vars} ] return losses def dcgan_init(self, image_size, output_size, z_dim, c_dim, gf_dim=64, df_dim=64, gfc_dim=1024, dfc_dim=1024): """ Args: output_size: (optional) The resolution in pixels of the images. [64] z_dim: (optional) Dimension of dim for Z. [100] gf_dim: (optional) Dimension of gen filters in first conv layer. [64] df_dim: (optional) Dimension of discrim filters in first conv layer. [64] gfc_dim: (optional) Dimension of gen units for for fully connected layer. [1024] dfc_dim: (optional) Dimension of discrim units for fully connected layer. [1024] c_dim: (optional) Dimension of image color. For grayscale input, set to 1. [3] """ self.image_size = image_size self.output_size = output_size self.z_dim = z_dim self.gf_dim = gf_dim self.df_dim = df_dim self.gfc_dim = gfc_dim self.dfc_dim = dfc_dim self.c_dim = c_dim self.batch_size = tf.shape(self.x)[0] self.soft_label_margin = 0.1 # batch normalization : deals with poor initialization helps gradient flow self.d_bn1 = batch_norm(name='d_bn1') self.d_bn2 = batch_norm(name='d_bn2') self.d_bn3 = batch_norm(name='d_bn3') self.g_bn0 = batch_norm(name='g_bn0') self.g_bn1 = batch_norm(name='g_bn1') self.g_bn2 = batch_norm(name='g_bn2') self.g_bn3 = batch_norm(name='g_bn3') self.build_model() def build_model(self): if not self.is_inference: # create both the generator and the discriminator # self.x is a batch of images - shape: [N, H, W, C] # self.y is a vector of labels - shape: [N] # sample z from a normal distribution self.z = tf.random_normal(shape=[self.batch_size, self.z_dim], dtype=tf.float32, seed=None, name='z') # scale input to [-1, +1] range self.images = (tf.reshape(self.x, shape=[self.batch_size, self.image_size, self.image_size, self.c_dim], name='x_reshaped') - 128) / 127. # create generator self.G = self.generator(self.z) # create an instance of the discriminator (real samples) self.D, self.D_logits = self.discriminator(self.images, reuse=False) # create another identical instance of the discriminator (fake samples) # NOTE: we are re-using variables here to share weights between the two # instances of the discriminator self.D_, self.D_logits_ = self.discriminator(self.G, reuse=True) # we are using the cross entropy loss for all these losses # note the use of the soft label smoothing here to prevent D from getting overly confident # on real samples d_real = tf.nn.sigmoid_cross_entropy_with_logits(logits=self.D_logits, labels=(tf.ones_like(self.D) - self.soft_label_margin), name="loss_D_real") self.d_loss_real = tf.reduce_mean(d_real) d_fake = tf.nn.sigmoid_cross_entropy_with_logits(logits=self.D_logits_, labels=(tf.zeros_like(self.D_)), name="loss_D_fake") self.d_loss_fake = tf.reduce_mean(d_fake) self.d_loss = (self.d_loss_real + self.d_loss_fake) / 2. # the typical GAN set-up is that of a minimax game where D is trying to minimize # its own error and G is trying to maximize D's error however note how we are flipping G labels here: # instead of maximizing D's error, we are minimizing D's error on the 'wrong' label # this trick helps produce a stronger gradient g_loss = tf.nn.sigmoid_cross_entropy_with_logits(logits=self.D_logits_, labels=(tf.ones_like(self.D_) + self.soft_label_margin), name="loss_G") self.g_loss = tf.reduce_mean(g_loss) # debug self.summaries.append(image_summary("G", self.G, max_outputs=3)) self.summaries.append(image_summary("X", self.images, max_outputs=3)) self.summaries.append(histogram_summary("G_hist", self.G)) self.summaries.append(histogram_summary("X_hist", self.images)) self.summaries.append(scalar_summary("d_loss_real", self.d_loss_real)) self.summaries.append(scalar_summary("d_loss_fake", self.d_loss_fake)) self.summaries.append(scalar_summary("g_loss", self.g_loss)) self.summaries.append(scalar_summary("d_loss", self.d_loss)) # all trainable variables t_vars = tf.trainable_variables() # G variables self.g_vars = [var for var in t_vars if 'g_' in var.name] # D variables self.d_vars = [var for var in t_vars if 'd_' in var.name] # Extra hook for debug: log chi-square distance between G's output histogram and the dataset's histogram value_range = [0.0, 1.0] nbins = 100 hist_g = tf.to_float(tf.histogram_fixed_width(self.G, value_range, nbins=nbins)) / nbins hist_images = tf.to_float(tf.histogram_fixed_width(self.images, value_range, nbins=nbins)) / nbins chi_square = tf.reduce_mean(tf.div(tf.square(hist_g - hist_images), hist_g + hist_images + 1e-5)) self.summaries.append(scalar_summary("chi_square", chi_square)) else: # Create only the generator self.x = tf.reshape(self.x, shape=[self.batch_size, self.z_dim]) self.z = self.x[:, :self.z_dim] self.G = self.generator(self.z) def discriminator(self, image, y=None, reuse=False): """ Create the discriminator This creates a string of layers: - input - [N, 64, 64, 3] - conv layer with 64 5x5 kernels and 2x2 stride - [N, 32, 32, 64] - leaky relu - [N, 32, 32, 64] - conv layer with 128 5x5 kernels and 2x2 stride - [N, 16, 16, 32] - batch norm - [N, 16, 16, 32] - leaky relu - [N, 16, 16, 32] - conv layer with 256 5x5 kernels and 2x2 stride - [N, 8, 8, 256] - batch norm - [N, 8, 8, 256] - leaky relu - [N, 8, 8, 256] - conv layer with 256 5x5 kernels and 2x2 stride - [N, 4, 4, 512] - batch norm - [N, 4, 4, 512] - leaky relu - [N, 4, 4, 512] - flatten - [N, 8192] - linear layer with 1 output neurons - [N, 1] - sigmoid - [N,1] Args: image: batch of input images - shape: [N, H, W, C] y: batch of one-hot encoded labels - shape: [N, K] reuse: whether to re-use previously created variables """ with tf.variable_scope("discriminator") as scope: if reuse: scope.reuse_variables() h0 = lrelu(conv2d(image, self.df_dim, name='d_h0_conv')) h1 = lrelu(self.d_bn1(conv2d(h0, self.df_dim * 2, name='d_h1_conv'), train=self.is_training)) h2 = lrelu(self.d_bn2(conv2d(h1, self.df_dim * 4, name='d_h2_conv'), train=self.is_training)) h3 = lrelu(self.d_bn3(conv2d(h2, self.df_dim * 8, name='d_h3_conv'), train=self.is_training)) h3_size = ((self.output_size // 16) ** 2) * self.df_dim * 8 h4 = linear(tf.reshape(h3, [self.batch_size, h3_size]), 1, 'd_h3_lin') return tf.nn.sigmoid(h4), h4 def generator(self, z, y=None): """ Create the generator This creates a string of layers: - input - [N, 100] - linear layer with 8192 output neurons - [N, 8192] - reshape - [N, 4, 4, 512] - batch norm - [N, 4, 4, 512] - relu - [N, 4, 4, 512] - transpose convolution with 256 filters and stride 2 - [N, 8, 8, 256] - batch norm - [N, 8, 8, 256] - relu - [N, 8, 8, 256] - transpose convolution with 128 filters and stride 2 - [N, 16, 16, 128] - batch norm - [N, 16, 16, 128] - relu - [N, 16, 16, 128] - transpose convolution with 64 filters and stride 2 - [N, 32, 32, 64] - batch norm - [N, 32, 32, 64] - relu - [N, 32, 32, 64] - transpose convolution with 3 filters and stride 2 - [N, 64, 64, 3] - tanh - [N, 64, 64, 3] """ with tf.variable_scope("generator"): s = self.output_size s2, s4, s8, s16 = int(s // 2), int(s // 4), int(s // 8), int(s // 16) # project `z` and reshape self.z_, self.h0_w, self.h0_b = linear(z, self.gf_dim * 8 * s16 * s16, 'g_h0_lin', with_w=True) self.h0 = tf.reshape(self.z_, [-1, s16, s16, self.gf_dim * 8]) h0 = tf.nn.relu(self.g_bn0(self.h0, train=self.is_training)) self.h1, self.h1_w, self.h1_b = deconv2d(h0, [self.batch_size, s8, s8, self.gf_dim * 4], name='g_h1', with_w=True) h1 = tf.nn.relu(self.g_bn1(self.h1, train=self.is_training)) h2, self.h2_w, self.h2_b = deconv2d(h1, [self.batch_size, s4, s4, self.gf_dim * 2], name='g_h2', with_w=True) h2 = tf.nn.relu(self.g_bn2(h2, train=self.is_training)) h3, self.h3_w, self.h3_b = deconv2d(h2, [self.batch_size, s2, s2, self.gf_dim * 1], name='g_h3', with_w=True) h3 = tf.nn.relu(self.g_bn3(h3, train=self.is_training)) h4, self.h4_w, self.h4_b = deconv2d(h3, [self.batch_size, s, s, self.c_dim], name='g_h4', with_w=True) return tf.nn.tanh(h4)
DIGITS-master
examples/gan/network-celebA.py
# The MIT License (MIT) # # Original work Copyright (c) 2016 Taehoon Kim # Modified work Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import tensorflow as tf from model import Tower from utils import model_property image_summary = tf.summary.image scalar_summary = tf.summary.scalar histogram_summary = tf.summary.histogram merge_summary = tf.summary.merge SummaryWriter = tf.summary.FileWriter class batch_norm(object): """ This class creates an op that composes the specified tensor with a batch normalization layer. """ def __init__(self, epsilon=1e-5, momentum=0.9, name="batch_norm"): """Instance initialization""" with tf.variable_scope(name): self.epsilon = epsilon self.momentum = momentum self.name = name def __call__(self, x, train=True): """ Functional interface Args: x: tensor to compose train: set to True during training and False otherwise """ return tf.contrib.layers.batch_norm(x, decay=self.momentum, updates_collections=None, epsilon=self.epsilon, scale=True, is_training=train, scope=self.name) def conv_cond_concat(x, y): """ Concatenate conditioning matrix across channel axis. The specified input tensor is concatenated with K feature maps (K = number of classes) across the channel dimension. Each of the K feature maps is set to all-zeros except for the one whose index matches the target class (which is set to all-ones). Args: x: non-conditioned tensor. Shape: [N, H, W, C] y: one-hot encoded conditioning matrix. Shape: [N, K] Returns: conditioned feature map. Shape: [N, H, W, C + K] """ x_shapes = x.get_shape() y_shapes = y.get_shape() batch_size = tf.shape(x)[0] return tf.concat([x, y * tf.ones([batch_size, int(x_shapes[1]), int(x_shapes[2]), int(y_shapes[3])])], 3) def conv2d(input_, output_dim, k_h=5, k_w=5, d_h=2, d_w=2, stddev=0.02, name="conv2d"): """ Compose specified symbol with 2D convolution layer Args: input_: tensor to compose. Shape: [N, H, W, C] output_dim: number of output features maps k_h: kernel height k_w: kernel width d_h: horizontal stride d_w: vertical stride stddev: standard deviation of gaussian distribution to use for random weight initialization name: name scope Returns: Composed tensor. """ with tf.variable_scope(name): w = tf.get_variable('w', [k_h, k_w, input_.get_shape()[-1], output_dim], initializer=tf.truncated_normal_initializer(stddev=stddev)) conv = tf.nn.conv2d(input_, w, strides=[1, d_h, d_w, 1], padding='SAME') biases = tf.get_variable('biases', [output_dim], initializer=tf.constant_initializer(0.0)) conv = tf.nn.bias_add(conv, biases) return conv def deconv2d(input_, output_shape, k_h=5, k_w=5, d_h=2, d_w=2, stddev=0.02, name="deconv2d", with_w=False): """ Compose specified symbol with 2D *transpose* convolution layer Args: input_: tensor to compose. Shape: [N, H, W, C] output_shape: output shape k_h: kernel height k_w: kernel width d_h: horizontal stride d_w: vertical stride stddev: standard deviation of gaussian distribution to use for random weight initialization name: name scope Returns: Composed tensor. """ with tf.variable_scope(name): # filter : [height, width, output_channels, in_channels] w = tf.get_variable('w', [k_h, k_w, output_shape[-1], input_.get_shape()[-1]], initializer=tf.random_normal_initializer(stddev=stddev)) deconv = tf.nn.conv2d_transpose(input_, w, output_shape=output_shape, strides=[1, d_h, d_w, 1]) biases = tf.get_variable('biases', [output_shape[-1]], initializer=tf.constant_initializer(0.0)) deconv = tf.reshape(tf.nn.bias_add(deconv, biases), output_shape) if with_w: return deconv, w, biases else: return deconv def lrelu(x, leak=0.2, name="lrelu"): """Compose specified tensor with leaky Rectifier Linear Unit""" return tf.maximum(x, leak*x) def linear(input_, output_size, scope=None, stddev=0.02, bias_start=0.0, with_w=False): """ Compose specified tensor with linear (fully-connected) layer Args: input_: tensor to compose. Shape: [N, M] output_size: number of output neurons scope: name scope stddev: standard deviation of gaussian distribution to use for random weight initialization name: name scope with_w: whether to also return parameter variables Returns: Composed tensor. Shape: [N, output_size] """ shape = input_.get_shape().as_list() with tf.variable_scope(scope or "Linear"): matrix = tf.get_variable("Matrix", [shape[1], output_size], tf.float32, tf.random_normal_initializer(stddev=stddev)) bias = tf.get_variable("bias", [output_size], initializer=tf.constant_initializer(bias_start)) if with_w: return tf.matmul(input_, matrix) + bias, matrix, bias else: return tf.matmul(input_, matrix) + bias class UserModel(Tower): """ User Model definition DIGITS creates an instance of this class for every tower it needs to create. This includes: - one for training, - one for validation, - one for testing. In the case of multi-GPU training, one training instance is created for every GPU. DIGITS takes care of doing the gradient averaging across GPUs so this class only needs to define the inference op and desired loss/cost function. """ def __init__(self, *args, **kwargs): """ Identify the correct input nodes. In the parent class, DIGITS conveniently sets the following fields: - self.is_training: whether this is a training graph - self.is_inference: whether this graph is created for inference/testing - self.x: input node. Shape: [N, H, W, C] - self.y: label. Shape: [N] for scalar labels, [N, H, W, C] otherwise. Only defined if self._is_training is True """ super(UserModel, self).__init__(*args, **kwargs) # initialize graph with parameters for MNIST self.dcgan_init(image_size=28, y_dim=10, output_size=28, c_dim=1) @model_property def inference(self): """op to use for inference""" # inference op is the output of the generator after rescaling # to the 8-bit range return tf.to_int32(self.G * 255) @model_property def loss(self): """ Loss function Returns either an op or a list of dicts. If the returned value is an op then DIGITS will optimize against this op with respect to all trainable variables. If the returned value is a list then DIGITS will optimize against each loss in the list with respect to the specified variables. """ # here we are returning a list because we want to alternately optimize the # discriminator on real samples, the discriminator on fake samples and the # generator. losses = [ {'loss': self.d_loss_real, 'vars': self.d_vars}, {'loss': self.d_loss_fake, 'vars': self.d_vars}, {'loss': self.g_loss, 'vars': self.g_vars} ] return losses def dcgan_init(self, image_size=108, output_size=64, y_dim=None, z_dim=100, gf_dim=64, df_dim=64, gfc_dim=1024, dfc_dim=1024, c_dim=3): """ Create the model Args: output_size: (optional) The resolution in pixels of the images. [64] y_dim: (optional) Dimension of dim for y. [None] z_dim: (optional) Dimension of dim for Z. [100] gf_dim: (optional) Dimension of gen filters in first conv layer. [64] df_dim: (optional) Dimension of discrim filters in first conv layer. [64] gfc_dim: (optional) Dimension of gen units for for fully connected layer. [1024] dfc_dim: (optional) Dimension of discrim units for fully connected layer. [1024] c_dim: (optional) Dimension of image color. For grayscale input, set to 1. [3] """ self.image_size = image_size self.output_size = output_size self.y_dim = y_dim self.z_dim = z_dim self.gf_dim = gf_dim self.df_dim = df_dim self.gfc_dim = gfc_dim self.dfc_dim = dfc_dim self.c_dim = c_dim self.batch_size = tf.shape(self.x)[0] # batch normalization : deals with poor initialization helps gradient flow self.d_bn1 = batch_norm(name='d_bn1') self.d_bn2 = batch_norm(name='d_bn2') self.g_bn0 = batch_norm(name='g_bn0') self.g_bn1 = batch_norm(name='g_bn1') self.g_bn2 = batch_norm(name='g_bn2') self.build_model() def build_model(self): """Create the main ops""" if not self.is_inference: # create both the generator and the discriminator # self.x is a batch of images - shape: [N, H, W, C] # self.y is a vector of labels - shape: [N] # sample z from a normal distribution self.z = tf.random_normal(shape=[self.batch_size, self.z_dim], dtype=tf.float32, seed=None, name='z') # rescale x to [0, 1] x_reshaped = tf.reshape(self.x, shape=[self.batch_size, self.image_size, self.image_size, self.c_dim], name='x_reshaped') self.images = x_reshaped / 255. # one hot encode the label - shape: [N] -> [N, self.y_dim] self.y = tf.one_hot(self.y, self.y_dim, name='y_onehot') # create the generator self.G = self.generator(self.z, self.y) # create one instance of the discriminator for real images (the input is # images from the dataset) self.D, self.D_logits = self.discriminator(self.images, self.y, reuse=False) # create another instance of the discriminator for fake images (the input is # the discriminator). Note how we are reusing variables to share weights between # both instances of the discriminator self.D_, self.D_logits_ = self.discriminator(self.G, self.y, reuse=True) # aggregate losses across batch # we are using the cross entropy loss for all these losses d_real = tf.nn.sigmoid_cross_entropy_with_logits(logits=self.D_logits, labels=tf.ones_like(self.D), name="loss_D_real") self.d_loss_real = tf.reduce_mean(d_real) d_fake = tf.nn.sigmoid_cross_entropy_with_logits(logits=self.D_logits_, labels=tf.zeros_like(self.D_), name="loss_D_fake") self.d_loss_fake = tf.reduce_mean(d_fake) self.d_loss = (self.d_loss_real + self.d_loss_fake) / 2. # the typical GAN set-up is that of a minimax game where D is trying to minimize # its own error and G is trying to maximize D's error however note how we are flipping G labels here: # instead of maximizing D's error, we are minimizing D's error on the 'wrong' label # this trick helps produce a stronger gradient g_loss = tf.nn.sigmoid_cross_entropy_with_logits(logits=self.D_logits_, labels=tf.ones_like(self.D_), name="loss_G") self.g_loss = tf.reduce_mean(g_loss) # create some summaries for debug and monitoring self.summaries.append(histogram_summary("z", self.z)) self.summaries.append(histogram_summary("d", self.D)) self.summaries.append(histogram_summary("d_", self.D_)) self.summaries.append(image_summary("G", self.G, max_outputs=5)) self.summaries.append(image_summary("X", self.images, max_outputs=5)) self.summaries.append(histogram_summary("G_hist", self.G)) self.summaries.append(histogram_summary("X_hist", self.images)) self.summaries.append(scalar_summary("d_loss_real", self.d_loss_real)) self.summaries.append(scalar_summary("d_loss_fake", self.d_loss_fake)) self.summaries.append(scalar_summary("g_loss", self.g_loss)) self.summaries.append(scalar_summary("d_loss", self.d_loss)) # all trainable variables t_vars = tf.trainable_variables() # G's variables self.g_vars = [var for var in t_vars if 'g_' in var.name] # D's variables self.d_vars = [var for var in t_vars if 'd_' in var.name] # Extra hook for debug: log chi-square distance between G's output histogram and the dataset's histogram value_range = [0.0, 1.0] nbins = 100 hist_g = tf.to_float(tf.histogram_fixed_width(self.G, value_range, nbins=nbins)) / nbins hist_images = tf.to_float(tf.histogram_fixed_width(self.images, value_range, nbins=nbins)) / nbins chi_square = tf.reduce_mean(tf.div(tf.square(hist_g - hist_images), hist_g + hist_images + 1e-5)) self.summaries.append(scalar_summary("chi_square", chi_square)) else: # Create only the generator # self.x is the conditioned latent representation - shape: [self.batch_size, 1, self.z_dim + self.y_dim] self.x = tf.reshape(self.x, shape=[self.batch_size, self.z_dim + self.y_dim]) # extract z and y self.y = self.x[:, self.z_dim:self.z_dim + self.y_dim] self.z = self.x[:, :self.z_dim] # create an instance of the generator self.G = self.generator(self.z, self.y) def discriminator(self, image, y=None, reuse=False): """ Create the discriminator This creates a string of layers: - input - [N, 28, 28, 1] - concat conditioning - [N, 28, 28, 11] - conv layer with 11 5x5 kernels and 2x2 stride - [N, 14, 14, 11] - leaky relu - [N, 14, 14, 11] - concat conditioning - [N, 14, 14, 21] - conv layer with 74 5x5 kernels and 2x2 stride - [N, 7, 7, 74] - batch norm - [N, 14, 14, 64] - leaky relu - [N, 14, 14, 64] - flatten - [N, 3626] - concat conditioning - [N, 3636] - linear layer with 1014 output neurons - [N, 1024] - batch norm - [N, 1024] - leaky relu - [N, 1024] - concat conditioning - [N, 1034] - linear layer with 1 output neuron - [N, 1] Args: image: batch of input images - shape: [N, H, W, C] y: batch of one-hot encoded labels - shape: [N, K] reuse: whether to re-use previously created variables """ with tf.variable_scope("discriminator") as scope: if reuse: # re-use (share) variables scope.reuse_variables() yb = tf.reshape(y, [self.batch_size, 1, 1, self.y_dim]) x = conv_cond_concat(image, yb) h0 = lrelu(conv2d(x, self.c_dim + self.y_dim, name='d_h0_conv')) h0 = conv_cond_concat(h0, yb) h1 = lrelu(self.d_bn1(conv2d(h0, self.df_dim + self.y_dim, name='d_h1_conv'), train=self.is_training)) sz = h1.get_shape() h1 = tf.reshape(h1, [self.batch_size, int(sz[1] * sz[2] * sz[3])]) h1 = tf.concat([h1, y], 1) h2 = lrelu(self.d_bn2(linear(h1, self.dfc_dim, 'd_h2_lin'), train=self.is_training)) h2 = tf.concat([h2, y], 1) h3 = linear(h2, 1, 'd_h3_lin') return tf.nn.sigmoid(h3), h3 def generator(self, z, y=None): """ Create the generator This creates a string of layers: - input - [N, 100] - concatenate conditioning - [N, 110] - linear layer with 1024 output neurons - [N, 1024] - batch norm - [N, 1024] - relu - [N, 1024] - concatenate conditioning - [N, 1034] - linear layer with 7*7*128=6272 output neurons - [N, 6272] - reshape 7x7 feature maps - [N, 7, 7, 128] - concatenate conditioning - [N, 7, 7, 138] - transpose convolution with 128 filters and stride 2 - [N, 14, 14, 128] - batch norm - [N, 14, 14, 128] - relu - [N, 14, 14, 128] - concatenate conditioing - [N, 14, 14, 138] - transpose convolution with 1 filter and stride 2 - [N, 28, 28, 1] """ with tf.variable_scope("generator"): s = self.output_size s2, s4 = int(s/2), int(s/4) yb = tf.reshape(y, [self.batch_size, 1, 1, self.y_dim]) z = tf.concat([z, y], 1) h0 = tf.nn.relu(self.g_bn0(linear(z, self.gfc_dim, 'g_h0_lin'), train=self.is_training)) h0 = tf.concat([h0, y], 1) h1 = tf.nn.relu(self.g_bn1(linear(h0, self.gf_dim*2*s4*s4, 'g_h1_lin'), train=self.is_training)) h1 = tf.reshape(h1, [self.batch_size, s4, s4, self.gf_dim * 2]) h1 = conv_cond_concat(h1, yb) h2 = tf.nn.relu(self.g_bn2(deconv2d(h1, [self.batch_size, s2, s2, self.gf_dim * 2], name='g_h2'), train=self.is_training)) h2 = conv_cond_concat(h2, yb) return tf.nn.sigmoid(deconv2d(h2, [self.batch_size, s, s, self.c_dim], name='g_h3'))
DIGITS-master
examples/gan/network-mnist.py
# The MIT License (MIT) # # Original work Copyright (c) 2016 Taehoon Kim # Modified work Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import tensorflow as tf from model import Tower from utils import model_property image_summary = tf.summary.image scalar_summary = tf.summary.scalar histogram_summary = tf.summary.histogram merge_summary = tf.summary.merge SummaryWriter = tf.summary.FileWriter class batch_norm(object): """ This class creates an op that composes the specified tensor with a batch normalization layer. """ def __init__(self, epsilon=1e-5, momentum=0.9, name="batch_norm"): """Instance initialization""" with tf.variable_scope(name): self.epsilon = epsilon self.momentum = momentum self.name = name def __call__(self, x, train=True): """ Functional interface Args: x: tensor to compose train: set to True during training and False otherwise """ return tf.contrib.layers.batch_norm(x, decay=self.momentum, updates_collections=None, epsilon=self.epsilon, scale=True, is_training=train, scope=self.name) def conv_cond_concat(x, y): """ Concatenate conditioning matrix across channel axis. The specified input tensor is concatenated with K feature maps (K = number of classes) across the channel dimension. Each of the K feature maps is set to all-zeros except for the one whose index matches the target class (which is set to all-ones). Args: x: non-conditioned tensor. Shape: [N, H, W, C] y: one-hot encoded conditioning matrix. Shape: [N, K] Returns: conditioned feature map. Shape: [N, H, W, C + K] """ x_shapes = x.get_shape() y_shapes = y.get_shape() batch_size = tf.shape(x)[0] return tf.concat([x, y * tf.ones([batch_size, int(x_shapes[1]), int(x_shapes[2]), int(y_shapes[3])])], 3) def conv2d(input_, output_dim, k_h=5, k_w=5, d_h=2, d_w=2, stddev=0.02, name="conv2d"): """ Compose specified symbol with 2D convolution layer Args: input_: tensor to compose. Shape: [N, H, W, C] output_dim: number of output features maps k_h: kernel height k_w: kernel width d_h: horizontal stride d_w: vertical stride stddev: standard deviation of gaussian distribution to use for random weight initialization name: name scope Returns: Composed tensor. """ with tf.variable_scope(name): w = tf.get_variable('w', [k_h, k_w, input_.get_shape()[-1], output_dim], initializer=tf.truncated_normal_initializer(stddev=stddev)) conv = tf.nn.conv2d(input_, w, strides=[1, d_h, d_w, 1], padding='SAME') biases = tf.get_variable('biases', [output_dim], initializer=tf.constant_initializer(0.0)) conv = tf.nn.bias_add(conv, biases) return conv def deconv2d(input_, output_shape, k_h=5, k_w=5, d_h=2, d_w=2, stddev=0.02, name="deconv2d", with_w=False): """ Compose specified symbol with 2D *transpose* convolution layer Args: input_: tensor to compose. Shape: [N, H, W, C] output_shape: output shape k_h: kernel height k_w: kernel width d_h: horizontal stride d_w: vertical stride stddev: standard deviation of gaussian distribution to use for random weight initialization name: name scope Returns: Composed tensor. """ with tf.variable_scope(name): # filter : [height, width, output_channels, in_channels] w = tf.get_variable('w', [k_h, k_w, output_shape[-1], input_.get_shape()[-1]], initializer=tf.random_normal_initializer(stddev=stddev)) deconv = tf.nn.conv2d_transpose(input_, w, output_shape=output_shape, strides=[1, d_h, d_w, 1]) biases = tf.get_variable('biases', [output_shape[-1]], initializer=tf.constant_initializer(0.0)) deconv = tf.reshape(tf.nn.bias_add(deconv, biases), output_shape) if with_w: return deconv, w, biases else: return deconv def lrelu(x, leak=0.2, name="lrelu"): """Compose specified tensor with leaky Rectifier Linear Unit""" return tf.maximum(x, leak*x) def linear(input_, output_size, scope=None, stddev=0.02, bias_start=0.0, with_w=False): """ Compose specified tensor with linear (fully-connected) layer Args: input_: tensor to compose. Shape: [N, M] output_size: number of output neurons scope: name scope stddev: standard deviation of gaussian distribution to use for random weight initialization name: name scope with_w: whether to also return parameter variables Returns: Composed tensor. Shape: [N, output_size] """ shape = input_.get_shape().as_list() with tf.variable_scope(scope or "Linear"): matrix = tf.get_variable("Matrix", [shape[1], output_size], tf.float32, tf.random_normal_initializer(stddev=stddev)) bias = tf.get_variable("bias", [output_size], initializer=tf.constant_initializer(bias_start)) if with_w: return tf.matmul(input_, matrix) + bias, matrix, bias else: return tf.matmul(input_, matrix) + bias class UserModel(Tower): """ User Model definition DIGITS creates an instance of this class for every tower it needs to create. This includes: - one for training, - one for validation, - one for testing. In the case of multi-GPU training, one training instance is created for every GPU. DIGITS takes care of doing the gradient averaging across GPUs so this class only needs to define the inference op and desired loss/cost function. """ def __init__(self, *args, **kwargs): """ Identify the correct input nodes. In the parent class, DIGITS conveniently sets the following fields: - self.is_training: whether this is a training graph - self.is_inference: whether this graph is created for inference/testing - self.x: input node. Shape: [N, H, W, C] - self.y: label. Shape: [N] for scalar labels, [N, H, W, C] otherwise. Only defined if self._is_training is True """ super(UserModel, self).__init__(*args, **kwargs) # initialize graph with parameters for MNIST self.dcgan_init(image_size=28, y_dim=10, output_size=28, c_dim=1) @model_property def inference(self): """ op to use for inference """ # rescale images = self.G * 255 # flatten G output images_flat = tf.reshape(images, [self.batch_size, self.image_size * self.image_size * self.c_dim]) # now return encoded z concatenated with G output # during inference the visualization script will need to extract # both z and the generated image to display them separately zgen_flat = tf.reshape(self.DzGEN, [self.batch_size, self.z_dim]) return tf.concat([zgen_flat, images_flat], 1) @model_property def loss(self): """ Loss function Returns either an op or a list of dicts. If the returned value is an op then DIGITS will optimize against this op with respect to all trainable variables. If the returned value is a list then DIGITS will optimize against each loss in the list with respect to the specified variables. """ # here we are returning a list because we want to alternately optimize the # discriminator on real samples, the discriminator on fake samples and the # generator. losses = [ {'loss': self.dzgen_loss, 'vars': self.d_vars}, ] return losses def dcgan_init(self, image_size=108, output_size=64, y_dim=None, z_dim=100, gf_dim=64, df_dim=64, gfc_dim=1024, dfc_dim=1024, c_dim=3): """ Create the model Args: output_size: (optional) The resolution in pixels of the images. [64] y_dim: (optional) Dimension of dim for y. [None] z_dim: (optional) Dimension of dim for Z. [100] gf_dim: (optional) Dimension of gen filters in first conv layer. [64] df_dim: (optional) Dimension of discrim filters in first conv layer. [64] gfc_dim: (optional) Dimension of gen units for for fully connected layer. [1024] dfc_dim: (optional) Dimension of discrim units for fully connected layer. [1024] c_dim: (optional) Dimension of image color. For grayscale input, set to 1. [3] """ self.image_size = image_size self.output_size = output_size self.y_dim = y_dim self.z_dim = z_dim self.gf_dim = gf_dim self.df_dim = df_dim self.gfc_dim = gfc_dim self.dfc_dim = dfc_dim self.c_dim = c_dim self.batch_size = tf.shape(self.x)[0] # batch normalization : deals with poor initialization helps gradient flow self.d_bn1 = batch_norm(name='d_bn1') self.d_bn2 = batch_norm(name='d_bn2') self.g_bn0 = batch_norm(name='g_bn0') self.g_bn1 = batch_norm(name='g_bn1') self.g_bn2 = batch_norm(name='g_bn2') self.build_model() def build_model(self): """Create the main ops""" if self.is_inference: # HACK: we are hard-coding class 3 during inference # TODO: find way to pass this from UI self.y = tf.to_int32(3*tf.ones(shape=[self.batch_size])) # create both the generator and the discriminator/encoder # self.x is a batch of images - shape: [N, H, W, C] # self.y is a vector of labels - shape: [N] # rescale to [0,1] range x_reshaped = tf.reshape(self.x, shape=[self.batch_size, self.image_size, self.image_size, self.c_dim], name='x_reshaped') self.images = x_reshaped / 255. # one-hot encode y - shape: [N] -> [N, self.y_dim] self.y = tf.one_hot(self.y, self.y_dim, name='y_onehot') # create discriminator/encoder self.DzGEN, self.D_logits = self.discriminator(self.images, self.y, reuse=False) # create generator self.G = self.generator(self.DzGEN, self.y) # we only have one loss function here (L2 distance between input image and generator output) self.dzgen_loss = tf.reduce_mean(tf.square(self.G - self.images), name="loss_DzGEN") # debug self.summaries.append(image_summary("G", self.G, max_outputs=5)) self.summaries.append(image_summary("X", self.images, max_outputs=5)) self.summaries.append(histogram_summary("G_hist", self.G)) self.summaries.append(histogram_summary("X_hist", self.images)) self.summaries.append(scalar_summary("DzGen_loss", self.dzgen_loss)) # all trainable variables t_vars = tf.trainable_variables() # D variables self.d_vars = [var for var in t_vars if 'd_' in var.name] def discriminator(self, image, y=None, reuse=False): """ Create the discriminator/encoder This creates a string of layers: - input - [N, 28, 28, 1] - concat conditioning - [N, 28, 28, 11] - conv layer with 11 5x5 kernels and 2x2 stride - [N, 14, 14, 11] - leaky relu - [N, 14, 14, 11] - concat conditioning - [N, 14, 14, 21] - conv layer with 74 5x5 kernels and 2x2 stride - [N, 7, 7, 74] - batch norm - [N, 14, 14, 64] - leaky relu - [N, 14, 14, 64] - flatten - [N, 3626] - concat conditioning - [N, 3636] - linear layer with 1014 output neurons - [N, 1024] - batch norm - [N, 1024] - leaky relu - [N, 1024] - concat conditioning - [N, 1034] - linear layer with 1 output neuron - [N, z_dim] Args: image: batch of input images - shape: [N, H, W, C] y: batch of one-hot encoded labels - shape: [N, K] reuse: whether to re-use previously created variables """ # NOTE: although we are really creating an encoder here we need to re-use the same # variable scope (i.e. "discriminator") as in the original GAN so we can re-use # learned parameters with tf.variable_scope("discriminator") as scope: if reuse: # re-use (share) variables scope.reuse_variables() yb = tf.reshape(y, [self.batch_size, 1, 1, self.y_dim]) x = conv_cond_concat(image, yb) h0 = lrelu(conv2d(x, self.c_dim + self.y_dim, name='d_h0_conv')) h0 = conv_cond_concat(h0, yb) h1 = lrelu(self.d_bn1(conv2d(h0, self.df_dim + self.y_dim, name='d_h1_conv'), train=self.is_training)) sz = h1.get_shape() h1 = tf.reshape(h1, [self.batch_size, int(sz[1] * sz[2] * sz[3])]) h1 = tf.concat([h1, y], 1) h2 = lrelu(self.d_bn2(linear(h1, self.dfc_dim, 'd_h2_lin'), train=self.is_training)) h2 = tf.concat([h2, y], 1) h3 = linear(h2, self.z_dim, 'd_h3_lin_retrain') return h3, h3 def generator(self, z, y=None): """ Create the generator This creates a string of layers: - input - [N, 100] - concatenate conditioning - [N, 110] - linear layer with 1024 output neurons - [N, 1024] - batch norm - [N, 1024] - relu - [N, 1024] - concatenate conditioning - [N, 1034] - linear layer with 7*7*128=6272 output neurons - [N, 6272] - reshape 7x7 feature maps - [N, 7, 7, 128] - concatenate conditioning - [N, 7, 7, 138] - transpose convolution with 128 filters and stride 2 - [N, 14, 14, 128] - batch norm - [N, 14, 14, 128] - relu - [N, 14, 14, 128] - concatenate conditioing - [N, 14, 14, 138] - transpose convolution with 1 filter and stride 2 - [N, 28, 28, 1] """ with tf.variable_scope("generator"): s = self.output_size s2, s4 = int(s/2), int(s/4) # yb = tf.expand_dims(tf.expand_dims(y, 1),2) yb = tf.reshape(y, [self.batch_size, 1, 1, self.y_dim]) z = tf.concat([z, y], 1) h0 = tf.nn.relu(self.g_bn0(linear(z, self.gfc_dim, 'g_h0_lin'), train=False)) h0 = tf.concat([h0, y], 1) h1 = tf.nn.relu(self.g_bn1(linear(h0, self.gf_dim*2*s4*s4, 'g_h1_lin'), train=False)) h1 = tf.reshape(h1, [self.batch_size, s4, s4, self.gf_dim * 2]) h1 = conv_cond_concat(h1, yb) h2 = tf.nn.relu(self.g_bn2(deconv2d(h1, [self.batch_size, s2, s2, self.gf_dim * 2], name='g_h2'), train=False)) h2 = conv_cond_concat(h2, yb) return tf.nn.sigmoid(deconv2d(h2, [self.batch_size, s, s, self.c_dim], name='g_h3'))
DIGITS-master
examples/gan/network-mnist-encoder.py
#!/usr/bin/env python2 # Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. import argparse import os import pickle import shutil import numpy as np import PIL.Image import tensorflow as tf from tensorflow.contrib.tensorboard.plugins import projector TB_DIR = os.path.join(os.getcwd(), "gan-tb") SPRITE_IMAGE_FILENAME = os.path.join(TB_DIR, "sprite.png") def save_tb_embeddings(embeddings_filename): f = open(embeddings_filename, 'rb') embeddings = pickle.load(f) images = embeddings['images'] zs = embeddings['zs'] # overwrite Tensorboard log dir if necessary if os.path.exists(TB_DIR): shutil.rmtree(TB_DIR) os.makedirs(TB_DIR) # create grid image img_width, img_height = save_sprite_image(images) with tf.device('cpu:0'): # create embedding var embedding_var = tf.Variable(initial_value=zs) # save projector config summary_writer = tf.summary.FileWriter(TB_DIR) config = projector.ProjectorConfig() embedding = config.embeddings.add() embedding.tensor_name = embedding_var.name embedding.sprite.image_path = SPRITE_IMAGE_FILENAME embedding.sprite.single_image_dim.extend([img_width, img_height]) projector.visualize_embeddings(summary_writer, config) # save embeddings sess = tf.Session() sess.run(embedding_var.initializer) saver = tf.train.Saver([embedding_var]) saver.save(sess, os.path.join(TB_DIR, 'model.ckpt')) def save_sprite_image(images): n_embeddings = images.shape[0] grid_cols = int(np.sqrt(n_embeddings)) grid_rows = int(np.ceil(float(n_embeddings) / grid_cols)) img_height, img_width, img_channels = images[0].shape grid_image = np.empty((img_height * grid_rows, img_width * grid_cols, img_channels)) for i, image in enumerate(images): row = i / grid_cols col = i % grid_cols x = img_width * col y = img_height * row grid_image[y:y + img_height, x:x + img_width] = image grid_image = PIL.Image.fromarray(grid_image.astype('uint8')) grid_image.save(SPRITE_IMAGE_FILENAME) return img_width, img_height if __name__ == '__main__': parser = argparse.ArgumentParser(description='Inference tool - DIGITS') # Positional arguments parser.add_argument( 'embeddings_file', help='Embeddings pickle file') args = vars(parser.parse_args()) try: save_tb_embeddings( args['embeddings_file'], ) except Exception as e: print('%s: %s' % (type(e).__name__, e.message)) raise
DIGITS-master
examples/gan/gan_embeddings.py
# The MIT License (MIT) # # Original work Copyright (c) 2016 Taehoon Kim # Modified work Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import tensorflow as tf from model import Tower from utils import model_property image_summary = tf.summary.image scalar_summary = tf.summary.scalar histogram_summary = tf.summary.histogram merge_summary = tf.summary.merge SummaryWriter = tf.summary.FileWriter class batch_norm(object): """ This class creates an op that composes the specified tensor with a batch normalization layer. """ def __init__(self, epsilon=1e-5, momentum=0.9, name="batch_norm"): """Instance initialization""" with tf.variable_scope(name): self.epsilon = epsilon self.momentum = momentum self.name = name def __call__(self, x, train=True): """ Functional interface Args: x: tensor to compose train: set to True during training and False otherwise """ return tf.contrib.layers.batch_norm(x, decay=self.momentum, updates_collections=None, epsilon=self.epsilon, scale=True, is_training=train, scope=self.name) def conv2d(input_, output_dim, k_h=5, k_w=5, d_h=2, d_w=2, stddev=0.02, name="conv2d"): """ Compose specified symbol with 2D convolution layer Args: input_: tensor to compose. Shape: [N, H, W, C] output_dim: number of output features maps k_h: kernel height k_w: kernel width d_h: horizontal stride d_w: vertical stride stddev: standard deviation of gaussian distribution to use for random weight initialization name: name scope Returns: Composed tensor. """ with tf.variable_scope(name): w = tf.get_variable('w', [k_h, k_w, input_.get_shape()[-1], output_dim], initializer=tf.truncated_normal_initializer(stddev=stddev)) conv = tf.nn.conv2d(input_, w, strides=[1, d_h, d_w, 1], padding='SAME') biases = tf.get_variable('biases', [output_dim], initializer=tf.constant_initializer(0.0)) conv = tf.nn.bias_add(conv, biases) return conv def deconv2d(input_, output_shape, k_h=5, k_w=5, d_h=2, d_w=2, stddev=0.02, name="deconv2d", with_w=False): """ Compose specified symbol with 2D *transpose* convolution layer Args: input_: tensor to compose. Shape: [N, H, W, C] output_shape: output shape k_h: kernel height k_w: kernel width d_h: horizontal stride d_w: vertical stride stddev: standard deviation of gaussian distribution to use for random weight initialization name: name scope Returns: Composed tensor. """ with tf.variable_scope(name): # filter : [height, width, output_channels, in_channels] w = tf.get_variable('w', [k_h, k_w, output_shape[-1], input_.get_shape()[-1]], initializer=tf.random_normal_initializer(stddev=stddev)) deconv = tf.nn.conv2d_transpose(input_, w, output_shape=output_shape, strides=[1, d_h, d_w, 1]) biases = tf.get_variable('biases', [output_shape[-1]], initializer=tf.constant_initializer(0.0)) deconv = tf.reshape(tf.nn.bias_add(deconv, biases), output_shape) if with_w: return deconv, w, biases else: return deconv def lrelu(x, leak=0.2, name="lrelu"): """Compose specified tensor with leaky Rectifier Linear Unit""" return tf.maximum(x, leak*x) def linear(input_, output_size, scope=None, stddev=0.02, bias_start=0.0, with_w=False): """ Compose specified tensor with linear (fully-connected) layer Args: input_: tensor to compose. Shape: [N, M] output_size: number of output neurons scope: name scope stddev: standard deviation of gaussian distribution to use for random weight initialization name: name scope with_w: whether to also return parameter variables Returns: Composed tensor. Shape: [N, output_size] """ shape = input_.get_shape().as_list() with tf.variable_scope(scope or "Linear"): matrix = tf.get_variable("Matrix", [shape[1], output_size], tf.float32, tf.random_normal_initializer(stddev=stddev)) bias = tf.get_variable("bias", [output_size], initializer=tf.constant_initializer(bias_start)) if with_w: return tf.matmul(input_, matrix) + bias, matrix, bias else: return tf.matmul(input_, matrix) + bias class UserModel(Tower): """ User Model definition DIGITS creates an instance of this class for every tower it needs to create. This includes: - one for training, - one for validation, - one for testing. In the case of multi-GPU training, one training instance is created for every GPU. DIGITS takes care of doing the gradient averaging across GPUs so this class only needs to define the inference op and desired loss/cost function. """ def __init__(self, *args, **kwargs): """ Identify the correct input nodes. In the parent class, DIGITS conveniently sets the following fields: - self.is_training: whether this is a training graph - self.is_inference: whether this graph is created for inference/testing - self.x: input node. Shape: [N, H, W, C] - self.y: label. Shape: [N] for scalar labels, [N, H, W, C] otherwise. Only defined if self._is_training is True """ super(UserModel, self).__init__(*args, **kwargs) image_size = 64 output_size = 64 c_dim = 3 z_dim = 100 self.dcgan_init(image_size=image_size, output_size=output_size, c_dim=c_dim, z_dim=z_dim) @model_property def inference(self): """ op to use for inference """ # scale back to [0, 255] range images = (self.G * 127) + 128 images_flat = tf.reshape(images, [self.batch_size, self.image_size * self.image_size * self.c_dim]) # concatenate encoded z and generated image into a single flat structure zgen_flat = tf.reshape(self.DzGEN, [self.batch_size, self.z_dim]) return tf.concat([zgen_flat, images_flat], 1) @model_property def loss(self): """ Loss function Returns either an op or a list of dicts. If the returned value is an op then DIGITS will optimize against this op with respect to all trainable variables. If the returned value is a list then DIGITS will optimize against each loss in the list with respect to the specified variables. """ # here we are returning a list because we want to alternately optimize the # discriminator and the generator. losses = [ {'loss': self.dzgen_loss, 'vars': self.d_vars}, ] return losses def dcgan_init(self, image_size, output_size, z_dim, c_dim, gf_dim=64, df_dim=64, gfc_dim=1024, dfc_dim=1024): """ Args: output_size: (optional) The resolution in pixels of the images. [64] z_dim: (optional) Dimension of dim for Z. [100] gf_dim: (optional) Dimension of gen filters in first conv layer. [64] df_dim: (optional) Dimension of discrim filters in first conv layer. [64] gfc_dim: (optional) Dimension of gen units for for fully connected layer. [1024] dfc_dim: (optional) Dimension of discrim units for fully connected layer. [1024] c_dim: (optional) Dimension of image color. For grayscale input, set to 1. [3] """ self.image_size = image_size self.output_size = output_size self.z_dim = z_dim self.gf_dim = gf_dim self.df_dim = df_dim self.gfc_dim = gfc_dim self.dfc_dim = dfc_dim self.c_dim = c_dim self.batch_size = tf.shape(self.x)[0] self.soft_label_margin = 0.1 # batch normalization : deals with poor initialization helps gradient flow self.d_bn1 = batch_norm(name='d_bn1') self.d_bn2 = batch_norm(name='d_bn2') self.d_bn3 = batch_norm(name='d_bn3') self.g_bn0 = batch_norm(name='g_bn0') self.g_bn1 = batch_norm(name='g_bn1') self.g_bn2 = batch_norm(name='g_bn2') self.g_bn3 = batch_norm(name='g_bn3') self.build_model() def build_model(self): # reshape/rescale x self.images = (tf.reshape(self.x, shape=[self.batch_size, self.image_size, self.image_size, self.c_dim], name='x_reshaped') - 128) / 127. # create discriminator/encoder self.DzGEN, self.D_logits = self.discriminator(self.images, reuse=False) # create generator self.G = self.generator(self.DzGEN) # loss is now L2 distance between input image and generator output self.dzgen_loss = tf.reduce_mean(tf.square(self.G - self.images), name="loss_DzGEN") # debug self.summaries.append(image_summary("G", self.G, max_outputs=3)) self.summaries.append(image_summary("X", self.images, max_outputs=3)) self.summaries.append(histogram_summary("G_hist", self.G)) self.summaries.append(histogram_summary("X_hist", self.images)) self.summaries.append(scalar_summary("DzGen_loss", self.dzgen_loss)) # all trainable variables t_vars = tf.trainable_variables() # d variables self.d_vars = [var for var in t_vars if 'd_' in var.name] def discriminator(self, image, y=None, reuse=False): """ Create the discriminator This creates a string of layers: - input - [N, 64, 64, 3] - conv layer with 64 5x5 kernels and 2x2 stride - [N, 32, 32, 64] - leaky relu - [N, 32, 32, 64] - conv layer with 128 5x5 kernels and 2x2 stride - [N, 16, 16, 32] - batch norm - [N, 16, 16, 32] - leaky relu - [N, 16, 16, 32] - conv layer with 256 5x5 kernels and 2x2 stride - [N, 8, 8, 256] - batch norm - [N, 8, 8, 256] - leaky relu - [N, 8, 8, 256] - conv layer with 256 5x5 kernels and 2x2 stride - [N, 4, 4, 512] - batch norm - [N, 4, 4, 512] - leaky relu - [N, 4, 4, 512] - flatten - [N, 8192] - linear layer with 1 output neurons - [N, 1] - sigmoid - [N,1] Args: image: batch of input images - shape: [N, H, W, C] y: batch of one-hot encoded labels - shape: [N, K] reuse: whether to re-use previously created variables """ # NOTE: although we are really creating an encoder here we need to re-use the same # variable scope (i.e. "discriminator") as in the original GAN so we can re-use # learned parameters with tf.variable_scope("discriminator") as scope: if reuse: scope.reuse_variables() h0 = lrelu(conv2d(image, self.df_dim, name='d_h0_conv')) h1 = lrelu(self.d_bn1(conv2d(h0, self.df_dim*2, name='d_h1_conv'), train=self.is_training)) h2 = lrelu(self.d_bn2(conv2d(h1, self.df_dim*4, name='d_h2_conv'), train=self.is_training)) h3 = lrelu(self.d_bn3(conv2d(h2, self.df_dim*8, name='d_h3_conv'), train=self.is_training)) h3_size = ((self.output_size // 16) ** 2) * self.df_dim * 8 h4 = linear(tf.reshape(h3, [self.batch_size, h3_size]), self.z_dim, 'd_h3_lin_retrain') return h4, h4 def generator(self, z, y=None): """ Create the generator This creates a string of layers: - input - [N, 100] - linear layer with 8192 output neurons - [N, 8192] - reshape - [N, 4, 4, 512] - batch norm - [N, 4, 4, 512] - relu - [N, 4, 4, 512] - transpose convolution with 256 filters and stride 2 - [N, 8, 8, 256] - batch norm - [N, 8, 8, 256] - relu - [N, 8, 8, 256] - transpose convolution with 128 filters and stride 2 - [N, 16, 16, 128] - batch norm - [N, 16, 16, 128] - relu - [N, 16, 16, 128] - transpose convolution with 64 filters and stride 2 - [N, 32, 32, 64] - batch norm - [N, 32, 32, 64] - relu - [N, 32, 32, 64] - transpose convolution with 3 filters and stride 2 - [N, 64, 64, 3] - tanh - [N, 64, 64, 3] """ with tf.variable_scope("generator"): s = self.output_size s2, s4, s8, s16 = int(s/2), int(s/4), int(s/8), int(s/16) # project `z` and reshape self.z_, self.h0_w, self.h0_b = linear(z, self.gf_dim*8*s16*s16, 'g_h0_lin', with_w=True) self.h0 = tf.reshape(self.z_, [-1, s16, s16, self.gf_dim * 8]) h0 = tf.nn.relu(self.g_bn0(self.h0, train=False)) self.h1, self.h1_w, self.h1_b = deconv2d(h0, [self.batch_size, s8, s8, self.gf_dim*4], name='g_h1', with_w=True) h1 = tf.nn.relu(self.g_bn1(self.h1, train=False)) h2, self.h2_w, self.h2_b = deconv2d(h1, [self.batch_size, s4, s4, self.gf_dim*2], name='g_h2', with_w=True) h2 = tf.nn.relu(self.g_bn2(h2, train=False)) h3, self.h3_w, self.h3_b = deconv2d(h2, [self.batch_size, s2, s2, self.gf_dim*1], name='g_h3', with_w=True) h3 = tf.nn.relu(self.g_bn3(h3, train=False)) h4, self.h4_w, self.h4_b = deconv2d(h3, [self.batch_size, s, s, self.c_dim], name='g_h4', with_w=True) return tf.nn.tanh(h4)
DIGITS-master
examples/gan/network-celebA-encoder.py
#!/usr/bin/env python2 # Copyright (c) 2015-2017, NVIDIA CORPORATION. All rights reserved. """ Classify an image using a model archive file """ import argparse import os import tarfile import tempfile import time import zipfile from example import classify def unzip_archive(archive): """ Unzips an archive into a temporary directory Returns a link to that directory Arguments: archive -- the path to an archive file """ assert os.path.exists(archive), 'File not found - %s' % archive tmpdir = os.path.join(tempfile.gettempdir(), os.path.basename(archive)) assert tmpdir != archive # That wouldn't work out if os.path.exists(tmpdir): # files are already extracted pass else: if tarfile.is_tarfile(archive): print 'Extracting tarfile ...' with tarfile.open(archive) as tf: tf.extractall(path=tmpdir) elif zipfile.is_zipfile(archive): print 'Extracting zipfile ...' with zipfile.ZipFile(archive) as zf: zf.extractall(path=tmpdir) else: raise ValueError('Unknown file type for %s' % os.path.basename(archive)) return tmpdir def classify_with_archive(archive, image_files, batch_size=None, use_gpu=True): """ """ tmpdir = unzip_archive(archive) caffemodel = None deploy_file = None mean_file = None labels_file = None for filename in os.listdir(tmpdir): full_path = os.path.join(tmpdir, filename) if filename.endswith('.caffemodel'): caffemodel = full_path elif filename == 'deploy.prototxt': deploy_file = full_path elif filename.endswith('.binaryproto'): mean_file = full_path elif filename == 'labels.txt': labels_file = full_path else: print 'Unknown file:', filename assert caffemodel is not None, 'Caffe model file not found' assert deploy_file is not None, 'Deploy file not found' classify(caffemodel, deploy_file, image_files, mean_file=mean_file, labels_file=labels_file, batch_size=batch_size, use_gpu=use_gpu) if __name__ == '__main__': script_start_time = time.time() parser = argparse.ArgumentParser(description='Classification example using an archive - DIGITS') # Positional arguments parser.add_argument('archive', help='Path to a DIGITS model archive') parser.add_argument('image_file', nargs='+', help='Path[s] to an image') # Optional arguments parser.add_argument('--batch-size', type=int) parser.add_argument('--nogpu', action='store_true', help="Don't use the GPU") args = vars(parser.parse_args()) classify_with_archive(args['archive'], args['image_file'], batch_size=args['batch_size'], use_gpu=(not args['nogpu']), ) print 'Script took %f seconds.' % (time.time() - script_start_time,)
DIGITS-master
examples/classification/use_archive.py
#!/usr/bin/env python2 # Copyright (c) 2015-2017, NVIDIA CORPORATION. All rights reserved. """ Classify an image using individual model files Use this script as an example to build your own tool """ import argparse import os import time from google.protobuf import text_format import numpy as np import PIL.Image import scipy.misc os.environ['GLOG_minloglevel'] = '2' # Suppress most caffe output import caffe # noqa from caffe.proto import caffe_pb2 # noqa def get_net(caffemodel, deploy_file, use_gpu=True): """ Returns an instance of caffe.Net Arguments: caffemodel -- path to a .caffemodel file deploy_file -- path to a .prototxt file Keyword arguments: use_gpu -- if True, use the GPU for inference """ if use_gpu: caffe.set_mode_gpu() # load a new model return caffe.Net(deploy_file, caffemodel, caffe.TEST) def get_transformer(deploy_file, mean_file=None): """ Returns an instance of caffe.io.Transformer Arguments: deploy_file -- path to a .prototxt file Keyword arguments: mean_file -- path to a .binaryproto file (optional) """ network = caffe_pb2.NetParameter() with open(deploy_file) as infile: text_format.Merge(infile.read(), network) if network.input_shape: dims = network.input_shape[0].dim else: dims = network.input_dim[:4] t = caffe.io.Transformer(inputs={'data': dims}) t.set_transpose('data', (2, 0, 1)) # transpose to (channels, height, width) # color images if dims[1] == 3: # channel swap t.set_channel_swap('data', (2, 1, 0)) if mean_file: # set mean pixel with open(mean_file, 'rb') as infile: blob = caffe_pb2.BlobProto() blob.MergeFromString(infile.read()) if blob.HasField('shape'): blob_dims = blob.shape assert len(blob_dims) == 4, 'Shape should have 4 dimensions - shape is "%s"' % blob.shape elif blob.HasField('num') and blob.HasField('channels') and \ blob.HasField('height') and blob.HasField('width'): blob_dims = (blob.num, blob.channels, blob.height, blob.width) else: raise ValueError('blob does not provide shape or 4d dimensions') pixel = np.reshape(blob.data, blob_dims[1:]).mean(1).mean(1) t.set_mean('data', pixel) return t def load_image(path, height, width, mode='RGB'): """ Load an image from disk Returns an np.ndarray (channels x width x height) Arguments: path -- path to an image on disk width -- resize dimension height -- resize dimension Keyword arguments: mode -- the PIL mode that the image should be converted to (RGB for color or L for grayscale) """ image = PIL.Image.open(path) image = image.convert(mode) image = np.array(image) # squash image = scipy.misc.imresize(image, (height, width), 'bilinear') return image def forward_pass(images, net, transformer, batch_size=None): """ Returns scores for each image as an np.ndarray (nImages x nClasses) Arguments: images -- a list of np.ndarrays net -- a caffe.Net transformer -- a caffe.io.Transformer Keyword arguments: batch_size -- how many images can be processed at once (a high value may result in out-of-memory errors) """ if batch_size is None: batch_size = 1 caffe_images = [] for image in images: if image.ndim == 2: caffe_images.append(image[:, :, np.newaxis]) else: caffe_images.append(image) dims = transformer.inputs['data'][1:] scores = None for chunk in [caffe_images[x:x + batch_size] for x in xrange(0, len(caffe_images), batch_size)]: new_shape = (len(chunk),) + tuple(dims) if net.blobs['data'].data.shape != new_shape: net.blobs['data'].reshape(*new_shape) for index, image in enumerate(chunk): image_data = transformer.preprocess('data', image) net.blobs['data'].data[index] = image_data start = time.time() output = net.forward()[net.outputs[-1]] end = time.time() if scores is None: scores = np.copy(output) else: scores = np.vstack((scores, output)) print 'Processed %s/%s images in %f seconds ...' % (len(scores), len(caffe_images), (end - start)) return scores def read_labels(labels_file): """ Returns a list of strings Arguments: labels_file -- path to a .txt file """ if not labels_file: print 'WARNING: No labels file provided. Results will be difficult to interpret.' return None labels = [] with open(labels_file) as infile: for line in infile: label = line.strip() if label: labels.append(label) assert len(labels), 'No labels found' return labels def classify(caffemodel, deploy_file, image_files, mean_file=None, labels_file=None, batch_size=None, use_gpu=True): """ Classify some images against a Caffe model and print the results Arguments: caffemodel -- path to a .caffemodel deploy_file -- path to a .prototxt image_files -- list of paths to images Keyword arguments: mean_file -- path to a .binaryproto labels_file path to a .txt file use_gpu -- if True, run inference on the GPU """ # Load the model and images net = get_net(caffemodel, deploy_file, use_gpu) transformer = get_transformer(deploy_file, mean_file) _, channels, height, width = transformer.inputs['data'] if channels == 3: mode = 'RGB' elif channels == 1: mode = 'L' else: raise ValueError('Invalid number for channels: %s' % channels) images = [load_image(image_file, height, width, mode) for image_file in image_files] labels = read_labels(labels_file) # Classify the image scores = forward_pass(images, net, transformer, batch_size=batch_size) # # Process the results # indices = (-scores).argsort()[:, :5] # take top 5 results classifications = [] for image_index, index_list in enumerate(indices): result = [] for i in index_list: # 'i' is a category in labels and also an index into scores if labels is None: label = 'Class #%s' % i else: label = labels[i] result.append((label, round(100.0 * scores[image_index, i], 4))) classifications.append(result) for index, classification in enumerate(classifications): print '{:-^80}'.format(' Prediction for %s ' % image_files[index]) for label, confidence in classification: print '{:9.4%} - "{}"'.format(confidence / 100.0, label) print if __name__ == '__main__': script_start_time = time.time() parser = argparse.ArgumentParser(description='Classification example - DIGITS') # Positional arguments parser.add_argument('caffemodel', help='Path to a .caffemodel') parser.add_argument('deploy_file', help='Path to the deploy file') parser.add_argument('image_file', nargs='+', help='Path[s] to an image') # Optional arguments parser.add_argument('-m', '--mean', help='Path to a mean file (*.npy)') parser.add_argument('-l', '--labels', help='Path to a labels file') parser.add_argument('--batch-size', type=int) parser.add_argument('--nogpu', action='store_true', help="Don't use the GPU") args = vars(parser.parse_args()) classify( args['caffemodel'], args['deploy_file'], args['image_file'], args['mean'], args['labels'], args['batch_size'], not args['nogpu'], ) print 'Script took %f seconds.' % (time.time() - script_start_time,)
DIGITS-master
examples/classification/example.py
# Tensorflow Triangle binary segmentation model using TensorFlow-Slim from model import Tower from utils import model_property import tensorflow as tf import tensorflow.contrib.slim as slim import utils as digits class UserModel(Tower): @model_property def inference(self): _x = tf.reshape(self.x, shape=[-1, self.input_shape[0], self.input_shape[1], self.input_shape[2]]) with slim.arg_scope([slim.conv2d, slim.conv2d_transpose], weights_initializer=tf.contrib.layers.xavier_initializer(), weights_regularizer=slim.l2_regularizer(0.05)): # 1*H*W -> 32*H*W model = slim.conv2d(_x, 32, [3, 3], padding='SAME', scope='conv1') # 32*H*W -> 1024*H/16*W/16 model = slim.conv2d(model, 1024, [16, 16], padding='VALID', scope='conv2', stride=16) model = slim.conv2d_transpose(model, self.input_shape[2], [16, 16], stride=16, padding='VALID', activation_fn=None, scope='deconv_1') return model @model_property def loss(self): y = tf.reshape(self.y, shape=[-1, self.input_shape[0], self.input_shape[1], self.input_shape[2]]) # For a fancy tensorboard summary: put the input, label and model side by side (sbs) for a fancy image summary: # tf.summary.image(sbs.op.name, sbs, max_outputs=3, collections=["training summary"]) return digits.mse_loss(self.inference, y)
DIGITS-master
examples/binary-segmentation/binary_segmentation-TF.py
#!/usr/bin/env python2 # Copyright (c) 2016-2017, NVIDIA CORPORATION. All rights reserved. """ Functions for creating a dummy image segmentation dataset """ import argparse import numpy as np import os import PIL.Image import PIL.ImageDraw import shutil import time INPUT_FOLDER = "input" TARGET_FOLDER = "target" def create_images(folder, image_count, image_size, grid_size): """ Create image pairs for segmentation dataset """ # create folders if os.path.exists(folder): shutil.rmtree(folder) input_folder = os.path.join(folder, INPUT_FOLDER) os.makedirs(input_folder) target_folder = os.path.join(folder, TARGET_FOLDER) os.makedirs(target_folder) # create random x,y coordinates for image_count triangles coords = np.random.uniform(size=(image_count, 6)) * image_size for idx in xrange(image_count): triangle = coords[idx].tolist() # create blank images image_input = PIL.Image.new("L", (image_size, image_size), 255) image_target = PIL.Image.new("L", (image_size, image_size), 255) # draw an empty triangle draw = PIL.ImageDraw.Draw(image_input) draw.polygon( triangle, outline=0, ) # draw a full triangle draw = PIL.ImageDraw.Draw(image_target) draw.polygon( triangle, outline=0, fill=0 ) # save images input_fname = os.path.join(input_folder, "%08d.png" % idx) target_fname = os.path.join(target_folder, "%08d.png" % idx) image_input.save(input_fname) image_target.save(target_fname) # create sample image grid image_grid = PIL.Image.new("L", (grid_size * image_size, grid_size * image_size), 255) coords = np.random.uniform(size=(grid_size, grid_size, 3, 2)) * image_size draw = PIL.ImageDraw.Draw(image_grid) for x in xrange(grid_size): for y in xrange(grid_size): triangle = coords[x][y] # shift triangle += np.array([x * image_size, y * image_size]) triangle = triangle.reshape(6).tolist() # draw an empty triangle draw.polygon( triangle, outline=0, ) image_grid.save(os.path.join(folder, "grid.png")) return if __name__ == '__main__': parser = argparse.ArgumentParser(description='Create segmentation image pairs') # Positional arguments parser.add_argument('output', help='Output folder') # Optional arguments parser.add_argument( '-c', '--image_count', type=int, default=10000, help='How many images to create') parser.add_argument( '-s', '--image_size', type=int, default=32, help='How many images to create') parser.add_argument( '-g', '--grid_size', type=int, default=10, help='Size of image grid in sample image') args = vars(parser.parse_args()) start_time = time.time() create_images(args['output'], args['image_count'], args['image_size'], args['grid_size']) print 'Done after %s seconds' % (time.time() - start_time,)
DIGITS-master
examples/binary-segmentation/create_images.py
# Tensorflow MNIST autoencoder model using TensorFlow-Slim from model import Tower from utils import model_property import tensorflow as tf import tensorflow.contrib.slim as slim import utils as digits class UserModel(Tower): @model_property def inference(self): with slim.arg_scope([slim.fully_connected], weights_initializer=tf.contrib.layers.xavier_initializer(), weights_regularizer=slim.l2_regularizer(0.0005)): const = tf.constant(0.00390625) model = tf.multiply(self.x, const) model = tf.reshape(model, shape=[-1, 784]) # equivalent to `model = slim.flatten(_x)` model = slim.fully_connected(model, 300, scope='fc1') model = slim.fully_connected(model, 50, scope='fc2') model = slim.fully_connected(model, 300, scope='fc3') model = slim.fully_connected(model, 784, activation_fn=None, scope='fc4') model = tf.reshape(model, shape=[-1, self.input_shape[0], self.input_shape[1], self.input_shape[2]]) # The below image summary makes it very easy to review your result tf.summary.image(self.x.op.name, self.x, max_outputs=5, collections=['summaries']) tf.summary.image(model.op.name, model, max_outputs=5, collections=['summaries']) return model @model_property def loss(self): return digits.mse_loss(self.inference, self.x)
DIGITS-master
examples/autoencoder/autoencoder-TF.py
#!/usr/bin/env python2 # Copyright (c) 2016-2017, NVIDIA CORPORATION. All rights reserved. """ Downloads BVLC Alexnet and perform the require net surgery to convert into an FCN Alexnet """ import urllib import caffe ALEXNET_PROTOTXT_URL = "https://raw.githubusercontent.com/BVLC/caffe/rc3/models/bvlc_alexnet/deploy.prototxt" ALEXNET_PROTOTXT_FILENAME = "bvlc_alexnet.deploy.prototxt" ALEXNET_MODEL_URL = "http://dl.caffe.berkeleyvision.org/bvlc_alexnet.caffemodel" ALEXNET_MODEL_FILENAME = "bvlc_alexnet.caffemodel" FCN_ALEXNET_PROTOTXT_FILENAME = "fcn_alexnet.deploy.prototxt" FCN_ALEXNET_MODEL_FILENAME = "fcn_alexnet.caffemodel" def download(url, filename): print "Downloading %s..." % url urllib.urlretrieve(url, filename) def generate_fcn(): # download files print "Downloading files (this might take a few minutes)..." download(ALEXNET_PROTOTXT_URL, ALEXNET_PROTOTXT_FILENAME) download(ALEXNET_MODEL_URL, ALEXNET_MODEL_FILENAME) caffe.set_mode_cpu() print "Loading Alexnet model..." alexnet = caffe.Net(ALEXNET_PROTOTXT_FILENAME, ALEXNET_MODEL_FILENAME, caffe.TEST) print "Loading FCN-Alexnet prototxt..." fcn_alexnet = caffe.Net(FCN_ALEXNET_PROTOTXT_FILENAME, caffe.TEST) print "Transplanting parameters..." transplant(fcn_alexnet, alexnet) print "Saving FCN-Alexnet model to %s " % FCN_ALEXNET_MODEL_FILENAME fcn_alexnet.save(FCN_ALEXNET_MODEL_FILENAME) def transplant(new_net, net, suffix=''): # from fcn.berkeleyvision.org for p in net.params: p_new = p + suffix if p_new not in new_net.params: print 'dropping', p continue for i in range(len(net.params[p])): if i > (len(new_net.params[p_new]) - 1): print 'dropping', p, i break if net.params[p][i].data.shape != new_net.params[p_new][i].data.shape: print 'coercing', p, i, 'from', net.params[p][i].data.shape, 'to', new_net.params[p_new][i].data.shape else: print 'copying', p, ' -> ', p_new, i new_net.params[p_new][i].data.flat = net.params[p][i].data.flat if __name__ == '__main__': generate_fcn()
DIGITS-master
examples/semantic-segmentation/net_surgery.py
#!/usr/bin/env python2 # Copyright (c) 2016-2017, NVIDIA CORPORATION. All rights reserved. """ Functions for creating a text classification dataset out of .csv files The expected CSV structure is: <Class>,<Text Field 1>, ..., <Text Field N> """ import argparse import caffe import csv import lmdb import numpy as np import os import PIL.Image import shutil import time DB_BATCH_SIZE = 1024 ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789-,;.!?:'\"/\\|_@#$%^&*~`+ =<>()[]{}" FEATURE_LEN = 1024 # must have integer square root def _save_image(image, filename): # convert from (channels, heights, width) to (height, width) image = image[0] image = PIL.Image.fromarray(image) image.save(filename) def create_dataset(folder, input_file_name, db_batch_size=None, create_images=False, labels_file=None): """ Creates LMDB database and images (if create_images==True) """ if db_batch_size is None: db_batch_size = DB_BATCH_SIZE # open output LMDB output_db = lmdb.open(folder, map_async=True, max_dbs=0) print "Reading input file %s..." % input_file_name # create character dict cdict = {} for i, c in enumerate(ALPHABET): cdict[c] = i + 2 # indices start at 1, skip first index for 'other' characters samples = {} with open(input_file_name) as f: reader = csv.DictReader(f, fieldnames=['class'], restkey='fields') for row in reader: label = row['class'] if label not in samples: samples[label] = [] sample = np.ones(FEATURE_LEN) # one by default (i.e. 'other' character) count = 0 for field in row['fields']: for char in field.lower(): if char in cdict: sample[count] = cdict[char] count += 1 if count >= FEATURE_LEN - 1: break samples[label].append(sample) samples_per_class = None classes = samples.keys() class_samples = [] for c in classes: if samples_per_class is None: samples_per_class = len(samples[c]) else: assert samples_per_class == len(samples[c]) class_samples.append(samples[c]) indices = np.arange(samples_per_class) np.random.shuffle(indices) labels = None if labels_file is not None: labels = map(str.strip, open(labels_file, "r").readlines()) assert len(classes) == len(samples) else: labels = classes print "Class labels: %s" % repr(labels) if create_images: for label in labels: os.makedirs(os.path.join(args['output'], label)) print "Storing data into %s..." % folder batch = [] for idx in indices: for c, cname in enumerate(classes): class_id = c + 1 # indices start at 1 sample = class_samples[c][idx].astype('uint8') sample = sample[np.newaxis, np.newaxis, ...] sample = sample.reshape((1, np.sqrt(FEATURE_LEN), np.sqrt(FEATURE_LEN))) if create_images: filename = os.path.join(args['output'], labels[c], '%d.png' % idx) _save_image(sample, filename) datum = caffe.io.array_to_datum(sample, class_id) batch.append(('%d_%d' % (idx, class_id), datum)) if len(batch) >= db_batch_size: _write_batch_to_lmdb(output_db, batch) batch = [] # close database output_db.close() return def _write_batch_to_lmdb(db, batch): """ Write a batch of (key,value) to db """ try: with db.begin(write=True) as lmdb_txn: for key, datum in batch: lmdb_txn.put(key, datum.SerializeToString()) except lmdb.MapFullError: # double the map_size curr_limit = db.info()['map_size'] new_limit = curr_limit * 2 try: db.set_mapsize(new_limit) # double it except AttributeError as e: version = tuple(int(x) for x in lmdb.__version__.split('.')) if version < (0, 87): raise ImportError('py-lmdb is out of date (%s vs 0.87)' % lmdb.__version__) else: raise e # try again _write_batch_to_lmdb(db, batch) if __name__ == '__main__': parser = argparse.ArgumentParser(description='Create Dataset tool') # Positional arguments parser.add_argument('input', help='Input .csv file') parser.add_argument('output', help='Output Folder') parser.add_argument('--create-images', action='store_true') parser.add_argument('--labels', default=None) args = vars(parser.parse_args()) if os.path.exists(args['output']): shutil.rmtree(args['output']) os.makedirs(args['output']) start_time = time.time() create_dataset( args['output'], args['input'], create_images=args['create_images'], labels_file=args['labels'], ) print 'Done after %s seconds' % (time.time() - start_time,)
DIGITS-master
examples/text-classification/create_dataset.py
from model import Tower from utils import model_property import tensorflow as tf import tensorflow.contrib.slim as slim import utils as digits class UserModel(Tower): @model_property def inference(self): _x = tf.reshape(self.x, shape=[-1, self.input_shape[0], self.input_shape[1], self.input_shape[2]]) # tf.image_summary(_x.op.name, _x, max_images=10, collections=[digits.GraphKeys.SUMMARIES_TRAIN]) # Split out the color channels _, model_g, model_b = tf.split(_x, 3, 3, name='split_channels') # tf.image_summary(model_g.op.name, model_g, max_images=10, collections=[digits.GraphKeys.SUMMARIES_TRAIN]) # tf.image_summary(model_b.op.name, model_b, max_images=10, collections=[digits.GraphKeys.SUMMARIES_TRAIN]) with slim.arg_scope([slim.conv2d, slim.fully_connected], weights_initializer=tf.contrib.layers.xavier_initializer(), weights_regularizer=slim.l2_regularizer(0.0005)): with tf.variable_scope("siamese") as scope: def make_tower(net): net = slim.conv2d(net, 20, [5, 5], padding='VALID', scope='conv1') net = slim.max_pool2d(net, [2, 2], padding='VALID', scope='pool1') net = slim.conv2d(net, 50, [5, 5], padding='VALID', scope='conv2') net = slim.max_pool2d(net, [2, 2], padding='VALID', scope='pool2') net = slim.flatten(net) net = slim.fully_connected(net, 500, scope='fc1') net = slim.fully_connected(net, 2, activation_fn=None, scope='fc2') return net model_g = make_tower(model_g) model_g = tf.reshape(model_g, shape=[-1, 2]) scope.reuse_variables() model_b = make_tower(model_b) model_b = tf.reshape(model_b, shape=[-1, 2]) return [model_g, model_b] @model_property def loss(self): _y = tf.reshape(self.y, shape=[-1]) _y = tf.to_float(_y) model = self.inference return digits.constrastive_loss(model[0], model[1], _y)
DIGITS-master
examples/siamese/siamese-TF.py
#!/usr/bin/env python2 # Copyright (c) 2015-2017, NVIDIA CORPORATION. All rights reserved. """ Functions for creating temporary LMDBs Used in test_views """ import argparse import os import random import re import sys import time import lmdb import numpy as np import PIL.Image if __name__ == '__main__': dirname = os.path.dirname(os.path.realpath(__file__)) sys.path.insert(0, os.path.join(dirname, '..', '..')) import digits.config # noqa from digits import utils # noqa # Import digits.config first to set the path to Caffe import caffe.io # noqa import caffe_pb2 # noqa IMAGE_SIZE = 10 TRAIN_IMAGE_COUNT = 1000 VAL_IMAGE_COUNT = 1000 TEST_IMAGE_COUNT = 10 DB_BATCH_SIZE = 100 def create_lmdbs(folder, file_list, image_count=None, db_batch_size=None): """ Creates LMDBs for generic inference Returns the filename for a test image Creates these files in "folder": train_images/ train_labels/ val_images/ val_labels/ mean.binaryproto test.png """ if image_count is None: train_image_count = TRAIN_IMAGE_COUNT else: train_image_count = image_count val_image_count = VAL_IMAGE_COUNT if db_batch_size is None: db_batch_size = DB_BATCH_SIZE # read file list images = [] f = open(file_list) for line in f.readlines(): line = line.strip() if not line: continue path = None # might contain a numerical label at the end match = re.match(r'(.*\S)\s+(\d+)$', line) if match: path = match.group(1) ground_truth = int(match.group(2)) images.append([path, ground_truth]) print "Found %d image paths in image list" % len(images) for phase, image_count in [ ('train', train_image_count), ('val', val_image_count)]: print "Will create %d pairs of %s images" % (image_count, phase) # create DBs image_db = lmdb.open(os.path.join(folder, '%s_images' % phase), map_async=True, max_dbs=0) label_db = lmdb.open(os.path.join(folder, '%s_labels' % phase), map_async=True, max_dbs=0) # add up all images to later create mean image image_sum = None shape = None # save test images (one for each label) testImagesSameClass = [] testImagesDifferentClass = [] # arrays for image and label batch writing image_batch = [] label_batch = [] for i in xrange(image_count): # pick up random indices from image list index1 = random.randint(0, len(images) - 1) index2 = random.randint(0, len(images) - 1) # label=1 if images are from the same class otherwise label=0 label = 1 if int(images[index1][1]) == int(images[index2][1]) else 0 # load images from files image1 = np.array(utils.image.load_image(images[index1][0])) image2 = np.array(utils.image.load_image(images[index2][0])) if not shape: # initialize image sum for mean image shape = image1.shape image_sum = np.zeros((3, shape[0], shape[1]), 'float64') assert(image1.shape == shape and image2.shape == shape) # create BGR image: blue channel will contain first image, # green channel will contain second image image_pair = np.zeros(image_sum.shape) image_pair[0] = image1 image_pair[1] = image2 image_sum += image_pair # save test images on first pass if label > 0 and len(testImagesSameClass) < TEST_IMAGE_COUNT: testImagesSameClass.append(image_pair) if label == 0 and len(testImagesDifferentClass) < TEST_IMAGE_COUNT: testImagesDifferentClass.append(image_pair) # encode into Datum object image = image_pair.astype('uint8') datum = caffe.io.array_to_datum(image, -1) image_batch.append([str(i), datum]) # create label Datum label_datum = caffe_pb2.Datum() label_datum.channels, label_datum.height, label_datum.width = 1, 1, 1 label_datum.float_data.extend(np.array([label]).flat) label_batch.append([str(i), label_datum]) if (i % db_batch_size == (db_batch_size - 1)) or (i == image_count - 1): _write_batch_to_lmdb(image_db, image_batch) _write_batch_to_lmdb(label_db, label_batch) image_batch = [] label_batch = [] if i % (image_count / 20) == 0: print "%d/%d" % (i, image_count) # close databases image_db.close() label_db.close() # save mean mean_image = (image_sum / image_count).astype('uint8') _save_mean(mean_image, os.path.join(folder, '%s_mean.binaryproto' % phase)) _save_mean(mean_image, os.path.join(folder, '%s_mean.png' % phase)) # create test images for idx, image in enumerate(testImagesSameClass): _save_image(image, os.path.join(folder, '%s_test_same_class_%d.png' % (phase, idx))) for idx, image in enumerate(testImagesDifferentClass): _save_image(image, os.path.join(folder, '%s_test_different_class_%d.png' % (phase, idx))) return def _write_batch_to_lmdb(db, batch): """ Write a batch of (key,value) to db """ try: with db.begin(write=True) as lmdb_txn: for key, datum in batch: lmdb_txn.put(key, datum.SerializeToString()) except lmdb.MapFullError: # double the map_size curr_limit = db.info()['map_size'] new_limit = curr_limit * 2 try: db.set_mapsize(new_limit) # double it except AttributeError as e: version = tuple(int(x) for x in lmdb.__version__.split('.')) if version < (0, 87): raise ImportError('py-lmdb is out of date (%s vs 0.87)' % lmdb.__version__) else: raise e # try again _write_batch_to_lmdb(db, batch) def _save_image(image, filename): # converting from BGR to RGB image = image[[2, 1, 0], ...] # channel swap # convert to (height, width, channels) image = image.astype('uint8').transpose((1, 2, 0)) image = PIL.Image.fromarray(image) image.save(filename) def _save_mean(mean, filename): """ Saves mean to file Arguments: mean -- the mean as an np.ndarray filename -- the location to save the image """ if filename.endswith('.binaryproto'): blob = caffe_pb2.BlobProto() blob.num = 1 blob.channels = mean.shape[0] blob.height = mean.shape[1] blob.width = mean.shape[2] blob.data.extend(mean.astype(float).flat) with open(filename, 'wb') as outfile: outfile.write(blob.SerializeToString()) elif filename.endswith(('.jpg', '.jpeg', '.png')): _save_image(mean, filename) else: raise ValueError('unrecognized file extension') if __name__ == '__main__': parser = argparse.ArgumentParser(description='Create-LMDB tool - DIGITS') # Positional arguments parser.add_argument('folder', help='Where to save the images') parser.add_argument('file_list', help='File list') # Optional arguments parser.add_argument('-c', '--image_count', type=int, help='How many images') args = vars(parser.parse_args()) if os.path.exists(args['folder']): print 'ERROR: Folder already exists' sys.exit(1) else: os.makedirs(args['folder']) print 'Creating images at "%s" ...' % args['folder'] start_time = time.time() create_lmdbs( args['folder'], args['file_list'], image_count=args['image_count'], ) print 'Done after %s seconds' % (time.time() - start_time,)
DIGITS-master
examples/siamese/create_db.py
from model import Tower from utils import model_property import tensorflow as tf import tensorflow.contrib.slim as slim import utils as digits class UserModel(Tower): @model_property def inference(self): x = tf.reshape(self.x, shape=[-1, self.input_shape[0], self.input_shape[1], self.input_shape[2]]) # scale (divide by MNIST std) x = x * 0.0125 with slim.arg_scope([slim.conv2d, slim.fully_connected], weights_initializer=tf.contrib.layers.xavier_initializer(), weights_regularizer=slim.l2_regularizer(0.0005)): model = slim.conv2d(x, 20, [5, 5], padding='VALID', scope='conv1') model = slim.max_pool2d(model, [2, 2], padding='VALID', scope='pool1') model = slim.conv2d(model, 50, [5, 5], padding='VALID', scope='conv2') model = slim.max_pool2d(model, [2, 2], padding='VALID', scope='pool2') model = slim.flatten(model) model = slim.fully_connected(model, 500, scope='fc1') model = slim.dropout(model, 0.5, is_training=self.is_training, scope='do1') model = slim.fully_connected(model, 10, activation_fn=None, scope='fc2_not_in_use') model = slim.fully_connected(model, self.nclasses, activation_fn=None, scope='fc2_true') return model @model_property def loss(self): model = self.inference loss = digits.classification_loss(model, self.y) accuracy = digits.classification_accuracy(model, self.y) self.summaries.append(tf.summary.scalar(accuracy.op.name, accuracy)) return loss
DIGITS-master
examples/fine-tuning/lenet-fine-tune-tf.py
#!/usr/bin/env python2 # Copyright (c) 2016-2017, NVIDIA CORPORATION. All rights reserved. """ Prepares KITTI data for ingestion by DIGITS """ import argparse import os import re import shutil import zipfile def extract_data(input_dir, output_dir): """ Extract zipfiles at input_dir into output_dir """ if os.path.isdir(output_dir): print ' Using extracted data at %s.' % output_dir return for filename in ( 'data_object_label_2.zip', 'data_object_image_2.zip', 'devkit_object.zip'): filename = os.path.join(input_dir, filename) zf = zipfile.ZipFile(filename, 'r') print 'Unzipping %s ...' % filename zf.extractall(output_dir) def get_image_to_video_mapping(devkit_dir): """ Return a mapping from image filename (e.g. 7282 which is training/image_2/007282.png) to video and frame (e.g. {'video': '2011_09_26_0005', 'frame': 109}) """ image_to_video = {} mapping_lines = None with open(os.path.join(devkit_dir, 'mapping', 'train_mapping.txt'), 'r') as infile: mapping_lines = infile.readlines() with open(os.path.join(devkit_dir, 'mapping', 'train_rand.txt'), 'r') as infile: for image_index, mapping_index in enumerate(infile.read().split(',')): mapping_index = mapping_index.strip() if not mapping_index: continue mapping_index = int(mapping_index) - 1 map_line = mapping_lines[mapping_index] match = re.match('^\s*[\d_]+\s+(\d{4}_\d{2}_\d{2})_drive_(\d{4})_sync\s+(\d+)$\s*$', map_line) if not match: raise ValueError('Unrecognized mapping line "%s"' % map_line) date = match.group(1) video_id = match.group(2) video_name = '%s_%s' % (date, video_id) frame_index = int(match.group(3)) if image_index in image_to_video: raise ValueError('Conflicting mappings for image %s' % image_index) image_to_video[image_index] = { 'video': video_name, 'frame': frame_index, } return image_to_video def split_by_video(training_dir, mapping, split_dir, use_symlinks=True): """ Create one directory per video in split_dir """ new_images_dir = os.path.join(split_dir, 'images') new_labels_dir = os.path.join(split_dir, 'labels') if os.path.isdir(new_images_dir): shutil.rmtree(new_images_dir) if os.path.isdir(new_labels_dir): shutil.rmtree(new_labels_dir) for old_image_fname in os.listdir(os.path.join(training_dir, 'image_2')): old_image_path = os.path.abspath(os.path.join(training_dir, 'image_2', old_image_fname)) image_index_str, image_ext = os.path.splitext( os.path.basename(old_image_fname)) image_index_int = int(image_index_str) video_name = mapping[image_index_int]['video'] frame_id = '%09d' % mapping[image_index_int]['frame'] # Copy image new_image_dir = os.path.join(new_images_dir, video_name) if not os.path.isdir(new_image_dir): os.makedirs(new_image_dir) new_image_fname = '%s_%s%s' % (frame_id, image_index_str, image_ext) new_image_path = os.path.join(new_image_dir, new_image_fname) if use_symlinks: os.symlink(old_image_path, new_image_path) else: shutil.copyfile(old_image_path, new_image_path) # Copy label old_label_fname = '%s.txt' % image_index_str old_label_path = os.path.abspath(os.path.join(training_dir, 'label_2', old_label_fname)) new_label_fname = '%s_%s.txt' % (frame_id, image_index_str) new_label_dir = os.path.join(new_labels_dir, video_name) if not os.path.isdir(new_label_dir): os.makedirs(new_label_dir) new_label_path = os.path.join(new_label_dir, new_label_fname) if use_symlinks: os.symlink(old_label_path, new_label_path) else: shutil.copyfile(old_label_path, new_label_path) def split_for_training(split_dir, train_dir, val_dir, use_symlinks=True): """ Create directories of images for training and validation """ if os.path.isdir(train_dir): shutil.rmtree(train_dir) if os.path.isdir(val_dir): shutil.rmtree(val_dir) for images_dirname in os.listdir(os.path.join(split_dir, 'images')): match = re.match('^(\d{4})_(\d{2})_(\d{2})_(\d+)$', images_dirname) if not match: raise ValueError('Unrecognized format of directory named "%s"' % images_dirname) # year = int(match.group(1)) month = int(match.group(2)) date = int(match.group(3)) video_id = int(match.group(4)) # Filter out some videos for the validation set # XXX this is pretty arbitrary if month == 9 and date == 26 and video_id <= 18: output_dir = val_dir else: output_dir = train_dir # Copy images old_images_dir = os.path.join(split_dir, 'images', images_dirname) new_images_dir = os.path.join(output_dir, 'images') if not os.path.isdir(new_images_dir): os.makedirs(new_images_dir) for fname in os.listdir(old_images_dir): old_image_path = os.path.realpath(os.path.join(old_images_dir, fname)) new_image_path = os.path.join(new_images_dir, os.path.basename(old_image_path)) if use_symlinks: os.symlink(old_image_path, new_image_path) else: shutil.move(old_image_path, new_image_path) # Copy labels old_labels_dir = os.path.join(split_dir, 'labels', images_dirname) new_labels_dir = os.path.join(output_dir, 'labels') if not os.path.isdir(new_labels_dir): os.makedirs(new_labels_dir) for fname in os.listdir(old_labels_dir): old_label_path = os.path.realpath(os.path.join(old_labels_dir, fname)) new_label_path = os.path.join(new_labels_dir, os.path.basename(old_label_path)) if use_symlinks: os.symlink(old_label_path, new_label_path) else: shutil.move(old_label_path, new_label_path) if __name__ == '__main__': parser = argparse.ArgumentParser(description='Prepare KITTI data') parser.add_argument('-i', '--input-dir', default='', help='The directory containing the original KITTI zipfiles [default "./"]') parser.add_argument('-o', '--output-dir', default='kitti-data', help='The output directory [default "./kitti-data"]') parser.add_argument('-s', '--no-symlinks', action='store_true', help='Copy files instead of making symlinks') args = parser.parse_args() print 'Extracting zipfiles ...' extract_data( args.input_dir, os.path.join(args.output_dir, 'raw'), ) print 'Calculating image to video mapping ...' mapping = get_image_to_video_mapping( os.path.join(args.output_dir, 'raw'), ) print 'Splitting images by video ...' split_by_video( os.path.join(args.output_dir, 'raw', 'training'), mapping, os.path.join(args.output_dir, 'video-split'), use_symlinks=(not args.no_symlinks), ) print 'Creating train/val split ...' split_for_training( os.path.join(args.output_dir, 'video-split'), os.path.join(args.output_dir, 'train'), os.path.join(args.output_dir, 'val'), use_symlinks=(not args.no_symlinks), ) print 'Done.'
DIGITS-master
examples/object-detection/prepare_kitti_data.py
from model import Tower from utils import model_property import tensorflow as tf import utils as digits class UserModel(Tower): @model_property def inference(self): const = tf.constant(0.004) normed = tf.multiply(self.x, const) # The reshaping have to be done for tensorflow to get the shape right right_shape = tf.reshape(normed, shape=[-1, 50, 50]) transposed = tf.transpose(right_shape, [0, 2, 1]) squeezed = tf.reshape(transposed, shape=[-1, 2500]) # Define weights weights = { 'w1': tf.get_variable('w1', [2500, 2]) } biases = { 'b1': tf.get_variable('b1', [2]) } # Linear activation model = tf.matmul(squeezed, weights['w1']) + biases['b1'] tf.summary.image(model.op.name, model, max_outputs=1, collections=["Training Summary"]) return model @model_property def loss(self): label = tf.reshape(self.y, shape=[-1, 2]) model = self.inference loss = digits.mse_loss(model, label) return loss
DIGITS-master
examples/regression/regression-TF.py
#!/usr/bin/env python3 # # @ build_bios.py # Builds BIOS using configuration files and dynamically # imported functions from board directory # # Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR> # Copyright (c) 2021, American Megatrends International LLC.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # """ This module builds BIOS using configuration files and dynamically imported functions from board directory """ import os import re import sys import glob import signal import shutil import argparse import traceback import subprocess from importlib import import_module try: # python 2.7 import ConfigParser as configparser except ImportError: # python 3 import configparser def pre_build(build_config, build_type="DEBUG", silent=False, toolchain=None): """Sets the environment variables that shall be used for the build :param build_config: The build configuration as defined in the JSON configuration files :type build_config: Dictionary :param build_type: The build target, DEBUG, RELEASE, RELEASE_PDB, TEST_RELEASE :type build_type: String :param silent: Enables build in silent mode :type silent: Boolean :param toolchain: Specifies the tool chain tag to use for the build :type toolchain: String :returns: The updated environment variables :rtype: Dictionary """ # get current environment variables config = os.environ.copy() # patch the build config build_config = patch_config(build_config) # update the current config with the build config config.update(build_config) # make the config and build python 2.7 compatible config = py_27_fix(config) # Set WORKSPACE environment. config["WORKSPACE"] = os.path.abspath(os.path.join("..", "..", "..", "")) print("Set WORKSPACE as: {}".format(config["WORKSPACE"])) # Check whether Git has been installed and been added to system path. try: subprocess.Popen(["git", "--help"], stdout=subprocess.PIPE) except OSError: print("The 'git' command is not recognized.") print("Please make sure that Git is installed\ and has been added to system path.") sys.exit(1) # Create the Conf directory under WORKSPACE if not os.path.isdir(os.path.join(config["WORKSPACE"], "Conf")): try: # create directory os.makedirs(os.path.join(config["WORKSPACE"], "Conf")) # copy files to it config_template_path = os.path.join(config["WORKSPACE"], config["BASE_TOOLS_PATH"], "Conf") config_path = os.path.join(config["WORKSPACE"], "Conf") shutil.copyfile(config_template_path + os.sep + "target.template", config_path + os.sep + "target.txt") shutil.copyfile(config_template_path + os.sep + "tools_def.template", config_path + os.sep + "tools_def.txt") shutil.copyfile(config_template_path + os.sep + "build_rule.template", config_path + os.sep + "build_rule.txt") except OSError: print("Error while creating Conf") sys.exit(1) # Set other environments. # Basic Rule: # Platform override Silicon override Core # Source override Binary config["WORKSPACE_PLATFORM"] = os.path.join(config["WORKSPACE"], config["WORKSPACE_PLATFORM"]) config["WORKSPACE_SILICON"] = os.path.join(config["WORKSPACE"], config["WORKSPACE_SILICON"]) config["WORKSPACE_FEATURES"] = os.path.join(config["WORKSPACE"], config["WORKSPACE_FEATURES"]) config["WORKSPACE_DRIVERS"] = os.path.join(config["WORKSPACE"], config["WORKSPACE_DRIVERS"]) config["WORKSPACE_PLATFORM_BIN"] = \ os.path.join(config["WORKSPACE"], config["WORKSPACE_PLATFORM_BIN"]) config["WORKSPACE_SILICON_BIN"] = \ os.path.join(config["WORKSPACE"], config["WORKSPACE_SILICON_BIN"]) config["WORKSPACE_FSP_BIN"] = os.path.join(config["WORKSPACE"], config["WORKSPACE_FSP_BIN"]) # add to package path config["PACKAGES_PATH"] = config["WORKSPACE_PLATFORM"] config["PACKAGES_PATH"] += os.pathsep + config["WORKSPACE_SILICON"] config["PACKAGES_PATH"] += os.pathsep + config["WORKSPACE_SILICON_BIN"] config["PACKAGES_PATH"] += os.pathsep + config["WORKSPACE_FEATURES"] # add all feature domains in WORKSPACE_FEATURES to package path for filename in os.listdir(config["WORKSPACE_FEATURES"]): filepath = os.path.join(config["WORKSPACE_FEATURES"], filename) # feature domains folder does not contain dec file if os.path.isdir(filepath) and \ not glob.glob(os.path.join(filepath, "*.dec")): config["PACKAGES_PATH"] += os.pathsep + filepath config["PACKAGES_PATH"] += os.pathsep + config["WORKSPACE_DRIVERS"] config["PACKAGES_PATH"] += os.pathsep + \ os.path.join(config["WORKSPACE"], config["WORKSPACE_FSP_BIN"]) config["PACKAGES_PATH"] += os.pathsep + \ os.path.join(config["WORKSPACE"], config["WORKSPACE_CORE"]) config["PACKAGES_PATH"] += os.pathsep + os.path.join(config["WORKSPACE"]) config["PACKAGES_PATH"] += os.pathsep + config["WORKSPACE_PLATFORM_BIN"] config["EDK_TOOLS_PATH"] = os.path.join(config["WORKSPACE"], config["EDK_TOOLS_PATH"]) config["BASE_TOOLS_PATH"] = config["EDK_TOOLS_PATH"] config["EDK_TOOLS_BIN"] = os.path.join(config["WORKSPACE"], config["EDK_TOOLS_BIN"]) # # Board may have different FSP binary between API and Dispatch modes. # In API mode if FSP_BIN_PKG_FOR_API_MODE is assigned, it should # override FSP_BIN_PKG. # if config.get("API_MODE_FSP_WRAPPER_BUILD", "FALSE") == "TRUE": if config.get("FSP_BIN_PKG_FOR_API_MODE") is not None: config['FSP_BIN_PKG'] = config['FSP_BIN_PKG_FOR_API_MODE'] config["PLATFORM_FSP_BIN_PACKAGE"] = \ os.path.join(config['WORKSPACE_FSP_BIN'], config['FSP_BIN_PKG']) config['PROJECT_DSC'] = os.path.join(config["WORKSPACE_PLATFORM"], config['PROJECT_DSC']) config['BOARD_PKG_PCD_DSC'] = os.path.join(config["WORKSPACE_PLATFORM"], config['BOARD_PKG_PCD_DSC']) config["CONF_PATH"] = os.path.join(config["WORKSPACE"], "Conf") # get the python path if os.environ.get("PYTHON_HOME") is None: if os.environ.get("PYTHONPATH") is not None: config["PYTHON_HOME"] = os.environ.get("PYTHONPATH") else: config["PYTHON_HOME"] = os.path.dirname(sys.executable) config["PYTHONPATH"] = config["PYTHON_HOME"] if config.get("PYTHON_HOME") is None or \ not os.path.exists(config.get("PYTHON_HOME")): print("PYTHON_HOME environment variable is not found") sys.exit(1) # if python is installed, disable the binary base tools. # python is installed if this code is running :) if config.get("PYTHON_HOME") is not None: if config.get("EDK_TOOLS_BIN") is not None: del config["EDK_TOOLS_BIN"] # Run edk setup and update config if os.name == 'nt': edk2_setup_cmd = [os.path.join(config["EFI_SOURCE"], "edksetup"), "Rebuild"] if config.get("EDK_SETUP_OPTION") and \ config["EDK_SETUP_OPTION"] != " ": edk2_setup_cmd.append(config["EDK_SETUP_OPTION"]) _, _, result, return_code = execute_script(edk2_setup_cmd, config, collect_env=True, shell=True) if return_code == 0 and result is not None and isinstance(result, dict): config.update(result) # nmake BaseTools source # and enable BaseTools source build shell = True command = ["nmake", "-f", os.path.join(config["BASE_TOOLS_PATH"], "Makefile")] if os.name == "posix": # linux shell = False command = ["make", "-C", os.path.join(config["BASE_TOOLS_PATH"])] _, _, result, return_code = execute_script(command, config, shell=shell) if return_code != 0: build_failed(config) # # build platform silicon tools # # save the current workspace saved_work_directory = config["WORKSPACE"] # change the workspace to silicon tools directory config["WORKSPACE"] = os.path.join(config["WORKSPACE_SILICON"], "Tools") command = ["nmake"] if os.name == "posix": # linux command = ["make"] # add path to generated FitGen binary to # environment path variable config["PATH"] += os.pathsep + \ os.path.join(config["BASE_TOOLS_PATH"], "Source", "C", "bin") # build the silicon tools _, _, result, return_code = execute_script(command, config, shell=shell) if return_code != 0: build_failed(config) # restore WORKSPACE environment variable config["WORKSPACE"] = saved_work_directory config["SILENT_MODE"] = 'TRUE' if silent else 'FALSE' print("==============================================") if os.path.isfile(os.path.join(config['WORKSPACE'], "Prep.log")): os.remove(os.path.join(config['WORKSPACE'], "Prep.log")) config["PROJECT"] = os.path.join(config["PLATFORM_BOARD_PACKAGE"], config["BOARD"]) # Setup Build # @todo: Need better TOOL_CHAIN_TAG detection if toolchain is not None: config["TOOL_CHAIN_TAG"] = toolchain elif config.get("TOOL_CHAIN_TAG") is None: if os.name == 'nt': config["TOOL_CHAIN_TAG"] = "VS2015" else: config["TOOL_CHAIN_TAG"] = "GCC5" # echo Show CL revision config["PrepRELEASE"] = build_type if build_type == "DEBUG": config["TARGET"] = 'DEBUG' config["TARGET_SHORT"] = 'D' else: config["TARGET"] = 'RELEASE' config["TARGET_SHORT"] = 'R' # set BUILD_DIR_PATH path config["BUILD_DIR_PATH"] = os.path.join(config["WORKSPACE"], 'Build', config["PROJECT"], "{}_{}".format( config["TARGET"], config["TOOL_CHAIN_TAG"])) # set BUILD_DIR path config["BUILD_DIR"] = os.path.join('Build', config["PROJECT"], "{}_{}".format( config["TARGET"], config["TOOL_CHAIN_TAG"])) config["BUILD_X64"] = os.path.join(config["BUILD_DIR_PATH"], 'X64') config["BUILD_IA32"] = os.path.join(config["BUILD_DIR_PATH"], 'IA32') if not os.path.isdir(config["BUILD_DIR_PATH"]): try: os.makedirs(config["BUILD_DIR_PATH"]) except OSError: print("Error while creating Build folder") sys.exit(1) # Set FSP_WRAPPER_BUILD if config['FSP_WRAPPER_BUILD'] == "TRUE": # Create dummy Fsp_Rebased_S_padded.fd to build the BiosInfo.inf # if it is wrapper build, due to the SECTION inclusion open(os.path.join(config["WORKSPACE_FSP_BIN"], config["FSP_BIN_PKG"], "Fsp_Rebased_S_padded.fd"), 'w').close() if not os.path.isdir(config["BUILD_X64"]): try: os.mkdir(config["BUILD_X64"]) except OSError: print("Error while creating {}".format(config["BUILD_X64"])) sys.exit(1) # update config file with changes update_target_file(config) # Additional pre build scripts for this platform result = pre_build_ex(config) if result is not None and isinstance(result, dict): config.update(result) # print user settings print("BIOS_SIZE_OPTION = {}".format(config["BIOS_SIZE_OPTION"])) print("EFI_SOURCE = {}".format(config["EFI_SOURCE"])) print("TARGET = {}".format(config["TARGET"])) print("TARGET_ARCH = {}".format("IA32 X64")) print("TOOL_CHAIN_TAG = {}".format(config["TOOL_CHAIN_TAG"])) print("WORKSPACE = {}".format(config["WORKSPACE"])) print("WORKSPACE_CORE = {}".format(config["WORKSPACE_CORE"])) print("EXT_BUILD_FLAGS = {}".format(config["EXT_BUILD_FLAGS"])) return config def build(config): """Builds the BIOS image :param config: The environment variables to be used in the build process :type config: Dictionary :returns: nothing """ if config["FSP_WRAPPER_BUILD"] == "TRUE": pattern = "Fsp_Rebased.*\\.fd$" file_dir = os.path.join(config['WORKSPACE_FSP_BIN'], config['FSP_BIN_PKG']) for item in os.listdir(file_dir): if re.search(pattern, item): os.remove(os.path.join(file_dir, item)) command = [os.path.join(config['PYTHON_HOME'], "python"), os.path.join(config['WORKSPACE_PLATFORM'], config['PLATFORM_PACKAGE'], 'Tools', 'Fsp', 'RebaseFspBinBaseAddress.py'), os.path.join(config['WORKSPACE_PLATFORM'], config['FLASH_MAP_FDF']), os.path.join(config['WORKSPACE_FSP_BIN'], config['FSP_BIN_PKG']), "Fsp.fd", "0x0"] _, _, _, return_code = execute_script(command, config, shell=False) if return_code != 0: print("ERROR:RebaseFspBinBaseAddress failed") sys.exit(return_code) # create Fsp_Rebased.fd which is Fsp_Rebased_S.fd + # Fsp_Rebased_M + Fsp_Rebased_T with open(os.path.join(file_dir, "Fsp_Rebased_S.fd"), 'rb') as fsp_s, \ open(os.path.join(file_dir, "Fsp_Rebased_M.fd"), 'rb') as fsp_m, \ open(os.path.join(file_dir, "Fsp_Rebased_T.fd"), 'rb') as fsp_t: fsp_rebased = fsp_s.read() + fsp_m.read() + fsp_t.read() with open(os.path.join(file_dir, "Fsp_Rebased.fd"), 'wb') as new_fsp: new_fsp.write(fsp_rebased) if not os.path.isfile(os.path.join(file_dir, "Fsp_Rebased.fd")): print("!!! ERROR:failed to create fsp!!!") sys.exit(1) # Output the build variables the user has selected. print("==========================================") print(" User Selected build options:") print(" SILENT_MODE = ", config.get("SILENT_MODE")) print(" REBUILD_MODE = ", config.get("REBUILD_MODE")) print(" BUILD_ROM_ONLY = ", config.get("BUILD_ROM_ONLY")) print(" BINARY_CACHE_CMD_LINE = ", config.get("HASH"), config.get("BINARY_CACHE_CMD_LINE")) print("==========================================") command = ["build", "-n", config["NUMBER_OF_PROCESSORS"]] if config["REBUILD_MODE"] and config["REBUILD_MODE"] != "": command.append(config["REBUILD_MODE"]) if config["EXT_BUILD_FLAGS"] and config["EXT_BUILD_FLAGS"] != "": ext_build_flags = config["EXT_BUILD_FLAGS"].split(" ") ext_build_flags = [x.strip() for x in ext_build_flags] ext_build_flags = [x for x in ext_build_flags if x != ""] command.extend(ext_build_flags) if config.get('BINARY_CACHE_CMD_LINE'): command.append(config['HASH']) command.append(config['BINARY_CACHE_CMD_LINE']) if config.get("SILENT_MODE", "FALSE") == "TRUE": command.append("--silent") command.append("--quiet") else: command.append("--log=" + config.get("BUILD_LOG", "Build.log")) command.append("--report-file=" + config.get("BUILD_REPORT", "BuildReport.log")) if config.get("VERBOSE", "FALSE") == "TRUE": command.append("--verbose") if config.get("MAX_SOCKET") is not None: command.append("-D") command.append("MAX_SOCKET=" + config["MAX_SOCKET"]) if config.get("API_MODE_FSP_WRAPPER_BUILD", "FALSE") == "TRUE": #Override PCD to enable API mode FSP wrapper. command.append("--pcd") command.append("gIntelFsp2WrapperTokenSpaceGuid.PcdFspModeSelection=1") if config.get("PERFORMANCE_BUILD", "FALSE") == "TRUE": command.append("--pcd") command.append("gMinPlatformPkgTokenSpaceGuid.PcdPerformanceEnable=True") shell = True if os.name == "posix": shell = False _, _, _, exit_code = execute_script(command, config, shell=shell) if exit_code != 0: build_failed(config) # Additional build scripts for this platform result = build_ex(config) if result is not None and isinstance(result, dict): config.update(result) return config def post_build(config): """Post build process of BIOS image :param config: The environment variables to be used in the build process :type config: Dictionary :returns: nothing """ print("Running post_build to complete the build process.") board_fd = config["BOARD"].upper() final_fd = os.path.join(config["BUILD_DIR_PATH"], "FV", "{}.fd".format(board_fd)) if config["BIOS_INFO_GUID"]: # Generate the fit table print("Generating FIT ...") if os.path.isfile(final_fd): temp_fd = os.path.join(config["BUILD_DIR_PATH"], "FV", "{}_.fd".format(board_fd)) shell = True command = ["FitGen", "-D", final_fd, temp_fd, "-NA", "-I", config["BIOS_INFO_GUID"]] #@todo: Need mechanism to add additional options to the FitGen command line if os.name == "posix": # linux shell = False _, _, result, return_code = execute_script(command, config, shell=shell) if return_code != 0: print("Error while generating fit") else: # copy output to final binary shutil.copyfile(temp_fd, final_fd) # remove temp file os.remove(temp_fd) else: print("{} does not exist".format(final_fd)) # remove temp file # Additional build scripts for this platform result = post_build_ex(config) if result is not None and isinstance(result, dict): config.update(result) # cleanup pattern = "Fsp_Rebased.*\\.fd$" file_dir = os.path.join(config['WORKSPACE_FSP_BIN'], config['FSP_BIN_PKG']) for item in os.listdir(file_dir): if re.search(pattern, item): os.remove(os.path.join(file_dir, item)) if config.get("DYNAMIC_BUILD_INIT_FILES") is not None: for item in config["DYNAMIC_BUILD_INIT_FILES"].split(","): try: os.remove(item) # remove __init__.py os.remove(item + "c") # remove __init__.pyc as well except OSError: pass print("Done") if os.path.isfile(final_fd): print("Fd file can be found at {}".format(final_fd)) def build_failed(config): """Displays results when build fails :param config: The environment variables used in the build process :type config: Dictionary :returns: nothing """ print(" The EDKII BIOS Build has failed!") # clean up if config.get("DYNAMIC_BUILD_INIT_FILES") is not None: for item in config["DYNAMIC_BUILD_INIT_FILES"].split(","): if os.path.isfile(item): try: os.remove(item) # remove __init__.py os.remove(item + "c") # remove __init__.pyc as well except OSError: pass sys.exit(1) def import_platform_lib(path, function): """Imports custom functions for the platforms being built :param path: the location of the custom build script to be executed :type path: String :param path: the function to be executed :type path: String :returns: nothing """ if path.endswith(".py"): path = path[:-3] path = path.replace(os.sep, ".") module = import_module(path) lib = getattr(module, function) return lib def pre_build_ex(config): """ An extension of the pre_build process as defined platform specific pre_build setup script :param config: The environment variables used in the pre build process :type config: Dictionary :returns: config dictionary :rtype: Dictionary """ if config.get("ADDITIONAL_SCRIPTS"): try: platform_function =\ import_platform_lib(config["ADDITIONAL_SCRIPTS"], "pre_build_ex") functions = {"execute_script": execute_script} return platform_function(config, functions) except ImportError as error: print(config["ADDITIONAL_SCRIPTS"], str(error)) build_failed(config) return None def build_ex(config): """ An extension of the build process as defined platform specific build setup script :param config: The environment variables used in the build process :type config: Dictionary :returns: config dictionary :rtype: Dictionary """ if config.get("ADDITIONAL_SCRIPTS"): try: platform_function =\ import_platform_lib(config["ADDITIONAL_SCRIPTS"], "build_ex") functions = {"execute_script": execute_script} return platform_function(config, functions) except ImportError as error: print("error", config["ADDITIONAL_SCRIPTS"], str(error)) build_failed(config) return None def post_build_ex(config): """ An extension of the post build process as defined platform specific build setup script :param config: The environment variables used in the post build process :type config: Dictionary :returns: config dictionary :rtype: Dictionary """ if config.get("ADDITIONAL_SCRIPTS"): try: platform_function =\ import_platform_lib(config["ADDITIONAL_SCRIPTS"], "post_build_ex") functions = {"execute_script": execute_script} return platform_function(config, functions) except ImportError as error: print(config["ADDITIONAL_SCRIPTS"], str(error)) build_failed(config) return None def clean_ex(config): """ An extension of the platform cleaning :param config: The environment variables used in the clean process :type config: Dictionary :returns: config dictionary :rtype: Dictionary """ if config.get("ADDITIONAL_SCRIPTS"): try: platform_function =\ import_platform_lib(config["ADDITIONAL_SCRIPTS"], "clean_ex") functions = {"execute_script": execute_script} return platform_function(config, functions) except ImportError as error: print(config["ADDITIONAL_SCRIPTS"], str(error)) build_failed(config) return None def get_environment_variables(std_out_str, marker): """Gets the environment variables from a process :param std_out_str: The std_out pipe :type std_out_str: String :param marker: A begining and end mark of environment variables printed to std_out :type marker: String :returns: The environment variables read from the process' std_out pipe :rtype: Tuple """ start_env_update = False environment_vars = {} out_put = "" for line in std_out_str.split("\n"): if start_env_update and len(line.split("=")) == 2: key, value = line.split("=") environment_vars[key] = value else: out_put += "\n" + line.replace(marker, "") if marker in line: if start_env_update: start_env_update = False else: start_env_update = True return (out_put, environment_vars) def execute_script(command, env_variables, collect_env=False, enable_std_pipe=False, shell=True): """launches a process that executes a script/shell command passed to it :param command: The command/script with its commandline arguments to be executed :type command: List:String :param env_variables: Environment variables passed to the process :type env_variables: String :param collect_env: Enables the collection of environment variables when process execution is done :type collect_env: Boolean :param enable_std_pipe: Enables process out to be piped to :type enable_std_pipe: String :returns: a tuple of std_out, stderr , environment variables, return code :rtype: Tuple: (std_out, stderr , enVar, return_code) """ print("Calling " + " ".join(command)) env_marker = '-----env-----' env = {} kwarg = {"env": env_variables, "universal_newlines": True, "shell": shell, "cwd": env_variables["WORKSPACE"]} if enable_std_pipe or collect_env: kwarg["stdout"] = subprocess.PIPE kwarg["stderr"] = subprocess.PIPE # collect environment variables if collect_env: # get the binary that prints environment variables based on os if os.name == 'nt': get_var_command = "set" else: get_var_command = "env" # modify the command to print the environment variables if isinstance(command, list): command += ["&&", "echo", env_marker, "&&", get_var_command, "&&", "echo", env_marker] else: command += " " + " ".join(["&&", "echo", env_marker, "&&", get_var_command, "&&", "echo", env_marker]) # execute the command execute = subprocess.Popen(command, **kwarg) std_out, stderr = execute.communicate() code = execute.returncode # wait for process to be done execute.wait() # if collect environment variables if collect_env: # get the new environment variables std_out, env = get_environment_variables(std_out, env_marker) return (std_out, stderr, env, code) def patch_config(config): """ An extension of the platform cleaning :param config: The environment variables used in the build process :type config: Dictionary :returns: config dictionary :rtype: Dictionary """ new_config = {} for key in config: new_config[str(key)] = str(config[key].replace("/", os.sep)) return new_config def py_27_fix(config): """ Prepares build for python 2.7 => build :param config: The environment variables used in the build process :type config: Dictionary :returns: config dictionary :rtype: Dictionary """ if not sys.version_info > (3, 0): path_list = [] # create __init__.py in directories in this path if config.get("ADDITIONAL_SCRIPTS"): # get the directory path_to_directory =\ os.path.dirname(config.get("ADDITIONAL_SCRIPTS")) path = "" for directories in path_to_directory.split(os.sep): path += directories + os.sep init_file = path + os.sep + "__init__.py" if not os.path.isfile(init_file): open(init_file, 'w').close() path_list.append(init_file) config["DYNAMIC_BUILD_INIT_FILES"] = ",".join(path_list) return config def clean(build_config, board=False): """Cleans the build workspace :param config: The environment variables used in the build process :type config: Dictionary :param board: This flag specifies specific board clean :type board: Bool :returns: nothing """ # patch the config build_config = patch_config(build_config) # get current environment variables config = os.environ.copy() # update it with the build variables config.update(build_config) if config.get('WORKSPACE') is None or not config.get('WORKSPACE'): config["WORKSPACE"] =\ os.path.abspath(os.path.join("..", "..", "..", "")) # build cleanall print("Cleaning directories...") if board: platform_pkg = config.get("PLATFORM_BOARD_PACKAGE", None) if platform_pkg is None or\ not os.path.isdir(os.path.join(config['WORKSPACE'], "Build", platform_pkg)): print("Platform package not found") sys.exit(1) else: print("Removing " + os.path.join(config['WORKSPACE'], "Build", platform_pkg)) shutil.rmtree(os.path.join(config['WORKSPACE'], "Build", platform_pkg)) else: if os.path.isdir(os.path.join(config['WORKSPACE'], "Build")): print("Removing " + os.path.join(config['WORKSPACE'], "Build")) shutil.rmtree(os.path.join(config['WORKSPACE'], "Build")) if os.path.isdir(os.path.join(config['WORKSPACE'], "Conf")): print("Removing " + os.path.join(config['WORKSPACE'], "Conf")) shutil.rmtree(os.path.join(config['WORKSPACE'], "Conf")) print("Cleaning files...") if os.path.isfile(os.path.join(config['WORKSPACE'], config.get("BUILD_REPORT", "BuildReport.log"))): print("Removing ", os.path.join(config['WORKSPACE'], config.get("BUILD_REPORT", "BuildReport.log"))) os.remove(os.path.join(config['WORKSPACE'], config.get("BUILD_REPORT", "BuildReport.log"))) print(" All done...") sys.exit(0) def update_target_file(config): """Updates Conf's target file that will be used in the build :param config: The environment variables used in the build process :type config: Dictionary :returns: True if update was successful and False if update fails :rtype: Boolean """ contents = None result = False with open(os.path.join(config["CONF_PATH"], "target.txt"), 'r') as target: contents = target.readlines() options_list = ['ACTIVE_PLATFORM', 'TARGET', 'TARGET_ARCH', 'TOOL_CHAIN_TAG', 'BUILD_RULE_CONF'] modified = [] # remove these options from the config file for line in contents: if line.replace(" ", "")[0] != '#' and\ any(opt in line for opt in options_list): continue modified.append(line) # replace with config options provided string = "{} = {}\n".format("ACTIVE_PLATFORM", os.path.join( config['WORKSPACE_PLATFORM'], config['PLATFORM_BOARD_PACKAGE'], config['BOARD'], config['PROJECT_DSC'])) modified.append(string) string = "{} = {}\n".format("TARGET", config['TARGET']) modified.append(string) string = "TARGET_ARCH = IA32 X64\n" modified.append(string) string = "{} = {}\n".format("TOOL_CHAIN_TAG", config['TOOL_CHAIN_TAG']) modified.append(string) string = "{} = {}\n".format("BUILD_RULE_CONF", os.path.join("Conf", "build_rule.txt")) modified.append(string) if modified is not None: with open(os.path.join(config["WORKSPACE"], "Conf", "target.txt"), 'w') as target: for line in modified: target.write(line) result = True return result def get_config(): """Reads the default projects config file :returns: The config defined in the the Build.cfg file :rtype: Dictionary """ config_file = configparser.RawConfigParser() config_file.optionxform = str config_file.read('build.cfg') config_dictionary = {} for section in config_file.sections(): dictionary = dict(config_file.items(section)) config_dictionary[section] = dictionary return config_dictionary def get_platform_config(platform_name, config_data): """ Reads the platform specific config file param platform_name: The name of the platform to be built :type platform_name: String param configData: The environment variables to be used in the build process :type configData: Dictionary :returns: The config defined in the the Build.cfg file :rtype: Dictionary """ config = {} platform_data = config_data.get("PLATFORMS") path = platform_data.get(platform_name) config_file = configparser.RawConfigParser() config_file.optionxform = str config_file.read(path) for section in config_file.sections(): config[section] = dict(config_file.items(section)) return config def get_cmd_config_arguments(arguments): """Get commandline config arguments param arguments: The environment variables to be used in the build process :type arguments: argparse :returns: The config dictionary built from the commandline arguments :rtype: Dictionary """ result = {} if arguments.capsule is True: result["CAPSULE_BUILD"] = "1" if arguments.performance is True: result["PERFORMANCE_BUILD"] = "TRUE" if arguments.fsp is True: result["FSP_WRAPPER_BUILD"] = "TRUE" if arguments.fspapi is True: result["API_MODE_FSP_WRAPPER_BUILD"] = "TRUE" if not arguments.UseHashCache: result['BINARY_CACHE_CMD_LINE'] = '' elif arguments.BinCacheDest: result['HASH'] = '--hash' result['BINARY_CACHE_CMD_LINE'] = '--binary-destination=%s' % arguments.BinCacheDest elif arguments.BinCacheSource: result['HASH'] = '--hash' result['BINARY_CACHE_CMD_LINE'] = '--binary-source=%s' % arguments.BinCacheSource else: result['BINARY_CACHE_CMD_LINE'] = '' return result def get_cmd_arguments(build_config): """ Get commandline inputs from user param config_data: The environment variables to be used in the build process :type config_data: Dictionary :returns: The commandline arguments input by the user :rtype: argparse object """ class PrintPlatforms(argparse.Action): """ this is an argparse action that lists the available platforms """ def __call__(self, parser, namespace, values, option_string=None): print("Platforms:") for key in build_config.get("PLATFORMS"): print(" " + key) setattr(namespace, self.dest, values) sys.exit(0) # get the build commands parser = argparse.ArgumentParser(description="Build Help") parser.add_argument('--platform', '-p', dest="platform", help='the platform to build', choices=build_config.get("PLATFORMS"), required=('-l' not in sys.argv and '--cleanall' not in sys.argv)) parser.add_argument('--toolchain', '-t', dest="toolchain", help="using the Tool Chain Tagname to build \ the platform,overriding \ target.txt's TOOL_CHAIN_TAG definition") parser.add_argument("--DEBUG", '-d', help="debug flag", action='store_const', dest="target", const="DEBUG", default="DEBUG") parser.add_argument("--RELEASE", '-r', help="release flag", action='store_const', dest="target", const="RELEASE") parser.add_argument("--TEST_RELEASE", '-tr', help="test Release flag", action='store_const', dest="target", const="TEST_RELEASE") parser.add_argument("--RELEASE_PDB", '-rp', help="release flag", action='store_const', dest="target", const="RELEASE_PDB") parser.add_argument('--list', '-l', action=PrintPlatforms, help='lists available platforms', nargs=0) parser.add_argument('--cleanall', dest='clean_all', help='cleans all', action='store_true') parser.add_argument('--clean', dest='clean', help='cleans specific platform', action='store_true') parser.add_argument("--capsule", help="capsule build enabled", action='store_true', dest="capsule") parser.add_argument("--silent", help="silent build enabled", action='store_true', dest="silent") parser.add_argument("--performance", help="performance build enabled", action='store_true', dest="performance") parser.add_argument("--fsp", help="fsp wrapper build enabled", action='store_true', dest="fsp") parser.add_argument("--fspapi", help="API mode fsp wrapper build enabled", action='store_true', dest="fspapi") parser.add_argument("--hash", action="store_true", dest="UseHashCache", default=False, help="Enable hash-based caching during build process.") parser.add_argument("--binary-destination", help="Generate a cache of binary \ files in the specified directory.", action='store', dest="BinCacheDest") parser.add_argument("--binary-source", help="Consume a cache of binary files \ from the specified directory.", action='store', dest="BinCacheSource") return parser.parse_args() def keyboard_interruption(int_signal, int_frame): """ Catches a keyboard interruption handler param int_signal: The signal this handler is called with :type int_signal: Signal param int_frame: The signal this handler is called with :type int_frame: frame :rtype: nothing """ print("Signal #: {} Frame: {}".format(int_signal, int_frame)) print("Quiting...") sys.exit(0) def main(): """ The main function of this module :rtype: nothing """ # to quit the build signal.signal(signal.SIGINT, keyboard_interruption) # get general build configurations build_config = get_config() # get commandline parameters arguments = get_cmd_arguments(build_config) if arguments.clean_all: clean(build_config.get("DEFAULT_CONFIG")) # get platform specific config platform_config = get_platform_config(arguments.platform, build_config) # update general build config with platform specific config config = build_config.get("DEFAULT_CONFIG") config.update(platform_config.get("CONFIG")) # if user selected clean if arguments.clean: clean(config, board=True) # Override config with cmd arguments cmd_config_args = get_cmd_config_arguments(arguments) config.update(cmd_config_args) # get pre_build configurations config = pre_build(config, build_type=arguments.target, toolchain=arguments.toolchain, silent=arguments.silent) # build selected platform config = build(config) # post build post_build(config) if __name__ == "__main__": try: EXIT_CODE = 0 main() except Exception as error: EXIT_CODE = 1 traceback.print_exc() sys.exit(EXIT_CODE)
edk2-platforms-master
Platform/Intel/build_bios.py
## @file # PreBuild operations for Vlv2TbltDevicePkg # # Copyright (c) 2019, Intel Corporation. All rights reserved.<BR> # # SPDX-License-Identifier: BSD-2-Clause-Patent # ''' PreBuild ''' import os import sys import argparse import subprocess import glob import shutil import struct import datetime # # Globals for help information # __prog__ = 'PreBuild' __copyright__ = 'Copyright (c) 2019, Intel Corporation. All rights reserved.' __description__ = 'Vlv2Tbl2DevicePkg pre-build operations.\n' # # Globals # gWorkspace = '' gBaseToolsPath = '' gArgs = None def LogAlways(Message): sys.stdout.write (__prog__ + ': ' + Message + '\n') sys.stdout.flush() def Log(Message): global gArgs if not gArgs.Verbose: return sys.stdout.write (__prog__ + ': ' + Message + '\n') sys.stdout.flush() def Error(Message, ExitValue=1): sys.stderr.write (__prog__ + ': ERROR: ' + Message + '\n') sys.exit (ExitValue) def RelativePath(target): global gWorkspace Log('RelativePath' + target) return os.path.relpath (target, gWorkspace) def NormalizePath(target): if isinstance(target, tuple): return os.path.normpath (os.path.join (*target)) else: return os.path.normpath (target) def RemoveFile(target): target = NormalizePath(target) if not target or target == os.pathsep: Error ('RemoveFile() invalid target') if os.path.exists(target): os.remove (target) Log ('remove %s' % (RelativePath (target))) def RemoveDirectory(target): target = NormalizePath(target) if not target or target == os.pathsep: Error ('RemoveDirectory() invalid target') if os.path.exists(target): Log ('rmdir %s' % (RelativePath (target))) shutil.rmtree(target) def CreateDirectory(target): target = NormalizePath(target) if not os.path.exists(target): Log ('mkdir %s' % (RelativePath (target))) os.makedirs (target) def Copy(src, dst): src = NormalizePath(src) dst = NormalizePath(dst) for File in glob.glob(src): Log ('copy %s -> %s' % (RelativePath (File), RelativePath (dst))) shutil.copy (File, dst) def GenCapsuleDevice (BaseName, PayloadFileName, Guid, Version, Lsv, CapsulesPath, CapsulesSubDir): global gBaseToolsPath LogAlways ('Generate Capsule: {0} {1:08x} {2:08x} {3}'.format (Guid, Version, Lsv, PayloadFileName)) VersionString = '.'.join([str(ord(x)) for x in struct.pack('>I', Version).decode()]) FmpCapsuleFile = NormalizePath ((CapsulesPath, CapsulesSubDir, BaseName + '.' + VersionString + '.cap')) Command = GenerateCapsuleCommand.format ( FMP_CAPSULE_GUID = Guid, FMP_CAPSULE_VERSION = Version, FMP_CAPSULE_LSV = Lsv, BASE_TOOLS_PATH = gBaseToolsPath, FMP_CAPSULE_FILE = FmpCapsuleFile, FMP_CAPSULE_PAYLOAD = PayloadFileName ) Command = ' '.join(Command.splitlines()).strip() if gArgs.Verbose: Command = Command + ' -v' Log (Command) Process = subprocess.Popen(Command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True) ProcessOutput = Process.communicate() if Process.returncode == 0: Log (ProcessOutput[0].decode()) else: LogAlways (Command) LogAlways (ProcessOutput[0].decode()) Error ('GenerateCapsule returned an error') Copy (PayloadFileName, (CapsulesPath, 'firmware.bin')) MetaInfoXml = MetaInfoXmlTemplate MetaInfoXml = MetaInfoXml.replace ('FMP_CAPSULE_GUID', Guid) MetaInfoXml = MetaInfoXml.replace ('FMP_CAPSULE_BASE_NAME', BaseName) MetaInfoXml = MetaInfoXml.replace ('FMP_CAPSULE_VERSION_DECIMAL', str(Version)) MetaInfoXml = MetaInfoXml.replace ('FMP_CAPSULE_STRING', VersionString) MetaInfoXml = MetaInfoXml.replace ('FMP_CAPSULE_DATE', str(datetime.date.today())) f = open (NormalizePath ((CapsulesPath, 'firmware.metainfo.xml')), 'w') f.write(MetaInfoXml) f.close() f = open (NormalizePath ((CapsulesPath, 'Lvfs.ddf')), 'w') f.write(LvfsDdfTemplate) f.close() if sys.platform == "win32": Command = 'makecab /f ' + NormalizePath ((CapsulesPath, 'Lvfs.ddf')) else: Command = 'gcab --create firmware.cab firmware.bin firmware.metainfo.xml' Log (Command) Process = subprocess.Popen(Command, cwd=CapsulesPath, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True) ProcessOutput = Process.communicate() if Process.returncode == 0: Log (ProcessOutput[0].decode()) else: LogAlways (Command) LogAlways (ProcessOutput[0].decode()) Error ('GenerateCapsule returned an error') FmpCabinetFile = NormalizePath ((CapsulesPath, CapsulesSubDir, BaseName + '.' + VersionString + '.cab')) Copy ((CapsulesPath, 'firmware.cab'), FmpCabinetFile) RemoveFile ((CapsulesPath, 'firmware.cab')) RemoveFile ((CapsulesPath, 'setup.inf')) RemoveFile ((CapsulesPath, 'setup.rpt')) RemoveFile ((CapsulesPath, 'Lvfs.ddf')) RemoveFile ((CapsulesPath, 'firmware.metainfo.xml')) RemoveFile ((CapsulesPath, 'firmware.bin')) BiosIdTemplate = ''' BOARD_ID = MNW2MAX BOARD_REV = $BOARD_REV BOARD_EXT = $ARCH VERSION_MAJOR = 0090 BUILD_TYPE = $BUILD_TYPE VERSION_MINOR = 01 ''' if __name__ == '__main__': # # Create command line argument parser object # parser = argparse.ArgumentParser ( prog = __prog__, description = __description__ + __copyright__, conflict_handler = 'resolve' ) parser.add_argument ( '-a', '--arch', dest = 'Arch', nargs = '+', action = 'append', required = True, help = '''ARCHS is one of list: IA32, X64, IPF, ARM, AARCH64 or EBC, which overrides target.txt's TARGET_ARCH definition. To specify more archs, please repeat this option.''' ) parser.add_argument ( '-t', '--tagname', dest = 'ToolChain', required = True, help = '''Using the Tool Chain Tagname to build the platform, overriding target.txt's TOOL_CHAIN_TAG definition.''' ) parser.add_argument ( '-p', '--platform', dest = 'PlatformFile', required = True, help = '''Build the platform specified by the DSC file name argument, overriding target.txt's ACTIVE_PLATFORM definition.''' ) parser.add_argument ( '-b', '--buildtarget', dest = 'BuildTarget', required = True, help = '''Using the TARGET to build the platform, overriding target.txt's TARGET definition.''' ) parser.add_argument ( '--conf=', dest = 'ConfDirectory', required = True, help = '''Specify the customized Conf directory.''' ) parser.add_argument ( '-D', '--define', dest = 'Define', nargs='*', action = 'append', help = '''Macro: "Name [= Value]".''' ) parser.add_argument ( '-v', '--verbose', dest = 'Verbose', action = 'store_true', help = '''Turn on verbose output with informational messages printed''' ) parser.add_argument ( '--package', dest = 'Package', nargs = '*', action = 'append', help = '''The directory name of a package of tests to copy''' ) # # Parse command line arguments # gArgs, remaining = parser.parse_known_args() gArgs.BuildType = 'all' for BuildType in ['all', 'fds', 'genc', 'genmake', 'clean', 'cleanall', 'modules', 'libraries', 'run']: if BuildType in remaining: gArgs.BuildType = BuildType remaining.remove(BuildType) break gArgs.Remaining = ' '.join(remaining) # # Get WORKSPACE environment variable # try: gWorkspace = os.environ['WORKSPACE'] except: Error ('WORKSPACE environment variable not set') # # Get PACKAGES_PATH and generate prioritized list of paths # PathList = [gWorkspace] try: PathList += os.environ['PACKAGES_PATH'].split(os.pathsep) except: pass # # Determine full path to BaseTools # Vlv2Tbl2DevicePkgPath = '' for Path in PathList: if gBaseToolsPath == '': if os.path.exists (os.path.join (Path, 'BaseTools')): gBaseToolsPath = os.path.join (Path, 'BaseTools') if Vlv2Tbl2DevicePkgPath == '': if os.path.exists (os.path.join (Path, 'Vlv2TbltDevicePkg')): Vlv2Tbl2DevicePkgPath = os.path.join (Path, 'Vlv2TbltDevicePkg') if gBaseToolsPath == '': Error ('Can not find BaseTools in WORKSPACE or PACKAGES_PATH') if Vlv2Tbl2DevicePkgPath == '': Error ('Can not find Vlv2Tbl2DevicePkg in WORKSPACE or PACKAGES_PATH') # # Parse OUTPUT_DIRECTORY from DSC file # for Path in PathList: if os.path.exists (os.path.join (Path, gArgs.PlatformFile)): Dsc = open (os.path.join (Path, gArgs.PlatformFile), 'r').readlines() break for Line in Dsc: if Line.strip().startswith('OUTPUT_DIRECTORY'): OutputDirectory = Line.strip().split('=')[1].strip() break # # Determine full paths to EDK II build directory, EDK II build output # directory and the CPU arch of the UEFI phase. # CommandDir = os.path.dirname(sys.argv[0]) EdkiiBuildDir = os.path.join (gWorkspace, OutputDirectory) EdkiiBuildOutput = os.path.join (EdkiiBuildDir, gArgs.BuildTarget + '_' + gArgs.ToolChain) UefiArch = gArgs.Arch[0][0] if len (gArgs.Arch) > 1: if ['X64'] in gArgs.Arch: UefiArch = 'X64' if gArgs.BuildType == 'run': Error ("'run' target not supported") if gArgs.BuildType == 'clean': sys.exit (0) # # Create output directories to put BiosId files # try: CreateDirectory ((gWorkspace, 'Build')) except: pass try: CreateDirectory ((EdkiiBuildDir)) except: pass try: CreateDirectory ((EdkiiBuildOutput)) except: pass # # Generate BiosId files # BiosId = BiosIdTemplate if sys.platform == "win32": # Built from a Windows Host OS BiosId = BiosId.replace ('$BOARD_REV', 'W') else: # Built from a Linux/Unix/Mac Host OS BiosId = BiosId.replace ('$BOARD_REV', 'L') if UefiArch == 'X64': BiosId = BiosId.replace ('$ARCH', 'X64') else: BiosId = BiosId.replace ('$ARCH', 'I32') BiosId = BiosId.replace ('$BUILD_TYPE', gArgs.BuildTarget[0]) BiosIdFileName = NormalizePath ((EdkiiBuildOutput, 'BiosId.env')) f = open (BiosIdFileName, 'w') f.write(BiosId) f.close() Command = 'python ' + NormalizePath ((Vlv2Tbl2DevicePkgPath, '../Tools/GenBiosId/GenBiosId.py')) Command = Command + ' -i ' + BiosIdFileName Command = Command + ' -o ' + NormalizePath ((EdkiiBuildOutput, 'BiosId.bin')) Command = Command + ' -ot ' + NormalizePath ((EdkiiBuildOutput, 'BiosId.txt')) LogAlways (Command) Process = subprocess.Popen(Command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True) ProcessOutput = Process.communicate() if Process.returncode == 0: Log (ProcessOutput[0].decode()) else: LogAlways (Command) LogAlways (ProcessOutput[0].decode()) Error ('GenBiosId returned an error')
edk2-platforms-master
Platform/Intel/Vlv2TbltDevicePkg/PreBuild.py
## @file # Generate capsules for Vlv2TbltDevicePkg # openssl must be install and in path # # Copyright (c) 2019, Intel Corporation. All rights reserved.<BR> # # SPDX-License-Identifier: BSD-2-Clause-Patent # ''' GenCapsuleAll ''' import os import sys import argparse import subprocess import glob import shutil import struct import datetime # # Globals for help information # __prog__ = 'GenCapsuleAll' __copyright__ = 'Copyright (c) 2019, Intel Corporation. All rights reserved.' __description__ = 'Generate Vlv2Tbl2DevicePkg capsules.\n' # # Globals # gWorkspace = '' gBaseToolsPath = '' gArgs = None def LogAlways(Message): sys.stdout.write (__prog__ + ': ' + Message + '\n') sys.stdout.flush() def Log(Message): global gArgs if not gArgs.Verbose: return sys.stdout.write (__prog__ + ': ' + Message + '\n') sys.stdout.flush() def Error(Message, ExitValue=1): sys.stderr.write (__prog__ + ': ERROR: ' + Message + '\n') sys.exit (ExitValue) def RelativePath(target): global gWorkspace Log('RelativePath' + target) return os.path.relpath (target, gWorkspace) def NormalizePath(target): if isinstance(target, tuple): return os.path.normpath (os.path.join (*target)) else: return os.path.normpath (target) def RemoveFile(target): target = NormalizePath(target) if not target or target == os.pathsep: Error ('RemoveFile() invalid target') if os.path.exists(target): os.remove (target) Log ('remove %s' % (RelativePath (target))) def RemoveDirectory(target): target = NormalizePath(target) if not target or target == os.pathsep: Error ('RemoveDirectory() invalid target') if os.path.exists(target): Log ('rmdir %s' % (RelativePath (target))) shutil.rmtree(target) def CreateDirectory(target): target = NormalizePath(target) if not os.path.exists(target): Log ('mkdir %s' % (RelativePath (target))) os.makedirs (target) def Copy(src, dst): src = NormalizePath(src) dst = NormalizePath(dst) for File in glob.glob(src): Log ('copy %s -> %s' % (RelativePath (File), RelativePath (dst))) shutil.copy (File, dst) GenerateCapsuleCommand = ''' GenerateCapsule --encode --guid {FMP_CAPSULE_GUID} --fw-version {FMP_CAPSULE_VERSION} --lsv {FMP_CAPSULE_LSV} --capflag PersistAcrossReset --capflag InitiateReset --signer-private-cert={BASE_TOOLS_PATH}/Source/Python/Pkcs7Sign/TestCert.pem --other-public-cert={BASE_TOOLS_PATH}/Source/Python/Pkcs7Sign/TestSub.pub.pem --trusted-public-cert={BASE_TOOLS_PATH}/Source/Python/Pkcs7Sign/TestRoot.pub.pem -o {FMP_CAPSULE_FILE} {FMP_CAPSULE_PAYLOAD} ''' MetaInfoXmlTemplate = ''' <?xml version="1.0" encoding="UTF-8"?> <component type="firmware"> <id>com.intel.FMP_CAPSULE_BASE_NAME.firmware</id> <name>FMP_CAPSULE_BASE_NAME</name> <summary>System firmware for the FMP_CAPSULE_BASE_NAME</summary> <description> Description of System firmware for the FMP_CAPSULE_BASE_NAME </description> <provides> <firmware type="flashed">FMP_CAPSULE_GUID</firmware> </provides> <url type="homepage">http://www.tianocore.org</url> <metadata_license>CC0-1.0</metadata_license> <project_license>BSD</project_license> <developer_name>Tianocore</developer_name> <releases> <release version="FMP_CAPSULE_VERSION_DECIMAL" date="FMP_CAPSULE_DATE"> <description> Build FMP_CAPSULE_STRING </description> </release> </releases> <!-- most OEMs do not need to do this... --> <custom> <value key="LVFS::InhibitDownload"/> </custom> </component> ''' LvfsDdfTemplate = ''' .OPTION EXPLICIT ; Generate errors on variable typos .Set CabinetNameTemplate=firmware.cab ; The name of the file .set DiskDirectoryTemplate=CDROM ; All cabinets go in a single directory .Set Cabinet=on ; .Set Compress=on ; .Set DiskDirectory1=. .Set MaxDiskSize=99999744 ; multiple of 512 ;*** Files to zip ; ; firmware.bin firmware.metainfo.xml ;*** ''' def GenCapsuleDevice (BaseName, PayloadFileName, Guid, Version, Lsv, CapsulesPath, CapsulesSubDir): global gBaseToolsPath LogAlways ('Generate Capsule: {0} {1:08x} {2:08x} {3}'.format (Guid, Version, Lsv, PayloadFileName)) VersionString = '.'.join([str(ord(x)) for x in struct.pack('>I', Version).decode()]) FmpCapsuleFile = NormalizePath ((CapsulesPath, CapsulesSubDir, BaseName + '.' + VersionString + '.cap')) Command = GenerateCapsuleCommand.format ( FMP_CAPSULE_GUID = Guid, FMP_CAPSULE_VERSION = Version, FMP_CAPSULE_LSV = Lsv, BASE_TOOLS_PATH = gBaseToolsPath, FMP_CAPSULE_FILE = FmpCapsuleFile, FMP_CAPSULE_PAYLOAD = PayloadFileName ) Command = ' '.join(Command.splitlines()).strip() if gArgs.Verbose: Command = Command + ' -v' Log (Command) Process = subprocess.Popen(Command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True) ProcessOutput = Process.communicate() if Process.returncode == 0: Log (ProcessOutput[0].decode()) else: LogAlways (Command) LogAlways (ProcessOutput[0].decode()) Error ('GenerateCapsule returned an error') Copy (PayloadFileName, (CapsulesPath, 'firmware.bin')) MetaInfoXml = MetaInfoXmlTemplate MetaInfoXml = MetaInfoXml.replace ('FMP_CAPSULE_GUID', Guid) MetaInfoXml = MetaInfoXml.replace ('FMP_CAPSULE_BASE_NAME', BaseName) MetaInfoXml = MetaInfoXml.replace ('FMP_CAPSULE_VERSION_DECIMAL', str(Version)) MetaInfoXml = MetaInfoXml.replace ('FMP_CAPSULE_STRING', VersionString) MetaInfoXml = MetaInfoXml.replace ('FMP_CAPSULE_DATE', str(datetime.date.today())) f = open (NormalizePath ((CapsulesPath, 'firmware.metainfo.xml')), 'w') f.write(MetaInfoXml) f.close() f = open (NormalizePath ((CapsulesPath, 'Lvfs.ddf')), 'w') f.write(LvfsDdfTemplate) f.close() if sys.platform == "win32": Command = 'makecab /f ' + NormalizePath ((CapsulesPath, 'Lvfs.ddf')) else: Command = 'gcab --create firmware.cab firmware.bin firmware.metainfo.xml' Log (Command) Process = subprocess.Popen(Command, cwd=CapsulesPath, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True) ProcessOutput = Process.communicate() if Process.returncode == 0: Log (ProcessOutput[0].decode()) else: LogAlways (Command) LogAlways (ProcessOutput[0].decode()) Error ('GenerateCapsule returned an error') FmpCabinetFile = NormalizePath ((CapsulesPath, CapsulesSubDir, BaseName + '.' + VersionString + '.cab')) Copy ((CapsulesPath, 'firmware.cab'), FmpCabinetFile) RemoveFile ((CapsulesPath, 'firmware.cab')) RemoveFile ((CapsulesPath, 'setup.inf')) RemoveFile ((CapsulesPath, 'setup.rpt')) RemoveFile ((CapsulesPath, 'Lvfs.ddf')) RemoveFile ((CapsulesPath, 'firmware.metainfo.xml')) RemoveFile ((CapsulesPath, 'firmware.bin')) def GenCapsuleSampleDevice (SampleDeviceName, Guid, Version, Lsv, CapsulesPath, CapsulesSubDir): BinaryPayload = SampleDeviceName.encode() + bytearray(0x18 - len (SampleDeviceName.encode())) BinaryPayload = BinaryPayload + struct.pack('<I', Version) BinaryPayload = BinaryPayload + struct.pack('<I', Lsv) PayloadFileName = NormalizePath ((CapsulesPath, SampleDeviceName + '.bin')) f = open (PayloadFileName, 'wb') f.write(BinaryPayload) f.close() GenCapsuleDevice(SampleDeviceName, PayloadFileName, Guid, Version, Lsv, CapsulesPath, CapsulesSubDir) RemoveFile (PayloadFileName) if __name__ == '__main__': # # Create command line argument parser object # parser = argparse.ArgumentParser ( prog = __prog__, description = __description__ + __copyright__, conflict_handler = 'resolve' ) parser.add_argument ( '-a', '--arch', dest = 'Arch', nargs = '+', action = 'append', required = True, help = '''ARCHS is one of list: IA32, X64, IPF, ARM, AARCH64 or EBC, which overrides target.txt's TARGET_ARCH definition. To specify more archs, please repeat this option.''' ) parser.add_argument ( '-t', '--tagname', dest = 'ToolChain', required = True, help = '''Using the Tool Chain Tagname to build the platform, overriding target.txt's TOOL_CHAIN_TAG definition.''' ) parser.add_argument ( '-p', '--platform', dest = 'PlatformFile', required = True, help = '''Build the platform specified by the DSC file name argument, overriding target.txt's ACTIVE_PLATFORM definition.''' ) parser.add_argument ( '-b', '--buildtarget', dest = 'BuildTarget', required = True, help = '''Using the TARGET to build the platform, overriding target.txt's TARGET definition.''' ) parser.add_argument ( '--conf=', dest = 'ConfDirectory', required = True, help = '''Specify the customized Conf directory.''' ) parser.add_argument ( '-D', '--define', dest = 'Define', nargs='*', action = 'append', help = '''Macro: "Name [= Value]".''' ) parser.add_argument ( '-v', '--verbose', dest = 'Verbose', action = 'store_true', help = '''Turn on verbose output with informational messages printed''' ) parser.add_argument ( '--package', dest = 'Package', nargs = '*', action = 'append', help = '''The directory name of a package of tests to copy''' ) # # Parse command line arguments # gArgs, remaining = parser.parse_known_args() gArgs.BuildType = 'all' for BuildType in ['all', 'fds', 'genc', 'genmake', 'clean', 'cleanall', 'modules', 'libraries', 'run']: if BuildType in remaining: gArgs.BuildType = BuildType remaining.remove(BuildType) break gArgs.Remaining = ' '.join(remaining) # # Get WORKSPACE environment variable # try: gWorkspace = os.environ['WORKSPACE'] except: Error ('WORKSPACE environment variable not set') # # Get PACKAGES_PATH and generate prioritized list of paths # PathList = [gWorkspace] try: PathList += os.environ['PACKAGES_PATH'].split(os.pathsep) except: pass # # Determine full path to BaseTools # for Path in PathList: if os.path.exists (os.path.join (Path, 'BaseTools')): gBaseToolsPath = os.path.join (Path, 'BaseTools') break # # Parse OUTPUT_DIRECTORY from DSC file # for Path in PathList: if os.path.exists (os.path.join (Path, gArgs.PlatformFile)): Dsc = open (os.path.join (Path, gArgs.PlatformFile), 'r').readlines() break for Line in Dsc: if Line.strip().startswith('OUTPUT_DIRECTORY'): OutputDirectory = Line.strip().split('=')[1].strip() break # # Determine full paths to EDK II build directory, EDK II build output # directory and the CPU arch of the UEFI phase. # CommandDir = os.path.dirname(sys.argv[0]) EdkiiBuildDir = os.path.join (gWorkspace, OutputDirectory) EdkiiBuildOutput = os.path.join (EdkiiBuildDir, gArgs.BuildTarget + '_' + gArgs.ToolChain) UefiArch = gArgs.Arch[0][0] if len (gArgs.Arch) > 1: if ['X64'] in gArgs.Arch: UefiArch = 'X64' CapsulesPath = NormalizePath((EdkiiBuildDir, 'Capsules')) CapsulesSubDir = 'TestCert' + '_' + UefiArch + '_' + gArgs.BuildTarget + '_' + gArgs.ToolChain # # Create output directories # try: CreateDirectory ((CapsulesPath)) except: pass try: CreateDirectory ((CapsulesPath, CapsulesSubDir)) except: pass # # Copy CapsuleApp # Copy ((EdkiiBuildOutput, UefiArch, 'CapsuleApp.efi'), (CapsulesPath, CapsulesSubDir)) # # Generate capsules for the Red Sample Device # GenCapsuleSampleDevice('Red','72e2945a-00da-448e-9aa7-075ad840f9d4',0x00000010,0x00000000, CapsulesPath, CapsulesSubDir) GenCapsuleSampleDevice('Red','72e2945a-00da-448e-9aa7-075ad840f9d4',0x00000011,0x00000000, CapsulesPath, CapsulesSubDir) GenCapsuleSampleDevice('Red','72e2945a-00da-448e-9aa7-075ad840f9d4',0x00000012,0x00000000, CapsulesPath, CapsulesSubDir) # # Generate capsules for the Green Sample Device # GenCapsuleSampleDevice('Green','79179bfd-704d-4c90-9e02-0ab8d968c18a',0x00000020,0x00000020, CapsulesPath, CapsulesSubDir) GenCapsuleSampleDevice('Green','79179bfd-704d-4c90-9e02-0ab8d968c18a',0x00000021,0x00000020, CapsulesPath, CapsulesSubDir) GenCapsuleSampleDevice('Green','79179bfd-704d-4c90-9e02-0ab8d968c18a',0x00000022,0x00000020, CapsulesPath, CapsulesSubDir) # # Generate capsules for the Blue Sample Device # GenCapsuleSampleDevice('Blue','149da854-7d19-4faa-a91e-862ea1324be6',0x00000010,0x00000000, CapsulesPath, CapsulesSubDir) GenCapsuleSampleDevice('Blue','149da854-7d19-4faa-a91e-862ea1324be6',0x00000011,0x00000000, CapsulesPath, CapsulesSubDir) GenCapsuleSampleDevice('Blue','149da854-7d19-4faa-a91e-862ea1324be6',0x00000012,0x00000012, CapsulesPath, CapsulesSubDir) GenCapsuleSampleDevice('Blue','149da854-7d19-4faa-a91e-862ea1324be6',0x00000013,0x00000012, CapsulesPath, CapsulesSubDir) GenCapsuleSampleDevice('Blue','149da854-7d19-4faa-a91e-862ea1324be6',0x00000014,0x00000012, CapsulesPath, CapsulesSubDir) # # Generate capsules for Minnow Max Firmware Updates # RomFileName = os.path.join (EdkiiBuildOutput, 'FV', 'VLV.fd') GenCapsuleDevice('MinnowMax', RomFileName,'4096267b-da0a-42eb-b5eb-fef31d207cb4',0x0000000C,0x00000000, CapsulesPath, CapsulesSubDir)
edk2-platforms-master
Platform/Intel/Vlv2TbltDevicePkg/Feature/Capsule/GenerateCapsule/GenCapsuleAll.py
## @file # Trim files preprocessed by compiler # # Copyright (c) 2019, Intel Corporation. All rights reserved.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # ## # Import Modules # import os import sys import time import logging import struct import datetime import argparse import platform from collections import OrderedDict try: from configparser import ConfigParser except: from ConfigParser import ConfigParser # Config message _BIOS_Signature = "$IBIOSI$" _ConfigItem = { "BOARD_ID": {'Value': '', 'Length': 7}, "BOARD_REV": {'Value': '', 'Length': 1}, "BOARD_EXT": {'Value': '', 'Length': 3}, "BUILD_TYPE": {'Value': '', 'Length': 1}, "VERSION_MAJOR": {'Value': '0000', 'Length': 4}, "VERSION_MINOR": {'Value': '00', 'Length': 2}, } # Version message __prog__ = 'GenBiosld' __description__ = 'Trim files preprocessed by compiler' __copyright__ = 'Copyright (c) 2019, Intel Corporation. All rights reserved.<BR> ' __version__ = '%s Version %s' % (__prog__, '0.1 ') # ExtraData message _Usage = "Usage: GenBiosId -i Configfile -o OutputFile [-ot OutputTextFile]" _ConfigSectionNotDefine = "Not support the config file format, need config section" _ErrorMessageTemplate = '\n\n%(tool)s...\n : error: %(msg)s\n\t%(extra)s' _ErrorLogger = logging.getLogger("tool_error") _ErrorFormatter = logging.Formatter("%(message)s") _ConfigLenInvalid = "Config item %s length is invalid" _ConfigItemInvalid = "Item %s is invalid" # Error message INFO = 20 ERRORCODE = 50 OPTION_MISSING = 'Missing option' FORMAT_INVALID = 'Invalid syntax/format' FILE_NOT_FOUND = 'File/directory not found in workspace' FORMAT_UNKNOWN_ERROR = 'Unknown error in syntax/format' FORMAT_NOT_SUPPORTED = 'Not supported syntax/format' def SetEdkLogger(): _ErrorLogger.setLevel(INFO) _ErrorCh = logging.StreamHandler(sys.stderr) _ErrorCh.setFormatter(_ErrorFormatter) _ErrorLogger.addHandler(_ErrorCh) return _ErrorLogger # Output the error message and exit the tool def EdkLogger(ToolName, Message, ExtraData): _ErrorLogger = SetEdkLogger() TemplateDict = {"tool": ToolName, "msg": Message, "extra": ExtraData} LogText = _ErrorMessageTemplate % TemplateDict _ErrorLogger.log(ERRORCODE, LogText) sys.exit(1) # Open the file in the correct way def FileOpen(FileName, Mode, Buffer=-1): def LongFilePath(FileName): FileName = os.path.normpath(FileName) if platform.system() == 'Windows': if FileName.startswith('\\\\?\\'): return FileName if FileName.startswith('\\\\'): return '\\\\?\\UNC\\' + FileName[2:] if os.path.isabs(FileName): return '\\\\?\\' + FileName return FileName return open(LongFilePath(FileName), Mode, Buffer) # Parse command line options def MyOptionParser(): parser = argparse.ArgumentParser(prog=__prog__, description=__description__ + __copyright__ + _Usage, conflict_handler='resolve') parser.add_argument('-v', '--version', action='version', version=__version__, help="show program's version number and exit") parser.add_argument('-i', '--int', metavar='FILENAME', dest='InputFile', help="Input Config file") parser.add_argument('-o', '--out', metavar='FILENAME', dest='OutputFile', help="Output file") parser.add_argument('-ot', '--text', metavar='FILENAME', dest='OutputTextFile', help="Output Text file") parser.add_argument('-nt', '--notimestamp', dest='NoTimestamp', action='store_true', default=False, help="Set timestamp to zero") Options = parser.parse_args() return Options # Check the Tool for missing variables def CheckOptions(Options): if len(sys.argv) not in [5,6] and not (len(sys.argv) in [7,8] and Options.OutputTextFile): EdkLogger("GenBiosId", OPTION_MISSING, ExtraData=_Usage) elif not Options.InputFile or not Options.OutputFile: EdkLogger("GenBiosId", OPTION_MISSING, ExtraData=_Usage) InputFile = Options.InputFile OutputFile = Options.OutputFile OutputTextFile = Options.OutputTextFile NoTimestamp = Options.NoTimestamp if not os.path.exists(InputFile): EdkLogger("GenBiosId", FILE_NOT_FOUND, ExtraData="Input file not found") return InputFile, OutputFile, OutputTextFile, NoTimestamp # Read input file and get config def ReadInputFile(InputFile): InputDict = OrderedDict() with open(InputFile) as File: FileLines = File.readlines() for Line in FileLines: if Line.strip().startswith('#'): continue if '=' in Line: Key, Value = Line.split('=') InputDict[Key.strip()] = Value.strip() return InputDict # Parse the input file and extract the information def ParserInputFile(InputDict, NoTimestamp): for Item in InputDict: if Item not in _ConfigItem: EdkLogger("GenBiosId", FORMAT_INVALID, ExtraData=_ConfigItemInvalid % Item) _ConfigItem[Item]['Value'] = InputDict[Item] if len(_ConfigItem[Item]['Value']) != _ConfigItem[Item]['Length']: # The length of the Board ID is being updated based on the BOARD_ID string #If the PCH_TYPE is empty space/single quotes(''), removing the empty space/single quotes('') and concatenating the TARGET_PLATFORM_SHORT and BUILD flag strings if(_ConfigItem["BOARD_ID"]['Value'][3:5] == "\'\'"): _ConfigItem["BOARD_ID"]['Value']=_ConfigItem["BOARD_ID"]['Value'][0:3]+_ConfigItem["BOARD_ID"]['Value'][5:len(_ConfigItem["BOARD_ID"]['Value'])] _ConfigItem["BOARD_ID"]['Length']=len(_ConfigItem["BOARD_ID"]['Value']) else: EdkLogger("GenBiosId", FORMAT_INVALID, ExtraData=_ConfigLenInvalid % Item) for Item in _ConfigItem: if not _ConfigItem[Item]['Value']: EdkLogger("GenBiosId", FORMAT_UNKNOWN_ERROR, ExtraData="Item %s is missing" % Item) utcnow = datetime.datetime.utcnow() if NoTimestamp: TimeStamp = "\0\0\0\0\0\0\0\0\0\0" else: TimeStamp = time.strftime("%y%m%d%H%M", utcnow.timetuple()) Id_Str = _ConfigItem['BOARD_ID']['Value'] + _ConfigItem['BOARD_REV']['Value'] + '.' + _ConfigItem['BOARD_EXT'][ 'Value'] + '.' + _ConfigItem['VERSION_MAJOR']['Value'] + \ '.' + _ConfigItem["BUILD_TYPE"]['Value'] + _ConfigItem['VERSION_MINOR']['Value'] + '.' + TimeStamp return Id_Str # Output information to a file def PrintOutputFile(OutputFile, OutputTextFile, Id_Str): with FileOpen(OutputFile, 'wb') as FdOut: for i in _BIOS_Signature: FdOut.write(struct.pack('B', ord(i))) for i in Id_Str: FdOut.write(struct.pack('H', ord(i))) FdOut.write(struct.pack('H', 0x00)) if OutputTextFile: with FileOpen(OutputTextFile, 'w') as FdOut: FdOut.write(Id_Str) # Tool entrance method def Main(): Options = MyOptionParser() InputFile, OutputFile, OutputTextFile, NoTimestamp = CheckOptions(Options) InputDict = ReadInputFile(InputFile) Id_Str = ParserInputFile(InputDict, NoTimestamp) PrintOutputFile(OutputFile, OutputTextFile, Id_Str) return 0 if __name__ == '__main__': r = Main() ## 0-127 is a safe return range, and 1 is a standard default error if r < 0 or r > 127: r = 1 sys.exit(r)
edk2-platforms-master
Platform/Intel/Tools/GenBiosId/GenBiosId.py
## @file # Get all recursive package paths from special directories. # # Copyright (c) 2020, Intel Corporation. All rights reserved.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # import os import glob import argparse # # Globals for help information # __prog__ = 'GetPackagesPath.py' __copyright__ = 'Copyright (c) 2020, Intel Corporation. All rights reserved.' __description__ = 'Gets all recursive package paths in specified directory.\n' def __get_packages_path(root): """ Gets all recursive package paths in specified directory. A directory is a package path if it satisfies conditions below: 1. it is a directory 2. it is not an EDK II Package. An EDK II Package (directory) is a directory that contains an EDK II package declaration (DEC) file. 3. it contains at least one first level EDK II Package. Note: A directory is not package path but its subdirectory could be. Example: edk2-platforms/Features is not package path but edk2-platforms/Features/Intel is. :param root: The specified directory to find package paths in it, the caller should ensure it is an valid directory :type root: String :returns: Return all recursive package paths :rtype: String list """ paths = [] contain_package = False for filename in os.listdir(root): # skip files whose name starts with ".", such as ".git" if filename.startswith('.'): continue filepath = os.path.join(root, filename) if os.path.isdir(filepath): if glob.glob(os.path.join(filepath, '*.dec')): # it is an EDK II Package contain_package = True else: # get package paths for subdirectory if it is not package paths = paths + __get_packages_path(filepath) if contain_package: # root is a package path because it contains EDK II Package # in first level folder, inset it to head of list paths.insert(0, root) # return package paths return paths def get_packages_path(directories): """ For each direcory in directories, gets all recursive package paths in this directory and joins them into one string. :param directories: the list of directory :type directories: String list :returns: Return string of package paths :rtype: String """ packages_path = '' for directory in directories: directory = os.path.abspath(directory) if (not os.path.exists(directory)) or (not os.path.isdir(directory)): continue if glob.glob(os.path.join(directory, '*.dec')): # it is an EDK II Package continue paths = __get_packages_path(directory) for path in paths: if packages_path == '': packages_path = path else: packages_path += os.pathsep + path return packages_path if __name__ == '__main__': # Create command line argument parser object parser = argparse.ArgumentParser( prog=__prog__, description=__description__ + __copyright__, conflict_handler='resolve' ) parser.add_argument('directory', nargs='+', help='Specified directory where package packages are got from') args = parser.parse_args() print(get_packages_path(args.directory))
edk2-platforms-master
Platform/Intel/Tools/AppendPackagesPath/GetPackagesPath.py
## @file # generate UQI (Universal Question Identifier) unicode string for HII question PROMPT string. UQI string can be used to # identify each HII question. # # Copyright (c) 2019, Intel Corporation. All rights reserved. # # SPDX-License-Identifier: BSD-2-Clause-Patent # import re import sys import os import getopt import codecs import fnmatch import logging import argparse # global variable declarations QuestionError = False FileHeader = '//\r\n// FILE auto-generated by UniTool\r\n//\r\n\r\n#langdef uqi "uqi"\r\n\r\n' UqiList = re.compile('^#string[ \t]+([A-Z_0-9]+)[ \t]+#language[ \t]+uqi[ \t\r\n]+"(?:[x\S]{1,2})([0-9a-fA-F]{4,5})"', re.M).findall AllUqis = {} StringDict = {} GlobalVarId = {} Options = {} # Version message __prog__ = 'UniTool' __description__ = 'The script generate UQI unicode string for HII question PROMPT string.\n' __copyright__ = 'Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>' __version__ = '%s Version %s' % (__prog__, '0.1 ') _Usage = "Syntax: %s [-b] [-u] [-l] [-x] [-h] [-d 'rootDirectory1'] [-d 'rootDirectory2'] [-d 'rootDirectory3']... \n[-q e|w]" \ "'rootDirectory0' 'uqiFile'|'uqiFileDirectory' ['excludedDirectory1'] ['excludedDirectory2'] ['excludedDirectory3']...\n" \ % (os.path.basename(sys.argv[0])) # ********************************************************************** # description: Get uni file encoding # # arguments: Filename - name of uni file # # returns: utf-8 or utf-16 # def GetUniFileEncoding(Filename): # # Detect Byte Order Mark at beginning of file. Default to UTF-8 # Encoding = 'utf-8' # # Read file # try: with open(Filename, mode='rb') as UniFile: FileIn = UniFile.read() except: return Encoding if (FileIn.startswith(codecs.BOM_UTF16_BE) or FileIn.startswith(codecs.BOM_UTF16_LE)): Encoding = 'utf-16' return Encoding # rewrite function os.path.walk def Walk(Top, Func, Arg): try: Names = os.listdir(Top) except os.error: return Func(Arg, Top, Names) for Name in Names: Name = os.path.join(Top, Name) if os.path.isdir(Name): Walk(Name, Func, Arg) # ********************************************************************** # description: Parses commandline arguments and options # Calls function processUni to build dictionary of strings # Calls other functions according to user specified options # # arguments: argv - contains all input from command line # - must contain path to root directory # - may contain options -h, -u, -l, -b or -x before path # # returns: none # def main(): ##### Read input arguments and options global AllUqis, UqiList, QuestionError parser = argparse.ArgumentParser(prog=__prog__, description=__description__ + __copyright__, usage=_Usage, conflict_handler='resolve') parser.add_argument('Path', nargs='+', help='the path for files to be converted.It could be directory or file path.') parser.add_argument('-v', '--version', action='version', version=__version__, help="show program's version number and exit") parser.add_argument('-b', '--build', action='store_true', dest='BuildOption', help="Build option returns error if any new UQI needs assigning " \ "based on vfi/vfr/hfr/sd/sdi when no -u option is specified") parser.add_argument('-u', '--updata', action='store_true', dest='UpdateUQIs', help="Create new UQIs that does not already exist in uqiFile for" \ "any string requiring a UQI based on vfi/vfr/hfr/sd/sdi" \ "NOTE: 'uqiFile' cannot be readonly!") parser.add_argument('-l', '--lang', action='store_true', dest='LangOption', help="Language deletion option (keeps only English and uqi)" \ "moves all UQIs to 'uqiFile', NOTE: Uni files cannot be readonly!") parser.add_argument('-x', '--exclude', action='store_true', dest='ExcludeOption', help="Exclude 'rootDirectory'/'excludedDirectory1' &" \ "'rootDirectory'/'excludedDirectory2'... from UQI list build") parser.add_argument('-d', '--dir', action='append', metavar='FILEDIR', dest='DirName', help="Add multiple root directories to process") parser.add_argument('-q', '--question', dest='Question', choices=['w', 'e'], help="Print warning(w) or return error(e) if different HII questions" \ "are referring same string token") Opts = parser.parse_args() Destname = '' DirNameList = [] ExDirList = [] if Opts.Path: DirNameList.append(Opts.Path[0]) Destname = Opts.Path[1] ExDirList = Opts.Path[2:] if Opts.DirName: DirNameList.extend(Opts.DirName) QuestionOption = Opts.Question ExcludeOption = Opts.ExcludeOption BuildOption = Opts.BuildOption UpdateUQIs = Opts.UpdateUQIs LangOption = Opts.LangOption ExPathList = [] if ExDirList: try: for EachExDir in ExDirList: for EachRootDir in DirNameList: if EachExDir == EachRootDir: print("\nERROR: excludedDirectory is same as rootDirectory\n") return ExPathList.append(EachRootDir + os.sep + EachExDir) except: print(_Usage) return global Options Options = {'Destname': Destname, 'DirNameList': DirNameList, 'ExPathList': ExPathList, 'BuildOption': BuildOption, 'UpdateUQIs': UpdateUQIs, 'LangOption': LangOption, 'ExcludeOption': ExcludeOption, 'QuestionOption': QuestionOption} print("UQI file: %s" % Destname) for EachDirName in DirNameList: Walk(EachDirName, processUni, None) if QuestionError: return if os.path.isdir(Options['Destname']): DestFileName = Options['Destname'] + os.sep + 'UqiList.uni' else: DestFileName = Options['Destname'] if os.path.exists(DestFileName) and (DestFileName not in list(AllUqis.keys())): try: Encoding = GetUniFileEncoding(DestFileName) with codecs.open(DestFileName, 'r+', Encoding) as destFile: DestFileBuffer = destFile.read() except IOError as e: print("ERROR: " + e.args[1]) return AllUqis[DestFileName] = UqiList(DestFileBuffer) if BuildOption: ReturnVal = newUqi() if (ReturnVal == 1): print('Please fix UQI ERROR(s) above before proceeding.') else: print("No UQI issues detected\n") return # ********************************************************************** # description: newUqi collects a list of all currently used uqi values in the tree # Halt build if any duplicated string or value in UQI list. # If -u option was specified, creates new UQIs that does not # already exist in uqiFile for any string requiring a UQI. # # arguments: none # # returns: 0 on success # 1 on error - this should cause the build to halt # Syntax = "S" SyntaxRE = re.compile('#string[ \t]+[A-Z_0-9]+[ \t]+#language[ \t]+uqi[ \t\r\n]+"([x\S]{1,2}).*', re.DOTALL).findall def newUqi(): global Options, GlobalVarId, AllUqis, Syntax, SyntaxRE UqiRange = [] UqiStringList = [] CreateUQI = [] ReturnVal = 0 BaseNumSpaces = 47 # Used to line up the UQI values in the resulting uqiFile # Look for duplication in the current UQIs and collect current range of UQIs for path in AllUqis.keys(): for UqiString in AllUqis[path]: # path contains the path and Filename of each uni file # Checks for duplicated strings in UQI list for TempString in UqiStringList: if TempString == UqiString[0]: print("ERROR: UQI string %s was assigned more than once and will cause corruption!" % UqiString[0]) print("Delete one occurrence of the string and rerun tool.") ReturnVal = 1 # halt build UqiStringList.append(UqiString[0]) # Checks for duplicated UQI values in UQI list if int(UqiString[1], 16) in UqiRange: print("ERROR: UQI value %04x was assigned more than once and will cause corruption!" % int(UqiString[1], 16)) print("Delete one occurrance of the UQI and rerun tool to create alternate value.") ReturnVal = 1 # halt build UqiRange.append(int(UqiString[1], 16)) for StringValue in GlobalVarId.keys(): StringFound = False for path in StringDict.keys(): for UniString in StringDict[path]: # path contains the path and Filename of each uni file if (StringValue == UniString): StringFound = True break if not StringFound: print("ERROR: No definition for %s referred by HII question" % (StringValue)) ReturnVal = 1 # halt build # Require a UQI for any string in vfr/vfi files for StringValue in GlobalVarId.keys(): # Ignore strings defined as STRING_TOKEN(0) if (StringValue != "0"): # Check if this string already exists in the UQI list if (StringValue not in UqiStringList) and (StringValue not in CreateUQI): CreateUQI.append(StringValue) if not Options['UpdateUQIs']: print("ERROR: No UQI for %s referred by HII question" % (StringValue)) ReturnVal = 1 # halt build after printing all error messages if (ReturnVal == 1): return ReturnVal # Update uqiFile with necessary UQIs if Options['UpdateUQIs'] and CreateUQI: if os.path.isdir(Options['Destname']): DestFileName = Options['Destname'] + os.sep + 'UqiList.uni' else: DestFileName = Options['Destname'] try: Encoding = GetUniFileEncoding(DestFileName) with codecs.open(DestFileName, 'r+', Encoding) as OutputFile: PlatformUQI = OutputFile.read() except IOError as e: print("ERROR: " + e.args[1]) if (e.args[0] == 2): try: with codecs.open(DestFileName, 'w', Encoding) as OutputFile: print(DestFileName + " did not exist. Creating new file.") PlatformUQI = FileHeader except: print("Error creating " + DestFileName + ".") return 1 if (e.args[1] == "Permission denied"): print( "\n%s is Readonly. You must uncheck the ReadOnly attibute to run the -u option.\n" % DestFileName) return 1 # Determines and sets the UQI number format # TODO: there is probably a more elegant way to do this... SyntaxL = SyntaxRE(PlatformUQI) if len(SyntaxL) != 0: Syntax = SyntaxL[0] # script is reading the file in and writing it back instead of appending because the codecs module # automatically adds a BOM wherever you start writing. This caused build failure. UqiRange.sort() if (UqiRange == []): NextUqi = 0 else: NextUqi = UqiRange[len(UqiRange) - 1] + 1 for StringValue in CreateUQI: print("%s will be assigned a new UQI value" % StringValue) UqiRange.append(NextUqi) # # Lines up the UQI values in the resulting uqiFile # Spaces = " " * (BaseNumSpaces - len(StringValue)) PlatformUQI += '#string %s%s #language uqi \"%s%04x\"\r\n' % (StringValue, Spaces, Syntax, NextUqi) print("#string %s%s #language uqi \"%s%04X\"" % (StringValue, Spaces, Syntax, NextUqi)) NextUqi += 1 with codecs.open(DestFileName, 'r+', Encoding) as OutputFile: OutputFile.seek(0) OutputFile.write(PlatformUQI) return 0 # ********************************************************************** # description: Parses each uni file to collect dictionary of strings # Removes additional languages and overwrites current uni files # if -l option was specified # # arguments: path - directory location of file including file name # Filename - name of file to be modified # # returns: error string if failure occurred; # none if completed sucessfully # # the following are global so that parsefile is quicker FindUniString = re.compile( '^#string[ \t]+([A-Z_0-9]+)(?:[ \t\r\n]+#language[ \t]+[a-zA-Z-]{2,5}[ \t\r\n]+".*"[ \t]*[\r]?[\n]?)*', re.M).findall OtherLang = re.compile( '^#string[ \t]+[A-Z_0-9]+(?:[ \t\r\n]+#language[ \t]+[a-zA-Z-]{2,5}[ \t\r\n]+".*"[ \t]*[\r]?[\n]?)*', re.M).findall EachLang = re.compile('[ \t\r\n]+#language[ \t]+([a-zA-Z-]{2,5})[ \t\r\n]+".*"[ \t]*[\r]?[\n]?').findall UqiStrings = re.compile('^#string[ \t]+[A-Z_0-9]+[ \t]+#language[ \t]+uqi[ \t\r\n]+".*"[ \t]*[\r]?[\n]?', re.M) def parsefile(path, Filename): global Options, StringDict, AllUqis, UqiList, FindUniString, OtherLang, EachLang, UqiStrings FullPath = path + os.sep + Filename try: UniEncoding = GetUniFileEncoding(FullPath) with codecs.open(FullPath, 'r', UniEncoding) as UniFile: Databuffer = UniFile.read() except: print("Error opening " + FullPath + " for reading.") return WriteFile = False if os.path.isdir(Options['Destname']): DestFileName = Options['Destname'] + os.sep + 'UqiList.uni' else: DestFileName = Options['Destname'] if Options['LangOption']: try: UqiEncoding = GetUniFileEncoding(DestFileName) with codecs.open(DestFileName, 'r+', UqiEncoding) as OutputFile: PlatformUQI = OutputFile.read() except IOError as e: print("ERROR: " + e.args[1]) if (e.args[0] == 2): try: with codecs.open(DestFileName, 'w', UqiEncoding) as OutputFile: print(DestFileName + " did not exist. Creating new file.") PlatformUQI = FileHeader except: print("Error creating " + DestFileName + ".") return else: print("Error opening " + DestFileName + " for appending.") return if (Filename != DestFileName.split(os.sep)[-1]): Uqis = re.findall(UqiStrings, Databuffer) if Uqis: for Uqi in Uqis: PlatformUQI += Uqi with codecs.open(DestFileName, 'r+', UqiEncoding) as OutputFile: OutputFile.seek(0) OutputFile.write(PlatformUQI) Databuffer = re.sub(UqiStrings, '', Databuffer) if Uqis: WriteFile = True print("Deleted uqis from %s" % FullPath) stringlist = OtherLang(Databuffer) for stringfound in stringlist: ThisString = EachLang(stringfound) for LanguageFound in ThisString: if ((LanguageFound != 'en') and (LanguageFound != 'en-US') and (LanguageFound != 'eng') and ( LanguageFound != 'uqi')): Databuffer = re.sub(re.escape(stringfound), '', Databuffer) WriteFile = True print("Deleted %s from %s" % (LanguageFound, FullPath)) if (Filename != DestFileName.split(os.sep)[-1]): # adding strings to dictionary StringDict[r'%s' % FullPath] = FindUniString(Databuffer) # adding UQIs to dictionary AllUqis[r'%s' % FullPath] = UqiList(Databuffer) if WriteFile: try: with codecs.open(FullPath, 'w', UniEncoding) as UniFile: UniFile.write(Databuffer) except: print("Error opening " + FullPath + " for writing.") return # ********************************************************************** # description: Searches tree for uni files # Calls parsefile to collect dictionary of strings in each uni file # Calls searchVfiFile for each vfi or vfr file found # # arguments: argument list is built by os.path.walk function call # arg - None # dirname - directory location of files # names - specific files to search in directory # # returns: none # def processUni(args, dirname, names): global Options # Remove excludedDirectory if Options['ExcludeOption']: for EachExDir in Options['ExPathList']: for dir in names: if os.path.join(dirname, dir) == EachExDir: names.remove(dir) for entry in names: FullPath = dirname + os.sep + entry if fnmatch.fnmatch(FullPath, '*.uni'): parsefile(dirname, entry) if fnmatch.fnmatch(FullPath, '*.vf*'): searchVfiFile(FullPath) if fnmatch.fnmatch(FullPath, '*.sd'): searchVfiFile(FullPath) if fnmatch.fnmatch(FullPath, '*.sdi'): searchVfiFile(FullPath) if fnmatch.fnmatch(FullPath, '*.hfr'): searchVfiFile(FullPath) return # ********************************************************************** # description: Compose a dictionary of all strings that may need UQIs assigned # to them and key is the string # # arguments: Filename - name of file to search for strings # # returns: none # # separate regexes for readability StringGroups = re.compile( '^[ \t]*(?:oneof|numeric|checkbox|orderedlist)[ \t]+varid.+?(?:endoneof|endnumeric|endcheckbox|endorderedlist);', re.DOTALL | re.M).findall StringVarIds = re.compile( '[ \t]*(?:oneof|numeric|checkbox|orderedlist)[ \t]+varid[ \t]*=[ \t]*([a-zA-Z_0-9]+\.[a-zA-Z_0-9]+)').findall StringTokens = re.compile('prompt[ \t]*=[ \t]*STRING_TOKEN[ \t]*\(([a-zA-Z_0-9]+)\)').findall def searchVfiFile(Filename): global Options, GlobalVarId, StringGroups, StringVarIds, StringTokens, QuestionError try: with open(Filename, 'r') as VfiFile: Databuffer = VfiFile.read() # Finds specified lines in file VfiStringGroup = StringGroups(Databuffer) # Searches for prompts within specified lines for EachGroup in VfiStringGroup: for EachString in StringTokens(EachGroup): # Ignore strings defined as STRING_TOKEN(0), STRING_TOKEN(STR_EMPTY) or STRING_TOKEN(STR_NULL) if (EachString != "0") and (EachString != "STR_EMPTY") and (EachString != "STR_NULL"): if EachString not in GlobalVarId: GlobalVarId[EachString] = StringVarIds(EachGroup) else: if (GlobalVarId[EachString][0] != StringVarIds(EachGroup)[0]): if Options['QuestionOption']: if Options['QuestionOption'] == "e": QuestionError = True print("ERROR:"), if Options['QuestionOption'] == "w": print("WARNING:"), print("%s referred by different HII questions(%s and %s)" % ( EachString, GlobalVarId[EachString][0], StringVarIds(EachGroup)[0])) except: print("Error opening file at %s for reading." % Filename) if __name__ == '__main__': sys.exit(main())
edk2-platforms-master
Platform/Intel/Tools/UniTool/UniTool.py
## @file # # Copyright (c) 2017, Intel Corporation. All rights reserved.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # ''' AmlGenOffset ''' import os import sys import argparse import subprocess import uuid import struct import collections import binascii import re from ctypes import * # # Globals for help information # __prog__ = 'AmlGenOffset' __version__ = '%s Version %s' % (__prog__, '0.1 ') __copyright__ = 'Copyright (c) 2017, Intel Corporation. All rights reserved.' __usage__ = '%s -e|-d [options] <input_file>' % (__prog__) if __name__ == '__main__': # # Create command line argument parser object # parser = argparse.ArgumentParser(prog=__prog__, usage=__usage__, description=__copyright__, conflict_handler='resolve') group = parser.add_mutually_exclusive_group(required=True) group.add_argument("-e", action="store_true", dest='Encode', help='encode file') group.add_argument("-d", action="store_true", dest='Decode', help='decode file') parser.add_argument("-o", "--output", dest='OutputFileName', type=str, metavar='filename', help="specify the output filename", required=True) parser.add_argument("-v", "--verbose", dest='Verbose', action="store_true", help="increase output messages") parser.add_argument("-q", "--quiet", dest='Quiet', action="store_true", help="reduce output messages") parser.add_argument("--debug", dest='Debug', type=int, metavar='[0-9]', choices=range(0,10), default=0, help="set debug level") parser.add_argument("--aml_filter", dest='AmlFilterStr', type=str, help="specify the AML filter.") parser.add_argument(metavar="input_file", dest='InputFile', type=argparse.FileType('r'), help="specify the input filename") # # Parse command line arguments # args = parser.parse_args() if args.Encode: print('Unsupported') if args.Decode: args.OutputFileName = os.path.normpath(args.OutputFileName) args.OutputFile = open(args.OutputFileName, 'w') AmlFilter = args.AmlFilterStr filter_pattern = '|'.join(AmlFilter.split(' ')) lines = args.InputFile.readlines() args.InputFile.close() for line in lines: if line.strip().startswith('{\"') == False: if line.strip().startswith('* Compilation') == False and line.strip().startswith('* ASL+') == False and line.strip().startswith('* Copyright') == False: args.OutputFile.write(line) else: match_obj = re.search(filter_pattern, line, re.M | re.I) if match_obj is not None: args.OutputFile.write(line) args.OutputFile.close()
edk2-platforms-master
Platform/Intel/MinPlatformPkg/Tools/AmlGenOffset/AmlGenOffset.py
## @ RebaseFspBinBaseAddress.py # # Copyright (c) 2019 - 2021, Intel Corporation. All rights reserved.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # import os import sys import re import subprocess if len(sys.argv) not in [5,6]: print ("RebaseFspBinBaseAddress.py - Error in number of arguments received") print ("Usage - RebaseFspBinBaseAddress.py <FlashMap file path> <FspBinPkg Folder> <Fsp.fd file name>\ <pad_offset for Fsp-S Base Address> <OPTIONAL SplitFspBin.py tool path>") exit(1) flashMapName = sys.argv[1] fspBinPath = sys.argv[2] fspBinFile = sys.argv[3] fvOffset = int(sys.argv[4], 16) fspBinFileRebased = "Fsp_Rebased.fd" splitFspBinPath = os.path.join("edk2","IntelFsp2Pkg","Tools","SplitFspBin.py") if len(sys.argv) == 6: splitFspBinPath = sys.argv[5] # # Make sure argument passed or valid # if not os.path.exists(flashMapName): print ("WARNING! " + str(flashMapName) + " is not found.") exit(1) fspBinFilePath = fspBinPath + os.sep + fspBinFile if not os.path.exists(fspBinFilePath): print ("WARNING! " + str(fspBinFilePath) + " is not found.") exit(1) if not os.path.exists(splitFspBinPath): print ("WARNING! " + str(splitFspBinPath) + " is not found.") exit(1) # # Get the FSP-S / FSP-M-T FV Base Address from Flash Map # file = open (flashMapName, "r") data = file.read () # Get the Flash Base Address flashBase = int(data.split("FLASH_BASE")[1].split("=")[1].split()[0], 16) # Based on Build Target, select the section in the FlashMap file flashmap = data # Get FSP-S & FSP-M & FSP-T offset & calculate the base for line in flashmap.split("\n"): if "PcdFlashFvFspSOffset" in line: fspSBaseOffset = int(line.split("=")[1].split()[0], 16) if "PcdFlashFvFspMOffset" in line: fspMBaseOffset = int(line.split("=")[1].split()[0], 16) if "PcdFlashFvFspTOffset" in line: fspTBaseOffset = int(line.split("=")[1].split()[0], 16) file.close() # # Get FSP-M Size, in order to calculate the FSP-T Base. Used SplitFspBin.py script # to dump the header, and get the ImageSize in FSP-M section # pythontool = 'python' if 'PYTHON_HOME' in os.environ: pythontool = os.environ['PYTHON_HOME'] + os.sep + 'python' else: pythontool = sys.executable Process = subprocess.Popen([pythontool, splitFspBinPath, "info","-f",fspBinFilePath], stdout=subprocess.PIPE) Output = Process.communicate()[0] FsptInfo = Output.rsplit(b"FSP_M", 1); for line in FsptInfo[1].split(b"\n"): if b"ImageSize" in line: fspMSize = int(line.split(b"=")[1], 16) break # Calculate FSP-S/M/T base address, to which re-base has to be done fspSBaseAddress = flashBase + fspSBaseOffset + fvOffset fspMBaseAddress = flashBase + fspMBaseOffset fspTBaseAddress = flashBase + fspTBaseOffset # # Re-base FSP bin file to new address and save it as fspBinFileRebased using SplitFspBin.py # rebaseArguments = fspBinFilePath + " -c s m t -b " + str(hex(fspSBaseAddress).rstrip("L")) + " " + str(hex(fspMBaseAddress).rstrip("L")) + " " + str(hex(fspTBaseAddress).rstrip("L")) + " -o" + fspBinPath + " -n " + fspBinFileRebased os.system('"' + pythontool + '"' + " " + splitFspBinPath + " rebase -f" + rebaseArguments) # # Split FSP bin to FSP-S/M/T segments # splitArguments = fspBinPath + os.sep + fspBinFileRebased + " -o " + fspBinPath + " -n Fsp_Rebased.fd" os.system('"' + pythontool + '"' + " " + splitFspBinPath + " split -f" + splitArguments) exit(0)
edk2-platforms-master
Platform/Intel/MinPlatformPkg/Tools/Fsp/RebaseFspBinBaseAddress.py
## @ PatchFspBinBaseAddress.py # # Copyright (c) 2017, Intel Corporation. All rights reserved.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # ## import os import re import sys import struct from datetime import date fspSBaseAddress = 0 fspMBaseAddress = 0 fspTBaseAddress = 0 def GetFspBaseAddress (binfile): offset = 0; for index in range(1,4): attribute = readDataFromFile(binfile, offset+0xB7, 1) >> 4 if attribute == 0x3: global fspSBaseAddress fspSBaseAddress = readDataFromFile(binfile, offset+0xB0, 4) if attribute == 0x2: global fspMBaseAddress fspMBaseAddress = readDataFromFile(binfile, offset+0xB0, 4) if attribute == 0x1: global fspTBaseAddress fspTBaseAddress = readDataFromFile(binfile, offset+0xB0, 4) offset += readDataFromFile(binfile, offset+0xAC, 4) return 0 # # Read data from file # # param [in] binfile Binary file # param [in] offset Offset # param [in] len Length # # retval value Value # def readDataFromFile (binfile, offset, len=1): fd = open(binfile, "rb") fsize = os.path.getsize(binfile) offval = offset & 0xFFFFFFFF if (offval & 0x80000000): offval = fsize - (0xFFFFFFFF - offval + 1) fd.seek(offval) bytearray = [ord(b) for b in fd.read(len)] value = 0 idx = len - 1 while idx >= 0: value = value << 8 | bytearray[idx] idx = idx - 1 fd.close() return value def updateFspFvsBase (binfile, TargetFile): ext_file = str(os.path.splitext(TargetFile)[-1]).lower() if not os.path.exists(binfile): print "WARNING! " + str(binfile) + " is not found." return 1 if not os.path.exists(TargetFile): print "WARNING! " + str(TargetFile) + " is not found." return 1 GetFspBaseAddress(binfile) if ext_file == ".dsc": DscFile = open(TargetFile, "r") DscLines = DscFile.readlines() DscFile.close() DscContent = [] for line in DscLines: DscContent.append(line) DscFile = open(TargetFile,"w") for index in range(len(DscContent)): DscLine = DscContent[index] Match = re.match("([_a-zA-Z0-9]+).Pcd(Fspt|Fspm|Fsps)BaseAddress",DscLine) if Match: DscLine = Match.group(1) + ".Pcd" + Match.group(2) + "BaseAddress|0x" if Match.group(2) == 'Fspt': BaseAddrStr = str(hex(fspTBaseAddress)[2:]).zfill(8).upper().rstrip('L') elif Match.group(2) == 'Fspm': BaseAddrStr = str(hex(fspMBaseAddress)[2:]).zfill(8).upper().rstrip('L') elif Match.group(2) == 'Fsps': BaseAddrStr = str(hex(fspSBaseAddress)[2:]).zfill(8).upper().rstrip('L') DscLine = DscLine + BaseAddrStr + "\n" DscFile.writelines(DscLine) DscFile.close() return 0 def Main(): # # Parse the options and args # if len(sys.argv) != 3: print "error" return 1 ret = updateFspFvsBase (sys.argv[1], sys.argv[2]) if ret != 0: return 1 return 0 if __name__ == '__main__': sys.exit(Main())
edk2-platforms-master
Platform/Intel/MinPlatformPkg/Tools/Fsp/PatchFspBinFvsBaseAddress.py
## @ RebaseAndPatchFspBinBaseAddress.py # # Copyright (c) 2017 - 2021, Intel Corporation. All rights reserved.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # import os import sys import re import subprocess if len(sys.argv) not in [6,7]: print ("RebaseAndPatchFspBinBaseAddress.py - Error in number of arguments received") print ("Usage - RebaseAndPatchFspBinBaseAddress.py <FlashMap file path> <FspBinPkg Folder> <Fsp.fd file name>\ <Dsc file path to be patched> <pad_offset for Fsp-S Base Address> <OPTIONAL SplitFspBin.py tool path>") exit(1) flashMapName = sys.argv[1] fspBinPath = sys.argv[2] fspBinFile = sys.argv[3] targetDscFile = sys.argv[4] fvOffset = int(sys.argv[5], 16) fspBinFileRebased = "Fsp_Rebased.fd" splitFspBinPath = os.path.join("edk2","IntelFsp2Pkg","Tools","SplitFspBin.py") if len(sys.argv) == 7: splitFspBinPath = sys.argv[6] # # Make sure argument passed or valid # if not os.path.exists(flashMapName): print ("WARNING! " + str(flashMapName) + " is not found.") exit(1) fspBinFilePath = fspBinPath + os.sep + fspBinFile if not os.path.exists(fspBinFilePath): print ("WARNING! " + str(fspBinFilePath) + " is not found.") exit(1) if not os.path.exists(targetDscFile): print ("WARNING! " + str(targetDscFile) + " is not found.") exit(1) ext_file = str(os.path.splitext(targetDscFile)[-1]).lower() if ext_file != ".dsc": print ("WARNING! " + str(targetDscFile) + " is not a dsc file") exit(1) if not os.path.exists(splitFspBinPath): print ("WARNING! " + str(splitFspBinPath) + " is not found.") exit(1) # # Get the FSP-S / FSP-M-T FV Base Address from Flash Map # file = open (flashMapName, "r") data = file.read () # Get the Flash Base Address flashBase = int(data.split("FLASH_BASE")[1].split("=")[1].split()[0], 16) # Based on Build Target, select the section in the FlashMap file flashmap = data # Get FSP-S & FSP-M & FSP-T offset & calculate the base for line in flashmap.split("\n"): if "PcdFlashFvFspSOffset" in line: fspSBaseOffset = int(line.split("=")[1].split()[0], 16) if "PcdFlashFvFspMOffset" in line: fspMBaseOffset = int(line.split("=")[1].split()[0], 16) if "PcdFlashFvFspTOffset" in line: fspTBaseOffset = int(line.split("=")[1].split()[0], 16) file.close() # # Get FSP-M Size, in order to calculate the FSP-T Base. Used SplitFspBin.py script # to dump the header, and get the ImageSize in FSP-M section # pythontool = sys.executable Process = subprocess.Popen([pythontool, splitFspBinPath, "info","-f",fspBinFilePath], stdout=subprocess.PIPE) Output = Process.communicate()[0] FsptInfo = Output.rsplit(b"FSP_M", 1); for line in FsptInfo[1].split(b"\n"): if b"ImageSize" in line: fspMSize = int(line.split(b"=")[1], 16) break # Calculate FSP-S/M/T base address, to which re-base has to be done fspSBaseAddress = flashBase + fspSBaseOffset + fvOffset fspMBaseAddress = flashBase + fspMBaseOffset fspTBaseAddress = flashBase + fspTBaseOffset # # Re-base FSP bin file to new address and save it as fspBinFileRebased using SplitFspBin.py # rebaseArguments = fspBinFilePath + " -c s m t -b " + str(hex(fspSBaseAddress).rstrip("L")) + " " + str(hex(fspMBaseAddress).rstrip("L")) + " " + str(hex(fspTBaseAddress).rstrip("L")) + " -o" + fspBinPath + " -n " + fspBinFileRebased os.system('"' + pythontool + '"' + " " + splitFspBinPath + " rebase -f" + rebaseArguments) # # Split FSP bin to FSP-S/M/T segments # splitArguments = fspBinPath + os.sep + fspBinFileRebased + " -o " + fspBinPath + " -n Fsp_Rebased.fd" os.system('"' + pythontool + '"' + " " + splitFspBinPath + " split -f" + splitArguments) # # Patch dsc file with the re-based FSP-S/M/T address, so internally build will use the same. # DscFile = open(targetDscFile, "r") DscLines = DscFile.readlines() DscFile.close() DscContent = [] for line in DscLines: DscContent.append(line) DscFile = open(targetDscFile,"w") for index in range(len(DscContent)): DscLine = DscContent[index] Match = re.match("([\s_a-zA-Z0-9]+).Pcd(Fspt|Fspm|Fsps)BaseAddress",DscLine) if Match: DscLine = Match.group(1) + ".Pcd" + Match.group(2) + "BaseAddress|0x" if Match.group(2) == 'Fspt': BaseAddrStr = str(hex(fspTBaseAddress)[2:]).zfill(8).upper().rstrip('L') elif Match.group(2) == 'Fspm': BaseAddrStr = str(hex(fspMBaseAddress)[2:]).zfill(8).upper().rstrip('L') elif Match.group(2) == 'Fsps': BaseAddrStr = str(hex(fspSBaseAddress)[2:]).zfill(8).upper().rstrip('L') DscLine = DscLine + BaseAddrStr + "\n" DscFile.writelines(DscLine) DscFile.close() exit(0)
edk2-platforms-master
Platform/Intel/MinPlatformPkg/Tools/Fsp/RebaseAndPatchFspBinBaseAddress.py
## @ SyncBinFvInf.py # # Copyright (c) 2017, Intel Corporation. All rights reserved.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # ## import os import re import sys import time import shutil from ctypes import * class GUID(Structure): _fields_ = [ ('Guid1', c_uint32), ('Guid2', c_uint16), ('Guid3', c_uint16), ('Guid4', ARRAY(c_uint8, 8)), ] class EFI_FIRMWARE_VOLUME_HEADER(Structure): _fields_ = [ ('ZeroVector', ARRAY(c_uint8, 16)), ('FileSystemGuid', GUID), ('FvLength', c_uint64), ('Signature', c_uint32), ('Attributes', c_uint32), ('HeaderLength', c_uint16), ('Checksum', c_uint16), ('ExtHeaderOffset', c_uint16), ('Reserved', c_uint8), ('Revision', c_uint8), ] # # File Types Definitions # EFI_FV_FILETYPE_ALL = 0x00 EFI_FV_FILETYPE_RAW = 0x01 EFI_FV_FILETYPE_FREEFORM = 0x02 EFI_FV_FILETYPE_SECURITY_CORE = 0x03 EFI_FV_FILETYPE_PEI_CORE = 0x04 EFI_FV_FILETYPE_DXE_CORE = 0x05 EFI_FV_FILETYPE_PEIM = 0x06 EFI_FV_FILETYPE_DRIVER = 0x07 EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER = 0x08 EFI_FV_FILETYPE_APPLICATION = 0x09 EFI_FV_FILETYPE_SMM = 0x0A EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE = 0x0B EFI_FV_FILETYPE_COMBINED_SMM_DXE = 0x0C EFI_FV_FILETYPE_SMM_CORE = 0x0D EFI_FV_FILETYPE_OEM_MIN = 0xc0 EFI_FV_FILETYPE_OEM_MAX = 0xdf EFI_FV_FILETYPE_DEBUG_MIN = 0xe0 EFI_FV_FILETYPE_DEBUG_MAX = 0xef EFI_FV_FILETYPE_FFS_MIN = 0xf0 EFI_FV_FILETYPE_FFS_MAX = 0xff EFI_FV_FILETYPE_FFS_PAD = 0xf0 # # FFS File Attributes. # FFS_ATTRIB_LARGE_FILE = 0x01 FFS_ATTRIB_DATA_ALIGNMENT_2 = 0x02 FFS_ATTRIB_FIXED = 0x04 FFS_ATTRIB_DATA_ALIGNMENT = 0x38 FFS_ATTRIB_CHECKSUM = 0x40 # # FFS File State Bits. # EFI_FILE_HEADER_CONSTRUCTION = 0x01 EFI_FILE_HEADER_VALID = 0x02 EFI_FILE_DATA_VALID = 0x04 EFI_FILE_MARKED_FOR_UPDATE = 0x08 EFI_FILE_DELETED = 0x10 EFI_FILE_HEADER_INVALID = 0x20 class EFI_FFS_FILE_HEADER(Structure): _fields_ = [ ('Name', GUID), ('IntegrityCheck', c_uint16), ('Type', c_uint8), ('Attributes', c_uint8), ('Size', ARRAY(c_uint8, 3)), ('State', c_uint8), ] class EFI_FFS_FILE_HEADER2(Structure): _fields_ = [ ('Name', GUID), ('IntegrityCheck', c_uint16), ('Type', c_uint8), ('Attributes', c_uint8), ('Size', ARRAY(c_uint8, 3)), ('State', c_uint8), ('ExtendedSize', c_uint64), ] # # Pseudo type. It is used as a wild card when retrieving sections. # The section type EFI_SECTION_ALL matches all section types. # EFI_SECTION_ALL = 0x00 # # Encapsulation section Type values. # EFI_SECTION_COMPRESSION = 0x01 EFI_SECTION_GUID_DEFINED = 0x02 EFI_SECTION_DISPOSABLE = 0x03 # # Leaf section Type values. # EFI_SECTION_PE32 = 0x10 EFI_SECTION_PIC = 0x11 EFI_SECTION_TE = 0x12 EFI_SECTION_DXE_DEPEX = 0x13 EFI_SECTION_VERSION = 0x14 EFI_SECTION_USER_INTERFACE = 0x15 EFI_SECTION_COMPATIBILITY16 = 0x16 EFI_SECTION_FIRMWARE_VOLUME_IMAGE = 0x17 EFI_SECTION_FREEFORM_SUBTYPE_GUID = 0x18 EFI_SECTION_RAW = 0x19 EFI_SECTION_PEI_DEPEX = 0x1B EFI_SECTION_SMM_DEPEX = 0x1C class EFI_COMMON_SECTION_HEADER(Structure): _fields_ = [ ('Size', ARRAY(c_uint8, 3)), ('Type', c_uint8), ] class EFI_COMMON_SECTION_HEADER2(Structure): _fields_ = [ ('Size', ARRAY(c_uint8, 3)), ('Type', c_uint8), ('ExtendedSize', c_uint32), ] class FileChecker: def __init__(self): self.SyncSectionList = ["Packages", "PatchPcd", "PcdEx"] self.RebasePcd = ["", "", ""] self.FvName = "" self.FfsGuidList = [] self.FfsInfList = [] self.FfsOffsetList = [] self.PeOffsetList = [] self.target = "" self.sourceRoot = "" self.sourceInfList = [] self.destRoot = "" self.reportFile = "" def GetSectionName(self, line): splitLine = line[1:-1].split(".") return splitLine[0] def IsSyncSection(self, line): name = self.GetSectionName(line) for sectionName in self.SyncSectionList: if (cmp (sectionName, name) == 0) : return True return False def PrintRebasePcd(self, pcd): if cmp (pcd[0], "") != 0: print "PCD: " + pcd[0] + "|" + pcd[1] + "(" + pcd[2] + ")" def PrintList(self, fileList): for file in fileList: print file def GetFileList(self, dir, fileList, checkFunc): if os.path.isdir(dir): for sub in os.listdir(dir): if sub[0] == "." : continue newDir = os.path.join(dir,sub) if (os.path.isdir(newDir) == True): self.GetFileList(newDir, fileList, checkFunc) else : AppendName = checkFunc (newDir) if cmp (AppendName, "") != 0: #print "AppendName = " + AppendName if AppendName not in fileList: fileList.append(AppendName) def GetInfFileGuid(self, fileName): guid = "" try : file = open(fileName) except Exception: print "fail to open " + fileName return try: while 1: line = file.readline() if not line: break newline = line[:-1] if cmp (line[:11], " FILE_GUID") == 0: splitLine = line.split("=") templine = splitLine[1] guid = templine[1:1+36] finally: file.close() return guid def GetInfNameFromGuid(self, fileList, guid): for file in fileList: fileGuid = self.GetInfFileGuid (file) if (cmp (fileGuid.upper(), guid.upper()) == 0) : return file return "" def CheckSourceInf(self, file): if (cmp (file[-4:], ".inf") == 0) and (file.find("BinPkg") != -1) and (file.find(self.target) != -1) and (file.find("FVFSP") == -1): return file return "" def ParseInfFile(self, fileName, destFile, Offset): SyncToDest = False PatchOffset = False try : file = open(fileName) except Exception: print "fail to open " + fileName return try: while 1: line = file.readline() if not line: break newline = line[:-1] if cmp (line[0], "[") == 0: SyncToDest = self.IsSyncSection(line) PatchOffset = False if SyncToDest == True : if (cmp (self.GetSectionName(line), "PatchPcd") == 0) : PatchOffset = True if (PatchOffset == True) and ('|' in line) : splitLine = line.split("|") destFile.writelines(splitLine[0] + "|" + splitLine[1] + "|") DataOffset = int(splitLine[2], 16) DataOffset = DataOffset + int(Offset, 16) destFile.writelines(hex(DataOffset)) destFile.writelines(" # " + splitLine[2][:-1] + "+" + Offset + "\n") else : destFile.writelines(line) else : destFile.write("# ") destFile.writelines(line) finally: file.close() return def ParseInfFiles(self, fileList, FfsOffsetList, destFileName, RebasePcd): try : destFile = open(destFileName, "a") except Exception: print "fail to open " + destFileName return try: if cmp (RebasePcd[0], "") != 0 : destFile.write("\n#![Pcd]\n") destFile.write("#! ") destFile.write(RebasePcd[0]) destFile.write("|") destFile.write(RebasePcd[1]) destFile.write("\n\n") index = 0 for file in fileList: if (cmp (file, "") == 0) : index = index + 1 continue print "handling - (" + str(index) + ") :" + file self.ParseInfFile (file, destFile, FfsOffsetList[index]) index = index + 1 finally: destFile.close() return def GetGuildFfsGuidList(self, fileName): self.FfsGuidList = [] self.FfsOffsetList = [] try : file = open(fileName) except Exception: print "fail to open " + fileName return try: while 1: line = file.readline() if not line: break #0x000D4868 A8499E65-A6F6-48B0-96DB-45C266030D83 MatchString = "(0x[0-9a-fA-F]{8}) ([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})" match = re.match(MatchString, line) if match is not None: offset = match.group(1) self.FfsOffsetList.append(offset) ffsGuid = match.group(2) self.FfsGuidList.append(ffsGuid) finally: file.close() return def GetPeOffsetList(self, fileName): self.PeOffsetList = [] try : file = open(fileName, "rb") except Exception: print "fail to open " + fileName return try: FvBuffer = file.read() FvData = bytearray(FvBuffer) for FfsOffset in self.FfsOffsetList: PeOffsetFound = False PeOffset = int(FfsOffset, 16) FfsHeader = EFI_FFS_FILE_HEADER.from_buffer (FvData, PeOffset) FfsSize = FfsHeader.Size[0] + (FfsHeader.Size[1] << 8) + (FfsHeader.Size[2] << 16) PeOffset = PeOffset + sizeof(EFI_FFS_FILE_HEADER) while (PeOffset < int(FfsOffset, 16) + FfsSize) : SectionHeader = EFI_COMMON_SECTION_HEADER.from_buffer (FvData, PeOffset) if (SectionHeader.Type == EFI_SECTION_PE32) or (SectionHeader.Type == EFI_SECTION_TE) : PeOffset = PeOffset + sizeof(EFI_COMMON_SECTION_HEADER) self.PeOffsetList.append(hex(PeOffset)) PeOffsetFound = True break else: SectionSize = SectionHeader.Size[0] + (SectionHeader.Size[1] << 8) + (SectionHeader.Size[2] << 16) PeOffset = (PeOffset + SectionSize + 3) & ~0x3 if (PeOffsetFound == False): self.PeOffsetList.append(0) finally: file.close() return def ProcessFvInf(self, fvName, RebasePcd): destFile = os.path.join(self.destRoot,fvName+"\\"+self.target+"\\"+fvName+".Fv.txt") print "\nprocessing - " + destFile self.GetGuildFfsGuidList (destFile) #print "FfsGuidList" #self.PrintList(self.FfsGuidList) #print "FfsOffsetList" #self.PrintList(self.FfsOffsetList) destFile = os.path.join(self.destRoot,fvName+"\\"+self.target+"\\"+fvName+".Fv") self.GetPeOffsetList (destFile) #print "PeOffsetList" #self.PrintList(self.PeOffsetList) self.FfsInfList = [] for guid in self.FfsGuidList: fileName = self.GetInfNameFromGuid(self.sourceInfList, guid) print " adding - " + guid + " : " + fileName self.FfsInfList.append(fileName) #print "FfsInfList" #self.PrintList(self.FfsInfList) shutil.copy(os.path.join(self.destRoot,fvName+"\\"+self.target+"\\"+fvName+".Base.inf"),os.path.join(self.destRoot,fvName+"\\"+self.target+"\\"+fvName+".inf")) self.ParseInfFiles (self.FfsInfList, self.PeOffsetList, os.path.join(self.destRoot,fvName+"\\"+self.target+"\\"+fvName+".inf"), RebasePcd) def GetPcdFromReport(self, file, pcd): FoundPkg = False pcdSplit = pcd.split(".") TargetPkg = pcdSplit[0] TargetPcd = pcdSplit[1] while 1: line = file.readline() if not line: break newline = line[:-1] if (cmp (newline, TargetPkg) == 0): FoundPkg = True continue if (cmp (newline, "") == 0) or ((cmp (newline[0], " ") != 0) and (cmp (newline[0], "0") != 0)): FoundPkg = False if (FoundPkg == True) : newline = newline.strip() splitLine = newline.split(" ", 2) if (cmp (splitLine[0], "*F") == 0) or (cmp (splitLine[0], "*P") == 0): if (cmp (splitLine[1], TargetPcd) == 0): print "found - " + TargetPkg + "." + TargetPcd splitLine = splitLine[2].strip()[1:].strip().split(" ", 1) if (cmp (splitLine[0], "FIXED") == 0) or (cmp (splitLine[0], "PATCH") == 0): SplitLine = splitLine[1].strip()[1:].split(")", 1) Type = SplitLine[0] Value = SplitLine[1].strip()[1:].strip().split()[0] print " Type - (" + Type + "), Value - (" + Value + ")" return [Value, Type] return ["", ""] def GetRebaseAddressFromReport(self): try : file = open(self.reportFile) except Exception: print "fail to open " + self.reportFile return try: file.seek(0) if (cmp(self.RebasePcd[0], "") != 0): print "checking - " + self.RebasePcd[0] ValuePair = self.GetPcdFromReport (file, self.RebasePcd[0]) self.RebasePcd[1] = ValuePair[0] self.RebasePcd[2] = ValuePair[1] finally: file.close() def DumpFileList(self, dir): #print "DumpFileList - " + dir if os.path.exists(dir) == False: return if os.path.isdir(dir): for sub in os.listdir(dir): #print "Get sub - " + sub if sub[0] == "." : continue newDir = os.path.join(dir,sub) if (os.path.isdir(newDir) == True): self.DumpFileList(newDir) else : print "file - " + newDir def main(): global FileChecker fileChecker = FileChecker() if (len(sys.argv) != 6) and (len(sys.argv) != 7): print "usage: SyncBinFvInf <Target> <SourceRoot> <DestRoot> <ReportFile> <FspFvName> [<RebasePcdName>]" return 0 fileChecker.target = sys.argv[1] fileChecker.sourceRoot = sys.argv[2] fileChecker.destRoot = sys.argv[3] fileChecker.reportFile = sys.argv[4] fileChecker.FvName = sys.argv[5] if (len(sys.argv) == 7): fileChecker.RebasePcd[0] = sys.argv[6] fileChecker.GetRebaseAddressFromReport() fileChecker.PrintRebasePcd (fileChecker.RebasePcd) fileChecker.GetFileList (fileChecker.sourceRoot, fileChecker.sourceInfList, fileChecker.CheckSourceInf) fileChecker.ProcessFvInf (fileChecker.FvName, fileChecker.RebasePcd) if __name__ == '__main__': sys.exit(main())
edk2-platforms-master
Platform/Intel/MinPlatformPkg/Tools/PatchFv/SyncBinFvInf.py
## @ PatchBinFv.py # # Copyright (c) 2017 - 2019, Intel Corporation. All rights reserved.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # import os import re import sys import time import shutil import struct import binascii from ctypes import * class GUID(Structure): _fields_ = [ ('Guid1', c_uint32), ('Guid2', c_uint16), ('Guid3', c_uint16), ('Guid4', ARRAY(c_uint8, 8)), ] class EFI_FIRMWARE_VOLUME_HEADER(Structure): _fields_ = [ ('ZeroVector', ARRAY(c_uint8, 16)), ('FileSystemGuid', GUID), ('FvLength', c_uint64), ('Signature', c_uint32), ('Attributes', c_uint32), ('HeaderLength', c_uint16), ('Checksum', c_uint16), ('ExtHeaderOffset', c_uint16), ('Reserved', c_uint8), ('Revision', c_uint8), ] class EFI_FIRMWARE_VOLUME_EXT_HEADER(Structure): _fields_ = [ ('FvName', GUID), ('ExtHeaderSize', c_uint32), ] # # File Types Definitions # EFI_FV_FILETYPE_ALL = 0x00 EFI_FV_FILETYPE_RAW = 0x01 EFI_FV_FILETYPE_FREEFORM = 0x02 EFI_FV_FILETYPE_SECURITY_CORE = 0x03 EFI_FV_FILETYPE_PEI_CORE = 0x04 EFI_FV_FILETYPE_DXE_CORE = 0x05 EFI_FV_FILETYPE_PEIM = 0x06 EFI_FV_FILETYPE_DRIVER = 0x07 EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER = 0x08 EFI_FV_FILETYPE_APPLICATION = 0x09 EFI_FV_FILETYPE_SMM = 0x0A EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE = 0x0B EFI_FV_FILETYPE_COMBINED_SMM_DXE = 0x0C EFI_FV_FILETYPE_SMM_CORE = 0x0D EFI_FV_FILETYPE_OEM_MIN = 0xc0 EFI_FV_FILETYPE_OEM_MAX = 0xdf EFI_FV_FILETYPE_DEBUG_MIN = 0xe0 EFI_FV_FILETYPE_DEBUG_MAX = 0xef EFI_FV_FILETYPE_FFS_MIN = 0xf0 EFI_FV_FILETYPE_FFS_MAX = 0xff EFI_FV_FILETYPE_FFS_PAD = 0xf0 # # FFS File Attributes. # FFS_ATTRIB_LARGE_FILE = 0x01 FFS_ATTRIB_DATA_ALIGNMENT_2 = 0x02 FFS_ATTRIB_FIXED = 0x04 FFS_ATTRIB_DATA_ALIGNMENT = 0x38 FFS_ATTRIB_CHECKSUM = 0x40 # # FFS File State Bits. # EFI_FILE_HEADER_CONSTRUCTION = 0x01 EFI_FILE_HEADER_VALID = 0x02 EFI_FILE_DATA_VALID = 0x04 EFI_FILE_MARKED_FOR_UPDATE = 0x08 EFI_FILE_DELETED = 0x10 EFI_FILE_HEADER_INVALID = 0x20 class EFI_FFS_FILE_HEADER(Structure): _fields_ = [ ('Name', GUID), ('IntegrityCheck', c_uint16), ('Type', c_uint8), ('Attributes', c_uint8), ('Size', ARRAY(c_uint8, 3)), ('State', c_uint8), ] class EFI_FFS_FILE_HEADER2(Structure): _fields_ = [ ('Name', GUID), ('IntegrityCheck', c_uint16), ('Type', c_uint8), ('Attributes', c_uint8), ('Size', ARRAY(c_uint8, 3)), ('State', c_uint8), ('ExtendedSize', c_uint64), ] # # Pseudo type. It is used as a wild card when retrieving sections. # The section type EFI_SECTION_ALL matches all section types. # EFI_SECTION_ALL = 0x00 # # Encapsulation section Type values. # EFI_SECTION_COMPRESSION = 0x01 EFI_SECTION_GUID_DEFINED = 0x02 EFI_SECTION_DISPOSABLE = 0x03 # # Leaf section Type values. # EFI_SECTION_PE32 = 0x10 EFI_SECTION_PIC = 0x11 EFI_SECTION_TE = 0x12 EFI_SECTION_DXE_DEPEX = 0x13 EFI_SECTION_VERSION = 0x14 EFI_SECTION_USER_INTERFACE = 0x15 EFI_SECTION_COMPATIBILITY16 = 0x16 EFI_SECTION_FIRMWARE_VOLUME_IMAGE = 0x17 EFI_SECTION_FREEFORM_SUBTYPE_GUID = 0x18 EFI_SECTION_RAW = 0x19 EFI_SECTION_PEI_DEPEX = 0x1B EFI_SECTION_SMM_DEPEX = 0x1C class EFI_COMMON_SECTION_HEADER(Structure): _fields_ = [ ('Size', ARRAY(c_uint8, 3)), ('Type', c_uint8), ] class EFI_COMMON_SECTION_HEADER2(Structure): _fields_ = [ ('Size', ARRAY(c_uint8, 3)), ('Type', c_uint8), ('ExtendedSize', c_uint32), ] class EFI_FV_FILETYPE: ALL = 0x00 RAW = 0x01 FREEFORM = 0x02 SECURITY_CORE = 0x03 PEI_CORE = 0x04 DXE_CORE = 0x05 PEIM = 0x06 DRIVER = 0x07 COMBINED_PEIM_DRIVER = 0x08 APPLICATION = 0x09 SMM = 0x0a FIRMWARE_VOLUME_IMAGE = 0x0b COMBINED_SMM_DXE = 0x0c SMM_CORE = 0x0d OEM_MIN = 0xc0 OEM_MAX = 0xdf DEBUG_MIN = 0xe0 DEBUG_MAX = 0xef FFS_MIN = 0xf0 FFS_MAX = 0xff FFS_PAD = 0xf0 class EFI_SECTION_TYPE: ALL = 0x00 COMPRESSION = 0x01 GUID_DEFINED = 0x02 DISPOSABLE = 0x03 PE32 = 0x10 PIC = 0x11 TE = 0x12 DXE_DEPEX = 0x13 VERSION = 0x14 USER_INTERFACE = 0x15 COMPATIBILITY16 = 0x16 FIRMWARE_VOLUME_IMAGE = 0x17 FREEFORM_SUBTYPE_GUID = 0x18 RAW = 0x19 PEI_DEPEX = 0x1b SMM_DEPEX = 0x1c IMAGE_FILE_MACHINE_I386 = 0x014c IMAGE_FILE_MACHINE_X64 = 0x8664 EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC = 5 class EFI_IMAGE_DOS_HEADER(Structure): _fields_ = [ ('e_magic', c_uint16), ('e_cblp', c_uint16), ('e_cp', c_uint16), ('e_crlc', c_uint16), ('e_cparhdr', c_uint16), ('e_minalloc', c_uint16), ('e_maxalloc', c_uint16), ('e_ss', c_uint16), ('e_sp', c_uint16), ('e_csum', c_uint16), ('e_ip', c_uint16), ('e_cs', c_uint16), ('e_lfarlc', c_uint16), ('e_ovno', c_uint16), ('e_res', ARRAY(c_uint16, 4)), ('e_oemid', c_uint16), ('e_oeminfo', c_uint16), ('e_res2', ARRAY(c_uint16, 10)), ('e_lfanew', c_uint16) ] class EFI_IMAGE_DATA_DIRECTORY(Structure): _fields_ = [ ('VirtualAddress', c_uint32), ('Size', c_uint32) ] class EFI_IMAGE_FILE_HEADER(Structure): _fields_ = [ ('Machine', c_uint16), ('NumberOfSections', c_uint16), ('TimeDateStamp', c_uint32), ('PointerToSymbolTable', c_uint32), ('NumberOfSymbols', c_uint32), ('SizeOfOptionalHeader', c_uint16), ('Characteristics', c_uint16) ] class EFI_IMAGE_OPTIONAL_HEADER32(Structure): _fields_ = [ ('Magic', c_uint16), ('MajorLinkerVersion', c_uint8), ('MinorLinkerVersion', c_uint8), ('SizeOfCode', c_uint32), ('SizeOfInitializedData', c_uint32), ('SizeOfUninitializedData', c_uint32), ('AddressOfEntryPoint', c_uint32), ('BaseOfCode', c_uint32), ('BaseOfData', c_uint32), ('ImageBase', c_uint32), ('SectionAlignment', c_uint32), ('FileAlignment', c_uint32), ('MajorOperatingSystemVersion', c_uint16), ('MinorOperatingSystemVersion', c_uint16), ('MajorImageVersion', c_uint16), ('MinorImageVersion', c_uint16), ('MajorSubsystemVersion', c_uint16), ('MinorSubsystemVersion', c_uint16), ('Win32VersionValue', c_uint32), ('SizeOfImage', c_uint32), ('SizeOfHeaders', c_uint32), ('CheckSum' , c_uint32), ('Subsystem', c_uint16), ('DllCharacteristics', c_uint16), ('SizeOfStackReserve', c_uint32), ('SizeOfStackCommit' , c_uint32), ('SizeOfHeapReserve', c_uint32), ('SizeOfHeapCommit' , c_uint32), ('LoaderFlags' , c_uint32), ('NumberOfRvaAndSizes', c_uint32), ('DataDirectory', ARRAY(EFI_IMAGE_DATA_DIRECTORY, 16)) ] class EFI_IMAGE_OPTIONAL_HEADER64(Structure): _fields_ = [ ('Magic', c_uint16), ('MajorLinkerVersion', c_uint8), ('MinorLinkerVersion', c_uint8), ('SizeOfCode', c_uint32), ('SizeOfInitializedData', c_uint32), ('SizeOfUninitializedData', c_uint32), ('AddressOfEntryPoint', c_uint32), ('BaseOfCode', c_uint32), ('ImageBase', c_uint64), ('SectionAlignment', c_uint32), ('FileAlignment', c_uint32), ('MajorOperatingSystemVersion', c_uint16), ('MinorOperatingSystemVersion', c_uint16), ('MajorImageVersion', c_uint16), ('MinorImageVersion', c_uint16), ('MajorSubsystemVersion', c_uint16), ('MinorSubsystemVersion', c_uint16), ('Win32VersionValue', c_uint32), ('SizeOfImage', c_uint32), ('SizeOfHeaders', c_uint32), ('CheckSum' , c_uint32), ('Subsystem', c_uint16), ('DllCharacteristics', c_uint16), ('SizeOfStackReserve', c_uint64), ('SizeOfStackCommit' , c_uint64), ('SizeOfHeapReserve', c_uint64), ('SizeOfHeapCommit' , c_uint64), ('LoaderFlags' , c_uint32), ('NumberOfRvaAndSizes', c_uint32), ('DataDirectory', ARRAY(EFI_IMAGE_DATA_DIRECTORY, 16)) ] class EFI_IMAGE_NT_HEADERS32(Structure): _fields_ = [ ('Signature', c_uint32), ('FileHeader', EFI_IMAGE_FILE_HEADER), ('OptionalHeader', EFI_IMAGE_OPTIONAL_HEADER32) ] class EFI_IMAGE_NT_HEADERS64(Structure): _fields_ = [ ('Signature', c_uint32), ('FileHeader', EFI_IMAGE_FILE_HEADER), ('OptionalHeader', EFI_IMAGE_OPTIONAL_HEADER64) ] class EFI_IMAGE_SECTION_HEADER(Structure): _fields_ = [ ('Name', ARRAY(c_uint8, 8)), ('VirtualSize', c_uint32), ('VirtualAddress', c_uint32), ('SizeOfRawData', c_uint32), ('PointerToRawData', c_uint32), ('PointerToRelocations', c_uint32), ('PointerToLinenumbers', c_uint32), ('NumberOfRelocations', c_uint16), ('NumberOfLinenumbers', c_uint16), ('Characteristics', c_uint32), ] class EFI_TE_IMAGE_HEADER(Structure): _fields_ = [ ('Signature', ARRAY(c_char, 2)), ('Machine', c_uint16), ('NumberOfSections', c_uint8), ('Subsystem', c_uint8), ('StrippedSize', c_uint16), ('AddressOfEntryPoint', c_uint32), ('BaseOfCode', c_uint32), ('ImageBase', c_uint64), ('DataDirectoryBaseReloc', EFI_IMAGE_DATA_DIRECTORY), ('DataDirectoryDebug', EFI_IMAGE_DATA_DIRECTORY) ] class EFI_IMAGE_DIRECTORY_ENTRY: EXPORT = 0 IMPORT = 1 RESOURCE = 2 EXCEPTION = 3 SECURITY = 4 BASERELOC = 5 DEBUG = 6 COPYRIGHT = 7 GLOBALPTR = 8 TLS = 9 LOAD_CONFIG = 10 class PE_RELOC_BLOCK_HEADER(Structure): _fields_ = [ ('PageRVA', c_uint32), ('BlockSize', c_uint32) ] def AlignPtr (offset, alignment = 8): return (offset + alignment - 1) & ~(alignment - 1) def Bytes2Val (bytes): return reduce(lambda x,y: (x<<8)|y, bytes[::-1] ) def Val2Bytes (value, blen): return [(value>>(i*8) & 0xff) for i in range(blen)] class PeTeImage: def __init__(self, offset, data): self.Offset = offset tehdr = EFI_TE_IMAGE_HEADER.from_buffer (data, 0) if tehdr.Signature == 'VZ': # TE image self.TeHdr = tehdr elif tehdr.Signature == 'MZ': # PE32 image self.TeHdr = None self.DosHdr = EFI_IMAGE_DOS_HEADER.from_buffer (data, 0) self.PeHdr = EFI_IMAGE_NT_HEADERS32.from_buffer (data, self.DosHdr.e_lfanew) if self.PeHdr.Signature != 0x4550: raise Exception("ERROR: Invalid PE32 header !") if self.PeHdr.FileHeader.SizeOfOptionalHeader < EFI_IMAGE_OPTIONAL_HEADER32.DataDirectory.offset: raise Exception("ERROR: Unsupported PE32 image !") if self.PeHdr.OptionalHeader.NumberOfRvaAndSizes <= EFI_IMAGE_DIRECTORY_ENTRY.BASERELOC: raise Exception("ERROR: No relocation information available !") self.Offset = offset self.Data = data self.RelocList = [] def IsTeImage(self): return self.TeHdr is not None def ParseReloc(self): if self.IsTeImage(): rsize = self.TeHdr.DataDirectoryBaseReloc.Size roffset = sizeof(self.TeHdr) - self.TeHdr.StrippedSize + self.TeHdr.DataDirectoryBaseReloc.VirtualAddress else: rsize = self.PeHdr.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY.BASERELOC].Size roffset = self.PeHdr.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY.BASERELOC].VirtualAddress alignment = 4 offset = roffset while offset < roffset + rsize: offset = AlignPtr(offset, 4) blkhdr = PE_RELOC_BLOCK_HEADER.from_buffer(self.Data, offset) offset += sizeof(blkhdr) # Read relocation type,offset pairs rlen = blkhdr.BlockSize - sizeof(PE_RELOC_BLOCK_HEADER) rnum = rlen/sizeof(c_uint16) rdata = (c_uint16 * rnum).from_buffer(self.Data, offset) for each in rdata: roff = each & 0xfff rtype = each >> 12 if rtype == 0: # IMAGE_REL_BASED.ABSOLUTE: continue if rtype != 3: # IMAGE_REL_BASED_HIGHLOW raise Exception("ERROR: Unsupported relocation type %d!" % rtype) # Calculate the offset of the relocation aoff = blkhdr.PageRVA + roff if self.IsTeImage(): aoff += sizeof(self.TeHdr) - self.TeHdr.StrippedSize self.RelocList.append((rtype, aoff)) offset += sizeof(rdata) def Rebase(self, delta, fdbin): count = 0 if delta == 0: return count for (rtype, roff) in self.RelocList: if rtype == 0x03: # HIGHLOW offset = roff + self.Offset value = Bytes2Val(fdbin[offset:offset+sizeof(c_uint32)]) value += delta fdbin[offset:offset+sizeof(c_uint32)] = Val2Bytes(value, sizeof(c_uint32)) count += 1 else: raise Exception('ERROR: Unknown relocation type %d !' % rtype) if self.IsTeImage(): offset = self.Offset + EFI_TE_IMAGE_HEADER.ImageBase.offset size = EFI_TE_IMAGE_HEADER.ImageBase.size else: offset = self.Offset + self.DosHdr.e_lfanew offset += EFI_IMAGE_NT_HEADERS32.OptionalHeader.offset offset += EFI_IMAGE_OPTIONAL_HEADER32.ImageBase.offset size = EFI_IMAGE_OPTIONAL_HEADER32.ImageBase.size value = Bytes2Val(fdbin[offset:offset+size]) + delta fdbin[offset:offset+size] = Val2Bytes(value, size) return count class Section: def __init__(self, offset, secdata): self.SecHdr = EFI_COMMON_SECTION_HEADER.from_buffer (secdata, 0) self.SecData = secdata[0:int(self.SecHdr.Size)] self.Offset = offset class FirmwareFile: def __init__(self, offset, filedata): self.FfsHdr = EFI_FFS_FILE_HEADER.from_buffer (filedata, 0) self.FfsData = filedata[0:int(self.FfsHdr.Size)] self.Offset = offset self.SecList = [] def ParseFfs(self): ffssize = len(self.FfsData) offset = sizeof(self.FfsHdr) if self.FfsHdr.Name != '\xff' * 16: while offset < ffssize: sechdr = EFI_COMMON_SECTION_HEADER.from_buffer (self.FfsData, offset) sec = Section (offset, self.FfsData[offset:offset + int(sechdr.Size)]) self.SecList.append(sec) offset += int(sechdr.Size) offset = AlignPtr(offset, 4) class FirmwareVolume: def __init__(self, offset, fvdata): self.FvHdr = EFI_FIRMWARE_VOLUME_HEADER.from_buffer (fvdata, 0) self.FvData = fvdata[0 : self.FvHdr.FvLength] self.Offset = offset if self.FvHdr.ExtHeaderOffset > 0: self.FvExtHdr = EFI_FIRMWARE_VOLUME_EXT_HEADER.from_buffer (self.FvData, self.FvHdr.ExtHeaderOffset) else: self.FvExtHdr = None self.FfsList = [] def ParseFv(self): fvsize = len(self.FvData) if self.FvExtHdr: offset = self.FvHdr.ExtHeaderOffset + self.FvExtHdr.ExtHeaderSize else: offset = self.FvHdr.HeaderLength offset = AlignPtr(offset) while offset < fvsize: ffshdr = EFI_FFS_FILE_HEADER.from_buffer (self.FvData, offset) if (ffshdr.Name == '\xff' * 16) and (int(ffshdr.Size) == 0xFFFFFF): offset = fvsize else: ffs = FirmwareFile (offset, self.FvData[offset:offset + int(ffshdr.Size)]) ffs.ParseFfs() self.FfsList.append(ffs) offset += int(ffshdr.Size) offset = AlignPtr(offset) class FileChecker: def __init__(self): # sourceRoot == WORKSPACE # sourceRoot != PACKAGES_PATH self.RebasePcd = ["", "", "", ""] self.FvName = "" self.target = "" self.sourceRoot = "" self.reportFile = "" def GetSectionName(self, line): splitLine = line[1:-1].split(".") return splitLine[0] def IsSyncSection(self, line): name = self.GetSectionName(line) for sectionName in self.SyncSectionList: if (cmp (sectionName, name) == 0) : return True return False def PrintRebasePcd(self, pcd): print "PCD: " + pcd[0] + "|" + pcd[3] + " <== " + pcd[1] + "(" + pcd[2] + ")" def RebaseFv(self, fvName, rebasePcd): sourceFileName = os.path.join(self.sourceRoot,fvName,self.target,fvName+".Fv") print "rebasing(FV) - " + sourceFileName try : file = open(sourceFileName, "rb") except Exception: print "fail to open " + sourceFileName return try: buffer = file.read() data = bytearray(buffer) file.close() FvHeader = EFI_FIRMWARE_VOLUME_HEADER.from_buffer (data, 0) print "HeaderLength - " + hex(FvHeader.HeaderLength) print "ExtHeaderOffset - " + hex(FvHeader.ExtHeaderOffset) if (FvHeader.ExtHeaderOffset == 0): Offset = FvHeader.HeaderLength else: FvExHeader = EFI_FIRMWARE_VOLUME_EXT_HEADER.from_buffer(data, FvHeader.ExtHeaderOffset) print " FvName - %08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x" % (FvExHeader.FvName.Guid1, FvExHeader.FvName.Guid2, FvExHeader.FvName.Guid3, FvExHeader.FvName.Guid4[0], FvExHeader.FvName.Guid4[1], FvExHeader.FvName.Guid4[2], FvExHeader.FvName.Guid4[3], FvExHeader.FvName.Guid4[4], FvExHeader.FvName.Guid4[5], FvExHeader.FvName.Guid4[6], FvExHeader.FvName.Guid4[7]) print " ExtHeaderSize - " + hex(FvExHeader.ExtHeaderSize) Offset = FvHeader.ExtHeaderOffset + FvExHeader.ExtHeaderSize Offset = (Offset + 0x7) & ~0x7 while (Offset < FvHeader.FvLength) : FfsHeader = EFI_FFS_FILE_HEADER.from_buffer (data, Offset) FfsOffset = Offset FfsSize = FfsHeader.Size[0] + (FfsHeader.Size[1] << 8) + (FfsHeader.Size[2] << 16) if (FfsSize == 0xFFFFFF) : break #print "Ffs - " + hex(FfsOffset) if (FfsHeader.Type == 0xFF) or (FfsHeader.Type == EFI_FV_FILETYPE_FFS_PAD) : Offset = (FfsOffset + FfsSize + 7) & ~0x7 continue print "Ffs - %08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x" % (FfsHeader.Name.Guid1, FfsHeader.Name.Guid2, FfsHeader.Name.Guid3, FfsHeader.Name.Guid4[0], FfsHeader.Name.Guid4[1], FfsHeader.Name.Guid4[2], FfsHeader.Name.Guid4[3], FfsHeader.Name.Guid4[4], FfsHeader.Name.Guid4[5], FfsHeader.Name.Guid4[6], FfsHeader.Name.Guid4[7]) Offset = Offset + sizeof(EFI_FFS_FILE_HEADER) while (Offset < FfsOffset + FfsSize) : SectionHeader = EFI_COMMON_SECTION_HEADER.from_buffer (data, Offset) #print " Section - " + hex(Offset) if (SectionHeader.Type == EFI_SECTION_PE32) or (SectionHeader.Type == EFI_SECTION_TE) : PeOffset = Offset + sizeof(EFI_COMMON_SECTION_HEADER) print " PE - " + hex(PeOffset) + "(" + binascii.hexlify(data[PeOffset:PeOffset+2]) + ")" newbase = int(rebasePcd[1],16) oldbase = int(rebasePcd[3],16) delta = newbase - oldbase print " delta - " + hex(delta) + "(" + hex(oldbase) + " <== " + hex(newbase) + ")" PeLength = FfsSize-sizeof(EFI_FFS_FILE_HEADER); img = PeTeImage(PeOffset, data[PeOffset:PeOffset + PeLength]) img.ParseReloc() img.Rebase(delta, data) SectionSize = SectionHeader.Size[0] + (SectionHeader.Size[1] << 8) + (SectionHeader.Size[2] << 16) Offset = (Offset + SectionSize + 3) & ~0x3 Offset = (FfsOffset + FfsSize + 7) & ~0x7 file = open(sourceFileName, "wb") file.write(data) finally: file.close() def GetPcdFromReport(self, file, pcd): FoundPkg = False pcdSplit = pcd.split(".") TargetPkg = pcdSplit[0] TargetPcd = pcdSplit[1] while 1: line = file.readline() if not line: break newline = line[:-1].replace('\r','') if (cmp (newline, TargetPkg) == 0): FoundPkg = True continue if (cmp (newline, "") == 0) or ((cmp (newline[0], " ") != 0) and (cmp (newline[0], "0") != 0)): FoundPkg = False if (FoundPkg == True) : newline = newline.strip() splitLine = newline.split(" ", 2) if (cmp (splitLine[0], "*F") == 0) or (cmp (splitLine[0], "*P") == 0): if (cmp (splitLine[1], TargetPcd) == 0): print "found - " + TargetPkg + "." + TargetPcd splitLine = splitLine[2].strip()[1:].strip().split(" ", 1) if (cmp (splitLine[0], "FIXED") == 0) or (cmp (splitLine[0], "PATCH") == 0): SplitLine = splitLine[1].strip()[1:].split(")", 1) Type = SplitLine[0] Value = SplitLine[1].strip()[1:].strip().split()[0] print " Type - (" + Type + "), Value - (" + Value + ")" return [Value, Type] return ["", ""] def GetOldFvBase (self, fvName, PcdName): ParseBase = False Value = "" fileName = os.path.join(self.sourceRoot,fvName,self.target,fvName+".inf") try : file = open(fileName) except Exception: print "fail to open " + fileName return try: while 1: line = file.readline() if not line: break newline = line[:-1].replace('\r','') if cmp (newline, "") == 0: continue if cmp (newline, "#![Pcd]") == 0: ParseBase = True continue if ParseBase == True : if (cmp (line[0:2], "#!") != 0) : ParseBase = False continue newline = newline[2:].strip() splitLine = newline.split("|") if cmp (PcdName, splitLine[0]) == 0: Value = splitLine[1] finally: file.close() return Value def SetNewFvBase (self, fvName, PcdName, OldFvBase, NewFvBase): fileName = os.path.join(self.sourceRoot,fvName,self.target,fvName+".inf") print "update - " + fileName try : file = open(fileName, "r") except Exception: print "fail to open " + fileName return try: lines = file.readlines() file.close() ParseBase = False for index in range(len(lines)): line = lines[index] if not line: break newline = line[:-1].strip() if cmp (newline, "") == 0: continue if cmp (newline, "#![Pcd]") == 0: ParseBase = True continue if ParseBase == True : if (cmp (line[0:2], "#!") != 0) : ParseBase = False continue newline = newline[2:].strip() splitLine = newline.split("|") if cmp (PcdName, splitLine[0]) == 0: if cmp (OldFvBase, splitLine[1]) != 0: print "ERROR: OldFvBase mismatch!" else: lines[index] = "#! " + PcdName + "|" + NewFvBase + "\n" break file = open(fileName, "w") file.writelines(lines) finally: file.close() def GetRebaseAddressFromReport(self): try : file = open(self.reportFile) except Exception: print "fail to open " + self.reportFile return try: file.seek(0) print "checking - " + self.RebasePcd[0] ValuePair = self.GetPcdFromReport (file, self.RebasePcd[0]) self.RebasePcd[1] = ValuePair[0] self.RebasePcd[2] = ValuePair[1] finally: file.close() def main(): global FileChecker fileChecker = FileChecker() if (len(sys.argv) != 6) : print "usage: RebaseBinFv <Target> <SourceRoot> <ReportFile> <FvName> <RebasePcdName>" return 0 fileChecker.target = sys.argv[1] fileChecker.sourceRoot = sys.argv[2] fileChecker.reportFile = sys.argv[3] fileChecker.FvName = sys.argv[4] fileChecker.RebasePcd[0] = sys.argv[5] fileChecker.GetRebaseAddressFromReport() fileChecker.RebasePcd[3] = fileChecker.GetOldFvBase (fileChecker.FvName, fileChecker.RebasePcd[0]) fileChecker.PrintRebasePcd(fileChecker.RebasePcd) fileChecker.RebaseFv (fileChecker.FvName, fileChecker.RebasePcd) fileChecker.SetNewFvBase (fileChecker.FvName, fileChecker.RebasePcd[0], fileChecker.RebasePcd[3], fileChecker.RebasePcd[1]) if __name__ == '__main__': sys.exit(main())
edk2-platforms-master
Platform/Intel/MinPlatformPkg/Tools/PatchFv/RebaseBinFv.py
## @ PatchBfv.py # # Copyright (c) 2017, Intel Corporation. All rights reserved.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # ## import os import re import sys import time import shutil import struct import binascii from ctypes import * class FileChecker: def __init__(self): self.fdName = "" self.reportFile = "" self.pcd = ["", "", ""] def PrintPcd(self): print "PCD: " + self.pcd[0] + "|" + self.pcd[1] + "(" + self.pcd[2] + ")" def ProcessReport(self): try : file = open(self.reportFile) except Exception: print "fail to open " + self.reportFile return try: file.seek(0) print "checking - " + self.pcd[0] ValuePair = self.GetPcdFromReport (file, self.pcd[0]) self.pcd[1] = ValuePair[0] self.pcd[2] = ValuePair[1] finally: file.close() self.PrintPcd() def PatchFd(self): fileName = self.fdName print "patching BFV - " + fileName try : file = open(fileName, "rb") except Exception: print "fail to open " + fileName return try: buffer = file.read() data = bytearray(buffer) file.close() offset = -4 l = struct.pack("L", int(self.pcd[1],16)) print " [" + hex(offset) + "] " + binascii.hexlify(data[-4:]) + " <= " + binascii.hexlify(l) data[-4:] = l file = open(fileName, "wb") file.write(data[0:]) finally: file.close() def GetPcdFromReport(self, file, pcd): FoundPkg = False pcdSplit = pcd.split(".") TargetPkg = pcdSplit[0] TargetPcd = pcdSplit[1] while 1: line = file.readline() if not line: break newline = line[:-1] if (cmp (newline, TargetPkg) == 0): FoundPkg = True continue if (cmp (newline, "") == 0) or ((cmp (newline[0], " ") != 0) and (cmp (newline[0], "0") != 0)): FoundPkg = False if (FoundPkg == True) : newline = newline.strip() splitLine = newline.split(" ", 2) if (cmp (splitLine[0], "*F") == 0) or (cmp (splitLine[0], "*P") == 0) : if (cmp (splitLine[1], TargetPcd) == 0): print "found - " + TargetPkg + "." + TargetPcd splitLine = splitLine[2].strip()[1:].strip().split(" ", 1) if (cmp (splitLine[0], "FIXED") == 0) or (cmp (splitLine[0], "PATCH") == 0): SplitLine = splitLine[1].strip()[1:].split(")", 1) Type = SplitLine[0] Value = SplitLine[1].strip()[1:].strip().split()[0] print " Type - (" + Type + "), Value - (" + Value + ")" return [Value, Type] return ["", ""] def main(): global FileChecker fileChecker = FileChecker() if (len(sys.argv) != 4) : print "usage: PatchBfv <FdFile> <ReportFile> <BfvPcdName>" return 0 fileChecker.fdName = sys.argv[1] fileChecker.reportFile = sys.argv[2] fileChecker.pcd[0] = sys.argv[3] fileChecker.ProcessReport () fileChecker.PatchFd () if __name__ == '__main__': sys.exit(main())
edk2-platforms-master
Platform/Intel/MinPlatformPkg/Tools/PatchFv/PatchBfv.py
## @ PatchBinFv.py # # Copyright (c) 2017 - 2019, Intel Corporation. All rights reserved.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # ## import os import re import sys import time import shutil import struct import binascii from ctypes import * class FileChecker: def __init__(self): self.SyncSectionList = ["PatchPcd"] self.FvName = "" self.target = "" self.sourceRoot = "" self.reportFile = "" self.InfPcdList = [] def GetSectionName(self, line): splitLine = line[1:-1].split(".") return splitLine[0] def IsSyncSection(self, line): name = self.GetSectionName(line) for sectionName in self.SyncSectionList: if (cmp (sectionName, name) == 0) : return True return False def PrintPcdList(self, pcdList): for pcd in pcdList: print "PCD: " + pcd[0] + "|" + pcd[1] + "|" + pcd[2] + " <== " + pcd[3] + "(" + pcd[4] + ")" def GetInfFileGuid(self, fileName): guid = "" try : file = open(fileName) except Exception: print "fail to open " + fileName return try: while 1: line = file.readline() if not line: break newline = line[:-1] if cmp (line[:11], " FILE_GUID") == 0: splitLine = line.split("=") templine = splitLine[1] guid = templine[1:1+36] finally: file.close() return guid def ParseInfFile(self, fileName): SyncToDest = False try : file = open(fileName) except Exception: print "fail to open " + fileName return try: while 1: line = file.readline() if not line: break newline = line[:-1] if cmp (line[0], "#") == 0: continue if cmp (line[0], "[") == 0: SyncToDest = self.IsSyncSection(line) PatchOffset = False if (cmp (self.GetSectionName(line), "PatchPcd") == 0) : PatchOffset = True continue if SyncToDest == True : line = line.strip() if (cmp (line, "") == 0) : continue if (cmp (line[0], "#") == 0) : continue splitLine = line.split(" ") line = splitLine[0] splitLine = line.split("|") self.InfPcdList.append([splitLine[0], splitLine[1], splitLine[2], "", ""]) finally: file.close() return def ProcessFvInf(self, fvName): sourceFileName = os.path.join(self.sourceRoot,fvName,self.target,fvName+".inf") print "\nprocessing - " + sourceFileName fileGuid = self.GetInfFileGuid (sourceFileName) print "FV NAME GUID - " + fileGuid self.InfPcdList = [] self.ParseInfFile(sourceFileName) self.InfPcdList.sort() #self.PrintPcdList(self.InfPcdList) try : file = open(self.reportFile) except Exception: print "fail to open " + self.reportFile return try: for pcd in self.InfPcdList: file.seek(0) print "checking - " + pcd[0] ValuePair = self.GetPcdFromReport (file, pcd[0]) pcd[3] = ValuePair[0] pcd[4] = ValuePair[1] finally: file.close() self.PrintPcdList(self.InfPcdList) def PatchFv(self, fvName): sourceFileName = os.path.join(self.sourceRoot,fvName,self.target,fvName+".Fv") print "patching - " + sourceFileName try : file = open(sourceFileName, "rb") except Exception: print "fail to open " + sourceFileName return try: buffer = file.read() data = bytearray(buffer) file.close() for pcd in self.InfPcdList: offset = int(pcd[2], 16) if (cmp (pcd[4], "BOOLEAN") == 0) or (cmp (pcd[4], "UINT8") == 0): b = struct.pack("B", int(pcd[3],16)) print " [" + hex(offset) + "] " + binascii.hexlify(data[offset:offset+1]) + " <= " + binascii.hexlify(b) data[offset:offset+1] = b elif (cmp (pcd[4], "UINT16") == 0): h = struct.pack("H", int(pcd[3],16)) print " [" + hex(offset) + "] " + binascii.hexlify(data[offset:offset+2]) + " <= " + binascii.hexlify(h) data[offset:offset+2] = h elif (cmp (pcd[4], "UINT32") == 0): l = struct.pack("I", int(pcd[3],16)) print " [" + hex(offset) + "] " + binascii.hexlify(data[offset:offset+4]) + " <= " + binascii.hexlify(l) data[offset:offset+4] = l elif (cmp (pcd[4], "UINT64") == 0): q = struct.pack("Q", int(pcd[3],16)) print " [" + hex(offset) + "] " + binascii.hexlify(data[offset:offset+8]) + " <= " + binascii.hexlify(q) data[offset:offset+8] = q file = open(sourceFileName, "wb") file.write(data) finally: file.close() def GetPcdFromReport(self, file, pcd): FoundPkg = False pcdSplit = pcd.split(".") TargetPkg = pcdSplit[0] TargetPcd = pcdSplit[1] while 1: line = file.readline() if not line: break newline = line[:-1] if (cmp (newline, TargetPkg) == 0): FoundPkg = True continue if (cmp (newline, "") == 0) or ((cmp (newline[0], " ") != 0) and (cmp (newline[0], "0") != 0)): FoundPkg = False if (FoundPkg == True) : newline = newline.strip() splitLine = newline.split(" ", 2) if (cmp (splitLine[0], "*F") == 0) or (cmp (splitLine[0], "*P") == 0): if (cmp (splitLine[1], TargetPcd) == 0): print "found - " + TargetPkg + "." + TargetPcd splitLine = splitLine[2].strip()[1:].strip().split(" ", 1) if (cmp (splitLine[0], "FIXED") == 0) or (cmp (splitLine[0], "PATCH") == 0): SplitLine = splitLine[1].strip()[1:].split(")", 1) Type = SplitLine[0] Value = SplitLine[1].strip()[1:].strip().split()[0] print " Type - (" + Type + "), Value - (" + Value + ")" return [Value, Type] return ["", ""] def main(): global FileChecker fileChecker = FileChecker() if (len(sys.argv) != 5) : print "usage: PatchBinFv <Target> <SourceRoot> <ReportFile> <FvName>" return 0 fileChecker.target = sys.argv[1] fileChecker.sourceRoot = sys.argv[2] fileChecker.reportFile = sys.argv[3] fileChecker.FvName = sys.argv[4] fileChecker.ProcessFvInf (fileChecker.FvName) fileChecker.PatchFv (fileChecker.FvName) if __name__ == '__main__': sys.exit(main())
edk2-platforms-master
Platform/Intel/MinPlatformPkg/Tools/PatchFv/PatchBinFv.py
## @file # # Copyright (c) 2017, Intel Corporation. All rights reserved.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # ''' ParseVar ''' import os import sys import argparse import subprocess import uuid import struct import collections import binascii from ctypes import * # # Globals for help information # __prog__ = 'ParseVar' __version__ = '%s Version %s' % (__prog__, '0.1 ') __copyright__ = 'Copyright (c) 2017, Intel Corporation. All rights reserved.' __usage__ = '%s -e|-d [options] <input_file>' % (__prog__) class GUID(Structure): _fields_ = [ ('Guid1', c_uint32), ('Guid2', c_uint16), ('Guid3', c_uint16), ('Guid4', ARRAY(c_uint8, 8)), ] class TIME(Structure): _fields_ = [ ('Year', c_uint16), ('Month', c_uint8), ('Day', c_uint8), ('Hour', c_uint8), ('Minute', c_uint8), ('Second', c_uint8), ('Pad1', c_uint8), ('Nanosecond', c_uint32), ('TimeZone', c_uint16), ('Daylight', c_uint8), ('Pad2', c_uint8), ] EFI_VARIABLE_GUID = [0xddcf3616, 0x3275, 0x4164, 0x98, 0xb6, 0xfe, 0x85, 0x70, 0x7f, 0xfe, 0x7d] EFI_AUTHENTICATED_VARIABLE_GUID = [0xaaf32c78, 0x947b, 0x439a, 0xa1, 0x80, 0x2e, 0x14, 0x4e, 0xc3, 0x77, 0x92] # Variable Store Header Format. VARIABLE_STORE_FORMATTED = 0x5a # Variable Store Header State. VARIABLE_STORE_HEALTHY = 0xfe class VARIABLE_STORE_HEADER(Structure): _fields_ = [ ('Signature', GUID), ('Size', c_uint32), ('Format', c_uint8), ('State', c_uint8), ('Reserved', c_uint16), ('Reserved1', c_uint32), ] # Variable data start flag. VARIABLE_DATA = 0x55AA # Variable State flags. VAR_IN_DELETED_TRANSITION = 0xfe VAR_DELETED = 0xfd VAR_HEADER_VALID_ONLY = 0x7f VAR_ADDED = 0x3f class VARIABLE_HEADER(Structure): _fields_ = [ ('StartId', c_uint16), ('State', c_uint8), ('Reserved', c_uint8), ('Attributes', c_uint32), ('NameSize', c_uint32), ('DataSize', c_uint32), ('VendorGuid', GUID), ] class AUTHENTICATED_VARIABLE_HEADER(Structure): _fields_ = [ ('StartId', c_uint16), ('State', c_uint8), ('Reserved', c_uint8), ('Attributes', c_uint32), ('MonotonicCount', c_uint64), ('TimeStamp', TIME), ('PubKeyIndex', c_uint32), ('NameSize', c_uint32), ('DataSize', c_uint32), ('VendorGuid', GUID), ] # Alignment of Variable Data Header in Variable Store region. HEADER_ALIGNMENT = 4 class DEFAULT_INFO(Structure): _fields_ = [ ('DefaultId', c_uint16), ('BoardId', c_uint8), ('Reserved', c_uint8), ] class DEFAULT_DATA(Structure): _fields_ = [ ('HeaderSize', c_uint16), ('DefaultInfo', DEFAULT_INFO), ] def DumpHexData(Data): CharPerLine = 8 DataLen = len(Data) Count = DataLen / CharPerLine Rem = DataLen % CharPerLine CountIndex = 0 for CountIndex in range (0, Count) : TempData = Data[CountIndex * CharPerLine:CountIndex * CharPerLine + CharPerLine] print "#// %04x: "%(CountIndex*CharPerLine) + binascii.hexlify(TempData) if Rem != 0 : TempData = Data[Count * CharPerLine:Count * CharPerLine + Rem] print "#// %04x: "%(Count*CharPerLine) + binascii.hexlify(TempData) def DumpBin(Data): DataLen = len(Data) for Index in range (0, DataLen - 1) : print "0x%02x,"%(Data[Index]), print "0x%02x"%(Data[DataLen - 1]), def DumpName(Data): DataLen = len(Data) for Index in range (0, DataLen/2 - 1) : print "%c"%(Data[Index * 2]), if __name__ == '__main__': # # Create command line argument parser object # parser = argparse.ArgumentParser(prog=__prog__, version=__version__, usage=__usage__, description=__copyright__, conflict_handler='resolve') group = parser.add_mutually_exclusive_group(required=True) group.add_argument("-e", action="store_true", dest='Encode', help='encode file') group.add_argument("-d", action="store_true", dest='Decode', help='decode file') parser.add_argument("-v", "--verbose", dest='Verbose', action="store_true", help="increase output messages") parser.add_argument("-q", "--quiet", dest='Quiet', action="store_true", help="reduce output messages") parser.add_argument("--debug", dest='Debug', type=int, metavar='[0-9]', choices=range(0,10), default=0, help="set debug level") parser.add_argument(metavar="input_file", dest='InputFile', type=argparse.FileType('rb'), help="specify the input filename") # # Parse command line arguments # args = parser.parse_args() # # Read input file into a buffer and save input filename # args.InputFileName = args.InputFile.name args.InputFileBuffer = args.InputFile.read() args.InputFile.close() if args.Encode: print 'Unsupported' if args.Decode: print '#//FCE binary' FullInputFileBuffer = bytearray(args.InputFileBuffer) FullSize = len(FullInputFileBuffer) DefaultData = DEFAULT_DATA.from_buffer (bytearray(args.InputFileBuffer), 0) print "#// DEFAULT_DATA:" print "#// HeaderSize - 0x%04x" % DefaultData.HeaderSize print "#// DefaultId - 0x%04x" % DefaultData.DefaultInfo.DefaultId print "#// BoardId - 0x%02x" % DefaultData.DefaultInfo.BoardId print "" Offset = DefaultData.HeaderSize VariableStoreHeader = VARIABLE_STORE_HEADER.from_buffer (bytearray(args.InputFileBuffer), Offset) print "#// VARIABLE_STORE_HEADER:" print "#// Signature - %08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x" % (VariableStoreHeader.Signature.Guid1, VariableStoreHeader.Signature.Guid2, VariableStoreHeader.Signature.Guid3, VariableStoreHeader.Signature.Guid4[0], VariableStoreHeader.Signature.Guid4[1], VariableStoreHeader.Signature.Guid4[2], VariableStoreHeader.Signature.Guid4[3], VariableStoreHeader.Signature.Guid4[4], VariableStoreHeader.Signature.Guid4[5], VariableStoreHeader.Signature.Guid4[6], VariableStoreHeader.Signature.Guid4[7]) print "#// Size - 0x%08x" % VariableStoreHeader.Size print "#// Format - 0x%02x" % VariableStoreHeader.Format print "#// State - 0x%02x" % VariableStoreHeader.State print "" Offset += sizeof(VARIABLE_STORE_HEADER) Offset = (Offset + HEADER_ALIGNMENT - 1) & (~(HEADER_ALIGNMENT - 1)) if VariableStoreHeader.Format != VARIABLE_STORE_FORMATTED : sys.exit(0) if VariableStoreHeader.State != VARIABLE_STORE_HEALTHY : sys.exit(0) VarIndex = 1 while Offset < FullSize : VariableHeader = VARIABLE_HEADER.from_buffer (bytearray(args.InputFileBuffer), Offset) print "#// VARIABLE_HEADER:" print "#// StartId - 0x%04x" % VariableHeader.StartId print "#// State - 0x%02x" % VariableHeader.State print "#// Attributes - 0x%08x" % VariableHeader.Attributes print "#// NameSize - 0x%08x" % VariableHeader.NameSize print "#// DataSize - 0x%08x" % VariableHeader.DataSize print "#// VendorGuid - %08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x" % (VariableHeader.VendorGuid.Guid1, VariableHeader.VendorGuid.Guid2, VariableHeader.VendorGuid.Guid3, VariableHeader.VendorGuid.Guid4[0], VariableHeader.VendorGuid.Guid4[1], VariableHeader.VendorGuid.Guid4[2], VariableHeader.VendorGuid.Guid4[3], VariableHeader.VendorGuid.Guid4[4], VariableHeader.VendorGuid.Guid4[5], VariableHeader.VendorGuid.Guid4[6], VariableHeader.VendorGuid.Guid4[7]) Offset += sizeof(VARIABLE_HEADER) if VariableHeader.StartId != VARIABLE_DATA : sys.exit(0) Name = FullInputFileBuffer[Offset:Offset + VariableHeader.NameSize] AsciiName = [] for Int in Name: if Int == 0: continue AsciiName.append(chr(Int)) AsciiName = ''.join(AsciiName) print "#// Name - L\"" + AsciiName + "\"" #print "#// Name - L\"", #DumpName(Name) #print "\"" Offset += VariableHeader.NameSize print "#// Data - " Data=FullInputFileBuffer[Offset:Offset + VariableHeader.DataSize] DumpHexData (Data) Offset += VariableHeader.DataSize print " gOemSkuTokenSpaceGuid.Pcd" + AsciiName + "Data|{", DumpBin(Data) #print "}|VOID*|0x000F%04x" % VarIndex print "}" print "" #OutputFile = open(AsciiName, 'wb') #OutputFile.write(Data) #OutputFile.close() VarIndex = VarIndex + 1 Offset = (Offset + HEADER_ALIGNMENT - 1) & (~(HEADER_ALIGNMENT - 1))
edk2-platforms-master
Platform/Intel/MinPlatformPkg/Tools/ParseVar/ParseVar.py
## @ CheckCodeBase.py # # Copyright (c) 2017, Intel Corporation. All rights reserved.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # ## import os import re import sys import time import shutil class FileChecker: def __init__(self): # sourceRoot == WORKSPACE # sourceRoot != PACKAGES_PATH self.sourceRoot = "" self.includeCoreList = ["\\CryptoPkg\\", "\\FatBinPkg\\", "\\FatPkg\\", "\\IntelFrameworkModulePkg\\", "\\IntelFrameworkPkg\\", "\\IntelFsp2Pkg\\", "\\IntelFsp2WrapperPkg\\", "\\IntelFspPkg\\", "\\IntelFspWrapperPkg\\", "\\IntelSiliconPkg\\", "\\MdeModulePkg\\", "\\MdePkg\\", "\\NetworkPkg\\", "\\PcAtChipsetPkg\\", "\\PerformancePkg\\", "\\SecurityPkg\\", "\\ShellBinPkg\\", "\\ShellPkg\\", "\\SignedCapsulePkg\\", "\\SourceLevelDebugPkg\\", "\\UefiCpuPkg\\"] self.includeList = self.includeCoreList self.excluseCoreList = ["\\BaseTools\\", "\\Conf\\", "\\Tools\\", "\\Build\\", "\\tool\\", "\\.svn", "\\.git", "\\Override\\", "\\SampleCode\\", "\\openssl"] self.excluseList = self.excluseCoreList self.usedModuleList = [] self.usedLibraryList = [] self.makefileList = [] self.usedIncludeFileList = [] self.usedModuleFileList = [] self.usedLibraryFileList = [] self.usedFileList = [] self.usedPackageList = [] self.allModuleList = [] self.allLibraryList = [] self.allDirList = [] self.allIncludeFileList = [] self.allModuleFileList = [] self.allLibraryFileList = [] self.allFileList = [] self.allPackageList = [] self.unusedModuleList = [] self.unusedLibraryList = [] self.unusedIncludeFileList = [] self.unusedModuleFileList = [] self.unusedLibraryFileList = [] self.unusedFileList = [] self.unusedPackageList = [] self.unusedPackageFileList = [] def CheckFile(self, file): if os.path.isfile(file): return file.decode('gbk') else: return "" def CheckDir(self, file): if os.path.isdir(file): return file.decode('gbk') else: return "" def IsIncludeFile(self, file): if (cmp (file[-2:], ".h") == 0) and (file.find ("Pkg\\Include") != -1): return True else: return False def IsLibraryFile(self, file): if (file.find ("Pkg\\Library") != -1): return True else: return False def CheckIncludeFile(self, file): if self.IsIncludeFile(file) and (self.IsInExclusiveList(file) == False): return file.decode('gbk') else: return "" def GetModulePathFromMakefile (self, file): makefile = open (file, "r") data = makefile.read () for line in data.split("\n"): # MODULE_DIR = c:\home\edkiigit\edk2\MdeModulePkg\Library\BaseSerialPortLib16550 if "MODULE_DIR =" in line: moduleDir = line.split(" = ")[1] # BUILD_DIR = c:\home\edkiigit\Build\KabylakeOpenBoardPkg\KabylakeRvp3\DEBUG_VS2015x86 if "BUILD_DIR =" in line: buildDir = line.split(" = ")[1] makefile.close() # record sourceRoot = c:\home\Edk-II self.sourceRoot = buildDir.split("\\Build\\")[0] if (self.IsInExclusiveList(moduleDir) == False): self.AddPackageList(moduleDir, self.usedPackageList) return moduleDir def AddPackageList(self, file, packageList): packageName = file.split("Pkg") packagePath = packageName[0] + "Pkg" if packagePath not in packageList: packageList.append(packagePath) def IsInPackageList(self, file): for package in self.usedPackageList: if file.find(package) != -1: return True return False def CheckUsedModule(self, file): if (cmp (file[-8:], "Makefile") == 0) and (self.IsLibraryFile(file) == False): finalDir = self.GetModulePathFromMakefile(file) if self.IsInExclusiveList(finalDir): return "" return finalDir.decode('gbk') else: return "" def CheckUsedLibrary(self, file): if (cmp (file[-8:], "Makefile") == 0) and self.IsLibraryFile(file): finalDir = self.GetModulePathFromMakefile(file) if self.IsInExclusiveList(finalDir): return "" return finalDir.decode('gbk') else: return "" def CheckMakefile(self, file): if cmp (file[-8:], "Makefile") == 0: finalDir = self.GetModulePathFromMakefile(file) if self.IsInExclusiveList(finalDir): return "" return file.decode('gbk') else: return "" def ParseMakefile(self, fileName): try : file = open(fileName) except Exception: print "fail to open " + fileName return try: while 1: line = file.readline() if not line: break if cmp (line[0], "#") == 0: continue newline = line[:-1] #print "check - (" + newline + ")" headFile = "" #COMMON_DEPS = $(WORKSPACE)\MdePkg\Include\Protocol\DebugSupport.h \ # $(WORKSPACE)\MdePkg\Include\Ppi\PciCfg2.h \ #$(OUTPUT_DIR)\X64\Semaphore.obj : $(WORKSPACE)\UefiCpuPkg\Include\Library\MtrrLib.h #MatchString = "[\w\\\s\=\:\.\(\)\$]*\$\(WORKSPACE\)([\\\w]*\.h)[\\w\s]*" MatchString1 = "(COMMON_DEPS = | |\$\(OUTPUT_DIR\)[\\\\\w]*.obj : )\$\(WORKSPACE\)\\\\([\\\\\w]*\.h)" match1 = re.match(MatchString1, newline) if match1 is not None: #print "match1 - " + newline #print "0 - " + match1.group(0) #print "1 - " + match1.group(1) #print "2 - " + match1.group(2) headFile = match1.group(2) if (cmp (headFile, "") != 0) and self.IsIncludeFile(headFile): finalPath = os.path.join (self.sourceRoot, headFile) if (self.IsInExclusiveList(finalPath) == False) and (finalPath not in self.usedIncludeFileList): self.usedIncludeFileList.append(finalPath) self.AddPackageList (finalPath, self.usedPackageList) finally: file.close() return def IsInIncludeList(self, file): for list in self.includeList: result = file.find(list); if (result != -1): return True return False def IsInExclusiveList(self, file): if self.IsInIncludeList(file) == False: return True for list in self.excluseList: result = file.find(list); if (result != -1): return True for list in self.excluseList: full_file = file + "\\" result = full_file.find(list); if (result != -1): return True return False def IsFinalDir(self, file): for s in os.listdir(file): newFile=os.path.join(file,s) if cmp (newFile[-4:], ".inf") == 0: return True return False def IsInUsedModuleList(self, file): if file in self.usedModuleList: return True else: return False def IsInUsedLibraryList(self, file): if file in self.usedLibraryList: return True else: return False def IsUsedModule(self, file): for used in self.usedModuleList: final = used + "\\" result = file.find(final); if (result != -1): return True return False def IsUsedLibrary(self, file): for used in self.usedLibraryList: final = used + "\\" result = file.find(final); if (result != -1): return True return False def IsUnusedModule(self, file): for unused in self.unusedModuleList: final = unused + "\\" result = file.find(final); if (result != -1): return True return False def IsUnusedLibrary(self, file): for unused in self.unusedLibraryList: final = unused + "\\" result = file.find(final); if (result != -1): return True return False def IsUnusedPackage(self, file): for unused in self.unusedPackageList: final = unused + "\\" result = file.find(final); if (result != -1): return True return False def CheckUnusedModule(self, file): if os.path.isdir(file): if (self.IsInExclusiveList(file) == False) and self.IsFinalDir(file) and (self.IsInUsedModuleList(file) == False) and (self.IsLibraryFile(file) == False): return file.decode('gbk') else: return "" else: return "" def CheckUnusedLibrary(self, file): if os.path.isdir(file): if (self.IsInExclusiveList(file) == False) and self.IsFinalDir(file) and (self.IsInUsedLibraryList(file) == False) and self.IsLibraryFile(file): return file.decode('gbk') else: return "" else: return "" def CheckAllModule(self, file): if os.path.isdir(file): if (self.IsInExclusiveList(file) == False) and self.IsFinalDir(file) and (self.IsLibraryFile(file) == False): return file.decode('gbk') else: return "" else: return "" def CheckAllLibrary(self, file): if os.path.isdir(file): if (self.IsInExclusiveList(file) == False) and self.IsFinalDir(file) and self.IsLibraryFile(file): return file.decode('gbk') else: return "" else: return "" def CheckAllDir(self, file): if os.path.isdir(file): if (self.IsInExclusiveList(file) == False): return file.decode('gbk') else: return "" else: return "" def CheckAllModuleFile(self, file): if os.path.isfile(file): if (self.IsInExclusiveList(file) == False) and (self.IsUsedModule(file) or self.IsUnusedModule(file)) and (self.IsLibraryFile(file) == False): return file.decode('gbk') else: return "" else: return "" def CheckAllLibraryFile(self, file): if os.path.isfile(file): if (self.IsInExclusiveList(file) == False) and (self.IsUsedLibrary(file) or self.IsUnusedLibrary(file)) and self.IsLibraryFile(file): return file.decode('gbk') else: return "" else: return "" def CheckAllFile(self, file): if os.path.isfile(file): if (self.IsInExclusiveList(file) == False): return file.decode('gbk') else: return "" else: return "" def CheckUsedModuleFile(self, file): if os.path.isfile(file): if (self.IsInExclusiveList(file) == False) and self.IsUsedModule(file): return file.decode('gbk') else: return "" else: return "" def CheckUsedLibraryFile(self, file): if os.path.isfile(file): if (self.IsInExclusiveList(file) == False) and self.IsUsedLibrary(file): return file.decode('gbk') else: return "" else: return "" def CheckUnusedModuleFile(self, file): if os.path.isfile(file): if (self.IsInExclusiveList(file) == False) and self.IsUnusedModule(file): return file.decode('gbk') else: return "" else: return "" def CheckUnusedLibraryFile(self, file): if os.path.isfile(file): if (self.IsInExclusiveList(file) == False) and self.IsUnusedLibrary(file): return file.decode('gbk') else: return "" else: return "" def CheckUnusedPackageFile(self, file): if os.path.isfile(file): if (self.IsInExclusiveList(file) == False) and self.IsUnusedPackage(file): return file.decode('gbk') else: return "" else: return "" def GetFileList(self, dir, fileList, checkFunc): newDir = dir AppendName = checkFunc (dir) if cmp (AppendName, "") != 0: #print "AppendName = " + AppendName if AppendName not in fileList: fileList.append(AppendName) if os.path.isdir(dir): for sub in os.listdir(dir): newDir = os.path.join(dir,sub) self.GetFileList(newDir, fileList, checkFunc) return fileList def DeleteEmptyDir(self, dir): if os.path.exists(dir) == False: return if os.path.isdir(dir): for sub in os.listdir(dir): newDir = os.path.join(dir,sub) if (os.path.isdir(newDir) == True): self.DeleteEmptyDir(newDir) if not os.listdir(dir): print "deleting empty " + dir os.rmdir(dir) def DeleteEmptyDirList(self, fileList): for file in fileList: self.DeleteEmptyDir(file) def DeleteUnusedFile(self, fileList): for file in fileList: if os.path.exists(file) == False: continue print "deleting " + file try : if os.path.isdir(file): shutil.rmtree(file) if os.path.isfile(file): os.remove(file) except : print "deleting error (" + file + ")" def PrintFileTime(self, file): statinfo = os.stat(file) strucatime = time.localtime(statinfo.st_atime) print "atime: " + str(statinfo.st_atime) + " (" + str(strucatime.tm_year) + "." + str(strucatime.tm_mon) + "." + str(strucatime.tm_mday) + " " + str(strucatime.tm_hour) + ":" + str(strucatime.tm_min) + ":" + str(strucatime.tm_sec) + ")" strucctime = time.localtime(statinfo.st_ctime) print "ctime: " + str(statinfo.st_ctime) + " (" + str(strucctime.tm_year) + "." + str(strucctime.tm_mon) + "." + str(strucctime.tm_mday) + " " + str(strucctime.tm_hour) + ":" + str(strucctime.tm_min) + ":" + str(strucctime.tm_sec) + ")" strucmtime = time.localtime(statinfo.st_mtime) print "mtime: " + str(statinfo.st_mtime) + " (" + str(strucmtime.tm_year) + "." + str(strucmtime.tm_mon) + "." + str(strucmtime.tm_mday) + " " + str(strucmtime.tm_hour) + ":" + str(strucmtime.tm_min) + ":" + str(strucmtime.tm_sec) + ")" def TouchFileTime(self, file): #currentTime = time.time() #os.utime(file, (currentTime, currentTime)) os.utime(file, None) def TouchFileListTime(self, fileList): for file in fileList: self.TouchFileTime(file) def PrintFileList(self, fileList): for file in fileList: print file print " Count - " + str(len(fileList)) def SortFileList(self, fileList): fileList.sort() def PrintFileListTime(self, fileList): for file in fileList: print file self.PrintFileTime(file) def GetUsedModuleList(self): if (len(self.usedModuleList) == 0): self.usedModuleList = self.GetFileList(sys.argv[1], [], self.CheckUsedModule) self.SortFileList(self.usedModuleList) def GetUsedLibraryList(self): if (len(self.usedLibraryList) == 0): self.usedLibraryList = self.GetFileList(sys.argv[1], [], self.CheckUsedLibrary) self.SortFileList(self.usedLibraryList) def GetMakefileList(self): if (len(self.makefileList) == 0): self.GetUsedModuleList() self.makefileList = self.GetFileList(sys.argv[1], [], self.CheckMakefile) def GetUsedIncludeFileList(self): if (len(self.usedIncludeFileList) == 0): self.GetMakefileList() #print "\nMakefile:" #fileChecker.PrintFileList (fileChecker.makefileList) for file in self.makefileList: self.ParseMakefile(file) self.SortFileList(self.usedIncludeFileList) def GetUsedModuleFileList(self): if (len(self.usedModuleFileList) == 0): self.GetUsedModuleList() self.usedModuleFileList = self.GetFileList(self.sourceRoot, [], self.CheckUsedModuleFile) self.SortFileList(self.usedModuleFileList) def GetUsedLibraryFileList(self): if (len(self.usedLibraryFileList) == 0): self.GetUsedLibraryList() self.usedLibraryFileList = self.GetFileList(self.sourceRoot, [], self.CheckUsedLibraryFile) self.SortFileList(self.usedLibraryFileList) def GetUsedFileList(self): if (len(self.usedFileList) == 0): self.GetAllFileList() self.GetUnusedFileList() self.usedFileList = [] for file in self.allFileList: if (file not in self.unusedFileList) and self.IsInPackageList(file): self.usedFileList.append(file) self.SortFileList(self.usedFileList) def GetUsedPackageList(self): self.GetUsedModuleList() self.GetUsedLibraryList() self.GetUsedIncludeFileList() self.SortFileList(self.usedPackageList) def GetAllModuleList(self): if (len(self.allModuleList) == 0): self.GetUsedModuleList() self.allModuleList = self.GetFileList(self.sourceRoot, [], self.CheckAllModule) self.SortFileList(self.allModuleList) def GetAllLibraryList(self): if (len(self.allLibraryList) == 0): self.GetUsedLibraryList() self.allLibraryList = self.GetFileList(self.sourceRoot, [], self.CheckAllLibrary) self.SortFileList(self.allLibraryList) def GetAllIncludeFileList(self): if (len(self.allIncludeFileList) == 0): self.GetUsedModuleList() self.allIncludeFileList = self.GetFileList(self.sourceRoot, [], self.CheckIncludeFile) self.SortFileList(self.allIncludeFileList) def GetAllModuleFileList(self): if (len(self.allFileList) == 0): self.GetUsedModuleList() self.GetUnusedModuleList() self.allModuleFileList = self.GetFileList(self.sourceRoot, [], self.CheckAllModuleFile) self.SortFileList(self.allModuleFileList) def GetAllLibraryFileList(self): if (len(self.allFileList) == 0): self.GetUsedLibraryList() self.GetUnusedLibraryList() self.allLibraryFileList = self.GetFileList(self.sourceRoot, [], self.CheckAllLibraryFile) self.SortFileList(self.allLibraryFileList) def GetAllFileList(self): if (len(self.allFileList) == 0): self.GetUsedModuleList() self.allFileList = self.GetFileList(self.sourceRoot, [], self.CheckAllFile) self.SortFileList(self.allFileList) def GetAllPackageList(self): if (len(self.allPackageList) == 0): self.GetAllFileList() prefixLength = len(self.sourceRoot) for file in self.allFileList: finalPath = os.path.join (self.sourceRoot, file[prefixLength + 1:]) self.AddPackageList(finalPath, self.allPackageList) self.SortFileList(self.allPackageList) def GetUnusedModuleList(self): if (len(self.unusedModuleList) == 0): self.GetUsedModuleList() self.unusedModuleList = self.GetFileList(self.sourceRoot, [], self.CheckUnusedModule) def GetUnusedLibraryList(self): if (len(self.unusedLibraryList) == 0): self.GetUsedLibraryList() self.unusedLibraryList = self.GetFileList(self.sourceRoot, [], self.CheckUnusedLibrary) def GetUnusedIncludeFileList(self): if (len(self.unusedIncludeFileList) == 0): self.GetUsedIncludeFileList() self.GetAllIncludeFileList() self.unusedIncludeFileList = [] for file in self.allIncludeFileList: if file not in self.usedIncludeFileList: self.unusedIncludeFileList.append(file) self.SortFileList(self.unusedIncludeFileList) def GetUnusedModuleFileList(self): if (len(self.unusedModuleFileList) == 0): self.GetUnusedModuleList () self.unusedModuleFileList = self.GetFileList(self.sourceRoot, [], self.CheckUnusedModuleFile) self.SortFileList(self.unusedModuleFileList) def GetUnusedLibraryFileList(self): if (len(self.unusedLibraryFileList) == 0): self.GetUnusedLibraryList () self.unusedLibraryFileList = self.GetFileList(self.sourceRoot, [], self.CheckUnusedLibraryFile) self.SortFileList(self.unusedLibraryFileList) def GetUnusedFileList(self): if (len(self.unusedFileList) == 0): self.GetUnusedIncludeFileList() self.GetUnusedModuleFileList() self.GetUnusedLibraryFileList() self.GetUnusedPackageList() self.unusedPackageFileList = self.GetFileList(self.sourceRoot, [], self.CheckUnusedPackageFile) self.unusedFileList = [] self.unusedFileList.extend(self.unusedIncludeFileList) self.unusedFileList.extend(self.unusedModuleFileList) self.unusedFileList.extend(self.unusedLibraryFileList) for file in self.unusedPackageFileList: if file not in self.unusedFileList: self.unusedFileList.append(file) self.SortFileList(self.unusedFileList) def GetUnusedPackageList(self): if (len(self.unusedPackageList) == 0): self.GetUsedPackageList() self.GetAllPackageList() for package in self.allPackageList: if package not in self.usedPackageList: self.unusedPackageList.append(package) self.SortFileList(self.unusedPackageList) # # Print out the usage # def usage(): print "Usage: \n\tCheckCodeBase <Build Dir> used|unused|all" print " used - used library, modules, include file, library files, module files, all used files" print " unused - unused library, modules, include file, library files, module files, all unused files" print " all - all library, modules, include file, library files, module files, all files" print " library : the directory of a library" print " module : the directory of a driver" print " include file : the header files in include directory" print " library file : all files in a library directory" print " module file : all files in a driver directory" print " all file : all files in project, including any other metadata files or batch files" #print "Usage: \n\tCheckCodeBase <Build Dir> time|touch" print "For Example: \n\tCheckCodeBase Build\KabylakeOpenBoardPkg\KabylakeRvp3\DEBUG_VS2015x86 used" def main(): global FileChecker fileChecker = FileChecker() if len(sys.argv) < 3: usage() return 1 if cmp (sys.argv[2], "used") == 0: fileChecker.GetUsedModuleList () print "\n Used Module List:" fileChecker.PrintFileList (fileChecker.usedModuleList) fileChecker.GetUsedLibraryList () print "\n Used Library List:" fileChecker.PrintFileList (fileChecker.usedLibraryList) fileChecker.GetUsedIncludeFileList() print "\n Used Include File List:" fileChecker.PrintFileList (fileChecker.usedIncludeFileList) fileChecker.GetUsedModuleFileList() print "\n Used Module File List:" fileChecker.PrintFileList (fileChecker.usedModuleFileList) fileChecker.GetUsedLibraryFileList() print "\n Used Library File List:" fileChecker.PrintFileList (fileChecker.usedLibraryFileList) fileChecker.GetUsedFileList() print "\n All Used File List:" fileChecker.PrintFileList (fileChecker.usedFileList) fileChecker.GetUsedPackageList() print "\n Used Package List:" fileChecker.PrintFileList (fileChecker.usedPackageList) print "\n ==== Used Module Summary ====" print " Module Count - " + str(len(fileChecker.usedModuleList)) print " Library Count - " + str(len(fileChecker.usedLibraryList)) print " Include File Count - " + str(len(fileChecker.usedIncludeFileList)) print " Module File Count - " + str(len(fileChecker.usedModuleFileList)) print " Library File Count - " + str(len(fileChecker.usedLibraryFileList)) print " All File Count - " + str(len(fileChecker.usedFileList)) elif cmp (sys.argv[2], "all") == 0: fileChecker.GetAllModuleList() print "\n All Module List:" fileChecker.PrintFileList (fileChecker.allModuleList) fileChecker.GetAllLibraryList() print "\n All Library List:" fileChecker.PrintFileList (fileChecker.allLibraryList) fileChecker.GetAllIncludeFileList() print "\n All Include File List:" fileChecker.PrintFileList (fileChecker.allIncludeFileList) fileChecker.GetAllModuleFileList() print "\n All Module File List:" fileChecker.PrintFileList (fileChecker.allModuleFileList) fileChecker.GetAllLibraryFileList() print "\n All Library File List:" fileChecker.PrintFileList (fileChecker.allLibraryFileList) fileChecker.GetAllFileList() print "\n All File List:" fileChecker.PrintFileList (fileChecker.allFileList) fileChecker.GetAllPackageList() print "\n All Package List:" fileChecker.PrintFileList (fileChecker.allPackageList) print "\n ==== All Module Summary ====" print " Module Count - " + str(len(fileChecker.allModuleList)) print " Library Count - " + str(len(fileChecker.allLibraryList)) print " Include File Count - " + str(len(fileChecker.allIncludeFileList)) print " Module File Count - " + str(len(fileChecker.allModuleFileList)) print " Library File Count - " + str(len(fileChecker.allLibraryFileList)) print " All File Count - " + str(len(fileChecker.allFileList)) elif cmp (sys.argv[2], "unused") == 0: fileChecker.GetUnusedModuleList() print "\n Unused Module List:" fileChecker.PrintFileList (fileChecker.unusedModuleList) fileChecker.GetUnusedLibraryList() print "\n Unused Library List:" fileChecker.PrintFileList (fileChecker.unusedLibraryList) fileChecker.GetUnusedIncludeFileList() print "\n Unused Include List:" fileChecker.PrintFileList (fileChecker.unusedIncludeFileList) fileChecker.GetUnusedModuleFileList() print "\n Unused Module File List:" fileChecker.PrintFileList (fileChecker.unusedModuleFileList) fileChecker.GetUnusedLibraryFileList() print "\n Unused Library File List:" fileChecker.PrintFileList (fileChecker.unusedLibraryFileList) fileChecker.GetUnusedFileList() print "\n Unused File List:" fileChecker.PrintFileList (fileChecker.unusedFileList) fileChecker.GetUnusedPackageList() print "\n Unused Package List:" fileChecker.PrintFileList (fileChecker.unusedPackageList) print "\n ==== Unused Module Summary ====" print " Module Count - " + str(len(fileChecker.unusedModuleList)) print " Library Count - " + str(len(fileChecker.unusedLibraryList)) print " Include File Count - " + str(len(fileChecker.unusedIncludeFileList)) print " Module File Count - " + str(len(fileChecker.unusedModuleFileList)) print " Library File Count - " + str(len(fileChecker.unusedLibraryFileList)) print " All File Count - " + str(len(fileChecker.unusedFileList)) elif cmp (sys.argv[2], "delete_unused") == 0: fileChecker.GetUnusedModuleList() fileChecker.GetUnusedLibraryList() fileChecker.GetUnusedIncludeFileList() fileChecker.GetUnusedPackageList() fileChecker.DeleteUnusedFile(fileChecker.unusedPackageList) fileChecker.DeleteUnusedFile(fileChecker.unusedModuleList) fileChecker.DeleteUnusedFile(fileChecker.unusedLibraryList) fileChecker.DeleteUnusedFile(fileChecker.unusedIncludeFileList) fileChecker.allDirList = fileChecker.GetFileList(fileChecker.sourceRoot, [], fileChecker.CheckAllDir) fileChecker.DeleteEmptyDirList(fileChecker.allDirList) elif cmp (sys.argv[2], "time") == 0: fileChecker.allDirList = fileChecker.GetFileList(sys.argv[1], [], fileChecker.CheckFile) fileChecker.PrintFileListTime(fileChecker.allDirList) elif cmp (sys.argv[2], "touch") == 0: fileChecker.allDirList = fileChecker.GetFileList(sys.argv[1], [], fileChecker.CheckFile) fileChecker.TouchFileListTime(fileChecker.allDirList) else: print "Unknown - " + sys.argv[2] if __name__ == '__main__': sys.exit(main())
edk2-platforms-master
Platform/Intel/MinPlatformPkg/Tools/Help/CheckCodeBase.py
# @ build_board.py # Extensions for building WilsonCityRvp using build_bios.py # # Copyright (c) 2021, Intel Corporation. All rights reserved.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # """ This module serves as a sample implementation of the build extension scripts """ import os import sys def pre_build_ex(config, functions): """Additional Pre BIOS build function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: nothing """ print("pre_build_ex") config["BUILD_DIR_PATH"] = os.path.join(config["WORKSPACE"], 'Build', config["PLATFORM_BOARD_PACKAGE"], "{}_{}".format( config["TARGET"], config["TOOL_CHAIN_TAG"])) # set BUILD_DIR path config["BUILD_DIR"] = os.path.join('Build', config["PLATFORM_BOARD_PACKAGE"], "{}_{}".format( config["TARGET"], config["TOOL_CHAIN_TAG"])) config["BUILD_X64"] = os.path.join(config["BUILD_DIR_PATH"], 'X64') config["BUILD_IA32"] = os.path.join(config["BUILD_DIR_PATH"], 'IA32') if not os.path.isdir(config["BUILD_DIR_PATH"]): try: os.makedirs(config["BUILD_DIR_PATH"]) except OSError: print("Error while creating Build folder") sys.exit(1) #@todo: Replace this with PcdFspModeSelection if config.get("API_MODE_FSP_WRAPPER_BUILD", "FALSE") == "TRUE": config["EXT_BUILD_FLAGS"] += " -D FSP_MODE=0" else: config["EXT_BUILD_FLAGS"] += " -D FSP_MODE=1" if config.get("API_MODE_FSP_WRAPPER_BUILD", "FALSE") == "TRUE": raise ValueError("FSP API Mode is currently unsupported on Ice Lake Xeon Scalable") # Build the ACPI AML offset table *.offset.h print("Info: re-generating PlatformOffset header files") execute_script = functions.get("execute_script") # AML offset arch is X64, not sure if it matters. command = ["build", "-a", "X64", "-t", config["TOOL_CHAIN_TAG"], "-D", "MAX_SOCKET=" + config["MAX_SOCKET"]] if config["EXT_BUILD_FLAGS"] and config["EXT_BUILD_FLAGS"] != "": ext_build_flags = config["EXT_BUILD_FLAGS"].split(" ") ext_build_flags = [x.strip() for x in ext_build_flags] ext_build_flags = [x for x in ext_build_flags if x != ""] command.extend(ext_build_flags) aml_offsets_split = os.path.split(os.path.normpath(config["AML_OFFSETS_PATH"])) command.append("-p") command.append(os.path.normpath(config["AML_OFFSETS_PATH"]) + '.dsc') command.append("-m") command.append(os.path.join(aml_offsets_split[0], aml_offsets_split[1], aml_offsets_split[1] + '.inf')) command.append("-y") command.append(os.path.join(config["WORKSPACE"], "PreBuildReport.txt")) command.append("--log=" + os.path.join(config["WORKSPACE"], "PreBuild.log")) shell = True if os.name == "posix": # linux shell = False _, _, _, code = execute_script(command, config, shell=shell) if code != 0: print(" ".join(command)) print("Error re-generating PlatformOffset header files") sys.exit(1) # Build AmlGenOffset command to consume the *.offset.h and produce AmlOffsetTable.c for StaticSkuDataDxe use. # Get destination path and filename from config relative_file_path = os.path.normpath(config["STRIPPED_AML_OFFSETS_FILE_PATH"]) # get path relative to Platform/Intel out_file_path = os.path.join(config["WORKSPACE_PLATFORM"], relative_file_path) # full path to output file out_file_dir = os.path.dirname(out_file_path) # remove filename out_file_root_ext = os.path.splitext(os.path.basename(out_file_path)) # root and extension of output file # Get relative path for the generated offset.h file relative_dsdt_file_path = os.path.normpath(config["DSDT_TABLE_FILE_PATH"]) # path relative to Platform/Intel dsdt_file_root_ext = os.path.splitext(os.path.basename(relative_dsdt_file_path)) # root and extension of generated offset.h file # Generate output directory if it doesn't exist if not os.path.exists(out_file_dir): os.mkdir(out_file_dir) command = ["python", os.path.join(config["MIN_PACKAGE_TOOLS"], "AmlGenOffset", "AmlGenOffset.py"), "-d", "--aml_filter", config["AML_FILTER"], "-o", out_file_path, os.path.join(config["BUILD_X64"], aml_offsets_split[0], aml_offsets_split[1], aml_offsets_split[1], "OUTPUT", os.path.dirname(relative_dsdt_file_path), dsdt_file_root_ext[0] + ".offset.h")] # execute the command _, _, _, code = execute_script(command, config, shell=shell) if code != 0: print(" ".join(command)) print("Error re-generating PlatformOffset header files") sys.exit(1) print("GenOffset done") return None def _merge_files(files, ofile): with open(ofile, 'wb') as of: for x in files: if not os.path.exists(x): return with open(x, 'rb') as f: of.write(f.read()) def build_ex(config, functions): """Additional BIOS build function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("build_ex") fv_path = os.path.join(config["BUILD_DIR_PATH"], "FV") binary_fd = os.path.join(fv_path, "BINARY.fd") main_fd = os.path.join(fv_path, "MAIN.fd") secpei_fd = os.path.join(fv_path, "SECPEI.fd") board_fd = config["BOARD"].upper() final_fd = os.path.join(fv_path, "{}.fd".format(board_fd)) _merge_files((binary_fd, main_fd, secpei_fd), final_fd) return None def post_build_ex(config, functions): """Additional Post BIOS build function :param config: The environment variables to be used in the post build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("post_build_ex") fv_path = os.path.join(config["BUILD_DIR_PATH"], "FV") board_fd = config["BOARD"].upper() final_fd = os.path.join(fv_path, "{}.fd".format(board_fd)) final_ifwi = os.path.join(fv_path, "{}.bin".format(board_fd)) ifwi_ingredients_path = os.path.join(config["WORKSPACE_PLATFORM_BIN"], "Ifwi", config["BOARD"]) flash_descriptor = os.path.join(ifwi_ingredients_path, "FlashDescriptor.bin") intel_me = os.path.join(ifwi_ingredients_path, "Me.bin") _merge_files((flash_descriptor, intel_me, final_fd), final_ifwi) if os.path.isfile(final_fd): print("IFWI image can be found at {}".format(final_ifwi)) return None def clean_ex(config, functions): """Additional clean function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("clean_ex") return None
edk2-platforms-master
Platform/Intel/WhitleyOpenBoardPkg/WilsonCityRvp/build_board.py
# @ build_board.py # Extensions for building SuperMicro using build_bios.py # # Copyright (c) 2021, Intel Corporation. All rights reserved.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # """ This module serves as a sample implementation of the build extension scripts """ import os import sys def pre_build_ex(config, functions): """Additional Pre BIOS build function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: nothing """ print("pre_build_ex") config["BUILD_DIR_PATH"] = os.path.join(config["WORKSPACE"], 'Build', config["PLATFORM_BOARD_PACKAGE"], "{}_{}".format( config["TARGET"], config["TOOL_CHAIN_TAG"])) # set BUILD_DIR path config["BUILD_DIR"] = os.path.join('Build', config["PLATFORM_BOARD_PACKAGE"], "{}_{}".format( config["TARGET"], config["TOOL_CHAIN_TAG"])) config["BUILD_X64"] = os.path.join(config["BUILD_DIR_PATH"], 'X64') config["BUILD_IA32"] = os.path.join(config["BUILD_DIR_PATH"], 'IA32') if not os.path.isdir(config["BUILD_DIR_PATH"]): try: os.makedirs(config["BUILD_DIR_PATH"]) except OSError: print("Error while creating Build folder") sys.exit(1) #@todo: Replace this with PcdFspModeSelection if config.get("API_MODE_FSP_WRAPPER_BUILD", "FALSE") == "TRUE": config["EXT_BUILD_FLAGS"] += " -D FSP_MODE=0" else: config["EXT_BUILD_FLAGS"] += " -D FSP_MODE=1" if config.get("API_MODE_FSP_WRAPPER_BUILD", "FALSE") == "TRUE": raise ValueError("FSP API Mode is currently unsupported on Ice Lake Xeon Scalable") return None def _merge_files(files, ofile): with open(ofile, 'wb') as of: for x in files: if not os.path.exists(x): return with open(x, 'rb') as f: of.write(f.read()) def build_ex(config, functions): """Additional BIOS build function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("build_ex") fv_path = os.path.join(config["BUILD_DIR_PATH"], "FV") binary_fd = os.path.join(fv_path, "BINARY.fd") main_fd = os.path.join(fv_path, "MAIN.fd") secpei_fd = os.path.join(fv_path, "SECPEI.fd") board_fd = config["BOARD"].upper() final_fd = os.path.join(fv_path, "{}.fd".format(board_fd)) _merge_files((binary_fd, main_fd, secpei_fd), final_fd) return None def post_build_ex(config, functions): """Additional Post BIOS build function :param config: The environment variables to be used in the post build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("post_build_ex") fv_path = os.path.join(config["BUILD_DIR_PATH"], "FV") board_fd = config["BOARD"].upper() final_fd = os.path.join(fv_path, "{}.fd".format(board_fd)) final_ifwi = os.path.join(fv_path, "{}.bin".format(board_fd)) ifwi_ingredients_path = os.path.join(config["WORKSPACE_PLATFORM_BIN"], "Ifwi", config["BOARD"]) flash_descriptor = os.path.join(ifwi_ingredients_path, "FlashDescriptor.bin") intel_me = os.path.join(ifwi_ingredients_path, "Me.bin") _merge_files((flash_descriptor, intel_me, final_fd), final_ifwi) if os.path.isfile(final_fd): print("IFWI image can be found at {}".format(final_ifwi)) return None def clean_ex(config, functions): """Additional clean function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("clean_ex") return None
edk2-platforms-master
Platform/Intel/WhitleyOpenBoardPkg/BoardPortTemplate/build_board.py
# @ build_board.py # Extensions for building CooperCityRvp using build_bios.py # # Copyright (c) 2021, Intel Corporation. All rights reserved.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # """ This module serves as a sample implementation of the build extension scripts """ import os import sys def pre_build_ex(config, functions): """Additional Pre BIOS build function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: nothing """ print("pre_build_ex") config["BUILD_DIR_PATH"] = os.path.join(config["WORKSPACE"], 'Build', config["PLATFORM_BOARD_PACKAGE"], "{}_{}".format( config["TARGET"], config["TOOL_CHAIN_TAG"])) # set BUILD_DIR path config["BUILD_DIR"] = os.path.join('Build', config["PLATFORM_BOARD_PACKAGE"], "{}_{}".format( config["TARGET"], config["TOOL_CHAIN_TAG"])) config["BUILD_X64"] = os.path.join(config["BUILD_DIR_PATH"], 'X64') config["BUILD_IA32"] = os.path.join(config["BUILD_DIR_PATH"], 'IA32') if not os.path.isdir(config["BUILD_DIR_PATH"]): try: os.makedirs(config["BUILD_DIR_PATH"]) except OSError: print("Error while creating Build folder") sys.exit(1) #@todo: Replace this with PcdFspModeSelection if config.get("API_MODE_FSP_WRAPPER_BUILD", "FALSE") == "TRUE": config["EXT_BUILD_FLAGS"] += " -D FSP_MODE=0" else: config["EXT_BUILD_FLAGS"] += " -D FSP_MODE=1" return None def _merge_files(files, ofile): with open(ofile, 'wb') as of: for x in files: if not os.path.exists(x): return with open(x, 'rb') as f: of.write(f.read()) def build_ex(config, functions): """Additional BIOS build function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("build_ex") fv_path = os.path.join(config["BUILD_DIR_PATH"], "FV") binary_fd = os.path.join(fv_path, "BINARY.fd") main_fd = os.path.join(fv_path, "MAIN.fd") secpei_fd = os.path.join(fv_path, "SECPEI.fd") board_fd = config["BOARD"].upper() final_fd = os.path.join(fv_path, "{}.fd".format(board_fd)) _merge_files((binary_fd, main_fd, secpei_fd), final_fd) return None def post_build_ex(config, functions): """Additional Post BIOS build function :param config: The environment variables to be used in the post build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("post_build_ex") fv_path = os.path.join(config["BUILD_DIR_PATH"], "FV") board_fd = config["BOARD"].upper() final_fd = os.path.join(fv_path, "{}.fd".format(board_fd)) final_ifwi = os.path.join(fv_path, "{}.bin".format(board_fd)) ifwi_ingredients_path = os.path.join(config["WORKSPACE_PLATFORM_BIN"], "Ifwi", config["BOARD"]) flash_descriptor = os.path.join(ifwi_ingredients_path, "FlashDescriptor.bin") intel_me = os.path.join(ifwi_ingredients_path, "Me.bin") _merge_files((flash_descriptor, intel_me, final_fd), final_ifwi) if os.path.isfile(final_fd): print("IFWI image can be found at {}".format(final_ifwi)) return None def clean_ex(config, functions): """Additional clean function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("clean_ex") return None
edk2-platforms-master
Platform/Intel/WhitleyOpenBoardPkg/CooperCityRvp/build_board.py
# @ build_board.py # Extensions for building JunctionCity using build_bios.py # # # Copyright (c) 2021, Intel Corporation. All rights reserved.<BR> # Copyright (c) 2021, American Megatrends International LLC. <BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # """ This module serves as a sample implementation of the build extension scripts """ import os import sys def pre_build_ex(config, functions): """Additional Pre BIOS build function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: nothing """ print("pre_build_ex") config["BUILD_DIR_PATH"] = os.path.join(config["WORKSPACE"], 'Build', config["PLATFORM_BOARD_PACKAGE"], "{}_{}".format( config["TARGET"], config["TOOL_CHAIN_TAG"])) # set BUILD_DIR path config["BUILD_DIR"] = os.path.join('Build', config["PLATFORM_BOARD_PACKAGE"], "{}_{}".format( config["TARGET"], config["TOOL_CHAIN_TAG"])) config["BUILD_X64"] = os.path.join(config["BUILD_DIR_PATH"], 'X64') config["BUILD_IA32"] = os.path.join(config["BUILD_DIR_PATH"], 'IA32') if not os.path.isdir(config["BUILD_DIR_PATH"]): try: os.makedirs(config["BUILD_DIR_PATH"]) except OSError: print("Error while creating Build folder") sys.exit(1) #@todo: Replace this with PcdFspModeSelection if config.get("API_MODE_FSP_WRAPPER_BUILD", "FALSE") == "TRUE": config["EXT_BUILD_FLAGS"] += " -D FSP_MODE=0" else: config["EXT_BUILD_FLAGS"] += " -D FSP_MODE=1" if config.get("API_MODE_FSP_WRAPPER_BUILD", "FALSE") == "TRUE": raise ValueError("FSP API Mode is currently unsupported on Ice Lake Xeon Scalable") # Build the ACPI AML offset table *.offset.h print("Info: re-generating PlatformOffset header files") execute_script = functions.get("execute_script") # AML offset arch is X64, not sure if it matters. command = ["build", "-a", "X64", "-t", config["TOOL_CHAIN_TAG"], "-D", "MAX_SOCKET=" + config["MAX_SOCKET"]] if config["EXT_BUILD_FLAGS"] and config["EXT_BUILD_FLAGS"] != "": ext_build_flags = config["EXT_BUILD_FLAGS"].split(" ") ext_build_flags = [x.strip() for x in ext_build_flags] ext_build_flags = [x for x in ext_build_flags if x != ""] command.extend(ext_build_flags) aml_offsets_split = os.path.split(os.path.normpath(config["AML_OFFSETS_PATH"])) command.append("-p") command.append(os.path.normpath(config["AML_OFFSETS_PATH"]) + '.dsc') command.append("-m") command.append(os.path.join(aml_offsets_split[0], aml_offsets_split[1], aml_offsets_split[1] + '.inf')) command.append("-y") command.append(os.path.join(config["WORKSPACE"], "PreBuildReport.txt")) command.append("--log=" + os.path.join(config["WORKSPACE"], "PreBuild.log")) shell = True if os.name == "posix": # linux shell = False _, _, _, code = execute_script(command, config, shell=shell) if code != 0: print(" ".join(command)) print("Error re-generating PlatformOffset header files") sys.exit(1) # Build AmlGenOffset command to consume the *.offset.h and produce AmlOffsetTable.c for StaticSkuDataDxe use. # Get destination path and filename from config relative_file_path = os.path.normpath(config["STRIPPED_AML_OFFSETS_FILE_PATH"]) # get path relative to Platform/Intel out_file_path = os.path.join(config["WORKSPACE_PLATFORM"], relative_file_path) # full path to output file out_file_dir = os.path.dirname(out_file_path) # remove filename out_file_root_ext = os.path.splitext(os.path.basename(out_file_path)) # root and extension of output file # Get relative path for the generated offset.h file relative_dsdt_file_path = os.path.normpath(config["DSDT_TABLE_FILE_PATH"]) # path relative to Platform/Intel dsdt_file_root_ext = os.path.splitext(os.path.basename(relative_dsdt_file_path)) # root and extension of generated offset.h file # Generate output directory if it doesn't exist if not os.path.exists(out_file_dir): os.mkdir(out_file_dir) command = ["python", os.path.join(config["MIN_PACKAGE_TOOLS"], "AmlGenOffset", "AmlGenOffset.py"), "-d", "--aml_filter", config["AML_FILTER"], "-o", out_file_path, os.path.join(config["BUILD_X64"], aml_offsets_split[0], aml_offsets_split[1], aml_offsets_split[1], "OUTPUT", os.path.dirname(relative_dsdt_file_path), dsdt_file_root_ext[0] + ".offset.h")] # execute the command _, _, _, code = execute_script(command, config, shell=shell) if code != 0: print(" ".join(command)) print("Error re-generating PlatformOffset header files") sys.exit(1) print("GenOffset done") return None def _merge_files(files, ofile): with open(ofile, 'wb') as of: for x in files: if not os.path.exists(x): return with open(x, 'rb') as f: of.write(f.read()) def build_ex(config, functions): """Additional BIOS build function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("build_ex") fv_path = os.path.join(config["BUILD_DIR_PATH"], "FV") binary_fd = os.path.join(fv_path, "BINARY.fd") main_fd = os.path.join(fv_path, "MAIN.fd") secpei_fd = os.path.join(fv_path, "SECPEI.fd") board_fd = config["BOARD"].upper() final_fd = os.path.join(fv_path, "{}.fd".format(board_fd)) _merge_files((binary_fd, main_fd, secpei_fd), final_fd) return None def post_build_ex(config, functions): """Additional Post BIOS build function :param config: The environment variables to be used in the post build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("post_build_ex") fv_path = os.path.join(config["BUILD_DIR_PATH"], "FV") board_fd = config["BOARD"].upper() final_fd = os.path.join(fv_path, "{}.fd".format(board_fd)) final_ifwi = os.path.join(fv_path, "{}.bin".format(board_fd)) ifwi_ingredients_path = os.path.join(config["WORKSPACE_PLATFORM_BIN"], "Ifwi", config["BOARD"]) flash_descriptor = os.path.join(ifwi_ingredients_path, "FlashDescriptor.bin") intel_me = os.path.join(ifwi_ingredients_path, "Me.bin") _merge_files((flash_descriptor, intel_me, final_fd), final_ifwi) if os.path.isfile(final_fd): print("IFWI image can be found at {}".format(final_ifwi)) return None def clean_ex(config, functions): """Additional clean function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("clean_ex") return None
edk2-platforms-master
Platform/Intel/WhitleyOpenBoardPkg/JunctionCity/build_board.py
# @ build_board.py # Extensions for building Aowanda using build_bios.py # # # Copyright (c) 2021, Intel Corporation. All rights reserved.<BR> # Copyright (c) 2022, American Megatrends International LLC. <BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # """ This module serves as a sample implementation of the build extension scripts """ import os import sys def pre_build_ex(config, functions): """Additional Pre BIOS build function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: nothing """ print("pre_build_ex") config["BUILD_DIR_PATH"] = os.path.join(config["WORKSPACE"], 'Build', config["PLATFORM_BOARD_PACKAGE"], "{}_{}".format( config["TARGET"], config["TOOL_CHAIN_TAG"])) # set BUILD_DIR path config["BUILD_DIR"] = os.path.join('Build', config["PLATFORM_BOARD_PACKAGE"], "{}_{}".format( config["TARGET"], config["TOOL_CHAIN_TAG"])) config["BUILD_X64"] = os.path.join(config["BUILD_DIR_PATH"], 'X64') config["BUILD_IA32"] = os.path.join(config["BUILD_DIR_PATH"], 'IA32') if not os.path.isdir(config["BUILD_DIR_PATH"]): try: os.makedirs(config["BUILD_DIR_PATH"]) except OSError: print("Error while creating Build folder") sys.exit(1) #@todo: Replace this with PcdFspModeSelection if config.get("API_MODE_FSP_WRAPPER_BUILD", "FALSE") == "TRUE": config["EXT_BUILD_FLAGS"] += " -D FSP_MODE=0" else: config["EXT_BUILD_FLAGS"] += " -D FSP_MODE=1" if config.get("API_MODE_FSP_WRAPPER_BUILD", "FALSE") == "TRUE": raise ValueError("FSP API Mode is currently unsupported on Ice Lake Xeon Scalable") # Build the ACPI AML offset table *.offset.h print("Info: re-generating PlatformOffset header files") execute_script = functions.get("execute_script") # AML offset arch is X64, not sure if it matters. command = ["build", "-a", "X64", "-t", config["TOOL_CHAIN_TAG"], "-D", "MAX_SOCKET=" + config["MAX_SOCKET"]] if config["EXT_BUILD_FLAGS"] and config["EXT_BUILD_FLAGS"] != "": ext_build_flags = config["EXT_BUILD_FLAGS"].split(" ") ext_build_flags = [x.strip() for x in ext_build_flags] ext_build_flags = [x for x in ext_build_flags if x != ""] command.extend(ext_build_flags) aml_offsets_split = os.path.split(os.path.normpath(config["AML_OFFSETS_PATH"])) command.append("-p") command.append(os.path.normpath(config["AML_OFFSETS_PATH"]) + '.dsc') command.append("-m") command.append(os.path.join(aml_offsets_split[0], aml_offsets_split[1], aml_offsets_split[1] + '.inf')) command.append("-y") command.append(os.path.join(config["WORKSPACE"], "PreBuildReport.txt")) command.append("--log=" + os.path.join(config["WORKSPACE"], "PreBuild.log")) shell = True if os.name == "posix": # linux shell = False _, _, _, code = execute_script(command, config, shell=shell) if code != 0: print(" ".join(command)) print("Error re-generating PlatformOffset header files") sys.exit(1) # Build AmlGenOffset command to consume the *.offset.h and produce AmlOffsetTable.c for StaticSkuDataDxe use. # Get destination path and filename from config relative_file_path = os.path.normpath(config["STRIPPED_AML_OFFSETS_FILE_PATH"]) # get path relative to Platform/Intel out_file_path = os.path.join(config["WORKSPACE_PLATFORM"], relative_file_path) # full path to output file out_file_dir = os.path.dirname(out_file_path) # remove filename out_file_root_ext = os.path.splitext(os.path.basename(out_file_path)) # root and extension of output file # Get relative path for the generated offset.h file relative_dsdt_file_path = os.path.normpath(config["DSDT_TABLE_FILE_PATH"]) # path relative to Platform/Intel dsdt_file_root_ext = os.path.splitext(os.path.basename(relative_dsdt_file_path)) # root and extension of generated offset.h file # Generate output directory if it doesn't exist if not os.path.exists(out_file_dir): os.mkdir(out_file_dir) command = ["python", os.path.join(config["MIN_PACKAGE_TOOLS"], "AmlGenOffset", "AmlGenOffset.py"), "-d", "--aml_filter", config["AML_FILTER"], "-o", out_file_path, os.path.join(config["BUILD_X64"], aml_offsets_split[0], aml_offsets_split[1], aml_offsets_split[1], "OUTPUT", os.path.dirname(relative_dsdt_file_path), dsdt_file_root_ext[0] + ".offset.h")] # execute the command _, _, _, code = execute_script(command, config, shell=shell) if code != 0: print(" ".join(command)) print("Error re-generating PlatformOffset header files") sys.exit(1) print("GenOffset done") return None def _merge_files(files, ofile): with open(ofile, 'wb') as of: for x in files: if not os.path.exists(x): return with open(x, 'rb') as f: of.write(f.read()) def build_ex(config, functions): """Additional BIOS build function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("build_ex") fv_path = os.path.join(config["BUILD_DIR_PATH"], "FV") binary_fd = os.path.join(fv_path, "BINARY.fd") main_fd = os.path.join(fv_path, "MAIN.fd") secpei_fd = os.path.join(fv_path, "SECPEI.fd") board_fd = config["BOARD"].upper() final_fd = os.path.join(fv_path, "{}.fd".format(board_fd)) _merge_files((binary_fd, main_fd, secpei_fd), final_fd) return None def post_build_ex(config, functions): """Additional Post BIOS build function :param config: The environment variables to be used in the post build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("post_build_ex") fv_path = os.path.join(config["BUILD_DIR_PATH"], "FV") board_fd = config["BOARD"].upper() final_fd = os.path.join(fv_path, "{}.fd".format(board_fd)) final_ifwi = os.path.join(fv_path, "{}.bin".format(board_fd)) ifwi_ingredients_path = os.path.join(config["WORKSPACE_PLATFORM_BIN"], "Ifwi", config["BOARD"]) flash_descriptor = os.path.join(ifwi_ingredients_path, "FlashDescriptor.bin") intel_me = os.path.join(ifwi_ingredients_path, "Me.bin") _merge_files((flash_descriptor, intel_me, final_fd), final_ifwi) if os.path.isfile(final_fd): print("IFWI image can be found at {}".format(final_ifwi)) return None def clean_ex(config, functions): """Additional clean function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("clean_ex") return None
edk2-platforms-master
Platform/Intel/WhitleyOpenBoardPkg/Aowanda/build_board.py
# @ build_board.py # This is a sample code provides Optional dynamic imports # of build functions to the BuildBios.py script # # Copyright (c) 2019, Intel Corporation. All rights reserved.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # """ This module serves as a sample implementation of the build extension scripts """ def pre_build_ex(config, functions): """Additional Pre BIOS build function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: nothing """ print("pre_build_ex") return None def build_ex(config, functions): """Additional BIOS build function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("build_ex") return None def post_build_ex(config, functions): """Additional Post BIOS build function :param config: The environment variables to be used in the post build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("post_build_ex") return None def clean_ex(config, functions): """Additional clean function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("clean_ex") return None
edk2-platforms-master
Platform/Intel/KabylakeOpenBoardPkg/KabylakeRvp3/build_board.py
# @ build_board.py # This adds additional functions to the build_bios.py # # Copyright (c) 2019, Intel Corporation. All rights reserved.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # """ This module serves as an additional build steps for the Mt Olympus board """ import os import sys def pre_build_ex(config, functions): """Additional Pre BIOS build function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: nothing """ print("Info: re-generating PlatformOffset header files") execute_script = functions.get("execute_script") command = ["build", "-D", "MAX_SOCKET=" + config.get("MAX_SOCKET", "1"), "-m", os.path.join(config["PLATFORM_BOARD_PACKAGE"], "Acpi", "BoardAcpiDxe", "Dsdt.inf"), "-y", config.get("PRE_BUILD_REPORT", os.path.join(config["WORKSPACE"], "preBuildReport.txt")), "--log=" + config.get("PRE_BUILD_LOG", os.path.join(config["WORKSPACE"], "prebuild.log"))] _, _, _, code = execute_script(command, config) if code != 0: print(" ".join(command)) print("Error re-generating PlatformOffset header files") sys.exit(1) config["AML_FILTER"] = "\"PSYS\" .MCTL\" .FIX[0-9,A-Z]\"" print("AML_FILTER= ", config.get("AML_FILTER")) # build the command with arguments command = ["python", os.path.join(config["MIN_PACKAGE_TOOLS"], "AmlGenOffset", "AmlGenOffset.py"), "-d", "--aml_filter", config["AML_FILTER"], "-o", os.path.join(config["WORKSPACE_PLATFORM"], config["PLATFORM_BOARD_PACKAGE"], "Acpi", "BoardAcpiDxe", "AmlOffsetTable.c"), os.path.join(config["BUILD_X64"], "PurleyOpenBoardPkg", "Acpi", "BoardAcpiDxe", "DSDT", "OUTPUT", "Dsdt", "WFPPlatform.offset.h")] # execute the command _, _, _, code = execute_script(command, config) if code != 0: print(" ".join(command)) print("Error re-generating PlatformOffset header files") sys.exit(1) print("GenOffset done") return config def build_ex(config, functions): """Additional BIOS build function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("build_ex") return None def post_build_ex(config, functions): """Additional Post BIOS build function :param config: The environment variables to be used in the post build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("post_build_ex") execute_script = functions.get("execute_script") if not execute_script: print("post_build_ex Error") sys.exit(1) common_patch_command = [os.path.join(config["PYTHON_HOME"], "python"), os.path.join(config["MIN_PACKAGE_TOOLS"], "PatchFv", "PatchBinFv.py"), config["TARGET"], os.path.join(config["WORKSPACE_SILICON_BIN"], "PurleySiliconBinPkg", "FV"), os.path.join(config["WORKSPACE"], "BuildReport.log")] fvs_to_patch = ["FvTempMemorySilicon", "FvPreMemorySilicon", "FvPostMemorySilicon", "FvLateSilicon"] for fv in fvs_to_patch: patch_command = common_patch_command + [fv] _, _, _, code = execute_script(patch_command, config) if code != 0: print(" ".join(patch_command)) print("Patch Error!") sys.exit(1) common_rebase_command = [os.path.join(config["PYTHON_HOME"], "python"), os.path.join(config["MIN_PACKAGE_TOOLS"], "PatchFv", "RebaseBinFv.py"), config["TARGET"], os.path.join(config["WORKSPACE_SILICON_BIN"], "PurleySiliconBinPkg", "FV"), os.path.join(config["WORKSPACE"], "BuildReport.log")] rebase_command = common_rebase_command +\ ["FvPreMemorySilicon", "gMinPlatformPkgTokenSpaceGuid.PcdFlashFvFspMBase"] _, _, _, code = execute_script(rebase_command, config) if code != 0: print(" ".join(rebase_command)) print("Patch Error!") sys.exit(1) rebase_command = common_rebase_command +\ ["FvPostMemorySilicon", "gMinPlatformPkgTokenSpaceGuid.PcdFlashFvFspSBase"] _, _, _, code = execute_script(rebase_command, config) if code != 0: print(" ".join(rebase_command)) print("Patch Error!") sys.exit(1) return None def clean_ex(config, functions): """Additional clean function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("clean_ex") return None
edk2-platforms-master
Platform/Intel/PurleyOpenBoardPkg/BoardMtOlympus/build_board.py
# @ build_board.py # This adds additional functions to the build_bios.py # # Copyright (c) 2018, Intel Corporation. All rights reserved.<BR> # Copyright (c) 2021, American Megatrends International LLC.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent # """ This module serves as an additional build steps for the Tioga Pass board """ import os import sys def pre_build_ex(config, functions): """Additional Pre BIOS build function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: nothing """ print("Info: re-generating PlatformOffset header files") execute_script = functions.get("execute_script") command = ["build", "-D", "MAX_SOCKET=" + config.get("MAX_SOCKET", "1"), "-m", os.path.join(config["PLATFORM_BOARD_PACKAGE"], "Acpi", "BoardAcpiDxe", "Dsdt.inf"), "-y", config.get("PRE_BUILD_REPORT", os.path.join(config["WORKSPACE"], "preBuildReport.txt")), "--log=" + config.get("PRE_BUILD_LOG", os.path.join(config["WORKSPACE"], "prebuild.log"))] _, _, _, code = execute_script(command, config) if code != 0: print(" ".join(command)) print("Error re-generating PlatformOffset header files") sys.exit(1) config["AML_FILTER"] = "\"PSYS\" .MCTL\" .FIX[0-9,A-Z]\"" print("AML_FILTER= ", config.get("AML_FILTER")) # build the command with arguments command = ["python", os.path.join(config["MIN_PACKAGE_TOOLS"], "AmlGenOffset", "AmlGenOffset.py"), "-d", "--aml_filter", config["AML_FILTER"], "-o", os.path.join(config["WORKSPACE_PLATFORM"], config["PLATFORM_BOARD_PACKAGE"], "Acpi", "BoardAcpiDxe", "AmlOffsetTable.c"), os.path.join(config["BUILD_X64"], "PurleyOpenBoardPkg", "Acpi", "BoardAcpiDxe", "DSDT", "OUTPUT", "Dsdt", "WFPPlatform.offset.h")] # execute the command _, _, _, code = execute_script(command, config) if code != 0: print(" ".join(command)) print("Error re-generating PlatformOffset header files") sys.exit(1) print("GenOffset done") return config def build_ex(config, functions): """Additional BIOS build function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("build_ex") return None def post_build_ex(config, functions): """Additional Post BIOS build function :param config: The environment variables to be used in the post build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("post_build_ex") execute_script = functions.get("execute_script") if not execute_script: print("post_build_ex Error") sys.exit(1) common_patch_command = [os.path.join(config["PYTHON_HOME"], "python"), os.path.join(config["MIN_PACKAGE_TOOLS"], "PatchFv", "PatchBinFv.py"), config["TARGET"], os.path.join(config["WORKSPACE_SILICON_BIN"], "PurleySiliconBinPkg", "FV"), os.path.join(config["WORKSPACE"], "BuildReport.log")] fvs_to_patch = ["FvTempMemorySilicon", "FvPreMemorySilicon", "FvPostMemorySilicon", "FvLateSilicon"] for fv in fvs_to_patch: patch_command = common_patch_command + [fv] _, _, _, code = execute_script(patch_command, config) if code != 0: print(" ".join(patch_command)) print("Patch Error!") sys.exit(1) common_rebase_command = [os.path.join(config["PYTHON_HOME"], "python"), os.path.join(config["MIN_PACKAGE_TOOLS"], "PatchFv", "RebaseBinFv.py"), config["TARGET"], os.path.join(config["WORKSPACE_SILICON_BIN"], "PurleySiliconBinPkg", "FV"), os.path.join(config["WORKSPACE"], "BuildReport.log")] rebase_command = common_rebase_command +\ ["FvPreMemorySilicon", "gMinPlatformPkgTokenSpaceGuid.PcdFlashFvFspMBase"] _, _, _, code = execute_script(rebase_command, config) if code != 0: print(" ".join(rebase_command)) print("Patch Error!") sys.exit(1) rebase_command = common_rebase_command +\ ["FvPostMemorySilicon", "gMinPlatformPkgTokenSpaceGuid.PcdFlashFvFspSBase"] _, _, _, code = execute_script(rebase_command, config) if code != 0: print(" ".join(rebase_command)) print("Patch Error!") sys.exit(1) common_patchbfv_command = [os.path.join(config["PYTHON_HOME"], "python"), os.path.join(config["MIN_PACKAGE_TOOLS"], "PatchFv", "PatchBfv.py"), os.path.join(config["BUILD_DIR_PATH"], "FV", "PLATFORM.fd"), os.path.join(config["WORKSPACE"], "BuildReport.log")] patchbfv_command = common_patchbfv_command +\ ["gMinPlatformPkgTokenSpaceGuid.PcdFlashFvPreMemoryBase"] _, _, _, code = execute_script(patchbfv_command, config) if code != 0: print(" ".join(patchbfv_command)) print("Patch Error!") sys.exit(1) return None def clean_ex(config, functions): """Additional clean function :param config: The environment variables to be used in the build process :type config: Dictionary :param functions: A dictionary of function pointers :type functions: Dictionary :returns: config dictionary :rtype: Dictionary """ print("clean_ex") return None
edk2-platforms-master
Platform/Intel/PurleyOpenBoardPkg/BoardTiogaPass/build_board.py
edk2-platforms-master
Platform/Intel/PurleyOpenBoardPkg/BoardTiogaPass/__init__.py
## @file # This file contains the script to build UniversalPayload with platform payload # # Copyright (c) 2022, Intel Corporation. All rights reserved.<BR> # SPDX-License-Identifier: BSD-2-Clause-Patent ## import argparse import subprocess import os import shutil import sys from ctypes import * sys.dont_write_bytecode = True def RunCommand(cmd): print(cmd) p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,cwd=os.environ['WORKSPACE']) while True: line = p.stdout.readline() if not line: break print(line.strip().decode(errors='ignore')) p.communicate() if p.returncode != 0: print("- Failed - error happened when run command: %s"%cmd) raise Exception("ERROR: when run command: %s"%cmd) def BuildUniversalPayload(Args, MacroList): BuildTarget = Args.Target ToolChain = Args.ToolChain ElfToolChain = 'CLANGDWARF' ObjCopyFlag = "elf64-x86-64" if Args.Arch == 'X64' else "elf32-i386" # # Find universal UEFI payload build build script # Edk2PayloadBuildScript = os.path.normpath("UefiPayloadPkg/UniversalPayloadBuild.py") for package_path in os.environ['PACKAGES_PATH'].split(os.pathsep): if os.path.exists (os.path.join (package_path, Edk2PayloadBuildScript)): Edk2PayloadBuildScript = os.path.join (package_path, Edk2PayloadBuildScript) break if not os.path.exists (Edk2PayloadBuildScript): raise Exception("Could not find universal UEFI payload build script UniversalPayloadBuild.py") PlatformFvDscPath = os.path.normpath("PlatformPayloadFeaturePkg/PlatformPayloadFeaturePkg.dsc") BuildDir = os.path.join(os.environ['WORKSPACE'], os.path.normpath("Build/UefiPayloadPkgX64")) PlatformFvReportPath = os.path.join(BuildDir, "PlatformPayloadReport.txt") UniversalUefiPld = os.path.join(BuildDir, 'UniversalPayload.elf') PlatformFv = os.path.join(os.environ['WORKSPACE'], os.path.normpath("Build/PlatformPayloadFeaturePkg"), f"{BuildTarget}_{ToolChain}", os.path.normpath("FV/PLATFORMPAYLOAD.Fv")) if "CLANG_BIN" in os.environ: LlvmObjcopyPath = os.path.join(os.environ["CLANG_BIN"], "llvm-objcopy") else: LlvmObjcopyPath = "llvm-objcopy" try: RunCommand('"%s" --version'%LlvmObjcopyPath) except: print("- Failed - Please check if LLVM is installed or if CLANG_BIN is set correctly") sys.exit(1) Defines = "" for key in MacroList: Defines +=" -D {0}={1}".format(key, MacroList[key]) # # Building Universal Payload entry. # if not Args.Skip: BuildPayload = f"python {Edk2PayloadBuildScript} -b {BuildTarget} -t {ToolChain} -a {Args.Arch} {Defines}" RunCommand(BuildPayload) # # Building Platform Payload. # BuildPayload = f"build -p {PlatformFvDscPath} -b {BuildTarget} -a X64 -t {ToolChain} -y {PlatformFvReportPath}" BuildPayload += Defines RunCommand(BuildPayload) # # Copy the Platform Payload as a section in elf format Universal Payload. # remove_section = f'"{LlvmObjcopyPath}" -I {ObjCopyFlag} -O {ObjCopyFlag} --remove-section .upld.platform_fv {UniversalUefiPld}' add_section = f'"{LlvmObjcopyPath}" -I {ObjCopyFlag} -O {ObjCopyFlag} --add-section .upld.platform_fv={PlatformFv} {UniversalUefiPld}' set_section = f'"{LlvmObjcopyPath}" -I {ObjCopyFlag} -O {ObjCopyFlag} --set-section-alignment .upld.platform_fv=16 {UniversalUefiPld}' RunCommand(remove_section) RunCommand(add_section) RunCommand(set_section) def main(): parser = argparse.ArgumentParser(description='Build Platform Payload FV and add it to Universal UEFI Payload') parser.add_argument('-t', '--ToolChain') parser.add_argument('-b', '--Target', default='DEBUG') parser.add_argument('-a', '--Arch', choices=['IA32', 'X64'], help='Specify the ARCH for payload entry module. Default build X64 image.', default ='X64') parser.add_argument("-D", "--Macro", action="append") parser.add_argument('-s', '--Skip', action='store_true', help='Skip Universal UEFI payload build (just build platform FV and add to Universal UEFI payload.') MacroList = {} args = parser.parse_args() if args.Macro is not None: for Argument in args.Macro: if Argument.count('=') != 1: print("Unknown variable passed in: %s"%Argument) raise Exception("ERROR: Unknown variable passed in: %s"%Argument) tokens = Argument.strip().split('=') MacroList[tokens[0].upper()] = tokens[1] BuildUniversalPayload(args, MacroList) print ("Successfully build Universal Payload with platform FV") if __name__ == '__main__': main()
edk2-platforms-master
Features/Intel/PlatformPayloadFeaturePkg/PlatformPayloadFeaturePkg.py
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import setuptools with open("README.md", "r") as fh: long_description = fh.read() setuptools.setup( name="nvidia-clara-client", version="0.8.1.7", author="NVIDIA Clara Deploy", description="Python package to interact with Clara Platform Server API", license='Apache Software License (http://www.apache.org/licenses/LICENSE-2.0)', long_description=long_description, long_description_content_type="text/markdown", url="https://github.com/NVIDIA/clara-platform-python-client", install_requires=['grpcio', 'protobuf'], packages=setuptools.find_packages('.'), classifiers=[ "Programming Language :: Python :: 3", "Operating System :: OS Independent", 'License :: OSI Approved :: Apache Software License' ], python_requires='>=3.6', )
clara-platform-python-client-main
setup.py
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from typing import List, Mapping from nvidia_clara.grpc import common_pb2 class PipelineDefinition: def __init__(self, content: str = None, name: str = None): self._content = content self._name = name @property def content(self) -> str: """Text content of a pipeline definition. Content is typed as a "System.String" to avoid encoding related issues.""" return self._content @content.setter def content(self, content: str): """Text content of a pipeline definition. Content is typed as a "System.String" to avoid encoding related issues.""" self._content = content @property def name(self) -> str: """The name of the pipeline definition. Not the name of the pipeline as defined by the definition. Example: clara/examples/my-pipeline.yml """ return self._name @name.setter def name(self, name: str): """The name of the pipeline definition. Not the name of the pipeline as defined by the definition. Example: clara/examples/my-pipeline.yml """ self._name = name class PipelineId: def __init__(self, value: str): if (value == "") or (value is None): raise Exception("Value arguement must be initialized to non-null value") self._value = value @property def value(self): return self._value def __eq__(self, other): return self._value == other._value def __ne__(self, other): return not (self == other) def __repr__(self): return "%s" % (self._value) def __str__(self): return "%s" % (self._value) def __hash__(self): return hash(self._value) def to_grpc_value(self): id = common_pb2.Identifier() id.value = self._value return id class PipelineDetails: def __init__(self, pipeline_id: PipelineId = None, name: str = None, definition: List[PipelineDefinition] = None, metadata: Mapping[str, str] = None): if definition is None: definition = [] if metadata is None: metadata = dict() self._pipeline_id = pipeline_id self._name = name self._definition = definition self._metadata = metadata @property def pipeline_id(self) -> PipelineId: """Unique identifier of the pipeline.""" return self._pipeline_id @pipeline_id.setter def pipeline_id(self, pipeline_id: PipelineId): """Unique identifier of the pipeline.""" self._pipeline_id = pipeline_id @property def name(self) -> str: """ Human readable name of the pipeline. Not guaranteed to be unique. """ return self._name @name.setter def name(self, name: str): """ Human readable name of the pipeline. Not guaranteed to be unique. """ self._name = name @property def definition(self) -> List[PipelineDefinition]: """ The definition of the pipeline. Clara pipeline definitions can be multi-file. """ return self._definition @definition.setter def definition(self, definition: List[PipelineDefinition]): """ The definition of the pipeline. Clara pipeline definitions can be multi-file. """ self._definition = definition @property def metadata(self) -> Mapping[str, str]: """ Metadata (set of key/value pairs) associated with the pipeline """ return self._metadata @metadata.setter def metadata(self, metadata: Mapping[str, str]): """ Metadata (set of key/value pairs) associated with the pipeline """ self._metadata = metadata class PipelineInfo: def __init__(self, pipeline_id: PipelineId = None, name: str = None, metadata: Mapping[str, str] = None): if metadata is None: metadata = dict() self._pipeline_id = pipeline_id self._name = name self._metadata = metadata @property def pipeline_id(self) -> PipelineId: """Unique identifier of the pipeline.""" return self._pipeline_id @pipeline_id.setter def pipeline_id(self, pipeline_id: PipelineId): """Unique identifier of the pipeline.""" self._pipeline_id = pipeline_id @property def name(self) -> str: """ Human readable name of the pipeline. Not guaranteed to be unique. """ return self._name @name.setter def name(self, name: str): """ Human readable name of the pipeline. Not guaranteed to be unique. """ self._name = name @property def metadata(self) -> Mapping[str, str]: """ Metadata (set of key/value pairs) associated with the pipeline """ return self._metadata @metadata.setter def metadata(self, metadata: Mapping[str, str]): """ Metadata (set of key/value pairs) associated with the pipeline """ self._metadata = metadata
clara-platform-python-client-main
nvidia_clara/pipeline_types.py
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from typing import List, Mapping import grpc from nvidia_clara.grpc import pipelines_pb2, pipelines_pb2_grpc import nvidia_clara.pipeline_types as pipeline_types from nvidia_clara.base_client import BaseClient, RequestIterator class PipelinesClientStub: def create_pipeline(self, definition: List[pipeline_types.PipelineDefinition], pipeline_id: pipeline_types.PipelineId = None, metadata: Mapping[str, str] = None) -> pipeline_types.PipelineId: """ Requests the creation of a new pipeline by Clara. Args: definition(List[pipeline_types.PipelineDefinition]): Definition from which to create the new pipeline. pipeline_id: Optional argument to force a specific pipeline identifier when replicating deployments. Use ONLY with a high available primary-primary fail-over solution in place AND full understanding on what it does. metadata(Mapping[str, str]): Set of key/value pairs to be appended to the pipeline metadata. If a metadata key in the request already exists in the pipeline record, or if duplicate keys are passed in the request, the pipeline will not be updated and and an error will be returned. Keys are compared using case insensitive comparator functions. The maximum allowed size of a metadata key is 128 bytes, while the maximum allowed size of a metadata value is 256 bytes. The maximum allowed size for the overall metadata of an individual job is 4 Megabytes. Returns: pipeline_types.PipelineId of newly created pipeline """ pass def list_pipelines(self) -> List[pipeline_types.PipelineInfo]: """ Requests a list of pipelines from Clara. Returns: List of pipeline_types.PipelineInfo with running pipeline information """ pass def pipeline_details(self, pipeline_id: pipeline_types.PipelineId) -> pipeline_types.PipelineDetails: """ Requests details of a pipeline, identified by pipeline_types.PipelineId, from Clara. Args: pipeline_id (pipeline_types.PipelineId): Unique identifier of the pipeline. Return: A pipeline_types.PipelineDetails instance with details on the pipeline specified by 'pipeline_id' """ pass def remove_pipeline(self, pipeline_id: pipeline_types.PipelineId): """ Removes a pipeline, identified by "pipelineId", from Clara. Args: pipeline_id (pipeline_types.PipelineId): Unique identifier of the pipeline """ pass def update_pipeline(self, pipeline_id: pipeline_types.PipelineId, definition: List[pipeline_types.PipelineDefinition]): """ Requests a pipeline, identified by "pipelineId", be updated by Clara. Args: pipeline_id (pipeline_types.PipelineId): Unique identifier of the pipeline. definition: Definition from which to update the pipeline. """ pass def add_metadata(self, pipeline_id: pipeline_types.PipelineId, metadata: Mapping[str, str]) -> Mapping[str, str]: """ Requests the addition of metadata to a pipeline. Args: pipeline_id (pipeline_types.PipelineId): Unique identifier of the pipeline whose metadata is to be appended. metadata(Mapping[str, str]): Set of key/value pairs to be appended to the pipeline metadata. If a metadata key in the request already exists in the pipeline record, or if duplicate keys are passed in the request, the pipeline will not be updated and and an error will be returned. Keys are compared using case insensitive comparator functions. The maximum allowed size of a metadata key is 128 bytes, while the maximum allowed size of a metadata value is 256 bytes. The maximum allowed size for the overall metadata of an individual job is 4 Megabytes. Returns: A Mapping[str, str] containing the appended metadata """ pass def remove_metadata(self, pipeline_id: pipeline_types.PipelineId, keys: List[str]) -> Mapping[str, str]: """ Requests the removal of specified metadata of a pipeline. Args: pipeline_id: Unique identifier of the pipeline whose metadata is to be removed. keys: List of keys to be removed from the pipeline metadata. Returns: A Mapping[str, str] containing the updated set of metadata """ pass class PipelinesClient(BaseClient, PipelinesClientStub): def __init__(self, target: str, port: str = None, stub=None): """ Pipelines Client Creation Args: target (str): ipv4 address of clara instance port (str): if specified, port will be appended to the target with a ":" """ if target is None: raise Exception("Target must be initialized to a non-null value") self._connection = target if port is not None: self._connection += ":" + port self._channel = grpc.insecure_channel(self._connection) if stub is None: self._stub = pipelines_pb2_grpc.PipelinesStub(self._channel) else: self._stub = stub def close(self): """ Close connection """ if self._channel: self._channel.close() self._channel = None else: print("Connection for client already closed") def reconnect(self): """ Re-open connection with existing channel """ if self._channel is None: self._channel = grpc.insecure_channel(self._connection) self._stub = pipelines_pb2_grpc.PipelinesStub(self._channel) else: print("Connection for client already open") def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): if self._channel is not None: self.close() return False def create_pipeline(self, definition: List[pipeline_types.PipelineDefinition], pipeline_id: pipeline_types.PipelineId = None, metadata: Mapping[str, str] = None, timeout=None) -> pipeline_types.PipelineId: """ Requests the creation of a new pipeline by Clara. Args: definition(List[pipeline_types.PipelineDefinition]): Definition from which to create the new pipeline. pipeline_id: Optional argument to force a specific pipeline identifier when replicating deployments. Use ONLY with a high available primary-primary fail-over solution in place AND full understanding on what it does. metadata(Mapping[str, str]): Set of key/value pairs to be appended to the pipeline metadata. If a metadata key in the request already exists in the pipeline record, or if duplicate keys are passed in the request, the pipeline will not be updated and and an error will be returned. Keys are compared using case insensitive comparator functions. The maximum allowed size of a metadata key is 128 bytes, while the maximum allowed size of a metadata value is 256 bytes. The maximum allowed size for the overall metadata of an individual job is 4 Megabytes. Returns: pipeline_types.PipelineId of newly created pipeline """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if definition is None: raise Exception("Argument 'definition' must be initialized to a non-null list instance") request_list = [] for item in definition: item_definition = pipelines_pb2.PipelineDefinitionFile( content=item.content, path=item.name ) # If pipeline identifier set, must first be in GRPC Identifier format if pipeline_id is not None: pipeline_id = pipeline_id.to_grpc_value() request = pipelines_pb2.PipelinesCreateRequest( definition=item_definition, pipeline_id=pipeline_id, header=self.get_request_header() ) if metadata is not None: request.metadata.update(metadata) request_list.append(request) request_list = RequestIterator(request_list) response = self._stub.Create( request_list(), timeout=timeout ) self.check_response_header(header=response.header) return pipeline_types.PipelineId(response.pipeline_id.value) def list_pipelines(self, timeout=None) -> List[pipeline_types.PipelineInfo]: """ Requests a list of pipelines from Clara. Returns: List of pipeline_types.PipelineInfo with running pipeline information """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") request = pipelines_pb2.PipelinesListRequest( header=self.get_request_header() ) response = self._stub.List(request, timeout=timeout) info_list = [] responses = [resp for resp in response] if len(responses) > 0: for item in responses: if (item.details is None) or (item.details.pipeline_id.value == ''): continue info = pipeline_types.PipelineInfo( pipeline_id=pipeline_types.PipelineId(item.details.pipeline_id.value), name=item.details.name, metadata=item.details.metadata ) info_list.append(info) return info_list def pipeline_details(self, pipeline_id: pipeline_types.PipelineId, timeout=None) -> pipeline_types.PipelineDetails: """ Requests details of a pipeline, identified by pipeline_types.PipelineId, from Clara. Args: pipeline_id (pipeline_types.PipelineId): Unique identifier of the pipeline. Return: A pipeline_types.PipelineDetails instance with details on the pipeline specified by 'pipeline_id' """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if pipeline_id.value is None or pipeline_id.value == "": raise Exception("Pipeline identifier argument must be initialized with non-null instance") request = pipelines_pb2.PipelinesDetailsRequest( header=self.get_request_header(), pipeline_id=pipeline_id.to_grpc_value(), ) response = self._stub.Details(request, timeout=timeout) responses = [resp for resp in response] if len(responses) > 0: self.check_response_header(header=responses[0].header) result = pipeline_types.PipelineDetails( name=responses[0].name, pipeline_id=pipeline_types.PipelineId(responses[0].pipeline_id.value), metadata=responses[0].metadata ) result_definition = [] for resp in responses: result_definition.append( pipeline_types.PipelineDefinition( name=resp.name, content=resp.definition ) ) result.definition = result_definition return result return None def remove_pipeline(self, pipeline_id: pipeline_types.PipelineId, timeout=None): """ Removes a pipeline, identified by "pipelineId", from Clara. Args: pipeline_id (pipeline_types.PipelineId): Unique identifier of the pipeline """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if pipeline_id.value is None or pipeline_id.value == "": raise Exception("Pipeline identifier argument must be initialized with non-null instance") request = pipelines_pb2.PipelinesRemoveRequest( header=self.get_request_header(), pipeline_id=pipeline_id.to_grpc_value() ) response = self._stub.Remove(request, timeout=timeout) self.check_response_header(header=response.header) def update_pipeline(self, pipeline_id: pipeline_types.PipelineId, definition: List[pipeline_types.PipelineDefinition], timeout=None): """ Requests a pipeline, identified by "pipelineId", be updated by Clara. Args: pipeline_id (pipeline_types.PipelineId): Unique identifier of the pipeline. definition: Definition from which to update the pipeline. """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if pipeline_id.value is None or pipeline_id.value == "": raise Exception("Pipeline identifier argument must be initialized with non-null instance") if definition is None: raise Exception( "Pipeline definition argument must be initialized" "with non-null instnace of List[pipeline_types.PipelineDefinition]") request_list = [] for item in definition: request = pipelines_pb2.PipelinesUpdateRequest( definition=pipelines_pb2.PipelineDefinitionFile( content=item.content, path=item.name ), header=self.get_request_header(), pipeline_id=pipeline_id.to_grpc_value() ) request_list.append(request) request_list = RequestIterator(request_list) response = self._stub.Update(request_list(), timeout=timeout) self.check_response_header(header=response.header) def add_metadata(self, pipeline_id: pipeline_types.PipelineId, metadata: Mapping[str, str], timeout=None) -> \ Mapping[str, str]: """ Requests the addition of metadata to a pipeline. Args: pipeline_id (pipeline_types.PipelineId): Unique identifier of the pipeline whose metadata is to be appended. metadata(Mapping[str, str]): Set of key/value pairs to be appended to the pipeline metadata. If a metadata key in the request already exists in the pipeline record, or if duplicate keys are passed in the request, the pipeline will not be updated and and an error will be returned. Keys are compared using case insensitive comparator functions. The maximum allowed size of a metadata key is 128 bytes, while the maximum allowed size of a metadata value is 256 bytes. The maximum allowed size for the overall metadata of an individual job is 4 Megabytes. Returns: A Mapping[str, str] containing the appended metadata """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (pipeline_id.value is None) or (pipeline_id.value == ""): raise Exception("Pipeline identifier must have instantiated value") if metadata is None: raise Exception("Metadata must be an instantiated map") request = pipelines_pb2.PipelinesAddMetadataRequest( pipeline_id=pipeline_id.to_grpc_value() ) request.metadata.update(metadata) response = self._stub.AddMetadata(request, timeout) self.check_response_header(header=response.header) result = response.metadata return result def remove_metadata(self, pipeline_id: pipeline_types.PipelineId, keys: List[str], timeout=None) -> Mapping[ str, str]: """ Requests the removal of specified metadata of a pipeline. Args: pipeline_id: Unique identifier of the pipeline whose metadata is to be removed. keys: List of keys to be removed from the pipeline metadata. Returns: A Mapping[str, str] containing the updated set of metadata """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (pipeline_id.value is None) or (pipeline_id.value == ""): raise Exception("Pipeline identifier must have instantiated value") if keys is None: raise Exception("Keys paramater must be valid list of metadata keys") request = pipelines_pb2.PipelinesRemoveMetadataRequest( pipeline_id=pipeline_id.to_grpc_value() ) request.keys.extend(keys) response = self._stub.RemoveMetadata(request, timeout) self.check_response_header(header=response.header) result = response.metadata return result
clara-platform-python-client-main
nvidia_clara/pipelines_client.py
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from enum import Enum from nvidia_clara.grpc import common_pb2, jobs_pb2 import nvidia_clara.constants as constants class BaseClient: @staticmethod def check_response_header(header): if not isinstance(header, common_pb2.ResponseHeader): raise TypeError("Header arguement must be of type ResponseHeader") if header.code < 0: if header.messages is not None: if len(header.messages) > 0: message_string_list = [header.messages[i] for i in range(len(header.messages))] raise Exception('\n'.join(message_string_list)) else: raise Exception("Internal Server Error " + str(header.code)) else: raise Exception("Internal Server Error " + str(header.code)) @staticmethod def get_request_header() -> common_pb2.RequestHeader: header = common_pb2.RequestHeader(api_version=common_pb2.Version( major=constants.ClaraVersionMajor, minor=constants.ClaraVersionMinor, patch=constants.ClaraVersionPatch), user_agent="Nvidia.Clara.Platform") return header class RequestIterator(object): def __init__(self, requests): self._requests_iter = iter(requests) def __call__(self, handler=None): while True: try: request = next(self._requests_iter) except StopIteration: return yield request
clara-platform-python-client-main
nvidia_clara/base_client.py
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import grpc from typing import BinaryIO, Mapping, List from nvidia_clara.grpc import payloads_pb2, payloads_pb2_grpc from nvidia_clara.base_client import BaseClient import nvidia_clara.payload_types as payload_types class PayloadsClientStub: def create_payload(self, metadata: Mapping[str, str] = None) -> payload_types.PayloadDetails: """ Creates a static payload. Payloads created using this API are created with a type of "PayloadType.Reusable" Returns: the details of newly created payload. """ pass def delete_payload(self, payload_id: payload_types.PayloadId): """ Requests the deletion of a payload, identified by "payload_id" from Clara. Deleted payloads cannot be recovered. Args: payload_id (payload_types.PayloadId): Unique identifier of the payload to delete. """ pass def get_details(self, payload_id: payload_types.PayloadId) -> payload_types.PayloadDetails: """ Requests the details of a payload, identified by "payload_id" from Clara. Args: payload_id (payload_types.PayloadId): Unique identifier of the payload. Returns: A payload_types.PayloadDetails instance containing payload details """ pass def download_from(self, payload_id: payload_types.PayloadId, blob_name: str, dest_obj: BinaryIO) -> payload_types.PayloadFileDetails: """ Downloads a blob, identified by "blob_name", from a payload, identified by its "payload_id", from Clara. Data downloaded from the payload will be written to 'dest_obj' a passed in BinaryIO object with write privileges Args: payload_id (payload_types.PayloadId): Unique identifier of the payload. blob_name (str): The name, or path, of the blob in the payload. dest_obj (BinaryIO): Target stream object to write to """ pass def remove_from(self, payload_id: payload_types.PayloadId, blob_name: str): """ Removes a blob from the payload. Args: payload_id (payload_types.PayloadId): Unique identifier of the payload from which to remove the blob. blob_name (str): The name, or path, of the blob in the payload. """ pass def upload(self, payload_id: payload_types.PayloadId, blob_name: str, file_object: BinaryIO = None) -> payload_types.PayloadFileDetails: """ Uploads a blob from "file_object", to a Clara Payload identified by "payload_id". Each uploaded blob must be have a unique "blob_name" value within a given payload. Args: payload_id (payload_types.PayloadId): Unique identifier of the payload. blob_name (str): The name, or path, of the blob in the payload. file_object (BinaryIO): stream to read from and upload """ pass def add_metadata(self, payload_id: payload_types.PayloadId, metadata: Mapping[str, str]) -> Mapping[str, str]: """ Requests the addition of metadata to a payload. Args: payload_id (payload_types.PayloadId): Unique identifier of the payload. metadata(Mapping[str, str]): Set of key/value pairs to be appended to the payload metadata. If a metadata key in the request already exists in the job record, or if duplicate keys are passed in the request, the payload will not be updated and and an error will be returned. Keys are compared using case insensitive comparator functions. The maximum allowed size of a metadata key is 128 bytes, while the maximum allowed size of a metadata value is 256 bytes. The maximum allowed size for the overall metadata of an individual payload is 4 Megabytes. Returns: A Mapping[str, str] containing the appended metadata """ pass def remove_metadata(self, payload_id: payload_types.PayloadId, keys: List[str]) -> Mapping[str, str]: """ Requests the removal of metadata from a payload. Args: payload_id (payload_types.PayloadId): Unique identifier of the payload. keys: List of keys to be removed from the payload metadata. Returns: A Mapping[str, str] containing the updated set of metadata """ pass class PayloadsClient(BaseClient, PayloadsClientStub): def __init__(self, target: str, port: str = None, stub=None): """ Payloads Client Creation Args: target (str): ipv4 address of clara instance port (str): if specified, port will be appended to the target with a ":" """ if target is None: raise Exception("Target must be initialized to a non-null value") self._connection = target if port is not None: self._connection += ":" + port self._channel = grpc.insecure_channel(self._connection) if stub is None: self._stub = payloads_pb2_grpc.PayloadsStub(self._channel) else: self._stub = stub def close(self): """ Close connection """ if self._channel: self._channel.close() self._channel = None else: print("Connection for client already closed") def reconnect(self): """ Re-open connection with existing channel """ if self._channel is None: self._channel = grpc.insecure_channel(self._connection) self._stub = payloads_pb2_grpc.PayloadsStub(self._channel) else: print("Connection for client already open") def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): if self._channel is not None: self.close() return False def create_payload(self, metadata: Mapping[str, str] = None, timeout=None) -> payload_types.PayloadDetails: """ Creates a static payload. Payloads created using this API are created with a type of "PayloadType.Reusable" Returns: the details of newly created payload. """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") request = payloads_pb2.PayloadsCreateRequest(header=self.get_request_header()) if metadata is not None: request.metadata.update(metadata) response = self._stub.Create(request, timeout=timeout) self.check_response_header(header=response.header) payload_details = payload_types.PayloadDetails( file_details=[], payload_id=payload_types.PayloadId(response.payload_id.value), payload_type=response.type ) return payload_details def delete_payload(self, payload_id: payload_types.PayloadId, timeout=None): """ Requests the deletion of a payload, identified by "payload_id" from Clara. Deleted payloads cannot be recovered. Args: payload_id (payload_types.PayloadId): Unique identifier of the payload to delete. """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (payload_id.value is None) or (payload_id.value == ""): raise Exception("Payload identifier argument must be initialized with non-null instance") request = payloads_pb2.PayloadsDeleteRequest( header=self.get_request_header(), payload_id=payload_id.to_grpc_value() ) response = self._stub.Delete(request, timeout=timeout) self.check_response_header(header=response.header) def get_details(self, payload_id: payload_types.PayloadId, timeout=None) -> payload_types.PayloadDetails: """ Requests the details of a payload, identified by "payload_id" from Clara. Args: payload_id (payload_types.PayloadId): Unique identifier of the payload. Returns: A payload_types.PayloadDetails instance containing payload details """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (payload_id.value is None) or (payload_id.value == ""): raise Exception("Payload identifier argument must be initialized with non-null instance") request = payloads_pb2.PayloadsDetailsRequest( header=self.get_request_header(), payload_id=payload_id.to_grpc_value() ) response = self._stub.Details(request, timeout=timeout) responses = [resp for resp in response] if len(responses) > 0: self.check_response_header(header=responses[0].header) file_details = [] for item in responses: if item.file is None: continue detail = payload_types.PayloadFileDetails( mode=item.file.mode, name=item.file.name, size=item.file.size ) file_details.append(detail) result = payload_types.PayloadDetails( payload_id=payload_types.PayloadId(responses[0].payload_id.value), file_details=file_details, payload_type=responses[0].type, metadata=responses[0].metadata ) return result return None def download_from(self, payload_id: payload_types.PayloadId, blob_name: str, dest_obj: BinaryIO = None, dest_path: str = None, timeout=None) -> payload_types.PayloadFileDetails: """ Downloads a blob, identified by "blob_name", from a payload, identified by its "payload_id", from Clara. Data downloaded from the payload will be written to 'dest_obj' a passed in BinaryIO object with write privileges Args: payload_id (payload_types.PayloadId): Unique identifier of the payload. blob_name (str): The name, or path, of the blob in the payload. dest_obj (BinaryIO): Target stream object to write to with write privileges dest_path (str): Alternative to passing in BinaryIO object to download to, and rather passing in path for a file """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (payload_id.value is None) or (payload_id.value == ""): raise Exception("Payload identifier argument must be initialized with non-null instance") if (blob_name is None) or (blob_name == ""): raise Exception("Name of source blob must be initialized with non-null string") file_path_used = False if dest_obj is None: if dest_path is None: raise Exception("Destination object for upload must be initialized with non-null BinaryIO object") else: dest_obj = open(dest_path, 'wb') file_path_used = True request = payloads_pb2.PayloadsDownloadRequest( header=self.get_request_header(), name=blob_name, payload_id=payload_id.to_grpc_value() ) responses = self._stub.Download(request, timeout=timeout) result = None for resp in responses: if result is None: self.check_response_header(header=resp.header) result = payload_types.PayloadFileDetails( mode=resp.details.mode, name=resp.details.name, size=resp.details.size ) dest_obj.write(resp.data) if file_path_used: dest_obj.close() return result def remove_from(self, payload_id: payload_types.PayloadId, blob_name: str, timeout=None): """ Removes a blob from the payload. Args: payload_id (payload_types.PayloadId): Unique identifier of the payload from which to remove the blob. blob_name (str): The name, or path, of the blob in the payload. """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (payload_id.value is None) or (payload_id.value == ""): raise Exception("Payload identifier argument must be initialized with non-null instance") if (blob_name is None) or (blob_name == ""): raise Exception("Name of blob to remove must be initialized with non-null string") request = payloads_pb2.PayloadsRemoveRequest( header=self.get_request_header(), name=blob_name, payload_id=payload_id.to_grpc_value() ) response = self._stub.Remove(request, timeout=timeout) self.check_response_header(header=response.header) def upload_request_iterator(self, payload_id: payload_types.PayloadId, file_name: str, source_object: BinaryIO = None, mode: int = 0): """ Creates generator with data from input file (specified by file_name) Args: payload_id (payload_types.PayloadId): Unique identifier of the payload. file_name (str): File_name to read from source_object (BinaryIO): Stream to read from mode (int): Privilege level """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if source_object is None: raise Exception("Source object must be initialized with a non-null BinaryIO instance") chunk_size = 64 * 1024 while True: data = source_object.read(chunk_size) if not data: return details = payloads_pb2.PayloadFileDetails(mode=mode, name=file_name, size=len(data)) request = payloads_pb2.PayloadsUploadRequest( header=self.get_request_header(), payload_id=payload_id.to_grpc_value(), details=details, data=data ) yield request def upload(self, payload_id: payload_types.PayloadId, blob_name: str, file_object: BinaryIO = None, file_path: str = None, timeout=None) -> payload_types.PayloadFileDetails: """ Uploads a blob from "file_object", to a Clara Payload identified by "payload_id". Each uploaded blob must be have a unique "blob_name" value within a given payload. Args: payload_id (payload_types.PayloadId): Unique identifier of the payload. blob_name (str): The name, or path, of the blob in the payload. file_object (BinaryIO): stream to read from and upload with read privileges file_path (str): Alternative to passing in BinaryIO object for upload, and rather passing in path for a file """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (payload_id.value is None) or (payload_id.value == ""): raise Exception("Payload identifier argument must be initialized with non-null instance") if (blob_name is None) or (blob_name == ""): raise Exception("Name of destination blob must be initialized with non-null string") file_path_used = False if file_object is None: if file_path is None: raise Exception("File_object of file for upload must be initialized with non-null BinaryIO object") else: file_object = open(file_path, 'rb') file_path_used = True requests = self.upload_request_iterator( payload_id=payload_id, file_name=blob_name, source_object=file_object ) response = self._stub.Upload( requests, timeout=timeout ) self.check_response_header(header=response.header) result = payload_types.PayloadFileDetails(other=response.details) if file_path_used: file_object.close() return result def add_metadata(self, payload_id: payload_types.PayloadId, metadata: Mapping[str, str], timeout=None) -> Mapping[ str, str]: """ Requests the addition of metadata to a payload. Args: payload_id (payload_types.PayloadId): Unique identifier of the payload. metadata(Mapping[str, str]): Set of key/value pairs to be appended to the payload metadata. If a metadata key in the request already exists in the job record, or if duplicate keys are passed in the request, the payload will not be updated and and an error will be returned. Keys are compared using case insensitive comparator functions. The maximum allowed size of a metadata key is 128 bytes, while the maximum allowed size of a metadata value is 256 bytes. The maximum allowed size for the overall metadata of an individual payload is 4 Megabytes. Returns: A Mapping[str, str] containing the appended metadata """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (payload_id.value is None) or (payload_id.value == ""): raise Exception("Payload identifier must have instantiated value") if metadata is None: raise Exception("Metadata must be an instantiated map") request = payloads_pb2.PayloadsAddMetadataRequest( payload_id=payload_id.to_grpc_value() ) request.metadata.update(metadata) response = self._stub.AddMetadata(request, timeout) self.check_response_header(header=response.header) result = response.metadata return result def remove_metadata(self, payload_id: payload_types.PayloadId, keys: List[str], timeout=None) -> Mapping[str, str]: """ Requests the removal of metadata from a payload. Args: payload_id (payload_types.PayloadId): Unique identifier of the payload. keys: List of keys to be removed from the payload metadata. Returns: A Mapping[str, str] containing the updated set of metadata """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (payload_id.value is None) or (payload_id.value == ""): raise Exception("Payload identifier must have instantiated value") if keys is None: raise Exception("Keys paramater must be valid list of metadata keys") request = payloads_pb2.PayloadsRemoveMetadataRequest( payload_id=payload_id.to_grpc_value() ) request.keys.extend(keys) response = self._stub.RemoveMetadata(request, timeout) self.check_response_header(header=response.header) result = response.metadata return result
clara-platform-python-client-main
nvidia_clara/payloads_client.py
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. ClaraVersionMajor = 0 ClaraVersionMinor = 6 ClaraVersionPatch = 0 GrpcChunkSizeDefault = 1024 * 1024 GrpcChunkSizeMaximum = 4 * 1024 * 1024 - 512 GrpcChunkSizeMinimum = 1024 GrpcChunkSizeName = "GRPC_CHUNK_SIZE" GrpcParallelStreamsDefault = 8 GrpcParallelStreamsMaximum = 64 GrpcParallelStreamsMinimum = 1 GrpcParallelStreamsName = "GRPC_PARALLEL_STREAMS" GrpcChannelProviderUnavailable = "GRPC Channel provider is unavailable." GrpcClientProviderUnavailable = "GRPC client provider is unavailable."
clara-platform-python-client-main
nvidia_clara/constants.py
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import datetime from typing import List, Mapping, Iterator import grpc from nvidia_clara.grpc import common_pb2, clara_pb2, clara_pb2_grpc from nvidia_clara.base_client import BaseClient import nvidia_clara.clara_types as clara_types import nvidia_clara.job_types as job_types class ClaraClient(BaseClient): def __init__(self, target: str, port: str = None, stub=None): """ Clara Client Creation Args: target (str): ipv4 address of clara instance port (str): if specified, port will be appended to the target with a ":" """ if target is None: raise Exception("Target must be initialized to a non-null value") self._connection = target if port is not None: self._connection += ":" + port self._channel = grpc.insecure_channel(self._connection) if stub is None: self._stub = clara_pb2_grpc.ClaraStub(self._channel) else: self._stub = stub @staticmethod def get_timestamp(seconds_since_year_one: str) -> datetime.datetime: """ Create datetime.datetime object from a string date Args: seconds_since_year_one(str): date to parse Returns: datetime.datetime object """ if (seconds_since_year_one is None) or (seconds_since_year_one == ""): return None try: # Check to see if in form of seconds since year one seconds_int = float(seconds_since_year_one.value) - 62167219200 except: # Otherwise parse timestamp return datetime.datetime.strptime(seconds_since_year_one, "%Y-%m-%d %H:%M:%SZ") if seconds_int < 0: return None result_date = datetime.datetime.fromtimestamp(seconds_int) return result_date def stop(self, timeout=None): """Sends stop request to instance of Pipeline Services and Triton""" if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") request = clara_pb2.ClaraStopRequest(header=self.get_request_header()) response = self._stub.Stop(request, timeout=timeout) self.check_response_header(header=response.header) def list_utilization(self, timeout=None) -> List[clara_types.ClaraUtilizationDetails]: """ Method for aquiring snapshot of GPU utilization information of Clara in a list Returns: List[clara_types.ClaraGpuUtilization] with snapshot of GPU Utilization details for Clara GPUs """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") request = clara_pb2.ClaraUtilizationRequest(header=self.get_request_header(), watch=False) response = self._stub.Utilization(request, timeout=timeout) utilization_list = [] header_check = False for resp in response: if not header_check: self.check_response_header(header=resp.header) header_check = True metrics = resp.gpu_metrics clara_utilization_details = clara_types.ClaraUtilizationDetails() for item in metrics: gpu_utilization = clara_types.ClaraGpuUtilization( node_id=item.node_id, pcie_id=item.pcie_id, compute_utilization=item.compute_utilization, memory_free=item.memory_free, memory_used=item.memory_used, memory_utilization=item.memory_utilization, timestamp=self.get_timestamp(item.timestamp), ) for proc_info in item.process_details: process_details = clara_types.ClaraProcessDetails( name=proc_info.name, ) if proc_info.job_id.value: process_details.job_id = job_types.JobId(proc_info.job_id.value) gpu_utilization.process_details.append((process_details)) clara_utilization_details.gpu_metrics.append((gpu_utilization)) utilization_list.append(clara_utilization_details) return utilization_list def stream_utilization(self, timeout=None) -> Iterator[clara_types.ClaraUtilizationDetails]: """ Method for aquiring stream of GPU utilization information of Clara Returns: Iterator[clara_types.ClaraUtilizationDetails] with stream of GPU Utilization details for Clara GPUs """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") request = clara_pb2.ClaraUtilizationRequest(header=self.get_request_header(), watch=True) response = self._stub.Utilization(request, timeout=timeout) header_check = False for resp in response: if not header_check: self.check_response_header(header=resp.header) header_check = True metrics = resp.gpu_metrics clara_utilization_details = clara_types.ClaraUtilizationDetails() for item in metrics: gpu_utilization = clara_types.ClaraGpuUtilization( node_id=item.node_id, pcie_id=item.pcie_id, compute_utilization=item.compute_utilization, memory_free=item.memory_free, memory_used=item.memory_used, memory_utilization=item.memory_utilization, timestamp=self.get_timestamp(item.timestamp), ) for proc_info in item.process_details: process_details = clara_types.ClaraProcessDetails( name=proc_info.name, job_id=job_types.JobId(proc_info.job_id.value) ) gpu_utilization.process_details.append((process_details)) clara_utilization_details.gpu_metrics.append((gpu_utilization)) yield clara_utilization_details def version(self, timeout=None): """Get Clara Version""" request = clara_pb2.ClaraVersionRequest(header=self.get_request_header()) response = self._stub.Version(request, timeout=timeout) self.check_response_header(header=response.header) result = clara_types.ClaraVersionInfo( major=response.version.major, minor=response.version.minor, patch=response.version.patch, label=response.version.label ) return result
clara-platform-python-client-main
nvidia_clara/clara_client.py
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from nvidia_clara.jobs_client import JobsClient from nvidia_clara.pipelines_client import PipelinesClient from nvidia_clara.payloads_client import PayloadsClient from nvidia_clara.models_client import ModelsClient from nvidia_clara.base_client import BaseClient from nvidia_clara.clara_client import ClaraClient import nvidia_clara.pipeline_types as PipelineTypes import nvidia_clara.job_types as JobTypes import nvidia_clara.payload_types as PayloadTypes import nvidia_clara.model_types as ModelTypes import nvidia_clara.model_types as ClaraTypes
clara-platform-python-client-main
nvidia_clara/__init__.py
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from enum import Enum from typing import List, Mapping from nvidia_clara.grpc import common_pb2, payloads_pb2 class PayloadType(Enum): Unknown = payloads_pb2.PAYLOAD_TYPE_UNKNOWN Pipeline = payloads_pb2.PAYLOAD_TYPE_PIPELINE Reusable = payloads_pb2.PAYLOAD_TYPE_REUSABLE Minimum = Pipeline Maximum = Reusable class PayloadFileDetails: def __init__(self, other: payloads_pb2.PayloadFileDetails = None, mode: int = None, name: str = None, size: int = None): """ Args: mode(int): Permissions name(str): File Path Location size(int): Size of File other(payloads_pb2.PayloadFileDetails): If specified, object information replicated """ if other is None: self._mode = mode self._name = name self._size = size else: self._mode = other.mode self._name = other.name self._size = other.size @property def mode(self): """ Mode of the file. See [https://en.wikipedia.org/wiki/Chmod] for additional information. """ return self._mode @mode.setter def mode(self, mode: int): """ Mode of the file. See [https://en.wikipedia.org/wiki/Chmod] for additional information. """ self._mode = mode @property def name(self): """ Unique (withing a payload) name of the file; in path format. File names are relative to the root of the payload, and should not be rooted paths (prefixed with a '/' character). """ return self._name @name.setter def name(self, name: str): """ Unique (withing a payload) name of the file; in path format. File names are relative to the root of the payload, and should not be rooted paths (prefixed with a '/' character). """ self._name = name @property def size(self): """Size, in bytes, of the file.""" return self._size @size.setter def size(self, size: int): """Size, in bytes, of the file.""" self._size = size def __eq__(self, other): return (self._mode == other.getMode()) and (self._name == other.getName()) and ( self._size == other.getSize()) def __ne__(self, other): return not (self == other) def __hash__(self): return hash((self._mode, self._name, self._size)) class PayloadId: def __init__(self, value: str = None): if value == None: raise Exception("Arguement 'Value' must be initialized to non-null or empty string") self._value = value @property def value(self): return self._value def __eq__(self, other): return self._value == other._value def __ne__(self, other): return not (self == other) def __repr__(self): return "%s" % (self._value) def __str__(self): return "%s" % (self._value) def __hash__(self): return hash(self._value) def to_grpc_value(self): id = common_pb2.Identifier() id.value = self._value return id class PayloadDetails: def __init__(self, payload_id: PayloadId = None, file_details: List[PayloadFileDetails] = None, payload_type: payloads_pb2.PayloadType = None, metadata: Mapping[str, str] = None): if file_details is None: file_details = [] if metadata is None: metadata = dict() self._payload_id = payload_id self._file_details = file_details self._payload_type = payload_type self._metadata = metadata @property def payload_id(self): """Gets the unique identifier of the payload.""" return self._payload_id @payload_id.setter def payload_id(self, payload_id: PayloadId): """Sets the unique identifier of the payload.""" self._payload_id = payload_id @property def file_details(self): """Gets list of files contained in the payload.""" return self._file_details @file_details.setter def file_details(self, file_details: List[PayloadFileDetails]): """Sets a list of files contained in the payload.""" self._file_details = file_details @property def payload_type(self): """Gets a list of files contained in the payload.""" return self._payload_type @payload_type.setter def payload_type(self, payload_type: payloads_pb2.PayloadType): """Sets a list of files contained in the payload.""" self._payload_type = payload_type @property def metadata(self) -> Mapping[str, str]: """ Metadata (set of key/value pairs) associated with the payload """ return self._metadata @metadata.setter def metadata(self, metadata: Mapping[str, str]): """ Metadata (set of key/value pairs) associated with the payload """ self._metadata = metadata
clara-platform-python-client-main
nvidia_clara/payload_types.py
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from datetime import datetime from enum import Enum from typing import List, Mapping, TypeVar from nvidia_clara.grpc import common_pb2, jobs_pb2 import nvidia_clara.payload_types as payload_types import nvidia_clara.pipeline_types as pipeline_types T = TypeVar('T') class JobPriority(Enum): """ Priority of a pipeline job. A job's priority affects the order it will be scheduled once "JobsClient.StartJob()" is called. """ # The job priority is unknown. Unkown = 0 # Lower than normal priority. # Lower priority jobs are queued like "Normal" and "Higher" priority jobs, but are scheduled less frequently. Lower = jobs_pb2.JOB_PRIORITY_LOWER # Normal, or default, priority. # Normal priority jobs are queued like "Lower" and "Higher" priority jobs. # Normal priority jobs are scheduled more frequently than lower priority jobs and less frequently then higher priority jobs. Normal = jobs_pb2.JOB_PRIORITY_NORMAL # Higher than normal priority. # Higher priority jobs are queued like "Lower" and "Normal"priority jobs, but are scheduled more frequently. Higher = jobs_pb2.JOB_PRIORITY_HIGHER # Immediate priority jobs are queued in separate queue which must emptied before any other priority jobs can be scheduled. Immediate = jobs_pb2.JOB_PRIORITY_IMMEDIATE # The maximum supported value for "JobPriority" Maximum = jobs_pb2.JOB_PRIORITY_IMMEDIATE # The minimum supported value for "JobPriority" Minimum = jobs_pb2.JOB_PRIORITY_LOWER class JobState(Enum): """ State of a pipeline job. Related to "JobStatus" """ # The job is unknown or in an unknown state. Unknown = 0 # The job has been accepted and queued by the server, but has not yet started running. Pending = jobs_pb2.JOB_STATE_PENDING # The job is currently running. Running = jobs_pb2.JOB_STATE_RUNNING # The job has stopped runing. Stopped = jobs_pb2.JOB_STATE_STOPPED # Maximum supported value of "JobState" Maximum = Stopped # Minimum supported value of "JobState" Minimum = Pending class JobStatus(Enum): """ Status of pipeline job. Related to "JobState" """ # The job is unknown or the status of the job is unknown. Unknown = 0 # The job has been canceled. Canceled = jobs_pb2.JOB_STATUS_CANCELED # The job has encountered a terminal error. Faulted = jobs_pb2.JOB_STATUS_FAULTED # The job is healthy. # If stopped, the job has completed successfully. Healthy = jobs_pb2.JOB_STATUS_HEALTHY # The job was evicted Evicted = jobs_pb2.JOB_STATUS_EVICTED # The job was terminated Terminated = jobs_pb2.JOB_STATUS_TERMINATED # Maximum supported value of "JobStatus" Maximum = Canceled # Minimum supported value of "JobStatus" Minimum = Healthy class JobOperatorStatus(Enum): """ Status of an operator in a job. """ # The operator is unknownor the status of the operator is unknown. Unknown = jobs_pb2.JOB_OPERATOR_STATUS_UNKNOWN # The operator has been accepted and queued by the server, but has not yet started running. Pending = jobs_pb2.JOB_OPERATOR_STATUS_PENDING # The operator is currently running. Running = jobs_pb2.JOB_OPERATOR_STATUS_RUNNING # The operator has completed successfully. Completed = jobs_pb2.JOB_OPERATOR_STATUS_COMPLETED # The operator has encountered an error. Faulted = jobs_pb2.JOB_OPERATOR_STATUS_FAULTED class JobId: """ Unique identifier for a Clara Pipeline Job. """ def __init__(self, value: str): """ Creates Unique Identifier Object for a Clara Pipeline Job. """ if (value is None) or (value == ""): raise Exception("Job identifier value must be intialized.") self._value = value @property def value(self): return self._value def __eq__(self, other) -> bool: return self._value == other.value def __ne__(self, other) -> bool: return not (self == other) def __repr__(self): return "%s" % self._value def __str__(self): return "%s" % self._value def __hash__(self): return hash(self._value) def to_grpc_value(self): id = common_pb2.Identifier() id.value = self._value return id class JobToken: def __init__(self, job_id: JobId = None, job_state: JobState = None, job_status: JobStatus = None, job_priority: JobPriority = None): self._job_id = job_id self._job_state = job_state self._job_status = job_status self._job_priority = job_priority @property def job_id(self) -> JobId: """Unique identifier of the job.""" return self._job_id @job_id.setter def job_id(self, job_id: JobId): """Unique identifier of the job.""" self._job_id = job_id @property def job_state(self) -> JobState: """Current state of the job.""" return self._job_state @job_state.setter def job_state(self, job_state: JobState): """Current state of the job.""" self._job_state = job_state @property def job_status(self) -> JobStatus: """Current status of the job.""" return self._job_status @job_status.setter def job_status(self, job_status: JobStatus): """Current status of the job.""" self._job_status = job_status @property def job_priority(self) -> JobPriority: """Priority of the job""" return self._job_priority @job_priority.setter def job_priority(self, job_priority: JobPriority): """Priority of the job""" self._job_priority = job_priority class JobInfo(JobToken): def __init__(self, job_id: JobId = None, job_state: JobState = None, job_status: JobStatus = None, job_priority: JobPriority = None, date_created: datetime = None, date_started: datetime = None, date_stopped: datetime = None, name: str = None, payload_id: payload_types.PayloadId = None, pipeline_id: pipeline_types.PipelineId = None, metadata: Mapping[str, str] = None): super().__init__( job_id=job_id, job_state=job_state, job_status=job_status, job_priority=job_priority, ) if metadata is None: metadata = dict() self._date_created = date_created self._date_started = date_started self._date_stopped = date_stopped self._name = name self._payload_id = payload_id self._pipeline_id = pipeline_id self._metadata = metadata @property def date_created(self) -> datetime: return self._date_created @date_created.setter def date_created(self, date_created: datetime): self._date_created = date_created @property def date_started(self) -> datetime: return self._date_started @date_started.setter def date_started(self, date_started: datetime): self._date_started = date_started @property def date_stopped(self) -> datetime: return self._date_stopped @date_stopped.setter def date_stopped(self, date_stopped: datetime): self._date_stopped = date_stopped @property def name(self) -> str: return self._name @name.setter def name(self, name: str): self._name = name @property def payload_id(self) -> payload_types.PayloadId: return self._payload_id @payload_id.setter def payload_id(self, payload_id: payload_types.PayloadId): self._payload_id = payload_id @property def pipeline_id(self) -> pipeline_types.PipelineId: return self._pipeline_id @pipeline_id.setter def pipeline_id(self, pipeline_id: pipeline_types.PipelineId): self._pipeline_id = pipeline_id @property def metadata(self) -> Mapping[str, str]: """ Metadata (set of key/value pairs) associated with the job """ return self._metadata @metadata.setter def metadata(self, metadata: Mapping[str, str]): """ Metadata (set of key/value pairs) associated with the job """ self._metadata = metadata class JobFilter: def __init__(self, completed_before: datetime = None, created_after: datetime = None, has_job_state: List[JobState] = None, has_job_status: List[JobStatus] = None, pipeline_ids: List[pipeline_types.PipelineId] = None): if has_job_state is None: has_job_state = [] if has_job_status is None: has_job_status = [] if pipeline_ids is None: pipeline_ids = [] self._completed_before = completed_before self._created_after = created_after self._has_job_state = has_job_state self._has_job_status = has_job_status self._pipeline_ids = pipeline_ids @property def completed_before(self) -> datetime: """When applied, only jobs completed before the supplied date will be returned.""" return self._completed_before @completed_before.setter def completed_before(self, completed_before: datetime): """When applied, only jobs completed before the supplied date will be returned.""" self._completed_before = completed_before @property def created_after(self) -> datetime: """When applied, only jobs created after the supplied date will be returned.""" return self._created_after @created_after.setter def created_after(self, created_after: datetime): """When applied, only jobs created after the supplied date will be returned.""" self._created_after = created_after @property def has_job_state(self) -> List[JobState]: """When applied, only jobs having a provided state value will be returned.""" return self._has_job_state @has_job_state.setter def has_job_state(self, has_job_state: List[JobState]): """When applied, only jobs having a provided state value will be returned.""" self._has_job_state = has_job_state @property def has_job_status(self) -> List[JobStatus]: """When applied, only jobs having a provided status value will be returned.""" return self._has_job_status @has_job_status.setter def has_job_status(self, has_job_status: List[JobStatus]): """When applied, only jobs having a provided status value will be returned.""" self._has_job_status = has_job_status @property def pipeline_ids(self) -> List[pipeline_types.PipelineId]: """When applied, only jobs with matching pipeline identifiers will be returned.""" return self._pipeline_ids @pipeline_ids.setter def pipeline_ids(self, pipeline_ids: List[pipeline_types.PipelineId]): """When applied, only jobs with matching pipeline identifiers will be returned.""" self._pipeline_ids = pipeline_ids class JobDetails(JobInfo): def __init__(self, job_id: JobId = None, job_state: JobState = None, job_status: JobStatus = None, job_priority: JobPriority = None, date_created: datetime = None, date_started: datetime = None, date_stopped: datetime = None, name: str = None, payload_id: payload_types.PayloadId = None, pipeline_id: pipeline_types.PipelineId = None, operator_details: Mapping[str, Mapping[str, T]] = None, messages: List[str] = None, metadata: Mapping[str, str] = None): if metadata is None: metadata = dict() super().__init__( job_id=job_id, job_state=job_state, job_status=job_status, job_priority=job_priority, date_created=date_created, date_started=date_started, date_stopped=date_stopped, name=name, payload_id=payload_id, pipeline_id=pipeline_id, metadata=metadata ) if messages is None: messages = [] if operator_details is None: operator_details = dict() self._messages = messages self._operator_details = operator_details @property def messages(self) -> List[str]: """List of messages reported by the job.""" return self._messages @messages.setter def messages(self, messages: List[str]): """List of messages reported by the job.""" self._messages = messages @property def operator_details(self) -> Mapping[str, Mapping[str, T]]: """Dictionary mapping operator names to operator details""" return self._operator_details @operator_details.setter def operator_details(self, operator_details: Mapping[str, Mapping[str, T]]): """Dictionary mapping operator names to operator details""" self._operator_details = operator_details
clara-platform-python-client-main
nvidia_clara/job_types.py
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import datetime from typing import List, Mapping import grpc import itertools from nvidia_clara.grpc import common_pb2, jobs_pb2, jobs_pb2_grpc from nvidia_clara.base_client import BaseClient import nvidia_clara.job_types as job_types import nvidia_clara.pipeline_types as pipeline_types import nvidia_clara.payload_types as payload_types class JobsClientStub: def cancel_job(self, job_id: job_types.JobId, reason=None) -> job_types.JobToken: """ Cancels a pipeline job, preventing it from being executed. Has no affect on executing or terminated jobs. Args: job_id (job_types.JobId): Unique identity of the job to be cancelled. reason: Optional reason as to why the job was cancelled. Returns: job_types.JobToken of cancelled job """ pass def create_job(self, pipeline_id: pipeline_types.PipelineId, job_name: str, job_priority: job_types.JobPriority, input_payloads: List[payload_types.PayloadId] = None, metadata: Mapping[str, str] = None) -> job_types.JobInfo: """ Creates a new pipeline job record and associate storage payload. Jobs are created in a "JobState.Pending" state. Use "StartJob(JobId, Map{KeyValuePair{string, string}}" to cause the job to start executing. Args: pipeline_id (pipeline_types.PipelineId): Unique identifier of the pipeline which the job should be instances from. job_name (str): Human readable name of the job. job_priority (job_types.JobPriority): Optional Priority of the job. Affects how and when the server will schedule the job. input_payloads (List[payload_types.PayloadId]): [Optional Paramater] List of static payloads to include as input for the job. metadata (Mapping[str, str]): [Optional Parameter] Metadata (set of key/value pairs) associated with the job Returns: job_types.JobInfo about the newly created pipeline job. """ pass def get_status(self, job_id: job_types.JobId) -> job_types.JobDetails: """ Get status of a job Args: job_id (job_types.JobId): job_id Unique identifier of the job to get the status of. Returns: job_types.JobDetails including the status of a known job """ pass def list_jobs(self, job_filter: job_types.JobFilter = None) -> List[job_types.JobInfo]: """ Provides list of currently running jobs Args: job_filter (job_types.JobFilter): Optional filter used to limit the number of pipeline job records return Returns: list of job_types.JobInfo with known pipeline job details from the server. """ pass def start_job(self, job_id: job_types.JobId, named_values: Mapping[str, str] = None) -> job_types.JobToken: """ Starts a "JobState.Pending" job. Once started, a job's payload becomes readonly. Args: job_id (job_types.JobId): Unique identifier of the job to start. named_values: Collection of name/value pairs used to populate pipeline variables. Returns: A job_types.JobToken with information on started job """ pass def job_logs(self, job_id: job_types.JobId, operator_name: str) -> List[str]: """ Retrieve logs of operator specified with "operator_name" with job associated with "job_id" Args: job_id (job_types.JobId): Unique identifier of the job to retrieve logs from operator_name (str): Operator to retrieve logs from Returns: List of operator logs """ pass def add_metadata(self, job_id: job_types.JobId, metadata: Mapping[str, str]) -> Mapping[str, str]: """ Requests the addition of metadata to a job. Args: job_id (job_types.JobId): Unique identifier of the job whose metadata is to be appended. metadata(Mapping[str, str]): Set of key/value pairs to be appended to the job metadata. If a metadata key in the request already exists in the job record, or if duplicate keys are passed in the request, the job will not be updated and and an error will be returned. Keys are compared using case insensitive comparator functions. The maximum allowed size of a metadata key is 128 bytes, while the maximum allowed size of a metadata value is 256 bytes. The maximum allowed size for the overall metadata of an individual job is 4 Megabytes. Returns: A Mapping[str, str] containing the appended metadata """ pass def remove_metadata(self, job_id: job_types.JobId, keys: List[str]) -> Mapping[str, str]: """ Requests the removal of metadata from a job. Args: job_id: Unique identifier of the job whose metadata is to be removed. keys: List of keys to be removed from the job metadata. Returns: A Mapping[str, str] containing the updated set of metadata """ pass class JobsClient(BaseClient, JobsClientStub): def __init__(self, target: str, port: str = None, stub=None): """ Jobs Client Creation Args: target (str): ipv4 address of clara instance port (str): if specified, port will be appended to the target with a ":" """ if target is None: raise Exception("Target must be initialized to a non-null value") self._connection = target if port is not None: self._connection += ":" + port self._channel = grpc.insecure_channel(self._connection) if stub is None: self._stub = jobs_pb2_grpc.JobsStub(self._channel) else: self._stub = stub def close(self): """ Close connection """ if self._channel: self._channel.close() self._channel = None self._stub = None else: print("Connection for client already closed") def reconnect(self): """ Re-open connection with existing channel """ if self._channel is None: self._channel = grpc.insecure_channel(self._connection) self._stub = jobs_pb2_grpc.JobsStub(self._channel) else: print("Connection for client already open") def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): if self._channel is not None: self.close() return False @staticmethod def get_timestamp(seconds_since_year_one: str) -> datetime.datetime: """ Create datetime.datetime object from a string date Args: seconds_since_year_one(str): date to parse Returns: datetime.datetime object """ if (seconds_since_year_one is None) or (seconds_since_year_one == ""): return None try: # Check to see if in form of seconds since year one seconds_int = float(seconds_since_year_one.value) - 62135596800 except: # Otherwise parse timestamp return datetime.datetime.strptime(seconds_since_year_one, "%Y-%m-%d %H:%M:%SZ").astimezone(datetime.timezone.utc) if seconds_int < 0: return None result_date = datetime.datetime.fromtimestamp(seconds_int).astimezone(datetime.timezone.utc) return result_date def cancel_job(self, job_id: job_types.JobId, reason=None, timeout=None) -> job_types.JobToken: """ Cancels a pipeline job, preventing it from being executed. Has no affect on executing or terminated jobs. Args: job_id (job_types.JobId): Unique identity of the job to be cancelled. reason: Optional reason as to why the job was cancelled. Returns: job_types.JobToken of cancelled job """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (job_id.value is None) or (job_id.value == ""): raise Exception("Job identifier must have instantiated value") request = jobs_pb2.JobsCancelRequest(header=self.get_request_header(), job_id=job_id.to_grpc_value(), reason=reason) response = self._stub.Cancel(request, timeout=timeout) self.check_response_header(header=response.header) result = job_types.JobToken( job_id=job_types.JobId(response.job_id.value), job_state=response.job_state, job_status=response.job_status ) return result def create_job(self, pipeline_id: pipeline_types.PipelineId, job_name: str, input_payloads: List[payload_types.PayloadId] = None, job_priority: job_types.JobPriority = job_types.JobPriority.Normal, metadata: Mapping[str, str] = None, timeout=None) -> job_types.JobInfo: """ Creates a new pipeline job record and associate storage payload. Jobs are created in a "JobState.Pending" state. Use "StartJob(JobId, Map{KeyValuePair{string, string}}" to cause the job to start executing. Args: pipeline_id (pipeline_types.PipelineId): Unique identifier of the pipeline which the job should be instances from. job_name (str): Human readable name of the job. job_priority (job_types.JobPriority): Optional Priority of the job. Affects how and when the server will schedule the job. input_payloads (List[payload_types.PayloadId]): [Optional Paramater] List of static payloads to include as input for the job. metadata (Mapping[str, str]): [Optional Parameter] Metadata (set of key/value pairs) associated with the job Returns: job_types.JobInfo about the newly created pipeline job. """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if pipeline_id.value is None: raise Exception("Pipeline identifier must have instantiated non-null instance") if (job_name is None) or (job_name == ""): raise Exception("Job name must be initialized to non-null/non-empty string") if (job_priority.value < job_types.JobPriority.Minimum.value) or ( job_priority.value > job_types.JobPriority.Maximum.value): raise Exception("Job priority must contain valid value between minimum and maximum job priority bounds") input_payloads_identifiers = [] if input_payloads is not None: for pay_id in input_payloads: input_payloads_identifiers.append(pay_id.to_grpc_value()) else: input_payloads_identifiers = None request = jobs_pb2.JobsCreateRequest( header=self.get_request_header(), name=job_name, pipeline_id=pipeline_id.to_grpc_value(), priority=job_priority.value, input_payloads=input_payloads_identifiers ) if metadata is not None: request.metadata.update(metadata) response = self._stub.Create(request, timeout=timeout) self.check_response_header(header=response.header) result = job_types.JobInfo( job_id=job_types.JobId(response.job_id.value), job_priority=job_priority, job_state=job_types.JobState.Pending, job_status=job_types.JobStatus.Healthy, name=job_name, payload_id=payload_types.PayloadId(value=response.payload_id.value), pipeline_id=pipeline_id, metadata=metadata ) return result def get_status(self, job_id: job_types.JobId, timeout=None) -> job_types.JobDetails: """ Get status of a job Args: job_id (job_types.JobId): job_id Unique identifier of the job to get the status of. Returns: job_types.JobDetails including the status of a known job """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if job_id.value is None: raise Exception("Job identifier must have instantiated non-null instance") request = jobs_pb2.JobsStatusRequest(header=self.get_request_header(), job_id=job_id.to_grpc_value()) response = self._stub.Status(request, timeout=timeout) self.check_response_header(header=response.header) resp_operator_details = response.operator_details operator_details = {} for item in resp_operator_details: operator_details[item.name] = {} operator_details[item.name]["created"] = item.created operator_details[item.name]["started"] = item.started operator_details[item.name]["stopped"] = item.stopped operator_details[item.name]["status"] = item.status result = job_types.JobDetails( job_id=job_types.JobId(response.job_id.value), job_priority=response.priority, job_state=response.state, job_status=response.status, name=response.name, payload_id=payload_types.PayloadId(response.payload_id.value), pipeline_id=pipeline_types.PipelineId(response.pipeline_id.value), date_created=self.get_timestamp(response.created), date_started=self.get_timestamp(response.started), date_stopped=self.get_timestamp(response.stopped), operator_details=operator_details, messages=response.messages, metadata=response.metadata ) return result def list_jobs(self, job_filter: job_types.JobFilter = None, timeout=None) -> List[job_types.JobInfo]: """ Provides list of current jobs on platform Args: job_filter (job_types.JobFilter): Optional filter used to limit the number of pipeline job records return Returns: list of job_types.JobInfo with known pipeline job details from the server. """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") empty = job_types.JobFilter() request = jobs_pb2.JobsListRequest( header=self.get_request_header() ) if job_filter != empty and job_filter is not None: request_filter = jobs_pb2.JobsListRequest.JobFilter if job_filter.completed_before is not None: day_one = datetime.datetime(1, 1, 1) if job_filter.completed_before.tzinfo is not None \ and job_filter.completed_before.tzinfo.utcoffset(job_filter.completed_before) is not None: day_one = datetime.datetime(1, 1, 1, tzinfo=job_filter.completed_before.tzinfo) seconds = (job_filter.completed_before - day_one).total_seconds() request.filter.completed_before.value = int(seconds) if job_filter.created_after is not None: day_one = datetime.datetime(1, 1, 1) if job_filter.created_after.tzinfo is not None \ and job_filter.created_after.tzinfo.utcoffset(job_filter.created_after) is not None: day_one = datetime.datetime(1, 1, 1, tzinfo=job_filter.created_after.tzinfo) seconds = (job_filter.created_after - day_one).total_seconds() request.filter.created_after.value = int(seconds) if job_filter.has_job_state is not None: if len(job_filter.has_job_state) > 0: for state in job_filter.has_job_state: if (state.value < job_types.JobState.Minimum.value) or ( state.value > job_types.JobState.Maximum.value): raise Exception("Job states in filter must be within " + str( job_types.JobState.Minimum) + " and " + str( job_types.JobState.Maximum) + ", found:" + str(state)) request.filter.has_state.append(state.value) if job_filter.has_job_status is not None: if len(job_filter.has_job_status) > 0: for status in job_filter.has_job_status: if (status.value < job_types.JobStatus.Minimum.value) or ( status.value > job_types.JobStatus.Maximum.value): raise Exception("Job status in filter must be within " + str( job_types.JobStatus.Minimum) + " and " + str( job_types.JobStatus.Maximum) + ", found:" + str(status)) request.filter.has_status.append(status.value) if job_filter.pipeline_ids is not None: if len(job_filter.pipeline_ids) > 0: for pipe_id in job_filter.pipeline_ids: request.filter.pipeline_id.append(pipe_id.to_grpc_value()) response = self._stub.List(request, timeout=timeout) check_header = True result = [] for item in response: if check_header: self.check_response_header(header=item.header) check_header = False if (item.job_details is None) or (item.job_details.job_id.value == ''): continue info = job_types.JobInfo( job_id=job_types.JobId(item.job_details.job_id.value), job_priority=item.job_details.priority, job_state=item.job_details.state, job_status=item.job_details.status, name=item.job_details.job_name, payload_id=payload_types.PayloadId(item.job_details.payload_id.value), pipeline_id=pipeline_types.PipelineId(item.job_details.pipeline_id.value), date_created=self.get_timestamp(item.job_details.created), date_started=self.get_timestamp(item.job_details.started), date_stopped=self.get_timestamp(item.job_details.stopped), metadata=item.job_details.metadata ) result.append(info) return result def stream_jobs(self, job_filter: job_types.JobFilter = None, timeout=None): """ Provides generator to stream current jobs on platform Args: job_filter (job_types.JobFilter): Optional filter used to limit the number of pipeline job records return Returns: list of job_types.JobInfo with known pipeline job details from the server. """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") empty = job_types.JobFilter() request = jobs_pb2.JobsListRequest( header=self.get_request_header() ) if job_filter != empty and job_filter is not None: request_filter = jobs_pb2.JobsListRequest.JobFilter if job_filter.completed_before is not None: day_one = datetime.datetime(1, 1, 1) if job_filter.completed_before.tzinfo is not None \ and job_filter.completed_before.tzinfo.utcoffset(job_filter.completed_before) is not None: day_one = datetime.datetime(1, 1, 1, tzinfo=job_filter.completed_before.tzinfo) seconds = (job_filter.completed_before - day_one).total_seconds() request.filter.completed_before.value = int(seconds) if job_filter.created_after is not None: day_one = datetime.datetime(1, 1, 1) if job_filter.created_after.tzinfo is not None \ and job_filter.created_after.tzinfo.utcoffset(job_filter.created_after) is not None: day_one = datetime.datetime(1, 1, 1, tzinfo=job_filter.created_after.tzinfo) seconds = (job_filter.created_after - day_one).total_seconds() request.filter.created_after.value = int(seconds) if job_filter.has_job_state is not None: if len(job_filter.has_job_state) > 0: for state in job_filter.has_job_state: if (state.value < job_types.JobState.Minimum.value) or ( state.value > job_types.JobState.Maximum.value): raise Exception("Job states in filter must be within " + str( job_types.JobState.Minimum) + " and " + str( job_types.JobState.Maximum) + ", found:" + str(state)) request.filter.has_state.append(state.value) if job_filter.has_job_status is not None: if len(job_filter.has_job_status) > 0: for status in job_filter.has_job_status: if (status.value < job_types.JobStatus.Minimum.value) or ( status.value > job_types.JobStatus.Maximum.value): raise Exception("Job status in filter must be within " + str( job_types.JobStatus.Minimum) + " and " + str( job_types.JobStatus.Maximum) + ", found:" + str(status)) request.filter.has_status.append(status.value) if job_filter.pipeline_ids is not None: if len(job_filter.pipeline_ids) > 0: for pipe_id in job_filter.pipeline_ids: request.filter.pipeline_id.append(pipe_id.to_grpc_value()) response = self._stub.List(request, timeout=timeout) check_header = True for item in response: if check_header: self.check_response_header(header=item.header) check_header = False if (item.job_details is None) or (item.job_details.job_id.value == ''): continue info = job_types.JobInfo( job_id=job_types.JobId(item.job_details.job_id.value), job_priority=item.job_details.priority, job_state=item.job_details.state, job_status=item.job_details.status, name=item.job_details.job_name, payload_id=payload_types.PayloadId(item.job_details.payload_id.value), pipeline_id=pipeline_types.PipelineId(item.job_details.pipeline_id.value), date_created=self.get_timestamp(item.job_details.created), date_started=self.get_timestamp(item.job_details.started), date_stopped=self.get_timestamp(item.job_details.stopped), metadata=item.job_details.metadata ) yield info def start_job(self, job_id: job_types.JobId, named_values: Mapping[str, str] = None, timeout=None) -> job_types.JobToken: """ Starts a "JobState.Pending" job. Once started, a job's payload becomes readonly. Args: job_id (job_types.JobId): Unique identifier of the job to start. named_values: Collection of name/value pairs used to populate pipeline variables. Returns: A job_types.JobToken with information on started job """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (job_id.value is None) or (job_id.value == ""): raise Exception("Job identifier must have instantiated value") request = jobs_pb2.JobsStartRequest( header=self.get_request_header(), job_id=job_id.to_grpc_value() ) if named_values is not None: for item in named_values.keys(): nvp = jobs_pb2.JobsStartRequest.NamedValue( name=item, value=named_values.get(item) ) request.Variables.append(nvp) response = self._stub.Start(request, timeout=timeout) self.check_response_header(header=response.header) result = job_types.JobToken( job_id=job_id, job_priority=response.priority, job_state=response.state, job_status=response.status ) return result def job_logs(self, job_id: job_types.JobId, operator_name: str, timeout=None) -> List[str]: """ Retrieve logs of operator specified with "operator_name" with job associated with "job_id" Args: job_id (job_types.JobId): Unique identifier of the job to retrieve logs from operator_name (str): Operator to retrieve logs from Returns: List of operator logs """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (job_id.value is None) or (job_id.value == ""): raise Exception("Job identifier must have instantiated value") if operator_name is None: raise Exception("Operator must have valid instantiated value") if operator_name.strip() == "": raise Exception("Operator must have valid instantiated value") request = jobs_pb2.JobsReadLogsRequest( header=self.get_request_header(), job_id=job_id.to_grpc_value(), operator_name=operator_name ) response = self._stub.ReadLogs(request, timeout=timeout) responses = [resp.logs for resp in response] logs_list = [] for resp in responses: for log in resp: logs_list.append(log) return logs_list def add_metadata(self, job_id: job_types.JobId, metadata: Mapping[str, str], timeout=None) -> Mapping[str, str]: """ Requests the addition of metadata to a job. Args: job_id (job_types.JobId): Unique identifier of the job whose metadata is to be appended. metadata(Mapping[str, str]): Set of key/value pairs to be appended to the job metadata. If a metadata key in the request already exists in the job record, or if duplicate keys are passed in the request, the job will not be updated and and an error will be returned. Keys are compared using case insensitive comparator functions. The maximum allowed size of a metadata key is 128 bytes, while the maximum allowed size of a metadata value is 256 bytes. The maximum allowed size for the overall metadata of an individual job is 4 Megabytes. Returns: A Mapping[str, str] object containing the appended metadata """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (job_id.value is None) or (job_id.value == ""): raise Exception("Job identifier must have instantiated value") if metadata is None: raise Exception("Metadata must be an instantiated map") request = jobs_pb2.JobsAddMetadataRequest( job_id=job_id.to_grpc_value() ) request.metadata.update(metadata) response = self._stub.AddMetadata(request, timeout) self.check_response_header(header=response.header) result = response.metadata return result def remove_metadata(self, job_id: job_types.JobId, keys: List[str], timeout=None) -> Mapping[str, str]: """ Requests the removal of metadata from a job. Args: job_id: Unique identifier of the job whose metadata is to be removed. keys: List of keys to be removed from the job metadata. Returns: A Mapping[str, str] object containing the updated set of metadata """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (job_id.value is None) or (job_id.value == ""): raise Exception("Job identifier must have instantiated value") if keys is None: raise Exception("Keys paramater must be valid list of metadata keys") request = jobs_pb2.JobsRemoveMetadataRequest( job_id=job_id.to_grpc_value() ) request.keys.extend(keys) response = self._stub.RemoveMetadata(request, timeout) self.check_response_header(header=response.header) result = response.metadata return result
clara-platform-python-client-main
nvidia_clara/jobs_client.py
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from typing import BinaryIO, List, Mapping import grpc from nvidia_clara.grpc import models_pb2, models_pb2_grpc from nvidia_clara.base_client import BaseClient import nvidia_clara.model_types as model_types class ModelsClientStub: def create_catalog(self) -> model_types.CatalogId: """ Creates a new inference model catalog. Returns: model_types.CatalogId of the unique identity of the new catalog. """ pass def create_instance(self) -> model_types.InstanceId: """ Creates a new inference model catalog instance. Returns: model_types.InstanceId of the unique identity of the new instance. """ pass def delete_catalog(self, catalog_id: model_types.CatalogId): """ Deletes the inference catalog associated with "catalog_id" Deleted catalogs can no longer be used by Clara Platform Server to manage inference server model collections. Deleted catalogs cannot be recovered. Args: catalog_id (model_types.CatalogId): Unique identifier for the inference model catalog to be deleted """ pass def delete_instance(self, instance_id: model_types.InstanceId): """ Deletes the inference model catalog instance associated with "instance_id" Deleted instances can no longer be used by Clara Platform Server to manage inference server model collections. Deleted instances cannot be recovered. Args: instance_id (model_types.InstanceId): Unique identifier for the inference model catalog instance to be deleted. """ pass def delete_model(self, model_id: model_types.ModelId): """ Deletes the nference model associated with Deleted models cannot be used by pipeline jobs for inference. Deleted models cannot be recovered. Args: model_id (model_types.ModelId): Unique identifier of the inference model to be deleted. """ pass def download_model(self, model_id: model_types.ModelId, output_stream: BinaryIO) -> model_types.ModelDetails: """ Downloads the model associated with "model_id" to an "output_stream" BinaryIO object Args: model_id (model_types.ModelId): Unique identifier of the model to download. output_stream (BinaryIO): Writable stream use to write the raw model data to. Returns: model_types.ModelDetails with details of the downloaded model. """ pass def list_models(self) -> List[model_types.ModelDetails]: """ Returns details of all inference models known to the server. Only inference model details are provided; no model raw data is downloaded. Returns: List[model_types.ModelDetails] with each element containing details of all inference models known to the server """ pass def read_catalog(self, catalog_id: model_types.CatalogId) -> List[model_types.ModelDetails]: """ Returns details of all inference models included in the catalog associated with "catalog_id" Args: catalog_id (model_types.CatalogId): Unique identifier of the inference catalog to read. Returns: List[model_types.ModelDetails] ith each element containing details of all inference models associated with catalog """ pass def read_instance(self, instance_id: model_types.InstanceId) -> List[model_types.ModelDetails]: """ Returns details of all inference models included in the catalog instance associated with "instance_id" Args: instance_id (model_types.InstanceId): Unique identifier of the inference catalog instance to read. Returns: List[model_types.ModelDetails] ith each element containing details of all inference models associated with Instance """ pass def update_catalog(self, catalog_id: model_types.CatalogId, model_ids: List[model_types.ModelId]): """ Updates the inference model catalog associated with "catalog_id" and sets its set of included models in "model_ids" Any existing list of inference models associated with the catalog is replaced with the new list. Args: catalog_id (model_types.CatalogId): Unique identifier of the inference model catalog to update. model_ids: List of inference model identifiers to replace any existing list with. """ pass def update_instance(self, instance_id: model_types.InstanceId, model_ids: List[model_types.ModelId]): """ Updates the inference model catalog instance associated with "instance_id" and sets its set of included models to "model_ids" Any existing list of inference models associated with the instance is replaced with the new list. Args: instance_id (model_types.InstanceId): Unique identifier of the inference model catalog instance to update. model_ids: List of inference model identifiers to replace any existing list with. """ pass def upload_model(self, details: model_types.ModelDetails, input_stream: BinaryIO): """ Uploads an inference model to the model repository. If a model with the same name exists, it will be overwritten by this operation. Args: details (model_types.ModelDetails): provides details, including the name of the model. input_stream (BinaryIO): Raw model data is read from this stream and persisted into storage by the model repository. """ pass def add_metadata(self, model_id: model_types.ModelId, metadata: Mapping[str, str]) -> Mapping[str, str]: """ Requests the addition of metadata to a model. Args: model_id (model_types.ModelId): Unique identifier of the model to download. metadata(Mapping[str, str]): Set of key/value pairs to be appended to the job metadata. If a metadata key in the request already exists in the model record, or if duplicate keys are passed in the request, the model will not be updated and and an error will be returned. Keys are compared using case insensitive comparator functions. The maximum allowed size of a metadata key is 128 bytes, while the maximum allowed size of a metadata value is 256 bytes. The maximum allowed size for the overall metadata of an individual model is 4 Megabytes. Returns: A Mapping[str, str] containing the appended metadata """ pass def remove_metadata(self, model_id: model_types.ModelId, keys: List[str]) -> Mapping[str, str]: """ Requests the removal of metadata from a model. Args: model_id (model_types.ModelId): Unique identifier of the model to download. keys: List of keys to be removed from the model metadata. Returns: A Mapping[str, str] containing the updated set of metadata """ pass class ModelsClient(ModelsClientStub, BaseClient): def __init__(self, target: str, port: str = None, stub=None): """ Models Client Creation Args: target (str): ipv4 address of clara instance port (str): if specified, port will be appended to the target with a ":" """ if target is None: raise Exception("Target must be initialized to a non-null value") self._connection = target if port is not None: self._connection += ":" + port self._channel = grpc.insecure_channel(self._connection) if stub is None: self._stub = models_pb2_grpc.ModelsStub(self._channel) else: self._stub = stub def close(self): """Close connection""" if self._channel: self._channel.close() self._channel = None self._stub = None else: print("Connection for client already closed") def reconnect(self): """Re-open connection with existing channel""" if self._channel is None: self._channel = grpc.insecure_channel(self._connection) self._stub = models_pb2_grpc.ModelsStub(self._channel) else: print("Connection for client already open") def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): if self._channel is not None: self.close() return False def create_catalog(self, timeout=None) -> model_types.CatalogId: """ Creates a new inference model catalog. Returns: model_types.CatalogId of the unique identity of the new catalog. """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") request = models_pb2.ModelsCreateCatalogRequest( header=self.get_request_header() ) response = self._stub.CreateCatalog(request, timeout=timeout) self.check_response_header(header=response.header) result = model_types.CatalogId(value=response.catalog_id.value) return result def create_instance(self, timeout=None) -> model_types.InstanceId: """ Creates a new inference model catalog instance. Returns: model_types.InstanceId of the unique identity of the new instance. """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") request = models_pb2.ModelsCreateInstanceRequest( header=self.get_request_header() ) response = self._stub.CreateInstance(request, timeout=timeout) self.check_response_header(header=response.header) result = model_types.InstanceId(value=response.instance_id.value) return result def delete_catalog(self, catalog_id: model_types.CatalogId, timeout=None): """ Deletes the inference catalog associated with "catalog_id" Deleted catalogs can no longer be used by Clara Platform Server to manage inference server model collections. Deleted catalogs cannot be recovered. Args: catalog_id (model_types.CatalogId): Unique identifier for the inference model catalog to be deleted """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (catalog_id.value is None) or (catalog_id.value == ""): raise Exception("Catalog identifier must be initialized to non-null instance of model_types.CatalogId") request = models_pb2.ModelsDeleteCatalogRequest( catalog_id=catalog_id.to_grpc_value(), header=self.get_request_header() ) response = self._stub.DeleteCatalog(request, timeout=timeout) self.check_response_header(header=response.header) def delete_instance(self, instance_id: model_types.InstanceId, timeout=None): """ Deletes the inference model catalog instance associated with "instance_id" Deleted instances can no longer be used by Clara Platform Server to manage inference server model collections. Deleted instances cannot be recovered. Args: instance_id (model_types.InstanceId): Unique identifier for the inference model catalog instance to be deleted. """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if self._channel is None: raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (instance_id.value is None) or (instance_id.value == ""): raise Exception("Instance identifier must be initialized to non-null instance of model_types.InstanceId") request = models_pb2.ModelsDeleteInstanceRequest( catalog_id=instance_id.to_grpc_value(), header=self.get_request_header() ) response = self._stub.DeleteInstance(request, timeout=timeout) self.check_response_header(header=response.header) def delete_model(self, model_id: model_types.ModelId, timeout=None): """ Deletes the nference model associated with Deleted models cannot be used by pipeline jobs for inference. Deleted models cannot be recovered. Args: model_id (model_types.ModelId): Unique identifier of the inference model to be deleted. """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (model_id.value is None) or (model_id.value == ""): raise Exception("Model identifier must be initialized to non-null instance of model_types.ModelId") request = models_pb2.ModelsDeleteModelRequest( catalog_id=model_id.to_grpc_value(), header=self.get_request_header() ) response = self._stub.DeleteModel(request, timeout=timeout) self.check_response_header(header=response.header) def download_model(self, model_id: model_types.ModelId, output_stream: BinaryIO, timeout=None) -> model_types.ModelDetails: """ Downloads the model associated with "model_id" to an "output_stream" BinaryIO object Args: model_id (model_types.ModelId): Unique identifier of the model to download. output_stream (BinaryIO): Writable stream use to write the raw model data to. Returns: model_types.ModelDetails with details of the downloaded model. """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (model_id.value is None) or (model_id.value == ""): raise Exception("Model identifier must be initialized to non-null instance of model_types.ModelId") request = models_pb2.ModelsDownloadModelRequest( header=self.get_request_header(), model_id=model_id.to_grpc_value() ) responses = self._stub.Download(request, timeout=timeout) result = None for resp in responses: if result is None: self.check_response_header(header=resp.header) result = model_types.ModelDetails(other=resp.details) output_stream.write(resp.data) return result def list_models(self, timeout=None) -> List[model_types.ModelDetails]: """ Returns details of all inference models known to the server. Only inference model details are provided; no model raw data is downloaded. Returns: List[model_types.ModelDetails] with each element containing details of all inference models known to the server """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") request = models_pb2.ModelsListModelsRequest( header=self.get_request_header() ) response = self._stub.ListModels(request, timeout=timeout) responses = [resp for resp in response] if len(responses) > 0: self.check_response_header(header=responses[0].header) result = [] for resp in responses: details = model_types.ModelDetails(other=resp.models) result.append(details) return result return None def read_catalog(self, catalog_id: model_types.CatalogId, timeout=None) -> List[model_types.ModelDetails]: """ Returns details of all inference models included in the catalog associated with "catalog_id" Args: catalog_id (model_types.CatalogId): Unique identifier of the inference catalog to read. Returns: List[model_types.ModelDetails] ith each element containing details of all inference models associated with catalog """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") request = models_pb2.ModelsReadCatalogRequest( catalog_id=catalog_id.to_grpc_value(), header=self.get_request_header() ) response = self._stub.ReadCatalog(request, timeout=timeout) responses = [resp for resp in response] if len(responses) > 0: self.check_response_header(header=responses[0].header) result = [] for resp in responses: details = model_types.ModelDetails(other=resp.models) result.append(details) return result return None def read_instance(self, instance_id: model_types.InstanceId, timeout=None) -> List[model_types.ModelDetails]: """ Returns details of all inference models included in the catalog instance associated with "instance_id" Args: instance_id (model_types.InstanceId): Unique identifier of the inference catalog instance to read. Returns: List[model_types.ModelDetails] ith each element containing details of all inference models associated with Instance """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") request = models_pb2.ModelsReadCatalogRequest( instance_id=instance_id.to_grpc_value(), header=self.get_request_header() ) response = self._stub.ReadInstance(request, timeout=timeout) responses = [resp for resp in response] if len(responses) > 0: self.check_response_header(header=responses[0].header) result = [] for resp in responses: details = model_types.ModelDetails(other=resp.models) result.append(details) return result return None def update_catalog(self, catalog_id: model_types.CatalogId, model_ids: List[model_types.ModelId], timeout=None): """ Updates the inference model catalog associated with "catalog_id" and sets its set of included models in "model_ids" Any existing list of inference models associated with the catalog is replaced with the new list. Args: catalog_id (model_types.CatalogId): Unique identifier of the inference model catalog to update. model_ids: List of inference model identifiers to replace any existing list with. """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") model_ids_req = [model_id.to_grpc_value() for model_id in model_ids] request = models_pb2.ModelsUpdateCatalogRequest( catalog_id=catalog_id.to_grpc_value(), header=self.get_request_header(), model_ids=model_ids_req ) response = self._stub.UpdateCatalog([request], timeout=timeout) self.check_response_header(header=response.header) def update_instance(self, instance_id: model_types.InstanceId, model_ids: List[model_types.ModelId], timeout=None): """ Updates the inference model catalog instance associated with "instance_id" and sets its set of included models to "model_ids" Any existing list of inference models associated with the instance is replaced with the new list. Args: instance_id (model_types.InstanceId): Unique identifier of the inference model catalog instance to update. model_ids: List of inference model identifiers to replace any existing list with. """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") model_ids_req = [model_id.to_grpc_value() for model_id in model_ids] request = models_pb2.ModelsReadInstanceRequest( instance_id=instance_id.to_grpc_value(), header=self.get_request_header(), model_ids=model_ids_req ) response = self._stub.UpdateInstance([request], timeout=timeout) self.check_response_header(header=response.header) def upload_request_iterator(self, details: models_pb2.ModelDetails, source_object: BinaryIO = None): """ Helper method for uplaod model that creates generator of requests Args: details (models_pb2.ModelDetails): details of specified model source_object (BinaryIO): model source file to read data from """ if source_object is None: raise Exception("Source object must be initialized with a non-null BinaryIO instance") chunk_size = 64 * 1024 while True: data = source_object.read(chunk_size) if not data: return request = models_pb2.ModelsUploadModelRequest( header=self.get_request_header(), details=details, data=data ) yield request def upload_model(self, details: model_types.ModelDetails, input_stream: BinaryIO, timeout=None): """ Uploads an inference model to the model repository. If a model with the same name exists, it will be overwritten by this operation. Args: details (model_types.ModelDetails): provides details, including the name of the model. input_stream (BinaryIO): Raw model data is read from this stream and persisted into storage by the model repository. """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") details = models_pb2.ModelDetails(model_id=details.model_id.to_grpc_value(), name=details.name, tags=details.tags, model_type=details.model_type) response = self._stub.UploadModel( self.upload_request_iterator(details=details, source_object=input_stream), timeout=timeout ) self.check_response_header(header=response.header) def add_metadata(self, model_id: model_types.ModelId, metadata: Mapping[str, str], timeout=None) -> Mapping[ str, str]: """ Requests the addition of metadata to a model. Args: model_id (model_types.ModelId): Unique identifier of the model to download. metadata(Mapping[str, str]): Set of key/value pairs to be appended to the job metadata. If a metadata key in the request already exists in the model record, or if duplicate keys are passed in the request, the model will not be updated and and an error will be returned. Keys are compared using case insensitive comparator functions. The maximum allowed size of a metadata key is 128 bytes, while the maximum allowed size of a metadata value is 256 bytes. The maximum allowed size for the overall metadata of an individual model is 4 Megabytes. Returns: A Mapping[str, str] containing the appended metadata """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (model_id.value is None) or (model_id.value == ""): raise Exception("Model identifier must have instantiated value") if metadata is None: raise Exception("Metadata must be an instantiated map") request = models_pb2.ModelsAddMetadataRequest( model_id=model_id.to_grpc_value() ) request.metadata.update(metadata) response = self._stub.AddMetadata(request, timeout) self.check_response_header(header=response.header) result = response.metadata return result def remove_metadata(self, model_id: model_types.ModelId, keys: List[str], timeout=None) -> Mapping[str, str]: """ Requests the removal of metadata from a model. Args: model_id (model_types.ModelId): Unique identifier of the model to download. keys: List of keys to be removed from the model metadata. Returns: A Mapping[str, str] containing the updated set of metadata """ if (self._channel is None) or (self._stub is None): raise Exception("Connection is currently closed. Please run reconnect() to reopen connection") if (model_id.value is None) or (model_id.value == ""): raise Exception("Model identifier must have instantiated value") if keys is None: raise Exception("Keys paramater must be valid list of metadata keys") request = models_pb2.ModelsRemoveMetadataRequest( model_id=model_id.to_grpc_value() ) request.keys.extend(keys) response = self._stub.RemoveMetadata(request, timeout) self.check_response_header(header=response.header) result = response.metadata return result
clara-platform-python-client-main
nvidia_clara/models_client.py
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from datetime import datetime from typing import List from nvidia_clara.job_types import JobId class ClaraVersionInfo: def __init__(self, major: int = None, minor: int = None, patch: int = None, label: str = None): """Clara version information.""" self._major = major self._minor = minor self._patch = patch self._label = label @property def major(self) -> int: """Version Major""" return self._major @major.setter def major(self, major: int): """Version Major""" self._major = major @property def minor(self) -> int: """Version Minor""" return self._minor @minor.setter def minor(self, minor: int): """Version Minor""" self._minor = minor @property def patch(self) -> int: """Version Patch""" return self._patch @patch.setter def patch(self, patch: int): """Version Patch""" self._patch = patch @property def label(self) -> str: """Version Label""" return self._label @label.setter def label(self, label: str): """Version Label""" self._label = label class ClaraProcessDetails: def __init__(self, name: str = None, job_id: JobId = None): self._name = name self._job_id = job_id @property def name(self) -> str: """ Name of the process utilizing the GPU. - When job_id is provided, is the unique (to the pipeline-job) name of the pipeline-job operator utilizing the GPU. - When job_id is not provided, is the name of the Clara Platform managed, non-pipeline process utilizing the GPU. """ return self._name @name.setter def name(self, name: str): """ Name of the process utilizing the GPU. - When job_id is provided, is the unique (to the pipeline-job) name of the pipeline-job operator utilizing the GPU. - When job_id is not provided, is the name of the Clara Platform managed, non-pipeline process utilizing the GPU. """ self._name = name @property def job_id(self) -> JobId: """Unique identifier of the pipeline-job utilizing the GPU. Only provided when the process utilizing the GPU is a pipeline-job. """ return self._job_id @job_id.setter def job_id(self, job_id: JobId): """Unique identifier of the pipeline-job utilizing the GPU. Only provided when the process utilizing the GPU is a pipeline-job. """ self._job_id = job_id class ClaraGpuUtilization: def __init__(self, node_id: int = None, pcie_id: int = None, compute_utilization: float = None, memory_free: int = None, memory_used: int = None, memory_utilization: float = None, process_details: List[ClaraProcessDetails] = None, timestamp: datetime = None): """GPU Utilization details for a Clara process.""" if process_details is None: process_details = [] self._node_id = node_id self._pcie_id = pcie_id self._compute_utilization = compute_utilization self._memory_free = memory_free self._memory_used = memory_used self._memory_utilization = memory_utilization self._process_details = process_details self._timestamp = timestamp @property def node_id(self) -> int: """Unique (to the cluster) name of the node which contains the GPU.""" return self._node_id @node_id.setter def node_id(self, node_id: int): """Unique (to the cluster) name of the node which contains the GPU.""" self._node_id = node_id @property def pcie_id(self) -> int: """PCIE device identifier of the GPU.""" return self._pcie_id @pcie_id.setter def pcie_id(self, pcie_id: int): """PCIE device identifier of the GPU.""" self._pcie_id = pcie_id @property def compute_utilization(self) -> float: """GPU compute utilization; in the range of zero to one, inclusive [0, 1].""" return self._compute_utilization @compute_utilization.setter def compute_utilization(self, compute_utilization: float): """GPU compute utilization; in the range of zero to one, inclusive [0, 1].""" self._compute_utilization = compute_utilization @property def memory_free(self) -> int: """Free GPU memory, measured in megabytes.""" return self._memory_free @memory_free.setter def memory_free(self, memory_free: int): """Free GPU memory, measured in megabytes.""" self._memory_free = memory_free @property def memory_used(self) -> int: """Used GPU memory, measured in megabytes.""" return self._memory_used @memory_used.setter def memory_used(self, memory_used: int): """Used GPU memory, measured in megabytes.""" self._memory_used = memory_used @property def memory_utilization(self) -> float: """GPU memory utilization; in the range of zero to one, inclusive [0, 1].""" return self._memory_utilization @memory_utilization.setter def memory_utilization(self, memory_utilization: float): """GPU memory utilization; in the range of zero to one, inclusive [0, 1].""" self._memory_utilization = memory_utilization @property def process_details(self) -> List[ClaraProcessDetails]: """List of pipeline-job operators and/or Clara Platform managed process utilizing the GPU.""" return self._process_details @process_details.setter def process_details(self, process_details: List[ClaraProcessDetails]): """List of pipeline-job operators and/or Clara Platform managed process utilizing the GPU.""" self._process_details = process_details @property def timestamp(self) -> datetime: """Timestamp when the associated metrics data was collected.""" return self._timestamp @timestamp.setter def timestamp(self, timestamp: datetime): """Timestamp when the associated metrics data was collected.""" self._timestamp = timestamp class ClaraUtilizationDetails: """Utilization details for a Clara process.""" def __init__(self, gpu_metrics: List[ClaraGpuUtilization] = None): if gpu_metrics is None: gpu_metrics = [] self._gpu_metrics = gpu_metrics @property def gpu_metrics(self) -> List[ClaraGpuUtilization]: """List of Utilization Details of each GPU""" return self._gpu_metrics @gpu_metrics.setter def gpu_metrics(self, gpu_metrics: List[ClaraGpuUtilization]): """List of Utilization Details of each GPU""" self._gpu_metrics = gpu_metrics
clara-platform-python-client-main
nvidia_clara/clara_types.py
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from enum import Enum from typing import Mapping as HashMap, List, Mapping from nvidia_clara.grpc import models_pb2, common_pb2 class CatalogId: def __init__(self, value: str): """ Unique identifier for an Inference Model Catalog. """ if (value is None) or (value == ""): raise Exception("Catalog identifier value must be intialized.") self._value = value @property def value(self): return self._value def __eq__(self, other) -> bool: return self._value == other.value def __ne__(self, other) -> bool: return not (self == other) def __repr__(self): return "%s" % self._value def __str__(self): return "%s" % self._value def __hash__(self): return hash(self._value) def to_grpc_value(self): id = common_pb2.Identifier() id.value = self._value return id class ModelType(Enum): Unknown = 0 TensorFlow = 1 TensorRT = 2 PyTorch = 3 Minimum = TensorFlow Maximum = PyTorch class ModelId: def __init__(self, value: str): if (value is None) or (value == ""): raise Exception("Model identifier value must be intialized.") self._value = value @property def value(self): return self._value def __eq__(self, other) -> bool: return self._value == other.value def __ne__(self, other) -> bool: return not (self == other) def __repr__(self): return "%s" % self._value def __str__(self): return "%s" % self._value def __hash__(self): return hash(self._value) def to_grpc_value(self): id = common_pb2.Identifier() id.value = self._value return id class ModelDetails: def __init__(self, other: models_pb2.ModelDetails = None, model_id: ModelId = None, name: str = None, tags: Mapping[str, str] = None, model_type: ModelType = None, metadata: Mapping[str, str] = None): if other is None: if tags is None: tags = dict() if metadata is None: metadata = dict() self._model_id = model_id self._name = name self._tags = tags self._model_type = model_type self._metadata = metadata else: self._model_id = other.model_id self._name = other.name self._tags = other.tags self._model_type = other.type self._metadata = other.metadata @property def model_id(self) -> ModelId: """Unique identifier of this inference model.""" return self._model_id @model_id.setter def model_id(self, model_id: ModelId = None): """Unique identifier of this inference model.""" self._model_id = model_id @property def name(self) -> str: """The name of this inference model.""" return self._name @name.setter def name(self, name: str = None): """The name of this inference model.""" self._name = name @property def tags(self) -> Mapping[str, str]: """The set of tags / meta-data associated with this infrence model.""" return self._tags @tags.setter def tags(self, tags: Mapping[str, str] = None): """The set of tags / meta-data associated with this infrence model.""" self._tags = tags @property def model_type(self) -> ModelId: """The type (inference toolset) of this inference model.""" return self._model_type @model_type.setter def model_type(self, model_type: ModelType = None): """The type (inference toolset) of this inference model.""" self._model_type = model_type @property def metadata(self) -> Mapping[str, str]: """ Metadata (set of key/value pairs) associated with the model """ return self._metadata @metadata.setter def metadata(self, metadata: Mapping[str, str]): """ Metadata (set of key/value pairs) associated with the model """ self._metadata = metadata class CatalogDetails: def __init__(self, other: models_pb2.ModelCatalogDetails = None, catalog_id: CatalogId = None, models: List[ModelDetails] = None): if other is None: if catalog_id is None: raise Exception("Catalog identifier can not be None and must be initializes") self._catalog_id = catalog_id if models is None: self._models = [] else: self._models = models else: self._catalog_id = None if (other.catalog_id.value is not None) or (other.catalog_id.value != ""): self._catalog_id = CatalogId(value=other.catalog_id.value) self._models = [] if len(other.models) > 0: for model in other.models: new_model = ModelDetails(other=model) self._models.append(new_model) @property def catalog_id(self) -> CatalogId: """Unique identifier of this inference model catalog.""" return self._catalog_id @catalog_id.setter def catalog_id(self, catalog_id: CatalogId = None): """Unique identifier of this inference model catalog.""" self._catalog_id = catalog_id @property def models(self) -> List[ModelDetails]: """List of inference models associated with this inference model catalog.""" return self._models @models.setter def models(self, models: List[ModelDetails] = None): """List of inference models associated with this inference model catalog.""" self._models = models class InstanceId: def __init__(self, value: str): """Unique identifier for an Model Catalog Instance.""" if (value is None) or (value == ""): raise Exception("InstanceId identifier value must be intialized.") self._value = value @property def value(self): return self._value def __eq__(self, other) -> bool: return self._value == other.value def __ne__(self, other) -> bool: return not (self == other) def __repr__(self): return "%s" % self._value def __str__(self): return "%s" % self._value def __hash__(self): return hash(self._value) def to_grpc_value(self): id = common_pb2.Identifier() id.value = self._value return id class InstanceDetails: def __init__(self, other: models_pb2.ModelCatalogDetails = None, instance_id: InstanceId = None, models: List[ModelDetails] = None): if other is None: if instance_id is None: raise Exception("Instance identifier can not be None and must be initializes") self._instance_id = instance_id if models is None: self._models = [] else: self._models = models else: self._instance_id = None if (other.catalog_id.value is not None) or (other.catalog_id.value != ""): self._instance_id = InstanceId(value=other.catalog_id.value) self._models = [] if len(other.models) > 0: for model in other.models: new_model = ModelDetails(other=model) self._models.append(new_model) @property def instance_id(self) -> InstanceId: """Unqiue identifier of this inference model catalog instance.""" return self._instance_id @instance_id.setter def instance_id(self, instance_id: InstanceId = None): """Unqiue identifier of this inference model catalog instance.""" self._instance_id = instance_id @property def models(self) -> List[ModelDetails]: """List of inference models associated with this inference model catalog instance.""" return self._models @models.setter def models(self, models: List[ModelDetails] = None): """List of inference models associated with this inference model catalog instance.""" self._models = models
clara-platform-python-client-main
nvidia_clara/model_types.py
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # -*- coding: utf-8 -*- # Generated by the protocol buffer compiler. DO NOT EDIT! # source: nvidia/clara/platform/payloads.proto import sys _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) from google.protobuf.internal import enum_type_wrapper from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf import reflection as _reflection from google.protobuf import symbol_database as _symbol_database # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from nvidia_clara.grpc import common_pb2 as nvidia_dot_clara_dot_platform_dot_common__pb2 from nvidia_clara.grpc.common_pb2 import * DESCRIPTOR = _descriptor.FileDescriptor( name='nvidia/clara/platform/payloads.proto', package='nvidia.clara.platform', syntax='proto3', serialized_options=_b('\n\031com.nvidia.clara.platformZ\004apis\252\002\032Nvidia.Clara.Platform.Grpc'), serialized_pb=_b('\n$nvidia/clara/platform/payloads.proto\x12\x15nvidia.clara.platform\x1a\"nvidia/clara/platform/common.proto\">\n\x12PayloadFileDetails\x12\x0c\n\x04mode\x18\x01 \x01(\r\x12\x0c\n\x04size\x18\x02 \x01(\x04\x12\x0c\n\x04name\x18\x03 \x01(\t\"\x8d\x02\n\x1aPayloadsAddMetadataRequest\x12\x34\n\x06header\x18\x01 \x01(\x0b\x32$.nvidia.clara.platform.RequestHeader\x12\x35\n\npayload_id\x18\x02 \x01(\x0b\x32!.nvidia.clara.platform.Identifier\x12Q\n\x08metadata\x18\x03 \x03(\x0b\x32?.nvidia.clara.platform.PayloadsAddMetadataRequest.MetadataEntry\x1a/\n\rMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"\x90\x02\n\x1bPayloadsAddMetadataResponse\x12\x35\n\x06header\x18\x01 \x01(\x0b\x32%.nvidia.clara.platform.ResponseHeader\x12\x35\n\npayload_id\x18\x02 \x01(\x0b\x32!.nvidia.clara.platform.Identifier\x12R\n\x08metadata\x18\x03 \x03(\x0b\x32@.nvidia.clara.platform.PayloadsAddMetadataResponse.MetadataEntry\x1a/\n\rMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"\xcc\x01\n\x15PayloadsCreateRequest\x12\x34\n\x06header\x18\x01 \x01(\x0b\x32$.nvidia.clara.platform.RequestHeader\x12L\n\x08metadata\x18\x02 \x03(\x0b\x32:.nvidia.clara.platform.PayloadsCreateRequest.MetadataEntry\x1a/\n\rMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"\xb8\x01\n\x16PayloadsCreateResponse\x12\x35\n\x06header\x18\x01 \x01(\x0b\x32%.nvidia.clara.platform.ResponseHeader\x12\x35\n\npayload_id\x18\x02 \x01(\x0b\x32!.nvidia.clara.platform.Identifier\x12\x30\n\x04type\x18\x05 \x01(\x0e\x32\".nvidia.clara.platform.PayloadType\"\x84\x01\n\x15PayloadsDeleteRequest\x12\x34\n\x06header\x18\x01 \x01(\x0b\x32$.nvidia.clara.platform.RequestHeader\x12\x35\n\npayload_id\x18\x02 \x01(\x0b\x32!.nvidia.clara.platform.Identifier\"O\n\x16PayloadsDeleteResponse\x12\x35\n\x06header\x18\x01 \x01(\x0b\x32%.nvidia.clara.platform.ResponseHeader\"\x85\x01\n\x16PayloadsDetailsRequest\x12\x34\n\x06header\x18\x01 \x01(\x0b\x32$.nvidia.clara.platform.RequestHeader\x12\x35\n\npayload_id\x18\x02 \x01(\x0b\x32!.nvidia.clara.platform.Identifier\"\xa6\x03\n\x17PayloadsDetailsResponse\x12\x35\n\x06header\x18\x01 \x01(\x0b\x32%.nvidia.clara.platform.ResponseHeader\x12\x35\n\npayload_id\x18\x02 \x01(\x0b\x32!.nvidia.clara.platform.Identifier\x12\x37\n\x04\x66ile\x18\x03 \x01(\x0b\x32).nvidia.clara.platform.PayloadFileDetails\x12\x30\n\x04type\x18\x04 \x01(\x0e\x32\".nvidia.clara.platform.PayloadType\x12\x31\n\x06job_id\x18\x05 \x01(\x0b\x32!.nvidia.clara.platform.Identifier\x12N\n\x08metadata\x18\x06 \x03(\x0b\x32<.nvidia.clara.platform.PayloadsDetailsResponse.MetadataEntry\x1a/\n\rMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"\x94\x01\n\x17PayloadsDownloadRequest\x12\x34\n\x06header\x18\x01 \x01(\x0b\x32$.nvidia.clara.platform.RequestHeader\x12\x35\n\npayload_id\x18\x02 \x01(\x0b\x32!.nvidia.clara.platform.Identifier\x12\x0c\n\x04name\x18\x03 \x01(\t\"\x9b\x01\n\x18PayloadsDownloadResponse\x12\x35\n\x06header\x18\x01 \x01(\x0b\x32%.nvidia.clara.platform.ResponseHeader\x12:\n\x07\x64\x65tails\x18\x02 \x01(\x0b\x32).nvidia.clara.platform.PayloadFileDetails\x12\x0c\n\x04\x64\x61ta\x18\x03 \x01(\x0c\"\x92\x01\n\x15PayloadsRemoveRequest\x12\x34\n\x06header\x18\x01 \x01(\x0b\x32$.nvidia.clara.platform.RequestHeader\x12\x35\n\npayload_id\x18\x02 \x01(\x0b\x32!.nvidia.clara.platform.Identifier\x12\x0c\n\x04name\x18\x03 \x01(\t\"O\n\x16PayloadsRemoveResponse\x12\x35\n\x06header\x18\x01 \x01(\x0b\x32%.nvidia.clara.platform.ResponseHeader\"\x9a\x01\n\x1dPayloadsRemoveMetadataRequest\x12\x34\n\x06header\x18\x01 \x01(\x0b\x32$.nvidia.clara.platform.RequestHeader\x12\x35\n\npayload_id\x18\x02 \x01(\x0b\x32!.nvidia.clara.platform.Identifier\x12\x0c\n\x04keys\x18\x03 \x03(\t\"\x96\x02\n\x1ePayloadsRemoveMetadataResponse\x12\x35\n\x06header\x18\x01 \x01(\x0b\x32%.nvidia.clara.platform.ResponseHeader\x12\x35\n\npayload_id\x18\x02 \x01(\x0b\x32!.nvidia.clara.platform.Identifier\x12U\n\x08metadata\x18\x03 \x03(\x0b\x32\x43.nvidia.clara.platform.PayloadsRemoveMetadataResponse.MetadataEntry\x1a/\n\rMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"\xce\x01\n\x15PayloadsUploadRequest\x12\x34\n\x06header\x18\x01 \x01(\x0b\x32$.nvidia.clara.platform.RequestHeader\x12\x35\n\npayload_id\x18\x02 \x01(\x0b\x32!.nvidia.clara.platform.Identifier\x12:\n\x07\x64\x65tails\x18\x03 \x01(\x0b\x32).nvidia.clara.platform.PayloadFileDetails\x12\x0c\n\x04\x64\x61ta\x18\x04 \x01(\x0c\"\x8b\x01\n\x16PayloadsUploadResponse\x12\x35\n\x06header\x18\x01 \x01(\x0b\x32%.nvidia.clara.platform.ResponseHeader\x12:\n\x07\x64\x65tails\x18\x02 \x01(\x0b\x32).nvidia.clara.platform.PayloadFileDetails*]\n\x0bPayloadType\x12\x18\n\x14PAYLOAD_TYPE_UNKNOWN\x10\x00\x12\x19\n\x15PAYLOAD_TYPE_PIPELINE\x10\x01\x12\x19\n\x15PAYLOAD_TYPE_REUSABLE\x10\x02\x32\xf8\x06\n\x08Payloads\x12t\n\x0b\x41\x64\x64Metadata\x12\x31.nvidia.clara.platform.PayloadsAddMetadataRequest\x1a\x32.nvidia.clara.platform.PayloadsAddMetadataResponse\x12\x65\n\x06\x43reate\x12,.nvidia.clara.platform.PayloadsCreateRequest\x1a-.nvidia.clara.platform.PayloadsCreateResponse\x12\x65\n\x06\x44\x65lete\x12,.nvidia.clara.platform.PayloadsDeleteRequest\x1a-.nvidia.clara.platform.PayloadsDeleteResponse\x12j\n\x07\x44\x65tails\x12-.nvidia.clara.platform.PayloadsDetailsRequest\x1a..nvidia.clara.platform.PayloadsDetailsResponse0\x01\x12m\n\x08\x44ownload\x12..nvidia.clara.platform.PayloadsDownloadRequest\x1a/.nvidia.clara.platform.PayloadsDownloadResponse0\x01\x12\x65\n\x06Remove\x12,.nvidia.clara.platform.PayloadsRemoveRequest\x1a-.nvidia.clara.platform.PayloadsRemoveResponse\x12}\n\x0eRemoveMetadata\x12\x34.nvidia.clara.platform.PayloadsRemoveMetadataRequest\x1a\x35.nvidia.clara.platform.PayloadsRemoveMetadataResponse\x12g\n\x06Upload\x12,.nvidia.clara.platform.PayloadsUploadRequest\x1a-.nvidia.clara.platform.PayloadsUploadResponse(\x01\x42>\n\x19\x63om.nvidia.clara.platformZ\x04\x61pis\xaa\x02\x1aNvidia.Clara.Platform.GrpcP\x00\x62\x06proto3') , dependencies=[nvidia_dot_clara_dot_platform_dot_common__pb2.DESCRIPTOR,], public_dependencies=[nvidia_dot_clara_dot_platform_dot_common__pb2.DESCRIPTOR,]) _PAYLOADTYPE = _descriptor.EnumDescriptor( name='PayloadType', full_name='nvidia.clara.platform.PayloadType', filename=None, file=DESCRIPTOR, values=[ _descriptor.EnumValueDescriptor( name='PAYLOAD_TYPE_UNKNOWN', index=0, number=0, serialized_options=None, type=None), _descriptor.EnumValueDescriptor( name='PAYLOAD_TYPE_PIPELINE', index=1, number=1, serialized_options=None, type=None), _descriptor.EnumValueDescriptor( name='PAYLOAD_TYPE_REUSABLE', index=2, number=2, serialized_options=None, type=None), ], containing_type=None, serialized_options=None, serialized_start=3209, serialized_end=3302, ) _sym_db.RegisterEnumDescriptor(_PAYLOADTYPE) PayloadType = enum_type_wrapper.EnumTypeWrapper(_PAYLOADTYPE) PAYLOAD_TYPE_UNKNOWN = 0 PAYLOAD_TYPE_PIPELINE = 1 PAYLOAD_TYPE_REUSABLE = 2 _PAYLOADFILEDETAILS = _descriptor.Descriptor( name='PayloadFileDetails', full_name='nvidia.clara.platform.PayloadFileDetails', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='mode', full_name='nvidia.clara.platform.PayloadFileDetails.mode', index=0, number=1, type=13, cpp_type=3, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='size', full_name='nvidia.clara.platform.PayloadFileDetails.size', index=1, number=2, type=4, cpp_type=4, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='name', full_name='nvidia.clara.platform.PayloadFileDetails.name', index=2, number=3, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=99, serialized_end=161, ) _PAYLOADSADDMETADATAREQUEST_METADATAENTRY = _descriptor.Descriptor( name='MetadataEntry', full_name='nvidia.clara.platform.PayloadsAddMetadataRequest.MetadataEntry', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='key', full_name='nvidia.clara.platform.PayloadsAddMetadataRequest.MetadataEntry.key', index=0, number=1, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='value', full_name='nvidia.clara.platform.PayloadsAddMetadataRequest.MetadataEntry.value', index=1, number=2, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=_b('8\001'), is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=386, serialized_end=433, ) _PAYLOADSADDMETADATAREQUEST = _descriptor.Descriptor( name='PayloadsAddMetadataRequest', full_name='nvidia.clara.platform.PayloadsAddMetadataRequest', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='header', full_name='nvidia.clara.platform.PayloadsAddMetadataRequest.header', index=0, number=1, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='payload_id', full_name='nvidia.clara.platform.PayloadsAddMetadataRequest.payload_id', index=1, number=2, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='metadata', full_name='nvidia.clara.platform.PayloadsAddMetadataRequest.metadata', index=2, number=3, type=11, cpp_type=10, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[_PAYLOADSADDMETADATAREQUEST_METADATAENTRY, ], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=164, serialized_end=433, ) _PAYLOADSADDMETADATARESPONSE_METADATAENTRY = _descriptor.Descriptor( name='MetadataEntry', full_name='nvidia.clara.platform.PayloadsAddMetadataResponse.MetadataEntry', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='key', full_name='nvidia.clara.platform.PayloadsAddMetadataResponse.MetadataEntry.key', index=0, number=1, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='value', full_name='nvidia.clara.platform.PayloadsAddMetadataResponse.MetadataEntry.value', index=1, number=2, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=_b('8\001'), is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=386, serialized_end=433, ) _PAYLOADSADDMETADATARESPONSE = _descriptor.Descriptor( name='PayloadsAddMetadataResponse', full_name='nvidia.clara.platform.PayloadsAddMetadataResponse', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='header', full_name='nvidia.clara.platform.PayloadsAddMetadataResponse.header', index=0, number=1, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='payload_id', full_name='nvidia.clara.platform.PayloadsAddMetadataResponse.payload_id', index=1, number=2, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='metadata', full_name='nvidia.clara.platform.PayloadsAddMetadataResponse.metadata', index=2, number=3, type=11, cpp_type=10, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[_PAYLOADSADDMETADATARESPONSE_METADATAENTRY, ], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=436, serialized_end=708, ) _PAYLOADSCREATEREQUEST_METADATAENTRY = _descriptor.Descriptor( name='MetadataEntry', full_name='nvidia.clara.platform.PayloadsCreateRequest.MetadataEntry', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='key', full_name='nvidia.clara.platform.PayloadsCreateRequest.MetadataEntry.key', index=0, number=1, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='value', full_name='nvidia.clara.platform.PayloadsCreateRequest.MetadataEntry.value', index=1, number=2, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=_b('8\001'), is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=386, serialized_end=433, ) _PAYLOADSCREATEREQUEST = _descriptor.Descriptor( name='PayloadsCreateRequest', full_name='nvidia.clara.platform.PayloadsCreateRequest', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='header', full_name='nvidia.clara.platform.PayloadsCreateRequest.header', index=0, number=1, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='metadata', full_name='nvidia.clara.platform.PayloadsCreateRequest.metadata', index=1, number=2, type=11, cpp_type=10, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[_PAYLOADSCREATEREQUEST_METADATAENTRY, ], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=711, serialized_end=915, ) _PAYLOADSCREATERESPONSE = _descriptor.Descriptor( name='PayloadsCreateResponse', full_name='nvidia.clara.platform.PayloadsCreateResponse', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='header', full_name='nvidia.clara.platform.PayloadsCreateResponse.header', index=0, number=1, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='payload_id', full_name='nvidia.clara.platform.PayloadsCreateResponse.payload_id', index=1, number=2, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='type', full_name='nvidia.clara.platform.PayloadsCreateResponse.type', index=2, number=5, type=14, cpp_type=8, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=918, serialized_end=1102, ) _PAYLOADSDELETEREQUEST = _descriptor.Descriptor( name='PayloadsDeleteRequest', full_name='nvidia.clara.platform.PayloadsDeleteRequest', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='header', full_name='nvidia.clara.platform.PayloadsDeleteRequest.header', index=0, number=1, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='payload_id', full_name='nvidia.clara.platform.PayloadsDeleteRequest.payload_id', index=1, number=2, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=1105, serialized_end=1237, ) _PAYLOADSDELETERESPONSE = _descriptor.Descriptor( name='PayloadsDeleteResponse', full_name='nvidia.clara.platform.PayloadsDeleteResponse', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='header', full_name='nvidia.clara.platform.PayloadsDeleteResponse.header', index=0, number=1, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=1239, serialized_end=1318, ) _PAYLOADSDETAILSREQUEST = _descriptor.Descriptor( name='PayloadsDetailsRequest', full_name='nvidia.clara.platform.PayloadsDetailsRequest', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='header', full_name='nvidia.clara.platform.PayloadsDetailsRequest.header', index=0, number=1, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='payload_id', full_name='nvidia.clara.platform.PayloadsDetailsRequest.payload_id', index=1, number=2, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=1321, serialized_end=1454, ) _PAYLOADSDETAILSRESPONSE_METADATAENTRY = _descriptor.Descriptor( name='MetadataEntry', full_name='nvidia.clara.platform.PayloadsDetailsResponse.MetadataEntry', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='key', full_name='nvidia.clara.platform.PayloadsDetailsResponse.MetadataEntry.key', index=0, number=1, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='value', full_name='nvidia.clara.platform.PayloadsDetailsResponse.MetadataEntry.value', index=1, number=2, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=_b('8\001'), is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=386, serialized_end=433, ) _PAYLOADSDETAILSRESPONSE = _descriptor.Descriptor( name='PayloadsDetailsResponse', full_name='nvidia.clara.platform.PayloadsDetailsResponse', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='header', full_name='nvidia.clara.platform.PayloadsDetailsResponse.header', index=0, number=1, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='payload_id', full_name='nvidia.clara.platform.PayloadsDetailsResponse.payload_id', index=1, number=2, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='file', full_name='nvidia.clara.platform.PayloadsDetailsResponse.file', index=2, number=3, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='type', full_name='nvidia.clara.platform.PayloadsDetailsResponse.type', index=3, number=4, type=14, cpp_type=8, label=1, has_default_value=False, default_value=0, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='job_id', full_name='nvidia.clara.platform.PayloadsDetailsResponse.job_id', index=4, number=5, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='metadata', full_name='nvidia.clara.platform.PayloadsDetailsResponse.metadata', index=5, number=6, type=11, cpp_type=10, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[_PAYLOADSDETAILSRESPONSE_METADATAENTRY, ], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=1457, serialized_end=1879, ) _PAYLOADSDOWNLOADREQUEST = _descriptor.Descriptor( name='PayloadsDownloadRequest', full_name='nvidia.clara.platform.PayloadsDownloadRequest', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='header', full_name='nvidia.clara.platform.PayloadsDownloadRequest.header', index=0, number=1, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='payload_id', full_name='nvidia.clara.platform.PayloadsDownloadRequest.payload_id', index=1, number=2, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='name', full_name='nvidia.clara.platform.PayloadsDownloadRequest.name', index=2, number=3, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=1882, serialized_end=2030, ) _PAYLOADSDOWNLOADRESPONSE = _descriptor.Descriptor( name='PayloadsDownloadResponse', full_name='nvidia.clara.platform.PayloadsDownloadResponse', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='header', full_name='nvidia.clara.platform.PayloadsDownloadResponse.header', index=0, number=1, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='details', full_name='nvidia.clara.platform.PayloadsDownloadResponse.details', index=1, number=2, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='data', full_name='nvidia.clara.platform.PayloadsDownloadResponse.data', index=2, number=3, type=12, cpp_type=9, label=1, has_default_value=False, default_value=_b(""), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=2033, serialized_end=2188, ) _PAYLOADSREMOVEREQUEST = _descriptor.Descriptor( name='PayloadsRemoveRequest', full_name='nvidia.clara.platform.PayloadsRemoveRequest', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='header', full_name='nvidia.clara.platform.PayloadsRemoveRequest.header', index=0, number=1, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='payload_id', full_name='nvidia.clara.platform.PayloadsRemoveRequest.payload_id', index=1, number=2, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='name', full_name='nvidia.clara.platform.PayloadsRemoveRequest.name', index=2, number=3, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=2191, serialized_end=2337, ) _PAYLOADSREMOVERESPONSE = _descriptor.Descriptor( name='PayloadsRemoveResponse', full_name='nvidia.clara.platform.PayloadsRemoveResponse', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='header', full_name='nvidia.clara.platform.PayloadsRemoveResponse.header', index=0, number=1, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=2339, serialized_end=2418, ) _PAYLOADSREMOVEMETADATAREQUEST = _descriptor.Descriptor( name='PayloadsRemoveMetadataRequest', full_name='nvidia.clara.platform.PayloadsRemoveMetadataRequest', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='header', full_name='nvidia.clara.platform.PayloadsRemoveMetadataRequest.header', index=0, number=1, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='payload_id', full_name='nvidia.clara.platform.PayloadsRemoveMetadataRequest.payload_id', index=1, number=2, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='keys', full_name='nvidia.clara.platform.PayloadsRemoveMetadataRequest.keys', index=2, number=3, type=9, cpp_type=9, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=2421, serialized_end=2575, ) _PAYLOADSREMOVEMETADATARESPONSE_METADATAENTRY = _descriptor.Descriptor( name='MetadataEntry', full_name='nvidia.clara.platform.PayloadsRemoveMetadataResponse.MetadataEntry', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='key', full_name='nvidia.clara.platform.PayloadsRemoveMetadataResponse.MetadataEntry.key', index=0, number=1, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='value', full_name='nvidia.clara.platform.PayloadsRemoveMetadataResponse.MetadataEntry.value', index=1, number=2, type=9, cpp_type=9, label=1, has_default_value=False, default_value=_b("").decode('utf-8'), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=_b('8\001'), is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=386, serialized_end=433, ) _PAYLOADSREMOVEMETADATARESPONSE = _descriptor.Descriptor( name='PayloadsRemoveMetadataResponse', full_name='nvidia.clara.platform.PayloadsRemoveMetadataResponse', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='header', full_name='nvidia.clara.platform.PayloadsRemoveMetadataResponse.header', index=0, number=1, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='payload_id', full_name='nvidia.clara.platform.PayloadsRemoveMetadataResponse.payload_id', index=1, number=2, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='metadata', full_name='nvidia.clara.platform.PayloadsRemoveMetadataResponse.metadata', index=2, number=3, type=11, cpp_type=10, label=3, has_default_value=False, default_value=[], message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[_PAYLOADSREMOVEMETADATARESPONSE_METADATAENTRY, ], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=2578, serialized_end=2856, ) _PAYLOADSUPLOADREQUEST = _descriptor.Descriptor( name='PayloadsUploadRequest', full_name='nvidia.clara.platform.PayloadsUploadRequest', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='header', full_name='nvidia.clara.platform.PayloadsUploadRequest.header', index=0, number=1, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='payload_id', full_name='nvidia.clara.platform.PayloadsUploadRequest.payload_id', index=1, number=2, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='details', full_name='nvidia.clara.platform.PayloadsUploadRequest.details', index=2, number=3, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='data', full_name='nvidia.clara.platform.PayloadsUploadRequest.data', index=3, number=4, type=12, cpp_type=9, label=1, has_default_value=False, default_value=_b(""), message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=2859, serialized_end=3065, ) _PAYLOADSUPLOADRESPONSE = _descriptor.Descriptor( name='PayloadsUploadResponse', full_name='nvidia.clara.platform.PayloadsUploadResponse', filename=None, file=DESCRIPTOR, containing_type=None, fields=[ _descriptor.FieldDescriptor( name='header', full_name='nvidia.clara.platform.PayloadsUploadResponse.header', index=0, number=1, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), _descriptor.FieldDescriptor( name='details', full_name='nvidia.clara.platform.PayloadsUploadResponse.details', index=1, number=2, type=11, cpp_type=10, label=1, has_default_value=False, default_value=None, message_type=None, enum_type=None, containing_type=None, is_extension=False, extension_scope=None, serialized_options=None, file=DESCRIPTOR), ], extensions=[ ], nested_types=[], enum_types=[ ], serialized_options=None, is_extendable=False, syntax='proto3', extension_ranges=[], oneofs=[ ], serialized_start=3068, serialized_end=3207, ) _PAYLOADSADDMETADATAREQUEST_METADATAENTRY.containing_type = _PAYLOADSADDMETADATAREQUEST _PAYLOADSADDMETADATAREQUEST.fields_by_name['header'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._REQUESTHEADER _PAYLOADSADDMETADATAREQUEST.fields_by_name['payload_id'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._IDENTIFIER _PAYLOADSADDMETADATAREQUEST.fields_by_name['metadata'].message_type = _PAYLOADSADDMETADATAREQUEST_METADATAENTRY _PAYLOADSADDMETADATARESPONSE_METADATAENTRY.containing_type = _PAYLOADSADDMETADATARESPONSE _PAYLOADSADDMETADATARESPONSE.fields_by_name['header'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._RESPONSEHEADER _PAYLOADSADDMETADATARESPONSE.fields_by_name['payload_id'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._IDENTIFIER _PAYLOADSADDMETADATARESPONSE.fields_by_name['metadata'].message_type = _PAYLOADSADDMETADATARESPONSE_METADATAENTRY _PAYLOADSCREATEREQUEST_METADATAENTRY.containing_type = _PAYLOADSCREATEREQUEST _PAYLOADSCREATEREQUEST.fields_by_name['header'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._REQUESTHEADER _PAYLOADSCREATEREQUEST.fields_by_name['metadata'].message_type = _PAYLOADSCREATEREQUEST_METADATAENTRY _PAYLOADSCREATERESPONSE.fields_by_name['header'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._RESPONSEHEADER _PAYLOADSCREATERESPONSE.fields_by_name['payload_id'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._IDENTIFIER _PAYLOADSCREATERESPONSE.fields_by_name['type'].enum_type = _PAYLOADTYPE _PAYLOADSDELETEREQUEST.fields_by_name['header'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._REQUESTHEADER _PAYLOADSDELETEREQUEST.fields_by_name['payload_id'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._IDENTIFIER _PAYLOADSDELETERESPONSE.fields_by_name['header'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._RESPONSEHEADER _PAYLOADSDETAILSREQUEST.fields_by_name['header'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._REQUESTHEADER _PAYLOADSDETAILSREQUEST.fields_by_name['payload_id'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._IDENTIFIER _PAYLOADSDETAILSRESPONSE_METADATAENTRY.containing_type = _PAYLOADSDETAILSRESPONSE _PAYLOADSDETAILSRESPONSE.fields_by_name['header'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._RESPONSEHEADER _PAYLOADSDETAILSRESPONSE.fields_by_name['payload_id'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._IDENTIFIER _PAYLOADSDETAILSRESPONSE.fields_by_name['file'].message_type = _PAYLOADFILEDETAILS _PAYLOADSDETAILSRESPONSE.fields_by_name['type'].enum_type = _PAYLOADTYPE _PAYLOADSDETAILSRESPONSE.fields_by_name['job_id'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._IDENTIFIER _PAYLOADSDETAILSRESPONSE.fields_by_name['metadata'].message_type = _PAYLOADSDETAILSRESPONSE_METADATAENTRY _PAYLOADSDOWNLOADREQUEST.fields_by_name['header'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._REQUESTHEADER _PAYLOADSDOWNLOADREQUEST.fields_by_name['payload_id'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._IDENTIFIER _PAYLOADSDOWNLOADRESPONSE.fields_by_name['header'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._RESPONSEHEADER _PAYLOADSDOWNLOADRESPONSE.fields_by_name['details'].message_type = _PAYLOADFILEDETAILS _PAYLOADSREMOVEREQUEST.fields_by_name['header'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._REQUESTHEADER _PAYLOADSREMOVEREQUEST.fields_by_name['payload_id'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._IDENTIFIER _PAYLOADSREMOVERESPONSE.fields_by_name['header'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._RESPONSEHEADER _PAYLOADSREMOVEMETADATAREQUEST.fields_by_name['header'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._REQUESTHEADER _PAYLOADSREMOVEMETADATAREQUEST.fields_by_name['payload_id'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._IDENTIFIER _PAYLOADSREMOVEMETADATARESPONSE_METADATAENTRY.containing_type = _PAYLOADSREMOVEMETADATARESPONSE _PAYLOADSREMOVEMETADATARESPONSE.fields_by_name['header'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._RESPONSEHEADER _PAYLOADSREMOVEMETADATARESPONSE.fields_by_name['payload_id'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._IDENTIFIER _PAYLOADSREMOVEMETADATARESPONSE.fields_by_name['metadata'].message_type = _PAYLOADSREMOVEMETADATARESPONSE_METADATAENTRY _PAYLOADSUPLOADREQUEST.fields_by_name['header'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._REQUESTHEADER _PAYLOADSUPLOADREQUEST.fields_by_name['payload_id'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._IDENTIFIER _PAYLOADSUPLOADREQUEST.fields_by_name['details'].message_type = _PAYLOADFILEDETAILS _PAYLOADSUPLOADRESPONSE.fields_by_name['header'].message_type = nvidia_dot_clara_dot_platform_dot_common__pb2._RESPONSEHEADER _PAYLOADSUPLOADRESPONSE.fields_by_name['details'].message_type = _PAYLOADFILEDETAILS DESCRIPTOR.message_types_by_name['PayloadFileDetails'] = _PAYLOADFILEDETAILS DESCRIPTOR.message_types_by_name['PayloadsAddMetadataRequest'] = _PAYLOADSADDMETADATAREQUEST DESCRIPTOR.message_types_by_name['PayloadsAddMetadataResponse'] = _PAYLOADSADDMETADATARESPONSE DESCRIPTOR.message_types_by_name['PayloadsCreateRequest'] = _PAYLOADSCREATEREQUEST DESCRIPTOR.message_types_by_name['PayloadsCreateResponse'] = _PAYLOADSCREATERESPONSE DESCRIPTOR.message_types_by_name['PayloadsDeleteRequest'] = _PAYLOADSDELETEREQUEST DESCRIPTOR.message_types_by_name['PayloadsDeleteResponse'] = _PAYLOADSDELETERESPONSE DESCRIPTOR.message_types_by_name['PayloadsDetailsRequest'] = _PAYLOADSDETAILSREQUEST DESCRIPTOR.message_types_by_name['PayloadsDetailsResponse'] = _PAYLOADSDETAILSRESPONSE DESCRIPTOR.message_types_by_name['PayloadsDownloadRequest'] = _PAYLOADSDOWNLOADREQUEST DESCRIPTOR.message_types_by_name['PayloadsDownloadResponse'] = _PAYLOADSDOWNLOADRESPONSE DESCRIPTOR.message_types_by_name['PayloadsRemoveRequest'] = _PAYLOADSREMOVEREQUEST DESCRIPTOR.message_types_by_name['PayloadsRemoveResponse'] = _PAYLOADSREMOVERESPONSE DESCRIPTOR.message_types_by_name['PayloadsRemoveMetadataRequest'] = _PAYLOADSREMOVEMETADATAREQUEST DESCRIPTOR.message_types_by_name['PayloadsRemoveMetadataResponse'] = _PAYLOADSREMOVEMETADATARESPONSE DESCRIPTOR.message_types_by_name['PayloadsUploadRequest'] = _PAYLOADSUPLOADREQUEST DESCRIPTOR.message_types_by_name['PayloadsUploadResponse'] = _PAYLOADSUPLOADRESPONSE DESCRIPTOR.enum_types_by_name['PayloadType'] = _PAYLOADTYPE _sym_db.RegisterFileDescriptor(DESCRIPTOR) PayloadFileDetails = _reflection.GeneratedProtocolMessageType('PayloadFileDetails', (_message.Message,), dict( DESCRIPTOR = _PAYLOADFILEDETAILS, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadFileDetails) )) _sym_db.RegisterMessage(PayloadFileDetails) PayloadsAddMetadataRequest = _reflection.GeneratedProtocolMessageType('PayloadsAddMetadataRequest', (_message.Message,), dict( MetadataEntry = _reflection.GeneratedProtocolMessageType('MetadataEntry', (_message.Message,), dict( DESCRIPTOR = _PAYLOADSADDMETADATAREQUEST_METADATAENTRY, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsAddMetadataRequest.MetadataEntry) )) , DESCRIPTOR = _PAYLOADSADDMETADATAREQUEST, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsAddMetadataRequest) )) _sym_db.RegisterMessage(PayloadsAddMetadataRequest) _sym_db.RegisterMessage(PayloadsAddMetadataRequest.MetadataEntry) PayloadsAddMetadataResponse = _reflection.GeneratedProtocolMessageType('PayloadsAddMetadataResponse', (_message.Message,), dict( MetadataEntry = _reflection.GeneratedProtocolMessageType('MetadataEntry', (_message.Message,), dict( DESCRIPTOR = _PAYLOADSADDMETADATARESPONSE_METADATAENTRY, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsAddMetadataResponse.MetadataEntry) )) , DESCRIPTOR = _PAYLOADSADDMETADATARESPONSE, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsAddMetadataResponse) )) _sym_db.RegisterMessage(PayloadsAddMetadataResponse) _sym_db.RegisterMessage(PayloadsAddMetadataResponse.MetadataEntry) PayloadsCreateRequest = _reflection.GeneratedProtocolMessageType('PayloadsCreateRequest', (_message.Message,), dict( MetadataEntry = _reflection.GeneratedProtocolMessageType('MetadataEntry', (_message.Message,), dict( DESCRIPTOR = _PAYLOADSCREATEREQUEST_METADATAENTRY, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsCreateRequest.MetadataEntry) )) , DESCRIPTOR = _PAYLOADSCREATEREQUEST, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsCreateRequest) )) _sym_db.RegisterMessage(PayloadsCreateRequest) _sym_db.RegisterMessage(PayloadsCreateRequest.MetadataEntry) PayloadsCreateResponse = _reflection.GeneratedProtocolMessageType('PayloadsCreateResponse', (_message.Message,), dict( DESCRIPTOR = _PAYLOADSCREATERESPONSE, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsCreateResponse) )) _sym_db.RegisterMessage(PayloadsCreateResponse) PayloadsDeleteRequest = _reflection.GeneratedProtocolMessageType('PayloadsDeleteRequest', (_message.Message,), dict( DESCRIPTOR = _PAYLOADSDELETEREQUEST, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsDeleteRequest) )) _sym_db.RegisterMessage(PayloadsDeleteRequest) PayloadsDeleteResponse = _reflection.GeneratedProtocolMessageType('PayloadsDeleteResponse', (_message.Message,), dict( DESCRIPTOR = _PAYLOADSDELETERESPONSE, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsDeleteResponse) )) _sym_db.RegisterMessage(PayloadsDeleteResponse) PayloadsDetailsRequest = _reflection.GeneratedProtocolMessageType('PayloadsDetailsRequest', (_message.Message,), dict( DESCRIPTOR = _PAYLOADSDETAILSREQUEST, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsDetailsRequest) )) _sym_db.RegisterMessage(PayloadsDetailsRequest) PayloadsDetailsResponse = _reflection.GeneratedProtocolMessageType('PayloadsDetailsResponse', (_message.Message,), dict( MetadataEntry = _reflection.GeneratedProtocolMessageType('MetadataEntry', (_message.Message,), dict( DESCRIPTOR = _PAYLOADSDETAILSRESPONSE_METADATAENTRY, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsDetailsResponse.MetadataEntry) )) , DESCRIPTOR = _PAYLOADSDETAILSRESPONSE, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsDetailsResponse) )) _sym_db.RegisterMessage(PayloadsDetailsResponse) _sym_db.RegisterMessage(PayloadsDetailsResponse.MetadataEntry) PayloadsDownloadRequest = _reflection.GeneratedProtocolMessageType('PayloadsDownloadRequest', (_message.Message,), dict( DESCRIPTOR = _PAYLOADSDOWNLOADREQUEST, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsDownloadRequest) )) _sym_db.RegisterMessage(PayloadsDownloadRequest) PayloadsDownloadResponse = _reflection.GeneratedProtocolMessageType('PayloadsDownloadResponse', (_message.Message,), dict( DESCRIPTOR = _PAYLOADSDOWNLOADRESPONSE, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsDownloadResponse) )) _sym_db.RegisterMessage(PayloadsDownloadResponse) PayloadsRemoveRequest = _reflection.GeneratedProtocolMessageType('PayloadsRemoveRequest', (_message.Message,), dict( DESCRIPTOR = _PAYLOADSREMOVEREQUEST, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsRemoveRequest) )) _sym_db.RegisterMessage(PayloadsRemoveRequest) PayloadsRemoveResponse = _reflection.GeneratedProtocolMessageType('PayloadsRemoveResponse', (_message.Message,), dict( DESCRIPTOR = _PAYLOADSREMOVERESPONSE, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsRemoveResponse) )) _sym_db.RegisterMessage(PayloadsRemoveResponse) PayloadsRemoveMetadataRequest = _reflection.GeneratedProtocolMessageType('PayloadsRemoveMetadataRequest', (_message.Message,), dict( DESCRIPTOR = _PAYLOADSREMOVEMETADATAREQUEST, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsRemoveMetadataRequest) )) _sym_db.RegisterMessage(PayloadsRemoveMetadataRequest) PayloadsRemoveMetadataResponse = _reflection.GeneratedProtocolMessageType('PayloadsRemoveMetadataResponse', (_message.Message,), dict( MetadataEntry = _reflection.GeneratedProtocolMessageType('MetadataEntry', (_message.Message,), dict( DESCRIPTOR = _PAYLOADSREMOVEMETADATARESPONSE_METADATAENTRY, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsRemoveMetadataResponse.MetadataEntry) )) , DESCRIPTOR = _PAYLOADSREMOVEMETADATARESPONSE, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsRemoveMetadataResponse) )) _sym_db.RegisterMessage(PayloadsRemoveMetadataResponse) _sym_db.RegisterMessage(PayloadsRemoveMetadataResponse.MetadataEntry) PayloadsUploadRequest = _reflection.GeneratedProtocolMessageType('PayloadsUploadRequest', (_message.Message,), dict( DESCRIPTOR = _PAYLOADSUPLOADREQUEST, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsUploadRequest) )) _sym_db.RegisterMessage(PayloadsUploadRequest) PayloadsUploadResponse = _reflection.GeneratedProtocolMessageType('PayloadsUploadResponse', (_message.Message,), dict( DESCRIPTOR = _PAYLOADSUPLOADRESPONSE, __module__ = 'nvidia.clara.platform.payloads_pb2' # @@protoc_insertion_point(class_scope:nvidia.clara.platform.PayloadsUploadResponse) )) _sym_db.RegisterMessage(PayloadsUploadResponse) DESCRIPTOR._options = None _PAYLOADSADDMETADATAREQUEST_METADATAENTRY._options = None _PAYLOADSADDMETADATARESPONSE_METADATAENTRY._options = None _PAYLOADSCREATEREQUEST_METADATAENTRY._options = None _PAYLOADSDETAILSRESPONSE_METADATAENTRY._options = None _PAYLOADSREMOVEMETADATARESPONSE_METADATAENTRY._options = None _PAYLOADS = _descriptor.ServiceDescriptor( name='Payloads', full_name='nvidia.clara.platform.Payloads', file=DESCRIPTOR, index=0, serialized_options=None, serialized_start=3305, serialized_end=4193, methods=[ _descriptor.MethodDescriptor( name='AddMetadata', full_name='nvidia.clara.platform.Payloads.AddMetadata', index=0, containing_service=None, input_type=_PAYLOADSADDMETADATAREQUEST, output_type=_PAYLOADSADDMETADATARESPONSE, serialized_options=None, ), _descriptor.MethodDescriptor( name='Create', full_name='nvidia.clara.platform.Payloads.Create', index=1, containing_service=None, input_type=_PAYLOADSCREATEREQUEST, output_type=_PAYLOADSCREATERESPONSE, serialized_options=None, ), _descriptor.MethodDescriptor( name='Delete', full_name='nvidia.clara.platform.Payloads.Delete', index=2, containing_service=None, input_type=_PAYLOADSDELETEREQUEST, output_type=_PAYLOADSDELETERESPONSE, serialized_options=None, ), _descriptor.MethodDescriptor( name='Details', full_name='nvidia.clara.platform.Payloads.Details', index=3, containing_service=None, input_type=_PAYLOADSDETAILSREQUEST, output_type=_PAYLOADSDETAILSRESPONSE, serialized_options=None, ), _descriptor.MethodDescriptor( name='Download', full_name='nvidia.clara.platform.Payloads.Download', index=4, containing_service=None, input_type=_PAYLOADSDOWNLOADREQUEST, output_type=_PAYLOADSDOWNLOADRESPONSE, serialized_options=None, ), _descriptor.MethodDescriptor( name='Remove', full_name='nvidia.clara.platform.Payloads.Remove', index=5, containing_service=None, input_type=_PAYLOADSREMOVEREQUEST, output_type=_PAYLOADSREMOVERESPONSE, serialized_options=None, ), _descriptor.MethodDescriptor( name='RemoveMetadata', full_name='nvidia.clara.platform.Payloads.RemoveMetadata', index=6, containing_service=None, input_type=_PAYLOADSREMOVEMETADATAREQUEST, output_type=_PAYLOADSREMOVEMETADATARESPONSE, serialized_options=None, ), _descriptor.MethodDescriptor( name='Upload', full_name='nvidia.clara.platform.Payloads.Upload', index=7, containing_service=None, input_type=_PAYLOADSUPLOADREQUEST, output_type=_PAYLOADSUPLOADRESPONSE, serialized_options=None, ), ]) _sym_db.RegisterServiceDescriptor(_PAYLOADS) DESCRIPTOR.services_by_name['Payloads'] = _PAYLOADS # @@protoc_insertion_point(module_scope)
clara-platform-python-client-main
nvidia_clara/grpc/payloads_pb2.py
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # -*- coding: utf-8 -*- # Generated by the protocol buffer compiler. DO NOT EDIT! # source: nvidia/clara/platform/clara.proto # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! import grpc from nvidia_clara.grpc import metrics_pb2 as nvidia_dot_clara_dot_platform_dot_node__monitor_dot_metrics__pb2 class MonitorStub(object): # missing associated documentation comment in .proto file pass def __init__(self, channel): """Constructor. Args: channel: A grpc.Channel. """ self.GpuMetrics = channel.unary_stream( '/nvidia.clara.platform.node_monitor.Monitor/GpuMetrics', request_serializer=nvidia_dot_clara_dot_platform_dot_node__monitor_dot_metrics__pb2.MonitorGpuMetricsRequest.SerializeToString, response_deserializer=nvidia_dot_clara_dot_platform_dot_node__monitor_dot_metrics__pb2.MonitorGpuMetricsResponse.FromString, ) class MonitorServicer(object): # missing associated documentation comment in .proto file pass def GpuMetrics(self, request, context): """Request GPU metrics """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details('Method not implemented!') raise NotImplementedError('Method not implemented!') def add_MonitorServicer_to_server(servicer, server): rpc_method_handlers = { 'GpuMetrics': grpc.unary_stream_rpc_method_handler( servicer.GpuMetrics, request_deserializer=nvidia_dot_clara_dot_platform_dot_node__monitor_dot_metrics__pb2.MonitorGpuMetricsRequest.FromString, response_serializer=nvidia_dot_clara_dot_platform_dot_node__monitor_dot_metrics__pb2.MonitorGpuMetricsResponse.SerializeToString, ), } generic_handler = grpc.method_handlers_generic_handler( 'nvidia.clara.platform.node_monitor.Monitor', rpc_method_handlers) server.add_generic_rpc_handlers((generic_handler,))
clara-platform-python-client-main
nvidia_clara/grpc/metrics_pb2_grpc.py
# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # -*- coding: utf-8 -*- # Generated by the protocol buffer compiler. DO NOT EDIT! # source: nvidia/clara/platform/clara.proto # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! import grpc from nvidia_clara.grpc import models_pb2 as nvidia_dot_clara_dot_platform_dot_models__pb2 class ModelsStub(object): # missing associated documentation comment in .proto file pass def __init__(self, channel): """Constructor. Args: channel: A grpc.Channel. """ self.AddMetadata = channel.unary_unary( '/nvidia.clara.platform.Models/AddMetadata', request_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsAddMetadataRequest.SerializeToString, response_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsAddMetadataResponse.FromString, ) self.CreateCatalog = channel.unary_unary( '/nvidia.clara.platform.Models/CreateCatalog', request_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsCreateCatalogRequest.SerializeToString, response_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsCreateCatalogResponse.FromString, ) self.CreateInstance = channel.unary_unary( '/nvidia.clara.platform.Models/CreateInstance', request_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsCreateInstanceRequest.SerializeToString, response_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsCreateInstanceResponse.FromString, ) self.DeleteCatalog = channel.unary_unary( '/nvidia.clara.platform.Models/DeleteCatalog', request_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsDeleteCatalogRequest.SerializeToString, response_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsDeleteCatalogResponse.FromString, ) self.DeleteInstance = channel.unary_unary( '/nvidia.clara.platform.Models/DeleteInstance', request_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsDeleteInstanceRequest.SerializeToString, response_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsDeleteInstanceResponse.FromString, ) self.DeleteModel = channel.unary_unary( '/nvidia.clara.platform.Models/DeleteModel', request_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsDeleteModelRequest.SerializeToString, response_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsDeleteModelResponse.FromString, ) self.DownloadModel = channel.unary_stream( '/nvidia.clara.platform.Models/DownloadModel', request_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsDownloadModelRequest.SerializeToString, response_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsDownloadModelResponse.FromString, ) self.ListCatalogs = channel.unary_stream( '/nvidia.clara.platform.Models/ListCatalogs', request_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsListCatalogsRequest.SerializeToString, response_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsListCatalogsResponse.FromString, ) self.ListInstances = channel.unary_stream( '/nvidia.clara.platform.Models/ListInstances', request_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsListInstancesRequest.SerializeToString, response_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsListInstancesResponse.FromString, ) self.ListModels = channel.unary_stream( '/nvidia.clara.platform.Models/ListModels', request_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsListModelsRequest.SerializeToString, response_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsListModelsResponse.FromString, ) self.ReadCatalog = channel.unary_stream( '/nvidia.clara.platform.Models/ReadCatalog', request_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsReadCatalogRequest.SerializeToString, response_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsReadCatalogResponse.FromString, ) self.ReadInstance = channel.unary_stream( '/nvidia.clara.platform.Models/ReadInstance', request_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsReadInstanceRequest.SerializeToString, response_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsReadInstanceResponse.FromString, ) self.RemoveMetadata = channel.unary_unary( '/nvidia.clara.platform.Models/RemoveMetadata', request_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsRemoveMetadataRequest.SerializeToString, response_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsRemoveMetadataResponse.FromString, ) self.UpdateCatalog = channel.stream_unary( '/nvidia.clara.platform.Models/UpdateCatalog', request_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsUpdateCatalogRequest.SerializeToString, response_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsUpdateCatalogResponse.FromString, ) self.UpdateInstance = channel.stream_unary( '/nvidia.clara.platform.Models/UpdateInstance', request_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsUpdateInstanceRequest.SerializeToString, response_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsUpdateInstanceResponse.FromString, ) self.UploadModel = channel.stream_unary( '/nvidia.clara.platform.Models/UploadModel', request_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsUploadModelRequest.SerializeToString, response_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsUploadModelResponse.FromString, ) class ModelsServicer(object): # missing associated documentation comment in .proto file pass def AddMetadata(self, request, context): """Requests the addition of metadata to a model. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details('Method not implemented!') raise NotImplementedError('Method not implemented!') def CreateCatalog(self, request, context): """Requests the creation of a model catalog from the model repository. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details('Method not implemented!') raise NotImplementedError('Method not implemented!') def CreateInstance(self, request, context): """Requests the creation of a model catalog instance from the model repository. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details('Method not implemented!') raise NotImplementedError('Method not implemented!') def DeleteCatalog(self, request, context): """Requests the deletion of a model catalog from the model repository. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details('Method not implemented!') raise NotImplementedError('Method not implemented!') def DeleteInstance(self, request, context): """Requests the deletion of a model catalog instance from the model repository. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details('Method not implemented!') raise NotImplementedError('Method not implemented!') def DeleteModel(self, request, context): """Requests the deletion of a model from the model repository. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details('Method not implemented!') raise NotImplementedError('Method not implemented!') def DownloadModel(self, request, context): """Requests the download of an existing model from the model repository. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details('Method not implemented!') raise NotImplementedError('Method not implemented!') def ListCatalogs(self, request, context): """Requests the list of all existing catalogs from the model repository. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details('Method not implemented!') raise NotImplementedError('Method not implemented!') def ListInstances(self, request, context): """Requests a list of all existing model catalog instances from the model repository. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details('Method not implemented!') raise NotImplementedError('Method not implemented!') def ListModels(self, request, context): """Requests a list of available models from the model repository. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details('Method not implemented!') raise NotImplementedError('Method not implemented!') def ReadCatalog(self, request, context): """Requests the contents of a model catalog from the model repository. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details('Method not implemented!') raise NotImplementedError('Method not implemented!') def ReadInstance(self, request, context): """Requests the contents of a model catalog instance from the model repository. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details('Method not implemented!') raise NotImplementedError('Method not implemented!') def RemoveMetadata(self, request, context): """Requests the removal of metadata from a model. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details('Method not implemented!') raise NotImplementedError('Method not implemented!') def UpdateCatalog(self, request_iterator, context): """Requests the update of an existing model catalog in the model repository. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details('Method not implemented!') raise NotImplementedError('Method not implemented!') def UpdateInstance(self, request_iterator, context): """Requests the update of an existing model catalog instance with a new set of models. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details('Method not implemented!') raise NotImplementedError('Method not implemented!') def UploadModel(self, request_iterator, context): """Requests the uploads of a new model to model repository. """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details('Method not implemented!') raise NotImplementedError('Method not implemented!') def add_ModelsServicer_to_server(servicer, server): rpc_method_handlers = { 'AddMetadata': grpc.unary_unary_rpc_method_handler( servicer.AddMetadata, request_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsAddMetadataRequest.FromString, response_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsAddMetadataResponse.SerializeToString, ), 'CreateCatalog': grpc.unary_unary_rpc_method_handler( servicer.CreateCatalog, request_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsCreateCatalogRequest.FromString, response_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsCreateCatalogResponse.SerializeToString, ), 'CreateInstance': grpc.unary_unary_rpc_method_handler( servicer.CreateInstance, request_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsCreateInstanceRequest.FromString, response_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsCreateInstanceResponse.SerializeToString, ), 'DeleteCatalog': grpc.unary_unary_rpc_method_handler( servicer.DeleteCatalog, request_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsDeleteCatalogRequest.FromString, response_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsDeleteCatalogResponse.SerializeToString, ), 'DeleteInstance': grpc.unary_unary_rpc_method_handler( servicer.DeleteInstance, request_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsDeleteInstanceRequest.FromString, response_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsDeleteInstanceResponse.SerializeToString, ), 'DeleteModel': grpc.unary_unary_rpc_method_handler( servicer.DeleteModel, request_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsDeleteModelRequest.FromString, response_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsDeleteModelResponse.SerializeToString, ), 'DownloadModel': grpc.unary_stream_rpc_method_handler( servicer.DownloadModel, request_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsDownloadModelRequest.FromString, response_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsDownloadModelResponse.SerializeToString, ), 'ListCatalogs': grpc.unary_stream_rpc_method_handler( servicer.ListCatalogs, request_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsListCatalogsRequest.FromString, response_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsListCatalogsResponse.SerializeToString, ), 'ListInstances': grpc.unary_stream_rpc_method_handler( servicer.ListInstances, request_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsListInstancesRequest.FromString, response_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsListInstancesResponse.SerializeToString, ), 'ListModels': grpc.unary_stream_rpc_method_handler( servicer.ListModels, request_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsListModelsRequest.FromString, response_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsListModelsResponse.SerializeToString, ), 'ReadCatalog': grpc.unary_stream_rpc_method_handler( servicer.ReadCatalog, request_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsReadCatalogRequest.FromString, response_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsReadCatalogResponse.SerializeToString, ), 'ReadInstance': grpc.unary_stream_rpc_method_handler( servicer.ReadInstance, request_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsReadInstanceRequest.FromString, response_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsReadInstanceResponse.SerializeToString, ), 'RemoveMetadata': grpc.unary_unary_rpc_method_handler( servicer.RemoveMetadata, request_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsRemoveMetadataRequest.FromString, response_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsRemoveMetadataResponse.SerializeToString, ), 'UpdateCatalog': grpc.stream_unary_rpc_method_handler( servicer.UpdateCatalog, request_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsUpdateCatalogRequest.FromString, response_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsUpdateCatalogResponse.SerializeToString, ), 'UpdateInstance': grpc.stream_unary_rpc_method_handler( servicer.UpdateInstance, request_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsUpdateInstanceRequest.FromString, response_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsUpdateInstanceResponse.SerializeToString, ), 'UploadModel': grpc.stream_unary_rpc_method_handler( servicer.UploadModel, request_deserializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsUploadModelRequest.FromString, response_serializer=nvidia_dot_clara_dot_platform_dot_models__pb2.ModelsUploadModelResponse.SerializeToString, ), } generic_handler = grpc.method_handlers_generic_handler( 'nvidia.clara.platform.Models', rpc_method_handlers) server.add_generic_rpc_handlers((generic_handler,))
clara-platform-python-client-main
nvidia_clara/grpc/models_pb2_grpc.py