Alpha

evalica.alpha(data, distance='nominal', solver='pyo3')

Compute Krippendorff's alpha.

Parameters:

Name	Type	Description	Default
data	DataFrame	Ratings by observer (rows) and unit (columns).	required
distance	DistanceFunc[T_distance_contra] | DistanceName	Distance metric (nominal, ordinal, interval, ratio) or a custom function.	'nominal'
solver	Literal['naive', 'pyo3']	The solver to use (naive or pyo3).	'pyo3'

Returns:

Type	Description
AlphaResult	The alpha result.

Source code in evalica/__init__.py

def alpha(
    data: pd.DataFrame,
    distance: DistanceFunc[T_distance_contra] | DistanceName = "nominal",
    solver: Literal["naive", "pyo3"] = "pyo3",
) -> AlphaResult:
    """
    Compute Krippendorff's alpha.

    Args:
        data: Ratings by observer (rows) and unit (columns).
        distance: Distance metric (nominal, ordinal, interval, ratio) or a custom function.
        solver: The solver to use (naive or pyo3).

    Returns:
        The alpha result.

    """
    matrix = _as_unit_matrix(data)
    codes, unique_values = _factorize_values(matrix)

    if solver == "pyo3":
        if not PYO3_AVAILABLE:
            raise SolverError(solver)

        numeric_values = np.asarray(unique_values, dtype=np.float64)

        if callable(distance):
            distance_matrix = _custom_distance(distance, unique_values)
            _alpha, observed, expected = _brzo.alpha(codes, numeric_values, distance_matrix)
        else:
            _alpha, observed, expected = _brzo.alpha(codes, numeric_values, distance)

        if expected == 0.0:
            _alpha = 1.0 if observed == 0.0 else 0.0
    else:
        _alpha, observed, expected = _alpha_naive(codes, unique_values, distance)

    return AlphaResult(
        alpha=_alpha,
        observed=observed,
        expected=expected,
        solver=solver,
    )

evalica.AlphaResult dataclass

The result of Krippendorff's alpha.

Attributes:

Name	Type	Description
alpha	float	The alpha value.
observed	float	The observed disagreement.
expected	float	The expected disagreement.
solver	str	The solver used.

Source code in evalica/__init__.py

@dataclass(frozen=True)
class AlphaResult:
    """
    The result of Krippendorff's alpha.

    Attributes:
        alpha: The alpha value.
        observed: The observed disagreement.
        expected: The expected disagreement.
        solver: The solver used.

    """

    alpha: float
    observed: float
    expected: float
    solver: str

evalica.DistanceFunc

Bases: Protocol[T_distance_contra]

The distance function protocol.

Source code in evalica/__init__.py

class DistanceFunc(Protocol[T_distance_contra]):
    """The distance function protocol."""

    def __call__(self, left: T_distance_contra, right: T_distance_contra, /) -> float:
        """
        Compute the distance between the values.

        Args:
            left: The left-hand side value.
            right: The right-hand side value.

        Returns:
            The non-negative distance between the values.

        """
        ...

__call__(left, right)

Compute the distance between the values.

Parameters:

Name	Type	Description	Default
left	T_distance_contra	The left-hand side value.	required
right	T_distance_contra	The right-hand side value.	required

Returns:

Type	Description
float	The non-negative distance between the values.

Source code in evalica/__init__.py

def __call__(self, left: T_distance_contra, right: T_distance_contra, /) -> float:
    """
    Compute the distance between the values.

    Args:
        left: The left-hand side value.
        right: The right-hand side value.

    Returns:
        The non-negative distance between the values.

    """
    ...