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

Original: Out-of-distribution or systematic generalization is a desirable property that most deep learning algorithms lack.
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 weaken 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 insights and forms a basis for new research directions to improve systematic generalization.
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

Original: [Figure]
Revised: [Figure]

Original: A fundamental property of artificial intelligence is generalization, where a trained model appropriately processes 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, 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.
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: Systematic generalization is crucial for human learning and supports efficient data use and creativity.
Revised: Systematic generalization is crucial for human learning and supports efficient data use and creativity.

Original: Therefore, machines are encouraged to acquire such generalization ability to achieve human-like intelligence.
Revised: Therefore, machines are encouraged to acquire such generalization ability to achieve human-like intelligence.

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.
Revised: 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.
Revised: For example, models trained on blue rectangles and green triangles predict blue triangles.

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

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

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

Original: 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.
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 &
Revised: It was criticized that Connectionist models do not support systematic generalization well (Fodor &

Original: Pylyshyn, 1988; Marcus, 1998).
Revised: 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: -/+ - / - + / +
Revised: -/+ - / - + / +

Original: [Figure]
Revised: [Figure]

Original: -/+ - / - + / +
Revised: -/+ - / - + / +

Original: [Figure]
Revised: [Figure]

Original: /+ - / - + / +
Revised: /+ - / - + / +

Original: [Figure]
Revised: [Figure]

Original: -/+ - / - + / +
Revised: -/+ - / - + / +

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

Original: This paper addresses the above question by looking into a built-in characteristic of deep learning.
Revised: This paper addresses the above question by looking into a built-in characteristic of deep learning.

Original: A node (or a set of nodes) is a function of the network input.
Revised: A node (or a set of nodes) is a function of the network input.

Original: By function sharing , we mean nodes in one layer share inputs from nodes in the previous layer.
Revised: By function sharing , we mean nodes in one layer share inputs from nodes in the previous layer.

Revised: It may also be called activation sharing or feature sharing.

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 training 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 a 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 (Section 4).
Revised: We also discuss that function sharing belongs naturally to deep learning (Section 4).

Original: Figure 2 has an intuitive example explaining why the conflict happens.
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: Therefore, 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: Figure 3 has a visualized example.
Revised: Figure 3 has a visualized example.

Original: It is similar to the example in Figure 2a.
Revised: It is similar to the example in Figure 2a.

Original: The two functions are shared in the top-right region, and few inputs are predicted as the new combination.
Revised: The two functions are shared in the top-right region, and few inputs are predicted as the new combination.

Original: Figure 1 has a simplified plot for a result in the experiment section.
Revised: Figure 1 has a simplified plot for a result in the experiment section.

Original: As the degree of function sharing increases (more sharing layers), the accuracy of the test dataset or generalization capacity decreases accordingly.
Revised: As the degree of function sharing increases (more sharing layers), the accuracy of the test dataset or generalization capacity decreases accordingly.

Original: It support that function sharing weakens systematic generalization.
Revised: It supports that function sharing weakens systematic generalization.

Original: Please refer to Section 3 for more details.
Revised: Please refer to Section 3 for more details.

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

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: We hope this study provides novel insights, forms a basis for new research directions, and helps improve machine intelligence to the human level.

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 cover the definition, assumptions, and derivations of the conflict.
Revised: We cover the definition, assumptions, and derivations of the conflict.

Original: 2. 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 is decided by K factors Y 1 , . . .

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

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 Y test .
Revised: The test set D test has input X test and output 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: 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: Assumption1 (Correct training prediction) . ∀ ( x, y ) ∈ D train : y = f
Revised: Assumption

Original: ( x ) .
Revised: [Equation]

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

Original: In Figure 2, deep learning prefers the model in (a) over the model in (b).
Revised: In Figure 2, deep learning prefers the model in (a) over the model in (b).

Original: We denote the models as f and g , respectively.
Revised: We denote the models as f and g (mapping from input to output), respectively.

Original: We see that g has one more region for the new factor combination between the magenta and cyan boundaries.
Revised: We see that g has one more region for the new factor combination between the magenta and cyan boundaries.

Original: This region exists because the magenta boundary in g splits the +/+ region in f into two parts.
Revised: This region exists because the magenta boundary in g splits the +/+ region in f into two parts.

Original: It means the partition under g refines that under f , but not vice versa.
Revised: It means the partition under g refines that under f , but not vice versa.

Original: We assume a property of function sharing.
Revised: We assume a property of function sharing.

Original: For general models f and g , deep learningmore 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 prefers f over g more or equally 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 learningmore or equally prefers f over g  if
Revised: Deep learning prefers f over g more or equally if

Original: [Equation]
Revised: [Equation]

Original: Note that it is a bias in the learning process.
Revised: Note that it is a bias in the learning process.

Original: 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 .
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: 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 common but less similar example is pre-training.
Revised: A more common but less similar example is pre-training.

Original: Pretrained 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 4.
Revised: We will discuss more insights in Section 4 and Appendix C.

Original: 2. 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 B.

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, suppose there is a non-empty set of all inputs that a function f does not map to training outputs f
Revised: Informally, suppose there is a non-empty set of all inputs that a function f does not map to training outputs f

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

Original: In that case, we can design another function f ′ that predicts a training output for these inputs 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.
Revised: It does not apply Assumption 1, indicating that the phenomena may happen before a model is well trained.

Original: If a model performs 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 3.
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 sample ( 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 D. More experiments with natural inputs are in Appendix A. The results of zero-shot learning datasets are in Appendix E, 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: 3. 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.

Revised: We first chose output y and chose x based on it.

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: y 2 is 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: xand 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: Architecture
Revised: Architecture

Original: 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.
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 4).
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 4.
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.
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 [Figure] 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.We
Revised: We also consider a set of inputs mapped to unseen output combinations corresponding to Proposition 2.

Original: [Figure]

Original:  evaluate whether the test samples predict one of the unseen output factor combinations (b Test Set
Revised: We 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 asa model property for any valid input.
Revised: So we also evaluate systematic generalization as property for the

Original: We randomly draw test inputs from the whole input space (c Random run each experiment five times and plot the mean and the standard deviation (Figure 5).
Revised: Figure 5)

Original: The numbers are in Table 1 (Appendix B
Revised: Table 2 ( [Equation]

Original: [Equation]
Revised: [Equation]

Original: 3.  R ESULTS
Revised:  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., 2016), 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 2).

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 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.
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.

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

Original: [Figure]
Revised: [Figure]

Revised: Test Set Acc.

Original: [Figure]
Revised: Rnd.

Revised: Set Acc.

Original: [Figure]
Revised: [Figure]

Original: (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: network 01- 23- 45- 67-0 Shared-Individual Network Depths

Original: Random Set Accuracy are the ratios of unseen factor combinations in prediction.
Revised: [Figure] [Figure] Convolutional [Table]

Revised: [Figure]

Revised: [Figure]

Revised: [Table]

Revised: [Table]

Revised: Shared

Original: Test Sample
Revised: [Figure] [Table] [Figure] Network 01-

Original: Accuracy and Test Set Accuracy are computed with the test data, and Random Set Accuracy is with randomly generated inputs.
Revised: 23- 45- 67-0 Shared-Individual Network Depths [Figure] 12- 34- 56- 7-0 Shared [Figure]

Revised: Individual Network

Revised: [Figure]

Revised: [Figure]

Revised: [Figure]

Original:  D ISCUSSIONS 4. E NTANGLED OUTPUT
Revised:  D ISCUSSIONS 4. E NTANGLED OUTPUT

Original: 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: 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: 4. B EYOND 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 beyond 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: 4. W HY DOES FUNCTION SHARING HAPPEN IN DEEP LEARNING ?
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: 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: 4. P OTENTIAL SOLUTIONS
Revised: 4. P OTENTIAL SOLUTIONS

Original: 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, 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:  R ELATED W ORK
Revised:  R ELATED W ORK

Original: 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).
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).

Original: Cognitive scientists see it as central for an organism to view the world (Gallistel & King, 2011).
Revised: 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).
Revised: Studies indicate it is related to the prefrontal cortex (Robin & Holyoak, 1995).

Original: 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.,
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.,

Original: Consciousness Prior (Bengio, 2017).
Revised: Consciousness Prior (Bengio, 2017).

Original: Levels of systematicity were defined (Hadley, 1992; Niklasson & van Gelder, 1994), and types of tests were summarized (Hupkes et al., 2020).
Revised: Levels of systematicity were defined (Hadley, 1992; Niklasson & van Gelder, 1994), and types of tests were summarized (Hupkes et al., 2020).

Original: We focus on the primary case with an unseen combination of seen factor values.
Revised: 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).
Revised: 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).
Revised: 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).

Original: The causation forms Independent Causal Mechanisms (ICMs) (Peters et al., 2017; Sch¨olkopf et al., 2021).
Revised: The causation forms Independent Causal Mechanisms (ICMs) (Peters et al., 2017; Sch¨olkopf et al., 2021).

Original: Systematic generalization is the counterfactual when the joint input distribution is intervened to have new values with zero probability in training (covariate shift).
Revised: Systematic generalization is the counterfactual when the joint input distribution is intervened to have new values with zero probability in training (covariate shift).

Original: This work indicates that standard neural networks do not prefer to learn ICMs.
Revised: This work indicates that standard neural networks do not prefer to learn ICMs.

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.
Revised: 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.

Original: 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).
Revised: 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).

Original: Deep learning is a recent PDP model with many achievements (LeCun et al., 2015; He et al., 2016).
Revised: Deep learning is a recent PDP model with many achievements (LeCun et al., 2015; He et al., 2016).

Original: It was studied that deep neural networks use the composition of functions to achieve high performance (Montufar et al., 2014).
Revised: 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.
Revised: The improvements in i.i.d.

Original: problems encourage to equip deep learning with systematic generalization.
Revised: problems encourage to equip deep learning with systematic generalization.

Original: Recent directions
Revised: Recent directions

Original: 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
Revised: 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

Original: Disentangled representation (Bengio et al., 2013) is learned in unsupervised manners.
Revised: 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).
Revised: 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).
Revised: 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;
Revised: It leads to Symmetry-based Disentangled Representation Learning (Caselles-Dupr ´ e et al., 2019;

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

Original: A disentangled representation learning model can be used as a feature extractor for other systematic generalization tasks.
Revised: A disentangled representation learning model can be used as a feature extractor for other systematic generalization tasks.

Original: Attention mechanisms are widely used in neural networks (Bahdanau et al., 2015).
Revised: Attention mechanisms are widely used in neural networks (Bahdanau et al., 2015).

Original: Transformers (Vaswani et al., 2017) are modern neural network architectures with self-attention.
Revised: Transformers (Vaswani et al., 2017) are modern neural network architectures with self-attention.

Original: Recurrent
Revised: Recurrent

Original: Independent Mechanisms (Goyal et al., 2021b) use attention and the name of the incoming nodes for variable binding.
Revised: 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.
Revised: 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.
Revised: 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.
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: Each task has training and test data, where test data requires systematic generalization from training data.
Revised: 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).
Revised: 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).
Revised: 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).
Revised: 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.
Revised: 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.
Revised: However, it is less discussed why standard deep learning models do not achieve systematic generalization.

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

Original:  C ONCLUSION
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 hypothesize that the conflict is caused by sharing internal functions, and experiments support it.
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: The phenomena are shown in different standard deep neural networks.
Revised: The phenomena are shown in different standard deep neural networks.

Original: 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. 
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. A M ORE EXPERIMENTS

Revised: We run experiments with natural inputs.

Revised: For image data, we use NICO++ dataset (Zhang et al., 2022).

Original: A P ROOFS
Revised: We use five foregrounds as the first output label and five backgrounds as the second. For text data, we use Amazon reviews (Ni et al., 2019). We use five categories as the first output label and five ratings as the second. Either dataset has two outputs, each containing five possible classes.

Revised: There are 25 class combinations, and we separate them into 15 training combinations and 10 test ones in a similar way as in the experiment section.

Revised: For fully connected networks, we use the Fashion dataset (ten classes) and render with ten colors.

Revised: Please refer to Figure 6 and Table 1 for examples.

Revised: For the image dataset, we aggregated foregrounds into five abstract classes, e.g., mammal and vehicle.

Revised: It better uses the limited data with annotations on combined labels.

Revised: We use 72,176 image samples.

Revised: For text data, we randomly select 100,000 samples for each category, with a length limit of 100 tokens.

Revised: Data with training combinations are randomly split into training and i.i.d.

Revised: generalization data with a ratio of 9:1.

Revised: The results are in Figure 7.

Revised: Similar to the results in the experiment section, the test accuracies decrease as there are more shared layers.

Revised: Also, both the training accuracy and the i.i.d.

Revised: generalization accuracy do not decrease as much as the test accuracies.

Revised: We run ablations.

Revised: Figure 8 shows the results with different layer widths.

Revised: Figure 9 shows the results with dropout (Srivastava et al., 2014) and mixup (Zhang et al., 2018).

Revised: All the results have similar effects as the original experiment.

Revised: [Figure]

Revised: [Figure]

Revised: Review

Revised: Book quick read from the most excellent author.

Revised: fun

Revised: Book

Revised: It had tears, some label covering a defect and also wrinkled pages.

Revised: Electronics

Revised: Works perfectly, better than the original cable.

Revised: Electronics

Revised: DID NOT fit as described to accommodate the

Revised: [Table]

Revised: B 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.

Original: 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: 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.

Original: Therefore, if a function does not have other functions more preferred over it, the function follows the proposition.
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: Then, ∀ x a , x b ∈ X :
Revised: Then, ∀ x a , x b ∈ X :

Original: [Equation]
Revised: [Equation]

Original: : g ( x

Original: [Equation]
Revised: [Figure]

Original: =
Revised: [Figure]

Original: g ( x b ) = ⇒ f
Revised: [Figure]

Original: ( x a ) = g ( x a ) =
Revised: [Figure] [Figure] [Figure]

Original: g
Revised: [Figure] [Figure]

Original: [Equation]
Revised: [Figure]

Original: x b ) = f ( x b )
Revised: 23- 45- 67-0 Shared

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

Original: x
Revised: function sharing reduces systematic generalization ability.

Original: [Equation]
Revised: Both the training and the i.i.d.

Original: x [Equation]
Revised: generalization accuracy do not decrease as much as test accuracies.

Original: In both cases,
Revised: In both cases,

Original: [Equation]
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: Also, ∀ x ∈ X :
Revised: Also, ∀ x ∈ X :

Original: [Equation]
Revised: [Equation]

Original:  Therefore, ∀ x ∈ X : f ( x ) ∈ f
Revised: [Figure] [Figure] 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, ∀ x ∈ X : f ( x ) ∈ f
Revised: From Proposition 1, ∀ x [Equation] X : f ( x [Equation]

Revised: ∈ f

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

Original: =
Revised: =

Original: Y 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: C A CONJECTURE ON WHY THE FUNCTION SHARING HAPPENS

Revised: The neural network training process is complicated, so it is hard to describe what happens. Instead, we have a conjecture. For a large network, when a boundary is learned for the first time, it separates the problem into two sub-problems, and their learning processes do not influence each other for the rest of the training.

Revised: We first explain the idea with an analogy of a binary decision tree (or a hierarchical classification).

Revised: We then define a boundary and discuss its properties.

Revised: Binary Decision tree We consider such a binary decision tree that at each decision node, a label set is separated into two parts, each for a sub-tree.

Revised: For example, if there are 10 classes, the root node may divide them into 6 and 4 classes.

Revised: Then the root node of the first sub-tree divides the 6 lasses into two sets of 3 classes.

Revised: In this decision tree, a node separates input space into two parts with disjoint output labels, and each part is learned separately.

Revised: Such a decision tree does not predict new outputs because all leaf nodes predict seen outputs.

Revised: We discuss neural network training process is similar to creating such a decision tree from some aspects.

Revised: A decision tree node is a boundary in a neural network.

Revised: Boundary We consider a problem P =

Revised: ( X , X, Y ) with input space X , input set X , output set Y .

Revised: We have ground truth mapping f : X → Y and learned mapping ˆ f : X → Y .

Revised: We define a boundary as follows.

Revised: Definition 2 (Boundary) .

Revised: Suppose we have a binary partition ( X a , X b ) of an input space X .

Revised: X a , X b are non-empty.

Revised: [Equation]

Revised: It is a boundary if the output sets are disjoint; for each part, all inputs map to its output set.

Revised: [Equation]

Revised: A boundary separates a problem P =

Revised: ( X , X, Y ) to two sub-problems P a =

Revised: ( X a , X a , Y a ) and

Revised: P b = ( X b , X b , Y b ) .

Revised: We assume that when the boundary is learned for the first time, the learning processes of P a and P b do not influence each other for the rest of the training.

Revised: Assumption 3 (Separate sub-problems) .

Revised: When a network is large enough, learning one sub-problem does not affect the prediction of another sub-problem.

Revised: With this assumption, for a large network, a boundary separates the original problem into two problems whose training processes do not influence each other.

Revised: The assumption applies to each subproblem.

Revised: When a problem has only one label, all the inputs are mapped to the label.

Revised: So the model is learned not to predict an unseen output.

Revised: This learning process is similar to that of a decision tree.

Revised: D E XPERIMENT D ETAILS D. 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 of deep playground 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: D. 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: D. 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 2.

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 function sharing avoids systematic generalization.
Revised: So it indicates that function sharing avoids systematic generalization.

Original: [Table]
Revised: [Table]

Original: C Z ERO -S HOT L EARNING D ATASETS
Revised: E 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) [Table] 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 construct output labels from attributes.
Revised: We construct output labels from attributes.

Original: Each attribute is a binary number, 1 for existing in a sample and 0 otherwise.
Revised: Each attribute is a binary number, 1 for existing in a sample and 0 otherwise.

Original: We select six attributes with the most balanced average number (close to 0.5) in all data.
Revised: We select six attributes with the most balanced average number (close to 0.5) in all data.

Original: The first, third, and fifth attributes are used for the first output, and the others for the second output.
Revised: The first, third, and fifth attributes are used for the first output, and the others for the second output.

Original: Each output has eight classes yielded from all the combinations of three binary attributes.
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 split all data to disjoint training and test 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 isfor 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 6 and Table 3.
Revised: The result is shown in Figure 10 and Table 4.

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

Original: [Figure]

Original: [Figure]

Original: [Figure]

Original: [Figure]

Original: [Figure]

Original: [Table]
Revised: [Table]

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

Revised: F. 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, and if an output combination has at least 50 samples, we regard it as a new output (o [Figure] o.d.) partition.
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.o.d.) partition.

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

Original: [Figure]

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

Original: partitions for shared and individual networks in Figure 7.
Revised: partitions for shared and individual networks in Figure 11.

Original: The experiment settings follow DNN and CNN settings in the experiment section.
Revised: The experiment settings follow 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]

Original: D. E QUALLY DIFFICULT FACTORS
Revised: F. 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 the average of two colored images can cause training data under-fitting, we merge the inputs 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 8 and Table 3.
Revised: The result is shown in Figure 12 and Table 4.

Original: Similar to the previous experiments, when the difficulties are equal, the depth of the shared network weakens systematic generalization
Revised: Similar to the previous experiments, when the difficulties are equal, the depth of the shared network weakens systematic generalization. 23- 45- 67-0 Shared-Individual Network Depths

Original: [Table]
Revised: [Figure]

Revised: Test Sample Acc.

Revised: Test Set Acc.

Original: [Table]
Revised: Rnd. Set Acc. [Figure] aPY 01-

Revised: 23- 45- 67-0 Shared-Individual Network Depths

Original: [Figure]
Revised: [Figure]

Revised: cc

Revised: [Figure]

Revised: [Figure]

Revised: [Figure]

Revised: [Figure]

Revised: [Figure]

Revised: [Figure]

Revised: 67-0 Shared-Individual Network Depths

Revised: [Figure]

Revised: [Figure]

Revised: 23- 45- 67-0 Shared-Individual Network Depths

Revised: [Figure]

Revised: [Figure]

Revised: [Table]

Original: D. L ABEL COMBINATIONS
Revised: F. 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-shot 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-shot, 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 to one-shot learning.
Revised: It is similar to one-shot learning.

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

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

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

Revised: [Figure]

Revised: [Figure]