Phân loại hình ảnh một nhiệm vụ mà ngay cả một đứa trẻ có thể làm trong vài giây, nhưng đối với một chiếc máy, đó là một nhiệm vụ khó khăn cho đến khi những tiến bộ gần đây trong và Học kĩ càng . Ô tô tự lái có thể phát hiện các đối tượng và thực hiện các hành động cần thiết trong thời gian thực và hầu hết điều này là có thể vì Phân loại hình ảnh. Trong bài viết này, tôi sẽ hướng dẫn bạn các chủ đề sau:
- TensorFlow là gì?
- Phân loại hình ảnh là gì?
- Phân loại hình ảnh TensorFlow: Thời trang MNIST
- CIFAR 10: CNN
TensorFlow là gì?
TensorFlow là Khuôn khổ học máy mã nguồn mở của Google để lập trình luồng dữ liệu trong nhiều nhiệm vụ. Các nút trong biểu đồ đại diện cho các phép toán, trong khi các cạnh biểu đồ biểu thị các mảng dữ liệu đa chiều được giao tiếp giữa chúng.
Tensors chỉ là mảng nhiều chiều, một phần mở rộng của bảng 2 chiều thành dữ liệu có chiều cao hơn. Có nhiều tính năng của Tensorflow phù hợp với Học sâu và thư viện nguồn mở cốt lõi của nó giúp bạn phát triển và đào tạo các mô hình ML.
Phân loại hình ảnh là gì?
Mục đích của Phân loại Hình ảnh là phân loại tất cả các pixel trong một hình ảnh kỹ thuật số thành một trong một số độ che phủ đất các lớp học hoặc là chủ đề . Dữ liệu được phân loại này sau đó có thể được sử dụng để sản xuất bản đồ chuyên đề của lớp phủ đất hiện diện trong một hình ảnh.
Bây giờ Tùy thuộc vào sự tương tác giữa người phân tích và máy tính trong quá trình phân loại, có hai kiểu phân loại:
- Giám sát &
- Không được giám sát
Vì vậy, không lãng phí thời gian, hãy bắt đầu với Phân loại hình ảnh TensorFlow. Tôi có 2 ví dụ: dễ và khó. Hãy tiếp tục với điều dễ dàng.
Phân loại hình ảnh TensorFlow: Thời trang MNIST
Tập dữ liệu MNIST thời trang
Ở đây chúng ta sẽ sử dụng Tập dữ liệu MNIST thời trang, chứa 70.000 hình ảnh thang độ xám trong 10 danh mục. Chúng tôi sẽ sử dụng 60000 để đào tạo và 10000 còn lại cho mục đích thử nghiệm. Bạn có thể truy cập MNIST Thời trang trực tiếp từ TensorFlow, chỉ cần nhập và tải dữ liệu.
- Hãy nhập các thư viện trước
từ __future__ nhập tuyệt đối_import, phân chia, in_ Chức năng # TensorFlow và tf.keras nhập tensorflow dưới dạng tf từ tensorflow nhập keras # Thư viện trợ giúp nhập numpy dưới dạng np nhập matplotlib.pyplot dưới dạng plt
- Hãy tải dữ liệu
fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data ()
- Tiếp theo, chúng ta sẽ ánh xạ các hình ảnh thành các lớp
class_names = ['T-shirt / top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
- Khám phá dữ liệu
train_images.hình dạng
# Mỗi Nhãn nằm trong khoảng từ 0-9
train_labels
test_images.hình dạng
- Bây giờ, đã đến lúc xử lý trước dữ liệu.
làm ơn.nhân vật() làm ơn.imshow(train_images[0]) làm ơn.thanh màu() làm ơn.lưới(Sai) làm ơn.chỉ()
#Nếu bạn kiểm tra hình ảnh đầu tiên trong tập huấn luyện, bạn sẽ thấy rằng các giá trị pixel nằm trong khoảng từ 0 đến 255.
- Chúng tôi phải chia tỷ lệ hình ảnh từ 0-1 để đưa nó vào Mạng thần kinh
train_images = train_images / 255.0 test_images = test_images / 255.0
- Hãy hiển thị một số hình ảnh.
làm ơn.nhân vật(sung=(10,10)) cho Tôi trong phạm vi(25): làm ơn.subplot(5,5,Tôi+một) làm ơn.xticks([]) làm ơn.cây gậy([]) làm ơn.lưới(Sai) làm ơn.imshow(train_images[Tôi], cmap=làm ơn.cm.nhị phân) làm ơn.xlabel(class_names[train_labels[Tôi]]) làm ơn.chỉ()
- Thiết lập các lớp
mô hình = cứng.Tuần tự([ cứng.lớp.Làm phẳng(input_shape=(28, 28)), cứng.lớp.Ngu độn(128, kích hoạt=tf.không.relu), cứng.lớp.Ngu độn(10, kích hoạt=tf.không.softmax) ])
- Biên dịch mô hình
mô hình.biên dịch(người tối ưu hóa='adam', thua='Slice_categorical_crossentropy', số liệu=['sự chính xác'])
- Đào tạo người mẫu
mô hình.Phù hợp(train_images, train_labels, kỷ nguyên=10)
không gian tên có nghĩa là gì trong c ++
- Đánh giá độ chính xác
test_loss, test_acc = mô hình.đánh giá(test_images, test_labels) in('Kiểm tra độ chính xác:', test_acc)
- Đưa ra dự đoán
phỏng đoán = mô hình.dự đoán(test_images)
phỏng đoán[0]
Dự đoán là một dãy 10 số. Những điều này mô tả 'sự tự tin' của người mẫu mà hình ảnh tương ứng với mỗi trong số 10 mặt hàng quần áo khác nhau. Chúng ta có thể xem nhãn nào có giá trị tin cậy cao nhất.
ví dụ..argmax(phỏng đoán[0])#Model tự tin nhất đó là ankle boot. Hãy xem nó có chính xác khôngĐầu ra: 9
test_labels[0]
Đầu ra: 9
- Bây giờ, đã đến lúc xem toàn bộ 10 kênh
phản đối plot_image(Tôi, dự đoán_array, true_label, img): dự đoán_array, true_label, img = dự đoán_array[Tôi], true_label[Tôi], img[Tôi] làm ơn.lưới(Sai) làm ơn.xticks([]) làm ơn.cây gậy([]) làm ơn.imshow(img, cmap=làm ơn.cm.nhị phân) nhãn_bản_công_tác = ví dụ..argmax(dự đoán_array) nếu nhãn_bản_công_tác == true_label: màu sắc = 'màu xanh lá' khác: màu sắc = 'mạng lưới' làm ơn.xlabel('{} {: 2.0f}% ({}) '.định dạng(class_names[nhãn_bản_công_tác], 100*ví dụ..tối đa(dự đoán_array), class_names[true_label]), màu sắc=màu sắc) phản đối plot_value_array(Tôi, dự đoán_array, true_label): dự đoán_array, true_label = dự đoán_array[Tôi], true_label[Tôi] làm ơn.lưới(Sai) làm ơn.xticks([]) làm ơn.cây gậy([]) lô đất này = làm ơn.quán ba(phạm vi(10), dự đoán_array, màu sắc='# 777777') làm ơn.ylim([0, một]) nhãn_bản_công_tác = ví dụ..argmax(dự đoán_array) lô đất này[nhãn_bản_công_tác].set_color('mạng lưới') lô đất này[true_label].set_color('màu xanh lá')
- Trước tiên, hãy xem hình ảnh thứ 0 và thứ 10
Tôi = 0 làm ơn.nhân vật(sung=(6,3)) làm ơn.subplot(một,2,một) plot_image(Tôi, phỏng đoán, test_labels, test_images) làm ơn.subplot(một,2,2) plot_value_array(Tôi, phỏng đoán, test_labels) làm ơn.chỉ()
Tôi = 10 làm ơn.nhân vật(sung=(6,3)) làm ơn.subplot(một,2,một) plot_image(Tôi, phỏng đoán, test_labels, test_images) làm ơn.subplot(một,2,2) plot_value_array(Tôi, phỏng đoán, test_labels) làm ơn.chỉ()
- Bây giờ, hãy vẽ một số hình ảnh và dự đoán của chúng. Những cái đúng có màu xanh lá cây, trong khi những cái sai có màu đỏ.
num_rows = 5 num_cols = 3 num_images = num_rows*num_cols làm ơn.nhân vật(sung=(2*2*num_cols, 2*num_rows)) cho Tôi trong phạm vi(num_images): làm ơn.subplot(num_rows, 2*num_cols, 2*Tôi+một) plot_image(Tôi, phỏng đoán, test_labels, test_images) làm ơn.subplot(num_rows, 2*num_cols, 2*Tôi+2) plot_value_array(Tôi, phỏng đoán, test_labels) làm ơn.chỉ()
- Cuối cùng, chúng tôi sẽ sử dụng mô hình đã đào tạo để đưa ra dự đoán về một hình ảnh duy nhất.
# Lấy hình ảnh từ tập dữ liệu thử nghiệm img = test_images[0] in(img.hình dạng)
# Thêm hình ảnh vào một lô mà nó là thành viên duy nhất. img = (ví dụ..expand_dims(img,0)) in(img.hình dạng)
dự đoán_single = mô hình.dự đoán(img) in(dự đoán_single)plot_value_array(0, dự đoán_single, test_labels) làm ơn.xticks(phạm vi(10), class_names, Vòng xoay=Bốn năm) làm ơn.chỉ()
dự đoán_ kết quả = ví dụ..argmax(dự đoán_single[0])
Đầu ra: 9
CIFAR-10: CNN
Bộ dữ liệu CIFAR-10 bao gồm máy bay, chó, mèo và các đối tượng khác. Bạn sẽ xử lý trước các hình ảnh, sau đó đào tạo một mạng nơ-ron phức hợp trên tất cả các mẫu. Hình ảnh cần được chuẩn hóa và các nhãn cần được mã hóa một nóng. Trường hợp sử dụng này chắc chắn sẽ xóa tan những nghi ngờ của bạn về Phân loại hình ảnh TensorFlow.
- Tải xuống dữ liệu
từ urllib.request nhập khẩu urlretrieve từ os.path nhập khẩu isfile, là muội từ tqdm nhập khẩu tqdm nhập khẩu tarfile cifar10_dataset_folder_path = 'cifar-10-batches-py' lớp học Tiến độ tải xuống(tqdm): last_block = 0 phản đối móc câu(bản thân, block_num=một, kích thước khối=một, total_size=không ai): bản thân.toàn bộ = total_size bản thân.cập nhật((block_num - bản thân.last_block) * kích thước khối) bản thân.last_block = block_num '' kiểm tra xem tệp dữ liệu (zip) đã được tải xuống chưa nếu không, hãy tải xuống từ 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' và lưu dưới dạng cifar-10-python.tar.gz '' nếu không phải isfile('cifar-10-python.tar.gz'): với Tiến độ tải xuống(đơn vị='B', unit_scale=Thật, miniters=một, desc='Bộ dữ liệu CIFAR-10') như pbar: urlretrieve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.móc câu) nếu không phải là muội(cifar10_dataset_folder_path): với tarfile.mở('cifar-10-python.tar.gz') như nhựa đường: nhựa đường.trích xuất() nhựa đường.đóng()
- Nhập các thư viện cần thiết
nhập khẩu dưa muối nhập khẩu numpy như ví dụ. nhập khẩu matplotlib.pyplot như làm ơn
- Hiểu dữ liệu
Lô Dữ liệu ban đầu có kích thước 10000 × 3072 tensor được biểu thị trong một mảng numpy, trong đó 10000 là số lượng dữ liệu mẫu. Hình ảnh có màu và kích thước 32 × 32. Việc cung cấp có thể được thực hiện theo định dạng (chiều rộng x chiều cao x số kênh) hoặc (số kênh x chiều rộng x chiều cao). Hãy xác định các nhãn.
phản đối load_label_names(): trở về ['Máy bay', 'ô tô', 'chim', 'con mèo', 'con nai', 'chó', 'ếch', 'con ngựa', 'tàu', 'xe tải']
- Định hình lại dữ liệu
Chúng tôi sẽ định hình lại dữ liệu trong hai giai đoạn
Đầu tiên, chia vector hàng (3072) thành 3 phần. Mỗi phần tương ứng với mỗi kênh. Điều này dẫn đến kích thước (3 x 1024) của một tensor. Sau đó Chia tensor kết quả từ bước trước với 32. 32 ở đây có nghĩa là chiều rộng của hình ảnh. Kết quả là (3x32x32).
Thứ hai, chúng ta phải chuyển dữ liệu từ (num_channel, width, height) sang (width, height, num_channel). Để làm được điều đó, chúng ta sẽ sử dụng hàm chuyển vị.
phản đối load_cfar10_batch(cifar10_dataset_folder_path, batch_id): với mở(cifar10_dataset_folder_path + '/ data_batch_' + p(batch_id), chế độ='rb') như tập tin: # lưu ý loại mã hóa là 'latin1' lô hàng = dưa muối.tải(tập tin, mã hóa='latin1') đặc trưng = lô hàng['dữ liệu'].định hình lại((len(lô hàng['dữ liệu']), 3, 32, 32)).đổi chỗ(0, 2, 3, một) nhãn mác = lô hàng['nhãn'] trở về đặc trưng, nhãn
- Khám phá dữ liệu
phản đối display_stats(cifar10_dataset_folder_path, batch_id, sample_id): đặc trưng, nhãn mác = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) nếu không phải (0 <= sample_id < len(đặc trưng)): in('{}mẫu trong lô{}.{}nằm ngoài phạm vi. '.định dạng(len(đặc trưng), batch_id, sample_id)) trở về không ai in(' Số liệu thống kê của lô #{}: '.định dạng(batch_id)) in('# mẫu:{} '.định dạng(len(đặc trưng))) label_names = load_label_names() label_counts = mệnh lệnh(zip(*ví dụ..độc nhất(nhãn mác, return_counts=Thật))) cho Chìa khóa, giá trị trong label_counts.mặt hàng(): in('Số lượng nhãn của [{}] ({}):{}'.định dạng(Chìa khóa, label_names[Chìa khóa].phía trên(), giá trị)) hình ảnh mẫu = đặc trưng[sample_id] sample_label = nhãn mác[sample_id] in(' Ví dụ về Hình ảnh{}: '.định dạng(sample_id)) in('Hình ảnh - Giá trị Tối thiểu:{}Giá trị tối đa:{}'.định dạng(hình ảnh mẫu.min(), hình ảnh mẫu.tối đa())) in('Hình ảnh - Hình dạng:{}'.định dạng(hình ảnh mẫu.hình dạng)) in('Nhãn - Id Nhãn:{}Tên:{}'.định dạng(sample_label, label_names[sample_label])) làm ơn.imshow(hình ảnh mẫu)
%matplotlib nội tuyến %cấu hình InlineBackend.figure_format = 'võng mạc' nhập khẩu numpy như ví dụ. # Khám phá tập dữ liệu batch_id = 3 sample_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, sample_id)
- Thực hiện các chức năng tiền xử lý
Chúng tôi sẽ Chuẩn hóa dữ liệu thông qua Chuẩn hóa Tối đa. Điều này chỉ đơn giản là làm cho tất cả các giá trị x nằm trong khoảng từ 0 đến 1.
y = (x-min) / (max-min)
phản đối bình thường hóa(x): '' tranh luận - x: dữ liệu hình ảnh đầu vào trong mảng numpy [32, 32, 3] trở về - chuẩn hóa x '' min_val = ví dụ..min(x) max_val = ví dụ..tối đa(x) x = (x-min_val) / (max_val-min_val) trở về x
- Mã hóa một nóng
phản đối one_hot_encode(x): '' tranh luận - x: danh sách các nhãn trở về - một ma trận mã hóa nóng (số lượng nhãn, số lớp) '' được mã hóa = ví dụ..số không((len(x), 10)) cho idx, giờ trong liệt kê(x): được mã hóa[idx] [giờ] = một trở về được mã hóa
- Tiền xử lý và lưu dữ liệu
phản đối _preprocess_and_save(bình thường hóa, one_hot_encode, đặc trưng, nhãn mác, tên tập tin): đặc trưng = bình thường hóa(đặc trưng) nhãn mác = one_hot_encode(nhãn mác) dưa muối.đổ((đặc trưng, nhãn mác), mở(tên tập tin, 'wb')) phản đối prerocess_and_save_data(cifar10_dataset_folder_path, bình thường hóa, one_hot_encode): n_batches = 5 valid_features = [] valid_labels = [] cho batch_i trong phạm vi(một, n_batches + một): đặc trưng, nhãn mác = load_cfar10_batch(cifar10_dataset_folder_path, batch_i) # tìm chỉ mục là điểm làm dữ liệu xác thực trong toàn bộ tập dữ liệu của lô (10%) index_of_validation = int(len(đặc trưng) * 0,1) # xử lý trước 90% toàn bộ tập dữ liệu của lô # - chuẩn hóa các tính năng # - one_hot_encode các nhãn # - lưu trong một tệp mới có tên, 'preprocess_batch_' + batch_number # - mỗi tệp cho mỗi lô _preprocess_and_save(bình thường hóa, one_hot_encode, đặc trưng[:-index_of_validation], nhãn mác[:-index_of_validation], 'preprocess_batch_' + p(batch_i) + '.p') # không giống như tập dữ liệu đào tạo, tập dữ liệu xác thực sẽ được thêm vào thông qua tất cả tập dữ liệu hàng loạt # - lấy 10% tập dữ liệu toàn bộ của lô # - thêm chúng vào danh sách # - valid_features # - hợp lệ valid_features.mở rộng(đặc trưng[-index_of_validation:]) valid_labels.mở rộng(nhãn mác[-index_of_validation:]) # xử lý trước tất cả tập dữ liệu xác thực xếp chồng lên nhau _preprocess_and_save(bình thường hóa, one_hot_encode, ví dụ..mảng(valid_features), ví dụ..mảng(valid_labels), 'preprocess_validation.p') # tải tập dữ liệu kiểm tra với mở(cifar10_dataset_folder_path + '/ test_batch', chế độ='rb') như tập tin: lô hàng = dưa muối.tải(tập tin, mã hóa='latin1') # xử lý trước dữ liệu thử nghiệm test_features = lô hàng['dữ liệu'].định hình lại((len(lô hàng['dữ liệu']), 3, 32, 32)).đổi chỗ(0, 2, 3, một) test_labels = lô hàng['nhãn'] # Tiền xử lý và Lưu tất cả dữ liệu thử nghiệm _preprocess_and_save(bình thường hóa, one_hot_encode, ví dụ..mảng(test_features), ví dụ..mảng(test_labels), 'preprocess_training.p')
prerocess_and_save_data(cifar10_dataset_folder_path, bình thường hóa, one_hot_encode)
- Trạm kiểm soát
nhập khẩu dưa muối valid_features, valid_labels = dưa muối.tải(mở('preprocess_validation.p', chế độ='rb'))
- Xây dựng mạng
Toàn bộ mô hình bao gồm tổng cộng 14 lớp.
nhập khẩu dòng chảy căng thẳng như tf phản đối mạng chuyển đổi(x, keep_prob): convert1_filter = tf.Biến đổi(tf.truncated_normal(hình dạng=[3, 3, 3, 64], nghĩa là=0, stddev=0,08)) chuyển đổi = tf.Biến đổi(tf.truncated_normal(hình dạng=[3, 3, 64, 128], nghĩa là=0, stddev=0,08)) chuyển đổi_filter = tf.Biến đổi(tf.truncated_normal(hình dạng=[5, 5, 128, 256], nghĩa là=0, stddev=0,08)) convert_filter = tf.Biến đổi(tf.truncated_normal(hình dạng=[5, 5, 256, 512], nghĩa là=0, stddev=0,08)) # 1, 2 chuyển đổi 1 = tf.không.chuyển đổi(x, convert1_filter, sải bước=[một,một,một,một], đệm lót='TƯƠNG TỰ') chuyển đổi 1 = tf.không.relu(chuyển đổi 1) chuyển đổi = tf.không.max_pool(chuyển đổi 1, ksize=[một,2,2,một], sải bước=[một,2,2,một], đệm lót='TƯƠNG TỰ') chuyển đổi = tf.lớp.batch_normalization(chuyển đổi) # 3. 4 chuyển đổi 2 = tf.không.chuyển đổi(chuyển đổi, chuyển đổi, sải bước=[một,một,một,một], đệm lót='TƯƠNG TỰ') chuyển đổi 2 = tf.không.relu(chuyển đổi 2) chuyển đổi = tf.không.max_pool(chuyển đổi 2, ksize=[một,2,2,một], sải bước=[một,2,2,một], đệm lót='TƯƠNG TỰ') convert2_bn = tf.lớp.batch_normalization(chuyển đổi) # 5, 6 chuyển đổi 3 = tf.không.chuyển đổi(convert2_bn, chuyển đổi_filter, sải bước=[một,một,một,một], đệm lót='TƯƠNG TỰ') chuyển đổi 3 = tf.không.relu(chuyển đổi 3) chuyển đổi = tf.không.max_pool(chuyển đổi 3, ksize=[một,2,2,một], sải bước=[một,2,2,một], đệm lót='TƯƠNG TỰ') chuyển đổi_bn = tf.lớp.batch_normalization(chuyển đổi) # 7, 8 chuyển đổi 4 = tf.không.chuyển đổi(chuyển đổi_bn, convert_filter, sải bước=[một,một,một,một], đệm lót='TƯƠNG TỰ') chuyển đổi 4 = tf.không.relu(chuyển đổi 4) chuyển đổi = tf.không.max_pool(chuyển đổi 4, ksize=[một,2,2,một], sải bước=[một,2,2,một], đệm lót='TƯƠNG TỰ') chuyển đổi = tf.lớp.batch_normalization(chuyển đổi) # 9 bằng phẳng = tf.đóng góp.lớp.làm phẳng(chuyển đổi) # 10 full1 = tf.đóng góp.lớp.kết nối đầy đủ(đầu vào=bằng phẳng, num_outputs=128, kích hoạt_fn=tf.không.relu) full1 = tf.không.rơi ra ngoài(full1, keep_prob) full1 = tf.lớp.batch_normalization(full1) # mười một full2 = tf.đóng góp.lớp.kết nối đầy đủ(đầu vào=full1, num_outputs=256, kích hoạt_fn=tf.không.relu) full2 = tf.không.rơi ra ngoài(full2, keep_prob) full2 = tf.lớp.batch_normalization(full2) # 12 full3 = tf.đóng góp.lớp.kết nối đầy đủ(đầu vào=full2, num_outputs=512, kích hoạt_fn=tf.không.relu) full3 = tf.không.rơi ra ngoài(full3, keep_prob) full3 = tf.lớp.batch_normalization(full3) # 13 full4 = tf.đóng góp.lớp.kết nối đầy đủ(đầu vào=full3, num_outputs=1024, kích hoạt_fn=tf.không.relu) full4 = tf.không.rơi ra ngoài(full4, keep_prob) full4 = tf.lớp.batch_normalization(full4) # 14 ngoài = tf.đóng góp.lớp.kết nối đầy đủ(đầu vào=full3, num_outputs=10, kích hoạt_fn=không ai) trở về ngoài
- Siêu tham số
kỷ nguyên = 10 batch_size = 128 keep_probability = 0,7 tỷ lệ học = 0,001
logits = mạng chuyển đổi(x, keep_prob) mô hình = tf.danh tính(logits, Tên='logits') # Name logits Tensor, để có thể tải từ đĩa sau khi đào tạo # Loss and Optimizer Giá cả = tf.giảm_mean(tf.không.softmax_cross_entropy_with_logits(logits=logits, nhãn mác=Y)) người tối ưu hóa = tf.xe lửa.AdamOptimizer(tỷ lệ học=tỷ lệ học).giảm thiểu(Giá cả) # Sự chính xác true_pred = tf.công bằng(tf.argmax(logits, một), tf.argmax(Y, một)) sự chính xác = tf.giảm_mean(tf.diễn viên(true_pred, tf.float32), Tên='sự chính xác')
- Huấn luyện mạng lưới thần kinh
#Single Optimization
phản đối train_neural_network(phiên họp, người tối ưu hóa, keep_probability, feature_batch, label_batch): phiên họp.chạy(người tối ưu hóa, feed_dict={ x: feature_batch, Y: label_batch, keep_prob: keep_probability })
#Showing Stats def print_stats(phiên họp, feature_batch, label_batch, Giá cả, sự chính xác): thua = sess.chạy(Giá cả, feed_dict={ x: feature_batch, Y: label_batch, keep_prob: một. }) valid_acc = sess.chạy(sự chính xác, feed_dict={ x: valid_features, Y: valid_labels, keep_prob: một. }) in('Thua:{:> 10.4f}Độ chính xác xác thực:{: .6f}'.định dạng(thua, valid_acc))
- Đào tạo đầy đủ và lưu mô hình
phản đối batch_features_labels(đặc trưng, nhãn mác, batch_size): '' Chia các tính năng và nhãn thành nhiều đợt '' cho khởi đầu trong phạm vi(0, len(đặc trưng), batch_size): kết thúc = min(khởi đầu + batch_size, len(đặc trưng)) năng suất đặc trưng[khởi đầu:kết thúc], nhãn mác[khởi đầu:kết thúc] phản đối load_preprocess_training_batch(batch_id, batch_size): '' Tải dữ liệu Đào tạo được xử lý trước và trả lại chúng theo lô hoặc ít hơn '' tên tập tin = 'preprocess_batch_' + p(batch_id) + '.p' đặc trưng, nhãn mác = dưa muối.tải(mở(tên tập tin, chế độ='rb')) # Trả lại dữ liệu đào tạo theo lô có kích thước hoặc nhỏ hơn trở về batch_features_labels(đặc trưng, nhãn mác, batch_size)
# Lưu mô hình và đường dẫn
save_model_path = './image_classification' in('Đào tạo...') với tf.Phiên họp() như sess: # Khởi tạo các biến sess.chạy(tf.global_variables_initializer()) # Chu kỳ đào tạo cho kỷ nguyên trong phạm vi(kỷ nguyên): # Vòng lặp trên tất cả các lô n_batches = 5 cho batch_i trong phạm vi(một, n_batches + một): cho batch_features, batch_labels trong load_preprocess_training_batch(batch_i, batch_size): train_neural_network(sess, người tối ưu hóa, keep_probability, batch_features, batch_labels) in('Kỷ nguyên{:> 2}, CIFAR-10 Batch{}: '.định dạng(kỷ nguyên + một, batch_i), kết thúc='') print_stats(sess, batch_features, batch_labels, Giá cả, sự chính xác) # Lưu Mô hình người tiết kiệm = tf.xe lửa.Saver() Lưu đường dẫn = người tiết kiệm.tiết kiệm(sess, save_model_path)
ví dụ về khung công tác testng selenium webdriver
Bây giờ, phần quan trọng của Phân loại hình ảnh Tensorflow đã xong. Bây giờ, đã đến lúc kiểm tra mô hình.
- Kiểm tra mô hình
nhập khẩu dưa muối nhập khẩu numpy như ví dụ. nhập khẩu matplotlib.pyplot như làm ơn từ sklearn.preprocessing nhập khẩu LabelBinarizer phản đối batch_features_labels(đặc trưng, nhãn mác, batch_size): '' Chia các tính năng và nhãn thành nhiều đợt '' cho khởi đầu trong phạm vi(0, len(đặc trưng), batch_size): kết thúc = min(khởi đầu + batch_size, len(đặc trưng)) năng suất đặc trưng[khởi đầu:kết thúc], nhãn mác[khởi đầu:kết thúc] phản đối display_image_predictions(đặc trưng, nhãn mác, phỏng đoán, top_n_predictions): n_classes = 10 label_names = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.Phù hợp(phạm vi(n_classes)) label_ids = label_binarizer.inverse_transform(ví dụ..mảng(nhãn mác)) quả sung, trục = làm ơn.âm mưu phụ(nrows=top_n_predictions, ncols=2, sung=(hai mươi, 10)) quả sung.chặt chẽ() quả sung.suptitle('Dự đoán Softmax', cỡ chữ=hai mươi, Y=1.1) n_predictions = 3 lề = 0,05 ind = ví dụ..arange(n_predictions) chiều rộng = (một. - 2. * lề) / n_predictions cho image_i, (đặc tính, label_id, pred_indicies, pred_values) trong liệt kê(zip(đặc trưng, label_ids, phỏng đoán.chỉ số, phỏng đoán.giá trị)): nếu (image_i < top_n_predictions): pred_names = [label_names[pred_i] cho pred_i trong pred_indicies] tên chính xác = label_names[label_id] trục[image_i] [0].imshow((đặc tính*255).astype(ví dụ..int32, sao chép=Sai)) trục[image_i] [0].set_title(tên chính xác) trục[image_i] [0].set_axis_off() trục[image_i] [một].barh(ind + lề, pred_values[:3], chiều rộng) trục[image_i] [một].set_yticks(ind + lề) trục[image_i] [một].set_yticklabels(pred_names[::-một]) trục[image_i] [một].set_xticks([0, 0,5, 1,0])
%matplotlib nội tuyến %cấu hình InlineBackend.figure_format = 'võng mạc' nhập khẩu dòng chảy căng thẳng như tf nhập khẩu dưa muối nhập khẩu ngẫu nhiên save_model_path = './image_classification' batch_size = 64 n_samples = 10 top_n_predictions = 5 phản đối test_model(): test_features, test_labels = dưa muối.tải(mở('preprocess_training.p', chế độ='rb')) Load_graph = tf.Đồ thị() với tf.Phiên họp(đồ thị=Load_graph) như sess: # Tải mô hình người nạp = tf.xe lửa.import_meta_graph(save_model_path + '.meta') người nạp.khôi phục lại(sess, save_model_path) # Nhận Tensors từ mô hình đã tải Load_x = Load_graph.get_tensor_by_name('input_x: 0') Load_y = Load_graph.get_tensor_by_name('output_y: 0') Load_keep_prob = Load_graph.get_tensor_by_name('keep_prob: 0') load_logits = Load_graph.get_tensor_by_name('logits: 0') Load_acc = Load_graph.get_tensor_by_name('độ chính xác: 0') # Nhận độ chính xác theo lô đối với giới hạn bộ nhớ test_batch_acc_total = 0 test_batch_count = 0 cho train_feature_batch, train_label_batch trong batch_features_labels(test_features, test_labels, batch_size): test_batch_acc_total + = sess.chạy( Load_acc, feed_dict={Load_x: train_feature_batch, Load_y: train_label_batch, Load_keep_prob: 1,0}) test_batch_count + = một in('Kiểm tra độ chính xác:{} '.định dạng(test_batch_acc_total/test_batch_count)) # In mẫu ngẫu nhiên random_test_features, random_test_labels = tuple(zip(*ngẫu nhiên.mẫu vật(danh sách(zip(test_features, test_labels)), n_samples))) random_test_predictions = sess.chạy( tf.không.top_k(tf.không.softmax(load_logits), top_n_predictions), feed_dict={Load_x: random_test_features, Load_y: random_test_labels, Load_keep_prob: 1,0}) display_image_predictions(random_test_features, random_test_labels, random_test_predictions, top_n_predictions) test_model()
Đầu ra: Kiểm tra độ chính xác: 0.5882762738853503
Bây giờ, nếu bạn đào tạo mạng nơ-ron của mình cho nhiều kỷ nguyên hơn hoặc thay đổi chức năng kích hoạt, bạn có thể nhận được một kết quả khác có độ chính xác tốt hơn.
Vì vậy, với điều này, chúng ta kết thúc bài viết Phân loại hình ảnh TensorFlow này. Tôi chắc rằng bây giờ bạn có thể sử dụng cùng một để phân loại bất kỳ loại hình ảnh nào và bạn không phải là người mới bắt đầu phân loại hình ảnh.
Edureka's với Chương trình đào tạo chứng chỉ Python được các chuyên gia trong ngành quản lý theo yêu cầu và nhu cầu của ngành. Bạn sẽ nắm vững các khái niệm như hàm SoftMax, Mạng thần kinh tự động mã hóa, Máy Boltzmann hạn chế (RBM), Keras & TFLearn. Khóa học đã được các chuyên gia trong ngành đặc biệt phụ trách với các nghiên cứu điển hình trong thời gian thực.