edgepython 0.2.0__py3-none-any.whl

edgepython/compressed_matrix.py

@@ -0,0 +1,388 @@
+# This code was written by Claude (Anthropic). The project was directed by Lior Pachter.
+"""
+CompressedMatrix class for memory-efficient matrix storage.
+
+Port of edgeR's CompressedMatrix (makeCompressedMatrix.R).
+Stores scalars, row vectors, or column vectors with flags indicating
+which dimensions should be repeated when expanding to a full matrix.
+"""
+
+import numpy as np
+
+
+class CompressedMatrix:
+    """Memory-efficient matrix that stores repeated rows/columns compactly.
+
+    A CompressedMatrix stores a scalar, row vector, column vector, or full
+    matrix along with flags indicating which dimensions are repeated.
+    This avoids materializing large matrices when the same values are
+    repeated across rows or columns.
+
+    Parameters
+    ----------
+    x : scalar, 1-D array, or 2-D array
+        The data to store.
+    dims : tuple of (int, int), optional
+        The logical dimensions (nrow, ncol) of the full matrix.
+    byrow : bool
+        If True (default), a 1-D vector is treated as a row to be repeated
+        down rows. If False, treated as a column to be repeated across columns.
+    """
+
+    def __init__(self, x, dims=None, byrow=True):
+        x = np.asarray(x, dtype=np.float64)
+        self.repeat_row = False
+        self.repeat_col = False
+
+        if x.ndim == 2:
+            if dims is not None:
+                xr, xc = x.shape
+                if xr == 1 and xc == 1:
+                    self.repeat_row = True
+                    self.repeat_col = True
+                    self._data = x.reshape(1, 1)
+                elif xr == 1 and xc >= 2:
+                    if xc != dims[1]:
+                        raise ValueError("dims[1] should equal length of row vector x")
+                    if byrow:
+                        self.repeat_row = True
+                        self._data = x.reshape(1, xc)
+                    else:
+                        self._data = x.reshape(1, xc)
+                        dims = (xr, xc)
+                elif xr >= 2 and xc == 1:
+                    if xr != dims[0]:
+                        raise ValueError("dims[0] should equal length of column vector x")
+                    if not byrow:
+                        self.repeat_col = True
+                        self._data = x.reshape(xr, 1)
+                    else:
+                        self._data = x.reshape(xr, 1)
+                        dims = (xr, xc)
+                else:
+                    self._data = x
+                    dims = x.shape
+            else:
+                self._data = x
+                dims = x.shape
+        elif x.ndim <= 1:
+            x = x.ravel()
+            if x.size == 1:
+                self.repeat_row = True
+                self.repeat_col = True
+                self._data = x.reshape(1, 1)
+                if dims is None:
+                    dims = (1, 1)
+            else:
+                if dims is None:
+                    raise ValueError("dims must be provided for vector input")
+                if not byrow:
+                    if dims[0] != x.size:
+                        raise ValueError("dims[0] should equal length of x")
+                    self._data = x.reshape(-1, 1)
+                    self.repeat_col = True
+                else:
+                    if dims[1] != x.size:
+                        raise ValueError("dims[1] should equal length of x")
+                    self._data = x.reshape(1, -1)
+                    self.repeat_row = True
+        else:
+            raise ValueError("x must be scalar, 1-D, or 2-D")
+
+        self._dims = (int(dims[0]), int(dims[1]))
+
+    @property
+    def shape(self):
+        """Logical dimensions of the full matrix."""
+        return self._dims
+
+    @property
+    def nrow(self):
+        return self._dims[0]
+
+    @property
+    def ncol(self):
+        return self._dims[1]
+
+    def __len__(self):
+        return self._dims[0] * self._dims[1]
+
+    def as_matrix(self):
+        """Expand to a full numpy matrix."""
+        nr, nc = self._dims
+        if self.repeat_row and self.repeat_col:
+            return np.tile(self._data, (nr, nc))[:nr, :nc]
+        elif self.repeat_row:
+            return np.tile(self._data, (nr, 1))[:nr, :nc]
+        elif self.repeat_col:
+            return np.tile(self._data, (1, nc))[:nr, :nc]
+        else:
+            return self._data.copy()
+
+    def __array__(self, dtype=None):
+        result = self.as_matrix()
+        if dtype is not None:
+            result = result.astype(dtype)
+        return result
+
+    def __getitem__(self, key):
+        if isinstance(key, tuple):
+            if len(key) == 2:
+                i, j = key
+                raw = self._data.copy()
+
+                if not self.repeat_row and i is not None:
+                    if isinstance(i, slice):
+                        raw = raw[i, :]
+                    else:
+                        i_idx = np.arange(self._dims[0])[i]
+                        i_idx = np.atleast_1d(i_idx)
+                        raw = raw[i_idx, :]
+                if not self.repeat_col and j is not None:
+                    if isinstance(j, slice):
+                        raw = raw[:, j]
+                    else:
+                        j_idx = np.arange(self._dims[1])[j]
+                        j_idx = np.atleast_1d(j_idx)
+                        raw = raw[:, j_idx]
+
+                # Compute new dims
+                nr = self._dims[0]
+                if i is not None:
+                    ref = np.arange(nr)
+                    nr = len(ref[i]) if not np.isscalar(ref[i]) else 1
+                nc = self._dims[1]
+                if j is not None:
+                    ref = np.arange(nc)
+                    nc = len(ref[j]) if not np.isscalar(ref[j]) else 1
+
+                result = CompressedMatrix.__new__(CompressedMatrix)
+                result._data = raw
+                result._dims = (nr, nc)
+                result.repeat_row = self.repeat_row
+                result.repeat_col = self.repeat_col
+
+                # Drop to vector if single row or column
+                i_scalar = (isinstance(i, (int, np.integer)) or
+                            (hasattr(i, '__len__') and len(i) == 1))
+                j_scalar = (isinstance(j, (int, np.integer)) or
+                            (hasattr(j, '__len__') and len(j) == 1))
+                if i_scalar or j_scalar:
+                    return result.as_matrix().ravel()
+                return result
+            else:
+                return self.as_matrix()[key]
+        else:
+            return self.as_matrix().ravel()[key]
+
+    def __setitem__(self, key, value):
+        full = self.as_matrix()
+        if isinstance(value, CompressedMatrix):
+            value = value.as_matrix()
+        if isinstance(key, tuple):
+            full[key] = value
+        else:
+            full.ravel()[key] = value
+        new = CompressedMatrix(full)
+        self._data = new._data
+        self._dims = new._dims
+        self.repeat_row = new.repeat_row
+        self.repeat_col = new.repeat_col
+
+    def _binary_op(self, other, op):
+        if isinstance(other, CompressedMatrix):
+            if self._dims != other._dims:
+                raise ValueError("CompressedMatrix dimensions should be equal for binary operations")
+            row_rep = self.repeat_row and other.repeat_row
+            col_rep = self.repeat_col and other.repeat_col
+            if row_rep or col_rep:
+                e1 = self._data.ravel()
+                e2 = other._data.ravel()
+                outcome = op(e1, e2)
+                return CompressedMatrix(outcome, self._dims, byrow=row_rep)
+            else:
+                return CompressedMatrix(op(self.as_matrix(), other.as_matrix()))
+        else:
+            other_arr = np.asarray(other, dtype=np.float64)
+            if other_arr.ndim <= 1 and other_arr.size == 1:
+                other_cm = CompressedMatrix(other_arr, self._dims, byrow=False)
+            elif other_arr.ndim == 1:
+                other_cm = CompressedMatrix(other_arr, self._dims, byrow=False)
+            else:
+                other_cm = CompressedMatrix(other_arr, self._dims, byrow=False)
+            return self._binary_op(other_cm, op)
+
+    def __add__(self, other):
+        return self._binary_op(other, np.add)
+
+    def __radd__(self, other):
+        return self._binary_op(other, lambda a, b: np.add(b, a))
+
+    def __sub__(self, other):
+        return self._binary_op(other, np.subtract)
+
+    def __rsub__(self, other):
+        return self._binary_op(other, lambda a, b: np.subtract(b, a))
+
+    def __mul__(self, other):
+        return self._binary_op(other, np.multiply)
+
+    def __rmul__(self, other):
+        return self._binary_op(other, lambda a, b: np.multiply(b, a))
+
+    def __truediv__(self, other):
+        return self._binary_op(other, np.true_divide)
+
+    def __rtruediv__(self, other):
+        return self._binary_op(other, lambda a, b: np.true_divide(b, a))
+
+    def __pow__(self, other):
+        return self._binary_op(other, np.power)
+
+    def __neg__(self):
+        result = CompressedMatrix.__new__(CompressedMatrix)
+        result._data = -self._data
+        result._dims = self._dims
+        result.repeat_row = self.repeat_row
+        result.repeat_col = self.repeat_col
+        return result
+
+    def __repr__(self):
+        return (f"CompressedMatrix(shape={self._dims}, "
+                f"repeat_row={self.repeat_row}, repeat_col={self.repeat_col}, "
+                f"stored_shape={self._data.shape})")
+
+    @staticmethod
+    def rbind(*matrices):
+        """Row-bind CompressedMatrix objects."""
+        if len(matrices) == 1:
+            return matrices[0]
+        all_nr = sum(m.nrow for m in matrices)
+        col_rep = [m.repeat_col for m in matrices]
+        row_rep = [m.repeat_row for m in matrices]
+
+        if all(col_rep):
+            all_nc = matrices[0].ncol
+            collected = []
+            for m in matrices:
+                if m.ncol != all_nc:
+                    raise ValueError("cannot combine CompressedMatrix objects with different number of columns")
+                collected.append(np.tile(m._data.ravel(), max(1, m.nrow // max(1, m._data.shape[0])))[:m.nrow])
+            return CompressedMatrix(np.concatenate(collected), dims=(all_nr, all_nc), byrow=False)
+
+        if all(row_rep):
+            ref = matrices[0]._data
+            ok = all(np.allclose(m._data, ref) for m in matrices[1:])
+            if ok:
+                result = CompressedMatrix.__new__(CompressedMatrix)
+                result._data = matrices[0]._data.copy()
+                result._dims = (all_nr, matrices[0].ncol)
+                result.repeat_row = True
+                result.repeat_col = matrices[0].repeat_col
+                return result
+
+        expanded = [m.as_matrix() for m in matrices]
+        return CompressedMatrix(np.vstack(expanded))
+
+    @staticmethod
+    def cbind(*matrices):
+        """Column-bind CompressedMatrix objects."""
+        if len(matrices) == 1:
+            return matrices[0]
+        all_nc = sum(m.ncol for m in matrices)
+        col_rep = [m.repeat_col for m in matrices]
+        row_rep = [m.repeat_row for m in matrices]
+
+        if all(row_rep):
+            all_nr = matrices[0].nrow
+            collected = []
+            for m in matrices:
+                if m.nrow != all_nr:
+                    raise ValueError("cannot combine CompressedMatrix objects with different number of rows")
+                collected.append(np.tile(m._data.ravel(), max(1, m.ncol // max(1, m._data.shape[1])))[:m.ncol])
+            return CompressedMatrix(np.concatenate(collected), dims=(all_nr, all_nc), byrow=True)
+
+        if all(col_rep):
+            ref = matrices[0]._data
+            ok = all(np.allclose(m._data, ref) for m in matrices[1:])
+            if ok:
+                result = CompressedMatrix.__new__(CompressedMatrix)
+                result._data = matrices[0]._data.copy()
+                result._dims = (matrices[0].nrow, all_nc)
+                result.repeat_row = matrices[0].repeat_row
+                result.repeat_col = True
+                return result
+
+        expanded = [m.as_matrix() for m in matrices]
+        return CompressedMatrix(np.hstack(expanded))
+
+
+def compress_offsets(y, offset=None, lib_size=None):
+    """Compress offsets into a CompressedMatrix.
+
+    Port of edgeR's .compressOffsets.
+    """
+    if isinstance(offset, CompressedMatrix):
+        return offset
+    dims = y.shape if hasattr(y, 'shape') else (y._dims if isinstance(y, CompressedMatrix) else None)
+    if offset is None:
+        if lib_size is None:
+            if isinstance(y, np.ndarray):
+                lib_size = y.sum(axis=0)
+            else:
+                lib_size = np.asarray(y).sum(axis=0)
+        offset = np.log(lib_size)
+    offset = np.asarray(offset, dtype=np.float64)
+    if not np.all(np.isfinite(offset)):
+        raise ValueError("offsets must be finite values")
+    return CompressedMatrix(offset, dims, byrow=True)
+
+
+def compress_weights(y, weights=None):
+    """Compress weights into a CompressedMatrix.
+
+    Port of edgeR's .compressWeights.
+    """
+    if isinstance(weights, CompressedMatrix):
+        return weights
+    dims = y.shape if hasattr(y, 'shape') else (y._dims if isinstance(y, CompressedMatrix) else None)
+    if weights is None:
+        weights = 1.0
+    weights = np.asarray(weights, dtype=np.float64)
+    if np.any(np.isnan(weights)):
+        raise ValueError("NA weights not allowed")
+    if np.any(weights <= 0):
+        raise ValueError("Weights must be positive")
+    return CompressedMatrix(weights, dims, byrow=True)
+
+
+def compress_prior(y, prior_count):
+    """Compress prior counts into a CompressedMatrix.
+
+    Port of edgeR's .compressPrior.
+    """
+    if isinstance(prior_count, CompressedMatrix):
+        return prior_count
+    dims = y.shape if hasattr(y, 'shape') else (y._dims if isinstance(y, CompressedMatrix) else None)
+    prior_count = np.asarray(prior_count, dtype=np.float64)
+    if np.any(np.isnan(prior_count)):
+        raise ValueError("NA prior counts not allowed")
+    if np.any(prior_count < 0):
+        raise ValueError("Negative prior counts not allowed")
+    return CompressedMatrix(prior_count, dims, byrow=False)
+
+
+def compress_dispersions(y, dispersion):
+    """Compress dispersions into a CompressedMatrix.
+
+    Port of edgeR's .compressDispersions.
+    """
+    if isinstance(dispersion, CompressedMatrix):
+        return dispersion
+    dims = y.shape if hasattr(y, 'shape') else (y._dims if isinstance(y, CompressedMatrix) else None)
+    dispersion = np.asarray(dispersion, dtype=np.float64)
+    if np.any(np.isnan(dispersion)):
+        raise ValueError("NA dispersions not allowed")
+    if np.any(dispersion < 0):
+        raise ValueError("Negative dispersions not allowed")
+    return CompressedMatrix(dispersion, dims, byrow=False)

edgepython/dgelist.py

@@ -0,0 +1,314 @@
+# This code was written by Claude (Anthropic). The project was directed by Lior Pachter.
+"""
+DGEList construction, validation, and accessors.
+
+Port of edgeR's DGEList.R, validDGEList.R, getCounts.R, getDispersion.R,
+getOffset.R, effectiveLibSizes.R.
+"""
+
+import numpy as np
+import pandas as pd
+import warnings
+from .classes import DGEList
+
+
+def _drop_empty_levels(x):
+    """Drop unused levels from a categorical/factor variable."""
+    if hasattr(x, 'cat'):
+        return x.cat.remove_unused_categories()
+    return pd.Categorical(x)
+
+
+def make_dgelist(counts, lib_size=None, norm_factors=None, samples=None,
+                 group=None, genes=None, remove_zeros=False,
+                 annotation_columns=None):
+    """Construct a DGEList object from components.
+
+    Port of edgeR's DGEList().
+
+    Parameters
+    ----------
+    counts : array-like or DataFrame
+        Matrix of counts (genes x samples).
+    lib_size : array-like, optional
+        Library sizes. Defaults to column sums.
+    norm_factors : array-like, optional
+        Normalization factors. Defaults to all ones.
+    samples : DataFrame, optional
+        Sample-level information.
+    group : array-like, optional
+        Group memberships.
+    genes : DataFrame, optional
+        Gene-level annotation.
+    remove_zeros : bool
+        Whether to remove rows with all zero counts.
+    annotation_columns : list, optional
+        For DataFrame counts, which columns are annotation (not counts).
+
+    Returns
+    -------
+    DGEList
+    """
+    # Handle DataFrame input
+    if isinstance(counts, pd.DataFrame):
+        if annotation_columns is not None:
+            if isinstance(annotation_columns, (list, np.ndarray)):
+                ann_cols = annotation_columns
+            elif isinstance(annotation_columns, str):
+                ann_cols = [annotation_columns]
+            else:
+                ann_cols = list(annotation_columns)
+
+            if genes is None:
+                genes = counts[ann_cols].copy()
+            else:
+                genes = pd.concat([counts[ann_cols], genes], axis=1)
+            counts = counts.drop(columns=ann_cols)
+        else:
+            # Auto-detect non-numeric columns
+            numeric_mask = counts.dtypes.apply(lambda dt: np.issubdtype(dt, np.number))
+            if not numeric_mask.all():
+                non_numeric = counts.columns[~numeric_mask]
+                last_non_numeric = non_numeric[-1]
+                last_idx = counts.columns.get_loc(last_non_numeric)
+                ann_cols = counts.columns[:last_idx + 1].tolist()
+                if genes is None:
+                    genes = counts[ann_cols].copy()
+                else:
+                    genes = pd.concat([counts[ann_cols], genes], axis=1)
+                counts = counts.iloc[:, last_idx + 1:]
+
+    # Handle scipy sparse matrices
+    if hasattr(counts, 'toarray') and hasattr(counts, 'nnz'):
+        shape = counts.shape
+        nnz = counts.nnz
+        density = nnz / (shape[0] * shape[1]) if shape[0] * shape[1] > 0 else 0
+        warnings.warn(
+            f"Densifying sparse matrix ({shape[0]} x {shape[1]}, "
+            f"{100*density:.1f}% non-zero, "
+            f"{shape[0] * shape[1] * 8 / 1e6:.0f} MB dense). "
+            f"edgePython stores counts as dense arrays.",
+            stacklevel=2,
+        )
+        counts = np.asarray(counts.toarray(), dtype=np.float64)
+    else:
+        counts = np.asarray(counts, dtype=np.float64)
+    if counts.ndim == 1:
+        counts = counts.reshape(-1, 1)
+
+    # Validate counts
+    if counts.size == 0:
+        raise ValueError("'counts' must contain at least one value")
+    m = np.nanmin(counts)
+    if np.isnan(m):
+        raise ValueError("NA counts not allowed")
+    if m < 0:
+        raise ValueError("Negative counts not allowed")
+    if not np.isfinite(np.max(counts)):
+        raise ValueError("Infinite counts not allowed")
+
+    nlib = counts.shape[1]
+    ntags = counts.shape[0]
+
+    # Column names
+    col_names = [f"Sample{i+1}" for i in range(nlib)]
+    row_names = [str(i+1) for i in range(ntags)]
+
+    # Library sizes
+    if lib_size is None:
+        lib_size = counts.sum(axis=0)
+        if np.min(lib_size) <= 0:
+            warnings.warn("At least one library size is zero")
+    else:
+        lib_size = np.asarray(lib_size, dtype=np.float64)
+        if not np.issubdtype(lib_size.dtype, np.number):
+            raise ValueError("'lib_size' must be numeric")
+        if len(lib_size) != nlib:
+            raise ValueError("length of 'lib_size' must equal number of samples")
+        if np.any(np.isnan(lib_size)):
+            raise ValueError("NA library sizes not allowed")
+        if np.any(lib_size < 0):
+            raise ValueError("negative library sizes not allowed")
+        if np.any((lib_size == 0) & (counts.sum(axis=0) > 0)):
+            raise ValueError("library size set to zero but counts for that sample are nonzero")
+
+    # Normalization factors
+    if norm_factors is None:
+        norm_factors = np.ones(nlib)
+    else:
+        norm_factors = np.asarray(norm_factors, dtype=np.float64)
+        if len(norm_factors) != nlib:
+            raise ValueError("Length of 'norm_factors' must equal number of columns in 'counts'")
+        if np.any(np.isnan(norm_factors)):
+            raise ValueError("NA norm factors not allowed")
+        if np.any(norm_factors <= 0):
+            raise ValueError("norm factors must be positive")
+        if abs(np.sum(np.log(norm_factors))) > 1e-6:
+            warnings.warn("norm factors don't multiply to 1")
+
+    # Samples DataFrame
+    if samples is not None:
+        samples = pd.DataFrame(samples)
+        if nlib != len(samples):
+            raise ValueError("Number of rows in 'samples' must equal number of columns in 'counts'")
+
+    # Group
+    if group is None and samples is not None and 'group' in samples.columns:
+        group = samples['group'].values
+        samples = samples.drop(columns=['group'])
+
+    if group is None:
+        group = pd.Categorical([1] * nlib)
+    else:
+        if len(group) != nlib:
+            raise ValueError("Length of 'group' must equal number of columns in 'counts'")
+        group = _drop_empty_levels(pd.Categorical(group))
+
+    # Build samples DataFrame
+    sam = pd.DataFrame({
+        'group': group,
+        'lib.size': lib_size,
+        'norm.factors': norm_factors
+    })
+    if samples is not None:
+        for col in samples.columns:
+            sam[col] = samples[col].values
+    sam.index = col_names
+
+    # Build DGEList
+    x = DGEList()
+    x['counts'] = counts
+    x['samples'] = sam
+
+    # Gene annotation
+    if genes is not None:
+        genes = pd.DataFrame(genes)
+        if len(genes) != ntags:
+            raise ValueError("Counts and genes have different numbers of rows")
+        genes.index = row_names
+        x['genes'] = genes
+
+    # Remove all-zero rows
+    if remove_zeros:
+        all_zeros = np.sum(counts > 0, axis=1) == 0
+        if np.any(all_zeros):
+            keep = ~all_zeros
+            x['counts'] = counts[keep]
+            if 'genes' in x and x['genes'] is not None:
+                x['genes'] = x['genes'].iloc[keep]
+            print(f"Removing {np.sum(all_zeros)} rows with all zero counts")
+
+    return x
+
+
+def valid_dgelist(y):
+    """Check and fill standard components of a DGEList.
+
+    Port of edgeR's validDGEList.
+    """
+    if 'counts' not in y or y['counts'] is None:
+        raise ValueError("No count matrix")
+    y['counts'] = np.asarray(y['counts'], dtype=np.float64)
+    nlib = y['counts'].shape[1]
+    if 'samples' not in y:
+        y['samples'] = pd.DataFrame()
+    if 'group' not in y['samples'].columns:
+        y['samples']['group'] = pd.Categorical([1] * nlib)
+    if 'lib.size' not in y['samples'].columns:
+        y['samples']['lib.size'] = y['counts'].sum(axis=0)
+    if 'norm.factors' not in y['samples'].columns:
+        y['samples']['norm.factors'] = np.ones(nlib)
+    return y
+
+
+def get_counts(y):
+    """Extract count matrix from DGEList.
+
+    Port of edgeR's getCounts.
+    """
+    return np.asarray(y['counts'])
+
+
+def get_dispersion(y):
+    """Get the most complex dispersion values from a DGEList.
+
+    Port of edgeR's getDispersion.
+    Returns tagwise > trended > common > None, with a 'type' attribute.
+    """
+    if y.get('tagwise.dispersion') is not None:
+        disp = np.asarray(y['tagwise.dispersion'])
+        disp_type = 'tagwise'
+    elif y.get('trended.dispersion') is not None:
+        disp = np.asarray(y['trended.dispersion'])
+        disp_type = 'trended'
+    elif y.get('common.dispersion') is not None:
+        disp = np.float64(y['common.dispersion'])
+        disp_type = 'common'
+    else:
+        return None
+
+    # Store type as attribute (Python doesn't have R's attr, use a wrapper)
+    result = disp
+    # We'll just return the value; callers can check type if needed
+    return result
+
+
+def get_dispersion_type(y):
+    """Get the type of the most complex dispersion in a DGEList."""
+    if y.get('tagwise.dispersion') is not None:
+        return 'tagwise'
+    elif y.get('trended.dispersion') is not None:
+        return 'trended'
+    elif y.get('common.dispersion') is not None:
+        return 'common'
+    return None
+
+
+def get_offset(y):
+    """Extract offset vector or matrix from a DGEList.
+
+    Port of edgeR's getOffset. Returns log(lib.size * norm.factors) by default.
+    """
+    if y.get('offset') is not None:
+        return y['offset']
+
+    lib_size = y['samples']['lib.size'].values
+    if lib_size is None:
+        raise ValueError("y is not a valid DGEList object")
+
+    norm_factors = y['samples'].get('norm.factors')
+    if norm_factors is not None:
+        lib_size = lib_size * norm_factors.values
+
+    return np.log(lib_size)
+
+
+def get_norm_lib_sizes(y, log=False):
+    """Get effective (normalized) library sizes.
+
+    Port of edgeR's getNormLibSizes / effectiveLibSizes.
+    """
+    if isinstance(y, dict):
+        if y.get('offset') is not None:
+            # For DGEGLM/DGELRT objects, offset is a matrix
+            offset = y['offset']
+            if hasattr(offset, 'as_matrix'):
+                offset = offset.as_matrix()
+            if isinstance(offset, np.ndarray) and offset.ndim == 2:
+                els = offset[0, :]
+            else:
+                els = offset
+            if not log:
+                els = np.exp(els)
+            return els
+        elif 'samples' in y:
+            els = y['samples']['lib.size'].values * y['samples']['norm.factors'].values
+            if log:
+                els = np.log(els)
+            return els
+    # Default for matrices
+    y = np.asarray(y)
+    els = y.sum(axis=0)
+    if log:
+        els = np.log(els)
+    return els