การจัดประเภทรูปภาพเป็นงานที่แม้แต่ทารกก็สามารถทำได้ในไม่กี่วินาที แต่สำหรับเครื่องจักรนั้นเป็นงานที่ยากลำบากจนกระทั่งความก้าวหน้าล่าสุดใน และ การเรียนรู้เชิงลึก . รถยนต์ที่ขับเคลื่อนด้วยตนเองสามารถตรวจจับวัตถุและดำเนินการที่จำเป็นได้แบบเรียลไทม์และส่วนใหญ่เป็นไปได้เนื่องจาก การจำแนกภาพ ในบทความนี้ฉันจะแนะนำคุณเกี่ยวกับหัวข้อต่อไปนี้:
- TensorFlow คืออะไร?
- Image Classification คืออะไร?
- การจัดประเภทภาพ TensorFlow: Fashion MNIST
- CIFAR 10: CNN
TensorFlow คืออะไร?
TensorFlow คือ Open Source Machine Learning Framework ของ Google สำหรับการเขียนโปรแกรมกระแสข้อมูลในงานต่างๆ โหนดในกราฟแสดงถึงการดำเนินการทางคณิตศาสตร์ในขณะที่ขอบกราฟแสดงถึงอาร์เรย์ข้อมูลหลายมิติที่สื่อสารระหว่างกัน
เทนเซอร์เป็นเพียงอาร์เรย์หลายมิติซึ่งเป็นส่วนขยายของตาราง 2 มิติไปยังข้อมูลที่มีมิติสูงกว่า มีคุณสมบัติมากมายของ Tensorflow ซึ่งเหมาะสำหรับ Deep Learning และไลบรารีโอเพนซอร์สหลักช่วยให้คุณพัฒนาและฝึกอบรมโมเดล ML ได้
Image Classification คืออะไร?
วัตถุประสงค์ของการจัดประเภทภาพคือการจัดประเภทพิกเซลทั้งหมดในภาพดิจิทัลให้เป็นหนึ่งในหลาย ๆ สิ่งปกคลุมดิน ชั้นเรียน หรือ ธีม . จากนั้นข้อมูลที่จัดหมวดหมู่นี้อาจถูกนำไปใช้ในการผลิต แผนที่เฉพาะเรื่อง ของสิ่งปกคลุมดินอยู่ในรูปภาพ
ตอนนี้ขึ้นอยู่กับปฏิสัมพันธ์ระหว่างนักวิเคราะห์และคอมพิวเตอร์ในระหว่างการจำแนกประเภทมีสองประเภท:
- ดูแล &
- ไม่ได้รับการดูแล
ดังนั้นโดยไม่ต้องเสียเวลาใด ๆ มาลองเข้าสู่ TensorFlow Image Classification ฉันมี 2 ตัวอย่าง: ง่ายและยาก มาดำเนินการต่อด้วยวิธีง่ายๆ
การจัดประเภทภาพ TensorFlow: Fashion MNIST
ชุดข้อมูล Fashion MNIST
ที่นี่เราจะใช้ Fashion MNIST Dataset ซึ่งมีภาพสีเทา 70,000 ภาพใน 10 หมวดหมู่ เราจะใช้ 60000 สำหรับการฝึกอบรมและส่วนที่เหลือ 10,000 เพื่อการทดสอบ คุณสามารถเข้าถึง Fashion MNIST ได้โดยตรงจาก TensorFlow เพียงแค่นำเข้าและโหลดข้อมูล
- มานำเข้าไลบรารีก่อน
จาก __future__ import absolute_import, division, print_function # TensorFlow และ tf.keras นำเข้า tensorflow เป็น tf จากเทนเซอร์โฟลว์อิมพอร์ต keras # Helper libraries นำเข้า numpy เป็น np import matplotlib.pyplot เป็น plt
- มาโหลดข้อมูลกัน
fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data ()
- ต่อไปเราจะแมปรูปภาพลงในคลาส
class_names = ['เสื้อยืด / ท่อนบน', 'กางเกง', 'เสื้อสวมหัว', 'ชุดเดรส', 'เสื้อโค้ท', 'รองเท้าแตะ', 'เสื้อเชิ้ต', 'รองเท้าผ้าใบ', 'กระเป๋า', 'รองเท้าบูทหุ้มข้อ']
- สำรวจข้อมูล
train_images.รูปร่าง
# แต่ละป้ายอยู่ระหว่าง 0-9
train_labels
test_images.รูปร่าง
- ตอนนี้ได้เวลาประมวลผลข้อมูลล่วงหน้า
plt.รูป() plt.imshow(train_images[0]) plt.แถบสี() plt.กริด(เท็จ) plt.แสดง()
#หากคุณตรวจสอบภาพแรกในชุดการฝึกคุณจะเห็นว่าค่าพิกเซลอยู่ในช่วง 0 ถึง 255
- เราต้องปรับขนาดภาพตั้งแต่ 0-1 เพื่อป้อนเข้าสู่ Neural Network
train_images = train_images / 255.0 test_images = test_images / 255.0
- มาแสดงภาพกัน
plt.รูป(มะเดื่อ=(10,10)) สำหรับ ผม ใน พิสัย(25): plt.แผนย่อย(5,5,ผม+หนึ่ง) plt.xticks([]) plt.yticks([]) plt.กริด(เท็จ) plt.imshow(train_images[ผม], ซม=plt.ซม.ไบนารี่) plt.xlabel(class_names[train_labels[ผม]]) plt.แสดง()
- ตั้งค่าเลเยอร์
แบบ = ยาก.ตามลำดับ([ ยาก.ชั้น.เรียบ(input_shape=(28, 28)), ยาก.ชั้น.หนาแน่น(128, การเปิดใช้งาน=tf.nos.relu), ยาก.ชั้น.หนาแน่น(10, การเปิดใช้งาน=tf.nos.ซอฟต์แม็กซ์) ])
- รวบรวม Model
แบบ.รวบรวม(เครื่องมือเพิ่มประสิทธิภาพ='อดัม', ขาดทุน='sparse_categorical_crossentropy', เมตริก=['ความถูกต้อง'])
- การฝึกโมเดล
แบบ.พอดี(train_images, train_labels, ยุค=10)
ผสานการใช้งาน c ++ เรียงลำดับ
- การประเมินความถูกต้อง
test_loss, test_acc = แบบ.ประเมิน(test_images, test_labels) พิมพ์('ความแม่นยำในการทดสอบ:', test_acc)
- การทำนาย
การคาดการณ์ = แบบ.ทำนาย(test_images)
การคาดการณ์[0]
การทำนายคืออาร์เรย์ของตัวเลข 10 ตัว สิ่งเหล่านี้อธิบายถึง 'ความมั่นใจ' ของนางแบบที่ภาพนั้นสอดคล้องกับเสื้อผ้า 10 ชิ้นที่แตกต่างกัน เราสามารถดูได้ว่าป้ายใดมีค่าความเชื่อมั่นสูงสุด
เช่น..argmax(การคาดการณ์[0])# นางแบบมั่นใจที่สุดว่าเป็นรองเท้าบูทหุ้มข้อ มาดูกันว่าถูกต้องไหมเอาต์พุต: 9
test_labels[0]
เอาต์พุต: 9
- ตอนนี้ได้เวลาดูชุดเต็ม 10 ช่อง
def plot_image(ผม, Predictions_array, true_label, img): Predictions_array, true_label, img = Predictions_array[ผม], true_label[ผม], img[ผม] plt.กริด(เท็จ) plt.xticks([]) plt.yticks([]) plt.imshow(img, ซม=plt.ซม.ไบนารี่) Predict_label = เช่น..argmax(Predictions_array) ถ้า Predict_label == true_label: สี = 'เขียว' อื่น: สี = 'สุทธิ' plt.xlabel('{} {: 2.0f}% ({}) '.รูปแบบ(class_names[Predict_label], 100*เช่น..สูงสุด(Predictions_array), class_names[true_label]), สี=สี) def plot_value_array(ผม, Predictions_array, true_label): Predictions_array, true_label = Predictions_array[ผม], true_label[ผม] plt.กริด(เท็จ) plt.xticks([]) plt.yticks([]) เรื่องนี้ = plt.บาร์(พิสัย(10), Predictions_array, สี='# 777777') plt.ylim([0, หนึ่ง]) Predict_label = เช่น..argmax(Predictions_array) เรื่องนี้[Predict_label].set_color('สุทธิ') เรื่องนี้[true_label].set_color('เขียว')
- มาดูภาพที่ 0 และ 10 ก่อน
ผม = 0 plt.รูป(มะเดื่อ=(6,3)) plt.แผนย่อย(หนึ่ง,2,หนึ่ง) plot_image(ผม, การคาดการณ์, test_labels, test_images) plt.แผนย่อย(หนึ่ง,2,2) plot_value_array(ผม, การคาดการณ์, test_labels) plt.แสดง()
ผม = 10 plt.รูป(มะเดื่อ=(6,3)) plt.แผนย่อย(หนึ่ง,2,หนึ่ง) plot_image(ผม, การคาดการณ์, test_labels, test_images) plt.แผนย่อย(หนึ่ง,2,2) plot_value_array(ผม, การคาดการณ์, test_labels) plt.แสดง()
- ตอนนี้เรามาพล็อตภาพหลาย ๆ ภาพและการคาดคะเน คนที่ถูกต้องจะเป็นสีเขียวส่วนที่ไม่ถูกต้องจะเป็นสีแดง
num_rows = 5 num_cols = 3 num_images = num_rows*num_cols plt.รูป(มะเดื่อ=(2*2*num_cols, 2*num_rows)) สำหรับ ผม ใน พิสัย(num_images): plt.แผนย่อย(num_rows, 2*num_cols, 2*ผม+หนึ่ง) plot_image(ผม, การคาดการณ์, test_labels, test_images) plt.แผนย่อย(num_rows, 2*num_cols, 2*ผม+2) plot_value_array(ผม, การคาดการณ์, test_labels) plt.แสดง()
- สุดท้ายเราจะใช้แบบจำลองที่ได้รับการฝึกฝนเพื่อทำการคาดคะเนเกี่ยวกับภาพเดียว
# หยิบภาพจากชุดข้อมูลทดสอบ img = test_images[0] พิมพ์(img.รูปร่าง)
# เพิ่มรูปภาพลงในชุดที่เป็นสมาชิกเพียงคนเดียว img = (เช่น..expand_dims(img,0)) พิมพ์(img.รูปร่าง)
Predictions_single = แบบ.ทำนาย(img) พิมพ์(Predictions_single)plot_value_array(0, Predictions_single, test_labels) plt.xticks(พิสัย(10), class_names, การหมุน=สี่ห้า) plt.แสดง()
prediction_result = เช่น..argmax(Predictions_single[0])
เอาต์พุต: 9
CIFAR-10: CNN
ชุดข้อมูล CIFAR-10 ประกอบด้วยเครื่องบินสุนัขแมวและวัตถุอื่น ๆ คุณจะประมวลผลภาพล่วงหน้าจากนั้นฝึกโครงข่ายประสาทเทียมแบบ Convolutional กับตัวอย่างทั้งหมด รูปภาพต้องได้รับการปรับให้เป็นมาตรฐานและป้ายกำกับต้องเข้ารหัสแบบร้อนครั้งเดียว กรณีการใช้งานนี้จะคลายข้อสงสัยของคุณเกี่ยวกับการจำแนกประเภทภาพ TensorFlow
- การดาวน์โหลดข้อมูล
จาก urllib.request นำเข้า urlretrieve จาก os.path นำเข้า เป็นไฟล์, เป็นเขม่า จาก tqdm นำเข้า tqdm นำเข้า tarfile cifar10_dataset_folder_path = 'cifar-10-batches-py' ชั้นเรียน ดาวน์โหลด(tqdm): last_block = 0 def ตะขอ(ตนเอง, block_num=หนึ่ง, block_size=หนึ่ง, ขนาดทั้งหมด=ไม่มี): ตนเอง.รวม = ขนาดทั้งหมด ตนเอง.อัพเดต((block_num - ตนเอง.last_block) * block_size) ตนเอง.last_block = block_num '' ' ตรวจสอบว่าดาวน์โหลดไฟล์ data (zip) แล้วหรือยัง ถ้าไม่มีให้ดาวน์โหลดจาก 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' และบันทึกเป็น cifar-10-python.tar.gz '' ' ถ้า ไม่ เป็นไฟล์('cifar-10-python.tar.gz'): ด้วย ดาวน์โหลด(หน่วย='B', unit_scale=จริง, คนงานเหมือง=หนึ่ง, desc='CIFAR-10 ชุดข้อมูล') เช่น pbar: urlretrieve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.ตะขอ) ถ้า ไม่ เป็นเขม่า(cifar10_dataset_folder_path): ด้วย tarfile.เปิด('cifar-10-python.tar.gz') เช่น น้ำมันดิน: น้ำมันดิน.แตกออก() น้ำมันดิน.ปิด()
- การนำเข้าไลบรารีที่จำเป็น
นำเข้า ดอง นำเข้า มึน เช่น เช่น. นำเข้า matplotlib.pyplot เช่น plt
- การทำความเข้าใจข้อมูล
ชุดข้อมูลดั้งเดิมคือ 10,000 × 3072 เทนเซอร์ที่แสดงในอาร์เรย์ตัวเลขโดยที่ 10,000 คือจำนวนข้อมูลตัวอย่าง ภาพมีสีและขนาด 32 × 32 การให้อาหารสามารถทำได้ทั้งในรูปแบบ (กว้าง x สูง x num_channel) หรือ (num_channel x width x height) มากำหนดป้ายกำกับกัน
def load_label_names(): กลับ ['เครื่องบิน', 'รถยนต์', 'นก', 'แมว', 'กวาง', 'หมา', 'กบ', 'ม้า', 'เรือ', 'รถบรรทุก']
- การสร้างข้อมูลใหม่
เราจะจัดรูปแบบข้อมูลใหม่ในสองขั้นตอน
ขั้นแรกแบ่งเวกเตอร์แถว (3072) ออกเป็น 3 ชิ้น แต่ละชิ้นสอดคล้องกับแต่ละช่อง สิ่งนี้ส่งผลให้มิติ (3 x 1024) ของเทนเซอร์ จากนั้นหารค่าเทนเซอร์ที่ได้จากขั้นตอนก่อนหน้าด้วย 32 32 ในที่นี้หมายถึงความกว้างของรูปภาพ ผลลัพธ์เป็น (3x32x32)
ประการที่สองเราต้องเปลี่ยนข้อมูลจาก (num_channel, width, height) เป็น (width, height, num_channel) เราจะใช้ฟังก์ชันทรานสโพส
def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): ด้วย เปิด(cifar10_dataset_folder_path + '/ data_batch_' + น(batch_id), โหมด='rb') เช่น ไฟล์: # โปรดทราบว่าประเภทการเข้ารหัสคือ 'latin1' แบทช์ = ดอง.โหลด(ไฟล์, การเข้ารหัส='ละติน 1') คุณสมบัติ = แบทช์['ข้อมูล'].ก่อร่างใหม่((เลน(แบทช์['ข้อมูล']), 3, 32, 32)).ทรานสโพส(0, 2, 3, หนึ่ง) ป้ายกำกับ = แบทช์['ป้ายกำกับ'] กลับ คุณสมบัติ, ฉลาก
- การสำรวจข้อมูล
def display_stats(cifar10_dataset_folder_path, batch_id, sample_id): คุณสมบัติ, ป้ายกำกับ = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) ถ้า ไม่ (0 <= sample_id < เลน(คุณสมบัติ)): พิมพ์('{}ตัวอย่างในชุด{}.{}อยู่นอกช่วง '.รูปแบบ(เลน(คุณสมบัติ), batch_id, sample_id)) กลับ ไม่มี พิมพ์(' สถิติของชุดงาน #{}: '.รูปแบบ(batch_id)) พิมพ์('# ตัวอย่าง:{} '.รูปแบบ(เลน(คุณสมบัติ))) label_names = load_label_names() label_counts = dict(ซิป(*เช่น..ไม่เหมือนใคร(ป้ายกำกับ, return_counts=จริง))) สำหรับ สำคัญ, มูลค่า ใน label_counts.รายการ(): พิมพ์('จำนวนฉลากของ [{}] ({}):{}'.รูปแบบ(สำคัญ, label_names[สำคัญ].ด้านบน(), มูลค่า)) sample_image = คุณสมบัติ[sample_id] sample_label = ป้ายกำกับ[sample_id] พิมพ์(' ตัวอย่างรูปภาพ{}: '.รูปแบบ(sample_id)) พิมพ์('รูปภาพ - ค่าต่ำสุด:{}มูลค่าสูงสุด:{}'.รูปแบบ(sample_image.นาที(), sample_image.สูงสุด())) พิมพ์('ภาพ - รูปร่าง:{}'.รูปแบบ(sample_image.รูปร่าง)) พิมพ์('ป้ายกำกับ - รหัสป้ายกำกับ:{}ชื่อ:{}'.รูปแบบ(sample_label, label_names[sample_label])) plt.imshow(sample_image)
%matplotlib อินไลน์ %config InlineBackend.figure_format = 'เรตินา' นำเข้า มึน เช่น เช่น. # สำรวจชุดข้อมูล batch_id = 3 sample_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, sample_id)
- การใช้ฟังก์ชันก่อนการประมวลผล
เรากำลังจะ Normalize ข้อมูลผ่าน Min-Max Normalization สิ่งนี้ทำให้ค่า x ทั้งหมดอยู่ในช่วงระหว่าง 0 ถึง 1
y = (x-min) / (สูงสุด - นาที)
def ทำให้ปกติ(x): '' ' การโต้เถียง - x: ป้อนข้อมูลภาพในอาร์เรย์ numpy [32, 32, 3] กลับ - มาตรฐาน x '' ' min_val = เช่น..นาที(x) max_val = เช่น..สูงสุด(x) x = (x-min_val) / (max_val-min_val) กลับ x
- One-Hot Encode
def one_hot_encode(x): '' ' การโต้เถียง - x: รายการป้ายกำกับ กลับ - เมทริกซ์การเข้ารหัสร้อนหนึ่งรายการ (จำนวนป้ายกำกับจำนวนคลาส) '' ' เข้ารหัส = เช่น..ศูนย์((เลน(x), 10)) สำหรับ idx, ชม ใน แจกแจง(x): เข้ารหัส[idx] [ชม] = หนึ่ง กลับ เข้ารหัส
- ประมวลผลล่วงหน้าและบันทึกข้อมูล
def _preprocess_and_save(ทำให้ปกติ, one_hot_encode, คุณสมบัติ, ป้ายกำกับ, ชื่อไฟล์): คุณสมบัติ = ทำให้ปกติ(คุณสมบัติ) ป้ายกำกับ = one_hot_encode(ป้ายกำกับ) ดอง.การถ่ายโอนข้อมูล((คุณสมบัติ, ป้ายกำกับ), เปิด(ชื่อไฟล์, 'wb')) def preprocess_and_save_data(cifar10_dataset_folder_path, ทำให้ปกติ, one_hot_encode): n_batches = 5 valid_features = [] valid_labels = [] สำหรับ batch_i ใน พิสัย(หนึ่ง, n_batches + หนึ่ง): คุณสมบัติ, ป้ายกำกับ = load_cfar10_batch(cifar10_dataset_folder_path, batch_i) # ค้นหาดัชนีเพื่อเป็นข้อมูลการตรวจสอบความถูกต้องในชุดข้อมูลทั้งหมดของชุดงาน (10%) index_of_validation = int(เลน(คุณสมบัติ) * 0.1) # ประมวลผล 90% ของชุดข้อมูลทั้งหมดของชุดงาน # - ทำให้คุณสมบัติปกติ # - one_hot_encode ฉลาก # - บันทึกในไฟล์ใหม่ชื่อ 'preprocess_batch_' + batch_number # - แต่ละไฟล์สำหรับแต่ละชุด _preprocess_and_save(ทำให้ปกติ, one_hot_encode, คุณสมบัติ[:-index_of_validation], ป้ายกำกับ[:-index_of_validation], 'preprocess_batch_' + น(batch_i) + '.p') # ต่างจากชุดข้อมูลการฝึกอบรมชุดข้อมูลการตรวจสอบความถูกต้องจะถูกเพิ่มผ่านชุดข้อมูลทั้งหมด # - รับ 10% ของชุดข้อมูลทั้งหมดของชุดงาน # - เพิ่มลงในรายการ # - valid_features # - valid_labels valid_features.ขยาย(คุณสมบัติ[-index_of_validation:]) valid_labels.ขยาย(ป้ายกำกับ[-index_of_validation:]) # ประมวลผลชุดข้อมูลการตรวจสอบความถูกต้องแบบเรียงซ้อนทั้งหมดล่วงหน้า _preprocess_and_save(ทำให้ปกติ, one_hot_encode, เช่น..อาร์เรย์(valid_features), เช่น..อาร์เรย์(valid_labels), 'preprocess_validation.p') # โหลดชุดข้อมูลการทดสอบ ด้วย เปิด(cifar10_dataset_folder_path + '/ test_batch', โหมด='rb') เช่น ไฟล์: แบทช์ = ดอง.โหลด(ไฟล์, การเข้ารหัส='ละติน 1') # ประมวลผลข้อมูลการทดสอบล่วงหน้า test_features = แบทช์['ข้อมูล'].ก่อร่างใหม่((เลน(แบทช์['ข้อมูล']), 3, 32, 32)).ทรานสโพส(0, 2, 3, หนึ่ง) test_labels = แบทช์['ป้ายกำกับ'] # ประมวลผลล่วงหน้าและบันทึกข้อมูลการทดสอบทั้งหมด _preprocess_and_save(ทำให้ปกติ, one_hot_encode, เช่น..อาร์เรย์(test_features), เช่น..อาร์เรย์(test_labels), 'preprocess_training.p')
preprocess_and_save_data(cifar10_dataset_folder_path, ทำให้ปกติ, one_hot_encode)
- ด่าน
นำเข้า ดอง valid_features, valid_labels = ดอง.โหลด(เปิด('preprocess_validation.p', โหมด='rb'))
- การสร้างเครือข่าย
โมเดลทั้งหมดประกอบด้วย 14 ชั้นทั้งหมด
นำเข้า เทนเซอร์โฟลว์ เช่น tf def conv_net(x, keep_prob): conv1_filter = tf.ตัวแปร(tf.truncated_normal(รูปร่าง=[3, 3, 3, 64], ค่าเฉลี่ย=0, stddev=0.08)) conv2_filter = tf.ตัวแปร(tf.truncated_normal(รูปร่าง=[3, 3, 64, 128], ค่าเฉลี่ย=0, stddev=0.08)) conv3_filter = tf.ตัวแปร(tf.truncated_normal(รูปร่าง=[5, 5, 128, 256], ค่าเฉลี่ย=0, stddev=0.08)) conv4_filter = tf.ตัวแปร(tf.truncated_normal(รูปร่าง=[5, 5, 256, 512], ค่าเฉลี่ย=0, stddev=0.08)) # 1, 2 Conv1 = tf.nos.Conv2d(x, conv1_filter, ก้าว=[หนึ่ง,หนึ่ง,หนึ่ง,หนึ่ง], การขยายความ='เหมือนกัน') Conv1 = tf.nos.relu(Conv1) Conv1_pool = tf.nos.max_pool(Conv1, ksize=[หนึ่ง,2,2,หนึ่ง], ก้าว=[หนึ่ง,2,2,หนึ่ง], การขยายความ='เหมือนกัน') Conv1_bn = tf.ชั้น.batch_normalization(Conv1_pool) # 3 4 Conv2 = tf.nos.Conv2d(Conv1_bn, conv2_filter, ก้าว=[หนึ่ง,หนึ่ง,หนึ่ง,หนึ่ง], การขยายความ='เหมือนกัน') Conv2 = tf.nos.relu(Conv2) Conv2_pool = tf.nos.max_pool(Conv2, ksize=[หนึ่ง,2,2,หนึ่ง], ก้าว=[หนึ่ง,2,2,หนึ่ง], การขยายความ='เหมือนกัน') Conv2_bn = tf.ชั้น.batch_normalization(Conv2_pool) # 5, 6 Conv3 = tf.nos.Conv2d(Conv2_bn, conv3_filter, ก้าว=[หนึ่ง,หนึ่ง,หนึ่ง,หนึ่ง], การขยายความ='เหมือนกัน') Conv3 = tf.nos.relu(Conv3) Conv3_pool = tf.nos.max_pool(Conv3, ksize=[หนึ่ง,2,2,หนึ่ง], ก้าว=[หนึ่ง,2,2,หนึ่ง], การขยายความ='เหมือนกัน') Conv3_bn = tf.ชั้น.batch_normalization(Conv3_pool) # 7, 8 Conv4 = tf.nos.Conv2d(Conv3_bn, conv4_filter, ก้าว=[หนึ่ง,หนึ่ง,หนึ่ง,หนึ่ง], การขยายความ='เหมือนกัน') Conv4 = tf.nos.relu(Conv4) Conv4_pool = tf.nos.max_pool(Conv4, ksize=[หนึ่ง,2,2,หนึ่ง], ก้าว=[หนึ่ง,2,2,หนึ่ง], การขยายความ='เหมือนกัน') Conv4_bn = tf.ชั้น.batch_normalization(Conv4_pool) # 9 แบน = tf.มีส่วน.ชั้น.เรียบ(Conv4_bn) # 10 เต็ม 1 = tf.มีส่วน.ชั้น.เชื่อมต่ออย่างเต็มที่(ปัจจัยการผลิต=แบน, num_outputs=128, activation_fn=tf.nos.relu) เต็ม 1 = tf.nos.ออกกลางคัน(เต็ม 1, keep_prob) เต็ม 1 = tf.ชั้น.batch_normalization(เต็ม 1) # สิบเอ็ด เต็ม 2 = tf.มีส่วน.ชั้น.เชื่อมต่ออย่างเต็มที่(ปัจจัยการผลิต=เต็ม 1, num_outputs=256, activation_fn=tf.nos.relu) เต็ม 2 = tf.nos.ออกกลางคัน(เต็ม 2, keep_prob) เต็ม 2 = tf.ชั้น.batch_normalization(เต็ม 2) # 12 เต็ม 3 = tf.มีส่วน.ชั้น.เชื่อมต่ออย่างเต็มที่(ปัจจัยการผลิต=เต็ม 2, num_outputs=512, activation_fn=tf.nos.relu) เต็ม 3 = tf.nos.ออกกลางคัน(เต็ม 3, keep_prob) เต็ม 3 = tf.ชั้น.batch_normalization(เต็ม 3) # 13 เต็ม 4 = tf.มีส่วน.ชั้น.เชื่อมต่ออย่างเต็มที่(ปัจจัยการผลิต=เต็ม 3, num_outputs=1024, activation_fn=tf.nos.relu) เต็ม 4 = tf.nos.ออกกลางคัน(เต็ม 4, keep_prob) เต็ม 4 = tf.ชั้น.batch_normalization(เต็ม 4) # 14 ออก = tf.มีส่วน.ชั้น.เชื่อมต่ออย่างเต็มที่(ปัจจัยการผลิต=เต็ม 3, num_outputs=10, activation_fn=ไม่มี) กลับ ออก
- ไฮเปอร์พารามิเตอร์
ยุค = 10 batch_size = 128 keep_probability = 0.7 อัตราการเรียนรู้ = 0.001
บันทึก = conv_net(x, keep_prob) แบบ = tf.เอกลักษณ์(บันทึก, ชื่อ='logits') # ชื่อบันทึก Tensor เพื่อให้สามารถโหลดจากดิสก์หลังการฝึกอบรม # การสูญเสียและเครื่องมือเพิ่มประสิทธิภาพ ค่าใช้จ่าย = tf.Reduce_mean(tf.nos.softmax_cross_entropy_with_logits(บันทึก=บันทึก, ป้ายกำกับ=ย)) เครื่องมือเพิ่มประสิทธิภาพ = tf.รถไฟ.AdamOptimizer(อัตราการเรียนรู้=อัตราการเรียนรู้).ย่อเล็กสุด(ค่าใช้จ่าย) # ความแม่นยำ correct_pred = tf.เท่ากัน(tf.argmax(บันทึก, หนึ่ง), tf.argmax(ย, หนึ่ง)) ความถูกต้อง = tf.Reduce_mean(tf.นักแสดง(correct_pred, tf.ลอย 32), ชื่อ='ความถูกต้อง')
- ฝึก Neural Network
#Single การเพิ่มประสิทธิภาพ
def train_neural_network(เซสชัน, เครื่องมือเพิ่มประสิทธิภาพ, keep_probability, feature_batch, label_batch): เซสชัน.วิ่ง(เครื่องมือเพิ่มประสิทธิภาพ, feed_dict={ x: feature_batch, ย: label_batch, keep_prob: keep_probability })
#Showing สถิติ def print_stats(เซสชัน, feature_batch, label_batch, ค่าใช้จ่าย, ความถูกต้อง): ขาดทุน = sess.วิ่ง(ค่าใช้จ่าย, feed_dict={ x: feature_batch, ย: label_batch, keep_prob: หนึ่ง. }) valid_acc = sess.วิ่ง(ความถูกต้อง, feed_dict={ x: valid_features, ย: valid_labels, keep_prob: หนึ่ง. }) พิมพ์('การสูญเสีย:{:> 10.4f}ความถูกต้องในการตรวจสอบ:{: .6f}'.รูปแบบ(ขาดทุน, valid_acc))
- ฝึกฝนอย่างเต็มที่และประหยัดโมเดล
def batch_features_labels(คุณสมบัติ, ป้ายกำกับ, batch_size): '' ' แยกคุณสมบัติและป้ายกำกับออกเป็นแบทช์ '' ' สำหรับ เริ่มต้น ใน พิสัย(0, เลน(คุณสมบัติ), batch_size): จบ = นาที(เริ่มต้น + batch_size, เลน(คุณสมบัติ)) ผลผลิต คุณสมบัติ[เริ่มต้น:จบ], ป้ายกำกับ[เริ่มต้น:จบ] def load_preprocess_training_batch(batch_id, batch_size): '' ' โหลดข้อมูลการฝึกอบรมที่ประมวลผลล่วงหน้าแล้วส่งคืนเป็นชุดหรือน้อยกว่า '' ' ชื่อไฟล์ = 'preprocess_batch_' + น(batch_id) + '.p' คุณสมบัติ, ป้ายกำกับ = ดอง.โหลด(เปิด(ชื่อไฟล์, โหมด='rb')) # ส่งคืนข้อมูลการฝึกอบรมเป็นชุดขนาดหรือน้อยกว่า กลับ batch_features_labels(คุณสมบัติ, ป้ายกำกับ, batch_size)
# ออมสินโมเดลและเส้นทาง
save_model_path = './image_classification' พิมพ์('การฝึก ... ') ด้วย tf.เซสชัน() เช่น sess: # การเริ่มต้นตัวแปร sess.วิ่ง(tf.global_variables_initializer()) # รอบการฝึก สำหรับ ยุค ใน พิสัย(ยุค): # วนซ้ำทุกแบทช์ n_batches = 5 สำหรับ batch_i ใน พิสัย(หนึ่ง, n_batches + หนึ่ง): สำหรับ batch_features, batch_labels ใน load_preprocess_training_batch(batch_i, batch_size): train_neural_network(sess, เครื่องมือเพิ่มประสิทธิภาพ, keep_probability, batch_features, batch_labels) พิมพ์('ยุค{:> 2}, CIFAR-10 Batch{}: '.รูปแบบ(ยุค + หนึ่ง, batch_i), จบ='') print_stats(sess, batch_features, batch_labels, ค่าใช้จ่าย, ความถูกต้อง) # บันทึกโมเดล ประหยัด = tf.รถไฟ.ประหยัด() save_path = ประหยัด.บันทึก(sess, save_model_path)
การตั้งค่า hadoop บน Ubuntu
ตอนนี้ส่วนสำคัญของ Tensorflow Image Classification เสร็จสิ้นแล้ว ตอนนี้ได้เวลาทดสอบโมเดล
- การทดสอบแบบจำลอง
นำเข้า ดอง นำเข้า มึน เช่น เช่น. นำเข้า matplotlib.pyplot เช่น plt จาก sklearn.preprocessing นำเข้า LabelBinarizer def batch_features_labels(คุณสมบัติ, ป้ายกำกับ, batch_size): '' ' แยกคุณสมบัติและป้ายกำกับออกเป็นแบทช์ '' ' สำหรับ เริ่มต้น ใน พิสัย(0, เลน(คุณสมบัติ), batch_size): จบ = นาที(เริ่มต้น + batch_size, เลน(คุณสมบัติ)) ผลผลิต คุณสมบัติ[เริ่มต้น:จบ], ป้ายกำกับ[เริ่มต้น:จบ] def display_image_predictions(คุณสมบัติ, ป้ายกำกับ, การคาดการณ์, top_n_predictions): n_classes = 10 label_names = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.พอดี(พิสัย(n_classes)) label_ids = label_binarizer.inverse_transform(เช่น..อาร์เรย์(ป้ายกำกับ)) รูปที่, แกน = plt.พล็อตย่อย(จมูก=top_n_predictions, ncols=2, มะเดื่อ=(ยี่สิบ, 10)) รูปที่.tight_layout() รูปที่.suptitle('การคาดการณ์ Softmax', ขนาดตัวอักษร=ยี่สิบ, ย=1.1) n_predictions = 3 ขอบ = 0.05 ind = เช่น..arange(n_predictions) ความกว้าง = (หนึ่ง. - 2. * ขอบ) / n_predictions สำหรับ image_i, (ลักษณะเฉพาะ, label_id, pred_indicies, pred_values) ใน แจกแจง(ซิป(คุณสมบัติ, label_ids, การคาดการณ์.ดัชนี, การคาดการณ์.ค่า)): ถ้า (image_i < top_n_predictions): pred_names = [label_names[pred_i] สำหรับ pred_i ใน pred_indicies] correct_name = label_names[label_id] แกน[image_i] [0].imshow((ลักษณะเฉพาะ*255).astype(เช่น..int32, สำเนา=เท็จ)) แกน[image_i] [0].set_title(correct_name) แกน[image_i] [0].set_axis_off() แกน[image_i] [หนึ่ง].barh(ind + ขอบ, pred_values[:3], ความกว้าง) แกน[image_i] [หนึ่ง].set_yticks(ind + ขอบ) แกน[image_i] [หนึ่ง].set_yticklabels(pred_names[::-หนึ่ง]) แกน[image_i] [หนึ่ง].set_xticks([0, 0.5, 1.0])
%matplotlib อินไลน์ %config InlineBackend.figure_format = 'เรตินา' นำเข้า เทนเซอร์โฟลว์ เช่น tf นำเข้า ดอง นำเข้า สุ่ม save_model_path = './image_classification' batch_size = 64 n_samples = 10 top_n_predictions = 5 def test_model(): test_features, test_labels = ดอง.โหลด(เปิด('preprocess_training.p', โหมด='rb')) loaded_graph = tf.กราฟ() ด้วย tf.เซสชัน(กราฟ=loaded_graph) เช่น sess: # โหลดโมเดล รถตักดิน = tf.รถไฟ.import_meta_graph(save_model_path + '.meta') รถตักดิน.คืนค่า(sess, save_model_path) # รับ Tensors จากโมเดลที่โหลด loaded_x = loaded_graph.get_tensor_by_name('input_x: 0') loaded_y = loaded_graph.get_tensor_by_name('output_y: 0') loaded_keep_prob = loaded_graph.get_tensor_by_name('keep_prob: 0') loaded_logits = loaded_graph.get_tensor_by_name('บันทึก: 0') loaded_acc = loaded_graph.get_tensor_by_name('ความถูกต้อง: 0') # รับความแม่นยำในแบทช์สำหรับข้อ จำกัด ของหน่วยความจำ test_batch_acc_total = 0 test_batch_count = 0 สำหรับ train_feature_batch, train_label_batch ใน batch_features_labels(test_features, test_labels, batch_size): test_batch_acc_total + = sess.วิ่ง( loaded_acc, feed_dict={loaded_x: train_feature_batch, loaded_y: train_label_batch, loaded_keep_prob: 1.0}) test_batch_count + = หนึ่ง พิมพ์('ความแม่นยำในการทดสอบ:{} '.รูปแบบ(test_batch_acc_total/test_batch_count)) # พิมพ์ตัวอย่างสุ่ม random_test_features, random_test_labels = ทูเพิล(ซิป(*สุ่ม.ตัวอย่าง(รายการ(ซิป(test_features, test_labels)), n_samples))) random_test_predictions = sess.วิ่ง( tf.nos.top_k(tf.nos.ซอฟต์แม็กซ์(loaded_logits), top_n_predictions), feed_dict={loaded_x: random_test_features, loaded_y: random_test_labels, loaded_keep_prob: 1.0}) display_image_predictions(random_test_features, random_test_labels, random_test_predictions, top_n_predictions) test_model()
เอาท์พุต: ความแม่นยำในการทดสอบ: 0.5882762738853503
ตอนนี้หากคุณฝึกโครงข่ายประสาทเทียมสำหรับยุคต่างๆหรือเปลี่ยนฟังก์ชันการเปิดใช้งานคุณอาจได้รับผลลัพธ์ที่แตกต่างออกไปซึ่งอาจมีความแม่นยำที่ดีกว่า
ดังนั้นเราจึงมาถึงตอนจบของบทความการจำแนกภาพ TensorFlow นี้ ฉันแน่ใจว่าตอนนี้คุณสามารถใช้แบบเดียวกันนี้เพื่อจัดประเภทของรูปภาพได้แล้วและคุณไม่ใช่มือใหม่ในการจัดหมวดหมู่รูปภาพ
Edureka’s ด้วย Python Certification Training ได้รับการดูแลโดยผู้เชี่ยวชาญในอุตสาหกรรมตามข้อกำหนดและความต้องการของอุตสาหกรรม คุณจะเชี่ยวชาญแนวคิดต่างๆเช่นฟังก์ชัน SoftMax, Autoencoder Neural Networks, เครื่อง Boltzmann ที่ จำกัด (RBM), Keras & TFLearn หลักสูตรนี้ได้รับการดูแลเป็นพิเศษโดยผู้เชี่ยวชาญในอุตสาหกรรมพร้อมกรณีศึกษาแบบเรียลไทม์