Portfolio


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

from datasets import load_dataset

ds = load_dataset("xodhks/EmoSet118K_MonetStyle")

emotion_classes = ["happiness", "sadness", "fear", "surprise", "anger", "disgust"]

transform = transforms.Compose([
    transforms.Resize((224, 224)), 
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])

class SketchDataset(Dataset):
    def __init__(self, data, labels, transform=None):
        self.data = data
        self.labels = labels
        self.transform = transform

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

    def __getitem__(self, idx):
        image = Image.open(self.data[idx]).convert("RGB")  
        label = self.labels[idx]
        if self.transform:
            image = self.transform(image)
        return image, label

# 모델 정의 (ResNet-18 사용)
def create_resnet_model(num_classes):
    model = models.resnet18(pretrained=True) 
    model.fc = nn.Linear(model.fc.in_features, num_classes) 
    return model

# 학습 및 평가 함수
def train_model(model, dataloader, criterion, optimizer, num_epochs=10):
    model.train()
    for epoch in range(num_epochs):
        running_loss = 0.0
        for inputs, labels in dataloader:
            inputs, labels = inputs.to(device), labels.to(device)
            
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            
            running_loss += loss.item() * inputs.size(0)
        
        epoch_loss = running_loss / len(dataloader.dataset)
        print(f"Epoch {epoch+1}/{num_epochs}, Loss: {epoch_loss:.4f}")

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
num_classes = len(emotion_classes)
model = create_resnet_model(num_classes).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

train_data = ["path/to/image1.jpg", "path/to/image2.jpg", ...]  # 이미지 경로 리스트
train_labels = [0, 1, ...]  # 각 이미지에 대한 라벨 (0~5까지의 정수로 매핑)
train_dataset = SketchDataset(train_data, train_labels, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

# 모델 학습
train_model(model, train_loader, criterion, optimizer, num_epochs=10)


import json
import requests
import openai
import base64  
from PIL import Image  # Image 클래스를 가져오는 부분
import os

# OpenAI API 키 설정
	openai.api_key = 'sk-proj-...' # API Key 사용?

# 데이터셋과 레이블 목록 설정
dataset_path = r'G:\dataset\dataset_info.json'  # JSON 파일 경로 설정
images_base_path = r'G:\dataset'  # 이미지 기본 경로 설정

# JSON 파일에서 데이터 로드
with open(dataset_path, 'r', encoding='utf-8') as f:
    dataset = json.load(f)

correct_predictions = 0

# 데이터셋 반복 처리
for data in dataset:
    # 이미지 파일 경로 가져오기
    image_filename = data['image']
    image_path = os.path.join(images_base_path, image_filename)  # 이미지 전체 경로 생성
    label = data['label']
    
    # 이미지 로드 및 base64로 인코딩
    try:
        with Image.open(image_path) as img:
            img = img.convert("RGB")  # 이미지를 RGB로 변환
            img = img.resize((256, 256))  # 이미지 크기 조정 (256x256)
            img.save("temp_image.jpg", format="JPEG")  # 임시 JPEG 이미지로 저장
            with open("temp_image.jpg", "rb") as image_file:
                image_data = image_file.read()
                image_base64 = base64.b64encode(image_data).decode('utf-8')  # 이미지를 base64로 인코딩
    except FileNotFoundError:
        print(f"파일을 찾을 수 없습니다: {image_path}")
        continue  # 이미지가 없으면 다음으로 넘어감
    
    # API 요청
    possible_labels = ["Happiness", "Disgust", "Fear", "Sadness", "Anger", "Surprise"]

    question = (
        f"Analyze the following image data and predict the emotion it represents. "
        f"Choose one of these labels only: {', '.join(possible_labels)}.\n\n"
        # f"Data: {data}\n\n"  # JSON 데이터 포함
        f"[IMAGE] {image_base64}\n\n"  # base64 인코딩된 이미지 추가
        "Provide only the label without any explanation: "
    )

    # OpenAI API 요청
    response = requests.post(
        "https://api.openai.com/v1/chat/completions",
        headers={
            "Authorization": f"Bearer {openai.api_key}",
            "Content-Type": "application/json"
        },
        json={
            "model": "gpt-4o-mini",  # GPT 비전 모델 사용
            "messages": [
                {"role": "user", "content": question}
            ],
            "max_tokens": 50,
        }
    )

    # API 응답 출력
    # print(f"Response from API: {response.text}")  # 응답 출력

    # 예측된 라벨 추출
    if response.status_code == 200:
        answer = response.json()
        predicted_label = answer['choices'][0]['message']['content'].strip()
    else:
        print(f"API 요청 실패: {response.status_code} - {response.text}")
        continue

    # 예측이 맞는지 확인
    if predicted_label == label:
        correct_predictions += 1

# 임시 파일 삭제
if os.path.exists("temp_image.jpg"):
    os.remove("temp_image.jpg")

# 정확도 출력
accuracy = correct_predictions / len(dataset)
print(f"Model accuracy: {accuracy * 100:.2f}%")


from langchain import PromptTemplate, LLMChain
from langchain.llms import HuggingFaceHub
from transformers import pipeline

# 1. 감정 분석 및 설명을 위한 Prompt 정의
prompt = """
주어진 문장의 감정을 분석하고 자세히 설명하세요.

문장: "{text}"
결과: 문장의 주요 감정은 다음과 같습니다~
"""

# 2. LangChain의 PromptTemplate 설정
template = PromptTemplate(input_variables=["text"], template=prompt)

# 3. HuggingFace LLM 연결 (Hugging Face Hub 모델 활용)
llm = HuggingFaceHub(repo_id="google/flan-t5-large", model_kwargs={"temperature": 0.7, "max_length": 256})

# 4. LangChain의 LLMChain 구성
emotion_chain = LLMChain(llm=llm, prompt=template)

# 5. 감정 분석 코드 실행
def analyze_emotion(text):
    """
    입력 텍스트를 기반으로 감정을 분석하고 설명을 생성합니다.
    """
    result = emotion_chain.run(text)
    return result

# 예제 문장 분석
input_text = "오늘은 정말 기분이 좋아요! 날씨도 화창하고 모든 것이 잘 풀리고 있어요."
output = analyze_emotion(input_text)

print("감정 분석 결과:")
print(output)

[11-19] 데이터 수집 + LLM?

1. ResNet-LoRA?

2. LLM 사용