PyTorchKR Papers

최신 논문

총 5,575편
태그·기간 등 상세 필터

카테고리 탐색

로그인 후 이 태그 구독

arXiv:1806.03287공식 코드 · Papers with Code

Slalom: Fast, Verifiable and Private Execution of Neural Networks in Trusted Hardware

As Machine Learning (ML) gets applied to security-critical or sensitive domains, there is a growing need for integrity and privacy for outsourced ML computations. A pragmatic solution comes from Trusted Execution Environments (TEEs), which use hardware and software protections to isolate sensitive computations from the untrusted software stack. However, these isolation guarantees come at a price in performance, compared to untrusted alternatives. This paper initiates the study of high performance execution of Deep Neural Networks (DNNs) in TEEs by efficiently partitioning DNN computations between trusted and untrusted devices. Building upon an efficient outsourcing scheme for matrix multiplication, we propose Slalom, a framework that securely delegates execution of all linear layers in a DNN from a TEE (e.g., Intel SGX or Sanctum) to a faster, yet untrusted, co-located processor. We evaluate Slalom by running DNNs in an Intel SGX enclave, which selectively delegates work to an untrusted GPU. For canonical DNNs (VGG16, MobileNet and ResNet variants) we obtain 6x to 20x increases in throughput for verifiable inference, and 4x to 11x for verifiable and private inference.

arXiv:1804.03243

A GPU-based WFST Decoder with Exact Lattice Generation

We describe initial work on an extension of the Kaldi toolkit that supports weighted finite-state transducer (WFST) decoding on Graphics Processing Units (GPUs). We implement token recombination as an atomic GPU operation in order to fully parallelize the Viterbi beam search, and propose a dynamic load balancing strategy for more efficient token passing scheduling among GPU threads. We also redesign the exact lattice generation and lattice pruning algorithms for better utilization of the GPUs. Experiments on the Switchboard corpus show that the proposed method achieves identical 1-best results and lattice quality in recognition and confidence measure tasks, while running 3 to 15 times faster than the single process Kaldi decoder. The above results are reported on different GPU architectures. Additionally we obtain a 46-fold speedup with sequence parallelism and multi-process service (MPS) in GPU.

arXiv:1806.04226

Physical Representation-based Predicate Optimization for a Visual Analytics Database

Querying the content of images, video, and other non-textual data sources requires expensive content extraction methods. Modern extraction techniques are based on deep convolutional neural networks (CNNs) and can classify objects within images with astounding accuracy. Unfortunately, these methods are slow: processing a single image can take about 10 milliseconds on modern GPU-based hardware. As massive video libraries become ubiquitous, running a content-based query over millions of video frames is prohibitive. One promising approach to reduce the runtime cost of queries of visual content is to use a hierarchical model, such as a cascade, where simple cases are handled by an inexpensive classifier. Prior work has sought to design cascades that optimize the computational cost of inference by, for example, using smaller CNNs. However, we observe that there are critical factors besides the inference time that dramatically impact the overall query time. Notably, by treating the physical representation of the input image as part of our query optimization---that is, by including image transforms, such as resolution scaling or color-depth reduction, within the cascade---we can optimize data handling costs and enable drastically more efficient classifier cascades. In this paper, we propose Tahoma, which generates and evaluates many potential classifier cascades that jointly optimize the CNN architecture and input data representation. Our experiments on a subset of ImageNet show that Tahoma's input transformations speed up cascades by up to 35 times. We also find up to a 98x speedup over the ResNet50 classifier with no loss in accuracy, and a 280x speedup if some accuracy is sacrificed.

arXiv:1806.03925

Gear Training: A new way to implement high-performance model-parallel training

The training of Deep Neural Networks usually needs tremendous computing resources. Therefore many deep models are trained in large cluster instead of single machine or GPU. Though major researchs at present try to run whole model on all machines by using asynchronous asynchronous stochastic gradient descent (ASGD), we present a new approach to train deep model parallely -- split the model and then seperately train different parts of it in different speed.

arXiv:1806.03905

Retinal Optic Disc Segmentation using Conditional Generative Adversarial Network

This paper proposed a retinal image segmentation method based on conditional Generative Adversarial Network (cGAN) to segment optic disc. The proposed model consists of two successive networks: generator and discriminator. The generator learns to map information from the observing input (i.e., retinal fundus color image), to the output (i.e., binary mask). Then, the discriminator learns as a loss function to train this mapping by comparing the ground-truth and the predicted output with observing the input image as a condition.Experiments were performed on two publicly available dataset; DRISHTI GS1 and RIM-ONE. The proposed model outperformed state-of-the-art-methods by achieving around 0.96% and 0.98% of Jaccard and Dice coefficients, respectively. Moreover, an image segmentation is performed in less than a second on recent GPU.

arXiv:1806.05217

Impostor Networks for Fast Fine-Grained Recognition

In this work we introduce impostor networks, an architecture that allows to perform fine-grained recognition with high accuracy and using a light-weight convolutional network, making it particularly suitable for fine-grained applications on low-power and non-GPU enabled platforms. Impostor networks compensate for the lightness of its `backend' network by combining it with a lightweight non-parametric classifier. The combination of a convolutional network and such non-parametric classifier is trained in an end-to-end fashion. Similarly to convolutional neural networks, impostor networks can fit large-scale training datasets very well, while also being able to generalize to new data points. At the same time, the bulk of computations within impostor networks happen through nearest neighbor search in high-dimensions. Such search can be performed efficiently on a variety of architectures including standard CPUs, where deep convolutional networks are inefficient. In a series of experiments with three fine-grained datasets, we show that impostor networks are able to boost the classification accuracy of a moderate-sized convolutional network considerably at a very small computational cost.

arXiv:1806.05363

Fire SSD: Wide Fire Modules based Single Shot Detector on Edge Device

With the emergence of edge computing, there is an increasing need for running convolutional neural network based object detection on small form factor edge computing devices with limited compute and thermal budget for applications such as video surveillance. To address this problem, efficient object detection frameworks such as YOLO and SSD were proposed. However, SSD based object detection that uses VGG16 as backend network is insufficient to achieve real time speed on edge devices. To further improve the detection speed, the backend network is replaced by more efficient networks such as SqueezeNet and MobileNet. Although the speed is greatly improved, it comes with a price of lower accuracy. In this paper, we propose an efficient SSD named Fire SSD. Fire SSD achieves 70.7mAP on Pascal VOC 2007 test set. Fire SSD achieves the speed of 30.6FPS on low power mainstream CPU and is about 6 times faster than SSD300 and has about 4 times smaller model size. Fire SSD also achieves 22.2FPS on integrated GPU.

arXiv:1806.05482

Morphological and Language-Agnostic Word Segmentation for NMT

The state of the art of handling rich morphology in neural machine translation (NMT) is to break word forms into subword units, so that the overall vocabulary size of these units fits the practical limits given by the NMT model and GPU memory capacity. In this paper, we compare two common but linguistically uninformed methods of subword construction (BPE and STE, the method implemented in Tensor2Tensor toolkit) and two linguistically-motivated methods: Morfessor and one novel method, based on a derivational dictionary. Our experiments with German-to-Czech translation, both morphologically rich, document that so far, the non-motivated methods perform better. Furthermore, we iden- tify a critical difference between BPE and STE and show a simple pre- processing step for BPE that considerably increases translation quality as evaluated by automatic measures.

arXiv:1806.03583공식 코드 · Papers with Code

IVUS-Net: An Intravascular Ultrasound Segmentation Network

IntraVascular UltraSound (IVUS) is one of the most effective imaging modalities that provides assistance to experts in order to diagnose and treat cardiovascular diseases. We address a central problem in IVUS image analysis with Fully Convolutional Network (FCN): automatically delineate the lumen and media-adventitia borders in IVUS images, which is crucial to shorten the diagnosis process or benefits a faster and more accurate 3D reconstruction of the artery. Particularly, we propose an FCN architecture, called IVUS-Net, followed by a post-processing contour extraction step, in order to automatically segments the interior (lumen) and exterior (media-adventitia) regions of the human arteries. We evaluated our IVUS-Net on the test set of a standard publicly available dataset containing 326 IVUS B-mode images with two measurements, namely Jaccard Measure (JM) and Hausdorff Distances (HD). The evaluation result shows that IVUS-Net outperforms the state-of-the-art lumen and media segmentation methods by 4% to 20% in terms of HD distance. IVUS-Net performs well on images in the test set that contain a significant amount of major artifacts such as bifurcations, shadows, and side branches that are not common in the training set. Furthermore, using a modern GPU, IVUS-Net segments each IVUS frame only in 0.15 seconds. The proposed work, to the best of our knowledge, is the first deep learning based method for segmentation of both the lumen and the media vessel walls in 20 MHz IVUS B-mode images that achieves the best results without any manual intervention. Code is available at https://github.com/Kulbear/ivus-segmentation-icsm2018

arXiv:1806.06144공식 코드 · Papers with Code

Kernel machines that adapt to GPUs for effective large batch training

Modern machine learning models are typically trained using Stochastic Gradient Descent (SGD) on massively parallel computing resources such as GPUs. Increasing mini-batch size is a simple and direct way to utilize the parallel computing capacity. For small batch an increase in batch size results in the proportional reduction in the training time, a phenomenon known as linear scaling. However, increasing batch size beyond a certain value leads to no further improvement in training time. In this paper we develop the first analytical framework that extends linear scaling to match the parallel computing capacity of a resource. The framework is designed for a class of classical kernel machines. It automatically modifies a standard kernel machine to output a mathematically equivalent prediction function, yet allowing for extended linear scaling, i.e., higher effective parallelization and faster training time on given hardware. The resulting algorithms are accurate, principled and very fast. For example, using a single Titan Xp GPU, training on ImageNet with $1.3\times 10^6$ data points and $1000$ labels takes under an hour, while smaller datasets, such as MNIST, take seconds. As the parameters are chosen analytically, based on the theoretical bounds, little tuning beyond selecting the kernel and the kernel parameter is needed, further facilitating the practical use of these methods.

arXiv:1806.05626공식 코드 · Papers with Code

NCRF++: An Open-source Neural Sequence Labeling Toolkit

This paper describes NCRF++, a toolkit for neural sequence labeling. NCRF++ is designed for quick implementation of different neural sequence labeling models with a CRF inference layer. It provides users with an inference for building the custom model structure through configuration file with flexible neural feature design and utilization. Built on PyTorch, the core operations are calculated in batch, making the toolkit efficient with the acceleration of GPU. It also includes the implementations of most state-of-the-art neural sequence labeling models such as LSTM-CRF, facilitating reproducing and refinement on those methods.

arXiv:1806.00187공식 코드 · Papers with Code

Scaling Neural Machine Translation

Sequence to sequence learning models still require several days to reach state of the art performance on large benchmark datasets using a single machine. This paper shows that reduced precision and large batch training can speedup training by nearly 5x on a single 8-GPU machine with careful tuning and implementation. On WMT'14 English-German translation, we match the accuracy of Vaswani et al. (2017) in under 5 hours when training on 8 GPUs and we obtain a new state of the art of 29.3 BLEU after training for 85 minutes on 128 GPUs. We further improve these results to 29.8 BLEU by training on the much larger Paracrawl dataset. On the WMT'14 English-French task, we obtain a state-of-the-art BLEU of 43.2 in 8.5 hours on 128 GPUs.

arXiv:1805.09300공식 코드 · Papers with Code

SNIPER: Efficient Multi-Scale Training

We present SNIPER, an algorithm for performing efficient multi-scale training in instance level visual recognition tasks. Instead of processing every pixel in an image pyramid, SNIPER processes context regions around ground-truth instances (referred to as chips) at the appropriate scale. For background sampling, these context-regions are generated using proposals extracted from a region proposal network trained with a short learning schedule. Hence, the number of chips generated per image during training adaptively changes based on the scene complexity. SNIPER only processes 30% more pixels compared to the commonly used single scale training at 800x1333 pixels on the COCO dataset. But, it also observes samples from extreme resolutions of the image pyramid, like 1400x2000 pixels. As SNIPER operates on resampled low resolution chips (512x512 pixels), it can have a batch size as large as 20 on a single GPU even with a ResNet-101 backbone. Therefore it can benefit from batch-normalization during training without the need for synchronizing batch-normalization statistics across GPUs. SNIPER brings training of instance level recognition tasks like object detection closer to the protocol for image classification and suggests that the commonly accepted guideline that it is important to train on high resolution images for instance level visual recognition tasks might not be correct. Our implementation based on Faster-RCNN with a ResNet-101 backbone obtains an mAP of 47.6% on the COCO dataset for bounding box detection and can process 5 images per second during inference with a single GPU. Code is available at https://github.com/MahyarNajibi/SNIPER/.

arXiv:1803.06333

Snap ML: A Hierarchical Framework for Machine Learning

We describe a new software framework for fast training of generalized linear models. The framework, named Snap Machine Learning (Snap ML), combines recent advances in machine learning systems and algorithms in a nested manner to reflect the hierarchical architecture of modern computing systems. We prove theoretically that such a hierarchical system can accelerate training in distributed environments where intra-node communication is cheaper than inter-node communication. Additionally, we provide a review of the implementation of Snap ML in terms of GPU acceleration, pipelining, communication patterns and software architecture, highlighting aspects that were critical for achieving high performance. We evaluate the performance of Snap ML in both single-node and multi-node environments, quantifying the benefit of the hierarchical scheme and the data streaming functionality, and comparing with other widely-used machine learning software frameworks. Finally, we present a logistic regression benchmark on the Criteo Terabyte Click Logs dataset and show that Snap ML achieves the same test loss an order of magnitude faster than any of the previously reported results, including those obtained using TensorFlow and scikit-learn.

arXiv:2610.15965v1cs.LG

반복 데이터 사전학습 스케일링: 배치 크기, 정규화 및 GPU-시간 트레이드오프

Scaling Repeated-Data Pretraining: Batch Size, Regularization, and GPU-Time Tradeoffs

본 연구에서는 연산량은 풍부하지만 고유한 학습(training) 데이터가 유한하여 동일한 데이터에 대한 반복 학습이 필요한 환경에서의 사전학습(pre-training)을 다룹니다. 먼저 무한 연산량 사전학습(Kim et al. 2026)을 재검토하여, 그 프론티어가 기존에 고정되었거나 개별적으로만 연구되었던 선택 사항들에 결정적으로 의존함을 보입니다. 특히 에포크(epoch) 수와 함께 배치(batch) 크기를 최적화하면 검증 손실(validation loss)과 배치 크기 사이에 U자형 관계가 나타나 일반적인 사전학습보다 더 작은 배치를 선호하게 됨을 밝히며, 이는 소배치 그래디언트(gradient) 노이즈가 암묵적 정규화(implicit regularization)를 제공하기 때문인 것으로 보입니다. 나아가 기존에 단일 패스 가정 하에서 최적화되었던 학습 레시피를 조정할 수 있음을 확인했습니다. 예를 들어 에포크마다 문서를 새로운 시퀀스로 재패킹하는 것, 가중치 공유(weight tying), 그리고 양의 임베딩 가중치 감쇠(positive embedding weight decay) 등이 있습니다. 이후 무한 연산량 가정을 완화합니다. 특히 일반적인 경우보다 작은 배치 크기는 지나치게 긴 순차적 학습 시간을 요구할 수 있으므로, GPU와 시간을 별개의 자원으로 다루어야 할 필요성이 발생합니다. 마감 기한이 촉박할수록 더 큰 배치가 유리하며, 지연 시간 중심의 병렬 처리를 통해 추가 GPU를 투입하여 학습 시간을 단축할 수 있습니다. 그럼에도 불구하고 고정된 시간 예산 내에서도 더 적은 수의 GPU와 작은 배치를 사용하는 것이 더 많은 GPU와 큰 배치를 사용하는 것보다 더 낮은 검증 손실을 달성할 수 있으며, 이는 마감 기한 내에서 GPU 활용도를 극대화하기 위해 데이터 병렬 처리를 늘리는 일반적인 관행에 도전합니다. 종합적으로 본 연구 결과는 반복 데이터 학습에서 충분히 탐구되지 않았던 요인들을 식별하고, 단일 패스 사전학습 대비 학습 레시피와 자원 할당이 어떻게 변화해야 하는지에 대한 구체적인 지침을 제공합니다.

arXiv:2610.15730v1cs.LG

시간적 그래프 신경망을 위한 의존성 인식 다중 GPU 학습 프레임워크

A Dependency-Aware Multi-GPU Training Framework for Temporal Graph Neural Networks

시간적 그래프 신경망(TGNN)은 많은 동적 그래프 학습 작업에서 우수한 성능을 달성한다. 이러한 모델은 노드 상태 벡터(즉, 메모리)를 사용하여 그래프 변화(즉, 이벤트)를 포착하고 기록한 뒤, 이 메모리를 활용하여 예측을 돕는다. 그러나 이러한 메모리 중심 설계는 다중 GPU 학습을 어렵게 만드는데, 이는 이후 이벤트에 대한 예측이 종종 이전 이벤트의 메모리 업데이트에 의존하기 때문이다. 모델 품질을 유지하기 위해 기존의 다중 GPU TGNN 학습 기법들은 모든 이벤트 의존성을 엄격하게 보존하는데, 이는 병렬성을 제한하고 비용이 큰 GPU 간 메모리 동기화를 야기한다. 본 연구에서는 이러한 의존성 중 다수를 학습 품질을 저해하지 않으면서도 더 유연하게 처리할 수 있다는 점을 관찰하였다. 구체적으로, (a) TGNN 학습의 의존성은 시간 및 그래프 토폴로지 측면에서 높은 지역성(locality)을 가지며, (b) 큰 배치 내에서 놓치는 단거리 의존성은 대개 저비용으로 복구할 수 있고, (c) 많은 메모리 업데이트는 즉시 필요하지 않다. 이러한 관찰을 바탕으로, 우리는 세 가지 기법을 통해 다중 GPU TGNN 학습을 가속화하는 DepBloom을 제안한다: (1) 불필요한 GPU 간 동기화를 줄이고 병렬성을 향상시키는 시간적으로 제한된 공간 분할(temporally bounded spatial partitioning); (2) 확대된 배치 내에서 놓친 단거리 시간적 의존성을 복구하는 배치 내 메모리 보정(intra-batch memory refinement); (3) 다중 GPU 파이프라인 실행 중 긴급한 메모리 업데이트를 우선 처리하고 비핵심 작업을 지연시키는 critical-path 최적화(critical-path optimization). 대표적인 모델들과 다양한 데이터셋에 대한 실험 결과, DepBloom은 최신 기법(state-of-the-art methods) 대비 평균 2.84배, 최대 5.16배의 속도 향상을 달성하면서도 동등하거나 더 나은 모델 정확도를 유지함을 보여준다.

arXiv:2610.13708v1cs.AI

Adaptive DHiSparse: 부하 적응형(Load-Adaptive) KV 계층 구조에서의 추측 디코딩(Speculative Decoding)

Adaptive DHiSparse: Speculative Decoding over a Load-Adaptive KV Hierarchy

롱 컨텍스트(long-context) 서빙은 하드웨어가 유효 처리량(throughput)에 도달하기 전에 KV 메모리가 먼저 소진된다. HiSparse는 히스토리를 호스트 메모리에 저장하고 선택된 항목만 가져오지만, 모든 로드(load)에서 단일 캐시 예산(budget)을 사용하며 DSpark 및 DFlash2와 같은 드래프트 모델(draft-model) 추측 디코딩(speculative decoding)을 처리하지 못한다. 우리는 계층적 희소(hierarchical sparse) KV 위에서 추측 디코딩을 지원하고 상주(residency)를 부하(load)에 맞춰 적응시키는 Adaptive DHiSparse를 제시한다. 이 방법은 필요한 작업 집합(working set)을 보호하고, GPU 메모리가 여유 있을 때 추가 히스토리를 유지하며, 나머지는 정확한 융합 검색(fused retrieval)을 통해 복구한다. DSpark와 DFlash2는 각자의 제안(proposal) 및 수락(acceptance) 규칙을 그대로 유지한다: 쿼리는 누락된 행(missing-row) 검색을 공유하고, 드래프트 KV는 윈도우 경계(window-bounded) 링을 사용하며, 검증(verification) 스테이징은 층(layer) 그룹 간에 재사용된다. 100K 컨텍스트와 동시성(concurrency) 128에서, DFlash2를 사용한 GLM-5.3은 디코드 GPU당 793 출력 토큰(token)/s를 달성하며, 이는 HiSparse의 1.45배, 추측 디코딩을 사용하지 않는 적응형 서빙의 1.27배이다. HiSparse와 동일한 지연 시간(latency) 한계를 유지할 때, 이 방법은 동시성을 최대 4배까지, 출력을 토큰당 한계에 따라 2.3배에서 3.7배까지 유지한다. 500K 컨텍스트와 동시성 512에서 DeepSeek-V4.1-Flash에 대해, DSpark를 사용한 Adaptive DHiSparse는 DSpark를 사용한 상주(resident) 서빙의 출력보다 1.85배 높은 출력을 달성한다. 로드 단계(load step)에서, 선택적 상주(residency)는 저부하 상황에서 호스트 페치(fetch) 비율을 선택된 행의 14.2%에서 1.4%로 줄이고, 압박(pressure) 상황에서는 메모리를 해제한다.

arXiv:2610.13382v1cs.LG

BLOKS: 스케치된 블록 전처리를 통한 커널 솔버의 스케일링

BLOKS: Scaling Kernel Solvers with Sketched Block Preconditioning

커널 리지 회귀(Kernel Ridge Regression, KRR)는 비매개변수적 학습(nonparametric learning)을 위한 이론적으로 타당한 알고리즘이며, 심층 학습(deep learning)의 특성을 연구하는 데에도 자주 사용된다. 그러나 정확한(exact) KRR 수식은 대규모 데이터셋(dataset)에 적용할 수 없을 정도의 시간 및 메모리 비용을 발생시키며, 이는 근사 솔버(approximate solver) 개발의 동기가 되었다. 이러한 알고리즘들은 (i) 직접적인 해법의 계산 부담을 피하기 위한 반복적 방법(iterative method), (ii) 문제 크기를 줄이기 위한 스케칭(sketching) 또는 배치화(batching), (iii) 수렴(convergence)을 가속화하기 위한 전처리(preconditioning)에 의존한다. 빠른 수렴을 위해 필수적이지만, 전처리는 메모리 비용을 발생시키며, 이는 모델(model)의 자유 매개변수 수를 줄임으로써 관리할 수 있으나 그 대가로 표현력, 나아가 정확도가 저하될 수 있다. 이러한 문제를 해결하기 위해, 우리는 블록 자코비(Jacobi) 근사와 스케칭을 결합한 새로운 프리컨디셔너(preconditioner)를 중심으로 구축된, Nyström 방식으로 스케치된 KRR을 위한 컨주게이트 그래디언트(Conjugate Gradient) 기반 솔버인 BLOKS를 제안한다. BLOKS의 프리컨디셔너는 데이터셋 크기와 매개변수 수 모두와 무관한 메모리 비용을 가지므로, 대규모 모델로의 스케일링(scaling)이 가능하다. 우리는 메모리 효율적이고 GPU로 가속화된 구현을 제공하며, BLOKS가 우수한 시간/메모리 복잡도를 유지하면서도 뛰어난 정확도를 달성함을 보인다. 실제로, 커널 솔버를 벤치마킹(benchmark)하는 데 사용되는 표준 대규모 데이터셋에서 BLOKS는 최신(state-of-the-art) 기법들과 비교할 만하거나 그보다 더 나은 성능을 달성한다.

arXiv:2610.10959v1cs.CV

이미지 데이터의 위상학적 분석을 위한 지속성 호몰로지 연산의 GPU 가속화

GPU-Accelerated Computation of Persistent Homology for Topological Analysis of Image Data

최근 몇 년 동안 지속성 호몰로지(persistent homology)는 심층 학습(deep learning)에서 빠르게 도입되었으나, 그 연산 과정은 네트워크 학습(training)에서 여전히 주요한 병목점으로 남아 있습니다. 본 논문에서는 2D 및 3D 이미지로부터 유도된 큐비컬 복합체(cubical complex)의 지속성 다이어그램(persistence diagram)을 계산하는 GPU 스트리밍 파이프라인인 TopoGPU를 소개합니다. TopoGPU는 입력 이미지를 청크 단위로 스트리밍하여 GPU 블록 그리드 상의 대규모 병렬 GPU 커널로 각 청크를 처리하며, 그 결과로 얻어지는 경계 관계는 호스트 메모리에 누적되어 CPU가 경계 행렬 축약(boundary matrix reduction)을 수행합니다. TopoGPU는 스트리밍 환경에서도 지속성 호몰로지를 증명 가능하게 보존하는 계층화 인식 이산 모스 매칭(stratification-aware discrete Morse matching)을 도입하고, GPU 상에서 모스 경계를 도출하기 위한 병렬 위상 정렬 알고리즘 및 병렬 V-경로 패리티(V-path parity) 알고리즘을 함께 제안합니다. TopoGPU는 평가된 모든 벤치마크에서 지속성 호몰로지 계산의 최신 기법인 Cubical Ripser를 능가하여 평균 53.24배, 최대 198.01배의 엔드투엔드 속도 향상을 달성했습니다. 나아가 TopoGPU를 위상 보존 딥 네트워크에 통합하여, 네트워크 학습 중 지속성 호몰로지 연산 비용을 대폭 줄일 수 있음을 입증했습니다. TopoGPU는 오픈 소스로 제공되며, 사전 빌드된 바이너리, Google Colab 노트북 및 Docker 이미지는 프로젝트 GitHub 페이지(https://github.com/seravee08/GPU-Computation-of-Persistent-Homology-for-Image-Data)에서 이용할 수 있습니다.

arXiv:2610.10924v1cs.AR

에뮬레이션 텐서-메모리 평형(TME) 모델에서 누락된 네 번째 항: 잔차 분해 비용

The Missing Fourth Term for the Emulation Tensor Memory Equilibrium (TME) Model: The Residue Deconstruction Cost

"FP8 is All You Need (Part 1)"의 텐서-메모리 평형(Tensor-Memory Equilibrium, TME) 모델은 fp64에 대한 Ozaki Scheme II 에뮬레이션의 실행 시간을 텐서 코어 항과 고대역폭 메모리(HBM) 트래픽 항 중 더 큰 값에 출력당 재구성(reconstruction) 항을 더한 값으로 계산한다. 그러나 이 모델은 입력당 분해(deconstruction) 비용을 누락하고 있다: 스트리밍되는 모든 fp64 피연산자는 행렬 곱셈이 실행되기 전에 SIMT 파이프에서 스케일링, 라운딩, 그리고 $r$개의 모듈러스(moduli) 각각에 대한 모듈로 축소(modulo reduction)를 거쳐야 한다. 이 노트에서는 이 네 번째 항을 추가하고, cuBLAS 에뮬레이션 경로로부터 그 상수를 보정(calibrate)하며, 텐서 코어 처리량과 무관하게 에뮬레이션이 네이티브 fp64 성능에 도달할 수 없는 연산 강도(operational intensity) 임계값을 $\mathrm{OI}^{*} = c_q r P_{\mathrm{fp64}}/(8P_{\mathrm{int}})$라는 닫힌 형태(closed-form)로 도출한다. NVIDIA B300 GPU에서 이 임계값은 $\mathrm{OI}^{*}\approx 0.56$ FLOP/B이다. 그 결과, 원 논문이 가속 대상으로 주장하는 메모리 바운드 커널인 GEMV, SpMV, 그리고 저배치(low-batch) GEMV는 네이티브 성능의 0.3~0.9배로 제한되며, 7점 스텐실(stencil)은 주장된 3.1배가 아닌 1.8배에 그친다. 예상대로 밀집(dense) GEMM은 영향을 받지 않는다. 또한 우리는 잔차(residue)를 미리 계산하여 저장하는 방식이 동일한 비용을 대역폭 항으로 이전시킨다는 것을 보이며, 이 경계(bound)를 무효화하기 위해 구현이 달성해야 하는 명령어 수(instruction count)를 제시한다.