lazyqml 2.0.5__py2.py3-none-any.whl → 3.0.0__py2.py3-none-any.whl

lazyqml/Utils/Utils.py

@@ -1,9 +1,23 @@
-from lazyqml.Global.globalEnums import *
-from itertools import product
+# Imports
+import pandas as pd
 import numpy as np
 import torch
 import psutil
+import GPUtil
+
+# Importing from
+from sklearn.model_selection import LeaveOneOut, StratifiedKFold, train_test_split
+from Global.globalEnums import *
+from itertools import product
 
+"""
+------------------------------------------------------------------------------------------------------------------
+    Verbose printer class
+        - This class implements the functionlity to print or not depending on a boolean flag
+        - The message is preceded by "[VERBOSE] {message}" 
+        - It is implemented as a Singleton Object
+------------------------------------------------------------------------------------------------------------------
+"""
 class VerbosePrinter:
     _instance = None
     _initialized = False
@@ -32,8 +46,17 @@ class VerbosePrinter:
         if cls._instance is None:
             cls._instance = VerbosePrinter()
         return cls._instance
+    
+"""
+------------------------------------------------------------------------------------------------------------------
+                                            Miscelaneous Utils
+------------------------------------------------------------------------------------------------------------------
+"""
 
 def adjustQubits(nqubits, numClasses):
+    """
+        Adjust the number of qubits to be able to solve the problem
+    """
     # Find the next power of 2 greater than numClasses
     power = np.ceil(np.log2(numClasses))
     nqubits = 2 ** power
@@ -42,120 +65,216 @@ def adjustQubits(nqubits, numClasses):
         nqubits *= 2
     return int(nqubits)
 
+def calculate_quantum_memory(num_qubits, overhead=2):
+    """
+        Estimates the memory in MiB used by the quantum circuits.
+    """
+    # Each qubit state requires 2 complex numbers (amplitude and phase)
+    # Each complex number uses 2 double-precision floats (16 bytes)
+    bytes_per_qubit_state = 16
 
-def create_combinationsCV(classifiers, embeddings, ansatzs, features, qubits, FoldID, RepeatID):
-    classifier_list = []
-    embedding_list = []
-    ansatzs_list = []
-
-    # Make sure we don't have duplicated items
-    classifiers = list(classifiers)
-    embeddings = list(embeddings)
-    ansatzs = list(ansatzs)
-    qubits = sorted(list(qubits))   # Convert the qubits set to a list as well
-    FoldID = sorted(list(FoldID))
-    RepeatID = sorted(list(RepeatID))
-
-    if Model.ALL in classifiers:
-        classifier_list = Model.list()
-        classifier_list.remove(Model.ALL)
-    else:
-        classifier_list = classifiers
-
-    if Embedding.ALL in embeddings:
-        embedding_list = Embedding.list()
-        embedding_list.remove(Embedding.ALL)
-    else:
-        embedding_list = embeddings
-
-    if Ansatzs.ALL in ansatzs:
-        ansatzs_list = Ansatzs.list()
-        ansatzs_list.remove(Ansatzs.ALL)
-    else:
-        ansatzs_list = ansatzs
+    # Number of possible states is 2^n, where n is the number of qubits
+    num_states = 2 ** num_qubits
 
-    combinations = []
+    # Total memory in bytes
+    total_memory_bytes = num_states * bytes_per_qubit_state * overhead
 
-    for classifier in classifier_list:
-        if classifier == Model.QSVM:
-            # QSVM doesn't use ansatzs or features but uses qubits (first in the product)
-            combinations.extend(list(product(qubits, [classifier], embedding_list, [None], [None], RepeatID, FoldID)))
-        elif classifier == Model.QNN:
-            # QNN uses ansatzs and qubits (qubits first)
-            combinations.extend(list(product(qubits, [classifier], embedding_list, ansatzs_list, [None], RepeatID, FoldID)))
-        elif classifier == Model.QNN_BAG:
-            # QNN_BAG uses ansatzs, features, and qubits (qubits first)
-            combinations.extend(list(product(qubits, [classifier], embedding_list, ansatzs_list, features, RepeatID, FoldID)))
+    # Convert to more readable units
 
-    return combinations
+    return total_memory_bytes / (1024**2)
 
-def create_combinations(classifiers, embeddings, ansatzs, features, qubits):
+def calculate_free_memory():
+    """
+        Calculates the amount of free RAM
+    """
+    # Use psutil to get available system memory (in MiB)
+    mem = psutil.virtual_memory()
+    free_ram_mb = mem.available / (1024 ** 2)  # Convert bytes to MiB
+    return free_ram_mb
+
+def calculate_free_video_memory():
+    """
+        Calculates the amount of free Video Memory
+    """
+    # Use psutil to get available system memory (in MiB)
+    return GPUtil.getGPUs()[0].memoryFree
+
+
+def create_combinations(classifiers, embeddings, ansatzs, features, qubits, FoldID, RepeatID):
     classifier_list = []
     embedding_list = []
     ansatzs_list = []
-
+    
     # Make sure we don't have duplicated items
     classifiers = list(classifiers)
     embeddings = list(embeddings)
     ansatzs = list(ansatzs)
-    qubits = sorted(list(qubits))   # Convert the qubits set to a list as well
-
+    qubit_values = sorted(list(qubits))
+    FoldID = sorted(list(FoldID))
+    RepeatID = sorted(list(RepeatID))
+    
     if Model.ALL in classifiers:
         classifier_list = Model.list()
         classifier_list.remove(Model.ALL)
     else:
         classifier_list = classifiers
-
+    
     if Embedding.ALL in embeddings:
         embedding_list = Embedding.list()
         embedding_list.remove(Embedding.ALL)
     else:
         embedding_list = embeddings
-
+    
     if Ansatzs.ALL in ansatzs:
         ansatzs_list = Ansatzs.list()
         ansatzs_list.remove(Ansatzs.ALL)
     else:
         ansatzs_list = ansatzs
-
+    
     combinations = []
-
-    for classifier in classifier_list:
-        if classifier == Model.QSVM:
-            # QSVM doesn't use ansatzs or features but uses qubits (first in the product)
-            combinations.extend(list(product(qubits, [classifier], embedding_list, [None], [None])))
-        elif classifier == Model.QNN:
-            # QNN uses ansatzs and qubits (qubits first)
-            combinations.extend(list(product(qubits, [classifier], embedding_list, ansatzs_list, [None])))
-        elif classifier == Model.QNN_BAG:
-            # QNN_BAG uses ansatzs, features, and qubits (qubits first)
-            combinations.extend(list(product(qubits, [classifier], embedding_list, ansatzs_list, features)))
-
+    # Create all base combinations first
+    for qubits in qubit_values:
+        for classifier in classifier_list:
+            temp_combinations = []
+            if classifier == Model.QSVM:
+                # QSVM doesn't use ansatzs or features but uses qubits
+                temp_combinations = list(product([qubits], [classifier], embedding_list, [None], [None], RepeatID, FoldID))
+            elif classifier == Model.QNN:
+                # QNN uses ansatzs and qubits
+                temp_combinations = list(product([qubits], [classifier], embedding_list, ansatzs_list, [None], RepeatID, FoldID))
+            elif classifier == Model.QNN_BAG:
+                # QNN_BAG uses ansatzs, features, and qubits
+                temp_combinations = list(product([qubits], [classifier], embedding_list, ansatzs_list, features, RepeatID, FoldID))
+            
+            # Add memory calculation for each combination
+            for combo in temp_combinations:
+                memory = calculate_quantum_memory(combo[0])  # Calculate memory based on number of qubits
+                combinations.append(combo + (memory,))
+    
     return combinations
 
 def fixSeed(seed):
     np.random.seed(seed=seed)
     torch.manual_seed(seed)
 
-def calculate_quantum_memory(num_qubits, overhead=2):
-    # Each qubit state requires 2 complex numbers (amplitude and phase)
-    # Each complex number uses 2 double-precision floats (16 bytes)
-    bytes_per_qubit_state = 16
 
-    # Number of possible states is 2^n, where n is the number of qubits
-    num_states = 2 ** num_qubits
-
-    # Total memory in bytes
-    total_memory_bytes = num_states * bytes_per_qubit_state * overhead
-
-    # Convert to more readable units
-
-    return total_memory_bytes / (1024**3)
-
-def calculate_free_memory():
-        # Use psutil to get available system memory (in GB)
-        mem = psutil.virtual_memory()
-        free_ram_gb = mem.available / (1024 ** 3)  # Convert bytes to GB
-        return free_ram_gb
-
-printer = VerbosePrinter()
+def generate_cv_indices(X, y, mode="cross-validation", test_size=0.4, n_splits=5, n_repeats=1, random_state=None):
+    """
+    Generate train and test indices for either cross-validation, holdout split, or leave-one-out.
+    
+    Parameters:
+        X (pd.DataFrame or np.ndarray): The features matrix.
+        y (pd.Series or np.ndarray): The target vector.
+        mode (str): "cross-validation", "holdout", or "leave-one-out".
+        test_size (float): Test set proportion for the holdout split (ignored for CV and LOO).
+        n_splits (int): Number of folds in StratifiedKFold (ignored for holdout and LOO).
+        n_repeats (int): Number of repeats for cross-validation (ignored for holdout and LOO).
+        random_state (int): Random state for reproducibility.
+    
+    Returns:
+        dict: A dictionary of train/test indices.
+    """
+    cv_indices = {}
+    
+    if mode == "holdout":
+        # Single train-test split for holdout
+        train_idx, test_idx = train_test_split(
+            np.arange(len(X)),
+            test_size=test_size,
+            stratify=y,
+            random_state=random_state
+        )
+        cv_indices[(0, 0)] = {
+            'train_idx': train_idx,
+            'test_idx': test_idx
+        }
+    
+    elif mode == "cross-validation":
+        # StratifiedKFold for cross-validation splits
+        for repeat in range(n_repeats):
+            skf = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=random_state + repeat if random_state is not None else None)
+            for fold, (train_idx, test_idx) in enumerate(skf.split(X, y)):
+                cv_indices[(repeat, fold)] = {
+                    'train_idx': train_idx,
+                    'test_idx': test_idx
+                }
+    
+    elif mode == "leave-one-out":
+        # LeaveOneOut cross-validation
+        loo = LeaveOneOut()
+        for fold, (train_idx, test_idx) in enumerate(loo.split(X)):
+            cv_indices[(0, fold)] = {
+                'train_idx': train_idx,
+                'test_idx': test_idx
+            }
+    
+    else:
+        raise ValueError("Invalid mode. Choose 'holdout', 'cross-validation', or 'leave-one-out'.")
+    
+    return cv_indices
+
+def get_train_test_split(cv_indices, repeat_id=0, fold_id=0):
+    """
+    Retrieve the train and test indices for a given repeat and fold ID.
+    
+    Parameters:
+        cv_indices (dict): The cross-validation indices dictionary.
+        repeat_id (int): The repeat ID (0 to n_repeats-1 or 0 for holdout/LOO).
+        fold_id (int): The fold ID within the specified repeat.
+    
+    Returns:
+        tuple: (train_idx, test_idx) arrays for the specified fold and repeat.
+    """
+    indices = cv_indices.get((repeat_id, fold_id))
+    if indices is None:
+        print(f"RepeatID {repeat_id}, FoldID{fold_id}")
+        raise ValueError("Invalid repeat_id or fold_id specified.")
+    
+    return indices['train_idx'], indices['test_idx']
+
+
+
+def dataProcessing(X, y, prepFactory, customImputerCat, customImputerNum, 
+                train_idx, test_idx, ansatz=None, embedding=None):
+    """
+    Process data for specific train/test indices.
+    
+    Parameters:
+    - X: Input features
+    - y: Target variable
+    - prepFactory: Preprocessing factory object
+    - customImputerCat: Categorical imputer
+    - customImputerNum: Numerical imputer
+    - train_idx: Training set indices
+    - test_idx: Test set indices
+    - ansatz: Optional preprocessing ansatz
+    - embedding: Optional embedding method
+    
+    Returns:
+    Tuple of (X_train_processed, X_test_processed, y_train, y_test)
+    """
+    # Split the data using provided indices
+    X_train, X_test = X.iloc[train_idx], X.iloc[test_idx]
+    y_train, y_test = y[train_idx], y[test_idx]
+    
+    # Create sanitizer and preprocess
+    sanitizer = prepFactory.GetSanitizer(customImputerCat, customImputerNum)
+    X_train = pd.DataFrame(sanitizer.fit_transform(X_train))
+    X_test = pd.DataFrame(sanitizer.transform(X_test))
+    
+    # Apply additional preprocessing if ansatz/embedding provided
+    if ansatz is not None or embedding is not None:
+        preprocessing = prepFactory.GetPreprocessing(ansatz=ansatz, embedding=embedding)
+        X_train_processed = np.array(preprocessing.fit_transform(X_train, y=y_train))
+        X_test_processed = np.array(preprocessing.transform(X_test))
+    else:
+        X_train_processed = np.array(X_train)
+        X_test_processed = np.array(X_test)
+    
+    # Convert target variables to numpy arrays
+    y_train = np.array(y_train)
+    y_test = np.array(y_test)
+    
+    return X_train_processed, X_test_processed, y_train, y_test
+
+printer = VerbosePrinter()

lazyqml/Utils/Validator.py

@@ -1,12 +1,9 @@
-from pydantic import BaseModel, ValidationError, field_validator , ConfigDict
-from typing import Callable
-import inspect
-from sklearn.metrics import accuracy_score
-from sklearn.preprocessing import OneHotEncoder, StandardScaler
 import numpy as np
-from typing import Any
 import pandas as pd
 
+from pydantic import BaseModel, ConfigDict, field_validator 
+from typing import Any
+
 class FitParamsValidator(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)  # Allow arbitrary types like DataFrame and ndarray
 
@@ -77,7 +74,7 @@ class FitParamsValidatorCV(BaseModel):
 
         if size1 != size2:
             raise ValueError(f"{name1} and {name2} must have the same number of examples. "
-                             f"Got {size1} and {size2}.")
+                            f"Got {size1} and {size2}.")
 
     # Ensure inputs are valid DataFrames or NumPy arrays, and not empty/null
     @field_validator("x", "y")

lazyqml/__init__.py

@@ -2,4 +2,4 @@
 
 __author__ = """Diego García Vega, Fernando Álvaro Plou Llorente, Alejandro Leal Castaño"""
 __email__ = "garciavdiego@uniovi.es, ploufernando@uniovi.es, lealcalejandro@uniovi.es"
-__version__ = "2.0.5"
+__version__ = "3.0.0"

lazyqml/lazyqml.py

@@ -1,3 +1,5 @@
+import inspect
+import warnings
 import numpy as np
 import pandas as pd
 import sys
@@ -6,17 +8,15 @@ from pydantic import BaseModel, Field, model_validator, field_validator, Validat
 from pydantic.config import ConfigDict
 from typing import List, Callable, Optional, Set
 from typing_extensions import Annotated, Set
-
-
-from lazyqml.Factories.Preprocessing.fPreprocessing import PreprocessingFactory
-from lazyqml.Global.globalEnums import *
-from lazyqml.Utils.Utils import *
-from lazyqml.Utils.Validator import *
-from lazyqml.Factories.Dispatchers.DispatcherCV import *
-from lazyqml.Factories.Dispatchers.Dispatcher import *
+from Factories.Preprocessing.fPreprocessing import PreprocessingFactory
+from Global.globalEnums import *
+from Utils.Utils import *
+from Utils.Validator import *
+from Factories.Dispatchers.Dispatcher import *
 from sklearn.impute import SimpleImputer
 from ucimlrepo import fetch_ucirepo
 from sklearn.preprocessing import LabelEncoder
+from time import time
 
 class QuantumClassifier(BaseModel):
     """
@@ -101,13 +101,12 @@ class QuantumClassifier(BaseModel):
     shots: Annotated[int, Field(gt=0)] = 1
     runs: Annotated[int, Field(gt=0)] = 1
     batchSize: Annotated[int, Field(gt=0)] = 8
-    threshold: Annotated[int, Field(gt=0)] = 26
+    threshold: Annotated[int, Field(gt=0)] = 22
     maxSamples: Annotated[float, Field(gt=0, le=1)] = 1.0
     verbose: bool = False
     customMetric: Optional[Callable] = None
     customImputerNum: Optional[Any] = None
     customImputerCat: Optional[Any] = None
-    batch: Optional[bool] = True
     cores: Optional[int] = True
 
     @field_validator('nqubits', mode='before')
@@ -201,25 +200,29 @@ class QuantumClassifier(BaseModel):
 
         return preprocessor
 
-    def fit(self, X_train, y_train, X_test, y_test,showTable=True):
-
-
+    def fit(self, X, y, test_size=0.4, showTable=True):
+        """
+        
+        """
+        warnings.filterwarnings("ignore")
         printer.set_verbose(verbose=self.verbose)
         # Validation model to ensure input parameters are DataFrames and sizes match
-        FitParamsValidator(
-            train_x=X_train,
-            train_y=y_train,
-            test_x=X_test,
-            test_y=y_test
+        FitParamsValidatorCV(
+            x=X,
+            y=y
         )
         printer.print("Validation successful, fitting the model...")
 
         # Fix seed
         fixSeed(self.randomstate)
-        d = Dispatcher(sequential=self.sequential,threshold=self.threshold)
-        d.dispatch(nqubits=self.nqubits,randomstate=self.randomstate,predictions=self.predictions,numPredictors=self.numPredictors,numLayers=self.numLayers,classifiers=self.classifiers,ansatzs=self.ansatzs,backend=self.backend,embeddings=self.embeddings,features=self.features,learningRate=self.learningRate,epochs=self.epochs,runs=self.runs,maxSamples=self.maxSamples,verbose=self.verbose,customMetric=self.customMetric,customImputerNum=self.customImputerNum,customImputerCat=self.customImputerCat, X_train=X_train,y_train=y_train, X_test=X_test, y_test=y_test,shots=self.shots,showTable=showTable,batch=self.batchSize,auto=self.batch)
+        d = Dispatcher(sequential=self.sequential,threshold=self.threshold,repeats=1, folds=1)
+        d.dispatch(nqubits=self.nqubits,randomstate=self.randomstate,predictions=self.predictions,numPredictors=self.numPredictors,numLayers=self.numLayers,classifiers=self.classifiers,ansatzs=self.ansatzs,backend=self.backend,embeddings=self.embeddings,features=self.features,learningRate=self.learningRate,epochs=self.epochs,runs=self.runs,maxSamples=self.maxSamples,verbose=self.verbose,customMetric=self.customMetric,customImputerNum=self.customImputerNum,customImputerCat=self.customImputerCat, X=X ,y=y,shots=self.shots,showTable=showTable,batch=self.batchSize,mode="holdout",testsize=test_size)
 
     def repeated_cross_validation(self, X, y, n_splits=10, n_repeats=5, showTable=True):
+        """
+        
+        """
+        warnings.filterwarnings("ignore")
         printer.set_verbose(verbose=self.verbose)
         # Validation model to ensure input parameters are DataFrames and sizes match
         FitParamsValidatorCV(
@@ -230,45 +233,47 @@ class QuantumClassifier(BaseModel):
 
         # Fix seed
         fixSeed(self.randomstate)
-        d = DispatcherCV(sequential=self.sequential,threshold=self.threshold,repeats=n_repeats,folds=n_splits)
-        d.dispatch(nqubits=self.nqubits,randomstate=self.randomstate,predictions=self.predictions,numPredictors=self.numPredictors,numLayers=self.numLayers,classifiers=self.classifiers,ansatzs=self.ansatzs,backend=self.backend,embeddings=self.embeddings,features=self.features,learningRate=self.learningRate,epochs=self.epochs,runs=self.runs,maxSamples=self.maxSamples,verbose=self.verbose,customMetric=self.customMetric,customImputerNum=self.customImputerNum,customImputerCat=self.customImputerCat,X_train=X ,X_test=X,y_test=y,y_train=y,shots=self.shots,showTable=showTable,batch=self.batchSize,auto=self.batch,cores=self.cores)
+        d = Dispatcher(sequential=self.sequential,threshold=self.threshold,repeats=n_repeats,folds=n_splits)
+        d.dispatch(nqubits=self.nqubits,randomstate=self.randomstate,predictions=self.predictions,numPredictors=self.numPredictors,numLayers=self.numLayers,classifiers=self.classifiers,ansatzs=self.ansatzs,backend=self.backend,embeddings=self.embeddings,features=self.features,learningRate=self.learningRate,epochs=self.epochs,runs=self.runs,maxSamples=self.maxSamples,verbose=self.verbose,customMetric=self.customMetric,customImputerNum=self.customImputerNum,customImputerCat=self.customImputerCat,X=X ,y=y,shots=self.shots,showTable=showTable,batch=self.batchSize,mode="cross-validation")
 
     def leave_one_out(self, X, y, showTable=True):
-        pass
+        """
+        
+        """
+        warnings.filterwarnings("ignore")
+        printer.set_verbose(verbose=self.verbose)
+        # Validation model to ensure input parameters are DataFrames and sizes match
+        FitParamsValidatorCV(
+            x=X,
+            y=y
+        )
+        printer.print("Validation successful, fitting the model...")
+        
+        # Fix seed 
+        fixSeed(self.randomstate)
+        d = Dispatcher(sequential=self.sequential,threshold=self.threshold,folds=len(X),repeats=1)
+        d.dispatch(nqubits=self.nqubits,randomstate=self.randomstate,predictions=self.predictions,numPredictors=self.numPredictors,numLayers=self.numLayers,classifiers=self.classifiers,ansatzs=self.ansatzs,backend=self.backend,embeddings=self.embeddings,features=self.features,learningRate=self.learningRate,epochs=self.epochs,runs=self.runs,maxSamples=self.maxSamples,verbose=self.verbose,customMetric=self.customMetric,customImputerNum=self.customImputerNum,customImputerCat=self.customImputerCat,X=X ,y=y,shots=self.shots,showTable=showTable,batch=self.batchSize,mode="leave-one-out")
 
-if __name__ == '__main__':
-    Batch_auto = True
-    Sequential = sys.argv[1].lower() == 'true'
-    Node = sys.argv[2].lower()
-    qubits = int(sys.argv[3])
-    cores = int(sys.argv[4])
 
+if __name__ == '__main__':
+    Sequential = False
+    Node = "slave4"
+    qubits = 4
+    cores = 6
 
     from sklearn.datasets import load_iris
 
-    dataset="iris"
-
     # Load data
     data = load_iris()
     X = data.data
     y = data.target
 
+    repeats = 2
+    embeddings = {Embedding.ZZ}
 
-    if Node == "slave1":
-        repeats = 4
-        embeddings = {Embedding.AMP}
-    elif Node == "slave2":
-        repeats = 4
-        embeddings = {Embedding.ZZ}
-    elif Node == "slave5":
-        repeats = 2
-        embeddings = {Embedding.ZZ}
-
-    print(f"PARAMETERS\nEmbeddings: {embeddings}\tBatch Auto: {Batch_auto}\tSequential: {Sequential}\tNode: {Node}\tDataset: {dataset}\tQubits: {qubits}\t Folds\\Repeats: {(8,repeats)}\tCores: {cores}")
-
-    classifier = QuantumClassifier(nqubits={qubits},classifiers={Model.QSVM},embeddings=embeddings,features={1.0},verbose=True,sequential=Sequential,backend=Backend.lightningQubit,batch=Batch_auto,cores=cores)
-
-    start = time.time()
-    classifier.repeated_cross_validation(X,y,n_repeats=repeats,n_splits=8)
-    print(f"TOTAL TIME: {time.time()-start}s\t PARALLEL: {not Sequential}")
-
+    classifier = QuantumClassifier(nqubits={4}, classifiers={Model.QSVM,Model.QNN},embeddings={Embedding.RX,Embedding.RY,Embedding.RZ},ansatzs={Ansatzs.HARDWARE_EFFICIENT},sequential=Sequential,backend=Backend.lightningQubit,cores=cores,threshold=22,epochs=5)
+    
+    start = time()
+    
+    classifier.repeated_cross_validation(X,y,n_splits=2,n_repeats=1)
+    print(f"TOTAL TIME: {time()-start}s\t PARALLEL: {not Sequential}")

lazyqml-3.0.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 QHPC & SP Research Lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.