# %%

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader
import numpy as np

# %%
class SimpleFFNetwork(nn.Module):
def __init__(self, input_length, hidden_sizes, output_size):
super(SimpleFFNetwork, self).__init__()
self.input_length = input_length
self.hidden_sizes = hidden_sizes
self.output_size = output_size

self.layers = nn.ModuleList()
prev_size = input_length
for hidden_size in hidden_sizes:
self.layers.append(nn.Linear(prev_size, hidden_size))
self.layers.append(nn.ReLU())
prev_size = hidden_size
self.layers.append(nn.Linear(hidden_size, output_size))

def forward(self, x):

norms = torch.norm(x, dim=1, keepdim=True)
x = x / norms
for layer in self.layers:
x = layer(x)
return x

# %%
class SiameseNetwork(nn.Module):

def __init__(self, input_lengths, hidden_sizes_list, output_size):

super(SiameseNetwork, self).__init__()
self.embedding_network1 = SimpleFFNetwork(input_lengths[0],
hidden_sizes_list[0], output_size)
self.embedding_network2 = SimpleFFNetwork(input_lengths[1],
hidden_sizes_list[1], output_size)

def forward(self, x1, x2):

output1 = self.embedding_network1(x1)
output2 = self.embedding_network2(x2)
distance = torch.norm(output1 - output2, dim=1)
return distance

# %%
class TripletDataset(Dataset):

def __init__(self, dataframe):

dataframe['anchor'] = dataframe['anchor'].apply(lambda x:
x/np.linalg.norm(x))
dataframe['positive'] = dataframe['positive'].apply(lambda x:
x/np.linalg.norm(x))
dataframe['negative'] = dataframe['negative'].apply(lambda x:
x/np.linalg.norm(x))
self.dataframe = dataframe

def __len__(self):
return len(self.dataframe)

def __getitem__(self, idx):

anchor = torch.tensor(self.dataframe.iloc[idx]['anchor'],
dtype=torch.float32)
positive = torch.tensor(self.dataframe.iloc[idx]['positive'],
dtype=torch.float32)
negative = torch.tensor(self.dataframe.iloc[idx]['negative'],
dtype=torch.float32)
return anchor, positive, negative

# %%

class BinaryClassifier(nn.Module):
def __init__(self, input_size, hidden_size):
super(BinaryClassifier, self).__init__()
self.fc1 = nn.Linear(input_size, hidden_size)
self.relu = nn.ReLU()
self.fc2 = nn.Linear(hidden_size, 1) # Output size is 1 for binary
classification

def forward(self, x):

x = self.fc1(x)
x = self.relu(x)
x = self.fc2(x)
return x

class SiameseBinaryClassifier(nn.Module):
def __init__(self, siamese_network):
super(SiameseBinaryClassifier, self).__init__()
self.siamese_network = siamese_network
self.fc = nn.Linear(1, 1)

def forward(self, x1, x2):

distance = self.siamese_network(x1, x2)
output = torch.sigmoid(self.fc(distance))
return output

# %%