หน้านี้ได้รับการแปลโดย Cloud Translation API

โมเดลการสร้างต้นแบบในสมุดบันทึก AI Platform

1. ภาพรวม

บทแนะนำนี้จะอธิบายเครื่องมือต่างๆ ใน AI Platform Notebooks สําหรับการสํารวจข้อมูลและการสร้างต้นแบบโมเดล ML

สิ่งที่จะได้เรียนรู้

โดยคุณจะได้เรียนรู้วิธีต่อไปนี้

สร้างและปรับแต่งอินสแตนซ์ AI Platform Notebooks
ติดตามโค้ดของสมุดบันทึกด้วย Git ที่ผสานรวมกับ AI Platform Notebooks โดยตรง
ใช้เครื่องมือ "What-If" ในโน้ตบุ๊ก

ต้นทุนทั้งหมดในการใช้งานห้องทดลองนี้ใน Google Cloud อยู่ที่ประมาณ $1 ดูรายละเอียดทั้งหมดเกี่ยวกับราคา AI Platform Notebooks ได้ที่นี่

2. สร้างอินสแตนซ์ AI Platform Notebooks

คุณต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินจึงจะเรียกใช้โค้ดแล็บนี้ได้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่

ขั้นตอนที่ 2: เปิดใช้ Compute Engine API

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

ขั้นตอนที่ 3: สร้างอินสแตนซ์โน้ตบุ๊ก

ไปที่ส่วน AI Platform Notebooks ของ Cloud Console แล้วคลิกอินสแตนซ์ใหม่ จากนั้นเลือกประเภทอินสแตนซ์ TensorFlow 2 Enterprise ล่าสุดที่ไม่มี GPU

ตั้งชื่ออินสแตนซ์หรือใช้ชื่อเริ่มต้น จากนั้นเราจะดูตัวเลือกการปรับแต่ง คลิกปุ่มปรับแต่ง

AI Platform Notebooks มีตัวเลือกการปรับแต่งมากมาย เช่น ภูมิภาคที่ติดตั้งใช้งานอินสแตนซ์ ประเภทอิมเมจ ขนาดเครื่อง จำนวน GPU และอื่นๆ เราจะใช้ค่าเริ่มต้นสำหรับภูมิภาคและสภาพแวดล้อม เราจะใช้เครื่อง n1-standard-8 ในการกําหนดค่าเครื่อง

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

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

เมื่อเปิดอินสแตนซ์ ให้สร้างไดเรกทอรีใหม่ชื่อ codelab ไดเรกทอรีที่เราจะใช้ตลอดทั้งห้องทดลองนี้

คลิกไดเรกทอรี codelab ที่สร้างขึ้นใหม่โดยดับเบิลคลิก จากนั้นเลือกโน้ตบุ๊ก Python 3 จากตัวเปิด

เปลี่ยนชื่อสมุดบันทึกเป็น demo.ipynb หรือชื่อใดก็ได้

ขั้นตอนที่ 4: นําเข้าแพ็กเกจ Python

สร้างเซลล์ใหม่ในโน้ตบุ๊กและนําเข้าไลบรารีที่เราจะใช้ในโค้ดแล็บนี้

import pandas as pd
import tensorflow as tf
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense

import numpy as np
import json

from sklearn.model_selection import train_test_split
from sklearn.utils import shuffle
from google.cloud import bigquery
from witwidget.notebook.visualization import WitWidget, WitConfigBuilder

3. เชื่อมต่อข้อมูล BigQuery กับโน้ตบุ๊ก

BigQuery ซึ่งเป็นคลังข้อมูลขนาดใหญ่ของ Google Cloud ได้เผยแพร่ชุดข้อมูลจํานวนมากแบบสาธารณะให้คุณสํารวจ AI Platform Notebook รองรับการผสานรวมโดยตรงกับ BigQuery โดยไม่จำเป็นต้องมีการตรวจสอบสิทธิ์

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

ขั้นตอนที่ 1: ดาวน์โหลดข้อมูล BigQuery ลงในโน้ตบุ๊ก

เราจะใช้ไลบรารีไคลเอ็นต์ Python สําหรับ BigQuery เพื่อดาวน์โหลดข้อมูลลงใน Pandas DataFrame ชุดข้อมูลเดิมมีขนาด 21 GB และมี 123 ล้านแถว เราจะใช้เพียง 10,000 แถวจากชุดข้อมูลเพื่อให้การดำเนินการง่ายขึ้น

สร้างการค้นหาและแสดงตัวอย่าง DataFrame ที่ได้โดยใช้โค้ดต่อไปนี้ ในที่นี้เราจะดึงข้อมูล 4 รายการจากชุดข้อมูลเดิม พร้อมกับน้ำหนักของทารก (สิ่งที่โมเดลจะคาดการณ์) ชุดข้อมูลย้อนหลังไปหลายปี แต่สําหรับรูปแบบนี้ เราจะใช้เฉพาะข้อมูลจากหลังปี 2000 เท่านั้น

query="""
SELECT
  weight_pounds,
  is_male,
  mother_age,
  plurality,
  gestation_weeks
FROM
  publicdata.samples.natality
WHERE year > 2000
LIMIT 10000
"""
df = bigquery.Client().query(query).to_dataframe()
df.head()

หากต้องการดูข้อมูลสรุปของฟีเจอร์ตัวเลขในชุดข้อมูล ให้เรียกใช้คำสั่งต่อไปนี้

df.describe()

ซึ่งจะแสดงค่าเฉลี่ย ค่าเบี่ยงเบนมาตรฐาน ค่าต่ำสุด และเมตริกอื่นๆ สําหรับคอลัมน์ตัวเลข สุดท้าย มารับข้อมูลในคอลัมน์บูลีนซึ่งระบุเพศของทารกกัน ซึ่งทำได้โดยใช้เมธอด value_counts ของ Pandas ดังนี้

df['is_male'].value_counts()

ดูเหมือนว่าชุดข้อมูลจะสมดุลเกือบ 50/50 ตามเพศ

ขั้นตอนที่ 2: เตรียมชุดข้อมูลสําหรับการฝึก

เมื่อดาวน์โหลดชุดข้อมูลไปยังโน้ตบุ๊กในรูปแบบ Pandas DataFrame แล้ว เราจะทำการประมวลผลข้อมูลเบื้องต้นและแยกออกเป็นชุดการฝึกและชุดทดสอบได้

ก่อนอื่น ให้ลบแถวที่มีค่า Null ออกจากชุดข้อมูลและสับเปลี่ยนข้อมูล

df = df.dropna()
df = shuffle(df, random_state=2)

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

labels = df['weight_pounds']
data = df.drop(columns=['weight_pounds'])
data['is_male'] = data['is_male'].astype(int)

ตอนนี้หากคุณดูตัวอย่างชุดข้อมูลของเราโดยเรียกใช้ data.head() คุณควรเห็นฟีเจอร์ 4 รายการที่เราจะใช้สำหรับการฝึก

4. เริ่มต้นใช้งาน Git

AI Platform Notebooks ผสานรวมกับ Git โดยตรง คุณจึงทำการควบคุมเวอร์ชันได้โดยตรงภายในสภาพแวดล้อมโน้ตบุ๊ก ซึ่งรองรับการคอมมิตโค้ดใน UI ของโน้ตบุ๊กโดยตรง หรือผ่านเทอร์มินัลที่มีให้ใช้งานใน JupyterLab ในส่วนนี้ เราจะเริ่มต้นรีโพซิทอรี Git ในโน้ตบุ๊กและทำคอมมิตครั้งแรกผ่าน UI

ขั้นตอนที่ 1: เริ่มต้นที่เก็บ Git

จากไดเรกทอรีโค้ดแล็บ ให้เลือก Git แล้วเลือก Init จากแถบเมนูด้านบนใน JupyterLab

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

ขั้นตอนที่ 2: ทำการคอมมิตครั้งแรก

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

เลือกช่องข้างไฟล์โน้ตบุ๊ก demo.ipynb เพื่อจัดเตรียมไฟล์สำหรับคอมมิต (คุณสามารถละเว้นไดเรกทอรี .ipynb_checkpoints/ ได้) ป้อนข้อความคอมมิตในกล่องข้อความ แล้วคลิกเครื่องหมายถูกเพื่อคอมมิตการเปลี่ยนแปลง

ป้อนชื่อและอีเมลเมื่อได้รับข้อความแจ้ง จากนั้นกลับไปที่แท็บประวัติเพื่อดูการคอมมิตครั้งแรก

โปรดทราบว่าภาพหน้าจออาจไม่ตรงกับ UI ของคุณ เนื่องจากมีการอัปเดตตั้งแต่เผยแพร่ห้องทดลองนี้

5. สร้างและฝึกโมเดล TensorFlow

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

ขั้นตอนที่ 1: แยกข้อมูลออกเป็นชุดการฝึกและชุดทดสอบ

เราจะใช้ยูทิลิตี Scikit Learn train_test_split เพื่อแยกข้อมูลก่อนสร้างโมเดล

x,y = data,labels
x_train,x_test,y_train,y_test = train_test_split(x,y)

ตอนนี้เราพร้อมที่จะสร้างโมเดล TensorFlow แล้ว

ขั้นตอนที่ 2: สร้างและฝึกโมเดล TensorFlow

เราจะสร้างโมเดลนี้โดยใช้ API ของโมเดล tf.keras Sequential ซึ่งช่วยให้เรากําหนดโมเดลเป็นกองเลเยอร์ได้ โค้ดทั้งหมดที่เราต้องใช้ในการสร้างโมเดลมีดังนี้

model = Sequential([
    Dense(64, activation='relu', input_shape=(len(x_train.iloc[0]),)),
    Dense(32, activation='relu'),
    Dense(1)]
)

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

model.compile(optimizer=tf.keras.optimizers.RMSprop(),
              loss=tf.keras.losses.MeanSquaredError(),
              metrics=['mae', 'mse'])

คุณสามารถใช้ฟังก์ชัน model.summary() ที่มีประโยชน์ของ Keras เพื่อดูรูปร่างและจํานวนพารามิเตอร์ที่ฝึกได้ของโมเดลในแต่ละเลเยอร์

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

model.fit(x_train, y_train, epochs=10, validation_split=0.1)

ขั้นตอนที่ 3: สร้างการคาดการณ์จากตัวอย่างทดสอบ

มาดูประสิทธิภาพของโมเดลกันด้วยการทดสอบการคาดการณ์กับตัวอย่าง 10 รายการแรกจากชุดทดสอบ

num_examples = 10
predictions = model.predict(x_test[:num_examples])

จากนั้นเราจะวนซ้ำการคาดการณ์ของโมเดลเพื่อเปรียบเทียบกับค่าจริง

for i in range(num_examples):
    print('Predicted val: ', predictions[i][0])
    print('Actual val: ',y_test.iloc[i])
    print()

ขั้นตอนที่ 4: ใช้ git diff และคอมมิตการเปลี่ยนแปลง

เมื่อทำการเปลี่ยนแปลงโน้ตบุ๊กแล้ว คุณสามารถลองใช้ฟีเจอร์ git diff ที่มีอยู่ใน UI ของ git ในโน้ตบุ๊ก ตอนนี้สมุดบันทึก demo.ipynb ควรอยู่ในส่วน "เปลี่ยนแปลงแล้ว" ใน UI วางเมาส์เหนือชื่อไฟล์ แล้วคลิกไอคอน "ความแตกต่าง"

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

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

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

git add demo.ipynb

จากนั้นเรียกใช้คำสั่งต่อไปนี้เพื่อบันทึกการเปลี่ยนแปลง (คุณใช้ข้อความคอมมิตใดก็ได้)

git commit -m "Build and train TF model"

จากนั้นคุณควรเห็นการคอมมิตล่าสุดในประวัติ

6. ใช้ What-If Tool จากสมุดบันทึกโดยตรง

เครื่องมือ "What-If" คืออินเทอร์เฟซภาพแบบอินเทอร์แอกทีฟที่ออกแบบมาเพื่อช่วยให้คุณเห็นภาพชุดข้อมูลและเข้าใจผลลัพธ์ของโมเดล ML ได้ดียิ่งขึ้น ซึ่งเป็นเครื่องมือโอเพนซอร์สที่ทีม PAIR ของ Google สร้างขึ้น แม้ว่าจะทํางานกับโมเดลทุกประเภท แต่ก็มีฟีเจอร์บางอย่างที่สร้างขึ้นสําหรับ Cloud AI Platform โดยเฉพาะ

เครื่องมือ "What-If" จะติดตั้งมาล่วงหน้าในอินสแตนซ์โน้ตบุ๊ก AI Platform ของ Cloud ที่มี TensorFlow เราจะใช้เมตริกนี้เพื่อดูประสิทธิภาพโดยรวมของโมเดลและตรวจสอบลักษณะการทํางานของโมเดลกับจุดข้อมูลจากชุดทดสอบ

ขั้นตอนที่ 1: เตรียมข้อมูลสําหรับเครื่องมือ "What-If"

เราจะส่งตัวอย่างจากชุดทดสอบพร้อมกับป้ายกํากับข้อมูลจากการสังเกตการณ์โดยตรงสําหรับตัวอย่างเหล่านั้น (y_test) ไปยังเครื่องมือ "What-If" เพื่อให้คุณได้รับประโยชน์สูงสุดจากเครื่องมือนี้ ซึ่งจะช่วยให้เราเปรียบเทียบสิ่งที่โมเดลคาดการณ์กับข้อมูลจากการสังเกตการณ์โดยตรงได้ เรียกใช้บรรทัดโค้ดด้านล่างเพื่อสร้าง DataFrame ใหม่ที่มีตัวอย่างการทดสอบและป้ายกำกับ

wit_data = pd.concat([x_test, y_test], axis=1)

ในบทแนะนํานี้ เราจะเชื่อมต่อเครื่องมือ "What-If" กับโมเดลที่เพิ่งฝึกในโน้ตบุ๊ก ในการดําเนินการดังกล่าว เราจําเป็นต้องเขียนฟังก์ชันที่เครื่องมือจะใช้เพื่อเรียกใช้จุดข้อมูลทดสอบเหล่านี้กับโมเดลของเรา

def custom_predict(examples_to_infer):
    preds = model.predict(examples_to_infer)
    return preds

ขั้นตอนที่ 2: สร้างอินสแตนซ์เครื่องมือ "What-If"

เราจะสร้างอินสแตนซ์ของเครื่องมือ "What-If" ด้วยการส่งตัวอย่าง 500 รายการจากชุดทดสอบที่ต่อเชื่อมกัน + ป้ายกำกับที่เป็นข้อมูลจริงที่เราเพิ่งสร้างขึ้น เราสร้างอินสแตนซ์ของ WitConfigBuilder เพื่อตั้งค่าเครื่องมือ โดยส่งข้อมูลของเรา ฟังก์ชันการคาดการณ์ที่กําหนดเองซึ่งเราได้ระบุไว้ข้างต้น รวมถึงเป้าหมาย (สิ่งที่เรากําลังคาดการณ์) และประเภทโมเดล

config_builder = (WitConfigBuilder(wit_data[:500].values.tolist(), data.columns.tolist() + ['weight_pounds'])
  .set_custom_predict_fn(custom_predict)
  .set_target_feature('weight_pounds')
  .set_model_type('regression'))
WitWidget(config_builder, height=800)

คุณควรเห็นข้อมูลประมาณนี้เมื่อเครื่องมือ "What-If" โหลด

ในแกน x คุณจะเห็นจุดข้อมูลทดสอบกระจายตามค่าน้ำหนักที่คาดการณ์ของโมเดล weight_pounds

ขั้นตอนที่ 3: สํารวจลักษณะการทํางานของรูปแบบด้วยเครื่องมือ "What-If"

คุณทําสิ่งที่น่าสนใจได้มากมายด้วยเครื่องมือ "What-If" เราจะมาสำรวจตัวอย่างบางส่วนกัน ก่อนอื่น มาดูเครื่องมือแก้ไขจุดข้อมูลกัน คุณสามารถเลือกจุดข้อมูลใดก็ได้เพื่อดูฟีเจอร์และเปลี่ยนค่าฟีเจอร์ เริ่มต้นด้วยการคลิกจุดข้อมูลใดก็ได้

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

คุณสามารถสร้างภาพข้อมูลที่กําหนดเองได้ทุกประเภทโดยใช้เมนูแบบเลื่อนลงในส่วนผังภาพของเครื่องมือ "What-If" ตัวอย่างเช่น นี่เป็นแผนภูมิที่มีน้ำหนักที่คาดการณ์ไว้ของโมเดลบนแกน X, อายุของมารดาบนแกน Y และจุดที่มีสีตามข้อผิดพลาดในการอนุมาน (ยิ่งสีเข้ม ความแตกต่างระหว่างน้ำหนักที่คาดการณ์ไว้กับน้ำหนักจริงก็จะยิ่งมากขึ้น) ดูเหมือนว่าเมื่อน้ำหนักลดลง ข้อผิดพลาดของโมเดลจะเพิ่มขึ้นเล็กน้อย

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

ดูแนวคิดการสำรวจเพิ่มเติมด้วยเครื่องมือ "What-If" ได้ที่ลิงก์ตอนต้นของส่วนนี้

7. ไม่บังคับ: เชื่อมต่อที่เก็บ Git ในเครื่องกับ GitHub

สุดท้าย เราจะดูวิธีเชื่อมต่อที่เก็บ Git ในอินสแตนซ์โน้ตบุ๊กกับที่เก็บในบัญชี GitHub หากต้องการทำขั้นตอนนี้ คุณจะต้องมีบัญชี GitHub

ขั้นตอนที่ 1: สร้างที่เก็บใหม่ใน GitHub

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

เปิดหน้าต่างเทอร์มินัล แล้วเพิ่มที่เก็บข้อมูลใหม่เป็นรีโมต แทนที่ username ใน URL ของที่เก็บด้านล่างด้วยชื่อผู้ใช้ GitHub ของคุณ และแทนที่ your-repo ด้วยชื่อของที่เก็บที่คุณเพิ่งสร้างขึ้น

git remote add origin git@github.com:username/your-repo.git

ขั้นตอนที่ 2: ตรวจสอบสิทธิ์กับ GitHub ในอินสแตนซ์สมุดบันทึก

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

หากไม่แน่ใจว่าควรเริ่มต้นอย่างไร ให้ทำตามขั้นตอนในเอกสารประกอบของ GitHub เพื่อสร้างคีย์ SSH แล้วเพิ่มคีย์ใหม่ลงใน GitHub

ขั้นตอนที่ 3: ตรวจสอบว่าคุณได้ลิงก์ที่เก็บ GitHub อย่างถูกต้องแล้ว

เรียกใช้ git remote -v ในเทอร์มินัลเพื่อตรวจสอบว่าได้ตั้งค่าอย่างถูกต้อง คุณควรเห็นที่เก็บใหม่แสดงเป็นรีโมต เมื่อเห็น URL ของที่เก็บ GitHub และตรวจสอบสิทธิ์กับ GitHub จากโน้ตบุ๊กแล้ว คุณก็พร้อมที่จะพุชไปยัง GitHub จากอินสแตนซ์โน้ตบุ๊กโดยตรง

หากต้องการซิงค์ที่เก็บ Git ของสมุดบันทึกในเครื่องกับที่เก็บ GitHub ที่สร้างขึ้นใหม่ ให้คลิกปุ่มอัปโหลดระบบคลาวด์ที่ด้านบนของแถบด้านข้าง Git

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

ในแท็บประวัติของ UI Git ของสมุดบันทึก คุณสามารถดูได้ว่ามีการซิงค์การคอมมิตในเครื่องกับ GitHub หรือไม่ ในตัวอย่างนี้ origin/master สอดคล้องกับที่เก็บของเราใน GitHub

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

8. ยินดีด้วย

คุณทํางานในแท็บทดลองนี้มากมาย 👏👏👏

โดยสรุปแล้ว คุณได้เรียนรู้วิธีต่อไปนี้

สร้างและปรับแต่งอินสแตนซ์ AI Platform Notebook
เริ่มต้นที่เก็บ Git ในพื้นที่ในอินสแตนซ์นั้น เพิ่มการคอมมิตผ่าน UI ของ Git หรือบรรทัดคำสั่ง ดูความแตกต่างของ Git ใน UI ของ Git ใน Notebook
สร้างและฝึกโมเดล TensorFlow 2 แบบง่าย
ใช้เครื่องมือ "What-If" ภายในอินสแตนซ์ Notebook
เชื่อมต่อที่เก็บ Git ของ Notebook กับที่เก็บภายนอกใน GitHub

9. ล้างข้อมูล

หากต้องการใช้โน้ตบุ๊กเครื่องนี้ต่อไป เราขอแนะนำให้ปิดเครื่องเมื่อไม่ได้ใช้งาน จาก UI ของโน้ตบุ๊กใน Cloud Console ให้เลือกโน้ตบุ๊ก แล้วเลือกหยุด

หากต้องการลบทรัพยากรทั้งหมดที่สร้างไว้ในห้องทดลองนี้ ให้ลบอินสแตนซ์โน้ตบุ๊กแทนการหยุด

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