fusion-bench 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

fusion_bench/dataset/llama/alpaca.py

@@ -1,16 +1,100 @@
 import logging
 import os
+import warnings
 from typing import Any, Dict, List, Optional
 
 from datasets import Dataset, load_dataset, load_from_disk
+from lightning.fabric.utilities import rank_zero_only
+from tqdm.auto import tqdm
 from transformers import PreTrainedTokenizer
 
 import fusion_bench
+from fusion_bench.utils import timeit_context
 
 log = logging.getLogger(__name__)
 
 
-def tokenize_alpaca_dataset(
+def convert_alpaca_to_conversation(alpaca_data: List[Dict[str, str]]):
+    """
+    Convert Alpaca format data to conversation format.
+
+    Args:
+        alpaca_data (list): List of dictionaries in Alpaca format with
+            'instruction', 'input', and 'output' keys
+
+    Returns:
+        list: List of conversations in ChatML format
+    """
+    conversations = []
+
+    for item in tqdm(
+        alpaca_data,
+        "Converting Alpaca to conversations",
+        disable=not rank_zero_only.rank == 0,
+    ):
+        # Skip if required fields are missing
+        if not item.get("instruction") or not item.get("output"):
+            continue
+
+        conversation = []
+
+        # Create user message
+        user_content = item["instruction"]
+        if item.get("input") and item["input"].strip():
+            user_content += f"\n\n{item['input']}"
+
+        conversation.append({"role": "user", "content": user_content})
+
+        # Create assistant message
+        conversation.append({"role": "assistant", "content": item["output"]})
+
+        conversations.append(conversation)
+
+    return conversations
+
+
+def load_tokenized_alpaca_dataset(
+    tokenizer: PreTrainedTokenizer,
+    path: str = "yahma/alpaca-cleaned",
+    split: str = "train",
+    cache_path: Optional[str] = None,
+):
+    """
+    Load and tokenized Alpaca dataset and Alpaca-like dataset.
+
+    Args:
+        tokenizer (PreTrainedTokenizer): The tokenizer to use for tokenizing the dataset.
+        path (str, optional): The path to the Alpaca dataset. Defaults to "yahma/alpaca-cleaned".
+        split (str, optional): The dataset split to load (e.g., "train", "test"). Defaults to "train".
+        cache_path (Optional[str], optional): The path to cache the tokenized dataset. If provided and the cache exists,
+            the dataset will be loaded from the cache. Defaults to None.
+
+    Returns:
+        Dataset: The tokenized dataset.
+    """
+    if cache_path is not None and os.path.exists(cache_path):
+        dataset = load_from_disk(cache_path)
+        if split is not None and split in dataset:
+            return dataset[split]
+        else:
+            return dataset
+
+    dataset = load_dataset(path, split=split)
+
+    alpaca_data = dataset.to_list()
+    conversations = convert_alpaca_to_conversation(alpaca_data)
+    with timeit_context("Tokenizing dataset"):
+        tokenized_dataset = tokenizer.apply_chat_template(
+            conversations, return_dict=True
+        )
+    tokenized_dataset = Dataset.from_dict(tokenized_dataset)
+
+    if cache_path is not None and rank_zero_only.rank == 0:
+        tokenized_dataset.save_to_disk(cache_path)
+    return tokenized_dataset
+
+
+def _tokenize_alpaca_dataset_with_template(
     dataset: Dataset,
     tokenizer: PreTrainedTokenizer,
     max_length: int = 2048,
@@ -32,6 +116,10 @@ def tokenize_alpaca_dataset(
     Returns:
         Tokenized dataset
     """
+    warnings.warn(
+        "This function is deprecated. Use `apply_chat_template` from `transformers` instead.",
+        DeprecationWarning,
+    )
 
     def prepare_samples(samples: Dict[str, List[str]]) -> Dict[str, List[List[int]]]:
         # Format prompts based on whether input field exists
@@ -115,7 +203,7 @@ def tokenize_alpaca_dataset(
     return tokenized_dataset
 
 
-def load_tokenized_alpaca_dataset_from_json(
+def load_tokenized_alpaca_dataset_from_json_with_prompt(
     data_files: str,
     tokenizer: PreTrainedTokenizer,
     max_length: int,
@@ -138,5 +226,7 @@ def load_tokenized_alpaca_dataset_from_json(
     dataset = load_dataset("json", data_files=data_files)
     if split is not None:
         dataset = dataset[split]
-    dataset = tokenize_alpaca_dataset(dataset, tokenizer, max_length=max_length)
+    dataset = _tokenize_alpaca_dataset_with_template(
+        dataset, tokenizer, max_length=max_length
+    )
     return dataset

fusion_bench/dataset/llama/collate.py

@@ -7,13 +7,14 @@ from torch.nn.utils.rnn import pad_sequence
 
 def padded_collate_sft(
     batch: List[Dict[str, List[int]]],
-    padding_idx: int = 0,
+    pad_token_id: int = 0,
     input_ids_key: str = "input_ids",
     attention_mask_key: Optional[str] = "attention_mask",
     labels_key: Optional[str] = "labels",
     ignore_idx: int = -100,
 ) -> Dict[str, torch.Tensor]:
-    """Pad a batch of sequences to the longest sequence length in the batch, and
+    """
+    Pad (right) a batch of sequences to the longest sequence length in the batch, and
     convert integer lists to tensors.
 
     Args:
@@ -27,7 +28,7 @@ def padded_collate_sft(
     input_ids = pad_sequence(
         [torch.tensor(x[input_ids_key]) for x in batch],
         batch_first=True,
-        padding_value=padding_idx,
+        padding_value=pad_token_id,
     )
     if attention_mask_key is not None and attention_mask_key in batch[0]:
         attention_mask = pad_sequence(
@@ -37,6 +38,12 @@ def padded_collate_sft(
         )
     else:
         attention_mask = None
+
+    for i, item in enumerate(batch):
+        # if labels_key not in item, copy input_ids to labels_key
+        if labels_key not in item:
+            item[labels_key] = item[input_ids_key]
+
     labels = pad_sequence(
         [torch.tensor(x[labels_key]) for x in batch],
         batch_first=True,
@@ -44,10 +51,70 @@ def padded_collate_sft(
     )
 
     if attention_mask is not None:
-        return {
+        collated_batch = {
             input_ids_key: input_ids,
             attention_mask_key: attention_mask,
             labels_key: labels,
         }
     else:
-        return {input_ids_key: input_ids, labels_key: labels}
+        collated_batch = {input_ids_key: input_ids, labels_key: labels}
+
+    for key in batch[0]:
+        if key not in [input_ids_key, attention_mask_key, labels_key]:
+            collated_batch[key] = [x[key] for x in batch]
+
+    return collated_batch
+
+
+def bradley_terry_rm_collate(
+    batch: List[Dict[str, List[int]]],
+    pad_token_id: int = 0,
+    padding_side="right",
+):
+    """
+    Collate function for Bradley-Terry reward modeling.
+
+    Args:
+        batch (List[Dict[str, List[int]]]): A list of dictionaries containing input, label pairs.
+        pad_token_id (int): Padding index for input ids. Defaults to 0.
+
+    Returns:
+        Dict[str, torch.Tensor]: Collated input and label tensors. The first half of the batch is the winner, and the second half is the loser.
+    """
+    converted_batch = []
+    for item in batch:
+        new_item = {
+            "input_ids": item["chosen_input_ids"],
+            "attention_mask": item["chosen_attention_mask"],
+        }
+        converted_batch.append(new_item)
+    for item in batch:
+        new_item = {
+            "input_ids": item["rejected_input_ids"],
+            "attention_mask": item["rejected_attention_mask"],
+        }
+        converted_batch.append(new_item)
+
+    input_ids = pad_sequence(
+        [torch.tensor(x["input_ids"]) for x in converted_batch],
+        batch_first=True,
+        padding_value=pad_token_id,
+        padding_side=padding_side,
+    )
+    attention_mask = pad_sequence(
+        [torch.tensor(x["attention_mask"]) for x in converted_batch],
+        batch_first=True,
+        padding_value=0,
+        padding_side=padding_side,
+    )
+
+    collated_batch = {"input_ids": input_ids, "attention_mask": attention_mask}
+    for key in batch[0]:
+        if key not in [
+            "chosen_input_ids",
+            "chosen_attention_mask",
+            "rejected_input_ids",
+            "rejected_attention_mask",
+        ]:
+            collated_batch[key] = [x[key] for x in batch]
+    return collated_batch

fusion_bench/dataset/llama/metamathqa.py

@@ -0,0 +1,50 @@
+import os
+from typing import TYPE_CHECKING, Optional
+
+from datasets import Dataset, load_dataset, load_from_disk
+from lightning.fabric.utilities import rank_zero_only
+from tqdm.auto import tqdm
+
+from fusion_bench.utils import timeit_context
+
+from .alpaca import convert_alpaca_to_conversation
+
+if TYPE_CHECKING:
+    from transformers import PreTrainedTokenizer
+
+
+def load_tokenized_metamathqa(
+    tokenizer: "PreTrainedTokenizer",
+    path: str = "meta-math/MetaMathQA",
+    split: str = "train",
+    cache_path: Optional[str] = None,
+):
+    if cache_path is not None and os.path.exists(cache_path):
+        dataset = load_from_disk(cache_path)
+        if split is not None and split in dataset:
+            return dataset[split]
+        else:
+            return dataset
+
+    dataset = load_dataset(path, split=split)
+
+    # convert dataset to alpaca format and save to ../data/MetaMathQA.json
+    alpaca_dataset = []
+    for example in tqdm(dataset, disable=not rank_zero_only.rank == 0):
+        alpaca_example = {
+            "instruction": example["query"],
+            "input": "",
+            "output": example["response"],
+        }
+        alpaca_dataset.append(alpaca_example)
+
+    conversations = convert_alpaca_to_conversation(alpaca_dataset)
+    with timeit_context("Tokenizing dataset"):
+        tokenized_dataset = tokenizer.apply_chat_template(
+            conversations, return_dict=True
+        )
+    tokenized_dataset = Dataset.from_dict(tokenized_dataset)
+
+    if cache_path is not None and rank_zero_only.rank == 0:
+        tokenized_dataset.save_to_disk(cache_path)
+    return tokenized_dataset

fusion_bench/dataset/llama/preference_700k.py

@@ -0,0 +1,70 @@
+import os
+from copy import deepcopy
+from typing import TYPE_CHECKING, Optional
+
+from datasets import Dataset, load_dataset, load_from_disk
+from lightning.fabric.utilities import rank_zero_only
+from tqdm.auto import tqdm
+
+from fusion_bench.utils import timeit_context
+import logging
+
+if TYPE_CHECKING:
+    from transformers import PreTrainedTokenizer
+
+log = logging.getLogger(__name__)
+
+
+def load_tokenized_preference_700k_for_rlhf(
+    tokenizer: "PreTrainedTokenizer",
+    path: str = "hendrydong/preference_700K",
+    split: str = "train",
+    num_proc: int = 8,
+    cache_path: Optional[str] = None,
+):
+    R"""
+    Load and tokenized Preference 700k dataset for Bradley-Terry ranking model.
+
+    The returned dataset contains the following fields:
+
+    - chosen_input_ids: The input token ids for the winner.
+    - chosen_attention_mask: The attention mask for the winner.
+    - rejected_input_ids: The input token ids for the loser.
+    - rejected_attention_mask: The attention mask for the loser.
+    """
+    if cache_path is not None and os.path.exists(cache_path):
+        dataset = load_from_disk(cache_path)
+        return dataset
+
+    dataset = load_dataset(path, split=split)
+
+    def tokenize(sample):
+        sample["chosen_chat"] = tokenizer.apply_chat_template(
+            sample["chosen"], tokenize=False, add_generation_prompt=False
+        )
+        sample["rejected_chat"] = tokenizer.apply_chat_template(
+            sample["rejected"], tokenize=False, add_generation_prompt=False
+        )
+
+        tokenized_pos = tokenizer(sample["chosen_chat"], truncation=True)
+        tokenized_neg = tokenizer(sample["rejected_chat"], truncation=True)
+
+        # Ensure that the chosen response does not contain an PAD token
+        sample["chosen_input_ids"] = tokenized_pos["input_ids"]
+        sample["chosen_attention_mask"] = tokenized_pos["attention_mask"]
+        if tokenizer.pad_token_id in tokenized_pos["input_ids"]:
+            log.warning(f"Prompt contains PAD token: {sample['chosen_chat']}")
+
+        sample["rejected_input_ids"] = tokenized_neg["input_ids"]
+        sample["rejected_attention_mask"] = tokenized_neg["attention_mask"]
+        # Ensure that the rejected response does not contain an PAD token
+        if tokenizer.pad_token_id in tokenized_neg["input_ids"]:
+            log.warning(f"Prompt contains PAD token: {sample['rejected_chat']}")
+
+        return sample
+
+    dataset = dataset.map(tokenize, num_proc=num_proc)
+
+    if cache_path is not None and rank_zero_only.rank == 0:
+        dataset.save_to_disk(cache_path)
+    return dataset

fusion_bench/dataset/llama/stanford_shp.py

@@ -0,0 +1,90 @@
+import os
+from copy import deepcopy
+from typing import TYPE_CHECKING, Optional
+
+from datasets import Dataset, load_dataset, load_from_disk
+from lightning.fabric.utilities import rank_zero_only
+from tqdm.auto import tqdm
+
+from fusion_bench.utils import timeit_context
+
+if TYPE_CHECKING:
+    from transformers import PreTrainedTokenizer
+
+
+def load_tokenized_stanford_shp_for_rlhf(
+    tokenizer: "PreTrainedTokenizer",
+    path: str = "stanfordnlp/SHP",
+    split: str = "train",
+    num_proc: int = 8,
+    cache_path: Optional[str] = None,
+):
+    if cache_path is not None and os.path.isdir(cache_path):
+        dataset = load_from_disk(cache_path)
+        return dataset
+
+    dataset = load_dataset(path, split=split)
+
+    def tokenize(sample):
+        """
+        - history: the post title concatented to the post body (string)
+        - human_ref_A: text of comment A (string)
+        - human_ref_B: text of comment B (string)
+        - labels: the preference label -- it is 1 if A is preferred to B; 0 if B is preferred to A. This was randomized such that the label distribution is roughly 50/50. (integer)
+        """
+        # Create a conversation with the post title and body, followed by comments
+        conversation = [{"role": "user", "content": sample["history"]}]
+        if sample["labels"] == 0:
+            sample["chosen"] = deepcopy(conversation).append(
+                {"role": "assistant", "content": sample["human_ref_B"]}
+            )
+            sample["rejected"] = deepcopy(conversation).append(
+                {"role": "assistant", "content": sample["human_ref_A"]}
+            )
+        else:
+            sample["chosen"] = deepcopy(conversation).append(
+                {"role": "assistant", "content": sample["human_ref_A"]}
+            )
+            sample["rejected"] = deepcopy(conversation).append(
+                {"role": "assistant", "content": sample["human_ref_B"]}
+            )
+
+        # apply chat template
+        sample["chosen_chat"] = tokenizer.apply_chat_template(
+            sample["chosen"], tokenize=False, add_generation_prompt=False
+        )
+        sample["rejected_chat"] = tokenizer.apply_chat_template(
+            sample["rejected"], tokenize=False, add_generation_prompt=False
+        )
+
+        # tokenize the conversation
+        tokenized_pos = tokenizer(sample["chosen_chat"], truncation=True)
+        tokenized_neg = tokenizer(sample["rejected_chat"], truncation=True)
+
+        # Ensure that the chosen response does not contain an EOS token
+        sample["chosen_input_ids"] = tokenized_pos["input_ids"]
+        sample["chosen_attention_mask"] = tokenized_pos["attention_mask"]
+        assert (
+            tokenizer.eos_token_id not in tokenized_pos["input_ids"][:-1]
+        ), f"Prompt contains EOS token: {sample['positive']}"
+        if sample["chosen_input_ids"][-1] != tokenizer.eos_token_id:
+            sample["chosen_input_ids"].append(tokenizer.eos_token_id)
+            sample["chosen_attention_mask"].append(1)
+
+        sample["rejected_input_ids"] = tokenized_neg["input_ids"]
+        sample["rejected_attention_mask"] = tokenized_neg["attention_mask"]
+        # Ensure that the rejected response does not contain an EOS token
+        assert (
+            tokenizer.eos_token_id not in tokenized_neg["input_ids"][:-1]
+        ), f"Prompt contains EOS token: {sample['rejected']}"
+        if sample["rejected_input_ids"][-1] != tokenizer.eos_token_id:
+            sample["rejected_input_ids"].append(tokenizer.eos_token_id)
+            sample["rejected_attention_mask"].append(1)
+
+        return sample
+
+    dataset = dataset.map(tokenize, num_proc=num_proc)
+
+    if cache_path is not None and rank_zero_only.rank == 0:
+        dataset.save_to_disk(cache_path)
+    return dataset

fusion_bench/dataset/llama/ultrachat.py

@@ -0,0 +1,58 @@
+import os
+from typing import TYPE_CHECKING, Optional
+
+from datasets import Dataset, load_dataset, load_from_disk
+from lightning.fabric.utilities import rank_zero_only
+from tqdm.auto import tqdm
+
+from fusion_bench.utils import timeit_context
+
+if TYPE_CHECKING:
+    from transformers import PreTrainedTokenizer
+
+
+def load_tokenized_ultrachat_200k(
+    tokenizer: "PreTrainedTokenizer",
+    path: str = "HuggingFaceH4/ultrachat_200k",
+    split: str = "train_sft",
+    num_proc: int = 8,
+    cache_path: Optional[str] = None,
+):
+    R"""
+    Load and tokenized Ultrachat 200k dataset for Bradley-Terry ranking model.
+
+    The returned dataset contains the following fields:
+
+    - input_ids: The input token ids for the winner.
+    - attention_mask: The attention mask for the winner.
+    """
+    if cache_path is not None and os.path.exists(cache_path):
+        dataset = load_from_disk(cache_path)
+        return dataset
+
+    dataset = load_dataset(path, split=split)
+
+    def tokenize(sample):
+
+        # ? is it necessary to `.replace(tokenizer.bos_token, "")`?
+        sample["input_ids"] = tokenizer.apply_chat_template(
+            sample["messages"], tokenize=True, add_generation_prompt=False
+        )
+        sample["attention_mask"] = [1] * len(sample["input_ids"])
+
+        return sample
+
+    dataset = dataset.map(tokenize, num_proc=num_proc)
+
+    if cache_path is not None and rank_zero_only.rank == 0:
+        dataset.save_to_disk(cache_path)
+    return dataset
+
+
+if __name__ == "__main__":
+    # Example usage and testing
+    from transformers import AutoTokenizer
+
+    tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-1B-Instruct")
+    dataset = load_tokenized_ultrachat_200k(tokenizer)
+    print(dataset)

fusion_bench/method/__init__.py

@@ -5,11 +5,12 @@ from typing import TYPE_CHECKING
 from fusion_bench.utils.lazy_imports import LazyImporter
 
 _import_structure = {
+    # --------------
     "base_algorithm": ["BaseModelFusionAlgorithm", "BaseAlgorithm"],
     "dummy": ["DummyAlgorithm"],
     # single task learning (fine-tuning)
     "classification": ["ImageClassificationFineTuningForCLIP"],
-    "lm_finetune": ["FullFinetuneSFT", "PeftFinetuneSFT"],
+    "lm_finetune": ["FullFinetuneSFT", "PeftFinetuneSFT", "BradleyTerryRewardModeling"],
     # analysis
     "analysis": ["TaskVectorCosSimilarity", "TaskVectorViolinPlot"],
     # model ensemble methods
@@ -64,6 +65,7 @@ _import_structure = {
     ],
     "dawe": ["DataAdaptiveWeightEnsemblingForCLIP"],
     "we_moe": ["CLIPWeightEnsemblingMoEAlgorithm"],
+    "rankone_moe": ["CLIPRankOneMoEAlgorithm", "RankOneMoEAlgorithm"],
     "sparse_we_moe": [
         "SparseWeightEnsemblingMoEAlgorithm",
         "SparseCLIPWeightEnsemblingMoEAlgorithm",
@@ -134,6 +136,7 @@ if TYPE_CHECKING:
         PWEMoELinearScalarizationForCLIP,
         PWEMoExactParetoOptimalForCLIP,
     )
+    from .rankone_moe import CLIPRankOneMoEAlgorithm, RankOneMoEAlgorithm
     from .regmean import RegMeanAlgorithmForCLIP, RegMeanAlgorithmForGPT2
     from .simple_average import SimpleAverageAlgorithm
     from .smile_upscaling import (

fusion_bench/method/adamerging/__init__.py

@@ -1,6 +1,6 @@
 # flake8: noqa F401
 from .clip_layer_wise_adamerging import CLIPLayerWiseAdaMergingAlgorithm
 from .clip_task_wise_adamerging import CLIPTaskWiseAdaMergingAlgorithm
+from .flan_t5_layer_wise_adamerging import FlanT5LayerWiseAdaMergingAlgorithm
 from .gpt2_layer_wise_adamerging import GPT2LayerWiseAdaMergingAlgorithm
 from .llama_adamerging import LayerWiseAdaMergingForLlamaSFT
-from .flan_t5_layer_wise_adamerging import FlanT5LayerWiseAdaMergingAlgorithm

fusion_bench/method/adamerging/layer_wise_adamerging.py

@@ -1,12 +1,12 @@
 import logging
 import os
 from abc import abstractmethod
-from typing import Any, List, Mapping, Union, cast  # noqa: F401
+from typing import TYPE_CHECKING, Any, List, Mapping, TypeVar, Union, cast  # noqa: F401
 
 import torch
 from lightning.fabric.utilities.rank_zero import rank_zero_only
 from omegaconf import DictConfig
-from torch import Tensor
+from torch import Tensor, nn
 from torch.utils.data import DataLoader
 from tqdm.autonotebook import tqdm
 
@@ -19,10 +19,14 @@ from fusion_bench.models.wrappers.layer_wise_fusion import (
     get_layer_wise_weights,
 )
 from fusion_bench.utils.data import load_tensor_from_file
+from fusion_bench.utils.type import TorchModelType
 
 from .entropy_loss import entropy_loss
 from .utils import get_memory_usage
 
+if TYPE_CHECKING:
+    from fusion_bench.programs.fabric_fusion_program import FabricModelFusionProgram
+
 log = logging.getLogger(__name__)
 
 
@@ -31,6 +35,9 @@ class LayerWiseAdaMergingAlgorithm(
     LightningFabricMixin,
     SimpleProfilerMixin,
 ):
+    _program: "FabricModelFusionProgram"
+    """The program that this algorithm is running on."""
+
     """
     Implements the Layer-Wise AdaMerging Algorithm.
 
@@ -48,7 +55,7 @@ class LayerWiseAdaMergingAlgorithm(
         super().__init__(algorithm_config)
 
     @torch.no_grad()
-    def construct_layer_wise_merged_model(self, modelpool: ModelPool):
+    def construct_layer_wise_merged_model(self, modelpool: "ModelPool"):
         """
         Constructs a wrapped layer-wise merged model from model pool.
 
@@ -183,7 +190,7 @@ class LayerWiseAdaMergingAlgorithm(
         """
         pass
 
-    def test_time_adaptation(self, module: LayerWiseMergedModel):
+    def test_time_adaptation(self, module: "LayerWiseMergedModel[TorchModelType]"):
         """
         Perform test-time adaptation on the merged model.
 

fusion_bench/method/adamerging/min_norm_solvers.py

@@ -49,7 +49,7 @@ class MinNormSolver:
         return gamma, cost
 
     def _min_norm_2d(vecs, dps):
-        """
+        R"""
         Find the minimum norm solution as combination of two points
         This is correct only in 2D
         ie. min_c |\sum c_i x_i|_2^2 st. \sum c_i = 1 , 1 >= c_1 >= 0 for all i, c_i + c_j = 1.0 for some i, j
@@ -85,7 +85,7 @@ class MinNormSolver:
         return sol, dps
 
     def _projection2simplex(y):
-        """
+        R"""
         Given y, it solves argmin_z |y-z|_2 st \sum z = 1 , 1 >= z_i >= 0 for all i
         """
         m = len(y)
@@ -117,7 +117,7 @@ class MinNormSolver:
         return next_point
 
     def find_min_norm_element(vecs):
-        """
+        R"""
         Given a list of vectors (vecs), this method finds the minimum norm element in the convex hull
         as min |u|_2 st. u = \sum c_i vecs[i] and \sum c_i = 1.
         It is quite geometric, and the main idea is the fact that if d_{ij} = min |u|_2 st u = c x_i + (1-c) x_j; the solution lies in (0, d_{i,j})
@@ -163,7 +163,7 @@ class MinNormSolver:
             sol_vec = new_sol_vec
 
     def find_min_norm_element_FW(vecs):
-        """
+        R"""
         Given a list of vectors (vecs), this method finds the minimum norm element in the convex hull
         as min |u|_2 st. u = \sum c_i vecs[i] and \sum c_i = 1.
         It is quite geometric, and the main idea is the fact that if d_{ij} = min |u|_2 st u = c x_i + (1-c) x_j; the solution lies in (0, d_{i,j})