def post(self): token = request.headers.get('X-Auth-Token') if not existsToken(token): resp = Response(status=401) return resp f = flask.request.files['tumor_image'] # print(f) # content = StringIO(f.read()) img = Image.open(f) print(img) transform = transforms.Compose([ transforms.RandomResizedCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) img = transform(img) img = img.unsqueeze(0) with torch.no_grad(): model.eval() py = model(img) res = torch.max(py, 1)[1].data.numpy()[0] return classes[res], '200'
def predict(data, samples=1): """ Predict probability for different digits in incoming data and make a bar plot out of it. Args: data (str): Image encoded as a base64 string. samples (int): Number of times the network should be sampled. An average is then used. This is only useful if network is stochastic (default 1). Returns: matplotlib figure """ image = preprocess(data) x = torch.Tensor(image).view(1, 1, 28, 28) figure = Figure() ax = figure.add_subplot(1, 1, 1) preds = [] for _ in range(samples): pred = model(x).detach().numpy() pred = np.squeeze(pred) preds.append(pred) pred = np.mean(preds, axis=0) pred = np.exp(pred) return pred
def create(self, model, defaults=None, **kwargs): params = dict( (k, v) for k, v in kwargs.items() if not isinstance(v, ClauseElement)) params.update(defaults or {}) instance = model(**params) self.session.add(instance) self.session.flush() return instance
def gen_probabilities(image): """Call PyTorch ResNet + Fine-tuned net. @param image: RGB face image. @return probability vector of size 23. """ # first get the image into standard form image = Image.fromarray(image) image = image.convert('RGB') image = preprocessing(image).unsqueeze(0) image = Variable(image, volatile=True) # pass image through ResNet to get embedding embedding = embedder(image) embedding = embedding.squeeze(2).squeeze(2) # pass image through model to get prediction log_probas = model(embedding) probas = torch.exp(log_probas) # probabilities return probas
def predict(file: bytes = File(...)): try: img = Image.open(io.BytesIO(file)).convert('RGB') del file except (ValueError, AttributeError, OSError): raise HTTPException( status_code=422, detail= 'You must pass binaries of jpg or png image. Your data can not be interpreted as ' 'image') with torch.no_grad(): raw_preds = model(model.transforms(img).unsqueeze(0).to(model.device)) ingr_ids = raw_preds['ingr_ids'].cpu().numpy() recipe_ids = raw_preds['recipe_ids'].cpu().numpy() del raw_preds outs = process_prediction(recipe_ids[0], ingr_ids[0], model.instr_vocab, model.ingred_vocab) return dict(title=outs['title'], ingredients=outs['ingredients'])
def generate_models(ceesim_data, ceesim_flattened, lookup_table): # type: (dict, dict, dict) -> list ''' Generate all non INP/PUL models Parameters: * `ceesim_data`: (dictionary) Imported CEESIM JSON data * `ceesim_flattened`: (dictionary, optional) Flattened CEESIM JSON data * `lookup_table`: (dictionary) Lookup table JSON imported **Returns**: (list) List of models ''' logger.debug('Now generating all non-signal models') def fill_table(model, pos, value): # type: (model, int, str) -> None ''' Fills out table from model with values Parameters: * `model`: (model class object) Model object * `pos`: (int) Position index * `value`: (str) Value to fill **Returns**: None, table is filled in-place ''' if len(model.converted_data) <= pos: model.converted_data += [''] * \ (pos - len(model.converted_data) + 1) model.converted_data[pos] = value def create_converted(model, opt): # type: (model, list) -> None ''' Converts in-place model Parameters: * `model`: (model class object) Model object * `opt`: (list) Options from lookup table **Returns**: None, table is filled in place ''' if type(opt["TABLE"]) is int: table_string = build_table_str(ceesim_data, lookup_table, opt[FILE_HDR], opt["SECTION"], opt[PRI_HDR], convert_one_key, obtain_relevant_tags, opt[FILE_HDR] == "ANT") fill_table(model, opt[PRI_HDR], table_string) return None # No other conversion should occur after building table values = [] for tag in opt[TAG_HDR].split('&'): tags = obtain_relevant_tags(ceesim_data, ceesim_flattened, tag) # removed taking the zero-index as it's done below if tags: value = tags[0] logger.debug("Found tag {} for {} in {} with value: {}".format(opt[TAG_HDR], opt["LABEL"], opt[FILE_HDR], value)) else: if opt[TAG_HDR]: logger.debug('Could not find tag {}, using default value for {} in {}: {}'.format(opt[TAG_HDR], opt["LABEL"], opt[FILE_HDR], opt[DEFAULT_HDR])) else: logger.debug('Using default value for tagless {} in {}: {}'.format( opt["LABEL"], opt[FILE_HDR], opt[DEFAULT_HDR])) value = opt[DEFAULT_HDR] values.append(value) converted = convert_one_key(opt, values) fill_table(model, opt[PRI_HDR], converted) # adds to model.converted_data def add_headers(mfile, model): # type: (str, model) -> None ''' Adds headers to converted model Parameters: * `mfile`: (string) Name of file * `model`: (model) Model class object **Returns**: None, data is converted in place ''' with open("data/headers.csv") as head: headers = reader(head) for header in headers: if header[0] == mfile: left = (int(header[2]) - len(header[1]) - 3) / 2 lleft = int(left) right = lleft if lleft == left: left = lleft right = lleft + 1 htext = "//" + ' '.join( ['*' * lleft, header[1], '*' * right]) h_priority = int(header[3]) if determine_scan_type(ceesim_data) == "LORO" and mfile == "SIG" and (header[1] == "ANTENNA MODEL" or header[1] == "MULTIPLE SIMULTANEOUS SIGNALS"): # Resolves a downstream feature displacement that occurs from the inclusion of all scan data within the .sig file's SCAN MODEL h_priority += 3 fill_table(model, h_priority, htext) models = list() name = form_model_name(ceesim_data, ceesim_flattened) timestamp = obtain_relevant_tags(ceesim_data, ceesim_flattened, "LastUpdateDate")[0] logger.debug('Generic model generator using name: {}'.format(name)) for mtype in AUTO_MODELS: next_model = model(mtype, name, timestamp) if mtype not in MODEL_FILES: logger.warn( 'Could not find mtype {} in model files, skipping'.format(mtype)) continue table_key = MODEL_FILES[mtype] add_headers(table_key, next_model) if table_key not in lookup_table: logger.warn( 'Could not find key {} in lookup table, skipping'.format(table_key)) continue logger.debug( 'Now processing table key {} with mtype {}'.format(table_key, mtype)) for cdict_key in lookup_table[table_key]: key_data = lookup_table[table_key][cdict_key] if MULTI_HDR in key_data and TABLE_DATA in key_data: data_opts = key_data[TABLE_DATA] for opt in data_opts: if opt["SECTION"] == "Main": continue create_converted(next_model, opt) else: if key_data["SECTION"] == "Main": continue create_converted(next_model, key_data) models.append(next_model) # Handles Intrapule here inp_deviations = obtain_relevant_tags(ceesim_data, ceesim_flattened, "LinearFreqDeviation") inp_durations = obtain_relevant_tags(ceesim_data, ceesim_flattened, "LinearFreqDuration") inp_info = zip(inp_deviations, inp_durations) for i, info in enumerate(inp_info): newName = "{}-{}".format(name, i + 1) next_model = model('INTRAPULSE', newName, timestamp) table_key = MODEL_FILES['INTRAPULSE'] add_headers(table_key, next_model) if table_key not in lookup_table: logger.warn( 'Could not find key {} in lookup table, skipping'.format(table_key)) continue logger.debug( 'Now processing table key {} with mtype {}'.format(table_key, 'INTRAPULSE')) for cdict_key in lookup_table[table_key]: key_data = lookup_table[table_key][cdict_key] if MULTI_HDR in key_data and TABLE_DATA in key_data: data_opts = key_data[TABLE_DATA] for opt in data_opts: if opt["SECTION"] == "Main": continue create_converted(next_model, opt) else: if key_data["SECTION"] == "Main": continue if not key_data["TAG"]: create_converted(next_model, key_data) else: if key_data["TAG"] == "LinearFreqDeviation": fill_table(next_model, key_data[PRI_HDR], convert_one_key(key_data, [info[0]])) if key_data["TAG"] == "LinearFreqDeviation&LinearFreqDuration": fill_table(next_model, key_data[PRI_HDR], convert_one_key(key_data, info)) models.append(next_model) return models