def init_model(gpu_ids, model_name):
# model_name = 'pnasnet5large'
# could be fbresnet152 or inceptionresnetv2
model = pretrainedmodels.__dict__[model_name](num_classes=1000,
pretrained='imagenet')
model.eval()
load_img = utils.LoadImage()
# transformations depending on the model
# rescale, center crop, normalize, and others (ex: ToBGR, ToRange255)
tf_img = utils.TransformImage(model)
"""
TODO(WG): Would be nice to use something like DataParallel, but that only does forward pass on given module.
Need to stop before logits step.
Should create wrapper for pretrainedmodels that does the MPI-like ops across GPUs on model.features modules:
1) replicated
2) scatter
3) parallel_apply
4) gather
Would have to know what layers are being used on each model.
"""
if torch.cuda.is_available():
model = model.cuda(device=gpu_ids[0])
return load_img, tf_img, model
def __init__(self, cnn_model, image_dir, index_file, caption_file, vocab):
self.load_img = utils.LoadImage()
self.tf_img = utils.TransformImage(cnn_model)
self.image_dir = image_dir
self.image_indices = codecs.open(index_file,
encoding="utf-8").readlines()
self.captions = codecs.open(caption_file, encoding="utf-8").readlines()
self.vocab = vocab
self.vocab_keys = vocab.keys()
self.max_len = 50
def __init__(self, img_paths, model, img_size=224, augment=False):
self.load_img = utils.LoadImage()
additional_args = {}
if augment:
additional_args = {
'random_crop': True, 'random_hflip': False,
'random_vflip': False
}
self.tf_img = utils.TransformImage(
model, scale=img_size / 256, **additional_args)
self.img_paths = img_paths
def __init__(self,
root,
datalist,
transform=None,
target_transform=None,
space='RGB'):
self.root = root
self.datalist = datalist
self.transform = transform
self.target_transform = target_transform
self.loader = putils.LoadImage(space)
def __init__(self,
data_dir,
train=True,
transform=None,
tta_transform=None,
tta_times=1):
self.data_dir = data_dir
self.coco = COCO(os.path.join(data_dir, 'metadata_utf8.json'))
self.load_img = utils.LoadImage()
self.transform = transform
self.train = train
self.tta_times = tta_times
self.tta_transform = tta_transform
self._prepare_mappings()
def __getitem__(self, idx):
if idx < len(self.neg_list):
image_path = self.neg_list[idx]
label = np.array(0).reshape([1, 1])
else:
image_path = self.pos_list[idx - len(self.neg_list)]
label = np.array(1).reshape([1, 1])
input_image = utils.LoadImage()(image_path)
# hot_label = np.zeros(2, dtype=np.int32)
# hot_label[label] = 1
if self.transform:
input_image = self.transform(input_image)
return input_image, label.astype(np.long)
def test_multi_process_infer():
model = pretrainedmodels.__dict__["resnet18"](num_classes=1000,
pretrained='imagenet')
tf_img = utils.TransformImage(model)
load_img = utils.LoadImage()
img_list = [
"010.jpg", "004.jpg", "005.jpg", "011.jpg", "012.jpg", "boy.jpg"
]
res = {}
t0 = time.time()
p_list = []
my_queue = Queue()
with Manager() as manager:
pred_list = manager.list()
my_pool = Pool(4)
for img in img_list:
input_img = load_img(img)
input_tensor = tf_img(
input_img) # 3x400x225 -> 3x299x299 size may differ
input_tensor = input_tensor.unsqueeze(
0) # 3x299x299 -> 1x3x299x299
input_img = torch.autograd.Variable(input_tensor,
requires_grad=False)
print("image:", img)
p = Process(target=infer_process,
args=(my_queue, input_img, model))
p.start()
p_list.append(p)
# p.start()
# p.join()
# xx = my_pool.apply_async(infer_process,args=(pred_list,input_img,model,),callback=infer_callback)
# res[img] = xx
# my_pool.close()
# my_pool.join()
for p in p_list:
p.join()
while not my_queue.empty():
value = my_queue.get(True)
print("queue get a predict result:", value)
# time.sleep(random.random())
print("Time cost:", time.time() - t0)
print("模型推理完毕...")
def main():
global args
args = parser.parse_args()
for arch in args.arch:
# Load Model
model = pretrainedmodels.__dict__[arch](num_classes=1000,
pretrained='imagenet')
model.eval()
path_img = args.path_img
# Load and Transform one input image
load_img = utils.LoadImage()
tf_img = utils.TransformImage(model)
input_data = load_img(args.path_img) # 3x400x225
input_data = tf_img(input_data) # 3x299x299
input_data = input_data.unsqueeze(0) # 1x3x299x299
input = torch.autograd.Variable(input_data)
# Load Imagenet Synsets
with open('data/imagenet_synsets.txt', 'r') as f:
synsets = f.readlines()
# len(synsets)==1001
# sysnets[0] == background
synsets = [x.strip() for x in synsets]
splits = [line.split(' ') for line in synsets]
key_to_classname = {spl[0]: ' '.join(spl[1:]) for spl in splits}
with open('data/imagenet_classes.txt', 'r') as f:
class_id_to_key = f.readlines()
class_id_to_key = [x.strip() for x in class_id_to_key]
# Make predictions
output = model(input) # size(1, 1000)
max, argmax = output.data.squeeze().max(0)
class_id = argmax[0]
class_key = class_id_to_key[class_id]
classname = key_to_classname[class_key]
print("'{}': '{}' is a '{}'".format(arch, path_img, classname))
def test_batch_infer():
model = pretrainedmodels.__dict__["resnet18"](num_classes=1000,
pretrained='imagenet')
tf_img = utils.TransformImage(model)
load_img = utils.LoadImage()
img_list = [
"010.jpg", "004.jpg", "005.jpg", "011.jpg", "012.jpg", "boy.jpg"
]
t0 = time.time()
for img in img_list:
input_img = load_img(img)
input_tensor = tf_img(
input_img) # 3x400x225 -> 3x299x299 size may differ
input_tensor = input_tensor.unsqueeze(0) # 3x299x299 -> 1x3x299x299
input_img = torch.autograd.Variable(input_tensor, requires_grad=False)
output = model(input_img)
_, predicted = torch.max(output.data, 1)
print("model predict result is:", predicted.numpy()[0])
print("Time cost:", time.time() - t0)
def init():
global model
seed = 0
torch.manual_seed(seed)
logging.basicConfig(level=logging.DEBUG)
model_name = 'nasnetalarge'
model = pretrainedmodels.__dict__[model_name](num_classes=1000,
pretrained='')
model_path = Model.get_model_path('full_chexray_e17')
# if you want to test the run script on your local system you can uncomment the following line and comment the one above
#model_path = os.path.join(base_path,'output/chexray_nasnet_e10.pth.tar')
n_classes = 14
in_ftrs = model.last_linear.in_features
model.last_linear = nn.Sequential(nn.Linear(in_ftrs, 256), nn.ReLU(),
nn.Dropout(p=0.4),
nn.Linear(256, n_classes), nn.Sigmoid())
chkpt = torch.load(model_path, map_location=lambda storage, loc: storage)
state_dict = chkpt['state_dict']
new_state_dict = OrderedDict()
for k, v in state_dict.items():
name = k[7:] # remove 'module.' of dataparallel
new_state_dict[name] = v
model.load_state_dict(new_state_dict)
global load_img
load_img = utils.LoadImage()
global credentials
credentials = {
"datastore_name":
"chexrayds",
"container_name":
"chexray-images",
"account_name":
"chexray14",
"account_key":
"rXogWjkm8lXV0QfHAety1KktKGxbb1pMGoWkd4E9FI3QN+MW2qp4bWlFRymGS2zR0MyroV+VJcgHurr8+dhQdg=="
}
model.eval()
def createFeatures3(encoder, img_dir, lbl_train, lbl_test):
import pretrainedmodels.utils as utils
load_img = utils.LoadImage()
tf_img = utils.TransformImage(encoder)
train_dir = '%s/natural-image_training' % img_dir
featuresTrain = []
for i in range(len(lbl_train)):
file = '%s/%s' % (train_dir, lbl_train[i])
sample = transformFile2(load_img, tf_img, file)
featuresTrain.append(encoder(sample))
test_dir = '%s/natural-image_test' % img_dir
featuresTest = []
for i in range(len(lbl_test)):
file = '%s/%s' % (test_dir, lbl_test[i])
sample = transformFile2(load_img, tf_img, file)
featuresTest.append(encoder(sample))
return featuresTrain, featuresTest
def extract():
cuda_is_availabe = torch.cuda.is_available()
print('CUDA is available' if cuda_is_availabe else 'CUDA is NOT available')
xception_model = xception_with_pooling_features(num_classes=1000,
pretrained='imagenet')
if cuda_is_availabe:
xception_model = xception_model.to(torch.device('cuda:0'))
photo_df = pd.read_json('photos/photo.json', lines=True)
load_img = utils.LoadImage()
# transformations depending on the model
# rescale, center crop, normalize, and others (ex: ToBGR, ToRange255)
tf_img = utils.TransformImage(xception_model)
photo_df['features'] = None
# Extract features just for a small subset.
#photo_df = photo_df.loc[:100-1,:]
for index, row in tqdm(photo_df.iterrows(),
total=photo_df.shape[0],
desc="Extracting features from photos"):
photo_id = row['photo_id']
file_name = os.path.join('photos', 'photos', photo_id + '.jpg')
input_img = load_img(file_name)
input_tensor = tf_img(input_img) # 3x?x? -> 3x299x299 size may differ
input_tensor = input_tensor.unsqueeze(0) # 3x299x299 -> 1x3x299x299
if cuda_is_availabe:
input_tensor = input_tensor.cuda()
with torch.no_grad():
#input = torch.autograd.Variable(input_tensor, requires_grad=False)
output_features = xception_model.features(
input_tensor).cpu().numpy() # 1x2048x1x1
output_features = np.reshape(output_features, (-1, ))
row['features'] = output_features
os.makedirs('.cache', exist_ok=True)
photo_df.to_pickle('.cache/photo.pkl')
import torch
import torch.nn as nn
from torch.autograd import Variable
import pretrainedmodels as pm
import pretrainedmodels.utils as utils
# torch 1.0.x
set_grad_enabled = getattr(torch.autograd, 'set_grad_enabled', None)
pm_args = []
for model_name in pm.model_names:
for pretrained in pm.pretrained_settings[model_name]:
if pretrained in ['imagenet', 'imagenet+5k']:
pm_args.append((model_name, pretrained))
#여기를 건드려야 할 것 같은데...?!
img = utils.LoadImage()('data/cat.jpg')
def equal(x, y):
return torch.all(torch.lt(torch.abs(torch.add(x, -y)), 1e-12))
@pytest.mark.parametrize('model_name, pretrained', pm_args)
def test_pm_imagenet(model_name, pretrained):
if set_grad_enabled: set_grad_enabled(False)
print('test_pm_imagenet("{}")'.format(model_name))
net = pm.__dict__[model_name](num_classes=1000, pretrained=pretrained)
net.eval()
tensor = utils.TransformImage(net)(img)
probabilities_all.append(probabilities)
if (j+1)%2 == 0:
input_file.write("fitness at iteration " + str(j+1) + ' ' + str(result[1]))
input_file.write("\n")
input_file.write("Target probability: " +str(target_prob) + ":: Original probability: " +str(orig_prob))
input_file.write("\n")
input_file.write('Top scorer: '+ str(labels[int(np.argmax(probabilities))]) +
', probability:: ' + str(np.max(probabilities)))
input_file.write("\n")
return j,history, probabilities_all, orig_probs, target_probs
load_img = utils.LoadImage()
tf_img = utils.TransformImage(model)
NUMBER_OF_LINE_PERMUTATIONS = 10
import random
for iterations in range(NUMBER_OF_FILES):
target_class = random.randint(0,1000)
for permutation in range(NUMBER_OF_LINE_PERMUTATIONS):
xpoint = random.randint(0,224)
ypoint = random.randint(0,224)
xpoint2 = random.randint(0,224)
ypoint2 = random.randint(0,224)
# xpoint,ypoint,xpoint2,ypoint2 = 13,5,200,210
print ('Random points: ', xpoint,ypoint,xpoint2,ypoint2)
def __init__(self, cnn_model, image_dir, index_file):
self.load_img = utils.LoadImage()
self.tf_img = utils.TransformImage(cnn_model)
self.image_dir = image_dir
self.image_indices = codecs.open(index_file,
encoding="utf-8").readlines()
def load_model():
if args.architect.startswith('resnet'):
if args.architect == 'resnet18':
model = models.resnet18(pretrained=True)
if args.architect == 'resnet50':
model = models.resnet50(pretrained=True)
model.avgpool = nn.AdaptiveAvgPool2d(1)
if args.nodoublefc is True:
model.fc = nn.Linear(in_features=model.fc.in_features,
out_features=37)
else:
model.fc = nn.Sequential(
nn.Linear(in_features=model.fc.in_features, out_features=1024),
nn.ReLU(), nn.Linear(in_features=1024,
out_features=37)) # change dis shit
elif args.architect == 'squeezenet':
model = models.squeezenet1_1(pretrained=True)
model.classifier = nn.Sequential([
nn.Dropout(p=0.5),
nn.Conv2d(512, 37, kernel_size=(1, 1), stride=(1, 1)),
nn.ReLU(inplace=True),
nn.AdaptiveAvgPool2d(1)
])
elif args.architect == 'mobilenet':
model = mobilenetv2()
model.load_state_dict(
torch.load('./mobilenetv2/pretrained/mobilenetv2-36f4e720.pth'))
model.avgpool = nn.AdaptiveAvgPool2d(1)
if args.nodoublefc is True:
model.classifier = nn.Linear(
in_features=model.classifier.in_features, out_features=37)
else:
model.classifier = nn.Sequential(
nn.Linear(in_features=model.classifier.in_features,
out_features=1024), nn.ReLU(),
nn.Linear(in_features=1024,
out_features=37)) # change dis shit
elif args.architect in pretrainedmodels.__dict__: # no blabla fully conv for these models
model = pretrainedmodels.__dict__[args.architect](
num_classes=1000, pretrained='imagenet')
load_img = utils.LoadImage()
tf_img = utils.TransformImage(model)
else:
raise 'no known architecture %s' % args.architect
filename = '%s.checkpoint.pth.tar' % (args.tag)
if args.start_tag is not None:
start_filename = '%s.checkpoint.pth.tar' % (args.start_tag)
else:
start_filename = filename
checkpoint = None
if os.path.exists(start_filename) and args.resume:
checkpoint = torch.load(start_filename)
model.load_state_dict(checkpoint['state_dict'])
print 'loaded weights from file ', start_filename
for i, child in enumerate(model.children()):
print child
if i < args.freeze:
for param in child.parameters():
param.requires_grad = False
return model.cuda(), checkpoint, filename
import dlib
import numpy as np
from sklearn.cluster import KMeans
from sklearn.cluster import MeanShift, DBSCAN
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
import pickle
import tkinter
from PIL import ImageTk
from PIL import Image
import cv2
from imdirect import imdirect_open
from sklearn.preprocessing import Normalizer
import random
load_img = utils_pretrained.LoadImage()
def _is_valid_img(img_path):
try:
load_img(img_path)
return True
except Exception:
return False
def filter_invalid_images(img_paths, num_workers=4, progress=False):
"""Filter invalid images before computing expensive features."""
with multiprocessing.Pool(num_workers) as p:
if progress:
load_works = list(
import pretrainedmodels.utils as pretrained_utils
from models import Encoder
print(pretrainedmodels.model_names)
test_models = ['pnasnet5large', 'nasnetalarge', 'senet154', 'polynet', 'inceptionv4', 'xception', 'resnet152']
attr = {model_name:{} for model_name in test_models}
for model_name in test_models:
model = pretrainedmodels.__dict__[model_name](num_classes=1000, pretrained='imagenet')
model.cuda()
model.eval()
with torch.no_grad():
load_img = pretrained_utils.LoadImage()
tf_img = pretrained_utils.TransformImage(model)
path_img = '../test/2.png'
input_img = load_img(path_img)
input_tensor = tf_img(input_img)
input_tensor = input_tensor.unsqueeze(0).cuda()
time_used_per_model = []
for i in range(100):
s = time.time()
output_features = model.features(input_tensor)
e = time.time()
time_used_per_model.append(e-s)
print(e-s, model_name)
attr[model_name]['time_used'] = time_used_per_model
attr[model_name]['size'] = input_tensor.size()
x = x.view(x.size(0), -1)
x = self.dropout(x)
x = self.last_linear(x)
return x
features_model = pretrainedmodels.__dict__['nasnetamobile'](num_classes=1000, pretrained='imagenet')
features_model.eval()
features_model.cuda()
classifier_model = Classifier()
classifier_model.load_state_dict(torch.load('scent_model.pt'))
classifier_model.eval()
classifier_model.cuda()
load_image = utils.LoadImage()
transform_image = utils.TransformImage(features_model)
class_labels = "citrus floral fruity woody oriental musk aromatic water mossy green".split(
"\t")
image = load_image('test/Screen Shot 2018-03-13 at 7.56.47 PM.png')
image = transform_image(image)
image = torch.autograd.Variable(image.unsqueeze(0).cuda())
outputs = classifier_model(features_model.features(image))
for predicted_label in outputs:
label_probs, label_indices = torch.topk(predicted_label, 3)
label_probs = label_probs.cpu().data.numpy()
label_indices = label_indices.cpu().data.numpy()
def eval(dataset, models, batch_size):
dataset_filename = dataset
if models == 'all':
models = all_models
else:
models = models.split(',')
for model in models:
assert model in all_models
dataset_filepath = pathlib.Path(__file__).parent / '../data/datasets' / (
dataset_filename + '.json')
print('Reading dataset from {} ...'.format(dataset_filepath))
with open(dataset_filepath, 'r') as f:
dataset = json.load(f)
cur_imgs = [x[0] for x in dataset['image_filenames']]
imgnet = imagenet.ImageNetData()
cds = candidate_data.CandidateData(load_metadata_from_s3=False,
exclude_blacklisted_candidates=False)
loader = image_loader.ImageLoader(imgnet, cds)
pbar = tqdm(total=len(cur_imgs), desc='Dataset download')
img_data = loader.load_image_bytes_batch(
cur_imgs,
size='scaled_500',
verbose=False,
download_callback=lambda x: pbar.update(x))
pbar.close()
for model in tqdm(models, desc='Model evaluations'):
if (model not in extra_models):
tqdm.write('Evaluating {}'.format(model))
resize_size = 256
center_crop_size = 224
if model == 'inception_v3':
resize_size = 299
center_crop_size = 299
data_loader = eval_utils.get_data_loader(
cur_imgs,
imgnet,
cds,
image_size='scaled_500',
resize_size=resize_size,
center_crop_size=center_crop_size,
batch_size=batch_size)
pt_model = getattr(torchvision.models, model)(pretrained=True)
if (torch.cuda.is_available()):
pt_model = pt_model.cuda()
pt_model.eval()
tqdm.write(' Number of trainable parameters: {}'.format(
sum(p.numel() for p in pt_model.parameters()
if p.requires_grad)))
predictions, top1_acc, top5_acc, total_time, num_images = eval_utils.evaluate_model(
pt_model, data_loader, show_progress_bar=True)
tqdm.write(' Evaluated {} images'.format(num_images))
tqdm.write(' Top-1 accuracy: {:.2f}'.format(100.0 * top1_acc))
tqdm.write(' Top-5 accuracy: {:.2f}'.format(100.0 * top5_acc))
tqdm.write(
' Total time: {:.1f} (average time per image: {:.2f} ms)'.
format(total_time, 1000.0 * total_time / num_images))
npy_out_filepath = pathlib.Path(
__file__).parent / '../data/predictions' / dataset_filename / (
model + '.npy')
npy_out_filepath = npy_out_filepath.resolve()
directory = os.path.dirname(npy_out_filepath)
if not os.path.exists(directory):
os.makedirs(directory)
if (os.path.exists(npy_out_filepath)):
old_preds = np.load(npy_out_filepath)
np.save(f'{npy_out_filepath}.{int(time.time())}', old_preds)
print('checking old preds is same as new preds')
if not np.allclose(old_preds, predictions):
diffs = np.round(old_preds - predictions, 4)
print('old preds != new preds')
else:
print('old preds == new_preds!')
np.save(npy_out_filepath, predictions)
tqdm.write(' Saved predictions to {}'.format(npy_out_filepath))
else:
tqdm.write('Evaluating extra model {}'.format(model))
if (model in {"dpn68b", "dpn92", "dpn107"}):
pt_model = pretrainedmodels.__dict__[model](
num_classes=1000, pretrained='imagenet+5k')
else:
pt_model = pretrainedmodels.__dict__[model](
num_classes=1000, pretrained='imagenet')
tf_img = pretrained_utils.TransformImage(pt_model)
load_img = pretrained_utils.LoadImage()
tqdm.write(' Number of trainable parameters: {}'.format(
sum(p.numel() for p in pt_model.parameters()
if p.requires_grad)))
#print(pt_model)
#print(load_img)
dataset = eval_utils.ImageLoaderDataset(cur_imgs,
imgnet,
cds,
'scaled_500',
transform=tf_img)
data_loader = torch.utils.data.DataLoader(dataset,
batch_size=batch_size,
shuffle=False,
num_workers=0,
pin_memory=True)
if (torch.cuda.is_available()):
pt_model = pt_model.cuda()
pt_model.eval()
predictions, top1_acc, top5_acc, total_time, num_images = eval_utils.evaluate_model(
pt_model, data_loader, show_progress_bar=True)
tqdm.write(' Evaluated {} images'.format(num_images))
tqdm.write(' Top-1 accuracy: {:.2f}'.format(100.0 * top1_acc))
tqdm.write(' Top-5 accuracy: {:.2f}'.format(100.0 * top5_acc))
tqdm.write(
' Total time: {:.1f} (average time per image: {:.2f} ms)'.
format(total_time, 1000.0 * total_time / num_images))
npy_out_filepath = pathlib.Path(
__file__).parent / '../data/predictions' / dataset_filename / (
model + '.npy')
npy_out_filepath = npy_out_filepath.resolve()
directory = os.path.dirname(npy_out_filepath)
if not os.path.exists(directory):
os.makedirs(directory)
if (os.path.exists(npy_out_filepath)):
old_preds = np.load(npy_out_filepath)
np.save(f'{npy_out_filepath}.{int(time.time())}', old_preds)
print('checking old preds is same as new preds')
if not np.allclose(old_preds, predictions):
diffs = np.round(old_preds - predictions, 4)
print('old preds != new preds')
else:
print('old preds == new_preds!')
np.save(npy_out_filepath, predictions)
tqdm.write(' Saved predictions to {}'.format(npy_out_filepath))
