Upload 17 files

code : Add MalConv code

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+paper/1710.09435v1.pdf filter=lfs diff=lfs merge=lfs -text
+paper/2012.09390v1.pdf filter=lfs diff=lfs merge=lfs -text

Reference/ember-malconv/README.md

@@ -0,0 +1,36 @@
+This directory is provided as a courtesy.  It includes the MalConv model to which we compared to in https://arxiv.org/abs/1804.04637.
+
+For more details about MalConv, please see (and cite) the [original paper](https://arxiv.org/abs/1710.09435).
+
+```
+Raff, Edward, et al. "Malware detection by eating a whole exe." arXiv preprint arXiv:1710.09435 (2017).
+```
+
+If you use the pre-trained weights or code in your work, we also ask that you please cite [our paper](https://arxiv.org/pdf/1804.04637.pdf) for the implementation of MalConv, as it differs in a few subtle ways from the original.
+
+```
+H. Anderson and P. Roth, "EMBER: An Open Dataset for Training Static PE Malware Machine Learning Models”, in ArXiv e-prints. Apr. 2018.
+
+@ARTICLE{2018arXiv180404637A,
+  author = {{Anderson}, H.~S. and {Roth}, P.},
+  title = "{EMBER: An Open Dataset for Training Static PE Malware Machine Learning Models}",
+  journal = {ArXiv e-prints},
+  archivePrefix = "arXiv",
+  eprint = {1804.04637},
+  primaryClass = "cs.CR",
+  keywords = {Computer Science - Cryptography and Security},
+  year = 2018,
+  month = apr,
+  adsurl = {http://adsabs.harvard.edu/abs/2018arXiv180404637A},
+}
+```
+
+## Can I use this code to train MalConv on my own dataset?
+The code provided is instructional and nonfunctional.  With a few minor changes, it can be made functional.  In particular, you must provide a URL to fetch file contents by sha256 hash.
+
+## How does this MalConv model differ from that of Raff et al.?
+ * Our model was trained on binary files from labeled samples in the EMBER training set.
+ * The original paper used `batch_size = 256` and `SGD(lr=0.01, momentum=0.9, decay=UNDISCLOSED, nesterov=True )`.  We used
+ `decay=1e-3` and `batch_size=100`.
+ * It is unknown whether the original paper used a special symbol for padding.
+ * The paper allowed for up to 2MB malware sizes, we use 1MB because of memory limits on a commonly-used Titan X.

Reference/ember-malconv/malconv.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:957fd697149066ee2926b18d7008997479952fe083e2b3f8e3fa4a35e84b6bd3
+size 12550712

Reference/ember-malconv/malconv.py

@@ -0,0 +1,177 @@
+#!/usr/bin/python
+'''defines the MalConv architecture.
+Adapted from https://arxiv.org/pdf/1710.09435.pdf
+Things different about our implementation and that of the original paper:
+ * The paper uses batch_size = 256 and SGD(lr=0.01, momentum=0.9, decay=UNDISCLOSED, nesterov=True )
+ * The paper didn't have a special EOF symbol
+ * The paper allowed for up to 2MB malware sizes, we use 1.0MB because of memory on a Titan X
+ '''
+
+def main(): 
+    from keras.layers import Dense, Conv1D, Activation, GlobalMaxPooling1D, Input, Embedding, Multiply
+    from keras.models import Model
+    from keras import backend as K
+    from keras import metrics
+    import multi_gpu
+    import os
+    import math
+    import random
+    import argparse
+    import os
+    import numpy as np
+    import requests
+
+    batch_size = 100
+    input_dim = 257 # every byte plus a special padding symbol
+    padding_char = 256
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--gpus', help='number of GPUs', default=1)
+
+    args = parser.parse_args()
+    ngpus = int(args.gpus)
+
+    if os.path.exists('malconv.h5'):
+        print("restoring malconv.h5 from disk for continuation training...")
+        from keras.models import load_model
+        basemodel = load_model('malconv.h5')
+        _, maxlen, embedding_size = basemodel.layers[1].output_shape
+        input_dim
+    else:
+        maxlen = 2**20 # 1MB
+        embedding_size = 8 
+
+        # define model structure
+        inp = Input( shape=(maxlen,))
+        emb = Embedding( input_dim, embedding_size )( inp )
+        filt = Conv1D( filters=128, kernel_size=500, strides=500, use_bias=True, activation='relu', padding='valid' )(emb)
+        attn = Conv1D( filters=128, kernel_size=500, strides=500, use_bias=True, activation='sigmoid', padding='valid')(emb)
+        gated = Multiply()([filt,attn])
+        feat = GlobalMaxPooling1D()( gated )
+        dense = Dense(128, activation='relu')(feat)
+        outp = Dense(1, activation='sigmoid')(dense)
+
+        basemodel = Model( inp, outp )
+
+    basemodel.summary() 
+
+    print("Using %i GPUs" %ngpus)
+
+    if ngpus > 1:
+        model = multi_gpu.make_parallel(basemodel,ngpus)
+    else:
+        model = basemodel
+
+    from keras.optimizers import SGD
+    model.compile( loss='binary_crossentropy', optimizer=SGD(lr=0.01,momentum=0.9,nesterov=True,decay=1e-3), metrics=[metrics.binary_accuracy] )
+
+    def bytez_to_numpy(bytez,maxlen):
+        b = np.ones( (maxlen,), dtype=np.uint16 )*padding_char
+        bytez = np.frombuffer( bytez[:maxlen], dtype=np.uint8 )
+        b[:len(bytez)] = bytez
+        return b
+
+    def getfile_service(sha256,url=None,maxlen=maxlen):
+        if url is None:
+            raise NotImplementedError("You must provide your own url for getting file bytez by sha256")
+        r = requests.get( url, params={'sha256':sha256} )
+        if not r.ok:
+            return None
+        return bytez_to_numpy( r.content, maxlen )        
+
+    def generator( hashes, labels, batch_size, shuffle=True ):
+        X = []
+        y = []
+        zipped = list(zip(hashes, labels))
+        while True:
+            if shuffle:
+                random.shuffle( zipped )
+            for sha256,l in zipped:
+                x = getfile_service(sha256)
+                if x is None:
+                    continue
+                X.append( x )
+                y.append( l )
+                if len(X) == batch_size:
+                    yield np.asarray(X,dtype=np.uint16), np.asarray(y)
+                    X = []
+                    y = []
+
+    import pandas as pd
+    train_labels = pd.read_csv('ember_training.csv.gz')
+    train_labels = train_labels[ train_labels['y'] != -1 ] # get only labeled samples
+    labels = train_labels['y'].tolist()
+    hashes = train_labels['sha256'].tolist()
+
+    from sklearn.model_selection import train_test_split
+    hashes_train, hashes_val, labels_train, labels_val = train_test_split( hashes, labels, test_size=200 )
+
+    train_gen = generator( hashes_train, labels_train, batch_size )
+    val_gen = generator( hashes_val, labels_val, batch_size )
+
+    from keras.callbacks import LearningRateScheduler
+
+    base = K.get_value( model.optimizer.lr )
+    def schedule(epoch):
+        return base / 10.0**(epoch//2)
+
+    model.fit_generator(
+        train_gen,
+        steps_per_epoch=len(hashes_train)//batch_size,
+        epochs=10,
+        validation_data=val_gen,
+        callbacks=[ LearningRateScheduler( schedule ) ],
+        validation_steps=int(math.ceil(len(hashes_val)/batch_size)),
+    )
+
+    basemodel.save('malconv.h5')
+
+    test_labels = pd.read_csv('ember_test.csv.gz')
+    labels_test = test_labels['y'].tolist()
+    hashes_test = test_labels['sha256'].tolist()
+
+    test_generator = generator(hashes_test,labels_test,batch_size=1,shuffle=False)
+    test_p = basemodel.predict_generator( test_generator, steps=len(test_labels), verbose=1 )
+
+
+if __name__ == '__main__':
+    print('*'*80)
+    print('''
+This is nonfunctional demonstration code that is provided for convenience. It shows
+- The MalConv structure used in our paper
+- Training procedure used in the paper
+- How to load the weights for the MalConv model that we used.
+
+It may be made functional by modifying the code to retrieve file contents by sha256
+from a user-defined URL.
+
+You may use the provided weights under the Ember AGPL-3.0 license included in the parent directory.
+We also ask that you cite the original MalConv paper and refer to the Ember paper as the implementation.
+
+(1) E. Raff, J. Barker, J. Sylvester, R. Brandon, B. Catanzaro, C. Nicholas, "Malware Detection by Eating a Whole EXE", in ArXiv e-prints. Oct. 2017.
+
+@ARTICLE{raff2017malware,
+  title={Malware detection by eating a whole exe},
+  author={Raff, Edward and Barker, Jon and Sylvester, Jared and Brandon, Robert and Catanzaro, Bryan and Nicholas, Charles},
+  journal={arXiv preprint arXiv:1710.09435},
+  year={2017}
+}
+
+(2) H. Anderson and P. Roth, "EMBER: An Open Dataset for Training Static PE Malware Machine Learning Models”, in ArXiv e-prints. Apr. 2018.
+
+@ARTICLE{2018arXiv180404637A,
+  author = {{Anderson}, H.~S. and {Roth}, P.},
+  title = "{EMBER: An Open Dataset for Training Static PE Malware Machine Learning Models}",
+  journal = {ArXiv e-prints},
+  archivePrefix = "arXiv",
+  eprint = {1804.04637},
+  primaryClass = "cs.CR",
+  keywords = {Computer Science - Cryptography and Security},
+  year = 2018,
+  month = apr,
+  adsurl = {http://adsabs.harvard.edu/abs/2018arXiv180404637A},
+}
+''')
+    print('*'*80)
+
+    #main() # uncomment this line after fixing the URL NotImplementedError above

Reference/ember-malconv/multi_gpu.py

@@ -0,0 +1,47 @@
+from keras.layers import concatenate
+from keras.layers.core import Lambda
+from keras.models import Model
+
+import tensorflow as tf
+
+def make_parallel(model, gpu_count):
+    def get_slice(data, idx, parts):
+        shape = tf.shape(data)
+        size = tf.concat([ shape[:1] // parts, shape[1:] ],axis=0)
+        stride = tf.concat([ shape[:1] // parts, shape[1:]*0 ],axis=0)
+        start = stride * idx
+        return tf.slice(data, start, size)
+
+    outputs_all = []
+    for i in range(len(model.outputs)):
+        outputs_all.append([])
+
+    #Place a copy of the model on each GPU, each getting a slice of the batch
+    for i in range(gpu_count):
+        with tf.device('/gpu:%d' % i):
+            with tf.name_scope('tower_%d' % i) as scope:
+
+                inputs = []
+                #Slice each input into a piece for processing on this GPU
+                for x in model.inputs:
+                    input_shape = tuple(x.get_shape().as_list())[1:]
+                    slice_n = Lambda(get_slice, output_shape=input_shape, arguments={'idx':i,'parts':gpu_count})(x)
+                    inputs.append(slice_n)                
+
+                outputs = model(inputs)
+                
+                if not isinstance(outputs, list):
+                    outputs = [outputs]
+                
+                #Save all the outputs for merging back together later
+                for l in range(len(outputs)):
+                    outputs_all[l].append(outputs[l])
+
+    # merge outputs on CPU
+    with tf.device('/cpu:0'):
+        merged = []
+        for outputs in outputs_all:
+            merged.append(concatenate(outputs, axis=0))
+            
+        return Model(inputs=model.inputs, outputs=merged)
+

paper/1710.09435v1.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:369986a8098764ec67dc68d52c3b5de29a4c3117d4aa7f8463d39c208349f1f7
+size 385364

paper/2012.09390v1.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9af4474974c56852bda85326d80dd23bffbec3c1e42ff46681d6b3e2bddab766
+size 1007625

paper/PaperReview.md

@@ -0,0 +1,209 @@
+# Malware Detection by Eating a Whole EXE
+
+--
+### Instroduction
+
+[ENG]
+The introduction of MalConv addresses the fundamental limitations of traditional signature-based malware detection systems and the complexities of dynamic analysis approaches. Current anti-virus technologies rely on manually crafted rules that are specific to particular malware families and cannot recognize new variants, making them increasingly ineffective against the millions of new malware samples discovered daily. Dynamic analysis, while intuitive, presents significant challenges including high computational requirements, potential detection by sophisticated malware, and discrepancies between analysis and target environments
+
+The core innovation lies in processing raw byte sequences from entire executable files without requiring domain knowledge or feature engineering. This approach presents unique challenges not encountered in traditional machine learning domains: handling multi-modal byte information (text, code, images), managing spatial correlations with discontinuities, processing sequences exceeding two million time steps, and addressing multiple levels of concept drift over time
+
+
+[KOR]
+MalConv의 도입배경은 전통적인 시그니처 기반 악성코드 탐지 시스템의 근본적 한계와 동적 분석 방법의 복잡성을 해결하는 데 있습니다. 현재 안티바이러스 기술은 특정 악성코드 패밀리에 특화된 수동 제작 규칙에 의존하며 새로운 변종을 인식할 수 없어, 매일 발견되는 수백만 개의 새로운 악성코드 샘플에 대해 점점 비효율적이 되고 있습니다. 동적 분석은 직관적이지만 높은 계산 요구사항, 정교한 악성코드의 탐지 가능성, 분석 환경과 대상 환경 간의 불일치 등 심각한 문제를 제시합니다.
+
+핵심 혁신은 도메인 지식이나 특징 공학 없이 전체 실행 파일의 원시 바이트 시퀀스를 처리하는 것입니다. 이 접근법은 전통적인 기계학습 영역에서 만나지 못한 고유한 도전과제들을 제시합니다: 다중 모달 바이트 정보(텍스트, 코드, 이미지) 처리, 불연속성을 가진 공간 상관관계 관리, 200만 시간 단계를 초과하는 시퀀스 처리, 시간에 따른 다중 레벨 개념 드리프트 해결
+
+
+
+--
+### 2. Related work
+
+
+[ENG]
+The application of neural networks to extremely long sequences represents a significant computational challenge that MalConv addresses at an unprecedented scale. Prior work in this area includes WaveNet, which processes audio sequences of up to 16,000 time steps per second, still two orders of magnitude smaller than MalConv's capability. ByteNet and similar architectures for machine translation handle relatively shorter sequences compared to the malware detection problem.
+
+The use of dilated convolutions, popularized by WaveNet and ByteNet for capturing wide receptive fields, was explored but found ineffective for binary data. Unlike spatially consistent domains like images and audio, the values in dilated convolution "holes" are not easily interpolated for binary content, leading to poor performance. RNN-based approaches face memory and computational complexity limitations when dealing with sequences of this magnitude
+
+[KOR]
+극도로 긴 시퀀스에 대한 신경망 적용은 MalConv가 전례 없는 규모로 해결하는 중요한 계산적 도전을 나타냅니다. 이 영역의 선행 연구로는 초당 최대 16,000 시간 단계의 오디오 시퀀스를 처리하는 WaveNet이 있지만, 여전히 MalConv 능력보다 두 자릿수 작습니다. 기계 번역을 위한 ByteNet과 유사한 아키텍처들은 악성코드 탐지 문제에 비해 상대적으로 짧은 시퀀스를 처리합니다.
+
+넓은 수용 필드를 포착하기 위해 WaveNet과 ByteNet에서 인기를 얻은 팽창 컨볼루션의 사용이 탐구되었지만 바이너리 데이터에 대해서는 비효과적임이 발견되었습니다. 이미지와 오디오 같은 공간적으로 일관된 도메인과 달리, 팽창 컨볼루션 "구멍"의 값들은 바이너리 콘텐츠에 대해 쉽게 보간되지 않아 성능 저하를 초래합니다. RNN 기반 접근법은 이러한 규모의 시퀀스를 다룰 때 메모리와 계산 복잡도 제한에 직면합니다
+
+
+#### 2.1 Neural Network for Long Sequence
+
+[EMG]
+The application of neural networks to extremely long sequences represents a significant computational challenge that MalConv addresses at an unprecedented scale. Prior work in this area includes WaveNet, which processes audio sequences of up to 16,000 time steps per second, still two orders of magnitude smaller than MalConv's capability. ByteNet and similar architectures for machine translation handle relatively shorter sequences compared to the malware detection problem.
+
+The use of dilated convolutions, popularized by WaveNet and ByteNet for capturing wide receptive fields, was explored but found ineffective for binary data. Unlike spatially consistent domains like images and audio, the values in dilated convolution "holes" are not easily interpolated for binary content, leading to poor performance. RNN-based approaches face memory and computational complexity limitations when dealing with sequences of this magnitude
+
+
+[KOR]
+극도로 긴 시퀀스에 대한 신경망 적용은 MalConv가 전례 없는 규모로 해결하는 중요한 계산적 도전을 나타냅니다. 이 영역의 선행 연구로는 초당 최대 16,000 시간 단계의 오디오 시퀀스를 처리하는 WaveNet이 있지만, 여전히 MalConv 능력보다 두 자릿수 작습니다. 기계 번역을 위한 ByteNet과 유사한 아키텍처들은 악성코드 탐지 문제에 비해 상대적으로 짧은 시퀀스를 처리합니다.
+
+넓은 수용 필드를 포착하기 위해 WaveNet과 ByteNet에서 인기를 얻은 팽창 컨볼루션의 사용이 탐구되었지만 바이너리 데이터에 대해서는 비효과적임이 발견되었습니다. 이미지와 오디오 같은 공간적으로 일관된 도메인과 달리, 팽창 컨볼루션 "구멍"의 값들은 바이너리 콘텐츠에 대해 쉽게 보간되지 않아 성능 저하를 초래합니다. RNN 기반 접근법은 이러한 규모의 시퀀스를 다룰 때 메모리와 계산 복잡도 제한에 직면합니다
+
+
+
+#### 2.2 Neural Netwokrs for Malware Detectioon
+
+[ENG]
+Previous applications of neural networks to malware detection have relied heavily on domain knowledge and feature extraction, limiting their generalizability. Saxe and Berlin (2015) used histogram-based features including byte entropy values, ASCII string lengths, and PE metadata, discarding most information about actual binary content. Kolosnjaji et al. (2016) applied LSTM networks to API call sequences from dynamic analysis, focusing on only 60 kernel API calls.
+
+The work most closely related to MalConv in terms of feature representation is the PE-header network by Raff et al. (2017), which achieved high accuracy using only 300 bytes from PE headers. However, this approach still requires domain knowledge about executable file structure and cannot process the entire binary content. Most existing work relies on sophisticated emulation environments and manual feature engineering, creating barriers to reproduction and extension.
+
+
+[KOR]
+악성코드 탐지에 대한 신경망의 이전 적용들은 도메인 지식과 특징 추출에 크게 의존하여 일반화 가능성을 제한했습니다. Saxe와 Berlin(2015)은 바이트 엔트로피 값, ASCII 문자열 길이, PE 메타데이터를 포함한 히스토그램 기반 특징을 사용하여 실제 바이너리 콘텐츠에 대한 대부분의 정보를 버렸습니다. Kolosnjaji 등(2016)은 동적 분석의 API 호출 시퀀스에 LSTM 네트워크를 적용하여 단지 60개의 커널 API 호출에만 집중했습니다.
+
+특징 표현 측면에서 MalConv와 가장 밀접한 관련이 있는 작업은 PE 헤더의 300바이트만을 사용하여 높은 정확도를 달성한 Raff 등(2017)의 PE-헤더 네트워크입니다. 그러나 이 접근법은 여전히 실행 파일 구조에 대한 도메인 지식이 필요하고 전체 바이너리 콘텐츠를 처리할 수 없습니다. 기존 작업의 대부분은 정교한 에뮬레이션 환경과 수동 특징 공학에 의존하여 재현과 확장에 장벽을 만듭니다.
+
+
+--
+### 3. Training data
+
+
+[ENG]
+The training data for MalConv consists of two primary groups with distinct collection methodologies to ensure robust evaluation. Group B contains 400,000 files split evenly between benign and malicious classes, provided by an anti-virus industry partner and representing files encountered on real machines. The Group B test set includes 77,349 files with 40,000 malicious and the remainder benign samples.
+
+Group A data follows the conventional academic approach, with benign samples from clean Microsoft Windows installations and common applications, while malware comes from the VirusShare corpus. The Group A test set contains 43,967 malicious and 21,854 benign files. A critical finding revealed that training on Group A-style data results in severe overfitting, with models learning to recognize "from Microsoft" rather than genuinely benign characteristics.
+
+An extended dataset of 2,011,786 binaries (1,000,020 benign and 1,011,766 malicious) was later obtained to demonstrate MalConv's continued improvement with increased training data, while byte n-gram approaches showed performance plateauing.
+
+
+
+[KOR]
+MalConv의 훈련 데이터는 강건한 평가를 보장하기 위해 서로 다른 수집 방법론을 가진 두 가지 주요 그룹으로 구성됩니다. 그룹 B는 안티바이러스 업계 파트너가 제공한 40만 개의 파일을 포함하며, 악성과 정상 클래스로 균등하게 분할되어 실제 기계에서 발견되는 파일을 대표합니다. 그룹 B 테스트 세트는 77,349개 파일을 포함하며 이중 40,000개가 악성이고 나머지가 정상 샘플입니다.
+
+그��� A 데이터는 전통적인 학술적 접근법을 따르며, 정상 샘플은 깨끗한 Microsoft Windows 설치와 일반적인 애플리케이션에서, 악성코드는 VirusShare 코퍼스에서 가져왔습니다. 그룹 A 테스트 세트는 43,967개의 악성과 21,854개의 정상 파일을 포함합니다. 중요한 발견은 그룹 A 스타일 데이터에 대한 훈련이 심각한 과적합을 초래하며, 모델이 진정한 정상 특성보다는 "Microsoft에서 나온" 것을 인식하도록 학습한다는 것입니다.
+
+MalConv의 훈련 데이터 증가에 따른 지속적인 성능 향상을 보여주기 위해 2,011,786개 바이너리(정상 1,000,020개, 악성 1,011,766개)의 확장 데이터셋이 나중에 획득되었으며, 바이트 n-그램 접근법은 성능 정체를 보였습니다
+
+
+--
+### 4. Model Archtecture
+
+[ENG]
+The MalConv architecture is designed with three key requirements: scalability with sequence length, ability to consider both local and global context across entire files, and explanatory capability for analysis of flagged malware. The model processes raw byte sequences through an embedding layer that maps each byte (0-255) to an 8-dimensional learned feature vector, avoiding the false assumption that certain byte values are intrinsically closer than others.
+
+The core architecture employs gated convolution with 128 filters, using large convolutional filter width of 500 bytes combined with an aggressive stride of 500. This design choice addresses GPU memory constraints while enabling efficient data-parallel training. The gated convolution approach follows Dauphin et al. (2016), incorporating element-wise multiplication with sigmoid activation to control information flow.
+
+Temporal max-pooling extracts the maximum activation across the entire sequence, allowing the model to detect informative features regardless of their location within the binary. This design addresses the high positional variation in executable files where contents can be arbitrarily rearranged while maintaining functionality. The final component is a fully connected layer with softmax activation for binary classification.
+
+
+[KOR]
+MalConv 아키텍처는 세 가지 핵심 요구사항으로 설계되었습니다: 시퀀스 길이에 따른 확장성, 전체 파일에 걸친 지역적 및 전역적 컨텍스트 고려 능력, 플래그된 악성코드 분석을 위한 설명 능력. 모델은 각 바이트(0-255)를 8차원 학습된 특징 벡터로 매핑하는 임베딩 레이어를 통해 원시 바이트 시퀀스를 처리하여, 특정 바이트 값이 다른 값보다 본질적으로 더 가깝다는 잘못된 가정을 피합니다.
+
+핵심 아키텍처는 128개 필터를 가진 게이트 컨볼루션을 사용하며, 500바이트의 큰 컨볼루션 필터 폭과 500의 공격적인 스트라이드를 결합합니다. 이 설계 선택은 GPU 메모리 제약을 해결하면서 효율적인 데이터 병렬 훈련을 가능하게 합니다. 게이트 컨볼루션 접근법은 Dauphin 등(2016)을 따르며, 정보 흐름을 제어하기 위해 시그모이드 활성화와 요소별 곱셈을 통합합니다.
+
+시간적 최대 풀링은 전체 시퀀스에 걸쳐 최대 활성화를 추출하여, 모델이 바이너리 내 위치에 관계없이 정보적 특징을 탐지할 수 있게 합니다. 이 설계는 기능을 유지하면서 콘텐츠가 임의로 재배열될 수 있는 실행 파일의 높은 위치 변동을 해결합니다. 최종 구성요소는 이진 분류를 위한 소프트맥스 활성화를 가진 완전 연결 레이어입니다
+
+
+
+
+#### 4.1 On Failed Archtectures
+
+[ENG]
+Extensive experimentation with alternative architectures revealed several fundamental challenges in processing extremely long sequences for malware detection. Deep convolutional networks with up to 13 layers suffered from gradient vanishing problems and required rapid compression of state size per layer due to memory constraints, ultimately inhibiting learning. The standard approach of doubling convolutional filters after each pooling round becomes computationally intractable with 2 million time steps.
+
+Chunking approaches, where files are divided into 500-10,000 byte segments for independent processing, achieved reasonable training accuracies up to 95% but failed to generalize with test accuracies dropping to 65-80%. This failure occurs because much of a binary's content may be non-informative for maliciousness decisions, and training on random chunks encourages overfitting to training data rather than learning discriminative features.
+
+RNN-based architectures performed poorly when applied after convolutions, as reshaping temporal CNN outputs into fixed-sized chunks imposes an artificial prior that activation patterns must appear at consistent frequencies. The malware "image" approach, treating bytes as grayscale pixels with arbitrary width selection, introduces false spatial correlations and fails to handle variable file sizes meaningfully.
+
+
+
+[KOR]
+대안적 아키��처에 대한 광범위한 실험은 악성코드 탐지를 위한 극도로 긴 시퀀스 처리에서 몇 가지 근본적인 도전과제를 드러냈습니다. 최대 13층의 깊은 컨볼루션 네트워크는 그래디언트 소실 문제를 겪었고 메모리 제약으로 인해 레이어당 상태 크기의 급속한 압축이 필요했으며, 궁극적으로 학습을 저해했습니다. 각 풀링 라운드 후 컨볼루션 필터를 두 배로 늘리는 표준 접근법은 200만 시간 단계에서 계산적으로 다루기 어려워집니다.
+
+파일을 500-10,000바이트 세그먼트로 나누어 독립적으로 처리하는 청킹 접근법은 최대 95%의 합리적인 훈련 정확도를 달성했지만 테스트 정확도가 65-80%로 떨어지면서 일반화에 실패했습니다. 이 실패는 바이너리 콘텐츠의 대부분이 악성 여부 결정에 비정보적일 수 있고, 무작위 청크에 대한 훈련이 판별적 특징을 학습하기보다는 훈련 데이터에 과적합을 장려하기 때문에 발생합니다.
+
+RNN 기반 아키텍처는 컨볼루션 후에 적용될 때 성능이 저조했는데, 이는 시간적 CNN 출력을 고정 크기 청크로 재구성하는 것이 활성화 패턴이 일관된 빈도로 나타나야 한다는 인위적인 사전 지식을 부과하기 때문입니다. 바이트를 임의의 폭 선택으로 그레이스케일 픽셀로 취급하는 악성코드 "이미지" 접근법은 거짓 공간 상관관계를 도입하고 가변 파일 크기를 의미 있게 처리하지 못합니다.
+
+
+
+--
+### 5. Results
+
+#### 5.1 Malware classification
+
+[ENG]
+MalConv demonstrates superior performance across multiple metrics and test sets, achieving balanced accuracy between Group A and Group B evaluations. The model achieves 88.1% accuracy on Group A and 89.6% on Group B, with AUC scores of 98.5% and 95.8% respectively. Notably, MalConv shows the smallest performance difference between test groups, indicating robust feature learning that generalizes well across different data distributions.
+
+The application of DeCov regularization significantly improves model accuracy by up to 4.8 percentage points, primarily through better calibration of decision thresholds rather than fundamental concept changes. When trained on the extended 2 million sample dataset, MalConv's performance increases substantially: Group A accuracy improves to 94.0% and Group B to 90.9%, while Group B AUC reaches 98.2%.
+
+Comparative analysis reveals that byte n-gram models, while achieving high Group B performance (92.5% accuracy, 97.9% AUC), show significant performance gaps between test groups and demonstrate brittleness to single-byte modifications. The PE-header network achieves slightly higher Group A accuracy (90.8%) but significantly reduced Group B performance, indicating limited feature diversity.
+
+
+
+[KOR]
+MalConv는 여러 메트릭과 테스트 세트에서 우수한 성능을 보여주며, 그룹 A와 그룹 B 평가 간 균형잡힌 정확도를 달성합니다. 모델은 그룹 A에서 88.1%, 그룹 B에서 89.6%의 정확도를 달성하며, AUC 점수는 각각 98.5%와 95.8%입니다. 특히 MalConv는 테스트 그룹 간 가장 작은 성능 차이를 보여, 서로 다른 데이터 분포에서 잘 일반화되는 강건한 특징 학습을 나타냅니다.
+
+DeCov 정규화의 적용은 근본적인 개념 변화보다는 결정 임계값의 더 나은 보정을 통해 모델 정확도를 최대 4.8 퍼센트 포인트까지 크게 향상시킵니다. 200만 샘플의 확장 데이터셋에서 훈련될 때 MalConv의 성능은 상당히 증가합니다: 그룹 A 정확도는 94.0%로, 그룹 B는 90.9%로 향상되며, 그룹 B AUC는 98.2%에 도달합니다.
+
+비교 분석은 바이트 n-그램 모델이 높은 그룹 B 성능(92.5% 정확도, 97.9% AUC)을 달성하지만 테스트 그룹 간 상당한 성능 격차를 보이고 단일 바이트 수정에 대한 취약성을 보인다는 것을 드러냅니다. PE-헤더 네트워크는 약간 더 높은 그룹 A 정확도(90.8%)를 달성하지만 그룹 B 성능이 현저히 감소하여 제한된 특징 다양성을 나타냅니다.
+
+
+#### 5.2 Maunal Analysis
+
+
+[ENG]
+MalConv's interpretability is enhanced through a sparse Class Activation Map (sparse-CAM) approach that adapts Zhou et al. (2016)'s methodology for the extreme sequence lengths encountered in malware detection. Using global max-pooling instead of average pooling produces naturally sparse activation maps, returning one 500-byte region per convolutional filter (maximum 128 regions per binary) as important for classification decisions.
+
+Analysis of 224 randomly selected binaries from Group A test set reveals that MalConv utilizes significantly more diverse information sources compared to byte n-gram approaches. While previous byte n-gram models obtained almost all information from PE-headers, MalConv derives only 58-61% of its information from this region, indicating broader feature utilization across different binary sections.
+
+The model demonstrates sophisticated understanding of binary structure, with activations distributed across .rsrc sections (16%), .text and CODE sections (14%), indicating utilization of resource directories and executable code as features. Notably, the model shows balanced activation patterns for UPX1 sections (indicating packed executables) for both benign and malicious samples, suggesting it has learned to avoid the common but unhelpful association between packing and maliciousness.
+
+
+
+
+[KOR]
+MalConv의 해석가능성은 악성코드 탐지에서 접하는 극도의 시퀀스 길이에 대해 Zhou 등(2016)의 방법론을 적응시킨 희소 클래스 활성화 맵(sparse-CAM) 접근법을 통해 향상됩니다. 평균 풀링 대신 전역 최대 풀링을 사용하면 자연스럽게 희소한 활성화 맵이 생성되어, 분류 결정에 중요한 것으로 컨볼루션 필터당 하나의 500바이트 영역(바이너리당 최대 128개 영역)을 반환합니다.
+
+그룹 A 테스트 세트에서 무작위로 선택된 224개 바이너리의 분석은 MalConv가 바이트 n-그램 접근법에 비해 훨씬 더 다양한 정보 소스를 활용한다는 것을 드러냅니다. 이전 바이트 n-그램 모델이 PE-헤더에서 거의 모든 정보를 얻었던 반면, MalConv는 이 영역에서 정보의 58-61%만을 도출하여 다른 바이너리 섹션에 걸쳐 더 광범위한 특징 활용을 나타냅니다.
+
+모델은 .rsrc 섹션(16%), .text 및 CODE 섹션(14%)에 걸쳐 분산된 활성화로 바이너리 구조에 대한 정교한 이해를 보여주며, 리소스 디렉토리와 실행 코드를 특징으로 활용함을 나타냅니다. 특히 모델은 정상과 악성 샘플 모두에 대해 UPX1 섹션(패킹된 실행 파일을 나타냄)에 대한 균형잡힌 활성화 패턴을 보여, 패킹과 악성성 간의 일반적이지만 도움이 되지 않는 연관성을 피하도록 학습했음을 시사합니다.
+
+
+#### 5.3 The Failure of Batch-Normlaization
+
+[ENG]
+One of the most significant findings in MalConv research is the complete failure of batch normalization, a technique that typically accelerates convergence and improves generalization in deep learning. Models incorporating batch normalization consistently failed to learn, achieving at best 60% training accuracy and 50% test accuracy across multiple framework implementations including PyTorch, TensorFlow, Chainer, and Theano.
+
+Kernel density estimation analysis reveals the root cause: binary executable data exhibits multi-modal activation distributions fundamentally different from the approximately Gaussian distributions assumed by batch normalization. While image processing networks show smooth, unimodal activation patterns suitable for normalization, MalConv activations display distinct multi-modal characteristics with multiple peaks.
+
+This multi-modal nature stems from the diverse byte content within executables, where the same byte value can represent ASCII text, binary code, structured data, or embedded images depending on context. The violation of batch normalization's normality assumption leads to degraded performance, with the technique only functioning when trained on homogeneous sub-regions of 500-10,000 bytes, though these models still failed to generalize to test data.
+
+
+
+[KOR]
+One of the most significant findings in MalConv research is the complete failure of batch normalization, a technique that typically accelerates convergence and improves generalization in deep learning. Models incorporating batch normalization consistently failed to learn, achieving at best 60% training accuracy and 50% test accuracy across multiple framework implementations including PyTorch, TensorFlow, Chainer, and Theano.
+
+Kernel density estimation analysis reveals the root cause: binary executable data exhibits multi-modal activation distributions fundamentally different from the approximately Gaussian distributions assumed by batch normalization. While image processing networks show smooth, unimodal activation patterns suitable for normalization, MalConv activations display distinct multi-modal characteristics with multiple peaks.
+
+This multi-modal nature stems from the diverse byte content within executables, where the same byte value can represent ASCII text, binary code, structured data, or embedded images depending on context. The violation of batch normalization's normality assumption leads to degraded performance, with the technique only functioning when trained on homogeneous sub-regions of 500-10,000 bytes, though these models still failed to generalize to test data.
+
+
+
+
+
+
+--
+### 6. Conclusion
+
+[ENG]
+MalConv represents a paradigm shift in malware detection by demonstrating that neural networks can successfully learn to identify malicious software directly from raw byte sequences without domain knowledge. The model's ability to process entire PE files up to 2 million bytes establishes it as the first architecture capable of handling such extreme sequence lengths in cybersecurity applications.
+
+The research contributions extend beyond malware detection to the broader machine learning community by identifying unique challenges in processing multi-modal sequential data and proposing effective solutions. The discovery of batch normalization's failure provides valuable insights for future work on non-standard data distributions, while the sparse-CAM interpretability approach offers a practical method for understanding model decisions on extremely long sequences.
+
+Future research directions include developing architectures that better handle multi-modal data, improving memory efficiency for even longer sequences, and integrating semantic understanding of code structure. The model's demonstrated scalability with increased training data suggests continued performance improvements as larger datasets become available, positioning MalConv as a foundation for next-generation cybersecurity solutions.
+
+
+
+[KOR]
+MalConv는 신경망이 도메인 지식 없이 원시 바이트 시퀀스에서 직접 악성 소프트웨어를 식별하도록 성공적으로 학습할 수 있음을 보여줌으로써 악성코드 탐지의 패러다임 전환을 나타냅니다. 최대 200만 바이트의 전체 PE 파일을 처리할 수 있는 모델의 능력은 사이버보안 애플리케이션에서 이러한 극도의 시퀀스 길이를 처리할 수 있는 최초의 아키텍처로 확립됩니다.
+
+연구 기여는 악성코드 탐지를 넘어 다중 모달 순차 데이터 처리의 고유한 도전과제를 식별하고 효과적인 해결책을 제안함으로써 더 광범위한 기계학습 커뮤니티로 확장됩니다. 배치 정규화 실패의 발견은 비표준 데이터 분포에 대한 향후 작업에 귀중한 통찰을 제공하며, sparse-CAM 해석가능성 접근법은 극도로 긴 시퀀스에서 모델 결정을 이해하는 실용적인 방법을 제공합니다.
+
+향후 연구 방향에는 다중 모달 데이터를 더 잘 처리하는 아키텍처 개발, 더 긴 시퀀스를 위한 메모리 효율성 향상, 코드 구조의 의미론적 이해 통합이 포함됩니다. 훈련 데이터 증가에 따른 모델의 입증된 확장성은 더 큰 데이터셋이 사용 가능해짐에 따라 지속적인 성능 향상을 시사하며, MalConv를 차세대 사이버보안 솔루션의 기반으로 위치시킵니다.
+

requirements.txt

@@ -0,0 +1,7 @@
+tensorflow>=2.8.0
+numpy>=1.21.0
+pandas>=1.3.0
+scikit-learn>=1.0.0
+matplotlib>=3.5.0
+seaborn>=0.11.0
+tqdm>=4.62.0

src/model.py

@@ -0,0 +1,148 @@
+import tensorflow as tf
+from tensorflow.keras import layers, Model
+import numpy as np
+
+class DeCorrelationLoss(tf.keras.layers.Layer):
+    """논문의 정확한 DeCov 정규화 구현"""
+    
+    def __init__(self, lambda_decov=1e-4, **kwargs):
+        super(DeCorrelationLoss, self).__init__(**kwargs)
+        self.lambda_decov = lambda_decov
+    
+    def build(self, input_shape):
+        super(DeCorrelationLoss, self).build(input_shape)
+    
+    def call(self, inputs):
+        batch_size = tf.cast(tf.shape(inputs)[0], tf.float32)
+        
+        # 중심화
+        inputs_centered = inputs - tf.reduce_mean(inputs, axis=0, keepdims=True)
+        
+        # 공분산 행렬 계산
+        covariance = tf.matmul(inputs_centered, inputs_centered, transpose_a=True) / (batch_size - 1)
+        
+        # 대각선 제거
+        covariance_off_diagonal = covariance - tf.linalg.diag(tf.linalg.diag_part(covariance))
+        
+        # DeCov 손실
+        decov_loss = 0.5 * tf.reduce_sum(tf.square(covariance_off_diagonal))
+        
+        self.add_loss(self.lambda_decov * decov_loss)
+        return inputs
+
+class MalConv(Model):
+    """논문 정확 사양 MalConv 모델"""
+    
+    def __init__(self, 
+                 max_input_length=2_000_000,
+                 embedding_size=8,
+                 filter_size=500,
+                 stride=500,
+                 num_filters=128,
+                 fc_size=128,
+                 use_decov=True,
+                 lambda_decov=1e-4,
+                 **kwargs):
+        super(MalConv, self).__init__(**kwargs)
+        
+        self.max_input_length = max_input_length
+        self.use_decov = use_decov
+        
+        # 논문 정확 사양: 0-255 바이트만 사용
+        self.embedding = layers.Embedding(
+            input_dim=256,  # 수정: 257→256
+            output_dim=embedding_size,
+            input_length=None,  # 가변 길이 지원
+            mask_zero=False,
+            name='byte_embedding'
+        )
+        
+        # 게이트 컨볼루션 (논문 Figure 1)
+        self.conv_A = layers.Conv1D(
+            filters=num_filters,
+            kernel_size=filter_size,
+            strides=stride,
+            padding='valid',
+            activation='relu',
+            name='conv_A'
+        )
+        
+        self.conv_B = layers.Conv1D(
+            filters=num_filters,
+            kernel_size=filter_size,
+            strides=stride,
+            padding='valid',
+            activation='sigmoid',
+            name='conv_B'
+        )
+        
+        # 전역 최대 풀링
+        self.global_max_pool = layers.GlobalMaxPooling1D(name='global_max_pool')
+        
+        # 완전연결층
+        self.fc = layers.Dense(fc_size, activation='relu', name='fc_layer')
+        
+        # DeCov 정규화
+        if use_decov:
+            self.decov_layer = DeCorrelationLoss(lambda_decov=lambda_decov)
+        
+        self.dropout = layers.Dropout(0.5, name='dropout')
+        self.output_layer = layers.Dense(1, activation='sigmoid', name='output')
+    
+    def call(self, inputs, training=None):
+        # 1. 바이트 임베딩
+        x = self.embedding(inputs)
+        
+        # 2. 게이트 컨볼루션 (논문 핵심)
+        conv_a = self.conv_A(x)
+        conv_b = self.conv_B(x)
+        gated_conv = layers.multiply([conv_a, conv_b], name='gated_conv')
+        
+        # 3. 전역 최대 풀링
+        pooled = self.global_max_pool(gated_conv)
+        
+        # 4. 완전연결층
+        fc_out = self.fc(pooled)
+        
+        # 5. DeCov 정규화 (penultimate layer)
+        if self.use_decov:
+            fc_out = self.decov_layer(fc_out)
+        
+        # 6. 드롭아웃
+        if training:
+            fc_out = self.dropout(fc_out, training=training)
+        
+        # 7. 출력
+        output = self.output_layer(fc_out)
+        
+        return output
+
+def create_malconv_model (max_input_length=2_000_000):
+    """논문 완전 동일 사양 모델"""
+    model = MalConv(max_input_length=max_input_length)
+    
+    # 논문 정확한 옵티마이저 + 스케줄러
+    initial_lr = 0.01
+    lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(
+        initial_learning_rate=initial_lr,
+        decay_steps=1000,
+        decay_rate=0.96,  # 논문에서 언급된 지수 감소
+        staircase=True
+    )
+    
+    optimizer = tf.keras.optimizers.SGD(
+        learning_rate=lr_schedule,
+        momentum=0.9,
+        nesterov=True
+    )
+    
+    model.compile(
+        optimizer=optimizer,
+        loss='binary_crossentropy',
+        metrics=['accuracy', 
+                tf.keras.metrics.Precision(name='precision'),
+                tf.keras.metrics.Recall(name='recall'),
+                tf.keras.metrics.AUC(name='auc')]
+    )
+    
+    return model

src/predict.py

@@ -0,0 +1,137 @@
+import os
+import sys
+import argparse
+import numpy as np
+import tensorflow as tf
+import pandas as pd
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from src.utils import read_binary_file
+
+def predict_file(model_path, file_path, max_length=2_000_000):  # 2,000,000
+    """
+    단일 파일에 대한 예측
+    
+    Args:
+        model_path: 저장된 모델 경로
+        file_path: 예측할 파일 경로
+        max_length: 최대 입력 길이
+    
+    Returns:
+        float: 예측 확률 (0에 가까우면 악성코드, 1에 가까우면 정상)
+    """
+    # 모델 로드
+    model = tf.keras.models.load_model(model_path)
+    
+    # 파일 읽기
+    byte_array = read_binary_file(file_path, max_length)
+    
+    # 배치 차원 추가
+    input_data = np.expand_dims(byte_array, axis=0)
+    
+    # 예측
+    prediction = model.predict(input_data, verbose=0)[0][0]
+    
+    return prediction
+
+def predict_batch(model_path, csv_path, output_path=None, max_length=2**20):
+    """
+    배치 예측
+    
+    Args:
+        model_path: 저장된 모델 경로
+        csv_path: 예측할 파일들의 CSV 경로
+        output_path: 결과 저장 경로
+        max_length: 최대 입력 길이
+    """
+    # 모델 로드
+    print("모델 로딩 중...")
+    model = tf.keras.models.load_model(model_path)
+    
+    # CSV 파일 읽기
+    df = pd.read_csv(csv_path)
+    
+    predictions = []
+    labels = []
+    
+    print("예측 중...")
+    for idx, row in df.iterrows():
+        file_path = row['filepath']
+        
+        if os.path.exists(file_path):
+            try:
+                # 파일 읽기
+                byte_array = read_binary_file(file_path, max_length)
+                input_data = np.expand_dims(byte_array, axis=0)
+                
+                # 예측
+                pred = model.predict(input_data, verbose=0)[0][0]
+                predictions.append(pred)
+                
+                # 라벨이 있는 경우
+                if 'label' in row:
+                    labels.append(row['label'])
+                
+                # 결과 출력
+                status = "정상" if pred > 0.5 else "악성코드"
+                confidence = pred if pred > 0.5 else 1 - pred
+                print(f"{file_path}: {status} (신뢰도: {confidence:.4f})")
+                
+            except Exception as e:
+                print(f"Error processing {file_path}: {e}")
+                predictions.append(-1)  # 에러 표시
+        else:
+            print(f"파일을 찾을 수 없습니다: {file_path}")
+            predictions.append(-1)
+    
+    # 결과 저장
+    result_df = df.copy()
+    result_df['prediction'] = predictions
+    result_df['predicted_label'] = (np.array(predictions) > 0.5).astype(int)
+    result_df['prediction_text'] = ['정상' if p > 0.5 else '악성코드' if p >= 0 else '에러' 
+                                   for p in predictions]
+    
+    if output_path:
+        result_df.to_csv(output_path, index=False)
+        print(f"결과가 저장되었습니다: {output_path}")
+    
+    # 정확도 계산 (라벨이 있는 경우)
+    if labels and len(labels) == len(predictions):
+        valid_predictions = [p for p in predictions if p >= 0]
+        valid_labels = [labels[i] for i, p in enumerate(predictions) if p >= 0]
+        
+        if valid_predictions:
+            pred_binary = (np.array(valid_predictions) > 0.5).astype(int)
+            accuracy = np.mean(pred_binary == np.array(valid_labels))
+            print(f"\n정확도: {accuracy:.4f}")
+    
+    return result_df
+
+def main():
+    parser = argparse.ArgumentParser(description='MalConv 모델 예측')
+    parser.add_argument('model_path', help='저장된 모델 경로')
+    parser.add_argument('--file', help='단일 파일 예측')
+    parser.add_argument('--csv', help='배치 예측용 CSV 파일')
+    parser.add_argument('--output', help='결과 저장 경로')
+    parser.add_argument('--max_length', type=int, default=2**20, help='최대 입력 길이')
+    
+    args = parser.parse_args()
+    
+    if args.file:
+        # 단일 파일 예측
+        prediction = predict_file(args.model_path, args.file, args.max_length)
+        status = "정상" if prediction > 0.5 else "악성코드"
+        confidence = prediction if prediction > 0.5 else 1 - prediction
+        print(f"파일: {args.file}")
+        print(f"예측: {status} (신뢰도: {confidence:.4f})")
+        
+    elif args.csv:
+        # 배치 예측
+        predict_batch(args.model_path, args.csv, args.output, args.max_length)
+        
+    else:
+        print("--file 또는 --csv 옵션을 지정해주세요.")
+
+if __name__ == "__main__":
+    main()

src/train.py

@@ -0,0 +1,157 @@
+import os
+import sys
+import argparse
+import numpy as np
+import tensorflow as tf
+from sklearn.model_selection import train_test_split
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from src.model import create_malconv_model
+from src.utils import (
+    configure_gpu_memory, 
+    plot_training_history, 
+    evaluate_model,
+    get_file_paths_and_labels,
+    data_generator,
+    read_binary_file
+)
+
+def train_malconv(data_source,
+                  epochs=10,
+                  batch_size=256,
+                  max_length=2_000_000,
+                  validation_split=0.2,
+                  save_path="models/malconv_model.h5"):
+    """
+    MalConv 모델 훈련 (데이터 제너레이터 사용)
+    
+    Args:
+        data_source: (malware_dir, benign_dir) 튜플
+        epochs: 훈련 에포크 수
+        batch_size: 배치 크기
+        max_length: 최대 입력 길이 (2MB)
+        validation_split: 검증 데이터 비율
+        save_path: 모델 저장 경로
+    """
+    
+    print("=" * 60)
+    print("MalConv 모델 훈련 시작 (데이터 제너레이터 모드)")
+    print("=" * 60)
+    
+    # GPU 설정
+    configure_gpu_memory()
+    
+    # 데이터 경로 및 레이블 로딩
+    if isinstance(data_source, tuple) and len(data_source) == 2:
+        malware_dir, benign_dir = data_source
+        filepaths, labels = get_file_paths_and_labels(malware_dir, benign_dir)
+    else:
+        raise ValueError("data_source는 (malware_dir, benign_dir) 튜플이어야 합니다.")
+
+    # 훈련/검증 분할 (파일 경로 기준)
+    filepaths_train, filepaths_val, labels_train, labels_val = train_test_split(
+        filepaths, labels, test_size=validation_split, random_state=42, stratify=labels
+    )
+    
+    print(f"총 데이터: {len(filepaths)}")
+    print(f"훈련 데이터: {len(filepaths_train)}, 검증 데이터: {len(filepaths_val)}")
+
+    # 데이터 제너레이터 생성
+    train_gen = data_generator(filepaths_train, labels_train, batch_size, max_length)
+    val_gen = data_generator(filepaths_val, labels_val, batch_size, max_length, shuffle=False) # 검증 시에는 셔플 안함
+
+    # 모델 생성
+    print("MalConv 모델 생성 중...")
+    model = create_malconv_model(max_length)
+    
+    # 더미 입력으로 모델 빌드
+    dummy_input = np.zeros((1, max_length), dtype=np.uint8)
+    _ = model(dummy_input)
+    
+    print("\n=== 모델 아키텍처 ===")
+    model.summary()
+    print(f"총 파라미터 수: {model.count_params():,}")
+    
+    # 콜백 설정
+    callbacks = [
+        tf.keras.callbacks.EarlyStopping(
+            monitor='val_loss',
+            patience=5, # 참을성 증가
+            restore_best_weights=True,
+            verbose=1
+        ),
+        tf.keras.callbacks.ModelCheckpoint(
+            save_path,
+            monitor='val_auc',
+            save_best_only=True,
+            verbose=1,
+            mode='max' # AUC는 높을수록 좋음
+        )
+    ]
+    
+    # 훈련
+    print(f"\n=== 훈련 시작 ===")
+    print(f"배치 크기: {batch_size}")
+    print(f"에포크: {epochs}")
+    
+    history = model.fit(
+        train_gen,
+        steps_per_epoch=len(filepaths_train) // batch_size,
+        epochs=epochs,
+        validation_data=val_gen,
+        validation_steps=len(filepaths_val) // batch_size,
+        callbacks=callbacks,
+        verbose=1
+    )
+    
+    # 평가 (메모리 문제로 검증 데이터의 일부만 사용)
+    print("\n=== 최종 평가 ===")
+    num_eval_samples = min(len(filepaths_val), 1024) # 평가 샘플 수 제한
+    X_eval = np.array([read_binary_file(fp, max_length) for fp in filepaths_val[:num_eval_samples]])
+    y_eval = np.array(labels_val[:num_eval_samples])
+    
+    if X_eval.size > 0:
+        results = evaluate_model(model, X_eval, y_eval, batch_size=batch_size//2)
+    else:
+        print("평가할 데이터가 없습니다.")
+        results = {}
+
+    # 시각화
+    plot_training_history(history)
+    
+    print(f"\n모델이 저장되었습니다: {save_path}")
+    
+    return model, history, results
+
+def main():
+    parser = argparse.ArgumentParser(description='MalConv 모델 훈련')
+    
+    # 데이터 소스 옵션
+    parser.add_argument('--malware_dir', required=True, help='악성코드 디렉토리')
+    parser.add_argument('--benign_dir', required=True, help='정상파일 디렉토리')
+    
+    # 훈련 옵션
+    parser.add_argument('--epochs', type=int, default=20, help='에포크 수') # 에포크 증가
+    parser.add_argument('--batch_size', type=int, default=64, help='배치 크기') # 배치 크기 조정
+    parser.add_argument('--max_length', type=int, default=2_000_000, help='최대 입력 길이')
+    parser.add_argument('--save_path', default='models/malconv_model.h5', help='모델 저장 경로')
+    
+    args = parser.parse_args()
+    
+    data_source = (args.malware_dir, args.benign_dir)
+    
+    # 저장 디렉토리 생성
+    os.makedirs(os.path.dirname(args.save_path), exist_ok=True)
+    
+    # 모델 훈련
+    train_malconv(
+        data_source=data_source,
+        epochs=args.epochs,
+        batch_size=args.batch_size,
+        max_length=args.max_length,
+        save_path=args.save_path
+    )
+
+if __name__ == "__main__":
+    main()

src/tune_model.py

@@ -0,0 +1,148 @@
+import os
+import sys
+import itertools
+import numpy as np
+import tensorflow as tf
+from sklearn.model_selection import train_test_split
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from src.model import MalConv
+from src.utils import preprocess_dataset
+
+def hyperparameter_search(csv_path, 
+                         param_grid=None, 
+                         max_length=2**20,
+                         epochs=5,
+                         validation_split=0.2):
+    """
+    그리드 서치를 통한 하이퍼파라미터 최적화
+    
+    Args:
+        csv_path: 훈련 데이터 CSV 경로
+        param_grid: 하이퍼파라미터 그리드
+        max_length: 최대 입력 길이
+        epochs: 훈련 에포크 수
+        validation_split: 검증 데이터 비율
+    """
+    
+    if param_grid is None:
+        param_grid = {
+            'embedding_size': [8, 16],
+            'num_filters': [64, 128],
+            'fc_size': [64, 128],
+            'learning_rate': [0.001, 0.0001]
+        }
+    
+    print("데이터 로딩 중...")
+    X, y = preprocess_dataset(csv_path, max_length)
+    X_train, X_val, y_train, y_val = train_test_split(
+        X, y, test_size=validation_split, random_state=42, stratify=y
+    )
+    
+    # 모든 하이퍼파라미터 조합 생성
+    param_names = list(param_grid.keys())
+    param_values = list(param_grid.values())
+    param_combinations = list(itertools.product(*param_values))
+    
+    best_score = 0
+    best_params = None
+    results = []
+    
+    print(f"총 {len(param_combinations)}개의 조합을 테스트합니다.")
+    
+    for i, params in enumerate(param_combinations):
+        param_dict = dict(zip(param_names, params))
+        print(f"\n[{i+1}/{len(param_combinations)}] 테스트 중: {param_dict}")
+        
+        try:
+            # 모델 생성
+            model = MalConv(
+                max_input_length=max_length,
+                embedding_size=param_dict['embedding_size'],
+                num_filters=param_dict['num_filters'],
+                fc_size=param_dict['fc_size']
+            )
+            
+            # 컴파일
+            model.compile(
+                optimizer=tf.keras.optimizers.Adam(
+                    learning_rate=param_dict['learning_rate']
+                ),
+                loss='binary_crossentropy',
+                metrics=['accuracy']
+            )
+            
+            # 더미 입력으로 모델 빌드
+            dummy_input = np.zeros((1, max_length), dtype=np.uint8)
+            _ = model(dummy_input)
+            
+            # 훈련
+            history = model.fit(
+                X_train, y_train,
+                batch_size=16,
+                epochs=epochs,
+                validation_data=(X_val, y_val),
+                verbose=0
+            )
+            
+            # 평가
+            val_loss, val_acc = model.evaluate(X_val, y_val, verbose=0)
+            
+            result = {
+                'params': param_dict,
+                'val_accuracy': val_acc,
+                'val_loss': val_loss
+            }
+            results.append(result)
+            
+            print(f"검증 정확도: {val_acc:.4f}")
+            
+            # 최고 성능 업데이트
+            if val_acc > best_score:
+                best_score = val_acc
+                best_params = param_dict
+                print(f"새로운 최고 성능! 정확도: {best_score:.4f}")
+            
+        except Exception as e:
+            print(f"에러 발생: {e}")
+            continue
+    
+    print("\n" + "="*50)
+    print("하이퍼파라미터 튜닝 완료")
+    print("="*50)
+    print(f"최고 성능: {best_score:.4f}")
+    print(f"최적 하이퍼파라미터: {best_params}")
+    
+    # 결과 정렬
+    results.sort(key=lambda x: x['val_accuracy'], reverse=True)
+    
+    print("\n상위 5개 결과:")
+    for i, result in enumerate(results[:5]):
+        print(f"{i+1}. 정확도: {result['val_accuracy']:.4f}, "
+              f"파라미터: {result['params']}")
+    
+    return best_params, results
+
+def main():
+    csv_path = "Input/sample_data.csv"  # 실제 데이터 경로로 변경
+    
+    # 커스텀 하이퍼파라미터 그리드
+    param_grid = {
+        'embedding_size': [8, 16],
+        'num_filters': [64, 128],
+        'fc_size': [64, 128],
+        'learning_rate': [0.001, 0.0001]
+    }
+    
+    best_params, results = hyperparameter_search(
+        csv_path=csv_path,
+        param_grid=param_grid,
+        epochs=3  # 빠른 테스트를 위해 에포크 수 감소
+    )
+    
+    print(f"\n최적 하이퍼파라미터로 모델을 다시 훈련하세요:")
+    print(f"python src/train.py {csv_path} --epochs 10")
+
+if __name__ == "__main__":
+    main()

src/utils.py

@@ -0,0 +1,287 @@
+import os
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import classification_report, confusion_matrix, roc_auc_score, balanced_accuracy_score
+import matplotlib.pyplot as plt
+import seaborn as sns
+# utils.py에 누락된 import
+import tensorflow as tf  # configure_gpu_memory 함수에서 필요
+
+
+def read_binary_file(file_path, max_length=2_000_000):
+    """
+    바이너리 파일을 읽어 정수 배열로 변환
+    논문 사양: 2MB까지 처리
+    """
+    try:
+        with open(file_path, 'rb') as f:
+            raw_bytes = f.read()
+        
+        # 바이트를 0-255 정수로 변환
+        byte_array = np.frombuffer(raw_bytes, dtype=np.uint8)
+        
+        if len(byte_array) > max_length:
+            # 긴 파일: 앞 2MB만 사용 (논문 방식)
+            return byte_array[:max_length]
+        else:
+            # 짧은 파일: 0으로 패딩
+            padded = np.zeros(max_length, dtype=np.uint8)
+            padded[:len(byte_array)] = byte_array
+            return padded
+            
+    except Exception as e:
+        print(f"파일 읽기 오류 {file_path}: {e}")
+        return np.zeros(max_length, dtype=np.uint8)
+
+def load_dataset_from_directory(malware_dir, benign_dir, max_length=2_000_000, max_samples_per_class=None):
+    """
+    디렉토리에서 직접 바이너리 파일들을 로드
+    
+    Args:
+        malware_dir: 악성코드 파일들이 있는 디렉토리
+        benign_dir: 정상 파일들이 있는 디렉토리  
+        max_length: 최대 바이트 길이
+        max_samples_per_class: 클래스당 최대 샘플 수
+    """
+    X, y = [], []
+    
+    # 악성코드 파일 로드
+    if os.path.exists(malware_dir):
+        malware_files = [f for f in os.listdir(malware_dir) if os.path.isfile(os.path.join(malware_dir, f))]
+        if max_samples_per_class:
+            malware_files = malware_files[:max_samples_per_class]
+            
+        print(f"악성코드 파일 로딩 중... ({len(malware_files)}개)")
+        for i, filename in enumerate(malware_files):
+            file_path = os.path.join(malware_dir, filename)
+            byte_array = read_binary_file(file_path, max_length)
+            X.append(byte_array)
+            y.append(0)  # 악성코드 = 0
+            
+            if (i + 1) % 100 == 0:
+                print(f"  {i + 1}/{len(malware_files)} 처리 완료")
+    
+    # 정상 파일 로드
+    if os.path.exists(benign_dir):
+        benign_files = [f for f in os.listdir(benign_dir) if os.path.isfile(os.path.join(benign_dir, f))]
+        if max_samples_per_class:
+            benign_files = benign_files[:max_samples_per_class]
+            
+        print(f"정상 파일 로딩 중... ({len(benign_files)}개)")
+        for i, filename in enumerate(benign_files):
+            file_path = os.path.join(benign_dir, filename)
+            byte_array = read_binary_file(file_path, max_length)
+            X.append(byte_array)
+            y.append(1)  # 정상 = 1
+            
+            if (i + 1) % 100 == 0:
+                print(f"  {i + 1}/{len(benign_files)} 처리 완료")
+    
+    X = np.array(X)
+    y = np.array(y)
+    
+    print(f"\n데이터셋 로딩 완료:")
+    print(f"  총 샘플: {len(X)}")
+    print(f"  악성코드: {np.sum(y == 0)}")
+    print(f"  정상파일: {np.sum(y == 1)}")
+    
+    return X, y
+
+def load_dataset_from_csv(csv_path, max_length=2_000_000):
+    """CSV 파일에서 데이터셋 로드"""
+    df = pd.read_csv(csv_path)
+    
+    X, y = [], []
+    
+    print("CSV에서 파일 로딩 중...")
+    for idx, row in df.iterrows():
+        file_path = row['filepath']
+        label = row['label']
+        
+        if os.path.exists(file_path):
+            byte_array = read_binary_file(file_path, max_length)
+            X.append(byte_array)
+            y.append(label)
+        else:
+            print(f"파일을 찾을 수 없습니다: {file_path}")
+        
+        if (idx + 1) % 1000 == 0:
+            print(f"  {idx + 1} 파일 처리 완료")
+    
+    return np.array(X), np.array(y)
+
+def configure_gpu_memory():
+    """GPU 메모리 설정"""
+    gpus = tf.config.experimental.list_physical_devices('GPU')
+    if gpus:
+        try:
+            for gpu in gpus:
+                tf.config.experimental.set_memory_growth(gpu, True)
+            print(f"GPU 설정 완료: {len(gpus)}개 GPU 사용")
+            return True
+        except RuntimeError as e:
+            print(f"GPU 설정 오류: {e}")
+    return False
+
+def plot_training_history(history):
+    """훈련 히스토리 시각화"""
+    fig, axes = plt.subplots(2, 2, figsize=(12, 10))
+    
+    # Loss
+    axes[0, 0].plot(history.history['loss'], label='Training Loss')
+    if 'val_loss' in history.history:
+        axes[0, 0].plot(history.history['val_loss'], label='Validation Loss')
+    axes[0, 0].set_title('Model Loss')
+    axes[0, 0].set_xlabel('Epoch')
+    axes[0, 0].set_ylabel('Loss')
+    axes[0, 0].legend()
+    axes[0, 0].grid(True)
+    
+    # Accuracy
+    axes[0, 1].plot(history.history['accuracy'], label='Training Accuracy')
+    if 'val_accuracy' in history.history:
+        axes[0, 1].plot(history.history['val_accuracy'], label='Validation Accuracy')
+    axes[0, 1].set_title('Model Accuracy')
+    axes[0, 1].set_xlabel('Epoch')
+    axes[0, 1].set_ylabel('Accuracy')
+    axes[0, 1].legend()
+    axes[0, 1].grid(True)
+    
+    # AUC
+    if 'auc' in history.history:
+        axes[1, 0].plot(history.history['auc'], label='Training AUC')
+        if 'val_auc' in history.history:
+            axes[1, 0].plot(history.history['val_auc'], label='Validation AUC')
+        axes[1, 0].set_title('Model AUC')
+        axes[1, 0].set_xlabel('Epoch')
+        axes[1, 0].set_ylabel('AUC')
+        axes[1, 0].legend()
+        axes[1, 0].grid(True)
+    
+    # Learning Rate
+    if 'lr' in history.history:
+        axes[1, 1].plot(history.history['lr'], label='Learning Rate', color='red')
+        axes[1, 1].set_title('Learning Rate Schedule')
+        axes[1, 1].set_xlabel('Epoch')
+        axes[1, 1].set_ylabel('Learning Rate')
+        axes[1, 1].set_yscale('log')
+        axes[1, 1].legend()
+        axes[1, 1].grid(True)
+    
+    plt.tight_layout()
+    plt.show()
+
+def plot_confusion_matrix(y_true, y_pred, title="Confusion Matrix"):
+    """혼동 행렬 시각화"""
+    cm = confusion_matrix(y_true, y_pred)
+    
+    plt.figure(figsize=(8, 6))
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
+                xticklabels=['Malware', 'Benign'],
+                yticklabels=['Malware', 'Benign'])
+    plt.title(title)
+    plt.ylabel('True Label')
+    plt.xlabel('Predicted Label')
+    plt.show()
+
+def evaluate_model(model, X_test, y_test, batch_size=16):
+    """모델 성능 평가"""
+    print("모델 평가 중...")
+    
+    # 예측
+    y_pred_prob = model.predict(X_test, batch_size=batch_size, verbose=1)
+    y_pred = (y_pred_prob > 0.5).astype(int).flatten()
+    
+    # 메트릭 계산
+    accuracy = np.mean(y_pred == y_test)
+    balanced_acc = balanced_accuracy_score(y_test, y_pred)
+    auc_score = roc_auc_score(y_test, y_pred_prob)
+    
+    print(f"\n=== 평가 결과 ===")
+    print(f"Accuracy: {accuracy:.4f}")
+    print(f"Balanced Accuracy: {balanced_acc:.4f}")
+    print(f"AUC Score: {auc_score:.4f}")
+    
+    print(f"\n분류 리포트:")
+    print(classification_report(y_test, y_pred, target_names=['Malware', 'Benign']))
+    
+    # 혼동 행렬 시각화
+    plot_confusion_matrix(y_test, y_pred, "MalConv Performance")
+    
+    return {
+        'accuracy': accuracy,
+        'balanced_accuracy': balanced_acc,
+        'auc': auc_score,
+        'predictions': y_pred_prob
+    }
+
+def get_file_paths_and_labels(malware_dir, benign_dir, max_samples_per_class=None):
+    """
+    디렉토리에서 파일 경로와 레이블 목록을 가져옵니다. (메모리에 파일 로드 안함)
+    """
+    filepaths = []
+    labels = []
+
+    # 악성코드 파일 경로
+    if os.path.exists(malware_dir):
+        malware_files = [os.path.join(malware_dir, f) for f in os.listdir(malware_dir) if os.path.isfile(os.path.join(malware_dir, f))]
+        if max_samples_per_class:
+            malware_files = malware_files[:max_samples_per_class]
+        filepaths.extend(malware_files)
+        labels.extend([0] * len(malware_files)) # 악성코드 = 0
+        print(f"악성코드 파일 경로 로딩: {len(malware_files)}개")
+
+    # 정상 파일 경로
+    if os.path.exists(benign_dir):
+        benign_files = [os.path.join(benign_dir, f) for f in os.listdir(benign_dir) if os.path.isfile(os.path.join(benign_dir, f))]
+        if max_samples_per_class:
+            benign_files = benign_files[:max_samples_per_class]
+        filepaths.extend(benign_files)
+        labels.extend([1] * len(benign_files)) # 정상 = 1
+        print(f"정상 파일 경로 로딩: {len(benign_files)}개")
+        
+    print(f"\n총 파일 경로: {len(filepaths)}")
+    print(f"  악성코드: {labels.count(0)}")
+    print(f"  정상파일: {labels.count(1)}")
+
+    # 데이터 순서 섞기
+    indices = np.arange(len(filepaths))
+    np.random.shuffle(indices)
+    filepaths = np.array(filepaths)[indices].tolist()
+    labels = np.array(labels)[indices]
+
+    return filepaths, labels
+
+
+def data_generator(filepaths, labels, batch_size, max_length=2_000_000, shuffle=True):
+    """
+    데이터를 배치 단위로 생성하는 제너레이터
+    """
+    num_samples = len(filepaths)
+    if num_samples == 0:
+        return
+        
+    while True:
+        indices = np.arange(num_samples)
+        if shuffle:
+            np.random.shuffle(indices)
+        
+        for i in range(0, num_samples, batch_size):
+            batch_indices = indices[i:i+batch_size]
+            
+            X_batch = []
+            y_batch_list = []
+
+            for j in batch_indices:
+                try:
+                    X_batch.append(read_binary_file(filepaths[j], max_length))
+                    y_batch_list.append(labels[j])
+                except Exception as e:
+                    print(f"Warning: Skipping file {filepaths[j]} due to error: {e}")
+                    continue
+            
+            if not X_batch:
+                continue
+
+            yield np.array(X_batch), np.array(y_batch_list)