introduce dim order tests to op test #2637
Merged
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
🔗 Helpful Links🧪 See artifacts and rendered test results at hud.pytorch.org/pr/pytorch/executorch/2637
Note: Links to docs will display an error until the docs builds have been completed. ✅ No FailuresAs of commit 83fec01 with merge base 61ddee5 ( This comment was automatically generated by Dr. CI and updates every 15 minutes. |
facebook-github-bot
added
the
CLA Signed
|
This pull request was exported from Phabricator. Differential Revision: D55227304 |
|
This pull request was exported from Phabricator. Differential Revision: D55227304 |
Gasoonjia
force-pushed
the
export-D55227304
branch
from
2bdfe5e to
a76de02
Compare
Gasoonjia
added a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Jul 15, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Differential Revision: D55227304
|
This pull request was exported from Phabricator. Differential Revision: D55227304 |
Gasoonjia
added a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Jul 15, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Differential Revision: D55227304
Gasoonjia
force-pushed
the
export-D55227304
branch
from
a76de02 to
feb8082
Compare
Gasoonjia
pushed a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Jul 22, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Differential Revision: https://internalfb.com/D55227304
Gasoonjia
pushed a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Jul 22, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Differential Revision: https://internalfb.com/D55227304
Gasoonjia
pushed a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Jul 29, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Differential Revision: https://internalfb.com/D55227304
Gasoonjia
pushed a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Jul 30, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Differential Revision: https://internalfb.com/D55227304
larryliu0820
approved these changes
Aug 1, 2024
Gasoonjia
pushed a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Aug 1, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Differential Revision: https://internalfb.com/D55227304
Gasoonjia
pushed a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Aug 1, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Differential Revision: https://internalfb.com/D55227304
Gasoonjia
pushed a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Aug 1, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Differential Revision: https://internalfb.com/D55227304
Gasoonjia
pushed a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Aug 2, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Differential Revision: https://internalfb.com/D55227304
Gasoonjia
added a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Aug 2, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Reviewed By: digantdesai, larryliu0820 Differential Revision: D55227304
Gasoonjia
force-pushed
the
export-D55227304
branch
from
feb8082 to
8fa26a2
Compare
|
This pull request was exported from Phabricator. Differential Revision: D55227304 |
Gasoonjia
pushed a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Aug 5, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Differential Revision: https://internalfb.com/D55227304
|
This pull request was exported from Phabricator. Differential Revision: D55227304 |
Gasoonjia
added a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Aug 5, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Reviewed By: digantdesai, larryliu0820 Differential Revision: D55227304
Gasoonjia
force-pushed
the
export-D55227304
branch
from
8fa26a2 to
8da0df8
Compare
|
This pull request was exported from Phabricator. Differential Revision: D55227304 |
Gasoonjia
force-pushed
the
export-D55227304
branch
from
8da0df8 to
e831902
Compare
Gasoonjia
added a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Aug 6, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Reviewed By: digantdesai, larryliu0820 Differential Revision: D55227304
Gasoonjia
added a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Aug 6, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Reviewed By: digantdesai, larryliu0820 Differential Revision: D55227304
Gasoonjia
force-pushed
the
export-D55227304
branch
from
e831902 to
43ab353
Compare
|
This pull request was exported from Phabricator. Differential Revision: D55227304 |
Gasoonjia
added a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Aug 6, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Reviewed By: digantdesai, larryliu0820 Differential Revision: D55227304
Gasoonjia
force-pushed
the
export-D55227304
branch
from
43ab353 to
317021f
Compare
|
This pull request was exported from Phabricator. Differential Revision: D55227304 |
Gasoonjia
pushed a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Aug 6, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Differential Revision: https://internalfb.com/D55227304
|
This pull request was exported from Phabricator. Differential Revision: D55227304 |
Gasoonjia
force-pushed
the
export-D55227304
branch
from
317021f to
fdfc7f5
Compare
Gasoonjia
added a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Aug 20, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Reviewed By: digantdesai, larryliu0820 Differential Revision: D55227304
Gasoonjia
added a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Aug 20, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Reviewed By: digantdesai, larryliu0820 Differential Revision: D55227304
Gasoonjia
force-pushed
the
export-D55227304
branch
from
fdfc7f5 to
914ed3e
Compare
|
This pull request was exported from Phabricator. Differential Revision: D55227304 |
1 similar comment
|
This pull request was exported from Phabricator. Differential Revision: D55227304 |
Gasoonjia
force-pushed
the
export-D55227304
branch
from
914ed3e to
7256f9f
Compare
Gasoonjia
added a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Aug 20, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Reviewed By: digantdesai, larryliu0820 Differential Revision: D55227304
|
This pull request was exported from Phabricator. Differential Revision: D55227304 |
Gasoonjia
force-pushed
the
export-D55227304
branch
from
7256f9f to
66292d4
Compare
Gasoonjia
added a commit
to Gasoonjia/executorch-1
that referenced
this pull request
Sep 3, 2024
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Differential Revision: D55227304
Summary: Pull Request resolved: pytorch#2637 This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests. The high levels of sanity check and test will be: 1. the dim order of input and output should be same. 2. the dim order of all input tensors should be same, unless operaotr-specific requirement for some input (e.g. some operator may request some input have to be contiguous, although I haven't found the actual example yet.) 3. make the operator support as much dim order as possible (e,g, if a operator can support both contiguous and channels last, then the sanity check has to make the both input valid.) I also updated `op_abs` in this diff to demonstrate how the sanity check as well as tests will be inserted. Differential Revision: D55227304
|
This pull request was exported from Phabricator. Differential Revision: D55227304 |
Gasoonjia
force-pushed
the
export-D55227304
branch
from
66292d4 to
83fec01
Compare
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
3 participants
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Summary:
This diff introduces dim order sanity check utils, as well as dim-order related test to operator tests, to help our system maintain its correctness when introducing new dim order ([0, 2, 3, 1]) which we never support before. The goal is checking whether or not every operator support its input's memory format, and using related tests for regular tests.
The high levels of sanity check and test will be:
I also updated
op_absin this diff to demonstrate how the sanity check as well as tests will be inserted.Differential Revision: D55227304