


'''simple docstring'''

from sklearn.metrics import mean_squared_error

import datasets


lowerCamelCase							:   Dict  						=	'\\n@article{scikit-learn,\n title={Scikit-learn: Machine Learning in {P}ython},\n author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n         and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n         and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n         Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n journal={Journal of Machine Learning Research},\n volume={12},\n pages={2825--2830},\n year={2011}\n}\n'

lowerCamelCase							:   Tuple  						=	'\\nMean Squared Error(MSE) is the average of the square of difference between the predicted\nand actual values.\n'


lowerCamelCase							:   List[str]  						=	'\nArgs:\n    predictions: array-like of shape (n_samples,) or (n_samples, n_outputs)\n        Estimated target values.\n    references: array-like of shape (n_samples,) or (n_samples, n_outputs)\n        Ground truth (correct) target values.\n    sample_weight: array-like of shape (n_samples,), default=None\n        Sample weights.\n    multioutput: {"raw_values", "uniform_average"} or array-like of shape (n_outputs,), default="uniform_average"\n        Defines aggregating of multiple output values. Array-like value defines weights used to average errors.\n\n        "raw_values" : Returns a full set of errors in case of multioutput input.\n\n        "uniform_average" : Errors of all outputs are averaged with uniform weight.\n\n    squared : bool, default=True\n        If True returns MSE value, if False returns RMSE (Root Mean Squared Error) value.\n\nReturns:\n    mse : mean squared error.\nExamples:\n\n    >>> mse_metric = datasets.load_metric("mse")\n    >>> predictions = [2.5, 0.0, 2, 8]\n    >>> references = [3, -0.5, 2, 7]\n    >>> results = mse_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'mse\': 0.375}\n    >>> rmse_result = mse_metric.compute(predictions=predictions, references=references, squared=False)\n    >>> print(rmse_result)\n    {\'mse\': 0.6123724356957945}\n\n    If you\'re using multi-dimensional lists, then set the config as follows :\n\n    >>> mse_metric = datasets.load_metric("mse", "multilist")\n    >>> predictions = [[0.5, 1], [-1, 1], [7, -6]]\n    >>> references = [[0, 2], [-1, 2], [8, -5]]\n    >>> results = mse_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'mse\': 0.7083333333333334}\n    >>> results = mse_metric.compute(predictions=predictions, references=references, multioutput=\'raw_values\')\n    >>> print(results) # doctest: +NORMALIZE_WHITESPACE\n    {\'mse\': array([0.41666667, 1. ])}\n'
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION  ,     _KWARGS_DESCRIPTION     )
class   __lowerCAmelCase						(datasets.Metric     ):





      '''simple docstring'''






      def       UpperCamelCase__		(self    :    Tuple ):

             '''simple docstring'''







             return datasets.MetricInfo(
                 description=_DESCRIPTION   ,						citation=_CITATION   ,						inputs_description=_KWARGS_DESCRIPTION   ,						features=datasets.Features(self._get_feature_types() )   ,						reference_urls=[
                     '''https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html'''
                 ]   ,						)



      def       UpperCamelCase__		(self    :    Tuple ):

             '''simple docstring'''







             if self.config_name == "multilist":
                    return {
                        "predictions": datasets.Sequence(datasets.Value('''float''' ) ),
                        "references": datasets.Sequence(datasets.Value('''float''' ) ),
                    }
             else:
                    return {
                        "predictions": datasets.Value('''float''' ),
                        "references": datasets.Value('''float''' ),
                    }






      def       UpperCamelCase__		(self    :    List[str]   ,						UpperCamelCase    :    Optional[Any]   ,						UpperCamelCase    :    str   ,						UpperCamelCase    :    Optional[int]=None   ,						UpperCamelCase    :    Tuple="uniform_average"   ,						UpperCamelCase    :    Union[str, Any]=True ):

             '''simple docstring'''







             lowercase__      			= mean_squared_error(
                 UpperCamelCase   ,						UpperCamelCase   ,						sample_weight=UpperCamelCase   ,						multioutput=UpperCamelCase   ,						squared=UpperCamelCase )

             return {"mse": mse}








'''simple docstring'''

import dataclasses
import re
import string
from typing import Any, Dict, Iterator, List, Mapping, Optional, Sequence, Tuple

import numpy as np

from . import residue_constants


lowerCamelCase							:   str  						=	Mapping[str, np.ndarray]
lowerCamelCase							:   List[Any]  						=	Mapping[str, Any]  # Is a nested dict.
lowerCamelCase							:   Any  						=	0.0_1
@dataclasses.dataclass(frozen=lowercase_     )
class   __lowerCAmelCase						:





      '''simple docstring'''






      lowerCAmelCase__					:     np.ndarray  # [num_res, num_atom_type, 3]

      # Amino-acid type for each residue represented as an integer between 0 and
      # 20, where 20 is 'X'.
      lowerCAmelCase__					:     np.ndarray  # [num_res]

      # Binary float mask to indicate presence of a particular atom. 1.0 if an atom
      # is present and 0.0 if not. This should be used for loss masking.
      lowerCAmelCase__					:     np.ndarray  # [num_res, num_atom_type]

      # Residue index as used in PDB. It is not necessarily continuous or 0-indexed.
      lowerCAmelCase__					:     np.ndarray  # [num_res]

      # B-factors, or temperature factors, of each residue (in sq. angstroms units),
      # representing the displacement of the residue from its ground truth mean
      # value.
      lowerCAmelCase__					:     np.ndarray  # [num_res, num_atom_type]

      # Chain indices for multi-chain predictions
      lowerCAmelCase__					:     Optional[np.ndarray]  					=							None

      # Optional remark about the protein. Included as a comment in output PDB
      # files
      lowerCAmelCase__					:     Optional[str]  					=							None

      # Templates used to generate this protein (prediction-only)
      lowerCAmelCase__					:     Optional[Sequence[str]]  					=							None

      # Chain corresponding to each parent
      lowerCAmelCase__					:     Optional[Sequence[int]]  					=							None






def _SCREAMING_SNAKE_CASE      (A       )       ->       Protein:






       """simple docstring"""







       lowercase__      			= R'''(\[[A-Z]+\]\n)'''
       lowercase__      			= [tag.strip() for tag in re.split(A  , A       ) if len(A       ) > 0]
       lowercase__      			= zip(tags[0::2]  , [l.split('''\n'''       ) for l in tags[1::2]]       )

       lowercase__      			= ["N", "CA", "C"]
       lowercase__      			= None
       lowercase__      			= None
       lowercase__      			= None
       for g in groups:
              if "[PRIMARY]" == g[0]:
                     lowercase__      			= g[1][0].strip()
                     for i in range(len(A       )       ):
                            if seq[i] not in residue_constants.restypes:
                                   lowercase__      			= '''X'''  # FIXME: strings are immutable
                     lowercase__      			= np.array(
                         [residue_constants.restype_order.get(A  , residue_constants.restype_num       ) for res_symbol in seq]       )
              elif "[TERTIARY]" == g[0]:
                     lowercase__      			= []
                     for axis in range(3       ):
                            tertiary.append(list(map(A  , g[1][axis].split()       )       )       )
                     lowercase__      			= np.array(A       )
                     lowercase__      			= np.zeros((len(tertiary[0]       ) // 3, residue_constants.atom_type_num, 3)       ).astype(np.floataa       )
                     for i, atom in enumerate(A       ):
                            lowercase__      			= np.transpose(tertiary_np[:, i::3]       )
                     atom_positions *= PICO_TO_ANGSTROM
              elif "[MASK]" == g[0]:
                     lowercase__      			= np.array(list(map({'''-''': 0, '''+''': 1}.get  , g[1][0].strip()       )       )       )
                     lowercase__      			= np.zeros(
                         (
                             len(A       ),
                             residue_constants.atom_type_num,
                         )       ).astype(np.floataa       )
                     for i, atom in enumerate(A       ):
                            lowercase__      			= 1
                     atom_mask *= mask[..., None]

       assert aatype is not None

       return Protein(
           atom_positions=A  , atom_mask=A  , aatype=A  , residue_index=np.arange(len(A       )       )  , b_factors=A  , )

def _SCREAMING_SNAKE_CASE      (A  , A = 0       )       ->       List[str]:






       """simple docstring"""







       lowercase__      			= []

       lowercase__      			= prot.remark
       if remark is not None:
              pdb_headers.append(f"REMARK {remark}"       )

       lowercase__      			= prot.parents
       lowercase__      			= prot.parents_chain_index
       if parents is not None and parents_chain_index is not None:
              lowercase__      			= [p for i, p in zip(A  , A       ) if i == chain_id]

       if parents is None or len(A       ) == 0:
              lowercase__      			= ['''N/A''']

       pdb_headers.append(f"PARENT {' '.join(A       )}"       )

       return pdb_headers

def _SCREAMING_SNAKE_CASE      (A  , A       )       ->       str:






       """simple docstring"""







       lowercase__      			= []
       lowercase__      			= pdb_str.split('''\n'''       )

       lowercase__      			= prot.remark
       if remark is not None:
              out_pdb_lines.append(f"REMARK {remark}"       )

       lowercase__      			= 42
       if prot.parents is not None and len(prot.parents       ) > 0:
              lowercase__      			= []
              if prot.parents_chain_index is not None:
                     lowercase__      			= {}
                     for p, i in zip(prot.parents  , prot.parents_chain_index       ):
                            parent_dict.setdefault(str(A       )  , []       )
                            parent_dict[str(A       )].append(A       )

                     lowercase__      			= max([int(A       ) for chain_idx in parent_dict]       )
                     for i in range(max_idx + 1       ):
                            lowercase__      			= parent_dict.get(str(A       )  , ['''N/A''']       )
                            parents_per_chain.append(A       )
              else:
                     parents_per_chain.append(list(prot.parents       )       )
       else:
              lowercase__      			= [['''N/A''']]

       def make_parent_line(A       ) -> str:
              return f"PARENT {' '.join(A       )}"

       out_pdb_lines.append(make_parent_line(parents_per_chain[0]       )       )

       lowercase__      			= 0
       for i, l in enumerate(A       ):
              if "PARENT" not in l and "REMARK" not in l:
                     out_pdb_lines.append(A       )
              if "TER" in l and "END" not in lines[i + 1]:
                     chain_counter += 1
                     if not chain_counter >= len(A       ):
                            lowercase__      			= parents_per_chain[chain_counter]
                     else:
                            lowercase__      			= ['''N/A''']

                     out_pdb_lines.append(make_parent_line(A       )       )

       return "\n".join(A       )

def _SCREAMING_SNAKE_CASE      (A       )       ->       str:






       """simple docstring"""







       lowercase__      			= residue_constants.restypes + ['''X''']

       def res_atoa(A       ) -> str:
              return residue_constants.restype_atoa.get(restypes[r]  , '''UNK'''       )

       lowercase__      			= residue_constants.atom_types

       lowercase__      			= []

       lowercase__      			= prot.atom_mask
       lowercase__      			= prot.aatype
       lowercase__      			= prot.atom_positions
       lowercase__      			= prot.residue_index.astype(np.intaa       )
       lowercase__      			= prot.b_factors
       lowercase__      			= prot.chain_index

       if np.any(aatype > residue_constants.restype_num       ):
              raise ValueError('''Invalid aatypes.'''       )

       lowercase__      			= get_pdb_headers(A       )
       if len(A       ) > 0:
              pdb_lines.extend(A       )

       lowercase__      			= aatype.shape[0]
       lowercase__      			= 1
       lowercase__      			= 0
       lowercase__      			= string.ascii_uppercase
       lowercase__      			= None
       # Add all atom sites.
       for i in range(A       ):
              lowercase__      			= res_atoa(aatype[i]       )
              for atom_name, pos, mask, b_factor in zip(A  , atom_positions[i]  , atom_mask[i]  , b_factors[i]       ):
                     if mask < 0.5:
                            continue

                     lowercase__      			= '''ATOM'''
                     lowercase__      			= atom_name if len(A       ) == 4 else f" {atom_name}"
                     lowercase__      			= ''''''
                     lowercase__      			= ''''''
                     lowercase__      			= 1.00
                     lowercase__      			= atom_name[0]  # Protein supports only C, N, O, S, this works.
                     lowercase__      			= ''''''

                     lowercase__      			= '''A'''
                     if chain_index is not None:
                            lowercase__      			= chain_tags[chain_index[i]]

                     # PDB is a columnar format, every space matters here!
                     lowercase__      			= (
                         f"{record_type:<6}{atom_index:>5} {name:<4}{alt_loc:>1}"
                         f"{res_name_a:>3} {chain_tag:>1}"
                         f"{residue_index[i]:>4}{insertion_code:>1}   "
                         f"{pos[0]:>8.3f}{pos[1]:>8.3f}{pos[2]:>8.3f}"
                         f"{occupancy:>6.2f}{b_factor:>6.2f}          "
                         f"{element:>2}{charge:>2}"
                     )
                     pdb_lines.append(A       )
                     atom_index += 1

              lowercase__      			= i == n - 1
              if chain_index is not None:
                     if i != n - 1 and chain_index[i + 1] != prev_chain_index:
                            lowercase__      			= True
                            lowercase__      			= chain_index[i + 1]

              if should_terminate:
                     # Close the chain.
                     lowercase__      			= '''TER'''
                     lowercase__      			= (
                         f"{chain_end:<6}{atom_index:>5}      {res_atoa(aatype[i]       ):>3} {chain_tag:>1}{residue_index[i]:>4}"
                     )
                     pdb_lines.append(A       )
                     atom_index += 1

                     if i != n - 1:
                            # "prev" is a misnomer here. This happens at the beginning of
                            # each new chain.
                            pdb_lines.extend(get_pdb_headers(A  , A       )       )

       pdb_lines.append('''END'''       )
       pdb_lines.append(''''''       )
       return "\n".join(A       )

def _SCREAMING_SNAKE_CASE      (A       )       ->       np.ndarray:






       """simple docstring"""







       return residue_constants.STANDARD_ATOM_MASK[prot.aatype]

def _SCREAMING_SNAKE_CASE      (A  , A  , A = None  , A = None  , A = None  , A = None  , A = None  , )       ->       Protein:






       """simple docstring"""







       return Protein(
           aatype=features['''aatype''']  , atom_positions=result['''final_atom_positions''']  , atom_mask=result['''final_atom_mask''']  , residue_index=features['''residue_index'''] + 1  , b_factors=b_factors if b_factors is not None else np.zeros_like(result['''final_atom_mask''']       )  , chain_index=A  , remark=A  , parents=A  , parents_chain_index=A  , )




