def load_checkpoints(self, checkpoint_paths, models): """ Either loads a single checkpoint or loads an ensemble of checkpoints from `checkpoint_paths` """ assert isinstance(checkpoint_paths, list), \ "Make sure checkpoint_paths is specified in list format in the\ yaml file." assert isinstance(models, list), \ "Make sure model_names is specified in list format in the\ yaml file." assert len(checkpoint_paths) == len(models), \ "The number of checkpoints and models should be the same." # single model instances if len(checkpoint_paths) == 1: try: # loading traceable self.model = load(checkpoint_paths[0]).cuda().eval() print(f"Traced model from {checkpoint_paths}") except: self.model = load_weights_infer(checkpoint_paths[0], models[0]).cuda().eval() print(f"Loaded model from {checkpoint_paths}") # ensembled models elif len(checkpoint_paths) > 1: try: self.model = EnsembleModel( [load(path).cuda().eval() for path in checkpoint_paths]) except: self.model = EnsembleModel([ load_weights_infer(path, model).cuda().eval() for (path, model) in zip(checkpoint_paths, models) ]) print(f"Loaded an ensemble from {checkpoint_paths}")
def runPose(image, boxList, video_name=''): parser = argparse.ArgumentParser( description='''Lightweight human pose estimation python demo. This is just for quick results preview. Please, consider c++ demo for the best performance.''' ) parser.add_argument('--checkpoint-path', type=str, default='openpose.jit', help='path to the checkpoint') parser.add_argument('--height-size', type=int, default=256, help='network input layer height size') parser.add_argument('--video', type=str, default='', help='path to video file or camera id') parser.add_argument('--images', nargs='+', default='./data/test1', help='path to input image(s)') parser.add_argument('--cpu', action='store_true', help='run network inference on cpu') parser.add_argument('--device', default='0', help='cuda device, i.e. 0 or 0,1,2,3 or cpu') parser.add_argument('--code_name', type=str, default='None', help='the name of video') # parser.add_argument('--track', type=int, default=0, help='track pose id in video') # parser.add_argument('--smooth', type=int, default=1, help='smooth pose keypoints') args = parser.parse_args() args.images = image if video_name != '': args.code_name = video_name if args.video == '' and args.images == '': raise ValueError('Either --video or --image has to be provided') net = jit.load(r'.\weights\openpose.jit') # ************************************************************************* action_net = jit.load(r'.\action_detect\checkPoint\action.jit') # ************************************************************************ frame_provider = [image] run_demo(net, action_net, frame_provider, args.height_size, args.cpu, boxList)
def detect_main(video_source = '',image_source = '',video_name=''): parser = argparse.ArgumentParser( description='''Lightweight human pose estimation python demo. This is just for quick results preview. Please, consider c++ demo for the best performance.''') parser.add_argument('--checkpoint-path', type=str, default='openpose.jit', help='path to the checkpoint') parser.add_argument('--height-size', type=int, default=256, help='network input layer height size') parser.add_argument('--video', type=str, default='', help='path to video file or camera id') parser.add_argument('--images', nargs='+', default='', help='path to input image(s)') parser.add_argument('--cpu',action='store_true', help='run network inference on cpu') parser.add_argument('--code_name',type=str,default='None',help='the name of video') # parser.add_argument('--track', type=int, default=0, help='track pose id in video') # parser.add_argument('--smooth', type=int, default=1, help='smooth pose keypoints') args = parser.parse_args() args.video = video_source args.images = image_source if video_name != '': args.code_name = video_name if args.video == '' and args.images == '': raise ValueError('Either --video or --image has to be provided') net = jit.load(r'.\weights\openpose.jit') # ************************************************************************* action_net = jit.load(r'.\action_detect\checkPoint\action.jit') # ************************************************************************ frame_provider = ImageReader(args.images) if args.video != '': frame_provider = VideoReader(args.video,args.code_name) # print(frame_provider) else: images_dir = [] if os.path.isdir(args.images): for img_dir in os.listdir(args.images): images_dir.append(os.path.join(args.images, img_dir)) frame_provider = ImageReader(images_dir) else: img = cv2.imread(args.images, cv2.IMREAD_COLOR) frame_provider = [img] # ************************************************************************* # args.track = 0 run_demo(net, action_net, frame_provider, args.height_size, args.cpu)
def load_checkpoints(checkpoint_paths, models): """Loads checkpoints. Either loads a single checkpoint or loads an ensemble of checkpoints from `checkpoint_paths` Args: checkpoint_paths (list[str]): list of paths to checkpoints models (list[torch.nn.Module]): models corresponding to the checkpoint_paths. If it is left as [], the function assumes that the weights are traced (so no models are needed). Returns: model (torch.nn.Module): The single/ensembled model """ assert isinstance(checkpoint_paths, list), \ "Make sure checkpoint_paths is specified in list format in the\ yaml file." assert isinstance(models, list), \ "Make sure model_names is specified in list format in the\ yaml file." if len(models) != 0: assert len(checkpoint_paths) == len(models), \ "The number of checkpoints and models should be the same." # single model instances if len(checkpoint_paths) == 1: try: # loading traceable model = load(checkpoint_paths[0]).cuda().eval() print(f"Traced model from {checkpoint_paths}") except: model = load_weights(checkpoint_paths[0], models[0]).cuda().eval() print(f"Loaded model from {checkpoint_paths}") # ensembled models elif len(checkpoint_paths) > 1: try: model = EnsembleModel( [load(path).cuda().eval() for path in checkpoint_paths]) except: model = EnsembleModel([ load_weights(path, model).cuda().eval() for (path, model) in zip(checkpoint_paths, models) ]) print(f"Loaded an ensemble from {checkpoint_paths}") return model
def load_traced_model( model_path: Union[str, Path], device: Device = "cpu", opt_level: str = None, ) -> ScriptModule: """Loads a traced model. Args: model_path: Path to traced model device (str): Torch device opt_level (str): Apex FP16 init level, optional Returns: (ScriptModule): Traced model """ # jit.load dont work with pathlib.Path model_path = str(model_path) if opt_level is not None: device = "cuda" model = load(model_path, map_location=device) if opt_level is not None: assert_fp16_available() from apex import amp model = amp.initialize(model, optimizers=None, opt_level=opt_level) return model
def _get_torch_script_model(model_path): try: from torch import jit except ImportError: raise MissingDependencyException( '"torch" package is required for inference with ' 'PytorchLightningModelArtifact') return jit.load(model_path)
def load(cls, dirname, model_class=None): if os.path.exists(os.path.join(dirname, cls.JIT_MODEL_NAME)): model = jit.load(os.path.join(dirname, cls.JIT_MODEL_NAME), map_location='cpu') else: assert model_class is not None model = model_class.from_trained(dirname) trainer_states = torch.load(os.path.join(dirname, cls.TRAINER_STATES_NAME), map_location='cpu') return cls(model, trainer_states)
def __init__(self): self.net = load("torch_script_eval.pt") normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) self.transforms = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), normalize, ]) self.category = "airplane airport baseball_diamond basketball_court beach bridge chaparral church circular_farmland cloud commercial_area dense_residential desert forest freeway golf_course ground_track_field harbor industrial_area intersection island lake meadow medium_residential mobile_home_park mountain overpass palace parking_lot railway railway_station rectangular_farmland river roundabout runway sea_ice ship snowberg sparse_residential stadium storage_tank tennis_court terrace thermal_power_station wetland".split( )
def infer(x: Dataset, file: str, batch_size: int = 1, batch_mode: bool = False, use_logistic: bool = True, num_workers: int = 1): loader = DataLoader(x, batch_size=batch_size, shuffle=False, num_workers=num_workers, pin_memory=True) model = load(file).cuda() if batch_mode: return _infer_batch(model, loader, use_logistic=use_logistic) return _infer(model, loader, use_logistic=use_logistic)
def __init__(self, file: str, batch_size: int, batch_mode: bool = False, use_logistic: bool = False, num_workers: int = 1, *args, **kwargs): super().__init__(*args, **kwargs) self.model = load(file).cuda() self.batch_size = batch_size self.use_logistic = use_logistic self.batch_mode = batch_mode self.num_workers = num_workers
def init_model(): """ Load the saved quantized model for inference. """ # Initialize the Model using the saved Quantized Model torch.backends.quantized.engine = 'qnnpack' print('\n\nInitializing Model...') model = jit.load('models/convnet-traced-new.pt', map_location='cpu') print('Model Loaded Successfully') # try: # except Exception as e: # print(e) # print('ERROR: Could not Initialize the Model.') # sys.exit(1) return model
def infer( x: Dataset, file: str, batch_size: int = 1, batch_mode: bool = False, activation=None, num_workers: int = 1, ): loader = DataLoader(x, batch_size=batch_size, shuffle=False, num_workers=num_workers, pin_memory=True) model = load(file).cuda() if batch_mode: return _infer_batch(model, loader, activation=activation) return _infer(model, loader, activation=activation)
def load(path, eval=True): path = Path(path) p = Predictor() # TODO: read from tarfile directly instead if str(path).endswith('.tar.gz'): untar(path) path = Path(str(path).rstrip('.tar.gz')) p.model = None if (path / 'model.th').exists(): p.model = torch.load(str(path / 'model.th')) elif (path / 'model.traced.th').exists(): from torch import jit p.model = jit.load(str(path / 'model.traced.th')) if p.model and eval: p.model.eval() with suppress(FileNotFoundError): p.model_state_dict = torch.load(str(path / 'model.state_dict.th')) with suppress(FileNotFoundError): p.classes = load_json(path / 'classes.json') with suppress(FileNotFoundError): p.preprocess = load_pickle(path / 'preprocess.pkl') with suppress(FileNotFoundError): p.postprocess = load_pickle(path / 'postprocess.pkl') with suppress(FileNotFoundError): p.predict = load_pickle(path / 'predict.pkl') with suppress(FileNotFoundError): p.meta = load_json(path / 'meta.json') with suppress(FileNotFoundError): p.kwargs = load_pickle(path / 'kwargs.pkl') return p
'frame': row.frame, 'path': os.path.join(path_test_dir, row.path) } for _, row in test_dataset_paths.iterrows()] dataset = TestAntispoofDataset(paths=paths) dataloader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=False, num_workers=4) device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') # predict samples, probabilities = [], [] models = [load(x).to(device) for x in glob('*.trcd')] with torch.no_grad(): for video, batch in tqdm(dataloader): batch = batch.to(device) for model in models: proba = torch.softmax(model(batch), dim=1).cpu().numpy() proba = proba[:, :-1].sum(axis=1) samples.extend(video) probabilities.extend(proba) # save predictions = pd.DataFrame.from_dict({ 'id': samples, 'probability': probabilities
def detect(save_img=False): global ip source, weights, view_img, save_txt, imgsz = opt.source, opt.weights, opt.view_img, opt.save_txt, opt.img_size webcam = source.isnumeric() or source.endswith( '.txt') or source.lower().startswith(('rtsp://', 'rtmp://', 'http://')) # Directories save_dir = Path( increment_path(Path(opt.project) / opt.name, exist_ok=opt.exist_ok)) # increment run (save_dir / 'labels' if save_txt else save_dir).mkdir( parents=True, exist_ok=True) # make dir #加载摔倒检测的模型 print("加载摔倒检测的模型开始") net = jit.load(r'.\weights\openpose.jit') action_net = jit.load(r'.\action_detect\checkPoint\action.jit') print("加载摔倒检测的模型结束") # Initialize set_logging() # 获取设备 device = select_device(opt.device) # 如果设备为gpu,使用Float16 half = device.type != 'cpu' # half precision only supported on CUDA half = False # Load model # 加载Float32模型,确保用户设定的输入图片分辨率能整除32(如果不能则调整为能整除并删除) model = attempt_load(weights, map_location=device) # load FP32 model imgsz = check_img_size(imgsz, s=model.stride.max()) # check img_size # 设置Float16 if half: model.half() # to FP16 # Set Dataloader # 通过不同的输入源来设置不同的数据加载方式 vid_path, vid_writer = None, None if webcam: view_img = True cudnn.benchmark = True # set True to speed up constant image size inference dataset = LoadStreams(source, img_size=imgsz) else: save_img = True # 如果检测视频的时候想显示出来,可以再这里加一行 view_img = True view_img = True dataset = LoadImages(source, img_size=imgsz) # Get names and colors # 获取类别的名字 names = model.module.names if hasattr(model, 'module') else model.names # 设置画框的颜色 colors = [[random.randint(0, 255) for _ in range(3)] for _ in names] # Run inference t0 = time.time() # 进行一次向前推理,测试程序是否正常 img = torch.zeros((1, 3, imgsz, imgsz), device=device) # init img _ = model(img.half() if half else img ) if device.type != 'cpu' else None # run once """ path 图片/视频路径 img 进行resize+pad之后的图片 img0 原size图片 cap 当读取图片时为None,读取视频时为视频源 """ for path, img, im0s, vid_cap in dataset: img = torch.from_numpy(img).to(device) # 图片也设置为Float16 img = img.half() if half else img.float() # uint8 to fp16/32 img /= 255.0 # 0 - 255 to 0.0 - 1.0 # 没有batch_size 的话则在最前面增加一个轴 if img.ndimension() == 3: img = img.unsqueeze(0) # Inference t1 = time_synchronized() """ 前向传播 返回pred的shape是(1, num_boxes, 5+num_class) h,w为传入网络图片的长和宽,注意dataset在检测时使用了矩形推理,所以这里h不一定等于w num_boxes = h/32 * w/32 + h/16 * w/16 + h/8 * w/8 pred[..., 0:4]为预测框坐标 预测框坐标为xywh(中心点+宽长)格式 pred[..., 4]为objectness置信度 pred[..., 5:-1]为分类结果 """ pred = model(img, augment=opt.augment)[0] # Apply NMS """ pred:前向传播的输出 conf_thres:置信度阈值 iou_thres:iou阈值 classes:是否只保留特定的类别 agnostic:进行nms是否也去除不同类别之间的框 经过nms之后,预测框格式:xywh-->xyxy(左上角右下角) pred是一个列表list[torch.tensor],长度为batch_size 每一个torch.tensor的shape为(num_boxes, 6),内容为box+conf+cls """ pred = non_max_suppression(pred, opt.conf_thres, opt.iou_thres, classes=opt.classes, agnostic=opt.agnostic_nms) t2 = time_synchronized() # Apply Classifier # 添加二次分类,默认不适用 # if classify: # pred = apply_classifier(pred, modelc, img, im0s) # Process detections # 对每一张图片作处理 for i, det in enumerate(pred): # detections per image # 如果输入源是webcam 则batch_size 不为1,取出dataset中的一张图片 if webcam: # batch_size >= 1 p, s, im0, frame = path[i], '%g: ' % i, im0s[i].copy( ), dataset.count else: p, s, im0, frame = path, '', im0s, getattr(dataset, 'frame', 0) # print(det) boxList = [] # 框的一个list 给openpose 使用 p = Path(p) # to Path # 设置保存图片/视频的路径 save_path = str(save_dir / p.name) # img.jpg # 设置保存框最薄txt文件的路径 txt_path = str(save_dir / 'labels' / p.stem) + ( '' if dataset.mode == 'image' else f'_{frame}') # img.txt # 设置打印信息(图片长宽) s += '%gx%g ' % img.shape[2:] # print string gn = torch.tensor(im0.shape)[[1, 0, 1, 0]] # normalization gain whwh if len(det): # Rescale boxes from img_size to im0 size # 调整预测框的坐标:基于resize+pad的图片的坐标 -->基于原size图片的坐标 # 此时坐标格式为xyxy det[:, :4] = scale_coords(img.shape[2:], det[:, :4], im0.shape).round() # Print results # 打印检测到的类别数量 for c in det[:, -1].unique(): n = (det[:, -1] == c).sum() # detections per class s += f'{n} {names[int(c)]}s, ' # add to string # Write results # 保存预测结果 for *xyxy, conf, cls in reversed(det): if save_txt: # Write to file # 将xyxy(左上角+右下角)格式转为xywh(中心点+宽长)格式,并除上w,h做归一化,转化为列表再保存 xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist() # normalized xywh line = (cls, *xywh, conf) if opt.save_conf else ( cls, *xywh) # label format with open(txt_path + '.txt', 'a') as f: f.write(('%g ' * len(line)).rstrip() % line + '\n') # 在原图上画框 if save_img or view_img: # Add bbox to image label = f'{names[int(cls)]} {conf:.2f}' plot_one_box(xyxy, im0, label=label, color=colors[int(cls)], line_thickness=3) boxList.append([ int(xyxy[0]), int(xyxy[1]), int(xyxy[2]), int(xyxy[3]) ]) print(boxList) for box in boxList: c1, c2 = (int(box[0]), int(box[1])), (int(box[2]), int(box[3])) x = c2[0] - c1[0] y = c2[1] - c1[1] if x / y >= 0.8: # 比例>0.8 可能会是摔倒 print('进行人体姿态检测') runOpenpose.run_demo( net, action_net, im0, 256, True, boxList) # 人体姿态检测 将图片和yolov5检测人体的框也传给openpose break # Print time (inference + NMS) # 打印向前传播+nms时间 print(f'{s}Done. ({t2 - t1:.3f}s)') if save_img: if dataset.mode == 'image': imageName = str( time.strftime('%Y%m%d%H%M%S', time.localtime(time.time()))) + ".jpg" imagePath = r"/photo/ism_uniform/" + str(ip) + "/" + str( datetime.datetime.now().strftime("%Y-%m-%d")) + "/" if not os.path.exists(r"/photo/ism_uniform/" + str(ip) + "/"): os.makedirs(r"/photo/ism_uniform/" + str(ip) + "/") if not os.path.exists( r"/photo/ism_uniform/" + str(ip) + "/" + "/" + str(datetime.datetime.now().strftime("%Y-%m-%d"))): os.makedirs( r"/photo/ism_uniform/" + str(ip) + "/" + "/" + str(datetime.datetime.now().strftime("%Y-%m-%d"))) cv2.imwrite(imagePath + imageName, im0) else: # 'video' if vid_path != save_path: # new video vid_path = save_path if isinstance(vid_writer, cv2.VideoWriter): vid_writer.release( ) # release previous video writer fourcc = 'mp4v' # output video codec fps = vid_cap.get(cv2.CAP_PROP_FPS) w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH)) h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) vid_writer = cv2.VideoWriter( save_path, cv2.VideoWriter_fourcc(*fourcc), fps, (w, h)) vid_writer.write(im0) print('保存图片') # 打印总时间 print(f'Done. ({time.time() - t0:.3f}s)')
) parser.add_argument("image", type=str, help="path of signature image") parser.add_argument( "--scan", dest="scan", action="store_true", default=False, help="add a scan filter to image while processing (default: False)") args = parser.parse_args() # Image Transformations transform = transforms.Compose([ transforms.Resize((256, 256)), # transforms.RandomVerticalFlip(), transforms.ToTensor(), transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]), ]) # Loading Jitted Model model = torchjit.load("modeljit.pth") model.eval() # Making Predictions classes = ["fake", "real"] img = processimage(args.image, scan=args.scan) img = transform(img).float().unsqueeze(0) output = model(img) index = output.data.numpy().argmax() print(classes[index])
import PIL.Image import json from IPython.display import Image, display with open('./imagenet_classes.json', mode='rt') as f: CLASS_DICT = json.load(f) IMAGENET_MEAN = np.array([[[0.485, 0.456, 0.406]]], dtype=np.float32) IMAGENET_STD = np.array([[[0.229, 0.224, 0.225]]], dtype=np.float32) def predict_imagenet(net, image_file): # Load image and resize image = PIL.Image.open(image_file).resize((244, 244)) # Convert to numpy and normalize image = np.array(image, dtype=np.float32) / 255. image = (image - IMAGENET_MEAN) / IMAGENET_STD # Convert to PyTorch and make channel first image = torch.as_tensor(image).unsqueeze(0).permute(0, 3, 1, 2) # Predict top class logits = net(image) class_idx = logits.squeeze(0).argmax().item() # Output predictions print('It is a %s.' % CLASS_DICT[str(class_idx)]) display(Image(filename=image_file)) net = jit.load('./model.pth') predict_imagenet(net, './whats_this.jpg') print('https://i.ytimg.com/vi/2fb-g_V-UT4/hqdefault.jpg')
def __init__(self, file: str, batch_size: int, *args, **kwargs): super().__init__(*args, **kwargs) self.model = load(file) self.batch_size = batch_size
tokenizer = T5Tokenizer.from_pretrained('t5-small') init_token = tokenizer.pad_token eos_token = tokenizer.eos_token pad_token = tokenizer.pad_token unk_token = tokenizer.unk_token init_token_idx = tokenizer.convert_tokens_to_ids(init_token) eos_token_idx = tokenizer.convert_tokens_to_ids(eos_token) pad_token_idx = tokenizer.convert_tokens_to_ids(pad_token) unk_token_idx = tokenizer.convert_tokens_to_ids(unk_token) max_input_length = tokenizer.max_model_input_sizes['t5-small'] new_model = jit.load('t5_ts_qa_model.zip') def translate_sentence2(sentence, eval_model, max_len=50): eval_model.eval() eval_model = eval_model.float() src_indexes = [init_token_idx] + sentence + [eos_token_idx] src_tensor = torch.LongTensor(src_indexes).unsqueeze(0) trg_indexes = [init_token_idx] for i in range(max_len):
from tqdm import tqdm_notebook import pandas as pd import torch import torch.nn as nn from torch.utils.data import DataLoader from torch.jit import load from torch.nn.parameter import Parameter from torch.nn import functional as F from model import * from mlcomp.contrib.transform.albumentations import ChannelTranspose from mlcomp.contrib.dataset.classify import ImageDataset from mlcomp.contrib.transform.rle import rle2mask, mask2rle from mlcomp.contrib.transform.tta import TtaWrap unet_se_resnext = load( '/kaggle/input/pretrainedmodel/unet_se_resnext50_32x4d.pth').cuda() unet_mobilenet = load( '/kaggle/input/pretrainedmodel/unet_mobilenet2.pth').cuda() unet_resnet = load('/kaggle/input/pretrainedmodel/unet_resnet34.pth').cuda() model = Model([unet_se_resnext, unet_mobilenet, unet_resnet]) model_cls = nn.DataParallel(Net(num_class=4)) checkpoint = torch.load( '/kaggle/input/pretrainedmodel/resnet_cls_model_ver2.pth', map_location='cuda') model_cls.load_state_dict(checkpoint["state_dict"]) model_cls = model_cls.eval() def create_transforms(additional): res = list(additional)
import cv2 import albumentations as A from tqdm import tqdm_notebook import pandas as pd import torch import torch.nn as nn from torch.utils.data import DataLoader from torch.jit import load from mlcomp.contrib.transform.albumentations import ChannelTranspose from mlcomp.contrib.dataset.classify import ImageDataset from mlcomp.contrib.transform.rle import rle2mask, mask2rle from mlcomp.contrib.transform.tta import TtaWrap unet_se_resnext50_32x4d = \ load('/kaggle/input/severstalmodels/unet_se_resnext50_32x4d.pth').cuda() unet_mobilenet2 = load( '/kaggle/input/severstalmodels/unet_mobilenet2.pth').cuda() unet_resnet34 = load('/kaggle/input/severstalmodels/unet_resnet34.pth').cuda() class Model: def __init__(self, models): self.models = models def __call__(self, x): res = [] x = x.cuda() with torch.no_grad(): for m in self.models: res.append(m(x))
import torch from torch import jit import cv2 import time # Load the torchscript model model = jit.load('/models/run10/model.zip') # Set the model to evaluate mode model = model.cuda().eval() # Export ONNX format x = torch.ones(1, 3, 320, 640, requires_grad=True).cuda() #torch.onnx.export(model,x,'/home/brian/models/run10/jetracer.onnx',export_params=True,opset_version=11,do_constant_folding=True) torch.onnx.export(model, x, '/home/brian/models/run10/jetracer.onnx', export_params=True) ino = 536 # Read a sample image and mask from the data-set img = cv2.imread(f'/models/train_data/Images/{ino:03d}.jpg').transpose( 2, 0, 1).reshape(1, 3, 320, 640) mask = cv2.imread(f'/models/train_data/Masks/{ino:03d}_mask.png') torch.cuda.current_stream().synchronize() t0 = time.time() with torch.no_grad(): a = model(torch.from_numpy(img).type(torch.cuda.FloatTensor) / 255) torch.cuda.current_stream().synchronize()
def _load_model(self): PATH = self._find_with_extension(EXTENSION) self.model = jit.load(PATH)
def segmentation(self, data): """ Perform semantic segmentation Parameters ---------- data: dict contain: input_files: str path to input layers neural_network: str path to neural network output_file: str path where to save the output Returns ------- True if segmentation has been correctly perfomed. Raise an exception otherwise. """ cfg = self.cfg["segmentation"] neural_net = data["neural_network"] print("\tStep 1: Load inputs.") if self.ssh_server: neural_net = self.ssh_server.get(neural_net, cache=True) if isinstance(self.cache, dict) and self.cache.get("net_file") == neural_net: net = self.cache["net"] else: net = jit.load(neural_net, map_location=self.device) if isinstance(self.cache, dict): self.cache["net"] = net self.cache["net_file"] = neural_net self.n_classes = find_n_classes(net) fp, inputs, nodata_mask = self._prepare_inputs(data, "segmentation") result = self._tile_fp(fp, cfg) if isinstance(result, str): return result else: tiled_fp = result # check the inputs sum_channs, channels_net = check_inputs_and_net(inputs, net) if sum_channs != channels_net: warn = f"Warning: {sum_channs} input channels while the chosen net expects {channels_net} channels." print_warning(warn) return warn print("\tStep 2: Inference") with torch.no_grad(): pred = torch.zeros((self.n_classes, *fp.shape)).to( self.device, torch.double ) # Slides a window across the image for batch_fps in make_batches(cfg["batch_size"], tiled_fp): inputs_patches = [ from_coord_to_patch(x, batch_fps, self.original_fp) for x in inputs ] outs = net(torch.cat(inputs_patches, dim=1)).data.to(torch.double) for out, sub_fp in zip(outs, batch_fps): small_sub_slice = sub_fp.slice_in(fp, clip=True) big_sub_slice = fp.slice_in(sub_fp, clip=True) pred[:, small_sub_slice[0], small_sub_slice[1]] += out[ :, big_sub_slice[0], big_sub_slice[1] ] mask = torch.argmax(pred, dim=0).cpu().numpy() print("\tStep 3: Save outputs") self._save_output(data, mask, nodata_mask, fp) return mask
while not terminal: step += 1 print() simulator.render(state) if step % 2 == 0: action = int(input("Action: ")) else: root = alpha_zero.mcts(state, mask, simulator, network, config, root_node=root) action = np.random.choice(mask.shape[0], p=root.action_policy) state, _, terminal, _ = simulator.step(state, action) mask = simulator.action_space.as_discrete.action_mask(state) if root is not None: root = root.children[action] simulator.render(state) if __name__ == "__main__": args = parser.parse_args() net = jit.load(os.path.join(args.save_path, "network.pt")) play(simulators.ConnectFour(), net, alpha_zero.MCTSConfig())
import torch.nn.functional as F from networks.imageunet import init_network import cv2 import numpy as np import pandas as pd from torchvision import models import albumentations as albu from efficientnet_pytorch import EfficientNet import segmentation_models_pytorch as smp # model_params = {} # model_params['architecture'] = "unet_se_resnext50_cbam_v0a" # seg_model = init_network(model_params) from torch.jit import load from albumentations.pytorch.transforms import ToTensor unet_se_resnext50_32x4d = load( 'E:/pycharm_project/steel/baseline_model/unet_se_resnext50_32x4d.pth' ).cuda() unet_se_resnext50_32x4d.eval() unet_mobilenet2 = load( 'E:/pycharm_project/steel/baseline_model/unet_mobilenet2.pth').cuda() unet_mobilenet2.eval() unet_resnet34 = load( 'E:/pycharm_project/steel/baseline_model/unet_resnet34.pth').cuda() unet_resnet34.eval() # model_params = {} # arch = "unet_se_resnext50_cbam_v0a" # model_params['architecture'] = arch # unet_se_resnext50_32x4d = init_network(model_params).cuda() # unet_se_resnext50_32x4d.load_state_dict(torch.load('E:/pycharm_project/steel/code/save_model/lb89277.pth')['state_dict']) mymodel = smp.Unet("efficientnet-b0",
import cv2 import albumentations as A from tqdm import tqdm_notebook import pandas as pd import torch import torch.nn as nn from torch.utils.data import DataLoader from torch.jit import load from mlcomp.contrib.transform.albumentations import ChannelTranspose from mlcomp.contrib.dataset.classify import ImageDataset from mlcomp.contrib.transform.rle import rle2mask, mask2rle from mlcomp.contrib.transform.tta import TtaWrap unet_se_resnext50_32x4d = load( "/kaggle/input/severstalmodels/unet_se_resnext50_32x4d.pth").cuda() unet_mobilenet2 = load( "/kaggle/input/severstalmodels/unet_mobilenet2.pth").cuda() # unet_resnet34 = load('/kaggle/input/severstalmodels/unet_resnet34.pth').cuda() import os from segmentation_models_pytorch import Unet, FPN ENCODER = "resnet34" ENCODER_WEIGHTS = "imagenet" DEVICE = "cuda" CLASSES = ["0", "1", "2", "3", "4"] ACTIVATION = "softmax" unet_resnet34 = Unet(encoder_name=ENCODER,