pyerualjetwork 4.3.8.dev14__py3-none-any.whl → 4.3.9b0__py3-none-any.whl

pyerualjetwork_afterburner/memory_operations.py

@@ -1,298 +0,0 @@
-import psutil
-import numpy as np
-import cupy as cp
-import logging
-
-def get_available_cpu_memory():
-    """
-    The function `get_available_memory` returns the amount of available memory in the system using the
-    `psutil` library.
-    :return: The function `get_available_memory()` returns the amount of available memory in bytes on
-    the system.
-    """
-    return psutil.virtual_memory().available
-
-def get_optimal_batch_size_for_cpu(x, data_size_bytes, available_memory):
-    """
-    The function calculates the optimal batch size for a given data size and available memory based on
-    the size of each element.
-    
-    :param x: `x` is a NumPy array representing the input data for which we want to determine the optimal batch size for processing on the CPU
-    
-    :param data_size_bytes: The `data_size_bytes` parameter represents the size of the data in bytes that you want to process in batches
-    
-    :param available_memory: The `available_memory` parameter represents the total memory available on the CPU in bytes. This function calculates the optimal batch size for processing data based on the provided parameters. Let me know if you need any further assistance or explanation!
-    
-    :return: the optimal batch size for a given array `x` based on the available memory and the size of each element in bytes.
-    """
-    safe_memory = available_memory * 0.25
-    element_size = data_size_bytes / x.size
-    return int(safe_memory / (element_size * 2))
-
-def transfer_to_cpu(x, dtype=np.float32):
-    """
-    The `transfer_to_cpu` function converts data to a specified data type on the CPU, handling memory constraints
-    by batching the conversion process and ensuring complete GPU memory cleanup.
-   
-    param x: Input data to transfer to CPU (CuPy array)
-    
-    param dtype: Target NumPy dtype for the output array (default: np.float32)
-    
-    return: NumPy array with the specified dtype
-    """
-    from .ui import loading_bars, initialize_loading_bar
-    try:
-        if isinstance(x, np.ndarray):
-            return x.astype(dtype) if x.dtype != dtype else x
-
-        x = x.astype(dtype=dtype, copy=False)
-        
-        data_size = x.nbytes
-        available_memory = get_available_cpu_memory()
-        logging.debug(f"Data size: {data_size/1e6:.2f}MB, Available memory: {available_memory/1e6:.2f}MB")
-        
-        pool = cp.get_default_memory_pool()
-        pinned_mempool = cp.cuda.PinnedMemoryPool()
-        
-        if data_size <= available_memory * 0.25:
-            try:
-                final_result = np.array(x.get(), dtype=dtype, copy=False)
-            finally:
-                del x
-                pool.free_all_blocks()
-                pinned_mempool.free_all_blocks()
-                cp.cuda.runtime.deviceSynchronize()
-            return final_result
-        
-        batch_size = max(get_optimal_batch_size_for_cpu(x, data_size, available_memory), 1)
-        total_batches = (len(x) + batch_size - 1) // batch_size
-        loading_bar = initialize_loading_bar(
-            total=total_batches,
-            desc='Transfering to CPU mem',
-            ncols=70,
-            bar_format=loading_bars()[0],
-            leave=False
-        )
-        logging.debug(f"Using batch size: {batch_size}")
-        
-        try:
-            sample_chunk = x[0:1]
-            sample_array = np.array(sample_chunk.get(), dtype=dtype)
-            chunk_shape = sample_array.shape[1:] if len(sample_array.shape) > 1 else ()
-            total_shape = (len(x),) + chunk_shape
-        finally:
-            del sample_array
-            del sample_chunk
-            pool.free_all_blocks()
-            pinned_mempool.free_all_blocks()
-        
-        chunks = np.empty(total_shape, dtype=dtype)
-        
-        try:
-            for i in range(0, len(x), batch_size):
-                try:
-                    end_idx = min(i + batch_size, len(x))
-                    chunk = x[i:end_idx]
-                    chunks[i:end_idx] = chunk.get().astype(dtype=dtype)
-                finally:
-                    del chunk
-                    pool.free_all_blocks()
-                    pinned_mempool.free_all_blocks()
-                    cp.cuda.runtime.deviceSynchronize()
-                
-                loading_bar.update(1)
-        finally:
-            del x
-            pool.free_all_blocks()
-            pinned_mempool.free_all_blocks()
-            cp.cuda.runtime.deviceSynchronize()
-        
-        return chunks
-        
-    except Exception as e:
-        logging.error(f"Error in transfer_to_cpu: {str(e)}")
-        if 'x' in locals():
-            del x
-        if 'pool' in locals():
-            pool.free_all_blocks()
-        if 'pinned_mempool' in locals():
-            pinned_mempool.free_all_blocks()
-        cp.cuda.runtime.deviceSynchronize()
-        raise
-
-def get_optimal_batch_size_for_gpu(x, data_size_bytes):
-    """
-    The function calculates the optimal batch size for a GPU based on available memory and data size.
-    
-    :param x: A list or array containing the data elements that will be processed on the GPU
-    :param data_size_bytes: The `data_size_bytes` parameter represents the total size of the data in
-    bytes that you want to process on the GPU. This could be the size of a single batch of data or the
-    total size of the dataset, depending on how you are structuring your computations
-    :return: the optimal batch size that can be used for processing the given data on the GPU, based on
-    the available free memory on the GPU and the size of the data elements.
-    """
-    free_memory = cp.get_default_memory_pool().free_bytes()
-    device_memory = cp.cuda.runtime.memGetInfo()[0]
-    safe_memory = min(free_memory, device_memory) * 0.25
-    
-    element_size = data_size_bytes / len(x)
-    return int(safe_memory / (element_size * 2))
-
-
-def transfer_to_gpu(x, dtype=cp.float32):
-    """
-    The `transfer_to_gpu` function in Python converts input data to GPU arrays, optimizing memory usage by
-    batching and handling out-of-memory errors.
-    
-    :param x: The `x` parameter in the `transfer_to_gpu` function is the input data that you want to transfer to the GPU for processing. It can be either a NumPy array or a CuPy array. If it's a NumPy array, the function will convert it to a CuPy array and
-    
-    :param dtype: The `dtype` parameter in the `transfer_to_gpu` function specifies the data type to which the input array `x` should be converted when moving it to the GPU. By default, it is set to `cp.float32`, which is a 32-bit floating-point data type provided by the CuPy
-    
-    :return: The `transfer_to_gpu` function returns the input data `x` converted to a GPU array of type `dtype` (default is `cp.float32`). If the input `x` is already a GPU array with the same dtype, it returns `x` as is. If the data size of `x` exceeds 25% of the free GPU memory, it processes the data in batches to
-    """
-    from .ui import loading_bars, initialize_loading_bar
-    try:
-        if isinstance(x, cp.ndarray):
-            return x.astype(dtype) if x.dtype != dtype else x
-            
-        x = x.astype(dtype=dtype, copy=False)
-        data_size = x.nbytes
-        pinned_mempool = cp.cuda.PinnedMemoryPool()
-        free_gpu_memory = cp.cuda.runtime.memGetInfo()[0]
-        logging.debug(f"Data size: {data_size/1e6:.2f}MB, Free GPU memory: {free_gpu_memory/1e6:.2f}MB")
-
-        if data_size <= free_gpu_memory * 0.25:
-            new_x = cp.array(x, dtype=dtype, copy=False)
-            return new_x
-            
-        batch_size = get_optimal_batch_size_for_gpu(x, data_size)
-        if batch_size == 0: batch_size = 1
-
-        loading_bar = initialize_loading_bar(total=len(x)/batch_size, desc='Transfering to GPU mem', ncols=70, bar_format=loading_bars()[0], leave=False)
-        
-        logging.debug(f"Using batch size: {batch_size}")
-        current_threshold = 0.75
-        total_batches = (len(x) + batch_size - 1) // batch_size
-
-        sample_chunk = x[0:1]
-        sample_array = cp.array(sample_chunk, dtype=dtype)
-        chunk_shape = sample_array.shape[1:] if len(sample_array.shape) > 1 else ()
-        del sample_array
-        del sample_chunk
-        if chunk_shape:
-            total_shape = (len(x),) + chunk_shape
-        else:
-            total_shape = (len(x),)
-        
-        del chunk_shape
-        chunks = cp.empty(total_shape, dtype=dtype)
-        del total_shape
-
-        for i in range(0, len(x), batch_size):
-            try:
-                chunk = x[i:i + batch_size]
-                chunk = cp.array(chunk, dtype=dtype)
-                chunks[i // batch_size] = chunk
-                del chunk
-                pinned_mempool.free_all_blocks()
-
-                if i > 0 and i % (batch_size * 5) == 0:
-                    pool = cp.get_default_memory_pool()
-                    current_threshold = adjust_gpu_memory_threshold(pool, free_gpu_memory, current_threshold)
-                    if pool.used_bytes() > cp.cuda.runtime.memGetInfo()[0] * current_threshold:
-                        pool.free_all_blocks()
-                    
-                    
-                loading_bar.update(1)
-                    
-            except cp.cuda.memory.OutOfMemoryError:
-                logging.error(f"GPU out of memory at batch {i//batch_size + 1}/{total_batches}")
-                cp.get_default_memory_pool().free_all_blocks()
-                batch_size = max(batch_size // 2, 1)
-                continue
-                
-            except Exception as e:
-                logging.error(f"Error processing batch {i//batch_size + 1}/{total_batches}: {str(e)}")
-                raise
-                
-        try:
-            del x
-            cp.get_default_memory_pool().free_all_blocks()
-            pinned_mempool.free_all_blocks()
-            return chunks
-            
-        except Exception as e:
-            logging.error(f"Error concatenating results: {str(e)}")
-            raise
-            
-    except Exception as e:
-        logging.error(f"Error in transfer_to_gpu: {str(e)}")
-        raise
-
-def adjust_gpu_memory_threshold(pool, free_gpu_memory, current_threshold=0.75, min_threshold=0.5, max_threshold=0.9):
-    used_memory = pool.used_bytes()
-    usage_ratio = used_memory / free_gpu_memory
-    
-    if usage_ratio > current_threshold:
-        current_threshold = max(min_threshold, current_threshold - 0.05)
-    elif usage_ratio < current_threshold * 0.8:
-        current_threshold = min(max_threshold, current_threshold + 0.05)
-
-    return current_threshold
-
-
-def optimize_labels(y, one_hot_encoded=True, cuda=False):
-    """
-    The function `optimize_labels` optimizes the data type of labels based on their length and encoding
-    format.
-    
-    :param y: The `optimize_labels` function is designed to optimize the data type of the input labels
-    `y` based on certain conditions. The function checks if the labels are in one-hot encoded format or
-    not, and then based on the length of the labels and the specified data types (`uint8`, `uint
-    :param one_hot_encoded: The `one_hot_encoded` parameter in the `optimize_labels` function indicates
-    whether the labels are in one-hot encoded format or not. If `one_hot_encoded` is set to `True`, it
-    means that the labels are in one-hot encoded format, and the function will check the length of the,
-    defaults to True (optional)
-    :param cuda: The `cuda` parameter in the `optimize_labels` function is a boolean flag that indicates
-    whether to use CUDA for computations. If `cuda` is set to `True`, the function will use the CuPy
-    library for array operations, which can leverage GPU acceleration. If `cuda` is `False, defaults to
-    False (optional)
-    :return: The function `optimize_labels` returns the input array `y` after optimizing its data type
-    based on the specified conditions. If `one_hot_encoded` is True, it checks the length of the
-    elements in `y` and converts the data type to uint8, uint16, or uint32 accordingly. If
-    `one_hot_encoded` is False, it checks the length of `y` itself and
-    """
-
-    if cuda: array_type = cp
-    else: array_type = np
-
-    dtype_uint8 = array_type.uint8
-    dtype_uint16 = array_type.uint16
-    dtype_uint32 = array_type.uint32
-
-    if one_hot_encoded:
-        if len(y[0]) < 256:
-            if y.dtype != dtype_uint8:
-                y = array_type.array(y, copy=False).astype(dtype_uint8, copy=False)
-        elif len(y[0]) <= 32767:
-            if y.dtype != dtype_uint16:
-                y = array_type.array(y, copy=False).astype(dtype_uint16, copy=False)
-        else:
-            if y.dtype != dtype_uint32:
-                y = array_type.array(y, copy=False).astype(dtype_uint32, copy=False)
-
-        return y
-
-    else:
-
-        if len(y) < 256:
-            if y.dtype != dtype_uint8:
-                y = array_type.array(y, copy=False).astype(dtype_uint8, copy=False)
-        elif len(y) <= 32767:
-            if y.dtype != dtype_uint16:
-                y = array_type.array(y, copy=False).astype(dtype_uint16, copy=False)
-        else:
-            if y.dtype != dtype_uint32:
-                y = array_type.array(y, copy=False).astype(dtype_uint32, copy=False)
-
-        return y

pyerualjetwork_afterburner/metrics.py

@@ -1,190 +0,0 @@
-import numpy as np
-
-def metrics(y_ts, test_preds, average='weighted'):
-    """
-    Calculates precision, recall and F1 score for a classification task.
-    
-    Args:
-        y_ts (list or numpy.ndarray): True labels.
-        test_preds (list or numpy.ndarray): Predicted labels.
-        average (str): Type of averaging ('micro', 'macro', 'weighted').
-
-    Returns:
-        tuple: Precision, recall, F1 score.
-    """
-    
-    from .data_operations import decode_one_hot
-    
-    y_test_d = decode_one_hot(y_ts)
-    y_test_d = np.array(y_test_d)
-    y_pred = np.array(test_preds)
-
-    if y_test_d.ndim > 1:
-        y_test_d = y_test_d.reshape(-1)
-    if y_pred.ndim > 1:
-        y_pred = y_pred.reshape(-1)
-
-    tp = {}
-    fp = {}
-    fn = {}
-
-    classes = np.unique(np.concatenate((y_test_d, y_pred)))
-
-    for c in classes:
-        tp[c] = 0
-        fp[c] = 0
-        fn[c] = 0
-
-    for c in classes:
-        for true, pred in zip(y_test_d, y_pred):
-            if true == c and pred == c:
-                tp[c] += 1
-            elif true != c and pred == c:
-                fp[c] += 1
-            elif true == c and pred != c:
-                fn[c] += 1
-
-    precision = {}
-    recall = {}
-    f1 = {}
-
-    for c in classes:
-        precision[c] = tp[c] / (tp[c] + fp[c]) if (tp[c] + fp[c]) > 0 else 0
-        recall[c] = tp[c] / (tp[c] + fn[c]) if (tp[c] + fn[c]) > 0 else 0
-        f1[c] = 2 * (precision[c] * recall[c]) / (precision[c] + recall[c]) if (precision[c] + recall[c]) > 0 else 0
-
-    if average == 'micro':
-        precision_val = np.sum(list(tp.values())) / (np.sum(list(tp.values())) + np.sum(list(fp.values()))) if (np.sum(list(tp.values())) + np.sum(list(fp.values()))) > 0 else 0
-        recall_val = np.sum(list(tp.values())) / (np.sum(list(tp.values())) + np.sum(list(fn.values()))) if (np.sum(list(tp.values())) + np.sum(list(fn.values()))) > 0 else 0
-        f1_val = 2 * (precision_val * recall_val) / (precision_val + recall_val) if (precision_val + recall_val) > 0 else 0
-
-    elif average == 'macro':
-        precision_val = np.mean(list(precision.values()))
-        recall_val = np.mean(list(recall.values()))
-        f1_val = np.mean(list(f1.values()))
-
-    elif average == 'weighted':
-        weights = np.array([np.sum(y_test_d == c) for c in classes])
-        weights = weights / np.sum(weights)
-        precision_val = np.sum([weights[i] * precision[classes[i]] for i in range(len(classes))])
-        recall_val = np.sum([weights[i] * recall[classes[i]] for i in range(len(classes))])
-        f1_val = np.sum([weights[i] * f1[classes[i]] for i in range(len(classes))])
-
-    else:
-        raise ValueError("Invalid value for 'average'. Choose from 'micro', 'macro', 'weighted'.")
-
-    return precision_val, recall_val, f1_val
-
-
-def roc_curve(y_true, y_score):
-    """
-    Compute Receiver Operating Characteristic (ROC) curve.
-
-    Parameters:
-    y_true : array, shape = [n_samples]
-        True binary labels in range {0, 1} or {-1, 1}.
-    y_score : array, shape = [n_samples]
-        Target scores, can either be probability estimates of the positive class,
-        confidence values, or non-thresholded measure of decisions (as returned
-        by decision_function on some classifiers).
-
-    Returns:
-    fpr : array, shape = [n]
-        Increasing false positive rates such that element i is the false positive rate
-        of predictions with score >= thresholds[i].
-    tpr : array, shape = [n]
-        Increasing true positive rates such that element i is the true positive rate
-        of predictions with score >= thresholds[i].
-    thresholds : array, shape = [n]
-        Decreasing thresholds on the decision function used to compute fpr and tpr.
-    """
-    
-    y_true = np.asarray(y_true)
-    y_score = np.asarray(y_score)
-
-    if len(np.unique(y_true)) != 2:
-        raise ValueError("Only binary classification is supported.")
-
-    
-    desc_score_indices = np.argsort(y_score, kind="mergesort")[::-1]
-    y_score = y_score[desc_score_indices]
-    y_true = y_true[desc_score_indices]
-
-
-    fpr = []
-    tpr = []
-    thresholds = []
-    n_pos = np.sum(y_true)
-    n_neg = len(y_true) - n_pos
-
-    tp = 0
-    fp = 0
-    prev_score = None
-
-    
-    for i, score in enumerate(y_score):
-        if score != prev_score:
-            fpr.append(fp / n_neg)
-            tpr.append(tp / n_pos)
-            thresholds.append(score)
-            prev_score = score
-
-        if y_true[i] == 1:
-            tp += 1
-        else:
-            fp += 1
-
-    fpr.append(fp / n_neg)
-    tpr.append(tp / n_pos)
-    thresholds.append(score)
-
-    return np.array(fpr), np.array(tpr), np.array(thresholds)
-
-
-def confusion_matrix(y_true, y_pred, class_count):
-    """
-    Computes confusion matrix.
-
-    Args:
-        y_true (numpy.ndarray): True class labels (1D array).
-        y_pred (numpy.ndarray): Predicted class labels (1D array).
-        num_classes (int): Number of classes.
-
-    Returns:
-        numpy.ndarray: Confusion matrix of shape (num_classes, num_classes).
-    """
-    confusion = np.zeros((class_count, class_count), dtype=int)
-
-    for i in range(len(y_true)):
-        true_label = y_true[i]
-        pred_label = y_pred[i]
-        confusion[true_label, pred_label] += 1
-
-    return confusion
-
-
-def pca(X, n_components):
-    """
-    
-    Parameters:
-    X (numpy array): (n_samples, n_features)
-    n_components (int):
-    
-    Returns:
-    X_reduced (numpy array): (n_samples, n_components)
-    """
-    
-    X_meaned = X - np.mean(X, axis=0)
-    
-    covariance_matrix = np.cov(X_meaned, rowvar=False)
-    
-    eigenvalues, eigenvectors = np.linalg.eigh(covariance_matrix)
-    
-    sorted_index = np.argsort(eigenvalues)[::-1]
-    sorted_eigenvectors = eigenvectors[:, sorted_index]
-    
-    eigenvectors_subset = sorted_eigenvectors[:, :n_components]
-    
-    X_reduced = np.dot(X_meaned, eigenvectors_subset)
-    
-    return X_reduced

pyerualjetwork_afterburner/metrics_cuda.py

@@ -1,163 +0,0 @@
-import cupy as cp
-
-def metrics(y_ts, test_preds, average='weighted'):
-    from .data_operations import decode_one_hot
-    y_test_d = cp.array(decode_one_hot(y_ts))
-    y_pred = cp.array(test_preds)
-
-    if y_test_d.ndim > 1:
-        y_test_d = y_test_d.ravel()
-    if y_pred.ndim > 1:
-        y_pred = y_pred.ravel()
-
-    classes = cp.unique(cp.concatenate((y_test_d, y_pred)))
-    tp = cp.zeros(len(classes), dtype=cp.int32)
-    fp = cp.zeros(len(classes), dtype=cp.int32)
-    fn = cp.zeros(len(classes), dtype=cp.int32)
-
-    for i, c in enumerate(classes):
-        tp[i] = cp.sum((y_test_d == c) & (y_pred == c))
-        fp[i] = cp.sum((y_test_d != c) & (y_pred == c))
-        fn[i] = cp.sum((y_test_d == c) & (y_pred != c))
-
-    precision = tp / (tp + fp + 1e-10)
-    recall = tp / (tp + fn + 1e-10)
-    f1 = 2 * (precision * recall) / (precision + recall + 1e-10)
-
-    if average == 'micro':
-        tp_sum = cp.sum(tp)
-        fp_sum = cp.sum(fp)
-        fn_sum = cp.sum(fn)
-        precision_val = tp_sum / (tp_sum + fp_sum + 1e-10)
-        recall_val = tp_sum / (tp_sum + fn_sum + 1e-10)
-        f1_val = 2 * (precision_val * recall_val) / (precision_val + recall_val + 1e-10)
-
-    elif average == 'macro':
-        precision_val = cp.mean(precision)
-        recall_val = cp.mean(recall)
-        f1_val = cp.mean(f1)
-
-    elif average == 'weighted':
-        weights = cp.array([cp.sum(y_test_d == c) for c in classes])
-        weights = weights / cp.sum(weights)
-        precision_val = cp.sum(weights * precision)
-        recall_val = cp.sum(weights * recall)
-        f1_val = cp.sum(weights * f1)
-
-    else:
-        raise ValueError("Invalid value for 'average'. Choose from 'micro', 'macro', 'weighted'.")
-
-    return precision_val.item(), recall_val.item(), f1_val.item()
-
-
-def roc_curve(y_true, y_score):
-    """
-    Compute Receiver Operating Characteristic (ROC) curve.
-
-    Parameters:
-    y_true : array, shape = [n_samples]
-        True binary labels in range {0, 1} or {-1, 1}.
-    y_score : array, shape = [n_samples]
-        Target scores, can either be probability estimates of the positive class,
-        confidence values, or non-thresholded measure of decisions (as returned
-        by decision_function on some classifiers).
-
-    Returns:
-    fpr : array, shape = [n]
-        Increasing false positive rates such that element i is the false positive rate
-        of predictions with score >= thresholds[i].
-    tpr : array, shape = [n]
-        Increasing true positive rates such that element i is the true positive rate
-        of predictions with score >= thresholds[i].
-    thresholds : array, shape = [n]
-        Decreasing thresholds on the decision function used to compute fpr and tpr.
-    """
-    
-    y_true = cp.asarray(y_true)
-    y_score = cp.asarray(y_score)
-
-    if len(cp.unique(y_true)) != 2:
-        raise ValueError("Only binary classification is supported.")
-
-    
-    desc_score_indices = cp.argsort(y_score, kind="stable")[::-1]
-    y_score = y_score[desc_score_indices]
-    y_true = y_true[desc_score_indices]
-
-
-    fpr = []
-    tpr = []
-    thresholds = []
-    n_pos = cp.sum(y_true)
-    n_neg = len(y_true) - n_pos
-
-    tp = 0
-    fp = 0
-    prev_score = 0
-
-    for i, score in enumerate(y_score):
-        if score is not prev_score:
-            fpr.append(fp / n_neg)
-            tpr.append(tp / n_pos)
-            thresholds.append(score)
-            prev_score = score
-
-        if y_true[i] == 1:
-            tp += 1
-        else:
-            fp += 1
-
-    fpr.append(fp / n_neg)
-    tpr.append(tp / n_pos)
-    thresholds.append(score)
-
-    return cp.array(fpr), cp.array(tpr), cp.array(thresholds)
-
-
-def confusion_matrix(y_true, y_pred, class_count):
-    """
-    Computes confusion matrix.
-
-    Args:
-        y_true (numpy.ndarray): True class labels (1D array).
-        y_pred (numpy.ndarray): Predicted class labels (1D array).
-        num_classes (int): Number of classes.
-
-    Returns:
-        numpy.ndarray: Confusion matrix of shape (num_classes, num_classes).
-    """
-    confusion = cp.zeros((class_count, class_count), dtype=int)
-
-    for i in range(len(y_true)):
-        true_label = y_true[i]
-        pred_label = y_pred[i]
-        confusion[true_label, pred_label] += 1
-
-    return confusion
-
-
-def pca(X, n_components):
-    """
-    
-    Parameters:
-    X (numpy array): (n_samples, n_features)
-    n_components (int):
-    
-    Returns:
-    X_reduced (numpy array): (n_samples, n_components)
-    """
-    
-    X_meaned = X - cp.mean(X, axis=0)
-    
-    covariance_matrix = cp.cov(X_meaned, rowvar=False)
-    
-    eigenvalues, eigenvectors = cp.linalg.eigh(covariance_matrix)
-    
-    sorted_index = cp.argsort(eigenvalues)[::-1]
-    sorted_eigenvectors = eigenvectors[:, sorted_index]
-    
-    eigenvectors_subset = sorted_eigenvectors[:, :n_components]
-    
-    X_reduced = cp.dot(X_meaned, eigenvectors_subset)
-    
-    return X_reduced