Update README.md

README.md

@@ -1,3 +1,129 @@
 ---
 license: cc
 ---
+
+This is a classifier fine_tuned from camemBERT that takes as input a text and a question and returns 1 if the text is helpful to answer the question and 0 else. 
+the input should be formatted as tokenized_paragraph + sep_token + tokenized_question.
+
+class QuestionAnswerDataset(Dataset):
+    def __init__(self, dataframe, tokenizer, max_length=512):
+        self.dataframe = dataframe
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+
+    def __len__(self):
+        return len(self.dataframe)
+
+    def __getitem__(self, idx):
+        # Extract data
+        row = self.dataframe.iloc[idx]
+        paragraph = row['paragraph']
+        is_positive = np.random.random()
+        if is_positive > 0.5:
+            is_positive = 1
+        else:
+            is_positive = 0
+
+        if is_positive:
+            question = row['positive_questions'][np.random.randint(len(row['positive_questions']))]
+            label = 1
+        else:
+            question = row['negative_questions'][np.random.randint(len(row['negative_questions']))]
+            label = 0
+
+        # print('paragraph', paragraph)
+        # print('question', question)
+
+        # Tokenize
+        tokenized_paragraph = self.tokenizer(
+            paragraph,
+            truncation=True,
+            max_length=self.max_length,
+            return_tensors="pt"
+        )
+        tokenized_question = self.tokenizer(
+            question,
+            truncation=True,
+            max_length=self.max_length,
+            return_tensors="pt"
+        )
+        total_length = tokenized_paragraph['input_ids'].shape[1] + tokenized_question['input_ids'].shape[1]+2
+        if total_length > self.max_length:
+            tokenized_paragraph['input_ids'] = tokenized_paragraph['input_ids'][:, :self.max_length - tokenized_question['input_ids'].shape[1]-2]
+            tokenized_paragraph['attention_mask'] = tokenized_paragraph['attention_mask'][:, :self.max_length - tokenized_question['input_ids'].shape[1]-2]
+
+
+        # print('-'*100)
+        # print('tokenized_paragraph', tokenized_paragraph)
+        # print('tokenized_question', tokenized_question)
+        # print('total_length', total_length)
+        # print('-'*100)
+
+        sep_token = torch.tensor([[self.tokenizer.sep_token_id]]).to(tokenized_paragraph['input_ids'].device)
+
+
+        # Concatenate tokenized inputs
+        tokenized_input_ids = torch.cat((tokenized_paragraph['input_ids'], sep_token, tokenized_question['input_ids']),
+                                        dim=1)
+        tokenized_attention_mask = torch.cat(
+            [tokenized_paragraph['attention_mask'], torch.ones_like(sep_token), tokenized_question['attention_mask']],
+            dim=1)
+
+        # print("tokenized_input_ids shape:", tokenized_input_ids.shape)
+        # print("tokenized_attention_mask shape:", tokenized_attention_mask.shape)
+
+        # Make sure the length does not exceed max_length
+        if tokenized_input_ids.size(1) > self.max_length:
+            tokenized_input_ids = tokenized_input_ids[:, :self.max_length]
+            tokenized_attention_mask = tokenized_attention_mask[:, :self.max_length]
+
+        return tokenized_input_ids.squeeze(0), tokenized_attention_mask.squeeze(0), torch.tensor(label)
+
+
+# Tokenizer
+tokenizer = AutoTokenizer.from_pretrained("camembert/camembert-large")
+
+#split test_train test_size = 0.2
+from sklearn.model_selection import train_test_split
+
+train_df, test_df = train_test_split(df, test_size=0.2, random_state=42)
+
+
+# Dataset
+train_dataset = QuestionAnswerDataset(train_df, tokenizer)
+test_dataset = QuestionAnswerDataset(test_df, tokenizer)
+
+def custom_collate_fn(batch):
+    input_ids = [item[0] for item in batch]
+    attention_masks = [item[1] for item in batch]
+    labels = torch.tensor([item[2] for item in batch])
+
+    input_ids_padded = pad_sequence(input_ids, batch_first=True, padding_value=tokenizer.pad_token_id)
+    attention_masks_padded = pad_sequence(attention_masks, batch_first=True, padding_value=0)
+
+    return input_ids_padded, attention_masks_padded, labels
+
+
+# DataLoader
+train_dataloader = DataLoader(train_dataset, batch_size=64, shuffle=True, collate_fn=custom_collate_fn)
+test_dataloader = DataLoader(test_dataset, batch_size=64, shuffle=True, collate_fn=custom_collate_fn)
+
+# Assuming 'myDataloader' is your DataLoader
+for i, (input_ids, attention_masks, labels) in enumerate(train_dataloader):
+    print(f"Batch {i+1}")
+    print("Input IDs:", input_ids)
+    print("Input IDs Shape:", input_ids.shape)
+    print("Attention Masks:", attention_masks)
+    print("Attention Masks Shape:", attention_masks.shape)
+    print("Labels:", labels)
+    print("Labels Shape:", labels.shape)
+    print("-" * 50)
+
+    # Optionally, stop after the first few batches
+    if i == 1:  # Change this number to control how many batches to print
+        break
+
+
+# Model (for binary classification)
+camembertModel = AutoModelForSequenceClassification.from_pretrained("camembert/camembert-large", num_labels=1)
+