Відео

import numpy as np from PIL import Image import tensorflow as tf from tensorflow.keras.applications import MobileNetV2 from tensorflow.keras.applications.mobilenet_v2 import preprocess_input, decode_predictions from art.estimators.classification import TensorFlowV2Classifier from art.attacks.evasion import FastGradientMethod # Step 1: Load and preprocess the image def load_image(image_path): image = Image.open(image_path).convert('RGB') return image def resize_image(image, size=(224, 224)): return image.resize(size, Image.LANCZOS) def preprocess_image(image): image_array = np.array(image).astype(np.float32) image_preprocessed = preprocess_input(image_array) # Scales values as required by MobileNetV2 return image_preprocessed def deprocess_image(image_array): # Convert back from preprocessed [-1,1] to [0,255] image_array = ((image_array + 1.0) * 127.5).astype(np.uint8) return image_array # Step 2: Generate adversarial perturbation def generate_adversarial(model, image_preprocessed, eps=0.1): loss_object = tf.keras.losses.CategoricalCrossentropy() classifier = TensorFlowV2Classifier( model=model, nb_classes=1000, input_shape=image_preprocessed.shape[1:], loss_object=loss_object, clip_values=(-1.0, 1.0), ) attack = FastGradientMethod(estimator=classifier, eps=eps) adversarial_image = attack.generate(x=np.expand_dims(image_preprocessed, axis=0)) return adversarial_image[0] # Remove batch dimension # Step 3: Create the blended image with random weights def create_weighted_image(original_image_array, adversarial_image_array): # Generate random weights between 0 and 1 for each pixel weights = np.random.rand(*original_image_array.shape) # Blend the images blended_image_array = original_image_array * (1 - weights) + adversarial_image_array * weights # Ensure pixel values are within valid range blended_image_array = np.clip(blended_image_array, 0, 255).astype(np.uint8) # Convert array to image blended_image = Image.fromarray(blended_image_array) return blended_image # Main execution if __name__ == '__main__': import os import random # Set random seed for reproducibility random.seed(42) np.random.seed(42) tf.random.set_seed(42) # Paths image_path = 'turtle.jpg' # Replace with your image file path adversarial_image_path = 'adversarial_turtle.jpg' blended_image_path = 'blended_turtle.jpg' # Load the original high-resolution image original_image = load_image(image_path) original_image_array = np.array(original_image).astype(np.float32) # Resize and preprocess image for the model resized_image = resize_image(original_image) image_preprocessed = preprocess_image(resized_image) # Load the pre-trained MobileNetV2 model model = MobileNetV2(weights='imagenet') # Generate adversarial image adversarial_image_preprocessed = generate_adversarial(model, image_preprocessed, eps=0.1) # Deprocess images for blending adversarial_image_array = deprocess_image(adversarial_image_preprocessed) adversarial_image = Image.fromarray(adversarial_image_array) adversarial_image = adversarial_image.resize(original_image.size, Image.LANCZOS) adversarial_image_array = np.array(adversarial_image).astype(np.float32) # Create the blended image blended_image = create_weighted_image(original_image_array, adversarial_image_array) # Save the images adversarial_image_uint8 = adversarial_image_array.astype(np.uint8) adversarial_image_pil = Image.fromarray(adversarial_image_uint8) adversarial_image_pil.save(adversarial_image_path) print(f"Adversarial image saved as '{adversarial_image_path}'") blended_image.save(blended_image_path) print(f"Blended image saved as '{blended_image_path}'") # Optional: Verify the classification of the blended image # Resize blended image to model input size blended_image_resized = resize_image(blended_image) blended_image_preprocessed = preprocess_image(blended_image_resized) # Predictions preds_original = model.predict(np.expand_dims(image_preprocessed, axis=0)) preds_adversarial = model.predict(np.expand_dims(adversarial_image_preprocessed, axis=0)) preds_blended = model.predict(np.expand_dims(blended_image_preprocessed, axis=0)) decoded_preds_original = decode_predictions(preds_original, top=1)[0][0] decoded_preds_adversarial = decode_predictions(preds_adversarial, top=1)[0][0] decoded_preds_blended = decode_predictions(preds_blended, top=1)[0][0] print(f"Original image classified as: {decoded_preds_original[1]} ({decoded_preds_original[2]*100:.2f}% confidence)") print(f"Adversarial image classified as: {decoded_preds_adversarial[1]} ({decoded_preds_adversarial[2]*100:.2f}% confidence)") print(f"Blended image classified as: {decoded_preds_blended[1]} ({decoded_preds_blended[2]*100:.2f}% confidence)")

where can i find other resources like this that talk about practical considerations for deep learning training for an intermediate level.

The question @ 28:18 was actually how do we know when to change (i.e., decay) the learning rate, not how do we choose the initial learning rate value.

very informative. Thanks.

Can you please share a link to the HW assignment (and possibly related code\ Jupyter notbooks) ? Thank you for sharing these lectures and tutorials !

sir if i have more data like more than 100gb which cannot be stored in google colab then how should i approach this problem for training my model on whole data

Thank you! Very useful lecture. The teacher explained basic concepts really well.

Thanks a lot for this, helped with my interview prep!

21:19 Where does the averaging of gradients happen? On the CPU as shown in the animation? Or all the GPUs talk to each other directly and averaging happens on each GPU?

There are lots of tutorials, introductions, "for beginners", I think we do like to see some "advanced", "useful" materials for all of us.

When is this out or love to know more

Please provide us the course website if it is possible! Thank you!

Really good and clear, thank you for this video!

Never released the code did you?

super clear! Thanks!

thanks

so clear and well-explained. Thank you very much

thanks for course

I think the questions are excellent

Thank you so much

so clear,so great

I have a question. The train function runs on each process independent of the other (train functions running on other process). Within train, the epoch may finish at different times for each train function. How does the PyTorch distributed know that when it is time to synchronize gradients? BTW - this is the best lecture I have seen on this topic :+1:

Thank you very much. Very good presentation, comprehensive and clear.

This tutorial is so underrated! Hands down the most clear and in-depth understanding of DDP for someone who doesn't know multi-processing in Pytorch. I came across this after watching 4-5 other videos. Strongly recommend this one.

Thanks a lot. really enjoyed it. God bless you all

This was very interesting. Are slides also available by any chance? I'd also really like to see the homework and try them out as well. God bless you.

Can you Also share the link to other videos about PyTorch in this series ? This video was quite insightful.

Thanks cam explanation is v good

how did you do it can you share with me , thank you

Thanks a zillion times for this very informative series DL4CV. I must ack that I was drawn by the Borat thumbnail (it seemed fun, is located at 6:02) but I stayed for the learning.

Love this!!!!! Great lecturer

Will you release a GUI? Nice project!

Nice

תודה רבה🙏

Can you please make a google colab demo of this that we can try out? thanks in advance!

Super interesting stuff! This was discussed on RoosterTeeth podcast 631 around 38 minutes in.

Could you tell more about the object insertion approaches? I am so interested on the achieved effect!

LOCKDOWN FROM GOOGLE

I do a research work on this topic, can you send to me this presentation i saw it is so helpful for me

Simply Amazing.

It's amazing. On this technology, you can make many useful pieces. I just have no words ... it's cool

Use opig watermak problem solvd

Wow! Really amazing results! Congrats!

It's so cool.

Can or is this gonna be converted to a real programm without having to install all the addons for python. Sorry I am not very talented xD

That's insane!

For some better result you can use 4 cameras horizontally and 4 cameras vertically. So the all side parallax can be obtained that can do the work more effectively

+3:10 this would incredibly useful for visual effects work. it's a real pain point

We wonder what AI is going to produce out of #10yearschallenge

Beautiful! all this with no synthetic data! *How fast it runs with 1 mega pixel image for example ? *I would want to see how the model works on a scene that a human is walking in a forest environment, with a strong wind that moves everything around. or indoor with many non human moving objects.