tessl/pypi-cupy

NumPy & SciPy-compatible array library for GPU-accelerated computing with Python

—

Pending

Overview

Eval results

Files

Statistics and Data Analysis

Name: tessl/pypi-cupy
Author: tessl

Statistical functions for data analysis including descriptive statistics, correlations, and histograms. All functions operate on GPU arrays and support axis-wise operations with the same interface as NumPy.

Capabilities

Descriptive Statistics

Basic statistical measures for data analysis.

def mean(a, axis=None, dtype=None, out=None, keepdims=False):
    """
    Compute arithmetic mean along specified axes.
    
    Parameters:
    - a: array-like, input data
    - axis: None or int or tuple of ints, axes to compute mean over
    - dtype: data type, type of output
    - out: cupy.ndarray, output array
    - keepdims: bool, keep reduced dimensions as size 1
    
    Returns:
    cupy.ndarray: Mean values
    """

def std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False):
    """Compute standard deviation along specified axes."""

def var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False):
    """Compute variance along specified axes."""

def median(a, axis=None, out=None, overwrite_input=False, keepdims=False):
    """Compute median along specified axes."""

def average(a, axis=None, weights=None, returned=False):
    """
    Compute weighted average along specified axis.
    
    Parameters:
    - a: array-like, input data
    - axis: None or int, axis to average over
    - weights: array-like, weights for averaging
    - returned: bool, return weights sum if True
    
    Returns:
    cupy.ndarray: Weighted average
    tuple: (average, sum_of_weights) if returned=True
    """

Order Statistics

Statistical measures based on data ordering.

def amax(a, axis=None, out=None, keepdims=False, initial=None, where=None):
    """Return maximum along axes."""

def amin(a, axis=None, out=None, keepdims=False, initial=None, where=None):
    """Return minimum along axes."""

def max(a, axis=None, out=None, keepdims=False, initial=None, where=None):
    """Return maximum along axes (alias for amax)."""

def min(a, axis=None, out=None, keepdims=False, initial=None, where=None):
    """Return minimum along axes (alias for amin)."""

def percentile(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=False):
    """
    Compute percentiles along specified axes.
    
    Parameters:
    - a: array-like, input data
    - q: float or array-like, percentile(s) to compute (0-100)
    - axis: None or int or tuple of ints, axes to compute over
    - out: cupy.ndarray, output array
    - overwrite_input: bool, allow input modification
    - method: str, interpolation method
    - keepdims: bool, keep reduced dimensions
    
    Returns:
    cupy.ndarray: Percentile values
    """

def quantile(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=False):
    """Compute quantiles along specified axes (0-1 scale)."""

def ptp(a, axis=None, out=None, keepdims=False):
    """Return range (peak-to-peak) along axes."""

Correlation and Covariance

Statistical relationships between variables.

def corrcoef(x, y=None, rowvar=True, bias=None, ddof=None):
    """
    Return Pearson correlation coefficients.
    
    Parameters:
    - x: array-like, input data
    - y: array-like, additional data
    - rowvar: bool, rows represent variables if True
    - bias: deprecated parameter
    - ddof: deprecated parameter
    
    Returns:
    cupy.ndarray: Correlation coefficient matrix
    """

def cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=None):
    """
    Estimate covariance matrix.
    
    Parameters:
    - m: array-like, input data
    - y: array-like, additional data
    - rowvar: bool, rows represent variables if True
    - bias: bool, normalization by N if True, N-1 if False
    - ddof: int, delta degrees of freedom
    - fweights: array-like, frequency weights
    - aweights: array-like, observation weights
    
    Returns:
    cupy.ndarray: Covariance matrix
    """

def correlate(a, v, mode='valid'):
    """
    Cross-correlation of two 1-D sequences.
    
    Parameters:
    - a, v: array-like, input sequences
    - mode: {'valid', 'same', 'full'}, output size
    
    Returns:
    cupy.ndarray: Cross-correlation
    """

Histograms

Data distribution analysis and binning.

def histogram(a, bins=10, range=None, normed=None, weights=None, density=None):
    """
    Compute histogram of dataset.
    
    Parameters:
    - a: array-like, input data
    - bins: int or array-like, number of bins or bin edges
    - range: tuple, lower and upper range of bins
    - normed: deprecated, use density instead
    - weights: array-like, weights for each value
    - density: bool, normalize to probability density
    
    Returns:
    tuple: (hist, bin_edges)
    """

def histogram2d(x, y, bins=10, range=None, normed=None, weights=None, density=None):
    """
    Compute 2D histogram.
    
    Parameters:
    - x, y: array-like, input data
    - bins: int or [int, int] or array-like, bin specification
    - range: array-like, bin ranges [[xmin, xmax], [ymin, ymax]]
    - normed: deprecated, use density instead
    - weights: array-like, weights for each sample
    - density: bool, normalize to probability density
    
    Returns:
    tuple: (H, xedges, yedges)
    """

def histogramdd(sample, bins=10, range=None, normed=None, weights=None, density=None):
    """Compute multidimensional histogram."""

def bincount(x, weights=None, minlength=0):
    """
    Count occurrences of each value in array.
    
    Parameters:
    - x: array-like, non-negative integer array
    - weights: array-like, weights for each value
    - minlength: int, minimum number of bins
    
    Returns:
    cupy.ndarray: Counts for each value
    """

def digitize(x, bins, right=False):
    """
    Return indices of bins to which each value belongs.
    
    Parameters:
    - x: array-like, input array
    - bins: array-like, bin edges
    - right: bool, left or right interval boundaries
    
    Returns:
    cupy.ndarray: Bin indices
    """

NaN-aware Statistics

Statistical functions that handle NaN values appropriately.

def nanmean(a, axis=None, dtype=None, out=None, keepdims=False):
    """Compute mean ignoring NaNs."""

def nanstd(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False):
    """Compute standard deviation ignoring NaNs."""

def nanvar(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False):
    """Compute variance ignoring NaNs."""

def nanmedian(a, axis=None, out=None, overwrite_input=False, keepdims=False):
    """Compute median ignoring NaNs."""

def nanmax(a, axis=None, out=None, keepdims=False):
    """Return maximum ignoring NaNs."""

def nanmin(a, axis=None, out=None, keepdims=False):
    """Return minimum ignoring NaNs."""

Usage Examples

Basic Statistical Analysis

import cupy as cp

# Sample data
data = cp.random.normal(100, 15, size=(10000,))

# Basic statistics
mean_val = cp.mean(data)
std_val = cp.std(data)
var_val = cp.var(data)
median_val = cp.median(data)

print(f"Mean: {mean_val:.2f}, Std: {std_val:.2f}")
print(f"Median: {median_val:.2f}, Range: {cp.ptp(data):.2f}")

# Percentiles
percentiles = cp.percentile(data, [25, 50, 75, 90, 95])

Multi-dimensional Statistics

# Multi-dimensional data analysis
matrix_data = cp.random.normal(0, 1, size=(1000, 50))

# Statistics along different axes
col_means = cp.mean(matrix_data, axis=0)  # Mean of each column
row_means = cp.mean(matrix_data, axis=1)  # Mean of each row
overall_mean = cp.mean(matrix_data)       # Overall mean

# Correlation analysis
correlation_matrix = cp.corrcoef(matrix_data.T)  # 50x50 correlation matrix
covariance_matrix = cp.cov(matrix_data.T)       # 50x50 covariance matrix

Histogram Analysis

# Distribution analysis
data = cp.random.exponential(2.0, size=100000)

# Basic histogram
counts, bin_edges = cp.histogram(data, bins=50, range=(0, 20))

# Probability density
density_counts, _ = cp.histogram(data, bins=50, range=(0, 20), density=True)

# 2D histogram for joint distributions
x = cp.random.normal(0, 1, 10000)
y = 2*x + cp.random.normal(0, 0.5, 10000)
H, xedges, yedges = cp.histogram2d(x, y, bins=50)

Install with Tessl CLI