Original: O N A B UILT - IN C ONFLICT BETWEEN D EEP L EARNING AND S YSTEMATIC G ENERALIZATION
Revised: O N A B UILT - IN C ONFLICT BETWEEN D EEP L EARNING AND S YSTEMATIC G ENERALIZATION

Original: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Revised: Out-of-distribution or systematic generalization is a desirable property that most deep learning algorithms lack.

Original: In this paper, we hypothesize that internal function sharing is one of the reasons to weakeno.o.d. or systematic generalization in deep learning for classification tasks.
Revised: In this paper, we hypothesize that internal function sharing is one of the reasons to weaken systematic generalization in deep learning for classification tasks.

Original: Under equivalent prediction, a model partitions an input space into multiple parts separated by boundaries.
Revised: Under equivalent prediction, a model partitions an input space into multiple parts separated by boundaries.

Original: The function sharing prefers to reuse boundaries, leading to fewer parts for new outputs, which conflicts with systematic generalization.
Revised: The function sharing prefers to reuse boundaries, leading to fewer parts for new outputs, which conflicts with systematic generalization.

Original: We show such phenomena in standard deep learning models, such as fully connected, convolutional, residual networks, LSTMs, and (Vision) Transformers.
Revised: We show such phenomena in standard deep learning models, such as fully connected, convolutional, residual networks, LSTMs, and (Vision) Transformers.

Original: We hope this study provides novel insightsinto systematic generalization and forms a basis for new research directions.
Revised: We hope this study provides novel insights and forms a basis for new research directions to improve systematic generalization.

Original: Source codes are available in the supplementary material.
Revised: Source codes are available in the supplementary material.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Revised: [Figure]

Original: A fundamental property of artificial intelligence is generalizations, where a trained model appropriately addresses unseen test samples.
Revised: A fundamental property of artificial intelligence is generalization, where a trained model appropriately processes unseen test samples.

Original: Many problems adopt the i.i.d. assumption.
Revised: Many problems adopt the i.i.d. assumption.

Original: On the other hand,in out-of-distribution (o.o.d.) or systematic generalization (Fodor & Pylyshyn, 1988; Lake & Baroni, 2018), test samples have zero probability in training distribution.
Revised: On the other hand, out-of-distribution (o.o.d.) or systematic generalization (Fodor & Pylyshyn, 1988; Lake & Baroni, 2018) requires that training and test distributions are disjoint so that test samples have zero probability in training distribution.

Original: It is crucial for human learning and provides creation ability.
Revised: Systematic generalization is crucial for human learning and supports efficient data use and creativity.

Original: So machines arealso encouraged to have such ability.
Revised: Therefore, machines are encouraged to acquire such generalization ability to achieve human-like intelligence. Systematic generalization usually requires that a sample has multiple explanatory factors of variation (Bengio et al., 2013), and the generalization is enabled by producing an unseen combination of seen factor values. For example, models trained on blue rectangles and green triangles predict blue triangles. We adopt factors mainly in designing experiments and developing intuitions.

Revised: It helps experiments because new outputs are only related to function sharing between factors (Section 3).

Revised: So we limit our claim to the cases for recombination of factors.

Original: A stream of artificial intelligence has been Connectionism (Feldman & Ballard, 1982; Rumelhart et al., 1986), which uses many simple neuron-like units richly interconnected and processed in parallel.
Revised: One stream of artificial intelligence is Connectionism (Feldman & Ballard, 1982; Rumelhart et al., 1986), which uses many simple neuron-like units richly interconnected and processed in parallel.

Original: It was criticized that Connectionist models do not support systematic generalization well (Fodor & Pylyshyn, 1988; Marcus, 1998).
Revised: It was criticized that Connectionist models do not support systematic generalization well (Fodor & Pylyshyn, 1988; Marcus, 1998).

Original: Deep learning (LeCun et al., 2015) originates from Connectionism, and various techniques have enabled multiple-layer modelings and improved performance on i.i.d.
Revised: Deep learning (LeCun et al., 2015) originates from Connectionism, and various techniques have enabled multiple-layer modelings and improved performance on i.i.d.

Original: problems in recent years.
Revised: problems in recent years.

Original: Also, specific algorithms have been proposed to equip deep learning with systematic generalization ability (Russin et al., 2019; Lake, 2019).
Revised: Also, specific algorithms have been proposed to equip deep learning with systematic generalization ability (Russin et al., 2019; Lake, 2019).

Original: However, less discussion has been made on why standard deep learning models do not achieve systematic generalization.
Revised: However, less discussion has been made on why standard deep learning models do not achieve systematic generalization.

Original: This paper addresses the above question by looking into a build-in characteristic of deep learning.
Revised: -/+ - / - + / + [Figure] -/+ - / - + / + [Figure]

Original: Rich connections allow nodes on a layer to share inputs from nodes on the previous layer.
Revised: /+ - / - + / + [Figure] -/+ - / - + / + [Figure]

Original: Each node  is a function of the network input, so we call it function sharing (not parameter sharing).
Revised: [Figure] This paper addresses the above question by looking into a built-in characteristic of deep learning. A node (or a set of nodes) is a function of the network input. By function sharing , we mean nodes in one layer share inputs from nodes in the previous layer.

Original: We hypothesize that function sharing is one of the reasons to prevent systematic generalization in deep learning.
Revised: We hypothesize that function sharing is one of the reasons to prevent systematic generalization in deep learning.

Original: Under equivalent prediction, a classification network partitions an input space into multiple parts separated by boundaries.
Revised: Under equivalent prediction, a classification network partitions an input space into multiple parts separated by boundaries.

Original: Function sharing prefers to reuse boundaries and avoid redundant ones for train predictions.
Revised: Function sharing prefers to reuse boundaries and avoid redundant ones for training predictions.

Original: It leads to fewer parts for new outputs and weakens systematic generalization.
Revised: It leads to fewer parts for new outputs and weakens systematic generalization.

Original: The nearest neighbor classifier is an analogy for this effect because it predicts a training sample output for any test sample, so it does not have any part for new outputs.
Revised: The nearest neighbor classifier is an analogy for this effect because it predicts a training sample output for any test sample, so it does not have a part for new outputs.

Original: We also discuss that function sharing belongs naturally to deep learning, so it may not be removed without additional design.
Revised: We also discuss that function sharing belongs naturally to deep learning (Section 4).

Original: Systematic generalization usually requires that a sample has multiple explanatory factors of variation (Bengio et al., 2013), and the generalization is enabled by producing an unseen combination of seen factor values.

Original: For example, models trained on blue rectangles and green triangles predict blue triangles.

Original: We adopt factors in designing experiments and developing intuitions.

Original: It helps experiments because new outputs are only related to function sharing between factors (Section 4).

Original: So we limit our claim to the cases for recombination of factors. [Figure] Figure 1 has an intuitive example.
Revised: Figure 2 has an intuitive example explaining why the conflict happens.

Original: A test sample (in orange) equals a set of training samples (+/+) on the first output.
Revised: A test sample (in orange) equals a set of training samples (+/+) on the first output.

Original: Then they are also equal on the second output if the function is reused (see caption).
Revised: Then they are also equal on the second output if the function is reused (see caption).

Original: So they are equal in all the outputs, which conflicts with systematic generalization.
Revised: Therefore, they are equal in all the outputs, which conflicts with systematic generalization.

Original: More generally, the two boundaries jointly partition an input space into multiple parts, and deep learning prefers (a) because it has fewer parts than (b).
Revised: More generally, the two boundaries jointly partition an input space into multiple parts, and deep learning prefers (a) because it has fewer parts than (b).

Original: This paper contributes to uncovering a built-in conflict between deep learning and systematic generalization.
Revised: Figure 3 has a visualized example.

Original: We hope this study provides novel insights, forms a basis for new research directions, and helps improve machine intelligence to the human level.
Revised: It is similar to the example in Figure 2a. The two functions are shared in the top-right region, and few inputs are predicted as the new combination.

Original: We look at the related work and development of systematic generalization and deep learning. We then discuss recent research directions. Systematic generalization and deep learning Systematic generalization 1 is considered the “Great Move” of evolution, caused by the need to process an increasing amount and diversity of environmental information (Newell, 1990).
Revised: Figure 1 has a simplified plot for a result in the experiment section.

Original: Cognitive scientists see it as central for an organism to view the world (Gallistel & King, 2011).

Original: Studies indicate it is related to the prefrontal cortex (Robin & Holyoak, 1995). It was discussed that commonsense is critical (Mccarthy, 1959; Lenat et al., 1986) for systematic generalization, and recent works aim to find general prior knowledge (Goyal & Bengio, 2020), e.g., Consciousness Prior (Bengio, 2017). Levels of systematicity were defined (Hadley, 1992; Niklasson & van Gelder, 1994), and types of tests were summarized (Hupkes et al., 2020).
Revised: As the degree of function sharing increases (more sharing layers), the accuracy of the test dataset or generalization capacity decreases accordingly.

Original: We focus on the primary case with an unseen combination of seen factor values.

Original: A closely related field is causal learning, rooted in the eighteenth-century (Hume, 2003) and classical fields of AI (Pearl, 2003).

Original: It was mainly explored from statistical perspectives (Pearl, 2009; Peters et al., 2016; Greenland et al., 1999; Pearl, 2018) with do-calculus (Pearl, 1995; 2009) and interventions (Peters et al., 2016). The causation forms Independent Causal Mechanisms (ICMs) (Peters et al., 2017; Sch¨olkopf et al., 2021). Systematic generalization is the counterfactual when the joint input distribution is intervened to have new values with zero probability in training (covariate shift). This work indicates that standard neural networks do not prefer to learn ICMs.
Revised: It support that function sharing weakens systematic generalization.

Original: Parallel Distributed Processing (PDP) models (Rumelhart et al., 1986) use Connectionist models with distributed representations, which describe an object in terms of a set of factors. Though they have the potential to combine the factors to create unseen object representations (Hinton, 1990), it was criticized that they do not address systematic generalization in general (Fodor & Pylyshyn, 1988; Marcus, 1998). Deep learning is a recent PDP model with many achievements (LeCun et al., 2015; He et al., 2016a).
Revised: Please refer to Section 3 for more details.

Original: It was studied that deep neural networks use the composition of functions to achieve high performance (Montufar et al., 2014).

Original: The improvements in i.i.d. problems encourage to equip deep learning with systematic generalization.
Revised: This paper contributes to uncovering a built-in conflict between deep learning and systematic generalization.

Original: Recent directions Other than architecture design (Russin et al., 2019; Andreas et al., 2016) and data augmentation (Andreas, 2020;

Original: Aky¨urek et al., 2021), Perspectives for systematic generalization approaches include disentangled representation learning, attention mechanism, and meta-learning.

Original: Disentangled representation (Bengio et al., 2013) is learned in unsupervised manners.

Original: Early methods learn the representation from statistical independence (Higgins et al., 2017; Locatello et al., 2019).

Original: Later, the definition of disentangled representation was proposed with symmetry transformation (Higgins et al., 2018).

Original: It leads to Symmetry-based Disentangled Representation Learning (Caselles-Dupr´e et al., 2019;

Original: Painter et al., 2020; Pfau et al., 2020). A disentangled representation learning model can be used as a feature extractor for other systematic generalization tasks. Attention mechanisms are widely used in neural networks (Bahdanau et al., 2015). Transformers (Vaswani et al., 2017) are modern neural network architectures with self-attention.
Revised: We hope this study provides novel insights, forms a basis for new research directions, and helps improve machine intelligence to the human level.

Original: Recurrent

Original: Independent Mechanisms (Goyal et al., 2021b) use attention and the name of the incoming nodes for variable binding.

Original: Global workspace (Goyal et al., 2021a) improves them by using limited-capacity global communication to enable the exchangeability of knowledge.

Original: Discrete-valued communication bottleneck (Liu et al., 2021) further enhances systematic generalization ability.

Original: Meta-learning (Lake, 2019) usually designs a series of training tasks for learning a meta-learner and uses it in a target task.

Original: Each task has training and test data, where test data requires systematic generalization from training data.

Original: When ICMs are available, they can be used to generate meta-learning tasks (Sch ¨ olkopf et al., 2021).

Original: Meta-reinforcement learning was used for causal reasoning (Dasgupta et al., 2019).

Original: Meta-learning can also capture the adaptation speed to discover causal relations (Bengio et al., 2020; Ke et al., 2019).

Original: Deep learning is a fast-growing field, and many efforts focus on designing architectures and algorithms to improve its performance.

Original: However, it is less discussed why standard deep learning models do not achieve systematic generalization.

Original: We look into a build-in conflict.

Original:  A B UILT - IN C ONFLICT
Revised:  A B UILT - IN C ONFLICT

Original: We hypothesize a built-in conflict between the function sharing in deep learning and systematic generalization.
Revised: We hypothesize a built-in conflict between the function sharing in deep learning and systematic generalization.

Original: We first consider the requirements from visualized examples.

Original: Wethen cover the definition, assumptions, and derivations of the conflict.
Revised: We cover the definition, assumptions, and derivations of the conflict.

Original: 3. V ISUALIZED EXAMPLES AND REQUIREMENTS

Original: Figure 2 has visualized examples.

Original: Case (a) is similar to the illustration example (Figure 1).

Original: The two functions are shared in the top-right region.

Original: We may infer that function sharing prefers to merge two regions if it keeps the training loss.

Original: In case (b) result figure, the top-right region is merged with the training region on the bottom-left.

Original: In case (c) second output, the blue training region in the upper half and a small blue region in the middle-lower part have the same value in both the first and the second outputs.

Original: They are disconnected in the input space and may be adjacent in a hidden layer.

Original: Case (d) shows that new output combinations are avoided before the model is trained well.

Original: The above cases encourage assumptions independent of the distribution geometry, and we should also consider the training process.

Original: Note that (a) (b) and (c) (d) have different data distributions to show diverse phenomena.

Original: Please refer to Appendix B.1 for settings and Appendix D.5 for more examples.

Original: 3. S YSTEMATIC GENERALIZATION
Revised: 2. S YSTEMATIC GENERALIZATION

Original: We have input set X and output set Y .
Revised: We have input set X and output set Y .

Original: Y contains K factors Y 1 , . . .
Revised: Y contains K factors Y 1 , . . .

Original: , Y K , which may be entangled.
Revised: , Y K , which can be entangled.

Original: The training set D train has input X train and output Y train .
Revised: The training set D train has input X train and output Y train .

Original: The test set D test has input X test and output
Revised: The test set D test has input X test and output

Original: Y test .
Revised: Y test .

Original: In systematic generalization, Y train and Y test are disjoint.
Revised: In systematic generalization, Y train and Y test are disjoint.

Original: However, the values for each factor i are included in the training output.
Revised: However, the values for each factor i are included in the training output.

Original: A model f maps input X to the prediction of output f ( X ) .
Revised: A model f maps input X to the prediction of output f ( X ) .

Original: A model enables systematic generalization if it correctly predicts the ground-truth test outputs.
Revised: A model enables systematic generalization if it correctly predicts the ground-truth test outputs.

Original: [Figure]

Original: Definition 1 (Systematic generalization) .
Revised: Definition 1 (Systematic generalization) .

Original: The dataset requires that any test label is not a training label, but each factor of a test label is seen in a training label.
Revised: The dataset requires that any test label is not a training label, but each factor of a test label is seen in a training label.

Original: [Equation]
Revised: [Equation]

Original: A function f enables systematic generalization
Revised: A function f enables systematic generalization

Original: if ∀ ( x, y ) ∈ D test : y = f
Revised: if ∀ ( x, y ) ∈ D test : y = f

Original: ( x ) .
Revised: ( x ) .

Original: When the model is well trained, we assume it correctly predicts training samples.
Revised: When the model is well trained, we assume it correctly predicts training samples.

Original: Assumption 1 (Correct training prediction) .
Revised: Assumption 1 (Correct training prediction) .

Original: ∀ ( x, y ) ∈
Revised: ∀ ( x, y ) ∈

Original: D train : y = f
Revised: D train : y = f

Original: ( x ) .
Revised: ( x ) .

Original: 3. F UNCTION SHARING
Revised: 2. F UNCTION SHARING

Original: We assume a property of function sharing (intuition in Figure 1).
Revised: In Figure 2, deep learning prefers the model in (a) over the model in (b). We denote the models as f and g , respectively.

Original: Function sharing prefers to merge two regions to reuse functions and avoid learning redundant functions with the same effect on training data.
Revised: We see that g has one more region for the new factor combination between the magenta and cyan boundaries. This region exists because the magenta boundary in g splits the +/+ region in f into two parts. It means the partition under g refines that under f , but not vice versa. We assume a property of function sharing.

Original: It means, for models f and g , deep learning more or equally prefers f over g if the partition under g is a refinement of that under f .
Revised: For general models f and g , deep learning more or equally prefers f over g if the partition under g is a refinement of that under f .

Original: Equivalently, if two inputs have an identical prediction in g , their predictions are still equal in f .
Revised: Equivalently, if two inputs have an identical prediction in g , their predictions are still equal in f .

Original: It means an equal prediction in g implies that in f .
Revised: It means an equal prediction in g implies that in f .

Original: Assumption 2 (Function sharing) .
Revised: Assumption 2 (Function sharing) .

Original: Deep learning more or equally prefers f over g if
Revised: Deep learning more or equally prefers f over g if

Original: [Equation]
Revised: [Equation]

Original: It is a bias in the learning process other than training loss.
Revised: Note that it is a bias in the learning process.

Original: Note that the function sharing does not depend on the geometry of distributions.
Revised: In case we need f to be strictly more preferred over g , we can additionally show that identical prediction in f does not imply that in g .

Original: We consider what causes the function sharing.
Revised: We consider what causes the function sharing.

Original: Intuitively, the preference comes from greedy optimization and the task requirement to learn a complicated model.
Revised: Intuitively, the preference comes from greedy optimization and the task requirement to learn a complicated model.

Original: A model learns to split or partition inputs by different predictions.
Revised: A model learns to split or partition inputs by different predictions.

Original: Some splits (can be a factor) might be easier to learn than others.
Revised: Some splits (can be a factor) might be easier to learn than others.

Original: For example, learning to split inputs by color is more straightforward than by shape.
Revised: For example, learning to split inputs by color is more straightforward than by shape.

Original: Then the greedy optimization learns it quickly and reuses its intermediate functions to learn other splits.
Revised: Then the greedy optimization learns it quickly and reuses its intermediate functions to learn other splits.

Original: It is not likely that multiple splits (or factors) are learned equally fast during the whole training process.
Revised: It is not likely that multiple splits (or factors) are learned equally fast during the whole training process.

Original: In analogy, the mechanism of reusing function is similar to auxiliary tasks.
Revised: The mechanism of reusing function is similar to auxiliary tasks.

Original: The parameters are updated to address a complicated main task while quickly learning and keeping the prediction ability for more straightforward auxiliary tasks.
Revised: The parameters are updated to address a complicated main task while quickly learning and keeping the prediction ability for more straightforward auxiliary tasks.

Original: A more frequent but less similar example is pre-training.
Revised: A more common but less similar example is pre-training.

Original: Pre-trained modules, such as image feature extractors or word embeddings, share the internal functions with the main target tasks.
Revised: Pretrained modules, such as image feature extractors or word embeddings, share the internal functions with the main target tasks.

Original: However, the pre-training and the main task training do not happen simultaneously.
Revised: However, the pre-training and the main task training do not happen simultaneously.

Original: We will discuss more insights in Section 5.
Revised: We will discuss more insights in Section 4.

Original: 3. T HE CONFLICT
Revised: 2. T HE CONFLICT

Original: We derive propositions for proving the theorem and explaining the reasons for the phenomena.
Revised: We derive propositions for proving the theorem and explaining the reasons for the phenomena.

Original: In practice, the assumptions may not hold strictly, and the effects come more from the soft biases of the conclusions.
Revised: In practice, the assumptions may not hold strictly, and the effects come more from the soft biases of the conclusions.

Original: The proofs are in Appendix A.
Revised: The proofs are in Appendix A.

Original: Assumption 2 leads a model to predict training outputs for any input.
Revised: Assumption 2 leads a model to predict training outputs for any input.

Original: Proposition 1 (Seen prediction) .
Revised: Proposition 1 (Seen prediction) .

Original: From Assumption 2, ∀ x ∈ X : f ( x ) ∈ f
Revised: From Assumption 2, ∀ x ∈ X : f ( x ) ∈ f

Original: ( X train ) .
Revised: ( X train ) .

Original: Informally, if f ( x ) ̸∈ f ( X train ) , the function f has to differentiate this input x from training inputs.
Revised: Informally, suppose there is a non-empty set of all inputs that a function f does not map to training outputs f ( X train ) .

Original: However, we can design another function f ′ that predicts a training output for the input and keeps predictions for other inputs.
Revised: In that case, we can design another function f ′ that predicts a training output for these inputs and keeps predictions for other inputs.

Original: Then both f and f ′ equivalently distinguish training outputs.
Revised: Then both f and f ′ equivalently distinguish training outputs.

Original: With Assumption 2, f ′ is preferred, hence ∀ x ∈ X : f ( x ) ∈ f
Revised: With Assumption 2, f ′ is preferred, hence ∀ x ∈ X : f ( x ) ∈ f

Original: ( X train ) .
Revised: ( X train ) .

Original: It does not apply Assumption 1, indicating that the phenomena may happen before a model is well trained (Figure 2d).
Revised: It does not apply Assumption 1, indicating that the phenomena may happen before a model is well trained.

Original: If a model works well for the training set, it predicts training ground-truth output for any input.
Revised: If a model performs well for the training set, it predicts training ground-truth output for any input.

Original: Proposition 2 (Seen label) .
Revised: Proposition 2 (Seen label) .

Original: From Assumption 1 and Proposition 1, ∀ x ∈ X : f ( x ) ∈ Y train .
Revised: From Assumption 1 and Proposition 1, ∀ x ∈ X : f ( x ) ∈ Y train .

Original: It says that the prediction is not any new output.
Revised: It says that the prediction is not any new output.

Original: It is a stronger argument than avoiding a particular new output for each input in systematic generalization.
Revised: It is a stronger argument than avoiding a particular new output for each input in systematic generalization.

Original: It explains that prediction is incorrect because any new output is resisted.
Revised: It explains that prediction is incorrect because any new output is resisted.

Original: We evaluate it in Section 4.
Revised: We evaluate it in Section 3.

Original: We then look at the conflict.
Revised: We then look at the conflict.

Original: For any test data ( x, y ) , the definition of systematic generalization requires that the output y is not a training output Y train .
Revised: For any test sample ( x, y ) , the definition of systematic generalization requires that the output y is not a training output Y train .

Original: However, this contradicts Proposition 2.
Revised: However, this contradicts Proposition 2.

Original: Theorem 1 (The conflict) .
Revised: Theorem 1 (The conflict) .

Original: From Definition 1 and Proposition 2, ∀ ( x
Revised: From Definition 1 and Proposition 2, ∀ ( x

Original: , y ) ∈ D test : y ̸
Revised: , y ) ∈ D test : y ̸

Original: = f ( x ) .
Revised: = f ( x ) .

Original: We covered systematic generalization definition and function sharing assumption.
Revised: We covered systematic generalization definition and function sharing assumption.

Original: We then derived propositions and a theorem of the conflict.
Revised: We then derived propositions and a theorem of the conflict.

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: We run experiments to show that function sharing reduces the ability of systematic generalization in deep learning.
Revised: We run experiments to show that function sharing reduces the ability of systematic generalization in deep learning.

Original: We not only compare sharing or not but also adjust the degree of sharing.
Revised: We not only compare sharing or not but also adjust the degree of sharing.

Original: We focus on the cases where new outputs are unseen combinations of seen factor values.
Revised: We focus on the cases where new outputs are unseen combinations of seen factor values.

Original: We cover different standard deep neural network models.
Revised: We cover different standard deep neural network models.

Original: The details of networks and experiments can be found in
Revised: The details of networks and experiments can be found in

Original: Appendix B. The results of zero-shot learning datasets are in Appendix C, where factors are mainly related to the input locality.
Revised: Appendix B. The results of zero-shot learning datasets are in Appendix C, where factors are mainly related to the input locality.

Original: We look at the experiment settings and results.
Revised: We look at the experiment settings and results.

Original: 4. S ETTINGS
Revised: 3. S ETTINGS

Original: Data preparation We construct a dataset from two ten-class classification datasets.
Revised: Data preparation We construct a dataset from two ten-class classification datasets.

Original: The training data are generated from the original training dataset.
Revised: The training data are generated from the original training dataset.

Original: Y 1 is chosen from all possible labels.
Revised: Y 1 is chosen from all possible labels.

Original: Yis chosen from five classes { Y 1 , Y 1 + 1 , . . .
Revised: Yis chosen from five classes { Y 1 , Y 1 + 1 , . . .

Original: , Y 1 + 4 } (we use modular for labels).
Revised: , Y 1 + 4 } (we use modular for labels).

Original: The test data are generated from the original test dataset.
Revised: The test data are generated from the original test dataset.

Original: Y 1 is chosen in the same way as in training.
Revised: Y 1 is chosen in the same way as in training.

Original: Y 2 is chosen from the other classes { Y 1 + 5 , Y 1 + 6 , . . .
Revised: Y 2 is chosen from the other classes { Y 1 + 5 , Y 1 + 6 , . . .

Original: , Y 1 + 9 } .
Revised: , Y 1 + 9 } .

Original: In this design, training and test label combinations are mutually exclusive, but test labels for each output factor are seen in training.
Revised: In this design, training and test label combinations are mutually exclusive, but test labels for each output factor are seen in training.

Original: Any factor label appears evenly in training and test combinations.
Revised: Any factor label appears evenly in training and test combinations.

Original: X 1 and X 2 are chosen conditioned on their labels Y 1 , Y 2 , respectively, and merged as the input X .
Revised: X 1 and X 2 are chosen conditioned on their labels Y 1 , Y 2 , respectively, and merged as the input X .

Original: The original datasets and input merge methods vary for each experiment.
Revised: The original datasets and input merge methods vary for each experiment.

Original: All the choices follow uniform distributions.
Revised: All the choices follow uniform distributions.

Original: Model architecture To evaluate the influence of function sharing on new outputs, welike to change the function sharing ability while keeping other properties stable for a deep learning model.
Revised: To evaluate the influence of function sharing on new outputs, we change the function sharing ability while keeping other properties stable for a deep learning model.

Original: So we modify function sharing related to new outputs.
Revised: So we modify function sharing related to new outputs.

Original: Since a new output appears only as a new factor combination in our setting, we adjust the sharings between output factors.
Revised: Since a new output appears only as a new factor combination in our setting, we adjust the sharings between output factors.

Original: It does not need to remove all sharings and avoid difficulties in model design.
Revised: It does not need to remove all sharings and avoid difficulties in model design.

Original: We choose a layer and duplicate the following layers, keeping the number of all hidden nodes in each layer if feasible (Figure 3).
Revised: We choose a layer and duplicate the following layers, keeping the number of all hidden nodes in each layer if feasible (Figure 4).

Original: We call the former part a shared network and the latter parts individual networks.
Revised: We call the former part a shared network and the latter parts individual networks.

Original: Each individual network predicts one output factor, so the output is disentangled.
Revised: Each individual network predicts one output factor, so the output is disentangled.

Original: We will discuss entangled outputs in Section 5.
Revised: We will discuss entangled outputs in Section 4.

Original: We keep the depth of the whole network and change the depth of the shared network and individual networks.
Revised: We keep the depth of the whole network and change the depth of the shared network and individual networks.

Original: Note that only sharing the input layer indicates learning two separate models.[Equation]
Revised: Note that only sharing the input layer indicates learning two separate models.

Original: Evaluation metrics We use accuracy as the metric.
Revised: Evaluation metrics We use accuracy as the metric.

Original: A sample prediction is correct if all the outputs are correct.
Revised: A sample prediction is correct if all the outputs are correct.

Original: We have three types of accuracy.
Revised: We have three types of accuracy.

Original: The first is the regular evaluation of test data for systematic generalization (a: Test Sample Accuracy ) corresponding to Theorem 1.
Revised: The first is the regular evaluation of test data for systematic generalization (a: Test Sample Accuracy ) corresponding to Theorem 1.

Original: We also consider a set of inputs mapped to unseen output combinations corresponding to Proposition 2. 
Revised: We also consider a set of inputs mapped to unseen output combinations corresponding to Proposition 2. We

Revised: [Figure]

Original: We evaluate whether the test samples predict one of the unseen output factor combinations (b: Test Set
Revised: evaluate whether the test samples predict one of the unseen output factor combinations (b Test Set

Original: Accuracy ).
Revised: Accuracy ).

Original: However, test samples are only a subset of input space.
Revised: However, test samples are only a subset of input space.

Original: If a model learns a different set of factors, the expected inputs may not be those of test samples.
Revised: If a model learns a different set of factors, the expected inputs may not be those of test samples.

Original: So we also evaluate systematic generalization as a model property for any valid input.
Revised: So we also evaluate systematic generalization as a model property for any valid input.

Original: We randomly draw test inputs from the whole input space (c: Random Set Accuracy ) 2 .
Revised: We randomly draw test inputs from the whole input space (c

Original: We run each experiment five times and plot the mean and the standard deviation (Figure 4).
Revised: Random run each experiment five times and plot the mean and the standard deviation (Figure 5).

Original: Please also refer to the result numbers  in Table 1 (Appendix B.3).
Revised: The numbers are in Table 1 (Appendix B

Original: [Equation]
Revised: [Equation]

Original: )] c : E x ∼ U

Original: [ X ] [ δ ( f ( x ) ∈ Y test )]

Original: 4. R ESULTS
Revised: 3. R ESULTS

Original: Fully Connected Network We use an eight-layer fully connected neural network with a flattened image input.
Revised: Fully Connected Network We use an eight-layer fully connected neural network with a flattened image input.

Original: We use the Fashion dataset (Xiao et al., 2017) and the MNIST dataset (LeCun et al., 1998).
Revised: We use the Fashion dataset (Xiao et al., 2017) and the MNIST dataset (LeCun et al., 1998).

Original: The datasets are uncomplicated to avoid the training data under-fitting for a fully connected neural network.
Revised: The datasets are uncomplicated to avoid the training data under-fitting for a fully connected neural network.

Original: We merge the two inputs by averaging values at each input node.
Revised: We merge the two inputs by averaging values at each input node.

Original: Convolutional Network
Revised: Convolutional Network

Original: We use a convolutional neural network with six convolutional layers and two fully connected layers.
Revised: We use a convolutional neural network with six convolutional layers and two fully connected layers.

Original: We use the CIFAR-10 dataset (Krizhevsky, 2009) and the Fashion dataset (Xiao et al., 2017).
Revised: We use the CIFAR-10 dataset (Krizhevsky, 2009) and the Fashion dataset (Xiao et al., 2017).

Original: We scale the input sizes to that of the larger one and broadcast gray images to colored ones.
Revised: We scale the input sizes to that of the larger one and broadcast gray images to colored ones.

Original: We merge the inputs by averaging at each node.
Revised: We merge the inputs by averaging at each node.

Original: We use the Fashion dataset as one factor because the average of two colored images can cause training data under-fitting for convolutional neural networks.
Revised: We use the Fashion dataset as one factor because the average of two colored images can cause training data under-fitting for convolutional neural networks.

Original: Residual Network We use ResNet50 (He et al., 2016b), which has five stages, each treated as a layer while changing the shared network depth.
Revised: Residual Network We use ResNet50 (He et al., 2016), which has five stages, each treated as a layer while changing the shared network depth.

Original: It has the dataset setting in the CNN experiment.
Revised: It has the dataset setting in the CNN experiment.

Original: Vision Transformer
Revised: Vision Transformer

Original: We use Vision Transformer (Dosovitskiy et al., 2021) with one fully connected layer for each patch, five attention layers, and two fully connected layers.
Revised: We use Vision Transformer (Dosovitskiy et al., 2021) with one fully connected layer for each patch, five attention layers, and two fully connected layers.

Original: We treat the patches as one layer.
Revised: We treat the patches as one layer.

Original: It has the dataset setting in the CNN experiment.
Revised: It has the dataset setting in the CNN experiment.

Original: LSTM A recurrent network has the same parameters for each layer, so it does not support learning different individual networks.
Revised: LSTM A recurrent network has the same parameters for each layer, so it does not support learning different individual networks.

Original: Instead, we treat an LSTM as a layer.
Revised: Instead, we treat an LSTM as a layer.

Original: We use stacked LSTM models with an embedding layer, five bidirectional LSTM layers, and two fully connected layers.
Revised: We use stacked LSTM models with an embedding layer, five bidirectional LSTM layers, and two fully connected layers.

Original: We use the Reuters dataset (Joachims, 1998) for both the first and the second datasets.
Revised: We use the Reuters dataset (Joachims, 1998) for both the first and the second datasets.

Original: We filter samples by a maximum input length of 200 and use the most frequent ten classes of samples.
Revised: We filter samples by a maximum input length of 200 and use the most frequent ten classes of samples.

Original: We merge inputs by concatenating two input texts.
Revised: We merge inputs by concatenating two input texts.

Original: The inputs have different lengths because the text lengths vary.
Revised: The inputs have different lengths because the text lengths vary.

Original: We also run experiments for one-layer LSTM, which compares sharing or not sharing all layers.
Revised: We also run experiments for one-layer LSTM, which compares sharing or not sharing all layers.

Original: The results indicate that the shared network has less generalization than the individual network (Table 1).
Revised: The results indicate that the shared network has less generalization than the individual network (Table 1).

Original: Transformer We use Transformer (Vaswani et al., 2017).
Revised: Transformer We use Transformer (Vaswani et al., 2017).

Original: Since it is a classification problem, we only use the encoder.
Revised: Since it is a classification problem, we only use the encoder.

Original: It has one embedding layer, five hidden layers, and two fully connected layers.
Revised: It has one embedding layer, five hidden layers, and two fully connected layers.

Original: We use the same dataset setting as the LSTM experiment.
Revised: We use the same dataset setting as the LSTM experiment.

Original: Summary of results Figure 4 shows that, for each evaluation, the accuracy on the left end (not sharing any hidden layer) is higher than that on the right end (sharing all hidden layers), and it generally decreases as the shared network depth increases.
Revised: Summary of results Figure 5 shows that, for each evaluation, the accuracy on the left end (not sharing any hidden layer) is higher than that on the right end (sharing all hidden layers), and it generally decreases as the shared network depth increases.

Original: The results indicate that the function sharing weakens systematic generalization. 
Revised: The results indicate that the function sharing weakens systematic generalization. [Figure] [Figure] [Figure]

Revised: [Figure]

Original: D ISCUSSIONS
Revised: [Figure] (sub)network depths. As the shared network depth increases, the accuracy generally decreases, indicating that function sharing reduces systematic generalization ability. Test Set Accuracy and

Revised: Random Set Accuracy are the ratios of unseen factor combinations in prediction.

Revised: Test Sample

Revised: Accuracy and Test Set Accuracy are computed with the test data, and Random Set Accuracy is with randomly generated inputs.

Original: Entangled output Though the theory does not require disentangled output, the experiments use it to split the network into individual ones.
Revised: Though the theory does not require disentangled output, the experiments use it to split the network into individual ones.

Original: We discuss that entangled output prediction is not easier than disentangled one.
Revised: We discuss that entangled output prediction is not easier than disentangled one.

Original: Hence the experiment conclusions will likely extend to entangled outputs.
Revised: Hence the experiment conclusions will likely extend to entangled outputs.

Original: (1) Disentangled output is a particular and usually less complicated case of entangled output.
Revised: (1) Disentangled output is a particular and usually less complicated case of entangled output.

Original: Entangled output can be seen as another shared layer, and the experiments show that increasing shared layers reduces systematic generalization ability, so entangled outputs are also likely to suffer from the problem.
Revised: Entangled output can be seen as another shared layer, and the experiments show that increasing shared layers reduces systematic generalization ability, so entangled outputs are also likely to suffer from the problem.

Original: (3) We can see each output node of an entangled output as a factor, so it becomes disentangled output.
Revised: We can see each output node of an entangled output as a factor, so it becomes disentangled output.

Original: The generalization is even more difficult if a value is unseen for an output node.
Revised: The generalization is even more difficult if a value is unseen for an output node.

Original: Beyond factor recombination
Revised: 4. B EYOND FACTOR RECOMBINATION

Original: The definition of systematic generalization (Definition 1) requires that each test label factor is seen in a training label.
Revised: The definition of systematic generalization (Definition 1) requires that each test label factor is seen in a training label.

Original: However, it is not directly used in the derivations, and the conclusions may apply to more general o.o.d.
Revised: However, it is not directly used in the derivations, and the conclusions may apply to more general o.o.d.

Original: problems other than recombining factors.
Revised: problems beyond recombining factors.

Original: A new output may correspond to an unseen activation for an output node, e.g., a new class in a classification problem.
Revised: A new output may correspond to an unseen activation for an output node, e.g., a new class in a classification problem.

Original: In such settings, it is sometimes discussed that the bias parameter of the output is a reason to avoid the new value prediction because it does not have any training signal to increase its value.
Revised: In such settings, it is sometimes discussed that the bias parameter of the output is a reason to avoid the new value prediction because it does not have any training signal to increase its value.

Original: This work provides another reason for not predicting a new value.
Revised: This work provides another reason for not predicting a new value.

Original: Why does function sharing happen?
Revised: 4. W HY DOES FUNCTION SHARING HAPPEN IN DEEP LEARNING ?

Original: We discuss that function sharing can be caused by characteristics of deep learning: deep architecture, shareable network, and greedy optimization.
Revised: We discuss that function sharing can be caused by characteristics of deep learning: deep architecture, shareable network, and greedy optimization.

Original: Deep architecture and shareable networks make it possible for factors to share elaborated functions, and greedy optimization encourages the sharing.
Revised: Deep architecture and shareable networks make it possible for factors to share elaborated functions, and greedy optimization encourages the sharing.

Original: Deep architecture and greedy search are necessary for deep learning.
Revised: Deep architecture and greedy search are necessary for deep learning.

Original: Deep learning uses deep architecture to fit complicated non-linear functions.
Revised: Deep learning uses deep architecture to fit complicated non-linear functions.

Original: Deep learning has a large and complex parameter space.
Revised: Deep learning has a large and complex parameter space.

Original: To search in it, we need some prioritization, which leads to a greedy search.
Revised: To search in it, we need some prioritization, which leads to a greedy search.

Original: It might be gradient descent and its variants or other methods such as evolutionary computation.

Original: The shareable network is widely used in standard deep learning models and works well for i.i.d.
Revised: The shareable network is widely used in standard deep learning models and works well for i.i.d.

Original: problems.
Revised: problems.

Original: However, it is less critical compared to the other ones.
Revised: However, it is less critical compared to the other ones.

Original: Potential solutions We consider possible solutions to avoid function sharing and achieve systematic generalization.
Revised: We consider possible solutions to avoid function sharing and achieve systematic generalization.

Original: From the above discussion,deep architecture and greedy optimization are essential for deep learning, so we look at shareable networks.
Revised: From the above discussion, we look at shareable networks.

Original: We consider the recombination of factors and focus on sharing between factors.
Revised: We consider the recombination of factors and focus on sharing between factors.

Original: Then, one potential solution uses individual networks for output factors, similar to the experiment setup.
Revised: Then, one potential solution uses individual networks for output factors, similar to the experiment setup.

Original: We discuss how to design networks when the input or the output is entangled.
Revised: We discuss how to design networks when the input or the output is entangled.

Original: If the output is entangled, we can design an architecture where each individual network only changes one factor in the output.
Revised: If the output is entangled, we can design an architecture where each individual network only changes one factor in the output.

Original: For example, one individual network changes color, and another changes shape.
Revised: For example, one individual network changes color, and another changes shape.

Original: If the input is entangled, we need to extract factors from it to feed the individual networks.
Revised: If the input is entangled, we need to extract factors from it to feed the individual networks.

Original: It contains two questions: how to avoid spurious influence from other factors and keep it working in test distribution.
Revised: It contains two questions: how to avoid spurious influence from other factors and keep it working in test distribution.

Original: We can bottleneck representations for the first one and divide the input into units invariant in training and test for the other, e.g., words or objects.
Revised: We can bottleneck representations for the first one and divide the input into units invariant in training and test for the other, e.g., words or objects.

Original: [Figure] [Figure]
Revised: Systematic generalization and deep learning Systematic generalization 2 (Fodor & Pylyshyn, 1988; Lake & Baroni, 2018; Bahdanau et al., 2019) is considered the “Great Move” of evolution, caused by the need to process an increasing amount and diversity of environmental information (Newell, 1990). Cognitive scientists see it as central for an organism to view the world (Gallistel & King, 2011).

Original: [Figure]
Revised: Studies indicate it is related to the prefrontal cortex (Robin & Holyoak, 1995).

Original: [Figure]
Revised: It was discussed that commonsense is critical (Mccarthy, 1959; Lenat et al., 1986) for systematic generalization, and recent works aim to find general prior knowledge (Goyal & Bengio, 2020), e.g., Consciousness Prior (Bengio, 2017). Levels of systematicity were defined (Hadley, 1992; Niklasson & van Gelder, 1994), and types of tests were summarized (Hupkes et al., 2020). We focus on the primary case with an unseen combination of seen factor values.

Original: [Figure]
Revised: A closely related field is causal learning, rooted in the eighteenth-century (Hume, 2003) and classical fields of AI (Pearl, 2003). It was mainly explored from statistical perspectives (Pearl, 2009; Peters et al., 2016; Greenland et al., 1999; Pearl, 2018) with do-calculus (Pearl, 1995; 2009) and interventions (Peters et al., 2016). The causation forms Independent Causal Mechanisms (ICMs) (Peters et al., 2017; Sch¨olkopf et al., 2021). Systematic generalization is the counterfactual when the joint input distribution is intervened to have new values with zero probability in training (covariate shift).

Original: [Figure]
Revised: This work indicates that standard neural networks do not prefer to learn ICMs. Parallel Distributed Processing (PDP) models (Rumelhart et al., 1986) use Connectionist models with distributed representations, which describe an object in terms of a set of factors. Though they have the potential to combine the factors to create unseen object representations (Hinton, 1990), it was criticized that they do not address systematic generalization in general (Fodor & Pylyshyn, 1988; Marcus, 1998). Deep learning is a recent PDP model with many achievements (LeCun et al., 2015; He et al., 2016).

Original: [Figure]
Revised: It was studied that deep neural networks use the composition of functions to achieve high performance (Montufar et al., 2014). The improvements in i.i.d.

Original: [Figure] [Figure] Test Sample Acc. Test Set Acc.
Revised: problems encourage to equip deep learning with systematic generalization.

Original: Rnd.
Revised: Recent directions In addition to architecture design (Russin et al., 2019; Andreas et al., 2016) and data augmentation (Andreas, 2020; Aky ¨ urek et al., 2021; Jia & Liang, 2016), the main perspectives for systematic generalization approaches include disentangled representation learning, attention mechanism, and Disentangled representation (Bengio et al., 2013) is learned in unsupervised manners. Early methods learn the representation from statistical independence (Higgins et al., 2017; Locatello et al., 2019).

Original: Set Acc. [Figure] 23- 45- 67-0 Shared-Individual Network Depths
Revised: Later, the definition of disentangled representation was proposed with symmetry transformation (Higgins et al., 2018). It leads to Symmetry-based Disentangled Representation Learning (Caselles-Dupr ´ e et al., 2019;

Original: [Figure] [Figure] [Figure]
Revised: Painter et al., 2020; Pfau et al., 2020).

Original: 12- 34- 56- 7-0 Shared-Individual Network Depths
Revised: A disentangled representation learning model can be used as a feature extractor for other systematic generalization tasks. Attention mechanisms are widely used in neural networks (Bahdanau et al., 2015). Transformers (Vaswani et al., 2017) are modern neural network architectures with self-attention.

Original: [Figure] cc
Revised: Recurrent

Original: [Figure] Vision Transformer [Figure] [Figure]
Revised: Independent Mechanisms (Goyal et al., 2021b) use attention and the name of the incoming nodes for variable binding.

Original: [Figure]
Revised: Global workspace (Goyal et al., 2021a) improves them by using limited-capacity global communication to enable the exchangeability of knowledge.

Original: [Figure]
Revised: Discrete-valued communication bottleneck (Liu et al., 2021) further enhances systematic generalization ability.

Original: [Figure] [Figure]
Revised: Meta-learning (Lake, 2019) usually designs a series of training tasks for learning a meta-learner and uses it in a target task.

Original: [Figure] [Figure]
Revised: Each task has training and test data, where test data requires systematic generalization from training data.

Original: [Figure]
Revised: When ICMs are available, they can be used to generate meta-learning tasks (Sch ¨ olkopf et al., 2021).

Original: [Figure] [Figure] [Figure]
Revised: Meta-reinforcement learning was used for causal reasoning (Dasgupta et al., 2019). Meta-learning can also capture the adaptation speed to discover causal relations (Bengio et al., 2020; Ke et al., 2019).

Original: [Figure] [Figure] -Individual Network Depths
Revised: Deep learning is a fast-growing field, and many efforts focus on designing architectures and algorithms to improve its performance. However, it is less discussed why standard deep learning models do not achieve systematic generalization.

Original: [Figure]
Revised: This paper looks into a built-in conflict.

Original:  C ONCLUSIONS
Revised:  C ONCLUSION

Original: This paper investigates a built-in conflict between deep learning and systematic generalization.
Revised: This paper investigates a built-in conflict between deep learning and systematic generalization.

Original: It explains one of the reasons why standard neural networks seldom achieve systematic generalization.
Revised: It explains one of the reasons why standard neural networks seldom achieve systematic generalization.

Original: We discuss that the conflict is caused by sharingof internal functions.
Revised: We hypothesize that the conflict is caused by sharing internal functions, and experiments support it.

Original: A model partitions an input space into multiple parts separated by boundaries.
Revised: A model partitions an input space into multiple parts separated by boundaries.

Original: The function sharing tends to reuse the boundaries, leading to fewer parts for new outputs, which conflicts with systematic generalization.
Revised: The function sharing tends to reuse the boundaries, leading to fewer parts for new outputs, which conflicts with systematic generalization.

Original: Theexperiments show the phenomena  in differenttypes of standard  neural network models.
Revised: The phenomena are shown in different standard deep neural networks.

Original: We hope this finding provides a new understanding of systematic generalization mechanisms  and helps to improve machine learning algorithms for a higher level of artificial intelligence.
Revised: We hope this finding provides a new understanding of systematic generalization mechanisms in deep learning and helps to improve machine learning algorithms for a higher level of artificial intelligence.

Original: A P ROOFS
Revised: A P ROOFS

Original: Proposition 1 (Seen prediction) .
Revised: Proposition 1 (Seen prediction) .

Original: From Assumption 2, ∀ x ∈ X : f ( x ) ∈ f
Revised: From Assumption 2, ∀ x ∈ X : f ( x ) ∈ f

Original: ( X train ) .
Revised: ( X train ) .

Original: Proof.
Revised: Proof.

Revised: We are going to prove that for a function g with at least one input mapped to a new output, there exists a more preferred function f with all inputs mapped to seen outputs.

Revised: Therefore, if a function does not have other functions more preferred over it, the function follows the proposition.

Original: Given a function g , we construct a function f .
Revised: Given a function g , we construct a function f .

Original: We pick a x ′ ∈ X train .
Revised: We pick a x ′ ∈ X train .

Original: ∀ x ∈ X : g ( x ) ∈ g ( X train ) :
Revised: ∀ x ∈ X : g ( x ) ∈ g ( X train ) :

Original: f ( x ) =
Revised: f ( x ) =

Original: g ( x ) , o.w. :
Revised: g ( x ) , o.w. :

Original: f ( x ) = f
Revised: f ( x ) = f

Original: ( x ′ ) .
Revised: ( x ′ ) .

Original: We look at the conditions.

Original:  ∀ x a , x b ∈ X :
Revised: Then, ∀ x a , x b ∈ X :

Original: [Equation]
Revised: [Equation]

Revised: : g ( x

Revised: [Equation]

Revised: =

Revised: g ( x b ) =

Revised: ⇒ f

Revised: ( x a ) =

Revised: g ( x a ) =

Revised: g

Revised: [Equation]

Revised: x b ) =

Revised: f

Revised: ( x b )

Revised: [Equation]

Revised: [Equation]

Revised: x

Revised: [Equation]

Revised: x

Revised: [Equation]

Revised: In both cases,

Revised: [Equation]

Original: On the other hand,
Revised: On the other hand,

Original: [Equation]
Revised: [Equation]

Original: So f ( x ) =
Revised: So f ( x ) =

Original: f
Revised: f

Original: ( x ′ ) does not imply g ( x )
Revised: ( x ′ ) does not imply g ( x )

Original: =
Revised: =

Original: g ( x ′ ) .
Revised: g ( x ′ ) .

Original: With Assumption 2, f is preferred over g .
Revised: With Assumption 2, f is preferred over g .

Original: It follows that ∀ x ∈ X :
Revised: Also, ∀ x ∈ X :

Original: [Equation]
Revised: [Equation]

Original: Therefore, ∀ x ∈ X : f ( x ) ∈ f
Revised: Therefore, ∀ x ∈ X : f ( x ) ∈ f

Original: ( X train ) .
Revised: ( X train ) .

Original: Proposition 2 (Seen label) .
Revised: Proposition 2 (Seen label) .

Original: From Assumption 1 and Proposition 1, ∀ x ∈ X : f ( x ) ∈ Y train .
Revised: From Assumption 1 and Proposition 1, ∀ x ∈ X : f ( x ) ∈ Y train .

Original: Proof.
Revised: Proof.

Original: From Assumption 1, f ( X train ) =
Revised: From Assumption 1, f ( X train ) =

Original: Y train .
Revised: Y train .

Original: From Proposition 1, 
Revised: From Proposition 1, ∀ x ∈ X : f ( x ) ∈ f

Original: [Equation]
Revised: ( X train ) =

Revised: Y train

Original: Theorem 1 (The conflict) .
Revised: Theorem 1 (The conflict) .

Original: From Definition 1 and Proposition 2, ∀ ( x
Revised: From Definition 1 and Proposition 2, ∀ ( x

Original: , y ) ∈ D test : y ̸
Revised: , y ) ∈ D test : y ̸

Original: = f ( x ) .
Revised: = f ( x ) .

Original: Proof.
Revised: Proof.

Original: ∀ ( x, y ) ∈
Revised: ∀ ( x, y ) ∈

Original: D test : y ̸∈ Y train (Definition 1), x ∈ X test ⊆
Revised: D test : y ̸∈ Y train (Definition 1), x ∈ X test ⊆

Original: X =
Revised: X =

Original: ⇒ f
Revised: ⇒ f

Original: ( x ) ∈ Y train (Proposition 2).
Revised: ( x ) ∈ Y train (Proposition 2).

Original: Therefore y ̸
Revised: Therefore y ̸

Original: = f ( x ) .
Revised: = f ( x ) .

Original: B E XPERIMENT D ETAILS B. V ISUALIZATION SETTINGS
Revised: B E XPERIMENT D ETAILS B. V ISUALIZATION SETTINGS

Original: The model is a fully connected neural network with two input and two output nodes.
Revised: The model is a fully connected neural network with two input and two output nodes.

Original: It has six hidden layers with ReLU activations, and each hidden layer has eight nodes.
Revised: It has six hidden layers with ReLU activations, and each hidden layer has eight nodes.

Original: We use a mini-batch size of 10 with a learning rate of 0.01.
Revised: We use a mini-batch size of 10 with a learning rate of 0.01.

Original: We iterate until the model prediction becomes stable.
Revised: We iterate until the model prediction becomes stable.

Original: Please see the original work  for more information.
Revised: Please see the original work of deep playground for more information.

Original: We use six Intel(R) Core(TM) i5-8400 2.80GHz CPUs, and the asset has a public license.
Revised: We use six Intel(R) Core(TM) i5-8400 2.80GHz CPUs, and the asset has a public license.

Original: B. E XPERIMENT SETTINGS
Revised: B. E XPERIMENT SETTINGS

Original: We use GeForce GTX 1080 or GeForce GTX 

Revised: We use GeForce GTX 1080 or GeForce GTX

Original: Ti GPU for single GPU experiments.
Revised: Ti GPU for single GPU experiments.

Original: We use
Revised: We use

Original: TensorFlow for implementation.
Revised: TensorFlow for implementation.

Original: The assets have a public license.
Revised: The assets have a public license.

Original: Each input element is linearly scaled to [-0.5, 0.5] for image input.
Revised: Each input element is linearly scaled to [-0.5, 0.5] for image input.

Original: We also uniformly sample from this interval for random image input.
Revised: We also uniformly sample from this interval for random image input.

Original: We select two sentence lengths uniformly from valid integers (one to maximum length) and then generate each word uniformly from the vocabulary for random text input.
Revised: We select two sentence lengths uniformly from valid integers (one to maximum length) and then generate each word uniformly from the vocabulary for random text input.

Original: Fully Connected Network
Revised: Fully Connected Network

Original: The input shape is 28 × 28, flattened to a vector.
Revised: The input shape is 28 × 28, flattened to a vector.

Original: There are seven fully connected layers.
Revised: There are seven fully connected layers.

Original: Each of them has 512 hidden nodes and ReLU activation.
Revised: Each of them has 512 hidden nodes and ReLU activation.

Original: The output has ten nodes and Softmax activation.
Revised: The output has ten nodes and Softmax activation.

Original: We use cross-entropy loss and Adam optimizer with a learning rate of 0.001.
Revised: We use cross-entropy loss and Adam optimizer with a learning rate of 0.001.

Original: The batch size is 512, and we train 2,000 iterations.
Revised: The batch size is 512, and we train 2,000 iterations.

Original: Each evaluation uses 10,000 samples.
Revised: Each evaluation uses 10,000 samples.

Original: Convolutional Network
Revised: Convolutional Network

Original: The input shape is 32 × 32 × 3.
Revised: The input shape is 32 × 32 × 3.

Original: There are seven convolutional layers.
Revised: There are seven convolutional layers.

Original: Each of them has 3 × 3 kernel size with 64 channels.
Revised: Each of them has 3 × 3 kernel size with 64 channels.

Original: Then the layer is flattened.
Revised: Then the layer is flattened.

Original: We have a fully connected layer with 128 nodes and ReLU activation.
Revised: We have a fully connected layer with 128 nodes and ReLU activation.

Original: The output layer has ten nodes with Softmax activation.
Revised: The output layer has ten nodes with Softmax activation.

Original: We use cross-entropy loss and Adam optimizer with a learning rate of 0.001.
Revised: We use cross-entropy loss and Adam optimizer with a learning rate of 0.001.

Original: The batch size is 512, and we train 5,000 iterations.
Revised: The batch size is 512, and we train 5,000 iterations.

Original: Each evaluation uses 10,000 samples.
Revised: Each evaluation uses 10,000 samples.

Original: Residual Network
Revised: Residual Network

Original: The input is the same as CNN.
Revised: The input is the same as CNN.

Original: The model is the standard ResNet50 implementation.
Revised: The model is the standard ResNet50 implementation.

Original: The hidden groups are treated as one layer, so there are five hidden layers.
Revised: The hidden groups are treated as one layer, so there are five hidden layers.

Original: The hidden layer size is 64.
Revised: The hidden layer size is 64.

Original: The output layer has ten nodes with Softmax activation.
Revised: The output layer has ten nodes with Softmax activation.

Original: We use cross-entropy loss and
Revised: We use cross-entropy loss and

Original: Adam optimizer with a learning rate of 0.001.
Revised: Adam optimizer with a learning rate of 0.001.

Original: The batch size is 512, and we train 10,000 iterations.
Revised: The batch size is 512, and we train 10,000 iterations.

Original: Each evaluation uses 10,000 samples.
Revised: Each evaluation uses 10,000 samples.

Original: Vision Transformer
Revised: Vision Transformer

Original: The input is the same as CNN.
Revised: The input is the same as CNN.

Original: The model is the standard Vision Transformer implementation with seven hidden layers.
Revised: The model is the standard Vision Transformer implementation with seven hidden layers.

Original: The hidden layer size is 64.
Revised: The hidden layer size is 64.

Original: The output layer has ten nodes with Softmax activation.
Revised: The output layer has ten nodes with Softmax activation.

Original: We use cross-entropy loss and Adam optimizer with a learning rate of 0.001.
Revised: We use cross-entropy loss and Adam optimizer with a learning rate of 0.001.

Original: The batch size is 512, and we train 10,000 iterations.
Revised: The batch size is 512, and we train 10,000 iterations.

Original: Each evaluation uses 10,000 samples.
Revised: Each evaluation uses 10,000 samples.

Original: LSTM
Revised: LSTM

Original: The vocabulary size is 30,977, including a start symbol and padding symbol.
Revised: The vocabulary size is 30,977, including a start symbol and padding symbol.

Original: The input length is 200.
Revised: The input length is 200.

Original: The embedding size is 64.
Revised: The embedding size is 64.

Original: There are seven stacked bidirectional LSTM layers, and each has 32 hidden nodes for each direction.
Revised: There are seven stacked bidirectional LSTM layers, and each has 32 hidden nodes for each direction.

Original: Then the output is flattened.
Revised: Then the output is flattened.

Original: The output layer is a fully-connected layer with ten output nodes and Softmax activation.
Revised: The output layer is a fully-connected layer with ten output nodes and Softmax activation.

Original: We use cross-entropy loss and
Revised: We use cross-entropy loss and

Original: Adam optimizer with a learning rate of 0.001.
Revised: Adam optimizer with a learning rate of 0.001.

Original: The batch size is 64, and we train 1,000 iterations.
Revised: The batch size is 64, and we train 1,000 iterations.

Original: Each evaluation uses 10,000 samples.
Revised: Each evaluation uses 10,000 samples.

Original: Transformer The input is the same as that of LSTM.
Revised: Transformer The input is the same as that of LSTM.

Original: The embedding size is 64.
Revised: The embedding size is 64.

Original: There are seven hidden groups.
Revised: There are seven hidden groups.

Original: The hidden layer size is 64.
Revised: The hidden layer size is 64.

Original: The output is flattened.
Revised: The output is flattened.

Original: The output layer is a fullyconnected layer with ten output nodes and Softmax activation.
Revised: The output layer is a fullyconnected layer with ten output nodes and Softmax activation.

Original: We use cross-entropy loss and Adam optimizer with a learning rate of 0.001.
Revised: We use cross-entropy loss and Adam optimizer with a learning rate of 0.001.

Original: The batch size is 64, and we train 2,000 iterations.
Revised: The batch size is 64, and we train 2,000 iterations.

Original: Each evaluation uses 10,000 samples.
Revised: Each evaluation uses 10,000 samples.

Original: B. E XPERIMENT RESULTS
Revised: B. E XPERIMENT RESULTS

Original: We numerically compare the individual (left ends in result figures, 0-max) and shared (right ends, max-0) networks in Table 1.
Revised: We numerically compare the individual (left ends in result figures, 0-max) and shared (right ends, max-0) networks in Table 1.

Original: LSTM is the stacked LSTM, and LSTM-1 has only one LSTM layer.
Revised: LSTM is the stacked LSTM, and LSTM-1 has only one LSTM layer.

Original: It shows that shared network has lower scores than individual network on the three types of accuracy.
Revised: It shows that shared network has lower scores than individual network on the three types of accuracy.

Original: So it indicates that  sharingnetwork avoids systematic generalization
Revised: So it indicates that function sharing avoids systematic generalization.

Original: [Table]

Original: [Table]
Revised: [Table]

Original: C Z ERO -S HOT L EARNING D ATASETS
Revised: C Z ERO -S HOT L EARNING D ATASETS

Original: We look at the results for Zero-shot learning.
Revised: We look at the results for Zero-shot learning.

Original: We use aPY (Farhadi et al., 2009), AwA2 (Xian et al., 2019), CUB (Wah et al., 2011), and SUN (Patterson & Hays, 2012) datasets.
Revised: We use aPY (Farhadi et al., 2009), AwA2 (Xian et al., 2019), CUB (Wah et al., 2011), and SUN (Patterson & Hays, 2012) datasets.

Original: In these datasets, factors are mainly related to the input locality (Sylvain et al., 2020).
Revised: In these datasets, factors are mainly related to the input locality (Sylvain et al., 2020).

Original: We use the pre-extracted input features for aPY and AwA and image input for CUB and SUN.
Revised: We use the pre-extracted input features for aPY and AwA and image input for CUB and SUN.

Original: We use the most balanced attributes in all  the data with a relative ratio of 0.5, three for each output.
Revised: We construct output labels from attributes. Each attribute is a binary number, 1 for existing in a sample and 0 otherwise. We select six attributes with the most balanced average number (close to 0.5) in all data. The first, third, and fifth attributes are used for the first output, and the others for the second output.

Original: So there are eight output nodes for each of the two outputs.
Revised: Each output has eight classes yielded from all the combinations of three binary attributes.

Original: For aPY, samples may share the same image, so we construct training data from the original training and test data from the original test data.
Revised: For aPY, samples may share the same image, so we construct training data from the original training and test data from the original test data.

Original: For other datasets, we separate all the data.
Revised: For other datasets, we split all data to disjoint training and test data.

Original: We use an eight-layer CNN model, the same as in the experiment section.
Revised: We use an eight-layer CNN model, the same as in the experiment section.

Original: The batch size is 512 for aPY and AwA and 256 for CUB and SUN.
Revised: The batch size isfor aPY and AwA and 256 for CUB and SUN.

Original: Other settings are the same as that in the experiment section.
Revised: Other settings are the same as that in the experiment section.

Original: The result is shown in Figure 5 and Table 4.
Revised: The result is shown in Figure 6 and Table 3.

Original: Similar to the previous experiments, the depths of shared and individual networks influence systematic generalization.
Revised: Similar to the previous experiments, the depths of shared and individual networks reduce systematic generalization capability.

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: 12- 34- 56- 7-0 Shared-Individual Network Depths

Original: [Figure]
Revised: [Figure]

Original: [Figure][Figure] [Figure] [Figure]
Revised: [Figure]

Original: -Individual Network Depths

Original: [Figure][Figure]
Revised: [Figure]

Original: 12- 34- 56- 7-0 Shared-Individual Network Depths

Original: [Figure][Figure]
Revised: [Figure]

Original: Test Set Accuracy

Original: Random Set Accuracy Individual Shared Individual
Revised: [Figure]

Original: Shared

Original: Individual Shared aPY 2.5 ± 0. 0.6 ± 0. 22.4 ± 2.
Revised: [Figure]

Original: 5.9 ± 1.

Original: [Table]
Revised: [Table]

Original: D M ORE D ISCUSSIONS D. T RAINING PROCESS
Revised: D M ORE D ISCUSSIONS D. T RAINING PROCESS

Original: We discussed that sharing boundaries reduces the number of partitions and shrinks the area for new outputs (Proposition 1).
Revised: We discussed that sharing boundaries reduces the number of partitions and shrinks the area for new outputs (Proposition 1).

Original: We run experiments to find when this happens during training.
Revised: We run experiments to find when this happens during training.

Original: We sample 10,000 inputs from test data [Table] and if an output combination has at least 50 samples, we regard it as a new output (o[Table]
Revised: We sample 10,000 inputs from test data, and if an output combination has at least 50 samples, we regard it as a new output (o

Original: o

Original: [Table]
Revised: [Figure]

Original: d.) partition.
Revised: o.d.) partition.

Original: We plot the number of o
Revised: We plot the number of o

Original: [Table]
Revised: [Figure]

Original: o [Table] d. partitions and the test sample ratio in the o
Revised: o.d. partitions and the test sample ratio in the o.o.d.

Original: [Table]

Original: o.d. partitions for shared and individual networks in Figure 6.
Revised: partitions for shared and individual networks in Figure 7.

Original: The experiment settings follow
Revised: The experiment settings follow

Original: DNN and CNN settings in the experiment section.
Revised: DNN and CNN settings in the experiment section.

Original: The results show that the differences start to happen in early training.
Revised: The results show that the differences start to happen in early training

Original: [Figure]
Revised: [Figure]

Original: D. N EW CLASSES

Original: In the experiment section, a new output is the recombination of seen factors.

Original: It is also available to design experiments for new classes without factor combinations.

Original: However, it might be less attractive because tasks usually do not expect a model to predict a new class unrelated to seen classes.

Original: Also, the model design needs to meet some requirements.

Original: We look at ten-class classification problems.

Original: We use the first five classes in the training and the remaining five classes in the test.

Original: For a fully connected network, we use the Fashion dataset.

Original: For a convolutional neural network, we use the CIFAR-10 dataset.

Original: The networks do not have biases.

Original: There are ten pieces of individual networks for a model.

Original: We use binary cross-entropy for each output node and sum them as the loss.

Original: Other architecture settings are the same as those in the experiment section.

Original: The results are in Table 3.

Original: The individual network has non-zero random set accuracy, which means the input space has elements mapped to new outputs.

Original: The shared network does not have such inputs.

Original: It indicates that the sharing of functions discourages predicting the new output.

Original: [Table]

Original: D. I LLUSTRATIVE EXAMPLES

Original: We have mainly used examples for two factors.

Original: Figure 7 is an illustration of K > 2 factors.

Original: [Figure]

Original: D. E XAMPLES IN OTHER CONDITIONS

Original: We focus on solving complicated non-linear problems with deep learning models.

Original: Figure 8 shows examples not in such condition.

Original: One example (a) is a shallow network.

Original: Another example (b) has a linear problem, and the model design matches it.

Original: [Figure]

Original: D. M ORE VISUALIZED EXAMPLES

Original: We look at the visualized example.

Original: We use a more complicated example than the one in the previous section.

Original: The first output is spiral, and the second output is XOR.

Original: The result shows that all three accuracies tend to drop as the shared network depth increases.

Original: The result is in Figure 9.

Original: D. E QUALLY DIFFICULT FACTORS
Revised: D. E QUALLY DIFFICULT FACTORS

Original: We look at the results when two inputs are equally hard to learn.
Revised: We look at the results when two inputs are equally hard to learn.

Original: We use two CIFAR-10 datasets for both the first and the second datasets.
Revised: We use two CIFAR-10 datasets for both the first and the second datasets.

Original: Since it is too hard to learn added samples, we merge the samples by concatenating them by channel.
Revised: Since the average of two colored images can cause training data under-fitting, we merge the inputs by concatenating them by channel.

Original: It means the input channel is six.
Revised: It means the input channel is six.

Original: The result is shown in Figure 10 and Table 4.
Revised: The result is shown in Figure 8 and Table 3.

Original: Similar to the previous experiments, when the difficulties are equal, the depth of the shared network influences systematic generalization.
Revised: Similar to the previous experiments, when the difficulties are equal, the depth of the shared network weakens systematic generalization

Original: [Table] [Figure]
Revised: [Table] [Table]

Original: [Figure]
Revised: [Figure]

Original: D. L ABEL COMBINATIONS
Revised: D. L ABEL COMBINATIONS

Original: We also test other training label distribution types.
Revised: We also test other training label distribution types.

Original: We design tile and one-label combinations.
Revised: We design tile and one-shot combinations.

Original: In tile, a label combination is for training when Y 1 < 5 or Y 2 < 5 .
Revised: In tile, a label combination is for training when Y 1 < 5 or Y 2 < 5 .

Original: It is similar to the split for illustrative example.
Revised: It is similar to the split for illustrative example.

Original: In One-label, a label combination is for training when Y 1 < 9 or Y 2 < 1 .
Revised: In One-shot, a label combination is for training when Y 1 < 9 or Y 2 < 1 .

Original: In such a case, only (9 , 0) contains Y 2 = 0 .
Revised: In such a case, only (9 , 0) contains Y 2 = 0 .

Original: It is similar tothe case of one-shot learning.
Revised: It is similar to one-shot learning.

Original: The results for the feed- forward neural network are in Figure 11 and Table 5.
Revised: The results for the fully connected neural network are in Figure 9 and Table 4.

Original: It is similar to the results in the experiment section.
Revised: It is similar to the results in the experiment section

Original: [Figure]
Revised: [Figure]

Original: A cc u r a c y ( % )

Original: [Figure] [Table]
Revised: [Table]