def generate_data(data_folder, filename):
data_folder = 'D:\CharsFont\Bmp'
transform = {
'train':
transforms.Compose([
transforms.Resize([28, 28]),
transforms.Grayscale(num_output_channels=1),
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
]),
'test':
transforms.Compose([
transforms.Resize([28, 28]),
transforms.Grayscale(num_output_channels=1),
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])
}
data = datasets.ImageFolder(root=data_folder, transform=transform['train'])
data_loader = torch.utils.data.DataLoader(data,
batch_size=len(data),
shuffle=True)
test_dataset_array = next(iter(data_loader))
images = test_dataset_array[0].numpy()
labels = test_dataset_array[1].numpy()
store_many_hdf5(images, labels, filename)
def importDataset():
shutil.copy('/content/drive/My Drive/bg_fg_bg_mask_2.zip','bg_fg_bg_mask_2.zip')
shutil.copy('/content/drive/My Drive/Session15/copy_depth_output.zip','copy_depth_output.zip')
zip = ZipFile('bg_fg_bg_mask_2.zip')
zip.extractall('./')
zip = ZipFile('copy_depth_output.zip')
zip.extractall('./')
data_root = Path('.')
f1, f2, f3 ,f4 = data_root/'bg', data_root/'fg_bg', data_root/'mask_fg_bg', data_root/'depth'
print(len(list(f1.iterdir())))
print(len(list(f2.iterdir())))
print(len(list(f3.iterdir())))
print(len(list(f4.iterdir())))
scale_transform = transforms.Compose([
transforms.Resize((128, 128)),
#transforms.ColorJitter(brightness=0.2, contrast = 0.2, saturation = 0.2, hue = 0.2),
transforms.ToTensor(),
])
grayTransform = transforms.Compose([
transforms.Grayscale(num_output_channels=1),
transforms.Resize((128, 128)),
#transforms.ColorJitter(brightness=0.2, contrast = 0.2, saturation = 0.2, hue = 0.2),
transforms.ToTensor(),
])
mean, std = torch.tensor([0.485, 0.456, 0.406])*255, torch.tensor([0.229, 0.224, 0.225])*255
train_transforms = transforms.Compose([
transforms.Resize((128, 128)),
transforms.ColorJitter(brightness=0.15, contrast=0.15, saturation=0.15, hue= 0.15),
transforms.ToTensor(),
transforms.Normalize(mean, std)
])
train_ds = MasterData(data_root, train_transforms, scale_transform)
train_d1 = DataLoader(train_ds, batch_size=16, shuffle=True, pin_memory=True)
return train_d1
def get_transform():
return transforms.Compose([
transforms.ToPILImage(),
transforms.Grayscale(num_output_channels=1),
transforms.Resize(image_dims),
transforms.ToTensor(),
])
def __init__(self, root_dir):
self.samples = glob.glob(os.path.join(root_dir, '*'))
self.transforms = transforms.Compose([
transforms.Grayscale(),
transforms.Resize((128, 128)),
transforms.ToTensor()
])
def set_transform(resize=112, crop=112, normalize=None, additional=None):
if normalize is None or normalize is True:
normalize = [[0.485, 0.456, 0.406], [0.229, 0.224, 0.225]]
transform_list = [
transforms.Resize(resize),
transforms.CenterCrop(crop),
transforms.Grayscale(3)
]
if additional is not None:
transform_list.extend(additional)
transform_list.extend([transforms.ToTensor()])
if normalize is None or normalize is True:
normalize = [[0.485, 0.456, 0.406], [0.229, 0.224, 0.225]]
transform_list.extend(
[transforms.Normalize(mean=normalize[0], std=normalize[1])])
elif normalize is not False:
transform_list.extend(
[transforms.Normalize(mean=normalize[0], std=normalize[1])])
else:
pass
return transforms.Compose(transform_list)
def predict_image(img):
print("Prediction in progress")
# Define transformations for the image, should (note that imagenet models are trained with image size 224)
transformation = transforms.Compose([
transforms.Grayscale(),
transforms.ToTensor(),
transforms.Normalize((0.5, ), (0.5, ))
])
# Preprocess the image
image_tensor = transformation(img).float()
# Add an extra batch dimension since pytorch treats all images as batches
image_tensor = image_tensor.unsqueeze_(0)
# Turn the input into a Variable
image = Variable(image_tensor)
# Predict the class of the image
output = model(image)
index = output.data.numpy().argmax()
return index
def __init__(self):
## these are the potential labels for objects
self.labels = ['1','2','3','A','B', 'C']
## This try/except statement is if you are running the file itself to run the test method or importing it. The model.pt will be different location based on the context of who calls it.
try:
## Loading model
self.model = torch.hub.load('pytorch/vision:v0.5.0', 'alexnet', pretrained=True)
self.model.load_state_dict(torch.load('model_handler/model.pt'))
self.model.eval()
except Exception:
try:
## Loading model
self.model = torch.hub.load('pytorch/vision:v0.5.0', 'alexnet', pretrained=True)
self.model.load_state_dict(torch.load('model.pt'))
self.model.eval()
except:
print('System model not detected, please assure that "model.pt" is downloaded..')
sys.exit(1)
## Creates a transformer object.
## This transformer does the following, resizes the image and crops to the resize. Grayscales it. transforms it to a tensor object and normalizes the pixel values
self.trans = transforms.Compose([
transforms.Resize(224),
transforms.Grayscale(num_output_channels=3),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])
def get_imager_folder(folder='/mnt/sdb1/datasets/mammoset/exp5-2_aug'):
# Normalizacao utilizada no paper da ResNet https://arxiv.org/abs/1512.03385
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
scale = 224
transform = transforms.Compose([
# transforms.RandomResizedCrop(200),
# transforms.RandomHorizontalFlip(),
# transforms.RandomRotation(45),
transforms.Resize([scale, scale]),
# transforms.CenterCrop(scale),
transforms.Grayscale(1),
transforms.ToTensor(),
normalize,
])
train_data, val_data = ImageFolder(folder,
transform).get_split(train_perc=0.8)
num_classes = len(train_data.class_counts)
print('Tamanho conjuto de treino %s' % len(train_data))
print('Tamanho conjuto de teste %s' % len(val_data))
print('Classes Ids %s' % train_data.class_to_idx)
print('Classes Counts %s' % train_data.class_counts)
return train_data, val_data, num_classes
def predict_images(img):
print("Prediction in progress")
# Define transformations for the image, should (note that imagenet models are trained with image size 224)
transformation = transforms.Compose([
transforms.Grayscale(),
transforms.ToTensor(),
transforms.Normalize((0.5, ), (0.5, ))
])
index = []
# Preprocess the image
for im in img:
image_tensor = transformation(im.image).float().unsqueeze_(0)
# Turn the input into a Variable
image = Variable(image_tensor)
# Predict the class of the image
output = model(image)
index.append(output.data.numpy().argmax())
#fig,ax = plt.subplots()
#ax.imshow(np.asarray(im.image),cmap='gray')
#if output.data.numpy().argmax()==0:
# ax.set_title("Class = Noise")
#else:
# ax.set_title("Class = Data")
return index
def __init__(self, data_path, mode):
if mode == "train" or mode == "val":
img_paths = sorted(glob.glob(os.path.join(data_path, '*.jpg')))
random.shuffle(img_paths)
else:
img_paths = sorted(glob.glob(os.path.join(data_path, '*.jpg')),
key=get_name)
split = int(len(img_paths) * 0.75)
if mode == "train":
self.img_paths = img_paths[:split]
elif mode == "val":
self.img_paths = img_paths[split:]
else:
self.img_paths = img_paths
if mode == "train" or mode == "val":
self.labels = [
path.split("/")[-1].split(".")[0] for path in self.img_paths
]
self.labels = [int(label == "cat") for label in self.labels]
else:
self.img_ids = [
path.split("/")[-1].split(".")[0] for path in self.img_paths
]
if mode == "train":
transforms = [
T.Grayscale(),
T.Resize((RE_HEIGHT, RE_WIDTH)),
T.RandomHorizontalFlip(),
T.ToTensor()
]
else: # "val" and "test"
transforms = [
T.Grayscale(),
T.Resize((RE_HEIGHT, RE_WIDTH)),
T.ToTensor()
]
self.transforms = T.Compose(transforms)
self.mode = mode
def get_train_set(path, part):
trans_train = transforms.Compose([
transforms.Grayscale(1),
# this also convert pixel value from [0,255] to [0,1]
transforms.ToTensor(),
transforms.Normalize(mean=0.4638, std=0.1889),
])
train_set = GazeMe(path, part, transform=trans_train)
print("dataset successfully read!")
return train_set
def set_dataset_images(self):
transform_list = [transforms.ToTensor()]
if self.resize:
transform_list.append(transforms.Resize(256))
transform_list.append(transforms.CenterCrop(224))
if not self.rgb:
transform_list.append(transforms.Grayscale(num_output_channels=3))
transform = transforms.Compose(transform_list)
self.dataset_images = datasets.ImageNet(location=self.location, transform=transform)
def img_open(path):
data = PIL.Image.open(path)
height = 32
width = int(data.size[0] / (data.size[1] / height))
data = data.resize((width, height))
Transform = transforms.Compose([
transforms.Grayscale(),
transforms.ToTensor(),
transforms.Lambda(lambda x: torch.unsqueeze(x, 0))
])
data = Transform(data)
return data
def CreateImageTensors(IMAGE_PATH,TENSOR_PATH,sampletensor,labeltensor):
# INPUTS REQUIREMENTS
# Path to one folder containing a subfolder for each category
# Path to one folder where torch tensors will be saved
# Name of sample and label tensors
# OUTPUT
# train and test data
# input channels
# input size
# ID of categories used
# Choose image size (all image will be resized to this size)
inputsize=[299,299]
# 3 channels for colors, 1 for grayscale
chan=3
trans = transforms.Compose([
# transforms.Resize(inputsize),
transforms.Grayscale(num_output_channels=chan),
transforms.ToTensor(),
transforms.Normalize((0,),(0.5,))
])
# Read folders
dataset = datasets.ImageFolder(root=IMAGE_PATH, transform=trans)
# Create samples and label tensors
samples=torch.empty([len(dataset),*list(dataset[0][0].size())])
labels=torch.empty(len(dataset))
for i in range(len(dataset)):
samples[i]=dataset[i][0]
labels[i]=dataset[i][1]
# # This places all pixel value between 0 and 1, treating channels (colors) separately
for i in range(chan):
samples[:,i,:,:]=(samples[:,i,:,:]-torch.min(samples[:,i,:,:]))/torch.max(samples[:,i,:,:])
torch.save(samples, TENSOR_PATH + sampletensor)
torch.save(labels, TENSOR_PATH + labeltensor)
def get_fashion_mnist(bs,
size=32,
train=True,
mu=0.5,
std=0.5,
root=DATA_ROOT):
fatrans = transforms.Compose([
transforms.Grayscale(3),
transforms.Resize(size),
transforms.ToTensor(),
transforms.Normalize((mu, mu, mu), (std, std, std))
])
fmset = torchvision.datasets.FashionMNIST(root,
train=train,
transform=fatrans,
download=True)
fmloader = DataLoader(fmset, batch_size=bs, shuffle=True, num_workers=2)
return fmset, fmloader
def predict_for_frame(model, cv_img):
"""
Crop face on img, preprocess, make prediction
If several face on image, chose one.
:return: [
{"prediction": prediction vector, "position": (x, y, w, h)}
]
"""
faces = crop_faces([cv_img], only_one=False, using_bundled_library=True)[0]
if len(faces) == 0:
return []
pre_processing = transforms.Compose([
transforms.Grayscale(num_output_channels=1),
transforms.Resize(tuple(config["resolution"])),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5], std=[0.5]),
])
pre_processed_faces = []
faces_coords = []
for face in faces:
(x, y, w, h) = face
face_cv = crop_cv_img(cv_img, x, y, w, h)
face_pil = pre_processing(pl.Image.fromarray(face_cv))
pre_processed_faces.append(face_pil)
faces_coords.append((x, y, w, h))
x = torch.stack(pre_processed_faces)
predictions = torch.nn.Softmax(dim=1)(model.forward(x))
output = []
for prediction, coords in zip(predictions, faces_coords):
output.append({
"prediction": prediction,
"position": coords
})
return output
def __init__(self) -> None:
self._greyscale = transforms.Grayscale()
def make_video(fps):
"""
Make video from model predictions on the youtube faciale expression video: https://www.youtube.com/watch?v=B0ouAnmsO1Y
- Take one frame over 3 on the original 60fps video
- Detect face on the frame and draw rectangle delimiter.
- If a face is detected, run the model on it and write the results on the frame.
:param fps:
:return:
"""
cap = cv2.VideoCapture('./videos/facial_expressions_demo.mov')
out = cv2.VideoWriter(
'./videos/output.avi',
cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'),
fps,
(int(cap.get(3)), int(cap.get(4)))
)
model = Custom_vgg(1, len(config["catslist"]), device=torch.device('cpu'))
model.load_state_dict(torch.load(config["current_best_model"], map_location=torch.device('cpu')))
pre_process = transforms.Compose(
[transforms.Grayscale(num_output_channels=1), transforms.ToTensor(),
transforms.Normalize(mean=[0.5], std=[0.5])])
if not cap.isOpened():
print("Error opening video stream or file")
i = 0
while cap.isOpened():
i += 1
ret, frame = cap.read()
# process one frame over 3.
if i % 3 == 0:
if ret:
# detect face on the frame
face = crop_faces([frame])[0]
if face is None:
out.write(frame)
else:
(x, y, w, h) = face
# draw rectangle face delimiter
cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0))
# compute model predictions
pil_frame = pl.Image.fromarray(frame)
pil_frame = pil_frame.resize(config["resolution"]) # TODO add that in pre-processing
x = pre_process(pil_frame).unsqueeze(0)
predictions = model.predict_single(x)
# write predictions on the output frame
for index, proba in enumerate(predictions):
text = "{}: {}%".format(config["catslist"][index], proba)
cv2.putText(frame, text, (10, 130 + 32 * index), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255),
2, cv2.LINE_AA)
out.write(frame)
else:
break
if i % 60 == 0:
print("Processed {} seconds of video".format(i / 60))
cap.release()
out.release()
cv2.destroyAllWindows()
def Grayscale(self, **args):
return self._add(transforms.Grayscale(**args))
import torch.nn as nn
from torch import optim
from torch.autograd import Variable
import datas
from models.v2_net import KitModel
import torchvision.transforms.transforms as transforms
import importlib
from torch.nn.modules.distance import PairwiseDistance
from eval_metrics import evaluate, plot_roc
l2_dist = PairwiseDistance(2)
use_cuda = torch.cuda.is_available()
total_epoch = 150
transform = transforms.Compose([
transforms.Grayscale(),
transforms.Resize([32, 32]),
transforms.ToTensor()
])
trainset = datas.fec_data.FecData(transform)
trainloader = data.DataLoader(trainset, batch_size=256, num_workers=16)
# net = KitModel()
# load model which converted from caffe model using MMdnn tool
MainModel = imp.load_source('MainModel', "./models/v2_net.py")
net = torch.load("./models/v2_net.pth")
net.fc8_1 = nn.Linear(net.fc8_1.in_features, 4)
for param in net.parameters():
import torch
import glob
import torch.nn as nn
from torchvision.transforms import transforms
from torch.utils.data import DataLoader
from torch.optim import Adam
from torch.autograd import Variable
import torchvision
import pathlib
from tqdm import tqdm
import user_set
transformer = transforms.Compose([
transforms.Resize((256, 256)),
transforms.RandomHorizontalFlip(),
transforms.Grayscale(num_output_channels=1),
transforms.ToTensor(), #0-255 to 0-1, numpy to tensors
transforms.Normalize(
[0.5], # 0-1 to [-1,1] , formula (x-mean)/std
[0.5])
])
class ConvNet(nn.Module):
def __init__(self, num_classes=6):
super(ConvNet, self).__init__()
#Input shape= (3,256,256)
self.conv1 = nn.Conv2d(in_channels=1,
out_channels=32,
# ---------------Tensor上的操作---------------------------------
# transforms2 = transforms.Compose([transforms.Normalize(mean=(0.5, 0.5, #0.5), std=(0.5, 0.5, 0.5))])
# img2 = transforms2(img1)
# print('img2 = ', img2)
# ---------------PIL.Image上的操作---------------------------------
transforms3 = transforms.Compose([transforms.Resize(256)])
img3 = transforms3(img)
print('img3 = ', img3)
img3.show()
transforms4 = transforms.Compose([transforms.CenterCrop(256)])
img4 = transforms4(img)
print('img4 = ', img4)
img4.show()
transforms5 = transforms.Compose([transforms.RandomCrop(224, padding=0)])
img5 = transforms5(img)
print('img5 = ', img5)
img5.show()
transforms6 = transforms.Compose([transforms.Grayscale(num_output_channels=1)])
img6 = transforms6(img)
print('img6 = ', img6)
img6.show()
transforms7 = transforms.Compose([transforms.ColorJitter()])
img7 = transforms7(img)
img7.show()
def __init__(self, gpu=False):
models_directory = os.path.dirname(os.path.abspath(__file__))
# DENSENET
self.N_CLASSES = 14
self.CLASS_NAMES = [
'Atelectasis', 'Cardiomegaly', 'Effusion', 'Infiltration', 'Mass',
'Nodule', 'Pneumonia', 'Pneumothorax', 'Consolidation', 'Edema',
'Emphysema', 'Fibrosis', 'Pleural_Thickening', 'Hernia'
]
if gpu:
import torch.backends.cudnn as cudnn
cudnn.benchmark = True
device = torch.device("cuda:0")
else:
device = torch.device("cpu")
# initialize and load the model
model_dense = DenseNet121(self.N_CLASSES).to(device).eval()
if gpu:
model_dense = torch.nn.DataParallel(model_dense).to(device).eval()
checkpoint = torch.load(
os.path.join(models_directory, "gpu_weight.pth"))
else:
checkpoint = torch.load(os.path.join(models_directory,
"cpu_weight.pth"),
map_location=device)
model_dense.load_state_dict(checkpoint)
self.normalize = transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])
self.transform_dense = transforms.Compose([
transforms.Resize(256),
transforms.FiveCrop(224),
transforms.Lambda(lambda crops: torch.stack(
[transforms.ToTensor()(crop) for crop in crops])),
transforms.Lambda(lambda crops: torch.stack(
[self.normalize(crop) for crop in crops]))
])
self.model_dense = model_dense.to(device).eval()
self.device = device
# EFFNET
model_eff = EfficientNet.from_name(model_name="efficientnet-b0",
params=[1.0, 1.0, 224, 0.2],
override_params={'num_classes': 2})
state_dict = torch.load(os.path.join(models_directory,
"effnet_weight.pth"),
map_location=device)
model_eff.load_state_dict(state_dict)
self.model_eff = model_eff.to(device).eval()
self.transform_eff = transforms.Compose([
transforms.Resize(224),
transforms.Grayscale(3),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
#Resnet for detecting xray out of random images
resnet_state_dict = torch.load(os.path.join(models_directory,
"nonxray.pth"),
map_location=device)
model_resnet = resnet18()
model_resnet.fc = torch.nn.Linear(model_resnet.fc.in_features, 2)
model_resnet.load_state_dict(resnet_state_dict)
self.model_resnet = model_resnet.to(device).eval()
self.transform_resnet = transforms.Compose([
transforms.Resize(100),
transforms.CenterCrop(64),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
from torchvision.transforms import transforms as VT
from torchvision.transforms import functional as VF
valid_tmft = VT.Compose([
VT.Resize((256, 256)),
VT.Grayscale(),
VT.ToTensor(),
])
device = "cuda" if T.cuda.is_available() else "cpu"
print("device:", device)
v = 0
a = 0.95
# SETUP DATA TRANSFORMS
if args.random:
r = args.random
train_transforms = transforms.Compose([
transforms.ToTensor(),
#transforms.RandomApply([
# transforms.GaussianBlur(3, sigma=(0.1, 2.0))
#], p=0.2),
transforms.RandomApply(
[transforms.Grayscale(num_output_channels=3)], p=0.2),
transforms.RandomApply([
transforms.ColorJitter(brightness=r,
contrast=r,
saturation=r,
hue=r)
]),
transforms.RandomApply(
[transforms.RandomAffine(r * 10, shear=r * 10)]),
transforms.RandomResizedCrop((32, 32), scale=(1 - r, 1.0)),
transforms.RandomHorizontalFlip(p=0.5),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
])
test_transforms = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
from OmniglotDataset import OmniglotData
from models.SiameseNetwork import SiameseNetwork
from torchvision.transforms import transforms
import torch.optim as optim
import torch.nn as nn
import torch
if __name__ == "__main__":
transform_pipeline = transforms.Compose(
[transforms.Grayscale(), transforms.ToTensor()])
train_data = OmniglotData(root='./data/Omniglot/images_background',
transform=transform_pipeline)
train_loader = torch.utils.data.DataLoader(train_data,
batch_size=32,
shuffle=True,
num_workers=0)
net = SiameseNetwork()
optimizer = optim.Adam(net.parameters(), lr=1e-3)
criterion = nn.BCELoss()
for e in range(4):
running_loss = 0.0
batch_size = 0
for i, data in enumerate(train_loader):
img1, img2, similar = data
optimizer.zero_grad()
output = net(img1, img2)
loss = criterion(output, similar)
loss.backward()
optimizer.step()
train_labels=range(split_labels),
eval_labels=range(split_labels),
batch_size=batch_size,
)
# Defining unseen evaluation set
if type_of_unseen == 'random':
_, _, evalloader_unseen = get_random(number_of_channels=dim_channels, img_dim=dim_input, number_of_classes=10)
if type_of_unseen == 'unseen_classes':
_, _, evalloader_unseen = get_trainset(train_labels=(), eval_labels=range(split_labels, 10, ), )
res['split_labels'] = split_labels
if type_of_unseen == 'unseen_dataset':
res['unseen_dataset'] = unseen_evalset
assert trainset != unseen_evalset, 'Train Set must be different from Unseen Test Set'
transform = transforms.Compose([
transforms.Grayscale(num_output_channels=dim_channels),
transforms.Resize(dim_input),
transforms.ToTensor(),
])
if unseen_evalset == 'cifar10':
_, _, evalloader_unseen = get_cifar10(transform=transform)
if unseen_evalset == 'mnist':
_, _, evalloader_unseen = get_mnist(transform=transform)
if unseen_evalset == 'omniglot':
_, _, evalloader_unseen = get_omniglot(transform=transform, download=False)
seed_model = set_and_print_random_seed()
bay_net = GaussianClassifier(rho=rho, stds_prior=stds_prior, dim_input=dim_input, number_of_classes=10, dim_channels=dim_channels)
bay_net.to(device)
criterion = CrossEntropyLoss()
