From 9d16d3d47372010e209b066d897802bc7aed76f7 Mon Sep 17 00:00:00 2001 From: Vipul Pandey <54221581+vipulpandey12345@users.noreply.github.com> Date: Sun, 14 Apr 2024 13:26:30 -0700 Subject: [PATCH 1/3] added implementation for loss function --- train.py | 25 ++++++++++++++++++++----- 1 file changed, 20 insertions(+), 5 deletions(-) diff --git a/train.py b/train.py index 525c236..6d23641 100644 --- a/train.py +++ b/train.py @@ -8,15 +8,30 @@ - class CustomLossFunction(nn.Module): - def __init__(self): + def __init__(self, margin=1.0): super(CustomLossFunction, self).__init__() - # Initialize your loss components here, if any + self.margin = margin + self.model = SentenceTransformer('distilbert-base-uncased') + self.training_examples = gptdatagenerator.generate_qa() # Assuming gptdatagenerator generates input examples + self.train_dataloader = DataLoader(self.training_examples, shuffle=True, batch_size=16) def forward(self, predictions, targets): - # Define how your loss is computed and return it - + pairwise_distances = self.compute_pairwise_distances(predictions) + loss = self.pairwise_ranking_loss(pairwise_distances, targets) + return loss + + def compute_pairwise_distances(self, predictions): + # Compute pairwise distances (e.g., cosine similarity) between predictions + embeddings = self.model.encode(predictions) # Assuming 'predictions' are texts + pairwise_distances = 1 - torch.cosine_similarity(embeddings.unsqueeze(1), embeddings.unsqueeze(2), dim=-1) + return pairwise_distances + + def pairwise_ranking_loss(self, pairwise_distances, targets): + # Compute pairwise ranking loss + positive_pairs = pairwise_distances[targets == 1] # Positive pairs + negative_pairs = pairwise_distances[targets == 0] # Negative pairs + loss = torch.mean(torch.clamp(self.margin + positive_pairs - negative_pairs, min=0)) return loss From 420da892c33e9824f1073ebada0910d1b44f201b Mon Sep 17 00:00:00 2001 From: Vipul Pandey <54221581+vipulpandey12345@users.noreply.github.com> Date: Sun, 28 Apr 2024 20:13:52 -0700 Subject: [PATCH 2/3] updates to loss func --- train.py | 72 ++++++++++++++++++++++++++++++++++++-------------------- 1 file changed, 47 insertions(+), 25 deletions(-) diff --git a/train.py b/train.py index 6d23641..c749eb0 100644 --- a/train.py +++ b/train.py @@ -1,44 +1,66 @@ ##FILE TAKES IN CHATGPT QUESTION ANSWER EMBEDDED PAIRS AND COMPARES IT TO RAG OUTPUT - import torch +import torch.nn.functional as F import numpy as np - from model import embedder from model import transformer +from torch.utils.data import DataLoader + + + +""" +Computes a MultipleNegativeRankingLoss function +Args: + qa_dataset +Returns: + returns array of cross entropy + + +""" + +def loss_function(logits, labels): + softmax_score = F.softmax(logits, dim = -1) + loss = F.cross_entropy(softmax_score, labels) + return loss.item() + + + + + + -class CustomLossFunction(nn.Module): - def __init__(self, margin=1.0): - super(CustomLossFunction, self).__init__() - self.margin = margin - self.model = SentenceTransformer('distilbert-base-uncased') - self.training_examples = gptdatagenerator.generate_qa() # Assuming gptdatagenerator generates input examples - self.train_dataloader = DataLoader(self.training_examples, shuffle=True, batch_size=16) + # def __init__(self, margin=1.0): + # super(CustomLossFunction, self).__init__() + # self.margin = margin + # self.model = SentenceTransformer('distilbert-base-uncased') + # self.training_examples = gptdatagenerator.generate_qa() # Assuming gptdatagenerator generates input examples + # self.train_dataloader = DataLoader(self.training_examples, shuffle=True, batch_size=16) - def forward(self, predictions, targets): - pairwise_distances = self.compute_pairwise_distances(predictions) - loss = self.pairwise_ranking_loss(pairwise_distances, targets) - return loss + # def forward(self, predictions, targets): + # pairwise_distances = self.compute_pairwise_distances(predictions) + # loss = self.pairwise_ranking_loss(pairwise_distances, targets) + # return loss - def compute_pairwise_distances(self, predictions): - # Compute pairwise distances (e.g., cosine similarity) between predictions - embeddings = self.model.encode(predictions) # Assuming 'predictions' are texts - pairwise_distances = 1 - torch.cosine_similarity(embeddings.unsqueeze(1), embeddings.unsqueeze(2), dim=-1) - return pairwise_distances + # def compute_pairwise_distances(self, predictions): + # # Compute pairwise distances (e.g., cosine similarity) between predictions + # embeddings = self.model.encode(predictions) # Assuming 'predictions' are texts + # pairwise_distances = 1 - torch.cosine_similarity(embeddings.unsqueeze(1), embeddings.unsqueeze(2), dim=-1) + # return pairwise_distances - def pairwise_ranking_loss(self, pairwise_distances, targets): - # Compute pairwise ranking loss - positive_pairs = pairwise_distances[targets == 1] # Positive pairs - negative_pairs = pairwise_distances[targets == 0] # Negative pairs - loss = torch.mean(torch.clamp(self.margin + positive_pairs - negative_pairs, min=0)) - return loss + # def pairwise_ranking_loss(self, pairwise_distances, targets): + # # Compute pairwise ranking loss between similarities and predicted + # positive_pairs = pairwise_distances[targets == 1] + # negative_pairs = pairwise_distances[targets == 0] + # loss = torch.mean(torch.clamp(self.margin + positive_pairs - negative_pairs, min=0)) + # return loss # Assuming you have a defined model, dataloader, and other components embedder = Embedder("microsoft/codebert-base") transformer = Transformer("codellama/CodeLlama-7b-Instruct-hf") -loss_function = CustomLossFunction() +loss_function = lossFunction() optimizer = torch.optim.AdamW(embedder.model.parameters(), lr=5e-5) for epoch in range(num_epochs): From e2c14919357f795df21367ed08cdb1b0ed7ba56b Mon Sep 17 00:00:00 2001 From: Vipul Pandey <54221581+vipulpandey12345@users.noreply.github.com> Date: Wed, 1 May 2024 00:17:17 -0700 Subject: [PATCH 3/3] added some comments --- train.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/train.py b/train.py index c749eb0..ca354e4 100644 --- a/train.py +++ b/train.py @@ -11,9 +11,9 @@ """ Computes a MultipleNegativeRankingLoss function Args: - qa_dataset + logits, labels Returns: - returns array of cross entropy + returns scalar of loss """