Rename calcXXX to calculateXXX

hyperswap/src/helper.py

@@ -34,7 +34,7 @@ def convert_tensor(input_tensor : Tensor, convert_template : ConvertTemplate) ->
 	return output_tensor
 
 
-def calc_embedding(embedder : EmbedderModule, input_tensor : Tensor, padding : Padding) -> Embedding:
+def calculate_embedding(embedder : EmbedderModule, input_tensor : Tensor, padding : Padding) -> Embedding:
 	crop_tensor = convert_tensor(input_tensor, 'arcface_128_to_arcface_112_v2')
 	crop_tensor = nn.functional.interpolate(crop_tensor, size = 112, mode = 'area')
 	crop_tensor[:, :, :padding[0], :] = 0

hyperswap/src/inferencing.py

@@ -3,7 +3,7 @@ import configparser
 import torch
 from torchvision import io
 
-from .helper import calc_embedding
+from .helper import calculate_embedding
 from .training import HyperSwapTrainer
 
 CONFIG_PARSER = configparser.ConfigParser()
@@ -22,6 +22,6 @@ def infer() -> None:
 
 	source_tensor = io.read_image(config_source_path)
 	target_tensor = io.read_image(config_target_path)
-	source_embedding = calc_embedding(embedder, source_tensor, (0, 0, 0, 0))
+	source_embedding = calculate_embedding(embedder, source_tensor, (0, 0, 0, 0))
 	output_tensor, _ = generator(source_embedding, target_tensor)
 	io.write_jpeg(output_tensor, config_output_path)

hyperswap/src/models/loss.py

@@ -6,7 +6,7 @@ from pytorch_msssim import ssim
 from torch import Tensor, nn
 from torchvision import transforms
 
-from ..helper import calc_embedding, dilate_mask
+from ..helper import calculate_embedding, dilate_mask
 from ..types import EmbedderModule, FaceMaskerModule, Feature, GazerModule, Loss, Mask
 
 
@@ -97,8 +97,8 @@ class ReconstructionLoss(nn.Module):
 
 	def forward(self, source_tensor : Tensor, target_tensor : Tensor, output_tensor : Tensor) -> Tuple[Loss, Loss]:
 		with torch.no_grad():
-			source_embedding = calc_embedding(self.embedder, source_tensor, (0, 0, 0, 0))
-			target_embedding = calc_embedding(self.embedder, target_tensor, (0, 0, 0, 0))
+			source_embedding = calculate_embedding(self.embedder, source_tensor, (0, 0, 0, 0))
+			target_embedding = calculate_embedding(self.embedder, target_tensor, (0, 0, 0, 0))
 
 		has_similar_identity = torch.cosine_similarity(source_embedding, target_embedding) > 0.8
 
@@ -120,8 +120,8 @@ class IdentityLoss(nn.Module):
 		self.embedder = embedder
 
 	def forward(self, source_tensor : Tensor, output_tensor : Tensor) -> Tuple[Loss, Loss]:
-		output_embedding = calc_embedding(self.embedder, output_tensor, (30, 0, 10, 10))
-		source_embedding = calc_embedding(self.embedder, source_tensor, (30, 0, 10, 10))
+		output_embedding = calculate_embedding(self.embedder, output_tensor, (30, 0, 10, 10))
+		source_embedding = calculate_embedding(self.embedder, source_tensor, (30, 0, 10, 10))
 		identity_loss = (1 - torch.cosine_similarity(source_embedding, output_embedding)).mean()
 		weighted_identity_loss = identity_loss * self.config_identity_weight
 		return identity_loss, weighted_identity_loss
@@ -169,7 +169,7 @@ class MaskLoss(nn.Module):
 		self.mse_loss = nn.MSELoss()
 
 	def forward(self, target_tensor : Tensor, output_mask : Mask) -> Tuple[Loss, Loss]:
-		target_mask = self.calc_mask(target_tensor)
+		target_mask = self.calculate_mask(target_tensor)
 
 		if self.config_mask_factor > 0:
 			target_mask = dilate_mask(target_mask, self.config_mask_factor)
@@ -180,7 +180,7 @@ class MaskLoss(nn.Module):
 		weighted_mask_loss = mask_loss * self.config_mask_weight
 		return mask_loss, weighted_mask_loss
 
-	def calc_mask(self, target_tensor : Tensor) -> Tensor:
+	def calculate_mask(self, target_tensor : Tensor) -> Tensor:
 		target_tensor = torch.nn.functional.interpolate(target_tensor, (256, 256), mode = 'bilinear')
 		target_tensor = (target_tensor.clip(-1, 1) + 1) * 0.5
 

hyperswap/src/training.py

@@ -14,7 +14,7 @@ from torch.utils.data import ConcatDataset, Dataset, random_split
 from torchdata.stateful_dataloader import StatefulDataLoader
 
 from .dataset import DynamicDataset
-from .helper import apply_noise, calc_embedding, erode_mask, overlay_mask
+from .helper import apply_noise, calculate_embedding, erode_mask, overlay_mask
 from .models.discriminator import Discriminator
 from .models.generator import Generator
 from .models.loss import AdversarialLoss, CycleLoss, DiscriminatorLoss, FeatureLoss, GazeLoss, IdentityLoss, MaskLoss, ReconstructionLoss
@@ -101,8 +101,8 @@ class HyperSwapTrainer(LightningModule):
 		do_update = (batch_index + 1) % self.config_accumulate_size == 0
 		generator_optimizer, discriminator_optimizer = self.optimizers() #type:ignore[attr-defined]
 		generator_scheduler, discriminator_scheduler = self.lr_schedulers() #type:ignore[attr-defined]
-		source_embedding = calc_embedding(self.generator_embedder, source_tensor, (0, 0, 0, 0))
-		target_embedding = calc_embedding(self.generator_embedder, target_tensor, (0, 0, 0, 0))
+		source_embedding = calculate_embedding(self.generator_embedder, source_tensor, (0, 0, 0, 0))
+		target_embedding = calculate_embedding(self.generator_embedder, target_tensor, (0, 0, 0, 0))
 
 		if self.config_noise_factor > 0:
 			source_embedding = apply_noise(source_embedding, self.config_noise_factor)
@@ -176,9 +176,9 @@ class HyperSwapTrainer(LightningModule):
 
 	def validation_step(self, batch : Batch, batch_index : int) -> Tensor:
 		source_tensor, target_tensor = batch
-		source_embedding = calc_embedding(self.generator_embedder, source_tensor, (0, 0, 0, 0))
+		source_embedding = calculate_embedding(self.generator_embedder, source_tensor, (0, 0, 0, 0))
 		output_tensor, _ = self.forward(source_embedding, target_tensor)
-		output_embedding = calc_embedding(self.generator_embedder, output_tensor, (0, 0, 0, 0))
+		output_embedding = calculate_embedding(self.generator_embedder, output_tensor, (0, 0, 0, 0))
 		validation_score = (nn.functional.cosine_similarity(source_embedding, output_embedding).mean() + 1) * 0.5
 		self.log('validation_score', validation_score, sync_dist = True, prog_bar = True)
 		return validation_score