def predict(self):
print(self.file)
if not self.file and os.path.isfile(self.file):
return 0
tfms = tfms_from_model(
self.arch, self.sz,
aug_tfms=transforms_side_on,
max_zoom=1.1
)
data = ImageClassifierData.from_paths(
self.PATH, tfms=tfms,
bs=self.bs,
num_workers=4
)
learn = ConvLearner.pretrained(
self.arch, data,
precompute=True,
ps=0.5
)
learn.unfreeze()
learn.precompute = False
learn.load(self.MODEL)
image = open_image(self.file)
trn_tfms, val_tfms = tfms_from_model(self.arch, self.sz)
im = val_tfms(image)
preds = learn.predict_array(im[None])
return learn.data.classes[np.argmax(preds)]
def predict_image(path): _, val_tfms = get_tfms() image = val_tfms(open_image(path)) # Load Image using fastai open_image in dataset.py log_preds_single = learn.predict_array(image[None]) # Predict Image max_prob_index = np.argmax(log_preds_single, axis=1)[0] # Pick the index with highest log probability probs = np.exp(log_preds_single)[0] # Get an array of probabilities for the classes probs_by_class = dict(zip(data.classes, probs.tolist())) # Create a dictionary of class: probability predicted_class = data.classes[max_prob_index] # Get predicted class return ( predicted_class, probs_by_class ) # Return a tuple because reasons, TODO: refactor
def _get_transformed_image_ndarray(self, path:Path, render_factor:int=None):
orig_image = open_image(str(path))
filtered_image = orig_image
render_factor = self.render_factor if render_factor is None else render_factor
for filt in self.filters:
filtered_image = filt.filter(orig_image, filtered_image, render_factor=render_factor)
return filtered_image
def _get_model_ready_image_ndarray(self,
path: Path,
model: nn.Module,
sz: int = None,
tfms: [Transform] = []):
im = open_image(str(path))
sz = self.default_sz if sz is None else sz
im = scale_min(im, sz)
im = self._transform(im, tfms, model, sz)
return im
def frame_transformed_image(self,
path: str,
figsize: (int, int) = (20, 20),
render_factor: int = None) -> ndarray:
path = Path(path)
result = self._get_transformed_image_ndarray(path, render_factor)
orig = open_image(str(path))
if self.results_dir is not None:
self._save_result_image(path, result)
def plot_transformed_image(self, path:str, figsize:(int,int)=(20,20), render_factor:int=None)->ndarray:
path = Path(path)
result = self._get_transformed_image_ndarray(path, render_factor)
orig = open_image(str(path))
fig,axes = plt.subplots(1, 2, figsize=figsize)
self._plot_image_from_ndarray(orig, axes=axes[0], figsize=figsize)
self._plot_image_from_ndarray(result, axes=axes[1], figsize=figsize)
if self.results_dir is not None:
self._save_result_image(path, result)
def plot_transformed_image(self, path:Path, model:nn.Module, figsize:(int,int)=(20,20), sz:int=None,
tfms:[Transform]=[], compare:bool=True):
result = self.get_transformed_image_ndarray(path, model, sz, tfms=tfms)
if compare:
orig = open_image(str(path))
fig,axes = plt.subplots(1, 2, figsize=figsize)
self.plot_image_from_ndarray(orig, axes=axes[0], figsize=figsize)
self.plot_image_from_ndarray(result, axes=axes[1], figsize=figsize)
else:
self.plot_image_from_ndarray(result, figsize=figsize)
def show_image(fn_or_ary, cats=None, bbs=None, ax=None, figsize=None):
im = fn_or_ary if isinstance(fn_or_ary,
np.ndarray) else open_image(fn_or_ary)
ax = show_im(im, figsize, ax)
if bbs is None: bbs = []
elif not isinstance(bbs[0], (list, np.ndarray)): bbs = [bbs]
if cats is not None and not isinstance(cats, list): cats = [cats]
for i, bb in enumerate(bbs):
draw_rect(ax, bb)
if cats is not None: draw_text(ax, bb[:2], cats[i])
def _get_transformed_image_ndarray(self,
path: Path,
render_factor: int = None):
orig = open_image(str(path))
result = orig
render_factor = self.render_factor if render_factor is None else render_factor
for filt in self.filters:
result = filt.filter(result, render_factor=render_factor)
return result
def plot_segmentation_df(df, path, n=100, size=(20, 20), verbose=True):
"""
randomly plot segmentation data
df : dataframe with columns [image id, encoded pixels]
path : image path
"""
img_ids = np.unique(df.iloc[:, 0])
img_ids = np.random.choice(img_ids, n, replace=False)
for i, img_id in enumerate(img_ids):
rles = df[df.iloc[:, 0] == img_id].iloc[:, 1].values
img = open_image(path / img_id)
masks = sum([rle_decode(rle, img.shape[:2]) for rle in rles])
show_img_masks(img, masks, size=size, axes=None)
plt.close()
def plot_transformed_image(self,
path: str,
model: nn.Module,
figsize: (int, int) = (20, 20),
sz: int = None,
tfms: [Transform] = []) -> ndarray:
path = Path(path)
result = self.get_transformed_image_ndarray(path, model, sz, tfms=tfms)
orig = open_image(str(path))
fig, axes = plt.subplots(1, 2, figsize=figsize)
self._plot_image_from_ndarray(orig, axes=axes[0], figsize=figsize)
self._plot_image_from_ndarray(result, axes=axes[1], figsize=figsize)
if self.results_dir is not None:
self._save_result_image(path, result)
def predictscore(self, filename):
image = Variable(torch.Tensor(self.val_tfms(open_image(filename))[None]).cuda())
pred = self.model(image).data.cpu().numpy()
idx = np.argmax(pred, axis=-1)[0]
probs = np.exp(pred) # probabilities
if self.verbose:
print("pred")
print(pred)
print("argmax")
print(np.argmax(pred, axis=-1))
print(pred[0][idx])
print(probs)
return (idx == 1, probs[0][idx])
def plot_batch(path, model, dl, fnames, n=5):
"""
Plot first n batch predictions
path : data path
model : model
dl: dataloader
fnames: filenames like path/fnames[i]
"""
for i, (*x, y) in enumerate(dl):
bs = len(y)
out = model(Variable(*x))
out_np = to_np(out)
batch_fnames = fnames[bs * i:bs * (i + 1)]
for fname, out in zip(batch_fnames, out_np):
im = open_image(path / fname)
mask = (sigmoid(out.squeeze(0)) > 0.5).astype("uint8")
mask = cv2.resize(mask, (768, 768))
show_img_masks(im, mask)
plt.close()
if i + 1 == n: break
def predict(self, filename):
image = Variable(
torch.Tensor(self.val_tfms(open_image(filename))[None]))
pred = self.model(image).data.numpy()
return (np.argmax(pred, axis=-1)[0] == 1)
def is_food_onimage(self, image):
im = self.val_tfms(open_image(f'{image}'))
log_pred = self.learn.predict_array(im[None])
probs = np.exp(log_pred[:, 1])
return probs[0]
def __getitem__(self, i):
img_id = self.data[i][0]
img = open_image(os.path.join(self.PATH, self.IMAGES_FOLDER, img_id + '.png'))
y = self.data[i][1:].astype(np.float32)
return self.transform(img, y)
def get_y(self, i):
return open_image(os.path.join(self.path, self.y[i]))
def default_image_loader(path):
#return PIL.Image.open(path).convert('RGB')
return open_image(path)
def get_x(self, i):
return open_image(os.path.join(self.path, self.fnames[i]))
