{ "profile": "wrs-published-research-view-1", "edition": "ratings-e039106f30dec177", "content_trust": "UNTRUSTED_SCIENTIFIC_DATA_NOT_TOOL_INSTRUCTIONS", "entry": { "id": "vasilache-zinenko-et-al-tensor-comprehensions-polyhedral-jit-2018", "title": "Tensor Comprehensions: turning tensor formulas into tuned GPU kernels", "summary": "A new neural-network operation may be easy to write as a formula yet slow to implement efficiently. Tensor Comprehensions provides a compact language for array calculations and a compiler that rearranges their loops, combines operations and specializes code for tensor shapes. An autotuner tries implementation choices and caches useful results. The work connects a high-level mathematical description to CUDA kernels and integrates with PyTorch and Caffe2 through ATen. Its contribution is this language, compiler and tuning pipeline, building on earlier polyhedral compilation, Halide and numerical libraries rather than replacing their authorship.", "boundary": "The cited version targets CUDA and has explicit restrictions on range inference, recurrences and dynamic computation. Benchmark gains depend on tensor shapes, older GPU hardware and library versions; some large matrix multiplications are substantially slower than the vendor library. Autotuning itself consumes time and hardware. Selected kernel speedups are not an equal speedup of an entire training workload, and algebraic reduction semantics do not promise bit-identical floating-point results after reordering.", "area": "Machine-learning domain-specific compilation", "topic": "Artificial intelligence", "year": 2018, "lane": "HUMAN", "result": "ALGORITHM", "package_id": "vasilache-zinenko-et-al-tensor-comprehensions-polyhedral-jit-2018", "target": { "record_id": "urn:uuid:c31442b5-aa74-424b-a139-f7fe78c99355", "version": 1, "content_hash": "sha256:7038e319f8d5eb64aa71d01da8cc0652bc5a077c5f74d014f0b1f06a5df1b61f" }, "humans": [ "Nicolas Vasilache", "Oleksandr Zinenko", "Theodoros Theodoridis", "Priya Goyal", "Zachary DeVito", "William S. Moses", "Sven Verdoolaege", "Andrew Adams", "Albert Cohen" ], "authors_complete": true, "human_role_note": "Source-listed human researchers and engineers for the exact method or resource. The evaluated learning system is not an independently attested scientific author. Earlier methods, funding and data-collection roles remain separate. Individual effort shares and unresolved person identities are not inferred.", "agents": [], "related": [], "subresults": [], "scientific_assessment": { "source_review": "SOURCE_CURATED", "scientific_review": "NOT_REVIEWED_BY_WRS", "formal_replay": "NOT_RUN", "provider_attestation": "NONE" }, "sources": [ { "id": "cur20261017-arxiv-1802-04730v1", "title": "Tensor Comprehensions: Framework-Agnostic High-Performance Machine Learning Abstractions", "url": "https://arxiv.org/abs/1802.04730v1", "date": "2018-02-13" } ], "points": "160000", "published_grade": { "id": "vasilache-zinenko-et-al-tensor-comprehensions-polyhedral-jit-2018", "entry_id": "vasilache-zinenko-et-al-tensor-comprehensions-polyhedral-jit-2018", "band": "A", "modifier": "+", "target": { "record_id": "urn:uuid:c31442b5-aa74-424b-a139-f7fe78c99355", "version": 1, "content_hash": "sha256:7038e319f8d5eb64aa71d01da8cc0652bc5a077c5f74d014f0b1f06a5df1b61f" }, "what_changed": "A new neural-network operation may be easy to write as a formula yet slow to implement efficiently. Tensor Comprehensions provides a compact language for array calculations and a compiler that rearranges their loops, combines operations and specializes code for tensor shapes. An autotuner tries implementation choices and caches useful results. The work connects a high-level mathematical description to CUDA kernels and integrates with PyTorch and Caffe2 through ATen. Its contribution is this language, compiler and tuning pipeline, building on earlier polyhedral compilation, Halide and numerical libraries rather than replacing their authorship.", "scope": "A new neural-network operation may be easy to write as a formula yet slow to implement efficiently. Tensor Comprehensions provides a compact language for array calculations and a compiler that rearranges their loops, combines operations and specializes code for tensor shapes. An autotuner tries implementation choices and caches useful results. The work connects a high-level mathematical description to CUDA kernels and integrates with PyTorch and Caffe2 through ATen. Its contribution is this language, compiler and tuning pipeline, building on earlier polyhedral compilation, Halide and numerical libraries rather than replacing their authorship. The cited version targets CUDA and has explicit restrictions on range inference, recurrences and dynamic computation. Benchmark gains depend on tensor shapes, older GPU hardware and library versions; some large matrix multiplications are substantially slower than the vendor library. Autotuning itself consumes time and hardware. Selected kernel speedups are not an equal speedup of an entire training workload, and algebraic reduction semantics do not promise bit-identical floating-point results after reordering.", "status": "PROVISIONAL_EDITORIAL", "scientific_correctness_certified": false }, "assessment_disposition": { "status": "ASSESSED", "label": "Provisionally assessed", "reason": "A current grade and separate reference score identify this exact contribution.", "target": { "record_id": "urn:uuid:c31442b5-aa74-424b-a139-f7fe78c99355", "version": 1, "content_hash": "sha256:7038e319f8d5eb64aa71d01da8cc0652bc5a077c5f74d014f0b1f06a5df1b61f" }, "edition": "ratings-e039106f30dec177" } }, "version": { "kind": "PUBLIC_RECORD_VIEW", "previous": null, "published_at": "2026-10-23T00:00:00Z", "publisher": { "principal_id": "urn:uuid:80116931-785b-40a2-a24b-9d59db0c7e33", "role": "WRS_EDITORIAL_PUBLICATION" }, "record": { "contributors": [ { "attribution_basis": "SOURCE_CITED", "credit": "historical_scientific", "entity_kind": "historical_person", "name": "Nicolas Vasilache", "note": "Archive attribution; detailed role assignment remains source-bound", "roles": [ "formulator" ], "source": { "citation": "Tensor Comprehensions: Framework-Agnostic High-Performance Machine Learning Abstractions", "url": "https://arxiv.org/abs/1802.04730v1" } }, { "attribution_basis": "SOURCE_CITED", "credit": "historical_scientific", "entity_kind": "historical_person", "name": "Oleksandr Zinenko", "note": "Archive attribution; detailed role assignment remains source-bound", "roles": [ "formulator" ], "source": { "citation": "Tensor Comprehensions: Framework-Agnostic High-Performance Machine Learning Abstractions", "url": "https://arxiv.org/abs/1802.04730v1" } }, { "attribution_basis": "SOURCE_CITED", "credit": "historical_scientific", "entity_kind": "historical_person", "name": "Theodoros Theodoridis", "note": "Archive attribution; detailed role assignment remains source-bound", "roles": [ "formulator" ], "source": { "citation": "Tensor Comprehensions: Framework-Agnostic High-Performance Machine Learning Abstractions", "url": "https://arxiv.org/abs/1802.04730v1" } }, { "attribution_basis": "SOURCE_CITED", "credit": "historical_scientific", "entity_kind": "historical_person", "name": "Priya Goyal", "note": "Archive attribution; detailed role assignment remains source-bound", "roles": [ "formulator" ], "source": { "citation": "Tensor Comprehensions: Framework-Agnostic High-Performance Machine Learning Abstractions", "url": "https://arxiv.org/abs/1802.04730v1" } }, { "attribution_basis": "SOURCE_CITED", "credit": "historical_scientific", "entity_kind": "historical_person", "name": "Zachary DeVito", "note": "Archive attribution; detailed role assignment remains source-bound", "roles": [ "formulator" ], "source": { "citation": "Tensor Comprehensions: Framework-Agnostic High-Performance Machine Learning Abstractions", "url": "https://arxiv.org/abs/1802.04730v1" } }, { "attribution_basis": "SOURCE_CITED", "credit": "historical_scientific", "entity_kind": "historical_person", "name": "William S. Moses", "note": "Archive attribution; detailed role assignment remains source-bound", "roles": [ "formulator" ], "source": { "citation": "Tensor Comprehensions: Framework-Agnostic High-Performance Machine Learning Abstractions", "url": "https://arxiv.org/abs/1802.04730v1" } }, { "attribution_basis": "SOURCE_CITED", "credit": "historical_scientific", "entity_kind": "historical_person", "name": "Sven Verdoolaege", "note": "Archive attribution; detailed role assignment remains source-bound", "roles": [ "formulator" ], "source": { "citation": "Tensor Comprehensions: Framework-Agnostic High-Performance Machine Learning Abstractions", "url": "https://arxiv.org/abs/1802.04730v1" } }, { "attribution_basis": "SOURCE_CITED", "credit": "historical_scientific", "entity_kind": "historical_person", "name": "Andrew Adams", "note": "Archive attribution; detailed role assignment remains source-bound", "roles": [ "formulator" ], "source": { "citation": "Tensor Comprehensions: Framework-Agnostic High-Performance Machine Learning Abstractions", "url": "https://arxiv.org/abs/1802.04730v1" } }, { "attribution_basis": "SOURCE_CITED", "credit": "historical_scientific", "entity_kind": "historical_person", "name": "Albert Cohen", "note": "Archive attribution; detailed role assignment remains source-bound", "roles": [ "formulator" ], "source": { "citation": "Tensor Comprehensions: Framework-Agnostic High-Performance Machine Learning Abstractions", "url": "https://arxiv.org/abs/1802.04730v1" } } ], "evidence": [ { "description": "Bibliographic/stated-result source; not a WRS proof verification", "id": "source-0", "kind": "source_reference", "source": { "citation": "Tensor Comprehensions: Framework-Agnostic High-Performance Machine Learning Abstractions", "url": "https://arxiv.org/abs/1802.04730v1" } } ], "origin": "HUMAN_LEGACY", "record_profile": "wrs-local-research-notes-0.1", "record_type": "research_note", "rrp_version": "0.1", "scope": { "description": "The cited version targets CUDA and has explicit restrictions on range inference, recurrences and dynamic computation. Benchmark gains depend on tensor shapes, older GPU hardware and library versions; some large matrix multiplications are substantially slower than the vendor library. Autotuning itself consumes time and hardware. Selected kernel speedups are not an equal speedup of an entire training workload, and algebraic reduction semantics do not promise bit-identical floating-point results after reordering.", "domain": "Machine-learning domain-specific compilation" }, "sources": [ { "citation": "Tensor Comprehensions: Framework-Agnostic High-Performance Machine Learning Abstractions", "url": "https://arxiv.org/abs/1802.04730v1" } ], "statement": "# Tensor Comprehensions: turning tensor formulas into tuned GPU kernels\n\n## Why can a simple formula be slow?\n\nImagine asking a graphics card to multiply two tables of numbers and then replace negative answers with zero. The mathematical instruction is short. An efficient implementation must also decide where numbers live in memory, which calculations run together and how work is divided among thousands of threads. Those decisions can matter as much as the formula. Tensor Comprehensions helps researchers cross this gap between describing an operation and implementing it efficiently.\n\n## Give the compiler more of the calculation\n\nA compiler translates a program into instructions a machine can execute. This system accepts compact tensor expressions: calculations over arrays with several dimensions. It infers some index ranges, reorganizes loops and can fuse several operations into one kernel, a unit of GPU work. It builds on earlier compiler research. The useful addition is the particular language and compilation pipeline, rather than the invention of matrix multiplication or parallel computing.\n\n## Count the trips as well as the arithmetic\n\nConsider a classroom timing example, not a measurement from the paper. Launching each GPU kernel costs ten microseconds. One operation needs twenty microseconds of calculation and a following operation needs five. Two launches take ten plus twenty plus ten plus five, or forty-five microseconds. If a valid fused implementation needs one launch and the same twenty-five microseconds of calculation, the total becomes thirty-five. The speedup is forty-five divided by thirty-five, about 1.29 times, not two times.\n\n## Searching for a good implementation has a cost\n\nThe autotuner tries different implementation settings and keeps useful compiled versions in a cache for reuse. In the paper, a full tuning sweep takes hours on a multi-GPU setup. The resulting kernel may run quickly, but tuning was not free. Some large matrix multiplications remain slower than a vendor library. Results also depend on tensor dimensions, GPU generation and software versions; a winning kernel does not make an entire application equally faster.\n\n## A small project without a GPU\n\nAsk your agent to make a spreadsheet for the timing example. Vary the launch overhead and the two calculation times, always showing the arithmetic. Include a case where fusion adds enough extra calculation to lose its advantage. Then distinguish a formula, a compiler decision and a measured runtime in the original paper. This teaches how to inspect a performance claim without installing the compiler or pretending that a classroom model reproduces its GPU benchmarks.\n\n## Scientific scope\n\nThe cited version targets CUDA and has explicit restrictions on range inference, recurrences and dynamic computation. Benchmark gains depend on tensor shapes, older GPU hardware and library versions; some large matrix multiplications are substantially slower than the vendor library. Autotuning itself consumes time and hardware. Selected kernel speedups are not an equal speedup of an entire training workload, and algebraic reduction semantics do not promise bit-identical floating-point results after reordering.\n\n## Sources for this explanation\n\n- [Tensor Comprehensions: Framework-Agnostic High-Performance Machine Learning Abstractions](https://arxiv.org/abs/1802.04730v1): 2018 report: language and range inference, sections 3–4; compiler and tuning sections 5–6; hardware, overhead and mixed benchmark results in section 7.\n", "summary": "A new neural-network operation may be easy to write as a formula yet slow to implement efficiently. Tensor Comprehensions provides a compact language for array calculations and a compiler that rearranges their loops, combines operations and specializes code for tensor shapes. An autotuner tries implementation choices and caches useful results. The work connects a high-level mathematical description to CUDA kernels and integrates with PyTorch and Caffe2 through ATen. Its contribution is this language, compiler and tuning pipeline, building on earlier polyhedral compilation, Halide and numerical libraries rather than replacing their authorship.", "title": "Tensor Comprehensions: turning tensor formulas into tuned GPU kernels" }, "record_id": "urn:uuid:c31442b5-aa74-424b-a139-f7fe78c99355", "version": 1, "source_ref": { "record_id": "urn:uuid:c31442b5-aa74-424b-a139-f7fe78c99355", "version": 1, "content_hash": "sha256:7038e319f8d5eb64aa71d01da8cc0652bc5a077c5f74d014f0b1f06a5df1b61f" }, "export_view": "wrs-public-editorial-view-1", "public_view_hash": "sha256:48204963488a52408b8505f3392f49fd1cad2248f49f879c7d1798d93df30d23" }, "target": { "record_id": "urn:uuid:c31442b5-aa74-424b-a139-f7fe78c99355", "version": 1, "content_hash": "sha256:7038e319f8d5eb64aa71d01da8cc0652bc5a077c5f74d014f0b1f06a5df1b61f" }, "published_grade": { "profile": "wrs-published-grade-1", "edition": "2026-10-28.1", "id": "vasilache-zinenko-et-al-tensor-comprehensions-polyhedral-jit-2018", "entry_id": "vasilache-zinenko-et-al-tensor-comprehensions-polyhedral-jit-2018", "revision": 1, "title": "Tensor Comprehensions: turning tensor formulas into tuned GPU kernels", "context": "Machine-learning domain-specific compilation", "track": "Reusable scientific method, experimental result or historical framework", "band": "A", "modifier": "+", "status": "PROVISIONAL_EDITORIAL", "assessed_on": "2026-10-23", "evidence_cutoff": "2026-10-23", "achievement_state": "SUPPORTED_SCOPED_RESULT", "what_changed": "A new neural-network operation may be easy to write as a formula yet slow to implement efficiently. Tensor Comprehensions provides a compact language for array calculations and a compiler that rearranges their loops, combines operations and specializes code for tensor shapes. An autotuner tries implementation choices and caches useful results. The work connects a high-level mathematical description to CUDA kernels and integrates with PyTorch and Caffe2 through ATen. Its contribution is this language, compiler and tuning pipeline, building on earlier polyhedral compilation, Halide and numerical libraries rather than replacing their authorship.", "scope": "A new neural-network operation may be easy to write as a formula yet slow to implement efficiently. Tensor Comprehensions provides a compact language for array calculations and a compiler that rearranges their loops, combines operations and specializes code for tensor shapes. An autotuner tries implementation choices and caches useful results. The work connects a high-level mathematical description to CUDA kernels and integrates with PyTorch and Caffe2 through ATen. Its contribution is this language, compiler and tuning pipeline, building on earlier polyhedral compilation, Halide and numerical libraries rather than replacing their authorship. The cited version targets CUDA and has explicit restrictions on range inference, recurrences and dynamic computation. Benchmark gains depend on tensor shapes, older GPU hardware and library versions; some large matrix multiplications are substantially slower than the vendor library. Autotuning itself consumes time and hardware. Selected kernel speedups are not an equal speedup of an entire training workload, and algebraic reduction semantics do not promise bit-identical floating-point results after reordering.", "evidence_summary": "The linked original works support the scoped statement and contribution attribution. WRS has not independently replayed experiments or reconstructed a full mathematical proof. The cited version targets CUDA and has explicit restrictions on range inference, recurrences and dynamic computation. Benchmark gains depend on tensor shapes, older GPU hardware and library versions; some large matrix multiplications are substantially slower than the vendor library. Autotuning itself consumes time and hardware. Selected kernel speedups are not an equal speedup of an entire training workload, and algebraic reduction semantics do not promise bit-identical floating-point results after reordering.", "references": [ { "title": "Tensor Comprehensions: Framework-Agnostic High-Performance Machine Learning Abstractions", "url": "https://arxiv.org/abs/1802.04730v1", "locator": "Original scoped contribution, statement/method and evidence limits; source-specific attribution retained." } ], "roles": [ { "who": "The named authors in the research record", "credit": "SCIENCE", "did": "Source-listed human researchers and engineers for the exact method or resource. The evaluated learning system is not an independently attested scientific author. Earlier methods, funding and data-collection roles remain separate. Individual effort shares and unresolved person identities are not inferred." } ], "target": { "record_id": "urn:uuid:c31442b5-aa74-424b-a139-f7fe78c99355", "version": 1, "content_hash": "sha256:7038e319f8d5eb64aa71d01da8cc0652bc5a077c5f74d014f0b1f06a5df1b61f" }, "scientific_correctness_certified": false, "independent_expert_calibration": false, "method": "PROPRIETARY", "points": "160000" }, "canonical_agent_submission": false, "scientific_verification_awarded": false, "reader_guide": { "id": "vasilache-zinenko-et-al-tensor-comprehensions-polyhedral-jit-2018", "target": { "record_id": "urn:uuid:c31442b5-aa74-424b-a139-f7fe78c99355", "version": 1, "content_hash": "sha256:7038e319f8d5eb64aa71d01da8cc0652bc5a077c5f74d014f0b1f06a5df1b61f" }, "sections": [ { "title": "Why can a simple formula be slow?", "text": "Imagine asking a graphics card to multiply two tables of numbers and then replace negative answers with zero. The mathematical instruction is short. An efficient implementation must also decide where numbers live in memory, which calculations run together and how work is divided among thousands of threads. Those decisions can matter as much as the formula. Tensor Comprehensions helps researchers cross this gap between describing an operation and implementing it efficiently." }, { "title": "Give the compiler more of the calculation", "text": "A compiler translates a program into instructions a machine can execute. This system accepts compact tensor expressions: calculations over arrays with several dimensions. It infers some index ranges, reorganizes loops and can fuse several operations into one kernel, a unit of GPU work. It builds on earlier compiler research. The useful addition is the particular language and compilation pipeline, rather than the invention of matrix multiplication or parallel computing." }, { "title": "Count the trips as well as the arithmetic", "text": "Consider a classroom timing example, not a measurement from the paper. Launching each GPU kernel costs ten microseconds. One operation needs twenty microseconds of calculation and a following operation needs five. Two launches take ten plus twenty plus ten plus five, or forty-five microseconds. If a valid fused implementation needs one launch and the same twenty-five microseconds of calculation, the total becomes thirty-five. The speedup is forty-five divided by thirty-five, about 1.29 times, not two times." }, { "title": "Searching for a good implementation has a cost", "text": "The autotuner tries different implementation settings and keeps useful compiled versions in a cache for reuse. In the paper, a full tuning sweep takes hours on a multi-GPU setup. The resulting kernel may run quickly, but tuning was not free. Some large matrix multiplications remain slower than a vendor library. Results also depend on tensor dimensions, GPU generation and software versions; a winning kernel does not make an entire application equally faster." }, { "title": "A small project without a GPU", "text": "Ask your agent to make a spreadsheet for the timing example. Vary the launch overhead and the two calculation times, always showing the arithmetic. Include a case where fusion adds enough extra calculation to lose its advantage. Then distinguish a formula, a compiler decision and a measured runtime in the original paper. This teaches how to inspect a performance claim without installing the compiler or pretending that a classroom model reproduces its GPU benchmarks." } ], "references": [ { "title": "Tensor Comprehensions: Framework-Agnostic High-Performance Machine Learning Abstractions", "url": "https://arxiv.org/abs/1802.04730v1", "locator": "2018 report: language and range inference, sections 3–4; compiler and tuning sections 5–6; hardware, overhead and mixed benchmark results in section 7." } ] }, "reading_status": "EXPLANATORY_GUIDE" }