Forem: Swapnoneel Saha

Designing Machine Learning Workflows in Python

Swapnoneel Saha — Tue, 12 Mar 2024 15:09:29 +0000

Introduction

In our recent AI-revolutionized world, to design proper machine learning workflows is important for getting insights, making predictions, and also solving complex problems. Python, with its vast collection of libraries and frameworks, is the go-to language for developing machine learning models and workflows. So, that's why, understanding the steps involved in designing machine learning workflows in Python is essential to progress in this field.

In this article, we will explore the fundamental steps and considerations that go into building efficient and robust machine learning pipelines. We will cover all the essential aspects that is needed using some of the extensive support from libraries such as NumPy, Pandas, Scikit-Learn, TensorFlow, and PyTorch.

So, let's dive in and discover the key components of designing machine learning workflows in Python. By the end of this article, you'll have a solid foundation to tackle real-world machine learning challenges and unleash the power of Python in your data-driven endeavors.

What's the process?

To design a machine learning workflow, we have to perform and maintain some specific steps which are crucial. They are stated below:

Data Preparation

It is a crucial step in designing machine learning workflows. It involves ensuring that the data is in a suitable format and quality for the subsequent stages of the workflow.

# Import necessary libraries
import numpy as np
import pandas as pd

# Load and explore the dataset
dataset = pd.read_csv('data.csv')
print(dataset.head())

# Handle missing data and outliers
dataset = dataset.dropna()
dataset = dataset[dataset['column'] < threshold]

# Preprocess the data
X = dataset.drop('target', axis=1)
y = dataset['target']

# Split the data into training and testing sets
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

Feature Engineering

It is the next step that comes after Data Preparation. It involves transforming raw data into a format that can effectively represent the underlying patterns and relationships in them.

# Extract relevant features from the data
# Feature extraction techniques like PCA, LDA, etc.

# Perform dimensionality reduction
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
X_train_pca = pca.fit_transform(X_train)
X_test_pca = pca.transform(X_test)

Model Selection

The model selection section involves choosing an appropriate algorithm or model architecture that best fits the problem at hand. It includes tasks such as determining the type of problem selecting the appropriate model class (e.g., decision trees, neural networks, support vector machines), and tuning hyperparameters to optimize model performance.

# Import necessary libraries
from sklearn.model_selection import cross_val_score
from sklearn.metrics import accuracy_score, precision_score, recall_score

# Choose appropriate models based on the problem
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier

# Split data into input features (X) and target variable (y)
X = X_train_pca
y = y_train

# Define evaluation metrics for model selection
scoring = 'accuracy'

# Train and evaluate models using cross-validation
model_lr = LogisticRegression()
scores_lr = cross_val_score(model_lr, X, y, cv=5, scoring=scoring)
model_rf = RandomForestClassifier()
scores_rf = cross_val_score(model_rf, X, y, cv=5, scoring=scoring)

# Select the best-performing model based on evaluation metrics
best_model = model_rf if np.mean(scores_rf) > np.mean(scores_lr) else model_lr

Model Training and Evaluation

The model training process involves feeding the input data and corresponding labels into the model, adjusting the model's internal parameters iteratively using optimization techniques (e.g., gradient descent), and updating the parameters to minimize the specified loss function. Evaluation metrics such as accuracy, precision, recall, or mean squared error are calculated to quantify the model's predictive performance.

# Train the selected model on the training set
best_model.fit(X_train_pca, y_train)

# Evaluate the model using test set
y_pred = best_model.predict(X_test_pca)

# Calculate evaluation metrics
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)

Model Deployment

The Model Deployment section involves making the trained machine learning model available for use in real-world applications. This process includes preparing the model for deployment, such as converting it into a deployable format or packaging it into a containerized environment.

# Save the trained model to a file
import joblib
joblib.dump(best_model, 'model.pkl')

Now, with all these covered, it may seem overwhelming to you, so let’s check some examples to solidify your concepts.

Examples

Machine Learning workflow for Image Classification using the Fashion MNIST dataset

Here's an example of a machine learning workflow for image classification using the Fashion MNIST dataset. The workflow includes data loading, preprocessing, model selection, training, evaluation, and saving the trained model. Let’s check the code sample, how we are doing that-

# Import necessary libraries
import tensorflow as tf
from tensorflow import keras
import numpy as np

# Load the Fashion MNIST dataset
fashion_mnist = keras.datasets.fashion_mnist
(X_train, y_train), (X_test, y_test) = fashion_mnist.load_data()

# Preprocess the data
X_train = X_train / 255.0
X_test = X_test / 255.0

# Model Selection
model = keras.models.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])

# Model Training
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(X_train, y_train, epochs=10)

# Model Evaluation
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print(f"Test Loss: {test_loss}")
print(f"Test Accuracy: {test_accuracy}")

# Save the trained model
model.save("fashion_mnist_model.h5")

Now, let’s see how the workflow works:

We import the necessary libraries, including TensorFlow and Keras, which provide high-level APIs for building and training deep learning models.
The Fashion MNIST dataset is loaded using the keras.datasets.fashion_mnist module and is split into training and testing sets, and the images and labels are stored in variables X_train, y_train, X_test, and y_test, respectively.
Pre-processing the data: The pixel values of the images are scaled to a range of 0 to 1 by dividing them by 255. This normalization step ensures that the input data is in a suitable range for the model.
Model Selection: We create a sequential model using keras.models.Sequential(). In this example, we use a simple architecture with a flattening layer, a dense layer with 128 units and ReLU activation, and a dense output layer with 10 units (corresponding to the number of classes in the dataset) and softmax activation.
Model Training: We compile the model using model.compile() with the Adam optimizer, sparse categorical cross-entropy loss function, and accuracy as the evaluation metric. The model is trained using model.fit() with the training data (X_train and y_train) for a specified number of epochs.
Model Evaluation: We evaluate the trained model on the test set using model.evaluate(). The test loss and accuracy are calculated and printed.

Saving the trained model: We save the trained model to a file using model.save.

Machine Learning workflow for Sentiment Analysis using the IMDb movie review dataset

Let’s get into the example of a machine learning workflow for sentiment analysis using the IMDb movie review dataset. The workflow includes data preparation, feature engineering, model selection, training, evaluation, and deployment. Let’s dive into the code and check how we are doing that-

# Import necessary libraries
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
import joblib

# Load the IMDb movie review dataset
df = pd.read_csv('imdb_reviews.csv')

# Data Preparation
X = df['review']
y = df['sentiment']

# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Feature Engineering
vectorizer = TfidfVectorizer()
X_train_vectors = vectorizer.fit_transform(X_train)
X_test_vectors = vectorizer.transform(X_test)

# Model Selection
model = LogisticRegression(max_iter=100000)

# Model Training
model.fit(X_train_vectors, y_train)

# Model Evaluation
y_pred = model.predict(X_test_vectors)
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy}")

# Model Deployment
joblib.dump(model, 'sentiment_analysis_model.pkl')
joblib.dump(vectorizer, 'vectorizer.pkl')

Now, let’s see how the workflow works:

We start by importing the necessary libraries, including Pandas for data manipulation, scikit-learn for machine learning functionality, and joblib for model serialization.
The IMDb movie review dataset is loaded using pd.read_csv() into a Pandas DataFrame called df. The dataset contains two columns: "review" (textual movie reviews) and "sentiment" (positive or negative sentiment).
Data Preparation: We assign the "review" column to X and the "sentiment" column to Y, which prepares the data for training and testing.
Splitting the data: The train_test_split() function is used to split the data into training and testing sets. We assign 80% of the data to training and 20% to testing. The random_state parameter ensures reproducibility of the split.
Feature Engineering: We use the TfidfVectorizer from scikit-learn to convert the textual reviews into numerical features. The fit_transform() function is applied to the training set (X_train), and the transform() function is applied to the testing set (X_test), as you can clearly see in the code.
Model Selection: We choose a logistic regression model for sentiment analysis. In this example, we use scikit-learn's LogisticRegression() class.
Model Training: We fit the logistic regression model to the training data using model.fit() with the training vectors (X_train_vectors) and corresponding labels (y_train).
Model Evaluation: We make predictions on the testing set using model.predict() with the testing vectors (X_test_vectors). The accuracy is calculated by comparing the predicted labels (y_pred) with the actual labels (y_test).
Model Deployment: And finally, we save the trained model and vectorizer using joblib.dump() for future use and deployment.

Conclusion

Thank you for reading the blog! I hope you found it informative and valuable. For more information, follow me on Twitter (swapnoneel123) where I share more such content through my tweets and threads. And, please consider sharing it with others on Twitter and tag me in your post so I can see it too. You can also check my GitHub (Swpn0neel) to see my projects.

I wish you a great day ahead and till then keep learning and keep exploring!!

The 3 Most Powerful Functions in JavaScript

Swapnoneel Saha — Sun, 10 Mar 2024 17:53:37 +0000

Introduction

The map(), filter() and the reduce() are the most powerful and important higher order functions in JavaScript that generally operates on arrays. Being the part of the functional programming paradigm of JavaScript, these functions allow us to write cleaner and concise code.

To master JavaScript, it's a necessity to master them, as you'll be using them almost everywhere while building projects; even if you are using React!!

So let's not waste any more time, and learn these functions quickly!!

The `map()` function

Naively speaking, the map() function converts a group of data into another group of data based on some specific conditions. The conditions are defined through the provided callback function. For example, we are taking an array of numbers and converting it to another array where each element from the former array is squared and put in the latter array. Here, we are performing the squaring function.

Syntax

Arrays.map((element, index, array) => { ... })

The map function can take three arguments, but in general we'll be using the element value only in most of the cases!!

Now, let's check with an example, how we can use this in our code!!

Example

const nums = [1, 2, 3, 4, 5];

const squaredNums = nums.map((num) => (num * num));

console.log(squaredNums);

The `filter()` function

As the name clearly suggests, the filter() function is used to extract certain amounts data from a given set of data, based on a specific condition. For example, we have an array of numbers and we want to extract only the positive numbers from that array; we'll be able to do it easily using the filter() function.

Syntax

Array.filter((element, index, array) => { ... } )

Just like the map() function, the filter() function also takes the same types of three arguments, but here the return type of the callback function should be boolean. The filter() function returns an array containing the elements for which the callback function returns true.

Example

const nums = [1, -2, 3, 4, 5, -6, -7];

const positiveNums = nums.filter((num) => num > 0);

console.log(positiveNums);

The `reduce()` function

To explain it simply, the reduce() function reduces/converts all the values of an array into a single value. It iterates through all the elements and calculates the result based on the given condition. It takes a callback function and an initial value as arguments. The callback function receives an accumulator and the current element, and it returns the updated value of the accumulator for the next iteration.

Syntax

reduce((accumulator, currentValue, index, array) => { ... }, initialValue)

Now, the syntax may look a bit too complex to you, but no worries, we will understand this better using the help of the example!!

Example

Let's consider that we want to find the product of all the elements in an array. So what the reduce() function will do is, take the initialValue (here, it is 1) as the accumulator and will iterate over each and every elements in the array, and will perform the operations as defined by the callback function. And, once all the values has been traversed, it will return the final value of the accumulator.

const nums = [1, 2, 3, 4, 5];

const product = nums.reduce(
(accumulator, currentValue) => accumulator * currentValue, 
1);

console.log(product);

Conclusion

Well, that's a wrap for now!! Hope you folks have enriched yourself today with lots of known or unknown concepts. I wish you a great day ahead and till then keep learning and keep exploring!!

Also, if you want to connect with me, check out my Twitter/X profile, where I regularly post Tech contents: https://x.com/swapnoneel123

My First year in Tech

Swapnoneel Saha — Tue, 05 Mar 2024 07:35:50 +0000

Just over an year back from now, I got into University for my Bachelor's degree in Computer Science and Engineering. And it was then, I actually got introduced to the Tech world. Previously, I had some coding experience in both Java & Python and had a proper knowledge of MySQL.

In this one year, I have learned and experienced quite a few things. So, I thought it would be the perfect time to document my journey with the timelines and also share some of my plans for the next year. This may help the beginners in starting their journey and will definitely motivate me for my upcoming journey. So let's begin…

The Journey

October, 2022

As this was my first month of college, I focused on my academics a bit and attended classes regularly. Besides that, as I had a bit of coding knowledge, I decided to start learning Web Development. I followed the free course from Code with Harry, which is available on YouTube.

And by the end of that month, I was mostly done with HTML. It didn't take me more than two weeks to learn it as it was extremely simple and beginner-friendly.

November, 2022

This was an interesting month for me, because it was when I got introduced to CSS, and the sheer amount of styling that I can do with it amazed me 🤩. I continued with Code with Harry and started creating some small projects including a form page for School admission, a basic site for a fictional shoe brand, etc.

December, 2022

I decided to enhance my skills in HTML and CSS more before moving on to JavaScript, so I took a course from Coursera, which was taught by Meta. Following that, I started and completed learning Bootstrap from there.

And the most interesting and a bit disappointing thing happened during this month:

The interesting thing is, that I got my first Tech freelancing gig, which consisted of building a few small projects using Bootstrap and the APIs provided by the client, for showcasing the service of their small start-up. And, it was a 15K rupees gig. Now, the disappointing part is, that I couldn't complete the gig because some part of it was extremely out of my league. But they paid me 8K rupees for the work I had done.

The most important thing I learned was that real-life development is all about googling, pasting codes from StackOverflow, and learning while doing so…

Took full advantage of my Winter vacation, to start learning some advanced concepts of Python and finally got started with JavaScript!!

January, 2023

This is that single month where I did a lot of "first-time" things and learned & got started with them.

Continued learning JavaScript from both Code with Harry and Coursera. And, I started building some small projects using my newly learned concepts from Python.

Now with the skills I have learned so far, I was thinking of putting them to the test by attending a Hackathon. So, I grabbed one of my classmates and a 2nd-year guy from another college. Our small team had a diverse skill set, and we decided to participate in "Treasure Hacks 3.0". Our project was "Lab for All" (Website link: https://labforall.vercel.app, GitHub link: https://github.com/Swpn0neel/treasure-hacks-labforall)

We planned to make a project on the Ed-Tech field and the idea was to create a platform where the users can get assistance, particularly in their lab assignments, from video lectures to notes, and viva questions to 3D simulations.

While working on the project, I got to know about how you have to make the site design before starting to code, and that attracted me a lot and planted the seed inside me to start designing in Figma, which I planned to learn in the near future.

Strangely enough, till now I haven't learned about Git and GitHub. But I had to grasp it now for the obvious reason of collaboration in my Hackathon project. And it was a significant bump in my Tech learning journey.

Also, while doing the project I had to learn Firebase as it was needed for data storing and user authentication, and it was my part to complete that job.

The best part is, we completed the project within the time limit and implemented all the planned features. And to our amazement, we won the Hackathon being the second runner-up.

Also, this month, I wrote my first blog at Hashnode on Python and also got active on Twitter (now X), and started posting content on both mediums.

February, 2023

Our first-semester final exam happened this month and was stretched over a period of 20 days. And later, when the results came out, I topped my batch with an SGPA of 9.33.

This month, I also focused on my blogging and wrote around 8-9 articles. Also, I started working on my personal portfolio website and completed it. It took just over two weeks to do that. Learned a bit of React and JavaScript while building my portfolio, and also worked on file handling and its modules in Python.

March, 2023

After a lot of grinding web development for some months, I decided to switch the gear a bit and decided to start doing DSA. Now for doing that, I rarely used any guide or video tutorials, but relied on solving more and more Leetcode problems (you can check my Leetcode profile, here) based on my previous knowledge of arrays, strings and recursion. By doing so, I solved just over 30 problems and approached around 100 problems in that venture.

Also, I started learning UI/UX design and gained a huge interest in that. Followed Jesse Showalter, Design Course and Payton Clerk on YouTube to get knowledge about designing. I used Figma for the design purpose!!

Besides these, I completed the "7 days, 7 blogs" challenge on Hashnode and mostly shared my Python knowledge there. And also, explored a lot of Python libraries mainly about text and image analysis.

April, 2023

Continued my DSA journey and solved over 20+ questions based on String Builder, Array List and Arrays.

Also, I decided to go for another Hackathon along with two of my classmates. It was one of the MLH hacks, called "Hack Around the World 2.0". Our project was "The Magnificent Seven" (Website link: https://magnificent-seven.vercel.app, GitHub link: https://github.com/Swpn0neel/TheMagnificentSeven)We decided to use Three.js, Svelte and Tailwind CSS for the project. That's why, I started learning Svelte and Tailwind CSS. Also, I created the Figma design of the site. This was a much smaller scale project than the previous one but cramped most of our technical skills into it. And again, to our amazement, we managed to be the Winner of this Hackathon.

May, 2023

Paused DSA for a bit, but started learning C as it was a part of my college curriculum.

Also, I delved more into designing and started mastering animations and transitions in CSS and decided to build some small-scale projects using that. In that venture, I created around 5-6 projects that focused mainly on uniqueness and smooth animations. Check them out here: https://github.com/Swpn0neel/Web-Development-Projects

And the most important thing that happened at the end of the month. Previously, I mentioned that I wrote a number of blogs regarding Python in the months of February and March. Now, they got noticed by Tutorials Point, and I got a part-time job offer from them, whose first contract was to deliver an advanced Python course for their platform. I accepted the offer and started working for them.

June, 2023

This was a really special month, because I only earned, earned and earned in this one. Aside from Tutorials Point, I got some really good freelancing offers too: I created the UI/UX Design and wrote SEO-optimized content for some medium-scale businesses. Delivered some copywriting and technical writing jobs.

Also, this was the month of our second-semester exam. I was extremely loose academically this semester and didn't have high hopes about scoring. But still, some fruitful one-nighters helped me to get an SGPA of 9.14.

July, 2023

Took the after-semester break to my advantage and again went for an earning streak with various freelancing job offers.

For some time I hadn't attended any hackathons, so in the middle of the month, our same team from MLH Hacks decided to attend our first offline hackathon and we chose Eastern India's largest Hackathon, Hack 4 Bengal 2.0 for that. Everything was going nicely there, but one of our teammates faced health issues, and that's why we had to return to our home before the Hackathon ended. It was a disappointing failure for us.

But for me personally, it was extremely fruitful from an earning standpoint.

August, 2023

The month started with me hosting an introductory session to Open-Source at my University for my fellow peers, along with two other folks from my batch. It was my first mentoring and public speaking session.

Also, an important thing that caught my eye was that, I haven't learned a lot of things personally (except Python, most of my Freelancing works were dependent on that and I learned a lot of Python libraries during that time), as I was majorly focusing on earning. Also, I haven't touched DSA for some months.

So, I again started Leetcoding at the end of this month. Previously, I had completed 50+ problems, I added 10+ to that number this month.

September, 2023

Rejected all Freelancing offers this month and went hard on Leetcoding. I solved more than 90 problems this month, ranging from Linked List and Prefix Sum to Siding Window and Recursion problems.

Also, I started preparing for the Smart India Hackathon '23. Involved two juniors in our team so that they can have their first Hackathon experience and learn along the way. As part of the national hackathon, we have to qualify for the internal Hackathon of our University, MAKATHON '23. We qualified with flying colors taking the first position in the Hackathon.

October, 2023

Decided to make some complex projects related to Web Development and prepared some web designs on Figma for the same, while learning a bit more about UI/UX Designing in general.

Started taking weekly mentorship sessions for my juniors, so that they could learn at a better pace and not get distracted while being focused on the ultimate goal of upskilling themselves.

Bonus

I have mentioned almost everything here. But I want to mention some things that weren't mentioned in the timeline.

Python and its vast library have always been with me throughout my learning journey and earned me the majority of my bucks through freelancing.
I was able to purchase an ASUS TUF A15 laptop all by myself through freelancing ventures, and also manage a lot of my personal expenses besides making a little bit of savings for myself.
Since January, I've been active on Twitter and made a family of over 500 folks.
College academics were never my priority and I tried to ignore it as much as possible and gave the least possible amount of time to it.
Although I started my journey with the help of video tutorials, as time passed I majorly relied on official documentation and blogs because of their simplicity and least time requirement.
Other than the mentioned stuff, I had to learn quite a few other things like API management, handling ML models, and many more for project requirements. It's impossible for me to mention all of them in a single blog 😅.

My plans for the Second year

So far, I have completed 170+ Leetcode problems, and my target moving forward is to cover all the DSA concepts in the 2nd year and at least reach the 600+ problems mark on Leetcode. Also, I'll start attending coding contests to put my skills to the test.

I will start delving into AI/ML and would like to get a solid grip on it by October 2024. Along with that, I plan to make some SaaS products with my knowledge of AI/ML and Web Development. Also, I'll attend more and more hackathons, because the learning opportunity from there is just undeniable. And, I would start focusing on subjects like System Design and Operating Systems. Plus, I would be actively looking forward to grabbing any internship opportunities.

And lastly, I would continue mentoring my fellow juniors and would start focusing on making Open-Source contributions to renowned organizations.

Conclusion

And that's a wrap!! But if you have any queries regarding my journey or any suggestions for my future, I would love to hear that from you in the comments. Also, as a closing note, I would like to share my resume which I have created recently based on my progress so far, you can check it out here. And if you want to stay connected with me, you can follow me here or on my other social handles, like Twitter/X. Thank You for reading about my journey, have a nice day ahead!!

JavaScript Objects vs JSON: Are they same?

Swapnoneel Saha — Sat, 02 Mar 2024 17:28:30 +0000

Introduction

While learning JavaScript, you will find about JavaScript objects, which may seem familiar to you if you are coming from other programming languages like Java or Python. But soon enough, you will also find something called JSON or JavaScript Object Notation which is widely used all over web development. You may find a lot of similarities between these two and may think about whether they are the same thing or not!!

So in this blog, I'm here to clear your confusion regarding JS Objects and JSON. So let's dive in!!

What is JavaScript Object?

JavaScript Objects are the fundamental constructs which are used to store collections of data, entities or some specific values. They are essentially containers for named values, known as properties, and functions, which are termed methods when they are part of an object.

Compare it with a cup, for example, a cup is an object, with properties. It has a color, a design, weight, a material it is made of, etc. The same way, JavaScript objects can have properties, which define their characteristics. We can define an object in JavaScript like this:

const cup = {
    color : "black",
    design : "cylindrical",
    weight : 300,
    material : "glass"
}

What is JSON?

JSON, which stands for JavaScript Object Notation is a light-weight data interchange format that is both easy for humans to read, write and understand, and also convenient for the machines to parse and generate.

It's completely language-independent but uses the conventions/syntax that are similar to that of the C-family of languages, like C, C++, C#, Java, JavaScript, Python, and many others.

And that's why, we use JSON primarily in data transmission between a server and a web application or as a format for storing configuration or the state information. The simplicity and ease of use of JSON have made it a popular choice for web APIs and configuration files. Here's an example of JSON data:

{
    "firstName": "John",
    "lastName": "Doe",
    "age": 30,
    "isEmployed": true,
    "address": {
        "street": "123 Main St",
        "city": "Anytown",
        "zipCode": "12345"
    },
    "phoneNumbers": [
        {"type": "home", "number": "212 555-1234"},
        {"type": "office", "number": "646 555-5678"}
    ]
}

What's the difference?

It might have been already clear to you how JS Objects and JSON have a lot of dissimilarities between them. But to further develop on that, here are some more aspects where they differ from each other:

	JavaScript Objects	JSON
Flexibility	It can contain functions and support methods that can manipulate the object's data.	It is purely a data format and cannot hold functions.
Syntax	Objects can be declared using the object literal syntax, constructor functions, or the `class` keyword starting from ES6.	JSON closely resembles JavaScript object literal syntax, but it has stricter rules. For example, property names must be double-quoted, and trailing commas are not allowed.
Purpose	They are used within JavaScript code to organize data and functionality.	It's a language-independent text format that is used to transmit data between a server and web application or as a file format.

Conclusion

Understanding these differences is crucial for effectively using JavaScript objects within your code and JSON for data interchange between clients and servers or storing the configuration and state. And, I hope you folks have enriched yourself today with some known or unknown concepts today and cleared any misunderstanding regarding these topics. I wish you a great day ahead and till then keep learning and keep exploring!!

Also, if you want to connect with me, check out my Twitter/X profile, where I regularly post Tech contents: https://x.com/swapnoneel123

Forem: Swapnoneel Saha

Designing Machine Learning Workflows in Python

Introduction

What's the process?

Data Preparation

Feature Engineering

Model Selection

Model Training and Evaluation

Model Deployment

Examples

Machine Learning workflow for Image Classification using the Fashion MNIST dataset

Machine Learning workflow for Sentiment Analysis using the IMDb movie review dataset

Conclusion

The 3 Most Powerful Functions in JavaScript

Introduction

The map() function

Syntax

Example

The filter() function

Syntax

Example

The reduce() function

Syntax

Example

Conclusion

My First year in Tech

The Journey

October, 2022

November, 2022

December, 2022

January, 2023

February, 2023

March, 2023

April, 2023

May, 2023

June, 2023

July, 2023

August, 2023

September, 2023

October, 2023

Bonus

My plans for the Second year

Conclusion

JavaScript Objects vs JSON: Are they same?

Introduction

What is JavaScript Object?

What is JSON?

What's the difference?

Conclusion

The `map()` function

The `filter()` function

The `reduce()` function