def _predict_single(fp): img = open_image(fp) pred = img.predict(_learn) idx = pred.argmax() label = _learn.data.classes[idx] img_data = encode(img) return {'label': label, 'name': fp.filename, 'image': img_data}
def predict(img_path, class_add_thresh, message_id): learn, data = load_model(inference=True) img = open_image(img_path) pred_class, pred_idx, outputs = learn.predict(img) confidence = float(outputs[pred_idx]) zipped = zip((round(n, 3) for n in map(float, outputs)), data.classes) zipped = sorted(zipped, key=lambda tup: tup[0], reverse=True) print(f'Predicted Class: {pred_class}') print(f'Probs: {zipped}') if class_add_thresh and confidence > class_add_thresh: now_str = str(datetime.now()).replace(":", "_") filename = f'auto_add_{now_str}_{confidence}' filetype = img_path[img_path.rfind('.'):] path = PATH / 'train' / str(pred_class) / f'{filename}{filetype}' Path(path).write_bytes( Path(img_path).read_bytes()) # save the image to the training set print(AUTO_ADD_MESSAGE.format(conf=confidence, thresh=class_add_thresh)) r.set(message_id, str(path)) r.set(f'{message_id}_added', int(class_add_thresh and confidence > class_add_thresh)) # redis wants an int, byte, or string
def predict(): print('yes') try: f = request.files['img'] f.save( os.path.join(app.config['UPLOAD_FOLDER'], secure_filename(f.filename))) except Exception as e: print('cannot upload') print(str(e)) try: #img = request.form['img'] #print(img) #path = url_for('static', filename = secure_filename(img)) #print(img) img = open_image('./static/image/' + secure_filename(f.filename)) print(f.filename) pred_class, pred_idx, outputs = learn.predict(img) print(pred_class) except Exception as e: print(str(e)) return render_template('predict.html', predict_value=pred_class, path=f.filename)
async def analyze(request): img_data = await request.form() img_bytes = await (img_data['file'].read()) img = open_image(BytesIO(img_bytes)) prediction = learn.predict(img)[0] prob = list( sorted(zip(classes, list(learn.predict(img)[2].numpy())), key=lambda x: -x[1])) return JSONResponse({'result': str(prediction), 'prob': str(prob)})
def _predict_single(fp): img = open_image(fp) pred_class,pred_idx,outputs = _learn.predict(img) #pred = img.predict(_learn) #idx = pred.argmax() #label = _learn.data.classes[idx] img_data = encode(img) #return { 'label': label, 'name': fp.filename, 'image': img_data } return { 'label': str(pred_class), 'name': fp.filename, 'image': img_data }
def predictFile(file): if os.path.isfile(file): try: img=open_image(file,convert_mode="L") r=learn.predict(img) res=str(r[0]).capitalize(),str(float(torch.max(r[2])*100)) return res except: pass
def happysad_eval(pic): trained_model = model_fetch() classes = ['happy', 'sad'] bytes_pic = open_image(BytesIO(pic)) pred_class, pred_idx, outputs = trained_model.predict(bytes_pic) os.remove(Path.cwd() / 'export.pkl') return JSONResponse({ "pred_class": str(pred_class), "results": dict(zip(classes, outputs.tolist())) })
def predict_image_from_bytes(bytes): img = open_image(BytesIO(bytes)) pred_class, _pred_idx, outputs = LEARN.predict(img) return JSONResponse({ "predictions": sorted( zip(LEARN.data.classes, map(float, outputs)), key=lambda p: p[1], reverse=True ) })
def form_valid(self, form): _, _, outputs = LEARN.predict( open_image(BytesIO(form.files['pic'].read()))) predictions = zip(LEARN.data.classes, outputs) return render(self.request, self.template_name, { 'form': form, 'predictions': predictions })
def bearsInference(): #Get querystring to figure out which model to load ic=request.args.get('imageclassifier') print(ic) classes=[] path=None if ic=='KDEF': path=os.path.join(HERE, "tmp/KDEF") classes = ['afraid', 'angry', 'disgusted', 'happy', 'neutral', 'sad', 'surprised'] elif ic=='teddys': path=os.path.join(HERE, "tmp/bears") classes = ['black', 'grizzly', 'teddys'] learn = create_cnn(ImageDataBunch.single_from_classes(path, classes, tfms=get_transforms(), size=224).normalize(imagenet_stats), models.resnet34) learn.load('stage-2') fp = request.files['file'] #img=open_image(bearspath + '/models/00000014.jpg') # Read EXIF data exifData={} imgTemp=Image.open(fp) exifDataRaw=imgTemp._getexif() angle=0 if not exifDataRaw==None: for orientation in ExifTags.TAGS.keys(): if ExifTags.TAGS[orientation]=='Orientation': break exif=dict(exifDataRaw.items()) # print(exif[orientation]) if exif[orientation] == 3: angle=180 elif exif[orientation] == 6: angle=270 elif exif[orientation] == 8: angle=90 img=open_image(fp) rotate(img,angle) pred_class,pred_idx,outputs = learn.predict(img) img_data = encode(img) body = { 'label': str(pred_class), 'image': img_data } resp= Response(response=json.dumps({"response": body}), status=200, mimetype='application/json') #print (str(pred_class)) return resp
def augment_image(path, size=(224, 224), x=10): img = image.open_image(path) augmented = [ img.apply_tfms(tfms=tfms[0], size=size, padding_mode='border') for i in range(x) ] orig = load_img(path, target_size=size) return [orig] + [ array_to_img(aug_img.data, data_format='channels_first') for aug_img in augmented ]
def infer_classes(png_fname): """ XXX TODO predict classes (background audio type or speech) """ # 1 as speech from fastai.vision.image import open_image classes = model_classes.predict(open_image(png_fname)) return classes
def predictscore(self, filename): img = open_image(filename) pred_class, pred_idx, outputs = self.learn.predict(img) if self.verbose: print("pred") print(pred_class) print("pred_idx") print(pred_idx) print(outputs) return (pred_class.obj, outputs[pred_idx].item())
def predict(url): response = requests.get(url) img = Image.open(BytesIO(response.content)).resize((512, 384), Image.ANTIALIAS) filename = "./ml-model/data/img.jpg" img.save(filename) learn = load_learner("./ml-model/") category = str(learn.predict(open_image(filename))[0]) tensor_probs = learn.predict(open_image(filename))[2] pred_probs = { "cardboard": round(float(tensor_probs[0]), 2), "glass": round(float(tensor_probs[1]), 2), "metal": round(float(tensor_probs[2]), 2), "paper": round(float(tensor_probs[3]), 2), "plastic": round(float(tensor_probs[4]), 2), "trash": round(float(tensor_probs[5]), 2) } ans = {"url": url, "category": category, "pred_probs": pred_probs} return ans
def predictImage(request): fileObj = getFile(request) filePath, fileName, fileUrl = handled_uploaded_file(fileObj) print(filePath) _,_,outputs = LEARN.predict(open_image(filePath)) outputs = outputs.numpy() # print(fileObj) # print(np.around(outputs*100, 3)) # print(outputs[np.argmax(outputs)]) # print(LEARN.data.classes[np.argmax(outputs)]) # print(fileUrl) context = {'scores': list(np.around(outputs*100, 3)), 'prediction_score': np.around(outputs[np.argmax(outputs)]*100, 3), 'labels': LEARN.data.classes, 'prediction_label': LEARN.data.classes[np.argmax(outputs)], 'image': fileUrl} return render(request, 'index.html', context)
def run_test(model, path, show_images=False, test_folder='test'): count = 0 correct = 0 if not path[-1] == '/': path += '/' testpath = path + test_folder + '/' for folder in os.listdir(testpath): folderpath = testpath+folder if os.path.isdir(folderpath): for img in os.listdir(folderpath): imgpath = folderpath + '/' + img img = image.open_image(imgpath) p = model.predict(img) if show_images: img.show(title=p) prediction = str(p[0]) if prediction == folder: correct += 1 count += 1 print("Result for test: " + str(correct) + "/" + str(count) + "(" + str(correct/count) + ")")
def predict(self, img_path): img = open_image(img_path) return self.learn.predict(img)
def get_prediction(bytes): img = open_image(BytesIO(bytes)) pred = learner.predict(img) return pred
def predict(self, filename): img = open_image(filename) pred_class, pred_idx, outputs = self.learn.predict(img) return pred_class
# In[ ]: learn = load_learner("/content/drive/My Drive/data/models/") # In[ ]: learn.load("/content/drive/My Drive/data/models/model3") # In[49]: learn.predict(open_image("stack-of-paper.jpg")) # In[ ]: from PIL import Image img = Image.open("stack-of-paper.jpg").resize((512,384), Image.ANTIALIAS) img.save("stack-of-paper.jpg") # In[46]: get_ipython().system('wget "http://tmib.com/wp-content/uploads/2014/08/stack-of-paper.jpg"')
def make_prediction(img_bytes): img = open_image(BytesIO(img_bytes)) pred_class,pred_idx,outputs = learn.predict(img) prob = outputs[pred_idx].item()*100.0 return (str(pred_class), str(round(prob,1)))
def predict_recylable_from_image_url(): """ Get recycling item class prediction and probability from a `fastai` model. This endpoint accepts an image `url` as a query argument. It returns the recycling image `url`, `class`, and `probability` (probability of being that class) based on the image. To access the API Docs, visit host:port/apidocs (e.g.: 0.0.0.0:80/apidocs) --- tags: - Probability of recycling class from image URL parameters: - name: url in: query type: string required: true description: url for recyling image to analyze responses: 400: description: Bad Request 200: description: OK properties: url: type: string example: google.com/images/plastic_bottle.jpg class: type: string example: plastics probability: type: float example: 0.992 """ url = _get_image_url_from_request(request) g.log = g.log.bind(url=url) try: response = requests.get(url) image_from_interwebs = im.open_image(BytesIO(response.content)) g.log = g.log.bind(image_opened=True) except Exception as e: print(e) abort( 400, 'Unable to open image specified in `url`. Check API docs for usage.' ) try: pred_class, _, pred_probs = LEARNER.predict(image_from_interwebs) g.log = g.log.bind(prediction_made=True) except Exception as e: print(e) abort( 400, 'Issue getting model prediction for image. Check API docs for usage.' ) try: g.log = g.log.bind(pred_class=pred_class.obj, pred_probability=max(pred_probs.tolist()), pred_probability_list=pred_probs.tolist()) output = { 'url': url, 'class': pred_class.obj, 'probability': max(pred_probs.tolist()), } return jsonify(output) except Exception as e: print(e) abort(400, 'Issue JSON-ifying output. Check API docs for usage.')
def open(self, fn, **kwargs): return open_image(fn, **kwargs)
def addmask(img, i): mask = image.open_image('{:s}/{:06d}.jpg'.format("masks", i), convert_mode="L") img.px = torch.max(img.px, mask.px) return img
def addgrain(img, i, alpha): grain = image.open_image('{:s}/{:06d}.jpg'.format("grains", i), convert_mode="L") img.px = torch.mul(img.px, grain.px * alpha + (1 - alpha)) return img
contrast = np.clip(rnd[0] * 0.5 + 1, a_min=0.4, a_max=3) brightness = np.clip(rnd[1] * 0.25 + 0.5, a_min=0.2, a_max=0.8) grainalpha = np.clip(rnd[2] * 0.25 + 0.5, a_min=0, a_max=1) * 0.2 return deterioration(img, index, contrast, brightness, grainalpha) def loguniform(low=0, high=1, size=None): return np.exp(np.random.uniform(np.log(low), np.log(high), size)) def expuniform(low=0, high=1, size=None): return np.log(np.random.uniform(np.exp(low), np.exp(high), size)) data = [] for filename in glob.glob('color/*.jpg'): im = image.open_image(filename, convert_mode='L') contrast = np.random.uniform(0.5, 3) brightness = np.random.uniform(0.2, 0.8) # contrast = np.clip(rnd[0]*0.5+1, a_min=0.4, a_max=3) # brightness = np.clip(rnd[1]*0.25+0.5, a_min=0.2, a_max=0.8) data.append([path.basename(filename), contrast, brightness]) im = deterioration(im, 0, contrast, brightness) im.save("deteriorated/" + path.basename(filename)) df = pd.DataFrame(columns=["image", "contrasts", "brightness"], data=data) df.head() df.set_index("image").to_csv("deteriorated/data.csv")
def _categorize_feature_class( self, feature_class, raster, class_value_field, class_name_field, confidence_field, cell_size, coordinate_system, predict_function, batch_size, overwrite ): import arcpy arcpy.env.overwriteOutput = overwrite if batch_size is None: batch_size = self._data.batch_size if predict_function is None: predict_function = _prediction_function norm_mean = torch.tensor(imagenet_stats[0]) norm_std = torch.tensor(imagenet_stats[1]) fcdesc = arcpy.Describe(feature_class) oid_field = fcdesc.OIDFieldName if not (fcdesc.dataType == 'FeatureClass' and fcdesc.shapeType == 'Polygon'): e = Exception(f"The specified FeatureClass at '{feature_class}' is not valid, it should be Polygon FeatureClass") raise(e) fields = arcpy.ListFields(feature_class) field_names = [f.name for f in fields] if class_value_field in field_names: if not overwrite: e = Exception(f"The specified class_value_field '{class_value_field}' already exists in the target FeatureClass, please specify a different name or set `overwrite=True`") raise(e) arcpy.DeleteField_management(feature_class, [ class_value_field ]) arcpy.AddField_management(feature_class, class_value_field, "LONG") if class_name_field in field_names: if not overwrite: e = Exception(f"The specified class_name_field '{class_name_field}' already exists in the target FeatureClass, please specify a different name or set `overwrite=True`") raise(e) arcpy.DeleteField_management(feature_class, [ class_name_field ]) arcpy.AddField_management(feature_class, class_name_field, "TEXT") if confidence_field is not None: if confidence_field in field_names: if not overwrite: e = Exception(f"The specified confidence_field '{confidence_field}' already exists in the target FeatureClass, please specify a different name or set `overwrite=True`") raise(e) arcpy.DeleteField_management(feature_class, [ confidence_field ]) arcpy.AddField_management(feature_class, confidence_field, "DOUBLE") if raster is not None: #Arcpy Environment to export data arcpy.env.cellSize = cell_size arcpy.env.outputCoordinateSystem = coordinate_system arcpy.env.cartographicCoordinateSystem = coordinate_system tempid_field = _tempid_field = 'f_fcuid' i = 1 while tempid_field in field_names: tempid_field = _tempid_field + str(i) i+=1 arcpy.AddField_management(feature_class, tempid_field, "LONG") arcpy.CalculateField_management(feature_class, tempid_field, f"!{oid_field}!") temp_folder = arcpy.env.scratchFolder temp_datafldr = os.path.join(temp_folder, 'categorize_features_'+str(int(time.time()))) result = arcpy.ia.ExportTrainingDataForDeepLearning( in_raster=raster, out_folder=temp_datafldr, in_class_data=feature_class, image_chip_format="TIFF", tile_size_x=self._data.chip_size, tile_size_y=self._data.chip_size, stride_x=0, stride_y=0, output_nofeature_tiles="ALL_TILES", metadata_format="Labeled_Tiles", start_index=0, class_value_field=tempid_field, buffer_radius=0, in_mask_polygons=None, rotation_angle=0 ) # cleanup arcpy.DeleteField_management(feature_class, [ tempid_field ]) image_list = ImageList.from_folder(os.path.join(temp_datafldr, 'images')) def get_id(imagepath): with open(os.path.join(temp_datafldr, 'labels', os.path.basename(imagepath)[:-3]+'xml')) as f: return(int(f.read().split('<name>')[1].split('<')[0])) for i in range(0, len(image_list), batch_size): # Get Temporary Ids tempids =[ get_id(f) for f in image_list.items[i:i+batch_size] ] # Get Image batch image_batch = torch.stack([ im.data for im in image_list[i:i+batch_size] ]) image_batch = normalize(image_batch, mean=norm_mean, std=norm_std) # Get Predications predicted_classes, predictions_conf = self._predict_batch(image_batch) # Update Feature Class where_clause = f"{oid_field} IN ({','.join(str(e) for e in tempids)})" update_cursor = arcpy.UpdateCursor( feature_class, where_clause=where_clause, sort_fields=f"{oid_field} A" ) for row in update_cursor: row_tempid = row.getValue(oid_field) ui = tempids.index(row_tempid) classvalue = self._data.classes[predicted_classes[ui]] row.setValue(class_value_field, classvalue) row.setValue(class_name_field, self._data.class_mapping[classvalue]) if confidence_field is not None: row.setValue(confidence_field, predictions_conf[ui]) update_cursor.updateRow(row) # Remove Locks del row del update_cursor # Cleanup arcpy.Delete_management(temp_datafldr) shutil.rmtree(temp_datafldr, ignore_errors=True) else: feature_class_attach = feature_class+'__ATTACH' nrows = arcpy.GetCount_management(feature_class_attach)[0] store={} for i in range(0, int(nrows), batch_size): attachment_ids = [] rel_objectids = [] image_batch = [] # Get Image Batch with arcpy.da.SearchCursor(feature_class_attach, [ 'ATTACHMENTID', 'REL_OBJECTID', 'DATA' ]) as search_cursor: for c, item in enumerate(search_cursor): if c >= i and c < i+batch_size : attachment_ids.append(item[0]) rel_objectids.append(item[1]) attachment = item[-1] im = open_image(io.BytesIO(attachment.tobytes())) # Read Bytes im = im.resize(self._data.chip_size) # Resize image_batch.append(im.data) # Convert to tensor del item del attachment #del im image_batch = torch.stack(image_batch) image_batch = normalize(image_batch, mean=norm_mean, std=norm_std) # Get Predictions and save to store predicted_classes, predictions_conf = self._predict_batch(image_batch) for ai in range(len(attachment_ids)): if store.get(rel_objectids[ai]) is None: store[rel_objectids[ai]] = [] store[rel_objectids[ai]].append([predicted_classes[ai], predictions_conf[ai]]) # Update Feature Class update_cursor = arcpy.UpdateCursor(feature_class) for row in update_cursor: row_oid = row.getValue(oid_field) max_prediction_class, max_prediction_value = predict_function(store[row_oid]) if max_prediction_class is not None: classvalue = self._data.classes[max_prediction_class] classname = self._data.class_mapping[classvalue] else: classvalue = None classname = None row.setValue(class_value_field, classvalue) row.setValue(class_name_field, classname) if confidence_field is not None: row.setValue(confidence_field, max_prediction_value) update_cursor.updateRow(row) # Remove Locks del row del update_cursor return True
def _categorize_feature_layer( self, feature_layer, raster, class_value_field, class_name_field, confidence_field, cell_size, coordinate_system, predict_function, batch_size, overwrite ): # norm_mean = torch.tensor(imagenet_stats[0]) norm_std = torch.tensor(imagenet_stats[1]) # Check and create Fields class_name_field_template = { "name": class_name_field.lower(), "type": "esriFieldTypeString", "alias": class_name_field, "sqlType": "sqlTypeOther", "length": 256, "nullable": True, "editable": True, "visible": True, "domain": None, "defaultValue": '' } class_value_field_template = { "name": class_value_field.lower(), "type": "esriFieldTypeInteger", "alias": class_value_field, "sqlType": "sqlTypeOther", "nullable": True, "editable": True, "visible": True, "domain": None, "defaultValue": -999 } to_delete = [] to_create = [] feature_layer_fields = { f['name'].lower():f for f in feature_layer.properties["fields"] } oid_field = feature_layer.properties['objectIdField'] if class_value_field_template['name'] in feature_layer_fields: if overwrite: to_delete.append(feature_layer_fields[class_value_field_template['name']]) else: e = Exception(f"The specified class_value_field '{class_value_field}' already exists, please specify a different name or set `overwrite=True`") raise(e) to_create.append(class_value_field_template) if class_name_field_template['name'] in feature_layer_fields: if overwrite: to_delete.append(feature_layer_fields[class_name_field_template['name']]) else: e = Exception(f"The specified class_name_field '{class_name_field}' already exists, please specify a different name or set `overwrite=True`") raise(e) to_create.append(class_name_field_template) if confidence_field is not None: confidence_field_template = { "name": confidence_field.lower(), "type": "esriFieldTypeDouble", "alias": confidence_field, "sqlType": "sqlTypeDouble", "nullable": True, "editable": True, "visible": True, "domain": None, "defaultValue": -999 } if confidence_field_template['name'] in feature_layer_fields: if overwrite: to_delete.append(feature_layer_fields[confidence_field_template['name']]) else: e = Exception(f"The specified confidence_field '{confidence_field}' already exists, please specify a different name or set `overwrite=True`") raise(e) to_create.append(confidence_field_template) feature_layer.manager.delete_from_definition({'fields': to_delete}) feature_layer.manager.add_to_definition({'fields': to_create}) # Get features for updation fields_to_update = [oid_field, class_value_field, class_name_field] if confidence_field is not None: fields_to_update.append(confidence_field) feature_layer_features = feature_layer.query(out_fields=",".join(fields_to_update), return_geometry=False).features update_store = {} if raster is not None: import arcpy #Arcpy Environment to export data arcpy.env.cellSize = cell_size arcpy.env.outputCoordinateSystem = coordinate_system arcpy.env.cartographicCoordinateSystem = coordinate_system feature_layer_url = feature_layer.url if feature_layer._token is not None: feature_layer_url = feature_layer_url + f"?token={feature_layer._token}" # Create Temporary ID field tempid_field = _tempid_field = 'f_fcuid' i = 1 while tempid_field in feature_layer_fields: tempid_field = _tempid_field + str(i) i+=1 arcpy.AddField_management(feature_layer_url, tempid_field, "LONG") #feature_layer.manager.add_to_definition({'fields': [tempid_field_template]}) arcpy.CalculateField_management(feature_layer_url, tempid_field, f"{oid_field}", "SQL") temp_folder = arcpy.env.scratchFolder temp_datafldr = os.path.join(temp_folder, 'categorize_features_'+str(int(time.time()))) result = arcpy.ia.ExportTrainingDataForDeepLearning( in_raster=raster, out_folder=temp_datafldr, in_class_data=feature_layer_url, image_chip_format="TIFF", tile_size_x=self._data.chip_size, tile_size_y=self._data.chip_size, stride_x=0, stride_y=0, output_nofeature_tiles="ALL_TILES", metadata_format="Labeled_Tiles", start_index=0, class_value_field=tempid_field, buffer_radius=0, in_mask_polygons=None, rotation_angle=0 ) # cleanup arcpy.DeleteField_management(feature_layer_url, [ tempid_field ]) image_list = ImageList.from_folder(os.path.join(temp_datafldr, 'images')) def get_id(imagepath): with open(os.path.join(temp_datafldr, 'labels', os.path.basename(imagepath)[:-3]+'xml')) as f: return(int(f.read().split('<name>')[1].split('<')[0])) for i in range(0, len(image_list), batch_size): # Get Temporary Ids tempids = [ get_id(f) for f in image_list.items[i:i+batch_size] ] # Get Image batch image_batch = torch.stack([ im.data for im in image_list[i:i+batch_size] ]) image_batch = normalize(image_batch, mean=norm_mean, std=norm_std) # Get Predications predicted_classes, predictions_conf = self._predict_batch(image_batch) # push prediction to store for ui, oid in enumerate(tempids): classvalue = self._data.classes[predicted_classes[ui]] update_store[oid] = { oid_field: oid, class_value_field: classvalue, class_name_field: self._data.class_mapping[classvalue] } if confidence_field is not None: update_store[oid][confidence_field] = predictions_conf[ui] # Cleanup arcpy.Delete_management(temp_datafldr) shutil.rmtree(temp_datafldr, ignore_errors=True) else: out_folder = tempfile.TemporaryDirectory().name os.mkdir(out_folder) feature_layer.export_attachments(out_folder) with open(os.path.join(out_folder, 'mapping.txt')) as file: feature_attachments_mapping = json.load(file) images_store = [] for oid in feature_attachments_mapping: for im in feature_attachments_mapping[oid]: images_store.append({ 'oid': oid, 'im': os.path.join(out_folder,im) }) update_store_scratch = {} for i in range(0, len(images_store), batch_size): rel_objectids = [] image_batch = [] for r in images_store[i:i+batch_size]: im = open_image(r['im']) # Read Bytes im = im.resize(self._data.chip_size) # Resize image_batch.append(im.data) # Convert to tensor rel_objectids.append(int(r['oid'])) image_batch = torch.stack(image_batch) image_batch = normalize(image_batch, mean=norm_mean, std=norm_std) # Get Predictions and save to scratch predicted_classes, predictions_conf = self._predict_batch(image_batch) for ai, oid in enumerate(rel_objectids): if update_store_scratch.get(oid) is None: update_store_scratch[oid] = [] update_store_scratch[oid].append([predicted_classes[ai], predictions_conf[ai]]) # Prepare final updated features for oid in update_store_scratch: max_prediction_class, max_prediction_value = predict_function(update_store_scratch[oid]) if max_prediction_class is not None: classvalue = self._data.classes[max_prediction_class] classname = self._data.class_mapping[classvalue] else: classvalue = None classname = None update_store[oid] = { oid_field: oid, class_value_field: classvalue, class_name_field: classname } if confidence_field is not None: update_store[oid][confidence_field] = max_prediction_value # Update Features features_to_update = [] for feat in feature_layer_features: if update_store.get(feat.attributes[oid_field]) is not None: updated_attributes = update_store[feat.attributes[oid_field]] for f in fields_to_update: feat.attributes[f] = updated_attributes[f] features_to_update.append(feat) step = 100 for si in range(0, len(features_to_update), step): feature_batch = features_to_update[si:si+step] response = feature_layer.edit_features(updates=feature_batch) for resp in response.get('updateResults', []): if resp.get('success', False): continue warnings.warn(f"Something went wrong for data {resp}") time.sleep(2)
img = img_to_array(img) / 255 if batchImages.shape == (0, ): batchImages = np.array([img]) continue batchImages = np.r_[batchImages, np.array([img])] features = model.predict(batchImages, batch_size=batchImages.shape[0]) features = features.reshape( (features.shape[0], np.prod(features.shape[1:]))) if test_x.shape == (0, ): test_x = features continue test_x = np.r_[test_x, features] # deserialize model of classifier model = pickle.load(open(MODEL_PATH, 'rb')) # evaluate the model preds = model.predict(test_x) df = pd.DataFrame(np.array([[str(i).zfill(4), LABELS[int(p)]] for i, p in enumerate(preds)]), columns=('id', 'label')) df.to_csv(BASE_CSV_PATH + "/test_prediction.csv", index=False) return df df = test(10) df.describe() for i, label in df.values[:10]: img_paths = list(paths.list_images(TEST_DIR)) img = image.open_image(TEST_DIR + i + '.jpg') img.show(title=label)
def predict(filename): app_root = os.path.dirname(os.path.abspath(__file__)) app_root=os.path.join(app_root,'Skincancermodel') p=['Actinic keratoses', 'Basal cell carcinoma', 'Benign keratosis ', 'Dermatofibroma', 'Melanocytic nevi', 'Melanoma', 'Vascular lesions'] img = open_image(os.path.join(app_root,filename)) img=cv2.imread(os.path.join(app_root,filename)) #converting from gbr to hsv color space img_HSV = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) #skin color range for hsv color space HSV_mask = cv2.inRange(img_HSV, (0, 15, 0), (17,170,255)) HSV_mask = cv2.morphologyEx(HSV_mask, cv2.MORPH_OPEN, np.ones((3,3), np.uint8)) #converting from gbr to YCbCr color space img_YCrCb = cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb) #skin color range for hsv color space YCrCb_mask = cv2.inRange(img_YCrCb, (0, 135, 85), (255,180,135)) YCrCb_mask = cv2.morphologyEx(YCrCb_mask, cv2.MORPH_OPEN, np.ones((3,3), np.uint8)) #merge skin detection (YCbCr and hsv) global_mask=cv2.bitwise_and(YCrCb_mask,HSV_mask) global_mask=cv2.medianBlur(global_mask,3) global_mask = cv2.morphologyEx(global_mask, cv2.MORPH_OPEN, np.ones((4,4), np.uint8)) HSV_result = cv2.bitwise_not(HSV_mask) YCrCb_result = cv2.bitwise_not(YCrCb_mask) global_result=cv2.bitwise_not(global_mask) #print(global_result.size) #show results # cv2.imshow("1_HSV.jpg",HSV_result) # cv2.imshow("2_YCbCr.jpg",YCrCb_result) # cv2.imshow("3_global_result.jpg",global_result) # cv2.imshow("Image.jpg",img) #cv2.imwrite("1_HSV.jpg",HSV_result) #cv2.imwrite("2_YCbCr.jpg",YCrCb_result) #cv2.imwrite("3_global_result.jpg",global_result) #cv2.waitKey(0) #cv2.destroyAllWindows() ii=0 jj=0 for i in range(0,global_result.shape[0]): for j in range(0,global_result.shape[1]): ii+=global_result[i][j] jj+=255 print(ii) print(jj) print(ii/jj) if ii/jj>0.5: return { "answer":"no skin" } #os.remove(os.path.join(app_root,filename)) learn = load_learner(os.path.join( os.path.dirname(os.path.abspath(__file__)),'Skincancermodel'),"export.pkl") aa=p[learn.predict(img)[1]] bb=learn.predict(img) predict_names={ "answer":aa, "v1":str(bb[0]), "v2":str(bb[1]), "v3":str(bb[2]) } print("predict______predict") print(predict_names) return predict_names