My journey towards the AI learnings

How My AI Journey Started

I got the opportunity to start my AI journey with Samsung Innovation Campus, and honestly, I came into it thinking I already knew quite a bit about AI.

I had been using tools like ChatGPT, Microsoft Copilot, Gemini, Claude, and several other AI tools. I had also explored AI coding agents like Windsurf, Codex, Cursor, and others.

At one point, I started thinking, Maybe I already know AI. 😅

I knew how to ask AI the right questions, how to get better outputs, how to use AI for coding, and even how to use different AI tools for different tasks.

But as the course progressed, I realized something important:

Using AI and actually understanding AI are two very different things.

The course introduced me to a completely different side of AI — what happens behind these tools, what concepts are actually needed, and how everything comes together to build AI systems.

That made me want to document my learning journey in a simple way.

So, this blog series is my attempt to answer a very basic question:

“If I want to start learning AI from scratch, where should I actually begin, and what do I need to learn?”

Not just how to use AI, but how to understand what is happening behind it.

Starting the AI Roadmap

Before jumping directly into machine learning or deep learning, I realized there are a few foundations that make the whole journey much easier.

The first thing I would recommend is getting comfortable with Python.

How Much Python Do Actually Need?

This was an important realization for me:

You don’t have to finish all of Python before starting AI.

You need enough Python to comfortably:

• write small programs
• work with lists and dictionaries
• use loops and conditions
• create functions
• manipulate text
• read files
• install and import libraries
• understand basic classes and objects
• read someone else’s Python code

First Step: Get Comfortable With Python

Before getting into machine learning, deep learning, or NLP, the first thing I would recommend is getting comfortable with Python.

You don’t need to become a Python expert. You just need enough Python knowledge that, when you see AI code, you’re able to understand what is happening instead of getting stuck on the programming itself.

Here are the Python basics I found important:

1. Variables and Data Types

A variable is simply a name we give to some information.

name = "Likhitha"
age = 20
cgpa = 8.9

Here, name is a string, age is an integer, and cgpa is a floating-point number.

This becomes important in AI because we constantly work with different kinds of data numbers, text, labels, and more.

2. Lists

A list allows us to store multiple values together.

marks = [85, 92, 78, 90, 88]
print(marks[0])

Output:

85

Think of it like keeping all the marks of students in one place.

Lists become very useful when working with collections of data.

3. Dictionaries

A dictionary stores information using key-value pairs.

student = {
"name": "Likhitha",
"age": 20,
"branch" : "ECE"
}
print(student["branch"])

Output:

ECE

This is useful when data has a clear meaning attached to each value.

For example, instead of remembering that 20 represents age, we can simply access it using “age”.

4. Conditional Statements

Sometimes our program needs to make decisions.

marks = 85
if marks >= 50:
   print("Pass")
else:
   print("Fail")

Output:

Pass

The same idea appears everywhere in programming and AI applications — checking conditions, classifying results, deciding actions, and so on.

5. Loops

Loops help us repeat an operation without writing the same code again and again.

marks = [85, 92, 78]
for mark in marks:
   print(mark)

Output:

85
92
78

Imagine having 10,000 data points and wanting to perform an operation on each one. Writing the operation 10,000 times obviously isn’t practical.

Loops help automate repetitive tasks.

6. Functions

A function is a reusable block of code that performs a particular task.

def calculate_average(a, b):
   return (a + b) / 2
   print(calculate_average(80, 90))

Output:

85.0

Instead of writing the same calculation repeatedly, we can create a function once and reuse it.

As AI projects become bigger, functions help keep the code organized and reusable.

6. BeautifulSoup — Pulling Data From the Web

Not every dataset comes neatly packaged as a CSV file. Sometimes the data I need is sitting inside a webpage, and that’s where BeautifulSoup comes in.

BeautifulSoup is a library that helps extract information from HTML pages.

For example:

python

from bs4 import BeautifulSoup
import requests

response = requests.get("https://example.com")
soup = BeautifulSoup(response.text, "html.parser")
print(soup.title.text)

This pulls the page content and lets me search through it for the specific pieces of information I actually need, like headlines, prices, or product names.

For AI projects, this matters because not all training data is pre-packaged — sometimes you have to go and collect it yourself.

7. List Comprehension

Python provides a shorter way of creating lists using list comprehensions.

For example, suppose I want to square every number:

numbers = [1, 2, 3, 4, 5]
squares = [x * x for x in numbers]
print(squares)

Output:

[1, 4, 9, 16, 25]

You don’t need to master this immediately, but you’ll see this style quite often in Python-based AI and data science code.

8. String Manipulation

AI doesn’t only work with numbers. A huge amount of AI data is actually text.

So understanding how to work with strings is important.

sentence = "I am learning AI"
print(sentence.upper())

Output:

I AM LEARNING AI

We can also split text:

words = sentence.split()
print(words)

Output:

['I', 'am', 'learning', 'AI']

This becomes especially useful when we move into NLP, where we work with human language.

9. Exception Handling

Programs don’t always run perfectly.

Sometimes something unexpected happens, and we need to handle it without crashing the entire program.

try:
  number = int(input("Enter a number: "))
  print(10 / number)
except ValueError:
  print("Please enter a valid number.")
except ZeroDivisionError:
  print("Cannot divide by zero.")

This becomes useful when working with real-world applications where user input, files, APIs, or datasets may not always contain what we expect.

10. File Handling

AI projects often work with files — CSV datasets, text files, JSON files, images, and more.

For example:

with open("notes.txt", "r") as file:
  content = file.read()
  print(content)

Here, Python opens a text file and reads its contents.

Later, when working with datasets, this same idea becomes much more practical.

11. Modules and Packages

As projects grow, putting everything into one Python file becomes messy.

Python allows us to use code from other files and packages.

For example:

import math
print(math.sqrt(25))

Output:

5.0

Instead of creating every mathematical function ourselves, we can use functionality that already exists.

This idea leads directly to something very important in AI: Python libraries.

12. Installing Libraries with pip

One of the first commands you’ll probably use when entering AI development is:

pip install numpy

This installs NumPy so that we can use it in our Python programs.

Then:

import numpy as np

And now we can use NumPy’s functionality.

This is one of the things I found interesting about Python’s AI ecosystem — we don’t have to build everything from scratch.

There are already powerful libraries available for mathematics, data analysis, visualization, NLP, machine learning and deep learning.

13. Basic Object-Oriented Programming

You don’t need advanced OOP before starting AI, but understanding the basic idea of classes and objects is useful.

For example:

class Student:
def __init__(self, name):
   self.name = name
   student = Student("Likhitha")
   print(student.name)

Here, Student is a class, and student is an object created from that class.

Many Python libraries use classes and objects internally, so understanding the basic concept makes unfamiliar AI code easier to read.

14. JSON

JSON is a very common format for exchanging structured information.

For example:

student = {
"name": "Likhitha",
"age": 20,
"branch": "ECE"
}

JSON is commonly encountered when working with APIs, web applications, datasets, and AI services.

For example, when an AI application communicates with an API, the information being sent or received may be structured as JSON.

The Python Libraries Needed for AI Journey

Python Libraries

Once I was comfortable with the Python basics, the next question was:

“Okay, but what do I actually need to learn for AI?”

This is where I came across the huge Python ecosystem.

There are libraries for almost everything : mathematics, data, visualization, web scraping, language processing, machine learning, deep learning, and much more.

At first, seeing a long list of libraries can feel overwhelming.

But I found it much easier when I stopped trying to memorize their names and instead started asking:

“What problem does this library solve?”

That simple question made the whole thing much clearer.

1. NumPy — Learning to Work With Numbers

NumPy stands for Numerical Python.

If I had to explain NumPy in one sentence, I would say:

NumPy is one of the fundamental tools for efficiently working with numerical data in Python.

A normal Python list can store numbers:

numbers = [10, 20, 30, 40, 50]

But AI and data science rarely deal with just five numbers.

Imagine working with:

• thousands of sensor readings
• millions of pixels in images
• mathematical matrices
• model parameters
• large numerical datasets

This is where NumPy becomes useful.

NumPy introduces a powerful data structure called an array.

import numpy as np
numbers = np.array([10, 20, 30, 40, 50])
print(numbers * 2)

Output:

[20 40 60 80 100]

Instead of manually going through every number, NumPy can perform the operation across the entire array.

Why does AI need NumPy?

Because underneath many AI systems, there is a lot of mathematics.

Take an image as an example.

When I look at a photograph, I see a person, a tree, a car, or a dog.

A computer sees numerical values representing pixels.

Those values can be organized into arrays.

Similarly, mathematical operations used in machine learning often involve:

• vectors
• matrices
• arrays
• dot products
• averages
• standard deviations
• transformations

NumPy provides tools for working with these efficiently.

It supports operations such as:

Arithmetic → Statistics → Matrix operations → Reshaping → Mathematical functions

For me, the important takeaway was:

Before an AI model can learn from numbers, I need to know how to work with those numbers. NumPy is one of the foundations for that.

2. Pandas — When Data Starts Looking Like a Dataset

If NumPy is mainly about numerical arrays, Pandas is where things start looking much more like the datasets we see in real projects.

The easiest analogy I use is:

Pandas is like having Excel inside Python, but with the power of programming.

Imagine I have student data:

NameAgeMarksRavi2085Priya2192Anu2078

For a human, this is simply a table.

Pandas represents this kind of data using a DataFrame.

import pandas as pd
data = {
    "Name": ["Ravi", "Priya", "Anu"],
    "Age": [20, 21, 20],
    "Marks": [85, 92, 78]
}
df = pd.DataFrame(data)
print(df)

Now Python can work with this table.

Why is Pandas so important in AI?

Because real-world data is rarely clean.

Imagine downloading a dataset of customer information.

You might find:

Name       Age       Salary

Ravi       25        30000

Priya      24        35000

Anu        NaN       28000

Rahul      26        32000

There is a missing value.

Maybe another row is duplicated.

Maybe some values are written incorrectly.

Maybe a column isn’t useful at all.

Before giving this data to a machine learning model, we usually need to understand, clean and prepare it.

Pandas helps us do things like:

• read CSV files
• read Excel files
• inspect datasets
• find missing values
• remove duplicates
• filter rows
• select columns
• sort data
• group information
• modify values
• prepare datasets

For example:

df = pd.read_csv("customers.csv")

Now an entire CSV file can be brought into Python as a DataFrame.

This is something I found really important to understand:

AI doesn’t start with a model. It often starts with messy data.

And Pandas is one of the tools that helps us turn that messy data into something we can actually work with.

3. Matplotlib — Making Data Visible

After working with data, another problem appears.

Imagine I have 500 rows of numbers.

I can print them.

But can I actually understand them?

Not very easily.

That’s where Matplotlib comes in.

I like to think of it as:

A drawing tool for data.

Suppose I have monthly sales:

January  → 20
February → 35
March    → 28
April    → 50

I could simply read the numbers.

Or I could create a graph and immediately see the trend.

import matplotlib.pyplot as plt
months = ["Jan", "Feb", "Mar", "Apr"]
sales = [20, 35, 28, 50]
plt.plot(months, sales)
plt.title("Monthly Sales")
plt.xlabel("Month")
plt.ylabel("Sales")
plt.show()

Now the numbers become a visual pattern.

Why does visualization matter in AI?

Suppose I’m training a machine learning model.

After every training step, I get a loss value:

0.91
0.76
0.63
0.48
0.35

The numbers tell me the loss is decreasing.

But when I plot them, I can immediately see the trend.

Visualization can help us:

• understand datasets
• identify trends
• compare values
• detect unusual observations
• understand relationships
• analyze model performance

Sometimes data can tell us something through a graph that would take much longer to notice by simply reading rows of numbers.

4. Seaborn — Making Statistical Visualization Easier

Seaborn is another visualization library, but it has a different focus.

A simple way to remember the difference is:

Matplotlib gives me the basic drawing tools. Seaborn gives me easier ways to create statistical visualizations.

Seaborn is built on top of Matplotlib.

For example, suppose I have a collection of values and want to understand their distribution.

import seaborn as sns
data = [1, 1, 2, 3, 4, 4, 4, 5]
sns.displot(data)

Instead of manually building everything from scratch, Seaborn provides convenient functions for statistical plots.

It is particularly useful for:

• distributions
• relationships between variables
• categorical data
• correlation analysis
• heatmaps
• statistical visualization

5. SciPy — When Basic Mathematics Isn’t Enough

SciPy stands for Scientific Python.

If NumPy is one of the foundations for numerical computing, SciPy provides additional tools for more specialized scientific and mathematical work.

A simple way to remember it:

NumPy gives me the numerical foundation; SciPy gives me additional scientific tools built around that foundation.

SciPy is useful for areas such as:

• statistics
• optimization
• signal processing
• scientific calculations
• numerical methods

For example:

from scipy import stats
data = [10, 20, 30, 40, 50
print(stats.tmean(data))

Output:

30.0

7. NLTK — Giving Python Tools to Work With Human Language

Now we move from numbers and tables to something completely different:

Human language.

Consider this sentence:

“I absolutely loved this phone! The camera is amazing.”

As humans, we immediately understand it.

A computer doesn’t naturally understand language in the same way.

This is where Natural Language Processing, or NLP, comes in.

And one of the classic Python libraries for learning NLP concepts is NLTK — Natural Language Toolkit.

A simple way to think about NLTK is:

It provides tools that help us break human language into pieces that a computer program can process.

For example:

import nltk
sentence = "Python is super awesome!"
words = nltk.word_tokenize(sentence)
print(words)

The sentence can be broken into tokens:

['Python', 'is', 'super', 'awesome', '!']

This process is called tokenization.

Why would we need this?

Imagine building a system that analyzes customer reviews.

We have:

“The product is amazing.”

“I really disliked the quality.”

“It’s okay, nothing special.”

To analyze these sentences, we first need to process the language.

NLP can involve techniques such as:

• tokenization
• stop-word handling
• stemming
• lemmatization
• part-of-speech tagging
• text analysis

This is where I started understanding something important:

Before an AI model can learn from text, we need to turn human language into something computational systems can work with.

NLTK is especially useful for learning these fundamental NLP concepts.

8. TensorFlow — Building Deep Learning Models

Now we’ve reached a different stage.

The previous libraries mostly helped us handle, understand and prepare data.

But eventually, we want to build a model that can learn patterns from that data.

This is where TensorFlow comes in.

TensorFlow is a machine learning and deep learning framework developed by Google.

My simple analogy:

If the previous libraries help prepare the ingredients, TensorFlow provides the machinery for building and training the neural network.

Imagine that I have thousands of images of cats.

I want my model to learn what makes an image look like a cat.

The basic idea is:

Cat Images
↓
Prepare Data
↓
Neural Network
↓
Training
↓
Model Learns Patterns
↓
New Image
↓
Prediction

TensorFlow handles many of the mathematical computations involved in training neural networks.

This is where concepts such as:

• layers
• weights
• activation functions
• loss
• optimization
• training
• prediction

start becoming important.

So I wouldn’t think of TensorFlow simply as “another Python library.”

It is a framework that helps us actually build and train deep learning systems.

9. PyTorch — Another Major Deep Learning Framework

Once I started exploring deep learning, I came across another name:

PyTorch.

PyTorch is another framework used to build and train machine learning and deep learning models.

A simple way to think about it is:

TensorFlow and PyTorch are two major ecosystems for developing deep learning models.

For example:

import torch
x = torch.tensor([1.0, 2.0, 3.0])
print(x)

Here, we’re creating a tensor.

A tensor is essentially a generalized way of representing numerical data across different dimensions.

For example:

Number       → scalar
List         → vector
Table        → matrix
Higher-dimensional data → tensor

Tensors are fundamental to modern deep learning because neural networks perform huge numbers of mathematical operations on them.

PyTorch is widely used in:

• computer vision
• NLP
• generative AI
• deep learning
• AI research

One reason it became important in my learning journey is that a lot of modern AI research and open-source models use PyTorch.

10. Keras — Making Neural Networks Easier to Build

Finally, there is Keras.

When I first looked at neural networks, the mathematics and implementation details could feel overwhelming.

Keras provides a much simpler high-level way to construct neural networks.

The easiest analogy I can give is:

If TensorFlow is the engine, Keras gives us a much simpler interface for building with it.

For example:

from tensorflow import keras
model = keras.Sequential([
keras.layers.Dense(10, activation="relu"),
keras.layers.Dense(1)
])

Even if we don’t understand every line yet, we can see the basic idea:

Input
↓
Layer
↓
Layer
↓
Output

Keras allows us to construct models by combining layers.

This makes it particularly useful when learning the fundamentals of neural networks.

Instead of getting buried in low-level implementation details immediately, we can focus more on:

What is a neural network?

What does a layer do?

How does training work?

How does the model make predictions?

That’s why I see Keras as a beginner-friendly bridge into deep learning.

Not every AI project will use every library.

And that’s an important point.

I don’t need to use NumPy, Pandas, SciPy, NLTK, TensorFlow and PyTorch together in every project.

The right library depends on the problem.

That’s why I think learning libraries should not be about memorizing names.

It should be about developing this habit:

“I have a problem. Which tool is designed to solve it?”

Once I started thinking this way, the huge list of AI libraries started looking much less scary.

Instead of seeing ten unfamiliar names, I started seeing ten different tools — each with a specific job.

And that made the next part of my AI journey much easier.

📚 Library Exposure

Once the Python basics are comfortable, the next step is getting familiar with the libraries commonly used throughout an AI workflow.

Start with:

• NumPy → numerical computing and arrays
• Pandas → working with datasets and tables
• Matplotlib → basic data visualization
• Seaborn → statistical visualization
• SciPy → scientific and mathematical computing
• BeautifulSoup → extracting information from web pages
• NLTK → basic Natural Language Processing
• Scikit-learn → machine learning
• TensorFlow / Keras → deep learning
• PyTorch → deep learning and AI research

The important thing here is not to memorize all these libraries at once.

Instead, understand one simple thing:

What problem does this library solve, and when would I actually use it?

Once that becomes clear, the rest of the AI roadmap starts making much more sense.