데이터 분석 공부

[R] 콘크리트 내구성 예측 - 인공신경망

dori_0 — Fri, 3 Jun 2022 20:44:09 +0900

콘크리트 내구성 예측

인공신경망

콘크리트 압축 내구력에 대한 데이터

1030개의 콘크리트 예제, 구성요소를 나타내는 8개의 속성으로 이루어져 있음

mount of cement 콘크리트의 총량, slag 슬래그, ahs 회분, water 물superplasicizer 고성능감수제, coarse aggregate 굵은 골재fine aggregate 잔골재, aging time 숙성 시간

1. 데이터 준비와 탐구

> concrete = read.csv("C:/R/concrete.csv", header=T)
> str(concrete)
'data.frame':	1030 obs. of  9 variables:
 $ cement      : num  141 169 250 266 155 ...
 $ slag        : num  212 42.2 0 114 183.4 ...
 $ ash         : num  0 124.3 95.7 0 0 ...
 $ water       : num  204 158 187 228 193 ...
 $ superplastic: num  0 10.8 5.5 0 9.1 0 0 6.4 0 9 ...
 $ coarseagg   : num  972 1081 957 932 1047 ...
 $ fineagg     : num  748 796 861 670 697 ...
 $ age         : int  28 14 28 28 28 90 7 56 28 28 ...
 $ strength    : num  29.9 23.5 29.2 45.9 18.3 ...

8개의 속성과 1개의 결과 변수(strength)로 구성되어 있다.

신경망은 입력 데이터가 0을 중심으로 좁게 형성되어 있을 때 잘 작동한다.

이를 위해 데이터를 정규화 or 표준화를 실시해주어야 한다.

데이터가 정규분포를 따른다면 scale() 함수를 통해 표준화
데이터가 비정규성을 따른다면 0~1로 정규화

cement 변수를 히스토그램으로 확인해보면 다음과 같다.

hist(concrete$cement)

normalize 함수를 만들어 모든 열들을 정규화 해주자

> # 정규화
> normalize = function(x){
+   return((x-min(x)) / (max(x)-min(x)))
+ }
> concrete_norm = as.data.frame(lapply(concrete, normalize))

> summary(concrete_norm$strength)
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
 0.0000  0.2664  0.4001  0.4172  0.5457  1.0000

strength를 확인해보면 0~1로 정규화 된 것을 볼 수 있다.
lapply() 함수를 사용해 데이터의 각 열에 normalize 함수를 적용했다.

이제 train set와 test set을 3:1로 분리해주자

# train set, test set 3:1로 분리
concrete_train = concrete_norm[1:773, ]
concrete_test = concrete_norm[774:1030, ]

2. 데이터로 모델 훈련

concrete_train 데이터를 이용하여 모델을 훈련해주자

먼저 하나의 은닉 뉴런을 가진 단순한 신경망을 만들어볼 것이다.

> library(neuralnet)

> # 하나의 은닉 뉴런에 대한 단순한 ANN
> concrete_model = neuralnet(formula = strength ~ cement + slag +
+                              ash + water + superplastic +
+                              coarseagg + fineagg + age,
+                            data = concrete_train)
> # network 시각화
> plot(concrete_model)

plot(모델)을 이용하여 신경망을 시각화해볼 수 있다.

3. 모델 성능 평가

이 예제는 분류 문제가 아닌 수치 예측 문제이므로 모델의 정확도를 보기 위해 CrossTable을 사용할 수 없다.

모델의 성능을 평가하기 위해서는 예측된 콘크리트의 강도와 실제 값 사이의 상관관계를 측정해야 한다.

> # 모델 결과
> model_results = compute(concrete_model, concrete_test[, 1:8])

> # 강도값 예측
> predicted_strength = model_results$net.result

> # 예측값과 실제값의 상관 관계
> cor(predicted_strength, concrete_test$strength)
          [,1]
[1,] 0.8063074

compute(모델, 분석할 변수들) 함수를 사용해 test data에 대한 예측을 생성했다.
그 값의 net.results로 예측값을 predicted_strength에 저장해주었다.
예측값과 실제값의 상관계수를 cor을 통해 구하였다.

4. 모델 성능 향상 - 은닉 노드 수 늘리기

좀 더 복잡한 구성도를 가진 신경망은 어려운 개념을 학습하는 능력이 있다. (과적합의 위험도 있음)

이번에는 모델 성능을 향상 시키기 위해 은닉 노드 수를 1개에서 5개로 늘려보자

> # 5개 은닉 뉴런인 복잡한 뉴런망
> concrete_model2 = neuralnet(formula = strength ~ cement + slag +
+                               ash + water + superplastic +
+                               coarseagg + fineagg + age,
+                             data = concrete_train, hidden = 5)

# network 시각화
> plot(concrete_model2)

hidden = 5를 추가해주면 된다.

위에서 만들었던 신경망보다는 더 복잡해보인다!

위와 같이 모델의 성능을 평가해보면

> # 성능 평가
> model_results2 = compute(concrete_model2, concrete_test[, 1:8])
> predicted_strength2 = model_results2$net.result
> cor(predicted_strength2, concrete_test$strength)
          [,1]
[1,] 0.9267753

은닉 노드 수를 늘리니 더 좋은 성능을 내는 것을 볼 수 있다.

5. 인공 신경망의 장단점

장점	단점
1. 디지털 컴퓨터에 인간 두뇌의 신경 연결을 흉내내 인간의 능력과 컴퓨터의 능력 사이의 간격을 좁힘 2. 인간들의 경험으로부터 학습하는 능력에 가까운 데이터 모방으로부터 일반화하고 학습하는 능력을 얻을 수 있음	1. 신경망의 훈련에 대한 결과는 신경망 내에 분포된 내부 가중치들이므로 사람의 사고과정을 설명하는 것과는 다르게 왜 그 대답이 유효한지에 대한 통찰을 제공하지 못함 2. 우리의 두뇌만큼 내부 동작이 미지에 둘러싸인 블랙박스임

[SQL] HackerRank - SQL Project Planning(M)

dori_0 — Fri, 3 Jun 2022 16:39:44 +0900

SQL Project Planning

SQL Project Planning | HackerRank

Write a query to output the start and end dates of projects listed by the number of days it took to complete the project in ascending order.

www.hackerrank.com

# Problem

You are given a table, Projects, containing three columns: Task_ID, Start_Date and End_Date. It is guaranteed that the difference between the End_Date and the Start_Date is equal to 1 day for each row in the table.

If the End_Date of the tasks are consecutive, then they are part of the same project. Samantha is interested in finding the total number of different projects completed.

Write a query to output the start and end dates of projects listed by the number of days it took to complete the project in ascending order. If there is more than one project that have the same number of completion days, then order by the start date of the project.

Sample Input

Sample Output

Explanation

The example describes following four projects:

* Project 1: Tasks 1, 2 and 3 are completed on consecutive days, so these are part of the project. Thus start date of project is 2015-10-01 and end date is 2015-10-04, so it took 3 days to complete the project.

* Project 2: Tasks 4 and 5 are completed on consecutive days, so these are part of the project. Thus, the start date of project is 2015-10-13 and end date is 2015-10-15, so it took 2 days to complete the project.

* Project 3: Only task 6 is part of the project. Thus, the start date of project is 2015-10-28 and end date is 2015-10-29, so it took 1 day to complete the project.

* Project 4: Only task 7 is part of the project. Thus, the start date of project is 2015-10-30 and end date is 2015-10-31, so it took 1 day to complete the project.

# Answer

1) 한 프로젝트의 시작일, 마감일 출력하기 ( 날짜가 연속적이라면 모두 한 프로젝트 )
2) 프로젝트 기간 순으로 정렬, 기간이 같다면 시작일 순으로 정렬하기

먼저, 프로젝트 시작일과 마감일을 찾아보자

End_Date에 없는 Start_Date는 연속적이지 않고 개별적인 시작하는 프로젝트의 시작일이다.
Start_Date에 없는 End_Date는 연속적이지 않고 개별적인 프로젝트의 마감일이다.

두 조건을 만족하는 쿼리를 작성하여 FROM 절에 넣어주면 다음과 같다.

SELECT *
  FROM (SELECT start_date
          FROM projects
         WHERE start_date NOT IN (SELECT end_date FROM projects)) AS s
     , (SELECT end_date
          FROM projects
         WHERE end_date NOT IN (SELECT start_date FROM projects)) AS e
 WHERE start_date < end_date
 ORDER BY start_date;

이 때 start_date는 end_date보다 빨라야 하므로 WHERE절에 조건을 넣어주어야 한다.

(1) 2015-10-01에 시작한 프로젝트의 마감일이 여러개가 나오는데 이 중 실제 마감일은 날짜가 가장 빠른 2015-10-05이다.

실제 마감일을 찾는 법은 start_date로 그룹화 한 뒤 end_date의 최솟값을 추출하는 것이다.

(2) 프로젝트 기간을 기준으로 정렬해야 하므로 DATEDIFF를 사용했다.

DATEDIFF(날짜1, 날짜2) 가 의미하는 것은 날짜1 - 날짜2 이다.

기간 다음으로는 start_date를 정렬 조건으로 지정하였다.

(3) 시작일, 마감일을 출력하기 위해 SELECT절에 지정해주었다.

SELECT start_date 
     , MIN(end_date)  -- (1)(3)
  FROM (SELECT start_date
          FROM projects
         WHERE start_date NOT IN (SELECT end_date FROM projects)) AS s
     , (SELECT end_date
          FROM projects
         WHERE end_date NOT IN (SELECT start_date FROM projects)) AS e
 WHERE start_date < end_date 
 GROUP BY start_date  -- (1)
 ORDER BY DATEDIFF(MIN(end_date), start_date), start_date;  -- (2)

[SQL] HackerRank - Ollivander's Inventory(M)

dori_0 — Fri, 3 Jun 2022 15:57:59 +0900

Ollivander's Inventory

문제에 대한 자세한 내용은 다음 링크에서 확인하실 수 있습니다

Ollivander's Inventory | HackerRank

Help pick out Ron's new wand.

www.hackerrank.com

# Problem

Harry Potter and his friends are at Ollivander's with Ron, finally replacing Charlie's old broken wand.

Hermione decides the best way to choose is by determining the minimum number of gold galleons needed to buy each non-evil wand of high power and age. Write a query to print the id, age, coins_needed, and power of the wands that Ron's interested in, sorted in order of descending power. If more than one wand has same power, sort the result in order of descending age.

Input Format

The following tables contain data on the wands in Ollivander's inventory:

* Wands: The id is the id of the wand, code is the code of the wand, coins_needed is the total number of gold galleons needed to buy the wand, and power denotes the quality of the wand (the higher the power, the better the wand is).

* Wands_Property: The code is the code of the wand, age is the age of the wand, and is_evil denotes whether the wand is good for the dark arts. If the value of is_evil is 0, it means that the wand is not evil. The mapping between code and age is one-one, meaning that if there are two pairs, (code1, age1) and (code2, age2), then code1 != code2 and age1 != age2.

# Answer

1) id, age, coins_needed, power of the wands 출력하기
2) age와 power가 같은 것이 여러개라면 그 중 coins_needed 값이 가장 작은 것을 출력하기
3) is_evil 값이 0이어야 함
3) power순으로 내림차순, power가 같다면 age순으로 내림차순 하기

먼저, age와 power별 coins_needed의 최솟값을 찾기 위한 쿼리는 다음과 같다

SELECT code, power, MIN(coins_needed) AS min_coins
  FROM wands
 GROUP BY code, power

code가 1이고 power가 1, 2, 6일때 coins_needed의 최솟값은 각각 2701, 4361, 3754이다.

(1) 위의 쿼리를 FROM절에 넣고 wands, wands_property 테이블과 LEFT JOIN해주었다.

( 우리는 wands 테이블의 전체는 필요없고 위의 테이블에 해당하는 값만 필요하므로 LEFT JOIN을 해주었다. )

(2) is_evil 값이 0이라는 조건과 power, age 순으로 내림차순 정렬하는 조건을 각각 WHERE, ORDER BY 절에 넣어주었다.

(3) 마지막으로 id, age, coins_needed, power of the wands를 출력하기 위해 SELECT절에 지정해주었다.

SELECT w.id
     , wp.age
     , a.min_coins
     , a.power   -- (3)
  FROM (SELECT code, power, MIN(coins_needed) AS min_coins
          FROM wands
         GROUP BY code, power) AS a
  LEFT JOIN wands AS w
         ON a.min_coins = w.coins_needed AND a.code = w.code
  LEFT JOIN wands_property AS wp
         ON a.code = wp.code   -- (1)
 WHERE wp.is_evil = 0
 ORDER BY a.power DESC, wp.age DESC;   -- (2)

[SQL] HackerRank - Challenges(M)

dori_0 — Wed, 1 Jun 2022 21:28:32 +0900

Challenges

Challenges | HackerRank

Print the total number of challenges created by hackers.

www.hackerrank.com

# Problem

Julia asked her students to create some coding challenges. Write a query to print the hacker_id, name, and the total number of challenges created by each student. Sort your results by the total number of challenges in descending order. If more than one student created the same number of challenges, then sort the result by hacker_id. If more than one student created the same number of challenges and the count is less than the maximum number of challenges created, then exclude those students from the result.

Input Format

The following tables contain challenge data:

Sample Input 0, 1

Sample Output 0, 1

Explanation

For Sample Case 0, we can get the following details:

Students 5077 and 62743 both created 4 challenges, but the maximum number of challenges created is 6 so these students are excluded from the result.

For Sample Case 1, we can get the following details:

Students 12299 and 34856 both created 6 challenges. Because 6 is the maximum number of challenges created, these students are included in the result.

# Answer

1) hacker_id, name, total number of challenges 출력하기
2) total number 순으로 내림차순, hacker_id 순으로 오름차순 정렬하기
3) total number가 같은 학생이 2명 이상인데, 그 값이 total의 최댓값보다 작다면 출력에서 제외하기

이 문제는 서브쿼리를 사용해야 한다.

3번을 만족하려면 total number는 다른 학생들과 중복되지 않는 고유값이거나 최댓값이어야 한다.

이에 대해 단계별로 쿼리를 작성해보자

1. challenges_created가 중복되지 않고 고유한 값인 경우

먼저, hacker_id로 그룹화해 학생별 challenges 수를 구해보면 다음과 같다.

SELECT c.hacker_id, COUNT(*) AS total
  FROM challenges AS c
 GROUP BY c.hacker_id

아이디가 10, 91, 158, 1315인 학생은 모두 challenges 수가 2이고 최댓값이 아니므로 출력에서 제외돼야한다.

고유값을 찾으려면 위의 쿼리를 다시 total을 기준으로 그룹화 후 COUNT한 값이 1이어야 한다.

SELECT A.total
  FROM (SELECT c.hacker_id, COUNT(*) AS total
          FROM challenges AS c
         GROUP BY c.hacker_id) AS A
 GROUP BY A.total
HAVING COUNT(*) = 1

8, 9, 10 등의 total number of challenges는 모두 중복되지 않는고유한 값이다.

2. challenges_created가 최댓값인 경우

SELECT MAX(B.total)
  FROM (SELECT c.hacker_id, COUNT(*) AS total
          FROM challenges AS c
         GROUP BY c.hacker_id) AS B

서브쿼리는 위와 동일하고 이번에는 최댓값을 출력해야 하므로 SELECT절에 MAX()를 사용해주었다.

이제 전체 쿼리를 작성해주자!

(1) Hackers, Challenges 테이블을 hacker_id 기준으로 LEFT JOIN 해주고 hacker_id와 name으로 그룹화하였다.

(2) 출력해야하는 hacker_id, name, challenges_created를 SELECT절에 작성해주었는데

이 때 challenges_created는 위의 두 경우 중 한 가지에 해당해야 한다.

따라서 이 조건을 HAVING절에 추가해주었다.

(3) 마지막으로 challenges_created 기준으로 내림차순 DESC, hacker_id 기준으로 오름차순 정렬을 해주었다.

SELECT h.hacker_id
     , h.name
     , COUNT(*) AS challenges_created
  FROM challenges AS c
  LEFT JOIN hackers AS h ON c.hacker_id = h.hacker_id
 GROUP BY h.hacker_id, h.name  -- (1)
HAVING challenges_created IN (SELECT A.total
                                FROM (SELECT c.hacker_id, COUNT(*) AS total
                                        FROM challenges AS c
                                       GROUP BY c.hacker_id) AS A
                               GROUP BY A.total
                              HAVING COUNT(*) = 1)
    OR challenges_created = (SELECT MAX(B.total)
                               FROM (SELECT c.hacker_id, COUNT(*) AS total
                                       FROM challenges AS c
                                      GROUP BY c.hacker_id) AS B)  -- (2)
 ORDER BY challenges_created DESC, h.hacker_id;  -- (3)

[SQL] HackerRank - Placements(M)

dori_0 — Wed, 1 Jun 2022 16:16:35 +0900

Placements

Placements | HackerRank

Write a query to output the names of those students whose best friends got offered a higher salary than them.

www.hackerrank.com

# Problem

You are given three tables: Students, Friends and Packages. Students contains two columns: ID and Name. Friends contains two columns: ID and Friend_ID (ID of the ONLY best friend). Packages contains two columns: ID and Salary (offered salary in $ thousands per month).

Write a query to output the names of those students whose best friends got offered a higher salary than them. Names must be ordered by the salary amount offered to the best friends. It is guaranteed that no two students got same salary offer.

Explanation

See the following table:

Now,

* Samantha's best friend got offered a higher salary than her at 11.55

* Julia's best friend got offered a higher salary than her at 12.12

* Scarlet's best friend got offered a higher salary than her at 15.2

* Ashley's best friend did NOT get offered a higher salary than her

The name output, when ordered by the salary offered to their friends, will be:

* Samantha

* Julia

* Scarlet

# Answer

1) 자신보다 친구의 salary가 더 많은 학생들의 이름 출력하기
2) 친구의 salary 기준으로 정렬하기

먼저, 세 테이블을 JOIN 해주어야 한다.

1. Students와 Packages 테이블을 ID 기준으로 JOIN해 각 학생의 이름과 Salary를 볼 수 있도록 하였다.

2. Students와 Friends 테이블을 ID 기준으로 JOIN해 기존 테이블에 각 학생의 친구 컬럼을 추가해주었다.

3. 마지막으로 친구들의 Salary 컬럼을 추가하기 위하여 Friends 테이블의 Friend_id와 Packages 테이블의 ID를 기준으로 JOIN해주었다.

SELECT *
  FROM students AS s
 INNER JOIN packages AS p 
         ON s.id = p.id
 INNER JOIN friends AS f 
         ON s.id = f.id
 INNER JOIN packages AS p2 
         ON f.friend_id = p2.id;

학생의 Salary보다 친구의 Salary가 높은 학생을 추출하기 위해 WHERE절에 조건을 추가했다.

친구의 Salary (p2.salary)를 기준으로 정렬하기 위해 ORDER BY에 추가해주었다.

SELECT s.name
  FROM students AS s
 INNER JOIN packages AS p 
         ON s.id = p.id
 INNER JOIN friends AS f 
         ON s.id = f.id
 INNER JOIN packages AS p2 
         ON f.friend_id = p2.id
 WHERE p.salary < p2.salary
 ORDER BY p2.salary;

최종 출력은 학생의 이름이므로 SELECT에 s.name을 적어주었다.

[SQL] HackerRank - The Report(M)

dori_0 — Wed, 1 Jun 2022 15:43:57 +0900

The Report

The Report | HackerRank

Write a query to generate a report containing three columns: Name, Grade and Mark.

www.hackerrank.com

# Problem

You are given two tables: Students and Grades. Students contains three columns ID, Name and Marks.

Grades contains the following data:

Ketty gives Eve a task to generate a report containing three columns: Name, Grade and Mark. Ketty doesn't want the NAMES of those students who received a grade lower than 8. The report must be in descending order by grade -- i.e. higher grades are entered first. If there is more than one student with the same grade (8-10) assigned to them, order those particular students by their name alphabetically. Finally, if the grade is lower than 8, use "NULL" as their name and list them by their grades in descending order. If there is more than one student with the same grade (1-7) assigned to them, order those particular students by their marks in ascending order.

Write a query to help Eve.

Sample Input

Sample Output

Note

Print "NULL" as the name if the grade is less than 8.

Explanation

Consider the following table with the grades assigned to the students:

So, the following students got 8, 9 or 10 grades:

* Maria (grade 10)

* Jane (grade 9)

* Julia (grade 9)

* Scarlet (grade 8)

# Answer

1) grade를 기준으로 내림차순 하기
2) 같은 grade의 학생이 있다면, 학생의 이름순으로 정렬하기
3) grade가 8 미만인 학생들의 이름은 "NULL"로 출력하고 grade 순으로 내림차순 하기
4) grade가 8 미만인 학생들 중 같은 grade인 학생이 2명 이상이라면 marks 순으로 오름차순 하기

먼저, 두 테이블을 JOIN 해주어야 한다.

Students 테이블의 Garks 값이 grades 테이블의 Min_mark, Max_mark 사이에 있어야 하므로

SELECT *
  FROM students AS s
 INNER JOIN grades AS g 
         ON s.marks BETWEEN g.min_mark AND g.max_mark

다음과 같이 BETWEEN을 사용하여 JOIN 할 수 있다.

정렬 조건을 보면 1. grade 내림차순 2. 학생의 이름순 3. mark 오름차순 이므로 ORDER BY에 조건을 추가해주자

SELECT *
  FROM students AS s
 INNER JOIN grades AS g 
         ON s.marks BETWEEN g.min_mark AND g.max_mark
 ORDER BY g.grade DESC, s.name, s.marks;

마지막으로 grade가 8 미만인 학생의 이름은 "NULL"로 출력해야한다.

IF절을 사용하여 marks가 69이하이면 NULL 그렇지 않으면 이름을 출력하도록 적어주었다.

그 뒤로는 grade, marks를 출력해주었다.

[ 최종 답 ]

SELECT IF(s.marks <= 69, NULL, s.name)
     , g.grade
     , s.marks
  FROM students AS s
 INNER JOIN grades AS g 
         ON s.marks BETWEEN g.min_mark AND g.max_mark
 ORDER BY g.grade DESC, s.name, s.marks;

[SQL] HackerRank - Blunder, Census, African, 75 Marks(E)

dori_0 — Thu, 19 May 2022 23:14:53 +0900

1. The Blunder

2. Population Census

3. African Cities

4. Higher Than 75 Marks

HackerRank

HackerRank is the market-leading technical assessment and remote interview solution for hiring developers. Learn how to hire technical talent from anywhere!

www.hackerrank.com

1. The Blunder

조건 1) salary 값의 평균에서 잘못 계산한 salary의 평균 빼기

조건 2) 올림으로 계산하기

SELECT CEIL(AVG(salary) - AVG(REGEXP_REPLACE(salary, '[0]', '')))
  FROM employees;

잘못 계산한 salary를 구하기 위해 REGEXP_REPLACE를 사용하였다.
- salary의 0을 없는 것처럼 처리해주기
CEIL을 이용해 올림으로 계산하였다.

2. Population Census

조건 1) city 테이블과 country 테이블 JOIN하기

조건 2) country 테이블의 continent가 'Asia'라는 조건 달아주기

조건 3) city 테이블의 population 합계 추출하기

SELECT SUM(city.population)
  FROM city
 INNER JOIN country
         ON city.countrycode = country.code
 WHERE country.continent = 'Asia';

city의 countrycode와 country의 code를 기준으로 두 테이블을 INNER JOIN 해주었다.
WHERE절에 continent가 'Asia'라는 조건을 달아주었다.

3. African Cities

조건 1) city 테이블과 country 테이블 JOIN하기

조건 2) country 테이블의 continent가 'Africa'라는 조건 달아주기

조건 3) city 테이블의 name 추출하기

SELECT city.name
  FROM city
 INNER JOIN country
         ON city.countrycode = country.code
 WHERE country.continent = 'Africa';

city의 countrycode와 country의 code를 기준으로 두 테이블을 INNER JOIN 해주었다
WHERE 절에 continent가 'Africa'라는 조건을 달아주었다.

4. Higher Than 75 Marks

조건 1) marks가 75보다 커야한다.

조건 2) 이름의 마지막 3글자를 기준으로 정렬 해주어야 한다. 만약 이름이 같다면 ID를 기준으로 오름차순 해야한다.

SELECT name
  FROM students
 WHERE marks > 75
 ORDER BY RIGHT(name, 3), id ASC;

marks가 75보다 크다는 조건을 WHERE절에 적었다.
RIGHT 함수를 이용해 name의 오른쪽 3글자만 추출해 정렬 조건에 넣어 주었다. 그 다음 조건으로는 id를 추가했다.

[SQL] HackerRank - Employee, Revising 5문제(E)

dori_0 — Tue, 17 May 2022 00:19:45 +0900

1. Employee Names

2. Employee Salaries

3. Revising Aggregations - The Sum Function

4. Revising Aggregations - The Count Function

5. Revising Aggregations - Averages

HackerRank

HackerRank is the market-leading technical assessment and remote interview solution for hiring developers. Learn how to hire technical talent from anywhere!

www.hackerrank.com

1. Employee Names

SELECT name
  FROM employee
 ORDER BY name;

name의 알파벳 순서로 정렬하기 위해 ORDER BY name을 써주었다.

2. Employee Salaries

조건 1) employee names 열 출력하기

조건 2) salary가 2000 초과이면서 months는 10 미만인 사람

조건 3) employee_id 오름차순으로 정렬하기

SELECT name  -- 조건 1
  FROM employee
 WHERE salary > 2000 AND months < 10  -- 조건 2
 ORDER BY employee_id;  -- 조건 3

ORDER BY는 디폴트 값이 ASC (오름차순), 내림차순을 원할때는 뒤에 DESC를 적어주면 된다.

3. Revising Aggregations - The Sum Function

SELECT SUM(population)
  FROM city
 WHERE district = 'California';

city 테이블에서 population의 합계를 추출했다.
district가 'California'인 조건을 WHERE 절에 추가했다.

4. Revising Aggregations - The Count Function

SELECT COUNT(countrycode)
  FROM city
 WHERE population > 100000;

population이 100000보다 크다는 조건을 WHERE절에 넣어주고 countrycode의 개수를 셌다.

5. Revising Aggregations - Averages

SELECT AVG(population)
  FROM city
 WHERE district = 'California';

district가 'California'라는 조건을 넣고 population의 평균 (AVG)을 추출했다.

[SQL] HackerRank - Revising, Select, Population, Japan 9문제(E)

dori_0 — Mon, 16 May 2022 23:56:33 +0900

1. Revising the Select Query 1

2. Revising the Select Query 2

3. Select All

4. Select By ID

5. Average Population

6. Population Density Difference

7. Japan Population

8. Japanese Cities’ Names

9. Japanese Cities’ Attributes

HackerRank

HackerRank is the market-leading technical assessment and remote interview solution for hiring developers. Learn how to hire technical talent from anywhere!

www.hackerrank.com

1. Revising the Select Query 1

SELECT *  -- all columns
  FROM city  -- city table
 WHERE population > 100000 AND countrycode = 'USA';

population이 100000보다 크면서 (AND) countrycode가 'USA'인 조건을 WHERE절에 추가

2. Revising the Select Query 2

SELECT name
  FROM city
 WHERE population > 120000 AND countrycode = 'USA';

population이 120000보다 크면서 (AND) countrycode가 'USA'인 조건을 WHERE절에 추가

3. Select All

SELECT *
  FROM CITY;

4. Select By ID

SELECT *
  FROM CITY
 WHERE ID = 1661;

5. Average Population

SELECT FLOOR(AVG(population))
  FROM city;

버림을 하라고했으므로 FLOOR 함수를 사용해준다.

6. Population Density Difference

SELECT MAX(population) - MIN(population)
  FROM city;

최댓값 구하기 MAX함수 / 최솟값 구하기 MIN 함수

7. Japan Population

SELECT SUM(population)
  FROM city
 WHERE countrycode = 'JPN';

population의 합계를 구해야하므로 SUM(population)
countrycode가 'JPN'이라는 조건을 where절에 추가

8. Japanese Cities' Names

SELECT name
  FROM city
 WHERE countrycode = 'JPN';

countrycode가 'JPN'인 조건을 주고 name 컬럼을 SELECT 했다.

9. Japanese Cities' Attributes

SELECT *
  FROM city
 WHERE countrycode = 'JPN';

[Kaggle] Titanic 생존자 예측 ② Feature Engineering & 모델링

dori_0 — Wed, 11 May 2022 18:12:26 +0900

Titanic 생존자 예측

② Feature Engineering & 모델링

3. Feature Engineering

Feature Engineering을 시작하기에 앞서 상관계수, 결측치를 확인해보자

train.corr()

train.isnull().sum()

Train과 Test data를 한 번에 변환하기 위해 List에 담아주었다.

data_list = [train, test]

3-1. Sex

train['Sex'].head()

Sex는 male(남성), female(여성)으로 나누어져 있다. 이를 0과 1로 변경해주자

# int type의 숫자 0과 1로 매핑
for data in data_list:
    data['Sex'] = data['Sex'].astype('category').cat.codes
    
train['Sex'].head()

3-2. Age

위에서 Age 컬럼에 177개의 결측치가 존재하였다.

이 결측치에 대해 여성에겐 여성 나이의 평균, 남성에겐 남성 나이의 평균으로 채워줄 것이다.

sex_mean = train.groupby('Sex')['Age'].mean()
sex_mean

여성의 평균 나이는 28세, 남성의 평균 나이는 31세이다.

# Age 결측치 처리
for data in data_list:
    data.loc[(data['Sex'] == 0) & (data['Age'].isnull()), 'Age'] = sex_mean[0]
    data.loc[(data['Sex'] == 1) & (data['Age'].isnull()), 'Age'] = sex_mean[1]
    
train.isnull().sum()

이제 Age를 카테고리화 할 것이다.

남자와 여자는 0, 1로 차이가 극명하게 나뉘는 값이지만 요금이나 나이의 경우 20과 30의 차이가 10이라고 해서 극명하게 나뉘는 값이 아니다.
이를 전체적인 범주에 맞게 낮춰주기 위해 카테고리화 할 것이다

먼저, Age를 5개 구간으로 나누어 AgeRange 컬럼에 저장해주자

# 카테고리화
train['AgeRange'] = pd.cut(train['Age'], 5)
train[['AgeRange', 'Survived']].groupby(['AgeRange']).mean()

16, 32, 48, 64 값들을 기준으로 카테고리화를 하면 되겠다

for data in data_list:    
    data.loc[ data['Age'] <= 16, 'Age'] = 0
    data.loc[(data['Age'] > 16) & (data['Age'] <= 32), 'Age'] = 1
    data.loc[(data['Age'] > 32) & (data['Age'] <= 48), 'Age'] = 2
    data.loc[(data['Age'] > 48) & (data['Age'] <= 64), 'Age'] = 3
    data.loc[ data['Age'] > 64, 'Age'] = 4
train.drop('AgeRange', inplace=True, axis=1)
train.head()

카테고리화가 잘 되었고 'AgeRange' 컬럼은 이제 필요 없으므로 drop 해주었다.

3-3. Name

탑승객들의 이름 앞을 추출해보면 Mr, Mrs, Miss 등의 명칭등을 뽑아낼 수 있다.

이름 전체를 사용하는 것은 생존자 예측에 큰 도움이 되지 않을 것으로 예상되므로 이름을 간소화해보자

train['Title'] = train['Name'].str.extract(' ([A-Za-z]+)\.', expand=False)
train['Title'].value_counts()

Mr, Miss, Mrs, Master가 가장 많이 존재하고 나머지는 적게 존재하므로 복잡도를 증가시키지 않기 위해 모두 'Other'로 통일하면 좋을 것 같다.

for data in data_list:
    data['Title'] = data['Name'].str.extract(' ([A-Za-z]+)\.', expand=False)
    data['Title'] = data['Title'].replace(['Dr', 'Rev', 'Mlle', 'Major', 'Col', 'Countess',
                                        'Capt', 'Ms', 'Sir', 'Lady', 'Mme', 'Don', 'Jonkheer'], 'Other')
    # -> 범주형 -> 수치형
    data['Title_name'] = data['Title'].astype('category').cat.codes

title_name이라는 컬럼에 title을 카테고리화 -> 수치화 한 값을 넣어주었다.

이름의 Title별로 생존율을 확인해보면 다음과 같다.

train[['Title', 'Survived']].groupby(['Title']).mean()

Title_name 컬럼을 만들어줬으니 이제 필요 없는 'Name', 'Title' 컬럼을 지우고 확인해보자

# 불필요한 데이터 지우기
train.drop(['Name', 'Title'], axis=1, inplace = True)
test.drop(['Name', 'Title'], axis=1, inplace = True)
train.head()

3-4. SibSp + Parch

SibSp는 함께 탑승한 형제자매, 배우자의 총합 / Parch는 함께 탑승한 부모, 자녀의 총합 이었다.

혼자 탑승한 탑승객과 그 외의 탑승객의 사망률에 차이가 있었기 때문에 가족이라는 새로운 컬럼을 만들어주자

train['FamilySize'] = train['SibSp'] + train['Parch'] + 1
test['FamilySize'] = train['SibSp'] + train['Parch'] + 1
train.head()

피봇 테이블을 이용하여 가족수별 생존율을 확인해보고 시각화해보자

pd.pivot_table(train, index='FamilySize', values='Survived')
sns.countplot(data=train, x='FamilySize', hue='Survived')

FamilySize라는 컬럼을 만들어주었으므로 이제 필요 없는 'SibSp', 'Parch' 컬럼을 제거해주자

# 컬럼 제거
drop_list = ['SibSp', 'Parch']
for data in data_list:
    data.drop(drop_list, inplace=True, axis=1)

3-5. Embarked

위에서 Embarked 컬럼에 2개의 결측치가 존재했다.

결측치가 2개뿐이니 가장 많은 비율을 차지하는 'S'로 채워주었다.

train['Embarked'].value_counts()

# 결측치 처리
for data in data_list:
    data['Embarked'] = data['Embarked'].fillna('S')
sns.countplot(data=train, x='Embarked', hue='Survived')

Cherbourg에서 탑승한 사람들이 상대적으로 많이 살아남은 것으로 보인다

이제 S, C, Q를 각각 0, 1, 2로 매핑해주자

em_mapping = {'S':0, 'C':1, 'Q':2}
for data in data_list:
    data['Embarked'] = data['Embarked'].map(em_mapping)

3-6. Cabin

먼저 Cabin 컬럼에 대해 살펴보면 다음과 같이 선실을 대표하는 알파벳이 맨 처음에 나온다

train['Cabin'].value_counts()

for data in data_list:
    data['Cabin'] = data['Cabin'].fillna('N')
    data['Cabin'] = data['Cabin'].apply(lambda x:x[0])
    data['Cabin'] = data['Cabin'].astype('category').cat.codes
train.head()

결측치에는 'N'으로 저장하고 각각 맨 앞자리의 알파벳을 불러왔다.
그 다음 Cabin 컬럼을 카테고리화 한 뒤 수치형으로 바꿔주었다.

3-7. Fare

Fare도 위의 Age에서 한 것과 같이 이미 숫자이긴 하지만 단순화하기 위하여 4개 구간으로 나누어줄 것이다

# 카테고리화
for data in data_list:
    data['Farerange'] = pd.cut(data['Fare'], 4)
train[['Farerange', 'Survived']].groupby(['Farerange']).mean()

128, 256, 384를 기준으로 나눠주면 될 것 같다

for data in data_list:    
    data.loc[data['Fare'] <= 128, 'Fare'] = 0
    data.loc[(data['Fare'] > 128) & (data['Fare'] <= 256), 'Fare'] = 1
    data.loc[(data['Fare'] > 256) & (data['Fare'] <= 384), 'Fare'] = 2
    data.loc[data['Fare'] > 384, 'Fare'] = 3

train.head()

이제 Farerange 컬럼은 필요 없으므로 제거해주었다

# 컬럼 지우기
for data in data_list:
    data.drop('Farerange', axis=1, inplace=True)

3-8. Drop Data

train 데이터의 컬럼들을 살펴보면 다음과 같다

PassengerId, Ticket 컬럼들은 필요 없으므로 drop해 줄 것이다

drop_list = ['PassengerId', 'Ticket']
for data in data_list:
    data.drop(drop_list, inplace=True, axis=1)
    
for data in data_list:
    data.drop('Cabin', inplace=True, axis=1)

Cabin 컬럼도 제거하는 것이 조금 더 성능이 좋아서 뒤늦게 제거에 추가했다.

3-9. test data 결측치

마지막으로 test data에 있는 Fare 결측치 1개를 Fare의 평균으로 채워주었다.

test[test['Fare'].isnull()] = test['Fare'].mean()

피쳐 엔지니어링이 끝났으므로 train, test 데이터를 확인해보자

train.head()
test.head()

상관계수도 확인해보면

train.corr()

FE 후 상관계수

FE 전 상관계수

FE 전후 상관계수를 확인해보면 원래는 없었거나 상관관계가 거의 없었던 Pclass, Sex, Fare, Embarked 등이 이제는 Survived에 영향을 끼치는 것으로 보인다.

4. 모델링

여러 알고리즘을 돌려보고 점수가 가장 좋은 것을 최종 모델로 선정하려고 한다.

먼저 train_input, train_target을 만들어주고 라이브러리들을 불러오자

train_input = train.drop('Survived', axis=1).values
train_target = train['Survived'].values
print(train_input.shape, train_target.shape)  #(891, 7) (891,)

# 라이브러리
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_validate
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import StratifiedKFold
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.experimental import enable_hist_gradient_boosting
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC

4-1. KNN

model = KNeighborsClassifier()
score = cross_validate(model, train_input, train_target,
                      return_train_score=True, n_jobs=-1,
                      cv = StratifiedKFold())
print(np.mean(score['train_score']), np.mean(score['test_score']))
# 0.8369821296310886 0.8013495700207143

train data의 정확도는 약 84%, 검증 데이터의 정확도는 약 80%

4-2. Decision Tree

model = DecisionTreeClassifier()
score = cross_validate(model, train_input, train_target,
                      return_train_score=True, n_jobs=-1,
                      cv = StratifiedKFold())
print(np.mean(score['train_score']), np.mean(score['test_score']))
# 0.872335203366059 0.8024982738057874

train data의 정확도는 약 87%, 검증 데이터의 정확도는 약 80% -> 과대적합으로 보임

4-3. Random Forest

model = RandomForestClassifier()
score = cross_validate(model, train_input, train_target,
                      return_train_score=True, n_jobs=-1,
                      cv = StratifiedKFold())
print(np.mean(score['train_score']), np.mean(score['test_score']))
# 0.872335203366059 0.7980164459230431

train data의 정확도는 약 87%, 검증 데이터의 정확도는 약 80% -> 과대적합으로 보임

4-4. GradientBoosting

model = GradientBoostingClassifier()
score = cross_validate(model, train_input, train_target,
                      return_train_score=True, n_jobs=-1,
                      cv = StratifiedKFold())
print(np.mean(score['train_score']), np.mean(score['test_score']))
# 0.8555009691602187 0.8204632477559475

train data의 정확도는 약 86%, 검증 데이터의 정확도는 약 82%

4-5. HistGradientBoosting

model = HistGradientBoostingClassifier()
score = cross_validate(model, train_input, train_target,
                      return_train_score=True, n_jobs=-1,
                      cv = StratifiedKFold())
print(np.mean(score['train_score']), np.mean(score['test_score']))
# 0.8597093307278945 0.8126043562864854

train data의 정확도는 약 86%, 검증 데이터의 정확도는 약 81% -> 과대적합으로 보임

4-6. Naive Bayes

model = GaussianNB()
score = cross_validate(model, train_input, train_target,
                      return_train_score=True, n_jobs=-1,
                      cv = StratifiedKFold())
print(np.mean(score['train_score']), np.mean(score['test_score']))
# 0.8117284145169169 0.812560416797439

train data의 정확도는 약 81%, 검증 데이터의 정확도는 약 81%

4-7. Support Vector Machine

model = SVC()
score = cross_validate(model, train_input, train_target,
                      return_train_score=True, n_jobs=-1,
                      cv = StratifiedKFold())
print(np.mean(score['train_score']), np.mean(score['test_score']))
# 0.8366992609168413 0.8349946644906158

train data의 정확도는 약 84%, 검증 데이터의 정확도는 약 80%

4-8. 최종 모델

KNN, Gradient Boosting, SVM의 성능이 가장 좋았고 최종 모델로는 KNN으로 정하였다.

	train 데이터 정확도	검증 데이터 정확도
KNN	0.83698	0.80135
Gradient Boosting	0.8555	0.82046
SVM	0.836699	0.834995

model = KNeighborsClassifier()
model.fit(train_input, train_target)
test_input = test.values
pred = model.predict(test_input)

submission['Survived'] = pred
submission

submission.to_csv("C:/data/titanic/submission_result.csv", index=False)

캐글 점수

예측 Model의 성능을 올리기 위해 개선할 점을 생각해보면

더 자세한 EDA
결측값을 다른 방법으로 처리하기
사용하지 않은 Feature을 사용하거나, 사용한 Feature들 중 필요 없다고 생각하는 것들은 제거해보기
Modeling 단계에서 파라미터 값을 튜닝해보며 최적화 값 찾기
- AutoML 이라는 것을 알게 되었는데 아직 시도는 못 해봤다. 다음에 시도해봐야지!

	train 데이터 정확도	검증 데이터 정확도
KNN	0.83698	0.80135
Gradient Boosting	0.8555	0.82046
SVM	0.836699	0.834995

사실 나는 KNN보다 Gradient Boosting이나 SVM가 더 적합한 모델일 것이라고 생각했는데

캐글의 점수는 그렇지 않았다.

캐글에서 이 대회의 평가 지표는 Metric여서 그런게 아닐까 싶다!