Latest ArticlesMachine learning techniques have been widely applied in various fields but still face numerous challenges, including heavy dependence on large-scale training data, limited adaptability to changing environments, concerns regarding data privacy and ownership, and the issue of catastrophic forgetting. The learnware paradigm provides a systematic solution to these challenges, focusing on reusing existing high-quality models to tackle new tasks instead of training models from scratch. The learnware comprises a model and a specification describing its capabilities. Various learnwares are managed by the learnware dock system. Existing studies have shown the effectiveness of this paradigm when learnwares and user tasks share the same feature space. However, in real-world scenarios, the system often lacks models that precisely match the feature space of user’s task. Current work has preliminarily explored the identification and reuse of single learnware in heterogeneous feature spaces. However, the performance of a single heterogeneous learnware is limited and may fall short when addressing the entirety of a user task. While multiple heterogeneous learnwares can complement each other’s capabilities, the key challenge lies in identifying and effectively integrating the localized strengths of different heterogeneous learnwares. We propose a decision tree-like learnware assembly algorithm, which effectively integrates the high-confidence regions of multiple heterogeneous learnwares. Furthermore, to facilitate the effective learnware recommendation, we introduce an identification mechanism based on reuse performance estimation. Experiments demonstrate that even in the absence of models that perfectly match the user’s task, the proposed method can effectively assist the system in recommending potentially useful heterogeneous learnwares and significantly outperform models trained from scratch through tree-like assembly.
With the advent of the big data era, various enterprises and organizations have accumulated massive amounts of data driven by the growing demands for business expansion and information. This data are typically stored in relational databases in structured or semi-structured formats. SQL, as a structured database query language, has long been widely used for data retrieval and processing. It provides professionals with an efficient way to interact with databases, thereby facilitating quicker and more convenient data sharing and analysis. With the exponential advancement of large language models (LLMs), in-context learning (ICL) has shown significant promise for the text-to-SQL task, where LLMs utilize reference examples to accurately generate SQL queries. To fully harness the potential of LLMs through ICL for text-to-SQL, we propose a new SQL generation pipeline comprising three parts: first, we propose a schema enhancement component to strengthen LLMs’ focus on question-related information. Second, we leverage the inherent structure of SQL to preselect semantically similar, aiding in the generation of initial pseudo-SQL queries. Third, a selection strategy is proposed for selecting reference examples, which considers the similarities between the question and the pseudo-SQL structure to enhance the accuracy of the generated SQL queries. We implement an iterative refinement process in both stages, employing a boosting-like mechanism that progressively improves selection until stabilization is achieved. Extensive experiments across various models and datasets demonstrate the effectiveness of our approach.
Visual reinforcement learning has demonstrated enormous potential across a wide range of domains. However, current algorithms still face two core challenges: insufficient generalization capability and low sample efficiency. Due to the limited availability of training data and the diversity and complexity of environments, reinforcement learning agents often become overly reliant on specific features present in the training settings, which hampers their ability to adapt to novel environments. Even minor environmental changes can induce significant alterations in image pixels, thereby affecting the latent representations learned by the agents and ultimately causing their policies to fail. To develop robust representations, we introduce the environment disentangled representation learning (EDRL) algorithm for visual reinforcement learning. It employs a self-supervised framework to extract environment-invariant features, thereby significantly enhancing the agent’s generalization and sample efficiency. Firstly, by employing periodic data augmentation and integrating historical observations, the method simulates complex environmental changes and expands the effective observation range, thus reducing policy biases caused by training instability. Secondly, robust, environment-invariant features are obtained by disentangling latent features and isolating them through reconstruction. Finally, by predicting the changes in representations across time steps and incorporating a dynamic consistency loss, the approach ensures the consistency and robustness of the representations. Experimental results demonstrate the effectiveness of EDRL, as validated on the DMControl generalization benchmark (DMControl-GB) and the distracting control suite (DistractingCS). The results indicate that, compared with state-of-the-art methods, EDRL achieves an average performance improvement of over 15% in complex scenarios on DMControl-GB and over 20% in highly distracting environments on DistractingCS.
Segmenting skin lesions from dermatoscopic images is crucial for the quantitative analysis and early diagnosis of skin cancer. However, automatic segmentation remains challenging due to blurred lesion boundaries, low contrast between lesions and surrounding skin, and the presence of artifacts, all of which complicate the segmentation process. Although the visual state space model based on Mamba architecture demonstrates notable advantages over Transformer models in terms of linear computational complexity and long-range dependency modeling, it still struggles to preserve the topological integrity of segmentation results. To address this issue, a topological prior guided dual-branch vision Mamba network (TDBVM) is proposed. The proposed architecture adopts a dual-encoder design to extract topological priors and deep semantic features independently. In particular, the topology branch incorporates a multi-color space topological component extraction module to generate topological prior maps. These priors are fused with visual features through a multi-scale fusion mechanism, effectively guiding feature learning, enhancing the model’s ability to capture complex lesion boundaries and morphological variations, and suppressing artifacts. Experimental results on ISIC2018, ISIC2017, ISIC2016 and PH2 datasets demonstrate that the proposed method significantly outperforms existing state-of-the-art approaches in terms of both segmentation accuracy and topological structure preservation, showing better segmentation results and robust generalization capability.
While the primary function of computers lies in computation and processing, the core value of the Internet is rooted in sharing and collaboration. Computers create the Internet, and the Internet empowers the value of computers. The rapid development of the Internet, cloud computing, and big data is pushing artificial intelligence into the era of large models (LMs). However, the practical application of LMs is currently hindered by high training costs and deployment complexities, driving a shift toward lightweight, private, and domain-specific models. With the rapid proliferation and wide distribution of heterogeneous models, enabling effective interaction and collaboration among them has emerged as a critical bottleneck that urgently needs to be addressed in LM development. Drawing inspiration from the development of the Internet, we propose the concept, vision, and system architecture of world wide AI-model network (AI-ModelNet). It is a novel paradigm that achieves interconnection, capability sharing, and collaborative reasoning by establishing pathways between models. We first briefly review the current state of single-model and multi-model research. Subsequently, the systemic vision and hierarchical architecture of AI-ModelNet are articulated, followed by validation of the framework’s feasibility through a prototype system and diverse application cases. Finally, key directions for future research are discussed preliminarily.
Blockchain sharding, which divides a blockchain network into multiple shards to process transactions in parallel, is widely considered to be one of the most effective techniques for enhancing blockchain scalability and system performance. However, existing sharding schemes primarily focus on optimizing point-to-point asset transfer transactions and exhibit significant limitations in supporting Turing-complete smart contracts. Since executing the business logic based on Turing-complete smart contracts typically involves initiating multiple internal transactions to synchronize state across shard, designing the schemes of blockchain sharding with smart contract compatibility (BS-SCC) presents significant and unique challenges. Although there are some studies in the literatures, there is still a lack of a systematic survey to review the academic progress and research landscape. This paper provides a comprehensive survey on existing BS-SCC schemes. First, we introduce the research motivation and basic concepts of BS-SCC. Next, we propose a taxonomy of BS-SCC schemes based on the dimensions of transaction execution and state storage, categorizing them into such classes as on-chain and off-chain execution models. Then, we propose a set of criteria for evaluating BS-SCC schemes that encompass reliability, effectiveness, and other performance properties. By employing the proposed criteria, we furthermore conduct a multi-dimensional comparative analysis of existing schemes. Finally, we identify a list of technical bottlenecks and suggest corresponding future research directions to offer theoretical insights and practical guidance for advancing BS-SCC.
Remote direct memory access(RDMA)technology is widely used in high-performance computing and intelligent computing scenarios that require high bandwidth and low latency transmission, offering significant advantages over traditional TCP/IP protocol stacks in terms of bandwidth, efficiency, and latency. It has gradually become an industry consensus for high-speed sensors to access computing networks through RDMA technology. However, deploying RDMA in this scenario faces challenges due to the limited resources of embedded sensor nodes, making it difficult to deploy traditional software stacks. We conduct research on lightweight techniques for embedded RDMA software stacks, proposing a lightweight RDMA connection establishment method based on reliable UDP and a lightweight RDMA driver based on reliable Ethernet under conditions without high-performance CPU or operating system. An ultra-lightweight RDMA software stack suitable for embedded sensor nodes is designed. The experimental results show that the lightweight RDMA software stack for embedded systems can reduce the connection establishment overhead by approximately 94% and the software driver overhead by 84% compared with the standard RDMA software stack. The embedded sensor nodes and standard nodes use RDMA technology to perform sensor data acquisition and reliable transmission through one-level switching, with a system bandwidth of up to 98.04 Gbps, end-to-end latency as low as 4.58 μs, and CPU overhead of standard nodes within the system as low as 4.2%. In terms of protocol compatibility, as the number of queue pairs and data volume increase, the READ and WRITE bandwidths of embedded RDMA nodes can reach the peak performance of standard nodes. Meanwhile, the READ and WRITE latency remains at the microsecond level when the data volume is small.
Integrating C/C++ with assembly language is a common practice in software development, particularly in operating system-level software. However, programming with inline assembly can be more error-prone due to its complex architecture-related details and the lack of compiler checks. Modern software engineering employs static analysis to detect bugs and security vulnerabilities. Nevertheless, analyzing inline assembly poses challenges beyond the capabilities of LLVM IR-based static analysis tools. If the effects of inline assembly on data flow and control flow are not addressed effectively, the result can be a rise in false positives and a decline in precision. We present LASM, an innovative tool that can automatically lift x86 inline assembly code into LLVM IR and integrate it with the IR generated from compiling the C/C++ code. LASM enables downstream static analysis tools to perform whole program analysis on applications containing inline assembly code fragments, thereby reducing false positives and improving precision. It emulates hardware and the semantics of assembly instructions using LLVM IR. By providing optional optimizations that simplify the semantics of atomic instructions and enhance pointer arithmetic semantics, LASM supports static analysis tools more effectively. By completely and accurately emulating assembly instructions, the LLVM IR lifted by LASM can be compiled into an executable program. The strength of LASM lies in its ease of integration; LLVM IR-based static analysis tools can analyze inline assembly code by incorporating it seamlessly into their existing workflows without requiring additional modifications or adaptations to their implementations. LASM facilitates the reuse of many pre-existing tools in the ecosystem. Our experimental results indicate that LASM effectively supports SVF-based static analysis on the Linux kernel. This analysis systematically categorizes global variables based on whether their access occurs during the initialization or post-initialization phase. The results show an impressive 62.03% reduction in misclassifications and an 8.06 percentage point increase in precision. LASM helps to identify 14.80% more protectable variables without introducing new misclassifications. These results highlight LASM’s potential to enhance the effectiveness of static analysis in the presence of inline assembly code.
In modern software development, requirements ambiguity is a key factor that leads to project failure, cost overruns, and quality issues. Therefore, the automatic detection of requirement ambiguity has been extensively studied. Although these methods reduce the time cost of manual review, their solutions are incomplete for the types of ambiguity detection, and it is difficult to fully cover the six types of ambiguity corresponding to language ambiguity. The traditional method lacks the ability of in-depth semantic understanding, logical relationship recognition and quotation/referential relationship recognition, which limits its semantic processing ability and cannot detect pragmatic ambiguity and linguistic error ambiguity. To this end, we propose a large language model-based method called LMAdetect for automatic detection of requirements ambiguity. For a given requirement, LMAdetect analyzes the requirement according to the heuristic rules and the large language model, and classifies the requirement detection into the corresponding ambiguity type. However, large language models often classify different types of ambiguity, and for the classification results of large language models, LMAdetect uses a rule-based algorithm to assign different types of ambiguity to different experts for detection. Finally, the detection results are summarized according to the confidence level, and the classification results with high confidence are output. Experiments on
Large language models (LLM) are increasingly being applied in software engineering, but current automated code generation research primarily focuses on general-purpose functional code, lacking effective solutions for the specific requirements of embedded systems. We propose RD2ESC (requirements documents to embedded system code), a prompt-based fine-tuning method that enables LLMs to understand the complex relationships between embedded code and requirements documents, and constructs a multi-agent collaborative code generation framework capable of rapidly generating high-quality embedded code using requirements documents and reference code. Experimental results demonstrate that RD2ESC improves the Pass@1 metric from 0.15 to 0.71 compared with the GPT-4o baseline model, achieving a test pass rate of 0.75 and compilation pass rate of 0.96. Sensitivity analysis reveals that the method exhibits certain dependency on reference code quality, with Pass@1 declining from 0.68 to 0.47 under 10%~50% perturbation conditions and dropping to 0.25 without reference code, while still maintaining basic code generation capabilities. Ablation experiments confirm the synergistic effects among multi-agents, with the complete system demonstrating significant performance improvements compared with individual components. This research provides an effective technical framework for embedded code automatic generation, substantially enhancing embedded system development efficiency.