def __init__(self, learner, input_type=None, output_type=None): self.learn = load_learner(learner) # get input type if input_type == None: if 'TextLearner' in str(type(self.learn)): self.input_type = 'text' else: self.input_type = 'image' else: self.input_type == input_type # get output type if output_type == None: loss_func = str(type(self.learn.loss_func)) if 'CrossEntropy' in loss_func: self.output_type = 'class' elif 'BCEWithLogits' in loss_func: self.output_type = 'label' elif 'MSELoss' in loss_func: self.output_type = 'reg' else: print('no output_type defined!') else: self.output_type = output_type print( f'learner initialized! input: {self.input_type}, output: {self.output_type}' )
def experiment_2b_inference(): #learn = cnn_learner(dls, resnet18, metrics=[acc uracy]) learn = load_learner("30_export.pkl") cats = create_image_array_from_directory_path( "datasets/cat_dog/cat_dog_test_set/dogs") dl = learn.dls.test_dl(cats) op = learn.get_preds(dl=dl) print(op)
def load(cls, path: str, reset_paths=True, verbose=True): from fastai.learner import load_learner model = super().load(path, reset_paths=reset_paths, verbose=verbose) if model._load_model: model.model = load_pkl.load_with_fn( f'{model.path}{model.model_internals_file_name}', lambda p: load_learner(p), verbose=verbose) model._load_model = None return model
def __call__(self, img): if not self.loaded: self.model = load_learner(self.model_path, cpu=False) self.loaded = True original_size = (img.shape[1], img.shape[0]) mask = expand_mask(road_preds(self.model.predict(img))) masked_img = hide_non_road(img, mask) return masked_img
async def setup_learner(): await download_file(export_file_url, path / export_file_name) try: learn = load_learner(path / export_file_name) return learn except RuntimeError as e: if len(e.args) > 0 and 'CPU-only machine' in e.args[0]: print(e) message = "\n\nThis model was trained with an old version of fastai and will not work in a CPU environment.\n\nPlease update the fastai library in your training environment and export your model again.\n\nSee instructions for 'Returning to work' at https://course.fast.ai." raise RuntimeError(message) else: raise
class EmojiClassifier: def __init__(self): self.MODEL_PATH = "model.pkl" self.model_origin = self.MODEL_PATH if (MODEL_S3_PATH := os.environ.get("MODEL_S3_PATH")) : self.MODEL_S3_PATH = MODEL_S3_PATH self.model_origin = self.MODEL_S3_PATH print(f"Fetching model from: {self.MODEL_S3_PATH}") client.download_file( os.getenv("SPACE_NAME"), self.MODEL_S3_PATH, self.MODEL_PATH ) print(f"Loading model: {self.MODEL_PATH}") self.learn = load_learner(self.MODEL_PATH) self.labels = self.learn.dls.vocab[1]
def get_dog_details(self, img): """Use pre trained model and get dog details.""" if os.path.exists(model_path): logger.info("Invoking Model:" + model_path) learn_inference = load_learner(model_path) logger.info("Running Predictor...") img = PILImage.create(img) pred, pred_idx, probs = learn_inference.predict(img) logger.info('Predicted Result:' + str(pred)) return { 'success': True, 'pred': str(pred), # 'pred_idx': pred_idx, # 'probs': probs } else: logger.debug("Model not found:" + model_path) return {'success': False, 'message': 'Apologies. Model not found'}
def from_pretrained_fastai( repo_id: str, revision: Optional[str] = None, ): """ Load pretrained fastai model from the Hub or from a local directory. Args: repo_id (`str`): The location where the pickled fastai.Learner is. It can be either of the two: - Hosted on the Hugging Face Hub. E.g.: 'espejelomar/fatai-pet-breeds-classification' or 'distilgpt2'. You can add a `revision` by appending `@` at the end of `repo_id`. E.g.: `dbmdz/bert-base-german-cased@main`. Revision is the specific model version to use. Since we use a git-based system for storing models and other artifacts on the Hugging Face Hub, it can be a branch name, a tag name, or a commit id. - Hosted locally. `repo_id` would be a directory containing the pickle and a pyproject.toml indicating the fastai and fastcore versions used to build the `fastai.Learner`. E.g.: `./my_model_directory/`. revision (`str`, *optional*): Revision at which the repo's files are downloaded. See documentation of `snapshot_download`. Returns: The `fastai.Learner` model in the `repo_id` repo. """ _check_fastai_fastcore_versions() # Load the `repo_id` repo. # `snapshot_download` returns the folder where the model was stored. # `cache_dir` will be the default '/root/.cache/huggingface/hub' if not os.path.isdir(repo_id): storage_folder = snapshot_download( repo_id=repo_id, revision=revision, library_name="fastai", library_version=get_fastai_version(), ) else: storage_folder = repo_id _check_fastai_fastcore_pyproject_versions(storage_folder) from fastai.learner import load_learner return load_learner(os.path.join(storage_folder, "model.pkl"))
def bart2(filename, number, y, str): from fastai.learner import load_learner import torch import pickle import datasets import re import pathlib temp = pathlib.PosixPath pathlib.PosixPath = pathlib.WindowsPath inf_learn = load_learner(fname='./data/bart_pretrained_SAMsum.pkl') with open( "./static/text_files/{}".format( filename.replace('.txt', '_dr_sum_file.txt')), 'w') as f: f.write(str + "\n") num = 0 s = '' llist = [] for i in range(len(y)): s = s + y[i] if num == number: llist.append(s) num = 0 s = '' num += 1 ll = [] for i in llist: tt = inf_learn.blurr_generate(i) a = tt.pop() a = a.strip() # a1 = re.sub(r'\([^)]*\)', '', a) ll.append(a) print(a) for i in ll: f.write(i + "\n") return
def _load_model(path): from fastai.learner import load_learner return load_learner(os.path.abspath(path))
def __init__(self, model_path): self.model = load_learner(model_path)
def load_model(): return load_learner(current_folder / "instrument_classifier.pkl")
def load_model(): """Load model from file.""" path = Path(os.path.realpath(__file__)).resolve().parent.parent path = path / "models/model.pkl" learner = load_learner(path, cpu=True) return learner
def load_all(path='export', dls_fname='dls', model_fname='model', learner_fname='learner', device=None, pickle_module=pickle, verbose=False): if isinstance(device, int): device = torch.device('cuda', device) elif device is None: device = default_device() if device == 'cpu': cpu = True else: cpu = None path = Path(path) learn = load_learner(path / f'{learner_fname}.pkl', cpu=cpu, pickle_module=pickle_module) learn.load(f'{model_fname}', with_opt=True, device=device) if learn.dls_type == "MixedDataLoaders": from .data.mixed import MixedDataLoader, MixedDataLoaders dls_fnames = [] _dls = [] for i in range(learn.n_loaders[0]): _dl = [] for j in range(learn.n_loaders[1]): l = torch.load(path / f'{dls_fname}_{i}_{j}.pth', map_location=device, pickle_module=pickle_module) l = l.new(num_workers=0) l.to(device) dls_fnames.append(f'{dls_fname}_{i}_{j}.pth') _dl.append(l) _dls.append( MixedDataLoader(*_dl, path=learn.dls.path, device=device, shuffle=l.shuffle)) learn.dls = MixedDataLoaders(*_dls, path=learn.dls.path, device=device) else: loaders = [] dls_fnames = [] for i in range(learn.n_loaders): dl = torch.load(path / f'{dls_fname}_{i}.pth', map_location=device, pickle_module=pickle_module) dl = dl.new(num_workers=0) dl.to(device) first(dl) loaders.append(dl) dls_fnames.append(f'{dls_fname}_{i}.pth') learn.dls = type(learn.dls)(*loaders, path=learn.dls.path, device=device) pv(f'Learner loaded:', verbose) pv(f"path = '{path}'", verbose) pv(f"dls_fname = '{dls_fnames}'", verbose) pv(f"model_fname = '{model_fname}.pth'", verbose) pv(f"learner_fname = '{learner_fname}.pkl'", verbose) return learn
st.markdown( f""" <style> .reportview-container .main .block-container{{ {max_width_str} }} </style> """, unsafe_allow_html=True, ) _max_width_() model_path = Path("bart_tldr.pkl") # @st.cache(max_entries=3) def load_model(path): return load_learner(path) tech_doc = st.text_area( label="Man Page Entry", value="Pls enter technical document you want to summarize", height=500, ) model = load_learner(fname=model_path) st.markdown(f"### Summary:\n\n{model.blurr_summarize(tech_doc)[0]}")
def load_model(path): return load_learner(path)
def __init__(self, model): self.inf = load_learner(model)
return Image.open(image) def predict_img(img): ''' Pass PILImage object Return prediction[str], prediction_idx[int], probability[tensor] ''' if img is not None: return learner_inf.predict(pil_img) '## COVID-19 Mask Classifier' "Here's the [GitHub](https://github.com/jacKlinc/covid_mask_classifier) repo" 'Upload a picture of someone' learner_inf = load_learner('./covid_mask.pkl') # Upload pic = st.file_uploader("Upload Files") 'Click Classify to find out if there wearing a mask' probs = [] pred_idx = 1 pred = 'n/a' # Display image if pic is not None: img = load_image(pic) st.image(img)
def predict_img(img): ''' Pass PILImage object Return prediction[str], prediction_idx[int], probability[tensor] ''' if img is not None: return learner_inf.predict(pil_img) '## German Character Recogniser' "Here's the [GitHub](https://github.com/jacKlinc/german_char_recogniser) repo" 'Upload a picture of a vowel' learner_inf = load_learner('./res/AEIOU_model.pkl') # Upload pic = st.file_uploader("Upload Image") 'Click Classify to find whether it\'s an A or a B' probs = [] pred_idx = 1 pred = 'n/a' # Display image if pic is not None: img = load_image(pic) st.image(img)
def load_model(self, results_path="results", model_name=None, cpu=True): self.learn = load_learner(fname=os.path.join(results_path, model_name), cpu=cpu) # can unfreeze the model and fine_tune self.learn.unfreeze() return self
from flask import request, redirect, render_template from fastai.learner import load_learner import pathlib from fastai.vision.core import PILImage import platform application = Flask(__name__) application.config['MAX_CONTENT_LENGTH'] = 2 * 1024 * 1024 # Workaround pytorch issue with models developed on linux being used on Windows if platform.system() == 'Windows': pathlib.PosixPath = pathlib.WindowsPath ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif'} learn_inf = load_learner('export.pkl', cpu=True) def allowed_file(filename): return '.' in filename and filename.rsplit( '.', 1)[1].lower() in ALLOWED_EXTENSIONS @application.route("/upload-image/", methods=["GET", "POST"]) def upload_image(): if request.method == "POST": if request.files: image = request.files["image"] if allowed_file(image.filename): pred, pred_idx, probs = learn_inf.predict( PILImage.create(image))
import fastai from fastai.imports import * from fastai.learner import load_learner # from fastai.vision.widgets import * from fastai.vision.core import PILImage from flask import Flask, request, render_template import os import glob from flask import send_file path = Path() print(path.ls(file_exts='.pkl')) learn_inf = load_learner(path / 'export.pkl') app = Flask(__name__) #Defining the home page for the web service # @app.route('/') # def home(): # return f"<h1>{predict}</h1>" # UPLOAD_FOLDER = './upload' UPLOAD_FOLDER = os.path.join('static', 'upload') app = Flask(__name__, static_folder=os.path.abspath('static')) app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER def clear_contents(): files = glob.glob(UPLOAD_FOLDER) for f in files: os.remove(f)
def get_mask_detection_learner(): learner = load_learner(MASK_DETECTION_MODEL_PATH) return learner
def get_model(): if not os.path.isfile(MODEL_FILE): _ = download_file(f'{REPO_DIR}/models/{MODEL_FILE}') learn = load_learner(MODEL_FILE) return learn
def __init__(self, path): self.learn = load_learner(path) classes = self.learn.dls.vocab
import numpy as np import pandas as pd from fastai.learner import load_learner import plotly.express as px import dash from dash.dependencies import Input, Output, State import dash_core_components as dcc import dash_html_components as html external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css'] app = dash.Dash(__name__, external_stylesheets=external_stylesheets) server = app.server learn = load_learner('resnet50_v2.pkl') classes = learn.dls.vocab app.layout = html.Div([ html.Div([ html.H2('Airliners classifier'), html.H6([ 'Welcome to aircraft photos classifier. This application is expected to recognize an airliner based on uploaded image.', html.Br(), 'Currently it supports the following planes:' ]), html.Div(str(classes)) ], style={'textAlign': 'center'}), dcc.Upload(id='upload-image', children=html.Div(['Drag and Drop or ', html.A('Select Files')]),
from io import BytesIO from PIL import Image import torch import torchvision.transforms.functional as F import pathlib temp = pathlib.PosixPath pathlib.PosixPath = pathlib.WindowsPath # folder_path = 'C:/Users/SHREYAS/Desktop/Fabric Project/Final/fabrixx/fabrix/models/export.pkl' # folder_path_fault = 'C:/Users/SHREYAS/Desktop/Fabric Project/Final/fabrixx/fabrix/models/fault.pkl' folder_path = 'fabrix/models/export.pkl' folder_path_fault = 'fabrix/models/fault.pkl' learn = load_learner(folder_path) classes = ['Defective', 'Non Defective'] learn_fault = load_learner(folder_path_fault) classes_fault = [ 'Foreign Bodies on Tissue', 'Holes and Cuts', 'Oil Stains', 'Thread Error' ] # import numpy as np # import traceback # import pickle # import pandas as pd # with open('./fabrix/models/Fast_ai.pkl', 'rb') as f: # learn = pickle.load(f) # classes = learn.data.classes
# %% model_file_path = config.model_dir_path / "cats-vs-dogs.pth" # %% if session.is_interactive: learner.dls.show_batch() learner.show_results() # %% if session.is_interactive: learner.export(model_file_path) # %% if session.is_interactive: loaded_learner = load_learner(model_file_path) # %% class AnimalType(str, Enum): cat = "cat" dog = "dog" # %% def classify(image: PILImage, learner: Learner) -> Tuple[AnimalType, float]: with learner.no_bar(): results = learner.predict(image) _, category, probabilities = results is_a_cat = category == 1 animal_type = AnimalType.cat if is_a_cat else AnimalType.dog
def predict_segmentation(path_to_model: str, path_to_image: str, outfile: str, processing_dir: str = 'temp', tile_size: int = 400, tile_overlap: int = 100, use_tta: bool = True): """Segment image into land cover classes with a pretrained models TODO save also information about label and class TODO add test-time augmentations""" if os.path.exists(processing_dir): print('Processing folder exists') return os.makedirs(processing_dir) print( f'Reading and tiling {path_to_image} to {tile_size}x{tile_size} tiles with overlap of {tile_overlap}px' ) tiler = Tiler(outpath=processing_dir, gridsize_x=int(tile_size), gridsize_y=int(tile_size), overlap=(int(tile_overlap), int(tile_overlap))) tiler.tile_raster(path_to_image) # Check whether is possible to use gpu cpu = True if not torch.cuda.is_available() else False # Loading pretrained model # PyTorch state dict TODO if path_to_model.endswith('.pth') or path_to_model.endswith('.pt'): print('Using PyTorch state dict not yet supported') print('Removing intermediate files') rmtree(processing_dir) return # fastai learn.export() elif path_to_model.endswith('.pkl'): learn = load_learner(path_to_model, cpu=cpu) test_files = get_image_files(f'{processing_dir}/raster_tiles') print('Starting prediction') os.makedirs(f'{processing_dir}/predicted_rasters') # Works with chunks of 300 patches for chunk in range(0, len(test_files), 300): test_dl = learn.dls.test_dl(test_files[chunk:chunk + 300], num_workers=0, bs=1) test_dl.set_base_transforms() if use_tta: batch_tfms = [Dihedral()] item_tfms = [ToTensor(), IntToFloatTensor()] preds = learn.tta(dl=test_dl, batch_tfms=batch_tfms)[0] else: preds = learn.get_preds(dl=test_dl, with_input=False, with_decoded=False)[0] print('Rasterizing predictions') for f, p in tqdm(zip(test_files[chunk:chunk + 300], preds)): #if len(p.shape) == 3: p = p[0] ds = gdal.Open(str(f)) out_raster = gdal.GetDriverByName('gtiff').Create( f'{processing_dir}/predicted_rasters/{f.stem}.{f.suffix}', ds.RasterXSize, ds.RasterYSize, p.shape[0], gdal.GDT_Int16) out_raster.SetProjection(ds.GetProjectionRef()) out_raster.SetGeoTransform(ds.GetGeoTransform()) np_pred = p.numpy() #.argmax(axis=0) np_pred = np_pred.round(2) np_pred *= 100 np_pred = np_pred.astype(np.int16) for c in range(p.shape[0]): band = out_raster.GetRasterBand(c + 1).WriteArray( np_pred[c]) band = None #band = out_raster.GetRasterBand(1).WriteArray(np_pred) out_raster = None ds = None print('Merging predictions') temp_full = f'{processing_dir}/full_raster.tif' untile_raster(f'{processing_dir}/predicted_rasters', outfile=temp_full, method='sum') print('Postprocessing predictions') raw_raster = gdal.Open(temp_full) processed_raster = gdal.GetDriverByName('gtiff').Create( outfile, raw_raster.RasterXSize, raw_raster.RasterYSize, 1, gdal.GDT_Int16) processed_raster.SetProjection(raw_raster.GetProjectionRef()) processed_raster.SetGeoTransform(raw_raster.GetGeoTransform()) raw_np = raw_raster.ReadAsArray() pred_np = raw_np.argmax(axis=0) band = processed_raster.GetRasterBand(1).WriteArray(pred_np) raw_raster = None band = None processed_raster = None print('Removing intermediate files') rmtree(processing_dir) return