빅 데이터 분석-퀵 가이드

처리해야하는 데이터의 양은 지난 10 년 동안 상상할 수없는 수준으로 폭발적으로 증가했으며 동시에 데이터 스토리지 가격도 체계적으로 하락했습니다. 민간 기업과 연구 기관은 사용자의 상호 작용, 비즈니스, 소셜 미디어 및 휴대 전화 및 자동차와 같은 장치의 센서에 대한 테라 바이트의 데이터를 캡처합니다. 이 시대의 과제는 데이터의 바다를 이해하는 것입니다. 여기가big data analytics 그림이 나타납니다.

빅 데이터 분석은 주로 다양한 소스에서 데이터를 수집하고 분석가가 사용할 수있는 방식으로 데이터를 뭉개고 마지막으로 조직 비즈니스에 유용한 데이터 제품을 제공하는 것을 포함합니다.

다양한 소스에서 검색된 대량의 비정형 원시 데이터를 조직에 유용한 데이터 제품으로 변환하는 프로세스가 빅 데이터 분석의 핵심을 형성합니다.

기존 데이터 마이닝 수명주기

조직에 필요한 작업을 구성하고 빅 데이터에서 명확한 통찰력을 제공하는 프레임 워크를 제공하려면 여러 단계의 주기로 생각하는 것이 유용합니다. 결코 선형이 아니며 모든 단계가 서로 관련되어 있음을 의미합니다. 이주기는 다음에 설명 된보다 전통적인 데이터 마이닝주기와 표면적으로 유사합니다.CRISP methodology.

CRISP-DM 방법론

그만큼 CRISP-DM methodology데이터 마이닝을위한 산업 간 표준 프로세스의 약자로, 데이터 마이닝 전문가가 기존 BI 데이터 마이닝의 문제를 해결하기 위해 사용하는 일반적으로 사용되는 접근 방식을 설명하는주기입니다. 기존 BI 데이터 마이닝 팀에서 여전히 사용되고 있습니다.

다음 그림을 살펴보십시오. CRISP-DM 방법론에 의해 설명 된주기의 주요 단계와 이들이 상호 연관되는 방식을 보여줍니다.

CRISP-DM은 1996 년에 구상되었고 내년에는 ESPRIT 자금 조달 이니셔티브에 따라 유럽 연합 프로젝트로 진행되었습니다. 이 프로젝트는 SPSS, Teradata, Daimler AG, NCR Corporation 및 OHRA (보험 회사)의 5 개 회사가 주도했습니다. 이 프로젝트는 마침내 SPSS에 통합되었습니다. 방법론은 데이터 마이닝 프로젝트를 지정하는 방법에 대해 매우 자세하게 설명되어 있습니다.

이제 CRISP-DM 라이프 사이클에 관련된 각 단계에 대해 조금 더 알아 보겠습니다.

  • Business Understanding−이 초기 단계는 비즈니스 관점에서 프로젝트 목표 및 요구 사항을 이해 한 다음이 지식을 데이터 마이닝 문제 정의로 변환하는 데 중점을 둡니다. 목표를 달성하기 위해 예비 계획이 설계되었습니다. 의사 결정 모델, 특히 Decision Model 및 Notation 표준을 사용하여 구축 된 모델을 사용할 수 있습니다.

  • Data Understanding − 데이터 이해 단계는 초기 데이터 수집으로 시작하여 데이터에 익숙해 지거나, 데이터 품질 문제를 식별하고, 데이터에 대한 첫 번째 통찰력을 발견하거나, 숨겨진 정보에 대한 가설을 형성하기 위해 흥미로운 하위 집합을 감지하기위한 활동으로 진행됩니다.

  • Data Preparation− 데이터 준비 단계는 초기 원시 데이터에서 최종 데이터 세트 (모델링 도구에 공급 될 데이터)를 구성하는 모든 활동을 다룹니다. 데이터 준비 작업은 정해진 순서가 아닌 여러 번 수행 될 수 있습니다. 작업에는 테이블, 레코드 및 속성 선택과 모델링 도구를위한 데이터 변환 및 정리가 포함됩니다.

  • Modeling−이 단계에서는 다양한 모델링 기법을 선택하여 적용하고 해당 매개 변수를 최적의 값으로 보정합니다. 일반적으로 동일한 데이터 마이닝 문제 유형에 대한 몇 가지 기술이 있습니다. 일부 기술에는 데이터 형식에 대한 특정 요구 사항이 있습니다. 따라서 종종 데이터 준비 단계로 돌아 가야합니다.

  • Evaluation− 프로젝트의이 단계에서 데이터 분석 관점에서 고품질로 보이는 모델 (또는 모델)을 구축했습니다. 모델의 최종 배포를 진행하기 전에 모델을 철저히 평가하고 모델을 구성하기 위해 실행 된 단계를 검토하여 비즈니스 목표를 제대로 달성하는지 확인하는 것이 중요합니다.

    핵심 목표는 충분히 고려되지 않은 중요한 비즈니스 문제가 있는지 확인하는 것입니다. 이 단계가 끝나면 데이터 마이닝 결과 사용에 대한 결정이 내려져야합니다.

  • Deployment− 모델 생성은 일반적으로 프로젝트의 끝이 아닙니다. 모델의 목적이 데이터에 대한 지식을 늘리는 것이더라도 얻은 지식은 고객에게 유용한 방식으로 구성되고 제시되어야합니다.

    요구 사항에 따라 배포 단계는 보고서를 생성하는 것처럼 간단하거나 반복 가능한 데이터 점수 (예 : 세그먼트 할당) 또는 데이터 마이닝 프로세스를 구현하는 것처럼 복잡 할 수 있습니다.

대부분의 경우 배포 단계를 수행하는 것은 데이터 분석가가 아닌 고객입니다. 분석가가 모델을 배포하더라도 고객은 생성 된 모델을 실제로 사용하기 위해 수행해야하는 작업을 미리 이해하는 것이 중요합니다.

SEMMA 방법론

SEMMA는 데이터 마이닝 모델링을 위해 SAS에서 개발 한 또 다른 방법입니다. 그것은S앰플, Explore, Modify, Model 및 Asses. 다음은 단계에 대한 간략한 설명입니다.

  • Sample−이 프로세스는 데이터 샘플링으로 시작됩니다 (예 : 모델링을위한 데이터 세트 선택). 데이터 세트는 검색하기에 충분한 정보를 포함 할 수있을만큼 커야하지만 효율적으로 사용할 수있을만큼 작아야합니다. 이 단계에서는 데이터 파티셔닝도 다룹니다.

  • Explore −이 단계에서는 데이터 시각화를 통해 변수 간의 예상 및 예상치 못한 관계와 비정상을 발견하여 데이터에 대한 이해를 다룹니다.

  • Modify − 수정 단계에는 데이터 모델링을 준비하기 위해 변수를 선택, 생성 및 변환하는 방법이 포함되어 있습니다.

  • Model − 모델 단계에서는 원하는 결과를 제공 할 수있는 모델을 생성하기 위해 준비된 변수에 다양한 모델링 (데이터 마이닝) 기술을 적용하는 데 중점을 둡니다.

  • Assess − 모델링 결과 평가는 생성 된 모델의 신뢰성과 유용성을 보여줍니다.

CRISM-DM과 SEMMA의 주요 차이점은 SEMMA는 모델링 측면에 초점을 맞추는 반면 CRISP-DM은 해결해야 할 비즈니스 문제를 이해하고 데이터를 이해하고 사전 처리하는 등 모델링 전주기 단계에 더 중요합니다. 입력으로 사용됩니다 (예 : 기계 학습 알고리즘).

빅 데이터 수명주기

오늘날의 빅 데이터 컨텍스트에서 이전 접근 방식은 불완전하거나 차선책입니다. 예를 들어, SEMMA 방법론은 서로 다른 데이터 소스의 데이터 수집 및 전처리를 완전히 무시합니다. 이러한 단계는 일반적으로 성공적인 빅 데이터 프로젝트에서 대부분의 작업을 구성합니다.

빅 데이터 분석주기는 다음 단계로 설명 할 수 있습니다.

  • 비즈니스 문제 정의
  • Research
  • 인적 자원 평가
  • 데이터 취득
  • 데이터 결합
  • 데이터 저장고
  • 탐색 적 데이터 분석
  • 모델링 및 평가를위한 데이터 준비
  • Modeling
  • Implementation

이 섹션에서는 빅 데이터 수명주기의 각 단계에 대해 간략하게 설명합니다.

비즈니스 문제 정의

이는 기존 BI 및 빅 데이터 분석 수명주기에서 공통적 인 점입니다. 일반적으로 문제를 정의하고 조직이 얻을 수있는 잠재적 이득이 얼마나되는지 정확하게 평가하는 것은 빅 데이터 프로젝트의 중요한 단계입니다. 이것을 언급하는 것은 분명해 보이지만 프로젝트의 예상 이익과 비용이 무엇인지 평가해야합니다.

연구

같은 상황에서 다른 회사가 한 일을 분석하십시오. 여기에는 회사가 보유한 리소스 및 요구 사항에 다른 솔루션을 적용하는 것이 포함되지만 회사에 적합한 솔루션을 찾는 것이 포함됩니다. 이 단계에서는 향후 단계에 대한 방법론이 정의되어야합니다.

인적 자원 평가

문제가 정의되면 현재 직원이 프로젝트를 성공적으로 완료 할 수 있는지 계속 분석하는 것이 합리적입니다. 기존 BI 팀은 모든 단계에 최적의 솔루션을 제공하지 못할 수 있으므로 프로젝트의 일부를 아웃소싱하거나 더 많은 인력을 고용해야하는 경우 프로젝트를 시작하기 전에 고려해야합니다.

데이터 취득

이 섹션은 빅 데이터 수명주기의 핵심입니다. 결과 데이터 제품을 제공하는 데 필요한 프로필 유형을 정의합니다. 데이터 수집은 프로세스의 중요한 단계입니다. 일반적으로 다른 소스에서 구조화되지 않은 데이터를 수집합니다. 예를 들어, 웹 사이트에서 리뷰를 검색하는 크롤러를 작성하는 것이 포함될 수 있습니다. 여기에는 일반적으로 완료하는 데 상당한 시간이 필요한 다른 언어로 된 텍스트 처리가 포함됩니다.

데이터 결합

예를 들어 웹에서 데이터를 검색 한 후에는 사용하기 쉬운 형식으로 저장해야합니다. 리뷰 예제를 계속 진행하기 위해 각기 다른 데이터 표시가있는 다른 사이트에서 데이터를 검색한다고 가정 해 보겠습니다.

하나의 데이터 소스가 별점 평가 측면에서 리뷰를 제공한다고 가정하면이를 반응 변수에 대한 매핑으로 읽을 수 있습니다. y ∈ {1, 2, 3, 4, 5}. 또 다른 데이터 소스는 두 개의 화살표 시스템을 사용하여 리뷰를 제공합니다. 하나는 업 투표 용이고 다른 하나는 다운 투표 용입니다. 이것은 다음 형식의 응답 변수를 의미합니다.y ∈ {positive, negative}.

두 데이터 소스를 결합하려면이 두 응답 표현을 동등하게 만들기 위해 결정을 내려야합니다. 여기에는 첫 번째 데이터 소스 응답 표현을 두 번째 형식으로 변환하는 것이 포함될 수 있으며, 별 하나는 음수로, 별 다섯 개는 양수로 간주합니다. 이 프로세스는 종종 좋은 품질로 제공되기 위해 많은 시간을 할당해야합니다.

데이터 저장고

데이터가 처리되면 때때로 데이터베이스에 저장해야합니다. 빅 데이터 기술은이 점과 관련하여 많은 대안을 제공합니다. 가장 일반적인 대안은 사용자에게 HIVE 쿼리 언어로 알려진 제한된 버전의 SQL을 제공하는 스토리지 용 Hadoop 파일 시스템을 사용하는 것입니다. 이를 통해 대부분의 분석 작업을 사용자 관점에서 기존 BI 데이터웨어 하우스에서 수행하는 것과 유사한 방식으로 수행 할 수 있습니다. 고려해야 할 다른 스토리지 옵션은 MongoDB, Redis 및 SPARK입니다.

주기의이 단계는 다른 아키텍처를 구현하는 능력 측면에서 인적 자원 지식과 관련이 있습니다. 기존 데이터웨어 하우스의 수정 된 버전은 여전히 ​​대규모 애플리케이션에서 사용되고 있습니다. 예를 들어, teradata와 IBM은 테라 바이트의 데이터를 처리 할 수있는 SQL 데이터베이스를 제공합니다. postgreSQL 및 MySQL과 같은 오픈 소스 솔루션은 여전히 ​​대규모 애플리케이션에 사용되고 있습니다.

백그라운드에서 서로 다른 스토리지가 작동하는 방식에는 차이가 있지만 클라이언트 측에서는 대부분의 솔루션이 SQL API를 제공합니다. 따라서 SQL을 잘 이해하는 것은 여전히 ​​빅 데이터 분석을위한 핵심 기술입니다.

이 단계는 선험적으로 가장 중요한 주제 것처럼 보이지만 실제로는 사실이 아닙니다. 필수 단계도 아닙니다. 실시간 데이터로 작업 할 수있는 빅 데이터 솔루션을 구현할 수 있으므로이 경우 모델을 개발하기 위해 데이터를 수집 한 다음 실시간으로 구현하기 만하면됩니다. 따라서 데이터를 공식적으로 저장할 필요가 전혀 없습니다.

탐색 적 데이터 분석

인사이트를 검색 할 수있는 방식으로 데이터를 정리하고 저장 한 후에는 데이터 탐색 단계가 필수입니다. 이 단계의 목적은 데이터를 이해하는 것입니다. 일반적으로 통계 기법을 사용하고 데이터를 플로팅합니다. 이것은 문제 정의가 타당하거나 실행 가능한지 평가하기에 좋은 단계입니다.

모델링 및 평가를위한 데이터 준비

이 단계에는 이전에 검색된 정리 된 데이터를 재구성하고 결 측값 대치, 이상 값 감지, 정규화, 특징 추출 및 특징 선택을위한 통계적 전처리를 사용하는 것이 포함됩니다.

모델링

이전 단계에서는 학습 및 테스트를위한 여러 데이터 세트 (예 : 예측 모델)를 생성해야합니다. 이 단계에서는 다양한 모델을 시도하고 당면한 비즈니스 문제를 해결하기를 기대합니다. 실제로 모델이 비즈니스에 대한 통찰력을 제공하는 것이 일반적으로 바람직합니다. 마지막으로, 남은 데이터 세트에 대한 성능을 평가하여 최상의 모델 또는 모델 조합을 선택합니다.

이행

이 단계에서 개발 된 데이터 제품은 회사의 데이터 파이프 라인에서 구현됩니다. 여기에는 성능을 추적하기 위해 데이터 제품이 작동하는 동안 유효성 검사 체계를 설정하는 것이 포함됩니다. 예를 들어, 예측 모델을 구현하는 경우이 단계에서는 모델을 새 데이터에 적용하고 응답을 사용할 수있게되면 모델을 평가합니다.

방법론 측면에서 빅 데이터 분석은 실험 설계의 기존 통계 접근 방식과 크게 다릅니다. 분석은 데이터에서 시작됩니다. 일반적으로 우리는 응답을 설명하는 방식으로 데이터를 모델링합니다. 이 접근 방식의 목표는 응답 동작을 예측하거나 입력 변수가 응답과 어떻게 관련되는지 이해하는 것입니다. 일반적으로 통계 실험 설계에서는 실험이 개발되고 그 결과 데이터가 검색됩니다. 이를 통해 독립성, 정규성 및 무작위 화와 같은 특정 가정이 유지되는 통계 모델에서 사용할 수있는 방식으로 데이터를 생성 할 수 있습니다.

빅 데이터 분석에서는 데이터가 제공됩니다. 우리가 가장 좋아하는 통계 모델을 충족하는 실험을 설계 할 수 없습니다. 대규모 분석 애플리케이션에서는 데이터를 정리하기 위해 많은 작업 (일반적으로 작업의 80 %)이 필요하므로 머신 러닝 모델에서 사용할 수 있습니다.

우리는 실제 대규모 응용 프로그램에서 따를 수있는 고유 한 방법론이 없습니다. 일반적으로 비즈니스 문제가 정의되면 사용할 방법론을 설계하기위한 연구 단계가 필요합니다. 그러나 일반적인 지침은 언급되어야하며 거의 모든 문제에 적용됩니다.

빅 데이터 분석에서 가장 중요한 작업 중 하나는 statistical modeling, 감독 및 비지도 분류 또는 회귀 문제를 의미합니다. 데이터가 정리되고 사전 처리되고 모델링에 사용할 수있게되면 합리적인 손실 메트릭으로 여러 모델을 평가할 때주의를 기울여야하며 모델이 구현되면 추가 평가 및 결과를보고해야합니다. 예측 모델링의 일반적인 함정은 모델을 구현하고 성능을 측정하지 않는 것입니다.

빅 데이터 라이프 사이클에서 언급했듯이 빅 데이터 제품 개발로 인한 데이터 제품은 대부분의 경우 다음 중 일부입니다.

  • Machine learning implementation − 분류 알고리즘, 회귀 모델 또는 세분화 모델 일 수 있습니다.

  • Recommender system − 목표는 사용자 행동에 따라 선택을 추천하는 시스템을 개발하는 것입니다. Netflix 이 데이터 제품의 특징적인 예이며, 사용자의 등급에 따라 다른 영화를 추천합니다.

  • Dashboard− 기업은 일반적으로 집계 된 데이터를 시각화하는 도구가 필요합니다. 대시 보드는이 데이터에 액세스 할 수 있도록하는 그래픽 메커니즘입니다.

  • Ad-Hoc analysis − 일반적으로 비즈니스 영역에는 데이터로 임시 분석을 수행하여 답변 할 수있는 질문, 가설 또는 신화가 있습니다.

대규모 조직에서 빅 데이터 프로젝트를 성공적으로 개발하기 위해서는 관리자가 프로젝트를 백업하는 것이 필요합니다. 이것은 일반적으로 프로젝트의 비즈니스 이점을 보여주는 방법을 찾는 것을 포함합니다. 우리는 프로젝트의 스폰서를 찾는 문제에 대한 고유 한 해결책이 없지만 몇 가지 지침이 아래에 나와 있습니다.

  • 관심있는 프로젝트와 유사한 다른 프로젝트의 스폰서가 누구이며 어디에 있는지 확인하십시오.

  • 주요 관리 직책에 개인 연락처가 있으면 프로젝트가 유망한 경우 모든 연락처가 트리거 될 수 있습니다.

  • 당신의 프로젝트로 누가 혜택을 볼까요? 프로젝트가 순조롭게 진행되면 고객은 누구입니까?

  • 간단하고 명확하며 기존의 제안을 개발하고 조직의 주요 플레이어와 공유하십시오.

프로젝트의 스폰서를 찾는 가장 좋은 방법은 문제를 이해하고 구현 된 데이터 제품이 무엇인지 이해하는 것입니다. 이러한 이해는 빅 데이터 프로젝트의 중요성에 대한 경영진의 설득력을 제공 할 것입니다.

데이터 분석가는 SQL을 사용하여 기존 데이터웨어 하우스에서 데이터를 추출하고 분석 한 경험이있는보고 지향 프로필을 가지고 있습니다. 이들의 작업은 일반적으로 데이터 스토리지 측면 또는 일반적인 비즈니스 결과보고에 있습니다. 데이터웨어 하우징은 결코 간단하지 않으며 데이터 과학자가하는 일과 다릅니다.

많은 조직이 시장에서 유능한 데이터 과학자를 찾기 위해 고군분투하고 있습니다. 그러나 미래의 데이터 분석가를 선택하고 그들에게 데이터 과학자가되기위한 관련 기술을 가르치는 것이 좋습니다. 이것은 결코 사소한 일이 아니며 일반적으로 양적 분야에서 석사 학위를 취득하는 사람을 포함하지만 확실히 실행 가능한 옵션입니다. 유능한 데이터 분석가가 갖추어야하는 기본 기술은 다음과 같습니다.

  • 비즈니스 이해
  • SQL 프로그래밍
  • 보고서 디자인 및 구현
  • 대시 보드 개발

데이터 과학자의 역할은 일반적으로 예측 모델링, 세분화 알고리즘 개발, 추천 시스템, A / B 테스트 프레임 워크와 같은 작업과 관련되며 종종 원시 비정형 데이터로 작업합니다.

그들의 작업의 성격은 수학, 응용 통계 및 프로그래밍에 대한 깊은 이해를 요구합니다. 데이터 분석가와 데이터 과학자 사이에는 몇 가지 공통적 인 기술이 있습니다 (예 : 데이터베이스 쿼리 기능). 둘 다 데이터를 분석하지만 데이터 과학자의 결정은 조직에 더 큰 영향을 미칠 수 있습니다.

다음은 데이터 과학자가 일반적으로 필요로하는 기술입니다.

  • R, Python, SAS, SPSS 또는 Julia와 같은 통계 패키지로 프로그래밍
  • 다양한 소스에서 데이터를 정리, 추출 및 탐색 할 수 있습니다.
  • 통계 모델의 연구, 설계 및 구현
  • 심층 통계, 수학 및 컴퓨터 과학 지식

빅 데이터 분석에서 사람들은 일반적으로 데이터 과학자의 역할과 데이터 설계자의 역할을 혼동합니다. 실제로 그 차이는 아주 간단합니다. 데이터 아키텍트는 데이터가 저장 될 도구와 아키텍처를 정의하는 반면 데이터 과학자는이 아키텍처를 사용합니다. 물론 데이터 과학자는 임시 프로젝트에 필요한 경우 새로운 도구를 설정할 수 있어야하지만 인프라 정의 및 설계가 그의 작업에 포함되어서는 안됩니다.

이 튜토리얼을 통해 우리는 프로젝트를 개발할 것입니다. 이 튜토리얼의 각 후속 장에서는 미니 프로젝트 섹션에서 더 큰 프로젝트의 일부를 다룹니다. 이것은 실제 문제에 대한 노출을 제공하는 응용 튜토리얼 섹션으로 생각됩니다. 이 경우 프로젝트의 문제 정의부터 시작합니다.

프로젝트 설명

이 프로젝트의 목표는 이력서 (CV) 텍스트를 입력으로 사용하여 사람들의 시간당 급여를 예측하는 기계 학습 모델을 개발하는 것입니다.

위에서 정의한 프레임 워크를 사용하면 문제를 간단하게 정의 할 수 있습니다. 우리는 정의 할 수 있습니다 X = {X 1 , X 2 , ..., X의 N } 이력서의 각 기능을 할 수있는 사용자의 가장 간단한 방법으로 가능 시간이 단어가 나타납니다의 양으로. 그런 다음 응답은 실제 가치가 있습니다. 우리는 개인의 시간당 급여를 달러로 예측하려고합니다.

이 두 가지 고려 사항은 제시된 문제를 감독 회귀 알고리즘으로 해결할 수 있다는 결론을 내리기에 충분합니다.

문제 정의

Problem Definition아마도 빅 데이터 분석 파이프 라인에서 가장 복잡하고 간과 된 단계 중 하나 일 것입니다. 데이터 제품이 해결할 문제를 정의하려면 경험이 필수입니다. 대부분의 데이터 과학자 지망자는이 단계에서 경험이 거의 또는 전혀 없습니다.

대부분의 빅 데이터 문제는 다음과 같은 방식으로 분류 할 수 있습니다.

  • 감독 분류
  • 감독 회귀
  • 비지도 학습
  • 순위 배우기

이제이 네 가지 개념에 대해 자세히 알아 보겠습니다.

감독 분류

특징 행렬 X = {x 1 , x 2 , ..., x n }이 주어지면 y = {c 1 , c 2 , ..., c n } 로 정의 된 다른 클래스를 예측하는 모델 M을 개발합니다 . 예 : 보험 회사 고객의 거래 데이터가 주어지면 고객이 이탈할지 여부를 예측하는 모델을 개발할 수 있습니다. 후자는 이진 분류 문제로, 두 개의 클래스 또는 대상 변수 (churn 및 churn 아님)가 있습니다.

다른 문제는 둘 이상의 클래스를 예측하는 것과 관련이 있습니다. 숫자 인식에 관심이있을 수 있으므로 응답 벡터는 다음과 같이 정의됩니다. y = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} , 최첨단 모델은 컨볼 루션 신경망이되고 특징 매트릭스는 이미지의 픽셀로 정의됩니다.

감독 회귀

이 경우 문제 정의는 이전 예제와 다소 유사합니다. 차이는 응답에 달려 있습니다. 회귀 문제에서 반응 y ∈ ℜ, 이는 반응이 실제 값임을 의미합니다. 예를 들어, 우리는 이력서의 말뭉치가 주어진 개인의 시간당 급여를 예측하는 모델을 개발할 수 있습니다.

비지도 학습

경영진은 종종 새로운 통찰력에 목 말라합니다. 세분화 모델은 마케팅 부서가 다양한 세그먼트에 대한 제품을 개발할 수 있도록 이러한 통찰력을 제공 할 수 있습니다. 알고리즘을 생각하는 것보다 세분화 모델을 개발하는 좋은 방법은 원하는 세분화와 관련된 기능을 선택하는 것입니다.

예를 들어, 통신 회사에서 휴대폰 사용을 기준으로 클라이언트를 분류하는 것은 흥미 롭습니다. 여기에는 세분화 목표와 관련이없는 기능을 무시하고 해당 기능 만 포함하는 것이 포함됩니다. 이 경우 한 달에 사용되는 SMS 수, 인바운드 및 아웃 바운드 시간 (분) 등으로 기능을 선택합니다.

순위 배우기

이 문제는 회귀 문제로 간주 될 수 있지만 특별한 특성이 있으며 별도의 치료가 필요합니다. 문제는 주어진 쿼리에서 가장 관련성이 높은 순서를 찾으려는 문서 모음을 포함합니다. 지도 학습 알고리즘을 개발하기 위해서는 질의가 주어 졌을 때 순서가 얼마나 관련이 있는지 레이블을 지정해야합니다.

지도 학습 알고리즘을 개발하려면 훈련 데이터에 레이블을 지정해야합니다. 즉, 예를 들어 이미지에서 숫자를 인식하는 모델을 학습하려면 상당한 양의 예제에 손으로 레이블을 지정해야합니다. 이 프로세스의 속도를 높일 수있는 웹 서비스가 있으며 Amazon Mechanical Turk와 같이이 작업에 일반적으로 사용됩니다. 학습 알고리즘은 더 많은 데이터가 제공 될 때 성능을 향상시키는 것으로 입증되었으므로 적절한 양의 예제에 레이블을 지정하는 것은 감독 학습에서 실질적으로 필수입니다.

데이터 수집은 빅 데이터주기에서 가장 중요한 역할을합니다. 인터넷은 다양한 주제에 대해 거의 무제한의 데이터 소스를 제공합니다. 이 영역의 중요성은 비즈니스 유형에 따라 다르지만 전통적인 산업은 다양한 외부 데이터 소스를 획득하고이를 트랜잭션 데이터와 결합 할 수 있습니다.

예를 들어 레스토랑을 추천하는 시스템을 구축한다고 가정 해 보겠습니다. 첫 번째 단계는 데이터 (이 경우 다른 웹 사이트의 레스토랑 리뷰)를 수집하여 데이터베이스에 저장하는 것입니다. 원시 텍스트에 관심이 있고이를 분석에 사용할 것이므로 모델 개발을위한 데이터가 저장되는 위치는 그다지 중요하지 않습니다. 이는 빅 데이터의 주요 기술과 모순되는 것처럼 들릴 수 있지만, 빅 데이터 애플리케이션을 구현하려면 실시간으로 작동하도록하면됩니다.

트위터 미니 프로젝트

문제가 정의되면 다음 단계는 데이터를 수집하는 것입니다. 다음 미니 프로젝트 아이디어는 웹에서 데이터를 수집하고 기계 학습 모델에서 사용할 수 있도록 구조화하는 것입니다. R 프로그래밍 언어를 사용하여 twitter rest API에서 일부 트윗을 수집합니다.

먼저 트위터 계정을 만든 다음 twitteR패키지 비 네트 를 사용하여 트위터 개발자 계정을 만듭니다. 이것은 그 지침의 요약입니다-

  • 이동 https://twitter.com/apps/new 로그인하십시오.

  • 기본 정보를 입력 한 후 "설정"탭으로 이동하여 "다이렉트 메시지 읽기, 쓰기 및 액세스"를 선택합니다.

  • 이 작업을 수행 한 후 반드시 저장 버튼을 클릭하십시오.

  • "세부 정보"탭에서 소비자 키와 소비자 비밀을 기록해 둡니다.

  • R 세션에서 API 키와 API 비밀 값을 사용합니다.

  • 마지막으로 다음 스크립트를 실행하십시오. 이것은 설치합니다twitteR github의 저장소에서 패키지.

install.packages(c("devtools", "rjson", "bit64", "httr"))  

# Make sure to restart your R session at this point 
library(devtools) 
install_github("geoffjentry/twitteR")

우리는 "big mac"문자열이 포함 된 데이터를 얻고 이에 대해 어떤 주제가 눈에 띄는 지 알아내는 데 관심이 있습니다. 이를 위해 첫 번째 단계는 트위터에서 데이터를 수집하는 것입니다. 아래는 트위터에서 필요한 데이터를 수집하는 R 스크립트입니다. 이 코드는 bda / part1 / collect_data / collect_data_twitter.R 파일에서도 사용할 수 있습니다.

rm(list = ls(all = TRUE)); gc() # Clears the global environment
library(twitteR)
Sys.setlocale(category = "LC_ALL", locale = "C")

### Replace the xxx’s with the values you got from the previous instructions

# consumer_key = "xxxxxxxxxxxxxxxxxxxx"
# consumer_secret = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

# access_token = "xxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

# access_token_secret= "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

# Connect to twitter rest API
setup_twitter_oauth(consumer_key, consumer_secret, access_token, access_token_secret)

# Get tweets related to big mac
tweets <- searchTwitter(’big mac’, n = 200, lang = ’en’)
df <- twListToDF(tweets)

# Take a look at the data
head(df)

# Check which device is most used
sources <- sapply(tweets, function(x) x$getStatusSource())
sources <- gsub("</a>", "", sources)
sources <- strsplit(sources, ">")
sources <- sapply(sources, function(x) ifelse(length(x) > 1, x[2], x[1]))
source_table = table(sources)
source_table = source_table[source_table > 1]
freq = source_table[order(source_table, decreasing = T)]
as.data.frame(freq)

#                       Frequency
# Twitter for iPhone       71
# Twitter for Android      29
# Twitter Web Client       25
# recognia                 20

데이터가 수집되면 일반적으로 특성이 다른 다양한 데이터 소스가 있습니다. 가장 즉각적인 단계는 이러한 데이터 소스를 동종으로 만들고 데이터 제품을 계속 개발하는 것입니다. 그러나 데이터 유형에 따라 다릅니다. 데이터를 균질화하는 것이 실용적인지 자문해야합니다.

데이터 소스가 완전히 다를 수 있으며 소스를 균질화하면 정보 손실이 커집니다. 이 경우 대안을 생각할 수 있습니다. 하나의 데이터 소스가 회귀 모델을 구축하고 다른 하나는 분류 모델을 구축하는 데 도움이 될 수 있습니까? 정보를 잃어 버리는 것보다 유리하게 이질성을 가지고 일하는 것이 가능합니까? 이러한 결정을 내리는 것이 분석을 흥미롭고 도전적으로 만드는 요인입니다.

리뷰의 경우 각 데이터 소스에 대한 언어를 가질 수 있습니다. 다시 두 가지 선택이 있습니다.

  • Homogenization− 다른 언어를 더 많은 데이터가있는 언어로 번역하는 것이 포함됩니다. 번역 서비스의 품질은 만족 스럽지만 API를 사용하여 방대한 양의 데이터를 번역하려면 비용이 많이 듭니다. 이 작업에 사용할 수있는 소프트웨어 도구가 있지만 비용도 많이 듭니다.

  • Heterogenization− 각 언어에 대한 솔루션을 개발할 수 있습니까? 말뭉치의 언어를 감지하는 것이 간단하기 때문에 각 언어에 대한 추천자를 개발할 수 있습니다. 사용 가능한 언어의 양에 따라 각 추천자를 조정하는 측면에서 더 많은 작업이 필요하지만 몇 가지 언어를 사용할 수있는 경우 확실히 실행 가능한 옵션입니다.

트위터 미니 프로젝트

현재의 경우, 토픽 모델링을 적용하기 위해 먼저 구조화되지 않은 데이터를 정리 한 다음 데이터 매트릭스로 변환해야합니다. 일반적으로 트위터에서 데이터를 가져올 때 적어도 데이터 정리 프로세스의 첫 번째 단계에서 사용하는 데 관심이없는 여러 문자가 있습니다.

예를 들어 트윗을받은 후 이상한 문자 "<ed> <U + 00A0> <U + 00BD> <ed> <U + 00B8> <U + 008B>"를 얻습니다. 아마도 이모티콘 일 것이므로 데이터를 정리하기 위해 다음 스크립트를 사용하여 제거합니다. 이 코드는 bda / part1 / collect_data / cleaning_data.R 파일에서도 사용할 수 있습니다.

rm(list = ls(all = TRUE)); gc() # Clears the global environment
source('collect_data_twitter.R')
# Some tweets
head(df$text)

[1] "I’m not a big fan of turkey but baked Mac &
cheese <ed><U+00A0><U+00BD><ed><U+00B8><U+008B>"
[2] "@Jayoh30 Like no special sauce on a big mac. HOW"
### We are interested in the text - Let’s clean it!

# We first convert the encoding of the text from latin1 to ASCII
df$text <- sapply(df$text,function(row) iconv(row, "latin1", "ASCII", sub = ""))

# Create a function to clean tweets
clean.text <- function(tx) {
  tx <- gsub("htt.{1,20}", " ", tx, ignore.case = TRUE)
  tx = gsub("[^#[:^punct:]]|@|RT", " ", tx, perl = TRUE, ignore.case = TRUE)
  tx = gsub("[[:digit:]]", " ", tx, ignore.case = TRUE)
  tx = gsub(" {1,}", " ", tx, ignore.case = TRUE)
  tx = gsub("^\\s+|\\s+$", " ", tx, ignore.case = TRUE) return(tx) } clean_tweets <- lapply(df$text, clean.text)

# Cleaned tweets
head(clean_tweets)
[1] " WeNeedFeminlsm MAC s new make up line features men woc and big girls "
[1] " TravelsPhoto What Happens To Your Body One Hour After A Big Mac "

데이터 정리 미니 프로젝트의 마지막 단계는 행렬로 변환하고 알고리즘을 적용 할 수있는 텍스트를 정리하는 것입니다. 에 저장된 텍스트에서clean_tweets 벡터 우리는 그것을 단어 모음 행렬로 쉽게 변환하고 비지도 학습 알고리즘을 적용 할 수 있습니다.

보고는 빅 데이터 분석에서 매우 중요합니다. 모든 조직은 의사 결정 과정을 지원하기 위해 정기적으로 정보를 제공해야합니다. 이 작업은 일반적으로 SQL 및 ETL (추출, 전송 및로드) 경험이있는 데이터 분석가가 처리합니다.

이 작업을 담당하는 팀은 빅 데이터 분석 부서에서 생성 된 정보를 조직의 여러 영역으로 확산하는 책임이 있습니다.

다음 예는 데이터 요약의 의미를 보여줍니다. 폴더로 이동bda/part1/summarize_data 폴더 내에서 summarize_data.Rproj파일을 두 번 클릭합니다. 그런 다음summarize_data.R 스크립트를 작성하고 코드를 살펴보고 제시된 설명을 따르십시오.

# Install the following packages by running the following code in R. 
pkgs = c('data.table', 'ggplot2', 'nycflights13', 'reshape2') 
install.packages(pkgs)

그만큼 ggplot2패키지는 데이터 시각화에 적합합니다. 그만큼data.table 패키지는 빠르고 메모리 효율적인 요약을 수행 할 수있는 훌륭한 옵션입니다. R. 최근 벤치 마크에 따르면pandas, 유사한 작업에 사용되는 파이썬 라이브러리.

다음 코드를 사용하여 데이터를 살펴보십시오. 이 코드는bda/part1/summarize_data/summarize_data.Rproj 파일.

library(nycflights13) 
library(ggplot2) 
library(data.table) 
library(reshape2)  

# Convert the flights data.frame to a data.table object and call it DT 
DT <- as.data.table(flights)  

# The data has 336776 rows and 16 columns 
dim(DT)  

# Take a look at the first rows 
head(DT) 

#   year    month  day   dep_time  dep_delay  arr_time  arr_delay  carrier 
# 1: 2013     1     1      517       2         830         11       UA 
# 2: 2013     1     1      533       4         850         20       UA 
# 3: 2013     1     1      542       2         923         33       AA 
# 4: 2013     1     1      544      -1        1004        -18       B6 
# 5: 2013     1     1      554      -6         812        -25       DL 
# 6: 2013     1     1      554      -4         740         12       UA  

#     tailnum  flight  origin   dest    air_time   distance    hour   minute 
# 1:  N14228   1545     EWR      IAH      227        1400       5       17 
# 2:  N24211   1714     LGA      IAH      227        1416       5       33 
# 3:  N619AA   1141     JFK      MIA      160        1089       5       42 
# 4:  N804JB    725     JFK      BQN      183        1576       5       44 
# 5:  N668DN    461     LGA      ATL      116        762        5       54 
# 6:  N39463   1696     EWR      ORD      150        719        5       54

다음 코드에는 데이터 요약의 예가 있습니다.

### Data Summarization
# Compute the mean arrival delay  
DT[, list(mean_arrival_delay = mean(arr_delay, na.rm = TRUE))] 
#        mean_arrival_delay 
# 1:           6.895377  
# Now, we compute the same value but for each carrier 
mean1 = DT[, list(mean_arrival_delay = mean(arr_delay, na.rm = TRUE)), 
   by = carrier] 
print(mean1) 
#      carrier    mean_arrival_delay 
# 1:      UA          3.5580111 
# 2:      AA          0.3642909 
# 3:      B6          9.4579733 
# 4:      DL          1.6443409 
# 5:      EV         15.7964311 
# 6:      MQ         10.7747334 
# 7:      US          2.1295951 
# 8:      WN          9.6491199 
# 9:      VX          1.7644644 
# 10:     FL         20.1159055 
# 11:     AS         -9.9308886 
# 12:     9E          7.3796692
# 13:     F9         21.9207048 
# 14:     HA         -6.9152047 
# 15:     YV         15.5569853 
# 16:     OO         11.9310345

# Now let’s compute to means in the same line of code 
mean2 = DT[, list(mean_departure_delay = mean(dep_delay, na.rm = TRUE), 
   mean_arrival_delay = mean(arr_delay, na.rm = TRUE)), 
   by = carrier] 
print(mean2) 

#       carrier    mean_departure_delay   mean_arrival_delay 
# 1:      UA            12.106073          3.5580111 
# 2:      AA             8.586016          0.3642909 
# 3:      B6            13.022522          9.4579733 
# 4:      DL             9.264505          1.6443409 
# 5:      EV            19.955390         15.7964311 
# 6:      MQ            10.552041         10.7747334 
# 7:      US             3.782418          2.1295951 
# 8:      WN            17.711744          9.6491199 
# 9:      VX            12.869421          1.7644644 
# 10:     FL            18.726075         20.1159055 
# 11:     AS             5.804775         -9.9308886 
# 12:     9E            16.725769          7.3796692 
# 13:     F9            20.215543         21.9207048 
# 14:     HA             4.900585         -6.9152047 
# 15:     YV            18.996330         15.5569853 
# 16:     OO            12.586207         11.9310345

### Create a new variable called gain 
# this is the difference between arrival delay and departure delay 
DT[, gain:= arr_delay - dep_delay]  

# Compute the median gain per carrier 
median_gain = DT[, median(gain, na.rm = TRUE), by = carrier] 
print(median_gain)

Exploratory data analysis통계의 새로운 관점으로 구성된 John Tuckey (1977)가 개발 한 개념입니다. Tuckey의 아이디어는 전통적인 통계에서 데이터가 그래픽으로 탐색되지 않고 가설을 테스트하는 데 사용된다는 것입니다. 도구를 개발하려는 첫 번째 시도는 스탠포드에서 이루어 졌으며이 프로젝트는 prim9 라고 불 렸습니다 . 이 도구는 데이터를 9 개 차원으로 시각화 할 수 있었으므로 데이터에 대한 다 변수 관점을 제공 할 수있었습니다.

최근에는 탐색 적 데이터 분석이 필수이며 빅 데이터 분석 수명주기에 포함되었습니다. 통찰력을 찾고 조직 내에서 효과적으로 소통 할 수있는 능력은 강력한 EDA 기능을 통해 촉진됩니다.

Tuckey의 아이디어를 바탕으로 Bell Labs는 S programming language통계를 수행하기위한 대화 형 인터페이스를 제공합니다. S의 아이디어는 사용하기 쉬운 언어로 광범위한 그래픽 기능을 제공하는 것이 었습니다. 오늘날의 세계에서 빅 데이터의 맥락에서R 그 기반 S 프로그래밍 언어는 분석에 가장 많이 사용되는 소프트웨어입니다.

다음 프로그램은 탐색 적 데이터 분석의 사용을 보여줍니다.

다음은 탐색 적 데이터 분석의 예입니다. 이 코드는part1/eda/exploratory_data_analysis.R 파일.

library(nycflights13) 
library(ggplot2) 
library(data.table) 
library(reshape2)  

# Using the code from the previous section 
# This computes the mean arrival and departure delays by carrier. 
DT <- as.data.table(flights) 
mean2 = DT[, list(mean_departure_delay = mean(dep_delay, na.rm = TRUE), 
   mean_arrival_delay = mean(arr_delay, na.rm = TRUE)), 
   by = carrier]  

# In order to plot data in R usign ggplot, it is normally needed to reshape the data 
# We want to have the data in long format for plotting with ggplot 
dt = melt(mean2, id.vars = ’carrier’)  

# Take a look at the first rows 
print(head(dt))  

# Take a look at the help for ?geom_point and geom_line to find similar examples 
# Here we take the carrier code as the x axis 
# the value from the dt data.table goes in the y axis 

# The variable column represents the color 
p = ggplot(dt, aes(x = carrier, y = value, color = variable, group = variable)) +
   geom_point() + # Plots points 
   geom_line() + # Plots lines 
   theme_bw() + # Uses a white background 
   labs(list(title = 'Mean arrival and departure delay by carrier', 
      x = 'Carrier', y = 'Mean delay')) 
print(p)  

# Save the plot to disk 
ggsave('mean_delay_by_carrier.png', p,  
   width = 10.4, height = 5.07)

코드는 다음과 같은 이미지를 생성해야합니다.

데이터를 이해하기 위해 시각화하는 것이 유용한 경우가 많습니다. 일반적으로 빅 데이터 애플리케이션에서 관심은 단지 아름다운 플롯을 만드는 것보다 통찰력을 찾는 데 달려 있습니다. 다음은 플롯을 사용하여 데이터를 이해하는 다양한 접근 방식의 예입니다.

비행 데이터 분석을 시작하려면 숫자 변수간에 상관 관계가 있는지 확인하는 것부터 시작할 수 있습니다. 이 코드는bda/part1/data_visualization/data_visualization.R 파일.

# Install the package corrplot by running
install.packages('corrplot')  

# then load the library 
library(corrplot)  

# Load the following libraries  
library(nycflights13) 
library(ggplot2) 
library(data.table) 
library(reshape2)  

# We will continue working with the flights data 
DT <- as.data.table(flights)  
head(DT) # take a look  

# We select the numeric variables after inspecting the first rows. 
numeric_variables = c('dep_time', 'dep_delay',  
   'arr_time', 'arr_delay', 'air_time', 'distance')

# Select numeric variables from the DT data.table 
dt_num = DT[, numeric_variables, with = FALSE]  

# Compute the correlation matrix of dt_num 
cor_mat = cor(dt_num, use = "complete.obs")  

print(cor_mat) 
### Here is the correlation matrix 
#              dep_time   dep_delay   arr_time   arr_delay    air_time    distance 
# dep_time   1.00000000  0.25961272 0.66250900  0.23230573 -0.01461948 -0.01413373 
# dep_delay  0.25961272  1.00000000 0.02942101  0.91480276 -0.02240508 -0.02168090 
# arr_time   0.66250900  0.02942101 1.00000000  0.02448214  0.05429603  0.04718917 
# arr_delay  0.23230573  0.91480276 0.02448214  1.00000000 -0.03529709 -0.06186776 
# air_time  -0.01461948 -0.02240508 0.05429603 -0.03529709  1.00000000  0.99064965 
# distance  -0.01413373 -0.02168090 0.04718917 -0.06186776  0.99064965  1.00000000  

# We can display it visually to get a better understanding of the data 
corrplot.mixed(cor_mat, lower = "circle", upper = "ellipse")  

# save it to disk 
png('corrplot.png') 
print(corrplot.mixed(cor_mat, lower = "circle", upper = "ellipse")) 
dev.off()

이 코드는 다음과 같은 상관 행렬 시각화를 생성합니다.

그림에서 데이터 세트의 일부 변수간에 강한 상관 관계가 있음을 알 수 있습니다. 예를 들어, 도착 지연과 출발 지연은 높은 상관 관계가있는 것으로 보입니다. 타원이 두 변수 간의 거의 선형 관계를 보여주기 때문에 이것을 볼 수 있지만이 결과에서 원인을 찾는 것은 간단하지 않습니다.

두 변수가 상관 관계가 있으므로 하나가 다른 변수에 영향을 미친다고 말할 수 없습니다. 또한 플롯에서 공기 시간과 거리 사이의 강한 상관 관계를 발견했습니다. 이는 거리가 멀수록 비행 시간이 늘어날 것으로 예상하는 것이 상당히 합리적입니다.

데이터의 일 변량 분석도 수행 할 수 있습니다. 분포를 시각화하는 간단하고 효과적인 방법은 다음과 같습니다.box-plots. 다음 코드는 ggplot2 라이브러리를 사용하여 상자 그림 및 격자 차트를 생성하는 방법을 보여줍니다. 이 코드는bda/part1/data_visualization/boxplots.R 파일.

source('data_visualization.R') 
### Analyzing Distributions using box-plots  
# The following shows the distance as a function of the carrier 

p = ggplot(DT, aes(x = carrier, y = distance, fill = carrier)) + # Define the carrier 
   in the x axis and distance in the y axis 
   geom_box-plot() + # Use the box-plot geom 
   theme_bw() + # Leave a white background - More in line with tufte's 
      principles than the default 
   guides(fill = FALSE) + # Remove legend 
   labs(list(title = 'Distance as a function of carrier', # Add labels 
      x = 'Carrier', y = 'Distance')) 
p   
# Save to disk 
png(‘boxplot_carrier.png’) 
print(p) 
dev.off()   

# Let's add now another variable, the month of each flight 
# We will be using facet_wrap for this 
p = ggplot(DT, aes(carrier, distance, fill = carrier)) + 
   geom_box-plot() + 
   theme_bw() + 
   guides(fill = FALSE) +  
   facet_wrap(~month) + # This creates the trellis plot with the by month variable
   labs(list(title = 'Distance as a function of carrier by month', 
      x = 'Carrier', y = 'Distance')) 
p   
# The plot shows there aren't clear differences between distance in different months  

# Save to disk 
png('boxplot_carrier_by_month.png') 
print(p) 
dev.off()

이 섹션은 사용자에게 R 프로그래밍 언어를 소개하는 데 전념합니다. R은 cran 웹 사이트 에서 다운로드 할 수 있습니다 . Windows 사용자의 경우 rtools 및 rstudio IDE 를 설치 하는 것이 유용합니다 .

뒤에있는 일반적인 개념 R C, C ++ 및 Fortran과 같은 컴파일 된 언어로 개발 된 다른 소프트웨어에 대한 인터페이스 역할을하고 사용자에게 데이터 분석을위한 대화 형 도구를 제공하는 것입니다.

책 zip 파일의 폴더로 이동 bda/part2/R_introduction 열다 R_introduction.Rproj파일. 그러면 RStudio 세션이 열립니다. 그런 다음 01_vectors.R 파일을 엽니 다. 스크립트를 한 줄씩 실행하고 코드의 주석을 따릅니다. 배우기위한 또 다른 유용한 옵션은 코드를 입력하는 것입니다. 이것은 R 구문에 익숙해지는 데 도움이됩니다. R에서 주석은 # 기호로 작성됩니다.

책에 R 코드를 실행 한 결과를 표시하기 위해 코드를 평가 한 후 R 반환 결과에 주석을 달았습니다. 이렇게하면 책에 코드를 복사하여 붙여넣고 R에서 직접 섹션을 시도 할 수 있습니다.

# Create a vector of numbers 
numbers = c(1, 2, 3, 4, 5) 
print(numbers) 

# [1] 1 2 3 4 5  
# Create a vector of letters 
ltrs = c('a', 'b', 'c', 'd', 'e') 
# [1] "a" "b" "c" "d" "e"  

# Concatenate both  
mixed_vec = c(numbers, ltrs) 
print(mixed_vec) 
# [1] "1" "2" "3" "4" "5" "a" "b" "c" "d" "e"

이전 코드에서 무슨 일이 있었는지 분석해 보겠습니다. 숫자와 문자로 벡터를 만드는 것이 가능하다는 것을 알 수 있습니다. 우리가 원하는 데이터 유형을 미리 R에게 말할 필요가 없었습니다. 마지막으로 숫자와 문자로 구성된 벡터를 만들 수있었습니다. 벡터 mixed_vec는 숫자를 문자로 강제 변환했습니다. 우리는 값이 따옴표 안에 어떻게 인쇄되는지 시각화함으로써 이것을 볼 수 있습니다.

다음 코드는 함수 클래스에서 반환 된 다른 벡터의 데이터 유형을 보여줍니다. 클래스 함수를 사용하여 객체를 "질문"하여 클래스가 무엇인지 묻는 것이 일반적입니다.

### Evaluate the data types using class

### One dimensional objects 
# Integer vector 
num = 1:10 
class(num) 
# [1] "integer"  

# Numeric vector, it has a float, 10.5 
num = c(1:10, 10.5) 
class(num) 
# [1] "numeric"  

# Character vector 
ltrs = letters[1:10] 
class(ltrs) 
# [1] "character"  

# Factor vector 
fac = as.factor(ltrs) 
class(fac) 
# [1] "factor"

R은 2 차원 객체도 지원합니다. 다음 코드에는 R에서 가장 많이 사용되는 두 가지 데이터 구조 인 matrix와 data.frame의 예가 있습니다.

# Matrix
M = matrix(1:12, ncol = 4) 
#      [,1] [,2] [,3] [,4] 
# [1,]    1    4    7   10 
# [2,]    2    5    8   11 
# [3,]    3    6    9   12 
lM = matrix(letters[1:12], ncol = 4) 
#     [,1] [,2] [,3] [,4] 
# [1,] "a"  "d"  "g"  "j"  
# [2,] "b"  "e"  "h"  "k"  
# [3,] "c"  "f"  "i"  "l"   

# Coerces the numbers to character 
# cbind concatenates two matrices (or vectors) in one matrix 
cbind(M, lM) 
#     [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] 
# [1,] "1"  "4"  "7"  "10" "a"  "d"  "g"  "j"  
# [2,] "2"  "5"  "8"  "11" "b"  "e"  "h"  "k"  
# [3,] "3"  "6"  "9"  "12" "c"  "f"  "i"  "l"   

class(M) 
# [1] "matrix" 
class(lM) 
# [1] "matrix"  

# data.frame 
# One of the main objects of R, handles different data types in the same object.  
# It is possible to have numeric, character and factor vectors in the same data.frame  

df = data.frame(n = 1:5, l = letters[1:5]) 
df 
#   n l 
# 1 1 a 
# 2 2 b 
# 3 3 c 
# 4 4 d 
# 5 5 e

이전 예제에서 설명한 것처럼 동일한 개체에서 다른 데이터 유형을 사용할 수 있습니다. 일반적으로 데이터가 데이터베이스에 표시되는 방식이며 데이터의 API 부분은 텍스트 또는 문자 벡터 및 기타 숫자입니다. In은 할당 할 통계 데이터 유형을 결정한 다음 올바른 R 데이터 유형을 사용하는 분석가 작업입니다. 통계에서 우리는 일반적으로 변수가 다음 유형이라고 생각합니다.

  • Numeric
  • 명목 또는 범주
  • Ordinal

R에서 벡터는 다음과 같은 클래스가 될 수 있습니다.

  • 숫자-정수
  • Factor
  • 정렬 된 요소

R은 각 통계 유형의 변수에 대한 데이터 유형을 제공합니다. 그러나 정렬 된 요소는 거의 사용되지 않지만 함수 요소에 의해 생성되거나 정렬 될 수 있습니다.

다음 섹션에서는 인덱싱의 개념을 다룹니다. 이것은 매우 일반적인 작업이며 개체의 섹션을 선택하고 변형하는 문제를 다룹니다.

# Let's create a data.frame
df = data.frame(numbers = 1:26, letters) 
head(df) 
#      numbers  letters 
# 1       1       a 
# 2       2       b 
# 3       3       c 
# 4       4       d 
# 5       5       e 
# 6       6       f 

# str gives the structure of a data.frame, it’s a good summary to inspect an object 
str(df) 
#   'data.frame': 26 obs. of  2 variables: 
#   $ numbers: int 1 2 3 4 5 6 7 8 9 10 ... # $ letters: Factor w/ 26 levels "a","b","c","d",..: 1 2 3 4 5 6 7 8 9 10 ...  

# The latter shows the letters character vector was coerced as a factor. 
# This can be explained by the stringsAsFactors = TRUE argumnet in data.frame 
# read ?data.frame for more information  

class(df) 
# [1] "data.frame"  

### Indexing
# Get the first row 
df[1, ] 
#     numbers  letters 
# 1       1       a  

# Used for programming normally - returns the output as a list 
df[1, , drop = TRUE] 
# $numbers # [1] 1 # # $letters 
# [1] a 
# Levels: a b c d e f g h i j k l m n o p q r s t u v w x y z  

# Get several rows of the data.frame 
df[5:7, ] 
#      numbers  letters 
# 5       5       e 
# 6       6       f 
# 7       7       g  

### Add one column that mixes the numeric column with the factor column 
df$mixed = paste(df$numbers, df$letters, sep = ’’) str(df) # 'data.frame': 26 obs. of 3 variables: # $ numbers: int  1 2 3 4 5 6 7 8 9 10 ...
# $ letters: Factor w/ 26 levels "a","b","c","d",..: 1 2 3 4 5 6 7 8 9 10 ... # $ mixed  : chr  "1a" "2b" "3c" "4d" ...  

### Get columns 
# Get the first column 
df[, 1]  
# It returns a one dimensional vector with that column  

# Get two columns 
df2 = df[, 1:2] 
head(df2)  

#      numbers  letters 
# 1       1       a 
# 2       2       b 
# 3       3       c 
# 4       4       d 
# 5       5       e 
# 6       6       f  

# Get the first and third columns 
df3 = df[, c(1, 3)] 
df3[1:3, ]  

#      numbers  mixed 
# 1       1     1a
# 2       2     2b 
# 3       3     3c  

### Index columns from their names 
names(df) 
# [1] "numbers" "letters" "mixed"   
# This is the best practice in programming, as many times indeces change, but 
variable names don’t 
# We create a variable with the names we want to subset 
keep_vars = c("numbers", "mixed") 
df4 = df[, keep_vars]  

head(df4) 
#      numbers  mixed 
# 1       1     1a 
# 2       2     2b 
# 3       3     3c 
# 4       4     4d 
# 5       5     5e 
# 6       6     6f  

### subset rows and columns 
# Keep the first five rows 
df5 = df[1:5, keep_vars] 
df5 

#      numbers  mixed 
# 1       1     1a 
# 2       2     2b
# 3       3     3c 
# 4       4     4d 
# 5       5     5e  

# subset rows using a logical condition 
df6 = df[df$numbers < 10, keep_vars] 
df6 

#      numbers  mixed 
# 1       1     1a 
# 2       2     2b 
# 3       3     3c 
# 4       4     4d 
# 5       5     5e 
# 6       6     6f 
# 7       7     7g 
# 8       8     8h 
# 9       9     9i

SQL은 구조화 된 쿼리 언어를 나타냅니다. 기존 데이터웨어 하우스 및 빅 데이터 기술의 데이터베이스에서 데이터를 추출하는 데 가장 널리 사용되는 언어 중 하나입니다. SQL의 기본을 설명하기 위해 예제로 작업 할 것입니다. 언어 자체에 초점을 맞추기 위해 R 내부에서 SQL을 사용할 것입니다. SQL 코드 작성 측면에서 이것은 데이터베이스에서 수행되는 것과 똑같습니다.

SQL의 핵심은 SELECT, FROM 및 WHERE의 세 가지 문입니다. 다음 예제는 SQL의 가장 일반적인 사용 사례를 사용합니다. 폴더로 이동bda/part2/SQL_introduction 열다 SQL_introduction.Rproj파일. 그런 다음 01_select.R 스크립트를 엽니 다. R에서 SQL 코드를 작성하려면 다음을 설치해야합니다.sqldf 다음 코드에 설명 된대로 패키지.

# Install the sqldf package
install.packages('sqldf')  

# load the library 
library('sqldf') 
library(nycflights13)  

# We will be working with the fligths dataset in order to introduce SQL  

# Let’s take a look at the table 
str(flights) 
# Classes 'tbl_d', 'tbl' and 'data.frame': 336776 obs. of  16 variables: 

# $ year     : int  2013 2013 2013 2013 2013 2013 2013 2013 2013 2013 ... 
# $ month : int 1 1 1 1 1 1 1 1 1 1 ... # $ day      : int  1 1 1 1 1 1 1 1 1 1 ... 
# $ dep_time : int 517 533 542 544 554 554 555 557 557 558 ... # $ dep_delay: num  2 4 2 -1 -6 -4 -5 -3 -3 -2 ... 
# $ arr_time : int 830 850 923 1004 812 740 913 709 838 753 ... # $ arr_delay: num  11 20 33 -18 -25 12 19 -14 -8 8 ...
# $ carrier : chr "UA" "UA" "AA" "B6" ... # $ tailnum  : chr  "N14228" "N24211" "N619AA" "N804JB" ... 
# $ flight : int 1545 1714 1141 725 461 1696 507 5708 79 301 ... # $ origin   : chr  "EWR" "LGA" "JFK" "JFK" ... 
# $ dest : chr "IAH" "IAH" "MIA" "BQN" ... # $ air_time : num  227 227 160 183 116 150 158 53 140 138 ... 
# $ distance : num 1400 1416 1089 1576 762 ... # $ hour     : num  5 5 5 5 5 5 5 5 5 5 ... 
# $ minute   : num  17 33 42 44 54 54 55 57 57 58 ...

select 문은 테이블에서 열을 검색하고 이에 대한 계산을 수행하는 데 사용됩니다. 가장 간단한 SELECT 문은ej1. 다음과 같이 새 변수를 만들 수도 있습니다.ej2.

### SELECT statement
ej1 = sqldf(" 
   SELECT  
   dep_time 
   ,dep_delay 
   ,arr_time 
   ,carrier 
   ,tailnum 
   FROM 
   flights
")  

head(ej1) 
#    dep_time   dep_delay  arr_time  carrier  tailnum 
# 1      517         2      830      UA       N14228 
# 2      533         4      850      UA       N24211 
# 3      542         2      923      AA       N619AA 
# 4      544        -1     1004      B6       N804JB 
# 5      554        -6      812      DL       N668DN 
# 6      554        -4      740      UA       N39463  

# In R we can use SQL with the sqldf function. It works exactly the same as in 
a database 

# The data.frame (in this case flights) represents the table we are querying 
and goes in the FROM statement  
# We can also compute new variables in the select statement using the syntax: 

# old_variables as new_variable 
ej2 = sqldf(" 
   SELECT 
   arr_delay - dep_delay as gain, 
   carrier 
   FROM 
   flights
")  

ej2[1:5, ] 
#    gain   carrier 
# 1    9      UA 
# 2   16      UA 
# 3   31      AA 
# 4  -17      B6 
# 5  -19      DL

SQL에서 가장 일반적으로 사용되는 기능 중 하나는 문별 그룹입니다. 이를 통해 다른 변수의 다른 그룹에 대한 숫자 값을 계산할 수 있습니다. 02_group_by.R 스크립트를 엽니 다.

### GROUP BY      

# Computing the average 
ej3 = sqldf(" 
  SELECT 
   avg(arr_delay) as mean_arr_delay, 
   avg(dep_delay) as mean_dep_delay, 
   carrier 
   FROM 
   flights 
   GROUP BY 
   carrier 
")  

#    mean_arr_delay   mean_dep_delay carrier 
# 1       7.3796692      16.725769      9E 
# 2       0.3642909       8.586016      AA 
# 3      -9.9308886       5.804775      AS 
# 4       9.4579733      13.022522      B6 
# 5       1.6443409       9.264505      DL 
# 6      15.7964311      19.955390      EV 
# 7      21.9207048      20.215543      F9 
# 8      20.1159055      18.726075      FL 
# 9      -6.9152047       4.900585      HA 
# 10     10.7747334      10.552041      MQ
# 11     11.9310345      12.586207      OO 
# 12      3.5580111      12.106073      UA 
# 13      2.1295951       3.782418      US 
# 14      1.7644644      12.869421      VX 
# 15      9.6491199      17.711744      WN 
# 16     15.5569853      18.996330      YV  

# Other aggregations 
ej4 = sqldf(" 
   SELECT 
   avg(arr_delay) as mean_arr_delay, 
   min(dep_delay) as min_dep_delay, 
   max(dep_delay) as max_dep_delay, 
   carrier 
   FROM  
   flights 
   GROUP BY 
   carrier 
")  

# We can compute the minimun, mean, and maximum values of a numeric value 
ej4 
#      mean_arr_delay    min_dep_delay   max_dep_delay   carrier 
# 1       7.3796692           -24           747          9E 
# 2       0.3642909           -24          1014          AA 
# 3      -9.9308886           -21           225          AS 
# 4       9.4579733           -43           502          B6
# 5       1.6443409           -33           960         DL 
# 6      15.7964311           -32           548         EV 
# 7      21.9207048           -27           853         F9 
# 8      20.1159055           -22           602         FL 
# 9      -6.9152047           -16          1301         HA 
# 10     10.7747334           -26          1137         MQ 
# 11     11.9310345           -14           154         OO 
# 12      3.5580111           -20           483         UA 
# 13      2.1295951           -19           500         US 
# 14      1.7644644           -20           653         VX 
# 15      9.6491199           -13           471         WN 
# 16     15.5569853           -16           387         YV  

### We could be also interested in knowing how many observations each carrier has  
ej5 = sqldf(" 
   SELECT 
   carrier, count(*) as count 
   FROM  
   flights 
   GROUP BY 
   carrier 
")  

ej5 
#      carrier  count 
# 1       9E    18460
# 2       AA   32729 
# 3       AS   714 
# 4       B6   54635 
# 5       DL   48110 
# 6       EV   54173 
# 7       F9   685 
# 8       FL   3260 
# 9       HA   342 
# 10      MQ   26397 
# 11      OO   32 
# 12      UA   58665 
# 13      US   20536 
# 14      VX   5162 
# 15      WN   12275 
# 16      YV   601

SQL의 가장 유용한 기능은 조인입니다. 조인은 두 테이블의 값을 일치시키기 위해 하나의 열을 사용하여 테이블 A와 테이블 B를 하나의 테이블에 결합한다는 것을 의미합니다. 실제로 시작하기위한 다양한 유형의 조인이 있습니다. 내부 조인과 왼쪽 외부 조인이 가장 유용한 조인입니다.

# Let’s create two tables: A and B to demonstrate joins.
A = data.frame(c1 = 1:4, c2 = letters[1:4]) 
B = data.frame(c1 = c(2,4,5,6), c2 = letters[c(2:5)])  

A 
# c1 c2 
# 1  a 
# 2  b 
# 3  c 
# 4  d  

B 
# c1 c2 
# 2  b 
# 4  c 
# 5  d 
# 6  e  

### INNER JOIN 
# This means to match the observations of the column we would join the tables by.   
inner = sqldf(" 
   SELECT 
   A.c1, B.c2 
   FROM 
   A INNER JOIN B 
   ON A.c1 = B.c1 
")  

# Only the rows that match c1 in both A and B are returned 
inner 
# c1 c2 
#  2  b 
#  4  c  

### LEFT OUTER JOIN
# the left outer join, sometimes just called left join will return the  
# first all the values of the column used from the A table  
left = sqldf(" 
  SELECT 
   A.c1, B.c2 
  FROM 
   A LEFT OUTER JOIN B 
   ON A.c1 = B.c1 
")  

# Only the rows that match c1 in both A and B are returned 
left 
#   c1    c2 
#    1  <NA> 
#    2    b 
#    3  <NA> 
#    4    c

데이터를 분석하는 첫 번째 방법은 시각적으로 분석하는 것입니다. 이를 수행하는 목적은 일반적으로 변수 간의 관계와 변수의 일 변량 설명을 찾는 것입니다. 우리는 이러한 전략을 다음과 같이 나눌 수 있습니다.

  • 일 변량 분석
  • 다변량 분석

일 변량 그래픽 방법

Univariate통계 용어입니다. 실제로는 나머지 데이터와 독립적으로 변수를 분석하고자 함을 의미합니다. 이를 효율적으로 수행 할 수있는 플롯은 다음과 같습니다.

상자 도표

상자 그림은 일반적으로 분포를 비교하는 데 사용됩니다. 분포간에 차이가 있는지 시각적으로 검사하는 좋은 방법입니다. 컷마다 다이아몬드 가격에 차이가 있는지 확인할 수 있습니다.

# We will be using the ggplot2 library for plotting
library(ggplot2)  
data("diamonds")  

# We will be using the diamonds dataset to analyze distributions of numeric variables 
head(diamonds) 

#    carat   cut       color  clarity  depth  table   price    x     y     z 
# 1  0.23    Ideal       E      SI2    61.5    55     326     3.95  3.98  2.43 
# 2  0.21    Premium     E      SI1    59.8    61     326     3.89  3.84  2.31 
# 3  0.23    Good        E      VS1    56.9    65     327     4.05  4.07  2.31 
# 4  0.29    Premium     I      VS2    62.4    58     334     4.20  4.23  2.63 
# 5  0.31    Good        J      SI2    63.3    58     335     4.34  4.35  2.75 
# 6  0.24    Very Good   J      VVS2   62.8    57     336     3.94  3.96  2.48 

### Box-Plots
p = ggplot(diamonds, aes(x = cut, y = price, fill = cut)) + 
   geom_box-plot() + 
   theme_bw() 
print(p)

줄거리에서 다이아몬드 가격 분포가 다른 유형의 컷에서 차이가 있음을 알 수 있습니다.

히스토그램

source('01_box_plots.R')

# We can plot histograms for each level of the cut factor variable using 
facet_grid 
p = ggplot(diamonds, aes(x = price, fill = cut)) + 
   geom_histogram() + 
   facet_grid(cut ~ .) + 
   theme_bw() 

p  
# the previous plot doesn’t allow to visuallize correctly the data because of 
the differences in scale 
# we can turn this off using the scales argument of facet_grid  

p = ggplot(diamonds, aes(x = price, fill = cut)) + 
   geom_histogram() + 
   facet_grid(cut ~ ., scales = 'free') + 
   theme_bw() 
p  

png('02_histogram_diamonds_cut.png') 
print(p) 
dev.off()

위 코드의 출력은 다음과 같습니다.

다변량 그래픽 방법

탐색 적 데이터 분석의 다변량 그래픽 방법은 서로 다른 변수 간의 관계를 찾는 목적을 가지고 있습니다. 일반적으로 사용되는 두 가지 방법이 있습니다. 숫자 변수의 상관 행렬을 플로팅하거나 단순히 원시 데이터를 산점도 행렬로 플로팅하는 것입니다.

이를 증명하기 위해 diamonds 데이터 셋을 사용할 것입니다. 코드를 따르려면 스크립트를 엽니 다.bda/part2/charts/03_multivariate_analysis.R.

library(ggplot2)
data(diamonds) 

# Correlation matrix plots  
keep_vars = c('carat', 'depth', 'price', 'table') 
df = diamonds[, keep_vars]  
# compute the correlation matrix 
M_cor = cor(df) 

#          carat       depth      price      table 
# carat 1.00000000  0.02822431  0.9215913  0.1816175 
# depth 0.02822431  1.00000000 -0.0106474 -0.2957785 
# price 0.92159130 -0.01064740  1.0000000  0.1271339 
# table 0.18161755 -0.29577852  0.1271339  1.0000000  

# plots 
heat-map(M_cor)

코드는 다음 출력을 생성합니다.

이것은 요약이며 가격과 캐럿 사이에 강한 상관 관계가 있으며 다른 변수들 사이에는 그다지 많지 않다는 것을 알려줍니다.

상관 행렬은 원시 데이터를 그리는 것이 실용적이지 않은 변수가 많을 때 유용 할 수 있습니다. 언급했듯이 원시 데이터도 표시 할 수 있습니다.

library(GGally)
ggpairs(df)

히트 맵에 표시된 결과가 확인 된 플롯에서 가격과 캐럿 변수 사이에 0.922의 상관 관계가 있음을 알 수 있습니다.

산점도 행렬의 (3, 1) 인덱스에있는 가격-캐럿 산점도에서이 관계를 시각화 할 수 있습니다.

데이터 과학자가 데이터를 효과적으로 분석 할 수있는 다양한 도구가 있습니다. 일반적으로 데이터 분석의 엔지니어링 측면은 데이터베이스에 중점을두고 데이터 과학자는 데이터 제품을 구현할 수있는 도구에 중점을 둡니다. 다음 섹션에서는 데이터 과학자가 실제로 가장 자주 사용하는 통계 패키지에 초점을 맞춘 다양한 도구의 장점에 대해 설명합니다.

R 프로그래밍 언어

R은 통계 분석에 중점을 둔 오픈 소스 프로그래밍 언어입니다. 통계 기능 측면에서 SAS, SPSS와 같은 상용 도구와 경쟁합니다. C, C ++ 또는 Fortran과 같은 다른 프로그래밍 언어에 대한 인터페이스로 간주됩니다.

R의 또 다른 장점은 사용 가능한 많은 오픈 소스 라이브러리입니다. CRAN에는 무료로 다운로드 할 수있는 6000 개 이상의 패키지가 있습니다.Github 사용 가능한 다양한 R 패키지가 있습니다.

성능 측면에서 R은 사용 가능한 라이브러리가 많고 코드의 느린 섹션이 컴파일 된 언어로 작성되므로 집약적 인 작업에는 느립니다. 그러나 깊은 for 루프를 작성해야하는 작업을 수행하려는 경우 R이 최선의 대안이 아닙니다. 데이터 분석 목적으로 다음과 같은 멋진 라이브러리가 있습니다.data.table, glmnet, ranger, xgboost, ggplot2, caret 더 빠른 프로그래밍 언어에 대한 인터페이스로 R을 사용할 수 있습니다.

데이터 분석을위한 Python

Python은 범용 프로그래밍 언어이며 다음과 같은 데이터 분석에 전념하는 많은 라이브러리를 포함합니다. pandas, scikit-learn, theano, numpyscipy.

R에서 사용할 수있는 대부분의 작업은 Python에서도 수행 할 수 있지만 R이 사용하기 더 쉽다는 것을 알았습니다. 대규모 데이터 세트로 작업하는 경우 일반적으로 Python이 R보다 나은 선택입니다. Python은 데이터를 한 줄씩 정리하고 처리하는 데 매우 효과적으로 사용할 수 있습니다. 이것은 R에서 가능하지만 스크립팅 작업을 위해 Python만큼 효율적이지 않습니다.

머신 러닝의 경우 scikit-learn중간 크기의 데이터 세트를 문제없이 처리 할 수있는 많은 양의 알고리즘을 사용할 수있는 멋진 환경입니다. R의 동등한 라이브러리 (캐럿)와 비교하면scikit-learn 더 깨끗하고 일관된 API가 있습니다.

줄리아

Julia는 기술 컴퓨팅을위한 높은 수준의 고성능 동적 프로그래밍 언어입니다. 구문은 R 또는 Python과 매우 유사하므로 이미 R 또는 Python으로 작업중인 경우 Julia에서 동일한 코드를 작성하는 것이 매우 간단해야합니다. 이 언어는 매우 새롭고 지난 몇 년 동안 크게 성장 했으므로 현재로서는 확실히 옵션입니다.

신경망과 같이 계산 집약적 인 알고리즘 프로토 타이핑에는 Julia를 권장합니다. 연구를위한 훌륭한 도구입니다. 프로덕션에서 모델을 구현하는 측면에서 Python에는 더 나은 대안이 있습니다. 그러나 R, Python 및 Julia에서 모델을 구현하는 엔지니어링을 수행하는 웹 서비스가 있기 때문에 이것은 문제가되지 않습니다.

SAS

SAS는 비즈니스 인텔리전스에 여전히 사용되고있는 상용 언어입니다. 사용자가 다양한 응용 프로그램을 프로그래밍 할 수있는 기본 언어가 있습니다. 비전문가 사용자에게 프로그래밍없이 신경망 라이브러리와 같은 복잡한 도구를 사용할 수있는 기능을 제공하는 몇 가지 상용 제품이 포함되어 있습니다.

상용 도구의 명백한 단점 외에도 SAS는 대규모 데이터 세트로 확장되지 않습니다. 중간 크기의 데이터 세트조차도 SAS에 문제가 발생하고 서버가 충돌합니다. 소규모 데이터 세트로 작업하고 사용자가 전문 데이터 과학자가 아닌 경우에만 SAS를 권장합니다. 고급 사용자를 위해 R 및 Python은보다 생산적인 환경을 제공합니다.

SPSS

SPSS는 현재 통계 분석을위한 IBM의 제품입니다. 주로 설문 조사 데이터를 분석하는 데 사용되며 프로그래밍 할 수없는 사용자에게는 괜찮은 대안입니다. SAS만큼 사용하기 쉽지만 모델 구현 측면에서 모델 점수를 매기는 SQL 코드를 제공하므로 더 간단합니다. 이 코드는 일반적으로 효율적이지 않지만 SAS는 각 데이터베이스에 대해 개별적으로 모델을 평가하는 제품을 판매하는 반면 시작입니다. 소규모 데이터와 경험이없는 팀의 경우 SPSS는 SAS만큼 좋은 옵션입니다.

그러나 소프트웨어는 다소 제한적이며 숙련 된 사용자는 R 또는 Python을 사용하여 훨씬 더 생산적 일 것입니다.

Matlab, 옥타브

Matlab 또는 오픈 소스 버전 (Octave)과 같은 다른 도구를 사용할 수 있습니다. 이 도구는 주로 연구에 사용됩니다. 기능 측면에서 R 또는 Python은 Matlab 또는 Octave에서 사용할 수있는 모든 작업을 수행 할 수 있습니다. 제품이 제공하는 지원에 관심이있는 경우에만 제품 라이센스를 구입하는 것이 합리적입니다.

데이터를 분석 할 때 통계적 접근이 가능합니다. 기본 분석을 수행하는 데 필요한 기본 도구는 다음과 같습니다.

  • 상관 분석
  • 분산 분석
  • 가설 검증

대규모 데이터 세트로 작업 할 때 상관 분석을 제외하고는 이러한 방법이 계산 집약적이지 않기 때문에 문제가 발생하지 않습니다. 이 경우 항상 샘플을 채취 할 수 있으며 결과는 견고해야합니다.

상관 분석

상관 관계 분석은 숫자 변수 간의 선형 관계를 찾습니다. 이것은 다른 상황에서 사용될 수 있습니다. 한 가지 일반적인 용도는 탐색 적 데이터 분석이며,이 책의 섹션 16.0.2에는이 접근 방식의 기본 예가 있습니다. 우선, 언급 된 예에서 사용 된 상관 관계 측정 항목은Pearson coefficient. 그러나 특이 치의 영향을받지 않는 또 다른 흥미로운 상관 관계 지표가 있습니다. 이 측정 항목을 spearman 상관 관계라고합니다.

그만큼 spearman correlation 메트릭은 Pearson 방법보다 특이 치의 존재에 더 강력하며 데이터가 정규 분포를 따르지 않을 때 숫자 변수 간의 선형 관계에 대한 더 나은 추정치를 제공합니다.

library(ggplot2)

# Select variables that are interesting to compare pearson and spearman 
correlation methods. 
x = diamonds[, c('x', 'y', 'z', 'price')]  

# From the histograms we can expect differences in the correlations of both 
metrics.  
# In this case as the variables are clearly not normally distributed, the 
spearman correlation 

# is a better estimate of the linear relation among numeric variables. 
par(mfrow = c(2,2)) 
colnm = names(x) 
for(i in 1:4) { 
   hist(x[[i]], col = 'deepskyblue3', main = sprintf('Histogram of %s', colnm[i])) 
} 
par(mfrow = c(1,1))

다음 그림의 히스토그램에서 두 메트릭의 상관 관계에서 차이를 예상 할 수 있습니다. 이 경우 변수가 분명히 정규 분포를 따르지 않기 때문에 spearman 상관이 숫자 변수 간의 선형 관계를 더 잘 추정합니다.

R의 상관 관계를 계산하려면 파일을 엽니 다. bda/part2/statistical_methods/correlation/correlation.R 이 코드 섹션이 있습니다.

## Correlation Matrix - Pearson and spearman
cor_pearson <- cor(x, method = 'pearson') 
cor_spearman <- cor(x, method = 'spearman')  

### Pearson Correlation 
print(cor_pearson) 
#            x          y          z        price 
# x      1.0000000  0.9747015  0.9707718  0.8844352 
# y      0.9747015  1.0000000  0.9520057  0.8654209 
# z      0.9707718  0.9520057  1.0000000  0.8612494 
# price  0.8844352  0.8654209  0.8612494  1.0000000  

### Spearman Correlation 
print(cor_spearman) 
#              x          y          z      price 
# x      1.0000000  0.9978949  0.9873553  0.9631961 
# y      0.9978949  1.0000000  0.9870675  0.9627188 
# z      0.9873553  0.9870675  1.0000000  0.9572323 
# price  0.9631961  0.9627188  0.9572323  1.0000000

카이 제곱 검정

카이 제곱 테스트를 사용하면 두 개의 랜덤 변수가 독립적인지 테스트 할 수 있습니다. 이는 각 변수의 확률 분포가 다른 변수에 영향을 미치지 않음을 의미합니다. R에서 테스트를 평가하려면 먼저 분할 테이블을 만든 다음 테이블을chisq.test R 함수.

예를 들어, 다이아몬드 데이터 셋의 cut과 color 변수 사이에 연관성이 있는지 확인해 보겠습니다. 테스트는 공식적으로 다음과 같이 정의됩니다.

  • H0 : 가변 컷과 다이아몬드는 독립적입니다.
  • H1 : 가변 컷과 다이아몬드는 독립적이지 않습니다.

이름으로이 두 변수 사이에 관계가 있다고 가정하지만 테스트는이 결과가 얼마나 중요한지 여부를 나타내는 객관적인 "규칙"을 제공 할 수 있습니다.

다음 코드 스 니펫에서 테스트의 p- 값은 2.2e-16이고 실제적으로는 거의 0입니다. 그런 다음 테스트를 실행 한 후Monte Carlo simulation, 우리는 p- 값이 0.0004998로 여전히 임계 값 0.05보다 훨씬 낮다는 것을 발견했습니다. 이 결과는 귀무 가설 (H0)을 기각한다는 것을 의미하므로 변수가cutcolor 독립적이지 않습니다.

library(ggplot2)

# Use the table function to compute the contingency table 
tbl = table(diamonds$cut, diamonds$color) 
tbl  

#              D    E    F    G    H    I    J 
# Fair       163  224  312  314  303  175  119 
# Good       662  933  909  871  702  522  307 
# Very Good 1513 2400 2164 2299 1824 1204  678 
# Premium   1603 2337 2331 2924 2360 1428  808 
# Ideal     2834 3903 3826 4884 3115 2093  896  

# In order to run the test we just use the chisq.test function. 
chisq.test(tbl)  

# Pearson’s Chi-squared test 
# data:  tbl 
# X-squared = 310.32, df = 24, p-value < 2.2e-16
# It is also possible to compute the p-values using a monte-carlo simulation 
# It's needed to add the simulate.p.value = TRUE flag and the amount of 
simulations 
chisq.test(tbl, simulate.p.value = TRUE, B = 2000)  

# Pearson’s Chi-squared test with simulated p-value (based on 2000 replicates) 
# data:  tbl 
# X-squared = 310.32, df = NA, p-value = 0.0004998

T- 테스트

아이디어 t-test명목 변수의 다른 그룹간에 숫자 변수 분포에 차이가 있는지 평가하는 것입니다. 이를 입증하기 위해 요인 변수 컷의 공정 및 이상 수준 수준을 선택한 다음 두 그룹 사이에서 숫자 변수 값을 비교합니다.

data = diamonds[diamonds$cut %in% c('Fair', 'Ideal'), ]

data$cut = droplevels.factor(data$cut) # Drop levels that aren’t used from the 
cut variable 
df1 = data[, c('cut', 'price')]  

# We can see the price means are different for each group 
tapply(df1$price, df1$cut, mean) 
# Fair    Ideal  
# 4358.758 3457.542

t- 검정은 R에서 t.test함수. t.test에 대한 공식 인터페이스는 그것을 사용하는 가장 간단한 방법이며, 아이디어는 숫자 변수가 그룹 변수로 설명된다는 것입니다.

예를 들면 : t.test(numeric_variable ~ group_variable, data = data). 이전 예에서numeric_variable 이다 price 그리고 group_variable 이다 cut.

통계적 관점에서 우리는 두 그룹 간의 숫자 변수 분포에 차이가 있는지 테스트하고 있습니다. 공식적으로 가설 검정은 귀무 (H0) 가설과 대립 가설 (H1)로 설명됩니다.

  • H0 : 공정한 그룹과 이상적인 그룹 간의 가격 변수 분포에는 차이가 없습니다.

  • H1 공정한 그룹과 이상적인 그룹 간의 가격 변수 분포에 차이가 있습니다.

다음 코드를 사용하여 R에서 다음을 구현할 수 있습니다.

t.test(price ~ cut, data = data)

# Welch Two Sample t-test 
#  
# data:  price by cut 
# t = 9.7484, df = 1894.8, p-value < 2.2e-16 
# alternative hypothesis: true difference in means is not equal to 0 
# 95 percent confidence interval: 
#   719.9065 1082.5251 
# sample estimates: 
#   mean in group Fair mean in group Ideal  
#   4358.758            3457.542   

# Another way to validate the previous results is to just plot the 
distributions using a box-plot 
plot(price ~ cut, data = data, ylim = c(0,12000),  
   col = 'deepskyblue3')

p- 값이 0.05 미만인지 확인하여 검정 결과를 분석 할 수 있습니다. 이 경우 대립 가설을 유지합니다. 이는 컷 팩터의 두 수준간에 가격 차이를 발견했음을 의미합니다. 레벨의 이름으로 우리는이 결과를 예상했을 것이지만 실패 그룹의 평균 가격이 이상적인 그룹보다 높을 것이라고는 예상하지 못했을 것입니다. 각 요인의 평균을 비교하여이를 알 수 있습니다.

그만큼 plot명령은 가격과 컷 변수 사이의 관계를 보여주는 그래프를 생성합니다. 이것은 상자 그림입니다. 섹션 16.0.1에서이 플롯을 다루었지만 기본적으로 우리가 분석하는 두 가지 수준의 인하에 대한 가격 변수의 분포를 보여줍니다.

분산 분석

분산 분석 (ANOVA)은 각 그룹의 평균과 분산을 비교하여 그룹 분포 간의 차이를 분석하는 데 사용되는 통계 모델이며, 모델은 Ronald Fisher가 개발했습니다. ANOVA는 여러 그룹의 평균이 같은지 여부에 대한 통계 테스트를 제공하므로 t- 테스트를 세 개 이상의 그룹으로 일반화합니다.

분산 분석은 통계적 유의성에 대해 세 개 이상의 그룹을 비교하는 데 유용합니다. 여러 개의 2- 표본 t- 검정을 수행하면 통계 제 1 종 오류를 범할 가능성이 증가하기 때문입니다.

수학적 설명을 제공하는 측면에서 테스트를 이해하려면 다음이 필요합니다.

x ij = x + (x i − x) + (x ij − x)

이것은 다음 모델로 이어집니다-

x ij = μ + α i + ∈ ij

여기서 μ는 총 평균이고 α i 는 i 번째 그룹 평균입니다. 오차항 ij 는 정규 분포의 iid라고 가정합니다. 검정의 귀무 가설은 다음과 같습니다.

α 1 = α 2 =… = α k

검정 통계량을 계산하려면 두 값을 계산해야합니다.

  • 그룹 차이에 대한 제곱합 −

$$SSD_B = \sum_{i}^{k} \sum_{j}^{n}(\bar{x_{\bar{i}}} - \bar{x})^2$$

  • 그룹 내 제곱의 합

$$SSD_W = \sum_{i}^{k} \sum_{j}^{n}(\bar{x_{\bar{ij}}} - \bar{x_{\bar{i}}})^2$$

여기서 SSD B 의 자유도는 k-1이고 SSD W 의 자유도는 N-k입니다. 그런 다음 각 메트릭에 대한 평균 제곱 차이를 정의 할 수 있습니다.

MS B = SSD B / (k-1)

MS w = SSD w / (N-k)

마지막으로 ANOVA의 검정 통계량은 위의 두 수량의 비율로 정의됩니다.

F = MS B / MS w

k-1N-k 자유도를 갖는 F- 분포를 따릅니다 . 귀무 가설이 참이면 F는 1에 가까울 것입니다. 그렇지 않으면 그룹 간 평균 제곱 MSB가 클 가능성이 높아 F 값이 커집니다.

기본적으로 ANOVA는 총 분산의 두 가지 원인을 조사하고 어떤 부분이 더 많이 기여하는지 확인합니다. 이것이 그룹 평균을 비교하려는 의도이지만 분산 분석이라고하는 이유입니다.

통계를 계산하는 측면에서 실제로 R에서 수행하는 것이 다소 간단합니다. 다음 예제는 수행 방법을 보여주고 결과를 플로팅합니다.

library(ggplot2)
# We will be using the mtcars dataset 

head(mtcars) 
#                    mpg  cyl disp  hp drat  wt  qsec   vs am  gear carb 
# Mazda RX4         21.0   6  160 110 3.90 2.620 16.46  0  1    4    4 
# Mazda RX4 Wag     21.0   6  160 110 3.90 2.875 17.02  0  1    4    4 
# Datsun 710        22.8   4  108  93 3.85 2.320 18.61  1  1    4    1 
# Hornet 4 Drive    21.4   6  258 110 3.08 3.215 19.44  1  0    3    1 
# Hornet Sportabout 18.7   8  360 175 3.15 3.440 17.02  0  0    3    2 
# Valiant           18.1   6  225 105 2.76 3.460 20.22  1  0    3    1  

# Let's see if there are differences between the groups of cyl in the mpg variable. 
data = mtcars[, c('mpg', 'cyl')]  
fit = lm(mpg ~ cyl, data = mtcars) 
anova(fit)  

# Analysis of Variance Table 
# Response: mpg 
#           Df Sum Sq Mean Sq F value    Pr(>F)     
# cyl        1 817.71  817.71  79.561 6.113e-10 *** 
# Residuals 30 308.33   10.28 
# Signif. codes:  0 *** 0.001 ** 0.01 * 0.05 . 
# Plot the distribution 
plot(mpg ~ as.factor(cyl), data = mtcars, col = 'deepskyblue3')

코드는 다음 출력을 생성합니다.

예제에서 얻은 p- 값은 0.05보다 훨씬 작으므로 R은이를 나타내는 기호 '***'를 반환합니다. 그것은 우리가 귀무 가설을 기각하고 다른 그룹들 사이에서 mpg 평균 사이의 차이를 발견한다는 것을 의미합니다.cyl 변하기 쉬운.

기계 학습은 패턴 인식, 컴퓨터 비전, 음성 인식, 텍스트 분석과 같은 작업을 처리하는 컴퓨터 과학의 하위 분야이며 통계 및 수학적 최적화와 밀접한 관련이 있습니다. 애플리케이션에는 검색 엔진 개발, 스팸 필터링, 광학 문자 인식 (OCR) 등이 포함됩니다. 데이터 마이닝, 패턴 인식 및 통계 학습 분야 간의 경계는 명확하지 않으며 기본적으로 모두 유사한 문제를 나타냅니다.

기계 학습은 두 가지 유형의 작업으로 나눌 수 있습니다.

  • 지도 학습
  • 비지도 학습

지도 학습

지도 학습은 행렬 X 로 정의 된 입력 데이터 가 있고 응답 y 예측에 관심 이있는 문제 유형을 나타냅니다 . 여기서 X = {x 1 , x 2 ,…, x n } 에는 n 개의 예측 변수가 있고 두 개의 값 y = {c 1 , c 2 }가 있습니다.

예제 애플리케이션은 인구 통계 학적 특징을 예측 변수로 사용하여 웹 사용자가 광고를 클릭 할 확률을 예측하는 것입니다. 클릭률 (CTR)을 예측하기 위해 종종 호출됩니다. 그런 다음 y = {클릭, 안 함 − 클릭} 및 예측 변수는 사용 된 IP 주소, 사이트에 들어간 날짜, 사용자의 도시, 국가 등 사용 가능한 다른 기능이 될 수 있습니다.

비지도 학습

비지도 학습은 배울 수업없이 서로 비슷한 그룹을 찾는 문제를 다룹니다. 예측 변수에서 매핑을 학습하여 각 그룹에서 유사한 인스턴스를 공유하고 서로 다른 그룹을 찾는 작업에는 여러 가지 접근 방식이 있습니다.

비지도 학습의 예제 응용 프로그램은 고객 세분화입니다. 예를 들어, 통신 산업에서 일반적인 작업은 사용자가 전화기에 제공하는 사용량에 따라 사용자를 분류하는 것입니다. 이를 통해 마케팅 부서는 다른 제품으로 각 그룹을 타겟팅 할 수 있습니다.

Naive Bayes는 분류기를 구성하기위한 확률 적 기법입니다. naive Bayes 분류기의 특성 가정은 특정 특성의 값이 클래스 변수가 주어지면 다른 특성의 값과 무관하다고 간주하는 것입니다.

앞서 언급 한 지나치게 단순화 된 가정에도 불구하고 naive Bayes 분류기는 복잡한 실제 상황에서 좋은 결과를 제공합니다. naive Bayes의 장점은 분류에 필요한 매개 변수를 추정하는 데 소량의 학습 데이터 만 필요하고 분류기를 점진적으로 학습 할 수 있다는 것입니다.

Naive Bayes는 조건부 확률 모델입니다. 분류 할 문제 인스턴스가 주어지면 벡터로 표시됩니다. x= (x 1 ,…, x n ) 일부 n 개의 기능 (독립 변수)을 나타내는 경우 K 개의 가능한 결과 또는 클래스 각각에 대해이 인스턴스 확률에 할당합니다.

$$p(C_k|x_1,....., x_n)$$

위 공식의 문제점은 특성의 개수 n이 크거나 특성이 많은 수의 값을 가질 수있는 경우 확률 테이블을 기반으로 이러한 모델을 기반으로하는 것이 불가능하다는 것입니다. 따라서 모델을 더 간단하게 재구성합니다. Bayes 정리를 사용하여 조건부 확률은 다음과 같이 분해 될 수 있습니다.

$$p(C_k|x) = \frac{p(C_k)p(x|C_k)}{p(x)}$$

이는 위의 독립 가정 하에서 클래스 변수 C에 대한 조건부 분포가 다음과 같음을 의미합니다.

$$p(C_k|x_1,....., x_n)\: = \: \frac{1}{Z}p(C_k)\prod_{i = 1}^{n}p(x_i|C_k)$$

증거 Z = p (x)는 x 1 ,…, x n 에만 의존하는 스케일링 인자 이며, 특성 변수의 값이 알려진 경우 상수입니다. 한 가지 일반적인 규칙은 가장 가능성이 높은 가설을 선택하는 것입니다. 이것은 최대 사후 또는 MAP 결정 규칙으로 알려져 있습니다. 해당 분류 기인 Bayes 분류기는 클래스 레이블을 할당하는 기능입니다.$\hat{y} = C_k$ 다음과 같이 일부 k에 대해-

$$\hat{y} = argmax\: p(C_k)\prod_{i = 1}^{n}p(x_i|C_k)$$

R에서 알고리즘을 구현하는 것은 간단한 프로세스입니다. 다음 예제는 Naive Bayes 분류기를 학습시키고 스팸 필터링 문제의 예측에 사용하는 방법을 보여줍니다.

다음 스크립트는 bda/part3/naive_bayes/naive_bayes.R 파일.

# Install these packages 
pkgs = c("klaR", "caret", "ElemStatLearn") 
install.packages(pkgs)  
library('ElemStatLearn') 
library("klaR") 
library("caret")  

# Split the data in training and testing 
inx = sample(nrow(spam), round(nrow(spam) * 0.9)) 
train = spam[inx,] 
test = spam[-inx,]  

# Define a matrix with features, X_train 
# And a vector with class labels, y_train 
X_train = train[,-58] 
y_train = train$spam X_test = test[,-58] y_test = test$spam  
# Train the model 
nb_model = train(X_train, y_train, method = 'nb',  
   trControl = trainControl(method = 'cv', number = 3)) 

# Compute  
preds = predict(nb_model$finalModel, X_test)$class 
tbl = table(y_test, yhat = preds) 
sum(diag(tbl)) / sum(tbl) 
# 0.7217391

결과에서 알 수 있듯이 Naive Bayes 모델의 정확도는 72 %입니다. 이는 모델이 인스턴스의 72 %를 올바르게 분류 함을 의미합니다.

k- 평균 군집화는 n 개의 관측치를 k 개의 군집으로 분할하는 것을 목표로하며, 각 관측치는 가장 가까운 평균을 가진 군집에 속하며 군집의 원형 역할을합니다. 이로 인해 데이터 공간이 Voronoi 셀로 분할됩니다.

각 관측 값이 d 차원 실수 벡터 인 일련의 관측 값 (x 1 , x 2 ,…, x n )이 주어지면 k- 평균 클러스터링은 n 개의 관측치를 k 그룹으로 분할하는 것을 목표로합니다. G = {G 1 , G 2 ,…, G k } 다음과 같이 정의 된 클러스터 내 제곱합 (WCSS)을 최소화하기 위해-

$$argmin \: \sum_{i = 1}^{k} \sum_{x \in S_{i}}\parallel x - \mu_{i}\parallel ^2$$

이후의 공식은 k- 평균 클러스터링에서 최적의 원형을 찾기 위해 최소화되는 목적 함수를 보여줍니다. 공식의 직관은 우리가 서로 다른 그룹을 찾고자하며 각 그룹의 각 구성원은 각 클러스터의 다른 구성원과 유사해야한다는 것입니다.

다음 예제는 R에서 k- 평균 클러스터링 알고리즘을 실행하는 방법을 보여줍니다.

library(ggplot2)
# Prepare Data 
data = mtcars  

# We need to scale the data to have zero mean and unit variance 
data <- scale(data)  

# Determine number of clusters 
wss <- (nrow(data)-1)*sum(apply(data,2,var)) 
for (i in 2:dim(data)[2]) { 
   wss[i] <- sum(kmeans(data, centers = i)$withinss) 
}  

# Plot the clusters 
plot(1:dim(data)[2], wss, type = "b", xlab = "Number of Clusters", 
   ylab = "Within groups sum of squares")

K에 대한 좋은 값을 찾기 위해 K의 다른 값에 대한 그룹 내 제곱합을 그릴 수 있습니다.이 메트릭은 일반적으로 더 많은 그룹이 추가 될수록 감소합니다. 우리는 그룹 내에서 감소가 합산되는 지점을 찾고 싶습니다. 제곱의 수가 천천히 감소하기 시작합니다. 플롯에서이 값은 K = 6으로 가장 잘 표현됩니다.

이제 K 값이 정의되었으므로 해당 값으로 알고리즘을 실행해야합니다.

# K-Means Cluster Analysis
fit <- kmeans(data, 5) # 5 cluster solution 

# get cluster means  
aggregate(data,by = list(fit$cluster),FUN = mean) 

# append cluster assignment 
data <- data.frame(data, fit$cluster)

하자 내가 I = 1 전, 2 , ..., i가 n 개의 항목이라는 세트 N 이진 속성을합니다. D = t 1 , t 2 , ..., t m을 데이터베이스라고하는 일련의 트랜잭션이라고 합시다 . D의 각 트랜잭션은 고유 한 트랜잭션 ID를 가지며 I에있는 항목의 하위 집합을 포함합니다. 규칙은 X ⇒ Y 형식의 의미로 정의됩니다. 여기서 X, Y ⊆ I 및 X ∩ Y = ∅.

항목 세트 (짧은 항목 세트의 경우) X 및 Y는 규칙의 선행 (왼쪽 또는 LHS) 및 결과 (오른쪽 또는 RHS)라고합니다.

개념을 설명하기 위해 슈퍼마켓 도메인의 작은 예를 사용합니다. 항목 집합은 I = {우유, 빵, 버터, 맥주}이며 항목이 포함 된 작은 데이터베이스가 다음 표에 나와 있습니다.

거래 ID 아이템
1 우유, 빵
2 빵, 버터
맥주
4 우유, 빵, 버터
5 빵, 버터

슈퍼마켓에 대한 규칙의 예는 {milk, bread} ⇒ {butter} 일 수 있습니다. 즉, 우유와 빵을 구매하면 고객도 버터를 구매합니다. 가능한 모든 규칙 집합에서 흥미로운 규칙을 선택하기 위해 다양한 중요도와 관심도에 대한 제약 조건을 사용할 수 있습니다. 가장 잘 알려진 제약은 지원 및 신뢰에 대한 최소 임계 값입니다.

항목 세트 X의 지원 supp (X)는 항목 세트를 포함하는 데이터 세트의 트랜잭션 비율로 정의됩니다. 표 1의 예제 데이터베이스에서 항목 세트 {milk, bread}는 모든 트랜잭션의 40 % (5 개 트랜잭션 중 2 개)에서 발생하므로 2/5 = 0.4를 지원합니다. 자주 항목 세트를 찾는 것은 비지도 학습 문제의 단순화로 볼 수 있습니다.

규칙의 신뢰도는 conf (X ⇒ Y) = supp (X ∪ Y) / supp (X)로 정의됩니다. 예를 들어, {milk, bread} ⇒ {butter} 규칙은 표 1의 데이터베이스에서 0.2 / 0.4 = 0.5의 신뢰도를 가지며 이는 우유와 빵을 포함하는 트랜잭션의 50 %에 대해 규칙이 정확함을 의미합니다. 신뢰는 확률 P (Y | X)의 추정치로 해석 될 수 있습니다. 이러한 트랜잭션에도 LHS가 포함된다는 조건 하에서 트랜잭션에서 규칙의 RHS를 찾을 확률입니다.

에있는 스크립트에서 bda/part3/apriori.R 구현하는 코드 apriori algorithm 찾을수있다.

# Load the library for doing association rules
# install.packages(’arules’) 
library(arules)  

# Data preprocessing 
data("AdultUCI") 
AdultUCI[1:2,]  
AdultUCI[["fnlwgt"]] <- NULL 
AdultUCI[["education-num"]] <- NULL  

AdultUCI[[ "age"]] <- ordered(cut(AdultUCI[[ "age"]], c(15,25,45,65,100)), 
   labels = c("Young", "Middle-aged", "Senior", "Old")) 
AdultUCI[[ "hours-per-week"]] <- ordered(cut(AdultUCI[[ "hours-per-week"]], 
   c(0,25,40,60,168)), labels = c("Part-time", "Full-time", "Over-time", "Workaholic")) 
AdultUCI[[ "capital-gain"]] <- ordered(cut(AdultUCI[[ "capital-gain"]], 
   c(-Inf,0,median(AdultUCI[[ "capital-gain"]][AdultUCI[[ "capitalgain"]]>0]),Inf)), 
   labels = c("None", "Low", "High")) 
AdultUCI[[ "capital-loss"]] <- ordered(cut(AdultUCI[[ "capital-loss"]], 
   c(-Inf,0, median(AdultUCI[[ "capital-loss"]][AdultUCI[[ "capitalloss"]]>0]),Inf)), 
   labels = c("none", "low", "high"))

apriori 알고리즘을 사용하여 규칙을 생성하려면 트랜잭션 매트릭스를 만들어야합니다. 다음 코드는 R에서이를 수행하는 방법을 보여줍니다.

# Convert the data into a transactions format
Adult <- as(AdultUCI, "transactions") 
Adult 
# transactions in sparse format with 
# 48842 transactions (rows) and 
# 115 items (columns)  

summary(Adult)  
# Plot frequent item-sets 
itemFrequencyPlot(Adult, support = 0.1, cex.names = 0.8)  

# generate rules 
min_support = 0.01 
confidence = 0.6 
rules <- apriori(Adult, parameter = list(support = min_support, confidence = confidence))

rules 
inspect(rules[100:110, ]) 
# lhs                             rhs                      support     confidence  lift
# {occupation = Farming-fishing} => {sex = Male}        0.02856148  0.9362416   1.4005486
# {occupation = Farming-fishing} => {race = White}      0.02831579  0.9281879   1.0855456
# {occupation = Farming-fishing} => {native-country     0.02671881  0.8758389   0.9759474
                                       = United-States}

의사 결정 트리는 분류 또는 회귀와 같은지도 학습 문제에 사용되는 알고리즘입니다. 의사 결정 트리 또는 분류 트리는 각 내부 (비 리프) 노드가 입력 기능으로 레이블이 지정된 트리입니다. 피쳐로 레이블이 지정된 노드에서 나오는 호에는 피쳐의 가능한 각 값으로 레이블이 지정됩니다. 트리의 각 잎은 클래스 또는 클래스에 대한 확률 분포로 레이블이 지정됩니다.

속성 값 테스트를 기반으로 소스 세트를 서브 세트로 분할하여 트리를 "학습"할 수 있습니다. 이 프로세스는 파생 된 각 하위 집합에서 다음과 같은 재귀적인 방식으로 반복됩니다.recursive partitioning. 재귀는 노드의 하위 집합이 모두 동일한 대상 변수 값을 갖거나 분할이 더 이상 예측에 값을 추가하지 않을 때 완료됩니다. 의사 결정 트리의 하향식 유도 프로세스는 탐욕스러운 알고리즘의 예이며 의사 결정 트리를 학습하는 가장 일반적인 전략입니다.

데이터 마이닝에 사용되는 의사 결정 트리는 두 가지 주요 유형입니다.

  • Classification tree − 응답이 명목 변수 인 경우 (예 : 이메일이 스팸인지 여부).

  • Regression tree − 예측 된 결과가 실수로 간주 될 수있는 경우 (예 : 근로자의 급여).

의사 결정 트리는 간단한 방법이므로 몇 가지 문제가 있습니다. 이 문제 중 하나는 의사 결정 트리가 생성하는 결과 모델의 높은 분산입니다. 이 문제를 완화하기 위해 의사 결정 트리의 앙상블 방법이 개발되었습니다. 현재 광범위하게 사용되는 두 그룹의 앙상블 방법이 있습니다.

  • Bagging decision trees−이 트리는 훈련 데이터를 반복적으로 리샘플링하여 교체하고 합의 예측을 위해 트리에 투표하여 여러 의사 결정 트리를 구축하는 데 사용됩니다. 이 알고리즘을 랜덤 포레스트라고합니다.

  • Boosting decision trees− 그라디언트 부스팅은 약한 학습자를 결합합니다. 이 경우 의사 결정 트리를 반복적 인 방식으로 강력한 단일 학습자로 전환합니다. 데이터에 약한 트리를 맞추고 이전 모델의 오류를 수정하기 위해 반복적으로 약한 학습자를 계속 맞추고 있습니다.

# Install the party package
# install.packages('party') 
library(party) 
library(ggplot2)  

head(diamonds) 
# We will predict the cut of diamonds using the features available in the 
diamonds dataset. 
ct = ctree(cut ~ ., data = diamonds) 

# plot(ct, main="Conditional Inference Tree") 
# Example output 
# Response:  cut  
# Inputs:  carat, color, clarity, depth, table, price, x, y, z  

# Number of observations:  53940  
#  
# 1) table <= 57; criterion = 1, statistic = 10131.878 
#   2) depth <= 63; criterion = 1, statistic = 8377.279 
#     3) table <= 56.4; criterion = 1, statistic = 226.423 
#       4) z <= 2.64; criterion = 1, statistic = 70.393 
#         5) clarity <= VS1; criterion = 0.989, statistic = 10.48 
#           6) color <= E; criterion = 0.997, statistic = 12.829 
#             7)*  weights = 82  
#           6) color > E  

#Table of prediction errors 
table(predict(ct), diamonds$cut) 
#            Fair  Good Very Good Premium Ideal 
# Fair       1388   171        17       0    14 
# Good        102  2912       499      26    27 
# Very Good    54   998      3334     249   355 
# Premium      44   711      5054   11915  1167 
# Ideal        22   114      3178    1601 19988 
# Estimated class probabilities 
probs = predict(ct, newdata = diamonds, type = "prob") 
probs = do.call(rbind, probs) 
head(probs)

로지스틱 회귀는 반응 변수가 범주 형인 분류 모델입니다. 통계에서 비롯된 알고리즘이며 감독 된 분류 문제에 사용됩니다. 로지스틱 회귀에서 우리는 비용 함수를 최소화하는 다음 방정식에서 매개 변수의 벡터 β를 찾으려고합니다.

$$logit(p_i) = ln \left ( \frac{p_i}{1 - p_i} \right ) = \beta_0 + \beta_1x_{1,i} + ... + \beta_kx_{k,i}$$

다음 코드는 R에서 로지스틱 회귀 모델을 맞추는 방법을 보여줍니다. 여기서는 Naive Bayes에 사용 된 것과 동일한 로지스틱 회귀를 보여주기 위해 스팸 데이터 세트를 사용할 것입니다.

정확도 측면에서 예측 결과를 통해 회귀 모델은 테스트 세트에서 92.5 %의 정확도를 달성했으며 Naive Bayes 분류기에 의해 달성 된 72 %의 정확도를 달성했습니다.

library(ElemStatLearn)
head(spam) 

# Split dataset in training and testing 
inx = sample(nrow(spam), round(nrow(spam) * 0.8)) 
train = spam[inx,] 
test = spam[-inx,]  

# Fit regression model 
fit = glm(spam ~ ., data = train, family = binomial()) 
summary(fit)  

# Call: 
#   glm(formula = spam ~ ., family = binomial(), data = train) 
#  

# Deviance Residuals:  
#   Min       1Q   Median       3Q      Max   
# -4.5172  -0.2039   0.0000   0.1111   5.4944
# Coefficients: 
# Estimate Std. Error z value Pr(>|z|)     
# (Intercept) -1.511e+00  1.546e-01  -9.772  < 2e-16 *** 
# A.1         -4.546e-01  2.560e-01  -1.776 0.075720 .   
# A.2         -1.630e-01  7.731e-02  -2.108 0.035043 *   
# A.3          1.487e-01  1.261e-01   1.179 0.238591     
# A.4          2.055e+00  1.467e+00   1.401 0.161153     
# A.5          6.165e-01  1.191e-01   5.177 2.25e-07 *** 
# A.6          7.156e-01  2.768e-01   2.585 0.009747 **  
# A.7          2.606e+00  3.917e-01   6.652 2.88e-11 *** 
# A.8          6.750e-01  2.284e-01   2.955 0.003127 **  
# A.9          1.197e+00  3.362e-01   3.559 0.000373 *** 
# Signif. codes:  0 *** 0.001 ** 0.01 * 0.05 . 0.1  1  

### Make predictions 
preds = predict(fit, test, type = ’response’) 
preds = ifelse(preds > 0.5, 1, 0) 
tbl = table(target = test$spam, preds) 
tbl 

#         preds 
# target    0   1 
# email   535  23 
# spam     46 316 
sum(diag(tbl)) / sum(tbl) 
# 0.925

시계열은 날짜 또는 타임 스탬프에 의해 인덱싱 된 범주 형 또는 숫자 변수의 관측 시퀀스입니다. 시계열 데이터의 명확한 예는 주가의 시계열입니다. 다음 표에서 시계열 데이터의 기본 구조를 볼 수 있습니다. 이 경우 관찰은 매시간 기록됩니다.

타임 스탬프 재고-가격
2015-10-11 09:00:00 100
2015-10-11 10:00:00 110
2015-10-11 11:00:00 105
2015-10-11 12:00:00 90
2015-10-11 13:00:00 120

일반적으로 시계열 분석의 첫 번째 단계는 시리즈를 그리는 것입니다. 이는 일반적으로 선 차트로 수행됩니다.

시계열 분석의 가장 일반적인 응용 프로그램은 데이터의 시간적 구조를 사용하여 숫자 값의 미래 값을 예측하는 것입니다. 즉, 사용 가능한 관측치는 미래의 값을 예측하는 데 사용됩니다.

데이터의 시간적 순서는 전통적인 회귀 방법이 유용하지 않음을 의미합니다. 강력한 예측을 구축하려면 데이터의 시간적 순서를 고려하는 모델이 필요합니다.

시계열 분석에 가장 널리 사용되는 모델은 Autoregressive Moving Average(ARMA). 모델은 두 부분으로 구성됩니다.autoregressive (AR) 부분과 moving average(MA) 부분. 그런 다음 모델은 일반적으로 ARMA (p, q) 모델이라고합니다. 여기서 p 는 자기 회귀 부분 의 차수 이고 q 는 이동 평균 부분의 차수입니다.

자기 회귀 모형

AR (p)의 차 (P)의 자기 회귀 모델로 판독된다. 수학적으로 다음과 같이 작성됩니다.

$$ X_t = c + \ sum_ {i = 1} ^ {P} \ phi_i X_ {t-i} + \ varepsilon_ {t} $$

여기서 {φ 1 ,…, φ p }는 추정 할 매개 변수이고, c는 상수이고, 랜덤 변수 ε t 는 백색 잡음을 나타냅니다. 모델이 고정 된 상태로 유지되도록 매개 변수 값에 대한 일부 구속이 필요합니다.

이동 평균

표기 MA (Q)는 주문의 이동 평균 모델을 말한다 Q -

$$ X_t = \ mu + \ varepsilon_t + \ sum_ {i = 1} ^ {q} \ theta_i \ varepsilon_ {t-i} $$

여기서 θ 1 , ..., θ q 는 모델의 매개 변수이고, μ는 X t 의 기대 값 이고, ε t , ε t − 1 , ...은 백색 잡음 오류 항입니다.

자기 회귀 이동 평균

ARMA (P, Q) 모델 콤바인 P는 회귀 조건 및 Q 이동 평균 용어. 수학적으로 모델은 다음 공식으로 표현됩니다.

$$ X_t = c + \ varepsilon_t + \ sum_ {i = 1} ^ {P} \ phi_iX_ {t-1} + \ sum_ {i = 1} ^ {q} \ theta_i \ varepsilon_ {ti} $$

우리는 것을 알 수 있습니다 ARMA (P, Q) 모델의 조합 AR (P)MA (Q) 모델.

모델의 일부 직관을 제공하기 위해 방정식의 AR 부분이 X에 대한 매개 변수를 추정하고자하는 것이 생각 난 - t X의에서 변수의 값을 예측하기 위해 관찰을 t을 . 결국 과거 값의 가중 평균입니다. MA 섹션은 동일한 접근 방식을 사용하지만 이전 관측치의 오류 인 ε t − i를 사용 합니다. 결국 모델의 결과는 가중 평균입니다.

다음 코드 스 니펫 은 R에서 ARMA (p, q) 를 구현하는 방법을 보여줍니다 .

# install.packages("forecast")
library("forecast")  

# Read the data 
data = scan('fancy.dat') 
ts_data <- ts(data, frequency = 12, start = c(1987,1)) 
ts_data  
plot.ts(ts_data)

데이터 플로팅은 일반적으로 데이터에 시간 구조가 있는지 확인하는 첫 번째 단계입니다. 플롯에서 매년 말에 강한 급등이 있음을 알 수 있습니다.

다음 코드는 ARMA 모델을 데이터에 맞 춥니 다. 여러 모델 조합을 실행하고 오류가 적은 모델을 선택합니다.

# Fit the ARMA model
fit = auto.arima(ts_data) 
summary(fit) 

# Series: ts_data  
# ARIMA(1,1,1)(0,1,1)[12]                     
#    Coefficients: 
#    ar1     ma1    sma1 
# 0.2401  -0.9013  0.7499 
# s.e.  0.1427   0.0709  0.1790 

#  
# sigma^2 estimated as 15464184:  log likelihood = -693.69 
# AIC = 1395.38   AICc = 1395.98   BIC = 1404.43 

# Training set error measures: 
#                 ME        RMSE      MAE        MPE        MAPE      MASE       ACF1 
# Training set   328.301  3615.374  2171.002  -2.481166  15.97302  0.4905797 -0.02521172

이 장에서는 책의 1 부에서 긁어 낸 데이터를 사용합니다. 데이터에는 프리랜서의 프로필과 그들이 부과하는 시간당 요금이 USD로 설명 된 텍스트가 있습니다. 다음 섹션의 아이디어는 프리랜서의 기술을 고려하여 시간당 급여를 예측할 수있는 모델을 맞추는 것입니다.

다음 코드는이 경우 단어 모음 매트릭스에서 사용자의 기술을 보유한 원시 텍스트를 변환하는 방법을 보여줍니다. 이를 위해 tm이라는 R 라이브러리를 사용합니다. 이것은 말뭉치의 각 단어에 대해 각 변수의 발생 횟수로 변수를 생성한다는 것을 의미합니다.

library(tm)
library(data.table)  

source('text_analytics/text_analytics_functions.R') 
data = fread('text_analytics/data/profiles.txt') 
rate = as.numeric(data$rate) 
keep = !is.na(rate) 
rate = rate[keep]  

### Make bag of words of title and body 
X_all = bag_words(data$user_skills[keep]) 
X_all = removeSparseTerms(X_all, 0.999) 
X_all 

# <<DocumentTermMatrix (documents: 389, terms: 1422)>> 
#   Non-/sparse entries: 4057/549101 
# Sparsity           : 99% 
# Maximal term length: 80 
# Weighting          : term frequency - inverse document frequency (normalized) (tf-idf) 

### Make a sparse matrix with all the data 
X_all <- as_sparseMatrix(X_all)

이제 희소 행렬로 표시된 텍스트가 있으므로 희소 솔루션을 제공 할 모델을 맞출 수 있습니다. 이 경우에 대한 좋은 대안은 LASSO (최소 절대 축소 및 선택 연산자)를 사용하는 것입니다. 목표를 예측하기 위해 가장 관련성이 높은 특징을 선택할 수있는 회귀 모델입니다.

train_inx = 1:200
X_train = X_all[train_inx, ] 
y_train = rate[train_inx]  
X_test = X_all[-train_inx, ] 
y_test = rate[-train_inx]  

# Train a regression model 
library(glmnet) 
fit <- cv.glmnet(x = X_train, y = y_train,  
   family = 'gaussian', alpha = 1,  
   nfolds = 3, type.measure = 'mae') 
plot(fit)  

# Make predictions 
predictions = predict(fit, newx = X_test) 
predictions = as.vector(predictions[,1]) 
head(predictions)  

# 36.23598 36.43046 51.69786 26.06811 35.13185 37.66367 
# We can compute the mean absolute error for the test data 
mean(abs(y_test - predictions)) 
# 15.02175

이제 우리는 일련의 기술이 프리랜서의 시간당 급여를 예측할 수있는 모델을 가지고 있습니다. 더 많은 데이터가 수집되면 모델의 성능이 향상되지만이 파이프 라인을 구현하는 코드는 동일합니다.

온라인 학습은지도 학습 모델을 대규모 데이터 세트로 확장 할 수있는 기계 학습의 하위 분야입니다. 기본 아이디어는 모델에 맞추기 위해 메모리의 모든 데이터를 읽을 필요가 없으며 한 번에 각 인스턴스 만 읽으면된다는 것입니다.

이 경우 로지스틱 회귀를 사용하여 온라인 학습 알고리즘을 구현하는 방법을 보여줍니다. 대부분의지도 학습 알고리즘과 마찬가지로 최소화 된 비용 함수가 있습니다. 로지스틱 회귀에서 비용 함수는 다음과 같이 정의됩니다.

$$ J (\ theta) \ : = \ : \ frac {-1} {m} \ left [\ sum_ {i = 1} ^ {m} y ^ {(i)} log (h _ {\ theta} ( x ^ {(i)})) + (1-y ^ {(i)}) log (1-h _ {\ theta} (x ^ {(i)})) \ right] $$

여기서 J (θ) 는 비용 함수를 나타내고 h θ (x) 는 가설을 나타냅니다. 로지스틱 회귀의 경우 다음 공식으로 정의됩니다.

$$ h_ \ theta (x) = \ frac {1} {1 + e ^ {\ theta ^ T x}} $$

비용 함수를 정의 했으므로이를 최소화 할 알고리즘을 찾아야합니다. 이를 달성하기위한 가장 간단한 알고리즘은 확률 적 경사 하강 법이라고합니다. 로지스틱 회귀 모델의 가중치에 대한 알고리즘의 업데이트 규칙은 다음과 같이 정의됩니다.

$$ \ theta_j : = \ theta_j-\ alpha (h_ \ theta (x)-y) x $$

다음 알고리즘의 여러 구현이 있지만 vowpal wabbit 라이브러리 에서 구현 된 것이 가장 많이 개발 된 것입니다. 이 라이브러리는 대규모 회귀 모델의 훈련을 허용하고 소량의 RAM을 사용합니다. 제작자 자신의 말로는 "Vowpal Wabbit (VW) 프로젝트는 Microsoft Research와 (이전) Yahoo! Research가 후원하는 빠른 핵심 학습 시스템입니다"라고 설명되어 있습니다.)

우리는 타이타닉 데이터 셋으로 작업 할 것입니다. kaggle경쟁. 원본 데이터는bda/part3/vw폴더. 여기에 두 개의 파일이 있습니다.

  • 훈련 데이터 (train_titanic.csv)가 있고
  • 새로운 예측을 위해 라벨이없는 데이터 (test_titanic.csv).

csv 형식을 vowpal wabbit 입력 형식은 csv_to_vowpal_wabbit.py파이썬 스크립트. 이를 위해서는 분명히 파이썬이 설치되어 있어야합니다. 다음으로 이동bda/part3/vw 폴더에서 터미널을 열고 다음 명령을 실행하십시오-

python csv_to_vowpal_wabbit.py

이 섹션의 경우 Windows를 사용하는 경우 Unix 명령 줄을 설치해야하며이를 위해 cygwin 웹 사이트를 입력해야 합니다.

터미널과 폴더를 엽니 다. bda/part3/vw 다음 명령을 실행하십시오-

vw train_titanic.vw -f model.vw --binary --passes 20 -c -q ff --sgd --l1 
0.00000001 --l2 0.0000001 --learning_rate 0.5 --loss_function logistic

의 각 주장을 분석하자 vw call 방법.

  • -f model.vw − 나중에 예측하기 위해 model.vw 파일에 모델을 저장하고 있음을 의미합니다.

  • --binary − -1,1 레이블이있는 이진 분류로 손실을보고합니다.

  • --passes 20 − 데이터는 가중치를 학습하기 위해 20 회 사용됩니다.

  • -c − 캐시 파일 생성

  • -q ff − f 네임 스페이스에서 2 차 기능 사용

  • --sgd − 정규 / 클래식 / 단순 확률 적 경사 하강 법 업데이트 (예 : 비 적응, 비정규 화 및 비 불변)를 사용합니다.

  • --l1 --l2 − L1 및 L2 노름 정규화

  • --learning_rate 0.5 − 업데이트 규칙 공식에 정의 된 학습률 α

다음 코드는 명령 줄에서 회귀 모델을 실행 한 결과를 보여줍니다. 결과에서 우리는 평균 로그 손실과 알고리즘 성능에 대한 작은 보고서를 얻습니다.

-loss_function logistic
creating quadratic features for pairs: ff  
using l1 regularization = 1e-08 
using l2 regularization = 1e-07 

final_regressor = model.vw 
Num weight bits = 18 
learning rate = 0.5 
initial_t = 1 
power_t = 0.5 
decay_learning_rate = 1 
using cache_file = train_titanic.vw.cache 
ignoring text input in favor of cache input 
num sources = 1 

average    since         example   example  current  current  current 
loss       last          counter   weight    label   predict  features 
0.000000   0.000000          1      1.0    -1.0000   -1.0000       57 
0.500000   1.000000          2      2.0     1.0000   -1.0000       57 
0.250000   0.000000          4      4.0     1.0000    1.0000       57 
0.375000   0.500000          8      8.0    -1.0000   -1.0000       73 
0.625000   0.875000         16     16.0    -1.0000    1.0000       73 
0.468750   0.312500         32     32.0    -1.0000   -1.0000       57 
0.468750   0.468750         64     64.0    -1.0000    1.0000       43 
0.375000   0.281250        128    128.0     1.0000   -1.0000       43 
0.351562   0.328125        256    256.0     1.0000   -1.0000       43 
0.359375   0.367188        512    512.0    -1.0000    1.0000       57 
0.274336   0.274336       1024   1024.0    -1.0000   -1.0000       57 h 
0.281938   0.289474       2048   2048.0    -1.0000   -1.0000       43 h 
0.246696   0.211454       4096   4096.0    -1.0000   -1.0000       43 h 
0.218922   0.191209       8192   8192.0     1.0000    1.0000       43 h 

finished run 
number of examples per pass = 802 
passes used = 11 
weighted example sum = 8822 
weighted label sum = -2288 
average loss = 0.179775 h 
best constant = -0.530826 
best constant’s loss = 0.659128 
total feature number = 427878

이제 우리는 model.vw 우리는 새로운 데이터로 예측을 생성하도록 훈련했습니다.

vw -d test_titanic.vw -t -i model.vw -p predictions.txt

이전 명령에서 생성 된 예측은 [0, 1] 범위에 맞도록 정규화되지 않았습니다. 이를 위해 시그 모이 드 변환을 사용합니다.

# Read the predictions
preds = fread('vw/predictions.txt')  

# Define the sigmoid function 
sigmoid = function(x) { 
   1 / (1 + exp(-x)) 
} 
probs = sigmoid(preds[[1]])  

# Generate class labels 
preds = ifelse(probs > 0.5, 1, 0) 
head(preds) 
# [1] 0 1 0 0 1 0