1. ภาพรวม
ห้องทดลองนี้จะแนะนำเครื่องมือต่างๆ ใน AI Platform Notebooks สำหรับการสำรวจข้อมูลและการสร้างต้นแบบโมเดล ML
สิ่งที่ได้เรียนรู้
โดยคุณจะได้เรียนรู้วิธีต่อไปนี้
- สร้างและปรับแต่งอินสแตนซ์ AI Platform Notebooks
- ติดตามโค้ดสมุดบันทึกด้วย Git ที่ผสานรวมโดยตรงในสมุดบันทึกของ AI Platform
- ใช้เครื่องมือ What-If ในสมุดบันทึก
ค่าใช้จ่ายรวมในการเรียกใช้ห้องทดลองนี้บน Google Cloud อยู่ที่ประมาณ $1 ดูรายละเอียดทั้งหมดเกี่ยวกับราคา AI Platform Notebooks ได้ที่นี่
2. สร้างอินสแตนซ์ AI Platform Notebooks
คุณจะต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้ Codelab นี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่
ขั้นตอนที่ 2: เปิดใช้ Compute Engine API
ไปที่ Compute Engine แล้วเลือกเปิดใช้ หากยังไม่ได้เปิดใช้ ซึ่งคุณจะต้องใช้ในการสร้างอินสแตนซ์สมุดบันทึก
ขั้นตอนที่ 3: สร้างอินสแตนซ์สมุดบันทึก
ไปที่ส่วน AI Platform Notebooks ของ Cloud Console แล้วคลิกอินสแตนซ์ใหม่ จากนั้นเลือกประเภทอินสแตนซ์ TensorFlow 2 Enterprise ล่าสุดที่ไม่มี GPU ดังนี้
ตั้งชื่ออินสแตนซ์หรือใช้ค่าเริ่มต้น จากนั้นเราจะสำรวจตัวเลือกการปรับแต่ง คลิกปุ่มกำหนดค่า ดังนี้
สมุดบันทึก AI มีตัวเลือกการปรับแต่งต่างๆ มากมาย เช่น ภูมิภาคที่คุณติดตั้งใช้งานอินสแตนซ์ ประเภทอิมเมจ ขนาดเครื่อง จำนวน GPU และอื่นๆ เราจะใช้ค่าเริ่มต้นสำหรับภูมิภาคและสภาพแวดล้อม สำหรับการกำหนดค่าเครื่อง เราจะใช้เครื่อง n1-standard-8 ดังนี้
เราจะไม่เพิ่ม GPU และจะใช้ค่าเริ่มต้นสำหรับดิสก์เปิดเครื่อง เครือข่าย และสิทธิ์ เลือกสร้างเพื่อสร้างอินสแตนซ์ ซึ่งอาจใช้เวลาดำเนินการสักครู่
เมื่อสร้างอินสแตนซ์แล้ว คุณจะเห็นเครื่องหมายถูกสีเขียวข้างอินสแตนซ์ดังกล่าวใน UI ของสมุดบันทึก เลือก Open JupyterLab เพื่อเปิดอินสแตนซ์และเริ่มการสร้างต้นแบบ
เมื่อเปิดอินสแตนซ์ ให้สร้างไดเรกทอรีใหม่ชื่อ Codelab นี่คือไดเรกทอรีที่เราจะใช้ในห้องทดลองนี้
คลิกเข้าไปในไดเรกทอรี codelab ที่สร้างขึ้นใหม่โดยดับเบิลคลิกที่สมุดบันทึก แล้วเลือกสมุดบันทึก Python 3 จาก Launcher ดังนี้
เปลี่ยนชื่อสมุดบันทึกเป็น demo.ipynb หรือชื่อใดก็ได้ที่ต้องการ
ขั้นตอนที่ 4: นำเข้าแพ็กเกจ Python
สร้างเซลล์ใหม่ในสมุดบันทึกและนำเข้าไลบรารีที่เราจะใช้ใน Codelab นี้
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 รองรับการผสานรวมกับ 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 แล้ว เราก็จะประมวลผลและแยกชุดข้อมูลเป็นชุดการฝึกและการทดสอบได้
ก่อนอื่นให้วางแถวที่มีค่าว่างจากชุดข้อมูลและสับเปลี่ยนข้อมูล
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 มีการผสานรวมกับ git โดยตรง คุณจึงควบคุมเวอร์ชันภายในสภาพแวดล้อมสมุดบันทึกได้โดยตรง การดำเนินการนี้รองรับการระบุโค้ดโดยตรงใน UI ของสมุดบันทึกหรือผ่านเทอร์มินัลที่มีอยู่ใน JupyterLab ในส่วนนี้เราจะเริ่มต้นที่เก็บ Git ในสมุดบันทึกและสร้างคอมมิตแรกผ่าน UI
ขั้นตอนที่ 1: เริ่มต้นที่เก็บ Git
จากไดเรกทอรี Codelab ให้เลือก Git แล้วเลือก Init จากแถบเมนูด้านบนใน JupyterLab ดังนี้
เมื่อระบบถามว่าคุณต้องการทำให้ไดเรกทอรีนี้เป็นที่เก็บ Git หรือไม่ ให้เลือกใช่ จากนั้นเลือกไอคอน Git ในแถบด้านข้างทางซ้ายเพื่อดูสถานะของไฟล์และคอมมิต
ขั้นตอนที่ 2: ทำการคอมมิตครั้งแรก
ใน UI นี้ คุณสามารถเพิ่มไฟล์ในคอมมิต ดูความแตกต่างของไฟล์ (เราจะกล่าวถึงในภายหลัง) และคอมมิตการเปลี่ยนแปลง เริ่มต้นด้วยการส่งไฟล์สมุดบันทึกที่เราเพิ่งเพิ่มไป
เลือกช่องข้างไฟล์สมุดบันทึก demo.ipynb เพื่อแสดงไฟล์ดังกล่าวสำหรับคอมมิต (หรือไม่ต้องสนใจไดเรกทอรี .ipynb_checkpoints/) ป้อนข้อความคอมมิตในช่องข้อความ แล้วคลิกเครื่องหมายถูกเพื่อยืนยันการเปลี่ยนแปลงของคุณ
ป้อนชื่อและอีเมลของคุณเมื่อได้รับข้อความแจ้ง จากนั้นกลับไปที่แท็บประวัติเพื่อดูคอมมิตแรก
โปรดทราบว่าภาพหน้าจออาจไม่ตรงกับ UI ของคุณทุกประการ ซึ่งเกิดจากการอัปเดตนับตั้งแต่มีการเผยแพร่ Lab นี้
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() โดยส่งต่อข้อมูลและป้ายกำกับการฝึกของเรา ในที่นี้เราจะใช้พารามิเตอร์ Valida_split แบบไม่บังคับ ซึ่งจะเก็บข้อมูลการฝึกส่วนหนึ่งของเราไว้เพื่อตรวจสอบโมเดลในแต่ละขั้นตอน โดยหลักการแล้ว คุณควรเห็นการลดลงของการฝึกและการตรวจสอบทั้ง แต่โปรดทราบว่าในตัวอย่างนี้ เราให้ความสำคัญกับเครื่องมือโมเดลและสมุดบันทึกมากกว่าคุณภาพของโมเดล
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 ที่มีอยู่ใน UI ของ Git สมุดบันทึกได้ ตอนนี้สมุดบันทึก demo.ipynb ควรอยู่ในส่วน "เปลี่ยนแปลงแล้ว" ใน UI วางเมาส์เหนือชื่อไฟล์แล้วคลิกไอคอนความแตกต่าง
คุณควรเห็นการเปลี่ยนแปลงที่แตกต่างกัน เช่น
ครั้งนี้เราจะดำเนินการเปลี่ยนแปลงผ่านบรรทัดคำสั่งโดยใช้เทอร์มินัล จากเมนู Git ในแถบเมนูด้านบนของ JupyterLab ให้เลือก Git Command ในเทอร์มินัล ถ้าคุณเปิดแท็บ git ของแถบด้านข้างทางซ้ายในขณะที่คุณเรียกใช้คำสั่งด้านล่าง คุณจะเห็นการเปลี่ยนแปลงแสดงใน UI ของ Git
ในอินสแตนซ์เทอร์มินัลใหม่ ให้เรียกใช้คำสั่งต่อไปนี้เพื่อเตรียมไฟล์สมุดบันทึกสำหรับคอมมิต
git add demo.ipynb
จากนั้นเรียกใช้รายการต่อไปนี้เพื่อยืนยันการเปลี่ยนแปลงของคุณ (คุณสามารถใช้ข้อความคอมมิตใดก็ได้ที่คุณต้องการ)
git commit -m "Build and train TF model"
จากนั้นคุณจะเห็นคอมมิตล่าสุดในประวัติ
6. ใช้เครื่องมือ What-If จากสมุดบันทึกโดยตรง
เครื่องมือ What-If เป็นอินเทอร์เฟซแบบอินเทอร์แอกทีฟที่ออกแบบมาเพื่อช่วยให้คุณแสดงภาพชุดข้อมูลและทำความเข้าใจเอาต์พุตของโมเดล ML ได้ดียิ่งขึ้น เป็นเครื่องมือโอเพนซอร์สที่สร้างโดยทีม PAIR ที่ Google แม้จะใช้งานได้กับโมเดลทุกประเภท แต่ก็มีฟีเจอร์บางอย่างที่สร้างขึ้นมาสำหรับ Cloud AI Platform โดยเฉพาะ
เครื่องมือ What-If จะติดตั้งมาล่วงหน้าในอินสแตนซ์ Cloud AI Platform Notebooks ที่มี TensorFlow เราจะใช้ข้อมูลนี้เพื่อดูประสิทธิภาพโดยรวมของโมเดลและตรวจสอบลักษณะการทำงานของจุดข้อมูลจากชุดทดสอบของเรา
ขั้นตอนที่ 1: เตรียมข้อมูลสําหรับเครื่องมือ What-If
ในการใช้ประโยชน์สูงสุดจากเครื่องมือ What-If เราจะส่งตัวอย่างจากชุดทดสอบของเราพร้อมกับป้ายกำกับข้อมูลจากการสังเกตการณ์โดยตรงสำหรับตัวอย่างเหล่านั้น (y_test) ด้วยวิธีนี้ เราจะเปรียบเทียบสิ่งที่โมเดลของเราคาดการณ์กับข้อมูลจากการสังเกตการณ์โดยตรง เรียกใช้บรรทัดโค้ดด้านล่างเพื่อสร้าง DataFrame ใหม่ที่มีตัวอย่างการทดสอบและป้ายกำกับของตัวอย่างการทดสอบ
wit_data = pd.concat([x_test, y_test], axis=1)
ในห้องทดลองนี้ เราจะเชื่อมต่อเครื่องมือ "ถ้าหาก" กับโมเดลที่เราเพิ่งฝึกในสมุดบันทึกของเรา ในการทำเช่นนั้น เราต้องเขียนฟังก์ชันที่เครื่องมือจะใช้เพื่อเรียกใช้จุดข้อมูลทดสอบเหล่านี้ไปยังโมเดลของเรา
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 Tool โหลด
บนแกน x คุณจะเห็นจุดข้อมูลทดสอบที่กระจายตามค่าน้ำหนักที่คาดการณ์ไว้ของโมเดล weight_pounds
ขั้นตอนที่ 3: สำรวจลักษณะการทำงานของโมเดลด้วยเครื่องมือ "ถ้าหาก"
คุณสามารถใช้เครื่องมือ "ถ้าหาก" ทำอะไรเจ๋งๆ ได้อีกมากมาย เดี๋ยวเราจะสำรวจบางวิธีที่นี่ ก่อนอื่น มาดูเครื่องมือแก้ไขจุดข้อมูล คุณเลือกจุดข้อมูลใดก็ได้เพื่อดูฟีเจอร์ต่างๆ และเปลี่ยนค่าของฟีเจอร์ เริ่มต้นด้วยการคลิกที่จุดข้อมูลใดๆ ต่อไปนี้
คุณจะเห็นค่าฟีเจอร์ของจุดข้อมูลที่เลือกไว้ทางด้านซ้าย คุณยังเปรียบเทียบป้ายกำกับข้อมูลที่ระบุว่าถูกต้องโดยเจ้าหน้าที่ของจุดข้อมูลนั้นกับค่าที่คาดการณ์โดยโมเดลได้ด้วย ในแถบด้านข้างทางซ้าย คุณยังสามารถเปลี่ยนค่าฟีเจอร์ และเรียกใช้การคาดการณ์โมเดลอีกครั้งเพื่อดูผลกระทบที่การเปลี่ยนแปลงนี้มีต่อโมเดลของคุณ ตัวอย่างเช่น เราเปลี่ยน gestation_weeks เป็น 30 สำหรับจุดข้อมูลนี้ได้โดยดับเบิลคลิกที่จุดดังกล่าวเพื่อให้ระบบเรียกใช้การคาดการณ์อีกครั้ง
คุณสามารถสร้างการแสดงภาพที่กำหนดเองได้ทุกประเภทด้วยการใช้เมนูแบบเลื่อนลงในส่วนพล็อตของเครื่องมือ "ถ้าหาก" ตัวอย่างเช่น นี่คือแผนภูมิที่มีโมเดลของ น้ำหนักที่คาดการณ์บนแกน x อายุของมารดาบนแกน Y และส่วนที่เป็นสีโดยความผิดพลาดจากการอนุมาน (สีเข้มกว่าหมายถึงค่าความแตกต่างที่คาดการณ์ไว้และน้ำหนักจริงมีค่าสูงกว่า) ดูเหมือนว่าน้ำหนักลดลง ข้อผิดพลาดของโมเดลจะเพิ่มขึ้นเล็กน้อย
จากนั้นให้เลือกปุ่มแผนภูมิทรัพยากร Dependency บางส่วนทางด้านซ้าย คอลัมน์นี้จะแสดงอิทธิพลต่อการคาดการณ์ของโมเดลของแต่ละฟีเจอร์ ตัวอย่างเช่น เมื่อเวลาตั้งครรภ์เพิ่มขึ้น น้ำหนักทารกที่คาดการณ์ไว้ของโมเดลเราก็เพิ่มขึ้นตามไปด้วย:
หากต้องการดูแนวคิดการสำรวจเพิ่มเติมเกี่ยวกับเครื่องมือ 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 ของคุณและคุณต้องการดึงการเปลี่ยนแปลงล่าสุดในสมุดบันทึกลง ให้คลิกไอคอนดาวน์โหลดในระบบคลาวด์เพื่อซิงค์การเปลี่ยนแปลงเหล่านั้น
ในแท็บ "ประวัติ" ของ Git UI สมุดบันทึก คุณจะดูได้ว่าคอมมิตในเครื่องซิงค์กับ GitHub หรือไม่ ในตัวอย่างนี้ origin/master สอดคล้องกับที่เก็บของเราใน GitHub
ทุกครั้งที่คุณสร้างคอมมิตใหม่ เพียงคลิกปุ่มอัปโหลดไปยังระบบคลาวด์อีกครั้งเพื่อพุชการเปลี่ยนแปลงเหล่านั้นไปยังที่เก็บ GitHub ของคุณ
8. ยินดีด้วย
คุณได้ทำอะไรหลายอย่างในห้องทดลองนี้ 👏👏👏
กล่าวโดยสรุป คุณได้เรียนรู้วิธีต่อไปนี้
- สร้างอินสแตนซ์ AI Platform Notebook ที่กำหนดเอง
- เริ่มต้นที่เก็บ Git ในเครื่องในอินสแตนซ์นั้น เพิ่มคอมมิตผ่าน UI ของ Git หรือบรรทัดคำสั่ง ดูความแตกต่างของ Git ใน UI ของ Git ของสมุดบันทึก
- สร้างและฝึกโมเดล TensorFlow 2 แบบง่าย
- ใช้เครื่องมือ "สิ่งที่จะเกิดขึ้น" ในอินสแตนซ์สมุดบันทึก
- เชื่อมต่อที่เก็บ Git สำหรับสมุดบันทึกกับที่เก็บภายนอกบน GitHub
9. ล้างข้อมูล
หากต้องการใช้สมุดบันทึกนี้ต่อไป ขอแนะนำให้ปิดสมุดบันทึกเมื่อไม่ได้ใช้งาน จาก UI ของสมุดบันทึกใน Cloud Console ให้เลือกสมุดบันทึก แล้วเลือกหยุด
หากต้องการลบทรัพยากรทั้งหมดที่คุณสร้างไว้ในห้องทดลองนี้ เพียงลบอินสแตนซ์สมุดบันทึกแทนที่จะหยุด
ใช้เมนูการนำทางใน Cloud Console เพื่อเรียกดูพื้นที่เก็บข้อมูล แล้วลบที่เก็บข้อมูลทั้ง 2 รายการที่คุณสร้างขึ้นเพื่อจัดเก็บเนื้อหาโมเดล