User Rating: 0 / 5
Dans le domaine du Deep Learning, les tensors sont les structures de données fondamentales. Ce TP vous guidera à travers la manipulation de tensors et d'éléments essentiels dans trois frameworks populaires : TensorFlow, Keras et PyTorch. Nous allons résoudre les problèmes suivants :
User Rating: 0 / 5
L'architecture U-Net est une architecture de réseau de neurones convolutifs (CNN) spécifiquement conçue pour la segmentation d'images, c'est-à-dire la tâche de prédire pour chaque pixel d'une image à quelle classe il appartient. Développée initialement pour la segmentation d'images biomédicales, U-Net a rapidement gagné en popularité dans divers domaines en raison de sa performance robuste, surtout dans les cas où les données d'entraînement sont limitées.
Le réseau U-Net tire son nom de sa forme distinctive en "U". Cette architecture comporte deux chemins : un chemin contractant (ou de descente) qui capture le contexte et un chemin symétrique d'expansion (ou de montée) qui permet une localisation précise. La dénomination "U-Net" est donc directement inspirée par cette conception architecturale, où la forme en "U" est centrale pour la fonctionnalité du réseau.
Figure 1
Description détaillée de l'architecture U-Net :
Chemin de contraction (encodeur) :
Partie la plus basse :
Chemin d'expansion (décodeur) :
Sortie :
Ainsi, l'encodeur (chemin de contraction) réduit les dimensions spatiales (hauteur et largeur) et extrait des informations de haut niveau (profondeur en termes de nombre de canaux), tandis que le décodeur (chemin expansif) utilise ces informations pour reconstruire une carte de segmentation détaillée de l'image.
La structure en "U" est non seulement symétrique mais aussi fonctionnelle, car elle permet la fusion des caractéristiques de contexte à partir du chemin contractant avec des informations de localisation plus détaillées à partir du chemin d'expansion. Cela se fait par des connexions de saut (skip connections) qui copient des caractéristiques de la partie contractante et les combinent avec les caractéristiques dans la partie d'expansion correspondante. Cette combinaison de contexte et de localisation est cruciale pour effectuer une segmentation précise à l'échelle des pixels.
Le schéma (figure1) précédent montre comment le réseau procède à une analyse détaillée de l'image en réduisant progressivement sa dimension pour extraire des caractéristiques, puis reconstruit une sortie de haute résolution en réintégrant les informations de localisation. Voici une explication détaillée de chaque partie de cet exemple.
Partie gauche (contraction / encodeur) :
Partie centrale (le fond du "U") :
Partie droite (expansion / décodeur) :
Flèches et symboles :
La mise en œuvre peut être divisée en trois parties. Tout d’abord, nous définirons le bloc codeur utilisé dans le chemin de contraction. Ce bloc se compose de deux couches de convolution 3 × 3 suivies d'une couche d'activation ReLU et d'une couche de pooling max 2 × 2. La deuxième partie est le bloc décodeur, qui prend la carte des caractéristiques de la couche inférieure, la convertit, la recadre et la concatène avec les données de l'encodeur du même niveau, puis exécute deux couches de convolution 3 × 3 suivies de l'activation de ReLU. La troisième partie consiste à définir le modèle U-Net à l'aide de ces blocs.
Code du bloc encodeur
def encoder_block(inputs, num_filters):
# une Convolution avec un filter de 3x3 filter suivit d'une ReLU
x = tf.keras.layers.Conv2D(num_filters, 3, padding = 'valid')(inputs)
x = tf.keras.layers.Activation('relu')(x)
# Cune Convolution avec un filter de 3x3 filter suivit d'une ReLU
x = tf.keras.layers.Conv2D(num_filters,3, padding = 'valid')(x)
x = tf.keras.layers.Activation('relu')(x)
# un Max Pooling avec un filter de 2x2
x = tf.keras.layers.MaxPool2D(pool_size = (2, 2), strides = 2)(x)
return x
Code du bloc décodeur
def decoder_block(inputs, skip_features, num_filters):
# Up-convolution c'est un Upsampling avec2x2 filter
x = tf.keras.layers.Conv2DTranspose(num_filters,(2, 2),strides = 2,padding = 'valid')(inputs)
# Copier et recadrer la connexion de saut, puis la concaténer
skip_features = tf.image.resize(skip_features,size = (x.shape[1],
x.shape[2]))
x = tf.keras.layers.Concatenate()([x, skip_features])
# Convolution avec un filter de 3x3 filter suivit d'une ReLU
x = tf.keras.layers.Conv2D(num_filters, 3,padding = 'valid')(x)
x = tf.keras.layers.Activation('relu')(x)
# Convolution avec un filter de 3x3 filter suivit d'une ReLU
x = tf.keras.layers.Conv2D(num_filters, 3, padding = 'valid')(x)
x = tf.keras.layers.Activation('relu')(x)
return x
# le code du modél Unet
import tensorflow as tf
def unet_model(input_shape = (256, 256, 3), num_classes = 1):
inputs = tf.keras.layers.Input(input_shape)
# Cchemin contractuel
s1 = encoder_block(inputs, 64)
s2 = encoder_block(s1, 128)
s3 = encoder_block(s2, 256)
s4 = encoder_block(s3, 512)
# Bottleneck la partie la plus basse de l'architecture en U
b1 = tf.keras.layers.Conv2D(1024, 3, padding = 'valid')(s4)
b1 = tf.keras.layers.Activation('relu')(b1)
b1 = tf.keras.layers.Conv2D(1024, 3, padding = 'valid')(b1)
b1 = tf.keras.layers.Activation('relu')(b1)
# chemin expansif
s5 = decoder_block(b1, s4, 512)
s6 = decoder_block(s5, s3, 256)
s7 = decoder_block(s6, s2, 128)
s8 = decoder_block(s7, s1, 64)
# Output
outputs = tf.keras.layers.Conv2D(num_classes,1,padding = 'valid',activation = 'sigmoid')(s8)
model = tf.keras.models.Model(inputs = inputs,outputs = outputs,name = 'U-Net')
return model
model = unet_model(input_shape=(572, 572, 3), num_classes=2)
model.summary()img = Image.open('palastine.png')
img
import numpy as np
from PIL import Image
from tensorflow.keras.preprocessing import image
img = Image.open('palastine.png')
# preparation de l'image
img = img.resize((572, 572))
img_array = image.img_to_array(img)
img_array = np.expand_dims(img_array[:,:,:3], axis=0)
img_array = img_array / 255.
# chargement du model
model = unet_model(input_shape=(572, 572, 3), num_classes=2)
# predictions
predictions = model.predict(img_array)
# Convertir les predictions en un tableau numpy et modifier la taille en taille originale de l'image
predictions = np.squeeze(predictions, axis=0)
predictions = np.argmax(predictions, axis=-1)
predictions = Image.fromarray(np.uint8(predictions*255))
predictions = predictions.resize((img.width, img.height))
# sauvgarder l'image predit
predictions.save('image_predite.jpg')
predictions
User Rating: 0 / 5
Sora, la dernière innovation d'OpenAI, représente un jalon remarquable dans le domaine de l'intelligence artificielle et la génération de contenu multimédia. Ce modèle de transformation de texte en vidéo illustre la capacité sans précédent de l'IA à interpréter et matérialiser des descriptions textuelles en séquences vidéo dynamiques et cohérentes. Sora incarne non seulement une avancée technique significative, permettant la création de vidéos à partir de simples énoncés textuels, mais ouvre également la voie à de nouvelles applications dans l'éducation, le marketing, le divertissement, et bien au-delà.
Doté d'une compréhension approfondie du langage et d'une capacité à contextualiser les demandes, Sora peut générer des contenus vidéo qui correspondent étroitement aux intentions des utilisateurs, rendant possible la visualisation de concepts, d'histoires, et d'idées de manière visuelle et engageante. Cette avancée technologique, avec ses caractéristiques impressionnantes, souligne l'évolution rapide de l'intelligence artificielle vers des applications de plus en plus créatives et interactives, marquant un tournant dans notre façon de créer et de consommer le contenu numérique.
User Rating: 5 / 5
User Rating: 5 / 5
DataScienceToday is a new online plateform and going source for data science related content for its influential audience in the world . You can reach us via email
contact@datasciencetoday.net
datasciencetoday.net@gmail.com
made by Bouchra ZEITANE , Zaineb MOUNIR
under the supervision of Pr. Habib BENLAHMAR
