No Code Machine Learning for Non-CS Background

Introduction

The recent decade has witnessed a massive surge in the application of Machine learning techniques. There is a continuous rise of application of machine learning techniques in nearly all domains, including research, education, environment, social science, businesses, service providers, production, manufacturing,  supply chain, healthcare, biochemistry, biotechnology, and many more. Adding machine learning techniques to existing systems is not a mere IT update but a business-wide endeavor.

These additions can help broaden the horizons, explore new avenues, identify problematic areas, optimize the workflow, explore new markets, and improve customer services. Today, every business wants to take the benefits of machine learning with priority. However, those not from a specific computer science background find it hard to utilize machine learning techniques in their domains. This article presents a case study using a no-code platform to design a machine-learning solution.

Learning Outcomes

• Understand the rise and impact of machine learning applications across various domains.
• Identify challenges in conventional machine learning implementations and the role of no-code platforms.
• Learn about key features and benefits of no-code machine learning platforms.
• Gain insights into practical applications of no-code platforms through a detailed use case.
• Explore steps to implement machine learning solutions using Python and no-code platforms.

This article was published as a part of the Data Science Blogathon.

Challenges with Conventional Implementation

Machine learning systems have their complexities. Designing and coding a machine learning application through the traditional approach is tiresome and expensive. In-house development of customized products for data analysis has challenges like recruiting qualified professionals, setting up hardware and licensing software, and the time-consuming development lifecycle of products.

Citizen developers and programmers are moving away from this coding-intensive approach. They are looking into tools with simple user interface design, general application development with drag-and-drop, forms, or wizard facilities.

Finding the right team of experts is also a big challenge. Traditional ML implementations are done under the guidance of an expert, data scientist, or data analyst. The experts must use programming languages to code and deploy the machine learning system and generate results. There are difficulties in finding the right ML expert with good coding skills in the market; hence, businesses are looking for alternatives to fill the gap.

The key point about generating an ML system is that an ML expert should have good knowledge of data analysis, machine learning algorithms, and coding. However, ML experts might be experts in their domain but not in business solutions, which might lead to a gap between expectations and the real outcome.

A typical machine learning workflow comprises stages like data cleaning, data preparation, model selection, training, testing, hyper-parameter tuning, and report generation or prediction. However, implementing this theory is not easy. It requires a good understanding of computer programming, mathematics, and statistics.

Potential Solution: No Code Platform

To address these challenges and empower non-CS professionals, no-code platforms have emerged. These platforms are automatic machine learning tools that can deliver rapid results, particularly for time-sensitive projects with limited resources. Traditional programming often requires extensive language skills, which can be time-consuming to acquire. However, with a no-code platform, individuals with limited programming knowledge can design applications tailored to their specific needs.

No-code platforms like Shopify allow business owners to launch online stores without building a website from scratch, saving time and effort. By 2024, Gartner estimates that 80% of technology services and products will be built outside IT departments, making no-code platforms a crucial tool for millions of businesses.

User-friendly, automated ML platforms are emerging as an excellent option to simplify the analytic and coding process. These platforms can be used by anyone to develop customized products without the need for conventional programming. The seamless and simplified platforms have allowed citizen developers and businesses to digitize and update their services and products to be competitive, without relying on heavy, time-consuming IT skills for programming.

Platforms offer user-friendly data analysis tools for data exploration, deep learning, and machine learning models. They provide a user-friendly interface with drag-and-drop icons, allowing for minimal coding. Users can modify ML models and settings without writing code, and integrate code written in Python, C, and C++, enhancing the learning process with diverse functionalities and devices.

Below is the table for clear clarification

No Code Platform Features

A platform is considered to be no code when it has a user friendly interface to create a machine learning system without any coding. The platform should have the following features.

• The platform should automate data ingestion and support multiple formats.
• Complete automation of data preprocessing with data visualization. The data preprocessing includes processing like handling missing data, redundancy or imbalance.
• The platform provides a wide variety of models and recipes for analysis. The user can choose from the dropdown box or ask for suggestions. The process of training, testing, and validating the model is automated with nearly no human interaction. Multiple simple and complex models can be selected and tested; if required, an ensemble can be added to the process. Irrespective of the complexity of the learning model, the platform can compare the performance and rank the models implemented.
• The performance output is automatically displayed on a dashboard through standard metrics like a confusion matrix.
• The models can be auto-scaled and are production-ready and fast-to-go in the market.
• The platform should facilitate the auto-tuning of hyper-parameters.
• Continuous monitoring of the performance of models.

A typical machine learning workflow comprises stages like data cleaning, data preparation, model selection, training, testing, hyper-parameter tuning, and report generation or prediction. However, implementing these is not an easy job. It requires a good understanding of computer programming, mathematics, and statistics.

Let’s see how a no-code platform can be helpful with an example.

Use Case

Mammalian fully-grown oocytes are classified as a Surrounded Nucleolus (SN) or a Not Surrounded Nucleolus (NSN) based on their chromatin configuration observed after staining. We have a dataset of images of mouse oocytes to be classified as SN or NSN. The given problem is a machine learning classification problem where the images must be classified based on their features. The dataset used in the example can be found here https://figshare.com/articles/dataset/Orange-Image-Analytics/9632276?file=17282204

The above classification is achieved with the following Python program.

Step by Step Outline of Code

Let us now go through the steps.

Step1: Load Data Set and Pre-process

Load images for both SN and NSN from the given directory and convert to array.

import matplotlib.pyplot as plt
import numpy as np
import PIL
import tensorflow as tf
import pandas as pd
import os
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.models import Sequential
from tensorflow.keras.applications.inception_v3 import InceptionV3, preprocess_input
from tensorflow.keras. preprocessing import image
from sklearn.metrics import pairwise_distances
from sklearn.manifold import MDS
from os import listdir


# get the path/directory
folder_dir = "/content/sample_data/OO/SN"
for images in os.listdir(folder_dir):

    # check if the image ends with jpg
    if (images.endswith(".jpg")):
        print(images)

    # check if the image ends with jpg  
folder_dir = "/content/sample_data/OO/NSN"
for images in os.listdir(folder_dir):

    # check if the image ends with jpg
    if (images.endswith(".jpg")):
        print(images)

# Set the paths
data_dir="/content/sample_data/OO"
sn_dir = os.path.join(data_dir, 'SN')
nsn_dir = os.path.join(data_dir, 'NSN')

Step2: Image embedding

Create and extract embedding (vectors) of images with Google’s Inception V3.

# Load InceptionV3 model pre-trained on ImageNet without the top layer
inception_model = InceptionV3(weights="imagenet", include_top=False)

inception_model.summary()
# Function to load and preprocess images
def load_and_preprocess_img(img_path):
    img = image.load_img(img_path, target_size=(299, 299))
    img_array = image.img_to_array(img)
    img_array = np.expand_dims(img_array, axis=0)
    return preprocess_input(img_array)

# Function to extract embeddings 
def extract_embeddings(model, img_dir):
    embeddings = []
    img_paths = []
    for img_file in os.listdir(img_dir):
        img_path = os.path.join(img_dir, img_file)
        img_paths.append(img_path)
        preprocessed_img = load_and_preprocess_img(img_path)
        embedding = model.predict(preprocessed_img)
        embeddings.append(embedding.flatten())
    return np.array(embeddings), img_paths

# Combine embeddings and paths
all_embeddings = np.vstack((sn_embeddings, nsn_embeddings))
all_paths = sn_paths + nsn_paths

Step3: Calculate Distance

Calculate the pairwise distance between the vectors of images with euclidean distance method.

# Calculate the pairwise distances
distance_matrix = pairwise_distances(all_embeddings, metric="euclidean")

Step4: Apply Multidimensional Scaling

Convert the results into 2D with dimension reduction technique MDS for get an insight of images.

# Apply MDS
mds = MDS(n_components=2, dissimilarity='precomputed', random_state=42)
mds_embeddings = mds.fit_transform(distance_matrix)

Step5: Visualization

Create a 2D scatter graph to show the classification of images with annotations.

# Create a DataFrame for visualization
labels = ['SN'] * len(sn_paths) + ['NSN'] * len(nsn_paths)
df = pd.DataFrame({'x': mds_embeddings[:, 0], 'y': mds_embeddings[:, 1], 'label': labels})

# Plotting the MDS result
import pandas as pd
from plotnine import ggplot, aes, geom_point
df = pd.DataFrame({'x': mds_embeddings[:, 0], 'y': mds_embeddings[:, 1], 'label': labels})
# Create the scatter plot
(ggplot(df, aes(x='x', y='y')) +   geom_point())

The above python code is the minimal indicative code for unsupervised image classification of images to classify them as SN or NSN and plot a graph. The code can be optimized or scaled or customized according to the user requirement. For example the umap can applied to reduce dimensions or ResNet50 model from Keras can used to create embedding.

However, analysts without a Python background can also analyze the images with the help of no-code platforms like Orange. Orange is an AutoML platform for analyzing data and predicting outputs.The above Python code can be implemented in Orange in the following steps.

Conclusion

No-code machine learning platforms are rapidly emerging as Software-as-a-Service (SaaS) platforms, where they provide infrastructure and access to advanced functionalities through APIs and user interfaces. These platforms offer the advantage of upgradation by moving to advanced models with minimal hassle. Moreover, flexibility and scalability are other advantages that come handy to meet changing or expanding business requirements.

Key Takeaways

• No-code machine learning platforms democratize access to ML, enabling non-programmers to build and deploy models.
• These platforms streamline the ML development process, saving time and reducing costs compared to traditional methods.
• They offer user-friendly interfaces and automated features, simplifying tasks like data preprocessing, model selection, and performance monitoring.
• No-code platforms support a wide range of applications across various industries, enhancing efficiency and innovation.
• While they provide significant benefits, no-code platforms may have limitations in customization and performance for highly complex tasks.

Frequently Asked Questions

The media shown in this article is not owned by Analytics Vidhya and is used at the Author’s discretion.