Upload 2 files

Autoencoder.py

@@ -0,0 +1,63 @@
+import torch
+import torch.nn as nn
+
+class DenseAutoencoder(nn.Module):
+    def __init__(self, input_dim=784, hidden_dims=[256, 64], latent_dim=32):
+        super().__init__()
+        
+        # Encoder
+        encoder_layers = []
+        prev_dim = input_dim
+        for h in hidden_dims: # [256, 64]
+            encoder_layers += [nn.Linear(prev_dim, h), nn.ReLU()]
+            prev_dim = h
+        encoder_layers.append(nn.Linear(prev_dim, latent_dim)) 
+        self.encoder = nn.Sequential(*encoder_layers)
+        
+        # Decoder
+        decoder_layers = []
+        prev_dim = latent_dim
+        for h in reversed(hidden_dims): # [64, 256]
+            decoder_layers += [nn.Linear(prev_dim, h), nn.ReLU()]
+            prev_dim = h
+            
+        # 마지막 출력 레이어 (Sigmoid 제거)
+        decoder_layers.append(nn.Linear(prev_dim, input_dim)) 
+        self.decoder = nn.Sequential(*decoder_layers)
+    
+    def forward(self, x):
+        z = self.encoder(x)
+        x_hat = self.decoder(z)
+        return x_hat, z
+
+# --- 이 스크립트가 직접 실행될 때만 아래 코드가 동작합니다 ---
+if __name__ == "__main__":
+    
+    # 1. 모델 인스턴스 생성
+    model = DenseAutoencoder(latent_dim=32)
+    
+    # 2. 테스트용 더미 데이터 생성
+    #    (Batch_Size, Input_Dim)
+    #    MSELoss를 사용하므로 randn으로 생성
+    batch_size = 64
+    x = torch.randn(batch_size, 784)
+    
+    print(f"원본 데이터(x) shape: {x.shape}")
+    
+    # 3. 모델 실행 (Forward pass)
+    x_hat, z = model(x)
+    
+    print(f"압축된 잠재 벡터(z) shape: {z.shape}")
+    print(f"복원된 데이터(x_hat) shape: {x_hat.shape}")
+    
+    # 4. 손실(Loss) 계산
+    #    모델 출력이 Linear이므로 MSELoss 사용
+    loss_fn = nn.MSELoss()
+    loss = loss_fn(x_hat, x)
+    
+    print(f"\n계산된 손실(MSELoss): {loss.item()}")
+    
+    # 5. 역전파 (Backpropagation)
+    loss.backward()
+    
+    print("역전파 완료")

CNN_AutoEncoder.py

@@ -0,0 +1,66 @@
+import torch
+import torch.nn as nn
+
+class CNNAutoencoder(nn.Module):
+    def __init__(self, latent_dim=32):
+        super().__init__()
+        # Encoder
+        self.encoder = nn.Sequential(
+            # (B, 1, 28, 28)
+            nn.Conv2d(1, 16, 3, padding=1), nn.ReLU(), # (B, 16, 28, 28)
+            nn.MaxPool2d(2, 2), # (B, 16, 14, 14)
+            nn.Conv2d(16, 32, 3, padding=1), nn.ReLU(), # (B, 32, 14, 14)
+            nn.MaxPool2d(2, 2), # (B, 32, 7, 7)
+            nn.Flatten(),
+            nn.Linear(32*7*7, latent_dim) # (B, 32)
+        )
+        
+        # Decoder
+        self.decoder_input = nn.Linear(latent_dim, 32*7*7)
+        self.decoder = nn.Sequential(
+            nn.Unflatten(1, (32, 7, 7)),
+            # (B, 32, 7, 7)
+            nn.ConvTranspose2d(32, 16, 2, stride=2), nn.ReLU(),
+            # (B, 16, 14, 14)
+            nn.ConvTranspose2d(16, 1, 2, stride=2), 
+            # (B, 1, 28, 28)
+            nn.Sigmoid()
+        )
+    
+    def forward(self, x):
+        z = self.encoder(x)
+        z_dec = self.decoder_input(z)
+        x_hat = self.decoder(z_dec)
+        return x_hat, z
+
+# --- 이 스크립트가 직접 실행될 때만 아래 코드가 동작합니다 ---
+if __name__ == "__main__":
+    
+    # 1. 모델 인스턴스 생성
+    model = CNNAutoencoder(latent_dim=32)
+    
+    # 2. 테스트용 더미 데이터 생성
+    #    (Batch_Size, Channels, Height, Width)
+    #    BCELoss를 사용하기 위해 0과 1 사이의 값으로 생성 (torch.rand)
+    batch_size = 64
+    x = torch.rand(batch_size, 1, 28, 28)
+    
+    print(f"원본 데이터(x) shape: {x.shape}")
+    
+    # 3. 모델 실행 (Forward pass)
+    x_hat, z = model(x)
+    
+    print(f"압축된 잠재 벡터(z) shape: {z.shape}")
+    print(f"복원된 데이터(x_hat) shape: {x_hat.shape}")
+    
+    # 4. 손실(Loss) 계산
+    #    모델 출력이 Sigmoid이므로 BCELoss 사용
+    loss_fn = nn.BCELoss()
+    loss = loss_fn(x_hat, x)
+    
+    print(f"\n계산된 손실(BCELoss): {loss.item()}")
+    
+    # 5. 역전파 (Backpropagation)
+    loss.backward()
+    
+    print("역전파 완료")