In this, building machine learning models are a skill that only data scientists with Python knowledge can master. However, low-code AI platforms now make things much easier.
Now anyone can make a model directly, link it to the data, and publish it as a web service with just a few clicks. Marketers can now develop customer segmentation models, user support teams can implement chatbots, and product managers can automatically predict the sales process without writing code.
Even so, this simplicity still has its drawbacks.
A false start of a scale
When a mid-sized e-commerce company introduced its first machine learning model, it took the fastest route: a low-code platform. The data team quickly built a product recommendation model using Microsoft Azure ML designers. No coding or complex setup is required, and the model is up and running in just a few days.
When staged, it did a great job of recommending related products and maintaining user interest. However, when 100,000 people use the app, it faces problems. Response time twice. It is recommended to show it only twice, or not at all. Eventually, the system crashed.
The problem is not the model being used. This is the platform.
Azure ML designer and AWS Sagemaker canvas are designed to run quickly. Thanks to their easy-to-use drag and drop tools, machine learning can be used by anyone. However, the simplicity of making them easy to use also covers their weaknesses. When a simple prototype puts it into high-flow production, these tools start to fail, which happens due to their structure.
Simple fantasy
Low-code AI tools have been promoted to people who are not technical experts. They take care of the complex parts of data preparation, function creation, training the model, and using it. Azure ML Designer enables users to import data quickly, build model pipelines and deploy pipelines as web services.
However, there is an abstract idea that is both positive and negative.
Resource Management: Limited and Invisible
Most low-code platforms run models on pre-designed computing environments. The amount of CPU, GPU and memory that users can access is unadjustable. In most cases, these limits work well, but they become a problem when traffic surges.
Using the AWS SageMaker Canvas’ educational technology platform, creates a model that classifies students’ responses when submitted. During the test, it performed perfectly. However, as the number of users reaches 50,000, the model’s API endpoint fails. The only solution to discover that the model is running on the basic compute instance and upgrade it to rebuild all workflows.
National Administration: Hidden but dangerous
Because low-code platforms keep model state between sessions, they can be tested quickly, but can be risky in real life.
A chatbot for retail is created in Azure ML Designer to maintain user data during each session. During the testing period, I felt like this experience was just for me. However, in production environments, users start to receive messages targeting others. question? It stores information about user sessions, so each user will be considered a previous continuation.
Limited surveillance: large-scale blindfolding of eyes
Low-code systems give basic results, such as accuracy, AUC or F1 scores, but these are measures to test, not test measures to run the system. Only after the incident did the team realize that they could not track what was essential in the production environment.
Logistics Launches implement a demand forecast model using Azure ML designer to help with routing optimization. Everything was fine until the holidays arrived and requested. Customers complain about slow response, but the team cannot see how long the API will take to respond or find the cause of the error. The model cannot be opened to see how it works.
Scalable and non-scale low-code pipelines (author image)
Why is low-code models difficult to deal with large projects
Low-code AI systems cannot scale because they lack the key components of a powerful machine learning system. They are popular because they are fast, but it’s a price: losing control.
1. Resource limitations become bottlenecks
Low code models are used for environments that set limits on computing resources. As time goes by, more people use them, the system will slow down or even crash. These limitations can cause significant problems if the model has to deal with large amounts of traffic.
2. Hidden state creates unpredictability
State management is usually not something you have to consider in a low-code platform. For users, the value of a variable is not lost from one session to another. It works for testing, but once multiple users use the system at the same time, it becomes messy.
3. Observability barrier block debugging
Low-code platforms provide basic information (such as accuracy and F1 scores), but do not support monitoring of production environments. Teams cannot see API latency, how to use resources or data input methods. The problem that occurred cannot be detected.
Low-code AI Scaling Risk – Hierarchical View (Author’s Image)
List of factors to consider when making a low-code model scalable
Low code doesn’t mean it’s easy to work, especially if you want to grow. When making ML systems with low-code tools, scalability must be remembered from the beginning.
1. Consider scalability when designing a system for the first time.
- You can use services that provide automatic scaling, such as Azure Kubernetes service in Azure ML and Sagemaker pipeline in AWS.
- Avoid default computing environments. Perform instances that can handle more memory and CPU as needed.
2. Isolated State Management
- To use a session-based model like a chatbot, make sure that user data is cleared after each session.
- Ensure that the web service handles each request independently to avoid accidental transmission of information.
3. Watch the production number and model.
- Monitors the API’s response time, the number of failed requests, and the resources used by the application.
- Use PSI and KS scores to find out when the input of the system is not standard.
- Focus on business results, not only on technical numbers (conversion rates and sales impact).
4. Implement load balancing and automatic scaling
- Use the model as a managed endpoint with the help of a load balancer (Azure Kubernetes or AWS ELB).
- You can set the automatic scaling guide based on CPU load, number of requests, or delays.
5. Versions and test models are constantly
- Make sure that a new version of each model is given every time you change it. Checking should be done on the stage before a new version is released to the public.
- Perform A/B tests to check how the model works without causing the user to destroy the user.
When the low-code model is running well
- The low-code tool has no obvious flaws. They are powerful:
- Rapid prototyping means prioritizing speed over stable results.
- Analysis conducted within the system, where the probability of failure is small.
- Simple software is valuable in school because it speeds up the learning process.
A group of people at a healthcare startup built models using AWS Sagemaker canvas to capture medical billing errors. This model is only used for internal reporting, so it does not require scale-up and can be easily used. This is an ideal situation for using low code.
in conclusion
Low-code AI platforms provide instant intelligence because they do not require any encoding. But, as the business grows, its shortcomings reveal. Some problems are insufficient resources, limited information leakage and visibility. These issues cannot be solved with just a few clicks. They are architectural issues.
When launching a low-code AI project, consider whether it is used as a prototype or a marketable product. If the latter, low code should only be your initial tool, not your final solution.
