DEV Community: Aya El Sherif

Why companies need to have a Data & AI team as soon as possible?

Aya El Sherif — Fri, 20 Feb 2026 20:05:16 +0000

My name is Aya and I am here to share my insights about why companies might need to consider having their Data & AI department as soon as possible!

In the past, business decisions were based on:

Experience
Intuition
Historical reports
People's personal visions and biases

Today, Artificial Intelligence is completely changing the rules not only in tech but also in business big decisions and our daily life.

From intuition → data-driven decisions

Instead of guessing, AI systems analyze millions and billions of data points in seconds to deliver accurate insights to make a better decision.

Example:
An e-commerce company can predict which products will be sold fastly and can be in demand before it happens.
Here we move from static reports → real-time decisions
Companies no longer need to wait until the end of the month to review performance and then make a decision about each product separately.

With AI, You can get:

Immediate problem detection
Immediate risk response
Continuous performance optimization

Example:
Fraud detection systems flag suspicious transactions the moment they occur, Have you wondered before how this can happen?

From analyzing the past → We are predicting the future

Instead of understanding what happened, companies can anticipate what will happen as well.
With AI, You can:

Predict customer behavior
Forecast churn
Avoid operational failures
Assess financial risks

From management reports → intelligent decision support

Rather than reading lengthy and long reports, executives and decision makers can get:

Smart recommendations
Proactive alerts
“What-if” scenarios with all possibilities and probabilities.

Let's get to know what does this mean for businesses and business owners?

Organizations that adopt AI-driven decision making gain:

Faster decisions
Calculated and Reduced risk
Increased profitability and revenue
A real competitive advantage

The truth
AI does not replace decision-makers .. it makes their decisions smarter and way faster.

If you lead a company today,
Are your decisions driven by intuition or by data?

Intro to Machine Learning

Aya El Sherif — Tue, 21 Dec 2021 01:54:18 +0000

Welcome to my third blog!
In this blog, I am revising basic concepts in the Kaggle course (Intro to machine learning) and we'll build our very first model here and it's totally basic so, it doesn't require any experience in this topic, Let's start!

Lesson 1 : How models work?

Let's walk through the example there:

Your cousin has made millions of dollars speculating on real estate. He's offered to become business partners with you because of your interest in data science. He'll supply the money, and you'll supply models that predict how much various houses are worth.

When you wondered how he predicted the house prices before he said by "intuition", But more questioning reveals that he's identified price patterns from houses he has seen in the past and he uses those patterns to make predictions for new houses he is considering.

Machine learning works the same way. We'll start with a model called the Decision Tree. There are fancier models that give more accurate predictions.

What is that?

The DT (decision tree) divides houses into only two categories.
We use data to decide how to break the houses into two groups
Then again to determine the predicted price in each group. This step of capturing patterns from data is called fitting or training the model.
After data has been fit, you can apply it to new data to predict prices of additional new homes.

Improving the Decision Tree

Now, It pops up in your mind that definitely DT 1 makes more sense as when the more no. of bedrooms the higher price it'll be, right?
Well, This not totally true.
As there are extra features (e.g. lot size, crime rate and so on).
This will lead us to the deeper tree that covers more features that definitely affects the predicted price and those are the extra "splits".

leaf is where we have our predicted price.

The splits and values at the leaves will be determined by the data, so we need to check out the data we'll be working with.

Lesson 2 : Basic Data Exploration (Examine your data)
To build any ML model we need to be familiar and fully understand our data, In order to do so, One of the well known libraries is "Pandas".
What's pandas?
Pandas is the primary tool used for exploring and manipulating data.
Pandas => pd
Let's import it :

import pandas as pd

The most important part of the Pandas is the "DataFrame".
A DataFrame holds the type of data you might think of as a table. This is similar to a sheet in Excel, or a table in a SQL database.

Pandas has powerful methods for most things we'll want to do with this type of data.
Let's do some code!
Check this dataset : Homes in Melbourne, Australia

As usual, Check my code

Interpreting Data Description

The results show 8 numbers for each column in our original dataset. The first number is count that shows how many rows have non-missing values.

Missing values arise for many reasons. For example, the size of the 2nd bedroom wouldn't be collected when surveying a 1 bedroom house. We'll come back to the topic of missing data.

The second value is the mean, which is the average.
The third value is std (standard deviation) which measures how numerically spread out the values are.

To interpret the min, 25%, 50%, 75% and max values, imagine sorting each column from lowest to highest value.
The first (smallest) value is the min.
If you go a quarter way through the list, you'll find a number that is bigger than 25% of the values and smaller than 75% of the values that is the 25% value (pronounced "25th percentile").
The 50th and 75th percentiles are defined analogously and the max is the largest number.

Lesson 3 : Your First Machine Learning Model

In this lesson, we'll apply what is explained above to build a model. Let's go!

Selecting Data for Modeling

We have so many variables here so, we'll pick a few of them using our intuition (for now).

To choose variables/columns, we'll need to see a list of all columns in the dataset.

melbourne_data.columns

Output => Index(['Suburb', 'Address', 'Rooms', 'Type', 'Price', 'Method', 'SellerG','Date', 'Distance', 'Postcode', 'Bedroom2', 'Bathroom', 'Car','Landsize', 'BuildingArea', 'YearBuilt', 'CouncilArea', 'Lattitude','Longtitude', 'Regionname', 'Propertycount'],dtype='object')

We have some missing values

We will take the simplest option for now and drop houses from our data. (dropna as we can consider for now that "na" means "not available".)

melbourne_data = melbourne_data.dropna(axis=0)

Now, we'll select pieces from our data

Two approaches to be followed :

- Dot notation, which we use to select the "prediction target"
- Selecting with a column list, which we use to select the "features"

Selecting The Prediction Target

You can pull out a variable with dot-notation "."
This single column is stored in a Series, which is like a df with only a single column of data.

We'll use the dot notation to select the column we want to predict, which is called the prediction target.
We'll call the prediction target "y".
So we need to save the house prices in the Melbourne data :

y = melbourne_data.Price

Choosing "Features"

The columns or "features." In our case, those would be used to determine the home price. Sometimes, we will use all columns except the target one as features. Other times it'd be better with fewer features.

For now, we'll build a model with only a few features. Later on we'll see how to iterate and compare models built with different features.

We select multiple features by providing a list of column names.

Here is an example:

melbourne_features = ['Rooms', 'Bathroom', 'Landsize', 'Lattitude', 'Longtitude']

We'll call our data "X"

X = melbourne_data[melbourne_features]

Let's see it more deep :

X.describe()

Output => Rooms Bathroom Landsize Lattitude Longtitude
count 6196.000000 6196.000000 6196.000000 6196.000000 6196.000000
mean 2.931407 1.576340 471.006940 -37.807904 144.990201
std 0.971079 0.711362 897.449881 0.075850 0.099165
min 1.000000 1.000000 0.000000 -38.164920 144.542370
25% 2.000000 1.000000 152.000000 -37.855438 144.926198
50% 3.000000 1.000000 373.000000 -37.802250 144.995800
75% 4.000000 2.000000 628.000000 -37.758200 145.052700
max 8.000000 8.000000 37000.000000 -37.457090 145.526350

And

X.head()

Output =>
Rooms Bathroom Landsize Lattitude Longtitude
1 2 1.0 156.0 -37.8079 144.9934
2 3 2.0 134.0 -37.8093 144.9944
4 4 1.0 120.0 -37.8072 144.9941
6 3 2.0 245.0 -37.8024 144.9993
7 2 1.0 256.0 -37.8060 144.9954

Building Our Model

We will use the scikit-learn library to create our model.
(sklearn) is the most popular library for modeling the types of data typically stored in DataFrames.

The steps to building and using a model are:

Define: What type of model will it be? A decision tree? Some other type of model? Some other parameters of the model type are specified too.
Fit: Capture patterns from provided data. This is the heart of modeling.
Predict: Just what it sounds like
Evaluate: Determine how accurate the model's predictions are.

Here is an example of defining a decision tree model with scikit-learn and fitting it with the features and target variable.

from sklearn.tree import DecisionTreeRegressor

# Define model.Specify a number for random_state to ensure same results each run
melbourne_model = DecisionTreeRegressor(random_state=1)

# Fit model
melbourne_model.fit(X, y)

Output =>
DecisionTreeRegressor(random_state=1)

Many machine learning models allow some randomness in model training.
Specifying a number for random_state ensures you get the same results in each run.
We use any number, and model quality won't depend on exactly what value we choose.

We now have a fitted model that we can use to make predictions.

print("Making predictions for the following 5 houses:")
print(X.head())
print("The predictions are")
print(melbourne_model.predict(X.head()))

Output => Making predictions for the following 5 houses:
Rooms Bathroom Landsize Lattitude Longtitude
1 2 1.0 156.0 -37.8079 144.9934
2 3 2.0 134.0 -37.8093 144.9944
4 4 1.0 120.0 -37.8072 144.9941
6 3 2.0 245.0 -37.8024 144.9993
7 2 1.0 256.0 -37.8060 144.9954
The predictions are
[1035000. 1465000. 1600000. 1876000. 1636000.]

Check my final code from Here

That's all for today, We covered half of the course and we'll continue in the upcoming blog!
Hope you learnt and know now how to build a model.

Resources and docs :

1.Kaggle Course
2.W3schools
3.Pandas documentation

Foundations of probability (1)

Aya El Sherif — Thu, 16 Dec 2021 11:29:37 +0000

As explained before in our previous blog that probabilities is essential to explore more in the data science field So, Let's start our today's journey!

You may wonder what is probability and its role in data science field?
Probability is the foundation of many models and methods in data science, We can't really build a good model without knowing the concepts of probabilities.

Flipping a coin

Do you remember "head and tail" we were taught in the primary school? We'll travel back years ago to this basic example.
As we know we explain and also show the theoretical part in a piece of code in python.

Bernoulli trial
Possible outcomes here are binary which can be modeled as (Yes/No) or (On/Off) or (Head/Tail) or (Success/Failure) and so on.
In our case its success (Heads) or Failures (Tails).
Each outcome is called an Event.
For a fair coin flip it we have 50% chance of getting heads and 50% chance of getting tails for each event.

Let's simulate the coin flips, We'll be using the "Bernoulli" object from a python library called "Scipy.stats".

#Generate rvs for random variates using arg. p for success prob. and size for no. of coin flips.
from scipy.stats import bernoulli
bernoulli.rvs(p=0.5, size=1)

Outputs =>
array([0]) is the output for the first time which means failure or T.
array([1]) is the output if you ran it again which means success or H.

Flipping multiple coins

Change the size of flips

bernoulli.rvs (p=0.5, size=10)

Output => array([0, 1, 1, 0, 1, 0, 1, 0, 1, 0])
So, How many head there? Let's explore this together!

sum(bernoulli.rvs(p=0.5, size=10))

Output => 5, This means 5 heads and 5 tails.
Let's rerun it again and see what happens.

sum((bernoulli.rvs(p=0.5, size=10)))

Output => 2, This means we have 2 heads and 8 tails.

Using binomial distribution for independent Bernoulli trials

n => No. of the coin flips
p => Probability of success
size => No. of draws of the same experiment

Let's simulate the coin flips, We'll be using the "Binom" object from a python library called "Scipy.stats".

#**Binomial r.v.**
from scipy.stats import binom
binom.rvs (n=10 , p = 0.5 , size = 1)

Output => array([7]), This means we have 7 heads out of 10 flips.
Let's now try 10 more times of drawing.

binom.rvs(n=10, p=0.5 , size=10)

Output => array([6, 5, 6, 6, 7, 6, 4, 6, 5, 6]), This means that "6" is the result that repeats the most for a fair coin.

Biased coin draws

binom.rvs(n=10, p=0.3 , size=10)

Output => array([2, 5, 3, 4, 2, 4, 1, 4, 2, 5]), Changed the p of getting heads to "0.3" lead to different outcomes.

Random number generator seed

To simulate the outcome of a random experiment.
If you run the same command with the same random seed, you will always get the same result. In Python we need to set a seed for the generator to produce similar outcomes in each experiment. Then we can check if the results are what we expected. We have two options to configure the generator: using the (random_state) parameter of the rvs function or using (np.random.seed).

from scipy.stats import binom
binom.rvs(n=10, p=0.5 , size =1, random_state=42)

from scipy.stats import binom
import numpy as np
np.random.seed(42)
binom.rvs(n=10,p=0.5,size=1)

Output => array([4])

Today's blog is done but let's do a practice now!

Practice

This exercise requires the bernoulli object from the scipy.stats library to simulate the two possible outcomes from a coin flip, 1 ("heads") or 0 ("tails"), and the numpy library (loaded as np) to set the random generator seed.

We'll use the bernoulli.rvs() function to simulate coin flips using the size argument.

We will set the random seed so you can reproduce the results for the random experiment in each exercise.

From each experiment, you will get the values of each coin flip. You can add the coin flips to get the number of heads after flipping 10 coins using the sum() function.

Steps:

Import bernoulli from scipy.stats, set the seed with np.random.seed(). Simulate 1 flip, with a 35% chance of heads.
Use bernoulli.rvs() and sum() to get the number of heads after 10 coin flips with 35% chance of getting heads.
Using bernoulli.rvs() and sum(), try to get the number of heads after 5 flips with a 50% chance of getting heads.

# Import numpy
import numpy as np
# Import the bernoulli object from scipy.stats
from scipy.stats import bernoulli

# Set the random seed to reproduce the results
np.random.seed(42)

# Simulate one coin flip with 35% chance of getting heads
coin_flip = bernoulli.rvs(p=0.35, size=10)
print(coin_flip)

Output => [0 1 1 0 0 0 0 1 0 1]

#Using bernoulli.rvs() and sum(), try to get the number of heads after 5 flips with a 50% chance of getting heads.
five_coin_flips = bernoulli.rvs(p=0.5, size=5)
coin_flips_sum = sum(five_coin_flips)
print(coin_flips_sum)

Output => 2

Using binom to flip even more coins Previously, you simulated 10 coin flips with a 35% chance of getting heads using bernoulli.rvs().

This exercise loads the binom object from scipy.stats so you can use binom.rvs() to simulate 20 trials of 10 coin flips with a 35% chance of getting heads on each coin flip.

#Defining binom
# Set the random seed to reproduce the results
np.random.seed(42)

# Simulate 20 trials of 10 coin flips 
draws = binom.rvs(n=10, p=0.35, size=20)
print(draws)

Output => [3 6 4 4 2 2 1 5 4 4 1 6 5 2 2 2 3 4 3 3]

I hope you got some basic knowledge and refreshed your mind with this blog and see you in the next learning journey where we will learn the probability distribution and more!
You can check the code
Resource : https://campus.datacamp.com/courses/foundations-of-probability-in-python/

"Hello Neural Network!"

Aya El Sherif — Fri, 10 Dec 2021 13:49:50 +0000

Machine learning is about a computer learning the patterns that distinguish things.

Let's start with a very simple question :

X = -1 , 0 , 1 , 2 , 3 , 4

Y = -3 , -1 , 1 , 3 , 5 , 7

What is the formula that maps X to Y?

⇒ 2X-1
i.e. 2(-1)-1 = -3

Neural Network is a set of functions that can learn patterns.

model = keras.Sequential([keras.layers.Dense(units=1, input_shape=[1])])

The above code is written using python , TF and an API in TF called "Keras".
"Keras" makes it easy to define Neural networks.
"Dense" defines a layer of connected neurons. ⇒ 1 dense ⇒ 1 layer ⇒ 1 unit ⇒ 1 neuron
Successive layers are defined in sequence as "Sequential" ⇒ 1 neuron.
Shape of what's input to NN in 1st layer ⇒ 1 value.

Important functions:

Optimizers
Loss

Very simple :

The neural network has no idea what is the relation between X and Y as mentioned before So,

It guesses the formula for example ⇒ Y=10X-10 and then it will use the data it knows about (Set of Xs and Ys) to measure how good or bad its guess was. The LOSS fun. measures this and then gives it to the OPTIMIZER which figures out the next guess So, The optimizer thinks about how good / bad the guess was done using the data from the loss function.

Each guess should be better than the prev. one.
As the guesses become better and better ⇒ Accuracy approaches 100%. (Convergence)

Convergence

A machine learning model reaches convergence when it achieves a state during training in which loss settles to within an error range around the final value ⇒ A model converges when additional training will not improve the model.

Loss

A lost/cost function is about checking probabilities of a prediction based on how much the prediction varies from the true value. This helps us to know more about how well our model is performing.
Unlike accuracy, loss is not a % — it is a summation of the errors made for each sample in training or validation sets. Loss is often used in the training process to find the "best" parameter values for the model (e.g. weights in neural network). During the training process the goal is to minimize this value.

A ML model reaches convergence when it achieves a state during training in which loss settles to within an error range around the final value.

A model converges when any additional training will not improve the model.

E.g. ⇒ Mean squared error.

mean_squared_error ( ):

Computes the mean squared error between labels and predictions.

Optimizer

SGD (Stochastic Gradient Descent).

model.complie(optimizer = 'sgd', loss_function = 'mean_squared_error')

Now, Let's get back to our example and our sets (X & Y):

Xs= np.array([-1.0, 0.0, 1.0, 2,0, 3.0, 4,0], dtype= float)
Ys= np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7,0], dtype=float)

We used numpy *python * library (np) for data representation.

model.fit(Xs,Ys, epochs=100)

As discussed above : 'Epochs' is to loop 100 times and make a guess => measure how good/bad the guesses by LOSS and then use the OPTIMIZER + data to make another guess and repeat this more and more.

print(model.predict([10]))

When you run the whole code
You'll notice that it the prediction is [[17.862192]] and not 19 as expected that's because in neural networks we deal in "Probability"!
Wait for more blogs explaining the glorious role of probability in the art of data!
Resources and they're pretty good to explore more:

The main refrence
Also, This video explains the NN very well!