Hi everyone i’m : Furkan Kızılay

In today’s world, deep learning and image processing technologies are being utilized across various application domains. In this blog post, we will embark on a journey to accomplish a digit recognition project using the Convolutional Neural Network (CNN) and OpenCV libraries. We will proceed step by step to grasp how the project can be executed.

1. Project Preparations
2. Separate the Data
3. Data Visualization
4. Data Preprocessing
5. Data Generate
6. Create the CNN Model
7. Evaluate the Model
8. Testing the Trained Model with OpenCV

Project Purpose and Scope

In this project, we aim to create a digit recognition system using the power of Convolutional Neural Networks (CNNs) and OpenCV. The scope of the project encompasses building a model that can accurately identify digits. Through this undertaking, we will demonstrate the application of deep learning and image processing techniques for practical problem-solving.

Separate the Data

We are specifying the path to our dataset directory. We use the os.listdir() function to obtain a list of all items (files and directories) within the specified path. The len() function calculates the total number of items (files and directories) in the specified directory. Afterwards, we print the value of noOfClasses.

path = "myData"
myList = os.listdir(path)
noOfClasses = len(myList)
print("number of classes", noOfClasses)

We are defining arrays named images and classNo to hold our data.

images = []
classNo = []

for i in range(noOfClasses):
    myImageList = os.listdir(path + "\\" + str(i))
    for j in myImageList:
        img = cv2.imread(path + "\\" + str(i) + "\\" + j)
        img = cv2.resize(img, (32, 32))
        images.append(img)
        classNo.append(i)

print(len(images))
print(len(classNo))

images = np.array(images)
classNo = np.array(classNo)

print(images.shape)
print(classNo.shape)

This code reads images from different classes, resizes them to a standard size of 32x32 pixels, and organizes them with their class labels for deep learning. The images and class labels are stored in lists, then converted into NumPy arrays for further processing. The goal is to prepare these images and labels for training a deep learning model.

x_train, x_test, y_train, y_test = train_test_split(images, classNo, test_size=0.5, random_state=42)
x_train, x_val, y_train, y_val = train_test_split(x_train, y_train, test_size=0.2, random_state=42)

These two lines of code segment the dataset into training, validation, and testing sets, enabling the model to be trained on one subset, validated on another, and tested on the remaining portion. This is a common practice in deep learning to assess and improve model performance.

x_train, x_test, y_train, y_test = train_test_split(images, classNo, test_size=0.5, random_state=42) splits the dataset into training (x_train and y_train) and testing (x_test and y_test) sets. It divides the data so that 50% is allocated for testing, using a fixed random seed (random_state=42) for reproducibility.

x_train, x_val, y_train, y_val = train_test_split(x_train, y_train, test_size=0.2, random_state=42) further splits the training set into training (x_train and y_train) and validation (x_val and y_val) sets. It designates 20% of the training data for validation. Again, the random seed is set to 42 for consistent results.

Data Visualization

fig, axes = plt.subplots(3,1, figsize=(7,7))
fig.subplots_adjust(hspace=0.5)
sns.countplot(y_train, ax=axes[0])
axes[0].set_title("y_train")

sns.countplot(y_test, ax=axes[1])
axes[1].set_title("y_test")

sns.countplot(y_val, ax=axes[2])
axes[2].set_title("y_val")
plt.show()

Generates a visual representation of the class distribution in the training, testing, and validation datasets using bar plots. It helps to understand how balanced or imbalanced the class distribution is across the different subsets of data.

Data Preprocessing

# preporcess
def preProcess(img):
    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    img = cv2.equalizeHist(img) # histogram expanded from 0 to 255
    img = img / 255
    return img

x_train = np.array(list(map(preProcess, x_train)))
x_test = np.array(list(map(preProcess, x_test)))
x_val = np.array(list(map(preProcess, x_val)))

x_train = x_train.reshape(-1,32,32,1)
x_test = x_test.reshape(-1,32,32,1)
x_val = x_val.reshape(-1,32,32,1)

Defines a preprocessing function that converts images to grayscale, performs histogram equalization, and normalizes pixel values. It then applies this preprocessing function to the training, testing, and validation datasets. Finally, it reshapes the images to the required format for model training. These preprocessing steps help enhance the quality and suitability of the images for feeding into a deep learning model.

Data Generate

# data generate
dataGen = ImageDataGenerator(width_shift_range=0.1,
                             height_shift_range=0.1,
                             zoom_range=0.2,
                             rotation_range=10)

dataGen.fit(x_train)

Sets up an ImageDataGenerator to perform data augmentation by applying random shifts, zooms, and rotations to the training images. The generator is then fit to the training data to calculate necessary statistics and parameters for the augmentation process. This helps the model learn from a more diverse set of augmented images, improving its ability to generalize to new and unseen data.

y_train = to_categorical(y_train, noOfClasses)
y_test = to_categorical(y_test, noOfClasses)
y_val = to_categorical(y_val, noOfClasses)

Converting the original class labels into a binary matrix format using one-hot encoding. This format is commonly used in machine learning when dealing with categorical data, as it provides a suitable representation for training models that require numerical input.

Create the CNN Model

model = Sequential()
model.add(Conv2D(input_shape=(32,32,1), filters=8, kernel_size=(5,5), activation="relu", padding="same"))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Conv2D(filters=16, kernel_size=(3,3), activation="relu", padding="same"))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Dropout(0.2))
model.add(Flatten())
model.add(Dense(units=256, activation="relu"))
model.add(Dropout(0.2))
model.add(Dense(units=noOfClasses, activation="softmax"))

model.compile(loss="categorical_crossentropy", optimizer="Adam", metrics=["Accuracy"])

batch_size = 250

hist = model.fit_generator(dataGen.flow(x_train, y_train, batch_size = batch_size), 
                                        validation_data = (x_val, y_val),
                                        epochs = 15,steps_per_epoch = x_train.shape[0]//batch_size, shuffle = 1)

model.save("modelWeights.h5")

Defines a CNN model for image classification, compiles it, trains it using data augmentation, and saves the trained model’s weights and architecture for future use. The model is designed to learn features from the input images and classify them into one of the specified classes.

Evaluate the Model

plt.figure()
plt.plot(hist.history["loss"], label = "Train Loss")
plt.plot(hist.history["val_loss"], label = "Val Loss")
plt.legend()
plt.show()

Creates a line plot showing the training loss and validation loss as the number of training epochs increases. It’s a visual way to understand how well the model is learning and whether it’s overfitting or underfitting.

plt.figure()
plt.plot(hist.history["Accuracy"], label = "Train accuracy")
plt.plot(hist.history["val_Accuracy"], label = "Val accuracy")
plt.legend()
plt.show()

Creates a line plot showing the training accuracy and validation accuracy trends as the number of training epochs increases. This visualization helps assess how well the model is learning from the training data and how well it generalizes to the validation data.

score = model.evaluate(x_test, y_test, verbose = 1)
print("Test loss: ", score[0])
print("Test accuracy: ", score[1])

y_pred = model.predict(x_val)
y_pred_class = np.argmax(y_pred, axis = 1)
Y_true = np.argmax(y_val, axis = 1)
cm = confusion_matrix(Y_true, y_pred_class)
f, ax = plt.subplots(figsize=(8,8))
sns.heatmap(cm, annot = True, linewidths = 0.01, cmap = "Greens", linecolor = "gray", fmt = ".1f", ax=ax)
plt.xlabel("predicted")
plt.ylabel("true")
plt.title("cm")
plt.show()

Evaluates the model’s performance on the test dataset, calculates a confusion matrix for the validation dataset’s predictions, and then visualizes the confusion matrix using a heatmap. The heatmap helps to visualize how well the model is performing in terms of class predictions and where it might be making mistakes.

Testing the Trained Model with OpenCV

cap = cv2.VideoCapture(0)
cap.set(3, 480)
cap.set(4, 480)

# pickle_in = open("model_trained_new.pickle", "rb")
# model = pickle.load(pickle_in)
model = load_model("modelWeights.h5")

while True:
    success, frame = cap.read()
    if success:
        img = np.asarray(frame)
        img = cv2.resize(img, (32, 32))
        img = preProcess(img)
        img = img.reshape(1, 32, 32, 1)

        #predict
        #classIndex = int(model.predict_classes(img))
        predictions = model.predict(img)
        classIndex = np.argmax(predictions)
        probVal = np.amax(predictions)
        print(classIndex, probVal)

        if probVal > 0.7:
            cv2.putText(frame, str(classIndex) + "  " + str(probVal), (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,255,0), 1)

        cv2.imshow("digit-recognition", frame)

    if cv2.waitKey(1) & 0xFF == ord("q"): break

cap = cv2.VideoCapture(0): This line initializes a video capture object to capture frames from the webcam (camera index 0).

cap.set(3, 480) and cap.set(4, 480): These lines set the width and height of the captured video frames to 480 pixels each.

model = load_model("modelWeights.h5"): This line loads the pre-trained CNN model from the "modelWeights.h5" file.

The code enters a loop to continuously capture and process video frames from the webcam.

success, frame = cap.read(): This line captures a frame from the webcam. success indicates whether the frame was captured successfully.

Inside the loop:

• The captured frame is processed and resized to 32x32 pixels using the preProcess function.
• The processed image is reshaped into the required format for the model’s input.
• The model predicts the class probabilities for the input image.
• The predicted class index with the highest probability and the maximum probability value are extracted.
• If the maximum probability value is greater than 0.7, the predicted class index and probability are displayed on the frame using cv2.putText.
• The frame with annotations is displayed using cv2.imshow.

if cv2.waitKey(1) & 0xFF == ord("q"): break: This checks if the 'q' key is pressed. If it is, the loop breaks, ending the video capture and window display.

In summary, this code captures video frames from the webcam, processes them, feeds them into the pre-trained model, and displays the results (class index and probability) on the video feed. The loop continues until the ‘q’ key is pressed.

Let’s test our project by running code and showing a number to our computer’s camera.

When I display the number 8 on the phone screen, OpenCV processes the image. Later, the photo we show to the camera serves as input to our model. Our model then predicts the shown number as 8.

Project: https://github.com/furkankizilay/computer-vision/tree/main/cnn-with-opencv/digit-recognition

Digit Recognition Project Using CNN and OpenCV was originally published in AI Mind on Medium, where people are continuing the conversation by highlighting and responding to this story.

Hi everyone i’m : Furkan Kızılay

In this article, we will develop an end-to-end machine learning project with 11 steps in our own locale. After that, we will create an API with FastAPI, after creating the interface with the help of Streamlit, we will dockerize our project.

1. Data Load
2. Feature Engineering
3. Data Cleaning
4. Outlier Removal
5. Data Visualization (Relationship Between Variables)
6. Extracting Training Data
7. Encoding
8. Build a Model
9. Create API with FastAPI
10. Creating a web interface to the model created with Streamlit.
11. Dockerize

df = pd.read_csv("cars.csv")
df.head()

Feature Engineering

Add new feature for company names.

df["company"] = df.name.apply(lambda x: x.split(" ")[0])
df.head()

Data Cleaning

year has many non-year values.

df2 = df.copy()
df2 = df2[df2["year"].str.isnumeric()]

year is in object. Change to integer.

df2["year"] = df2["year"].astype(int)

Price has Ask for Price.

df2 = df2[df2["Price"] != "Ask For Price"]
df2.Price

Price has commas in its prices and is in object.

df2.Price = df2.Price.str.replace(",","").astype(int)

kms_driven has object values with kms at last.

df2["kms_driven"]

df2["kms_driven"] = df2["kms_driven"].str.split(" ").str.get(0).str.replace(",","")

It has nan values and two rows have ‘Petrol’ in them.

df2 = df2[df2["kms_driven"].str.isnumeric()]
df2.info()

df2["kms_driven"] = df2["kms_driven"].astype(int)

fuel_type has nan values.

df2[df2["fuel_type"].isna()]

df2 = df2[~df2["fuel_type"].isna()]

Changing car names. Keeping only the first three words.

df2['name']=df2['name'].str.split().str.slice(start=0,stop=3).str.join(' ')
df2.head()

Resetting the index of the final cleaned data.

df2 = df2.reset_index(drop=True)

Save the clanned data.

df2.to_csv("cleaned_car_data.csv")
df2.describe(include="all")

Outlier Removal

Drop the price outliers.

df2 = df2[df2["Price"]<6e6].reset_index(drop=True)
df2

Data Visualization

Checking relationship of Company with Price.

df2["company"].unique()

import seaborn as sns

plt.subplots(figsize=(15,7))
ax=sns.boxplot(x='company',y='Price',data=df2)
ax.set_xticklabels(ax.get_xticklabels(),rotation=40,ha='right')
plt.show()

Checking relationship of Year with Price.

plt.subplots(figsize=(20,10))
ax=sns.swarmplot(x='year',y='Price',data=df2)
ax.set_xticklabels(ax.get_xticklabels(),rotation=40,ha='right')
plt.show()

Checking relationship of kms_driven with Price.

sns.relplot(x='kms_driven',y='Price',data=df2,height=7,aspect=1.5)

Checking relationship of Fuel Type with Price.

plt.subplots(figsize=(14,7))
sns.boxplot(x='fuel_type',y='Price',data=df2)

Relationship of Price with FuelType, Year and Company mixed.

ax=sns.relplot(x='company',y='Price',data=df2,hue='fuel_type',size='year',height=7,aspect=2)
ax.set_xticklabels(rotation=40,ha='right')

Extracting Training Data

X=df2[['name','company','year','kms_driven','fuel_type']]
y=df2['Price']

X

Applying Train Test Split

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)

Encoding

Creating an OneHotEncoder object to contain all the possible categories.

from sklearn.linear_model import LinearRegression

from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import make_column_transformer
from sklearn.pipeline import make_pipeline
from sklearn.metrics import r2_score

ohe=OneHotEncoder()
ohe.fit(X[['name','company','fuel_type']])

Creating a column transformer to transform categorical columns.

column_trans=make_column_transformer((OneHotEncoder(categories=ohe.categories_),['name','company','fuel_type']),
                                remainder='passthrough')

Build a Model

Linear Regression Model

lr=LinearRegression()

Making a pipeline

pipe=make_pipeline(column_trans,lr)

Fitting the model

pipe.fit(X_train,y_train)

y_pred=pipe.predict(X_test)

Checking R2 Score

r2_score(y_test,y_pred)

Finding the model with a random state of TrainTestSplit where the model was found to give almost 0.92 as r2_score.

scores=[]
for i in range(1000):
    X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.1,random_state=i)
    lr=LinearRegression()
    pipe=make_pipeline(column_trans,lr)
    pipe.fit(X_train,y_train)
    y_pred=pipe.predict(X_test)
    scores.append(r2_score(y_test,y_pred))

scores[np.argmax(scores)]

Predict spesific car price

pipe.predict(pd.DataFrame(columns=X_test.columns,data=np.array(['Maruti Suzuki Swift','Maruti',2019,100,'Petrol']).reshape(1,5)))

The best model is found at a certain random state

X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.1,random_state=np.argmax(scores))
lr=LinearRegression()
pipe=make_pipeline(column_trans,lr)
pipe.fit(X_train,y_train)
y_pred=pipe.predict(X_test)
r2_score(y_test,y_pred)

import joblib

joblib.dump(pipe,open('LinearRegressionModel.pkl','wb'))

pipe.predict(pd.DataFrame(columns=['name','company','year','kms_driven','fuel_type'],data=np.array(['Maruti Suzuki Swift','Maruti',2019,100,'Petrol']).reshape(1,5)))

Create API with FastAPI

Initialize application instance in main.py in app folder.

app = FastAPI(title='Car Price Prediction', version='1.0',

description='Linear Regression model is used for prediction')

Initialize model artifacte files. This will be loaded at the start of FastAPI model server.

model = joblib.load("LinearRegressionModel.joblib")

This struture will be used for Json validation.

With just that Python type declaration, FastAPI will perform below operations on the request data

1) Read the body of the request as JSON.

2) Convert the corresponding types (if needed).

3) Validate the data.If the data is invalid, it will return a nice and clear error, indicating exactly where and what was the incorrect data.

class Data(BaseModel):

    name: str

    company: str

    year: int

    kms_driven: float

    fuel_type: str

Create API root or home endpoint.

@app.get('/')

@app.get('/home')

def read_home():

    """

    Home endpoint which can be used to test the availability of the    application.

    """

    return {'message': 'System is healthy'}

Create ML API endpoint to predict against the request received from the client.

@app.post("/predict")

def predict(data: Data):

    result = model.predict(pd.DataFrame(columns=['name','company','year','kms_driven','fuel_type'],data=np.array([data.name,data.company,data.year,data.kms_driven,data.fuel_type]).reshape(1,5)))[0]

    return result

We need to add this code block to run the codes we wrote at the end of main.py.

if __name__ == '__main__':

    uvicorn.run("main:app", host="127.0.0.1", port=8000, reload=True)

Creating a web interface to the model created with Streamlit.

We are reading the csv file with the help of pandas, as we will use the data that we save the clean data in app.py.

df = pd.read_csv("../cleaned_car_data.csv")

Let’s add the codes that we will create the interface with the help of Streamlit.

def run():

    streamlit.title("Car Price Prediction")

    name = streamlit.selectbox("Cars Model", df.name.unique())

    company = streamlit.selectbox("Company Name", df.company.unique())

    year = streamlit.number_input("Year")

    kms_driven = streamlit.number_input("Kilometers driven")

    fuel_type = streamlit.selectbox("Fuel type", df.fuel_type.unique())

Let’s store the data we receive from the user through the interface in the “data” variable.

data = {

    'name': name,

    'company': company,

    'year': year,

    'kms_driven': kms_driven,

    'fuel_type': fuel_type,

    }

When the “Predict” button is clicked, we get results from our model using the API we created with the help of “request”.

if streamlit.button("Predict"):

    response = requests.post("http://127.0.0.1:8000/predict", json=data)

    prediction = response.text

    streamlit.success(f"The prediction from model: {prediction}")

We need to add this code block to run the codes we wrote at the end of app.py.

if __name__ == '__main__':

    run()

We can open our application by running the “streamlit run app.py” command in the file directory where app.py is located.

Let’s try it, will we be able to get the results we got on the notebook in the web application?

We will do cauterization with Docker so that the service we have created works on other systems.

Dockerize

Before that, we should not forget to create the requirements.txt file with the pipreqs ./ command on the console screen.

We need to add Dockerfile, It will expect a file at /app/main.py and will expect it to contain a variable app with your FastAPI application.

FROM tiangolo/uvicorn-gunicorn-fastapi:python3.7

COPY /app/requirements.txt /app/

RUN pip install -r /app/requirements.txt

COPY ./model /model/

COPY ./app /app

• Again on the console screen, “docker image build -t car-price .” We create docker images by running the command.
• We can see the image we created by running the “docker image ls” command.
• We will upload our container to Docker Hub to share the created container with the whole world. After creating a repository in Docker Hub, we tag it with the code “docker tag car-price username/car-price”.
• And finally, we push it to Docker Hub with the command “docker push username/car-price”. (This may take a long time) Then we can open Docker Hub and check that it has been pushed.

Project: https://github.com/furkankizilay/car-price-prediction

Hi everyone i’m : Furkan Kızılay

In this article, we will try to learn about the dataset by using pandas’ entry-level functions with a dataset containing the average temperature information of the countries. After that we will visualize the data using matplotlib and seaborn.

We will use a dataset containing the average temperature information of countries and cities. We will simply use pandas and visualize without questioning the accuracy of the data and without noisy data analysis, missing data analysis or outlier analysis.

Let’s Start

• First let import the pandas framework

import pandas as pd

But firstly what is pandas ?

Pandas is a fast, powerful, flexible and easy to use open source data analysis and manipulation tool.

• Let’s assign the dataset containing the city temperatures to the variable data using pandas.

data = pd.read_csv("city_temperature.csv")

• Let’s look at the first 5 observation units of the dataset.

data.head()

• head() defaultly show 5 observation unit, if you want to see more observation unit you can give the parameter.

Which type of data include this columns, let’s find out?

data.dtypes

• If you want to more information about dataset, you can use the info function.

data.info()

• info() show us the columns non-null count and the columns types, also how much memory used.

Keep to examine, possible to see the central distribution measures of the features with a single line of code.

data.describe().T

• The T at the end of the code means transpose.

How many observation units and columns are dataset, ı want to see this together.

data.shape

(2906327, 8)

Is there any null value in the dataset?

data.isnull()

That way it would be very difficult to see if there is any missing data, wouldn’t it? We can make this situation easy in a very simple way.

data.isnull().sum()

Upss, all data in the state column seems to be missing, let’s drop the column.

data.drop("State",axis = 1 ,inplace=True)
data.head()

• The drop method allows us to delete columns or indexes in the data set.
• If we set the axis parameter to 1, drop can delete columns, and the inplace parameter ensures that the change we make is permanent.

Let’s convert the object data type to the categorical data type.

columns = data.columns[0:3]
for i in columns :
    data[i] = pd.Categorical(data[i])
data.dtypes

Let’s explore the data frame further to answer some specific questions.

How many cities are in the dataset?

data["City"].nunique()

321

How many data do we have from each country in our dataset?

data["Country"].value_counts()

How many data do we have from some specific country?

len(data[data["Country"] == "US"])

1455337

What is the mean average temperature?

data["AvgTemperature"].mean()

56.004920781458054

What is the max average temperature?

data["AvgTemperature"].max()

110.0

Is it 110, I wonder where is this place, let’s find out.

data[data["AvgTemperature"] == data["AvgTemperature"].max()]

How many data are there for cities in any country we choose?

data[data["Country"].isin(["Turkey","Australia","US"])]["City"].value_counts()

This example will be a bit silly but we should learn to use functions too.

Let’s find the average temperature of countries with the letter F in them.

def re_find(f):
    if "f" in f.lower():
        return True
    return False

data[data["Country"].apply(re_find)]

So how do we find the average temperature on each continent? (groupby method will help us)

data.groupby(by = "Region").mean()["AvgTemperature"]

It may be more easy to see average temperatures on a graph rather than looking at a stack of numbers. Let’s do some visualization.

• We need to import matplotlib library to make visualization.

But firstly what is matplotlib?

Matplotlib is a comprehensive library for creating static, animated, and interactive visualizations in Python.

import matplotlib.pyplot as plt
%matplotlib inline
data.groupby(by = "Region").mean()["AvgTemperature"].plot(kind = "bar")

It’s easier to see which continent has more data this way.

It is possible to draw a graph where we can compare the average temperatures of the continents with each other. For this, we import the more advanced seaborn library, which is based on matplotlib.

import seaborn as sns
(sns
 .FacetGrid(data,
              hue= "Region",
              height = 5,
              xlim = (0,120))
 .map(sns.kdeplot,"AvgTemperature",shade = True)
 .add_legend()
);

What about comparison of average temperature by month?

plt.ylim(0, 120)
sns.boxplot(x = "Month", y = "AvgTemperature",data = data);

Since the values with an average temperature of -99 in the data set are evaluated incorrectly, we need to remove them from the data set.

data = data[~(data["AvgTemperature"] == -99)]
data.shape

(2826655, 8)

• The ~ statement filters out the observation units that satisfy the condition in the parenthesis to the right.

Let’s try to draw the density graphs of the 3 countries we have chosen in the same graph.

data_selected = data[data["Country"].isin(["China","France","US"])]
sns.set_style("whitegrid")
plt.figure(figsize=(15,5))
countries = data_selected["Country"].unique()

for country in countries :
    data = data_selected[data_selected["Country"]==country]["AvgTemperature"]
    sns.distplot(data)

plt.legend(countries)

What did we do?

• We examined the dataset using Pandas and tried to find the answers to the questions we asked to the dataset using Pandas.
• We visualized the data we obtained so that the data can be read and understood more easily.

The dataset:

https://www.kaggle.com/datasets/subhamjain/temperature-of-all-countries-19952020

Hi everyone i’m : Furkan Kızılay

Welcome to my blog, where I will write about my experiences while learning programming, and the topics that I think may be useful. In this blog, I will describe my experience of getting started with programming.

Where I Started Programming

Firstly, like everyone ı was did so many research about programming. As I researched, I realized how comprehensive programming is and that there are many different areas to improve myself.

The one common thread in every article I read about how to get started with programming was that programming should start with learning algorithm logic. So I started programming with learning algorithms, ı bought some algorithms books in my language and read some books. When i started learning something i didn’t have a computer so i could only learn theoretically.

Programming Language and English

After gaining knowledge of algorithms, I had to choose a programming language to learn. I decided to learn Python because it is easy to understand. I learned Python from books in my language again. After finish this book ı got some courses at Udemy. this courses were in my language again.

After finishing the book and completing the courses, I felt like I fell into a void because when I finished these I thought I could do anything with python. At the very least, I wanted to see something concrete that I could do with the knowledge I had learned.

I didn’t trust my English to learn anything. But I knew that if I’m going to be a programmer, I need to improve my English. I started to improve my English while learning programming.

Choosing Career Map

When I look back now, I think that I made a good start in programming, but perhaps I missed the most important detail and I had not determined my career path. I researched for a long time to determine my career path, I needed to find the most suitable one for me. As a result of my research, I became interested in deep learning, machine learning and data science, but as a person with a programming background of 3 months, I was afraid of the difficulty of the subjects I need to learn for AI, and I thought that it would be healthy to learn AI after I chose another field and improved my programming knowledge. (not exactly a good idea)

Since I wanted to see something concrete, I thought mobile development was the right career path for the moment. Since I don’t think it’s the right decision, I won’t dwell on it too much. First of all, I started learning Java (I’m glad I did, it helped me a lot at school), then I made simple application developments with Android Studio. Being aware of the fact that I need to learn on a cross platform, I took Flutter trainings and made application developments with Flutter. Before long, my interest in this field waned and I realized that I really did not want to further my career in this direction.

It was time to put my career path on the route I wanted to specialize in. After doing the longest and most comprehensive research I have done so far, I learned about data science, machine learning and deep learning, and I prepared a study plan.

This is how I started programming. In my next blogs, I will explain my data science and machine learning study plan, the resources I use and the route I follow.