def test_data_aug():
# given
data_path = DATA_DIR / "COVIDx"
assert data_path.exists()
img_path = data_path / 'test/0a51f668-b7b1-4d8d-9ab9-de1f702f071a.png'
img = fv.open_image(img_path)
# then brightness
plt.close("all")
fig, axs = plt.subplots(1,5,figsize=(12,4))
for change, ax in zip([0.4, 0.5, 0.6, 1.0,1.1], axs):
img = fv.open_image(img_path)
fv.brightness(img, change).show(ax=ax, title=f'change={change:.1f}')
plt.savefig("test_data_aug_bitghtness.jpg")
# then rotation
plt.close("all")
tfm = [fv.rotate(degrees=(-10,10), p=0.75)]
fig, axs = plt.subplots(1,5,figsize=(12,4))
for ax in axs:
img = fv.open_image(img_path)
img = img.apply_tfms(tfm)
title = f"Done, deg={tfm[0].resolved['degrees']:.1f}" if tfm[0].do_run else f'Not done'
img.show(ax=ax, title=title)
plt.savefig("test_data_aug_rotation.jpg")
def input_fn(request_body, content_type=JPEG_CONTENT_TYPE):
logger.info('Deserializing the input data.')
# process an image uploaded to the endpoint
if content_type == JPEG_CONTENT_TYPE:
return open_image(io.BytesIO(request_body))
# process a URL submitted to the endpoint
if content_type == JSON_CONTENT_TYPE:
img_request = requests.get(request_body['url'], stream=True)
return open_image(io.BytesIO(img_request.content))
raise Exception(
'Requested unsupported ContentType in content_type: {}'.format(
content_type))
async def signature_compute(app: UploadFile = File(...),
device: UploadFile = File(...)):
try:
app_img = open_image(app.file)
except:
app_img = None
try:
device_img = open_image(device.file)
except:
device_img = None
result = compare_sig(app_img, device_img)
app.file.close()
device.file.close()
return result
async def infer():
path = Path('data/')
learn = load_learner(path)
data = await request.get_data()
img = open_image(BytesIO(data))
pred_class, pred_idx, outputs = learn.predict(img)
return str(pred_class)
def is_hotdog(filepath: str) -> bool:
"""
in current model, hotdog is 0 and not hotdog is 1
"""
category, tensor, probs = model.predict(open_image(filepath))
return False if model.data.c2i.get(str(category)) else True
def write_prediction_with_score(result_file, learner, test_path, num_samples, class_names):
"""
Writes the prediction to a file for the Stanford cars test dataset, including class name and confidence score.
:param result_file: User-defined result file name, which will have the class id, class name and confidence score for prediction.
:param learner: Model learner to classify images.
:param test_path: Path to dir where test images as located.
:param num_samples: Test samples = 8041, as provided by https://ai.stanford.edu/~jkrause/cars/car_dataset.html
:param class_names: Class names for cars as provided by https://ai.stanford.edu/~jkrause/cars/car_dataset.html
:return:
"""
out = open(result_file, 'a')
start = time.time()
out.write('class_id, class_name, confidence\n')
for i in range(num_samples):
filename = os.path.join(test_path, '%05d.jpg' % (i + 1))
img = open_image(filename)
pred_class, pred_idx, confidence = learner.predict(img)
out.write('{}, {}, {}\n'.format(pred_idx.item() + 1, class_names[pred_idx.item()][0][0],
confidence[pred_idx.item()].item()))
end = time.time()
seconds = end - start
print('avg fps: {}'.format(str(num_samples / seconds)))
out.close()
def segment(self, input_volume, output_label):
vol = sitk.ReadImage(input_volume)
vol_nda = sitk.GetArrayFromImage(vol)
original_shape = vol_nda.shape
print("Original vol shape:", original_shape)
stacked_labels = np.array([])
for idx, slice in enumerate(vol_nda):
im = Image.fromarray(slice).convert("L")
with io.BytesIO() as slice_bytes:
im.save(slice_bytes, format="PNG")
img = open_image(slice_bytes)
pred_class, pred_labels, losses = self.learner.predict(img)
np_labels = pred_labels.numpy()
if stacked_labels.size == 0:
stacked_labels = np_labels
else:
stacked_labels = np.concatenate([stacked_labels, np_labels],
axis=0)
print("Prediction ranges:", stacked_labels.min(), stacked_labels.max())
bone_labels = np.clip(stacked_labels - 1, 0, 1)
print("Output volume shape:", bone_labels.shape)
print("Output volume ranges:", bone_labels.min(), bone_labels.max())
label_vol = sitk.GetImageFromArray(bone_labels.astype(np.uint8))
label_vol.CopyInformation(vol)
writer = sitk.ImageFileWriter()
writer.Execute(label_vol, output_label, True)
def predict_landcover_type(filepath: str) -> List[str]:
""" Predict the landcover type form a Planet Skysat Image.
Utilizes the Fasiai.vision land cover classification model in order to predict
a set of landcover types from
https://docs.fast.ai/vision.image.html
Args:
filepath [str]: Path to the image that will be run through the model
Returns:
List[str]: A list of string labels resulting from a combination of the following land cover types:
{'agriculture', 'artisinal_mine', 'bare_ground', 'blooming', 'blow_down',
'clear', 'cloudy', 'conventional_mine', 'cultivation',
'habitation', 'haze', 'partly_cloudy', 'primary', 'road',
'selective_logging', 'slash_burn', 'water'}
"""
image = open_image(filepath)
# https://forums.fast.ai/t/how-to-make-predictions-with-vision-learner-solved/34456/9
model = load_learner('models/', 'fastai_planet_model.pkl')
category, tensor, probs = model.predict(image)
return str(category).split(';')
def deploy(model_name):
doc_ref = db.collection(u'Models').document(model_name)
try:
doc = doc_ref.get()
labels = doc.to_dict()['labels']
except:
print(u'No such model exists!')
return 'No such model exists!'
if 'file' not in request.files:
flash('No file part')
return 'No File Sent'
file = request.files['file']
file.save("/home/bharathrajeevnair/dsfh-v2/api-backend/tmp/samp.jpeg")
img = open_image(
"/home/bharathrajeevnair/dsfh-v2/api-backend/tmp/samp.jpeg")
learn = load_learner(
'/home/bharathrajeevnair/dsfh-v2/api-backend/models/' + model_name)
pred_class, _, _ = learn.predict(img)
pred = int(pred_class)
os.remove("/home/bharathrajeevnair/dsfh-v2/api-backend/tmp/samp.jpeg")
data_foy = {
u'prediction': labels[pred],
}
resy = json.dumps(data_foy)
respons = json.loads(resy)
return respons
def authenticate():
path = '/lib/Auth/RecFace/images/models/'
root_models = [f for f in listdir(path) if isfile(join(path, f))]
if 'tmp.pth' in root_models:
root_models.remove('tmp.pth')
classes = ["Test", "Train"]
data = ImageDataBunch.single_from_classes('/lib/Auth/RecFace/images/',
classes,
ds_tfms=None,
size = 224)
data.normalize(imagenet_stats)
learn = cnn_learner(data, models.vgg16_bn)
imgs = getFaces.getFaces()
if len(imgs)==0:
return False
for img in imgs:
img = resize(img, (224,224), interpolation = INTER_AREA)
imwrite('temp.jpeg', img)
img = open_image('temp.jpeg')
for mod in root_models:
if compare(mod.split('.')[0], img, learn):
return True
return False
def upload_file():
"""
retrieve the image uploaded and make sure it is an image file
"""
file = request.files['file']
image_extensions = ['jpg', 'jpeg', 'png']
if file.filename.split('.')[1] not in image_extensions:
return jsonify('Please upload an appropriate image file')
"""
Load the trained model in export.pkl
"""
learn = load_learner(path=".")
"""
Perform prediction
"""
#image_bytes = file.read()
#img = Image.open(io.BytesIO(image_bytes))
img = open_image(file)
pred_class, pred_idx, outputs = learn.predict(img)
i = pred_idx.item()
classes = [
'Domestic Medium Hair', 'Persian', 'Ragdoll', 'Siamese', 'Snowshoe'
]
prediction = classes[i]
return jsonify(f'Your cat is a {prediction}')
def get_vector(img, model):
sf = SaveFeatures(model.model[1][4]) # layer ke-empat sebelum softmax (_fc)
model.
_ = model.predict(open_image(img))
vectors = sf.features
sf.remove()
return vectors[0]
def run_model(learn, image_path, info):
# Get the image
image = open_image(image_path)
# Run the prediction
__, __, outputs = learn.predict(image)
# Convert the results to a list of predictions
predictions = convert_to_predictions(outputs, learn.data.classes)
prediction = predictions[0]
if len(predictions) == 1:
other_predictions = []
else:
del predictions[0]
other_predictions = predictions
# Get just the filename from the path
__, filename = os.path.split(image_path)
# copy to a result object
r = Result(image_path, filename, info, prediction, other_predictions)
return r
def covid_func():
model = load_learner('models')
if request.method == 'GET':
return render_template('index.html', value='We Got You!')
if request.method == 'POST':
print(request.files)
if 'file' not in request.files:
print('Image not uploaded')
return
file = request.files['file']
img = open_image(file)
#Getting the Best class
pred_class_1, idx_1, pred_prob = model.predict(img)
#Getting all best pred
preds_sorted, idxs = pred_prob.sort(descending=True)
#Getting prediction
pred_1_prob = np.round(100 * preds_sorted[0].item(), 2)
return render_template('result.html',
label=pred_class_1,
category=pred_1_prob)
def fetch_image(url):
response = requests.get(url)
img = open_image(BytesIO(response.content))
#response = requests.get(url)
#pil_img = PIL.Image.open(BytesIO(response.content))
#display_img = np.asarray(pil_img)
return img
async def predict(request):
form = await request.form()
filename = form['file'].filename
content = await form['file'].read()
img = open_image(BytesIO(content))
prediction = learn.predict(img)[0]
return JSONResponse({'result': str(prediction)})
def handle_cli(self, args, func):
parser = argparse.ArgumentParser()
parser.add_argument("--input", required=True)
parser.add_argument("-o",
"--output",
default="str",
choices=["str", "json", "yaml"])
parsed_args = parser.parse_args(args)
file_path = parsed_args.input
verify_image_format_or_raise(file_path, self.accept_image_formats)
if not os.path.isabs(file_path):
file_path = os.path.abspath(file_path)
image_array = open_image(
fn=file_path,
convert_mode=self.convert_mode,
div=self.div,
after_open=self.after_open,
cls=self.cls or Image,
)
result = func(image_array)
result = get_output_str(result, output_format=parsed_args.output)
print(result)
def submit():
print(request.url)
if 'file' not in request.files:
flash('No file received')
return redirect(request.url)
file = request.files['file']
if file.filename == '':
flash('No file selected.')
return redirect(request.url)
if file and allowed_file(file.filename):
filename = file.filename
img_path = (os.path.join(path, 'static', filename))
file.save(img_path)
print(img_path)
img = open_image(img_path)
_, pred_idx, pred_conf = learn.predict(img)
pred_class = learn.data.train_ds.y.classes[pred_idx.data.numpy()]
conf = pred_conf.max().numpy()
output_string = f'{pred_class.__str__().title()} [ {conf*100:.4} % ]'
return render_template('prediction.html',
image=filename,
prediction=output_string)
else:
flash('The file type is not allowed')
return redirect(request.url)
def main(req: func.HttpRequest) -> func.HttpResponse:
try:
image_file = req.files['petimage'].stream
except:
return func.HttpResponse("Failed to get image. Check the URL",
status_code=400)
global learn
if learn is None:
learn = load_model.load_fastai()
# fetch image from uploaded file then predict
try:
img = open_image(BytesIO(image_file.read()))
_, _, losses = learn.predict(img)
except Exception as e:
logging.error('predict image failed', exc_info=True)
return func.HttpResponse("Failed to get image. Check the URL",
status_code=400)
res = sorted(zip(learn.data.classes, map(float, losses)),
key=lambda x: x[1],
reverse=True)
result_class = res[0][0]
return func.HttpResponse("Is your image {0} ?".format(result_class),
status_code=200)
def proc_file(f):
im = open_image(os.path.join(path, f))
if dir_qmap is not None:
qmap = learn.predict_quality_map(im, [32, 32])
name = os.path.basename(f).split('.')[0]
qmap.plot()
qmap.savefig(os.path.join(dir_qmap, name + '.jpg'))
score = qmap.global_score
if sz is not None:
height, width = qmap.img.size
new_width = sz # 500
new_height = new_width * height // width
qmap.pil_image.resize(
(new_width, new_height), PIL_Image.ANTIALIAS).save(
os.path.join(dir_qmap, name + '_raw.jpg'))
qmap.blend(mos_range=(None, None)).resize(
(new_width, new_height), PIL_Image.ANTIALIAS).save(
os.path.join(dir_qmap, name + '_map.jpg'))
else:
score = learn.predict(im)[0].obj[0]
del im
del qmap
return score
def handle_cli(self, args, func):
parser = argparse.ArgumentParser()
parser.add_argument("--input", required=True)
parser.add_argument("-o",
"--output",
default="str",
choices=["str", "json", "yaml"])
parsed_args = parser.parse_args(args)
file_path = parsed_args.input
check_file_format(file_path, self.accept_file_extensions)
if not os.path.isabs(file_path):
file_path = os.path.abspath(file_path)
try:
from fastai.vision import open_image, Image
except ImportError:
raise ImportError("fastai package is required to use")
image_array = open_image(
fn=file_path,
convert_mode=self.convert_mode,
div=self.div,
after_open=self.after_open,
cls=self.cls or Image,
)
result = func(image_array)
result = get_output_str(result, output_format=parsed_args.output)
print(result)
def detect(path, model, img_cat_bin):
'''
Detect whether an image or a group of images are resistors or not.
'''
# setting cpu as default for inference
defaults.device = torch.device('cpu')
try:
# load model
learner = load_learner(path='.', file=model)
# open image
img = open_image(path)
except FileNotFoundError as e:
click.echo(e, err=True)
return
click.echo(f'Using model: {model}')
click.echo('Starting prediction for:')
# display image on the shell using imgcat from iterm2
os.system(f'{img_cat_bin} {path}')
# inference
pred_class, pred_index, probs = learner.predict(img)
click.echo(f'Data classes: {learner.data.classes} ')
click.echo(f'prediction: {pred_class} ')
click.echo(f'prediction index: {pred_index} ')
click.echo(f'Probabilities: {probs}')
async def main(req: func.HttpRequest) -> func.HttpResponse:
logging.info('Start my function')
# fetch image from form data
try:
url = req.form['url']
except:
logging.error('Customer didn\'t pass URL', exc_info=True)
return func.HttpResponse("Please pass URL for Prediction",
status_code=400)
# load model as global to cache
global learn
if learn is None:
learn = load_model.load_fastai()
# fetch image from URL then predict
try:
image = await utility.get_bytes(url)
img = open_image(BytesIO(image))
_, _, losses = learn.predict(img)
except Exception as e:
logging.error('predict image failed', exc_info=True)
return func.HttpResponse("Failed to get image. Check the URL",
status_code=400)
res = sorted(zip(learn.data.classes, map(float, losses)),
key=lambda x: x[1],
reverse=True)
result_class = res[0][0]
return func.HttpResponse("Is your image {0} ?".format(result_class),
status_code=200)
def get_image_by_url(url):
""" Load img from url and save to path/filename locally """
resp = requests.get(url)
if resp.status_code == 200:
# need convert to RGB to save in .jpeg further
return open_image(BytesIO(resp.content))
async def classify_url(request):
bytes = await get_bytes(request.query_params["url"])
img = open_image(BytesIO(bytes))
_, _, losses = learner.predict(img)
return JSONResponse({
"predictions": sorted(zip(learner.data.classes, map(float, losses)), key=lambda p: p[1], reverse=True)
})
def test_model_to_learner(tmp):
model = models.resnet18
# Test if the function loads an ImageNet model (ResNet) trainer
learn = model_to_learner(model(pretrained=True))
assert len(learn.data.classes) == 1000 # Check Image net classes
assert isinstance(learn.model, models.ResNet)
# Test if model can predict very simple image
IM_URL = "https://cvbp.blob.core.windows.net/public/images/cvbp_cup.jpg"
imagefile = os.path.join(tmp, "cvbp_cup.jpg")
urllib.request.urlretrieve(IM_URL, imagefile)
category, ind, predict_output = learn.predict(
open_image(imagefile, convert_mode="RGB"))
assert learn.data.classes[ind] == str(category) == "coffee_mug"
# Test if .predict() yield the same output when use .get_preds()
one_data = (
ImageList.from_folder(tmp).split_none().label_const(
) # cannot use label_empty because of fastai bug: # https://github.com/fastai/fastai/issues/1908
.transform(
tfms=None,
size=IMAGENET_IM_SIZE).databunch(bs=1).normalize(imagenet_stats))
learn.data.train_dl = one_data.train_dl
get_preds_output = learn.get_preds(ds_type=DatasetType.Train)
assert np.all(
np.isclose(
np.array(get_preds_output[0].tolist()
[0]), # Note, get_preds() produces a batch (list) output
np.array(predict_output.tolist()),
rtol=1e-05,
atol=1e-08,
))
def UploadPhoto(request):
image_object = Image()
context = {}
uploaded = False
learn = load_learner('classifier')
if request.method == "POST":
form = PictureForm(request.POST, request.FILES, instance=image_object)
if form.is_valid():
image_object = form.save(commit=False)
image_object.save()
uploaded = True
context['image_url'] = image_object.image.url
image = request.FILES['image']
# image = PIL.Image.open(image)
image = open_image(image)
prediction = learn.predict(image)
print(prediction)
context['prediction'] = prediction[0]
form = PictureForm(instance=image_object)
context['form'] = form
context['uploaded'] = uploaded
return render(request,
template_name='classifier/photo_upload.html',
context=context)
def index(request):
result = False
if request.method == 'POST' and request.FILES:
x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
if x_forwarded_for:
ip = x_forwarded_for.split(',')[0]
else:
ip = request.META.get('REMOTE_ADDR')
form = MainForm({'ip': ip}, request.FILES)
if form.is_valid():
model = form.save()
img = open_image(settings.BASE_DIR + model.photo.url)
learn = load_learner(os.path.join(settings.BASE_DIR, 'fastai'))
pred_class, pred_idx, outputs = learn.predict(img)
scores = sorted(zip(classes, outputs.data.tolist()),
key=lambda kv: kv[1],
reverse=True)
model.scores = dict(scores)
model.save(update_fields=["scores"])
result = list(scores[0]) + [_(scores[0][0])]
print(result)
else:
form = MainForm()
return render(request, 'web/index.html', {
'form': form,
'result': result,
'labels': labels
})
def get_preds(img_path):
img = open_image(img_path)
_, _, losses = self.LEARNER.predict(img)
return [
x
for x in zip(self.LEARNER.data.classes, map(float, losses))
if x[0] in self.LABELS
]
def predict_single(img_file):
'''function to take image and return prediction'''
logging.debug('Funcao para pegar uma imagem e retornar a prediction')
prediction = learn.predict(open_image(img_file))
probs_list = prediction
logging.debug('Antes da lista de probabilidades')
return probs_list
async def analyze(request):
data = await request.form()
img_bytes = await (data['file'].read())
img = open_image(BytesIO(img_bytes))
prediction = learn.predict(img)[0]
return JSONResponse({'result': str(prediction)})
