สร้างไปป์ไลน์การสร้างโมเดล Amazon SageMaker และปรับใช้โมเดล R โดยใช้ RStudio บน Amazon SageMaker

ในเดือนพฤศจิกายน 2021 ร่วมกับ อาร์สตูดิโอ พีบีซีเรา ประกาศ ความพร้อมทั่วไปของ RStudio บน Amazon SageMakerซึ่งเป็น RStudio Workbench IDE ที่มีการจัดการเต็มรูปแบบรายแรกของอุตสาหกรรมในคลาวด์ ตอนนี้คุณสามารถนำใบอนุญาต RStudio ปัจจุบันของคุณเพื่อย้ายสภาพแวดล้อม RStudio ที่จัดการด้วยตนเองของคุณไปยัง อเมซอน SageMaker เพียงไม่กี่ขั้นตอน

RStudio เป็นหนึ่งใน IDE ที่ได้รับความนิยมมากที่สุดในหมู่นักพัฒนา R สำหรับแมชชีนเลิร์นนิง (ML) และโครงการวิทยาศาสตร์ข้อมูล RStudio มีเครื่องมือโอเพนซอร์ซสำหรับ R และซอฟต์แวร์ระดับมืออาชีพที่พร้อมใช้งานสำหรับองค์กรสำหรับทีมวิทยาศาสตร์ข้อมูลเพื่อพัฒนาและแบ่งปันงานของพวกเขาในองค์กร การนำ RStudio บน SageMaker มาใช้ไม่เพียงแต่ให้คุณเข้าถึงโครงสร้างพื้นฐานของ AWS ด้วยวิธีที่มีการจัดการเต็มรูปแบบเท่านั้น แต่ยังช่วยให้คุณเข้าถึง SageMaker แบบเนทีฟได้อีกด้วย

ในโพสต์นี้ เราจะสำรวจวิธีที่คุณสามารถใช้คุณสมบัติ SageMaker ผ่าน RStudio บน SageMaker เพื่อสร้างไปป์ไลน์ SageMaker ที่สร้าง ประมวลผล ฝึกฝน และลงทะเบียนโมเดล R ของคุณ เรายังสำรวจการใช้ SageMaker สำหรับการปรับใช้โมเดลของเรา ทั้งหมดโดยใช้ R

ภาพรวมโซลูชัน

ไดอะแกรมต่อไปนี้แสดงสถาปัตยกรรมที่ใช้ในโซลูชันของเรา รหัสทั้งหมดที่ใช้ในตัวอย่างนี้สามารถพบได้ใน พื้นที่เก็บข้อมูล GitHub.

เบื้องต้น

หากต้องการติดตามโพสต์นี้ จำเป็นต้องเข้าถึง RStudio บน SageMaker หากคุณเพิ่งเริ่มใช้ RStudio บน SageMaker ให้ตรวจทาน เริ่มต้นใช้งาน RStudio บน Amazon SageMaker.

เรายังต้องสร้างคอนเทนเนอร์ Docker แบบกำหนดเอง เราใช้ AWS CodeBuild เพื่อสร้างคอนเทนเนอร์เหล่านี้ คุณจึงต้องการเพิ่มอีกเล็กน้อย AWS Identity และการจัดการการเข้าถึง (IAM) สิทธิ์ที่คุณอาจไม่มีโดยค่าเริ่มต้น ก่อนที่คุณจะดำเนินการต่อ ตรวจสอบให้แน่ใจว่าบทบาท IAM ที่คุณใช้มีนโยบายความเชื่อถือกับ CodeBuild:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": [
          "codebuild.amazonaws.com"
        ]
      },
      "Action": "sts:AssumeRole"
    }
  ]
}

จำเป็นต้องมีการอนุญาตต่อไปนี้ในบทบาท IAM เพื่อรันบิลด์ใน CodeBuild และพุชอิมเมจไปที่ การลงทะเบียน Amazon Elastic Container (อเมซอน ECR):

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "codebuild:DeleteProject",
                "codebuild:CreateProject",
                "codebuild:BatchGetBuilds",
                "codebuild:StartBuild"
            ],
            "Resource": "arn:aws:codebuild:*:*:project/sagemaker-studio*"
        },
        {
            "Effect": "Allow",
            "Action": "logs:CreateLogStream",
            "Resource": "arn:aws:logs:*:*:log-group:/aws/codebuild/sagemaker-studio*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "logs:GetLogEvents",
                "logs:PutLogEvents"
            ],
            "Resource": "arn:aws:logs:*:*:log-group:/aws/codebuild/sagemaker-studio*:log-stream:*"
        },
        {
            "Effect": "Allow",
            "Action": "logs:CreateLogGroup",
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "ecr:CreateRepository",
                "ecr:BatchGetImage",
                "ecr:CompleteLayerUpload",
                "ecr:DescribeImages",
                "ecr:DescribeRepositories",
                "ecr:UploadLayerPart",
                "ecr:ListImages",
                "ecr:InitiateLayerUpload", 
                "ecr:BatchCheckLayerAvailability",
                "ecr:PutImage"
            ],
            "Resource": "arn:aws:ecr:*:*:repository/sagemaker-studio*"
        },
        {
            "Sid": "ReadAccessToPrebuiltAwsImages",
            "Effect": "Allow",
            "Action": [
                "ecr:BatchGetImage",
                "ecr:GetDownloadUrlForLayer"
            ],
            "Resource": [
                "arn:aws:ecr:*:763104351884:repository/*",
                "arn:aws:ecr:*:217643126080:repository/*",
                "arn:aws:ecr:*:727897471807:repository/*",
                "arn:aws:ecr:*:626614931356:repository/*",
                "arn:aws:ecr:*:683313688378:repository/*",
                "arn:aws:ecr:*:520713654638:repository/*",
                "arn:aws:ecr:*:462105765813:repository/*"
            ]
        },
        {
            "Sid": "EcrAuthorizationTokenRetrieval",
            "Effect": "Allow",
            "Action": [
                "ecr:GetAuthorizationToken"
            ],
            "Resource": [
                "*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
              "s3:GetObject",
              "s3:DeleteObject",
              "s3:PutObject"
              ],
            "Resource": "arn:aws:s3:::sagemaker-*/*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:CreateBucket"
            ],
            "Resource": "arn:aws:s3:::sagemaker*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "iam:GetRole",
                "iam:ListRoles"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "arn:aws:iam::*:role/*",
            "Condition": {
                "StringLikeIfExists": {
                    "iam:PassedToService": "codebuild.amazonaws.com"
                }
            }
        }
    ]
}

สร้างคอนเทนเนอร์ R พื้นฐาน

ในการใช้สคริปต์ R ของเราสำหรับการประมวลผลและการฝึกอบรมเกี่ยวกับงานการประมวลผลและการฝึกอบรมของ SageMaker เราจำเป็นต้องสร้างของเราเอง คอนเทนเนอร์เทียบท่า มีรันไทม์และแพ็คเกจที่จำเป็น ความสามารถในการใช้คอนเทนเนอร์ของคุณเอง ซึ่งเป็นส่วนหนึ่งของข้อเสนอของ SageMaker ให้ความยืดหยุ่นอย่างมากแก่นักพัฒนาและนักวิทยาศาสตร์ข้อมูลในการใช้เครื่องมือและกรอบงานที่พวกเขาเลือก โดยแทบไม่มีข้อจำกัดใดๆ

เราสร้างคอนเทนเนอร์ Docker ที่เปิดใช้งาน R สองคอนเทนเนอร์: คอนเทนเนอร์หนึ่งสำหรับการประมวลผลงาน และอีกคอนเทนเนอร์หนึ่งสำหรับการฝึกอบรมและการปรับใช้โมเดลของเรา โดยทั่วไปการประมวลผลข้อมูลต้องใช้แพ็คเกจและไลบรารีที่แตกต่างจากการสร้างแบบจำลอง ดังนั้นจึงควรแยกสองขั้นตอนและใช้คอนเทนเนอร์ที่แตกต่างกัน

สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับการใช้คอนเทนเนอร์กับ SageMaker โปรดดูที่ การใช้คอนเทนเนอร์ Docker กับ SageMaker.

คอนเทนเนอร์ที่ใช้สำหรับการประมวลผลถูกกำหนดดังนี้:

FROM public.ecr.aws/docker/library/r-base:4.1.2

# Install tidyverse
RUN apt update && apt-get install -y --no-install-recommends 
    r-cran-tidyverse
    
RUN R -e "install.packages(c('rjson'))"

ENTRYPOINT ["Rscript"]

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

คอนเทนเนอร์ที่ใช้สำหรับการฝึกอบรมและการปรับใช้ถูกกำหนดดังนี้:

FROM public.ecr.aws/docker/library/r-base:4.1.2

RUN apt-get -y update && apt-get install -y --no-install-recommends 
    wget 
    apt-transport-https 
    ca-certificates 
    libcurl4-openssl-dev 
    libsodium-dev
    
RUN apt-get update && apt-get install -y python3-dev python3-pip 
RUN pip3 install boto3
RUN R -e "install.packages(c('readr','plumber', 'reticulate'),dependencies=TRUE, repos='http://cran.rstudio.com/')"

ENV PATH="/opt/ml/code:${PATH}"

WORKDIR /opt/ml/code

COPY ./docker/run.sh /opt/ml/code/run.sh
COPY ./docker/entrypoint.R /opt/ml/entrypoint.R

RUN /bin/bash -c 'chmod +x /opt/ml/code/run.sh'

ENTRYPOINT ["/bin/bash", "run.sh"]

เคอร์เนล RStudio ทำงานบนคอนเทนเนอร์ Docker ดังนั้นคุณจะไม่สามารถสร้างและปรับใช้คอนเทนเนอร์โดยใช้คำสั่ง Docker ได้โดยตรงในเซสชัน Studio ของคุณ คุณสามารถใช้ห้องสมุดที่มีประโยชน์แทนได้แทน sagemaker-studio-image-buildซึ่งโดยพื้นฐานแล้วจะจ้างงานการสร้างคอนเทนเนอร์ไปยัง CodeBuild

ด้วยคำสั่งต่อไปนี้ เราสร้างการลงทะเบียน Amazon ECR สองรายการ: sagemaker-r-processing และ sagemaker-r-train-n-deployและสร้างคอนเทนเนอร์ที่เกี่ยวข้องซึ่งเราใช้ในภายหลัง:

if (!py_module_available("sagemaker-studio-image-build")){py_install("sagemaker-studio-image-build", pip=TRUE)}
system("cd pipeline-example ; sm-docker build . —file ./docker/Dockerfile-train-n-deploy —repository sagemaker-r-train-and-deploy:1.0")
system("cd pipeline-example ; sm-docker build . —file ./docker/Dockerfile-processing —repository sagemaker-r-processing:1.0")

สร้างไปป์ไลน์

ตอนนี้คอนเทนเนอร์ถูกสร้างขึ้นและพร้อมแล้ว เราสามารถสร้างไปป์ไลน์ SageMaker ที่ประสานเวิร์กโฟลว์การสร้างแบบจำลองได้ รหัสเต็มนี้อยู่ใต้ไฟล์ pipeline.R ในที่เก็บ วิธีที่ง่ายที่สุดในการสร้างไปป์ไลน์ SageMaker คือการใช้ SageMaker SDK ซึ่งเป็นไลบรารี Python ที่เราสามารถเข้าถึงได้โดยใช้ไลบรารี ทำซ้ำ. สิ่งนี้ทำให้เราเข้าถึงฟังก์ชันทั้งหมดของ SageMaker โดยไม่ต้องออกจากสภาพแวดล้อมภาษา R

ไปป์ไลน์ที่เราสร้างมีองค์ประกอบดังต่อไปนี้:

• ขั้นตอนการประมวลผลล่วงหน้า – นี่คืองานประมวลผลของ SageMaker (ใช้ sagemaker-r-processing คอนเทนเนอร์) รับผิดชอบในการประมวลผลข้อมูลล่วงหน้าและแยกข้อมูลออกเป็นชุดข้อมูลฝึกและทดสอบ
• ขั้นตอนการฝึก – นี่คืองานฝึกอบรม SageMaker (ใช้ sagemaker-r-train-n-deploy คอนเทนเนอร์) รับผิดชอบการฝึกอบรมโมเดล ในตัวอย่างนี้ เราฝึกโมเดลเชิงเส้นอย่างง่าย
• ขั้นตอนการประเมิน – นี่คืองานประมวลผลของ SageMaker (ใช้ sagemaker-r-processing คอนเทนเนอร์) รับผิดชอบในการดำเนินการประเมินแบบจำลอง โดยเฉพาะในตัวอย่างนี้ เราสนใจ RMSE (ค่าคลาดเคลื่อนของค่าเฉลี่ยรูท) ในชุดข้อมูลทดสอบ ซึ่งเราต้องการใช้ในขั้นตอนต่อไปรวมทั้งเชื่อมโยงกับตัวแบบเอง
• ขั้นตอนแบบมีเงื่อนไข – นี่เป็นขั้นตอนแบบมีเงื่อนไข ซึ่งมาจากไปป์ไลน์ SageMaker ซึ่งช่วยให้เราแยกสาขาตรรกะของไปป์ไลน์ตามพารามิเตอร์บางตัว ในกรณีนี้ ไปป์ไลน์จะแยกสาขาตามค่าของ RMSE ที่คำนวณในขั้นตอนก่อนหน้า
• ลงทะเบียนรุ่น step – หากขั้นตอนเงื่อนไขก่อนหน้าคือ Trueและประสิทธิภาพของโมเดลเป็นที่ยอมรับ จากนั้นโมเดลจะถูกลงทะเบียนในรีจีสทรีโมเดล สำหรับข้อมูลเพิ่มเติม โปรดดูที่ ลงทะเบียนและปรับใช้โมเดลด้วย Model Registry.

ขั้นแรกให้เรียกใช้ฟังก์ชัน upsert เพื่อสร้าง (หรืออัปเดต) ไปป์ไลน์แล้วเรียกใช้ฟังก์ชันเริ่มต้นเพื่อเริ่มใช้งานไปป์ไลน์จริง ๆ :

source("pipeline-example/pipeline.R")
my_pipeline <- get_pipeline(input_data_uri=s3_raw_data)

upserted <- my_pipeline$upsert(role_arn=role_arn)
started <- my_pipeline$start()

ตรวจสอบไปป์ไลน์และรีจิสตรีรุ่น

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

ทันทีที่เราเริ่มต้นไปป์ไลน์ เราสามารถสลับไปที่ สตูดิโอ Amazon SageMakerซึ่งช่วยให้เราเห็นภาพไปป์ไลน์และตรวจสอบการทำงานปัจจุบันและก่อนหน้าของมัน

หากต้องการดูรายละเอียดเกี่ยวกับไปป์ไลน์ที่เราเพิ่งสร้างและใช้งาน ให้ไปที่อินเทอร์เฟซ Studio IDE เลือก แหล่งข้อมูล SageMakerเลือก ท่อ บนเมนูแบบเลื่อนลง และเลือกไปป์ไลน์ (ในกรณีนี้ AbalonePipelineUsingR).

ซึ่งเผยให้เห็นรายละเอียดของไปป์ไลน์ รวมถึงการรันปัจจุบันและก่อนหน้าทั้งหมด เลือกอันล่าสุดเพื่อแสดงภาพของไปป์ไลน์ ตามภาพหน้าจอต่อไปนี้

DAG ของไปป์ไลน์ถูกสร้างขึ้นโดยอัตโนมัติโดยบริการตามการขึ้นต่อกันของข้อมูลระหว่างขั้นตอนต่างๆ เช่นเดียวกับการขึ้นต่อกันที่เพิ่มแบบกำหนดเอง (ไม่ได้เพิ่มใดๆ ในตัวอย่างนี้)

เมื่อการวิ่งเสร็จสิ้น หากสำเร็จ คุณจะเห็นขั้นตอนทั้งหมดเปลี่ยนเป็นสีเขียว

การเลือกแต่ละขั้นตอนจะแสดงรายละเอียดเกี่ยวกับขั้นตอนเฉพาะ รวมถึงอินพุต เอาต์พุต บันทึก และการตั้งค่าการกำหนดค่าเริ่มต้น ซึ่งจะทำให้คุณสามารถเจาะลึกในไปป์ไลน์และตรวจสอบขั้นตอนที่ล้มเหลวได้

ในทำนองเดียวกัน เมื่อไปป์ไลน์ทำงานเสร็จแล้ว โมเดลจะถูกบันทึกในรีจีสทรีโมเดล ในการเข้าถึงใน แหล่งข้อมูล SageMaker บานหน้าต่างเลือก ทะเบียนโมเดล ในเมนูแบบเลื่อนลงและเลือกรุ่นของคุณ ซึ่งจะแสดงรายการของรุ่นที่ลงทะเบียนตามที่แสดงในภาพหน้าจอต่อไปนี้ เลือกหนึ่งรายการเพื่อเปิดหน้ารายละเอียดสำหรับรุ่นนั้นๆ

หลังจากที่คุณเปิดเวอร์ชันของโมเดลแล้ว ให้เลือก อัปเดตสถานะ และ อนุมัติ เพื่ออนุมัติรูปแบบ

ณ จุดนี้ ตามกรณีการใช้งานของคุณ คุณสามารถตั้งค่าการอนุมัตินี้เพื่อทริกเกอร์การดำเนินการเพิ่มเติม รวมถึงการปรับใช้โมเดลตามความต้องการของคุณ

การปรับใช้โมเดลแบบไร้เซิร์ฟเวอร์

หลังจากที่คุณได้ฝึกฝนและลงทะเบียนโมเดลบน SageMaker แล้ว การปรับใช้โมเดลบน SageMaker นั้นตรงไปตรงมา

มีตัวเลือกหลายวิธีในการปรับใช้โมเดล เช่น การอนุมานแบบแบตช์ ปลายทางแบบเรียลไทม์ หรือจุดสิ้นสุดแบบอะซิงโครนัส แต่ละวิธีมาพร้อมกับการกำหนดค่าที่จำเป็นหลายอย่าง รวมถึงการเลือกประเภทอินสแตนซ์ที่คุณต้องการและกลไกการปรับขนาด

สำหรับตัวอย่างนี้ เราใช้ฟีเจอร์ที่เพิ่งประกาศของ SageMaker การอนุมานแบบไร้เซิร์ฟเวอร์ (ในโหมดแสดงตัวอย่าง ณ เวลาที่เขียน) เพื่อปรับใช้โมเดล R ของเราบนปลายทางแบบไร้เซิร์ฟเวอร์ สำหรับจุดสิ้นสุดประเภทนี้ เรากำหนดเฉพาะจำนวน RAM ที่เราต้องการจัดสรรให้กับโมเดลสำหรับการอนุมาน เช่นเดียวกับจำนวนสูงสุดของการเรียกใช้พร้อมกันที่อนุญาตของโมเดล SageMaker ดูแลการโฮสต์โมเดลและการปรับขนาดอัตโนมัติตามต้องการ คุณจะถูกเรียกเก็บเงินตามจำนวนวินาทีที่แน่นอนและข้อมูลที่ใช้โดยโมเดล โดยไม่มีค่าใช้จ่ายสำหรับเวลาที่ว่าง

คุณสามารถปรับใช้โมเดลกับปลายทางแบบไร้เซิร์ฟเวอร์ด้วยรหัสต่อไปนี้:

model_package_arn <- 'ENTER_MODEL_PACKAGE_ARN_HERE'
model <- sagemaker$ModelPackage(
                        role=role_arn, 
                        model_package_arn=model_package_arn, 
                        sagemaker_session=session)
serverless_config <- sagemaker$serverless$ServerlessInferenceConfig(
                        memory_size_in_mb=1024L, 
                        max_concurrency=5L)
model$deploy(serverless_inference_config=serverless_config, 
             endpoint_name="serverless-r-abalone-endpoint")

หากคุณเห็นข้อผิดพลาด ClientError: An error occurred (ValidationException) when calling the CreateModel operation: Invalid approval status "PendingManualApproval" โมเดลที่คุณต้องการปรับใช้ยังไม่ได้รับการอนุมัติ ทำตามขั้นตอนจากส่วนก่อนหน้าเพื่ออนุมัติแบบจำลองของคุณ

เรียกใช้ปลายทางโดยส่งคำขอไปยังปลายทาง HTTP ที่เราปรับใช้ หรือใช้ SageMaker SDK แทน ในโค้ดต่อไปนี้ เราเรียกใช้ปลายทางในข้อมูลทดสอบบางอย่าง:

library(jsonlite)
x = list(features=format_csv(abalone_t[1:3,1:11]))
x = toJSON(x)

# test the endpoint
predictor <- sagemaker$predictor$Predictor(endpoint_name="serverless-r-abalone-endpoint", sagemaker_session=session)
predictor$predict(x)

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

เมื่อคุณทำการทดลองกับปลายทางเสร็จแล้ว คุณสามารถลบออกได้ด้วยคำสั่งต่อไปนี้:

predictor$delete_endpoint(delete_endpoint_config=TRUE)

สรุป

ในโพสต์นี้ เราได้พูดถึงขั้นตอนการสร้างไปป์ไลน์ SageMaker โดยใช้ R ในสภาพแวดล้อม RStudio ของเรา และแสดงวิธีการปรับใช้โมเดล R ของเราบนจุดปลายแบบไร้เซิร์ฟเวอร์บน SageMaker โดยใช้รีจีสทรีรุ่น SageMaker

ด้วยการผสมผสานระหว่าง RStudio และ SageMaker ตอนนี้ คุณสามารถสร้างและจัดการเวิร์กโฟลว์ ML แบบ end-to-end ที่สมบูรณ์บน AWS โดยใช้ภาษาที่เราต้องการ นั่นคือ R.

หากต้องการเจาะลึกลงไปในโซลูชันนี้ เราขอแนะนำให้คุณตรวจสอบซอร์สโค้ดของโซลูชันนี้ รวมถึงตัวอย่างอื่นๆ บน GitHub.

เกี่ยวกับผู้เขียน

จอร์จิออส ชินาส เป็น Specialist Solutions Architect สำหรับ AI/ML ในภูมิภาค EMEA เขาอยู่ในลอนดอนและทำงานอย่างใกล้ชิดกับลูกค้าในสหราชอาณาจักรและไอร์แลนด์ Georgios ช่วยลูกค้าในการออกแบบและปรับใช้แอปพลิเคชันแมชชีนเลิร์นนิงในการผลิตบน AWS โดยมีความสนใจเป็นพิเศษในแนวทางปฏิบัติ MLOps และช่วยให้ลูกค้าสามารถดำเนินการแมชชีนเลิร์นนิงในวงกว้างได้ ในเวลาว่าง เขาสนุกกับการเดินทาง ทำอาหาร และใช้เวลากับเพื่อนและครอบครัว