채영sw

HCI 3요소: 유용성, 사용성, 감성

채영sw — Sat, 10 May 2025 21:45:26 +0900

최적의 경험을 전달하기 위한 세 가지 조건

유용성 (USefilness): 사람들이 시스템을 통해 하고자 하는 일을 효과적으로 달성할 수 있어야 한다는 것. 어떠한 제품이나 서비스를 개발할 때 가장 먼저 관심의 대상이 되는 조건

사용성 (Usability): 사람들이 디지털 제품이나 서비스를 가능한 쉽고 편리하게 사용할 수 있어야 한다는 것. 디지털 제품이나 서비스를 사용할 때 되도록 적은 노력으로 사용해 목적에 달성할 수 있어야 함

감성 (Affect): 시스템을 사용하면서 사람들이 마음속에서 얼마나 적절한 느낌을 받았는지를 판단하는 것. 사람들이 시스템을 사용하면서 그 기본 목적에 적합한 감성을 풍부하게 느낄 수 있어야 함

유용성 (Usefulness)

유용성의 원리: 사람들이 디지털 시스템을 사용하는 목적을 효과적으로 달성할 수 있도록 도와주는 원리

- 사람들이 자신의 현재 어떤 문제점이나 바람을 가지고 있는지, 이러한 상황을 어떻게 충족시켜 줄 수 있는지 이해 필요

- 인지과학 분야에선 문제 공간과 디자인 공간이라는 개념으로 정리 → 두 공간 사이의 원활한 관계를 통해 유용한 시스템이 만들어짐

→ 문제 공간을 명확하게 파악하고 이에 상응하는 디자인 공간을 만들기!

문제 공간 (Problem Space)

- 인간의 문제 해결 과정은 제한 조건 내에서 조작자(operator)를 사용해 초기 상태에서 목표 사태로 가기 위한 문제 공간을 탐색하는 과정

→ 문제 공간: 사용자가 본인의 문제를 해결하는 과정에서 처할 수 있는 상태들로 이루어진 미로

→ 조작자: 시스템 내에서 사용자의 상태를 변경시키는 행동 수단

- 인지과학 분야에선 문제에 대한 표상을 구축하는 단계라고 봄 → 유용한 시스템을 만들기 위한 선결조건

디자인 공간 (Design Space)

- 사람들이 가지고 있는 문제를 해결해 줄 수 있는 모든 제품이나 서비스 대안의 집합

→ 개념적 모형을 이용해 특정 제품이나 서비스가 사람들에게 어떤 의미를 가지는지 이해하는 것

cf.)

- 모형 (Model): 단순화를 위해 특정 제품이나 서비스가 어떻게 구성되어 있고 어떻게 작동하는지 추상화시킨 결과

- 심성 모형 (Mental Model): 복잡한 대상이 어떤 구조를 가지고 있고 시간의 흐름에 따라 어떻게 움직이는지를 추상화해 표현하는 사람의 마음속에 있는 지식의 구조 (HCI - 특정 시스템의 기능이나 구조 또는 가치에 대해 사용자가 머릿속에 가지고 있는 동적인 모형)

→ 사람에 따라 동일한 대상에 대해서도 상이한 심성 모형을 가짐

→ 사람들의 머릿속에서 가상으로 작동시켜 볼 수 있는 동적 특징을 가짐

→ 개인의 인지 능력에 크게 영향을 받기 때문에, 불완전하고 상충적임

구조 모형 (Structured Model)
- 시스템이 구체적으로 어떤 세부 요소들로 구성되어 있는지를 묘사하는 모형
기능 모형/작업-행위 모형 (Functional Model / Task-Action Model)
- 사람들이 시스템을 어떻게 사용하는지에 대한 모형
가치 모형 (Value Model)
- 사용자가 시스템이 자신에게 어떤 가치를 제공해 줄 것이라고 생각하는 심성 모형
- 기능적 가치, 유희적 가치, 개인적 가치, 사회적 가치, 부수적 가치

→ (사실적) 구조 - 기능 - 가치 (추성적)

⚠️ 설계자는 시스템 이미지를 적절하게 구현해, 사용자가 개발자 모형 만큼은 아니더라도 멘탈 모델을 올바르게 구축할 수 있도록 해야 함

실행차: 사용자가 시스템이 어떻게 작동하는지 이해하지 못해 원하는 작업을 수행하는 데 어려움을 겪을 때 발생
평가차: 사용자가 시스템에서 발생한 결과나 상태를 평가하고 해석하는 데 어려움을 겪어, 시스템이 제공하는 피드백을 이해하지 못하면 발생

사용성 (Usability)

- 제공된 기능이 이용하기 어려워 시스템을 충분히 사용할 수 없다고 느낀다면, 아무리 많은 기능이 제공될지라도 사용자는 그 시스템을 더이상 사용하지 않음 (e.g. 토스 vs. 기존 증권사 앱)

사용성의 속성

효율성: 얼마나 빠르게 달성할 수 있는가
- 반응성: 사용자의 행동에 대한 시스템의 반응 속도 → 시간 측면의 효율성
  - 시스템 지체, 네트워크 지체
  - 경고 메시지, 지체되는 시스템 상태 보여주기 등으로 체감하는 반응성의 속도를 높일 수 있음
- 단축성: 사용자가 자신이 원하는 과업을 간단하게 마무리할 수 있는 정도 → 의미/절차 측면의 효율성
  - 단축키, 단축 경로
  - 자주 사용하는 정보, 기능, 키를 좀 더 쉽게 접할 수 있는 곳에 배치
정확성: 정확하게 업무처리를 할 수 있는가
- 사전 방지성: 오류를 저지를 수 있는 가능성을 미연에 제거하거나 줄여 시스템을 사용하면서 범하는 실수를 사전에 방지
  - 균형성의 범칙: 어떤 행위가 복구하기 어려울수록 애초에 그 행위를 저지르는 것 자체도 어려워한다 (파일 삭제)
  - 사전심사: 시스템의 현재 상태를 사전에 심사해 실행할 수 있는 항목만 사용자에게 보여주는 것
- 오류 방생 감지성: 오류 발생을 사용자에게 빠르게 인식하고 조치를 취할 수 있어야 함
  - 지속성 효과: 오류 발생을 사용자가 볼 수 있도록 시,청각적으로 강조하는 것
- 오류 회복성: 시스템을 통해 사용자 자신이 과거에 저질렀던 오류를 정정할 수 있게 하는 속성
  - 후방 오류 회복성: 사용자의 과거 오류 효과를 취소하고 오류 발생 전의 상태로 돌아가는 것
  - 전방 오류 회복성: 과거의 과거 오류 효과를 취소할 순 없지만, 이전 상태로 다시 돌아갈 수 있는 길을 제공하는 것 (e.g. 기본 설정으로 돌아가기, 문서 복구(최근 저장상태로 돌아가기))

의미성: 시스템을 쉽게 이해할 수 있는가
- 변화 제시성: 시스템 내부 상태가 변화했을 때 그 변화된 상태를 사용자가 감지할 수 있게 제공하는 속성
  - 즉시성: 변화가 발생한 즉시 별도의 작업을 하지 않더라도 사용자에게 제공 (e.g. sns 활동중 표시)
  - 부가성: 사용자가 변화된 상태를 보고 싶다는 의사를 부가적으로 명백하게 밝힐 때 시스템이 현재의 상태를 사용자에게 보여주는 것 (e.g. 다운로드 완료 표시)
- 이해 가능성: 시스템이 전달한 정보를 사용자가 이해할 수 있게 함
  - 가독성: 제시된 정보를 사용자가 정확하게 읽게 해주는 것
  - 논리성: 사용자가 보기에 정보가 제공되는 순서나 구조가 논리적이라고 생각할 수 있도록 정보를 구성하는 것
- 학습성: 초보 사용자가 시스템에 대하여 어느 정도 수준의 지식을 취득하는 것이 얼마나 쉬운지
  - 사용자 메뉴얼 제공
  - 과업 적합성: 시스템의 특성에 따라 상이한 수준의 최종 목표 정하기 (e.g. 키오스크, ATM vs. 비행기 조종 시스템, 공정 제어)
  - 기억 가능성: 어느 정도 시간이 지난 후 다시 사용할 때 원래 사용하던 수준으로 도달하는데 걸리는 시간
유연성: 원하는 방식으로 시스템을 쓸 수 있는가
- 사용자 주도권: 사용자가 자신이 원하는 대로 시스템과 상호작용할 수 있게 하는 시스템 속성
  - 상호작용 Mode: 논리적 연결이 없는 상호작용 모드 제거
  - 과업 전이성: 사용자가 과업을 수행하면서 시스템과 사용자 사이에 통제권을 유연하게 주고받을 수 있게 하는 것
- 대체성: 사용자가 시스템을 사용하면서 특정 작업을 하기 원할 때 그 작업을 수행할 수 있는 방법이 두 가지 이상 → 처한 상황에 따라 가장 적절한 방법을 선택할 수 있게 하는 시스템의 특성
  - 입력 대체성: 사용자가 두 가지 방법으로 입력할 수 있게 하는 속성
  - 출력 대체성: 출력 상황을 여러 가지 조건에서 볼 수 있도록 하는 속성
- 다중성: 사용자가 한꺼번에 두개 이상의 작업을 동시에 수행할 수 있도록 하는 시스템 속성
  - 동시적 다중성: 동시에 두 가지 작업 수행 가능
  - 교차적 다중성: 어떤 기간을 두고 보면 두 가지 이상의 작업을 동시에 수행했지만, 특정 시점만 두고 보면 한 가지 작업
- 개인화: 사용자의 취향이나 특성에 따라 시스템의 상태를 변화시킬 수 있는 속성
  - 응용성: 사용자가 개인화의 주체로서 시스템의 특성을 바꾸는 속성 (e.g. 아이폰 위젯)
  - 적응성: 시스템이 주체로서 사용자에게 맞게 특성을 바꿔주는 속성 (e.g. 추천 플레이리스트)
- 연결성: 시스템 간의 연결이 얼마나 쉬운지
  - 연동성: 하나의 제품이 다른 제품과 얼마나 쉽게 연결될 수 있는가 (하드웨어, e.g. 애플 제품들)
  - 호환성: 서로 다른 시스템 간에 컨텐츠 및 가능이 얼마나 쉽게 이동되는지 (소프트위어, e.g. 로지텍)
일관성: 시각적으로 얼마나 익숙한 모습인가
- 예측 가능성: 사용자가 자신이 과거에 시스템과 상호작용한 경험을 통해 자기가 어떤 행동을 하면 그 결과를 예측할 수 있게 하는 특성
  - 일관된 명령 체계
  - 정보의 향기: 시스템에서 어떤 행동을 했을 때 그 결과가 어떻게 되리라는 것을 사용자에게 미리 알려주는 것
- 친숙성: 사람들이 실제 세상에 가지고 있던 경험을 바탕으로 시스템을 사용하는 데 필요한 지식을 습득할 수 있게 하는 시특성
  - 일상 용어 사용
  - 직관성
- 일반화 가능성: 사용자가 과거에 사용한 명령어나 메뉴를 새로운 상황에서도 사용할 수 있도록 하는 시스템 속성
  - 시스템 내부 일관성: 시스템 내부에서 비슷한 효과를 내는 작업은 비슷한 절차를 거치도록 설계
  - 시스템 간의 일관성: 비슷한 지향점을 가진 서비스 및 프로그램 등은 서로 비슷한 포맷 (e.g. 메신저 앱)

→ 다중적 시스템 개발 (e.g. 초보자 모드, 전문가 모드)

핵심 속성을 선정할 때 사용자의 특성, 맥락의 특성을 이해해야 함

기능적 가치 - 단축성, 사전 방지성, 오류 회복성

유희적 가치 - 변화제시성, 대체성, 다중성

사회적 가치 - 친숙성, 일반화 가능성

개인적 가치 - 개인화, 주도성

사용 교재

+ khux 세션 자료

유저 리서치 방법론_2

채영sw — Fri, 11 Apr 2025 00:26:14 +0900

서베이 방법론

- 현상적 질문에 대한 연구 질문 (Research Question)을 설정해 유저 리서치를 진행하고 본질적인 문제 찾기!

서베이에 대한 태도

해석보다는 관찰이 우선
- 사용자의 행동을 먼저 관찰한 후, 해석하는 것이 중요
- 해석이 선행되면 연구자가 선입견을 가질 수 있음 -> 있는 그대로 객관적으로 바라보고 데이터를 수집해야 함
문제를 찾는 것을 넘어 구조화하기
- 단순히 문제를 찾는 것이 아니라 문제를 올바르게 정의하고 구조화하는 것이 중요
- Finding x Framing o
- 문제를 잘 정의해야 해결 방향도 효과적으로 설정 가능

서베이의 주요 과정

서베이 시 발생할 수 있는 오류

샘플링 오류 (Sampling Error)
- 조사 대상 전체(모집단)의 특성을 정확하게 반영하지 못하는 오류
측정 오류 (Measurement Error)
- 연구에서 데이터를 수집할 때 잘못된 측정이 이루어지는 경우
- 실제로 측정하려는 개념과 실제 수집된 데이터 간에 차이가 발생하는 오류
무응답 오류 (Non-reaponse Error)
- 조사 대상자 중 일부가 응답을 하지 않거나, 특정 집단이 응답을 거부함으로써 발생하는 오류
포괄 오류 (Converge Error)
- 표본을 추출할 때 조사 대상에서 특정 그룹이 과소 또는 과대 대표되는 문제

서베이 설계와 응답 과정

- 응답자가 기억을 회상하는 과정에서 대략적인 추정이 개입될 수 있음 → 명확한 질문 설계 필요

질문 이해 → 정보 회상 → 판단 및 추정 (응답자가 스스로 고민하도로 유도하는 질문이 중요!) → 응답 보고

질문 유형과 설계 원칙

- 질문 유형 선택 시 응답자의 사고 과정과 분석 목적 고려

질문 유형
- Open-ended
  - 심층적이고 질적인 답변 유도
  - e.g. 사용자의 동기, 불편사항, 해결방안
- Closed-ended
  - 비교적 명확한 답변 제공, 분석 용이
  - e.g. Likert scale(리커트 척도), 다지선다형
설계 원칙
- 명확하고 간결한 문장 사용 → 복잡한 구문, 애매한 수량화/단어 X
- 회상 가능성 고려 → 오래된 경험보다 최근 경험 질문 추천
- 응답 범위 명확화 → 명확한 선택지 제공, 선택지 순서 효과 방지

응답 오류와 편향 방지

정보 부호화 실패
- 응답자가 정보를 회상하지 못하는 경우 → 사전 조사 및 문항 개선 필요
질문 오해
- 모호한 개념, 과도한 복잡성, 애매한 수량화 사용 금지
응답 편향

사회적 기대, 질문 순서, 설문 길이 등에 의해 영향을 받을 수 있음 → 사전 파일럿 테스트 필수베이 방법론

- 현상적 질문에 대한 연구 질문 (Research Question)을 설정해 유저 리서치를 진행하고 본질적인 문제 찾기!

서베이 배치 및 순서 효과

- 연관된 질문은 그룹화

- 신뢰도 검사를 위한 문항은 분산 배치

초반: 쉬운 질문 배치 → 응답자 참여 유도
중반: 주요 연구 질문 배치
후반: 민감한 질문이나 개방형 질문 배치 (응답 부담 고려)

문항 검토 및 파일럿 테스트

- 파일럿 테스트를 통해 응답자의 이해도 검증

체크리스트

복잡한 구문 사용 여부 | 실험 기억에 부담을 주는 문장 여부 | 애매한 명사구 사용 여부

익숙하지 않은 전문 용어 포함 여부 | 애매한 수량화 여부 | 오도할 가능성이 있는 문장 여부

질문 카테고리의 명확성 | 두 개 이상의 질문 결합 여부 | 질문과 응답 선택지의 일관성 여부

응답자가 회상하기 어려운 질문 여부 | 응답자가 답할 수 없는 질문 여부 | 질문 목적의 명확성

연구 윤리 및 데이터 보호

비밀 보장: 응답을 개별 식별이 불가능한 형태로 집계해야 함
자발적 참여: 응답을 강요하지 않고 자유로운 응답 환경 조성

인터뷰 방법론

- 연구 주제에 대해 많은 정보나 풍부한 경험을 갖고 있는 사람을 대상으로 그들이 생각하고 경험한 바를 본인의 언어적 습관과 표현으로 서술하도록 하여 연구 주제에 대해 참가자의 태도, 믿음, 기분, 반응 등에 대한 정보를 획득

- 이를 통해 주관적으로 형성된 참여자의 경험을 맥락적으로 파악해 연구자의 언어로 해석

맥락 → 사용자가 특정 행동을 하는 이유 파악
인사이트 → 양적 연구에서 놓칠 수 있는 인사이트 도출
경험과 감정 → 사용자의 주관적 경험과 감정 직접 탐색

→ 맥락을 파악하고, Why & How를 구체화하기 위해!

인터뷰의 유형

- 구조화의 수준에 따라 나뉨

구조화된 인터뷰
- 인터뷰 가이드가 구체적으로 조직되어 연구자가 가이드에 준비된 모든 질문을 순서대로 정확하게 질문
- 사전에 준비된 질문에 대한 답변만 얻을 수 있으므로 독창적인 해석의 여지가 없음
반구조화된 인터뷰
- 구조화-비구조화의 중간 성격
- 인터뷰 프로토콜을 사전에 준비하지만 참여자의 반응에 따라 변형 가능
- 연구자가 가진 의도나 편향 발생 가능성이 있음
비구조화된 인터뷰
- 일상적 대화 형식 진행
- 대화 주제에 대한 최소한의 정보만 있거나 인터뷰 가이드를 준비하지 않음
- 여러 상황에 유연한 대처 필요
- 원하는 정보와 유의미한 정보를 얻기 어려움

인터뷰 질문 설계하기

질문 유형

탐색형 질문 (Grand-tour Questions)
- 응답자가 잘 알고 있는 것에 대한 설명 유도
사례 질문 (Example Questions)
- 특정한 사건이나 경험을 설명하도록 유도
추가/유도 질문 (Prompts)
- 응답이 끊기지 않게 도와주는 질문

잘 구성된 인터뷰 질문

개방형 질문 → 예/아니오가 아닌 더 깊은 정보를 유도하는 질문
이해하기 쉬운 질문 → 연구자와 참가자가 같은 의미로 단어를 사용하도록 설계
구체적인 질문 → 참여자가 명확히 답변할 수 있도록 유도하는 질문

피해야 할 인터뷰 질문

유도 질문 → 사용자의 경험에 기반하지 않은 연구자의 의도가 반영된 질문
편향된 질문 → 논쟁의 여지가 있는 가정을 포함하는 질문
이중 질문 → 두 가지 이슈를 하나의 질문에 포함

인터뷰 진행 절차

FGI vs. IDI

FGI (Focus Group Interview)

Group Observation
- 그룹의 자연스러운 대화를 파악해야 하는 경우
- 인터뷰이가 관찰자로서 존재하며 깊은 공감을 하기 어려운 경우
- 특정 집단 내 인물이 아니라면 명확한 질문이 어려운 경우
- 특정 집단만의 문화와 언어 등을 파악하고 싶은 경우
Group Brainstorming
- 의견의 긍/부정을 함께 관찰하고자 하는 경우
- 인터뷰이가 관찰자로서 존재하며 전문 분야에 대한 지식이 부족한 경우
- 특정 집단 내 인물의 의견에 대한 객관성을 판단하기 어려운 경우

IDI (In-depth Interview)

1대1 인터뷰

관찰 방법론

완전 참여 관찰
- 연구자가 대상 그룹에 완전히 참여
- 대상자가 연구를 인식하지 못할 수도 있음
- 몰입형 연구 가능 (e.g. 스타트업 직원처럼 활동)
관찰 참여
- 연구자가 일부 활동에 참여하면서 관찰 수행
- 사용자와 상호작용 가능
- 사용자 경험의 맥락을 더 깊이 이해할 수 있음
비참여 관찰
- 사용자와 직접적인 상호작용 최소화
- 연구자가 개입하지 않음으로써 자연스러운 행동 관찰 가능
완전 관찰
- 연구 대상이 연구자를 인지하지 못하도록 완전히 숨겨진 상태에서 관찰 수행
- 행동의 왜곡이 적지만 연구자의 해석이 중요

관찰 데이터 수집 방법

현장 노트 (Field Notes)
- 행동, 대화, 환경 등을 기록
- 사건의 시간적 흐름과 상호작용 정리
비디오/오디오 녹화
- 세부적인 관찰 가능
- 연구 후 반복 분석 용이
사진 촬영
- 공간과 맥락을 기록하는 데 유용
- 주요 사용 패턴을 시각적으로 파악 가능
샘플링
- 특정 시간대, 장소, 사용자 그룹을 설정하여 데이터 수집

관찰 연구 + 인터뷰/서베이

탐색적 연구 → 관찰을 통해 문제점을 도출하고, 이후 인터뷰와 서베이로 검증

트라이앵귤레이션 (Triangulation) → 관찰, 인터뷰, 서베이를 함께 활용해 연구 신뢰도를 높임.
- 사용자 페르소나 및 Journey Map (사용자가 생활 맥락에서 제품/서비스와 만나는 지점 기록) 제작에 활용

사용 교재

+ khux 세션 자료

유저 리서치 방법론 _ 1

채영sw — Sun, 6 Apr 2025 16:07:39 +0900

유저 리서치(User Research) vs UX 리서치(User Experience Research)

-> 둘다 사용자 중심 설계를 실현하기 위해 필요한 과정

유저 리서치: 현실적인 문제에 대한 사용자의 경험을 탐색해 사용자가 겪고 있는 본질적인 문제를 발견하는 과정

-> 표면적인 문제가 아닌 깊이 있는 진짜 문제를 발견하는 과정 (문제 정의)

UX 리서치: 사용자의 행동과 피드백을 분석하여 제품이나 서비스가 실제 사용자의 니즈와 기대를 얼마나 잘 충족하는 지를 평가하고 개선

-> 현존하는 제품 및 서비스에 대한 사용자 경험을 평가해 개선하는 과정 (문제 해결)

리서치를 통해 하고자 하는 것

- 사용자의 실제 행동과 요구에 맞는 프로덕트를 설계 또는 디자인/기능 개선

- 사용성과 접근성이 높은 제품 및 서비스 개발

- 제품 및 서비스의 사용성과 접근성 향상

- 가설 검증을 통한 객관적 데이터 기반 의사결정

- 사용자 이탈 방지 및 유지율 증가

더블 다이아몬드

- 발견 정의 개발 전달 네 단계를 따르는 디자인 프로세스의 시각화 프레임워크

- 복잡한 디자인 프로세스를 구조화하기 위한 기본적인 접근 방식

- 문제 영역과 솔루션 영역을 구분하고 확산(divergent)과 수렴(convergent) 사고를 거치는 과정을 묘사

첫 번째 다이아몬드, Problem

- 사용자 조사와 공감을 통해 문제를 이해하고 정의

Discover - 문제 발견
- 연구 주제 설정 - 사용자 관찰 - 문제점 수집: 행동 뒤에 숨겨진 욕구 탐색
- Issue Identification - Relevant UX Analysis - Goal Setting
- 데스크 리서치, 유저 리서치, 필드 리서치
Define - 문제점 정의
- 리서치 결과 분석 - 가장 핵심적이고 중요한 문제점 파악 - 해결할 수 있는 디자인 기회 정리
- Insight Generations - Key findings - UX Modeling
- 어피니티 다이어그램, 고객 행동 매핑, 고객 여정 지도, 페르소나

두 번째 다이아몬드, Solution

- 아이디어를 다양하게 발산한 후 최선의 해결책을 개발하고 구현

Develop - 아이디어 도출 및 컨셉 개발
- 반복적인 디자인 프로세스 진행 - UX 및 디지털 프로덕트 컨셉 확정 - 디지털 프로덕트가 갖추어야 할 세부기능을 정리하여 구체화
- UX Strategy, Idea Generation - Idea Evaluation - Concept Design - Scenario Design
  - 다양한 아이디어 중에 어떤 아이디어를 최종적으로 선택, 그거에 대한 컨셉은 뭐고 이걸 사용하게 됐을 때 어떤 시나리오로 사용자들이 사용하게 되는지 디자인
Deliver - 최종 결과물 도출, 평가 및 개선
- 제품 및 서비스의 최종 프로토타이핑 제작 - 테스트를 통한 평가 및 개선
- IA, Interaction, Interface Design - Prototyping - UX Testing - UX Guidelines

DF3 방법론

- 진짜 문제를 정의하기

레벨 1. Defining Surface Problem (DSP): 사용자를 둘러싼 현상적 문제 정의

레벨 2. Finding The Reason (FTR): 정의한 현상 문제에 대한 이유 찾기

-> 사용자를 둘러싼 현상적 문제를 정의하고 그것에 대한 이유를 찾는 단계

레벨 3. Defining Interface Problem (DIP): 사용자가 경험하는 최접점의 문제 정의

레벨 4. Finding The Journey (FTJ): 정의된 접점 문제에 대한 사용자의 경험 과정 찾기

-> 유저 리서치를 통해 진짜 어느 곳에서 사용자들이 문제를 겪고 있는지를 찾는 단계

레벨 5. Defining Key Experience (DKE): 사용자에게 중요한 핵심 경험 정의

레벨 6. Finding The Contrast (FTC): 정의된 경험을 기존의 프로덕트와 비교 평가하기

-> 사용자가 어떤 경험이 있어야 겪고 있는 문제들이 해결될 것인지를 정의 내리는 단계

UX 리서치 방법론

- 3차원 프레임워크

- 태도 vs. 행동 | 정량 vs. 정성 | 사용 맥락

태도 (Attitudinal) vs. 행동 (Behavioral)

-> 사용자가 "이 기능이 좋다"고 말했어도, 실제 행동을 보면 사용하지 않는 경우가 있을 수 있으므로 말과 행동을 모두 다루는 연구가 병행되어야 함!

태도 기반 연구
- 사용자가 말하는 것을 파악 -> 사용자가 어떻게 생각하는지를 조사하는 방법
행동 기반 연구
- 사용자가 실제로 하는 것 -> 사용자가 실제로 어떻게 행동하는지를 분석하는 방법

정성 (Qualitative) vs. 정량 (Quantitaive)

-> 정성적 연구 - 왜 그런가 | 정량적 연구 - 얼마나 많은 사람이 그런가

정성적 연구
- Direct. 소수의 사용자에게 깊이 있는 질문을 던지고, 사용자의 경험과 맥락을 분석하는 방식 (인터뷰, 관찰 등)
정량적 연구
- Indirect. 수치로 측정해 사용자 행동의 패턴을 파악하는 방식 (설문조사, A/B 테스트 등 수치로 파악)

사용 맥락 (Context of Use)

Field Studies: 제품 및 서비스를 실제 환경에서 사용하는지 (e.g. 에스노 그라피: 인류학자들이 다른 문화를 관찰하고 기록하는 연구방법)
Usability Testing: 실험실 환경에서 테스트하는지
사용하지 않은 상태에서 조사하는지에 따라 구분

태도 기반 연구 (Attitudinal Research)

- 사용자가 어떤 생각을 가지고 있는지, 어떤 의견을 가지고 있는지를 조사하는 연구 방법

- 사용자의 의식적인 태도, 신념, 선호도를 이해하는 것이 필요함

주의할 점
- 사용자가 솔직하게 말하지 않을 수도 있음
- 사용자가 자신이 겪고 있는 문제를 정확히 인식하지 못할 수도 있음
- 실제 행동과 차이가 있을 가능성이 있음
유용하게 작용하는 경우
- 브랜드 이미지, 제품 및 서비스에 대한 인식 조사
- 사용자의 주관적인 선호도 파악
- UX 설계 시, 사용자의 Mental Model (심성 모형) 이해
  - 심성 모형: 어떤 제품이나 서비스를 봤을 때 어떻게 움직여야겠다 머릿속에 그려져 있는 것
UX 설계 시 한계
- 사용자가 좋다고 말하지만, 실제로 사용하지 않을 수도 있음
- 특정 기능이 필요하다고 말하지만, 막상 사용해 보면 불편하다고 느낄 수 있음

- 대표적인 Attitudinal Research 방법론

Surveys 설문조사
- 사용자의 만족도, 선호도, 인식을 정량적으로 조사
Focus Groups 포커스 그룹
- 여러 명을 모아 특정 제품, 서비스, 브랜드, 현상 등에 대한 의견 토론
Card Sorting 카드 정렬
- 사용자가 정보를 어떻게 분류하는지 조사 (e.g. 메뉴, 내비게이션 만들 때 사용)

행동 기반 연구 (Behavioral Research)

- 사용자의 실제 행동을 측정하고 분석하는 연구 방법

- 사용자가 말하는 것이 아닌, 실제로 제품 및 서비스를 사용할 때의 행동을 관찰

중요한 이유
- 사용자가 무의식적으로 하는 행동 파악 가능
- 사용자가 실제로 겪는 어려움 확인 가능
- 객관적인 데이터를 얻을 수 있어 의사결정이 더 명확해짐
유용하게 작용하는 경우
- 실제 사용자의 행동 패턴과 문제점 분석
- UI/UX 변경이 전환율(Conversion Rate)에 미치는 영향 검증
- 사용자가 기능을 쉽게 찾고 활용하는지 확인
UX설계 시 한계
- 사용자가 왜 그런 행동을 하는지 알 수 없음
- 사용자가 어떤 기능을 거의 사용하지 않을 때, 어떤 이유인지 모름
- Attitudinal Research와 병행되어야 좋은 연구 결과 도출 가능!!

- 대표적인 Behavioral Research 방법론

A/B Testing A/B 테스트
- 두 가지 디자인을 비교해 실제 클릭률이나 전환율 분석
Eyetracking 시선 추적 연구
- 사용자가 화면에서 어디를 가장 많이 보는지 추적 (히트맵)
Clickstream Analysis 클릭스트림 분석
- 사용자가 웹사이트에서 어떤 경로를 따라 이동하는지 분석 (e.g. 뷰저블: 아이트래킹처럼 잘 설계해 분석하는 기업)

태도 기반 연구와 행동 기반 연구의 혼합 연구 방법

- 사용자의 말과 행동을 함께 조사

Usability Testing 사용성 테스트
- 사용자가 실제로 제품을 사용하는 모습을 관찰하면서 질문도 함께 진행
- 행동 기반이지만, 사용자의 피드백도 동시에 수집 가능
Field Studies 현장 연구
- 실제 사용자 환경에서 제품 사용을 관찰하는 인터뷰 진행
- 행동 + 태도 데이터 동시에 수집 가능
혼합 연구 장점
- 사용자의 행동을 관찰하면서 왜 그렇게 행동하는지 직접 질문 가능
- 행동 데이터만으로는 알 수 없는 맥락 파악 가능

정성적 연구 (Qualitative Research)

- 사용자의 행동이나 의견을 직접 관찰하거나 듣는 방식으로 데이터를 수집하는 연구 방법

- 사용자는 왜 그렇게 행동할까? | 어떻게 개선할 수 있을까?

특징
- 데이터 수집 방식이 관찰(Observing)과 인터뷰(Interviewing) 중심
- 연구자는 사용자의 행동을 직접 보고 질문할 수 있음
- 연구 과정에서 질문을 바꿀 수 있고, 추가 질문을 할 수도 있는 유연성을 가짐
- 분석 과정이 수학적, 통계적이지 않음 (패턴을 찾고 의미를 해석하는 과정 중심)
유용하게 작용하는 경우
- 사용자는 왜 이렇게 행동하는지 이해
- 제품 및 서비스에서 발생하는 문제를 어떻게 해결해야 할지 탐색
- 사용자 경험의 깊은 이해
정성적 연구의 한계
- 데이터가 소수의 사용자에 의존 -> 대표성 부족
  - 어떤 집단에게 물을 건지도 중요
- 연구자의 주관적인 해석이 개입될 가능성이 있음

- 대표적인 Qualitative Research 방법론

Usability Testing 사용성 테스트
- 사용자가 실제 제품 및 서비스를 사용하는 모습 직접 관찰하고 질문
Field Studies 현장 연구
- 사용자가 일상에서 제품을 사용하는 모습 관찰
In-Depth Interview 심층 인터뷰
- 사용자의 경험과 의견을 깊이 탐색 (e.g. 1 대 1 인터뷰)
Contextual Inquiry 맥락 기반 연구
- 사용자의 실제 작업 환경에서 관찰하며 질문

정량적 연구 (Quantitative Research)

- 사용자의 행동과 의견을 측정 가능한 데이터로 수집해 분석하는 연구 방법

- 얼마나 많은 사용자가 이 기능을 쓰고 있는가? | 이 버튼의 클릭률은 몇 %인가?

특징
- 데이터가 측정 가능한 방식으로 수집됨
- 사용자와 직접 대화하지 않아도 됨
- 데이터 수집 과정이 자동화됨
- 수학적,통계적 기법을 활용하여 객관적 패턴을 찾는 분석 과정을 가짐
유용하게 작용하는 경우
- 열마나 많은 사람들이 이 기능을 쓰는지 확인
- UX 문제의 심각도(Severity)를 수치화해 우선순위를 정할 때
- 데이터를 통해 객관적인 의사결정
정량적 연구의 한계
- 데이터만으로는 행동의 맥락을 알기 어렵기 때문에 사용자의 이유를 설명할 수 없음
- 숫자가 의미하는 바를 적절히 해석해야 함

- 대표적인 Quantitative Research 방법론

Surveys 설문 조사
- 다수의 사용자에게 동일한 질문을 던져 데이터 수집
A/B Testing
- 두 가지 디자인을 비교해 클릭률, 전환율 분석
Analytics 웹/앱 분석
- 사용자 행동 데이터(클릭 수, 체류 시간 등) 분석 (e.g. GA)
Usability Benchmarking 사용성 벤치마킹
- 사용자의 작업 성공률, 소요 시간 등을 수치화
- 프로토타입 테스트

정성적 연구, 정량적 연구를 통한 질문 해결

What people say
- 정성적 연구 + 태도 기반 연구
- 사용자의 주관적인 인식이나 기대 파악 (왜 좋아하고 왜 싫어하는지)
What people do
- 행동 기반 연구
- 사용자의 실제 행동 패턴을 객관적으로 측정
- UX 변경이 사용자 행동에 미치는 영향 분석에 효과적
How many & How much
- 정량적 연구
- 사용자의 행동이 얼마나 널리 퍼져 있는지(빈도, 퍼센트) 파악
- 우선순위 정하는 데 도움
Why & How to fix
- 정성적 연구
- 사용자 문제를 어떻게 해결할 수 있을까에 대한 인사이트 제공
- 디자인 및 기능 변경의 방향을 결정하는 데 도움

사용 맥락 (The Context of Product Use)

- 사용자가 실제로 제품 및 서비스를 사용하면서 리서치를 진행하는지 여부에 따른 연구 방법

- 제품 및 서비스를 실생활에서 자연스럽게 사용하면서 연구하는가? | 특정 시나리오를 정해놓고 연구하는가?

- 자연스러운 제품 사용 | 스크립트 기반 연구 | 제한적인 제품 및 서비스 사용 | 제품을 사용하지 않는 연구

자연스러운 제품 사용 (Natural or Near-Natural Use)

- 사용자가 실제 환경에서 자연스럽게 제품 및 서비스를 사용하는 모습을 연구하는 방식

특징
- 연구자가 사용자의 행동에 개입하지 않고 최대한 현실 그대로 관찰
- 현실적인 데이터를 얻을 수 있지만, 연구자가 특정 부분을 통제하기 어려움
장점
- 사용자의 실제 행동을 있는 그대로 관찰할 수 있음
- 외부 환경이 연구에 영향을 줄 가능성이 적어 현실성(외부 타당도)이 높음
단점
- 연구자가 통제할 수 없는 변수가 많음 -> 특정 기능을 집중적으로 연구하기 어려움
- 관찰자의 해석에 따라 결과가 달라질 수도 있음

민속지학적 연구 (Ethnographic Field Studies)
- 사용자의 일상에서 제품 및 서비스 사용 관찰
현장 설문조사 (Intercept Surveys)
- 사용자에게 제품 및 서비스를 사용한 후 즉각적인 피드백 요청
데이터 마이닝 (data mining)
- 사용자의 실제 행동 데이터 분석

스크립트 기반 연구 (Scripteed Use of the Product)

- 특정 시나리오나 미리 정해진 흐름에 따라 제품 및 서비스를 사용하도록 유도하는 방식

특징
- 연구자가 실험 설계를 통해 사용자가 특정한 기능을 테스트하도록 유도
- 테스트 환경을 통제할 수 있어 객관적인 비교 분석이 가능함
- 주로 사용성 평가나 벤치마킹 연구에서 활용됨
장점
- 연구자가 특정 기능을 초점화해서 연구 가능
- 결과를 객관적인 수치로 측정 가능
단점
- 사용자가 자연스럽게 행동하지 않을 가능성이 있음
- 특정 기능만 연구하기 때문에 전체적인 사용자 경험을 놓칠 수 있음

사용성 벤치마킹 (Usability Benchmarking)
- 동일한 과제를 여러 사용자에게 수행시키고 결과 비교
Remote Moderated Usability Testing
- 연구원이 온라인으로 실시간 진행하며 가이드 제공
A/B 테스트

제한적인 제품 및 서비스 사용 (Limited Use of the Product)

- 제품 및 서비스의 일부 기능이나 특정 요소만 연구하는 방식

특징
- 제품 및 서비스 전체를 사용하는 것이 아니라, 일부 요소(디자인, IA 등)만 테스트
- 연구자가 특정한 요소에 대한 사용자의 인식을 집중적으로 분석할 수 있음
장점
- 특정 문제나 디자인 요소에 더 깊이 연구 가능
- 사용자 멘탈 모델을 분석하는 데 효과적
단점
- 전체가 아니라 일부만 연구하므로 맥락을 놓칠 가능성이 있음
- 사용자 행동이 아니라 인지적 구조(IA)를 분석하는 것이 목적 -> 행동 기반 연구와 함께 사용해야 함!!

참여형 디자인 연구 (Participatory Design)
- 사용자가 직접 디자인 요소를 배치하며 피드백 제공
컨셉 테스트 (Concept Testing)
- 제품 및 서비스의 컨셉(디자인, 기능 등)에 대한 피드백 수집
카드 정렬 (Card Sorting)
- 사용자가 정보 구조를 정리하여 탐색 효율성을 평가
트리 테스트 (Tree Testing)
- 사용자들이 메뉴 구조를 얼마나 쉽게 탐색할 수 있는지 테스트

제품을 사용하지 않는 연구 (Not Using the Product)

- 사용자가 제품 및 서비스를 실제로 사용하지 않고, 브랜드나 디자인 감성에 대한 연구를 수행하는 방식

특징
- 연구 대상이 제품 및 서비스의 기능이 아니라 주로 디자인 스타일 가이드, 브랜드 인식 조사 등(브랜드, 디자인 스타일, 감성적 반응 같은 요소)에 활용됨
장점
- 제품 및 서비스를 직접 사용하지 않아도 UX 디자인의 감성적 요소를 연구할 수 있음
- 브랜드, 감성적 반응 등의 추상적 개념을 연구하는 데 효과적
단점
- 실제 제품 및 서비스 사용 경험과는 연관성이 낮을 수 있음
- 연구 결과가 사용자 행동에 미치는 영향을 예측하기 어려움

선호도 연구 (Desirability Studies)
- 사용자가 디자인 스타일을 보고 감성적 반응을 평가
브랜드 인식 연구 (Brand Perception Studies)
- 사용자가 브랜드에 대해 어떻게 인식하는지 조사

닫기

사용 교재

+ khux 세션 자료

Activity - Interaction

채영sw — Sun, 30 Mar 2025 14:37:00 +0900

Interaction (상호 작용) = 최적의 사용자 경험을 제공하기 위한 행위적 요소

-> 경험은 상호작용에서 비롯되기 때문에, 사람들의 경험을 이해하기 위해서 필수적!

상호작용의 주체와 관계에 따라

사회학
- Human - Human Interaction
- 사건들을 이루는 가장 기본적 단위로, 둘 이상의 사람이 모여 서로 영향을 주는 양방향적 관계
- ex. 친구 관계
커뮤니케이션학
- Human - Content Interaction
- 상호작용의 개념을 좀 더 구체화
- 미디어를 통해 전달되는 콘텐츠와 이를 전달 받는 사람 사이에 일어나는 여러 가지 과정
- ex. 미디어 광고에 사람들이 어떤 영향을 받고 어떻게 느끼는지

인간 - 컴퓨터 상호작용학
- Human - Computer Interaction
- 사람이 디지털 시스템을 사용하는 과정에서 시스템과 사람 사이에 일어나는 일련의 절차
- 과거에 비해 디지털 시스템 발전 -> 더욱 다양한 형태와 방식을 취할 수 있음 -> 더 넓고 다양한 경험 제공

상호작용의 네가지 절차

1) 표명 단계

사람들이 자신의 마음 속에 가지고 있는 추상적인 목표를 디지털 시스템에 나타난 구체적인 정보로 표현하는 단계
사용자는 일반적으로 목적을 가지고 시스템에 접했을 때 시스템에서 제시한 정보를 보고 자신의 목표를 구체적으로 명료화
- ex. 유튜브, 음악 앱의 디지털 시스템 추천 -> 영상을 보겠다/음악을 듣겠다의 목표 구체화
- 여름에 여름 음악 추천...등
고려할 점
- 사용자가 특정 시스템을 사용해 달성하고자 하는 목표가 시스템에서 제공하는 정보나 기능과 얼마나 일치하는가?
- 사람들이 이러한 기능이나 정보를 찾는 과정이 얼마나 용이한가? (디자인 중요)

2) 변환 단계

시스템의 입력 장치가 받은 정보를 시스템의 처리 장치로 변환하는 단계
입력 장치가 시스템의 기능을 얼마나 충실하게 반영하고 있는지를 의미
사용자에게 제시되는 입력 장치가 시스템의 기능과 상호작용의 가능성을 얼마나 충실하게 표현할 수 있는지가 중요
- ex. 음악 top 100 한 번에 담았다가 취향이 아닌 음악이 들어갔을 때 삭제, 한 번 더 듣고 싶으면 다시 넣는 기능, 순서 바꾸는 기능 등
데이터베이스에 있는 기능을 실제 인터페이스에서 구현하지 못한다면 변환 단계가 충실하지 못하다~

3) 표현 단계

시스템의 반응을 출력 도구로 전환하는 과정
시스템이 가지고 있는 정보의 넓이와 깊이를 시스템의 출력장치가 얼마나 충실하게 묘사할 수 있는지가 중요
- ex. 고상향 그래픽이 탑재된 컴퓨터에서만 돌아가는 게임, 게임 렉 -> 표현 단계가 충실하지 못하다~

4) 평가 단계

인터페이스에 나타난 정보를 보고 이를 사용자가 가지고 있는 목표와 비교
표명 단계에서 사용자가 마음속에서 구체화한 목표가 정말 잘 이루어졌는지 평가
적정한 범위의 정보들이 사용자가 이해하기 쉬운 형태로 제시되고 있는지가 중요
- ex. 내가 듣고 싶은 음악이 잘 나온다.

상호작용의 네 가지 종류

- 상호작용에 사용되는 내용을 만드는 과정과 그것이 사용자에게 전달되는 과정에서 사용자와 사업자 중에 누가 주도권을 가지고 있는지에 따라 상호작용의 유형 구분 전송형 | 등록형 | 문의형 | 대화형

전송형 (Transmission)
- 사업자가 주도해 내용을 만들어 사용자에게 전달하는 상호작용의 유형
- 전적으로 사업자가 편집권을 가지며 사용자는 수동적으로 정보를 받아들이는 상호작용
- 콘텐츠의 품질이 곧 상호작용의 품질을 좌우함
  - ex. TV 송출
등록형 (Registration)
- 사용자가 내용 생성을 주도하고 이를 사용자에게 전달하는 사업자 유형
- 내용은 개별 사용자를 통해 생성되지만, 상호작용이 진행되는 과정은 사업자나 운영자를 통해 이루어짐
- 등록하는 과정이 얼마나 쉽고 즐거운지, 사용자 입장에서 상품이나 콘텐츠를 등록하는 비용에 큰 효과를 거둘 수 있게 하는 것이 중요 (ex. 포인트, 돈)
  - ex. 족보 공유 사이트
문의형 (Consultation)
- 내용을 만드는 것은 사업자가 주도하고 사용자가 전달 과정의 주도권을 가지고 있는 유형
- 사업자에 의해 만들어진 상호작용의 내용이 사업자의 요구에 얼마나 적합한지, 그 내용을 찾아내는 과정이 얼마나 쉽고 즐거운지가 중요
  - ex. 밀리의 서재 - 만들어진 콘텐츠를 사용할지 말지는 사용자가 정한다~
대화형 (Conversation)
- 상호작용 내용을 만들고 전달하는 것도 사용자가 주도하는 유형
- 어떤 콘텐츠를 올리고 어떤 콘텐츠를 소비할지 모두 사용자가 결정
- 사용자가 상호작용의 내용과 절차를 주도하기 때문에 그 내용을 작성하는 과정이나 이를 전송하는 과정이 얼마나 사용하기 쉽고 즐거운지가 중요
  - ex. 인스타그램, 유튜브 등의 소셜 미디어

상호작용의 수준 평가 : 상호작용성

- 시스템이나 사람 간에 상호작용이 얼마나 활발한지를 측정하는 개념

- 상호성 | 반응성 | 신속성 | 다중성 | 통제성

상호성 (Reciprocity)
- 상호작용성을 이루는 가장 기본적인 개념
- 시스템이 일방적으로 정보를 전달하는 것이 아니라 사용자 입장에서 시스템과 양방향 의사교환이 얼마나 가능한지 판단
- 상호작용이 얼마나 자주 발생하는가?
  - ex. 카카오톡, 인스타그램 등 매일 쓰는 시스템 > 연말 정산을 할 때만 들어가는 국세정의 홈텍스
반응성 (Responsiveness)
- 시스템과 상호작용하는 사용자에게 시스템의 응답이 얼마나 적절하고 관련성이 높으며 사용자의 필요를 충족시켜 주고 있는지 판단
- 시스템이 사용자의 행동(액션)에 얼마나 적절하게 반응했는지
  - ex. 구글 검색 추천 검색어('경희' 만 쳐도 '경희대학교'가 나오는 것)
신속성 (Speed of Response)
- 상호작용의 반응이 얼마나 즉각적이고 지연이 없는지 판단
- (=) 매체의 동시성 - 매체의 전달 속도가 빠르거나 동시에 여러 가지 내용이 오갈 수 있을 때
  - ex. 다양한 앱 한 번에 사용, 왔다갔다 용이, 접속 시간
다중성 (Multimode)
- 한 번에 얼마나 다양한 모드의 정보를 제공하고 제공받을 수 있는지 판단
- 모드 : 인간, 기계가 정보를 주고 받는 채널의 성격
  - 시각, 청각 모드
  - ex. 휴대폰 - 통화(청각), 스와이프(촉각)...
- 높은 해상도를 가진 다양한 종류의 정보를 한 번에 주고 받을 수 있을 때
통제성 (Controllability)
- 상호작용을 통해 제공되는 정보의 순서와 내용 및 시간을 사용자가 조종할 수 있는 정도
- 부가적 상호작용성 -> 내용적 통제성 | 시간적 통제성
  - 내용적 통제성
    - 사용자가 상호작용의 내용을 얼마나 많이 변형할 수 있는가
      - ex. 나무위키 > 뉴스
  - 시간적 통제성
    - 상호작용하는 시간과 관련된 요소들을 사용자가 얼마나 마음대로 결정할 수 있는가
      - ex. 유튜브 영상 배속 > TV 송출 영상

상호작용의 행위와 스타일

- 사람들은 특정 목적을 달성하기 위해 어떤 행위를 하면서 상호작용함

- 사람들이 어떤 행위를 하면서 디지털 시스템과 상호작용하느냐에 따라 어떤 종류의 상호작용 스타일을 제공해 주는 것이 좋은지를 결정!

- 지시하기와 명령어 스타일 | 이야기하기와 대화형 스타일 | 탐색하기와 메뉴 스타일 | 조종하기와 직조작 스타일 | 위임하기와 대리인 스타일

지시하기와 명령어 스타일
- 지시하기
  - 사용자가 어떤 일을 수행하기 위해 디지털 시스템에게 어떤 작업을 지시하면, 시스템은 주어진 명령을 그대로 수행하기만 하는 경우
- 명령어 스타일 (Command Entry Style)
  - 기능키, 문자, 단축키, 명령어 등을 통해 디지털 시스템과 상호작용하는 것
    - ex. ctrl c + v, 포토샵/피그마 명령어 단축키..
  - 사용자마다 격차가 존재
    - 초보자들이 쓰기 어렵다 (-) vs 고수가 되면 매우 편하다 (+)
이야기하기와 대화형 스타일
- 이야기하기
  - 사용자가 시스템과 대화하고, 시스템은 사람의 대화 상대가 되는 경우
  - 사람들이 일상생활에서 해왔던 사람과 사람 간의 대화 방식으로 디지털 시스템을 대하는 것
- 대화형 스타일 (Dialog Style)
  - 시스템과 사용자가 일련의 질문과 대답을 주고 받으면서 상호작용을 진행시켜 나가는 방식
  - 질의응답형 스타일
    - ex. 윈도우 다운로드 창 다음, 동의함 등
    - ex. ATM 기 - 카드를 회수해야 돈이 나오도록 스타일 바꿔서 카드 분실 사고 감소
  - 양식형 스타일
    - ex. 설문조사 폼, 회원가입 정보 입력
  - 자연어형 스타일
    - ex. 시리, AI 스피커 (맥락 중요)
탐색하기와 메뉴 스타일
- 탐색하기
  - 사용자가 다양한 정보를 둘러보고 자신이 원하는 항목을 선택하는 방식
  - 새로운 지식을 알아가는 사용 과정 (+) vs 정보의 바닷속 방황 (-)
- 메뉴 스타일 (Menu Style)
  - 사용자에게 선택할 수 있는 대안을 텍스트나 그래픽 기반으로 제시 -> 메뉴구조를 항해하면서 원하는 대안 서치 -> 마우스나 키보드, 기능키를 이용해 원하는 대상 선택 -> 활성화
    - ex. 햄버거 바
조종하기와 직조작 스타일
- 조종하기
  - 사용자가 자신이 가지고 있는 실제 대상에 대한 지식을 기반으로 시스템에서 제공하고 있는 대상을 조종하는 방식
- 직조작 스타일 (Direct Manipulation Style)
  - 사용자의 작업 환경을 반영하는 대상이나 기능을 시각적으로 표현하는 인터페이스가 있고, 그 인터페이스 대상을 마우스 등의 방식을 이용해 직접 선택해서 원하는 조종 시행
    - ex. 게임 캐릭터 옷 갈아입히기, 아이템 창 바로 반영
- 조건 3가지
  - 사용자가 관심을 가지고 있는 대상이 항상 사용자에게 명확하게 제시되어야 함 (ex. 게임 캐릭터 마커화)
  - 복잡한 명령어를 입력하거나 메뉴를 선택하는 것이 아니라, 관심의 대상을 직접 조종할 수 있어야 함
  - 조작을 가한 결과가 즉시 나타나야 하고, 그 결과가 마음에 들지 않을 때에는 이를 번복할 수 있어야 함
위임하기와 대리인 스타일
- 위임하기
  - 사람이 직접 수행하기 귀찮은 행위를 디지털 시스템에게 위임함으로써 디지털 시스템이 어느 정도의 자율권을 가지고 작업을 수행하는 경우
- 대리인 스타일 (Intelligent Agent Sytle)
  - 특정 사용자가 어떤 필요성을 느끼고 있다는 것을 사용자가 직접 명시하지 않아도 미리 예측하고, 대리인 스스로의 판단 하에 필요한 행위를 취함
  - 나아가 새로운 개념이나 기술을 학습, 자신이 취한 행위에 대한 설명 가능
    - ex. 챗 gpt 논문 요약
- 조건 3가지
  - 대리인 시스템의 행동이 예측 가능해야 함 (시도때도 없는 참견 x, 신뢰 중요)
  - 사람이 대리인에게 의존할 수 있어야 함 (의존할 만큼 안정적)
  - 사용자도 대리인의 의견을 믿어야 함
    - ex. 할루시네이션 방지를 위한 장치 (출처를 함께 준다든지)

상호작용의 발전 추세

- 사회적 상호작용 | 창조적 상호작용 | 촉지적 상호작용

사회적 상호작용
- (HCI 1.0) 디지털 시스템과 개인 간의 기능적 상호작용 -> (HCI 2.0) 사용자 간의 네트워크 및 커뮤니티 기반의 상호작용
- 참여하는 상호작용 (ex. 치치직) | 개방하는 상호작용 (ex. 족보 공유) | 공감하는 상호작용 (ex. 기부 사이트 스토리텔링)
창조적 상호작용
- 이미 기존에 만들어진 제품이나 서비스 단순 이용 -> 새로운 디지털 제품이나 서비스를 사용자가 직접 만들어 가는 상호작용 | UCC (User Created Contents) UGC(User Generated Contents)
- 사용자가 제작자의 작품에 반응 (ex. 좋아요) | 제작자가 사용자의 의견 파악 (ex. 댓글) | 사용자가 공유된 관심사를 형성 (ex. 알고리즘 형성)
촉지적 상호작용
- 디지털 형식이기 때문에 물리적인 형태나 느낌을 가지고 있지 않아 다소 추상적 -> 최근 구체적으로 손으로 만져지는 상호작용으로 변화시키는 추세
  - 촉지적 조작 - 사용자의 직접적인 조작에 의한 물리적이고 신체적인 상호작용
    - 촉각 직조작 (ex. 스마트폰 확대/축소) | 경량 상호작용 (ex. 아이폰 사진 확대/움직임 즉각적으로 움직이는 피드백) | 동형 효과 (ex. 카메라 확대/축소 현실의 실세상 조작과 비슷)
  - 공간적 상호작용 - 상호작용이 일어나고 있는 공간의 의미를 적극적으로 활용한 상호작용, 밖에서 하는 행동 안에서 똑같이
    - 내재적 공간 (ex. VR 농구는 농구장 배경) | 전체적 상호작용 (ex. 닌텐도 운동 자기 몸 전체 사용) | 신체적 소통 (ex. 신체 움직임으로 의사 표현)
  - 표면적 묘사 - 디지털 시스템에서 상호작용의 대상을 사실적으로 표현하는 상호작용, 현실과 같은 입체감
    - 중점표현 (ex. 실제 세상 - 지도 나름대로 의미있게 표현) | 외재화 (ex. 생각하는 것 구체적인 대상으로 제공) | 지각된 맵핑 (ex. 로드뷰 실제 새상의 모습의 매칭)
  - 내재화된 촉진 - 사용자의 행동을 촉진, 허용하거나 금지, 제한하는 상호작용
    - 내재화된 제약사항 (ex. 사용자 행동 미세 조절 - 협업 유도) | 다중접속점 (ex. 모든 사용자가 어떤 일을 동시에 보고 직접 조작) | 맞춤형 표현 (ex. 시스템 표현 방식 = 일상생활 경험)

사용 교재

+ khux 세션 자료

HCI x UX 개론

채영sw — Mon, 17 Mar 2025 17:31:48 +0900

사용 교재

HCI (Human-Computer Interaction): 인간과 컴퓨터 사이의 상호작용 방식을 창조하고 평가함으로써 디지털 인공물을 구현하고, 사람들이 의미 있는 경험을 할 수 있도록 연구하는 분야

HCI 1.0: 한 명의 사용자와 컴퓨터 시스템 간에 주고 받는 상호작용에 대해 연구하고 궁극적으로 사용자가 좀 더 편리하게 사용할 수 있는 컴퓨터 시스템을 설계하고 평가하는 분야

HCI 2.0: 단순 개인이 컴퓨터 화면에서 보는 시스템의 모양을 넘어, 다양한 시스템과 사람들 간의 모든 상호작용을 연구 대상으로 함 (ex. 인스타그램 하트)

HCI 3.0: 차세대 HCI. 개인과 집단을 넘어 사회 전체를 대상으로 하며, 컴퓨터를 넘어 정보 기기, 디지털 제품 및 서비스, 콘텐츠까지 포함하는 전 영역을 연구 대상으로 함

HCI 분야가 중요한 이유

- 모든 문제를 디지털로 해결하는 시대

- 문제 해결 지점이 곧 비즈니스 기회로 직결

- 일상부터 죽음까지 삶의 모든 것에 영향

Interface

Interaction

Experience

목표: 위 세 가지 요소를 연구해 사용자에게 최적의 사용자 경험을 제공하는 고품질의 디지털 제품, 서비스 및 콘텐츠 개발하는 것이 HCI의 목표!

Tool - Interface

:컴퓨터와 같은 디지털 시스템의 입출력 장치

- 인터페이스 디자인: 입출력장치의 모양과 내용을 디자인하는 것

- 사용자와 접하는 시간이 상대적으로 짧음 (ex. 단일 화면, 효과음 등)

- 입출력 장치와 밀접하게 연결된 구체적인 도구로 간주될 수 있어 디지털 시스템과 밀접한 관계를 갖고 있음

Activity - Interaction

:입출력 장치를 매개로 디지털 시스템과 사람이 주고 받는 일련의 의사소통 과정

- 인터랙션 설계: 화면에 보이는 요소 뿐만 아니라 화면에 보이지 않는 사람의 행동과 이에 반응하는 시스템 전체를 설계하는 것

- 인터페이스보다 좀 더 긴 시간 사용자와 접촉 지속 (ex. 일련의 의사소통 과정을 가짐)

- 시스템 디자인에서의 인터랙션 디자인은 시스템의 행동적인 측면에 초점을 맞추고 있기 때문에 HCI 맥락에서의 상호작용보다 작은 개념

Goal - experience

:일상생활에서 사람들이 컴퓨터와 상호작용 하면서 사람들 속에 축적하게 되는 모든 지식과 기억과 감정

- 사용자가 디지털 제품이나 서비스를 사용하고나 사용 상황을 예상하면서 갖게 되는 모든 감정, 지각, 인지적인 결과

- 제품의 사용 전, 중, 후에 일어나는 사용자의 감정, 신념, 선호도, 지각, 신체적/정신적 반응이나 행동을 포함하는 넓은 개념

사용자 경험의 특징

- 주관성 (Subjectivity): 경험은 근본적으로 사람의 내부에 축적되는 효과

- 총체성 (Holistic): 특정 시점에 개인이 느끼는 총체적인 효과

- 정황성 (Contextuality): 인터랙션이 일어나는 시점에서의 환경이나 맥락에 영향 받음

최적의 경험

- 특정 경험을 시작하게 되면 계속 그 경험을 하고 싶어하는 상태

- 그 경험을 하는 동안에는 전적으로 그 일에만 집중하는 상태

- 경험에 해당되는 제품이나 서비스에 각별한 관심을 가지게 됨

- 경험하는 과정 그 자체를 즐기게 됨

최적의 경험을 위한 조건

- 유용성 (Usefulness): 사람들이 시스템을 이용해 하고자 하는 일을 효과적으로 달성할 수 있어야 함

- 사용성 (Usability): 사람들이 디지털 제품이나 서비스를 가능한 쉽고 편리하게 사용할 수 있어야 함 (최대한 적은 노력으로 목적 달성)

- 감성 (Affect): 시스템을 사용하면서 사람들이 마음속에서 얼마나 적절한 느낌을 받았는지를 판단 (목적에 적합한 감성을 풍부하게 느낄 수 있어야 함)

+ 차세대 경험을 위한 추가 조건

- 수용성 (Acceptability): 기술에 대한 수용성(ex. 서비스 시간이 너무 김)

- 관계성 (Relationship)

HCI 연구 절차

- UX 리서치: 사용자 분석, 과업 분석, 맥락 분석, 기술 분석

- UX 디자인: 컨셉 디자인, 정보구조 디자인(ex. 메뉴바 어디에?), 인터랙션 디자인, 인터페이스 디자인

- UX 향상: 디지털 시스템의 최종 목표 설정, 현재 상태 평가 및 개선

github 오류 해결

채영sw — Sun, 24 Nov 2024 19:17:56 +0900

git config --global user.name "Your Name"
git config --global user.email "you@example.com"

설정 확인

git config --global --list

git commit -m "Initial commit"

SSH 키 생성 확인

ls ~/.ssh

SSH 키 생성
ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

SSH 공개 키 복사
cat ~/.ssh/id_rsa.pub

SSH 에이전트 시작
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_rsa

SSH키 추가 여부 확인
ssh-add -l

github에서 SSH 등록 (settings, SSH and GPG keys)

연결 확인

ssh -T git@github.com

강제 푸시

git push -u origin main --force

<로컬 브랜치와 원격 브랜드 연결>

git fetch origin main

<파일 크기 제한>

Git LFS(Git Large File Storage) 사용

git lfs install

git lfs track "제한 파일"
git add .gitattributes [제한파일]
git commit -m "Track large file with Git LFS"

+ 로그 확인

git log --name-only

github 2 (.gitignore , requirements.txt)

채영sw — Sun, 24 Nov 2024 13:53:29 +0900

1) .gitignoer

.gitignoer 파일 생성

https://www.toptal.com/developers/gitignore

gitignore.io

Create useful .gitignore files for your project

www.toptal.com

2) requirements.txt

pip list

pip freeze > requirements.txt

한번에 설치

pip install -r requirements.txt

github

채영sw — Sun, 24 Nov 2024 11:55:49 +0900

< 깃 클론 : 레포지토리 복사 >

git clone ~
git clone -b 브랜치 이름 ~

< cd (change directory) >

< 깃허브에 새 브랜치를 생성하고 작업한 파일을 업로드하는 방법 >

로컬에서 새 브랜치 생성

# 새로운 브랜치 생성
git checkout -b 새브랜치이름

작업한 파일 스테이징 및 커밋

# 모든 변경 사항을 추가 (스테이징)
git add .

git add [파일/디렉토리 이름]


//add한 파일 모두 취소
git rm --cached -r .

//특정 파일만 add 취소
git rm --cached [파일]


# 커밋
git commit -m "작업 내용에 대한 설명"

github의 원격 저장소에 푸시

git push origin 새브랜치이름

git push -u origin main

//로컬 저장소에서 원격 저장소로 올리기
git push origin [브랜치 이름]

Repository에 'main' branch로 push하기

git init
git add [디렉토리명]
git commit -m "commit message"

git push -u origin main

원격 저장소 바꾸기

//연결된 원격저장소 있는지 확인
git remote -v

//이미 존재하는 원격저장소 삭제
git remote rm origin

//원격 저장소와 연결
git remote add origin [깃헙 레포지토리 주소]

내가 현재 있는 branch 확인하기

git branch

branch 이름 바꾸기

git branch -M [되고싶은 branch name]
git branch -m [현재 branch name] [바꾸고싶은 branch name]

branch 전환하기

git branch checkout [전환하고싶은 브랜치명]

pull

git pull origin [branch name]
git pull

05장(회원 탈퇴를 예측하는 테크닉), 06장(물류의 최적경로를 컨설팅하는 테크닉)

채영sw — Wed, 2 Oct 2024 17:01:32 +0900

05장. 회원 탈퇴를 예측하는 테크닉 10

전제 조건

→ 스포츠 센터의 데이터

<041. 데이터를 읽어 들이고 이용 데이터를 수정하자>

import pandas as pd
customer = pd.read_csv('customer_join.csv')
uselog_months = pd.read_csv('use_log_months.csv')

미래를 예측하기 위해 그 달과 1개월 전의 이용 이력(횟수)만으로 데이터 작성

year_months = list(uselog_months["연월"].unique())
uselog = pd.DataFrame()
for i in range(1, len(year_months)):
    tmp = uselog_months.loc[uselog_months["연월"]==year_months[i]]
    tmp.rename(columns={"count":"count_0"}, inplace = True)
    tmp_before = uselog_months.loc[uselog_months["연월"]==year_months[i-1]]
    del tmp_before["연월"]
    tmp_before.rename(columns={"count":"count_1"}, inplace=True)
    tmp = pd.merge(tmp, tmp_before, on="customer_id", how="left")
    uselog = pd.concat([uselog, tmp], ignore_index=True)
uselog.head()

count_0 : 현재 달

count_1 : 이전 달

<042. 탈퇴 전월의 탈퇴 고객 데이터를 작성하자>

이 데이터의 경우 탈퇴 월의 관계성이 아래와 같으므로, 탈퇴 월이 아닌 탈퇴 전월의 데이터를 작성함.

탈퇴한 회원을 추출하고, end_date의 1개월 전을 계산해 연월에 저장한 후 uselog와 결합

from dateutil.relativedelta import relativedelta
exit_customer = customer.loc[customer["is_deleted"]==1]
exit_customer["exit_date"] = None
exit_customer["end_date"] = pd.to_datetime(exit_customer["end_date"])
for i in range(len(exit_customer)):
    exit_customer["exit_date"].iloc[i] = exit_customer["end_date"].iloc[i] - relativedelta(months=1)
exit_customer["연월"] = pd.to_datetime(exit_customer["exit_date"]).dt.strftime("%Y%m")
uselog["연월"] = uselog["연월"].astype(str)
exit_uselog = pd.merge(uselog, exit_customer, on=["customer_id", "연월"], how="left")
print(len(uselog))
exit_uselog.head()

33851

exit_customer["exit_date"] = None

→ exit_customer 데이터프레임에 새로운 열 만들고, 모든 값을 None으로 초기화

exit_customer["exit_date"].iloc[i] = exit_customer["end_date"].iloc[i] - relativedelta(months=1)

→ relativedelta(months=1) : end_date에서 한 달 전 날짜를 계산해 줌

결측치 없는 데이터만 남기고 나머지 제거 → 특정 회원이 그만두기 전월의 상태를 나타내는 데이터

exit_uselog = exit_uselog.dropna(subset=["name"])
print(len(exit_uselog))
print(len(exit_uselog["customer_id"].unique()))
exit_uselog.head()

1104

exit_uselog = exit_uselog.dropna(subset=["name"])

→ name 열만을 기준으로 결측값을 확인하여 그 행 삭제

<043. 지속 회원의 데이터를 작성하자>

지속 회원은 탈퇴 월이 없기 때문에 어떤 연월의 데이터를 작성해도 상관 없음

conti_customer = customer.loc[customer["is_deleted"]==0]
conti_uselog = pd.merge(uselog, conti_customer, on=["customer_id"], how="left")
print(len(conti_uselog))
conti_uselog = conti_uselog.dropna(subset=["name"])
print(len(conti_uselog))

33851

27422

name 칼럼의 결손 데이터를 제거해 탈퇴 회원 제거

탈퇴 데이터가 1104개밖에 없기 때문에 지속회원 데이터 27422개를 전부 사용한다면 불균형 데이터가 되어 버림

→ 한쪽의 데이터가 몇 %밖에 없는 경우 샘플의 수를 조정! (언더샘플링)

지속 회원 데이터가 회원 당 1개가 되도록 언더샘플링

conti_uselog = conti_uselog.sample(frac=1).reset_index(drop=True)
conti_uselog = conti_uselog.drop_duplicates(subset="customer_id")
print(len(conti_uselog))
conti_uselog.head()

2842

conti_uselog = conti_uselog.sample(frac=1).reset_index(drop=True)

→ conti_uselog의 모든 행을 무작위로 섞음

→ sample(frac=1) : 전체 데이터(비율 1, 즉 100%)를 무작위로 샘플링하여 섞어주기 위해 사용

→ reset_index(drop=True) : 섞은 후 원래 인덱스 삭제 후, 새롭게 인덱스를 0부터 다시 부여(리셋)

conti_uselog = conti_uselog.drop_duplicates(subset="customer_id")

→ customer_id를 기준으로 중복된 행 제거(기본적으로 첮 번째로 등장한 중복 값을 남김)

- 지속 회원과 탈퇴 회원 데이터를 세로 결합

predict_data = pd.concat([conti_uselog, exit_uselog],ignore_index=True)
print(len(predict_data))
predict_data.head()

3946

<044. 예측할 달의 재적 기간을 작성하자>

- 재적 기간 데이터를 변수로 이용하기 위해 재적 기간 열 추가

predict_data["period"] = 0
predict_data["now_date"] = pd.to_datetime(predict_data["연월"], format="%Y%m")
predict_data["start_date"] = pd.to_datetime(predict_data["start_date"])
for i in range(len(predict_data)):
    delta = relativedelta(predict_data["now_date"][i], predict_data["start_date"][i])
    predict_data["period"][i] = int(delta.years*12 + delta.months)
predict_data.head()

<045. 결측치를 제거하자>

결측치가 있으면 머신러닝할 수 없으므로 결측치 제거 or 채워야 함 → 제거 선택

- 결측치의 수 파악

predict_data.isna().sum()

end_date와 exit_date는 탈퇴 고객만 있는 것이므로 유지 회원은 켤측치가 되는 게 당연

여기서는 count_1의 결손치만 제거

predict_data = predict_data.dropna(subset=["count_1"])
predict_data.isna().sum()

<046. 문자열 변수를 처리할 수 있게 가공하자>

머신러닝할 때 가입 캠페인 구분, 회원 구분, 성별과 같은 문자열 데이터 (카테고리 변수) 어떻게 처리하면 좋을까?

→ 플래그 만들기! (더미 변수 : 독립 변수를 0과 1로 변환한 변수)

target_col = ["campaign_name", "class_name", "gender", "count_1", "routine_flg", "period", "is_deleted"]
predict_data = predict_data[target_col]
predict_data.head()

특정 열만 선택해 새로운 데이터프레임 생성

→ 설명 변수로 1개월 전의 이용 횟수 count_1

→ 카테고리 변수 campaign_name, class_name, gender, 정기 이용 여부 플래그 routine_flg, 재적기간 period

→ 목적 변수로 탈퇴 플래그 is_deleted 사용

- 카테고리 변수를 이용해 더미 변수 만들기

predict_data = pd.get_dummies(predict_data)
predict_data.head()

pandas의 get_dummies를 이용해 일괄적으로 더미 변수 생성

- 겹치는 정보를 제거하기 위해 campaign_name_일반, class_name_야간, gender_M 삭제

del predict_data["campaign_name_일반"]
del predict_data["class_name_야간"]
del predict_data["gender_M"]
predict_data.head()

<047. 의사결정 트리를 사용해서 탈퇴 예측 모델을 구축하자>

- 의사결정 트리 알고리즘을 사용해 모델 구축하기

from sklearn.tree import DecisionTreeClassifier
import sklearn.model_selection

exit = predict_data.loc[predict_data["is_deleted"]==1]
conti = predict_data.loc[predict_data["is_deleted"]==0].sample(len(exit))

X = pd.concat([exit, conti], ignore_index=True)
y = X["is_deleted"]
del X["is_deleted"]
X_train, X_test, y_train, y_test = sklearn.model_selection.train_test_split(X,y)

model = DecisionTreeClassifier(random_state=0)
model.fit(X_train, y_train)
y_test_pred = model.predict(X_test)
print(y_test_pred)

- 1은 탈퇴, 0은 유지를 의미

- from sklearn.tree import DecisionTreeClassifier

→ Decision Tree 분류 모델을 사용하기 위해 sklearn 라이브러리에서 DecisionTreeClassifier 임포트

- import sklearn.model_selection

→ train_test_split 함수 사용을 위해 sklearn.model_selection 모듈 임포트

- conti = predict_data.loc[predict_data["is_deleted"]==0].sample(len(exit))

→ exit 데이터프레임과 같은 크기로 무작위 샘플링하여 모델 편향 방지

- fit으로 학습용 데이터를 사용해 모델 구축

- predict로 평가 데이터 예측

- 실제 정답 비교

results_test = pd.DataFrame({"y_test":y_test ,"y_pred":y_test_pred })
results_test.head()

<048. 예측 모델을 평가하고 모델을 튜닝해 보자>

- results_test 데이터를 집계해 정답률 계산하기

correct = len(results_test.loc[results_test["y_test"]==results_test["y_pred"]])
data_count = len(results_test)
score_test = correct / data_count
print(score_test)

0.8973384030418251

약 90% 정도의 정확도!

학습용 데이터로 예측한 정확도와 평가용 데이터로 예측한 정확도의 차이가 작은 것이 이상적임

print(model.score(X_test, y_test))
print(model.score(X_train, y_train))

0.8973384030418251
0.9790874524714829

train data에 과적합인 경향이 있음!

→ 데이터 늘리기, 변수 재검토, 모델의 파라미터 변경 등의 방법을 적용해 이상적인 모델로 만들 수 있음

모델의 파라미터 바꾸기

→ 의사결정 트리는 0과 1로 분할할 수 있는 설명 변수와 그 조건에 맞는 트리 구조를 찾는 방법이므로, 트리의 깊이를 얕게 하면 모델을 단순화할 수 있음

X = pd.concat([exit, conti], ignore_index=True)
y = X["is_deleted"]
del X["is_deleted"]
X_train, X_test, y_train, y_test = sklearn.model_selection.train_test_split(X,y)

model = DecisionTreeClassifier(random_state=0, max_depth=5)
model.fit(X_train, y_train)
print(model.score(X_test, y_test))
print(model.score(X_train, y_train))

0.9106463878326996
0.9334600760456274

max_depth를 5로 지정해 트리 깊이 제한

<049. 모델에 기여하는 변수를 확인하자>

- 변수와 중요도 저장 → 변수의 기여율 확인

importance = pd.DataFrame({"feature_names":X.columns, "coefficient":model.feature_importances_})
importance

- model.feature_importances_

→ 학습된 의사결정 나무 모델이 각 특징에 부여한 중요도 값을 coefficient 열에 저장

- 1개월 전의 이용 횟수, 정기 이용 여부, 재적 기간이 크게 기여함을 알 수 있음

의사결정 트리 결과 가시화

→ graphviz, plot_tree와 같은 라이브러리 이용

from sklearn.tree import plot_tree
import matplotlib.pyplot as plt

plt.figure(figsize=(20,10))  # 그래프 크기 설정
plot_tree(model, 
          feature_names=list(X.columns),
          class_names=["Not Deleted", "Deleted"],  
          filled=True, #색 채우기
          rounded=True, 
          fontsize=10)  # 폰트 크기 설정
plt.show()

<050. 회원 탈퇴를 예측하자>

- 예측을 위한 데이터 작성

count_1 = 3
routing_flg = 1
period = 10
campaign_name = "입회비무료"
class_name = "종일"
gender = "M"

- 데이터 가공

→ 카테고리 변수를 if 문으로 분기하면서 더미 변수로 작성

if campaign_name == "입회비반값할인":
    campaign_name_list = [1, 0]
elif campaign_name == "입회비무료":
    campaign_name_list = [0, 1]
elif campaign_name == "일반":
    campaign_name_list = [0, 0]
if class_name == "종일":
    class_name_list = [1, 0]
elif class_name == "주간":
    class_name_list = [0, 1]
elif class_name == "야간":
    class_name_list = [0, 0]
if gender == "F":
    gender_list = [1]
elif gender == "M":
    gender_list = [0]
input_data = [count_1, routing_flg, period]
input_data.extend(campaign_name_list)
input_data.extend(class_name_list)
input_data.extend(gender_list)

범주형 데이터를 원핫 인코딩 (One-Hot Encoding) 방식으로 변환하여 input_data 리스트에 추가

인코딩(encoding) / 부호화 : 데이터의 양을 줄이기 위해 데이터를 코드화하고 압축, 변형하는 것

디코딩(decoding) : 압축, 변형된 데이터를 원형으로 변환하는 것

원핫(one-hot) : 비트들의 모임 중 하나만 1이고 나머지는 모두 0인 비트들의 그룹

원핫 인코딩 : 데이터를 one-hot 데이터 형태로 변형, 압축하는 것

→ 범주의 개수에 따라 벡터의 크기 달라짐

from sklearn.preprocessing import OneHotEncoder

print(model.predict([input_data]))  # 0 또는 1로 예측된 클래스 반환
print(model.predict_proba([input_data])) # 각 클래스에 속할 확률 반환

[1.]
[[0.01492537 0.98507463]]

- 1, 즉 탈퇴가 예상됨

06장. 물류의 최적경로를 컨설팅하는 테크닉 10

전제 조건

→ 부품을 보관하는 창고에서 생산 공장으로 부품 운송

→ 각 창고와 공장 구간의 운송 비용은 과거 데이터에서 정량적으로 계산되어 있음

→ 집계 기간 2019년 1월 1일 ~ 2019년 12월 31일

→ 북부지사와 남부지사의 데이터를 csv로 제공

<051. 물류 데이터를 불러오자>

import pandas as pd

# 공장데이터 불러오기
factories = pd.read_csv("tbl_factory.csv", index_col=0)
factories

# 창고데이터 불러오기
warehouses = pd.read_csv("tbl_warehouse.csv", index_col=0)
warehouses

# 비용 테이블
cost = pd.read_csv("rel_cost.csv", index_col=0)
cost.head()

# 운송 실적 테이블
trans = pd.read_csv("tbl_transaction.csv", index_col=0)
trans.head()

- index_col=0

→ csv 파일의 첫 번째 열을 데이터프레임의 인덱스로 설정

- 공장 데이터 'FCID'와 창고 데이터 "'WHID' 가 키임을 알 수 있음

→ 운석 실적을 중심으로 각 정보 결합(레프트 조인)

join_data = pd.merge(trans, cost, left_on=["ToFC","FromWH"], right_on=["FCID","WHID"], how="left")
join_data.head()

- 운송 실적 테이블에 비용 데이터 추가

- 운송 실적 데이터의 도착 공장(ToFC), 출발 창고(FromWH)와 비용 데이터의 공장ID(FCID)와 창고ID(WHID)를 키로 결합

join_data = pd.merge(join_data, factories, left_on="ToFC", right_on="FCID", how="left")
join_data.head()

- 공장 정보 추가

- ToFC 열과 FCID의 열이 일치하는 데이터를 찾아 병합

→ 일치하지 않는 경우 오른쪽 데이터프레임의 값은 NaN으로 채워짐(left 조인)

join_data = pd.merge(join_data, warehouses, left_on="FromWH", right_on="WHID", how="left")

join_data = join_data[["TransactionDate","Quantity","Cost","ToFC","FCName","FCDemand","FromWH","WHName","WHSupply","WHRegion"]]
join_data.head()

- 창고 정보 추가, 컬럼 정리

- 순서대로 운송 날짜, 운송 수량, 비용, 공장ID, 공장명, 공장수요, 창고ID, 창고명, 창고 공급량, 지사

- 연결에 사용했던 키는 필요 없으니 데이터에서 삭제

- 지사 별로 데이터를 비교하기 위해 각각 해당하는 데이터만 추출해서 변수에 저장

north = join_data.loc[join_data["WHRegion"]=="북부"]
north.head()

- 북부 데이터 추출

south = join_data.loc[join_data["WHRegion"]=="남부"]
south.head()

-남부 데이터 추출

<052. 현재 운송량과 비용을 확인해 보자>

- 1년간 운송한 부품 수와 비용 집계

print("북부지사 총비용: " + str(north["Cost"].sum()) + "만원")
print("남부지사 총비용: " + str(south["Cost"].sum()) + "만원")

북부지사 총비용: 2189.3만원
남부지사 총비용: 2062.0만원

- 1년간 운송 비용을 sum으로 집계

- 북부지사 쪽이 운송 비용의 총액이 많이 소요되는 것을 알 수 있음

print("북부지사의 총부품 운송개수: " + str(north["Quantity"].sum()) + "개")
print("남부지사의 총부품 운송개수: " + str(south["Quantity"].sum()) + "개")

북부지사의 총부품 운송개수: 49146개
남부지사의 총부품 운송개수: 50214개

- 1년간의 운송 실적으로 실제로 운송한 부품의 수 집계

- 남부지사 쪽이 많은 부품을 운송하고 있음을 알 수 있음

tmp = (north["Cost"].sum() / north["Quantity"].sum()) * 10000
print("북부지사의 부품 1개당 운송 비용: " + str(int(tmp)) + "원")
tmp = (south["Cost"].sum() / south["Quantity"].sum()) * 10000
print("남부지사의 부품 1개당 운송 비용: " + str(int(tmp)) + "원")

북부지사의 부품 1개당 운송 비용: 445원
남부지사의 부품 1개당 운송 비용: 410원

- 부품 1개당 운송 비용 계산 → 남부지사 쪽이 1개당 운송 비용이 낮음을 알 수 있음

cost_chk = pd.merge(cost, factories, on="FCID", how="left")

print("북부지사의 평균 운송 비용：" + str(cost_chk["Cost"].loc[cost_chk["FCRegion"]=="북부"].mean()) + "원")
print("남부지사의 평균 운송 비용：" + str(cost_chk["Cost"].loc[cost_chk["FCRegion"]=="남부"].mean()) + "원")

북부지사의 평균 운송 비용：1.075원
남부지사의 평균 운송 비용：1.05원

- cost와 factories 데이터를 FICD 열을 기준으로 병합

- 비용을 지사별로 집계 후 평균 → 평균 운송 비용은 거의 같으므로, 남부지사 쪽이 효율 높게 부품을 운송하고 있다는 것을 알 수 있음

<053. 네트워크를 가시화해 보자>

최적 경로를 가시화하는 방법인 네트워크 가시화

→ NetworkX

import networkx as nx
import matplotlib.pyplot as plt

# 그래프 객체생성
G=nx.Graph()

# 노드 설정
G.add_node("nodeA")
G.add_node("nodeB")
G.add_node("nodeC")

# 엣지 설정
G.add_edge("nodeA","nodeB")
G.add_edge("nodeA","nodeC")
G.add_edge("nodeB","nodeC")

# 좌표 설정
pos={}
pos["nodeA"]=(0,0)
pos["nodeB"]=(1,1)
pos["nodeC"]=(0,1)

# 그리기
nx.draw(G,pos)

# 표시
plt.show()

- 그래프 객체 선언 후 노드와 각각을 연결할 엣지 설정

→ networkx : 그래프(네트워크)를 생성하고 노드와 엣지를 다루기 위한 라이브러리

- pos로 노드의 좌표를 설정하고 draw 함수를 이용해 그리기

- matplotlib의 함수 show 사용해서 그래프를 화면에 표시

- 이 흐름으로 네트워크를 가시화해서 창고에서 대리점까지의 물류를 표현할 수 있음

→ 물류의 쏠림과 같은 전체 그림 파악 가능

<054. 네트워크에 노드를 추가해 보자>

G.add_node("nodeD")
G.add_edge("nodeA", "nodeD")
pos["nodeD"]=(1,0)
nx.draw(G, pos, with_labels = True)

- with_labels=True

→ 각 노드에 레이블이 표시되도록 설정

- dict 형식으로 pos에 위치 추가

<055. 경로에 가중치를 부여하자>

가중치를 이용해 노드 사이의 엣지 굵기를 바꿈으로써 물류의 최적 경로를 알기 쉽게 가시화할 수 있음

→ csv 파일에 저장된 가중치 정보를 데이터프레임으로 읽어 들여 사용하는 방법을 이용해보자!

df_w / df_p

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import networkx as nx

# 데이터 불러오기
df_w = pd.read_csv('network_weight.csv')
df_p = pd.read_csv('network_pos.csv')

# 그래프 객체 생성
G = nx.Graph()

# 노드 설정
for i in range(len(df_w.columns)):
    G.add_node(df_w.columns[i])

# 엣지 설정 & 가중치 리스트화
size = 10
edge_weights = []
num_pre = 0
# 엣지 가중치 확인용 번역자 추가 코드
name = ['A','B','C','D','E']

for i in range(len(df_w.columns)):
    for j in range(len(df_w.columns)):
        if not (i==j):
            # 엣지 추가
            G.add_edge(df_w.columns[i],df_w.columns[j])
            if num_pre<len(G.edges):
                num_pre = len(G.edges)
                # 엣지 가중치 추가
                edge_weights.append(df_w.iloc[i][j]*size)
               
                # 엣지 가중치 확인용 번역자 추가 코드
                print(f'({name[i]}, {name[j]}) = {np.round(edge_weights[-1],5)}')
               

# 좌표 설정
pos = {}
for i in range(len(df_w.columns)):
    node = df_w.columns[i]
    pos[node] = (df_p[node][0],df_p[node][1])

# 그리기
nx.draw(G, pos, with_labels=True,font_size=16, node_size = 1000, node_color='k', font_color='w', width=edge_weights)

# 표시
plt.show()

for i in range(len(df_w.columns)):
    G.add_node(df_w.columns[i])

- df_w의 열 이름을 사용해 각 노드를 그래프에 추가

size = 10
edge_weights = []
num_pre = 0
name = ['A', 'B', 'C', 'D', 'E']

- 엣지의 가중치를 저장할 리스트 생성

- 현재까지 추가된 엣지 수를 추적하기 위한 num_pre 변수 설정

- name : 엣지 가중치를 출력하기 위한 노드 이름 리스트

for i in range(len(df_w.columns)):
    for j in range(len(df_w.columns)):
        if not (i==j):
            G.add_edge(df_w.columns[i], df_w.columns[j])
            if num_pre < len(G.edges):
                num_pre = len(G.edges)
                edge_weights.append(df_w.iloc[i][j] * size)
                print(f'({name[i]}, {name[j]}) = {np.round(edge_weights[-1], 5)}')

- 두 노드 간의 엣지 추가, 가중치를 edge_weights 리스트에 부여

- df_w.iloc[i][j] * size : 가중치 값에 size 변수를 곱해 엣지의 두께를 더 강조함

- 새 엣지가 추가될 때만 가중치를 저장

- 소수점 5자리까지 반올림하여 출력

pos = {}
for i in range(len(df_w.columns)):
    node = df_w.columns[i]
    pos[node] = (df_p[node][0], df_p[node][1])

- 노드의 좌표를 저장하는 딕셔너리 생성

- df_p에서 각 노드의 x, y 좌표를 가져와 pos 딕셔너리에 저장

<056. 운송 경로 정보를 불러오자>

제품의 부품을 저장한 창고 W1, W2, W3에서 조립 공장 F1, F2, F3, F4로 필요한 부품을 운송

import pandas as pd

df_tr = pd.read_csv('trans_route.csv', index_col="공장")
df_tr.head()

<057. 운송 경로 정보로 네트워크를 가시화해 보자>

import pandas as pd
import matplotlib.pyplot as plt
import networkx as nx

df_tr = pd.read_csv('trans_route.csv', index_col="공장")
df_pos = pd.read_csv('trans_route_pos.csv')


# 그래프 객체 생성
G = nx.Graph()

# 노드 설정
for i in range(len(df_pos.columns)):
    G.add_node(df_pos.columns[i])

# 엣지 설정 및 가중치 리스트화
num_pre = 0
edge_weights = []
size = 0.1
for i in range(len(df_pos.columns)):
    for j in range(len(df_pos.columns)):
        if not (i==j):
            # 엣지 추가
            G.add_edge(df_pos.columns[i],df_pos.columns[j])
            # 엣지 가중치 추가
            if num_pre<len(G.edges):
                num_pre = len(G.edges)
                weight = 0
                if (df_pos.columns[i] in df_tr.columns)and(df_pos.columns[j] in df_tr.index):
                    if df_tr[df_pos.columns[i]][df_pos.columns[j]]:
                        weight = df_tr[df_pos.columns[i]][df_pos.columns[j]]*size
                elif(df_pos.columns[j] in df_tr.columns)and(df_pos.columns[i] in df_tr.index):
                    if df_tr[df_pos.columns[j]][df_pos.columns[i]]:
                        weight = df_tr[df_pos.columns[j]][df_pos.columns[i]]*size
                edge_weights.append(weight)
                

# 좌표 설정
pos = {}
for i in range(len(df_pos.columns)):
    node = df_pos.columns[i]
    pos[node] = (df_pos[node][0],df_pos[node][1])
    
# 그리기
nx.draw(G, pos, with_labels=True,font_size=16, node_size = 1000, node_color='k', font_color='w', width=edge_weights)

# 표시
plt.show()

if (df_pos.columns[i] in df_tr.columns) and (df_pos.columns[j] in df_tr.index):
                    if df_tr[df_pos.columns[i]][df_pos.columns[j]]:
                        weight = df_tr[df_pos.columns[i]][df_pos.columns[j]] * size
                elif (df_pos.columns[j] in df_tr.columns) and (df_pos.columns[i] in df_tr.index):
                    if df_tr[df_pos.columns[j]][df_pos.columns[i]]:
                        weight = df_tr[df_pos.columns[j]][df_pos.columns[i]] * size
                edge_weights.append(weight)

- 노드 간의 경로가 존재할 경우 가중치 계산

- 골고루 엣지가 보임 → 운송 비용을 생각하면 운송 경로는 어느 정도 집중되는 편이 효율이 높을 수 있음

<058. 운송 비용 함수를 작성하자>

최적화 문제를 푸는 패턴

- 최소화(또는 최대화)하고 싶은 것을 함수로 정의 (목적 함수)

- 최소화(또는 최대화)를 함에 있어 지켜야 할 조건 정의 (제약 조건)

- 생각할 수 있는 여러 가지 조합 중에서 제약 조건을 만족시키면서 목적함수를 최소화(또는 최대화)하는 조합 선택

가설 : 운송 비용을 낮출 효율적인 운송 경로가 존재한다.

→ 이 가설을 입증하고 운송 경로를 최적화하기 위해 먼저 운송 비용을 계산할 함수를 작성하고 목적함수로 정의

import pandas as pd

# 데이터 불러오기
df_tr = pd.read_csv('trans_route.csv', index_col="공장")
df_tc = pd.read_csv('trans_cost.csv', index_col="공장")

# 운송 비용 함수
def trans_cost(df_tr,df_tc):
    cost = 0
    for i in range(len(df_tc.index)):
        for j in range(len(df_tr.columns)):
            cost += df_tr.iloc[i][j]*df_tc.iloc[i][j]
    return cost

print("총 운송 비용:"+str(trans_cost(df_tr,df_tc)))

총 운송 비용:1493

- 운송 경로의 운송량과 비용을 곱하고 전부 더해서 총 운송 비용을 계산

- 함수로 미리 작성함으로써, 변경 후 운송 비용을 간단히 계산할 수 있도록 함

<059. 제약 조건을 만들어보자>

- 각 창고는 공급 가능한 부품 수에 제한이 있음

- 각 공장은 채워야 할 최소한의 제품 제조량이 있음

import pandas as pd

# 데이터 불러오기
df_tr = pd.read_csv('trans_route.csv', index_col="공장")
df_demand = pd.read_csv('demand.csv')
df_supply = pd.read_csv('supply.csv')

# 수요측 제약조건
for i in range(len(df_demand.columns)):
    temp_sum = sum(df_tr[df_demand.columns[i]])
    print(str(df_demand.columns[i])+"으로 운송량:"+str(temp_sum)+" (수요량:"+str(df_demand.iloc[0][i])+")")
    if temp_sum>=df_demand.iloc[0][i]:
        print("수요량을 만족시키고있음")
    else:
        print("수요량을 만족시키지 못하고 있음. 운송경로 재계산 필요")

# 공급측 제약조건
for i in range(len(df_supply.columns)):
    temp_sum = sum(df_tr.loc[df_supply.columns[i]])
    print(str(df_supply.columns[i])+"부터의 운송량:"+str(temp_sum)+" (공급한계:"+str(df_supply.iloc[0][i])+")")
    if temp_sum<=df_supply.iloc[0][i]:
        print("공급한계 범위내")
    else:
        print("공급한계 초과. 운송경로 재계산 필요")

F1으로 운송량:30 (수요량:28)
수요량을 만족시키고있음
F2으로 운송량:30 (수요량:29)
수요량을 만족시키고있음
F3으로 운송량:32 (수요량:31)
수요량을 만족시키고있음
F4으로 운송량:25 (수요량:25)
수요량을 만족시키고있음
W1부터의 운송량:35 (공급한계:35)
공급한계 범위내
W2부터의 운송량:40 (공급한계:41)
공급한계 범위내
W3부터의 운송량:42 (공급한계:42)
공급한계 범위내

- 각 공장으로 운반되는 부품의 수와 각 공장에 대한 수요량을 비교하면 공장에서 제조된 제품의 수가 수요량을 만족시키는지 여부를 검토할 수 있음

- 각 창고에서 출하되는 부품의 수가 창고의 공급 한계를 넘는지를 검토할 수 있음

- temp_sum = sum(df_tr[df_demand.columns[i]])

→ 각 수요지로 운송되는 총 운송량 계산

- temp_sum = sum(df_tr.loc[df_supply.columns[i]])

→ 각 공급 공장에서 운송된 총 운송량 계산

<060. 제약 조건을 만들어보자>

- 시험 삼아 W1에서 F4로의 운송을 줄이고, 그만큼을 W2에서 F2로의 운송으로 보충하게 변경한 경로가 저장된 trans_route_new.csv를 불러들여 이 경로가 제약 조건을 만족시키는지, 어느 정도 비용 개선이 가능한지 확인, 계산

import pandas as pd
import numpy as np

# 데이터 불러오기
df_tr_new = pd.read_csv('trans_route_new.csv', index_col="공장")
print(df_tr_new)

# 총 운송비용 재계산 
print("총 운송 비용(변경 후):"+str(trans_cost(df_tr_new,df_tc)))

# 제약조건 계산함수
# 수요측
def condition_demand(df_tr,df_demand):
    flag = np.zeros(len(df_demand.columns))
    for i in range(len(df_demand.columns)):
        temp_sum = sum(df_tr[df_demand.columns[i]])
        if (temp_sum>=df_demand.iloc[0][i]):
            flag[i] = 1
    return flag
            
# 공급측
def condition_supply(df_tr,df_supply):
    flag = np.zeros(len(df_supply.columns))
    for i in range(len(df_supply.columns)):
        temp_sum = sum(df_tr.loc[df_supply.columns[i]])
        if temp_sum<=df_supply.iloc[0][i]:
            flag[i] = 1
    return flag

print("수요조건 계산결과:"+str(condition_demand(df_tr_new,df_demand)))
print("공급조건 계산결과:"+str(condition_supply(df_tr_new,df_supply)))

    F1  F2  F3  F4
공장                
W1  15  15   0   0
W2   5   0  30  10
W3  10  15   2  15
총 운송 비용(변경 후):1428
수요조건 계산결과:[1. 1. 1. 1.]
공급조건 계산결과:[1. 0. 1.]

def condition_demand(df_tr, df_demand):
    flag = np.zeros(len(df_demand.columns))
    for i in range(len(df_demand.columns)):
        temp_sum = sum(df_tr[df_demand.columns[i]])
        if temp_sum >= df_demand.iloc[0][i]:
            flag[i] = 1
    return flag

- 각 수요지에 대한 조건이 충족되었는지의 여부를 0과 1로 저장하는 배열 생성(초기 값을 0으로 설정)

- 운송 비용 함수로 바로 계산 (비용 절감)

- 공급 조건 제약 조건 만족 못함

01장(웹에서 주문 수를 분석하는 테크닉), 02장(대리점 데이터를 가공하는 테크닉)

채영sw — Wed, 18 Sep 2024 18:36:22 +0900

01장. 웹에서 주문 수를 분석하는 테크닉 10

목적 : 어떤 기업 쇼핑몰 사이트의 상품 주문 수의 추세를 분석함으로써 판매량 개선의 방향을 찾는 것

전제 조건

→ 이 쇼핑몰의 주요 품목은 컴퓨터

→ 가격대별로 5개의 상품 존재

→ 4종류의 6개 데이터

데이터 정보

데이터베이스에 들어 있는 데이터를 시스템에서 가져올 때는 월별이나 1,000건 단위로 분할하는 경우가 많음

→ 데이터를 결합해 사용해야 함

<001. 데이터를 읽어 들이자>

# 경고(warning) 비표시
import warnings
warnings.filterwarnings('ignore')

import pandas as pd
customer_master = pd.read_csv('customer_master.csv')
customer_master.head()

- 파이썬 라이브러리 판다스(pandas) 임포트

- pandas의 read_csv를 사용해 프레임형 변수 customer_master에 저장

- 읽어 들인 customer_master의 처음 5행 표시

item_master = pd.read_csv('item_master.csv')
item_master.head()

transaction_1 = pd.read_csv('transaction_1.csv')
transaction_1.head()

transaction_detail_1 = pd.read_csv('transaction_detail_1.csv')
transaction_detail_1.head()

→ 데이터를 확인함으로써 어떤 데이터가 존재하고 각 데이터 간에 어떤 관계가 있는지와 같은 데이터의 큰 틀 확인 가능

먼저 데이터 전체를 파악하는 것이 중요하기 때문에 되도록 상세하게 나와 있는 쪽에 맞춰 데이터 가공

→ 이 사례의 경우, 매출과 연관이 있고, 가장 상세한 데이터는 매출 관련 데이터이므로 transaction_detail을 기준으로 생각

→ 크게 2가지의 데이터 가공이 필요

- transaction_detail_1, transaction_detail_2 / transaction_1, transaction_2 세로 결합(유니언)

- transaction_detial을 기준으로, transaction, customer_master, item_master 가로 결합(조인)

<002. 데이터를 결합(유니언)해 보자>

transaction_2 = pd.read_csv('transaction_2.csv')
transaction = pd.concat([transaction_1, transaction_2], ignore_index = True)
transaction.head()

- pd.concat으로 유니언

- head()로는 유니언이 잘 됐는지 확인 불가 → 세로 결합이므로 데이터 개수로 유니언 검증 필요

- ignore_index = Ture : 이를 무시하지 않으면 이전 데이터에 있던 index를 그대로 가져옴, 특별히 인덱스를 유지해야 하는 경우가 아니라면 옵션을 추가함 (↔ index = )

print(len(transaction_1))
print(len(transaction_2))
print(len(transaction))

transaction_detail_2 = pd.read_csv('transaction_detail_2.csv')
transaction_detail = pd.concat([transaction_detail_1, transaction_detail_2], ignore_index = True)
transaction_detail.head()

- transaction_detail도 유니언

<003. 매출 데이터끼리 결합(조인)해 보자>

기준이 되는 데이터를 결정하고 어떤 칼럼을 키로 조인할지 생각해야 함 → transaction_detail을 기준 데이터로 결정

- 부족한(추가하고 싶은) 데이터 칼럼이 무엇인가

→ transaction의 payment_date, customer_id 추가, price는 추가 x (quantity와 item_price의 곱으로 알 수 있음)

- 공통되는 데이터 칼럼은 무엇인가

→ transaction_id

join_data = pd.merge(transaction_detail, transaction[["transaction_id", "payment_date", "customer_id"]], on="transaction_id", how = "left")
join_data.head()

- pd.merge 로 조인

- transaction_detial을 기준으로

- 조인키(join key)는 결합할 transaction 데이터의 필요한 칼럼 transaction_id

- 조인 종류 : Left Join으로 지정

print(len(transaction_detail))
print(len(transaction))
print(len(join_data))

→ 세로로 데이터가 늘어나지 않고 가로로 늘어나 조인된 것을 확인할 수 있음

→ 조인할 데이터의 조인키(transaction_id)에 중복 데이터가 존재하는 경우 데이터 개수가 늘어날 수 있음

가짜 데이터 생성 - 데이터의 무결성 위반

<부록 001. 데이터 결합과 정규화>

데이터 정규화 : 데이터를 관리하는 데이터베이스 설계 개념 중 하나로, '데이터의 정합성'을 담보하는 설계 사상

→ 데이터 정규화의 진행 정도에 따라 비정규화, 제1정규화, 제2정규화, 제3정규화로 분류

제1정규화 - 도메인 원자값 조건 만족 필요

- 반복 그룹 존재하면 안됨

- 모든 행은 식별자로 완전하게 구분되어야 함

제2정규화 - 부분함수 종속 제거

- key가 아닌 값들은 모두 key에 종속되어야 함

제3정규화 - 이행적 함수 종속 제거
- 모든 non-key 컬럼은 key 컬럼에만 종속되어야 함

결합 : 데이터를 합치는 것

- 내부 결합(inner join) : 결합할 2개의 데이터에 모두 존재하는 데이터로만 구성

→ 정확하게 결합 조건을 설정하지 않으면 데이터 누락이 생길 수 있음

- 외부 결합(outer join) : 어느 한 쪽만 존재하면 데이터 결합 가능

→ 레프트 조인(결합되는 쪽의 좌측 데이터가 모두 사용됨), 라이트 조인(결합되는 쪽의 우측 데이터가 모두 사용됨) 포함

→ 데이터 1에만 있는 데이터의 데이터 2 부분에는 NULL이 들어감

<004. 마스터데이터를 결합(조인)해 보자>

- 부족한(추가하고 싶은) 데이터 칼럼이 무엇인가

→ customer_master, item_master에 포함된 데이터

- 공통되는 데이터 칼럼은 무엇인가

→ 각각 customer_id, item_id

join_data = pd.merge(join_data, customer_master, on = "customer_id", how = 'left')
join_data = pd.merge(join_data, item_master, on = "item_id", how = 'left')
join_data.head()

- 결합의 영향으로 매출(price)이 사라졌기 때문에 다시 계산해야 함

<005. 필요한 데이터 칼럼을 만들자>

매출 = quantity x item_price

join_data["price"] = join_data["quantity"] * join_data["item_price"]
join_data[["quantity", "item_price", "price"]].head()

- 판다스의 데이터프레임형 곱셈 : 행마다(가로 방향) 계산 실행

<006. 데이터를 검산하자>

검산이 가능한 데이터 칼럼을 찾고 검산하기 : 이번 사례는 price 칼럼

print(join_data["price"].sum())
print(transaction["price"].sum())

데이터 가공 전 transaction의 price 총합과 데이터 가공 후 price 총합이 같음

join_data["price"].sum() == transaction["price"].sum()

#True

True / False로도 확인 가능

<007. 각종 통계량을 파악하자>

데이터 분석을 진행할 때는 크게 두 가지를 파악해야 함

- 결손치의 개수 : 제거하거나 보간해야 함

- 전체를 파악할 수 있는 숫자감 : 이번 달 상품 A의 매출이 10만원 → 전체 매출 단위 10억/100만원인지로 의미 달라짐

join_data.isnull().sum()

- 결손치의 개수 출력

- isnull()은 결손치가 True/False로 반환되기 때문에 True의 개수를 칼럼마다 sum()으로 계산

- 결손치 없음

join_data.describe()

- describe()를 이용해 데이터 개수(count), 평균값(mean), 표준편차(std), 최솟값(min), 사분위수(25%, 75%), 중앙값(50%), 최댓값(max) 각종 통계량 출력 가능

- describe()는 숫자 데이터를 집계함

print(join_data["payment_date"].min())
print(join_data["payment_date"].max())

- 데이터의 기간 파악 가능

<008. 월별로 데이터를 집계해 보자>

시계열 상황 살펴보기

- 이번 케이스처럼 반년 정도의 데이터라면 별로 영향이 없겠지만, 과거 수년의 데이터에는 여러가지 비즈니스 모델이 포함되어 있을 수 있기 때문에 전체 데이터를 한 번에 분석하면 데이터의 시계열 변화를 잘못 파악하는 경우가 있을 수 있음

→ 데이터 범위를 좁혀 분석하는 것도 하나의 방법!

전체적으로 매출 변화를 파악해보기

- 구입일 payment_date에서 연월을 추출해 새롭게 칼럼을 작성하고, 연월 단위로 price 집계해서 표시

join_data.dtypes

- 데이터타입 확인

- payment_date는 object형

join_data["payment_date"] = pd.to_datetime(join_data["payment_date"])
join_data["payment_month"] = join_data["payment_date"].dt.strftime("%Y%m")
join_data[["payment_date", "payment_month"]].head()

- datetime형으로 데이터 타입 변환 (to_datetime)

- 새로운 칼럼 payment_month를 연월 단위로 작성

→ 판다스의 datetime의 dt를 사용하면 년, 월 추출 가능

→ strftime을 사용해 연월 작성

- datetime object에 dt 접근자를 사용해 datetime 속성이나 메서드를 사용해 시계열 데이터를 처리할 수 있음

- dt.strftime() : pandas의 datetime object를 지정된 date format으로 변환

from datetime import datetime 

# 현재 날짜 
now = datetime.now() 

# 특정 형식의 문자열로 변환 
formatted_date = now.strftime('%d-%m-%Y %H:%M:%S') 

print(formatted_date)

#result = sr.dt.strftime('% d % m % Y, % r')

%Y : 연도 0001~9999

%m : 달 01~12

%d : 날짜 01~31

%H : 24시간 형식의 하루의 시간 00~23

%I : 12시간 형식의 하루의 시간 01~12

%M : 분 00~59

%S : 초 00~59

join_data.groupby("payment_month").sum()["price"]

- 월별 매출 집계

- groupby : 집계하고 싶은 칼럼(payment_month)과 집계 방법(sum) 기술, price만 표시하기 위해 price 칼럼 지정

→ 5월 매출이 조금 내려갔지만, 6월, 7월 회복, 가장 매출이 높은 달은 7월 등의 정보를 알 수 있음

데이터프레임.groupby(그룹이되는컬럼)[계산하고 싶은 컬럼].집계함수()

                            or

데이터프레임.groupby(그룹이되는컬럼).집계함수()[계산하고 싶은 컬럼]

<집계함수(집계 방법) 종류>

- mean(평균), median(중위수)

- count(개수), sum(합산)

- min(최소), max(최대)

- std(표준편차), var(분산), quantile(특정 백분위)

(ex. df.groupby("월")["야근"].quantile(0.9) ← 월별 상위 10% 야근일수)

- describe(전반적인 지표)

< multiple column / groupby >

데이터프레임.groupby([컬럼1,컬럼2]).agg({계산하고싶은컬럼명1 : 집계함수 , 계산하고싶은컬럼명2 : 집계함수})

ex. 월별 인당 휴일 평균과 야근 총합

df.groupby(["월","이름"]).agg({"휴일":"mean","야근":"sum"})

< reset_index로 index 초기화해서 데이터 활용하기 >

g1_df["이름"]   #컬럼명 자체가 인덱스로 들어가 있기 때문에 오류 발생

g2_df = df.groupby(["월", "이름"]).agg({"휴일":"mean", "야근":"sum"}).reset_index()
g2_df

<009. 월별, 상품별로 데이터를 집계해 보자>

월별, 상품별로 매출의 합계, 수량 표시

join_data.groupby(["payment_month", "item_name"]).sum()[["price", "quantity"]]

- 월별, 상품별로 price와 quantity의 집계 결과 표시

- groupby에서 출력하고 싶은 칼럼이 여러 개 있을 경우, 리스트형으로 지정

pd.pivot_table(join_data, index='item_name', columns='payment_month', values=['price', 'quantity'], aggfunc='sum')

- pivot_table로 행과 칼럼 지정 가능

- 행에는 상품명, 칼럼에는 월이 오도록 index와 columns로 지정

- values에는 집계하고 싶은 칼럼(price, quantity) 지정

- aggfunc에는 집계 방법(sum) 지정

- 월별, 상품별로 추세 파악하기 쉬움

→ 매출 합계는 PC-E가 가장 높지만, 수량에서는 가장 싼 PC-A가 많음, 5월 매출 감소의 원인은 PC-E의 영향이 큼

pandas.pivot_table(data, values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, dropna=True, margins_name='All', observed=_NoDefault.no_default, sort=True)

- fill_value : 집계 후, 결과 피벗 테이블에서 누락된 값을 바꿀 값

- margins = True : 행과 열의 범주에 부분 그룹 집계가 적용되어 특수 열과 행 추가(여백)

- dropna = True : 모든 열에 NaN 값이 있는 행은 마진 계산 전 생략

- sort : 결과 정렬 여부 지정

<010. 상품별 매출 추이를 가시화해 보자>

월별, 상품별 매출 추이 그래프로 표현

- 데이터 집계

- 집계된 데이터를 이용해 그래프 그리기

graph_data = pd.pivot_table(join_data, index='payment_month', columns='item_name', values='price', aggfunc='sum')
graph_data.head()

- pivot_table를 이용해 데이터 집계

- 그래프를 그리기 위해 가로축에 payment_month, 세로축에 graph_data의 해당 상품명 지정

import matplotlib.pyplot as plt  # from matplotlib import pyplot as plt
%matplotlib inline
plt.plot(list(graph_data.index), graph_data["PC-A"], label='PC-A')
plt.plot(list(graph_data.index), graph_data["PC-B"], label='PC-B')
plt.plot(list(graph_data.index), graph_data["PC-C"], label='PC-C')
plt.plot(list(graph_data.index), graph_data["PC-D"], label='PC-D')
plt.plot(list(graph_data.index), graph_data["PC-E"], label='PC-E')
plt.legend()

- matplotlib 임포트

→ 가로축, 세로축 순서로 지정

→ 가로축은 payment_month를 표시해야 하므로 graph_data.index를 리스트형으로 변환하여 지정

→ 세로축은 상품별 매출로 graph_data 칼럼을 지정

→ label로 범례 표시

- 상품마다 그래프를 그리고, legend()는 범례 표시

- %matplotlib inline : notebook을 실행한 브라우저에서 바로 그림을 볼 수 있도록 브라우저 내부에 그려지도록 함

→ 도표, 그래프, 그림, 소리, 애니메이션 등과 같은 산출물(Rich output)을 표현하는 방법 중 하나

- plt.legend() : 그래프에 범례 추가 (plot 함수 안에 입력한 label이 사용)

→ plt.legend(('Y1', 'Y2')) 와 같이 legend 함수 안에 label 직접 입력 가능

02장. 대리점 데이터를 가공하는 테크닉 10

전제조건

→ 상품 A~Z까지 26개의 상품 취급

→ 매출 이력과 고객정보 데이터는 담당사원이 시스템에 직접 입력 : '지저분한 데이터'

데이터 정보

<011. 데이터를 읽어 들이자>

import pandas as pd
uriage_data = pd.read_csv("uriage.csv")
uriage_data.head()

매출 이력

- item_name, item_price에 결측치/오류 확인 가능

kokyaku_data = pd.read_excel("kokyaku_daicho.xlsx")
kokyaku_data.head()

고객 정보

→ 데이터의 정합성에 문제가 있음 : 입력 오류나 표기 방법의 차이가 부정합을 일으킴

ex) 날짜 포맷 차이, 공백 유무

→ 정합성을 갖추기 위해 데이터의 속성과 의미를 이해하고 데이터의 오류를 파악해야 함

<012. 데이터의 오류를 살펴보자>

- 매출 이력에서 item_name을 추출해 데이터 오류 확인

uriage_data["item_name"].head()

- 공백, 대소문자 섞여있음

uriage_data["item_price"].head()

- 결측치 NaN 확인 가능

<013. 데이터에 오류가 있는 상태로 집계해 보자>

데이터 정합성의 중요성 파악

- 매출 이력 데이터에서 상품별로 월 매출 합계 집계

uriage_data["purchase_date"] = pd.to_datetime(uriage_data["purchase_date"])
uriage_data["purchase_month"] = uriage_data["purchase_date"].dt.strftime("%Y%m")
res = uriage_data.pivot_table(index = "purchase_month", columns = "item_name", aggfunc = "size", fill_value = 0)
res

- 날짜를 연월 형태로 반환

- pivot_table로 행(구입 연월)와 칼럼(삼품 이름) 지정

→ 상품의 건수로 집계

- aggfunc로 집계 방법(size) 지정

- fill_value = 0 : 집계 후, 결과 피벗 테이블에서 누락된 값을 바꿀 값을 0으로 설정

- 동일한 상품이 다른 상품으로 집계됨, 26개의 상품이 99개의 상품으로 늘어남

res = uriage_data.pivot_table(index = "purchase_month", columns = "item_name", values = "item_price", aggfunc = "sum", fill_value = 0)
res

- values로 집계하고 싶은 칼럼(item_price)을 지정해서 집계

→ 데이터 가공 없이 집계 및 분석을 실시하면 의미 없는 결과가 나옴!

<014. 상품명 오류를 수정하자>

- 공백 오류 수정하기

print(len(pd.unique(uriage_data.item_name)))

→ 26개의 상품이 99개로 늘어나 있음

- len + pd.unique로 매출 이력의 item_name의 중복을 제외한 데이터 건수 확인 가능

print(uriage_data["item_name"].nunique())

- len + pd.unique를 nunique로 대체 가능

- 데이터 오류 수정하기

uriage_data["item_name"] = uriage_data["item_name"].str.upper()
uriage_data["item_name"] = uriage_data["item_name"].str.replace("  ", "")
uriage_data["item_name"] = uriage_data["item_name"].str.replace(" ", "")
uriage_data.sort_values(by = ["item_name"], ascending = True)

- str.upper()로 소문자를 대문자로 변환

- str.replace()로 공백 제거

- item_name을 기준으로 정렬해 화면에 표시

<문자열 내장 함수>

문자열.replace(기존 값, 변경할 값, 변경횟수)

문자열.upper() : 소문자를 대문자로 변환

문자열.lower() : 대문자를 소문자로 변환

print(len(pd.unique(uriage_data["item_name"])))
print(pd.unique(uriage_data["item_name"]))

<015. 금액의 결측치를 수정하자>

상품 단가가 집계 중에 변하지 않았기 때문에 프로그램으로 결측치 수정 가능

- 결측치 확인하기

uriage_data.isnull().any(axis = 0)

- isnull() 을 이용해 매출 이력 데이터의 결측치 유무 확인 가능

- item_price에 결측치가 있음을 확인할 수 있음

- 데이터프레임.isnull() : 데이터프레임에서 결측치가 있는지 확인

→ 결측치 있으면 True, 없으면 False로 표시

- any() : True가 하나라도 존재하는지 확인하는 함수

axis = 0 : 열(column)단위로 연산 → 각 열을 기준으로, 해당 열에 하나라도 결측치가 있으면 True, 그렇지 않으면 False 반환하므로 이를 통해 열별로 결측값이 존재하는지 여부 확인 가능

axis=1 : 행(row) 단위로 연산 → 각 행을 기준으로 계산

- all() : 모든 값이 True일 때만 True 반환

- 결측치 수정하기

→ 집계 기간에 상품 단가의 변동이 없다는 전제조건이 있으므로, 같은 상품의 단가를 이용해 수정 가능

flg_is_null = uriage_data["item_price"].isnull()
for trg in list(uriage_data.loc[flg_is_null, "item_name"].unique()):
    price = uriage_data.loc[(~flg_is_null) & (uriage_data["item_name"] == trg), "item_price"].max()
    uriage_data["item_price"].loc[(flg_is_null) & (uriage_data["item_name"] == trg)] = price
uriage_data.head()

- item_price 중에 결측치 있는 곳 조사하여 flg_is_null 변수에 저장 (True, False로 저장)

- list(uriage_data.loc[flg_is_null, "item_name"].unique()) : flg_is_null을 이용해 결측치가 있는 상품명 리스트 작성

→ list() : 변수의 값을 리스트 형식으로 변환

→ loc 함수 : 조건이 일치하는 데이터 추출

- '금액에 결측치가 있다'를 조건으로 하기 위해 flg_is_null로 조건 지정 (flg_is_null이 True 인 행)

- 조건과 일치하는 데이터 중에서 어떤 칼럼(item_name)을 가져올지 지정 가능

→ 결측치가 존재하는 상품명 추출

- unique() : 추출한 상품명에서 중복을 제거하여 고유한 상품명 리스트 제작

- price = uriage_data.loc[(~flg_is_null) & (uriage_data["item_name"] == trg), "item_price"].max()

→ 결측치가 있는 상품과 같은 상품이며 금액이 올바르게 입력된 행을 loc으로 찾고, 그 금액을 가져옴

- loc()의 조건 : 부정 연산자 ~을 이용 ( flg_is_null == False )

- 현재 상품의 결측치가 없는 item_price 값 중에서 최대값을 찾아 결측치를 채우기 위해 price에 저장

- uriage_data["item_price"].loc[(flg_is_null) & (uriage_data["item_name"] == trg)] = price

→ 가져온 금액으로 데이터 수정

- 매출 이력의 item_price 칼럼에서 loc()으로 결측치가 있는 데이터 추출 후, 금액 데이터 price로 대체

→ 결측치가 있는 상품명에 대해 위에서 찾은 최대 가격을 해당 상품의 결측치에 할당

- 검증하기

uriage_data.isnull().any(axis = 0)

- item_price 의 결측치가 없어진 것을 확인 가능

for trg in list(uriage_data["item_name"].sort_values().unique()):
    print(trg + "의최고가：" + str(uriage_data.loc[uriage_data["item_name"]==trg]["item_price"].max()) 
          + "의최저가：" + str(uriage_data.loc[uriage_data["item_name"]==trg]["item_price"].min(skipna=False)))

- 모든 상품에 대해 반복문 처리

- 모든 상품의 최대금액과 최소금액이 일치하는 것으로 봐서 성공적으로 금액을 수정했다는 것을 알 수 있음

→ skipna : NaN의 무시 여부 설정 가능 , False로 지정하여 NaN이 존재할 경우 최솟값이 NaN으로 표시되도록 함

<016. 고객 이름의 오류를 수정하자>

- 데이터 확인하기

kokyaku_data["고객이름"].head()

uriage_data["customer_name"].head()

- 두 데이터 서식이 일치하지 않으므로 결합 불가능

kokyaku_data["고객이름"] = kokyaku_data["고객이름"].str.replace("  ", "")
kokyaku_data["고객이름"] = kokyaku_data["고객이름"].str.replace(" ", "")
kokyaku_data["고객이름"].head()

- str.replace()로 고객 정보의 고객 이름에서 공백 제거

f. 같은 이름의 데이터가 존재하는 경우 등록일, 생년월일 등 다른 정보를 이용해서 구분해야 함

<017. 날짜 오류를 수정하자>

- 고객 등록일 오류 수정하기

고객 정보

엑셀 데이터로, 서식이 다른 데이터가 섞여 있을 수 있으니 주의 필요

- 날짜 동일한 포맷으로 통일하기

flg_is_serial = kokyaku_data["등록일"].astype("str").str.isdigit()
flg_is_serial.sum()

- str.isdigit() : 고객 정보의 등록일이 숫자인지 아닌지 판정

→ 숫자로 된 곳을 flg_is_serial에 저장

.astype("str") : 열의 값을 모두 문자열로 변환

→ 날짜 데이터의 경우 문자열로 변환하고, 결측치(NaN)은 "nan"이라는 문자열로 변환

str.isdigit() : 각 문자열이 숫자로만 이루어졌는지 확인하는 함수

→ 문자열의 모든 문자가 숫자(0~9)로만 이루어졌다면 True를, 그렇지 않다면 False를 반환

→ 공백, 기호, 날짜형식(ex. 2022-08-15), 결측치(NaN) 등은 Flase

fromSerial = pd.to_timedelta(kokyaku_data.loc[flg_is_serial, "등록일"].astype("float"), unit="D") + pd.to_datetime("1900/01/01")
fromSerial

엑셀에서 사용하는 시리얼 날짜 형식을 변환하여 Pandas에서 처리하는 과정

(엑셀에서 날짜는 1900년 1월 1일부터의 경과일수를 숫자로 기록하는 방식으로 표현하므로, 이 시리얼 넘버를 실제 날짜로 변환해야 함)

→ loc() : flg_is_serial이 True인 행의 "등록일" 값 추출 ( 숫자로만 이루어진 시리얼 날짜 값 선택)

- .astype("float") : 추출한 "등록일" 값을 실수형으로 변환

→ 엑셀 시리얼 날짜 값은 거의 정수로 표현되지만, 소수점을 포함하여 시간을 나타낼 수 있기에 실수형으로 변환하는 것이 적합 (ex. 2.5 = 1900년 1월 2일 오후 12시)

- pd.to_timedelta() 함수 : 시간의 차이를 표현하는 함수

→ unit ="D" : 일(Day) 단위로 계산한다는 의미

→ 일 단위로 숫자를 날짜로 변환

- pd.to_datetime("1900/01/01") : 1900/01/01 을 1로 기준 날짜 설정

→ 시리얼 넘버로 계산된 시간 차이에 '+' 로 더함으로써 실제 날짜 계산

<이틀이 어긋난 이유>

fromSerial = pd.to_timedelta(kokyaku_data.loc[flg_is_serial, "등록일"].astype("float") - 2, unit="D") + pd.to_datetime("1900/01/01")
fromSerial

- 엑셀 숫잣값에서 2를 빼서 처리

fromString = pd.to_datetime(kokyaku_data.loc[~flg_is_serial, "등록일"])
fromString

- 날짜로 변환된 데이터도 서식 통일

- 2018/01/04와 같이 슬래시로 구분된 서식을 하이픈으로 구분된 서식으로 통일하기 위한 처리 과정

- ~flg_is_serial : 부정 연산자 ~로 Flase인 것을 loc()함수의 조건으로 설정

→ 숫자가 아닌 값들로 이루어진 데이터도 pd.to_datetime을 이용해 날짜 형식으로 변환

kokyaku_data["등록일"] = pd.concat([fromSerial, fromString])
kokyaku_data

- 숫자를 날짜로 수정한 데이터(fromSerial)와 서식을 변경한 데이터(fromString)를 결합해서 데이터 갱신

kokyaku_data["등록연월"] = kokyaku_data["등록일"].dt.strftime("%Y%m")
rslt = kokyaku_data.groupby("등록연월").count()["고객이름"]
print(rslt)
print(len(kokyaku_data))

- 수정한 날짜에서 strftime을 이용해 등록연월을 작성하고 groupby()로 집계

데이터프레임.groupby(그룹이되는컬럼).집계함수()[계산하고 싶은 컬럼]

→ groupby 후, count()로 데이터 개수 집계

flg_is_serial = kokyaku_data["등록일"].astype("str").str.isdigit()
flg_is_serial.sum()

- 등록일 칼럼에 숫자 데이터가 남아 있는지 다시 확인해보면 모든 숫자 데이터가 날짜로 잘 수정되었다는 것을 알 수 있음!

<018. 고객 이름을 키로 두 개의 데이터를 결합(조인)하자>

join_data = pd.merge(uriage_data, kokyaku_data, left_on="customer_name", right_on="고객이름", how="left")
join_data = join_data.drop("customer_name", axis=1)
join_data

- pd.merge() : 두 개의 데이터의 서로 다른 열을 지정하여 결합

- left_on 의 인수로 uriage_data의 customer_name 칼럼을 키로, right_on의 인수로 kokyaku_data의 고객 이름 칼럼을 키로 지정

- how로 결합 방법을 left로 지정 ( uriage_data을 기준으로 일치하는 kokyaku_data를 결합 )

- join_data.drop("customer_name", axis=1)

→ "고객 이름"과 중복되는 customer_name 열 제거

데이터 정제 완료!

<019. 정제한 데이터를 덤프하자>

정제한 데이터를 파일로 출력(덤프)해두고, 분석할 때 위 파일을 읽어 들이는 형식으로 데이터 분석 진행

- 먼저 칼럼의 배치를 다루기 쉽게 조정하기

dump_data = join_data[["purchase_date", "purchase_month", "item_name", "item_price", "고객이름", "지역", "등록일"]]
dump_data

- join_data에서 필요한 칼럼을 임의의 순서로 정렬 후, dump_data에 저장

dump_data.to_csv("dump_data.csv", index=False)

- to_csv를 이용해 파일로 출력

<020. 데이터를 집계하자>

import_data = pd.read_csv("dump_data.csv")
import_data

- 덤프 데이터 불러오기

byItem = import_data.pivot_table(index="purchase_month", columns="item_name", aggfunc="size", fill_value=0)
byItem

- purchase_month를 세로축으로 상품별로 집계

byPrice = import_data.pivot_table(index="purchase_month", columns="item_name", values="item_price", aggfunc="sum", fill_value=0)
byPrice

- purchase_month를 세로축으로 매출금액별로 집계

byCustomer = import_data.pivot_table(index="purchase_month", columns="고객이름", aggfunc="size", fill_value=0)
byCustomer

- purchase_month를 세로축으로 고객별로 집계

byRegion = import_data.pivot_table(index="purchase_month", columns="지역", aggfunc="size", fill_value=0)
byRegion

- purchase_month를 세로축으로 지역별로 집계

away_data = pd.merge(uriage_data, kokyaku_data, left_on="customer_name", right_on="고객이름", how="right")
away_data[away_data["purchase_date"].isnull()][["고객이름", "등록일"]]

- 집계 기간에 구매 이력이 없는 사용자 확인

- right join으로 결합

→ 집계 기간 내에 구매하지 않은 고객은 NaN으로 채워짐