Forem: Learn Earn & Fun

Predicting Flight Prices with MindsDB

Hridya — Sat, 14 Oct 2023 13:17:14 +0000

Introduction

MindsDB is an Open-Source AI Layer for databases, For more details, Checkout this blog to know more

This tutorial will teach you how to train a model to predict flight prices based on many variables, such as duration, stops etc.. with MindsDB

Importing Data into MindsDB Cloud

In order to import the dataset to MindsDB Cloud, we need to first download it from Kaggle and then upload it simply to MindsDB using the steps mentioned below.

Step 1: Create a MindsDB Cloud Account, If you already haven't done so

Step 2: Download this Dataset

Step 3: Click the Upload file option under the Add List.
(After downloading you will get a .zip file, You have to extract it and import the csv inside)

Step 4: Name the Table

Step 5: To verify the dataset has successfully imported in:

Run this Query:

SHOW TABLES FROM files;

If you see the dataset, then it's imported successfully!

We have imported our dataset into MindsDB, next up we will be creating a Predictor Model!

Training a Model

Step 1: Creating a Predictor Model

MindsDB provides a syntax which exactly does that!

CREATE PREDICTOR mindsdb.predictor_name       (Your Predictor Name)
FROM database_name                            (Your Database Name)
(SELECT columns FROM table_name LIMIT 10000)  (Your Table Name)
PREDICT target_parameter;                     (Your Target Parameter)

Change the paramaters with the ones you want to use

CREATE PREDICTOR mindsdb.flightprice_predictor
FROM files 
(SELECT * FROM FlightPrices LIMIT 10000)
PREDICT price;

Step 2: Based on the size of the dataset, it might take some time.

There's 3 stages once you run the command to create the model:

Generating: The model's generating!
Training: Model is getting trained with the dataset
Complete: The model is ready to do predictions

To check the status, this is the query:

SELECT status
FROM mindsdb.predictors
WHERE name='flightprice_predictor'

Once it returns complete we can start predicting with it!

Describe the Model

Before we proceed to the final part of predicting flight prices, let us first understand the model that we just trained.

MindsDB provides the following 3 types of descriptions for the model using the DESCRIBE statement.

By Features
By Model
By Model Ensemble

By Features

DESCRIBE mindsdb.flightprice_predictor.features;

This query shows the role of each column for the predictor model along with the type of encoders used on the columns while training.

By Model

DESCRIBE mindsdb.flightprice_predictor.model;

This query shows the list of all the underlying candidate models that were used during training. The one with the best performance (whose value is 1), is selected. You can see the value 1 for the selected one in the selected column while others are set at 0.

By Model Ensemble

DESCRIBE mindsdb.flightprice_predictor.ensemble;

This query gives back a JSON output that contains the different parameters that helped to choose the best candidate model for the Predictor Model.

As we are done understanding our Predictor model, let's move on to predicting values.

Predicting the Target Value

We will start by predicting that only 1 feature parameter is supported by price and therefore the query should look like this.

NOTE: While predicting always input multiple feature parameters as the prediction accuracy degrades.

SELECT price
FROM mindsdb.flightprice_predictor
WHERE duration ='2.29';

SELECT price
FROM mindsdb.flightprice_predictor
WHERE airline = 'Vistara' and duration = '2.29';

You can play around with the values to predict different prices based on the dataset

We have now successfully predicted the Flight prices with MindsDB

Conclusion

This concludes the tutorial here.

Lastly, before you leave, I would love to know your feedback in the Comments section below and it would be really great if you drop a LIKE on this article.

Quickstart to Flyte

Hridya — Sun, 08 Oct 2023 18:28:55 +0000

Introduction

What is Flyte?

Kubernetes-native workflow automation platform
Open-source
Makes it easy create concurrent, scalable, and maintainable workflows
DLF AI & Data Incubation Project
Opinionated, scalable & hosted workflow automating platform
Extensible, Auditable, Observable

Integrations

Flyte supports a ton of integrations such as Hugging Face, Vaex,
Polars, Modin, BigQuery, DuckDB, Hive, etc...

This is an overall view of how many integrations they support!

You can check out all the integrations they support by clicking here

Trust by Companies

Flyte is used in production at LinkedIn, Spotify, Intel and others.

Setting Up Flyte

Note: You can skip this step and use Flyte on the browser if you don't want to download Flyte on your PC, https://sandbox.union.ai/

Requirements

Docker
Python

Ensure that your Docker Daemon is running

Installation

pip install flytekit flytekitplugins-deck-standard scikit-learn

Installing FlyteCTL

FlyteCTL is a command-line interface for Flyte

OSX

brew install flyteorg/homebrew-tap/flytectl

Other Operating Systems

curl -sL https://ctl.flyte.org/install | sudo bash -s -- -b /usr/local/bin

Creating an Example Flyte Script

Just to checkout your setup works and have a bit of fun with Flyte.

Let's create an example script with flyte that:

Trains a model on the Wine Dataset from sklearn

Here's the script, insert it into any python file

from sklearn.datasets import load_wine
from sklearn.linear_model import LogisticRegression


def get_data():
    """Get the wine dataset."""
    return load_wine(as_frame=True).frame


def process_data(data):
    """Simplify the task from a 3-class to a binary classification problem."""
    return data.assign(target=lambda x: x["target"].where(x["target"] == 0, 1))


def train_model(data):
    """Train a model on the wine dataset."""
    features = data.drop("target", axis="columns")
    target = data["target"]
    return LogisticRegression(max_iter=1000).fit(features, target)


def training_workflow():
    """Put all of the steps together into a single workflow."""
    data = get_data()
    processed_data = process_data(data)
    return train_model(processed_data)


if __name__ == "__main__":
    print(f"Running training_workflow() {training_workflow()}")

Running Flyte workflows

You can run the workflow in example.py on a local Python environment or a Flyte cluster.

Running a workflow using a local python env

Run this command to kickstart your newly created workflow using a python env
NOTE: Change example.py with the filename your Python file is!

pyflyte run example.py training_workflow

Creating a Demo Flyte Cluster

Run this command to kickstart your newly created workflow using a Flyte Cluster.

flytectl demo start

Then run the workflow on the cluster with the following command:

pyflyte run --remote example.py training_workflow

If you have setup everything correctly, You should receive the following message:

Great! You have run and successfully setup Flyte in your computer

Conclusion

🎉 Congratulations! In this getting started guide, you:

🤓 You learned all about Flyte
💻 Setup Flyte in your computer
📜 Created a Flyte script
🛥 Created a demo Flyte cluster on your local system.
👟 Ran a workflow locally and on a demo Flyte cluster.

Flyte is a great workflow automation tool for Data, Machine Learning Processes

Lastly, don't forget to leave a LIKE and key in your feedback in the comments!

Predicting Mobile Phone Prices with MindsDB

Hridya — Fri, 04 Nov 2022 17:31:35 +0000

Introduction

MindsDB is an Open-Source AI Layer for databases, For more details, Checkout this blog to know more

This tutorial will teach you how to train a model to predict mobile worth based on many variables, such as clock_speed, battery_power, dual_sim, etc.. with MindsDB

Importing Data into MindsDB Cloud

In order to import the dataset to MindsDB Cloud, we need to first download it from Kaggle and then upload it simply to MindsDB using the steps mentioned below.

Step 1: Create a MindsDB Cloud Account, If you already haven't done so

Step 2: Download this Dataset

Step 3: Go into Add Data -> Files -> Import File
Lastly Add the dataset (After downloading you will get a .zip file, You have to extract it and import the csv inside)

Step 4: Name the Table

Step 5: To verify the dataset has successfully imported in:

Run this Query:

SHOW TABLES FROM files;

If you see the dataset, then it's imported successfully!

We have imported our dataset into MindsDB, next up we will be creating a Predictor Model!

Training a Model

Step 1: Creating a Predictor Model

MindsDB provides a syntax which exactly does that!

CREATE PREDICTOR mindsdb.predictor_name       (Your Predictor Name)
FROM database_name                            (Your Database Name)
(SELECT columns FROM table_name LIMIT 10000)  (Your Table Name)
PREDICT target_parameter;                     (Your Target Parameter)

Simply replace the paramaters with the ones you want to use

CREATE PREDICTOR mindsdb.mobileprice_predictor
FROM files 
(SELECT * FROM MobilePrices LIMIT 10000)
PREDICT price_range;

Step 2: Based on the size of the dataset, it might take some time.

There's 3 stages once you run the command to create the model:

Generating: The model's generating!
Training: Model is getting trained with the dataset
Complete: The model is ready to do predictions

To check the status, this is the query:

SELECT status
FROM mindsdb.predictors
WHERE name='mobileprice_predictor'

Once it returns complete we can start predicting with it!

Describe the Model

Before we proceed to the final part of predicting mobile phone prices, let us first understand the model that we just trained.

MindsDB provides the following 3 types of descriptions for the model using the DESCRIBE statement.

By Features
By Model
By Model Ensemble

By Features

DESCRIBE mindsdb.predictor_model_name.features;

This query shows the role of each column for the predictor model along with the type of encoders used on the columns while training.

By Model

DESCRIBE mindsdb.predictor_model_name.model;

By Model Ensemble

DESCRIBE mindsdb.predictor_model_name.ensemble;

This query gives back a JSON output that contains the different parameters that helped to choose the best candidate model for the Predictor Model.

As we are done understanding our Predictor model, let's move on to predicting values.

Predicting the Target Value

We will start by predicting that only 1 feature parameter is supported by price_range and therefore the query should look like this.

NOTE: While predicting always input multiple feature parameters as the prediction accuracy degrades.

SELECT price_range
FROM mindsdb.mobileprice_predictor
WHERE dual_sim ='0';

The predicted price range should be 0

SELECT price_range 
FROM mindsdb.mobileprice_predictor
WHERE touch_screen ='0' and int_memory = 51;

The price range should be 3

Mobilistic! We have now successfully predicted the mobile phone price range with MindsDB

Conclusion

This concludes the tutorial here.

Lastly, before you leave, I would love to know your feedback in the Comments section below and it would be really great if you drop a LIKE on this article.

Predicting Wine Quality with MindsDB

Hridya — Fri, 04 Nov 2022 17:26:57 +0000

Introduction

MindsDB is an Open-Source AI Layer for databases, For more details, Checkout this blog to know more

In this tutorial we will be predicting the quality of wine based on its features using MindsDB.

Importing Data into MindsDB Cloud

In order to import the dataset to MindsDB Cloud, we need to first download it from Kaggle and then upload it simply to MindsDB using the steps mentioned below.

Step 1: Create a MindsDB Cloud Account, If you already haven't done so

Step 2: Download this Dataset

Step 3: Go into Add Data -> Files -> Import File
Lastly Add the dataset (After downloading you will get a .zip file, You have to extract it and import the csv inside)

Step 4: Name the Table

Step 5: To verify the dataset has successfully imported in:

Run this Query:

SHOW TABLES FROM files;

If you see the dataset, then it's imported successfully!

We have imported our dataset into MindsDB, next up we will be creating a Predictor Model!

Training a Model

Step 1: Creating a Predictor Model

MindsDB provides a syntax which exactly does that!

CREATE PREDICTOR mindsdb.predictor_name       (Your Predictor Name)
FROM database_name                            (Your Database Name)
(SELECT columns FROM table_name LIMIT 10000)  (Your Table Name)
PREDICT target_parameter;                     (Your Target Parameter)

Simply replace the paramaters with the ones you want to use

CREATE PREDICTOR mindsdb.wine_predictor
FROM files 
(SELECT * FROM WineFeatures LIMIT 10000)
PREDICT quality;

Step 2: Based on the size of the dataset, it might take some time.

There's 3 stages once you run the command to create the model:

Generating: The model's generating!
Training: Model is getting trained with the dataset
Complete: The model is ready to do predictions

To check the status, this is the query:

SELECT status
FROM mindsdb.predictors
WHERE name='wine_predictor'

Once it returns complete we can start predicting with it!

Describe the Model

Before we proceed to the final part of predicting the wine quality, let us first understand the model that we just trained.

MindsDB provides the following 3 types of descriptions for the model using the DESCRIBE statement.

By Features
By Model
By Model Ensemble

By Features

DESCRIBE mindsdb.predictor_model_name.features;

This query shows the role of each column for the predictor model along with the type of encoders used on the columns while training.

By Model

DESCRIBE mindsdb.predictor_model_name.model;

By Model Ensemble

DESCRIBE mindsdb.predictor_model_name.ensemble;

This query gives back a JSON output that contains the different parameters that helped to choose the best candidate model for the Predictor Model.

As we are done understanding our Predictor model, let's move on to predicting values.

Predicting the Target Value

It should be noted that the quality of wine is determined by multiple feature values altogether. The accuracy may degrade if some of these feature values are left out.

But let us still try to predict the wine quality based on a few feature sets with a query like this.

SELECT quality,quality_confidence,quality_explain
FROM mindsdb.wine_predictor
WHERE pH=3.3 AND density=0.997 AND alcohol=9.4 AND sulphates=0.46;

As the predicted quality is 5, It states that the wine is neither good nor bad.

It's time to pass values of all the features to have a more accurate prediction.

SELECT quality,quality_confidence,quality_explain
FROM mindsdb.wine_predictor
WHERE pH=3.5 AND density=0.9976 AND alcohol=13 AND sulphates=0.86 
AND fixed_acidity=10.3 AND volatile_acidity=0.3 AND citric_acid=0.72 
AND residual_sugar=2.5 AND chlorides=0.075 AND free_sulfur_dioxide=11 
AND total_sulfur_dioxide=20;

As the predicted Quality is 8, this wine is good!

Great! We have now successfully predicted the wine quality with MindsDB

Conclusion

This concludes the tutorial here.

Lastly, before you leave, I would love to know your feedback in the Comments section below and it would be really great if you drop a LIKE on this article.

Predicting Tesla Stock Prices with MindsDB!

Hridya — Thu, 03 Nov 2022 13:39:06 +0000

Introduction

If you don't know what MindsDB is, Go checkout my blog to know more

Basically, MindsDB is an Open-Source AI Layer for existing Databases.

It's an AI Layer for traditional databases such as PostgreSQL, MariaDB, MySQL, etc..

In this tutorial, We are going to be predicting the stock prices of tesla using MindsDB!

Importing Data into MindsDB Cloud

In order to import the dataset to MindsDB Cloud, we need to first download it from Kaggle and then upload it simply to MindsDB using the steps mentioned below.

Step 1: Create a MindsDB Cloud Account, If you already haven't done so

Step 2: Download this Dataset

Step 3: Go into Add Data -> Files -> Import File
Lastly, Add the dataset (After downloading you will get a .zip file, you have to extract it and import the csv inside)

Step 4: Name the Table: TeslaStock (You can name it anything you like!)

Step 5: To verify the dataset has successfully imported in:

Go into the Editor Tab and run this command:

SHOW TABLES FROM files;

If you see TeslaStock or whatever you named it that means it's successfully imported!

Training a Model

MindsDB provides very simple SQL queries to carry out different tasks in its interface. So, we will now proceed with the steps below to get ready with the model.

Step 1: Create a Model, we will be creating a Predictor Model.

CREATE PREDICTOR mindsdb.tesla_predictor   
FROM files
(SELECT * FROM TeslaStock)              
PREDICT Close                      
ORDER BY value_date                
WINDOW 120                         
HORIZON 60;

Step 2: Based on the size of the dataset, it might take some time.

There's 3 stages once you run the command to create the model:

Generating: The model's generating!
Training: Model is getting trained with the dataset
Complete: The model is ready to do predictions

To check the status, this is the query:

SELECT status
FROM mindsdb.predictors
WHERE name='tesla_predictor';

Once it returns complete we can start predicting with it!

Describe the Model

Before we proceed to the final part of predicting the tesla stock price, let us first understand the model that we just trained.

MindsDB provides the following 3 types of descriptions for the model using the DESCRIBE statement.

By Features
By Model
By Model Ensemble

By Features

DESCRIBE mindsdb.predictor_model_name.features;

This query shows the role of each column for the predictor model along with the type of encoders used on the columns while training.

By Model

DESCRIBE mindsdb.predictor_model_name.model;

By Model Ensemble

DESCRIBE mindsdb.predictor_model_name.ensemble;

This query gives back a JSON output that contains the different parameters that helped to choose the best candidate model for the Predictor Model.

As we are done now understanding our Predictor model, let's move on to prediciting values in the next section.

Predicting the Target Value

Before we proceed, we need to understand the basic scenario here. So, we have a dataset that lists out the closing stock values of Tesla over a period of time. Now, with this predictor model, we will try to predict the closing value after the last record available in the dataset. We can do that by using another keyword LATEST for the dates now.

This is the query:

SELECT T.value_date as date,
       T.Closing as Forecast,
       Closing_explain
FROM mindsdb.tesla_predictor as T
JOIN files.TeslaStock as P
WHERE P.value_date > LATEST
LIMIT 60;

This query should return us with the forecasts of up to 2 months (60 Days) after the last date that was available in the dataset.

Awesome! We have now successfully predicted the Tesla Stock Prices using a Predictor.

Conclusion

This concludes the tutorial here. Before we wrap this up, let's do a quick recap of what we did here. We first started with creating a MindsDB Cloud account, fed the dataset and created a table using the cloud UI, trained a Predictor model, described its model features and finally predicted the target closing value.

Lastly, before you leave, I would love to know your feedback in the Comments section below and please drop a LIKE

Introduction to Refine

Hridya — Mon, 31 Oct 2022 20:51:14 +0000

Introduction

What is Refine?

Refine is a React Framework that makes it really easy to create CRUD Applications

Why should you use refine?

Really easy to setup
Blazing fast to create an application
Supports a ton of data providers
SSR Support

Integrations

Refine supports a lot of integrations:

UI Frameworks/Libraries: AntUI, MaterialUI, MantineUI
Data Providers: Supabase, Appwrite, Any REST API, Any GraphQL API, Hasura, Firebase, etc..
Frameworks: Next.js, Remix
Live Providers: Ably

You can checkout all the integrations they support right here

Setting Up Requirements for Refine

Refine Requires:

Node 16.x
NPM 8.x

You can download Node.js from https://nodejs.org/en/

Conclusion

This ends this blog right here!

In the next blog of the refine series, We will be creating a app with refine using a UI Framework

Lastly, Don't forget to Leave a LIKE and key in your feedback in the comments!

Discovering Cache Channels!

Hridya — Mon, 31 Oct 2022 13:28:25 +0000

Introduction

In this blog we are going to explore pusher channels new feature: Cache Channels!

Cache Channels

A Cache Channel:

Store Realtime Data Values
Remembers the last triggered event and sends it as the first event to new subscribers
Provides a convenient way of working with changing data.

With the new addition of cache channels, you can now use Pusher Channels as a Realtime key-value store!

Currently Pusher channels are used for 2 things:

Event streams: representing instantaneous events, e.g., a channel mouse-clicks.
Variables: represents a varying value, e.g., channels like btc-usd, car-12 or gamestate-1.

The Problem with Existing Pusher Channels

Many Pusher users are running applications with very high frequency updates, e.g., Live Location Tracking, Gaming.

In these cases, Developers only care about the latest value of a datapoint which is served so frequently that any cached event would be out of date almost as soon as it was written.

Channels model event streams very well but channels could be difficult for representing variables.

Changes to the value would be broadcast over the channels as they occur, but without implementing some complicated config & code in your backend to fetch initial state, clients subscribing to channels with variable frequency updates and stuff like that. A sports app displaying live match scores would have to wait for a long amount of time to understand the current value.

A new user joining a sports app to follow up on a football match would not want to wait for a new goal to know what the current score was.

So previously, this initial state would have to be served up in the page itself, or the latest value would need to be requested by the client.

This results in three difficulties:

Unwanted server requests
Higher time-to-first-event
Application complexity

How do cache channels solve this problem?

With cache channels, you can avoid the “fetch initial state” workaround and reduce some of the overhead in accommodating variable frequency updates on “normal” Pusher channels.

This simplifies things notably and users working with variable values should be able to write less code with cache channels.

Difference from the existing Pusher Channels:

Fewer server requests
No more missed updates due to network reconnect
Lower initial latency

Conclusion

Cache channels has made life easier for people who were using variables with the existing pusher channels!

Lastly, Don't forget to leave a LIKE and key in your feedback in the comments

Predicting Water Purity using MindsDB

Hridya — Sun, 30 Oct 2022 12:46:08 +0000

Introduction

If you don't know what MindsDB is, Go checkout my blog to know more

Basically, MindsDB is an Open-Source AI Layer for existing Databases.

It's an AI Layer for traditional databases such as PostgreSQL, MariaDB, MySQL, etc..

In this tutorial, We are going to be predicting the purity of water based on several parameters by a dataset found in kaggle!

Importing Data into MindsDB Cloud

In order to import the dataset to MindsDB Cloud, we need to first download it from Kaggle and then upload it simply to MindsDB using the steps mentioned below.

Step 1: Create a MindsDB Cloud Account, If you already haven't done so

Step 2: Download this Dataset

Step 3: Go into Add Data -> Files -> Import File
Lastly Add the dataset (After downloading you will get a .zip file, You have to extract it and import the csv inside)

Step 4: Name the Table: WaterPU (You can name it anything you like!)

Step 5: To verify the dataset has successfully imported in:

Go into the Editor Tab and run this command:

SHOW TABLES FROM files;

If you see WaterPU or whatever you named it that means it's successfully imported!

Training a Model

MindsDB provides very simple SQL queries to carry out different tasks in its interface. So, we will now proceed with the steps below to get ready with the model.

Step 1: Create a Model, we will be creating a Predictor Model.
For that MindsDB provides a syntax:

CREATE PREDICTOR mindsdb.predictor_name       (Your Predictor Name)
FROM database_name                            (Your Database Name)
(SELECT columns FROM table_name LIMIT 10000)  (Your Table Name)
PREDICT target_parameter;                     (Your Target Parameter)

Simply replace the paramaters with the ones you want to use

The Actual query for me, looks like this:

CREATE PREDICTOR mindsdb.water_purity
FROM files 
(SELECT * FROM WaterPU LIMIT 10000)
PREDICT Potability;

NOTE: We are predicting Potability as that's in the dataset, if you write anything else, e.g. Purity, Quality

You won't be able to Predict the Purity!

Step 2: Based on the size of the dataset, it might take some time.

There's 3 stages once you run the command to create the model:

Generating: The model's generating!
Training: Model is getting trained with the dataset
Complete: The model is ready to do predictions

To check the status, this is the syntax:

SELECT status
FROM mindsdb.predictors
WHERE name='Name_of_the_Predictor';

The Actual Query looks something like this:

SELECT status
FROM mindsdb.predictors
WHERE name='water_purity';

Once it returns complete we can start predicting with it!

Describe the Model

Before we proceed to the final part of predicting the water quality, let us first understand the model that we just trained.

MindsDB provides the following 3 types of descriptions for the model using the DESCRIBE statement.

By Features
By Model
By Model Ensemble

By Features

DESCRIBE mindsdb.predictor_model_name.features;

This query shows the role of each column for the predictor model along with the type of encoders used on the columns while training.

By Model

DESCRIBE mindsdb.predictor_model_name.model;

By Model Ensemble

DESCRIBE mindsdb.predictor_model_name.ensemble;

This query gives back a JSON output that contains the different parameters that helped to choose the best candidate model for the Predictor Model.

As we are done now understanding our Predictor model, let's move on to prediciting values in the next section.

Predicting the Target Value

Predicitng the water Purity/Quality/Potability is as easy as running a simple SELECT statement using the Predictor.

As water purity depends on many feature parameters, It is preferred to enter all the parameters, However we can go forward by passing a few of them

The syntax for the query will be something like this:

SELECT target_value_name, target_value_confidence, target_value_confidence
FROM mindsdb.predictor_name
WHERE feature1=value1 AND feature2=value 2,...;

Now, replacing the variables in the above query, the actual query will be like this.

SELECT Potability,Potability_confidence,Potability_explain
FROM mindsdb.water_purity
WHERE ph=2.6 AND Hardness=210 AND Solids=18645.233 AND Chloramines=6.546;

As the predicted Purity is 0, this water is not safe for human consumption.

We will now pass all the required feature parameters to obtain a more accurate prediction of the water quality. So, the query now becomes something like this.

SELECT Potability,Potability_confidence,Potability_explain
FROM mindsdb.water_purity
WHERE ph=6.9 AND Hardness=201 
AND Solids=11350.675 AND Chloramines=4.3 AND Sulfate=NULL 
AND Conductivity=467.5 AND Organic_carbon=9.98 AND Trihalomethanes=89.686 AND Turbidity=4.99;

As the predicted Purity is 1, this water is safe for human consumption.

Fantastic! We have now successfully predicted the water quality using a Predictor.

target_parameter: This returns the value we want to predict.
target_parameter_confidence: This returns how confident the model is about the Prediction.
target_parameter_explain: This returns all the details about the predicted target_value.

Conclusion

Lastly, before you leave, I would love to know your feedback in the Comments section below and would be really motivated if you drop a LIKE on this article.

Quickstart to Amplication

Hridya — Sun, 23 Oct 2022 18:33:38 +0000

Introduction to Amplication

Have you ever wanted to not have to repeatedly code Node.js Backends?
Did you want a Low-code Platform to do that?
Well, Amplication does exactly that!

Instantly Generate:

GraphQL APIs,
Microservices,
REST APIs,
Authentication,
Authorization,
Admin UI

Amplication is a flexible open-source Node.js app development platform. It helps you build production-ready Node.js backend without wasting time on repetitive coding.

Setting Up Amplication

Requirements:

Docker
Node.js
NPM
Github Account

Select these configurations for your starter Project

Order management is a sample app by Amplication that contains some entities on creation.

Once you create your service you should see this:

Amplication uses some popular technologies as you can see

Next click the amplication logo to get directed to the home page.

So there's 4 components Workspace, Project, Service, Message Broker

Service is basically what you created so you can create that multiple times in a project

You can create a project to store multiple services

Now, we need to link a github repo to our project so we go into Project Settings -> Github and Authorize your github account, nextly link it!
(Note: Do not keep the repo empty)

After that, Let's merge our starter service into the Github repo,
In the right side of your screen, Press the commit changes button, A PR should generate in your repo!

Approve the PR, and the service should be in your github repo! There will be 2 folders: server & admin-ui

You can then download the github repo, and you can follow the README.md in the server to set it up!

Video Version: https://www.youtube.com/watch?v=VCU1hOnSA6k

Conclusion

Amplication helps you create Node.js backends really easily

Lastly, before you leave, don't forget to key in your feedback in the Comments section below and show some love by dropping a LIKE on this article.

Quickstart to MindsDB

Hridya — Sat, 22 Oct 2022 19:54:53 +0000

Introduction to MindsDB

MindsDB, brings machine learning capabilities to traditional databases. It acts as an AI layer on top of the existing tables and enables to train models and predict outcomes easily and instantly with the help of simple SQL statements.

MindsDB connects with the most popular DB Clients, BI Tools, Data Sources making it really easy for clients to use. You can use MindsDB locally (Docker, pip) or use MindsDB Cloud which provides a 30-day free trial.

As you can see MindsDB integrates with a lot of tools & DBs, there are still more that I couldn't fit in the image

If you want to check out their official website for the connections they support, Click here

MindsDB Cloud Account

Now, let's create a MindsDB Cloud Account

Go to https://cloud.mindsdb.com/ and enter your details and voila! You have a MindsDB Cloud Account, Now you can train ML Models, Predict a lot of things!

The Editor is where you write your SQL Queries

The Add Data Tab allows you to add data from a lot of popular data sources, and you can import your own by websites like Kaggle

Conclusion

MindsDB is an Open-source AI Layer for traditional databases (MySQL, PostgreSQL, MariaDB, etc...)

Lastly, before you leave, don't forget to key in your feedback in the Comments section below and show some love by dropping a LIKE on this article.