BZBei Zhou

Bei Zhou

*This is an algorithmically generated author record based on publicly available information.

Current Organizations / Institutes

The organizations/institutes from the scholar's latest article


Bei Zhou has a total of 42 co-authors. Here are the top co-authors by number of shared publications:


Latest Publications

  • MQNN: Multi‐Block Quantum Neural Networks for Radar Echo Signal Recognition of Unmanned Aerial Vehicles

    by Wenxia Wang, Fudong Liu, Weilong Wang, Chuanbing Han, Zhili Qin, Bei Zhou, Yizhen Huang, Yifan Hou, Xiaodong Ding, Jinchen Xu, et al.

    Quantum neural networks (QNNs) have made significant progress in theoretical research, yet their application to real‐world tasks remains highly challenging. To handle complex signal classification tasks and reduce the impact of decoherence effects on real quantum devices, it is necessary to study a QNN that both supports multi‐dimensional input features and has small‐scale quantum circuits. Based on the theoretical derivation of the unitary invariance of matrix operations, this paper proposes a novel multi‐block quantum neural network(MQNN), which supports direct rotational encoding of multi‐dimensional features. MQNN combines multiple small‐scale quantum circuits to replace the quantum operations of large quantum circuits, and collaboratively processes multi‐dimensional features to complete the classification task. MQNN is applied to the real collected dataset of radar echo signals from unmanned aerial vehicles(UAVs). The 64‐dimensional Doppler spectrum features extracted from the dataset can be simultaneously rotationally encoded into 64 qubits of the MQNN. Compared with five quantum machine learning algorithms (QSVM, QKNN, QCNN, QNNC, and QNNS), MQNN has the highest accuracy. Moreover, MQNN also has a smaller quantum circuit scale than the amplitude encoded quantum methods, thus it has a stronger anti‐decoherence ability. MQNN provides a useful reference for other quantum algorithms in processing multi‐dimensional data.

  • Open Access

    QEMOS: a scalable quantum error mitigation method to overcome qubit sensitivity

    by Zheng Tu, Jinchen Xu, Xin Zhou, Yu Zhu, Yi Liu, Qiming Du, Hang Lian, Bei Zhou

    Compared with traditional computers, quantum computers can provide exponential acceleration for certain critical fields. However, the coupling of quantum systems with the environment, along with the intrinsic characteristics of quantum systems, has collectively introduced quantum noise, which has emerged as a significant impediment to the development of quantum computing. Quantum error mitigation (QEM) has been proposed as an alternative solution in the noisy intermediate-scale quantum era. In recent years, with the rise of artificial intelligence, machine learning-based QEM technology has received attention from the industry. However, the latest machine learning-based QEM techniques have limitations, especially their inability to mitigate errors in the quantum circuits whose number of qubits exceeds the number of qubits in the training set, and their tendency to amplify noise when constructing feature sets. This paper proposes QEMOS, a novel random forest-based machine learning model that utilizes a new feature dataset incorporating quantum computer backend properties, with feature dimensionality reduction enabling decoupling from the number of qubits. The model is trained and tested using six different simulators from Qiskit and a real quantum computer tianyan-176. It is worth noting that this model overcomes the limitation of sensitivity to the number of qubits, which was the main problem of previous methods. When trained on 5–9 qubit circuits, the model achieves a probability of correct mitigation of 86.38% on 2–13 qubit circuits, though this efficacy is observed primarily for circuits exhibiting high-probability outputs and decreases as all output probabilities approach zero. Compared to the baseline, the model demonstrates a 31.74% error reduction on test sets with more qubits than the training set. On real quantum computer, testing shows an average error reduction of 67.5%.


  • Lightweight Quantum Neural Networks Intelligent Generation

    by Wenxia Wang, Jinchen Xu, Fudong Liu, Bei Zhou, Weilong Wang, Hanyun Wang, Qiming Du, Benzheng Yuan, Yizhen Huang, Yifan Hou, et al.

    The decoherence effect of the real quantum computer poses a significant challenge for designing quantum neural networks (QNN), which requires simultaneous consideration of model performances and parameterized quantum circuit (PQC) scales. In this paper, a method for the intelligent generation of lightweight QNN is proposed, which utilizes the parameters of quantum chips such as topology and relaxation time to assist the automatic design of QNNs. Combining the mixture expert mechanism with the Hyperband algorithm, a Mixture of Hyperband Experts for QNN is proposed to search for combinations of hyperparameters that meet multi‐objective requirements from the lightweight QNN. To the best of the authors’ knowledge, this is the first work that combines quantum chip capabilities to intelligently generate lightweight QNNs. Experiments are carried out on datasets in the fields of medicine and information security, and compared with classical machine learning algorithms and quantum machine learning algorithms (QSVM, QKNN, Intelligent Generation for QNN), the QNN automatically generated by this method has good performance and scalability, and the PQC has a smaller scale. The anti‐coherence capability of the QNN intelligently generated by this method is verified using experiments on a real quantum computer.


  • PESA: error sensitivity analysis tool for floating-point computational programs

    by Mengqi Cui, Jinchen Xu, Yuchang Zhou, Hongru Yang, Liguang Ji, Bei Zhou


  • Open Access

    AutoFPIR: A Automatic Conversion Tool for Floating-point Program to Equivalent Intermediate Representation

    by Yuchang Zhou, Ping Zhang, Jinchen Xu, Bei Zhou, Mengqi Cui, Hongru Yang, Liguang Ji, Jianing Zhang

  • Open Access

    Arfa: An Agile Regime-Based Floating-Point Optimization Approach for Rounding Errors

    by Jinchen Xu, Mengqi Cui, Fei Li, Zuoyan Zhang, Hongru Yang, Bei Zhou, Jie Zhao

    We introduce a floating-point (FP) error optimization approach called Arfa that partitions the domain D of an FP expression fe into regimes and rewrites fe in each regime where fe shows larger errors. First, Arfa seeks a rewrite substitution fo with lower errors across D, whose error distribution is plotted for effective regime inference. Next, Arfa generates an incomplete set of ordered rewrite candidates within each regime of interest, so that searching for the best rewrite substitutions is performed efficiently. Finally, Arfa selects the best rewrite substitution by inspecting the errors of top ranked rewrite candidates, with enhancing precision also considered. Experiments on 56 FPbench examples and four real-life programs show that Arfa not only reduces the maximum and average errors of fe by 4.73 and 2.08 bits on average (and up to 33 and 16 bits), but also exhibits lower errors, sometimes to a significant degree, than Herbie and NumOpt.


  • Open Access

    A Holistic Approach to Automatic Mixed-Precision Code Generation and Tuning for Affine Programs

    by Jinchen Xu, Guanghui Song, Bei Zhou, Fei Li, Jiangwei Hao, Jie Zhao

    Reducing floating-point (FP) precision is used to trade the quality degradation of a numerical program's output for performance, but this optimization coincides with type casting, whose overhead is undisclosed until a mixed-precision code version is generated. This uncertainty enforces the decoupled implementation of mixed-precision code generation and autotuning in prior work. In this paper, we present a holistic approach called PrecTuner that consolidates the mixed-precision code generator and the autotuner by defining one parameter. This parameter is first initialized by some automatically sampled values and used to generate several code variants, with various loop transformations also taken into account. The generated code variants are next profiled to solve a performance model formulated using the aforementioned parameter, possibly under a pre-defined quality degradation budget. The best-performing value of the defined parameter is finally predicted without evaluating all code variants. Experimental results of the PolyBench benchmarks on CPU demonstrate that PrecTuner outperforms LuIs by 3.28× while achieving smaller errors, and we also validate its effectiveness in optimizing a real-life large-scale application. In addition, PrecTuner also obtains a mean speedup of 1.81× and 1.52×-1.73× over Pluto on single- and multi-core CPU, respectively, and 1.71× over PPCG on GPU.


  • SCR-LIBM: A Correctly Rounded Elementary Function Library in Double-Precision

    by Yang Qu, Jinchen Xu, Bei Zhou, Jiangwei Hao, Fei Li, Zuoyan Zhang

    The MPFR and CR-LIBM math libraries are frequently utilized due to their ability to generate correctly rounded results for all double-precision inputs. However, it is worth noting that MPFR has a slower average performance, while CR-LIBM achieves correct rounding over two iterations, rendering it less stable. In addition, CR-LIBM has a poor performance in handling the worst-case of correct rounding. This paper implements a correctly rounded elementary function library called SCR-LIBM in double-precision, which is stable and efficient. Our key idea is to divide subdomains and use the low-degree Taylor polynomial to approximate the elementary function in each subdomain. We simulate the high-precision representation based on the double–double data format, and use the error-free transformation and Double-double algorithm to control the error in the process of polynomial approximation and output compensation. Our approach ensures that the elementary function is correctly rounded, without the need for redundant iterations. The experimental evaluation shows that the average performance of elementary functions implemented in SCR-LIBM is 8.534 times faster than that of MPFR, and 2.492 times faster than that of CR-LIBM when dealing with the worst-case of correct rounding. What’s more, our SCR-LIBM is more stable than CR-LIBM.

  • Hierarchical search algorithm for error detection in floating-point arithmetic expressions

    by Zuoyan Zhang, Jinchen Xu, Jiangwei Hao, Yang Qu, Haotian He, Bei Zhou


  • Open Access

    Detecting Floating‐Point Expression Errors Based Improved PSO Algorithm

    by Hongru Yang, Jinchen Xu, Jiangwei Hao, Zuoyan Zhang, Bei Zhou

    The use of floating‐point numbers inevitably leads to inaccurate results and, in certain cases, significant program failures. Detecting floating‐point errors is critical to ensuring that floating‐point programs outputs are proper. However, due to the sparsity of floating‐point errors, only a limited number of inputs can cause significant floating‐point errors, and determining how to detect these inputs and to selecting the appropriate search technique is critical to detecting significant errors. This paper proposes characteristic particle swarm optimization (CPSO) algorithm based on particle swarm optimization (PSO) algorithm. The floating‐point expression error detection tool PSOED is implemented, which can detect significant errors in floating‐point arithmetic expressions and provide corresponding input. The method presented in this paper is based on two insights: (1) treating floating‐point error detection as a search problem and selecting reliable heuristic search strategies to solve the problem; (2) fully utilizing the error distribution laws of expressions and the distribution characteristics of floating‐point numbers to guide the search space generation and improve the search efficiency. This paper selects 28 expressions from the FPBench standard set as test cases, uses PSOED to detect the maximum error of the expressions, and compares them to the current dynamic error detection tools S3FP and Herbie. PSOED detects the maximum error 100% better than S3FP, 68% better than Herbie, and 14% equivalent to Herbie. The results of the experiments indicate that PSOED can detect significant floating‐point expression errors.