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]))