
'''simple docstring'''




from scipy.stats import pearsonr, spearmanr
from sklearn.metrics import fa_score, matthews_corrcoef

import datasets


lowercase			:				Dict    		=			'\\n@inproceedings{wang2019glue,\n  title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding},\n  author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.},\n  note={In the Proceedings of ICLR.},\n  year={2019}\n}\n'

lowercase			:				Union[str, Any]    		=			'\\nGLUE, the General Language Understanding Evaluation benchmark\n(https://gluebenchmark.com/) is a collection of resources for training,\nevaluating, and analyzing natural language understanding systems.\n'

lowercase			:				Optional[int]    		=			'\nCompute GLUE evaluation metric associated to each GLUE dataset.\nArgs:\n    predictions: list of predictions to score.\n        Each translation should be tokenized into a list of tokens.\n    references: list of lists of references for each translation.\n        Each reference should be tokenized into a list of tokens.\nReturns: depending on the GLUE subset, one or several of:\n    "accuracy": Accuracy\n    "f1": F1 score\n    "pearson": Pearson Correlation\n    "spearmanr": Spearman Correlation\n    "matthews_correlation": Matthew Correlation\nExamples:\n\n    >>> glue_metric = datasets.load_metric(\'glue\', \'sst2\')  # \'sst2\' or any of ["mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'accuracy\': 1.0}\n\n    >>> glue_metric = datasets.load_metric(\'glue\', \'mrpc\')  # \'mrpc\' or \'qqp\'\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'accuracy\': 1.0, \'f1\': 1.0}\n\n    >>> glue_metric = datasets.load_metric(\'glue\', \'stsb\')\n    >>> references = [0., 1., 2., 3., 4., 5.]\n    >>> predictions = [0., 1., 2., 3., 4., 5.]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print({"pearson": round(results["pearson"], 2), "spearmanr": round(results["spearmanr"], 2)})\n    {\'pearson\': 1.0, \'spearmanr\': 1.0}\n\n    >>> glue_metric = datasets.load_metric(\'glue\', \'cola\')\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'matthews_correlation\': 1.0}\n'







def 		lowerCAmelCase_				(   snake_case__		,				snake_case__						):




    '''simple docstring'''



    return float((preds == labels).mean()						)







def 		lowerCAmelCase_				(   snake_case__		,				snake_case__						):




    '''simple docstring'''



    A       :   List[Any]					=						simple_accuracy(snake_case__		,				snake_case__						)
    A       :   List[Any]					=						float(fa_score(y_true=snake_case__		,				y_pred=snake_case__						)						)
    return {
        "accuracy": acc,
        "f1": fa,
    }







def 		lowerCAmelCase_				(   snake_case__		,				snake_case__						):




    '''simple docstring'''



    A       :   Any					=						float(pearsonr(snake_case__		,				snake_case__						)[0]						)
    A       :   str					=						float(spearmanr(snake_case__		,				snake_case__						)[0]						)
    return {
        "pearson": pearson_corr,
        "spearmanr": spearman_corr,
    }







@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION    ,			_KWARGS_DESCRIPTION						)
class  A				(							datasets.Metric						):





     def 				__lowerCAmelCase							(							self	) ->				Optional[int]:






         """simple docstring"""






         if self.config_name not in [
             "sst2",
             "mnli",
             "mnli_mismatched",
             "mnli_matched",
             "cola",
             "stsb",
             "mrpc",
             "qqp",
             "qnli",
             "rte",
             "wnli",
             "hans",
         ]:
             raise KeyError(
                 '''You should supply a configuration name selected in '''
                 '''["sst2", "mnli", "mnli_mismatched", "mnli_matched", '''
                 '''"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]'''	)
         return datasets.MetricInfo(
             description=_DESCRIPTION						,			citation=_CITATION						,			inputs_description=_KWARGS_DESCRIPTION						,			features=datasets.Features(
                 {
                     '''predictions''': datasets.Value('''int64''' if self.config_name != '''stsb''' else '''float32'''	),
                     '''references''': datasets.Value('''int64''' if self.config_name != '''stsb''' else '''float32'''	),
                 }	)						,			codebase_urls=[]						,			reference_urls=[]						,			format='''numpy'''						,			)





     def 				__lowerCAmelCase							(							self						,			SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE	) ->				Optional[Any]:






         """simple docstring"""






         if self.config_name == "cola":
             return {"matthews_correlation": matthews_corrcoef(SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE	)}
         elif self.config_name == "stsb":
             return pearson_and_spearman(SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE	)
         elif self.config_name in ["mrpc", "qqp"]:
             return acc_and_fa(SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE	)
         elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]:
             return {"accuracy": simple_accuracy(SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE	)}
         else:
             raise KeyError(
                 '''You should supply a configuration name selected in '''
                 '''["sst2", "mnli", "mnli_mismatched", "mnli_matched", '''
                 '''"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]'''	)






'''simple docstring'''




import os
from pickle import UnpicklingError
from typing import Dict, Tuple

import jax
import jax.numpy as jnp
import numpy as np
from flax.serialization import from_bytes
from flax.traverse_util import flatten_dict, unflatten_dict

import transformers

from .utils import logging


lowercase			:				Dict    		=			logging.get_logger(__name__)







def 		lowerCAmelCase_				(   snake_case__		,				snake_case__		,				snake_case__		,				snake_case__=False						):




    '''simple docstring'''



    try:
        import torch  # noqa: F401
    except ImportError:
        logger.error(
            '''Loading a PyTorch model in Flax, requires both PyTorch and Flax to be installed. Please see'''
            ''' https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation'''
            ''' instructions.'''						)
        raise

    if not is_sharded:
        A       :   Union[str, Any]					=						os.path.abspath(snake_case__						)
        logger.info(F'Loading PyTorch weights from {pt_path}'						)

        A       :   Any					=						torch.load(snake_case__		,				map_location='''cpu'''						)
        logger.info(F'PyTorch checkpoint contains {sum(t.numel() for t in pt_state_dict.values()						):,} parameters.'						)

        A       :   List[str]					=						convert_pytorch_state_dict_to_flax(snake_case__		,				snake_case__						)
    else:
        # model is sharded and pytorch_checkpoint_path already contains the list of .pt shard files
        A       :   Any					=						convert_pytorch_sharded_state_dict_to_flax(snake_case__		,				snake_case__						)
    return flax_state_dict







def 		lowerCAmelCase_				(   snake_case__		,				snake_case__		,				snake_case__		,				snake_case__		,				):




    '''simple docstring'''



    def is_key_or_prefix_key_in_dict(snake_case__						) -> bool:
        return len(set(snake_case__						) & {key, (model_prefix,) + key}						) > 0

    # layer norm
    A       :   Union[str, Any]					=						pt_tuple_key[:-1] + ('''scale''',)
    if pt_tuple_key[-1] in ["weight", "gamma"] and is_key_or_prefix_key_in_dict(snake_case__						):
        return renamed_pt_tuple_key, pt_tensor

    # batch norm layer mean
    A       :   Tuple					=						pt_tuple_key[:-1] + ('''mean''',)
    if pt_tuple_key[-1] == "running_mean" and not is_key_or_prefix_key_in_dict(snake_case__						):
        return renamed_pt_tuple_key, pt_tensor

    # batch norm layer var
    A       :   Dict					=						pt_tuple_key[:-1] + ('''var''',)
    if pt_tuple_key[-1] == "running_var" and not is_key_or_prefix_key_in_dict(snake_case__						):
        return renamed_pt_tuple_key, pt_tensor

    # embedding
    A       :   Any					=						pt_tuple_key[:-1] + ('''embedding''',)
    if pt_tuple_key[-1] == "weight" and is_key_or_prefix_key_in_dict(snake_case__						):
        return renamed_pt_tuple_key, pt_tensor

    # conv layer
    A       :   Optional[Any]					=						pt_tuple_key[:-1] + ('''kernel''',)
    if pt_tuple_key[-1] == "weight" and pt_tensor.ndim == 4 and not is_key_or_prefix_key_in_dict(snake_case__						):
        A       :   List[Any]					=						pt_tensor.transpose(2		,				3		,				1		,				0						)
        return renamed_pt_tuple_key, pt_tensor

    # linear layer
    A       :   Optional[int]					=						pt_tuple_key[:-1] + ('''kernel''',)
    if pt_tuple_key[-1] == "weight" and not is_key_or_prefix_key_in_dict(snake_case__						):
        A       :   str					=						pt_tensor.T
        return renamed_pt_tuple_key, pt_tensor

    # old PyTorch layer norm weight
    A       :   Dict					=						pt_tuple_key[:-1] + ('''weight''',)
    if pt_tuple_key[-1] == "gamma":
        return renamed_pt_tuple_key, pt_tensor

    # old PyTorch layer norm bias
    A       :   List[Any]					=						pt_tuple_key[:-1] + ('''bias''',)
    if pt_tuple_key[-1] == "beta":
        return renamed_pt_tuple_key, pt_tensor

    # New `weight_norm` from https://github.com/huggingface/transformers/pull/24030
    A       :   Dict					=						None
    if pt_tuple_key[-3::2] == ("parametrizations", "original0"):
        A       :   List[Any]					=						pt_tuple_key[-2] + '''_g'''
    elif pt_tuple_key[-3::2] == ("parametrizations", "original1"):
        A       :   List[str]					=						pt_tuple_key[-2] + '''_v'''
    if name is not None:
        A       :   int					=						pt_tuple_key[:-3] + (name,)
        return renamed_pt_tuple_key, pt_tensor

    return pt_tuple_key, pt_tensor







def 		lowerCAmelCase_				(   snake_case__		,				snake_case__						):




    '''simple docstring'''



    A       :   Dict					=						{k: v.numpy() for k, v in pt_state_dict.items()}

    A       :   int					=						flax_model.base_model_prefix

    # use params dict if the model contains batch norm layers
    if "params" in flax_model.params:
        A       :   List[str]					=						flax_model.params['''params''']
    else:
        A       :   Dict					=						flax_model.params
    A       :   List[Any]					=						flatten_dict(snake_case__						)

    # add batch_stats keys,values to dict
    if "batch_stats" in flax_model.params:
        A       :   List[str]					=						flatten_dict(flax_model.params['''batch_stats''']						)
        random_flax_state_dict.update(snake_case__						)

    A       :   int					=						{}

    A       :   List[str]					=						(model_prefix not in flax_model_params) and (
        model_prefix in {k.split('''.'''						)[0] for k in pt_state_dict.keys()}
    )
    A       :   int					=						(model_prefix in flax_model_params) and (
        model_prefix not in {k.split('''.'''						)[0] for k in pt_state_dict.keys()}
    )

    # Need to change some parameters name to match Flax names
    for pt_key, pt_tensor in pt_state_dict.items():
        A       :   str					=						tuple(pt_key.split('''.'''						)						)

        # remove base model prefix if necessary
        A       :   Union[str, Any]					=						pt_tuple_key[0] == model_prefix
        if load_model_with_head_into_base_model and has_base_model_prefix:
            A       :   Any					=						pt_tuple_key[1:]

        # Correctly rename weight parameters
        A,  A       :   Dict					=						rename_key_and_reshape_tensor(
            snake_case__		,				snake_case__		,				snake_case__		,				snake_case__						)

        # add model prefix if necessary
        A       :   Any					=						(model_prefix,) + flax_key in random_flax_state_dict
        if load_base_model_into_model_with_head and require_base_model_prefix:
            A       :   int					=						(model_prefix,) + flax_key

        if flax_key in random_flax_state_dict:
            if flax_tensor.shape != random_flax_state_dict[flax_key].shape:
                raise ValueError(
                    F'PyTorch checkpoint seems to be incorrect. Weight {pt_key} was expected to be of shape '
                    F'{random_flax_state_dict[flax_key].shape}, but is {flax_tensor.shape}.'						)

        # add batch stats if the model contains batchnorm layers
        if "batch_stats" in flax_model.params:
            if "mean" in flax_key[-1] or "var" in flax_key[-1]:
                A       :   Tuple					=						jnp.asarray(snake_case__						)
                continue
            # remove num_batches_tracked key
            if "num_batches_tracked" in flax_key[-1]:
                flax_state_dict.pop(snake_case__		,				snake_case__						)
                continue

            # also add unexpected weight so that warning is thrown
            A       :   List[str]					=						jnp.asarray(snake_case__						)

        else:
            # also add unexpected weight so that warning is thrown
            A       :   Optional[Any]					=						jnp.asarray(snake_case__						)

    return unflatten_dict(snake_case__						)







def 		lowerCAmelCase_				(   snake_case__		,				snake_case__						):




    '''simple docstring'''



    import torch

    # Load the index
    A       :   Union[str, Any]					=						{}
    for shard_file in shard_filenames:
        # load using msgpack utils
        A       :   List[str]					=						torch.load(snake_case__						)
        A       :   int					=						{k: v.numpy() for k, v in pt_state_dict.items()}

        A       :   Tuple					=						flax_model.base_model_prefix

        # use params dict if the model contains batch norm layers and then add batch_stats keys,values to dict
        if "batch_stats" in flax_model.params:
            A       :   Optional[int]					=						flax_model.params['''params''']

            A       :   List[Any]					=						flatten_dict(snake_case__						)
            random_flax_state_dict.update(flatten_dict(flax_model.params['''batch_stats''']						)						)
        else:
            A       :   Dict					=						flax_model.params
            A       :   Tuple					=						flatten_dict(snake_case__						)

        A       :   List[str]					=						(model_prefix not in flax_model_params) and (
            model_prefix in {k.split('''.'''						)[0] for k in pt_state_dict.keys()}
        )
        A       :   List[str]					=						(model_prefix in flax_model_params) and (
            model_prefix not in {k.split('''.'''						)[0] for k in pt_state_dict.keys()}
        )
        # Need to change some parameters name to match Flax names
        for pt_key, pt_tensor in pt_state_dict.items():
            A       :   int					=						tuple(pt_key.split('''.'''						)						)

            # remove base model prefix if necessary
            A       :   List[str]					=						pt_tuple_key[0] == model_prefix
            if load_model_with_head_into_base_model and has_base_model_prefix:
                A       :   Union[str, Any]					=						pt_tuple_key[1:]

            # Correctly rename weight parameters
            A,  A       :   Any					=						rename_key_and_reshape_tensor(
                snake_case__		,				snake_case__		,				snake_case__		,				snake_case__						)
            # add model prefix if necessary
            A       :   int					=						(model_prefix,) + flax_key in random_flax_state_dict
            if load_base_model_into_model_with_head and require_base_model_prefix:
                A       :   int					=						(model_prefix,) + flax_key

            if flax_key in random_flax_state_dict:
                if flax_tensor.shape != random_flax_state_dict[flax_key].shape:
                    raise ValueError(
                        F'PyTorch checkpoint seems to be incorrect. Weight {pt_key} was expected to be of shape '
                        F'{random_flax_state_dict[flax_key].shape}, but is {flax_tensor.shape}.'						)

            # add batch stats if the model contains batchnorm layers
            if "batch_stats" in flax_model.params:
                if "mean" in flax_key[-1]:
                    A       :   Optional[int]					=						jnp.asarray(snake_case__						)
                    continue
                if "var" in flax_key[-1]:
                    A       :   Optional[int]					=						jnp.asarray(snake_case__						)
                    continue
                # remove num_batches_tracked key
                if "num_batches_tracked" in flax_key[-1]:
                    flax_state_dict.pop(snake_case__		,				snake_case__						)
                    continue

                # also add unexpected weight so that warning is thrown
                A       :   Optional[Any]					=						jnp.asarray(snake_case__						)

            else:
                # also add unexpected weight so that warning is thrown
                A       :   Optional[Any]					=						jnp.asarray(snake_case__						)
    return unflatten_dict(snake_case__						)







def 		lowerCAmelCase_				(   snake_case__		,				snake_case__						):




    '''simple docstring'''



    A       :   Dict					=						os.path.abspath(snake_case__						)
    logger.info(F'Loading Flax weights from {flax_checkpoint_path}'						)

    # import correct flax class
    A       :   List[str]					=						getattr(snake_case__		,				'''Flax''' + model.__class__.__name__						)

    # load flax weight dict
    with open(snake_case__		,				'''rb'''						) as state_f:
        try:
            A       :   int					=						from_bytes(snake_case__		,				state_f.read()						)
        except UnpicklingError:
            raise EnvironmentError(F'Unable to convert {flax_checkpoint_path} to Flax deserializable object. '						)

    return load_flax_weights_in_pytorch_model(snake_case__		,				snake_case__						)







def 		lowerCAmelCase_				(   snake_case__		,				snake_case__						):




    '''simple docstring'''



    try:
        import torch  # noqa: F401
    except ImportError:
        logger.error(
            '''Loading a Flax weights in PyTorch, requires both PyTorch and Flax to be installed. Please see'''
            ''' https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation'''
            ''' instructions.'''						)
        raise

    # check if we have bf16 weights
    A       :   List[str]					=						flatten_dict(jax.tree_util.tree_map(lambda snake_case__						: x.dtype == jnp.bfloataa		,				snake_case__						)						).values()
    if any(snake_case__						):
        # convert all weights to fp32 if the are bf16 since torch.from_numpy can-not handle bf16
        # and bf16 is not fully supported in PT yet.
        logger.warning(
            '''Found ``bfloat16`` weights in Flax model. Casting all ``bfloat16`` weights to ``float32`` '''
            '''before loading those in PyTorch model.'''						)
        A       :   Optional[Any]					=						jax.tree_util.tree_map(
            lambda snake_case__						: params.astype(np.floataa						) if params.dtype == jnp.bfloataa else params		,				snake_case__						)

    A       :   Union[str, Any]					=						flatten_dict(snake_case__						)
    A       :   List[Any]					=						pt_model.state_dict()

    A       :   Union[str, Any]					=						(pt_model.base_model_prefix in flax_state) and (
        pt_model.base_model_prefix not in {k.split('''.'''						)[0] for k in pt_model_dict.keys()}
    )
    A       :   Tuple					=						(pt_model.base_model_prefix not in flax_state) and (
        pt_model.base_model_prefix in {k.split('''.'''						)[0] for k in pt_model_dict.keys()}
    )

    # keep track of unexpected & missing keys
    A       :   int					=						[]
    A       :   Any					=						set(pt_model_dict.keys()						)

    for flax_key_tuple, flax_tensor in flax_state_dict.items():
        A       :   Union[str, Any]					=						flax_key_tuple[0] == pt_model.base_model_prefix
        A       :   int					=						'''.'''.join((pt_model.base_model_prefix,) + flax_key_tuple						) in pt_model_dict

        # adapt flax_key to prepare for loading from/to base model only
        if load_model_with_head_into_base_model and has_base_model_prefix:
            A       :   List[str]					=						flax_key_tuple[1:]
        elif load_base_model_into_model_with_head and require_base_model_prefix:
            A       :   Optional[Any]					=						(pt_model.base_model_prefix,) + flax_key_tuple

        # rename flax weights to PyTorch format
        if flax_key_tuple[-1] == "kernel" and flax_tensor.ndim == 4 and ".".join(snake_case__						) not in pt_model_dict:
            # conv layer
            A       :   Optional[int]					=						flax_key_tuple[:-1] + ('''weight''',)
            A       :   Optional[int]					=						jnp.transpose(snake_case__		,				(3, 2, 0, 1)						)
        elif flax_key_tuple[-1] == "kernel" and ".".join(snake_case__						) not in pt_model_dict:
            # linear layer
            A       :   Tuple					=						flax_key_tuple[:-1] + ('''weight''',)
            A       :   Tuple					=						flax_tensor.T
        elif flax_key_tuple[-1] in ["scale", "embedding"]:
            A       :   Optional[int]					=						flax_key_tuple[:-1] + ('''weight''',)

        # adding batch stats from flax batch norm to pt
        elif "mean" in flax_key_tuple[-1]:
            A       :   Tuple					=						flax_key_tuple[:-1] + ('''running_mean''',)
        elif "var" in flax_key_tuple[-1]:
            A       :   Tuple					=						flax_key_tuple[:-1] + ('''running_var''',)

        if "batch_stats" in flax_state:
            A       :   List[Any]					=						'''.'''.join(flax_key_tuple[1:]						)  # Remove the params/batch_stats header
        else:
            A       :   Union[str, Any]					=						'''.'''.join(snake_case__						)

        # We also need to look at `pt_model_dict` and see if there are keys requiring further transformation.
        A       :   int					=						{}
        # New `weight_norm` from https://github.com/huggingface/transformers/pull/24030
        for key in pt_model_dict:
            A       :   Optional[int]					=						key.split('''.'''						)
            A       :   Dict					=						None
            if key_components[-3::2] == ["parametrizations", "original0"]:
                A       :   List[str]					=						key_components[-2] + '''_g'''
            elif key_components[-3::2] == ["parametrizations", "original1"]:
                A       :   List[Any]					=						key_components[-2] + '''_v'''
            if name is not None:
                A       :   str					=						key_components[:-3] + [name]
                A       :   Optional[Any]					=						'''.'''.join(snake_case__						)
                A       :   Optional[Any]					=						key

        if flax_key in special_pt_names:
            A       :   Optional[Any]					=						special_pt_names[flax_key]

        if flax_key in pt_model_dict:
            if flax_tensor.shape != pt_model_dict[flax_key].shape:
                raise ValueError(
                    F'Flax checkpoint seems to be incorrect. Weight {flax_key_tuple} was expected '
                    F'to be of shape {pt_model_dict[flax_key].shape}, but is {flax_tensor.shape}.'						)
            else:
                # add weight to pytorch dict
                A       :   Dict					=						np.asarray(snake_case__						) if not isinstance(snake_case__		,				np.ndarray						) else flax_tensor
                A       :   Dict					=						torch.from_numpy(snake_case__						)
                # remove from missing keys
                missing_keys.remove(snake_case__						)
        else:
            # weight is not expected by PyTorch model
            unexpected_keys.append(snake_case__						)

    pt_model.load_state_dict(snake_case__						)

    # re-transform missing_keys to list
    A       :   List[Any]					=						list(snake_case__						)

    if len(snake_case__						) > 0:
        logger.warning(
            '''Some weights of the Flax model were not used when initializing the PyTorch model'''
            F' {pt_model.__class__.__name__}: {unexpected_keys}\n- This IS expected if you are initializing'
            F' {pt_model.__class__.__name__} from a Flax model trained on another task or with another architecture'
            ''' (e.g. initializing a BertForSequenceClassification model from a FlaxBertForPreTraining model).\n- This'''
            F' IS NOT expected if you are initializing {pt_model.__class__.__name__} from a Flax model that you expect'
            ''' to be exactly identical (e.g. initializing a BertForSequenceClassification model from a'''
            ''' FlaxBertForSequenceClassification model).'''						)
    else:
        logger.warning(F'All Flax model weights were used when initializing {pt_model.__class__.__name__}.\n'						)
    if len(snake_case__						) > 0:
        logger.warning(
            F'Some weights of {pt_model.__class__.__name__} were not initialized from the Flax model and are newly'
            F' initialized: {missing_keys}\nYou should probably TRAIN this model on a down-stream task to be able to'
            ''' use it for predictions and inference.'''						)
    else:
        logger.warning(
            F'All the weights of {pt_model.__class__.__name__} were initialized from the Flax model.\n'
            '''If your task is similar to the task the model of the checkpoint was trained on, '''
            F'you can already use {pt_model.__class__.__name__} for predictions without further training.'						)

    return pt_model




