Matrix Multiplication Computation Research Articles

Mutually reinforcing non-local neural networks for semantic segmentation

The ability to capture pixels' long-distance interdependence is beneficial to semantic segmentation. In addition, semantic segmentation requires the effective use of pixel-to-pixel similarity in the channel direction to enhance pixel regions. Asymmetric Non-local Neural Networks (ANNet) combine multi-scale spatial pyramidal pooling modules and Non-local blocks to reduce model parameters without sacrificing performance. However, ANNet does not consider pixel similarity in the channel direction in the feature map, so its segmentation effect is not ideal. This article proposes a Mutually Reinforcing Non-local Neural Networks (MRNNet) to improve ANNet. MRNNet consists specifically of the channel enhancement regions module (CERM), and the position-enhanced pixels module (PEPM). In contrast to Asymmetric Fusion Non-local Block (AFNB) in ANNet, CERM does not combine the feature maps of the high and low stages, but rather utilizes the auxiliary loss function of ANNet. Calculating the similarity between feature maps in channel direction improves the category representation of feature maps in the channel aspect and reduces matrix multiplication computation. PEPM enhances pixels in the spatial direction of the feature map by calculating the similarity between pixels in the spatial direction of the feature map. Experiments reveal that our segmentation accuracy for cityscapes test data reaches 81.9%. Compared to ANNet, the model's parameters are reduced by 11.35 (M). Given ten different pictures with a size of 2048 × 1024, the average reasoning time of MRNNet is 0.103(s) faster than that of the ANNet model.

CONNA: Configurable Matrix Multiplication Engine for Neural Network Acceleration

Convolutional neural networks (CNNs) have demonstrated promising results in various applications such as computer vision, speech recognition, and natural language processing. One of the key computations in many CNN applications is matrix multiplication, which accounts for a significant portion of computation. Therefore, hardware accelerators to effectively speed up the computation of matrix multiplication have been proposed, and several studies have attempted to design hardware accelerators to perform better matrix multiplications in terms of both speed and power consumption. Typically, accelerators with either a two-dimensional (2D) systolic array structure or a single instruction multiple data (SIMD) architecture are effective only when the input matrix has shapes that are close to or similar to a square. However, several CNN applications require multiplications of non-squared matrices with various shapes and dimensions, and such irregular shapes lead to poor utilization efficiency of the processing elements (PEs). This study proposes a configurable engine for neural network acceleration, called CONNA, whose computation engine can conduct matrix multiplications with highly utilized computing units, regardless of the access patterns, shapes, and dimensions of the input matrices by changing the shape of matrix multiplication conducted in the physical array. To verify the functionality of the CONNA accelerator, we implemented CONNA as an SoC platform that integrates a RISC-V MCU with CONNA on Xilinx VC707 FPGA. SqueezeNet on CONNA achieved an inference performance of 100 frames per second (FPS) with 2.36 mm2 and 83.55 mW in a 65 nm process, improving efficiency by up to 34.1 times better than existing accelerators in terms of FPS, silicon area, and power consumption.

Invited Tutorial: Analog Matrix Computing With Crosspoint Resistive Memory Arrays

Matrix computation is ubiquitous in modern scientific and engineering fields. Due to the high computational complexity in conventional digital computers, matrix computation represents a heavy workload in many data-intensive applications, e.g., machine learning, scientific computing, and wireless communications. For fast, efficient matrix computations, analog computing with resistive memory arrays has been proven to be a promising solution. In this Tutorial, we present analog matrix computing (AMC) circuits based on crosspoint resistive memory arrays. AMC circuits are able to carry out basic matrix computations, including matrix multiplication, matrix inversion, pseudoinverse and eigenvector computation, all with one single operation. We describe the main design principles of the AMC circuits, such as local/global or negative/positive feedback configurations, with/without external inputs. Mapping strategies for matrices containing negative values will be presented. The underlying requirements for circuit stability will be described via the transfer function analysis, which also defines time complexity of the circuits towards steady-state results. Lastly, typical applications, challenges, and future trends of AMC circuits will be discussed.

Analysis and mitigation of parasitic resistance effects for analog in-memory neural network acceleration

To support the increasing demands for efficient deep neural network processing, accelerators based on analog in-memory computation of matrix multiplication have recently gained significant attention for reducing the energy of neural network inference. However, analog processing within memory arrays must contend with the issue of parasitic voltage drops across the metal interconnects, which distort the results of the computation and limit the array size. This work analyzes how parasitic resistance affects the end-to-end inference accuracy of state-of-the-art convolutional neural networks, and comprehensively studies how various design decisions at the device, circuit, architecture, and algorithm levels affect the system’s sensitivity to parasitic resistance effects. A set of guidelines are provided for how to design analog accelerator hardware that is intrinsically robust to parasitic resistance, without any explicit compensation or re-training of the network parameters.

An improved peak-selection algorithm using block-based recurrence Cholesky decomposition for mesh deformation

An improved peak-selection algorithm is proposed for mesh deformation. With the use of the newly derived block-based recurrence Cholesky (BRC) decomposition scheme, the computational complexity for solving the linear algebraic system in the data reducing procedure is reduced from O(Nc4/Np) to O(Nc3), where Nc denotes the total number of support nodes and Np denotes the number of support nodes added at a time. Because the BRC decomposition scheme introduces block matrices, it involves more multiplications between matrices rather than between vectors. Due to the fact that the computation of matrix multiplication is more efficient with the use of the linear algebraic library, the efficiency for solving the linear algebraic system can be further increased. Two deformation problems are applied to validate the algorithm. The results show that it significantly increases the efficiency for solving the linear algebraic system, allowing the time consumption of this process to be reduced to only one sixth. Moreover, the efficiency will increase with the mesh scale. The results also show that it allows the efficiency of the data reducing procedure to improve by two times. Furthermore, it is found that only 1.094 s in total is required to solve the linear algebraic system with serial computing by constructing a set of as many as 2999 support nodes in a large-scale mesh deformation problem. It is indicated that the bottleneck of mesh deformation caused by inefficient parallel computing for solving the linear algebraic system can thus be removed. This makes the algorithm favorable for large-scale engineering applications.

SAZD: A Low Computational Load Coded Distributed Computing Framework for IoT Systems

Coded distributed computing (CDC) can overcome the problem that the computation of matrix multiplication with an extremely huge dimension cannot be executed in a single Internet-of-Things (IoT) node. All the encoding of existing CDC schemes are based on the linear combination (LC) to generate independent computation tasks, which introduces a heavy computational load, including a significant volume of expensive multiplications (compared with inexpensive additions) and even more expensive divisions to the encoding and decoding phases. Note that the number of elementwise multiplications of the LC operation during the encoding phase is N times that of the original computation task, where N denotes the number of worker nodes. In this article, to avoid expensive multiplications introduced by LC, a fresh new CDC framework based on shift-and-addition (SA) over the real field is proposed. In addition, to avoid the expensive matrix inverse operation (divisions) in the decoding phase, zigzag decoding (ZD) is incorporated. The proposed scheme, which combines SA and ZD and is hence named SAZD-based CDC, avoids expensive multiplications and divisions in both the encoding and decoding phases. It targets the following simultaneous objectives: an arbitrary K out of N generated computation tasks is independent and can recover the original computation tasks with the ZD algorithm, and the shift distance is small so as to cause a light additional computational load in the computation phase. Both analysis and practical study show that compared to the LC-based CDC, the SAZD-based CDC significantly reduces the computational load.

Secure and Efficient Protocol for Outsourcing Large-Scale Matrix Multiplication to the Cloud

Outsourcing computing is an application of cloud computing. It is an important method to solve the problem of client resource limitation. However, outsourcing computing brings security and efficiency challenges. Matrix multiplication computation (MMC) outsourcing has attracted many researchers to carry out research and has achieved many admirable results. Unfortunately, there is still a problem with zero elements of information protection for MMC outsourcing. In this paper, we are motivated to design a protocol, which can protect the private information of the zero elements, for outsourcing MMC to the cloud server. Our proposed protocol not only solves the problem of protecting zero elements information but also has no large client-overhead. The main idea is to add a special matrix to the original matrix for hiding zero elements before transforming the computation task. Then, the cloud server computes the received encryption task and returns the result to the client. Finally, the client decrypts and verifies the result. The experiment verifies the efficiency and practicability of our protocol. The comparison with previous schemes shows that the protocol improves security without much client overhead.

Secure Outsourced Computation of Multiple Matrix Multiplication Based on Fully Homomorphic Encryption

Secure Outsourced Computation of Multiple Matrix Multiplication Based on Fully Homomorphic Encryption

Practical and Secure Outsourcing Algorithms of Matrix Operations Based on a Novel Matrix Encryption Method

With the recent growth and commercialization of cloud computing, outsourcing computation has become one of the most important cloud services, which allows the resource-constrained clients to efficiently perform large-scale computation in a pay-per-use manner. Meanwhile, outsourcing large scale computing problems and computationally intensive applications to the cloud has become prevalent in the science and engineering computing community. As important fundamental operations, large-scale matrix multiplication computation (MMC), matrix inversion computation (MIC), and matrix determinant computation (MDC) have been frequently used. In this paper, we present three new algorithms to enable secure, verifiable, and efficient outsourcing of MMC, MIC, and MDC operations to a cloud that may be potentially malicious. The main idea behind our algorithms is a novel matrix encryption/decryption method utilizing consecutive and sparse unimodular matrix transformations. Compared to previous works, this versatile technique can be applied to many matrix operations while achieving a good balance between security and efficiency. First, the proposed algorithms provide robust confidentiality by concealing the local information of the entries in the input matrices. Besides, they also protect the statistic information of the original matrix. Moreover, these algorithms are highly efficient. Our theoretical analysis indicates that the proposed algorithms reduce the time overhead on the client side from $O(n^{2.3728639})$ to $O(n^{2})$ . Finally, the extensive experimental evaluations demonstrate the practical efficiency and effectiveness of our algorithms.

Memristor-CMOS Analog Coprocessor for Acceleration of High-Performance Computing Applications

Vector matrix multiplication computation underlies major applications in machine vision, deep learning, and scientific simulation. These applications require high computational speed and are run on platforms that are size, weight, and power constrained. With the transistor scaling coming to an end, existing digital hardware architectures will not be able to meet this increasing demand. Analog computation with its rich set of primitives and inherent parallel architecture can be faster, more efficient, and compact for some of these applications. One such primitive is a memristor-CMOS crossbar array-based vector matrix multiplication. In this article, we develop a memristor-CMOS analog coprocessor architecture that can handle floating-point computation. To demonstrate the working of the analog coprocessor at a system level, we use a new electronic design automation tool called PSpice Systems Option, which performs integrated cosimulation of MATLAB/Simulink and PSpice. It is shown that the analog coprocessor has a superior performance when compared to other processors, and a speedup of up to 12 × when compared to projected GPU performance is observed. Using the new PSpice Systems Option tool, various application simulations for image processing and solutions to partial differential equations are performed on the analog coprocessor model.<?enlrg 3pt?>

Cloud outsourcing computing security protocol of matrix multiplication computation based on similarity transformation

With the emergence of the cloud computing paradigm in scientific and business applications, computation outsourcing to the cloud has become a popular application in the age of cloud computing. However, this computing paradigm brings in some new security concerns and challenges, such as input/output privacy and result verifiability. In this paper we use similar transformation of matrix to design secure verifiable and practical outsourcing protocol for matrix multiplication calculation. Compared with those existing outsourcing protocols, our protocol has obvious improvement concerning both efficiency and security. In order to check the correctness of the result returned from the cloud, an efficient verification algorithm is employed. Computational complexity analysis shows that our protocol is highly efficient.

Cloud outsourcing computing security protocol of matrix multiplication computation based on similarity transformation

Cloud outsourcing computing security protocol of matrix multiplication computation based on similarity transformation

New publicly verifiable computation for batch matrix multiplication

With the prevalence of cloud computing, the resource constrained clients are trended to outsource their computation-intensive tasks to the cloud server. Although outsourcing computation paradigm brings many benefits for both clients and cloud server, it causes some security challenges. In this paper, we focus on the outsourcing computation of matrix multiplication, and propose a new publicly verifiable computation scheme for batch matrix multiplication. Different from traditional matrix computation outsourcing model, the outsourcing task of our scheme is to compute MXi for group of clients, where Xi is a private matrix chosen by different clients and M is a public matrix given by a data center beforehand. Based on the two techniques of privacy-preserving matrix transformation and matrix digest, our scheme can protect the secrecy of the client’s private matrix Xi and dramatically reduce the computation cost in both the key generation and the computing phases. Security analysis shows that the proposed scheme can achieve the desired security properties under the co-computational Diffie-Hellman assumption. We also provide the experimental evaluation that demonstrates the efficiency of our scheme.

Privacy preserving, verifiable and efficient outsourcing algorithm for matrix multiplication to a malicious cloud server

AbstractMatrix Multiplication is a basic engineering and scientific problem, which has application in various domains. There exists many cryptographic solutions for secure computation of matrix multiplication, but cryptographic preamble makes them infeasible for outsourcing with large input size to the cloud server. In this paper, we propose a privacy-preserving, verifiable and efficient algorithm for matrix multiplication in outsourcing paradigm illustrated by the following scenario: the client is having a large data-set and needs to perform matrix multiplication, but unable to process due to the lack of computing resources. Therefore, the client outsources the computation to the cloud server. We evaluate the algorithm on security, efficiency and verifiability parameters and discuss the implementation details. The result analysis shows that the algorithm is highly efficient and endorses the practical usability of the algorithm. Using this algorithm, we can mostly replace the costly cryptographic operatio...

Encrypting Controller using Fully Homomorphic Encryption for Security of Cyber-Physical Systems

Abstract: In order to enhance security of cyber-physical systems, it is important to protect the signals from sensors to the controller, and from the controller to the actuator, because the attackers often steal and compromise those signals. One immediate solution could be encrypting the signals, but in order to perform computation in the controller, they should be decrypted before computation and encrypted again after computation. For this, the controller keeps the secret key, which in turn increases vulnerability from the attacker. In this paper, we introduce the fully homomorphic encryption (FHE) , which is an advanced cryptography that has enabled arithmetic operations directly on the encrypted variables without decryption. However, this also introduces several new issues that have not been studied for conventional controllers. Most of all, an encrypted variable has a finite lifespan, which decreases as an arithmetic operation is performed on it. Our solution is to run multiple controllers, and orchestrate them systematically. Also, in order to slow down the decrease of the lifespan, a tree-based computation of sequential matrix multiplication is introduced. We finally demonstrate the effectiveness of the proposed algorithm with quadruple water tank example.

Magnetic Sensor Array-Based AC Current Measurement for Multiconductor Cables Using Evolutionary Computation Method

A novel and accurate AC current measurement method for multiconductor cables is proposed in this paper by employing magnetic sensor arrays and evolutionary algorithms. The positions of several conductors within the electrical cables are determined by the computing method. Then the currents in these conductors can be measured in real time by using a matrix multiplication computation. The mathematical model for estimating conductor currents is investigated considering two configurations, i.e., single conductor and multiconductors in the cable. Evolutionary computation methods are investigated and implemented to improve the computing accuracy. In particular, the performances of a variety of evolutionary algorithms in the current computation are compared. The differential evolution (DE) computation method is found outperforming other methods after conducting numerous simulation studies. Finally, comprehensive experiments are carried out by utilizing the DE method to validate the theoretical studies. The experimental results sufficiently verify the feasibility and reliability of the proposed AC current measurement method for multiconductor cables.

The Nonrecursive Plating Algorithm (NRPA) for Computing the Total Radiative Exchange Factors in Enclosures

Many numerical methods for computing radiation exchange in enclosures are based on the computation of direct exchange areas (DEAs) and total exchange areas (TEAs). Excessively long computation times can be associated with TEAs computation. Among the best performing methods, the plating algorithm (PA) computes TEAs from DEAs based on a set of simple recursive equations. An efficient CPU and GPU parallelization of the PA are represented. Nevertheless, PA computation complexity is O(N 3). A novel formulation, the nonrecursive plating algorithm (NRPA), is introduced. It allows the computation of TEAs with a single nonrecursive step. Its equations are formulated by identification to the PA equations giving TEAs from DEAs, requiring one simple assumption. The NRPA is then written in matrix form as mainly a square matrix multiplication operation. Based on advancement in matrix multiplication computation, the NRPA complexity is proven to be O(N 2.38) for the number of multiplications. CPU and GPU NRPA are implemented based on the optimized linear algebra library BLAS for CPU and cuBLAS for GPU CUDA programs. NRPA is found to highly outperform PA in both CPU and GPU computation times. Finally, a test enclosure is considered and serves to validate the accuracy of the NRPA by comparison to the PA.

Achieving security, robust cheating resistance, and high-efficiency for outsourcing large matrix multiplication computation to a malicious cloud

Computation outsourcing to the cloud has become a popular application in the age of cloud computing. This computing paradigm brings in some new security concerns and challenges, such as input/output privacy and result verifiability. Given that matrix multiplication computation (MMC) is a ubiquitous scientific and engineering computational task, we are motivated to design a protocol to enable secure, robust cheating resistant, and efficient outsourcing of MMC to a malicious cloud in this paper. The main idea to protect the privacy is employing some transformations on the original MMC problem to get an encrypted MMC problem which is sent to the cloud; and then transforming the result returned from the cloud to get the correct result to the original MMC problem. Next, a randomized Monte Carlo verification algorithm with one-sided error is introduced to successfully handle result verification. We analytically show that the proposed protocol is correct, secure, and robust cheating resistant. Extensive theoretical analysis and experimental evaluation also show its high-efficiency and immediate practicability. Finally, comparisons between the proposed protocol and the previous protocols are given to demonstrate the improvements of the proposed protocol.

Efficient edit distance with duplications and contractions

We propose three algorithms for string edit distance with duplications and contractions. These include an efficient general algorithm and two improvements which apply under certain constraints on the cost function. The new algorithms solve a more general problem variant and obtain better time complexities with respect to previous algorithms. Our general algorithm is based on min-plus multiplication of square matrices and has time and space complexities of O (|Σ|MP (n)) and O (|Σ|n2), respectively, where |Σ| is the alphabet size, n is the length of the strings, and MP (n) is the time bound for the computation of min-plus matrix multiplication of two n × n matrices (currently, due to an algorithm by Chan).For integer cost functions, the running time is further improved to . In addition, this variant of the algorithm is online, in the sense that the input strings may be given letter by letter, and its time complexity bounds the processing time of the first n given letters. This acceleration is based on our efficient matrix-vector min-plus multiplication algorithm, intended for matrices and vectors for which differences between adjacent entries are from a finite integer interval D. Choosing a constant , the algorithm preprocesses an n × n matrix in time and space. Then, it may multiply the matrix with any given n-length vector in time. Under some discreteness assumptions, this matrix-vector min-plus multiplication algorithm applies to several problems from the domains of context-free grammar parsing and RNA folding and, in particular, implies the asymptotically fastest time algorithm for single-strand RNA folding with discrete cost functions.Finally, assuming a different constraint on the cost function, we present another version of the algorithm that exploits the run-length encoding of the strings and runs in time and space, where is the length of the run-length encoding of the strings.

HIERARCHICAL MAPPING FOR HPC APPLICATIONS

As the high performance computing systems scale up, mapping the tasks of a parallel application onto physical processors to allow efficient communication becomes one of the critical performance issues. Existing algorithms were usually designed to map applications with regular communication patterns. Their mapping criterion usually overlooks the size of communicated messages, which is the primary factor of communication time. In addition, most of their time complexities are too high to process large scale problems. In this paper, we present a hierarchical mapping algorithm (HMA), which is capable of mapping applications with irregular communication patterns. It first partitions tasks according to their run-time communication information. The tasks that communicate with each other more frequently are regarded as strongly connected. Based on their connectivity strength, the tasks are partitioned into supernodes based on the algorithms in spectral graph theory. The hierarchical partitioning reduces the mapping algorithm complexity to achieve scalability. Finally, the run-time communication information will be used again in fine tuning to explore better mappings. With the experiments, we show how the mapping algorithm helps to reduce the point-to-point communication time for the PDGEMM, a ScaLAPACK matrix multiplication computation kernel, up to 20% and the AMG2006, a tier 1 application of the Sequoia benchmark, up to 7%.