


"""simple docstring"""





import json
import logging
import os
import socket

import git
import numpy as np
import torch


logging.basicConfig(
    format="%(asctime)s - %(levelname)s - %(name)s - PID: %(process)d -  %(message)s",
    datefmt="%m/%d/%Y %H:%M:%S",
    level=logging.INFO,
)
_UpperCamelCase     :		str											=					logging.getLogger(__name__)





def        a_  (   _lowerCAmelCase						:				str  ):





       '''simple docstring'''

       lowercase__    :	Any     					=			git.Repo(search_parent_directories=_lowerCAmelCase  )
       lowercase__    :	Any     					=			{
           'repo_id': str(_lowerCAmelCase  ),
           'repo_sha': str(repo.head.object.hexsha  ),
           'repo_branch': str(repo.active_branch  ),
       }

       with open(os.path.join(_lowerCAmelCase     ,				'git_log.json'  )     ,				'w'  ) as f:
              json.dump(_lowerCAmelCase     ,				_lowerCAmelCase     ,				indent=4  )





def        a_  (   _lowerCAmelCase						:				List[Any]  ):





       '''simple docstring'''

       if params.n_gpu <= 0:
              lowercase__    :	Dict     					=			0
              lowercase__    :	List[Any]     					=			-1
              lowercase__    :	List[str]     					=			True
              lowercase__    :	Union[str, Any]     					=			False
              return

       assert torch.cuda.is_available()

       logger.info('Initializing GPUs'  )
       if params.n_gpu > 1:
              assert params.local_rank != -1

              lowercase__    :	Optional[int]     					=			int(os.environ['WORLD_SIZE']  )
              lowercase__    :	Union[str, Any]     					=			int(os.environ['N_GPU_NODE']  )
              lowercase__    :	List[Any]     					=			int(os.environ['RANK']  )

              # number of nodes / node ID
              lowercase__    :	int     					=			params.world_size // params.n_gpu_per_node
              lowercase__    :	List[Any]     					=			params.global_rank // params.n_gpu_per_node
              lowercase__    :	List[str]     					=			True

              assert params.n_nodes == int(os.environ['N_NODES']  )
              assert params.node_id == int(os.environ['NODE_RANK']  )

       # local job (single GPU)
       else:
              assert params.local_rank == -1

              lowercase__    :	List[str]     					=			1
              lowercase__    :	Tuple     					=			0
              lowercase__    :	int     					=			0
              lowercase__    :	List[Any]     					=			0
              lowercase__    :	int     					=			1
              lowercase__    :	List[Any]     					=			1
              lowercase__    :	Tuple     					=			False

       # sanity checks
       assert params.n_nodes >= 1
       assert 0 <= params.node_id < params.n_nodes
       assert 0 <= params.local_rank <= params.global_rank < params.world_size
       assert params.world_size == params.n_nodes * params.n_gpu_per_node

       # define whether this is the master process / if we are in multi-node distributed mode
       lowercase__    :	Tuple     					=			params.node_id == 0 and params.local_rank == 0
       lowercase__    :	Optional[int]     					=			params.n_nodes > 1

       # summary
       lowercase__    :	Union[str, Any]     					=			f"""--- Global rank: {params.global_rank} - """
       logger.info(PREFIX + 'Number of nodes: %i' % params.n_nodes  )
       logger.info(PREFIX + 'Node ID        : %i' % params.node_id  )
       logger.info(PREFIX + 'Local rank     : %i' % params.local_rank  )
       logger.info(PREFIX + 'World size     : %i' % params.world_size  )
       logger.info(PREFIX + 'GPUs per node  : %i' % params.n_gpu_per_node  )
       logger.info(PREFIX + 'Master         : %s' % str(params.is_master  )  )
       logger.info(PREFIX + 'Multi-node     : %s' % str(params.multi_node  )  )
       logger.info(PREFIX + 'Multi-GPU      : %s' % str(params.multi_gpu  )  )
       logger.info(PREFIX + 'Hostname       : %s' % socket.gethostname()  )

       # set GPU device
       torch.cuda.set_device(params.local_rank  )

       # initialize multi-GPU
       if params.multi_gpu:
              logger.info('Initializing PyTorch distributed'  )
              torch.distributed.init_process_group(
                  init_method='env://'     ,				backend='nccl'     ,				)






def        a_  (   _lowerCAmelCase						:				List[Any]  ):





       '''simple docstring'''

       np.random.seed(args.seed  )
       torch.manual_seed(args.seed  )
       if args.n_gpu > 0:
              torch.cuda.manual_seed_all(args.seed  )


"""simple docstring"""





import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.metrics import mean_absolute_error, mean_squared_error
from sklearn.model_selection import train_test_split
from xgboost import XGBRegressor





def        a_  (   _lowerCAmelCase						:				dict  ):





       '''simple docstring'''

       return (data["data"], data["target"])





def        a_  (   _lowerCAmelCase						:				np.ndarray     ,				_lowerCAmelCase						:				np.ndarray     ,				_lowerCAmelCase						:				np.ndarray  ):





       '''simple docstring'''

       lowercase__    :	Any     					=			XGBRegressor(verbosity=0     ,				random_state=42  )
       xgb.fit(_lowerCAmelCase     ,				_lowerCAmelCase  )
       # Predict target for test data
       lowercase__    :	str     					=			xgb.predict(_lowerCAmelCase  )
       lowercase__    :	Union[str, Any]     					=			predictions.reshape(len(_lowerCAmelCase  )     ,				1  )
       return predictions





def        a_  (   ):





       '''simple docstring'''

       lowercase__    :	Optional[Any]     					=			fetch_california_housing()
       lowercase__					,   lowercase__    :	str     					=			data_handling(_lowerCAmelCase  )
       lowercase__					,   lowercase__					,   lowercase__					,   lowercase__    :	str     					=			train_test_split(
           _lowerCAmelCase     ,				_lowerCAmelCase     ,				test_size=0.2_5     ,				random_state=1  )
       lowercase__    :	Any     					=			xgboost(_lowerCAmelCase     ,				_lowerCAmelCase     ,				_lowerCAmelCase  )
       # Error printing
       print(f"""Mean Absolute Error : {mean_absolute_error(_lowerCAmelCase     ,				_lowerCAmelCase  )}"""  )
       print(f"""Mean Square Error  : {mean_squared_error(_lowerCAmelCase     ,				_lowerCAmelCase  )}"""  )


if __name__ == "__main__":
       import doctest

       doctest.testmod(verbose=True)
       main()

