autoencoder, feature concatenate, Global Average Pooling

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
from torch.utils.data import Dataset, DataLoader
import os
from PIL import Image

class CustomImageDataset(Dataset):
    def __init__(self, img_dir, transform=None):
        self.img_dir = img_dir
        self.img_names = os.listdir(img_dir)
        self.transform = transform

    def __len__(self):
        return len(self.img_names)

    def __getitem__(self, idx):
        img_path = os.path.join(self.img_dir, self.img_names[idx])
        image = Image.open(img_path).convert('RGB')
        if self.transform:
            image = self.transform(image)
        return image

# 데이터 로딩 및 전처리
data_path = "C:\\Users\\intern2024\\Desktop\\train\\unlabeled\\M1"
transform = transforms.Compose([transforms.Resize((224, 224)), transforms.ToTensor()])
dataset = CustomImageDataset(data_path, transform=transform)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

# 모델 정의
class ConvAutoencoder(nn.Module):
    def __init__(self):
        super(ConvAutoencoder, self).__init__()
        
        # Encoder layers
        self.encoder = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, stride=2, padding=1),
            nn.ReLU(),
            nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1),
            nn.ReLU(),
            nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1),
            nn.ReLU(),
            nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1),
            nn.ReLU(),
            nn.Conv2d(256, 512, kernel_size=3, stride=2, padding=1),
            nn.ReLU(),
        )
        
        # Decoder layers
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(512, 256, kernel_size=3, stride=2, padding=1, output_padding=1),
            nn.ReLU(),
            nn.ConvTranspose2d(256, 128, kernel_size=3, stride=2, padding=1, output_padding=1),
            nn.ReLU(),
            nn.ConvTranspose2d(128, 64, kernel_size=3, stride=2, padding=1, output_padding=1),
            nn.ReLU(),
            nn.ConvTranspose2d(64, 32, kernel_size=3, stride=2, padding=1, output_padding=1),
            nn.ReLU(),
            nn.ConvTranspose2d(32, 3, kernel_size=3, stride=2, padding=1, output_padding=1),
            nn.Sigmoid(),
        )

    def forward(self, x):
        x = self.encoder(x)
        x = self.decoder(x)
        return x

# 모델 생성
model = ConvAutoencoder()

# 손실 함수 및 최적화 알고리즘 설정
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 학습 시작
num_epochs = 10  # 학습 횟수
for epoch in range(num_epochs):
    for data in dataloader:
        img = data
        output = model(img)
        loss = criterion(output, img)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
    print(f'Epoch: {epoch+1}, Loss: {loss.item()}')

torch.save(model.state_dict(), 'model.pth')

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
from torch.utils.data import Dataset, DataLoader
import os
from PIL import Image
import scipy.io
from scipy.io import savemat
import numpy as np
import scipy.io as sio

class ConvAutoencoder(nn.Module):
    def __init__(self):
        super(ConvAutoencoder, self).__init__()
          
        # Encoder layers
        self.encoder = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, stride=2, padding=1),
            nn.ReLU(),
            nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1),
            nn.ReLU(),
            nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1),
            nn.ReLU(),
            nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1),
            nn.ReLU(),
            nn.Conv2d(256, 512, kernel_size=3, stride=2, padding=1),
            nn.ReLU(),
        )

        # Decoder layers
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(512, 256, kernel_size=3, stride=2, padding=1, output_padding=1),
            nn.ReLU(),
            nn.ConvTranspose2d(256, 128, kernel_size=3, stride=2, padding=1, output_padding=1),
            nn.ReLU(),
            nn.ConvTranspose2d(128, 64, kernel_size=3, stride=2, padding=1, output_padding=1),
            nn.ReLU(),
            nn.ConvTranspose2d(64, 32, kernel_size=3, stride=2, padding=1, output_padding=1),
            nn.ReLU(),
            nn.ConvTranspose2d(32, 3, kernel_size=3, stride=2, padding=1, output_padding=1),
            nn.Sigmoid(),
        )

    def forward(self, x):
        x = self.encoder(x)
        return x  # Decoder 부분 제거

# 학습시킨 모델 로드
model = ConvAutoencoder()
model.load_state_dict(torch.load('model.pth'))
model.eval()

class CustomImageDataset(Dataset):
    def __init__(self, img_dir, transform=None):
        self.img_dir = img_dir
        self.img_names = os.listdir(img_dir)
        self.transform = transform

    def __len__(self):
        return len(self.img_names)

    def __getitem__(self, idx):
        img_path = os.path.join(self.img_dir, self.img_names[idx])
        image = Image.open(img_path).convert('RGB')
        if self.transform:
            image = self.transform(image)
        return image, self.img_names[idx]  # 이미지 이름도 반환
        
save_dir = "C:\\Users\\intern2024\\Desktop\\feature_scae\\class1"

# 새로운 이미지셋 로드
new_data_path = r"C:\Users\intern2024\Desktop\new_labeled_data\class1"
transform = transforms.Compose([transforms.Resize((224, 224)), transforms.ToTensor()])
new_dataset = CustomImageDataset(new_data_path, transform=transform)
new_dataloader = DataLoader(new_dataset, batch_size=1, shuffle=False)

with torch.no_grad():
    for idx, (data, img_name) in enumerate(new_dataloader):  # 이미지 이름
        img = data
        output = model(img)
        
        # 첫 번째 차원 제거
        output = np.squeeze(output, axis=0)
        
        # feature_map2의 축 변경
        output = np.transpose(output, (1, 2, 0))
        
        # feature map의 사이즈 출력
        print(f'Feature map size: {output.size()}')

        # 이미지 이름을 기반으로 mat 파일 저장
        npy_file_name = os.path.splitext(img_name[0])[0]  # 확장자 제거
        np.save(os.path.join(save_dir, f'{npy_file_name}.npy'), output.cpu().numpy())

SCAE 
autoencoder에서 feature map 추출

import os
import numpy as np
import scipy.io as sio

# .npy 파일이 있는 두 디렉토리
npy_dir1 = r"C:\Users\intern2024\Desktop\feature_resnet\class1"
npy_dir2 = r"C:\Users\intern2024\Desktop\feature_scae\class1"

# 결과를 저장할 디렉토리
save_dir = r"C:\Users\intern2024\Desktop\feature_fusion\class1"

# 첫 번째 디렉토리 내의 모든 파일 순회
for filename in os.listdir(npy_dir1):
    # .npy 파일만 처리
    if filename.endswith('.npy'):
        # 두 번째 디렉토리에 같은 이름의 파일이 있는지 확인
        if filename in os.listdir(npy_dir2):
            # 두 .npy 파일 불러오기
            feature_map1 = np.load(os.path.join(npy_dir1, filename), allow_pickle=True)
            feature_map2 = np.load(os.path.join(npy_dir2, filename), allow_pickle=True)

            # 두 feature map을 concatenate
            
            concatenated = np.concatenate((feature_map1, feature_map2), axis=2)  
            # channel 차원을 따라 concatenate

            print(concatenated.shape)
            # concatenate한 feature map을 같은 이름의 .mat 파일로 저장
            sio.savemat(os.path.join(save_dir, filename.replace('.npy', '.mat')), {'matrix': concatenated})

feature fusion (concatenate)

 

from keras.layers import GlobalAveragePooling2D, Reshape, Dense
from keras.models import Sequential
import scipy.io
import os
import numpy as np

# 경로 설정
folder_path = r'C:\Users\intern2024\Desktop\feature_fusion\class3'
output_folder_path = r'C:\Users\intern2024\Desktop\gap\class3'

# 모든 mat 파일 목록 가져오기
mat_files = [file for file in os.listdir(folder_path) if file.endswith('.mat')]

# 전체 features를 저장할 리스트
all_features = []

# 7,7,1024 크기의 입력을 받는 모델 생성
model = Sequential()
model.add(Reshape((7,7,1024), input_shape=(7,7,1024)))

# Global Average Pooling 적용
model.add(GlobalAveragePooling2D(keepdims=True)) # 차원 유지

# Fully Connected Layer 추가하여 feature 차원 조절
model.add(Dense(512, activation='relu'))

# 모든 mat 파일에 대해 반복
for file_name in mat_files:
    # mat 파일 로드
    mat_data = scipy.io.loadmat(os.path.join(folder_path, file_name))
    
    # mat 파일에서 features 추출
    features = mat_data['matrix']
    
    # global average pooling
    pooled_features = model.predict(np.expand_dims(features, axis=0))
    pooled_features = np.squeeze(pooled_features, 2)
    
    # pooled_features의 차원 출력
    print(f'Pooled Features Shape: {pooled_features.shape}')
    
    # 새로운 mat 파일로 저장 (파일명 그대로)
    scipy.io.savemat(os.path.join(output_folder_path, file_name), {'matrix': pooled_features})

Global Average Pooling