DEV Community: Smit

[Boost]

Smit — Thu, 23 Oct 2025 13:58:36 +0000

Understanding SQL CTEs: A Simple Approach

Smit ・ Jun 28

#programming #sql #beginners #computerscience

CTEs Explained Simply

Smit — Sat, 28 Jun 2025 16:05:24 +0000

Smit

Jun 28 '25

Understanding SQL CTEs: A Simple Approach

#programming #sql #beginners #computerscience

Comments 1

2 min read

Understanding SQL CTEs: A Simple Approach

Smit — Sat, 28 Jun 2025 16:04:39 +0000

A CTE is a common table expression in SQL. It is essentially a temporary result set or output that can be referenced later within other queries. It is extremely useful for managing complex queries and making them more optimized and readable.

1. Basic Syntax

With cte_name AS (
   select col1, col2
   from table a
   where condition
)

SELECT * FROM cte_name

2. Why Use CTEs

Easy to understand: Long queries can be broken down into simpler, smaller logical pieces and more manageable problems.
Can be reused: Once a CTE is created with an alias, it can be referenced multiple times within the SQL query. This makes the code more optimized, reusable, and avoids rewriting logic.
Multiple use cases: CTEs can be used to create multiple definitions together, including advanced tasks like recursive CTEs.

3. Real-World Use Cases:

CREATE TABLE employees(
    id INT,
    name VARCHAR(40),
    salary INT
);

INSERT INTO employees (id, name, salary) VALUES
(1, 'ALICE', 5000),
(2, 'Ben', 5000),
(3, 'Raj', 2000);

WITH salary_calculations AS (
    SELECT AVG(salary) AS avg_salary
    FROM employees
)

SELECT e.name, e.salary
FROM employees e, salary_calculations s
WHERE e.salary > s.avg_salary;

Output is below

JDoodle is an amazing online tool for trying out SQL code online and makes it easy to test with different SQL versions. Try it below:
jdoodle

Explanation:

We start by creating the table and inserting values into it.
Next, we define the CTE with the average salary.
Finally, we select the employees whose salary is above that average.

Conclusion:

Common Table Expressions are powerful and flexible tools in SQL and should be used carefully and wisely. It's important to break down long, complex logic into smaller parts and use CTEs effectively to make the code easier to read and debug

Essential SQL Query Concepts for Beginners

Smit — Sun, 22 Jun 2025 20:23:53 +0000

Smit

May 16 '25

5 SQL Queries Everyone Should Know

#sql #database #beginners #tutorial

Comments 1

2 min read

Confused about Random Forest algorithm? Learn it in this easy guide!

Smit — Sat, 21 Jun 2025 19:27:04 +0000

Smit

May 26 '25

Random Forest Explained

#ai #machinelearning #python #beginners

Comments 1

5 min read

Struggling with lambda functions? Learn them in 3 easy steps.

Smit — Sat, 21 Jun 2025 19:24:05 +0000

Smit

Jun 6 '25

Python Lambda Functions Explained in 3 Easy Steps

#programming #python #beginners #tutorial

Comments 2

1 min read

Python Lambda Functions Explained in 3 Easy Steps

Smit — Fri, 06 Jun 2025 02:08:26 +0000

Step 1: What is it ?

Think of a lambda as a small, one line function.
It's a quick and simple solution for small tasks, rather than using traditional functions defined with def.

Step 2: How does the function look?
Lambda x : x+2
This simple (and slightly different looking line) just means: "a function takes x and then returns x+2". That’s it!

Example:

add_two = lambda x : x+2
print(add_two(5)) #output: 7

Explanation: We create a lambda function that takes a number x and adds 2 to it. We pass 5 as value and it returns 7.

Step 3: When to use a lambda function ?

It's very useful for quick, simple tasks like sorting, mapping, or filtering instead of writing a full function.

That’s it! A lambda function is just a short, fast function for simple jobs. And guess what? It’s called an anonymous function because it doesn’t have a name!

As promised, just 3 steps. Happy learning and happy coding!🎉💻

Random Forest Explained

Smit — Mon, 26 May 2025 15:27:27 +0000

Introduction

In the vast forest of machine learning models, Random Forest stands out. But what’s the big deal? And seriously, what’s with that name? Did someone go hiking, see some trees 🌳, and think, “Yep, this is definitely an algorithm”? Probably not.

🔍Let’s explore why Random Forest is such a powerful and widely used algorithm and where the name actually comes from.

What is random forest algorithm ?

• A simplified way to understand Random Forest is this: imagine you're making a big decision, like choosing which college to attend. Instead of asking just one person for advice, you ask 100 random people. Each gives their opinion, and you go with the majority vote. That, in essence, is how Random Forest works.

• Random Forest builds a collection (or forest) of decision trees. Each tree is trained on a different subset of the data, with slight variations this process is known as bootstrapping. Every tree learns something a little different due to these variations.

• Each tree then makes its own prediction, and the forest combines all these predictions taking a majority vote (for classification) or averaging (for regression) to produce the final output.

• Now, each tree is different because it's trained on a different subset of data. Each tree sees different features and samples.

• At every decision point (called a split), each tree only looks at a random subset of features, not all of them. This *randomness * ensures that trees are diverse and less correlated.

• Finally, once all trees have voted, Random Forest aggregates those votes to make a robust final prediction.

Photo reference: https://builtin.com/data-science/random-forest-python

Key Equations for Random Forest:

1.🌳 Random forest equation (classification)

so h_i (x) is prediction from i-th decision tree
ŷ is final predicted class after coming to decision of most common vote among all the trees.

2.📊 Regression equation (numerical)

ŷ is the average prediction across all trees and T is total number of trees.
Each h_i(x) is a numerical prediction from the i-th decision tree

The image and equations illustrate how the Random Forest algorithm works by making predictions from individual trees, then selecting the majority vote (for classification) or averaging the outputs (for regression) to make a final decision.

Why is it so famous ?

Random forest is so famous for a few reasons:

🛡️ Resistant to overfitting

Single decision trees often perform well on training data, but their performance tends to drop when faced with new, unseen data.
Random Forest solves this problem by averaging the predictions of multiple trees, which helps smooth out noise and leads to more balanced and robust predictions.

2.🧪 Works well without any fine tuning:

Many machine learning algorithms require extensive fine-tuning to perform well. However, Random Forest performs strongly even with its default settings, without much need for parameter tuning.
This makes it a popular choice among beginners who need quick and accurate results.
Works with all kinds of data:
📊 Numerical data
🧩 Data with lots of features
❓ Missing values
🏷️ Categorical data

3.Features (🌳) matters:

Most importantly, Random Forest identifies which features matter and which don’t.
This helps us better understand the model by providing insights into the variables that influence predictions.
It makes it easier to explain results to non-technical people.
It also allows for easy modification of which variables to include or exclude in future models.

Random Forest in action ?

Now that we know why Random Forest is so famous and how it got its name, let’s see it in action with a simple code snippet.
Imagine we want to build a model to predict whether someone will be approved for a house loan by a bank. Features include Income, Credit Score, Employment Status, Loan Amount, Interest Rate, and previous credit card history.
Training a single large decision tree often leads to overfitting. What makes Random Forest unique is that it creates many smaller decision trees, each looking at different parts of the data.

Python Code snippet:

# Sample dataset that simulates loan applications
X, y = make_classification(
    n_samples=2000,        # 2,000 loan applicants
    n_features=5,          # 5 features: credit score, income, etc.
    n_informative=3,       # only 3 features really affect the outcome
    n_redundant=0,
    random_state=0,
    shuffle=False)

# Create a Random Forest model with small trees
clf = RandomForestClassifier(max_depth=2,random_state=0)

# Training the model
clf.fit(X,y)

# Predict loan approval for a new applicant
print(clf.predict([[0, 0, 0, 0]]))  # Output: [1] (Approved)

Reference: scikit-learn RandomForestClassifier documentation

Steps that algorithm follows:

So, what Random Forest does is it randomly picks samples of people from the list of loan applicants.
Then, it builds a decision tree on each sample.
This process is repeated many times to create multiple decision trees.
When it’s time to decide whether to approve a loan for a person, each tree makes its own decision: “Yes” or “No.”
The Random Forest algorithm collects all the votes from the trees and chooses the majority vote. If most trees say “Yes,” the loan is approved; otherwise, it is denied.

That’s it in simple terms, these are the steps the Random Forest algorithm follows.

Pro’s and Con’s of random forest algorithm.

Pro’s

The best part of the Random Forest algorithm is that it smooths out noise and creates balance in decision-making by considering the majority vote.
If one tree makes a mistake, the other trees have a chance to correct it by covering different edge cases.
Each tree is trained on different data, which makes the overall model more accurate.
It also identifies which features matter to the model and which don’t. This is very important for fine-tuning the model for future use cases.

Con’s

Slow process: Having many trees making individual decisions slows down the overall process, which is not ideal for real-time systems.
Difficult to explain: Random Forest is harder to interpret compared to simpler models like single decision trees or linear regression.
High memory usage: It can consume a lot of memory since it depends on the number of trees, each trained on different data subsets, making it computationally expensive.
Struggles with sparse data: Random Forest does not perform well on high dimensional, sparse data such as in text classification tasks.

Real life impact:

The best thing about the Random Forest algorithm is its impact on many real-world decisions. Here are some of the top real-life use cases:

🏦 Finance: Used to approve loans by identifying risky applicants without bias.
🧬 Healthcare: Widely used to diagnose diseases like cancer and diabetes, predict outcomes, and identify key risk factors.
🛒 Retail: Helps analyze customer behavior and make recommendations—such as predicting when a customer will buy next or when they might stop shopping.
🚗 Transportation: Predicts delays, forecasts demand fluctuations, and helps improve service and convenience for customers.

It’s fascinating how such a straightforward algorithm can have a profound impact across industries, enhancing our daily lives and positively contributing to society.

Follow along as I continue to explore and explain the fascinating world of AI and machine learning in simple terms.

5 SQL Queries Everyone Should Know

Smit — Fri, 16 May 2025 01:08:24 +0000

SQL queries are an important tool for retrieving data from databases and are widely used in the field of computer science. SQL stands for Structured Query Language, and many tools can be used to run SQL queries, such as PyCharm and Anaconda Spyder. Below are five essential SQL query concepts that everyone should know.

1. WHERE

Usage: retrieve specific types of data from a table based on filters.

SELECT emp_name FROM company WHERE department = 'Finance';

Note: Filters are always important, as without them, the data can be overwhelming and may include a lot of unnecessary information.

2. GROUP BY

Usage: It is widely used for summarizing data and can be combined with aggregate functions.

SELECT department, count(*) AS emp_count FROM employees_table GROUP BY department;

Note: Aggregation is useful for identifying patterns and uncovering hidden trends in the data.

3. JOINS

Usage: Joins are used to combine rows from different tables based on a key column, and data is retrieved according to specific conditions. There are different types of joins, with the most used being the inner join.

SELECT orders.order_id, customers.customer_name FROM orders_table a INNER JOIN customers_table b ON a.customer_id = b.customer_id;

Note: See the image below for more information on all types of joins, along with a Venn diagram that visually explains them.

Diagram reference: https://dsin.wordpress.com/2013/03/16/sql-join-cheat-sheet/

4. Window Functions:

Usage: This is widely used when performing calculations across multiple rows in a table that are related to the current row.

SELECT employee_id, salary, RANK() OVER (ORDER BY salary asc) AS salary_rank FROM employees_table;

Note: Window functions are extremely useful for building advanced reports that require complex analytics, such as ranking, row numbering, and moving averages.

5. Subqueries:

Usage: Subqueries are widely used to incorporate the result of one query within another query.

SELECT first_name, last_name FROM employees_table WHERE salary > ( SELECT AVG(salary) FROM employees_table);

Note: Subqueries are useful for creating advanced and dynamic logic that normal queries can’t achieve, and they can sometimes help optimize query performance.

Well, this was fun to write! If you found this helpful, please clap, share, or follow for more data tips. Let me know in the comments what you think, and if anyone has questions or would like me to cover more advanced queries. Happy querying!

Why Llama AI is Popular

Smit — Sun, 27 Oct 2024 21:06:11 +0000

Meta's Llama model is an open-source AI model. It is appreciated by everyone in the industry for being open-source, while so many famous AI models are closed. "The model's open-source nature allows anyone to contribute to it, fine-tune it, and use it for tasks like summarizing, text generation, and much more. So, let’s dive into what makes the Llama model so special!"

Key Sections:

1. Introduction to Llama model
2. Core features
3. How to use the Llama model?
4. Alternative AI models
5. Challenges
6. Conclusion & Final Thoughts

1. Introduction

The Llama model is an open-source AI model developed by Meta. Since it is open-source, anyone can use, train, and deploy the model from anywhere in the world. There are different versions of the Llama models available, allowing users to choose from various sizes: 7B, 13B, 30B, and 65B. And just in case you're wondering, the "B" stands for "billion," so all the heavy lifting is done by these billions of parameters. Thanks to Meta for making this possible!

2. Core Features

Efficiency: The Llama model is efficient in processing large datasets and can handle complex tasks.
Different Model sizes: Users can choose from models like 7B and 13B parameters, depending on their usage and computational resources. Each model has its pros and cons.
*Open-source *: Llama is open-source, meaning anyone can contribute to and improve the models, which allows for rapid enhancements and support from large communities.
Multi-language Processing: The Llama AI model supports many languages including German, English, French, Hindi, and many more. It's a powerful tool and can be used for translation. For example, it can translate English to Spanish using a meta-AI model available online.

MultiModal Processing: The Llama AI model can also handle various types of media like text, and images allowing it to work with different media formats.
*Fine-Tuning *: The Llama model can be fine-tuned and trained on specific datasets for particular industries, such as healthcare or education, making the AI model more specialized and accurate.

3. How to use the Llama model?

For developers and programmers, using the Llama model is straightforward through the Hugging Face website. To obtain the model, one needs to select the type of model on Hugging Face, submit the required information, and receive approval within a few days.

Always remember to use the model responsibly and safely. Here’s the link for obtaining the models: Getting the models.

Below is a code snippet from the Hugging Face website showing how to use the model. For more reference, see this link: Code snippet

For someone who wants to use the model directly instead of setting it up, you can go to https://www.meta.ai/. Let's figure out what AI thinks is the meaning of life. Haven't we always wondered about that?

We can also generate a remix of a response by changing the settings. How about considering it from a Stoicism perspective? That's so cool!

and we can always go back to the previous version of the conversation.

4. Alternative AI models

GPT: Created and trained by OpenAI. , this is a closed-source AI model that can be accessed from their website. ChatGPT
Claude Sonnet: Developed by Anthropic AI, backed by Amazon. Check out the link to explore their AI model. Claude

5. Challenges

Computational Requirements: The computational power required for some types of Llama models is significant.
Content Bias: There is a possibility of content bias, which depends on the data on which it is trained.
Energy costs: The Llama model requires a substantial amount of energy for training and running, leading to a significant environmental impact. However, efficiency improvements may occur in the future.
Security and Misuse: There can be security risks, as the text generated by these models can sometimes be harmful and affect individuals. Therefore, careful review and additional safety measures or safeguards are required.

6. Conclusion & Final Thoughts

We learned today about what the Llama model is, why it is famous, and what makes it so powerful as an open-source AI model that anyone can easily train, deploy, and use. AI models are powerful yet often act as black boxes, sometimes generating outputs that can hallucinate (when the model produces inaccurate information).

If used carefully for specific use cases, AI models can be incredibly useful and can solve many problems across various industries. This post was written by me with the assistance of AI, the amazing documentation from Hugging Face, and the documentation page from Meta.ai.

And it's a wrap! I had a lot of fun writing this post. This is my first post here, and I’m eager to receive any feedback or suggestions you all might have. Share your ideas in the comments below!