Latent Structure and Signal Extraction: How Linear Algebra Reveals Hidden Patterns and Residual Signals

Last Updated July 3, 2026

Latent structure and signal extraction explain how hidden patterns can be inferred from observable data without mistaking those patterns for automatic causes, categories, or truths. In linear algebra and systems modeling, latent structure often appears through low-rank patterns, shared variation, hidden factors, correlated measurements, common modes, embedded coordinates, residual anomalies, and signals separated from noise.

This article continues Part VI of the Linear Algebra for Systems Modeling series by connecting singular value decomposition, principal component analysis, dimensionality reduction, matrix factorization, latent variables, signal extraction, noise separation, factor models, nonnegative matrix factorization, independent component analysis, embeddings, residual diagnostics, anomaly detection, validation, and responsible interpretation.

The central modeling question is not only “Can hidden structure be extracted?” It is “What kind of structure is being inferred, how stable is it, what assumptions produced it, what remains in the residuals, and whether the extracted signal is meaningful for the system being studied?”

Latent structure refers to patterns that are not directly observed but are inferred from observable measurements. A dataset may contain many variables, sensors, documents, regions, indicators, or system states, but its behavior may be partly explained by fewer hidden dimensions. Signal extraction is the process of identifying the structured part of the data that supports interpretation, prediction, monitoring, compression, or decision-making.

Linear algebra provides many tools for this work. SVD extracts singular directions. PCA extracts directions of maximum variance. Factor models infer hidden factors. Nonnegative matrix factorization finds additive parts-based patterns. Independent component analysis separates statistically independent sources. Embeddings map complex objects into lower-dimensional vector spaces. Residual analysis identifies what the extracted structure failed to explain.

Why Latent Structure Matters

Latent structure matters because observable data often contain hidden organization. Measurements may be correlated because they share underlying drivers. Documents may cluster because they share themes. Sensors may move together because they reflect common operating modes. Public health indicators may vary together because they reflect access, exposure, deprivation, or service capacity. Economic variables may move together because they share sectoral or demand structure.

Extracting latent structure can help simplify complex systems, identify dominant patterns, reduce noise, compress data, stabilize models, support monitoring, detect anomalies, and reveal hidden relationships. But it can also mislead when latent coordinates are treated as real categories without validation.

Latent structure is useful precisely because it is not directly visible. That also makes it dangerous when its assumptions are hidden.

Back to top ↑

Observed Data and Hidden Patterns

A common modeling setup begins with an observed data matrix:

Latent structure assumes that the observed matrix can be partly explained by hidden lower-dimensional structure:

This general structure appears in PCA, factor models, matrix factorization, embeddings, topic models, recommender systems, sensor models, and reduced-order simulations.

Back to top ↑

Signal, Noise, and Residuals

Signal extraction separates structured variation from variation treated as noise or residual. In a simplified form:

The difficulty is that the boundary between signal and noise is not automatic. A large component may be systematic bias. A small component may be an early warning signal. A residual may be random noise, data error, subgroup structure, nonlinear behavior, or an event the model fails to represent.

Signal extraction requires judgment. Mathematical strength does not automatically equal importance, and residual weakness does not automatically equal irrelevance.

Back to top ↑

Low-Rank Structure

Low-rank structure means that a high-dimensional matrix can be approximated by fewer independent directions. If the rank-\(k\) approximation captures most relevant structure, then:

Low-rank assumptions are common in signal processing, recommender systems, scientific computing, environmental modeling, sensor analysis, text analysis, and reduced-order modeling. They are powerful because they make hidden structure computationally tractable.

Low-rank structure is a hypothesis about how the system can be represented. It should be evaluated, not assumed.

Back to top ↑

SVD and Latent Directions

Singular value decomposition expresses a matrix as:

The rank-\(k\) approximation is:

In latent-structure terms, \(U_k\Sigma_k\) can be treated as latent scores, while \(V_k\) defines feature directions. The residual is:

SVD is one of the clearest linear algebra tools for latent structure because it makes strength, rank, reconstruction, and residuals explicit.

Back to top ↑

PCA as Signal Extraction

Principal component analysis extracts directions of maximum variance from centered data. If \(X_c\) is centered, PCA represents observations using principal component scores:

The retained PCA signal is:

PCA can be understood as signal extraction when the leading variance directions are interpreted as the structured part of the data. But this interpretation requires care. PCA extracts variance, not necessarily meaning. A high-variance direction may reflect scale, sampling, bias, or a dominant group rather than a meaningful system mechanism.

PCA is signal extraction only under an assumption that dominant linear variance is the structure worth retaining.

Back to top ↑

Factor Models

Factor models assume that observed variables are influenced by a smaller number of latent factors. A common form is:

Factor models are used when observed indicators are thought to reflect hidden constructs, such as capability, risk, deprivation, infrastructure condition, economic stress, organizational capacity, or latent demand. Unlike PCA, factor analysis often makes stronger statistical assumptions about latent variables, errors, and covariance structure.

Factor models are powerful when latent constructs are theoretically meaningful, but they should not be used to invent hidden categories without validation.

Back to top ↑

Nonnegative Matrix Factorization

Nonnegative matrix factorization, often abbreviated NMF, approximates a nonnegative matrix as a product of nonnegative factors:

NMF is useful when negative values would be hard to interpret. It is often applied to document-term matrices, topic-like structures, image parts, biological data, recommender systems, and nonnegative measurement systems. Because it produces additive, nonnegative components, it can be easier to interpret than PCA in some settings.

NMF components are often interpretable as parts, topics, patterns, or profiles, but they are still model artifacts shaped by rank choice, initialization, objective function, scaling, and constraints.

Back to top ↑

Independent Component Analysis

Independent component analysis, or ICA, seeks to separate observed mixtures into statistically independent source signals. In a simplified form:

ICA is often used in signal processing, sensor analysis, neuroscience, audio separation, and source separation problems. Unlike PCA, which finds uncorrelated orthogonal directions of maximum variance, ICA seeks statistically independent components that need not be orthogonal.

ICA is valuable when source separation is plausible, but independence is a strong assumption and extracted components require domain validation.

Back to top ↑

Embeddings and Latent Spaces

Embeddings map objects into latent vector spaces. Documents, users, items, nodes, regions, images, scenarios, or system states can be represented as vectors:

Embeddings are widespread because they make complex objects computationally comparable. Similarity, clustering, retrieval, recommendation, classification, and anomaly detection can all operate on latent vectors. But embedding spaces depend on training data, objective functions, architecture, preprocessing, normalization, sampling, and deployment context.

Latent spaces can be useful without being fully interpretable. Responsible use requires knowing when an embedding is a useful computational representation and when it should not be treated as an explanation.

Back to top ↑

Residual Diagnostics

Residuals are central to signal extraction. After extracting latent structure, the residual matrix is the part that remains unexplained:

Residuals should be examined across observations, variables, time, groups, locations, and scenarios. A small total residual may hide concentrated error. A residual pattern may reveal omitted structure, nonlinear effects, sensor problems, rare events, subgroup differences, or changing system behavior.

Residuals are not simply waste. They are often where the model’s limits become visible.

Back to top ↑

Anomaly Detection and Change Signals

Latent structure can support anomaly detection by defining expected structure and measuring deviation from it. Observations with large residuals, unusual latent scores, or sudden changes in component patterns may indicate anomalies.

Anomaly detection is useful in infrastructure monitoring, cybersecurity, sensor systems, public health surveillance, financial systems, environmental monitoring, manufacturing, and operational risk. But anomaly is not the same as error. An anomaly can be a measurement fault, rare legitimate event, emerging transition, subgroup mismatch, or early warning signal.

Signal extraction should help detect meaningful deviation, not suppress it in the name of simplification.

Back to top ↑

Validation and Stability

Latent structure must be validated. A decomposition can always produce components, factors, or embeddings, but that does not mean the extracted structure is stable or meaningful. Validation asks whether the structure persists across data samples, preprocessing choices, rank choices, random seeds, time periods, subgroups, and downstream tasks.

Stable latent structure is not guaranteed. It must be demonstrated through reproducible diagnostics.

Back to top ↑

Latent Structure in Systems Modeling

Systems modeling often depends on extracting hidden structure from observable measurements. Infrastructure systems produce sensor patterns. Environmental systems produce spatial-temporal modes. Public health systems produce correlated indicators. Economic systems produce latent demand, stress, or sectoral relationships. Knowledge systems produce semantic embeddings. Machine learning systems produce latent representations inside pipelines.

Across these domains, latent structure should clarify hidden organization while keeping uncertainty, residuals, and interpretation limits visible.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer. Latent structure and signal extraction connect low-rank approximation, matrix factorization, projections, covariance structure, source separation, embeddings, residual diagnostics, anomaly scoring, regularization, stability analysis, and validation.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for latent structure and signal extraction should document the original matrix, preprocessing, centering, scaling, method, rank, extracted components, latent scores, loadings, reconstructed signal, residual matrix, reconstruction error, anomaly score, explained variation, factor interpretation, initialization, random seed, regularization, stability checks, validation context, and interpretation warnings.

The companion repository treats latent structure as an auditable signal-extraction workflow. Python, R, Julia, SQL, Haskell, C, C++, Fortran, Rust, Go, notebooks, schemas, generated outputs, Canvas artifacts, advanced reports, and calculators each support a different layer of reproducible latent-structure diagnostics.

For this article, the computational examples focus on SVD-based signal extraction, low-rank reconstruction, residual energy, anomaly scoring, retained-signal ratio, latent score export, governance records, and interpretation warnings.

Back to top ↑

Python Workflow: Latent Structure Audit

The Python workflow below computes a latent-structure audit for a synthetic systems measurement matrix. It extracts a low-rank signal using SVD, reconstructs the retained structure, computes residuals, and reports anomaly scores and governance warnings.

from __future__ import annotations

from dataclasses import asdict, dataclass
from pathlib import Path
import csv
import json
import numpy as np


@dataclass(frozen=True)
class LatentStructureAudit:
    model_name: str
    observations: int
    variables: int
    method: str
    preprocessing: str
    retained_rank: int
    retained_signal_ratio: float
    relative_reconstruction_error: float
    maximum_observation_residual: float
    highest_residual_observation: int
    signal_definition_warning: str
    interpretation_warning: str


def build_measurement_matrix() -> np.ndarray:
    return np.array(
        [
            [82.0, 71.0, 18.0, 22.0, 41.0, 3.2],
            [79.0, 69.0, 17.0, 20.0, 39.0, 3.0],
            [85.0, 73.0, 20.0, 25.0, 43.0, 3.5],
            [48.0, 52.0, 35.0, 40.0, 62.0, 6.1],
            [51.0, 54.0, 38.0, 42.0, 64.0, 6.4],
            [46.0, 50.0, 34.0, 39.0, 60.0, 5.9],
            [68.0, 61.0, 27.0, 31.0, 52.0, 4.8],
            [70.0, 63.0, 29.0, 33.0, 54.0, 5.0],
            [90.0, 78.0, 42.0, 47.0, 71.0, 7.8],
        ],
        dtype=float,
    )


def standardize(x: np.ndarray) -> np.ndarray:
    return (x - x.mean(axis=0)) / x.std(axis=0, ddof=1)


def latent_structure_audit(retained_rank: int = 2) -> tuple[LatentStructureAudit, np.ndarray, np.ndarray]:
    x = build_measurement_matrix()
    xs = standardize(x)

    u, singular_values, vt = np.linalg.svd(xs, full_matrices=False)

    scores = u[:, :retained_rank] @ np.diag(singular_values[:retained_rank])
    reconstructed = scores @ vt[:retained_rank, :]
    residuals = xs - reconstructed

    retained_signal_ratio = float(np.sum(singular_values[:retained_rank] ** 2) / np.sum(singular_values ** 2))
    relative_reconstruction_error = float(np.linalg.norm(residuals, ord="fro") / np.linalg.norm(xs, ord="fro"))

    observation_residuals = np.sqrt(np.sum(residuals * residuals, axis=1))
    highest_residual_observation = int(np.argmax(observation_residuals))

    audit = LatentStructureAudit(
        model_name="synthetic_latent_structure_signal_extraction_audit",
        observations=x.shape[0],
        variables=x.shape[1],
        method="svd_low_rank_signal_extraction",
        preprocessing="centered_and_standardized",
        retained_rank=retained_rank,
        retained_signal_ratio=round(retained_signal_ratio, 12),
        relative_reconstruction_error=round(relative_reconstruction_error, 12),
        maximum_observation_residual=round(float(observation_residuals.max()), 12),
        highest_residual_observation=highest_residual_observation,
        signal_definition_warning=(
            "The retained low-rank structure is treated as signal only under the chosen method, "
            "preprocessing, retained rank, scaling, and validation assumptions."
        ),
        interpretation_warning=(
            "Latent components are inferred mathematical structures, not automatic causes, categories, "
            "mechanisms, or complete system truths. Residuals require review before being dismissed as noise."
        ),
    )

    return audit, scores, residuals


def write_outputs(output_dir: Path) -> None:
    (output_dir / "tables").mkdir(parents=True, exist_ok=True)
    (output_dir / "json").mkdir(parents=True, exist_ok=True)

    audit, scores, residuals = latent_structure_audit()
    row = asdict(audit)

    with (output_dir / "tables" / "latent_structure_audit.csv").open(
        "w", newline="", encoding="utf-8"
    ) as handle:
        writer = csv.DictWriter(handle, fieldnames=list(row.keys()))
        writer.writeheader()
        writer.writerow(row)

    with (output_dir / "tables" / "latent_scores.csv").open(
        "w", newline="", encoding="utf-8"
    ) as handle:
        writer = csv.DictWriter(handle, fieldnames=["observation_index", "latent_1", "latent_2"])
        writer.writeheader()
        for index, score_row in enumerate(scores):
            writer.writerow({
                "observation_index": index,
                "latent_1": round(float(score_row[0]), 12),
                "latent_2": round(float(score_row[1]), 12),
            })

    residual_norms = np.sqrt(np.sum(residuals * residuals, axis=1))
    with (output_dir / "tables" / "residual_diagnostics.csv").open(
        "w", newline="", encoding="utf-8"
    ) as handle:
        writer = csv.DictWriter(handle, fieldnames=["observation_index", "residual_norm"])
        writer.writeheader()
        for index, value in enumerate(residual_norms):
            writer.writerow({
                "observation_index": index,
                "residual_norm": round(float(value), 12),
            })

    (output_dir / "json" / "latent_structure_audit.json").write_text(
        json.dumps(row, indent=2, sort_keys=True),
        encoding="utf-8",
    )


if __name__ == "__main__":
    write_outputs(Path("outputs"))
    print("Latent structure and signal extraction audit complete.")

This workflow keeps extracted structure, retained rank, latent scores, residuals, anomaly review, and interpretation warnings together.

Back to top ↑

R Workflow: Signal Extraction Diagnostics

R can support latent-structure diagnostics using SVD, low-rank reconstruction, residual norms, and retained-signal ratios.

X <- matrix(
  c(
    82, 71, 18, 22, 41, 3.2,
    79, 69, 17, 20, 39, 3.0,
    85, 73, 20, 25, 43, 3.5,
    48, 52, 35, 40, 62, 6.1,
    51, 54, 38, 42, 64, 6.4,
    46, 50, 34, 39, 60, 5.9,
    68, 61, 27, 31, 52, 4.8,
    70, 63, 29, 33, 54, 5.0,
    90, 78, 42, 47, 71, 7.8
  ),
  nrow = 9,
  byrow = TRUE
)

retained_rank <- 2
scaled_X <- scale(X, center = TRUE, scale = TRUE)

svd_result <- svd(scaled_X)

scores <- svd_result$u[, 1:retained_rank, drop = FALSE] %*%
  diag(svd_result$d[1:retained_rank], retained_rank, retained_rank)

reconstructed <- scores %*% t(svd_result$v[, 1:retained_rank, drop = FALSE])
residuals <- scaled_X - reconstructed

retained_signal_ratio <-
  sum(svd_result$d[1:retained_rank]^2) / sum(svd_result$d^2)

relative_reconstruction_error <-
  sqrt(sum(residuals^2)) / sqrt(sum(scaled_X^2))

observation_residuals <- sqrt(rowSums(residuals^2))

audit_record <- data.frame(
  model_name = "synthetic_latent_structure_signal_extraction_audit",
  observations = nrow(X),
  variables = ncol(X),
  method = "svd_low_rank_signal_extraction",
  preprocessing = "centered_and_standardized",
  retained_rank = retained_rank,
  retained_signal_ratio = retained_signal_ratio,
  relative_reconstruction_error = relative_reconstruction_error,
  maximum_observation_residual = max(observation_residuals),
  highest_residual_observation = which.max(observation_residuals) - 1,
  signal_definition_warning = paste(
    "The retained low-rank structure is treated as signal only under the chosen method,",
    "preprocessing, retained rank, scaling, and validation assumptions."
  ),
  interpretation_warning = paste(
    "Latent components are inferred mathematical structures, not automatic causes, categories,",
    "mechanisms, or complete system truths."
  )
)

dir.create("outputs/tables", recursive = TRUE, showWarnings = FALSE)

write.csv(audit_record, "outputs/tables/r_latent_structure_audit.csv", row.names = FALSE)
write.csv(scores, "outputs/tables/r_latent_scores.csv")
write.csv(data.frame(observation_index = seq_along(observation_residuals) - 1,
                     residual_norm = observation_residuals),
          "outputs/tables/r_residual_diagnostics.csv",
          row.names = FALSE)

print(audit_record)

This R workflow keeps signal extraction, retained rank, residual diagnostics, and interpretation warnings in the same audit record.

Back to top ↑

Haskell Workflow: Typed Latent Structure Records

Haskell can represent latent-structure audit output as typed records, keeping method, retained rank, signal ratio, residual diagnostics, and interpretation warnings attached to the result.

module Main where

data LatentStructureAudit = LatentStructureAudit
  { modelName :: String
  , observations :: Int
  , variables :: Int
  , method :: String
  , preprocessing :: String
  , retainedRank :: Int
  , retainedSignalRatio :: Double
  , relativeReconstructionError :: Double
  , maximumObservationResidual :: Double
  , highestResidualObservation :: Int
  , signalDefinitionWarning :: String
  , interpretationWarning :: String
  } deriving (Show)

buildAudit :: LatentStructureAudit
buildAudit =
  LatentStructureAudit
    "synthetic_latent_structure_signal_extraction_audit"
    9
    6
    "svd_low_rank_signal_extraction"
    "centered_and_standardized"
    2
    0.962
    0.195
    1.43
    8
    "The retained low-rank structure is treated as signal only under chosen method, preprocessing, rank, scaling, and validation assumptions."
    "Latent components are inferred mathematical structures, not automatic causes, categories, mechanisms, or complete system truths."

main :: IO ()
main =
  print buildAudit

The typed record helps keep latent signal claims tied to assumptions, diagnostics, and residual review.

Back to top ↑

SQL Workflow: Latent Structure Governance Registry

SQL can document latent-structure assumptions when signal extraction supports dashboards, monitoring systems, embeddings, anomaly detection, scientific models, or governance workflows.

CREATE TABLE latent_structure_governance_registry (
    assumption_key TEXT PRIMARY KEY,
    assumption_name TEXT NOT NULL,
    mathematical_role TEXT NOT NULL,
    systems_modeling_role TEXT NOT NULL,
    review_warning TEXT NOT NULL
);

INSERT INTO latent_structure_governance_registry VALUES
(
  'observed_matrix',
  'Observed matrix',
  'Defines observations, variables, measurements, units, and missing-data handling.',
  'Determines what latent structure can be inferred.',
  'Latent structure is only as meaningful as the observed matrix construction.'
);

INSERT INTO latent_structure_governance_registry VALUES
(
  'preprocessing',
  'Preprocessing',
  'Defines centering, scaling, normalization, transformation, weighting, and filtering.',
  'Determines which patterns appear dominant or residual.',
  'Preprocessing choices can change extracted signal.'
);

INSERT INTO latent_structure_governance_registry VALUES
(
  'method_choice',
  'Method choice',
  'Defines whether structure is extracted through SVD, PCA, factor models, NMF, ICA, embeddings, or another method.',
  'Determines what kind of hidden structure the model is able to represent.',
  'Different methods extract different structures and should not be interpreted interchangeably.'
);

INSERT INTO latent_structure_governance_registry VALUES
(
  'rank_or_dimension',
  'Rank or latent dimension',
  'Defines how many components, factors, sources, or latent coordinates are retained.',
  'Controls signal extraction, residual size, interpretability, and compression.',
  'Rank choice should be justified and sensitivity-tested.'
);

INSERT INTO latent_structure_governance_registry VALUES
(
  'signal_definition',
  'Signal definition',
  'Defines which extracted components are treated as structured signal.',
  'Determines what is retained for interpretation, monitoring, or decision-making.',
  'Signal is a modeling designation, not an automatic property of the data.'
);

INSERT INTO latent_structure_governance_registry VALUES
(
  'residual_review',
  'Residual review',
  'Defines how unexplained variation is assessed.',
  'Supports detection of noise, anomaly, omitted structure, subgroup mismatch, or system change.',
  'Residuals should be reviewed before being dismissed as noise.'
);

INSERT INTO latent_structure_governance_registry VALUES
(
  'stability_validation',
  'Stability validation',
  'Assesses whether extracted structure persists across preprocessing, samples, time, groups, rank choices, and seeds.',
  'Supports trust in extracted signal.',
  'Unstable latent structure should not be overinterpreted.'
);

INSERT INTO latent_structure_governance_registry VALUES
(
  'responsible_interpretation',
  'Responsible interpretation',
  'Defines how latent components, scores, factors, or embeddings are explained and used.',
  'Prevents hidden coordinates from becoming unreviewed proxies for people, places, risk, capacity, or value.',
  'Latent components are inferred model artifacts, not automatic causes, categories, or truths.'
);

SELECT
    assumption_name,
    mathematical_role,
    systems_modeling_role,
    review_warning
FROM latent_structure_governance_registry
ORDER BY assumption_key;

This registry keeps latent-structure workflows tied to observed matrices, preprocessing, method choice, rank, signal definition, residual review, stability validation, and responsible interpretation.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports latent-structure audits, SVD-based signal extraction, low-rank reconstruction, retained-signal summaries, latent-score tables, residual diagnostics, anomaly-score reports, SQL governance tables, generated outputs, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Latent structure and signal extraction are powerful because they make hidden organization visible. They can simplify high-dimensional data, reveal shared variation, support monitoring, compress information, identify anomalies, and expose residuals. Their limits arise because latent components are inferred through modeling assumptions. They depend on matrix construction, preprocessing, scaling, centering, rank choice, constraints, objective functions, initialization, random seeds, sample composition, and validation choices.

A latent factor is not automatically a cause. A principal component is not automatically a category. A singular direction is not automatically a mechanism. A topic-like factor is not automatically a real topic. A recommender embedding is not automatic preference. A high retained-signal ratio does not guarantee that rare, local, minority, or high-consequence structure was preserved. A residual is not automatically noise. An anomaly is not automatically an error.

Responsible use requires documenting observed data construction, preprocessing, method choice, rank or latent dimension, signal definition, residual diagnostics, anomaly scoring, stability validation, subgroup review, temporal review, and interpretation limits. Latent structure should help reveal hidden patterns without pretending that hidden coordinates are complete system truth.

Back to top ↑

Related Articles

• What Is Linear Algebra for Systems Modeling?
• Dimensionality Reduction Techniques
• Principal Component Analysis
• Singular Value Decomposition
• Orthogonal Decomposition and Structured Approximation
• Compression, Noise, and Informational Tradeoffs
• Machine Learning and Linear Algebra
• Large-Scale Matrix Computation
• Sparse Matrices and Computational Efficiency
• Numerical Stability and Conditioning
• Decomposition Workflows for Systems Analysis
• Scaling, Normalization, and Comparative Structure
• When Linear Models Clarify and When They Distort
• Interpretation, Approximation, and Responsible Mathematical Modeling
• Linear Algebra for Systems Modeling
• Mathematical Modeling
• Systems Modeling
• Algorithms & Computational Reasoning
• Scientific Computing for Systems Modeling

Back to top ↑

Further Reading

• Bishop, C.M. (2006) Pattern Recognition and Machine Learning. New York: Springer. Available at: https://link.springer.com/book/9780387310732.
• Comon, P. (1994) ‘Independent component analysis, a new concept?’, Signal Processing, 36(3), pp. 287–314. Available at: https://doi.org/10.1016/0165-1684(94)90029-9.
• Golub, G.H. and Van Loan, C.F. (2013) Matrix Computations. 4th edn. Baltimore, MD: Johns Hopkins University Press. Available at: https://jhupbooks.press.jhu.edu/title/matrix-computations.
• Hyvärinen, A., Karhunen, J. and Oja, E. (2001) Independent Component Analysis. New York: Wiley. Available at: https://onlinelibrary.wiley.com/doi/book/10.1002/0471221317.
• Jolliffe, I.T. (2002) Principal Component Analysis. 2nd edn. New York: Springer. Available at: https://link.springer.com/book/10.1007/b98835.
• Lee, D.D. and Seung, H.S. (1999) ‘Learning the parts of objects by non-negative matrix factorization’, Nature, 401, pp. 788–791. Available at: https://doi.org/10.1038/44565.
• Lee, D.D. and Seung, H.S. (2001) ‘Algorithms for non-negative matrix factorization’, Advances in Neural Information Processing Systems, 13. Available at: https://proceedings.neurips.cc/paper/2000/hash/f9d1152547c0bde01830b7e8bd60024c-Abstract.html.
• Shlens, J. (2014) ‘A tutorial on principal component analysis’. Available at: https://arxiv.org/abs/1404.1100.
• Tipping, M.E. and Bishop, C.M. (1999) ‘Probabilistic principal component analysis’, Journal of the Royal Statistical Society: Series B, 61(3), pp. 611–622. Available at: https://doi.org/10.1111/1467-9868.00196.
• Trefethen, L.N. and Bau, D. (1997) Numerical Linear Algebra. Philadelphia, PA: SIAM. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898719574.

Back to top ↑

References

• Bishop, C.M. (2006) Pattern Recognition and Machine Learning. New York: Springer. Available at: https://link.springer.com/book/9780387310732.
• Comon, P. (1994) ‘Independent component analysis, a new concept?’, Signal Processing, 36(3), pp. 287–314. Available at: https://doi.org/10.1016/0165-1684(94)90029-9.
• Golub, G.H. and Van Loan, C.F. (2013) Matrix Computations. 4th edn. Baltimore, MD: Johns Hopkins University Press. Available at: https://jhupbooks.press.jhu.edu/title/matrix-computations.
• Hyvärinen, A., Karhunen, J. and Oja, E. (2001) Independent Component Analysis. New York: Wiley. Available at: https://onlinelibrary.wiley.com/doi/book/10.1002/0471221317.
• Jolliffe, I.T. (2002) Principal Component Analysis. 2nd edn. New York: Springer. Available at: https://link.springer.com/book/10.1007/b98835.
• Lee, D.D. and Seung, H.S. (1999) ‘Learning the parts of objects by non-negative matrix factorization’, Nature, 401, pp. 788–791. Available at: https://doi.org/10.1038/44565.
• Lee, D.D. and Seung, H.S. (2001) ‘Algorithms for non-negative matrix factorization’, Advances in Neural Information Processing Systems, 13. Available at: https://proceedings.neurips.cc/paper/2000/hash/f9d1152547c0bde01830b7e8bd60024c-Abstract.html.
• Shlens, J. (2014) ‘A tutorial on principal component analysis’. Available at: https://arxiv.org/abs/1404.1100.
• Tipping, M.E. and Bishop, C.M. (1999) ‘Probabilistic principal component analysis’, Journal of the Royal Statistical Society: Series B, 61(3), pp. 611–622. Available at: https://doi.org/10.1111/1467-9868.00196.
• Trefethen, L.N. and Bau, D. (1997) Numerical Linear Algebra. Philadelphia, PA: SIAM. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898719574.

Back to top ↑