mirror of
https://github.com/aladdinpersson/Machine-Learning-Collection.git
synced 2026-04-10 12:33:44 +00:00
Initial commit
This commit is contained in:
Aladdin Persson
@@ -0,0 +1,189 @@
|
||||
import random
|
||||
import PIL, PIL.ImageOps, PIL.ImageEnhance, PIL.ImageDraw
|
||||
import numpy as np
|
||||
import torch
|
||||
from PIL import Image
|
||||
|
||||
def ShearX(img, v): # [-0.3, 0.3]
|
||||
assert -0.3 <= v <= 0.3
|
||||
if random.random() > 0.5:
|
||||
v = -v
|
||||
return img.transform(img.size, PIL.Image.AFFINE, (1, v, 0, 0, 1, 0))
|
||||
|
||||
|
||||
def ShearY(img, v): # [-0.3, 0.3]
|
||||
assert -0.3 <= v <= 0.3
|
||||
if random.random() > 0.5:
|
||||
v = -v
|
||||
return img.transform(img.size, PIL.Image.AFFINE, (1, 0, 0, v, 1, 0))
|
||||
|
||||
|
||||
def TranslateX(img, v): # [-150, 150] => percentage: [-0.45, 0.45]
|
||||
assert -0.45 <= v <= 0.45
|
||||
if random.random() > 0.5:
|
||||
v = -v
|
||||
v = v * img.size[0]
|
||||
return img.transform(img.size, PIL.Image.AFFINE, (1, 0, v, 0, 1, 0))
|
||||
|
||||
|
||||
def TranslateXabs(img, v): # [-150, 150] => percentage: [-0.45, 0.45]
|
||||
assert 0 <= v
|
||||
if random.random() > 0.5:
|
||||
v = -v
|
||||
return img.transform(img.size, PIL.Image.AFFINE, (1, 0, v, 0, 1, 0))
|
||||
|
||||
|
||||
def TranslateY(img, v): # [-150, 150] => percentage: [-0.45, 0.45]
|
||||
assert -0.45 <= v <= 0.45
|
||||
if random.random() > 0.5:
|
||||
v = -v
|
||||
v = v * img.size[1]
|
||||
return img.transform(img.size, PIL.Image.AFFINE, (1, 0, 0, 0, 1, v))
|
||||
|
||||
|
||||
def TranslateYabs(img, v): # [-150, 150] => percentage: [-0.45, 0.45]
|
||||
assert 0 <= v
|
||||
if random.random() > 0.5:
|
||||
v = -v
|
||||
return img.transform(img.size, PIL.Image.AFFINE, (1, 0, 0, 0, 1, v))
|
||||
|
||||
|
||||
def Rotate(img, v): # [-30, 30]
|
||||
assert -30 <= v <= 30
|
||||
if random.random() > 0.5:
|
||||
v = -v
|
||||
return img.rotate(v)
|
||||
|
||||
|
||||
def AutoContrast(img, _):
|
||||
return PIL.ImageOps.autocontrast(img)
|
||||
|
||||
|
||||
def Invert(img, _):
|
||||
return PIL.ImageOps.invert(img)
|
||||
|
||||
|
||||
def Equalize(img, _):
|
||||
return PIL.ImageOps.equalize(img)
|
||||
|
||||
|
||||
def Flip(img, _): # not from the paper
|
||||
return PIL.ImageOps.mirror(img)
|
||||
|
||||
|
||||
def Solarize(img, v): # [0, 256]
|
||||
assert 0 <= v <= 256
|
||||
return PIL.ImageOps.solarize(img, v)
|
||||
|
||||
|
||||
def SolarizeAdd(img, addition=0, threshold=128):
|
||||
img_np = np.array(img).astype(np.int)
|
||||
img_np = img_np + addition
|
||||
img_np = np.clip(img_np, 0, 255)
|
||||
img_np = img_np.astype(np.uint8)
|
||||
img = Image.fromarray(img_np)
|
||||
return PIL.ImageOps.solarize(img, threshold)
|
||||
|
||||
|
||||
def Posterize(img, v): # [4, 8]
|
||||
v = int(v)
|
||||
v = max(1, v)
|
||||
return PIL.ImageOps.posterize(img, v)
|
||||
|
||||
|
||||
def Contrast(img, v): # [0.1,1.9]
|
||||
assert 0.1 <= v <= 1.9
|
||||
return PIL.ImageEnhance.Contrast(img).enhance(v)
|
||||
|
||||
|
||||
def Color(img, v): # [0.1,1.9]
|
||||
assert 0.1 <= v <= 1.9
|
||||
return PIL.ImageEnhance.Color(img).enhance(v)
|
||||
|
||||
|
||||
def Brightness(img, v): # [0.1,1.9]
|
||||
assert 0.1 <= v <= 1.9
|
||||
return PIL.ImageEnhance.Brightness(img).enhance(v)
|
||||
|
||||
|
||||
def Sharpness(img, v): # [0.1,1.9]
|
||||
assert 0.1 <= v <= 1.9
|
||||
return PIL.ImageEnhance.Sharpness(img).enhance(v)
|
||||
|
||||
|
||||
def Cutout(img, v): # [0, 60] => percentage: [0, 0.2]
|
||||
assert 0.0 <= v <= 0.2
|
||||
if v <= 0.:
|
||||
return img
|
||||
|
||||
v = v * img.size[0]
|
||||
return CutoutAbs(img, v)
|
||||
|
||||
|
||||
def CutoutAbs(img, v): # [0, 60] => percentage: [0, 0.2]
|
||||
# assert 0 <= v <= 20
|
||||
if v < 0:
|
||||
return img
|
||||
w, h = img.size
|
||||
x0 = np.random.uniform(w)
|
||||
y0 = np.random.uniform(h)
|
||||
|
||||
x0 = int(max(0, x0 - v / 2.))
|
||||
y0 = int(max(0, y0 - v / 2.))
|
||||
x1 = min(w, x0 + v)
|
||||
y1 = min(h, y0 + v)
|
||||
|
||||
xy = (x0, y0, x1, y1)
|
||||
color = (125, 123, 114)
|
||||
# color = (0, 0, 0)
|
||||
img = img.copy()
|
||||
PIL.ImageDraw.Draw(img).rectangle(xy, color)
|
||||
return img
|
||||
|
||||
|
||||
def SamplePairing(imgs): # [0, 0.4]
|
||||
def f(img1, v):
|
||||
i = np.random.choice(len(imgs))
|
||||
img2 = PIL.Image.fromarray(imgs[i])
|
||||
return PIL.Image.blend(img1, img2, v)
|
||||
return f
|
||||
|
||||
|
||||
def Identity(img, v):
|
||||
return img
|
||||
|
||||
def augment_list():
|
||||
l = [
|
||||
(AutoContrast, 0, 1),
|
||||
(Equalize, 0, 1),
|
||||
(Invert, 0, 1),
|
||||
(Rotate, 0, 30),
|
||||
(Posterize, 0, 4),
|
||||
(Solarize, 0, 256),
|
||||
(SolarizeAdd, 0, 110),
|
||||
(Color, 0.1, 1.9),
|
||||
(Contrast, 0.1, 1.9),
|
||||
(Brightness, 0.1, 1.9),
|
||||
(Sharpness, 0.1, 1.9),
|
||||
(ShearX, 0., 0.3),
|
||||
(ShearY, 0., 0.3),
|
||||
(CutoutAbs, 0, 40),
|
||||
(TranslateXabs, 0., 100),
|
||||
(TranslateYabs, 0., 100),
|
||||
]
|
||||
|
||||
return l
|
||||
|
||||
class RandAugment:
|
||||
def __init__(self, n, m):
|
||||
self.n = n
|
||||
self.m = m # [0, 30]
|
||||
self.augment_list = augment_list()
|
||||
|
||||
def __call__(self, img):
|
||||
ops = random.choices(self.augment_list, k=self.n)
|
||||
for op, minval, maxval in ops:
|
||||
val = (float(self.m) / 30) * float(maxval - minval) + minval
|
||||
img = op(img, val)
|
||||
|
||||
return img
|
||||
@@ -0,0 +1,36 @@
|
||||
import torch
|
||||
import albumentations as A
|
||||
from albumentations.pytorch import ToTensorV2
|
||||
|
||||
SEED = 42
|
||||
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
|
||||
NUM_WORKERS = 4
|
||||
BATCH_SIZE = 64
|
||||
PIN_MEMORY = True
|
||||
LOAD_MODEL = True
|
||||
LEARNING_RATE = 1e-4
|
||||
NUM_EPOCHS = 100
|
||||
|
||||
train_transforms = A.Compose([
|
||||
A.Resize(width=224, height=224,),
|
||||
A.RandomCrop(width=224, height=224),
|
||||
A.Rotate(40),
|
||||
A.HorizontalFlip(p=0.5),
|
||||
A.VerticalFlip(p=0.1),
|
||||
A.Normalize(
|
||||
mean=[0, 0, 0],
|
||||
std=[1, 1, 1],
|
||||
max_pixel_value=255.0,
|
||||
),
|
||||
ToTensorV2(),
|
||||
])
|
||||
|
||||
val_transforms = A.Compose([
|
||||
A.Resize(height=224, width=224),
|
||||
A.Normalize(
|
||||
mean=[0, 0, 0],
|
||||
std=[1, 1, 1],
|
||||
max_pixel_value=255.0,
|
||||
),
|
||||
ToTensorV2(),
|
||||
])
|
||||
@@ -0,0 +1,34 @@
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
import os
|
||||
from torch.utils.data import Dataset
|
||||
from PIL import Image
|
||||
import numpy as np
|
||||
|
||||
|
||||
class MyImageFolder(Dataset):
|
||||
def __init__(self, root_dir, transform=None):
|
||||
super(MyImageFolder, self).__init__()
|
||||
self.data = []
|
||||
self.root_dir = root_dir
|
||||
self.transform = transform
|
||||
self.class_names = os.listdir(root_dir)
|
||||
|
||||
for index, name in enumerate(self.class_names):
|
||||
files = os.listdir(os.path.join(root_dir, name))
|
||||
self.data += list(zip(files, [index]*len(files)))
|
||||
|
||||
def __len__(self):
|
||||
return len(self.data)
|
||||
|
||||
def __getitem__(self, index):
|
||||
img_file, label = self.data[index]
|
||||
root_and_dir = os.path.join(self.root_dir, self.class_names[label])
|
||||
image = np.array(Image.open(os.path.join(root_and_dir, img_file)))
|
||||
|
||||
if self.transform is not None:
|
||||
augmentations = self.transform(image=image)
|
||||
image = augmentations["image"]
|
||||
|
||||
return image, label
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
from torch import nn
|
||||
from efficientnet_pytorch import EfficientNet
|
||||
|
||||
class Net(nn.Module):
|
||||
def __init__(self, net_version, num_classes):
|
||||
super(Net, self).__init__()
|
||||
self.backbone = EfficientNet.from_pretrained('efficientnet-'+net_version)
|
||||
self.backbone._fc = nn.Sequential(
|
||||
nn.Linear(1280, num_classes),
|
||||
)
|
||||
|
||||
def forward(self, x):
|
||||
return self.backbone(x)
|
||||
@@ -0,0 +1,54 @@
|
||||
import torch
|
||||
import torch.nn as nn
|
||||
import torch.optim as optim
|
||||
from torch.utils.data import DataLoader
|
||||
from tqdm import tqdm
|
||||
from model import Net
|
||||
from utils import check_accuracy, load_checkpoint, save_checkpoint, make_prediction
|
||||
import config
|
||||
from dataset import MyImageFolder
|
||||
|
||||
|
||||
def train_fn(loader, model, optimizer, loss_fn, scaler, device):
|
||||
for batch_idx, (data, targets) in enumerate(tqdm(loader)):
|
||||
# Get data to cuda if possible
|
||||
data = data.to(device=device)
|
||||
targets = targets.to(device=device)
|
||||
|
||||
# forward
|
||||
with torch.cuda.amp.autocast():
|
||||
scores = model(data)
|
||||
loss = loss_fn(scores, targets.float())
|
||||
|
||||
# backward
|
||||
optimizer.zero_grad()
|
||||
scaler.scale(loss).backward()
|
||||
scaler.step(optimizer)
|
||||
scaler.update()
|
||||
|
||||
|
||||
def main():
|
||||
train_ds = MyImageFolder(root_dir="train/", transform=config.train_transforms)
|
||||
val_ds = MyImageFolder(root_dir="val/", transform=config.val_transforms)
|
||||
train_loader = DataLoader(train_ds, batch_size=config.BATCH_SIZE, num_workers=config.NUM_WORKERS,pin_memory=config.PIN_MEMORY, shuffle=True)
|
||||
val_loader = DataLoader(val_ds, batch_size=config.BATCH_SIZE, num_workers=config.NUM_WORKERS,pin_memory=config.PIN_MEMORY,shuffle=True)
|
||||
|
||||
loss_fn = nn.CrossEntropyLoss()
|
||||
model = Net(net_version="b0", num_classes=10).to(config.DEVICE)
|
||||
optimizer = optim.Adam(model.parameters(), lr=config.LEARNING_RATE)
|
||||
scaler = torch.cuda.amp.GradScaler()
|
||||
|
||||
if config.LOAD_MODEL:
|
||||
load_checkpoint(torch.load("my_checkpoint.pth.tar"), model, optimizer)
|
||||
|
||||
make_prediction(model, config.val_transforms, 'test/', config.DEVICE)
|
||||
check_accuracy(val_loader, model, config.DEVICE)
|
||||
|
||||
for epoch in range(config.NUM_EPOCHS):
|
||||
train_fn(train_loader, model, optimizer, loss_fn, scaler, config.DEVICE)
|
||||
check_accuracy(val_loader, model, config.DEVICE)
|
||||
checkpoint = {'state_dict': model.state_dict(), 'optimizer': optimizer.state_dict()}
|
||||
save_checkpoint(checkpoint)
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,56 @@
|
||||
import torch
|
||||
import torch.nn.functional as F
|
||||
import os
|
||||
from PIL import Image
|
||||
import pandas as pd
|
||||
import numpy as np
|
||||
from tqdm import tqdm
|
||||
|
||||
def check_accuracy(loader, model, device="cuda"):
|
||||
num_correct = 0
|
||||
num_samples = 0
|
||||
model.eval()
|
||||
|
||||
with torch.no_grad():
|
||||
for x, y in loader:
|
||||
x = x.to(device=device)
|
||||
y = y.to(device=device)
|
||||
|
||||
scores = torch.sigmoid(model(x))
|
||||
predictions = (scores>0.5).float()
|
||||
num_correct += (predictions == y).sum()
|
||||
num_samples += predictions.shape[0]
|
||||
|
||||
print(f'Got {num_correct} / {num_samples} with accuracy {float(num_correct) / float(num_samples) * 100:.2f}')
|
||||
|
||||
model.train()
|
||||
|
||||
|
||||
def save_checkpoint(state, filename="my_checkpoint.pth.tar"):
|
||||
print("=> Saving checkpoint")
|
||||
torch.save(state, filename)
|
||||
|
||||
|
||||
def load_checkpoint(checkpoint, model, optimizer):
|
||||
print("=> Loading checkpoint")
|
||||
model.load_state_dict(checkpoint['state_dict'])
|
||||
optimizer.load_state_dict(checkpoint['optimizer'])
|
||||
|
||||
def make_prediction(model, transform, rootdir, device):
|
||||
files = os.listdir(rootdir)
|
||||
preds = []
|
||||
model.eval()
|
||||
|
||||
files = sorted(files, key=lambda x: float(x.split(".")[0]))
|
||||
for file in tqdm(files):
|
||||
img = Image.open(os.path.join(rootdir, file))
|
||||
img = transform(img).unsqueeze(0).to(device)
|
||||
with torch.no_grad():
|
||||
pred = torch.sigmoid(model(img))
|
||||
preds.append(pred.item())
|
||||
|
||||
|
||||
df = pd.DataFrame({'id': np.arange(1, len(preds)+1), 'label': np.array(preds)})
|
||||
df.to_csv('submission.csv', index=False)
|
||||
model.train()
|
||||
print("Done with predictions")
|
||||
Reference in New Issue
Block a user