def ResSENet101(num_classes = 10):
'''
First conv layer: 1
4 residual blocks with [3, 4, 23, 3] sets of three convolutions each: 3*3 + 4*3 + 23*3 + 3*3 = 99
last FC layer: 1
Total layers: 1+99+1 = 101
'''
return ResNet(ResidualSEBasicBlock, [3, 4, 23, 3], num_classes)
def ResSENet50(num_classes = 10):
'''
First conv layer: 1
4 residual blocks with [3, 4, 6, 3] sets of three convolutions each: 3*3 + 4*3 + 6*3 + 3*3 = 48
last FC layer: 1
Total layers: 1+48+1 = 50
'''
return ResNet(ResidualSEBasicBlock, [3, 4, 6, 3], num_classes)
def ResSENet152(num_classes = 10):
'''
First conv layer: 1
4 residual blocks with [3, 8, 36, 3] sets of three convolutions each: 3*3 + 8*3 + 36*3 + 3*3 = 150
last FC layer: 1
Total layers: 1+150+1 = 152
'''
return ResNet(ResidualSEBasicBlock, [3, 8, 36, 3], num_classes)
def ResNet18(num_classes=10):
'''
First conv layer: 1
4 residual blocks with two sets of two convolutions each: 2*2 + 2*2 + 2*2 + 2*2 = 16 conv layers
last FC layer: 1
Total layers: 1+16+1 = 18
'''
return ResNet(BasicBlock, [2, 2, 2, 2], num_classes)
def ResNet34(num_classes):
'''
First conv layer: 1
4 residual blocks with [3, 4, 6, 3] sets of two convolutions each: 3*2 + 4*2 + 6*2 + 3*2 = 32
last FC layer: 1
Total layers: 1+32+1 = 34
'''
return ResNet(BasicBlock, [3, 4, 6, 3], num_classes)
with torch.no_grad():
for i, j in loader:
inputs, labels = i.to(device), j.to(device)
outputs = model(inputs)
correct = correct + accuracy(outputs, labels)
print("[%d/%d] Test Accuracy : %f" %
(epochs, total_epochs, (correct / len(loader.dataset)) * 100))
print(
'---------------------------------------------------------------------'
)
return (correct / len(loader.dataset)) * 100
dtype = torch.cuda.FloatTensor
torch.manual_seed(52)
net = ResNet(BasicBlock, [2, 2, 2, 2]).to(device)
named_layers = []
for i in net.named_parameters():
named_layers.append(i[0])
opt = SwatsLocal(net.parameters(), named_layers, lr=0.001)
loss = nn.CrossEntropyLoss().type(dtype)
def adjust_lr(opt, epochs):
base_lr = 0.001
if epochs >= 75:
for ui in opt.param_groups:
ui['div_lr_decay'] = 10
if epochs >= 150:
for ui in opt.param_groups:
ui['div_lr_decay'] = 100
def ResSENet18(num_classes = 10):
return ResNet(ResidualSEBasicBlock, [2, 2, 2, 2], num_classes)
def Resnet101(num_classes=1):
model = ResNet(Bottleneck, [3, 4, 23, 3], num_classes=num_classes)
return model
def CBAMResnet101(num_classes=1):
model = ResNet(CBAMBottleneck, [3, 4, 23, 3], num_classes=num_classes)
model.avgpool = nn.AdaptiveAvgPool2d(1)
return model
def SEResnet50(num_classes=1):
model = ResNet(SEBottleneck, [3, 4, 6, 3], num_classes=num_classes)
model.avgpool = nn.AdaptiveAvgPool2d(1)
return model
with torch.no_grad():
for i, j in loader:
inputs, labels = i.to(device), j.to(device)
outputs = model(inputs)
correct = correct + accuracy(outputs, labels)
print("[%d/%d] Test Accuracy : %f" %
(epochs, total_epochs, (correct / len(loader.dataset)) * 100))
print(
'---------------------------------------------------------------------'
)
return (correct / len(loader.dataset)) * 100
dtype = torch.cuda.FloatTensor
torch.manual_seed(52)
net = ResNet(BasicBlock, [2, 2, 2, 2]).to(device)
opt = SwatsVanillaGlobal(net.parameters(), lr=0.001)
loss = nn.CrossEntropyLoss().type(dtype)
def adjust_lr(opt, epochs):
base_lr = 0.001
if epochs >= 100:
for ui in opt.param_groups:
ui['lr_decay'] = 10
total_epochs = 200
train_loss = []
train_acc = []
test_acc = []
with torch.no_grad():
for i, j in loader:
inputs, labels = i.to(device), j.to(device)
outputs = model(inputs)
correct = correct + accuracy(outputs, labels)
print("[%d/%d] Test Accuracy : %f" %
(epochs, total_epochs, (correct / len(loader.dataset)) * 100))
print(
'---------------------------------------------------------------------'
)
return (correct / len(loader.dataset)) * 100
dtype = torch.cuda.FloatTensor
torch.manual_seed(52)
net = ResNet(BasicBlock, [2, 2, 2, 2]).to(device)
opt = AdaBound(net.parameters(), lr=0.001, final_lr=0.1)
loss = nn.CrossEntropyLoss().type(dtype)
scheduler = torch.optim.lr_scheduler.StepLR(opt, step_size=100, gamma=0.1)
total_epochs = 200
train_loss = []
train_acc = []
test_acc = []
for s in range(1, total_epochs + 1):
a, b = train(net, s, trainloader)
c = test(net, s, testloader)
train_loss.append(a)
train_acc.append(b)
test_acc.append(c)
scheduler.step()
from Resnet import ResNet
# Constants
# Setting
SEED = 222
BATCH_SIZE = 64
HEIGHT = 137
WIDTH = 236
device = "cuda" if torch.cuda.is_available() else "cpu"
# Call seed to setup for repeatable results
seed_everything(SEED)
# Create Model
model = ResNet().to(device)
# Setup data files to load
data_dir = '../data'
files_train = [f'train_image_data_{fid}.parquet' for fid in range(4)]
# Predict Test values
model.eval()
row_id = []
target = []
dataset = BenDataset(HEIGHT, WIDTH)
for i in range(4):
# Do training here
parquet_df = pd.read_parquet(F'../data/train_image_data_{i}.parquet',
engine='pyarrow')
from BengaliDataset import BengaliDataset
from Resnet import ResNet
from Utils import seed_everything
# Constants
# Setting
SEED = 222
BATCH_SIZE = 64
HEIGHT = 137
WIDTH = 236
device = "cuda" if torch.cuda.is_available() else "cpu"
seed_everything(SEED)
# Create Model
model = ResNet().to(device)
model_path = '../input/resnet18/resnet_saved_weights.pth'
# load model from dict to create test output csv
model.load_state_dict(torch.load(model_path))
# Get Parquet files for Testing
data_dir = '../input/bengaliai-cv19'
files_test = [f'test_image_data_{fid}.parquet' for fid in range(4)]
# Predict Test values
model.eval()
row_id = []
target = []
for fname in files_test:
def __init__(self):
self.resnet_head = ResNet()
self.input = tf.placeholder(tf.float32, shape=(None, 400, 400, 3))
self.labels = tf.placeholder(tf.float32, shape=(None, ))
self.output = self.forward(self.input)
self.lr = 0.0001
class Retrieval(object):
def __init__(self):
self.resnet_head = ResNet()
self.input = tf.placeholder(tf.float32, shape=(None, 400, 400, 3))
self.labels = tf.placeholder(tf.float32, shape=(None, ))
self.output = self.forward(self.input)
self.lr = 0.0001
def forward(self, X):
for layer in self.resnet_head.layers:
X = layer.forward(X)
X = tf.nn.l2_normalize(X, axis=1)
return X
def fit(self, batch_size, traingen, valgen, contrastive_obj, keras_model):
N = len(os.listdir("../Data/Augmented_data/Images/"))
init = tf.variables_initializer(self.resnet_head.get_params())
session = keras.backend.get_session()
self.resnet_head.set_session(session)
session.run(init)
self.session = session
self.resnet_head.copyFromKerasLayers(keras_model.layers)
embedding = self.forward(self.input)
tf.add_to_collection("embedding", embedding)
saver = tf.train.Saver()
margin = 0.4
anchor_left, anchor_right = contrastive_obj.pair_combos(embedding)
labels = contrastive_obj.get_binaray_labels(self.labels)
first_part, second_part, cost = contrastive_obj.contrastive_loss(
labels, anchor_left, anchor_right, margin)
optimizer = tf.train.AdamOptimizer(self.lr)
trainin_op = optimizer.minimize(cost) # current best 0.0001
epoch = 50
n_batches = N // batch_size
LL_train = []
LL_val = []
#self.session.run(tf.variables_initializer(optimizer.variables())) # Gives a wierd cost on batches
self.session.run(tf.global_variables_initializer())
for i in range(epoch):
for j in range(n_batches):
X, Y, _ = next(traingen)
self.session.run(trainin_op,
feed_dict={
self.input: X,
self.labels: Y
})
if j % 100 == 0:
loss_train = self.session.run(cost,
feed_dict={
self.input: X,
self.labels: Y
})
Xval, Yval, val_name = next(valgen)
loss_val = self.session.run(cost,
feed_dict={
self.input: Xval,
self.labels: Yval
})
LL_val.append(loss_val)
LL_train.append(loss_train)
print(
" epoch %d of %d iteration %d of %d , val_loss is %.6f"
% (i, epoch - 1, j, n_batches, loss_val))
print(
" epoch %d of %d iteration %d of %d , train_loss is %.6f"
% (i, epoch - 1, j, n_batches, loss_train))
if not os.path.exists("./Models/Resnet50-plain"):
os.makedirs("./Models/Resnet50-plain")
saver.save(self.session, "./Models/Resnet50-plain/Resnet50-plain")
fig = plt.figure("Resnet trained from scratch")
plt.plot(LL_train, label="train_cost")
plt.plot(LL_val, label="val_cost")
plt.legend()
if not os.path.exists("./Plots"):
os.makedirs("./Plots")
fig.savefig("./Plots/resnet_train",
transparent=True,
bbox_inches="tight",
pad_inches=0)
