Search

In this letter, we consider an unmanned aerial vehicle (UAV)-aided information monitoring scheme in a multiple input multiple output (MIMO) communication system. According to the tensor structure of the communication links, an information monitoring receiver is proposed. The receiver is based on the generalized tensor contraction (GTC), which exploits a nested parallel factor (PARAFAC) model for the received signals, via an iterative least squares (LS) algorithm to jointly monitor the data symbols transmitted from the users via the base stations. Compared with some competing receivers, our simulation results demonstrate the superiority of the proposed GTC-LS receiver in terms of normalized mean square error and bit error rate.

Tensor network and tensor computation are widely applied in scientific and engineering domains like quantum physics, electronic design automation, and machine learning. As one of the most fundamental operations for tensor networks, a tensor contraction eliminates the sharing orders among tensors and produces a compact sub-network. Different contraction sequence usually yields distinct storage and compute costs, and searching the optimal sequence is known as a hard problem. Prior work have designed heuristic and fast algorithms to solve this problem, however, several issues still remain unsolved. For example, the data format and data structure are not efficient, the constraints during modeling are impractical, the search of the optimal solution might fail, and the search cost is very high. In this paper, we first introduce a $log_k$ order representation and design an adjacency matrix-based data structure to efficiently accelerate the search of the optimal contraction sequence. Then, we propose an outer product pruning method with acceptable overhead to reduce the search space. Finally, we use a multithread optimization in our implementation to further improve the execution performance. We also present in-depth analysis of factors that influence the search time. This work provides a full-stack solution for optimal contraction sequence search from both high-level data structure and search algorithm to low-level execution parallelism, and it will benefit a broad range of tensor-related applications.

Tropical cyclone (TC) intensity estimation is an important task in meteorological research. Meanwhile, TC intensity estimation performance can be improved by developing advanced machine learning techniques using the newly emerged high-quality multispectral images (MSIs) acquired by FY-4 meteorological satellite of China. To this end, this article proposes a novel model, tensor-based convolutional neural network (TCNN). Not only being a deep network entirely formulated in tensor algebra, but TCNN also establishes the mathematical connections between tensor decomposition and CNN operations with tensor contraction. Moreover, TCNN adopts a multitask structure, which consists of a classification network for intensity categorization and a regression network for wind speed estimation. It allows the regression network to leverage the outcome of the classification network, thus ensuring intensity estimation accuracy. In addition, two alternative TCNN models, coupled TCNN (C-TCNN) and Tucker TCNN (T-TCNN), are designed to automatically deal with invalid band data in the FY-4 MSIs, which has been a practical issue with the data. Experimental results prove that the proposed network is accurate and functional. They also demonstrate the advantages of TCNN over other TC intensity estimation methods, showing that C-TCNN and T-TCNN outperform several classic models and the state-of-the-art models based on CNN.

Tensor contraction is a fundamental operation in many algorithms with a plethora of applications ranging from quantum chemistry over fluid dynamics and image processing to machine learning. The performance of tensor computations critically depends on the efficient utilization of on-chip/off-chip memories. In the context of low-power embedded devices, efficient management of the memory space becomes even more crucial, in order to meet energy constraints. This work aims at investigating strategies for performance- and energy-efficient tensor contractions on embedded systems, using racetrack memory (RTM)-based scratch-pad memory (SPM) and DRAM-based off-chip memory. Compiler optimizations such as the loop access order and data layout transformations paired with architectural optimizations such as prefetching and preshifting are employed to reduce the shifting overhead in RTMs. Optimizations for off-chip memory such as memory access order, data mapping and the choice of a suitable memory access granularity are employed to reduce the contention in the off-chip memory. Experimental results demonstrate that the proposed optimizations improve the SPM performance and energy consumption by 32% and 73%, respectively, compared to an iso-capacity SRAM. The overall DRAM dynamic energy consumption improvements due to memory optimizations amount to 80%.

The recently introduced multi-layer (ML) multi-configurational time-dependent Hartree (MCTDH) in optimized second quantization representation (oSQR) approach combines the use of an optimized time-dependent orbital basis and the multi-layer MCTDH tensor contraction scheme to efficiently describe the quantum dynamics of system consisting of identical particles. Extending the original work on the subject, which studied propagation in real and imaginary time for Hamiltonians with flexible and fixed particle numbers, here the representation of thermal ensembles and the calculation of thermally averaged observables within the ML-MCTDH-oSQR is investigated. Different statistal sampling schemes for fixed and flexible particle numbers are introduced and analyzed. Numerical calculations studying a Hubbard model are used to illustrate the properties of the different schemes.

General Matrix Multiplication or GEMM kernels take centre place in high performance computing and machine learning. Recent NVIDIA GPUs include GEMM accelerators, such as NVIDIA's Tensor Cores. Their exploitation is hampered by the two-language problem: it requires either low-level programming which implies low programmer productivity or using libraries that only offer a limited set of components. Because rephrasing algorithms in terms of established components often introduces overhead, the libraries' lack of flexibility limits the freedom to explore new algorithms. Researchers using GEMMs can hence not enjoy programming productivity, high performance, and research flexibility at once. In this paper we solve this problem. We present three sets of abstractions and interfaces to program GEMMs within the scientific Julia programming language. The interfaces and abstractions are co-designed for researchers' needs and Julia's features to achieve sufficient separation of concerns and flexibility to easily extend basic GEMMs in many different ways without paying a performance price. Comparing our GEMMs to state-of-the-art libraries cuBLAS and CUTLASS, we demonstrate that our performance is in the same ballpark of the libraries, and in some cases even exceeds it, without having to write a single line of code in CUDA C++ or assembly, and without facing flexibility limitations., This paper was submitted to IEEE TPDS

In this chapter we deal with a method of constructing a new group from two given ones, other than their extension. This method, the tensor product, is an important one in several branches of mathematics, but fails to have the same degree of importance as the direct sum, in the theory of abelian groups. The reason why this is the situation may be sought primarily in the fact that forming tensor products simplifies the group structure in a considerable manner, as is shown by the result stating that the tensor product of two torsion groups is always the direct sum of cyclic groups. The reader will recognize that tensor products have properties which are, in a sense, dual to those of homomorphism groups.

We develop a high-performance tensor-based simulator for random quantum circuits(RQCs) on the new Sunway supercomputer. Our major innovations include: (1) a near-optimal slicing scheme, and a path-optimization strategy that considers both complexity and compute density; (2) a three-level parallelization scheme that scales to about 42 million cores; (3) a fused permutation and multiplication design that improves the compute efficiency for a wide range of tensor contraction scenarios; and (4) a mixed-precision scheme to further improve the performance. Our simulator effectively expands the scope of simulatable RQCs to include the 10*10(qubits)*(1+40+1)(depth) circuit, with a sustained performance of 1.2 Eflops (single-precision), or 4.4 Eflops (mixed-precision)as a new milestone for classical simulation of quantum circuits; and reduces the simulation sampling time of Google Sycamore to 304 seconds, from the previously claimed 10,000 years., Comment: 18 pages, 13 figures

To meet the extreme compute demands for deep learning across commercial and scientific applications, dataflow accelerators are becoming increasingly popular. While these "domain-specific" accelerators are not fully programmable like CPUs and GPUs, they retain varying levels of flexibility with respect to data orchestration, i.e., dataflow and tiling optimizations to enhance efficiency. There are several challenges when designing new algorithms and mapping approaches to execute the algorithms for a target problem on new hardware. Previous works have addressed these challenges individually. To address this challenge as a whole, in this work, we present a HW-SW co-design ecosystem for spatial accelerators called Union within the popular MLIR compiler infrastructure. Our framework allows exploring different algorithms and their mappings on several accelerator cost models. Union also includes a plug-and-play library of accelerator cost models and mappers which can easily be extended. The algorithms and accelerator cost models are connected via a novel mapping abstraction that captures the map space of spatial accelerators which can be systematically pruned based on constraints from the hardware, workload, and mapper. We demonstrate the value of Union for the community with several case studies which examine offloading different tensor operations(CONV/GEMM/Tensor Contraction) on diverse accelerator architectures using different mapping schemes., Comment: This paper is accepted to PACT 2021

Tensor network states have been a very prominent tool for the study of quantum many-body physics, thanks to their physically relevant entanglement properties and their ability to encode symmetries. In the last few years, the formalism has been extended and applied to theories with local symmetries too---lattice gauge theories. In order to extract physical properties (such as expectation values and correlation functions of physical observables) out of such states, one has to use the so-called transfer operators, the local properties of which dictate the long-range behavior of the state. In this paper we study transfer operators of tensor network states (in particular, projected entangled pair states) of lattice gauge theories, and consider the implications of the local symmetry on their structure and properties. In particular, we study the implications on the computation of the Wilson loop---a nonlocal, gauge-invariant observable which is central to pure gauge theories, the long-range decay behavior of which probes the confinement or deconfinement of static charges. Using the symmetry, we show how to simplify the tensor contraction required for computing Wilson loop expectation values for such states, eliminate nonphysical parts of the tensors, and formulate conditions relating local properties (that is, of the tensors) to their decay fashion.

We introduce a diagrammatic approach to facilitate the automatic derivation of analytical nuclear gradients for tensor hyper-contraction (THC) based electronic structure methods. The automatically derived gradients are guaranteed to have the same scaling in terms of both operation count and memory footprint as the underlying energy calculations, and the computation of a gradient is roughly three times as costly as the underlying energy. The new diagrammatic approach enables the first cubic scaling implementation of nuclear derivatives for THC tensors fitted in molecular orbital basis (MO-THC). Furthermore, application of this new approach to THC-MP2 analytical gradients leads to an implementation, which is at least four times faster than the previously reported, manually derived implementation. Finally, we apply the new approach to the 14 tensor contraction patterns appearing in the supporting subspace formulation of multireference perturbation theory, laying the foundation for developments of analytical nuclear gradients and nonadiabatic coupling vectors for multi-state CASPT2.

In seismology, linear inversion techniques were proposed to determine the moment tensor component in both time and frequency domains (Stump & Johnson 1977) and (Kanamori & Given 1981). Although all components of the moment tensor must be determined, the moment tensor inversion with constraints has been normally applied to obtaining stable solutions in seismology (Dziewonski & Woodhouse 1981). This is partly because a fault motion of an earthquake is primarily associated with shear motion, corresponding to off-diagonal components in the moment tensor. One application of the moment tensor inversion with constraints is found in rock mechanics (Dai, Labuz et al. 2000).

In finite element calculations, the integral forms are usually evaluated using nested loops over elements, and over quadrature points. Many such forms (e.g. linear or multi-linear) can be expressed in a compact way, without the explicit loops, using a single tensor contraction expression by employing the Einstein summation convention. To automate this process and leverage existing high performance codes, we first introduce a notation allowing trivial differentiation of multi-linear finite element forms. Based on that we propose and describe a new transpiler from Einstein summation based expressions, augmented to allow defining multi-linear finite element weak forms, to regular tensor contraction expressions. The resulting expressions are compatible with a number of Python scientific computing packages, that implement, optimize and in some cases parallelize the general tensor contractions. We assess the performance of those packages, as well as the influence of operand memory layouts and tensor contraction paths optimizations on the elapsed time and memory requirements of the finite element form evaluations. We also compare the efficiency of the transpiled weak form implementations to the C-based functions available in the finite element package SfePy.

We present a massive-parallel implementation of the resolution-of-identity (RI) coupled-cluster approach that includes single, double and perturbatively triple excitations, namely RI-CCSD(T), in the FHI-aims package for molecular systems. A domain-based distributed-memory algorithm in the MPI/OpenMP hybrid framework has been designed to effectively utilize the memory bandwidth and significantly minimize the interconnect communication, particularly for the tensor contraction in the evaluation of the particle-particle ladder term. Our implementation features a rigorous avoidance of the on-the-fly disk storage and an excellent strong scaling up to 10,000 and more cores. Taking a set of molecules with different sizes, we demonstrate that the parallel performance of our CCSD(T) code is competitive with the CC implementations in state-of-the-art high-performance computing (HPC) computational chemistry packages. We also demonstrate that the numerical error due to the use of RI approximation in our RI-CCSD(T) is negligibly small. Together with the correlation-consistent numeric atom-centered orbital (NAO) basis sets, NAO-VCC-nZ, the method is applied to produce accurate theoretical reference data for 22 bio-oriented weak interactions (S22), 11 conformational energies of gaseous cysteine conformers (CYCONF), and 32 isomerization energies (ISO32).

International audience; Evaluating the complexity of an algorithm is an important step when developing applications, as it impacts both its time and energy performance. Computational complexity, which is the number of dynamic operations regardless of the execution order, is easy to characterize for affine programs. Data movement (or, I/O) complexity is more complex to evaluate as it refers, when considering all possible valid schedules, to the minimum required number of I/O between a slow (e.g. main memory) and a fast (e.g. local scratchpad) storage location.This paper presents IOOpt, a fully automated tool that automatically bounds the data movement of an affine (tilable) program. Given a tilable program described in a DSL, it automatically computes: 1. a lower bound of the I/O complexity as a symbolic expression of the cache size and program parameters; 2. an upper bound that allows one to assess the tightness of the lower bound; 3. a tiling recommendation (loop permutation and tile sizes) that matches the upper bound. For the lower bound algorithm which can be applied to any affine program, a substantial effort has been made to provide bounds that are as tight as possible for neural networks: In particular, it extends the previous work of Olivry et al. to handle multi-dimensional reductions and expose the constraints associated with small dimensions that are present in convolutions. For the upper bound algorithm that reasons on the tile band of the program (e.g. output of a polyhedral compiler such as PluTo), the algebraic computations involved have been tuned to behave well on tensor computations such as direct tensor contractions or direct convolutions. As a bonus, the upper bound algorithm that has been extended to multi-level cache can provide the programmer with a useful tiling recommendation. We demonstrate the effectiveness of our tool by deriving the symbolic lower and upper bounds for several tensor contraction and convolution kernels. Then we evaluate numerically the tightness of our bound using the convolution layers of Yolo9000 and representative tensor contractions from the TCCG benchmark suite. Finally, we show the pertinence of our I/O complexity model by reporting the running time of the recommended tiled code for the convolutionlayers of Yolo9000.

Sparse tensor contraction sequence has been widely employed in many fields, such as chemistry and physics. However, how to efficiently implement the sequence faces multiple challenges, such as redundant computations and memory operations, massive memory consumption, and inefficient utilization of hardware. To address the above challenges, we introduce Athena, a high-performance framework for SpTC sequences. Athena introduces new data structures, leverages emerging Optane-based heterogeneous memory (HM) architecture, and adopts stage parallelism. In particular, Athena introduces shared hash table-represented sparse accumulator to eliminate unnecessary input processing and data migration; Athena uses a novel data-semantic guided dynamic migration solution to make the best use of the Optane-based HM for high performance; Athena also co-runs execution phases with different characteristics to enable high hardware utilization. Evaluating with 12 datasets, we show that Athena brings 327-7362× speedup over the state-of-the-art SpTC algorithm. With the dynamic data placement guided by data semantics, Athena brings performance improvement on Optane-based HM over a state-of-the-art software-based data management solution, a hardware-based data management solution, and PMM-only by 1.58×, 1.82×, and 2.34× respectively. Athena also showcases its effectiveness in quantum chemistry and physics scenarios.

International audience; Many domains of scientific simulation (chemistry, condensed matter physics, data science) increasingly eschew dense tensors for block-sparse tensors, sometimes with additional structure (recursive hierarchy, rank sparsity, etc.). Distributedmemory parallel computation with block-sparse tensorial data is paramount to minimize the time-to-solution (e.g., to study dynamical problems or for real-time analysis) and to accommodate problems of realistic size that are too large to fit into the host/device memory of a single node equipped with accelerators. Unfortunately, computation with such irregular data structures is a poor match to the dominant imperative, bulk-synchronous parallel programming model. In this paper, we focus on the critical element of block-sparse tensor algebra, namely binary tensor contraction, and report on an efficient and scalable implementation using the task-focused PaRSEC runtime. High performance of the block-sparse tensor contraction on the Summit supercomputer is demonstrated for synthetic data as well as for real data involved in electronic structure simulations of unprecedented size.

With the help of available big data and powerful computing units, deep learning has achieved remarkable performance in a series of data processing applications, such as speech recognition, computer vision, and natural language processing. Most of the existing neural networks take a lot of matrix computation operators in their architecture, which requires that the multidimensional input or output must be transformed into matrix form and the multilinear structure information may inevitably be lost. In order to avoid the performance degeneration from the structure loss, tensor computation operators have been introduced to extend the matrix-based neural networks. In this chapter, we first give a brief introduction of classical deep neural networks. Tensor computation is used to extend deep neural networks mainly from three ways in existing works. The first one extends the matrix product in each neural layer to tensor counterparts, inspired by different tensor decompositions, including t-product connected deep neural network, mode-n product-based tensorized neural network, etc. In the second way, different tensor decompositions have been used to compress the whole network parameters by low-rank tensor approximation. The third way builds up the connection between tensor decompositions and neural networks, which helps to theoretically analyze deep learning. To demonstrate the effectiveness of tensor analysis for deep neural networks, experimental results on low-rank tensor approximation for network compression show that the computational complexity and storage requirement can be largely reduced, while the image classification accuracy can be maintained.

Sparse tensor contractions appear commonly in many applications. Efficiently computing a two sparse tensor product is challenging: It not only inherits the challenges from common sparse matrix-matrix multiplication (SpGEMM), i.e., indirect memory access and unknown output size before computation, but also raises new challenges because of high dimensionality of tensors, expensive multi-dimensional index search, and massive intermediate and output data. To address the above challenges, we introduce three optimization techniques by using multi-dimensional, efficient hashtable representation for the accumulator and larger input tensor, and all-stage parallelization. Evaluating with 15 datasets, we show that Sparta brings 28 -- 576× speedup over the traditional sparse tensor contraction with sparse accumulator. With our proposed algorithm- and memory heterogeneity-aware data management, Sparta brings extra performance improvement on the heterogeneous memory with DRAM and Intel Optane DC Persistent Memory Module (PMM) over a state-of-the-art software-based data management solution, a hardware-based data management solution, and PMM-only by 30.7% (up to 98.5%), 10.7% (up to 28.3%) and 17% (up to 65.1%) respectively.

This work improves best known numeric constants in the seminal hypercontractive inequality of Bonami, specialized to boolean polynomials of degree two. The novel approach builds on tensor calculus and a new tensor contraction inequality which is of independent interest. As an interesting byproduct, a closed-form formula for the number of perfect matchings in the cocktail-party graph is obtained.

An efficient Galerkin averaging-incremental harmonic balance (EGA-IHB) method is developed based on the fast Fourier transform (FFT) and tensor contraction to increase efficiency and robustness of the IHB method when calculating periodic responses of complex nonlinear systems with non-polynomial nonlinearities. As a semi-analytical method, derivation of formulae and programming are significantly simplified in the EGA-IHB method. The residual vector and Jacobian matrix corresponding to nonlinear terms in the EGA-IHB method are expressed using truncated Fourier series. After calculating Fourier coefficient vectors using the FFT, tensor contraction is used to calculate the Jacobian matrix, which can significantly improve numerical efficiency. Since inaccurate results may be obtained from discrete Fourier transform-based methods when aliasing occurs, the minimal non-aliasing sampling rate is determined for the EGA-IHB method. Performances of the EGA-IHB method are analyzed using several benchmark examples; its accuracy, efficiency, convergence, and robustness are analyzed and compared with several widely used semi-analytical methods. The EGA-IHB method has high efficiency and good robustness for both polynomial and non-polynomial nonlinearities, and it has considerable advantages over the other methods.

Many domains of scientific simulation (chemistry, condensed matter physics, data science) increasingly eschew dense tensors for block-sparse tensors, sometimes with additional structure (recursive hierarchy, rank sparsity, etc.). Distributed-memory parallel computation with block-sparse tensorial data is paramount to minimize the time-tosolution (e.g., to study dynamical problems or for real-time analysis) and to accommodateproblems of realistic size that are too large to fit into the host/device memory of a single node equipped with accelerators. Unfortunately, computation with such irregular data structures is a poor match to the dominant imperative, bulk-synchronous parallel programming model. In this paper, we focus on the critical element of block-sparse tensor algebra, namely binary tensor contraction, and report on an efficient and scalable implementation using the task-focused PaRSEC runtime. High performance of the block-sparse tensor contraction on the Summit supercomputer is demonstrated for synthetic data as well as for real data involved in electronic structure simulations of unprecedented size.; Les tenseurs creux par blocs (block-sparse) sont présents dans de nombreux domaines scientifiques. Ce rapport étudie la parallélisation d’un noyau de contraction essentiel pour la manipulation de tels tenseurs, qui peut se matérialiser sous forme d’un produit de matrices C ← C + AB, où les trois matrices ont une structure creuse par blocs, où les tuiles de A et B sont de tailles hétérogènes, et où B est carrée de taille n, alors que A et C sont rectangulaires de taille m × n avec m << n. Nous proposons une implémentation sur la plate-forme Summit à mémoire distribuée, où chaque nœud est équipé de plusieurs GPUs, au sein de l’environnement de tâches PaRSEC. Nous obtenons de bonnes performances pour des problèmes de taille inégalées à ce jour.

We present a GPU algorithm for performing convolution with decomposed tensor products. We experimentally find up to 4.85x faster execution times than Nvidia’s cuDNN for some tensors. This is achieved by extending recent advances in compression of CNNs through use of tensor decomposition methods on weight tensors. Progress had previously been limited by a lack of fast operations to compute the decomposed variants of critical functions such as 2D convolution. We interpret this and other operations as a network of compound convolution and tensor contraction on the decomposed factors (i.e., generalized tensor operations). The prior approach sees such networks evaluated in a pairwise manner until the resulting output has been recovered, by composing functions in existing libraries such as cuDNN. The computational cost of such evaluations depends upon the order in which the index sums are evaluated, and varies between networks. The sequence of pairwise generalized tensor operations that minimizes the number of computations often produces large intermediate products, incurring performance bottlenecks when communicated with the scarce global memory of modern GPUs. Our solution is a GPU parallel algorithm which performs 2D convolution using filter tensors obtained through CP-decomposition with minimal memory overhead. We benchmark the run-time performance of our algorithm for common filter sizes in neural networks at multiple decomposition ranks. We compare ourselves against cuDNN traditional convolutions and find that our implementation is superior for lower ranks. We also propose a method for determining optimal sequences of pairwise tensor operations, achieving a minimal number of operations with memory constraints.

The Density Matrix Renormalization Group (DMRG) algorithm is a powerful tool for solving eigenvalue problems to model quantum systems. DMRG relies on tensor contractions and dense linear algebra to compute properties of condensed matter physics systems. However, its efficient parallel implementation is challenging due to limited concurrency, large memory footprint, and tensor sparsity. We mitigate these problems by implementing two new parallel approaches that handle block sparsity arising in DMRG, via Cyclops, a distributed memory tensor contraction library. We benchmark their performance on two physical systems using the Blue Waters and Stampede2 supercomputers. Our DMRG performance is improved by up to 5.9X in runtime and 99X in processing rate over ITensor, at roughly comparable computational resource use. This enables higher accuracy calculations via larger tensors for quantum state approximation. We demonstrate that despite having limited concurrency, DMRG is weakly scalable with the use of efficient parallel tensor contraction mechanisms.

In this paper, we present a tensor MIMO-GFDM system model that is based on the double contraction operator. Based on the derived system model, we propose an iterative tensor based MIMOGFDM receiver, that is initialized with the channel estimation obtained via pilots transmitted in the first data frame. The proposed algorithm exploits the tensor structure by using several unfoldings of the received signal sequentially to obtain estimates of the transmitted symbols and the channel. Simulation results show the tensor gain for the proposed algorithm in addition to the improved channel estimation. Numerical results confirm that the receiver requires the same amount of pilots as the Zero Forcing (ZF) receiver, while having a better symbol error rate (SER) performance and a better channel estimation accuracy.

Coordinates play an essential role in the description of real world objects and physical processes. In robotics, coordinates are used to describe the kinematic structure and the kinematic and dynamic behavior. The description mostly takes place in charts, assigned by the observer of the robotic system. However, it is crucial that the described physical process does not depend on the coordinate choice of the observer. In this work we show the relation between coordinates and manipulability analysis. Manipulability measures are dependent of joint coordinates of the robot and task coordinates in the workspace of the robot. Both relations can be analyzed with tensor geometry. We remove the dependency on joint coordinates through the use of an appropriate metric. With the help of tensor contraction, the resulting induced metric in the workspace can be transformed into a coordinate invariant matrix. After applying eigenvalue decomposition on this matrix, we can visualize the dynamic manipulability of a robot as a coordinate invariant ellipsoid.

Tensor networks are the main building blocks in a wide variety of computational sciences, ranging from many-body theory and quantum computing to probability and machine learning. Here we propose a parallel algorithm for the contraction of tensor networks using probabilistic graphical models. Our approach is based on the heuristic solution of the $\mu$-treewidth deletion problem in graph theory. We apply the resulting algorithm to the simulation of random quantum circuits and discuss the extensions for general tensor network contractions., Comment: 11 pages, 12 figures