def __init__(self,
in_channels: int,
out_channels: int,
hidden_channels: int = 64,
num_layers: int = 3,
dropout: float = 0.5):
super().__init__()
self.save_hyperparameters()
self.convs = ModuleList()
for _ in range(num_layers):
mlp = Sequential(
Linear(in_channels, 2 * hidden_channels),
BatchNorm1d(2 * hidden_channels),
ReLU(inplace=True),
Linear(2 * hidden_channels, hidden_channels),
BatchNorm1d(hidden_channels),
ReLU(inplace=True),
)
conv = GINConv(mlp, train_eps=True)
self.convs.append(conv)
in_channels = hidden_channels
self.classifier = Sequential(
Linear(hidden_channels, hidden_channels),
BatchNorm1d(hidden_channels),
ReLU(inplace=True),
Dropout(p=dropout),
Linear(hidden_channels, out_channels),
)
self.train_acc = Accuracy()
self.val_acc = Accuracy()
self.test_acc = Accuracy()
def __init__(self):
super().__init__()
# merced images are (3, 256, 256) (channels, width, height)
self.conv1 = nn.Conv2d(in_channels=3,
out_channels=16,
kernel_size=3,
stride=1,
padding=0)
self.conv2 = nn.Conv2d(in_channels=16,
out_channels=32,
kernel_size=5,
stride=1,
padding=0)
self.conv3 = nn.Conv2d(in_channels=32,
out_channels=48,
kernel_size=3,
stride=2,
padding=0)
self.conv4 = nn.Conv2d(in_channels=48,
out_channels=64,
kernel_size=3,
stride=2,
padding=0)
self.pool = nn.MaxPool2d(2, 2)
self.fc1 = nn.Linear(64 * 3 * 3, 128)
self.train_acc = Accuracy()
self.val_acc = Accuracy(compute_on_step=False)
self.test_acc = Accuracy(compute_on_step=False)
def __init__(self, only_digits=False, input_channels=1, *args, **kwargs):
model = CNN_OriginalFedAvg(only_digits=only_digits, input_channels=input_channels)
super().__init__(*args, model=model, **kwargs)
self.model = model
# self.model.apply(init_weights)
self.accuracy = Accuracy()
self.train_accuracy = Accuracy()
def segmentation_model_attack(model,
model_type,
config,
num_classes=NUM_CLASSES):
"""Salt and pepper augmentation of segmentation images, return accuracy - difference between that and normal is
a measure of resiliency"""
if model_type == "pt":
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
test = perturbed_pt_gis_test_data()
test_set = PT_GISDataset(test)
testloader = DataLoader(test_set, batch_size=int(config['batch_size']))
accuracy = Accuracy()
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
for sample in tqdm(testloader):
cuda_in = sample[0].to(device)
out = model(cuda_in)
output = out.to('cpu').squeeze(1)
accuracy(output, sample[1])
# cuda_in = cuda_in.detach()
# label = label.detach()
return accuracy.compute().item()
elif model_type == "tf":
x_test, y_test = perturbed_tf_gis_test_data()
test_acc = model.evaluate(x_test,
y_test,
batch_size=config['batch_size'])
return test_acc
else:
print("Unknown model type, failure.")
return None
def __init__(self,
encoder,
DATA_PATH,
VAL_PATH,
hidden_dim,
image_size,
seed,
cpus,
transform=SimCLRTransform,
**classifier_hparams):
super().__init__()
self.DATA_PATH = DATA_PATH
self.VAL_PATH = VAL_PATH
self.transform = transform
self.image_size = image_size
self.cpus = cpus
self.seed = seed
self.batch_size = classifier_hparams['batch_size']
self.classifier_hparams = classifier_hparams
self.linear_layer = SSLEvaluator(
n_input=encoder.embedding_size,
n_classes=self.classifier_hparams['num_classes'],
p=self.classifier_hparams['dropout'],
n_hidden=hidden_dim)
self.train_acc = Accuracy()
self.val_acc = Accuracy(compute_on_step=False)
self.encoder = encoder
self.save_hyperparameters()
def __init__(self, num_channel, num_class, chunk_size=2048):
super().__init__()
self.num_channel = num_channel
self.chunk_size = chunk_size
self.network = nn.Sequential(
nn.Conv1d(self.num_channel, 16, 3),
nn.Conv1d(16, 32, 3, padding=1),
nn.MaxPool1d(2, stride=2),
nn.Conv1d(32, 32, 3, padding=1),
nn.MaxPool1d(2, stride=2),
nn.Conv1d(32, 32, 3, padding=1),
nn.MaxPool1d(2, stride=2),
nn.Conv1d(32, 64, 3, padding=1),
nn.MaxPool1d(2, stride=2),
nn.Conv1d(64, 64, 3, padding=1),
nn.MaxPool1d(2, stride=2),
nn.Flatten(),
nn.Linear(4032, 1024),
nn.ReLU(),
nn.Linear(1024, 256),
nn.ReLU(),
nn.Linear(256, 64),
nn.ReLU(),
nn.Linear(64, num_class)
)
self.train_acc = Accuracy()
self.valid_acc = Accuracy()
self.test_acc = Accuracy()
self.train_f1 = FBeta(num_classes=num_class)
self.valid_f1 = FBeta(num_classes=num_class)
self.test_f1 = FBeta(num_classes=num_class)
self.predictions = []
self.targets = []
def __init__(self, vocab_size, embedding_dim=32):
super().__init__()
self.embeddings_layer = nn.Embedding(vocab_size, embedding_dim)
self.loss = nn.BCEWithLogitsLoss()
self.valid_accuracy = Accuracy()
self.test_accuracy = Accuracy()
def __init__(self, lr: float = 0.01, num_blocks: int = 5):
super().__init__()
self.lr = lr
self.num_blocks = num_blocks
self.train_acc = Accuracy()
self.valid_acc = Accuracy()
self.test_acc = Accuracy()
class IrisClassification(pl.LightningModule):
def __init__(self, **kwargs):
super().__init__()
self.train_acc = Accuracy()
self.val_acc = Accuracy()
self.test_acc = Accuracy()
self.args = kwargs
self.fc1 = nn.Linear(4, 10)
self.fc2 = nn.Linear(10, 10)
self.fc3 = nn.Linear(10, 3)
self.cross_entropy_loss = nn.CrossEntropyLoss()
self.lr = kwargs.get("lr", 0.01)
self.momentum = kwargs.get("momentum", 0.9)
self.weight_decay = kwargs.get("weight_decay", 0.1)
def forward(self, x):
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = F.relu(self.fc3(x))
return x
def configure_optimizers(self):
return torch.optim.SGD(self.parameters(),
lr=self.lr,
momentum=self.momentum,
weight_decay=self.weight_decay)
def training_step(self, batch, batch_idx):
x, y = batch
logits = self.forward(x)
loss = self.cross_entropy_loss(logits, y)
self.train_acc(torch.argmax(logits, dim=1), y)
self.log("train_acc",
self.train_acc.compute(),
on_step=False,
on_epoch=True)
self.log("loss", loss)
return {"loss": loss}
def validation_step(self, batch, batch_idx):
x, y = batch
logits = self.forward(x)
loss = F.cross_entropy(logits, y)
self.val_acc(torch.argmax(logits, dim=1), y)
self.log("val_acc", self.val_acc.compute())
self.log("val_loss", loss, sync_dist=True)
def test_step(self, batch, batch_idx):
x, y = batch
logits = self.forward(x)
loss = F.cross_entropy(logits, y)
self.test_acc(torch.argmax(logits, dim=1), y)
self.log("test_loss", loss)
self.log("test_acc", self.test_acc.compute())
def __init__(self, ft_embedding_dim, hidden_dim=64):
super().__init__()
self.lstm_layer = nn.LSTM(ft_embedding_dim, hidden_dim, batch_first=True, bidirectional=True)
self.dropout_layer = nn.Dropout(0.2)
self.out_layer = nn.Linear(hidden_dim * 2, 1)
self.loss = nn.BCEWithLogitsLoss()
self.valid_accuracy = Accuracy()
self.test_accuracy = Accuracy()
def str_accuracy(m: Accuracy, detail: bool = False):
backup = m.correct, m.total
metric = m.compute()
m.correct, m.total = backup
if math.isnan(metric) or math.isinf(metric):
return 'N/A'
elif not detail:
return f'{metric * 100:.2f}%'
else:
return f'{metric * 100:.2f}%(= {m.correct}/{m.total})'
def test_wrong_params(top_k, threshold):
preds, target = _input_mcls_prob.preds, _input_mcls_prob.target
with pytest.raises(ValueError):
acc = Accuracy(threshold=threshold, top_k=top_k)
acc(preds, target)
acc.compute()
with pytest.raises(ValueError):
accuracy(preds, target, threshold=threshold, top_k=top_k)
def __init__(self):
super().__init__()
for i in range(3):
setattr(self, f"layer_{i}", nn.Linear(32, 32))
setattr(self, f"layer_{i}a", torch.nn.ReLU())
setattr(self, "layer_end", nn.Linear(32, 3))
self.train_acc = Accuracy()
self.valid_acc = Accuracy()
self.test_acc = Accuracy()
def __init__(self, **kwargs):
super().__init__()
self.train_acc = Accuracy()
self.val_acc = Accuracy()
self.test_acc = Accuracy()
self.args = kwargs
self.fc1 = nn.Linear(4, 10)
self.fc2 = nn.Linear(10, 10)
self.fc3 = nn.Linear(10, 3)
self.cross_entropy_loss = nn.CrossEntropyLoss()
def __init__(self,
num_classes,
*args,
weights=None,
pretrain=True,
**kwargs):
model = torchvision.models.resnet18(pretrained=pretrain)
model.fc = Linear(in_features=512, out_features=num_classes, bias=True)
super().__init__(*args, model=model, **kwargs)
self.model = model
self.accuracy = Accuracy()
self.train_accuracy = Accuracy()
self.criterion = CrossEntropyLoss(weight=weights)
def __init__(
self,
num_layers: int = 2,
hidden_channels: int = 128,
heads: int = 8,
groups: int = 16,
dropout: float = 0.8,
cached: bool = False,
num_features: int = None,
num_classes: int = None,
):
super().__init__()
assert num_features is not None
assert num_classes is not None
# utils from Lightning to save __init__ arguments
self.save_hyperparameters()
hparams = self.hparams
# Instantiate metrics
self.val_acc = Accuracy(hparams["num_classes"])
self.test_acc = Accuracy(hparams["num_classes"])
# Define DNA graph convolution model
self.hidden_channels = hparams["hidden_channels"]
self.lin1 = nn.Linear(hparams["num_features"],
hparams["hidden_channels"])
# Create ModuleList to hold all convolutions
self.convs = nn.ModuleList()
# Iterate through the number of layers
for _ in range(hparams["num_layers"]):
# Create a DNA Convolution - This graph convolution relies on MultiHead Attention mechanism
# to route information similar to Transformers.
# https://github.com/rusty1s/pytorch_geometric/blob/master/torch_geometric/nn/conv/dna_conv.py#L172
self.convs.append(
DNAConv(
hparams["hidden_channels"],
hparams["heads"],
hparams["groups"],
dropout=hparams["dropout"],
cached=False,
))
# classification MLP
self.lin2 = nn.Linear(hparams["hidden_channels"],
hparams["num_classes"],
bias=False)
def __init__(self, cfg: Config) -> None:
super().__init__() # type: ignore
self.logger: Union[LoggerCollection, WandbLogger, Any]
self.wandb: Run
self.cfg = cfg
self.model = ConvNet(self.cfg)
self.criterion = nn.CrossEntropyLoss()
# Metrics
self.train_acc = Accuracy()
self.val_acc = Accuracy()
def __init__(self, conf: DictConfig):
super().__init__()
self.trn_metric = Accuracy()
self.val_metric = Accuracy()
self.tst_metric = Accuracy()
self.save_hyperparameters(conf)
# instantiate objects
self.model = Net(self.hparams)
self.criterion = instantiate(self.hparams.loss)
self.mixfunction = instantiate(self.hparams.mixmethod)
if self.mixfunction is not None:
_logger.info(f"Training with {self.mixfunction}")
def __init__(self,
num_classes,
*args,
weights=None,
pretrain=True,
**kwargs):
model = torchvision.models.mobilenet_v2(pretrained=pretrain)
model.classifier = Sequential(
Dropout(p=0.2, inplace=False),
Linear(in_features=1280, out_features=num_classes, bias=True))
super().__init__(*args, model=model, **kwargs)
self.model = model
self.accuracy = Accuracy()
self.train_accuracy = Accuracy()
self.criterion = CrossEntropyLoss(weight=weights)
def __init__(self):
super().__init__()
num_classes = 9
weight = torch.tensor([
0.01030928,
0.00552486,
0.00344828,
0.01388889,
0.02222222,
0.01204819,
0.02272727,
0.00307692,
0.00055249,
])
self.criterion = nn.CrossEntropyLoss(weight=weight)
# self.criterion = nn.CrossEntropyLoss()
self.metrics = {
"accuracy": Accuracy(),
"recall_macro": Recall(num_classes=num_classes, average="macro"),
"precision_macro": Precision(num_classes=num_classes,
average="macro"),
}
self.classifier = nn.Sequential(
nn.Linear(768, 256),
nn.Dropout(0.5),
nn.ReLU(),
nn.Linear(256, 128),
nn.Dropout(0.5),
nn.ReLU(),
nn.Linear(128, num_classes),
)
def __init__(self, max_batch_len, learning_rate, **kwargs):
super().__init__()
self.input_size = max_batch_len
self.feature_size = 12
self.flatten_size = self.input_size * self.feature_size
self.hidden_size = 128
self.d = 10
self.learning_rate = learning_rate
self.criterion_class = torch.nn.BCELoss()
self.criterion_ae = torch.nn.MSELoss()
self.encoder = nn.Sequential(
nn.Linear(self.flatten_size, self.hidden_size), nn.ReLU(),
nn.Linear(self.hidden_size, self.d))
self.decoder = nn.Sequential(
nn.Linear(self.d, self.hidden_size), nn.ReLU(),
nn.Linear(self.hidden_size, self.flatten_size))
self.classifier = nn.Sequential(nn.Linear(self.d, 1), nn.Dropout(0.3),
nn.Sigmoid())
self.save_hyperparameters()
self.accuracy = Accuracy()
def test_topk_accuracy(preds, target, exp_result, k, subset_accuracy):
topk = Accuracy(top_k=k, subset_accuracy=subset_accuracy)
for batch in range(preds.shape[0]):
topk(preds[batch], target[batch])
assert topk.compute() == exp_result
# Test functional
total_samples = target.shape[0] * target.shape[1]
preds = preds.view(total_samples, 4, -1)
target = target.view(total_samples, -1)
assert accuracy(preds, target, top_k=k,
subset_accuracy=subset_accuracy) == exp_result
def __init__(
self,
num_classes,
backbone="resnet18",
num_features: int = None,
pretrained=True,
loss_fn: Callable = F.cross_entropy,
optimizer: Type[torch.optim.Optimizer] = torch.optim.SGD,
metrics: Union[Callable, Mapping, Sequence, None] = (Accuracy()),
learning_rate: float = 1e-3,
):
super().__init__(
model=None,
loss_fn=loss_fn,
optimizer=optimizer,
metrics=metrics,
learning_rate=learning_rate,
)
self.save_hyperparameters()
self.backbone, num_features = backbone_and_num_features(
backbone, pretrained)
self.head = nn.Sequential(
nn.AdaptiveAvgPool2d((1, 1)),
nn.Flatten(),
nn.Linear(num_features, num_classes),
)
def __init__(self, encoder, DATA_PATH, batch_size, val_split, hidden_dims,
train_transform, val_transform, num_workers, **kwargs):
super().__init__()
self.DATA_PATH = DATA_PATH
self.val_split = val_split
self.batch_size = batch_size
self.hidden_dims = hidden_dims
self.train_transform = train_transform
self.val_transform = val_transform
self.num_workers = num_workers
#data stuff
shutil.rmtree('split_data', ignore_errors=True)
if not (path.isdir(f"{self.DATA_PATH}/train")
and path.isdir(f"{self.DATA_PATH}/val")):
splitfolders.ratio(self.DATA_PATH,
output=f"split_data",
ratio=(1 - self.val_split, self.val_split),
seed=10)
self.DATA_PATH = 'split_data'
print(
'automatically splitting data into train and validation data')
self.num_classes = len(os.listdir(f'{self.DATA_PATH}/train'))
#model stuff
self.eval_acc = Accuracy()
self.encoder, self.embedding_size = load_encoder(encoder, kwargs)
self.fc1 = nn.Linear(self.embedding_size, self.hidden_dims)
self.fc2 = nn.Linear(self.hidden_dims, self.num_classes)
def __init__(self, device, num_classes, topK=3):
if not pl:
return
self.device = device
self.topK = topK
# https://github.com/PyTorchLightning/metrics/blob/master/torchmetrics/classification/f_beta.py#L221
#mdmc_average = "samplewise"
mdmc_average = "global"
val_metrics = {
'hamming_dist':
HammingDistance() if HammingDistance is not None else None,
'iou':
IoU(num_classes=num_classes),
'auroc':
AUROC(num_classes=num_classes),
'f1':
F1(num_classes=num_classes,
multilabel=True,
mdmc_average=mdmc_average),
'avg_precision':
AveragePrecision(num_classes=num_classes),
#'acc': Accuracy(num_classes=num_classes, mdmc_average = mdmc_average)
}
for k in range(1, topK + 1):
val_metrics["top%d" % k] = Accuracy(top_k=k)
val_metrics["top%d_f1" % k] = F1(top_k=k)
self.val_metrics = torch.nn.ModuleDict(val_metrics).to(self.device)
self.class_names = list(range(num_classes))
self.label_binarizer = MultiLabelBinarizer(classes=self.class_names)
def __init__(
self,
embedding_dim: Optional[int] = None,
backbone: str = "swav-imagenet",
pretrained: bool = True,
loss_fn: Callable = F.cross_entropy,
optimizer: Type[torch.optim.Optimizer] = torch.optim.SGD,
metrics: Union[Callable, Mapping, Sequence, None] = (Accuracy()),
learning_rate: float = 1e-3,
pooling_fn: Callable = torch.max
):
super().__init__(
model=None,
loss_fn=loss_fn,
optimizer=optimizer,
metrics=metrics,
learning_rate=learning_rate,
)
self.save_hyperparameters()
self.backbone_name = backbone
self.embedding_dim = embedding_dim
assert pooling_fn in [torch.mean, torch.max]
self.pooling_fn = pooling_fn
self.backbone, num_features = backbone_and_num_features(backbone, pretrained)
if embedding_dim is None:
self.head = nn.Identity()
else:
self.head = nn.Sequential(
nn.Flatten(),
nn.Linear(num_features, embedding_dim),
)
rank_zero_warn('embedding_dim is not None. Remember to finetune first!')
def __init__(self, model, criterion, optimizer, scheduler=None):
super(TaskCRAFT, self).__init__()
self.model = model
self.criterion = criterion
self.optimizer = optimizer
self.scheduler = scheduler
self.metric = Accuracy()
def __init__(self, seq_len, max_batch_len, learning_rate, **kwargs):
super().__init__()
self.n_features = 12
self.hidden_size = 256
self.num_layers = 5
self.dropout = 0.5
self.seq_len = seq_len
self.max_batch_size = max_batch_len
self.criterion = torch.nn.BCELoss()
self.learning_rate = learning_rate
self.batch_size = int(self.max_batch_size / self.seq_len)
self.output_size = 1
self.fc_size_1 = 50
self.fc_size_2 = 10
self.lstm = nn.LSTM(input_size=self.n_features,
hidden_size=self.hidden_size,
num_layers=self.num_layers,
dropout=self.dropout,
batch_first=True)
self.activation = nn.LeakyReLU()
self.fc1 = nn.Linear(self.hidden_size, self.fc_size_1)
self.fc2 = nn.Linear(self.fc_size_1, self.fc_size_2)
self.fc3 = nn.Linear(self.fc_size_2, self.output_size)
self.sigmoid = nn.Sigmoid()
self.save_hyperparameters()
self.accuracy = Accuracy()
def __init__(self, cfg, fold=0):
super().__init__()
self.fold = fold
self.cfg = cfg
trn_params = cfg['train_params']
self.batch_size = get_or_default(trn_params, 'batch_size', 16)
self.num_workers = get_or_default(trn_params, 'num_workers', 2)
self.aug_type = get_or_default(cfg, 'aug', '0')
self.margin_start = get_or_default(cfg, 'margin_start', 10)
self.csv_path = get_or_default(cfg, 'csv_path',
'input/train_folds.csv')
self.trn_path = get_or_default(cfg, 'image_path', 'input/train')
self.le = LabelEncoder()
train = pd.read_csv(self.csv_path)
self.le.fit(train.label_group)
model = get_or_default(cfg, 'model', 'ShopeeModelTimm')
self.model = model
num_classes = len(self.le.classes_)
if model == 'ShopeeModelTimm':
self.model = ShopeeModelTimm(num_classes, backbone=cfg['backbone'])
elif model == 'ShopeeModelResnext':
self.model = ShopeeModelResnext(num_classes=num_classes)
else:
raise Exception('unsupported model {}'.format(model))
self.crit = nn.CrossEntropyLoss()
self.acc = Accuracy()
print('using fold', self.fold)
def __init__(self, num_classes: int, *args, **kwargs):
super().__init__(model=OmniglotModel(num_classes=num_classes),
*args,
**kwargs)
self.model.apply(init_weights)
self.criterion = nn.CrossEntropyLoss(reduction='sum')
self.accuracy = Accuracy()
