DEV Community: Afroz Chakure

Yay! Reached 1035+ days Daily Coding Streak on Leetcode!

Afroz Chakure — Sun, 29 Dec 2024 17:11:20 +0000

52 Tricks to Media Manipulation

Afroz Chakure — Thu, 19 Dec 2024 13:06:39 +0000

Here's a list of 52 major media manipulation tactics used in the modern world to hide the truth:

Media Manipulation Tactics

Agenda Setting: How narratives are chosen to dominate public discourse.
Astroturfing: Creating fake grassroots support to manipulate opinions.
Clickbait Headlines: Misleading titles to draw attention while obscuring the real story.
Smear Campaigns: Targeted attacks to discredit individuals or groups.
Censorship by Omission: Ignoring inconvenient facts or stories.
Manufactured Consent: Using media to gain public approval for controversial decisions.
Echo Chambers: How reinforcing certain views limits critical thinking.
Misinformation vs. Disinformation: Spotting the difference.
Overton Window Manipulation: Shifting what’s seen as acceptable in public debate.
False Equivalence: Creating the illusion of balance where none exists.

Narrative Framing

Fearmongering: Leveraging fear to control public opinion.
The Scapegoat Strategy: Diverting blame to a convenient target.
Diversionary Tactics: The art of misdirection.
Sloganeering: Catchy phrases used to oversimplify complex issues.
Polarization: Dividing people to conquer attention.
Whataboutism: Avoiding criticism by pointing fingers elsewhere.
Cherry-Picking Data: Presenting partial truths to mislead.
Gaslighting the Masses: Denying reality to confuse and control.
Controlled Opposition: Simulating dissent to manipulate outcomes.
Dog Whistle Politics: Using coded language to rally specific groups.

Techniques to Manipulate Public Sentiment

Emotional Manipulation: Tugging at heartstrings to bypass logic.
Hero-Villain Narratives: Simplifying stories into good vs. bad.
Weaponizing Shame: Using guilt to silence critics.
Bandwagon Effect: Encouraging conformity by portraying widespread support.
Appeal to Authority: Leveraging "experts" to sell questionable ideas.
Fake Fact-Checking: Discrediting truths under the guise of verification.
Leaked “Exclusives”: Controlled releases to steer narratives.
Forced Virality: Coordinated campaigns to make topics trend.
The Streisand Effect: When censorship backfires.
Propaganda by Numbers: Inflating statistics to create urgency or panic.

Structural Control of Media

Media Monopolies: The dangers of concentrated ownership.
Advertising Pressure: When sponsors dictate editorial policy.
Revolving Doors: The media-politics nexus.
Silencing Journalists: Subtle and overt threats to free press.
Influencer Manipulation: Co-opting voices of trust.
Algorithmic Bias: How platforms amplify manipulation.
Saturation Coverage: Drowning other stories out.
Token Opposition: Allowing controlled dissent for credibility.
Orchestrated Leaks: When whistleblowing is weaponized.
Rebranding Controversy: Euphemisms to sanitize wrongdoing.

Fighting Back and Staying Aware

Critical Thinking: Cultivating skepticism in media consumption.
Fact-Checking Tools: Essential resources to verify claims.
Media Literacy Education: Teaching people to decode media.
Recognizing Bias: Spotting partiality in reporting.
Dismantling Echo Chambers: Diversifying your information sources.
Whistleblower Protections: Supporting those who expose manipulation.
Citizen Journalism: Empowering independent reporting.
Digital Detox: Breaking free from constant manipulation.
Call-Out Culture: Holding media accountable.
Supporting Ethical Journalism: Funding independent voices.
Spotting Red Flags: Identifying signs of manipulation in headlines.
The Role of Transparency: How openness combats misinformation.

Solved 1000+ Problems on Leetcode, Yay!

Afroz Chakure — Wed, 01 May 2024 18:19:11 +0000

Argh! Lost my 649 Days Hot streak on Leetcode

Afroz Chakure — Wed, 03 Jan 2024 18:20:32 +0000

Funny enough, the only badge I missed was my December 2023 badge (exhausted my time travels). Ended up losing my streak because of it. :)

You can follow me on Linkedin: https://www.linkedin.com/in/afrozchakure/

365 days and counting

Afroz Chakure — Wed, 08 Mar 2023 16:38:07 +0000

Ouch! Just lost my streak on Leetcode

Afroz Chakure — Wed, 02 Nov 2022 02:18:35 +0000

Was closing in on 250 days, damn!

Completed 500 problems on Leetcode!

Afroz Chakure — Thu, 18 Aug 2022 18:22:00 +0000

Yo! I completed 100 days of Leetcode

Afroz Chakure — Wed, 08 Jun 2022 17:43:04 +0000

All you need to know about YOLO v3 (You Only Look Once)

Afroz Chakure — Mon, 01 Mar 2021 19:34:25 +0000

This blog will provide an exhaustive study of YOLOv3 (You only look once), which is one of the most popular deep learning models extensively used for object detection, semantic segmentation, and image classification. In this blog, I'll explain the architecture of YOLOv3 model, with its different layers, and see some results for object detection that I got while running the inference program on some test images using the model.

So keep reading the blog to find out more about YOLOv3.

What is YOLO?

"You Only Look Once" or YOLO is a family of deep learning models designed for fast object Detection.
There are three main variations of YOLO, they are YOLOv1, YOLOv2, and YOLOv3.
The first version proposed the general architecture, where the second version refined the design and made use of predefined anchor boxes to improve the bounding box proposal, and version three further refined the model architecture and training process.
It is based on the idea that :

" A single neural network predicts bounding boxes and class probabilities directly from full images in one evaluation. Since the whole detection pipeline is a single network, it can be optimized end-to-end directly on detection performance. "

1. Network Architecture Diagram of YOLOv3

2. Description of Architecture

Steps for object Detection using YOLO v3:

The inputs is a batch of images of shape (m, 416, 416, 3).
YOLO v3 passes this image to a convolutional neural network (CNN).
The last two dimensions of the above output are flattened to get an output volume of (19, 19, 425):
- Here, each cell of a 19 x 19 grid returns 425 numbers.
- 425 = 5 * 85, where 5 is the number of anchor boxes per grid.
- 85 = 5 + 80, where 5 is (pc, bx, by, bh, bw) and 80 is the number of classes we want to detect.
The output is a list of bounding boxes along with the recognized classes. Each bounding box is represented by 6 numbers (pc, bx, by, bh, bw, c). If we expand c into an 80-dimensional vector, each bounding box is represented by 85 numbers.
Finally, we do the IoU (Intersection over Union) and Non-Max Suppression to avoid selecting overlapping boxes.

Regarding the architecture:

YOLO v3 uses a variant of Darknet, which originally has 53 layer network trained on Imagenet.
For the task of detection, 53 more layers are stacked onto it, giving us a 106 layer fully convolutional underlying architecture for YOLO v3.
In YOLO v3, the detection is done by applying 1 x 1 detection kernels on feature maps of three different sizes at three different places in the network.
The shape of detection kernel is 1 x 1 x (B x (5 + C)). Here B is the number of bounding boxes a cell on the feature map can predict, '5' is for the 4 bounding box attributes and one object confidence and C is the no. of classes.
YOLO v3 uses binary cross-entropy for calculating the classification loss for each label while object confidence and class predictions are predicted through logistic regression.

Hyper-parameters used

class_threshold - Defines probability threshold for the predicted object.
Non-Max suppression Threshold - It helps overcome the problem of detecting an object multiple times in an image. It does this by taking boxes with maximum probability and suppressing the close-by boxes with non-max probabilities (less than the predefined threshold).
input_height & input_shape - Image size to input.

CNN architecture of Darknet-53

Darknet-53 is used as a feature extractor.
Darknet-53 mainly composed of 3 x 3 and 1 x 1 filters with skip connections like the residual network in ResNet.

2. Architecture diagram of YOLOv3

3. Layers Details

YOLO makes use of only convolutional layers, making it a fully convolutional network (FCN)
In YOLOv3 a deeper architecture of feature extractor called Darknet-53 is used.

Convolution layers in YOLOv3

It contains 53 convolutional layers which have been, each followed by batch normalization layer and Leaky ReLU activation.
Convolution layer is used to convolve multiple filters on the images and produces multiple feature maps
No form of pooling is used and a convolutional layer with stride 2 is used to downsample the feature maps.
It helps in preventing loss of low-level features often attributed to pooling.

4. Different Layers inside YOLO

Code for Layer 1 to 53 in Tensorflow : Consider res_block() method for below code

def res_block(inputs, filters):  
    shortcut = inputs  
    net = conv2d(inputs, filters * 1, 1)  
    net = conv2d(net, filters * 2, 3)  
    net = net + shortcut  
    return net

First two conv2d layers with 32 and 64 filters

net = conv2d(inputs, 32,  3, strides=1)
net = conv2d(net, 64,  3, strides=2)

res_block * 1

    net = res_block(net, 32)
# Convolutional block with 128 filters
net = conv2d(net, 128, 3, strides=2)

res_block * 2

for i in range(2):
        net = res_block(net, 64)
# Convolutional layer with 256 filters
net = conv2d(net, 256, 3, strides=2)

res_block * 8

for i in range(8):
    net = res_block(net, 128)
# Convolutional layer with 512 filters
route_1 = net
net = conv2d(net, 512, 3, strides=2)

res_block * 8

for i in range(8):
    net = res_block(net, 256)
# Convolutional layer with 1024 filters
route_2 = net
net = conv2d(net, 1024, 3, strides=2)

res_block * 4

for i in range(4):
    net = res_block(net, 512)
route_3 = net

5. Input Details for Model Inference

i. Input Preprocessing:

The images need to be resized to 416 x 416 pixels before feeding it into our model or the dimensions can also be specified while running the python file

ii. Input Dimensions:

The model expects inputs to be color images with the square shape of 416 x 416 pixels or it can also be specified by the user.

6. Details on Model Inference program and output

1. The output of the model

The output is a list of bounding boxes along with the recognized classes.
Each bounding box is represented by 6 numbers (pc, bx, by, bh, bw, c). Here c is an 80-dimensional vector equivalent to the number of classes we want to predict, each bounding box is represented by 85 numbers.

2. Output of Post-processing

The Inference program produces a list of numpy arrays, the shape of which is displayed as the output. These arrays predict both the bounding boxes and class labels but are encoded.
Further we will take each of the numpy arrays and decode the candidate bounding boxes and class predictions. If there are any bounding boxes that don't confidently describe an object (having class probabilities less than the threshold, 0.3) we'll ignore them.
Here a maximum of 200 bounding boxes can be considered in an image.
I have used the correct_yolo_boxes() function to perform translation of bounding box coordinates so that we can plot the original image and draw the bounding boxes.
Again to remove those candidate bounding boxes that may be referring to the same object, we define the amount of overlap as non-max suppression threshold = 0.45.
Also there is a need to rescale the coordinates of the bounding boxes to the original image along with displaying the label and scores on top of each of them.
All these Post-processing steps need to be performed before we get the bounding boxes along with the recognized classes in our output image.

3. Output of inference program for the model

7. Speed and Accuracy of YOLOv3

Model Speed (in FPS) - On a Pascal Titan X it processes images at 30 FPS.
Model Accuracy (On Testing dataset) - It has a mAP (Mean Average Precision) of 87.54% on VOC test set.

8. Run the model

Find link to my Dockerfile : afrozchakure/yolov3-tensorflow

To run the model using docker (docker should be preinstalled) on your machine use the below commands in the terminal :)

xhost +

sudo docker run --rm -ti --net=host --ipc=host -e DISPLAY=$DISPLAY -v /tmp/.X11-unix:/tmp/.X11-unix --env="QT_X11_NO_MITSHM=1" afrozchakure/yolov3-tensorflow

9. Learn more about Working Principles of YOLOv3 from below resources

Referrence Link 1

Referrence Link 2

Well done if you came this far. Cheers 😇💖
Connect with me: https://www.linkedin.com/in/afrozchakure

You can support my work using Buy me a Coffee:
https://buymeacoffee.com/afrozchakure

Transfer Learning with MobileNet-v2

Afroz Chakure — Wed, 17 Feb 2021 08:14:23 +0000

What is Transfer Learning ?

In transfer learning, we use a pre-trained model which is trained on a large and general enough dataset to serve as a generic model for our needs.
We can use these pre-trained models without having to train a model from scratch on a large dataset.

Code

Find the Jupyter Notebook with Code for Transfer Learning here.

Model used to perform transfer learning - MobileNet V2

It is a model developed at Google.
It is trained on the ImageNet dataset, a large dataset of 1.4M images and 1000 classes.

Using the “Bottleneck Layer” for Feature Extraction

Here in the cats_vs_dogs dataset we use the very last layer before the flatten operation for feature extraction. This layer is called a ‘bottleneck layer’.
The bottleneck layer features retain more generality as compared to the final/top layer.
Here we set the include_top=False, so that we load a model that doesn’t include the classification layers at the top.

General Workflow for using a Pre-trained Model:

Examine and understand the data.
Build an input pipeline
Compose a. Loading the pre-trained model and pre-trained weights. b. Stack the classification layers on top.
Train
Evaluate

Advantages of using a pre-trained model for feature extraction:

When working with a small dataset, we can take advantage of features learned by a model trained on a larger dataset in the same domain.
This is done by instantiating the pre-trained model and adding a fully-connected classifier on top.
The pre-trained model is ‘frozen’ and only the weights of the classifier get updated during training.
This in turn helps us achieve better accuracy for our model, even if we have a small dataset and perform only fewer computations for training.

Accuracy and loss of model

The model has a initial Accuracy of 0.54 and initial loss of 0.63 for the Validation set before training.
After training the model on Train set, it has an accuracy of 0.9501 and loss of 0.1020.

Link to Dockerfile: https://hub.docker.com/repository/docker/afrozchakure/tl_tensorflow

Hyper-Parameter Tuning to Optimize ML Models (MobileNet v2)

Afroz Chakure — Wed, 17 Feb 2021 08:11:39 +0000

What is meant by Fine-Tuning a model ?

The goal of fine-tuning is to adapt specialized features from a generic dataset to work with the new dataset, rather than overwrite the generic learning.
Here I have trained (or "fine-tuned") the weights of the top layers of the pre-trained model.

Code

Find the Jupyter Notebook with the code here.

Parameters to tune

Learning rate: Choosing an appropriate learning_rate helps improve the accuracy. Here we have used learning_rate = 0.0001)
No. of epochs: Increasing the no. of epochs upto which the model should train, can increase the accuracy of the model. Here we have trained the model again on 10 epochs (20 in total).
Unfreezing the top layers of the model : We try and fine-tune a small number of top layers rather than the whole MobileNet model.

Un-freezing the top layers of the model

First step is to unfreeze the base_model and set the bottom layers to be un-trainable.
We then recompile the model (necessary for these changes to take effect), and resume training for 10 more epochs.
Lastly we compile the model using a much lower learning rate (0.0001).
After fine-tuning the model nearly reaches 98% accuracy.

# Setting the top layers as trainable
base_mode.trainable = True

# To check how many layers are in the base model
print('Number of layers in the base model: ', len(base_model.layers))

# Fine-tune from this layer onwards 
fine_tune_at = 100

# Freeze all the layers before the `fine_tune_at` layer
for layer in base_model.layers[:fine_tune_at]:
    layer.trainable = False

# This step improves the accuracy of the model by a few steps
model.compile(loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
              optimizer = tf.keras.optimizers.RMSprop(lr=base_learning_rate/10),
              metrics=['accuracy'])

Fine Tuning the parameter weights

To further improve performance, we can repurpose the top-level layers of the pre-trained models to the new dataset via fine-tuning.
In this case, we tuned our weights such that our model learned high-level featuers specific to the dataset.
This technique is usually recommended when the training dataset is large and very similar to the original dataset that the pre-trained model was trained on.

Results after Fine-Tuning the model

Before fine-tuning the model, the model has an accuracy of 93.25% and loss of 0.14 on the Test set.
After fine-tuning the model, the model has an accuracy of 97.89% and loss of 0.058 on the Test set.

Accuracy and Loss on Test set (Before Fine Tuning)

Accuaracy and Loss on Test set (After Fine Tuning)

Deep Neural Network (DNN) in a Brief

Afroz Chakure — Sun, 07 Feb 2021 13:29:18 +0000

Neural Network (NN):

It is a series of algorithms that endeavors to recognize underlying relationships in a set of data through a process that mimics the way the human brain operates.

Examples and Applications of NN:

Convolutional neural network => Good for image recognition
Long Short-Term memory network => Good for Speech Recognition

Neuron:

It is a mathematical function that models the functioning of a biological neuron.
It computes the weighted average of its input and passes the sum through a non-linear function called the activation function (such as the sigmoid).

Training an Artificial neural network:

Fig 1. Training an Artificial Neural Network

Gradient Descent:

The process of repeated nudging an input of a function by some multiple of the negative gradient is called Gradient Descent.
When there are one or more inputs, you can use Gradient descent for optimizing the values of the coefficients by iteratively minimizing the error of the model on your training data.
A learning rate is used as a scale factor and the coefficients are updated in the direction towards minimizing the error.
This process is repeated until a minimum sum squared error is achieved or no further improvement is possible.

Fig 2. Gradient Descent Image

Backward Propagation:

It is an algorithm for supervised learning of an ANN using Gradient Descent.
Given an ANN and an error function it calculates the gradient of the error function w.r.t. the NN weights.
Here the partial computations of the gradient from one layer are reused in the computation of the gradient for the previous layer.

Backpropagation Calculation:

The chain rule expressions give us the derivatives that determine each component in the gradient that helps to minimize the cost of the network by repeatedly stepping downhill.