DEV Community: Ransika Silva

Machine Learning vs. Deep Learning: What's the Difference?

Ransika Silva — Wed, 05 Mar 2025 15:50:40 +0000

Machine learning (ML) and deep learning (DL) are often used interchangeably as identical concepts; however, the two are quite different. While ML forms a part of DL, there are some basic distinctions regarding the specific purposes each aims to fulfill, the operations each was created to execute, and the specific situation that calls for the use of one method instead of the other. The next article intends to clarify the distinction between machine learning and deep learning.

What constitutes machine learning?

Machine learning lies at the core within the larger domain of artificial intelligence and uses statistical techniques that allow programs to "learn" from training sets, thereby removing the need to specifically program them [1]. The aim is to create algorithms that are capable of improving performance on specific tasks through the acquisition of knowledge through learning through experience.

Machine learning can be categorized into three types [2]:

Supervised learning - The training process uses labeled datasets where both the input and corresponding output are provided. It learns to match the inputs to the respective outputs.
Unsupervised learning means that the machine learning method uses unlabeled data to train the machine to recognize the underlying pattern or relationship that exists within the input.
Reinforcement learning involves the system learning through experience within the problem-solving environment, receiving reward or penalty during the process of searching the problem space.

Numerous commonly used machine learning algorithms include linear regression, logistic regression, decision trees, random forests, support vector machines (SVMs), and k-means clustering. Such algorithms are used to perform a variety of functions like prediction, classification, and pattern identification.

What is Deep Learning?

Deep learning forms a specialized branch of the larger machine learning domain that uses artificial neural networks to solve complex issues [3]. The method relies upon the nature and operations of the human brain based upon interconnected nodes (neurons) that enable the transfer and processing of information.

In a deep learning system, there are many layers of artificial neurons, each performing a simple computation. The word "deep" in deep learning refers to the depth of the network, that is the number of layers. As information flows through the network, each level learns more abstract features from the output of the next lower level. This methodical method of extracting the features makes the models in deep learning capable of learning complex representations from raw data [4].

Numerous commonly used deep learning structures include:

Convolutional Neural Networks (CNNs) - Mainly used to scan images and videos.
Recurrent Neural Networks are used to analyze sequential information like natural language and textual information.
Long Short-Term Memory Networks (LSTMs) - A type of RNN that can learn long-term dependencies
Generative Adversarial Networks (GANs) - Utilized to generate new datasets, especially visual data like images or videos.

Differences Between Machine Learning and Deep Learning

While both machine learning and deep learning aim to learn from data, there are some important distinctions to be made.

Data Requirements

Machine learning algorithms typically require well-prepared data along with careful feature engineering done by experienced individuals. However, deep learning has the capability to be used upon raw unstructured data, automatically extracting the required features [5].

Hardware

Deep learning requires extensive computational power and makes use of complex hardware like GPUs to train complex models within a reasonable time frame. Traditional machine learning algorithms are typically less computationally intense.

Understandability

A variety of machine learning algorithms such as decision trees are easily understandable and interpretable. However, deep learning models are often viewed as "black boxes" because of the complex structures that make them more difficult to understand [6].

Performance

For complex problems with large amounts of data, deep learning often outperforms traditional machine learning algorithms. However, for simpler problems or small datasets, machine learning may be more efficient and cost-effective.

When to Use Machine Learning vs. Deep Learning

The choice to use machine learning or deep learning will depend on several factors:

Data availability: With large and complex datasets, the use of deep learning algorithms can be beneficial. However, if the datasets are limited or simpler, the standard machine learning techniques are often sufficient.
Problem Complexity: If the problem involves perceptual tasks like image or speech recognition, deep learning is likely to perform better. For structured data and simpler problems, machine learning algorithms may be more appropriate.
Requirements for Interpretability: Where models need to be interpretable, such as healthcare or finance, machine learning methods like linear models or decision trees are used instead of the use of deep learning.
Computational Power: The use of deep learning requires large amounts of computational power that might make it unaffordable under resource-limited situations. However, machine learning algorithms typically require less.

Conclusion

While machine learning and deep learning are related, they differ in their capabilities, use cases, and underlying architectures. Machine learning encompasses a wide range of algorithms for learning from data, while deep learning focuses on neural networks with many layers. The choice between the two depends on factors like data availability, problem complexity, interpretability needs, and computational resources.

As artificial intelligence continues to evolve, the boundaries between machine learning and deep learning will likely grow more blurred. However, understanding the basic distinctions will help to inform wise decisions regarding solving data-related issues.

References

[1] Mitchell, T. (1997). Machine Learning. McGraw-Hill.

[2] Bishop, C. M. (2006). Pattern Recognition and Machine Learning. Springer.

[3] Goodfellow, I., Bengio, Y., & Courville, A. (2016). Deep Learning. MIT Press.

[4] LeCun, Y., Bengio, Y., & Hinton, G. (2015). Deep learning. Nature, 521(7553), 436-444.

[5] Bengio, Y., Courville, A., & Vincent, P. (2013). Representation learning: A review and new perspectives. IEEE Transactions on Pattern Analysis and Machine Intelligence, 35(8), 1798-1828.

[6] Samek, W., Wiegand, T., & Müller, K. R. (2017). Explainable artificial intelligence: Understanding, visualizing and interpreting deep learning models. ITU Journal: ICT Discoveries, Special Issue No. 1, 1-10.

Cybersecurity Applications of Image Classification

Ransika Silva — Sun, 02 Mar 2025 07:10:48 +0000

Machine learning has become increasingly valuable in the war against the ever-changing world of cyberattacks.Before, we spoke about the ability of machine learning to support cybersecurity at large. Here, let us look at the area of machine learning that it does best - that of classifying pictures and examine the areas of use and the challenges that are unique within the context of cybersecurity.

Detecting Phish Websites

Phishing sites are replicas of legitimate websites with the intention of misleading the user into providing sensitive information. Although the ML checks the URL and HTML attributes for the phish attack[1], visual signals are strongly pertinent too. The attackers duplicate the trusted websites with minute modifications.

Image classifiers are trained to classify such visual abnormalities such as misplaced logos, outdated visualizations, unusual position of the login form etc. Models such as EvilNet[2] are reported to be over 95% accurate for classifying the phishing websites using screenshots.

However, phishers keep making progress continuously. The latest threats need the most up-to-date retraining of the image classifiers. The most targeted spear-phish are likely more likely to be evasive as well[3]. Screenshots are ever more valuable to inspect with the traditional signals of phish detection.

Analyzing Malware Imagery

Malware often includes graphical resources and icons in order to make it appear legitimate and deceive the user into running the malicious code. Models used to classify images can learn malware visual patterns.

For instance, malware such as that distributed by e-mail are likely to employ plain or standard icons for the purpose of maximizing execution possibilities under varying themes of the operating system - something that image classifers are likely to learn about[4]. Screenshots of ransomeware payment websites or malicious app installation webpage screenshots are similarly learnable trends[5].

Challenges arise with more complex malware that impersonates using techniques such as employing techniques of binary steganography or obfuscation[6]. Multi-modal analysis with artifact binaries and behavioural details with visual content are often needed.

Detecting Deepfakes

Detecting

Deepfake videos that change faces, edit audio tracks, and doctor video are the new disinformation and social engineering frontier that ought to be troubling us. Even if they are sometimes cybersecurity threats by nature, deepfakes that are being used for impersonation, forgeries, extortion, and other malicious purposes most certainly fall under that category.

CNNs and classification models of the image are able to effectively identify the artifact and anomalies that exist within synthetic videos such as flicker, warping, asymmetry blinking etc.[7][8]

However, deepfake tools are always being refined and are increasingly more difficult to catch. The most critical challenge areas are robustness and generalization - detectors trained with particular manipulation techniques are sometimes incompetent at identifying new variants[9]. Staying abreast of synthetic media evolution always remains cat-and-mouse-like.

The Road Ahead

We've had encouraging examples of the application of image classification to cybersecurity but there's much more work to be done. In addition to the cat-and-mouse of malicious practice, challenges are data sparsity[10], adversarial robustness[11], scalability[12], and explainability[13].

As the cyberthreat profile increases in sophistication, visual insight shall become increasingly crucial supplemented by other machine learning and conventional security techniques. Additional study of efficient learning with efficiency of the data, efficiency, generalization, and interpretability shall be necessary for proper leveraging of the capability of image classification for cybersecurity.

References

Sahingoz, O.K., et al. (2019). Machine learning based phishing detection from URLs. Expert Systems with Applications.
Rao, R.S., & Ali, S.T. (2017). EvilNet: Generating Adversarial Examples to Fool Phishing Detection Models. ArXiv.
Das, A., et al. (2021). Phishpedia: A Web-based Encyclopedia of Phishing Attacks. USENIX Security Symposium.
Kancherla, K., & Mukkamala, S. (2018). Image visualization based malware detection. IEEE Symposium on Computational Intelligence in Cyber Security.
Mercaldo, F., et al. (2019). Ransomware Analysis with AI: The Visualization Approach. Intelligent Systems Reference Library.
Xue, M., et al. (2019). Adaptive Android Malware Detection with Dynamic Analysis. ACM Turing Celebration Conference.
Tolosana, R., et al. (2020). Deepfakes and beyond: A survey of face manipulation and fake detection. Information Fusion.
Mittal, S., et al. (2020). Detecting Deepfakes and Adversarial Attacks using Image Classification Models. IEEE International Conference on Informatics, IoT, and Enabling Technologies.
Vashisht, P., et al. (2021). Generalization in Deepfake Detection: an Empirical Analysis. ArXiv.
Mahdavifar, S., & Ghorbani, A.A. (2020). A Survey of Cybersecurity Datasets for Machine Learning. ArXiv.
Alawad, G., et al. (2022). Adversarial Image Classification by Hybrid Attack. International Conference on Future Communication Technologies and Applications.
Li, C., et al. (2020). Analyzing the Training Costs of Large Scale Image Classification. NeurIPS.
Kuppa, A., & Nadeem, T. (2021). xCyberSec: What, Where, Why and How is Explainability in AI for Cybersecurity. Computers & Security.

Machine Learning A Powerful Tool in the Fight Against Cyber Threats

Ransika Silva — Sun, 23 Feb 2025 15:29:26 +0000

In today's highly interconnected digital age, threats in the cyberspace are multiplying in number as well as sophistication. Hackers continuously evolve new ways of breaching networks, extracting sensitive information, as well as sabotaging the system. Conventional cybersecurity measures cannot keep pace with the changing threat horizon. Here is where machine learning (ML) is stepping in. ML is revolutionizing cybersecurity with the power of detecting threats more rapidly as well as more effectively. In this article, we'll see how ML is being applied for the enhancement of cyberspace defenses as well as touch upon a number of actual uses.

The Need for Security through Machine Learning

Cybersecurity professionals have their plates full with sheer volumes of events as well as alerts every day. Manually sorting through the mountain of data for threats is finding the needle in the haystack. Further, computer threats have also become subtle as well as advanced, easily falling under the radar of traditional signature-based detection. Machine learning is the answer because machine learning automatically processes large volumes of data identifying subtle patterns as well as outliers posing threats. By being pre-trained from experience as well as new data, ML models can identify threats humans as well as traditional security appliances miss.

How Machine Learning Can Detect Cyber Threats

Machine learning models work well when detecting patterns as well as outliers from normalcy. In the field of cybersecurity, ML models also train with large databases of normal system traffic, normal system use, as well as recognized threats. ML models can be trained as benign versus malevolent activity classifiers. Deployed models can scan continuously, alerting when suspicious events occur. Some popular ML-based techniques used in the field of cybersecurity include:

Anomaly detection: ML models detect the normal use patterns of the devices as well as the people. Any deviation from normal use, such as when the user is accessing from a new or non-familiar location at non-standard times, is considered suspicious event.
Malware discovery: ML models can identify the distinctive characteristics of the malware from the code as well as the pattern of the recognized specimens. It makes them identify new as well as unknown strains of malware evading traditional signature-based detection.
Network intrusion detection: ML can identify indications of a would-be attack through traffic pattern analysis in the network, such as port scanning, DDoS attack attempts, and attempts at exfiltration. Having the awareness of the normal traffic pattern of a network, ML models can identify minor abnormalities as indications of the presence of an attack.
User and entity behavior analytics (UEBA): It uses machine learning for the creation of normal behavior models of the devices as well as the user. It monitors any abnormality reflecting a hacked account or inside attack.

Real-World Applications of ML in Security

Most of the vendors apply machine learning in their solutions for advanced threat detection as well as responses. For example:

Darktrace applies the capability of unsupervised machine learning to build a "pattern of life" for each user as well as each device within the organization. Darktrace's Enterprise Immune System is then able to detect threats as well as respond to them in real-time without prior knowledge of the threat.
Cylance's endpoint security tool, CylancePROTECT, uses ML to scan the file DNA for benign or harmful characteristics. It is thus able to prevent new, as-yet-undiscovered malware from evading traditional antivirus.
Securonix's SNYPR incorporates machine learning-driven advanced UEBA. It builds behavior baselines for all the entities as well as iteratively learns from end-user feedback in a bid to continuously update threats detection.

Challenges and Future Directions

While machine learning is a great tool for cybersecurity, there is no panacea. ML models can be as great as the set of data upon which they have been trained. In the event the set of training is marred with biases or gaps, the model's attack detection won't be as great. ML models can be deceived with cleverness through blind spots as well as biases. Security vendors have the ongoing task of refreshing as well as honing their ML models in light of changing threats.

As ML continues to grow, there are possibilities for even greater applications in the field of cybersecurity. More sophisticated machine learning techniques such as RNNs would be capable of capturing sophisticated long-duration patterns of network and user activity. Reinforcement learning would be capable of enabling the autonomous learning of the skill of responding to threats as they occur. Cross-organizational cooperative learning would be capable of creating more robust, more transferable threat detection models.

Conclusion

Machine learning is the cybersecurity game changer. It is the equaliser when coupled with automated threat discovery and active defence from more advanced threats. As threats keep changing, ML will be the enabler of security teams being able to have the upper hand. But achieving the optimal use of ML for cybersecurity is going to be about ongoing research, advancement, and collaboration between the academy and the sector. It is sure: the future of cybersecurity is with the people who leverage the power of machine learning.

References

Cylance. (n.d.). CylancePROTECT: AI-powered endpoint protection. Retrieved from https://www.cylance.com/en-us/products/our-products/cylance-protect.html
Darktrace. (n.d.). The Enterprise Immune System: Self-learning cyber AI technology. Retrieved from https://darktrace.com/en/enterprise-immune-system/
Securonix. (n.d.). SNYPR: Next-generation SIEM with user and entity behavior analytics. Retrieved from https://www.securonix.com/products/snypr/

Data Augmentation Techniques for Improving the Robustness of Image Classifiers

Ransika Silva — Thu, 20 Feb 2025 16:08:20 +0000

Introduction

While training image classification models, we commonly encounter issues such as insufficient training data, overfitting, and poor generalization on unseen images. One way to overcome some of these challenges is through data augmentation, a powerful technique that can improve the robustness of our models. In this article, we are going to discuss some of the common examples of data augmentation techniques and how we can implement those methods in Python using TensorFlow.

What is Data Augmentation?

One approach is data augmentation; it helps to make altered images out of every input image, to increase the size and diversity of the dataset. We use different transformations of the images to simulate various differences that the model might see in the real world, allowing it to learn more robust and generalizable features [1].

Some common data augmentation techniques include:

Flipping
Rotation
Scaling
Cropping
Translation
Adding noise
Adjusting brightness or contrast
Perspective transformations

The idea is that a robust classifier should not be affected by all of these kinds of transformations; it should correctly recognize a photograph of a dog regardless of whether the photograph is mirrored, turned, or minimally zoomed-in.

Implementing data augmentation with TensorFlow

TensorFlow provides a range of preprocessing layers inside the tf.image module that can be used to build a data augmentation pipeline [2]. These preprocessing layers can easily be applied to the input data by means of the tf.data API.

Here, we provide a description of designing a multi-transformation augmentation pipeline.

import tensorflow as tf

def augment(image, label):  
    image = tf.image.resize(image, [224, 224])
    image = image.random_flip_lr
    image = tf.image.random_brightness(image, max_delta=0.5)
    image = tf.image.random_contrast(image, lower=0.2, upper=1.8)
    image = tf.image.random_rotation(image, 0.2)
    return image, tag

train_ds = train_ds.map(func=aug

This pipeline will perform a sequence of transformations to every image:

Resize the image to 224x224
Randomly flip the image horizontally
Randomly adjust the brightness by up to 0.5
Adjust the contrast at random between 0.2 to 1.8
Randomly rotate the image by up to 0.2 radians, that is 11.5 degrees

We can then supply this enriched database to the model while continuing to train.

model.fit(train_ds, epochs=10)

Recommendations for Success with Data Augmentation

Begin with the domain-independent base augmentations like flipping and rotation prior to tackling the stronger or domain-related augmentations [3].
One must also consider the kind of augmentation that can change the image class itself, like turning the digit '9' into a digit '6'.
Explore the range of augmentation parameters to find a harmonious balance; inept usage can render the gains negligible while excessive usage can impede the learning of meaningful patterns by the model.
Data augmentation can also be applied to the test and the validation sets to provide a complete analysis. Deterministic transformations like the centre cropping must, however, be applied instead of random cropping [1].
Data augmentation is no silver bullet; its strength comes into effect when combined with proper regularization, well-crafted architecture of the model, and thorough training

Visualizing Augmented Images

Visualizing examples of the image you have augmented is the best way to guarantee that the transformation looks like you want. Using the eager execution of TensorFlow, you can add the augmentation to the image and then graph the resultant image [4].

Here's a quick example of generating and plotting 9 augmented versions of an input image:

import matplotlib.pyplot as plt

for i, (augmented_image, *) in enumerate(train*ds.take(9)):
    ax = plt.subplot(3, 3, i + 1)
    plt.imshow(augmented_image)
    plt.axis("off")

Conclusion

Data augmentation is a priceless component of the toolkit of all machine learning practitioners that can improve the performance of image classifiers especially if confronted with the challenges of small or imbalanced datasets. It helps to promote the learning of stronger and transferable features by increasing the variability experienced within the training set artificially.

When paired with hyperparameter tuning, regularization techniques, and transfer learning strategies, augmentation can significantly improve the capacity of a model to deal with the complex dynamic vision present in the real world [5]. With the number of augmentation techniques out there being extensive, you must consider their suitability to your specific domain problem and monitor their impact on the performance of the model very closely. Good luck with the augmentation!

References

[1] Connor Shorten and Taghi M. Khoshgoftaar. "A survey on Image Data Augmentation for Deep Learning." Journal of Big Data 6.1 (2019): 1-48.
[2] "tf.image: Image Preprocessing - TensorFlow Core v2.11.0." TensorFlow, https://www.tensorflow.org/api_docs/python/tf/image.
[3] Aleju, Marcus. "Data Augmentation for Deep Learning." Medium, 19 July 2020, https://mxbi.medium.com/data-augmentation-for-deep-learning-4fe21d1a4eb9.
[4] "Eager Execution - TensorFlow Core v2.11.0." TensorFlow, https://www.tensorflow.org/guide/eager.
[5] Wang, Jason, and Luis Perez. "The effectiveness of data augmentation in image classification using deep learning." arXiv preprint arXiv:1712.04621 (2017).

Step-by-Step Guide: Building Your First Image Classification Project with Machine Learning

Ransika Silva — Thu, 20 Feb 2025 13:01:21 +0000

Introduction

Image classification is a pillar of the domain of computer vision that is a very good introduction to the domain of machine learning. In this article, we will go on a journey to build an image classifier from scratch with the aid of Python and Keras. At the end of this, you will have a working model that can classify images with a very acceptable degree of accuracy. So, let us begin!

Selecting a Dataset

The initial action to undertake with any machine learning activity is to find a fitting dataset to work with. It is best to find a well-documented dataset that is well-balanced—not too big and not too complex. Of the most intriguing challenges of image classification to tackle are:

MNIST: Handwritten digits (10 classes)
CIFAR-10: Small color images (10 classes)
Fashion MNIST: Fashion article images (10 classes)

For this guide, we will work with the CIFAR-10 database. The database includes 60,000 32x32 color images that are split into 10 classes with 6,000 images per class. The classes are airplane, car, bird, cat, deer, dog, frog, horse, ship, and truck.

The CIFAR-10 database can be obtained by the following code:

from tensorflow.keras.datasets import cifar10

(train_images, train_labels), (test_images, test_labels) = cifar10.load_data()

Setting Up Your Environment

Before diving into the code itself, you need to have the proper software installed to successfully finish this exercise:

Python version 3.x
TensorFlow 2.x, included with Keras
NumPy
Matplotlib (for visualization)

They can be installed with pip:

pip install tensorflow numpy matplotlib

Prepare the Data

Once the database is downloaded and the environment is established, we proceed with the following stages to prepare the learning material:

Modify the value of the pixel to between 0 to 1
Transform the category to a representation of a one-hot vector
Split the data into training sets and testing sets

Here lies the code that serves this function:

train_images = train_images / 255.0
test_images = test_images / 255.0

train_labels = to_categorical(train_labels) 
test_labels = to_categorical(test_labels)

Building the Model

At long last, we are at the exciting phase of building the neural network! We will have a convolutional neural network (CNN), a format that is highly adept at processing image information. We will have a simple CNN consisting of the following layers:

Conv2D layer with 32 filters, 3x3 kernel, ReLU activation
A MaxPooling2D with a 2x2 pooling area
A Conv2D with 64 filters with a 3x3 kernel and ReLU activation
A MaxPooling2D with a 2x2 pool size
Flatten the layer to reshape 2D features to 1D
Dense layer with 64 units, ReLU activation
Dense output layer with 10 units, softmax activation

This is the way that it looks:

model = models.Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),  
    MaxPooling2D((2, 2)),
    Conv2D(64, kernel_size=(3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    Conv2D(64, (3, 3), activation='relu'),
    Flatten(),
    Dense(64, activation='relu'),
    Dense(10, activation='softmax')
])

Training and Evaluation

With our architecture built out, the time is ready to actually train the model with our information. We first build the model out with the optimizer, loss function, and metrics we want to track:

model.compile(optimizer='adam',
              loss='categorical_crossentropy', 
              metrics=['accuracy'])

Then, we train the model using fit():

history = model.fit(train_images, train_labels, epochs=10, 
                    validation_data=(test_images, test_labels))

After training, we can evaluate the model's performance on the test set:

test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print('Test accuracy:', test_acc)

We can also plot the training and validation accuracy over time:

plt.plot(history.history['accuracy'], label='accuracy')
plt.plot(history.history['val_accuracy'], label = 'val_accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.show()

Conclusion

Congratulations, you have successfully built your very first image classification model! With minimal code touch, we were able to train a CNN that has a 70% accuracy rate of correctly predicting classes of images. Of course, much is still to improve upon; you could look into techniques like data augmentation or transfer learning to improve performance all the way!

I trust that this guide has introduced you to the potential of machine learning and computer vision. Carry on with learning, and have a nice time programming!

References and Resources

CIFAR-10 dataset: https://www.cs.toronto.edu/~kriz/cifar.html
Keras documentation: https://keras.io/
TensorFlow tutorials: https://www.tensorflow.org/tutorials
Stanford CS231n: Convolutional Neural Networks for Visual Recognition: https://cs231n.github.io/