chapter4.Rmd

---
title_meta  : บทที่ 4
title       : Factors
description : บ่อยครั้งที่ข้อมูลของเราเป็นข้อมูลที่ใช้ในการแบ่งกลุ่ม (categorical data) เช่น เพศ (ชายหรือหญิง) ในภาษา R ข้อมูลประเภทนี้จะถูกเก็บในรูปแบบที่เรียกว่า factor และในบทนี้คุณจะได้เรียนรู้วิธีการใช้งาน factor!

--- type:NormalExercise xp:100 skills:1 key:05273321916d99bb9c0deadf75c6834d25a47244
## Factor คืออะไรและทำไมเราถึงต้องใช้มัน?

ในบทนี้ เราจะให้คุณได้เรียนรู้เกี่ยวกับข้อมูลอีกแบบหนึ่งซึ่งเรียกว่า **factor**

ข้อมูลประเภท factor ใช้ในการเก็บตัวแปรที่ใช้แบ่งกลุ่ม(categorical data) ข้อแตกต่างระหว่างตัวแปรที่ใช้แบ่งกลุ่มกับตัวแปรแบบแบบต่อเนื่อง (continuous variable) คือ ตัวแปรแบบ categorical นั้นจะ มีค่าได้เพียงไม่กี่แบบ (เช่น ตัวแปรเพศ อาจะมีค่าเป็นชายหรือหญิงเท่านั้น) ในขณะที่ตัวแปรแบบ continuous สามารถมีค่าได้หลากหลายไม่จำกัด

การระบุประเภทข้อมูลให้ R รู้อย่างชัดเจนว่า ข้อมูลนี้เป็นประเภท categorical หรือ continuous นั้นมีความสำคัญอย่างมาก เนื่องจาก R จะจัดการกับข้อมูลทั้งสองประเภทแตกต่างกันเวลาเรานำข้อมูลไปใช้ในการสร้างโมเดลทางสถิติ

ตัวอย่างที่ดีของตัวแปรที่ใช้แบ่งกลุ่มคือ "เพศ" เนื่องจากมนุษย์ทุกคนสามารถถูกแบ่งเป็นกลุ่มตามเพศได้แค่ "ชาย" หรือ "หญิง" เท่านั้น ตัวแปร "เพศ" จึงมีได้เพียงแค่สองค่า คือ "ชาย" หรือ "หญิง"

`@instructions`
กำหนดให้ตัวแปร `theory` มีค่าเป็น `"factors for categorical variables"`

`@hint`
แค่ใช้คำสั่งกำหนดค่า (`<-`) และตรวจสอบให้แน่ใจว่าคุณได้พิมพ์เป็นตัวพิมพ์เล็กทั้งหมด

`@pre_exercise_code`
```{r}
# no pec
```

`@sample_code`
```{r}
# Assign to the variable theory what this chapter is about!
```

*** =solution
```{r}
# Assign to the variable theory what this chapter is about!
theory <- "factors for categorical variables"
```

`@sct`
```{r}
# MC-note: ideally, we could check for commonly mistyped variable names
#test_or({
#    bad_names <- c('Theory', "teory", "thoery", "theroy", "theiory", 'gender', 'value')
#    lapply(bad_names, test_object, eval=FALSE)
#    })

msg_undef <- paste("ดูเหมือนว่าคุณยังไม่ได้สร้างตัวแปร", "`theory`")
# ดูเหมือนว่าคุณยังไม่ได้สร้างตัวแปร `theory`

msg_incor <- paste("ตรวจสอบให้แน่ใจว่าคุณได้กำหนดค่าของตัวแปร", "`theory`", "ให้เท่ากับ", "`\"factors for categorical variables\"`", "(ต้องเป็นตัวพิมพ์เล็กทั้งหมด)")
# ตรวจสอบให้แน่ใจว่าคุณได้กำหนดค่าของตัวแปร `theory` ให้เท่ากับ `\"factors for categorical variables\"` (ต้องเป็นตัวพิมพ์เล็กทั้งหมด)

msg_err <- paste("ตรวจสอบให้แน่ใจว่าคุณได้สร้างตัวแปร", "`theory", "อย่างถูกต้องโดยใช้คำสั่ง", "`<-`", "ในการกำหนดค่าตัวแปร")
# ตรวจสอบให้แน่ใจว่าคุณได้สร้างตัวแปร `theory` อย่างถูกต้องโดยใช้คำสั่ง `<-` ในการกำหนดค่าตัวแปร

success_msg <- "เยี่ยมมาก! พร้อมที่จะเรียนรู้หรือยัง? เราไปดูแบบฝึกหัดต่อไปกันเลย"
# เยี่ยมมาก! พร้อมที่จะเรียนรู้หรือยัง? เราไปดูแบบฝึกหัดต่อไปกันเลย

# If get error and theory is undefined, point out the error
test_or(test_error(msg_err), test_object("theory", eval = FALSE))

test_object("theory", undefined_msg = msg_undef, incorrect_msg = msg_incor)
success_msg(success_msg)
```


--- type:NormalExercise xp:100 skills:1 key:6cc21c842b075347926bb1b244782213df32e370
## Factor คืออะไรและทำไมเราถึงต้องใช้มัน? (2)

คุณสามารถใช้ function [`factor()`](http://www.rdocumentation.org/packages/base/functions/factor)  ในการสร้าง factors ในภาษา R สิ่งแรกที่คุณต้องทำก็คือสร้าง vector ของข้อมูลที่ใช้ในการแบ่งกลุ่ม ยกตัวอย่างเช่น `gender_vector` ที่เก็บข้อมูลเพศของคน 5 คนเอาไว้:

```
gender_vector <- c("Male","Female","Female","Male","Male")
```

เราสามารถเห็นได้อย่างชัดเจนว่าข้อมูลถูกแบ่งออกเป็น 2 กลุ่มด้วยกัน (หรือในภาษา R เรียกว่า **'factor levels'**) ได้แก่ "Male" และ "Female".

และการใช้ function [`factor()`](http://www.rdocumentation.org/packages/base/functions/factor) จะทำการเปลี่ยนข้อมูลใน vector ให้เป็น factor:

```
factor_gender_vector <- factor(gender_vector)
```

`@instructions`
- แปลง vector ของข้อมูลแบบตัวอักษร `gender_vector` ให้เป็นข้อมูลแบบ factor ด้วย function `factor()` จากนั้นเก็บผลลัพธ์ไว้ในตัวแปร `factor_gender_vector`
- แสดงค่า `factor_gender_vector` และสังเกตดูว่า R จะพิมพ์ค่า factor levels ออกมาต่อท้ายข้อมูลให้เราด้วย

`@hint`
แค่ใช้ function [`factor()`](http://www.rdocumentation.org/packages/base/functions/factor) กับ `gender_vector` เท่านั้น ลองดูที่แบบฝึกหัดให้ดีๆอีกครั้ง คำตอบอยู่ในนั้นแล้ว...

`@pre_exercise_code`
```{r}
# no pec
```

`@sample_code`
```{r}
# Gender vector
gender_vector <- c("Male", "Female", "Female", "Male", "Male")

# Convert gender_vector to a factor
factor_gender_vector <-

# Print out factor_gender_vector

```

*** =solution
```{r}
# Gender vector
gender_vector <- c("Male", "Female", "Female", "Male", "Male")

# Convert gender_vector to a factor
factor_gender_vector <- factor(gender_vector)

# Print out factor_gender_vector
factor_gender_vector
```

`@sct`
```{r}
object_msg <- paste("คุณได้กำหนดให้ตัวแปร", "`factor_gender_vector`", "มีค่าเท่ากับ factor ของ", "`gender_vector`", "หรือยัง?")
# คุณได้กำหนดให้ตัวแปร `factor_gender_vector` มีค่าเท่ากับ factor ของ `gender_vector` หรือยัง?

output_msg <- paste("อย่าลืมสั่งแสดงค่า", "`factor_gender_vector`!")
# อย่าลืมสั่งแสดงค่า `factor_gender_vector`!

success_msg <- paste("เยี่ยม! ถ้าคุณต้องการคำอธิบายเพิ่มเติมเกี่ยวกับ function", "`factor()`", "แค่คุณพิมพ์", "`?factor`", "ลงไปใน Console ก็จะเป็นการเปิดหน้า help ซึ่งจะมีคำอธิบายเพิ่มเติมอยู่ในนั้น แต่ตอนนี้ ไปดูแบบฝึกหัดต่อไปกันดีกว่า")
# เยี่ยม! ถ้าคุณต้องการคำอธิบายเพิ่มเติมเกี่ยวกับ function `factor()` แค่คุณพิมพ์ `?factor` ลงไปใน Console ก็จะเป็นการเปิดหน้า help ซึ่งจะมีคำอธิบายเพิ่มเติมอยู่ในนั้น แต่ตอนนี้ ไปดูแบบฝึกหัดต่อไปกันดีกว่า

test_object("factor_gender_vector", incorrect_msg = object_msg)
test_output_contains("factor_gender_vector", incorrect_msg = output_msg)
success_msg(success_msg);
```


--- type:NormalExercise xp:100 skills:1 key:5bd4f50afc2c2dbc881e16b8ca94ca56960dff42
## Factor คืออะไรและทำไมเราถึงต้องใช้มัน? (3)

ตัตัวแปรที่ใช้ในการแบ่งกลุ่ม(categorical variable) สามารถแบ่งย่อยลงไปอีกได้ 2 ประเภทด้วยกัน คือ แบบ **nominal** และ **ordinal**.

ตัวแปรแบบ nominal คือตัวแปรในการแบ่งกลุ่มที่ไม่มีลำดับ นั่นคือ เราไม่สามารถบอกได้ว่ากลุ่มหนึ่งมีค่ามากกว่าอีกกลุ่มหนึ่งหรือไม่ ยกตัวอย่างเช่น ข้อมูลชื่อชนิดของสัตว์ในตัวแปร `animals_vector` ที่ประกอบไปด้วย `"Elephant"`, `"Giraffe"`, `"Donkey"` และ `"Horse"` ซึ่งเราไม่สามารถเรียงลำดับข้อมูลเหล่านี้ตามประเภทของสัตว์ได้

ในทางตรงกันข้าม เราสามารถเรียงลำดับตัวแปรแบบ ordinal ได้ ยกตัวอย่างเช่น ข้อมูลอุณหภูมิในตัวแปร `temperature_vector` ซึ่งประกอบด้วย `"Low"`, `"Medium"` และ `"High"` ซึ่งจากข้อมูลชุดนี้เราเห็นได้ชัดเจนว่า `"Medium"` มีค่ามากกว่า `"Low"` และ `"High"` มีค่ามากกว่า `"Medium"` เราจึงสามารถเรียงลำดับข้อมูลชุดนี้ได้

`@instructions`
กดปุ่ม 'Submit Answer' เพื่อดูว่า R สร้างและแสดงค่าตัวแปรแบบ nominal และ ordinal อย่างไร ไม่ต้องห่วงถ้าคุณยังไม่เข้าใจโค้ดทั้งหมด เดี๋ยวคุณจะเข้าใจมากขึ้นในแบบฝึกหัดต่อๆไป

`@hint`
แค่กดปุ่ม 'Submit Answer' แล้วดูที่ Console แล้วลองดูว่า R แสดงการเรียงลำดับของ factor levels สำหรับตัวแปรแบบ ordinal อย่างไร

`@pre_exercise_code`
```{r}
# no pec
```

`@sample_code`
```{r}
# Animals
animals_vector <- c("Elephant", "Giraffe", "Donkey", "Horse")
factor_animals_vector <- factor(animals_vector)
factor_animals_vector

# Temperature
temperature_vector <- c("High", "Low", "High","Low", "Medium")
factor_temperature_vector <- factor(temperature_vector, order = TRUE, levels = c("Low", "Medium", "High"))
factor_temperature_vector
```

*** =solution
```{r}
# Animals
animals_vector <- c("Elephant", "Giraffe", "Donkey", "Horse")
factor_animals_vector <- factor(animals_vector)
factor_animals_vector

# Temperature
temperature_vector <- c("High", "Low", "High","Low", "Medium")
factor_temperature_vector <- factor(temperature_vector, order = TRUE, levels = c("Low", "Medium", "High"))
factor_temperature_vector
```

`@sct`
```{r}
msg <- "อย่าเปลี่ยนโค้ดตัวอย่างที่เตรียมไว้ให้ แค่กดปุ่ม 'Submit Answer' ก็พอ!"
# อย่าเปลี่ยนโค้ดตัวอย่างที่เตรียมไว้ให้ แค่กดปุ่ม 'Submit Answer' ก็พอ!

success_msg <- "สังเกตไหมว่าเกิดอะไรขึ้นกับตัวแปรแบบ ordinal? ลองไปดูแบบฝึกหัดต่อไปเกี่ยวกับ factor levels กันเลย"
# สังเกตไหมว่าเกิดอะไรขึ้นกับตัวแปรแบบ ordinal? ลองไปดูแบบฝึกหัดต่อไปเกี่ยวกับ factor levels กันเลย

test_object("animals_vector", undefined_msg = msg, incorrect_msg = msg)
test_object("temperature_vector", undefined_msg = msg, incorrect_msg = msg)
test_object("factor_animals_vector", undefined_msg = msg, incorrect_msg = msg)
test_output_contains("factor_animals_vector", incorrect_msg = msg)
test_object("factor_temperature_vector", undefined_msg = msg, incorrect_msg = msg)
test_output_contains("factor_temperature_vector", incorrect_msg = msg)
success_msg(success_msg)
```


--- type:NormalExercise xp:100 skills:1 key:1aa698978d32d1a0befa4700d7da85a648e1d69e
## Factor levels

บางครั้งคุณอาจจะอยากเปลี่ยนชื่อของ factor levels ให้ชัดเจนมากขึ้น คุณสามารถใช้ function [`levels()`](http://www.rdocumentation.org/packages/base/functions/levels) ได้ ตามตัวอย่างโค้ดด้านล่าง:

```
levels(factor_vector) <- c("name1", "name2",...)
```

ลองนึกภาพเวลาที่คุณเก็บข้อมูลจากการทำแบบสำรวจ คำถามทั่วๆไปที่แบบสำรวจมักจะเก็บทุกครั้งคือ เพศของผู้ตอบแบบสำรวจ ซึ่งเป็นข้อมูลประเภท factor แต่ข้อมูลเพศชายและหญิงอาจจะมีค่า factor levels เป็นรหัสตัวอักษร `"M"` และ `"F"` ตามลำดับ

```
survey_vector <- c("M", "F", "F", "M", "M")
```

ทีนี้เมื่อคุณทำการวิเคราะห์ข้อมูล คุณก็อยากให้ตัวแปรที่อยู่ในข้อมูลอ่านเข้าใจได้ง่าย หลายๆครั้งคุณจึงต้องการเปลี่ยนค่า factor levels จาก `"M"` และ `"F"` ไปเป็น `"Male"` และ `"Female"`

**ข้อควรระวัง:** ลำดับของการกำหนด factor levels ใหม่มีความสำคัญ ถ้าคุณลองพิมพ์คำสั่ง `levels(factor_survey_vector)` ลงไปใน Console คุณจะเห็นค่าที่แสดงออกมาเป็น `[1] "F" "M"` นั่นเป็นเพราะเมื่อคุณสร้าง factor โดยไม่ได้กำหนดลำดับให้กับ factor levels `R` จะทำการเรียงลำดับ factor levels ตามตัวอักษร และในการที่จะเปลี่ยน `"F"` เป็น `"Female"` และ `"M"` เป็น `"Male"` ได้อย่างถูกต้อง คุณจะต้องเรียงลำดับ factor levels ที่กำหนดขึ้นใหม่ให้เป็น `c("Female", "Male")` ตามลำดับเดิมของ `"F"` และ `"M"`

`@instructions`
- ลองดูโค้ดที่ใช้สร้าง vector ของข้อมูล factor จากตัวแปร `survey_vector`
- เปลี่ยน factor levels ของ `factor_survey_vector` ให้เป็น `c("Female", "Male")` อย่าลืมว่าคุณต้องเรียงตามลำดับค่าให้ถูกต้องด้วย

`@hint`
ลำดับของ factor levels นั้นเป็นเรื่องสำคัญ ลองดูลำดับของ factor levels โดยการพิมพ์ `levels(factor_survey_vector)` ลงไปใน Console

`@pre_exercise_code`
```{r}
# no pec
survey_vector <- c("M", "F", "F", "M", "M")
factor_survey_vector <- factor(survey_vector)
```

`@sample_code`
```{r}
# Code to build factor_survey_vector
survey_vector <- c("M", "F", "F", "M", "M")
factor_survey_vector <- factor(survey_vector)

# Specify the levels of factor_survey_vector
levels(factor_survey_vector) <-

factor_survey_vector
```

*** =solution
```{r}
# Code to build factor_survey_vector
survey_vector <- c("M", "F", "F", "M", "M")
factor_survey_vector <- factor(survey_vector)

# Specify the levels of factor_survey_vector
levels(factor_survey_vector) <- c("Female", "Male")

factor_survey_vector
```

`@sct`
```{r}
msg = "อย่าลบหรือเปลี่ยนแปลงโค้ดที่ใช้ในการสร้าง vector ของข้อมูล factor"
# อย่าลบหรือเปลี่ยนแปลงโค้ดที่ใช้ในการสร้าง vector ของข้อมูล factor

test_object("survey_vector", undefined_msg = msg, incorrect_msg = msg)
msg = "Do not change or remove the code to create the factor vector."
test_function("factor", "x", not_called_msg = msg, incorrect_msg = msg)

# MC-note: ideally would want to test assign operator `<-`, and have it highlight whole line.

# MC-note: or negate this test_student_typed, to highlight where they type this incorrect phrase
# test_student_typed('c("Male", "Female")')

object_msg <- paste("คุณได้กำหนด factor levels ที่ถูกต้องให้กับ", "`factor_survey_vector`", "แล้วหรือยัง? ใช้คำสั่ง", "`levels(factor_survey_vector) <- c(\"Female\", \"Male\")`", "และอย่าลืมว่า R เป็นภาษาที่ case sensitive!")
# คุณได้กำหนด factor levels ที่ถูกต้องให้กับ `factor_survey_vector` แล้วหรือยัง? ใช้คำสั่ง `levels(factor_survey_vector) <- c(\"Female\", \"Male\")` และอย่าลืมว่า R เป็นภาษาที่ case sensitive!

success_msg <- "เยี่ยมมาก! ไปดูแบบฝึกหัดต่อไปกันเลย"
# เยี่ยมมาก! ไปดูแบบฝึกหัดต่อไปกันเลย

test_object("factor_survey_vector", eq_condition = "equal", incorrect_msg = object_msg)

success_msg(success_msg)
```


--- type:NormalExercise xp:100 skills:1 key:a549f13c0644ccc89cd39a10aa48706754637ed0
## การสรุปข้อมูล Factor

หลังจากจบคอร์สนี้ รับรองว่า function [`summary()`](http://www.rdocumentation.org/packages/base/functions/summary) จะกลายเป็นหนึ่งใน function โปรดของคุณ เพราะ function นี้จะช่วยให้คุณเห็นภาพรวมของตัวแปรต่างๆก่อนจะทำการวิเคราะห์ข้อมูล:

```
summary(my_var)
```

จากแบบฝึกหัดที่แล้ว ถ้าคุณอยากรู้ว่ามีผู้ตอบแบบสอบถามเป็นผู้ชาย(`"Male"`) และผู้หญิง(`"Female"`) กี่คน function [`summary()`](http://www.rdocumentation.org/packages/base/functions/summary) สามารถช่วยคุณได้!

`@instructions`
ลองใช้ function [`summary()`](http://www.rdocumentation.org/packages/base/functions/summary) กับตัวแปร `survey_vector` และ `factor_survey_vector` แล้วลองดูว่า R แสดงผลลัพธ์จากตัวแปรที่เป็น factor และไม่ใช่ factor แตกต่างกันอย่างไร? และอันไหนมีประโยชน์มากกว่ากัน?

`@hint`
เรียกใช้ function [`summary()`](http://www.rdocumentation.org/packages/base/functions/summary) กับตัวแปร `survey_vector` และ `factor_survey_vector` นั่นคือทั้งหมดที่คุณต้องทำ

`@pre_exercise_code`
```{r}
# no pec
```

`@sample_code`
```{r}
# Build factor_survey_vector with clean levels
survey_vector <- c("M", "F", "F", "M", "M")
factor_survey_vector <- factor(survey_vector)
levels(factor_survey_vector) <- c("Female", "Male")
factor_survey_vector

# Generate summary for survey_vector


# Generate summary for factor_survey_vector

```

*** =solution
```{r}
# Build factor_survey_vector with clean levels
survey_vector <- c("M", "F", "F", "M", "M")
factor_survey_vector <- factor(survey_vector)
levels(factor_survey_vector) <- c("Female", "Male")
factor_survey_vector

# Generate summary for survey_vector
summary(survey_vector)

# Generate summary for factor_survey_vector
summary(factor_survey_vector)
```

`@sct`
```{r}
msg <- paste("อย่าเปลี่ยนแปลงค่าของ", "`survey_vector`", "และ", "`factor_survey_factor`")
# อย่าเปลี่ยนแปลงค่าของ `survey_vector` และ `factor_survey_factor`

test_object("survey_vector", undefined_msg = msg, incorrect_msg = msg)
test_object("factor_survey_vector", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
msg_1 <- paste("คุณได้ใช้ function", "`summary()`", "ในการสรุปข้อมูลจาก")
# คุณได้ใช้ function `summary()` ในการสรุปข้อมูลจาก

msg_2 <- "หรือยัง?"
# หรือยัง?

success_msg <- paste("เยี่ยม! ลองสังเกตผลลัพธ์ดู การที่คุณระบุ factor levels เป็น", "`\"Male\"`", "และ", "`\"Female\"`", "ใน", "`factor_survey_vector`", "ช่วยให้ R สามารถสรุปจำนวนตัวอย่างในแต่ละกลุ่มให้คุณได้")
# เยี่ยม! ลองสังเกตผลลัพธ์ดู การที่คุณระบุ factor levels เป็น `\"Male\"` และ `\"Female\"` ใน `factor_survey_vector` ช่วยให้ R สามารถสรุปจำนวนตัวอย่างในแต่ละกลุ่มให้คุณได้

test_output_contains("summary(survey_vector)", incorrect_msg = paste(msg_1, "`survey_vector`", msg_2))
test_output_contains("summary(factor_survey_vector)", incorrect_msg = paste(msg_1, "`factor_survey_vector`", msg_2))
success_msg(success_msg)
```


--- type:NormalExercise xp:100 skills:1 key:90ecc160d1ebf2f75bf53f9c3843fc1632bdd0a5
## สงครามระหว่างเพศ

ในตัวแปร `factor_survey_vector` เรามี factor levels อยู่ 2 ค่า คือ Male และ Female แต่ว่า R ให้ความสำคัญกับ 2 ค่านี้แตกต่างกันหรือไม่?

`@instructions`
ลองอ่านโค้ดใน editor แล้วกดปุ่ม 'Submit Answer' เพื่อดูว่า R ให้ค่าผู้ชายมากกว่าผู้หญิงหรือไม่

`@hint`
แค่กดปุ่ม 'Submit Answer' แล้วดูผลลัพธ์บน Console ก็พอ

`@pre_exercise_code`
```{r}
# no pec
```

`@sample_code`
```{r}
# Build factor_survey_vector with clean levels
survey_vector <- c("M", "F", "F", "M", "M")
factor_survey_vector <- factor(survey_vector)
levels(factor_survey_vector) <- c("Female", "Male")

# Male
male <- factor_survey_vector[1]

# Female
female <- factor_survey_vector[2]

# Battle of the sexes: Male 'larger' than female?
male > female
```

*** =solution
```{r}
# Build factor_survey_vector with clean levels
survey_vector <- c("M", "F", "F", "M", "M")
factor_survey_vector <- factor(survey_vector)
levels(factor_survey_vector) <- c("Female", "Male")

# Male
male <- factor_survey_vector[1]

# Female
female <- factor_survey_vector[2]

# Battle of the sexes: Male 'larger' than female?
male > female
```

`@sct`
```{r}
msg = "อย่าเปลี่ยนแปลงโค้ด แค่กดปุ่ม 'Submit Answer' แล้วรอดูผลลัพธ์"
# อย่าเปลี่ยนแปลงโค้ด แค่กดปุ่ม 'Submit Answer' แล้วรอดูผลลัพธ์

test_object("survey_vector", undefined_msg = msg, incorrect_msg = msg)
test_object("factor_survey_vector", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)
test_object("male", undefined_msg = msg, incorrect_msg = msg)
test_object("female", undefined_msg = msg, incorrect_msg = msg)
test_output_contains("male > female", incorrect_msg = msg)

success_msg <- "โล่งอกไปที... ดูเหมือน R จะมองว่าทั้งสองเพศนั้นเท่าเทียมกัน เราไปดูแบบฝึกหัดต่อไปกันดีกว่า"
# โล่งอกไปที... ดูเหมือน R จะมองว่าทั้งสองเพศนั้นเท่าเทียมกัน เราไปดูแบบฝึกหัดต่อไปกันดีกว่า

success_msg(success_msg)
```


--- type:NormalExercise xp:100 skills:1 key:9ab0928916bf84ab225713a9a1ce40d9e322c6a0
## การสร้าง Factor แบบมีลำดับ

ในตัวอย่างที่แล้ว เนื่องจาก `"Male"` และ `"Female"` เป็น factor ที่ไม่สามารถเรียงลำดับได้(nominal) R จึงส่งข้อความเตือนออกมาว่าเครื่องหมายมากกว่า (`>`) นั้นไม่มีความหมายในการเปรียบเทียบ และ factor ทั้ง 2 ตัวถือว่าอยู่ในระดับเดียวกัน

แต่เมื่อคุณต้องทำงานกับ factor ที่สามารถเรียงลำดับได้ใน R คุณต้องแน่ใจว่าได้ระบุลำดับของ factor เหล่านี้อย่างชัดเจนแล้ว

สมมติว่าคุณเป็นหัวหน้าทีมที่มีนักวิเคราะห์ข้อมูล 5 คน และคุณต้องการที่จะประเมินความเร็วในการทำงานของแต่ละคน คุณจึงแบ่งระดับความเร็วออกเป็น `"slow"`, `"fast"` หรือ `"insane"` และเก็บผลลัพธ์ไว้ในตัวแปร `speed_vector`

`@instructions`
ขั้นแรก ให้คุณกำหนดให้ตัวแปร `speed_vector` เป็น vector ที่มีข้อมูล 5 ตัวสำหรับนักวิเคราะห์ข้อมูลแต่ละคน ข้อมูลแต่ละตัวควรมีค่าเป็น `"slow"`(ช้า), `"fast"`(เร็ว) หรือ `"insane"`(บ้าไปแล้ว!) เท่านั้น โดยอ้างอิงตามข้อมูลด้านล่าง:

- นักวิเคราะห์คนที่ 1 ให้เป็น fast
- นักวิเคราะห์คนที่ 2 ให้เป็น slow
- นักวิเคราะห์คนที่ 3 ให้เป็น slow
- นักวิเคราะห์คนที่ 4 ให้เป็น fast
- นักวิเคราะห์คนที่ 5 ให้เป็น insane

โดยที่ยังไม่จำเป็นต้องระบุว่าข้อมูลเหล่านี้เป็น factor

`@hint`
กำหนดให้ `speed_vector` เป็น vector ของข้อมูลตัวอักษรที่มีค่าเป็น `"fast"`, `"slow"` ...

`@pre_exercise_code`
```{r}
# no pec
```

`@sample_code`
```{r}
# Create speed_vector
speed_vector <-
```

*** =solution
```{r}
# Create speed_vector
speed_vector <- c("fast", "slow", "slow", "fast", "insane")
```

`@sct`
```{r}
incorrect_msg <- paste("`speed_vector`", "ควรมีค่าเป็น vector ที่มีข้อมูล 5 ตัว แต่ละตัวแทนระดับความเร็วในการทำงานของนักวิเคราะห์แต่ละคน และอย่าใช้ภาษาอังกฤษตัวพิมพ์ใหญ่ (R เป็นภาษาที่ case sensitive!)")
# `speed_vector` ควรมีค่าเป็น vector ที่มีข้อมูล 5 ตัว แต่ละตัวแทนระดับความเร็วในการทำงานของนักวิเคราะห์แต่ละคน และอย่าใช้ภาษาอังกฤษตัวพิมพ์ใหญ่ (R เป็นภาษาที่ case sensitive!)

success_msg <- "ทำได้ดีมาก! ไปแบบฝึกหัดต่อไปได้เลย"
# ทำได้ดีมาก! ไปแบบฝึกหัดต่อไปได้เลย

test_object("speed_vector", incorrect_msg = incorrect_msg)
success_msg(success_msg)
```


--- type:NormalExercise xp:100 skills:1 key:279077d10248ce03d5f972939ef8576430a16683
## การสร้าง Factor แบบมีลำดับ (2)

จริงๆแล้วตัวแปร `speed_vector` ควรถูกแปลงเป็น factor แบบมีลำดับ(ordinal) เนื่องจากเราสามารถเรียงลำดับระดับความเร็วในการทำงานได้ โดยปกติแล้ว function [`factor()`](http://www.rdocumentation.org/packages/base/functions/factor) จะทำการสร้าง factor แบบไม่มีลำดับ(nominal) หากไม่มีการระบุรายละเอียดเกี่ยวกับลำดับของ factor ในการกำหนดลำดับของ factor นั้น ต้องอาศัย argument เพิ่มเติมอีก 2 ตัว ได้แก่ `ordered` และ `levels`:

```
factor(some_vector,
       ordered = TRUE,
       levels = c("lev1", "lev2" ...))
```

การกำหนดให้ `ordered` มีค่าเป็น `TRUE` ใน function [`factor()`](http://www.rdocumentation.org/packages/base/functions/factor) เป็นการระบุว่า factor ที่กำลังจะสร้างนั้นเป็นแบบที่สามารถเรียงลำดับได้ และคุณสามารถกำหนดลำดับที่ถูกต้องของ factor นั้นผ่าน argument ชื่อ `levels`

`@instructions`
ลองสร้างตัวแปร `factor_speed_vector` ซึ่งเป็น factor แบบมีลำดับ จากตัวแปร `speed_vector` คุณจะต้องตั้งค่า arguments `ordered` เป็น `TRUE` และ `levels` ให้เป็น `c("slow", "fast", "insane")`

`@hint`
ใช้ function [`factor()`](http://www.rdocumentation.org/packages/base/functions/factor) ในการสร้างตัวแปร `factor_speed_vector` จาก `speed_character_vector` โดย argument `ordered` ควรมีค่าเป็น `TRUE` เพื่อเป็นการบอก R ว่า factor นี้มีลำดับ นอกจากนี้คุณต้องระบุลำดับของ factor ผ่าน argument `levels = c("slow", "fast", "insane")`

`@pre_exercise_code`
```{r}
# no pec
```

`@sample_code`
```{r}
# Create speed_vector
speed_vector <- c("fast", "slow", "slow", "fast", "insane")

# Convert speed_vector to ordered factor vector
factor_speed_vector <-

# Print factor_speed_vector
factor_speed_vector
summary(factor_speed_vector)
```

*** =solution
```{r}
# Create speed_vector
speed_vector <- c("fast", "slow", "slow", "fast", "insane")

# Add your code below
factor_speed_vector <- factor(speed_vector, ordered = TRUE, levels = c("slow", "fast", "insane"))

# Print factor_speed_vector
factor_speed_vector
summary(factor_speed_vector)
```

`@sct`
```{r}
msg <- paste("อย่าเปลี่ยนแปลงค่าของ", "`speed_vector`")
# อย่าเปลี่ยนแปลงค่าของ `speed_vector`

x_msg <- paste("argument ตัวแรกของ function", "`factor()`", "ควรเป็น", "`speed_vector`")
# argument ตัวแรกของ function `factor()` ควรเป็น `speed_vector`

ordered_msg <- paste("อย่าลืมตั้งค่าให้", "`ordered = TRUE`", "ใน function", "`factor()`")
# อย่าลืมตั้งค่าให้ `ordered = TRUE` ใน function `factor()`

levels_msg <- paste("ตรวจสอบให้แน่ใจว่าคุณได้ใส่", "`levels = c(\"slow\", \"fast\", \"insane\")`", "ลงไปใน function", "`factor()`")
# ตรวจสอบให้แน่ใจว่าคุณได้ใส่ `levels = c(\"slow\", \"fast\", \"insane\")` ลงไปใน function `factor()`

incorrect_msg <- paste("ดูเหมือนว่าตัวแปร", "`factor_speed_vector`", "จะยังผิดอยู่ ตรวจสอบให้แน่ใจว่าคุณได้ใส่ argument", "`speed_vector`, `ordered = TRUE`", "และ", "`levels = c(\"slow\", \"fast\", \"insane\")`", "ลงไปใน function", "`factor()`", "อย่างถูกต้อง")
# ดูเหมือนว่าตัวแปร `factor_speed_vector` จะยังผิดอยู่ ตรวจสอบให้แน่ใจว่าคุณได้ใส่ argument `speed_vector`, `ordered = TRUE` และ `levels = c(\"slow\", \"fast\", \"insane\")` ลงไปใน function `factor()` อย่างถูกต้อง

success_msg <- paste( "เยี่ยมมาก! ลองดูที่ console คุณจะเห็นว่า factor levels มีลำดับแสดงไว้ด้วย โดยใช้เครื่องหมายน้อยกว่า", "`<`", "ในการแสดงการเปรียบเทียบค่า เราไปดูแบบฝึกหัดต่อไปกันเลย")
# เยี่ยมมาก! ลองดูที่ console คุณจะเห็นว่า factor levels มีลำดับแสดงไว้ด้วย โดยใช้เครื่องหมายน้อยกว่า `<` ในการแสดงการเปรียบเทียบค่า เราไปดูแบบฝึกหัดต่อไปกันเลย

test_object("speed_vector", undefined_msg = msg, incorrect_msg = msg)
test_function("factor", args = c("x", "ordered", "levels"), incorrect_msg = c(x_msg, ordered_msg, levels_msg))
test_object("factor_speed_vector", eq_condition = "equal", incorrect_msg = incorrect_msg)
success_msg(success_msg)
```


--- type:NormalExercise xp:100 skills:1 key:db16e69805625bcfde227743a8cbc985f8482a37
## การเปรียบเทียบ Factor แบบมีลำดับ

นักวิเคราะห์คนที่ 2 เข้ามาหาคุณที่ออฟฟิศแล้วบอกคุณว่านักวิเคราะห์คนที่ 5 กำลังทำให้งานของพวกเขาล่าช้า แต่คุณยังไม่ปักใจเชื่อในสิ่งที่นักวิเคราะห์คนที่ 2 บอกกับคุณ คุณจึงตัดสินใจที่จะตรวจสอบความจริงเสียก่อนว่าสิ่งที่เขาพูดเป็นความจริงหรือไม่

ทีนี้เมื่อเรามี `factor_speed_vector` ซึ่งเป็น factor แบบมีลำดับแล้ว เราก็สามารถเปรียบเทียบ factor ที่บ่งบอกถึงระดับความเร็วในการทำงานของนักวิเคราะห์แต่ละคนได้ โดยคุณสามารถทำการเปรียบเทียบได้โดยใช้คำสั่งเปรียบเทียบทั่วๆไป (`>`, `<`, `>=`, `<=`, `==` หรือ `!=`)

`@instructions`
- ใช้ `[2]` เพื่อเลือกความเร็วในการทำงานของนักวิเคราะห์คนที่ 2 จาก `factor_speed_vector` แล้วเก็บค่าไว้ในตัวแปร `da2`
- ใช้ `[5]` เพื่อเลือกความเร็วในการทำงานของนักวิเคราะห์คนที่ 5 จาก `factor_speed_vector` แล้วเก็บค่าไว้ในตัวแปร `da5`
- ลองเปรียบเทียบและแสดงผลลัพธ์ดูว่า `da2` มากกว่า `da5` หรือไม่ คุณสามารถใช้เครื่องหมาย `>` ในการเปรียบเทียบ factor ทั้ง 2 ตัวได้เลย

`@hint`
- ในการจะดึงข้อมูลความเร็วในการทำงานของนักวิเคราะห์คนที่ 3 คุณต้องใช้คำสั่ง `factor_speed_vector[3]`
- ในการเปรียบเทียบค่า คุณสามารถใช้คำสั่ง `>` ได้ เช่น: `da3 > da4`

`@pre_exercise_code`
```{r}
# no pec
```

`@sample_code`
```{r}
# Create factor_speed_vector
speed_vector <- c("fast", "slow", "slow", "fast", "insane")
factor_speed_vector <- factor(speed_vector, ordered = TRUE, levels = c("slow", "fast", "insane"))

# Factor value for second data analyst
da2 <-

# Factor value for fifth data analyst
da5 <-

# Is data analyst 2 faster than data analyst 5?

```

*** =solution
```{r}
# Create factor_speed_vector
speed_vector <- c("fast", "slow", "slow", "fast", "insane")
factor_speed_vector <- factor(speed_vector, ordered = TRUE, levels = c("slow", "fast", "insane"))

# Factor value for second data analyst
da2 <- factor_speed_vector[2]

# Factor value for fifth data analyst
da5 <- factor_speed_vector[5]

# Is data analyst 2 faster data analyst 5?
da2 > da5
```

`@sct`
```{r}
msg <- paste("อย่าเปลี่ยนแปลงค่าของ", "`speed_vector`", "และ", "`factor_speed_vector`")
# อย่าเปลี่ยนแปลงค่าของ `speed_vector` และ `factor_speed_vector`

test_object("speed_vector", undefined_msg = msg, incorrect_msg = msg)
test_object("factor_speed_vector", eq_condition = "equal", undefined_msg = msg, incorrect_msg = msg)

object_msg_1 <- "คุณได้เลือกข้อมูลความเร็วในการทำงานของนักวิเคราะห์คนที่ Have you correctly selected the factor value for the %s data analyst? You can use `factor_speed_vector[%s]`."
# คุณได้เลือกข้อมูลความเร็วในการทำงานของนักวิเคราะห์คนที่

object_msg_2 <- "มาถูกต้องหรือเปล่า? ในการเลือกข้อมูลคุณสามารถใช้คำสั่ง"
# มาถูกต้องหรือเปล่า? ในการเลือกข้อมูลคุณสามารถใช้คำสั่ง

output_msg <- paste("คุณได้เปรียบเทียบตัวแปร", "`da2`", "และ", "`da5", "อย่างถูกต้องหรือยัง? คุณสามารถใช้เครื่องหมาย", "`>`", "ในการเปรียบเทียบ และอย่าลืมสั่งแสดงผลลัพธ์ออกมาด้วย")
# คุณได้เปรียบเทียบตัวแปร `da2` และ `da5` อย่างถูกต้องหรือยัง? คุณสามารถใช้เครื่องหมาย `>` ในการเปรียบเทียบ และอย่าลืมสั่งแสดงผลลัพธ์ออกมาด้วย

success_msg <- "เยี่ยมยอด! ผลลัพธ์จากแบบฝึกหัดนี้บอกอะไรกับคุณบ้าง? นักวิเคราะห์คนที่ 2 บ่นว่านักวิเคราะห์คนที่ 5 ทำงานช้า ทั้งที่จริงแล้วตัวเขาเองนั่นแหละคือคนที่ทำให้ทุกอย่างช้าลง! เท่านี้ก็เป็นอันจบบทที่ 4 ในตอนนี้คุณก็มีความรู้พื้นฐานเกี่ยวกับ vector, matrix และ factor แล้ว ในบทต่อไปเราจะให้คุณได้เรียนรู้เกี่ยวกับ data frame ซึ่งเป็น data structure อีกรูปแบบหนึ่งที่สำคัญมากๆใน R!"
# เยี่ยมยอด! ผลลัพธ์จากแบบฝึกหัดนี้บอกอะไรกับคุณบ้าง? นักวิเคราะห์คนที่ 2 บ่นว่านักวิเคราะห์คนที่ 5 ทำงานช้า ทั้งที่จริงแล้วตัวเขาเองนั่นแหละคือคนที่ทำให้ทุกอย่างช้าลง! เท่านี้ก็เป็นอันจบบทที่ 4 ในตอนนี้คุณก็มีความรู้พื้นฐานเกี่ยวกับ vector, matrix และ factor แล้ว ในบทต่อไปเราจะให้คุณได้เรียนรู้เกี่ยวกับ data frame ซึ่งเป็น data structure อีกรูปแบบหนึ่งที่สำคัญมากๆใน R!

test_object("da2", eq_condition = "equal", incorrect_msg = paste(object_msg_1, "2", object_msg_2, "2"))
test_object("da5", eq_condition = "equal", incorrect_msg = paste(object_msg_1, "5", object_msg_2, "5"))
test_output_contains("da2 > da5", incorrect_msg = output_msg)

success_msg(success_msg)
```