เกี่ยวกับ Codelab นี้
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 รายการที่คุณสร้างขึ้นเพื่อจัดเก็บชิ้นงานโมเดล