Pith. sign in

REVIEW 3 major objections 7 minor 28 references

Paths explain how deep ReLU networks carve input space and build functions

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · glm-5.2

2026-07-09 21:13 UTC pith:LWVVJA2C

load-bearing objection Geometric theory of deep ReLU networks via paths and piecewise linear manifolds; post-hoc explanation of training solutions is descriptive, not predictive the 3 major comments →

arxiv 2607.07035 v1 pith:LWVVJA2C submitted 2026-07-08 cs.LG cs.AI

On the Principles of Deep Feedforward ReLU Networks

Changcun Huang This is my paper
classification cs.LG cs.AI
keywords deeprelunetworksfeedforwardblacknetworkprinciplestwo-layer
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper argues that the mechanism of deep feedforward ReLU networks can be understood by generalizing principles already established for two-layer ReLU networks. The central object is a path — a chain of activated units from input to output, where each region of the partitioned input space corresponds to exactly one path. Two adjacent regions differ in exactly one unit, and the linear function on one region can be obtained from its neighbor by adding a term proportional to that unit's ReLU output. This recurrence, s_ν(x) = s_{ν-1}(x) + λ_ν σ(w_ν^T x + b_ν), is the same one that governs two-layer networks. What is new in the deep case is that a single hidden unit can produce a piecewise linear manifold — a bent, multi-segment surface — rather than a single flat hyperplane, because units in shallower layers can redirect the normal vector of a knot produced by a deeper unit. The paper shows that the combination of this knot-bending mechanism, multiple strict partial orders over knots, and a continuity-restriction principle (which automatically determines the linear function on a region once its neighbors are known) is sufficient to construct any desired continuous piecewise linear function over any desired partition. The author then demonstrates, on two concrete training solutions obtained by backpropagation, that the learned parameters can be read off and explained by these same principles.

Core claim

The key mechanism is that a path — the unique chain of activated units defining each region of the input-space partition — carries both the partition geometry and the output function simultaneously. Adjacent paths differ in one unit, and the output functions on adjacent regions satisfy the recurrence s_ν(x) = s_{ν-1}(x) + λ_ν σ(w_ν^T x + b_ν). In deep networks, a single unit can generate a piecewise linear manifold rather than a single hyperplane, because shallower-layer units can alter the normal vector of a knot generated by a deeper unit (Theorem 1, Corollary 5). This, combined with multiple strict partial orders of knots and the continuity-restriction principle (Theorem 21), is claimed —

What carries the argument

Path (Definition 2): a subset of units plus their connecting links, uniquely corresponding to one region of the input-space partition. Adjacent paths differ in exactly one unit. The recurrence s_ν(x) = s_{ν-1}(x) + λ_ν σ(w_ν^T x + b_ν) (Theorem 13) links linear functions on adjacent regions. The influence coefficient vector α (Definition 11) = W_{ν+2} W_{ν+3} ... w_{Φ+1} determines whether a unit's output weight can simultaneously produce a desired function increment λ and a desired knot modification β (Theorems 14, 15). The continuity-restriction principle (Theorem 21): if linear functions on two non-parallel boundaries of a region are realized, the function on the region itself is forced.

Load-bearing premise

The framework relies on an unstated-but-assumed structural premise: that when you build a solution piece by piece, each new unit can be added so that the resulting path stays adjacent to the previous one, its influence coefficient vector is nonzero, and previously created knots are not destroyed. The paper acknowledges this is tacitly assumed without proving it holds for arbitrary network configurations or for solutions that gradient descent actually finds.

What would settle it

Find a continuous piecewise linear function and a partition of the input space such that no setting of deep ReLU network parameters can realize both simultaneously under the path-adjacency constraint, or exhibit a training solution from backpropagation whose knot structure and parameter values cannot be decomposed into the recurrence formula, strict partial orders, and continuity-restriction principle described in the paper.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • If the path-based framework is complete, one could manually construct network parameters for a given function or dataset instead of training by gradient descent, yielding interpretable and potentially more parameter-efficient solutions.
  • The piecewise-linear-manifold partitioning mechanism suggests that deeper networks fit data geometry more flexibly than shallow ones not because of raw capacity but because bent decision boundaries track curvature in the data more naturally.
  • The continuity-restriction principle implies that a substantial fraction of linear pieces in a trained network's output are not independently parameterized but are forced by neighboring pieces, which could explain apparent parameter redundancy and over-parameterization effects.
  • The algorithm for drawing knots (Section 8.2) provides a practical tool for visualizing what a trained ReLU network has actually learned, applicable to any input dimensionality.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • If the adjacent-path assumption could be relaxed or proven to hold generically for trained networks, the framework would extend from constructive solutions to analytical characterization of all solutions reachable by gradient descent.
  • The observation that solution complexity is independent of input dimensionality (Section 9.2) suggests that the practical difficulty of training deep networks stems from path-adjacency constraints rather than from the dimensionality of the input space, which would redirect optimization research toward maintaining path adjacency during training.
  • The framework predicts that networks trained on data with piecewise-linear structure should converge faster than those trained on smooth functions, because the partition geometry would align with the data geometry without requiring manifold-bending corrections.
  • The knot-drawing algorithm could be turned into a diagnostic: comparing the knot structure of a trained network against the known geometry of the target function would reveal whether the network has found a natural or degenerate solution.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

3 major / 7 minor

Summary. This paper extends the author's prior work on two-layer ReLU networks (Huang 2024) to deep feedforward ReLU networks with multiple hidden layers. The central conceptual tool is the 'path'—a subset of units activated by a given region of the input space—and the relationships between adjacent paths. The paper develops a framework in which: (1) hidden-layer units produce piecewise linear manifolds (rather than hyperplanes) that partition the input space (Section 2, Theorems 1–2, Corollaries 4–5); (2) continuous piecewise linear functions are constructed via a recurrence formula s_ν(x) = s_{ν-1}(x) + λ_ν σ(w_ν^T x + b_ν) over adjacent regions (Section 3, Theorem 13); (3) the principles of strict partial orders of knots, continuity restriction, and two-sided solutions are generalized from the two-layer case (Sections 3–4, Theorems 21–26, 32). Section 8 provides two examples of trained networks whose knot structures are reverse-engineered using the proposed principles. The paper claims that the combination of these basic principles 'can yield complicated instantiations including the training solutions' obtained by backpropagation.

Significance. The paper tackles an important problem: providing a deductive, mechanistic understanding of deep ReLU networks rather than purely empirical or approximation-theoretic results. The path-based framework and the concept of influence coefficient vectors (Definition 11, Eq. 3.17) offer a useful language for reasoning about how parameters in shallower layers affect both partition geometry and output functions in deeper layers. The observation that a single unit can produce a piecewise linear manifold rather than a single hyperplane (Corollaries 4–5, Theorem 1) is a genuine structural insight. The knot-drawing algorithm (Algorithm 1, Proposition 10–11) is a practical tool. The framework is internally developed with definitions, lemmas, theorems, and corollaries in a systematic manner.

major comments (3)
  1. Section 8, Figures 4–5: The central empirical claim is that the proposed principles 'can yield complicated instantiations including the training solutions' (abstract; Section 8). However, the two examples in Section 8 are purely descriptive: the trained network's knots are drawn via Algorithm 1, and the resulting partition is then annotated with strict partial orders, continuity-restriction arrows, and two-sided solution labels. No actual parameter values are constructed and compared against the trained weights. Since Theorem 10 proves any ReLU network outputs a continuous piecewise linear function, and Theorems 23/32 show the framework can represent any such function over any partition, the framework can always post-hoc describe any training solution. What is missing is either (a) a quantitative comparison between manually constructed parameters and trained parameters, or (b) a falsific
  2. Assumption 1 (Section 4, p. 23): The adjacent-path assumption is described as 'tacitly assumed to be true in section 4' and is required for Theorem 23 (Theorem 32's condition (b) explicitly references it). The assumption bundles three conditions: path adjacency, nonzero influence coefficient vector, and preservation of existing knots during parameter setting. Theorems 6 and 16 provide partial resolutions for the first condition, and Section 3.4 addresses the second, but the third condition (knot preservation) is deferred to 'the methods of section 2.3' and 'concrete examples of section 8.3' without a general guarantee. Since Theorem 23 is load-bearing for Theorem 32 and for the spline-construction framework as a whole, the assumption needs either a theorem showing it is generically satisfiable, or a clear statement of the measure-zero or degenerate conditions under which it fails.
  3. Theorems 24–26 (Section 4): The constructive proofs for two-sided solutions involve cascading parameter resets across layers (e.g., Theorem 24's four-step process, Theorem 25's equation 4.11, Theorem 26's equation 4.13). The feasibility of each step depends on solving systems like Eq. 4.9, 4.11, or 4.13, which require the associated coefficient matrices to have sufficient rank. The proofs state that solutions exist 'provided that' these systems are solvable, but the conditions ensuring solvability (e.g., that the vectors α'_j, α'_{ji}, α'_{j,i-1} in Eq. 4.13 are linearly independent) are not established. This leaves the scope of two-sided solutions unclear: for which network configurations and knot orderings do they actually exist?
minor comments (7)
  1. The paper is almost entirely self-referential for its foundational results: Huang (2024) is cited for definitions 3, 6, 15, 17, 21, 22, lemmas 3, 4, 6, theorems 7, 9, 10, and proposition 2. A reader without access to Huang (2024) will find many proofs and definitions incomplete. At minimum, the key definitions (strict partial order of knots, continuity restriction in the two-layer case) should be briefly restated.
  2. Equation 2.1: The notation N = ∏_{i=1}^Φ m_i 1' uses a prime on the output layer symbol, but the meaning of the prime is only explained in Definition 1 as 'different type of output-layer units.' This is unclear; does it mean linear vs. ReLU? Clarify.
  3. Figure 2: The subfigure captions (a) and (b) reference theorems and corollaries, but the figure labels (K, k1, k2, s2, A, B, etc.) are small and difficult to parse. The dashed knot k'_2 in panel (a) is mentioned in the text but barely visible.
  4. Theorem 6, Eq. 2.21: The argmin notation is unusual—argmin over an intersection of sets defined by inequalities. This should be clarified, perhaps by rewriting as a feasibility condition.
  5. Section 8.3: The notation S^{(k)}_j for tracking solution updates across two-sided operations is introduced informally and becomes hard to follow when multiple orders are updated simultaneously (e.g., 'S^{(5)}_1, S^{(4)}_2, S^{(3)}_3, S^{(2)}_4, S^{(5)}_1' at the end of Section 8.3.2).
  6. Proposition 8 (Section 6.1) and Theorem 30: The 'trivial solution' where all knots are in the last hidden layer is acknowledged as the worst case. It would help to state upfront that the unit count lower bounds (Eqs. 6.3, 6.4, 7.4) are achieved by this trivial solution, so the reader understands these are not tight for non-trivial deep solutions.
  7. Several references have future dates (e.g., Simon et al. 2026, Bengio et al. 2025, Hendrycks 2025). Verify these are correct preprints or forthcoming works.

Circularity Check

0 steps flagged

No significant circularity; self-citations provide foundational lemmas that are genuinely extended, and Section 8 is descriptively weak but not formally circular.

full rationale

The paper's core derivation chain is largely self-contained. The key new results—piecewise linear manifolds (Theorem 1, Corollary 5), the path-based recurrence formula (Theorem 13), adjacent-path conditions (Theorems 8–9), and influence coefficient vectors (Theorems 18–20)—are derived from the network structure directly, not from self-citation. The self-citations to Huang (2024) provide foundational lemmas (lemma 3 for linear-algebra facts about rank-n+1 matrices, lemma 4 for hyperplane construction) that are standard results used as building blocks, and two results are directly imported: Theorem 21 (continuity restriction) explicitly states 'there's no substantial difference between deep and two-layer ReLU networks (Huang (2024)'s theorem 9),' and Theorem 32 condition (3) references 'Huang (2024)'s theorem 7' conditions. However, these are genuine generalizations from two-layer to deep networks, not circular definitions—the deep-network extension requires the new path machinery (Theorems 8–17) that is independently proven here. The Section 8 'explanation' of training solutions is post-hoc and descriptive: since Theorem 10 proves any ReLU output is continuous piecewise linear and Theorems 23/32 prove the framework can represent any such function, showing that specific trained solutions fit the framework is nearly tautological. But the paper does not claim to predict which solutions backpropagation finds; it claims to describe their structure, which is a weakness in falsifiability rather than formal circularity. No step in the derivation chain reduces to its own inputs by construction in the strict sense required for a high circularity score.

Axiom & Free-Parameter Ledger

4 free parameters · 5 axioms · 5 invented entities

The axiom ledger reveals that the framework rests on one ad-hoc assumption (adjacent-path), several domain restrictions (ReLU, [0,1]^n, fully connected), and multiple invented entities (paths, knots, influence vectors, order trees) whose utility is validated only internally. The free parameters are experimental choices, not theoretical constants.

free parameters (4)
  • Network architecture parameters (depth Φ, layer widths m_i) = Φ=3, m_i=6 in experiments
    Chosen by hand for the two experimental examples; not derived from theory.
  • Learning rate c=0.05, iterations N=5000 = c=0.05, N=5000
    Training hyperparameters for the experimental examples, chosen without justification.
  • Discretization step Δx=0.002 for Algorithm 1 = 0.002
    Chosen for knot-drawing algorithm; affects resolution of detected knots.
  • Threshold ε for region adjacency (Theorem 6) = Not specified numerically
    Introduced as a threshold to ensure activation is preserved; value is left unspecified.
axioms (5)
  • ad hoc to paper Adjacent-path assumption (Assumption 1)
    Section 4: 'tacitly assumed to be true' that adjacent paths differ in one unit, influence coefficient vectors are nonzero, and knots are preserved. This is a load-bearing structural premise for Theorems 23 and 32.
  • standard math ReLU activation function σ(x)=max{x,0}
    Standard activation function; defines the network class under study.
  • domain assumption Input space U=[0,1]^n
    Restricts analysis to unit hypercube; standard but limits generality.
  • domain assumption Fully connected feedforward architecture without skip connections
    Definition 1 restricts to fully connected adjacent layers; excludes ResNets and other modern architectures.
  • domain assumption Results from Huang (2024) for two-layer ReLU networks
    Multiple lemmas and theorems (e.g., Huang's lemma 3, lemma 4, theorem 7, theorem 9) are invoked as background; these are from the author's own prior work and are not independently verified here.
invented entities (5)
  • Path (of a deep ReLU network) no independent evidence
    purpose: A subset of units plus their links that are co-activated by a region of input space; central organizing concept.
    The path concept is defined in Definition 2 and used throughout, but it is a theoretical construct whose utility is demonstrated only through the paper's own framework and small-scale experiments.
  • Knot no independent evidence
    purpose: A piece of a hyperplane separating two adjacent regions; generalizes to piecewise linear manifold segments.
    Defined in Definition 5; central to the partition theory but specific to this framework.
  • Influence coefficient vector α no independent evidence
    purpose: Encodes how a unit's output propagates through subsequent layers to affect the final output; determines solution existence.
    Defined in Definition 11; a derived quantity within the framework, not independently observable.
  • Strict partial order of knots no independent evidence
    purpose: Organizes knots into a sequence enabling recursive function construction.
    Defined in Definition 13; borrowed from the author's prior work.
  • Order tree T no independent evidence
    purpose: Organizes multiple strict partial orders into a tree structure for multivariate function construction.
    Introduced in Section 7.1; a structural assumption about how partitions can be organized.

pith-pipeline@v1.1.0-glm · 44534 in / 2458 out tokens · 279718 ms · 2026-07-09T21:13:58.305181+00:00 · methodology

0 comments
read the original abstract

The architecture of deep feedforward neural networks is ubiquitous in deep learning, either as a whole system or as a subnetwork of other architectures, and thus its mechanism is a key ingredient of the black box of neural networks. On the basis of the simplest two-layer ReLU network, this paper systematically studies the mechanism of deep feedforward ReLU networks with multiple hidden layers and successfully explains the training solution obtained by the back-propagation algorithm. The concept of a path, especially in terms of the relationships between paths, plays a central role in uncovering the mystery of the black box. It is shown that a unit of a deep ReLU network can form a piecewise linear manifold to divide the input space, instead of a hyperplane of the two-layer case. How to efficiently use the hidden-layer units to produce both linear functions and partitions of the input space is also a central problem. The principles of a two-layer ReLU network can be generalized to the deeper case to a large extent, such as multiple strict partial orders and continuity restriction. The combination of the basic and simple principles proposed can yield complicated instantiations including the training solutions, and in this sense the black box of deep feedforward ReLU networks is revealed.

Figures

Figures reproduced from arXiv: 2607.07035 by Changcun Huang.

Figure 1
Figure 1. Figure 1: A path of deep neural networks. Especially, the case of one-dimensional output can be written as N = n Y Φ i=1 mi1 ′ . (2.1) Let uij be the jth unit of the ith layer of N. The output of uij can be expressed as σ(wT ijx (i−1) + bij ), where x (i−1) is the input vector of the ith layer for i ≥ 2 and x (0) = x ∈ [0, 1]n . We call wij the input-weight vector of uij and its entries the input weights, and call b… view at source ↗
Figure 2
Figure 2. Figure 2: Knots from the same unit. Theorem 1 (Knots from the same unit-I). Notations being from lemma 1, suppose that the input-dimensionality n ≥ 2. Then if k1 ∩ K = P 6= ∅ (2.10) and λ 6= 0, then K ∩ k1 ∩ k2 = P, (2.11) that is, k2 passes through the intersection of K and k1. And also, k2 ∩ K = P and k1 ∩ k2 = P. Proof. Let x0 ∈ P be a point of P of equation 2.10. Under the notations of lemma 1, equation 2.10 mea… view at source ↗
Figure 3
Figure 3. Figure 3: Modified standard partition via deep networks. [PITH_FULL_IMAGE:figures/full_fig_p036_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Explanation of training solutions-example I. [PITH_FULL_IMAGE:figures/full_fig_p041_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Explanation of training solutions-example II. [PITH_FULL_IMAGE:figures/full_fig_p044_5.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

28 extracted references · 28 canonical work pages · 4 internal anchors

  1. [1]

    Argerich, M. F. & Pati\ n o-Mart\' i nez, M. (2024). Measuring and improving the energy efficiency of large language models inference. IEEE Access, 12, 80194--80207

    work page 2024

  2. [2]

    Bengio Y. (2009). Learning deep architectures for AI. Foundations and Trends in Machine Learning, 2(1), 1--127

    work page 2009

  3. [3]

    Bengio, Y., Mindermann, S., Privitera, D., Besiroglu, T., Bommasani, R., Casper, S., & Zeng, Y. (2025). International ai safety report. arXiv:2501.17805

    work page internal anchor Pith review Pith/arXiv arXiv 2025

  4. [4]

    Bunge, M. (1973). Philosophy of Physics. D. Reidel Publishing Company

    work page 1973

  5. [5]

    Daubechies, I., DeVore, R., Foucart, S., Hanin, B., & Petrova, G. (2022). Nonlinear approximation and (deep) ReLU networks. Constructive Approximation, 55(1), 127-172

    work page 2022

  6. [6]

    DeVore, R., Hanin, B., & Petrova, G. (2021). Neural network approximation. Acta Numerica, 327--444

    work page 2021

  7. [7]

    L., Leung, C

    Du, K. L., Leung, C. S., Mow, W. H., & Swamy, M. N. S. (2022). Perceptron: Learning, generalization, model selection, fault tolerance, and role in the deep learning era. Mathematics, 10(24), p.4730

    work page 2022

  8. [8]

    Erhan, D., Courville, A., Bengio, Y., & Vincent, P. (2010). Why does unsupervised pre-training help deep learning?. In proceedings of the 13th international conference on artificial intelligence and statistics (AISTATS), 201--208

    work page 2010

  9. [9]

    Gauch, H. G. (2003). Scientific method in practice. Cambridge University Press, 269--326

    work page 2003

  10. [10]

    Dynamical variational autoencoders: A comprehensive review

    Girin, L., Leglaive, S., Bie, X., Diard, J., Hueber, T., & Alameda-Pineda, X., (2022). Dynamical variational autoencoders: A comprehensive review. Foundations and Trends in Machine Learning, 15(1-2), 1--175

    work page 2022

  11. [11]

    Glorot, X & Bengio, Y. (2010). Understanding the difficulty of training deep feedforward neural networks. In proceedings of the 13th international conference on artificial intelligence and statistics (AISTATS), 249--256

    work page 2010

  12. [12]

    Guth, F., M\' e nard, B., Rochette, G., & Mallat, S. (2024). A rainbow in deep network black boxes. Journal of Machine Learning Research, 25(350), 1--59

    work page 2024

  13. [13]

    Haykin, S. (2009). Neural networks and learning machines (3rd ed.). Pearson Prentice Hall, 122--221

    work page 2009

  14. [14]

    Hendrycks, D. (2025). Introduction to AI safety, ethics, and society. CRC Press

    work page 2025

  15. [15]

    Huang, C. (2020). ReLU networks are universal approximators via piecewise linear or constant functions. Neural Computation, 32(11), 2249--2278

    work page 2020

  16. [16]

    Huang, C. (2024). On the principles of ReLU networks with one-hidden layer. arXiv:2411.06728

    work page internal anchor Pith review Pith/arXiv arXiv 2024

  17. [17]

    D., Kawaguchi, K., & Karniadakis, G

    Jagtap, A. D., Kawaguchi, K., & Karniadakis, G. E. (2020). Adaptive activation functions accelerate convergence in deep and physics-informed neural networks. Journal of Computational Physics, 404, 109--136

    work page 2020

  18. [18]

    R., Koester, J

    Kandel, E. R., Koester, J. D., Mack, S. H., & Siegelbaum, S. A. (Eds.). (2021). Principles of neural science (6th ed.). New York: McGraw-hill, 84--88

    work page 2021

  19. [19]

    Ramanujan, V., Wortsman, M., Kembhavi, A., Farhadi, A., & Rastegari, M. (2020). What's hidden in a randomly weighted neural network?. In proceedings of the IEEE/CVF conference on computer vision and pattern recognition (CVPR), 11893--11902

    work page 2020

  20. [20]

    Raissi, M., Perdikaris, P., & Karniadakis, G. E. (2019). Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations. Journal of Computational physics, 378, 686--707

    work page 2019

  21. [21]

    E., Hinton, G

    Rumelhart, D. E., Hinton, G. E., & Williams, R. J. (1986). Learning representations by back-propagating errors. Nature, 323, 533--536

    work page 1986

  22. [22]

    Shen, Z., Yang, H., & Zhang, S. (2021). Deep network with approximation error being reciprocal of width to power of square root of depth. Neural Computation, 33(4), 1005--1036

    work page 2021

  23. [23]

    There Will Be a Scientific Theory of Deep Learning

    Simon, J., Kunin, D., Atanasov, A., Boix-Adser\` a , E., Bordelon, B., Cohen, J., Ghosh, N., Guth, F., Jacot, A., Kamb, M., Karkada, D., Michaud, E. J., Ottlik, B., & Turnbull, J. 2026. There will be a scientific theory of deep learning. arXiv:2604.21691

    work page internal anchor Pith review Pith/arXiv arXiv 2026

  24. [24]

    Strubell, E., Ganesh, A., & McCallum, A. (2019). Energy and policy considerations for deep learning in NLP. In proceedings of the 57th annual meeting of the association for computational linguistics, 3645--3650

    work page 2019

  25. [25]

    N., & Kaiser, L

    Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., & Kaiser, L. (2017). Attention is all you need. In proceedings of advances in neural information processing systems (NIPS)

    work page 2017

  26. [26]

    & Zhou, D

    Yang, Y. & Zhou, D. X. (2025). Optimal rates of approximation by shallow ReLU ^k neural networks and applications to nonparametric regression. Constructive Approximation, 62(2), 329--360

    work page 2025

  27. [27]

    Yarotsky, D. (2017). Error bounds for approximations with deep ReLU networks. Neural Networks, 94, 103--114

    work page 2017

  28. [28]

    Understanding deep learning requires rethinking generalization

    Zhang, C., Bengio, S., Hardt, M., Recht, B. & Vinyals, O. (2016). Understanding deep learning requires rethinking generalization. arXiv:1611.03530

    work page internal anchor Pith review Pith/arXiv arXiv 2016