



from .constants import (
    MODEL_NAME,
    OPTIMIZER_NAME,
    RNG_STATE_NAME,
    SAFE_WEIGHTS_INDEX_NAME,
    SAFE_WEIGHTS_NAME,
    SCALER_NAME,
    SCHEDULER_NAME,
    TORCH_LAUNCH_PARAMS,
    WEIGHTS_INDEX_NAME,
    WEIGHTS_NAME,
)
from .dataclasses import (
    BnbQuantizationConfig,
    ComputeEnvironment,
    CustomDtype,
    DeepSpeedPlugin,
    DistributedDataParallelKwargs,
    DistributedType,
    DynamoBackend,
    FPaRecipeKwargs,
    FullyShardedDataParallelPlugin,
    GradientAccumulationPlugin,
    GradScalerKwargs,
    InitProcessGroupKwargs,
    KwargsHandler,
    LoggerType,
    MegatronLMPlugin,
    PrecisionType,
    ProjectConfiguration,
    RNGType,
    SageMakerDistributedType,
    TensorInformation,
    TorchDynamoPlugin,
)
from .environment import get_int_from_env, parse_choice_from_env, parse_flag_from_env
from .imports import (
    get_ccl_version,
    is_abit_bnb_available,
    is_abit_bnb_available,
    is_aim_available,
    is_bfaa_available,
    is_bnb_available,
    is_botoa_available,
    is_ccl_available,
    is_comet_ml_available,
    is_datasets_available,
    is_deepspeed_available,
    is_fpa_available,
    is_ipex_available,
    is_megatron_lm_available,
    is_mlflow_available,
    is_mps_available,
    is_npu_available,
    is_rich_available,
    is_safetensors_available,
    is_sagemaker_available,
    is_tensorboard_available,
    is_tpu_available,
    is_transformers_available,
    is_wandb_available,
    is_xpu_available,
)
from .modeling import (
    check_device_map,
    check_tied_parameters_in_config,
    check_tied_parameters_on_same_device,
    compute_module_sizes,
    convert_file_size_to_int,
    dtype_byte_size,
    find_tied_parameters,
    get_balanced_memory,
    get_max_layer_size,
    get_max_memory,
    get_mixed_precision_context_manager,
    id_tensor_storage,
    infer_auto_device_map,
    load_checkpoint_in_model,
    load_offloaded_weights,
    load_state_dict,
    named_module_tensors,
    retie_parameters,
    set_module_tensor_to_device,
    shard_checkpoint,
)
from .offload import (
    OffloadedWeightsLoader,
    PrefixedDataset,
    extract_submodules_state_dict,
    load_offloaded_weight,
    offload_state_dict,
    offload_weight,
    save_offload_index,
)
from .operations import (
    broadcast,
    broadcast_object_list,
    concatenate,
    convert_outputs_to_fpaa,
    convert_to_fpaa,
    find_batch_size,
    find_device,
    gather,
    gather_object,
    get_data_structure,
    honor_type,
    initialize_tensors,
    is_namedtuple,
    is_tensor_information,
    is_torch_tensor,
    listify,
    pad_across_processes,
    recursively_apply,
    reduce,
    send_to_device,
    slice_tensors,
)
from .versions import compare_versions, is_torch_version


if is_deepspeed_available():
						from .deepspeed import (
						    DeepSpeedEngineWrapper,
						    DeepSpeedOptimizerWrapper,
						    DeepSpeedSchedulerWrapper,
						    DummyOptim,
						    DummyScheduler,
						    HfDeepSpeedConfig,
						)

from .bnb import has_abit_bnb_layers, load_and_quantize_model
from .fsdp_utils import load_fsdp_model, load_fsdp_optimizer, save_fsdp_model, save_fsdp_optimizer
from .launch import (
    PrepareForLaunch,
    _filter_args,
    prepare_deepspeed_cmd_env,
    prepare_multi_gpu_env,
    prepare_sagemager_args_inputs,
    prepare_simple_launcher_cmd_env,
    prepare_tpu,
)
from .megatron_lm import (
    AbstractTrainStep,
    BertTrainStep,
    GPTTrainStep,
    MegatronEngine,
    MegatronLMDummyDataLoader,
    MegatronLMDummyScheduler,
    MegatronLMOptimizerWrapper,
    MegatronLMSchedulerWrapper,
    TaTrainStep,
    avg_losses_across_data_parallel_group,
    gather_across_data_parallel_groups,
)
from .megatron_lm import initialize as megatron_lm_initialize
from .megatron_lm import prepare_data_loader as megatron_lm_prepare_data_loader
from .megatron_lm import prepare_model as megatron_lm_prepare_model
from .megatron_lm import prepare_optimizer as megatron_lm_prepare_optimizer
from .megatron_lm import prepare_scheduler as megatron_lm_prepare_scheduler
from .memory import find_executable_batch_size, release_memory
from .other import (
    extract_model_from_parallel,
    get_pretty_name,
    is_port_in_use,
    merge_dicts,
    patch_environment,
    save,
    wait_for_everyone,
    write_basic_config,
)
from .random import set_seed, synchronize_rng_state, synchronize_rng_states
from .torch_xla import install_xla
from .tqdm import tqdm
from .transformer_engine import convert_model, has_transformer_engine_layers





import logging

import numpy as np
import pytest
from scipy.linalg import eigh

logging.basicConfig(level=logging.INFO, format="%(message)s")






def        A       (      _lowerCamelCase						):





							'''simple docstring'''




							return input_array.reshape((input_array.size, 1)						)






def        A       (      _lowerCamelCase       ,				_lowerCamelCase       ,				_lowerCamelCase						):





							'''simple docstring'''




							_lowerCAmelCase  :							Any				     =					np.nan
							for i in range(_lowerCamelCase						):
														_lowerCAmelCase  :							Tuple				     =					features[:, labels == i]
														_lowerCAmelCase  :							Dict				     =					data.mean(1						)
														# Centralize the data of class i
														_lowerCAmelCase  :							Union[str, Any]				     =					data - column_reshape(_lowerCamelCase						)
														if i > 0:
																					# If covariance_sum is not None
																					covariance_sum += np.dot(_lowerCamelCase       ,				centered_data.T						)
														else:
																					# If covariance_sum is np.nan (i.e. first loop)
																					_lowerCAmelCase  :							int				     =					np.dot(_lowerCamelCase       ,				centered_data.T						)

							return covariance_sum / features.shape[1]






def        A       (      _lowerCamelCase       ,				_lowerCamelCase       ,				_lowerCamelCase						):





							'''simple docstring'''




							_lowerCAmelCase  :							Optional[Any]				     =					features.mean(1						)
							_lowerCAmelCase  :							List[str]				     =					np.nan
							for i in range(_lowerCamelCase						):
														_lowerCAmelCase  :							str				     =					features[:, labels == i]
														_lowerCAmelCase  :							Optional[Any]				     =					data.shape[1]
														_lowerCAmelCase  :							Optional[Any]				     =					data.mean(1						)
														if i > 0:
																					# If covariance_sum is not None
																					covariance_sum += device_data * np.dot(
																					    column_reshape(_lowerCamelCase						) - column_reshape(_lowerCamelCase						)       ,				(column_reshape(_lowerCamelCase						) - column_reshape(_lowerCamelCase						)).T       ,				)
														else:
																					# If covariance_sum is np.nan (i.e. first loop)
																					_lowerCAmelCase  :							Optional[Any]				     =					device_data * np.dot(
																					    column_reshape(_lowerCamelCase						) - column_reshape(_lowerCamelCase						)       ,				(column_reshape(_lowerCamelCase						) - column_reshape(_lowerCamelCase						)).T       ,				)

							return covariance_sum / features.shape[1]






def        A       (      _lowerCamelCase       ,				_lowerCamelCase						):





							'''simple docstring'''




							if features.any():
														_lowerCAmelCase  :							List[Any]				     =					features.mean(1						)
														# Center the dataset
														_lowerCAmelCase  :							List[Any]				     =					features - np.reshape(_lowerCamelCase       ,				(data_mean.size, 1)						)
														_lowerCAmelCase  :							Optional[Any]				     =					np.dot(_lowerCamelCase       ,				centered_data.T						) / features.shape[1]
														_lowerCAmelCase     ,					_lowerCAmelCase  :							List[Any]				     =					np.linalg.eigh(_lowerCamelCase						)
														# Take all the columns in the reverse order (-1), and then takes only the first
														_lowerCAmelCase  :							Union[str, Any]				     =					eigenvectors[:, ::-1][:, 0:dimensions]
														# Project the database on the new space
														_lowerCAmelCase  :							List[Any]				     =					np.dot(filtered_eigenvectors.T       ,				_lowerCamelCase						)
														logging.info("Principal Component Analysis computed"						)

														return projected_data
							else:
														logging.basicConfig(level=logging.ERROR       ,				format="%(message)s"       ,				force=_lowerCamelCase						)
														logging.error("Dataset empty"						)
														raise AssertionError






def        A       (      _lowerCamelCase       ,				_lowerCamelCase       ,				_lowerCamelCase       ,				_lowerCamelCase						):





							'''simple docstring'''




							assert classes > dimensions

							# Check if features have been already loaded
							if features.any:
														_lowerCAmelCase     ,					_lowerCAmelCase  :							List[str]				     =					eigh(
														    covariance_between_classes(_lowerCamelCase       ,				_lowerCamelCase       ,				_lowerCamelCase						)       ,				covariance_within_classes(_lowerCamelCase       ,				_lowerCamelCase       ,				_lowerCamelCase						)       ,				)
														_lowerCAmelCase  :							List[str]				     =					eigenvectors[:, ::-1][:, :dimensions]
														_lowerCAmelCase     ,					_lowerCAmelCase     ,					_lowerCAmelCase  :							Any				     =					np.linalg.svd(_lowerCamelCase						)
														_lowerCAmelCase  :							Optional[Any]				     =					svd_matrix[:, 0:dimensions]
														_lowerCAmelCase  :							str				     =					np.dot(filtered_svd_matrix.T       ,				_lowerCamelCase						)
														logging.info("Linear Discriminant Analysis computed"						)

														return projected_data
							else:
														logging.basicConfig(level=logging.ERROR       ,				format="%(message)s"       ,				force=_lowerCamelCase						)
														logging.error("Dataset empty"						)
														raise AssertionError






def        A       (      ):





							'''simple docstring'''




							_lowerCAmelCase  :							Optional[int]				     =					np.array([[1, 2, 3, 4, 5], [2, 3, 4, 5, 6], [3, 4, 5, 6, 7]]						)
							_lowerCAmelCase  :							List[Any]				     =					np.array([0, 0, 0, 1, 1]						)
							_lowerCAmelCase  :							List[Any]				     =					2
							_lowerCAmelCase  :							Union[str, Any]				     =					2

							# Assert that the function raises an AssertionError if dimensions > classes
							with pytest.raises(_lowerCamelCase						) as error_info:
														_lowerCAmelCase  :							Union[str, Any]				     =					linear_discriminant_analysis(
														    _lowerCamelCase       ,				_lowerCamelCase       ,				_lowerCamelCase       ,				_lowerCamelCase						)
														if isinstance(_lowerCamelCase       ,				np.ndarray						):
																					raise AssertionError(
																					    "Did not raise AssertionError for dimensions > classes"						)
														assert error_info.type is AssertionError






def        A       (      ):





							'''simple docstring'''




							_lowerCAmelCase  :							Optional[Any]				     =					np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]						)
							_lowerCAmelCase  :							List[str]				     =					2
							_lowerCAmelCase  :							List[Any]				     =					np.array([[6.92_82_03_23, 8.66_02_54_04, 10.39_23_04_85], [3.0, 3.0, 3.0]]						)

							with pytest.raises(_lowerCamelCase						) as error_info:
														_lowerCAmelCase  :							Tuple				     =					principal_component_analysis(_lowerCamelCase       ,				_lowerCamelCase						)
														if not np.allclose(_lowerCamelCase       ,				_lowerCamelCase						):
																					raise AssertionError
														assert error_info.type is AssertionError


if __name__ == "__main__":
						import doctest

						doctest.testmod()
