class Model(ModelBase): def __init__(self): # load config file config = json.load(open("model/config.json")) # get the image processor self._imageProcessor = ImageProcessor(config) # load the DL models # load net 1 model1 = Unet3d(in_dim=5, out_dim=2, num_filter=16) net1 = model1.cpu() net1.load_state_dict( torch.load('model/net_step1.pth', map_location='cpu')) self._model1 = net1 # load net 2 model2 = Unet3d_nopad(in_dim=5, out_dim=4, num_filter=32) net2 = model2.cpu() net2.load_state_dict( torch.load('model/net_step2.pth', map_location='cpu')) self._model2 = net2 def infer(self, input): # load preprocessed input inputAsNpArr1 = self._imageProcessor.loadAndPreprocess( input["t1"]["fileurl"], id="t1") inputAsNpArr2 = self._imageProcessor.loadAndPreprocess( input["t1c"]["fileurl"], id="t1c") inputAsNpArr3 = self._imageProcessor.loadAndPreprocess( input["t2"]["fileurl"], id="t2") inputAsNpArr4 = self._imageProcessor.loadAndPreprocess( input["flair"]["fileurl"], id="flair") # postprocessing print('loading done') affine = self._imageProcessor.returnAffine(input["t1"]["fileurl"]) print('affine recovered') dataset = preprocessForNet1(inputAsNpArr1, inputAsNpArr2, inputAsNpArr3, inputAsNpArr4, affine) print('dataset assembled') print('first U-Net running') outNet1 = predict1(dataset, self._model1) print('preprocessing step 2') dataset = preprocessForNet2(dataset, outNet1[0]) print('second U-Net running') outNet2 = predict2(dataset, self._model2) #outNet2 = predict2(outNet1, self._model2) print('done, postprocessing now') output = self._imageProcessor.computeOutput(outNet2[0]) return output def _preprocessInputForNet(t1, t1c, t2, flair): pass
class Model(ModelBase): def __init__(self): # load config file config = json.load(open("model/config.json", encoding="utf-8")) # get the image processor self._imageProcessor = ImageProcessor(config) # load the DL model nclasses = 2 self._model = Net(output_dim=nclasses) learning_rate = 0.001 momentum = 0.9 weight_decay = 0.0001 optimizer = optim.SGD(self._model.parameters(), lr=learning_rate, momentum=momentum, weight_decay=weight_decay) checkpoint = torch.load('model/model.pth.tar', map_location=lambda storage, loc: storage) optimizer.load_state_dict(checkpoint['optimizer']) self._model.load_state_dict(checkpoint['state_dict']) self._model.eval() def infer(self, input): # load preprocessed input inputAsNpArr = self._imageProcessor.loadAndPreprocess(input) # Run inference results = self._model.forward(inputAsNpArr) # postprocess results into output output = self._imageProcessor.computeOutput(results) return output
class Model(ModelBase): def __init__(self): # load config file config = json.load(open("model/config.json")) # get the image processor self._imageProcessor = ImageProcessor(config) # load the DL model (change this if you are not using ONNX) #self._model = onnx.load('model/model.onnx') #self._model = sfm def infer(self, input): inputAsNpArr = self._imageProcessor.loadAndPreprocess(input) # load preprocessed input graph = tf.Graph() with graph.as_default(): with tf.Session(graph=graph) as sess: tf.saved_model.loader.load( sess, [tag_constants.SERVING], 'model/', ) input_uint8 = graph.get_tensor_by_name('raw_input:0') prediction = graph.get_tensor_by_name('pose_prediction/pose_exp_net/pose/mul:0') pred = sess.run(prediction, feed_dict={input_uint8: inputAsNpArr[None,:,:,:]}) output = self._imageProcessor.computeOutput(pred) return output
class Model(ModelBase): def __init__(self): # load config file config = json.load(open("model/config.json")) # get the image processor self._imageProcessor = ImageProcessor(config) # # load the DL model # load archiecture json_file = open("model/architecture.json", 'r') loaded_model_json = json_file.read() json_file.close() self._model = model_from_json(loaded_model_json) # load weights self._model.load_weights("model/weights.h5") self._graph = tf.get_default_graph() def infer(self, input): # load preprocessed input inputAsNpArr = self._imageProcessor.loadAndPreprocess(input) inputAsNpArrFormatted = inputAsNpArr.reshape(1, 50, 50, 50, 1) with self._graph.as_default(): function = K.function( [self._model.layers[0].input, K.learning_phase()], [self._model.layers[23].output]) # Run inference with keras probabilities = self._model.predict_on_batch( [inputAsNpArrFormatted]) vector = function([inputAsNpArrFormatted, 0]) # postprocess results into output output = self._imageProcessor.computeOutput([probabilities, vector[0]]) return output
class Model(ModelBase): def __init__(self): # load config file config = json.load(open("model/config.json")) # get the image processor self._imageProcessor = ImageProcessor(config) # load the DL model self._model = caffe.Net('model/model.prototxt', 'model/model.caffemodel', caffe.TEST) # load input and configure preprocessing self._transformer = caffe.io.Transformer( {'data': self._model.blobs['data'].data.shape}) self._transformer.set_mean( 'data', np.load('model/ilsvrc_2012_mean.npy').mean(1).mean(1)) self._transformer.set_transpose('data', (2, 0, 1)) self._transformer.set_channel_swap('data', (2, 1, 0)) self._transformer.set_raw_scale('data', 255.0) def infer(self, input): # load preprocessed input inputAsNpArr = self._imageProcessor.loadAndPreprocess(input) # Run inference with caffe self._model.blobs['data'].reshape(1, 3, 227, 227) self._model.blobs['data'].data[...] = self._transformer.preprocess( 'data', inputAsNpArr) results = self._model.forward()['prob'] # postprocess results into output output = self._imageProcessor.computeOutput(results) return output
class Model(ModelBase): def __init__(self): # load config file config = json.load(open("model/config.json")) # get the image processor self._imageProcessor = ImageProcessor(config) # get context - cpu ctx = mx.cpu() sym, arg_params, aux_params = mx.model.load_checkpoint('model/nin', 0) mod = mx.mod.Module(symbol=sym, context=ctx, label_names=None) mod.bind(for_training=False, data_shapes=[('data', (1, 3, 224, 224))], label_shapes=mod._label_shapes) mod.set_params(arg_params, aux_params, allow_missing=True) self._model = mod def infer(self, input): # load preprocessed input inputAsNpArr = self._imageProcessor.loadAndPreprocess(input) # Run inference with mxnet batch = namedtuple('Batch', ['data']) self._model.forward(batch([inputAsNpArr]), is_train=False) prob = self._model.get_outputs()[0][0].asnumpy() # postprocess results into output output = self._imageProcessor.computeOutput(prob) return output
class Model(ModelBase): def __init__(self): # load config file config = json.load(open("model/config.json")) # get the image processor self._imageProcessor = ImageProcessor(config) # get context - cpu ctx = mx.cpu() sym, arg_params, aux_params = import_model('model/model.onnx') # Load module mod = mx.mod.Module(symbol=sym, context=ctx, label_names=None) mod.bind(for_training=False, data_shapes=[('data', (1, 3, 224, 224))], label_shapes=mod._label_shapes) mod.set_params(arg_params, aux_params, allow_missing=True, allow_extra=True) self._model = mod def infer(self, input): # load preprocessed input inputAsNpArr = self._imageProcessor.loadAndPreprocess(input) # Run inference with mxnet batch = namedtuple('Batch', ['data']) self._model.forward(batch([inputAsNpArr])) # Take softmax to generate probabilities scores = mx.ndarray.softmax(self._model.get_outputs()[0][0]).asnumpy() # postprocess results into output output = self._imageProcessor.computeOutput(scores) return output
class Model(ModelBase): def __init__(self): # load config file config = json.load(open("model/config.json")) # get the image processor self._imageProcessor = ImageProcessor(config) # get context - cpu ctx = mx.cpu() image_size = (112,112) # Import ONNX model sym, arg_params, aux_params = import_model('model/model.onnx') # Define and binds parameters to the network model = mx.mod.Module(symbol=sym, context=ctx, label_names = None) model.bind(data_shapes=[('data', (1, 3, image_size[0], image_size[1]))]) model.set_params(arg_params, aux_params) self._model = model def infer(self, input): # load preprocessed input inputAsNpArr = self._imageProcessor.loadAndPreprocess(input) # Run inference with mxnet input_blob = np.expand_dims(inputAsNpArr, axis=0) data = mx.nd.array(input_blob) db = mx.io.DataBatch(data=(data,)) self._model.forward(db, is_train=False) embedding = self._model.get_outputs()[0].asnumpy() # postprocess results into output output = self._imageProcessor.computeOutput(embedding) return output.tolist()
class Model(ModelBase): def __init__(self): # load config file config = json.load(open("model/config.json")) # get the image processor self._imageProcessor = ImageProcessor(config) # load the DL model (change this if you are not using ONNX) target_label_names = [ 'necrosis', 'contrast_enhancing', 'core', 'tumor', 'brain' ] net1 = UNET_3D_to_2D(0, channels_in=4, channels=128, growth_rate=12, dilated_layers=[6, 6, 6, 6], output_channels=len(target_label_names)) net2 = UNET_3D_to_2D(1, channels_in=4, channels=128, growth_rate=12, dilated_layers=[6, 6, 6], output_channels=len(target_label_names)) net1 = net1.cuda() net2 = net2.cuda() load_checkpoint(net1, 'model/checkpoint.pth.tar') load_checkpoint(net2, 'model/checkpoint_2.pth.tar') self._model1 = net1 self._model2 = net2 def infer(self, input): # load preprocessed input # CAUTION: these custum functions return the complete nib.Nifti1Image! t1 = self._imageProcessor.loadAndPreprocess(input["t1"]["fileurl"], id="t1") t1c = self._imageProcessor.loadAndPreprocess(input["t1c"]["fileurl"], id="t1c") t2 = self._imageProcessor.loadAndPreprocess(input["t2"]["fileurl"], id="t2") flair = self._imageProcessor.loadAndPreprocess( input["flair"]["fileurl"], id="flair") output = segment(flair, t1, t2, t1c, self._model1, self._model2) # compute output output = self._imageProcessor.computeOutput(output) return output
class Model(ModelBase): def __init__(self): # load config file config = json.load(open("model/config.json")) # get the image processor self._imageProcessor = ImageProcessor(config) # load the DL model within keras (change thi if you are not using keras) self._model = load_model('model/model.h5') def infer(self, input): # load preprocessed input inputAsNpArr = self._imageProcessor.loadAndPreprocess(input) # Run inference with kreas (change this if you are not using keras) results = self._model.predict( inputAsNpArr) # postprocess results into output output = self._imageProcessor.computeOutput(results) return output
class Model(ModelBase): def __init__(self): # load config file config = json.load(open("model/config.json")) # get the image processor self._imageProcessor = ImageProcessor(config) # load the DL model (change this if you are not using ONNX) self._model = onnx.load('model/model.onnx') def infer(self, input): # load preprocessed input inputAsNpArr = self._imageProcessor.loadAndPreprocess(input) # Run inference with caffe2 (change this if you are using a different DL framework) results = caffe2.python.onnx.backend.run_model(self._model, [inputAsNpArr]) # postprocess results into output output = self._imageProcessor.computeOutput(results) return output
class Model(ModelBase): def __init__(self): # load config file config = json.load(open("model/config.json")) # get the image processor self._imageProcessor = ImageProcessor(config) # load the DL model self._model = Xception() self._model.load_weights('model/model.h5') self._model._make_predict_function() def infer(self, input): # load preprocessed input inputAsNpArr = self._imageProcessor.loadAndPreprocess(input) # Run inference with caffe2 results = self._model.predict(inputAsNpArr) # postprocess results into output output = self._imageProcessor.computeOutput(results) return output
class Model(ModelBase): def __init__(self): # load config file config = json.load(open("model/config.json")) # get the image processor self._imageProcessor = ImageProcessor(config) # load the DL model self._model = C.Function.load("model/model.onnx", device=C.device.cpu(), format=C.ModelFormat.ONNX) def infer(self, input): # load preprocessed input inputAsNpArr = self._imageProcessor.loadAndPreprocess(input) # run inference results = self._model.eval({self._model.arguments[0]:[inputAsNpArr]}) # postprocess results into output output = self._imageProcessor.computeOutput(results) return output
class Model(ModelBase): def __init__(self): # load config file config = json.load(open("model/config.json")) # get the image processor self._imageProcessor = ImageProcessor(config) # load the DL model self._model = caffe.Net("model/step1/step1_deploy.prototxt", "model/step1/step1_weights.caffemodel", caffe.TEST) def infer(self, input): # load preprocessed input inputAsNpArr = self._imageProcessor.loadAndPreprocess(input) # Run inference self._model.blobs['data'].data[...] = inputAsNpArr results = self._model.forward() # postprocess results into output output = self._imageProcessor.computeOutput(results) return output
class Model(ModelBase): def __init__(self): # load config file config = json.load(open("model/config.json")) # get the image processor self._imageProcessor = ImageProcessor(config) # get context - cpu self._ctx = mx.cpu() def infer(self, input): # load preprocessed input inputAsNpArr = self._imageProcessor.loadAndPreprocess(input) # # Run inference im = self._imageProcessor._im result_shape = self._imageProcessor._result_shape # model loading needs to happen after input has been prosessed as # instantianting it requires the size of the input image. model = get_model(self._ctx, 'model/model.onnx', im) conf,result_img,blended_img,raw = predict(inputAsNpArr, result_shape, model, im) return np.array(result_img)