[🔔TIL] 추천 시스템을 설계해보자.

본 내용의 출처는 262가지 문제로 정복하는 코딩 인터뷰 in Java에 있으며, 추가한 내용이 있을 수 있습니다.

Day1

---

☁️ Intro: 주로 사용하는 추천 알고리즘은 무엇일까?

• 출처
  • 추천 시스템, 추천 알고리즘 종류
  • [추천시스템] 추천시스템 A to Z : 추천 알고리즘의 종류

추천 시스템?

• 인터넷이 발전됨에 따라 아이템 구매 및 선호에 대한 사용자의 피드백을 얻기 쉬워졌고, 이러한 피드백을 바탕으로 과거의 사용자 - 아이템 간 데이터를 분석해 아이템을 추천하는 것이 추천 시스템의 기본적 아이디어.
• 즉, User의 선호 Item을 예측하는 시스템.

추천 시스템의 구조

• 전체 구조는 "후보를 생성하는 단계"와 "랭킹을 매기는 단계"로 구분

1. 후보를 생성하는 단계
   a. 수백만 개 아이템 중 사용자의 활동 기록 기반으로 후보가 될 아이템들을 선정하는 단계
   b. 높은 정밀도로 사용자와 관련이 있고, 협업 필터링을 통해서만 광범위한 개인화를 제공
   c. list에서 최상의 list를 제시하기 위해서는 recall이 높은 후보 간 상대적 중요성 구분을 위해 세밀한 수준의 표현이 필요
   
   
2. 랭킹을 매기는 단계
   a. 아이템과 사용자를 설명하는 Feature를 사용해 원하는 목적 함수에 따라 각 아이템에 점수를 할당해 가장 높은 점수를 받은 아이템이 점수에 따라 순위가 매겨져 사용자에게 표시

대표적인 추천 알고리즘

• Collaborative Filtering : 협업 필터링
• Content-based Recommender Systems : 컨텐츠 기반 추천 시스템
• Knowledge-based Systems : 지식 기반 추천 시스템
  

추천 알고리즘의 목표

• Prediction version of Problem(=Matrix Completion Problem)
  • 학습 데이터를 통해 유저의 선호도를 정확히 예측하는 것이 목적
  • 일반적인 목적(이를 해결해야 Ranking 문제도 해결 가능하기 때문)
• Ranking version of Problem
  • 정확한 수치 예측이 아닌, 랭킹을 고려한 top-k 아이템 선정이 목적
  • 현실적으로 상품을 고를 때 상대적으로 더 좋은 것을 구매함(점수를 각각 정확히 구해서 비교하는 것은 아니기 때문에) Ranking 문제가 더 자연스러움

Basic Models of Recommender Systems

• 협업 필터링(Collaborative Filtering)

  • 두 명의 사용자가 비슷한 관심사를 가지고 있다면, 한 사용자의 데이터를 바탕으로 다른 사용자에게 추천하는 방식

  • 사용자 간의 선호도를 서로 고려해 많은 선택사항들로부터 아이템을 걸러내거나 선택

    
    

  • Memory-Based methods

    • neighborhood - based collaborative filtering algorithms 라고도 불림.
    • 사용자 기반 추천(User-based collaborative filtering)
      • 유저 간의 유사도가 높을수록 가중치를 부여
      • 같은 그룹의 다른 유저가 선호하는 아이템을 추천
      • 일반적으로 특정 A와 유사한 Top K의 유사한 유저들로 그룹을 구성해 선호 아이템 추천
    • 아이템 기반 추천 (Item-based collaborative filtering)
      • B라는 아이템에 대한 유저의 선호도를 예측을 위해 B와 가장 유사한 Top K 아이템을 선정하여 Item Set을 구성
    
    

  • Model - based methods

    • 머신러닝, 데이터 마이닝 방법에서의 예측 모델 context를 기반한 방법
    • 모델이 파라미터화되어 있다면, 이 모델의 파라미터는 context 내에서 학습됨.
    
    

  • 협업 필터링의 한계점
    콜드 스타트

    • 앞의 결과를 이용해 동작하므로 데이터가 없는 상태에서는 제대로 동작하지 않음.
    • 협업 필터링은 사용자들의 데이터를 기반으로 하기 때문에 신규 사용자에게는 아무런 정보가 없어 추천할 수 없는 상황 발생

    계산 효율 저하

    • 협업 필터링은 상당히 많은 계산량을 요구 -> 사용자 수 증가 -> 계산 시간이 더욱 길어짐
    • 사용자 수가 많아 데이터가 쌓이게 되면 정확도는 높일 수 있으나, 그만큼 시간이 오래 걸려 효율성이 떨어짐.

    롱테일

    • 사용자들이 소수의 인기 있는 항목에만 관심을 보여 관심이 저조한 항목은 추천되지 못하는 문제점 발생
    • 즉, 소수의 인기 컨텐츠가 전체 컨텐츠 비율을 차지하는 현상이 나타남.
  
  

• 컨텐츠 기반 필터링(Content based Filtering)

  • 사용자가 과거에 경험했던 아이템 중 비슷한 아이템을 현재 시점에서 추천하는 것

  • 정보를 찾는 과정과 과거 정보를 활용해 유저의 성향을 배우는 문제임.

    
    

  • 데이터 획득 후, 컨텐츠 분석에서 비정형 데이터로부터 관련 있는 정보를 얻는 작업이 필요

    • feature extraction, vector representation 등의 작업을 수행
    • 유저가 선호하는 아이템과 취향을 파악하는 유저 프로필 파악
    • cosine 유사도를 이용하여 유사 아이템 선택
  
  
  • 컨텐츠 기반 필터링의 한계점
    다양한 항목 추천에 대한 어려움
    • 콘텐츠 기반 필터링은 내용 자체를 분석하기 때문에 협업 필터링의 한계인 콜드 스타트 문제를 해결할 수 있음.
    • 그러나 음악, 사진, 영상을 동시에 추천해야한다고 할 때, 각 항목에서 추출할 수 있는 정보가 다 다르다보니 프로파일을 구성에 어려움이 있음.
    • 즉, 다양한 항목 추천에는 다소 어려움이 있음.

• 하이브리드 필터링(Hybrid Filtering)
  • 협업 필터링 + 지식 기반 추천 시스템 결합

Day2

---

☁️ 추천 시스템을 설계하는 방법

🔎 현재 기사와 관련 있는 기사를 자동으로 배치해주는 시스템을 설계하라.

Hint : 기술적 핵심은 관련 있는 기사의 리스트를 알아내는 것

• Solution 01
  • 최근에 인기 있는 문서를 추가하는 것
    • Jingle에서 사람을 고용해 중요해 보이는 문서에 태그를 달도록 할 수 있음.
    • 그 외에도 금융, 스포츠, 정치와 관련된 태그를 문서에 추가할 수 있음.
    • 태그 -> HTML의 메타 태그 혹은 페이지 제목에서 얻어올 수도 있음.

• Solution 02
  • 최근 뉴스 기사를 추가하는 것
    • 임의로 선택한 기사를 임의의 독자에게 보낸 뒤 해당 기사들이 얼마나 인기 있는지 확인할 수 있음.
    • 인기 있는 기사는 더 자주 읽힐 것임.

• Solution 03
• 자동 문서 분석(automatic textual analysis)
  • 좀 더 정교한 방식, 두 쌍의 기사가 얼마나 비슷한지 값을 구해 사용
  • 비슷한 정도 = 실수 값
  • 두 기사 사이 공통된 단어가 얼마나 많은지를 측정
  • 고려할 점
    • "for"나 "the"와 같이 흔하게 등장하는 단어 무시
    • 자주 등장하지 않는 "arbitrage"나 "diesel"과 같은 단어는 "sale"이나 "international"과 같이 흔한 단어보다는 더 중요하게 다뤄져야 함.

• 문서 분석 시, 여러 가지 문제를 직면하게 될 것.

  • 두 단어의 스펠링이 같아도 뜻이 다를 수 있음
    • 문맥에 따라, 즉 주제가 AIDS인지 컴퓨터 보안인지에 따라 anti-virus의 뜻이 달라질 수 있음.
    • 이러한 상황에서, 많은 사용자의 정보를 모아 협업 필터링(collaborative filtering) 을 적용하는 것이 도움이 될 수 있음.

• 웹 서버 로그 파일의 쿠기와 타임스탬프를 살펴보기

  • 사용자가 어떤 기사를 읽었는지 알 수 있음.
  • 같은 세션 안에서 A와 B를 함께 읽은 사용자가 많다면, A를 읽은 사용자에게 B를 추천해도 될 것.
    
    
    
    

Day3

---

☁️ 스프링부트를 활용하는 추천 시스템 설계 찾아보기

참고 교재 : 추천 시스템 입문

장르 기반 추천 시스템
1️⃣[SpringBoot] 장르기반 간단한 영화 추천 API 설계하기
2️⃣ [토이 프로젝트] 영화 추천
3️⃣ 스프링부트와 머신러닝 모델을 이용한 추천 엔진 구현
4️⃣ 협업 필터링

실시간 추천 시스템
1️⃣ 실시간 추천시스템 구현방법 문의

Day4

---

☁️ 스프링부트를 활용한 영화 추천 API를 설계해보자.

출처

• [SpringBoot] 장르기반 간단한 영화 추천 API 설계하기 #1
• [ SpringBoot ] 장르 기반 간단한 영화 추천 API 설계하기 #2
• 스프링부트와 머신러닝 모델을 이용한 추천 엔진 구현

SpringBoot 영화 추천 API 설계 과정

코드 및 내용에 대한 출처는 위의 1, 2번 링크에 있습니다!

시나리오

• MovieLense 데이터 활용 -> 데이터를 MySQL에 모두 저장
• 사용자에게 전체 영화 리스트 넘기기
• 사용자는 서버에 10개의 영화를 선택해 다시 전송
• 사용자가 선택한 영화에서 장르만 추출(가장 많이 선택된 장르 2개 선정)
• 전체 영화 리스트 중 선택된 장르 2개가 포함된 영화들을 추천 영화로 반환

Dependency

• 필요한 의존성 주입
  • 필수 : Spring data JPA, QueryDSL, MySQL

MovieLens 데이터

• MovieLens dataset의 small 데이터 활용

영화 데이터 적재

• 엔티티 설정

  • id : 기본키
  • title : 영화 제목
  • tid : tmdb Id(Frontend 측 고려)
  • genres : Genres를 set 형태로 가지고 있도록 설정
  
  

  😊 MovieEntity

  • 영화 엔티티

  😊 GenresEntity

  • 장르 엔티티

• 컨트롤러
  😊 dummyController

  • 데이터베이스에 모든 영화 정보를 기록하는 과정
  • movies.csv 파일을 읽어 line 기준으로 파싱하기
  • movieId, title의 경우 ','를 기준으로 split
  • 특히, 장르의 경우 | 를 기반으로 나뉨.

  //첫번째 라인 제외 -> skipFirstLine 변수 사용
  movieRepo.save(Movies.builder()
                    .id(movieId).tId(MovieIdToTid.get(movieId))
                    .title(title.toString())
                    .genres(Arrays.stream(genre)
                            .map(genreService::findOrCreateNew)
                            .collect(Collectors.toSet()))
                    .build());

  //findOrCreateNew 메서드 -> 데이터베이스에 해당 이름의 장르가 존재하면 그 장르 사용 or 없다면 새로 저장
  package com._chanho.movie_recommendation.genre;
  
  import lombok.RequiredArgsConstructor;
  import org.springframework.stereotype.Service;
  
  @Service
  @RequiredArgsConstructor
  public class GenreService {
      private final GenresRepo genresRepo;
  
      public Genres findOrCreateNew(String name) {
          return genresRepo.findByName(name).orElseGet(
                  () -> genresRepo.save(new Genres(name))
          );
      }
  }

  //movieId -> tmdbId 변환을 위한 빈 등록
  package com._chanho.movie_recommendation.api;
  
  import lombok.RequiredArgsConstructor;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  
  import java.io.*;
  import java.util.HashMap;
  import java.util.Map;
  
  @Configuration
  @RequiredArgsConstructor
  public class AppConfig {
  
      @Bean
      public Map<Long, Long> MovieIdToTid() {
          Map<Long, Long> movieIdToTid = new HashMap<>();
  
          File csv = new File("{your_path}\\links.csv");
          BufferedReader br = null;
          try {
              br = new BufferedReader(new BufferedReader(new FileReader(csv)));
          } catch (FileNotFoundException e) {
              e.printStackTrace();
          }
  
          String line = "";
          boolean skipFirstLine = true;
          while (true) {
              try {
                  assert br != null;
                  if ((line = br.readLine()) == null) break;
              } catch (IOException e) {
                  e.printStackTrace();
              }
  
              if (skipFirstLine) {
                  skipFirstLine = false;
                  continue;
              }
  
              String[] token = line.split(",");
  
              if(token.length > 2) {
                  Long movieId = Long.parseLong(token[0]);
                  Long tId = Long.parseLong(token[2]);
  
                  movieIdToTid.put(movieId, tId);
              }
  
          }
          return movieIdToTid;
      }
  }

• link.csv
  • movieId에 해당하는 tmdbId가 없는 경우도 있어, 있는 경우만 반환하기 위해 예외 처리 필요

😊 MovieController

• 전체 영화를 반환해주는 컨트롤러 작성

• Pagenation을 통해 100개씩 자르기

  package com._chanho.movie_recommendation.movie;
  
  import com._chanho.movie_recommendation.genre.Genres;
  import lombok.RequiredArgsConstructor;
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.data.domain.Page;
  import org.springframework.data.domain.Pageable;
  import org.springframework.data.web.PageableDefault;
  import org.springframework.http.HttpStatus;
  import org.springframework.http.ResponseEntity;
  import org.springframework.web.bind.annotation.*;
  
  import javax.persistence.criteria.CriteriaBuilder;
  import java.util.*;
  import java.util.stream.Collectors;
  
  @Slf4j
  @RestController
  @RequiredArgsConstructor
  @RequestMapping("/api/movie")
  public class MovieController {
      private final MovieRepo movieRepo;
      private final MovieService movieService;
  
      @GetMapping("/movies")
      public ResponseEntity retrieveMovies(@PageableDefault(size = 100) Pageable pageable) {
          return movieService.retrieveMovies(pageable);
      }
  
      @PostMapping("/recommendation")
      public List<Movies> getRecommendation(@RequestBody RecommendationDto recommendationDto) {
          HashMap<Genres, Integer> pickedGenres = movieService.getPickedGenres(recommendationDto);
          HashMap<Genres, Integer> pickedGenresWithSort = movieService.sortByValue(pickedGenres);
          Set<Genres> selectBestInKeys = movieService.selectKeyInMap(pickedGenresWithSort);
          return movieRepo.findByGenres(selectBestInKeys, recommendationDto);
      }
  }

• 서비스
  😊 MovieService

  import org.springframework.stereotype.Service;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.RequestMapping;
  
  import javax.transaction.Transactional;
  import java.util.*;
  import java.util.stream.Collectors;
  
  @Slf4j
  @Service
  @Transactional
  @RequiredArgsConstructor
  public class MovieService {
  
      private final MovieRepo movieRepo;
      private final GenresRepo genresRepo;
  
      public ResponseEntity retrieveMovies(Pageable pageable) {
          Page<Movies> moviesPage = movieRepo.findAll(pageable);
          return new ResponseEntity<>(moviesPage, HttpStatus.OK);
      }
  
      public HashMap<Genres, Integer> sortByValue(HashMap<Genres, Integer> raw) {
          return raw.entrySet()
                  .stream()
                  .sorted((i1, i2) -> i1.getValue().compareTo(i2.getValue()))
                  .collect(Collectors.toMap(
                          Map.Entry::getKey,
                          Map.Entry::getValue,
                          (e1, e2) -> e2, LinkedHashMap::new
                  ));
      }
  
      public HashMap<Genres, Integer> getPickedGenres(RecommendationDto recommendationDto) {
          HashMap<Genres, Integer> pickedGenres = new HashMap<>();
          recommendationDto.getPickedMovies().forEach(
                  movieData -> {
                      Movies movie = movieRepo.findById(movieData.getMovieId()).orElseThrow(
                              () -> new IllegalStateException("Cannot find Movies with given id: " + movieData.getMovieId().toString()));
  
                      Set<Genres> genresList = movie.getGenres();
                      for(Genres g : genresList) {
                          Integer count = pickedGenres.getOrDefault(g, 0);
                          pickedGenres.put(g, count);
                      }
                  }
          );
  
          return pickedGenres;
      }
  
      public Set<Genres> selectKeyInMap(HashMap<Genres, Integer> pickedGenresWithSort) {
          Iterator<Genres> keys = pickedGenresWithSort.keySet().iterator();
          Set<Genres> selectBestInKeys = new HashSet<>();
          int count = 0;
          while(keys.hasNext() && count < 2) {
              Genres genres = keys.next();
              selectBestInKeys.add(genres);
              count++;
          }
  
          return selectBestInKeys;
      }
  }

  
  

• DTO
  😊 RecommendationDTO

  • sortByValue는 Value를 기준으로 Map 값을 내림차순으로 정렬하는 메서드
  • 가장 많이 선택된 장르 2가지만 사용해 매칭되는 영화 정보 가져오기
  • selectKeyInMap은 정렬된 Map에서 가장 많이 선택된 장르 2개를 넣어 반환해주는 메서드

  package com._chanho.movie_recommendation.movie;
  
  import lombok.AllArgsConstructor;
  import lombok.Builder;
  import lombok.Data;
  import lombok.NoArgsConstructor;
  
  import java.util.List;
  
  @Data @Builder
  @NoArgsConstructor @AllArgsConstructor
  public class RecommendationDto {
      private Long userId;
      private List<MovieData> pickedMovies;
  }
  
  @Data @Builder
  class MovieData{
      private Long tId;
      private Long movieId;
      private Double rating;
  }

• Repository

  • QueryDSL 적용

  • 2개의 Predacate 만들기

  • 1. 선택된 2개의 Genres가 모두 포함되어 있는지?
  • 2. 이미 recommendationDTO에 포함된 영화가 아닌지?

  • Genres table과 left join 해서 fetch하기

    😊 MovieRepo

    package com._chanho.movie_recommendation.movie;
    
    import org.springframework.data.domain.Page;
    import org.springframework.data.domain.Pageable;
    import org.springframework.data.jpa.repository.EntityGraph;
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.stereotype.Repository;
    
    import javax.transaction.Transactional;
    
    @Repository
    public interface MovieRepo extends JpaRepository<Movies, Long>, MovieRepoExtension {
    
        @EntityGraph(value = "Movies.withGenres", type= EntityGraph.EntityGraphType.FETCH)
        Page<Movies> findAll(Pageable pageable);
    }

    
    

    😊 MovieRepoExtension

    package com._chanho.movie_recommendation.movie;
    
    import com._chanho.movie_recommendation.genre.Genres;
    
    import java.util.List;
    import java.util.Set;
    
    public interface MovieRepoExtension {
        List<Movies> findByGenres(Set<Genres> genres, RecommendationDto recommendationDto);
    }

    
    

    😊 MovieRepoExtensionImpl

    package com._chanho.movie_recommendation.movie;
    
    import com._chanho.movie_recommendation.genre.Genres;
    import com._chanho.movie_recommendation.genre.QGenres;
    import com.querydsl.core.BooleanBuilder;
    import com.querydsl.jpa.JPQLQuery;
    import org.springframework.data.jpa.repository.support.QuerydslRepositorySupport;
    
    import java.util.List;
    import java.util.Set;
    
    public class MovieRepoExtensionImpl extends QuerydslRepositorySupport implements MovieRepoExtension {
        public MovieRepoExtensionImpl() {
            super(Movies.class);
        }
    
        @Override
        public List<Movies> findByGenres(Set<Genres> genres, RecommendationDto recommendationDto) {
            com._chanho.movie_recommendation.movie.QMovies movies
                    = com._chanho.movie_recommendation.movie.QMovies.movies;
    
            BooleanBuilder containGenres = new BooleanBuilder();
            genres.forEach(genre -> {
                containGenres.and(movies.genres.contains(genre));
            });
    
            BooleanBuilder notInRecommendation = new BooleanBuilder();
            recommendationDto.getPickedMovies().forEach(movieData -> {
                notInRecommendation.and(movies.id.notIn(movieData.getMovieId()));
            });
    
            JPQLQuery<Movies> query = from(movies)
                    .where(containGenres)
                    .where(notInRecommendation)
                    .leftJoin(movies.genres, QGenres.genres).fetchJoin()
                    .distinct().limit(10);
    
            return query.fetch();
        }
    }

추천 엔진 포커스 설명

🔎 스프링부트와 머신러닝 모델을 이용한 추천 엔진 구현하기

코드 및 내용에 대한 출처는 위의 3번 링크에 있습니다!

추천 엔진?

• 사용자에게 맞춤형 추천을 제공하기 위해 다양한 알고리즘과 데이터 분석 기법을 사용하는 시스템

• 일반적인 스프링부트 기초 세팅은 비슷하기 때문에 별도의 설명은 적지 않음.

• 머신러닝 모델 준비

  • 데이터 준비

    • 사용자 리뷰, 제품 평점 등의 데이터가 있는 CSV 파일 읽어오기

    CREATE TABLE user (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100),
    email VARCHAR(100) UNIQUE
    );
    
    CREATE TABLE product (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100),
    category VARCHAR(100)
    );
    
    CREATE TABLE review (
    id SERIAL PRIMARY KEY,
    user_id BIGINT REFERENCES user(id),
    product_id BIGINT REFERENCES product(id),
    rating INT,
    review_text TEXT
    );

  • 머신러닝 모델 선택

    • 협업 필터링(Collaborative Filtering) 사용
    • 대표 알고리즘으로는 Matrix Factorization이 있음.
    • Python의 Suprise 라이브러리 사용해 협업 필터링 모델 학습

    # 1. 모델 학습
    
    from surprise import Dataset, Reader, SVD
    from surprise.model_selection import train_test_split
    from surprise import accuracy
    
    # 데이터 로딩
    reader = Reader(rating_scale=(1, 5))
    data = Dataset.load_from_df(df[['user_id', 'product_id', 'rating']], reader)
    trainset, testset = train_test_split(data, test_size=0.25)
    
    # 모델 학습
    model = SVD()
    model.fit(trainset)
    
    # 예측 및 평가
    predictions = model.test(testset)
    accuracy.rmse(predictions)

    # 2. 모델 저장 및 load
    import joblib
    
    # 모델 저장
    joblib.dump(model, 'svd_model.pkl')
    
    # 모델 로드
    loaded_model = joblib.load('svd_model.pkl')

• 스프링부트 애플리케이션과 머신러닝 모델 통합

  • 서비스 클래스 작성

  @Service
  public class RecommendationService {
  
  private final PythonInterpreter pythonInterpreter;
  
  @Autowired
  public RecommendationService() {
  // PythonInterpreter를 사용하여 Python 스크립트를 호출
  pythonInterpreter = new PythonInterpreter();
  pythonInterpreter.exec("import joblib");
  pythonInterpreter.exec("model = joblib.load('path/to/svd_model.pkl')");
  }
  
  public List<Product> getRecommendations(Long userId) {
  // Python 스크립트 호출 및 추천 생성
  pythonInterpreter.set("user_id", userId);
  pythonInterpreter.exec("recommendations = model.predict(user_id)");
  // 추천 리스트 변환 및 반환
  // ...
  return recommendations;
  }
  }

  • REST API 구현

  @RestController
  @RequestMapping("/api/recommendations")
  public class RecommendationController {
  
  @Autowired
  private RecommendationService recommendationService;
  
  @GetMapping("/{userId}")
  public ResponseEntity<List<Product>> getRecommendations(@PathVariable Long userId) {
  List<Product> recommendations = recommendationService.getRecommendations(userId);
  return ResponseEntity.ok(recommendations);
  }
  }

Day5

---

☁️ 협업 필터링에 대해 자세히 알아보자.(1)

출처 : 추천 시스템 기본 - 협업 필터링(Collaborative Filtering) - ①

• 협업 필터링의 대표 접근법
  • User-based Filtering
    • 특정 사용자(User)를 선택 ex) SNS 친구 추천 서비스
    • 평점 유사도 기반 유사 사용자 찾기
      - 유사 사용자가 좋아한 Item 추천
  • Item-based Filtering
    • 특정 아이템(Item)을 선택 및 특정 Item을 좋아한 사용자 찾기
    • 해당 사용자들이 좋아했던 다른 Item 찾기

• 유사도 측정 방법

  • 두 방법 모두 유사도(거리)를 측정해서 사용

  • 일반적인 거리 측정 방법론 3가지

    • Cosine Similarity
      

      • 일반적으로 사용되는 유사도로, 사용자 u와 사용자 u'가 같은 방향성을 보고 있는지 평가

    • Pearson Correlation Similarity
      

      • 평균적 경향성에서 얼마나 차이가 나는지를 기반으로 하며, Centered Cosine Similarity라고도 함.
      • 사용자 u와 사용자 u'가 함께 사용한 아이템이 많아야 한다는 단점이 있음.

• 유사도를 계산한 후 우리는 어떻게 아이템(Item)을 추천할 수 있을까?
  • User-Item 행렬(Matrix)를 구축
    • 목표 : 4번째 사용자(User)에게 영화를 추천해주기 위해서, 4번째 사용자가 아직 보지 않은 영화의 평점을 예측
  • User간의 유사도 계산
  • 예상 아이템의 평점 추론
    • 4번째 사용자가 보지 않은 영화들을 본 사용자의 평점을 추출
    • 4번째 사용자와의 유사도 계산
    • 각 사용자 별 유사도 x 평점 계산
      
    • 유사도가 반영된 가중치 평점을 합산
      
    • 가중치를 나누어 평균 평점을 계산 -> 4번째 사용자의 보지 않은 영화의 평점 추론
      

• Memory-based Approach의 장단점

  • 장점

    • 접근 방식이 쉬우며, 최적화(Optimization)나 훈련(Train)이 필요 없음

  • 단점

    • 희소(Sparse)데이터가 발생하면 -> 성능 저하
      • 비교 대상이 적어지기 때문
    • 확장성에 제한 ( ∵ 비교 대상이 많아지면, 계산량이 증가)

Day6

---

☁️ 협업 필터링에 대해 자세히 알아보자.(2)

출처 : 추천 시스템 기본 - 협업 필터링(Collaborative Filtering) - ②

• Model based Approach
  • Memory Based Approach의 단점을 채울 수 있는 방식
  • Machine Learning 알고리즘을 통해, 사용자가 아직 평가하지 않은 아이템의 평점 예측
  • 기본 IDEA : 사용자의 선호도는 소수의 Hidden Factor로 결정될 수 있다!
  • 행렬 분해(MF;Matrix Factorization) 사용
  • 비모수적(Non-Parametric) 방법
  • 딥러닝(Deep Learning) 기반 방법

• 첫 번째, MF(행렬 분해)란?
  

  • ex) User 및 Item 모두에 대해 5차원 임베딩( n_factor = 5 ) 가 있다고 가정

    • User-Item 행렬을 "User-X",와 "Item-A" 행렬로 변환

  • MF는 여러 방법 수행 가능

    • Orthogonal Factorization(Singular Vector Decomposition(SVD) 특이값 분해)
    • Non-Negative Matrix Factorization(NMF)
    • Probabilistic Factorization(PMF) 등 여러가지가 있음.
    • 각각의 User-X Embedding과 Movie-A Embedding은 여러 요약적인 특성을 나타낼 수 있음
      • Movie-A Embedding 예시
        • 1) 공상과학과 관련된 요소 2) 최근 영화인지에 대한 요소
      • User-X Embedding 예시
        • 1) 공상과학영화를 얼마나 좋아하는지 2) 최근 영화를 얼마나 선호하는지
      • 그러나, 실제로는 각 Factor가 무엇을 의미하는지 정확히 알 수 없는 문제가 있음.
    • User-X Embedding과 Movie-A Embedding의 내적 값이 높을수록 -> User-X에게 Movie-A가 더 좋은 추천임을 의미하게 됨!

• 두 번째, 비모수(Non-Parametric)적 접근법
  • Memory-based 추천 시스템의 아이디어와 유사하며, 사용자(User)와 아이템(Item)의 유사도를 사용함.
  • 가중치 평균을 통해 사용자의 아이템(Item)의 평가(Rating)를 예측
    • 차이점은?
      • Pearson Correlation이나 Cosine Similarity를 사용하는 대신, Unsupervised Learning 모델 사용
      • K개의 이웃(Neighbor)한 사용자 수로 제한하여, 시스템 확장성 높임

• 세 번째, 딥러닝(Deep Learning)적 접근법
  
  • Deep Learning을 활용한 협업 필터링 관련 자료는 아직 많이 부족한 편
  • 행렬 분해의 확장으로 생각해도 무방(행렬 분해 결과를 Input으로 사용 가능)
    - SVD, PCA : 희소(Sparse) 행렬을 2개의 낮은 Rank의 직교 행렬(User-X, Item-A)로 분해
    - Deep Learning : Embeddding 직교를 하지 않고도, 자체 학습을 해야 함.
    - User-Item의 조합으로부터 조회할 수 있으니 비선형(Non-linear : ReLU)나 선형(Linear), Sigmoid Layer를 사용하거나, 최적화 알고리즘(SGD, Adam)을 사용하여 가중치를 학습하는 등의 방식을 활용해볼 수 있음.

• 협업 필터링의 한계 극복 방안
  (컨텐츠 기반 필터링 및 하이브리드의 경우, 위의 내용과 겹쳐 별도로 작성하지 않음.)
  • 머신러닝 추천 시스템
    • 사용자의 조회, 클릭 등의 사소한 행동까지 모두 학습하여 사용자에게 추천할 후보군을 제안하고, 사용자의 반응을 학습해 더 정교한 결과를 도출할 수 있을 것.

Day7

---

☁️ 딥러닝 추천 모델 논문 정보

Q. 그렇다면 딥러닝 추천 모델에 대한 연구는 어떻게 되고 있을까?

A. 다음 논문을 통해 알아보자.

출처 : [논문요약] 딥러닝 관련 추천 모델 - Survey(2019)

추천 시스템에서의 딥러닝 모델 필요성

• End-to-End 학습

  • Contents-based recommendation에서 리뷰나 이미지 데이터를 처리하는 것은 필수적
  • 이미지 및 텍스트 데이터를 별도 전처리 비용없이, End-to-End 학습

• Inductive Biases(Generalization과 유사)

  • 딥러닝 모델은 Sequential 한 데이터나 Click-Log 데이터에 적합하기 때문

• 큰 데이터 및 복잡한 문제를 해결 가능

  • Collaborative Ranking, Matrix Completion 등의 문제 처리 시, 엄청난 양과 더불어 복잡한 학습 데이터가 필요하기 때문
  • 이때 딥러닝 모델은 엄청난 양의 데이터를 학습하여, 복잡한 문제를 해결함
  • GPU의 발전으로, 기존의 추천 알고리즘(Matrix Factorization 등)도 신경망 구조로 변환이 가능함.

추천시스템에서의 딥러닝 모델 장점 4가지

• Non-Linear Transformation

  • 복잡한 User-Item의 상호작용 패턴을 파악할 수 있음.
  • 기존 Matrix Factorization 모델의 경우 -> 선형 모델이므로, 표현력 학습에 제약이 있음.

• Representation Learning

  • Input data의 특징에 대한 효과적인 학습
  • Hand-Craft Feature Design을 줄여 Feature Engineering 비용 감소
  • 이미지 및 텍스트 등의 비정형 데이터의 효과적인 처리 가능

• Sequence Modeling

  • Sequence한 특성을 가지는 데이터(User의 행동, Item의 변경)에서도 효과적인 작동 간으
  • 다음에 구매 가능한 Item 추천 가능

• Flexibility

• Keras, Tensorflow, Pytorch와 같은 Framework를 가지고 있음.

추천시스템에서의 딥러닝 모델 단점 3가지

• Interpretability

  • 딥러닝 모델의 예측 결과 해석의 어려움 존재(Black-Box 모델)
  • Atttention model을 사용하면 해석될 가능성이 조금 더 있는 것으로 보임.

• Data Requirement

  • 딥러닝 모델을 학습하기 위해서는 대량 데이터가 필요한데 이미지 및 텍스트 데이터를 수집하는 것보다, 추천 시스템에서의 라벨링이 완료된 데이터를 수집하는 것이 용이함.

• Extensive Hyper-parameter Tuning

• 머신러닝의 전반적인 한계점으로, 매우 많은 수의 Hyper-Parameter 문제가 있음.

• 단일 Hyper-Parameter를 사용할 수 있는 연구가 진행되고 있다고 함.

추천 시스템에서의 딥러닝 - SOTA

SOTA?

• 각 분야의 가장 좋은 성능을 내는 모델을 뜻함.

• MLP
  • 기존의 선형적 방법을 사용하는 추천 시스템 대신, 비선형성을 추가해 확장함.
  • 추천 모델은 대부분 User의 선호도(Preference)와 Item Feature 간의 양반향성 상호작용을 활용
  • 추천 시스템에서의 MPL 모델로는 'Locally-Connected wide & deep Learning Model', 'Youtube DNN', 'Collaborative Metric Learning(CML)'이 있음.

• Autoencoder

• 학습 방안

  • Bottleneck Layer -> Feature Representation을 Low-dimensional Feature로 학습
  • Interaction Matrix의 공백을 직접 채우는 Reconstruction Layer 방식
    • Denoising 및 Variational Autoencoder 등 대부분의 Autoencoder 추천 분야에서 사용 가능!

• Autoencoder 기반 협업 필터링

• User나 Item의 Partial Vector를 입력하면 Output Layer에서 재구성
  - User의 벡터에서 더 높은 분산을 가지므로, Item-AutoRec > User-AutoRec 성립

  • Activation 함수의 조합에 따라 성능이 달라짐.
  • Hidden Unit의 크기 ⬆️ -> 성능이 더 좋아짐
    • 모델의 Capacity가 커지면 Input의 특정을 더 잘 모델링하기 때문.
  • 더 많은 Layer를 쌓으면 성능을 더 크게 개선 가능

• Convolutional Neural Network(CNN)
• 학습 방안
  • CNN은 비정형 데이터를 학습에 사용
  • CNN 모델을 통해 시각적인 콘텐츠와 User의 Factor 간의 상호작용을 탐색하여 이미지의 Feature를 추출
• CNN 기반 추천 시스템
  • ContagNet : CNN 및 MLP를 concat해서 사용
  • Comparative Deep Learning(CDL) : 긍정적인 이미지와 부정적인 이미지를 학습
• CNN 기반 협업 필터링
• Outer Product를 사용하여 Interaction Map 생성, CNN이 임베딩 차원 간의 고차원 상관관계를 캡쳐

• Graph CNNs
  • SNS 또는 Knowledge Graph 등의 관계성 데이터에 적합
  • 추천 분야는 이분 그래프로 표현 가능
  • 핀터레스트에서 Graph CNNs 기반 추천 시스템을 사용한다고 함.

• Attention 기반 추천 시스템

  Attention 메커니즘?

  • 사람이 전체 이미지나 문장 중 특정한 부분만을 집중하는 것에서 아이디어를 얻음

• Attention Score로 Input을 점수화

• Attention 종류 2가지 : Vanilla Attention, Co-Attention

이외의 자세한 내용 및 향후 연구 및 미해결 과제에 대한 부분은 이 곳을 참고해주세요!
📍 [논문요약] 딥러닝 관련 추천 모델 - Survey(2019)