Commit 1b57123d authored by Delvallez Delvallez's avatar Delvallez Delvallez

Premiers Travaux sur perturbation pour MechIR

parent 72bb425b
from mechir import Dot
from mechir.data import MechIRDataset, DotDataCollator
from mechir.perturb import perturbation
from mechir.plotting import plot_components
import torch
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
from matplotlib.ticker import MaxNLocator
import seaborn as sns
#Perturbations parametrées
def param_append(doc, mot="microwave"):
return doc + " " + mot
def param_prepend(doc, mot="microwave"):
return mot+ " " + doc
def param_replace(doc, mot_orig="microwave", mot_rempl="toaster"):
return doc.replace(mot_orig, mot_rempl)
# génération des perturbations à produire
def generer_transformations(fichier_regles):
transformations = []
perts_name=[]
with open(fichier_regles, "r", encoding="utf-8") as f:
for ligne in f:
ligne = ligne.strip()
if not ligne:
continue
# Cas 1 : remplacement ou suppression (mot->mot ou mot->)
if "->" in ligne:
gauche, droite = ligne.split("->", 1)
mot_present = gauche.strip()
mot_remplacant = droite.strip()
print(f"{gauche}, {droite}")
print(f"{mot_present}, {mot_remplacant}")
transformations.append( ("replace", mot_present, mot_remplacant)
)
perts_name.append(ligne)
# Cas 2 : ajout en début (mot+)
elif ligne.endswith("+"):
mot = ligne[:-1].strip()
transformations.append( ("prepend", mot))
perts_name.append(ligne)
# Cas 3 : ajout en fin (+mot)
elif ligne.startswith("+"):
mot = ligne[1:].strip()
transformations.append( ("prepend", mot))
perts_name.append(ligne)
else:
raise ValueError(f"Règle non reconnue : {ligne}")
return transformations, perts_name
# Helper function to print query/baseline document/perturbed document triplets
def pretty_print_triplets(batch, tokenizer, num=1):
"""
Pretty prints triplets of queries, documents, and their corresponding perturbed documents from a batch.
Args:
batch (dict): A dictionary containing 'queries', 'documents', and 'perturbed_documents' from a DataLoader.
tokenizer: The tokenizer used to decode the input IDs.
num (int): Number of examples to show per batch.
"""
# Get the queries, documents, and perturbed documents from the batch
queries = batch["queries"]
documents = batch["documents"]
perturbed_documents = batch["perturbed_documents"]
# Loop through number of examples to show in batch
for i in range(len(documents["input_ids"][:num])):
# Get the input IDs
query_ids = queries["input_ids"][i]
original_ids = documents["input_ids"][i]
perturbed_ids = perturbed_documents["input_ids"][i]
# Decode the input IDs to text
query_decoded = tokenizer.decode(query_ids.tolist(), skip_special_tokens=False).replace("[PAD]", "").strip()
original_doc_decoded = tokenizer.decode(original_ids.tolist(), skip_special_tokens=False).replace("[PAD]", "").strip()
perturbed_doc_decoded = tokenizer.decode(perturbed_ids.tolist(), skip_special_tokens=False).replace("[PAD]", "").strip()
# Pretty print
# print(f"Triplet {i + 1}:")
print("Query:", query_decoded)
print("Baseline Document:", original_doc_decoded)
print("Perturbed Document:", perturbed_doc_decoded)
print("=" * 50) # Separator for clarity
# Helper function to calculate and store performances
def calculate_performance(model, dataloader, baseline_performance, perturbed_performance):
for i, batch in enumerate(dataloader):
# Get the queries, documents, and perturbed documents from the batch
queries = batch["queries"]
documents = batch["documents"]
perturbed_documents = batch["perturbed_documents"]
# Encode queries, baseline, and perturbed documents
queries_encoded = model.forward(**queries) # [batch_size x hidden_dim]
baseline_encoded = model.forward(**documents) # [batch_size x hidden_dim]
perturbed_encoded = model.forward(**perturbed_documents) # [batch_size x hidden_dim]
# Calculate scores
baseline_scores = torch.sum(queries_encoded.unsqueeze(1) * baseline_encoded.unsqueeze(0), dim=2)
perturbed_scores = torch.sum(queries_encoded.unsqueeze(1) * perturbed_encoded.unsqueeze(0), dim=2)
# Append flattened scores to the performance lists
baseline_performance += baseline_scores.flatten().tolist()
perturbed_performance += perturbed_scores.flatten().tolist()
def plot_scores(baseline_scores, perturbed_scores, transformation_descr):
fig, ax = plt.subplots(1, 1, figsize=(15, 4), sharey=True)
fig.suptitle('Distribution of Baseline vs Perturbed Scores '+transformation_descr, fontsize=16)
sns.kdeplot(baseline_scores, label='Baseline', color='#D55E00', fill=True, ax=ax, alpha=0.5)
sns.kdeplot(perturbed_scores, label='Perturbed', color='#009E73', fill=True, ax=ax, alpha=0.5)
ax.set_ylabel('Density')
ax.legend()
#plt.tight_layout(rect=[0, 0, 1, 0.95]) # Adjust layout to make space for the title
plt.savefig('res/'+ (transformation_descr.replace(">", ""))+'_scores.png')
# Récup du modèle
dot_model_name = "sebastian-hofstaetter/distilbert-dot-tas_b-b256-msmarco"
dot_model = Dot(dot_model_name)
# Recup dataset
dataset = MechIRDataset("vaswani", query_id_subset=["1"])
print("Number of query,doc pairs in dataset:", len(dataset))
print("Query:", dataset._get_query("1"))
perts, perts_name = generer_transformations("perturbations.txt")
for i in range(len(perts)):
if perts[i][0]=="replace":
pert_fun = perturbation(lambda texte : param_replace(texte, perts[i][1], perts[i][2]))
elif perts[i][0]=="prepend":
pert_fun = perturbation(lambda texte : param_prepend(texte, perts[i][1]))
else:
pert_fun = perturbation(lambda texte : param_append(texte, perts[i][1]))
param_pert_dot_collator = DotDataCollator(dot_model.tokenizer, pert_fun, q_max_length=None, d_max_length=None, perturb_type=perts[i][0])
param_pert_dot_dataloader = DataLoader(dataset, batch_size=16, collate_fn=param_pert_dot_collator)
param_pert_batch = next(iter(param_pert_dot_dataloader))
print("PERTURBATION",i,":", perts_name[i])
pretty_print_triplets(param_pert_batch, dot_model.tokenizer, num=2)
baseline_perf = []
perturbed_perf = []
calculate_performance(dot_model, param_pert_dot_dataloader, baseline_perf, perturbed_perf)
plot_scores(baseline_perf, perturbed_perf, perts_name[i])
\ No newline at end of file
#!/usr/bin/env python3
"""
À partie d'une liste de requête et d'une liste de documents (tous deux des strings) fourni dans deux csv
Extraction du vocabulaire présent dans les queries (df.vocab) et des statistiques suivantes pour chaque mot:
- idf : log10((nombre de documents + 1)/(nombre de documents contenant le mot+1))
- query_freq2 : nombre d'occurrence du mot dans les queries (2 occurrences dans une même query compte pour 2)
- docs_freq : nombre d'occurrence du mot dans les documents (2 occurrences dans un même documents compte pour 1)
"""
import sys
import csv
import re
from collections import Counter
import pandas as pd
from math import log10
def extraire_csv(fichier_csv):
phrases = []
with open(fichier_csv, newline='', encoding='utf-8') as f:
lecteur = csv.DictReader(f, fieldnames=["entrees"])
for ligne in lecteur:
phrases.append(ligne["entrees"])
return phrases
def queries_vocab_freq(queries):
# Extraire les mots (lettres + chiffres)
mots = re.findall(r"(\b\w+\b)|([-+]?[0-9]+)", ' '.join(queries).lower())
# Compter les occurrences
compteur = Counter(mots)
# Trier du plus fréquent au moins fréquent
tableau = pd.DataFrame(columns=["mot", "query_freq2"])
for mot, count in compteur.most_common():
tableau.loc[len(tableau)] = {"mot":mot[0], "query_freq2":count}
return tableau
def calcul_idf(docs, vocab):
idfs = pd.DataFrame(columns=["mot", "idf", "docs_freq"])
vocab_size = len(vocab)
for i_mot in range(vocab_size):
nb_occ = 0
for doc in docs:
if vocab[i_mot] in doc:
nb_occ += 1
if nb_occ==0:
print(f"mot : {vocab[i_mot]}")
idfs.loc[i_mot] = {"mot":vocab[i_mot], "idf":log10((len(docs)+1)/(nb_occ+1)), "docs_freq":nb_occ}
return idfs
def main(docs_path, query_path, csv_path, sort_criteria):
docs = extraire_csv(docs_path)
queries = extraire_csv(query_path)
freqs = queries_vocab_freq(queries)
idfs = calcul_idf(docs, freqs.mot)
dt = pd.merge(freqs, idfs, how='outer', on='mot')
dt["query_freq2/docs_freq"] = dt.query_freq2*dt.docs_freq
if sort_criteria != "alpha":
if sort_criteria in ['query_freq2', 'idf', 'docs_freq', 'query_freq2/docs_freq']:
dt = dt.sort_values(by=sort_criteria)
else:
raise ValueError("Les critères de tri possibles sont",str(['query_freq2', 'idf', 'docs_freq', 'query_freq2/docs_freq']))
dt.to_csv(csv_path, index=False)
if __name__ == "__main__":
if len(sys.argv) != 5:
print("Usage : generation_idf.py <fichier_docs.csv> <fichier_query.csv> <csv_path.csv> <sort_criteria> \n where sort_criteria = 'query_freq2' or 'idf' or 'docs_freq' or 'alpha' or 'query_freq2/docs_freq'")
else:
main(sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4])
\ No newline at end of file
{
"cells": [
{
"cell_type": "markdown",
"id": "10ea03b4",
"metadata": {},
"source": [
"# Exploration de techniques pour produire des perturbations pour les méthodes d'explication par *Activation Patching*\n",
"\n",
"## Background\n",
"### Activation Patching [[Geiger et al., 2021](https://dl.acm.org/doi/10.5555/3540261.3540994)] \n",
"Les méthodes par activation patching cherchent à identifier les composants (neurones, couches, tête d'attention,...) des modèles d'apprentissage profond sensibles à certains changements dans l'entrée ou à certaines caractéristiques. L'objectif peut être de localiser les compétences linguistiques ou la sensibilité à un certain domaine ou vocabulaire dans un modèle de langue. \n",
"\n",
"Pour produire ces explications, la méthode présentée par [[Geiger et al., 2021](https://dl.acm.org/doi/10.5555/3540261.3540994)] procède ainsi: \n",
"Soient $M$ le modèle étudié qui contient des composants (neurone ou tête d'attention) $M_{i,j}$, $\\mathcal{D}$ un dataset et $P$ une fonction qui à une entrée de $e \\in \\mathcal{D}$ lui associe une version perturbée $e'$. On pose $\\mathcal{D}'$ le dataset issu de $\\mathcal{D}$ dont chaque entrée est perturbée selon $P$. \n",
"Itérativement, on effectue pour chaque composant $M_{i,j}$:\n",
"\n",
"- une passe de $\\mathcal{D}$ dans $M$ en notant la valeur en sortie de $M_{i,j}$ ($v_e$) pour chaque entrée $e$. On note sa performance $p$.\n",
"- une passe de $\\mathcal{D}'$ dans $M$. On note sa performance $p_{\\mathcal{D}'}$.\n",
"- une passe de $\\mathcal{D}'$ dans $M$ où la sortie du composant $M_{i,j}$ est fixée à $v_e$ pour l'entrée $e' = P(e)$. On note sa performance $p_{i,j}'$.\n",
"\n",
"Ainsi, on obtient une différence de performance $p - p_{i,j}'$ pour chaque composant $M_{i,j}$ qui peut être interprété comme la sensibilité du composant $M_{i,j}$ à la perturbation $P$.\n",
"\n",
"\n",
"### Activation patching pour l'extraction de document [[Chen et al., 2024](https://dl.acm.org/doi/10.1145/3626772.3657841)]\n",
"[[Chen et al., 2024](https://dl.acm.org/doi/10.1145/3626772.3657841)] propose une adaptation de la méthode d'activation patching pour les modèles d'extraction d'information par plongement des documents et des requêtes à l'aide d'un modèle bi-encodeur. \n",
"On conserve les notations précédentes. $\\mathcal{D}$ est l'ensemble des documents et $\\mathcal{Q}$ est l'ensemble des requêtes.\n",
"\n",
"Itérativement, on effectue pour chaque composant $M_{i,j}$:\n",
"\n",
"- une passe des paires étiquetées $ \\subset \\mathcal{Q} \\times \\mathcal{D}$ dans $M$ en notant la valeur en sortie de $M_{i,j}$ ($v^\\mathcal{D}_e$) pour chaque entrée $e=(q,d)$. On note sa performance $p_{\\mathcal{D}} = moy_{(q,d) \\in \\mathcal{Q} \\times \\mathcal{D}} (M(q)\\bullet M(d))$.\n",
"- une passe des paires étiquetées $ \\subset \\mathcal{Q} \\times \\mathcal{D'}$ dans $M$ en notant la valeur en sortie de $M_{i,j}$ ($v^\\mathcal{D'}_e$) pour chaque entrée $e=(q,d')$. On note sa performance $p_{\\mathcal{D'}} = moy_{(q,d') \\in \\mathcal{Q} \\times \\mathcal{D'}} (M(q)\\bullet M(d'))$.\n",
"- On pose $ \\forall e \\in \\mathcal{Q} \\times \\mathcal{D}, v_e = v^{\\mathcal{S}}_e$ où $\\mathcal{S}$ est tel que $p_{\\mathcal{S}} = max\\{p_{\\mathcal{D}}, p_{\\mathcal{D'}}\\}$ ($p_{\\mathcal{V}} = min\\{p_{\\mathcal{D}}, p_{\\mathcal{D'}}\\}$) \n",
"- une passe de $\\mathcal{V}$ dans $M$ où la sortie du composant $M_{i,j}$ est fixée à $v^{\\mathcal{S}}_e$ pour l'entrée $e' = P(e)$. On note sa performance $p_{i,j}'$.\n",
"\n",
"Ainsi, on peut considérer\n",
"$$\n",
"p = \\frac{p_{\\mathcal{S}} - p_{\\mathcal{D}}}{p_{\\mathcal{D}'} - p_{\\mathcal{D}}} \n",
"$$\n",
"comme la sensibilité composant $M_{i,j}$ à la perturbation $P$. Les sensibilités de chaque composant peut être récapitulé dans un tableau. \n",
"\n",
"\n",
"Remarques:\n",
"- La méthode proposée prend en compte les perturbations pouvant augmenter ou diminuer la performance.\n",
"- La métrique couramment utilisée pour la performance est la proximité entre les représentations d'une requête et d'un document (ie. le produit scalaire).\n",
"\n",
"\n",
"### MerchIR\n",
"[[Parry et al., 2025](https://arxiv.org/abs/2501.10165)] propose une implémentation de la méthode de [[Chen et al., 2024](https://dl.acm.org/doi/10.1145/3626772.3657841)] : [Github](https://github.com/Parry-Parry/MechIR.git). \n",
"En fournissant un modèle, une base de données et une fonction de perturbation, la librairie MechIR permet de construire le tableau des perturbations que chaque composant de l'architecture fournie.\n",
"\n",
"On développe dans la suite des méthodes et approches pour exploiter au mieux cette librairie."
]
},
{
"cell_type": "markdown",
"id": "a69dbec3",
"metadata": {},
"source": [
"#### Préparation des uotils de travail de MechIR"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "304d73db",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/home/marine/Documents/Cours/M2GPEx/ProjetIndividuel/Travaux/stagexairag/venv-mechir/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
" from .autonotebook import tqdm as notebook_tqdm\n",
"2026-04-08 13:11:34.469 WARNING streamlit.runtime.scriptrunner_utils.script_run_context: Thread 'MainThread': missing ScriptRunContext! This warning can be ignored when running in bare mode.\n"
]
}
],
"source": [
"# Librairies Necessaires\n",
"\n",
"from mechir import Dot\n",
"from mechir.data import MechIRDataset, DotDataCollator\n",
"from mechir.perturb import perturbation\n",
"from mechir.plotting import plot_components\n",
"\n",
"import torch\n",
"from torch.utils.data import DataLoader\n",
"\n",
"import matplotlib.pyplot as plt\n",
"from matplotlib.ticker import MaxNLocator\n",
"import seaborn as sns"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "0bb6d76c",
"metadata": {},
"outputs": [],
"source": [
"# Fonctions auxiliaires (pas besoin de lire)\n",
"def pretty_print_triplets(batch, tokenizer, num=1):\n",
" \"\"\"\n",
" Pretty prints triplets of queries, documents, and their corresponding perturbed documents from a batch.\n",
"\n",
" Args:\n",
" batch (dict): A dictionary containing 'queries', 'documents', and 'perturbed_documents' from a DataLoader.\n",
" tokenizer: The tokenizer used to decode the input IDs.\n",
" num (int): Number of examples to show per batch.\n",
" \"\"\"\n",
" # Get the queries, documents, and perturbed documents from the batch\n",
" queries = batch[\"queries\"]\n",
" documents = batch[\"documents\"]\n",
" perturbed_documents = batch[\"perturbed_documents\"]\n",
"\n",
" # Loop through number of examples to show in batch\n",
" for i in range(len(documents[\"input_ids\"][:num])):\n",
" # Get the input IDs\n",
" query_ids = queries[\"input_ids\"][i]\n",
" original_ids = documents[\"input_ids\"][i]\n",
" perturbed_ids = perturbed_documents[\"input_ids\"][i]\n",
"\n",
" # Decode the input IDs to text\n",
" query_decoded = tokenizer.decode(query_ids.tolist(), skip_special_tokens=False).replace(\"[PAD]\", \"\").strip()\n",
" original_doc_decoded = tokenizer.decode(original_ids.tolist(), skip_special_tokens=False).replace(\"[PAD]\", \"\").strip()\n",
" perturbed_doc_decoded = tokenizer.decode(perturbed_ids.tolist(), skip_special_tokens=False).replace(\"[PAD]\", \"\").strip()\n",
"\n",
" # Pretty print\n",
" # print(f\"Triplet {i + 1}:\")\n",
" print(\"Query:\", query_decoded)\n",
" print(\"Baseline Document:\", original_doc_decoded)\n",
" print(\"Perturbed Document:\", perturbed_doc_decoded)\n",
" print(\"=\" * 50) # Separator for clarity\n",
"\n",
"# Helper function to calculate and store performances\n",
"def calculate_performance(model, dataloader, baseline_performance, perturbed_performance):\n",
" for i, batch in enumerate(dataloader):\n",
" # Get the queries, documents, and perturbed documents from the batch\n",
" queries = batch[\"queries\"]\n",
" documents = batch[\"documents\"]\n",
" perturbed_documents = batch[\"perturbed_documents\"]\n",
"\n",
" # Encode queries, baseline, and perturbed documents\n",
" queries_encoded = model.forward(**queries) # [batch_size x hidden_dim]\n",
" baseline_encoded = model.forward(**documents) # [batch_size x hidden_dim]\n",
" perturbed_encoded = model.forward(**perturbed_documents) # [batch_size x hidden_dim]\n",
"\n",
" # Calculate scores\n",
" baseline_scores = torch.sum(queries_encoded.unsqueeze(1) * baseline_encoded.unsqueeze(0), dim=2)\n",
" perturbed_scores = torch.sum(queries_encoded.unsqueeze(1) * perturbed_encoded.unsqueeze(0), dim=2)\n",
"\n",
" # Append flattened scores to the performance lists\n",
" baseline_performance += baseline_scores.flatten().tolist()\n",
" perturbed_performance += perturbed_scores.flatten().tolist()\n",
"\n",
"def plot_scores(baseline_scores, perturbed_scores, transformation_descr, save=False):\n",
" fig, ax = plt.subplots(1, 1, figsize=(15, 4), sharey=True)\n",
" fig.suptitle('Distribution of Baseline vs Perturbed Scores '+transformation_descr, fontsize=16)\n",
" sns.kdeplot(baseline_scores, label='Baseline', color='#D55E00', fill=True, ax=ax, alpha=0.5)\n",
" sns.kdeplot(perturbed_scores, label='Perturbed', color='#009E73', fill=True, ax=ax, alpha=0.5)\n",
" ax.set_ylabel('Density')\n",
" ax.legend()\n",
" #plt.tight_layout(rect=[0, 0, 1, 0.95]) # Adjust layout to make space for the title\n",
" if save:\n",
" plt.savefig('res/'+ transformation_descr+'_scores.png')\n",
" plt.show()\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "a6aef7c9",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"WARNING:root:Support for BERT in TransformerLens is currently experimental, until such a time when it has feature parity with HookedTransformer and has been tested on real research tasks. Until then, backward compatibility is not guaranteed. Please see the docs for information on the limitations of the current implementation.\n",
"If using BERT for interpretability research, keep in mind that BERT has some significant architectural differences to GPT. For example, LayerNorms are applied *after* the attention and MLP components, meaning that the last LayerNorm in a block cannot be folded.\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Moving model to device: cpu\n",
"Loaded pretrained model sebastian-hofstaetter/distilbert-dot-tas_b-b256-msmarco into HookedEncoder\n"
]
}
],
"source": [
"# Récupération du modèle à évaluer (cas des modèles bi-encodeur)\n",
"dot_model_name = \"sebastian-hofstaetter/distilbert-dot-tas_b-b256-msmarco\"\n",
"dot_model = Dot(dot_model_name)\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "d860ecda",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Number of query,doc pairs in dataset: 19\n",
"Query: MEASUREMENT OF DIELECTRIC CONSTANT OF LIQUIDS BY THE USE OF MICROWAVE TECHNIQUES\n",
"\n"
]
}
],
"source": [
"# Recupération du dataset utilisé pour l'évaluation\n",
"dataset = MechIRDataset(\"vaswani\", query_id_subset=[\"1\"])\n",
"print(\"Number of query,doc pairs in dataset:\", len(dataset))\n",
"print(\"Query:\", dataset._get_query(\"1\"))"
]
},
{
"cell_type": "markdown",
"id": "d2019107",
"metadata": {},
"source": [
"## Construction d'une perturbation\n",
"\n",
"Pour observer les sensibilités d'un modèle à des perturbation, il est important de construire des perturbations de document pertinentes et qui engendrent un changement conséquent du comportement du modèle. On peut retrouver plusieurs approches.\n",
"\n",
"### Perturbation par ajout, remplacement ou suppression d'un mot\n",
"Les perturbations les plus simples sont:\n",
"- l'ajout d'un mot en début de document (prepend)\n",
"- l'ajout d'un mot en fin de document (append)\n",
"- le remplacement d'un mot par un autre (replace)\n",
"- la suppression d'un mot (cas particulier de replace avec le mot vide)\n",
"\n",
"Le choix important dans ces perturbations est celui du mot ajouté ou du mot replacé et de son remplaçant. On peut exploiter différentes statistiques issues des données pour choisir un mot à ajouter ou remplacer:\n",
"- la fréquence des mots dans les requêtes\n",
"- la fréquence des mots dans les documents\n",
"- le nombre de requête/ documents contenant chaque mot\n",
"- l'IDF des mots dans les documents/ requêtes\n",
"- le rapport fréquence dans les requêtes/nombre de documents contenant le mot\n",
"\n",
"Dans un second temps, pour le cas du remplacement d'un mot, le choix du mot remplaçant peut se baser sur la connaissance des données et du vocabulaire. On peut exploiter:\n",
"- les synonymes (remplacer atome par particule)\n",
"- les différents sens des mots (remplacer onde par vague ou fréquence)\n",
"- le vocabulaire connexe (remplacer atome par molécule)"
]
},
{
"cell_type": "markdown",
"id": "25a6e43a",
"metadata": {},
"source": [
"#### Définition et évaluation d'un perturbation simple"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "ae4ef107",
"metadata": {},
"outputs": [],
"source": [
"# Définition de la fonction de perturbation des données\n",
"@perturbation\n",
"def pert(texte):\n",
" return texte.replace(\"dielectric\", \"photonic\")\n",
"\n",
"pert_type = \"replace\" # autres valeurs possibles : \"append\", \"prepend\"\n",
"pert_name = \"replace dielectric by photonic\" # description de la pertubation (pour le titre du graphique)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "4f3615e9",
"metadata": {},
"outputs": [],
"source": [
"# Définition du traitement des données et du dataloader avec les données perturbées et non-perturbées\n",
"param_pert_dot_collator = DotDataCollator(dot_model.tokenizer, pert, q_max_length=None, d_max_length=None, perturb_type=pert_type)\n",
"param_pert_dot_dataloader = DataLoader(dataset, batch_size=16, collate_fn=param_pert_dot_collator)\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "a85b37a8",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Query: [CLS] measurement of dielectric constant of liquids by the use of microwave techniques [SEP]\n",
"Baseline Document: [CLS] broadband millimetre wave paramagnetic resonance spectrometer the specimen and waveguide which can be cooled by means of a cryostat are placed between close pole pieces giving high uniform magnetic fields design details and some measurements on zero field splittings are given [SEP]\n",
"Perturbed Document: [CLS] broadband millimetre wave paramagnetic resonance spectrometer the specimen and waveguide which can be cooled by means of a cryostat are placed between close pole pieces giving high uniform magnetic fields design details and some measurements on zero field splittings are given [SEP]\n",
"==================================================\n",
"Query: [CLS] measurement of dielectric constant of liquids by the use of microwave techniques [SEP]\n",
"Baseline Document: [CLS] microwave measurements of dielectric absorption in dilute solutions [SEP]\n",
"Perturbed Document: [CLS] microwave measurements of photon a a a a a a a [SEP]\n",
"==================================================\n"
]
}
],
"source": [
"# Construction du batch et aperçu des données\n",
"param_pert_batch = next(iter(param_pert_dot_dataloader))\n",
"pretty_print_triplets(param_pert_batch, dot_model.tokenizer, num=2)\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "80479fd0",
"metadata": {},
"outputs": [],
"source": [
"# Calcul des performances du modèle sur les données puis les données perturbées\n",
"baseline_perf = []\n",
"perturbed_perf = []\n",
"calculate_performance(dot_model, param_pert_dot_dataloader, baseline_perf, perturbed_perf)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "134347bb",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 1500x400 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Affichage des performances calculées\n",
"plot_scores(baseline_perf, perturbed_perf, pert_name)"
]
},
{
"cell_type": "markdown",
"id": "edea6dae",
"metadata": {},
"source": [
"On cherche à obtenir des profils de densité différents pour les données de base et les données perturbées. C'est cette variation qu'on va essayer d'attribuer aux composants du modèle."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "venv-mechir (3.12.3)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.12.3"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
matplotlib==3.9.1
mechir @ git+https://github.com/Parry-Parry/MechIR.git
seaborn==0.13.2
torch==2.10.0
bm25s==0.3.3
PyStemmer==3.0.0
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment