EDUCBA Logo

EDUCBA

MENUMENU
  • Explore
    • EDUCBA Pro
    • PRO Bundles
    • Featured Skills
    • New & Trending
    • Fresh Entries
    • Finance
    • Data Science
    • Programming and Dev
    • Excel
    • Marketing
    • HR
    • PDP
    • VFX and Design
    • Project Management
    • Exam Prep
    • All Courses
  • Blog
  • Enterprise
  • Free Courses
  • Log in
  • Sign Up
Home Data Science Data Science Tutorials Keras Tutorial Keras U-Net
 

Keras U-Net

Updated March 16, 2023

Keras U-Net

 

 

Introduction to Keras U-Net

Keras U-Net architecture contains the segmentation of image size 512*512 and it was computed by using modern GPU with a small amount of time. There are many variants and modifications of this architecture representing the success of the phenomenon. It has a significant attachment to the field of deep learning. It is equally essential for understanding the previous methods which were employed for solving similar kinds of tasks.

Watch our Demo Courses and Videos

Valuation, Hadoop, Excel, Mobile Apps, Web Development & many more.

Key Takeaways

  • It is a deep learning segmentation model and the architecture of u-net is used in the GAN variants.
  • It is an image segmentation task which was segmenting the images into multiple areas by assigning the label to every pixel of the image.

What is Keras U-Net?

Keras U-Net provides detailed information regarding object detection of the image which was drawing a bounding box around the detected object or image classification which was assigning labels to the specified object. Segmentation is very useful and it is used in real-world applications.

In a keras u-net image segmentation every pixel of an image is assigned to the class. As per application, classes contains the different cell types or task which was binary. It is a semantic segmentation technique that was proposed for imaging segmentation.

How to Implement Keras U-Net?

To implement the keras U-Net we need to follow the below steps. We need to import the required dependencies.

1. In this step we are importing the required dependencies which we are using in keras u-net.

Code:

import pandas as pd
import numpy as np
import os
…..
import warnings
warnings.filterwarnings('ignore')

Output:

Keras U-Net - Importing

2. After importing the module in this step, we are defining the width and height of the image as follows.

Code:

img_h = 128
img_w = 128
img_ch = 1
n_test = 10

Output:

defining the width and height

3. After defining the size of the image now in this step we are creating the image dataset as follows.

Code:

i_list = os.listdir('keras')
m_list = os.listdir('keras')
d_img = pd.DataFrame(i_list, columns=['image_id'])
d_img = d_img[d_img['image_id'] != '.htaccess']
def get_num_cells(x):
    a = x.split('_')
    b = a[2] 
    num_cells = int(b[1:])
    return num_cells
def check_for_mask(x):
    if x in m_list:
        return 'yes'
    else:
        return 'no'		
d_img['has_mask'] = d_img['image_id'].apply(check_for_mask)
def get_blur_amt(x):
    a = x.split('_')
    b = a[3] 
    b_amt = int(b[1:])
    return b_amt
d_img.head(10)

Output:

Keras U-Net - Creating

4. After defining the data frame now in this step we are using the data frame as follows.

Code:

d_mas = d_img [d_img['has_mask'] == 'yes']
d_mas['mask_id'] = d_mas['image_id']
d_mas.shape
d_mas.head()

Output:

Using the data frame

5. After using the data frame now in this step we are inspecting the images and mask.

Code:

s_img = 'IMG.png'
img = imread(s_img)
plt.imshow (img)
print('Shape: ', img.shape)
print('Max val: ', img.max())
print('Min val: ', img.min())

Output:

Keras U-Net - Inspecting

Keras U-Net 6

Keras U-Net 7

Keras U-Net in Image

Keras U-Net is a significant accomplishment in the field of deep learning. It is essential for understanding the previous methods. The image of it is defined in the architecture.

The below example shows how the keras u-net image will work.

Code:

import pandas as pd
import numpy as np
import os
warnings.filterwarnings('ignore')
img_h = 92
img_w = 92
img_ch = 1
n_test = 5
list = os.listdir('keras')
m_list = os.listdir('keras')
dir_img = pd.DataFrame(list, columns = ['image_id'])
dir_img = dir_img[dir_img ['image_id'] != '.htaccess']
def get_num_cells (x):
    		a = x.split('_')
    		b = a[2] 
    		num_cells = int (b[1:])
    		return num_cells
def check_for_mask (x):
    		if x in m_list:
        		return 'yes'
    		else:
        			return 'no'
dir_img ['has_mask'] = dir_img ['image_id'].apply (check_for_mask)
def get_blur_amt (x):
  		  a = x.split('_')
    		b = a[3] 
    		b_amt = int(b[1:])
    		return b_amt
dir_img.head(10)
mask_d = dir_img[dir_img['has_mask'] == 'yes']
mask_d['mask_id'] = mask_d['image_id']
mask_d.shape
mask_d.head()
tes_d = mask_d.sample (n_test, random_state = 101)
tes_d = tes_d.reset_index (drop=True)
test_images_list = list(tes_d ['image_id'])
mask_d = mask_d[~mask_d ['image_id'].isin (test_images_list)]
print(mask_d.shape)
print(tes_d.shape)
s_img = 'cat.jpg'
img = imread(s_img)
plt.imshow(img)
print('Shape: ', img.shape)
print('Max val: ', img.max())
print('Min val: ', img.min())
plt.show()
s_img = 'cat.jpg'
img = imread(s_img)
plt.imshow(img)

Output:

Keras U-Net - architecture 1

Keras U-Net - architecture

Keras U-Net 10

Keras U-Net 11

Keras U-Net Architecture

The shape of the architecture is in U form. While checking the structure and elements of the process is constructing the architechture, we can understand the build of the network is fully convolutional. We cannot use any other layer such as flatten or dense. We can show the visual representation of the contracting path which was followed by expanding path.

Architecture

In the above architecture, we can see that the input image will pass through the model, and then it will be followed by using convolutional layers. We can see that image size in the u-net architechture is reducing from high to low. The reason for image reduction is that it uses the unpadded convolutions which were blocking the decoder block.

The encoded block will contain the image size constant reduction by using max pooling layers. We have repeated convolutional layers by using an increasing number of filters. While reaching the decoding aspect we can notice the number of filters in the convolutional layer.

Keras U-Net Dataset

To define the dataset in it we need to import the below module by using import.

Code:

import tensorflow as tf
……..
import numpy as np

Output:

Keras U-Net dataset

After importing the module now in the below step we are pet dataset which was available in the tensorflow dataset. We can easily load the same by tfds. The below example shows to load the pet module as follows.

Code:

dataset, info = tfds.load()

Output:

Keras U-Net - Loading

After loading the dataset now in the below steps we are resizing the mask and images as follows.

Code:

def resize(ip_img, ip_mask):
ip_img = tf.image.resize (ip_img, (92, 92), method = "nearest")
ip_mask = tf.image.resize(ip_mask, (92, 92), method = "nearest")
return ip_img, ip_mask

Output:

Keras U-Net - resizing

After resizing the image and mask now in this step we are creating the function to augment the dataset by flipping the same horizontally as follows.

Code:

def augment(ip_img, ip_mask):
if tf.random.uniform(()) > 0.5:
ip_img = tf.image.flip_left_right(ip_img)
ip_mask = tf.image.flip_left_right(ip_mask)
return ip_img, ip_mask

Output:

creating the function

By creating the augment function now in this step, we are scaling the dataset to scale the range of image.

Code:

def normalize(ip_img, ip_mask):
ip_img = tf.cast (ip_img, tf.float32) / 255.0
ip_mask -= 1
return ip_img, ip_mask

Output:

Keras U-Net - Scaling

In the below example, we are creating the two functions for training and processing the dataset.

Code:

def load_image_train (datapoint):
ip_img = datapoint["image"]
ip_mask = datapoint["segmentation_mask"]
ip_img, ip_mask = resize(ip_img, ip_mask)
ip_img, ip_mask = augment(ip_img, ip_mask)
ip_img, ip_mask = normalize(ip_img, ip_mask)
return ip_img, ip_mask
def load_image_test(datapoint):
ip_img = datapoint["image"]
ip_mask = datapoint["segmentation_mask"]
ip_img, ip_mask = resize(ip_img, ip_mask)
ip_img, ip_mask = normalize(ip_img, ip_mask)
return ip_img, ip_mask

Output:

two functions for training and processing

After creating the two functions now in this step we are building the pipeline by using the map function.

Code:

tr_data = dataset()
test_data = dataset()

Output:

Keras U-Net - building

After building the pipeline now in this step we are defining the batch size and buffer size as follows.

Code:

B_SIZE = 64
BUF_SIZE = 1000
val_batch = test_data.take()
test_batch = test_data.skip()

Output:

batch size and buffer size

After defining the dataset now in this step, we are visualizing the sample image from the mask.

Code:

def display(display_list):
plt.figure(figsize=(20, 20))
img_name = []
for i in range(len(display_list)):
plt.subplot(1, len(display_list), i+1)
plt.img_name(img_name[i])
plt.imshow()
plt.axis("off")
plt.show()

Output:

visualizing the sample image

Keras U-Net - visualizing

FAQ

Given below are the FAQs mentioned:

Q1. What is the use of keras u-net?

Answer: It is segmentation model architecture that defines the image in a variants format.

Q2. Which libraries do we need to import while using keras u-net?

Answer: We need to import the keras, tensorflow, pandas, and numpy libraries at the time of working with it.

Q3. What is u-net model in keras?

Answer: Keras will define the u-net model. We are using three options for creating the u-net model i.e., functional API, model, and sequential API.

Conclusion

In keras u-net image segmentation of every pixel of an image is assigned to the class. As per application, classes contain different cell types. The architecture contains the segmentation of image sizes 512*512 and it was computed by using a modern GPU with a small time amount.

Recommended Articles

This is a guide to Keras U-Net. Here we discuss the introduction, and how to implement keras U-Net. architecture and dataset respectively. You may also have a look at the following articles to learn more –

  1. Keras Tuner
  2. What is Keras GPU?
  3. Keras Embedding
  4. Keras predict

Primary Sidebar

Footer

Follow us!
  • EDUCBA FacebookEDUCBA TwitterEDUCBA LinkedINEDUCBA Instagram
  • EDUCBA YoutubeEDUCBA CourseraEDUCBA Udemy
APPS
EDUCBA Android AppEDUCBA iOS App
Blog
  • Blog
  • Free Tutorials
  • About us
  • Contact us
  • Log in
Courses
  • Enterprise Solutions
  • Free Courses
  • Explore Programs
  • All Courses
  • All in One Bundles
  • Sign up
Email
  • [email protected]

ISO 10004:2018 & ISO 9001:2015 Certified

© 2025 - EDUCBA. ALL RIGHTS RESERVED. THE CERTIFICATION NAMES ARE THE TRADEMARKS OF THEIR RESPECTIVE OWNERS.

EDUCBA

*Please provide your correct email id. Login details for this Free course will be emailed to you
Loading . . .
Quiz
Question:

Answer:

Quiz Result
Total QuestionsCorrect AnswersWrong AnswersPercentage

Explore 1000+ varieties of Mock tests View more

EDUCBA

*Please provide your correct email id. Login details for this Free course will be emailed to you
EDUCBA
Free Data Science Course

Hadoop, Data Science, Statistics & others

By continuing above step, you agree to our Terms of Use and Privacy Policy.
*Please provide your correct email id. Login details for this Free course will be emailed to you
EDUCBA

*Please provide your correct email id. Login details for this Free course will be emailed to you

EDUCBA Login

Forgot Password?

🚀 Limited Time Offer! - ENROLL NOW