genetic-classifier 3.0.0__py3-none-any.whl

genetic_classifier/__init__.py

@@ -0,0 +1,10 @@
+"""genetic-classifier: linear classifier (binary and ordinal) trained by a genetic algorithm (Prandiano)."""
+
+from .core import predict, train
+from .evaluation import confusion_matrix, evaluate
+from .reading import read_csv, read_excel
+from .split import train_test_split
+
+__all__ = ["train", "predict", "evaluate", "confusion_matrix", "read_excel", "read_csv", "train_test_split"]
+
+__version__ = "3.0.0"

genetic_classifier/core.py

@@ -0,0 +1,339 @@
+"""Main loop of the genetic algorithm: training (train) and prediction (predict)."""
+
+import numpy as np
+
+from .creation import create_chromosomes
+from .crossover import one_point_crossover
+from .fitness import binary_fitness, fitness_proportions, ordinal_fitness
+from .mutation import mutate
+from .selection import select_parents_roulette
+from .update import update_population
+
+
+def _check_features(X: np.ndarray) -> None:
+    """
+    Check that X only holds valid numbers. Without this, an empty cell in the
+    spreadsheet would silently turn into a wrong predicted class.
+
+    Parameters
+    ----------
+    X : np.ndarray
+        Data to check, of any shape.
+
+    Returns
+    -------
+    None
+        Raises TypeError if X has text or another non-numeric value, and
+        ValueError if X has NaN or infinite values.
+    """
+    try:
+        values = X.astype(float)
+    except (TypeError, ValueError):
+        raise TypeError("X must contain only numbers, but found text or another type of value") from None
+
+    if not np.isfinite(values).all():
+        raise ValueError("X has empty cells or invalid values (NaN or infinity), fix the data before continuing")
+
+
+def train(
+    X: np.ndarray,
+    y: np.ndarray,
+    n_chromosomes: int = 30,
+    n_mutated_genes: int = 2,
+    n_offspring: int = 16,
+    n_replacements: int | None = None,
+    n_generations: int = 1000,
+    target_fitness: float = 1.0,
+    thresholds: np.ndarray | None = None,
+    gene_min: float = -1.0,
+    gene_max: float = 1.0,
+    seed: int | None = None,
+    verbose: bool = True,
+) -> dict:
+    """
+    Train a linear classifier with the full genetic algorithm: create the
+    population and repeat fitness -> selection -> crossover -> mutation ->
+    update until reaching target_fitness or running out of generations.
+
+    Parameters
+    ----------
+    X : np.ndarray of shape (n_samples, n_features)
+        Training data, numbers only (no empty cells).
+    y : np.ndarray of shape (n_samples,)
+        True class of each sample: 0 or 1 for binary, integers from 0 to K-1
+        for ordinal.
+    n_chromosomes : int, default=30
+        Population size.
+    n_mutated_genes : int, default=2
+        How many genes change in each child during mutation, from 0 to n_features + 1.
+    n_offspring : int, default=16
+        How many children are created per generation.
+    n_replacements : int or None, default=None
+        How many of the worst chromosomes are swapped for the best children, at
+        most min(n_chromosomes, n_offspring). None = half of n_offspring.
+    n_generations : int, default=1000
+        Maximum number of generations.
+    target_fitness : float, default=1.0
+        Stops when the best fitness reaches this value, between 0 and 1
+        (1.0 = only stops if every sample is right, so it usually runs every generation).
+    thresholds : np.ndarray of shape (K-1,) or None, default=None
+        None for 2 classes (binary), or K-1 cut points in increasing order for
+        K classes (ordinal).
+    gene_min : float, default=-1.0
+        Smallest gene value in the initial population.
+    gene_max : float, default=1.0
+        Largest gene value in the initial population. Must be greater than gene_min.
+    seed : int or None, default=None
+        Random seed for reproducibility (None = different result every run).
+    verbose : bool, default=True
+        If True, prints the best fitness and accuracy of every generation.
+
+    Returns
+    -------
+    model : dict
+        The trained model, ready to be passed to predict(). Keys:
+
+        - ``"chromosome"`` (np.ndarray of shape (n_features + 1,)): best
+          chromosome found. Position 0 is the bias, the rest are the weights.
+        - ``"fitness"`` (float): fitness of the best chromosome on the training data, 0 to 1.
+        - ``"accuracy"`` (float): fraction of the samples of X that the best
+          chromosome gets right, 0 to 1.
+        - ``"generation"`` (int): generation where training stopped.
+        - ``"thresholds"`` (np.ndarray or None): thresholds used (None if binary).
+        - ``"history"`` (dict of lists of float, one value per generation):
+          ``"best"`` = best fitness so far, ``"mean"`` = mean fitness of the
+          population, ``"accuracy"`` = accuracy of the best chromosome so far.
+
+    Examples
+    --------
+    >>> model = train(X_train, y_train, seed=0)
+    >>> model["accuracy"]
+    """
+
+    if not isinstance(X, np.ndarray):
+        raise TypeError("X must be an ndarray")
+
+    if not isinstance(y, np.ndarray):
+        raise TypeError("y must be an ndarray")
+
+    if X.ndim != 2:
+        raise ValueError(f"X must be a 2D matrix (n_samples, n_features), got {X.ndim} dimensions")
+
+    if y.ndim != 1:
+        raise ValueError(f"y must be a 1D vector, got {y.ndim} dimensions")
+
+    if X.shape[0] != y.shape[0]:
+        raise ValueError(f"X has {X.shape[0]} samples, but y has {y.shape[0]} values")
+
+    if X.shape[1] == 0:
+        raise ValueError("X has no features (at least 1 column is needed)")
+
+    _check_features(X)
+
+    if not isinstance(n_chromosomes, int):
+        raise TypeError("n_chromosomes must be an integer")
+
+    if n_chromosomes <= 0:
+        raise ValueError(f"n_chromosomes must be >= 1, got {n_chromosomes}")
+
+    if not isinstance(n_mutated_genes, int):
+        raise TypeError("n_mutated_genes must be an integer")
+
+    if n_mutated_genes < 0 or n_mutated_genes > X.shape[1] + 1:
+        raise ValueError(f"n_mutated_genes must be between 0 and {X.shape[1] + 1} (number of genes), got {n_mutated_genes}")
+
+    if not isinstance(n_offspring, int):
+        raise TypeError("n_offspring must be an integer")
+
+    if n_offspring <= 0:
+        raise ValueError(f"n_offspring must be >= 1, got {n_offspring}")
+
+    if n_replacements is None:
+        n_replacements = min(max(n_offspring // 2, 1), n_chromosomes)
+
+    if not isinstance(n_replacements, int):
+        raise TypeError("n_replacements must be an integer or None")
+
+    if n_replacements < 0 or n_replacements > min(n_chromosomes, n_offspring):
+        raise ValueError(f"n_replacements must be between 0 and {min(n_chromosomes, n_offspring)} (smaller of n_chromosomes and n_offspring), got {n_replacements}")
+
+    if not isinstance(n_generations, int):
+        raise TypeError("n_generations must be an integer")
+
+    if n_generations <= 0:
+        raise ValueError(f"n_generations must be >= 1, got {n_generations}")
+
+    if not isinstance(target_fitness, (int, float)):
+        raise TypeError("target_fitness must be a number")
+
+    if target_fitness < 0 or target_fitness > 1:
+        raise ValueError(f"target_fitness must be between 0 and 1, got {target_fitness}")
+
+    if not isinstance(gene_min, (int, float)):
+        raise TypeError("gene_min must be a number")
+
+    if not isinstance(gene_max, (int, float)):
+        raise TypeError("gene_max must be a number")
+
+    if gene_min >= gene_max:
+        raise ValueError(f"gene_min ({gene_min}) must be smaller than gene_max ({gene_max})")
+
+    if seed is not None and (not isinstance(seed, int) or isinstance(seed, bool)):
+        raise TypeError("seed must be an integer or None")
+
+    if not isinstance(verbose, bool):
+        raise TypeError("verbose must be True or False")
+
+    if thresholds is not None and not isinstance(thresholds, np.ndarray):
+        raise TypeError("thresholds must be an ndarray or None")
+
+    if seed is not None:
+        np.random.seed(seed)
+
+    # convert once: X @ weights with an integer X (e.g. output of read_csv) is ~6x slower than with float
+    X = X.astype(float)
+
+    n_genes = X.shape[1] + 1  # +1 for the bias
+
+    if thresholds is None:
+        def compute_fitness(chromosomes):
+            return binary_fitness(chromosomes, X, y)
+    else:
+        thresholds = np.asarray(thresholds)
+
+        def compute_fitness(chromosomes):
+            return ordinal_fitness(chromosomes, X, y, thresholds)
+
+    population = create_chromosomes(n_chromosomes, n_genes, gene_min, gene_max)
+
+    best_chromosome = None
+    best_fitness = -np.inf
+    best_accuracy = 0.0
+    final_generation = 0
+    history = {"best": [], "mean": [], "accuracy": []}
+
+    for generation in range(n_generations):
+        fitnesses = compute_fitness(population)
+        proportions = fitness_proportions(fitnesses)
+
+        # best of the current generation
+        best_index = int(np.argmax(fitnesses))
+        current_fitness = float(fitnesses[best_index])
+
+        # update the overall best, if it improved
+        if current_fitness > best_fitness:
+            best_fitness = current_fitness
+            best_chromosome = population[best_index].copy()
+
+            # accuracy = hits / total, only recomputed when the best changes
+            y_pred = predict({"chromosome": best_chromosome, "thresholds": thresholds}, X)
+            best_accuracy = float(np.mean(y_pred == y))
+
+        final_generation = generation + 1
+        history["best"].append(best_fitness)
+        history["mean"].append(float(fitnesses.mean()))
+        history["accuracy"].append(best_accuracy)
+
+        if verbose:
+            print(f"Generation {final_generation:>4} | best fitness: {best_fitness:.4f} | accuracy: {best_accuracy:.2%}")
+
+        # stopping criterion: target fitness
+        if best_fitness >= target_fitness:
+            if verbose:
+                print(f"\nTarget fitness {target_fitness} reached at generation {final_generation}.")
+            break
+
+        # no offspring in the last generation: they would never compete with the best
+        if final_generation == n_generations:
+            break
+
+        # selection -> crossover -> mutation -> fitness -> replacement
+        parent1, parent2 = select_parents_roulette(population, proportions)
+        offspring = one_point_crossover(parent1, parent2, n_offspring)
+        offspring = mutate(offspring, n_mutated_genes)
+        offspring_fitnesses = compute_fitness(offspring)
+        population = update_population(
+            population, fitnesses,
+            offspring, offspring_fitnesses,
+            n_replacements,
+        )
+
+    return {
+        "chromosome": best_chromosome,
+        "fitness": best_fitness,
+        "accuracy": best_accuracy,
+        "generation": final_generation,
+        "thresholds": thresholds,
+        "history": history,
+    }
+
+
+def predict(model: dict, X: np.ndarray) -> np.ndarray:
+    """
+    Use the best chromosome found by train() to classify new data.
+
+    Parameters
+    ----------
+    model : dict
+        Model returned by train(). Needs the keys ``"chromosome"`` and ``"thresholds"``.
+    X : np.ndarray of shape (n_features,) or (n_samples, n_features)
+        One sample (1D) or several samples (2D), numbers only, with the same
+        features used in training.
+
+    Returns
+    -------
+    y_pred : np.ndarray of shape (n_samples,), dtype int
+        Predicted class of each sample (shape (1,) when X is a single sample).
+
+    Examples
+    --------
+    >>> y_pred = predict(model, X_test)
+    """
+
+    if not isinstance(model, dict):
+        raise TypeError("model must be a dict (returned by train())")
+
+    if "chromosome" not in model:
+        raise ValueError("invalid model: missing the 'chromosome' key")
+
+    if "thresholds" not in model:
+        raise ValueError("invalid model: missing the 'thresholds' key")
+
+    if model["chromosome"] is None:
+        raise ValueError("model was not trained (chromosome is None)")
+
+    if not isinstance(model["chromosome"], np.ndarray):
+        raise TypeError("model['chromosome'] must be an ndarray")
+
+    if model["thresholds"] is not None and not isinstance(model["thresholds"], np.ndarray):
+        raise TypeError("model['thresholds'] must be an ndarray or None")
+
+    if not isinstance(X, np.ndarray):
+        raise TypeError("X must be an ndarray")
+
+    if X.ndim not in (1, 2):
+        raise ValueError(f"X must be 1D (one sample) or 2D (several samples), got {X.ndim}D")
+
+    _check_features(X)
+
+    chromosome = model["chromosome"]
+    thresholds = model["thresholds"]
+
+    bias = chromosome[0]
+    weights = chromosome[1:]
+
+    # a single sample (1D) becomes a (1, n_features) matrix so it works the same way
+    if X.ndim == 1:
+        X = X.reshape(1, -1)
+
+    # the number of features must match the chromosome
+    if X.shape[1] != len(weights):
+        raise ValueError(
+            f"X has {X.shape[1]} features, but the chromosome was trained with {len(weights)} features"
+        )
+
+    scores = np.dot(X, weights) + bias
+
+    if thresholds is None:
+        return np.where(scores >= 0, 1, 0)
+    return np.digitize(scores, thresholds)

genetic_classifier/creation.py

@@ -0,0 +1,47 @@
+# order: step 1 (start) -> next: fitness.py
+"""Creation of the initial population of chromosomes."""
+
+import numpy as np
+
+
+def create_chromosomes(n_chromosomes: int = 6, n_genes: int = 19,
+    gene_min: float = -1.0, gene_max: float = 1.0) -> np.ndarray:
+    """
+    Create the initial population: a matrix where each row is a chromosome and
+    each column is a gene, filled with random values between gene_min and gene_max.
+
+    Parameters
+    ----------
+    n_chromosomes : int, default=6
+        How many chromosomes to create (the population size). Must be >= 1.
+    n_genes : int, default=19
+        How many genes each chromosome has: one weight per feature plus one bias,
+        so usually ``n_features + 1``. Must be >= 1.
+    gene_min : float, default=-1.0
+        Smallest value a gene can take.
+    gene_max : float, default=1.0
+        Largest value a gene can take. Must be greater than gene_min.
+
+    Returns
+    -------
+    population : np.ndarray of shape (n_chromosomes, n_genes)
+        The new population. Column 0 is the bias, the other columns are the weights.
+
+    Examples
+    --------
+    >>> population = create_chromosomes(n_chromosomes=30, n_genes=X.shape[1] + 1)
+    """
+
+    if not isinstance(n_chromosomes, int) or not isinstance(n_genes, int):
+        raise TypeError("n_chromosomes and n_genes must be integers")
+
+    if n_chromosomes <= 0 or n_genes <= 0:
+        raise ValueError("at least 1 chromosome and 1 gene are needed")
+
+    if not isinstance(gene_min, (int, float)) or not isinstance(gene_max, (int, float)):
+        raise TypeError("gene_min and gene_max must be numbers")
+
+    if gene_min >= gene_max:
+        raise ValueError(f"gene_min ({gene_min}) must be smaller than gene_max ({gene_max})")
+
+    return np.random.uniform(gene_min, gene_max, size=(n_chromosomes, n_genes))

genetic_classifier/crossover.py

@@ -0,0 +1,53 @@
+# order: step 4, comes after selection.py -> next: mutation.py
+"""Crossover between two parents."""
+
+import numpy as np
+
+
+def one_point_crossover(parent1: np.ndarray, parent2: np.ndarray, n_offspring: int = 3) -> np.ndarray:
+    """
+    Create offspring by cutting the parents at a random point: each child takes
+    the beginning of parent1 and the end of parent2. Each child gets its own
+    cut point.
+
+    Parameters
+    ----------
+    parent1 : np.ndarray of shape (n_genes,)
+        First parent chosen (gives the genes before the cut).
+    parent2 : np.ndarray of shape (n_genes,)
+        Second parent chosen (gives the genes from the cut onwards). Must have
+        the same number of genes as parent1, at least 2.
+    n_offspring : int, default=3
+        How many children to create. Must be >= 1.
+
+    Returns
+    -------
+    offspring : np.ndarray of shape (n_offspring, n_genes)
+        The children, one per row.
+
+    Examples
+    --------
+    >>> offspring = one_point_crossover(parent1, parent2, n_offspring=16)
+    """
+
+    if not isinstance(parent1, np.ndarray) or not isinstance(parent2, np.ndarray):
+        raise TypeError("parent1 and parent2 must be ndarrays")
+
+    if len(parent1) != len(parent2):
+        raise ValueError("parent1 and parent2 must have the same number of genes")
+
+    if len(parent1) < 2:
+        raise ValueError(f"parent1 and parent2 need at least 2 genes to have a cut point, got {len(parent1)}")
+
+    if n_offspring <= 0:
+        raise ValueError(f"n_offspring must be at least 1, got {n_offspring}")
+
+    offspring = []
+    for _ in range(n_offspring):
+        # random integer from 1 to len(parent1)-1, never cuts at the ends
+        cut = np.random.randint(1, len(parent1))
+        child = parent1.copy()           # starts equal to parent1
+        child[cut:] = parent2[cut:]      # from the cut onwards takes parent2's genes
+        offspring.append(child)
+
+    return np.array(offspring)  # turns the list of children into a matrix

genetic_classifier/evaluation.py

@@ -0,0 +1,233 @@
+"""Model evaluation after training."""
+
+import numpy as np
+
+
+def _labels_to_int(y: np.ndarray, name: str) -> np.ndarray:
+    """
+    Return the classes as integers. Accepts floats holding whole numbers
+    (e.g. 1.0), which is how a class column may come from a spreadsheet.
+
+    Parameters
+    ----------
+    y : np.ndarray of shape (n_samples,)
+        Classes to convert.
+    name : str
+        Name of the parameter being converted, used in the error message.
+
+    Returns
+    -------
+    y_int : np.ndarray of shape (n_samples,), dtype int
+        The same classes as integers.
+    """
+    if np.issubdtype(y.dtype, np.integer):
+        return y
+
+    if np.issubdtype(y.dtype, np.floating) and np.isfinite(y).all() and np.all(y == np.floor(y)):
+        return y.astype(int)
+
+    raise TypeError(f"{name} must contain integers from 0 to K-1 (convert text classes first)")
+
+
+def confusion_matrix(y_true: np.ndarray, y_pred: np.ndarray,
+    class_names: list[str] | None = None, verbose: bool = True) -> np.ndarray:
+    """
+    Build the confusion matrix: each row is the true class, each column is the
+    predicted class, and the diagonal holds the correct predictions.
+
+    Parameters
+    ----------
+    y_true : np.ndarray of shape (n_samples,)
+        True class of each sample, integers from 0 to K-1.
+    y_pred : np.ndarray of shape (n_samples,)
+        Predicted class of each sample (output of predict).
+    class_names : list of str or None, default=None
+        Name of each class, in order from 0 to K-1 (None = use the numbers).
+        It also sets K, so the matrix is complete even if some class does not
+        appear in the data.
+    verbose : bool, default=True
+        If True, prints the matrix.
+
+    Returns
+    -------
+    matrix : np.ndarray of shape (K, K), dtype int
+        matrix[i, j] is how many samples of true class i were predicted as class j.
+
+    Examples
+    --------
+    >>> matrix = confusion_matrix(y_test, y_pred, class_names=["poisonous", "edible"])
+    """
+
+    if not isinstance(y_true, np.ndarray) or not isinstance(y_pred, np.ndarray):
+        raise TypeError("y_true and y_pred must be ndarrays")
+
+    if y_true.ndim != 1 or y_pred.ndim != 1:
+        raise ValueError(f"y_true and y_pred must be 1D vectors, got {y_true.ndim} and {y_pred.ndim} dimensions")
+
+    if len(y_true) != len(y_pred):
+        raise ValueError(f"y_true has {len(y_true)} values, but y_pred has {len(y_pred)}")
+
+    if len(y_true) == 0:
+        raise ValueError("y_true and y_pred cannot be empty")
+
+    y_true = _labels_to_int(y_true, "y_true")
+    y_pred = _labels_to_int(y_pred, "y_pred")
+
+    if class_names is not None and not isinstance(class_names, list):
+        raise TypeError("class_names must be a list or None")
+
+    if class_names is not None and len(class_names) == 0:
+        raise ValueError("class_names cannot be empty")
+
+    if not isinstance(verbose, bool):
+        raise TypeError("verbose must be True or False")
+
+    smallest_class = min(y_true.min(), y_pred.min())
+    largest_class = max(y_true.max(), y_pred.max())
+
+    if smallest_class < 0:
+        raise ValueError(f"classes must be integers starting at 0, found {smallest_class}")
+
+    if class_names is None:
+        K = int(largest_class) + 1
+    else:
+        K = len(class_names)
+        if largest_class >= K:
+            raise ValueError(f"class_names has {K} names, but the data has class {largest_class}")
+
+    matrix = np.zeros((K, K), dtype=int)
+    for true, predicted in zip(y_true, y_pred):
+        matrix[true, predicted] += 1
+
+    if verbose:
+        _print_matrix(matrix, _display_names(K, class_names))
+
+    return matrix
+
+
+def evaluate(y_true: np.ndarray, y_pred: np.ndarray,
+    class_names: list[str] | None = None, verbose: bool = True) -> dict:
+    """
+    Compare the predictions with the true classes: compute the accuracy, the
+    fitness, the recall of each class and the confusion matrix.
+
+    Parameters
+    ----------
+    y_true : np.ndarray of shape (n_samples,)
+        True class of each sample, integers from 0 to K-1.
+    y_pred : np.ndarray of shape (n_samples,)
+        Predicted class of each sample (output of predict).
+    class_names : list of str or None, default=None
+        Name of each class, in order from 0 to K-1 (None = use the numbers).
+        It also sets K, so the result is complete even if some class does not
+        appear in the data.
+    verbose : bool, default=True
+        If True, prints the results.
+
+    Returns
+    -------
+    results : dict
+        Dictionary with the keys:
+
+        - ``"accuracy"`` (float): fraction of samples predicted correctly, 0 to 1.
+        - ``"fitness"`` (float): product of the recalls, 0 to 1 (nan if some
+          class has no samples).
+        - ``"recall"`` (np.ndarray of shape (K,), dtype float): recall of each
+          class (nan for a class without samples).
+        - ``"confusion_matrix"`` (np.ndarray of shape (K, K), dtype int): same
+          as the output of confusion_matrix.
+
+    Examples
+    --------
+    >>> results = evaluate(y_test, y_pred)
+    >>> results["accuracy"]
+    """
+
+    if not isinstance(verbose, bool):
+        raise TypeError("verbose must be True or False")
+
+    # the other checks are already done by confusion_matrix
+    matrix = confusion_matrix(y_true, y_pred, class_names, verbose=False)
+
+    hits = np.diag(matrix)
+    totals = matrix.sum(axis=1)
+
+    # a class without samples gets nan: its recall cannot be measured
+    recall = np.full(len(matrix), np.nan)
+    has_samples = totals > 0
+    recall[has_samples] = hits[has_samples] / totals[has_samples]
+
+    accuracy = float(hits.sum() / matrix.sum())
+    fitness = float(np.prod(recall))
+
+    if verbose:
+        names = _display_names(len(matrix), class_names)
+
+        print(f"accuracy: {accuracy:.2%}")
+        if np.isnan(fitness):
+            print("fitness: not computed (a class has no samples)")
+        else:
+            print(f"fitness: {fitness:.4f}")
+
+        print("\nrecall per class:")
+        for name, hit, total, value in zip(names, hits, totals, recall):
+            if total == 0:
+                print(f"  {name}: no samples")
+            else:
+                print(f"  {name}: {hit}/{total} = {value:.2%}")
+
+        print("\nconfusion matrix:")
+        _print_matrix(matrix, names)
+
+    return {
+        "accuracy": accuracy,
+        "fitness": fitness,
+        "recall": recall,
+        "confusion_matrix": matrix,
+    }
+
+
+def _display_names(K: int, class_names: list[str] | None) -> list[str]:
+    """
+    Return the text that represents each class on screen.
+
+    Parameters
+    ----------
+    K : int
+        Number of classes.
+    class_names : list of str or None
+        Name of each class, or None to use the numbers 0 to K-1.
+
+    Returns
+    -------
+    names : list of str
+        K texts, one per class.
+    """
+    if class_names is None:
+        return [str(k) for k in range(K)]
+    return [str(name) for name in class_names]
+
+
+def _print_matrix(matrix: np.ndarray, names: list[str]) -> None:
+    """
+    Print the confusion matrix with aligned columns.
+
+    Parameters
+    ----------
+    matrix : np.ndarray of shape (K, K)
+        Confusion matrix.
+    names : list of str
+        Text that represents each class (K items).
+
+    Returns
+    -------
+    None
+        Only prints.
+    """
+    title = "true \\ predicted"
+    name_width = max(len(title), *(len(name) for name in names))
+    column_width = max(*(len(name) for name in names), len(str(matrix.max()))) + 2
+
+    print(f"{title:>{name_width}}" + "".join(f"{name:>{column_width}}" for name in names))
+    for name, row in zip(names, matrix):
+        print(f"{name:>{name_width}}" + "".join(f"{value:>{column_width}}" for value in row))